ssf
3.0.0
Secure Socket Funneling (SSF) es una herramienta de red y un kit de herramientas.
Proporciona formas simples y eficientes de reenviar datos de múltiples enchufes (TCP o UDP) a través de un solo túnel TLS seguro a una computadora remota.
SSF es la plataforma cruzada (Windows, Linux, OSX) y viene como ejecutables independientes.
Características:
Descargar binarios prebuilt
Documentación
Construir en Windows
Construir en Unix/Linux
Compilación cruzada de SSF (por ejemplo, Raspberry Pi)
Uso: ssf[.exe] [options] server_address
Opciones:
-v verbose_level : verbosidad: crítica | error | advertencia | información | Debug | traza (predeterminado: información)
-q : modo tranquilo. No imprima registros
-p port : puerto remoto (predeterminado: 8011)
-c config_file_path : especificar el archivo de configuración. Si no se establece, 'config.json' se carga desde el directorio de trabajo actual
-m attempts : intentos de conexión máximos sin éxito antes de detenerse (predeterminado: 1)
-t delay : hora de esperar antes de intentar volver a conectarse en segundos (predeterminado: 60)
-n : no intente volver a conectar el cliente si la conexión se interrumpe
-g : Permitir puertos de puerta de enlace. Permita que el cliente vincule los enchufes locales para un servicio a una dirección específica en lugar de "localhost"
-S : Muestra el estado de microservicios (encendido/apagado)
Opciones de servicios:
-D [[bind_address]:]port : ejecute un proxy de calcetines en el servidor accesible en el [[bind_address]:]port en el lado local
-F [[bind_address]:]port : ejecute un proxy de calcetines en el host local accesible desde el servidor en [[bind_address]:]port
-X [[bind_address]:]port : Reenviar E/S de shell del servidor al puerto especificado en el lado local. Cada conexión crea un nuevo proceso de shell
-Y [[bind_address]:]port : reenvía la E/S de shell local al puerto especificado en el servidor
-L [[bind_address]:]port:host:hostport : reenviar conexiones TCP a [[bind_address]:]port en el host local al host:hostport en el servidor
-R [[bind_address]:]port:host:hostport : reenviar conexiones TCP a [[bind_address]:]port en el servidor a host:hostport en el lado local
-U [[bind_address]:]port:host:hostport : reenviar el tráfico UDP local en [[bind_address]:]port al host:hostport en el servidor
-V [[bind_address]:]port:host:hostport : reenviar el tráfico UDP en [[bind_address]:]port en el servidor al host:hostport en el lado local
Uso: ssfd[.exe] [options]
Opciones:
-v verbose_level : verbosidad: crítica | error | advertencia | información | Debug | traza (predeterminado: información)
-q : modo tranquilo. No imprima registros
-c config_file_path : especificar el archivo de configuración. Si no se establece, 'config.json' se carga desde el directorio de trabajo actual
-p port : puerto local (predeterminado: 8011)
-R : el servidor solo transmitirá conexiones
-l host : establecer la dirección de enlace del servidor
-g : Permitir puertos de puerta de enlace. Permita que el cliente vincule los enchufes locales para un servicio a una dirección específica en lugar de "localhost"
-S : Muestra el estado de microservicios (encendido/apagado)
La función de copia debe estar habilitada en el archivo de configuración del cliente y del servidor:
{
"ssf" : {
"services" : {
"copy" : { "enable" : true }
}
}
} Uso: ssfcp[.exe] [options] [host@]/absolute/path/file [[host@]/absolute/path/file]
Opciones:
-v verbose_level : verbosidad: crítica | error | advertencia | información | Debug | traza (predeterminado: información)
-q : modo tranquilo. No imprima registros
-c config_file_path : especificar el archivo de configuración. Si no se establece, 'config.json' se carga desde el directorio de trabajo actual
-p port : puerto remoto (predeterminado: 8011)
-t : usa stdin como entrada
--resume : intente reanudar la transferencia de archivos si existe el archivo de destino
--check-integrity : Verifique la integridad de los archivos al final de la transferencia
-r : Copiar archivos recursivamente
--max-transfers arg : Max transfiere en paralelo (predeterminado: 1)
El cliente ejecutará un proxy de calcetines en el puerto 9000 y transferirá solicitudes de conexión al servidor 192.168.0.1:8000
ssf -D 9000 -c config.json -p 8000 192.168.0.1
El servidor estará vinculado al puerto 8011 en todas las interfaces de red
ssfd
El servidor estará vinculado a 192.168.0.1:9000
ssfd -p 9000 -l 192.168.0.1
ssfcp [-c config_file] [-p port] path/to/file host@absolute/path/directory_destination
ssfcp [-c config_file] [-p port] path/to/file* host@absolute/path/directory_destination
ssfcp [-c config_file] [-p port] -r path/to/dir host@absolute/path/directory_destination
data_in_stdin | ssfcp [-c config_file] [-p port] -t host@path/to/destination/file_destination
ssfcp [-c config_file] [-p port] remote_host@path/to/file absolute/path/directory_destination
ssfcp [-c config_file] [-p port] remote_host@path/to/file* absolute/path/directory_destination
ssfcp [-c config_file] [-p port] -r remote_host@path/to/dir absolute/path/directory_destination
{
"ssf" : {
"arguments" : " " ,
"circuit" : [],
"http_proxy" : {
"host" : " " ,
"port" : " " ,
"user_agent" : " " ,
"credentials" : {
"username" : " " ,
"password" : " " ,
"domain" : " " ,
"reuse_ntlm" : true ,
"reuse_nego" : true
}
},
"socks_proxy" : {
"version" : 5 ,
"host" : " " ,
"port" : " 1080 "
},
"tls" : {
"ca_cert_path" : " ./certs/trusted/ca.crt " ,
"cert_path" : " ./certs/certificate.crt " ,
"key_path" : " ./certs/private.key " ,
"key_password" : " " ,
"dh_path" : " ./certs/dh4096.pem " ,
"cipher_alg" : " DHE-RSA-AES256-GCM-SHA384 "
},
"services" : {
"datagram_forwarder" : { "enable" : true },
"datagram_listener" : {
"enable" : true ,
"gateway_ports" : false
},
"stream_forwarder" : { "enable" : true },
"stream_listener" : {
"enable" : true ,
"gateway_ports" : false
},
"copy" : { "enable" : false },
"shell" : {
"enable" : false ,
"path" : " /bin/bash|C: \ windows \ system32 \ cmd.exe " ,
"args" : " "
},
"socks" : { "enable" : true }
}
}
}| Clave de configuración | Descripción |
|---|---|
| argumentos | Use argumentos de configuración en lugar de argumentos CLI dados (excepto -c ) |
La clave arguments permite al usuario personalizar los argumentos de la línea de comando en el archivo de configuración. Esta característica es una forma conveniente de guardar diferentes perfiles de conexión del cliente.
Dado el siguiente archivo de configuración conf.json :
{
"ssf" : {
"arguments" : " 10.0.0.1 -p 443 -D 9000 -L 11000:localhost:12000 -v debug "
}
} SSF extraerá los argumentos dados y los usará como un reemplazo de los argumentos iniciales (excepto -c ).
Por ejemplo, ssf -c conf.json será equivalente a ssf 10.0.0.1 -p 443 -D 9000 -L 11000:localhost:12000 -v debug :
10.0.0.1:443 ( 10.0.0.1 -p 443 )-D 9000 )-L 11000:localhost:12000 )-v debug ) | Clave de configuración | Descripción |
|---|---|
| circuito | Servidores de cadena de retransmisión utilizados para establecer la conexión con el servidor remoto |
El circuito es una matriz JSON que contiene los servidores de rebote y los puertos que se utilizarán para establecer la conexión. Se enumeran de la siguiente manera:
{
"ssf" : {
"circuit" : [
{ "host" : " SERVER1 " , "port" : " PORT1 " },
{ "host" : " SERVER2 " , "port" : " PORT2 " },
{ "host" : " SERVER3 " , "port" : " PORT3 " }
]
}
}Esta configuración creará la siguiente cadena de conexión:
CLIENT -> SERVER1:PORT1 -> SERVER2:PORT2 -> SERVER3:PORT3 -> TARGET
SSF admite la conexión a través de:
CONNECT HTTP| Clave de configuración | Descripción |
|---|---|
| http_proxy.host | Host http proxy |
| http_proxy.port | Puerto proxy http |
| http_proxy.user_agent | Valor de encabezado de agente de usuario en la solicitud HTTP Connect |
| http_proxy.credentials.username | credenciales de nombre de usuario proxy (Todas las plataformas: básicas o digestas, Windows: NTLM y negociar si reutilizan = falso) |
| http_proxy.credentials.password | Credenciales de contraseña proxy (Toda la plataforma: Básica o Digest, Windows: NTLM y negocie si Reuse = False) |
| http_proxy.credentials.domain | Dominio de usuario (NTLM y negociar autores solo en Windows) |
| http_proxy.credentials.reuse_ntlm | Reutilizar las credenciales actuales del usuario de la computadora para autenticarse con Proxy NTLM Auth (SSO) |
| http_proxy.credentials.reuse_kerb | Reutilizar las credenciales de usuario de la computadora actual (Ticket Kerberos) para autenticarse con Proxy Negociate Auth (SSO) |
Esquemas de autenticación compatibles:
| Clave de configuración | Descripción |
|---|---|
| calcetines_proxy.version | Versión de calcetines (4 o 5) |
| calcetines_proxy.host | Anfitrión de los calcetines |
| socks_proxy.port | Puerto proxy de calcetines |
No hay esquema de autenticación admitido.
| Clave de configuración | Descripción |
|---|---|
| tls.ca_cert_path | FilePath relativo o absoluto al archivo de certificado CA |
| tls.cert_path | FilePath relativo o absoluto al archivo de certificado de instancia |
| tls.key_path | FilePath relativo o absoluto al archivo de clave privada |
| tls.key_password | Contraseña de llave |
| tls.dh_path | FilePath relativo o absoluto al archivo Diffie-Hellman (solo servidor) |
| tls.cipher_alg | algoritmo de cifrado |
Con las opciones predeterminadas, los siguientes archivos y carpetas deben estar en el directorio de trabajo del cliente o del servidor:
./certs/dh4096.pem./certs/certificate.crt./certs/private.key./certs/trusted/ca.crtDónde:
Si desea esos archivos en diferentes rutas, es posible personalizarlos gracias a las teclas de ruta TLS:
{
"ssf" : {
"tls" : {
"ca_cert_path" : " ./certs/trusted/ca.crt " ,
"cert_path" : " ./certs/certificate.crt " ,
"key_path" : " ./certs/private.key " ,
"key_password" : " " ,
"dh_path" : " ./certs/dh4096.pem " ,
"cipher_alg" : " DHE-RSA-AES256-GCM-SHA384 "
}
}
}| Clave de configuración | Descripción |
|---|---|
| tls.ca_cert_buffer | Contenido de archivo de certificado de CA en formato PEM (: Advertencia: n entre datos y encabezado/pie de página PEM) |
| tls.cert_buffer | Contenido del archivo de certificado de instancia en formato PEM (: ADVERTENCIA: n entre datos y encabezado/pie de página PEM) |
| tls.key_buffer | Contenido de archivo de clave privada en formato PEM (: ADVERTENCIA: n entre datos y encabezado/pie de página PEM) |
| tls.key_password | Contraseña de llave |
| tls.dh_buffer | Diffie-Hellman Parámetros Contenido del archivo en formato PEM (: ADVERTENCIA: n entre datos y encabezado/pie de página PEM, solo servidor) |
| tls.cipher_alg | algoritmo de cifrado |
Puede integrar los parámetros TLS directamente en el archivo de configuración utilizando las teclas tls.ca_cert_buffer , tls.cert_buffer , tls.key_buffer y tls.dh_buffer .
{
"ssf" : {
"tls" : {
"ca_cert_buffer" : " -----BEGIN CERTIFICATE----- n ... n -----END CERTIFICATE----- " ,
"cert_buffer" : " -----BEGIN CERTIFICATE----- n ... n -----END CERTIFICATE----- " ,
"key_buffer" : " -----BEGIN RSA PRIVATE KEY----- n ... n -----END RSA PRIVATE KEY----- " ,
"key_password" : " " ,
"dh_buffer" : " -----BEGIN DH PARAMETERS----- n ... n -----END DH PARAMETERS----- " ,
"cipher_alg" : " DHE-RSA-AES256-GCM-SHA384 "
}
}
} Los certificados, las claves privadas y los parámetros DH deben estar en formato PEM.n entre datos y encabezado/pie de página PEM son obligatorios.
| Clave de configuración | Descripción |
|---|---|
| Servicios.*. Habilitar | Habilitar/deshabilitar microservicio |
| Servicios.*. Gateway_ports | Habilitar/deshabilitar puertos de puerta de enlace |
| Services.shell.path | ruta binaria utilizada para la creación de conchas |
| Services.shell.args | Argumentos binarios utilizados para la creación de shell |
Las características de SSF se construyen con microservicios (reenvío de TCP, calcetines remotos, ...)
Hay 7 microservicios:
Cada característica es la combinación de al menos un microservicio del lado del cliente y un microservicio del lado del servidor.
Esta tabla resume cómo se ensambla cada característica:
| característica SSF | lado del cliente de microservicio | Lado del servidor de microservicio |
|---|---|---|
-L : reenvío de TCP | stream_listener | stream_forwarder |
-R : reenvío de TCP remoto | stream_forwarder | stream_listener |
-U : reenvío de UDP | datagram_listener | datagram_forwarder |
-V : reenvío UDP remoto | datagram_forwarder | datagram_listener |
-D : calcetines | stream_listener | medias |
-F : calcetines remotos | medias | stream_listener |
-X : Shell | stream_listener | caparazón |
-Y : shell remoto | caparazón | stream_listener |
Esta arquitectura hace que sea más fácil construir características remotas: usan los mismos microservicios pero en el lado opuesto.
ssf y ssfd vienen con microservicios pre-habilitados. Aquí está la configuración de microservicios predeterminada:
{
"ssf" : {
"services" : {
"datagram_forwarder" : { "enable" : true },
"datagram_listener" : { "enable" : true },
"stream_forwarder" : { "enable" : true },
"stream_listener" : { "enable" : true },
"socks" : { "enable" : true },
"copy" : { "enable" : false },
"shell" : { "enable" : false }
}
}
} Para habilitar o deshabilitar un microservicio, establezca la tecla enable en true o false .
Intentar usar una función que requiera un microservicio deshabilitado dará como resultado un mensaje de error.
openssl dhparam 4096 -outform PEM -out dh4096.pemEn primer lugar, cree un archivo llamado ExtFile.txt que contenga las siguientes líneas:
[ v3_req_p ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
Luego, genere un certificado autofirmado (CA) CA.CRT y su clave privada CA.Key :
openssl req -x509 -nodes -newkey rsa:4096 -keyout ca.key -out ca.crt -days 3650Genere una clave privada Private.Key y un certificado de solicitud de firma Certificado. CSR :
openssl req -newkey rsa:4096 -nodes -keyout private.key -out certificate.csrGenere el certificado ( certificado.pem ) firmando la CSR con la CA ( CA.CRT , CA.Key ):
openssl x509 -extfile extfile.txt -extensions v3_req_p -req -sha1 -days 3650 -CA ca.crt -CAkey ca.key -CAcreateserial -in certificate.csr -out certificate.pem
