Início / unix / Perguntas / 789699
Accepted
tresf
Asked: 2025-01-17 02:10:33 +0800 CST

Calcular deslocamento de bytes para unquashfs

  • 772

Estou tentando calcular o -ovalor para extrair um .AppImagearquivo usando unsquashfsarquiteturas/SOs estrangeiros, mas usando objdumpem vez de readelfpara tornar a solução mais compatível com SOs como o macOS.

unsquashfs

Usage:

-o BYTES, -offset BYTES
              skip BYTES at start of FILESYSTEM.  Optionally a suffix of K, M or G can be given to specify Kbytes, Mbytes or Gbytes respectively (default 0
              bytes).

Estou seguindo a orientação desta solução , que usa readelfpara calcular o -ovalor de deslocamento. Isso funciona muito bem no Ubuntu, mas não funciona no macOS devido à indisponibilidade geral de readelf.

No entanto, eu gostaria de usar objdumpif possible. Eu encontrei algumas perguntas que explicam como encontrar o ponto de entrada/deslocamento de um executável binário, mas não importa quais valores eu tente, não consigo encontrar uma maneira de obter o valor correto para unsquashfs. Estou convertendo valores hexadecimais para decimais, mas nada de objdumpcorresponde aos readelfvalores abaixo, mesmo usando a equação do Employed Russian ehdr->e_entry - phdr->p_vaddr + phdr->p_offset. .

Por exemplo, veja o AppImage do Audacity:

https://github.com/audacity/audacity/releases/download/Audacity-3.7.1/audacity-linux-3.7.1-x64-22.04.AppImage
  • Chamar readelf -h audacity-linux-3.7.1-x64-22.04.AppImageme dá alguns valores úteis, como Start of section headers, Size of section headers, Number of section headers.
  • Em seguida, usando a lógica de Martin Vyskočil $START_OF_SECTION + $SECTION_SIZE * $SECTION_NO , posso obter um valor correto de 191680 + 64 * 32, que é 193728.
  • O comando a seguir é bem-sucedido (no macOS e no Ubuntu): 
    unsquashfs -o 193728 audacity-linux-3.7.1-x64-22.04.AppImage squashfs-root

... mas como posso calcular esse valor de deslocamento com objdumpem vez de readelf?

bash

1 respostas

  1. Best Answer

    Se você ler os bytes corretos do arquivo ELF (com uma ferramenta que pode processar arquivos binários como python, perl, etc...), então você não precisa readelf -hnem objdumpum pouco.

    Um arquivo ELF começa com um cabeçalho parecido com este (veja man elfpara uma versão não modificada):

    typedef struct {
    unsigned char e_ident[16]; // ELF Identification (16 bytes)
    uint16_t      e_type;      // Type of file
    uint16_t      e_machine;   // Required architecture for this file
    uint32_t      e_version;   // Must be equal to 1
    uintN_t       e_entry;     // Address to jump to in order to start program
    uintN_t       e_phoff;     // Program header table's file offset, in bytes
    uintN_t       e_shoff;     // Section header table’s file offset, in bytes
    uint32_t      e_flags;     // Processor-specific flags
    uint16_t      e_ehsize;    // Size of ELF header, in bytes
    uint16_t      e_phentsize; // Size of an entry in the program header table
    uint16_t      e_phnum;     // Number of entries in the program header table
    uint16_t      e_shentsize; // Size of an entry in the section header table
    uint16_t      e_shnum;     // Number of entries in the section header table
    uint16_t      e_shstrndx;  // Sect hdr table index of sect name string table
};

    nota: o Nin uintN_tpode ser 32ou 64.

    Calculando o deslocamento necessário porunsquashfs

    Para calcular, SECTION_OFFSET + SECTION_SIZE * SECTION_NOvocê tem que extrair e_shoff, e_shentsizee e_shnumdo cabeçalho ELF. O problema é que a localização exata deles depende da bitness (32 ou 64 bits) do arquivo ELF, e a ordem dos bytes deles depende da endianness (little ou big endian).

    A quantidade de bits e a quantidade de endianidade de um arquivo ELF são armazenadas em:

    • e_ident[4](indexado 0): com 0x01representação para 32 bits e 0x02para 64 bits.
    • e_ident[5](0-indexado): com 0x01representação para little-endian e 0x02para big-endian.

    Depois de ler esses dois bytes, você saberá "onde" e "como" ler e_shoff, e_shentsizecom e_shnumprecisão.

    Solução Python

    O pythoncomando a seguir faz exatamente como descrito acima e então gera e_shoff + e_shentsize * e_shnum:

    python -c 'if 1:
    import os, struct;
    elfHeader = os.read(0, 64);
    (bitness,endianness) = struct.unpack("4x B B 58x", elfHeader);
    (shoff,shentsize,shnum) = struct.unpack(
        (">" if endianness == 2 else "<") +
        ("40x Q 10x H H 2x" if bitness == 2 else "32x L 10x H H 14x"),
        elfHeader
    );
    print(shoff + shentsize * shnum)
' < audacity-linux-3.7.1-x64-22.04.AppImage

    saída:

    193728

    nota: funciona com Python 2 e 3 e qualquer bitness e endianness de CPU.

    Solução POSIX

    Como um cabeçalho ELF tem no máximo 64 bytes de comprimento, não é muito difícil traduzir esses bytes para texto e processar o resultado. Tudo isso pode ser feito com ferramentas padrão de uma forma padrão:

    #!/bin/sh
od -v -t x1 -N 64 -- audacity-linux-3.7.1-x64-22.04.AppImage |
awk ' 
    {$1 = ""; elfHeader = elfHeader " " $0}
    END {
        $0 = toupper(elfHeader);
        is64Bits = $5 == "02";
        isBigEndian = $6 == "02";
        if (is64Bits) {
            if (isBigEndian) {
                shoff = $41 $42 $43 $44 $45 $46 $47 $48;
                shentsize = $59 $60;
                shnum = $61 $62;
            } else {
                shoff = $48 $47 $46 $45 $44 $43 $42 $41;
                shentsize = $60 $59;
                shnum = $62 $61;
            }
        } else {
            if (isBigEndian) {
                shoff = $33 $34 $35 $36;
                shentsize = $47 $48;
                shnum = $49 $50;
            } else {
                shoff = $36 $35 $34 $33;
                shentsize = $48 $47;
                shnum = $50 $49;
            }
        }
        print "ibase=16;" shoff "+" shentsize "*" shnum
    }
' |
bc

    saída:

    193728

    nota: funciona com qualquer UNIX/Linux e qualquer bitness e endianness de CPU.

    • 3

relate perguntas