GoHPTS - Proxy trasparente HTTP(S) e TCP/UDP verso proxy SOCKS4/SOCKS5 (catena) scritto in Go

GitHub go.mod Go version AUR Version AUR Last Modified AUR Maintainer Docker Pulls GitHub Release GitHub Downloads (all assets, all releases)

GoHPTS - Colors example

Indice

Introduzione
Funzionalità
Installazione
Utilizzo
- Configurazione tramite flag CLI
- Configurazione tramite file YAML
Proxy trasparente
Sniffing del traffico
- Formato JSON
- Formato colorato
Supporto HTTP2 e HTTP3
Supporto IPv4 e IPv6
ARP spoofing
NDP spoofing
DNS spoofing
Cattura pacchetti
Network Namespaces
- Configurazione del playground
- Esempi di utilizzo
Mixed Server
Link
Contribuire
Licenza

Introduzione

[Indietro]

Lo strumento CLI GoHPTS è un ponte tra i client HTTP e un server proxy SOCKS5 o più server (catena). Si mette in ascolto localmente come proxy HTTP, accetta richieste HTTP standard o HTTPS (tramite CONNECT) e inoltra la connessione attraverso un proxy SOCKS5. Ispirato a http-proxy-to-socks e Proxychains

Possibile caso d'uso: devi connetterti a un'API esterna tramite Postman, ma questa API è disponibile solo da un server remoto. I seguenti comandi ti aiuteranno a svolgere tale compito:

Crea un server proxy SOCKS5 tramite ssh:```shell ssh -D 1080 -Nf

Crea una connessione HTTP-to-SOCKS5 con `gohpts````shell
gohpts -s :1080 -l :8080

Specifica il server http nella configurazione del proxy di Postman

Funzionalità

[Indietro]

Funzionalità Proxy Chain
Supporta catene strict, dynamic, random, round_robin di proxy SOCKS4/SOCKS5
Proxy trasparente
Supporta le modalità redirect (SO_ORIGINAL_DST) e tproxy (IP_TRANSPARENT)
Supporto IPv4 e IPv6
Opera in modalità IPv4-only, IPv6-only o dual stack
Proxy trasparente TCP e UDP
tproxy e tlocal (IP_TRANSPARENT) gestiscono il traffico TCP e UDP
Sniffing del traffico
Il proxy è in grado di analizzare header HTTP, handshake TLS, messaggi DNS e altro
ARP spoofing
Proxy di intere sottoreti con l'approccio ARP spoofing
NDP spoofing
Proxy di connessioni IPv6 utilizzando Router/Neighbor Advertisement e iniezioni RDNSS.
DNS spoofing
Reindirizza i client verso domini arbitrari tramite la manipolazione dei record DNS
Cattura pacchetti
Cattura il traffico in file txt/pcap/pcapng e analizzalo con Wireshark
Protezione dalle perdite DNS
La risoluzione DNS avviene lato server SOCKS5.
Supporto del metodo CONNECT
Supporta il tunneling HTTP CONNECT, abilitando HTTPS e altri protocolli basati su TCP.
Supporto HTTP2/HTTP3
Supporta il trasporto moderno HTTP/2 e HTTP/3, abilitando connessioni multiplexate efficienti su TLS 1.3
Supporto dei Network Namespaces
Supporta network namespace Linux personalizzati per socket in ascolto e connessioni in uscita
Supporto degli header Trailer
Gestisce gli header trailer HTTP
Chunked Transfer Encoding
Gestisce risposte chunked e in streaming
Supporto autenticazione SOCKS5
Supporta l'autenticazione username/password per i proxy SOCKS5.
Supporto autenticazione HTTP
Supporta l'autenticazione username/password per il server proxy HTTP.
Leggero e veloce
Progettato con overhead minimo e gestione efficiente delle richieste.
Multipiattaforma
Compatibile con tutti i principali sistemi operativi.

Installazione

[Indietro]

Arch Linux/CachyOS/EndeavourOS ```shell yay -S gohpts

Oppure usando paru: ```shell paru -S gohpts

