Class: String

Inherits:
Object show all
Defined in:
lib/ronin/extensions/string.rb,
lib/ronin/fuzzing/extensions/string.rb,
lib/ronin/formatting/extensions/sql/string.rb,
lib/ronin/formatting/extensions/html/string.rb,
lib/ronin/formatting/extensions/http/string.rb,
lib/ronin/formatting/extensions/text/string.rb,
lib/ronin/formatting/extensions/binary/string.rb,
lib/ronin/formatting/extensions/digest/string.rb

Overview

Copyright (c) 2006-2013 Hal Brodigan (postmodern.mod3 at gmail.com)

This file is part of Ronin Support.

Ronin Support is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Ronin Support is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with Ronin Support. If not, see http://www.gnu.org/licenses/.

Constant Summary

ESCAPE_BYTES =

Special ASCII bytes and their escaped character forms

Hash.new do |escape,byte|
  escape[byte] = if (byte >= 0x20 && byte <= 0x7e)
                   byte.chr
                 else
                   "\\x%.2X" % byte
                 end
end
JS_BACKSLASHED_CHARS =

JavaScript characters that must be back-slashed.

{
  "\\b"  => "\b",
  "\\t"  => "\t",
  "\\n"  => "\n",
  "\\f"  => "\f",
  "\\r"  => "\r",
  "\\\"" => "\"",
  "\\\\" => "\\"
}
UNESCAPE_CHARS =

Common escaped characters.

Hash.new do |hash,char|
  if char[0,1] == '\\'
    char[1,1]
  else
    char
  end
end

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Enumerator) generate(*fields) {|string| ... }

Generate permutations of Strings from a format template.

Examples:

Generate Strings with ranges of repeating sub-strings:

Generate Strings with three alpha chars and one numeric chars:

String.generate([:alpha, 3], :numeric) do |password|
  puts password
end

Generate Strings with two to four alpha chars:

String.generate([:alpha, 2..4]) do |password|
  puts password
end

Generate Strings using alpha and punctuation chars:

String.generate([Chars.alpha + Chars.punctuation, 4]) do |password|
  puts password
end

Generate Strings from a custom char set:

String.generate([['a', 'b', 'c'], 3], [['1', '2', '3'], 3]) do |password|
  puts password
end

Generate Strings containing known Strings:

String.generate("rock", [:numeric, 4]) do |password|
  puts password
end

Generate Strings with ranges of repeating sub-strings:

String.generate(['/AA', (1..100).step(5)]) do |path|
  puts path
end

Yields:

  • (string)

    The given block will be passed each unique String.

Yield Parameters:

  • string (String)

    A newly generated String.

Raises:

  • (ArgumentError)

    A given character set name was unknown.

  • (TypeError)

    A given string set was not a String, Symbol or Enumerable. A given string set length was not an Integer or Enumerable.

Since:

  • 0.3.0



88
89
90
# File 'lib/ronin/fuzzing/extensions/string.rb', line 88

def self.generate(*fields,&block)
  Ronin::Fuzzing::Template.new(fields).each(&block)
end

Instance Method Details

- (String) base64_decode(mode = nil)

Note:

mode argument is only available on Ruby >= 1.9.

Base64 decodes a string.

Examples:

"aGVsbG8=\n".base64_decode
# => "hello"


255
256
257
258
259
260
261
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 255

def base64_decode(mode=nil)
  case mode
  when :strict        then Base64.strict_decode64(self)
  when :url, :urlsafe then Base64.urlsafe_decode64(self)
  else                     Base64.decode64(self)
  end
end

- (String) base64_encode(mode = nil)

Base64 encodes a string.

Examples:

"hello".base64_encode
# => "aGVsbG8=\n"


225
226
227
228
229
230
231
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 225

def base64_encode(mode=nil)
  case mode
  when :strict        then Base64.strict_encode64(self)
  when :url, :urlsafe then Base64.urlsafe_encode64(self)
  else                     Base64.encode64(self)
  end
end

- (Object) common_postfix(other)

Deprecated.

Deprecates as of 0.2.0, and will be removed in 1.0.0. Please use #common_suffix instead.



170
171
172
173
174
175
# File 'lib/ronin/extensions/string.rb', line 170

def common_postfix(other)
  warn 'DEPRECATED: String#common_postfix was deprecated in 0.2.0.'
  warn 'DEPRECATED: Please use String#common_suffix instead.'

  common_suffix(other)
end

- (String) common_prefix(other)

The common prefix of the string and the specified other string.



125
126
127
128
129
130
131
132
133
134
135
# File 'lib/ronin/extensions/string.rb', line 125

def common_prefix(other)
  min_length = [length, other.length].min

  min_length.times do |i|
    if self[i] != other[i]
      return self[0,i]
    end
  end

  return self[0,min_length]
end

- (String) common_suffix(other)

Finds the common suffix of the string and the specified other string.

Since:

  • 0.2.0



150
151
152
153
154
155
156
157
158
159
160
161
162
163
# File 'lib/ronin/extensions/string.rb', line 150

def common_suffix(other)
  min_length = [length, other.length].min

  (min_length - 1).times do |i|
    index       = (length - i - 1)
    other_index = (other.length - i - 1)

    if self[index] != other[other_index]
      return self[(index + 1)..-1]
    end
  end

  return ''
end

- (Integer) depack(arch, address_length = nil)

Deprecated.

Deprecated as of 0.5.0, use #unpack instead.

Unpacks the String into an Integer.

Examples:

using archs other than Ronin::Arch:

arch = OpenStruct.new(:endian => :little, :address_length => 4)

"A\0\0\0".depack(arch)
# => 65

using a Ronin::Arch arch:

"A\0\0\0".depack(Arch.i386)
# => 65

specifying a custom address-length:

"A\0".depack(Arch.ppc,2)
# => 65

using a String#unpack template:

"A\0\0\0".depack('V')
# => 65

Raises:

  • (ArgumentError)

    The given arch does not respond to the endian or address_length methods.



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 110

def depack(arch,address_length=nil)
  if arch.kind_of?(String)
    return unpack(arch)
  end

  unless arch.respond_to?(:address_length)
    raise(ArgumentError,"first argument to Ineger#pack must respond to address_length")
  end

  unless arch.respond_to?(:endian)
    raise(ArgumentError,"first argument to Ineger#pack must respond to endian")
  end

  endian           = arch.endian.to_sym
  address_length ||= arch.address_length

  integer    = 0x0
  byte_index = 0

  case endian
  when :little
    mask = lambda { |b| b << (byte_index * 8) }
  when :big
    mask = lambda { |b|
      b << ((address_length - byte_index - 1) * 8)
    }
  else
    raise(ArgumentError,"invalid endian #{arch.endian.inspect}")
  end

  each_byte do |b|
    break if byte_index >= address_length

    integer |= mask.call(b)
    byte_index += 1
  end

  return integer
end

- (String) dump Also known as: inspect, escape

Note:

This method is only defined on Ruby 1.8.x.

Dumps the string as a C-style string.

Examples:

"hello\x00\073\x90\r\n".dump
# => "hello\0;\x90\r\n"


230
231
232
233
234
235
# File 'lib/ronin/extensions/string.rb', line 230

def dump
  dumped_string = ''

  each_byte { |b| dumped_string << ESCAPE_BYTES[b] }
  return "\"#{dumped_string}\""
end

- (String) each_substring(min = 1) {|substring, (index)| ... }

Enumerates over every sub-string within the string.

Examples:

"hello".each_substring(3).to_a
# => ["hel", "hell", "hello", "ell", "ello", "llo"]

Yields:

  • (substring, (index))

    The given block will receive every sub-string contained within the string. If the block accepts two arguments, then the index of the sub-string will also be passed in.

Yield Parameters:

  • substring (String)

    A sub-string from the string.

  • index (Integer)

    The optional index of the sub-string.



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# File 'lib/ronin/extensions/string.rb', line 48

def each_substring(min=1,&block)
  return enum_for(__method__,min) unless block

  (0..(length - min)).each do |i|
    ((i + min)..length).each do |j|
      sub_string = self[i...j]

      if block.arity == 2
        block.call(sub_string,i)
      else
        block.call(sub_string)
      end
    end
  end

  return self
end

- (String) each_unique_substring(min = 1) {|substring, (index)| ... }

Enumerates over the unique sub-strings contained in the string.

Examples:

"xoxo".each_unique_substring(2).to_a
# => ["xo", "xox", "xoxo", "ox", "oxo"]

Yields:

  • (substring, (index))

    The given block will receive every unique sub-string contained within the string. If the block accepts two arguments, then the index of the unique sub-string will also be passed in.

Yield Parameters:

  • substring (String)

    A unique sub-string from the string.

  • index (Integer)

    The optional index of the unique sub-string.

See Also:

  • each_substring


94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
# File 'lib/ronin/extensions/string.rb', line 94

def each_unique_substring(min=1,&block)
  return enum_for(__method__,min) unless block

  unique_strings = {}

  each_substring(min) do |sub_string,index|
    unless unique_strings.has_key?(sub_string)
      unique_strings[sub_string] = index

      if block.arity == 2
        block.call(sub_string,index)
      else
        block.call(sub_string)
      end
    end
  end

  return self
end

- (String) format_bytes(options = {}) {|byte| ... }

Creates a new String by formatting each byte.

Examples:

"hello".format_bytes { |b| "%x" % b }
# => "68656c6c6f"

Options Hash (options):

  • :include (#include?) — default: 0x00..0xff

    The bytes to format.

  • :exclude (#include?)

    The bytes not to format.

Yields:

  • (byte)

    The block which will return the formatted version of each byte within the String.

Yield Parameters:

  • byte (Integer)

    The byte to format.



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
# File 'lib/ronin/formatting/extensions/text/string.rb', line 52

def format_bytes(options={})
  included  = (options[:include] || (0x00..0xff))
  excluded  = (options[:exclude] || Set[])
  formatted = ''

  each_byte do |b|
    formatted << if (included.include?(b) && !excluded.include?(b))
                   yield(b)
                 else
                   b
                 end
  end

  return formatted
end

- (String) format_chars(options = {}) {|char| ... }

Creates a new String by formatting each character.

Examples:

"hello".format_chars { |c| c * 3 }
# => "hhheeellllllooo"

Options Hash (options):

  • :include (#include?, Regexp) — default: /./m

    The bytes to format.

  • :exclude (#include?, Regexp)

    The bytes not to format.

Yields:

  • (char)

    The block which will return the formatted version of each character within the String.

Yield Parameters:

  • char (String)

    The character to format.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
# File 'lib/ronin/formatting/extensions/text/string.rb', line 96

def format_chars(options={})
  included  = (options[:include] || /./m)
  excluded  = (options[:exclude] || Set[])
  formatted = ''

  matches = lambda { |filter,c|
    if    filter.respond_to?(:include?) then filter.include?(c)
    elsif filter.kind_of?(Regexp)       then c =~ filter
    end
  }

  each_char do |c|
    formatted << if (matches[included,c] && !matches[excluded,c])
                   yield(c)
                 else
                   c
                 end
  end

  return formatted
end

- (String) format_html(options = {})

Formats the chars in the String for HTML.

Examples:

"abc".format_html
# => "&#97;&#98;&#99;"

See Also:

Since:

  • 0.2.0



97
98
99
100
101
102
103
104
# File 'lib/ronin/formatting/extensions/html/string.rb', line 97

def format_html(options={})
  # String#ord was not backported to Ruby 1.8.7
  formatter = if RUBY_VERSION < '1.9.' then lambda { |c| c[0].format_html  }
              else                          lambda { |c| c.ord.format_html }
              end

  format_chars(options,&formatter)
end

- (String) format_http(options = {})

Formats the bytes of the String.

Examples:

"hello".format_http
# => "%68%65%6c%6c%6f"

See Also:



106
107
108
# File 'lib/ronin/formatting/extensions/http/string.rb', line 106

def format_http(options={})
  format_bytes(options) { |b| b.format_http }
end

- (String) format_js(options = {})

Escapes a String for JavaScript.

Examples:

"hello".js_escape
# => "\\u0068\\u0065\\u006C\\u006C\\u006F"

See Also:

Since:

  • 0.2.0



185
186
187
188
189
190
191
192
# File 'lib/ronin/formatting/extensions/html/string.rb', line 185

def format_js(options={})
  # String#ord was not backported to Rub 1.8.7
  formatter = if RUBY_VERSION < '1.9.' then lambda { |c| c[0].format_js  }
              else                          lambda { |c| c.ord.format_js }
              end

  format_chars(options,&formatter)
end

- (Enumerator) fuzz(substitutions = {}) {|fuzz| ... }

Incrementally fuzzes the String.

Examples:

Replace every e, i, o, u with (, 100 As and a \0:

"the quick brown fox".fuzz(/[eiou]/ => ['(', ('A' * 100), "\0"]) do |str|
  p str
end

"GET /".fuzz('/' => String.generate(['A', 1..100])) do |str|
  p str
end

Replace a Regexp::UNIX_PATH with Ronin::Fuzzing#format_strings:

"GET /downloads/".fuzz(:unix_path => :format_string)

Yields:

  • (fuzz)

    The given block will be passed every fuzzed String.

Yield Parameters:

  • fuzz (String)

    A fuzzed String.

Since:

  • 0.3.0



173
174
175
# File 'lib/ronin/fuzzing/extensions/string.rb', line 173

def fuzz(substitutions={},&block)
  Ronin::Fuzzing::Fuzzer.new(substitutions).each(self,&block)
end

- (String) hex_escape(options = {})

Hex-escapes characters in the String.

Examples:

"hello".hex_escape
# => "\\x68\\x65\\x6c\\x6c\\x6f"

See Also:



164
165
166
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 164

def hex_escape(options={})
  format_bytes(options) { |b| b.hex_escape }
end

- (String) html_escape

HTML escapes the String.

Examples:

"one & two".html_escape
# => "one &amp; two"

See Also:

Since:

  • 0.2.0



54
55
56
# File 'lib/ronin/formatting/extensions/html/string.rb', line 54

def html_escape
  CGI.escapeHTML(self)
end

- (String) html_unescape

Unescapes the HTML encoded String.

Examples:

"&lt;p&gt;one &lt;span&gt;two&lt;/span&gt;&lt;/p&gt;".html_unescape
# => "<p>one <span>two</span></p>"

See Also:

Since:

  • 0.2.0



74
75
76
# File 'lib/ronin/formatting/extensions/html/string.rb', line 74

def html_unescape
  CGI.unescapeHTML(self)
end

- (String) insert_after(pattern, data)

Inserts data after the occurrence of a pattern.



186
187
188
189
190
191
192
193
194
195
196
197
# File 'lib/ronin/formatting/extensions/text/string.rb', line 186

def insert_after(pattern,data)
  string = dup
  match  = string.match(pattern)

  if match
    index = match.end(match.length - 1)

    string.insert(index,data)
  end

  return string
end

- (String) insert_before(pattern, data)

Inserts data before the occurrence of a pattern.



164
165
166
167
168
169
170
# File 'lib/ronin/formatting/extensions/text/string.rb', line 164

def insert_before(pattern,data)
  string = dup
  index  = string.index(pattern)

  string.insert(index,data) if index
  return string
end

- (String) js_escape(options = {})

Escapes a String for JavaScript.

Examples:

"hello\nworld\n".js_escape
# => "hello\\nworld\\n"

See Also:

Since:

  • 0.2.0



125
126
127
128
129
130
131
132
# File 'lib/ronin/formatting/extensions/html/string.rb', line 125

def js_escape(options={})
  # String#ord was not backported to Rub 1.8.7
  formatter = if RUBY_VERSION < '1.9.' then lambda { |c| c[0].js_escape  }
              else                          lambda { |c| c.ord.js_escape }
              end

  format_chars(options,&formatter)
end

- (String) js_unescape

Unescapes a JavaScript escaped String.

Examples:

"\\u0068\\u0065\\u006C\\u006C\\u006F world".js_unescape
# => "hello world"

Since:

  • 0.2.0



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
# File 'lib/ronin/formatting/extensions/html/string.rb', line 148

def js_unescape
  unescaped = ''

  scan(/[\\%]u[0-9a-fA-F]{1,4}|[\\%][0-9a-fA-F]{1,2}|\\[btnfr"\\]|./) do |c|
    unescaped << JS_BACKSLASHED_CHARS.fetch(c) do
      if (c.start_with?("\\u") || c.start_with?("%u"))
        c[2..-1].to_i(16)
      elsif (c.start_with?("\\") || c.start_with?("%"))
        c[1..-1].to_i(16)
      else
        c
      end
    end
  end

  return unescaped
end

- (String) md5

Returns The MD5 checksum of the String.

Examples:

"hello".md5
# => "5d41402abc4b2a76b9719d911017c592"


36
37
38
# File 'lib/ronin/formatting/extensions/digest/string.rb', line 36

def md5
  Digest::MD5.hexdigest(self)
end

- (Enumerator) mutate(mutations = {}) {|mutant| ... }

Permutes over every possible mutation of the String.

Examples:

"hello old dog".mutate('e' => ['3'], 'l' => ['1'], 'o' => ['0']) do |str|
  puts str
end

Yields:

  • (mutant)

    The given block will be yielded every possible mutant String.

Yield Parameters:

  • mutant (String)

    A mutated String.

Raises:

  • (TypeError)

    A mutation pattern was not a Regexp, String or Symbol. A mutation substitution was not a Symbol or Enumerable.

Since:

  • 0.4.0



205
206
207
# File 'lib/ronin/fuzzing/extensions/string.rb', line 205

def mutate(mutations={},&block)
  Ronin::Fuzzing::Mutator.new(mutations).each(self,&block)
end

- (String) pad(padding, max_length = length)

Creates a new String by padding the String with repeating text, out to a specified length.

Examples:

"hello".pad('A',50)
# => "helloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"


218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
# File 'lib/ronin/formatting/extensions/text/string.rb', line 218

def pad(padding,max_length=length)
  padding = padding.to_s

  if max_length > length
    max_length -= length
  else
    max_length = 0
  end

  padded = self + (padding * (max_length / padding.length))

  unless (remaining = (max_length % padding.length)) == 0
    padded << padding[0,remaining]
  end

  return padded
end

- (Object) random_case(options = {})

Creates a new String by randomizing the case of each character in the String.

Examples:

"get out your checkbook".random_case
# => "gEt Out YOur CHEckbook"

Options Hash (options):

  • :include (Array, Range) — default: 0x00..0xff

    The bytes to format.

  • :exclude (Array, Range)

    The bytes not to format.

  • :probability (Float) — default: 0.5

    The probability that a character will have it's case changed.



140
141
142
143
144
145
146
147
148
# File 'lib/ronin/formatting/extensions/text/string.rb', line 140

def random_case(options={})
  prob = (options[:probability] || 0.5)

  format_chars(options) do |c|
    if rand <= prob then c.swapcase 
    else                 c
    end
  end
end

- (Enumerator) repeating(lengths) {|repeated| ... }

Repeats the String.

Examples:

'A'.repeating(100)
# => "AAAAAAAAAAAAA..."

Generates 100 upto 700 As, increasing by 100 at a time:

'A'.repeating((100..700).step(100)) do |str|
  # ...
end

Generates 128, 1024, 65536 As:

'A'.repeating([128, 1024, 65536]) do |str|
  # ...
end

Yields:

  • (repeated)

    The given block will be passed every repeated String.

Yield Parameters:

  • repeated (String)

    A repeated version of the String.

Raises:

  • (TypeError)

    n must either be Enumerable or an Integer.

Since:

  • 0.4.0



128
129
130
131
132
133
134
135
136
137
138
139
# File 'lib/ronin/fuzzing/extensions/string.rb', line 128

def repeating(lengths,&block)
  case lengths
  when Integer
    # if lengths is an Integer, simply multiply the String and return
    repeated = (self * lengths)

    yield repeated if block_given?
    return repeated
  else
    return Ronin::Fuzzing::Repeater.new(lengths).each(self,&block)
  end
end

- (String) sha1 Also known as: sha128

Returns The SHA1 checksum of the String.

Examples:

"hello".sha1
# => "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d"


50
51
52
# File 'lib/ronin/formatting/extensions/digest/string.rb', line 50

def sha1
  Digest::SHA1.hexdigest(self)
end

- (String) sha256 Also known as: sha2

Returns The SHA2 checksum of the String.

Examples:

"hello".sha2
# => "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"


66
67
68
# File 'lib/ronin/formatting/extensions/digest/string.rb', line 66

def sha256
  Digest::SHA256.hexdigest(self)
end

- (String) sha512

Returns The SHA512 checksum of the String.

Examples:

"hello".sha512
# => "9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043"


82
83
84
# File 'lib/ronin/formatting/extensions/digest/string.rb', line 82

def sha512
  Digest::SHA512.hexdigest(self)
end

- (Object) sql_decode

Returns the SQL decoded form of the String.

Examples:

"'Conan O''Brian'".sql_decode
# => "Conan O'Brian"
"0x2f6574632f706173737764".sql_decode
# => "/etc/passwd"


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
# File 'lib/ronin/formatting/extensions/sql/string.rb', line 82

def sql_decode
  if (start_with?('0x') && (length % 2 == 0))
    raw = ''

    self[2..-1].scan(/../) do |hex_char|
      raw << hex_char.to_i(16).chr
    end

    return raw
  elsif (start_with?("'") && end_with?("'"))
    self[1..-2].gsub(/\\'|''/,"'")
  else
    return self
  end
end

- (Object) sql_encode

Returns the SQL hex-string encoded form of the String.

Examples:

"/etc/passwd".sql_encode
# => "0x2f6574632f706173737764"


59
60
61
62
63
64
65
66
67
68
69
# File 'lib/ronin/formatting/extensions/sql/string.rb', line 59

def sql_encode
  return '' if empty?

  hex_string = '0x'

  each_byte do |b|
    hex_string << ('%.2x' % b)
  end

  return hex_string
end

- (String) sql_escape(quotes = :single)

Escapes an String for SQL.

Examples:

"O'Brian".sql_escape
# => "'O''Brian'"

Raises:

  • (ArgumentError)

    The quotes argument was neither :single nor :double.

Since:

  • 0.3.0



40
41
42
43
44
45
46
47
48
49
50
# File 'lib/ronin/formatting/extensions/sql/string.rb', line 40

def sql_escape(quotes=:single)
  char = case quotes
         when :single then "'"
         when :double then '"'
         when :tick   then '`'
         else
           raise(ArgumentError,"invalid quoting style #{quotes.inspect}")
         end

  return char + gsub(char,char * 2) + char
end

- (String) sql_inject

Prepares the String for injection into a SQL expression.

Examples:

"'1' OR '1'='1'".sql_inject
# => "1' OR '1'='1"
"'1' OR 1=1".sql_inject
# => "1' OR 1=1 OR '"
"'1' OR 1=1".sql_inject(:terminate => true)
# => "1' OR 1=1 --"

Since:

  • 0.4.0



120
121
122
123
124
125
126
127
128
# File 'lib/ronin/formatting/extensions/sql/string.rb', line 120

def sql_inject
  if (start_with?("'") || start_with?('"') || start_with?('`'))
    if self[0,1] == self[-1,1] then self[1..-2]
    else                            "#{self[1..-1]}--"
    end
  else
    self
  end
end

- (String) uncommon_substring(other)

Finds the uncommon sub-string within the specified other string, which does not occur within the string.



189
190
191
192
193
194
# File 'lib/ronin/extensions/string.rb', line 189

def uncommon_substring(other)
  prefix  = common_prefix(other)
  postfix = self[prefix.length..-1].common_suffix(other[prefix.length..-1])

  return self[prefix.length...(length - postfix.length)]
end

- (String) unescape Also known as: hex_unescape

Unescapes the escaped String.

Examples:

"\\x68\\x65\\x6c\\x6c\\x6f".unescape
# => "hello"

Since:

  • 0.5.0



269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
# File 'lib/ronin/formatting/extensions/text/string.rb', line 269

def unescape
  buffer     = ''
  hex_index  = 0
  hex_length = length

  while (hex_index < hex_length)
    hex_substring = self[hex_index..-1]

    if hex_substring =~ /^\\[0-7]{3}/
      buffer    << hex_substring[0,4].to_i(8)
      hex_index += 3
    elsif hex_substring =~ /^\\x[0-9a-fA-F]{1,2}/
      hex_substring[2..-1].scan(/^[0-9a-fA-F]{1,2}/) do |hex_byte|
        buffer    << hex_byte.to_i(16)
        hex_index += (2 + hex_byte.length)
      end
    elsif hex_substring =~ /^\\./
      buffer    << UNESCAPE_CHARS[hex_substring[0,2]]
      hex_index += 2
    else
      buffer    << hex_substring[0,1]
      hex_index += 1
    end
  end

  return buffer
end

- (String) unhexdump(options = {})

Converts a multitude of hexdump formats back into raw-data.

Options Hash (options):

  • :format (Symbol)

    The expected format of the hexdump. Must be either :od or :hexdump.

  • :encoding (Symbol)

    Denotes the encoding used for the bytes within the hexdump. Must be one of the following:

    • :binary
    • :octal
    • :octal_bytes
    • :octal_shorts
    • :octal_ints
    • :octal_quads (Ruby 1.9 only)
    • :decimal
    • :decimal_bytes
    • :decimal_shorts
    • :decimal_ints
    • :decimal_quads (Ruby 1.9 only)
    • :hex
    • :hex_chars
    • :hex_bytes
    • :hex_shorts
    • :hex_ints
    • :hex_quads
    • :named_chars (Ruby 1.9 only)
    • :floats
    • :doubles
  • :endian (:little, :big, :network) — default: :little

    The endianness of the words.

  • :segment (Integer) — default: 16

    The length in bytes of each segment in the hexdump.



341
342
343
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 341

def unhexdump(options={})
  Ronin::Binary::Hexdump::Parser.new(options).parse(self)
end

- (Array) unpack(*arguments)

Unpacks the String.

Examples:

"A\0\0\0hello\0".unpack(:uint32_le, :string)
# => [10, "hello"]

using a String#unpack template:

"A\0\0\0".unpack('V')
# => 65

Raises:

See Also:

Since:

  • 0.5.0



63
64
65
66
67
68
69
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 63

def unpack(*arguments)
  if (arguments.length == 1 && arguments.first.kind_of?(String))
    unpack_original(arguments.first)
  else
    unpack_original(Ronin::Binary::Template.compile(arguments))
  end
end

- (Object) unpack_original



34
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 34

alias unpack_original unpack

- (String) uri_decode

URI decodes the String.

Examples:

"genre%3f".uri_decode
# => "genre?"


56
57
58
# File 'lib/ronin/formatting/extensions/http/string.rb', line 56

def uri_decode
  URI.decode(self)
end

- (String) uri_encode

URI encodes the String.

Examples:

"art is graffiti".uri_encode
# => "art%20is%20graffiti"


40
41
42
# File 'lib/ronin/formatting/extensions/http/string.rb', line 40

def uri_encode
  URI.encode(self)
end

- (String) uri_escape

URI escapes the String.

Examples:

"x > y".uri_escape
# => "x+%3E+y"


72
73
74
# File 'lib/ronin/formatting/extensions/http/string.rb', line 72

def uri_escape
  CGI.escape(self)
end

- (String) uri_unescape

URI unescapes the String.

Examples:

"sweet+%26+sour".uri_unescape
# => "sweet & sour"


88
89
90
# File 'lib/ronin/formatting/extensions/http/string.rb', line 88

def uri_unescape
  CGI.unescape(self)
end

- (String) xor(key)

XOR encodes the String.

Examples:

"hello".xor(0x41)
# => ")$--."
"hello again".xor([0x55, 0x41, 0xe1])
# => "=$\x8d9.\xc14&\x80</"


189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 189

def xor(key)
  key = case key
        when Integer then [key]
        when String  then key.bytes
        else              key
        end

  key    = key.cycle
  result = ''

  bytes.each do |b|
    result << (b ^ key.next).chr
  end

  return result
end

- (String) zlib_deflate

Zlib deflate a string.

Examples:

"hello".zlib_deflate
# => "x\x9C\xCBH\xCD\xC9\xC9\a\x00\x06,\x02\x15"


291
292
293
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 291

def zlib_deflate
  Zlib::Deflate.deflate(self)
end

- (String) zlib_inflate

Zlib inflate a string.

Examples:

"x\x9C\xCBH\xCD\xC9\xC9\a\x00\x06,\x02\x15".zlib_inflate
# => "hello"


275
276
277
# File 'lib/ronin/formatting/extensions/binary/string.rb', line 275

def zlib_inflate
  Zlib::Inflate.inflate(self)
end