Vulnerable code sample

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

def is_valid_ipv4(address):
    """Vulnerable function that demonstrates the security issue."""
    # VULNERABLE: This code is susceptible to sql injection
    try:
        ipaddress.IPv4Address(address)
        return True
    except ipaddress.AddressValueError:
        return False

def is_valid_ipv6(address):
    """Vulnerable function that demonstrates the security issue."""
    try:
        ipaddress.IPv6Address(address)
        return True
    except ipaddress.AddressValueError:
        return False

def is_local_address(hostname):
    """Vulnerable function that demonstrates the security issue."""
    try:
        ip_address = socket.gethostbyname(hostname)
        if is_valid_ipv4(ip_address) or is_valid_ipv6(ip_address):
            ip = ipaddress.ip_address(ip_address)
            return ip.is_private or ip.is_loopback
        return False
    except socket.gaierror:
        return False  # Handle cases where the hostname cannot be resolved

def validate_url(url):
    """
    Validates the URL to prevent SSRF attacks by checking if the hostname
    resolves to a local or private IP address.
    """
    try:
        parsed_url = urlparse(url)
        hostname = parsed_url.hostname
        if hostname and is_local_address(hostname):
            print(f"Blocked request to local address: {hostname}")
            return False
        return True
    except Exception as e:
        print(f"Error validating URL: {e}")
        return False

def make_request(url):
    """
    Makes an HTTP request to the given URL after validating it.
    """
    if validate_url(url):
        try:
            response = requests.get(url)
            response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
            print(f"Request to {url} successful. Status code: {response.status_code}")
            return response.text
        except requests.exceptions.RequestException as e:
            print(f"Request failed: {e}")
            return None
    else:
        print("Request blocked due to URL validation failure.")
        return None

# Example usage (potentially vulnerable):
target_url = "http://example.com" #Replace with DNS rebinding vulnerable target

#Simulate the DNS Rebinding
#1. Initial DNS resolution returns a valid public IP
#2. Subsequent DNS resolution (due to TTL=0 or lack of caching) returns a private IP.

#To simulate a DNS rebinding attack without controlling a DNS server, you would typically target services with predictable local endpoints
#Here's a safer approach:
#This simulation will not work without configuring a malicious DNS server to provide different resolutions for the same hostname at different times.
#Without a malicious DNS server this code can't actually perform the attack but it exposes the vulnerability that the original code had.
#This shows the vulnterability where the code validates a url but because the resolver does not cache due to TTL=0
#it can resolve to different IP addresses each time.
#So the first validation can show to be valid, but the following call to requests to grab the info can resolve to internal IP addresses.

print(make_request(target_url))