├── Rakefile
├── Enc.gemspec
├── README.markdown
├── bin
    └── enc-cli
├── test
    ├── spec_dec.rb
    └── spec_enc.rb
└── lib
    └── enc
        ├── dec.rb
        └── enc.rb


/Rakefile:
--------------------------------------------------------------------------------
 1 | require 'yard'
 2 | require 'rake/clean'
 3 | 
 4 | CLEAN.include('doc/', '*.gem')
 5 | 
 6 | task :buildgem do
 7 |   puts `gem build Enc.gemspec`
 8 | end
 9 | 
10 | task :install => [:clean, :buildgem] do
11 |   puts `gem install Enc-*.gem`
12 | end
13 | 
14 | YARD::Rake::YardocTask.new do |t|
15 |   t.files   = ['lib/enc/enc.rb', 'lib/enc/dec.rb']
16 |   t.options = ['--main', 'README.markdown']
17 | end
18 | 


--------------------------------------------------------------------------------
/Enc.gemspec:
--------------------------------------------------------------------------------
 1 | # -*- encoding: utf-8 -*-
 2 | 
 3 | Gem::Specification.new do |s|
 4 |   s.name = %q{Enc}
 5 |   s.version = "0.0.9"
 6 |   s.authors = ["Patrick Hof"]
 7 |   s.date = %q{2012-04-27}
 8 |   s.email = %q{courts@offensivethinking.org}
 9 |   s.files = %w(README.markdown Rakefile bin/enc-cli lib/enc/dec.rb lib/enc/enc.rb test/spec_enc.rb test/spec_dec.rb)
10 |   s.executables = ["enc-cli"]
11 |   s.homepage = %q{http://www.offensivethinking.org}
12 |   s.require_paths = ["lib"]
13 |   s.summary = %q{A module implementing commonly used string encoders for various occasions.}
14 |   s.description = <<-EOF
15 |     A module implementing commonly used string encoders for various occasions.
16 |     It's intended primary use is to include it in your scripts. A basic command line
17 |     client is included.
18 |   EOF
19 | end
20 | 


--------------------------------------------------------------------------------
/README.markdown:
--------------------------------------------------------------------------------
 1 | Ruby Enc
 2 | ========
 3 | 
 4 | Author:      Patrick Hof <courts@offensivethinking.org>  
 5 | License:     [CC0 1.0 Universal License](http://creativecommons.org/publicdomain/zero/1.0/legalcode)
 6 | 
 7 | Download:    git clone git@github.com:courts/enc.git  
 8 | YARD docs:   [http://courts.github.com/enc](http://courts.github.com/enc)
 9 | 
10 | Two modules implementing commonly used string encoders and decoders for various
11 | occasions. Their intended primary use is to include them in your scripts.  Basic
12 | command line clients are included.
13 | 
14 | Command Line Usage
15 | ------------------
16 | 
17 | There is a basic command line client in the /bin directory. Usage:
18 | 
19 |     enc-cli <encoder> [params] <string from stdin>
20 |     enc-cli -d <decoder> [params] <string from stdin>
21 | 
22 | See ``enc-cli -h`` for more information.
23 | 
24 | Examples
25 | --------
26 |     enc-cli Std::url <<< 'http://www.example.com?aa=bb&cc=dd'
27 |     http%3A%2F%2Fwww.example.com%3Faa%3Dbb%26cc%3Ddd%0A
28 | 
29 |     enc-cli Std::url true <<< 'http://www.example.com?aa=bb&cc=dd'
30 |     %68%74%74%70%3A%2F%2F%77%77%77%2E%65%78%61%6D%70%6C%65%2E%63%6F%6D%3F%61%61%3D%62%62%26%63%63%3D%64%64%0A
31 | 
32 |     enc-cli -d Std::url <<< 'http%3A%2F%2Fwww.example.com%3Faa%3Dbb%26cc%3Ddd'
33 |     http://www.example.com?aa=bb&cc=dd
34 | 
35 | Be aware of the trailing newline in the encoding example, which also gets
36 | encoded. To get rid of it, use the ``-n`` option.
37 | 
38 | RubyGems
39 | --------
40 | 
41 | A gemspec file is included, so you can build and install Enc as a gem with:
42 | 
43 |     gem build Enc.gemspec
44 |     gem install Enc-x.x.x.gem
45 | 
46 | ---
47 | 
48 | Inspired by:
49 | 
50 | *   [wfuzz][1]
51 | *   [rbkb][2]
52 | 
53 | [1]: http://www.edge-security.com/wfuzz.php
54 | [2]: http://github.com/emonti/rbkb
55 | 


--------------------------------------------------------------------------------
/bin/enc-cli:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | #
 3 | # A basic command line client for the Enc module.
 4 | #
 5 | # This software is licensed under the Creative
 6 | # Commons CC0 1.0 Universal License.
 7 | # To view a copy of this license, visit
 8 | # http://creativecommons.org/publicdomain/zero/1.0/legalcode
 9 | #
10 | # @author Patrick Hof
11 | 
12 | require 'enc/enc'
13 | require 'enc/dec'
14 | require 'optparse'
15 | 
16 | # Returns all methods the given module provides
17 | #
18 | # @param [Module] mod The module the check
19 | # @return [Array] array of strings with the methods
20 | def get_methods(mod)
21 |   methods = []
22 |   mod.constants.sort.each do |c|
23 |     mod.const_get(c).singleton_methods.sort.each do |m|
24 |       methods << "#{c}::#{m}"
25 |     end
26 |   end
27 |   methods
28 | end
29 | 
30 | fname = File.basename(__FILE__)
31 | methods = [
32 |   "",
33 |   "Available Encoders",
34 |   "------------------"
35 | ]
36 | methods += get_methods(Enc)
37 | methods += [
38 |   "",
39 |   "Available Decoders",
40 |   "------------------"
41 | ]
42 | methods += get_methods(Dec)
43 | methods += [
44 |   "",
45 |   "Examples:",
46 |   "#{fname} Std::url <<< '<script>'",
47 |   "#{fname} -n Std::url true <<< '<script>'",
48 |   "",
49 |   "#{fname} -d Std::url <<< '%3Cscript%3E'",
50 |   "#{fname} -d -n Std::url true <<< '%3C%73%63%72%69%70%74%3E'",
51 |   "",
52 |   "Please see the YARD documentation for available parameters.",
53 |   "",
54 |   ""
55 | ]
56 | 
57 | options = {
58 |   :nonewline => false,
59 |   :decoder   => false
60 | }
61 | popts = OptionParser.new do |opts|
62 |   opts.banner = "Usage: #{fname} [options] <(en|de)coder> [params] <string from stdin>"
63 |   opts.separator ""
64 |   opts.on("-d", "--decode", "Decode data") do
65 |     options[:decoder] = true
66 |   end
67 |   opts.on("-n", "--no-newline", "Remove trailing newlines from input (default: #{options[:nonewline]})") do
68 |     options[:nonewline] = true
69 |   end
70 |   opts.on("-h", "--help", "Print this help") do
71 |     puts opts
72 |     puts methods
73 |   end
74 | end.parse!
75 | 
76 | begin
77 |   mod, m = ARGV[0].split("::")
78 |   params = ARGV[1] ? ARGV[1].split(",") : []
79 |   data = $stdin.read()
80 |   data.chomp! if options[:nonewline]
81 |   if options[:decoder]
82 |     lib = Dec
83 |   else
84 |     lib = Enc
85 |   end
86 |   puts lib.const_get(mod.to_sym).send(m.to_sym, data, *params)
87 | rescue Exception => e
88 |   puts "ERROR: #{e}"
89 |   puts popts
90 | end
91 | 


--------------------------------------------------------------------------------
/test/spec_dec.rb:
--------------------------------------------------------------------------------
 1 | # coding: utf-8
 2 | require 'bacon'
 3 | require 'enc/dec'
 4 | 
 5 | include Dec
 6 | 
 7 | describe Dec do
 8 | 
 9 |   before do
10 |     @url_text = "http://www.example.com?aa=bb&cc=dd"
11 |     @sql_text = "SELECT * FROM users WHERE id = '1' AND pass='password'"
12 |     @utf8_text = "aabbäöü"
13 |   end
14 | 
15 |   it "should return a URL decoded string (either fully or only partially) when sent Std::url()" do
16 |     Std::url('http%3A%2F%2Fwww.example.com%3Faa%3Dbb%26cc%3Ddd').should.equal @url_text
17 |     Std::url('%68%74%74%70%3A%2F%2F%77%77%77%2E%65%78%61%6D%70%6C%65%2E%63%6F%6D%3F%61%61%3D%62%62%26%63%63%3D%64%64').should.equal @url_text
18 |   end
19 | 
20 |   it "should return a URL decoded string of the raw data's bytes when sent Std::url_raw()" do
21 |     # "unpack" is used here as a workaround for encoding problems preventing equality comparison
22 |     Std::url_raw('%41%42%EF%FF').unpack("H*").should.equal "\x41\x42\xEF\xFF".unpack("H*")
23 |   end
24 | 
25 |   it "should return a base64 representation of any binary data given to Std::b64()" do
26 |     Std::b64("dGVzdA==").should.equal "test"
27 |   end
28 | 
29 |   it "should return the binary represenation of hex data if sent Std::hex()" do
30 |     Std::hex("687474703A2F2F7777772E6578616D706C652E636F6D3F61613D62622663633D6464").should.equal @url_text
31 |   end
32 | 
33 |   it "should return the binary string from a comma separated hex representation when sent Std::charcode()" do
34 |     Std::charcode('104,116,116,112,58,47,47,119,119,119,46,101,120,97,109,112,108,101,46,99,111,109,63,97,97,61,98,98,38,99,99,61,100,100').should.equal @url_text
35 |   end
36 | 
37 |   it "should return an HTML unescaped string when sent HTML::html()" do
38 |     HTML::html("http://www.example.com?aa=bb&amp;cc=dd").should.equal @url_text
39 |   end
40 | 
41 |   it "should return a decoded MSSQL CHAR representation when sent MSSQL::char()" do
42 |     MSSQL::char('CHAR(83)+CHAR(69)+CHAR(76)+CHAR(69)+CHAR(67)+CHAR(84)+CHAR(32)+CHAR(42)+CHAR(32)+CHAR(70)+CHAR(82)+CHAR(79)+CHAR(77)+CHAR(32)+CHAR(117)+CHAR(115)+CHAR(101)+CHAR(114)+CHAR(115)+CHAR(32)+CHAR(87)+CHAR(72)+CHAR(69)+CHAR(82)+CHAR(69)+CHAR(32)+CHAR(105)+CHAR(100)+CHAR(32)+CHAR(61)+CHAR(32)+CHAR(39)+CHAR(49)+CHAR(39)+CHAR(32)+CHAR(65)+CHAR(78)+CHAR(68)+CHAR(32)+CHAR(112)+CHAR(97)+CHAR(115)+CHAR(115)+CHAR(61)+CHAR(39)+CHAR(112)+CHAR(97)+CHAR(115)+CHAR(115)+CHAR(119)+CHAR(111)+CHAR(114)+CHAR(100)+CHAR(39)').should.equal @sql_text
43 |   end
44 | 
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/enc/dec.rb:
--------------------------------------------------------------------------------
 1 | # coding: utf-8
 2 | require 'cgi'
 3 | require 'yaml'
 4 | require 'digest/sha1'
 5 | require 'digest/md5'
 6 | 
 7 | # This module implements the decoders complementary to the encoders in enc.rb
 8 | # (where it makes sense).
 9 | #
10 | # This software is licensed under the Creative
11 | # Commons CC0 1.0 Universal License.
12 | # To view a copy of this license, visit
13 | # http://creativecommons.org/publicdomain/zero/1.0/legalcode
14 | #
15 | # @author Patrick Hof
16 | module Dec
17 | 
18 |   # Contains all decoders not fitting into a specific category.
19 |   module Std
20 |     # Returns a URL decoded string
21 |     #
22 |     # @param [String] data The data to URL decode
23 |     # @return [String] the URL decoded string
24 |     def Std::url(data)
25 |       CGI.unescape(data)
26 |     end
27 | 
28 |     # Returns the raw bytes of a URL encoded string
29 |     #
30 |     # @param [String] data The data to URL decode
31 |     # @return [String] the raw bytes
32 |     def Std::url_raw(data)
33 |       data = data.split("%")
34 |       data[1..-1].pack("H2"*(data.length - 1))
35 |     end
36 | 
37 |     # Returns the decoded base64 string
38 |     #
39 |     # @param [String] bin The data to decode in base64
40 |     # @return [String] Base64 decoded string of the given data
41 |     def Std::b64(bin)
42 |       bin.unpack("m")[0]
43 |     end
44 | 
45 |     # Returns the decoded hex representation of data
46 |     #
47 |     # @param [String] data The hex data to decode
48 |     # @return [String] Hex decoded data
49 |     def Std::hex(data)
50 |       res = ""
51 |       data = data.split("")
52 |       until data.empty?
53 |         res << data.shift(2).join().hex.chr
54 |       end
55 |       res
56 |     end
57 | 
58 |     # Decodes a string of comma separated character codes, e.g.
59 |     # "98,99,100"
60 |     #
61 |     # @param [String] data The string to decode
62 |     # @return [String] The decoded string
63 |     def Std::charcode(data)
64 |       data.split(/,\s*/).map {|x| x.to_i.chr}.join()
65 |     end
66 |   end
67 | 
68 |   # Encoders converting strings to valid HTML.
69 |   module HTML
70 |     # HTML decodes a string
71 |     #
72 |     # @param [String] data The string to decode
73 |     # @return [String] The decoded string
74 |     def HTML::html(data)
75 |       CGI.unescapeHTML(data)
76 |     end
77 |   end
78 | 
79 |   # Encoders returning valid MSSQL strings.
80 |   module MSSQL
81 |     # Decodes an MSSQL CHARs string, e.g. CHAR(98)+CHAR(99)+CHAR(100)
82 |     #
83 |     # @param [String] data The string to decode
84 |     # @return [String] The decoded string
85 |     def MSSQL::char(data)
86 |       data = data.split("+")
87 |       data.map{|x| x =~ /CHAR\((\d+)\)/; $1.to_i.chr}.join()
88 |     end
89 |   end
90 | end
91 | 


--------------------------------------------------------------------------------
/test/spec_enc.rb:
--------------------------------------------------------------------------------
  1 | # coding: utf-8
  2 | require 'bacon'
  3 | require 'enc/enc'
  4 | 
  5 | include Enc
  6 | 
  7 | describe Enc do
  8 | 
  9 |   before do
 10 |     @url_text = "http://www.example.com?aa=bb&cc=dd"
 11 |     @sql_text = "SELECT * FROM users WHERE id = '1' AND pass='password'"
 12 |     @utf8_text = "aabbäöü"
 13 |   end
 14 | 
 15 |   it "should return a URL encoded string (either fully or only partially) when sent Std::url()" do
 16 |     Std::url(@url_text).should.equal 'http%3A%2F%2Fwww.example.com%3Faa%3Dbb%26cc%3Ddd'
 17 |     Std::url("\x00\x01\xEF\xFF", all=true).should.equal "%00%01%EF%FF"
 18 |     Std::url(255).should.equal "%FF"
 19 |     Std::url((254..255)).should.equal "%FE%FF"
 20 |     Std::url([254,255]).should.equal "%FE%FF"
 21 |     Std::url(['a', 'b']).should.equal "%61%62"
 22 |   end
 23 | 
 24 |   it "should return a base64 representation of any binary data given to Std::b64()" do
 25 |     Std::b64("test").should.equal "dGVzdA=="
 26 |   end
 27 | 
 28 |   it "should return a base64 representation of any binary data given to Std::b64() and not split the lines" do
 29 |     Std::b64("A"*46).should.equal "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQQ=="
 30 |   end
 31 | 
 32 |   it "should return a base64 representation of any binary data given to Std::b64() and split the lines" do
 33 |     Std::b64("A"*46, split=true).should.equal "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\nQQ=="
 34 |   end
 35 | 
 36 |   it "should return a transformed string with randomly uppercased characters with Std::rand_upcase()" do
 37 |     Std::rand_upcase(@url_text).downcase.should.equal @url_text
 38 |   end
 39 | 
 40 |   it "should return the SHA1 (hex) string when sent Std::sha1()" do
 41 |     Std::sha1(@url_text).should.equal "ba53d1abf6b7c2fec072379fcd312920c02152c1"
 42 |     Std::sha1(@url_text, raw=true).unpack("H*")[0].should.equal "ba53d1abf6b7c2fec072379fcd312920c02152c1"
 43 |   end
 44 | 
 45 |   it "should return the MD5 (hex) string when sent Std::md5()" do
 46 |     Std::md5(@url_text).should.equal "052619cb4bae29861029b120f0b86d54"
 47 |     Std::md5(@url_text, raw=true).unpack("H*")[0].should.equal "052619cb4bae29861029b120f0b86d54"
 48 |   end
 49 | 
 50 |   it "should return the hex represenation of binary data if sent Std::hex()" do
 51 |     Std::hex(@url_text).should.equal "687474703A2F2F7777772E6578616D706C652E636F6D3F61613D62622663633D6464"
 52 |     Std::hex(255).should.equal "FF"
 53 |     Std::hex(254..255).should.equal "FEFF"
 54 |     Std::hex([254,255]).should.equal "FEFF"
 55 |     Std::hex(['a', 'b']).should.equal "6162"
 56 |   end
 57 | 
 58 |   it "should XOR two strings when sent Std::xor()" do
 59 |     Std::xor(@url_text, "test").should.equal "\x1C\x11\a\x04NJ\\\x03\x03\x12]\x11\f\x04\x1E\x04\x18\x00]\x17\e\bL\x15\x15X\x11\x16R\x06\x10I\x10\x01"
 60 |   end
 61 | 
 62 |   it "should return an array of integers being the ordinal representation of a string's chars when sent Std::ord_as_ary()" do
 63 |     Std::ord_as_ary(@url_text).should.equal [104,116,116,112,58,47,47,119,119,119,46,101,120,97,109,112,108,101,46,99,111,109,63,97,97,61,98,98,38,99,99,61,100,100]
 64 |   end
 65 | 
 66 |   it "should return a string with spaces swapped for comments when sent Std::comment()" do
 67 |     Std::comment(@sql_text).should.equal "SELECT/**/*/**/FROM/**/users/**/WHERE/**/id/**/=/**/'1'/**/AND/**/pass='password'"
 68 |   end
 69 | 
 70 |   it "should return a PHP chr() representation of a string when sent PHP::chr()" do
 71 |     PHP::chr("abc").should.equal "chr(97).chr(98).chr(99)"
 72 |   end
 73 | 
 74 |   it "should return an HTML escaped string when sent HTML::html()" do
 75 |     HTML::html(@url_text).should.equal "http://www.example.com?aa=bb&amp;cc=dd"
 76 |   end
 77 | 
 78 |   it "should return the decimal html representation of a string when sent HTML::dec()" do
 79 |     HTML::dec(@url_text).should.equal "&#104;&#116;&#116;&#112;&#58;&#47;&#47;&#119;&#119;&#119;&#46;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#63;&#97;&#97;&#61;&#98;&#98;&#38;&#99;&#99;&#61;&#100;&#100;"
 80 |   end
 81 | 
 82 |   it "should return the hexadecimal html representation of a string when sent HTML::hex()" do
 83 |     HTML::hex(@url_text).should.equal '&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x77;&#x77;&#x77;&#x2E;&#x65;&#x78;&#x61;&#x6D;&#x70;&#x6C;&#x65;&#x2E;&#x63;&#x6F;&#x6D;&#x3F;&#x61;&#x61;&#x3D;&#x62;&#x62;&#x26;&#x63;&#x63;&#x3D;&#x64;&#x64;'
 84 |   end
 85 | 
 86 |   it "should only encode Umlauts when sent HTML::umlauts()" do
 87 |     HTML::umlauts("äÄöÖüÜß").should.equal '&auml;&Auml;&ouml;&Ouml;&uuml;&Uuml;&szlig;'
 88 |   end
 89 | 
 90 |   it "should return a JavaScript string.fromCharCode() representation when sent JS::charcode()" do
 91 |     JS::charcode(@url_text).should.equal 'String.fromCharCode(104,116,116,112,58,47,47,119,119,119,46,101,120,97,109,112,108,101,46,99,111,109,63,97,97,61,98,98,38,99,99,61,100,100)'
 92 |   end
 93 | 
 94 |   it "should return a Java byte array when sent Java::bytearray()" do
 95 |     res = Java::bytearray("AA").gsub("\n", "").gsub(/\s+/, " ")
 96 |     res.should.equal 'byte data[] = new byte[]{ (byte) 0x41, (byte) 0x41,};'
 97 |   end
 98 | 
 99 |   it "should return a MySQL hex representation when sent MySQL::hex()" do
100 |     MySQL::hex(@url_text).should.equal "0x687474703A2F2F7777772E6578616D706C652E636F6D3F61613D62622663633D6464"
101 |   end
102 | 
103 |   it "should return a MySQL CHAR representation when sent MySQL::char()" do
104 |     MySQL::char(@sql_text).should.equal 'CHAR(83,69,76,69,67,84,32,42,32,70,82,79,77,32,117,115,101,114,115,32,87,72,69,82,69,32,105,100,32,61,32,39,49,39,32,65,78,68,32,112,97,115,115,61,39,112,97,115,115,119,111,114,100,39)'
105 |   end
106 | 
107 |   it "should return a MSSQL CHAR representation when sent MSSQL::char()" do
108 |     MSSQL::char(@sql_text).should.equal 'CHAR(83)+CHAR(69)+CHAR(76)+CHAR(69)+CHAR(67)+CHAR(84)+CHAR(32)+CHAR(42)+CHAR(32)+CHAR(70)+CHAR(82)+CHAR(79)+CHAR(77)+CHAR(32)+CHAR(117)+CHAR(115)+CHAR(101)+CHAR(114)+CHAR(115)+CHAR(32)+CHAR(87)+CHAR(72)+CHAR(69)+CHAR(82)+CHAR(69)+CHAR(32)+CHAR(105)+CHAR(100)+CHAR(32)+CHAR(61)+CHAR(32)+CHAR(39)+CHAR(49)+CHAR(39)+CHAR(32)+CHAR(65)+CHAR(78)+CHAR(68)+CHAR(32)+CHAR(112)+CHAR(97)+CHAR(115)+CHAR(115)+CHAR(61)+CHAR(39)+CHAR(112)+CHAR(97)+CHAR(115)+CHAR(115)+CHAR(119)+CHAR(111)+CHAR(114)+CHAR(100)+CHAR(39)'
109 |   end
110 | 
111 | end
112 | 


--------------------------------------------------------------------------------
/lib/enc/enc.rb:
--------------------------------------------------------------------------------
  1 | # coding: utf-8
  2 | 
  3 | require 'cgi'
  4 | require 'base64'
  5 | require 'yaml'
  6 | require 'digest/sha1'
  7 | require 'digest/md5'
  8 | 
  9 | # This module implements commonly used (string) encoders for various occasions.
 10 | #
 11 | # This software is licensed under the Creative
 12 | # Commons CC0 1.0 Universal License.
 13 | # To view a copy of this license, visit
 14 | # http://creativecommons.org/publicdomain/zero/1.0/legalcode
 15 | #
 16 | # @author Patrick Hof
 17 | module Enc
 18 | 
 19 |   # Contains all encoders not fitting into a specific category.
 20 |   module Std
 21 |     # Returns a URL encoded string
 22 |     #
 23 |     # @param [String, Fixnum, #each] data The data to URL encode
 24 |     # @param [Boolean] all Whether to encode the whole string or only the
 25 |     #   necessary parts (default is false). If the data is not a string, it will
 26 |     #   always be fully encoded at the moment.
 27 |     # @return [String] the URL encoded string
 28 |     def Std::url(data, all=false)
 29 |       if all || (data.class != String)
 30 |         Std::hex_as_ary(data).map {|x| "%#{x}"}.join("")
 31 |       else
 32 |         CGI.escape(data)
 33 |       end
 34 |     end
 35 | 
 36 |     # Returns the base64 representation of the given data
 37 |     #
 38 |     # @param [String] bin The data to encode in base64
 39 |     # @param [Boolean] split whether to split lines with newlines or not (default is false)
 40 |     # @param [Boolean] htmlsafe whether to encode the string url-safe
 41 |     # @return [String] Base64 encoded string of the given data
 42 |     def Std::b64(bin, split=false, htmlsafe=false)
 43 |       if htmlsafe
 44 |         b64 = Base64.urlsafe_encode64(bin)
 45 |       else
 46 |         b64 = [bin].pack("m").chomp
 47 |       end
 48 |       b64.gsub!("\n", "") unless split
 49 |       return b64
 50 |     end
 51 | 
 52 |     # XOR a string with another string
 53 |     #
 54 |     # Adapted from
 55 |     # http://rubyforge.org/snippet/detail.php?type=snippet&id=108
 56 |     #
 57 |     # @param [String] data The original string
 58 |     # @param [String] key The string to XOR with
 59 |     # @return [String] the XOR'ed string
 60 |     #
 61 |     def Std::xor(data, key)
 62 |       data.length.times {|x| data[x] = (data[x].ord ^ (key[x % key.length]).ord).chr }
 63 |       return data
 64 |     end
 65 | 
 66 |     # Takes a string and returns the string with randomly uppercased characters
 67 |     #
 68 |     # @param [String] data The string to transform
 69 |     # @return [String] The string with randomly uppercased characters
 70 |     def Std::rand_upcase(data)
 71 |       data.split("").map do |x|
 72 |         if rand(2) == 0 then x.upcase else x end
 73 |       end.join
 74 |     end
 75 | 
 76 |     # Returns the SHA1 encoded (hex) string of the given string
 77 |     #
 78 |     # @param [String] data The string to transform
 79 |     # @param [Boolean] raw Wether to return the raw data if true or the hex
 80 |     #   string (default: false)
 81 |     # @return [String] SHA1 encoded string (hex)
 82 |     def Std::sha1(data, raw=false)
 83 |       if raw
 84 |         Digest::SHA1.digest(data)
 85 |       else
 86 |         Digest::SHA1.hexdigest(data)
 87 |       end
 88 |     end
 89 | 
 90 |     # Returns the MD5 encoded (hex) string of the given string
 91 |     #
 92 |     # @param [String] data The string to transform
 93 |     # @param [Boolean] raw Wether to return the raw data if true or the hex
 94 |     #   string (default: false)
 95 |     # @return [String] MD5 encoded string (hex)
 96 |     def Std::md5(data, raw=false)
 97 |       if raw
 98 |         Digest::MD5.digest(data)
 99 |       else
100 |         Digest::MD5.hexdigest(data)
101 |       end
102 |     end
103 | 
104 |     # Returns the hex representation of data
105 |     #
106 |     # @param [String, Fixnum, #each] data The data to transform
107 |     # @return [String] Hex representation of data
108 |     def Std::hex(data)
109 |       Std::hex_as_ary(data).join("")
110 |     end
111 | 
112 |     # Returns the hex representation of data
113 |     #
114 |     # @param [String, Fixnum, #each] data The data to transform
115 |     # @return [Array] Hex representation of data
116 |     def Std::hex_as_ary(data)
117 |       func = nil
118 |       res = []
119 |       if data.respond_to? 'each'
120 |         func = :each
121 |       elsif data.class == String
122 |         func = :each_byte
123 |       end
124 |       if func
125 |         data.send(func) do |x|
126 |           res << Std::hex_char(x)
127 |         end
128 |       else
129 |         res = [Std::hex_char(data)]
130 |       end
131 |       res
132 |     end
133 | 
134 |     # Returns the hex representation of an Integer. Also accepts a one
135 |     # character string.
136 |     #
137 |     # @param [Char, Fixnum] data The data to transform
138 |     # @return [String] Hex representation of data
139 |     def Std::hex_char(data)
140 |       return "%02X" % data.ord
141 |     end
142 | 
143 |     # Returns the integer ordinals of a string
144 |     #
145 |     # @param [String] data The string to encode
146 |     # @return [Array<Fixnum>] Array of Integers
147 |     def Std::ord_as_ary(data)
148 |       data.unpack("c*")
149 |     end
150 | 
151 |     # Substitutes whitespace with /**/ comments .
152 |     #
153 |     # @param [String] data The statement to encode
154 |     # @return [String] the encoded statement
155 |     def Std::comment(data)
156 |       data.gsub!(/\s+/, "/**/")
157 |     end
158 |   end
159 | 
160 |   # PHP encoders
161 |   module PHP
162 |     # Encodes a string as PHP CHARs, e.g. chr(98).chr(99).chr(100)
163 |     #
164 |     # @param [String] data The string to encode
165 |     # @return [String] The encoded string
166 |     def PHP::chr(data)
167 |       Std::ord_as_ary(data).map do |x|
168 |         "chr(#{x})"
169 |       end.join(".")
170 |     end
171 |   end
172 | 
173 |   # Encoders converting strings to valid HTML.
174 |   module HTML
175 |     # HTML encodes a string
176 |     #
177 |     # @param [String] data The string to encode
178 |     # @return [String] The encoded string
179 |     def HTML::html(data)
180 |       CGI.escapeHTML(data)
181 |     end
182 | 
183 |     # Decimal HTML encodes a string (e.g. "a" => &#97;
184 |     #
185 |     # @param [String] data The string to encode
186 |     # @return [String] The encoded string
187 |     def HTML::dec(data)
188 |       Std::ord_as_ary(data).map do |x|
189 |         "&##{x};"
190 |       end.join
191 |     end
192 | 
193 |     # HTML hex encodes a string
194 |     #
195 |     # @param [String] data The string to encode
196 |     # @return [String] The encoded string
197 |     def HTML::hex(data)
198 |       Std::hex_as_ary(data).map do |x|
199 |         "&#x" + x + ";"
200 |       end.join
201 |     end
202 | 
203 |     # HTML-encodes only umlauts to their HTML equivalent
204 |     #
205 |     # @param [String] data The string to encode
206 |     # @return [String] The encoded string
207 |     def HTML::umlauts(data)
208 |       umlauts = {
209 |         'ä' => '&auml;',
210 |         'ö' => '&ouml;',
211 |         'ü' => '&uuml;',
212 |         'Ä' => '&Auml;',
213 |         'Ö' => '&Ouml;',
214 |         'Ü' => '&Uuml;',
215 |         'ß' => '&szlig;'
216 |       }
217 |       umlauts.each do |umlaut, repr|
218 |         data.gsub!(umlaut, repr)
219 |       end
220 |       data
221 |     end
222 |   end
223 | 
224 |   # JavaScript encoders.
225 |   module JS
226 |     # Encodes a string with JavaScript string.fromCharCode(), e.g.
227 |     # string.fromCharCode(98,99,100)
228 |     #
229 |     # @param [String] data The string to encode
230 |     # @return [String] The encoded string
231 |     def JS::charcode(data)
232 |       "String.fromCharCode(" + Std::ord_as_ary(data).join(",") + ")"
233 |     end
234 |   end
235 | 
236 |   # Java encoders
237 |   module Java
238 |     # Encodes data as a Java byte array
239 |     #
240 |     # @example
241 |     #   Java::bytearray("AA")
242 |     #   -> byte data[] = new byte[] {(byte) 0x41, (byte) 0x41};
243 |     #
244 |     # @param [String] data The string to encode
245 |     # @return [Strings] The encoded string in Java byte array notation
246 |     def Java::bytearray(data)
247 |       bytes = Std::hex_as_ary(data)
248 |       java_ary = bytes.map {|x| "(byte) 0x#{x}"}
249 |       ret = "byte data[] = new byte[]\n{"
250 |       until java_ary.empty?
251 |         ret << "\n   " + java_ary.shift(8).join(", ") + ","
252 |       end
253 |       ret << "\n};\n"
254 |       return ret
255 |     end
256 |   end
257 | 
258 |   # Encoders returning valid MySQL strings.
259 |   module MySQL
260 |     # Returns the MySQL hex representation of data
261 |     #
262 |     # @param [String] data The data to transform
263 |     # @return [String] MySQL hex representation of data
264 |     def MySQL::hex(data)
265 |       return "0x#{Std::hex(data)}"
266 |     end
267 | 
268 |     # Encodes a string as MySQL CHAR, e.g. CHAR(98,99,100)
269 |     #
270 |     # @param [String] data The string to encode
271 |     # @return [String] The encoded string
272 |     def MySQL::char(data)
273 |       "CHAR(" + Std::ord_as_ary(data).join(",") + ")"
274 |     end
275 |   end
276 | 
277 |   # Encoders returning valid MSSQL strings.
278 |   module MSSQL
279 |     # Encodes a string as MSSQL CHARs, e.g. CHAR(98)+CHAR(99)+CHAR(100)
280 |     #
281 |     # @param [String] data The string to encode
282 |     # @return [String] The encoded string
283 |     def MSSQL::char(data)
284 |       Std::ord_as_ary(data).map do |x|
285 |         "CHAR(#{x})"
286 |       end.join("+")
287 |     end
288 |   end
289 | end
290 | 


--------------------------------------------------------------------------------