CVE-2026-11108 – Overflow di interi nell'allocatore di memoria (simulazione kmalloc)

Codice del programma (C)

// alloc_sim.c - Vulnerable memory allocator
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_BLOCK 1024

void *my_malloc(size_t size) {
    size_t total = size + sizeof(size_t); // header
    if (total > MAX_BLOCK) return NULL;
    void *ptr = malloc(total);
    if (!ptr) return NULL;
    *(size_t *)ptr = size;
    return ptr + sizeof(size_t);
}

void my_free(void *p) {
    if (!p) return;
    size_t *header = (size_t *)(p - sizeof(size_t));
    free(header);
}

int main() {
    // Craft size that causes integer overflow: 0xFFFFFFFF - sizeof(size_t) + 1 wraps to small number
    size_t huge = 0xFFFFFFFF;  // 4GB - 1
    char *buf = my_malloc(huge - sizeof(size_t) + 1); // overflow: total becomes 0?
    if (buf) {
        // Write far beyond allocated buffer, heap overflow
        memset(buf, 'A', 1000);
        printf("Wrote 1000 bytes to tiny buffer\n");
        my_free(buf);
    }
    return 0;
}

CVE-2026-11108 – Overflow di interi nell'allocatore di memoria

Panoramica

Un allocatore di memoria personalizzato calcola in modo errato la dimensione totale dell'allocazione aggiungendo la dimensione di un header senza controlli di overflow. Passando una dimensione vicina a UINT_MAX, il totale subisce un wrap a un valore piccolo, allocando un buffer minuscolo ma consentendo una scrittura di grandi dimensioni, causando un heap overflow.

Dettagli della vulnerabilità

• Tipo: Integer Overflow / Heap Overflow
• Impatto: Esecuzione di codice arbitrario, corruzione della memoria.
• Causa principale: La funzione di allocazione non verifica la presenza di overflow quando aggiunge la dimensione dell'header alla dimensione richiesta dall'utente.

Dimostrazione dell'exploit

Compila ed esegui:

gcc -o alloc_sim alloc_sim.c -fno-stack-protector
./alloc_sim

Il programma scrive molti più byte rispetto al buffer allocato, corrompendo i metadati dell'heap e probabilmente causando un crash.