Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
go-http-proxy-to-socks — Proxy 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. | Kitploit
Outils/GitHubGitHub/shadowy-pycoder/go-http-proxy-to-socks
Sniffing et Analyse de PaquetsProxies Web et InterceptionÉvasion IDS/IPSSécurité RéseauTests d'IntrusionUtilitaires et FrameworksFuzzing DNSRed TeamingAnalyse DNS
GitHubshadowy-pycoder/go-http-proxy-to-socks

go-http-proxy-to-socks

Proxy 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.

Voir le dépôt
693119il y a 2 moisVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite mais uniquement USB et multiplateforme.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    412
  • 6

    SafeLine

    chaitin/safeline

    WAF auto-hébergé et proxy inverse qui filtre le trafic HTTP malveillant, bloque les injections SQL, les XSS et les attaques de robots, avec limitation de débit et chiffrement dynamique HTML/JS.

    360

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager
# GoHPTS - Proxy transparent HTTP(S) et TCP/UDP vers un proxy SOCKS4/SOCKS5 (chaîne) écrit en Go

[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-yellow.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Go Reference](https://pkg.go.dev/badge/github.com/shadowy-pycoder/go-http-proxy-to-socks.svg)](https://pkg.go.dev/github.com/shadowy-pycoder/go-http-proxy-to-socks)
![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/shadowy-pycoder/go-http-proxy-to-socks)
![AUR Version](https://img.shields.io/aur/version/gohpts)
![AUR Last Modified](https://img.shields.io/aur/last-modified/gohpts)
![AUR Maintainer](https://img.shields.io/aur/maintainer/gohpts)
![Docker Pulls](https://img.shields.io/docker/pulls/shadowypycoder/gohpts)
![GitHub Release](https://img.shields.io/github/v/release/shadowy-pycoder/go-http-proxy-to-socks)
![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/shadowy-pycoder/go-http-proxy-to-socks/total)
![GitHub Downloads (all assets, latest release)](https://img.shields.io/github/downloads/shadowy-pycoder/go-http-proxy-to-socks/latest/total)

![GoHPTS - Colors example](https://assets.kitploit.com/production/public/readmes/11401/f8d0835de2e72b5ff12e3c50484028d40d1538f74d7098619d3ea785495e8536.png)

## 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
```
``````

---

[Read more](https://github.com/shadowy-pycoder/go-http-proxy-to-socks)
Télécharger l’outil