jamlib 3.2.0rc0__tar.gz → 3.3.0__tar.gz

{jamlib-3.2.0rc0/src/jamlib.egg-info → jamlib-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.2.0rc0
+Version: 3.3.0
 Summary: Simple and universal library for authorization.
 Author-email: Makridenko Adrian <adrianmakridenko@duck.com>, Ksenia Travnikova <kseniatravnikova@duck.com>
 License: Apache-2.0
@@ -62,6 +62,8 @@ Dynamic: license-file
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/lyaguxafrog/jam)
 [![GitHub License](https://img.shields.io/github/license/lyaguxafrog/jam)](https://github.com/lyaguxafrog/jam/blob/master/LICENSE.md)
 
+**Jam (Jam Auth Module)** - A universal auth* combine that provides popular auth mechanisms strictly according to the specification.
+
 * Documentation: [jam.makridenko.ru](https://jam.makridenko.ru)
 * Changelog: [CHANGELOG.md](https://github.com/lyaguxafrog/jam/blob/master/CHANGELOG.md)
 
@@ -77,7 +79,7 @@ from jam import Jam
 
 jam = Jam(config="config.toml")
 
-jwt = jam.jwt_create({"user": 1})
+jwt = jam.jwt_encode(payload={"user": 1})
 session_id = jam.session_create(session_key="username", data={"user": 1})
 otp_code = jam.otp_code(secret="3DB7FOAOFBCI3WFDRE7EPF43CA")
 ```
@@ -85,11 +87,12 @@ otp_code = jam.otp_code(secret="3DB7FOAOFBCI3WFDRE7EPF43CA")
 ## Why Jam?
 Jam is a library that provides the most popular AUTH* mechanisms right out of the box.
 
-* [JOSE](https://jam.makridenko.ru/usage/jose/index/)
+* [JOSE](https://jam.makridenko.ru/usage/jose/)
 * [PASETO](https://jam.makridenko.ru/usage/paseto/)
 * [Server side sessions](https://jam.makridenko.ru/usage/sessions/)
 * [OTP](https://jam.makridenko.ru/usage/otp/)
 * [OAuth2](https://jam.makridenko.ru/usage/oauth2/)
+* [SAML](https://jam.makridenko.ru/usage/saml/)
 
 ### Framework integrations
 
@@ -115,5 +118,6 @@ Here is a comparison with other libraries:
 | Server side sessions  | ✅     | ✅                               | ❌                                    | ❌                                  | ❌                                   |
 | OTP                   | ✅     | ❌                               | ❌                                    | ❌                                  | ✅                                   |
 | OAuth2                | ✅     | ✅                               | ❌                                    | ✅                                  | ❌                                   |
+| SAML 2.0              | ✅     | ❌                               | ❌                                    | ❌                                  | ❌                                   |
 | Flexible config       | ✅     | ❌                               | ❌                                    | ❌                                  | ❌                                   |
 | Modularity            | ✅     | ❌                               | ❌                                    | ❌                                  | ❌                                   |

{jamlib-3.2.0rc0 → jamlib-3.3.0}/README.md

@@ -9,6 +9,8 @@
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/lyaguxafrog/jam)
 [![GitHub License](https://img.shields.io/github/license/lyaguxafrog/jam)](https://github.com/lyaguxafrog/jam/blob/master/LICENSE.md)
 
+**Jam (Jam Auth Module)** - A universal auth* combine that provides popular auth mechanisms strictly according to the specification.
+
 * Documentation: [jam.makridenko.ru](https://jam.makridenko.ru)
 * Changelog: [CHANGELOG.md](https://github.com/lyaguxafrog/jam/blob/master/CHANGELOG.md)
 
@@ -24,7 +26,7 @@ from jam import Jam
 
 jam = Jam(config="config.toml")
 
-jwt = jam.jwt_create({"user": 1})
+jwt = jam.jwt_encode(payload={"user": 1})
 session_id = jam.session_create(session_key="username", data={"user": 1})
 otp_code = jam.otp_code(secret="3DB7FOAOFBCI3WFDRE7EPF43CA")
 ```
@@ -32,11 +34,12 @@ otp_code = jam.otp_code(secret="3DB7FOAOFBCI3WFDRE7EPF43CA")
 ## Why Jam?
 Jam is a library that provides the most popular AUTH* mechanisms right out of the box.
 
-* [JOSE](https://jam.makridenko.ru/usage/jose/index/)
+* [JOSE](https://jam.makridenko.ru/usage/jose/)
 * [PASETO](https://jam.makridenko.ru/usage/paseto/)
 * [Server side sessions](https://jam.makridenko.ru/usage/sessions/)
 * [OTP](https://jam.makridenko.ru/usage/otp/)
 * [OAuth2](https://jam.makridenko.ru/usage/oauth2/)
+* [SAML](https://jam.makridenko.ru/usage/saml/)
 
 ### Framework integrations
 
@@ -62,5 +65,6 @@ Here is a comparison with other libraries:
 | Server side sessions  | ✅     | ✅                               | ❌                                    | ❌                                  | ❌                                   |
 | OTP                   | ✅     | ❌                               | ❌                                    | ❌                                  | ✅                                   |
 | OAuth2                | ✅     | ✅                               | ❌                                    | ✅                                  | ❌                                   |
+| SAML 2.0              | ✅     | ❌                               | ❌                                    | ❌                                  | ❌                                   |
 | Flexible config       | ✅     | ❌                               | ❌                                    | ❌                                  | ❌                                   |
 | Modularity            | ✅     | ❌                               | ❌                                    | ❌                                  | ❌                                   |

{jamlib-3.2.0rc0 → jamlib-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jamlib"
-version = "3.2.0rc0"
+version = "3.3.0"
 description = "Simple and universal library for authorization."
 authors = [
     {name = "Makridenko Adrian",email = "adrianmakridenko@duck.com"},

jamlib-3.3.0/src/jam/__defaults__.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+import os
+
+
+@dataclass(slots=True, frozen=True)
+class DEFAULTS:
+    """Jam defaults vars."""
+
+    DEBUG: bool = os.getenv("JAM_DEBUG", "False") == "True"
+    """Debug flag. Use only while developing jam module."""
+
+    TEMP_DIR: str = os.getenv("JAM_TMP_DIR", "/tmp/jam/")
+    """tmp directory for storing temporary files and blobs."""
+
+    ENABLE_PLUGINS: bool = os.getenv("JAM_ENABLE_PLUGINS", "1") == "0"
+    """Enabling experimental plugin features."""
+
+
+defaults = DEFAULTS()

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/__init__.py

@@ -10,5 +10,5 @@ from jam.__base__ import BaseJam
 from jam.instance import Jam
 
 
-__version__ = "3.2.0rc0"
+__version__ = "3.3.0"
 __all__ = ["Jam", "BaseJam"]

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/aio/__base__.py

@@ -4,6 +4,7 @@ from abc import abstractmethod
 from typing import Any
 
 from jam.__base__ import BaseJam
+from jam.__deprecated__ import deprecated
 from jam.aio.oauth2.__base__ import BaseAsyncOAuth2Client
 from jam.aio.sessions.__base__ import BaseAsyncSessionModule
 from jam.jose.__base__ import BaseJWE, BaseJWS
@@ -21,11 +22,17 @@ class BaseAsyncJam(BaseJam):
     jwe: BaseJWE | None = None  # type: ignore[override]
 
     @abstractmethod
+    @deprecated(
+        "This method is deprecated; the JWT payload is generated automatically in accordance with the specification."
+    )
     async def jwt_make_payload(  # type: ignore[override]
         self, exp: int | None, data: dict[str, Any]
     ) -> dict[str, Any]:
         """Make JWT-specific payload.
 
+        !!! Deprecated
+                This method is deprecated; the JWT payload is generated automatically in accordance with the specification.
+
         Args:
             exp (int | None): Token expire, if None -> use default
             data (dict[str, Any]): Data to payload
@@ -36,6 +43,7 @@ class BaseAsyncJam(BaseJam):
         raise NotImplementedError
 
     @abstractmethod
+    @deprecated("Use jam.jwt_encode")
     async def jwt_create(  # type: ignore[override]
         self, payload: dict[str, Any]
     ) -> str:

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/aio/instance.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 
-import datetime
 import time
 from typing import Any
 import uuid
 
+from jam.__deprecated__ import deprecated
 from jam.aio.__base__ import BaseAsyncJam
 from jam.exceptions import (
     JamConfigurationError,
@@ -30,11 +30,17 @@ class Jam(BaseAsyncJam):
         "otp": "jam.otp.__base__.OTPConfig",
     }
 
+    @deprecated(
+        "This method is deprecated; the JWT payload is generated automatically in accordance with the specification."
+    )
     async def jwt_make_payload(
         self, exp: int | None, data: dict[str, Any]
     ) -> dict[str, Any]:
         """Make JWT-specific payload.
 
+        !!! Deprecated
+                This method is deprecated; the JWT payload is generated automatically in accordance with the specification.
+
         Args:
             exp (int | None): Token expire
             data (dict[str, Any]): Data to payload
@@ -42,17 +48,22 @@ class Jam(BaseAsyncJam):
         Returns:
             dict[str, Any]: Payload
         """
+        now = time.time()
         payload = {
-            "iat": datetime.datetime.now().timestamp(),
-            "exp": (datetime.datetime.now().timestamp() + exp) if exp else None,
+            "iat": now,
+            "exp": (now + exp) if exp else None,
             "jti": str(uuid.uuid4()),
         }
         payload = payload | data
         return payload
 
+    @deprecated("Use jam.jwt_encode")
     async def jwt_create(self, payload: dict[str, Any]) -> str:
         """Create JWT token.
 
+        !!! Deprecated
+                Use Jam.jwt_encode
+
         Args:
             payload (dict[str, Any]): Data payload
 
@@ -244,7 +255,10 @@ class Jam(BaseAsyncJam):
         """
         assert self.jwe is not None
         self._logger.debug(f"Encrypting data with JWE, header: {header}")
-        token = self.jwe.encrypt(data, header)
+        token = self.jwe.encrypt(
+            self._serializer.dumps(data) if isinstance(data, dict) else data,
+            header,
+        )
         self._logger.debug(f"JWE token created, length: {len(token)}")
         return token
 
@@ -369,8 +383,8 @@ class Jam(BaseAsyncJam):
     async def otp_uri(
         self,
         secret: str,
-        name: str | None = None,
-        issuer: str | None = None,
+        name: str,
+        issuer: str,
         counter: int | None = None,
     ) -> str:
         """Generates an otpauth:// URI for Google Authenticator.
@@ -388,9 +402,7 @@ class Jam(BaseAsyncJam):
         assert self._otp is not None
         return self._otp(
             secret=secret, digits=self.otp.digits, digest=self.otp.digest
-        ).provisioning_uri(
-            name=name or "", issuer=issuer or "", counter=counter
-        )
+        ).provisioning_uri(name=name, issuer=issuer, counter=counter)
 
     async def otp_verify_code(
         self,

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/aio/sessions/__base__.py

@@ -7,9 +7,11 @@ from uuid import uuid4
 
 from cryptography.fernet import Fernet
 
-from jam.encoders import BaseEncoder, JsonEncoder
+from jam.__base_encoder__ import BaseEncoder
+from jam.encoders import JsonEncoder
 from jam.exceptions import JamSessionEmptyAESKey
 from jam.logger import BaseLogger
+from jam.utils.config_maker import __key_loader__
 
 
 class BaseAsyncSessionModule(ABC):
@@ -32,6 +34,8 @@ class BaseAsyncSessionModule(ABC):
             raise JamSessionEmptyAESKey
         if is_session_crypt:
             assert session_aes_secret is not None
+            if isinstance(session_aes_secret, str):
+                session_aes_secret = __key_loader__(session_aes_secret)
             self._code_session_key = Fernet(session_aes_secret)
 
     def __encode_session_id__(self, data: str) -> str:

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/exceptions/__init__.py

@@ -45,6 +45,17 @@ from .sessions import (
     JamSessionEmptyAESKey,
     JamSessionNotFound,
 )
+from .saml import (
+    JamSAMLError,
+    JamSAMLExpired,
+    JamSAMLNotYetValid,
+    JamSAMLInvalidAudience,
+    JamSAMLInvalidIssuer,
+    JamSAMLEmptyPrivateKey,
+    JamSAMLEmptyPublicKey,
+    JamSAMLUnsupportedAlgorithm,
+    JamSAMLValidationError,
+)
 
 
 __all__ = [
@@ -81,4 +92,13 @@ __all__ = [
     "JamStarlettePluginError",
     "JamSessionNotFound",
     "JamSessionEmptyAESKey",
+    "JamSAMLError",
+    "JamSAMLExpired",
+    "JamSAMLNotYetValid",
+    "JamSAMLInvalidAudience",
+    "JamSAMLInvalidIssuer",
+    "JamSAMLEmptyPrivateKey",
+    "JamSAMLEmptyPublicKey",
+    "JamSAMLUnsupportedAlgorithm",
+    "JamSAMLValidationError",
 ]

jamlib-3.3.0/src/jam/exceptions/saml.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+from .base import JamConfigurationError, JamError, JamValidationError
+
+
+class JamSAMLError(JamError):
+    default_message = "SAML error occurred."
+    default_code = "saml.error"
+
+
+class JamSAMLExpired(JamError):
+    default_message = "SAML assertion has expired."
+    default_code = "saml.assertion_expired"
+
+
+class JamSAMLNotYetValid(JamError):
+    default_message = "SAML assertion is not yet valid."
+    default_code = "saml.assertion_not_yet_valid"
+
+
+class JamSAMLInvalidAudience(JamError):
+    default_message = "SAML assertion audience validation failed."
+    default_code = "saml.invalid_audience"
+
+
+class JamSAMLInvalidIssuer(JamError):
+    default_message = "SAML assertion issuer validation failed."
+    default_code = "saml.invalid_issuer"
+
+
+class JamSAMLEmptyPrivateKey(JamConfigurationError):
+    default_message = "For SAML signing, you must specify `private_key`."
+    default_code = "saml.config.empty_private_key"
+
+
+class JamSAMLEmptyPublicKey(JamConfigurationError):
+    default_message = "For SAML verification, you must specify `public_key`."
+    default_code = "saml.config.empty_public_key"
+
+
+class JamSAMLUnsupportedAlgorithm(JamConfigurationError):
+    default_message = "Unsupported SAML algorithm."
+    default_code = "saml.config.unsupported_algorithm"
+
+
+class JamSAMLValidationError(JamValidationError):
+    default_message = "SAML assertion validation failed."
+    default_code = "saml.validation.assertion_error"
+
+
+class JamSAMLInvalidRecipient(JamError):
+    default_message = (
+        "SAML assertion SubjectConfirmationData Recipient "
+        "does not match the expected ACS URL."
+    )
+    default_code = "saml.invalid_recipient"
+
+
+class JamSAMLReplayDetected(JamError):
+    default_message = "SAML message ID has already been consumed (replay attack)."
+    default_code = "saml.replay_detected"
+
+
+class JamSAMLSOAPError(JamError):
+    default_message = "SAML SOAP/artifact resolution failed."
+    default_code = "saml.soap_error"

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/ext/flask/extensions.py

@@ -89,6 +89,8 @@ class BaseAuthExtension(BaseExtension):
         _config: dict[str, Any] | None = (
             __config_maker__(config, pointer) if config else None
         )
+        if _config and _config.get("jose", None) and self.MODULE == create_jwt:
+            _config = _config["jose"]
 
         params = _config.pop(self._CONFIG_KEY) if _config else kwargs
         super().__init__(app=app, **params)

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/ext/litestar/middleware.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from collections.abc import Callable
+from typing import Any
 
 from litestar.connection import ASGIConnection
 from litestar.middleware import (
@@ -18,7 +18,7 @@ from jam.paseto import BasePASETO
 class BaseMiddleware(AbstractAuthenticationMiddleware):
     """Base Jam middleware for litestar."""
 
-    AUTH_MODULE: Callable
+    AUTH_MODULE: Any
     HEADER_NAME: str | None
     COOKIE_NAME: str | None
     BEARER: bool = False
@@ -95,7 +95,7 @@ class SessionMiddleware(BaseMiddleware):
             if not data:
                 return AuthenticationResult(None, auth=token_model)
             user = self.USER.from_payload(data)
-            return AuthenticationResult(user, token)
+            return AuthenticationResult(user=user, auth=token_model)
         except Exception as e:
             raise JamLitestarPluginError(message=str(e))
 
@@ -113,10 +113,10 @@ class PASETOMiddleware(BaseMiddleware):
         if not token:
             return AuthenticationResult(None, auth=token_model)
         try:
-            data = self.AUTH_MODULE.decode(token)
-            if not data:
+            result = self.AUTH_MODULE.decode(token)
+            if not result:
                 return AuthenticationResult(None, auth=token_model)
-            user = self.USER.from_payload(data)
-            return AuthenticationResult(user, token)
+            user = self.USER.from_payload(result[0])
+            return AuthenticationResult(user=user, auth=token_model)
         except Exception as e:
             raise JamLitestarPluginError(message=str(e))

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/ext/litestar/objects.py

@@ -4,10 +4,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, TypeVar
-
-
-User = TypeVar("User", bound="BaseUser")
+from typing import Any
 
 
 @dataclass(slots=True)
@@ -23,7 +20,7 @@ class BaseUser(ABC):
 
     @classmethod
     @abstractmethod
-    def from_payload(cls, payload: dict[str, Any]) -> User:
+    def from_payload(cls, payload: dict[str, Any]) -> BaseUser:
         """Build model from payload.
 
         Args:

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/ext/litestar/plugins.py

@@ -76,6 +76,9 @@ class BasePlugin(InitPlugin):
             __config_maker__(config, pointer) if config else None
         )
 
+        # FIXME: Make config wrapper
+        if _config and _config.get("jose", None) and self.MODULE == create_jwt:
+            _config = _config["jose"]
         params = _config.pop(self._CONFIG_KEY) if _config else kwargs
         self._setup_config(params)
         self._middleware = None

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/ext/starlette/backends.py

@@ -81,6 +81,8 @@ class BaseBackend(AuthenticationBackend):
         try:
             if config:
                 config_ = __config_maker__(config, pointer)[self._CONFIG_KEY]
+                if config_.get("jose", None) and self.MODULE == create_jwt:
+                    config_ = config_["jose"]
                 self._auth = self.MODULE(**config_)
             else:
                 self._auth = self.MODULE(**kwargs)

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/ext/starlette/objects.py

@@ -1,21 +1,20 @@
 # -*- coding: utf-8 -*-
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, TypeVar
+from typing import Any
 
 from starlette.authentication import BaseUser as StarletteBaseUser
 
 
-User = TypeVar("User", bound="BaseUser")
-
-
 class BaseUser(ABC, StarletteBaseUser):
     """BaseUser with builder from payload."""
 
     @classmethod
     @abstractmethod
-    def from_payload(cls, payload: dict[str, Any]) -> User:
+    def from_payload(cls, payload: dict[str, Any]) -> BaseUser:
         """Create instance by payload.
 
         Args:
@@ -49,7 +48,7 @@ class SimpleUser(BaseUser):
     payload: dict[str, Any]
 
     @classmethod
-    def from_payload(cls, payload: dict[str, Any]):  # noqa
+    def from_payload(cls, payload: dict[str, Any]) -> SimpleUser:  # noqa
         return cls(payload=payload)
 
     def is_authenticated(self) -> bool:  # type: ignore # noqa

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/jose/__algorithms__.py

@@ -112,6 +112,8 @@ class BaseAlgorithm(ABC):
             except OSError:
                 is_file = False
             return path.read_bytes() if is_file else data.encode()
+        if isinstance(data, rsa.RSAPrivateKey | ec.EllipticCurvePrivateKey):
+            data = data.public_key()
         return data.public_bytes(
             encoding=serialization.Encoding.PEM,
             format=serialization.PublicFormat.SubjectPublicKeyInfo,
@@ -602,6 +604,11 @@ class BaseKeyAlgorithm(ABC):
         if hasattr(self._key, "private_key"):
             return self._key.private_key()
 
+        if isinstance(
+            self._key, rsa.RSAPrivateKey | ec.EllipticCurvePrivateKey
+        ):
+            return self._key
+
         key_bytes = self._load_key_data(self._key)
         return serialization.load_pem_private_key(
             key_bytes, password=self._password
@@ -620,6 +627,8 @@ class BaseKeyAlgorithm(ABC):
             except OSError:
                 is_file = False
             return path.read_bytes() if is_file else data.encode()
+        if isinstance(data, rsa.RSAPrivateKey | ec.EllipticCurvePrivateKey):
+            data = data.public_key()
         return data.public_bytes(
             encoding=serialization.Encoding.PEM,
             format=serialization.PublicFormat.SubjectPublicKeyInfo,

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/jose/__base__.py

@@ -73,34 +73,39 @@ class BaseJWT(ABC):
     @abstractmethod
     def encrypt(
         self,
-        payload: dict[str, Any] | str,
+        plaintext: bytes | str | dict[str, Any],
         header: dict[str, Any] | None = None,
     ) -> str:
-        """Encrypt payload using JWE.
+        """Encrypt plaintext.
 
-        Creates JWE or JWS+JWE token (sign then encrypt).
+        Produces JWE Compact Serialization:
+        BASE64URL(header).BASE64URL(encrypted_key).BASE64URL(iv).BASE64URL(ciphertext).BASE64URL(tag)
 
         Args:
-            payload: Data to encrypt. If dict, will be JSON encoded.
-            header: Additional JWE header.
+            plaintext: Data to encrypt. If str, will be encoded to UTF-8.
+                If dict, will be JSON encoded.
+            header: JWE header (must include 'alg' and 'enc').
 
         Returns:
-            str: Encrypted JWT (JWE or JWS+JWE).
+            JWE compact serialization string.
+
+        Raises:
+            JamJWEEncryptionError: If encryption fails.
         """
         raise NotImplementedError
 
     @abstractmethod
-    def decrypt(self, token: str) -> dict[str, Any]:
-        """Decrypt JWE or JWS+JWE token.
+    def decrypt(self, token: str) -> dict[str, Any] | bytes:
+        """Decrypt JWE token.
 
         Args:
-            token: Encrypted JWT token.
+            token: JWE compact serialization string.
 
         Returns:
-            dict[str, Any]: Decrypted payload.
+            bytes: Decrypted plaintext.
 
         Raises:
-            ValueError: If token is invalid or decryption fails.
+            JamJWEDecryptionError: If decryption fails.
         """
         raise NotImplementedError
 

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/jose/jwe.py

@@ -66,6 +66,8 @@ class JWE(BaseJWE):
 
         self._alg = alg.upper()
         self._enc = enc.upper()
+        if isinstance(key, JWKClass):
+            key = key._to_keylike()
         self._key = key
         self._password = password
         self._serializer = serializer

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/jose/jwk.py

@@ -56,9 +56,6 @@ class JWKRSA(JWKCommon, total=False):
         ... }
     """
 
-    kty: Literal["RSA"]
-    """Key Type. Fixed to "RSA"."""
-
     n: str
     """RSA modulus n. The modulus value for the RSA public key."""
 
@@ -98,9 +95,6 @@ class JWKEC(JWKCommon, total=False):
         ... }
     """
 
-    kty: Literal["EC"]
-    """Key Type. Fixed to "EC"."""
-
     crv: Literal["P-256", "P-384", "P-521"]
     """Elliptic curve name. The curve on which the key is based."""
 
@@ -126,9 +120,6 @@ class JWKOct(JWKCommon, total=False):
         ... }
     """
 
-    kty: Literal["oct"]
-    """Key Type. Fixed to "oct"."""
-
     k: str
     """Key value. The base64url-encoded symmetric key value."""
 

{jamlib-3.2.0rc0 → jamlib-3.3.0}/src/jam/jose/jws.py

@@ -15,6 +15,7 @@ from jam.jose.__algorithms__ import (
 from jam.jose.__base__ import BaseJWS
 from jam.jose.utils import __base64url_decode__, __base64url_encode__
 from jam.logger import BaseLogger, logger
+from jam.utils.config_maker import __key_loader__
 
 
 if TYPE_CHECKING:
@@ -46,6 +47,9 @@ class JWS(BaseJWS):
         self._alg = alg.upper()
         self._validate_algorithm(self._alg)
 
+        if isinstance(key, str):
+            key = __key_loader__(key)
+
         if isinstance(key, JWKClass):
             key = key._to_keylike()
 
@@ -80,7 +84,7 @@ class JWS(BaseJWS):
     def serialize_compact(
         self,
         protected: dict[str, Any],
-        payload: bytes | str,
+        payload: bytes | str | dict[str, Any],
     ) -> str:
         """Create JWS Compact Serialization.