CVE-2026-73242: 
Wolfi vulnerability analysis and mitigation

CVE-2026-73242 is a heap-based buffer overflow (out-of-bounds read/write) vulnerability in FreeRDP's Kerberos SSPI decryption logic, specifically in the kerberos_DecryptMessage function within winpr/libwinpr/sspi/Kerberos/kerberos.c. The flaw allows a malicious RDP peer to trigger out-of-bounds memory reads and in-place writes during CredSSP/NLA Kerberos authentication by supplying an unbounded GSS Wrap-token EC field. All FreeRDP versions prior to 3.30.0 with Kerberos support (WITH_KRB5 builds) are affected. The vulnerability was disclosed on August 11, 2026, and carries a CVSS v4.0 base score of 8.3 (High) (GitHub Advisory, FreeRDP Release).

The root cause is improper input validation (CWE-122: Heap-based Buffer Overflow; CWE-125: Out-of-bounds Read) in kerberos_DecryptMessage(). The function reads the peer-controlled 16-bit EC (extra count) field from a GSS Wrap token (RFC 4121 §4.2.6.2) but never validates it against the buffer size before using it in IOV pointer arithmetic: iov[0].data.data = (char*)&header[16 + rrc + ec] and iov[2].data.data = (char*)&header[16 + ec]. While RRC and the total buffer length are validated, EC is unconstrained (0–0xFFFF), allowing an attacker to shift IOV base pointers up to ~64 KB past a ~60-byte heap allocation. Because AES-CTS-HMAC enctypes used by RDP NLA follow a decrypt-then-verify pattern, krb5_k_decrypt_iov() performs the out-of-bounds read and in-place write before the HMAC integrity check can fail. The vulnerability is reachable from both directions: a malicious server targeting a FreeRDP client, and an authenticated client targeting a FreeRDP server, via nla_recv/nla_server_recv → credssp_auth_decrypt → DecryptMessage (GitHub Advisory, Fix Commit).

Successful exploitation can result in heap memory corruption, potential leakage of sensitive heap contents (confidentiality impact), limited in-place memory writes at attacker-controlled offsets (integrity impact), and process crashes causing denial of service (high availability impact). The vulnerability is exploitable in both client and server roles, meaning a compromised RDP server could attack connecting FreeRDP clients, and a malicious client could attack FreeRDP-based servers. Sensitive data processed during the Kerberos NLA authentication handshake — including session key material — may be exposed or corrupted (GitHub Advisory).

A harness-style proof-of-concept reproducer is publicly available in the GitHub security advisory, demonstrating the heap-buffer-overflow via AddressSanitizer output with EC=0xFFFF. Exploitation requires a completed Kerberos NLA handshake context (a KDC, a service keytab, and a peer that finishes the Kerberos exchange before sending the malformed token), making it network-exploitable with high attack complexity and no privileges required. The EPSS score is 0.0 as of initial publication, and there is no evidence of in-the-wild exploitation or CISA KEV catalog listing at this time. The vulnerability was discovered using AI-assisted security research by Anthropic (Claude) and validated by Ada Logics (GitHub Advisory).

1. Prerequisite — Establish Kerberos NLA context: The attacker must first complete a legitimate Kerberos NLA handshake with the target FreeRDP client or server, obtaining a valid AES256-CTS-HMAC-SHA1-96 session key and Kerberos SSPI context. This requires access to a KDC and a service keytab (for server-side attack) or the ability to act as a malicious RDP server.
2. Craft malicious GSS Wrap token: Construct a 60-byte GSS Wrap token (RFC 4121) with TOK_ID = TOK_ID_WRAP, RRC = 28 (valid for AES256-CTS-HMAC-SHA1-96), and EC = 0xFFFF (maximum 16-bit value). The token passes the existing length check (cbBuffer == 16 + rrc + iov[0].data.length) because EC is not included in that validation.
3. Deliver token via CredSSP/NLA: Send the malformed token as the pubKeyAuth or authInfo blob during the CredSSP authentication phase. The token is processed by nla_recv/nla_server_recv → credssp_auth_decrypt → kerberos_DecryptMessage.
4. Trigger out-of-bounds access: kerberos_DecryptMessage computes iov[2].data.data = header + 16 + 0xFFFF = header + 65551, placing the IOV pointer ~64 KB past the 60-byte heap allocation. krb5_k_decrypt_iov() then reads and writes at this out-of-bounds address before the HMAC check.
5. Achieve impact: Depending on heap layout, the attacker may cause a process crash (DoS), read adjacent heap memory (information disclosure), or corrupt heap metadata/adjacent objects for potential further exploitation (GitHub Advisory).

• Network: Unexpected or repeated RDP NLA/CredSSP handshake attempts that complete Kerberos authentication but then send malformed pubKeyAuth or authInfo blobs; RDP connections from unusual source IPs that complete authentication but immediately trigger errors.
• Logs: FreeRDP process crashes or SEC_E_INVALID_TOKEN / SEC_E_INTERNAL_ERROR return codes logged during CredSSP decryption; AddressSanitizer heap-buffer-overflow reports referencing kerberos_DecryptMessage in winpr/libwinpr/sspi/Kerberos/kerberos.c if built with ASan.
• Process: Unexpected termination of FreeRDP client or server processes during or immediately after NLA authentication; core dumps from the FreeRDP process referencing krb5_k_decrypt_iov or k5_iov_cursor_get in the stack trace.
• File System: Core dump files generated by FreeRDP processes in /tmp, /var/crash, or the working directory, with stack traces involving kerberos_DecryptMessage and AES decryption functions (GitHub Advisory).

Upgrade FreeRDP to version 3.30.0 or later, which adds bounds checks on the EC field before computing IOV pointer offsets in kerberos_DecryptMessage(). The fix validates that 16 + rrc + ec + iov[0].data.length and 16 + ec + iov[2].data.length do not exceed sig_buffer->cbBuffer, returning SEC_E_INVALID_TOKEN for out-of-bounds values. Since FreeRDP's legitimate RDP-NLA implementation always sends EC = 0, rejecting non-zero EC values is also a safe workaround for environments that cannot immediately upgrade. Organizations should prioritize patching internet-facing FreeRDP deployments and those used in environments with untrusted RDP peers (FreeRDP Release, Fix Commit).

The FreeRDP maintainer (akallabeth) published the advisory and fix on July 15–16, 2026, describing it as a "security and bugfix release" with the patch "highly recommended" due to a "severe server side issue." The vulnerability was notably discovered through AI-assisted security research by Anthropic using Claude agents, with Ada Logics (credited to DavidKorczynski) performing manual validation and responsible disclosure — representing a notable example of AI-driven vulnerability discovery in open-source security. The advisory notes the reproducer was harness-style rather than a full end-to-end exploit, reflecting the complexity of the required Kerberos NLA preconditions (FreeRDP Release, GitHub Advisory).