Tester un proxy sous Windows, macOS et Linux

Un proxy peut servir à filtrer le trafic, sortir avec une autre adresse IP, diagnostiquer une application, accéder à un réseau d’entreprise ou tester une API.

Cependant, avant de l’utiliser sérieusement, une question s’impose : le proxy fonctionne-t-il réellement comme prévu ?

Un serveur proxy peut accepter une connexion sans être pleinement utilisable. Il peut être lent, refuser HTTPS, demander une authentification, utiliser une résolution DNS inattendue ou ne fonctionner que depuis certains réseaux.

Le test doit donc aller plus loin qu’une simple ouverture de page.

Dans ce guide, nous allons vérifier un proxy sous Windows, macOS et Linux avec les outils du système, curl, PowerShell et deux services de diagnostic reconnus :

• Cloudflare /cdn-cgi/trace pour connaître l’adresse IP vue depuis Internet ;
• Postman Echo pour examiner les en-têtes HTTP transmis à un serveur distant.

Cette approche évite de dépendre de petits services de diagnostic dont la réputation, l’hébergement ou la maintenance peuvent évoluer.

Ce qu’il faut réellement tester sur un proxy

Un bon diagnostic vérifie plusieurs éléments :

• Accessibilité : le serveur et son port répondent-ils ?
• Type de proxy : HTTP, HTTPS, SOCKS4 ou SOCKS5 ?
• Authentification : faut-il un identifiant et un mot de passe ?
• IP de sortie : le serveur distant voit-il l’adresse du proxy ?
• HTTPS : le proxy autorise-t-il les tunnels TLS ?
• DNS : les noms de domaine sont-ils résolus localement ou via le proxy ?
• En-têtes HTTP : le proxy ajoute-t-il des informations révélatrices ?
• Performance : quel délai ajoute-t-il ?
• Stabilité : fonctionne-t-il sur plusieurs requêtes successives ?

Un proxy peut parfaitement réussir trois tests et échouer au quatrième. Il vaut donc mieux procéder méthodiquement.

Comprendre les différents types de proxies

Avant de tester un proxy, identifiez son protocole.

Type	Exemple	Usage
HTTP	http://proxy.example.com:8080	HTTP et HTTPS via CONNECT
HTTPS	https://proxy.example.com:8443	Connexion chiffrée jusqu’au proxy
SOCKS4	socks4://proxy.example.com:1080	Ancien protocole SOCKS
SOCKS5	socks5://proxy.example.com:1080	Proxy générique
SOCKS5 avec DNS distant	socks5h://proxy.example.com:1080	Résolution DNS effectuée via le proxy

Cette distinction est importante. Tester un proxy SOCKS comme s’il s’agissait d’un proxy HTTP donnera généralement un échec, même lorsque le serveur fonctionne correctement.

Comment connaître l’IP publique utilisée par le proxy ?

ipconfig, ifconfig ou ip addr peuvent afficher les adresses de votre machine.

Ils ne peuvent cependant pas vous dire quelle adresse IP publique un serveur distant voit après le passage par un proxy HTTP ou SOCKS.

Pour cela, il faut nécessairement demander à un serveur distant quelle adresse IP il voit pour la connexion.

Nous utiliserons l’endpoint de diagnostic de Cloudflare :

https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Cloudflare renvoie quelques informations simples sur la connexion :

fl=...
h=cloudflare.com
ip=203.0.113.42
ts=...
visit_scheme=https
colo=CDG
http=http/2
loc=FR
tls=TLSv1.3

La ligne qui nous intéresse principalement est :

ip=203.0.113.42

Il s’agit de l’adresse IP vue par Cloudflare. C’est précisément ce dont nous avons besoin pour comparer une connexion directe et une connexion via proxy.

Commencer par relever son IP sans proxy

Sous Linux et macOS

Utilisez :

curl -sS https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Pour ne récupérer que l’adresse IP :

