程序的自我改写

曾经，程序的自动改写是每个黑客必备的知识，因为这样可以有效的节约内存，下面是在现代的GNU/Linux 操作系统上实现的程序自我改写。
列一下环境：
speller@SHELL-LAB:~/code/c$ egrep "model name" /proc/cpuinfo | uniq -c
      2 model name      : Pentium(R) Dual-Core  CPU      E6300  @ 2.80GHz
speller@SHELL-LAB:~/code/c$ uname -sr
Linux 2.6.35.10-smp
speller@SHELL-LAB:~/code/c$ gcc --version | grep GCC
gcc (GCC) 4.4.4
speller@SHELL-LAB:~/code/c$

上代码：

1. /*
   
2.  * 文件名: self-modification.c
   
3.  * 备注: 一个可以修改自身代码的小程序 ;p
   
4.  */
   
5. #include <stdio.h>
   
6. #include <unistd.h>
   
7. #include <sys/mman.h>
   
8. 
   
9. void func (void);
   
10. 
    
11. int main
    
12. (int argc, char *argv[]) {
    
13.     
    
14.     int count = 0;
15. 
    
16.     for (count = 0; count < 3; ++count) {
    
17.         printf ("第<%d>次执行函数func:\n", count+1);
    
18.         func ();
    
19.     }
    
20. 
    
21.     return 0;
    
22. }
    
23. 
    
24. void func
    
25. (void) {
    
26. 
    
27.     __asm__ __volatile__ (
    
28.         "slot:\n"
    
29.         "nop\nnop\n" /* 这两个nop 指令用来为下面的自动改写留出位置 */
    
30.         "after_slot:\n"
    
31.     );
    
32. 
    
33.     puts ("\t你只能在第<1>次执行函数func 的时候看到这条消息\n"
    
34.           "\t\t——因为程序对自身的代码进行了修改。\n");
    
35.     
    
36.     /* 将函数func 的堆栈属性设置为可读写、可执行 */
    
37.     int pagesize = (int)sysconf (_SC_PAGESIZE);
    
38.     char *p = (char *)((int)func & ~(pagesize - 1));
    
39.     mprotect (p, pagesize * 10, PROT_READ | PROT_WRITE | PROT_EXEC);
    
40.     
    
41.     /* 进行自我改写 */
    
42.     __asm__ __volatile__ (
    
43.         ".byte 0xe8, 0, 0, 0, 0\n"     /* 0xe8 是call 指令，把popl 指令当作函数调用 */
    
44.         "popl %%eax\n"                /* popl 出栈的是popl 指令自身的地址 */
    
45.         "addl $20, %%eax\n"         /* 定位到第二个puts 函数 */
    
46.         "subl $after_slot, %%eax\n"/* 得到第二个puts 函数相对于after_slot 标签的偏移 */
    
47.         "shl $8, %%eax\n"             /* 这里是little endian 系统 */
    
48.         "movb $0xeb, %%al\n"      /* 0xeb 是jmp 指令，%ax 里现在是 <jmp 偏移 >*/
    
49.         "movw %%ax, slot"           /* 填充先前两个nop 指令预留出的空间 */
    
50.         :
    
51.         :
    
52.         : "eax"
    
53.     );
54. 
    
55.     puts ("\t这条消息应该在每次调用函数func 的时候都被输出到stdout。\n");
    
56.     
    
57.     return;
    
58. }

效果如下：
speller@SHELL-LAB:~/code/c$ gcc -o self-modification self-modification.c
speller@SHELL-LAB:~/code/c$ ./self-modification
第<1>次执行函数func:
        你只能在第<1>次执行函数func 的时候看到这条消息
                ——因为程序对自身的代码进行了修改。

        这条消息应该在每次调用函数func 的时候都被输出到stdout。

第<2>次执行函数func:
        这条消息应该在每次调用函数func 的时候都被输出到stdout。

第<3>次执行函数func:
        这条消息应该在每次调用函数func 的时候都被输出到stdout。

speller@SHELL-LAB:~/code/c$

程序自身对自身的指令进行修改，有点黑客帝国的味道，不是么 ;p