datntsec/cve-2020-0796Analisi tecnica e proof-of-concept per CVE-2020-0796 (SMBGhost), una vulnerabilità di integer overflow nella compressione SMBv3 che porta a escalation dei privilegi locali su Windows 10/Server.
La funzionalità di compressione aggiunta a SMBv3 a partire dalla versione del sistema operativo Windows 10/Server versione 1903 contiene una vulnerabilità di integer overflow confermata da Microsoft il 12/03/2020. Consente a un attaccante di effettuare Local Privilege Escalation (LPE) e Remote Code Execution (RCE). Qui si parlerà solo della vulnerabilità LPE.
Versioni affette:
Analizzando il file srv2.sys, si nota che le funzioni relative alla Decompressione vengono chiamate come segue:``` js
Srv2ReceiveHandler
|
|
v
Srv2DecompressMessageAsync
|
|
v
Srv2DecompressData -------> SrvNetAllocateBuffer
|
|
v
SmbCompressionDecompress
|
|
v
memcpy
Prima di tutto, la funzione `Srv2ReceiveHandler` viene chiamata per ricevere un pacchetto dati SMB e richiama una funzione corrispondente al `ProtocolId`. Se `PrococolId` = 0x424D53FC, chiama la funzione `Srv2DecompressMessageAsync`, la quale procede a chiamare `Srv2DecompressData` per decomprimere il pacchetto dati. La funzione `Srv2DecompressData` chiama `SrvNetAllocateBuffer` per allocare un `Alloc` usato per memorizzare i dati dopo la decompressione, quindi chiama `SmbCompressionDecompress` per decomprimere il pacchetto dati e infine chiama `memcpy`. L'intero processo di decompressione ha quindi i seguenti passaggi principali:
- 1. Allocazione
- 2. Decompressione
- 3. Copia
Secondo la documentazione fornita da Microsoft, la struttura `COMPRESSION_TRANSFORM_HEADER` viene utilizzata per inviare e ricevere dati compressi dal client e dal server. Ha la seguente struttura:``` c
typedef struct _COMPRESSION_TRANSFORM_HEADER
{
ULONG ProtocolId;
ULONG OriginalCompressedSegmentSize;
USHORT CompressionAlgorithm;
USHORT Flags;
ULONG Offset;
} ;
Qui ci concentriamo solo sui 2 campi principali sopra citati:
OriginalCompressedSegmentSize è la dimensione del segmento di dati non compressi, in byte.Offset è lo scostamento in byte tra il punto di inizio dei dati compressi e il punto finale della struttura _COMPRESSION_TRANSFORM_HEADER.Pertanto il pacchetto di dati compresso avrà la seguente forma:
``` c
typedef struct _ALLOCATION_HEADER
{
// ...
PVOID UserBuffer;
// ...
} ALLOCATION_HEADER, *PALLOCATION_HEADER;
NTSTATUS Srv2DecompressData(PCOMPRESSION_TRANSFORM_HEADER Header, SIZE_T TotalSize) { PALLOCATION_HEADER Alloc = SrvNetAllocateBuffer( (ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset), NULL); If (!Alloc) { return STATUS_INSUFFICIENT_RESOURCES; }
ULONG FinalCompressedSize = 0;
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
Analisi della funzione `Srv2DecompressData`: si nota che la funzione riceve un pacchetto di dati compressi `COMPRESSION_TRANSFORM_HEADER` (Header), quindi alloca una zona di memoria (Alloc) tramite la funzione `SrvNetAllocateBuffer` con parametro la somma di `Header->OriginalCompressedSegmentSize` + `Header->Offset`, dopodiché decomprime i dati compressi e copia i dati non compressi in `Alloc->Buffer`.
L'errore di integer overflow si verifica quando `Srv2DecompressData` chiama la funzione `SrvNetAllocateBuffer`. La funzione `SrvNetAllocateBuffer` accetta effettivamente due valori a 64 bit, ma quando viene chiamata, `Srv2DecompressData` le passa solo due valori a 32 bit (ULONG). Mentre sia `OriginalCompressedSegmentSize` che `Offset` sono ULONG, sommandoli insieme possono produrre un numero maggiore di 32 bit. È così che si verifica l'errore di integer overflow (In parole semplici, sommando 0xffffffff (`OriginalCompressedSegmentSize`) con 0x10 (`Offset`) si ottiene 0xf0000000f ma la funzione `SrvNetAllocateBuffer` riceve solo il valore 0x0000000f).
L'errore di integer overflow porta a un'allocazione errata della zona di memoria Alloc (la dimensione allocata è minore di quella effettiva), potenzialmente causando un buffer overflow:
