Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach A2A server JSON-RPC/REST endpoint
-
ExploitSend request that forces internal fault
-
ExecutionTrigger unsanitized INTERNAL_ERROR path
-
ImpactRead leaked server-side diagnostic detail
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V14 - Data Protection Data exposure prevention
MITRE ATT&CK
2 techniques across 2 tactics: Collection, Discovery The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The disclosure occurs only when the server itself hits an internal error whose detailed message was previously returned to the client unsanitized - specifically serialization/ProtoJSON stream serialization faults, HttpPushSender failures, extended-agent-card handler faults, or broadcast subscription lag - all of which pre-patch surfaced the raw internal detail (the tests reference leaked strings such as a filesystem path like /etc/server/keys.pem). Exploitation is remote and unauthenticated (PR:N), but is LIMITED by the need to actually induce one of these internal fault conditions and by the fact that only low-sensitivity diagnostic/implementation detail is exposed (VC:L), not guaranteed credentials or user data. Affects a2a-rs 0.4.0 through 0.4.3 running the a2a-server component; fixed by the sanitized_internal_error change. |
| Impact | All signals point to a genuine but modest-severity information-disclosure issue rather than a top-tier priority. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:L, score 6.9) indicates a remotely reachable, low-complexity, unauthenticated flaw, but with only LOW confidentiality impact and no integrity or availability impact (VI:N/VA:N) - consistent with leaking internal error detail rather than sensitive secrets. There is NO CISA KEV listing and NO public exploit code referenced in the data, so exploitation status is 'no public exploit identified at time of analysis'. No EPSS score was provided, so exploitation probability cannot be quantified. The SSVC framework data (exploitation/automatable/technical-impact) was not supplied. The 6.9 base score is somewhat inflated for what the source evidence shows is disclosure of server-side diagnostic strings (serialization faults, internal file paths); the CWE-209 class remediation (sanitizing INTERNAL_ERROR messages) confirms the real-world impact is diagnostic leakage, which is a hardening/defense-in-depth issue more than a critical breach vector. Net: real but low-urgency - patch during normal maintenance, not an emergency. |
| Exploit ScenarioDerived | A remote, unauthenticated attacker sends malformed or edge-case requests to the a2a-rs server's JSON-RPC or REST endpoints to force an internal server fault (e.g., a payload serialization failure, a push-notification sender error, or a broadcast subscription that falls behind). Pre-patch, the server returned the raw internal error message verbatim to the client, potentially exposing server-side detail such as internal file paths or implementation state. No public proof-of-concept is referenced in the provided data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Error-message information disclosure in the a2a-rs Rust agent-to-agent server (a2a-server component) versions 0.4.0 through 0.4.3 lets remote, unauthenticated clients learn internal server detail when the framework returns raw diagnostic text in INTERNAL_ERROR responses. The leak surfaces only when the server itself faults - ProtoJSON stream serialization failures, HttpPushSender errors, extended-agent-card handler faults, or broadcast subscription lag - where pre-patch code passed the underlying detail (the project's own tests use a leaked filesystem path such as /etc/server/keys.pem as the example) straight to the caller instead of a generic message. Impact is limited to low-sensitivity diagnostic and implementation detail, not guaranteed credentials or user data, and no public exploit was identified at time of analysis; the issue is fixed by the sanitized_internal_error refactor in commit 713b943af94ab2d521d483b841618b97a2e78a4d (PR #127).
RemediationAI
Vendor-released patch: apply commit 713b943af94ab2d521d483b841618b97a2e78a4d (merged as https://github.com/a2aproject/a2a-rs/pull/127), which adds sanitized_internal_error() and routes every server-side internal fault through it; a tagged release above 0.4.3 is not independently confirmed in the supplied data, so pin to the commit or to the first release containing it and verify the changelog before rolling out. Because the sanitization is compiled into the error path there is no runtime toggle, so interim compensating controls on 0.4.0-0.4.3 must sit in front of the server: terminate traffic at a reverse proxy or API gateway that rewrites the "message" field of HTTP 500 / JSON-RPC INTERNAL_ERROR bodies to a generic string (trade-off: it also strips legitimate AgentExecutor failure detail and any client logic that branches on error text will degrade), restrict network access to the REST/ProtoJSON streaming and extended-agent-card endpoints to trusted callers with mTLS or IP allow-listing (trade-off: blocks legitimate remote agents, so scope it to the window before patching), and rate-limit or schema-validate inbound requests to make it harder to induce the serialization and push-sender faults that trigger disclosure (trade-off: throughput reduction and possible false positives on large payloads). Keep server-side tracing enabled after patching, since the real cause now only appears in logs; storage or forwarding of those logs should still be access-controlled because they retain the diagnostic detail the client no longer sees.
Affected VersionsENISA
Affected Packages
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
a2a-rs is a Rust implementation of the A2A (Agent-to-Agent) protocol, exposing a JSON-RPC transport (a2a-server/src/jsonrpc.rs), a REST/ProtoJSON transport (a2a-server/src/rest.rs), server-push delivery (a2a-server/src/push/sender.rs), and streaming task subscriptions built on a tokio broadcast channel (a2a-server/src/handler.rs). Pre-patch, internal faults constructed via A2AError::internal() carried their full source string - serde/ProtoJSON serialization errors, push-sender failure messages, extended-agent-card handler errors, and broadcast RecvError::Lagged internals - out to the client in the JSON-RPC/REST error body. The fix introduces sanitized_internal_error() in a2a-server/src/lib.rs, which logs the real cause with tracing::error! server-side and returns the static string "Internal error" to the caller, and deliberately moves sanitization from the response boundary to the raise site: the patch's tests document that the boundary cannot distinguish an AgentExecutor's own failure report (which A2A only lets executors express as INTERNAL_ERROR) from a server fault, so boundary rewriting would erase legitimate agent diagnostics. The commit also threads the generic type through protojson_stream and stops the subscription stream from spinning after a lag by setting the done flag. The reported CWE is CWE-200 (exposure of sensitive information); the upstream code comment cites CWE-209 (generation of error message containing sensitive information), which more precisely describes the root-cause class. Because the leaked strings are diagnostics rather than user records, the assessed vector is AV:N/AC:L/PR:N/UI:N with only C:L and no integrity or availability impact.
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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Remotely reachable JSON-RPC/REST API needing no auth to trigger an internal error path (AV:N/AC:L/PR:N/UI:N); only low-sensitivity diagnostic detail leaks (C:L), with no integrity or availability impact.
Primary rating from Vendor (vuldb).
CVSS VectorVendor: vuldb
DescriptionCVE.org
A vulnerability was determined in a2aproject a2a-rs up to 0.4.3. This issue affects some unknown processing of the file a2a-server/src/error.rs. Executing a manipulation can lead to information exposure through error message. The attack can be executed remotely. This patch is called 713b943af94ab2d521d483b841618b97a2e78a4d. A patch should be applied to remediate this issue.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-106872
GHSA-fjv6-497g-h4xf
NVD
CVE.org
EPSS
VulDB
Exploit-DB