文档章节

解读Linux安全机制之栈溢出保护

macwe
 macwe
发布于 2016/01/27 14:10
字数 3163
阅读 1993
收藏 7

解读Linux安全机制之栈溢出保护

0x00 概述

栈溢出保护是一种缓冲区溢出攻击缓解手段,当函数存在缓冲区溢出攻击漏洞时,攻击者可以覆盖栈上的返回地址来让shellcode能够得到执行。当启用栈保护后,函数开始执行的时候会先往栈里插入cookie信息,当函数真正返回的时候会验证cookie信息是否合法,如果不合法就停止程序运行。攻击者在覆盖返回地址的时候往往也会将cookie信息给覆盖掉,导致栈保护检查失败而阻止shellcode的执行。在Linux中我们将cookie信息称为canary(以下统一使用canary)。

gcc在4.2版本中添加了-fstack-protector和-fstack-protector-all编译参数以支持栈保护功能,4.9新增了-fstack-protector-strong编译参数让保护的范围更广。以下是-fstack-protector和-fstack-protector-strong的区别:

参数gcc支持版本说明
-fstack-protector4.2只为局部变量中包含长度超过8-byte(含)的char数组的函数插入保护代码
-fstack-protector-strong4.9满足以下三个条件都会插入保护代码:1.局部变量的地址作为赋值语句的右值或函数参数;2.局部变量包含数组类型的局部变量,不管数组的长度;3.带register声明的局部变量

Linux系统中存在着三种类型的栈:

  1. 应用程序栈:工作在Ring3,由应用程序来维护;
  2. 内核进程上下文栈:工作在Ring0,由内核在创建线程的时候创建;
  3. 内核中断上下文栈:工作在Ring0,在内核初始化的时候给每个CPU核心创建一个。

0x01 应用程序栈保护

1. 栈保护工作原理

下面是一个包含栈溢出的例子:

/* test.c */
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    char buf[16];

    scanf("%s", buf);
    printf("%s\n", buf);

    return 0;
}

我们先禁用栈保护功能看看执行的结果

[root@localhost stackp]# gcc -o test test.c -fno-stack-protector
[root@localhost stackp]# python -c "print 'A'*24" | ./test
AAAAAAAAAAAAAAAAAAAAAAAA
Segmentation fault   <- RIP腐败,导致异常

当返回地址被覆盖后产生了一个段错误,因为现在的返回地址已经无效了,所以现在执行的是CPU的异常处理流程。我们打开栈保护后再看看结果:

[root@localhost stackp]# gcc -o test test.c -fstack-protector
[root@localhost stackp]# python -c "print 'A'*25" | ./test
AAAAAAAAAAAAAAAAAAAAAAAAA
*** stack smashing detected ***: ./test terminated <- 提示检查到栈溢出

这时触发的就不是段错误了,而是栈保护的处理流程,我们反汇编看看做了哪些事情:

0000000000400610 <main>:
  400610:       55                      push   %rbp
  400611:       48 89 e5                mov    %rsp,%rbp
  400614:       48 83 ec 30             sub    $0x30,%rsp
  400618:       89 7d dc                mov    %edi,-0x24(%rbp)
  40061b:       48 89 75 d0             mov    %rsi,-0x30(%rbp)
  40061f:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax  <- 插入canary值
  400626:       00 00
  400628:       48 89 45 f8             mov    %rax,-0x8(%rbp)
  40062c:       31 c0                   xor    %eax,%eax
  40062e:       48 8d 45 e0             lea    -0x20(%rbp),%rax
  400632:       48 89 c6                mov    %rax,%rsi
  400635:       bf 00 07 40 00          mov    $0x400700,%edi
  40063a:       b8 00 00 00 00          mov    $0x0,%eax
  40063f:       e8 cc fe ff ff          callq  400510 <__isoc99_scanf@plt>
  400644:       48 8d 45 e0             lea    -0x20(%rbp),%rax
  400648:       48 89 c7                mov    %rax,%rdi
  40064b:       e8 80 fe ff ff          callq  4004d0 <puts@plt>
  400650:       b8 00 00 00 00          mov    $0x0,%eax
  400655:       48 8b 55 f8             mov    -0x8(%rbp),%rdx  <- 检查canary值
  400659:       64 48 33 14 25 28 00    xor    %fs:0x28,%rdx
  400660:       00 00
  400662:       74 05                   je     400669 <main+0x59> # 0x400669
  400664:       e8 77 fe ff ff          callq  4004e0 <__stack_chk_fail@plt>
  400669:       c9                      leaveq
  40066a:       c3                      retq

我们看到函数开头(地址:0x40061f)处gcc编译时在栈帧的返回地址和临时变量之间插入了一个canary值,该值是从%fs:0x28里取的,栈帧的布局如下:

stack:
| ......          |
| orig_return     |
| orig_rbp        |  <- %rbp
| canary          |  <- -0x8(%rpb), 既 %fs:0x28
| local variables |
|                 |  <- %rsp

在函数即将返回时(地址:0x400655)检查栈中的值是否和原来的相等,如果不相等就调用glibc的__stack_chk_fail函数,并终止进程。

2. canary值的产生

这里以x64平台为例,canary是从%fs:0x28偏移位置获取的,%fs寄存器被glibc定义为存放tls信息的,我们需要查看glibc的源代码:

typedef struct
{
  void *tcb;		/* Pointer to the TCB.  Not necessarily the
			   thread descriptor used by libpthread.  */
  dtv_t *dtv;
  void *self;		/* Pointer to the thread descriptor.  */
  int multiple_threads;
  int gscope_flag;
  uintptr_t sysinfo;
  uintptr_t stack_guard;   <- canary值,偏移位置0x28处
  uintptr_t pointer_guard;
  ......
} tcbhead_t;

结构体tcbhead_t就是用来描述tls的也就是%fs寄存器指向的位置,其中+0x28偏移位置的成员变量stack_guard就是canary值。另外通过strace ./test看到在进程加载的过程中会调用arch_prctl系统调用来设置%fs的值,

root@localhost stackp]# strace ./test
execve("./test", ["./test"], [/* 24 vars */]) = 0
......
arch_prctl(ARCH_SET_FS, 0x7f985a041740) = 0
......

产生canary值的代码在glibc的_dl_main和__libc_start_main函数中:

  /* Set up the stack checker's canary.  */
  uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
# ifdef THREAD_SET_STACK_GUARD
  THREAD_SET_STACK_GUARD (stack_chk_guard);
# else
  __stack_chk_guard = stack_chk_guard;
# endif

_dl_random是一个随机数,它由_dl_sysdep_start函数从内核获取的。_dl_setup_stack_chk_guard函数负责生成canary值,THREAD_SET_STACK_GUARD宏将canary设置到%fs:0x28位置。

在应用程序栈保护中,进程的%fs寄存器是由glibc来管理的,并不涉及到内核提供的功能。

3. x32应用程序栈保护

解读完了x64的实现,我们来看看x32下面的情况,我们还是使用上面例子的代码在x32的机器上编译,得到下面的代码:

08048464 <main>:
 ......
 8048474:    65 a1 14 00 00 00      mov   %gs:0x14,%eax  # 插入canary值
 804847a:    89 44 24 3c            mov   %eax,0x3c(%esp)
 ......
 80484aa:    65 33 15 14 00 00 00   xor   %gs:0x14,%edx  # 检查canary值
 80484b1:    74 05                  je    80484b8 <main+0x54> # 0x80484b8
 80484b3:    e8 c0 fe ff ff         call  8048378 <__stack_chk_fail@plt>
 80484b8:    c9                     leave
 80484b9:    c3                     ret

在x32下的实现和x64是一样的,只不过canary值保存在%gs:0x14中,glibc使用%gs寄存器来保存TLS信息。

0x02 内核态栈保护

Linux的CC_STACKPROTECTOR补丁提供了对内核栈溢出保护功能,该补丁是Tejun Heo在09年给主线kernel提交的。

  • 2.6.24:首次出现CONFIG_CC_STACKPROTECTOR编译选项并实现了x64平台的进程上下文栈保护支持;
  • 2.6.30:新增对内核中断上下文的栈保护和对x32平台进程上下文的栈保护支持;
  • 3.14:对该功能进行了一次升级以支持gcc的-fstack-protector-strong参数,提供更大范围的栈保护。

1. 栈保护工作原理

