Nov 19, 2026·11 min read·1 visit
Chainguard Go SDK versions prior to v0.1.107 fail to verify that the Chainguard-Audience and Chainguard-Identity HTTP headers are covered by the AWS SigV4 signature in auth/aws.VerifyToken, allowing an attacker with a captured AWS STS GetCallerIdentity request to inject arbitrary binding headers and bypass authentication.
CVE-2026-71861 (GHSA-wq26-3j2m-4hvv) is a high-severity authentication bypass and cryptographic signature-binding replay vulnerability in the Chainguard Go SDK (chainguard.dev/sdk / github.com/chainguard-dev/sdk) affecting versions prior to v0.1.107. The vulnerability resides in the auth/aws.VerifyToken function, which validates AWS STS GetCallerIdentity requests signed with AWS Signature Version 4 (SigV4) to authenticate AWS workloads. Prior to version v0.1.107, VerifyToken verified the values of custom HTTP binding headers (Chainguard-Audience and Chainguard-Identity) without confirming that those headers were listed in the SigV4 SignedHeaders parameter of the Authorization header. Because AWS STS ignores unsigned headers when recomputing and verifying the SigV4 signature, an attacker who captures any valid, fresh SigV4-signed STS GetCallerIdentity request from a victim AWS principal can inject or overwrite the Chainguard-Audience and Chainguard-Identity headers and replay the token to bypass authentication and impersonate the victim identity.
The Chainguard Go SDK (chainguard.dev/sdk / github.com/chainguard-dev/sdk) provides client and server packages for interacting with the Chainguard platform, including workload identity federation utilities in the auth/aws package. To allow AWS IAM principals (such as IAM roles, users, or federated workloads) to authenticate to Chainguard without exchanging static credentials, the SDK implements an identity token scheme based on AWS Security Token Service (STS). In this scheme, an authenticating client constructs an HTTP POST request targeting the AWS STS GetCallerIdentity API action, signs the request using AWS Signature Version 4 (SigV4), serializes the raw HTTP request, and base64-encodes it for transmission as a bearer token.
To prevent cross-service token replay and bind each signed STS request to a specific relying party and target account, Chainguard requires two custom HTTP headers in the serialized request: Chainguard-Audience, which specifies the intended token recipient (for example, https://issuer.enforce.dev), and Chainguard-Identity, which specifies the unique identifier (UID) of the Chainguard assumable identity being requested. On the server side, the auth/aws.VerifyToken function deserializes the bearer token, validates the presence and values of these custom headers against expected configuration parameters, and forwards the request to AWS STS (sts.amazonaws.com) to confirm the cryptographic validity of the SigV4 signature and retrieve the caller's AWS IAM claims (Arn, UserId, and Account).
In versions of the Chainguard Go SDK prior to v0.1.107, auth/aws.VerifyToken failed to verify that the Chainguard-Audience and Chainguard-Identity headers were actually included in the cryptographic signature calculation specified by the SignedHeaders field of the AWS SigV4 Authorization header. While auth/aws.GenerateToken properly attached and signed these headers when minting tokens, VerifyToken evaluated the header values on the parsed HTTP request object without checking whether they were protected against tampering or post-signing injection.
Tracked as CVE-2026-71861 (and GitHub Security Advisory GHSA-wq26-3j2m-4hvv), this flaw is classified under CWE-347 (Improper Verification of Cryptographic Signature), CWE-294 (Authentication Bypass by Capture-replay), and CWE-290 (Authentication Bypass by Spoofing). Because AWS STS only includes headers explicitly declared in SignedHeaders when reconstructing the canonical request for signature verification, an attacker who obtains a valid SigV4-signed GetCallerIdentity request generated for another system (such as HashiCorp Vault AWS Auth, Kubernetes aws-iam-authenticator, or a different Chainguard audience) can append or modify the Chainguard-Audience and Chainguard-Identity headers and replay the modified request within the STS 15-minute validity window to impersonate the victim AWS principal.
The root cause of CVE-2026-71861 is a cryptographic verification mismatch between how auth/aws.VerifyToken inspects HTTP headers for security policy enforcement and how AWS STS validates SigV4 signatures over an incoming HTTP request. Under the AWS Signature Version 4 specification, a client computes an HMAC-SHA256 signature over a Canonical Request string. The Canonical Request includes the HTTP method, canonical URI, canonical query string, canonical headers, and a semicolon-delimited list of lowercase header names known as SignedHeaders. The resulting Authorization header takes the following structure:
Authorization: AWS4-HMAC-SHA256 Credential=<AccessKey>/<Date>/<Region>/sts/aws4_request, SignedHeaders=accept;host;x-amz-date, Signature=<HexSignature>When AWS STS receives a signed GetCallerIdentity request, it parses the SignedHeaders attribute from the Authorization header and reads only those listed headers from the incoming HTTP request to reconstruct the Canonical Request and verify the HMAC signature. Any additional HTTP headers present in the request that are omitted from SignedHeaders are treated as transport-layer metadata and are ignored by AWS STS during signature validation. This design allows intermediate HTTP proxies to append headers (such as X-Forwarded-For or tracing headers) without invalidating the client's cryptographic signature.
In vulnerable versions of auth/aws/verify.go, VerifyToken base64-decoded the bearer token and parsed it into a standard Go *http.Request structure using http.ReadRequest. The verification logic immediately inspected req.Header.Get("Chainguard-Audience") and req.Header.Get("Chainguard-Identity") to verify that they matched the configured allowedAudiences set and identity string. Once these string comparisons succeeded, VerifyToken forwarded the *http.Request to AWS STS via an HTTP client and trusted the returned AWS account, user ID, and ARN if STS responded with HTTP 200 OK.
Because VerifyToken did not parse the Authorization header to enforce that chainguard-audience and chainguard-identity were present in SignedHeaders, and did not reject requests containing duplicate instances of critical headers, the binding between the AWS principal's signature and the Chainguard target claims was entirely unauthenticated. Any valid GetCallerIdentity request signed with standard headers (host and x-amz-date) acted as a universal bearer assertion onto which an attacker could graft arbitrary Chainguard audience and identity claims after the signature was already generated.
Prior to commit d27997d62aaffe85f905cce4cbe8cdebbd5e24eb, the token verification workflow in auth/aws/verify.go parsed the incoming serialized request and checked the custom headers directly without inspecting the Authorization header's SignedHeaders list:
// Pre-patch vulnerable logic in auth/aws/verify.go
req, err = http.ReadRequest(r)
if err != nil {
return nil, fmt.Errorf("reading request: %w", err)
}
// Flaw: Header values are checked, but VerifyToken never verifies that
// "chainguard-audience" or "chainguard-identity" are in SignedHeaders.
if conf.allowedAudiences != nil && !conf.allowedAudiences.Has(req.Header.Get("Chainguard-Audience")) {
return nil, ErrInvalidAudience
}
if conf.identity != "" && conf.identity != req.Header.Get("Chainguard-Identity") {
return nil, ErrInvalidIdentity
}
// The request is forwarded directly to AWS STS. STS ignores any headers
// not listed in SignedHeaders when validating the SigV4 signature.
resp, err := client.Do(req)In commit d27997d62aaffe85f905cce4cbe8cdebbd5e24eb, Chainguard remediated the vulnerability by introducing strict pre-verification checks before forwarding any request to AWS STS. First, the patch defines the mandatory signed headers—combining Host, X-Amz-Date, Chainguard-Audience, and Chainguard-Identity—and verifies that each normalized lowercase header name is present in the SignedHeaders parameter of the Authorization header:
// Patched implementation in auth/aws/verify.go
var requiredSignedHeaders = func() []string {
hs := append([]string{hostHeader, amzDateHeader}, bindingHeaders...)
for i := range hs {
hs[i] = strings.ToLower(hs[i])
}
return hs
}()
// Extract SignedHeaders from the Authorization header and ensure all required
// binding headers are cryptographically covered by the SigV4 signature.
signed := signedHeaderNames(req.Header.Get(authorizationHeader))
for _, h := range requiredSignedHeaders {
if !slices.Contains(signed, h) {
return nil, ErrUnsignedBindingHeaders
}
}Second, to prevent HTTP header smuggling or parameter pollution discrepancies between Go's net/http parser (where req.Header.Get returns only the first value of a multi-valued header) and AWS STS's canonical header folding (which concatenates multiple values of the same header with commas during signature verification), the patch explicitly rejects requests containing duplicate instances of security-sensitive headers:
// Reject requests with duplicate Authorization, X-Amz-Date, or binding headers
var noDuplicateHeaders = append([]string{authorizationHeader, amzDateHeader}, bindingHeaders...)
for _, h := range noDuplicateHeaders {
if len(req.Header.Values(h)) > 1 {
return nil, ErrInvalidRequest
}
}Third, the patch adds defense-in-depth validation by enforcing strict HTTP method and host pinning (requiring POST requests targeting the configured STS hostname, defaulting to sts.amazonaws.com) and validating X-Amz-Date against a maximum allowed clock skew so that future-dated tokens are rejected with ErrTokenFutureDated:
if timestamp.After(now.Add(conf.allowedClockSkew)) {
return nil, ErrTokenFutureDated
}This combination of controls ensures that fix completeness is achieved: an attacker cannot omit binding headers from the signature, cannot smuggle an unsigned second copy of a signed binding header via header duplication, and cannot abuse alternative HTTP verbs or future timestamps.
Exploiting CVE-2026-71861 requires no prior authentication to Chainguard (PR:N) and no user interaction (UI:N), though it carries high attack complexity (AC:H) because the attacker must first obtain a valid, unexpired SigV4-signed GetCallerIdentity request generated by a target AWS principal. Because signed GetCallerIdentity requests are widely used as bearer tokens across cloud infrastructure—including HashiCorp Vault's AWS IAM auth method, Kubernetes aws-iam-authenticator / EKS token generation, and cross-tenant services—an attacker can harvest a suitable request from verbose debug logs, compromised sidecars, misconfigured proxies, or an unrelated relying party where the victim workload authenticates.
Once a raw signed request is obtained within its 15-minute STS validity window, the attacker modifies the plaintext HTTP headers prior to base64 encoding. Consider a standard GetCallerIdentity request captured from a victim workload authenticating to an external service:
POST /?Action=GetCallerIdentity&Version=2011-06-15 HTTP/1.1
Host: sts.amazonaws.com
Accept: application/json
X-Amz-Date: 20260707T140000Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAVICTIM/20260707/us-east-1/sts/aws4_request, SignedHeaders=accept;host;x-amz-date, Signature=abcdef...Notice that SignedHeaders only covers accept;host;x-amz-date. The attacker appends the Chainguard-Audience and Chainguard-Identity headers to the HTTP request without modifying the Authorization header or knowing the victim's SecretAccessKey:
POST /?Action=GetCallerIdentity&Version=2011-06-15 HTTP/1.1
Host: sts.amazonaws.com
Accept: application/json
X-Amz-Date: 20260707T140000Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAVICTIM/20260707/us-east-1/sts/aws4_request, SignedHeaders=accept;host;x-amz-date, Signature=abcdef...
Chainguard-Audience: https://issuer.enforce.dev
Chainguard-Identity: target-identity-to-assumeThe reproduction mechanics are further confirmed in the official regression test TestVerifyRejectsUnsignedBindingHeaders in auth/aws/verify_replay_test.go, which simulates an attacker taking an STS request signed without Chainguard headers and injecting the binding headers post-signing:
// From auth/aws/verify_replay_test.go
creds := aws.Credentials{AccessKeyID: "AKIAVICTIM", SecretAccessKey: "victimsecret"}
req, err := http.NewRequest("POST", "https://sts.amazonaws.com", nil)
req.URL.Path = "/"
req.URL.RawQuery = "Action=GetCallerIdentity&Version=2011-06-15"
req.Header.Add("Accept", "application/json")
_ = v4.NewSigner().SignHTTP(ctx, creds, req, emptyBodySHA256, "sts", "us-east-1", signAt)
// The attacker injects the Chainguard headers AFTER signing.
req.Header.Set(audHeader, testAud)
req.Header.Set(idHeader, testID)
forged := serializeToken(t, req)When the base64-encoded forged token is submitted to an unpatched service running VerifyToken, the local audience and identity string checks pass, AWS STS validates the signature over accept;host;x-amz-date and returns the victim's IAM ARN (arn:aws:iam::123456789012:role/VictimRole), and the attacker assumes the target Chainguard identity.
Successful exploitation of CVE-2026-71861 breaks the cryptographic binding between an AWS IAM principal's proof of identity and the relying party context, resulting in full authentication bypass and identity impersonation within applications relying on chainguard.dev/sdk/auth/aws.VerifyToken. An attacker who intercepts a GetCallerIdentity request intended for another service (or intended for a low-privilege Chainguard identity where the headers were not signed) can pivot laterally into Chainguard platform resources scoped to the victim AWS IAM role or user.
The vulnerability is assigned a CVSS v3.1 base score of 7.4 (High) with the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N. The Confidentiality (C:H) and Integrity (I:H) ratings reflect that an attacker assuming a victim's federated Chainguard identity gains full read and write permissions associated with that identity inside the Chainguard authentication boundary. Availability impact is rated None (A:N) because the flaw does not provide a mechanism to degrade or disrupt service availability.
Two factors scope the operational exposure of this vulnerability. First, applications that only use auth/aws.GenerateToken on the client side are unaffected, because GenerateToken always populated the Chainguard-Audience and Chainguard-Identity headers on the HTTP request prior to invoking the AWS SigV4 signer, ensuring those headers were listed in SignedHeaders for legitimately minted Chainguard tokens. Only services acting as token verifiers via auth/aws.VerifyToken in SDK releases < 0.1.107 (including tagged releases v0.1.87 through v0.1.106) are vulnerable.
Second, exploitation is bounded by the temporal validity of the captured AWS SigV4 signature. AWS STS enforces a 15-minute expiration window on signed requests based on the X-Amz-Date header, meaning an attacker must capture and replay the signed GetCallerIdentity request while the signature remains fresh. As of publication, CVE-2026-71861 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no active in-the-wild exploitation campaigns have been recorded.
All downstream services and applications that verify AWS identity tokens using chainguard.dev/sdk/auth/aws must upgrade to Chainguard Go SDK version v0.1.107 or later, which contains commit d27997d62aaffe85f905cce4cbe8cdebbd5e24eb. Operators and developers can update their Go module dependencies using the following commands:
go get chainguard.dev/sdk@v0.1.107
go mod tidyIf an immediate dependency upgrade and binary redeployment cannot be performed, operators can implement temporary pre-filtering in an upstream API gateway, reverse proxy, or middleware layer before passing the token to VerifyToken. The pre-filter should base64-decode the incoming bearer token, parse the raw HTTP headers, confirm that Chainguard-Audience, Chainguard-Identity, X-Amz-Date, and Authorization each appear exactly once, and verify that the SignedHeaders= parameter inside the Authorization header contains chainguard-audience, chainguard-identity, host, and x-amz-date.
> [!NOTE] > Standard Web Application Firewall (WAF) rules inspecting outer HTTP requests will not automatically inspect the inner SigV4 headers unless the WAF is configured to base64-decode the bearer token payload first.
After upgrading to v0.1.107 or later, security engineering teams should monitor application logs for verification rejection errors introduced by the patch. Specifically, occurrences of ErrUnsignedBindingHeaders ("verification failed because a required header is not covered by the request signature"), ErrInvalidRequest ("verification failed because of a duplicated request header"), or ErrTokenFutureDated ("verification failed because the token timestamp is in the future") indicate either misconfigured custom token generators or active token replay and header injection attempts.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
chainguard.dev/sdk (github.com/chainguard-dev/sdk) Chainguard | < 0.1.107 | 0.1.107 |
| Attribute | Detail |
|---|---|
| CVE / GHSA ID | CVE-2026-71861 / GHSA-wq26-3j2m-4hvv |
| CWE Classification | CWE-347 (Improper Verification of Cryptographic Signature) / CWE-294 / CWE-290 |
| CVSS v3.1 Score | 7.4 High (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N) |
| Affected Component | chainguard.dev/sdk/auth/aws (VerifyToken) |
| Affected Versions | < v0.1.107 |
| Patched Version | v0.1.107 (d27997d62aaffe85f905cce4cbe8cdebbd5e24eb) |
| Impact | Authentication Bypass and Federated Identity Impersonation |
| CISA KEV Status | Not Listed |
The software does not verify, or incorrectly verifies, the cryptographic signature for data, allowing an attacker to modify or forge critical data items outside signature coverage.
CVE-2026-73864 is a CWE-494 (Download of Code Without Integrity Check) vulnerability in the Node.js package install-artifact-from-github prior to version 1.7.0. The tool downloads precompiled native Node.js C/C++ addons (.node binaries) from GitHub Releases or configurable mirrors and writes them directly to disk without verifying cryptographic checksums or signatures. Furthermore, its HTTP client follows cross-protocol redirects from HTTPS to plaintext HTTP. When the consuming application loads the downloaded addon via require(), the unverified native binary executes immediately within the Node.js process, permitting arbitrary native code execution if an attacker compromises a GitHub release asset, poisons a configured mirror, or intercepts downgraded network traffic.
LLMKube prior to version 0.9.0 fails to restrict local filesystem paths and file:// URIs supplied in the Model.spec.source field of custom resources. A namespace-level user with permission to create or modify Model and InferenceService resources can traverse the filesystem of the operator controller pod or mount arbitrary host node files via a HostPathVolumeSource. This enables unauthorized disclosure of high-privilege Kubernetes ServiceAccount tokens and underlying host credentials.
CVE-2026-75521 is an unauthenticated remote authentication bypass vulnerability in Miren Runtime prior to version 0.11.1. The QUIC/HTTP3 RPC service configures its TLS listener with tls.RequestClientCert, which requests client certificates without validating them against the cluster Certificate Authority. Simultaneously, the RPC authenticators extract caller identities directly from PeerCertificates[0] without checking VerifiedChains, granting any caller presenting a self-signed certificate the AuthMethodCert identity and a complete Role-Based Access Control (RBAC) bypass.
CVE-2026-63129 is a high-severity SQL injection vulnerability (CWE-89) in the @connorbritain/mssql-mcp-core library and its downstream implementations (mssql-mcp-server, mssql-mcp-reader, and mssql-mcp-writer). The flaw results from the direct concatenation of unvalidated database identifiers, filter predicates, and enum parameters into T-SQL batches passed to the node-mssql Request.query() interface. Because pre-execution row count and preview queries execute before safety confirmation flags are checked, an attacker with access to invoke Model Context Protocol (MCP) tools can bypass confirmation controls and execute arbitrary stacked T-SQL statements.
CVE-2026-73504 (GHSA-jc42-994r-vvwp) is a credential exposure vulnerability in ING Bank's cassandra-jdbc-wrapper (com.ing.data:cassandra-jdbc-wrapper). Resulting from an incomplete remediation of AIKIDO-2024-10565, the log sanitization routines in DriverUtil redact the password property but fail to redact the token property. When DEBUG logging is enabled, connection properties and JDBC URLs containing DataStax Astra DB bearer tokens are written in plaintext to application logs, enabling local users or log aggregation readers to harvest active database credentials.
A denial-of-service vulnerability (CWE-400) exists in PGPainless versions prior to 1.7.8 and 2.0.x prior to 2.0.4 within the MessageInspector and InlineDetachImpl components. These components manually iterate over OpenPGP packet streams without enforcing the global 16-layer maximum nesting limit (MAX_LAYER_DEPTH). An unauthenticated remote attacker can supply a specially crafted OpenPGP message containing deeply nested PGPCompressedData packets to trigger unbounded recursive decompression, resulting in CPU starvation and Java Virtual Machine (JVM) heap exhaustion.