pwntools 0.1.0

data/test/util/cyclic_test.rb

@@ -0,0 +1,36 @@
+# encoding: ASCII-8BIT
+
+require 'test_helper'
+require 'pwnlib/util/cyclic'
+
+class CyclicTest < MiniTest::Test
+  include ::Pwnlib::Util::Cyclic::ClassMethods
+
+  def test_cyclic
+    assert_equal('AAABAACABBABCACBACCBBBCBCCC', cyclic(alphabet: 'ABC', n: 3))
+    assert_equal('aaaabaaacaaadaaaeaaa', cyclic(20))
+    assert_equal(27_000, cyclic(alphabet: (0...30).to_a, n: 3).size)
+    assert_equal([1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 2, 2, 2],
+                 cyclic(alphabet: [1, 2], n: 4))
+  end
+
+  def test_cyclic_find
+    r = cyclic(1000)
+    10.times do
+      idx = rand(0...1000 - 4)
+      assert_equal(idx, cyclic_find(r[idx, 4]))
+    end
+
+    r = cyclic(1000)
+    10.times do
+      idx = rand(0...1000 - 5)
+      assert_equal(idx, cyclic_find(r[idx, 5], n: 4))
+    end
+
+    r = cyclic(1000, alphabet: (0...10).to_a)
+    10.times do
+      idx = rand(0...1000 - 4)
+      assert_equal(idx, cyclic_find(r[idx, 4], alphabet: (0...10).to_a))
+    end
+  end
+end

data/test/util/fiddling_test.rb

