ronin-support 0.4.1 → 0.5.2

data/spec/formatting/binary/string_spec.rb

@@ -1,91 +1,120 @@
+# encoding: US-ASCII
+
 require 'spec_helper'
-require 'ronin/formatting/binary'
+require 'ronin/formatting/extensions/binary/string'
 
-require 'formatting/binary/helpers/hexdumps'
 require 'ostruct'
 
 describe String do
   subject { "hello" }
 
+  it "should provide String#unpack_original" do
+    expect(subject).to respond_to(:unpack_original)
+  end
+
+  it "should provide String#unpack" do
+    expect(subject).to respond_to(:unpack)
+  end
+
   it "should provide String#depack" do
-    should respond_to(:depack)
+    expect(subject).to respond_to(:depack)
   end
 
   it "should provide String#zlib_inflate" do
-    should respond_to(:zlib_inflate)
+    expect(subject).to respond_to(:zlib_inflate)
   end
 
   it "should provide String#zlib_deflate" do
-    should respond_to(:zlib_deflate)
+    expect(subject).to respond_to(:zlib_deflate)
   end
 
   it "should provide String#hex_unescape" do
-    should respond_to(:hex_unescape)
+    expect(subject).to respond_to(:hex_unescape)
   end
 
   it "should provide String#xor" do
-    should respond_to(:xor)
+    expect(subject).to respond_to(:xor)
   end
 
   it "should provide String#unhexdump" do
-    should respond_to(:unhexdump)
+    expect(subject).to respond_to(:unhexdump)
   end
 
-  describe "#depack" do
-    subject { 0x1337 }
+  describe "#unpack" do
+    subject { "\x34\x12\x00\x00hello\0" }
+
+    let(:data) { [0x1234, "hello"] }
 
-    let(:i386) do
-      OpenStruct.new(:endian => :little, :address_length => 4)
+    context "when given only a String" do
+      it "should unpack Strings using String#unpack template Strings" do
+        expect(subject.unpack('VZ*')).to eq(data)
+      end
     end
 
-    let(:ppc) do
-      OpenStruct.new(:endian => :big, :address_length => 4)
+    context "otherwise" do
+      it "should unpack Strings using Binary::Template" do
+        expect(subject.unpack(:uint32_le, :string)).to eq(data)
+      end
     end
+  end
 
-    let(:i386_packed_int)   { "7\023\000\000" }
-    let(:i386_packed_short) { "7\023" }
-    let(:i386_packed_long)  { "7\023\000\000" }
-    let(:i386_packed_quad)  { "7\023\000\000\000\000\000\000" }
+  context "deprecated" do
+    describe "#depack" do
+      subject { 0x1337 }
 
-    let(:ppc_packed_int)   { "\000\000\0237" }
-    let(:ppc_packed_short) { "\0237" }
-    let(:ppc_packed_long)  { "\000\000\0237" }
-    let(:ppc_packed_quad)  { "\000\000\000\000\000\000\0237" }
+      let(:i386) do
+        OpenStruct.new(:endian => :little, :address_length => 4)
+      end
 
-    it "should depack itself for a little-endian architecture" do
-      i386_packed_int.depack(i386).should == subject
-    end
+      let(:ppc) do
+        OpenStruct.new(:endian => :big, :address_length => 4)
+      end
 
-    it "should depack itself as a short for a little-endian architecture" do
-      i386_packed_short.depack(i386,2).should == subject
-    end
+      let(:i386_packed_int)   { "7\023\000\000" }
+      let(:i386_packed_short) { "7\023" }
+      let(:i386_packed_long)  { "7\023\000\000" }
+      let(:i386_packed_quad)  { "7\023\000\000\000\000\000\000" }
 
-    it "should depack itself as a long for a little-endian architecture" do
-      i386_packed_long.depack(i386,4).should == subject
-    end
+      let(:ppc_packed_int)   { "\000\000\0237" }
+      let(:ppc_packed_short) { "\0237" }
+      let(:ppc_packed_long)  { "\000\000\0237" }
+      let(:ppc_packed_quad)  { "\000\000\000\000\000\000\0237" }
 
-    it "should depack itself as a quad for a little-endian architecture" do
-      i386_packed_quad.depack(i386,8).should == subject
-    end
+      it "should depack itself for a little-endian architecture" do
+        expect(i386_packed_int.depack(i386)).to eq(subject)
+      end
 
