GoHPTS - HTTP(S)- und TCP/UDP-transparenter Proxy zu SOCKS4/SOCKS5-Proxy (Kette), geschrieben 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

Inhaltsverzeichnis

Einführung
Funktionen
Installation
Verwendung
- Konfiguration über CLI-Flags
- Konfiguration über YAML-Datei
Transparenter Proxy
Verkehrsanalyse (Traffic Sniffing)
- JSON-Format
- Farbiges Format
HTTP2- und HTTP3-Unterstützung
IPv4- und IPv6-Unterstützung
ARP-Spoofing
NDP-Spoofing
DNS-Spoofing
Paketaufzeichnung
Netzwerk-Namespaces
- Playground-Setup
- Verwendungsbeispiele
Gemischter Server
Links
Mitwirken
Lizenz

Einführung

[Zurück]

Das GoHPTS CLI-Tool ist eine Brücke zwischen HTTP-Clients und einem SOCKS5-Proxy-Server oder mehreren Servern (Kette). Es lauscht lokal als HTTP-Proxy, akzeptiert standardmäßige HTTP- oder HTTPS-Anfragen (über CONNECT) und leitet die Verbindung durch 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, aber diese API ist nur von einem bestimmten Remote-Server aus erreichbar. Die folgenden Befehle helfen Ihnen, eine solche Aufgabe durchzuführen:

Erstellen Sie einen SOCKS5-Proxy-Server über ssh:```shell ssh -D 1080 -Nf

Erstellen Sie eine HTTP-zu-SOCKS5-Verbindung mit `gohpts````shell
gohpts -s :1080 -l :8080

HTTP-Server in der Proxy-Konfiguration von Postman angeben

Funktionen

[Zurück]

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-Modi (IP_TRANSPARENT)
IPv4- und IPv6-Unterstützung
Arbeitet in IPv4-only-, IPv6-only- oder dual stack-Modi
TCP- und UDP-Transparent-Proxy
tproxy und tlocal (IP_TRANSPARENT) verarbeiten TCP- und UDP-Verkehr
Traffic-Sniffing
Der Proxy kann HTTP-Header, TLS-Handshake, DNS-Nachrichten und mehr parsen
ARP-Spoofing
Ganze Subnetze mit dem ARP-Spoofing-Ansatz proxen
NDP-Spoofing
IPv6-Verbindungen mithilfe von Router/Neighbor Advertisement- und RDNSS-Injektionen proxen.
DNS-Spoofing
Clients mithilfe von DNS-Eintragsmanipulation auf beliebige Domains umleiten
Paketaufzeichnung
Verkehr in txt/pcap/pcapng-Dateien aufzeichnen und mit Wireshark analysieren
DNS-Leak-Schutz
Die DNS-Auflösung erfolgt auf der SOCKS5-Serverseite.
CONNECT-Methoden-Unterstützung
Unterstützt HTTP-CONNECT-Tunneling, was HTTPS und andere TCP-basierte Protokolle ermöglicht.
HTTP2/HTTP3-Unterstützung
Unterstützt moderne HTTP/2- und HTTP/3-Transporte und ermöglicht effiziente multiplexte Verbindungen über TLS 1.3
Unterstützung für Netzwerk-Namespaces
Unterstützt benutzerdefinierte Linux-Netzwerk-Namespaces für Listening-Sockets und ausgehende Verbindungen
Unterstützung für Trailer-Header
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
Entwickelt mit minimalem Overhead und effizienter Anfragenverarbeitung.
Plattformübergreifend
Kompatibel mit allen gängigen Betriebssystemen.

Installation

[Zurück]

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

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.6; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-linux-amd64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-linux-amd64 gohpts && ./gohpts -h

Installation mit dem 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

Dadurch wird die Binärdatei gohpts in deinem Verzeichnis $GOPATH/bin installiert.

Aus dem Quellcode erstellen: ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make build ./bin/gohpts
In Docker ausführen: ```shell docker run -it --privileged --network host -v "$PWD/gohpts.yaml:/config.yaml" shadowypycoder/gohpts:latest -f config.yaml

Verwendung

[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) -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)

### Konfiguration über CLI-Flags

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

I can't translate this chunk because the INPUT section is empty — no source text was provided after "INPUT:".

Please paste the actual Markdown content for chunk 21/241 and I'll return the German translation, preserving all structure and leaving code, paths, URLs, and identifiers untouched.```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"}

Geben Sie Benutzername und Passwort für den SOCKS5-Proxy-Server an:```shell
gohpts -s 1080 -l 8080 -d -j -u user
SOCKS5 Password: #you will be prompted for password input here

Geben Sie Benutzername und Passwort für den HTTP-Proxy-Server an:```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ühre den Proxy als Daemon aus (eine Logdatei wird für die Protokollausgabe benötigt, andernfalls siehst du nichts)```shell gohpts -D -logfile /tmp/gohpts.log

Ihre Anfrage wird bearbeitet. Bitte warten Sie, bis der Vorgang abgeschlossen ist.```shell
# output
gohpts pid: <pid>

I'll analyze the request and provide the translation. However, I notice that the actual content to translate was not included in your message — the INPUT section is empty.

Please provide the Markdown content (chunk 33 of 241) that you'd like me to translate from English to German, and I'll return only the translated text following all the rules you've specified.```shell

kill the process

kill #or kill $(pidof gohpts)

`-u` und `-U` Flags funktionieren nicht im Daemon-Modus (und daher auch nicht bei der 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 sich zu sehr mit der CLI herumschlagen zu müssen, oder wenn Sie einfach mehrere Profile für unterschiedliche Anforderungen wünschen.

HTTP-Proxy im SOCKS5-Proxy-Chain-Modus ausführen (Servereinstellungen über YAML-Konfigurationsdatei angeben)```shell
gohpts -f "~/gohtps.yaml" -d -j

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

Sie können nahezu jede in der Konfigurationsdatei angegebene Einstellung überschreiben, indem Sie die entsprechenden CLI-Flags angeben:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor

Proxy übernimmt alle Einstellungen, die in ~/gohpts.yaml angegeben sind, startet aber 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 die Datei konfiguriert werden.

Die vollständige Version der Konfiguration finden Sie hier: example_gohpts.yaml

Um mehr über Proxy-Ketten zu erfahren, besuchen Sie Proxychains Github

Transparenter Proxy

[Zurück]

Auch bekannt als intercepting proxy, inline proxy oder forced proxy, fängt ein transparenter Proxy die normale Kommunikation auf Anwendungsebene ab, ohne dass eine spezielle Client-Konfiguration erforderlich ist. Clients müssen nicht wissen, dass der Proxy existiert. 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 Funktionalität ist nur auf Linux-Systemen und Android (arm64) verfügbar und erfordert zusätzliche Einrichtung (iptables, ip route, etc.)

Das Flag -T address gibt die Adresse des transparenten Proxy-Servers an

Es gibt drei Modi redirect, tproxy und tlocal (wie tproxy, aber fängt auch lokalen Datenverkehr ab), die mit dem Flag -M angegeben werden können

`redirect` (über NAT und SO_ORIGINAL_DST)

[Zurück]

In diesem Modus erfolgt das Proxying über die iptables-nat-Tabelle und das REDIRECT-Ziel. Der Host des eingehenden Pakets ändert sich zur Adresse des laufenden redirect-transparenten Proxys, enthält aber 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

Beispiel

[Zurück]```shell

run the proxy

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

Please provide the Markdown content to translate.```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf

Richten Sie Ihr Betriebssystem ein:```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

Verbindung testen:```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

Automatische Konfiguration für den `redirect`-Modus

[Zurück]

Um 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 generisch ist, was für Ihre Anforderungen möglicherweise nicht geeignet ist.

Optional können Sie `-mark <value>` angeben, um mögliche Proxy-Schleifen zu verhindern```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100

`tproxy` (über MANGLE und IP_TRANSPARENT)

[Zurück]

In diesem Modus erfolgt das Proxying über die iptables-mangle-Tabelle und das TPROXY-Target. Der transparente Proxy sieht die Zieladresse unverändert; sie wird nicht vom Kernel umgeschrieben. Damit dies funktioniert, bindet sich der Proxy mit der Socket-Option IP_TRANSPARENT, iptables fängt den Datenverkehr mithilfe des TPROXY-Targets ab, und Routing-Regeln weisen markierte Pakete an den lokalen Proxy weiter, ohne deren ursprüngliches Ziel zu ändern.

Dieser Modus erfordert erhöhte Rechte, um GoHPTS auszuführen. Sie können dies mit dem folgenden Befehl tun:```shell sudo setcap 'cap_net_admin+ep' ~/go/bin/gohpts

Um `GoHPTS` in diesem Modus auszuführen, verwendest du das `-T`-Flag 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

Examples

# Basic scan
scanner scan --target example.com

# Scan with custom output format
scanner scan --target example.com --format json --output results.json

# Authenticated scan
scanner scan --target example.com --token YOUR_API_TOKEN

# Verbose mode
scanner scan --target example.com --verbose

Configuration

The scanner can be configured using a configuration file located at ~/.scanner/config.yaml:

server:
  url: "http://localhost:8080"
  timeout: 30

scan:
  threads: 10
  timeout: 60
  user_agent: "Scanner/1.0"

output:
  format: "json"
  verbose: false

Environment Variables

Variable	Description
`SCANNER_SERVER_URL`	Server URL
`SCANNER_TOKEN`	Authentication token
`SCANNER_THREADS`	Number of threads
`SCANNER_TIMEOUT`	Request timeout in seconds
`SCANNER_LOG_LEVEL`	Log level: `debug`, `info`, `warn`, `error`

API Reference

Authentication

All API requests require an authentication token passed in the Authorization header:

Authorization: Bearer YOUR_API_TOKEN

Endpoints

`POST /api/v1/scan`

Start a new scan.

Request Body:

{
  "target": "example.com",
  "options": {
    "threads": 10,
    "timeout": 60
  }
}

Response:

{
  "scan_id": "abc123",
  "status": "running",
  "created_at": "2024-01-01T00:00:00Z"
}

`GET /api/v1/scan/{scan_id}`

Get scan status and results.

Response:

{
  "scan_id": "abc123",
  "status": "completed",
  "results": {
    "vulnerabilities": [],
    "summary": {
      "total": 0,
      "critical": 0,
      "high": 0,
      "medium": 0,
      "low": 0
    }
  }
}

`DELETE /api/v1/scan/{scan_id}`

Cancel or delete a scan.

Response:

{
  "scan_id": "abc123",
  "status": "cancelled"
}

Troubleshooting

Common Issues

Connection refused:

Error: connection refused to http://localhost:8080

Ensure the server is running and accessible.

Authentication failed:

Error: authentication failed (401 Unauthorized)

Verify your API token is correct and not expired.

Timeout errors:

Error: request timeout after 60s

Increase the timeout value or check network connectivity.

Debug Mode

Enable debug logging for detailed output:

scanner scan --target example.com --verbose --log-level debug

Getting Help

Check the FAQ
Open an issue
Join our Discord

Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Development Setup

# Clone the repository
git clone https://github.com/example/scanner.git
cd scanner

# Install dependencies
pip install -r requirements.txt

# Run tests
pytest tests/

# Run linter
flake8 scanner/

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Thanks to all contributors
Inspired by similar security tools
Built with Python and FastAPI```shell

run socks5 server on 127.0.0.1:1080

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

Automatische Konfiguration für den `tproxy`-Modus

[Zurück]

Um Ihr System automatisch zu konfigurieren, führen Sie den folgenden Befehl aus (zum Beispiel 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

UDP-Unterstützung

[Zurück]

GoHPTS bietet UDP-Unterstützung, die in den Modi tproxy und tlocal aktiviert werden kann. Damit dieses Setup funktioniert, müssen Sie sich mit einem SOCKS5-Server verbinden, der UDP-Verbindungen bedienen kann (UDP ASSOCIATE). Zum Beispiel 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 haben, mit dem Sie sich verbinden können, 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.

Um ihn lokal zu testen, können Sie den UDP-Transparent-Proxy mit dem `-arpspoof`-Flag kombinieren. Zum Beispiel:

1. Richten Sie eine VM auf Ihrem System mit einer beliebigen Linux-Distribution ein, die `tproxy` unterstützt (zum Beispiel Kali Linux).
2. Aktivieren Sie das `bridged`-Netzwerk, damit die VM auf Ihren Host-Rechner zugreifen kann.
3. Verschieben Sie das `gohpts`-Binary auf die VM (zum Beispiel via `ssh`) oder bauen Sie es dort, falls ein anderes OS/Arch vorliegt.
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"

Überprüfe die Verbindung auf deinem Host-Rechner, der Datenverkehr sollte über die Kali-Maschine laufen.

Android-Unterstützung

[Zurück]

Der transparente Proxy kann auf Android-Geräten (arm64) mit Root-Zugriff aktiviert werden. Du kannst Termux installieren und GoHPTS dort als CLI-Tool ausführen:```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"

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

Traffic-Sniffing

[Zurück]

MrGopher

Der GoHPTS-Proxy ermöglicht es, den Datenverkehr, der durch den Dienst läuft, zu erfassen und zu überwachen. Dieser Vorgang ist als traffic sniffing, packet sniffing oder einfach sniffing bekannt. Insbesondere versucht der Proxy zu erkennen, ob es sich um Klartext- (HTTP) oder TLS-Datenverkehr handelt, und nach der Identifizierung parst er die Anfrage-/Antwort-Metadaten und schreibt sie in die Datei oder auf die Konsole. Im Fall des GoHTPS-Proxys sehen die geparsten Metadaten wie folgt aus (TLS-Handshake):

JSON-Format

[Zurück]```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 die Angabe des -sniff-Flags zusammen mit den regulären Flags```shell gohpts -d -T 8888 -M redirect -sniff -j

Du kannst auch eine Datei angeben, in die der mitgeschnittene Datenverkehr geschrieben wird:```shell
gohpts -sniff -snifflog ~/sniff.log -j

Farbiges Format

[Zurück]

Sie können das Beispiel der farbigen Ausgabe im obigen Bild sehen. In diesem Modus versucht GoHPTS, wichtige Informationen hervorzuheben, wie TLS-Handshake, HTTP-Metadaten, etwas, das wie Login/Passwörter oder verschiedene Arten von Authentifizierungs- und geheimen Token aussieht. Die Ausgabe ist im Vergleich zu JSON eingeschränkt, aber für Menschen viel leichter zu lesen.

Um GoHPTS in diesem Modus auszuführen, verwenden Sie die folgenden Flags:```shell gohpts -sniff -body

Sie können Sniffing mit dem Transparent-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 unter Verwendung derselben Serveradresse und desselben TLS-Zertifikats. Dadurch können Clients automatisch das bestverfügbare Protokoll auswählen, ohne die Konfiguration zu ändern. Ein TLS-Zertifikat kann auf verschiedene Weise bezogen werden: von Cloud-Anbietern (Google, AWS, Cloudflare), als kostenloses Zertifikat von Let's Encrypt, oder Sie können ein selbstsigniertes Zertifikat mit `openssl` (Linux/macOS) oder `New-SelfSignedCertificate` (Windows) erstellen.

### Beispiel-Setup 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"

Socks5-Server mit UDP-ASSOCIATE-Unterstützung vorbereiten ```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
Öffnen Sie ein weiteres Terminal und installieren Sie den 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.

Abschließend:
1. Erstellen Sie eine minimale Konfiguration für Ihren 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

Starten Sie den Proxy: ```shell gohpts -f ./gohpts_config.yaml

2. Oder wenn Sie Kommandozeilenargumente bevorzugen:  ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body

Sie sollten etwa Folgendes 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

### Verbindung testen

[[Zurück]](#table-of-contents)

- Für einen HTTP/2-Proxy-Server können Sie `curl` verwenden:  ```shell
  curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://localhost:8080 "https://stream.wikimedia.org/v2/stream/recentchange"

Drücken Sie Ctrl+C, um den laufenden Stream zu stoppen.

Bei HTTP/3 ist es anders, da (zum Zeitpunkt des Schreibens) curl keinen HTTP3-Proxy unterstützt, daher werde ich meinen benutzerdefinierten Client verwenden, den ich zu Testzwecken erstellt habe.

Laden Sie das Simple HTTP3 to SOCKS5 proxy example herunter und installieren Sie 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

Du solltest etwas Kauderwelsch sehen, das einer HTML-Seite ähnelt.

Gehe zum Terminal-Tab mit dem `GoHPTS`-Proxy und prüfe die Logs, du solltest dort alle deine Anfragen sehen.

### Verbindung im Browser testen

[[Zurück]](#table-of-contents)

- Erstelle 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

Fügen Sie das neu erstellte rootCA.crt zum System-Truststore hinzu:
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

- Starten Sie den Proxy mit `server.crt` und `server.key`:  ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body

Starten Sie den Browser und rufen Sie eine beliebige Website auf: ```shell chromium --proxy-server="https://127.0.0.1:8080"

IPv4- und IPv6-Unterstützung

[Zurück]

Hinsichtlich der Verarbeitung auf der Netzwerkschicht kann GoHPTS in drei Modi betrieben werden: dual stack, IPv4-only und IPv6-only. Der Benutzer kann den Modus durch 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 werden, wird dual stack angenommen. Bitte beachten Sie, dass in den "only"-Modi nur IP-Adressen der jeweiligen Version erlaubt sind, alle Domains auf die jeweilige IP-Version aufgelöst werden (falls möglich), alle lauschenden Adressen dieselbe Version verwenden müssen 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, kannst du eine beliebige Linux-VM verwenden:

1. Auf deiner 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"

Auf Ihrem Host:```shell

run proxy on your host

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 `-6`-Flag hinzu, zum Beispiel bei der Verwendung mit einem transparenten Proxy:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6

Damit dies funktioniert, sollten dein ISP und der entfernte SOCKS5-Proxy aktive IPv6-Unterstützung haben. Du kannst https://test-ipv6.com/ besuchen, um herauszufinden, ob du auf IPv6-Adressen zugreifen kannst. Um den Proxy im IPv6-Modus zu testen, kannst du eine beliebige Linux-VM verwenden:

Auf deiner virtuellen Maschine:```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. Auf Ihrem Host:```shell
# run proxy on your host
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -6

Besuchen Sie eine beliebige Website auf Ihrer virtuellen Maschine und sehen Sie den Datenverkehr in den Proxy-Protokollen

ARP-Spoofing

[Zurück]

GoHPTS verfügt über einen integrierten ARP-Spoofer, mit dem alle TCP-fähigen Geräte in Ihrem LAN dazu gebracht werden können, den Proxy-Server für die Verbindung zum Internet zu verwenden. Dies wird erreicht, indem das Flag -arpspoof mit einigen Parametern hinzugefügt wird, die durch ein Semikolon getrennt sind.

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"

Proxy wird Geräte im Subnetz `192.168.10.0/24` scannen und ARP-Pakete an sie senden, um sich als Gateway auszugeben. Wenn `fullduplex` true ist,
wird der Proxy auch ARP-Pakete an das Gateway senden, um es glauben zu lassen, dass unser Proxy jede IP im Subnetz besitzt.

Nachdem der Proxy mit `Ctrl+C` gestoppt wurde, wird er automatisch das Spoofing für alle Ziele aufheben.

`GoHPTS` kann auch mit Tools wie [Bettercap](https://github.com/bettercap/bettercap) verwendet werden, um ARP-gespooften Datenverkehr zu proxien.

Führe 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ühre 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üfe die Proxy-Logs auf Datenverkehr von anderen Geräten aus deinem LAN

Weitere Informationen zu arpspoof-Optionen findest du unter `gohpts -h` und [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)

## NDP-Spoofing

[[Zurück]](#table-of-contents)

`GoHPTS` verfügt über eine integrierte Funktionalität zum Durchführen 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 einzurichten. In Kombination mit dem transparenten Proxy-Modus (TCP/UDP) ermöglicht NDP-Spoofing `gohpts`, den Datenverkehr für Clients in lokalen Netzwerken zu proxen. Wie beim [ARP-Spoofing](#arp-spoofing) kannst du NDP-Spoofing-Optionen mit einem einzigen `-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"

Weitere Informationen zu ndpspoof-Optionen finden Sie unter gohpts -h und https://github.com/shadowy-pycoder/ndpspoof

Bitte beachten Sie, dass einige Optionen wie rdnss, gateway, interface von gohpts selbst automatisch gesetzt werden, um ordnungsgemäß als Proxy zu funktionieren.

Da gohpts alle Verbindungen über einen Upstream-SOCKS5-Server weiterleitet, benötigen Sie einen funktionierenden Server mit IPv4/IPv6- und TCP/UDP-Unterstützung. Offensichtlich sollte eine entfernte Maschine (z. B. ein VPS) auch über eine funktionierende IPv6-Konnektivität verfügen. Selbstverständlich sollte die Maschine, auf der gohpts läuft, Teil eines Netzwerks mit IPv6-Unterstützung sein.

Beispiel-Setup, damit NDP-Spoofing korrekt funktioniert:

Verbindung zum VPS herstellen```shell ssh [email protected]

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

SOCKS5-Server einrichten (sicherstellen, dass Firewall-Regeln die verwendeten Ports nicht blockieren)```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. Gehen Sie zurück zu Ihrer Host-Maschine 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

Holen Sie sich ein anderes Gerät (Telefon, Tablet usw.) und verbinden Sie es mit demselben Netzwerk. Versuchen Sie, auf das Internet zuzugreifen, und prüfen Sie, ob Datenverkehr auf Ihrem Host-Rechner erscheint. Überprüfen Sie die öffentliche IP-Adresse mit einigen Online-Tools (sie sollte in diesem Fall mit Ihrer VPS-Adresse 203.0.113.10 oder der globalen IPv6-Adresse übereinstimmen)
Stoppen Sie den Proxy mit Strg+C
Profit!

DNS-Spoofing

[Zurück]

Um DNS-Filter durchzusetzen 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. Damit dies funktioniert, führen Sie einfach einen transparenten Proxy mit aktiviertem UDP aus und betreiben Sie zusätzlich ARP/NDP-Spoofing, damit die Ziele Ihren DNS-Server verwenden.

Die von GoHPTS erstellten DNS-Antworten sehen wie normale Pakete aus, die vom Router oder von vertrauenswürdigen DNS-Servern (Google, Cloudflare) kommen, was dazu führt, dass Clients ihren Cache mit dem aktualisieren, was Sie ihnen mitteilen. Beachten Sie jedoch, dass dies nur für „standardmäßigen" unverschlüsselten DNS-Datenverkehr funktioniert (DOT/DOH werden nicht gefiltert oder gespooft).

DNS-Filter und Domains für Spoofing können im Abschnitt dns_filter der YAML-Dateikonfiguration konfiguriert werden. Alle Listen akzeptieren URLs, Dateipfade und Einträge ähnlich denen, die üblicherweise in Hosts-Dateien zu finden sind, siehe https://en.wikipedia.org/wiki/Hosts_(file)>).

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

Use Cases:

- Werbe- und Tracker-Blocker für alle LAN-Geräte
- Kindersicherung durch Blockierung bestimmter Kategorien von Websites
- Blockierung bekannter Phishing- und Malware-Domains
- Verkehrsumleitung zur Analyse
- Erfassung von Anmeldedaten durch Umleitung
- Verkehrsentführung und -manipulation (Injizieren 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)

## Packet Capture

[[Zurück]](#table-of-contents)

Der Datenverkehr kann in den Formaten pcap, pcapng oder benutzerdefiniertem txt 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 Rechte verfügt, um Rohpakete erfassen zu können. Sie haben zwei Möglichkeiten:

- Führen Sie einmalig `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` aus, um dem Proxy Rohdatenverkehrszugriff 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 Paketmitschnittdateien 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 einzelnen Netzwerk-Namespace, aber dies kann überschrieben werden. Lauschende 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 es 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, die sich im Verzeichnis `/etc/netns/NAME/` befinden. 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 Google-DNS-Server zur Auflösung von Domänennamen verwendet.

Wenn Ihr System systemd-resolved.service (8) aktiviert hat, möchten Sie es möglicherweise 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 persistent für eine bestimmte Shell-Instanz:```shell
sudo ip netns exec ns1 unshare --mount bash -c '
    mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve
    exec bash --login'

Playground-Einrichtung

[Zurück]

Socks5-Server mit UDP-ASSOCIATE-Unterstützung ausführen ```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
Laden Sie das Simple HTTP3 to SOCKS5 proxy example herunter und installieren Sie es: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git cd http3-socks-proxy make
Repository klonen und kompilieren ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make
key.pem- und cert.pem-Dateien erstellen: ```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"
Netzwerk-Namespace ns1 erstellen und veth-Netzwerk konfigurieren ```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
Ermittle die IP-Adresse von wlan0, um sich mit dem lokalen SOCKS5 verbinden zu können ```shell WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')

Anwendungsbeispiele

[Zurück]

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 über 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 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 stellen ```shell sudo ip netns exec ns1 curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://127.0.0.1:8083 https://example.com

Request 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 senden ```shell sudo ip netns exec ns1 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com

Request sollte erfolgreich sein

4. **Transparenter Redirect-Proxy (`-M redirect`) – Proxy-Listener in `ns1` (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 -nohttp -M redirect -T :8888 -auto

Anfrage über ns1 senden ```shell sudo ip netns exec ns1 curl -Nv https://example.com

Anfrage sollte fehlschlagen

Standardroute zu `ns1` hinzufügen   ```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

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

Nun 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

Request 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

Anfrage über Host stellen ```shell ./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com

Request sollte erfolgreich sein

7. **Transparenter Redirect-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 stellen ```shell curl -Nv https://example.com

Request sollte erfolgreich sein

8. **HTTP-Proxy - LAN (`ns2` (Proxy-Listener), `ns3`, `ns4`), ausgehende Sockets in `ns1` (Standardroute, Internetzugang)**

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 Redirect-Proxy - 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 vorherige 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, `-nosocks`-Flag**

 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`, `-nosocks`-Flag**

 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 SOCKS-Verbindungen auf derselben Adresse wie der HTTP-Server lauscht. Fügen Sie einfach das `-mixed`-Flag hinzu, um einen zusätzlichen SOCKS-Server zu starten. Dadurch kann `GoHPTS` nicht nur als `HTTP-to-SOCKS`-Proxy, sondern auch als `SOCKS-to-SOCKS`-Proxy fungieren. Der lokale SOCKS5-Server unterstützt den `UDP ASSOCIATE`-Befehl, sodass Benutzer technisch gesehen UDP-Datagramme mit diesem gemischten Server senden können.

Proxy ausführen:```shell
gohpts -s :1080 -l :8080 -mixed

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

Oder deaktiviere den vorgelagerten SOCKS-Proxy und verbinde dich direkt, indem du `-nosocks` hinzufügst:```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

[[Zurück]](#table-of-contents)

Erfahren Sie mehr über transparente Proxies, indem Sie die folgenden Links besuchen:

- [Transparent proxy support in Linux Kernel](https://docs.kernel.org/networking/tproxy.html)
- [Transparent proxy tutorial by Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Simple tproxy example](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Transparent Proxy Implementation using eBPF and Go](https://medium.com/all-things-ebpf/building-a-transparent-proxy-with-ebpf-50a012237e76)
- [https://github.com/heiher/hev-socks5-tproxy](https://github.com/heiher/hev-socks5-tproxy)

  `socks5` proxy with `UDP ASSOCIATE` support:

- [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 network security:

- [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/)

## Contributing

[[Zurück]](#table-of-contents)

Sind Sie Entwickler?

- Forken Sie das Repository
- Erstellen Sie Ihren Feature-Branch: `git switch -c my-new-feature`
- Committen Sie Ihre Änderungen: `git commit -am 'Add some feature'`
- Pushen Sie in den Branch: `git push origin my-new-feature`
- Reichen Sie einen Pull-Request ein

## License

[[Zurück]](#table-of-contents)

GPLv3

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

GoHPTS - HTTP(S)- und TCP/UDP-transparenter Proxy zu SOCKS4/SOCKS5-Proxy (Kette), geschrieben in Go

Inhaltsverzeichnis

Einführung

Funktionen

Installation

Verwendung

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

Transparenter Proxy

redirect (über NAT und SO_ORIGINAL_DST)

Beispiel

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

Automatische Konfiguration für den redirect-Modus

tproxy (über MANGLE und IP_TRANSPARENT)

Examples

Configuration

Environment Variables

API Reference

Authentication

Endpoints

POST /api/v1/scan

GET /api/v1/scan/{scan_id}

DELETE /api/v1/scan/{scan_id}

Troubleshooting

Common Issues

Debug Mode

Getting Help

Contributing

Development Setup

License

Acknowledgments

run socks5 server on 127.0.0.1:1080

Automatische Konfiguration für den tproxy-Modus

UDP-Unterstützung

Android-Unterstützung

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

JSON-Format

Farbiges Format

gohpts_config.yaml

IPv4- und IPv6-Unterstützung

run proxy on your host

add your host machine as gateway IPv6 for VM

`redirect` (über NAT und SO_ORIGINAL_DST)

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

create `GOHPTS` nat chain

Automatische Konfiguration für den `redirect`-Modus

`tproxy` (über MANGLE und IP_TRANSPARENT)

`POST /api/v1/scan`

`GET /api/v1/scan/{scan_id}`

`DELETE /api/v1/scan/{scan_id}`

Automatische Konfiguration für den `tproxy`-Modus