vmlinux-to-elf

Cet outil permet d'obtenir un fichier .ELF entièrement analysable à partir d'une image kernel vmlinux/vmlinuz/bzImage/zImage (qu'il s'agisse d'un blob binaire brut ou d'un fichier .ELF préexistant mais dépouillé de ses symboles), avec les symboles de fonctions et de variables récupérés.

Pour ce faire, il analyse votre kernel à la recherche d'une table de symboles kernel (kallsyms), une table de symboles compressée présente dans presque tous les kernels, la plupart du temps non modifiée.

Comme la table de symboles concernée est compressée à l'origine, il devrait récupérer des chaînes qui ne sont pas visibles dans le binaire d'origine.

Il produit un fichier .ELF que vous pouvez analyser avec IDA Pro et Ghidra. Cet outil est donc utile pour la rétro-ingénierie de systèmes embarqués.

Utilisation :

# Ligne de commande :
vmlinux-to-elf <input_kernel.bin> <output_kernel.elf>

# Ligne de commande, lister uniquement les adresses des symboles :
kallsyms-finder <input_kernel.bin> # Si installé avec uv
vmlinux-to-elf.kallsyms-finder # Si installé avec snap

# Ligne de commande, décompresser simplement le kernel :
vmlinuz-decompressor <input_kernel.bin> <output_kernel.bin> # Si installé avec uv
vmlinux-to-elf.vmlinuz-decompressor # Si installé avec snap

# Interface graphique :
vmlinux-to-elf-gui # Si installé avec uv
vmlinux-to-elf.gui # Si installé avec snap
flatpak run re.fossplant.vmlinux-to-elf # Si installé avec flatpak

Installation :

# Installer CLI+GUI avec Snap (recommandé sur Ubuntu)
sudo snap install vmlinux-to-elf

# Installer CLI+GUI avec yay (recommandé sur Arch, Manjaro)
yay -S vmlinux-to-elf libadwaita python-gobject

# Installer CLI+GUI avec uv (exemple avec Fedora)
sudo dnf install -y uv glib2-devel libadwaita-devel gtk4-devel \
    gobject-introspection-devel python3-gobject-devel \
    python3-devel cairo-devel @development-tools
uv tool install vmlinux-to-elf[gui]
vmlinux-to-elf-gui --install-metadata # Installer le fichier .desktop

# Installer CLI avec uv et GUI avec Flatpak (recommandé sur
# les distributions avec libadwaita < 1.6)
sudo dnf install -y uv flatpak @development-tools
uv tool install vmlinux-to-elf

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak install re.fossplant.vmlinux-to-elf

Configuration de l'environnement de développement local :

sudo snap install --classic astral-uv
sudo apt install git
git clone [email protected]:marin-m/vmlinux-to-elf.git

# Dépendances pour l'interface graphique GTK-4
sudo apt install libgirepository-2.0-dev libadwaita-1-dev \
    gir1.2-adw-1 gir1.2-gtk-4.0 python3-dev blueprint-compiler

cd vmlinux-to-elf
cp -a .github/hooks/* .git/hooks/
# Télécharger les modules Python et initialiser virtualenv (crée « .venv »,
# appeler « source .venv/bin/activate » pour l'activer)
uv sync --extra gui
# Ajouter vmlinux-to-elf au $PATH, afin que les commandes soient appelables
# à l'échelle du système (crée un lien symbolique vers la source dans « ~/.local/bin »)
uv tool install -e .[gui]

Fonctionnalités

• Prendre un blob binaire brut ou un fichier kernel ELF comme entrée [OK]
• Détecter et décompresser automatiquement les principaux formats de compression utilisés pour le kernel Linux [OK]
• Trouver et extraire la table de symboles kernel intégrée (kallsyms) du fichier d'entrée [OK]
• Déduire l'architecture du jeu d'instructions, l'endianness et la taille en bits, en s'appuyant entre autres sur les signatures courantes de prologue de fonctions [OK]
• Déduire le point d'entrée du kernel à partir des symboles contenus dans la table kallsyms [OK]
• Fournir une déduction de base pour l'adresse de base du kernel [OK] (pour l'instant, considérez qu'il s'agit de la première adresse de symbole « TEXT » du binaire avec les bits de poids faible 0xfff mis à zéro - semble fonctionner suffisamment bien)
• Décompresser certains types de fichiers Android boot.img, commençant par une signature magique ANDROID! ou UNCOMPRESSED_IMG [OK]
• Produire en sortie un fichier .ELF entièrement analysable avec IDA Pro ou Ghidra [OK]

Comment cela fonctionne-t-il, vraiment ?

Un bref historique de la table de symboles « kallsyms » se trouve en haut du fichier « kallsyms.py ». En bref, elle a été introduite vers 2004 dans le kernel Linux sous sa forme actuelle et sert, entre autres, à afficher les messages « Kernel oops ».

Elle contient des tuples « nom du symbole », « adresse du symbole », « type du symbole » (les types de symboles étant désignés par une seule lettre, d'une manière similaire à l'utilitaire nm), ces informations étant densément empaquetées avec un algorithme de compression simple.

Le schéma ci-dessous montre comment ces informations sont sérialisées dans le kernel, le décalage de chaque structure respective étant détecté par vmlinux-to-elf via des heuristiques :

Ces champs ont un alignement et une taille de champ variables. Les tailles de champs peuvent également varier selon l'architecture et la version du kernel. Pour cette raison, vmlinux-to-elf a été testé sur une variété de cas.

OpenWRT depuis 2013 dispose d'un patch qui supprime la compression de la table kallsyms par défaut (lorsque la compilation de kallsyms a été activée par l'utilisateur). Ils font cela afin d'économiser de l'espace lors de la recompression du kernel avec LZMA.

Cela signifie que les entrées kallsyms_token_table et kallsyms_token_address disparaissent et que les noms de symboles utilisent du texte ASCII brut à la place. Ce cas est également pris en charge.

Dans les kernels Linux 6.2 standard, les tableaux kallsyms sont encodés dans l'ordre suivant :

1. kallsyms_addresses (ou kallsyms_offsets + kallsyms_relative_base)
2. kallsyms_num_syms
3. kallsyms_names
4. kallsyms_markers
5. kallsyms_seqs_of_names (uniquement 6.2+)
6. kallsyms_token_table
7. kallsyms_token_index

Pour les kernels Linux 6.4+, cette disposition est modifiée comme suit :

1. kallsyms_num_syms
2. kallsyms_names
3. kallsyms_markers
4. kallsyms_token_table
5. kallsyms_token_index
6. kallsyms_addresses (ou kallsyms_offsets + kallsyms_relative_base)
7. kallsyms_seqs_of_names

Tandis qu'ils sont analysés dans l'ordre suivant par l'algorithme d'analyse de vmlinux-to-elf :

1. kallsyms_token_table (avant-dernière structure)
2. kallsyms_token_index (dernière structure, en avant)
3. kallsyms_markers (en arrière)
4. kallsyms_names (encore en arrière)
5. kallsyms_num_syms (encore en arrière)
6. kallsyms_addresses (ou kallsyms_offsets + kallsyms_relative_base) (encore en arrière)

Prise en charge des kernels

Il devrait prendre en charge les kernels de la version 2.6.10 (décembre 2004) jusqu'à la version actuelle 6.4 (en date d'août 2023). Seuls les kernels explicitement configurés sans CONFIG_KALLSYMS ne devraient pas être pris en charge. Si cette variable de configuration du kernel n'a pas été définie lors de la compilation, vous obtiendrez : KallsymsNotFoundException: No embedded symbol table found in this kernel.

Pour les kernels bruts, les architectures suivantes peuvent être détectées (en utilisant les signatures magiques de binwalk) : MIPSEL, MIPSEB, ARMEL, ARMEB, PowerPC, SPARC, x86, x86-64, ARM64, MIPS64, SuperH, ARC.

Les formats de compression de kernel suivants peuvent être automatiquement détectés : XZ, LZMA, GZip, BZ2, LZ4, LZO et Zstd.

Utilisation avancée

Vous pouvez également obtenir une sortie textuelle uniquement des noms, adresses et types de symboles du kernel en utilisant l'utilitaire kallsyms-finder, également fourni avec cet outil. Le format de sa sortie sera similaire au fichier procfs /proc/kallsyms.

Certains paramètres qui devraient être automatiquement déduits par l'outil (tels que le jeu d'instructions ou l'adresse de base) peuvent être remplacés en cas de problème. La spécification complète des arguments permettant de le faire est présentée ci-dessous :

$ vmlinux-to-elf -h
usage: vmlinux-to-elf [-h] [--e-machine DECIMAL_NUMBER] [--bit-size BIT_SIZE]
                      [--file-offset HEX_NUMBER] [--base-address HEX_NUMBER]
                      [--bss-size BSS_SIZE] [--use-absolute]
                      input_file output_file

Turn a raw or compressed kernel binary, or a kernel ELF without symbols, into a fully analyzable ELF whose symbols were extracted from the kernel symbol table

positional arguments:
  input_file            Path to the vmlinux/vmlinuz/zImage/bzImage/kernel.bin/kernel.elf file to make into an analyzable .ELF
  output_file           Path to the analyzable .ELF to output

options:
  -h, --help            show this help message and exit
  --e-machine DECIMAL_NUMBER
                        Force overriding the output ELF "e_machine" field with this integer value (rather than auto-detect)
  --bit-size BIT_SIZE   Force overriding the input kernel bit size, providing 32 or 64 bit (rather than auto-detect)
  --file-offset HEX_NUMBER
                        Consider that the raw kernel starts at this offset of the provided raw file or compressed stream (rather than 0, or the beginning of the ELF
                        sections if an ELF header was present in the input)
  --base-address HEX_NUMBER
                        Force overriding the output ELF base address field with this integer value (rather than auto-detect)
  --bss-size BSS_SIZE   Size in megabytes of the .bss section in the binary
  --use-absolute        Assume kallsyms offsets are absolute addresses

Comment le code source est-il organisé ?

Corrections de bugs, améliorations, etc.

N'hésitez pas à ouvrir un ticket pour toute suggestion d'amélioration.

Veuillez privilégier en priorité les tickets et les pull requests du dépôt Github actuel pour signaler des bugs, poser des questions, etc.

Vous pouvez également utiliser ce canal matrix si vous avez besoin de contacter directement l'auteur du projet, mais veuillez réserver cela comme canal secondaire, par exemple pour envoyer des échantillons de kernels ; ce qui y est envoyé autrement risque plus probablement d'être perdu.