CVE-2024-10553: H2O Deserialization RCE Vulnerability

CVE-2024-10553 Overview

A critical insecure deserialization vulnerability exists in the h2oai/h2o-3 REST API version 3.46.0.4 that allows unauthenticated remote attackers to execute arbitrary code. The vulnerability is present in the POST /99/ImportSQLTable and POST /3/SaveToHiveTable endpoints, where user-controlled JDBC URLs are passed directly to DriverManager.getConnection. When a MySQL or PostgreSQL driver is available in the classpath, attackers can exploit this to trigger deserialization of untrusted data, leading to remote code execution.

Critical Impact

Unauthenticated remote code execution via JDBC deserialization attacks, allowing complete system compromise without any authentication.

Affected Products

• H2O-3 version 3.46.0.4
• H2O machine learning platform REST API
• Systems with MySQL or PostgreSQL JDBC drivers in classpath

Discovery Timeline

• 2025-03-20 - CVE CVE-2024-10553 published to NVD
• 2025-07-14 - Last updated in NVD database

Technical Details for CVE-2024-10553

Vulnerability Analysis

This vulnerability represents a classic insecure deserialization flaw (CWE-502) affecting the H2O-3 machine learning platform's REST API. The root issue lies in how the application handles user-supplied JDBC connection URLs without proper validation or sanitization. When processing requests to the ImportSQLTable and SaveToHiveTable endpoints, the application directly passes attacker-controlled JDBC URLs to Java's DriverManager.getConnection method.

This is particularly dangerous because certain JDBC drivers, notably MySQL and PostgreSQL connectors, can be abused to trigger arbitrary deserialization during the connection handshake process. An attacker can craft a malicious JDBC URL that points to an attacker-controlled server, which then responds with a serialized Java object payload. When deserialized by the target system, this payload executes arbitrary code with the privileges of the H2O-3 application.

The attack requires no authentication, making it exploitable by any network-accessible attacker. The vulnerability enables complete confidentiality, integrity, and availability compromise of the affected system.

Root Cause

The root cause is the direct use of untrusted user input in JDBC connection operations without proper validation. The vulnerable code paths in the POST /99/ImportSQLTable and POST /3/SaveToHiveTable endpoints accept JDBC URLs from API requests and pass them to DriverManager.getConnection without sanitizing or restricting the URL parameters. This allows attackers to specify malicious JDBC connection strings that trigger deserialization gadget chains through vulnerable JDBC driver implementations.

Attack Vector

The attack is network-based and requires no user interaction or authentication. An attacker crafts a malicious HTTP POST request to either vulnerable endpoint with a specially crafted JDBC URL. This URL points to an attacker-controlled server that serves a serialized Java object containing a gadget chain. When the H2O-3 application attempts to establish a JDBC connection, the malicious server responds with the serialized payload, which is then deserialized by the victim's Java runtime, executing arbitrary code.

The attack flow involves crafting a malicious JDBC URL with parameters that trigger deserialization behavior in MySQL or PostgreSQL JDBC drivers. The attacker's server responds with a serialized Java gadget chain that exploits classes available in the application's classpath. Upon deserialization, the gadget chain executes, allowing arbitrary command execution on the target system.

Detection Methods for CVE-2024-10553

Indicators of Compromise

• Unexpected HTTP POST requests to /99/ImportSQLTable or /3/SaveToHiveTable endpoints from external or unauthorized sources
• JDBC connection attempts to unknown or suspicious external IP addresses
• Unusual network traffic patterns from the H2O-3 application to external hosts on database ports
• Process spawning or command execution originating from the H2O-3 Java process
• Presence of serialized Java objects in network traffic to/from the H2O-3 application

Detection Strategies

• Implement network monitoring for outbound JDBC connections from H2O-3 servers to untrusted destinations
• Deploy web application firewall (WAF) rules to inspect and filter suspicious JDBC URLs in POST request bodies
• Monitor Java process behavior for anomalous child process creation or network connections
• Enable detailed logging on the affected endpoints and analyze for malformed or suspicious JDBC URLs
• Utilize SentinelOne's behavioral AI to detect post-exploitation activities following deserialization attacks

Monitoring Recommendations

• Continuously monitor H2O-3 REST API access logs for requests to the vulnerable endpoints
• Implement real-time alerting on outbound connections from H2O-3 servers to non-whitelisted database hosts
• Deploy endpoint detection and response (EDR) solutions to identify anomalous behavior from Java applications
• Correlate network traffic with application logs to identify potential exploitation attempts

How to Mitigate CVE-2024-10553

Immediate Actions Required

• Upgrade H2O-3 to version 3.47.0 or later immediately to address this vulnerability
• If immediate upgrade is not possible, restrict network access to the vulnerable REST API endpoints
• Implement network segmentation to limit outbound connections from H2O-3 servers
• Review access logs for any signs of prior exploitation attempts
• Remove unnecessary JDBC drivers (MySQL, PostgreSQL) from the classpath if not required for operations

Patch Information

H2O AI has released a fix in version 3.47.0 of the H2O-3 platform. The patch addresses the insecure handling of JDBC URLs in the affected endpoints. Organizations should upgrade to this version or later. The specific fix can be reviewed in the H2O-3 GitHub commit. Additional technical details about the vulnerability are available in the Huntr security advisory.

Workarounds

• Implement strict network-level access controls to limit which clients can reach the H2O-3 REST API
• Deploy a reverse proxy or WAF to filter requests containing suspicious JDBC URL patterns
• Disable the ImportSQLTable and SaveToHiveTable endpoints if they are not required for operations
• Remove MySQL and PostgreSQL JDBC drivers from the application classpath if database import functionality is not needed
• Implement egress filtering to prevent the H2O-3 server from establishing outbound JDBC connections to untrusted hosts

# Network segmentation example - restrict outbound JDBC connections
# Using iptables to block outbound MySQL (3306) and PostgreSQL (5432) traffic
iptables -A OUTPUT -p tcp --dport 3306 -m owner --uid-owner h2o_user -j DROP
iptables -A OUTPUT -p tcp --dport 5432 -m owner --uid-owner h2o_user -j DROP

# Allow only specific whitelisted database servers
iptables -A OUTPUT -p tcp --dport 3306 -d TRUSTED_DB_IP -m owner --uid-owner h2o_user -j ACCEPT
iptables -A OUTPUT -p tcp --dport 5432 -d TRUSTED_DB_IP -m owner --uid-owner h2o_user -j ACCEPT