# AWS : Imposer IMDSv2 (requiert un accès basé sur des tokens)
aws ec2 modify-instance-metadata-options \
  --instance-id i-1234567890 \
  --http-tokens required \
  --http-put-response-hop-limit 1

# Déployer un proxy de dissimulation de métadonnées (comme Shopify)
# Bloquer 169.254.169.254 au niveau de l'hôte avec iptables/nftables.
# NOTE : les Security Groups et NACL AWS n'y peuvent rien - le trafic
# link-local ne quitte jamais l'ENI. Utilisez IMDSv2 + une règle locale.

# Kubernetes : Bloquer les métadonnées via NetworkPolicy
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: block-metadata
spec:
  podSelector: {}
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 169.254.169.254/32

import ipaddress
import urllib.parse
import socket

ALLOWED_SCHEMES = {'https'}
BLOCKED_NETWORKS = [
    ipaddress.ip_network('127.0.0.0/8'), # Loopback
    ipaddress.ip_network('10.0.0.0/8'), # Privé
    ipaddress.ip_network('172.16.0.0/12'), # Privé
    ipaddress.ip_network('192.168.0.0/16'), # Privé
    ipaddress.ip_network('169.254.0.0/16'), # Link-local (métadonnées !)
    ipaddress.ip_network('0.0.0.0/8'), # Spécial
    ipaddress.ip_network('::1/128'), # Loopback IPv6
    ipaddress.ip_network('::ffff:0:0/96'), # IPv6 mappé IPv4
    ipaddress.ip_network('100.64.0.0/10'), # CGNAT — l'IMDS d'Alibaba est en 100.100.100.200
    ipaddress.ip_network('fc00::/7'), # IPv6 unique-local
    ipaddress.ip_network('fd00:ec2::/32'), # IMDS IPv6 d'AWS
]

def validate_url(url: str) -> bool:
    parsed = urllib.parse.urlparse(url)
    
    # 1. Protocole en liste blanche
    if parsed.scheme not in ALLOWED_SCHEMES:
        return False
    
    # 2. Résoudre le nom et vérifier TOUTES les réponses, pas seulement la
    #    première. Un hôte renvoyant à la fois un enregistrement public et un
    #    privé passerait sur [0] puis se connecterait au privé.
    try:
        answers = socket.getaddrinfo(parsed.hostname, None)
    except socket.gaierror:
        return False

    ips = set()
    for family, _, _, _, sockaddr in answers:
        try:
            ips.add(ipaddress.ip_address(sockaddr[0]))
        except ValueError:
            return False          # échec fermé sur tout ce qui est illisible
    if not ips:
        return False

    # 3. Échec fermé si UNE SEULE des adresses résolues est bloquée
    for ip in ips:
        for network in BLOCKED_NETWORKS:
            if ip in network:
                return False
    
    # 4. Re-valider après redirection (critique contre le DNS rebinding !)
    return True

# Stratégie d'épinglage DNS
def safe_fetch(url: str) -> bytes:
    parsed = urllib.parse.urlparse(url)
    
    # Étape 1 : Résoudre et valider
    resolved_ip = resolve_and_validate(parsed.hostname)
    
    # Étape 2 : Se connecter directement à l'IP résolue (contourne le DNS)
    # Empêche le DNS rebinding entre la validation et la requête
    response = requests.get(
        url,
        headers={'Host': parsed.hostname},
        allow_redirects=False, # Gérer les redirections manuellement !
        timeout=5,
        # Forcer la connexion à l'IP validée
        # via un adaptateur personnalisé ou un override de socket
    )
    
    # Étape 3 : Valider toute URL de redirection avant de la suivre
    if response.is_redirect:
        redirect_url = response.headers['Location']
        validate_url(redirect_url) # Re-valider !
    
    return response.content

# Proxy egress de type Smokescreen (utilisé par Stripe, Shopify)
# Tout le HTTP sortant de l'application transite par ce proxy
# Le proxy impose :
# - Aucune connexion aux plages IP internes
# - Aucune connexion aux endpoints de métadonnées cloud
# - Aucune connexion aux domaines refusés
# - La résolution DNS se fait dans le proxy (empêche le rebinding)

proxy_config:
  deny_ranges:
    - "127.0.0.0/8"
    - "10.0.0.0/8"
    - "169.254.0.0/16"
    - "172.16.0.0/12"
    - "192.168.0.0/16"
  deny_domains:
    - "*.internal"
    - "metadata.google.internal"