ronin-support 0.5.1 → 1.0.0.beta1

data/spec/formatting/binary/array_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/binary/array'
-
-describe Array do
-  subject { [0x1234, "hello"] }
-
-  it "should provide Array#pack" do
-    should respond_to(:pack)
-  end
-
-  describe "#pack" do
-    let(:packed) { "\x34\x12hello\0" }
-
-    context "when only given a String" do
-      it "should pack elements using Array#pack codes" do
-        subject.pack('vZ*').should == packed
-      end
-    end
-
-    context "otherwise" do
-      it "should pack fields using Binary::Template" do
-        subject.pack(:uint16_le, :string).should == packed
-      end
-    end
-  end
-end

data/spec/formatting/binary/base64_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/binary/base64'
-
-describe Base64 do
-  subject { described_class }
-
-  if RUBY_VERSION < '1.9.'
-    let(:string) { '>' * 64 }
-
-    let(:base64) { "Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+\nPj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pg==\n" }
-    let(:strict_base64) { "Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pj4+Pg==" }
-    let(:urlsafe_base64) { "Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pj4-Pg==" }
-
-    describe "strict_encode64" do
-      it "should strictly encode a String" do
-        subject.strict_encode64(string).should == strict_base64
-      end
-    end
-
-    describe "strict_decode64" do
-      it "should strict decode an encoded Base64 String" do
-        subject.strict_decode64(strict_base64).should == string
-      end
-
-      it "should raise an ArgumentError for non-strictly encoded Base64" do
-        lambda {
-          subject.strict_decode64(base64)
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    describe "urlsafe_encode64" do
-      it "should encode URL-safe Base64 Strings" do
-        subject.urlsafe_encode64(string).should == urlsafe_base64
-      end
-    end
-
-    describe "urlsafe_decode64" do
-      it "should decode URL-safe Base64 String" do
-        subject.urlsafe_decode64(urlsafe_base64).should == string
-      end
-
-      it "should raise an ArgumentError for non-strictly encoded Base64" do
-        lambda {
-          subject.urlsafe_decode64(base64)
-        }.should raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/formatting/binary/float_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/binary/float'
-
-describe Float do
-  subject { 0.42 }
-
-  it "should provide Float#pack" do
-    should respond_to(:pack)
-  end
-
-  describe "#pack" do
-    let(:packed) { "\xE1z\x14\xAEG\xE1\xDA?" }
-
-    context "when only given a String" do
-      it "should unpack Strings using String#unpack template Strings" do
-        subject.pack('E').should == packed
-      end
-    end
-
-    context "when given a Binary::Template Float type" do
-      it "should unpack Strings using Binary::Template" do
-        subject.pack(:double_le).should == packed
-      end
-    end
-
-    context "when given non-Float Binary::Template types" do
-      it "should raise an ArgumentError" do
-        lambda {
-          subject.pack(:int)
-        }.should raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/formatting/binary/integer_spec.rb

@@ -1,166 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/binary/integer'
-
-require 'ostruct'
-
-describe Integer do
-  subject { 0x41 }
-
-  it "should provide Integer#bytes" do
-    should respond_to(:bytes)
-  end
-
-  it "should provide Integer#pack" do
-    should respond_to(:pack)
-  end
-
-  it "should provide Integer#hex_escape" do
-    should respond_to(:hex_escape)
-  end
-
-  it "should alias char to the #chr method" do
-    subject.char.should == subject.chr
-  end
-
-  describe "#hex_escape" do
-    subject { 42 }
-
-    it "should hex escape an Integer" do
-      subject.hex_escape.should == "\\x2a"
-    end
-  end
-
-  describe "#bytes" do
-    let(:little_endian_char)  { [0x37] }
-    let(:little_endian_short) { [0x37, 0x13] }
-    let(:little_endian_long)  { [0x37, 0x13, 0x0, 0x0] }
-    let(:little_endian_quad)  { [0x37, 0x13, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0] }
-
-    let(:big_endian_char)  { [0x37] }
-    let(:big_endian_short) { [0x13, 0x37] }
-    let(:big_endian_long)  { [0, 0, 0x13, 0x37] }
-    let(:big_endian_quad)  { [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x37] }
-
-    subject { 0x1337 }
-
-    it "should return the bytes in little endian ordering by default" do
-      subject.bytes(4).should == little_endian_long
-    end
-
-    it "should return the bytes for a char in little endian ordering" do
-      subject.bytes(1, :little).should == little_endian_char
-    end
-
-    it "should return the bytes for a short in little endian ordering" do
-      subject.bytes(2, :little).should == little_endian_short
-    end
-
-    it "should return the bytes for a long in little endian ordering" do
-      subject.bytes(4, :little).should == little_endian_long
-    end
-
-    it "should return the bytes for a quad in little endian ordering" do
-      subject.bytes(8, :little).should == little_endian_quad
-    end
-
-    it "should return the bytes for a char in big endian ordering" do
-      subject.bytes(1, :big).should == big_endian_char
-    end
-
-    it "should return the bytes for a short in big endian ordering" do
-      subject.bytes(2, :big).should == big_endian_short
-    end
-
-    it "should return the bytes for a long in big endian ordering" do
-      subject.bytes(4, :big).should == big_endian_long
-    end
-
-    it "should return the bytes for a quad in big endian ordering" do
-      subject.bytes(8, :big).should == big_endian_quad
-    end
-  end
-
-  describe "#pack" do
-    subject { 0x1337 }
-
-    let(:packed) { "7\023\000\000" }
-
-    context "when only given a String" do
-      it "should pack Integers using Array#pack codes" do
-        subject.pack('V').should == packed
-      end
-    end
-
-    context "when given a Binary::Template Integer type" do
-      it "should pack Integers using Binary::Template" do
-        subject.pack(:uint32_le).should == packed
-      end
-    end
-
-    context "when given non-Integer Binary::Template types" do
-      it "should raise an ArgumentError" do
-        lambda {
-          subject.pack(:float)
-        }.should raise_error(ArgumentError)
-      end
-    end
-
-    context "deprecated" do
-      let(:uint16_le) { "7\023" }
-      let(:uint32_le) { "7\023\000\000" }
-      let(:uint64_le) { "7\023\000\000\000\000\000\000" }
-
-      let(:uint16_be) { "\0237" }
-      let(:uint32_be) { "\000\000\0237" }
-      let(:uint64_be) { "\000\000\000\000\000\000\0237" }
-
-      let(:i386) do
-        OpenStruct.new(:endian => :little, :address_length => 4)
-      end
-
-      let(:ppc) do
-        OpenStruct.new(:endian => :big, :address_length => 4)
-      end
-
-      it "should pack itself for a little-endian architecture by default" do
-        subject.pack(i386).should == uint32_le
-      end
-
-      it "should pack itself as a short for a little-endian architecture" do
-        subject.pack(i386,2).should == uint16_le
-      end
-
-      it "should pack itself as a long for a little-endian architecture" do
-        subject.pack(i386,4).should == uint32_le
-      end
-
-      it "should pack itself as a quad for a little-endian architecture" do
-        subject.pack(i386,8).should == uint64_le
-      end
-
-      it "should pack itself for a big-endian architecture" do
-        subject.pack(ppc).should == uint32_be
-      end
-
-      it "should pack itself as a short for a big-endian architecture" do
-        subject.pack(ppc,2).should == uint16_be
-      end
-
-      it "should pack itself as a long for a big-endian architecture" do
-        subject.pack(ppc,4).should == uint32_be
-      end
-
-      it "should pack itself as a quad for a big-endian architecture" do
-        subject.pack(ppc,8).should == uint64_be
-      end
-    end
-
-    context "when given more than 1 or 2 arguments" do
-      it "should raise an ArgumentError" do
-        lambda {
-          subject.pack(1,2,3)
-        }.should raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/formatting/binary/string_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/binary/string'
-
-require 'ostruct'
-
-describe String do
-  subject { "hello" }
-
-  it "should provide String#unpack_original" do
-    should respond_to(:unpack_original)
-  end
-
-  it "should provide String#unpack" do
-    should respond_to(:unpack)
-  end
-
-  it "should provide String#depack" do
-    should respond_to(:depack)
-  end
-
-  it "should provide String#zlib_inflate" do
-    should respond_to(:zlib_inflate)
-  end
-
-  it "should provide String#zlib_deflate" do
-    should respond_to(:zlib_deflate)
-  end
-
-  it "should provide String#hex_unescape" do
-    should respond_to(:hex_unescape)
-  end
-
-  it "should provide String#xor" do
-    should respond_to(:xor)
-  end
-
-  it "should provide String#unhexdump" do
-    should respond_to(:unhexdump)
-  end
-
-  describe "#unpack" do
-    subject { "\x34\x12\x00\x00hello\0" }
-
-    let(:data) { [0x1234, "hello"] }
-
-    context "when given only a String" do
-      it "should unpack Strings using String#unpack template Strings" do
-        subject.unpack('VZ*').should == data
-      end
-    end
-
-    context "otherwise" do
-      it "should unpack Strings using Binary::Template" do
-        subject.unpack(:uint32_le, :string).should == data
-      end
-    end
-  end
-
-  context "deprecated" do
-    describe "#depack" do
-      subject { 0x1337 }
-
-      let(:i386) do
-        OpenStruct.new(:endian => :little, :address_length => 4)
-      end
-
-      let(:ppc) do
-        OpenStruct.new(:endian => :big, :address_length => 4)
-      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" }
-
-      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 for a little-endian architecture" do
-        i386_packed_int.depack(i386).should == subject
-      end
-
-      it "should depack itself as a short for a little-endian architecture" do
-        i386_packed_short.depack(i386,2).should == subject
-      end
-
-      it "should depack itself as a long for a little-endian architecture" do
-        i386_packed_long.depack(i386,4).should == subject
-      end
-
-      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 big-endian architecture" do
-        ppc_packed_int.depack(ppc).should == 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 big-endian architecture" do
-        ppc_packed_long.depack(ppc,4).should == 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 accept String#unpack template strings" do
-        i386_packed_long.depack('V').should == [subject]
-      end
-    end
-  end
-
-  describe "#base64_encode" do
-    subject { "hello\0" }
-
-    it "should base64 encode a String" do
-      subject.base64_encode.should == "aGVsbG8A\n"
-    end
-  end
-
-  describe "#base64_decode" do
-    subject { "aGVsbG8A\n" }
-
-    it "should base64 decode a String" do
-      subject.base64_decode.should == "hello\0"
-    end
-  end
-
-  describe "#zlib_inflate" do
-    subject do
-      "x\xda3H\xb3H3MM6\xd354II\xd651K5\xd7M43N\xd4M\xb3\xb0L2O14423Mb\0\0\xc02\t\xae"
-    end
-
-    it "should inflate a zlib deflated String" do
-      subject.zlib_inflate.should == "0f8f5ec6-14dc-46e7-a63a-f89b7d11265b\0"
-    end
-  end
-
-  describe "#zlib_deflate" 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"
-    end
-  end
-
-  describe "#hex_escape" do
-    subject { "hello\x4e" }
-
-    it "should hex escape a String" do
-      subject.hex_escape.should == "\\x68\\x65\\x6c\\x6c\\x6f\\x4e"
-    end
-  end
-
-  describe "#xor" do
-    subject { 'hello' }
-
-    let(:key) { 0x50 }
-    let(:keys) { [0x50, 0x55] }
-
-    it "should not contain the key used in the xor" do
-      should_not include(key.chr)
-    end
-
-    it "should not equal the original string" do
-      subject.xor(key).should_not == subject
-    end
-
-    it "should be able to be decoded with another xor" do
-      subject.xor(key).xor(key).should == subject
-    end
-
-    it "should allow xoring against a single key" do
-      subject.xor(key).should == "85<<?"
-    end
-
-    it "should allow xoring against multiple keys" do
-      subject.xor(keys).should == "80<9?"
-    end
-  end
-
-  describe "#unhexdump" do
-    subject { "00000000  23 20 52 6f 6e 69 6e 20  53 75 70 70 6f 72 74 0a  |# Ronin Support.|\n00000010\n" }
-
-    let(:raw) { "# Ronin Support\n" }
-
-    it "should unhexdump a String" do
-      subject.unhexdump.should == raw
-    end
-  end
-end

data/spec/formatting/digest/string_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/digest'
-
-describe String do
-  subject { "hello" }
-
-  it "should provide String#md5" do
-    should respond_to(:md5)
-  end
-
-  it "should provide String#sha1" do
-    should respond_to(:sha1)
-  end
-
-  it "should provide String#sha2" do
-    should respond_to(:sha2)
-  end
-
-  it "should provide String#sha256" do
-    should respond_to(:sha256)
-  end
-
-  it "should provide String#sha512" do
-    should respond_to(:sha512)
-  end
-
-  describe "#md5" do
-    subject { "test" }
-
-    let(:digest_md5) { "098f6bcd4621d373cade4e832627b4f6" }
-
-    it "should return the MD5 digest of itself" do
-      subject.md5.should == digest_md5
-    end
-  end
-
-  describe "#sha1" do
-    subject { "test" }
-
-    let(:digest_sha1) { "a94a8fe5ccb19ba61c4c0873d391e987982fbbd3" }
-
-    it "should return the SHA1 digest of itself" do
-      subject.sha1.should == digest_sha1
-    end
-  end
-
-  describe "#sha2" do
-    subject { "test" }
-
-    let(:digest_sha2) do
-      "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
-    end
-
-    it "should return the SHA2 digest of itself" do
-      subject.sha2.should == digest_sha2
-    end
-  end
-
-  describe "#sha256" do
-    subject { "test" }
-
-    let(:digest_sha256) do
-      "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
-    end
-
-    it "should return the SHA256 digest of itself" do
-      subject.sha256.should == digest_sha256
-    end
-  end
-
-  describe "#sha512" do
-    subject { "test" }
-
-    let(:digest_sha512) do
-      "ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff"
-    end
-
-    it "should return the SHA512 digest of itself" do
-      subject.sha512.should == digest_sha512
-    end
-  end
-end

data/spec/formatting/html/integer_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/html/integer'
-
-describe Integer do
-  subject { 0x26 }
-
-  it "should provide String#html_escape" do
-    should respond_to(:html_escape)
-  end
-
-  it "should provide String#format_html" do
-    should respond_to(:format_html)
-  end
-
-  it "should provide String#js_escape" do
-    should respond_to(:js_escape)
-  end
-
-  it "should provide String#format_js" do
-    should respond_to(:format_js)
-  end
-
-  describe "#html_escape" do
-    let(:html_escaped) { "&" }
-
-    it "should HTML escape itself" do
-      subject.html_escape.should == html_escaped
-    end
-  end
-
-  describe "#format_html" do
-    let(:formatted_html) { "&" }
-
-    it "should HTML format all chars" do
-      subject.format_html.should == formatted_html
-    end
-  end
-
-  describe "#js_escape" do
-    let(:special_byte) { 0x0a }
-    let(:escaped_special_byte) { '\n' }
-
-    let(:normal_byte) { 0x41 }
-    let(:normal_char) { 'A' }
-
-    it "should escape special JavaScript characters" do
-      special_byte.js_escape.should == escaped_special_byte
-    end
-
-    it "should ignore normal characters" do
-      normal_byte.js_escape.should == normal_char
-    end
-  end
-
-  describe "#format_js" do
-    let(:js_escaped) { '\x26' }
-
-    it "should JavaScript format ascii bytes" do
-      subject.format_js.should == js_escaped
-    end
-
-    it "should JavaScript format unicode bytes" do
-      0xd556.format_js.should == '\uD556'
-    end
-  end
-end