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.

