r2gopclntabParser

Nota: Esta funcionalidade foi implementada diretamente no núcleo do radare2 como plugin de análise gopc

Um analisador gopclntab baseado em radare2 para recuperar símbolos de funções de binários Go, incluindo os totalmente despojados (stripped). Suporta binários ELF, Mach-O e PE nas versões Go 1.2, 1.16, 1.18 e 1.20+.

Todo binário Go 1.2+ incorpora uma região de dados chamada gopclntab (Tabela de Linhas de Contadores de Programa) que o runtime Go usa para stack traces, mensagens de pânico, coleta de lixo e suporte ao depurador. É uma das fontes mais valiosas de informação de símbolos em binários Go.

r2gopclntabParser lê essa região através do radare2, analisa as estruturas específicas da versão e imprime a lista de funções recuperadas (com endereços, arquivos fonte e números de linha) ou aplica os nomes recuperados de volta na sessão aberta do radare2 como definições de funções, flags e comentários.

Source files (261): ------------------------------------------------------------ /opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/bounds.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/escape.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/type.go <autogenerated> /opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/cpu/cpu.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/cpu/cpu_arm64.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/runtime/proc.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/runtime/mgc.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/runtime/malloc.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/runtime/panic.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/fmt/print.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/fmt/format.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/reflect/value.go /opt/homebrew/Cellar/go/1.26.1/libexec/src/reflect/type.go /tmp/gotest/main.go ... ... and 61 more ``` ### Modo Aplicar (--apply) Escreve todos os nomes de funções recuperados na sessão do radare2. O seguinte mostra uma comparação antes/depois no binário stripped. **ANTES** (análise nativa do r2 em binário stripped, sem parsing de gopclntab): ![image](https://user-images.githubusercontent.com/2173508/38002375-56621c1a-320a-11e8-8b08-7d9b9c0c7e5b.png)``` Functions found by r2 natively: 1913 Disassembly at 0x1000a0c20 (main.main, unnamed): ; CODE XREF from fcn.1000a0c20 @ 0x1000a0d14(r) 24: fcn.1000a0c20 (int64_t arg1); 0x1000a0c20 900b40f9 ldr x16, [x28, 0x10] 0x1000a0c24 ff6330eb cmp sp, x16 0x1000a0c28 29070054 b.ls 0x1000a0d0c Disassembly at 0x1000a0bb0 (main.fibonacci, unnamed): 112: fcn.1000a0bb0 (signed int64_t arg1, int64_t arg_8h); 0x1000a0bb0 900b40f9 ldr x16, [x28, 0x10] 0x1000a0bb4 ff6330eb cmp sp, x16 0x1000a0bb8 a9020054 b.ls 0x1000a0c0c ``` r2 encontrou 1913 funções, mas não nomeou nenhuma delas (apenas rótulos anônimos `fcn.XXXXXXXX`). A busca por `main.main` ou `main.fibonacci` não retorna nada. **Aplicando símbolos gopclntab:**``` [*] Binary format: mach0, endian: little, arch: arm, bits: 64 [*] Found magic at vaddr=0x1000ABCE8 [*] Parsed header: PcHeader(magic=0xFFFFFFF1, version=1.20+, ...) [*] textStart is 0, using .text section vaddr: 0x100001000 [*] Parsed 2030 functions [+] Applied 2030 function names to radare2 (0 skipped) ``` **DEPOIS** (sessão r2 com símbolos gopclntab aplicados):``` r2 function list matching "main" (after --apply): 0x100041510 0 0 runtime.main 0x100041920 0 0 runtime.main.func2 0x10006ce30 0 0 runtime.main.func1 Flags in go.* flagspace (last 20): 0x10009fa60 1 go.fmt._ptr_pp_.doPrintf 0x1000a0930 1 go.fmt._ptr_pp_.doPrintln 0x1000a0bb0 1 go.main.fibonacci 0x1000a0c20 1 go.main.main 0x1000a0d20 1 go.go:textfipsstart 0x1000a0d30 1 go.go:textfipsend ``` A desmontagem em `main.main` agora mostra o nome recuperado e a localização da fonte:``` ;-- go.main.main: 24: fcn.1000a0c20 (int64_t arg1); 0x1000a0c20 900b40f9 ldr x16, [x28, 0x10] ; " src: /tmp/gotest/main.go:20" 0x1000a0c24 ff6330eb cmp sp, x16 0x1000a0c28 29070054 b.ls 0x1000a0d0c ``` Desmontagem em `main.fibonacci` agora mostra o nome recuperado e a localização da fonte:``` ;-- go.main.fibonacci: 112: fcn.1000a0bb0 (signed int64_t arg1, int64_t arg_8h); 0x1000a0bb0 900b40f9 ldr x16, [x28, 0x10] ; " src: /tmp/gotest/main.go:13" 0x1000a0bb4 ff6330eb cmp sp, x16 0x1000a0bb8 a9020054 b.ls 0x1000a0c0c ``` Buscar por nome agora funciona na sessão r2:``` go.main.main resolves to: 0x1000a0c20 go.main.fibonacci resolves to: 0x1000a0bb0 ``` --- ## Resumo dos Resultados: Mach-O (Binário de Teste Stripped) | Métrica | r2 nativo (stripped) | Após r2_gopclntab.py | |---|---|---| | Funções encontradas | 1913 (rótulos anônimos `fcn.XXXX`) | 2030 (nomes completos qualificados por pacote Go) | | Funções de usuário identificadas | 0 | `main.main`, `main.fibonacci` com fonte + linha | | Arquivos fonte recuperados | 0 | 261 (caminhos absolutos completos) | | Símbolos nomeados | Apenas stubs de importação C (`sym.imp.mmap`, etc.) | Todas as funções Go rotuladas (`go.main.main`, `go.runtime.gcStart`, etc.) | | Comentários de fonte | Nenhum | Embutido `src: /tmp/gotest/main.go:20` na desmontagem | | Navegável por nome | Não | Sim (`s go.main.main`, `afl~runtime.gc`) | --- ## Teste PE: Greenblood, um Binário Ransomware Go O analisador foi testado contra um binário PE real, Greenblood (`greenblood_1`), uma amostra de ransomware Go compilada como um executável PE32+ x86-64 Windows. Binários PE não possuem uma seção `.gopclntab` dedicada, portanto isso exercita o caminho alternativo de varredura de bytes mágicos. ### Detecção e Cabeçalho``` $ python3 r2_gopclntab.py -f ./greenblood_1 -v ``` Please provide the Markdown content to translate.``` [*] Binary format: pe, endian: little, arch: x86, bits: 64 [*] Scanning binary for gopclntab magic bytes... [*] Scanning section '.text' (0x401000, 0xF4000)... [*] Scanning section '.rdata' (0x4F5000, 0x127000)... [*] Found magic at vaddr=0x568C00 [*] Parsed header: PcHeader(magic=0xFFFFFFF1, version=1.20+, ptrSize=8, minLC=1, nfunc=2596, nfiles=345, textStart=0x401000) [*] textStart from header: 0x401000 [*] Parsed 2596 functions ``` O scanner encontrou o gopclntab dentro da seção `.rdata` em `0x568C00`. Como este é um PE padrão (não PIE), `textStart` é `0x401000` (diferente de zero), então o valor do cabeçalho é usado diretamente para o cálculo do endereço. | Campo | Valor | |---|---| | Formato | PE32+ x86-64 | | Localização do gopclntab | `.rdata` em `0x568C00` (encontrado por varredura de magia) | | Magic | `0xFFFFFFF1` (Go 1.20+) | | Tamanho do ponteiro | 8 | | Quantum (minLC) | 1 (x86) | | textStart | `0x401000` (do cabeçalho) | | Funções recuperadas | 2596 | | Arquivos de origem | 345 | ### Funções de Malware Recuperadas Buscando pelo código do malware (`main.`):``` $ python3 r2_gopclntab.py -f ./greenblood_1 -n "main." ``` Please provide the Markdown content to translate.``` ADDRESS FUNCTION NAME ---------------------------------------------------------------------- 0x4D91E0 main.init (<autogenerated>:1) 0x4D9200 main.map.init.0 (/root/victims/ransom/daf/enc.go:59) 0x4D92C0 main.map.init.1 (/root/victims/ransom/daf/enc.go:126) 0x4D95C0 main.NewKeyManager (/root/victims/ransom/daf/enc.go:146) 0x4D97E0 main.getMachineFingerprint (/root/victims/ransom/daf/enc.go:173) 0x4DA2C0 main.getBIOSUUID (/root/victims/ransom/daf/enc.go:249) 0x4DA3C0 main.NewEncryptionEngine (/root/victims/ransom/daf/enc.go:287) 0x4DA560 main.(*EncryptionEngine).fileWorker (/root/victims/ransom/daf/enc.go:303) 0x4DA660 main.(*EncryptionEngine).processFile (/root/victims/ransom/daf/enc.go:319) 0x4DA740 main.(*EncryptionEngine).encryptFile (/root/victims/ransom/daf/enc.go:334) 0x4DB2A0 main.(*EncryptionEngine).EncryptPath (/root/victims/ransom/daf/enc.go:446) 0x4DB620 main.(*EncryptionEngine).shouldSkipDirectory (/root/victims/ransom/daf/enc.go:495) 0x4DB7C0 main.(*EncryptionEngine).shouldEncryptFile (/root/victims/ransom/daf/enc.go:522) 0x4DB9A0 main.(*EncryptionEngine).placeRansomNote (/root/victims/ransom/daf/enc.go:560) 0x4DBB60 main.(*EncryptionEngine).recordSuccess (/root/victims/ransom/daf/enc.go:636) 0x4DBFA0 main.(*EncryptionEngine).Wait (/root/victims/ransom/daf/enc.go:664) 0x4DC3C0 main.formatBytes (/root/victims/ransom/daf/enc.go:689) 0x4DC500 main.disableRecovery (/root/victims/ransom/daf/enc.go:706) 0x4DC720 main.isAdmin (/root/victims/ransom/daf/enc.go:732) 0x4DC8C0 main.main (/root/victims/ransom/daf/enc.go:760) 0x4DD260 main.getLogicalDrives (/root/victims/ransom/daf/enc.go:863) 0x4DD4A0 main.isAlreadyRunning (/root/victims/ransom/daf/enc.go:892) 0x4DD660 main.getDesktopPath (/root/victims/ransom/daf/enc.go:911) 0x4DD780 main.removeExecutable (/root/victims/ransom/daf/enc.go:932) ... [+] 43 function(s) shown (filtered from 2596 total) ``` All 43 user functions were recovered from a single source file at `/root/victims/ransom/daf/enc.go`. The function names immediately reveal the ransomware's capabilities: key management, machine fingerprinting, file encryption with path traversal, ransom note placement, recovery disabling, privilege checking, mutex-based single-instance enforcement, drive enumeration, and self-deletion. ### Dependências Não-Padrão da Biblioteca Extraindo arquivos fonte que não fazem parte da biblioteca padrão do Go:``` /root/go/pkg/mod/golang.org/x/[email protected]/windows/dll_windows.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/registry/key.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/registry/value.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/security_windows.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/str.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/syscall.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/syscall_windows.go /root/go/pkg/mod/golang.org/x/[email protected]/windows/zsyscall_windows.go /root/victims/ransom/daf/enc.go ``` A única dependência externa é `golang.org/x/[email protected]` para syscalls específicas do Windows (acesso ao registro, tokens de segurança, carregamento de DLL). ### Funções de Criptografia A busca por `crypto` revela 137 funções relacionadas a criptografia, incluindo:``` $ python3 r2_gopclntab.py -f ./greenblood_1 -n "crypto" ``` Para contribuir, você precisa seguir as [instruções anteriores](#previous-requisites).``` ADDRESS FUNCTION NAME ---------------------------------------------------------------------- 0x4AEC00 crypto/cipher.NewCTR (/usr/local/go/src/crypto/cipher/ctr.go:41) 0x4AF520 crypto/cipher.StreamWriter.Write (/usr/local/go/src/crypto/cipher/io.go:36) 0x4AF840 crypto/aes.NewCipher (/usr/local/go/src/crypto/aes/aes.go:36) 0x4C3760 crypto/rand.(*reader).Read (/usr/local/go/src/crypto/rand/rand.go:45) 0x4DE6C0 crypto/internal/fips140/sha256.New (.../sha256/sha256.go:138) 0x4E3EC0 crypto/internal/fips140/sha3.NewCShake128 (.../sha3/shake.go:134) 0x4EED60 crypto/internal/fips140/hmac.New (.../hmac/hmac.go:131) 0x4EF800 crypto/internal/fips140/aes.newBlock (.../aes/aes_asm.go:59) 0x4F0800 crypto/internal/fips140/aes.(*CBCEncrypter).CryptBlocks (.../aes/cbc.go:26) 0x4F0FE0 crypto/internal/fips140/aes.(*CTR).XORKeyStream (.../aes/ctr.go:41) ... [+] 137 function(s) shown (filtered from 2596 total) ``` The crypto usage profile: AES (CBC and CTR modes), SHA-256, SHA-512, HMAC, CSHAKE128, and DRBG (deterministic random bit generator). This is consistent with ransomware that generates per-machine encryption keys derived from a machine fingerprint, encrypts files with AES-CTR, and uses HMAC for integrity. ### Modo de Aplicação``` $ python3 r2_gopclntab.py -f ./greenblood_1 --apply [+] Applied 2596 function names to radare2 (0 skipped) [+] Function names applied. Use 'afl' in r2 to see them. ``` Todas as 2596 funções aplicadas com sucesso e nenhuma ignorada. --- ## Casos de Uso para Engenharia Reversa ### 1. Triagem e Identificação Determine instantemente se um binário é Go, com qual versão foi compilado e quais pacotes utiliza. A saída `--files` revela a versão do toolchain Go (a partir de caminhos de arquivo como `/usr/local/go/1.26.1/...`) e todos os caminhos de arquivos fonte, incluindo bibliotecas de terceiros. Para malware, isso revela instantemente se a amostra usa `crypto/tls`, `net/http`, `os/exec` ou outros pacotes de interesse. ### 2. Recuperação de Símbolos em Binários Stripped O caso de uso principal. Binários Go stripped com `-ldflags="-s -w"` perdem sua tabela de símbolos, mas o gopclntab sobrevive. Esta ferramenta restaura cada nome de função, transformando `fcn.1000a0c20` anônimo de volta em `main.main`. Isso se aplica a amostras de malware, desafios CTF, binários de produção e qualquer executável Go stripped. ### 3. Navegando pelo Runtime do Go Binários Go incorporam todo o runtime (tipicamente 1500 a 2000+ funções). Sem nomes, o runtime é uma parede impenetrável de funções anônimas. Com nomes, você pode localizar instantemente `runtime.mallocgc`, `runtime.gopanic`, `runtime.newproc`, `runtime.gcStart` e entender o que o binário está fazendo em cada ponto de chamada. ### 4. Separando Código do Usuário do Runtime Ao pesquisar por `main.` ou pelo caminho do pacote da aplicação, você pode isolar apenas o código do usuário do runtime. Nos exemplos acima, filtrar por `main.` revela imediatamente `main.main` e `main.fibonacci` entre 2030 funções no total. Você também pode pesquisar por nomes de pacotes de terceiros (por exemplo, `-n "github.com/user/repo"`) para identificar dependências externas. ### 5. Contexto de Nível de Código Fonte Cada função vem com seu caminho de arquivo fonte e número da linha inicial. Isso significa que você pode fazer referência cruzada da desmontagem com o código fonte da biblioteca padrão do Go (que é aberto), mesmo ao analisar um binário stripped. Saber que uma função começa na linha 733 de `runtime/mgc.go` permite ler o código fonte original junto com a desmontagem. ### 6. Pipeline e Automação O modo `--json` permite script. Alimente a saída em importadores IDA/Ghidra, ferramentas de diff, geradores de regras YARA, ou qualquer pipeline de análise. Por exemplo, para extrair todas as funções relacionadas a criptografia:```bash python3 r2_gopclntab.py -f sample.exe --json \ | jq '.functions[] | select(.name | contains("crypto"))' ``` ### 7. Fluxo de Trabalho Interativo do radare2 Após `--apply`, toda a sessão do r2 torna-se navegável por nome Go. Você pode ir para funções (`s go.main.main`), pesquisar a lista de funções (`afl~runtime.gc`), inspecionar referências cruzadas (`axf go.main.fibonacci`) e ver comentários de localização de código fonte inline na saída de desmontagem (`pd`). Isso transforma o r2 de um desmontador genérico em um ambiente de análise consciente de Go. --- ## Plataformas Suportadas e Versões Go ### Formatos Binários | Formato | Método de Descoberta da Seção | Testado | |---|---|---| | ELF (Linux) | Nome da seção `.gopclntab` ou `.data.rel.ro.gopclntab` | Sim | | Mach-O (macOS) | Nome da seção `__gopclntab` (dentro do segmento `__TEXT`) | Sim | | PE (Windows) | Varredura de bytes mágicos (sem seção dedicada) | Sim (testado no Greenblood, um ransomware Go PE64) | Para binários PE e binários ELF/Mach-O agressivamente removidos que não possuem o cabeçalho de seção, a ferramenta recorre à varredura de todas as seções em busca dos bytes mágicos de 4 bytes seguidos por bytes de validação (pad=0, ptrSize em {4,8}, minLC em {1,2,4}). ### Versões Go | Mágico | Versão Go | `textStart` no cabeçalho | Tipo `functab.entry` | Campo `startLine` | Status | |---|---|---|---|---|---| | `0xFFFFFFFB` | 1.2 | Não | `uintptr` (absoluto) | Não | Suportado | | `0xFFFFFFFA` | 1.16 | Não | `uintptr` (absoluto) | Não | Suportado | | `0xFFFFFFF0` | 1.18 - 1.19 | Sim | `uint32` (relativo) | Não | Suportado | | `0xFFFFFFF1` | 1.20+ | Sim (pode ser 0) | `uint32` (relativo) | Sim | Suportado | O mágico `0xFFFFFFF1` é usado pelo Go 1.20 até pelo menos Go 1.26. --- ## Metodologia ### Estratégia de Localização da Seção O analisador usa uma abordagem de duas fases para encontrar os dados gopclntab: **Fase 1 (ELF/Mach-O):** Consultar a lista de seções do radare2 (`iSj`) e procurar por seções nomeadas `.gopclntab`, `.data.rel.ro.gopclntab` ou `__gopclntab`. **Fase 2 (PE/fallback):** Se nenhuma seção nomeada for encontrada, varra todas as seções em busca dos bytes mágicos de 4 bytes. Cada candidato é validado verificando se os bytes 4-7 correspondem ao padrão esperado: dois bytes de preenchimento zero, um tamanho de ponteiro válido (4 ou 8) e um quantum de instrução válido (1, 2 ou 4). Isso elimina falsos positivos de padrões de bytes coincidentes. ### textStart vs Seção .text Em Go >= 1.18, os pontos de entrada das funções na functab são armazenados como deslocamentos relativos. Calcular o endereço virtual absoluto requer uma base:``` absolute_addr = base + entryoff ``` A base é resolvida com a seguinte lógica:``` Is magic 0xFFFFFFFB (Go 1.2)? YES -> base = 0 (entries are absolute addresses) NO -> Is magic 0xFFFFFFFA (Go 1.16)? YES -> base = .text section vaddr (entries are absolute) NO -> (Go 1.18 / 1.20+) Is header.textStart != 0? YES -> base = header.textStart NO -> base = .text section vaddr ``` O caso `textStart == 0` ocorre no Go >= 1.22 para binários Mach-O e PIE. Quando isso acontece, os valores de `entryoff` são relativos ao início da seção `.text`, portanto o parser consulta o r2 pelo endereço virtual da seção `.text` e usa isso como base. Isso foi verificado num binário Go 1.26 Mach-O arm64: - `textStart` no cabeçalho: `0x0` - vaddr da seção `.text`: `0x100001000` - `functab[1].entryoff`: `0x70` - Endereço calculado: `0x100001000 + 0x70 = 0x100001070` - A análise nativa do r2 confirmou `internal/abi.BoundsDecode` em `0x100001070` ### Parsing de Struct Sensível à Versão O layout da struct `_func` difere entre Go 1.18 e Go 1.20+. A única mudança é a inserção de um campo `startLine` de 4 bytes no offset 36 no Go 1.20+, que desloca `funcID`, `flag` e `nfuncdata` em 4 bytes: | Campo | Offset Go 1.18 | Offset Go 1.20+ | |---|---|---| | `entryOff` | 0 | 0 | | `nameOff` | 4 | 4 | | `args` | 8 | 8 | | `cuOffset` | 32 | 32 | | `startLine` | (ausente) | 36 | | `funcID` | 36 | 40 | | `flag` | 37 | 41 | | `nfuncdata` | 39 | 43 | O parser verifica o número mágico para determinar qual layout usar. ### Decodificação de Dados PC Índices de arquivo fonte e números de linha são armazenados como "programas de dados PC" compactos na região pctab. Cada programa codifica uma sequência de pares `(value_delta, pc_delta)` usando inteiros de comprimento variável com codificação zig-zag para valores com sinal. O parser decodifica estes para resolver: - Arquivo fonte: `_func.pcfile` -> programa pctab -> índice do arquivo -> cutab -> filetab -> string do caminho do arquivo - Número de linha: `_func.pcln` -> programa pctab -> número de linha (mais offset `startLine` para Go 1.20+) --- ## Limitações 1. **Funções inline** não aparecem na tabela de funções de nível superior. Elas são codificadas nas estruturas `FUNCDATA_InlTree` / `PCDATA_InlTreeIndex`, que esta ferramenta atualmente não decodifica. No binário de teste, `main.helloWorld` e `main.addNumbers` foram inlinizadas pelo compilador e, portanto, não aparecem na saída. 2. **Suporte ao Go 1.2** é o melhor possível. O formato Go 1.2 é substancialmente diferente (sem funcnametab separado, sem cutab, ponteiros absolutos na functab) e raramente é encontrado na prática. 3. **Arquiteturas big-endian** são tratadas em princípio (o endian é detectado a partir da informação binária do radare2 e usado para todas as leituras de struct), mas não foram testadas. 4. O modo `--apply` cria stubs de função com `af+` que podem entrar em conflito com a auto-análise do r2. Executá-lo numa sessão limpa (antes ou no lugar de `aaa`) pode dar melhores resultados em alguns casos. --- ## Documentação Adicional Documentação técnica detalhada está disponível no diretório `documentation/`: - [DOCUMENTATION.md](https://github.com/asherdll/r2gopclntabparser/blob/main/documentation/DOCUMENTATION.md) — Documentação completa do usuário com todos os modos de uso, formatos de saída e combinações de flags. - [METHODOLOGY.md](https://github.com/asherdll/r2gopclntabparser/blob/main/documentation/METHODOLOGY.md) — Decisões de design e algoritmos: resolução textStart vs .text, parsing sensível à versão, estratégia de escaneamento PE, decodificação de dados PC, detalhes de integração com r2. - [GOPCLNTAB_FORMAT.md](https://github.com/asherdll/r2gopclntabparser/blob/main/documentation/GOPCLNTAB_FORMAT.md) — O formato binário gopclntab entre versões do Go: layouts de struct em nível de byte, modelo de memória, cadeias de offsets, codificação varint, resumo das diferenças entre versões. --- ## Referências - Código fonte do runtime Go (pcHeader): [go1.20.6/src/runtime/symtab.go#L414](https://github.com/golang/go/blob/go1.20.6/src/runtime/symtab.go#L414) - Linker Go (escreve o formato): [go1.20.6/src/cmd/link/internal/ld/pcln.go](https://github.com/golang/go/blob/go1.20.6/src/cmd/link/internal/ld/pcln.go) - Mandiant — Recuperação de Símbolos em Golang: [mandiant.com/resources/blog/golang-internals-symbol-recovery](https://www.mandiant.com/resources/blog/golang-internals-symbol-recovery) - Documento de design da tabela de símbolos Go 1.2: [docs.google.com/document/d/1lyPIbmsYbXnpNj57a261hgOYVpNRcgydurVQIyZOz_o](https://docs.google.com/document/d/1lyPIbmsYbXnpNj57a261hgOYVpNRcgydurVQIyZOz_o/pub)

Dependência	Versão Mínima
Python 3	3.8+
radare2	5.0+ (testado na 6.0.9)
r2pipe	qualquer

Flag	Descrição
`-f FILE`, `--file FILE`	Caminho para o binário Go a ser analisado. O script cria sua própria instância r2.
`--r2pipe`	Anexar a uma sessão r2 já em execução (para uso dentro do console r2).

Flag	Descrição
`-l`, `--list`	Imprime todas as funções recuperadas com seus endereços.
`-n NAME`, `--funcname NAME`	Imprime apenas funções cujo nome contenha `NAME` (correspondência de substring). Se houver uma correspondência exata, seu endereço é impresso separadamente.
`-v`, `--verbose`	Imprime mensagens de progresso, campos de cabeçalho analisados e offsets internos.
`--apply`	Escreve os nomes de funções recuperados na sessão radare2 como definições de função (`af+`), flags no espaço de flags `go.` e comentários com o nome Go original e localização do código-fonte.
`--json`	Produz o cabeçalho e a lista completa de funções como JSON na saída padrão.
`--files`	Imprime a lista de caminhos de arquivos fonte extraídos da tabela de arquivos.
`-h`, `--help`	Exibe a mensagem de ajuda.

r2gopclntabParser

Mais Populares

Pré-requisitos

Início Rápido```bash

List all functions recovered from a Go binary

Search for a specific function (substring match)

Verbose header + function list

Apply recovered names into an r2 session

JSON output

From within r2 (attach to running session)

Obrigatório (um de)

Opcional

Modos de Saída e Exemplos

Modo Padrão (Cabeçalho + Lista de Funções)

Verbose Mode (-v)

Modo de Busca (-n)

SSL

Personalização

ADDRESS FUNCTION NAME