ronin-support 0.5.2 → 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
-        expect(subject.pack('vZ*')).to eq(packed)
-      end
-    end
-
-    context "otherwise" do
-      it "should pack fields using Binary::Template" do
-        expect(subject.pack(:uint16_le, :string)).to eq(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
-        expect(subject.strict_encode64(string)).to eq(strict_base64)
-      end
-    end
-
-    describe "strict_decode64" do
-      it "should strict decode an encoded Base64 String" do
-        expect(subject.strict_decode64(strict_base64)).to eq(string)
-      end
-
-      it "should raise an ArgumentError for non-strictly encoded Base64" do
-        expect {
-          subject.strict_decode64(base64)
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    describe "urlsafe_encode64" do
-      it "should encode URL-safe Base64 Strings" do
-        expect(subject.urlsafe_encode64(string)).to eq(urlsafe_base64)
-      end
-    end
-
-    describe "urlsafe_decode64" do
-      it "should decode URL-safe Base64 String" do
-        expect(subject.urlsafe_decode64(urlsafe_base64)).to eq(string)
-      end
-
-      it "should raise an ArgumentError for non-strictly encoded Base64" do
-        expect {
-          subject.urlsafe_decode64(base64)
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/formatting/binary/float_spec.rb

@@ -1,36 +0,0 @@
-# encoding: US-ASCII
-
-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
-        expect(subject.pack('E')).to eq(packed)
-      end
-    end
-
-    context "when given a Binary::Template Float type" do
-      it "should unpack Strings using Binary::Template" do
-        expect(subject.pack(:double_le)).to eq(packed)
-      end
-    end
-
-    context "when given non-Float Binary::Template types" do
-      it "should raise an ArgumentError" do
-        expect {
-          subject.pack(:int)
-        }.to 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
-    expect(subject.char).to eq(subject.chr)
-  end
-
-  describe "#hex_escape" do
-    subject { 42 }
-
-    it "should hex escape an Integer" do
-      expect(subject.hex_escape).to eq("\\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
-      expect(subject.bytes(4)).to eq(little_endian_long)
-    end
-
-    it "should return the bytes for a char in little endian ordering" do
-      expect(subject.bytes(1, :little)).to eq(little_endian_char)
-    end
-
-    it "should return the bytes for a short in little endian ordering" do
-      expect(subject.bytes(2, :little)).to eq(little_endian_short)
-    end
-
-    it "should return the bytes for a long in little endian ordering" do
-      expect(subject.bytes(4, :little)).to eq(little_endian_long)
-    end
-
-    it "should return the bytes for a quad in little endian ordering" do
-      expect(subject.bytes(8, :little)).to eq(little_endian_quad)
-    end
-
-    it "should return the bytes for a char in big endian ordering" do
-      expect(subject.bytes(1, :big)).to eq(big_endian_char)
-    end
-
-    it "should return the bytes for a short in big endian ordering" do
-      expect(subject.bytes(2, :big)).to eq(big_endian_short)
-    end
-
-    it "should return the bytes for a long in big endian ordering" do
-      expect(subject.bytes(4, :big)).to eq(big_endian_long)
-    end
-
-    it "should return the bytes for a quad in big endian ordering" do
-      expect(subject.bytes(8, :big)).to eq(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
-        expect(subject.pack('V')).to eq(packed)
-      end
-    end
-
-    context "when given a Binary::Template Integer type" do
-      it "should pack Integers using Binary::Template" do
-        expect(subject.pack(:uint32_le)).to eq(packed)
-      end
-    end
-
-    context "when given non-Integer Binary::Template types" do
-      it "should raise an ArgumentError" do
-        expect {
-          subject.pack(:float)
-        }.to 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
-        expect(subject.pack(i386)).to eq(uint32_le)
-      end
-
-      it "should pack itself as a short for a little-endian architecture" do
-        expect(subject.pack(i386,2)).to eq(uint16_le)
-      end
-
-      it "should pack itself as a long for a little-endian architecture" do
-        expect(subject.pack(i386,4)).to eq(uint32_le)
-      end
-
-      it "should pack itself as a quad for a little-endian architecture" do
-        expect(subject.pack(i386,8)).to eq(uint64_le)
-      end
-
-      it "should pack itself for a big-endian architecture" do
-        expect(subject.pack(ppc)).to eq(uint32_be)
-      end
-
-      it "should pack itself as a short for a big-endian architecture" do
-        expect(subject.pack(ppc,2)).to eq(uint16_be)
-      end
-
-      it "should pack itself as a long for a big-endian architecture" do
-        expect(subject.pack(ppc,4)).to eq(uint32_be)
-      end
-
-      it "should pack itself as a quad for a big-endian architecture" do
-        expect(subject.pack(ppc,8)).to eq(uint64_be)
-      end
-    end
-
-    context "when given more than 1 or 2 arguments" do
-      it "should raise an ArgumentError" do
-        expect {
-          subject.pack(1,2,3)
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/formatting/binary/string_spec.rb

@@ -1,199 +0,0 @@
-# encoding: US-ASCII
-
-require 'spec_helper'
-require 'ronin/formatting/extensions/binary/string'
-
-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
-    expect(subject).to respond_to(:depack)
-  end
-
-  it "should provide String#zlib_inflate" do
-    expect(subject).to respond_to(:zlib_inflate)
-  end
-
-  it "should provide String#zlib_deflate" do
-    expect(subject).to respond_to(:zlib_deflate)
-  end
-
-  it "should provide String#hex_unescape" do
-    expect(subject).to respond_to(:hex_unescape)
-  end
-
-  it "should provide String#xor" do
-    expect(subject).to respond_to(:xor)
-  end
-
-  it "should provide String#unhexdump" do
-    expect(subject).to 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
-        expect(subject.unpack('VZ*')).to eq(data)
-      end
-    end
-
-    context "otherwise" do
-      it "should unpack Strings using Binary::Template" do
-        expect(subject.unpack(:uint32_le, :string)).to eq(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
-        expect(i386_packed_int.depack(i386)).to eq(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 long for a little-endian architecture" do
-        expect(i386_packed_long.depack(i386,4)).to eq(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 for a big-endian architecture" do
-        expect(ppc_packed_int.depack(ppc)).to eq(subject)
-      end
-
-      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
-
-  describe "#base64_encode" do
-    subject { "hello\0" }
-
-    it "should base64 encode a String" do
-      expect(subject.base64_encode).to eq("aGVsbG8A\n")
-    end
-  end
-
-  describe "#base64_decode" do
-    subject { "aGVsbG8A\n" }
-
-    it "should base64 decode a String" do
-      expect(subject.base64_decode).to eq("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
-      expect(subject.zlib_inflate).to eq("0f8f5ec6-14dc-46e7-a63a-f89b7d11265b\0")
-    end
-  end
-
-  describe "#zlib_deflate" do
-    subject { "hello" }
-
-    it "should zlib deflate a String" do
-      expect(subject.zlib_deflate).to eq("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
-      expect(subject.hex_escape).to eq("\\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
-      expect(subject).to_not include(key.chr)
-    end
-
-    it "should not equal the original string" do
-      expect(subject.xor(key)).to_not be == subject
-    end
-
-    it "should be able to be decoded with another xor" do
-      expect(subject.xor(key).xor(key)).to eq(subject)
-    end
-
-    it "should allow xoring against a single key" do
-      expect(subject.xor(key)).to eq("85<<?")
-    end
-
-    it "should allow xoring against multiple keys" do
-      expect(subject.xor(keys)).to eq("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
-      expect(subject.unhexdump).to eq(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
-      expect(subject.md5).to eq(digest_md5)
-    end
-  end
-
-  describe "#sha1" do
-    subject { "test" }
-
-    let(:digest_sha1) { "a94a8fe5ccb19ba61c4c0873d391e987982fbbd3" }
-
-    it "should return the SHA1 digest of itself" do
-      expect(subject.sha1).to eq(digest_sha1)
-    end
-  end
-
-  describe "#sha2" do
-    subject { "test" }
-
-    let(:digest_sha2) do
-      "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
-    end
-
-    it "should return the SHA2 digest of itself" do
-      expect(subject.sha2).to eq(digest_sha2)
-    end
-  end
-
-  describe "#sha256" do
-    subject { "test" }
-
-    let(:digest_sha256) do
-      "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
-    end
-
-    it "should return the SHA256 digest of itself" do
-      expect(subject.sha256).to eq(digest_sha256)
-    end
-  end
-
-  describe "#sha512" do
-    subject { "test" }
-
-    let(:digest_sha512) do
-      "ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff"
-    end
-
-    it "should return the SHA512 digest of itself" do
-      expect(subject.sha512).to eq(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
-      expect(subject.html_escape).to eq(html_escaped)
-    end
-  end
-
-  describe "#format_html" do
-    let(:formatted_html) { "&" }
-
-    it "should HTML format all chars" do
-      expect(subject.format_html).to eq(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
-      expect(special_byte.js_escape).to eq(escaped_special_byte)
-    end
-
-    it "should ignore normal characters" do
-      expect(normal_byte.js_escape).to eq(normal_char)
-    end
-  end
-
-  describe "#format_js" do
-    let(:js_escaped) { '\x26' }
-
-    it "should JavaScript format ascii bytes" do
-      expect(subject.format_js).to eq(js_escaped)
-    end
-
-    it "should JavaScript format unicode bytes" do
-      expect(0xd556.format_js).to eq('\uD556')
-    end
-  end
-end