pq_crypto-jwt 0.2.1 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,129 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "base64"
4
+ require "json"
5
+
6
+ module PQCrypto
7
+ module JWT
8
+ module JWA
9
+ module Streaming
10
+ DEFAULT_CHUNK_SIZE = 1 << 20
11
+ DECODE_ERRORS = [JSON::ParserError, ArgumentError, TypeError, EncodingError].freeze
12
+ VERIFY_ERRORS = [PQCrypto::Error, PQCrypto::JWT::Error].freeze
13
+ UNSUPPORTED_HEADERS = %w[b64 crit].freeze
14
+ STREAMING_DECODE_ERRORS = DECODE_ERRORS
15
+ STREAMING_VERIFY_ERRORS = VERIFY_ERRORS
16
+
17
+ def self.validate_chunk_size!(chunk_size)
18
+ return chunk_size if chunk_size.is_a?(Integer) && chunk_size.positive?
19
+
20
+ raise ArgumentError, "chunk_size must be a positive Integer"
21
+ end
22
+
23
+ def streaming_supported?
24
+ PQCrypto::Signature.supported.include?(pq_crypto_algorithm)
25
+ rescue PQCrypto::Error
26
+ false
27
+ end
28
+
29
+ def sign_io(signing_key:, payload_io: nil, io: nil, header_fields: {}, chunk_size: DEFAULT_CHUNK_SIZE)
30
+ payload_io ||= io
31
+ validate_stream!(signing_key, PQCrypto::Signature::SecretKey, "signing", chunk_size)
32
+ raise ArgumentError, "payload_io must respond to #read" unless payload_io.respond_to?(:read)
33
+
34
+ encoded_header = base64url(JSON.generate(signing_header(header_fields)))
35
+ input = DetachedSigningInputIO.new(encoded_header, payload_io, chunk_size:)
36
+ "#{encoded_header}..#{base64url(signing_key.sign_io(input, chunk_size:, context: EMPTY_CONTEXT))}"
37
+ rescue PQCrypto::JWT::Error, ArgumentError
38
+ raise
39
+ rescue StandardError => error
40
+ raise ::JWT::EncodeError, error.message
41
+ end
42
+
43
+ def verify_io(verification_key:, token:, payload_io:, chunk_size: DEFAULT_CHUNK_SIZE, strict: false)
44
+ verify_detached!(verification_key, token, payload_io, chunk_size)
45
+ rescue ::JWT::DecodeError
46
+ raise if strict
47
+
48
+ false
49
+ end
50
+
51
+ def verify_io!(**kwargs)
52
+ verify_io(**kwargs) || raise(::JWT::VerificationError, "Streaming JWS verification failed")
53
+ true
54
+ end
55
+
56
+ private
57
+
58
+ def verify_detached!(verification_key, token, payload_io, chunk_size)
59
+ validate_stream!(verification_key, PQCrypto::Signature::PublicKey, "verification", chunk_size)
60
+ raise ::JWT::DecodeError, "token must be a String" unless token.is_a?(String)
61
+ raise ::JWT::DecodeError, "payload_io must respond to #read" unless payload_io.respond_to?(:read)
62
+
63
+ encoded_header, header, signature = decode_detached(token)
64
+ input = DetachedSigningInputIO.new(encoded_header, payload_io, chunk_size:)
65
+ unless verification_key.verify_io(input, signature, chunk_size:, context: EMPTY_CONTEXT)
66
+ raise ::JWT::VerificationError, "Streaming JWS verification failed"
67
+ end
68
+
69
+ [payload_position(payload_io), header]
70
+ rescue *DECODE_ERRORS => error
71
+ raise ::JWT::DecodeError, error.message
72
+ rescue *VERIFY_ERRORS => error
73
+ raise ::JWT::VerificationError, error.message
74
+ end
75
+
76
+ def decode_detached(token)
77
+ case token.split(".", -1)
78
+ in [encoded_header, "", encoded_signature]
79
+ header = JSON.parse(Base64URL.decode(encoded_header))
80
+ raise ::JWT::DecodeError, "unsupported streaming JWS protected header" unless streamable_header?(header)
81
+
82
+ signature = Base64URL.decode(encoded_signature)
83
+ raise ::JWT::VerificationError, "invalid #{alg} signature length" unless signature_length_valid?(signature)
84
+
85
+ [encoded_header, header, signature]
86
+ else
87
+ raise ::JWT::DecodeError,
88
+ "compact detached JWS must have exactly three segments and an empty payload segment"
89
+ end
90
+ end
91
+
92
+ def ensure_streaming!
93
+ raise UnsupportedFeature, "#{alg} does not support streaming JWS" unless streaming_supported?
94
+ end
95
+
96
+ def validate_stream!(key, klass, role, chunk_size)
97
+ ensure_streaming!
98
+ ensure_key!(key, klass, role)
99
+ Streaming.validate_chunk_size!(chunk_size)
100
+ end
101
+
102
+ def payload_position(payload_io)
103
+ payload_io.pos if payload_io.respond_to?(:pos)
104
+ end
105
+
106
+ def signing_header(header_fields)
107
+ raise ArgumentError, "header_fields must be a Hash-like object" unless header_fields.respond_to?(:to_hash)
108
+
109
+ converted = header_fields.to_hash
110
+ raise ArgumentError, "header_fields #to_hash must return a Hash" unless converted.is_a?(Hash)
111
+
112
+ header = converted.transform_keys { |key| String(key) }
113
+ unsupported = UNSUPPORTED_HEADERS & header.keys
114
+ unless unsupported.empty?
115
+ raise ArgumentError, "unsupported protected header#{'s' if unsupported.size > 1}: #{unsupported.join(', ')}"
116
+ end
117
+
118
+ header.merge("alg" => alg)
119
+ end
120
+
121
+ def streamable_header?(header)
122
+ header.is_a?(Hash) && header["alg"] == alg && !header.key?("crit") && header.fetch("b64", true) == true
123
+ end
124
+
125
+ def base64url(bytes) = Base64URL.encode(bytes)
126
+ end
127
+ end
128
+ end
129
+ end
@@ -1,7 +1,8 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- require "jwt"
4
- require "pq_crypto"
3
+ require_relative "jwa/streaming"
4
+ require_relative "jwa/detached_signing_input_io"
5
+ require_relative "jwa/ml_dsa"
5
6
 
6
7
  module PQCrypto
7
8
  module JWT
@@ -12,53 +13,7 @@ module PQCrypto
12
13
  ::JWT::DecodeError, ::JWT::VerificationError, ::JWT::JWKError,
13
14
  ArgumentError, TypeError, EncodingError
14
15
  ].freeze
15
-
16
- module MLDSA
17
- def valid_alg?(alg_to_validate) = alg_to_validate == alg
18
- def pq_crypto_algorithm = self::PQ_CRYPTO_ALGORITHM
19
- def key_kind = :signature
20
-
21
- def sign(data:, signing_key:)
22
- ensure_key!(signing_key, PQCrypto::Signature::SecretKey, "signing")
23
- raise ArgumentError, "data must be a String" unless data.is_a?(String)
24
-
25
- signing_key.sign(data.b, context: EMPTY_CONTEXT)
26
- rescue PQCrypto::JWT::KeyTypeError, ArgumentError
27
- raise
28
- rescue StandardError => e
29
- raise ::JWT::EncodeError, e.message
30
- end
31
-
32
- def verify(data:, signature:, verification_key:)
33
- return false unless verification_key.is_a?(PQCrypto::Signature::PublicKey)
34
- return false unless verification_key.algorithm == pq_crypto_algorithm
35
- return false unless data.is_a?(String) && signature.is_a?(String)
36
- return false unless signature_length_valid?(signature)
37
-
38
- verification_key.verify(data.b, signature.b, context: EMPTY_CONTEXT)
39
- rescue *VERIFY_ERRORS
40
- false
41
- end
42
-
43
- private
44
-
45
- def ensure_key!(key, klass, role)
46
- unless key.is_a?(klass)
47
- raise PQCrypto::JWT::KeyTypeError, "#{alg} #{role} requires #{klass}"
48
- end
49
- return if key.algorithm == pq_crypto_algorithm
50
-
51
- raise PQCrypto::JWT::KeyTypeError,
52
- "#{alg} #{role} requires #{pq_crypto_algorithm.inspect} key, got #{key.algorithm.inspect}"
53
- end
54
-
55
- def signature_length_valid?(signature)
56
- expected = PQCrypto::Signature.details(pq_crypto_algorithm)[:signature_bytes]
57
- expected.nil? || signature.bytesize == expected
58
- rescue *VERIFY_ERRORS
59
- false
60
- end
61
- end
16
+ MLDSAStreaming = Streaming
62
17
  end
63
18
  end
64
19
  end
@@ -5,9 +5,10 @@ require "jwt/jwk/key_base"
5
5
  module JWT
6
6
  module JWK
7
7
  class AKP < KeyBase
8
- KTY = "AKP".freeze
8
+ KTY = "AKP"
9
9
  KTYS = [KTY, PQCrypto::Signature::PublicKey, JWT::JWK::AKP].freeze
10
10
  AKP_KEY_ELEMENTS = %i[kty alg pub priv].freeze
11
+ AKP_PUBLIC_KEY_ELEMENTS = %i[alg kty pub].freeze
11
12
  PRIVATE_EXPORT_OPTIONS = %i[private include_private].freeze
12
13
 
13
14
  class NullKidGenerator
@@ -15,38 +16,34 @@ module JWT
15
16
  def generate = nil
16
17
  end
17
18
 
19
+ attr_reader :public_key
20
+
18
21
  def initialize(key, params = nil, options = {})
19
- params = params.is_a?(String) ? { kid: params } : (params || {})
20
- params = params.transform_keys(&:to_sym)
21
- key_params = extract_key_params(key)
22
- @checked_public_key, @checked_secret_key = check_jwk_params!(key_params, params)
23
- super({ kid_generator: NullKidGenerator }.merge(options || {}), key_params.merge(params))
22
+ params = { kid: params } if params.is_a?(String)
23
+ params = (params || {}).transform_keys(&:to_sym)
24
+ key_params = snapshot_key_params(extract_key_params(key))
25
+ @public_key = validate_key_params!(key_params, params)
26
+ super({ kid_generator: NullKidGenerator, **(options || {}) }, key_params.merge(params))
24
27
  end
25
28
 
26
- def private? = parameters.key?(:priv) && !parameters[:priv].nil?
29
+ def private? = !self[:priv].nil?
27
30
  def verify_key = public_key
28
-
29
- def public_key
30
- @public_key ||= @checked_public_key || PQCrypto::JWT::JWK.public_key_from_jwk(string_export)
31
- end
32
-
33
31
  def signing_key = private? ? secret_key : public_key
34
32
 
35
33
  def secret_key
36
34
  raise JWT::JWKError, "AKP JWK does not contain private material" unless private?
37
35
 
38
- @secret_key ||= @checked_secret_key || PQCrypto::JWT::JWK.secret_key_from_jwk(string_export(include_private: true))
36
+ self.cached_secret_key ||= PQCrypto::JWT::JWK.secret_key_from_jwk(string_export(include_private: true))
39
37
  end
40
38
 
41
39
  def export(options = {})
42
- include_private = PRIVATE_EXPORT_OPTIONS.any? { |key| (options || {})[key] }
43
- parameters.clone.tap { |exported| exported.delete(:priv) unless include_private }
40
+ include_private = (options || {}).values_at(*PRIVATE_EXPORT_OPTIONS).any?
41
+ include_private ? parameters.dup : parameters.except(:priv)
44
42
  end
45
43
 
46
- def members
47
- keys = private? ? %i[alg kty pub priv] : %i[alg kty pub]
48
- keys.each_with_object({}) { |key, out| out[key] = self[key] }
49
- end
44
+ def members = parameters.slice(*AKP_PUBLIC_KEY_ELEMENTS)
45
+
46
+ def parameters = super.dup.freeze
50
47
 
51
48
  def key_digest = PQCrypto::JWT::JWK.thumbprint(string_export)
52
49
  def jwa = PQCrypto::JWT.algorithm_for(self[:alg]) || super
@@ -59,16 +56,22 @@ module JWT
59
56
 
60
57
  private
61
58
 
62
- def string_export(include_private: false)
63
- export(include_private: include_private).transform_keys(&:to_s)
59
+ attr_accessor :cached_secret_key
60
+
61
+ def snapshot_key_params(key_params)
62
+ key_params.to_h do |name, value|
63
+ copied = AKP_KEY_ELEMENTS.include?(name) && value.is_a?(String) ? value.dup.freeze : value
64
+ [name, copied]
65
+ end
64
66
  end
65
67
 
68
+ def string_export(include_private: false) = export(include_private:).transform_keys(&:to_s)
69
+
66
70
  def extract_key_params(key)
67
71
  case key
68
72
  when JWT::JWK::AKP then key.export(include_private: key.private?)
69
73
  when Hash then key.transform_keys(&:to_sym)
70
- when PQCrypto::Signature::PublicKey
71
- PQCrypto::JWT::JWK.from_public_key(key).transform_keys(&:to_sym)
74
+ when PQCrypto::Signature::PublicKey then PQCrypto::JWT::JWK.from_public_key(key).transform_keys(&:to_sym)
72
75
  when PQCrypto::Signature::Keypair, PQCrypto::Signature::SecretKey
73
76
  raise JWT::JWKError,
74
77
  "AKP private JWK export from SecretKey requires public seed-export APIs in pq_crypto; " \
@@ -76,24 +79,32 @@ module JWT
76
79
  else
77
80
  raise ArgumentError, "key must be an AKP JWK Hash or PQCrypto::Signature::PublicKey"
78
81
  end
79
- rescue PQCrypto::JWT::Error => e
80
- raise JWT::JWKError, e.message
82
+ rescue PQCrypto::JWT::Error => error
83
+ raise JWT::JWKError, error.message
81
84
  end
82
85
 
83
- def check_jwk_params!(key_params, params)
84
- raise ArgumentError, "cannot overwrite cryptographic key attributes" unless (AKP_KEY_ELEMENTS & params.keys).empty?
85
- raise JWT::JWKError, "Incorrect 'kty' value: #{key_params[:kty]}, expected #{KTY}" unless key_params[:kty] == KTY
86
- raise JWT::JWKError, "AKP JWK alg is required" unless key_params[:alg]
87
- raise JWT::JWKError, "AKP JWK pub is required" unless key_params[:pub]
88
- raise JWT::JWKError, "Unsupported AKP JWK alg: #{key_params[:alg].inspect}" unless PQCrypto::JWT.algorithm_for(key_params[:alg])
89
-
90
- parsed = key_params.transform_keys(&:to_s)
91
- [
92
- PQCrypto::JWT::JWK.public_key_from_jwk(parsed),
93
- key_params[:priv] ? PQCrypto::JWT::JWK.secret_key_from_jwk(parsed) : nil
94
- ]
95
- rescue PQCrypto::JWT::Error => e
96
- raise JWT::JWKError, e.message
86
+ def validate_key_params!(key_params, params)
87
+ raise ArgumentError, "cannot overwrite cryptographic key attributes" if AKP_KEY_ELEMENTS.intersect?(params.keys)
88
+
89
+ kty, alg, pub = key_params.values_at(:kty, :alg, :pub)
90
+ raise JWT::JWKError, "Incorrect 'kty' value: #{kty}, expected #{KTY}" unless kty == KTY
91
+ raise JWT::JWKError, "AKP JWK alg is required" unless alg
92
+ raise JWT::JWKError, "AKP JWK pub is required" unless pub
93
+ raise JWT::JWKError, "Unsupported AKP JWK alg: #{alg.inspect}" unless PQCrypto::JWT.algorithm_for(alg)
94
+
95
+ validate_seed_length!(key_params) if key_params.key?(:priv)
96
+ PQCrypto::JWT::JWK.public_key_from_jwk(key_params)
97
+ rescue PQCrypto::JWT::Error => error
98
+ raise JWT::JWKError, error.message
99
+ end
100
+
101
+ def validate_seed_length!(key_params)
102
+ actual = PQCrypto::JWT::JWK.base64url_decode(key_params[:priv]).bytesize
103
+ expected = PQCrypto::JWT::JWK::SEED_BYTES
104
+ return if actual == expected
105
+
106
+ raise JWT::JWKError,
107
+ "Invalid priv seed length for #{key_params[:alg].inspect}: expected #{expected}, got #{actual}"
97
108
  end
98
109
  end
99
110
  end
@@ -7,35 +7,36 @@ require "json"
7
7
  module PQCrypto
8
8
  module JWT
9
9
  module JWK
10
- module_function
10
+ extend self
11
11
 
12
- KTY = "AKP".freeze
12
+ KTY = "AKP"
13
13
  SEED_BYTES = defined?(PQCrypto::PKCS8::ML_DSA_SEED_BYTES) ? PQCrypto::PKCS8::ML_DSA_SEED_BYTES : 32
14
+ THUMBPRINT_URI_PREFIX = "urn:ietf:params:oauth:jwk-thumbprint:sha-256:"
14
15
 
15
16
  def from_public_key(public_key, kid: nil, use: nil, key_ops: nil)
16
17
  validate_key!(public_key, PQCrypto::Signature::PublicKey)
17
- public_jwk(public_key.algorithm, public_key.to_bytes, kid: kid, use: use, key_ops: key_ops).freeze
18
+ public_jwk(public_key, kid:, use:, key_ops:).freeze
18
19
  end
19
20
 
20
21
  def from_seed(seed, alg:, kid: nil, public_key: nil, use: nil, key_ops: nil, verify_public: false)
21
22
  algorithm = pq_algorithm_from_jose!(alg)
22
- seed_bytes = validate_seed!(seed, algorithm)
23
- derived = derive_public_key(algorithm, seed_bytes) if public_key.nil? || verify_public
23
+ seed = validate_seed!(seed, algorithm)
24
+ derived = derive_public_key(algorithm, seed) if public_key.nil? || verify_public
24
25
  public_key ||= derived
25
26
  unless public_key
26
- raise PQCrypto::JWT::UnsupportedFeature,
27
+ raise UnsupportedFeature,
27
28
  "AKP JWK export from seed requires pq_crypto public_key_from_seed/keypair_from_seed or public_key:"
28
29
  end
29
30
 
30
31
  validate_key!(public_key, PQCrypto::Signature::PublicKey)
31
- unless public_key.algorithm == algorithm
32
- raise PQCrypto::JWT::KeyTypeError, "public_key algorithm mismatch: expected #{algorithm.inspect}, got #{public_key.algorithm.inspect}"
32
+ actual = public_key.algorithm
33
+ unless actual == algorithm
34
+ raise KeyTypeError,
35
+ "public_key algorithm mismatch: expected #{algorithm.inspect}, got #{actual.inspect}"
33
36
  end
34
- check_seed_matches_public!(public_key, derived) if verify_public
37
+ check_seed_matches_public!(public_key.to_bytes, derived) if verify_public
35
38
 
36
- public_jwk(algorithm, public_key.to_bytes, kid: kid, use: use, key_ops: key_ops)
37
- .merge!("priv" => base64url(seed_bytes))
38
- .freeze
39
+ public_jwk(public_key, kid:, use:, key_ops:).merge("priv" => base64url(seed).freeze).freeze
39
40
  end
40
41
 
41
42
  def from_secret_key(secret_key, kid: nil, public_key: nil, use: nil, key_ops: nil)
@@ -45,152 +46,156 @@ module PQCrypto
45
46
  end
46
47
  validate_key!(secret_key, PQCrypto::Signature::SecretKey)
47
48
 
48
- from_seed(seed_from_secret_key!(secret_key),
49
- alg: jose_alg_for!(secret_key.algorithm),
50
- kid: kid, public_key: public_key, use: use, key_ops: key_ops)
49
+ seed = seed_from_secret_key!(secret_key)
50
+ from_seed(seed, alg: jose_alg_for!(secret_key.algorithm), kid:, public_key:, use:, key_ops:)
51
51
  end
52
52
 
53
53
  def public_key_from_jwk(hash)
54
- jwk = normalize_hash!(hash)
55
- algorithm = algorithm_from_jwk!(jwk)
56
- PQCrypto::Signature.public_key_from_bytes(algorithm, decode_field!(jwk, "pub", algorithm))
57
- rescue ArgumentError, PQCrypto::Error => e
58
- raise PQCrypto::JWT::Error, e.message
54
+ _jwk, algorithm, public_bytes = parse_public!(hash)
55
+ PQCrypto::Signature.public_key_from_bytes(algorithm, public_bytes)
56
+ rescue ArgumentError, PQCrypto::Error => error
57
+ raise Error, error.message
59
58
  end
60
59
 
61
60
  def secret_key_from_jwk(hash, verify_public: false)
62
- jwk = normalize_hash!(hash)
63
- algorithm = algorithm_from_jwk!(jwk)
64
- decode_field!(jwk, "pub", algorithm)
65
- seed = validate_seed!(base64url_decode(jwk.fetch("priv") { raise PQCrypto::JWT::Error, "JWK priv is required" }), algorithm)
66
- check_seed_matches_public!(public_key_from_jwk(jwk), derive_public_key(algorithm, seed)) if verify_public
61
+ jwk, algorithm, public_bytes = parse_public!(hash)
62
+ seed = validate_seed!(base64url_decode(jwk.fetch("priv") { raise Error, "JWK priv is required" }), algorithm)
63
+ check_seed_matches_public!(public_bytes, derive_public_key(algorithm, seed)) if verify_public
67
64
 
68
65
  PQCrypto::Signature.secret_key_from_seed(algorithm, seed)
69
- rescue ArgumentError, PQCrypto::Error => e
70
- raise PQCrypto::JWT::Error, e.message
66
+ rescue ArgumentError, PQCrypto::Error => error
67
+ raise Error, error.message
71
68
  end
72
69
 
73
70
  def thumbprint(jwk_hash)
74
- jwk = normalize_hash!(jwk_hash)
75
- algorithm_from_jwk!(jwk)
76
- raise PQCrypto::JWT::Error, "JWK pub is required" unless jwk.key?("pub")
77
-
78
- canonical = JSON.generate("alg" => jwk.fetch("alg"), "kty" => KTY, "pub" => jwk.fetch("pub"))
79
- base64url(Digest::SHA256.digest(canonical.b))
71
+ jwk = parse_public!(jwk_hash).first
72
+ base64url(Digest::SHA256.digest(JSON.generate("alg" => jwk["alg"], "kty" => KTY, "pub" => jwk["pub"])))
80
73
  end
81
74
 
82
- def base64url(bytes)
83
- Base64.urlsafe_encode64(String(bytes).b, padding: false)
84
- end
75
+ def thumbprint_uri(jwk_hash) = "#{THUMBPRINT_URI_PREFIX}#{thumbprint(jwk_hash)}"
76
+
77
+ def base64url(bytes) = Base64URL.encode(bytes)
85
78
 
86
79
  def base64url_decode(value)
87
- raw = String(value)
88
- Base64.urlsafe_decode64(raw + ("=" * ((4 - raw.bytesize % 4) % 4)))
89
- rescue ArgumentError => e
90
- raise PQCrypto::JWT::Error, "Invalid base64url value: #{e.message}"
80
+ Base64URL.decode(value)
81
+ rescue ArgumentError => error
82
+ raise Error, "Invalid base64url value: #{error.message}"
91
83
  end
92
84
 
93
85
  def normalize_hash!(hash)
94
- raise PQCrypto::JWT::Error, "JWK must be a Hash-like object" unless hash.respond_to?(:to_hash)
86
+ raise Error, "JWK must be a Hash-like object" unless hash.respond_to?(:to_hash)
87
+
88
+ converted = hash.to_hash
89
+ raise Error, "JWK #to_hash must return a Hash" unless converted.is_a?(Hash)
95
90
 
96
- hash.to_hash.each_with_object({}) { |(key, value), out| out[String(key)] = value }
91
+ converted.transform_keys { |key| String(key) }
97
92
  end
98
93
 
99
94
  def algorithm_from_jwk!(jwk)
100
- raise PQCrypto::JWT::Error, "Unsupported JWK kty: #{jwk['kty'].inspect}" unless jwk["kty"] == KTY
95
+ kty = jwk["kty"]
96
+ raise Error, "Unsupported JWK kty: #{kty.inspect}" unless kty == KTY
101
97
 
102
98
  pq_algorithm_from_jose!(jwk["alg"])
103
99
  end
104
100
 
105
- def pq_algorithm_from_jose!(alg)
106
- algorithm = PQCrypto::JWT.algorithm_for(alg)
107
- raise PQCrypto::JWT::UnsupportedAlgorithm, "Unsupported JWK alg: #{alg.inspect}" unless algorithm&.key_kind == :signature
101
+ private
108
102
 
109
- algorithm.pq_crypto_algorithm
103
+ def parse_public!(hash)
104
+ jwk = normalize_hash!(hash)
105
+ algorithm = algorithm_from_jwk!(jwk)
106
+ [jwk, algorithm, decode_public_bytes!(jwk, algorithm)]
110
107
  end
111
- private_class_method :pq_algorithm_from_jose!
112
108
 
113
- def jose_alg_for!(pq_algorithm)
114
- match = PQCrypto::JWT.signing_algorithms.find { |candidate| candidate.pq_crypto_algorithm == pq_algorithm }
115
- raise PQCrypto::JWT::UnsupportedAlgorithm, "Unsupported pq_crypto signature algorithm: #{pq_algorithm.inspect}" unless match
109
+ def decode_public_bytes!(jwk, algorithm)
110
+ raise Error, "JWK pub is required" unless jwk.key?("pub")
116
111
 
117
- match.alg
118
- end
119
- private_class_method :jose_alg_for!
112
+ bytes = base64url_decode(jwk["pub"])
113
+ expected = PQCrypto::Signature.details(algorithm).fetch(:public_key_bytes)
114
+ actual = bytes.bytesize
115
+ return bytes if actual == expected
120
116
 
121
- def public_jwk(pq_algorithm, public_bytes, kid:, use:, key_ops:)
122
- jwk = { "kty" => KTY, "alg" => jose_alg_for!(pq_algorithm), "pub" => base64url(public_bytes) }
123
- jwk["kid"] = String(kid) unless kid.nil?
124
- jwk["use"] = String(use) unless use.nil?
125
- jwk["key_ops"] = Array(key_ops).map(&:to_s) unless key_ops.nil?
126
- jwk
117
+ raise Error, "Invalid pub length for #{algorithm.inspect}: expected #{expected}, got #{actual}"
127
118
  end
128
- private_class_method :public_jwk
129
119
 
130
- def decode_field!(jwk, field, algorithm)
131
- raise PQCrypto::JWT::Error, "JWK #{field} is required" unless jwk.key?(field)
120
+ def public_jwk(public_key, kid:, use:, key_ops:)
121
+ {
122
+ "kty" => KTY,
123
+ "alg" => jose_alg_for!(public_key.algorithm),
124
+ "pub" => base64url(public_key.to_bytes).freeze,
125
+ "kid" => metadata_string(kid),
126
+ "use" => metadata_string(use),
127
+ "key_ops" => (Array(key_ops).map { |operation| operation.to_s.dup.freeze }.freeze unless key_ops.nil?)
128
+ }.compact
129
+ end
132
130
 
133
- decoded = base64url_decode(jwk.fetch(field))
134
- expected = PQCrypto::Signature.details(algorithm).fetch(:public_key_bytes)
135
- raise PQCrypto::JWT::Error, "Invalid #{field} length for #{algorithm.inspect}: expected #{expected}, got #{decoded.bytesize}" unless decoded.bytesize == expected
131
+ def metadata_string(value)
132
+ String(value).dup.freeze unless value.nil?
133
+ end
136
134
 
137
- decoded.b
135
+ def pq_algorithm_from_jose!(alg)
136
+ PQCrypto::JWT.algorithm_for(alg)&.pq_crypto_algorithm ||
137
+ raise(UnsupportedAlgorithm, "Unsupported JWK alg: #{alg.inspect}")
138
138
  end
139
- private_class_method :decode_field!
140
139
 
141
- def validate_seed!(seed, algorithm)
142
- bytes = String(seed).b
143
- return bytes if bytes.bytesize == SEED_BYTES
140
+ def jose_alg_for!(pq_algorithm)
141
+ signing_algorithm_for(pq_algorithm)&.alg ||
142
+ raise(UnsupportedAlgorithm, "Unsupported pq_crypto signature algorithm: #{pq_algorithm.inspect}")
143
+ end
144
144
 
145
- raise PQCrypto::JWT::Error, "Invalid priv seed length for #{algorithm.inspect}: expected #{SEED_BYTES}, got #{bytes.bytesize}"
145
+ def signing_algorithm_for(pq_algorithm)
146
+ PQCrypto::JWT.signing_algorithms.find { |algorithm| algorithm.pq_crypto_algorithm == pq_algorithm }
146
147
  end
147
- private_class_method :validate_seed!
148
148
 
149
149
  def validate_key!(key, klass)
150
- raise PQCrypto::JWT::KeyTypeError, "Expected #{klass}" unless key.is_a?(klass)
151
- return if PQCrypto::JWT.signing_algorithms.any? { |c| c.pq_crypto_algorithm == key.algorithm }
150
+ raise KeyTypeError, "Expected #{klass}" unless key.is_a?(klass)
152
151
 
153
- raise PQCrypto::JWT::KeyTypeError, "Unsupported signature algorithm: #{key.algorithm.inspect}"
152
+ actual = key.algorithm
153
+ return if signing_algorithm_for(actual)
154
+
155
+ raise KeyTypeError, "Unsupported signature algorithm: #{actual.inspect}"
154
156
  end
155
- private_class_method :validate_key!
156
157
 
157
- def derive_public_key(algorithm, seed)
158
- return PQCrypto::Signature.public_key_from_seed(algorithm, seed) if PQCrypto::Signature.respond_to?(:public_key_from_seed)
159
- return PQCrypto::Signature.keypair_from_seed(algorithm, seed).public_key if PQCrypto::Signature.respond_to?(:keypair_from_seed)
158
+ def validate_seed!(seed, algorithm)
159
+ bytes = String(seed).b
160
+ actual = bytes.bytesize
161
+ return bytes if actual == SEED_BYTES
162
+
163
+ raise Error, "Invalid priv seed length for #{algorithm.inspect}: expected #{SEED_BYTES}, got #{actual}"
164
+ end
160
165
 
161
- nil
166
+ def derive_public_key(algorithm, seed)
167
+ if PQCrypto::Signature.respond_to?(:public_key_from_seed)
168
+ PQCrypto::Signature.public_key_from_seed(algorithm, seed)
169
+ elsif PQCrypto::Signature.respond_to?(:keypair_from_seed)
170
+ PQCrypto::Signature.keypair_from_seed(algorithm, seed).public_key
171
+ end
162
172
  end
163
- private_class_method :derive_public_key
164
173
 
165
- def check_seed_matches_public!(public_key, derived)
174
+ def check_seed_matches_public!(public_bytes, derived)
166
175
  unless derived
167
- raise PQCrypto::JWT::UnsupportedFeature,
176
+ raise UnsupportedFeature,
168
177
  "AKP JWK pub/priv consistency verification requires pq_crypto public_key_from_seed/keypair_from_seed"
169
178
  end
170
- return if public_key.to_bytes == derived.to_bytes
171
-
172
- raise PQCrypto::JWT::Error, "AKP JWK public_key does not match priv seed"
179
+ raise Error, "AKP JWK public_key does not match priv seed" unless public_bytes == derived.to_bytes
173
180
  end
174
- private_class_method :check_seed_matches_public!
175
181
 
176
182
  def seed_from_secret_key!(secret_key)
177
183
  if secret_key.respond_to?(:seed?) && !secret_key.seed?
178
- raise PQCrypto::JWT::UnsupportedFeature,
179
- "SecretKey was not created from a seed; cannot export RFC 9964 AKP JWK"
184
+ raise UnsupportedFeature, "SecretKey was not created from a seed; cannot export RFC 9964 AKP JWK"
180
185
  end
186
+
181
187
  unless secret_key.respond_to?(:to_seed)
182
- raise PQCrypto::JWT::UnsupportedFeature,
183
- "SecretKey seed export requires a public pq_crypto #to_seed API; use from_seed(..., public_key:) instead"
188
+ raise UnsupportedFeature, "SecretKey seed export requires a public pq_crypto #to_seed API; " \
189
+ "use from_seed(..., public_key:) instead"
184
190
  end
185
191
 
186
192
  seed = secret_key.to_seed
187
- raise PQCrypto::JWT::UnsupportedFeature, "SecretKey #to_seed returned nil" if seed.nil?
193
+ raise UnsupportedFeature, "SecretKey #to_seed returned nil" if seed.nil?
188
194
 
189
195
  validate_seed!(seed, secret_key.algorithm)
190
- rescue PQCrypto::Error => e
191
- raise PQCrypto::JWT::UnsupportedFeature, "SecretKey seed export failed: #{e.message}"
196
+ rescue PQCrypto::Error => error
197
+ raise UnsupportedFeature, "SecretKey seed export failed: #{error.message}"
192
198
  end
193
- private_class_method :seed_from_secret_key!
194
199
  end
195
200
  end
196
201
  end
@@ -0,0 +1,35 @@
1
+ # frozen_string_literal: true
2
+
3
+ module PQCrypto
4
+ module JWT
5
+ module JWKS
6
+ class Loader
7
+ def initialize(source)
8
+ @fetch = source.respond_to?(:call) ? source : proc { source }
9
+ @cached = CACHE_EMPTY
10
+ @mutex = Mutex.new
11
+ end
12
+
13
+ def call(options = {})
14
+ options ||= {}
15
+ invalidate = options[:invalidate]
16
+ current = cached
17
+ return current unless invalidate || current.equal?(CACHE_EMPTY)
18
+
19
+ mutex.synchronize { refresh(options, invalidate) }
20
+ end
21
+
22
+ private
23
+
24
+ attr_reader :fetch, :mutex
25
+ attr_accessor :cached
26
+
27
+ def refresh(options, invalidate)
28
+ self.cached = CACHE_EMPTY if invalidate
29
+ self.cached = fetch.call(options) if cached.equal?(CACHE_EMPTY)
30
+ cached
31
+ end
32
+ end
33
+ end
34
+ end
35
+ end