rathole-org/ratholeUn proxy inverso ligero y de alto rendimiento para la travesía de NAT, escrito en Rust. Una alternativa a frp y ngrok.
Un proxy inverso seguro, estable y de alto rendimiento para la travesía NAT, escrito en Rust.
rathole, al igual que frp y ngrok, puede ayudar a exponer el servicio en un dispositivo detrás de NAT a Internet, a través de un servidor con una IP pública.
Se puede obtener un rathole completamente funcional desde la página de lanzamientos. O compilar desde el código fuente para otras plataformas y minimizar el binario. También hay una imagen Docker disponible.
El uso de rathole es muy similar a frp. Si tienes experiencia con este último, la configuración te resultará muy sencilla. La única diferencia es que la configuración de un servicio se divide en el lado del cliente y el lado del servidor, y un token es obligatorio.
Para usar rathole, necesitas un servidor con una IP pública y un dispositivo detrás de NAT, donde se encuentren algunos servicios que necesiten exponerse a Internet.
Suponiendo que tienes un NAS en casa detrás de NAT y quieres exponer su servicio SSH a Internet:
Crea server.toml con el siguiente contenido y adáptalo a tus necesidades.
# server.toml
[server]
bind_addr = "0.0.0.0:2333" # `2333` especifica el puerto en el que rathole escucha a los clientes
[server.services.my_nas_ssh]
token = "use_a_secret_that_only_you_know" # Token utilizado para autenticar al cliente para el servicio. Cámbialo a un valor arbitrario.
bind_addr = "0.0.0.0:5202" # `5202` especifica el puerto que expone `my_nas_ssh` a Internet
Luego ejecuta:
./rathole server.toml
Crea client.toml con el siguiente contenido y adáptalo a tus necesidades.
# client.toml
[client]
remote_addr = "myserver.com:2333" # La dirección del servidor. El puerto debe ser el mismo que el puerto en `server.bind_addr`
[client.services.my_nas_ssh]
token = "use_a_secret_that_only_you_know" # Debe ser el mismo que en el servidor para pasar la validación
local_addr = "127.0.0.1:22" # La dirección del servicio que necesita ser reenviado
Luego ejecuta:
./rathole client.toml
myserver.com en el puerto 2333, y cualquier tráfico hacia myserver.com:5202 será reenviado al puerto 22 del cliente.Por lo tanto, puedes hacer ssh myserver.com:5202 para conectarte por SSH a tu NAS.
Para ejecutar rathole como un servicio en segundo plano en Linux, consulta los ejemplos de systemd.
rathole puede determinar automáticamente si ejecutarse en modo servidor o en modo cliente, según el contenido del archivo de configuración, si solo está presente uno de los bloques [server] o [client], como en el ejemplo de Inicio rápido.
Pero los bloques [client] y [server] también se pueden colocar en un mismo archivo. Entonces, en el lado del servidor, ejecuta rathole --server config.toml y en el lado del cliente, ejecuta rathole --client config.toml para indicar explícitamente a rathole el modo de ejecución.
Antes de pasar a la especificación completa de configuración, se recomienda echar un vistazo a los ejemplos de configuración para tener una idea del formato de configuración.
Consulta Transporte para más detalles sobre el cifrado y el bloque transport.
Aquí está la especificación completa de configuración:
[client]
remote_addr = "example.com:2333" # Necesario. La dirección del servidor
default_token = "default_token_if_not_specify" # Opcional. El token por defecto de los servicios, si no definen el suyo propio
heartbeat_timeout = 40 # Opcional. Ponlo a 0 para deshabilitar la prueba de latido a nivel de aplicación. El valor debe ser mayor que `server.heartbeat_interval`. Por defecto: 40 segundos
retry_interval = 1 # Opcional. El intervalo entre reintentos de conexión al servidor. Por defecto: 1 segundo
[client.transport] # Todo el bloque es opcional. Especifica el transporte a usar
type = "tcp" # Opcional. Valores posibles: ["tcp", "tls", "noise"]. Por defecto: "tcp"
[client.transport.tcp] # Opcional. También afecta a `noise` y `tls`
proxy = "socks5://user:[email protected]:1080" # Opcional. El proxy usado para conectarse al servidor. Se admiten `http` y `socks5`.
nodelay = true # Opcional. Determina si habilitar TCP_NODELAY, si es aplicable, para mejorar la latencia pero disminuir el ancho de banda. Por defecto: true
keepalive_secs = 20 # Opcional. Especifica `tcp_keepalive_time` en `tcp(7)`, si es aplicable. Por defecto: 20 segundos
keepalive_interval = 8 # Opcional. Especifica `tcp_keepalive_intvl` en `tcp(7)`, si es aplicable. Por defecto: 8 segundos
[client.transport.tls] # Necesario si `type` es "tls"
trusted_root = "ca.pem" # Necesario. El certificado de la CA que firmó el certificado del servidor
hostname = "example.com" # Opcional. El nombre de host que el cliente usa para validar el certificado. Si no se establece, se usará `client.remote_addr`
[client.transport.noise] # Protocolo Noise. Consulta `docs/transport.md` para una explicación más detallada
pattern = "Noise_NK_25519_ChaChaPoly_BLAKE2s" # Opcional. Valor por defecto como se muestra
local_private_key = "key_encoded_in_base64" # Opcional
remote_public_key = "key_encoded_in_base64" # Opcional
[client.transport.websocket] # Necesario si `type` es "websocket"
tls = true # Si es `true`, usará la configuración en `client.transport.tls`
[client.services.service1] # Un servicio que necesita reenvío. El nombre `service1` se puede cambiar arbitrariamente, siempre que sea idéntico al nombre en la configuración del servidor
type = "tcp" # Opcional. El protocolo que necesita reenvío. Valores posibles: ["tcp", "udp"]. Por defecto: "tcp"
token = "whatever" # Necesario si no se establece `client.default_token`
local_addr = "127.0.0.1:1081" # Necesario. La dirección del servicio que necesita ser reenviado
nodelay = true # Opcional. Sobrescribe `client.transport.nodelay` por servicio
retry_interval = 1 # Opcional. El intervalo entre reintentos de conexión al servidor. Por defecto: hereda la configuración global
[client.services.service2] # Se pueden definir varios servicios
local_addr = "127.0.0.1:1082"
[server]
bind_addr = "0.0.0.0:2333" # Necesario. La dirección en la que el servidor escucha a los clientes. Generalmente solo se necesita cambiar el puerto.
default_token = "default_token_if_not_specify" # Opcional
heartbeat_interval = 30 # Opcional. El intervalo entre dos latidos a nivel de aplicación. Ponlo a 0 para deshabilitar el envío de latidos. Por defecto: 30 segundos
[server.transport] # Igual que `[client.transport]`
type = "tcp"
[server.transport.tcp] # Igual que en el cliente
nodelay = true
keepalive_secs = 20
keepalive_interval = 8
[server.transport.tls] # Necesario si `type` es "tls"
pkcs12 = "identify.pfx" # Necesario. Archivo pkcs12 del certificado y clave privada del servidor
pkcs12_password = "password" # Necesario. Contraseña del archivo pkcs12
[server.transport.noise] # Igual que `[client.transport.noise]`
pattern = "Noise_NK_25519_ChaChaPoly_BLAKE2s"
local_private_key = "key_encoded_in_base64"
remote_public_key = "key_encoded_in_base64"
[server.transport.websocket] # Necesario si `type` es "websocket"
tls = true # Si es `true`, usará la configuración en `server.transport.tls`
[server.services.service1] # El nombre del servicio debe ser idéntico al del cliente
type = "tcp" # Opcional. Igual que en el cliente `[client.services.X.type]`
token = "whatever" # Necesario si no se establece `server.default_token`
bind_addr = "0.0.0.0:8081" # Necesario. La dirección en la que se expone el servicio. Generalmente solo se necesita cambiar el puerto.
nodelay = true # Opcional. Igual que en el cliente
[server.services.service2]
bind_addr = "0.0.0.1:8082"
rathole, como muchos otros programas en Rust, utiliza variables de entorno para controlar el nivel de registro. info, warn, error, debug, trace están disponibles.
RUST_LOG=error ./rathole config.toml
ejecutará rathole solo con el nivel de registro error.
Si no se establece RUST_LOG, el nivel de registro por defecto es info.
Desde v0.4.7, rathole habilita TCP_NODELAY por defecto, lo que debería beneficiar la latencia y las aplicaciones interactivas como RDP o servidores de Minecraft. Sin embargo, disminuye ligeramente el ancho de banda.
Si el ancho de banda es más importante, se puede deshabilitar TCP_NODELAY con nodelay = false.
rathole tiene una latencia similar a frp, pero puede manejar más conexiones, proporcionar mayor ancho de banda y usar menos memoria.
Para más detalles, consulta la página separada Benchmark.
Sin embargo, no deduzcas de esto que rathole puede hacer mágicamente que tu servicio reenviado sea varias veces más rápido que antes. El benchmark se realiza en el bucle local, lo que indica el rendimiento cuando la tarea está limitada por la CPU. Se puede obtener una mejora considerable si la red no es el cuello de botella. Desafortunadamente, eso no es cierto para muchos usuarios. En ese caso, el principal beneficio es el menor consumo de recursos, mientras que el ancho de banda y la latencia pueden no mejorar significativamente.
Fuera de alcance enumera las características que no están planificadas y el motivo.