go-http-proxy-to-socks — CLI 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. | Kitploit

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

Instalar usando el comando 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

Compilar desde el código fuente: ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make build ./bin/gohpts
Ejecutar en docker: ```shell docker run -it --privileged --network host -v "$PWD/gohpts.yaml:/config.yaml" shadowypycoder/gohpts:latest -f config.yaml

Especifique 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

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"

I'm sorry, but I don't see any content to translate in your message. You mentioned "INPUT:" but no actual text followed it.

Please provide the Markdown content from chunk 31 that you'd like me to translate from English to Spanish, and I'll return only the translated text with all Markdown structure, code, paths, URLs, and technical identifiers preserved exactly as-is.```shell
# output
gohpts pid: <pid>

# Escanear un objetivo único
scanner scan --target example.com

# Escanear múltiples objetivos desde un archivo
scanner scan --file targets.txt --output results.json

# Escanear con opciones personalizadas
scanner scan --target example.com --port 443 --timeout 30 --verbose

# Usar un archivo de configuración
scanner scan --config config.yaml

# Escanear y enviar resultados a la API
scanner scan --target example.com --server http://localhost:8080 --token YOUR_TOKEN

# config.yaml
server:
  url: "http://localhost:8080"
  token: "your-api-token"
  timeout: 30

scanner:
  threads: 10
  timeout: 5
  retries: 3
  user_agent: "Mozilla/5.0 (compatible; Scanner/1.0)"

output:
  format: "json"
  verbose: false
  color: true

logging:
  level: "info"
  file: "scanner.log"
  max_size: 100
  max_backups: 5
  max_age: 30

# Configuración del servidor
export SCANNER_SERVER_URL="http://localhost:8080"
export SCANNER_API_TOKEN="your-api-token"

# Configuración del escáner
export SCANNER_THREADS=10
export SCANNER_TIMEOUT=5
export SCANNER_USER_AGENT="Mozilla/5.0 (compatible; Scanner/1.0)"

# Configuración de salida
export SCANNER_OUTPUT_FORMAT="json"
export SCANNER_VERBOSE=false
export SCANNER_COLOR=true

# Configuración de registro
export SCANNER_LOG_LEVEL="info"
export SCANNER_LOG_FILE="scanner.log"

# Clonar el repositorio
git clone https://github.com/example/scanner.git
cd scanner

# Instalar dependencias
go mod download

# Compilar
make build

# Compilar para múltiples plataformas
make build-all

# Ejecutar pruebas
make test

# Ejecutar pruebas con cobertura
make test-coverage

# Ejecutar linter
make lint

# Limpiar artefactos de compilación
make clean

scanner/
├── cmd/
│   └── scanner/
│       └── main.go
├── internal/
│   ├── api/
│   │   ├── client.go
│   │   └── models.go
│   ├── config/
│   │   └── config.go
│   ├── scanner/
│   │   ├── port.go
│   │   ├── web.go
│   │   └── vuln.go
│   └── utils/
│       └── helpers.go
├── pkg/
│   └── logger/
│       └── logger.go
├── configs/
│   └── config.yaml
├── scripts/
│   └── build.sh
├── docs/
│   └── README.md
├── go.mod
├── go.sum
├── Makefile
└── README.md

# Ejecutar todas las pruebas
go test ./...

# Ejecutar pruebas con cobertura
go test -cover ./...

# Ejecutar pruebas de un paquete específico
go test ./internal/scanner/...

# Ejecutar pruebas con salida detallada
go test -v ./...

# Ejecutar benchmarks
go test -bench=. ./...

# Ejecutar el escáner
docker run --rm scanner:latest scan --target example.com

# Ejecutar con variables de entorno
docker run --rm \
  -e SCANNER_SERVER_URL=http://localhost:8080 \
  -e SCANNER_API_TOKEN=your-token \
  scanner:latest scan --target example.com

# Ejecutar con volúmenes montados
docker run --rm \
  -v $(pwd)/config.yaml:/app/config.yaml \
  -v $(pwd)/results:/app/results \
  scanner:latest scan --config /app/config.yaml --output /app/results/output.json

version: '3.8'

services:
  scanner:
    build: .
    environment:
      - SCANNER_SERVER_URL=http://api:8080
      - SCANNER_API_TOKEN=your-token
    volumes:
      - ./config.yaml:/app/config.yaml
      - ./results:/app/results
    command: scan --config /app/config.yaml

  api:
    image: scanner-api:latest
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/scanner
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=scanner
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Método	Endpoint	Descripción
GET	`/api/v1/health`	Verificación de estado
GET	`/api/v1/version`	Información de versión
POST	`/api/v1/scans`	Crear un nuevo escaneo
GET	`/api/v1/scans`	Listar todos los escaneos
GET	`/api/v1/scans/{id}`	Obtener detalles del escaneo
DELETE	`/api/v1/scans/{id}`	Eliminar un escaneo
GET	`/api/v1/scans/{id}/results`	Obtener resultados del escaneo
GET	`/api/v1/scans/{id}/status`	Obtener estado del escaneo

# Usar token Bearer
curl -H "Authorization: Bearer YOUR_TOKEN" \
  http://localhost:8080/api/v1/scans

# Usar clave API
curl -H "X-API-Key: YOUR_API_KEY" \
  http://localhost:8080/api/v1/scans

# Crear un nuevo escaneo
curl -X POST http://localhost:8080/api/v1/scans \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{
    "target": "example.com",
    "type": "full",
    "options": {
      "ports": "1-1000",
      "timeout": 30,
      "threads": 10
    }
  }'

# Obtener resultados del escaneo
curl -H "Authorization: Bearer YOUR_TOKEN" \
  http://localhost:8080/api/v1/scans/123/results

# Listar todos los escaneos
curl -H "Authorization: Bearer YOUR_TOKEN" \
  "http://localhost:8080/api/v1/scans?page=1&limit=10"

# Aumentar el número de hilos
scanner scan --target example.com --threads 50

# Reducir el tiempo de espera
scanner scan --target example.com --timeout 2

# Usar escaneo SYN (requiere root)
sudo scanner scan --target example.com --syn

# Verificar la conectividad de red
ping example.com

# Verificar la resolución DNS
nslookup example.com

# Probar con un tiempo de espera mayor
scanner scan --target example.com --timeout 60

# Verificar la configuración del proxy
export HTTP_PROXY=http://proxy:8080
export HTTPS_PROXY=http://proxy:8080

# Habilitar registro de depuración
scanner scan --target example.com --debug

# Habilitar salida detallada
scanner scan --target example.com --verbose

# Establecer el nivel de registro
export SCANNER_LOG_LEVEL=debug
scanner scan --target example.com

Los flags `-u` y `-U` no funcionan en modo daemon (y por lo tanto en la autenticación), pero puedes 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 quieres preconfigurar tu proxy sin complicarte demasiado con la CLI o simplemente quieres múltiples perfiles para diferentes necesidades.

Ejecutar el proxy http en modo cadena de proxy SOCKS5 (especificar la configuración del servidor mediante el archivo de configuración YAML)```shell
gohpts -f "~/gohtps.yaml" -d -j

Puedes sobrescribir casi cualquier configuración especificada en el archivo de configuración proporcionando los flags CLI correspondientes:```shell
gohpts -l :6969 -f "~/gohtps.yaml" -nocolor

| `-s` | `--server` | `SERVER` | `http://localhost:8080` | URL del servidor |
| `-t` | `--token` | `TOKEN` | - | Token de autenticación |
| `-o` | `--output` | `FILE` | `stdout` | Archivo de salida |
| `-f` | `--format` | `FORMAT` | `json` | Formato de salida |
| `-v` | `--verbose` | - | `false` | Salida detallada |
| `-q` | `--quiet` | - | `false` | Modo silencioso |
| `-h` | `--help` | - | - | Mostrar ayuda |
| `-V` | `--version` | - | - | Mostrar versión |

### Ejemplos de uso

```bash
# Escaneo básico
scanner scan --target example.com

# Escaneo con opciones avanzadas
scanner scan --target example.com --port 443 --format json --output results.json

# Escaneo con autenticación
scanner scan --target example.com --token "your-token-here"

# Escaneo silencioso
scanner scan --target example.com --quiet

Variable	Descripción	Valor por defecto
`SCANNER_SERVER`	URL del servidor	`http://localhost:8080`
`SCANNER_TOKEN`	Token de autenticación	-
`SCANNER_TIMEOUT`	Tiempo de espera en segundos	`30`
`SCANNER_VERBOSE`	Habilitar salida detallada	`false`

server: http://localhost:8080
token: your-token-here
timeout: 30
verbose: false
output:
  format: json
  file: results.json
``````shell
# run socks5 server on 127.0.0.1:1080
ssh remote -D 1080 -Nf

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

Ten en cuenta que la configuración automática requiere `sudo` y es muy genérica, por lo que podría no ser adecuada para tus necesidades.

