Class: String

Inherits:
Object
  • Object
show all
Defined in:
lib/ctf_party/cgi.rb,
lib/ctf_party/dec.rb,
lib/ctf_party/hex.rb,
lib/ctf_party/rot.rb,
lib/ctf_party/case.rb,
lib/ctf_party/flag.rb,
lib/ctf_party/leet.rb,
lib/ctf_party/base64.rb,
lib/ctf_party/binary.rb,
lib/ctf_party/digest.rb

Constant Summary collapse

@@flag =

The flag configuration hash. See flag=.

{
  prefix: '',
  suffix: '',
  enclosing: ['{', '}'],
  digest: nil
}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.flag ⇒ Object

Show the actual flag configuration. See flag=.



15
16
17
 
# File 'lib/ctf_party/flag.rb', line 15

def self.flag
  @@flag
end

.flag=(hash) ⇒ Hash

Note:

You can provide the full hash or only the key to update.

Update the flag configuration.

Examples:

String.flag # => {:prefix=>"", :suffix=>"", :enclosing=>["{", "}"], :digest=>nil}
String.flag = {prefix: 'sigsegv', digest: 'md5'}
String.flag # => {:prefix=>"sigsegv", :suffix=>"", :enclosing=>["{", "}"], :digest=>"md5"}
'this_1s_a_fl4g'.flag # => "sigsegv{a5bec9e2a86b6b70d288451eb38dfec8}"

Parameters:

  • hash (Hash) —

    flag configuration

Options Hash (hash):

  • :prefix (String) —

    prefix of the flag. Default: none.

  • :suffix (String) —

    suffix of the flag. Default: none.

  • :enclosing (Array<String>) —

    the characters used to surround the flag. Default are curly braces: {, }. The array must contain exactly 2 elements.

  • :digest (String) —

    the hash algorithm to apply on the flag. Default: none. Allowed values: md5, sha1, sha2_256, sha2_384, sha2_512, rmd160.

Returns:

  • (Hash) —

    hash of the updated options.



36
37
38
39
 
# File 'lib/ctf_party/flag.rb', line 36

def self.flag=(hash)
  hash.select! { |k, _v| @@flag.key?(k) }
  @@flag.merge!(hash)
end

Instance Method Details

#alternatecase(shift = 0) ⇒ String

Change one characte on two upcase and the other downcase

Examples:

'SELECT * FROM'.alternatecase # => "sElEcT * FrOm"
'SELECT * FROM'.alternatecase(1) # => "SeLeCt * fRoM"

Parameters:

  • shift (Integer) (defaults to: 0) —

    0: 1st character will be downcase, 1: 1st character will be upcase

Returns:

  • (String) —

    the case modified string



26
27
28
 
# File 'lib/ctf_party/case.rb', line 26

def alternatecase(shift = 0)
  chars.each_with_index.map { |c, i| (i + shift).even? ? c.downcase : c.upcase }.join
end

#alternatecase!(shift = 0) ⇒ Object

Change one characte on two upcase and the other downcase in place as described for #alternatecase.



32
33
34
 
# File 'lib/ctf_party/case.rb', line 32

def alternatecase!(shift = 0)
  replace(alternatecase(shift))
end

#b64?(opts = {}) ⇒ Boolean

Is the string encoded in base64?

Examples:

'SGVsbG8gd29ybGQh'.b64? # => true
'SGVsbG8g@@d29ybGQh'.b64? # => false

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :mode (Symbol) —

    Default value: :strict. Other values are :strict (:rfc4648) or :urlsafe.

Returns:

  • (Boolean) —

    true if the string is a valid base64 string, false else.

See Also:



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/ctf_party/base64.rb', line 69

def b64?(opts = {})
  opts[:mode] ||= :strict
  b64 = false
  # https://www.rexegg.com/regex-ruby.html
  reg1 = %r{\A(?:[a-zA-Z0-9+/]{4})*(?:|(?:[a-zA-Z0-9+/]{3}=)|
            (?:[a-zA-Z0-9+/]{2}==)|(?:[a-zA-Z0-9+/]{1}===))\Z}xn
  reg3 = /\A(?:[a-zA-Z0-9\-_]{4})*(?:|(?:[a-zA-Z0-9\-_]{3}=)|
          (?:[a-zA-Z0-9\-_]{2}==)|(?:[a-zA-Z0-9\-_]{1}===))\Z/xn
  case opts[:mode]
  when :strict, :rfc4648
    b64 = true if reg1.match?(self)
  when :rfc2045
    b64 = true
    split("\n").each do |s|
      b64 = false unless reg1.match?(s)
    end
  when :urlsafe
    b64 = true if reg3.match?(self)
  else
    raise ArgumentError 'Wrong mode'
  end
  return b64
end

#bin2hex(opts = {}) ⇒ String

Encode an binary string to a hexadecimal string

Examples:

'11110011'.bin2hex # => "f3"
'11110011'.bin2hex({prefix: '0x', case: :upper}) # => "0xF3"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the output. Default value is a void string. Example of values: 0x, \x.

  • :case (Symbol) —

    Char case of the ouput. Default value :lower. Other valid value :upper.

Returns:

  • (String) —

    the hexadecimal encoded string



197
198
199
200
201
202
203
204
205
206
 
# File 'lib/ctf_party/hex.rb', line 197

def bin2hex(opts = {})
  opts[:prefix] ||= ''
  opts[:case] ||= :lower
  # convert
  out = to_i(2).to_s(16)
  # char case management
  out = out.upcase if opts[:case] == :upper
  # adding prefix must be done after case change
  return opts[:prefix] + out
end

#bin2hex!(opts = {}) ⇒ Object

Encode an binary string to a hexadecimal string in place as described for #bin2hex.

Examples:

a = '11110011'
a.bin2hex!
a # => "f3"



214
215
216
 
# File 'lib/ctf_party/hex.rb', line 214

def bin2hex!(opts = {})
  replace(bin2hex(opts))
end

#bin2str(opts = {}) ⇒ Object

Alias for #from_bin.



59
60
61
 
# File 'lib/ctf_party/binary.rb', line 59

def bin2str(opts = {})
  from_bin(opts)
end

#bin2str!(opts = {}) ⇒ Object

Alias for #from_bin!.



74
75
76
 
# File 'lib/ctf_party/binary.rb', line 74

def bin2str!(opts = {})
  from_bin!(opts)
end

#dec2hex(opts = {}) ⇒ String

Encode an decimal string to a hexadecimal string

Examples:

'255'.dec2hex # => "ff"
'255'.dec2hex({prefix: '0x', case: :upper}) # => "0xFF"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the output. Default value is a void string. Example of values: 0x, \x.

  • :case (Symbol) —

    Char case of the ouput. Default value :lower. Other valid value :upper.

  • :padding (Symbol) —

    Minimum size of the hexadecimal display (number of characters). Eg. 10 -> 0xA or 0x0A

Returns:

  • (String) —

    the hexadecimal encoded string



42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/ctf_party/hex.rb', line 42

def dec2hex(opts = {})
  opts[:prefix] ||= ''
  opts[:case] ||= :lower
  opts[:padding] ||= 1
  # convert
  out = to_i.to_s(16)
  # padding
  out = ('0' * (opts[:padding] - 1)) + out if out.size < opts[:padding]
  # char case management
  out = out.upcase if opts[:case] == :upper
  # adding prefix must be done after case change
  return opts[:prefix] + out
end

#dec2hex!(opts = {}) ⇒ Object

Encode an decimal string to a hexadecimal string in place as described for #dec2hex.

Examples:

a = '255'
a.dec2hex!
a # => "ff"



62
63
64
 
# File 'lib/ctf_party/hex.rb', line 62

def dec2hex!(opts = {})
  replace(dec2hex(opts))
end

#dec2str ⇒ Object

Alias for #from_dec.



41
42
43
 
# File 'lib/ctf_party/dec.rb', line 41

def dec2str
  from_dec
end

#dec2str! ⇒ Object

Alias for #from_dec!.



46
47
48
 
# File 'lib/ctf_party/dec.rb', line 46

def dec2str!
  replace(dec2str)
end

#flag ⇒ String

Format the current string into the configured flag format. See flag= example.

Returns:

  • (String) —

    the format flag.



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/ctf_party/flag.rb', line 44

def flag
  flag = ''
  flag += @@flag[:prefix]
  flag += @@flag[:enclosing][0]
  if @@flag[:digest].nil?
    flag += self
  else
    case @@flag[:digest]
    when 'md5'
      flag += md5
    when 'sha1'
      flag += sha1
    when 'sha2_256'
      flag += sha2_256
    when 'sha2_384'
      flag += sha2_384
    when 'sha2_512'
      flag += sha2_512
    when 'rmd160'
      flag += rmd160
    end
  end
  flag += @@flag[:enclosing][1]
  flag + @@flag[:suffix]
end

#flag! ⇒ Object

Format the current string into the configured flag format in place as described for #flag.



72
73
74
 
# File 'lib/ctf_party/flag.rb', line 72

