Skip to main content

cpp-httplib EUVDEUVD-2026-101593

| CVE-2026-103930 LOW
HTTP Response Splitting (CWE-113)
2026-10-14 security-advisories@github.com
3.7
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Supply CRLF-bearing input to embedding app
  2. Exploit
    Reach open_stream path unencoded
  3. Execution
    Split outbound HTTP/1.1 request line
  4. Impact
    Inject attacker-controlled request metadata to backend

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization HTTP response header sanitization
Exploitation Conditions

Two conditions must both hold: (1) the embedding application must pass remote attacker-controlled input as the request path into Client::open_stream - or into the client path with set_path_encode(false), such as a decoded redirect Location - so that detail::write_request_line() is reached without detail::encode_path() sanitization; and (2) a backend server or intermediary proxy must interpret the injected raw CR/LF bytes as request-line/header boundaries. Limiting factors that reduce realistic risk: this requires a non-default usage pattern in the host application (default buffered request path is not affected), impact is limited to integrity of request data (no confidentiality or availability loss), and only versions 0.29.0 through 0.50.x are affected (fixed in 0.51.0). No authentication is required by the library itself (PR:N), but the application-side misuse requirement makes opportunistic exploitation impractical (AC:H).

Impact

This is a low-priority, defense-in-depth fix rather than an urgent threat. The NVD CVSS 3.1 score of 3.7 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) is driven down by high attack complexity (AC:H) and a limited, integrity-only impact (I:L; C:N/A:N) - consistent with the advisory's statement that the established impact is modification of backend-visible request data, not direct confidentiality or availability loss. No EPSS score was supplied in the input, and the CVE is not listed in CISA KEV; no public exploit code was referenced, so there is no public exploit identified at time of analysis. The signals are internally consistent: a genuinely networked vector (AV:N, PR:N on the library itself) but gated by AC:H because real-world exploitation depends on an embedding application misusing open_stream and on a downstream parser honoring the injected CR/LF. The one nuance to verify: PR:N reflects that cpp-httplib imposes no authentication, but exploitation requires a non-default coding pattern in the host application (passing raw remote input into open_stream, typically with path encoding disabled) - this application-side precondition, not any library credential, is the real limiter and is already captured by AC:H.

Exploit ScenarioDerived

An application embeds cpp-httplib (0.29.0-0.50.x) and passes attacker-controlled input - for example a decoded redirect Location under set_path_encode(false) - as the request path into Client::open_stream, which skips encode_path(). The attacker supplies a value containing CR/LF (e.g. a %0D%0A sequence that decodes to raw carriage-return/line-feed), splitting the outbound HTTP/1.1 request line and injecting attacker-shaped headers or an entire second request that a backend or intermediary then interprets. No public proof-of-concept was referenced, and the high attack complexity reflects the required application misuse and a cooperating downstream parser.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

Request-line injection in cpp-httplib 0.29.0 through 0.50.x lets a caller-controlled path that reaches Client::open_stream() - or any client path when set_path_encode(false) is in effect, such as a decoded redirect Location - carry raw CR/LF bytes into detail::write_request_line() and split the outbound HTTP/1.1 request line, injecting attacker-shaped request metadata that a downstream backend or intermediary may honor. The library itself requires no authentication (CVSS vector PR:N), but practical exploitation needs two coinciding conditions: the embedding application must forward remote input into that unsanitized path, and the receiving server or proxy must interpret the injected bytes as header or request boundaries. Impact is integrity-only (I:L) with no confidentiality or availability effect, no public exploit code has been identified at time of analysis, and the vendor fix is released in 0.51.0, making this a low-priority defense-in-depth issue rather than an urgent threat.

RemediationAI

Vendor-released patch: upgrade cpp-httplib to 0.51.0 (https://github.com/yhirose/cpp-httplib/releases/tag/v0.51.0); if a full upgrade is not possible, backport commit 255c075b82cf9f221e6e607e8e6789e6e2bf4c2a (PR #2501), which adds the fields::is_field_value() target check in write_request_line() and makes the client return Error::Write rather than putting a request-line-less, header-injecting request on the wire. As compensating controls, applications that cannot patch immediately should leave path encoding enabled (the default) - do not call set_path_encode(false) - and must not feed untrusted or decoded values such as redirect Location strings into open_stream() or any client path; validate or percent-encode CR (0x0D) and LF (0x0A) out of path values before they reach the library, accepting that this may break upstream routing for the rare backend that legitimately expects raw control bytes in a target. Defense-in-depth on the receiving side - a backend or proxy that rejects malformed request lines and duplicate headers - limits the consequence of any injected bytes, but does not fix the client-side flaw and should not be relied on in place of the 0.51.0 upgrade. Note the behavioral side effect of the patch: requests with CR/LF in the target now fail with Error::Write instead of silently succeeding, so callers should handle that error return.

Affected VersionsENISA

cpp-httplib 0.29.0, < 0.51.0

Affected Packages

euvd cpp_httplib fix: 0.51.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The flaw is CWE-113 (improper neutralization of CRLF sequences in HTTP headers, i.e. HTTP request/response splitting) in cpp-httplib, a header-only C++ HTTP/HTTPS library (also buildable in a 'split' configuration where split.py moves inline definitions into httplib.cc). The ordinary buffered request path sanitizes the request target through detail::encode_path() before writing it, but the streaming path used by Client::open_stream() reached detail::write_request_line() directly, so a path containing 0x0D/0x0A passed through verbatim and terminated the request line early, letting the remaining bytes be parsed as extra headers or an entirely separate request. The upstream fix (commit 255c075b82cf9f221e6e607e8e6789e6e2bf4c2a, PR #2501) reuses the existing fields::is_field_value() validation already applied to header values in check_and_write_headers and to the target in perform_websocket_handshake, causing write_request_line() to return -1 and the client to fail cleanly with Error::Write instead of emitting a malformed request. No CPE identifiers were supplied in the intelligence feed, so affected coverage is derived from the vendor advisory GHSA-vq69-f637-8fhr and the 0.29.0/0.51.0 version boundaries.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 3.7 LOW
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N
vuln.today AI 3.7 LOW

Network-reachable with no library authentication (AV:N/PR:N), but gated by required application misuse and a cooperating backend parser (AC:H); integrity-only request modification (I:L, C:N/A:N).

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
Low
Availability
None

Lifecycle Timeline

1
Patch available
Oct 14, 2026 - 20:34 EUVD

DescriptionCVE.org

cpp-httplib is a C++ header-only HTTP/HTTPS library. From 0.29.0 until 0.51.0, Client::open_stream in httplib.h accepts a caller-controlled path that reaches detail::write_request_line() without the detail::encode_path() protection used by the ordinary buffered request path. Raw carriage-return and line-feed bytes in the path can therefore split the outbound HTTP/1.1 request line and inject attacker-shaped request metadata. Exploitation requires an embedding application to pass remote user input into the open_stream path and a backend or intermediary that interprets the injected bytes; the established impact is modification of backend-visible request data, not direct confidentiality or availability impact. This issue is fixed in version 0.51.0.

Threat Intelligence Overview

EPSS Score
0.4%
Top 71% exploitable
Prevalence
Medium
popular header-only C++ HTTP library embedded in many applications, not ubiquitous
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity LOW
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

18
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +18
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy