ronin-support 0.5.2 → 1.0.0.beta1

data/spec/formatting/html/string_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/html/string'
-
-describe String do
-  subject { "one & two" }
-
-  it "should provide String#html_escape" do
-    should respond_to(:html_escape)
-  end
-
-  it "should provide String#html_unescape" do
-    should respond_to(:html_unescape)
-  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#js_unescape" do
-    should respond_to(:js_unescape)
-  end
-
-  it "should provide String#format_js" do
-    should respond_to(:format_js)
-  end
-
-  describe "#html_escape" do
-    let(:html_escaped) { "one & two" }
-
-    it "should HTML escape itself" do
-      expect(subject.html_escape).to eq(html_escaped)
-    end
-  end
-
-  describe "#html_unescape" do
-    let(:html_escaped) { "one & two" }
-
-    it "should HTML unescape itself" do
-      expect(html_escaped.html_unescape).to eq(subject)
-    end
-  end
-
-  describe "#format_html" do
-    let(:formatted_html) do
-      "one & two"
-    end
-
-    it "should HTML format all chars" do
-      expect(subject.format_html).to eq(formatted_html)
-    end
-  end
-
-  describe "#js_escape" do
-    let(:special_chars) { "\t\n\r" }
-    let(:escaped_special_chars) { '\t\n\r' }
-
-    let(:normal_chars) { "abc" }
-
-    it "should escape special JavaScript characters" do
-      expect(special_chars.js_escape).to eq(escaped_special_chars)
-    end
-
-    it "should ignore normal characters" do
-      expect(normal_chars.js_escape).to eq(normal_chars)
-    end
-  end
-
-  describe "#js_unescape" do
-    let(:js_unicode) do
-      "%u006F%u006E%u0065%u0020%u0026%u0020%u0074%u0077%u006F"
-    end
-    let(:js_hex) { "%6F%6E%65%20%26%20%74%77%6F" }
-    let(:js_mixed) { "%u6F%u6E%u65 %26 two" }
-
-    it "should unescape JavaScript unicode characters" do
-      expect(js_unicode.js_unescape).to eq(subject)
-    end
-
-    it "should unescape JavaScript hex characters" do
-      expect(js_hex.js_unescape).to eq(subject)
-    end
-
-    it "should unescape backslash-escaped characters" do
-      expect("\\b\\t\\n\\f\\r\\\"\\\\".js_unescape).to eq("\b\t\n\f\r\"\\")
-    end
-
-    it "should ignore non-escaped characters" do
-      expect(js_mixed.js_unescape).to eq(subject)
-    end
-  end
-
-  describe "#format_js" do
-    let(:js_formatted) { '\x6F\x6E\x65\x20\x26\x20\x74\x77\x6F' }
-
-    it "should JavaScript escape all characters" do
-      expect(subject.format_js).to eq(js_formatted)
-    end
-  end
-end

data/spec/formatting/http/integer_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/http/integer'
-
-describe Integer do
-  subject { 0x20 }
-
-  it "should provide String#uri_encode" do
-    should respond_to(:uri_encode)
-  end
-
-  it "should provide String#uri_escape" do
-    should respond_to(:uri_escape)
-  end
-
-  it "should provide String#format_http" do
-    should respond_to(:format_http)
-  end
-
-  describe "#uri_encode" do
-    let(:uri_encoded) { '%20' }
-
-    it "should URI encode itself" do
-      expect(subject.uri_encode).to eq(uri_encoded)
-    end
-  end
-
-  describe "#uri_escape" do
-    let(:uri_escaped) { '+' }
-
-    it "should URI escape itself" do
-      expect(subject.uri_escape).to eq(uri_escaped)
-    end
-  end
-
-  describe "#format_http" do
-    let(:http_formatted) { '%20' }
-
-    it "should format the byte" do
-      expect(subject.format_http).to eq(http_formatted)
-    end
-  end
-end

data/spec/formatting/http/string_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/http/string'
-
-describe String do
-  subject { "hello" }
-
-  it "should provide String#uri_encode" do
-    should respond_to(:uri_encode)
-  end
-
-  it "should provide String#uri_decode" do
-    should respond_to(:uri_decode)
-  end
-
-  it "should provide String#uri_escape" do
-    should respond_to(:uri_escape)
-  end
-
-  it "should provide String#uri_unescape" do
-    should respond_to(:uri_unescape)
-  end
-
-  it "should provide String#format_http" do
-    should respond_to(:format_http)
-  end
-
-  describe "#uri_encode" do
-    subject { "mod % 3" }
-
-    let(:uri_encoded) { "mod%20%25%203" }
-
-    it "should URI encode itself" do
-      expect(subject.uri_encode).to eq(uri_encoded)
-    end
-  end
-
-  describe "#uri_decode" do
-    subject { "mod%20%25%203" }
-
-    let(:uri_decoded) { "mod % 3" }
-
-    it "should URI decode itself" do
-      expect(subject.uri_decode).to eq(uri_decoded)
-    end
-  end
-
-  describe "#uri_escape" do
-    subject { "x + y" }
-
-    let(:uri_escaped) { "x+%2B+y" }
-
-    it "should URI escape itself" do
-      expect(subject.uri_escape).to eq(uri_escaped)
-    end
-  end
-
-  describe "#uri_unescape" do
-    subject { "x+%2B+y" }
-
-    let(:uri_unescaped) { "x + y" }
-
-    it "should URI unescape itself" do
-      expect(subject.uri_unescape).to eq(uri_unescaped)
-    end
-  end
-
-  describe "#format_http" do
-    subject { "mod % 3" }
-
-    let(:http_formatted) { "%6D%6F%64%20%25%20%33" }
-
-    it "should format each byte of the String" do
-      expect(subject.format_http).to eq(http_formatted)
-    end
-  end
-end

data/spec/formatting/sql/string_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/extensions/sql/string'
-
-describe String do
-  let(:string) {'/etc/passwd' }
-  let(:sql_encoded) { '0x2f6574632f706173737764' }
-  let(:string_with_quotes) { %{"O'Brian"} }
-
-  it "should provide the #sql_escape method" do
-    expect(string).to respond_to(:sql_escape)
-  end
-
-  it "should provide the #sql_encode method" do
-    expect(string).to respond_to(:sql_encode)
-  end
-
-  it "should provide the #sql_decode method" do
-    expect(string).to respond_to(:sql_decode)
-  end
-
-  describe "#sql_escape" do
-    it "should be able to single-quote escape" do
-      expect(string_with_quotes.sql_escape(:single)).to eq(%{'"O''Brian"'})
-    end
-
-    it "should be able to double-quote escape" do
-      expect(string_with_quotes.sql_escape(:double)).to eq(%{"""O'Brian"""})
-    end
-
-    it "should be able to tick-mark escape" do
-      expect(string_with_quotes.sql_escape(:tick)).to eq(%{`"O'Brian"`})
-    end
-  end
-
-  describe "#sql_encode" do
-    it "should be able to be SQL-hex encoded" do
-      expect(string.sql_encode).to eq(sql_encoded)
-    end
-
-    it "should return an empty String if empty" do
-      expect(''.sql_encode).to eq('')
-    end
-  end
-
-  describe "#sql_decode" do
-    it "should be able to be SQL-hex decoded" do
-      encoded = string.sql_encode
-
-      expect(encoded).to eq(sql_encoded)
-      expect(encoded.sql_decode).to eq(string)
-    end
-
-    it "should be able to decode SQL comma-escaping" do
-      expect("'Conan O''Brian'".sql_decode).to eq("Conan O'Brian")
-    end
-  end
-
-  describe "#sql_inject" do
-    context "when there is a leading quote character" do
-      it "should remove the first and last quote character" do
-        expect("'1' OR '1'='1'".sql_inject).to eq("1' OR '1'='1")
-      end
-
-      context "when there is no matching leading/trailing quote characters" do
-        it "should comment-terminate the String" do
-          expect("'1' OR 1=1".sql_inject).to eq("1' OR 1=1--")
-        end
-      end
-    end
-
-    context "when there is no leading quote character" do
-      it "should not modify the String" do
-        expect("1 OR 1=1".sql_inject).to eq("1 OR 1=1")
-      end
-    end
-  end
-end

