Nov 18, 2026·11 min read·3 visits
SimpleSAMLphp SAML2 versions 6.2.2 through 6.2.3 and 7.0.0-rc1 fail to mandate signatures or enforce issuer binding on embedded SAML Responses received via the HTTP-Artifact binding. An attacker controlling a single federated IdP can encapsulate an unsigned SAML Response claiming to be from another IdP inside a validly signed ArtifactResponse, bypassing authentication and achieving cross-IdP user impersonation.
CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.
The SimpleSAMLphp SAML2 library (simplesamlphp/saml2) provides core SAML 2.0 protocol message handling, XML serialization, and binding implementations for PHP applications. Among its supported transport mechanisms is the SAML 2.0 HTTP-Artifact binding, implemented within the SimpleSAML\SAML2\Binding\HTTPArtifact class in src/Binding/HTTPArtifact.php. Unlike HTTP-POST or HTTP-Redirect bindings, which transmit SAML assertions directly through the user's browser, the HTTP-Artifact binding transmits an opaque reference token (SAMLart) to the Service Provider (SP). The SP then resolves this token out-of-band by sending a direct SOAP <samlp:ArtifactResolve> request to the issuing Identity Provider's ArtifactResolutionService endpoint.
In versions 6.2.2 prior to 6.2.4 and 7.0.0-rc1 prior to 7.0.0-rc2, HTTPArtifact::receive() contains a cryptographic verification flaw categorized under CWE-347 (Improper Verification of Cryptographic Signature) and CWE-287 (Improper Authentication). This vulnerability is the direct result of an incomplete remediation for a prior vulnerability, CVE-2026-49283, introduced in commit df7d0d2d02c4ddf90c3c6149b1d53bb4ff0266fe. While the receive() method properly verifies the signature of the outer <samlp:ArtifactResponse> SOAP envelope against the artifact issuer's metadata keys, it fails to enforce signature verification and entity binding on the inner, embedded <samlp:Response> message.
Specifically, the implementation contains an explicit conditional short-circuit: if the embedded <samlp:Response> is unsigned (!$samlResponse->isSigned()), the method immediately returns the unverified message object to the caller before reaching verifyMessageSignature(). Furthermore, even when the embedded message is signed, the verification routine validates the signature against the outer artifact issuer's metadata without verifying that the embedded <saml:Issuer> matches the entity ID of the outer artifact issuer.
In federated architectures where a Service Provider trusts multiple Identity Providers, this flaw breaks the cryptographic isolation between federated trust boundaries. A malicious or compromised IdP can return a validly signed outer <samlp:ArtifactResponse> containing an unsigned inner <samlp:Response> that asserts an <saml:Issuer> belonging to a completely different, high-privilege IdP. If downstream application consumers rely on the HTTP-Artifact binding to guarantee message authenticity rather than enforcing independent assertion-level signature checks, the attacker achieves cross-IdP authentication bypass and arbitrary user impersonation.
To understand the root cause of CVE-2026-110782, it is necessary to examine the two-layer message structure of the SAML 2.0 HTTP-Artifact resolution protocol. When a Service Provider receives a SAMLart parameter from a user agent, it extracts the 20-byte SourceID field from the artifact payload. The SP maps this SourceID to a known Identity Provider's configuration ($idpMetadata) and initiates a back-channel SOAP exchange. The IdP replies with a <samlp:ArtifactResponse> element, which acts as a transport wrapper around the actual protocol payload, typically a <samlp:Response> containing authentication assertions.
When addressing CVE-2026-49283, the developers added signature verification logic to HTTPArtifact::receive() to ensure that the embedded <samlp:Response> was validated before being passed to the consuming application. However, the developers introduced a conditional guard clause: if (!$samlResponse->isSigned()) { return $samlResponse; }. This logic assumes that signature verification is only necessary if the sender optionally included an XML <ds:Signature> element on the inner response. Because the attacker controls the XML structure returned by the ArtifactResolutionService, omitting the <ds:Signature> element from the inner <samlp:Response> forces execution into the short-circuit branch, bypassing verifyMessageSignature() entirely.
The second compounding defect is the lack of cross-layer issuer binding between the outer transport envelope and the inner SAML payload. During artifact resolution, the SP determines $idpMetadata strictly from the SAMLart token's SourceID. While the outer <samlp:ArtifactResponse> is verified against $idpMetadata, the code never compares $idpMetadata->getString('entityid') against the <saml:Issuer> element inside the embedded $samlResponse.
Because these two checks are absent, the binding conflates transport-level authenticity (proving that IdP-B sent the ArtifactResponse) with payload-level authority (proving that IdP-B is authorized to issue assertions on behalf of the entity claimed inside the embedded Response). Consequently, any trusted IdP in a federation can forge unsigned responses claiming to originate from any other trusted IdP in the same federation.
The vulnerability resides in src/Binding/HTTPArtifact.php within the receive() method. In vulnerable versions (6.2.2 to 6.2.3 and 7.0.0-rc1), after the outer ArtifactResponse is received and its status and outer signature are verified, the code extracts the embedded message ($samlResponse) and executes the following flawed logic:
// Vulnerable code in src/Binding/HTTPArtifact.php (v6.2.2 - v6.2.3)
$query = $request->getQueryParams();
if (isset($query['RelayState'])) {
$this->setRelayState($query['RelayState']);
}
// BUG 1: Short-circuit return if the inner message lacks a <ds:Signature> element.
// An attacker simply omits the signature on the embedded Response to bypass verification.
if (!$samlResponse->isSigned()) {
return $samlResponse;
}
// BUG 2: Even if signed, verifyMessageSignature() uses $idpMetadata (derived from the
// outer artifact) without verifying that $samlResponse->getIssuer() matches $idpMetadata.
return $this->verifyMessageSignature($samlResponse, $idpMetadata);In commits 7b7fbb5322cb5607db3e5a329681f4886b1449fe (for 6.2.4) and 9a21edb96de1f3ece3b40ccbe3b7de761917a06f (for 7.0.0-rc2), the maintainers refactored the validation logic into a standalone method named handleReceivedArtifactResponse() to facilitate unit testing and corrected both flaws:
// Patched code in src/Binding/HTTPArtifact.php (v6.2.4 / v7.0.0-rc2)
public function handleReceivedArtifactResponse(
ArtifactResponse $artifactResponse,
array $query,
?Configuration $idpMetadata
): AbstractMessage {
if (!$artifactResponse->isSuccess()) {
throw new Exception('Received error from ArtifactResolutionService.');
}
$samlResponse = $artifactResponse->getMessage();
if ($samlResponse === null) {
throw new Exception('Empty ArtifactResponse received, maybe a replay?');
}
if (isset($query['RelayState'])) {
$this->setRelayState($query['RelayState']);
}
// FIX 1: Mandate that the embedded SAML Response must be cryptographically signed.
// Unsigned responses now trigger an immediate exception instead of returning early.
if ($samlResponse->isSigned() !== true) {
throw new Exception('Received SAML Response which is not signed.');
}
// FIX 2: Enforce strict Entity ID binding between the outer artifact issuer ($idpMetadata)
// and the inner SAML Response <saml:Issuer> element.
$idpEntity = $idpMetadata->getString('entityid');
$samlResponseEntity = $samlResponse->getIssuer()?->getContent()->getValue();
if ($samlResponseEntity === null) {
throw new Exception('Received SAML Response with no entity ID.');
}
if ($samlResponseEntity !== $idpEntity) {
throw new Exception('Received SAML Response from an IdP for another IdP.');
}
// Verify the cryptographic signature of the inner Response against the bound IdP metadata
$msg = $this->verifyMessageSignature($samlResponse, $idpMetadata);
return $msg;
}The patch completely resolves both the unsigned bypass and the cross-IdP issuer spoofing vector within the HTTPArtifact binding. By asserting $samlResponse->isSigned() !== true and throwing an exception, no unverified message can exit handleReceivedArtifactResponse(). By enforcing $samlResponseEntity === $idpEntity prior to calling verifyMessageSignature($samlResponse, $idpMetadata), the code guarantees that the cryptographic keys used to validate the inner signature belong to the exact entity claimed in the inner <saml:Issuer> element, closing the cross-IdP impersonation primitive.
Exploiting CVE-2026-110782 requires specific architectural prerequisites, reflected in its High Attack Complexity (AC:H) CVSS metric:
IdP-A and IdP-B).IdP-B), including its private signing key registered in the SP's federation metadata.HTTPArtifact::receive() to authenticate the <samlp:Response> without independently requiring a signature on the nested <saml:Assertion>.SAMLart query parameter. The SourceID embedded in the artifact points to IdP-B (https://idp-b.example/).SourceID to IdP-B's metadata, and sends a SOAP <samlp:ArtifactResolve> request to IdP-B's ArtifactResolutionService endpoint.ArtifactResolutionService constructs a <samlp:ArtifactResponse>. Inside this wrapper, the attacker embeds an unsigned <samlp:Response> whose <saml:Issuer> is set to https://idp-a.example/ (the target victim IdP) and whose <saml:Subject> asserts a privileged identity (e.g., admin@idp-a.example). The attacker signs only the outer <samlp:ArtifactResponse> using IdP-B's legitimate private key.<samlp:ArtifactResponse> signature against IdP-B's public certificate. This check succeeds. When HTTPArtifact::receive() inspects the inner <samlp:Response>, $samlResponse->isSigned() evaluates to false. The method immediately returns the forged $samlResponse to the application, authenticating the attacker as the user from IdP-A.The official patch commits include regression unit tests in tests/SAML2/Binding/HTTPArtifactNefTest.php that serve as a functional proof-of-concept for both the unsigned response vector and the cross-IdP issuer mismatch vector:
// Extracted from tests/SAML2/Binding/HTTPArtifactNefTest.php
public function testArtifactResolveUnsigned(): void
{
$idpB = $this->idpBMetadata(); // EntityID: 'https://idp-b.example/'
$ha = new HTTPArtifact();
// Construct forged embedded <samlp:Response> without a signature
$embedded = $this->createStub(Response::class);
$embedded->method('isSigned')->willReturn(false);
$embedded->method('getSignature')->willReturn(null);
$embedded->method('getIssuer')->willReturn(
new Issuer(SAMLStringValue::fromString('https://idp-b.example/'))
);
// Construct outer <samlp:ArtifactResponse> validly signed by IdP-B
$outer = $this->createStub(ArtifactResponse::class);
$outer->method('isSigned')->willReturn(true);
$outer->method('isSuccess')->willReturn(true);
$outer->method('verify')->willReturnCallback(fn() => $outer);
$outer->method('getSignature')->willReturn(self::sigEl());
$outer->method('getMessage')->willReturn($embedded);
// In vulnerable versions (6.2.2 - 6.2.3), this returns $embedded without throwing.
// In patched versions (6.2.4+), this throws 'Received SAML Response which is not signed.'
$this->expectException(\Exception::class);
$this->expectExceptionMessage('Received SAML Response which is not signed.');
$reply = $this->call($ha, 'handleReceivedArtifactResponse', $outer, [], $idpB);
}CVE-2026-110782 carries a CVSS v3.1 base score of 8.7 (High) with the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N. The vulnerability is remotely exploitable over the network (AV:N) without requiring prior authentication on the target Service Provider (PR:N) or interaction from a legitimate user (UI:N).
The Scope is marked as Changed (S:C) because the vulnerable component is the SAML protocol binding layer authenticating assertions for a specific Identity Provider realm, while the impacted component extends across federated trust boundaries to other Identity Provider realms and the downstream Service Provider application. In multi-tenant or academic/enterprise identity federations (such as eduGAIN or B2B partner hubs) where dozens or hundreds of IdPs are registered within a single SP's metadata store, the compromise of the lowest-security partner IdP compromises the authentication integrity of the entire federation.
Both Confidentiality (C:H) and Integrity (I:H) impacts are rated High. By forging identity assertions for arbitrary users—including administrative accounts belonging to the primary corporate IdP—an attacker gains full unauthorized access to protected application data and administrative functionality. Availability (A:N) is unaffected, as the flaw does not provide a mechanism for resource exhaustion or service disruption.
> [!NOTE]
> As of November 2026, CVE-2026-110782 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no active in-the-wild exploitation campaigns have been recorded. Public proof-of-concept code is limited to the PHPUnit test cases shipped in the official patch commits.
Organizations and developers utilizing simplesamlphp/saml2 must upgrade to the patched releases (v6.2.4 for the 6.x release train, or v7.0.0-rc2 and later for the 7.x release train). These versions enforce mandatory signature checks on embedded SAML Responses and verify strict entity ID alignment between the outer artifact issuer and the inner response issuer.
To update the dependency via Composer, run:
# For 6.x deployments
composer require simplesamlphp/saml2:^6.2.4
# For 7.x deployments
composer require simplesamlphp/saml2:^7.0.0-rc2> [!NOTE]
> Versions prior to 6.2.2 are not affected by this specific regression, as the defective check was introduced during the fix for CVE-2026-49283 in version 6.2.2. However, running versions prior to 6.2.2 exposes deployments to CVE-2026-49283, making 6.2.4 the minimum safe version on the 6.x branch.
If immediate package upgrading is not feasible, administrators and developers can mitigate the exposure through the following configuration and architectural controls:
HTTP-Artifact Assertion Consumer Service endpoints from the Service Provider's SAML metadata and configuration, restricting authentication flows to HTTP-POST binding.<saml:Assertion> element (wantAssertionsSigned = true) and validate the assertion signature against the metadata corresponding to the assertion's <saml:Issuer> independently of the transport binding.CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
simplesamlphp/saml2 SimpleSAMLphp | >= 6.2.2, < 6.2.4 | 6.2.4 |
simplesamlphp/saml2 SimpleSAMLphp | >= 7.0.0-rc1, < 7.0.0-rc2 | 7.0.0-rc2 |
| Attribute | Detail |
|---|---|
| Vulnerability Type | CWE-347: Improper Verification of Cryptographic Signature / CWE-287: Improper Authentication |
| Attack Vector | Network (SAML 2.0 HTTP-Artifact SOAP Resolution) |
| CVSS v3.1 Score | 8.7 High (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N) |
| Affected Component | SimpleSAML\SAML2\Binding\HTTPArtifact::receive() in src/Binding/HTTPArtifact.php |
| Impact | Cross-IdP authentication bypass and arbitrary user impersonation in multi-IdP federations |
| Exploit Status | Proof-of-Concept Available (Unit Test Suite) |
| CISA KEV Status | Not Listed |
| Patched Versions | simplesamlphp/saml2 6.2.4 and 7.0.0-rc2 |
The software does not verify, or incorrectly verifies, the cryptographic signature for data, allowing spoofed or unauthenticated payloads to be accepted as trusted.
CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.
CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.
CVE-2026-119793 (GHSA-x2vm-cf3p-m2w8) is a resource consumption vulnerability in the @libp2p/gossipsub module of the js-libp2p ecosystem. Prior to @libp2p/gossipsub version 17.0.0 and js-libp2p version 3.3.9, the GossipSub implementation processed incoming subscription RPC messages without enforcing per-peer or global limits on the number or cumulative byte size of subscribed topics in its default configuration. An unauthenticated remote peer can exploit this flaw by streaming continuous batches of unique topic subscription strings over an established connection, causing unbounded growth of the internal topics Map. This leads to V8 heap exhaustion (Out-Of-Memory crash) and severe CPU starvation on the main event loop during peer disconnection teardown.
Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.
CVE-2026-63182 is a high-severity XML Signature Wrapping (XSW) vulnerability in LightSAML (litesaml/lightsaml), a PHP library implementing SAML 2.0 data models and cryptographic verification. An architectural discrepancy between how LightSAML deserializes direct child assertions and how the underlying robrichards/xmlseclibs library resolves XML document fragment identifiers allows an attacker with a valid signed assertion to forge arbitrary SAML identity claims and bypass authentication.
A race condition and improper synchronization vulnerability (CWE-362) exists in Next.js versions 16.2.0 prior to 16.4.5 when Cache Components ('use cache' directive) are enabled. When an outer cached function calls a nested cached function that reads dynamic root parameters via 'next/root-params' and returns an object containing pending promises, React Flight can resolve and deliver the ready portion of the payload before the inner cache finishes publishing its root parameter dependencies. Consequently, the outer cache entry finalizes and persists under a cache key that omits the root parameter dependencies, causing the first written cache entry to be served across requests with different root parameter values and bypassing nested cache invalidation rules.