Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
go-http-proxy-to-socks — CLI-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. | Kitploit
Tools/GitHubGitHub/shadowy-pycoder/go-http-proxy-to-socks
Paket-Sniffing & AnalyseWeb-Proxys & AbfangenIDS/IPS-UmgehungNetzwerksicherheitPenetrationstestsDienstprogramme & FrameworksDNS-FuzzingRed TeamingDNS-Analyse
GitHubshadowy-pycoder/go-http-proxy-to-socks

go-http-proxy-to-socks

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

Repository anzeigen
693119vor 2 MonatenVon Kitploit geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    906
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    725
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    442
  • 4

    wifit3

    derv82/wifit3

    Wifite, aber nur USB & plattformübergreifend.

    434
  • 5

    jumpserver

    jumpserver/jumpserver

    JumpServer ist eine Open-Source-Plattform für Privileged Access Management (PAM), die DevOps- und IT-Teams bedarfsgesteuerten und sicheren Zugriff auf SSH-, RDP-, Kubernetes-, Datenbank- und RemoteApp-Endpunkte über einen Webbrowser bietet.

    412
  • 6

    SafeLine

    chaitin/safeline

    Selbst gehosteter WAF und Reverse Proxy, der bösartigen HTTP-Verkehr filtert, SQL-Injection, XSS und Bot-Angriffe blockiert, mit Ratenbegrenzung und dynamischer HTML/JS-Verschlüsselung.

    360

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen
# GoHPTS - HTTP(S)- und TCP/UDP-transparenter Proxy zu SOCKS4/SOCKS5-Proxy (Kette), geschrieben in Go

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

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

## Inhaltsverzeichnis

