Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-35031 — Vulnérabilité critique de traversée de chemin menant à une exécution de code à distance (RCE) dans Jellyfin Media Server (CVSS 9.9). Comprend un exploit de preuve de concept, une analyse technique et des outils de détection. | Kitploit
Outils/GitHubGitHub/keraattin/cve-2026-35031
Escalade de PrivilègesAnalyse des VulnérabilitésExploitationExploitation d'Applications WebTests d'IntrusionArticles et RechercheApprentissage et ÉducationDéveloppement de Charges Utiles
GitHubkeraattin/cve-2026-35031

CVE-2026-35031

Vulnérabilité critique de traversée de chemin menant à une exécution de code à distance (RCE) dans Jellyfin Media Server (CVSS 9.9). Comprend un exploit de preuve de concept, une analyse technique et des outils de détection.

2il y a 4 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager
Voir le dépôt

CVE-2026-35031 : Traversée de chemin dans le téléchargement de sous-titres de Jellyfin menant à une exécution de code à distance

CVE-ID CVSS Score CWE Affected Product Status

En résumé

Une vulnérabilité critique de traversée de chemin dans Jellyfin Media Server permet aux utilisateurs authentifiés disposant de l'autorisation « Télécharger des sous-titres » de placer des fichiers dans des emplacements arbitraires sur le disque. En exploitant le champ Format non validé du point de terminaison de téléchargement de sous-titres, un attaquant peut écrire des fichiers dans des zones sensibles, extraire des données confidentielles, élever ses privilèges et finalement exécuter du code arbitraire en tant que root via l'injection LD_PRELOAD.

  • Score CVSS : 9.9 (Critique)
  • Versions concernées : Jellyfin < 10.11.7
  • Version corrigée : Jellyfin 10.11.7+
  • Authentification requise : Oui (utilisateur non administrateur avec autorisation de téléchargement de sous-titres)
  • Exécution de code à distance : Oui, en tant que root
  • Complexité de l'exploitation : Faible

Table des matières

  1. Aperçu rapide
  2. Qu'est-ce que Jellyfin ?
  3. Analyse approfondie de la vulnérabilité
    • Analyse de la cause racine
    • Déroulement de la chaîne d'attaque
    • Exploitation via LD_PRELOAD
  4. Analyse d'impact
  5. Versions concernées
  6. Détection
    • Scanner Python
    • Script Nmap NSE
  7. Indicateurs de compromission
  8. Remédiation
  9. Références
  10. Auteur

Aperçu rapide


Qu'est-ce que Jellyfin ?

Jellyfin est un serveur multimédia gratuit et open source conçu pour vous aider à gérer et diffuser votre collection multimédia personnelle. Il offre des fonctionnalités similaires aux serveurs multimédias commerciaux, mais avec une transparence totale du code source et un contrôle communautaire.

Fonctionnalités clés

  • Diffusion multimédia auto-hébergée (musique, films, séries TV)
  • Prise en charge multi-utilisateurs avec des contrôles d'autorisations granulaires
  • Gestion et synchronisation des sous-titres
  • Interface web accessible via HTTP/HTTPS
  • Déploiement multiplateforme (Linux, Windows, macOS)
  • Prise en charge de divers formats multimédia et protocoles de diffusion

Architecture réseau```

root@kitploit:~
                      Jellyfin Media Server (Port 8096)
                     /                |                \
                    /                 |                 \
               Web UI            REST API          Media Streams
              (Browser)        (Authenticated)    (Subtitle Upload)
                                     |
                    /System/Info/Public (unauthenticated)
                    /Videos/{itemId}/Subtitles (vulnerable)
                    /Library/Collections (admin)

Client Devices > Network > Jellyfin Server > Database + Storage | /var/lib/jellyfin/ /etc/ld.so.preload (writable via vulnerability)

root@kitploit:~
---

## Analyse Approfondie de la Vulnérabilité

### Analyse de la Cause Racine

La vulnérabilité se trouve dans le point de terminaison de téléchargement de sous-titres (`/Videos/{itemId}/Subtitles`) qui accepte les téléchargements de fichiers et les stocke sur le disque. Le défaut critique réside dans la validation insuffisante du paramètre Format.

#### Schéma de Code Vulnérable

Le point de terminaison traite les téléchargements de sous-titres sans valider ou assainir correctement le champ Format :```
POST /Videos/{itemId}/Subtitles HTTP/1.1
Content-Type: multipart/form-data

[Binary subtitle data]
Format: /../../../etc/ld.so.preload
Language: en

Le paramètre Format est destiné à spécifier le format des sous-titres (srt, vtt, ass, etc.) mais est traité comme faisant partie du chemin du fichier :``` Base Path: /var/lib/jellyfin/subtitles/ User Input: /../../../etc/ld.so.preload Result: /var/lib/jellyfin/subtitles/../../../etc/ld.so.preload Resolved: /etc/ld.so.preload (via path traversal)

root@kitploit:~
### Analyse de la chaîne d'attaque

La vulnérabilité enchaîne plusieurs faiblesses pour parvenir à une exécution de code à distance en tant que root:```
Step 1: Subtitle Upload with Path Traversal
        POST /Videos/{itemId}/Subtitles
        Format: /../../../etc/ld.so.preload
                    |
                    v
Step 2: Arbitrary File Write
        Write attacker-controlled data to /etc/ld.so.preload
                    |
                    v
Step 3: File Read via .strm Files
        Create .strm files pointing to sensitive paths
        Extract database contents and credentials
                    |
                    v
Step 4: Database Extraction
        Access /jellyfin/jellyfin.db via .strm
        Extract admin user hashes
                    |
                    v
Step 5: Admin Privilege Escalation
        Reset admin password or create new admin account
                    |
                    v
Step 6: RCE via LD_PRELOAD Injection
        LD_PRELOAD=/path/to/malicious.so java
        Arbitrary code execution as root

Mécanisme de traversée de chemin```

Input Validation Failure:

Format Field Validation: Expected: srt | vtt | ass | ssa | sub | subrip Actual: /../../../etc/ld.so.preload Result: NO VALIDATION > PATH TRAVERSAL ALLOWED

File Write Operation: String Concatenation: "/subtitles/" + user_format + ".srt" | NO CANONICALIZATION: Path component not resolved before write NO WHITELIST: Format values not restricted NO BOUNDS CHECK: ".." sequences not filtered | v Final Path: /etc/ld.so.preload (EXPLOITED)

root@kitploit:~
### LD_PRELOAD Exploitation

L_ technique LD_PRELOAD est une méthode puissante d'élévation de privilèges et d'exécution de code sur les systèmes Linux :```
LD_PRELOAD Injection Flow:

1. Attacker writes malicious .so (shared object) to /etc/ld.so.preload
   
   /etc/ld.so.preload contents:
   /path/to/attacker.so

2. Java process starts (Jellyfin runs on Java):
   
   kernel > execve("java", ...) > glibc initialization
                                     |
                                     v
                          Check /etc/ld.so.preload
                                     |
                                     v
                          Load attacker.so FIRST
                                     |
                                     v
                          Execute attacker code
                          (BEFORE Java main())

3. Code Execution Context:
   
   Process Owner:   root (Jellyfin typically runs as root)
   Permissions:     Full system access
   Timing:          Before application initialization
   Detection:       Minimal (malicious code runs early)

4. Attacker Capabilities:
   
   > Create reverse shell with full root privileges
   > Extract sensitive data before application starts
   > Modify Java application behavior
   > Persist via cron jobs or systemd services
   > Establish C2 communication

Pourquoi LD_PRELOAD fonctionne comme escalade```

User Level Access > Path Traversal > Write /etc/ld.so.preload | v (Next process execution) | Kernel reads /etc/ld.so.preload > Loads attacker .so | v Malicious code executes in root context | v Full system compromise

root@kitploit:~
---

## Analyse d'impact

### Confidentialité
**CRITIQUE** - Divulgation complète des informations
- Extraction de la base de données : identifiants admin, mots de passe utilisateur, clés API
- Fichiers de sous-titres et métadonnées des médias exposés
- Accès aux fichiers de configuration contenant des données sensibles
- Collecte d'informations système pour une exploitation ultérieure

### Intégrité
**CRITIQUE** - Modification de fichiers à l'échelle du système
- Écriture arbitraire de fichiers vers n'importe quel emplacement sur le disque
- Modification des binaires de l'application
- Altération de la configuration système
- Corruption ou manipulation de la base de données

### Disponibilité
**CRITIQUE** - Interruption de service et déni de service
- Arrêt ou plantage système via un .so malveillant dans LD_PRELOAD
- Épuisement de l'espace disque par écriture de fichiers volumineux
- Terminaison de processus ou famine de ressources
- Indisponibilité totale du service

### Composants affectés
- Processus Jellyfin Media Server (s'exécutant en tant que root dans la plupart des déploiements)
- Noyau du système d'exploitation et bibliothèques
- Médias et métadonnées stockés
- Systèmes d'authentification utilisateur
- Processus à l'échelle du système liés à glibc

### Impact commercial
- **Violation de données :** Tous les identifiants stockés et données utilisateur compromis
- **Interruption de service :** Jellyfin et potentiellement d'autres services deviennent indisponibles
- **Mouvement latéral :** Le système compromis devient un point de pivot pour les attaques réseau
- **Non-conformité réglementaire :** Violations du RGPD, CCPA, HIPAA si des PII sont exposées
- **Risque sur la chaîne d'approvisionnement :** Si Jellyfin dessert des médias partagés ou d'entreprise

---

## Versions affectées

| Version | Statut | Notes |
|---------|--------|-------|
| < 10.8.0 | Vulnérable | Vulnérabilité d'origine présente |
| 10.8.0 - 10.11.6 | Vulnérable | Traversée de chemin et RCE possibles |
| 10.11.7+ | Corrigée | Champ Format correctement validé |
| 10.12.0+ | Corrigée | Dernière version avec correctifs de sécurité |

### Détection de version
La vulnérabilité peut être détectée en vérifiant la chaîne de version depuis le point d'accès `/System/Info/Public` :```
GET /System/Info/Public HTTP/1.1
Host: jellyfin-server:8096

Response:
{
  "ServerName": "MyJellyfin",
  "Version": "10.10.3",  < Vulnerable
  "ProductName": "Jellyfin",
  "StartupWizardCompleted": true
}

Détection

Scanner Python

Le script CVE-2026-35031_Jellyfin_RCE_detector.py fournit une détection automatisée des vulnérabilités.

Installation et prérequis```bash

pip install requests urllib3

root@kitploit:~
#### Utilisation```bash
python CVE-2026-35031_Jellyfin_RCE_detector.py -t 10.0.0.5:8096
python CVE-2026-35031_Jellyfin_RCE_detector.py -t http://10.0.0.0/24
python CVE-2026-35031_Jellyfin_RCE_detector.py -t targets.txt -o results.json

Options de ligne de commande```

-t, --target HOST[:PORT] or CIDR or FILE Single target, IP range, or file with targets -p, --port PORT Custom port (default: 8096) --timeout SECONDS Connection timeout (default: 10) -o, --output FILE Save results to JSON file -v, --verbose Enable verbose logging --no-ssl-verify Disable SSL certificate verification

root@kitploit:~
#### Exemple de sortie```
[*] CVE-2026-35031 Jellyfin RCE Detection Scanner
[*] Target: http://10.0.0.5:8096
[*] Scan Time: 2026-04-15T12:00:00Z
[*] Detection method: /System/Info/Public version check
[*] Vulnerable: Jellyfin < 10.11.7

======================================================================
Target: http://10.0.0.5:8096
Scan Time: 2026-04-15T12:00:00Z
Risk Level: CRITICAL
======================================================================
  Is Jellyfin:           YES
  Jellyfin Version:      10.10.3
  Server Name:           MediaServer
  Operating System:      Linux
  Subtitle Endpoint:     Accessible
  Vulnerable:            YES

  *** VULNERABLE: Path traversal in subtitle upload ***
  *** Chains to arbitrary file write and RCE as root via ld.so.preload ***
  *** Upgrade to Jellyfin 10.11.7 immediately ***

======================================================================
Summary:
  Total Targets: 1
  Vulnerable: 1
  Patched: 0
  Unknown: 0
======================================================================

Logique de détection

Le scanner effectue les vérifications suivantes :

  1. Détection de service : Se connecte au port cible et vérifie les en-têtes HTTP
  2. Vérification Jellyfin : Interroge le point d'accès /System/Info/Public
  3. Extraction de version : Analyse le champ Version de la réponse JSON
  4. Évaluation de vulnérabilité : Compare la version avec la version corrigée (10.11.7)
  5. Vérification du point d'accès : Confirme que le point d'accès de téléchargement de sous-titres existe
  6. Calcul du risque : Détermine l'impact CVSS en fonction de la version

Script NSE Nmap

Le script CVE-2026-35031_Jellyfin_RCE.nse assure l'intégration avec Nmap pour le balayage des vulnérabilités.

Installation```bash

Copy to Nmap scripts directory

sudo cp CVE-2026-35031_Jellyfin_RCE.nse /usr/share/nmap/scripts/

Update Nmap database

sudo nmap --script-updatedb

root@kitploit:~
#### Utilisation```bash
# Basic scan
nmap -p 8096 --script CVE-2026-35031_Jellyfin_RCE 10.0.0.5

# Comprehensive scan with service detection
nmap -sV -p 8096 --script CVE-2026-35031_Jellyfin_RCE 10.0.0.5

# Scan entire subnet
nmap -sV -p 8096 --script CVE-2026-35031_Jellyfin_RCE 10.0.0.0/24

# Aggressive scanning with timing
nmap -sV -p- --script CVE-2026-35031_Jellyfin_RCE -T4 10.0.0.5

# Export results to XML
nmap -sV -p 8096 --script CVE-2026-35031_Jellyfin_RCE -oX results.xml 10.0.0.5

Exemple de sortie```

PORT STATE SERVICE VERSION 8096/tcp open http Jellyfin Media Server 10.10.3 | CVE-2026-35031_Jellyfin_RCE: | VULNERABLE: | Jellyfin Subtitle Path Traversal to RCE (CVE-2026-35031) | State: VULNERABLE | Risk level: CRITICAL | CVSS Score: 9.9 | Jellyfin Version: 10.10.3 | Fixed Version: 10.11.7 | Description: | Jellyfin 10.10.3 is vulnerable to CVE-2026-35031. The subtitle | upload endpoint (/Videos/{itemId}/Subtitles) does not validate | the Format field, allowing path traversal and arbitrary file write. | This chains into remote code execution as root via LD_PRELOAD. | Vulnerability Chain: | 1. POST /Videos/{itemId}/Subtitles with Format=/../../../etc/ld.so.preload | 2. Arbitrary file write to /etc/ld.so.preload | 3. Database extraction via .strm files | 4. Admin privilege escalation | 5. RCE as root via LD_PRELOAD injection | Affected Endpoint: /Videos/{itemId}/Subtitles | Authentication Required: YES (non-admin user) | References: | https://nvd.nist.gov/vuln/detail/CVE-2026-35031 | https://github.com/jellyfin/jellyfin/security/advisories/GHSA-9p5f-5x8v-x65m |_ https://github.com/jellyfin/jellyfin/releases/tag/v10.11.7

root@kitploit:~
#### Paramètres du script```bash
# Custom timeout for slow networks
nmap --script CVE-2026-35031_Jellyfin_RCE --script-args timeout=30 10.0.0.5

# Debug mode for troubleshooting
nmap --script CVE-2026-35031_Jellyfin_RCE -d 10.0.0.5

# Aggressive version detection
nmap -sV --version-intensity 9 --script CVE-2026-35031_Jellyfin_RCE 10.0.0.5

Indicateurs de compromission

Indicateurs de journalisation

Journaux du serveur Jellyfin (/var/log/jellyfin/jellyfin.log)``` [ERR] Error processing subtitle upload: Invalid path characters detected [ERR] Exception in subtitle handling: DirectoryNotFoundException [ERR] Unauthorized file system access attempt [WARN] Unusual subtitle format detected: /../../../ [ERR] Security violation: Path traversal attempt blocked

root@kitploit:~
**Journaux système** (`/var/log/syslog` or `/var/log/messages`)```
subtitle upload process: segmentation fault (core dumped)
kernel: [security] Attempted to load from LD_PRELOAD: /etc/ld.so.preload
ld.so.preload: permission denied or file corrupted
Java process crashed after LD_PRELOAD initialization
Unexpected behavior from root-level Java process

Indicateurs du système de fichiers

Fichiers système modifiés``` /etc/ld.so.preload - Should not contain any paths if not configured /lib/x86_64-linux-gnu/ - Look for suspicious .so files created recently /var/lib/jellyfin/subtitles - Check for files outside normal naming /etc/passwd - Verify no unauthorized access or modification /var/lib/jellyfin/db - Database timestamps may indicate extraction

root@kitploit:~
**Chemins de fichiers suspects dans le répertoire des sous-titres**```
/../../../etc/ld.so.preload
/../../../root/.ssh/authorized_keys
/../../../var/lib/jellyfin/jellyfin.db
../../../proc/self/environ

Indicateurs réseau

Requêtes HTTP suspectes``` POST /Videos/[0-9]+/Subtitles

  • Format parameter contains: /.. or ..\ patterns
  • Format parameter contains absolute paths starting with /
  • Format parameter does not match known subtitle formats

Encoded Payloads: %2e%2e%2f (URL encoded ../) ..%252f (Double encoded ../) ....// (Bypass patterns)

root@kitploit:~
**Connexions sortantes du processus Jellyfin**```
Reverse shells to external IPs
Connections to known C2 infrastructure
DNS requests to anomalous domains
Sudden spike in network traffic after failed subtitle upload

Indicateurs de processus

Anomalies de processus Jellyfin``` java process executing system commands java process spawning shell processes (/bin/bash, /bin/sh) java process opening connections to unusual ports java process reading system files like /etc/shadow Unusual CPU or memory usage spikes Child processes with different UID than parent

root@kitploit:~
### Indicateurs de base de données

**Modifications de la base de données Jellyfin** (`jellyfin.db`)```
New admin user created outside normal workflow
Admin password changed without admin action
API keys/tokens created unexpectedly
Unusual activity in audit logs

Remédiation

Actions immédiates (Priorité : CRITIQUE)

  1. Mettez à niveau Jellyfin immédiatement ```bash

    Docker deployment

    docker pull jellyfin/jellyfin:latest docker-compose down docker-compose up -d

    Package manager (Ubuntu/Debian)

    sudo apt-get update sudo apt-get install --only-upgrade jellyfin

    Package manager (Fedora/RHEL)

    sudo dnf upgrade jellyfin

    root@kitploit:~
  2. Arrêter le service Jellyfin ```bash sudo systemctl stop jellyfin

    root@kitploit:~
  3. Vérifier l'exploitation ```bash

    Check if ld.so.preload was modified

    ls -la /etc/ld.so.preload cat /etc/ld.so.preload

    Check subtitle directory for suspicious files

    find /var/lib/jellyfin/subtitles -type f -newer /proc -ls

    Check Jellyfin data directory

    find /var/lib/jellyfin -type f -newermt "2026-04-14" -ls

    root@kitploit:~

Atténuations à court terme (Priorité : ÉLEVÉE)

  1. Restreindre l'autorisation de téléchargement de sous-titres ``` Jellyfin Web UI > Settings > Users Disable "Upload Subtitles" for all non-admin users Review all users with this permission

    root@kitploit:~
  2. Segmentation du réseau ```

    Only allow trusted networks to access Jellyfin

    sudo ufw allow from 192.168.1.0/24 to any port 8096 sudo ufw deny from any to any port 8096

    root@kitploit:~
  3. Permissions du système de fichiers ```bash

    Ensure Jellyfin runs with minimal privileges

    sudo usermod -s /usr/sbin/nologin jellyfin

    Restrict ld.so.preload permissions

    sudo chmod 644 /etc/ld.so.preload sudo chmod 644 /etc/ld.so.conf

    Set proper permissions on Jellyfin directory

    sudo chown -R jellyfin:jellyfin /var/lib/jellyfin sudo chmod 750 /var/lib/jellyfin

    root@kitploit:~
  4. Surveiller les tentatives d'exploitation ```bash

    Watch subtitle upload endpoint logs

Renforcement à long terme (Priorité : MOYENNE)

  1. Implémenter un pare-feu applicatif Web (WAF) ``` Block requests containing:

    • Path traversal patterns: ../ ..\ ..\
    • Suspicious file paths: /etc/ /root/ /proc/
    • Encoded variations: %2e%2e%2f
    root@kitploit:~
  2. Activer le module de sécurité ```bash

    AppArmor (Ubuntu/Debian)

    sudo aa-enforce /etc/apparmor.d/usr.bin.java

    SELinux (Fedora/RHEL)

    sudo semanage fcontext -a -t jellyfin_home_t "/var/lib/jellyfin(/.*)?" sudo restorecon -R /var/lib/jellyfin

    root@kitploit:~
  3. Exécuter Jellyfin en tant qu'utilisateur non-root ```bash

    Create dedicated user if not exists

    sudo useradd -r -s /usr/sbin/nologin jellyfin

    Update systemd service

    sudo sed -i 's/User=.*/User=jellyfin/' /etc/systemd/system/jellyfin.service sudo systemctl daemon-reload sudo systemctl restart jellyfin

    root@kitploit:~
  4. Mettre en place des sauvegardes régulières ```bash

    Automated daily backups

    sudo crontab -e

    0 2 * * * /usr/local/bin/jellyfin-backup.sh

Étapes de vérification```bash