def flag!
  replace(flag)
end

#flag? ⇒ Boolean

Check if the string respect the defined flag format.

Examples:

String.flag = {prefix: 'flag'}
flag = 'Brav0!'
flag.flag! # => "flag{Brav0!}"
flag.flag? # => true
flag = 'ctf{Brav0!}'
flag.flag? # => false

Returns:

  • (Boolean) —

    true if it respects the configured flag format. but it does not check digest used.



86
87
88
89
 
# File 'lib/ctf_party/flag.rb', line 86

def flag?
  /#{@@flag[:prefix]}#{@@flag[:enclosing][0]}[[:print:]]+
    #{@@flag[:enclosing][1]}#{@@flag[:suffix]}/ox.match?(self)
end

#from_b64(opts = {}) ⇒ String

Decode the string from base64

Examples:

'UnVieQ=='.from_b64 # => "Ruby"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :mode (Symbol) —

    Default value: :strict. Other values are :strict (:rfc4648) or :urlsafe.

Returns:

  • (String) —

    the Base64 decoded string

See Also:



41
42
43
44
45
46
47
 
# File 'lib/ctf_party/base64.rb', line 41

def from_b64(opts = {})
  opts[:mode] ||= :strict
  return Base64.strict_decode64(self) if opts[:mode] == :strict ||
                                         opts[:mode] == :rfc4648
  return Base64.decode64(self) if opts[:mode] == :rfc2045
  return Base64.urlsafe_decode64(self) if opts[:mode] == :urlsafe
end

#from_b64!(opts = {}) ⇒ nil

Decode the string from base64 in place as described for #from_b64.

Examples:

a = 'SGVsbG8gd29ybGQh' # => "SGVsbG8gd29ybGQh"
a.from_b64! # => nil
a # => "Hello world!"

Returns:

  • (nil) 


55
56
57
 
# File 'lib/ctf_party/base64.rb', line 55

def from_b64!(opts = {})
  replace(from_b64(opts))
end

#from_bin(opts = {}) ⇒ String

Decode a binary string

Examples:

'011000100110100101101110011000010111001001111001'.from_bin # => "binary"
'010001101001011001110110100001100100111010011110'.from_bin(bitnumbering: :LSB) # => "binary"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :bitnumbering (Symbol) —

    Display input with most significant bit first (:MSB default) or least significant bit first (:LSB).

Returns:

  • (String) —

    the binary decoded string



49
50
51
52
53
54
55
56
 
# File 'lib/ctf_party/binary.rb', line 49

def from_bin(opts = {})
  opts[:bitnumbering] ||= :MSB
  # convert
  return Array(self).pack('B*') if opts[:bitnumbering] == :MSB
  return Array(self).pack('b*') if opts[:bitnumbering] == :LSB

  raise ArgumentError ':bitnumbering expects :MSB or :LSB'
end

#from_bin!(opts = {}) ⇒ Object

Decode a binary string in place as described for #from_bin.

Examples:

a = "011000100110100101101110011000010111001001111001"
a.from_bin!
a # => "binary"



69
70
71
 
# File 'lib/ctf_party/binary.rb', line 69

def from_bin!(opts = {})
  replace(from_bin(opts))
end

#from_dec ⇒ String

Decode a decimal string (decimal to hexadecimal then hexadecimal to string)

Examples:

'1834615104613964215417'.from_dec # => "ctf-party"

Returns:

  • (String) —

    the decimal decoded string



21
22
23
 
# File 'lib/ctf_party/dec.rb', line 21

def from_dec
  dec2hex.hex2str
end

#from_dec! ⇒ Object

Decode a decimal string in place as described for #from_dec.



26
27
28
 
# File 'lib/ctf_party/dec.rb', line 26

def from_dec!
  replace(from_dec)
end

#from_hex(opts = {}) ⇒ String

Decode a hexadecimal string

Examples:

"6e6f72616a".from_hex # => "noraj"
"0x6e6f72616a".from_hex(prefix: '0x') # => "noraj"
"e6f62716a6".from_hex(nibble: :low) # => "noraj"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the input. Default value is a void string. Example of values: 0x, \x.

  • :nibble (Symbol) —

    Display input with high nibble first (:high default) or low nibble first (:low).

Returns:

  • (String) —

    the hexadecimal decoded string



129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/ctf_party/hex.rb', line 129

def from_hex(opts = {})
  opts[:prefix] ||= ''
  opts[:nibble] ||= :high
  # remove prefix
  out = sub(opts[:prefix], '')
  # convert
  return Array(out).pack('H*') if opts[:nibble] == :high
  return Array(out).pack('h*') if opts[:nibble] == :low

  raise ArgumentError ':nibble expects :high or :low'
