unisec 0.0.2 → 0.0.4

data/lib/unisec/bidi.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'unisec/utils'
+require 'ctf_party'
+
+module Unisec
+  # Manipulation of bidirectional related content
+  class Bidi
+    # Attack using BiDi code points like RtLO, for example, for spoofing a domain name or a file name
+    class Spoof
+      # The target string to spoof (eg. URL, domain or file name)
+      # @return [String] the target string
+      attr_reader :target_display
+
+      # Set a new target string to spoof
+      #
+      # It will automatically set `@spoof_string` and `@spoof_payload` as well.
+      # @param input [String] the target string
+      # @param opts [Hash] optional parameters, see {Spoof.bidi_affix}
+      # @return [String] the target string
+      def set_target_display(input, **opts)
+        @target_display = input
+        @spoof_string = reverse(**opts)
+        @spoof_payload = bidi_affix(**opts)
+        @target_display
+      end
+
+      # The string for the spoofing attack without the BiDi characters
+      # @return [String] the spoof string (without BiDi)
+      attr_reader :spoof_string
+
+      # The string for the spoofing attack with the BiDi characters. (Spoof payload = spoof string + BiDi)
+      # @return [String] the spoof string (with BiDi)
+      attr_reader :spoof_payload
+
+      # @param input [String] the target string
+      # @param opts [Hash] optional parameters, see {Spoof.bidi_affix}
+      # @example
+      #   bd = Unisec::Bidi::Spoof.new('https://moc.example.org//:sptth')
+      #   bd.target_display # => "https://moc.example.org//:sptth"
+      #   bd.spoof_string # => "https://gro.elpmaxe.com//:sptth"
+      #   bd.spoof_payload => "‮https://gro.elpmaxe.com//:sptth‬"
+      def initialize(input, **opts)
+        opts[:index] ||= opts[:infix_pos]
+
+        @target_display = input
+        @spoof_string = reverse(**opts)
+        @spoof_payload = bidi_affix(**opts)
+      end
+
+      # Reverse the (sub)-string (grapheme cluster aware)
+      # @param target [String] string to reverse
+      # @param opts [Hash] optional parameters
+      # @option opts [String] :index Index at which the revese starts (before this position will be left untouched)
+      # @return [String] the reversed string
+      # @example
+      #   Unisec::Bidi::Spoof.reverse('document_anntxt.exe', index: 12)
+      #   # => "document_annexe.txt"
+      #
+      #   Unisec::Bidi::Spoof.reverse("🇫🇷🐓")
+      #   # => "🐓🇫🇷"
+      def self.reverse(target, **opts)
+        opts[:index] ||= 0
+
+        target[0...opts[:index]] + Unisec::Utils::String.grapheme_reverse(target[opts[:index]..])
+      end
+
+      # Call {Spoof.reverse} with `@target_display` as default input (target).
+      def reverse(**opts)
+        Spoof.reverse(@target_display, **opts)
+      end
+
+      # Inject BiDi characters into the input string
+      # @param input [String] input string
+      # @param opts [Hash] optional parameters
+      # @option opts [String] :prefix Prefix Bidi. Default: RLO (U+202E).
+      # @option opts [String] :suffix Suffix Bidi. Default: PDF (U+202C).
+      # @option opts [String] :infix_bidi Bidi injected at a chosen position. Default: none (empty string).
+      # @option opts [String] :infix_pos Position (index) where to inject an extra BiDi. Default: 0.
+      # @return [String] spoof payload (input string with injected BiDi)
+      # @example
+      #   # By default inject a RLO prefix, a PDF suffix and no infix.
+      #   Unisec::Bidi::Spoof.bidi_affix('acceis')
+      #   # => "‮acceis‬"
+      #
+      #   # RLI ... PDI
+      #   Unisec::Bidi::Spoof.bidi_affix('acceis', prefix: "\u{2067}", suffix: "\u{2069}")
+      #   # => "⁧acceis⁩"
+      #
+      #   # RLE ... PDF
+      #   Unisec::Bidi::Spoof.bidi_affix('acceis', prefix: "\u{202B}", suffix: "\u{202C}")
+      #   # => "‫acceis‬"
+      #
+      #   # RLO ... PDF
+      #   Unisec::Bidi::Spoof.bidi_affix('https://moc.example.org//:sptth', prefix: "\u{202E}", suffix: "\u{202C}")
+      #   # => "‮https://moc.example.org//:sptth‬"
+      #
+      #   # FSI RLO ... PDF PDI
+      #   Unisec::Bidi::Spoof.bidi_affix('https://moc.example.org//:sptth', prefix: "\u{2068 202E}", suffix: "\u{202C 2069}")
+      #   # => "⁨‮https://moc.example.org//:sptth‬⁩"
+      #
+      #   # RLM ...
+      #   Unisec::Bidi::Spoof.bidi_affix('unicode', prefix: "\u{200F}", suffix: '')
+      #   # => "‏unicode"
+      #
+      #   # For file name spoofing, it is useful to be able to inject just a RLO before the fake extension
+      #   # so we can void the prefix and suffix and just set the position of an infix
+      #   ex = Unisec::Bidi::Spoof.bidi_affix('document_anntxt.exe', prefix: '', suffix: '', infix_bidi: "\u{202E}", infix_pos: 12)
+      #   # => "document_ann‮txt.exe"
+      #   puts ex
+      #   # document_ann‮txt.exe
+      def self.bidi_affix(input, **opts)
+        opts[:prefix] ||= "\u{202E}" # RLO
+        opts[:suffix] ||= "\u{202C}" # PDF
+        opts[:infix_bidi] ||= ''
+        opts[:infix_pos] ||= 0
+
+        out = "#{opts[:prefix]}#{input}#{opts[:suffix]}"
+        out.insert(opts[:infix_pos], opts[:infix_bidi])
+        out
+      end
+
+      # Call {Spoof.bidi_affix} with `@spoof_string` as input.
+      def bidi_affix(**opts)
+        Spoof.bidi_affix(@spoof_string, **opts)
+      end
+
+      # Display a CLI-friendly output summurizing the spoof payload
+      #
+      # The light version displays only the spoof payload for easy piping with other commands.
+      # @param light [Boolean] `true` = light display (displays only the spoof payload for easy piping with other commands), `false` (default) = full display.
+      # @example
+      #   puts Unisec::Bidi::Spoof.new('noraj').display
+      #   # Target string: noraj
+      #   # Spoof payload (display) ⚠: ‮jaron‬
+      #   # Spoof string 🛈: jaron
+      #   # Spoof payload (hex): e280ae6a61726f6ee280ac
+      #   # Spoof payload (hex, escaped): \xe2\x80\xae\x6a\x61\x72\x6f\x6e\xe2\x80\xac
+      #   # Spoof payload (base64): 4oCuamFyb27igKw=
+      #   # Spoof payload (urlencode): %E2%80%AEjaron%E2%80%AC
+      #   # Spoof payload (code points): U+202E U+006A U+0061 U+0072 U+006F U+006E U+202C
+      #   #
+      #   #
+      #   #
+      #   # ⚠: for the spoof payload to display correctly, be sure your VTE has RTL support, e.g. see https://wiki.archlinux.org/title/Bidirectional_text#Terminal.
+      #   # 🛈: Does not contain the BiDi character (e.g. RtLO).
+      #
+      #   puts Unisec::Bidi::Spoof.new('noraj').display(light: true)
+      #   # ‮jaron‬
+      def display(light: false)
+        if light == false # full display
+          "Target string: #{@target_display}\n" \
+            "Spoof payload (display) ⚠: #{@spoof_payload}\n" \
+            "Spoof string 🛈: #{@spoof_string}\n" \
+            "Spoof payload (hex): #{@spoof_payload.to_hex}\n" \
+            "Spoof payload (hex, escaped): #{@spoof_payload.to_hex(prefixall: '\\x')}\n" \
+            "Spoof payload (base64): #{@spoof_payload.to_b64}\n" \
+            "Spoof payload (urlencode): #{@spoof_payload.urlencode}\n" \
+            "Spoof payload (code points): #{Unisec::Properties.chars2codepoints(@spoof_payload)}\n" \
+            "\n\n\n" \
+            '⚠: for the spoof payload to display correctly, be sure your VTE has RTL support, ' \
+            "e.g. see https://wiki.archlinux.org/title/Bidirectional_text#Terminal.\n" \
+            '🛈: Does not contain the BiDi character (e.g. RtLO).'
+        else # light display
+          @spoof_payload
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/bidi.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+require 'unisec/utils'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI sub-commands `unisec bidi xxx` for the class {Unisec::Bidi} from the lib.
+      module Bidi
+        # Command `unisec bidi spoof`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec bidi spoof noraj
+        # Target string: noraj
+        # Spoof payload (display) ⚠: ‮jaron‬
+        # Spoof string 🛈: jaron
+        # Spoof payload (hex): e280ae6a61726f6ee280ac
+        # Spoof payload (hex, escaped): \xe2\x80\xae\x6a\x61\x72\x6f\x6e\xe2\x80\xac
+        # Spoof payload (base64): 4oCuamFyb27igKw=
+        # Spoof payload (urlencode): %E2%80%AEjaron%E2%80%AC
+        # Spoof payload (code points): U+202E U+006A U+0061 U+0072 U+006F U+006E U+202C
+        #
+        #
+        #
+        # ⚠: for the spoof payload to display correctly, be sure your VTE has RTL support, e.g. see https://wiki.archlinux.org/title/Bidirectional_text#Terminal.
+        # 🛈: Does not contain the BiDi character (e.g. RtLO).
+        #
+        # $ unisec bidi spoof 'document_annexe.txt' --prefix '' --suffix '' --infix-bidi $'\U202E' --infix-pos 12 --light=true
+        # document_ann‮txt.exe
+        # ```
+        class Spoof < Dry::CLI::Command
+          desc 'Craft a payload for BiDi attacks (for example, for spoofing a domain name or a file name)'
+
+          argument :input, required: true,
+                           desc: 'String input'
+          option :light, default: false, values: %w[true false],
+                         desc: 'true = light display (displays only the spoof payload for easy piping with other ' \
+                               'commands), false = full display'
+          option :prefix, default: nil, desc: 'Prefix Bidi. Default: RLO (U+202E).'
+          option :suffix, default: nil, desc: 'Suffix Bidi. Default: PDF (U+202C).'
+          option :infix_bidi, default: nil, desc: 'Bidi injected at a chosen position. Default: none (empty string).'
+          option :infix_pos, default: nil, desc: 'Spoof payload (input string with injected BiDi)'
+
+          # Craft a payload for BiDi attacks
+          # @param input [String] Input string to spoof
+          # @param options [Hash] optional parameters, see {Unisec::Bidi::Spoof.bidi_affix}
+          def call(input: nil, **options)
+            to_bool = ->(str) { ['true', true].include?(str) }
+            light = to_bool.call(options.fetch(:light))
+            infix_pos = options[:infix_pos].to_i unless options[:infix_pos].nil?
+            puts Unisec::Bidi::Spoof.new(input, prefix: options[:prefix], suffix: options[:suffix],
+                                                infix_bidi: options[:infix_bidi],
+                                                infix_pos: infix_pos).display(light: light)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/cli.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require 'unisec/cli/surrogates'
+require 'unisec/cli/bidi'
+require 'unisec/cli/confusables'
 require 'unisec/cli/hexdump'
 require 'unisec/cli/properties'
