legion-crypt 1.4.6 → 1.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58236395edc171db0660e744e8ed15ed7497af43bb6154f9361693a6576f070c
-  data.tar.gz: '008c7865a64d8a43c3c167ae3fc36aef7b537f26522b2ce05f40615b98ff3e80'
+  metadata.gz: f23263a49bc4e450c4c13189039e6a1324201fc31c074a59800569076c4baa40
+  data.tar.gz: 7c7fddeb4adb4a6d6721dea856af301f69a6b6a4c124c28195c87cf3e5e04f82
 SHA512:
-  metadata.gz: eb66a3e5aaf65cf06e463e0ed4024121d9f8b9459731ef8422761fa0d9888c6e90bef58e0a4bb13cfd57eb2d14063ebfe07a8968209f738d15f99080669055e9
-  data.tar.gz: 980231e72cdb5a7eb36702fcb69dfc25ff41811c35df5485476410e386126ff45c4911715ec43cc3c347932f6a5d79d4c70728afde25f99cf423d03aae223265
+  metadata.gz: fe700545e2fe3ec3166cf14e760655e84572c5283895057d9c5f114849e89d5e00f59b13de05769c350eea9deabc0caa3cba926d89ca9121f40787c75707583c
+  data.tar.gz: 7b22b0a6ff01a262d44497e201c0f9fab260d5897e4be7af0a7a8c8d7a1e6c7c95ec9b422c9047ef5c6428a8ffb0ed9de066bda0d63849f45c9634eb2692ebc4

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Legion::Crypt
 
+## [1.4.8] - 2026-03-22
+
+### Changed
+- Added logging to all silent rescue blocks across attestation, cluster_secret, ed25519, erasure, jwks_client, ldap_auth, vault_jwt_auth, and vault_kerberos_auth
+
+## [1.4.7] - 2026-03-22
+
+### Added
+- Logging across vault, JWT, JWKS, Ed25519, PartitionKeys, Attestation, LdapAuth, VaultJwtAuth, VaultCluster operations
+- `vault.rb`: `.info` on Vault connect, `.info` on cluster token renewal, `.debug` on read/write/get paths, `.warn` on read/write/get failures, `.debug` on renewal cycle start/complete
+- `jwt.rb`: `.info` on JWT issue (subject, expiry, algorithm), `.debug` on verify success, `.warn` on verify failures (expired, invalid, decode) before raising
+- `jwks_client.rb`: `.debug` on JWKS fetch URL, `.debug` on cache hit, `.warn` on fetch failure
+- `ed25519.rb`: `.debug` on keypair generation, sign, verify, and Vault store/load paths
+- `partition_keys.rb`: `.debug` on key derivation, `.warn` on encrypt/decrypt failures
+- `attestation.rb`: `.debug` on attestation create/verify, `.warn` on verification failure
+- `ldap_auth.rb`: `.info` on LDAP login success, `.warn` on LDAP login failure
+- `vault_jwt_auth.rb`: `.warn` on JWT auth client/server errors in non-bang `login`
+- `vault_cluster.rb`: `.info` on successful cluster connect
+
 ## [1.4.6] - 2026-03-21
 
 ### Fixed

data/CLAUDE.md

@@ -8,7 +8,7 @@
 Handles encryption, decryption, secrets management, JWT token management, and HashiCorp Vault connectivity for the LegionIO framework. Provides AES-256-CBC message encryption, RSA key pair generation, cluster secret management, JWT issue/verify operations, and Vault token lifecycle management.
 
 **GitHub**: https://github.com/LegionIO/legion-crypt
-**Version**: 1.4.4
+**Version**: 1.4.7
 **License**: Apache-2.0
 
 ## Architecture

data/CODEOWNERS

@@ -1 +1,40 @@
+# Default owner — all files
 * @Esity
+
+# Core library code
+# lib/ @Esity @future-security-team
+
+# Cipher and key management
+# lib/legion/crypt/cipher.rb @Esity @future-security-team
+# lib/legion/crypt/partition_keys.rb @Esity @future-security-team
+# lib/legion/crypt/ed25519.rb @Esity @future-security-team
+
+# Vault integration
+# lib/legion/crypt/vault.rb @Esity @future-security-team
+# lib/legion/crypt/vault_jwt_auth.rb @Esity @future-security-team
+# lib/legion/crypt/vault_renewer.rb @Esity @future-security-team
+# lib/legion/crypt/vault_cluster.rb @Esity @future-security-team
+# lib/legion/crypt/lease_manager.rb @Esity @future-security-team
+
+# JWT and JWKS
+# lib/legion/crypt/jwt.rb @Esity @future-security-team
+# lib/legion/crypt/jwks_client.rb @Esity @future-security-team
+
+# Auth integrations
+# lib/legion/crypt/ldap_auth.rb @Esity @future-security-team
+# lib/legion/crypt/vault_kerberos_auth.rb @Esity @future-security-team
+
+# Cluster secret
+# lib/legion/crypt/cluster_secret.rb @Esity @future-security-team
+
+# Cryptographic erasure
+# lib/legion/crypt/erasure.rb @Esity @future-security-team
+
+# Specs
+# spec/ @Esity @future-contributors
+
+# Documentation
+# *.md @Esity @future-docs-team
+
+# CI/CD
+# .github/ @Esity

data/README.md

@@ -2,7 +2,7 @@
 
 Encryption, secrets management, JWT token management, and HashiCorp Vault integration for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Provides AES-256-CBC message encryption, RSA key pair generation, cluster secret management, JWT issue/verify operations, Vault token lifecycle management, and multi-cluster Vault connectivity.
 
-**Version**: 1.4.4
+**Version**: 1.4.7
 
 ## Installation
 

data/lib/legion/crypt/attestation.rb

@@ -17,6 +17,7 @@ module Legion
 
           payload = Legion::JSON.dump(claim)
           signature = Legion::Crypt::Ed25519.sign(payload, private_key)
+          Legion::Logging.debug "Attestation created for agent #{agent_id}, state=#{state}" if defined?(Legion::Logging)
 
           { claim: claim, signature: signature.unpack1('H*'), payload: payload }
         end
@@ -24,13 +25,22 @@ module Legion
         def verify(claim_hash:, signature_hex:, public_key:)
           payload = Legion::JSON.dump(claim_hash)
           signature = [signature_hex].pack('H*')
-          Legion::Crypt::Ed25519.verify(payload, signature, public_key)
+          result = Legion::Crypt::Ed25519.verify(payload, signature, public_key)
+          if defined?(Legion::Logging)
+            if result
+              Legion::Logging.debug "Attestation verified for agent #{claim_hash[:agent_id]}"
+            else
+              Legion::Logging.warn "Attestation verification failed for agent #{claim_hash[:agent_id]}"
+            end
+          end
+          result
         end
 
         def fresh?(claim_hash, max_age_seconds: 300)
           timestamp = Time.parse(claim_hash[:timestamp])
           Time.now.utc - timestamp < max_age_seconds
-        rescue StandardError
+        rescue StandardError => e
+          Legion::Logging.warn("Legion::Crypt::Attestation#fresh? failed: #{e.message}") if defined?(Legion::Logging)
           false
         end
       end

data/lib/legion/crypt/cluster_secret.rb

@@ -32,7 +32,8 @@ module Legion
         return nil unless Legion::Crypt.exist?('crypt')
 
         get('crypt')[:cluster_secret]
-      rescue StandardError
+      rescue StandardError => e
+        Legion::Logging.warn("Legion::Crypt::ClusterSecret#from_vault failed: #{e.message}") if defined?(Legion::Logging)
         nil
       end
 
@@ -77,7 +78,8 @@ module Legion
 
       def only_member?
         Legion::Transport::Queue.new('node.crypt', passive: true).consumer_count.zero?
-      rescue StandardError
+      rescue StandardError => e
+        Legion::Logging.warn("Legion::Crypt::ClusterSecret#only_member? failed: #{e.message}") if defined?(Legion::Logging)
         nil
       end
 

data/lib/legion/crypt/ed25519.rb

@@ -8,6 +8,7 @@ module Legion
       class << self
         def generate_keypair
           signing_key = ::Ed25519::SigningKey.generate