data/spec/formatting/text/array_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/text'
-
-describe Array do
-  subject { [] }
-
-  let(:byte_array) { [0x41, 0x41, 0x20] }
-  let(:char_array) { ['A', 'A', ' '] }
-  let(:mixed_array) { ['AA', 0x20] }
-  let(:string) { 'AA ' }
-
-  it "should provide Array#bytes" do
-    should respond_to(:bytes)
-  end
-
-  it "should provide Array#chars" do
-    should respond_to(:chars)
-  end
-
-  it "should provide Array#char_string" do
-    should respond_to(:char_string)
-  end
-
-  it "should provide Array#hex_chars" do
-    should respond_to(:hex_chars)
-  end
-
-  it "should provide Array#hex_integers" do
-    should respond_to(:hex_integers)
-  end
-
-  describe "#bytes" do
-    it "should convert an Array of bytes to an Array of bytes" do
-      expect(byte_array.bytes).to eq(byte_array)
-    end
-
-    it "should convert an Array of chars to an Array of bytes" do
-      expect(char_array.bytes).to eq(byte_array)
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      expect(mixed_array.bytes).to eq(byte_array)
-    end
-  end
-
-  describe "#chars" do
-    it "should convert an Array of bytes to an Array of chars" do
-      expect(byte_array.chars).to eq(char_array)
-    end
-
-    it "should safely convert an Array of chars to an Array of chars" do
-      expect(char_array.chars).to eq(char_array)
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      expect(mixed_array.chars).to eq(char_array)
-    end
-  end
-
-  describe "#char_string" do
-    it "should convert an Array of bytes to a String" do
-      expect(byte_array.char_string).to eq(string)
-    end
-
-    it "should convert an Array of chars to a String" do
-      expect(char_array.char_string).to eq(string)
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      expect(mixed_array.char_string).to eq(string)
-    end
-  end
-
-  describe "#hex_chars" do
-    let(:hex_chars) { ['\x41', '\x41', '\x20'] }
-
-    it "should convert an Array of bytes into hexadecimal chars" do
-      expect(byte_array.hex_chars).to eq(hex_chars)
-    end
-
-    it "should convert an Array of chars into hexadecimal chars" do
-      expect(char_array.hex_chars).to eq(hex_chars)
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      expect(mixed_array.hex_chars).to eq(hex_chars)
-    end
-  end
-
-  describe "#hex_integers" do
-    let(:hex_integers) { ['0x41', '0x41', '0x20'] }
-
-    it "should convert an Array of bytes into hexadecimal integers" do
-      expect(byte_array.hex_integers).to eq(hex_integers)
-    end
-
-    it "should convert an Array of chars into hexadecimal integers" do
-      expect(char_array.hex_integers).to eq(hex_integers)
-    end
-
-    it "should safely handle mixed byte/char/string Arrays" do
-      expect(mixed_array.hex_integers).to eq(hex_integers)
-    end
-  end
-end

data/spec/formatting/text/string_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require 'ronin/formatting/text'
-
-describe String do
-  subject { "hello" }
-
-  it "should provide String#format_chars" do
-    should respond_to(:format_chars)
-  end
-
-  it "should provide String#format_bytes" do
-    should respond_to(:format_bytes)
-  end
-
-  it "should provide String#random_case" do
-    should respond_to(:random_case)
-  end
-
-  it "should provide String#insert_before" do
-    should respond_to(:insert_before)
-  end
-
-  it "should provide String#insert_after" do
-    should respond_to(:insert_after)
-  end
-
-  it "should provide String#escape" do
-    should respond_to(:escape)
-  end
-
-  it "should provide String#unescape" do
-    should respond_to(:unescape)
-  end
-
-  describe "#format_bytes" do
-    it "should format each byte in the String" do
-      expect(subject.format_bytes { |b|
-        sprintf("%%%x",b)
-      }).to eq("%68%65%6c%6c%6f")
-    end
-
-    it "should format specific bytes in a String" do
-      expect(subject.format_bytes(:include => [104, 108]) { |b|
-        b - 32
-      }).to eq('HeLLo')
-    end
-
-    it "should not format specific bytes in a String" do
-      expect(subject.format_bytes(:exclude => [101, 111]) { |b|
-        b - 32
-      }).to eq('HeLLo')
-    end
-
-    it "should format ranges of bytes in a String" do
-      expect(subject.format_bytes(:include => (104..108)) { |b|
-        b - 32
-      }).to eq('HeLLo')
-    end
-
-    it "should not format ranges of bytes in a String" do
-      expect(subject.format_bytes(:exclude => (104..108)) { |b|
-        b - 32
-      }).to eq('hEllO')
-    end
-  end
-
-  describe "#format_chars" do
-    it "should format each character in the String" do
-      expect(subject.format_chars { |c|
-        "#{c}."
-      }).to eq("h.e.l.l.o.")
-    end
-
-    it "should format specific chars in a String" do
-      expect(subject.format_chars(:include => ['h', 'l']) { |c|
-        c.upcase
-      }).to eq('HeLLo')
-    end
-
-    it "should not format specific chars in a String" do
-      expect(subject.format_chars(:exclude => ['h', 'l']) { |c|
-        c.upcase
-      }).to eq('hEllO')
-    end
-
-    it "should format ranges of chars in a String" do
-      expect(subject.format_chars(:include => /[h-l]/) { |c|
-        c.upcase
-      }).to eq('HeLLo')
-    end
-
-    it "should not format ranges of chars in a String" do
-      expect(subject.format_chars(:exclude => /[h-l]/) { |c|
-        c.upcase
-      }).to eq('hEllO')
-    end
-  end
-
-  describe "#random_case" do
-    it "should capitalize each character when :probability is 1.0" do
-      new_string = subject.random_case(:probability => 1.0)
-
-      expect(subject.upcase).to eq(new_string)
-    end
-
-    it "should not capitalize any characters when :probability is 0.0" do
-      new_string = subject.random_case(:probability => 0.0)
-
-      expect(subject).to eq(new_string)
-    end
-  end
-
-  describe "#insert_before" do
-    it "should inject data before a matched String" do
-      expect(subject.insert_before('ll','x')).to eq("hexllo")
-    end
-
-    it "should inject data before a matched Regexp" do
-      expect(subject.insert_before(/l+/,'x')).to eq("hexllo")
-    end
-
-    it "should not inject data if no matches are found" do
-      expect(subject.insert_before(/x/,'x')).to eq(subject)
-    end
-  end
-
-  describe "#insert_after" do
-    it "should inject data after a matched String" do
-      expect(subject.insert_after('ll','x')).to eq("hellxo")
-    end
-
-    it "should inject data after a matched Regexp" do
-      expect(subject.insert_after(/l+/,'x')).to eq("hellxo")
-    end
-
-    it "should not inject data if no matches are found" do
-      expect(subject.insert_after(/x/,'x')).to eq(subject)
-    end
-  end
-
-  describe "#unescape" do
-    it "should not unescape a normal String" do
-      expect("hello".unescape).to eq("hello")
-    end
-
-    it "should unescape a hex String" do
-      expect("\\x68\\x65\\x6c\\x6c\\x6f\\x4e".unescape).to eq("hello\x4e")
-    end
-
-    it "should unescape an octal String" do
-      expect("hello\012".unescape).to eq("hello\n")
-    end
-
-    it "should unescape control characters" do
-      expect("hello\\n".unescape).to eq("hello\n")
-    end
-
-    it "should unescape normal characters" do
-      expect("hell\\o".unescape).to eq("hello")
-    end
-  end
-end

