CVE-2026-23924

Executive Summary

CVE-2026-23924 is a critical path traversal vulnerability in the Zabbix Agent 2 Docker plugin. The plugin fails to properly sanitize the docker.container_info parameters when forwarding them to the Docker daemon. An attacker who can invoke Agent 2 can exploit this flaw to read arbitrary files from running Docker containers by injecting path traversal sequences via the Docker archive API. This allows unauthorized access to sensitive data within containerized environments, potentially leading to credential theft, data exfiltration, or further lateral movement.

This vulnerability is particularly dangerous in environments where Zabbix Agent 2 is deployed with Docker monitoring enabled, as it bypasses normal access controls and container isolation.

CVSS Breakdown & Threat Level

The CVSS score is listed as 0.0, which is likely a placeholder or uncalculated value. Based on the vulnerability description, a reasonable CVSS vector would be:

• Attack Vector (AV): Network (AV:N) – The attacker can invoke Agent 2 remotely.
• Attack Complexity (AC): Low (AC:L) – No special conditions required.
• Privileges Required (PR): Low (PR:L) – Requires ability to invoke Agent 2 (e.g., via Zabbix server or API).
• User Interaction (UI): None (UI:N) – No user action needed.
• Scope (S): Unchanged (S:U) – The vulnerable component and the affected resource are in the same security authority.
• Confidentiality (C): High (C:H) – Arbitrary file read from containers.
• Integrity (I): None (I:N) – No write capability.
• Availability (A): None (A:N) – No impact on availability.

Estimated CVSS Score: 6.5 (Medium)

Threat Level: High – Exploitation is straightforward and can lead to significant data exposure.

Deep Dive & Mechanics

The vulnerability resides in the Zabbix Agent 2 Docker plugin, which is used to monitor Docker containers. The plugin provides a docker.container_info parameter that allows querying information about a specific container. When this parameter is forwarded to the Docker daemon, it is not sanitized for path traversal sequences (e.g., ../).

The Docker archive API (/containers/{id}/archive) is used to retrieve files from a container. By injecting path traversal sequences into the container_info parameter, an attacker can specify a file path outside the intended container scope, such as /etc/shadow or /var/run/secrets/kubernetes.io/serviceaccount/token.

Attack Flow:

1. Attacker gains the ability to invoke Zabbix Agent 2 (e.g., via Zabbix server API or direct agent access).
2. Attacker sends a crafted request with docker.container_info containing a path traversal payload, e.g., ../../etc/shadow.
3. Agent 2 forwards this to the Docker daemon's archive API.
4. Docker daemon returns the contents of the specified file from the target container.
5. Attacker receives the file contents.

This bypasses container isolation because the Docker daemon trusts the agent's request, and the agent does not validate the path.

Vulnerable vs. Patched Code

Vulnerable Code (Conceptual):

// Zabbix Agent 2 Docker plugin - vulnerable version
int get_container_info(const char *container_id, const char *path) {
    char request[1024];
    snprintf(request, sizeof(request), "/containers/%s/archive?path=%s", container_id, path);
    // No sanitization of 'path' - allows traversal
    return docker_api_call(request);
}

Patched Code (Conceptual):

// Zabbix Agent 2 Docker plugin - patched version
int get_container_info(const char *container_id, const char *path) {
    // Sanitize path: remove traversal sequences
    char sanitized_path[1024];
    sanitize_path(path, sanitized_path, sizeof(sanitized_path)); // e.g., resolve ".." and reject if outside allowed base
    char request[1024];
    snprintf(request, sizeof(request), "/containers/%s/archive?path=%s", container_id, sanitized_path);
    return docker_api_call(request);
}

The patch must implement strict path validation, ensuring that the requested path is within the container's filesystem and does not contain ../ or absolute paths.

Exploitation & Lab Setup

Red Team

Prerequisites:

• Access to a Zabbix Agent 2 instance with Docker plugin enabled.
• Ability to send commands to the agent (e.g., via Zabbix server or direct API).

Exploit Steps:

