Disassemblando x86 em Go

Comecei a estudar a linguagem Go há alguns dias e fiquei muito impressionado com seus recursos. A facilidade para programação paralela, o fato de ter ponteiros, funções que retornam mais de um valor, código enxuto (se você declarar uma variável e não usar, o programa nem compila!) e outros realmente me encantaram.

Recentemente precisei disassemblar um trecho de código de um binário PE para um projeto que está escrito em Go. Vi que existem algumas bibliotecas prontas para serem usadas, como gapstone (bindings da Capstone) e go-zydis (bindings da Zydis) mas não encontrei uma nativa.

No entanto, vi que existe uma ferramenta nativa no toolset da linguagem similar ao objdump do GNU binutils:

$ go doc cmd/objdump
Objdump disassembles executable files.

Usage:

    go tool objdump [-s symregexp] binary

Objdump prints a disassembly of all text symbols (code) in the binary. If
the -s option is present, objdump only disassembles symbols with names
matching the regular expression.

Compilei um "hello, world" em Go só pra ver:

~/hello $ cat main.go
package main

import "fmt"

func main() {
	fmt.Println("menteb.in")
}

~/hello $ go build

E de fato o objdump da Go funciona:

~/hello $ go tool objdump hello | head
TEXT go.buildid(SB)
  :-134217728		0x1001000		ff20			JMP 0(AX)
  :-134217728		0x1001002		476f			OUTSD DS:0(SI), DX
  :-134217728		0x1001004		206275			ANDB AH, 0x75(DX)
  :-134217728		0x1001007		696c642049443a20	IMULL $0x203a4449, 0x20(SP), BP
  :-1			0x100100f		226d35			ANDB 0x35(BP), CH
  :-1			0x1001012		4c6f			OUTSD DS:0(SI), DX
  :-1			0x1001014		6a52			PUSHL $0x52
  :-1			0x1001016		436e			OUTSB DS:0(SI), DX
  :-1			0x1001018		4a31794f		XORQ DI, 0x4f(CX)

Mas ao tentar com o um PE compilado pra 64-bits, descobri que só funciona com binários feito em Go. ?

$ go tool objdump putty.exe
objdump: disassemble putty.exe: no runtime.pclntab symbol found

De qualquer forma, resolvi olhar o código-fonte deste objdump interno da linguagem pra ver qual é dessa mandinga.  Na linha 43 do main.go do objdump tem um import pra uma biblioteca chamada objfile. Pensei: Wow, deve ser uma biblioteca de disassembly, talvez eu possa alterar ! E na hora já criei um projeto tentando usá-la mas fui surpreendido com um errão! kkkk

~hello $ cat main.go
package main

import "fmt"
import "cmd/internal/objfile"

func main() {
	fmt.Println("menteb.in")
}

~hello $ go build
main.go:4:8: use of internal package cmd/internal/objfile not allowed

Não pesquisei muito sobre essa história sobre eu não poder usar um pacote interno (por quê o objdump pode e eu não posso?!), mas fui olhar esta objfile e terminei encontrando seu fonte. Para minha alegria, neste arquivos disasm.go vi os seguintes imports:

"golang.org/x/arch/arm/armasm"
"golang.org/x/arch/arm64/arm64asm"
"golang.org/x/arch/ppc64/ppc64asm"
"golang.org/x/arch/x86/x86asm"

Agora sim, carái! É tudo público e posso usar. Desculpe o desabafo.. hehe o artigo na verdade começa aqui mas quis contar como cheguei porque né. ?

Cada uma dessas bibliotecas possui uma função Decode() justamente pra decodificar uma instrução (tipo Inst). Testei com um NOP em 64-bits, só pra ver:

package main

import (
	"fmt"
	"log"

	"golang.org/x/arch/x86/x86asm"
)

func main() {
	dados := []byte{0x90}

	ins, err := x86asm.Decode(dados, 64)

	if err != nil {
		log.Fatalln(err)
	}

	fmt.Println(ins)
}

A saída foi exatamente a esperada:

$ ./hello
NOP

Show. Agora é abrir um PE, ler de onde quero e daí disassemblar usado essa x86asm.Decode() num loop, mas vou deixar esse exercício aí pra quem quiser treinar Go. Ou se acharem útil posso postar um aqui mais tarde. Aqui já funcionou mas precisa de uma polida. ?

Perceba também que há bibliotecas para ARM e PowerPC. Achei bem maneiro. Talvez em breve o time da Go adicione suporte a mais arquiteturas. Amém! ?