CVE-2026-120317 in http4k
Summary
by MITRE • 11/02/2026
http4k from 4.9.10.0 before 6.60.0.0 contains a missing integrity check vulnerability because DigestEncoder computes the auth-int digest without hashing the request entity body. On-path attackers on non-TLS channels can rewrite the body of authenticated requests while keeping the Authorization header valid, executing state-changing actions as the victim.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/02/2026
The http4k library, specifically versions ranging from 4.9.10.0 up to but not including 6.60.0.0, contains a critical security flaw related to HTTP Digest authentication integrity verification. This vulnerability stems from an incorrect implementation of the auth-int digest calculation within the DigestEncoder component. In standard HTTP Digest Authentication protocols defined by RFC 2617 and updated in RFC 7616, when the qop parameter is set to auth-int or auth-int-qop, the server must verify that the request body has not been altered during transmission. This verification relies on computing a hash of both the authentication parameters and the actual content of the request entity body. The flaw in http4k arises because the DigestEncoder computes the digest using only the header fields and other metadata while completely omitting the hashing of the request entity body itself. Consequently, the integrity check fails to detect any modifications made to the payload after the initial authorization token was generated.
This technical deficiency creates a severe risk for applications relying on this library for secure communication over non-TLS channels or scenarios where TLS termination occurs at an intermediate proxy that does not preserve message integrity checks properly. An attacker positioned on-path, such as in a man-in-the-middle scenario within an unencrypted network segment, can intercept authenticated requests and modify the request body to alter state-changing actions without invalidating the Authorization header. Because the server validates the digest based solely on headers and ignores the payload content, it accepts the tampered request as legitimate. This allows the attacker to execute unauthorized operations under the identity of the victim user, effectively bypassing authentication integrity controls designed to prevent replay attacks or data manipulation.
The operational impact of this vulnerability is significant for any service that processes mutable state through HTTP methods such as POST, PUT, or PATCH using Digest Authentication without mandatory TLS encryption. Attackers can change parameters in JSON payloads, form submissions, or other body formats to escalate privileges, transfer funds, modify user profiles, or trigger destructive actions while maintaining a valid authentication signature. This undermines the core security guarantee of integrity provided by auth-int qop values and exposes systems to unauthorized state changes that appear authentic from the server's perspective. The vulnerability is particularly dangerous in microservices architectures where internal services might communicate using Digest Authentication over unencrypted HTTP for performance reasons, assuming that network-level controls provide sufficient protection without realizing that on-path attackers can exploit this specific implementation gap.
To mitigate this risk, organizations should immediately upgrade http4k to version 6.60.0.0 or later, which corrects the digest computation logic to include the request entity body in the hash calculation as required by protocol standards. For environments where upgrading is not immediately feasible, it is imperative to enforce Transport Layer Security (TLS) for all communications involving Digest Authentication. By encrypting the entire HTTP transaction including headers and bodies, TLS prevents on-path attackers from modifying any part of the message, thereby neutralizing this specific integrity bypass technique. Additionally, developers should review their authentication strategies and consider migrating to more robust mechanisms such as OAuth 2.0 with JWTs or mutual TLS where appropriate, which provide stronger guarantees for both identity verification and data integrity without relying solely on HTTP Digest Authentication complexities that are prone to implementation errors.
This vulnerability aligns with CWE-354, the Improper Validation of Integrity Check Value, specifically in contexts involving cryptographic hash functions used for message authentication. It also maps to MITRE ATT&CK technique T1078, Valid Accounts, as it allows an attacker to maintain valid credentials while altering request content to perform unauthorized actions. Furthermore, the exploitation vector relates to T1557, Adversary-in-the-Middle, where the attacker intercepts and modifies communications between two parties who believe they are directly communicating with each other. Understanding these classifications helps in contextualizing the severity within broader security frameworks and ensures that remediation efforts address not just the code defect but also the architectural assumptions regarding network trust boundaries.