izokatu 0.1.1

data/lib/izokatu/openssl/private_key/default/decrypter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Izokatu
+  module Openssl
+    # Namespace for Openssl private key classes
+    module PrivateKey
+      # Namespace for OpenSSL private key non-authenticated classes
+      module Default
+        # OpenSSL private key decrypter for non-authenticated ciphers
+        class Decrypter < Izokatu::Decrypter
+          # @return [String] OpenSSL private key cipher
+          attr_reader :cipher
+          # @return [String] key for private key encryption/decryption
+          attr_reader :key
+          # @return [String] initialization vector for one-time use
+          attr_reader :nonce
+
+          # Default Openssl::PrivateKey::Default::Decrypter option
+          DEFAULT_OPTIONS = {
+            cipher: 'AES256'
+          }.freeze
+
+          Contract Contracts::HashOf[Symbol, String] => Any
+          # Initialize options for OpenSSL EC decryption
+          #
+          # @param encrypted_data (#encrypted_data)
+          # @param cipher (#cipher)
+          # @param key (#key)
+          # @param nonce (#nonce)
+          #
+          # @since 0.1.0
+          def initialize(encrypted_data:, cipher:, key:, nonce:)
+            super(encrypted_data: encrypted_data)
+            @cipher = cipher || DEFAULT_OPTIONS[:cipher]
+            @key = key
+            @nonce = nonce
+            create_decrypter!
+            initialize_decrypter_params!
+          end
+
+          private
+
+          Contract None => OpenSSL::Cipher
+          # Initializing decrypter
+          #
+          # @return [OpenSSL::Cipher] decrypter instance
+          #
+          # @since 0.1.0
+          def create_decrypter!
+            @decrypter = OpenSSL::Cipher.new(cipher).decrypt
+          end
+
+          Contract None => Any
+          # Initializing decrypter params
+          #
+          # @since 0.1.0
+          def initialize_decrypter_params!
+            decrypter.key = key
+            decrypter.iv = nonce
+          end
+
+          Contract None => Contracts::HashOf[Symbol, String]
+          # Decrypting data
+          #
+          # @return [Hash] decrypted data
+          #
+          # @since 0.1.0
+          def decrypt_data!
+            { decrypted_data_string: decrypter.update(encrypted_data) + decrypter.final }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/izokatu/openssl/private_key/default/encrypter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Izokatu
+  module Openssl
+    module PrivateKey
+      module Default
+        # OpenSSL private key encrypter for non-authenticated ciphers
+        class Encrypter < Izokatu::Encrypter
+          # @return [String] OpenSSL private key cipher
+          attr_reader :cipher
+          # @return [String] key for private key encryption/decryption
+          attr_reader :key
+          # @return [String] initialization vector for one-time use
+          attr_reader :nonce
+
+          # Default Openssl::PrivateKey::Default::Encrypter option
+          DEFAULT_OPTIONS = {
+            cipher: 'AES256'
+          }.freeze
+
+          Contract Contracts::HashOf[Symbol, String] => Any
+          # Initializing options for OpenSSL EC encryption
+          #
+          # @param clear_data (#clear_data)
+          # @param cipher (#cipher)
+          #
+          # @since 0.1.0
+          def initialize(clear_data:, cipher:)
+            super(clear_data: clear_data)
+            @cipher = cipher || DEFAULT_OPTIONS[:cipher]
+            create_encrypter!
+            @key = encrypter.random_key
+            @nonce = encrypter.random_iv
+            initialize_encrypter_params!
+          end
+
+          private
+
+          Contract None => OpenSSL::Cipher
+          # Initializing encrypter
+          #
+          # @return [OpenSSL::Cipher] encrypter instance
+          #
+          # @since 0.1.0
+          def create_encrypter!
+            @encrypter = OpenSSL::Cipher.new(cipher).encrypt
+          end
+
+          Contract None => Any
+          # Initializing encrypter params
+          #
+          # @since 0.1.0
+          def initialize_encrypter_params!
+            # OpenSSL::Cipher instances has only key=, iv= and auth_data= methods
+            encrypter.key = key
+            encrypter.iv = nonce
+          end
+
+          Contract None => Contracts::ArrayOf[Contracts::HashOf[Symbol, String]]
+          # Encrypting data
+          #
+          # @return [Array] encrypted data with decrypter params
+          #
+          # @since 0.1.0
+          def encrypt_data!
+            [
+              { encrypted_data_string: encrypter.update(clear_data) + encrypter.final },
+              { key: key, nonce: nonce }
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/izokatu/openssl/public_key/ec/decrypter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Izokatu
+  module Openssl
+    module PublicKey
+      module EC
+        # OpenSSL public key EC decrypter
+        class Decrypter < Izokatu::Decrypter
+          # @return [String] private key string for decryption
+          attr_reader :private_key
+          # @return [String] ECIES cipher name
+          attr_reader :ecies_cipher
+          # @return [String] ECIES digest name
+          attr_reader :ecies_digest
+          # @return [Symbol] ECIES MAC length
+          attr_reader :ecies_mac_length
+          # @return [String] ECIES KDF digest name
+          attr_reader :ecies_kdf_digest
+          # @return [String] ECIES MAC digest name
+          attr_reader :ecies_mac_digest
+
+          # Default options for ECIES
+          DEFAULT_ECIES_OPTIONS = {
+            ecies_cipher: 'AES-256-CTR',
+            ecies_digest: 'SHA512',
+            ecies_mac_length: :full,
+            ecies_kdf_digest: 'SHA512',
+            ecies_mac_digest: 'SHA512'
+          }.freeze
+
+          Contract Contracts::HashOf[Symbol, Maybe[String]] => Any
+          def initialize(encrypted_data:, private_key:, ecies_options:)
+            # Initialize options for OpenSSL EC decryption
+            #
+            # @param encrypted_data (#encrypted_data)
+            # @param private_key (#private_key)
+            # @param ecies_options Hash with ECIES options
+            #
+            # @since 0.1.0
+            super(encrypted_data: encrypted_data)
+            initialize_private_key!(private_key)
+            initialize_ecies_options!(ecies_options || DEFAULT_ECIES_OPTIONS)
+            initialize_decrypter!
+          end
+
+          Contract String => OpenSSL::PKey::EC
+          # Initialize EC private key from private key string
+          #
+          # @param private_key (#private_key)
+          #
+          # @return [OpenSSL:PKey::EC] OpenSSL private key instance
+          #
+          # @since 0.1.0
+          def initialize_private_key!(private_key)
+            raise 'ERROR: No private key!' unless private_key
+
+            @private_key = OpenSSL::PKey.read(private_key)
+          end
+
+          Contract Contracts::HashOf[Symbol, Or[String, Symbol]] => Any
+          # Initialize ECIES options
+          #
+          # @param ecies_options Hash with ECIES options
+          #
+          # @since 0.1.0
+          def initialize_ecies_options!(ecies_options)
+            @ecies_cipher = ecies_options[:ecies_cipher]
+            @ecies_digest = ecies_options[:ecies_digest]
+            @ecies_mac_length = ecies_options[:ecies_mac_length]
+            @ecies_kdf_digest = ecies_options[:ecies_kdf_digest]
+            @ecies_mac_digest = ecies_options[:ecies_mac_digest]
+          end
+
+          Contract None => ECIES::Crypt
+          # Initialize decrypter
+          #
+          # @return [ECIES::Crypt] decrypter instance
+          #
+          # @since 0.1.0
+          def initialize_decrypter!
+            @decrypter = ECIES::Crypt.new(
+              cipher: ecies_cipher,
+              digest: ecies_digest,
+              mac_length: ecies_mac_length,
+              kdf_digest: ecies_kdf_digest,
+              mac_digest: ecies_mac_digest
+            )
+          end
+
+          private
+
+          Contract None => Contracts::HashOf[Symbol, String]
+          # Decrypting data
+          #
+          # @return [Hash] decrypted data
+          #
+          # @since 0.1.0
+          def decrypt_data!
+            { decrypted_data_string: decrypter.decrypt(private_key, encrypted_data) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/izokatu/openssl/public_key/ec/encrypter.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Izokatu
+  module Openssl
+    module PublicKey
+      module EC
+        # OpenSSL public key EC encrypter
+        class Encrypter < Izokatu::Encrypter
+          # @return [String] public key string for decryption
+          attr_reader :public_key
+          # @return [String] ECIES cipher name
+          attr_reader :ecies_cipher
+          # @return [String] ECIES digest name
+          attr_reader :ecies_digest
+          # @return [Symbol] ECIES MAC length
+          attr_reader :ecies_mac_length
+          # @return [String] ECIES KDF digest name
+          attr_reader :ecies_kdf_digest
+          # @return [String] ECIES MAC digest name
+          attr_reader :ecies_mac_digest
+
+          # Default options for ECIES
+          DEFAULT_ECIES_OPTIONS = {
+            ecies_cipher: 'AES-256-CTR',
+            ecies_digest: 'SHA512',
+            ecies_mac_length: :full,
+            ecies_kdf_digest: 'SHA512',
+            ecies_mac_digest: 'SHA512'
+          }.freeze
+
+          Contract Contracts::HashOf[Symbol, Maybe[String]] => Any
+          # Initialize options for OpenSSL EC encryption
+          #
+          # @param clear_data (#clear_data)
+          # @param public_key (#public_key)
+          # @param ecies_options Hash with ECIES options
+          #
+          # @since 0.1.0
+          def initialize(clear_data:, public_key:, ecies_options:)
+            super(clear_data: clear_data)
+            @public_key = public_key
+            initialize_public_key!(public_key)
+            initialize_ecies_options!(ecies_options || DEFAULT_ECIES_OPTIONS)
+            initialize_encrypter!
+          end
+
+          Contract String => OpenSSL::PKey::EC
+          # Initialize EC public key from public key string
+          #
+          # @param public_key (#public_key)
+          #
+          # @return [OpenSSL:PKey::EC] OpenSSL public key instance
+          #
+          # @since 0.1.0
+          def initialize_public_key!(public_key)
+            raise 'ERROR: No public key!' unless public_key
+
+            @public_key = OpenSSL::PKey.read(public_key)
+          end
+
+          Contract Contracts::HashOf[Symbol, Or[String, Symbol]] => Any
+          # Initialize ECIES options
+          #
+          # @param ecies_options Hash with ECIES options
+          #
+          # @since 0.1.0
+          def initialize_ecies_options!(ecies_options)
+            @ecies_cipher = ecies_options[:ecies_cipher]
+            @ecies_digest = ecies_options[:ecies_digest]
+            @ecies_mac_length = ecies_options[:ecies_mac_length]
+            @ecies_kdf_digest = ecies_options[:ecies_kdf_digest]
+            @ecies_mac_digest = ecies_options[:ecies_mac_digest]
+          end
+
+          Contract None => ECIES::Crypt
+          # Initialize encrypter
+          #
+          # @return [ECIES::Crypt] encrypter instance
+          #
+          # @since 0.1.0
+          def initialize_encrypter!
+            @encrypter = ECIES::Crypt.new(
+              cipher: ecies_cipher,
+              digest: ecies_digest,
+              mac_length: ecies_mac_length,
+              kdf_digest: ecies_kdf_digest,
+              mac_digest: ecies_mac_digest
+            )
+          end
+
+          private
+
+          Contract None => Contracts::ArrayOf[Contracts::HashOf[Symbol, String]]
+          # Encrypting data
+          #
+          # @return [Array] encrypted data with empty hash in place of params
+          #
+          # @since 0.1.0
+          def encrypt_data!
+            [{ encrypted_data_string: encrypter.encrypt(public_key, clear_data) }, {}]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/izokatu/openssl/public_key/ec/keys_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Izokatu
+  module Openssl
+    # Namespace for OpenSSL public key classes
+    module PublicKey
+      # Namespace for OpenSSL public key EC classes
+      module EC
+        # OpenSSL EC keys generator
+        class KeysGenerator < Izokatu::KeysGenerator
+          # @return [String] cipher for keys generation
+          attr_reader :cipher
+
+          # Default options for OpenSSL EC keys generation
+          DEFAULT_OPTIONS = {
+            cipher: 'secp521r1'
+          }.freeze
+
+          Contract Contracts::HashOf[Symbol, String] => Any
+          # Initialize option for OpenSSL EC keys generation
+          #
+          # @param cipher (#cipher)
+          #
+          # @since 0.1.0
+          def initialize(cipher:)
+            super()
+            @cipher = cipher || DEFAULT_OPTIONS[:cipher]
+          end
+
+          Contract None => Contracts::HashOf[Or[*KEYS_SYMBOLS], String]
+          # Performing generation of OpenSSL EC private and public keys
+          #
+          # @return [Hash] OpenSSL EC public and private keys
+          #
+          # @since 0.1.0
+          def perform
+            validate_ec_cipher!
+            super.transform_values(&:to_pem)
+          end
+
+          private
+
+          # Verifying EC cipher
+          #
+          # @raise RuntimeError
+          #
+          # @since 0.1.0
+          def validate_ec_cipher!
+            raise 'ERROR: Unknown EC cipher!' unless PBKEY_EC_CIPHERS.include?(cipher)
+          end
+
+          Contract None => OpenSSL::PKey::EC
+          # Performing generation of OpenSSL EC private key
+          #
+          # @return [OpenSSL::PKey::EC] OpenSSL private key
+          #
+          # @since 0.1.0
+          def generate_private_key
+            OpenSSL::PKey::EC.new(cipher).generate_key
+          end
+
+          Contract OpenSSL::PKey::EC => OpenSSL::PKey::EC
+          # Performing generation of OpenSSL EC private key
+          #
+          # @return [OpenSSL::PKey::EC] OpenSSL private key
+          #
+          # @since 0.1.0
+          def generate_public_key(private_key)
+            private_key_copy = OpenSSL::PKey::EC.new(private_key.public_key.group)
+            private_key_copy.public_key = private_key.public_key
+            private_key_copy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/izokatu/openssl/public_key/rsa/decrypter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Izokatu
+  module Openssl
+    module PublicKey
+      module RSA
+        # OpenSSL public key RSA decrypter
+        class Decrypter < Izokatu::Decrypter
+          # @return [String] private key string for decryption
+          attr_reader :private_key
+
+          Contract Contracts::HashOf[Symbol, String] => Any
+          # Initialize options for OpenSSL RSA decryption
+          #
+          # @param encrypted_data (#encrypted_data)
+          # @param private_key (#private_key)
+          #
+          # @since 0.1.0
+          def initialize(encrypted_data:, private_key:)
+            super(encrypted_data: encrypted_data)
+            initialize_private_key!(private_key)
+          end
+
+          private
+
+          Contract String => OpenSSL::PKey::RSA
+          # Initialize RSA private key from private key string
+          #
+          # @param private_key (#private_key)
+          #
+          # @return [OpenSSL:PKey::RSA] OpenSSL private key instance
+          #
+          # @since 0.1.0
+          def initialize_private_key!(private_key)
+            raise 'ERROR: No private key!' unless private_key
+
+            @private_key = OpenSSL::PKey.read(private_key)
+          end
+
+          Contract None => Contracts::HashOf[Symbol, String]
+          # Decrypting data
+          #
+          # @return [Hash] decrypted data
+          #
+          # @since 0.1.0
+          def decrypt_data!
+            { decrypted_data_string: private_key.private_decrypt(encrypted_data) }
+          end
+        end
+      end
+    end
+  end
+end