-require 'unisec/cli/confusables'
-require 'unisec/cli/versions'
+require 'unisec/cli/rugrep'
 require 'unisec/cli/size'
+require 'unisec/cli/surrogates'
+require 'unisec/cli/versions'
 
 module Unisec
   # Module used to create the CLI for the executable
@@ -16,16 +18,18 @@ module Unisec
 
       # Mapping between the (sub-)commands as seen by the user
       # on the command-line interface and the CLI modules in the lib
-      register 'surrogates to', Surrogates::To
-      register 'surrogates from', Surrogates::From
-      register 'hexdump', Hexdump
-      register 'properties list', Properties::List
-      register 'properties codepoints', Properties::Codepoints
-      register 'properties char', Properties::Char
+      register 'bidi spoof', Bidi::Spoof
       register 'confusables list', Confusables::List
       register 'confusables randomize', Confusables::Randomize
-      register 'versions', Versions
+      register 'grep', Grep
+      register 'hexdump', Hexdump
+      register 'properties char', Properties::Char
+      register 'properties codepoints', Properties::Codepoints
+      register 'properties list', Properties::List
       register 'size', Size
+      register 'surrogates from', Surrogates::From
+      register 'surrogates to', Surrogates::To
+      register 'versions', Versions
     end
   end
 end

