CVE-2026-2711: WorldQuant Miner SSRF Vulnerability

CVE-2026-2711 Overview

A Server-Side Request Forgery (SSRF) vulnerability has been identified in zhutoutoutousan worldquant-miner up to version 1.0.9. The vulnerability exists in an unknown function within the file worldquant-miner-master/agent-dify-api/core/helper/ssrf_proxy.py of the URL Handler component. Through manipulation of the make_request argument, an attacker can initiate server-side request forgery attacks remotely. The attack complexity is rated as high, making exploitability difficult. The exploit has been disclosed publicly and may be used. The project maintainers were informed of the vulnerability through an issue report but have not responded.

Critical Impact

This SSRF vulnerability allows remote attackers to manipulate the server into making requests to arbitrary internal or external destinations, potentially exposing internal services, bypassing access controls, or enabling further attacks against backend infrastructure.

Affected Products

• worldquant-miner versions up to and including 1.0.9
• agent-dify-api component (specifically ssrf_proxy.py)
• Systems utilizing the URL Handler functionality

Discovery Timeline

• 2026-02-19 - CVE-2026-2711 published to NVD
• 2026-02-19 - Last updated in NVD database

Technical Details for CVE-2026-2711

Vulnerability Analysis

This vulnerability is classified as CWE-918 (Server-Side Request Forgery). The SSRF flaw resides in the ssrf_proxy.py file within the agent-dify-api core helper module. The vulnerable make_request function fails to properly validate and sanitize user-supplied URLs before processing them, allowing attackers to craft malicious requests that the server will execute on their behalf.

SSRF vulnerabilities are particularly dangerous in API-based applications because they can be leveraged to access internal services that would otherwise be unreachable from external networks. In the context of a mining or data analysis tool like worldquant-miner, this could potentially expose sensitive financial algorithms, internal APIs, or cloud metadata services.

Root Cause

The root cause of this vulnerability stems from insufficient input validation in the URL handling logic within ssrf_proxy.py. The make_request function accepts user-controlled URL parameters without proper sanitization, allowing attackers to specify arbitrary destination addresses including internal network resources, localhost services, or cloud metadata endpoints.

The lack of URL scheme restrictions, hostname validation, and IP address filtering enables attackers to bypass typical network segmentation and access controls.

Attack Vector

The attack can be initiated remotely over the network. An attacker can exploit this vulnerability by sending crafted requests to the vulnerable endpoint with malicious URLs in the make_request parameter. The high attack complexity indicates that successful exploitation requires specific conditions or knowledge about the target environment.

Potential attack scenarios include:

• Scanning internal network services
• Accessing cloud instance metadata (e.g., AWS IMDSv1)
• Reading local files via file:// protocol (if supported)
• Attacking internal services with POST requests
• Bypassing IP-based access controls

For technical details and proof-of-concept information, refer to the GitHub Issue Discussion and VulDB #346662.

Detection Methods for CVE-2026-2711

Indicators of Compromise

• Unusual outbound requests from the server to internal IP ranges (10.x.x.x, 172.16.x.x, 192.168.x.x)
• HTTP requests to cloud metadata endpoints such as 169.254.169.254
• Requests containing suspicious URL schemes like file://, gopher://, or dict://
• Server logs showing requests to localhost or 127.0.0.1 from the ssrf_proxy.py component

Detection Strategies

• Monitor application logs for requests processed by ssrf_proxy.py with unusual destination addresses
• Implement network-level detection for outbound requests to private IP ranges originating from the application server
• Review web server access logs for patterns indicating SSRF exploitation attempts
• Deploy Web Application Firewall (WAF) rules to detect and block SSRF payloads

Monitoring Recommendations

• Enable detailed logging for the agent-dify-api component to capture all URL requests
• Configure alerting for any requests targeting internal network ranges or metadata services
• Implement DNS query monitoring to detect attempts to resolve internal hostnames

How to Mitigate CVE-2026-2711

Immediate Actions Required

• Restrict network access to the vulnerable endpoint until a patch is available
• Implement network-level egress filtering to prevent the server from making requests to internal networks
• Consider disabling the affected URL Handler functionality if not critical to operations
• Review and audit existing logs for signs of exploitation

Patch Information

As of the last update on 2026-02-19, no official patch has been released by the project maintainers. The vulnerability was reported via GitHub Issue #100, but the project has not responded. Users should monitor the worldquant-miner repository for updates.

Workarounds

• Implement allowlist-based URL validation in ssrf_proxy.py to restrict allowed destination domains
• Block requests to private IP ranges, loopback addresses, and cloud metadata IPs at the application level
• Use network segmentation to isolate the application from sensitive internal services
• Deploy a reverse proxy with SSRF protection capabilities in front of the application

# Example iptables rules to block outbound SSRF to internal networks
iptables -A OUTPUT -d 10.0.0.0/8 -m owner --uid-owner www-data -j DROP
iptables -A OUTPUT -d 172.16.0.0/12 -m owner --uid-owner www-data -j DROP
iptables -A OUTPUT -d 192.168.0.0/16 -m owner --uid-owner www-data -j DROP
iptables -A OUTPUT -d 169.254.169.254 -m owner --uid-owner www-data -j DROP