我们参照前面的代码写了一个可加载模块并反汇编来看看是怎么样的:

[root@localhost stackpk]# objdump -r test.ko
RELOCATION RECORDS FOR [.text]:
OFFSET           TYPE              VALUE
0000000000000061 R_X86_64_PC32     __stack_chk_fail-0x0000000000000004
......

[root@localhost stackpk]# objdump -d test.ko
0000000000000000 <foo>:
  ......
  # 函数开头,往栈里插入canary
  24:   65 48 8b 04 25 28 00    mov    %gs:0x28,%rax
  2d:   48 89 45 f8             mov    %rax,-0x8(%rbp)
  ......
  # 函数返回,检查canary
  4a:   48 8b 45 f8             mov    -0x8(%rbp),%rax
  4e:   65 48 33 04 25 28 00    xor    %gs:0x28,%rax
  57:   75 02                   jne    5b <foo+0x5b>
  59:   c9                      leaveq
  5a:   c3                      retq
  5b:   0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)
  60:   e8 00 00 00 00          callq  65 <foo+0x65>  # __stack_chk_fail

内核函数的栈保护工作原理和应用程序的栈保护是一样的,只不过canary是从内核%gs:0x28位置取的,并且检查失败时调用内核的__stack_chk_fail函数并且产生panic。

2. 中断上下文canary值的产生

x64平台

硬件中断(hardware interrupt)和软中断(softirq)都使用中断栈(Interrupt stack)。

当内核刚进入64位模式的时候,startup_64函数为内核的初始化工作设置好了%gs寄存器和分配栈空间,代码在arch/x86/kernel/head_64.S中,下面是startup_64函数片段:

/* Setup a boot time stack */
movq stack_start(%rip), %rsp

/* Set up %gs */
movl	$MSR_GS_BASE,%ecx
movl	initial_gs(%rip),%eax
movl	initial_gs+4(%rip),%edx
wrmsr	

GLOBAL(initial_gs)
.quad	INIT_PER_CPU_VAR(irq_stack_union)
GLOBAL(stack_start)
.quad  init_thread_union+THREAD_SIZE-8
.word  0

其中%gs被定义为percpu变量,可用irq_stack_union联合体表示:

union irq_stack_union {
	char irq_stack[IRQ_STACK_SIZE];
	struct {
		char gs_base[40];
		unsigned long stack_canary; <- GS+40偏移位置
	};
};

startup_64的末尾会跳转到start_kernel函数,该函数也是canary产生的地方。start_kernel调用了boot_init_stack_canary,它的作用就是产生一个随机的canary并且应用到当前%gs:0x28位置:

static __always_inline void boot_init_stack_canary(void)
{
	u64 canary;
	u64 tsc;

#ifdef CONFIG_X86_64
	BUILD_BUG_ON(offsetof(union irq_stack_union, stack_canary) != 40);
#endif
	
	/* 同时使用随机数和TSC,让随机性更强 */
	get_random_bytes(&canary, sizeof(canary));
	tsc = rdtsc();
	canary += tsc + (tsc << 32UL);

	/* PID为0, 此时的进程名叫swapper,之后成为idle进程  */
	current->stack_canary = canary; <- canary信息保存在这里
#ifdef CONFIG_X86_64
	this_cpu_write(irq_stack_union.stack_canary, canary);
#else
	this_cpu_write(stack_canary.canary, canary);
#endif
}

start_kernel函数是由boot CPU执行的,在多核心的情况下还会在每个CPU核心初始化的时候分别调用boot_init_stack_canary来产生canary值。我们发现中断上下文的canary值保存在每个核心的idle进程task_struct->stack_canary中,这样当上下文切换的时候就不会丢失了。

x32平台

在x32平台上的percpu区域是保存在%fs中的,内核初始化的时候会为每个cpu核心产生canary值存放在percpu区域的stack_canary成员中备用。

struct stack_canary {
	char __pad[20];		/* canary at %gs:20 */
	unsigned long canary;
};
DECLARE_PER_CPU_ALIGNED(struct stack_canary, stack_canary);

但是gcc要求canary值必须从%gs:0x14偏移的位置获取,因此必须让%gs:0x14指向percpu变量stack_canary.canary才行。首先内核选用GDT第28项描述的数据段来存放canary信息:

/* ./arch/x86/include/asm/segment.h */
#define GDT_ENTRY_STACK_CANARY		28   <- canary数据段索引

#ifdef CONFIG_CC_STACKPROTECTOR
# define __KERNEL_STACK_CANARY		(GDT_ENTRY_STACK_CANARY*8)
#else
# define __KERNEL_STACK_CANARY		0
#endif

/* ./arch/x86/include/asm/stackprotector.h */
#define GDT_ENTRY_INIT(flags, base, limit) { { { \
		.a = ((limit) & 0xffff) | (((base) & 0xffff) << 16), \
		.b = (((base) & 0xff0000) >> 16) | (((flags) & 0xf0ff) << 8) | \
			((limit) & 0xf0000) | ((base) & 0xff000000), \
	} } }
	
/* 段描述符 limit=0x18,s=1,dpl=0,p=1,avl=0,l=0,d=1,g=0 */
#define GDT_STACK_CANARY_INIT						\
	[GDT_ENTRY_STACK_CANARY] = GDT_ENTRY_INIT(0x4090, 0, 0x18),
	
/* 将percpu变量stack_canary的地址设置到段描述符base */
static inline void setup_stack_canary_segment(int cpu)
{
#ifdef CONFIG_X86_32
	unsigned long canary = (unsigned long)&per_cpu(stack_canary, cpu);
	struct desc_struct *gdt_table = get_cpu_gdt_table(cpu);
	struct desc_struct desc;

	desc = gdt_table[GDT_ENTRY_STACK_CANARY];
	set_desc_base(&desc, canary);
	write_gdt_entry(gdt_table, GDT_ENTRY_STACK_CANARY, &desc, DESCTYPE_S);
#endif
}

接下来只要设置%gs寄存器来索引该段描述符就可以了:

/* ./arch/x86/include/asm/stackprotector.h */
static inline void load_stack_canary_segment(void)
{
#ifdef CONFIG_X86_32
	asm("mov %0, %%gs" : : "r" (__KERNEL_STACK_CANARY) : "memory");
#endif
}

/* ./arch/x86/kernel/cpu/common.c */
void load_percpu_segment(int cpu)
{
#ifdef CONFIG_X86_32
    loadsegment(fs, __KERNEL_PERCPU);
#else
    loadsegment(gs, 0);
    wrmsrl(MSR_GS_BASE, (unsigned long)per_cpu(irq_stack_union.gs_base, cpu));
#endif
    load_stack_canary_segment();
}

到这里x32平台的%gs:0x14偏移的canary值已经初始化完成了。

2. 进程上下文canary值的产生

无论是内核线程还是用户线程,当一个线程创建的时候,内核给线程生成一个canary值存放在task_struct结构体的stack_canary成员变量中,见dup_task_struct函数:

/* ./kernel/fork.c */

 static struct task_struct *dup_task_struct(struct task_struct *orig)
 {
     ......
 #ifdef CONFIG_CC_STACKPROTECTOR
     tsk->stack_canary = get_random_int();
 #endif
     ......
 }

接下来内核要做的事情就是当发生线程切换的时候让该canary值设置到%gs:0x28偏移处,这个是在switch_to宏中完成的:

/* ./arch/x86/include/asm/switch_to.h */

#define __switch_canary                                   \
    "movq %P[task_canary](%%rsi),%%r8\n\t"                \
    "movq %%r8,"__percpu_arg([gs_canary])"\n\t"
#define __switch_canary_oparam                            \
    , [gs_canary] "=m" (irq_stack_union.stack_canary)
#define __switch_canary_iparam                            \
    , [task_canary] "i" (offsetof(struct task_struct, stack_canary))

#define switch_to(prev, next, last)                   \
	asm volatile(SAVE_CONTEXT                         \
		 ......
		 __switch_canary                              \
		 ......
         : "=a" (last)                                \
           __switch_canary_oparam                     \
         : [next] "S" (next), [prev] "D" (prev),      \
		 ......
		 __switch_canary_iparam                       \
         : "memory", "cc" __EXTRA_CLOBBER)

上面是x64平台上的代码并且忽略了与canary值切换无关的部分,它把task_struct->stack_canary赋值到percpu变量irq_stack_union.stack_canary,这样我们代码中找到的canary值就是当前上下文的了。在x32平台上也是类似的只不过percpu变量是stack_canary.canary。

