---

## Référence CLI```
usage: r2_gopclntab.py [-h] [-f FILE] [-n FUNCNAME] [-v] [-l]
                       [--apply] [--json] [--files] [--r2pipe]

.

To be precise, I'll just not write anything. However, the API might require a message. I'll send an empty string.```
============================================================
  Go pclntab Header
============================================================
  Magic:           0xFFFFFFF1
  Go version:      1.20+
  Pointer size:    8
  Min LC (quantum):4
  Num functions:   2030
  Num files:       261
  funcnameOffset:  0x48
  cuOffset:        0x14D20
  filetabOffset:   0x158D8
  pctabOffset:     0x19A98
  pclnOffset:      0x55E40
============================================================

ADDRESS       FUNCTION NAME
----------------------------------------------------------------------
0x100001000   go:buildid
0x100001070   internal/abi.BoundsDecode  (/opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/bounds.go:86)
0x100001150   internal/abi.NoEscape  (/opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/escape.go:19)
0x100001160   internal/abi.Kind.String  (/opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/type.go:143)
0x1000011E0   internal/abi.TypeOf  (/opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/type.go:181)
0x1000011F0   internal/abi.(*Type).ExportedMethods  (/opt/homebrew/Cellar/go/1.26.1/libexec/src/internal/abi/type.go:453)
...
0x1000A0BB0   main.fibonacci  (/tmp/gotest/main.go:13)
0x1000A0C20   main.main  (/tmp/gotest/main.go:20)
0x1000A0D20   go:textfipsstart
0x1000A0D30   go:textfipsend

[+] 2030 function(s) shown

### Documentation

Pour des instructions d'utilisation complètes et la documentation, consultez : [NetDoc Documentation](https://github.com/```
[*] Running radare2 analysis...
[*] Binary format: mach0, endian: little, arch: arm, bits: 64
[*] Scanning binary for gopclntab magic bytes...
[*]   Scanning section '0.__TEXT.__text' (0x100001000, 0x9FD44)...
[*]   Scanning section '1.__TEXT.__symbol_stub1' (0x1000A0D60, 0x2B8)...
[*]   Scanning section '2.__TEXT.__rodata' (0x1000A1020, 0xACC2)...
[*]   Scanning section '3.__TEXT.__gopclntab' (0x1000ABCE8, 0xA48AE)...
[*]   Found magic at vaddr=0x1000ABCE8
[*] Parsed header: PcHeader(magic=0xFFFFFFF1, version=1.20+, ptrSize=8, minLC=4,
    nfunc=2030, nfiles=261, textStart=0x0)
[*] textStart is 0, using .text section vaddr: 0x100001000
[*] Parsed 2030 functions

============================================================
  Go pclntab Header
============================================================
  Magic:           0xFFFFFFF1
  Go version:      1.20+
  ...

VERSION = "2.0"
    DESCRIPTION = "Find vulnerabilities easily."

[![GitHub Issues](https://img.shields.io/badge/issues-0-brightgreen)](https://github.com/example/issues)

- [Fonctionnalités](#features)
- [Installation](#installation)
- [Utilisation](#usage)
- [Exemples](#examples)

## Fonctionnalités

- **Analyse rapide** avec multithreading.
- **Rapports complets** aux formats HTML et PDF.
- **Interface en ligne de commande conviviale** avec sortie colorée.

## Installation

```bash
pip install vulnscanner

vulnscanner scan --target example.com --output report.html

vulnscanner --help

Recherche de correspondance exacte :```
$ python3 r2_gopclntab.py -f ./gotest_stripped -n "main.fibonacci"

Recherche des internes du runtime liés au GC :```
$ python3 r2_gopclntab.py -f ./gotest_stripped -n "runtime.gc"

Recherche de `fmt.` (impression de la bibliothèque standard):```
$ python3 r2_gopclntab.py -f ./gotest_stripped -n "fmt."

Recherche de `sync.` (primitives de concurrence):```
$ python3 r2_gopclntab.py -f ./gotest_stripped -n "sync."

### Sortie JSON (--json)

Sortie lisible par machine pour l'intégration de scripts et de pipelines :```
$ python3 r2_gopclntab.py -f ./gotest_stripped --json

### Liste des fichiers sources (--files)

Extrait tous les chemins des fichiers sources intégrés dans le binaire :```
$ python3 r2_gopclntab.py -f ./gotest_stripped --files

### Apply Mode (--apply)

Écrit tous les noms de fonctions récupérés dans la session radare2. Ce qui suit montre une comparaison avant/après sur le binaire dépouillé.

**AVANT** (analyse native r2 sur binaire dépouillé, sans analyse gopclntab) :```
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

**APRÈS** (session r2 avec symboles gopclntab appliqués):```
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

Le désassemblage à `main.fibonacci` montre désormais le nom et l'emplacement source récupérés:```
            ;-- 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

---

## Résumé des résultats : Mach-O (binaire de test ébarbé)

| Métrique | r2 natif (ébarbé) | Après r2_gopclntab.py |
|---|---|---|
| Fonctions trouvées | 1913 (étiquettes anonymes `fcn.XXXX`) | 2030 (noms complets qualifiés par paquet Go) |
| Fonctions utilisateur identifiées | 0 | `main.main`, `main.fibonacci` avec source + ligne |
| Fichiers source récupérés | 0 | 261 (chemins absolus complets) |
| Symboles nommés | Uniquement les stubs d'importation C (`sym.imp.mmap`, etc.) | Chaque fonction Go étiquetée (`go.main.main`, `go.runtime.gcStart`, etc.) |
| Commentaires source | Aucun | Dans le désassemblage, en ligne `src: /tmp/gotest/main.go:20` |
| Navigable par nom | Non | Oui (`s go.main.main`, `afl~runtime.gc`) |

---

## Test PE : Greenblood, un binaire ransomware Go

L'analyseur a été testé avec un binaire PE réel, Greenblood (`greenblood_1`), un
échantillon de ransomware Go compilé en tant qu'exécutable Windows PE32+ x86-64.
Les binaires PE n'ont pas de section `.gopclntab` dédiée, ce qui met en œuvre le
chemin de repli par balayage des octets magiques.

### Détection et en-tête```
$ python3 r2_gopclntab.py -f ./greenblood_1 -v

Le scanner a trouvé le gopclntab dans la section `.rdata` à `0x568C00`.
Comme il s'agit d'un PE standard (pas PIE), `textStart` est `0x401000` (non nul),
donc la valeur de l'en-tête est utilisée directement pour le calcul d'adresse.

| Champ | Valeur |
|---|---|
| Format | PE32+ x86-64 |
| gopclntab location | `.rdata` à `0x568C00` (trouvé par magic scan) |
| Magic | `0xFFFFFFF1` (Go 1.20+) |
| Pointer size | 8 |
| Quantum (minLC) | 1 (x86) |
| textStart | `0x401000` (depuis l'en-tête) |
| Functions recovered | 2596 |
| Source files | 345 |

### Fonctions du malware récupérées

Recherche du code propre au malware (`main.`) :```
$ python3 r2_gopclntab.py -f ./greenblood_1 -n "main."

Toutes les 43 fonctions utilisateur ont été récupérées à partir d'un seul fichier source situé à
`/root/victims/ransom/daf/enc.go`. Les noms des fonctions révèlent immédiatement les
capacités du rançongiciel : gestion des clés, empreinte de la machine, chiffrement
des fichiers avec traversée de chemin, placement de la note de rançon, désactivation des
restaurations, vérification des privilèges, limitation à une seule instance via mutex,
énumération des lecteurs et auto-suppression.

### Dépendances non issues de la bibliothèque standard

Extraction des fichiers sources qui ne font pas partie de la bibliothèque standard 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

- 🪟 [**pivotnacci**](https://github.com/blackarrowsec/pivotnacci): Outil qui permet de faire un tunnel socks vers un serveur HTTP, modélisant les agents en tant que machines à états.

  Utilisateurs de FreeBSD

- Si vous avez installé via le port git :
  ```bash
  sudo pkg upgrade git

Le profil d'utilisation cryptographique : AES (modes CBC et CTR), SHA-256, SHA-512, HMAC, CSHAKE128 et DRBG (générateur de bits aléatoires déterministe). Ceci est cohérent avec les ransomwares qui génèrent des clés de chiffrement par machine dérivées d'une empreinte de la machine, chiffrent les fichiers avec AES-CTR et utilisent HMAC pour l'intégrité.

### Mode d'Application```
$ 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.

### 7. Workflow interactif radare2

Après `--apply`, la session r2 entière devient navigable par nom Go. Vous pouvez vous rendre à des fonctions (`s go.main.main`), chercher dans la liste des fonctions (`afl~runtime.gc`), inspecter les références croisées (`axf go.main.fibonacci`), et voir les commentaires d'emplacement source en ligne dans le résultat du désassemblage (`pd`). Cela transforme r2 d'un désassembleur générique en un environnement d'analyse sensible à Go.

---

## Plateformes supportées et versions de Go

### Formats binaires

| Format | Méthode de découverte de section | Testé |
|---|---|---|
| ELF (Linux) | Nom de section `.gopclntab` ou `.data.rel.ro.gopclntab` | Oui |
| Mach-O (macOS) | Nom de section `__gopclntab` (à l'intérieur du segment `__TEXT`) | Oui |
| PE (Windows) | Scan par octets magiques (pas de section dédiée) | Oui (testé sur Greenblood, un ransomware Go PE64) |

Pour les binaires PE et les binaires ELF/Mach-O agressivement stripés qui manquent l'en-tête de section, l'outil se rabat sur le scan de toutes les sections pour les 4 octets magiques suivis des octets de validation (pad=0, ptrSize dans {4,8}, minLC dans {1,2,4}).

### Versions de Go

| Magique | Version de Go | `textStart` dans l'en-tête | Type de `functab.entry` | Champ `startLine` | Statut |
|---|---|---|---|---|---|
| `0xFFFFFFFB` | 1.2 | Non | `uintptr` (absolu) | Non | Supporté |
| `0xFFFFFFFA` | 1.16 | Non | `uintptr` (absolu) | Non | Supporté |
| `0xFFFFFFF0` | 1.18 - 1.19 | Oui | `uint32` (relatif) | Non | Supporté |
| `0xFFFFFFF1` | 1.20+ | Oui (peut être 0) | `uint32` (relatif) | Oui | Supporté |

La magie `0xFFFFFFF1` est utilisée par Go 1.20 jusqu'à au moins Go 1.26.

---

## Méthodologie

### Stratégie de localisation de section

L'analyseur utilise une approche en deux phases pour trouver les données gopclntab :

**Phase 1 (ELF/Mach-O) :** Interroger la liste des sections de radare2 (`iSj`) et rechercher les sections nommées `.gopclntab`, `.data.rel.ro.gopclntab` ou `__gopclntab`.

**Phase 2 (PE/fallback) :** Si aucune section nommée n'est trouvée, scanner toutes les sections pour les 4 octets magiques. Chaque candidat est validé en vérifiant que les octets 4-7 correspondent au motif attendu : deux octets de padding zéro, une taille de pointeur valide (4 ou 8) et un quantum d'instruction valide (1, 2 ou 4). Cela élimine les faux positifs provenant de motifs d'octets fortuits.

### textStart par rapport à la section .text

À partir de Go >= 1.18, les points d'entrée des fonctions dans le functab sont stockés comme des décalages relatifs. Le calcul de l'adresse virtuelle absolue nécessite une base :```
absolute_addr = base + entryoff

Le cas `textStart == 0` se produit dans Go >= 1.22 pour les binaires Mach-O et PIE.
Lorsque cela se produit, les valeurs `entryoff` sont relatives au début de la section `.text`,
donc l'analyseur interroge r2 pour l'adresse virtuelle de `.text` et l'utilise comme base.

Cela a été vérifié sur un binaire Go 1.26 Mach-O arm64 :
- `textStart` dans l'en-tête : `0x0`
- `.text` section vaddr : `0x100001000`
- `functab[1].entryoff` : `0x70`
- Adresse calculée : `0x100001000 + 0x70 = 0x100001070`
- L'analyse native de r2 a confirmé `internal/abi.BoundsDecode` à l'adresse `0x100001070`

### Analyse de structure adaptée à la version

La disposition de la structure `_func` diffère entre Go 1.18 et Go 1.20+. La seule
modification est l'insertion d'un champ `startLine` de 4 octets au décalage 36 dans Go
1.20+, ce qui décale `funcID`, `flag` et `nfuncdata` de 4 octets :

| Champ | Décalage Go 1.18 | Décalage Go 1.20+ |
|---|---|---|
| `entryOff` | 0 | 0 |
| `nameOff` | 4 | 4 |
| `args` | 8 | 8 |
| `cuOffset` | 32 | 32 |
| `startLine` | (absent) | 36 |
| `funcID` | 36 | 40 |
| `flag` | 37 | 41 |
| `nfuncdata` | 39 | 43 |

L'analyseur vérifie le nombre magique pour déterminer quelle disposition utiliser.

### Décodage des données PC

Les indices de fichiers source et les numéros de ligne sont stockés sous forme de
« programmes de données PC » compacts dans la région pctab. Chaque programme encode une
séquence de paires `(value_delta, pc_delta)` en utilisant des entiers de longueur variable
avec un encodage zig-zag pour les valeurs signées. L'analyseur décode ceux-ci pour résoudre :

- Fichier source : `_func.pcfile` -> programme pctab -> index de fichier -> cutab ->
  filetab -> chaîne de chemin de fichier
- Numéro de ligne : `_func.pcln` -> programme pctab -> numéro de ligne (plus
  le décalage `startLine` pour Go 1.20+)

---

## Limitations

1. **Les fonctions inline** n'apparaissent pas dans la table des fonctions de premier
   niveau. Elles sont encodées dans les structures `FUNCDATA_InlTree` / `PCDATA_InlTreeIndex`,
   que cet outil ne décode pas actuellement. Dans le binaire de test,
   `main.helloWorld` et `main.addNumbers` ont été inline par le compilateur et
   n'apparaissent donc pas dans la sortie.

2. **Le support Go 1.2** est fourni au mieux. Le format Go 1.2 est sensiblement
   différent (pas de funcnametab séparé, pas de cutab, pointeurs absolus dans functab)
   et est rarement rencontré en pratique.

3. **Les architectures big-endian** sont gérées en principe (l'endianness est
   détectée à partir des informations binaires de radare2 et utilisée pour toutes les
   lectures de structures) mais n'ont pas été testées.

4. Le mode `--apply` crée des stubs de fonctions avec `af+` qui peuvent entrer
   en conflit avec l'auto-analyse de r2. L'exécuter sur une session propre (avant ou
   à la place de `aaa`) peut donner de meilleurs résultats dans certains cas.

---

## Documentation complémentaire

Une documentation technique détaillée est disponible dans le répertoire `documentation/` :

- [DOCUMENTATION.md](https://github.com/asherdll/r2gopclntabparser/blob/HEAD/documentation/DOCUMENTATION.md) - Documentation complète de l'utilisateur avec tous les modes d'utilisation, formats de sortie et combinaisons de drapeaux.
- [METHODOLOGY.md](https://github.com/asherdll/r2gopclntabparser/blob/HEAD/documentation/METHODOLOGY.md) - Décisions de conception et algorithmes : résolution textStart vs .text, analyse adaptée à la version, stratégie de numérisation PE, décodage des données PC, détails d'intégration r2.
- [GOPCLNTAB_FORMAT.md](https://github.com/asherdll/r2gopclntabparser/blob/HEAD/documentation/GOPCLNTAB_FORMAT.md) - Le format binaire gopclntab à travers les versions de Go : dispositions de structure au niveau octet, modèle mémoire, chaînes de décalages, encodage varint, résumé des différences de version.

---

## Références

- Source du 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)
- Éditeur de liens Go (écrit le format) : [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 - Golang Internals Symbol Recovery : [mandiant.com/resources/blog/golang-internals-symbol-recovery](https://www.mandiant.com/resources/blog/golang-internals-symbol-recovery)
- Document de conception de la table des symboles Go 1.2 : [docs.google.com/document/d/1lyPIbmsYbXnpNj57a261hgOYVpNRcgydurVQIyZOz_o](https://docs.google.com/document/d/1lyPIbmsYbXnpNj57a261hgOYVpNRcgydurVQIyZOz_o/pub)