Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconCompromise delegated signer credentials
-
DeliveryCraft malicious TUF metadata with traversal payloads
-
ExploitUpload signed metadata to repository
-
InstallVictim Tough client fetches metadata
-
C2Client resolves symlinks after boundary check
-
ExecuteArbitrary file write outside repository
-
ImpactExecute written payload or modify system files
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires authenticated access with delegated signing authority in a TUF repository using AWS Tough, meaning the attacker must possess valid cryptographic credentials for a delegated TUF role (typically developer, package maintainer, or CI/CD service accounts). The vulnerable code paths are triggered when repository metadata specifies absolute target names (copy_target/link_target), when parent directories in the save path contain symlinks created prior to save_target operations, or when metadata filenames are symlinks during SignedRole::write calls. Attack complexity is HIGH (AC:H) because successful exploitation requires precise control over repository metadata structure and may need specific timing for symlink-based attacks. The vulnerability is NOT exploitable by unauthenticated remote attackers or regular repository users without signing privileges. Limiting exploitation: requires network access to TUF repository infrastructure, depends on Tough library being used for repository operations (not all TUF implementations are vulnerable), and the impact scope is constrained to systems where the Tough client runs with write permissions outside the repository directory. |
| Impact | Real-world risk is MODERATE despite HIGH CVSS 7.1 score due to significant exploitation barriers. The CVSS:4.0 vector reveals critical limitations: Attack Complexity HIGH (AC:H) indicates non-trivial exploitation requiring specific timing or conditions, Attack Requirements PRESENT (AT:P) suggests additional prerequisites beyond network access, and Privileges Required LOW (PR:L) means attackers need authenticated access with delegated signing authority in the TUF repository - not typical low-privilege user access but a trusted role typically reserved for package maintainers or CI/CD systems. The vulnerability requires the attacker to already possess legitimate signing credentials for a delegated TUF role, significantly narrowing the threat actor pool to insider threats, compromised build systems, or supply chain attacks against signing infrastructure. EPSS data not provided but would likely be low given the authentication barrier and specialized nature of TUF implementations. No CISA KEV listing and no public POC identified, indicating no confirmed active exploitation or widespread attacker interest. The impact is severe when conditions are met (Vulnerable System Integrity HIGH, Subsequent System Integrity HIGH per CVSS 4.0 metrics), as arbitrary file writes could compromise update repository integrity or client systems downloading tampered packages. However, organizations not using AWS Tough/TUF or those without delegated signing workflows are unaffected. Priority should be HIGH for teams using Tough in production TUF repositories with role delegation, MEDIUM for those using Tough without delegation, LOW for evaluators or test deployments. |
| Exploit ScenarioDerived | An attacker who has compromised a CI/CD system with delegated TUF signing authority creates malicious repository metadata containing a target with an absolute path like '/etc/cron.d/backdoor' in its target name field. When a Tough client processes this metadata and calls copy_target or link_target, the absolute path bypasses relative path validation, writing the attacker's payload outside the intended repository directory. Alternatively, the attacker creates a symlink in the repository's parent directory chain pointing to '/usr/local/bin', then uses save_target to write a malicious binary that gets executed by legitimate processes. The attack succeeds because the initial containment check occurs before symlink resolution, but the actual file write uses the post-resolution path without re-validation. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 24, 2026
Path traversal vulnerabilities in AWS Tough (a Rust TUF client library) versions prior to 0.22.0 enable authenticated users with delegated signing privileges to write arbitrary files outside intended repository directories, bypassing incomplete fixes from previous security patches. The flaws exist in three distinct code paths: absolute target names in copy_target/link_target operations, symlinked parent directories in save_target, and symlinked metadata filenames in SignedRole::write. AWS has released patches in tough-v0.22.0 and tuftool-v0.15.0 that implement post-resolution path containment verification. No public exploit code or active exploitation confirmed at time of analysis, though CVSS 7.1 HIGH reflects significant integrity impact when exploited.
RemediationAI
Upgrade to AWS Tough 0.22.0 or later and AWS Tuftool 0.15.0 or later, available from GitHub releases (https://github.com/awslabs/tough/releases/tag/tough-v0.22.0 and https://github.com/awslabs/tough/releases/tag/tuftool-v0.15.0) and crates.io (https://crates.io/crates/tough/0.22.0 and https://crates.io/crates/tuftool/0.15.0). The patches implement post-resolution path containment checks that verify destination paths remain within intended directories after symlink resolution. If immediate patching is not feasible, implement compensating controls: restrict delegated signing authority to minimal necessary roles and principals, audit existing delegated role credentials and revoke unnecessary permissions, run TUF repository operations in isolated containers with read-only filesystem mounts outside target directories to limit traversal impact, and monitor file write operations for unexpected paths outside repository boundaries using filesystem audit tools like auditd or osquery (noting this adds operational overhead and may not prevent exploitation, only detect it). Review TUF repository metadata for unauthorized modifications if delegated signers had access during the vulnerability window. These workarounds reduce attack surface but do not eliminate the vulnerability - prioritize vendor-released patches.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
AWS Tough is a Rust implementation of The Update Framework (TUF), a security framework for software update systems that uses cryptographic signatures and role-based delegation. TUF clients download metadata and target files from repositories while verifying signatures from delegated roles. The vulnerability stems from classic TOCTOU (time-of-check-time-of-use) race conditions in file operations: the code validates that a destination path is within allowed boundaries before symlink resolution, but then writes to the resolved path without re-validating containment. This affects three distinct operations: copy_target and link_target accept absolute paths in target names that bypass relative path validation; save_target follows symlinked parent directories after initial validation; and SignedRole::write trusts symlinked metadata filenames. The root cause maps to CWE-22 (Improper Limitation of a Pathname to a Restricted Directory), specifically the variant where symbolic link resolution occurs after boundary checks. The description notes these are 'incomplete path traversal fixes,' indicating prior CVEs addressed similar issues but missed these attack vectors, suggesting the codebase had partial mitigations that failed under specific conditions.
Know when Tough 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:H/AT:P/PR:L/UI:N/VC:N/VI:H/VA:N/SC:N/SI:H/SA:L
Primary rating from Vendor (AMZN) · only source for this CVE.
CVSS VectorVendor: AMZN
Lifecycle Timeline
4DescriptionCVE.org
Incomplete path traversal fixes in awslabs/tough before tough-v0.22.0 allow remote authenticated users with delegated signing authority to write files outside intended output directories via absolute target names in copy_target/link_target, symlinked parent directories in save_target, or symlinked metadata filenames in SignedRole::write, because write paths trust the joined destination path without post-resolution containment verification.
We recommend you upgrade to tough-v0.22.0 / tuftool-v0.15.0.
Articles & Coverage 1
Executive ViewAI
AWS Tough, a Rust-based TUF (The Update Framework) client library, contains path traversal vulnerabilities that allow authenticated users with signing privileges to write arbitrary files outside designated repository directories, compromising the integrity of software update mechanisms. Organizations using Tough prior to version 0.22.0 for package distribution, firmware updates, or container image signing face elevated risk of malicious file placement within update infrastructure. This requires immediate patching to prevent supply chain compromise.
Apply vendor patch. If immediate patching is constrained: (1) Restrict delegated signing privileges to accounts with absolute operational necessity only; (2) Implement strict file system access controls and monitoring on TUF repository target directories to detect unauthorized file writes; (3) Enforce code review for all repository metadata changes; (4) Monitor for suspicious symlink creation in parent directories of metadata and target files.
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
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Affected Products (CPE)CVE.org
The tough library (Rust/crates.io) prior to version 0.7.1 does not properly verify the threshold of cryptographic signat
Tough provides a set of Rust libraries and tools for using and generating the update framework (TUF) repositories. Rated
Metadata integrity bypass in AWS tough (TUF client library) before v0.22.0 allows authenticated users with delegated sig
Signature duplication in AWS Tough TUF client prior to v0.22.0 allows authenticated attackers to bypass threshold signat
Tough provides a set of Rust libraries and tools for using and generating the update framework (TUF) repositories. Rated
During a snapshot rollback, the client incorrectly caches the timestamp metadata. Rated medium severity (CVSS 5.7), this
During a target rollback, the client fails to detect the rollback for delegated targets. Rated medium severity (CVSS 5.7
Missing validation of the root metatdata version number could allow an actor to supply an arbitrary version number to th
Missing validation of terminating delegation causes the client to continue searching the defined delegation list, even a
EUVD-2026-25629
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB