EUVD-2026-106878
GHSA-5mcc-8c36-qxp4
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate to A2A server
-
ExploitSend concurrent cancel requests for same task
-
ExecutionBoth pass check-then-act window
-
ImpactCorrupt/inconsistent task state
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Concurrency control, locking
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an authenticated client (PR:L) able to submit task operations to an A2A server configured with the in-memory task store backend (InMemoryTaskStore). The attacker must issue concurrent cancel/update requests for the same task ID and win the check-then-act timing window between the terminal-state check and the state write. Limiting factors: valid API access/credentials are required (not unauthenticated), the vulnerable InMemoryTaskStore backend must be in use, the impact is limited to task-state inconsistency (no confidentiality loss, low integrity/availability effect), and success is probabilistic because it depends on hitting a narrow concurrency window. |
| Impact | This is a moderate, not urgent, issue. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:L/VA:L) scores 5.3 (Medium) and describes a network-reachable but authenticated (PR:L) check-then-act race condition (CWE-362) with only low integrity and availability impact and no confidentiality impact. No EPSS score, no CISA KEV listing, and no public exploit were provided, so exploitation remains theoretical: no public exploit identified at time of analysis. The source diff confirms the real defect is a concurrency window in the task-cancel flow where two simultaneous cancel requests could both pass the terminal-state check before either commits, leaving task state inconsistent - an integrity/consistency problem, not data exposure. NOTE A CONFLICT: the input tag 'Information Disclosure' contradicts the CVSS vector (VC:N, no confidentiality impact) and the actual code evidence, which shows a state-transition race, not a disclosure flaw - treat the disclosure characterization as unverified. Net: a legitimate but low-severity correctness/robustness bug in a niche library, suitable for routine patching rather than emergency response. |
| Exploit ScenarioDerived | An authenticated client of an A2A server backed by InMemoryTaskStore issues two concurrent cancel (or update) requests for the same in-flight task, racing the check-then-act window so both pass the pre-cancel terminal-state check. The result is an inconsistent or double-applied task state transition rather than code execution or data theft. No public exploit code is known; triggering it requires simply sending concurrent requests and winning a timing window. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Concurrent task operations in the a2a-rs Rust A2A server (through 0.4.4) can drive the in-memory task store into an inconsistent state, because InMemoryTaskStore::update performs a check-then-act sequence on a task's state without holding a lock across the decision and the write. An authenticated client able to submit task operations, and able to issue concurrent cancel or update requests for the same task ID, can win the timing window and overwrite a terminal task state or cause both of two competing cancels to be processed; impact is limited to task-state integrity and low availability effects, with no confidentiality loss. Exploitation requires the in-memory backend to be configured and is probabilistic, and no public exploit code was identified at time of analysis; CISA KEV does not list this issue.
RemediationAI
Patch status: upstream fix available (PR/commit); a released patched version is not independently confirmed, so upgrade a2a-rs to a release containing commit 7050c7d329238539424ee46440e23b91c4825bee (the change merged via https://github.com/a2aproject/a2a-rs/pull/126; the repository is https://github.com/a2aproject/a2a-rs/) and rebuild the a2a-server crate, or pin the dependency to that commit if no tagged release exists. The patch adds begin_cancel, which holds the write lock across the terminal-state check and the transition to CANCELED, and rejects overwriting a terminal task state while still allowing idempotent re-emission of the same terminal state. If upgrading immediately is not possible, compensating controls with their trade-offs are: (1) serialize cancel and update operations per task ID in the application layer with a per-task async mutex or a single-writer queue wrapped around the handler, which closes the timing window but reduces concurrency and adds latency to task operations; (2) replace InMemoryTaskStore with a durable backend that provides atomic conditional updates (compare-and-set on task version/state), which removes the in-process race but introduces an external dependency and its own failure modes; (3) restrict the A2A task API to trusted, low-concurrency clients (for example by requiring strong credentials and rate-limiting cancel/update per task ID), which lowers the probability of winning the timing window without eliminating it; and (4) monitor for repeated cancel/update requests on the same task ID as a detection signal, noting this is detective rather than preventive. There is no vendor advisory with a version-specific fix number in the provided references; consult the GitHub commit and PR above for the authoritative change.
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 Agent2Agent (A2A) protocol, and the affected code lives in the a2a-server crate's task store layer (a2a-server/src/task_store/inmemory.rs) plus the request handler (a2a-server/src/handler.rs). The InMemoryTaskStore keeps tasks in an async Tokio RwLock-protected map; CWE-362 (race condition / concurrent execution using shared resource with improper synchronization) manifests because the store's update path read the entry's current state, validated the transition, and only then mutated it, leaving a check-then-act window when the lock was not held across both steps. The upstream fix (PR #126, commit 7050c7d329238539424ee46440e23b91c4825bee) addresses two related defects: BUG-43, where a terminal task state (Canceled, Failed, Completed) could be overwritten by a different state, and BUG-44, where two concurrent cancel requests could both pass the terminal-state check in the handler. The patch enforces terminal-state immutability in update (re-applying the same terminal state remains allowed for idempotent re-emission) and adds a begin_cancel method that holds the write lock across the check and the transition to CANCELED, returning TASK_NOT_CANCELABLE for already-terminal tasks while preserving idempotent cancel semantics in the handler. Regression tests (test_update_terminal_state_rejected, test_update_terminal_same_state_allowed, test_begin_cancel_transitions_non_terminal, test_cancel_task_concurrent_both_succeed_idempotently) accompany the change. The relevant attack surface is the A2A task cancel/update API rather than raw memory corruption, and the affected deployment shape is a server using the in-memory task store rather than a durable, transactionally consistent backend.
Know when Rust gets its next vulnerability
- 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:L/UI:N/VC:N/VI:L/VA:L/SC:N/SI:N/SA:N
Network-reachable but needs authenticated task access (PR:L) and winning a timing window (AC:H); only task-state consistency is affected, so I:L with C:N and A:N.
Primary rating from Vendor (vuldb).
CVSS VectorVendor: vuldb
DescriptionCVE.org
A security flaw has been discovered in a2aproject a2a-rs up to 0.4.4. The affected element is the function InMemoryTaskStore::update of the file a2a-server/src/task_store/inmemory.rs. The manipulation results in race condition. The attack may be performed from remote. The patch is identified as 7050c7d329238539424ee46440e23b91c4825bee. It is advisable to implement a patch to correct this issue.
Threat Intelligence Overview
NVD
CVE.org
EPSS
VulDB
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
Race conditions occur when multiple concurrent requests exploit the brief time gap between checking a condition and acting upon it (TOCTOU - Time of Check, Time of Use).
Related Vulnerabilities in a2a-rs Information Disclosure and Race Condition
View all 2Command injection via Windows CreateProcess argument parsing affects multiple language runtimes and tooling (Node.js, PH
In the standard library in Rust before 1.52.0, a double free can occur in the Vec::from_iter function if freeing the ele
In the standard library in Rust before 1.52.0, the Zip implementation can report an incorrect size due to an integer ove
Stored cross-site scripting and open redirect in Warpgate's SSO endpoints (versions prior to 0.25.5) allow an unauthenti
library/std/src/net/parser.rs in Rust before 1.53.0 does not properly consider extraneous zero characters at the beginni
Denial of service in the Vector observability pipeline's `logstash` source (versions 0.15.0 through 0.56.x) allows a rem
The Rust Programming Language Standard Library 1.34.x before 1.34.2 contains a stabilized method which, if overridden, c
Use-after-free in librsvg during rendering of crafted SVG documents with nested XInclude directives and duplicate entity
In the standard library in Rust before 1.52.0, the Zip implementation calls __iterator_get_unchecked() more than once fo
In the standard library in Rust before 1.50.0, read_to_end() does not validate the return value from Read in an unsafe c
Cargo prior to Rust 1.26.0 may download the wrong dependency if your package.toml file uses the `package` configuration
A parser differential in the Rust `zip` crate (zip2) through 9.0.4 lets a crafted archive present different filenames to
Exploit-DB