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:
- C pasa los argumentos por valor.
swap_wrongintercambió sus propias copias. Para que una función cambie tu variable, pásale su dirección. Por esoscanf("%d", &n)necesita el&. - Aquí un puntero mide 8 bytes, apunte a lo que apunte, mientras que
intmide 4. - La aritmética de punteros cuenta elementos, no bytes.
q + 2avanza 2 int (8 bytes), yq[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 */
mallocrecibe un tamaño en bytes y devuelve un bloque sin inicializar, oNULLsi falla.calloc(n, sizeof *a)devuelve memoria en cero.sizeof *a(el tamaño de aquello a lo que apuntaa) sigue siendo correcto si después cambiasintporlong.sizeof(int)no.- Cada
mallocexitoso necesita exactamente unfree. Después defree, el puntero sigue guardando la dirección vieja; ahora es un puntero colgante (dangling pointer). AsignarleNULLhace 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
| 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 |
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.
leakses parte de las herramientas de desarrollo de macOS; su formato de salida es el de Apple, y--atExites la forma que funcionó aquí.- En Linux x86-64,
-fsanitize=addressincluye 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.
%tdpara diferencias de punteros y%zuparasizeofson C99.nullptres C23 (-std=c23); esta clase usaNULLy 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.
- Anterior: curso de C 2/6: bucles, funciones y arreglos
- Siguiente: curso de C 4/6: strings, structs y buffer overflows
- Más adelante: comportamiento indefinido y optimización, caché, make y lldb; inicio de la serie: clase 1
- Relacionado: una pila (stack) en C++ con hallazgos de ASan (en inglés), hoja de ruta para aprender a programar
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.