data/lib/unisec/cli/hexdump.rb

@@ -22,12 +22,21 @@ module Unisec
         desc 'Hexdump in all Unicode encodings'
 
         argument :input, required: true,
-                         desc: 'String input'
+                         desc: 'String input. Read from STDIN if equal to -.'
+
+        option :enc, default: nil, values: %w[utf8 utf16be utf16le utf32be utf32le],
+                     desc: 'Output only in the specified encoding.'
 
         # Hexdump of all Unicode encodings.
         # @param input [String] Input string to encode
-        def call(input: nil, **)
-          puts Unisec::Hexdump.new(input).display
+        def call(input: nil, **options)
+          input = $stdin.read.chomp if input == '-'
+          if options[:enc].nil?
+            puts Unisec::Hexdump.new(input).display
+          else
+            # using send() is safe here thanks to the value whitelist
+            puts puts Unisec::Hexdump.send(options[:enc], input)
+          end
         end
       end
     end

data/lib/unisec/cli/rugrep.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI command `unisec grep` for the class {Unisec::Rugrep} from the lib.
+      #
+      # Example:
+      #
+      # ```plaintext
+      # $ unisec grep 'FRENCH \w+'
+      # U+20A3  ₣    FRENCH FRANC SIGN
+      # U+1F35F 🍟    FRENCH FRIES
+      # ```
+      class Grep < Dry::CLI::Command
+        desc 'Search for Unicode code point names by regular expression'
+
+        argument :regexp, required: true,
+                          desc: 'regular expression'
+
+        # Hexdump of all Unicode encodings.
+        # @param regexp [Regexp] Regular expression without delimiters or modifiers.
+        #   Supports everything Ruby Regexp supports
+        def call(regexp: nil, **)
+          puts Unisec::Rugrep.regrep_display(regexp)
+        end
+      end
+    end
+  end
+end

data/lib/unisec/properties.rb

@@ -50,7 +50,7 @@ module Unisec
     def self.codepoints_display(prop)
       codepoints = Properties.codepoints(prop)
       codepoints.each do |cp|
-        puts "#{Properties.char2codepoint(cp[:char]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
+        puts "#{Properties.deccp2stdhexcp(cp[:codepoint]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
       end
       nil
     end
@@ -158,7 +158,7 @@ module Unisec
     # @example
     #   Unisec::Properties.char2codepoint('💎') # => "U+1F48E"
     def self.char2codepoint(chr)
-      "U+#{format('%.4x', chr.codepoints.first).upcase}"
+      Properties.deccp2stdhexcp(chr.codepoints.first)
     end
 
     # Display the code points in Unicode format for the given characters (code points as string)
@@ -174,5 +174,14 @@ module Unisec
       end
       out.join(' ')
     end
+
+    # Convert from decimal code point to standardized format hexadecimal code point
+    # @param int_cp [Integer] Code point in decimal format
+    # @return [String] code point in Unicode format
+    # @example
+    #   Unisec::Properties.intcp2stdhexcp(128640) # => "U+1F680"
+    def self.deccp2stdhexcp(int_cp)
+      "U+#{format('%.4x', int_cp).upcase}"
+    end
   end
 end

