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.
# GoHPTS - Proxy transparent HTTP(S) et TCP/UDP vers un proxy SOCKS4/SOCKS5 (chaîne) écrit en Go
[](https://www.gnu.org/licenses/gpl-3.0)
[](https://pkg.go.dev/github.com/shadowy-pycoder/go-http-proxy-to-socks)
## Table des matières
- [Introduction](#introduction)
- [Fonctionnalités](#features)
- [Installation](#installation)
- [Utilisation](#usage)
- [Configuration via les options CLI](#configuration-via-cli-flags)
- [Configuration via un fichier YAML](#configuration-via-yaml-file)
- [Proxy transparent](#transparent-proxy)
- [redirect (via NAT et SO_ORIGINAL_DST)](#redirect-via-nat-and-so_original_dst)
- [Configuration automatique pour le mode redirect](#auto-configuration-for-redirect-mode)
- [tproxy (via MANGLE et IP_TRANSPARENT)](#tproxy-via-mangle-and-ip_transparent)
- [Configuration automatique pour le mode tproxy](#auto-configuration-for-tproxy-mode)
- [Prise en charge d'UDP](#udp-support)
- [Prise en charge d'Android](#android-support)
- [Configuration YAML](#yaml-configuration)
- [Inspection du trafic](#traffic-sniffing)
- [Format JSON](#json-format)
- [Format coloré](#colored-format)
- [Prise en charge de HTTP2 et HTTP3](#http2-and-http3-support)
- [Exemple de configuration avec un certificat auto-signé](#example-setup-using-self-signed-certificate)
- [Tester la connexion](#test-connection)
- [Tester la connexion dans un navigateur](#test-connection-in-a-browser)
- [Prise en charge d'IPv4 et IPv6](#ipv4-and-ipv6-support)
- [Usurpation ARP](#arp-spoofing)
- [Usurpation NDP](#ndp-spoofing)
- [Usurpation DNS](#dns-spoofing)
- [Capture de paquets](#packet-capture)
- [Espaces de noms réseau](#network-namespaces)
- [Configuration du bac à sable](#playground-setup)
- [Exemples d'utilisation](#usage-examples)
- [Serveur mixte](#mixed-server)
- [Liens](#links)
- [Contribution](#contributing)
- [Licence](#license)
## Introduction
[[Retour]](#table-of-contents)
L'outil en ligne de commande `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 transfère la connexion à travers un proxy SOCKS5. Inspiré par [http-proxy-to-socks](https://github.com/oyyd/http-proxy-to-socks) et [Proxychains](https://github.com/rofl0r/proxychains-ng)
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 à accomplir une telle tâche :
Créer un serveur proxy SOCKS5 via `ssh` :```shell
ssh <remote server> -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és
[[Retour]](#table-of-contents)
- **Fonctionnalité de chaîne de proxies**\
Prend en charge les chaînes `strict`, `dynamic`, `random`, `round_robin` de proxies SOCKS4/SOCKS5
- **Proxy transparent**\
Prend en charge les modes `redirect` (SO_ORIGINAL_DST) et `tproxy` (IP_TRANSPARENT)
- **Prise en charge 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**\
Proxyfiez des sous-réseaux entiers avec l'approche d'usurpation ARP
- **Usurpation NDP**\
Proxyfiez les connexions IPv6 à l'aide d'injections Router/Neighbor Advertisement et RDNSS.
- **Usurpation DNS**\
Redirigez les clients vers des domaines arbitraires à l'aide de la manipulation des enregistrements DNS
- **Capture de paquets**\
Capturez le trafic dans des fichiers txt/pcap/pcapng et analysez-le avec Wireshark
- **Protection contre les fuites DNS**\
La résolution DNS se produit du côté du 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 le transport moderne 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 HTTP trailer
- **Encodage de transfert chunked**\
Gère les réponses 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 proxies 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 une gestion efficace des requêtes.
- **Multiplateforme**\
Compatible avec tous les principaux systèmes d'exploitation.
## Installation
[[Retour]](#table-of-contents)
- Arch Linux/CachyOS/EndeavourOS ```shell
yay -S gohpts
```
Ou en utilisant `paru` : ```shell
paru -S gohpts
```
- Téléchargez le binaire correspondant à votre plateforme depuis la page [Releases](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases) : ```shell
GOHPTS_RELEASE=v1.15.6; 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
```
- Installation à l'aide de la commande `go install` (nécessite Go [1.26](https://go.dev/doc/install) ou une 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`.
- Compiler depuis les sources : ```shell
git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git
cd go-http-proxy-to-socks
make build
./bin/gohpts
```
- Exécuter dans docker : ```shell
docker run -it --privileged --network host -v "$PWD/gohpts.yaml:/config.yaml" shadowypycoder/gohpts:latest -f config.yaml
```
## Utilisation
[[Retour]](#table-of-contents)```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)
-A Comma separated list of allowed ip addresses for proxying (Example: "8.8.8.8,2001:4860:4860::8888,192.168.1.0/24")
-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 flags CLI
[[Retour]](#table-of-contents)```shell
gohpts -s 1080 -l 8080 -d -j
```
Sortie :```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écuter le proxy en tant que démon (un fichier de log est nécessaire pour la sortie de journalisation, sinon vous ne verrez rien)```shell
gohpts -D -logfile /tmp/gohpts.log
```
| `--no-color` | Désactive la sortie colorée |
| `--debug` | Active la journalisation de débogage |
| `--verbose` | Active la journalisation verbeuse |
| `--quiet` | Supprime toute sortie non essentielle |
| `--json` | Produit une sortie au format JSON |
| `--yaml` | Produit une sortie au format YAML |
| `--csv` | Produit une sortie au format CSV |
| `--output <file>` | Écrit la sortie dans un fichier |
| `--input <file>` | Lit l'entrée depuis un fichier |
| `--config <file>` | Spécifie un fichier de configuration |
| `--timeout <seconds>` | Définit un délai d'attente |
| `--retry <count>` | Définit le nombre de tentatives |
| `--threads <count>` | Définit le nombre de threads |
| `--rate-limit <rate>` | Définit la limitation de débit |
| `--proxy <url>` | Définit un proxy |
| `--user-agent <string>` | Définit l'User-Agent |
| `--header <header>` | Définit un en-tête personnalisé |
| `--cookie <cookie>` | Définit un cookie |
| `--auth <credentials>` | Définit les identifiants d'authentification |
| `--token <token>` | Définit un jeton d'authentification |
| `--api-key <key>` | Définit une clé API |
| `--secret <secret>` | Définit un secret |
| `--password <password>` | Définit un mot de passe |
| `--username <username>` | Définit un nom d'utilisateur |
| `--email <email>` | Définit une adresse e-mail |
| `--phone <phone>` | Définit un numéro de téléphone |
| `--address <address>` | Définit une adresse |
| `--port <port>` | Définit un port |
| `--host <host>` | Définit un hôte |
| `--url <url>` | Définit une URL |
| `--path <path>` | Définit un chemin |
| `--file <file>` | Définit un fichier |
| `--directory <directory>` | Définit un répertoire |
| `--database <database>` | Définit une base de données |
| `--table <table>` | Définit une table |
| `--column <column>` | Définit une colonne |
| `--row <row>` | Définit une ligne |
| `--query <query>` | Définit une requête |
| `--filter <filter>` | Définit un filtre |
| `--sort <sort>` | Définit un tri |
| `--limit <limit>` | Définit une limite |
| `--offset <offset>` | Définit un décalage |
| `--page <page>` | Définit une page |
| `--size <size>` | Définit une taille |
| `--format <format>` | Définit un format |
| `--encoding <encoding>` | Définit un encodage |
| `--language <language>` | Définit une langue |
| `--locale <locale>` | Définit une locale |
| `--timezone <timezone>` | Définit un fuseau horaire |
| `--date <date>` | Définit une date |
| `--time <time>` | Définit une heure |
| `--datetime <datetime>` | Définit une date et une heure |
| `--duration <duration>` | Définit une durée |
| `--interval <interval>` | Définit un intervalle |
| `--frequency <frequency>` | Définit une fréquence |
| `--schedule <schedule>` | Définit une planification |
| `--cron <cron>` | Définit une expression cron |
| `--daemon` | Exécute en mode démon |
| `--background` | Exécute en arrière-plan |
| `--foreground` | Exécute au premier plan |
| `--interactive` | Exécute en mode interactif |
| `--batch` | Exécute en mode batch |
| `--parallel` | Exécute en parallèle |
| `--sequential` | Exécute en séquentiel |
| `--recursive` | Exécute de manière récursive |
| `--force` | Force l'exécution |
| `--dry-run` | Exécute en mode simulation |
| `--yes` | Répond oui à toutes les invites |
| `--no` | Répond non à toutes les invites |
| `--help` | Affiche le message d'aide |
| `--version` | Affiche les informations de version |```shell
# output
gohpts pid: <pid>
```
| `-s` | `--server` | `SERVER` | `http://localhost:8080` | URL du serveur cible |
| `-t` | `--token` | `TOKEN` | - | Jeton d'authentification |
| `-o` | `--output` | `FILE` | `stdout` | Fichier de sortie |
| `-v` | `--verbose` | - | `false` | Activer la sortie détaillée |
| `-q` | `--quiet` | - | `false` | Supprimer la sortie non essentielle |
| `-f` | `--format` | `FORMAT` | `json` | Format de sortie (json, yaml, table) |
| `-c` | `--config` | `FILE` | `~/.config/tool/config.yaml` | Chemin du fichier de configuration |
| `-d` | `--debug` | - | `false` | Activer le mode débogage |
| `-n` | `--dry-run` | - | `false` | Exécuter sans appliquer les modifications |
| `-y` | `--yes` | - | `false` | Répondre automatiquement oui aux invites |
| `-h` | `--help` | - | - | Afficher le message d'aide |
| `-V` | `--version` | - | - | Afficher la version |
### Exemples
```bash
# Exécution de base
tool --server http://localhost:8080 --token abc123
# Avec fichier de sortie
tool -s http://localhost:8080 -t abc123 -o results.json
# Mode verbeux avec format yaml
tool -s http://localhost:8080 -t abc123 -v -f yaml
# Exécution à blanc
tool -s http://localhost:8080 -t abc123 --dry-run
# Utilisation d'un fichier de configuration personnalisé
tool -c /path/to/config.yaml
```
### Variables d'environnement
| Variable | Description | Valeur par défaut |
|----------|-------------|-------------------|
| `TOOL_SERVER` | URL du serveur cible | `http://localhost:8080` |
| `TOOL_TOKEN` | Jeton d'authentification | - |
| `TOOL_CONFIG` | Chemin du fichier de configuration | `~/.config/tool/config.yaml` |
| `TOOL_DEBUG` | Activer le mode débogage | `false` |
| `TOOL_TIMEOUT` | Délai d'expiration de la requête en secondes | `30` |
| `TOOL_RETRIES` | Nombre de tentatives en cas d'échec | `3` |
### Fichier de configuration
Le fichier de configuration utilise le format YAML :
```yaml
server: http://localhost:8080
token: your-token-here
output: results.json
format: json
verbose: false
debug: false
timeout: 30
retries: 3
```
## Utilisation
### Démarrage rapide
1. Installer l'outil :
```bash
go install github.com/example/tool@latest
```
2. Configurer l'authentification :
```bash
export TOOL_TOKEN=your-token-here
```
3. Exécuter votre première analyse :
```bash
tool scan --target example.com
```
### Commandes courantes
#### Analyser une cible
```bash
tool scan --target example.com --output results.json
```
#### Lister les analyses disponibles
```bash
tool list
```
#### Afficher les détails d'une analyse
```bash
tool show <scan-id>
```
#### Supprimer une analyse
```bash
tool delete <scan-id>
```
#### Exporter les résultats
```bash
tool export <scan-id> --format csv --output results.csv
```
## Sortie
L'outil prend en charge plusieurs formats de sortie :
### JSON
```json
{
"scan_id": "abc123",
"target": "example.com",
"status": "completed",
"findings": [
{
"id": "finding-1",
"severity": "high",
"title": "Exemple de vulnérabilité",
"description": "Description détaillée de la vulnérabilité",
"remediation": "Étapes pour corriger le problème"
}
]
}
```
### YAML
```yaml
scan_id: abc123
target: example.com
status: completed
findings:
- id: finding-1
severity: high
title: Exemple de vulnérabilité
description: Description détaillée de la vulnérabilité
remediation: Étapes pour corriger le problème
```
### Tableau
```
+----------+----------+-----------+--------------------------------+
| ID | SÉVÉRITÉ | TITRE | DESCRIPTION |
+----------+----------+-----------+--------------------------------+
| finding-1| high | Exemple | Description détaillée... |
+----------+----------+-----------+--------------------------------+
```
## Contribution
Les contributions sont les bienvenues ! Veuillez consulter le fichier [CONTRIBUTING.md](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/CONTRIBUTING.md) pour plus de détails.
### Configuration du développement
1. Cloner le dépôt :
```bash
git clone https://github.com/example/tool.git
cd tool
```
2. Installer les dépendances :
```bash
go mod download
```
3. Exécuter les tests :
```bash
go test ./...
```
4. Compiler le projet :
```bash
go build -o tool
```
### Directives de contribution
- Forker le dépôt
- Créer une branche de fonctionnalité (`git checkout -b feature/amazing-feature`)
- Valider vos modifications (`git commit -m 'Add amazing feature'`)
- Pousser vers la branche (`git push origin feature/amazing-feature`)
- Ouvrir une Pull Request
## Licence
Ce projet est sous licence MIT - voir le fichier [LICENSE](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/LICENSE) pour plus de détails.
## Remerciements
- [Contributeur 1](https://github.com/contributor1)
- [Contributeur 2](https://github.com/contributor2)
## Support
- Documentation : [https://docs.example.com](https://docs.example.com)
- Problèmes : [https://github.com/example/tool/issues](https://github.com/example/tool/issues)
- Discussions : [https://github.com/example/tool/discussions](https://github.com/example/tool/discussions)
## Avertissement
Cet outil est destiné à des fins de tests de sécurité et d'évaluation autorisés uniquement. Les utilisateurs sont responsables du respect de toutes les lois et réglementations applicables. Les auteurs ne sont pas responsables de toute utilisation abusive ou de tout dommage résultant de l'utilisation de cet outil.```shell
# kill the process
kill <pid>
#or
kill $(pidof gohpts)
```
`-u` et `-U` ne fonctionnent pas en mode démon (et donc pour l'authentification), mais vous pouvez fournir un fichier de configuration (voir ci-dessous)
### Configuration via un fichier YAML
[[Retour]](#table-of-contents)
Les fichiers de configuration sont utiles lorsque vous souhaitez préconfigurer votre proxy sans trop vous embêter avec la CLI ou simplement avoir plusieurs profils pour différents besoins.
Lancer le proxy http en mode chaîne de proxies SOCKS5 (spécifier les paramètres du serveur via un fichier de configuration YAML)```shell
gohpts -f "~/gohtps.yaml" -d -j
```
Exemple de configuration :```yaml
# bind proxy to specific network interface (either by interface name or index)
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)
# if ipv4 and ipv6 are both false or both true, dual stack is assumed
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 and password for adding basic authentication (comment out to disable auth)
username: username
password: password
# list of socks5 proxy
# if proxy_chain is disabled, uses first server in a list as upstream
proxy_list:
- address: 127.0.0.1:1080
- address: 127.0.0.1:1081
- address: :1082 # empty host means localhost
proxy_chain:
enabled: false
# Explanations for chains taken from /etc/proxychains4.conf
# strict - Each connection will be done via chained proxies
# all proxies chained in the order as they appear in the list
# all proxies must be online to play in chain
# dynamic - Each connection will be done via chained proxies
# all proxies chained in the order as they appear in the list
# at least one proxy must be online to play in chain
# (dead proxies are skipped)
# random - Each connection will be done via random proxy
# (or proxy chain, see chain_len) from the list.
# this option is good to test your IDS :)
# round_robin - Each connection will be done via chained proxies
# of chain_len length
# all proxies chained in the order as they appear in the list
# at least one proxy must be online to play in chain
# (dead proxies are skipped).
# the start of the current proxy chain is the proxy after the last
# proxy in the previously invoked proxy chain.
# if the end of the proxy chain is reached while looking for proxies
# start at the beginning again.
# These semantics are not guaranteed in a multithreaded environment.
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
# defaults to standard output
#logfile: /tmp/gohpts.log
# use colored output in logs (no effect if json enabled)
nocolor: false
# profiling data
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 options CLI correspondantes :```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor
```
Le proxy prend tous les paramètres spécifiés dans `~/gohpts.yaml` mais démarre 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 exemple proxy_chain et les filtres dns) ne peuvent être configurés que via un fichier.
La version complète de la configuration est disponible ici : [example_gohpts.yaml](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/resources/example_gohpts.yaml)
Pour en savoir plus sur les chaînes de proxy, consultez [Proxychains Github](https://github.com/rofl0r/proxychains-ng)
## Proxy transparent
[[Retour]](#table-of-contents)
> Également appelé `proxy intercepteur`, `proxy en ligne` ou `proxy forcé`, un proxy transparent intercepte la communication normale 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 assurant certaines des fonctions d'une passerelle ou d'un routeur
>
> -- _D'après [Wiki](https://en.wikipedia.org/wiki/Proxy_server)_
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.)
Le drapeau `-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 le drapeau `-M`
### `redirect` (via _NAT_ et _SO_ORIGINAL_DST_)
[[Retour]](#table-of-contents)
Dans ce mode, le proxying se fait avec la table `nat` d'`iptables` et la cible `REDIRECT`. L'hôte du paquet entrant change pour 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, vous utilisez le drapeau `-T` avec `-M redirect`
### Exemple
[[Retour]](#table-of-contents)```shell
# run the proxy
gohpts -s 1080 -T 1090 -M redirect -d
```
| `--list` | List all available modules. |
| `--module <name>` | Run a specific module. |
| `--target <host>` | Target host or IP address. |
| `--port <port>` | Target port. |
| `--output <file>` | Save results to a file. |
| `--verbose` | Enable verbose output. |
| `--threads <n>` | Number of concurrent threads. |
| `--timeout <sec>` | Connection timeout in seconds. |
| `--proxy <url>` | Use a proxy for connections. |
| `--config <file>` | Load configuration from a file. |
| `--no-color` | Disable colored output. |
| `--debug` | Enable debug mode. |
| `--version` | Show version information. |
| `--help` | Show help message. |
### Examples
```bash
# List all modules
./tool --list
# Run a specific module against a target
./tool --module scanner --target 192.168.1.1
# Save output to a file
./tool --module scanner --target example.com --output results.txt
# Use a proxy
./tool --module scanner --target example.com --proxy http://127.0.0.1:8080
```
### Configuration File
The tool supports a configuration file in YAML format:
```yaml
target: example.com
port: 443
threads: 10
timeout: 30
verbose: true
``````shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf
```
Configurez votre système d'exploitation :```shell
# commands below require elevated privileges (you can run it with `sudo -i`)
#enable ip forwarding
sysctl -w net.ipv4.ip_forward=1
# create `GOHPTS` nat chain
iptables -t nat -N GOHPTS
# set no redirection rules for local, http proxy, ssh and redirect proxy itself
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
# redirect traffic to transparent proxy
iptables -t nat -A GOHPTS -p tcp -j REDIRECT --to-ports 1090
# setup prerouting by adding our proxy
iptables -t nat -A PREROUTING -p tcp -j GOHPTS
# intercept local traffic for testing
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
```
- **`--no-verify`** : Ignorer la vérification du certificat SSL (utile pour les certificats auto-signés)
- **`--timeout`** : Délai d'attente de la requête en secondes (par défaut : 10)
- **`--user-agent`** : Chaîne User-Agent personnalisée
- **`--headers`** : En-têtes HTTP supplémentaires au format `Key:Value` (peut être répété)
- **`--proxy`** : Proxy à utiliser pour les requêtes (par exemple, `http://127.0.0.1:8080`)
- **`--cookie`** : Cookies à envoyer avec les requêtes
- **`--data`** : Données à envoyer dans le corps de la requête (pour les requêtes POST)
- **`--method`** : Méthode HTTP à utiliser (par défaut : GET)
- **`--output`** : Fichier de sortie pour enregistrer les résultats
- **`--format`** : Format de sortie (par exemple, `json`, `csv`, `text`)
- **`--verbose`** : Activer la sortie détaillée
- **`--quiet`** : Supprimer toute sortie sauf les erreurs
- **`--version`** : Afficher la version du programme et quitter
- **`--help`** : Afficher le message d'aide et quitter```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
```
### Configuration automatique pour le mode `redirect`
[[Retour]](#table-of-contents)
Pour 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_)
[[Retour]](#table-of-contents)
Dans ce mode, le proxy fonctionne 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 à l'aide de 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, vous utilisez le flag `-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 don't have the source content to translate. You mentioned "INPUT:" but no actual Markdown text followed it.
Please paste the chunk 61 content you'd like translated from English to French, and I'll return only the translated Markdown with all structure, code, paths, and identifiers preserved exactly.```shell
# run socks5 server on 127.0.0.1:1080
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
```
Annuler tout :```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
```
### Configuration automatique pour le mode `tproxy`
[[Retour]](#table-of-contents)
Pour configurer votre système automatiquement, exécutez la commande suivante (par exemple, sur une VM séparée) :```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
```
### Prise en charge d'UDP
[[Retour]](#table-of-contents)
`GoHPTS` dispose d'une prise en charge d'UDP qui peut être activée 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](https://github.com/wzshiming/socks5) pour déployer un serveur socks5 compatible UDP sur une machine distante ou locale. Une fois que vous avez le 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 mettra en place le serveur sur l'adresse `0.0.0.0:8989`.
Pour le tester localement, vous pouvez combiner le proxy transparent UDP avec le flag `-arpspoof`. Par exemple :
1. Configurez une VM sur votre système avec n'importe quelle 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 là-bas 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"
```
5. Vérifiez la connexion sur votre machine hôte, le trafic doit passer par la machine Kali.
### Prise en charge d'Android
[[Retour]](#table-of-contents)
Le proxy transparent peut être activé sur les appareils Android (arm64) disposant d'un accès root. Vous pouvez installer [Termux](https://github.com/termux/termux-app) et y exécuter `GoHPTS` en tant qu'outil CLI :```shell
# you need to root your device first
pkg install tsu iproute2
# Android support added in v1.10.2
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
# use your phone as router for LAN devices redirecting their traffic to remote socks5 server
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
```
## Analyse du trafic
[[Retour]](#table-of-contents)
<p align="center"><img alt="MrGopher" src="https://assets.kitploit.com/production/public/readmes/11401/ac38691c0f511a6265baf784c236e4ca9557e6c2b7744271f09b1b657af92ca7.png"/>
Le proxy `GoHPTS` permet de capturer et de surveiller le trafic qui traverse 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) :
### Format JSON
[[Retour]](#table-of-contents)```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 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"]
}
}
}
]
```
Utilisation aussi simple que de spécifier le flag `-sniff` avec les flags habituels```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
```
### Format coloré
[[Retour]](#table-of-contents)
Vous pouvez voir un exemple de sortie colorée dans l'image ci-dessus. Dans ce mode, `GoHPTS` tente de mettre en évidence les informations importantes telles que la poignée de main TLS, les métadonnées HTTP, ce qui ressemble à des identifiants/mots de passe ou différents types de jetons d'authentification et de 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 flags suivants :```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
[[Retour]](#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 modifier la configuration. Le certificat TLS peut être obtenu de plusieurs façons : fournisseurs cloud (Google, AWS, Cloudflare), certificat gratuit de Let's Encrypt, ou vous pouvez créer un certificat auto-signé à l'aide de `openssl` (Linux/macOS) ou `New-SelfSignedCertificate` (Windows).
### Exemple de configuration utilisant un certificat auto-signé
[[Retour]](#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"
```
- Préparer un serveur socks5 avec prise en charge d'UDP ASSOCIATE ```shell
git clone https://github.com/wzshiming/socks5.git && cd socks5
go build -o socks5_server ./cmd/socks5/main.go
./socks5_server -a 0.0.0.0:1080
```
- Ouvrez un autre terminal et installez le proxy `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](#installation).
- Enfin :
1. Créez une configuration minimale pour votre proxy ```yaml
# gohpts_config.yaml
http_server:
address: 127.0.0.1:8080
cert_file: ./cert.pem
key_file: ./key.pem
proxy_list:
- address: 127.0.0.1:1080
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 en ligne de commande : ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body
```
Vous devriez voir quelque chose comme ceci : ```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
[[Retour]](#table-of-contents)
- Pour un 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 d'exécution.
- Pour HTTP/3, c'est différent car (au moment de la rédaction) `curl` ne prend pas en charge le proxy HTTP3, donc j'utiliserai mon client personnalisé que j'ai créé à des fins de test.
Téléchargez et installez [Simple HTTP3 to SOCKS5 proxy example](https://github.com/shadowy-pycoder/http3-socks-proxy) : ```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 du 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
```
Plus d'informations sont disponibles ici : [Creating a browser trusted, self signed, SSL certificate](https://medium.com/@tbusser/creating-a-browser-trusted-self-signed-ssl-certificate-2709ce43fd15)
- Ajoutez le `rootCA.crt` nouvellement créé au magasin de confiance du système :
1. Debian/Ubuntu : ```shell
sudo cp rootCA.crt /usr/local/share/ca-certificates/rootCA.crt
sudo update-ca-certificates
```
2. Arch Linux/CachyOS/EndeavourOS : ```shell
sudo trust anchor rootCA.crt
```
- Lancez le proxy en utilisant `server.crt` et `server.key` : ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body
```
- Lancez le navigateur et accédez à n'importe quel site web : ```shell
chromium --proxy-server="https://127.0.0.1:8080"
```
## Prise en charge d'IPv4 et IPv6
[[Retour]](#table-of-contents)
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 flags `-4` et `-6`. Lorsque l'un des flags est défini, le proxy démarre dans le mode correspondant ; lorsque les deux flags sont présents ou tous deux omis, le mode `dual stack` est supposé. 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 le flag `-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"
```
2. Sur votre hôte :```shell
# run proxy on your host
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 le proxy socks5 distant doivent prendre en charge IPv6, vous pouvez visiter [https://test-ipv6.com/](https://test-ipv6.com/) pour vérifier que vous pouvez accéder aux adresses IPv6.
Pour tester le proxy en mode IPv6, vous pouvez utiliser n'importe quelle VM Linux :
1. Sur votre machine virtuelle :```shell
# add your host machine as gateway IPv6 for VM
export GATEWAY6="<host IPv6 address>"
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
```
3. Visitez n'importe quel site web sur votre machine virtuelle et observez le trafic dans les journaux du proxy
## ARP spoofing
[[Retour]](#table-of-contents)
`GoHPTS` dispose d'un ARP spoofer 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.
Ceci est réalisé en ajoutant le flag `-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 va scanner les appareils du sous-réseau `192.168.10.0/24` et leur envoyer des paquets ARP pour se faire passer pour une passerelle ; si `fullduplex` est vrai,
le proxy enverra également des paquets ARP à la passerelle afin de lui faire croire que notre proxy possède chaque IP du sous-réseau.
Une fois le proxy arrêté avec `Ctrl+C`, il annulera automatiquement l'usurpation ARP de toutes les cibles.
`GoHPTS` peut également être utilisé avec des outils comme [Bettercap](https://github.com/bettercap/bettercap) pour proxifier le trafic usurpé par ARP.
Lancer 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](https://www.bettercap.org/)) :```shell
sudo bettercap -eval "net.probe on;net.recon on;set arp.spoof.fullduplex true;arp.spoof on"
```
Vérifiez les journaux du proxy pour le trafic provenant d'autres appareils de votre réseau local
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
[[Retour]](#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éfinir l'hôte comme serveur de noms IPv6 pour les clients affectés. Lorsqu'elle est combinée avec le mode proxy transparent (TCP/UDP), l'usurpation NDP permet à `gohpts` de proxifier le trafic pour les clients des réseaux locaux. Comme c'est le cas avec [l'usurpation ARP](#arp-spoofing), vous pouvez définir les options d'usurpation ndp avec un seul drapeau `-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, voir `gohpts -h` et [https://github.com/shadowy-pycoder/ndpspoof](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 en tant que proxy.
Comme `gohpts` proxyfie toutes les connexions via un serveur SOCKS5 en amont, vous devez disposer d'un serveur fonctionnel avec prise en charge IPv4/IPv6 et TCP/UDP. De toute évidence, une machine distante (par exemple un VPS) doit également avoir une connectivité IPv6 fonctionnelle. Il va sans dire que la machine sur laquelle `gohpts` s'exécute doit faire partie d'un réseau avec prise en charge IPv6.
Exemple de configuration pour que l'usurpation NDP fonctionne correctement :
1. Se connecter au VPS```shell
ssh [email protected]
```
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
```
3. Configurer un serveur SOCKS5 (assurez-vous que les règles du pare-feu ne bloquent pas les ports utilisés)```shell
git clone https://github.com/wzshiming/socks5.git && cd socks5
go build -o ./bin/socks5_server ./cmd/socks5/*.go
./bin/socks5_server -a :3000
```
4. Revenez sur 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
```
6. 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 à l'adresse de votre VPS `203.0.113.10` dans ce cas ou à l'adresse IPv6 globale)
7. Arrêtez le proxy en appuyant sur Ctrl+C
8. Profitez-en !
## Usurpation DNS
[[Retour]](#table-of-contents)
Pour appliquer des filtres DNS et usurper des cibles en modifiant les enregistrements DNS, l'hôte exécutant `GoHPTS` doit devenir la passerelle par défaut des appareils du réseau local. Pour que cela fonctionne, il suffit d'exécuter le proxy transparent avec udp activé et d'exécuter également l'usurpation ARP/NDP pour 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 « standard » non chiffré (`DOT`/`DOH` non filtrés ni usurpés).
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 habituellement dans un fichier hosts, voir [https://en.wikipedia.org/wiki/Hosts\_(file)](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/%3Chttps%3A/en.wikipedia.org/wiki/Hosts_%28file)>).
Exemple :```yaml
# dns filters require udp transparent proxy and arpspoof/ndpspoof
# filters accept hosts like entries (use either links, file paths or just plain comma separated lists
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 réseau local
- Contrôle parental via le blocage de catégories spécifiques de sites web
- Blocage des domaines de phishing et de logiciels malveillants connus
- Redirection du trafic à des fins d'analyse
- Collecte d'identifiants via redirection
- Détournement et manipulation du trafic (injection de publicités, scripts, suivi)
- Surveillance et profilage
Configuration minimale pour cette installation :```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écuter :```shell
sudo ./gohpts -f ./gohpts_dns_spoof.yaml
```
Plus d'informations sont disponibles 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 les formats pcap, pcapng ou txt personnalisé et 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 pour pouvoir capturer des paquets bruts, vous avez deux options :
- Exécutez `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` une fois pour donner au proxy un accès brut au trafic
- Exécutez le proxy avec `sudo` lorsque vous devez spécifier le flag `-pcap` en 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 pourront 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, mais cela peut être modifié. Les sockets d'écoute (par exemple, serveur http ou 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 flags `-in-netns` (listeners) et `-out-netns` (dialers) avec le nom ou le chemin vers l'espace de noms réseau pour contrôler dans quel environnement isolé créer les sockets. Si vous souhaitez créer des listeners ou des dialers dans l'espace de noms actuel (par défaut), omettez simplement le flag. Pour spécifier explicitement l'espace de noms de l'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 la 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 dispose de [systemd-resolved.service (8)](https://man7.org/linux/man-pages/man8/systemd-resolved.service.8.html) activé, vous pouvez souhaiter le désactiver temporairement lors de l'exécution 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'
```
### Configuration du terrain de jeu
[[Retour]](#table-of-contents)
- Exécuter un serveur socks5 avec prise en charge d'UDP ASSOCIATE ```shell
git clone https://github.com/wzshiming/socks5.git && cd socks5
go build -o socks5_server ./cmd/socks5/main.go
./socks5_server -a 0.0.0.0:1080
```
- Téléchargez et installez [Simple HTTP3 to SOCKS5 proxy example](https://github.com/shadowy-pycoder/http3-socks-proxy) : ```shell
git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git
cd http3-socks-proxy
make
```
- Cloner le dépôt et compiler ```shell
git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git
cd go-http-proxy-to-socks
make
```
- 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"
```
- Créer un namespace réseau `ns1` et configurer 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
```
- Déterminer l'adresse IP de `wlan0` afin de 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')
```
### Exemples d'utilisation
[[Retour]](#table-of-contents)
1. **Proxy HTTP - écouteurs proxy dans `ns1` (pas de route par défaut, pas d'accès internet), sockets sortants sur l'hôte**
Lancer le proxy : ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1
```
Effectuer la 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 doit réussir
2. **Proxy HTTP2 - écouteurs proxy dans `ns1` (pas de route par défaut, pas d'accès à Internet), sockets sortants sur l'hôte**
Lancer 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
```
Effectuer la 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 - écouteurs proxy dans `ns1` (pas de route par défaut, pas d'accès à Internet), sockets sortants sur l'hôte**
Lancer 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
```
Effectuer la 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 doit réussir
4. **Proxy transparent par redirection (`-M redirect`) - écouteurs proxy dans `ns1` (route par défaut, pas d'accès internet), sockets sortants sur l'hôte**
Lancer 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
```
Effectuer la requête via `ns1` ```shell
sudo ip netns exec ns1 curl -Nv https://example.com
```
La requête doit échouer
Ajouter une 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éessayez ```shell
sudo ip netns exec ns1 curl -Nv https://example.com
```
La requête devrait maintenant réussir
5. **Proxy HTTP - écouteurs proxy sur l'hôte, sockets sortants dans `ns1` (route par défaut, accès internet)**
Ajouter 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
```
La requête doit réussir
6. **Proxy HTTP3 - écouteurs proxy sur l'hôte, sockets sortants dans `ns1` (route par défaut, accès Internet)**
Lancer le proxy : ```
sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0 -c ./cert.pem -k ./key.pem
```
Effectuer une requête via l'hôte ```shell
./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com
```
La requête doit réussir
7. **Proxy transparent avec redirection - écouteurs proxy sur l'hôte, sockets sortants dans `ns1` (route par défaut, accès internet)**
Lancer le proxy (`-auto` ne fonctionne pas avec un serveur socks5 local pour moi, donc j'utilise 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 réussir
8. **Proxy HTTP - LAN (`ns2` (écouteurs 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
```
Exécuter 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
```
Effectuer 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 doivent réussir
9. **Proxy HTTP3 - LAN (`ns2` (écouteurs proxy), `ns3`, `ns4`), sockets sortants dans `ns1` (route par défaut, accès internet)**
Lancer 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
```
Effectuer 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 par redirection - LAN (`ns2` (écouteurs proxy), `ns3`, `ns4`), sockets sortants dans `ns1` (route par défaut, accès internet)**
Lancer 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` (écouteurs proxy), `ns3`, `ns4`), sockets sortants dans `ns1` (route par défaut, accès internet)**
Lancer 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"
```
Maintenant 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 - écouteurs proxy dans `ns1`, sockets sortants sur l'hôte, flag `-nosocks`**
Lancer 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 - écouteurs proxy sur l'hôte, sockets sortants dans `ns1`, flag `-nosocks`**
Lancer 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 le flag `-mixed` pour démarrer un serveur SOCKS supplémentaire. Cela permet à `GoHPTS` d'agir non seulement comme proxy `HTTP-to-SOCKS` mais aussi comme 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.
Lancer 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 le flag `-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)
Pour en savoir plus sur les proxies transparents, consultez les liens suivants :
- [Transparent proxy support in Linux Kernel](https://docs.kernel.org/networking/tproxy.html)
- [Transparent proxy tutorial by Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Simple tproxy example](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Transparent Proxy Implementation using eBPF and 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/)
## Contribution
[[Retour]](#table-of-contents)
Vous êtes 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