- [Einführung](#introduction)
- [Funktionen](#features)
- [Installation](#installation)
- [Verwendung](#usage)
  - [Konfiguration über CLI-Flags](#configuration-via-cli-flags)
  - [Konfiguration über YAML-Datei](#configuration-via-yaml-file)
- [Transparenter Proxy](#transparent-proxy)
  - [redirect (über NAT und SO_ORIGINAL_DST)](#redirect-via-nat-and-so_original_dst)
  - [Automatische Konfiguration für den redirect-Modus](#auto-configuration-for-redirect-mode)
  - [tproxy (über MANGLE und IP_TRANSPARENT)](#tproxy-via-mangle-and-ip_transparent)
  - [Automatische Konfiguration für den tproxy-Modus](#auto-configuration-for-tproxy-mode)
  - [UDP-Unterstützung](#udp-support)
  - [Android-Unterstützung](#android-support)
  - [YAML-Konfiguration](#yaml-configuration)
- [Verkehrsanalyse (Traffic Sniffing)](#traffic-sniffing)
  - [JSON-Format](#json-format)
  - [Farbiges Format](#colored-format)
- [HTTP2- und HTTP3-Unterstützung](#http2-and-http3-support)
  - [Beispiel-Setup mit selbstsigniertem Zertifikat](#example-setup-using-self-signed-certificate)
  - [Verbindung testen](#test-connection)
  - [Verbindung im Browser testen](#test-connection-in-a-browser)
- [IPv4- und IPv6-Unterstützung](#ipv4-and-ipv6-support)
- [ARP-Spoofing](#arp-spoofing)
- [NDP-Spoofing](#ndp-spoofing)
- [DNS-Spoofing](#dns-spoofing)
- [Paketaufzeichnung](#packet-capture)
- [Netzwerk-Namespaces](#network-namespaces)
  - [Playground-Setup](#playground-setup)
  - [Verwendungsbeispiele](#usage-examples)
- [Gemischter Server](#mixed-server)
- [Links](#links)
- [Mitwirken](#contributing)
- [Lizenz](#license)

## Einführung

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

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](https://github.com/oyyd/http-proxy-to-socks) und [Proxychains](https://github.com/rofl0r/proxychains-ng)

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 <remote server> -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]](#table-of-contents)

- **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]](#table-of-contents)

- 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](https://go.dev/doc/install) 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]](#table-of-contents)```shell
gohpts -h
   _____       _    _ _____ _______ _____
  / ____|     | |  | |  __ \__   __/ ____|
 | |  __  ___ | |__| | |__) | | | | (___
 | | |_ |/ _ \|  __  |  ___/  | |  \___ \
 | |__| | (_) | |  | | |      | |  ____) |
  \_____|\___/|_|  |_|_|      |_| |_____/

GoHPTS: HTTP(S) Proxy to SOCKS4/SOCKS5 proxy by shadowy-pycoder
GitHub: https://github.com/shadowy-pycoder/go-http-proxy-to-socks
Codeberg: https://codeberg.org/shadowy-pycoder/go-http-proxy-to-socks

Usage: gohpts [OPTIONS]
OPTIONS:
  General:
  -h         Show this help message and exit
  -v         Show version and build information
  -D         Run as a daemon (provide -logfile to see logs)
  -I         Display list of network interfaces and exit
  -f         Path to proxy configuration file in YAML format

  Proxy:
  -l         Address of HTTP proxy server (Default: "127.0.0.1:8080" for IPv4, "[::1]:8080" for IPv6)
  -s         Address of SOCKS proxy server (Default: "127.0.0.1:1080" for IPv4 "[::1]:1080" for IPv6)
  -c         Path to certificate PEM encoded file
  -k         Path to private key PEM encoded file
  -U         User for HTTP proxy (basic auth). This flag invokes prompt for password (not echoed to terminal)
  -u         User for SOCKS proxy authentication. This flag invokes prompt for password (not echoed to terminal)
  -i         Bind proxy to specific network interface (either by interface name or index)
  -4         Force IPv4 stack for TCP and UDP (Default: dual stack)
  -6         Force IPv6 stack for TCP and UDP (Default: dual stack)
  -socks4    Use SOCKS4/SOCKS4a protocol for upstream proxy and mixed server (default: SOCKS5/SOCKS5h)
  -nohttp    Disable HTTP proxy server
  -nosocks   Disable SOCKS upstream proxy
  -dns       Use custom DNS server (Example: "8.8.8.8" or "2001:4860:4860::8888")
  -mixed     Accept SOCKS connections on HTTP proxy server address

  Logs:
  -d         Show logs in DEBUG mode
  -j         Show logs in JSON format
  -logfile   Log file path (Default: stdout)
  -nocolor   Disable colored output for logs (no effect if -j flag specified)
  -pprof     Address of pprof server with profiling data

  Sniffing:
  -sniff     Enable traffic sniffing for HTTP and TLS
  -snifflog  Sniffed traffic log file path (Default: the same as -logfile)
  -body      Collect request and response body for HTTP traffic (credentials, tokens, etc)

  TProxy:
  -T         Address of transparent proxy server
  -Tu        Address of transparent UDP proxy server
  -M         Transparent proxy mode: (redirect, tproxy, tlocal)
  -w         Number of instances of transparent proxy server (Default: number of CPU cores)
  -wu        Number of instances of transparent UDP proxy server (Default: number of CPU cores)
  -auto      Automatically setup iptables and kernel parameters for transparent proxy (requires elevated privileges)
  -mark      Set mark for each packet sent through transparent proxy (Default: redirect 0, tproxy 100, tlocal 100)
  -A         Comma separated list of allowed ip addresses for proxying (Example: "8.8.8.8,2001:4860:4860::8888,192.168.1.0/24")
  -P         Comma separated list of ports to ignore when proxying traffic (Example: "22,80,443,9092")
  -dump      Dump iptables rules and other system settings generated by -auto flag

  Spoofing:
  -arpspoof  Enable ARP spoof proxy for selected targets (Example: "targets 10.0.0.1,10.0.0.5-10,192.168.1.*,192.168.10.0/24;fullduplex false;debug true;interval 10s")
  -ndpspoof  Enable NDP spoof proxy for selected targets (Example: "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true;interval 10s")

  Packet Capture:
  -pcap      Enable packet capture (Example: "promisc true;expr ip proto tcp;snaplen 65535;timeout 10s;packet_count 100;packet_buffer 8192;exts txt,pcap,pcapng")

  Namespaces:
  -in-netns  Name or path of network namespace for inbound listeners (Default: default namespace)
  -out-netns Name or path of network namespace for outbound connections (Default: default namespace)
```
### 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 <pid>
#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](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/resources/example_gohpts.yaml)

Um mehr über Proxy-Ketten zu erfahren, besuchen Sie [Proxychains Github](https://github.com/rofl0r/proxychains-ng)

## Transparenter Proxy

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

> 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](https://en.wikipedia.org/wiki/Proxy_server)_

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]](#table-of-contents)

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]](#table-of-contents)```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
```
| `--no-color` | Deaktiviert farbige Ausgabe |
| `--verbose` | Aktiviert ausführliche Ausgabe |
| `--quiet` | Unterdrückt alle Ausgaben außer Fehlern |
| `--config` | Gibt eine benutzerdefinierte Konfigurationsdatei an |
| `--output` | Schreibt die Ausgabe in eine Datei |```shell
#traffic should be redirected via 127.0.0.1:8080
curl --proxy http://127.0.0.1:8080 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]](#table-of-contents)

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]](#table-of-contents)

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
```
| `-s` | `--server` | Server URL (default: `http://localhost:8080`) |
| `-t` | `--token` | Authentication token |
| `-o` | `--output` | Output file path |
| `-f` | `--format` | Output format: `json`, `yaml`, `table` |
| `-v` | `--verbose` | Enable verbose logging |
| `-q` | `--quiet` | Suppress non-error output |
| `-h` | `--help` | Show help message |
| `-V` | `--version` | Show version information |

### Examples

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

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

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

**Response:**

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

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

Get scan status and results.

**Response:**

```json
{
  "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:**

```json
{
  "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:

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

### Getting Help

- Check the [FAQ](https://github.com/example/scanner/wiki/FAQ)
- Open an [issue](https://github.com/example/scanner/issues)
- Join our [Discord](https://discord.gg/example)

## Contributing

We welcome contributions! Please see [CONTRIBUTING.md](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/CONTRIBUTING.md) for guidelines.

### Development Setup

```bash
# 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](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/LICENSE) file for details.

## Acknowledgments

- Thanks to all contributors
- Inspired by similar security tools
- Built with [Python](https://python.org) and [FastAPI](https://fastapi.tiangolo.com)```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]](#table-of-contents)

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]](#table-of-contents)

`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](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"
```
5. Überprüfe die Verbindung auf deinem Host-Rechner, der Datenverkehr sollte über die Kali-Maschine laufen.

### Android-Unterstützung

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

Der transparente Proxy kann auf Android-Geräten (arm64) mit Root-Zugriff aktiviert werden. Du kannst [Termux](https://github.com/termux/termux-app) 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]](#table-of-contents)

<p align="center"><img alt="MrGopher" src="https://assets.kitploit.com/production/public/readmes/11401/ac38691c0f511a6265baf784c236e4ca9557e6c2b7744271f09b1b657af92ca7.png"/>

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]](#table-of-contents)```json
[
  {
    "connection": {
      "tproxy_mode": "redirect",
      "src_local": "127.0.0.1:8888",
      "src_remote": "192.168.0.107:51142",
      "dst_local": "127.0.0.1:56256",
      "dst_remote": "127.0.0.1:1080",
      "original_dst": "216.58.209.206:443"
    }
  },
  {
    "tls_request": {
      "sni": "www.youtube.com",
      "type": "Client hello (1)",
      "version": "TLS 1.2 (0x0303)",
      "session_id": "2670a6779b4346e5e84d46890ad2aaf7a53b08adcfe0c9f6868c2d9882242e39",
      "cipher_suites": [
        "TLS_AES_128_GCM_SHA256 (0x1301)",
        "TLS_CHACHA20_POLY1305_SHA256 (0x1303)",
        "TLS_AES_256_GCM_SHA384 (0x1302)",

---

[Read more](https://github.com/shadowy-pycoder/go-http-proxy-to-socks)
Tool herunterladen