总结: 在gcc、glibc和内核的共同支持下,Linux对所有的可能发生缓冲区溢出的栈返回地址都进行了保护:

  1. 在应用进程上下文,canary值由glibc产生并保存在tcbhead_t中,当canary检查失败时执行glibc的__stack_chk_fail,并终止进程;
  2. 在内核进程上下文,canary值在内核copy_process时产生并保存在task_struct中,当canary检查失败时执行内核的__stack_chk_fail,并产生panic;
  3. 在内核中断上下文,canary值在start_kernel以及每个CPU核心初始化的时候产生并保存在每个CPU核心的idle进程task_struct中,当canary检查失败时执行内核的__stack_chk_fail,并产生panic。

0x03 参考资料

© 著作权归作者所有

共有 人打赏支持
macwe
粉丝 14
博文 18
码字总数 22244
作品 0
海淀
其他
私信 提问
栈的保护--windows和linux

对于为何要保护堆栈,请以“缓冲区溢出”,“堆栈”为关键词google一下,本文不再赘述。只要你的程序要调用函数,那么就要使用堆栈,不进行函数调用的程序已经很少了吧,难道你能忍受通篇的j...

晨曦之光
2012/04/10
364
0
x86架构的一个瑕疵--可执行保护

很久以前,曾经写过一篇关于如何保护栈不可执行的文章《栈的保护--windows和linux》,文章的最后谈到了一种很好的方式,就是不用段式保护机制而使用页式保护机制,在页表项中做文章,但是这种...

晨曦之光
2012/04/10
88
0
雪城大学信息安全讲义 4.3~4.4

3 对抗措施 3.1 应用安全工程原则 使用强类型语言,例如 Java、C#,以及其他。使用这些语言,可以避免缓冲区溢出。 使用安全的库函数 3.2 系统化代码修改 StackShield:分离控制(返回地址)...

apachecn_飞龙
2017/04/21
0
0
windows和linux的内存管理

windows的内存管理很是严谨,使用内存必须首先分配,当然每个操作系统都是这样,然而windows的严谨在于分配的过程,分为保留和提交两个阶段,其中保留的含义就是在进程的虚拟地址空间保留一块...

晨曦之光
2012/04/10
238
0
Android中的防缓冲区溢出技术

#ps -aux grep test #ps -aux grep test

samsunglinux
2018/07/02
0
0

没有更多内容

加载失败,请刷新页面

加载更多

开始看《JSP&Servlet学习笔记》

1:WEB应用简介。其中1.2.1对Web容器的工作流程写得不错 2:编写Servlet。搞清楚了Java的Web目录结构,以及Web.xml的一些配置作用。特别是讲了@WebServlet标签 3:请求与响应。更细致的讲了从...

max佩恩
23分钟前
0
0
mysql分区功能详细介绍,以及实例

一,什么是数据库分区 前段时间写过一篇关于mysql分表的的文章,下面来说一下什么是数据库分区,以mysql为例。mysql数据库中的数据是以文件的形势存在磁盘上的,默认放在/mysql/data下面(可...

吴伟祥
24分钟前
0
0
SQL语句查询

1.1 排序 通过order by语句,可以将查询出的结果进行排序。放置在select语句的最后。 格式: SELECT * FROM 表名 ORDER BY 排序字段ASC|DESC; ASC 升序 (默认) DESC 降序 1.查询所有商品信息,...

stars永恒
40分钟前
2
0
IntelliJ IDEA 第一个 Scala 程序

IntelliJ 安装完成 Scala 插件后,你需要尝试使用 IntelliJ 来创建并且运行第一个程序。 通常这个程序只是简单的输出 Hello World。 创建一个新工程 在文件下面选择新建,然后选择创建工程。...

honeymose
44分钟前
2
0
csapp 习题 - 如何实现异或 exclusive-or

阅读 csapp v3 时,练习题 2.13 很有意思。练习题描述如下。 位设置是对于参数 mask 中每一个为 1 的位,那么参数 x 中相应位则被设置为 1 ;位清除是对于参数 mask 中每一个为 1 的位,那么...

ylme
昨天
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部