shadowy-pycoder/go-http-proxy-to-socksProxy MITM en ligne de commande qui convertit SOCKS4/SOCKS5 en proxy HTTP/HTTPS/HTTP2/HTTP3 avec redirection transparente TCP/UDP, usurpation ARP/NDP/DNS, reniflage de trafic et capture de paquets. Pur Go, sans libpcap.
L'outil CLI GoHPTS est un pont entre les clients HTTP et un serveur proxy SOCKS5 ou plusieurs serveurs (chaîne). Il écoute localement en tant que proxy HTTP, accepte les requêtes HTTP standard
ou HTTPS (via CONNECT) et transmet la connexion via un proxy SOCKS5. Inspiré par http-proxy-to-socks et Proxychains
Cas d'utilisation possible : vous devez vous connecter à une API externe via Postman, mais cette API n'est disponible que depuis un serveur distant. Les commandes suivantes vous aideront à effectuer cette tâche :
Créez un serveur proxy SOCKS5 via ssh :```shell
ssh -D 1080 -Nf
Créer une connexion HTTP vers SOCKS5 avec `gohpts````shell
gohpts -s :1080 -l :8080
Spécifiez le serveur HTTP dans la configuration du proxy de Postman
Fonctionnalité de chaîne de proxys
Prend en charge les chaînes strict, dynamic, random, round_robin de proxys SOCKS4/SOCKS5
Proxy transparent
Prend en charge les modes redirect (SO_ORIGINAL_DST) et tproxy (IP_TRANSPARENT)
Prise en charge d'IPv4 et IPv6
Fonctionne en modes IPv4-only, IPv6-only ou dual stack
Proxy transparent TCP et UDP
tproxy et tlocal (IP_TRANSPARENT) gèrent le trafic TCP et UDP
Analyse du trafic
Le proxy est capable d'analyser les en-têtes HTTP, la poignée de main TLS, les messages DNS et plus encore
Usurpation ARP
Met en proxy des sous-réseaux entiers grâce à l'usurpation ARP
Usurpation NDP
Met en proxy les connexions IPv6 à l'aide des annonces de routeur/voisin (Router/Neighbor Advertisement) et des injections RDNSS.
Usurpation DNS
Redirige les clients vers des domaines arbitraires en manipulant les enregistrements DNS
Capture de paquets
Capture le trafic dans des fichiers txt/pcap/pcapng et analysez avec Wireshark
Protection contre les fuites DNS
La résolution DNS s'effectue côté serveur SOCKS5.
Prise en charge de la méthode CONNECT
Prend en charge le tunneling HTTP CONNECT, permettant HTTPS et d'autres protocoles basés sur TCP.
Prise en charge HTTP2/HTTP3
Prend en charge les transports modernes HTTP/2 et HTTP/3, permettant des connexions multiplexées efficaces sur TLS 1.3
Prise en charge des espaces de noms réseau
Prend en charge les espaces de noms réseau Linux personnalisés pour les sockets d'écoute et les connexions sortantes
Prise en charge des en-têtes trailer
Gère les en-têtes trailer HTTP
Encodage de transfert en blocs (chunked)
Gère les réponses fragmentées (chunked) et en streaming
Prise en charge de l'authentification SOCKS5
Prend en charge l'authentification par nom d'utilisateur/mot de passe pour les proxys SOCKS5.
Prise en charge de l'authentification HTTP
Prend en charge l'authentification par nom d'utilisateur/mot de passe pour le serveur proxy HTTP.
Léger et rapide
Conçu avec une surcharge minimale et un traitement efficace des requêtes.
Multiplateforme
Compatible avec tous les principaux systèmes d'exploitation.
Ou en utilisant paru : ```shell
paru -S gohpts
- Téléchargez le binaire pour votre plateforme depuis la page [Releases](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases) : ```shell
GOHPTS_RELEASE=v1.15.5; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-linux-amd64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-linux-amd64 gohpts && ./gohpts -h
go install (nécessite Go 1.26 ou version ultérieure): ```shell
CGO_ENABLED=0 go install -ldflags "-s -w" -trimpath github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Cela installera le binaire gohpts dans votre répertoire $GOPATH/bin.
[Retour]```shell gohpts -h
/ | | | | | __ _ / ____|
| | __ ___ | || | |) | | | | (__
| | |_ |/ _ | __ | / | | _
| |__| | () | | | | | | | ) |
_|_/|| ||| || |___/
GoHPTS: HTTP(S) Proxy to SOCKS4/SOCKS5 proxy by shadowy-pycoder GitHub: https://github.com/shadowy-pycoder/go-http-proxy-to-socks Codeberg: https://codeberg.org/shadowy-pycoder/go-http-proxy-to-socks
Usage: gohpts [OPTIONS] OPTIONS: General: -h Show this help message and exit -v Show version and build information -D Run as a daemon (provide -logfile to see logs) -I Display list of network interfaces and exit -f Path to proxy configuration file in YAML format
Proxy: -l Address of HTTP proxy server (Default: "127.0.0.1:8080" for IPv4, "[::1]:8080" for IPv6) -s Address of SOCKS proxy server (Default: "127.0.0.1:1080" for IPv4 "[::1]:1080" for IPv6) -c Path to certificate PEM encoded file -k Path to private key PEM encoded file -U User for HTTP proxy (basic auth). This flag invokes prompt for password (not echoed to terminal) -u User for SOCKS proxy authentication. This flag invokes prompt for password (not echoed to terminal) -i Bind proxy to specific network interface (either by interface name or index) -4 Force IPv4 stack for TCP and UDP (Default: dual stack) -6 Force IPv6 stack for TCP and UDP (Default: dual stack) -socks4 Use SOCKS4/SOCKS4a protocol for upstream proxy and mixed server (default: SOCKS5/SOCKS5h) -nohttp Disable HTTP proxy server -nosocks Disable SOCKS upstream proxy -dns Use custom DNS server (Example: "8.8.8.8" or "2001:4860:4860::8888") -mixed Accept SOCKS connections on HTTP proxy server address
Logs: -d Show logs in DEBUG mode -j Show logs in JSON format -logfile Log file path (Default: stdout) -nocolor Disable colored output for logs (no effect if -j flag specified) -pprof Address of pprof server with profiling data
Sniffing: -sniff Enable traffic sniffing for HTTP and TLS -snifflog Sniffed traffic log file path (Default: the same as -logfile) -body Collect request and response body for HTTP traffic (credentials, tokens, etc)
TProxy: -T Address of transparent proxy server -Tu Address of transparent UDP proxy server -M Transparent proxy mode: (redirect, tproxy, tlocal) -w Number of instances of transparent proxy server (Default: number of CPU cores) -wu Number of instances of transparent UDP proxy server (Default: number of CPU cores) -auto Automatically setup iptables and kernel parameters for transparent proxy (requires elevated privileges) -mark Set mark for each packet sent through transparent proxy (Default: redirect 0, tproxy 100, tlocal 100) -P Comma separated list of ports to ignore when proxying traffic (Example: "22,80,443,9092") -dump Dump iptables rules and other system settings generated by -auto flag
Spoofing: -arpspoof Enable ARP spoof proxy for selected targets (Example: "targets 10.0.0.1,10.0.0.5-10,192.168.1.*,192.168.10.0/24;fullduplex false;debug true;interval 10s") -ndpspoof Enable NDP spoof proxy for selected targets (Example: "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true;interval 10s")
Packet Capture: -pcap Enable packet capture (Example: "promisc true;expr ip proto tcp;snaplen 65535;timeout 10s;packet_count 100;packet_buffer 8192;exts txt,pcap,pcapng")
Namespaces: -in-netns Name or path of network namespace for inbound listeners (Default: default namespace) -out-netns Name or path of network namespace for outbound connections (Default: default namespace)
### Configuration via les options CLI
[[Retour]](#table-of-contents)```shell
gohpts -s 1080 -l 8080 -d -j
I'm unable to translate this chunk because the input content is empty—no source text was provided. Please provide the actual content of chunk 21/241, and I'll translate it into French while preserving all Markdown structure.```shell {"level":"info","time":"2025-05-28T06:15:18+00:00","message":"SOCKS5 Proxy: :1080"} {"level":"info","time":"2025-05-28T06:15:18+00:00","message":"HTTP Proxy: :8080"} {"level":"debug","time":"2025-05-28T06:15:22+00:00","message":"HTTP/1.1 - CONNECT - www.google.com:443"}
Spécifiez le nom d'utilisateur et le mot de passe pour le serveur proxy SOCKS5 :```shell
gohpts -s 1080 -l 8080 -d -j -u user
SOCKS5 Password: #you will be prompted for password input here
Spécifiez le nom d'utilisateur et le mot de passe pour le serveur proxy HTTP :```shell gohpts -s 1080 -l 8080 -d -j -U user HTTP Password: #you will be prompted for password input here
Lorsque `-u` et `-U` sont tous deux présents, vous serez invité deux fois
Exécuter un proxy HTTP sur une connexion TLS```shell
gohpts -s 1080 -l 8080 -c "path/to/certificate" -k "path/to/private/key"
Exécutez le proxy en tant que démon (un fichier journal est nécessaire pour la sortie des journaux, sinon vous ne verrez rien)```shell gohpts -D -logfile /tmp/gohpts.log
Permet d'analyser la requête ou la réponse avec le scanner actif ou passif de Burp.```shell
# output
gohpts pid: <pid>
kill #or kill $(pidof gohpts)
`-u` et `-U` ne fonctionnent pas en mode démon (et donc l’authentification), mais vous pouvez fournir un fichier de configuration (voir ci-dessous)
### Configuration via fichier YAML
[[Back]](#table-of-contents)
Les fichiers de configuration sont utiles lorsque vous souhaitez préconfigurer votre proxy sans trop manipuler la CLI, ou simplement avoir plusieurs profils pour différents besoins.
Exécutez le proxy HTTP en mode chaîne de proxy SOCKS5 (spécifiez les paramètres du serveur via le fichier de configuration YAML)```shell
gohpts -f "~/gohtps.yaml" -d -j
Exemple de configuration :```yaml
interface: "eth0" # if specified, overrides http server IP address disable_http: false # disable http proxy (default: false) disable_socks: false # disable upstream socks proxy (default: false)
ipv4: false # this must be enabled for arpspoof (default: false) ipv6: false # this must be enabled for ndpspoof (default: false) socks4: false # use SOCKS4/SOCKS4a protocol (tcp only protocol, no udp tproxy or http3 possible) (default: false) dns: 8.8.8.8 # custom DNS server (used in direct dialer, namespaces, spoofing)
http_server: address: 127.0.0.1:8080
username: username password: password
proxy_list:
proxy_chain: enabled: false
type: strict # dynamic, strict, random, round_robin length: 2 # maximum number of proxy in a chain (works only for random chain and round_robin chain)
logging: debug: true json: false
#logfile: /tmp/gohpts.log
nocolor: false
pprof: 127.0.0.1:8081
Vous pouvez remplacer presque tous les paramètres spécifiés dans le fichier de configuration en fournissant les indicateurs CLI correspondants :```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor
Le proxy prend tous les paramètres spécifiés dans ~/gohpts.yaml mais lance un serveur http sur 127.0.0.1:6969 au lieu de 127.0.0.1:8080 et désactive également la sortie colorée dans les journaux.
Certains paramètres (par ex. proxy_chain et filtres DNS) ne peuvent être configurés que via un fichier.
La version complète de la configuration se trouve ici : example_gohpts.yaml
Pour en savoir plus sur les chaînes de proxy, consultez Proxychains Github
Également connu sous le nom de
proxy intercepteur,proxy en ligneouproxy forcé, un proxy transparent intercepte les communications normales de la couche application sans nécessiter de configuration spéciale du client. Les clients n'ont pas besoin de connaître l'existence du proxy. Un proxy transparent est normalement situé entre le client et Internet, le proxy remplissant certaines des fonctions d'une passerelle ou d'un routeur.-- De Wiki
Cette fonctionnalité n'est disponible que sur les systèmes Linux et Android (arm64) et nécessite une configuration supplémentaire (iptables, ip route, etc.)
L'option -T address spécifie l'adresse du serveur proxy transparent.
Il existe trois modes redirect, tproxy et tlocal (identique à tproxy mais intercepte également le trafic local) qui peuvent être spécifiés avec l'option -M.
redirect (via NAT et SO_ORIGINAL_DST)Dans ce mode, le proxy s'effectue avec la table nat d'iptables et la cible REDIRECT. L'hôte du paquet entrant change vers l'adresse du proxy transparent redirect en cours d'exécution, mais il contient également la destination d'origine qui peut être récupérée avec getsockopt(SO_ORIGINAL_DST).
Pour exécuter GoHPTS dans ce mode, utilisez l'option -T avec -M redirect.
[Back]```shell
gohpts -s 1080 -T 1090 -M redirect -d
syntaxe de bloc (texte cité) en HTML. C'est un format rapide et bricolé, mais
il facilite l'inclusion d'exemples.
Ces exemples incluent trois tirets, délimitant le front matter. Si vous
retirez les tirets, l'exemple échouera.```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf
Configurez votre système d'exploitation :```shell
sudo -i)#enable ip forwarding sysctl -w net.ipv4.ip_forward=1
GOHPTS nat chainiptables -t nat -N GOHPTS
iptables -t nat -A GOHPTS -d 127.0.0.0/8 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 8080 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 1090 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 22 -j RETURN
iptables -t nat -A GOHPTS -p tcp -j REDIRECT --to-ports 1090
iptables -t nat -A PREROUTING -p tcp -j GOHPTS
iptables -t nat -A OUTPUT -p tcp -j GOHPTS
Test de connexion :```shell
#traffic should be redirected via 127.0.0.1:1090
curl http://example.com
I'm ready to translate the content, but I notice that the chunk content after "INPUT:" appears to be empty. There's no text provided for me to translate.
Please provide the actual Markdown content for chunk 49 of 241, and I'll translate it from English to French according to the specified rules.```shell #traffic should be redirected via 127.0.0.1:8080 curl --proxy http://127.0.0.1:8080 http://example.com
Annuler tout :```shell
sysctl -w net.ipv4.ip_forward=0
iptables -t nat -D PREROUTING -p tcp -j GOHPTS
iptables -t nat -D OUTPUT -p tcp -j GOHPTS
iptables -t nat -F GOHPTS
iptables -t nat -X GOHPTS
redirectPour configurer votre système automatiquement, exécutez la commande suivante :```shell sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto
Veuillez noter que la configuration automatique nécessite `sudo` et est très générique, ce qui pourrait ne pas convenir à vos besoins.
Vous pouvez éventuellement spécifier `-mark <value>` pour éviter d'éventuelles boucles de proxy.```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100
tproxy (via MANGLE et IP_TRANSPARENT)Dans ce mode, le proxy s'effectue avec la table mangle d'iptables et la cible TPROXY. Le proxy transparent voit l'adresse de destination telle quelle, elle n'est pas réécrite par le noyau. Pour que cela fonctionne, le proxy se lie avec l'option de socket IP_TRANSPARENT, iptables intercepte le trafic en utilisant la cible TPROXY, les règles de routage indiquent aux paquets marqués d'aller vers le proxy local sans modifier leur destination d'origine.
Ce mode nécessite des privilèges élevés pour exécuter GoHPTS. Vous pouvez le faire en exécutant la commande suivante :```shell
sudo setcap 'cap_net_admin+ep' ~/go/bin/gohpts
Pour exécuter `GoHPTS` dans ce mode, utilisez l'option `-T` avec `-M tproxy`
### Exemple
[[Retour]](#table-of-contents)```shell
# run the proxy
gohpts -s 1080 -T 0.0.0.0:1090 -M tproxy -d
I'm ready to translate, but I notice the input chunk appears to be empty. The message ends with "INPUT:" and no content follows.
Could you provide the actual text for chunk 61? Once you paste the content, I'll translate it from English to French following all the rules (preserving Markdown structure, code blocks, URLs, etc.).```shell
ssh remote -D 1080 -Nf
Configurez votre système d'exploitation :```shell
ip netns add ns-client
ip link add dev veth0 type veth peer name veth1 netns ns-client
ip addr add 10.0.0.1/24 dev veth0
ip link set dev veth0 up
ip netns exec ns-client ip addr add 10.0.0.2/24 dev veth1
ip netns exec ns-client ip link set dev lo up
ip netns exec ns-client ip link set dev veth1 up
ip netns exec ns-client ip route add default via 10.0.0.1
sysctl -w net.ipv4.ip_forward=1
iptables -t mangle -A PREROUTING -i veth0 -p tcp -j TPROXY --on-port 1090 --tproxy-mark 0x1/0x1
ip rule add fwmark 1 lookup 100
ip route add local 0.0.0.0/0 dev lo table 100
Test de connexion :```shell ip netns exec ns-client curl http://1.1.1.1
Tout annuler :```shell
sysctl -w net.ipv4.ip_forward=0
iptables -t mangle -F
ip rule del fwmark 1 lookup 100
ip route flush table 100
ip netns del ns-client
tproxyPour configurer votre système automatiquement, exécutez la commande suivante (par exemple, sur une VM distincte) :```shell ssh remote -D 1080 -Nf sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -auto -mark 100
Exécutez ce qui suit sur votre hôte :```shell
ip route show default > /tmp/default-route.txt
ip route add 0.0.0.0/1 via 192.168.0.1 # change with ip of your VM
ip route add 128.0.0.0/1 via 192.168.0.1
Test de connexion :```shell curl http://example.com #check logs on your VM
Annuler tout :```shell
ip route del 0.0.0.0/1 via 192.168.0.1 2>/dev/null || true
ip route del 128.0.0.0/1 via 192.168.0.1 2>/dev/null || true
if [[ -f /tmp/default-route.txt ]]; then
eval $(awk '{print "ip route add "$0}' /tmp/default-route.txt)
rm -f /tmp/default-route.txt
else
echo "Something went wrong"
fi
GoHPTS dispose d'un support UDP qui peut être activé dans les modes tproxy et tlocal. Pour que cette configuration fonctionne, vous devez vous connecter à un serveur socks5 capable de servir des connexions UDP (UDP ASSOCIATE). Par exemple, vous pouvez utiliser https://github.com/wzshiming/socks5 pour déployer un serveur socks5 compatible UDP sur une machine distante ou locale. Une fois que vous disposez du serveur auquel vous connecter, exécutez la commande suivante :```shell
sudo env PATH=$PATH gohpts -s remote -Tu :8989 -M tproxy -auto -mark 100 -d
Cette commande configurera votre système d’exploitation et démarrera le serveur sur l’adresse `0.0.0.0:8989`.
Pour le tester localement, vous pouvez combiner le proxy transparent UDP avec l’option `-arpspoof`. Par exemple :
1. Configurez une VM sur votre système avec une distribution Linux prenant en charge `tproxy` (Kali Linux, par exemple).
2. Activez le réseau `bridged` afin que la VM puisse accéder à votre machine hôte.
3. Déplacez le binaire `gohpts` vers la VM (via `ssh`, par exemple) ou compilez-le directement sur celle-ci en cas de système d’exploitation/architecture différent.
4. Sur votre VM, exécutez la commande suivante :```shell
# Do not forget to replace <socks5 server> and <your host> with actual addresses
sudo ./gohpts -s <socks5 server> -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "targets <your host>;fullduplex true;debug false"
Le proxy transparent peut être activé sur les appareils Android (arm64) avec un accès root. Vous pouvez installer Termux et y exécuter GoHPTS en tant qu'outil CLI :```shell
pkg install tsu iproute2
GOHPTS_RELEASE=v1.10.2; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-android-arm64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-android-arm64 gohpts && ./gohpts -h
sudo ./gohpts -s remote -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "fullduplex true;debug false"
### Configuration YAML
[[Retour]](#table-of-contents)```yaml
transparent_proxy:
tcp:
enabled: true
address: 0.0.0.0:8888
# number of instances of transparent proxy server (Default: number of CPU cores)
workers: 1
udp:
enabled: true
address: 0.0.0.0:8889
# number of instances of transparent UDP proxy server (Default: number of CPU cores)
workers: 1
mode: "tproxy" # available modes are "redirect", "tproxy" and "tlocal" (udp requires tproxy or tlocal mode)
# automatically setup iptables and kernel parameters for transparent proxy (requires elevated privileges)
auto: true
# dump iptables rules and other system settings generated by auto setting
dump_rules: false
# list of ports to ignore when proxying traffic (Example: [22,80,443,9092])
ignored_ports: []
# set mark for each packet sent through transparent proxy (Default: redirect 0, tproxy 100, tlocal 100)
mark: 100
Le proxy GoHPTS permet de capturer et de surveiller le trafic qui transite par le service. Ce processus est connu sous le nom de traffic sniffing, packet sniffing ou simplement sniffing. En particulier, le proxy tente d'identifier s'il s'agit d'un trafic en texte clair (HTTP) ou TLS, et une fois l'identification effectuée, il analyse les métadonnées de requête/réponse et les écrit dans le fichier ou la console. Dans le cas du proxy GoHTPS, les métadonnées analysées ressemblent à ce qui suit (TLS Handshake) :
[Back]```json [ { "connection": { "tproxy_mode": "redirect", "src_local": "127.0.0.1:8888", "src_remote": "192.168.0.107:51142", "dst_local": "127.0.0.1:56256", "dst_remote": "127.0.0.1:1080", "original_dst": "216.58.209.206:443" } }, { "tls_request": { "sni": "www.youtube.com", "type": "Client hello (1)", "version": "TLS 1.2 (0x0303)", "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39", "cipher_suites": [ "TLS_AES_128_GCM_SHA256 (0x1301)", "TLS_CHACHA20_POLY1305_SHA256 (0x1303)", "TLS_AES_256_GCM_SHA384 (0x1302)", "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 (0xc02b)", "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (0xc02f)", "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 (0xcca9)", "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 (0xcca8)", "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 (0xc02c)", "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (0xc030)", "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (0xc00a)", "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (0xc009)", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (0xc013)", "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (0xc014)", "TLS_RSA_WITH_AES_128_GCM_SHA256 (0x9c)", "TLS_RSA_WITH_AES_256_GCM_SHA384 (0x9d)", "TLS_RSA_WITH_AES_128_CBC_SHA (0x2f)", "TLS_RSA_WITH_AES_256_CBC_SHA (0x35)" ], "extensions": [ "server_name (0)", "extended_master_secret (23)", "renegotiation_info (65281)", "supported_groups (10)", "ec_point_formats (11)", "session_ticket (35)", "application_layer_protocol_negotiation (16)", "status_request (5)", "delegated_credential (34)", "signed_certificate_timestamp (18)", "key_share (51)", "supported_versions (43)", "signature_algorithms (13)", "psk_key_exchange_modes (45)", "record_size_limit (28)", "compress_certificate (27)", "encrypted_client_hello (65037)" ], "alpn": ["h2", "http/1.1"] } }, { "tls_response": { "type": "Server hello (2)", "version": "TLS 1.2 (0x0303)", "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39", "cipher_suite": "TLS_AES_128_GCM_SHA256 (0x1301)", "extensions": ["key_share (51)", "supported_versions (43)"], "supported_version": "TLS 1.3 (0x0304)" } } ]
Et une requête HTTP avec curl:```json
[
{
"connection": {
"tproxy_mode": "redirect",
"src_local": "127.0.0.1:8888",
"src_remote": "192.168.0.107:45736",
"dst_local": "127.0.0.1:37640",
"dst_remote": "127.0.0.1:1080",
"original_dst": "96.7.128.198:80"
}
},
{
"http_request": {
"host": "example.com",
"uri": "/",
"method": "GET",
"proto": "HTTP/1.1",
"header": {
"Accept": ["*/*"],
"My": ["Header"],
"User-Agent": ["curl/7.81.0"]
}
}
},
{
"http_response": {
"proto": "HTTP/1.1",
"status": "200 OK",
"content-length": 1256,
"header": {
"Cache-Control": ["max-age=2880"],
"Connection": ["keep-alive"],
"Content-Length": ["1256"],
"Content-Type": ["text/html"],
"Date": ["Tue, 17 Jun 2025 14:43:24 GMT"],
"Etag": ["\"84238dfc8092e5d9c0dac8ef93371a07:1736799080.121134\""],
"Last-Modified": ["Mon, 13 Jan 2025 20:11:20 GMT"]
}
}
}
]
L'utilisation est aussi simple que de spécifier l'option -sniff en plus des options habituelles```shell
gohpts -d -T 8888 -M redirect -sniff -j
Vous pouvez également spécifier un fichier dans lequel écrire le trafic capturé :```shell
gohpts -sniff -snifflog ~/sniff.log -j
Vous pouvez voir un exemple de sortie colorée dans l'image ci-dessus. Dans ce mode, GoHPTS essaie de mettre en évidence les informations importantes telles que la poignée de main TLS (TLS Handshake), les métadonnées HTTP, ou quelque chose qui ressemble à des identifiants/mots de passe, ainsi que différents types d'authentification et de jetons secrets. La sortie est limitée par rapport au JSON, mais bien plus facile à lire pour les humains.
Pour exécuter GoHPTS dans ce mode, vous utilisez les options suivantes :```shell
gohpts -sniff -body
Vous pouvez combiner le sniffing avec le mode transparent :```shell
./gohpts -T 8888 -M redirect -sniff -body
Pour désactiver les couleurs, ajoutez -nocolor:```shell
gohpts -sniff -body -nocolor
## Prise en charge de HTTP2 et HTTP3
[[Back]](#table-of-contents)
Le proxy `GoHPTS` gère les requêtes HTTP/1.1, HTTP/2 et HTTP/3 en utilisant la même adresse de serveur et le même certificat TLS. Cela permet aux clients de choisir automatiquement le meilleur protocole disponible sans changer de configuration. Le certificat TLS peut être obtenu de plusieurs manières : fournisseurs cloud (Google, AWS, Cloudflare), certificat gratuit de Let's Encrypt, ou vous pouvez créer un certificat auto-signé à l'aide d'`openssl` (Linux/macOS) ou de `New-SelfSignedCertificate` (Windows).
### Exemple de configuration avec un certificat auto-signé
[[Back]](#table-of-contents)
- Créez les fichiers `key.pem` et `cert.pem` : ```shell
openssl req -x509 -newkey rsa:2048 \
-keyout key.pem \
-out cert.pem \
-sha256 \
-days 365 \
-nodes \
-subj "/C=XX/ST=StateName/L=CityName/O=CompanyName/OU=CompanySectionName/CN=127.0.0.1" \
-addext "subjectAltName=IP:127.0.0.1"
GoHPTS : ```shell
go install github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Vous pouvez utiliser d'autres méthodes décrites dans la section Installation.
Enfin :
http_server: address: 127.0.0.1:8080 cert_file: ./cert.pem key_file: ./key.pem
proxy_list:
logging: debug: true
sniffing: enabled: true body: true
Exécutez le proxy : ```shell gohpts -f ./gohpts_config.yaml
2. Ou si vous préférez les arguments de ligne de commande: ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body
Vous devriez voir quelque chose comme cela : ```shell [15:20:32] INF SOCKS5 Proxy: 127.0.0.1:1080 [15:20:32] INF HTTPS Proxy: 127.0.0.1:8080 [15:20:32] INF HTTP3 Proxy (QUIC): 127.0.0.1:8080
### Tester la connexion
[[Back]](#table-of-contents)
- Pour le serveur proxy HTTP/2, vous pouvez utiliser `curl` : ```shell
curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://localhost:8080 "https://stream.wikimedia.org/v2/stream/recentchange"
Appuyez sur Ctrl+C pour arrêter le flux en cours.
Pour HTTP/3, c'est différent car (au moment de la rédaction) curl ne prend pas en charge le proxy HTTP3, j'utiliserai donc mon client personnalisé que j'ai créé à des fins de test.
Téléchargez et installez l'exemple simple de proxy HTTP3 vers SOCKS5 : ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make
Exécutez la commande suivante : ```shell ./bin/client -a 127.0.0.1:8080 www.google.com
Vous devriez voir un charabia ressemblant à une page HTML.
Allez dans l'onglet terminal avec le proxy `GoHPTS` et consultez les logs, vous devriez y voir toutes vos requêtes.
### Tester la connexion dans un navigateur
[[Retour]](#table-of-contents)
- Créez un certificat auto-signé approprié pour le navigateur : ```shell
git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git
cd go-http-proxy-to-socks
cp ./resources/makecert.sh makecert.sh && chmod +x makecert.sh
./makecert.sh
Vous trouverez plus d'informations ici : Créer un certificat SSL auto-signé approuvé par le navigateur
rootCA.crt nouvellement créé au magasin de confiance du système :
- Exécutez le proxy en utilisant `server.crt` et `server.key` : ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body
En ce qui concerne la gestion de la couche réseau, GoHPTS peut fonctionner selon trois modes : dual stack, IPv4-only et IPv6-only. L'utilisateur peut contrôler le mode en spécifiant les options -4 et -6. Lorsque l'une des options est définie, le proxy démarre dans le mode correspondant ; lorsque les deux options sont présentes ou toutes deux omises, le mode dual stack est utilisé par défaut. Veuillez noter que dans les modes "only", seules les adresses IP de la version spécifique sont autorisées, tous les domaines sont résolus vers la version IP spécifique (si possible), toutes les adresses d'écoute doivent utiliser la même version, etc.
Pour activer le mode IPv4-only, il suffit d'ajouter l'option -4 :```shell
sudo ./gohpts -sniff -body -d -4
Pour tester le proxy en mode IPv4, vous pouvez utiliser n'importe quelle VM Linux :
1. Sur votre machine virtuelle :```shell
# add your host machine as gateway for VM
export GATEWAY="<host IPv4 address>"
ip route add 0.0.0.0/1 via "$GATEWAY"
ip route add 128.0.0.0/1 via "$GATEWAY"
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -4
3. Visitez n'importe quel site web sur votre machine virtuelle et observez le trafic dans les journaux du proxy
Pour activer le mode `IPv6-only`, ajoutez simplement le flag `-6`, par exemple lors de l'utilisation avec un proxy transparent :```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6
Pour que cela fonctionne, votre FAI et votre proxy socks5 distant doivent avoir un support IPv6 actif, vous pouvez visiter https://test-ipv6.com/ pour savoir si vous pouvez accéder aux adresses IPv6. Pour tester le proxy en mode IPv6, vous pouvez utiliser n'importe quelle VM Linux :
export GATEWAY6="" ip -6 route add ::/1 via "$GATEWAY6" dev eth0 ip -6 route add 8000::/1 via "$GATEWAY6" dev eth0
2. Sur votre hôte :```shell
# run proxy on your host
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -6
GoHPTS dispose d'un usurpateur ARP intégré qui peut être utilisé pour faire en sorte que tous les appareils TCP de votre LAN utilisent le serveur proxy pour se connecter à Internet.
Cela est réalisé en ajoutant le drapeau -arpspoof avec quelques paramètres, séparés par un point-virgule.
Exemple :```shell ssh remote -D 1080 -Nf sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100 -arpspoof "targets 192.168.10.0/24;fullduplex true;debug true"
Le proxy analysera les appareils du sous-réseau `192.168.10.0/24` et leur enverra des paquets ARP pour se faire passer pour une passerelle ; si `fullduplex` est vrai,
le proxy enverra également des paquets ARP à la passerelle pour lui faire croire que notre proxy possède chaque adresse IP du sous-réseau.
Une fois le proxy arrêté avec `Ctrl+C`, il désactivera automatiquement le spoofing sur toutes les cibles.
`GoHPTS` peut également être utilisé avec des outils comme [Bettercap](https://github.com/bettercap/bettercap) pour servir de proxy au trafic usurpé par ARP.
Exécutez le proxy :```shell
ssh remote -D 1080 -Nf
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100
Exécutez bettercap avec cette commande (voir la documentation):```shell
sudo bettercap -eval "net.probe on;net.recon on;set arp.spoof.fullduplex true;arp.spoof on"
Consultez les journaux du proxy pour le trafic provenant d'autres appareils de votre LAN
Pour plus d'informations sur les options d'arpspoof, consultez `gohpts -h` et [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)
## Usurpation NDP
[[Back]](#table-of-contents)
`GoHPTS` dispose d'une fonctionnalité intégrée pour effectuer une usurpation NDP dans les réseaux IPv6 avec des paquets Router Advertisement (RA) et Neighbor Advertisement (NA). Il inclut également l'option RDNSS dans les paquets RA pour désigner l'hôte comme serveur de noms IPv6 pour les clients affectés. Lorsqu'elle est combinée au mode proxy transparent (TCP/UDP), l'usurpation NDP permet à `gohpts` de proxifier le trafic des clients des réseaux locaux. Comme pour l'[usurpation ARP](#arp-spoofing), vous pouvez définir les options de spoofing NDP avec l'unique indicateur `-ndpspoof` :
Exemple :```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100 -ndpspoof "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true"
Pour plus d’informations sur les options de ndpspoof, consultez gohpts -h et https://github.com/shadowy-pycoder/ndpspoof
Veuillez noter que certaines options comme rdnss, gateway, interface sont définies automatiquement par gohpts lui-même pour fonctionner correctement comme proxy.
Étant donné que gohpts achemine toutes les connexions via un serveur SOCKS5 en amont, vous devez disposer d’un serveur fonctionnel avec le support IPv4/IPv6 et TCP/UDP. Évidemment, une machine distante (par ex. un VPS) doit également avoir une connectivité IPv6 fonctionnelle. Inutile de préciser que la machine sur laquelle tourne gohpts doit faire partie d’un réseau avec prise en charge IPv6.
Exemple de configuration pour que le spoofing NDP fonctionne correctement :
2. Installer les dépendances```shell
GO_VERSION=$(curl 'https://go.dev/VERSION?m=text' | head -n1)
cd ~/Downloads/ && wget https://go.dev/dl/$GO_VERSION.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf $GO_VERSION.linux-amd64.tar.gz
4. Retournez à votre machine hôte et installez `gohpts` (voir [Installation](#installation))
5. Exécutez `gohtps`:```shell
gohpts -s 203.0.113.10:3000 -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -mark 100 -arpspoof "fullduplex true;debug true" -ndpspoof "ra true;debug true" -4 -6 -d
Prenez un autre appareil (téléphone, tablette, etc.) et connectez-le au même réseau. Essayez d'accéder à Internet et vérifiez si du trafic apparaît sur votre machine hôte. Vérifiez l'adresse IP publique avec des outils en ligne (elle doit correspondre à votre adresse VPS 203.0.113.10 dans ce cas, ou à une adresse IPv6 globale)
Arrêtez le proxy en appuyant sur Ctrl+C
Profitez-en !
Pour appliquer des filtres DNS et tromper les cibles en modifiant les enregistrements DNS, l'hôte exécutant GoHPTS doit devenir une passerelle par défaut pour les périphériques du réseau local. Pour que cela fonctionne, exécutez simplement un proxy transparent avec udp activé et lancez également une usurpation ARP/NDP afin que les cibles utilisent votre serveur DNS.
Les réponses DNS créées par GoHPTS ressemblent à des paquets normaux provenant du routeur ou de serveurs DNS de confiance (Google, Cloudflare), ce qui amène les clients à mettre à jour leur cache avec ce que vous leur indiquez. Gardez toutefois à l'esprit que cela ne fonctionne que pour le trafic DNS non chiffré "standard" (DOT/DOH non filtré ou non usurpé).
Les filtres DNS et les domaines à usurper peuvent être configurés dans la section dns_filter du fichier de configuration yaml. Toutes les listes acceptent des URL, des chemins de fichiers et des entrées similaires à celles que l'on trouve généralement dans un fichier hosts, voir https://en.wikipedia.org/wiki/Hosts_(file)>).
Exemple :```yaml
dns_filter: enabled: true whitelist: ["/tmp/whitelisted_domains.txt", "example.com", "*.google.com"] # ip is optional, domains can start with *. to match all subdomains blacklist: ["https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts"] blacklist_all: false # block all non whitelisted domains spooflist: ["127.0.0.1 example.com"] # ip address is required here
Cas d'utilisation :
- Bloqueur de publicités et de traqueurs pour tous les appareils du LAN
- Contrôle parental via le blocage de catégories spécifiques de sites web
- Bloquer les domaines de phishing et de malware connus
- Redirection du trafic pour analyse
- Collecte d'identifiants via redirection
- Détournement et manipulation du trafic (injection de publicités, scripts, suivi)
- Surveillance et profilage
Configuration minimale pour ce paramétrage :```yaml
# gohpts_dns_spoof.yaml
proxy_list:
- address: 127.0.0.1:1080 # point to socks5 server supporting TCP/UDP
sniffing:
enabled: true
body: true
transparent_proxy:
tcp:
enabled: true
address: 0.0.0.0:8888
udp:
enabled: true
address: 0.0.0.0:8889
mode: "tproxy"
auto: true
arpspoof:
enabled: true
settings: "fullduplex 1;debug 1;interval 1s"
dns_filter:
enabled: true
whitelist: []
blacklist: [
"https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts",
] # list of domains to filter
blacklist_all: true
# all requests for example.com will be redirected to 0.0.0.0 address
spooflist: ["0.0.0.0 example.com"]
Exécutez :```shell sudo ./gohpts -f ./gohpts_dns_spoof.yaml
Plus d'informations peuvent être trouvées ici : [https://en.wikipedia.org/wiki/DNS_spoofing](https://en.wikipedia.org/wiki/DNS_spoofing)
## Capture de paquets
[[Retour]](#table-of-contents)
Le trafic peut être capturé dans des formats pcap, pcapng ou txt personnalisés, puis analysé ultérieurement avec des outils comme Wireshark, tcpdump et bien d'autres.
Tout d'abord, assurez-vous que l'exécutable `GoHPTS` dispose de privilèges élevés afin de pouvoir capturer les paquets bruts. Vous avez deux options :
- Exécutez `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` une seule fois pour donner au proxy l'accès au trafic brut
- Exécutez le proxy avec `sudo` lorsque vous devez spécifier l'option `-pcap` dans la CLI ou `pcap.enabled` dans la configuration du fichier.
Configurez le proxy à l'aide de la CLI :```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"
Fichier de configuration :```yaml pcap: enabled: true settings: "promisc true;expr ip proto tcp;snaplen 65535;timeout 10s;packet_count 100;packet_buffer 8192;exts txt,pcap,pcapng"
Ces commandes produisent trois fichiers de capture de paquets avec les formats correspondants, qui peuvent ensuite être analysés par divers outils.
Pour plus d'informations sur les options pcap, voir `gohpts -h` et [https://github.com/shadowy-pycoder/mshark](https://github.com/shadowy-pycoder/mshark)
## Network Namespaces
[[Back]](#table-of-contents)
Par défaut, le proxy `GoHPTS` s'exécute dans un seul espace de noms réseau (network namespace), mais cela peut être remplacé. Les sockets d'écoute (par exemple le serveur HTTP ou le serveur proxy transparent) et les sockets sortants (proxy SOCKS ou dialer direct) créés par `GoHPTS` peuvent être isolés avec les [network_namespaces (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html) de Linux/Android. Lors du démarrage du processus proxy, les utilisateurs peuvent spécifier les options `-in-netns` (écouteurs) et `-out-netns` (dialers) avec le nom ou le chemin d'un espace de noms réseau afin de contrôler dans quel environnement isolé les sockets doivent être créés. Si vous souhaitez créer les écouteurs ou les dialers dans l'espace de noms actuel (par défaut), omettez simplement l'option. Pour spécifier explicitement l'espace de noms hôte, vous pouvez utiliser le chemin `/proc/1/ns/net` — cela permet au proxy d'identifier correctement les serveurs de noms système.
`GoHPTS` prend en charge la convention [ip-netns (8)](https://man7.org/linux/man-pages/man8/ip-netns.8.html) pour fournir une configuration réseau via des fichiers situés dans le répertoire `/etc/netns/NAME/`. Ainsi, pour spécifier des serveurs de noms personnalisés pour l'espace de noms réseau `ns1`, vous procédez comme suit :```shell
sudo mkdir -p /etc/netns/ns1
sudo tee /etc/netns/ns1/resolv.conf << EOF
nameserver 8.8.8.8
nameserver 2001:4860:4860:0:0:0:0:8888
EOF
Si aucune configuration n'est trouvée, les serveurs DNS de Google seront utilisés pour résoudre les noms de domaine.
Si votre système a systemd-resolved.service (8) activé, vous voudrez peut-être le désactiver temporairement lors de requêtes via des espaces de noms réseau personnalisés :```shell sudo ip netns exec ns1 unshare --mount bash -c ' mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve curl -Nvk https://example.com'
Ou rendez-le persistant pour une instance de shell spécifique :```shell
sudo ip netns exec ns1 unshare --mount bash -c '
mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve
exec bash --login'
key.pem et cert.pem : ```shell
openssl req -x509 -newkey rsa:2048 ns1 et configurez le réseau veth ```shell
sudo ip netns add ns1
sudo ip link add dev veth0 type veth peer name veth1 netns ns1
sudo ip addr add 10.0.0.1/24 dev veth0
sudo ip -6 addr add fd12:3456:789a::1/64 dev veth0
sudo ip link set dev veth0 up
sudo ip netns exec ns1 ip addr add 10.0.0.2/24 dev veth1
sudo ip netns exec ns1 ip -6 addr add fd12:3456:789a::2/64 dev veth1
sudo ip netns exec ns1 ip link set dev lo up
sudo ip netns exec ns1 ip link set dev veth1 up
wlan0 pour pouvoir se connecter au socks5 local ```shell
WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')
Proxy HTTP - écouteurs de proxy dans ns1 (pas de route par défaut, pas d'accès Internet), sockets sortantes sur l'hôte
Exécutez le proxy : ```shell sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1
Effectuez une requête via ns1 ```shell
sudo ip netns exec ns1 curl -Nv --proxy http://127.0.0.1:8083 https://example.com
La requête devrait réussir
2. **Proxy HTTP2 - écouteurs de proxy dans `ns1` (pas de route par défaut, pas d'accès Internet), sockets sortants sur l'hôte**
Exécuter le proxy : ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1 -c ./cert.pem -k ./key.pem
Faites une requête via ns1 ```shell
sudo ip netns exec ns1 curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://127.0.0.1:8083 https://example.com
La requête doit réussir
3. **Proxy HTTP3 - listeners du proxy dans `ns1` (pas de route par défaut, pas d'accès Internet), sockets sortantes sur l'hôte**
Exécuter le proxy : ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1 -c ./cert.pem -k ./key.pem
Faites une requête via ns1 ```shell
sudo ip netns exec ns1 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
La requête devrait aboutir
4. **Proxy transparent de redirection (`-M redirect`) - écouteurs proxy dans `ns1` (route par défaut, pas d'accès Internet), sockets sortants sur l'hôte**
Exécutez le proxy : ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1 -nohttp -M redirect -T :8888 -auto
Effectuez une requête via ns1 ```shell
sudo ip netns exec ns1 curl -Nv https://example.com
La requête devrait échouer
Ajouter la route par défaut à `ns1` ```shell
sudo ip netns exec ns1 ip route add default via 10.0.0.1
sudo ip netns exec ns1 ip -6 route add default via fd12:3456:789a::1
Réessayer ```shell sudo ip netns exec ns1 curl -Nv https://example.com
Maintenant la requête devrait réussir
5. **Proxy HTTP - écouteurs du proxy sur l'hôte, sockets sortantes dans `ns1` (route par défaut, accès Internet)**
Ajoutez des règles NAT pour permettre à `ns1` de se connecter à Internet via `wlan0` ```shell
sudo iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o wlan0 -j MASQUERADE
sudo ip6tables -t nat -A POSTROUTING -s fd12:3456:789a::/64 -o wlan0 -j MASQUERADE
Exécuter le proxy : ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0
Effectuer une requête via l'hôte ```shell
curl -Nv --proxy http://$WLAN_IP:8083 https://example.com
Proxy HTTP3 - écouteurs proxy sur l'hôte, sockets sortantes dans ns1 (route par défaut, accès Internet)
Lancer le proxy :
La requête doit aboutir ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0 -c ./cert.pem -k ./key.pem
Faire une requête via l'hôte ```shell ./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com
La requête devrait aboutir
7. **Redirection du proxy transparent - listeners du proxy sur l'hôte, sockets sortantes dans `ns1` (route par défaut, accès Internet)**
Exécutez le proxy (`-auto` ne fonctionne pas avec le serveur socks5 local pour moi, j'utilise donc un serveur distant): ```
sudo ./bin/gohpts -s <remote> -4 -6 -d -sniff -body -out-netns ns1 -nohttp -M redirect -T :8888 -auto
Effectuer une requête via l'hôte ```shell curl -Nv https://example.com
La requête doit aboutir
8. **Proxy HTTP - LAN (`ns2` (écouteurs de proxy), `ns3`, `ns4`), sockets sortants dans `ns1` (route par défaut, accès Internet)**
Créer le LAN ```shell
sudo ip link add br0 type bridge
sudo ip addr add 10.0.1.1/24 dev br0
sudo ip -6 addr add fd12:3456:789b::1/64 dev br0
sudo ip link set br0 up
sudo ip netns add ns2
sudo ip link add veth2 type veth peer name veth3 netns ns2
sudo ip link set veth2 master br0
sudo ip link set veth2 up
sudo ip netns exec ns2 ip addr add 10.0.1.2/24 dev veth3
sudo ip netns exec ns2 ip -6 addr add fd12:3456:789b::2/64 dev veth3
sudo ip netns exec ns2 ip link set lo up
sudo ip netns exec ns2 ip link set veth3 up
sudo ip netns exec ns2 ip route add default via 10.0.1.1
sudo ip netns exec ns2 ip -6 route add default via fd12:3456:789b::1
sudo ip netns add ns3
sudo ip link add veth4 type veth peer name veth5 netns ns3
sudo ip link set veth4 master br0
sudo ip link set veth4 up
sudo ip netns exec ns3 ip addr add 10.0.1.3/24 dev veth5
sudo ip netns exec ns3 ip -6 addr add fd12:3456:789b::3/64 dev veth5
sudo ip netns exec ns3 ip link set lo up
sudo ip netns exec ns3 ip link set veth5 up
sudo ip netns exec ns3 ip route add default via 10.0.1.1
sudo ip netns exec ns3 ip -6 route add default via fd12:3456:789b::1
sudo ip netns add ns4
sudo ip link add veth6 type veth peer name veth7 netns ns4
sudo ip link set veth6 master br0
sudo ip link set veth6 up
sudo ip netns exec ns4 ip addr add 10.0.1.4/24 dev veth7
sudo ip netns exec ns4 ip -6 addr add fd12:3456:789b::4/64 dev veth7
sudo ip netns exec ns4 ip link set lo up
sudo ip netns exec ns4 ip link set veth7 up
sudo ip netns exec ns4 ip route add default via 10.0.1.1
sudo ip netns exec ns4 ip -6 route add default via fd12:3456:789b::1
Lancez le proxy : ``` sudo ./bin/gohpts -s $WLAN_IP:1080 -l 0.0.0.0:8083 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1
Faire des requêtes ```shell
curl -Nv --proxy http://10.0.1.2:8083 http://example.com
sudo ip netns exec ns2 curl -Nv --proxy http://10.0.1.2:8083 https://example.com
sudo ip netns exec ns3 curl -Nv --proxy http://10.0.1.2:8083 https://example.com
sudo ip netns exec ns4 curl -Nv --proxy http://10.0.1.2:8083 https://example.com
Toutes les requêtes devraient aboutir
Proxy HTTP3 - LAN (ns2 (listeners du proxy), ns3, ns4), sockets de sortie dans ns1 (route par défaut, accès internet)
Exécutez le proxy: ``` sudo ./bin/gohpts -s $WLAN_IP:1080 -l 0.0.0.0:8083 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1 -c ./cert.pem -k ./key.pem
Faire des requêtes ```shell ./http3-socks-proxy/bin/client -a 10.0.1.2:8083 www.google.com sudo ip netns exec ns2 ./http3-socks-proxy/bin/client -a 10.0.1.2:8083 www.google.com sudo ip netns exec ns3 ./http3-socks-proxy/bin/client -a 10.0.1.2:8083 www.google.com sudo ip netns exec ns4 ./http3-socks-proxy/bin/client -a 10.0.1.2:8083 www.google.com
Toutes les requêtes devraient réussir
10. **Proxy transparent de redirection - LAN (`ns2` (sockets d'écoute du proxy), `ns3`, `ns4`), sockets sortantes dans `ns1` (route par défaut, accès Internet)**
Exécuter le proxy :
```shell
sudo ./bin/gohpts -s $WLAN_IP:1080 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1 -nohttp -M redirect -T :8888 -auto
```
Effectuer des requêtes
```shell
sudo ip netns exec ns2 curl -Nv https://example.com
```
Pour `ns3` et `ns4`, la requête échoue
11. **Proxy transparent avec `IP_TRANSPARENT` (usurpation arp/ndp activée) LAN (`ns2` (sockets d'écoute du proxy), `ns3`, `ns4`), sockets sortantes dans `ns1` (route par défaut, accès Internet)**
Exécuter le proxy :
```shell
sudo ./bin/gohpts -s $WLAN_IP:1080 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1 -nohttp -M tproxy -T :8888 -auto -arpspoof "fullduplex 1;debug 1;interval 1s" -ndpspoof "ra true;interval 10s;debug 1"
```
Désormais, les requêtes précédentes sur `ns3` et `ns4` devraient fonctionner
```
sudo ip netns exec ns3 curl -Nv https://example.com
sudo ip netns exec ns4 curl -Nv https://example.com
```
12. **Proxy HTTP3 - sockets d'écoute du proxy dans `ns1`, sockets sortantes sur l'hôte, option `-nosocks`**
Exécuter le proxy :
```shell
sudo ./bin/gohpts -l 0.0.0.0:8083 -4 -6 -d -sniff -body -in-netns ns1 -c ./cert.pem -k ./key.pem -nosocks
```
Effectuer une requête
```shell
./http3-socks-proxy/bin/client -a 10.0.0.2:8083 www.google.com
```
La requête devrait réussir
13. **Proxy HTTP3 - sockets d'écoute du proxy sur l'hôte, sockets sortantes dans `ns1`, option `-nosocks`**
Exécuter le proxy :
```shell
sudo ./bin/gohpts -l 0.0.0.0:8083 -4 -6 -d -sniff -body -out-netns ns1 -c ./cert.pem -k ./key.pem -nosocks
```
Effectuer une requête
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
La requête devrait échouer
Ajouter des règles à la chaîne `FORWARD`
```shell
sudo iptables -A FORWARD -i wlan0 -o veth0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
sudo iptables -A FORWARD -i veth0 -o wlan0 -j ACCEPT
sudo ip6tables -A FORWARD -i veth0 -j ACCEPT
sudo ip6tables -A FORWARD -o veth0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
```
Effectuer une requête
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
La requête devrait réussir
## Serveur mixte
[[Retour]](#table-of-contents)
`GoHPTS` peut être configuré pour écouter les connexions SOCKS sur la même adresse que le serveur HTTP ; il suffit d'ajouter l'option `-mixed` pour démarrer un serveur SOCKS supplémentaire. Cela permet à `GoHPTS` d'agir non seulement comme un proxy `HTTP-to-SOCKS` mais aussi comme un proxy `SOCKS-to-SOCKS`. Le serveur SOCKS5 local prend en charge la commande `UDP ASSOCIATE`, donc techniquement, les utilisateurs peuvent envoyer des datagrammes UDP avec ce serveur mixte.
Exécuter le proxy :```shell
gohpts -s :1080 -l :8080 -mixed
Test de connexion :```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Ou désactivez le proxy SOCKS en amont et connectez-vous directement en ajoutant `-nosocks`:```shell
gohpts -l :8080 -mixed -nosocks
Test de connexion :```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Ajoutez l'option `-socks4` pour utiliser le protocole SOCKS4 à la place :```shell
# :1080 should be a socks4 server
gohpts -s :1080 -l :8080 -mixed -socks4
Test de connexion :```shell curl -Nv --proxy socks4://127.0.0.1:8080 "https://example.com"
## Liens
[[Retour]](#table-of-contents)
En savoir plus sur les proxys transparents en visitant les liens suivants:
- [Prise en charge des proxys transparents dans le noyau Linux](https://docs.kernel.org/networking/tproxy.html)
- [Tutoriel sur les proxys transparents par Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Exemple simple de tproxy](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Implémentation d'un proxy transparent avec eBPF et Go](https://medium.com/all-things-ebpf/building-a-transparent-proxy-with-ebpf-50a012237e76)
- [https://github.com/heiher/hev-socks5-tproxy](https://github.com/heiher/hev-socks5-tproxy)
Proxy `socks5` avec prise en charge de `UDP ASSOCIATE`:
- [https://github.com/wzshiming/socks5](https://github.com/wzshiming/socks5)
- [https://github.com/things-go/go-socks5](https://github.com/things-go/go-socks5)
- [https://github.com/0990/socks5](https://github.com/0990/socks5)
- [https://github.com/dizda/fast-socks5](https://github.com/dizda/fast-socks5)
- [https://github.com/semigodking/redsocks](https://github.com/semigodking/redsocks)
- [https://github.com/ginuerzh/gost](https://github.com/ginuerzh/gost)
Sécurité réseau IPv4/IPv6:
- [https://caster0x00.com/legless/](https://caster0x00.com/legless/)
- [https://caster0x00.com/intercept/](https://caster0x00.com/intercept/)
- [https://www.prosec-networks.com/en/blog/ipv6-mitm/](https://www.prosec-networks.com/en/blog/ipv6-mitm/)
## Contribuer
[[Retour]](#table-of-contents)
Êtes-vous développeur?
- Forkez le dépôt
- Créez votre branche de fonctionnalité: `git switch -c my-new-feature`
- Validez vos modifications: `git commit -am 'Add some feature'`
- Poussez vers la branche: `git push origin my-new-feature`
- Soumettez une pull request
## Licence
[[Retour]](#table-of-contents)
GPLv3