curl -sS https://cloudflare.com/cdn-cgi/trace \
    | awk -F= '$1 == "ip" { print $2 }'Langage du code : JavaScript (javascript)

Vous obtenez simplement :

203.0.113.42Langage du code : CSS (css)

Gardez cette valeur.

Sous Windows

Les versions modernes de Windows fournissent curl.exe.

Dans PowerShell ou l’invite de commandes :

curl.exe -sS https://cloudflare.com/cdn-cgi/trace | findstr /B "ip="Langage du code : JavaScript (javascript)

Par exemple :

ip=203.0.113.42

Vous pouvez également utiliser uniquement PowerShell :

$trace = Invoke-RestMethod `
    -Uri "https://cloudflare.com/cdn-cgi/trace"

($trace -split "`n" | Where-Object { $_ -like "ip=*" }) `
    -replace "^ip=", ""Langage du code : PHP (php)

Cette adresse servira de référence.

Tester un proxy HTTP avec curl

curl constitue probablement le moyen le plus pratique de tester un proxy.

Il est fourni avec macOS et les versions modernes de Windows. Sous Linux, il est souvent déjà installé et reste disponible dans les dépôts de toutes les grandes distributions.

Supposons que le proxy soit :

proxy.example.com:8080Langage du code : CSS (css)

Testez-le ainsi :

curl \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Vous pouvez également utiliser la forme courte :

curl \
    -x http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Pour afficher uniquement l’adresse IP :

curl -sS \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/trace \
    | awk -F= '$1 == "ip" { print $2 }'Langage du code : JavaScript (javascript)

Comparez cette adresse avec votre IP directe.

Si votre connexion directe affichait 203.0.113.42 et que le test via proxy affiche 198.51.100.18, le trafic utilisé pour cette requête sort bien avec une autre adresse IP.

Tester un proxy sous Windows avec curl.exe

La même méthode fonctionne sans installer de logiciel supplémentaire sur les versions modernes de Windows :

curl.exe -sS `
    --proxy http://proxy.example.com:8080 `
    https://cloudflare.com/cdn-cgi/trace |
    findstr /B "ip="Langage du code : JavaScript (javascript)

Vous pourriez obtenir :

ip=198.51.100.18

Comparez cette valeur avec celle obtenue sans --proxy.

Tester un proxy SOCKS5

Pour un proxy SOCKS5 :

curl \
    --proxy socks5://proxy.example.com:1080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Toutefois, cette syntaxe présente une particularité importante.

Avec socks5://, la résolution du nom de domaine peut être effectuée par votre machine.

Pour demander au proxy de résoudre également le nom de domaine, utilisez :

curl \
    --proxy socks5h://proxy.example.com:1080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Le h de socks5h indique que le nom d’hôte est transmis au proxy pour résolution.

Pour les tests où vous souhaitez éviter une résolution DNS locale, utilisez donc de préférence socks5h://.

Tester un proxy avec authentification

Si le proxy nécessite un identifiant et un mot de passe :

curl \
    --proxy http://proxy.example.com:8080 \
    --proxy-user username:password \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Une mauvaise authentification provoque généralement :

407 Proxy Authentication RequiredLangage du code : JavaScript (javascript)

Évitez toutefois de laisser des mots de passe sensibles dans votre historique de terminal ou dans un script en clair.

Pour une automatisation durable, utilisez plutôt un mécanisme adapté de gestion des secrets.

Vérifier que le proxy accepte HTTPS

Aujourd’hui, vérifier uniquement HTTP ne suffit pratiquement plus.

Lorsqu’un client accède à une URL HTTPS via un proxy HTTP, il demande généralement au proxy d’ouvrir un tunnel avec la méthode HTTP CONNECT.

Vous pouvez observer cette négociation avec :

curl -v \
    --proxy http://proxy.example.com:8080 \
    https://www.example.com/ \
    -o /dev/nullLangage du code : JavaScript (javascript)

Le mode verbeux permet d’observer :

