Skip to main content

Robocode CVE-2025-14308

CRITICAL
Integer Overflow or Wraparound (CWE-190)
2025-12-09 cve_disclosure@tech.gov.sg
10.0
CVSS 4.0 · Vendor: tech
View

Attack ChainAIDerived

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

  1. Access
    Trick victim into loading malicious robot
  2. Exploit
    Call write() with manipulated offset/length
  3. Execution
    Overflow bounds check in RobotFileOutputStream
  4. Impact
    Write 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).

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 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

Vendor (tech) PRIMARY 10.0 CRITICAL
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
vuln.today AI 5.3 MEDIUM

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.

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

Primary rating from Vendor (tech).

CVSS VectorVendor: tech

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
High
Subsequent system: Integrity
High
Subsequent system: Availability
High

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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.6%
Top 54% exploitable
Prevalence
Low
niche open-source Java programming game, hobby/educational, no enterprise footprint
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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.6%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Medium

Priority Score

51
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +50
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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

cpe:2.3:a:robocode:robocode:1.9.3.6:*:*:*:*:*:*:*

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