JWK: Initialization optimizations

Author: bellebaum

lib/jwt/jwk.rb

@@ -14,10 +14,10 @@ def import(jwk_data)
         end.import(jwk_data)
       end
 
-      def create_from(keypair, params = nil, options = {})
+      def create_from(key, params = nil, options = {})
         mappings.fetch(keypair.class) do |klass|
           raise JWT::JWKError, "Cannot create JWK from a #{klass.name}"
-        end.new(keypair, params, options)
+        end.new(key, params, options)
       end
 
       def classes

lib/jwt/jwk/ec.rb

@@ -15,22 +15,26 @@ class EC < KeyBase # rubocop:disable Metrics/ClassLength
       EC_PRIVATE_KEY_ELEMENTS = %i[d].freeze
       EC_KEY_ELEMENTS = (EC_PRIVATE_KEY_ELEMENTS + EC_PUBLIC_KEY_ELEMENTS).freeze
 
-      def initialize(keypair, params = nil, options = {})
+      def initialize(key, params = nil, options = {})
         params ||= {}
 
         # For backwards compatibility when kid was a String
         params = { kid: params } if params.is_a?(String)
 
-        # Accept OpenSSL key as input
-        keypair = parse_ec_key(keypair) if keypair.is_a?(OpenSSL::PKey::EC)
-
-        raise ArgumentError, 'keypair must be of type OpenSSL::PKey::EC' unless keypair.is_a?(Hash)
+        key_params = case key
+                     when OpenSSL::PKey::EC # Accept OpenSSL key as input
+                       @keypair = key # Preserve the object to avoid recreation
+                       parse_ec_key(key)
+                     when Hash
+                       key.transform_keys(&:to_sym)
+                     else
+                       raise ArgumentError, 'key must be of type OpenSSL::PKey::EC or Hash with key parameters'
+        end
 
-        keypair = keypair.transform_keys(&:to_sym)
-        params  = params.transform_keys(&:to_sym)
-        check_jwk(keypair, params)
+        params = params.transform_keys(&:to_sym)
+        check_jwk(key_params, params)
 
-        super(options, keypair.merge(params))
+        super(options, key_params.merge(params))
       end
 
       def keypair

lib/jwt/jwk/hmac.rb

@@ -9,22 +9,25 @@ class HMAC < KeyBase
       HMAC_PRIVATE_KEY_ELEMENTS = %i[k].freeze
       HMAC_KEY_ELEMENTS = (HMAC_PRIVATE_KEY_ELEMENTS + HMAC_PUBLIC_KEY_ELEMENTS).freeze
 
-      def initialize(keypair, params = nil, options = {})
+      def initialize(key, params = nil, options = {})
         params ||= {}
 
         # For backwards compatibility when kid was a String
         params = { kid: params } if params.is_a?(String)
 
-        # Accept String key as input
-        keypair = { kty: KTY, k: keypair } if keypair.is_a?(String)
-
-        raise ArgumentError, 'keypair must be of type String' unless keypair.is_a?(Hash)
+        key_params = case key
+                     when String # Accept String key as input
+                       { kty: KTY, k: key }
+                     when Hash
+                       key.transform_keys(&:to_sym)
+                     else
+                       raise ArgumentError, 'key must be of type String or Hash with key parameters'
+        end
 
-        keypair = keypair.transform_keys(&:to_sym)
-        params  = params.transform_keys(&:to_sym)
-        check_jwk(keypair, params)
+        params = params.transform_keys(&:to_sym)
+        check_jwk(key_params, params)
 
-        super(options, keypair.merge(params))
+        super(options, key_params.merge(params))
       end
 
       def keypair

lib/jwt/jwk/rsa.rb

@@ -10,22 +10,26 @@ class RSA < KeyBase # rubocop:disable Metrics/ClassLength
       RSA_PRIVATE_KEY_ELEMENTS = %i[d p q dp dq qi].freeze
       RSA_KEY_ELEMENTS = (RSA_PRIVATE_KEY_ELEMENTS + RSA_PUBLIC_KEY_ELEMENTS).freeze
 
-      def initialize(keypair, params = nil, options = {})
+      def initialize(key, params = nil, options = {})
         params ||= {}
 
         # For backwards compatibility when kid was a String
         params = { kid: params } if params.is_a?(String)
 
-        # Accept OpenSSL key as input
-        keypair = parse_rsa_key(keypair) if keypair.is_a?(OpenSSL::PKey::RSA)
-
-        raise ArgumentError, 'keypair must be of type OpenSSL::PKey::RSA' unless keypair.is_a?(Hash)
+        key_params = case key
+                     when OpenSSL::PKey::RSA # Accept OpenSSL key as input
+                       @keypair = key # Preserve the object to avoid recreation
+                       parse_rsa_key(key)
+                     when Hash
+                       key.transform_keys(&:to_sym)
+                     else
+                       raise ArgumentError, 'key must be of type OpenSSL::PKey::RSA or Hash with key parameters'
+        end
 
-        keypair = keypair.transform_keys(&:to_sym)
-        params  = params.transform_keys(&:to_sym)
-        check_jwk(keypair, params)
+        params = params.transform_keys(&:to_sym)
+        check_jwk(key_params, params)
 
-        super(options, keypair.merge(params))
+        super(options, key_params.merge(params))
       end
 
       def keypair

spec/jwk/rsa_spec.rb

@@ -47,7 +47,7 @@
     context 'when unsupported keypair is given' do
       let(:keypair) { 'key' }
       it 'raises an error' do
-        expect { subject }.to raise_error(ArgumentError, 'keypair must be of type OpenSSL::PKey::RSA')
+        expect { subject }.to raise_error(ArgumentError)
       end
     end