Skip to main content

Takes TkFiles CVE-2025-66905

HIGH
Path Traversal (CWE-22)
2025-12-19 cve@mitre.org
7.5
CVSS 3.1 · Vendor: mitre
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Send crafted HTTP request with ../ sequences
  2. Delivery
    TkFiles resolves path without canonicalization
  3. Exploit
    Escape configured base directory
  4. Execution
    Read arbitrary host file
  5. Impact
    Exfiltrate sensitive data in HTTP response

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

Requires that the target application expose the Takes framework's TkFiles take to serve files from a configured base directory over HTTP; exploitation then needs only an attacker-controlled request path containing ../ traversal sequences. No authentication, no user interaction, and no non-default configuration are required to read files (AV:N/AC:L/PR:N/UI:N), making any internet-reachable TkFiles-backed endpoint exploitable. The principal limiting factors are deployment-based rather than technical: the application must actually use TkFiles for file serving, must be running an affected version (through 2.0-SNAPSHOT), and the readable scope is bounded by the OS-level file permissions of the process running the framework. Impact is confined to confidentiality (arbitrary file read); there is no write/integrity or availability impact.

Impact

Signals are moderately consistent but point to a lower real-world priority than the 7.5 CVSS base score implies in isolation. The CVSS vector (AV:N/AC:L/PR:N/UI:N) indicates a trivially reachable, unauthenticated, network-based file-read flaw with high confidentiality impact (C:H) and no integrity or availability impact (I:N/A:N), consistent with a classic unauthenticated path-traversal arbitrary-file-read. Publicly available exploit code exists (per the referenced GitHub report), which raises the operational likelihood of opportunistic use. However, this is NOT CISA KEV-listed and no EPSS score was provided in the input, so there is no evidence of active, widespread exploitation - exploitation status is limited to 'publicly available exploit code exists', which is a distinct and weaker signal than confirmed in-the-wild abuse. The dominant mitigating factor is deployment footprint: Takes/TkFiles is a niche open-source Java web framework (yegor256/takes), not enterprise-ubiquitous software, so the aggregate real-world attack surface is small. Net assessment: technically a genuine, easy-to-exploit unauthenticated vulnerability that warrants prompt patching for anyone running it, but low organizational priority for most defenders due to limited prevalence and no KEV/active-exploitation evidence. No signals directly conflict; the main gap is the absence of EPSS data to quantify exploitation probability.

Exploit ScenarioDerived

A remote, unauthenticated attacker sends an HTTP request to a service using the TkFiles take with a crafted path containing ../ sequences (e.g. requesting ../../../../etc/passwd), escaping the configured base directory and retrieving arbitrary host files such as configuration files, credentials, or source code. Because AV:N/AC:L/PR:N/UI:N, no authentication, user interaction, or special conditions are needed, and public exploit/report material already documents the technique.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.6% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 13, 2026

Arbitrary file read in the Takes web framework's TkFiles take (through version 2.0-SNAPSHOT) lets remote, unauthenticated attackers escape the configured file-serving base directory by inserting ../ sequences into the HTTP request path, disclosing files readable by the Java process. The CVSS v3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) confirms no authentication or user interaction is needed, and the impact is limited to confidentiality with no integrity or availability effect; the practical blast radius depends on how permissive the hosting process's OS-level file permissions are. Exploitation is straightforward for any internet-reachable TkFiles-backed endpoint, and publicly available exploit code exists (a detailed proof-of-concept report is linked from the NVD entry), but there is no indication of confirmed active exploitation in the wild and no CISA KEV listing.

RemediationAI

No vendor-released patch or fixed version was identified in the available data; track the upstream project at https://github.com/yegor256/takes for a corrected TkFiles release and apply it as soon as it is published, since the proper fix is canonicalizing the resolved path and verifying it remains under the configured base directory before reading. Until then, apply compensating controls that directly address the traversal primitive: place a reverse proxy or load balancer in front of the application that normalizes request paths and rejects those containing ../ or encoded traversal sequences after decoding - the trade-off is that normalization rules written only for raw ../ can be bypassed by alternate encodings, and aggressive path rewriting may break legitimate applications that rely on unusual URI syntax. Also run the Java process under a least-privileged OS account, container, or chroot with a read-only root filesystem and no access to secrets, SSH keys, or application configuration, which does not stop the vulnerability but caps what a successful traversal can disclose; note this may require adjusting file ownership and can break features that legitimately need broader read access. Do not rely on security-through-obscurity such as changing the base directory, and monitor the process for outbound reads of sensitive paths as a detection backstop. Given the publicly available exploit code and the unauthenticated nature of the flaw, prioritize remediation for any TkFiles endpoint reachable from untrusted networks.

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

TkFiles is a 'take' within the Takes framework (github.com/yegor256/takes), a Java web framework that models HTTP request handling as composable, chainable objects. The vulnerability class is CWE-22 (Improper Limitation of a Pathname to a Restricted Directory, i.e., path traversal): the take resolves the client-supplied request path against a configured base directory without first canonicalizing it (e.g., normalizing ./ and ../ segments and then verifying that the resulting canonical path still resides under the base directory). Because the raw, attacker-controlled path is joined to the base directory before any containment check, sequences such as ../../etc/passwd traverse upward out of the intended document root. The affected CPE is cpe:2.3:a:takes:tkfiles:2.0:*:*:*:*:*:*:*, i.e., the 2.0 line including the 2.0-SNAPSHOT development build - meaning both released 2.0 artifacts and builds tracking the snapshot branch may be exposed. The root cause is architectural rather than a memory-safety issue: no canonicalization step and no post-resolution 'starts-with base' assertion, so the fix belongs in the take's path handling rather than in the runtime.

Know when Tkfiles 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

Vendor (mitre) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
vuln.today AI 7.5 HIGH

Unauthenticated remote path traversal with no user interaction (AV:N/AC:L/PR:N/UI:N); arbitrary file read gives C:H, with no write or availability effect so I:N/A:N.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
None

DescriptionCVE.org

The Takes web framework's TkFiles take thru 2.0-SNAPSHOT fails to canonicalize HTTP request paths before resolving them against the filesystem. A remote attacker can include ../ sequences in the request path to escape the configured base directory and read arbitrary files from the host system.

Executive ViewAI

Why It Matters

A high-severity arbitrary file read vulnerability affects the Takes web framework's TkFiles take through version 2.0-SNAPSHOT, allowing unauthenticated remote attackers to read files accessible to the Java process. Publicly available exploit code exists, and no vendor-released patch identified at time of analysis, so any internet-reachable TkFiles-backed endpoint may expose configuration files, credentials, source code, or other sensitive data. Security leadership should prioritize discovery and containment of affected services because exploitation is straightforward and requires no authentication or user interaction.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis; interim mitigations include restricting network access to TkFiles-backed endpoints, deploying WAF or reverse-proxy rules to block ../ and encoded path traversal sequences, running the Java process with least-privilege OS file permissions, disabling TkFiles where not required, and monitoring for file-read attempts or exposed sensitive files.

Threat Intelligence Overview

EPSS Score
0.6%
Top 52% exploitable
Prevalence
Low
niche open-source Java web framework, minimal enterprise or production footprint
Exploit
POC
Public exploit code exists
Data Quality
3 sources
Confidence: Low

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.6%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Out-of-Cycle
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

59
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +38
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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

cpe:2.3:a:takes:tkfiles:2.0:*:*:*:*:*:*:*

References

Advisories & patches

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy