vmlinux-to-elf

Esta ferramenta permite obter um arquivo .ELF totalmente analisável a partir de uma imagem de kernel vmlinux/vmlinuz/bzImage/zImage (seja um blob binário bruto ou um arquivo .ELF pré-existente, porém sem símbolos), com símbolos de funções e variáveis recuperados.

Para isso, ela verifica o seu kernel em busca de uma tabela de símbolos do kernel (kallsyms), uma tabela de símbolos compactada que está presente em quase todos os kernels, quase sem alterações.

Como a tabela de símbolos em questão é originalmente compactada, ela deve recuperar strings que não são visíveis no binário original.

Ela produz um arquivo .ELF que você pode analisar usando IDA Pro e Ghidra. Portanto, esta ferramenta é útil para engenharia reversa de sistemas embarcados.

Uso:

# Command line:
vmlinux-to-elf <input_kernel.bin> <output_kernel.elf>

# Command line, list symbol addresses only:
kallsyms-finder <input_kernel.bin> # If installed with uv
vmlinux-to-elf.kallsyms-finder # If installed with snap

# Command line, just decompress the kernel:
vmlinuz-decompressor <input_kernel.bin> <output_kernel.bin> # If installed with uv
vmlinux-to-elf.vmlinuz-decompressor # If installed with snap

# Graphical:
vmlinux-to-elf-gui # If installed with uv
vmlinux-to-elf.gui # If installed with snap
flatpak run re.fossplant.vmlinux-to-elf # If installed with flatpak

Instalação:

# Install CLI+GUI with Snap (recommended on Ubuntu)
sudo snap install vmlinux-to-elf

# Install CLI+GUI with yay (recommended on Arch, Manjaro)
yay -S vmlinux-to-elf libadwaita python-gobject

# Install CLI+GUI with uv (example with 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 # Install .desktop file

# Install CLI with uv and GUI with Flatpak (recommended on
# distributions with 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

Configuração do ambiente de desenvolvimento local:

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

# Dependencies for the GTK-4 GUI
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/
# Download Python modules and initialize virtualenv (creates ".venv",
# call "source .venv/bin/activate" to set up)
uv sync --extra gui
# Add vmlinux-to-elf to $PATH, so that the commands are callable
# system-wide (creates a symlink to the source in "~/.local/bin")
uv tool install -e .[gui]

Recursos

• Aceitar um blob binário bruto ou arquivo de kernel ELF como entrada [OK]
• Detectar e descompactar automaticamente os principais formatos de compressão usados pelo kernel Linux [OK]
• Encontrar e extrair a tabela de símbolos do kernel embutida (kallsyms) do arquivo de entrada [OK]
• Inferir a arquitetura do conjunto de instruções, o endianness e o tamanho de bits, contando, entre outras coisas, com assinaturas comuns de prólogo de funções [OK]
• Inferir o ponto de entrada do kernel a partir dos símbolos contidos na tabela kallsyms [OK]
• Fornecer inferência básica para o endereço base do kernel [OK] (por enquanto, considere que é o endereço do primeiro símbolo "TEXT" do binário com os bits 0xfff inferiores zerados - parece funcionar bem o suficiente)
• Desempacotar certos tipos de arquivos boot.img do Android, começando com uma magia ANDROID! ou UNCOMPRESSED_IMG [OK]
• Produzir um arquivo .ELF totalmente analisável com IDA Pro ou Ghidra como saída [OK]

Como isso realmente funciona?

Uma breve história da tabela de símbolos "kallsyms" pode ser encontrada no topo do arquivo "kallsyms.py". Resumidamente, ela foi introduzida por volta de 2004 no kernel Linux em sua forma atual e é usada para imprimir as mensagens de "Kernel oops", entre outras coisas.

Ela contém tuplas de "nome do símbolo", "endereço do símbolo", "tipo do símbolo" (os tipos de símbolo são designados com uma única letra, de maneira semelhante ao utilitário nm), sendo essas informações compactadas de forma densa com um algoritmo de compressão simples.

O esquema abaixo mostra como essas informações são serializadas no kernel, sendo o offset de cada estrutura respectiva detectado pelo vmlinux-to-elf por meio de heurísticas:

Esses campos têm alinhamento e tamanho de campo variáveis. Os tamanhos dos campos também podem variar conforme a arquitetura e a versão do kernel. Por esse motivo, o vmlinux-to-elf foi testado em uma variedade de casos.

O OpenWRT desde 2013 possui um patch que remove a compressão da tabela kallsyms por padrão (quando a compilação de kallsyms foi habilitada pelo usuário). Eles fazem isso para economizar espaço ao recompactar o kernel usando LZMA.

Isso significa que as entradas kallsyms_token_table e kallsyms_token_address desaparecem, e que os nomes dos símbolos usam ASCII em texto simples. Esse caso também é suportado.

Em kernels Linux 6.2 padrão, os arrays kallsyms são codificados na seguinte ordem:

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

Para kernels Linux 6.4+, este layout é alterado para:

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

Embora estes sejam analisados na seguinte ordem pelo algoritmo de análise do vmlinux-to-elf:

1. kallsyms_token_table (estrutura penúltima)
2. kallsyms_token_index (última estrutura, para frente)
3. kallsyms_markers (para trás)
4. kallsyms_names (para trás novamente)
5. kallsyms_num_syms (para trás novamente)
6. kallsyms_addresses (ou kallsyms_offsets + kallsyms_relative_base) (para trás novamente)

Suporte a kernels

Deve suportar kernels desde a versão 2.6.10 (dezembro de 2004), até a atual 6.4 (em agosto de 2023). Apenas kernels explicitamente configurados sem CONFIG_KALLSYMS não devem ser suportados. Se esta variável de configuração do kernel não foi definida na compilação, então você obterá: KallsymsNotFoundException: No embedded symbol table found in this kernel.

Para kernels brutos, as seguintes arquiteturas podem ser detectadas (usando magias do binwalk): MIPSEL, MIPSEB, ARMEL, ARMEB, PowerPC, SPARC, x86, x86-64, ARM64, MIPS64, SuperH, ARC.

Os seguintes formatos de compressão de kernel podem ser detectados automaticamente: XZ, LZMA, GZip, BZ2, LZ4, LZO e Zstd.

Uso avançado

Você também pode obter uma saída somente em texto dos nomes, endereços e tipos de símbolos do kernel usando o utilitário kallsyms-finder, também incluído nesta ferramenta. O formato da saída será semelhante ao arquivo procfs /proc/kallsyms.

Alguns parâmetros que devem ser inferidos automaticamente pela ferramenta (como o conjunto de instruções ou o endereço base) podem ser sobrescritos em caso de problema. A especificação completa dos argumentos que permitem fazer isso é apresentada abaixo:

$ 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

Como o código-fonte está organizado?

Correções de bugs, melhorias, etc.

Não hesite em abrir uma issue para qualquer sugestão de melhoria.

Por favor, priorize as issues e pull requests do repositório atual do Github para relatar bugs, fazer perguntas, etc.

Alternativamente, você pode usar este canal matrix se precisar entrar em contato diretamente com o autor do projeto, mas reserve-o como um canal secundário, por exemplo, para envio de amostras de kernel; caso contrário, o que for postado aqui provavelmente se perderá.