data/spec/fuzzing/extensions/string_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/extensions/string'
-
-describe String do
-  it "should provide String.generate" do
-    expect(described_class).to respond_to(:generate)
-  end
-
-  it "should provide String#repeating" do
-    expect(subject).to respond_to(:repeating)
-  end
-
-  it "should provide String#fuzz" do
-    expect(subject).to respond_to(:fuzz)
-  end
-
-  it "should provide String#mutate" do
-    expect(subject).to respond_to(:mutate)
-  end
-
-  describe "generate" do
-    subject { described_class }
-
-    it "should generate Strings from a template" do
-      strings = subject.generate([:numeric, 2]).to_a
-
-      expect(strings.grep(/^[0-9]{2}$/)).to eq(strings)
-    end
-  end
-
-  describe "#repeating" do
-    subject { 'A' }
-
-    context "when n is an Integer" do
-      let(:n) { 100 }
-
-      it "should multiply the String by n" do
-        expect(subject.repeating(n)).to eq(subject * n)
-      end
-    end
-
-    context "when n is Enumerable" do
-      let(:n) { [128, 512, 1024] }
-
-      it "should repeat the String by each length" do
-        strings = subject.repeating(n).to_a
-
-        expect(strings).to eq(n.map { |length| subject * length })
-      end
-    end
-  end
-
-  describe "#fuzz" do
-    subject { "foo bar" }
-
-    it "should apply each fuzzing rule individually" do
-      strings = subject.fuzz(/o/ => ['O', '0'], /a/ => ['A', '@']).to_a
-      
-      expect(strings).to match_array([
-        "fOo bar",
-        "f0o bar",
-        "foO bar",
-        "fo0 bar",
-        "foo bAr",
-        "foo b@r"
-      ])
-    end
-  end
-
-  describe "#mutate" do
-    subject { "foo bar" }
-
-    it "should apply every combination of mutation rules" do
-      strings = subject.mutate(/o/ => ['0'], /a/ => ['@']).to_a
-
-      expect(strings).to match_array([
-        "f0o bar",
-        "fo0 bar",
-        "f00 bar",
-        "foo b@r",
-        "f0o b@r",
-        "fo0 b@r",
-        "f00 b@r"
-      ])
-    end
-  end
-end