In the Linux kernel, the following vulnerability has been resolved: crypto: algif_skcipher - force synchronous processing on trees without ctx->state The AIO/async path in skcipher_recvmsg() passes the socket-wide ctx->iv directly into the skcipher request. After io_submit() the socket lock is dropped and the request is processed asynchronously, so a concurrent sendmsg(ALG_SET_IV) can overwrite ctx->iv and make the in-flight request run under an attacker-controlled IV. For CTR/stream modes this is IV/keystream reuse and lets an unprivileged user recover the plaintext of a concurrent operation. Snapshotting ctx->iv into per-request storage for the async path is not sufficient. For ciphers with statesize == 0 - which includes cbc and ctr - the MSG_MORE inter-chunk IV chaining is carried solely by the in-place req->iv writeback, which a snapshot redirects into per-request memory that af_alg_free_resources() releases on completion, silently producing wrong output. Writing the IV back fr
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-74578 is a race condition in the Linux kernel's cryptographic socket interface (algif_skcipher) where concurrent operations can manipulate initialization vectors (IVs) during asynchronous encryption processing. When an application uses AIO/async mode for symmetric cipher operations, the socket lock is released after submitting a request, allowing a malicious actor to overwrite the ctx->iv parameter via sendmsg(ALG_SET_IV) while the original request is still in flight. This forces the in-flight cryptographic operation to execute under an attacker-controlled IV, fundamentally compromising the security of stream ciphers like CTR mode. This vulnerability affects any Linux system running vulnerable kernel versions where applications rely on the AF_ALG socket interface for cryptographic operations—particularly relevant for containerized workloads, cryptocurrency applications, and secure communication tools that leverage kernel crypto APIs.
Casky's extended reasoning capabilities would detect this vulnerability by correlating multiple suspicious patterns: detecting rapid successive sendmsg() calls to ALG_SET_IV followed by incomplete AIO recvmsg() operations, identifying socket-level race conditions through timing analysis of crypto context modifications, and flagging asynchronous cryptographic operations that lack proper serialization controls. While MITRE ATT&CK mapping isn't available for this CVE, practitioners would observe findings aligned with T1040 (Traffic Capture/Redirection) and T1555 (Credentials in Files) patterns—specifically the manipulation of cryptographic material in transit. Casky would highlight the specific vulnerability pattern: applications using AF_ALG sockets with async mode that fail to implement socket-level synchronization, allowing attackers to inject malicious cryptographic parameters between request submission and completion.
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-74578. Run one and get CVSS-scored findings in 3 minutes.
Run the skill that detects this →© 2026 Casky.AI, Inc. · AI Security Investigation