CVE-2026-35031: Path Traversal no Upload de Legendas do Jellyfin para RCE

TL;DR

Uma vulnerabilidade crítica de path traversal no Jellyfin Media Server permite que utilizadores autenticados com permissão "Upload de Legendas" carreguem ficheiros para localizações arbitrárias no disco. Ao explorar o campo Format não validado no endpoint de upload de legendas, atacantes podem escrever ficheiros em locais sensíveis, extrair dados confidenciais, escalar privilégios e, por fim, executar código arbitrário como root através de injeção LD_PRELOAD.

• Pontuação CVSS: 9.9 (Crítico)
• Versões Afetadas: Jellyfin < 10.11.7
• Versão Corrigida: Jellyfin 10.11.7+
• Autenticação Necessária: Sim (utilizador não administrador com permissão de upload de legendas)
• Execução Remota de Código: Sim, como root
• Complexidade do Exploit: Baixa

---

Índice

1. Factos Rápidos
2. O que é o Jellyfin?
3. Análise Aprofundada da Vulnerabilidade
   • Análise da Causa Raiz
   • Análise da Cadeia de Ataque
   • Exploração LD_PRELOAD
4. Análise de Impacto
5. Versões Afetadas
6. Detecção
   • Scanner Python
   • Script NSE do Nmap
7. Indicadores de Compromisso
8. Remediação
9. Referências
10. Autor

---

Factos Rápidos

Propriedade	Valor
ID CVE	CVE-2026-35031
Pontuação CVSS	9.9 (Crítico)
CWE	CWE-22: Limitação Incorreta de um Nome de Caminho para um Diretório Restrito ('Path Traversal')
Produto Afetado	Jellyfin Media Server
Versões Afetadas	< 10.11.7
Versão Corrigida	10.11.7 e posteriores
Tipo de Vulnerabilidade	Path Traversal + Escrita Arbitrária de Ficheiros + RCE
Autenticação Necessária	Sim (utilizador não administrador)
Privilégios Necessários	Permissão "Upload de Legendas"
Porta Padrão	8096/TCP
Aviso GitHub	GHSA-9p5f-5x8v-x65m
Estado do Patch	Disponível e lançado
Exploit Público	Sim

---

O que é o Jellyfin?

O Jellyfin é um servidor de multimédia gratuito e de código aberto concebido para ajudar a gerir e transmitir a sua coleção pessoal de multimédia. Fornece funcionalidades semelhantes a servidores de multimédia comerciais, mas com total transparência do código-fonte e controlo da comunidade.

Principais Funcionalidades

• Streaming de multimédia auto-hospedado (música, filmes, séries)
• Suporte para vários utilizadores com controlos de permissão granulares
• Gestão e sincronização de legendas
• Interface baseada na web acessível via HTTP/HTTPS
• Implantação multiplataforma (Linux, Windows, macOS)
• Suporte para vários formatos de multimédia e protocolos de streaming

Arquitetura de Rede```

                      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)

---
## Análise Aprofundada da Vulnerabilidade

### Análise da Causa Raiz

A vulnerabilidade existe no endpoint de upload de legendas (`/Videos/{itemId}/Subtitles`) que aceita uploads de arquivos e os armazena em disco. A falha crítica reside na validação insuficiente do parâmetro do campo Format.

#### Padrão de Código Vulnerável

O endpoint processa uploads de legendas sem validar ou sanitizar adequadamente o campo Format:```
POST /Videos/{itemId}/Subtitles HTTP/1.1
Content-Type: multipart/form-data

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

O parâmetro Format serve para especificar o formato da legenda (srt, vtt, ass, etc.), mas em vez disso é tratado como parte do caminho do arquivo:``` 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)

### Análise da Cadeia de Ataque

A vulnerabilidade combina múltiplas fraquezas para alcançar execução remota de código como 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

Mecanismo de Path Traversal```

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)

### Exploração LD_PRELOAD

A técnica LD_PRELOAD é um poderoso método de escalada de privilégios e execução de código em sistemas 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())