CVE-2026-3336: AWS-LC Auth Bypass Vulnerability

CVE-2026-3336 Overview

CVE-2026-3336 is an improper certificate validation vulnerability in the PKCS7_verify() function of AWS-LC, a general-purpose cryptographic library maintained by Amazon Web Services. This Certificate Validation Bypass vulnerability allows an unauthenticated user to bypass certificate chain verification when processing PKCS7 objects that contain multiple signers, with the exception of the final signer.

The vulnerability stems from a flaw in how PKCS7_verify() processes certificate chains for multi-signer PKCS7 structures. While the final signer's certificate chain is properly validated, intermediate signers do not undergo proper certificate chain verification, potentially allowing attackers to forge signatures using certificates that would normally fail validation.

Critical Impact

Unauthenticated attackers can bypass certificate chain verification in multi-signer PKCS7 objects, potentially allowing forged signatures to be accepted as valid, undermining the integrity guarantees that PKCS7 cryptographic signatures are designed to provide.

Affected Products

• AWS-LC versions prior to 1.69.0
• Applications using vulnerable AWS-LC versions for PKCS7 signature verification
• Systems processing PKCS7 structures with multiple signers

Discovery Timeline

• 2026-03-02 - CVE CVE-2026-3336 published to NVD
• 2026-03-03 - Last updated in NVD database

Technical Details for CVE-2026-3336

Vulnerability Analysis

This vulnerability is classified under CWE-295 (Improper Certificate Validation), a class of cryptographic vulnerabilities that occurs when an application fails to properly validate the certificate chain of trust. In the context of PKCS7_verify(), the function is responsible for verifying digital signatures on PKCS7 (Cryptographic Message Syntax) structures, which are commonly used for signing and encrypting data.

The flaw specifically manifests when processing PKCS7 objects containing multiple signers. In a properly implemented verification process, each signer's certificate should be validated against a trusted certificate chain to ensure the signature is authentic. However, due to improper validation logic in AWS-LC's implementation, only the final signer in a multi-signer PKCS7 structure undergoes complete certificate chain validation.

This creates a dangerous scenario where an attacker can craft a PKCS7 object with multiple signers, positioning their malicious or invalid certificates in any position except the last. The signatures from these intermediate signers would be accepted as valid despite failing certificate chain verification, effectively bypassing the trust model that PKCS7 signatures are designed to enforce.

Root Cause

The root cause of CVE-2026-3336 lies in the iteration logic within the PKCS7_verify() function when handling multi-signer PKCS7 structures. The certificate chain validation routine was only being invoked for the final signer in the signers list, rather than being applied to each signer independently. This represents a logic error in the implementation where the verification loop did not properly apply certificate chain checks at each iteration.

Attack Vector

This vulnerability is exploitable over the network without requiring authentication or user interaction. An attacker can exploit this vulnerability by:

1. Creating a malicious PKCS7 signed data structure containing multiple signer information blocks
2. Using an invalid, revoked, or self-signed certificate for all signers except the final one
3. Ensuring only the last signer has a valid certificate chain
4. Sending this crafted PKCS7 object to an application using a vulnerable version of AWS-LC for signature verification

The application would accept signatures from all signers as valid, even though intermediate signers' certificates should have failed chain validation. This could allow attackers to inject malicious content with forged signatures or bypass authentication mechanisms that rely on PKCS7 signature verification.

The vulnerability requires no special privileges and operates at the network level, making it remotely exploitable against any application accepting PKCS7 signed data from untrusted sources.

Detection Methods for CVE-2026-3336

Indicators of Compromise

• PKCS7 signed objects received from external sources containing an unusually high number of signers
• Signature verification operations that succeed despite certificate chain warnings in other components
• Applications accepting signed data with certificates that should have been rejected by chain validation
• Anomalous certificate usage patterns in cryptographic operations

Detection Strategies

• Audit applications for usage of PKCS7_verify() from AWS-LC versions prior to 1.69.0
• Implement monitoring for PKCS7 structures with multiple signers in high-security data flows
• Review code that processes externally-sourced signed data for vulnerable AWS-LC dependencies
• Deploy static analysis tools to identify AWS-LC version dependencies in application builds

Monitoring Recommendations

• Monitor cryptographic library versions deployed across infrastructure and flag AWS-LC versions below 1.69.0
• Implement logging around signature verification operations to detect potential exploitation attempts
• Track certificate validation events and correlate with PKCS7 processing activities
• Establish alerts for applications accepting multi-signer PKCS7 objects from untrusted sources

How to Mitigate CVE-2026-3336

Immediate Actions Required

• Upgrade AWS-LC to version 1.69.0 or later immediately in all affected applications
• Audit applications using AWS-LC to identify those processing PKCS7 structures with multiple signers
• Consider temporarily rejecting multi-signer PKCS7 objects until patching is complete
• Review any signed data accepted during the vulnerable period for potential integrity issues

Patch Information

AWS has released AWS-LC version 1.69.0 to address this vulnerability. According to the AWS Security Bulletin 2026-005, customers of AWS services do not need to take action as AWS has patched their services. However, applications using AWS-LC as a dependency should upgrade to version 1.69.0 or later.

The patched version is available from the AWS-LC GitHub repository. Additional technical details about the vulnerability are documented in the GitHub Security Advisory GHSA-cfwj-9wp5-wqvp.

Workarounds

• Restrict acceptance of multi-signer PKCS7 objects until the patch can be applied
• Implement additional certificate chain validation at the application layer for critical signing operations
• Use network segmentation to limit exposure of vulnerable applications processing signed data
• Consider using alternative cryptographic libraries for PKCS7 verification until patching is complete

# Verify AWS-LC version and upgrade
# Check current AWS-LC version in your build
cat CMakeLists.txt | grep -i "aws-lc"

# Update AWS-LC dependency to patched version
git clone --branch v1.69.0 https://github.com/aws/aws-lc.git
cd aws-lc
cmake -B build
cmake --build build