signxml-references-modified 1.0.0__py3-none-any.whl

signxml/__init__.py

@@ -0,0 +1,13 @@
+"""
+Use :class:`signxml.XMLSigner` and :class:`signxml.XMLVerifier` to sign and verify XML Signatures, respectively.
+See `SignXML documentation <#synopsis>`_ for examples.
+"""
+
+from .signer import XMLSigner, SignatureReference
+from .verifier import XMLVerifier, VerifyResult, SignatureConfiguration
+from .algorithms import DigestAlgorithm, SignatureMethod, CanonicalizationMethod, SignatureConstructionMethod
+from .exceptions import InvalidCertificate, InvalidDigest, InvalidInput, InvalidSignature
+from .processor import XMLSignatureProcessor
+from .util import namespaces
+
+methods = SignatureConstructionMethod

signxml/__pyinstaller/__init__.py

@@ -0,0 +1,10 @@
+"""
+This file indicates that this directory contains the hooks to include the schema files on the final version
+if it's compiled with pyinstaller.
+"""
+
+import os
+
+
+def get_hook_dirs():
+    return [os.path.dirname(__file__)]

signxml/__pyinstaller/hook-signxml.py

@@ -0,0 +1,5 @@
+"""Hook for pyinstaller to include the files are signxml/schemas/* into the final build."""
+
+from PyInstaller.utils.hooks import collect_data_files  # type: ignore
+
+datas = collect_data_files("signxml", excludes=["__pyinstaller"])

signxml/algorithms.py

@@ -0,0 +1,201 @@
+from enum import Enum
+from typing import Callable, Dict, Type, Union
+
+from cryptography.hazmat.primitives import hashes
+
+from .exceptions import InvalidInput
+
+
+class SignatureConstructionMethod(Enum):
+    """
+    An enumeration of signature construction methods supported by SignXML, used to specify the method when signing.
+    See the list of signature types under `XML Signature Syntax and Processing Version 2.0, Definitions
+    <http://www.w3.org/TR/xmldsig-core2/#sec-Definitions>`_.
+    """
+
+    enveloped = "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
+    """
+    The signature is over the XML content that contains the signature as an element. The content provides the root
+    XML document element. This is the most common XML signature type in modern applications.
+    """
+
+    enveloping = "enveloping-signature"
+    """
+    The signature is over content found within an Object element of the signature itself. The Object (or its
+    content) is identified via a Reference (via a URI fragment identifier or transform).
+    """
+
+    detached = "detached-signature"
+    """
+    The signature is over content external to the Signature element, and can be identified via a URI or
+    transform. Consequently, the signature is "detached" from the content it signs. This definition typically applies to
+    separate data objects, but it also includes the instance where the Signature and data object reside within the same
+    XML document but are sibling elements.
+    """
+
+
+class FragmentLookupMixin:
+    @classmethod
+    def from_fragment(cls, fragment):
+        for i in cls:  # type: ignore[attr-defined]
+            if i.value.endswith("#" + fragment):
+                return i
+        else:
+            raise InvalidInput(f"Unrecognized {cls.__name__} identifier fragment: {fragment}")
+
+
+class InvalidInputErrorMixin:
+    @classmethod
+    def _missing_(cls, value):
+        raise InvalidInput(f"Unrecognized {cls.__name__}: {value}")
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}.{self.name}"  # type: ignore[attr-defined]
+
+
+class DigestAlgorithm(FragmentLookupMixin, InvalidInputErrorMixin, Enum):
+    """
+    An enumeration of digest algorithms supported by SignXML.  See the
+    `Algorithm Identifiers and Implementation Requirements <http://www.w3.org/TR/xmldsig-core1/#sec-AlgID>`_ section of
+    the XML Signature 1.1 standard for details.
+    """
+
+    SHA224 = "http://www.w3.org/2001/04/xmldsig-more#sha224"
+    SHA384 = "http://www.w3.org/2001/04/xmldsig-more#sha384"
+    SHA256 = "http://www.w3.org/2001/04/xmlenc#sha256"
+    SHA512 = "http://www.w3.org/2001/04/xmlenc#sha512"
+    SHA3_224 = "http://www.w3.org/2007/05/xmldsig-more#sha3-224"
+    SHA3_256 = "http://www.w3.org/2007/05/xmldsig-more#sha3-256"
+    SHA3_384 = "http://www.w3.org/2007/05/xmldsig-more#sha3-384"
+    SHA3_512 = "http://www.w3.org/2007/05/xmldsig-more#sha3-512"
+
+    SHA1 = "http://www.w3.org/2000/09/xmldsig#sha1"
+    "See `SHA1 deprecation`_."
+
+    @property
+    def implementation(self) -> Callable:
+        """
+        The cryptography callable that implements the specified algorithm.
+        """
+        return digest_algorithm_implementations[self]
+
+
+# TODO: check if padding errors are fixed by using padding=MGF1
+class SignatureMethod(FragmentLookupMixin, InvalidInputErrorMixin, Enum):
+    """
+    An enumeration of signature methods (also referred to as signature algorithms) supported by SignXML. See the
+    `Algorithm Identifiers and Implementation Requirements <http://www.w3.org/TR/xmldsig-core1/#sec-AlgID>`_ section of
+    the XML Signature 1.1 standard for details.
+    """
+
+    RSA_SHA256 = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"
+    """
+    The RSASSA-PKCS1-v1_5 algorithm described in RFC 3447. This is the default, most widely supported signature method.
+    """
+
+    RSA_SHA224 = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha224"
+    RSA_SHA384 = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384"
+    RSA_SHA512 = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512"
+    ECDSA_SHA224 = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha224"
+    ECDSA_SHA256 = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256"
+    ECDSA_SHA384 = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384"
+    ECDSA_SHA512 = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512"
+    ECDSA_SHA3_224 = "http://www.w3.org/2021/04/xmldsig-more#ecdsa-sha3-224"
+    ECDSA_SHA3_256 = "http://www.w3.org/2021/04/xmldsig-more#ecdsa-sha3-256"
+    ECDSA_SHA3_384 = "http://www.w3.org/2021/04/xmldsig-more#ecdsa-sha3-384"
+    ECDSA_SHA3_512 = "http://www.w3.org/2021/04/xmldsig-more#ecdsa-sha3-512"
+    DSA_SHA256 = "http://www.w3.org/2009/xmldsig11#dsa-sha256"
+    HMAC_SHA224 = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha224"
+    HMAC_SHA256 = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha256"
+    HMAC_SHA384 = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha384"
+    HMAC_SHA512 = "http://www.w3.org/2001/04/xmldsig-more#hmac-sha512"
+    SHA3_224_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha3-224-rsa-MGF1"
+    SHA3_256_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha3-256-rsa-MGF1"
+    SHA3_384_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha3-384-rsa-MGF1"
+    SHA3_512_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha3-512-rsa-MGF1"
+    SHA224_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha224-rsa-MGF1"
+    SHA256_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha256-rsa-MGF1"
+    SHA384_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha384-rsa-MGF1"
+    SHA512_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha512-rsa-MGF1"
+
+    DSA_SHA1 = "http://www.w3.org/2000/09/xmldsig#dsa-sha1"
+    """
+    _`SHA1 deprecation`: SHA1 based algorithms are not secure for use in digital signatures. They are included for
+    legacy compatibility only and disabled by default. To verify SHA1 based signatures, use::
+
+        XMLVerifier().verify(
+            expect_config=SignatureConfiguration(
+                signature_methods=...,
+                digest_algorithms=...
+            )
+        )
+    """
+    HMAC_SHA1 = "http://www.w3.org/2000/09/xmldsig#hmac-sha1"
+    "See `SHA1 deprecation`_."
+    RSA_SHA1 = "http://www.w3.org/2000/09/xmldsig#rsa-sha1"
+    "See `SHA1 deprecation`_."
+    ECDSA_SHA1 = "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1"
+    "See `SHA1 deprecation`_."
+    SHA1_RSA_MGF1 = "http://www.w3.org/2007/05/xmldsig-more#sha1-rsa-MGF1"
+    "See `SHA1 deprecation`_."
+
+
+class CanonicalizationMethod(InvalidInputErrorMixin, Enum):
+    """
+    An enumeration of XML canonicalization methods (also referred to as canonicalization algorithms) supported by
+    SignXML. See the `Algorithm Identifiers and Implementation Requirements
+    <http://www.w3.org/TR/xmldsig-core1/#sec-AlgID>`_ section of the XML Signature 1.1 standard for details.
+    """
+
+    CANONICAL_XML_1_0 = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315"
+    CANONICAL_XML_1_0_WITH_COMMENTS = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments"
+    CANONICAL_XML_1_1 = "http://www.w3.org/2006/12/xml-c14n11"
+    CANONICAL_XML_1_1_WITH_COMMENTS = "http://www.w3.org/2006/12/xml-c14n11#WithComments"
+    EXCLUSIVE_XML_CANONICALIZATION_1_0 = "http://www.w3.org/2001/10/xml-exc-c14n#"
+    EXCLUSIVE_XML_CANONICALIZATION_1_0_WITH_COMMENTS = "http://www.w3.org/2001/10/xml-exc-c14n#WithComments"
+
+    # The identifier for Canonical XML 2.0 is "http://www.w3.org/2010/xml-c14n2", but it is not a W3C standard.
+    # While it is supported by lxml, it's not in general use and not supported by SignXML
+
+
+digest_algorithm_implementations: Dict[Union[DigestAlgorithm, SignatureMethod], Type[hashes.HashAlgorithm]] = {
+    DigestAlgorithm.SHA1: hashes.SHA1,
+    DigestAlgorithm.SHA224: hashes.SHA224,
+    DigestAlgorithm.SHA384: hashes.SHA384,
+    DigestAlgorithm.SHA256: hashes.SHA256,
+    DigestAlgorithm.SHA512: hashes.SHA512,
+    DigestAlgorithm.SHA3_224: hashes.SHA3_224,
+    DigestAlgorithm.SHA3_256: hashes.SHA3_256,
+    DigestAlgorithm.SHA3_384: hashes.SHA3_384,
+    DigestAlgorithm.SHA3_512: hashes.SHA3_512,
+    SignatureMethod.DSA_SHA1: hashes.SHA1,
+    SignatureMethod.HMAC_SHA1: hashes.SHA1,
+    SignatureMethod.RSA_SHA1: hashes.SHA1,
+    SignatureMethod.ECDSA_SHA1: hashes.SHA1,
+    SignatureMethod.ECDSA_SHA224: hashes.SHA224,
+    SignatureMethod.ECDSA_SHA256: hashes.SHA256,
+    SignatureMethod.ECDSA_SHA384: hashes.SHA384,
+    SignatureMethod.ECDSA_SHA512: hashes.SHA512,
+    SignatureMethod.HMAC_SHA224: hashes.SHA224,
+    SignatureMethod.HMAC_SHA256: hashes.SHA256,
+    SignatureMethod.HMAC_SHA384: hashes.SHA384,
+    SignatureMethod.HMAC_SHA512: hashes.SHA512,
+    SignatureMethod.RSA_SHA224: hashes.SHA224,
+    SignatureMethod.RSA_SHA256: hashes.SHA256,
+    SignatureMethod.RSA_SHA384: hashes.SHA384,
+    SignatureMethod.RSA_SHA512: hashes.SHA512,
+    SignatureMethod.DSA_SHA256: hashes.SHA256,
+    SignatureMethod.ECDSA_SHA3_224: hashes.SHA3_224,
+    SignatureMethod.ECDSA_SHA3_256: hashes.SHA3_256,
+    SignatureMethod.ECDSA_SHA3_384: hashes.SHA3_384,
+    SignatureMethod.ECDSA_SHA3_512: hashes.SHA3_512,
+    SignatureMethod.SHA3_224_RSA_MGF1: hashes.SHA3_224,
+    SignatureMethod.SHA3_256_RSA_MGF1: hashes.SHA3_256,
+    SignatureMethod.SHA3_384_RSA_MGF1: hashes.SHA3_384,
+    SignatureMethod.SHA3_512_RSA_MGF1: hashes.SHA3_512,
+    SignatureMethod.SHA224_RSA_MGF1: hashes.SHA224,
+    SignatureMethod.SHA256_RSA_MGF1: hashes.SHA256,
+    SignatureMethod.SHA384_RSA_MGF1: hashes.SHA384,
+    SignatureMethod.SHA512_RSA_MGF1: hashes.SHA512,
+    SignatureMethod.SHA1_RSA_MGF1: hashes.SHA1,
+}

