如何在 x86 汇编中编写自修改代码

Question

我正在考虑为我最近开发的一个业余爱好虚拟机编写一个 JIT 编译器。我了解一些汇编语言（我主要是一名 C 程序员。我可以阅读大多数汇编语言并参考我不理解的操作码，并编写一些简单的程序。）但是我很难理解这几个示例我在网上找到的自我修改代码。

这是一个这样的例子：http://asm.sourceforge.net/articles/smc.html

提供的示例程序在运行时做了大约四种不同的修改，其中没有一个被清楚地解释。 Linux 内核中断被多次使用，并且没有解释或详细说明。 （作者在调用中断之前将数据移动到几个寄存器中。我假设他正在传递参数，但这些参数根本没有解释，让读者猜测。）

我正在寻找的是最简单，最直接的例子在自修改程序的代码中。我可以查看并使用它来了解如何编写 x86 程序集中的自修改代码及其工作原理。您可以向我指出任何资源，或者您可以提供任何可以充分证明这一点的示例吗？

我使用 NASM 作为我的汇编器。

编辑：我也在 Linux 上运行此代码。

Answer 1

哇，结果比我想象的要痛苦得多。 100% 的痛苦是 Linux 保护程序不被覆盖和/或执行数据。

两种解决方案如下所示。并且涉及到很多谷歌搜索，因此有些简单的放置一些指令字节并执行它们是我的，mprotect 和页面大小对齐是从谷歌搜索中剔除的，这是我必须为这个例子学习的东西。

自修改代码很简单，如果您获取程序或至少只是两个简单的函数，编译然后反汇编，您将获得这些指令的操作码。或者使用 nasm 编译汇编程序块等。由此我确定了将立即数加载到 eax 中然后返回的操作码。

理想情况下，您只需将这些字节放入某个内存中并执行该内存即可。要让 Linux 做到这一点，您必须更改保护，这意味着您必须向其发送一个在 mmap 页上对齐的指针。因此，分配比您需要的更多的内存，找到该分配中页面边界上的对齐地址，并对该地址进行保护，并使用该内存来放置操作码，然后执行。

第二个示例将现有函数编译到程序中，同样由于保护机制，您不能简单地指向它并更改字节，您必须取消对它的写入保护。因此，您必须使用该地址和足够的字节备份到先前的页面边界调用 mprotect 来覆盖要修改的代码。然后，您可以按照您想要的任何方式更改该函数的字节/操作码（只要您不溢出到您想要继续使用的任何函数中）并执行它。在本例中，您可以看到 fun() 有效，然后我将其更改为仅返回一个值，再次调用它，现在它已被修改。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

unsigned char * testfun;

unsigned int fun(unsigned int a) {
    return (a + 13);
}

unsigned int fun2(void) {
    return (13);
}

int main(void) {
    unsigned int ra;
    unsigned int pagesize;
    unsigned char * ptr;
    unsigned int offset;

    pagesize = getpagesize();
    testfun = malloc(1023 + pagesize + 1);
    if (testfun == NULL) return (1);
    //need to align the address on a page boundary
    printf("%p\n", testfun);
    testfun = (unsigned char * )(((long) testfun + pagesize - 1) & ~(pagesize - 1));
    printf("%p\n", testfun);

    if (mprotect(testfun, 1024, PROT_READ | PROT_EXEC | PROT_WRITE)) {
        printf("mprotect failed\n");
        return (1);
    }

    //400687: b8 0d 00 00 00          mov    $0xd,%eax
    //40068d: c3                      retq

    testfun[0] = 0xb8;
    testfun[1] = 0x0d;
    testfun[2] = 0x00;
    testfun[3] = 0x00;
    testfun[4] = 0x00;
    testfun[5] = 0xc3;

    ra = ((unsigned int( * )()) testfun)();
    printf("0x%02X\n", ra);

    testfun[0] = 0xb8;
    testfun[1] = 0x20;
    testfun[2] = 0x00;
    testfun[3] = 0x00;
    testfun[4] = 0x00;
    testfun[5] = 0xc3;

    ra = ((unsigned int( * )()) testfun)();
    printf("0x%02X\n", ra);

    printf("%p\n", fun);
    offset = (unsigned int)(((long) fun) & (pagesize - 1));
    ptr = (unsigned char * )((long) fun & (~(pagesize - 1)));

    printf("%p 0x%X\n", ptr, offset);

    if (mprotect(ptr, pagesize, PROT_READ | PROT_EXEC | PROT_WRITE)) {
        printf("mprotect failed\n");
        return (1);
    }

    //for(ra=0;ra<20;ra++) printf("0x%02X,",ptr[offset+ra]); printf("\n");

    ra = 4;
    ra = fun(ra);
    printf("0x%02X\n", ra);

    ptr[offset + 0] = 0xb8;
    ptr[offset + 1] = 0x22;
    ptr[offset + 2] = 0x00;
    ptr[offset + 3] = 0x00;
    ptr[offset + 4] = 0x00;
    ptr[offset + 5] = 0xc3;

    ra = 4;
    ra = fun(ra);
    printf("0x%02X\n", ra);

    return (0);
}

Answer 2

由于您正在编写 JIT 编译器，因此您可能不需要自修改代码，而是希望在运行时生成可执行代码。这是两件不同的事情。自修改代码是指在开始运行后进行修改的代码。自修改代码对现代处理器有很大的性能损失，因此对于 JIT 编译器来说是不受欢迎的。

在运行时生成可执行代码应该是一个简单的事情，只需使用 PROT_EXEC 和 PROT_WRITE 权限 mmap() 一些内存即可。您还可以对自己分配的某些内存调用 mprotect()，如上面 dwelch 所做的那样。

Answer 3

我正在开发一个自修改游戏来教授 x86 汇编，并且必须解决这个确切的问题。我使用了以下三个库：

AsmJit + AsmTk进行组装： https://github.com/asmjit/asmjit + https://github.com/asmjit/asmtk
UDIS86反汇编：https://github.com/vmt/udis86

使用Udis86阅读说明，用户可以将它们编辑为字符串，然后使用 AsmJit/AsmTk 来组装新字节。这些可以写回内存，正如其他用户指出的那样，写回需要在 Windows 上使用 VirtualProtect 或在 Unix 上使用 mprotect 来修复内存页面权限。

对于 StackOverflow 来说，代码示例有点长，因此我将向您推荐我用代码示例编写的一篇文章：

https://medium.com/squallygame/how-we-wrote-a-self-hacking-game-in-c-d8b9f97bfa99

一个正常运行的仓库在这里（非常轻量级）：

https://github.com/Squalr/SelfHackingApp< /a>

Answer 4

这是用 AT&T 汇编编写的。从程序的执行中可以看到，由于自修改代码，输出发生了变化。

编译： gcc -m32modify.smodify.c

使用 -m32 选项是因为该示例适用于 32 位机器

Aesembly：

.globl f4
.data     

f4:
    pushl %ebp       #standard function start
    movl %esp,%ebp

f:
    movl $1,%eax # moving one to %eax
    movl $0,f+1  # overwriting operand in mov instuction over
                 # the new immediate value is now 0. f+1 is the place
                 # in the program for the first operand.

    popl %ebp    # standard end
    ret

C 测试程序：

 #include <stdio.h>

 // assembly function f4
 extern int f4();
 int main(void) {
 int i;
 for(i=0;i<6;++i) {
 printf("%d\n",f4());
 }
 return 0;
 }

输出：

1
0
0
0
0
0

Answer 5

基于上面的例子，有一个更简单的例子。感谢dwelch提供了很多帮助。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>

char buffer [0x2000];
void* bufferp;

char* hola_mundo = "Hola mundo!";
void (*_printf)(const char*,...);

void hola()
{ 
    _printf(hola_mundo);
}

