The requested URL was not found on this server.
Additionally, a 404 Not Found error was encountered while trying to use an ErrorDocument to handle the request.
1 " li~e Jva&Tţ pN " lY> Tm q@q.4Ҙo h H403 318 u """JSON Web Algorithms. https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40 """ import abc import logging import cryptography.exceptions from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives import hashes # type: ignore from cryptography.hazmat.primitives import hmac # type: ignore from cryptography.hazmat.primitives.asymmetric import padding # type: ignore from josepy import errors, interfaces, jwk try: from collections.abc import Hashable # pylint: disable=import-error except ImportError: from collections import Hashable logger = logging.getLogger(__name__) class JWA(interfaces.JSONDeSerializable): # pylint: disable=abstract-method # pylint: disable=too-few-public-methods # for some reason disable=abstract-method has to be on the line # above... """JSON Web Algorithm.""" class JWASignature(JWA, Hashable): # type: ignore """Base class for JSON Web Signature Algorithms.""" SIGNATURES = {} # type: dict def __init__(self, name): self.name = name def __eq__(self, other): if not isinstance(other, JWASignature): return NotImplemented return self.name == other.name def __hash__(self): return hash((self.__class__, self.name)) def __ne__(self, other): return not self == other @classmethod def register(cls, signature_cls): """Register class for JSON deserialization.""" cls.SIGNATURES[signature_cls.name] = signature_cls return signature_cls def to_partial_json(self): return self.name @classmethod def from_json(cls, jobj): return cls.SIGNATURES[jobj] @abc.abstractmethod def sign(self, key, msg): # pragma: no cover """Sign the ``msg`` using ``key``.""" raise NotImplementedError() @abc.abstractmethod def verify(self, key, msg, sig): # pragma: no cover """Verify the ``msg`` and ``sig`` using ``key``.""" raise NotImplementedError() def __repr__(self): return self.name class _JWAHS(JWASignature): kty = jwk.JWKOct def __init__(self, name, hash_): super(_JWAHS, self).__init__(name) self.hash = hash_() def sign(self, key, msg): signer = hmac.HMAC(key, self.hash, backend=default_backend()) signer.update(msg) return signer.finalize() def verify(self, key, msg, sig): verifier = hmac.HMAC(key, self.hash, backend=default_backend()) verifier.update(msg) try: verifier.verify(sig) except cryptography.exceptions.InvalidSignature as error: logger.debug(error, exc_info=True) return False else: return True class _JWARSA(object): kty = jwk.JWKRSA padding = NotImplemented hash = NotImplemented def sign(self, key, msg): """Sign the ``msg`` using ``key``.""" # If cryptography library supports new style api (v1.4 and later) new_api = hasattr(key, "sign") try: if new_api: return key.sign(msg, self.padding, self.hash) signer = key.signer(self.padding, self.hash) except AttributeError as error: logger.debug(error, exc_info=True) raise errors.Error("Public key cannot be used for signing") except ValueError as error: # digest too large logger.debug(error, exc_info=True) raise errors.Error(str(error)) signer.update(msg) try: return signer.finalize() except ValueError as error: