Patched code sample

import socket
import ipaddress
import requests
from urllib.parse import urlparse

# This code represents a robust fix for a Server-Side Request Forgery (SSRF)
# vulnerability. The principles shown here are standard for preventing an application
# from making unintended network requests to internal or reserved IP addresses.

# The vulnerability (CVE-2024-25580, not CVE-2026-25580) was in Pydantic AI's
# URL download functionality. The fix involves validating a URL before
# making an HTTP request.

def is_safe_url(url: str) -> bool:
    """
    Validates if a URL is safe to request by checking if its resolved IP address
    is a public, non-reserved IP.
    """
    try:
        parsed_url = urlparse(url)

        # 1. Scheme Check: Only allow HTTP and HTTPS protocols.
        if parsed_url.scheme not in ('http', 'https'):
            return False

        # 2. Hostname Check: Ensure hostname exists.
        hostname = parsed_url.hostname
        if not hostname:
            return False

        # 3. IP Resolution: Resolve the hostname to an IP address.
        # This is a critical step to prevent DNS rebinding attacks where an attacker
        # might return a public IP first, then a private one later.
        # We resolve it *before* the request is made.
        ip_addr_str = socket.gethostbyname(hostname)
        ip_addr = ipaddress.ip_address(ip_addr_str)

        # 4. IP Address Validation: Check if the resolved IP is private,
        # loopback, link-local, or otherwise reserved.
        # This prevents requests to internal network resources (e.g., 127.0.0.1,
        # 192.168.x.x, 10.x.x.x) or cloud metadata services (e.g., 169.254.169.254).
        if not ip_addr.is_global or ip_addr.is_private or ip_addr.is_loopback or ip_addr.is_link_local or ip_addr.is_multicast or ip_addr.is_reserved:
            return False

        # If all checks pass, the URL is considered safe.
        return True

    except (ValueError, socket.gaierror, TypeError):
        # ValueError for ipaddress, gaierror for DNS resolution, TypeError for urlparse
        return False

def safe_url_downloader(url: str, timeout: int = 5):
    """
    Downloads content from a URL only after it has been validated as safe.
    This function represents the fixed behavior.
    """
    print(f"Attempting to download from: {url}")

    if is_safe_url(url):
        try:
            print(f"URL is safe. Proceeding with download...")
            response = requests.get(url, timeout=timeout)
            response.raise_for_status()  # Raise an exception for bad status codes
            print("Download successful.")
            return response.text
        except requests.RequestException as e:
            print(f"An error occurred during download: {e}")
            return None
    else:
        # This is the protective action. The request is blocked.
        print("Download blocked: URL is not safe (points to a private, reserved, or invalid address).")
        return None

if __name__ == '__main__':
    # --- Test Cases ---

    # Example of a safe, public URL (should be allowed)
    safe_url = "https://www.google.com"
    safe_url_downloader(safe_url)

    print("\n" + "="*40 + "\n")

    # Example of a URL pointing to localhost (should be blocked)
    ssrf_url_localhost = "http://127.0.0.1/server-info"
    safe_url_downloader(ssrf_url_localhost)

    print("\n" + "="*40 + "\n")

    # Example of a URL pointing to a private network IP (should be blocked)
    ssrf_url_private = "http://192.168.1.1/router-admin"
    safe_url_downloader(ssrf_url_private)

    print("\n" + "="*40 + "\n")

    # Example of a URL pointing to the AWS metadata service (should be blocked)
    ssrf_url_metadata = "http://169.254.169.254/latest/meta-data/iam/security-credentials/"
    safe_url_downloader(ssrf_url_metadata)

    print("\n" + "="*40 + "\n")
    
    # Example using a different scheme (should be blocked)
    unsafe_scheme_url = "file:///etc/passwd"
    safe_url_downloader(unsafe_scheme_url)