+          Legion::Logging.debug 'Ed25519 keypair generated' if defined?(Legion::Logging)
           {
             private_key:    signing_key.to_bytes,
             public_key:     signing_key.verify_key.to_bytes,
@@ -17,14 +18,18 @@ module Legion
 
         def sign(message, private_key_bytes)
           signing_key = ::Ed25519::SigningKey.new(private_key_bytes)
-          signing_key.sign(message)
+          result = signing_key.sign(message)
+          Legion::Logging.debug 'Ed25519 sign complete' if defined?(Legion::Logging)
+          result
         end
 
         def verify(message, signature, public_key_bytes)
           verify_key = ::Ed25519::VerifyKey.new(public_key_bytes)
           verify_key.verify(signature, message)
+          Legion::Logging.debug 'Ed25519 verify success' if defined?(Legion::Logging)
           true
-        rescue ::Ed25519::VerifyError
+        rescue ::Ed25519::VerifyError => e
+          Legion::Logging.debug("Legion::Crypt::Ed25519.verify signature mismatch: #{e.message}") if defined?(Legion::Logging)
           false
         end
 
@@ -32,6 +37,7 @@ module Legion
           keypair ||= generate_keypair
           vault_path = "#{key_prefix}/#{agent_id}"
           if defined?(Legion::Crypt::Vault)
+            Legion::Logging.debug "Ed25519 storing keypair at #{vault_path}" if defined?(Legion::Logging)
             Legion::Crypt::Vault.write(vault_path, {
                                          private_key: keypair[:private_key].unpack1('H*'),
                                          public_key:  keypair[:public_key_hex]
@@ -42,9 +48,11 @@ module Legion
 
         def load_private_key(agent_id:)
           vault_path = "#{key_prefix}/#{agent_id}"
+          Legion::Logging.debug "Ed25519 loading private key from #{vault_path}" if defined?(Legion::Logging)
           data = Legion::Crypt::Vault.read(vault_path)
           [data[:private_key]].pack('H*') if data&.dig(:private_key)
-        rescue StandardError
+        rescue StandardError => e
+          Legion::Logging.warn("Legion::Crypt::Ed25519#load_private_key failed: #{e.message}") if defined?(Legion::Logging)
           nil
         end
 
@@ -53,7 +61,8 @@ module Legion
         def key_prefix
           begin
             Legion::Settings[:crypt][:ed25519][:vault_key_prefix]
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("Legion::Crypt::Ed25519#key_prefix settings lookup failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end || 'secret/data/legion/keys'
         end

data/lib/legion/crypt/erasure.rb

@@ -13,6 +13,7 @@ module Legion
 
           { erased: true, tenant_id: tenant_id, path: key_path }
         rescue StandardError => e
+          Legion::Logging.error("Legion::Crypt::Erasure#erase_tenant failed: #{e.message}") if defined?(Legion::Logging)
           { erased: false, tenant_id: tenant_id, error: e.message }
         end
 
@@ -20,7 +21,8 @@ module Legion
           key_path = "#{tenant_prefix}/#{tenant_id}/master_key"
           data = Legion::Crypt::Vault.read(key_path)
           { erased: data.nil?, tenant_id: tenant_id }
-        rescue StandardError
+        rescue StandardError => e
+          Legion::Logging.warn("Legion::Crypt::Erasure#verify_erasure failed: #{e.message}") if defined?(Legion::Logging)
           { erased: true, tenant_id: tenant_id }
         end
 
@@ -33,7 +35,8 @@ module Legion
         def tenant_prefix
           begin
             Legion::Settings[:crypt][:partition_keys][:vault_tenant_prefix]
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("Legion::Crypt::Erasure#tenant_prefix settings lookup failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end || 'secret/data/legion/tenants'
         end

data/lib/legion/crypt/jwks_client.rb

@@ -17,6 +17,7 @@ module Legion
       class << self
         def fetch_keys(jwks_url)
           @mutex.synchronize do
+            Legion::Logging.debug "JWKS fetch: #{jwks_url}" if defined?(Legion::Logging)
             response = http_get(jwks_url)
             jwks_data = parse_response(response)
             keys = parse_jwks(jwks_data)
@@ -24,6 +25,9 @@ module Legion
             @cache[jwks_url] = { keys: keys, fetched_at: Time.now }
             keys
           end
+        rescue StandardError => e
+          Legion::Logging.warn "JWKS fetch failed for #{jwks_url}: #{e.message}" if defined?(Legion::Logging)
+          raise
         end
 
         def find_key(jwks_url, kid)
@@ -31,10 +35,12 @@ module Legion
 
           if cached && !expired?(cached[:fetched_at])
             key = cached[:keys][kid]
-            return key if key
+            if key
+              Legion::Logging.debug "JWKS cache hit: kid=#{kid}" if defined?(Legion::Logging)
+              return key
+            end
           end
 
-          # Re-fetch once on cache miss or expiry
           keys = fetch_keys(jwks_url)
           key = keys[kid]
           return key if key
@@ -89,8 +95,8 @@ module Legion
 
             jwk = ::JWT::JWK.new(jwk_hash)
             keys[kid] = jwk.public_key
-          rescue StandardError
-            # Skip malformed keys, continue with valid ones
+          rescue StandardError => e
+            Legion::Logging.debug("Legion::Crypt::JwksClient#parse_jwks skipping malformed key kid=#{kid}: #{e.message}") if defined?(Legion::Logging)
             next
           end
 

data/lib/legion/crypt/jwt.rb

@@ -25,7 +25,9 @@ module Legion
           jti: SecureRandom.uuid
         }.merge(payload)
 
-        ::JWT.encode(claims, signing_key, algorithm)
+        token = ::JWT.encode(claims, signing_key, algorithm)
+        Legion::Logging.info "JWT issued: sub=#{claims[:sub]}, exp=#{Time.at(claims[:exp]).utc.iso8601}, alg=#{algorithm}" if defined?(Legion::Logging)
+        token
       end
 
       def self.verify(token, verification_key:, **opts)
@@ -44,12 +46,17 @@ module Legion
         decode_opts[:iss] = issuer if verify_issuer
 
         payload, _header = ::JWT.decode(token, verification_key, true, decode_opts)
-        symbolize_keys(payload)
+        result = symbolize_keys(payload)
+        Legion::Logging.debug "JWT verify success: sub=#{result[:sub]}, jti=#{result[:jti]}" if defined?(Legion::Logging)
+        result
       rescue ::JWT::ExpiredSignature
+        Legion::Logging.warn 'JWT verify failed: token has expired' if defined?(Legion::Logging)
         raise ExpiredTokenError, 'token has expired'
       rescue ::JWT::VerificationError, ::JWT::IncorrectAlgorithm
+        Legion::Logging.warn 'JWT verify failed: signature verification failed' if defined?(Legion::Logging)
         raise InvalidTokenError, 'token signature verification failed'
       rescue ::JWT::DecodeError => e
+        Legion::Logging.warn "JWT verify failed: #{e.message}" if defined?(Legion::Logging)
         raise DecodeError, "failed to decode token: #{e.message}"
       end
 
@@ -91,16 +98,23 @@ module Legion
         end
 
         payload, _header = ::JWT.decode(token, public_key, true, decode_opts)
-        symbolize_keys(payload)
+        result = symbolize_keys(payload)
+        Legion::Logging.debug "JWT JWKS verify success: sub=#{result[:sub]}, kid=#{kid}" if defined?(Legion::Logging)
+        result
       rescue ::JWT::ExpiredSignature
+        Legion::Logging.warn "JWT JWKS verify failed: token has expired, kid=#{kid}" if defined?(Legion::Logging)
         raise ExpiredTokenError, 'token has expired'
       rescue ::JWT::VerificationError, ::JWT::IncorrectAlgorithm
+        Legion::Logging.warn "JWT JWKS verify failed: signature verification failed, kid=#{kid}" if defined?(Legion::Logging)
         raise InvalidTokenError, 'token signature verification failed'
       rescue ::JWT::InvalidIssuerError
+        Legion::Logging.warn "JWT JWKS verify failed: issuer not allowed, kid=#{kid}" if defined?(Legion::Logging)
         raise InvalidTokenError, 'token issuer not allowed'
       rescue ::JWT::InvalidAudError
+        Legion::Logging.warn "JWT JWKS verify failed: audience mismatch, kid=#{kid}" if defined?(Legion::Logging)
         raise InvalidTokenError, 'token audience mismatch'
       rescue ::JWT::DecodeError => e
+        Legion::Logging.warn "JWT JWKS verify failed: #{e.message}, kid=#{kid}" if defined?(Legion::Logging)
         raise DecodeError, "failed to decode token: #{e.message}"
       end
 

data/lib/legion/crypt/ldap_auth.rb

@@ -13,8 +13,12 @@ module Legion
         clusters[cluster_name][:token] = token
         clusters[cluster_name][:connected] = true
 
+        Legion::Logging.info "LDAP login success: user=#{username}, cluster=#{cluster_name}" if defined?(Legion::Logging)
         { token: token, lease_duration: auth.lease_duration,
           renewable: auth.renewable, policies: auth.policies }
+      rescue StandardError => e
+        Legion::Logging.warn "LDAP login failed: user=#{username}, cluster=#{cluster_name}: #{e.message}" if defined?(Legion::Logging)
+        raise
       end
 
       def ldap_login_all(username:, password:)
@@ -24,6 +28,7 @@ module Legion
 
           results[name] = ldap_login(cluster_name: name, username: username, password: password)
         rescue StandardError => e
+          Legion::Logging.warn("Legion::Crypt::LdapAuth#ldap_login_all cluster=#{name} failed: #{e.message}") if defined?(Legion::Logging)
           results[name] = { error: e.message }
         end
         results

data/lib/legion/crypt/partition_keys.rb

@@ -12,6 +12,7 @@ module Legion
           rescue StandardError
             nil
           end || 'legion-partition'
+          Legion::Logging.debug "PartitionKeys key derivation for tenant #{tenant_id}" if defined?(Legion::Logging)
           salt = OpenSSL::Digest::SHA256.digest(tenant_id.to_s)
           OpenSSL::KDF.hkdf(master_key, salt: salt, info: context, length: 32, hash: 'SHA256')
         end
@@ -26,6 +27,9 @@ module Legion
           auth_tag = cipher.auth_tag
 
           { ciphertext: ciphertext, iv: iv, auth_tag: auth_tag }
+        rescue StandardError => e
+          Legion::Logging.warn "PartitionKeys encrypt failed for tenant #{tenant_id}: #{e.message}" if defined?(Legion::Logging)
+          raise
         end
 
         def decrypt_for_tenant(ciphertext:, init_vector:, auth_tag:, tenant_id:, master_key:)
@@ -36,6 +40,9 @@ module Legion
           decipher.iv = init_vector
           decipher.auth_tag = auth_tag
           decipher.update(ciphertext) + decipher.final
+        rescue StandardError => e
+          Legion::Logging.warn "PartitionKeys decrypt failed for tenant #{tenant_id}: #{e.message}" if defined?(Legion::Logging)
+          raise
         end
       end
     end

data/lib/legion/crypt/vault.rb

@@ -32,7 +32,10 @@ module Legion
         return nil if Legion::Settings[:crypt][:vault][:token].nil?
 
         ::Vault.token = Legion::Settings[:crypt][:vault][:token]
-        Legion::Settings[:crypt][:vault][:connected] = true if ::Vault.sys.health_status.initialized?
+        if ::Vault.sys.health_status.initialized?
+          Legion::Settings[:crypt][:vault][:connected] = true
+          Legion::Logging.info "Vault connected at #{::Vault.address}" if defined?(Legion::Logging)
+        end
         return unless Legion.const_defined? 'Extensions::Actors::Every'
 
         require_relative 'vault_renewer'
@@ -45,20 +48,32 @@ module Legion
 
       def read(path, type = 'legion')
         full_path = type.nil? || type.empty? ? "#{type}/#{path}" : path
+        Legion::Logging.debug "Vault read: #{full_path}" if defined?(Legion::Logging)
         lease = ::Vault.logical.read(full_path)
         add_session(path: lease.lease_id) if lease.respond_to? :lease_id
         lease.data
+      rescue StandardError => e
+        Legion::Logging.warn "Vault read failed at #{full_path}: #{e.message}" if defined?(Legion::Logging)
+        raise
       end
 
       def get(path)
+        Legion::Logging.debug "Vault kv get: #{path}" if defined?(Legion::Logging)
         result = ::Vault.kv(settings[:vault][:kv_path]).read(path)
         return nil if result.nil?
 
         result.data
+      rescue StandardError => e
+        Legion::Logging.warn "Vault kv get failed at #{path}: #{e.message}" if defined?(Legion::Logging)
+        raise
       end
 
       def write(path, **hash)
+        Legion::Logging.debug "Vault kv write: #{path}" if defined?(Legion::Logging)
         ::Vault.kv(settings[:vault][:kv_path]).write(path, **hash)
+      rescue StandardError => e
+        Legion::Logging.warn "Vault kv write failed at #{path}: #{e.message}" if defined?(Legion::Logging)
+        raise
       end
 
       def exist?(path)
@@ -96,19 +111,23 @@ module Legion
       end
 
       def renew_sessions(**_opts)
-        if respond_to?(:connected_clusters) && connected_clusters.any?
-          renew_cluster_tokens
-        else
-          @sessions.each do |session|
-            renew_session(session: session)
-          end
-        end
+        Legion::Logging.debug 'Vault renewal cycle start' if defined?(Legion::Logging)
+        result = if respond_to?(:connected_clusters) && connected_clusters.any?
+                   renew_cluster_tokens
+                 else
+                   @sessions.each do |session|
+                     renew_session(session: session)
+                   end
+                 end
+        Legion::Logging.debug 'Vault renewal cycle complete' if defined?(Legion::Logging)
+        result
       end
 
       def renew_cluster_tokens
         connected_clusters.each_key do |name|
           client = vault_client(name)
           client.auth_token.renew_self
+          Legion::Logging.info "Vault token renewed for cluster #{name}" if defined?(Legion::Logging)
         rescue StandardError => e
           log_vault_error(name, e)
         end

data/lib/legion/crypt/vault_cluster.rb

@@ -37,6 +37,7 @@ module Legion
           client = vault_client(name)
           config[:connected] = client.sys.health_status.initialized?
           results[name] = config[:connected]
+          Legion::Logging.info "Vault cluster connected: #{name} at #{config[:address]}" if config[:connected] && defined?(Legion::Logging)
         rescue StandardError => e
           config[:connected] = false
           results[name] = false

data/lib/legion/crypt/vault_jwt_auth.rb

@@ -44,8 +44,10 @@ module Legion
           metadata:       response.auth.metadata
         }
       rescue ::Vault::HTTPClientError => e
+        Legion::Logging.warn "Vault JWT auth failed (client error): role=#{role}, #{e.message}" if defined?(Legion::Logging)
         raise AuthError, "Vault JWT auth failed: #{e.message}"
       rescue ::Vault::HTTPServerError => e
+        Legion::Logging.warn "Vault JWT auth failed (server error): role=#{role}, #{e.message}" if defined?(Legion::Logging)
         raise AuthError, "Vault server error during JWT auth: #{e.message}"
       end
 
@@ -82,7 +84,8 @@ module Legion
         defined?(::Vault) &&
           defined?(Legion::Settings) &&
           Legion::Settings[:crypt][:vault][:connected] == true
-      rescue StandardError
+      rescue StandardError => e
+        Legion::Logging.debug("Legion::Crypt::VaultJwtAuth#vault_connected? failed: #{e.message}") if defined?(Legion::Logging)
         false
       end
 

data/lib/legion/crypt/vault_kerberos_auth.rb

@@ -33,7 +33,8 @@ module Legion
       def self.vault_connected?
         defined?(::Vault) && defined?(Legion::Settings) &&
           Legion::Settings[:crypt][:vault][:connected] == true
-      rescue StandardError
+      rescue StandardError => e
+        Legion::Logging.debug("Legion::Crypt::VaultKerberosAuth#vault_connected? failed: #{e.message}") if defined?(Legion::Logging)
         false
       end
 

data/lib/legion/crypt/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Crypt
-    VERSION = '1.4.6'
+    VERSION = '1.4.8'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-crypt
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.4.8
 platform: ruby
 authors:
 - Esity