Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
17 changes: 11 additions & 6 deletions docs/usage/examples.rst
Original file line number Diff line number Diff line change
Expand Up @@ -198,23 +198,28 @@ contains the following:
</XRDS>

The structure of the file should be fairly self-evident. Only links with @rel="urn:oasis:names:tc:SAML:2.0:metadata"
will be parsed. If a KeyInfo with a X509Certificate element (usual base64-encoded certificate format) then this
certificate is used to validate the signature on the downloaded SAML metadata. Note that while 'load' supports validation
based on certificate fingerprint the XRD format does not and you will have to include Base64-encoded certificates if
you want validation to work.
will be parsed. The X509Certificate elements (base64-encoded certificates) in a link's KeyInfo are the trusted signers
of the metadata it points to: the downloaded metadata is only loaded if it is signed by one of them, so during a key
rollover a link can list both the old and the new certificate. The certificate is used as such, not via its
fingerprint, so this also works for metadata whose signature does not carry the signing certificate, as is common for
MDQ responses.

.. warning::

A link without a certificate is loaded **without** signature verification.

Example 4 - Sign using a PKCS#11 module
---------------------------------------

Fetch SWAMID metadata (and validate the signature using a certificate matching the given SHA256 fingerprint), select
Fetch SWAMID metadata (and validate the signature using the SWAMID signing certificate in swamid-2.0.crt), select
the Identity Providers, tidy it up a bit and sign with the key with the label 'signer' in the PKCS#11 module
/usr/lib/libsofthsm.so. If a certificate is found in the same PKCS#11 object, that certificate is included in
the Signature object.

.. code-block:: yaml

- load:
- http://mds.swamid.se/md/swamid-2.0.xml A6:78:5A:37:C9:C9:0C:25:AD:5F:1F:69:22:EF:76:7B:C9:78:67:67:3A:AF:4F:8B:EA:A1:A7:6D:A3:A8:E5:85
- http://mds.swamid.se/md/swamid-2.0.xml verify swamid-2.0.crt
- select: "!//md:EntityDescriptor[md:IDPSSODescriptor]"
- xslt:
stylesheet: tidy.xsl
Expand Down
11 changes: 9 additions & 2 deletions src/pyff/builtins.py
Original file line number Diff line number Diff line change
Expand Up @@ -694,11 +694,18 @@ def load(req: Plumbing.Request, *opts):
- ``as``: name the resource, e.g. to refer to it in later pipeline steps.
- ``verify``: check the XML signature of the resource, using either a PEM certificate file or a SHA-1
fingerprint of the signing certificate. With a fingerprint, the certificate embedded in the signature is
used and the fingerprint pins it. ``verify`` may be repeated to support key rollovers; a signature by any
one of the given certificates (or fingerprints) is accepted. Certificates and fingerprints cannot be mixed.
used and the fingerprint pins it, so a document whose signature carries no certificate - common for MDQ
responses - can only be verified with the certificate file. Other fingerprints, eg SHA-256, are not
supported. ``verify`` may be repeated to support key rollovers; a signature by any one of the given
certificates (or fingerprints) is accepted. Certificates and fingerprints cannot be mixed.
- ``via``: name of a ``when`` clause in the same pipeline that is applied to the loaded metadata, for
example to remove entities with ``fork merge remove``.
- ``cleanup``: name of a ``when`` clause used to pre-process the parsed metadata before it is validated.