signxml/exceptions.py

@@ -0,0 +1,35 @@
+"""
+SignXML exception types.
+"""
+
+import cryptography.exceptions
+
+
+class SignXMLException(Exception):
+    pass
+
+
+class InvalidSignature(cryptography.exceptions.InvalidSignature, SignXMLException):
+    """
+    Raised when signature validation fails.
+    """
+
+
+class InvalidDigest(InvalidSignature):
+    """
+    Raised when digest validation fails (causing the signature to be untrusted).
+    """
+
+
+class InvalidCertificate(InvalidSignature):
+    """
+    Raised when certificate validation fails.
+    """
+
+
+class InvalidInput(ValueError, SignXMLException):
+    pass
+
+
+class RedundantCert(SignXMLException):
+    pass

signxml/processor.py

@@ -0,0 +1,160 @@
+import logging
+import os
+from typing import Any, List, Tuple
+from xml.etree import ElementTree as stdlibElementTree
+
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.hashes import Hash
+from lxml import etree
+
+from .algorithms import CanonicalizationMethod, DigestAlgorithm, digest_algorithm_implementations
+from .exceptions import InvalidInput
+from .util import namespaces
+
+logger = logging.getLogger(__name__)
+
+
+class XMLProcessor:
+    _schemas: List[Any] = []
+    schema_files: List[Any] = []
+    _default_parser, _parser = None, None
+    _schema_dir = os.path.normpath(os.path.join(os.path.dirname(__file__), "schemas"))
+
+    @classmethod
+    def schemas(cls):
+        if len(cls._schemas) == 0:
+            for schema_file in cls.schema_files:
+                schema_path = os.path.join(cls._schema_dir, schema_file)
+                cls._schemas.append(etree.XMLSchema(etree.parse(schema_path)))
+        return cls._schemas
+
+    @property
+    def parser(self):
+        if self._parser is None:
+            if self._default_parser is None:
+                self._default_parser = etree.XMLParser(resolve_entities=False)
+            return self._default_parser
+        return self._parser
+
+    def _fromstring(self, xml_string, **kwargs):
+        xml_node = etree.fromstring(xml_string, parser=self.parser, **kwargs)
+        for entity in xml_node.iter(etree.Entity):
+            raise InvalidInput("Entities are not supported in XML input")
+        return xml_node
+
+    def _tostring(self, xml_node, **kwargs):
+        return etree.tostring(xml_node, **kwargs)
+
+    def get_root(self, data):
+        if isinstance(data, (str, bytes)):
+            return self._fromstring(data)
+        elif isinstance(data, stdlibElementTree.Element):
+            # TODO: add debug level logging statement re: performance impact here
+            return self._fromstring(stdlibElementTree.tostring(data, encoding="utf-8"))
+        else:
+            # Create a separate copy of the node so we can modify the tree and avoid any c14n inconsistencies from
+            # namespaces propagating from parent nodes. The lxml docs recommend using copy.deepcopy for this, but it
+            # doesn't seem to preserve namespaces. It would be nice to find a less heavy-handed way of doing this.
+            return self._fromstring(self._tostring(data))
+
+
+class XMLSignatureProcessor(XMLProcessor):
+    schema_files = ["xmldsig1-schema.xsd"]
+
+    # See https://tools.ietf.org/html/rfc5656
+    known_ecdsa_curves = {
+        "urn:oid:1.2.840.10045.3.1.7": ec.SECP256R1,
+        "urn:oid:1.3.132.0.34": ec.SECP384R1,
+        "urn:oid:1.3.132.0.35": ec.SECP521R1,
+        "urn:oid:1.3.132.0.1": ec.SECT163K1,
+        "urn:oid:1.2.840.10045.3.1.1": ec.SECP192R1,
+        "urn:oid:1.3.132.0.33": ec.SECP224R1,
+        "urn:oid:1.3.132.0.26": ec.SECT233K1,
+        "urn:oid:1.3.132.0.27": ec.SECT233R1,
+        "urn:oid:1.3.132.0.16": ec.SECT283R1,
+        "urn:oid:1.3.132.0.36": ec.SECT409K1,
+        "urn:oid:1.3.132.0.37": ec.SECT409R1,
+        "urn:oid:1.3.132.0.38": ec.SECT571K1,
+    }
+    known_ecdsa_curve_oids = {ec().name: oid for oid, ec in known_ecdsa_curves.items()}  # type: ignore[abstract]
+
+    excise_empty_xmlns_declarations = False
+
+    id_attributes: Tuple[str, ...] = ("Id", "ID", "id", "xml:id")
+
+    def _get_digest(self, data, algorithm: DigestAlgorithm):
+        algorithm_implementation = digest_algorithm_implementations[algorithm]()
+        hasher = Hash(algorithm=algorithm_implementation)
+        hasher.update(data)
+        return hasher.finalize()
+
+    def _find(self, element, query, require=True, xpath=""):
+        namespace = "ds"
+        if ":" in query:
+            namespace, _, query = query.partition(":")
+        result = element.find(f"{xpath}{namespace}:{query}", namespaces=namespaces)
+
+        if require and result is None:
+            raise InvalidInput(f"Expected to find XML element {query} in {element.tag}")
+        return result
+
+    def _findall(self, element, query, xpath=""):
+        namespace = "ds"
+        if ":" in query:
+            namespace, _, query = query.partition(":")
+        return element.findall(f"{xpath}{namespace}:{query}", namespaces=namespaces)
+
+    def _c14n(self, nodes, algorithm: CanonicalizationMethod, inclusive_ns_prefixes=None):
+        exclusive, with_comments = False, False
+
+        if algorithm.value.startswith("http://www.w3.org/2001/10/xml-exc-c14n#"):
+            exclusive = True
+        if algorithm.value.endswith("#WithComments"):
+            with_comments = True
+
+        if not isinstance(nodes, list):
+            nodes = [nodes]
+
+        c14n = b""
+        for node in nodes:
+            c14n += etree.tostring(
+                node,
+                method="c14n",
+                exclusive=exclusive,
+                with_comments=with_comments,
+                inclusive_ns_prefixes=inclusive_ns_prefixes,
+            )
+        if exclusive is False and self.excise_empty_xmlns_declarations is True:
+            # Incorrect legacy behavior. See also:
+            # - https://github.com/XML-Security/signxml/issues/193
+            # - http://www.w3.org/TR/xml-c14n, "namespace axis"
+            # - http://www.w3.org/TR/xml-c14n2/#sec-Namespace-Processing
+            c14n = c14n.replace(b' xmlns=""', b"")
+        logger.debug("Canonicalized string (exclusive=%s, with_comments=%s): %s", exclusive, with_comments, c14n)
+        return c14n
+
+    def _resolve_reference(self, doc_root, reference, uri_resolver=None):
+        uri = reference.get("URI")
+        if uri is None:
+            raise InvalidInput("References without URIs are not supported")
+        elif uri == "":
+            return doc_root
+        elif uri.startswith("#xpointer("):
+            raise InvalidInput("XPointer references are not supported")
+            # doc_root.xpath(uri.lstrip("#"))[0]
+        elif uri.startswith("#"):
+            for id_attribute in self.id_attributes:
+                xpath_query = f"//*[@*[local-name() = '{id_attribute}']=$uri]"
+                results = doc_root.xpath(xpath_query, uri=uri.lstrip("#"))
+                if len(results) > 1:
+                    raise InvalidInput(f"Ambiguous reference URI {uri} resolved to {len(results)} nodes")
+                elif len(results) == 1:
+                    return results[0]
+            raise InvalidInput(f"Unable to resolve reference URI: {uri}")
+        else:
+            if uri_resolver is None:
+                raise InvalidInput(f"External URI dereferencing is not configured: {uri}")
+            result = uri_resolver(uri)
+            if result is None:
+                raise InvalidInput(f"Unable to resolve reference URI: {uri}")
+            return result