In the Linux kernel, the following vulnerability has been resolved: udf: validate sparing table length as an entry count, not a byte count udf_load_sparable_map() accepts a sparing table when sizeof(*st) + le16_to_cpu(st->reallocationTableLen) > sb->s_blocksize is false, i.e. it treats reallocationTableLen as a number of BYTES that must fit in the block. But the table is walked as an array of 8-byte sparingEntry elements: for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) { struct sparingEntry *entry = &st->mapEntry[i]; ... entry->origLocation ... } in udf_get_pblock_spar15() and udf_relocate_blocks(). A reallocationTableLen of N therefore passes the check whenever sizeof(*st) + N <= blocksize, yet the consumers index sizeof(*st) + N * sizeof(struct sparingEntry) bytes -- up to ~8x the block. On a crafted UDF image this is an out-of-bounds read in udf_get_pblock_spar15(); udf_relocate_blocks() additionally feeds the same length to udf_update_tag(), whose crc_it
Casky was already ahead
This CVE exploits attack patterns that Casky's 0matched skills already investigate — long before this vulnerability was disclosed. Claude's reasoning model maps these techniques to MITRE ATT&CK, so practitioners who ran these skills have already seen the threat behaviour in their findings.
CVE-2026-64322 is a memory validation flaw in the Linux kernel's UDF filesystem driver where the sparing table length is incorrectly validated as a byte count rather than an entry count. The vulnerability exists in udf_load_sparable_map(), which checks if the table fits within a block using byte-level arithmetic, but then iterates through the table as an array of 8-byte sparingEntry structures. This mismatch allows an attacker to supply a malformed UDF filesystem image with an oversized sparing table that passes validation but causes out-of-bounds memory access during parsing. Systems mounting untrusted UDF media—including USB drives, optical discs, or container images—are affected, potentially leading to kernel information disclosure, denial of service, or privilege escalation depending on the memory accessed.
While CVE-2026-64322 lacks mapped MITRE ATT&CK techniques and no Casky skills directly correlate to this specific vulnerability, practitioners using Casky.ai would benefit from extended reasoning analysis around Memory Safety (CWE-119 class issues) and Filesystem Handling patterns. Claude's reasoning capability can identify the semantic gap between validation logic and iteration logic—a pattern common in Exploitation (T1203) and Local Privilege Escalation (T1134) attack chains. A practitioner reviewing kernel security findings would see this surface as improper input validation during filesystem mount operations, correlating to Defense Evasion (T1036) techniques where malformed structures bypass safety checks. Detection would involve monitoring for UDF mount attempts with anomalous table structures and kernel memory access violations.
Composite risk scoring from EPSS, CISA KEV, Shodan, and GreyNoise — 21 security APIs correlated into a single Casky Risk Score. Coming in Casky Pro. Join early access →
Casky has 0 skills that investigate the attack patterns behind CVE-2026-64322. Run one and get CVSS-scored findings in 3 minutes.
Run the skill that detects this →© 2026 Casky.AI, Inc. · AI Security Investigation