[函数调用]

Author: zhaozhengcoder

example_code/function/test.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+int MyFunction(int x, int y);
+int MyFunctionNew(int x, int y);
+
+char new_func[] = 
+{
+   0x55,
+   0x48, 0x89, 0xe5, 
+   0x89, 0x7d, 0xec, 
+   0x89, 0x75, 0xe8, 
+
+   0xc7, 0x45, 0xfc, 0x0a, 0x00, 0x00, 0x00,
+
+   0xc7, 0x45, 0xf8, 0x01, 0x00, 0x00, 0x00, 
+
+   0x8b, 0x45, 0xfc, 
+   0x5d, 
+   0xc3  
+};
+
+void sig_user1_handler(int sig, siginfo_t *si, void *data)
+{
+    int pagesize = sysconf(_SC_PAGE_SIZE);
+    if (pagesize < 0) {
+        pagesize = 4096;
+    }
+
+    int len = sizeof(new_func);
+
+    uintptr_t addr = (((uintptr_t)MyFunction) / pagesize) * pagesize;
+    fprintf(stderr, "%s: iminus: %p, aligned: 0x%lx, sz %d\n", __func__, MyFunction, addr, len);
+    if (mprotect((void*)addr, (uintptr_t)MyFunction - addr + len, PROT_WRITE|PROT_READ|PROT_EXEC) < 0) {
+        fprintf(stderr, "%s\n", strerror(errno));
+    }
+
+    memcpy((void*)MyFunction, (void*)new_func, len);
+
+    if (mprotect((void*)addr, (uintptr_t)MyFunction - addr + len, PROT_READ|PROT_EXEC) < 0) {
+        fprintf(stderr, "%s\n", strerror(errno));
+    }
+}
+
+int MyFunction(int x, int y)
+{
+    int a, b;
+    a = 10;
+    b = 1;
+
+    int val = a * x + b * y;
+    return val;
+}
+
+int MyFunctionNew(int x, int y)
+{
+    int a = 10;
+    return a;
+}
+
+int main()
+{ 
+    struct sigaction newact, oldact;
+    sigemptyset(&newact.sa_mask);
+    newact.sa_sigaction = sig_user1_handler;
+    sigaction(SIGUSR1, &newact, &oldact);
+
+    void * ptr = &MyFunction;
+    printf("addr %p , sizeof %d\n", ptr, sizeof(new_func));
+
+    int a = 10;
+    int b = 10;
+
+    while (1)
+    {
+        int val = MyFunction(a, b);
+        printf("val : %d \n", val);
+        sleep(3);
+    }
+    return 0;
+}

example_code/function/test_asm.c

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+ 
+void function()
+{
+    while(1)
+    {
+	    printf("hello,function!\n");
+        sleep(1);
+    }
+}
+ 
+void test()
+{
+    int val = 10;
+    printf("val %d\n", val);
+    
+    // set val = 11
+    asm("movl $0xb, -0x4(%rbp)");
+    printf("val %d\n", val);
+    
+    long addr = function;
+    asm("movl $0x401156, 0x18(%rbp)");
+}
+ 
+int main()
+{
+    printf("addr %p \n", &function);
+	test();
+	printf("hello,world!\n");
+	return 0;
+}
+
+// https://blog.csdn.net/yiftss/article/details/89474622

example_code/function/test_jmp.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+jmp_buf env;
+
+int my_func(int a, int b) 
+{
+    if (b == 0) {
+        printf("do not allow division by 0\n");
+        longjmp(env, 1);
+    }
+    return a / b;
+}
+
+int main(int argc, char const *argv[]) 
+{
+    int res = setjmp(env);
+    if (res == 0) {
+        printf("return from setjmp\n");
+        my_func(10, 0);
+    } else {
+        printf("return from longjmp: %d\n", res);
+    }
+    return 0;
+}

note/函数调用过程.md

@@ -25,22 +25,175 @@
 
 * c调用汇编的代码
 
-    todo
+    在c语言中，使用asm可以调用汇编:
+    ```
+    void function();
+
+    void test()
+    {
+        int val = 10;
+        printf("val %d\n", val);
+        
+        // set val = 11
+        asm("movl $0xb, -0x4(%rbp)");
+        printf("val %d\n", val);
+        
+        long addr = function;
+        asm("movl $0x401156, 0x18(%rbp)");
+    }
+    ```
+
+    完成代码：
+
+    [example_code](../example_code/function/test_asm.c)
 
 ## 函数栈切换
 
 搞明白函数的调用过程，可以进一步去思考如何去进行函数切换。
 
 1. 思路1：堆栈溢出攻击
 
