Description

In the Linux kernel, the following vulnerability has been resolved: s390/zcrypt: Validate length for CCA ECC private key requests cca_ecc2protkey() derives the copy length for the CPRB parameter block directly from the length field in the key token. Reject the request early if the token length exceeds the available space in the parameter block.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "7.8",
  "pubDate": "2026-08-13T15:19:57.847Z",
  "pubdate": "2026-08-13T15:19:57.847Z",
  "executiveSummary": "A vulnerability exists in the Linux kernel s390 zcrypt subsystem concerning the validation of CCA ECC private key requests. Specifically, the flaw resides in the handling of key tokens processed by the cca_ecc2protkey function. This weakness is classified as an input validation failure where copy lengths are derived directly from untrusted length fields contained within key tokens without prior boundary verification against available parameter block buffers. Successful exploitation of this vulnerability can lead to critical security implications, including potential out-of-bounds memory operations, kernel memory corruption, system instability, or denial of service conditions. Affected systems include Linux kernel implementations utilizing s390 cryptographic hardware architectures and zcrypt device drivers. An attacker with the capability to submit maliciously crafted cryptographic requests containing oversized key token length fields can trigger this condition. Exploitation requires local access or the ability to dispatch ioctl or cryptographic device requests to the zcrypt driver subsystem, allowing malicious payloads or invalid memory offsets to destabilize the kernel runtime environment.",
  "technicalDetails": "The vulnerability stems from insufficient input validation within the Linux kernel's s390 cryptographic subsystem, specifically inside the cca_ecc2protkey function handling CCA ECC private key requests. The root cause is the direct derivation of the copy length for the CPRB parameter block from the length field embedded within the untrusted key token, omitting any preliminary bounds checking to ensure the specified length does not exceed the statically or dynamically allocated space within the destination parameter block. When a malicious or malformed key token containing an excessively large length field is parsed, the downstream memory copy operations attempt to process data beyond the allocated boundaries of the parameter block. The vulnerable component is the s390 zcrypt driver subsystem, specifically the routine responsible for translating CCA ECC key tokens into protected keys. Exploitation occurs step-by-step as follows: first, an unprivileged or privileged local user constructs a malicious cryptographic request payload targeting the zcrypt subsystem, embedding a manipulated length parameter inside the CCA ECC key token structure. Second, the user submits this request to the kernel via standard cryptographic interfaces or device nodes. Third, the cca_ecc2protkey function reads the untrusted length field and computes the memory copy size without verifying if the length exceeds the available space in the CPRB parameter block. Fourth, the subsequent execution performs an out-of-bounds memory read or write operation based on the exaggerated length calculation. This leads to kernel memory corruption, potential kernel panics resulting in a denial of service, or unpredictable system behavior. The attack vector is local, requiring the execution of software capable of interacting with the s390 zcrypt device drivers. Authentication and privilege requirements depend on the access permissions enforced on the underlying zcrypt character devices, though local system users with access to cryptographic hardware interfaces may initiate the attack flow."
}