Robocode
CVE-2025-14308
CRITICAL
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessTrick victim into loading malicious robot
-
ExploitCall write() with manipulated offset/length
-
ExecutionOverflow bounds check in RobotFileOutputStream
-
ImpactWrite outside sandbox or crash host
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim to import and execute an attacker-supplied Robocode robot, which then calls the vulnerable RobotFileOutputStream.write(byte[], off, len) with a crafted length/offset that defeats the missing/incorrect bounds validation (the pre-patch code only checked len<0). Limiting factors: this is a local desktop Java application, not a network service, so an attacker must deliver and get the malicious robot run (user interaction); the code path is the robot sandbox's file-write facility, so the practical impact is a sandbox file-write/bounds bypass and likely an exception-driven crash rather than confirmed native code execution. The input CVSS AV:N/PR:N/UI:N does not reflect these constraints and should be verified with the vendor. |
| Impact | The input assigns a maximal CVSS 4.0 score of 10.0 (AV:N/AC:L/PR:N/UI:N with High confidentiality, integrity, and availability impact on both vulnerable and subsequent systems), which on paper signals a critical remotely-exploitable flaw. However, these signals conflict sharply with the actual nature of the product and the patch evidence. Robocode is a desktop Java programming game in which users write and run 'robot' code; the vulnerable method is RobotFileOutputStream.write in the host's sandbox file I/O layer, meaning realistic exploitation requires an attacker to get a victim to load and run a malicious robot locally - not a true network-reachable, zero-interaction attack as AV:N/UI:N implies. There is no EPSS score, no CISA KEV listing (no public exploit identified at time of analysis), and no public POC supplied; the only reference is the GitHub pull request containing the fix. Furthermore, the CWE-190 integer-overflow-to-arbitrary-code-execution claim is questionable in a managed Java runtime, where an out-of-bounds array write raises an exception rather than corrupting memory, so the practical outcome is more likely a sandbox file-write bypass or denial of service than reliable native code execution. Net assessment: this is a high-CVSS-but-low-real-world-risk issue - a niche hobby/educational product, no evidence of exploitation, and a vector score that materially overstates reachability. CVSS indicates a network vector but the affected component implies local, robot-load-dependent access - verify AV and the ACE claim with the vendor. |
| Exploit ScenarioDerived | An attacker publishes or shares a specially crafted Robocode robot that, when imported and run by a victim, invokes the Buffer/RobotFileOutputStream write method with manipulated offset/length values to trigger the integer overflow and bypass the intended bounds check. No public exploit identified at time of analysis; exploitation depends on the victim choosing to load and execute the untrusted robot, so it is local and interaction-dependent rather than remote and automatic (contradicting the input AC:L/UI:N). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Improper bounds validation in Robocode 1.9.3.6's RobotFileOutputStream.write(byte[], int, int) method lets a malicious robot manipulate the offset and length arguments to bypass the sandbox's file-write checks, producing an integer-overflow-driven out-of-bounds write that in practice manifests as an exception-driven crash plus a sandbox file-write bypass rather than confirmed native code execution. Exploitation requires the victim to import and execute an attacker-supplied robot, i.e. meaningful user interaction on a local desktop Java application, and no public exploit code or confirmed active exploitation has been identified at time of analysis. The submitting advisory assigns a maximal CVSS 4.0 score of 10.0 (AV:N/AC:L/PR:N/UI:N with High impacts on all metrics), which overstates the exposure: an independent assessment rates this CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:L, and the discrepancy (network vs. local, unauthenticated remote vs. user-assisted local, full vs. integrity/availability-only) should be verified with the vendor.
RemediationAI
Patch status is: upstream fix available (PR/commit); released patched version not independently confirmed. The authoritative fix is the upstream change in https://github.com/robo-code/robocode/pull/70, which adds a null check and full bounds validation (off < 0 || len < 0 || len > b.length || off > b.length - len) to RobotFileOutputStream.write, so upgrading to a Robocode build that includes that merged commit - or rebuilding from the patched source - removes the vulnerable code path. Until a tagged release containing the fix is verified, the most effective compensating control is to avoid importing and executing untrusted robot archives entirely, since the exploit requires the victim to load and run the attacker-supplied robot; the trade-off is loss of the platform's core use case for third-party code. If untrusted robots must be run, restrict the Robocode process to a sandboxed JVM or OS-level container with a read-only or tightly scoped writable directory for the robots/data folders, which limits any file-write bypass to a disposable filesystem but does not prevent the in-process memory corruption attempt. Running Robocode under a security manager or with a JVM that enforces strong encapsulation can also constrain the robot's I/O surface, though modern JDK versions deprecate the security manager, so this control has diminishing viability. Because the submitted CVSS 4.0 vector (AV:N/PR:N/UI:N, score 10.0) materially disagrees with the independent assessment (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:L), confirm the true exposure and any vendor-published fixed version with the Robocode maintainers before treating this as a remotely exploitable critical issue.
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
The root cause is CWE-190 (Integer Overflow or Wraparound) in the Robocode host's I/O layer. Robocode is a Java desktop battle-robot simulation platform that runs user-supplied robot code inside a security sandbox; the sandbox mediates file writes through classes such as net.sf.robocode.host.io.RobotFileOutputStream. Prior to the upstream fix, the write(byte[] b, int off, int len) implementation validated only len < 0, so a robot could supply values where the length/offset combination defeats bounds reasoning (e.g. off + len overflow or len exceeding the array length) and reach an out-of-bounds write on the backing buffer. The upstream PR (https://github.com/robo-code/robocode/pull/70) replaces that partial check with a null check on the array and a comprehensive guard (off < 0 || len < 0 || len > b.length || off > b.length - len) that throws ArrayIndexOutOfBoundsException, and tidies the ignored-IOException catch block. Because the vulnerable class is a sandbox file-write facility rather than a remote service, the realistic consequence of a successful trigger is a bounds-check/sandbox bypass and an exception-driven crash; escalation to arbitrary native code execution is asserted in the description but not confirmed by the diff or by independent analysis. The CPE cpe:2.3:a:robocode:robocode:1.9.3.6 identifies version 1.9.3.6 as the affected release.
Know when Robocode 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:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H/AU:Y/R:U/V:D/RE:M/U:Red
Requires locally loading and running an untrusted robot (AV:L, UI:R); reliably weaponizing the overflow is hard (AC:H); primary effect is unauthorized sandbox file writes (I:H), with code execution unproven, so C:N and A:L.
Primary rating from Vendor (tech).
CVSS VectorVendor: tech
DescriptionCVE.org
An integer overflow vulnerability exists in the write method of the Buffer class in Robocode version 1.9.3.6. The method fails to properly validate the length of data being written, allowing attackers to cause an overflow, potentially leading to buffer overflows and arbitrary code execution. This vulnerability can be exploited by submitting specially crafted inputs that manipulate the data length, leading to potential unauthorized code execution.
Executive ViewAI
Robocode 1.9.3.6, a desktop Java programming game commonly used for developer training and classroom instruction, contains a sandbox-validation flaw that allows a maliciously crafted robot program to bypass file-write restrictions and overwrite files on the host machine, typically accompanied by an application crash. Exploitation requires a user to knowingly import and run an untrusted robot, and no public exploit code or confirmed active exploitation has been identified at time of analysis, so exposure is concentrated among staff and students who execute third-party robot code on their workstations. Because no vendor patch is currently available, this unpatched integrity risk should be managed through policy and isolation controls rather than remediation, and leadership should note that the submitting advisory's maximal 10.0 score overstates real-world exposure relative to the independently assessed local, user-assisted profile.
No vendor-released patch identified at time of analysis. Interim mitigations: prohibit import and execution of robots from untrusted or external sources; run Robocode 1.9.3.6 under a low-privilege account, container, or OS-level sandbox with write access confined to a dedicated scratch directory; remove access to shared, system, and user-profile directories; avoid reusing production credentials on hosts running the tool; monitor Java process file-write activity; and consider temporarily removing the application where it is not business-essential.
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
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Affected Products (CPE)CVE.org
Arbitrary file deletion via directory traversal in the CacheCleaner component of Robocode 1.9.3.6: the recursivelyDelete
Robocode through 1.9.3.5 allows remote attackers to cause external service interaction (DNS), as demonstrated by a query
Local attackers with a low-privileged account on a host running Robocode 1.9.3.6 can exploit an insecure temporary file
NVD
CVE.org
EPSS
GitHub
Exploit-DB