shadowy-pycoder/go-http-proxy-to-socksCLI-MITM-Proxy, der SOCKS4/SOCKS5 in HTTP/HTTPS/HTTP2/HTTP3-Proxy mit transparenter TCP/UDP-Umleitung, ARP/NDP/DNS-Spoofing, Traffic-Sniffing und Paketerfassung umwandelt. Reines Go, kein libpcap.
Das CLI-Tool GoHPTS ist eine Brücke zwischen HTTP-Clients und einem SOCKS5-Proxy-Server oder mehreren Servern (Kette). Es lauscht lokal als HTTP-Proxy, nimmt standardmäßige HTTP- oder HTTPS-Anfragen (über CONNECT) entgegen und leitet die Verbindung über einen SOCKS5-Proxy weiter. Inspiriert von http-proxy-to-socks und Proxychains
Möglicher Anwendungsfall: Sie müssen über Postman eine Verbindung zu einer externen API herstellen, diese API ist jedoch nur über einen entfernten Server verfügbar. Die folgenden Befehle helfen Ihnen, eine solche Aufgabe auszuführen:
SOCKS5-Proxy-Server über ssh erstellen:```shell
ssh -D 1080 -Nf
HTTP-zu-SOCKS5-Verbindung mit `gohpts` erstellen```shell
gohpts -s :1080 -l :8080
Specify http server in proxy configuration of Postman
Proxy-Chain-Funktionalität
Unterstützt strict, dynamic, random, round_robin Ketten von SOCKS4/SOCKS5-Proxys
Transparenter Proxy
Unterstützt redirect (SO_ORIGINAL_DST) und tproxy (IP_TRANSPARENT) Modi
IPv4- und IPv6-Unterstützung
Funktioniert in den Modi IPv4-only, IPv6-only oder dual stack
Transparenter Proxy für TCP und UDP
tproxy und tlocal (IP_TRANSPARENT) verarbeiten TCP- und UDP-Verkehr
Datenverkehrssniffing
Der Proxy kann HTTP-Header, TLS-Handshake, DNS-Nachrichten und mehr analysieren
ARP-Spoofing
Gesamte Subnetze mittels ARP-Spoofing proxieren
Oder mit paru: ```shell
paru -S gohpts
- Laden Sie die Binärdatei für Ihre Plattform von der Seite [Releases](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases) herunter: ```shell
GOHPTS_RELEASE=v1.15.5; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-linux-amd64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-linux-amd64 gohpts && ./gohpts -h
go install Befehl (erfordert Go 1.26 oder neuer): ```shell
CGO_ENABLED=0 go install -ldflags "-s -w" -trimpath github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Dies wird die gohpts-Binärdatei in Ihr $GOPATH/bin-Verzeichnis installieren.
[Zurück]```shell gohpts -h
/ | | | | | __ _ / ____|
| | __ ___ | || | |) | | | | (__
| | |_ |/ _ | __ | / | | _
| |__| | () | | | | | | | ) |
_|_/|| ||| || |___/
GoHPTS: HTTP(S) Proxy to SOCKS4/SOCKS5 proxy by shadowy-pycoder GitHub: https://github.com/shadowy-pycoder/go-http-proxy-to-socks Codeberg: https://codeberg.org/shadowy-pycoder/go-http-proxy-to-socks
Usage: gohpts [OPTIONS] OPTIONS: General: -h Show this help message and exit -v Show version and build information -D Run as a daemon (provide -logfile to see logs) -I Display list of network interfaces and exit -f Path to proxy configuration file in YAML format
Proxy: -l Address of HTTP proxy server (Default: "127.0.0.1:8080" for IPv4, "[::1]:8080" for IPv6) -s Address of SOCKS proxy server (Default: "127.0.0.1:1080" for IPv4 "[::1]:1080" for IPv6) -c Path to certificate PEM encoded file -k Path to private key PEM encoded file -U User for HTTP proxy (basic auth). This flag invokes prompt for password (not echoed to terminal) -u User for SOCKS proxy authentication. This flag invokes prompt for password (not echoed to terminal) -i Bind proxy to specific network interface (either by interface name or index) -4 Force IPv4 stack for TCP and UDP (Default: dual stack) -6 Force IPv6 stack for TCP and UDP (Default: dual stack) -socks4 Use SOCKS4/SOCKS4a protocol for upstream proxy and mixed server (default: SOCKS5/SOCKS5h) -nohttp Disable HTTP proxy server -nosocks Disable SOCKS upstream proxy -dns Use custom DNS server (Example: "8.8.8.8" or "2001:4860:4860::8888") -mixed Accept SOCKS connections on HTTP proxy server address
Logs: -d Show logs in DEBUG mode -j Show logs in JSON format -logfile Log file path (Default: stdout) -nocolor Disable colored output for logs (no effect if -j flag specified) -pprof Address of pprof server with profiling data
Sniffing: -sniff Enable traffic sniffing for HTTP and TLS -snifflog Sniffed traffic log file path (Default: the same as -logfile) -body Collect request and response body for HTTP traffic (credentials, tokens, etc)
TProxy: -T Address of transparent proxy server -Tu Address of transparent UDP proxy server -M Transparent proxy mode: (redirect, tproxy, tlocal) -w Number of instances of transparent proxy server (Default: number of CPU cores) -wu Number of instances of transparent UDP proxy server (Default: number of CPU cores) -auto Automatically setup iptables and kernel parameters for transparent proxy (requires elevated privileges) -mark Set mark for each packet sent through transparent proxy (Default: redirect 0, tproxy 100, tlocal 100) -P Comma separated list of ports to ignore when proxying traffic (Example: "22,80,443,9092") -dump Dump iptables rules and other system settings generated by -auto flag
Spoofing: -arpspoof Enable ARP spoof proxy for selected targets (Example: "targets 10.0.0.1,10.0.0.5-10,192.168.1.*,192.168.10.0/24;fullduplex false;debug true;interval 10s") -ndpspoof Enable NDP spoof proxy for selected targets (Example: "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true;interval 10s")
Packet Capture: -pcap Enable packet capture (Example: "promisc true;expr ip proto tcp;snaplen 65535;timeout 10s;packet_count 100;packet_buffer 8192;exts txt,pcap,pcapng")
Namespaces: -in-netns Name or path of network namespace for inbound listeners (Default: default namespace) -out-netns Name or path of network namespace for outbound connections (Default: default namespace)
### Konfiguration über CLI-Flags
[[Zurück]](#table-of-contents)```shell
gohpts -s 1080 -l 8080 -d -j
Ausgabe:```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"}
Benutzername und Passwort für den SOCKS5-Proxy-Server angeben:```shell
gohpts -s 1080 -l 8080 -d -j -u user
SOCKS5 Password: #you will be prompted for password input here
Benutzername und Passwort für den HTTP-Proxyserver angeben:```shell gohpts -s 1080 -l 8080 -d -j -U user HTTP Password: #you will be prompted for password input here
Wenn sowohl `-u` als auch `-U` vorhanden sind, werden Sie zweimal zur Eingabe aufgefordert
HTTP-Proxy über TLS-Verbindung ausführen```shell
gohpts -s 1080 -l 8080 -c "path/to/certificate" -k "path/to/private/key"
Führen Sie den Proxy als Daemon aus (eine Logdatei wird für die Protokollausgabe benötigt, sonst sehen Sie nichts)```shell gohpts -D -logfile /tmp/gohpts.log
INPUT:```shell
# output
gohpts pid: <pid>
kill #or kill $(pidof gohpts)
`-u` und `-U` funktionieren im Daemon-Modus nicht (und daher auch keine Authentifizierung), aber Sie können eine Konfigurationsdatei bereitstellen (siehe unten)
### Konfiguration über YAML-Datei
[[Zurück]](#table-of-contents)
Konfigurationsdateien sind nützlich, wenn Sie Ihren Proxy vorkonfigurieren möchten, ohne zu sehr mit der CLI herumspielen zu müssen, oder einfach mehrere Profile für verschiedene Anforderungen haben möchten.
HTTP-Proxy im SOCKS5-Proxy-Chain-Modus ausführen (Server-Einstellungen über YAML-Konfigurationsdatei angeben)```shell
gohpts -f "~/gohtps.yaml" -d -j
Konfigurationsbeispiel:```yaml
interface: "eth0" # if specified, overrides http server IP address disable_http: false # disable http proxy (default: false) disable_socks: false # disable upstream socks proxy (default: false)
ipv4: false # this must be enabled for arpspoof (default: false) ipv6: false # this must be enabled for ndpspoof (default: false) socks4: false # use SOCKS4/SOCKS4a protocol (tcp only protocol, no udp tproxy or http3 possible) (default: false) dns: 8.8.8.8 # custom DNS server (used in direct dialer, namespaces, spoofing)
http_server: address: 127.0.0.1:8080
username: username password: password
proxy_list:
proxy_chain: enabled: false
type: strict # dynamic, strict, random, round_robin length: 2 # maximum number of proxy in a chain (works only for random chain and round_robin chain)
logging: debug: true json: false
#logfile: /tmp/gohpts.log
nocolor: false
pprof: 127.0.0.1:8081
Sie können fast alle Einstellungen, die in der Konfigurationsdatei angegeben sind, durch die entsprechenden CLI flags überschreiben:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor
Proxy übernimmt alle Einstellungen, die in ~/gohpts.yaml festgelegt sind, startet jedoch einen HTTP-Server auf 127.0.0.1:6969 anstelle von 127.0.0.1:8080 und deaktiviert außerdem die farbige Ausgabe in den Logs.
Einige Einstellungen (z. B. proxy_chain und DNS-Filter) können nur über eine Datei konfiguriert werden.
Die vollständige Version der Konfiguration finden Sie hier: example_gohpts.yaml
Weitere Informationen zu Proxy-Ketten finden Sie auf Proxychains Github
Auch bekannt als
intercepting proxy,inline proxyoderforced proxy, fängt ein transparenter Proxy die normale Kommunikation auf Anwendungsebene ab, ohne dass eine spezielle Client-Konfiguration erforderlich ist. Clients müssen nicht über die Existenz des Proxys informiert sein. Ein transparenter Proxy befindet sich normalerweise zwischen dem Client und dem Internet, wobei der Proxy einige der Funktionen eines Gateways oder Routers übernimmt.-- Aus Wiki
Diese Funktion ist nur unter Linux-Systemen und Android (arm64) verfügbar und erfordert zusätzliche Einrichtung (iptables, IP-Route usw.)
Das -T address-Flag gibt die Adresse des transparenten Proxyservers an.
Es gibt drei Modi: redirect, tproxy und tlocal (wie tproxy, fängt aber auch lokalen Datenverkehr ab), die mit dem Flag -M angegeben werden können.
redirect (über NAT und SO_ORIGINAL_DST)In diesem Modus erfolgt das Proxying mit der iptables-nat-Tabelle und dem REDIRECT-Ziel. Die Adresse des eingehenden Pakets wird auf die Adresse des laufenden redirect-transparenten Proxys geändert, aber es enthält auch das ursprüngliche Ziel, das mit getsockopt(SO_ORIGINAL_DST) abgerufen werden kann.
Um GoHPTS in diesem Modus auszuführen, verwenden Sie das Flag -T mit -M redirect
[Back]```shell
gohpts -s 1080 -T 1090 -M redirect -d
---
### 🏆 Funktionen
- 🌐 **Webbasiert** – Funktioniert direkt im Browser über [Bash Web Hosting](https://bash.ws/) (keine Installation erforderlich).
- 🛍️ **Quellcode verfügbar** – Vollständig quelloffen unter der [MIT-Lizenz](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/HEAD/LICENSE).
- 🐧 **Linux & macOS** – Kompatibel mit `bash`, `zsh` und standardmäßigen Befehlszeilenwerkzeugen.
- ⚙️ **Anpassbar** – Funktionen nach Bedarf ändern oder erweitern.
- 📡 **Verfügbare Endpunkte**:
- `https://bash.ws/id` – Neue Tracking-ID abrufen.
- `https://bash.ws/dns/<id>` – Gibt ein Tracking-Pixel zurück (1x1 transparentes GIF).
- `https://bash.ws/code` – Zeigt den Payload-Code (Inhalt dieses Repositorys) an.
- 🔒 **Verschlüsselte ID-Übertragung** – Tracking-IDs werden in der Abfragezeichenfolge gesendet (HTTPS).```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf
Richten Sie Ihr Betriebssystem ein:```shell
sudo -i)#enable ip forwarding sysctl -w net.ipv4.ip_forward=1
GOHPTS nat chainiptables -t nat -N GOHPTS
iptables -t nat -A GOHPTS -d 127.0.0.0/8 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 8080 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 1090 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 22 -j RETURN
iptables -t nat -A GOHPTS -p tcp -j REDIRECT --to-ports 1090
iptables -t nat -A PREROUTING -p tcp -j GOHPTS
iptables -t nat -A OUTPUT -p tcp -j GOHPTS
Testverbindung:```shell
#traffic should be redirected via 127.0.0.1:1090
curl http://example.com
Alles rückgängig machen:```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
redirect modeUm Ihr System automatisch zu konfigurieren, führen Sie den folgenden Befehl aus:```shell sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto
Bitte beachten Sie, dass die automatische Konfiguration `sudo` erfordert und sehr allgemein ist, was möglicherweise nicht Ihren Anforderungen entspricht. Sie können optional `-mark <value>` angeben, um mögliche Proxy-Loops zu verhindern.```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100
tproxy (via MANGLE and IP_TRANSPARENT)In diesem Modus erfolgt das Proxying mit der mangle-Tabelle von iptables und dem TPROXY-Ziel. Der transparente Proxy sieht die Zieladresse unverändert, sie wird nicht vom Kernel umgeschrieben. Damit dies funktioniert, bindet der Proxy mit der Socket-Option IP_TRANSPARENT, iptables fängt den Datenverkehr mit dem TPROXY-Ziel ab, und Routing-Regeln weisen markierte Pakete an, zum lokalen Proxy zu gehen, ohne ihre ursprüngliche Zieladresse zu ändern.
Dieser Modus erfordert erhöhte Privilegien, um GoHPTS auszuführen. Sie können dies tun, indem Sie den folgenden Befehl ausführen:```shell
sudo setcap 'cap_net_admin+ep' ~/go/bin/gohpts
Um `GoHPTS` in diesem Modus auszuführen, verwenden Sie das Flag `-T` mit `-M tproxy`
### Beispiel
[[Zurück]](#table-of-contents)```shell
# run the proxy
gohpts -s 1080 -T 0.0.0.0:1090 -M tproxy -d
Von allen, die mit den Codebasen, Issue-Trackern, Chat-Räumen und Mailinglisten des AppConfig-Projekts interagieren, wird erwartet, dass sie den Verhaltenskodex befolgen.
ssh remote -D 1080 -Nf
Richten Sie Ihr Betriebssystem ein:```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
Verbindung testen:```shell ip netns exec ns-client curl http://1.1.1.1
Alles rückgängig machen:```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
tproxy ModusUm Ihr System automatisch zu konfigurieren, führen Sie den folgenden Befehl aus (z.B. auf einer separaten VM):```shell ssh remote -D 1080 -Nf sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -auto -mark 100
Führen Sie Folgendes auf Ihrem Host aus:```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
Verbindung testen:```shell curl http://example.com #check logs on your VM
Alles rückgängig machen:```shell
ip route del 0.0.0.0/1 via 192.168.0.1 2>/dev/null || true
ip route del 128.0.0.0/1 via 192.168.0.1 2>/dev/null || true
if [[ -f /tmp/default-route.txt ]]; then
eval $(awk '{print "ip route add "$0}' /tmp/default-route.txt)
rm -f /tmp/default-route.txt
else
echo "Something went wrong"
fi
GoHPTS hat UDP-Unterstützung, die in den Modi tproxy und tlocal aktiviert werden kann. Damit dieses Setup funktioniert, müssen Sie eine Verbindung zu einem socks5-Server herstellen, der UDP-Verbindungen bedienen kann (UDP ASSOCIATE). Beispielsweise können Sie https://github.com/wzshiming/socks5 verwenden, um einen UDP-fähigen socks5-Server auf einem entfernten oder lokalen Rechner bereitzustellen. Sobald Sie den Server zum Verbinden haben, führen Sie den folgenden Befehl aus:```shell
sudo env PATH=$PATH gohpts -s remote -Tu :8989 -M tproxy -auto -mark 100 -d
Dieser Befehl konfiguriert Ihr Betriebssystem und richtet den Server auf der Adresse `0.0.0.0:8989` ein.
Zum lokalen Testen können Sie den UDP-transparenten Proxy mit dem Flag `-arpspoof` kombinieren. Beispiel:
1. Richten Sie eine VM auf Ihrem System mit einer beliebigen Linux-Distribution ein, die `tproxy` unterstützt (z. B. Kali Linux).
2. Aktivieren Sie das `bridged` Netzwerk, damit die VM auf Ihren Hostrechner zugreifen kann.
3. Verschieben Sie die `gohpts`-Binärdatei auf die VM (z. B. per `ssh`) oder bauen Sie sie dort, falls das Betriebssystem/die Architektur anders ist.
4. Führen Sie auf Ihrer VM den folgenden Befehl aus:```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"
Transparenter Proxy kann auf Android-Geräten (arm64) mit Root-Zugriff aktiviert werden. Sie können Termux installieren und dort GoHPTS als CLI-Tool ausführen:```shell
pkg install tsu iproute2
GOHPTS_RELEASE=v1.10.2; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-android-arm64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-android-arm64 gohpts && ./gohpts -h
sudo ./gohpts -s remote -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "fullduplex true;debug false"
### YAML-Konfiguration
[[Zurück]](#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
Der GoHPTS-Proxy ermöglicht es, den Verkehr, der durch den Dienst läuft, zu erfassen und zu überwachen. Dieser Vorgang wird als traffic sniffing, packet sniffing oder einfach sniffing bezeichnet. Insbesondere versucht der Proxy zu identifizieren, ob es sich um Klartext- (HTTP) oder TLS-Verkehr handelt, und nach erfolgter Identifizierung parst er die Metadaten der Anfrage/Antwort und schreibt sie in eine Datei oder auf die Konsole. Im Fall des GoHTPS-Proxys sehen geparste Metadaten wie folgt aus (TLS-Handshake):
[Back]```json [ { "connection": { "tproxy_mode": "redirect", "src_local": "127.0.0.1:8888", "src_remote": "192.168.0.107:51142", "dst_local": "127.0.0.1:56256", "dst_remote": "127.0.0.1:1080", "original_dst": "216.58.209.206:443" } }, { "tls_request": { "sni": "www.youtube.com", "type": "Client hello (1)", "version": "TLS 1.2 (0x0303)", "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39", "cipher_suites": [ "TLS_AES_128_GCM_SHA256 (0x1301)", "TLS_CHACHA20_POLY1305_SHA256 (0x1303)", "TLS_AES_256_GCM_SHA384 (0x1302)", "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 (0xc02b)", "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (0xc02f)", "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 (0xcca9)", "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 (0xcca8)", "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 (0xc02c)", "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (0xc030)", "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA (0xc00a)", "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA (0xc009)", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA (0xc013)", "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA (0xc014)", "TLS_RSA_WITH_AES_128_GCM_SHA256 (0x9c)", "TLS_RSA_WITH_AES_256_GCM_SHA384 (0x9d)", "TLS_RSA_WITH_AES_128_CBC_SHA (0x2f)", "TLS_RSA_WITH_AES_256_CBC_SHA (0x35)" ], "extensions": [ "server_name (0)", "extended_master_secret (23)", "renegotiation_info (65281)", "supported_groups (10)", "ec_point_formats (11)", "session_ticket (35)", "application_layer_protocol_negotiation (16)", "status_request (5)", "delegated_credential (34)", "signed_certificate_timestamp (18)", "key_share (51)", "supported_versions (43)", "signature_algorithms (13)", "psk_key_exchange_modes (45)", "record_size_limit (28)", "compress_certificate (27)", "encrypted_client_hello (65037)" ], "alpn": ["h2", "http/1.1"] } }, { "tls_response": { "type": "Server hello (2)", "version": "TLS 1.2 (0x0303)", "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39", "cipher_suite": "TLS_AES_128_GCM_SHA256 (0x1301)", "extensions": ["key_share (51)", "supported_versions (43)"], "supported_version": "TLS 1.3 (0x0304)" } } ]
Und HTTP-Anfrage mit 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"]
}
}
}
]
Die Verwendung ist so einfach wie das Angeben des -sniff-Flags zusammen mit den regulären Flags.```shell
gohpts -d -T 8888 -M redirect -sniff -j
Sie können auch eine Datei angeben, in die der abgefangene Verkehr geschrieben werden soll:```shell
gohpts -sniff -snifflog ~/sniff.log -j
Sie können ein Beispiel der farbigen Ausgabe im obigen Bild sehen. In diesem Modus versucht GoHPTS, wichtige Informationen wie TLS-Handshake, HTTP-Metadaten, etwas, das wie Logins/Passwörter oder verschiedene Arten von Authentifizierungs- und geheimen Token aussieht, hervorzuheben. Die Ausgabe ist im Vergleich zu JSON eingeschränkt, aber für Menschen viel einfacher zu lesen.
Um GoHPTS in diesem Modus auszuführen, verwenden Sie die folgenden Flags:```shell
gohpts -sniff -body
Sie können Sniffing mit dem transparenten Modus kombinieren:```shell
./gohpts -T 8888 -M redirect -sniff -body
Um Farben zu deaktivieren, fügen Sie -nocolor hinzu:```shell
gohpts -sniff -body -nocolor
## HTTP2- und HTTP3-Unterstützung
[[Zurück]](#table-of-contents)
Der `GoHPTS`-Proxy verarbeitet HTTP/1.1-, HTTP/2- und HTTP/3-Anfragen über dieselbe Serveradresse und dasselbe TLS-Zertifikat. Dies ermöglicht es Clients, automatisch das beste verfügbare Protokoll auszuwählen, ohne die Konfiguration zu ändern. Das TLS-Zertifikat kann auf verschiedene Weise bezogen werden: Cloud-Anbieter (Google, AWS, Cloudflare), kostenloses Zertifikat von Let's Encrypt, oder Sie können ein selbstsigniertes Zertifikat mit `openssl` (Linux/macOS) oder `New-SelfSignedCertificate` (Windows) erstellen.
### Beispielsetup mit selbstsigniertem Zertifikat
[[Zurück]](#table-of-contents)
- Erstellen Sie die Dateien `key.pem` und `cert.pem`: ```shell
openssl req -x509 -newkey rsa:2048 \
-keyout key.pem \
-out cert.pem \
-sha256 \
-days 365 \
-nodes \
-subj "/C=XX/ST=StateName/L=CityName/O=CompanyName/OU=CompanySectionName/CN=127.0.0.1" \
-addext "subjectAltName=IP:127.0.0.1"
GoHPTS proxy: ```shell
go install github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Sie können andere Methoden verwenden, die im Abschnitt Installation beschrieben sind.
Schließlich:
http_server: address: 127.0.0.1:8080 cert_file: ./cert.pem key_file: ./key.pem
proxy_list:
logging: debug: true
sniffing: enabled: true body: true
Proxy ausführen: ```shell gohpts -f ./gohpts_config.yaml
2. Oder wenn Sie Befehlszeilenargumente bevorzugen: ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body
Sie sollten so etwas sehen: ```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
### Testverbindung
[[Back]](#table-of-contents)
- Für HTTP/2-Proxy-Server kannst du `curl` verwenden: ```shell
curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://localhost:8080 "https://stream.wikimedia.org/v2/stream/recentchange"
Drücke Ctrl+C, um den laufenden Stream zu stoppen.
Für HTTP/3 ist es anders, da (zum Zeitpunkt der Erstellung) curl keinen HTTP3-Proxy unterstützt, also werde ich meinen eigenen Client verwenden, den ich zu Testzwecken erstellt habe.
Lade das Simple HTTP3 to SOCKS5 proxy example herunter und installiere es: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make
Führen Sie den folgenden Befehl aus: ```shell ./bin/client -a 127.0.0.1:8080 www.google.com
Sie sollten einiges an Kauderwelsch sehen, das einer HTML-Seite ähnelt.
Gehen Sie zum Terminal-Tab mit dem `GoHPTS`-Proxy und überprüfen Sie die Logs. Sie sollten dort alle Ihre Anfragen sehen.
### Verbindung in einem Browser testen
[[Back]](#table-of-contents)
- Erstellen Sie ein ordnungsgemäßes selbstsigniertes Zertifikat für den 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
Weitere Informationen finden Sie hier: Creating a browser trusted, self signed, SSL certificate
rootCA.crt dem Systemvertrauensspeicher hinzu:
- Führen Sie den Proxy mit `server.crt` und `server.key` aus: ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body
In Bezug auf die Netzwerkschichthandhabung kann GoHPTS in drei Modi betrieben werden: dual stack, IPv4-only und IPv6-only. Der Benutzer kann den Modus durch die Angabe der Flags -4 und -6 steuern. Wenn eines der Flags gesetzt ist, startet der Proxy im entsprechenden Modus; wenn beide Flags vorhanden oder beide weggelassen sind, wird dual stack angenommen. Bitte beachten Sie, dass in den "only"-Modi nur IP-Adressen der jeweiligen Version erlaubt sind, alle Domains (wenn möglich) in die spezifische IP-Version aufgelöst werden, alle Listening-Adressen die Verwendung derselben Version erfordern usw.
Um den IPv4-only-Modus zu aktivieren, fügen Sie einfach das Flag -4 hinzu:```shell
sudo ./gohpts -sniff -body -d -4
Um den Proxy im IPv4-Modus zu testen, können Sie jede Linux-VM verwenden:
1. Auf Ihrer virtuellen Maschine:```shell
# add your host machine as gateway for VM
export GATEWAY="<host IPv4 address>"
ip route add 0.0.0.0/1 via "$GATEWAY"
ip route add 128.0.0.0/1 via "$GATEWAY"
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -4
3. Besuchen Sie eine beliebige Website auf Ihrer virtuellen Maschine und sehen Sie den Datenverkehr in den Proxy-Protokollen
Um den `IPv6-only`-Modus zu aktivieren, fügen Sie einfach das Flag `-6` hinzu, zum Beispiel bei Verwendung mit transparentem Proxy:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6
Damit dies funktioniert, müssen Ihr ISP und der entfernte Socks5-Proxy aktive IPv6-Unterstützung haben. Sie können https://test-ipv6.com/ besuchen, um herauszufinden, ob Sie auf IPv6-Adressen zugreifen können. Um den Proxy im IPv6-Modus zu testen, können Sie jede Linux-VM verwenden:
export GATEWAY6="" ip -6 route add ::/1 via "$GATEWAY6" dev eth0 ip -6 route add 8000::/1 via "$GATEWAY6" dev eth0
2. Auf Ihrem Host:```shell
# run proxy on your host
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -6
GoHPTS verfügt über einen integrierten ARP-Spoofer, mit dem alle TCP-kommunizierenden Geräte in Ihrem LAN gezwungen werden können, den Proxy-Server für die Internetverbindung zu nutzen.
Dies wird durch Hinzufügen des Flags -arpspoof mit einigen Parametern, getrennt durch Semikolon, erreicht.
Beispiel:```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"
Der Proxy scannt nach Geräten im Subnetz `192.168.10.0/24` und sendet ihnen ARP-Pakete, um sich als Gateway auszugeben. Wenn `fullduplex` true ist, sendet der Proxy auch ARP-Pakete an das Gateway, um ihm vorzutäuschen, dass unser Proxy jede IP im Subnetz besitzt.
Nachdem der Proxy mit `Ctrl+C` gestoppt wurde, wird er automatisch alle Ziele enttarnen.
`GoHPTS` kann auch mit Tools wie [Bettercap](https://github.com/bettercap/bettercap) verwendet werden, um ARP-gespoofte Datenverkehr zu proxen.
Führen Sie den Proxy aus:```shell
ssh remote -D 1080 -Nf
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100
Führen Sie bettercap mit diesem Befehl aus (siehe Dokumentation):```shell
sudo bettercap -eval "net.probe on;net.recon on;set arp.spoof.fullduplex true;arp.spoof on"
Überprüfen Sie die Proxy-Protokolle auf Datenverkehr von anderen Geräten aus Ihrem LAN
Weitere Informationen zu den arpspoof-Optionen finden Sie unter `gohpts -h` und [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)
## NDP spoofing
[[Back]](#table-of-contents)
`GoHPTS` verfügt über eine integrierte Funktion zur Durchführung von NDP-Spoofing in IPv6-Netzwerken mit Router Advertisement (RA)- und Neighbor Advertisement (NA)-Paketen. Es enthält außerdem die RDNSS-Option in RA-Paketen, um den Host als IPv6-Nameserver für betroffene Clients zu setzen. In Kombination mit dem transparenten Proxy-Modus (TCP/UDP) ermöglicht NDP-Spoofing `gohpts`, Datenverkehr für Clients in lokalen Netzwerken zu proxieren. Wie bei [ARP-Spoofing](#arp-spoofing) können Sie NDP-Spoof-Optionen mit dem einzelnen `-ndpspoof`-Flag festlegen:
Beispiel:```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"
Für weitere Informationen über ndpspoof-Optionen siehe gohpts -h und https://github.com/shadowy-pycoder/ndpspoof
Bitte beachten Sie, dass einige Optionen wie rdnss, gateway, interface automatisch von gohpts selbst gesetzt werden, um ordnungsgemäß als Proxy zu funktionieren.
Da gohpts alle Verbindungen über einen vorgeschalteten SOCKS5-Server proxyt, benötigen Sie einen funktionierenden Server mit IPv4/IPv6- und TCP/UDP-Unterstützung. Offensichtlich sollte auch ein entferntes System (z.B. VPS) eine funktionierende IPv6-Konnektivität haben. Selbstverständlich sollte die Maschine, auf der gohpts läuft, Teil eines Netzwerks mit IPv6-Unterstützung sein.
Beispiel-Setup für korrektes NDP-Spoofing:
2. Abhängigkeiten installieren```shell
GO_VERSION=$(curl 'https://go.dev/VERSION?m=text' | head -n1)
cd ~/Downloads/ && wget https://go.dev/dl/$GO_VERSION.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf $GO_VERSION.linux-amd64.tar.gz
4. Gehen Sie zurück zu Ihrem Host-Rechner und installieren Sie `gohpts` (siehe [Installation](#installation))
5. Führen Sie `gohtps` aus:```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
Nehmen Sie ein anderes Gerät (Handy, Tablet usw.) und verbinden Sie es mit demselben Netzwerk. Versuchen Sie, auf das Internet zuzugreifen und prüfen Sie, ob auf Ihrem Host-Rechner etwas Datenverkehr erscheint. Überprüfen Sie die öffentliche IP-Adresse mit einem Online-Tool (sie sollte in diesem Fall Ihrer VPS-Adresse 203.0.113.10 oder der globalen IPv6-Adresse entsprechen).
Stoppen Sie den Proxy mit Strg+C
Profit!
Um DNS-Filter zu erzwingen und Ziele durch Ändern von DNS-Einträgen zu spoofen, sollte der Host, auf dem GoHPTS läuft, zum Standard-Gateway für LAN-Geräte werden. Dazu führen Sie einfach den transparenten Proxy mit aktiviertem UDP aus und führen auch ARP/NDP-Spoofing durch, damit die Ziele Ihren DNS-Server verwenden.
Von GoHPTS erstellte DNS-Antworten sehen aus wie normale Pakete vom Router oder von vertrauenswürdigen DNS-Servern (Google, Cloudflare), sodass Clients ihren Cache mit dem aktualisieren, was Sie ihnen vorgeben. Beachten Sie jedoch, dass dies nur für „standardmäßigen“ unverschlüsselten DNS-Verkehr funktioniert (DOT/DOH werden nicht gefiltert oder gespooft).
DNS-Filter und Domains zum Spoofing können im Abschnitt dns_filter der YAML-Konfigurationsdatei konfiguriert werden. Alle Listen akzeptieren URLs, Dateipfade und Einträge ähnlich denen, die normalerweise in der Hosts-Datei zu finden sind, siehe https://en.wikipedia.org/wiki/Hosts_(file).
Beispiel:```yaml
dns_filter: enabled: true whitelist: ["/tmp/whitelisted_domains.txt", "example.com", "*.google.com"] # ip is optional, domains can start with *. to match all subdomains blacklist: ["https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts"] blacklist_all: false # block all non whitelisted domains spooflist: ["127.0.0.1 example.com"] # ip address is required here
Anwendungsfälle:
- Werbe- und Tracker-Blocker für alle LAN-Geräte
- Kindersicherung durch Blockieren bestimmter Website-Kategorien
- Blockieren bekannter Phishing- und Malware-Domains
- Verkehrsumleitung zur Analyse
- Erfassung von Anmeldeinformationen durch Umleitung
- Verkehrs-Hijacking und -Manipulation (Einschleusen von Werbung, Skripten, Tracking)
- Überwachung und Profilerstellung
Minimale Konfiguration für dieses Setup:```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"]
Ausführen:```shell sudo ./gohpts -f ./gohpts_dns_spoof.yaml
Weitere Informationen finden Sie hier: [https://en.wikipedia.org/wiki/DNS_spoofing](https://en.wikipedia.org/wiki/DNS_spoofing)
## Paket-Capture
[[Zurück]](#table-of-contents)
Der Datenverkehr kann in pcap-, pcapng- oder benutzerdefinierte txt-Formate erfasst und später mit Tools wie Wireshark, tcpdump und vielen anderen analysiert werden.
Stellen Sie zunächst sicher, dass die ausführbare Datei `GoHPTS` über erhöhte Berechtigungen verfügt, um Rohpakete erfassen zu können. Sie haben zwei Möglichkeiten:
- Führen Sie einmal `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` aus, um dem Proxy Zugriff auf Rohdatenverkehr zu gewähren
- Führen Sie den Proxy mit `sudo` aus, wenn Sie das Flag `-pcap` in der CLI oder `pcap.enabled` in der Dateikonfiguration angeben müssen.
Konfigurieren Sie den Proxy über die CLI:```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"
Konfigurationsdatei:```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"
Diese Befehle erzeugen drei Packet-Capture-Dateien mit entsprechenden Formaten, die später von verschiedenen Tools analysiert werden können.
Weitere Informationen zu pcap-Optionen finden Sie unter `gohpts -h` und [https://github.com/shadowy-pycoder/mshark](https://github.com/shadowy-pycoder/mshark)
## Netzwerk-Namespaces
[[Zurück]](#table-of-contents)
Standardmäßig läuft der `GoHPTS`-Proxy innerhalb eines einzigen Netzwerk-Namespace, aber dies kann überschrieben werden. Listening-Sockets (z. B. HTTP-Server oder transparenter Proxy-Server) und ausgehende Sockets (Socks-Proxy oder direkter Dialer), die von `GoHPTS` erstellt werden, können mit Linux/Android [network_namespaces (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html) isoliert werden. Beim Starten des Proxy-Prozesses können Benutzer die Flags `-in-netns` (Listener) und `-out-netns` (Dialer) mit dem Namen oder Pfad zum Netzwerk-Namespace angeben, um zu steuern, in welcher isolierten Umgebung Sockets erstellt werden sollen. Wenn Sie entweder Listener oder Dialer im aktuellen (Standard-)Namespace erstellen möchten, lassen Sie das Flag einfach weg. Um den Host-Namespace explizit anzugeben, können Sie den Pfad `/proc/1/ns/net` verwenden – dies ermöglicht dem Proxy, die System-Nameserver korrekt zu identifizieren.
`GoHPTS` unterstützt die [ip-netns (8)](https://man7.org/linux/man-pages/man8/ip-netns.8.html)-Konvention zur Bereitstellung der Netzwerkkonfiguration über Dateien im Verzeichnis `/etc/netns/NAME/`. Um also benutzerdefinierte Nameserver für den Netzwerk-Namespace `ns1` anzugeben, gehen Sie wie folgt vor:```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
Wenn keine Konfiguration gefunden wird, werden die Google DNS-Server zur Auflösung von Domainnamen verwendet.
Wenn auf Ihrem System systemd-resolved.service (8) aktiviert ist, sollten Sie es vorübergehend deaktivieren, wenn Sie Abfragen über benutzerdefinierte Netzwerk-Namespaces durchführen:```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'
Oder machen Sie es für eine bestimmte Shell-Instanz persistent:```shell
sudo ip netns exec ns1 unshare --mount bash -c '
mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve
exec bash --login'
key.pem und cert.pem: ```shell
openssl req -x509 -newkey rsa:2048 ns1 und konfigurieren Sie das veth-Netzwerk ```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
HTTP Proxy - Proxy-Listener in ns1 (keine Standardroute, kein Internetzugang), ausgehende Sockets auf dem Host
Proxy ausführen: ```shell sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1
Anfrage via ns1 stellen ```shell
sudo ip netns exec ns1 curl -Nv --proxy http://127.0.0.1:8083 https://example.com
Anfrage sollte erfolgreich sein
2. **HTTP2-Proxy - Proxy-Listener in `ns1` (keine Standardroute, kein Internetzugriff), ausgehende Sockets auf dem Host**
Proxy ausführen: ```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
Stelle Anfrage über ns1 ```shell
sudo ip netns exec ns1 curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://127.0.0.1:8083 https://example.com
Anfrage sollte erfolgreich sein
3. **HTTP3-Proxy - Proxy-Listener in `ns1` (keine Standardroute, kein Internetzugang), ausgehende Sockets auf dem Host**
Proxy ausführen: ```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
Anfrage über ns1 ```shell
sudo ip netns exec ns1 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
Anfrage sollte erfolgreich sein
4. **Redirect transparent proxy (`-M redirect`) - Proxy-Listener in `ns1` (Standardroute, kein Internetzugriff), ausgehende Sockets auf dem Host**
Proxy ausführen: ```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
Sende Anfrage via ns1 ```shell
sudo ip netns exec ns1 curl -Nv https://example.com
Anfrage sollte fehlschlagen
Füge Standardroute zu `ns1` hinzu ```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
Versuche es erneut ```shell sudo ip netns exec ns1 curl -Nv https://example.com
Jetzt sollte die Anfrage erfolgreich sein
5. **HTTP-Proxy - Proxy-Listener auf dem Host, ausgehende Sockets in `ns1` (Standardroute, Internetzugang)**
NAT-Regeln hinzufügen, damit `ns1` über `wlan0` eine Verbindung zum Internet herstellen kann ```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
Proxy ausführen: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0
Anfrage über Host stellen ```shell
curl -Nv --proxy http://$WLAN_IP:8083 https://example.com
Anfrage sollte erfolgreich sein
HTTP3-Proxy - Proxy-Listener auf dem Host, ausgehende Sockets in ns1 (Standardroute, Internetzugang)
Proxy ausführen: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0 -c ./cert.pem -k ./key.pem
Stelle Anfrage via Host ```shell ./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com
Request should succeed
7. **Weiterleitung transparenter Proxy - Proxy-Listener auf dem Host, ausgehende Sockets in `ns1` (Standardroute, Internetzugang)**
Proxy ausführen (`-auto` funktioniert bei mir nicht mit lokalem Socks5-Server, daher verwende ich einen entfernten): ```
sudo ./bin/gohpts -s <remote> -4 -6 -d -sniff -body -out-netns ns1 -nohttp -M redirect -T :8888 -auto
Anfrage über Host senden ```shell curl -Nv https://example.com
Anfrage sollte erfolgreich sein
8. **HTTP-Proxy - LAN (`ns2` (Proxy-Listener), `ns3`, `ns4`), ausgehende Sockets in `ns1` (Standardroute, Internetzugriff)**
LAN erstellen ```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
Proxy ausführen: ``` sudo ./bin/gohpts -s $WLAN_IP:1080 -l 0.0.0.0:8083 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1
Anfragen stellen ```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
Alle Anfragen sollten erfolgreich sein.
HTTP3-Proxy - LAN (ns2 (Proxy-Listener), ns3, ns4), ausgehende Sockets in ns1 (Standardroute, Internetzugang)
Proxy ausführen: ``` 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
Anfragen stellen ```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
Alle Anfragen sollten erfolgreich sein
10. **Transparenter Proxy mit Umleitung - LAN (`ns2` (Proxy-Listener), `ns3`, `ns4`), ausgehende Sockets in `ns1` (Standardroute, Internetzugang)**
Proxy ausführen:
```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
```
Anfragen stellen
```shell
sudo ip netns exec ns2 curl -Nv https://example.com
```
Für `ns3` und `ns4` schlägt die Anfrage fehl
11. **Transparenter Proxy mit `IP_TRANSPARENT` (ARP/NDP-Spoofing aktiviert) LAN (`ns2` (Proxy-Listener), `ns3`, `ns4`), ausgehende Sockets in `ns1` (Standardroute, Internetzugang)**
Proxy ausführen:
```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"
```
Nun sollten die vorherigen Anfragen auf `ns3` und `ns4` funktionieren
```
sudo ip netns exec ns3 curl -Nv https://example.com
sudo ip netns exec ns4 curl -Nv https://example.com
```
12. **HTTP3-Proxy - Proxy-Listener in `ns1`, ausgehende Sockets auf dem Host, Flag `-nosocks`**
Proxy ausführen:
```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
```
Anfrage stellen
```shell
./http3-socks-proxy/bin/client -a 10.0.0.2:8083 www.google.com
```
Anfrage sollte erfolgreich sein
13. **HTTP3-Proxy - Proxy-Listener auf dem Host, ausgehende Sockets in `ns1`, Flag `-nosocks`**
Proxy ausführen:
```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
```
Anfrage stellen
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
Anfrage sollte fehlschlagen
Regeln zur `FORWARD`-Kette hinzufügen
```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
```
Anfrage stellen
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
Anfrage sollte erfolgreich sein
## Gemischter Server
[[Zurück]](#table-of-contents)
`GoHPTS` kann so konfiguriert werden, dass es auf demselben Adressbereich wie der HTTP-Server auf SOCKS-Verbindungen hört. Fügen Sie einfach das Flag `-mixed` hinzu, um einen zusätzlichen SOCKS-Server zu starten. Dadurch fungiert `GoHPTS` nicht nur als `HTTP-zu-SOCKS`-Proxy, sondern auch als `SOCKS-zu-SOCKS`-Proxy. Der lokale SOCKS5-Server unterstützt den Befehl `UDP ASSOCIATE`, sodass Benutzer technisch gesehen UDP-Datagramme mit diesem gemischten Server senden können.
Proxy ausführen:```shell
gohpts -s :1080 -l :8080 -mixed
Testverbindung:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Oder deaktivieren Sie den vorgeschalteten SOCKS-Proxy und verbinden Sie direkt, indem Sie `-nosocks` hinzufügen:```shell
gohpts -l :8080 -mixed -nosocks
Verbindung testen:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Fügen Sie das Flag `-socks4` hinzu, um stattdessen das SOCKS4-Protokoll zu verwenden:```shell
# :1080 should be a socks4 server
gohpts -s :1080 -l :8080 -mixed -socks4
Verbindung testen:```shell curl -Nv --proxy socks4://127.0.0.1:8080 "https://example.com"
## Links
[[Back]](#table-of-contents)
Erfahre mehr über transparente Proxys unter den folgenden Links:
- [Transparent-Proxy-Unterstützung im Linux-Kernel](https://docs.kernel.org/networking/tproxy.html)
- [Transparent-Proxy-Tutorial von Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Einfaches tproxy-Beispiel](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Transparent-Proxy-Implementierung mit eBPF und 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)
`socks5`-Proxy mit `UDP ASSOCIATE`-Unterstützung:
- [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)
IPv4/IPv6-Netzwerksicherheit:
- [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/)
## Mitwirken
[[Back]](#table-of-contents)
Bist du Entwickler?
- Forke das Repository
- Erstelle deinen Feature-Branch: `git switch -c my-new-feature`
- Commite deine Änderungen: `git commit -am 'Add some feature'`
- Pushe auf den Branch: `git push origin my-new-feature`
- Reiche einen Pull-Request ein
## Lizenz
[[Back]](#table-of-contents)
GPLv3
NDP-Spoofing
Proxyt IPv6-Verbindungen mittels Router/Neighbor Advertisement und RDNSS-Injektionen.
DNS-Spoofing
Leitet Clients mittels Manipulation von DNS-Einträgen auf beliebige Domains um
Paketerfassung
Erfasst Verkehr in txt/pcap/pcapng-Dateien und analysieren mit Wireshark
DNS-Leak-Schutz
DNS-Auflösung erfolgt serverseitig auf dem SOCKS5-Proxy.
CONNECT-Methoden-Unterstützung
Unterstützt HTTP-CONNECT-Tunneling, wodurch HTTPS und andere TCP-basierte Protokolle ermöglicht werden.
HTTP2/HTTP3-Unterstützung
Unterstützt modernen HTTP/2- und HTTP/3-Transport, was effiziente multiplexierte Verbindungen über TLS 1.3 ermöglicht
Unterstützung von Netzwerk-Namespaces
Unterstützt benutzerdefinierte Linux-Netzwerk-Namespaces für Lauschsockets und ausgehende Verbindungen
Unterstützung von Trailer-Headern
Verarbeitet HTTP-Trailer-Header
Chunked Transfer Encoding
Verarbeitet chunked und Streaming-Antworten
SOCKS5-Authentifizierungsunterstützung
Unterstützt Benutzername/Passwort-Authentifizierung für SOCKS5-Proxys.
HTTP-Authentifizierungsunterstützung
Unterstützt Benutzername/Passwort-Authentifizierung für HTTP-Proxy-Server.
Leichtgewichtig und schnell
Konzipiert mit minimalem Overhead und effizienter Anfrageverarbeitung.
Plattformübergreifend
Kompatibel mit allen gängigen Betriebssystemen.
wlan0, um eine Verbindung zum lokalen socks5 herstellen zu können. ```shell
WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')