- Scarica il binario per la tua piattaforma dalla pagina [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

Installazione tramite il comando go install (richiede Go 1.26 o successivo): ```shell CGO_ENABLED=0 go install -ldflags "-s -w" -trimpath github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest

This installerà il binario gohpts nella tua directory $GOPATH/bin.

Compila dal sorgente: ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make build ./bin/gohpts
Esegui in docker: ```shell docker run -it --privileged --network host -v "$PWD/gohpts.yaml:/config.yaml" shadowypycoder/gohpts:latest -f config.yaml

Utilizzo

[Indietro]```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)

### Configurazione tramite flag CLI

[[Indietro]](#table-of-contents)```shell
gohpts -s 1080 -l 8080 -d -j

I cannot translate this content because the INPUT section is empty. No source text was provided for chunk 21 of 241.

Please provide the actual Markdown content you want translated from English to Italian, and I will return only the translated text with all Markdown structure, code, paths, URLs, and technical identifiers preserved exactly as specified.```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"}

Specificare nome utente e password per il server proxy SOCKS5:```shell
gohpts -s 1080 -l 8080 -d -j -u user
SOCKS5 Password: #you will be prompted for password input here

Specificare nome utente e password per il server proxy HTTP:```shell gohpts -s 1080 -l 8080 -d -j -U user HTTP Password: #you will be prompted for password input here

Quando sono presenti sia `-u` che `-U`, ti verrà richiesto due volte

Esegui il proxy http su connessione TLS```shell
gohpts -s 1080 -l 8080 -c "path/to/certificate" -k "path/to/private/key"

Esegui il proxy come demone (il file di log è necessario per l'output di logging, altrimenti non vedrai nulla)```shell gohpts -D -logfile /tmp/gohpts.log

I cannot translate this content because no text was provided. The INPUT section is empty.

Please send the actual Markdown chunk you want translated, and I will return only the Italian translation with all Markdown structure, code, paths, URLs, and identifiers preserved exactly as-is.```shell
# output
gohpts pid: <pid>

I cannot translate this content because no source text was provided. The INPUT section is empty.

Please send the actual Markdown chunk (chunk 33 of 241) that you want translated from English to Italian, and I will return only the translated Markdown, preserving all structure, code, paths, URLs, and identifiers exactly as required.```shell

kill the process

kill #or kill $(pidof gohpts)

I flag `-u` e `-U` non funzionano in modalità daemon (e quindi nell'autenticazione), ma puoi fornire un file di configurazione (vedi sotto)

### Configurazione tramite file YAML

[[Indietro]](#table-of-contents)

I file di configurazione sono utili quando vuoi preconfigurare il tuo proxy senza dover smanettare troppo con la CLI o semplicemente vuoi avere più profili per esigenze diverse.

Avvia il proxy http in modalità catena di proxy SOCKS5 (specifica le impostazioni del server tramite file di configurazione YAML)```shell
gohpts -f "~/gohtps.yaml" -d -j

Esempio di configurazione:```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

Puoi sovrascrivere quasi tutte le impostazioni specificate nel file di configurazione fornendo i corrispondenti flag CLI:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor

Proxy applica tutte le impostazioni specificate in ~/gohpts.yaml ma avvia un server http su 127.0.0.1:6969 invece di 127.0.0.1:8080 e disabilita anche l'output colorato nei log.

Alcune impostazioni (ad es. proxy_chain e filtri dns) possono essere configurate solo tramite file.

La versione completa della configurazione è disponibile qui: example_gohpts.yaml

Per saperne di più sulle proxy chain visita Proxychains Github

Proxy trasparente

[Indietro]

Noto anche come proxy intercettante, proxy inline o proxy forzato, un proxy trasparente intercetta la normale comunicazione a livello applicativo senza richiedere alcuna configurazione speciale del client. I client non devono essere consapevoli dell'esistenza del proxy. Un proxy trasparente è normalmente posizionato tra il client e Internet, con il proxy che svolge alcune delle funzioni di un gateway o router

-- Da Wiki

Questa funzionalità è disponibile solo su sistemi Linux e Android (arm64) e richiede una configurazione aggiuntiva (iptables, ip route, ecc.)

Il flag -T address specifica l'indirizzo del server proxy trasparente

Esistono tre modalità redirect, tproxy e tlocal (come tproxy ma intercetta anche il traffico locale) che possono essere specificate con il flag -M

`redirect` (tramite NAT e SO_ORIGINAL_DST)

[Indietro]

In questa modalità il proxying avviene con la tabella nat di iptables e il target REDIRECT. L'host del pacchetto in entrata cambia nell'indirizzo del proxy trasparente redirect in esecuzione, ma contiene anche la destinazione originale che può essere recuperata con getsockopt(SO_ORIGINAL_DST)

Per eseguire GoHPTS in questa modalità si utilizza il flag -T con -M redirect

Esempio

[Indietro]```shell

run the proxy

gohpts -s 1080 -T 1090 -M redirect -d

I cannot translate this content because no text was provided. The INPUT section is empty.

Please send the actual Markdown chunk (chunk 43 of 241) that you want translated from English to Italian, and I will return only the translated text with all Markdown structure, code, paths, URLs, and technical identifiers preserved exactly as-is.```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf

Configura il tuo sistema operativo:```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 connessione:```shell
#traffic should be redirected via 127.0.0.1:1090
curl http://example.com

I apologize, but I don't see any content to translate in your message. You've provided the instructions and context (chunk 49 of 241, source language English, target language Italian), but the actual Markdown content that needs to be translated is missing.

Please provide the source text you'd like me to translate, and I'll return only the translated Markdown content following all the rules you've specified.```shell #traffic should be redirected via 127.0.0.1:8080 curl --proxy http://127.0.0.1:8080 http://example.com

Annulla tutto:```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

Configurazione automatica per la modalità `redirect`

[Indietro]

Per configurare automaticamente il tuo sistema, esegui il seguente comando:```shell sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto

Tieni presente che la configurazione automatica richiede `sudo` ed è molto generica, il che potrebbe non essere adatta alle tue esigenze.

Puoi facoltativamente specificare `-mark <value>` per prevenire possibili loop del proxy```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100

`tproxy` (tramite MANGLE e IP_TRANSPARENT)

[Indietro]

In questa modalità il proxying avviene con la tabella mangle di iptables e il target TPROXY. Il proxy trasparente vede l'indirizzo di destinazione così com'è, non viene riscritto dal kernel. Perché questo funzioni, il proxy si associa con l'opzione socket IP_TRANSPARENT, iptables intercetta il traffico usando il target TPROXY, le regole di routing indicano ai pacchetti marcati di andare al proxy locale senza modificare la loro destinazione originale.

Questa modalità richiede privilegi elevati per eseguire GoHPTS. Puoi farlo eseguendo il seguente comando:```shell sudo setcap 'cap_net_admin+ep' ~/go/bin/gohpts

Per eseguire `GoHPTS` in questa modalità si utilizza il flag `-T` con `-M tproxy`

### Esempio

[[Indietro]](#table-of-contents)```shell
# run the proxy
gohpts -s 1080 -T 0.0.0.0:1090 -M tproxy -d

run socks5 server on 127.0.0.1:1080

ssh remote -D 1080 -Nf

Configura il tuo sistema operativo:```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 connessione:```shell ip netns exec ns-client curl http://1.1.1.1

Annulla tutto:```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

Configurazione automatica per la modalità `tproxy`

[Indietro]

Per configurare automaticamente il tuo sistema, esegui il seguente comando (ad esempio, su una VM separata):```shell ssh remote -D 1080 -Nf sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -auto -mark 100

Esegui quanto segue sul tuo host:```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 connessione:```shell curl http://example.com #check logs on your VM

Annulla tutto:```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

Supporto UDP

[Indietro]

GoHPTS ha il supporto UDP che può essere abilitato nelle modalità tproxy e tlocal. Per far funzionare questa configurazione è necessario connettersi a un server socks5 in grado di servire connessioni UDP (UDP ASSOCIATE). Ad esempio, è possibile utilizzare https://github.com/wzshiming/socks5 per distribuire un server socks5 con supporto UDP su una macchina remota o locale. Una volta ottenuto il server a cui connettersi, eseguire il seguente comando:```shell sudo env PATH=$PATH gohpts -s remote -Tu :8989 -M tproxy -auto -mark 100 -d

Questo comando configurerà il tuo sistema operativo e imposterà il server sull'indirizzo `0.0.0.0:8989`.

Per testarlo localmente, puoi combinare il proxy trasparente UDP con il flag `-arpspoof`. Ad esempio:

1. Configura una VM sul tuo sistema con qualsiasi distribuzione Linux che supporti `tproxy` (Kali Linux, ad esempio).
2. Abilita la rete `bridged` in modo che la VM possa accedere alla tua macchina host.
3. Sposta il binario `gohpts` sulla VM (tramite `ssh`, ad esempio) o compilalo lì nel caso di OS/arch diversi.
4. Sulla tua VM esegui il seguente comando:```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"

Verifica la connessione sulla tua macchina host, il traffico dovrebbe passare attraverso la macchina Kali.

Supporto Android

[Indietro]

Il proxy trasparente può essere abilitato sui dispositivi Android (arm64) con accesso root. Puoi installare Termux ed eseguire GoHPTS come strumento CLI lì:```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"

### Configurazione YAML

[[Indietro]](#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

Traffic sniffing

[Back]

MrGopher

Il proxy GoHPTS consente di catturare e monitorare il traffico che passa attraverso il servizio. Questo processo è noto come traffic sniffing, packet sniffing o semplicemente sniffing. In particolare, il proxy cerca di identificare se si tratta di traffico in chiaro (HTTP) o TLS, e una volta completata l'identificazione, analizza i metadati di richiesta/risposta e li scrive su file o console. Nel caso del proxy GoHTPS, i metadati analizzati appaiono come segue (TLS Handshake):

Formato JSON

[Back]```json [ { "connection": { "tproxy_mode": "redirect", "src_local": "127.0.0.1:8888", "src_remote": "192.168.0.107:51142", "dst_local": "127.0.0.1:56256", "dst_remote": "127.0.0.1:1080", "original_dst": "216.58.209.206:443" } }, { "tls_request": { "sni": "www.youtube.com", "type": "Client hello (1)", "version": "TLS 1.2 (0x0303)", "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39", "cipher_suites": [ "TLS_AES_128_GCM_SHA256 (0x1301)", "TLS_CHACHA20_POLY1305_SHA256 (0x1303)", "TLS_AES_256_GCM_SHA384 (0x1302)", "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 (0xc02b)", "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (0xc02f)", "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 (0xcca9)", "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 (0xcca8)", "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 (0xc02c)", "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (0xc030)", "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (0xc00a)", "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (0xc009)", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (0xc013)", "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (0xc014)", "TLS_RSA_WITH_AES_128_GCM_SHA256 (0x9c)", "TLS_RSA_WITH_AES_256_GCM_SHA384 (0x9d)", "TLS_RSA_WITH_AES_128_CBC_SHA (0x2f)", "TLS_RSA_WITH_AES_256_CBC_SHA (0x35)" ], "extensions": [ "server_name (0)", "extended_master_secret (23)", "renegotiation_info (65281)", "supported_groups (10)", "ec_point_formats (11)", "session_ticket (35)", "application_layer_protocol_negotiation (16)", "status_request (5)", "delegated_credential (34)", "signed_certificate_timestamp (18)", "key_share (51)", "supported_versions (43)", "signature_algorithms (13)", "psk_key_exchange_modes (45)", "record_size_limit (28)", "compress_certificate (27)", "encrypted_client_hello (65037)" ], "alpn": ["h2", "http/1.1"] } }, { "tls_response": { "type": "Server hello (2)", "version": "TLS 1.2 (0x0303)", "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39", "cipher_suite": "TLS_AES_128_GCM_SHA256 (0x1301)", "extensions": ["key_share (51)", "supported_versions (43)"], "supported_version": "TLS 1.3 (0x0304)" } } ]

E richiesta HTTP con 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"]
      }
    }
  }
]

Utilizzo semplice come specificare il flag -sniff insieme ai flag regolari```shell gohpts -d -T 8888 -M redirect -sniff -j

Puoi anche specificare un file in cui scrivere il traffico intercettato:```shell
gohpts -sniff -snifflog ~/sniff.log -j

Formato colorato

[Indietro]

Puoi vedere l'esempio di output colorato nell'immagine sopra. In questa modalità, GoHPTS cerca di evidenziare le informazioni importanti come TLS Handshake, metadati HTTP, qualcosa che assomiglia a login/password o diversi tipi di autenticazione e token segreti. L'output è limitato rispetto a JSON ma molto più facile da leggere per gli esseri umani.

Per eseguire GoHPTS in questa modalità si utilizzano i seguenti flag:```shell gohpts -sniff -body

Puoi combinare lo sniffing con la modalità trasparente:```shell
./gohpts -T 8888 -M redirect -sniff -body

Per disabilitare i colori aggiungi -nocolor:```shell gohpts -sniff -body -nocolor

## Supporto HTTP2 e HTTP3

[[Indietro]](#table-of-contents)

Il proxy `GoHPTS` gestisce richieste HTTP/1.1, HTTP/2 e HTTP/3 utilizzando lo stesso indirizzo server e certificato TLS. Ciò consente ai client di scegliere automaticamente il protocollo migliore disponibile senza modificare la configurazione. Il certificato TLS può essere ottenuto in diversi modi: provider cloud (Google, AWS, Cloudflare), certificato gratuito da Let's Encrypt, oppure è possibile creare un certificato self-signed utilizzando `openssl` (Linux/macOS) o `New-SelfSignedCertificate` (Windows).

### Configurazione di esempio con certificato self-signed

[[Indietro]](#table-of-contents)

- Creare i file `key.pem` e `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"

Preparare un server socks5 con supporto 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
Apri un altro terminale e installa il proxy GoHPTS: ```shell go install github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest

Puoi usare altri metodi descritti nella sezione Installation.

Infine:
1. Crea una configurazione minima per il tuo 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

Esegui il proxy: ```shell gohpts -f ./gohpts_config.yaml

2. Oppure, se preferisci gli argomenti da riga di comando:  ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body

Dovresti vedere qualcosa del genere: ```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

### Test connessione

[[Indietro]](#table-of-contents)

- Per un server proxy HTTP/2 puoi usare `curl`:  ```shell
  curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://localhost:8080 "https://stream.wikimedia.org/v2/stream/recentchange"

Premi Ctrl+C per interrompere lo stream in esecuzione.

Per HTTP/3 è diverso poiché (al momento della scrittura) curl non supporta il proxy HTTP3, quindi utilizzerò il mio client personalizzato che ho creato per scopi di test.

Scarica e installa Simple HTTP3 to SOCKS5 proxy example: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make

Esegui il seguente comando: ```shell ./bin/client -a 127.0.0.1:8080 www.google.com

Dovresti vedere una serie di caratteri senza senso che assomiglia a una pagina HTML.

Vai alla scheda del terminale con il proxy `GoHPTS` e controlla i log, dovresti vedere tutte le tue richieste lì.

### Testare la connessione in un browser

[[Indietro]](#table-of-contents)

- Crea un certificato self-signed adatto per il browser:  ```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

Ulteriori informazioni sono disponibili qui: Creating a browser trusted, self signed, SSL certificate

Aggiungi il rootCA.crt appena creato al trust store di sistema:
1. Debian/Ubuntu: ```shell sudo cp rootCA.crt /usr/local/share/ca-certificates/rootCA.crt sudo update-ca-certificates

Arch Linux/CachyOS/EndeavourOS: ```shell sudo trust anchor rootCA.crt

- Esegui il proxy utilizzando `server.crt` e `server.key`:  ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body

Avvia il browser e vai su qualsiasi sito web: ```shell chromium --proxy-server="https://127.0.0.1:8080"

Supporto IPv4 e IPv6

[Indietro]

Per quanto riguarda la gestione del livello di rete, GoHPTS può operare in tre modalità: dual stack, IPv4-only e IPv6-only. L'utente può controllare la modalità specificando i flag -4 e -6. Quando uno dei flag è impostato, il proxy si avvia nella modalità corrispondente; quando entrambi i flag sono presenti o entrambi omessi, viene assunta la modalità dual stack. Si noti che nelle modalità "only" sono consentiti solo indirizzi IP della versione specifica, tutti i domini vengono risolti alla versione IP specifica (se possibile), tutti gli indirizzi di ascolto richiedono l'uso della stessa versione, ecc.

Per abilitare la modalità IPv4-only è sufficiente aggiungere il flag -4:```shell sudo ./gohpts -sniff -body -d -4

Per testare il proxy in modalità IPv4 puoi usare qualsiasi VM Linux:

1. Sulla tua macchina virtuale:```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"

Sul tuo host:```shell

run proxy on your host

sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -4

3. Visita qualsiasi sito web sulla tua macchina virtuale e osserva il traffico nei log del proxy

Per abilitare la modalità `IPv6-only` basta aggiungere il flag `-6`, ad esempio quando si utilizza con un proxy trasparente:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6

Perché questo funzioni, il tuo ISP e il proxy socks5 remoto devono avere il supporto IPv6 attivo; puoi visitare https://test-ipv6.com/ per verificare se puoi accedere agli indirizzi IPv6. Per testare il proxy in modalità IPv6 puoi usare qualsiasi VM Linux:

Sulla tua macchina virtuale:```shell

add your host machine as gateway IPv6 for VM

export GATEWAY6="" ip -6 route add ::/1 via "$GATEWAY6" dev eth0 ip -6 route add 8000::/1 via "$GATEWAY6" dev eth0

2. Sul tuo host:```shell
# run proxy on your host
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -6

Visita qualsiasi sito web sulla tua macchina virtuale e osserva il traffico nei log del proxy

ARP spoofing

[Indietro]

GoHPTS dispone di un ARP spoofer integrato che può essere utilizzato per far sì che tutti i dispositivi TCP della tua LAN utilizzino il server proxy per connettersi a Internet. Ciò si ottiene aggiungendo il flag -arpspoof con un paio di parametri, separati da punto e virgola.

Esempio:```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"

Il proxy eseguirà la scansione dei dispositivi nella sottorete `192.168.10.0/24` e invierà loro pacchetti ARP per fingersi un gateway; se `fullduplex` è true,
il proxy invierà pacchetti ARP anche al gateway per fargli credere che il nostro proxy possieda ogni IP della sottorete.

Dopo che il proxy è stato arrestato con `Ctrl+C`, annullerà automaticamente lo spoofing di tutti i target.

`GoHPTS` può anche essere usato con strumenti come [Bettercap](https://github.com/bettercap/bettercap) per fare da proxy al traffico con ARP spoofing.

Avvia il proxy:```shell
ssh remote -D 1080 -Nf
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100

Esegui bettercap con questo comando (vedi documentazione):```shell sudo bettercap -eval "net.probe on;net.recon on;set arp.spoof.fullduplex true;arp.spoof on"

Controlla i log del proxy per il traffico proveniente da altri dispositivi della tua LAN

Per maggiori informazioni sulle opzioni di arpspoof vedi `gohpts -h` e [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)

## NDP spoofing

[[Indietro]](#table-of-contents)

`GoHPTS` ha una funzionalità integrata per eseguire lo spoofing NDP nelle reti IPv6 con pacchetti Router Advertisement (RA) e Neighbor Advertisement (NA). Include anche l'opzione RDNSS nei pacchetti RA per impostare l'host come nameserver IPv6 per i client interessati. Se combinato con la modalità proxy trasparente (TCP/UDP), lo spoofing NDP consente a `gohpts` di fare da proxy per il traffico dei client nelle reti locali. Come nel caso dello [spoofing ARP](#arp-spoofing), puoi impostare le opzioni di spoofing ndp con il singolo flag `-ndpspoof`:

Esempio:```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"

Per maggiori informazioni sulle opzioni di ndpspoof vedere gohpts -h e https://github.com/shadowy-pycoder/ndpspoof

Si noti che alcune opzioni come rdnss, gateway, interface sono impostate automaticamente da gohpts stesso per funzionare correttamente come proxy.

Poiché gohpts inoltra tutte le connessioni tramite un server SOCKS5 upstream, è necessario disporre di un server funzionante con supporto IPv4/IPv6 e TCP/UDP. Ovviamente, una macchina remota (ad es. un VPS) dovrebbe anche avere la connettività IPv6 funzionante. Inutile dire che la macchina su cui si trova gohpts dovrebbe far parte di una rete con supporto IPv6.

Configurazione di esempio per il corretto funzionamento dello spoofing NDP:

Connettersi al VPS```shell ssh [email protected]

2. Installa le dipendenze```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

Configurare il server SOCKS5 (assicurarsi che le regole del firewall non blocchino le porte utilizzate)```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. Torna alla tua macchina host e installa `gohpts` (vedi [Installation](#installation))

5. Esegui `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

Prendi un altro dispositivo (telefono, tablet, ecc.) e collegalo alla stessa rete. Prova ad accedere a Internet e verifica se compare del traffico sulla tua macchina host. Controlla l'indirizzo IP pubblico con alcuni strumenti online (dovrebbe corrispondere all'indirizzo del tuo VPS 203.0.113.10 in questo caso o all'indirizzo IPv6 globale)
Interrompi il proxy premendo Ctrl+C
Profit!

DNS spoofing

[Back]

Per applicare i filtri DNS e falsificare i target modificando i record DNS, l'host che esegue GoHPTS dovrebbe diventare il gateway predefinito per i dispositivi della LAN. Per farlo funzionare, è sufficiente eseguire il proxy trasparente con udp abilitato e anche eseguire lo spoofing ARP/NDP per far usare ai target il tuo server DNS.

Le risposte DNS create da GoHPTS appaiono come normali pacchetti provenienti dal router o da server DNS attendibili (Google, Cloudflare), il che porta i client ad aggiornare la loro cache con ciò che gli viene comunicato. Tieni presente, tuttavia, che funziona solo per il traffico DNS "standard" non crittografato (DOT/DOH non filtrati o falsificati).

I filtri DNS e i domini per lo spoofing possono essere configurati nella sezione dns_filter del file di configurazione yaml. Tutte le liste accettano URL, percorsi di file e voci simili a quelle solitamente presenti nel file hosts, vedi https://en.wikipedia.org/wiki/Hosts_(file)>).

Esempio:```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

Casi d'uso:

- Blocco di annunci e tracker per tutti i dispositivi LAN
- Controllo parentale tramite il blocco di categorie specifiche di siti web
- Blocco di domini noti di phishing e malware
- Reindirizzamento del traffico per analisi
- Raccolta di credenziali tramite reindirizzamento
- Hijacking e manipolazione del traffico (iniezione di annunci, script, tracciamento)
- Sorveglianza e profilazione

Configurazione minima per questa configurazione:```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"]

Esegui:```shell sudo ./gohpts -f ./gohpts_dns_spoof.yaml

Maggiori informazioni sono disponibili qui: [https://en.wikipedia.org/wiki/DNS_spoofing](https://en.wikipedia.org/wiki/DNS_spoofing)

## Packet Capture

[[Back]](#table-of-contents)

Il traffico può essere catturato nei formati pcap, pcapng o txt personalizzato e successivamente analizzato con strumenti come Wireshark, tcpdump e molti altri.

Per prima cosa, assicurati che l'eseguibile `GoHPTS` abbia privilegi elevati per poter catturare pacchetti raw; hai due opzioni:

- Esegui `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` una volta per concedere al proxy l'accesso al traffico raw
- Esegui il proxy con `sudo` quando devi specificare il flag `-pcap` nella CLI o `pcap.enabled` nella configurazione del file.

Configura il proxy usando la CLI:```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"

File di configurazione:```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"

Questi comandi producono tre file di cattura dei pacchetti con i formati corrispondenti che in seguito possono essere analizzati da vari strumenti.

Per maggiori informazioni sulle opzioni pcap vedere `gohpts -h` e [https://github.com/shadowy-pycoder/mshark](https://github.com/shadowy-pycoder/mshark)

## Network Namespaces

[[Back]](#table-of-contents)

Per impostazione predefinita il proxy `GoHPTS` viene eseguito all'interno di un singolo network namespace, ma questo può essere sovrascritto. I socket in ascolto (ad esempio il server http o il server proxy trasparente) e i socket in uscita (proxy socks o dialer diretto) creati da `GoHPTS` possono essere isolati con i [network_namespaces (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html) di Linux/Android. All'avvio del processo proxy, gli utenti possono specificare i flag `-in-netns` (listener) e `-out-netns` (dialer) con il nome o il percorso del network namespace per controllare in quale ambiente isolato creare i socket. Se si desidera creare listener o dialer nel namespace corrente (predefinito), è sufficiente omettere il flag. Per specificare esplicitamente il namespace host è possibile usare il percorso `/proc/1/ns/net` - questo permette al proxy di identificare correttamente i nameserver di sistema.

`GoHPTS` supporta la convenzione [ip-netns (8)](https://man7.org/linux/man-pages/man8/ip-netns.8.html) per fornire la configurazione di rete tramite file situati nella directory `/etc/netns/NAME/`. Quindi, per specificare nameserver personalizzati per il network namespace `ns1` si fa quanto segue:```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

Se non viene trovata alcuna configurazione, verranno utilizzati i server DNS di Google per risolvere i nomi di dominio.

Se il tuo sistema ha systemd-resolved.service (8) abilitato, potresti volerlo disabilitare temporaneamente quando esegui query tramite namespace di rete personalizzati:```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'

Oppure rendilo persistente per una specifica istanza della shell:```shell
sudo ip netns exec ns1 unshare --mount bash -c '
    mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve
    exec bash --login'

Configurazione del playground

[Indietro]

Esegui un server socks5 con supporto 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
Scarica e installa Simple HTTP3 to SOCKS5 proxy example: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git cd http3-socks-proxy make
Clonare il repository e compilare ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make
Creare i file key.pem e 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"
Creare un network namespace ns1 e configurare la rete 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
Determinare l'indirizzo IP di wlan0 per potersi connettere al socks5 locale ```shell WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')

Esempi di utilizzo

[Indietro]

Proxy HTTP - listener proxy in ns1 (nessuna route predefinita, nessun accesso a Internet), socket in uscita sull'host

Esegui il proxy: ```shell sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1

Effettua la richiesta tramite ns1 ```shell sudo ip netns exec ns1 curl -Nv --proxy http://127.0.0.1:8083 https://example.com

La richiesta dovrebbe avere successo

2. **Proxy HTTP2 - listener proxy in `ns1` (nessuna route predefinita, nessun accesso a Internet), socket in uscita sull'host**

Esegui il 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

Effettua la richiesta tramite 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 richiesta dovrebbe avere successo

3. **Proxy HTTP3 - listener proxy in `ns1` (nessuna route predefinita, nessun accesso a Internet), socket in uscita sull'host**

Avvia il 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

Effettua la richiesta tramite ns1 ```shell sudo ip netns exec ns1 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com

La richiesta dovrebbe avere successo

4. **Proxy trasparente di reindirizzamento (`-M redirect`) - listener proxy in `ns1` (route predefinita, nessun accesso a internet), socket in uscita sull'host**

Esegui il 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

Effettua la richiesta tramite ns1 ```shell sudo ip netns exec ns1 curl -Nv https://example.com

La richiesta dovrebbe fallire

Aggiungi la route predefinita a `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

Riprova ```shell sudo ip netns exec ns1 curl -Nv https://example.com

Ora la richiesta dovrebbe avere successo

5. **Proxy HTTP - listener proxy sull'host, socket in uscita in `ns1` (route predefinita, accesso a Internet)**

Aggiungi regole NAT per consentire a `ns1` di connettersi a Internet tramite `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

Esegui proxy: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0

Effettua la richiesta tramite host   ```shell
curl -Nv --proxy http://$WLAN_IP:8083 https://example.com

La richiesta dovrebbe avere successo

Proxy HTTP3 - listener proxy sull'host, socket in uscita in ns1 (route predefinita, accesso a Internet)

Esegui il proxy: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0 -c ./cert.pem -k ./key.pem

Effettua la richiesta tramite host ```shell ./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com

La richiesta dovrebbe avere successo

7. **Proxy trasparente con reindirizzamento - listener proxy sull'host, socket in uscita in `ns1` (rotta predefinita, accesso a Internet)**

Esegui il proxy (`-auto` non funziona con il server socks5 locale nel mio caso, quindi uso quello remoto):   ```
sudo ./bin/gohpts -s <remote> -4 -6 -d -sniff -body -out-netns ns1 -nohttp -M redirect -T :8888 -auto

Effettua la richiesta tramite host ```shell curl -Nv https://example.com

La richiesta dovrebbe avere successo

8. **Proxy HTTP - LAN (`ns2` (listener proxy), `ns3`, `ns4`), socket in uscita in `ns1` (route predefinita, accesso a Internet)**

Crea 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

Esegui 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

Effettua richieste   ```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

Tutte le richieste dovrebbero avere successo

Proxy HTTP3 - LAN (ns2 (listener del proxy), ns3, ns4), socket in uscita in ns1 (route predefinita, accesso a Internet)

Esegui il 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

Effettua richieste ```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

Tutte le richieste dovrebbero avere successo

10. **Proxy trasparente con redirect - LAN (`ns2` (listener del proxy), `ns3`, `ns4`), socket in uscita in `ns1` (route predefinita, accesso a internet)**

 Avvia il 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
 ```

 Effettua le richieste

 ```shell
 sudo ip netns exec ns2 curl -Nv https://example.com
 ```

 Per `ns3` e `ns4` la richiesta fallisce

11. **Proxy trasparente con `IP_TRANSPARENT` (arp/ndp spoofing abilitato) LAN (`ns2` (listener del proxy), `ns3`, `ns4`), socket in uscita in `ns1` (route predefinita, accesso a internet)**

 Avvia il 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"
 ```

 Ora le richieste precedenti su `ns3` e `ns4` dovrebbero funzionare

 ```
 sudo ip netns exec ns3 curl -Nv https://example.com
 sudo ip netns exec ns4 curl -Nv https://example.com
 ```

12. **Proxy HTTP3 - listener del proxy in `ns1`, socket in uscita sull'host, flag `-nosocks`**

 Avvia il 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
 ```

 Effettua la richiesta

 ```shell
 ./http3-socks-proxy/bin/client -a 10.0.0.2:8083 www.google.com
 ```

 La richiesta dovrebbe avere successo

13. **Proxy HTTP3 - listener del proxy sull'host, socket in uscita in `ns1`, flag `-nosocks`**

 Avvia il 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
 ```

 Effettua la richiesta

 ```shell
 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
 ```

 La richiesta dovrebbe fallire

 Aggiungi regole alla catena `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
 ```

 Effettua la richiesta

 ```shell
 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
 ```

 La richiesta dovrebbe avere successo

## Server misto

[[Indietro]](#table-of-contents)

`GoHPTS` può essere configurato per ascoltare connessioni SOCKS sullo stesso indirizzo del server HTTP, basta aggiungere il flag `-mixed` per avviare un server SOCKS aggiuntivo. Questo permette a `GoHPTS` di agire non solo come proxy `HTTP-to-SOCKS` ma anche come proxy `SOCKS-to-SOCKS`. Il server SOCKS5 locale supporta il comando `UDP ASSOCIATE`, quindi tecnicamente gli utenti possono inviare datagrammi UDP con questo server misto.

Avvia il proxy:```shell
gohpts -s :1080 -l :8080 -mixed

Test connessione:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"

Oppure disabilita il proxy SOCKS upstream e connettiti direttamente aggiungendo `-nosocks`:```shell
gohpts -l :8080 -mixed -nosocks

Test connessione:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"

Aggiungi il flag `-socks4` per utilizzare invece il protocollo SOCKS4:```shell
# :1080 should be a socks4 server
gohpts -s :1080 -l :8080 -mixed -socks4

Test connessione:```shell curl -Nv --proxy socks4://127.0.0.1:8080 "https://example.com"

## Link

[[Indietro]](#table-of-contents)

Scopri di più sui proxy trasparenti visitando i seguenti link:

- [Supporto proxy trasparente nel Kernel Linux](https://docs.kernel.org/networking/tproxy.html)
- [Tutorial sul proxy trasparente di Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Esempio semplice di tproxy](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Implementazione di un proxy trasparente con eBPF e 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` con supporto `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)

Sicurezza di rete 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/)

## Contribuire

[[Indietro]](#table-of-contents)

Sei uno sviluppatore?

- Fai un fork del repository
- Crea il tuo branch per la funzionalità: `git switch -c my-new-feature`
- Esegui il commit delle tue modifiche: `git commit -am 'Add some feature'`
- Fai il push sul branch: `git push origin my-new-feature`
- Invia una pull request

## Licenza

[[Indietro]](#table-of-contents)

GPLv3

go-http-proxy-to-socks v1.15.6

Categorie

go-http-proxy-to-socks v1.15.6

GoHPTS - Proxy trasparente HTTP(S) e TCP/UDP verso proxy SOCKS4/SOCKS5 (catena) scritto in Go

Indice

Introduzione

Funzionalità

Installazione

Utilizzo

kill the process

bind proxy to specific network interface (either by interface name or index)

if ipv4 and ipv6 are both false or both true, dual stack is assumed

username and password for adding basic authentication (comment out to disable auth)

list of socks5 proxy

if proxy_chain is disabled, uses first server in a list as upstream

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.

defaults to standard output

use colored output in logs (no effect if json enabled)

profiling data

Proxy trasparente

redirect (tramite NAT e SO_ORIGINAL_DST)

Esempio

run the proxy

commands below require elevated privileges (you can run it with sudo -i)

create GOHPTS nat chain

set no redirection rules for local, http proxy, ssh and redirect proxy itself

redirect traffic to transparent proxy

setup prerouting by adding our proxy

intercept local traffic for testing

Configurazione automatica per la modalità redirect

tproxy (tramite MANGLE e IP_TRANSPARENT)

run socks5 server on 127.0.0.1:1080

Configurazione automatica per la modalità tproxy

Supporto UDP

Supporto Android

you need to root your device first

Android support added in v1.10.2

use your phone as router for LAN devices redirecting their traffic to remote socks5 server

Traffic sniffing

Formato JSON

Formato colorato

gohpts_config.yaml

Supporto IPv4 e IPv6

run proxy on your host

add your host machine as gateway IPv6 for VM

ARP spoofing

DNS spoofing

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

Configurazione del playground

Esempi di utilizzo

Categorie

`redirect` (tramite NAT e SO_ORIGINAL_DST)

commands below require elevated privileges (you can run it with `sudo -i`)

create `GOHPTS` nat chain

Configurazione automatica per la modalità `redirect`

`tproxy` (tramite MANGLE e IP_TRANSPARENT)

Configurazione automatica per la modalità `tproxy`