data/lib/unisec/rugrep.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'twitter_cldr'
+require 'paint'
+
+module Unisec
+  # Ruby grep : Ruby regular expression search for Unicode code point names
+  class Rugrep
+    # UCD Derived names file location
+    # @see https://www.unicode.org/Public/UCD/latest/ucd/extracted/DerivedName.txt
+    UCD_DERIVEDNAME = File.join(__dir__, '../../data/DerivedName.txt')
+
+    # Search code points by (Ruby) regexp
+    # @param regexp [Regexp] Regular expression without delimiters or modifiers.
+    #   Supports everything Ruby Regexp supports
+    # @return [Array<Hash>] Array of code points (`{char: String, codepoint: Integer, name: String}`)
+    # @example
+    #   Unisec::Rugrep.regrep('snowman|snowflake')
+    #   # =>
+    #   # [{:char=>"☃", :codepoint=>9731, :name=>"SNOWMAN"},
+    #   #  {:char=>"⛄", :codepoint=>9924, :name=>"SNOWMAN WITHOUT SNOW"},
+    #   #  {:char=>"⛇", :codepoint=>9927, :name=>"BLACK SNOWMAN"},
+    #   #  {:char=>"❄", :codepoint=>10052, :name=>"SNOWFLAKE"},
+    #   #  {:char=>"❅", :codepoint=>10053, :name=>"TIGHT TRIFOLIATE SNOWFLAKE"},
+    #   #  {:char=>"❆", :codepoint=>10054, :name=>"HEAVY CHEVRON SNOWFLAKE"}]
+    #   Unisec::Rugrep.regrep('greek small letter \w+')
+    #   # =>
+    #   # [{:char=>"ͱ", :codepoint=>881, :name=>"GREEK SMALL LETTER HETA"},
+    #   #  {:char=>"ͳ", :codepoint=>883, :name=>"GREEK SMALL LETTER ARCHAIC SAMPI"},
+    #   #  {:char=>"ͷ", :codepoint=>887, :name=>"GREEK SMALL LETTER PAMPHYLIAN DIGAMMA"},
+    #   #  …]
+    def self.regrep(regexp)
+      out = []
+      file = File.new(UCD_DERIVEDNAME)
+      file.each_line(chomp: true) do |line|
+        # Skip if the line is empty or a comment
+        next if line.empty? || line[0] == '#'
+
+        # parse the line to extract code point as integer and the name
+        cp_int, name = line.split(';')
+        cp_int = cp_int.chomp.to_i(16)
+        name.lstrip!
+        next unless /#{regexp}/i.match?(name) # compiling regexp once is surprisingly not faster
+
+        out << {
+          char: TwitterCldr::Utils::CodePoints.to_string([cp_int]),
+          codepoint: cp_int,
+          name: name
+        }
+      end
+      out
+    end
+
+    # Display a CLI-friendly output listing all code points corresponding to a regular expression.
+    # @example
+    #   Unisec::Rugrep.regrep_display('snowman|snowflake')
+    #   # =>
+    #   # U+2603  ☃    SNOWMAN
+    #   # U+26C4  ⛄    SNOWMAN WITHOUT SNOW
+    #   # U+26C7  ⛇    BLACK SNOWMAN
+    #   # U+2744  ❄    SNOWFLAKE
+    #   # U+2745  ❅    TIGHT TRIFOLIATE SNOWFLAKE
+    #   # U+2746  ❆    HEAVY CHEVRON SNOWFLAKE
+    def self.regrep_display(regexp)
+      codepoints = regrep(regexp)
+      codepoints.each do |cp|
+        puts "#{Properties.deccp2stdhexcp(cp[:codepoint]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
+      end
+      nil
+    end
+
+    # Returns the version of Unicode used in UCD local file (data/DerivedName.txt)
+    # @return [String] Unicode version
+    # @example
+    #   Unisec::Rugrep.ucd_derivedname_version # => "15.1.0"
+    def self.ucd_derivedname_version
+      first_line = File.open(UCD_DERIVEDNAME, &:readline)
+      first_line.match(/-(\d+\.\d+\.\d+)\.txt/).captures.first
+    end
+
+    # Search code points by (Ruby) regexp
+    # @param regexp [Regexp] Regular expression without delimiters or modifiers
+    # @return [Array<Hash>] Array of code points (`{char: String, codepoint: Integer, name: String}`)
+    # @example
+    #   Unisec::Rugrep.regrep_slow('snowman|snowflake')
+    #   # =>
+    #   # [{:char=>"☃", :codepoint=>9731, :name=>"SNOWMAN"},
+    #   #  {:char=>"⛄", :codepoint=>9924, :name=>"SNOWMAN WITHOUT SNOW"},
+    #   #  {:char=>"⛇", :codepoint=>9927, :name=>"BLACK SNOWMAN"},
+    #   #  {:char=>"❄", :codepoint=>10052, :name=>"SNOWFLAKE"},
+    #   #  {:char=>"❅", :codepoint=>10053, :name=>"TIGHT TRIFOLIATE SNOWFLAKE"},
+    #   #  {:char=>"❆", :codepoint=>10054, :name=>"HEAVY CHEVRON SNOWFLAKE"}]
+    # @note ⚠ This command is very time consuming (~ 1min) and unoptimized (execute one regexp per code point…)
+    def self.regrep_slow(regexp)
+      out = []
+      TwitterCldr::Shared::CodePoint.each do |cp|
+        next unless /#{regexp}/oi.match?(cp.name) # compiling regexp once is surprisingly not faster
+
+        out << {
+          char: TwitterCldr::Utils::CodePoints.to_string([cp.code_point]),
+          codepoint: cp.code_point,
+          name: cp.name
+        }
+      end
+      out
+    end
+
+    # Display a CLI-friendly output listing all code points corresponding to a regular expression.
+    # @example
+    #   Unisec::Rugrep.regrep_display_slow('snowman|snowflake')
+    #   # =>
+    #   # U+2603  ☃    SNOWMAN
+    #   # U+26C4  ⛄    SNOWMAN WITHOUT SNOW
+    #   # U+26C7  ⛇    BLACK SNOWMAN
+    #   # U+2744  ❄    SNOWFLAKE
+    #   # U+2745  ❅    TIGHT TRIFOLIATE SNOWFLAKE
+    #   # U+2746  ❆    HEAVY CHEVRON SNOWFLAKE
+    def self.regrep_display_slow(regexp)
+      codepoints = regrep_slow(regexp)
+      codepoints.each do |cp|
+        puts "#{Properties.deccp2stdhexcp(cp[:codepoint]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
+      end
+      nil
+    end
+  end
+end

data/lib/unisec/utils.rb

@@ -98,6 +98,16 @@ module Unisec
           :string
         end
       end
+
+      # Reverse a string by graphemes (not by code points)
+      # @return [String] the reversed string
+      # @example
+      #   b = "\u{1f1eb}\u{1f1f7}\u{1F413}" # => "🇫🇷🐓"
+      #   b.reverse # => "🐓🇷🇫"
+      #   Unisec::Utils::String.grapheme_reverse(b) # => "🐓🇫🇷"
+      def self.grapheme_reverse(str)
+        str.grapheme_clusters.reverse.join
+      end
     end
   end
 end

data/lib/unisec/version.rb

@@ -2,5 +2,5 @@
 
 module Unisec
   # Version of unisec library and app
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
 end

data/lib/unisec/versions.rb

@@ -51,6 +51,10 @@ module Unisec
         unicodeconfusable_unicode: {
           version: Unicode::Confusable::UNICODE_VERSION,
           label: 'Unicode (unicode-confusable gem)'
+        },
+        ucd_derivedname: {
+          version: Unisec::Rugrep.ucd_derivedname_version,
+          label: 'UCD (data/DerivedName.txt)'
         }
       }
     end
@@ -76,6 +80,7 @@ module Unisec
       display.call(:twittercldr_icu)
       display.call(:twittercldr_cldr)
       display.call(:ruby_unicode_emoji)
+      display.call(:ucd_derivedname)
       puts Paint["\nGems:", :underline]
       display.call(:unisec)
       display.call(:twittercldr)

data/lib/unisec.rb

@@ -2,9 +2,11 @@
 
 require 'unisec/version'
 
-require 'unisec/surrogates'
+require 'unisec/bidi'
+require 'unisec/confusables'
 require 'unisec/hexdump'
 require 'unisec/properties'
-require 'unisec/confusables'
-require 'unisec/versions'
+require 'unisec/rugrep'
 require 'unisec/size'
+require 'unisec/surrogates'
+require 'unisec/versions'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unisec
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Alexandre ZANNI
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-18 00:00:00.000000000 Z
+date: 2024-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ctf-party
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: dry-cli
   requirement: !ruby/object:Gem::Requirement
@@ -86,7 +86,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
-description: Toolkit for security research manipulating Unicode
+description: 'Toolkit for security research manipulating Unicode: confusables, homoglyphs,
+  hexdump, code point, UTF-8, UTF-16, UTF-32, properties, regexp search, size, grapheme,
+  surrogates, version, ICU, CLDR, UCD'
 email: alexandre.zanni@europe.com
 executables:
 - unisec
@@ -95,17 +97,22 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - bin/unisec
+- data/DerivedName.txt
 - lib/unisec.rb
+- lib/unisec/bidi.rb
+- lib/unisec/cli/bidi.rb
 - lib/unisec/cli/cli.rb
 - lib/unisec/cli/confusables.rb
 - lib/unisec/cli/hexdump.rb
 - lib/unisec/cli/properties.rb
+- lib/unisec/cli/rugrep.rb
 - lib/unisec/cli/size.rb
 - lib/unisec/cli/surrogates.rb
 - lib/unisec/cli/versions.rb
 - lib/unisec/confusables.rb
 - lib/unisec/hexdump.rb
 - lib/unisec/properties.rb
+- lib/unisec/rugrep.rb
 - lib/unisec/size.rb
 - lib/unisec/surrogates.rb
 - lib/unisec/utils.rb
@@ -140,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Unicode Security Toolkit