int main ( void )
{
    //Compute the start of the page
    bufferp = (void*)( ((unsigned long)buffer+0x1000) & 0xfffff000 );
    if(mprotect(bufferp, 1024, PROT_READ|PROT_EXEC|PROT_WRITE))
    {
        printf("mprotect failed\n");
        return(1);
    }
    //The printf function has to be called by an exact address
    _printf = printf;

    //Copy the function hola into buffer
    memcpy(bufferp,(void*)hola,60 //Arbitrary size);


    ((void (*)())bufferp)();  

    return(0);
}

Answer 6

您还可以查看 GNU lighting 等项目。你给它一个简化的 RISC 型机器的代码，它会动态生成正确的机器。

您应该考虑的一个非常现实的问题是与外国图书馆的接口。您可能需要至少支持一些系统级调用/操作，虚拟机才能发挥作用。 Kitsune 的建议是让您考虑系统级调用的良好开端。您可能会使用 mprotect 来确保您修改的内存变得合法可执行。 （@KitsuneYMG）

一些允许调用用 C 编写的动态库的 FFI 应该足以隐藏许多操作系统特定的细节。所有这些问题都会对您的设计产生相当大的影响，因此最好尽早开始考虑它们。

Answer 7

该问题标有“汇编”和“x86”，但没有标有“C”。虽然提出问题的人提到他们主要使用 C 语言，但寻找纯汇编解决方案的人（包括过去的我）很可能会遇到这个问题。因此，这是我对 JIT 程序最简单的演示的尝试，很大程度上受到 old_timer 答案的启发，但用纯汇编重写。

.bss
.align 4096 # page size on my machine. You can automate this process using
            # libc's getpagesize() to make it bit more portable, but hey!,
            # this is a minimum viable product!
exec: 
    .skip 10000




.text
mprotectoutput: .asciz "mprotect output value %d\n"

.global main
main:
    # prologue
    pushq %rbp
    movq %rsp, %rbp

    # body
    movq $exec, %rdi
    movq $10000, %rsi
    movq $7, %rdx
    call mprotect

    # print output from the mprotect function. If other than 0, the code will
    # segfault on `jmp *%rax`.
    movq $mprotectoutput, %rdi
    movq %rax, %rsi
    xor %rax, %rax
    call printf

    # the subroutine will move 0x45 to %rax, the return to the address
    # in register %r15

    # set the return address
    movq $back, %r15

    # rdi will be a counter that counts how many program bytes were written
    xor %rdi, %rdi
    # 48 c7 c0 45 00 00 00  mov    $0x45,%rax
    movq $0x0000000045c0c748, %rax
    movq %rax, exec(%rdi)
    addq $7, %rdi
    # 41 ff e7              jmp    *%r15
    movl $0x00e7ff41, %eax
    movl %eax, exec(%rdi)
    addq $3, %rdi

    movq $exec, %rax
    jmp *%rax

back:
    # epilogue
    movq %rbp, %rsp
    popq %rbp
    ret

Answer 8

由于 https://nasm 可以编写比给出的解决方案简单得多的解决方案.us/doc/nasmdoc8.html#section-8.9.2，section 指令的 ELF 扩展。这允许您定义自定义部分，特别是可写和可执行的部分。基于这一见解，我写了这个（在 Linux amd64 上测试）：

    ; Here is a trivial example of self-modifying code.
    ; The instruction at to_modify would print 'A', but 
    ; because of the instruction at label `modifier`, 
    ; the 'A' is replaced by a 'B'. While this isn't changing the op itself,
    ; it is however modifying a hard-coded argument (within a code section), 
    ; so I would say it counts.
    ;
    ; Many of the examples online segfaulted when I tried to run them, or
    ; just wouldn't compile. This example uses nasm's 
    ; section directives found on https://nasm.us/doc/nasmdoc8.html#section-8.9.2,
    ; which allows us to create a writable AND executable section, .textmodify.
    ; 
    ; Be warned; this code may mess up your computer, as it has not been tested on computers
    ; other than mine
    ;
    ; To compile:
    ; $ nasm -f elf self_modify.asm && ld -m elf_i386 -o self_modify self_modify.o && ./self_modify
    ; I am using nasm version 2.14.02.
    ; 
    ; The expected output sohuld be 
    ; Original Code
    ; Modified Code
    ; B
    ;
    ; Whereas if you comment out the line at modifier:
    ; Original code
    ; Modified code
    ; A
    ;
    ; Try improving this program by isolating the .textmodify section to code that will
    ; change (I haven't tried this yet). 
    ; 
    
    
    section .textmodify   progbits    alloc   exec    write   align=1
    global _start
    
    _start:
        ; Print "Original code"
        mov eax, 4
        mov ebx, 1
        mov ecx, msg1
        mov edx, len1
        int 0x80
    
        ; Modify the code
    modifier:
        mov dword [to_modify+1], 0x42  ; 
    
        ; Print "Modified code"
        mov eax, 4
        mov ebx, 1
        mov ecx, msg2
        mov edx, len2
        int 0x80
    
    modified_code:
        ; This instruction will be modified
        to_modify:
        ; This instruction is 
        ; b8 41 00 00 00 
        ; in binary. The first byte is the opcode for mov, the second is 
        ; the character code for 'A' in hex. Thus we replace [to_modify+1] with 0x42. 
        mov eax, 'A'
        nop
        
        ; Print the modified character
        push eax
        mov eax, 4
        mov ebx, 1
        mov ecx, esp
        mov edx, 1
        int 0x80
        pop eax
    
        ; Exit
        mov eax, 1
        xor ebx, ebx
        int 0x80
    
    section .data
        msg1 db "Original code", 10
        len1 equ $ - msg1
        msg2 db "Modified code", 10
        len2 equ $ - msg2

记住有关自修改代码的所有正常警告适用（它很危险，不安全，可能会烧毁你的房子......）

编辑：这个答案的先前版本说我们需要 1 字节对齐才能访问指令的任何部分。这是不正确的；该代码似乎适用于对齐值 1 和 16。

Answer 9

我从未编写过自修改代码，尽管我对它的工作原理有基本的了解。基本上，您在内存中写入要执行的指令，然后跳转到那里。处理器解释您编写的指令的那些字节并（尝试）执行它们。例如，病毒和反复制程序可能会使用此技术。
关于系统调用，你是对的，参数是通过寄存器传递的。有关 Linux 系统调用及其参数的参考，请查看此处。