SAML

SAML (Security Assertion Markup Language) has long been the de facto standard in the enterprise single sign-on (SSO) space.

WorkOS is a technology company focused on providing enterprise-grade identity authentication and user management infrastructure for SaaS applications, with products covering core enterprise IT capabilities such as SSO (Single Sign-On), SCIM directory synchronization, and audit logs.

SSO implementation typically relies on standard protocols such as SAML or OIDC, integrating with enterprise identity providers such as Okta, Azure AD, and Google Workspace.

SAML is an XML-based identity federation protocol that conveys authentication and authorization information by having the IdP issue assertions to the SP, and is commonly used for enterprise single sign-on.

Traditional identity providers (IdPs) are designed for human users and rely on mechanisms such as account passwords and multi-factor authentication, with common standards including SAML, OAuth 2.0 and OpenID Connect.

In an SSO flow, the authentication assertion sent by the IdP to the application is usually carried in the form of a SAML assertion or an OIDC ID Token.

SCIM is usually used together with SAML/OIDC: the latter handles authentication, while the former handles provisioning.

A common premise of SAML and OIDC is the presence of a human user who, after authenticating at the IdP, is redirected by the browser with a token or assertion to the target domain.

In SAML and JWT, the signature protects "the bytes that were selected," while the semantic correctness of the selection logic often goes unverified.

Security researchers analyzing the issue believe that the C2PA range-not-verified flaw is not an implementation oversight in some library, but a consequence of the protocol design underestimating the signature coverage range metadata.

Common standards for automated identity provisioning include OAuth, SAML, and SCIM (System for Cross-domain Identity Management).

The reason EMA can consolidate authorization into the IdP is the premise that the enterprise has already unified employee identities with an IdP; after an application integrates with the IdP, user login follows the SAML or OpenID Connect standard, with identity assertions issued by the IdP.

The approach to fundamentally eliminating parser differential inconsistency is to base signature verification and identity extraction on the same canonicalized XML tree; any secondary parsing of the raw bytes is a potential risk.

Hard rules for handling signed XML include: prohibit multiple parsers from processing the same security-sensitive XML, perform C14N before signature verification and extract identity based on the canonicalized result, strictly validate namespaces, and use absolute paths in XPath.

This class of SAML flaws is usually categorized at the intersection of CWE-436 (Interpretation Conflict) and CWE-347 (Improper Verification of Cryptographic Signature).

An attacker can craft a piece of XML so that the signature verifier reads user A's data while the identity extractor reads user B's identity (usually an administrator), thereby bypassing the system while the signature remains valid.

The SAML specification requires the use of Exclusive Canonicalization (Exclusive C14N), which includes only the namespace declarations actually used, avoiding irrelevant declarations from ancestor nodes polluting the canonicalization result.

The four vulnerabilities disclosed this time can all be classified as authentication bypasses, all stemming from the same class of parsing ambiguity; an attacker does not need to break encryption algorithms or steal private keys to construct an exploit payload.

Any protocol that "verifies the signature first, then parses" (including some JWT and WS-Security implementations) carries similar parser inconsistency risks, and the core defensive principle is that security decisions and business logic must be based on the same data view.

A SAML response is digitally signed XML, and its signature verification and identity attribute extraction often use different XML parsers, different XPath expressions or different namespace handling, causing parser differential inconsistency.