fix(jwk): group key related errors with KeyParameterError

Author: lepture

src/joserfc/_rfc7517/models.py

@@ -13,6 +13,7 @@
 )
 from ..util import to_bytes
 from ..errors import (
+    KeyParameterError,
     UnsupportedKeyUseError,
     UnsupportedKeyAlgorithmError,
     UnsupportedKeyOperationError,
@@ -58,13 +59,13 @@ def as_bytes(
     def validate_dict_key_registry(cls, dict_key: DictKey, registry: KeyParameterRegistryDict) -> None:
         for k in registry:
             if registry[k].required and k not in dict_key:
-                raise ValueError(f"'{k}' is required")
+                raise KeyParameterError(f"'{k}' is required")
 
             if k in dict_key:
                 try:
                     registry[k].validate(dict_key[k])
                 except ValueError as error:
-                    raise ValueError(f"'{k}' {error}")
+                    raise KeyParameterError(f"'{k}' {error}")
 
     @classmethod
     def validate_dict_key_use_operations(cls, dict_key: DictKey) -> None:
@@ -73,7 +74,7 @@ def validate_dict_key_use_operations(cls, dict_key: DictKey) -> None:
             operations = cls.use_key_ops_registry[_use]
             for op in dict_key["key_ops"]:
                 if op not in operations:
-                    raise ValueError("'use' and 'key_ops' does not match")
+                    raise KeyParameterError("'use' and 'key_ops' does not match")
 
 
 class BaseKey(t.Generic[NativePrivateKey, NativePublicKey], metaclass=ABCMeta):

src/joserfc/_rfc7517/pem.py

@@ -71,7 +71,7 @@ def dump_pem_key(
     elif encoding == "DER":
         encoding_enum = Encoding.DER
     else:  # pragma: no cover
-        raise ValueError(f"Invalid encoding: {encoding!r}")
+        raise ValueError(f"Invalid encoding: {encoding}")
 
     if private:
         encryption_algorithm: KeySerializationEncryption

src/joserfc/_rfc7518/rsa_key.py

@@ -15,7 +15,7 @@
 )
 from cryptography.hazmat.backends import default_backend
 from ..registry import KeyParameter
-from ..errors import SecurityWarning
+from ..errors import SecurityWarning, KeyParameterError
 from .._rfc7517.models import AsymmetricKey
 from .._rfc7517.pem import CryptographyBinding
 from .._rfc7517.types import KeyParameters, AnyKey
@@ -194,6 +194,6 @@ def has_all_prime_factors(obj: RSADictKey) -> bool:
         return True
 
     if any(props_found):
-        raise ValueError("RSA key must include all parameters if any are present besides d")
+        raise KeyParameterError("RSA key must include all parameters if any are present besides d")
 
     return False

src/joserfc/errors.py

@@ -26,27 +26,31 @@ def __init__(self, description: str | None = None):
 # --- Key related errors --- #
 
 
+class KeyParameterError(JoseError):
+    error = "key_parameter"
+
+
 class MissingKeyError(JoseError):
     error = "missing_key"
 
 
-class UnsupportedKeyUseError(JoseError):
+class UnsupportedKeyUseError(KeyParameterError):
     error = "unsupported_key_use"
 
 
-class UnsupportedKeyAlgorithmError(JoseError):
+class UnsupportedKeyAlgorithmError(KeyParameterError):
     error = "unsupported_key_alg"
 
 
-class UnsupportedKeyOperationError(JoseError):
+class UnsupportedKeyOperationError(KeyParameterError):
     error = "unsupported_key_operation"
 
 
-class MissingKeyTypeError(JoseError):
+class MissingKeyTypeError(KeyParameterError):
     error = "missing_key_type"
 
 
-class InvalidKeyTypeError(JoseError):
+class InvalidKeyTypeError(KeyParameterError):
     error = "invalid_key_type"
 
 

tests/jwk/test_oct_key.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 from joserfc.jwk import OctKey
-from joserfc.errors import SecurityWarning
+from joserfc.errors import SecurityWarning, KeyParameterError
 from tests.keys import read_key
 
 
@@ -55,35 +55,35 @@ def test_import_missing_k(self):
             "kty": "oct",
             "alg": "A128KW",
         }
-        self.assertRaises(ValueError, OctKey.import_key, data)
+        self.assertRaises(KeyParameterError, OctKey.import_key, data)
 
     def test_invalid_typeof_k(self):
         data = {
             "kty": "oct",
             "alg": "A128KW",
             "k": 123,
         }
-        self.assertRaises(ValueError, OctKey.import_key, data)
+        self.assertRaises(KeyParameterError, OctKey.import_key, data)
 
     def test_mismatch_use_key_ops(self):
         data = {"kty": "oct", "alg": "A128KW", "k": "GawgguFyGrWKav7AX4VKUg", "use": "sig", "key_ops": ["wrapKey"]}
-        self.assertRaises(ValueError, OctKey.import_key, data)
+        self.assertRaises(KeyParameterError, OctKey.import_key, data)
 
     def test_invalid_use(self):
         data = {
             "kty": "oct",
             "k": "GawgguFyGrWKav7AX4VKUg",
             "use": "invalid",
         }
-        self.assertRaises(ValueError, OctKey.import_key, data)
+        self.assertRaises(KeyParameterError, OctKey.import_key, data)
 
     def test_invalid_key_ops(self):
         data = {
             "kty": "oct",
             "k": "GawgguFyGrWKav7AX4VKUg",
             "key_ops": ["invalid"],
         }
-        self.assertRaises(ValueError, OctKey.import_key, data)
+        self.assertRaises(KeyParameterError, OctKey.import_key, data)
 
     def test_import_pem_key(self):
         public_pem = read_key("ec-p256-public.pem")

tests/jwk/test_rsa_key.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 from joserfc.jwk import RSAKey
-from joserfc.errors import SecurityWarning, InvalidKeyTypeError
+from joserfc.errors import SecurityWarning, KeyParameterError, InvalidKeyTypeError
 from tests.keys import read_key
 
 
@@ -42,7 +42,7 @@ def test_with_oth(self):
             "e": "AQAB",
             "oth": "invalid information",
         }
-        self.assertRaises(ValueError, RSAKey.import_key, data)
+        self.assertRaises(KeyParameterError, RSAKey.import_key, data)
 
     def test_import_only_from_d(self):
         data = {
@@ -72,7 +72,7 @@ def test_import_only_from_d(self):
             "9vDQSccA3xXHOAFOPJ8R9EeIAbTi1VwBYnbTp87X-xcPWlEPkrdoUKW60tgs1aNd_Nnc"
             "9LEVVPMS390zbFxt8TN_biaBgelNgbC95sM"
         )
-        self.assertRaises(ValueError, RSAKey.import_key, data)
+        self.assertRaises(KeyParameterError, RSAKey.import_key, data)
 
     def test_import_key_from_ssh(self):
         ssh_public_pem = read_key("ssh-rsa-public.pem")