unisec 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1496d192c32a345de077d1643d041f15f960095f4931165a19b1250a52c5897e
+  data.tar.gz: 553ce1f9fa9d21895d31c144dc15fc73483a7301ececa1046138eec9b51a8707
+SHA512:
+  metadata.gz: ae33d34f6bdf6ae0c5a3dd97ffdb3beaf9b2b7a3d3d48697502b272a8db4fc17a6f91bec5596b12c83d7cc609f0b3f7c9a80b7da09d5584537388868364810a5
+  data.tar.gz: c440d1868a5a97a8d6a126c66541d5627ea039086f85d90347dcb52910c32ebc9d1c97f28ce3e0fef62b209f0c982e24414edce98a32406bbc1f802f42bd8ef4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexandre ZANNI at ACCEIS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/bin/unisec

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'unisec'
+require 'unisec/cli/cli'
+
+Dry::CLI.new(Unisec::CLI::Commands).call

data/lib/unisec/cli/cli.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'unisec/cli/surrogates'
+require 'unisec/cli/hexdump'
+require 'unisec/cli/properties'
+require 'unisec/cli/confusables'
+
+module Unisec
+  # Module used to create the CLI for the executable
+  module CLI
+    # Registered commands for the CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      # 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 'confusables list', Confusables::List
+      register 'confusables randomize', Confusables::Randomize
+    end
+  end
+end

data/lib/unisec/cli/confusables.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 confusables xxx` for the class {Unisec::Confusables} from the lib.
+      module Confusables
+        # Command `unisec confusables list`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec confusables list '!'
+        # U+FF01    ！    FULLWIDTH EXCLAMATION MARK
+        # U+01C3    ǃ    LATIN LETTER RETROFLEX CLICK
+        # …
+        # ```
+        class List < Dry::CLI::Command
+          desc 'List confusables characters for a given character'
+
+          argument :character, required: true, desc: 'Unicode code point (as string)'
+          option :map, default: true, values: %w[true false],
+                       desc: 'Allows partial mapping, includes confusable where the given chart is a part of'
+
+          # List confusables characters for a given character
+          # @param character [String] the character to search confusables for
+          # @option options [Boolean] :map allows partial mapping, includes confusable where the given chart is a
+          #   part of
+          def call(character: nil, **options)
+            to_bool = ->(str) { ['true', true].include?(str) }
+            Unisec::Confusables.list_display(character, map: to_bool.call(options.fetch(:map)))
+          end
+        end
+
+        # Command `unisec confusables randomize`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec confusables randomize noraj
+        # Original:    noraj
+        # Transformed: ռ໐𝘳𝜶𝙟
+        # …
+        # ```
+        class Randomize < Dry::CLI::Command
+          desc 'Replace all characters from a string with random confusables when possible'
+
+          argument :str, required: true, desc: 'Unicode string'
+
+          # Replace all characters from a string with random confusables when possible
+          # @param str [String] Unicode string
+          def call(str: nil, **)
+            Unisec::Confusables.randomize_display(str)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/hexdump.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI command `unisec hexdumps` for the class {Unisec::Hexdump} from the lib.
+      #
+      # Example:
+      #
+      # ```plaintext
+      # $ unisec hexdump "ACCEIS"
+      # UTF-8: 41 43 43 45 49 53
+      # UTF-16BE: 0041 0043 0043 0045 0049 0053
+      # UTF-16LE: 4100 4300 4300 4500 4900 5300
+      # UTF-32BE: 00000041 00000043 00000043 00000045 00000049 00000053
+      # UTF-32LE: 41000000 43000000 43000000 45000000 49000000 53000000
+      # ```
+      class Hexdump < Dry::CLI::Command
+        desc 'Hexdump in all Unicode encodings'
+
+        argument :input, required: true,
+                         desc: 'String input'
+
+        # Hexdump of all Unicode encodings.
+        # @param input [String] Input string to encode
+        def call(input: nil, **)
+          puts Unisec::Hexdump.new(input).display
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/properties.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+require 'unisec/utils'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI sub-commands `unisec properties xxx` for the class {Unisec::Properties} from the lib.
+      module Properties
+        # Command `unisec properties list`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec properties list
+        # ASCII_Hex_Digit
+        # Age
+        # Alphabetic
+        # …
+        # ```
+        class List < Dry::CLI::Command
+          desc 'List all Unicode properties'
+
+          # List Unicode properties name
+          def call(**)
+            Unisec::Properties.list.each do |p|
+              puts p
+            end
+          end
+        end
+
+        # Command `unisec properties codepoints`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec properties codepoints Bidi_Control
+        # U+61C     ؜    ARABIC LETTER MARK
+        # …
+        # ```
+        class Codepoints < Dry::CLI::Command
+          desc 'List all code points for a given property'
+
+          argument :property, required: true, desc: 'Unicode property name'
+
+          # List code points matching a Unicode property
+          # @param property [String] property name
+          def call(property: nil, **)
+            Unisec::Properties.codepoints_display(property)
+          end
+        end
+
+        # Command `unisec properties char`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec properties char é
+        # Name:               LATIN SMALL LETTER E WITH ACUTE
+        # Code Point:         U+00E9
+        #
+        # Block:              Latin-1 Supplement
+        # …
+        # ```
+        class Char < Dry::CLI::Command
+          desc 'Returns all properties of a given Unicode character (code point as string)'
+
+          argument :character, required: true, desc: 'Unicode character'
+          option :extended, default: false, values: %w[true false], desc: 'Show all properties'
+
+          # Returns all properties of a given Unicode character (code point as string)
+          # @param character [String] Unicode code point (as character / string)
+          # @option options [Boolean] :extended Show all properties
+          def call(character: nil, **options)
+            to_bool = ->(str) { str == 'true' }
+            Unisec::Properties.char_display(character, extended: to_bool.call(options.fetch(:extended)))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/surrogates.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+require 'unisec/utils'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI sub-commands `unisec surrogates xxx` for the class {Unisec::Surrogates} from the lib.
+      module Surrogates
+        # Command `unisec surrogates from`
+        #
+        # Example:
+        #
+        # ```plaintext
+        # $ unisec surrogates from 0xD801 0xDC37
+        # Char: 𐐷
+        # Code Point: 0x10437, 0d66615, 0b10000010000110111
+        # High Surrogate: 0xD801, 0d55297, 0b1101100000000001
+        # Low Surrogate: 0xDC37, 0d56375, 0b1101110000110111
+        # ```
+        class From < Dry::CLI::Command
+          desc 'Code point ⬅️ Surrogates'
+
+          argument :high, required: true,
+                          desc: 'High surrogate (in hexadecimal (0xXXXX), decimal (0dXXXX), binary (0bXXXX) or as text)'
+          argument :low, required: true,
+                         desc: 'Low surrogate (in hexadecimal (0xXXXX), decimal (0dXXXX), binary (0bXXXX) or as text)'
+
+          # Calculate the Unicode code point based on the surrogates.
+          # @param high [String] decimal high surrogate
+          # @param low [String] decimal low surrogate
+          def call(high: nil, low: nil, **)
+            puts Unisec::Surrogates.new(Unisec::Utils::String.convert(high, :integer),
+                                        Unisec::Utils::String.convert(low, :integer)).display
+          end
+        end
+
+        # Command `unisec surrogates to`
+        #
+        # Example:
+        #
+        # ```plaintext
+        #  $ unisec surrogates to 0x1F4A9
+        #  Char: 💩
+        #  Code Point: 0x1F4A9, 0d128169, 0b11111010010101001
+        #  High Surrogate: 0xD83D, 0d55357, 0b1101100000111101
+        #  Low Surrogate: 0xDCA9, 0d56489, 0b1101110010101001
+        # ```
+        class To < Dry::CLI::Command
+          desc 'Code point ➡️ Surrogates'
+
+          argument :codepoint, required: true,
+                               desc: 'One code point (character) (in hexadecimal (0xXXXX), decimal (0dXXXX), binary ' \
+                                     '(0bXXXX) or as text)'
+
+          # Calculate the surrogates based on the Unicode code point.
+          # @param codepoint [String] decimal codepoint
+          def call(codepoint: nil, **)
+            puts Unisec::Surrogates.new(Unisec::Utils::String.convert(codepoint, :integer)).display
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unisec/confusables.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'unicode/confusable'
+require 'twitter_cldr'
+
+module Unisec
+  # Operations about Unicode confusable characters (homoglyphs).
+  class Confusables
+    # List confusables characters for a given character
+    # @param chr [String] the character to search confusables for
+    # @param map [Boolean] allows partial mapping, includes confusable where the given chart is a part of
+    # @return [Array<String>] list of confusables
+    # @example
+    #   Unisec::Confusables.list('!') # => ["！", "ǃ", "ⵑ", "‼", "⁉", "⁈"]
+    #   Unisec::Confusables.list('!', map: false) # => ["！", "ǃ", "ⵑ"]
+    def self.list(chr, map: true)
+      Unicode::Confusable.list(chr, map)
+    end
+
+    # Display a CLI-friendly output listing all confusables corresponding to a character (code point)
+    # @param chr [String] the character to search confusables for
+    # @param map [Boolean] allows partial mapping, includes confusable where the given chart is a part of
+    def self.list_display(chr, map: true)
+      Confusables.list(chr, map: map).each do |confu|
+        puts "#{Properties.char2codepoint(confu).ljust(9)} #{confu.ljust(4)} " \
+             "#{TwitterCldr::Shared::CodePoint.get(confu.codepoints.first).name}"
+      end
+      nil
+    end
+
+    # Replace all characters with random confusables when possible.
+    # @param str [String] Unicode string
+    # @return [String] input randomized with confusables
+    # @example
+    #   Unisec::Confusables.randomize('noraj') # => "𝓃ⲟ𝓇𝒶ｊ"
+    #   Unisec::Confusables.randomize('noraj') # => "𝗻૦𝚛⍺𝐣"
+    #   Unisec::Confusables.randomize('noraj') # => "𝔫𞺄𝕣⍺ｊ"
+    def self.randomize(str)
+      out = ''
+      str.each_char do |chr|
+        confu = Confusables.list(chr, map: false).sample
+        out += confu.nil? ? chr : confu
+      end
+      out
+    end
+
+    # Display a CLI-friendly output of a string where characters are replaces with random confusables
+    # @param str [String] Unicode string
+    def self.randomize_display(str)
+      display = ->(key, value) { puts Paint[key, :red, :bold].ljust(23) + " #{value}" }
+      display.call('Original:', str)
+      display.call('Transformed:', Unisec::Confusables.randomize(str))
+    end
+  end
+end

data/lib/unisec/hexdump.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'ctf_party'
+
+module Unisec
+  # Hexdump of all Unicode encodings.
+  class Hexdump
+    # UTF-8 hexdump
+    # @return [String] UTF-8 hexdump
+    attr_reader :utf8
+
+    # UTF-16BE hexdump
+    # @return [String] UTF-16BE hexdump
+    attr_reader :utf16be
+
+    # UTF-16LE hexdump
+    # @return [String] UTF-16LE hexdump
+    attr_reader :utf16le
+
+    # UTF-32BE hexdump
+    # @return [String] UTF-32BE hexdump
+    attr_reader :utf32be
+
+    # UTF-32LE hexdump
+    # @return [String] UTF-32LE hexdump
+    attr_reader :utf32le
+
+    # Init the hexdump.
+    # @param str [String] Input string to encode
+    # @example
+    #   hxd = Unisec::Hexdump.new('I 💕 Ruby 💎')
+    #   hxd.utf8 # => "49 20 f0 9f 92 95 20 52 75 62 79 20 f0 9f 92 8e"
+    #   hxd.utf16be # => "0049 0020 d83d dc95 0020 0052 0075 0062 0079 0020 d83d dc8e"
+    #   hxd.utf32be # => "00000049 00000020 0001f495 00000020 00000052 00000075 00000062 00000079 00000020 0001f48e"
+    def initialize(str)
+      @utf8 = Hexdump.utf8(str)
+      @utf16be = Hexdump.utf16be(str)
+      @utf16le = Hexdump.utf16le(str)
+      @utf32be = Hexdump.utf32be(str)
+      @utf32le = Hexdump.utf32le(str)
+    end
+
+    # Encode to UTF-8 in hexdump format (spaced at every code unit = every byte)
+    # @param str [String] Input string to encode
+    # @return [String] hexdump (UTF-8 encoded)
+    # @example
+    #   Unisec::Hexdump.utf8('🐋') # => "f0 9f 90 8b"
+    def self.utf8(str)
+      str.encode('UTF-8').to_hex.scan(/.{2}/).join(' ')
+    end
+
+    # Encode to UTF-16BE in hexdump format (spaced at every code unit = every 2 bytes)
+    # @param str [String] Input string to encode
+    # @return [String] hexdump (UTF-16BE encoded)
+    # @example
+    #   Unisec::Hexdump.utf16be('🐋') # => "d83d dc0b"
+    def self.utf16be(str)
+      str.encode('UTF-16BE').to_hex.scan(/.{4}/).join(' ')
+    end
+
+    # Encode to UTF-16LE in hexdump format (spaced at every code unit = every 2 bytes)
+    # @param str [String] Input string to encode
+    # @return [String] hexdump (UTF-16LE encoded)
+    # @example
+    #   Unisec::Hexdump.utf16le('🐋') # => "3dd8 0bdc"
+    def self.utf16le(str)
+      str.encode('UTF-16LE').to_hex.scan(/.{4}/).join(' ')
+    end
+
+    # Encode to UTF-32BE in hexdump format (spaced at every code unit = every 4 bytes)
+    # @param str [String] Input string to encode
+    # @return [String] hexdump (UTF-32BE encoded)
+    # @example
+    #   Unisec::Hexdump.utf32be('🐋') # => "0001f40b"
+    def self.utf32be(str)
+      str.encode('UTF-32BE').to_hex.scan(/.{8}/).join(' ')
+    end
+
+    # Encode to UTF-32LE in hexdump format (spaced at every code unit = every 4 bytes)
+    # @param str [String] Input string to encode
+    # @return [String] hexdump (UTF-32LE encoded)
+    # @example
+    #   Unisec::Hexdump.utf32le('🐋') # => "0bf40100"
+    def self.utf32le(str)
+      str.encode('UTF-32LE').to_hex.scan(/.{8}/).join(' ')
+    end
+
+    # Display a CLI-friendly output summurizing the hexdump in all Unicode encodings
+    # @example
+    #   puts Unisec::Hexdump.new('K').display # =>
+    #   # UTF-8: e2 84 aa
+    #   # UTF-16BE: 212a
+    #   # UTF-16LE: 2a21
+    #   # UTF-32BE: 0000212a
+    #   # UTF-32LE: 2a210000
+    def display
+      "UTF-8: #{@utf8}\n" \
+        "UTF-16BE: #{@utf16be}\n" \
+        "UTF-16LE: #{@utf16le}\n" \
+        "UTF-32BE: #{@utf32be}\n" \
+        "UTF-32LE: #{@utf32le}"
+    end
+  end
+end

data/lib/unisec/properties.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'twitter_cldr'
+require 'paint'
+
+module Unisec
+  # Manipulate Unicode properties
+  class Properties
+    # List Unicode properties name
+    # @return [Array<String>] properties name
+    # @example
+    #   Unisec::Properties.list # => ["ASCII_Hex_Digit", "Age", "Alphabetic", … ]
+    def self.list
+      TwitterCldr::Shared::CodePoint.properties.property_names
+    end
+
+    # List all code points for a given property
+    # @param prop [String] the property name
+    # @return [Array<Hash>] Array of code points (`{char: String, codepoint: Integer, name: String}`)
+    # @example
+    #   Unisec::Properties.codepoints('Quotation_Mark')
+    #   # =>
+    #   # [{:char=>"\"", :codepoint=>34, :name=>"QUOTATION MARK"},
+    #   #  {:char=>"'", :codepoint=>39, :name=>"APOSTROPHE"},
+    #   #  … ]
+    def self.codepoints(prop)
+      cp = TwitterCldr::Shared::CodePoint
+      out = []
+      ranges = cp.properties.code_points_for_property(prop).ranges
+      ranges.each do |range|
+        range.each do |i|
+          codepoint = cp.get(i)
+          out << {
+            char: TwitterCldr::Utils::CodePoints.to_string([codepoint.code_point]),
+            codepoint: codepoint.code_point,
+            name: codepoint.name
+          }
+        end
+      end
+      out
+    end
+
+    # Display a CLI-friendly output listing all code points corresponding to a property.
+    # @example
+    #   Unisec::Properties.codepoints_display('Quotation_Mark')
+    #   # =>
+    #   # U+0022      "    QUOTATION MARK
+    #   # U+0027      '    APOSTROPHE
+    #   # …
+    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]}"
+      end
+      nil
+    end
+
+    # Returns all properties of a given unicode character (code point)
+    # @param chr [String] Unicode code point (as character / string)
+    # @return [Hash] All properties of the given code point
+    # @example
+    #   Unisec::Properties.char('é')
+    #   # =>
+    #   # {:age=>"1.1",
+    #   # … }
+    def self.char(chr)
+      cp_num = TwitterCldr::Utils::CodePoints.from_string(chr)
+      cp = TwitterCldr::Shared::CodePoint.get(cp_num.first)
+      props = cp.properties
+      props_hash = props.properties_hash.dup
+      %w[Age Block General_Category Script].each { |p| props_hash.delete(p) } # Remaining properties
+      categories = props.general_category.map do |cat|
+        TwitterCldr::Shared::PropertyValueAliases.long_alias_for('gc', cat)
+      end
+      {
+        age: props.age.join,
+        block: props.block.join,
+        category: categories[1],
+        subcategory: categories[0],
+        codepoint: Properties.char2codepoint(chr),
+        name: cp.name,
+        script: props.script.join,
+        case: {
+          ruby: {
+            lowercase: chr.downcase,
+            uppercase: chr.upcase
+          },
+          twitter: {
+            lowercase: chr.localize.downcase.to_s,
+            uppercase: chr.localize.upcase.to_s,
+            titlecase: chr.localize.titlecase.to_s,
+            casefold: chr.localize.casefold.to_s
+          }
+        },
+        normalization: {
+          ruby: {
+            nfkd: chr.unicode_normalize(:nfkd),
+            nfkc: chr.unicode_normalize(:nfkc),
+            nfd: chr.unicode_normalize(:nfd),
+            nfc: chr.unicode_normalize(:nfc)
+          },
+          twitter: {
+            nfkd: chr.localize.normalize(using: :NFKD).to_s,
+            nfkc: chr.localize.normalize(using: :NFKC).to_s,
+            nfd: chr.localize.normalize(using: :NFD).to_s,
+            nfc: chr.localize.normalize(using: :NFC).to_s
+          }
+        },
+        other_properties: props_hash
+      }
+    end
+
+    # Display a CLI-friendly output listing all properties corresponding to character (code point)
+    # @param chr [String] Unicode code point (as character / string)
+    # @param extended [String] By default, it will only show common properties, with extended set to `true` it will
+    #   show all of them.
+    def self.char_display(chr, extended: false)
+      data = Properties.char(chr)
+      display = ->(key, value) { puts Paint[key, :red, :bold].ljust(30) + " #{value}" }
+      display.call('Name:', data[:name])
+      display.call('Code Point:', data[:codepoint])
+      puts
+      display.call('Block:', data[:block])
+      display.call('Category:', data[:category])
+      display.call('Sub-Category:', data[:subcategory])
+      display.call('Script:', data[:script])
+      display.call('Since (age):', "Version #{data[:age]}")
+      puts
+      x = data.dig(:case, :twitter, :uppercase)
+      display.call('Uppercase:', x + " (#{Properties.char2codepoint(x)})")
+      x = data.dig(:case, :twitter, :lowercase)
+      display.call('Lowercase:', x + " (#{Properties.char2codepoint(x)})")
+      x = data.dig(:case, :twitter, :titlecase)
+      display.call('Titlecase:', x + " (#{Properties.char2codepoint(x)})")
+      x = data.dig(:case, :twitter, :casefold)
+      display.call('Casefold:', x + " (#{Properties.char2codepoint(x)})")
+      puts
+      x = data.dig(:normalization, :twitter, :nfkd)
+      display.call('Normalization NFKD:', x + " (#{Properties.chars2codepoints(x)})")
+      x = data.dig(:normalization, :twitter, :nfkc)
+      display.call('Normalization NFKC:', x + " (#{Properties.chars2codepoints(x)})")
+      x = data.dig(:normalization, :twitter, :nfd)
+      display.call('Normalization NFD:', x + " (#{Properties.chars2codepoints(x)})")
+      x = data.dig(:normalization, :twitter, :nfc)
+      display.call('Normalization NFC:', x + " (#{Properties.chars2codepoints(x)})")
+      if extended
+        puts
+        data[:other_properties].each do |k, v|
+          display.call(k, v&.join)
+        end
+      end
+      nil
+    end
+
+    # Display the code point in Unicode format for a given character (code point as string)
+    # @param chr [String] Unicode code point (as character / string)
+    # @return [String] code point in Unicode format
+    # @example
+    #   Unisec::Properties.char2codepoint('💎') # => "U+1F48E"
+    def self.char2codepoint(chr)
+      "U+#{format('%.4x', chr.codepoints.first).upcase}"
+    end
+
+    # Display the code points in Unicode format for the given characters (code points as string)
+    # @param chrs [String] Unicode code points (as characters / string)
+    # @return [String] code points in Unicode format
+    # @example
+    #   Unisec::Properties.chars2codepoints("ỳ́") # => "U+0079 U+0300 U+0301"
+    #   Unisec::Properties.chars2codepoints("🧑‍🌾") # => "U+1F9D1 U+200D U+1F33E"
+    def self.chars2codepoints(chrs)
+      out = []
+      chrs.each_char do |chr|
+        out << Properties.char2codepoint(chr)
+      end
+      out.join(' ')
+    end
+  end
+end

data/lib/unisec/surrogates.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'unisec/utils'
+require 'ctf_party'
+
+module Unisec
+  # UTF-16 surrogates conversion.
+  class Surrogates
+    # Unicode code point
+    # @return [Integer] decimal codepoint
+    attr_reader :cp
+
+    # High surrogate (1st code unit of a surrogate pair). Also called lead surrogate.
+    # @return [Integer] decimal high surrogate
+    attr_reader :hs
+
+    # Low surrogate (2nd code unit of a surrogate pair). Also called trail surrogate.
+    # @return [Integer] decimal low surrogate
+    attr_reader :ls
+
+    # Init the surrogate pair.
+    # @param args [Integer] If one argument is provided, it's evaluated as the
+    #   code point and the two surrogates will be calculated automatically.
+    #   If two arguments are provided, they are evaluated as a surrogate pair (high
+    #   then low) and the code point will be calculated.
+    # @example
+    #   surr = Unisec::Surrogates.new(128169)
+    #   # => #<Unisec::Surrogates:0x00007f96920a7ca8 @cp=128169, @hs=55357, @ls=56489>
+    #   surr.cp # => 128169
+    #   surr.hs # => 55357
+    #   surr.ls # => 56489
+    #   Unisec::Surrogates.new(55357, 56489)
+    #   # => #<Unisec::Surrogates:0x00007f96920689b8 @cp=128169, @hs=55357, @ls=56489>
+    def initialize(*args)
+      if args.size == 1
+        @cp = args[0]
+        @hs = high_surrogate
+        @ls = low_surrogate
+      elsif args.size == 2
+        @hs = args[0]
+        @ls = args[1]
+        @cp = code_point
+      else
+        raise ArgumentError
+      end
+    end
+
+    # Calculate the high surrogate based on the Unicode code point.
+    # @param codepoint [Integer] decimal codepoint
+    # @return [Integer] decimal high surrogate
+    # @example
+    #   Unisec::Surrogates.high_surrogate(128169) # => 55357
+    def self.high_surrogate(codepoint)
+      (((codepoint - 0x10000) / 0x400).floor + 0xd800)
+    end
+
+    # Calculate the low surrogate based on the Unicode code point.
+    # @param codepoint [Integer] decimal codepoint
+    # @return [Integer] decimal low surrogate
+    # @example
+    #   Unisec::Surrogates.low_surrogate(128169) # => 56489
+    def self.low_surrogate(codepoint)
+      (((codepoint - 0x10000) % 0x400) + 0xdc00)
+    end
+
+    # Calculate the Unicode code point based on the surrogates.
+    # @param hs [Integer] decimal high surrogate
+    # @param ls [Integer] decimal low surrogate
+    # @return [Integer] decimal code point
+    # @example
+    #   Unisec::Surrogates.code_point(55357, 56489) # => 128169
+    def self.code_point(hs, ls)
+      (((hs - 0xd800) * 0x400) + ls - 0xdc00 + 0x10000)
+    end
+
+    # Same as accessing {.hs}. Calculate the {.high_surrogate}.
+    # @return [Integer] decimal high surrogate
+    # @example
+    #   surr = Unisec::Surrogates.new(128169)
+    #   surr.high_surrogate # => 55357
+    def high_surrogate
+      @hs = Surrogates.high_surrogate(@cp)
+    end
+
+    # Same as accessing {.ls}. Calculate the {.low_surrogate}.
+    # @return [Integer] decimal low surrogate
+    # @example
+    #   surr = Unisec::Surrogates.new(128169)
+    #   surr.low_surrogate # => 56489
+    def low_surrogate
+      @ls = Surrogates.low_surrogate(@cp)
+    end
+
+    # Same as accessing {.cp}. Calculate the {.code_point}.
+    # @return [Integer] decimal code point
+    #   surr = Unisec::Surrogates.new(55357, 56489)
+    #   surr.code_point # => 128169
+    def code_point
+      @cp = Surrogates.code_point(@hs, @ls)
+    end
+
+    # Display a CLI-friendly output summurizing everithing about the surrogates:
+    # the corresponding character, code point, high and low surrogates
+    # (each displayed as hexadecimal, decimal and binary).
+    # @example
+    #   surr = Unisec::Surrogates.new(128169)
+    #   puts surr.display # =>
+    #   # Char: 💩
+    #   # Code Point: 0x1F4A9, 0d128169, 0b11111010010101001
+    #   # High Surrogate: 0xD83D, 0d55357, 0b1101100000111101
+    #   # Low Surrogate: 0xDCA9, 0d56489, 0b1101110010101001
+    def display
+      "Char: #{[@cp].pack('U*')}\n" \
+        "Code Point: 0x#{@cp.to_hex}, 0d#{@cp}, 0b#{@cp.to_bin}\n" \
+        "High Surrogate: 0x#{@hs.to_hex}, 0d#{@hs}, 0b#{@hs.to_bin}\n" \
+        "Low Surrogate: 0x#{@ls.to_hex}, 0d#{@ls}, 0b#{@ls.to_bin}"
+    end
+  end
+end

data/lib/unisec/utils.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'ctf_party'
+
+class Integer
+  # Convert an integer to an hexadecimal string
+  # @return [String] The interger converted to hexadecimal and casted to an upper case string
+  # @example
+  #   42.to_hex # => "2A"
+  def to_hex
+    to_s(16).upcase
+  end
+
+  # Convert an integer to an binary string
+  # @return [String] The interger converted to binary and casted to a string
+  # @example
+  #   42.to_bin # => "101010"
+  def to_bin
+    to_s(2)
+  end
+end
+
+module Unisec
+  # Generic stuff not Unicode-related that can be re-used.
+  module Utils
+    # About string conversion and manipulation.
+    module String
+      # Convert a string input into the chosen type.
+      # @param input [String] If the target type is `:integer`, the string must represent a number encoded in
+      #   hexadecimal, decimal, binary. If it's a Unicode string, only the first code point will be taken into account.
+      # @param target_type [Symbol] Convert to the chosen type. Currently only supports `:integer`.
+      # @return [Variable] The type of the output depends on the chosen `target_type`.
+      # @example
+      #   Unisec::Utils::String.convert('0x1f4a9', :integer) # => 128169
+      def self.convert(input, target_type)
+        case target_type
+        when :integer
+          convert_to_integer(input)
+        else
+          raise TypeError, "Target type \"#{target_type}\" not avaible"
+        end
+      end
+
+      # Internal method used for {.convert}.
+      #
+      # Convert a string input into integer.
+      # @param input [String] The string must represent a number encoded in hexadecimal, decimal, binary. If it's a
+      #   Unicode string, only the first code point will be taken into account. The input type is determined
+      #   automatically based on the prefix.
+      # @return [Integer]
+      # @example
+      #   # Hexadecimal
+      #   Unisec::Utils::String.convert_to_integer('0x1f4a9') # => 128169
+      #   # Decimal
+      #   Unisec::Utils::String.convert_to_integer('0d128169') # => 128169
+      #   # Binary
+      #   Unisec::Utils::String.convert_to_integer('0b11111010010101001') # => 128169
+      #   # Unicode string
+      #   Unisec::Utils::String.convert_to_integer('💩') # => 128169
+      def self.convert_to_integer(input)
+        case autodetect(input)
+        when :hexadecimal
+          input.hex2dec(prefix: '0x').to_i
+        when :decimal
+          input.to_i
+        when :binary
+          input.bin2hex.hex2dec.to_i
+        when :string
+          input.codepoints.first
+        else
+          raise TypeError, "Input \"#{input}\" is not of the expected type"
+        end
+      end
+
+      # Internal method used for {.convert}.
+      #
+      # Autodetect the representation type of the string input.
+      # @param str [String] Input.
+      # @return [Symbol] the detected type: `:hexadecimal`, `:decimal`, `:binary`, `:string`.
+      # @example
+      #   # Hexadecimal
+      #   Unisec::Utils::String.autodetect('0x1f4a9') # => :hexadecimal
+      #   # Decimal
+      #   Unisec::Utils::String.autodetect('0d128169') # => :decimal
+      #   # Binary
+      #   Unisec::Utils::String.autodetect('0b11111010010101001') # => :binary
+      #   # Unicode string
+      #   Unisec::Utils::String.autodetect('💩') # => :string
+      def self.autodetect(str)
+        case str
+        when /0x[0-9a-fA-F]/
+          :hexadecimal
+        when /0d[0-9]+/
+          :decimal
+        when /0b[0-1]+/
+          :binary
+        else
+          :string
+        end
+      end
+    end
+  end
+end

