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.
# GoHPTS - Proxy transparente HTTP(S) y TCP/UDP a proxy SOCKS4/SOCKS5 (cadena) escrito en Go
[](https://www.gnu.org/licenses/gpl-3.0)
[](https://pkg.go.dev/github.com/shadowy-pycoder/go-http-proxy-to-socks)









## Tabla de contenidos
- [Introducción](#introduction)
- [Características](#features)
- [Instalación](#installation)
- [Uso](#usage)
- [Configuración mediante flags de CLI](#configuration-via-cli-flags)
- [Configuración mediante archivo YAML](#configuration-via-yaml-file)
- [Proxy transparente](#transparent-proxy)
- [redirect (mediante NAT y SO_ORIGINAL_DST)](#redirect-via-nat-and-so_original_dst)
- [Configuración automática para el modo redirect](#auto-configuration-for-redirect-mode)
- [tproxy (mediante MANGLE e IP_TRANSPARENT)](#tproxy-via-mangle-and-ip_transparent)
- [Configuración automática para el modo tproxy](#auto-configuration-for-tproxy-mode)
- [Soporte UDP](#udp-support)
- [Soporte Android](#android-support)
- [Configuración YAML](#yaml-configuration)
- [Sniffing de tráfico](#traffic-sniffing)
- [Formato JSON](#json-format)
- [Formato con colores](#colored-format)
- [Soporte HTTP2 y HTTP3](#http2-and-http3-support)
- [Ejemplo de configuración usando certificado autofirmado](#example-setup-using-self-signed-certificate)
- [Probar conexión](#test-connection)
- [Probar conexión en un navegador](#test-connection-in-a-browser)
- [Soporte IPv4 e IPv6](#ipv4-and-ipv6-support)
- [ARP spoofing](#arp-spoofing)
- [NDP spoofing](#ndp-spoofing)
- [DNS spoofing](#dns-spoofing)
- [Captura de paquetes](#packet-capture)
- [Espacios de nombres de red](#network-namespaces)
- [Configuración del entorno de pruebas](#playground-setup)
- [Ejemplos de uso](#usage-examples)
- [Servidor mixto](#mixed-server)
- [Enlaces](#links)
- [Contribuir](#contributing)
- [Licencia](#license)
## Introducción
[[Volver]](#table-of-contents)
La herramienta de 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 estándar
o HTTPS (mediante CONNECT) y reenvía la conexión a través de un proxy SOCKS5. Inspirado por [http-proxy-to-socks](https://github.com/oyyd/http-proxy-to-socks) y [Proxychains](https://github.com/rofl0r/proxychains-ng)
Posible caso de uso: 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 <remote server> -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
## Características
[[Volver]](#table-of-contents)
- **Funcionalidad de cadena de proxies**\
Admite cadenas `strict`, `dynamic`, `random`, `round_robin` de proxies SOCKS4/SOCKS5
- **Proxy transparente**\
Admite modos `redirect` (SO_ORIGINAL_DST) y `tproxy` (IP_TRANSPARENT)
- **Soporte de IPv4 e IPv6**\
Opera en modos `IPv4-only`, `IPv6-only` o `dual stack`
- **Proxy transparente TCP y UDP**\
`tproxy` y `tlocal` (IP_TRANSPARENT) manejan tráfico TCP y UDP
- **Sniffing de tráfico**\
El proxy es capaz de analizar cabeceras HTTP, handshake TLS, mensajes DNS y más
- **ARP spoofing**\
Proxy de subredes enteras con el enfoque de ARP spoofing
- **NDP spoofing**\
Proxy de conexiones IPv6 usando Router/Neighbor Advertisement e inyecciones RDNSS.
- **DNS spoofing**\
Redirige clientes a dominios arbitrarios mediante la manipulación de registros DNS
- **Captura de paquetes**\
Captura tráfico en archivos txt/pcap/pcapng y analiza con Wireshark
- **Protección contra fugas de DNS**\
La resolución DNS ocurre en el lado del servidor SOCKS5.
- **Soporte del método CONNECT**\
Admite tunneling HTTP CONNECT, habilitando HTTPS y otros protocolos basados en TCP.
- **Soporte de HTTP2/HTTP3**\
Admite transporte moderno HTTP/2 y HTTP/3, habilitando conexiones multiplexadas eficientes sobre TLS 1.3
- **Soporte de Network Namespaces**\
Admite network namespaces personalizados de Linux para sockets de escucha y conexiones salientes
- **Soporte de Trailer Headers**\
Maneja cabeceras trailer HTTP
- **Chunked Transfer Encoding**\
Maneja respuestas chunked y en streaming
- **Soporte de autenticación SOCKS5**\
Admite autenticación con nombre de usuario/contraseña para proxies SOCKS5.
- **Soporte de autenticación HTTP**\
Admite autenticación con nombre 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.
## Instalación
[[Volver]](#table-of-contents)
- Arch Linux/CachyOS/EndeavourOS ```shell
yay -S gohpts
```
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.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](https://go.dev/doc/install) 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`.
- 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
```
## Uso
[[Volver]](#table-of-contents)```shell
gohpts -h
_____ _ _ _____ _______ _____
/ ____| | | | | __ \__ __/ ____|
| | __ ___ | |__| | |__) | | | | (___
| | |_ |/ _ \| __ | ___/ | | \___ \
| |__| | (_) | | | | | | | ____) |
\_____|\___/|_| |_|_| |_| |_____/
GoHPTS: HTTP(S) Proxy to SOCKS4/SOCKS5 proxy by shadowy-pycoder
GitHub: https://github.com/shadowy-pycoder/go-http-proxy-to-socks
Codeberg: https://codeberg.org/shadowy-pycoder/go-http-proxy-to-socks
Usage: gohpts [OPTIONS]
OPTIONS:
General:
-h Show this help message and exit
-v Show version and build information
-D Run as a daemon (provide -logfile to see logs)
-I Display list of network interfaces and exit
-f Path to proxy configuration file in YAML format
Proxy:
-l Address of HTTP proxy server (Default: "127.0.0.1:8080" for IPv4, "[::1]:8080" for IPv6)
-s Address of SOCKS proxy server (Default: "127.0.0.1:1080" for IPv4 "[::1]:1080" for IPv6)
-c Path to certificate PEM encoded file
-k Path to private key PEM encoded file
-U User for HTTP proxy (basic auth). This flag invokes prompt for password (not echoed to terminal)
-u User for SOCKS proxy authentication. This flag invokes prompt for password (not echoed to terminal)
-i Bind proxy to specific network interface (either by interface name or index)
-4 Force IPv4 stack for TCP and UDP (Default: dual stack)
-6 Force IPv6 stack for TCP and UDP (Default: dual stack)
-socks4 Use SOCKS4/SOCKS4a protocol for upstream proxy and mixed server (default: SOCKS5/SOCKS5h)
-nohttp Disable HTTP proxy server
-nosocks Disable SOCKS upstream proxy
-dns Use custom DNS server (Example: "8.8.8.8" or "2001:4860:4860::8888")
-mixed Accept SOCKS connections on HTTP proxy server address
Logs:
-d Show logs in DEBUG mode
-j Show logs in JSON format
-logfile Log file path (Default: stdout)
-nocolor Disable colored output for logs (no effect if -j flag specified)
-pprof Address of pprof server with profiling data
Sniffing:
-sniff Enable traffic sniffing for HTTP and TLS
-snifflog Sniffed traffic log file path (Default: the same as -logfile)
-body Collect request and response body for HTTP traffic (credentials, tokens, etc)
TProxy:
-T Address of transparent proxy server
-Tu Address of transparent UDP proxy server
-M Transparent proxy mode: (redirect, tproxy, tlocal)
-w Number of instances of transparent proxy server (Default: number of CPU cores)
-wu Number of instances of transparent UDP proxy server (Default: number of CPU cores)
-auto Automatically setup iptables and kernel parameters for transparent proxy (requires elevated privileges)
-mark Set mark for each packet sent through transparent proxy (Default: redirect 0, tproxy 100, tlocal 100)
-A Comma separated list of allowed ip addresses for proxying (Example: "8.8.8.8,2001:4860:4860::8888,192.168.1.0/24")
-P Comma separated list of ports to ignore when proxying traffic (Example: "22,80,443,9092")
-dump Dump iptables rules and other system settings generated by -auto flag
Spoofing:
-arpspoof Enable ARP spoof proxy for selected targets (Example: "targets 10.0.0.1,10.0.0.5-10,192.168.1.*,192.168.10.0/24;fullduplex false;debug true;interval 10s")
-ndpspoof Enable NDP spoof proxy for selected targets (Example: "ra true;na true;targets fe80::3a1c:7bff:fe22:91a4;fullduplex false;debug true;interval 10s")
Packet Capture:
-pcap Enable packet capture (Example: "promisc true;expr ip proto tcp;snaplen 65535;timeout 10s;packet_count 100;packet_buffer 8192;exts txt,pcap,pcapng")
Namespaces:
-in-netns Name or path of network namespace for inbound listeners (Default: default namespace)
-out-netns Name or path of network namespace for outbound connections (Default: default namespace)
```
### Configuración mediante flags 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"}
```
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
```
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"
```
Ejecuta el proxy como un demonio (se necesita un archivo de registro para la salida de registro; de lo contrario, no verás nada)```shell
gohpts -D -logfile /tmp/gohpts.log
```
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>
```
| `-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
# 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
```
## Características
### Escaneo de Puertos
- Escaneo TCP connect
- Escaneo SYN (requiere privilegios de root)
- Escaneo UDP
- Detección de servicios y versiones
- Detección de sistema operativo
### Escaneo Web
- Detección de tecnologías web
- Enumeración de directorios
- Detección de vulnerabilidades comunes
- Análisis de cabeceras HTTP
- Detección de WAF
### Análisis de Vulnerabilidades
- Detección de CVEs conocidos
- Pruebas de inyección SQL
- Detección de XSS
- Detección de inclusión de archivos
- Detección de traversal de directorios
### Integración con API
- Envío de resultados en tiempo real
- Gestión de tareas de escaneo
- Programación de escaneos
- Notificaciones y alertas
## Configuración
### Archivo de Configuración
```yaml
# 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
```
### Variables de Entorno
```bash
# 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"
```
## Desarrollo
### Requisitos
- Go 1.21 o superior
- Make
- Docker (opcional)
- Git
### Compilación
```bash
# 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
```
### Estructura del Proyecto
```
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
```
### Pruebas
```bash
# 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=. ./...
```
## Docker
### Construir la Imagen
```bash
# Construir la imagen
docker build -t scanner:latest .
# Construir con argumentos de compilación
docker build --build-arg VERSION=1.0.0 -t scanner:1.0.0 .
```
### Ejecutar el Contenedor
```bash
# 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
```
### Docker Compose
```yaml
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:
```
## API
### Endpoints
| 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 |
### Autenticación
```bash
# 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
```
### Ejemplos
```bash
# 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"
```
## Solución de Problemas
### Problemas Comunes
#### El escaneo es demasiado lento
```bash
# 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
```
#### Errores de conexión
```bash
# 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
```
#### Permiso denegado
```bash
# Ejecutar con privilegios de root para escaneo SYN
sudo scanner scan --target example.com --syn
# Verificar permisos de archivo
ls -la scanner
# Hacer ejecutable
chmod +x scanner
```
### Modo de Depuración
```bash
# 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
```
### Obtener Ayuda
- Documentación: https://docs.example.com/scanner
- Problemas: https://github.com/example/scanner/issues
- Discusiones: https://github.com/example/scanner/discussions
- Discord: https://discord.gg/example
## Contribución
### Cómo Contribuir
1. Hacer un fork del repositorio
2. Crear una rama de característica (`git checkout -b feature/amazing-feature`)
3. Confirmar los cambios (`git commit -m 'Add amazing feature'`)
4. Hacer push a la rama (`git push origin feature/amazing-feature`)
5. Abrir un Pull Request
### Directrices de Contribución
- Seguir el estilo de código de Go
- Escribir pruebas para nuevas características
- Actualizar la documentación
- Ejecutar pruebas y linters antes de confirmar
- Usar mensajes de confirmación convencionales
### Mensajes de Confirmación
```
feat: add new scanning feature
fix: resolve timeout issue
docs: update README
test: add unit tests
refactor: improve code structure
chore: update dependencies
```
## Registro de Cambios
### v1.0.0 (2024-01-01)
- Versión inicial
- Escaneo de puertos
- Escaneo web
- Análisis de vulnerabilidades
- Integración con API
- Soporte para Docker
### v0.9.0 (2023-12-01)
- Versión beta
- Características principales implementadas
- Documentación inicial
## Licencia
Este proyecto está licenciado bajo la Licencia MIT - consulte el archivo [LICENSE](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/LICENSE) para más detalles.
## Agradecimientos
- [Contribuidores](https://github.com/example/scanner/graphs/contributors)
- [Bibliotecas de código abierto](https://github.com/example/scanner/blob/main/THIRD_PARTY_LICENSES.md)
## Soporte
- Correo electrónico: [email protected]
- Twitter: [@example](https://twitter.com/example)
- Sitio web: https://example.com
---
**Descargo de responsabilidad**: Esta herramienta está destinada únicamente a pruebas de seguridad autorizadas. Los usuarios son responsables de cumplir con todas las leyes y regulaciones aplicables. Los autores no se hacen responsables del uso indebido o daños causados por esta herramienta.```shell
# kill the process
kill <pid>
#or
kill $(pidof gohpts)
```
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
```
Ejemplo de configuración:```yaml
# bind proxy to specific network interface (either by interface name or index)
interface: "eth0" # if specified, overrides http server IP address
disable_http: false # disable http proxy (default: false)
disable_socks: false # disable upstream socks proxy (default: false)
# if ipv4 and ipv6 are both false or both true, dual stack is assumed
ipv4: false # this must be enabled for arpspoof (default: false)
ipv6: false # this must be enabled for ndpspoof (default: false)
socks4: false # use SOCKS4/SOCKS4a protocol (tcp only protocol, no udp tproxy or http3 possible) (default: false)
dns: 8.8.8.8 # custom DNS server (used in direct dialer, namespaces, spoofing)
http_server:
address: 127.0.0.1:8080
# username and password for adding basic authentication (comment out to disable auth)
username: username
password: password
# list of socks5 proxy
# if proxy_chain is disabled, uses first server in a list as upstream
proxy_list:
- address: 127.0.0.1:1080
- address: 127.0.0.1:1081
- address: :1082 # empty host means localhost
proxy_chain:
enabled: false
# Explanations for chains taken from /etc/proxychains4.conf
# strict - Each connection will be done via chained proxies
# all proxies chained in the order as they appear in the list
# all proxies must be online to play in chain
# dynamic - Each connection will be done via chained proxies
# all proxies chained in the order as they appear in the list
# at least one proxy must be online to play in chain
# (dead proxies are skipped)
# random - Each connection will be done via random proxy
# (or proxy chain, see chain_len) from the list.
# this option is good to test your IDS :)
# round_robin - Each connection will be done via chained proxies
# of chain_len length
# all proxies chained in the order as they appear in the list
# at least one proxy must be online to play in chain
# (dead proxies are skipped).
# the start of the current proxy chain is the proxy after the last
# proxy in the previously invoked proxy chain.
# if the end of the proxy chain is reached while looking for proxies
# start at the beginning again.
# These semantics are not guaranteed in a multithreaded environment.
type: strict # dynamic, strict, random, round_robin
length: 2 # maximum number of proxy in a chain (works only for random chain and round_robin chain)
logging:
debug: true
json: false
# defaults to standard output
#logfile: /tmp/gohpts.log
# use colored output in logs (no effect if json enabled)
nocolor: false
# profiling data
pprof: 127.0.0.1:8081
```
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
```
El proxy toma todas las configuraciones especificadas en `~/gohpts.yaml` pero levanta el servidor http en `127.0.0.1:6969` en lugar de `127.0.0.1:8080` y también desactiva la salida con colores en los registros.
Algunas configuraciones (p. ej. proxy_chain y filtros dns) solo se pueden configurar mediante archivo.
La versión completa de la configuración se puede encontrar aquí: [example_gohpts.yaml](https://github.com/shadowy-pycoder/go-http-proxy-to-socks/blob/main/resources/example_gohpts.yaml)
Para obtener más información sobre las cadenas de proxy, visite [Proxychains Github](https://github.com/rofl0r/proxychains-ng)
## Proxy transparente
[[Volver]](#table-of-contents)
> También conocido como `proxy de interceptación`, `proxy en línea` o `proxy forzado`, un proxy transparente intercepta la comunicación normal de la capa de aplicación sin requerir ninguna configuración especial del cliente. Los clientes no necesitan ser conscientes de la existencia del proxy. Un proxy transparente normalmente se ubica entre el cliente e Internet, y el proxy realiza algunas de las funciones de una puerta de enlace o enrutador
>
> -- _De [Wiki](https://en.wikipedia.org/wiki/Proxy_server)_
Esta funcionalidad está disponible solo en sistemas Linux y Android (arm64) y requiere configuración adicional (`iptables`, ip route, etc.)
El flag `-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 el flag `-M`
### `redirect` (mediante _NAT_ y _SO_ORIGINAL_DST_)
[[Volver]](#table-of-contents)
En este modo el proxying ocurre 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 se utiliza el flag `-T` con `-M redirect`
### Ejemplo
[[Volver]](#table-of-contents)```shell
# run the proxy
gohpts -s 1080 -T 1090 -M redirect -d
```
| `-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
```
### Códigos de salida
| Código | Descripción |
|--------|-------------|
| `0` | Éxito |
| `1` | Error general |
| `2` | Argumentos inválidos |
| `3` | Error de conexión |
| `4` | Error de autenticación |
## Configuración
### Archivo de configuración
El archivo de configuración se busca en las siguientes ubicaciones:
1. `./config.yaml`
2. `~/.config/scanner/config.yaml`
3. `/etc/scanner/config.yaml`
### Variables de entorno
| 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` |
### Ejemplo de configuración
```yaml
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
```
Configura tu sistema operativo:```shell
# commands below require elevated privileges (you can run it with `sudo -i`)
#enable ip forwarding
sysctl -w net.ipv4.ip_forward=1
# create `GOHPTS` nat chain
iptables -t nat -N GOHPTS
# set no redirection rules for local, http proxy, ssh and redirect proxy itself
iptables -t nat -A GOHPTS -d 127.0.0.0/8 -j RETURN
iptables -t nat -A GOHPTS -p tcp --dport 8080 -j RETURN
iptables -t nat -A GOHPTS -p tcp --dport 1090 -j RETURN
iptables -t nat -A GOHPTS -p tcp --dport 22 -j RETURN
# redirect traffic to transparent proxy
iptables -t nat -A GOHPTS -p tcp -j REDIRECT --to-ports 1090
# setup prerouting by adding our proxy
iptables -t nat -A PREROUTING -p tcp -j GOHPTS
# intercept local traffic for testing
iptables -t nat -A OUTPUT -p tcp -j GOHPTS
```
Probar conexión:```shell
#traffic should be redirected via 127.0.0.1:1090
curl http://example.com
```
| `--no-color` | Desactiva la salida en color |
| `--debug` | Habilita el registro de depuración |
| `--verbose` | Habilita el registro detallado |
| `--version` | Muestra la versión y sale |
| `--help` | Muestra el mensaje de ayuda y sale |```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
```
### Configuración automática para el modo `redirect`
[[Volver]](#table-of-contents)
Para configurar tu sistema automáticamente, ejecuta el siguiente comando:```shell
sudo env PATH=$PATH gohpts -d -T 8888 -M redirect -auto
```
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
```
### `tproxy` (mediante _MANGLE_ e _IP_TRANSPARENT_)
[[Volver]](#table-of-contents)
``````
---
[Read more](https://github.com/shadowy-pycoder/go-http-proxy-to-socks)