ronin-support 0.4.1 → 0.5.2

data/spec/binary/hexdump/helpers/hexdumps/od_floats.txt

@@ -0,0 +1,17 @@
+0000000   3.8204714e-37   1.0082514e-34   2.6584628e-32    7.003653e-30
+0000020   1.8436203e-27    4.849422e-25    1.274669e-22    3.348188e-20
+0000040    8.789052e-18   2.3057262e-15    6.045325e-13   1.5841256e-10
+0000060    4.148859e-08   1.0860433e-05    0.0028415453      0.74312186
+0000100       194.25488       50757.266        13257032   3.4611722e+09
+0000120    9.033073e+11   2.3566197e+14    6.145978e+16   1.6023064e+19
+0000140   4.1759808e+21   1.0880146e+24    2.833864e+26   7.3789715e+28
+0000160   1.9208323e+31   4.9987784e+33   1.3005379e+36   3.3827546e+38
+0000200   -7.670445e-37  -2.0240553e-34    -5.33626e-32  -1.4056803e-29
+0000220  -3.6999117e-27   -9.731282e-25   -2.557642e-22  -6.7176346e-20
+0000240  -1.7632526e-17  -4.6253843e-15  -1.2126316e-12  -3.1773817e-10
+0000260   -8.321092e-08  -2.1780703e-05    -0.005698409      -1.4901652
+0000300      -389.51367      -101771.53       -26579856   -6.939187e+09
+0000320  -1.8109264e+12  -4.7242775e+14  -1.2320213e+17  -3.2118467e+19
+0000340  -8.3704803e+21    -2.18077e+24  -5.6798647e+26  -1.4789012e+29
+0000360  -3.8496183e+31 -1.00179184e+34  -2.6062884e+36            -nan
+0000400

data/spec/binary/hexdump/helpers/hexdumps/od_named_chars.txt

@@ -0,0 +1,17 @@
+0000000 nul soh stx etx eot enq ack bel  bs  ht  nl  vt  ff  cr  so  si
+0000020 dle dc1 dc2 dc3 dc4 nak syn etb can  em sub esc  fs  gs  rs  us
+0000040  sp   !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /
+0000060   0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
+0000100   @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
+0000120   P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
+0000140   `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
+0000160   p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~ del
+0000200 nul soh stx etx eot enq ack bel  bs  ht  nl  vt  ff  cr  so  si
+0000220 dle dc1 dc2 dc3 dc4 nak syn etb can  em sub esc  fs  gs  rs  us
+0000240  sp   !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /
+0000260   0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
+0000300   @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
+0000320   P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
+0000340   `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
+0000360   p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~ del
+0000400

data/spec/binary/hexdump/parser_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+require 'binary/hexdump/helpers/hexdumps'
+
+require 'ronin/binary/hexdump/parser'
+
+describe Binary::Hexdump::Parser do
+  include Helpers
+
+  context "GNU hexdump" do
+    let(:ascii) { load_binary_data('ascii') }
+    let(:repeated) { load_binary_data('repeated') }
+
+    context "octal bytes" do
+      subject do
+        described_class.new(:format => :hexdump, :encoding => :octal_bytes)
+      end
+
+      let(:hexdump) { load_hexdump('hexdump_octal_bytes') }
+
+      it "should unhexdump octal-byte hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context " hex bytes" do
+      subject do
+        described_class.new(:format => :hexdump, :encoding => :hex_bytes)
+      end
+
+      let(:hexdump) { load_hexdump('hexdump_hex_bytes') }
+
+      it "should unhexdump hex-byte hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "decimal shorts" do
+      subject do
+        described_class.new(:format => :hexdump, :encoding => :decimal_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('hexdump_decimal_shorts') }
+
+      it "should unhexdump decimal-short hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "octal shorts" do
+      subject do
+        described_class.new(:format => :hexdump, :encoding => :octal_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('hexdump_octal_shorts') }
+
+      it "should unhexdump octal-short hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "hex shorts" do
+      subject do
+        described_class.new(:format => :hexdump, :encoding => :hex_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('hexdump_hex_shorts') }
+
+      it "should unhexdump hex-short hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "repeated" do
+      subject do
+        described_class.new(:format => :hexdump, :encoding => :hex_bytes)
+      end
+
+      let(:hexdump) { load_hexdump('hexdump_repeated') }
+
+      it "should unhexdump repeated hexdump output" do
+        expect(subject.parse(hexdump)).to eq(repeated)
+      end
+    end
+  end
+
+  context "od" do
+    let(:ascii) { load_binary_data('ascii') }
+    let(:repeated) { load_binary_data('repeated') }
+
+    context "octal bytes" do
+      subject do
+        described_class.new(:format => :od, :encoding => :octal_bytes)
+      end
+
+      let(:hexdump) { load_hexdump('od_octal_bytes') }
+
+      it "should unhexdump octal-byte hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "octal shorts" do
+      subject do
+        described_class.new(:format => :od, :encoding => :octal_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('od_octal_shorts') }
+
+      it "should unhexdump octal-shorts hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "octal ints" do
+      subject do
+        described_class.new(:format => :od, :encoding => :octal_ints)
+      end
+
+      let(:hexdump) { load_hexdump('od_octal_ints') }
+
+      it "should unhexdump octal-ints hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    if RUBY_VERSION > '1.9.'
+      context "octal quads" do
+        subject do
+          described_class.new(:format => :od, :encoding => :octal_quads)
+        end
+
+        let(:hexdump) { load_hexdump('od_octal_quads') }
+
+        it "should unhexdump octal-quads hexdump output" do
+          expect(subject.parse(hexdump)).to eq(ascii)
+        end
+      end
+    end
+
+    context "decimal bytes" do
+      subject do
+        described_class.new(:format => :od, :encoding => :decimal_bytes)
+      end
+
+      let(:hexdump) { load_hexdump('od_decimal_bytes') }
+
+      it "should unhexdump decimal-byte hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "decimal shorts" do
+      subject do
+        described_class.new(:format => :od, :encoding => :decimal_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('od_decimal_shorts') }
+
+      it "should unhexdump decimal-shorts hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "decimal ints" do
+      subject do
+        described_class.new(:format => :od, :encoding => :decimal_ints)
+      end
+
+      let(:hexdump) { load_hexdump('od_decimal_ints') }
+
+      it "should unhexdump decimal-ints hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    if RUBY_VERSION > '1.9.'
+      context "decimal quads" do
+        subject do
+          described_class.new(:format => :od, :encoding => :decimal_quads)
+        end
+
+        let(:hexdump) { load_hexdump('od_decimal_quads') }
+
+        it "should unhexdump decimal-quads hexdump output" do
+          expect(subject.parse(hexdump)).to eq(ascii)
+        end
+      end
+    end
+
+    context "named chars" do
+      subject do
+        described_class.new(:format => :od, :encoding => :named_chars)
+      end
+
+      let(:mask)    { ~(1 << 7) }
+      let(:data)    { ascii.bytes.map { |b| (b & mask).chr }.join }
+      let(:hexdump) { load_hexdump('od_named_chars') }
+
+      it "should unhexdump named characters" do
+        expect(subject.parse(hexdump)).to eq(data)
+      end
+    end
+
+    context "hex bytes" do
+      subject do
+        described_class.new(:format => :od, :encoding => :hex_bytes)
+      end
+
+      let(:hexdump) { load_hexdump('od_hex_bytes') }
+
+      it "should unhexdump hex-byte hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "hex shorts" do
+      subject do
+        described_class.new(:format => :od, :encoding => :hex_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('od_hex_shorts') }
+
+      it "should unhexdump hex-shorts hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    context "hex ints" do
+      subject do
+        described_class.new(:format => :od, :encoding => :hex_ints)
+      end
+
+      let(:hexdump) { load_hexdump('od_hex_ints') }
+
+      it "should unhexdump hex-ints hexdump output" do
+        expect(subject.parse(hexdump)).to eq(ascii)
+      end
+    end
+
+    if RUBY_VERSION > '1.9.'
+      context "hex quads" do
+        subject do
+          described_class.new(:format => :od, :encoding => :hex_quads)
+        end
+
+        let(:hexdump) { load_hexdump('od_hex_quads') }
+
+        it "should unhexdump hex-quads hexdump output" do
+          expect(subject.parse(hexdump)).to eq(ascii)
+        end
+      end
+    end
+
+    context "floats" do
+      subject do
+        described_class.new(:format => :od, :encoding => :floats)
+      end
+
+      let(:data) do
+        data = ascii.dup
+        data[-4..-1] = ("\0" * 4)
+        data
+      end
+
+      let(:hexdump) { load_hexdump('od_floats') }
+
+      it "should unhexdump floats" do
+        expect(subject.parse(hexdump)).to eq(data)
+      end
+    end
+
+    context "doubles" do
+      subject do
+        described_class.new(:format => :od, :encoding => :doubles)
+      end
+
+      let(:data) do
+        data = ascii.dup
+        data[-8..-1] = ("\0" * 8)
+        data
+      end
+
+      let(:hexdump) { load_hexdump('od_doubles') }
+
+      it "should unhexdump doubles" do
+        expect(subject.parse(hexdump)).to eq(data)
+      end
+    end
+
+    context "repeated" do
+      subject do
+        described_class.new(:format => :od, :encoding => :octal_shorts)
+      end
+
+      let(:hexdump) { load_hexdump('od_repeated') }
+
+      it "should unhexdump repeated hexdump output" do
+        expect(subject.parse(hexdump)).to eq(repeated)
+      end
+    end
+  end
+end