data/lib/unisec/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Unisec
+  # Version of unisec library and app
+  VERSION = '0.0.1'
+end

data/lib/unisec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'unisec/version'
+
+require 'unisec/surrogates'
+require 'unisec/hexdump'
+require 'unisec/properties'
+require 'unisec/confusables'

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: unisec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexandre ZANNI
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ctf-party
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: twitter_cldr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.11.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.11.5
+- !ruby/object:Gem::Dependency
+  name: unicode-confusable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: Toolkit for security research manipulating Unicode
+email: alexandre.zanni@europe.com
+executables:
+- unisec
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- bin/unisec
+- lib/unisec.rb
+- lib/unisec/cli/cli.rb
+- lib/unisec/cli/confusables.rb
+- lib/unisec/cli/hexdump.rb
+- lib/unisec/cli/properties.rb
+- lib/unisec/cli/surrogates.rb
+- lib/unisec/confusables.rb
+- lib/unisec/hexdump.rb
+- lib/unisec/properties.rb
+- lib/unisec/surrogates.rb
+- lib/unisec/utils.rb
+- lib/unisec/version.rb
+homepage: https://github.com/Acceis/unisec
+licenses:
+- MIT
+metadata:
+  yard.run: yard
+  bug_tracker_uri: https://github.com/Acceis/unisec/issues
+  changelog_uri: https://github.com/Acceis/unisec/releases
+  documentation_uri: https://acceis.github.io/unisec/
+  homepage_uri: https://github.com/Acceis/unisec
+  source_code_uri: https://github.com/Acceis/unisec/
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Unicode Security Toolkit
+test_files: []