Giải phóng hai lần

#include <stdlib.h>

int main(void)
{
    int *p = malloc(sizeof *p);

    if (p == NULL) return 1;

    free(p);
    free(p);      /* hành vi không xác định */

    return 0;
}

char *a = malloc(64);

free(a);

char *b = malloc(64);      /* rất có thể nhận lại đúng khối vừa trả */

free(a);                   /* bộ cấp phát tưởng khối đang dùng đã trống */

char *c = malloc(64);
char *d = malloc(64);      /* c và d có thể trỏ vào CÙNG một vùng nhớ */

strcpy(c, "du lieu cua c");
strcpy(d, "du lieu cua d");

printf("%s\n", c);        /* in ra "du lieu cua d" */

Trạng thái bình thường của danh sách khối trống:

   [đầu danh sách] -> [khối A] -> [khối B] -> NULL

Sau khi free(A) hai lần, danh sách thành vòng:

   [đầu danh sách] -> [khối A] -> [khối A] -> ...

Kẻ tấn công:
   1. malloc lấy A ra khỏi danh sách, nhưng A vẫn còn ở đó lần thứ hai
   2. Ghi vào A một địa chỉ họ chọn, ví dụ địa chỉ của một con trỏ hàm
   3. malloc lần nữa, bộ cấp phát đọc "con trỏ liên kết" đó
   4. malloc lần nữa, và nó trả về đúng địa chỉ kẻ tấn công đã chọn
   5. Giờ họ ghi được vào bất kỳ đâu

typedef struct { char *ten; } Nguoi;

char *s = malloc(64);

strcpy(s, "An");

Nguoi a = { s };
Nguoi b = { s };      /* cùng trỏ vào s, không ai biết ai sở hữu */

free(a.ten);
free(b.ten);          /* giải phóng hai lần cùng một vùng */

/* Hàm hủy không đặt NULL, nên gọi lần hai là giải phóng lần hai. */
void huy_sai(Nguoi *n)
{
    if (n == NULL) return;

    free(n->ten);      /* không đặt NULL */
    free(n->diem);
}

huy_sai(&a);
huy_sai(&a);           /* giải phóng hai lần */

/* ĐÚNG: đặt NULL để lần gọi sau vô hại */
void huy_dung(Nguoi *n)
{
    if (n == NULL) return;

    free(n->ten);
    free(n->diem);

    n->ten  = NULL;
    n->diem = NULL;
}

huy_dung(&a);
huy_dung(&a);          /* an toàn: free(NULL) không làm gì */

free(NULL);
free(NULL);
free(NULL);      /* gọi bao nhiêu lần cũng được, không làm gì cả */

#define GIAI_PHONG(p)  do { free(p); (p) = NULL; } while (0)

char *a = malloc(64);

GIAI_PHONG(a);
GIAI_PHONG(a);      /* lần hai vô hại */

/* Ghi rõ ai sở hữu ngay trong khai báo và trong chú thích. */
typedef struct {
    char *ten;              /* SỞ HỮU: giải phóng trong nguoi_huy */
} Nguoi;

typedef struct {
    const char *ten;        /* MƯỢN: KHÔNG được giải phóng */
    const Nguoi *chu;       /* MƯỢN */
} TheDeoNguc;

void nguoi_huy(Nguoi *n)
{
    if (n == NULL) return;

    free(n->ten);
    n->ten = NULL;
}

/* Thẻ đeo ngực không có hàm hủy vì nó không sở hữu gì. */

void doi_tuong_huy(DoiTuong *d)
{
    if (d == NULL) return;      /* chấp nhận NULL */

    free(d->a);
    free(d->b);
    free(d->c);

    d->a = NULL;                /* đặt NULL để gọi lại vô hại */
    d->b = NULL;
    d->c = NULL;
}

/* Người gọi không thể quên đặt NULL, vì hàm làm hộ. */
void nguoi_huy(Nguoi **pp)
{
    if (pp == NULL || *pp == NULL) return;

    free((*pp)->ten);
    free(*pp);

    *pp = NULL;         /* con trỏ của người gọi cũng thành NULL */
}

Nguoi *n = nguoi_tao("An");

nguoi_huy(&n);          /* n giờ là NULL */
nguoi_huy(&n);          /* an toàn */