1. Identify the target container ID (e.g., via docker ps or Zabbix monitoring data).
2. Craft a request to the Zabbix Agent 2 API:

   POST /api_jsonrpc.php HTTP/1.1
   Host: zabbix-agent:10050
   Content-Type: application/json-rpc
   
   {
       "jsonrpc": "2.0",
       "method": "docker.container_info",
       "params": {
           "container_id": "target_container_id",
           "path": "../../etc/shadow"
       },
       "id": 1
   }
   

3. The agent will return the contents of /etc/shadow from the container.

Alternative Exploit (Direct Agent Command):

# Using zabbix_get tool
zabbix_get -s 192.168.1.100 -k "docker.container_info[target_container_id,../../etc/shadow]"

Blue Team

Detection:

• Monitor Zabbix Agent 2 logs for unusual docker.container_info requests containing ../ or absolute paths.
• Monitor Docker daemon logs for archive API calls with suspicious paths.
• Use network monitoring to detect anomalous data exfiltration from Zabbix agents.

Hunting:

• Search for Zabbix agent commands containing docker.container_info with path traversal patterns.
• Review Docker daemon audit logs for GET /containers/*/archive?path=* requests with .. sequences.

Prevention:

• Disable the Docker plugin if not needed.
• Apply network segmentation to restrict access to Zabbix agents.
• Implement input validation at the Zabbix server level before forwarding to agents.

Indicators of Compromise (IOCs)

• Network: HTTP requests to Zabbix Agent 2 with docker.container_info containing ../ or absolute paths.
• Logs: Zabbix agent logs showing docker.container_info with suspicious path parameters.
• Docker Daemon Logs: Entries like GET /v1.41/containers/{id}/archive?path=../../etc/shadow.
• File System: Unexpected file reads from containers (e.g., /etc/shadow, /var/run/secrets/).

Detection Engineering

YARA Rule

rule CVE_2026_23924_Zabbix_Docker_Traversal {
    meta:
        description = "Detects path traversal attempts in Zabbix Agent 2 Docker plugin"
        author = "Valters IT"
        date = "2026-01-01"
        reference = "CVE-2026-23924"
    strings:
        $traversal1 = "docker.container_info" ascii wide nocase
        $traversal2 = ".." ascii wide
        $traversal3 = "/etc/" ascii wide
        $traversal4 = "/var/" ascii wide
    condition:
        $traversal1 and ($traversal2 or $traversal3 or $traversal4)
}

Sigma Rule

title: CVE-2026-23924 Zabbix Agent 2 Docker Path Traversal
id: 7a8b9c0d-1e2f-3a4b-5c6d-7e8f9a0b1c2d
status: experimental
description: Detects path traversal attempts in Zabbix Agent 2 Docker plugin
author: Valters IT
date: 2026/01/01
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-23924
logsource:
    category: application
    product: zabbix_agent
detection:
    selection:
        EventID: 100
        CommandLine|contains: 'docker.container_info'
        CommandLine|contains|all:
            - '..'
            - '/'
    condition: selection
falsepositives:
    - Legitimate use of container paths with dots (rare)
level: high

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"CVE-2026-23924 Zabbix Agent 2 Docker Path Traversal";
    flow:to_server,established;
    content:"docker.container_info"; http_uri; nocase;
    content:".."; http_uri;
    pcre:"/docker\.container_info[^&]*\.\.\//i";
    reference:cve,2026-23924;
    classtype:attempted-recon;
    sid:1000001;
    rev:1;
)

Remediation & Mitigation

Immediate Actions:

1. Disable the Docker plugin on Zabbix Agent 2 if not required: sudo systemctl stop zabbix-agent2 && sudo systemctl disable zabbix-agent2.
2. Apply network access controls to restrict who can invoke Agent 2 commands.
3. Monitor for exploitation attempts using the provided detection rules.

Long-term Fix:

• Apply vendor patch when available (currently UNKNOWN).
• Implement input validation at the Zabbix server level to sanitize docker.container_info parameters before forwarding to agents.
• Upgrade to a patched version of Zabbix Agent 2.

Workaround:

• Use a reverse proxy or WAF to filter requests containing ../ in docker.container_info parameters.
• Restrict Docker API access to only trusted agents.

Valters IT
Senior DevSecOps & Cyber Threat Intelligence Expert