/

CVE-2026-90819

Severity:

HIGH RISK

(7.3)

HTTP Response Splitting (CWE-93) in A2A Java Server

CVE-2026-90819

Deferred

Vulnerability type

Category:

HTTP Response Splitting

CWE:

CWE-93, CWE-113

Impact:

HTTP Header Injection and Response Manipulation

Severity:

HIGH RISK

(7.3)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A high-severity HTTP response-splitting weakness in the A2A Java SDK affects authorization header construction in the push notification sender. If attacker-controlled content reaches this code without adequate control-character filtering, a remote attacker may inject header or response-boundary data and influence HTTP message handling.

Affected context

The issue occurs in deployments using the A2A Java SDK's push notification functionality, specifically the BasePushNotificationSender.dispatchNotification path. Risk depends on whether externally influenced values can reach authorization header construction and whether intermediaries or clients process injected carriage-return or line-feed characters as HTTP delimiters.

Exploit preconditions

  • Attack surface: Network-accessible push notification or related HTTP request handling
  • Required access: Ability to influence a value incorporated into the authorization header or notification request
  • Trigger point: Construction and dispatch of the outbound HTTP request
  • Why exploitation is possible: Insufficient neutralization of CRLF characters can cause attacker-controlled data to be interpreted as additional HTTP header or response content

Why this happens

The underlying bug is improper handling of untrusted data during HTTP header construction. When control characters such as carriage return and line feed are allowed to flow into header values, protocol delimiters may be introduced into an HTTP message. This behavior maps to CWE-113: Improper Neutralization of CRLF Sequences in HTTP Headers, with CWE-93: Improper Neutralization of CRLF Sequences ('CRLF') also describing the injection weakness.

Potential impact

  • An attacker may inject or alter HTTP headers
  • A request or response may be interpreted as multiple HTTP messages
  • Downstream proxies, clients, or caches could process attacker-controlled content unexpectedly
  • Authentication metadata or request routing could be manipulated
  • Applications may experience cache poisoning, request smuggling-like behavior, or integrity loss depending on deployment architecture

General mitigation guidance

Mitigation generally focuses on keeping untrusted data out of protocol-sensitive header construction and enforcing strict output controls.

Common defensive patterns include:

  • Rejecting or safely encoding carriage-return and line-feed characters before header creation
  • Using HTTP client APIs that validate header names and values by default
  • Allowing authorization values only from tightly controlled formats and sources
  • Separating user-controlled data from authentication and transport metadata
  • Applying least-privilege credentials and limiting the permissions of notification services
  • Ensuring proxies, gateways, and application servers apply consistent HTTP parsing and header-validation policies

How teams detect issues like this

Organizations can identify related issues through:

  • Static analysis rules for concatenating untrusted data into HTTP headers
  • Code review checks for authorization, redirect, cookie, and custom-header construction
  • Tests that verify control characters are rejected at trust boundaries
  • Dependency and policy checks covering HTTP client behavior and header validation
  • Runtime monitoring for malformed headers, duplicate security headers, unexpected response boundaries, and anomalous notification requests

Automated code review tools may help flag flows from externally influenced inputs into header-building APIs.

Sources

SourceLink
github.comgithub.com/a2aproject/a2a-java/
github.comgithub.com/a2aproject/a2a-java/commit/247a655043f145f6f8e3853724b6a543eaa02001
github.comgithub.com/a2aproject/a2a-java/pull/1043
github.comgithub.com/a2aproject/a2a-java/pull/1053
github.comgithub.com/a2aproject/a2a-java/releases/tag/v1.3.0.Final
vuldb.comvuldb.com/cve/CVE-2026-90819
vuldb.comvuldb.com/submit/922996
vuldb.comvuldb.com/vuln/403322
vuldb.comvuldb.com/vuln/403322/cti

Frequently asked

questions

Yes. The reported attack surface is remotely reachable, but successful exploitation generally requires an attacker to influence data used while constructing the outbound authorization header.

Not necessarily. The required access depends on how notification inputs are exposed and validated by the surrounding application; any reachable path that permits control of the relevant value may be significant.

Prevent untrusted values from being used directly in protocol-sensitive headers, reject CRLF characters, and rely on HTTP libraries that enforce strict header-value validation.

Treat header values as security-sensitive output, validate them at trust boundaries, use narrowly defined formats for authorization data, and include CRLF-focused tests and static analysis in the development process.

Find out what's already
exploitable in your codebase.