ctf-party 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a891b890cdf81188caac863846fef9ddd4492126a34645de0bb9c09d4e4ab44
-  data.tar.gz: bcce5f84823d802900e4d1ff7750eb1a58c370d26f1895603091a237a62e7f2b
+  metadata.gz: 41082df14f844e9d331e06352e00af3ab29af0899ad4a54f911ee6cef946258b
+  data.tar.gz: ffb31de3ffd71d581c277f10ff0be95e9eaf2e75c161df8af1f9b8d415af64fc
 SHA512:
-  metadata.gz: ce15b05e7b38dfe927a6c7035d07fe843f2106b3897d716f685f7b98c3b1a851b09337657d8ee46916c2e7f36aa9ff1a48462b23c989357ad8be59f701e26c9e
-  data.tar.gz: f76df14283f2002dec8896e1b21ecf0bfb1cf4b778340a000074406a03558c483f262aa026912876cdca34c8353a5a949e8873b4e4fc537640d1e2aa65975e8d
+  metadata.gz: e09eff292c815cb2a5de04f8ae901a9ccc83ac30f7cd8b3a634b2b0674b32e3cd568cecfca774641afe23953afc1a9987d810655d236bf6f4fede7a2d48c62e2
+  data.tar.gz: 425e78e522566abf5a67650de204e2feea57f800d81f85dd04c87a51c0cbfea1a8096344da8eea61ab9b0a857ef2c511eacb52f97f2e92fb333274897f05b8d9

data/bin/ctf-party

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 # Ruby internal
-require 'pp'
+require 'shellwords' # for shellescape cmd
 # Project internal
 require 'ctf_party'
 require 'ctf_party/version'
@@ -10,11 +10,16 @@ require 'ctf_party/version'
 require 'docopt'
 
 cmd_whitelist = {
+  # ctf-party commands
   alternatecase: 'Change one characte on two upcase and the other downcase',
   bin2hex: 'Encode an binary string to a hexadecimal string',
   bin2str: 'Alias for from_bin',
   dec2hex: 'Encode an decimal string to a hexadecimal string',
   dec2str: 'Alias for from_dec',
+  defang_domain: 'Defang domain name',
+  defang_email: 'Defang email address',
+  defang_ip: 'Defang IP address',
+  defang_uri: 'Defang URI',
   from_b64: 'Decode the string from base64',
   from_bin: 'Decode a binary string',
   from_dec: 'Decode a decimal string (decimal to hexadecimal then hexadecimal to string)',
@@ -29,6 +34,10 @@ cmd_whitelist = {
   leet: 'Transform into leet speak (l337 5p34k)',
   md5: 'Calculate the md5 hash of the string',
   randomcase: 'Change the case of characters randomly',
+  refang_domain: 'Refang domain name',
+  refang_email: 'Refang email address',
+  refang_ip: 'Refang IP address',
+  refang_uri: 'Refang URI',
   rmd160: 'Calculate the RIPEMD-160 hash of the string',
   rot13: 'Encrypt / Decrypt the string with Caesar cipher with a shift of 13',
   sha1: 'Calculate the sha1 hash of the string',
@@ -45,27 +54,62 @@ cmd_whitelist = {
   to_hex: 'Encode a string into hexadecimal',
   to_hexip: 'Encode a dotted decimal IP into a hexadecimal one',
   urldecode: 'URL-decode the string',
-  urlencode: 'URL-encode the string'
+  urldecode_component: 'URL-decode the URL component string',
+  urlencode: 'URL-encode the string',
+  urlencode_component: 'URL-encode the URL component string',
+  # native string commands
+  bytesize: 'https://rubyapi.org/3.1/o/string#method-i-bytesize',
+  capitalize: 'https://rubyapi.org/3.1/o/string#method-i-capitalize',
+  chomp: 'https://rubyapi.org/3.1/o/string#method-i-chomp',
+  chop: 'https://rubyapi.org/3.1/o/string#method-i-chop',
+  downcase: 'https://rubyapi.org/3.1/o/string#method-i-downcase',
+  dump: 'https://rubyapi.org/3.1/o/string#method-i-dump',
+  hex: 'https://rubyapi.org/3.1/o/string#method-i-hex',
+  inspect: 'https://rubyapi.org/3.1/o/string#method-i-inspect',
+  length: 'https://rubyapi.org/3.1/o/string#method-i-length',
+  lstrip: 'https://rubyapi.org/3.1/o/string#method-i-lstrip',
+  reverse: 'https://rubyapi.org/3.1/o/string#method-i-reverse',
+  rstrip: 'https://rubyapi.org/3.1/o/string#method-i-rstrip',
+  scrub: 'https://rubyapi.org/3.1/o/string#method-i-scrub',
+  shellescape: 'https://rubyapi.org/3.1/o/string#method-i-shellescape',
+  size: 'https://rubyapi.org/3.1/o/string#method-i-size',
+  squeeze: 'https://rubyapi.org/3.1/o/string#method-i-squeeze',
+  strip: 'https://rubyapi.org/3.1/o/string#method-i-strip',
+  succ: 'https://rubyapi.org/3.1/o/string#method-i-succ',
+  swapcase: 'https://rubyapi.org/3.1/o/string#method-i-swapcase',
+  undump: 'https://rubyapi.org/3.1/o/string#method-i-undump',
+  unicode_normalize: 'https://rubyapi.org/3.1/o/string#method-i-unicode_normalize',
+  upcase: 'https://rubyapi.org/3.1/o/string#method-i-upcase'
 }
 
 doc = <<~DOCOPT
-  ctf-party by noraj
+  ctf-party v#{Version::VERSION} by noraj
 
   Usage:
-    ctf-party <string> <cmd>... [--debug]
+    ctf-party <string> <cmd>... [--row --file] [--debug]
     ctf-party --list-commands [--debug]
     ctf-party -h | --help
     ctf-party --version
 
+  Parameters:
+    <string>              The string to manipulate, read from STDIN if equal to "-"
+    <cmd>                 Command to apply to the string, cf. --list-commands
+
   Options:
     -l, --list-commands   List available commands (see https://noraj.github.io/ctf-party/yard/String.html)
+    -r, --row             Apply the transformation to each row
+    -f, --file            Interpret the string as a filename, if file doesn't exist it will still be treated as a string
     --debug               Display arguments
     -h, --help            Show this screen
     --version             Show version
 
   Examples:
     ctf-party 'security' to_hex
-    ctf-party 'NzQ2Zjc0NmY=' from_b64 hex2str str2bin
+    ctf-party 'NzQ2Zjc0NmY=' from_b64 hex2bin
+    curl -s https://example.org | ctf-party - htmlescape
+    seq 1 10 | ctf-party - dec2hex hex2bin --row
+    cut -d : -f 1 /etc/passwd | ctf-party - randomcase --row
+    ctf-party /etc/passwd str2hex --row --file
 DOCOPT
 
 begin
@@ -73,11 +117,24 @@ begin
   # use case 1, using the tool
   pp args if args['--debug']
   if args['<string>']
+    args['<string>'] = $stdin.read.chomp if args['<string>'] == '-'
+    args['<string>'] = File.read(args['<string>']) if args['--file'] && File.exist?(args['<string>'])
     wrong_cmd = args['<cmd>'] - cmd_whitelist.keys.map(&:to_s)
     if wrong_cmd.empty?
-      output = args['<string>']
-      args['<cmd>'].each do |cmd|
-        output = output.public_send(cmd)
+      if args['--row']
+        output = ''
+        args['<string>'].each_line(chomp: true) do |line|
+          output_line = line
+          args['<cmd>'].each do |cmd|
+            output_line = output_line.public_send(cmd)
+          end
+          output += "#{output_line}\n"
+        end
+      else
+        output = args['<string>']
+        args['<cmd>'].each do |cmd|
+          output = output.public_send(cmd)
+        end
       end
       puts output
     else
@@ -85,7 +142,7 @@ begin
     end
   elsif args['--list-commands']
     cmd_whitelist.each do |k, v|
-      puts "#{k.to_s.ljust(15)}#{v}"
+      puts "#{k.to_s.ljust(25)}#{v}"
     end
   end
   # use case 2, help: already handled by docopt

data/lib/ctf_party/cgi.rb

@@ -2,6 +2,7 @@
 
 # Ruby standard library
 require 'cgi'
+require 'uri'
 
 class String
   # URL-encode the URL string (RFC2396)

data/lib/ctf_party/defang.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+require 'uri'
+
+class String
+  # Defang the string if it is an IP address
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :unvalid Default value: `false`.
+  #   If `unvalid: false`, only valid IP address will be defanged.
+  #   If `unvalid: true`, everything is defanged.
+  # @return [String] the defanged string if it is a valid IP address or itself else.
+  # @example
+  #   '1.1.1.1'.defang_ip # => 1[.]1[.]1[.]1
+  #   '2606:4700:4700::1111'.defang_ip # => '2606[:]4700[:]4700[:][:]1111'
+  def defang_ip(opts = {})
+    opts[:unvalid] ||= false
+    if ipv4?
+      gsub('.', '[.]')
+    elsif ipv6?
+      gsub(':', '[:]')
+    elsif opts[:unvalid] == true
+      gsub('.', '[.]').gsub(':', '[:]')
+    else
+      self
+    end
+  end
+
+  # Defang the string in place, if it is an IP address, as described for {String#defang_ip}.
+  # @return [nil]
+  # @example
+  #   my_str = '127.0.0.1'
+  #   my_str.defang_ip!
+  #   my_str # => 127[.]0[.]0[.]1
+  def defang_ip!(opts = {})
+    replace(defang_ip(opts))
+  end
+
+  # Refang the string if it is an IP address
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :unvalid Default value: `false`.
+  #   If `unvalid: false`, only valid IP address will be refanged.
+  #   If `unvalid: true`, everything is refanged.
+  # @return [String] the refanged string if it is a valid IP address or itself else.
+  # @example
+  #   '1[.]1[.]1[.]1'.refang_ip # => 1.1.1.1
+  #   '2606[:]4700[:]4700[:][:]1111'.refang_ip # => 2606:4700:4700::1111
+  def refang_ip(opts = {})
+    opts[:unvalid] ||= false
+    re_ipv4 = gsub('[.]', '.')
+    re_ipv6 = gsub('[:]', ':')
+    if re_ipv4.ipv4?
+      re_ipv4
+    elsif re_ipv6.ipv6?
+      re_ipv6
+    elsif opts[:unvalid] == true
+      gsub('[.]', '.').gsub('[:]', ':')
+    else
+      self
+    end
+  end
+
+  # Refang the string in place, if it is an IP address, as described for {String#refang_ip}.
+  # @return [nil]
+  def refang_ip!(opts = {})
+    replace(refang_ip(opts))
+  end
+
+  # Defang the string if it is an URI.
+  # Will defang dot for any scheme and defang scheme as well for supported ones.
+  # Supported schemes: HTTP, HTTPS, FTP, WS, WSS, LDAP, LDAPS, Mailto.
+  # @return [String] the defanged string if it is an URI or itself else.
+  # @example
+  #   'ftp://ftp.ruby-lang.org/pub/ruby/3.2/ruby-3.2.0.tar.xz'.defang_uri
+  #   # => fxp://ftp[.]ruby-lang[.]org/pub/ruby/3[.]2/ruby-3[.]2[.]0[.]tar[.]xz
+  def defang_uri
+    begin
+      uri = URI(self)
+    rescue URI::InvalidURIError, URI::InvalidComponentError => e
+      puts e
+      return gsub('.', '[.]')
+    end
+    case uri
+    when URI::HTTP, URI::HTTPS, URI::FTP
+      uri.scheme = uri.scheme.gsub(/t/i, 'x')
+    when URI::WS, URI::WSS
+      uri.scheme = uri.scheme.dup.insert(1, 'x')
+    when URI::LDAP, URI::LDAPS
+      uri.scheme = uri.scheme.dup.insert(2, 'x')
+    when URI::MailTo
+      uri.scheme = uri.scheme.dup.insert(4, 'x')
+      return uri.to_s.gsub('.', '[.]').gsub('@', '[@]')
+    end
+    uri.to_s.gsub('.', '[.]')
+  end
+
+  # Defang the string in place, if it is an URI, as described for {String#defang_uri}.
+  def defang_uri!
+    replace(defang_uri)
+  end
+
+  # Refang the string if it is an URI.
+  # Will refang dot for any scheme and refang scheme as well for supported ones.
+  # Supported schemes: HTTP, HTTPS, FTP, WS, WSS, LDAP, LDAPS, Mailto.
+  # @return [String] the refanged string if it is an URI or itself else.
+  # @example
+  #   'hxxp://noraj[.]neverssl[.]com/online/'.refang_uri # => http://noraj.neverssl.com/online/
+  def refang_uri
+    if %r{://}.match?(self)
+      scheme, remains = split('://', 2)
+    else
+      scheme, remains = split(':', 2)
+    end
+    case scheme
+    when /hxxps?/i, /fxp/i
+      scheme.gsub!(/x/i, 't')
+    when /wxss?/i, /ldxaps?/i
+      scheme.gsub!(/x/i, '')
+    when /mailxto/i
+      scheme.gsub!(/x/i, '')
+      remains.gsub!('[.]', '.')
+      remains.gsub!('[@]', '@')
+      return scheme.concat(":#{remains}")
+    end
+    remains.gsub!('[.]', '.')
+    if %r{://}.match?(self)
+      scheme.concat("://#{remains}")
+    else
+      scheme.concat(":#{remains}")
+    end
+  end
+
+  # Refang the string in place, if it is an URI, as described for {String#refang_uri}.
+  def refang_uri!
+    replace(refang_uri)
+  end
+
+  # Defang the string if it is a domain name
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :unvalid Default value: `false`.
+  #   If `unvalid: false`, only valid domain name will be defanged.
+  #   If `unvalid: true`, everything is defanged.
+  # @return [String] the defanged string if it is a valid domain name or itself else.
+  # @example
+  #   'pwn.by'.defang_domain # => pwn[.]by
+  def defang_domain(opts = {})
+    opts[:unvalid] ||= false
+    if domain? || opts[:unvalid] == true
+      gsub('.', '[.]')
+    else
+      self
+    end
+  end
+
+  # Defang the string in place, if it is a domain name, as described for {String#defang_domain}.
+  def defang_domain!(opts = {})
+    replace(defang_domain(opts))
+  end
+
+  # Refang the string if it is a domain name
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :unvalid Default value: `false`.
+  #   If `unvalid: false`, only valid domain name will be refanged.
+  #   If `unvalid: true`, everything is refanged.
+  # @return [String] the refanged string if it is a valid domain name or itself else.
+  # @example
+  #   'pwn[.]by'.refang_domain # => pwn.by
+  def refang_domain(opts = {})
+    opts[:unvalid] ||= false
+    re_domain = gsub('[.]', '.')
+    if re_domain.domain? || opts[:unvalid] == true
+      re_domain
+    else
+      self
+    end
+  end
+
+  # Refang the string in place, if it is a domain name, as described for {String#refang_domain}.
+  def refang_domain!(opts = {})
+    replace(refang_domain(opts))
+  end
+
+  # Defang the string if it is an email address
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :unvalid Default value: `false`.
+  #   If `unvalid: false`, only valid email address will be defanged.
+  #   If `unvalid: true`, everything is defanged.
+  # @return [String] the defanged string if it is an email address or itself else.
+  # @example
+  #   'noraj.rawsec@pwn.by'.defang_email # => noraj[.]rawsec[@]pwn[.]by
+  def defang_email(opts = {})
+    opts[:unvalid] ||= false
+    if email? || opts[:unvalid] == true
+      gsub('.', '[.]').gsub('@', '[@]')
+    else
+      self
+    end
+  end
+
+  # Defang the string in place, if it is a email address, as described for {String#defang_email}.
+  def defang_email!(opts = {})
+    replace(defang_email(opts))
+  end
+
+  # Refang the string if it is an email address
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :unvalid Default value: `false`.
+  #   If `unvalid: false`, only valid email address will be refanged.
+  #   If `unvalid: true`, everything is refanged.
+  # @return [String] the refanged string if it is a valid email address or itself else.
+  # @example
+  #   'noraj+alias[@]pwn[.]by'.refang_email # => noraj.rawsec@pwn.by
+  def refang_email(opts = {})
+    opts[:unvalid] ||= false
+    re_email = gsub('[.]', '.').gsub('[@]', '@')
+    if re_email.email? || opts[:unvalid] == true
+      re_email
+    else
+      self
+    end
+  end
+
+  # Refang the string in place, if it is a email address, as described for {String#refang_email}.
+  def refang_email!(opts = {})
+    replace(refang_email(opts))
+  end
+end

data/lib/ctf_party/hex.rb

@@ -59,8 +59,10 @@ class String
     out = ('0' * (opts[:padding] - out.size)) + out if out.size < opts[:padding]
     # char case management
     out = out.upcase if opts[:case] == :upper
-    # adding prefix must be done after case change
-    out = out.scan(/.{2}/).map { |x| opts[:prefixall] + x }.join
+    # adding prefix must be done after case change, complex conditional to avoid cropping when odd byte lenght
+    out = (out.size.odd? ? [out[0]] + out[1..].scan(/.{1,2}/) : out.scan(/.{2}/)).map do |x|
+      opts[:prefixall] + x
+    end.join
     return opts[:prefix] + out
   end
 

data/lib/ctf_party/network.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+require 'uri'
+
+class String
+  # Is the string an IPv4?
+  # @return [Boolean] `true` if the string is a valid IPv4, `false` else.
+  # @example
+  #   '1.1.1.1'.ipv4? # => true
+  #   '127.0.0.300'.ipv4? # => false
+  def ipv4?
+    IPAddr.new(self).ipv4?
+  rescue IPAddr::InvalidAddressError
+    false
+  end
+
+  # Is the string an IPv6?
+  # @return [Boolean] `true` if the string is a valid IPv6, `false` else.
+  # @example
+  #   '2606:4700:4700::1111'.ipv6? # => true
+  #   'fe80::fe80::fe80'.ipv6? # => false
+  def ipv6?
+    IPAddr.new(self).ipv6?
+  rescue IPAddr::InvalidAddressError
+    false
+  end
+
+  # Is the string an IP address?
+  # @return [Boolean] `true` if the string is a valid IP address, `false` else.
+  # @example
+  #   '127.0.0.1'.ip? # => true
+  #   '::1'.ip? # => true
+  def ip?
+    ipv4? || ipv6?
+  end
+
+  # Is the string a valid URI?
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :lax Default value: `false`.
+  #   When `lax: false`, only URI matching common protocols (ftp http https ldap ldaps mailto ws wss) are recognized,
+  #   but is still a bit lax (eg. `http://` is seen as valid).
+  #   When `lax: true`, the parser will accept more types of URI (gopher magnet matrix), but will be very lax and accept
+  #   nearly anything including `:`.
+  # @return [Boolean] `true` if the string is a valid URI, `false` else.
+  # @example
+  #   'ftp://ftp.ruby-lang.org/pub/ruby/3.2/ruby-3.2.0.tar.xz'.uri? # => true
+  #   'a:'.uri? # => false
+  #   'a:'.uri?(lax: true) # => true
+  def uri?(opts = {})
+    opts[:lax] ||= false
+    strict = URI::DEFAULT_PARSER.make_regexp(%w[ftp http https ldap ldaps mailto ws wss]).match?(self)
+    lax = URI::DEFAULT_PARSER.make_regexp.match?(self)
+    if opts[:lax] == true
+      strict || lax
+    else
+      strict
+    end
+  end
+
+  # Is the string a valid domain name?
+  # It is a bit lax, for exemple it does not validate if the TLD really exist but
+  # still performs more check than many checkers.
+  # @return [Boolean] `true` if the string is a valid domain name, `false` else.
+  # @example
+  #   'pwn.by'.domain? # => true
+  #   'a.-b.net'.domain? # => false
+  # rubocop:disable Metrics/PerceivedComplexity
+  def domain?
+    return false unless size.between?(1, 255) # max. domain length
+
+    # split each hostname into labels
+    labels = split('.')
+    return false if labels.size > 127 # max. label number
+    return false if labels.size < 2 # min. label number
+    return false if labels.first[0] == '.' # cannot start with a dot
+
+    labels.each_with_index do |label, _index|
+      return false unless label.size.between?(1, 63) # max. label length
+      return false if label[0] == '-' || label[-1] == '-' # label cannot begin or end with hyphen
+      # do not set a whitelist for allowed characters ([a-z0-9\-\_]) since there can be
+      # Unicode IDN (without punycode transcription)
+      # to not deal with punycode translation and validation, let's just do pseudo-validation
+      # by checking only for a few illegal ones (blacklist)
+      return false if /\p{C}|\p{Z}/.match?(self)
+      # skip TLD validity check since the list is large, often change and custom TLD could be used for internal usage
+    end
+    return false if /\.\./.match?(self) # cannot contain consecutive dots
+
+    # do not check for trailing dot
+    true
+  end
+  # rubocop:enable Metrics/PerceivedComplexity
+
+  # Is the string a valid email address?
+  # @param opts [Hash] optional parameters
+  # @option opts [Symbol] :mode Default value: `:rfc5322`.
+  #   Other values are `:strict` (`:rfc5322`), `:light` or `:lightwithlength`.
+  #   ``:strict` / `:rfc5322` is the closest thing to RFC 5322.
+  #   `:light` is a lighter more practical version of RFC 5322 that will be more useful in real life (omits IP
+  #   addresses, domain-specific addresses, the syntax using double quotes and square brackets).
+  #   `:lightwithlength` is the same as the light version but with length limit enforcing.
+  # @see https://stackoverflow.com/questions/22993545/ruby-email-validation-with-regex/75050279#75050279
+  # @return [Boolean] `true` if the string is a valid email address, `false` else.
+  # @example
+  #   "n#{'o' * 255}raj@pwn.by".email? # => true
+  #   "n#{'o' * 255}raj@pwn.by".email?(mode: :lightwithlength) # => false
+  #   '"valid"@domain.com'.email?(mode: :rfc5322) # => true
+  #   '"valid"@domain.com'.email?(mode: :light) # => false
+  def email?(opts = {})
+    opts[:mode] ||= :rfc5322
+    case opts[:mode]
+    when :strict, :rfc5322
+      %r{\A(?:[a-z0-9!#$%&'*+/=?^_‘{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_‘{|}~-]+)*|
+      "(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|
+      \\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|
+      \[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|
+      [a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|
+      \\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])\z}ix.match?(self)
+    when :light
+      %r{\A[a-z0-9!#$%&'*+/=?^_‘{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_‘{|}~-]+)*@
+      (?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z}ix.match?(self)
+    when :lightwithlength
+      %r{\A(?=[a-z0-9@.!#$%&'*+/=?^_‘{|}~-]{6,254}\z)
+      (?=[a-z0-9.!#$%&'*+/=?^_‘{|}~-]{1,64}@)[a-z0-9!#$%&'*+/=?^_‘{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_‘{|}~-]+)*@
+      (?:(?=[a-z0-9-]{1,63}\.)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+
+      (?=[a-z0-9-]{1,63}\z)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z}ix.match?(self)
+    end
+  end
+end

data/lib/ctf_party/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Version
-  VERSION = '2.1.0'
+  VERSION = '2.3.0'
 end

data/lib/ctf_party.rb

@@ -2,14 +2,16 @@
 
 # Project internal
 require 'ctf_party/base64'
-require 'ctf_party/rot'
+require 'ctf_party/binary'
+require 'ctf_party/case'
+require 'ctf_party/cgi'
+require 'ctf_party/dec'
+require 'ctf_party/defang'
 require 'ctf_party/digest'
 require 'ctf_party/flag'
 require 'ctf_party/hex'
-require 'ctf_party/case'
-require 'ctf_party/cgi'
-require 'ctf_party/binary'
 require 'ctf_party/leet'
-require 'ctf_party/dec'
 require 'ctf_party/misc'
+require 'ctf_party/network'
+require 'ctf_party/rot'
 require 'ctf_party/xor'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ctf-party
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Alexandre ZANNI
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-31 00:00:00.000000000 Z
+date: 2023-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docopt
@@ -46,11 +46,13 @@ files:
 - lib/ctf_party/case.rb
 - lib/ctf_party/cgi.rb
 - lib/ctf_party/dec.rb
+- lib/ctf_party/defang.rb
 - lib/ctf_party/digest.rb
 - lib/ctf_party/flag.rb
 - lib/ctf_party/hex.rb
 - lib/ctf_party/leet.rb
 - lib/ctf_party/misc.rb
+- lib/ctf_party/network.rb
 - lib/ctf_party/rot.rb
 - lib/ctf_party/version.rb
 - lib/ctf_party/xor.rb
@@ -76,14 +78,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
   - - "<"
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: A CLI tool & library to enhance and speed up script/exploit writing with