-    it "should depack itself for a big-endian architecture" do
-      ppc_packed_int.depack(ppc).should == subject
-    end
+      it "should depack itself as a short for a little-endian architecture" do
+        expect(i386_packed_short.depack(i386,2)).to eq(subject)
+      end
 
-    it "should depack itself as a short for a big-endian architecture" do
-      ppc_packed_short.depack(ppc,2).should == subject
-    end
+      it "should depack itself as a long for a little-endian architecture" do
+        expect(i386_packed_long.depack(i386,4)).to eq(subject)
+      end
 
-    it "should depack itself as a long for a big-endian architecture" do
-      ppc_packed_long.depack(ppc,4).should == subject
-    end
+      it "should depack itself as a quad for a little-endian architecture" do
+        expect(i386_packed_quad.depack(i386,8)).to eq(subject)
+      end
 
-    it "should depack itself as a quad for a big-endian architecture" do
-      ppc_packed_quad.depack(ppc,8).should == subject
-    end
+      it "should depack itself for a big-endian architecture" do
+        expect(ppc_packed_int.depack(ppc)).to eq(subject)
+      end
 
-    it "should accept String#unpack template strings" do
-      i386_packed_long.depack('L').should == [subject]
+      it "should depack itself as a short for a big-endian architecture" do
+        expect(ppc_packed_short.depack(ppc,2)).to eq(subject)
+      end
+
+      it "should depack itself as a long for a big-endian architecture" do
+        expect(ppc_packed_long.depack(ppc,4)).to eq(subject)
+      end
+
+      it "should depack itself as a quad for a big-endian architecture" do
+        expect(ppc_packed_quad.depack(ppc,8)).to eq(subject)
+      end
+
+      it "should accept String#unpack template strings" do
+        expect(i386_packed_long.depack('V')).to eq([subject])
+      end
     end
   end
 
@@ -93,7 +122,7 @@ describe String do
     subject { "hello\0" }
 
     it "should base64 encode a String" do
-      subject.base64_encode.should == "aGVsbG8A\n"
+      expect(subject.base64_encode).to eq("aGVsbG8A\n")
     end
   end
 
@@ -101,7 +130,7 @@ describe String do
     subject { "aGVsbG8A\n" }
 
     it "should base64 decode a String" do
-      subject.base64_decode.should == "hello\0"
+      expect(subject.base64_decode).to eq("hello\0")
     end
   end
 
@@ -111,7 +140,7 @@ describe String do
     end
 
     it "should inflate a zlib deflated String" do
-      subject.zlib_inflate.should == "0f8f5ec6-14dc-46e7-a63a-f89b7d11265b\0"
+      expect(subject.zlib_inflate).to eq("0f8f5ec6-14dc-46e7-a63a-f89b7d11265b\0")
     end
   end
 
@@ -119,7 +148,7 @@ describe String do
     subject { "hello" }
 
     it "should zlib deflate a String" do
-      subject.zlib_deflate.should == "x\x9c\xcbH\xcd\xc9\xc9\a\0\x06,\x02\x15"
+      expect(subject.zlib_deflate).to eq("x\x9c\xcbH\xcd\xc9\xc9\a\0\x06,\x02\x15")
     end
   end
 
@@ -127,25 +156,7 @@ describe String do
     subject { "hello\x4e" }
 
     it "should hex escape a String" do
-      subject.hex_escape.should == "\\x68\\x65\\x6c\\x6c\\x6f\\x4e"
-    end
-  end
-
-  describe "#hex_unescape" do
-    it "should unescape a normal String" do
-      "hello".hex_unescape.should == "hello"
-    end
-
-    it "should unescape a hex String" do
-      "\\x68\\x65\\x6c\\x6c\\x6f\\x4e".hex_unescape.should == "hello\x4e"
-    end
-
-    it "should unescape an octal String" do
-      "hello\012".hex_unescape.should == "hello\n"
-    end
-
-    it "should unescape control characters" do
-      "hello\\n".hex_unescape.should == "hello\n"
+      expect(subject.hex_escape).to eq("\\x68\\x65\\x6c\\x6c\\x6f\\x4e")
     end
   end
 
@@ -156,151 +167,33 @@ describe String do
     let(:keys) { [0x50, 0x55] }
 
     it "should not contain the key used in the xor" do
-      should_not include(key.chr)
+      expect(subject).to_not include(key.chr)
     end
 
     it "should not equal the original string" do