data/spec/binary/struct_spec.rb

@@ -0,0 +1,496 @@
+require 'spec_helper'
+require 'ronin/binary/struct'
+
+describe Binary::Struct do
+  describe "layout" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        layout :x, :uint,
+               :y, :uint
+      end
+
+      struct.new
+    end
+
+    it "should return the layout" do
+      expect(subject.class.layout).to eq([
+        :x,
+        :y
+      ])
+    end
+
+    context "when given fields" do
+      it "should populate fields" do
+        expect(subject.class.fields).to eq({
+          :x => [:uint, nil],
+          :y => [:uint, nil]
+        })
+      end
+
+      it "should define reader methods" do
+        expect(subject).to respond_to(:x)
+        expect(subject).to respond_to(:y)
+      end
+
+      it "should define writer methods" do
+        expect(subject).to respond_to(:x=)
+        expect(subject).to respond_to(:y=)
+      end
+    end
+  end
+
+  describe "field?" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval { layout :x, :uint }
+      struct
+    end
+
+    it "should determine if fields exist" do
+      expect(subject.field?(:x)).to be(true)
+      expect(subject.field?(:foo)).to be(false)
+    end
+  end
+
+  describe "endian" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval { endian :little }
+      struct
+    end
+
+    it "should return the endianness of the Struct" do
+      expect(subject.endian).to eq(:little)
+    end
+
+    context "when given an argument" do
+      it "should set the endianness" do
+        subject.endian :big
+
+        expect(subject.endian).to eq(:big)
+      end
+    end
+  end
+
+  describe "typedefs" do
+  end
+
+  describe "typedef" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        typedef :uint32_t, :test_t
+      end
+
+      struct
+    end
+
+    it "should register a new type in typedefs" do
+      expect(subject.typedefs).to have_key(:test_t)
+    end
+
+    it "should resolve the existing type" do
+      expect(subject.typedefs[:test_t]).to eq(:uint32)
+    end
+  end
+
+  describe "#initialize" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        nested_struct = Class.new(Ronin::Binary::Struct)
+        nested_struct.class_eval do
+          layout :int, :uint
+        end
+
+        layout :int,          :uint,
+               :int_array,    [:uint, 2],
+               :float,        :float,
+               :float_array,  [:float, 2],
+               :char,         :char,
+               :char_array,   [:char, 2],
+               :string,       :string,
+               :struct,       nested_struct,
+               :struct_array, [nested_struct, 2]
+      end
+
+      struct.new
+    end
+
+    it "should set integers to 0" do
+      expect(subject[:int]).to eq(0)
+    end
+
+    it "should set arrays of integers to [0, ...]" do
+      expect(subject[:int_array]).to eq([0, 0])
+    end
+
+    it "should set floats to 0.0" do
+      expect(subject[:float]).to eq(0.0)
+    end
+
+    it "should set arrays of floats to [0.0, ...]" do
+      expect(subject[:float_array]).to eq([0.0, 0.0])
+    end
+
+    it "should set chars to '\\0'" do
+      expect(subject[:char]).to eq("\0")
+    end
+
+    it "should set arrays of chars to ''" do
+      expect(subject[:char_array]).to eq('')
+    end
+
+    it "should set strings to ''" do
+      expect(subject[:string]).to eq('')
+    end
+
+    it "should initialize nested structs" do
+      expect(subject[:struct][:int]).to eq(0)
+    end
+
+    it "should initialize arrays of nested structs" do
+      expect(subject[:struct_array][0][:int]).to eq(0)
+      expect(subject[:struct_array][1][:int]).to eq(0)
+    end
+  end
+
+  describe "#[]" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        layout :x, :uint,
+               :y, :uint
+      end
+
+      struct.new
+    end
+
+    before do
+      subject.instance_variable_set('@x',10)
+    end
+
+    it "should access the instance variable" do
+      expect(subject[:x]).to eq(10)
+    end
+
+    it "should still call the underlying reader method" do
+      expect(subject).to receive(:x).and_return(10)
+
+      subject[:x]
+    end
+
+    it "should raise ArgumentError for unknown fields" do
+      expect {
+        subject[:foo]
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#[]=" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        layout :x, :uint,
+               :y, :uint
+      end
+
+      struct.new
+    end
+
+    before do
+      subject.instance_variable_set('@x',0)
+    end
+
+    it "should set the underlying instance variable" do
+      subject[:x] = 20
+
+      expect(subject.instance_variable_get('@x')).to eq(20)
+    end
+
+    it "should still call the underlying writer method" do
+      expect(subject).to receive(:x=).with(20)
+
+      subject[:x] = 20
+    end
+
+    it "should raise ArgumentError for unknown fields" do
+      expect {
+        subject[:foo] = 20
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#values" do
+    let(:x) { 10 }
+    let(:y) { 20 }
+
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        layout :x, :uint,
+               :y, :uint
+      end
+
+      struct.new
+    end
+
+    before do
+      subject.x = x
+      subject.y = y
+    end
+
+    it "should return the values of the fields" do
+      expect(subject.values).to eq([x, y])
+    end
+
+    context "nested structs" do
+      let(:z) { 30 }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          nested_struct = Class.new(Ronin::Binary::Struct)
+          nested_struct.class_eval do
+            layout :int, :uint
+          end
+
+          layout :x, :uint,
+                 :y, :uint,
+                 :z, nested_struct
+        end
+
+        struct.new
+      end
+
+      before do
+        subject.z.int = z
+      end
+
+      it "should nest the values of nested structs" do
+        expect(subject.values).to eq([x, y, [z]])
+      end
+    end
+
+    context "arrays of nested structs" do
+      let(:z) { 30 }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          nested_struct = Class.new(Ronin::Binary::Struct)
+          nested_struct.class_eval do
+            layout :int, :uint
+          end
+
+          layout :x, :uint,
+                 :y, :uint,
+                 :z, [nested_struct, 2]
+        end
+
+        struct.new
+      end
+
+      before do
+        subject.z[0].int = z
+        subject.z[1].int = z
+      end
+
+      it "should nest the values of nested structs" do
+        expect(subject.values).to eq([x, y, [[z], [z]]])
+      end
+    end
+  end
+
+  describe "#clear" do
+    subject do
+      struct = Class.new(described_class)
+      struct.class_eval do
+        nested_struct = Class.new(Ronin::Binary::Struct)
+        nested_struct.class_eval do
+          layout :int, :int
+        end
+
+        layout :x, :uint,
+               :y, :float,
+               :z, nested_struct
+      end
+
+      struct.new
+    end
+
+    before do
+      subject.x = 100
+      subject.y = 15.0
+      subject.z.int = -1
+
+      subject.clear
+    end
+
+    it "should reset fields to their default values" do
+      expect(subject.x).to eq(0)
+      expect(subject.y).to eq(0.0)
+    end
+
+    it "should reinitialize nested structs" do
+      expect(subject.z.int).to eq(0)
+    end
+  end
+
+  describe "#pack" do
+    context "arrays of chars" do
+      let(:string) { "hello" }
+      let(:packed) { string.ljust(10,"\0") }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          layout :chars, [:char, 10]
+        end
+
+        struct.new
+      end
+
+      before do
+        subject.chars = string
+      end
+
+      it "should pack arrays of chars into a String" do
+        expect(subject.pack).to eq(packed)
+      end
+    end
+
+    context "structs" do
+      let(:packed) { "\x0a\x00\x14\x00\x00\x00" }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          nested_struct = Class.new(Ronin::Binary::Struct)
+          nested_struct.class_eval do
+            layout :int, :uint32_le
+          end
+
+          layout :int,    :uint16_le,
+                 :struct, nested_struct
+        end
+
+        struct.new
+      end
+
+      before do
+        subject.int = 10
+        subject.struct.int = 20
+      end
+
+      it "should pack the nested struct fields" do
+        expect(subject.pack).to eq(packed)
+      end
+    end
+
+    context "arrays of structs" do
+      let(:packed) { "\x0a\x00\x14\x00\x00\x00\x1e\x00\x00\x00" }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          nested_struct = Class.new(Ronin::Binary::Struct)
+          nested_struct.class_eval do
+            layout :int, :uint32_le
+          end
+
+          layout :int,    :uint16_le,
+                 :struct, [nested_struct, 2]
+        end
+
+        struct.new
+      end
+
+      before do
+        subject.int = 10
+        subject.struct[0].int = 20
+        subject.struct[1].int = 30
+      end
+
+      it "should pack the nested fields" do
+        expect(subject.pack).to eq(packed)
+      end
+    end
+  end
+
+  describe "#unpack" do
+    context "arrays of chars" do
+      let(:string) { "hello" }
+      let(:packed) { string.ljust(10,"\0") }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          layout :chars, [:char, 10]
+        end
+
+        struct.new
+      end
+
+      it "should unpack arrays of chars into a String" do
+        subject.unpack(packed)
+
+        expect(subject.chars).to eq(string)
+      end
+    end
+
+    context "structs" do
+      let(:packed) { "\x0a\x00\x14\x00\x00\x00" }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          nested_struct = Class.new(Ronin::Binary::Struct)
+          nested_struct.class_eval do
+            layout :int, :uint32_le
+          end
+
+          layout :int,    :uint16_le,
+                 :struct, nested_struct
+        end
+
+        struct.new
+      end
+
+      it "should unpack the nested struct fields" do
+        subject.unpack(packed)
+
+        expect(subject.int).to        eq(10)
+        expect(subject.struct.int).to eq(20)
+      end
+    end
+
+    context "arrays of structs" do
+      let(:packed) { "\x0a\x00\x14\x00\x00\x00\x1e\x00\x00\x00" }
+
+      subject do
+        struct = Class.new(described_class)
+        struct.class_eval do
+          nested_struct = Class.new(Ronin::Binary::Struct)
+          nested_struct.class_eval do
+            layout :int, :uint32_le
+          end
+
+          layout :int,    :uint16_le,
+                 :struct, [nested_struct, 2]
+        end
+
+        struct.new
+      end
+
+      it "should unpack the nested fields" do
+        subject.unpack(packed)
+        
+        expect(subject.int).to           eq(10)
+        expect(subject.struct[0].int).to eq(20)
+        expect(subject.struct[1].int).to eq(30)
+      end
+    end
+  end
+end