-    覆盖返回地址，实现函数跳转
+    覆盖返回地址，实现函数跳转。
+    ```
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <unistd.h>
+    #include <unistd.h>
+
+    void fun() 
+    {
+        while(1) 
+        {
+            printf("Hello, I'm fun!\n");
+            sleep(1);
+        }
+    }
+
+    int foo2()
+    {
+        long a[5] = { 0 };
+    
+        // 溢出攻击
+        a[9] = fun;                 // 覆盖返回地址  // 为什么是a[9] 尝试不同的移动偏移去覆盖rbp的上一条地址 (不同的机器可能不太一样)
+    }
+
+    int main() 
+    {
+        printf("main \n");
+        foo2();
+        return 0;
+    }
+    ```
+
 
 2. 思路2：覆盖函数的地址的汇编代码，实现函数跳转
 
+    ```
+    void fun() 
+    {
+        while(1) 
+        {
+            printf("Hello, I'm fun!\n");
+            sleep(1);
+        }
+    }
+
+    int foo()
+    {
+        int a[5] = { 0 };
+    
+        // 溢出攻击
+        asm("mov $0x401136,%eax");    // 0x401136 是fun的入口地址
+        asm("mov %rax,0x18(%rbp)");
+    }
+    ```
+
+    fun的地址可以通过查看汇编代码找到：
+    ![](../pic/函数调用3.png)
+
+    执行结果：
+    ![](../pic/函数调用4.png)
+
 3. 思路3：覆盖函数的地址首部，插入跳转到其他函数的汇编代码，实现函数跳转
 
+    如果想要从函数a调到函数b，可以把函数b的栈copy覆盖过去。
+
+    ```
+    // 希望跳转到的函数
+    (gdb) disas/rs MyFunctionNew
+    Dump of assembler code for function MyFunctionNew:
+    0x0000000000401334 <+0>:     55      push   %rbp
+    0x0000000000401335 <+1>:     48 89 e5        mov    %rsp,%rbp
+    0x0000000000401338 <+4>:     89 7d ec        mov    %edi,-0x14(%rbp)
+    0x000000000040133b <+7>:     89 75 e8        mov    %esi,-0x18(%rbp)
+    0x000000000040133e <+10>:    c7 45 fc 0a 00 00 00    movl   $0xa,-0x4(%rbp)
+    0x0000000000401345 <+17>:    8b 45 fc        mov    -0x4(%rbp),%eax
+    0x0000000000401348 <+20>:    5d      pop    %rbp
+    0x0000000000401349 <+21>:    c3      retq   
+    End of assembler dump.
+    ```
+
+
+    ```
+    // 希望跳转到的函数的对应的汇编代码
+    char new_func[] = 
+    {
+    0x55,
+    0x48, 0x89, 0xe5, 
+    0x89, 0x7d, 0xec, 
+    0x89, 0x75, 0xe8, 
+
+    0xc7, 0x45, 0xfc, 0x0a, 0x00, 0x00, 0x00,
+
+    0xc7, 0x45, 0xf8, 0x01, 0x00, 0x00, 0x00, 
+
+    0x8b, 0x45, 0xfc, 
+    0x5d, 
+    0xc3  
+    };
+    ```
+
+    ```
+    // 用新的代码去覆盖旧的函数的代码
+    int len = sizeof(new_func);
+    memcpy((void*)MyFunction, (void*)new_func, len);
+    ```
+
+    完成代码：
+
+    [example_code](../example_code/function/test.c)
+
 4. set/jump的方案
 
+    ```
+    jmp_buf env;
+
+    int my_func(int a, int b) 
+    {
+        if (b == 0) {
+            printf("do not allow division by 0\n");
+            longjmp(env, 1);
+        }
+        return a / b;
+    }
+
+    int main(int argc, char const *argv[]) 
+    {
+        int res = setjmp(env);
+        if (res == 0) {
+            printf("return from setjmp\n");
+            my_func(10, 0);
+        } else {
+            printf("return from longjmp: %d\n", res);
+        }
+        return 0;
+    }
+    ```
+
+    完成代码：
+
+    [example_code](../example_code/function/test_jmp.c)
+
 ## 协程的基本原理
 
 核心 ：
@@ -54,7 +207,7 @@ libco 上下文切换的思路
 
 2. libco hook 系统函数的思路
 
-3. 
 
 ## 热更新的基本原理
-todo
+
+    todo