go-http-proxy-to-socks — Proxy CLI MITM que converte SOCKS4/SOCKS5 em proxy HTTP/HTTPS/HTTP2/HTTP3 com redirecionamento transparente de TCP/UDP, spoofing ARP/NDP/DNS, sniffing de tráfego e captura de pacotes. Puramente em Go, sem libpcap. | Kitploit

- Baixe o binário para a sua plataforma na página de [Releases](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases):  ```shell
GOHPTS_RELEASE=v1.15.6; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-linux-amd64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-linux-amd64 gohpts && ./gohpts -h

Instale usando o comando go install (requer Go 1.26 ou posterior): ```shell CGO_ENABLED=0 go install -ldflags "-s -w" -trimpath github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest

Compilar a partir do código-fonte: ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make build ./bin/gohpts
Executar no docker: ```shell docker run -it --privileged --network host -v "$PWD/gohpts.yaml:/config.yaml" shadowypycoder/gohpts:latest -f config.yaml

Quando ambos `-u` e `-U` estão presentes, você será solicitado duas vezes

Executar proxy http sobre conexão TLS```shell
gohpts -s 1080 -l 8080 -c "path/to/certificate" -k "path/to/private/key"

`-u` e `-U` não funcionam em modo daemon (e, portanto, na autenticação), mas você pode fornecer um arquivo de configuração (veja abaixo)

### Configuração via arquivo YAML

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

Arquivos de configuração são úteis quando você quer pré-configurar seu proxy sem mexer muito na CLI ou apenas quer múltiplos perfis para necessidades diferentes.

Executar proxy http em modo de cadeia de proxy SOCKS5 (especifique as configurações do servidor via arquivo de configuração YAML)```shell
gohpts -f "~/gohtps.yaml" -d -j

Você pode substituir quase todas as configurações especificadas no arquivo de configuração fornecendo os sinalizadores CLI correspondentes:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor

I'll analyze this request carefully. The user is asking me to translate a chunk of a README document from English to Portuguese, following specific rules about preserving Markdown structure and not translating code/technical identifiers.

However, looking at the actual content provided, the "INPUT:" section is empty. There is no actual text to translate. The chunk header says "chunk 43 of 241" but no content follows the "INPUT:" label.

Since there is no source text provided to translate, I cannot produce a translation. I should not fabricate content, add headings, or generate placeholder text.

The correct response is to indicate that no content was provided. But the instructions say to return ONLY the translated text with no preamble or commentary. Since there's nothing to translate, the appropriate output is empty or a minimal indication.

Given the constraints, I'll return nothing meaningful since there's no content. But I need to respond somehow. The most honest response given empty input is to note there's no content, but the rules forbid commentary.

I'll return an empty response, as there is no text to translate.```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf

Desfazer tudo:```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

Observe que a configuração automática requer `sudo` e é muito genérica, o que pode não ser adequado às suas necessidades.

Opcionalmente, você pode especificar `-mark <value>` para evitar possíveis loops de proxy```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100

Para executar o `GoHPTS` neste modo, você usa a flag `-T` com `-M tproxy`

### Exemplo

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

Configure seu sistema operacional:```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

Execute o seguinte no seu host:```shell
ip route show default > /tmp/default-route.txt

ip route add 0.0.0.0/1 via 192.168.0.1 # change with ip of your VM
ip route add 128.0.0.0/1 via 192.168.0.1

Desfazer tudo:```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

Este comando irá configurar o seu sistema operativo e configurar o servidor no endereço `0.0.0.0:8989`.

Para o testar localmente, pode combinar o proxy transparente UDP com a flag `-arpspoof`. Por exemplo:

1. Configure uma VM no seu sistema com qualquer distribuição Linux que suporte `tproxy` (Kali Linux, por exemplo).
2. Ative a rede `bridged` para que a VM possa aceder à sua máquina anfitriã.
3. Mova o binário `gohpts` para a VM (via `ssh`, por exemplo) ou compile-o lá em caso de OS/arch diferentes.
4. Na sua VM, execute o seguinte comando:```shell
# Do not forget to replace <socks5 server> and <your host> with actual addresses
sudo ./gohpts -s <socks5 server> -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "targets <your host>;fullduplex true;debug false"

### Configuração YAML

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

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

E requisição HTTP com 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"]
      }
    }
  }
]

## Suporte a HTTP2 e HTTP3

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

O proxy `GoHPTS` lida com requisições HTTP/1.1, HTTP/2 e HTTP/3 usando o mesmo endereço de servidor e certificado TLS. Isso permite que os clientes escolham automaticamente o melhor protocolo disponível sem alterar a configuração. O certificado TLS pode ser obtido de várias formas: provedores de nuvem (Google, AWS, Cloudflare), certificado gratuito do Let's Encrypt, ou você pode criar um certificado autoassinado usando `openssl` (Linux/macOS) ou `New-SelfSignedCertificate` (Windows).

### Exemplo de configuração usando certificado autoassinado

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

- Crie os arquivos `key.pem` e `cert.pem`:  ```shell
  openssl req -x509 -newkey rsa:2048 \
  -keyout key.pem \
  -out cert.pem \
  -sha256 \
  -days 365 \
  -nodes \
  -subj "/C=XX/ST=StateName/L=CityName/O=CompanyName/OU=CompanySectionName/CN=127.0.0.1" \
  -addext "subjectAltName=IP:127.0.0.1"

Preparar servidor socks5 com suporte a UDP ASSOCIATE ```shell git clone https://github.com/wzshiming/socks5.git && cd socks5 go build -o socks5_server ./cmd/socks5/main.go ./socks5_server -a 0.0.0.0:1080
Abra outro terminal e instale o proxy GoHPTS: ```shell go install github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest

Por fim:
1. Crie uma configuração mínima para o seu 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

### Testar conexão

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

- Para servidor proxy HTTP/2 você pode usar `curl`:  ```shell
  curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://localhost:8080 "https://stream.wikimedia.org/v2/stream/recentchange"

Para HTTP/3 é diferente, pois (no momento em que este texto foi escrito) o curl não suporta proxy HTTP3, então usarei meu cliente personalizado que criei para fins de teste.

Baixe e instale o Exemplo simples de proxy HTTP3 para SOCKS5: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make

Você deve ver algum texto sem sentido semelhante a uma página HTML.

Vá para a aba do terminal com o proxy `GoHPTS` e verifique os logs, você deve ver todas as suas requisições lá.

### Testar conexão em um navegador

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

- Crie um certificado autoassinado adequado para o navegador:  ```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

Adicione o rootCA.crt recém-criado ao armazenamento de confiança do sistema:
1. Debian/Ubuntu: ```shell sudo cp rootCA.crt /usr/local/share/ca-certificates/rootCA.crt sudo update-ca-certificates

Para testar o proxy em modo IPv4, você pode usar qualquer VM Linux:

1. Na sua máquina virtual:```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"

3. Visite qualquer site na sua máquina virtual e veja o tráfego nos logs do proxy

Para ativar o modo `IPv6-only`, basta adicionar a flag `-6`, por exemplo, ao usar com proxy transparente:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6

O proxy irá escanear dispositivos na sub-rede `192.168.10.0/24` e enviar-lhes pacotes ARP para se passar por gateway; se `fullduplex` for true,
o proxy também enviará pacotes ARP ao gateway para fazê-lo acreditar que o nosso proxy tem cada IP na sub-rede.

Depois de o proxy ser parado com `Ctrl+C`, ele irá automaticamente desfazer o spoof de todos os alvos.

O `GoHPTS` também pode ser usado com ferramentas como [Bettercap](https://github.com/bettercap/bettercap) para fazer proxy de tráfego com ARP spoofing.

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

Verifique os logs do proxy para tráfego de outros dispositivos da sua LAN

Para mais informações sobre as opções do arpspoof, consulte `gohpts -h` e [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)

## NDP spoofing

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

O `GoHPTS` possui funcionalidade integrada para realizar NDP spoofing em redes IPv6 com pacotes Router Advertisement (RA) e Neighbor Advertisement (NA). Também inclui a opção RDNSS em pacotes RA para definir o host como um nameserver IPv6 para os clientes afetados. Quando combinado com o modo proxy transparente (TCP/UDP), o NDP spoofing permite que o `gohpts` faça proxy do tráfego para clientes nas redes locais. Assim como no caso do [ARP spoofing](#arp-spoofing), você pode definir as opções de ndp spoof com uma única flag `-ndpspoof`:

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

2. Instalar dependências```shell
GO_VERSION=$(curl 'https://go.dev/VERSION?m=text' | head -n1)
cd ~/Downloads/ && wget https://go.dev/dl/$GO_VERSION.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf $GO_VERSION.linux-amd64.tar.gz

4. Volte para a sua máquina host e instale o `gohpts` (consulte [Instalação](#installation))

5. Execute o `gohtps`:```shell
gohpts -s 203.0.113.10:3000 -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -mark 100 -arpspoof "fullduplex true;debug true" -ndpspoof "ra true;debug true" -4 -6 -d

Casos de uso:

- Bloqueador de anúncios e rastreadores para todos os dispositivos da LAN
- Controle parental através do bloqueio de categorias específicas de sites
- Bloquear domínios conhecidos de phishing e malware
- Redirecionamento de tráfego para análise
- Coleta de credenciais através de redirecionamento
- Sequestro e manipulação de tráfego (injetar anúncios, scripts, rastreamento)
- Vigilância e criação de perfis

Configuração mínima para esta configuração:```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"]

Mais informações podem ser encontradas aqui: [https://en.wikipedia.org/wiki/DNS_spoofing](https://en.wikipedia.org/wiki/DNS_spoofing)

## Captura de Pacotes

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

O tráfego pode ser capturado nos formatos pcap, pcapng ou txt personalizado e posteriormente analisado com ferramentas como Wireshark, tcpdump e muitas outras.

Primeiro, certifique-se de que o executável `GoHPTS` tenha privilégios elevados para poder capturar pacotes brutos; você tem duas opções:

- Execute `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` uma vez para conceder ao proxy acesso ao tráfego bruto
- Execute o proxy com `sudo` quando precisar especificar a flag `-pcap` na CLI ou `pcap.enabled` na configuração do arquivo.

Configure o proxy usando a CLI:```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"

Esses comandos produzem três arquivos de captura de pacotes com formatos correspondentes que posteriormente podem ser analisados por várias ferramentas.

Para mais informações sobre as opções do pcap, consulte `gohpts -h` e [https://github.com/shadowy-pycoder/mshark](https://github.com/shadowy-pycoder/mshark)

## Network Namespaces

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

Por padrão, o proxy `GoHPTS` é executado dentro de um único network namespace, mas isso pode ser sobrescrito. Sockets de escuta (por exemplo, servidor http ou servidor proxy transparente) e sockets de saída (proxy socks ou discador direto) criados pelo `GoHPTS` podem ser isolados com [network_namespaces (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html) do Linux/Android. Ao iniciar o processo do proxy, os usuários podem especificar as flags `-in-netns` (listeners) e `-out-netns` (dialers) com o nome ou caminho para o network namespace para controlar em qual ambiente isolado criar os sockets. Se você quiser criar listeners ou dialers no namespace atual (padrão), basta omitir a flag. Para especificar explicitamente o namespace do host, você pode usar o caminho `/proc/1/ns/net` - isso permite que o proxy identifique corretamente os nameservers do sistema.

O `GoHPTS` suporta a convenção [ip-netns (8)](https://man7.org/linux/man-pages/man8/ip-netns.8.html) para fornecer configuração de rede por meio de arquivos localizados no diretório `/etc/netns/NAME/`. Então, para especificar nameservers personalizados para o network namespace `ns1`, você faz o seguinte:```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

Ou torne-o persistente para uma instância específica do shell:```shell
sudo ip netns exec ns1 unshare --mount bash -c '
    mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve
    exec bash --login'

Executar servidor socks5 com suporte a UDP ASSOCIATE ```shell git clone https://github.com/wzshiming/socks5.git && cd socks5 go build -o socks5_server ./cmd/socks5/main.go ./socks5_server -a 0.0.0.0:1080
Baixe e instale o Exemplo simples de proxy HTTP3 para SOCKS5: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git cd http3-socks-proxy make
Clone o repositório e compile ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make
Crie os arquivos key.pem e cert.pem: ```shell openssl req -x509 -newkey rsa:2048
-keyout key.pem
-out cert.pem
-sha256
-days 365
-nodes
-subj "/C=XX/ST=StateName/L=CityName/O=CompanyName/OU=CompanySectionName/CN=127.0.0.1"
-addext "subjectAltName=IP:127.0.0.1"
Crie um namespace de rede ns1 e configure a rede veth ```shell sudo ip netns add ns1 sudo ip link add dev veth0 type veth peer name veth1 netns ns1 sudo ip addr add 10.0.0.1/24 dev veth0 sudo ip -6 addr add fd12:3456:789a::1/64 dev veth0 sudo ip link set dev veth0 up sudo ip netns exec ns1 ip addr add 10.0.0.2/24 dev veth1 sudo ip netns exec ns1 ip -6 addr add fd12:3456:789a::2/64 dev veth1 sudo ip netns exec ns1 ip link set dev lo up sudo ip netns exec ns1 ip link set dev veth1 up
Determine o endereço IP de wlan0 para conseguir conectar ao socks5 local ```shell WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')

Proxy HTTP - listeners de proxy em ns1 (sem rota padrão, sem acesso à internet), sockets de saída no host

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

A requisição deve ser bem-sucedida

2. **Proxy HTTP2 - listeners de proxy em `ns1` (sem rota padrão, sem acesso à internet), sockets de saída no host**

Executar o proxy:   ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1 -c ./cert.pem -k ./key.pem

A requisição deve ser bem-sucedida

3. **Proxy HTTP3 - listeners de proxy em `ns1` (sem rota padrão, sem acesso à internet), sockets de saída no host**

Executar o proxy:   ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1 -c ./cert.pem -k ./key.pem

A requisição deve ser bem-sucedida

4. **Proxy transparente de redirecionamento (`-M redirect`) - listeners de proxy em `ns1` (rota padrão, sem acesso à internet), sockets de saída no host**

Executar o proxy:   ```shell
sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1 -nohttp -M redirect -T :8888 -auto

A requisição deve falhar

Adicione a rota padrão ao `ns1`   ```shell
sudo ip netns exec ns1 ip route add default via 10.0.0.1
sudo ip netns exec ns1 ip -6 route add default via fd12:3456:789a::1

Agora a requisição deve ter sucesso

5. **Proxy HTTP - listeners de proxy no host, sockets de saída em `ns1` (rota padrão, acesso à internet)**

Adicione regras NAT para permitir que `ns1` se conecte à internet via `wlan0`   ```shell
sudo iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o wlan0 -j MASQUERADE
sudo ip6tables -t nat -A POSTROUTING -s fd12:3456:789a::/64 -o wlan0 -j MASQUERADE

Proxy HTTP3 - listeners de proxy no host, sockets de saída em ns1 (rota padrão, acesso à internet)

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

A requisição deve ser bem-sucedida

7. **Proxy transparente de redirecionamento - listeners de proxy no host, sockets de saída em `ns1` (rota padrão, acesso à internet)**

Execute o proxy (`-auto` não funciona com servidor socks5 local para mim, então uso um remoto):   ```
sudo ./bin/gohpts -s <remote> -4 -6 -d -sniff -body -out-netns ns1 -nohttp -M redirect -T :8888 -auto

A requisição deve ser bem-sucedida

8. **Proxy HTTP - LAN (`ns2` (listeners do proxy), `ns3`, `ns4`), sockets de saída em `ns1` (rota padrão, acesso à internet)**

Criar LAN   ```shell
sudo ip link add br0 type bridge
sudo ip addr add 10.0.1.1/24 dev br0
sudo ip -6 addr add fd12:3456:789b::1/64 dev br0
sudo ip link set br0 up

sudo ip netns add ns2
sudo ip link add veth2 type veth peer name veth3 netns ns2
sudo ip link set veth2 master br0
sudo ip link set veth2 up
sudo ip netns exec ns2 ip addr add 10.0.1.2/24 dev veth3
sudo ip netns exec ns2 ip -6 addr add fd12:3456:789b::2/64 dev veth3
sudo ip netns exec ns2 ip link set lo up
sudo ip netns exec ns2 ip link set veth3 up
sudo ip netns exec ns2 ip route add default via 10.0.1.1
sudo ip netns exec ns2 ip -6 route add default via fd12:3456:789b::1

sudo ip netns add ns3
sudo ip link add veth4 type veth peer name veth5 netns ns3
sudo ip link set veth4 master br0
sudo ip link set veth4 up
sudo ip netns exec ns3 ip addr add 10.0.1.3/24 dev veth5
sudo ip netns exec ns3 ip -6 addr add fd12:3456:789b::3/64 dev veth5
sudo ip netns exec ns3 ip link set lo up
sudo ip netns exec ns3 ip link set veth5 up
sudo ip netns exec ns3 ip route add default via 10.0.1.1
sudo ip netns exec ns3 ip -6 route add default via fd12:3456:789b::1

sudo ip netns add ns4
sudo ip link add veth6 type veth peer name veth7 netns ns4
sudo ip link set veth6 master br0
sudo ip link set veth6 up
sudo ip netns exec ns4 ip addr add 10.0.1.4/24 dev veth7
sudo ip netns exec ns4 ip -6 addr add fd12:3456:789b::4/64 dev veth7
sudo ip netns exec ns4 ip link set lo up
sudo ip netns exec ns4 ip link set veth7 up
sudo ip netns exec ns4 ip route add default via 10.0.1.1
sudo ip netns exec ns4 ip -6 route add default via fd12:3456:789b::1

Fazer requisições   ```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

Proxy HTTP3 - LAN (ns2 (listeners do proxy), ns3, ns4), sockets de saída em ns1 (rota padrão, acesso à internet)

Executar proxy: ``` sudo ./bin/gohpts -s $WLAN_IP:1080 -l 0.0.0.0:8083 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1 -c ./cert.pem -k ./key.pem

Todas as requisições devem ser bem-sucedidas

10. **Proxy transparente de redirecionamento - LAN (`ns2` (listeners do proxy), `ns3`, `ns4`), sockets de saída em `ns1` (rota padrão, acesso à internet)**

 Executar proxy:

 ```shell
 sudo ./bin/gohpts -s $WLAN_IP:1080 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1 -nohttp -M redirect -T :8888 -auto
 ```

 Fazer requisições

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

 Para `ns3` e `ns4` a requisição falha

11. **Proxy transparente com `IP_TRANSPARENT` (arp/ndp spoofing habilitado) LAN (`ns2` (listeners do proxy), `ns3`, `ns4`), sockets de saída em `ns1` (rota padrão, acesso à internet)**

 Executar proxy:

 ```shell
 sudo ./bin/gohpts -s $WLAN_IP:1080 -4 -6 -d -sniff -body -in-netns ns2 -out-netns ns1 -nohttp -M tproxy -T :8888 -auto -arpspoof "fullduplex 1;debug 1;interval 1s" -ndpspoof "ra true;interval 10s;debug 1"
 ```

 Agora as requisições anteriores em `ns3` e `ns4` devem funcionar

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

12. **Proxy HTTP3 - listeners do proxy em `ns1`, sockets de saída no host, flag `-nosocks`**

 Executar proxy:

 ```shell
 sudo ./bin/gohpts -l 0.0.0.0:8083 -4 -6 -d -sniff -body -in-netns ns1 -c ./cert.pem -k ./key.pem -nosocks
 ```

 Fazer requisição

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

 A requisição deve ser bem-sucedida

13. **Proxy HTTP3 - listeners do proxy no host, sockets de saída em `ns1`, flag `-nosocks`**

 Executar proxy:

 ```shell
 sudo ./bin/gohpts -l 0.0.0.0:8083 -4 -6 -d -sniff -body -out-netns ns1 -c ./cert.pem -k ./key.pem -nosocks
 ```

 Fazer requisição

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

 A requisição deve falhar

 Adicionar regras à chain `FORWARD`

 ```shell
 sudo iptables -A FORWARD -i wlan0 -o veth0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
 sudo iptables -A FORWARD -i veth0 -o wlan0 -j ACCEPT

 sudo ip6tables -A FORWARD -i veth0 -j ACCEPT
 sudo ip6tables -A FORWARD -o veth0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
 ```

 Fazer requisição

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

 A requisição deve ser bem-sucedida

## Servidor misto

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

`GoHPTS` pode ser configurado para escutar conexões SOCKS no mesmo endereço que o servidor HTTP, basta adicionar a flag `-mixed` para iniciar um servidor SOCKS adicional. Isso permite que `GoHPTS` atue não apenas como proxy `HTTP-to-SOCKS`, mas também como proxy `SOCKS-to-SOCKS`. O servidor SOCKS5 local suporta o comando `UDP ASSOCIATE`, então tecnicamente os usuários podem enviar datagramas UDP com este servidor misto.

Executar proxy:```shell
gohpts -s :1080 -l :8080 -mixed

## Links

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

Saiba mais sobre proxies transparentes visitando os seguintes links:

- [Suporte a proxy transparente no Kernel do Linux](https://docs.kernel.org/networking/tproxy.html)
- [Tutorial de proxy transparente do Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Exemplo simples de tproxy](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Implementação de Proxy Transparente usando eBPF e Go](https://medium.com/all-things-ebpf/building-a-transparent-proxy-with-ebpf-50a012237e76)
- [https://github.com/heiher/hev-socks5-tproxy](https://github.com/heiher/hev-socks5-tproxy)

  proxy `socks5` com suporte a `UDP ASSOCIATE`:

- [https://github.com/wzshiming/socks5](https://github.com/wzshiming/socks5)
- [https://github.com/things-go/go-socks5](https://github.com/things-go/go-socks5)
- [https://github.com/0990/socks5](https://github.com/0990/socks5)
- [https://github.com/dizda/fast-socks5](https://github.com/dizda/fast-socks5)
- [https://github.com/semigodking/redsocks](https://github.com/semigodking/redsocks)
- [https://github.com/ginuerzh/gost](https://github.com/ginuerzh/gost)

Segurança de rede IPv4/IPv6:

- [https://caster0x00.com/legless/](https://caster0x00.com/legless/)
- [https://caster0x00.com/intercept/](https://caster0x00.com/intercept/)
- [https://www.prosec-networks.com/en/blog/ipv6-mitm/](https://www.prosec-networks.com/en/blog/ipv6-mitm/)

## Contributing

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

Você é um desenvolvedor?

- Faça um fork do repositório
- Crie sua branch de funcionalidade: `git switch -c my-new-feature`
- Faça commit das suas alterações: `git commit -am 'Add some feature'`
- Faça push para a branch: `git push origin my-new-feature`
- Envie um pull request

## License

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

GPLv3

go-http-proxy-to-socks

Mais Populares

GoHPTS - Proxy transparente HTTP(S) e TCP/UDP para proxy SOCKS4/SOCKS5 (cadeia) escrito em Go

Índice

Introdução

Recursos

Instalação

Uso

kill the process

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

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

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

list of socks5 proxy

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

Explanations for chains taken from /etc/proxychains4.conf

strict - Each connection will be done via chained proxies

all proxies chained in the order as they appear in the list

all proxies must be online to play in chain

dynamic - Each connection will be done via chained proxies

all proxies chained in the order as they appear in the list

at least one proxy must be online to play in chain

(dead proxies are skipped)

random - Each connection will be done via random proxy

(or proxy chain, see chain_len) from the list.

this option is good to test your IDS :)

round_robin - Each connection will be done via chained proxies

of chain_len length

all proxies chained in the order as they appear in the list

at least one proxy must be online to play in chain

(dead proxies are skipped).

the start of the current proxy chain is the proxy after the last

proxy in the previously invoked proxy chain.

if the end of the proxy chain is reached while looking for proxies

start at the beginning again.

These semantics are not guaranteed in a multithreaded environment.

defaults to standard output

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

profiling data

Proxy transparente

redirect (via NAT e SO_ORIGINAL_DST)

Exemplo

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

Configuração automática para o modo redirect

tproxy (via MANGLE e IP_TRANSPARENT)

Vulnerabilidade

Análise do Código

Mitigação

run socks5 server on 127.0.0.1:1080

Configuração automática para o modo tproxy

Suporte a UDP

Suporte a Android

you need to root your device first

Android support added in v1.10.2

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

Traffic sniffing

Formato JSON

Formato colorido

gohpts_config.yaml

Suporte a IPv4 e IPv6

run proxy on your host

add your host machine as gateway IPv6 for VM

ARP spoofing

DNS spoofing

dns filters require udp transparent proxy and arpspoof/ndpspoof

filters accept hosts like entries (use either links, file paths or just plain comma separated lists

Configuração do playground

Exemplos de uso

`redirect` (via NAT e SO_ORIGINAL_DST)

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

create `GOHPTS` nat chain

Configuração automática para o modo `redirect`

`tproxy` (via MANGLE e IP_TRANSPARENT)

Configuração automática para o modo `tproxy`