ronin-support 0.5.2 → 1.0.0.beta2

data/spec/binary/template_spec.rb

@@ -1,416 +0,0 @@
-# encoding: US-ASCII
-
-require 'spec_helper'
-require 'ronin/binary/template'
-
-describe Binary::Template do
-  describe "TYPES" do
-    subject { described_class::TYPES }
-
-    it("uint8      => C")  { expect(subject[:uint8]).to       eq('C' ) }
-    it("uint16     => S")  { expect(subject[:uint16]).to      eq('S' ) }
-    it("uint32     => L")  { expect(subject[:uint32]).to      eq('L' ) }
-    it("uint64     => Q")  { expect(subject[:uint64]).to      eq('Q' ) }
-    it("int8       => C")  { expect(subject[:int8]).to        eq('c' ) }
-    it("int16      => S")  { expect(subject[:int16]).to       eq('s' ) }
-    it("int32      => L")  { expect(subject[:int32]).to       eq('l' ) }
-    it("int64      => Q")  { expect(subject[:int64]).to       eq('q' ) }
-    if RUBY_VERSION < '1.9.'
-    it("uint16_le  => v")  { expect(subject[:uint16_le]).to   eq('v' ) }
-    it("uint32_le  => V")  { expect(subject[:uint32_le]).to   eq('V' ) }
-    it("uint16_be  => n")  { expect(subject[:uint16_be]).to   eq('n' ) }
-    it("uint32_be  => N")  { expect(subject[:uint32_be]).to   eq('N' ) }
-    end
-    it("uchar      => Z")  { expect(subject[:uchar]).to      eq('Z' ) }
-    it("ushort     => S!") { expect(subject[:ushort]).to     eq('S!') }
-    it("uint       => I!") { expect(subject[:uint]).to       eq('I!') }
-    it("ulong      => L!") { expect(subject[:ulong]).to      eq('L!') }
-    it("ulong_long => Q")  { expect(subject[:ulong_long]).to eq('Q' ) }
-    it("char       => Z")  { expect(subject[:char]).to       eq('Z' ) }
-    it("short      => s!") { expect(subject[:short]).to      eq('s!') }
-    it("int        => i!") { expect(subject[:int]).to        eq('i!') }
-    it("long       => l!") { expect(subject[:long]).to       eq('l!') }
-    it("long_long  => q")  { expect(subject[:long_long]).to  eq('q' ) }
-    it("utf8       => U")  { expect(subject[:utf8]).to       eq('U' ) }
-    it("float      => F")  { expect(subject[:float]).to       eq('F' ) }
-    it("double     => D")  { expect(subject[:double]).to      eq('D' ) }
-    it("float_le   => e")  { expect(subject[:float_le]).to    eq('e' ) }
-    it("double_le  => E")  { expect(subject[:double_le]).to   eq('E' ) }
-    it("float_be   => g")  { expect(subject[:float_be]).to    eq('g' ) }
-    it("double_ge  => G")  { expect(subject[:double_be]).to   eq('G' ) }
-    it("ubyte      => C")  { expect(subject[:ubyte]).to       eq('C' ) }
-    it("byte       => c")  { expect(subject[:byte]).to        eq('c' ) }
-    it("string     => Z*") { expect(subject[:string]).to     eq('Z*') }
-
-    if RUBY_VERSION > '1.9.'
-      context "Ruby 1.9" do
-        it("uint16_le     => S<") { expect(subject[:uint16_le]).to      eq('S<' ) }
-        it("uint32_le     => L<") { expect(subject[:uint32_le]).to      eq('L<' ) }
-        it("uint64_le     => Q<") { expect(subject[:uint64_le]).to      eq('Q<' ) }
-        it("int16_le      => S<") { expect(subject[:int16_le]).to       eq('s<' ) }
-        it("int32_le      => L<") { expect(subject[:int32_le]).to       eq('l<' ) }
-        it("int64_le      => Q<") { expect(subject[:int64_le]).to       eq('q<' ) }
-        it("uint16_be     => S>") { expect(subject[:uint16_be]).to      eq('S>' ) }
-        it("uint32_be     => L>") { expect(subject[:uint32_be]).to      eq('L>' ) }
-        it("uint64_be     => Q>") { expect(subject[:uint64_be]).to      eq('Q>' ) }
-        it("int16_be      => S>") { expect(subject[:int16_be]).to       eq('s>' ) }
-        it("int32_be      => L>") { expect(subject[:int32_be]).to       eq('l>' ) }
-        it("int64_be      => Q>") { expect(subject[:int64_be]).to       eq('q>' ) }
-        it("ushort_le     => S!<") { expect(subject[:ushort_le]).to     eq('S!<') }
-        it("uint_le       => I!<") { expect(subject[:uint_le]).to       eq('I!<') }
-        it("ulong_le      => L!<") { expect(subject[:ulong_le]).to      eq('L!<') }
-        it("ulong_long_le => L!<") { expect(subject[:ulong_long_le]).to eq('Q<' ) }
-        it("short_le      => S!<") { expect(subject[:short_le]).to      eq('s!<') }
-        it("int_le        => I!<") { expect(subject[:int_le]).to        eq('i!<') }
-        it("long_le       => L!<") { expect(subject[:long_le]).to       eq('l!<') }
-        it("long_long_le  => L!<") { expect(subject[:long_long_le]).to  eq('q<' ) }
-        it("ushort_be     => S!>") { expect(subject[:ushort_be]).to     eq('S!>') }
-        it("uint_be       => I!>") { expect(subject[:uint_be]).to       eq('I!>') }
-        it("ulong_be      => L!>") { expect(subject[:ulong_be]).to      eq('L!>') }
-        it("ulong_long_be => L!>") { expect(subject[:ulong_long_be]).to eq('Q>' ) }
-        it("short_be      => S!>") { expect(subject[:short_be]).to      eq('s!>') }
-        it("int_be        => I!>") { expect(subject[:int_be]).to        eq('i!>') }
-        it("long_be       => L!>") { expect(subject[:long_be]).to       eq('l!>') }
-        it("long_long_be  => L!>") { expect(subject[:long_long_be]).to  eq('q>' ) }
-      end
-    end
-  end
-
-  describe "translate" do
-    subject { described_class }
-
-    context "when given :endian" do
-      it "should translate endian-types" do
-        expect(subject.translate(:uint, :endian => :little)).to eq(:uint_le)
-      end
-
-      it "should not translate non-endian-types" do
-        expect(subject.translate(:string, :endian => :little)).to eq(:string)
-      end
-
-      it "should raise an ArgumentError for unknown endianness" do
-        expect {
-          subject.translate(:uint, :endian => :foo)
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "compile" do
-    let(:type) { :uint }
-    let(:code) { subject::TYPES[type] }
-
-    subject { described_class }
-
-    it "should translate types to their pack codes" do
-      expect(subject.compile([type])).to eq(code)
-    end
-
-    it "should support specifying the length of a field" do
-      expect(subject.compile([[type, 10]])).to eq("#{code}10")
-    end
-
-    it "should raise ArgumentError for unknown types" do
-      expect {
-        subject.compile([:foo])
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#initialize" do
-    subject { described_class.new [:uint32, :string] }
-
-    it "should store the types" do
-      expect(subject.fields).to eq([
-        :uint32,
-        :string
-      ])
-    end
-
-    it "should raise ArgumentError for unknown types" do
-      expect {
-        described_class.new [:foo]
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  ENDIANNESS = if [0x1234].pack('S') == "\x34\x12"
-                 :little
-               else
-                 :big
-               end
-
-  let(:byte) { 0x41 }
-  let(:char) { 'A' }
-
-  let(:bytes) { [104, 101, 108, 108, 111] }
-  let(:chars) { bytes.map(&:chr).join }
-  let(:string) { chars }
-
-  let(:uint8)  { 0xff }
-  let(:uint16) { 0xffff }
-  let(:uint32) { 0xffffffff }
-  let(:uint64) { 0xffffffffffffffff }
-
-  let(:int8)  { -1 }
-  let(:int16) { -1 }
-  let(:int32) { -1 }
-  let(:int32) { -1 }
-  let(:int64) { -1 }
-
-  describe "#pack" do
-    context ":byte" do
-      subject { described_class.new [:byte] }
-
-      it "should pack a signed byte" do
-        expect(subject.pack(byte)).to eq(char)
-      end
-    end
-
-    context "[:byte, n]" do
-      let(:n) { string.length }
-      subject { described_class.new [[:byte, n]] }
-
-      it "should pack multiple signed characters" do
-        expect(subject.pack(*bytes)).to eq(chars)
-      end
-    end
-
-    context ":char" do
-      subject { described_class.new [:char] }
-
-      it "should pack a signed character" do
-        expect(subject.pack(char)).to eq(char)
-      end
-    end
-
-    context "[:char, n]" do
-      let(:n) { string.length }
-      subject { described_class.new [[:char, n]] }
-
-      it "should pack multiple signed characters" do
-        expect(subject.pack(*chars)).to eq(string)
-      end
-
-      context "padding" do
-        let(:padding) { 10 }
-        subject { described_class.new [[:char, n + padding]] }
-
-        it "should pad the string with '\\0' characters" do
-          expect(subject.pack(*chars)).to eq((string + ("\0" * padding)))
-        end
-      end
-    end
-
-    context ":uint8" do
-      subject { described_class.new [:uint8] }
-
-      it "should pack an unsigned 8bit integer" do
-        expect(subject.pack(uint8)).to eq("\xff")
-      end
-    end
-
-    context ":uint16" do
-      subject { described_class.new [:uint16] }
-
-      it "should pack an unsigned 16bit integer" do
-        expect(subject.pack(uint16)).to eq("\xff\xff")
-      end
-    end
-
-    context ":uint32" do
-      subject { described_class.new [:uint32] }
-
-      it "should pack an unsigned 32bit integer" do
-        expect(subject.pack(uint32)).to eq("\xff\xff\xff\xff")
-      end
-    end
-
-    context ":uint64" do
-      subject { described_class.new [:uint64] }
-
-      it "should pack an unsigned 64bit integer" do
-        expect(subject.pack(uint64)).to eq("\xff\xff\xff\xff\xff\xff\xff\xff")
-      end
-    end
-
-    context ":int8" do
-      subject { described_class.new [:int8] }
-
-      it "should pack an signed 8bit integer" do
-        expect(subject.pack(int8)).to eq("\xff")
-      end
-    end
-
-    context ":int16" do
-      subject { described_class.new [:int16] }
-
-      it "should pack an unsigned 16bit integer" do
-        expect(subject.pack(int16)).to eq("\xff\xff")
-      end
-    end
-
-    context ":int32" do
-      subject { described_class.new [:int32] }
-
-      it "should pack an unsigned 32bit integer" do
-        expect(subject.pack(int32)).to eq("\xff\xff\xff\xff")
-      end
-    end
-
-    context ":int64" do
-      subject { described_class.new [:int64] }
-
-      it "should pack an unsigned 64bit integer" do
-        expect(subject.pack(int64)).to eq("\xff\xff\xff\xff\xff\xff\xff\xff")
-      end
-    end
-
-    context ":string" do
-      subject { described_class.new [:string] }
-
-      it "should pack a string" do
-        expect(subject.pack(string)).to eq("#{string}\0")
-      end
-    end
-  end
-
-  describe "#unpack" do
-    context ":byte" do
-      subject { described_class.new [:byte] }
-
-      it "should unpack a signed byte" do
-        expect(subject.unpack(char)).to eq([byte])
-      end
-    end
-
-    context "[:byte, n]" do
-      let(:n) { string.length }
-      subject { described_class.new [[:byte, n]] }
-
-      it "should pack multiple signed characters" do
-        expect(subject.unpack(chars)).to eq(bytes)
-      end
-    end
-
-    context ":char" do
-      subject { described_class.new [:char] }
-
-      it "should unpack a signed character" do
-        expect(subject.unpack(char)).to eq([char])
-      end
-    end
-
-    context "[:char, n]" do
-      let(:n) { string.length }
-      subject { described_class.new [[:char, n]] }
-
-      it "should unpack multiple signed characters" do
-        expect(subject.unpack(string)).to eq([chars])
-      end
-
-      context "padding" do
-        let(:padding) { 10 }
-        subject { described_class.new [[:char, n + padding]] }
-
-        it "should strip '\\0' padding characters" do
-          expect(subject.unpack(string + ("\0" * padding))).to eq([chars])
-        end
-      end
-    end
-
-    context ":uint8" do
-      subject { described_class.new [:uint8] }
-
-      it "should unpack an unsigned 8bit integer" do
-        expect(subject.unpack("\xff")).to eq([uint8])
-      end
-    end
-
-    context ":uint16" do
-      subject { described_class.new [:uint16] }
-
-      it "should unpack an unsigned 16bit integer" do
-        expect(subject.unpack("\xff\xff")).to eq([uint16])
-      end
-    end
-
-    context ":uint32" do
-      subject { described_class.new [:uint32] }
-
-      it "should unpack an unsigned 32bit integer" do
-        expect(subject.unpack("\xff\xff\xff\xff")).to eq([uint32])
-      end
-    end
-
-    context ":uint64" do
-      subject { described_class.new [:uint64] }
-
-      it "should unpack an unsigned 64bit integer" do
-        expect(subject.unpack("\xff\xff\xff\xff\xff\xff\xff\xff")).to eq([uint64])
-      end
-    end
-
-    context ":int8" do
-      subject { described_class.new [:int8] }
-
-      it "should unpack an signed 8bit integer" do
-        expect(subject.unpack("\xff")).to eq([int8])
-      end
-    end
-
-    context ":int16" do
-      subject { described_class.new [:int16] }
-
-      it "should unpack an unsigned 16bit integer" do
-        expect(subject.unpack("\xff\xff")).to eq([int16])
-      end
-    end
-
-    context ":int32" do
-      subject { described_class.new [:int32] }
-
-      it "should unpack an unsigned 32bit integer" do
-        expect(subject.unpack("\xff\xff\xff\xff")).to eq([int32])
-      end
-    end
-
-    context ":int64" do
-      subject { described_class.new [:int64] }
-
-      it "should unpack an unsigned 64bit integer" do
-        expect(subject.unpack("\xff\xff\xff\xff\xff\xff\xff\xff")).to eq([int64])
-      end
-    end
-
-    context ":string" do
-      subject { described_class.new [:string] }
-
-      it "should unpack a string" do
-        expect(subject.unpack("#{string}\0")).to eq([string])
-      end
-    end
-  end
-
-  describe "#to_s" do
-    subject { described_class.new [:uint32, :string] }
-
-    it "should return the pack format String" do
-      expect(subject.to_s).to eq("LZ*")
-    end
-  end
-
-  describe "#inspect" do
-    let(:template) { described_class.new [:uint32, :string] }
-
-    subject { template.inspect }
-
-    it "should inspect the class" do
-      expect(subject).to include(described_class.name)
-    end
-
-    it "should inspect the template" do
-      expect(subject).to include(template.fields.inspect)
-    end
-  end
-end

data/spec/extensions/enumerable_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/enumerable'
-
-describe Enumerable do
-  describe "#map_hash" do
-    it "should map elements to a Hash" do
-      expect([1, 2, 3].map_hash { |i| i ** 2 }).to eq({
-        1 => 1,
-        2 => 4,
-        3 => 9
-      })
-    end
-
-    it "should not map the same element twice" do
-      expect([1, 2, 2].map_hash { |i| rand }.keys).to match_array([1, 2])
-    end
-
-    it "should set the default_proc of the Hash" do
-      hash = [].map_hash { |i| i ** 2 }
-
-      expect(hash[3]).to eq(9)
-    end
-  end
-end

data/spec/extensions/file_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/file'
-
-require 'tempfile'
-
-describe File do
-  subject { File }
-
-  it "should provide File.escape_path" do
-    expect(subject).to respond_to(:escape_path)
-  end
-
-  describe "each_line" do
-    let(:lines) { %w[one two three] }
-    let(:path)  { Tempfile.new('ronin-support-File#each_line') }
-
-    before do
-      File.open(path,'w') { |file| file.puts(*lines) }
-    end
-
-    it "should enumerate over each line in the file" do
-      expect(File.each_line(path).to_a).to eq(lines)
-    end
-  end
-
-  describe "each_row" do
-    let(:rows) do
-      [
-        %w[one two three],
-        %w[four five six]
-      ]
-    end
-
-    let(:separator) { '|' }
-    let(:newline)   { "\r\n" }
-    let(:lines)     { rows.map { |row| row.join(separator) }.join(newline) }
-    let(:path)      { Tempfile.new('ronin-support-File#each_row') }
-
-    before do
-      File.open(path,'w') { |file| file.puts(*lines) }
-    end
-
-    it "should enumerate over each row from each line" do
-      expect(File.each_row(path,separator).to_a).to eq(rows)
-    end
-  end
-
-  describe "escape_path" do
-    it "should remove null-bytes" do
-      expect(File.escape_path("hello\0world\0")).to eq("helloworld")
-    end
-
-    it "should escape home-dir expansions" do
-      expect(File.escape_path("hello/~world")).to eq("hello/\\~world")
-    end
-
-    it "should remove '.' and '..' directories" do
-      expect(File.escape_path("hello/./../world")).to eq("world")
-    end
-  end
-end

data/spec/extensions/ip_addr_spec.rb

@@ -1,203 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/ip_addr'
-
-describe IPAddr do
-  describe "extract" do
-    context "IPv4" do
-      it "should extract a single IPv4 address" do
-        addr = '127.0.0.1'
-
-        expect(IPAddr.extract(addr,:ipv4)).to eq([addr])
-      end
-
-      it "should extract multiple IPv4 addresses" do
-        addrs = %w[127.0.0.1 192.168.0.1]
-        text = "#{addrs[0]} #{addrs[1]}"
-
-        expect(IPAddr.extract(text,:ipv4)).to eq(addrs)
-      end
-
-      it "should extract IPv4 addresses from text" do
-        addr = '127.0.0.1'
-        text = "ip (#{addr})"
-
-        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
-      end
-
-      it "should ignore leading periods" do
-        addr = '127.0.0.1'
-        text = ".#{addr}"
-
-        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
-      end
-
-      it "should ignore tailing periods" do
-        addr = '127.0.0.1'
-        text = "#{addr}."
-
-        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
-      end
-
-      it "should ignore less than 3 octet IPv4 addresses" do
-        text = '127.0.0. 1'
-
-        expect(IPAddr.extract(text,:ipv4)).to be_empty
-      end
-
-      it "should ignore IPv4 addresses with more than 3 diget octets" do
-        text = '127.1111.0.1'
-
-        expect(IPAddr.extract(text,:ipv4)).to be_empty
-      end
-    end
-
-    context "IPv6" do
-      it "should extract a single IPv6 address" do
-        addr = 'fe80:0000:0000:0000:0204:61ff:fe9d:f156'
-
-        expect(IPAddr.extract(addr,:ipv6)).to eq([addr])
-      end
-
-      it "should extract multiple IPv6 addresses" do
-        addrs = %w[::1 fe80:0000:0000:0000:0204:61ff:fe9d:f156]
-        text = "#{addrs[0]} #{addrs[1]}"
-
-        expect(IPAddr.extract(text,:ipv6)).to eq(addrs)
-      end
-
-      it "should extract collapsed IPv6 addresses" do
-        addr = 'fe80::0204:61ff:fe9d:f156'
-        text = "ipv6: #{addr}"
-
-        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
-      end
-
-      it "should extract IPv6 addresses from text" do
-        addr = 'fe80:0000:0000:0000:0204:61ff:fe9d:f156'
-        text = "hello #{addr} world"
-
-        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
-      end
-
-      it "should extract trailing IPv4 suffixes" do
-        addr = '::ffff:192.0.2.128'
-        text = "#{addr} 1.1.1.1"
-
-        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
-      end
-
-      it "should extract short-hand IPv6 addresses" do
-        addr = '::f0:0d'
-        text = "ipv6: #{addr}"
-
-        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
-      end
-    end
-
-    it "should extract both IPv4 and IPv6 addresses" do
-      ipv4 = '127.0.0.1'
-      ipv6 = '::1'
-      text = "ipv4: #{ipv4}, ipv6: #{ipv6}"
-
-      expect(IPAddr.extract(text)).to eq([ipv4, ipv6])
-    end
-
-    it "should ignore non-IP addresses" do
-      text = 'one: two.three.'
-
-      expect(IPAddr.extract(text)).to be_empty
-    end
-  end
-
-  describe "each" do
-    context "CIDR addresses" do
-      let(:fixed_addr) { IPAddr.new('10.1.1.2') }
-      let(:class_c) { IPAddr.new('10.1.1.2/24') }
-
-      it "should only iterate over one IP address for an address" do
-        addresses = fixed_addr.map { |ip| IPAddr.new(ip) }
-
-        expect(addresses.length).to eq(1)
-        expect(fixed_addr).to include(addresses.first)
-      end
-
-      it "should iterate over all IP addresses contained within the IP range" do
-        class_c.each do |ip|
-          expect(class_c).to include(IPAddr.new(ip))
-        end
-      end
-
-      it "should return an Enumerator when no block is given" do
-        expect(class_c.each.all? { |ip|
-          class_c.include?(IPAddr.new(ip))
-        }).to be(true)
-      end
-    end
-
-    context "globbed addresses" do
-      let(:ipv4_range) { '10.1.1-5.1' }
-      let(:ipv6_range) { '::ff::02-0a::c3' }
-
-      it "should expand '*' ranges" do
-        octets = IPAddr.each("10.1.1.*").map { |ip| ip.split('.',4).last }
-
-        expect(octets).to eq(('1'..'254').to_a)
-      end
-
-      it "should expend 'i-j' ranges" do
-        octets = IPAddr.each("10.1.1.10-20").map { |ip| ip.split('.',4).last }
-
-        expect(octets).to eq(('10'..'20').to_a)
-      end
-
-      it "should expand 'i,j,k' ranges" do
-        octets = IPAddr.each("10.1.1.1,2,3").map { |ip| ip.split('.',4).last }
-
-        expect(octets).to eq(['1', '2', '3'])
-      end
-
-      it "should expand combination 'i,j-k' ranges" do
-        octets = IPAddr.each("10.1.1.1,3-4").map { |ip| ip.split('.',4).last }
-
-        expect(octets).to eq(['1', '3', '4'])
-      end
-
-      it "should iterate over all IP addresses in an IPv4 range" do
-        IPAddr.each(ipv4_range) do |ip|
-          expect(ip).to match(/^10\.1\.[1-5]\.1$/)
-        end
-      end
-
-      it "should iterate over all IP addresses in an IPv6 range" do
-        IPAddr.each(ipv6_range) do |ip|
-          expect(ip).to match(/^::ff::0[2-9a]::c3$/)
-        end
-      end
-
-      it "should return an Enumerator when no block is given" do
-        ips = IPAddr.each(ipv4_range)
-
-        expect(ips.all? { |ip| ip =~ /^10\.1\.[1-5]\.1$/ }).to be(true)
-      end
-    end
-  end
-
-  let(:ip) { IPAddr.new('127.0.0.1') }
-  let(:bad_ip) { IPAddr.new('0.0.0.0') }
-
-  describe "#lookup", :network do
-    let(:nameserver) { '4.2.2.1' }
-
-    it "should lookup the host-name for an IP" do
-      expect(ip.lookup).to include('localhost')
-    end
-
-    it "may lookup host-names via other nameservers" do
-      expect(ip.lookup(nameserver)).to be_empty
-    end
-
-    it "should return an empty Array for unknown IP addresses" do
-      expect(bad_ip.lookup).to be_empty
-    end
-  end
-end