izokatu 0.1.1

data/lib/izokatu/action_call_selector.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Izokatu selector of action class to be called
+  class ActionCallSelector
+    extend Callable
+
+    include Contracts
+
+    # @return [Symbol] library used for encryption/decryption
+    attr_reader :via
+    # @return [Symbol] mode of encryption/decryption
+    attr_reader :mode
+    # @return [Symbol] action to execute
+    attr_reader :action
+    # @return [Symbol] OpenSSL public key cipher type
+    attr_reader :asym_cipher_type
+    # @return [Bool] equality of cipher mode to CCM
+    attr_reader :ccm_cipher
+    # @return [Bool] status of cipher as authenticated
+    attr_reader :auth_cipher
+
+    Contract Contracts::HashOf[Symbol, Or[Symbol, Bool]] => Any
+    # Initializing options for selection of action class
+    #
+    # @param via (#via)
+    # @param mode (#mode)
+    # @param action (#action)
+    # @param asym_cipher_type (#asym_cipher_type)
+    # @param ccm_cipher (#ccm_cipher)
+    # @param auth_cipher (#auth_cipher)
+    #
+    # @since 0.1.0
+    def initialize(via:, mode:, action:, asym_cipher_type:, ccm_cipher:, auth_cipher:)
+      @via = via
+      @mode = mode
+      @action = action
+      @asym_cipher_type = asym_cipher_type
+      @ccm_cipher = ccm_cipher
+      @auth_cipher = auth_cipher
+    end
+
+    Contract None => Class
+    # Selecting action class for keys generation or encryption/decryption
+    #
+    # @return [Class] selected class for keys generation
+    #
+    # @since 0.1.0
+    def perform
+      action == :keys_generation ? select_keys_generation_action_call : select_default_action_call
+    end
+
+    private
+
+    Contract None => Class
+    # Selecting action class for keys generation
+    #
+    # @return [Class] selected class for keys generation
+    #
+    # @since 0.1.0
+    def select_keys_generation_action_call
+      case [via, mode, action, asym_cipher_type, ccm_cipher, auth_cipher]
+        in [:rbnacl, :public_key, :keys_generation, _, _, _]
+          Izokatu::Rbnacl::PublicKey::KeysGenerator
+        in [:openssl, :public_key, :keys_generation, :rsa, _, _]
+          Izokatu::Openssl::PublicKey::RSA::KeysGenerator
+        in [:openssl, :public_key, :keys_generation, :ec, _, _]
+          Izokatu::Openssl::PublicKey::EC::KeysGenerator
+      end
+    end
+
+    Contract None => Class
+    # Selecting action class for encryption/decryption
+    #
+    # @return [Class] selected class for encryption/decryption
+    #
+    # @since 0.1.0
+    def select_default_action_call
+      via == :rbnacl ? select_rbnacl_action_call : select_openssl_action_call
+    end
+
+    Contract None => Class
+    # Selecting action class for Rbnacl encryption/decryption
+    #
+    # @return [Class] selected class for Rbnal encryption/decryption
+    #
+    # @since 0.1.0
+    def select_rbnacl_action_call
+      case [via, mode, action, asym_cipher_type, ccm_cipher, auth_cipher]
+        in [:rbnacl, :private_key, :encryption, _, _, _]
+          Izokatu::Rbnacl::PrivateKey::Encrypter
+        in [:rbnacl, :private_key, :decryption, _, _, _]
+          Izokatu::Rbnacl::PrivateKey::Decrypter
+        in [:rbnacl, :public_key, :encryption, _, _, _]
+          Izokatu::Rbnacl::PublicKey::Encrypter
+        in [:rbnacl, :public_key, :decryption, _, _, _]
+          Izokatu::Rbnacl::PublicKey::Decrypter
+      end
+    end
+
+    Contract None => Class
+    # Selecting action class for Openssl encryption/decryption
+    #
+    # @return [Class] selected class for encryption/decryption
+    #
+    # @since 0.1.0
+    def select_openssl_action_call
+      case [via, mode, action, asym_cipher_type, ccm_cipher, auth_cipher]
+        in [:openssl, :private_key, :encryption, _, false, false]
+          Izokatu::Openssl::PrivateKey::Default::Encrypter
+        in [:openssl, :private_key, :decryption, _, false, false]
+          Izokatu::Openssl::PrivateKey::Default::Decrypter
+        in [:openssl, :private_key, :encryption, _, false, true]
+          Izokatu::Openssl::PrivateKey::Auth::Encrypter
+        in [:openssl, :private_key, :decryption, _, false, true]
+          Izokatu::Openssl::PrivateKey::Auth::Decrypter
+        in [:openssl, :private_key, :encryption, _, true, _]
+          Izokatu::Openssl::PrivateKey::Auth::CCM::Encrypter
+        in [:openssl, :private_key, :decryption, _, true, _]
+          Izokatu::Openssl::PrivateKey::Auth::CCM::Decrypter
+        in [:openssl, :public_key, :encryption, :rsa, _, _]
+          Izokatu::Openssl::PublicKey::RSA::Encrypter
+        in [:openssl, :public_key, :decryption, :rsa, _, _]
+          Izokatu::Openssl::PublicKey::RSA::Decrypter
+        in [:openssl, :public_key, :encryption, :ec, _, _]
+          Izokatu::Openssl::PublicKey::EC::Encrypter
+        in [:openssl, :public_key, :decryption, :ec, _, _]
+          Izokatu::Openssl::PublicKey::EC::Decrypter
+      end
+    end
+  end
+end

