Punteros y malloc en C: use-after-free, fugas y ASan

Curso de C 3 con Apple clang 21: & y *, malloc/free, use-after-free y double free con ASan, leaks --atExit en macOS y 3 fugas de 240 bytes.

Serie: curso de C 3/6 (intermedio). Esta clase es para ti si ya escribes funciones y bucles en C (clase 2) y ahora ves * y & por todas partes en código real: en el proyecto final de la universidad, en un repositorio open source o en la librería nativa que heredaste en tu primer trabajo. Al terminar vas a poder explicar qué guarda un puntero, reservar y liberar memoria correctamente, leer los reportes de AddressSanitizer de los cuatro bugs clásicos del heap y encontrar fugas con la herramienta leaks que viene con macOS.

Los bugs de punteros son la razón de la fama de C. Rara vez truenan donde está el error; corrompen algo que truena después, o nunca truenan y devuelven datos viejos sin avisar. Si trabajas en una librería nativa, un videojuego, un dispositivo embebido o una extensión en C para Python o PHP, estos son los bugs que se comen días. Todo lo que sigue se compiló y ejecutó con Apple clang 21.0.0 en una Mac con Apple Silicon (M1 Pro), macOS 26; no usamos Valgrind ni gdb (ninguno viene con macOS), y las rutas de la salida se acortaron a ~/demo/.

Qué es un puntero, en un solo programa

Un puntero es una variable cuyo valor es una dirección de memoria. &x da la dirección de x; *p sigue la dirección guardada en p (esto se llama desreferenciar).

#include <stdio.h>

void swap_wrong(int a, int b) { int t = a; a = b; b = t; }
void swap(int *a, int *b)     { int t = *a; *a = *b; *b = t; }

int main(void) {
    int x = 10;
    int *p = &x;                 /* p holds the address of x */
    printf("x=%d  &x=%p  p=%p  *p=%d\n", x, (void *)&x, (void *)p, *p);
    *p = 20;                     /* write through the pointer */
    printf("after *p = 20: x=%d\n", x);
    printf("sizeof x=%zu  sizeof p=%zu\n", sizeof x, sizeof p);

    int a = 1, b = 2;
    swap_wrong(a, b);
    printf("swap_wrong: a=%d b=%d\n", a, b);
    swap(&a, &b);
    printf("swap:       a=%d b=%d\n", a, b);

    int arr[4] = {10, 20, 30, 40};
    int *q = arr;
    printf("*q=%d  *(q+2)=%d  q[3]=%d  (q+1)-q=%td\n", *q, *(q + 2), q[3], (q + 1) - q);
    return 0;
}
x=10  &x=0x16dcba578  p=0x16dcba578  *p=10
after *p = 20: x=20
sizeof x=4  sizeof p=8
swap_wrong: a=1 b=2
swap:       a=2 b=1
*q=10  *(q+2)=30  q[3]=40  (q+1)-q=1

Tres hechos para recordar:

  1. C pasa los argumentos por valor. swap_wrong intercambió sus propias copias. Para que una función cambie tu variable, pásale su dirección. Por eso scanf("%d", &n) necesita el &.
  2. Aquí un puntero mide 8 bytes, apunte a lo que apunte, mientras que int mide 4.
  3. La aritmética de punteros cuenta elementos, no bytes. q + 2 avanza 2 int (8 bytes), y q[3] está definido como *(q + 3). Por eso funciona el array decay de la clase 2.

Dónde vive la memoria: stack, heap y estática

global  0x104d00000
stack   0x16b1064a8
heap    0x1054bd970
code    0x104cf84f8

Esa salida (las direcciones cambian en cada ejecución) muestra los tres lugares donde puede vivir una variable de C:

Almacenamiento Cómo lo obtienes Tiempo de vida Error típico
stack (pila) variable local int local; hasta que la función retorna retornar &local
heap malloc, calloc, realloc hasta que llamas a free olvidar free, o usar después de free
estática variable global o static todo el programa estado compartido escondido

El stack se libera solo, y justo por eso retornar un puntero a una variable local está mal:

int *make_counter(void) {
    int count = 0;
    return &count;
}
dangling.c:4:13: warning: address of stack memory associated with local variable 'count' returned [-Wreturn-stack-address]

Al ejecutarlo igual imprimió 0, porque nada había sobrescrito todavía esa posición del stack. ASan normal tampoco dijo nada; solo ASAN_OPTIONS=detect_stack_use_after_return=1 produjo ERROR: AddressSanitizer: stack-use-after-return ... in main dangling.c:8. Confía en el warning del compilador.

malloc y free, bien hechos

int n = 5;
int *a = malloc(n * sizeof *a);          /* bytes = count * element size */
if (a == NULL) { perror("malloc"); return 1; }
for (int i = 0; i < n; i++) a[i] = i * i;
printf("a[4]=%d\n", a[4]);               /* a[4]=16 */
free(a);
a = NULL;                                /* no dangling pointer left */
  • malloc recibe un tamaño en bytes y devuelve un bloque sin inicializar, o NULL si falla. calloc(n, sizeof *a) devuelve memoria en cero.
  • sizeof *a (el tamaño de aquello a lo que apunta a) sigue siendo correcto si después cambias int por long. sizeof(int) no.
  • Cada malloc exitoso necesita exactamente un free. Después de free, el puntero sigue guardando la dirección vieja; ahora es un puntero colgante (dangling pointer). Asignarle NULL hace que los errores posteriores sean ruidosos (desreferenciar NULL truena) o inofensivos (free(NULL) no hace nada, por definición).

Cuatro bugs del heap, con y sin ASan

Pusimos cuatro versiones en un mismo archivo, elegidas por un argumento de línea de comandos, y lo compilamos dos veces: normal (-g) y con -fsanitize=address -g.

if (mode == 1) {                         /* forgot sizeof(int) */
    int *a = malloc(n);
    for (int i = 0; i < n; i++) a[i] = i;
    printf("a[4]=%d\n", a[4]);
    free(a);
} else if (mode == 2) {                  /* use after free */
    int *a = malloc(n * sizeof *a);
    a[0] = 42;
    free(a);
    printf("a[0]=%d\n", a[0]);
} else if (mode == 3) {                  /* double free */
    int *a = malloc(n * sizeof *a);
    free(a);
    free(a);
    printf("freed twice\n");
}
Bug Build normal Con ASan
malloc(n) en vez de malloc(n * sizeof *a) a[4]=4, salida 0 heap-buffer-overflow, línea 11
use after free a[0]=381779559 una vez, a[0]=7 después, salida 0 heap-use-after-free, línea 18
double free sin mensaje, Trace/BPT trap: 5 (salida 133) o Abort trap: 6 (salida 134) attempting double-free, línea 22
*hit con hit en NULL Segmentation fault: 11 (salida 139) SEGV on unknown address 0x000000000000, línea 13

Los dos primeros son los peligrosos: el build normal termina con 0 y un número que parece razonable. El bug de malloc(n) escribió 20 bytes en un bloque de 5; el allocator de macOS justo tenía espacio después, así que no pasó nada visible. Este es el reporte de use-after-free, recortado:

==76039==ERROR: AddressSanitizer: heap-use-after-free on address 0x603000001c30 ...
READ of size 4 at 0x603000001c30 thread T0
    #0 0x000100ed4ac4 in main heapbugs.c:18

0x603000001c30 is located 0 bytes inside of 20-byte region [0x603000001c30,0x603000001c44)
freed by thread T0 here:
    #0 0x000101971368 in free+0x7c (libclang_rt.asan_osx_dynamic.dylib:arm64e+0x41368)
    #1 0x000100ed4a74 in main heapbugs.c:17

previously allocated by thread T0 here:
    #0 0x000101971274 in malloc+0x78 (libclang_rt.asan_osx_dynamic.dylib:arm64e+0x41274)
    #1 0x000100ed4a08 in main heapbugs.c:15
SUMMARY: AddressSanitizer: heap-use-after-free heapbugs.c:18 in main

Tres stack traces, tres líneas: dónde lees (18), dónde se liberó (17) y dónde se reservó (15). En un programa real suelen estar en tres archivos distintos, y este reporte te ahorra un día de búsqueda.

Revisamos dos cosas más. Un puntero NULL y un puntero sin inicializar fallan de forma distinta: int *p; *p = 5; recibió -Wuninitialized al compilar y murió con Bus error: 10 (salida 138), no con un segfault. En lldb el valor sobrante era p = 0x00000001f5578100, que apuntaba a una página de solo lectura (r--) del cargador dinámico; en macOS, escribir en memoria de solo lectura se reporta como bus error. Otro valor sobrante daría otra señal.

Y el analizador estático de clang (clang --analyze, parte de la misma toolchain) no necesita ejecutar nada. De los ocho bugs de esta clase reportó cinco: el puntero sin inicializar, la dirección de stack retornada, los dos use-after-free (Use of memory after it is freed [unix.Malloc]) y el double free (Attempt to free released memory). Se le escaparon el overflow de malloc(n), el NULL que devuelve find() y la fuga de abajo.

Fugas de memoria: a la manera de macOS

Una fuga (leak) es memoria que reservaste y ya no puedes liberar, porque perdiste el puntero:

char *greet(const char *name) {
    char *buf = malloc(64);
    if (!buf) return NULL;
    snprintf(buf, 64, "Hello, %s!", name);
    return buf;                       /* caller must free */
}

int main(void) {
    for (int i = 0; i < 3; i++) {
        char *msg = greet("leak");
        printf("%s\n", msg);
        /* free(msg);  <- forgotten */
    }
    return 0;
}

En Linux usarías Valgrind o el LeakSanitizer de ASan. En macOS con Apple Silicon ninguno funciona aquí:

$ ASAN_OPTIONS=detect_leaks=1 ./leak_asan
==77114==AddressSanitizer: detect_leaks is not supported on this platform.
$ clang -std=c17 -g -fsanitize=leak -o leak_lsan leak.c
clang: error: unsupported option '-fsanitize=leak' for target 'arm64-apple-darwin25.6.0'

Peor todavía: detect_leaks=1 hizo que el programa abortara (salida 134) en vez de ignorar la opción, así que no la dejes en un ASAN_OPTIONS compartido. Lo que sí funciona es el comando leaks de /usr/bin (recortado):

$ leaks --atExit -- ./leak
Hello, leak!
Hello, leak!
Hello, leak!
Process 77064: 192 nodes malloced for 31 KB
Process 77064: 3 leaks for 240 total leaked bytes.

STACK OF 3 INSTANCES OF 'ROOT LEAK: <malloc in greet>':
2   leak                                  0x104684508 main + 52  leak.c:14
1   leak                                  0x104684478 greet + 24  leak.c:6
====
    3 (240 bytes) << TOTAL >>
      1 (80 bytes) ROOT LEAK: <malloc in greet 0xb14c08050> [80]

Fíjate en 80 bytes para un malloc(64): el allocator redondea hacia arriba a su clase de tamaño. leaks terminó con código 1; después de agregar free(msg); imprimió 0 leaks for 0 total leaked bytes. y terminó con 0, así que puede servir de filtro en un script de tests. Compila con -g para obtener los números de línea leak.c:14.

Qué herramienta para qué bug

Diagrama. El camino correcto va de izquierda a derecha: malloc y revisión de NULL, luego usar el bloque dentro de su tamaño, luego free(p) y luego asignar NULL a p. Se desprenden tres caminos equivocados. Olvidar free después de usarlo es una fuga (leak), que encuentra leaks --atExit. Leer a través de p después de free es un heap-use-after-free, que reporta AddressSanitizer. Llamar a free otra vez sobre el mismo puntero es un double-free, que también reporta AddressSanitizer; sin él, el programa murió con una señal de trap y sin mensaje.
La vida de un bloque del heap y las tres formas de romperla. Cada camino roto muestra qué lo detectó en nuestras ejecuciones en macOS.
Síntoma o bug Primera herramienta Notas de nuestras ejecuciones
retornar &local, puntero sin inicializar warnings del compilador -Wall -Wextra detectado al compilar
overflow en el heap, use-after-free, double free -fsanitize=address -g líneas exactas de lectura, free y malloc
use-after-return ASan + detect_stack_use_after_return=1 desactivado por defecto
fuga en macOS leaks --atExit -- ./prog salida 1 si hay fugas; ASan aquí no puede
revisión rápida sin ejecutar clang --analyze encontró 5 de nuestros 8 bugs
crash en un programa grande lldb (clase 6) backtrace y variables

Error típico → lo que realmente pasa → solución

Error Lo que vimos Solución
malloc(n) para n int overflow silencioso, salida 0 malloc(n * sizeof *p) o calloc(n, sizeof *p)
no revisar el resultado de malloc desreferencia de NULL: salida 139 if (p == NULL) siempre
p = realloc(p, bigger) si falla, el bloque viejo se fuga tmp = realloc(p, ...); if (!tmp) {...} p = tmp;
liberar nodos mientras recorres p = p->next Abort trap: 6, salida 134 (ejercicio 2) guarda next antes del free
seguir usando p después de free datos viejos o un crash posterior free(p); p = NULL;

Medido: cómo hacer crecer un arreglo en el heap

realloc(p, size) cambia el tamaño de un bloque y lo mueve si hace falta. La pregunta es cada cuánto llamarlo. Agregamos 1,000,000 de int de tres maneras, -O2, 5 ejecuciones, mediana, contando cuántas veces se movió realmente el bloque (tmp != a):

size_t newcap = strategy == 0 ? cap + 1 : (cap ? cap * 2 : 4);
int *tmp = realloc(a, newcap * sizeof *tmp);
if (!tmp) { free(a); exit(1); }
if (tmp != a) moves++;
a = tmp;
Estrategia Llamadas a realloc Veces que se movió Tiempo (mediana)
crecer de 1 elemento en 1 1,000,000 42 20.33 ms
duplicar la capacidad 19 14 0.76 ms
un solo malloc del tamaño final 0 0 0.61 ms
Gráfico de barras. Llamar a realloc por cada elemento nuevo, un millón de llamadas, tardó 20.33 milisegundos. Duplicar la capacidad, 19 llamadas a realloc, tardó 0.76 milisegundos. Un solo malloc del tamaño final tardó 0.61 milisegundos.
Agregar 1,000,000 de int a un arreglo en el heap con tres estrategias de crecimiento. Mediana de 5 ejecuciones, -O2, Mac con Apple Silicon (M1 Pro), macOS 26.

Dos sorpresas. Crecer de uno en uno fue "solo" 27× más lento que duplicar, porque el allocator de macOS hizo crecer el bloque en su lugar 999,958 veces de un millón; lo movió apenas 42 veces. No cuentes con eso: otro allocator (glibc, Windows, un heap embebido) puede copiar muchas más veces (no lo ejecutamos aquí). Y duplicar quedó a menos de 25% de conocer el tamaño de antemano. Por eso std::vector, las listas de Python y la mayoría de los arreglos dinámicos crecen de forma geométrica.

Límites honestos y notas de versión

  • Solo se ejecutó con Apple clang 21.0.0 en macOS 26 arm64. Valgrind, gdb y el LeakSanitizer de Linux se describen, no se ejecutaron.
  • leaks es parte de las herramientas de desarrollo de macOS; su formato de salida es el de Apple, y --atExit es la forma que funcionó aquí.
  • En Linux x86-64, -fsanitize=address incluye detección de fugas por defecto (no lo ejecutamos aquí).
  • Los valores basura después del use-after-free y la señal del double free (133 vs 134) cambiaron entre ejecuciones en la misma máquina. Esa variabilidad es justamente el punto.
  • %td para diferencias de punteros y %zu para sizeof son C99. nullptr es C23 (-std=c23); esta clase usa NULL y C17.

Ejercicios

1. Escribe int *make_range(int start, int n), que devuelve un nuevo arreglo en el heap {start, start+1, ..., start+n-1}, y un main que lo imprima y lo libere. Revísalo con ASan y con leaks --atExit.

2. Esta limpieza de una lista enlazada aborta con Abort trap: 6. Explica por qué y corrígela.

for (struct node *p = head; p != NULL; p = p->next)
    free(p);

Respuestas

1.

int *make_range(int start, int n) {
    if (n <= 0) return NULL;
    int *a = malloc((size_t)n * sizeof *a);
    if (a == NULL) return NULL;
    for (int i = 0; i < n; i++)
        a[i] = start + i;
    return a;                     /* caller frees */
}

make_range(10, 5) imprimió 10 11 12 13 14; ASan y UBSan no dijeron nada y leaks reportó 0 leaks for 0 total leaked bytes. El cast (size_t) hace la multiplicación en el tipo que espera malloc, así que un n grande no puede desbordar int antes (clase 1).

2. p = p->next se ejecuta después de free(p), así que lee un nodo ya liberado. ASan dice heap-use-after-free ... READ of size 8 ... ex_free.c:15 y freed by ... ex_free.c:16; el tamaño 8 es el puntero next. Guárdalo primero:

while (head != NULL) {
    struct node *next = head->next;   /* read before free */
    free(head);
    head = next;
}

Esta versión imprimió done y corrió limpia con ASan. Nuestro artículo sobre listas enlazadas (C++, con ASan) (en inglés) tiene más de estos casos límite.

Lo que sigue

La clase 4 pasa a los strings: el terminador NUL, por qué strcpy e incluso strncpy muerden, el padding de los structs medido con sizeof y offsetof, y un buffer overflow en el stack atrapado por ASan.

Preguntas frecuentes

¿Cómo encuentro fugas de memoria en C en una Mac?

Usa el comando leaks que viene con macOS: leaks --atExit -- ./prog. En nuestro programa reportó "3 leaks for 240 total leaked bytes" con la línea de cada malloc (compila con -g), y termina con código 1 cuando encuentra fugas, así que sirve en scripts. La detección de fugas de AddressSanitizer no está disponible en macOS con Apple Silicon: ASAN_OPTIONS=detect_leaks=1 imprimió "detect_leaks is not supported on this platform", y Apple clang 21 rechaza -fsanitize=leak.

¿Qué pasa si uso memoria después de free() en C?

Sin herramientas, normalmente nada visible: nuestro programa imprimió a[0]=381779559 en una ejecución y a[0]=7 en las siguientes, y terminó con 0. La memoria vuelve a pertenecer al allocator y se puede reutilizar en cualquier momento. Compilado con -fsanitize=address, se detiene de inmediato con heap-use-after-free y muestra las líneas de la lectura, del free y del malloc original.

¿Es seguro llamar a free() dos veces sobre el mismo puntero?

No, es comportamiento indefinido. En macOS 26 nuestro programa murió sin mensaje, a veces con Trace/BPT trap: 5 (código 133) y a veces con Abort trap: 6 (código 134). ASan reporta "attempting double-free". Asignar NULL al puntero después de free ayuda, porque free(NULL) está definido para no hacer nada.

  • #c
  • #intermedio
  • #punteros
  • #malloc
  • #addresssanitizer
  • #fugas de memoria

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