Créez un configurateur SOCKS5 local pour chaîner et faire tourner des proxys ChangeMyIP (Windows, macOS, Linux)

Aperçu

Un configurateur SOCKS5 est un petit service local qui écoute sur un port de votre machine et transfère tout ce que vos applications lui envoient vers un proxy en amont, ou à travers une chaîne de proxys. C'est la solution pratique lorsqu'une application n'a pas ses propres paramètres de proxy, ou lorsque vous souhaitez que plusieurs applications sans lien partagent une même configuration de proxy au lieu de modifier chacune séparément.

Dans ce tutoriel, vous allez construire ce configurateur avec gost, un outil proxy open source, et le pointer vers des points de terminaison SOCKS5 ChangeMyIP. Vous ajouterez ensuite un second saut pour le chaînage de pays à pays, effectuerez une rotation entre plusieurs points de terminaison au sein d'un saut, garderez les identifiants hors de vue, et exécuterez l'écouteur de manière persistante sur Windows, macOS et Linux.

N'importe quel fournisseur SOCKS5 fonctionne avec la configuration ci-dessous. ChangeMyIP est utilisé comme exemple parce qu'il propose SOCKS5 sur des points de terminaison de datacenter dédiés et partagés ainsi que des points de terminaison résidentiels rotatifs, et parce qu'une facturation mensuelle forfaitaire signifie qu'un écouteur local toujours actif n'ajoute aucun coût par requête.

Prérequis

• Un forfait ChangeMyIP qui inclut l'accès SOCKS5, ainsi que l'hôte, le port, le nom d'utilisateur et le mot de passe de votre point de terminaison depuis le tableau de bord.
• Un point de terminaison pour chaque saut que vous prévoyez de chaîner (le chaînage nécessite deux points de terminaison indépendants).
• L'autorisation de lier un écouteur sur 127.0.0.1:1080, ou tout port local libre.
• curl pour la vérification.
• Une aisance de base pour modifier un fichier YAML.

Comment le configurateur se place entre vos applications et ChangeMyIP

Chemin du trafic :

1. Une application ouvre une connexion SOCKS5 vers 127.0.0.1:1080.
2. Le configurateur l'accepte et transfère la session vers le premier point de terminaison ChangeMyIP (le saut d'entrée).
3. Si un second saut est défini, le point de terminaison d'entrée ouvre une connexion vers le point de terminaison de sortie.
4. Le point de terminaison de sortie effectue la requête sortante et la réponse remonte la chaîne.

Ce que cela vous apporte :

• Un port local unique que toute application peut utiliser, y compris les applications sans paramètres de proxy intégrés.
• La résolution DNS distante, afin que les recherches de noms ne fuient pas vers votre résolveur local lorsque vous utilisez le schéma socks5h.
• Une sortie déterministe : un point de terminaison de datacenter pour une IP stable, ou un point de terminaison résidentiel rotatif lorsque vous avez besoin de diversité d'IP.
• Le routage en chaîne : forcez le trafic à passer par une paire d'emplacements spécifique en chaînant deux points de terminaison.

Étapes

1. Classez les points de terminaison ChangeMyIP que vous allez utiliser. Copiez l'hôte, le port, le nom d'utilisateur et le mot de passe pour chacun, et notez s'il s'agit d'un point de terminaison de datacenter dédié, d'un point de terminaison de datacenter partagé ou d'un point de terminaison résidentiel rotatif.

2. Installez gost. Téléchargez l'archive de version correspondant à votre système d'exploitation et à votre architecture depuis la page officielle des versions de gost, puis extrayez-la.

Windows (PowerShell) :

Expand-Archive -Path .\gost_*_windows_amd64.zip -DestinationPath .\gost
.\gost\gost.exe -V

macOS et Linux (utilisez l'archive darwin ou linux et la build correspondante amd64 ou arm64) :

tar -xzf gost_*_linux_amd64.tar.gz
sudo install -m 0755 gost /usr/local/bin/gost
gost -V

3. Créez la configuration du configurateur pour un saut unique. Enregistrez-la sous gost.yaml et restreignez son accès, car elle contient des identifiants.

chmod 600 gost.yaml

services:
  - name: socks-in
    addr: "127.0.0.1:1080"
    handler:
      type: socks5
      chain: cmi-single
    listener:
      type: tcp

chains:
  - name: cmi-single
    hops:
      - name: hop-exit
        nodes:
          - name: exit-dc
            addr: proxy-host.example:1080
            connector:
              type: socks5
              auth:
                username: YOUR_USERNAME
                password: YOUR_PASSWORD

Remplacez proxy-host.example:1080 par le point de terminaison de votre tableau de bord ChangeMyIP et renseignez les identifiants fournis avec votre forfait.

4. Démarrez l'écouteur et faites un test de fumée.

gost -C gost.yaml

Dans un second terminal, confirmez que l'IP de sortie appartient au proxy et non à vous :

curl --silent --show-error --proxy socks5h://127.0.0.1:1080 https://api.ipify.org
echo
curl --silent https://api.ipify.org
echo

La première requête doit indiquer l'adresse du point de terminaison ChangeMyIP ; la seconde indique votre propre connexion.

5. Ajoutez un second saut pour chaîner deux emplacements. La requête passe par l'application, puis le point de terminaison d'entrée, puis le point de terminaison de sortie, puis le site cible. Le site voit l'adresse du point de terminaison de sortie ; le point de terminaison de sortie voit le point de terminaison d'entrée comme son client.

services:
  - name: socks-in
    addr: "127.0.0.1:1080"
    handler:
      type: socks5
      chain: cmi-two-hop
    listener:
      type: tcp

chains:
  - name: cmi-two-hop
    hops:
      - name: hop-entry
        nodes:
          - name: entry-de
            addr: entry-host.example:1080
            connector:
              type: socks5
              auth:
                username: YOUR_USERNAME
                password: YOUR_PASSWORD
      - name: hop-exit
        nodes:
          - name: exit-us
            addr: exit-host.example:1080
            connector:
              type: socks5
              auth:
                username: YOUR_USERNAME
                password: YOUR_PASSWORD

6. Effectuez une rotation entre les points de terminaison au sein d'un saut avec un sélecteur. C'est ainsi que vous répartissez le trafic sur plusieurs adresses distinctes au lieu d'épingler un seul nœud.

      - name: hop-exit
        selector:
          strategy: round
          maxFails: 1
          failTimeout: 30s
        nodes:
          - name: exit-us-1
            addr: exit-us-1.example:1080
            connector:
              type: socks5
              auth:
                username: YOUR_USERNAME
                password: YOUR_PASSWORD
          - name: exit-us-2
            addr: exit-us-2.example:1080
            connector:
              type: socks5
              auth:
                username: YOUR_USERNAME
                password: YOUR_PASSWORD
          - name: exit-us-3
            addr: exit-us-3.example:1080
            connector:
              type: socks5
              auth:
                username: YOUR_USERNAME
                password: YOUR_PASSWORD

Si vous préférez ne pas lister les adresses vous-même, pointez le saut vers un seul point de terminaison résidentiel rotatif : ChangeMyIP fait tourner l'IP de son côté, et le configurateur n'a besoin que d'un seul nœud. Le pool couvre plus de 40 pays, plus de 300 villes et plus de 1 000 sous-réseaux, vous pouvez donc répartir la rotation sur de nombreux réseaux distincts lorsqu'une tâche dépend du fait de ressembler à des visiteurs sans lien entre eux.

7. Pointez vos applications vers l'écouteur local. Les paramètres proxy du navigateur prennent un hôte SOCKS5 127.0.0.1 et le port 1080, avec le DNS distant activé afin que les noms soient résolus par le proxy. Les outils en ligne de commande acceptent généralement un drapeau ou une variable d'environnement :

export ALL_PROXY=socks5h://127.0.0.1:1080
export HTTPS_PROXY=socks5h://127.0.0.1:1080

Certains outils ignorent ces variables et nécessitent un drapeau explicite, par exemple curl --proxy socks5h://127.0.0.1:1080. Préférez toujours le schéma socks5h au schéma socks5 pour tout ce qui touche à la confidentialité.

8. Maintenez le configurateur en cours d'exécution. Sous Linux, une unité systemd est l'option la plus propre :

[Unit]
Description=Local SOCKS5 configurator (gost)
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/local/bin/gost -C /etc/gost/gost.yaml
Restart=on-failure
User=proxyuser
NoNewPrivileges=true

[Install]
WantedBy=multi-user.target

sudo install -m 0600 gost.yaml /etc/gost/gost.yaml
sudo systemctl daemon-reload
sudo systemctl enable --now gost
systemctl status gost

Sous Windows, créez une tâche du Planificateur de tâches qui exécute gost.exe -C C:\\gost\\gost.yaml à l'ouverture de session et configurez-la pour qu'elle s'exécute que l'utilisateur soit connecté ou non. Sous macOS, exécutez la même commande depuis un terminal pendant les tests, puis encapsulez-la dans un LaunchAgent pour qu'elle démarre à la connexion.

Vérification de la chaîne et du comportement DNS

Répétez une requête en boucle pour voir si la rotation se produit réellement :

for i in 1 2 3; do
  curl --silent --proxy socks5h://127.0.0.1:1080 https://api.ipify.org
  echo
done

Vérifiez l'emplacement signalé de l'adresse de sortie :

curl --silent --proxy socks5h://127.0.0.1:1080 https://ifconfig.co/json

• Un saut unique renvoie l'adresse de ce point de terminaison. Une chaîne à deux sauts renvoie l'adresse du point de terminaison de sortie, jamais celle du point d'entrée. Si vous voyez l'adresse d'entrée, la chaîne n'est pas appliquée.
• Le schéma socks5h demande au proxy de résoudre les noms d'hôtes. Le simple socks5:// résout localement, ce qui peut divulguer votre résolveur et votre localisation approximative même si le trafic lui-même est proxifié.
• Si chaque requête renvoie la même adresse avec un sélecteur configuré, vérifiez que maxFails et failTimeout n'excluent pas de nœuds, et que le point de terminaison lui-même n'est pas une adresse de datacenter persistante.

Dépannage

Résumé

• Un configurateur SOCKS5 local, construit ici avec gost, donne à chaque application de la machine un point de terminaison proxy à 127.0.0.1:1080, que l'application prenne en charge les proxys ou non.
• Un saut vous donne une sortie stable ; deux sauts vous donnent un routage de pays à pays, l'adresse du point de terminaison de sortie étant celle que les sites voient.
• Les sélecteurs effectuent une rotation entre plusieurs points de terminaison au sein d'un saut, tandis qu'un point de terminaison résidentiel rotatif gère la rotation côté fournisseur.
• Utilisez le schéma socks5h afin que le DNS soit résolu par le proxy, et vérifiez le résultat avec une boucle curl répétée et une recherche de géolocalisation.
• Conservez le fichier YAML en 0600 et exécutez l'écouteur en tant que service pour qu'il survive aux redémarrages et aux déconnexions.