data/lib/izokatu/callable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Shared call method for classes
+  module Callable
+    # Public call method for classes
+    #
+    # @since 0.1.0
+    def call(...)
+      new(...).perform
+    end
+  end
+end

data/lib/izokatu/ciphers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Namespace for OpenSSL classes
+  module Openssl
+    # List of OpenSSL private key ciphers
+    PKEY_CIPHERS = OpenSSL::Cipher.ciphers.map(&:upcase)
+
+    # Wrap cipher are not working in Openssl. Here text of error:
+    # OpenSSL::Cipher::CipherError: wrap mode not allowed
+    # Or straight from openssl 1.1.1d
+    # error:0607B0AA:digital envelope routines:EVP_CipherInit_ex:wrap mode not allowed:../crypto/evp/evp_enc.c:161
+    PKEY_CIPHERS.delete_if { |name| name.include?('WRAP') }
+
+    # List of OpenSSL public key EC ciphers
+    PBKEY_EC_CIPHERS = OpenSSL::PKey::EC.builtin_curves.map! { |cipher_name, _| cipher_name }
+  end
+end

data/lib/izokatu/decrypter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Abstract class for decrypters
+  #
+  # @abstract Subclasses are containing implementation of {#decrypt_data!}
+  class Decrypter
+    extend Callable
+
+    include Contracts
+
+    # @return decrypter instance
+    attr_reader :decrypter
+    # @return [String] encrypted data for decryption
+    attr_reader :encrypted_data
+    # @return [Hash] decrypted data for export
+    attr_reader :decrypted_data
+
+    Contract Contracts::HashOf[Symbol, String] => Any
+    # Initializing option for decryption
+    #
+    # @param encrypted_data (#encrypted_data)
+    #
+    # @since 0.1.0
+    def initialize(encrypted_data:)
+      import_encrypted_data!(encrypted_data)
+    end
+
+    Contract String => String
+    # Importing encrypted data from param
+    #
+    # @param encrypted_data (#encrypted_data)
+    #
+    # @return [String] (#encrypted_data)
+    #
+    # @since 0.1.0
+    def import_encrypted_data!(encrypted_data)
+      @encrypted_data = encrypted_data
+    end
+
+    Contract None => Contracts::HashOf[Symbol, String]
+    # Performing data decryption
+    #
+    # @return [Hash] decrypted data
+    #
+    # @since 0.1.0
+    def perform
+      decrypt_data!
+    end
+
+    private
+
+    # Decrypting data
+    #
+    # @raise RuntimeError
+    #
+    # @since 0.1.0
+    def decrypt_data!
+      raise 'Not implemented!'
+    end
+  end
+end

data/lib/izokatu/encrypter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Abstract class for encrypters
+  #
+  # @abstract Subclasses are containing implementation of {#encrypt_data!}
+  class Encrypter
+    extend Callable
+
+    include Contracts
+
+    # @return encrypter instance
+    attr_reader :encrypter
+    # @return [String] clear data for encryption
+    attr_reader :clear_data
+    # @return [Hash] encrypted data for export
+    attr_reader :encrypted_data
+
+    # Default options for Izokatu::Encrypter
+    DEFAULT_OPTIONS = {
+      clear_data_string: 'Testing, testing...'
+    }.freeze
+
+    Contract Contracts::HashOf[Symbol, String] => Any
+    # Initializing option for encryption
+    #
+    # @param clear_data (#clear_data)
+    #
+    # @since 0.1.0
+    def initialize(clear_data:)
+      import_clear_data!(clear_data)
+    end
+
+    Contract String => String
+    # Imporing clear data from options
+    #
+    # @param clear_data (#clear_data)
+    #
+    # @return [String] (#clear_data)
+    #
+    # @since 0.1.0
+    def import_clear_data!(clear_data)
+      @clear_data = clear_data || DEFAULT_OPTIONS[:clear_data_string]
+    end
+
+    Contract None => Contracts::ArrayOf[Contracts::HashOf[Symbol, Maybe[String]]]
+    # Performing encryption
+    #
+    # @return [Hash] encrypted data with params
+    #
+    # @since 0.1.0
+    def perform
+      encrypt_data!
+    end
+
+    private
+
+    # Encrypting data`
+    #
+    # @raise RuntimeError
+    #
+    # @since 0.1.0
+    def encrypt_data!
+      raise 'Not implemented!'
+    end
+  end
+end

data/lib/izokatu/exporter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Abstract class for exporters
+  #
+  # @abstract Subclasses are containing implementation of {#perform}
+  class Exporter
+    extend Callable
+
+    include Contracts
+    include Izokatu::Helpers
+
+    # @return [String] data for export
+    attr_reader :data
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, Maybe[String]], Bool]] => Any
+    # Initializing data for export
+    #
+    # @param data (#data)
+    # @param encode [TrueClass || FalseClass] Enable/disable encoding of exported data
+    #
+    # @since 0.1.0
+    def initialize(data:, encode:)
+      @data = encode ? encode_data(data) : data
+    end
+
+    # Performing export of initialized data
+    #
+    # @raise RuntimeError
+    #
+    # @since 0.1.0
+    def perform
+      raise 'Not implemented!'
+    end
+  end
+end

data/lib/izokatu/exporter/file_exporter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Izokatu exporter for exporting data in some file
+  class FileExporter < Izokatu::Exporter
+    # @return [String] name of file to export
+    attr_reader :filename
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, Maybe[String]], String, Bool]] => Any
+    # Initializing data for file export
+    #
+    # @param data (#data)
+    # @param filename (#filename)
+    # @param encode [TrueClass || FalseClass] Enable/disable encoding of exported data
+    #
+    # @since 0.1.0
+    def initialize(data:, filename:, encode:)
+      super(data: data, encode: encode)
+      @filename = filename
+    end
+
+    Contract None => Contracts::HashOf[Symbol, Maybe[String]]
+    # Performing export of initialized data
+    #
+    # @return [Hash] exported data
+    #
+    # @since 0.1.0
+    def perform
+      File.open(filename, 'w') do |f|
+        data.each do |_k, v|
+          f.puts(v)
+        end
+      end
+    end
+  end
+end

data/lib/izokatu/exporter/function_exporter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Izokatu exporter for exporting data in some function
+  class FunctionExporter < Izokatu::Exporter
+    Contract None => Contracts::HashOf[Symbol, Maybe[String]]
+    # Performing export of initialized data
+    #
+    # @return [Hash] exported data
+    #
+    # @since 0.1.0
+    def perform
+      data
+    end
+  end
+end

