shadowy-pycoder/go-http-proxy-to-socksCLI MITM proxy que convierte SOCKS4/SOCKS5 en proxy HTTP/HTTPS/HTTP2/HTTP3 con redirección transparente TCP/UDP, suplantación ARP/NDP/DNS, rastreo de tráfico y captura de paquetes. Escrito en Go puro, sin libpcap.
La herramienta CLI GoHPTS es un puente entre clientes HTTP y un servidor proxy SOCKS5 o múltiples servidores (cadena). Escucha localmente como un proxy HTTP, acepta solicitudes HTTP
o HTTPS (mediante CONNECT) y reenvía la conexión a través de un proxy SOCKS5. Inspirado en http-proxy-to-socks y Proxychains
Caso de uso posible: necesitas conectarte a una API externa mediante Postman, pero esta API solo está disponible desde algún servidor remoto. Los siguientes comandos te ayudarán a realizar dicha tarea:
Crear un servidor proxy SOCKS5 mediante ssh:```shell
ssh -D 1080 -Nf
Crear conexión HTTP a SOCKS5 con `gohpts````shell
gohpts -s :1080 -l :8080
Especificar servidor HTTP en la configuración de proxy de Postman
Funcionalidad de cadena de proxy
Soporta cadenas strict, dynamic, random, round_robin de proxy SOCKS4/SOCKS5
Proxy transparente
Soporta modos redirect (SO_ORIGINAL_DST) y tproxy (IP_TRANSPARENT)
Soporte para IPv4 e IPv6
Opera en modos solo IPv4, solo IPv6 o doble pila
Proxy transparente TCP y UDP
tproxy y tlocal (IP_TRANSPARENT) manejan tráfico TCP y UDP
Sniffing de tráfico
El proxy puede analizar cabeceras HTTP, el handshake TLS, mensajes DNS y más
Suplantación ARP
Proxy de subredes completas mediante suplantación ARP
Suplantación NDP
Proxy de conexiones IPv6 utilizando anuncios de enrutador/vecino e inyecciones RDNSS.
Suplantación DNS
Redirigir clientes a dominios arbitrarios mediante manipulación de registros DNS
Captura de paquetes
Capturar tráfico en archivos txt/pcap/pcapng y analizar con Wireshark
Protección contra fugas DNS
La resolución DNS ocurre en el lado del servidor SOCKS5.
Soporte para método CONNECT
Soporta túneles HTTP CONNECT, permitiendo HTTPS y otros protocolos basados en TCP.
Soporte para HTTP2/HTTP3
Soporta transporte moderno HTTP/2 y HTTP/3, permitiendo conexiones multiplexadas eficientes sobre TLS 1.3
Soporte para espacios de nombres de red
Soporta espacios de nombres de red personalizados de Linux para sockets de escucha y conexiones salientes
Soporte para cabeceras de finalización
Maneja cabeceras de finalización HTTP
Codificación de transferencia fragmentada
Maneja respuestas fragmentadas y en flujo continuo
Soporte para autenticación SOCKS5
Soporta autenticación de usuario/contraseña para proxies SOCKS5.
Soporte para autenticación HTTP
Soporta autenticación de usuario/contraseña para servidor proxy HTTP.
Ligero y rápido
Diseñado con sobrecarga mínima y manejo eficiente de solicitudes.
Multiplataforma
Compatible con todos los sistemas operativos principales.
O usando paru: ```shell
paru -S gohpts
- Descarga el binario para tu plataforma desde la página de [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 (requiere Go 1.26 o posterior): ```shell
CGO_ENABLED=0 go install -ldflags "-s -w" -trimpath github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Esto instalará el binario gohpts en tu directorio $GOPATH/bin.
[Volver]```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)
### Configuración mediante banderas de CLI
[[Volver]](#table-of-contents)```shell
gohpts -s 1080 -l 8080 -d -j
Salida:```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"}
Especifica el nombre de usuario y la contraseña para el servidor proxy SOCKS5:```shell
gohpts -s 1080 -l 8080 -d -j -u user
SOCKS5 Password: #you will be prompted for password input here
Especifique el nombre de usuario y la contraseña para el servidor proxy HTTP:```shell gohpts -s 1080 -l 8080 -d -j -U user HTTP Password: #you will be prompted for password input here
Cuando ambos `-u` y `-U` están presentes, se te solicitará dos veces
Ejecutar proxy HTTP sobre conexión TLS```shell
gohpts -s 1080 -l 8080 -c "path/to/certificate" -k "path/to/private/key"
Ejecutar proxy como un daemon (se necesita un archivo de registro para la salida de logs, de lo contrario no verás nada)```shell gohpts -D -logfile /tmp/gohpts.log
[No content provided for translation.]```shell
# output
gohpts pid: <pid>
The tool also supports a wide range of data sources, including:
Esta cobertura integral garantiza que ninguna actividad sospechosa pase desapercibida.
kill #or kill $(pidof gohpts)
`-u` y las opciones `-U` no funcionan en modo daemon (y por lo tanto la autenticación), pero puede proporcionar un archivo de configuración (ver más abajo)
### Configuración mediante archivo YAML
[[Volver]](#table-of-contents)
Los archivos de configuración son útiles cuando desea preconfigurar su proxy sin manipular demasiado la CLI o simplemente desea múltiples perfiles para diferentes necesidades.
Ejecute proxy http en modo de cadena de proxy SOCKS5 (especifique la configuración del servidor mediante archivo de configuración YAML)```shell
gohpts -f "~/gohtps.yaml" -d -j
Ejemplo de configuración:```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
Puede anular casi cualquier configuración especificada en el archivo de configuración proporcionando los indicadores de CLI correspondientes:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor
Proxy toma todas las configuraciones especificadas en ~/gohpts.yaml pero inicia un servidor http en 127.0.0.1:6969 en lugar de 127.0.0.1:8080 y también desactiva la salida coloreada en los registros.
Algunas configuraciones (por ejemplo, proxy_chain y filtros dns) solo se pueden configurar mediante archivo.
La versión completa de la configuración se encuentra aquí: example_gohpts.yaml
Para obtener más información sobre las cadenas de proxy, visite Proxychains Github
También conocido como
proxy interceptador,proxy inlineoproxy forzado, un proxy transparente intercepta la comunicación normal de la capa de aplicación sin requerir una configuración especial del cliente. Los clientes no necesitan estar al tanto de la existencia del proxy. Un proxy transparente normalmente se ubica entre el cliente e Internet, realizando algunas de las funciones de una puerta de enlace o enrutador.-- De Wiki
Esta funcionalidad está disponible solo en sistemas Linux y Android (arm64) y requiere configuración adicional (iptables, ruta ip, etc.)
La bandera -T address especifica la dirección del servidor proxy transparente
Hay tres modos redirect, tproxy y tlocal (igual que tproxy pero también intercepta el tráfico local) que se pueden especificar con la bandera -M
redirect (a través de NAT y SO_ORIGINAL_DST)En este modo, la intermediación se realiza con la tabla nat de iptables y el objetivo REDIRECT. El host del paquete entrante cambia a la dirección del proxy transparente redirect en ejecución, pero también contiene el destino original que se puede recuperar con getsockopt(SO_ORIGINAL_DST)
Para ejecutar GoHPTS en este modo, use la bandera -T con -M redirect
[Volver]```shell
gohpts -s 1080 -T 1090 -M redirect -d
(no content provided)```shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf
Configura tu sistema operativo:```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
Probar conexión:```shell
#traffic should be redirected via 127.0.0.1:1090
curl http://example.com
ENTRADA:```shell #traffic should be redirected via 127.0.0.1:8080 curl --proxy http://127.0.0.1:8080 http://example.com
Deshacer todo:```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
redirectPara configurar tu sistema automáticamente, ejecuta el siguiente comando:```shell sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto
Tenga en cuenta que la configuración automática requiere `sudo` y es muy genérica, lo que podría no ser adecuado para sus necesidades.
Opcionalmente puede especificar `-mark <value>` para evitar posibles bucles de proxy.```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100
tproxy (a través de MANGLE y IP_TRANSPARENT)En este modo, la proxy se realiza con la tabla mangle de iptables y el objetivo TPROXY. El proxy transparente ve la dirección de destino tal cual, no es reescrita por el kernel. Para que esto funcione, el proxy se vincula con la opción de socket IP_TRANSPARENT, iptables intercepta el tráfico usando el objetivo TPROXY, y las reglas de enrutamiento indican a los paquetes marcados que vayan al proxy local sin cambiar su destino original.
Este modo requiere privilegios elevados para ejecutar GoHPTS. Puede hacerlo ejecutando el siguiente comando:```shell
sudo setcap 'cap_net_admin+ep' ~/go/bin/gohpts
Para ejecutar `GoHPTS` en este modo, usas la bandera `-T` con `-M tproxy`
### Ejemplo
[[Volver]](#table-of-contents)```shell
# run the proxy
gohpts -s 1080 -T 0.0.0.0:1090 -M tproxy -d
git clone https://github.com/sonatype/detect.git && cd detect
curl -sL https://raw.githubusercontent.com/sonatype/detect/master/install_scripts/install.sh -o install.sh && chmod +x install.sh && ./install.sh
brew tap sonatype/detect
brew install detect
Para preparar la configuración general de detect, puedes:
.detectrc en tu directorio personal o en la raíz del proyectoDETECT_PROJECT_NAME, DETECT_SOURCE_PATH, etc.Para una lista completa de opciones de configuración, consulta la sección de Configuración.```shell
ssh remote -D 1080 -Nf
Configura tu sistema operativo:```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
Prueba de conexión:```shell ip netns exec ns-client curl http://1.1.1.1
Deshacer todo:```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
tproxyPara configurar tu sistema automáticamente, ejecuta el siguiente comando (por ejemplo, en una máquina virtual separada):```shell ssh remote -D 1080 -Nf sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -auto -mark 100
Ejecuta lo siguiente en tu 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
Prueba de conexión:```shell curl http://example.com #check logs on your VM
Deshacer todo:```shell
ip route del 0.0.0.0/1 via 192.168.0.1 2>/dev/null || true
ip route del 128.0.0.0/1 via 192.168.0.1 2>/dev/null || true
if [[ -f /tmp/default-route.txt ]]; then
eval $(awk '{print "ip route add "$0}' /tmp/default-route.txt)
rm -f /tmp/default-route.txt
else
echo "Something went wrong"
fi
GoHPTS tiene soporte UDP que se puede habilitar en los modos tproxy y tlocal. Para que esta configuración funcione, necesitas conectarte a un servidor socks5 capaz de manejar conexiones UDP (UDP ASSOCIATE). Por ejemplo, puedes usar https://github.com/wzshiming/socks5 para desplegar un servidor socks5 con soporte UDP en una máquina remota o local. Una vez que tengas el servidor al que conectarte, ejecuta el siguiente comando:```shell
sudo env PATH=$PATH gohpts -s remote -Tu :8989 -M tproxy -auto -mark 100 -d
Este comando configurará su sistema operativo y configurará el servidor en la dirección `0.0.0.0:8989`.
Para probarlo localmente, puede combinar el proxy transparente UDP con la bandera `-arpspoof`. Por ejemplo:
1. Configure una VM en su sistema con cualquier distribución de Linux que admita `tproxy` (Kali Linux, por ejemplo).
2. Habilite la red `bridged` para que la VM pueda acceder a su máquina host.
3. Mueva el binario `gohpts` a la VM (mediante `ssh`, por ejemplo) o constrúyalo allí en caso de diferente SO/arquitectura.
4. En su VM ejecute el siguiente 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"
El proxy transparente se puede habilitar en dispositivos Android (arm64) con acceso root. Puede instalar Termux y ejecutar GoHPTS como herramienta CLI allí:```shell
pkg install tsu iproute2
GOHPTS_RELEASE=v1.10.2; wget -v https://github.com/shadowy-pycoder/go-http-proxy-to-socks/releases/download/$GOHPTS_RELEASE/gohpts-$GOHPTS_RELEASE-android-arm64.tar.gz -O gohpts && tar xvzf gohpts && mv -f gohpts-$GOHPTS_RELEASE-android-arm64 gohpts && ./gohpts -h
sudo ./gohpts -s remote -T 8888 -Tu :8989 -M tproxy -sniff -body -auto -mark 100 -d -arpspoof "fullduplex true;debug false"
### Configuración YAML
[[Back]](#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
El proxy GoHPTS permite capturar y monitorear el tráfico que pasa a través del servicio. Este proceso se conoce como traffic sniffing, packet sniffing o simplemente sniffing. En particular, el proxy intenta identificar si se trata de tráfico de texto plano (HTTP) o TLS, y después de realizada la identificación, analiza los metadatos de solicitud/respuesta y los escribe en un archivo o en la consola. En el caso del proxy GoHTPS, los metadatos analizados se ven de la siguiente manera (Handshake TLS):
[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)" } } ]
Y una solicitud HTTP con 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"]
}
}
}
]
El uso es tan simple como especificar la bandera -sniff junto con las banderas normales```shell
gohpts -d -T 8888 -M redirect -sniff -j
También puedes especificar un archivo en el que escribir el tráfico capturado:```shell
gohpts -sniff -snifflog ~/sniff.log -j
Puedes ver un ejemplo de la salida coloreada en la imagen de arriba. En este modo, GoHPTS intenta resaltar información importante como el handshake TLS, metadatos HTTP, algo que parecen inicios de sesión/contraseñas o diferentes tipos de tokens de autenticación y secretos. La salida es limitada en comparación con JSON, pero mucho más fácil de leer para los humanos.
Para ejecutar GoHPTS en este modo, usas las siguientes banderas:```shell
gohpts -sniff -body
Puedes combinar el sniffing con el modo transparente:```shell
./gohpts -T 8888 -M redirect -sniff -body
Para deshabilitar los colores añade -nocolor:```shell
gohpts -sniff -body -nocolor
## Soporte para HTTP2 y HTTP3
[[Back]](#table-of-contents)
El proxy `GoHPTS` maneja solicitudes HTTP/1.1, HTTP/2 y HTTP/3 utilizando la misma dirección del servidor y el mismo certificado TLS. Esto permite que los clientes elijan automáticamente el mejor protocolo disponible sin cambiar la configuración. El certificado TLS se puede obtener de varias formas: proveedores en la nube (Google, AWS, Cloudflare), certificado gratuito de Let's Encrypt, o puedes crear un certificado autofirmado usando `openssl` (Linux/macOS) o `New-SelfSignedCertificate` (Windows).
### Ejemplo de configuración usando certificado autofirmado
[[Back]](#table-of-contents)
- Crea los archivos `key.pem` y `cert.pem`: ```shell
openssl req -x509 -newkey rsa:2048 \
-keyout key.pem \
-out cert.pem \
-sha256 \
-days 365 \
-nodes \
-subj "/C=XX/ST=StateName/L=CityName/O=CompanyName/OU=CompanySectionName/CN=127.0.0.1" \
-addext "subjectAltName=IP:127.0.0.1"
GoHPTS: ```shell
go install github.com/shadowy-pycoder/go-http-proxy-to-socks/cmd/gohpts@latest
Puede usar otros métodos descritos en la sección Instalación.
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
Ejecuta el proxy: ```shell gohpts -f ./gohpts_config.yaml
2. O si prefieres argumentos de línea de comandos: ```shell
gohpts -l :8080 -s 1080 -c ./cert.pem -k ./key.pem -d -sniff -body
Deberías ver algo como esto: ```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
### Probar conexión
[[Back]](#table-of-contents)
- Para servidor proxy HTTP/2 puedes usar `curl`: ```shell
curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://localhost:8080 "https://stream.wikimedia.org/v2/stream/recentchange"
Presiona Ctrl+C para detener la transmisión.
Para HTTP/3 es diferente, ya que (al momento de escribir esto) curl no admite proxy HTTP3, por lo que usaré mi cliente personalizado que creé con fines de prueba.
Descarga e instala Simple HTTP3 to SOCKS5 proxy example: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make
Ejecuta el siguiente comando: ```shell ./bin/client -a 127.0.0.1:8080 www.google.com
Deberías ver algo de galimatías que se asemeja a una página HTML.
Ve a la pestaña de terminal con el proxy `GoHPTS` y revisa los registros, deberías ver todas tus solicitudes allí.
### Probar conexión en un navegador
[[Back]](#table-of-contents)
- Crea un certificado autofirmado adecuado para el 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
Más información se puede encontrar aquí: Creating a browser trusted, self signed, SSL certificate
rootCA.crt recién creado al almacén de confianza del sistema:
- Ejecuta el proxy usando `server.crt` y `server.key`: ```shell
gohpts -l :8080 -s 1080 -c ./server.crt -k ./server.key -d -sniff -body
En cuanto al manejo de la capa de red, GoHPTS puede operar en tres modos: dual stack, IPv4-only y IPv6-only. El usuario puede controlar el modo especificando las banderas -4 y -6. Cuando se establece una de las banderas, el proxy se inicia en el modo correspondiente; cuando ambas banderas están presentes o ambas omitidas, se asume dual stack. Tenga en cuenta que en los modos "solo", solo se permiten direcciones IP de la versión específica, todos los dominios se resuelven a la versión IP específica (si es posible), todas las direcciones de escucha requieren usar la misma versión, etc.
Para habilitar el modo IPv4-only solo agregue la bandera -4:```shell
sudo ./gohpts -sniff -body -d -4
Para probar el proxy en modo IPv4 puedes usar cualquier máquina virtual Linux:
1. En tu 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 cualquier sitio web en su máquina virtual y vea el tráfico en los registros del proxy
Para habilitar el modo `solo-IPv6`, simplemente agregue la bandera `-6`, por ejemplo al usarlo con proxy transparente:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6
Para que esto funcione, su ISP y el proxy socks5 remoto deben tener soporte IPv6 activo, puede visitar https://test-ipv6.com/ para comprobar si puede acceder a direcciones IPv6. Para probar el proxy en modo IPv6 puede usar cualquier máquina virtual Linux:
export GATEWAY6="" ip -6 route add ::/1 via "$GATEWAY6" dev eth0 ip -6 route add 8000::/1 via "$GATEWAY6" dev eth0
2. En tu host:```shell
# run proxy on your host
sudo ./gohpts -T 8888 -Tu 8889 -M tproxy -sniff -body -auto -d -6
GoHPTS tiene un suplantador ARP incorporado que se puede usar para hacer que todos los dispositivos que hablan TCP en tu LAN usen el servidor proxy para conectarse a Internet.
Esto se logra añadiendo el flag -arpspoof con un par de parámetros, separados por punto y coma.
Ejemplo:```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"
El proxy escaneará dispositivos en la subred `192.168.10.0/24` y les enviará paquetes ARP para hacerse pasar por un gateway. Si `fullduplex` es verdadero, el proxy también enviará paquetes ARP al gateway para hacerle creer que nuestro proxy tiene cada IP de la subred.
Después de detener el proxy con `Ctrl+C`, desenmascarará automáticamente todos los objetivos.
`GoHPTS` también puede usarse con herramientas como [Bettercap](https://github.com/bettercap/bettercap) para redirigir el tráfico ARP suplantado.
Ejecutar el proxy:```shell
ssh remote -D 1080 -Nf
sudo env PATH=$PATH gohpts -d -T 8888 -M tproxy -sniff -body -auto -mark 100
Ejecuta bettercap con este comando (consulta la documentación):```shell
sudo bettercap -eval "net.probe on;net.recon on;set arp.spoof.fullduplex true;arp.spoof on"
Comprueba los registros del proxy para tráfico de otros dispositivos de tu LAN
Para más información sobre las opciones de arpspoof, consulta `gohpts -h` y [https://github.com/shadowy-pycoder/arpspoof](https://github.com/shadowy-pycoder/arpspoof)
## Suplantación NDP
[[Volver]](#table-of-contents)
`GoHPTS` tiene funcionalidad integrada para realizar suplantación NDP en redes IPv6 con paquetes de Anuncio de Router (RA) y Anuncio de Vecino (NA). También incluye la opción RDNSS en paquetes RA para establecer el host como servidor de nombres IPv6 para los clientes afectados. Cuando se combina con el modo de proxy transparente (TCP/UDP), la suplantación NDP permite que `gohpts` intermediar tráfico para clientes en las redes locales. Como ocurre con la [suplantación ARP](#arp-spoofing), puedes configurar las opciones de suplantación NDP con una sola bandera `-ndpspoof`:
Ejemplo:```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 más información sobre las opciones de ndpspoof, consulte gohpts -h y https://github.com/shadowy-pycoder/ndpspoof
Tenga en cuenta que algunas opciones como rdnss, gateway, interface son configuradas automáticamente por gohpts para funcionar correctamente como proxy.
Dado que gohpts redirige todas las conexiones a través de un servidor SOCKS5 ascendente, necesita tener un servidor funcional con soporte para IPv4/IPv6 y TCP/UDP. Obviamente, una máquina remota (por ejemplo, VPS) también debe tener conectividad IPv6. No hace falta decir que la máquina en la que se ejecuta gohpts debe ser parte de una red con soporte IPv6.
Configuración de ejemplo para que el NDP spoofing funcione correctamente:
2. Instalar dependencias```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. Vuelve a tu máquina anfitriona e instala `gohpts` (consulta [Instalación](#installation))
5. Ejecuta `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
Obtén otro dispositivo (teléfono, tableta, etc.) y conéctalo a la misma red. Intenta acceder a Internet y verifica si aparece algo de tráfico en tu máquina anfitriona. Comprueba la dirección IP pública con algunas herramientas en línea (debería coincidir con la dirección de tu VPS 203.0.113.10 en este caso o con la dirección IPv6 global)
Detén el proxy presionando Ctrl+C
¡Beneficio!
Para aplicar filtros DNS y suplantar objetivos cambiando registros DNS, el host que ejecuta GoHPTS debe convertirse en la puerta de enlace predeterminada para los dispositivos LAN. Para que esto funcione, solo ejecuta el proxy transparente con udp habilitado y también ejecuta la suplantación ARP/NDP para que los objetivos usen tu servidor DNS.
Las respuestas DNS creadas por GoHPTS parecen paquetes normales provenientes del enrutador o servidores DNS de confianza (Google, Cloudflare), lo que hace que los clientes actualicen su caché con lo que tú les indiques. Ten en cuenta, sin embargo, que solo funciona para tráfico DNS estándar sin cifrar (no se filtran ni suplantan DOT/DOH).
Los filtros DNS y los dominios para suplantación se pueden configurar en la sección dns_filter del archivo de configuración YAML. Todas las listas aceptan URLs, rutas de archivos y entradas similares a las que se encuentran habitualmente en el archivo hosts, consulta https://en.wikipedia.org/wiki/Hosts_(file)>).
Ejemplo:```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 anuncios y rastreadores para todos los dispositivos LAN
- Control parental mediante el bloqueo de categorías específicas de sitios web
- Bloquear dominios conocidos de phishing y malware
- Redirección de tráfico para análisis
- Captura de credenciales mediante redirección
- Secuestro y manipulación de tráfico (inyectar anuncios, scripts, seguimiento)
- Vigilancia y elaboración de perfiles
Configuración mínima para esta configuración:```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"]
Ejecutar:```shell sudo ./gohpts -f ./gohpts_dns_spoof.yaml
Más información se puede encontrar aquí: [https://en.wikipedia.org/wiki/DNS_spoofing](https://en.wikipedia.org/wiki/DNS_spoofing)
## Captura de Paquetes
[[Back]](#table-of-contents)
El tráfico se puede capturar en formatos pcap, pcapng o txt personalizados y luego analizarse con herramientas como Wireshark, tcpdump y muchas otras.
Primero, asegúrate de que el ejecutable `GoHPTS` tenga privilegios elevados para poder capturar paquetes sin procesar; tienes dos opciones:
- Ejecuta `sudo setcap cap_net_raw+ep ~/go/bin/gohpts` una vez para dar al proxy acceso al tráfico sin procesar
- Ejecuta el proxy con `sudo` cuando necesites especificar el flag `-pcap` en la CLI o `pcap.enabled` en la configuración de archivo.
Configura el proxy usando la CLI:```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"
Archivo de configuración:```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"
Estos comandos producen tres archivos de captura de paquetes con formatos correspondientes que posteriormente pueden ser analizados por varias herramientas.
Para más información sobre las opciones de pcap, consulte `gohpts -h` y [https://github.com/shadowy-pycoder/mshark](https://github.com/shadowy-pycoder/mshark)
## Espacios de Nombres de Red
[[Volver]](#table-of-contents)
Por defecto, el proxy `GoHPTS` se ejecuta dentro de un único espacio de nombres de red, pero esto se puede anular. Los sockets de escucha (por ejemplo, servidor http o servidor proxy transparente) y los sockets de salida (proxy socks o marcador directo) creados por `GoHPTS` pueden aislarse con los [espacios de nombres de red (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html) de Linux/Android. Al iniciar el proceso proxy, los usuarios pueden especificar los indicadores `-in-netns` (oyentes) y `-out-netns` (marcadores) con el nombre o la ruta al espacio de nombres de red para controlar en qué entorno aislado crear los sockets. Si desea crear oyentes o marcadores en el espacio de nombres actual (predeterminado), simplemente omita el indicador. Para especificar explícitamente el espacio de nombres del host, puede usar la ruta `/proc/1/ns/net`; esto permite que el proxy identifique correctamente los servidores de nombres del sistema.
`GoHPTS` admite la convención [ip-netns (8)](https://man7.org/linux/man-pages/man8/ip-netns.8.html) para proporcionar configuración de red a través de archivos ubicados en el directorio `/etc/netns/NAME/`. Por lo tanto, para especificar servidores de nombres personalizados para el espacio de nombres de red `ns1`, haga lo siguiente:```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
Si no se encuentra ninguna configuración, se usarán los servidores DNS de Google para resolver nombres de dominio.
Si tu sistema tiene systemd-resolved.service (8) habilitado, es posible que quieras deshabilitarlo temporalmente al realizar consultas a través de namespaces de red 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'
O hazlo persistente para una instancia de shell específica:```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 y cert.pem: ```shell
openssl req -x509 -newkey rsa:2048 ns1 y configurar la red 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
wlan0 para poder conectarse al socks5 local ```shell
WLAN_IP=$(ip -4 -c=never route get 8.8.8.8 | awk '{print $7}' | tr -d '\n')
Proxy HTTP - listeners del proxy en ns1 (sin ruta predeterminada, sin acceso a internet), sockets salientes en el host
Ejecutar proxy: ```shell sudo ./bin/gohpts -s 0.0.0.0:1080 -l :8083 -4 -6 -d -sniff -body -in-netns ns1
Hacer solicitud a través de ns1 ```shell
sudo ip netns exec ns1 curl -Nv --proxy http://127.0.0.1:8083 https://example.com
La solicitud debería tener éxito
2. **Proxy HTTP2 - listeners de proxy en `ns1` (sin ruta predeterminada, sin acceso a internet), sockets de salida en el host**
Ejecutar 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
Haga una solicitud mediante ns1 ```shell
sudo ip netns exec ns1 curl -Nvk --http2 --proxy-insecure --proxy-http2 --proxy https://127.0.0.1:8083 https://example.com
La solicitud debería tener éxito
3. **Proxy HTTP3 - listeners de proxy en `ns1` (sin ruta predeterminada, sin acceso a internet), sockets de salida en el host**
Ejecutar 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
Haga la solicitud a través de ns1 ```shell
sudo ip netns exec ns1 ./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
La solicitud debería tener éxito
4. **Proxy transparente de redirección (`-M redirect`) - listeners del proxy en `ns1` (ruta predeterminada, sin acceso a internet), sockets salientes en el host**
Ejecutar 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
Haz una solicitud mediante ns1 ```shell
sudo ip netns exec ns1 curl -Nv https://example.com
La solicitud debería fallar
Añadir ruta predeterminada a `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
Inténtalo de nuevo ```shell sudo ip netns exec ns1 curl -Nv https://example.com
Ahora la solicitud debería tener éxito
5. **Proxy HTTP: listeners de proxy en el host, sockets de salida en `ns1` (ruta predeterminada, acceso a internet)**
Agregue reglas NAT para permitir que `ns1` se conecte a internet a través de `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
Ejecutar proxy: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0
Realizar solicitud via host ```shell
curl -Nv --proxy http://$WLAN_IP:8083 https://example.com
La solicitud debería tener éxito
HTTP3 proxy - listeners del proxy en el host, sockets de salida en ns1 (ruta predeterminada, acceso a internet)
Ejecutar el proxy: ``` sudo ./bin/gohpts -s :1080 -l :8083 -4 -6 -d -sniff -body -out-netns ns1 -i wlan0 -c ./cert.pem -k ./key.pem
Hacer solicitud a través del host ```shell ./http3-socks-proxy/bin/client -a $WLAN_IP:8083 www.google.com
La solicitud debería tener éxito
7. **Proxy transparente de redirección: listeners de proxy en el host, sockets de salida en `ns1` (ruta predeterminada, acceso a internet)**
Ejecutar proxy (`-auto` no funciona con un servidor socks5 local para mí, así que uso uno remoto): ```
sudo ./bin/gohpts -s <remote> -4 -6 -d -sniff -body -out-netns ns1 -nohttp -M redirect -T :8888 -auto
Hacer solicitud a través del host ```shell curl -Nv https://example.com
La solicitud debería tener éxito
8. **Proxy HTTP - LAN (`ns2` (oyentes de proxy), `ns3`, `ns4`), sockets de salida en `ns1` (ruta predeterminada, acceso a internet)**
Crear 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
Ejecuta 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
Hacer solicitudes ```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 las solicitudes deberían tener éxito
HTTP3 proxy - LAN (ns2 (proxy listeners), ns3, ns4), sockets de salida en ns1 (default route, acceso a internet)
Ejecutar 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
Hacer solicitudes ```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
Todas las solicitudes deberían tener éxito
10. **Proxy transparente de redirección - LAN (`ns2` (oyentes del proxy), `ns3`, `ns4`), sockets de salida en `ns1` (ruta predeterminada, acceso a internet)**
Ejecutar 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
```
Realizar solicitudes
```shell
sudo ip netns exec ns2 curl -Nv https://example.com
```
Para `ns3` y `ns4` la solicitud falla
11. **Proxy transparente con `IP_TRANSPARENT` (suplantación arp/ndp habilitada) LAN (`ns2` (oyentes del proxy), `ns3`, `ns4`), sockets de salida en `ns1` (ruta predeterminada, acceso a internet)**
Ejecutar 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"
```
Ahora las solicitudes anteriores en `ns3` y `ns4` deberían funcionar
```
sudo ip netns exec ns3 curl -Nv https://example.com
sudo ip netns exec ns4 curl -Nv https://example.com
```
12. **Proxy HTTP3 - oyentes del proxy en `ns1`, sockets de salida en el host, bandera `-nosocks`**
Ejecutar 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
```
Realizar solicitud
```shell
./http3-socks-proxy/bin/client -a 10.0.0.2:8083 www.google.com
```
La solicitud debería tener éxito
13. **Proxy HTTP3 - oyentes del proxy en el host, sockets de salida en `ns1`, bandera `-nosocks`**
Ejecutar 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
```
Realizar solicitud
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
La solicitud debería fallar
Agregar reglas a la cadena `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
```
Realizar solicitud
```shell
./http3-socks-proxy/bin/client -a 127.0.0.1:8083 www.google.com
```
La solicitud debería tener éxito
## Servidor mixto
[[Volver]](#table-of-contents)
`GoHPTS` se puede configurar para escuchar conexiones SOCKS en la misma dirección que el servidor HTTP, solo agregue la bandera `-mixed` para poner en marcha un servidor SOCKS adicional. Esto permite que `GoHPTS` actúe no solo como un proxy `HTTP-a-SOCKS` sino también como un proxy `SOCKS-a-SOCKS`. El servidor SOCKS5 local admite el comando `UDP ASSOCIATE`, por lo que técnicamente los usuarios pueden enviar datagramas UDP con este servidor mixto.
Ejecutar proxy:```shell
gohpts -s :1080 -l :8080 -mixed
Probar conexión:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
O deshabilitar el proxy SOCKS upstream y conectarse directamente añadiendo `-nosocks`:```shell
gohpts -l :8080 -mixed -nosocks
Prueba de conexión:```shell curl -Nv --proxy socks5://127.0.0.1:8080 "https://example.com"
Agregue el indicador `-socks4` para usar el protocolo SOCKS4 en su lugar:```shell
# :1080 should be a socks4 server
gohpts -s :1080 -l :8080 -mixed -socks4
Probar conexión:```shell curl -Nv --proxy socks4://127.0.0.1:8080 "https://example.com"
## Enlaces
[[Back]](#table-of-contents)
Obtén más información sobre proxies transparentes visitando los siguientes enlaces:
- [Transparent proxy support in Linux Kernel](https://docs.kernel.org/networking/tproxy.html)
- [Transparent proxy tutorial by Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Simple tproxy example](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Transparent Proxy Implementation using eBPF and Go](https://medium.com/all-things-ebpf/building-a-transparent-proxy-with-ebpf-50a012237e76)
- [https://github.com/heiher/hev-socks5-tproxy](https://github.com/heiher/hev-socks5-tproxy)
proxy `socks5` con soporte para `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)
Seguridad de red 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/)
## Contribuciones
[[Back]](#table-of-contents)
¿Eres desarrollador?
- Haz un fork del repositorio
- Crea tu rama de características: `git switch -c my-new-feature`
- Confirma tus cambios: `git commit -am 'Add some feature'`
- Sube a la rama: `git push origin my-new-feature`
- Envía un pull request
## Licencia
[[Back]](#table-of-contents)
GPLv3