end

#from_hex!(opts = {}) ⇒ Object

Decode a hexadecimal string in place as described for #from_hex.

Examples:

a = "6e6f72616a"
a.from_hex!
a # => "noraj"



152
153
154
 
# File 'lib/ctf_party/hex.rb', line 152

def from_hex!(opts = {})
  replace(from_hex(opts))
end

#from_hexip(opts = {}) ⇒ String

Decode a hexadecimal IP string into a dotted decimal one

Examples:

'0100007F'.from_hexip(nibble: :low) # => "127.0.0.1"
'0x7f000001'.from_hexip(prefix: '0x') # => "127.0.0.1"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the input. Default value is a void string. Example of values: 0x, \x.

  • :nibble (Symbol) —

    Display input with high nibble first (:high default) or low nibble first (:low, used on Unix /proc/net/tcp).

Returns:

  • (String) —

    the dotted decimal IP



228
229
230
231
232
233
234
235
236
237
 
# File 'lib/ctf_party/hex.rb', line 228

def from_hexip(opts = {})
  opts[:prefix] ||= ''
  opts[:nibble] ||= :high
  # remove prefix
  out = sub(opts[:prefix], '')
  # convert
  out = out.scan(/.{2}/).map(&:hex2dec)
  out = out.reverse if opts[:nibble] == :low
  out.join('.')
end

#from_hexip!(opts = {}) ⇒ Object

Decode a hexadecimal IP string into a dotted decimal one in place as described for #from_hexip.



241
242
243
 
# File 'lib/ctf_party/hex.rb', line 241

def from_hexip!(opts = {})
  replace(from_hexip(opts))
end

#hex2bin(opts = {}) ⇒ String

Encode an hexadecimal string to a binary string

Examples:

'ab'.hex2bin # => "10101011"
'\xf3'.hex2bin(prefix: '\x') # => "11110011"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the input. Default value is a void string. Example of values: 0x, \x.

Returns:

  • (String) —

    the binary encoded string



169
170
171
172
173
174
175
 
# File 'lib/ctf_party/hex.rb', line 169

def hex2bin(opts = {})
  opts[:prefix] ||= ''
  # remove prefix
  out = sub(opts[:prefix], '')
  # convert
  return out.to_i(16).to_s(2)
end

#hex2bin!(opts = {}) ⇒ Object

Encode an hexadecimal string to a binary string in place as described for #hex2bin.

Examples:

a = 'ff'
a.hex2bin!
a # => => "11111111"



183
184
185
 
# File 'lib/ctf_party/hex.rb', line 183

def hex2bin!(opts = {})
  replace(hex2bin(opts))
end

#hex2dec(opts = {}) ⇒ String

Encode an hexadecimal string to a decimal string

Examples:

'ff'.hex2dec # => "255"
'\xf3'.hex2dec(prefix: '\x') # => "243"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the input. Default value is a void string. Example of values: 0x, \x.

Returns:

  • (String) —

    the decimal encoded string



12
13
14
15
16
17
18
 
# File 'lib/ctf_party/hex.rb', line 12

def hex2dec(opts = {})
  opts[:prefix] ||= ''
  # remove prefix
  out = sub(opts[:prefix], '')
  # convert
  return out.hex.to_s
end

#hex2dec!(opts = {}) ⇒ Object

Encode an hexadecimal string to a decimal string in place as described for #hex2dec.

Examples:

a = 'ff'
a.hex2dec!
a # => "255"



26
27
28
 
# File 'lib/ctf_party/hex.rb', line 26

def hex2dec!(opts = {})
  replace(hex2dec(opts))
end

#hex2str(opts = {}) ⇒ Object

Alias for #from_hex.



142
143
144
 
# File 'lib/ctf_party/hex.rb', line 142

def hex2str(opts = {})
  from_hex(opts)
end

#hex2str!(opts = {}) ⇒ Object

Alias for #from_hex!.



157
158
159
 
# File 'lib/ctf_party/hex.rb', line 157

def hex2str!(opts = {})
  from_hex!(opts)
end

#htmlescape ⇒ String

HTML escape the string

Examples:

'Usage: foo "bar" <baz>'.htmlescape # => "Usage: foo &quot;bar&quot; &lt;baz&gt;"

Returns:

  • (String) —

    the HTML escaped string



37
38
39
 
# File 'lib/ctf_party/cgi.rb', line 37

def htmlescape
  CGI.escapeHTML self
end

#htmlescape! ⇒ Object

HTML escape the string in place as described for #htmlescape.



42
43
44
 
# File 'lib/ctf_party/cgi.rb', line 42

def htmlescape!
  replace(htmlescape)
end

#htmlunescape ⇒ String

HTML unescape the string

Examples:

"Usage: foo &quot;bar&quot; &lt;baz&gt;".htmlunescape # => "Usage: foo \"bar\" <baz>"

Returns:

  • (String) —

    the HTML unescaped string



50
51
52
 
# File 'lib/ctf_party/cgi.rb', line 50

def htmlunescape
  CGI.unescapeHTML self
end

#htmlunescape! ⇒ Object

HTML unescape the string in place as described for #htmlunescape.



55
56
57
 
# File 'lib/ctf_party/cgi.rb', line 55

def htmlunescape!
  replace(htmlunescape)
end

#leet ⇒ Object

Transform into leet speak (l337 5p34k)

Examples:

'The quick brown fox jumps over the lazy dog'.leet # => "7h3 qu1ck 8r0wn f0x jump5 0v3r 7h3 14zy d06"
'leet speak'.leet # => "1337 5p34k"



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/ctf_party/leet.rb', line 8

def leet
  tr = {
    'T' => '7',
    'E' => '3',
    'I' => '1',
    'L' => '1',
    'O' => '0',
    'S' => '5',
    'A' => '4',
    'G' => '6',
    'B' => '8'
  }
  tr.merge! tr.transform_keys(&:downcase)
  gsub(/[#{tr.keys.join}]/i, **tr)
end

#leet! ⇒ Object

Transform into leet speak (l337 5p34k) in place as described for #leet.



26
27
28
 
# File 'lib/ctf_party/leet.rb', line 26

def leet!
  replace(leet)
end

#md5 ⇒ String

Calculate the md5 hash of the string.

Examples:

'noraj'.md5 # => "556cc23863fef20fab5c456db166bc6e"

Returns:

See Also:



12
13
14
 
# File 'lib/ctf_party/digest.rb', line 12

def md5
  Digest::MD5.hexdigest self
end

#md5! ⇒ Object

Calculate the md5 hash of the string in place as described for #md5.

Examples:

a = '\o/' # => "\\o/"
a.md5! # => "881419964e480e66162da521ccc25ebf"
a # => "881419964e480e66162da521ccc25ebf"



21
22
23
 
# File 'lib/ctf_party/digest.rb', line 21

def md5!
  replace(md5)
end

#randomcase ⇒ String

Change the case of characters randomly

Examples:

'SELECT * FROM'.randomcase # => "SElECt * frOm"
'SELECT * FROM'.randomcase # => "selECT * FROm"

Returns:

  • (String) —

    the case modified string



9
10
11
 
# File 'lib/ctf_party/case.rb', line 9

def randomcase
  chars.map { |c| rand(0..1).zero? ? c.downcase : c.upcase }.join
end

#randomcase! ⇒ Object

Change the case of characters randomly in place as described for #randomcase.



15
16
17
 
# File 'lib/ctf_party/case.rb', line 15

def randomcase!
  replace(randomcase)
end

#rmd160 ⇒ String

Calculate the RIPEMD-160 hash of the string.

Examples:

'payload'.rmd160 # => "3c6255c112d409dafdb84d5b0edba98dfd27b44f"

Returns:

  • (String) —

    RIPEMD-160 hash

See Also:



104
105
106
 
# File 'lib/ctf_party/digest.rb', line 104

def rmd160
  Digest::RMD160.hexdigest self
end

#rmd160! ⇒ Object

Calculate the RIPEMD-160 hash of the string in place as described for #rmd160.

Examples:

pl = 'payload' # => "payload"
pl.rmd160! # => "3c6255c112d409dafdb84d5b0edba98dfd27b44f"
pl # => "3c6255c112d409dafdb84d5b0edba98dfd27b44f"



114
115
116
 
# File 'lib/ctf_party/digest.rb', line 114

def rmd160!
  replace(rmd160)
end

#rot(opts = {}) ⇒ String

“Encrypt / Decrypt” the string with Caesar cipher. This will shift the alphabet letters by n, where n is the integer key. The same function is used for encryption / decryption.

Examples:

'Hello world!'.rot # => "Uryyb jbeyq!"
'Hello world!'.rot(shift: 11) # => "Spwwz hzcwo!"
'Uryyb jbeyq!'.rot # => "Hello world!"
'Spwwz hzcwo!'.rot(shift: 26-11) # => "Hello world!"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :shift (Integer) —

    The shift key. Default value: 13.

Returns:

  • (String) —

    the (de)ciphered string

See Also:



16
17
18
19
20
21
22
23
24
 
# File 'lib/ctf_party/rot.rb', line 16

def rot(opts = {})
  opts[:shift] ||= 13
  alphabet = Array('a'..'z')
  lowercase = Hash[alphabet.zip(alphabet.rotate(opts[:shift]))]
  alphabet = Array('A'..'Z')
  uppercasecase = Hash[alphabet.zip(alphabet.rotate(opts[:shift]))]
  encrypter = lowercase.merge(uppercasecase)
  chars.map { |c| encrypter.fetch(c, c) }.join
end

#rot!(opts = {}) ⇒ String

“Encrypt / Decrypt” the string with Caesar cipher in place as described for #rot.

Examples:

a = 'Bonjour le monde !' # => "Bonjour le monde !"
a.rot! # => "Obawbhe yr zbaqr !"
a # => "Obawbhe yr zbaqr !"

Returns:

  • (String) —

    the (de)ciphered string as well as changing changing the object in place.



34
35
36
 
# File 'lib/ctf_party/rot.rb', line 34

def rot!(opts = {})
  replace(rot(opts))
end

#rot13 ⇒ Object

Alias for #rot with default value ( rot(shift: 13) ).



39
40
41
 
# File 'lib/ctf_party/rot.rb', line 39

def rot13
  rot
end

#rot13! ⇒ Object

Alias for #rot! with default value ( rot!(shift: 13) ).



44
45
46
 
# File 'lib/ctf_party/rot.rb', line 44

def rot13!
  rot!
end

#sha1 ⇒ String

Calculate the sha1 hash of the string.

Examples:

'ctf-party'.sha1 # => "5a64f3bc491d0977e1e3578a48c65a89a16a5fe8"

Returns:

See Also:



30
31
32
 
# File 'lib/ctf_party/digest.rb', line 30

def sha1
  Digest::SHA1.hexdigest self
end

#sha1! ⇒ Object

Calculate the sha1 hash of the string in place as described for

{String#sha1}.

Examples:

bob = 'alice' # => "alice"
bob.sha1! # => "522b276a356bdf39013dfabea2cd43e141ecc9e8"
bob # => "522b276a356bdf39013dfabea2cd43e141ecc9e8"



40
41
42
 
# File 'lib/ctf_party/digest.rb', line 40

def sha1!
  replace(sha1)
end

#sha2(opts = {}) ⇒ String

Calculate the sha2 hash of the string.

Examples:

'try harder'.sha2 # => "5321ff2d4b1389b3a350dfe8ca77e3889dc6259bb233ad..."
'try harder'.sha2(bitlen: 512) # => "a7b73a98c095b22e25407b15c4dec128c..."

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :bitlen (Integer) —

    Defines the bit lenght of the digest. Default value: 256 (SHA2-256). other valid vales are 384 (SHA2-384) and 512 (SHA2-512).

Returns:

See Also:



54
55
56
57
 
# File 'lib/ctf_party/digest.rb', line 54

def sha2(opts = {})
  opts[:bitlen] ||= 256
  Digest::SHA2.new(opts[:bitlen]).hexdigest self
end

#sha2!(opts = {}) ⇒ Object

Calculate the sha2 hash of the string in place as described for

{String#sha2}.

Examples:

th = 'try harder' # => "try harder"
th.sha2!(bitlen: 384) # => "bb7f60b9562a19c3a83c23791440af11591c42ede9..."
th # => "bb7f60b9562a19c3a83c23791440af11591c42ede9988334cdfd7efa4261a..."



65
66
67
 
# File 'lib/ctf_party/digest.rb', line 65

def sha2!(opts = {})
  replace(sha2(opts))
end

#sha2_256 ⇒ Object

Alias for #sha2 with default value ( sha2(bitlen: 256) ).



70
71
72
 
# File 'lib/ctf_party/digest.rb', line 70

def sha2_256
  sha2
end

#sha2_256! ⇒ Object

Alias for #sha2! with default value ( sha2!(bitlen: 256) ).



75
76
77
 
# File 'lib/ctf_party/digest.rb', line 75

def sha2_256!
  replace(sha2)
end

#sha2_384 ⇒ Object

Alias for #sha2 with default value ( sha2(bitlen: 384) ).



80
81
82
 
# File 'lib/ctf_party/digest.rb', line 80

def sha2_384
  sha2(bitlen: 384)
end

#sha2_384! ⇒ Object

Alias for #sha2! with default value ( sha2!(bitlen: 384) ).



85
86
87
 
# File 'lib/ctf_party/digest.rb', line 85

def sha2_384!
  replace(sha2(bitlen: 384))
end

#sha2_512 ⇒ Object

Alias for #sha2 with default value ( sha2(bitlen: 512) ).



90
91
92
 
# File 'lib/ctf_party/digest.rb', line 90

def sha2_512
  sha2(bitlen: 512)
end

#sha2_512! ⇒ Object

Alias for #sha2! with default value ( sha2!(bitlen: 512) ).



95
96
97
 
# File 'lib/ctf_party/digest.rb', line 95

def sha2_512!
  replace(sha2(bitlen: 512))
end

#str2bin(opts = {}) ⇒ Object

Alias for #to_bin.



22
23
24
 
# File 'lib/ctf_party/binary.rb', line 22

def str2bin(opts = {})
  to_bin(opts)
end

#str2bin!(opts = {}) ⇒ Object

Alias for #to_bin!.



37
38
39
 
# File 'lib/ctf_party/binary.rb', line 37

def str2bin!(opts = {})
  to_bin!(opts)
end

#str2dec ⇒ Object

Alias for #to_dec.



31
32
33
 
# File 'lib/ctf_party/dec.rb', line 31

def str2dec
  to_dec
end

#str2dec! ⇒ Object

Alias for #to_dec!.



36
37
38
 
# File 'lib/ctf_party/dec.rb', line 36

def str2dec!
  replace(str2dec)
end

#str2hex(opts = {}) ⇒ Object

Alias for #to_hex.



99
100
101
 
# File 'lib/ctf_party/hex.rb', line 99

def str2hex(opts = {})
  to_hex(opts)
end

#str2hex!(opts = {}) ⇒ Object

Alias for #to_hex!.



114
115
116
 
# File 'lib/ctf_party/hex.rb', line 114

def str2hex!(opts = {})
  to_hex!(opts)
end

#to_b64(opts = {}) ⇒ String

Encode the string into base64

Examples:

'Super lib!'.to_b64 # => "U3VwZXIgbGliIQ=="

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :mode (Symbol) —

    Default value: :strict. Other values are :strict (:rfc4648) or :urlsafe.

Returns:

  • (String) —

    the Base64 encoded string

See Also:



15
16
17
18
19
20
21
 
# File 'lib/ctf_party/base64.rb', line 15

def to_b64(opts = {})
  opts[:mode] ||= :strict
  return Base64.strict_encode64(self) if opts[:mode] == :strict ||
                                         opts[:mode] == :rfc4648
  return Base64.encode64(self) if opts[:mode] == :rfc2045
  return Base64.urlsafe_encode64(self) if opts[:mode] == :urlsafe
end

#to_b64!(opts = {}) ⇒ nil

Encode the string into base64 in place as described for #to_b64.

Examples:

myStr = 'Ruby' # => "Ruby"
myStr.to_b64! # => nil
myStr # => "UnVieQ=="

Returns:

  • (nil) 


29
30
31
 
# File 'lib/ctf_party/base64.rb', line 29

def to_b64!(opts = {})
  replace(to_b64(opts))
end

#to_bin(opts = {}) ⇒ String

Encode a string into binary

Examples:

'binary'.to_bin # => "011000100110100101101110011000010111001001111001"
'binary'.to_bin(bitnumbering: :LSB) # => "010001101001011001110110100001100100111010011110"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :bitnumbering (Symbol) —

    Display output with most significant bit first (:MSB default) or least significant bit first (:LSB).

Returns:

  • (String) —

    the binary encoded string



12
13
14
15
16
17
18
19
 
# File 'lib/ctf_party/binary.rb', line 12

def to_bin(opts = {})
  opts[:bitnumbering] ||= :MSB
  # convert
  return unpack1('B*') if opts[:bitnumbering] == :MSB
  return unpack1('b*') if opts[:bitnumbering] == :LSB

  raise ArgumentError ':bitnumbering expects :MSB or :LSB'
end

#to_bin!(opts = {}) ⇒ Object

Encode a string into binary in place as described for #to_bin.

Examples:

a = 'binary'
a.to_bin!
a # => "011000100110100101101110011000010111001001111001"



32
33
34
 
# File 'lib/ctf_party/binary.rb', line 32

def to_bin!(opts = {})
  replace(to_bin(opts))
end

#to_dec ⇒ String

Encode a string into decimal (string to hexadecimal then hexadecimal to decimal)

Examples:

'noraj'.to_dec # => "474316169578"

Returns:

  • (String) —

    the decimal encoded string



8
9
10
 
# File 'lib/ctf_party/dec.rb', line 8

def to_dec
  str2hex.hex2dec
end

#to_dec! ⇒ Object

Encode a string into decimal in place as described for #to_dec.



13
14
15
 
# File 'lib/ctf_party/dec.rb', line 13

def to_dec!
  replace(to_dec)
end

#to_hex(opts = {}) ⇒ String

Encode a string into hexadecimal

Examples:

'noraj'.to_hex # => "6e6f72616a"
'noraj'.to_hex(prefix: '0x') # => "0x6e6f72616a"
'noraj'.to_hex(case: :upper) # => "6E6F72616A"
'noraj'.to_hex(nibble: :low) # => "e6f62716a6"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the output. Default value is a void string. Example of values: 0x, \x.

  • :case (Symbol) —

    Char case of the ouput. Default value :lower. Other valid value :upper.

  • :nibble (Symbol) —

    Display output with high nibble first (:high default) or low nibble first (:low).

Returns:

  • (String) —

    the hexadecimal encoded string



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ctf_party/hex.rb', line 80

def to_hex(opts = {})
  opts[:prefix] ||= ''
  opts[:case] ||= :lower
  opts[:nibble] ||= :high
  # convert
  out = ''
  case opts[:nibble]
  when :high
    out = unpack1('H*')
  when :low
    out = unpack1('h*')
  end
  # char case management
  out = out.upcase if opts[:case] == :upper
  # adding prefix must be done after case change
  return opts[:prefix] + out
end

#to_hex!(opts = {}) ⇒ Object

Encode a string into hexadecimal in place as described for #to_hex.

Examples:

a = 'noraj'
a.to_hex!
a # => "6e6f72616a"



109
110
111
 
# File 'lib/ctf_party/hex.rb', line 109

def to_hex!(opts = {})
  replace(to_hex(opts))
end

#to_hexip(opts = {}) ⇒ String

Encode a dotted decimal IP into a hexadecimal one

Examples:

'127.0.0.1'.to_hexip # => "7f000001"
'127.0.0.1'.to_hexip(nibble: :low) # => "0100007f"

Parameters:

  • opts (Hash) (defaults to: {}) —

    optional parameters

Options Hash (opts):

  • :prefix (String) —

    Prefix of the output. Default value is a void string. Example of values: 0x, \x.

  • :case (Symbol) —

    Char case of the ouput. Default value :lower. Other valid value :upper.

  • :nibble (Symbol) —

    Display output with high nibble first (:high default) or low nibble first (:low, used on Unix /proc/net/tcp).

Returns:

  • (String) —

    the hexadecimal encoded IP



257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/ctf_party/hex.rb', line 257

def to_hexip(opts = {})
  opts[:prefix] ||= ''
  opts[:case] ||= :lower
  opts[:nibble] ||= :high
  # convert
  out = split('.').map { |x| x.dec2hex(padding: 2) }
  out = out.reverse if opts[:nibble] == :low
  out = out.join
  # char case management
  out = out.upcase if opts[:case] == :upper
  # adding prefix must be done after case change
  return opts[:prefix] + out
end

#to_hexip!(opts = {}) ⇒ Object

Encode a dotted decimal IP into a hexadecimal one in place as described for #to_hexip.



273
274
275
 
# File 'lib/ctf_party/hex.rb', line 273

def to_hexip!(opts = {})
  replace(to_hexip(opts))
end

#urldecode ⇒ String

URL-decode the string

Examples:

"%27Stop%21%27+said+Fred".urldecode # => "'Stop!' said Fred"

Returns:

  • (String) —

    the URL-decoded string



24
25
26
 
# File 'lib/ctf_party/cgi.rb', line 24

def urldecode
  CGI.unescape self
end

#urldecode! ⇒ Object

URL-decode the string in place as described for #urldecode.



29
30
31
 
# File 'lib/ctf_party/cgi.rb', line 29

def urldecode!
  replace(urldecode)
end

#urlencode ⇒ String

URL-encode the string

Examples:

"'Stop!' said Fred".urlencode # => "%27Stop%21%27+said+Fred"

Returns:

  • (String) —

    the URL-encoded string



11
12
13
 
# File 'lib/ctf_party/cgi.rb', line 11

def urlencode
  CGI.escape self
end

#urlencode! ⇒ Object

URL-encode the string in place as described for #urlencode.



16
17
18
 
# File 'lib/ctf_party/cgi.rb', line 16

def urlencode!
  replace(urlencode)
end