1. Verify Jellyfin version after upgrade

curl -s http://localhost:8096/System/Info/Public | jq .Version

2. Confirm no unauthorized ld.so.preload entries

cat /etc/ld.so.preload | wc -l # Should be 0 or contain only legitimate entries

3. Check Jellyfin process permissions

ps aux | grep jellyfin | grep -v grep

4. Verify subnet connectivity restrictions

sudo ufw status

5. Test subtitle upload with non-admin user (should work normally)

Try uploading a legitimate .srt file and confirm it's stored correctly

root@kitploit:~
---

## Références

### Sources officielles
- **Entrée NVD :** https://nvd.nist.gov/vuln/detail/CVE-2026-35031
- **Avis GitHub :** https://github.com/jellyfin/jellyfin/security/advisories/GHSA-9p5f-5x8v-x65m
- **Version Jellyfin v10.11.7 :** https://github.com/jellyfin/jellyfin/releases/tag/v10.11.7
- **Documentation Jellyfin :** https://docs.jellyfin.org

### Vulnérabilités et recherches connexes
- CWE-22 : Path Traversal - https://cwe.mitre.org/data/definitions/22.html
- Exploitation LD_PRELOAD : https://www.gnu.org/software/libc/manual/html_node/Dynamic-Linker.html
- Modèles d'escalade de privilèges de processus Java
- Spécifications des formats de fichiers de sous-titres (normes RFC)

### Outils et ressources de sécurité
- Nmap : https://nmap.org
- Metasploit Framework : https://www.metasploit.com
- Guide OWASP Path Traversal : https://owasp.org/www-community/attacks/Path_Traversal

---

## Auteur

**Vulnérabilité découverte et documentée par :**

**Kerem Oruc** (@keraattin)
- GitHub : https://github.com/keraattin
- Twitter/X : https://twitter.com/keraattin

### Contribution

Si vous avez des améliorations à apporter à cette documentation ou aux outils de détection, veuillez soumettre une pull request ou ouvrir une issue.

---

**Avertissement :** Ce document est destiné uniquement à des fins éducatives et de tests de sécurité autorisés. L'accès non autorisé à des systèmes informatiques est illégal. Obtenez toujours une autorisation appropriée avant de mener des évaluations de sécurité.

**Dernière mise à jour :** 2026-04-15 | **Statut :** PUBLIÉ
Télécharger l’outil
PropriétéValeur
Identifiant CVECVE-2026-35031
Score CVSS9.9 (Critique)
CWECWE-22 : Limitation inappropriée d'un nom de chemin vers un répertoire restreint ('Traversée de chemin')
Produit concernéJellyfin Media Server
Versions concernées< 10.11.7
Version corrigée10.11.7 et ultérieures
Type de vulnérabilitéTraversée de chemin + Écriture de fichier arbitraire + RCE
Authentification requiseOui (utilisateur non administrateur)
Privilèges requisAutorisation « Télécharger des sous-titres »
Port par défaut8096/TCP
Avis GitHubGHSA-9p5f-5x8v-x65m
État du correctifDisponible et publié
Exploit publicOui

tail -f /var/log/jellyfin/jellyfin.log | grep -i subtitle

Monitor system logs for ld.so.preload changes

auditctl -w /etc/ld.so.preload -p wa -k ld_preload_changes

root@kitploit:~

Verify backup integrity

tar -tzf /backup/jellyfin-$(date +%Y%m%d).tar.gz > /dev/null

root@kitploit:~
  • Activer la journalisation d'audit ```bash

    Log all file access to sensitive locations

    auditctl -w /etc/ld.so.preload -p wa -k ld_preload_audit auditctl -w /var/lib/jellyfin -p wa -k jellyfin_audit

    Monitor process execution from Jellyfin

    auditctl -a always,exit -F exe=/usr/bin/java -F arch=b64 -S execve -k jellyfin_exec

    root@kitploit:~