@@ -0,0 +1,106 @@
+# encoding: ASCII-8BIT
+
+require 'test_helper'
+require 'pwnlib/util/fiddling'
+
+class FiddlingTest < MiniTest::Test
+  include ::Pwnlib::Util::Fiddling::ClassMethods
+
+  def test_enhex
+    assert_equal('4141313233', enhex('AA123'))
+    assert_equal('74657374', enhex('test'))
+    assert_equal('122355ff4499', enhex("\x12\x23\x55\xff\x44\x99"))
+    assert_equal('21402324255e262a28295f2b5f29282a265e2524234040213f7b7d5d5b2f2f5c60607e',
+                 enhex('!@#$%^&*()_+_)(*&^%$#@@!?{}][//\``~'))
+  end
+
+  def test_unhex
+    assert_equal('AA123', unhex('4141313233'))
+    assert_equal('test', unhex('74657374'))
+    assert_equal("\x12\x23\x55\xff\x44\x99", unhex('122355ff4499'))
+    assert_equal('!@#$%^&*()_+_)(*&^%$#@@!?{}][//\``~',
+                 unhex('21402324255e262a28295f2b5f29282a265e2524234040213f7b7d5d5b2f2f5c60607e'))
+  end
+
+  def test_hex
+    assert_equal('0x0', hex(0))
+    assert_equal('0x64', hex(100))
+    assert_equal('-0xa', hex(-10))
+    assert_equal('0xfaceb00cdeadbeef', hex(0xfaceb00cdeadbeef))
+  end
+
+  def test_urlencode
+    assert_equal('%74%65%73%74%20%41', urlencode('test A'))
+    assert_equal('%00%ff%01%fe', urlencode("\x00\xff\x01\xfe"))
+  end
+
+  def test_urldecode
+    assert_equal('test A', urldecode('te%73t%20%41'))
+    assert_equal("\x00\xff\x01\xfe", urldecode('%00%ff%01%fe'))
+
+    assert_equal('%qq', urldecode('%qq', true))
+    err = assert_raises(ArgumentError) { urldecode('%qq') }
+    assert_match(/Invalid input to urldecode/, err.message)
+
+    assert_equal('%%1z2%orz%%%%%#$!#)@%', urldecode('%%1z2%orz%%%%%#$!#)@%', true))
+    err = assert_raises(ArgumentError) { urldecode('%ff%') }
+    assert_match(/Invalid input to urldecode/, err.message)
+  end
+
+  def test_bits
+    assert_equal(['+', '+', '+', '+', '+', '+', '+', '-', '-', '-', '-', '-', '-', '-', '-', '-'],
+                 bits(511, zero: '+', one: '-'))
+    assert_equal([0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0], bits('XD'))
+    assert_equal([0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0],
+                 bits('XD', endian: 'le'))
+    assert_equal([0, 0, 0, 0, 0, 0, 0, 0], bits(0))
+
+    err = assert_raises(ArgumentError) { bits(2.0) }
+    assert_match(/must be either String or Integer/, err.message)
+
+    err = assert_raises(ArgumentError) { bits(-1) }
+    assert_match(/must be non-negative/, err.message)
+  end
+
+  def test_bits_str
+    assert_equal('0000000111111111', bits_str(511))
+    assert_equal('0100011010010110001011101100111011111010110011100010111001001110',
+                 bits_str('bits_str', endian: 'little'))
+  end
+
+  def test_unbits
+    assert_equal("\x80", unbits([1]))
+    assert_equal("\x01", unbits([1], endian: 'le'))
+    assert_equal("\x16\xa666\xf6", unbits(bits('hello'), endian: 'le'))
+
+    err = assert_raises(ArgumentError) { unbits(%w(hi there)) }
+    assert_match(/cannot decode value/, err.message)
+
+    assert_equal("\xf0", unbits('11110000'))
+  end
+
+  def test_bitswap
+    assert_equal("\x8cL\xcc,", bitswap('1234'))
+  end
+
+  def test_bitswap_int
+    assert_equal(0x2c, bitswap_int(0x1234, bits: 8))
+    assert_equal(0x2c48, bitswap_int(0x1234, bits: 16))
+    assert_equal(0x2c4800, bitswap_int(0x1234, bits: 24))
+    assert_equal(0x589000, bitswap_int(0x1234, bits: 25))
+
+    context.local(bits: 36) do
+      assert_equal(0xf77db57b0, bitswap_int(0xdeadbeef))
+    end
+  end
+
+  def test_b64e
+    assert_equal('dGVzdA==', b64e('test'))
+    assert_equal('shik' * 100, b64e("\xb2\x18\xa4" * 100))
+  end
+
+  def test_b64d
+    assert_equal('test', b64d('dGVzdA=='))
+    assert_equal("\xb2\x18\xa4" * 100, b64d('shik' * 100))
+  end
+end

data/test/util/hexdump_test.rb

@@ -0,0 +1,179 @@
+require 'rainbow'
+
+require 'test_helper'
+require 'pwnlib/util/hexdump'
+
+class HexDumpTest < MiniTest::Test
+  include ::Pwnlib::Util::HexDump::ClassMethods
+
+  def setup
+    # Default to disable coloring for easier testing.
+    Rainbow.enabled = false
+  end
+
+  def assert_lines_equal(s1, s2)
+    s1l = s1.chomp.lines
+    s2l = s2.chomp.lines
+    assert_equal(s1l, s2l)
+  end
+
+  def test_hexdump_basic
+    assert_lines_equal(<<-'EOS', hexdump('A'))
+00000000  41                                                  │A│
+00000001
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('ABCD'))
+00000000  41 42 43 44                                         │ABCD│
+00000004
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('<3 Ruby :)'))
+00000000  3c 33 20 52  75 62 79 20  3a 29                     │<3 R│uby │:)│
+0000000a
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('><>><>><>><>><>><>>'))
+00000000  3e 3c 3e 3e  3c 3e 3e 3c  3e 3e 3c 3e  3e 3c 3e 3e  │><>>│<>><│>><>│><>>│
+00000010  3c 3e 3e                                            │<>>│
+00000013
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('ABCD' * 5))
+00000000  41 42 43 44  41 42 43 44  41 42 43 44  41 42 43 44  │ABCD│ABCD│ABCD│ABCD│
+00000010  41 42 43 44                                         │ABCD│
+00000014
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump((0..255).map(&:chr).join))
+00000000  00 01 02 03  04 05 06 07  08 09 0a 0b  0c 0d 0e 0f  │····│····│····│····│
+00000010  10 11 12 13  14 15 16 17  18 19 1a 1b  1c 1d 1e 1f  │····│····│····│····│
+00000020  20 21 22 23  24 25 26 27  28 29 2a 2b  2c 2d 2e 2f  │ !"#│$%&'│()*+│,-./│
+00000030  30 31 32 33  34 35 36 37  38 39 3a 3b  3c 3d 3e 3f  │0123│4567│89:;│<=>?│
+00000040  40 41 42 43  44 45 46 47  48 49 4a 4b  4c 4d 4e 4f  │@ABC│DEFG│HIJK│LMNO│
+00000050  50 51 52 53  54 55 56 57  58 59 5a 5b  5c 5d 5e 5f  │PQRS│TUVW│XYZ[│\]^_│
+00000060  60 61 62 63  64 65 66 67  68 69 6a 6b  6c 6d 6e 6f  │`abc│defg│hijk│lmno│
+00000070  70 71 72 73  74 75 76 77  78 79 7a 7b  7c 7d 7e 7f  │pqrs│tuvw│xyz{│|}~·│
+00000080  80 81 82 83  84 85 86 87  88 89 8a 8b  8c 8d 8e 8f  │····│····│····│····│
+00000090  90 91 92 93  94 95 96 97  98 99 9a 9b  9c 9d 9e 9f  │····│····│····│····│
+000000a0  a0 a1 a2 a3  a4 a5 a6 a7  a8 a9 aa ab  ac ad ae af  │····│····│····│····│
+000000b0  b0 b1 b2 b3  b4 b5 b6 b7  b8 b9 ba bb  bc bd be bf  │····│····│····│····│
+000000c0  c0 c1 c2 c3  c4 c5 c6 c7  c8 c9 ca cb  cc cd ce cf  │····│····│····│····│
+000000d0  d0 d1 d2 d3  d4 d5 d6 d7  d8 d9 da db  dc dd de df  │····│····│····│····│
+000000e0  e0 e1 e2 e3  e4 e5 e6 e7  e8 e9 ea eb  ec ed ee ef  │····│····│····│····│
+000000f0  f0 f1 f2 f3  f4 f5 f6 f7  f8 f9 fa fb  fc fd fe ff  │····│····│····│····│
+00000100
+    EOS
+  end
+
+  def test_hexdump_width
+    assert_lines_equal(<<-'EOS', hexdump('vert~', width: 1))
+00000000  76  │v│
+00000001  65  │e│
+00000002  72  │r│
+00000003  74  │t│
+00000004  7e  │~│
+00000005
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('~!@$%^&*()_+{}:"<>?', width: 13))
+00000000  7e 21 40 24  25 5e 26 2a  28 29 5f 2b  7b  │~!@$│%^&*│()_+│{│
+0000000d  7d 3a 22 3c  3e 3f                         │}:"<│>?│
+00000013
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('xoxoxoxo', width: 6))
+00000000  78 6f 78 6f  78 6f  │xoxo│xo│
+00000006  78 6f               │xo│
+00000008
+    EOS
+  end
+
+  def test_hexdump_skip
+    assert_lines_equal(<<-'EOS', hexdump('A' * 49))
+00000000  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  │AAAA│AAAA│AAAA│AAAA│
+*
+00000030  41                                                  │A│
+00000031
+    EOS
+    assert_lines_equal(<<-'EOS', hexdump('A' * 49, skip: false))
+00000000  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  │AAAA│AAAA│AAAA│AAAA│
+00000010  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  │AAAA│AAAA│AAAA│AAAA│
+00000020  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  │AAAA│AAAA│AAAA│AAAA│
+00000030  41                                                  │A│
+00000031
+    EOS
+  end
+
+  def test_offset
+    assert_lines_equal(<<-'EOS', hexdump('ELF' * 10, offset: 0x400000))
+00400000  45 4c 46 45  4c 46 45 4c  46 45 4c 46  45 4c 46 45  │ELFE│LFEL│FELF│ELFE│
+00400010  4c 46 45 4c  46 45 4c 46  45 4c 46 45  4c 46        │LFEL│FELF│ELFE│LF│
+0040001e
+    EOS
+  end
+
+  def test_style_byte
+    assert_lines_equal(
+      <<-'EOS',
+00000000  (3f) [21] 61 62  (3f) [21] 63 64                            │(?)[!]ab│(?)[!]cd│
+00000008
+      EOS
+      hexdump('?!ab?!cd', style: { 0x21 => ->(s) { "[#{s}]" }, 0x3f => ->(s) { "(#{s})" } })
+    )
+  end
+
+  def test_style_marker
+    assert_lines_equal(
+      <<-'EOS',
+00000000  74 65 73 74  74 65 73 74  74 65 73 74               │test☆test☆test│
+0000000c
+      EOS
+      hexdump('testtesttest', style: { marker: ->(_) { '☆' } })
+    )
+  end
+
+  def test_style_printable
+    assert_lines_equal(
+      <<-'EOS',
+00000000  14 15 92 [65]  [35] 89 [79]                               │···[e]│[5]·[y]│
+00000007
+      EOS
+      hexdump("\x14\x15\x92\x65\x35\x89\x79", style: { printable: ->(s) { "[#{s}]" } })
+    )
+  end
+
+  def test_style_unprintable
+    assert_lines_equal(
+      <<-'EOS',
+00000000  [14] [15] [92] 65  35 [89] 79                               │[·][·][·]e│5[·]y│
+00000007
+      EOS
+      hexdump("\x14\x15\x92\x65\x35\x89\x79", style: { unprintable: ->(s) { "[#{s}]" } })
+    )
+  end
+
+  def test_highlight
+    orig_verbose = $VERBOSE
+    orig_style = HIGHLIGHT_STYLE
+    begin
+      $VERBOSE = nil
+      ::Pwnlib::Util::HexDump::ClassMethods.const_set(:HIGHLIGHT_STYLE, ->(s) { "#{s}!" })
+      assert_lines_equal(<<-'EOS', hexdump('abcdefghi', highlight: 'aeiou'))
+00000000  61! 62 63 64  65! 66 67 68  69!                        │a!bcd│e!fgh│i!│
+00000009
+        EOS
+    ensure
+      ::Pwnlib::Util::HexDump::ClassMethods.const_set(:HIGHLIGHT_STYLE, orig_style)
+      $VERBOSE = orig_verbose
+    end
+  end
+
+  class QQStream
+    def read(n)
+      'Q' * n
+    end
+  end
+
+  def test_iterator_lazy
+    assert_equal(<<-'EOS'.lines.map(&:chomp), hexdump_iter(QQStream.new, skip: false).take(4))
+00000000  51 51 51 51  51 51 51 51  51 51 51 51  51 51 51 51  │QQQQ│QQQQ│QQQQ│QQQQ│
+00000010  51 51 51 51  51 51 51 51  51 51 51 51  51 51 51 51  │QQQQ│QQQQ│QQQQ│QQQQ│
+00000020  51 51 51 51  51 51 51 51  51 51 51 51  51 51 51 51  │QQQQ│QQQQ│QQQQ│QQQQ│
+00000030  51 51 51 51  51 51 51 51  51 51 51 51  51 51 51 51  │QQQQ│QQQQ│QQQQ│QQQQ│
+    EOS
+  end
+end

data/test/util/packing_test.rb

@@ -0,0 +1,168 @@
+# encoding: ASCII-8BIT
+
+require 'test_helper'
+require 'pwnlib/util/packing'
+
+class PackingTest < MiniTest::Test
+  include ::Pwnlib::Util::Packing::ClassMethods
+
+  def test_pack
+    assert_equal('ABC',
+                 pack(0x414243, bits: 24, endian: 'big', signed: true))
+    assert_equal('CBA',
+                 pack(0x414243, bits: 24, endian: 'little', signed: true))
+
+    assert_equal("\x81BC", pack(0x814243, bits: 24, endian: 'big', signed: false))
+    err = assert_raises(ArgumentError) do
+      pack(0x814243, bits: 23, endian: 'big', signed: false)
+    end
+    assert_match(/does not fit/, err.message)
+
+    assert_equal("\x00\x81BC", pack(0x814243, bits: 25, endian: 'big', signed: true))
+    err = assert_raises(ArgumentError) do
+      pack(0x814243, bits: 24, endian: 'big', signed: true)
+    end
+    assert_match(/does not fit/, err.message)
+
+    assert_equal("\xff", pack(-1, bits: 'all', endian: 'little', signed: true))
+    assert_equal("\xff\x00", pack(-256, bits: 'all', endian: 'big', signed: true))
+    assert_equal("\xde\xad\xbe\xef",
+                 pack(0xdeadbeef, bits: 'all', endian: 'big', signed: false))
+    assert_equal("\x05\x04\x03\x02\x01",
+                 pack(0x0102030405, bits: 'all', endian: 'little', signed: true))
+    assert_equal("\x00\x00\x00\x80\x00",
+                 pack(0x80000000, bits: 'all', endian: 'little', signed: true))
+
+    assert_equal('ABC', pack(0x414243, bits: 24, endian: 'big'))
+
+    err = assert_raises(ArgumentError) { pack(-514, bits: 'all', signed: 'unsigned') }
+    assert_match(/Can't pack negative number/, err.message)
+  end
+
+  def test_unpack
+    assert_equal(0x55aa,
+                 unpack("\xaa\x55", bits: 16, endian: 'little', signed: false))
+    assert_equal(0xaa55,
+                 unpack("\xaa\x55", bits: 16, endian: 'big', signed: false))
+    assert_equal(-0x55ab, unpack("\xaa\x55", bits: 16, endian: 'big', signed: true))
+    assert_equal(0x2a55, unpack("\xaa\x55", bits: 15, endian: 'big', signed: true))
+    assert_equal(0x0302ff,
+                 unpack("\xff\x02\x03", bits: 'all', endian: 'little', signed: true))
+    assert_equal(-0xfdfd, unpack("\xff\x02\x03", bits: 'all', endian: 'big', signed: true))
+    assert_equal(0x80000000,
+                 unpack("\x00\x00\x00\x80\x00", bits: 'all', endian: 'little', signed: true))
+
+    err = assert_raises(ArgumentError) do
+      unpack("\xff\xff", bits: 8, endian: 'big', signed: false)
+    end
+    assert_match(/does not match/, err.message)
+
+    assert_equal(0x414243, unpack('ABC', bits: 'all', endian: 'big', signed: false))
+  end
+
+  def test_unpack_many
+    assert_equal([0x55aa, 0x33cc],
+                 unpack_many("\xaa\x55\xcc\x33", bits: 16, endian: 'little', signed: false))
+    assert_equal([0xaa55, 0xcc33],
+                 unpack_many("\xaa\x55\xcc\x33", bits: 16, endian: 'big', signed: false))
+    assert_equal([-0x55ab, -0x33cd],
+                 unpack_many("\xaa\x55\xcc\x33", bits: 16, endian: 'big', signed: true))
+    assert_equal([0x0302ff],
+                 unpack_many("\xff\x02\x03", bits: 'all', endian: 'little', signed: true))
+    assert_equal([-0xfdfd],
+                 unpack_many("\xff\x02\x03", bits: 'all', endian: 'big', signed: true))
+
+    err = assert_raises(ArgumentError) { unpack_many('ABCD', bits: 12) }
+    assert_match(/bits must be a multiple of 8/, err.message)
+
+    err = assert_raises(ArgumentError) { unpack_many('ABC', bits: 16) }
+    assert_match(/must be a multiple of bytes/, err.message)
+
+    assert_equal([0x41, 0x42, 0x43, 0x44], unpack_many('ABCD', bits: 8))
+    assert_equal([0x4142, 0x4344],
+                 unpack_many('ABCD', bits: 16, endian: 'big', signed: 'signed'))
+    assert_equal([-2, -1],
+                 unpack_many("\xff\xfe\xff\xff", bits: 16, endian: 'big', signed: 'signed'))
+  end
+
+  def test_ps
+    assert_equal('A', p8(0x41))
+    assert_equal('BA', p16(0x4142))
+    assert_equal('DCBA', p32(0x41424344))
+    assert_equal('4321DCBA', p64(0x4142434431323334))
+
+    assert_equal('AB', p16(0x4142, endian: 'big'))
+    assert_equal('ABCD', p32(0x41424344, endian: 'big'))
+    assert_equal('ABCD1234', p64(0x4142434431323334, endian: 'big'))
+
+    assert_equal("\xff\xff\xff\xff", p32(-1))
+  end
+
+  def test_us
+    assert_equal(0x41, u8('A'))
+    assert_equal(0x4142, u16('BA'))
+    assert_equal(0x41424344, u32('DCBA'))
+    assert_equal(0x4142434431323334, u64('4321DCBA'))
+
+    assert_equal(0x4142, u16('AB', endian: 'big'))
+    assert_equal(0x41424344, u32('ABCD', endian: 'big'))
+    assert_equal(0x4142434431323334, u64('ABCD1234', endian: 'big'))
+
+    assert_equal(0xFFFFFFFF, u32("\xff\xff\xff\xff", signed: false))
+    assert_equal(-1, u32("\xff\xff\xff\xff", signed: true))
+  end
+
+  def test_up_rand
+    srand(217)
+    [8, 16, 32, 64].each do |sz|
+      u = ->(*x) { public_send("u#{sz}", *x) }
+      p = ->(*x) { public_send("p#{sz}", *x) }
+      100.times do
+        limit = (1 << sz)
+        val = rand(0...limit)
+        assert_equal(val, u[p[val, signed: false], signed: false])
+
+        limit = (1 << (sz - 1))
+        val = rand(-limit...limit)
+        assert_equal(val, u[p[val, signed: true], signed: true])
+
+        rs = Array.new(sz / 8) { rand(256).chr }.join
+        assert_equal(rs, p[u[rs, signed: false], signed: false])
+        assert_equal(rs, p[u[rs, signed: true], signed: true])
+      end
+    end
+  end
+
+  def test_make_packer
+    p = context.local(bits: 32, signed: 'no') { make_packer(endian: 'be') }
+    assert_equal("\x00\x00\x00A", p[0x41])
+
+    context.local(bits: 64, endian: 'le', signed: true) do
+      assert_equal("\x00\x00\x00A", p[0x41])
+    end
+
+    p = make_packer(bits: 24)
+    assert_equal("B\x00\x00", p[0x42])
+  end
+
+  def test_make_unpacker
+    u = context.local(bits: 32, signed: 'no') { make_unpacker(endian: 'be') }
+    assert_equal(0x41, u["\x00\x00\x00A"])
+
+    context.local(bits: 64, endian: 'le', signed: true) do
+      assert_equal(0x41, u["\x00\x00\x00A"])
+    end
+
+    u = make_unpacker(bits: 24)
+    assert_equal(0x42, u["B\x00\x00"])
+  end
+
+  def test_flat
+    assert_equal("\x01\x00testABABABABABAB",
+                 flat(1, 'test', [[['AB'] * 2] * 3], endian: 'le', bits: 16))
+    assert_equal('234', flat([1, [2, 3]]) { |x| (x + 1).to_s })
+
+    err = assert_raises(ArgumentError) { flat(1.23) }
+    assert_match(/flat does not support values of type/, err.message)
+  end
+end