• la connexion au proxy ;
• la requête CONNECT ;
• la réponse du proxy ;
• la négociation TLS ;
• la connexion au serveur final.

Parmi les erreurs courantes :

407 Proxy Authentication Required
403 Forbidden
502 Bad Gateway
Proxy CONNECT abortedLangage du code : JavaScript (javascript)

Un proxy peut donc accepter HTTP tout en refusant les tunnels HTTPS. Dans la plupart des usages modernes, cela constitue une limitation majeure.

Tester un proxy avec PowerShell

Windows permet également de réaliser le test avec PowerShell.

Invoke-RestMethod `
    -Uri "https://cloudflare.com/cdn-cgi/trace" `
    -Proxy "http://proxy.example.com:8080"Langage du code : JavaScript (javascript)

Le résultat contient notamment une ligne ip=.

Avec authentification :

$credential = Get-Credential

Invoke-RestMethod `
    -Uri "https://cloudflare.com/cdn-cgi/trace" `
    -Proxy "http://proxy.example.com:8080" `
    -ProxyCredential $credentialLangage du code : PHP (php)

Get-Credential évite ici de placer directement le mot de passe dans la commande.

Tester si le port du proxy répond sous Windows

Avant même de tester HTTP, Windows peut vérifier l’accessibilité du port :

Test-NetConnection proxy.example.com -Port 8080Langage du code : CSS (css)

Regardez notamment :

TcpTestSucceeded : TrueLangage du code : PHP (php)

Si la valeur est False, le problème se situe probablement plus bas : serveur inaccessible, port incorrect, pare-feu, filtrage réseau, mauvaise adresse ou service arrêté.

Vérifier le proxy WinHTTP sous Windows

Windows possède également une configuration WinHTTP utilisée par certains services et certaines applications.

Affichez-la avec :

netsh winhttp show proxy

Vous pouvez réinitialiser cette configuration avec :

netsh winhttp reset proxy

Certaines applications utilisent les paramètres proxy de l’utilisateur tandis que d’autres utilisent WinHTTP.

C’est pourquoi un navigateur peut fonctionner alors qu’un service Windows échoue.

Configurer un proxy dans Windows

1. Ouvrez Paramètres.
2. Choisissez Réseau et Internet.
3. Ouvrez Proxy.
4. Configurez le proxy manuel ou automatique.
5. Enregistrez.

Ouvrez ensuite dans votre navigateur :

https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Repérez la ligne ip= et comparez-la avec votre IP obtenue avant l’activation du proxy.

Cette méthode vérifie le comportement réel du navigateur, et pas seulement celui de curl.

Vérifier un proxy sur macOS

macOS fournit plusieurs utilitaires réseau intéressants.

Pour afficher une vue d’ensemble de la configuration proxy :

scutil --proxy

Vous pouvez également utiliser networksetup.

Commencez par afficher les services réseau :

networksetup -listallnetworkservices

Vérifiez le proxy HTTP du Wi-Fi :

networksetup -getwebproxy "Wi-Fi"Langage du code : JavaScript (javascript)

Puis le proxy HTTPS :

networksetup -getsecurewebproxy "Wi-Fi"Langage du code : JavaScript (javascript)

Pour un fichier PAC :

networksetup -getautoproxyurl "Wi-Fi"Langage du code : JavaScript (javascript)

Pour la découverte automatique :

networksetup -getproxyautodiscovery "Wi-Fi"Langage du code : JavaScript (javascript)

Remplacez Wi-Fi si votre interface porte un autre nom.

Ensuite, vérifiez l’adresse réellement vue sur Internet :

curl -sS https://cloudflare.com/cdn-cgi/trace \
    | awk -F= '$1 == "ip" { print $2 }'Langage du code : JavaScript (javascript)

Tester un proxy sous Linux

Linux ne possède pas une configuration universelle de proxy HTTP appliquée automatiquement à toutes les applications.

Un proxy peut être défini :

• dans l’environnement du shell ;
• dans GNOME ou KDE ;
• dans le navigateur ;
• dans systemd ;
• dans APT ;
• dans Docker ;
• dans une application précise.

Pour un diagnostic propre, commencez donc par tester directement avec curl :

curl -sS \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Puis vérifiez éventuellement les variables existantes :

env | grep -i proxy

Vous pourrez ainsi distinguer un problème de proxy d’un problème de configuration de l’application.

Utiliser les variables d’environnement proxy

De nombreux logiciels respectent les variables suivantes :

http_proxy
https_proxy
no_proxy

Par exemple :

export http_proxy="http://proxy.example.com:8080"
export https_proxy="http://proxy.example.com:8080"
export no_proxy="localhost,127.0.0.1,.local"Langage du code : JavaScript (javascript)

Testez ensuite :

curl https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Pour supprimer ces variables :

unset http_proxy
unset https_proxy
unset no_proxyLangage du code : PHP (php)

Vous rencontrerez également HTTPS_PROXY, NO_PROXY et ALL_PROXY dans certains environnements.

Attention toutefois à une particularité de curl : http_proxy est volontairement accepté uniquement en minuscules.

Pour éviter les comportements différents entre applications, utilisez donc de préférence les formes minuscules lorsque vous contrôlez l’environnement.

La variable no_proxy mérite également votre attention. Elle permet d’empêcher l’envoi de certaines destinations vers le proxy :

export no_proxy="localhost,127.0.0.1,.local,.example.internal"Langage du code : JavaScript (javascript)

C’est particulièrement important pour les applications qui communiquent avec des services locaux ou internes.

Tester un proxy dans Firefox

Firefox permet d’utiliser une configuration proxy indépendante du système.

1. Ouvrez Paramètres.
2. Ouvrez la section Général.
3. Descendez jusqu’à Paramètres réseau.
4. Choisissez Paramètres.
5. Sélectionnez une configuration manuelle.
6. Renseignez le proxy.
7. Validez.

Ouvrez ensuite :

https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Comparez la valeur ip= avec votre IP directe.

Pour un proxy SOCKS, utilisez le champ SOCKS de Firefox et activez la résolution DNS via SOCKS si votre configuration l’exige.

Pour des tests réguliers, un profil Firefox distinct est une bonne idée. Vous évitez ainsi de mélanger cookies personnels, extensions, sessions ouvertes, authentifications et paramètres réseau de production.

Tester dans Chrome, Edge ou Safari

Chrome, Edge et Safari utilisent généralement les paramètres proxy du système.

Une méthode simple consiste donc à :

1. relever votre IP directe ;
2. activer le proxy système ;
3. ouvrir une fenêtre privée ;
4. visiter l’endpoint de diagnostic Cloudflare ;
5. comparer le champ ip=.

Vous vérifiez ainsi que le navigateur lui-même passe effectivement par le proxy.

Vérifier les en-têtes envoyés par le proxy

Changer d’adresse IP ne signifie pas nécessairement qu’un proxy ne transmet aucune information supplémentaire.

Certains proxies ajoutent des en-têtes comme :

X-Forwarded-For
Forwarded
Via
Client-IP
X-Real-IP

Pour observer les en-têtes réellement reçus par un service distant, vous pouvez utiliser Postman Echo.

Avec curl :

curl -sS \
    --proxy http://proxy.example.com:8080 \
    https://postman-echo.com/getLangage du code : JavaScript (javascript)

Si jq est installé :

curl -sS \
    --proxy http://proxy.example.com:8080 \
    https://postman-echo.com/get \
    | jq '.headers'Langage du code : JavaScript (javascript)

Examinez en particulier les éventuels champs x-forwarded-for, forwarded, via et x-real-ip.

Si votre véritable IP apparaît explicitement dans un de ces en-têtes, le proxy transmet cette information au service distant.

Attention cependant : un service d’écho ne peut montrer que les en-têtes qui lui parviennent effectivement. Un intermédiaire situé devant le service peut lui-même modifier ou supprimer certains champs.

Ce test complète donc la vérification de l’adresse IP, mais ne constitue pas à lui seul un audit complet d’anonymat.

Tester les éventuelles fuites DNS

La question DNS concerne surtout les proxies SOCKS.

Comparez :

curl -v \
    --proxy socks5://proxy.example.com:1080 \
    https://www.example.com/ \
    -o /dev/nullLangage du code : JavaScript (javascript)

avec :

curl -v \
    --proxy socks5h://proxy.example.com:1080 \
    https://www.example.com/ \
    -o /dev/nullLangage du code : JavaScript (javascript)

Avec socks5h, le nom de destination est transmis au proxy afin qu’il effectue lui-même la résolution.

Cette approche est plus pertinente qu’un simple test d’adresse IP lorsque vous voulez contrôler le chemin DNS.

Un proxy n’est toutefois pas un VPN. Le fait qu’un navigateur utilise un proxy ne signifie pas que toutes les résolutions DNS et toutes les applications de la machine utilisent le même chemin.

Mesurer la vitesse du proxy

Un proxy peut fonctionner tout en étant inutilisable au quotidien.

Mesurez donc ses délais :

curl \
    --proxy http://proxy.example.com:8080 \
    -o /dev/null \
    -sS \
    -w "connect=%{time_connect}s tls=%{time_appconnect}s first_byte=%{time_starttransfer}s total=%{time_total}s\n" \
    https://www.example.com/Langage du code : JavaScript (javascript)

Vous obtenez plusieurs valeurs utiles :

• time_connect : temps nécessaire pour joindre le proxy ;
• time_appconnect : durée de la négociation TLS ;
• time_starttransfer : délai avant le premier octet ;
• time_total : durée complète de la requête.

Exécutez le test plusieurs fois. Une seule requête rapide n’indique pas forcément un proxy rapide. Elle indique surtout qu’une requête a eu de la chance.

Tester plusieurs proxies automatiquement

Si vous avez une liste de proxies, créez un fichier proxies.txt avec par exemple :

http://proxy1.example.com:8080
http://proxy2.example.com:3128
socks5h://proxy3.example.com:1080Langage du code : JavaScript (javascript)

Puis utilisez :

while IFS= read -r proxy; do
    [ -z "$proxy" ] && continue

    response="$(
        curl \
            --proxy "$proxy" \
            --connect-timeout 5 \
            --max-time 12 \
            -fsS \
            https://cloudflare.com/cdn-cgi/trace \
            2>/dev/null
    )"

    if [ $? -ne 0 ]; then
        printf "%-45s %s\n" "$proxy" "FAILED"
        continue
    fi

    ip="$(
        printf '%s\n' "$response" \
            | awk -F= '$1 == "ip" { print $2 }'
    )"

    printf "%-45s %s\n" "$proxy" "${ip:-NO_IP}"
done < proxies.txtLangage du code : PHP (php)

Cette version est plus utile qu’un simple test HTTP 200. Elle affiche directement l’adresse IP réellement observée pour chaque proxy.

Tester si le port du proxy répond

Linux et macOS

Avec nc :

nc -vz proxy.example.com 8080Langage du code : CSS (css)

Si nmap est installé :

nmap -Pn -p 8080 proxy.example.comLangage du code : CSS (css)

Windows

Test-NetConnection proxy.example.com -Port 8080Langage du code : CSS (css)

Si le port ne répond pas, les tests HTTP plus avancés n’apporteront pas grand-chose. Commencez par régler la connectivité TCP.

Comprendre les erreurs courantes

Erreur	Cause probable	Action
Connection refused	Aucun service sur le port	Vérifier le port
Connection timed out	Filtrage ou proxy indisponible	Vérifier le pare-feu et le réseau
407 Proxy Authentication Required	Authentification nécessaire	Fournir les identifiants
403 Forbidden	Destination interdite	Vérifier les règles du proxy
502 Bad Gateway	Le proxy ne joint pas la destination	Tester la destination séparément
Could not resolve host	Problème DNS	Vérifier la résolution
Proxy CONNECT aborted	Tunnel HTTPS refusé	Vérifier CONNECT
Code curl 000	Aucune réponse HTTP exploitable	Relancer avec -v

En cas de doute :

curl -v \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Le mode verbeux permet souvent de localiser précisément l’étape qui échoue.

Tester un proxy utilisé par une API

Un test avec Cloudflare confirme le fonctionnement général du proxy.

Il ne garantit cependant pas que votre véritable destination acceptera cette adresse IP.

Après le test générique, testez donc toujours l’API finale :

curl \
    --proxy http://proxy.example.com:8080 \
    -H "Authorization: Bearer YOUR_TOKEN" \
    -H "Accept: application/json" \
    https://api.example.com/v1/statusLangage du code : JavaScript (javascript)

Une API peut :

• bloquer l’adresse IP du proxy ;
• filtrer certains ASN ;
• limiter le nombre de requêtes ;
• refuser certains pays ;
• exiger une version particulière de TLS ;
• détecter un proxy intermédiaire ;
• imposer une liste blanche d’adresses IP.

Le proxy peut donc fonctionner parfaitement avec Cloudflare tout en échouant auprès de votre API.

Tester un proxy depuis un serveur WordPress ou WooCommerce

Les erreurs réseau dans WordPress et WooCommerce peuvent parfois ressembler à des problèmes applicatifs :

• erreur cURL ;
• timeout ;
• webhook inaccessible ;
• licence impossible à valider ;
• API Stripe inaccessible ;
• service externe bloqué ;
• connexion à WordPress.org impossible.

Avant de modifier WordPress, testez directement depuis le serveur :

curl -v https://api.wordpress.org/Langage du code : JavaScript (javascript)

Puis, si un proxy doit être utilisé :

curl -v \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Vérifiez également l’environnement :

env | grep -i proxy

Si l’application fonctionne avec curl mais pas avec PHP ou WordPress, concentrez ensuite le diagnostic sur PHP-FPM, les variables d’environnement, systemd, la configuration de l’application, les règles du pare-feu, AppArmor ou le code utilisant l’API HTTP WordPress.

Cette méthode évite de modifier WordPress alors que le problème se situe en réalité une couche plus bas.

Proxy et VPN : deux choses différentes

Un proxy ne couvre généralement qu’une application ou un protocole donné.

Par exemple :

• Firefox peut utiliser un proxy ;
• votre client mail peut sortir directement ;
• curl peut avoir une autre configuration ;
• un service systemd peut encore utiliser une autre route.

Un VPN agit généralement à un niveau réseau plus large.

Il est donc parfaitement possible que votre navigateur affiche l’adresse du proxy alors qu’une autre application affiche votre IP habituelle. Ce n’est pas nécessairement un dysfonctionnement.

Checklist pour tester un proxy

• Relevez votre IP directe avec Cloudflare Trace.
• Identifiez le protocole du proxy.
• Vérifiez que son port répond.
• Testez-le explicitement avec curl --proxy.
• Comparez l’IP directe et l’IP via proxy.
• Vérifiez HTTPS.
• Vérifiez l’authentification.
• Utilisez socks5h lorsqu’une résolution DNS distante est nécessaire.
• Contrôlez les en-têtes avec Postman Echo.
• Mesurez les temps de réponse.
• Réalisez plusieurs requêtes.
• Testez ensuite l’application réelle.
• Vérifiez les variables http_proxy, https_proxy et no_proxy.

Questions fréquentes sur le test d’un proxy

Comment savoir si mon proxy fonctionne ?

Comparez l’adresse IP vue sans proxy et celle obtenue avec le proxy.

Sans proxy :

curl -sS https://cloudflare.com/cdn-cgi/trace \
    | awk -F= '$1 == "ip" { print $2 }'Langage du code : JavaScript (javascript)

Avec proxy :

curl -sS \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/trace \
    | awk -F= '$1 == "ip" { print $2 }'Langage du code : JavaScript (javascript)

Si l’adresse change et que la requête fonctionne, le trafic de ce test passe bien par une autre adresse de sortie.

Comment tester un proxy sous Windows ?

Utilisez Test-NetConnection pour vérifier le port, puis curl.exe --proxy ou Invoke-RestMethod -Proxy pour effectuer une requête réelle.

Vous pouvez également vérifier WinHTTP avec :

netsh winhttp show proxy

Comment tester un proxy sur macOS ?

Utilisez scutil --proxy ou networksetup pour examiner la configuration.

Pour un test isolé et reproductible, utilisez ensuite curl --proxy.

Comment tester un proxy sous Linux ?

Utilisez directement curl --proxy, puis vérifiez éventuellement les variables d’environnement :

env | grep -i proxy

Sous Linux, la configuration du proxy dépend souvent de l’application ou de l’environnement utilisé.

Quelle différence existe-t-il entre socks5 et socks5h ?

Avec socks5, la résolution DNS de la destination peut être effectuée localement.

Avec socks5h, curl transmet le nom d’hôte au proxy afin que celui-ci effectue la résolution.

Pourquoi le proxy fonctionne-t-il dans Firefox mais pas dans Chrome ?

Firefox peut utiliser sa propre configuration proxy. Chrome utilise généralement les réglages réseau du système.

Ils peuvent donc emprunter deux chemins différents.

Pourquoi curl renvoie-t-il un code 000 ?

000 n’est pas un véritable code HTTP envoyé par le serveur.

Il signifie que curl n’a pas reçu de réponse HTTP exploitable.

Cela peut venir d’un timeout, d’une erreur DNS, d’un mauvais protocole, d’un port fermé, d’un proxy inaccessible ou d’un tunnel HTTPS refusé.

Relancez la commande avec :

curl -v

pour obtenir davantage d’informations.

Peut-on connaître l’IP publique d’un proxy uniquement avec ipconfig ou ip addr ?

Non.

Ces commandes décrivent les interfaces de votre machine. Elles ne peuvent pas déterminer quelle adresse IP un serveur distant voit après le passage par un proxy applicatif.

Pour le savoir, un serveur situé de l’autre côté de la connexion doit vous indiquer l’adresse source qu’il voit.

C’est précisément le rôle du test Cloudflare utilisé dans ce guide.

Conclusion

Tester un proxy correctement demande plus qu’une page qui « semble fonctionner ».

Il faut vérifier successivement la connectivité TCP, le protocole, l’authentification, l’IP de sortie, HTTPS, la résolution DNS, les éventuels en-têtes ajoutés, la latence et le comportement de l’application finale.

Pour vérifier l’adresse de sortie, Cloudflare Trace fournit un test particulièrement simple :

curl \
    --proxy http://proxy.example.com:8080 \
    https://cloudflare.com/cdn-cgi/traceLangage du code : JavaScript (javascript)

Pour inspecter les en-têtes reçus côté serveur, Postman Echo complète utilement ce test.

Enfin, les outils natifs de Windows, macOS et Linux permettent de diagnostiquer la configuration et la connectivité sans installer une collection d’utilitaires obscurs.

Un proxy bien testé permet de savoir exactement quelle couche fonctionne. Un proxy mal testé permet surtout de devenir très bon pour regarder des timeouts.

Sources

• curl — documentation officielle
• Everything curl — proxies HTTP
• Everything curl — proxies SOCKS
• Everything curl — variables d’environnement proxy
• Cloudflare — endpoint /cdn-cgi/
• Cloudflare — vérification de l’adresse IP via un proxy
• Postman — Echo API
• Microsoft — utiliser un serveur proxy dans Windows
• Apple — modifier les réglages proxy sur macOS
• Mozilla — paramètres de connexion de Firefox

Report a typo