-      subject.xor(key).should_not == subject
+      expect(subject.xor(key)).to_not be == subject
     end
 
     it "should be able to be decoded with another xor" do
-      subject.xor(key).xor(key).should == subject
+      expect(subject.xor(key).xor(key)).to eq(subject)
     end
 
     it "should allow xoring against a single key" do
-      subject.xor(key).should == "85<<?"
+      expect(subject.xor(key)).to eq("85<<?")
     end
 
     it "should allow xoring against multiple keys" do
-      subject.xor(keys).should == "80<9?"
+      expect(subject.xor(keys)).to eq("80<9?")
     end
   end
 
   describe "#unhexdump" do
-    include Helpers
-
-    context "GNU hexdump" do
-      let(:ascii) { load_binary_data('ascii') }
-      let(:repeated) { load_binary_data('repeated') }
-
-      it "should unhexdump octal-byte hexdump output" do
-        hexdump = load_hexdump('hexdump_octal_bytes')
-
-        hexdump.unhexdump(:format => :hexdump, :encoding => :octal_bytes).should == ascii
-      end
-
-      it "should unhexdump hex-byte hexdump output" do
-        hexdump = load_hexdump('hexdump_hex_bytes')
-
-        hexdump.unhexdump(:format => :hexdump, :encoding => :hex_bytes).should == ascii
-      end
-
-      it "should unhexdump decimal-short hexdump output" do
-        hexdump = load_hexdump('hexdump_decimal_shorts')
-
-        hexdump.unhexdump(:format => :hexdump, :encoding => :decimal_shorts).should == ascii
-      end
-
-      it "should unhexdump octal-short hexdump output" do
-        hexdump = load_hexdump('hexdump_octal_shorts')
-
-        hexdump.unhexdump(:format => :hexdump, :encoding => :octal_shorts).should == ascii
-      end
-
-      it "should unhexdump hex-short hexdump output" do
-        hexdump = load_hexdump('hexdump_hex_shorts')
-
-        hexdump.unhexdump(:format => :hexdump, :encoding => :hex_shorts).should == ascii
-      end
+    subject { "00000000  23 20 52 6f 6e 69 6e 20  53 75 70 70 6f 72 74 0a  |# Ronin Support.|\n00000010\n" }
 
-      it "should unhexdump repeated hexdump output" do
-        hexdump = load_hexdump('hexdump_repeated')
+    let(:raw) { "# Ronin Support\n" }
 
-        hexdump.unhexdump(:format => :hexdump, :encoding => :hex_bytes).should == repeated
-      end
-    end
-
-    context "od" do
-      let(:ascii) { load_binary_data('ascii') }
-      let(:repeated) { load_binary_data('repeated') }
-
-      it "should unhexdump octal-byte hexdump output" do
-        hexdump = load_hexdump('od_octal_bytes')
-
-        hexdump.unhexdump(:format => :od, :encoding => :octal_bytes).should == ascii
-      end
-
-      it "should unhexdump octal-shorts hexdump output" do
-        hexdump = load_hexdump('od_octal_shorts')
-
-        hexdump.unhexdump(:format => :od, :encoding => :octal_shorts).should == ascii
-      end
-
-      it "should unhexdump octal-ints hexdump output" do
-        hexdump = load_hexdump('od_octal_ints')
-
-        hexdump.unhexdump(:format => :od, :encoding => :octal_ints).should == ascii
-      end
-
-      it "should unhexdump octal-quads hexdump output" do
-        hexdump = load_hexdump('od_octal_quads')
-
-        hexdump.unhexdump(:format => :od, :encoding => :octal_quads).should == ascii
-      end
-
-      it "should unhexdump decimal-byte hexdump output" do
-        hexdump = load_hexdump('od_decimal_bytes')
-
-        hexdump.unhexdump(:format => :od, :encoding => :decimal_bytes).should == ascii
-      end
-
-      it "should unhexdump decimal-shorts hexdump output" do
-        hexdump = load_hexdump('od_decimal_shorts')
-
-        hexdump.unhexdump(:format => :od, :encoding => :decimal_shorts).should == ascii
-      end
-
-      it "should unhexdump decimal-ints hexdump output" do
-        hexdump = load_hexdump('od_decimal_ints')
-
-        hexdump.unhexdump(:format => :od, :encoding => :decimal_ints).should == ascii
-      end
-
-      it "should unhexdump decimal-quads hexdump output" do
-        hexdump = load_hexdump('od_decimal_quads')
-
-        hexdump.unhexdump(:format => :od, :encoding => :decimal_quads).should == ascii
-      end
-
-      it "should unhexdump hex-byte hexdump output" do
-        hexdump = load_hexdump('od_hex_bytes')
-
-        hexdump.unhexdump(:format => :od, :encoding => :hex_bytes).should == ascii
-      end
-
-      it "should unhexdump hex-shorts hexdump output" do
-        hexdump = load_hexdump('od_hex_shorts')
-
-        hexdump.unhexdump(:format => :od, :encoding => :hex_shorts).should == ascii
-      end
-
-      it "should unhexdump hex-ints hexdump output" do
-        hexdump = load_hexdump('od_hex_ints')
-
-        hexdump.unhexdump(:format => :od, :encoding => :hex_ints).should == ascii
-      end
-
-      it "should unhexdump hex-quads hexdump output" do
-        hexdump = load_hexdump('od_hex_quads')
-
-        hexdump.unhexdump(:format => :od, :encoding => :hex_quads).should == ascii
-      end
-
-      it "should unhexdump repeated hexdump output" do
-        hexdump = load_hexdump('od_repeated')
-
-        hexdump.unhexdump(:format => :od, :encoding => :octal_shorts).should == repeated
-      end
+    it "should unhexdump a String" do
+      expect(subject.unhexdump).to eq(raw)
     end
   end
 end

data/spec/formatting/digest/string_spec.rb

@@ -30,7 +30,7 @@ describe String do
     let(:digest_md5) { "098f6bcd4621d373cade4e832627b4f6" }
 
     it "should return the MD5 digest of itself" do
-      subject.md5.should == digest_md5
+      expect(subject.md5).to eq(digest_md5)
     end
   end
 
@@ -40,7 +40,7 @@ describe String do
     let(:digest_sha1) { "a94a8fe5ccb19ba61c4c0873d391e987982fbbd3" }
 
     it "should return the SHA1 digest of itself" do
-      subject.sha1.should == digest_sha1
+      expect(subject.sha1).to eq(digest_sha1)
     end
   end
 
@@ -52,7 +52,7 @@ describe String do
     end
 
     it "should return the SHA2 digest of itself" do
-      subject.sha2.should == digest_sha2
+      expect(subject.sha2).to eq(digest_sha2)
     end
   end
 
@@ -64,7 +64,7 @@ describe String do
     end
 
     it "should return the SHA256 digest of itself" do
-      subject.sha256.should == digest_sha256
+      expect(subject.sha256).to eq(digest_sha256)
     end
   end
 
@@ -76,7 +76,7 @@ describe String do
     end
 
     it "should return the SHA512 digest of itself" do
-      subject.sha512.should == digest_sha512
+      expect(subject.sha512).to eq(digest_sha512)
     end
   end
 end

data/spec/formatting/html/integer_spec.rb

@@ -24,7 +24,7 @@ describe Integer do
     let(:html_escaped) { "&" }
 
     it "should HTML escape itself" do
-      subject.html_escape.should == html_escaped
+      expect(subject.html_escape).to eq(html_escaped)
     end
   end
 
@@ -32,7 +32,7 @@ describe Integer do
     let(:formatted_html) { "&" }
 
     it "should HTML format all chars" do
-      subject.format_html.should == formatted_html
+      expect(subject.format_html).to eq(formatted_html)
     end
   end
 
@@ -44,11 +44,11 @@ describe Integer do
     let(:normal_char) { 'A' }
 
     it "should escape special JavaScript characters" do
-      special_byte.js_escape.should == escaped_special_byte
+      expect(special_byte.js_escape).to eq(escaped_special_byte)
     end
 
     it "should ignore normal characters" do
-      normal_byte.js_escape.should == normal_char
+      expect(normal_byte.js_escape).to eq(normal_char)
     end
   end
 
@@ -56,11 +56,11 @@ describe Integer do
     let(:js_escaped) { '\x26' }
 
     it "should JavaScript format ascii bytes" do
-      subject.format_js.should == js_escaped
+      expect(subject.format_js).to eq(js_escaped)
     end
 
     it "should JavaScript format unicode bytes" do
-      0xd556.format_js.should == '\uD556'
+      expect(0xd556.format_js).to eq('\uD556')
     end
   end
 end