A resource may also be an XRD or eIDAS MDSL file listing metadata URLs. Each listed URL is loaded and verified
with the certificates given for it in the file, as if with ``verify``; any one of them is accepted, so a key
rollover can list both. An XRD link without a certificate is loaded unverified; an MDSL entry without one is
skipped.
"""
_opts = dict(list(zip(opts[::2], opts[1::2])))
_opts.setdefault('timeout', 120)
Expand Down
18 changes: 11 additions & 7 deletions src/pyff/parse.py
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,7 @@
from pyff.resource import Resource, ResourceInfo

# cert_dict replaces xmlsec.crypto.CertDict (fingerprint -> cert mapping).
from pyff.utils import cert_dict, find_matching_files, parse_xml, root, unicode_stream, utc_now
from pyff.utils import b64_to_pem, cert_dict, find_matching_files, parse_xml, root, unicode_stream, utc_now

__author__ = 'leifj'

Expand Down Expand Up @@ -120,12 +120,16 @@ def parse(self, resource: Resource, content: str) -> ParserInfo:
for link in xrd.findall(".//{{{}}}Link[@rel='{}']".format(NS['xrd'], NS['md'])):
link_href = link.get("href")
certs = cert_dict(link)
fingerprints = list(certs.keys())
fp = None
if len(fingerprints) > 0:
fp = fingerprints[0]
log.debug(f"XRD: {link_href} verified by {fp}")
child_opts = resource.opts.model_copy(update={'alias': None})
if certs:
log.debug(f"XRD: {link_href} verified by {', '.join(certs.keys())}")
else:
log.debug(f"XRD: {link_href} has no certificate, not verified")
# The Link's certificates are the trusted signers; all of them are accepted so that a key rollover
# can list both the old and the new certificate. Without one the metadata is not verified, rather
# than with the verify option of the XRD itself.
child_opts = resource.opts.model_copy(
update={'alias': None, 'verify': [b64_to_pem(cert_b64) for cert_b64 in certs.values()] or None}
)
resource.add_child(link_href, child_opts)
resource.last_seen = utc_now().replace(microsecond=0)
resource.expire_time = None
Expand Down
101 changes: 101 additions & 0 deletions src/pyff/test/test_pipeline.py
Original file line number Diff line number Diff line change
Expand Up @@ -280,6 +280,107 @@ def test_no_fail_on_error_invalid_dir(self):
assert md.lookup('https://idp.example.com/saml2/idp/metadata.php')


class XRDTest(PipeLineTest):
"""
Each XRD Link's certificates are the trusted signers of the metadata it points to: cf. issue #264.
"""

def setUp(self):
super().setUp()
self.tmpdir = tempfile.mkdtemp()
self.signed = os.path.join(self.tmpdir, 'signed.xml')
self.exec_pipeline(
f"""
- load:
- {self.datadir}/simple-pipeline
- select
- finalize:
cacheDuration: PT5H
validUntil: P10D
- sign:
key: {self.private_keyspec}
cert: {self.public_keyspec}
- publish:
output: {self.signed}
"""
)
with open(self.public_keyspec) as fd:
self.signer_cert = fd.read()

def tearDown(self):
shutil.rmtree(self.tmpdir)

@staticmethod
def _other_cert():
"""A self-signed certificate for a key that did not sign the metadata"""
import datetime

from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID

key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, 'other')])
now = datetime.datetime.now(datetime.timezone.utc)
cert = (
x509.CertificateBuilder()
.subject_name(name)
.issuer_name(name)
.public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(now)
.not_valid_after(now + datetime.timedelta(days=2))
.sign(key, hashes.SHA256())
)
return cert.public_bytes(serialization.Encoding.PEM).decode()

def _load_via_xrd(self, href, certs):
"""Load ``href`` through an XRD Link carrying ``certs`` (PEM) and return the loaded entityIDs"""
key_infos = "".join(
'<ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><ds:X509Data><ds:X509Certificate>'
+ "".join(pem.strip().splitlines()[1:-1])
+ '</ds:X509Certificate></ds:X509Data></ds:KeyInfo>'
for pem in certs
)
xrd = os.path.join(self.tmpdir, 'links.xrd')
with open(xrd, 'w') as fd:
fd.write(
f'<XRDS xmlns="{NS["xrd"]}"><XRD><Subject>{href}</Subject>'
f'<Link rel="{NS["md"]}" href="{href}"><Title>test</Title>{key_infos}</Link></XRD></XRDS>'
)
_res, md = self.exec_pipeline(f"- load:\n - {xrd}\n")
return {e.get('entityID') for e in md.store}

def _signed_url(self):
return f'file://{self.signed}'

def _tampered_url(self):
"""The signed metadata with one entityID changed after signing"""
tampered = os.path.join(self.tmpdir, 'tampered.xml')
with open(self.signed) as src, open(tampered, 'w') as dst:
dst.write(src.read().replace('https://idp.aco.net/idp/shibboleth', 'https://evil.example.org/idp'))
return f'file://{tampered}'

def test_link_certificate_verifies(self):
assert 'https://idp.aco.net/idp/shibboleth' in self._load_via_xrd(self._signed_url(), [self.signer_cert])

def test_wrong_link_certificate_is_rejected(self):
assert self._load_via_xrd(self._signed_url(), [self._other_cert()]) == set()

def test_tampered_metadata_is_rejected(self):
assert self._load_via_xrd(self._tampered_url(), [self.signer_cert]) == set()

def test_any_link_certificate_verifies(self):
"""A key rollover lists both the old and the new certificate"""
entity_ids = self._load_via_xrd(self._signed_url(), [self._other_cert(), self.signer_cert])
assert 'https://idp.aco.net/idp/shibboleth' in entity_ids

def test_link_without_certificate_is_loaded_unverified(self):
"""As in pyFF 2.0.0: without a certificate there is nothing to verify against"""
assert 'https://evil.example.org/idp' in self._load_via_xrd(self._tampered_url(), [])


class SortTest(PipeLineTest):
EID1 = "https://idp.aco.net/idp/shibboleth"
EID2 = "https://idp.example.com/saml2/idp/metadata.php"
Expand Down
Loading