Opcionalmente, puedes especificar `-mark <value>` para evitar posibles bucles de proxy```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto -mark 100

Para ejecutar `GoHPTS` en este modo se utiliza el flag `-T` junto con `-M tproxy`

### Ejemplo

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


`-h`, `--help`	Muestra el mensaje de ayuda y sale
`-v`, `--version`	Muestra la versión del programa y sale
`-l`, `--log`	Habilita el registro en un archivo
`-o`, `--output`	Especifica el archivo de salida
`-t`, `--threads`	Establece el número de hilos
`-u`, `--url`	Especifica la URL objetivo
`-x`, `--proxy`	Especifica el proxy a utilizar
`-r`, `--recursive`	Habilita el escaneo recursivo
`-d`, `--depth`	Establece la profundidad máxima de recursión
`-a`, `--user-agent`	Establece la cadena del User-Agent
`-c`, `--cookie`	Establece la cookie para las solicitudes
`-H`, `--header`	Establece encabezados personalizados para las solicitudes
`-m`, `--method`	Establece el método HTTP a utilizar
`-b`, `--body`	Establece el cuerpo de la solicitud
`-f`, `--follow`	Sigue las redirecciones
`-k`, `--insecure`	Ignora los errores de certificado SSL
`-s`, `--silent`	Modo silencioso, sin salida
`-q`, `--quiet`	Modo silencioso, salida mínima

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

Ejecute lo siguiente en su 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

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

Este comando configurará tu sistema operativo y pondrá en marcha el servidor en la dirección `0.0.0.0:8989`.

Para probarlo localmente, puedes combinar el proxy transparente UDP con el flag `-arpspoof`. Por ejemplo:

1. Configura una VM en tu sistema con cualquier distribución de Linux que soporte `tproxy` (Kali Linux, por ejemplo).
2. Habilita la red `bridged` para que la VM pueda acceder a tu máquina host.
3. Mueve el binario `gohpts` a la VM (mediante `ssh`, por ejemplo) o compílalo allí en caso de que el SO/arquitectura sean diferentes.
4. En tu VM ejecuta 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"

### Configuración YAML

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

[Volver]```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 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"]
      }
    }
  }
]

## Soporte de HTTP2 y HTTP3

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

El proxy `GoHPTS` maneja solicitudes HTTP/1.1, HTTP/2 y HTTP/3 usando la misma dirección de servidor y certificado TLS. Esto permite a los clientes elegir automáticamente el mejor protocolo disponible sin cambiar la configuración. El certificado TLS se puede obtener de varias maneras: proveedores de la nube (Google, AWS, Cloudflare), certificado gratuito de Let's Encrypt, o puede crear un certificado autofirmado usando `openssl` (Linux/macOS) o `New-SelfSignedCertificate` (Windows).

### Ejemplo de configuración usando certificado autofirmado

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

- Cree 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"

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

Finalmente:
1. Crea una configuración mínima para tu proxy ```yaml
gohpts_config.yaml

http_server: address: 127.0.0.1:8080 cert_file: ./cert.pem key_file: ./key.pem

proxy_list:
- address: 127.0.0.1:1080
logging: debug: true

sniffing: enabled: true body: true

### Probar conexión

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

- Para un 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"

Para HTTP/3 es diferente, ya que (en el momento de escribir esto) curl no admite proxy HTTP3, así que usaré mi cliente personalizado que creé con fines de prueba.

Descargue e instale Ejemplo simple de proxy HTTP3 a SOCKS5: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git && cd http3-socks-proxy make

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 la conexión en un navegador

[[Atrás]](#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

Añadir el rootCA.crt recién creado al almacén de confianza del sistema:
1. Debian/Ubuntu: ```shell sudo cp rootCA.crt /usr/local/share/ca-certificates/rootCA.crt sudo update-ca-certificates

Para probar el proxy en modo IPv4 puedes usar cualquier VM de 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"

3. Visita cualquier sitio web en tu máquina virtual y observa el tráfico en los registros del proxy

Para habilitar el modo `IPv6-only` simplemente añade el flag `-6`, por ejemplo al usarlo con un proxy transparente:```shell
sudo ./gohpts -T 8888 -M redirect -sniff -body -auto -mark 100 -d -6

El proxy escaneará dispositivos en la subred `192.168.10.0/24` y les enviará paquetes ARP para hacerse pasar por la puerta de enlace; si `fullduplex` es true,
el proxy también enviará paquetes ARP a la puerta de enlace para hacerle creer que nuestro proxy tiene cada IP de la subred.

Después de detener el proxy con `Ctrl+C`, automáticamente dejará de suplantar a todos los objetivos.

`GoHPTS` también se puede usar con herramientas como [Bettercap](https://github.com/bettercap/bettercap) para hacer proxy del tráfico suplantado por ARP.

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

Revisa los registros del proxy en busca de tráfico de otros dispositivos de tu LAN

Para obtener 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 de NDP

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

`GoHPTS` tiene funcionalidad integrada para realizar suplantación de NDP en redes IPv6 con paquetes de Router Advertisement (RA) y Neighbor Advertisement (NA). También incluye la opción RDNSS en los 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 de NDP permite que `gohpts` actúe como proxy del tráfico de los clientes en las redes locales. Al igual que en el caso de la [suplantación de ARP](#arp-spoofing), puedes configurar las opciones de suplantación de ndp con un único flag `-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"

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

Casos de uso:

- Bloqueador de anuncios y rastreadores para todos los dispositivos de la 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
- Recolección de credenciales mediante redirección
- Secuestro y manipulación de tráfico (inyectar anuncios, scripts, seguimiento)
- Vigilancia y perfilado

Configuración mínima para esta instalació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"]

Más información disponible aquí: [https://en.wikipedia.org/wiki/DNS_spoofing](https://en.wikipedia.org/wiki/DNS_spoofing)

## Captura de paquetes

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

El tráfico se puede capturar en formatos pcap, pcapng o txt personalizado y posteriormente 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 otorgar 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 del archivo.

Configura el proxy usando la CLI:```shell
gohpts -pcap "promisc true;timeout 10s;exts txt,pcap,pcapng"

Estos comandos producen tres archivos de captura de paquetes con los formatos correspondientes que luego pueden ser analizados por diversas herramientas.

Para obtener 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 puede sobrescribirse. 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 [network_namespaces (7)](https://man7.org/linux/man-pages/man7/network_namespaces.7.html) de Linux/Android. Al iniciar el proceso proxy, los usuarios pueden especificar las banderas `-in-netns` (listeners) y `-out-netns` (dialers) con el nombre o la ruta al espacio de nombres de red para controlar en qué entorno aislado crear los sockets. Si desea crear listeners o dialers en el espacio de nombres actual (predeterminado), simplemente omita la bandera. 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 de [ip-netns (8)](https://man7.org/linux/man-pages/man8/ip-netns.8.html) para proporcionar configuración de red mediante 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

O hazlo persistente para una instancia específica del shell:```shell
sudo ip netns exec ns1 unshare --mount bash -c '
    mount --bind /dev/null /run/systemd/resolve/io.systemd.Resolve
    exec bash --login'

Ejecutar servidor socks5 con soporte UDP ASSOCIATE ```shell git clone https://github.com/wzshiming/socks5.git && cd socks5 go build -o socks5_server ./cmd/socks5/main.go ./socks5_server -a 0.0.0.0:1080
Descarga e instala Ejemplo simple de proxy HTTP3 a SOCKS5: ```shell git clone https://github.com/shadowy-pycoder/http3-socks-proxy.git cd http3-socks-proxy make
Clona el repositorio y compila ```shell git clone https://github.com/shadowy-pycoder/go-http-proxy-to-socks.git cd go-http-proxy-to-socks make
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"
Crear un espacio de nombres de red 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
Determinar la dirección IP de 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 de proxy en ns1 (sin ruta por defecto, sin acceso a internet), sockets de salida en el host

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

La solicitud debe tener éxito

2. **Proxy HTTP2 - listeners de proxy en `ns1` (sin ruta predeterminada, sin acceso a internet), sockets de salida en el host**

Ejecutar el 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

La solicitud debe tener éxito

3. **Proxy HTTP3 - listeners de proxy en `ns1` (sin ruta por defecto, sin acceso a internet), sockets de salida en el host**

Ejecutar el 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

La solicitud debe tener éxito

4. **Proxy transparente de redirección (`-M redirect`) - listeners de proxy en `ns1` (ruta predeterminada, sin acceso a internet), sockets de salida en el host**

Ejecutar el 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

La solicitud debe 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

Ahora la solicitud debería tener éxito

5. **Proxy HTTP - escuchas de proxy en el host, sockets salientes en `ns1` (ruta predeterminada, acceso a internet)**

Añade 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

Proxy HTTP3 - listeners de 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

La solicitud debe 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 el servidor socks5 local en mi caso, así que uso uno remoto):   ```
sudo ./bin/gohpts -s <remote> -4 -6 -d -sniff -body -out-netns ns1 -nohttp -M redirect -T :8888 -auto

La solicitud debe tener éxito

8. **Proxy HTTP - LAN (`ns2` (listeners del proxy), `ns3`, `ns4`), sockets de salida en `ns1` (ruta por defecto, 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

Realizar 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

Proxy HTTP3 - LAN (ns2 (escuchas del proxy), ns3, ns4), sockets de salida en ns1 (ruta predeterminada, acceso a internet)

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

Todas las solicitudes deberían tener éxito

10. **Proxy transparente de redirección - LAN (`ns2` (escuchas 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` (escuchas 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 - escuchas del proxy en `ns1`, sockets de salida en el host, flag `-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 - escuchas del proxy en el host, sockets de salida en `ns1`, flag `-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

[[Atrás]](#table-of-contents)

`GoHPTS` se puede configurar para escuchar conexiones SOCKS en la misma dirección que el servidor HTTP, solo agregue el flag `-mixed` para iniciar un servidor SOCKS adicional. Esto permite que `GoHPTS` actúe no solo como proxy `HTTP-to-SOCKS` sino también como proxy `SOCKS-to-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

## Enlaces

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

Obtén más información sobre los proxies transparentes visitando los siguientes enlaces:

- [Soporte de proxy transparente en el kernel de Linux](https://docs.kernel.org/networking/tproxy.html)
- [Tutorial de proxy transparente de Gost](https://latest.gost.run/en/tutorials/redirect/)
- [Ejemplo simple de tproxy](https://github.com/FarFetchd/simple_tproxy_example)
- [Golang TProxy](https://github.com/KatelynHaworth/go-tproxy)
- [Implementación de proxy transparente usando eBPF y 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 de `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/)

## Contribuir

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

¿Eres desarrollador?

- Haz un fork del repositorio
- Crea tu rama de funcionalidad: `git switch -c my-new-feature`
- Confirma tus cambios: `git commit -am 'Add some feature'`
- Sube los cambios a la rama: `git push origin my-new-feature`
- Envía una pull request

## Licencia

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

GPLv3

Código	Descripción
`0`	Éxito
`1`	Error general
`2`	Argumentos inválidos
`3`	Error de conexión
`4`	Error de autenticación

go-http-proxy-to-socks

Más Populares

GoHPTS - Proxy transparente HTTP(S) y TCP/UDP a proxy SOCKS4/SOCKS5 (cadena) escrito en Go

Tabla de contenidos

Introducción

Características

Instalación

Uso

Ejemplos de Uso

Características

Escaneo de Puertos

Escaneo Web

Análisis de Vulnerabilidades

Integración con API

Configuración

Archivo de Configuración

Variables de Entorno

Desarrollo

Requisitos

Compilación

Estructura del Proyecto

Pruebas

Docker

Construir la Imagen

Ejecutar el Contenedor

Docker Compose

API

Endpoints

Autenticación

Ejemplos

Solución de Problemas

Problemas Comunes

El escaneo es demasiado lento

Errores de conexión

Permiso denegado

Modo de Depuración

Obtener Ayuda

Contribución

Cómo Contribuir

Directrices de Contribución

Mensajes de Confirmación

Registro de Cambios

v1.0.0 (2024-01-01)

v0.9.0 (2023-12-01)

Licencia

Agradecimientos

Soporte

kill the process

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

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

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

list of socks5 proxy

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

Explanations for chains taken from /etc/proxychains4.conf

strict - Each connection will be done via chained proxies

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

all proxies must be online to play in chain

dynamic - Each connection will be done via chained proxies

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

at least one proxy must be online to play in chain

(dead proxies are skipped)

random - Each connection will be done via random proxy

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

this option is good to test your IDS :)

round_robin - Each connection will be done via chained proxies

of chain_len length

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

at least one proxy must be online to play in chain

(dead proxies are skipped).

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

proxy in the previously invoked proxy chain.

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

start at the beginning again.

These semantics are not guaranteed in a multithreaded environment.

defaults to standard output

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

profiling data

Proxy transparente

redirect (mediante NAT y SO_ORIGINAL_DST)

Ejemplo

`redirect` (mediante NAT y SO_ORIGINAL_DST)

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

create `GOHPTS` nat chain

Configuración automática para el modo `redirect`

`tproxy` (mediante MANGLE e IP_TRANSPARENT)

Configuración automática para el modo `tproxy`