data/lib/izokatu/exporter/stdout_exporter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Izokatu exporter for exporting data in STDOUT
+  class StdoutExporter < Izokatu::Exporter
+    Contract None => Contracts::HashOf[Symbol, String]
+    # Performing export of initialized data
+    #
+    # @return [Hash] exported data
+    #
+    # @since 0.1.0
+    def perform
+      data.each do |_k, v|
+        puts v
+      end
+    end
+  end
+end

data/lib/izokatu/helpers.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Izokatu
+  # Izokatu helper methods
+  module Helpers
+    include Contracts
+
+    # Default Symbol keys for keys
+    KEY_SYMBOL = %i[private_key public_key].freeze
+    # Rbnacl classes for keys
+    RBNACL_KEY_CLASSES = [
+      RbNaCl::Boxes::Curve25519XSalsa20Poly1305::PrivateKey,
+      RbNaCl::Boxes::Curve25519XSalsa20Poly1305::PublicKey
+    ].freeze
+
+    # Verify cipher is included in OpenSSL public key EC ciphers
+    EC_CIPHER = ->(c) { Izokatu::Openssl::PBKEY_EC_CIPHERS.include?(c) }
+
+    Contract EC_CIPHER => Contracts::HashOf[Or[*KEY_SYMBOL], String]
+    # Generating EC keypair
+    #
+    # @param cipher [String] cipher for keys encryption
+    #
+    # @return [Hash] keypair of EC public and private key
+    #
+    # @since 0.1.0
+    def generate_ec_keypair(cipher = 'secp521r1')
+      Izokatu::Openssl::PublicKey::EC::KeysGenerator.call(cipher: cipher)
+    end
+
+    Contract Pos => Contracts::HashOf[Or[*KEY_SYMBOL], String]
+    # Generating RSA keypair
+    #
+    # @param bit_number [Integer] number of key bits
+    #
+    # @return [Hash] keypair of RSA public and private key
+    #
+    # @since 0.1.0
+    def generate_rsa_keypair(bit_number = 4096)
+      Izokatu::Openssl::PublicKey::RSA::KeysGenerator.call(bit_number: bit_number)
+    end
+
+    Contract None => Contracts::HashOf[Or[*KEY_SYMBOL], Or[*RBNACL_KEY_CLASSES]]
+    # Generating RbNaCl keypair
+    #
+    # @return [Hash] keypair of RbNaCl public and private key
+    #
+    # @since 0.1.0
+    def generate_rbnacl_keypair
+      Izokatu::Rbnacl::PublicKey::KeysGenerator.call
+    end
+
+    Contract None => Contracts::HashOf[Symbol, Or[String, Symbol, Bool]]
+    # Performing encryption and merging result in options
+    #
+    # @since 0.1.0
+    def import_encrypted_in_options!
+      encrypted_data, decrypter_params = encrypt(options)
+      options.merge!(encrypted_data)
+      options.merge!(decrypter_params)
+    end
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, Maybe[String]], String, Bool]] =>
+    Contracts::HashOf[Symbol, Maybe[String]]
+    # Exporting encrypted data and decrypter params
+    #
+    # @param encrypted_data [Hash] Hash with encrypted data for export
+    # @param decrypter_params [Hash] Hash with decrypter params for export
+    # @param encode [TrueClass || FalseClass] Enable/disable encoding of exported data
+    #
+    # @return [Hash] merged encrypted data and decrypter params
+    #
+    # @note Returning merged value even if not using :function exporter
+    #
+    # @since 0.1.0
+    def export_encrypted!(encrypted_data:, decrypter_params:, encode:)
+      export_data(
+        data: encrypted_data,
+        filename: options[:encrypted_data_filename],
+        encode: encode
+      ).merge!(
+        export_data(
+          data: decrypter_params,
+          filename: options[:decrypter_params_filename],
+          encode: encode
+        )
+      )
+    end
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, String], String, Bool]] =>
+    Contracts::HashOf[Symbol, String]
+    # Exporting decrypted data
+    #
+    # @param decrypted_data [Hash] Hash with encrypted data for export
+    # @param encode [TrueClass || FalseClass] Enable/disable encoding of exported data
+    #
+    # @return [Hash] decrypted data
+    #
+    # @note Returning value even if not using :function exporter
+    #
+    # @since 0.1.0
+    def export_decrypted!(decrypted_data:, encode:)
+      export_data(
+        data: decrypted_data,
+        filename: options[:decrypted_data_filename],
+        encode: encode
+      )
+    end
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, Maybe[String]], Maybe[String], Bool]] =>
+    Contracts::HashOf[Symbol, Maybe[String]]
+    # Exporting data
+    #
+    # @param data [Hash] Hash with data for export
+    # @param filename [String] Name of file for export
+    # @param encode [TrueClass || FalseClass] Enable/disable encoding of exported data
+    #
+    # @return [Hash] exported data
+    #
+    # @note Returning value even if not using :function exporter
+    #
+    # @since 0.1.0
+    def export_data(data:, filename:, encode:)
+      other_options = { data: data, encode: encode }
+      file_options = {
+        data: data,
+        filename: filename,
+        encode: encode
+      }
+      exporter = options[:exporter]
+      exporter_options = exporter == Izokatu::FileExporter ? file_options : other_options
+      exporter.call(**exporter_options)
+    end
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, Any], Bool]] =>
+    Contracts::HashOf[Symbol, Any]
+    # Importing encrypted data and decrypter params
+    #
+    # @param options [Hash] Hash with options
+    # @param decode [TrueClass || FalseClass] Enable/disable decoding of imported data
+    #
+    # @return [Hash] Hash with updated options
+    #
+    # @since 0.1.0
+    def import_encrypted!(options:, decode:)
+      encrypted_data = options.select { |k, _v| k == :encrypted_data_string }
+      decrypter_params_default_keys = %i[nonce key auth_data auth_tag]
+      decrypter_params = options.select { |k, _v| decrypter_params_default_keys.include?(k) }
+      options.merge! import_data(
+        data: encrypted_data,
+        filename: options[:encrypted_data_filename],
+        delete_imported: options[:delete_imported],
+        decode: decode
+      )
+      options.merge! import_data(
+        data: decrypter_params,
+        filename: options[:decrypter_params_filename],
+        delete_imported: options[:delete_imported],
+        decode: decode
+      )
+    end
+
+    Contract Contracts::HashOf[Symbol, Or[Contracts::HashOf[Symbol, String], Any]] =>
+    Contracts::HashOf[Symbol, Maybe[String]]
+    # Importing data
+    #
+    # @param data [Hash] Hash with data to import from
+    # @param filename [String] Name of file to import from
+    # @param delete_imported [TrueClass, FalseClass] Enable/disable deleting file after import
+    # @param decode [TrueClass || FalseClass] Enable/disable decoding of imported data
+    #
+    # @return [Hash] imported data
+    #
+    # @since 0.1.0
+    def import_data(data:, filename:, delete_imported:, decode:)
+      function_options = { data: data, decode: decode }
+      file_options = {
+        filename: filename,
+        delete_imported: delete_imported,
+        decode: decode
+      }
+      importer = options[:importer]
+      importer_options = importer == Izokatu::FunctionImporter ? function_options : file_options
+      importer.call(**importer_options)
+    end
+
+    Contract Contracts::HashOf[Symbol, Maybe[String]] =>
+    Contracts::HashOf[Symbol, Maybe[String]]
+    # Encoding data
+    #
+    # @param data [Hash] Hash with data for encoding
+    #
+    # @return [Hash] encoded data
+    #
+    # @since 0.1.0
+    def encode_data(data)
+      data.transform_values { |v| Base64.strict_encode64(v) if v }
+    end
+
+    Contract Contracts::HashOf[Symbol, Maybe[String]] =>
+    Contracts::HashOf[Symbol, Maybe[String]]
+    # Decoding data
+    #
+    # @param data [Hash] Hash with data for decoding
+    #
+    # @return [Hash] decoded data
+    #
+    # @since 0.1.0
+    def decode_data(data)
+      data.transform_values { |v| Base64.strict_decode64(v) if v }
+    end
+  end
+end