go 函数调用规则（一）

最新推荐文章于 2023-12-04 12:27:53 发布

yongbaoii

最新推荐文章于 2023-12-04 12:27:53 发布

阅读量1k

点赞数 2

分类专栏： CTF 文章标签：网络安全

本文链接：https://blog.csdn.net/yongbaoii/article/details/123744401

版权

CTF 专栏收录该内容

213 篇文章 16 订阅

订阅专栏

go逆向首先了解他的函数调用规则。

环境搭建在go 环境搭建

代码这样

package main

func val(c, d int) (a int, b int) {
	e := 5
	f := 6
	a = c + d + e + f
	b = d * 2
	return
}

func test() {
	i, j := val(1, 2)
	i = i + 3
	j = j + 4
}

func main() {
	test()
}

然后编译成二进制文件

go build -gcflags "-N -l" 1.go

gcflags可以向go编译器传递参数。

-N参数代表禁止优化, -l参数代表禁止内联,
go在编译目标程序的时候会嵌入运行时(runtime)的二进制,
禁止优化和内联可以让运行时(runtime)中的函数变得更容易调试.

然后就好多了。

先看main函数的汇编

sub     rsp, 8
mov     [rsp+8+var_8], rbp
lea     rbp, [rsp+8+var_8]
call    main_test
mov     rbp, [rsp+8+var_8]
add     rsp, 8
nop
retn

显然我们看到因为main没有参数
就是把栈抬高八个字节
然后rbp放进去
然后放的这个地方是rbp新地址。

函数返回的时候正常返回就可以了。

单从这里来看
效果跟C语言函数调用的效果是一样的。
都是压一个rbp进去
只不过是具体的汇编不一样。

再来看test函数

sub     rsp, 38h                      #两个参数此时rsp指向main函数中call的时候压进去的返回地址
mov     [rsp+38h+var_8], rbp          #0x38的栈最下面八个字节是rbp
lea     rbp, [rsp+38h+var_8]
mov     eax, 1                        #两个参数乱入
mov     ebx, 2                    
xchg    ax, ax                        #xchg是交换，ax交换ax，啥也不干，cherest师傅说是废话文学
call    main_val                      #又把返回地址压进去之后先不看下面的先去看看val函数

                                      #经过下面的函数调用回来之后我们现在知道
                                      #开了0x38的栈  最下面8个字节是栈底
                                      #然后最上面两个是函数调用时候的传参
                                      #rax  rbx里面放着返回值
mov     [rsp+38h+var_10], rax         #把返回值放进临时变量i  j 
mov     [rsp+38h+var_18], rbx
mov     rcx, [rsp+38h+var_10]         #剩下的四个qword就是两个i  两个j
mov     [rsp+38h+var_20], rcx         #两个的目的是进行了i = i + 3这样的操作
mov     rcx, [rsp+38h+var_18]         #可能因为关了优化  导致有点空间上的浪费
mov     [rsp+38h+var_28], rcx         #但是并不影响我们研究函数的调用规则
mov     rcx, [rsp+38h+var_20]
add     rcx, 3
mov     [rsp+38h+var_20], rcx
mov     rcx, [rsp+38h+var_28]
add     rcx, 4
mov     [rsp+38h+var_28], rcx
mov     rbp, [rsp+38h+var_8]
add     rsp, 38h
retn                                 #最后返回

val

var_28= qword ptr -28h
var_20= qword ptr -20h
var_18= qword ptr -18h
var_10= qword ptr -10h
var_8= qword ptr -8
arg_0= qword ptr  8
arg_8= qword ptr  10h


sub     rsp, 28h                    #这个函数栈空间开了0x28
mov     [rsp+28h+var_8], rbp        #然后又是rbp放进去这个操作
lea     rbp, [rsp+28h+var_8]
mov     [rsp+28h+arg_0], rax        #rax是第一个参数 放在了返回地址下面第一个qword
mov     [rsp+28h+arg_8], rbx        #rbx是第二个参数 放在返回地址下面第二个qword
mov     [rsp+28h+var_10], 0         #这连着的四个显然就是两个返回值跟两个临时变量
mov     [rsp+28h+var_18], 0
mov     [rsp+28h+var_20], 5
mov     [rsp+28h+var_28], 6
mov     rcx, [rsp+28h+arg_0]        #这里就是做那个加法，都加在rcx里面
add     rcx, [rsp+28h+arg_8]        #参数就是用之前rax  rbx加进去的。
add     rcx, [rsp+28h+var_20]
add     rcx, 6
mov     [rsp+28h+var_10], rcx       #最后的结果放进返回值那里
mov     rbx, [rsp+28h+arg_8]
shl     rbx, 1                      
mov     [rsp+28h+var_18], rbx       #对临时变量b进行处理
mov     rax, [rsp+28h+var_10]       #然后rax  rbx又分别是两个返回值   rax是第一个返回值  rbx是第二个返回值
mov     rbp, [rsp+28h+var_8]
add     rsp, 28h
retn