shadowy-pycoder/go-http-proxy-to-socksProxy 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.
GoHPTS CLI tool é uma ponte entre clientes HTTP e um servidor proxy SOCKS5 ou múltiplos servidores (cadeia). Ela escuta localmente como um proxy HTTP, aceita solicitações HTTP padrão ou HTTPS (via CONNECT) e encaminha a conexão através de um proxy SOCKS5. Inspirado por http-proxy-to-socks e Proxychains
Possível caso de uso: você precisa se conectar a uma API externa via Postman, mas essa API está disponível apenas a partir de algum servidor remoto. Os seguintes comandos ajudarão você a realizar essa tarefa:
Crie um servidor proxy SOCKS5 via ssh:```shell
ssh -D 1080 -Nf
Criar conexão HTTP para SOCKS5 com `gohpts````shell
gohpts -s :1080 -l :8080
Especifique o servidor http na configuração de proxy do Postman
Funcionalidade de Proxy Chain
Suporta cadeias strict, dynamic, random, round_robin de proxy SOCKS4/SOCKS5
Proxy transparente
Suporta modos redirect (SO_ORIGINAL_DST) e tproxy (IP_TRANSPARENT)
Suporte a IPv4 e IPv6
Opera em modos IPv4-only, IPv6-only ou dual stack
Proxy transparente TCP e UDP
tproxy e tlocal (IP_TRANSPARENT) gerenciam tráfego TCP e UDP
Sniffing de tráfego
O proxy é capaz de analisar cabeçalhos HTTP, handshake TLS, mensagens DNS e mais
ARP spoofing
Faça proxy de sub-redes inteiras com abordagem de ARP spoofing
Faça proxy de conexões IPv6 usando anúncios de Roteador/Vizinho e injeções RDNSS.
Ou usando paru: ```shell
paru -S gohpts
- Faça o download do binário para sua plataforma na página [Releases](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases): ```shell
GOHPTS_RELEASE=v1.15.5; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-linux-amd64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-linux-amd64 gohpts && ./gohpts -h
go install (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
Isso instalará o binário gohpts no seu diretório $GOPATH/bin.
[Voltar]```shell gohpts -h
/ | | | | | __ _ / ____|
| | __ ___ | || | |) | | | | (__
| | |_ |/ _ | __ | / | | _
| |__| | () | | | | | | | ) |
_|_/|| ||| || |___/
GoHPTS: HTTP(S) Proxy to SOCKS4/SOCKS5 proxy by shadowy-pycoder GitHub: https://github.com/shadowy-pycoder/go-http-proxy-to-socks Codeberg: https://codeberg.org/shadowy-pycoder/go-http-proxy-to-socks
Usage: gohpts [OPTIONS] OPTIONS: General: -h Show this help message and exit -v Show version and build information -D Run as a daemon (provide -logfile to see logs) -I Display list of network interfaces and exit -f Path to proxy configuration file in YAML format
Proxy: -l Address of HTTP proxy server (Default: "127.0.0.1:8080" for IPv4, "[::1]:8080" for IPv6) -s Address of SOCKS proxy server (Default: "127.0.0.1:1080" for IPv4 "[::1]:1080" for IPv6) -c Path to certificate PEM encoded file -k Path to private key PEM encoded file -U User for HTTP proxy (basic auth). This flag invokes prompt for password (not echoed to terminal) -u User for SOCKS proxy authentication. This flag invokes prompt for password (not echoed to terminal) -i Bind proxy to specific network interface (either by interface name or index) -4 Force IPv4 stack for TCP and UDP (Default: dual stack) -6 Force IPv6 stack for TCP and UDP (Default: dual stack) -socks4 Use SOCKS4/SOCKS4a protocol for upstream proxy and mixed server (default: SOCKS5/SOCKS5h) -nohttp Disable HTTP proxy server -nosocks Disable SOCKS upstream proxy -dns Use custom DNS server (Example: "8.8.8.8" or "2001:4860:4860::8888") -mixed Accept SOCKS connections on HTTP proxy server address
Logs: -d Show logs in DEBUG mode -j Show logs in JSON format -logfile Log file path (Default: stdout) -nocolor Disable colored output for logs (no effect if -j flag specified) -pprof Address of pprof server with profiling data
Sniffing: -sniff Enable traffic sniffing for HTTP and TLS -snifflog Sniffed traffic log file path (Default: the same as -logfile) -body Collect request and response body for HTTP traffic (credentials, tokens, etc)
TProxy: -T Address of transparent proxy server -Tu Address of transparent UDP proxy server -M Transparent proxy mode: (redirect, tproxy, tlocal) -w Number of instances of transparent proxy server (Default: number of CPU cores) -wu Number of instances of transparent UDP proxy server (Default: number of CPU cores) -auto Automatically setup iptables and kernel parameters for transparent proxy (requires elevated privileges) -mark Set mark for each packet sent through transparent proxy (Default: redirect 0, tproxy 100, tlocal 100) -P Comma separated list of ports to ignore when proxying traffic (Example: "22,80,443,9092") -dump Dump iptables rules and other system settings generated by -auto flag
Spoofing: -arpspoof Enable ARP spoof proxy for selected targets (Example: "targets 10.0.0.1,10.0.0.5-10,192.168.1.*,192.168.10.0/24;fullduplex false;debug true;interval 10s") -ndpspoof Enable NDP spoof proxy for selected targets (Example: "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true;interval 10s")
Packet Capture: -pcap Enable packet capture (Example: "promisc true;expr ip proto tcp;snaplen 65535;timeout 10s;packet_count 100;packet_buffer 8192;exts txt,pcap,pcapng")
Namespaces: -in-netns Name or path of network namespace for inbound listeners (Default: default namespace) -out-netns Name or path of network namespace for outbound connections (Default: default namespace)
### Configuração via flags de CLI
[[Voltar]](#table-of-contents)```shell
gohpts -s 1080 -l 8080 -d -j
Saída:```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"}
Especifique o nome de usuário e a senha para o servidor proxy SOCKS5:```shell
gohpts -s 1080 -l 8080 -d -j -u user
SOCKS5 Password: #you will be prompted for password input here
Especifique nome de usuário e senha para o servidor proxy HTTP:```shell gohpts -s 1080 -l 8080 -d -j -U user HTTP Password: #you will be prompted for password input here
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"
Executar o proxy como um daemon (logfile é necessário para a saída de log, caso contrário você não verá nada)```shell gohpts -D -logfile /tmp/gohpts.log
Fluxos de trabalho CI/CD automatizados para compilar, testar e analisar componentes```shell
# output
gohpts pid: <pid>
[!NOTE]
- O manual integrado para
evalno zsh afirma que ele não aceita opções, é por isso que é fornecido sem o prefixo da opção--.
kill #or kill $(pidof gohpts)
As flags `-u` e `-U` não funcionam em modo daemon (e portanto autenticação), mas você pode fornecer um arquivo de configuração (veja abaixo)
### Configuração via arquivo YAML
[[Back]](#table-of-contents)
Arquivos de configuração são úteis quando você deseja pré-configurar seu proxy sem mexer muito na CLI ou apenas ter vários perfis para diferentes necessidades.
Execute proxy HTTP no 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
Exemplo de configuração:```yaml
interface: "eth0" # if specified, overrides http server IP address disable_http: false # disable http proxy (default: false) disable_socks: false # disable upstream socks proxy (default: false)
ipv4: false # this must be enabled for arpspoof (default: false) ipv6: false # this must be enabled for ndpspoof (default: false) socks4: false # use SOCKS4/SOCKS4a protocol (tcp only protocol, no udp tproxy or http3 possible) (default: false) dns: 8.8.8.8 # custom DNS server (used in direct dialer, namespaces, spoofing)
http_server: address: 127.0.0.1:8080
username: username password: password
proxy_list:
proxy_chain: enabled: false
type: strict # dynamic, strict, random, round_robin length: 2 # maximum number of proxy in a chain (works only for random chain and round_robin chain)
logging: debug: true json: false
#logfile: /tmp/gohpts.log
nocolor: false
pprof: 127.0.0.1:8081
Você pode substituir quase todas as configurações especificadas no arquivo de configuração fornecendo as flags de CLI correspondentes:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor
Proxy assume todas as configurações especificadas em ~/gohpts.yaml, mas inicia um servidor http em 127.0.0.1:6969 em vez de 127.0.0.1:8080 e também desabilita a saída colorida nos logs.
Algumas configurações (por exemplo, proxy_chain e filtros de DNS) só podem ser configuradas via arquivo.
A versão completa da configuração pode ser encontrada aqui: example_gohpts.yaml
Para saber mais sobre cadeias de proxy, visite Proxychains Github
Também conhecido como
proxy interceptador,proxy inline, ouproxy forçado, um proxy transparente intercepta a comunicação normal da camada de aplicação sem exigir configuração especial do cliente. Os clientes não precisam ter conhecimento da existência do proxy. Um proxy transparente normalmente está localizado entre o cliente e a Internet, com o proxy realizando algumas das funções de um gateway ou roteador-- De Wiki
Esta funcionalidade está disponível apenas em sistemas Linux e Android (arm64) e requer configuração adicional (iptables, rota ip, etc)
A flag -T address especifica o endereço do servidor proxy transparente
Existem três modos redirect, tproxy e tlocal (mesmo que tproxy, mas também intercepta tráfego local) que podem ser especificados com a flag -M
redirect (via NAT e SO_ORIGINAL_DST)Neste modo, o proxy ocorre com a tabela nat do iptables e o alvo REDIRECT. O host do pacote de entrada muda para o endereço do proxy transparente redirect em execução, mas também contém o destino original que pode ser recuperado com getsockopt(SO_ORIGINAL_DST)
Para executar GoHPTS neste modo, você usa a flag -T com -M redirect
[Voltar]```shell
gohpts -s 1080 -T 1090 -M redirect -d
uma lista de palavras e irá gerar variações infinitas a partir delas. Pode então utilizar a lista de palavras gerada para praticamente qualquer coisa que desejar, por exemplo, ataques de força bruta.
# Exemplo de uso
hashcat -a 0 -m <hash mode> <hashes.txt> wordlist.txt --stdout -r /usr/share/hashcat/rules/best64.rule
# Aviso Legal
Esta ferramenta destina-se apenas a fins de teste ético.
Usar o Karma para atacar alvos sem consentimento mútuo prévio é ilegal. É da responsabilidade do usuário final obedecer a todas as leis locais, estaduais e federais aplicáveis. O desenvolvedor do Karma (D35m0nd142) não será responsabilizado por qualquer utilização indevida desta ferramenta. Utilize-o apenas para fins de teste e educacionais, e apenas em sistemas dos quais seja proprietário ou para os quais tenha permissão explícita para testar. Ao utilizar esta ferramenta, concorda com estes termos e condições.```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf
Configure seu sistema operacional:```shell
sudo -i)#enable ip forwarding sysctl -w net.ipv4.ip_forward=1
GOHPTS nat chainiptables -t nat -N GOHPTS
iptables -t nat -A GOHPTS -d 127.0.0.0/8 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 8080 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 1090 -j RETURN iptables -t nat -A GOHPTS -p tcp --dport 22 -j RETURN
iptables -t nat -A GOHPTS -p tcp -j REDIRECT --to-ports 1090
iptables -t nat -A PREROUTING -p tcp -j GOHPTS
iptables -t nat -A OUTPUT -p tcp -j GOHPTS
Testar conexão:```shell
#traffic should be redirected via 127.0.0.1:1090
curl http://example.com
id,tool_name,author,description
83,SSRFire,"https://github.com/ksharinarayanan","Um scanner automatizado de SSRF. Basta fornecer o domínio e o servidor Burp Collaborator e ele verifica automaticamente a vulnerabilidade. Além disso, tentará explorar o sistema de arquivos local e escalará o SSRF para uma injeção de comando."
84,r00kie-kr00kie,"https://github.com/Haruster","PoC do ataque Kr00k (CVE-2019-15126) em Python"
85,laravelSQLi,"https://github.com/rmendespt","Automatiza a exploração da vulnerabilidade de SQL injection no Laravel através do debug mode"
86,RevCry,"https://github.com/NullArray","Script Win32 AES Shellcode Crypter / Loader / Executor para evitar alguns AVs"
87,php_filter_chain_generator,"https://github.com/synacktiv","Um gerador de cadeias de filtros PHP, voltado para LFI/file include descoberto "
88,EVTXtract,"https://github.com/ahassan2","Recupera e reconstrói fragmentos de arquivos de log de eventos .evtx"
89,Sylab,"https://github.com/embedi","Um scanner que prioriza a detecção de maneiras de injetar falhas C/C++ para linguagens de script (como falhas ctypes) ou a detecção de falhas de corrupção de memória em nível de script"
90,malware_analysis_reports,"https://github.com/tern-tools","Relatórios de análise de malware da equipe TERN permitem que a comunidade acesse relatórios de análise estática e dinâmica de malware"
``````shell
#traffic should be redirected via 127.0.0.1:8080
curl --proxy http://127.0.0.1:8080 http://example.com
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
### Configuração automática para o modo `redirect`
[[Back]](#table-of-contents)
Para configurar o seu sistema automaticamente, execute o seguinte comando:```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto
Por favor, note que a configuração automática requer sudo e é muito genérica, o que pode não ser adequado para suas necessidades.
Você pode opcionalmente especificar -mark <value> para evitar possíveis loops de proxy.```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100
### `tproxy` (através de _MANGLE_ e _IP_TRANSPARENT_)
[[Back]](#table-of-contents)
Neste modo, o proxy ocorre com a tabela `mangle` do `iptables` e o alvo `TPROXY`. O proxy transparente vê o endereço de destino como ele é, não sendo reescrito pelo kernel. Para que isso funcione, o proxy faz bind com a opção de socket `IP_TRANSPARENT`, o `iptables` intercepta o tráfego usando o alvo TPROXY, e as regras de roteamento direcionam os pacotes marcados para o proxy local sem alterar seu destino original.
Este modo requer privilégios elevados para executar o `GoHPTS`. Você pode fazer isso executando o seguinte comando:```shell
sudo setcap 'cap_net_admin+ep' ~/go/bin/gohpts
Para executar o GoHPTS neste modo, você usa a flag -T com -M tproxy
[Voltar]```shell
gohpts -s 1080 -T 0.0.0.0:1090 -M tproxy -d
## Personalização
### Opção 1: Configuração local
Você pode especificar o arquivo de configuração do seu projeto definindo a variável de ambiente `PIPEKIT_CONFIG`.
O próprio arquivo de configuração conterá suas credenciais de acesso à API, sistemas de varredura alvo,
booleanos de conformidade personalizados, etc.```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf
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
Teste de conexão:```shell
ip netns exec ns-client curl http://1.1.1.1
Desfazer tudo:```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
### Configuração automática para o modo `tproxy`
[[Voltar]](#table-of-contents)
Para configurar seu sistema automaticamente, execute o seguinte comando (por exemplo, em uma VM separada):```shell
ssh remote -D 1080 -Nf
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -auto -mark 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
Testar conexão:```shell
curl http://example.com #check logs on your VM
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
### Suporte UDP
[[Back]](#table-of-contents)
`GoHPTS` tem suporte UDP que pode ser ativado nos modos `tproxy` e `tlocal`. Para que esta configuração funcione, você precisa se conectar a um servidor socks5 capaz de atender conexões UDP (`UDP ASSOCIATE`). Por exemplo, você pode usar [https://github.com/wzshiming/socks5](https://github.com/wzshiming/socks5) para implantar um servidor socks5 com capacidade UDP em alguma máquina remota ou local. Depois de ter o servidor ao qual se conectar, execute o seguinte comando:```shell
sudo env PATH=$PATH gohpts -s remote -Tu :8989 -M tproxy -auto -mark 100 -d
Este comando irá configurar seu sistema operacional e iniciar o servidor no endereço 0.0.0.0:8989.
Para testá-lo localmente, você pode combinar o proxy transparente UDP com a flag -arpspoof. Por exemplo:
tproxy (Kali Linux, por exemplo).bridged para que a VM possa acessar sua máquina host.gohpts para a VM (via ssh, por exemplo) ou compile-o lá no caso de OS/arquitetura diferentes.sudo ./gohpts -s -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "targets ;fullduplex true;debug false"
5. Verifique a conexão na sua máquina host, o tráfego deve passar pela máquina Kali.
### Suporte para Android
[[Voltar]](#table-of-contents)
O proxy transparente pode ser ativado em dispositivos Android (arm64) com acesso root. Você pode instalar o [Termux](https://github.com/termux/termux-app) e executar `GoHPTS` como uma ferramenta CLI lá:```shell
# you need to root your device first
pkg install tsu iproute2
# Android support added in v1.10.2
GOHPTS_RELEASE=v1.10.2; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-android-arm64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-android-arm64 gohpts && ./gohpts -h
# use your phone as router for LAN devices redirecting their traffic to remote socks5 server
sudo ./gohpts -s remote -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "fullduplex true;debug false"
[Voltar]```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)
auto: true
dump_rules: false
ignored_ports: []
mark: 100
## Sniffing de tráfego
[[Back]](#table-of-contents)
<p align="center"><img alt="MrGopher" src="https://assets.kitploit.com/production/public/readmes/11401/ac38691c0f511a6265baf784c236e4ca9557e6c2b7744271f09b1b657af92ca7.png"/>
O proxy `GoHPTS` permite capturar e monitorar o tráfego que passa pelo serviço. Esse processo é conhecido como `traffic sniffing`, `packet sniffing` ou apenas `sniffing`. Em particular, o proxy tenta identificar se o tráfego é texto simples (HTTP) ou TLS e, após a identificação, analisa os metadados de requisição/resposta e os escreve em um arquivo ou no console. No caso do proxy `GoHTPS`, os metadados analisados se parecem com o seguinte (TLS Handshake):
### Formato JSON
[[Back]](#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)",
"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"] } } } ]
Uso tão simples quanto especificar a flag `-sniff` junto com as flags regulares```shell
gohpts -d -T 8888 -M redirect -sniff -j
Você também pode especificar um arquivo no qual escrever o tráfego sniffado:```shell gohpts -sniff -snifflog ~/sniff.log -j
### Formato colorido
[[Back]](#table-of-contents)
Você pode ver o exemplo da saída colorida na imagem acima. Neste modo, o `GoHPTS` tenta destacar informações importantes como TLS Handshake, metadados HTTP, algo que se pareça com login/senhas ou diferentes tipos de tokens de autenticação e segredo. A saída é limitada em comparação ao JSON, mas muito mais fácil de ler para humanos.
Para executar o `GoHPTS` neste modo, você usa os seguintes flags:
``````shell
gohpts -sniff -body
Você pode combinar o sniffing com o modo transparente:```shell ./gohpts -T 8888 -M redirect -sniff -body
Para desabilitar cores, adicione `-nocolor`:```shell
gohpts -sniff -body -nocolor
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).
key.pem e cert.pem: ```shell
openssl req -x509 -newkey rsa:2048 GoHPTS: ```shell
go install github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Você pode usar outros métodos descritos na seção Installation.
Finalmente:
http_server: address: 127.0.0.1:8080 cert_file: ./cert.pem key_file: ./key.pem
proxy_list:
logging: debug: true
sniffing: enabled: true body: true
Execute o proxy: ```shell gohpts -f ./gohpts_config.yaml
2. Ou se preferir argumentos de linha de comando: ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body
Você deve ver algo assim: ```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
### 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"
Pressione Ctrl+C para interromper o fluxo em execução.
Para HTTP/3 é diferente, pois (no momento em que escrevo) o curl não suporta proxy HTTP3, então usarei meu cliente personalizado que criei para fins de teste.
Baixe e instale o Exemplo de proxy HTTP3 para SOCKS5 simples: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make
Execute o seguinte comando: ```shell ./bin/client -a 127.0.0.1:8080 www.google.com
Você deve ver alguns rabiscos parecidos com 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
[[Back]](#table-of-contents)
- Crie um certificado autoassinado apropriado 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
Mais informações podem ser encontradas aqui: Criando um certificado SSL autoassinado e confiável pelo navegador
rootCA.crt ao repositório de confiança do sistema:
- Execute o proxy usando `server.crt` e `server.key`: ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body
Em termos de manipulação da camada de rede, o GoHPTS pode operar em três modos: dual stack, IPv4-only e IPv6-only. O utilizador pode controlar o modo especificando as flags -4 e -6. Quando uma das flags é definida, o proxy inicia no modo correspondente; quando ambas as flags estão presentes ou ambas omitidas, assume-se dual stack. Note que nos modos "only", apenas endereços IP da versão específica são permitidos, todos os domínios são resolvidos para a versão IP específica (se possível), todos os endereços de escuta requerem o uso da mesma versão, etc.
Para ativar o modo IPv4-only, basta adicionar a flag -4:```shell
sudo ./gohpts -sniff -body -d -4
Para testar o proxy no 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"
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -4
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 o sinalizador `-6`, por exemplo ao usar com proxy transparente:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6
Para que isso funcione, seu ISP e o proxy socks5 remoto devem ter suporte ativo a IPv6. Você pode visitar https://test-ipv6.com/ para descobrir se consegue acessar endereços IPv6. Para testar o proxy no modo IPv6, você pode usar qualquer VM Linux:
export GATEWAY6="" ip -6 route add ::/1 via "$GATEWAY6" dev eth0 ip -6 route add 8000::/1 via "$GATEWAY6" dev eth0
2. No seu host:```shell
# run proxy on your host
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -6
GoHPTS possui um falsificador ARP embutido que pode ser usado para fazer com que todos os dispositivos TCP da sua LAN usem o servidor proxy para se conectar à Internet.
Isso é feito adicionando a flag -arpspoof com alguns parâmetros, separados por ponto e vírgula.
Exemplo:```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"
O proxy irá escanear dispositivos na sub-rede `192.168.10.0/24` e enviar pacotes ARP para fingir ser um gateway, se `fullduplex` for verdadeiro,
o proxy também enviará pacotes ARP para o gateway para fazê-lo acreditar que nosso proxy possui cada IP na sub-rede.
Após o proxy ser parado com `Ctrl+C`, ele irá automaticamente desfazer o spoofing de todos os alvos.
`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
Execute o bettercap com este comando (veja documentação):```shell
sudo bettercap -eval "net.probe on;net.recon on;set arp.spoof.fullduplex true;arp.spoof on"
Verifique os logs do proxy para tráfego de outros dispositivos da sua LAN
Para mais informações sobre as opções do arpspoof, veja `gohpts -h` e [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)
## NDP spoofing
[[Voltar]](#table-of-contents)
`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 servidor de nomes IPv6 para clientes afetados. Quando combinado com o modo de proxy transparente (TCP/UDP), o NDP spoofing permite que `gohpts` faça proxy de tráfego para clientes nas redes locais. 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"
Para mais informações sobre as opções do ndpspoof, veja gohpts -h e https://github.com/shadowy-pycoder/ndpspoof
Por favor, note que algumas opções como rdnss, gateway, interface são definidas automaticamente pelo próprio gohpts para funcionar corretamente como proxy.
Como o gohpts faz proxy de todas as conexões através de um servidor SOCKS5 upstream, você precisa ter um servidor funcional com suporte a IPv4/IPv6 e TCP/UDP. Obviamente, uma máquina remota (ex.: VPS) também deve ter conectividade IPv6 funcionando. Escusado será dizer que a máquina na qual o gohpts está deve fazer parte de uma rede com suporte a IPv6.
Exemplo de configuração para o NDP spoofing funcionar corretamente:
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` (veja [Instalação](#installation))
5. Execute `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
Obtenha outro dispositivo (telefone, tablet, etc.) e conecte-o à mesma rede. Tente acessar a Internet e verifique se algum tráfego aparece na sua máquina host. Verifique o endereço IP público com algumas ferramentas online (deve corresponder ao endereço do seu VPS 203.0.113.10 neste caso ou ao endereço IPv6 global)
Pare o proxy pressionando Ctrl+C
Lucro!
Para aplicar filtros DNS e falsificar alvos alterando registros DNS, o host executando GoHPTS deve se tornar o gateway padrão para dispositivos LAN. Para que isso funcione, basta executar o proxy transparente com udp ativado e também executar o ARP/NDP spoofing para fazer com que os alvos usem seu servidor DNS.
As respostas DNS criadas pelo GoHPTS parecem pacotes normais vindos do roteador ou de servidores DNS confiáveis (Google, Cloudflare), o que resulta em clientes atualizando seu cache com o que você lhes informar. Tenha em mente, no entanto, que isso funciona apenas para tráfego DNS não criptografado "padrão" (DOT/DOH não são filtrados ou falsificados).
Filtros DNS e domínios para spoofing podem ser configurados na seção dns_filter do arquivo de configuração yaml. Todas as listas aceitam URLs, caminhos de arquivo e entradas semelhantes às normalmente encontradas no arquivo hosts, veja https://en.wikipedia.org/wiki/Hosts_(file).
Exemplo:```yaml
dns_filter: enabled: true whitelist: ["/tmp/whitelisted_domains.txt", "example.com", "*.google.com"] # ip is optional, domains can start with *. to match all subdomains blacklist: ["https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts"] blacklist_all: false # block all non whitelisted domains spooflist: ["127.0.0.1 example.com"] # ip address is required here
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
- Captura de credenciais via 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"]
Executar:```shell sudo ./gohpts -f ./gohpts_dns_spoof.yaml
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 dar 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 de arquivo.
Configure o proxy usando a CLI:```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"
Arquivo de configuração:```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"
Estes 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 opções pcap veja `gohpts -h` e [https://github.com/shadowy-pycoder/mshark](https://github.com/shadowy-pycoder/mshark)
## Namespaces de Rede
[[Back]](#table-of-contents)
Por padrão, o proxy `GoHPTS` é executado dentro de um único namespace de rede, mas isso pode ser substituído. Sockets de escuta (por exemplo, servidor http ou proxy transparente) e sockets de saída (proxy socks ou discador direto) criados pelo `GoHPTS` podem ser isolados com namespaces de rede do Linux/Android [network_namespaces (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html). Ao iniciar o processo de proxy, os usuários podem especificar as flags `-in-netns` (ouvintes) e `-out-netns` (discadores) com nome ou caminho para o namespace de rede para controlar em qual ambiente isolado criar sockets. Se você quiser criar ouvintes ou discadores 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 servidores de nomes do sistema.
`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 através de arquivos localizados no diretório `/etc/netns/NAME/`. Então, para especificar servidores de nomes personalizados para o namespace de rede `ns1`, faça 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
Se nenhuma configuração for encontrada, os servidores Google DNS serão usados para resolver nomes de domínio.
Se o seu sistema tiver o systemd-resolved.service (8) ativado, talvez você queira desabilitá-lo temporariamente ao fazer consultas através de namespaces de rede personalizados:```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'
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'
key.pem e cert.pem: ```shell
openssl req -x509 -newkey rsa:2048 ns1 e configurar 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
Proxy HTTP - listeners de proxy em ns1 (sem rota padrão, sem acesso à internet), sockets de saída no host
Execute o proxy: ```shell sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1
Faça requisição via ns1 ```shell
sudo ip netns exec ns1 curl -Nv --proxy http://127.0.0.1:8083 https://example.com
A solicitação deve ser bem-sucedida
2. **proxy HTTP2 - listeners do 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 -c ./cert.pem -k ./key.pem
Faça solicitação via ns1 ```shell
sudo ip netns exec ns1 curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://127.0.0.1:8083 https://example.com
A solicitação deve ser bem-sucedida
3. **HTTP3 proxy - listeners de proxy em `ns1` (sem rota padrão, sem acesso à internet), sockets de saída no host**
Execute 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
Faça requisição via ns1 ```shell
sudo ip netns exec ns1 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
O pedido deve ser bem-sucedido
4. **Redirecionar proxy transparente (`-M redirect`) - ouvintes de proxy em `ns1` (rota padrão, sem acesso à internet), sockets de saída no host**
Execute 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
Faça requisição via ns1 ```shell
sudo ip netns exec ns1 curl -Nv https://example.com
A solicitação deve falhar
Adicionar rota padrão para `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
Tente novamente ```shell sudo ip netns exec ns1 curl -Nv https://example.com
Agora o pedido deve ser bem-sucedido
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
Executar proxy: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0
Faça requisição via host ```shell
curl -Nv --proxy http://$WLAN_IP:8083 https://example.com
A solicitação deve ser bem-sucedida
HTTP3 proxy - listeners de proxy no host, sockets de saída em ns1 (rota padrão, acesso à internet)
Executar proxy: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0 -c ./cert.pem -k ./key.pem
Faça requisição via host ```shell ./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com
A solicitação deve ter sucesso
7. **Redirecionar proxy transparente - listeners de proxy no host, sockets de saída em `ns1` (rota padrão, acesso à internet)**
Executar 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
Fazer requisição via host ```shell curl -Nv https://example.com
A solicitação deve ser bem-sucedida
8. **Proxy HTTP - LAN (`ns2` (ouvintes de 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
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
Faça 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
Todas as solicitações devem ser bem-sucedidas
HTTP3 proxy - LAN (ns2 (ouvintes de proxy), ns3, ns4), sockets de saída em ns1 (rota predefinida, 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
Faça requisições ```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
Todos os pedidos devem ser bem-sucedidos
10. **Proxy transparente de redirecionamento - LAN (`ns2` (ouvintes do proxy), `ns3`, `ns4`), sockets de saída em `ns1` (rota padrão, acesso à Internet)**
Execute o 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
```
Faça os pedidos
```shell
sudo ip netns exec ns2 curl -Nv https://example.com
```
Para `ns3` e `ns4`, o pedido falha
11. **Proxy transparente com `IP_TRANSPARENT` (spoofing arp/ndp ativado) LAN (`ns2` (ouvintes do proxy), `ns3`, `ns4`), sockets de saída em `ns1` (rota padrão, acesso à Internet)**
Execute o 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 os pedidos 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 - ouvintes do proxy em `ns1`, sockets de saída no host, flag `-nosocks`**
Execute o 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
```
Faça o pedido
```shell
./http3-socks-proxy/bin/client -a 10.0.0.2:8083 www.google.com
```
O pedido deve ser bem-sucedido
13. **Proxy HTTP3 - ouvintes do proxy no host, sockets de saída em `ns1`, flag `-nosocks`**
Execute o 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
```
Faça o pedido
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
O pedido deve falhar
Adicione regras à cadeia `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
```
Faça o pedido
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
O pedido deve ser bem-sucedido
## Servidor misto
[[Voltar]](#table-of-contents)
O `GoHPTS` pode ser configurado para escutar conexões SOCKS no mesmo endereço do servidor HTTP, basta adicionar a flag `-mixed` para iniciar um servidor SOCKS adicional. Isso permite que `GoHPTS` atue não apenas como um proxy `HTTP-to-SOCKS`, mas também como um proxy `SOCKS-to-SOCKS`. O servidor SOCKS5 local suporta o comando `UDP ASSOCIATE`, portanto, tecnicamente os usuários podem enviar datagramas UDP com este servidor misto.
Execute o proxy:```shell
gohpts -s :1080 -l :8080 -mixed
Teste de conexão:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Ou desative o proxy SOCKS upstream e conecte-se diretamente adicionando `-nosocks`:```shell
gohpts -l :8080 -mixed -nosocks
Teste de conexão:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Adicione a opção `-socks4` para usar o protocolo SOCKS4 em vez disso:```shell
# :1080 should be a socks4 server
gohpts -s :1080 -l :8080 -mixed -socks4
Teste de conexão:```shell curl -Nv --proxy socks4://127.0.0.1:8080 "https://example.com"
## Links
[[Back]](#table-of-contents)
Saiba mais sobre proxies transparentes visitando os seguintes links:
- [Suporte a proxy transparente no kernel Linux](https://docs.kernel.org/networking/tproxy.html)
- [Tutorial de proxy transparente por 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/)
## Contribuindo
[[Back]](#table-of-contents)
Você é desenvolvedor?
- Faça um fork do repositório
- Crie seu branch de funcionalidade: `git switch -c my-new-feature`
- Faça commit das suas alterações: `git commit -am 'Add some feature'`
- Envie para o branch: `git push origin my-new-feature`
- Envie um pull request
## Licença
[[Back]](#table-of-contents)
GPLv3
DNS spoofing
Redirecione clientes para domínios arbitrários usando manipulação de registros DNS
Captura de pacotes
Capture tráfego em arquivos txt/pcap/pcapng e analise com o Wireshark
Proteção contra vazamento de DNS
A resolução DNS ocorre no lado do servidor SOCKS5.
Suporte ao método CONNECT
Suporta tunelamento HTTP CONNECT, permitindo HTTPS e outros protocolos baseados em TCP.
Suporte a HTTP2/HTTP3
Suporta transporte moderno HTTP/2 e HTTP/3, permitindo conexões multiplexadas eficientes sobre TLS 1.3
Suporte a namespaces de rede
Suporta namespaces de rede Linux personalizados para sockets de escuta e conexões de saída
Suporte a cabeçalhos de trailer
Lida com cabeçalhos de trailer HTTP
Codificação de transferência por partes
Lida com respostas fragmentadas (chunked) e streaming
Suporte a autenticação SOCKS5
Suporta autenticação de nome de usuário/senha para proxies SOCKS5.
Suporte a autenticação HTTP
Suporta autenticação de nome de usuário/senha para servidor proxy HTTP.
Leve e rápido
Projetado com sobrecarga mínima e manipulação eficiente de requisições.
Multiplataforma
Compatível com todos os principais sistemas operacionais.
wlan0 para poder conectar ao socks5 local ```shell
WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')