Go 语言的特性与逆向难点

Go 语言是一种强类型检查的编译型语言,接近 C 但拥有原生的包管理、内建的网络包、协程等特性,使其成为一款开发效率更高的工程级语言。作为编译型语言它有开发速度快的优点,但是它又能通过内置的运行时符号信息实现反射这种动态特性。Go 语言作为一种内存安全的语言,它不仅有内建的垃圾回收,还在编译与运行时提供了大量的安全检查。

Go 通常使用静态链接程序,所以它会直接将库打包链接进来,因此程序体积会比较大。而且第三方库、标准库与用户代码混在一起,需要区分。在分析 Go 语言编写的二进制程序前,需要弄清楚某一操作是发生在编译期间还是运行期间,能在编译时做的事就在编译时做,这能实现错误前移并提高运行效率等,而为了语言的灵活性引入的某些功能又必须在运行时才能确定。

例如下面这段代码:

func main(){
    s:=[...]string{"hello","world"}
    fmt.Printf("%s %s\n",s[0],s[1])
}

在第二行定义了一个字符串数组,第三行将其输出,编译阶段就能确定元素访问的指令以及下标访问是否越界,于是就可以去除 s 的类型信息。但是由于 Printf 的输入是 interface{} 类型,因此在编译时它无法得知传入的数据实际为什么类型。但是作为一个输出函数,希望传入数字时直接输出,传入数组时遍历输出每个元素,那么在传入参数时,就需要在编译时把实际参数的类型与参数绑定后再传入 Printf,在运行时它就能根据参数绑定的信息确定是什么类型了。

其实在编译时,编译器做的事还很多,从逆向看只需要注意它会将很多操作转换为 runtime 的内建函数调用。例如字符串拼接

a:="123"
s:="abc"+a+"cba"

将被转换为 concatstring3 函数调用

若需要观察某语法最终生成的汇编代码,除了使用 IDA 还可以使用 Go 自带的工具

 go tool compile -N -l -S demo.go

Go 语言的编译命令是

 go build demo.go

如果需要禁止优化可以使用

go build -gcflags="-N -l" demo.go

如果需要去掉调试信息和符号可以使用

go build -ldflags="-w -s" demo.go

在逆向分析时,如果程序保留了符号信息,分析起来会容易很多,但是如果符号信息被去除,就需要通过其他方法来恢复符号信息。

Go 语言的数据类型

Go 语言的基本数据类型在不同位数的系统上占用的空间可能不同,下表列出了常见数据类型在 32 位和 64 位系统上的大小:

类型

32位

64位

bool、int8、uint8

8bit

8bit

int16、uint16

16bit

16bit

int32、uint32、float32

32bit

32bit

int64、uint64、float64、complex64

64bit

64bit

int、uint、uintptr

32bit

64bit

complex128

128bit

128bit

需要注意的是 int、uint、uintptr 类型的大小是平台相关的,在 32 位系统上是 32 位,在 64 位系统上是 64 位。在逆向分析时,需要根据程序的位数来判断这些类型的实际大小。

Go 语言的数据结构

string 字符串

传统的 C 是通过 \0 结束符来表示字符串结束位置,而 Go 语言则不同它通过存储字符串长度来确定字符串结束位置。在 Go 中声明字符串是声明了一个字符串对象,一个字符串对象结构在内存中分为两部分,结构中使用两个字段存储字符串信息,分别存储字符串指针以及字符串长度。

type StringHeader struct{
    Data uintptr // 字符串首地址
    Len int      // 字符串长度
}

字符串的大小由存储字符串长度的字段决定,程序通过访问字符串指针字段来使用字符串。在逆向中重点关注的是如上结构,因此说一个 string 对象占两个字长,其它结构也按这种约定。例如输出一个字符串,它会将上述结构入栈,由于没有终止符 IDA 无法正常识别字符串结束符因此输出了很多信息,我们需要依靠它的第二个域决定它的结束位置。

字符串的常见操作是字符串拼接,若拼接的字符串个数不超过 5,则调用 concatstringN,否则会调用 concatstrings,函数声明如下,可见在多个字符串拼接时参数形式不同:

func concatstring2(*[32]byte,string,string)string
func concatstring3(*[32]byte,string,string,string)string
func concatstring4(*[32]byte,string,string,string,string)string
func concatstring5(*[32]byte,string,string,string,string,string)string
func concatstrings(*[32]byte,[]string)string

因此在遇到 concatstringN 时可以跳过第一个参数,随后入栈的参数即为字符串,而遇到 concatstrings 时,跳过第一个参数后汇编层面还剩三个参数,其中后两个一般相同且指明字符串个数,第一个参数则指明字符串数组的首地址。

array 数组

类似 C 把字符串看作 char 数组,array 和 string 的结构类似,其真实数据也是在内存里连续存放,而使用如下结构索引数据,对数组里的元素访问其地址偏移在编译时就能确定,总之逆向角度看它也是占两个字长:

type arrayHeader struct{
    Data uintptr // 首元素地址
    Len int      // 数组长度
}

数组有三种存储位置,当数组内元素较少时可以直接存于栈上,较多时存于数据区,而当数据会被返回时会存于堆上。如下定义了三个局部变量,但是它们将在底层表现出不同的形态:

func Getarray() *[3]int {
    a:=[...]int{1,2,3}
    b:=[...]int{1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9}
    c:=[...]int{1,2,3}
    if len(a)<len(b){
        return &c
    }
    return nil
}

变量 a 直接在栈上定义并初始化

变量 b 的初始值被定义在了数据段,其中数据拷贝函数若符号信息完整遇到无法识别出的函数一般也就是数据拷贝函数。变量 c 尽管它和 a 的值一样,但是 Go 作为内存安全的语言,其通过 runtime.newobject 在堆上申请空间来释放该对象,返回的是新的对象指针。golang 的返回值通过栈传递。

slice 切片

类似数组,切片的实例对象数据结构如下,可知它占用了三个字长,与它相关的函数是 growslice,表示扩容,逆向时可忽略:

type SliceHeader struct {
    Data uintptr // 数据指针
    Len  int     // 当前长度
    Cap  int     // 可容纳的长度
}

更常见的函数是与字符串相关的转换,它们在底层调用的是如下函数,此处我们依然不必关注第一个参数:

func slicebytetostring(buf*[32]byte, ptr *byte, n int) string
func stringtoslicebyte(*[32]byte, string) []byte

例如下面的代码:

func main(){
    var a string = "hello world"
    var b []byte = []byte(a)
}

在汇编层面会调用 stringtoslicebyte 函数将字符串转换为字节切片。

map 字典

字典实现比较复杂,不过在逆向中会涉及到的内容很简单,字典操作常见的会转换为如下函数:

func fastrand() uint32
func makemap(mapType *byte, hint int, mapbuf *any) (hmap map[any]any)
func mapaccess1(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapaccess2(mapType *byte, hmap map[any]any, key *any) (val *any, pres bool)
func mapassign(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapiterinit(mapType *byte, hmap map[any]any, hiter *any)
func mapiternext(hiter *any)
  • 创建:一般fastrand和makemap连用返回一个map指针。
  • 读取:读字典时使用mapaccess1和mapaccess2。
  • 写入:写字典时会使用mapassign函数,它返回一个地址,将value写入该地址。

另外比较常见的是对字典进行遍历,会使用mapiterinit和mapiternext配合。

事实上更常见的是上面这些函数的同类函数,它们的后缀代表了对特定类型的优化。

例如下面的代码:

package main

import "fmt"

func main(){
    a := map[string]int{
        "id":1,
        "age":32,
    }
    a["age"] = 19
    fmt.Println(a["id"])
}

在汇编层面会调用 makemap 创建字典,调用 mapassign 写入键值对,调用 mapaccess1 读取值。

struct 结构体

类似 C 语言,Go 的结构体也是由其它类型组成的复合结构,它里面域的顺序也是定义的顺序,里面的数据对齐规则和 C 一致不过我们可以直接从其类型信息获得,不必自己算。在分析结构体变量时必须要了解结构体的类型结构了,其定义如下:

type rtype struct{
    size      uintptr  // 该类型对象实例的大小
    ptrdata   uintptr  // rtype 可以包含指针的字节数
    hash      uint32   // rtype 哈希值
    tflag     tflag    // 额外的类型信息标识
    align     uint8    // 当前具体类型变量的内存对齐
    kind      uint8    // 具体 kind 的枚举值
    alg       *typeAlg // 算法表
    gcdata    *byte    // 垃圾回收数据
    str       nameoff  // 字符串格式
    ptrToThis typeoff  // 指向该类型的指针
}

结构体的字段信息定义如下:

type structField struct {
    name        name    // 属性名称
    typ         *rtype  // 该域的类型
    offsetEmbed uintptr // offsetEmbed>>1 得到该属性在对象中的偏移
}

结构体类型信息定义如下:

type structType struct {
    typ     _type
    pkgPath name           // 包名
    fields  []structField  // 域数组
}
type uncommonType struct{
    pkgPath nameoff //包路径
    mcount  uint16  //方法数
    xcount  uint16  //导出的方法数
    moff    uint32  //方法数组的偏移
    -       uint32  //unused
}
type structTypeUncommon struct {
    structType
    u uncommonType
}

在逆向分析时,我们可以通过类型信息来恢复结构体的定义,这对于理解程序的数据结构非常有帮助。

Go 语言的语法特性

新建对象

Go 不是面向对象的语言,此处将 Go 的变量当作对象来描述。动态创建时会在堆区创建对象,这里涉及 make 和 new 两个关键词,不过在汇编层面它们分别对应着 makechan、makemap、makeslice 与 newobject。如 makeslice,它的定义如下:

func makeslice(et *_type,len,cap int) unsafe.Pointer

例如下面的代码:

package main

import "fmt"

func main(){
    a := make([]uint8,5,10)
}

调用 make([]uint8,5,10) 创建一个 slice 后,会在汇编层面调用 makeslice 函数,传入类型信息、长度和容量三个参数。

函数与方法

Go 语言的栈可以分为两个区域,在栈底部存放局部变量,栈顶部做函数调用相关的参数与返回值传递。因此在分析时不能对顶部的 var 命名,因为它不特指某具体变量而是随时在变化的,错误的命名容易造成混淆。如果某个栈变量距离栈顶很远,那么很大概率是局部变量可重命名,而如果距栈顶很近,很大概率是用于传参的,不要重命名。

Go 语言支持可变参数,类似 Python 的一般变参实际被转化为一个 tuple,Go 变参也被转换为了一个 slice。因此一个变参在汇编级别占 3 个参数位,如下代码:

func VarArgDemo(args ...int)(sum int){}

func main(){
    VarArgDemo(1,2,3)
}

在汇编层面会先创建一个 slice,然后将参数放入 slice,最后将 slice 的三个字段(指针、长度、容量)作为参数传递。

Go 可以为任意自定义类型绑定方法,方法将会被转换为普通函数,并且将方法的接收者转化为第一个参数。例如下面的代码:

package main

import "fmt"

type demo struct {
    size int
    data int
}

func (d *demo) len() int {
    return d.size
}

func main() {
    d := &demo{size: 10, data: 100}
    fmt.Println("Size of demo:", d.len())
}

在逆向时工具会将其解析为 类型名__方法名 或 类型名_方法名,因此遇到此类名称时我们需要注意它的第一个参数是隐含参数,类似 C++ 的 this 指针,但 Go 的方法定义不仅支持传引用,也支持传值,因此第一个参数可能在汇编层面不只占一个机器字。

package main

import "fmt"

type Person struct {
    name   string
    age    int
    weight uint16
    height uint16
}

func (p Person) Print() {
    fmt.Printf("%t\n", p)
}

func (p *Person) PPrint() {
    fmt.Printf("%t\n", p)
}

func main() {
    lihua := Person{
        name:   "lihua",
        age:    18,
        weight: 60,
        height: 170,
    }
    lihua.Print()
    lihua.PPrint()
}

伸缩栈

由于 Go 可以拥有大量的协程,若使用固定大小的栈将会造成内存空间浪费,因此它使用伸缩栈。初始时一个普通协程只分配几 kb 的栈,并在函数执行前先判断栈空间是否足够,若不够则通过一些方式扩展栈
这在汇编上的表现形式是在函数开头会调用
runtime.morestack* 函数扩展栈后会重新进入函数,因此在分析时直接忽略这个分支即可。

调用约定

Go 统一通过栈传递参数和返回值(较新版本可能通过寄存器),这些空间由调用者维护,返回值内存会在调用者前选择性的被初始化。参数传递是从左到右顺序,在内存中从下到上写入栈,因此看到 mov [rsp+0xXX+var_xx], reg 时就代表开始为函数调用准备参数了,继续向下就能确定函数的参数个数及内容。从此处到 call 指令前都是传参,call 指令之后为返回值,不过可能存在返回值未使用的情况,因此返回值的个数和含义需要从函数内部分析,即分析函数 retn 指令前的指令来确定返回值大小。

写屏障

Go 拥有垃圾回收机制,其三色标记使用了写屏障的方法保证一致性,在垃圾收集过程中会将写屏障标志置位,此时会进入另一条逻辑,但是我们在逆向过程中可以认为该位未置位而直接分析无保护的情况。在汇编中会看到 runtime.gcWriteBarrier 相关的代码,先判断标志,再决定是否进入,在分析时可以直接认为其永假并走左侧分支。

协程

在代码中使用 go 关键词可以创建并运行协程,它在汇编上会被表现为 runtime.newproc(fn,args?),它会封装函数与参数并创建协程执行信息,并在适当时候被执行。由于没有参数此处 newproc 只被传入了函数指针这一个参数,否则会继续传入函数所需的参数,在分析时直接将函数作为在新的线程里执行即可。

defer 延迟执行

defer 语句用于延迟函数的执行,往往用于资源释放。在汇编层面会调用 runtime.deferproc 注册延迟函数,在函数返回前会调用 runtime.deferreturn 执行所有延迟函数。在逆向分析时需要注意 defer 语句的执行顺序是后进先出的,即最后注册的 defer 最先执行。

Go 语言逆向实战

总结一下,Go 语言逆向的难点主要分为三点:独特而复杂的数据类型、独特的调用约定和栈结构以及多返回值机制、全静态链接构建。尽管是编译型语言,Go 仍然提供了一定的动态能力,这主要表现在接口与反射上,而这些能力离不开类型系统,它需要保留必要的类型定义以及对象和类型之间的关联,这部分内容无法在二进制文件中被去除,否则会影响程序运行,因此在 Go 逆向时能获取到大量的符号信息,大大简化了逆向的难度,对此类信息已有许多优秀的工具可供使用,例如 go_parser 与 redress。

import idaapi
import idc

def scan_strings(start,end):
    r=[]
    for i in range(start,end,16):
        addr=idaapi.get_qword(i)
        size=idaapi.get_qword(i+8)
        print(hex(size))
        if size>100:
            break
        s=idc.get_bytes(addr,size)
        r.append((i,s))
    return r
strings=scan_strings(0x1c16990,0x01c19430)
f=open("strings.txt","w")
for i,s in strings:
    f.write("%x:%s\n"%(i,s))
f.close()

符号还原

go_parser 是一个用于 IDA Pro 的 Go 语言符号恢复工具

go_praser符号恢复工具:0xjiayu/go_parser: Yet Another Golang binary parser for IDAPro

这个工具可以从 Go 二进制文件中提取出函数名、类型信息、字符串常量等符号信息,然后在 IDA 中为函数重命名、添加注释、恢复字符串等。使用方法很简单,用 IDA 打开 Go 程序后,运行 go_parser 脚本即可自动恢复符号信息。

另一个常用的工具是 redress,它是一个命令行工具,可以分析 Go 二进制文件并输出详细的符号信息。使用命令 redress -s <binary> 可以列出所有的符号,使用 redress -t <binary> 可以列出所有的类型信息。这些工具大大简化了 Go 语言的逆向分析,使得我们可以像分析带符号的程序一样分析 Go 程序。

实战案例:2024羊城杯 pic

这是一道典型的 Go 语言逆向题目,我们拿到附件有一个 pic.exe 文件和一个 flag.png 文件,flag.png 文件应该是加密后的 flag 文件。运行程序,要求我们输入密钥。使用 IDA 反编译分析,通过字符串定位到关键函数。

根据程序中的 "Input your key:" 字符串可以定位到输入处理的代码,这里 off_4DD470 变量就是输入字符串,我们将它重命名

根据下面的 "flag.png" 字样可以判断,程序应该是对 flag 文件进行加密或解密。这里可以猜测 p_string 变量是接收输入密钥的变量,我们根据逻辑重命名代码。

可以看到密钥在几个变量间传递,并且限制密钥的长度为 5,否则便退出。

下面我们观察函数表,发现很明显的反调试函数,以及 KeySize 和 NewCipher 的加密相关函数。

我们首先分析加密相关的函数,根据 main_KeySizeError_Error 函数,我们可以判断程序使用的是 RC4 加密算法。

这里程序要求我们输入密钥,但是我们完全不知道密钥。但是我们知道密钥的长度是 5,所以我们可以采取爆破的方法。这里我们加密的 flag 是一个 png 文件,所以我们可以知道 png 未被加密前的文件头是 89 50 4E 47,然后通过爆破加密直到加密后的文件头与我们 flag.png 的文件头相等。

编写爆破脚本:

def rc4(enc,key):    
  s=[]    
  for i in range(256):        
    s.append(i)    
  t=[]    
  for i in range(256):        
    t.append(ord(key[i%len(key)]))    
  j=0    
  for i in range(256):        
    j=(j+s[i]+t[i])%256        
    s[i],s[j]=s[j],s[i]    
  i=0    
  j=0    
  result=[]    
  for k in range(len(enc)):        
    i=(i+1)%256        
    j=(j+s[i])%256        
    s[i], s[j] = s[j], s[i]        
    x=(s[i]+s[j])%256        
    result.append(enc[k]^s[x]^ord(key[1])^17)
return result
for i in tqdm(product(Map,repeat=5)):    
  key = "".join(list(i))    
  enc = [0x85,0x43,0x72,0x78]    
  flag=rc4(enc,key)    
  if flag==[137, 80, 78, 71]:        
    print(key)        
    exit()

运行脚本爆破出密钥后,使用密钥解密 flag.png 文件即可得到原始的 flag 图片。这道题目展示了 Go 语言逆向的完整流程:识别 Go 程序、使用 IDA 分析、定位关键函数、分析加密算法、编写脚本爆破或解密。虽然 Go 语言的逆向相比 C# 要困难一些,但是通过符号恢复工具和对 Go 语言特性的理解,我们仍然可以有效地分析 Go 程序。

Go 语言逆向的技巧总结

在实际的 Go 语言逆向中,有一些技巧可以帮助我们更高效地分析程序。首先是充分利用符号信息,Go 程序即使去除了符号表,仍然会保留大量的类型信息和字符串常量,我们可以通过 go_parser 等工具恢复这些信息。其次是熟悉 Go 语言的标准库和常用函数,比如 fmt.Printf、os.Open、io.ReadFile 等,这些函数在逆向中经常遇到,熟悉它们的功能和参数可以帮助我们快速理解程序逻辑。

再次是注意 Go 语言的调用约定,Go 语言通过栈传递参数和返回值,而且支持多返回值,这和 C/C++ 的调用约定不同,需要特别注意。最后是善用动态分析,对于一些复杂的加密算法或者混淆代码,静态分析可能会遇到困难,这时候可以使用调试器动态跟踪程序的执行流程,观察变量的值和函数的调用关系,往往能更快地找到突破口。

总结

本文详细介绍了 Go 语言逆向的基础知识和实战技巧,包括 Go 语言的特性、数据类型、数据结构、语法特性、符号恢复工具的使用,以及通过实际的 CTF 题目演示了完整的逆向流程。Go 语言逆向相比传统的 C/C++ 逆向有一些独特的地方,比如独特的数据结构、调用约定、运行时机制等,但是通过对 Go 语言特性的理解和符号恢复工具的使用,我们仍然可以有效地分析 Go 程序。随着 Go 语言的普及,Go 语言逆向将成为一个越来越重要的技能