Description

In the Linux kernel, the following vulnerability has been resolved: s390/zcrypt: Improve EP11 CPRB domain handling with ASN.1 parsing The zcrypt_msgtype6_send_ep11_cprb() function uses fragile struct overlays to access and modify the domain field in the EP11 CPRB payload, creating maintainability and security concerns: 1. Struct overlay approach (pld_hdr) assumes fixed payload structure and doesn't validate the actual ASN.1 encoding. 2. Complex length format detection logic is error-prone and doesn't properly validate bounds at each parsing step. 3. Direct struct member access bypasses proper ASN.1 validation. Fix by replacing struct overlays with explicit ASN.1 parsing that validates each field (payload tag/length, function tag/length/value, optional domain tag/length/value) with proper bounds checking at every step. Add asn1_int_encode() helper function to safely write integer values with correct endianness conversion. This makes the code consistent with the validation pattern introduced with the rework of the xcrb_msg_to_type6_ep11cprb_msgx() function.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "7.8",
  "pubDate": "2026-08-26T15:17:08.763Z",
  "pubdate": "2026-08-26T15:17:08.763Z",
  "executiveSummary": "The Linux kernel's s390 zcrypt subsystem is susceptible to a vulnerability within the EP11 CPRB domain handling logic. The issue arises from the use of fragile struct overlays to manage and modify ASN.1-encoded payloads, which lacks rigorous bounds checking and structural validation. This defect allows for potential memory corruption or malformed data handling when processing cryptographic requests. The vulnerability affects the zcrypt_msgtype6_send_ep11_cprb function, which could be exploited by local attackers to cause system instability or bypass security controls by injecting specially crafted payloads. The primary risk involves the kernel's reliance on unsafe data structures that assume static payload geometry in an inherently variable ASN.1-encoded environment. Mitigation requires upgrading the kernel to a version containing the explicit ASN.1 parsing implementation, which introduces mandatory field validation and bounds checking, thereby ensuring the integrity of cryptographic message processing.",
  "technicalDetails": "The vulnerability resides in the zcrypt_msgtype6_send_ep11_cprb() function within the s390 zcrypt driver, specifically in how the EP11 CPRB (Cryptographic Parameter Request Block) payload is parsed and modified. Historically, the kernel utilized direct struct overlays (pld_hdr) to map directly onto the binary payload buffer. This approach assumed a rigid, fixed-length structure, failing to account for the dynamic and flexible nature of ASN.1 encoding.\nThe root cause is a lack of rigorous input validation during the parsing of the ASN.1 stream. Because the implementation relied on hardcoded struct offsets, it failed to perform field-level verification of tags, lengths, and values. Furthermore, the length detection logic for variable-length ASN.1 fields was prone to errors, as it did not enforce strict bounds checking at each recursive parsing step. An attacker could provide a malicious payload where the length fields are intentionally mismatched or overflow the expected buffer boundaries, potentially leading to out-of-bounds reads or writes within kernel memory.\nThe attack flow involves the submission of a crafted EP11 CPRB message from a user-space application capable of interacting with the /dev/zcrypt device. When zcrypt_msgtype6_send_ep11_cprb processes this message, the lack of validation allows the attacker to influence domain field updates in an unintended manner. By manipulating the ASN.1 structure, an attacker may induce a state where the kernel writes to incorrect memory addresses or misinterprets subsequent control sequences. Since this occurs within the kernel's privileged execution context, an attacker can leverage this primitive for kernel memory corruption.\nThe remediation replaces the fragile struct-based overlay mechanism with a robust ASN.1 parser. This parser performs explicit validation for every ASN.1 component, including the payload tag, function tag, and domain tag. By validating the length and value of each field before processing, the system ensures that the internal representation remains consistent with the actual payload contents. The introduction of the asn1_int_encode() helper function further ensures that integer values are written using correct endianness conversion, preventing logical inconsistencies that could be triggered by architecture-specific differences in bit-field ordering."
}