FastAPI (Python)

FastAPI est conçu pour des applications web asynchrones très performantes. Pour maintenir cette vitesse, nous intégrons ProxyTracer à l'aide d'un BaseHTTPMiddleware personnalisé et d'un client HTTP asynchrone (httpx) pour s'assurer que la boucle d'événements n'est jamais bloquée.

L'Intergiciel

Cette implémentation extrait en toute sécurité la véritable adresse IP du client, utilise un pool de connexions asynchrones pour interroger ProxyTracer, et renvoie un strict 403 Forbidden si le drapeau proxy est vrai.


import os
import httpx
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware
 
app = FastAPI()
 
class ProxyTracerMiddleware(BaseHTTPMiddleware):
    def __init__(self, app):
        super().__init__(app)
        self.api_key = os.getenv("PROXYTRACER_API_KEY")
        # Initialiser un client asynchrone persistant pour le pooling de connexions et une vitesse brute
        self.client = httpx.AsyncClient(timeout=0.5) # Délai d'attente strict de 500ms
 
    async def dispatch(self, request: Request, call_next):
        # 1. Extraire en toute sécurité l'IP réelle derrière les équilibreurs de charge/proxys
        forwarded_for = request.headers.get("x-forwarded-for")
        if forwarded_for:
            ip = forwarded_for.split(",")[0].strip()
        else:
            ip = request.client.host if request.client else None
 
        # Ignorer les IP de développement local
        if ip and ip not in ["127.0.0.1", "::1", "testclient"]:
            try:
                # 2. Interroger l'API ProxyTracer de manière asynchrone
                response = await self.client.get(
                    f"https://api.proxytracer.com/v1/check/{ip}",
                    headers={"Authorization": f"Bearer {self.api_key}"}
                )
                
                if response.status_code == 200:
                    data = response.json()
                    
                    # 3. Interrompre immédiatement la connexion si un proxy est détecté
                    if data.get("proxy") is True:
                        return JSONResponse(
                            status_code=status.HTTP_403_FORBIDDEN,
                            content={"error": "Access Denied: VPN or Proxy detected."}
                        )
            except httpx.RequestError as e:
                # Fail open : journaliser l'erreur réseau et autoriser la requête à se poursuivre
                print(f"ProxyTracer API timeout or failure: {e}")
 
        # 4. Le trafic est sain, poursuivre vers le gestionnaire de route
        return await call_next(request)
 
# Appliquer le middleware globalement
app.add_middleware(ProxyTracerMiddleware)

Note de dépendance: Cette implémentation nécessite la bibliothèque httpx pour les requêtes HTTP asynchrones. Installez-la via pip install httpx.