Como testar se um binário Linux foi compilado como código independente de posição?

Recentemente eu aprendi que (pelo menos no Fedora e Red Hat Enterprise Linux), os programas executáveis ​​que são compilados como PIE (Position Independent Executables) recebem proteção mais forte de randomização do espaço de endereço (ASLR).

Então: como testar se um executável específico foi compilado como um executável independente de posição, no Linux?

Você pode usar o perlscript contido no hardening-checkpacote, disponível no Fedora e Debian (as hardening-includes). Leia esta página wiki da Debian para obter detalhes sobre quais sinalizadores de compilação são verificados. É específico do Debian, mas a teoria se aplica ao Red Hat também.

Exemplo:

$ hardening-check $(which sshd)
/usr/sbin/sshd:
 Position Independent Executable: yes
 Stack protected: yes
 Fortify Source functions: yes (some protected functions found)
 Read-only relocations: yes
 Immediate binding: yes

Eu costumava readelf --relocstestar se a biblioteca estática ou dinâmica é PIC em x86-64 da seguinte maneira:

$ readelf --relocs /usr/lib/gcc/x86_64-linux-gnu/4.6/libstdc++.a |\
      awk '$3~/^R_/ && $5!~/^\.debug/{print $3}' |sort -u
R_X86_64_32
R_X86_64_32S
R_X86_64_64
R_X86_64_DTPOFF32
R_X86_64_GOTPCREL
R_X86_64_PC32
R_X86_64_PLT32
R_X86_64_TLSLD
R_X86_64_TPOFF32

Nós vemos aqui R_X86_64_32e R_X86_64_32S. Isso significa que o código não é independente de posição. Quando reconstruo uma biblioteca com -fPIC, recebo:

$ readelf --relocs libstdc++.a |\
      awk '$3~/^R_/ && $5!~/^\.debug/{print $3}' |sort -u
R_X86_64_64
R_X86_64_DTPOFF32
R_X86_64_GOTPCREL
R_X86_64_PC32
R_X86_64_PLT32
R_X86_64_TLSGD
R_X86_64_TLSLD

Esse método provavelmente pode funcionar para executáveis, mas eu não o usei dessa maneira.

Basta usar fileno binário:

$ file ./pie-off
./pie-off: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=0dc3858e9f0334060bfebcbe3e854909191d8bdc, not stripped
$ file ./pie-on
./pie-on: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=962235df5bd188e1ec48c151ff61b6435d395f89, not stripped

Observe o tipo diferente impresso após as informações do LSB.

file 5.36 diz claramente

file5.36 realmente imprime claramente se o executável é TORTA ou não. Por exemplo, um executável PIE mostra como:

main.out: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, not stripped

e um não-TORTA como:

main.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

O recurso foi introduzido na 5.33, mas fez apenas uma chmod +xverificação simples . Antes disso, apenas imprimia shared objectpara TORTA.

Na versão 5.34, ele deveria começar a verificar os DF_1_PIEmetadados ELF mais especializados , mas devido a um erro na implementação, ele realmente quebrou as coisas e mostrou os executáveis ​​do GCC PIE como shared objects.

Eu interpretei o filecódigo fonte, incluindo o bug, e exatamente quais bytes do formato ELF ele verifica com detalhes excruciantes em: https://stackoverflow.com/questions/34519521/why-does-gcc-create-a-shared-object de acordo com um binário executável de acordo com / 55704865 # 55704865

Um resumo rápido do comportamento do arquivo 5.36 é:

• E se Elf32_Ehdr.e_type == ET_EXEC
  • impressão executable
• senão se Elf32_Ehdr.e_type == ET_DYN
  • se DT_FLAGS_1a entrada de seção dinâmica estiver presente
    • se DF_1_PIEestiver definido em DT_FLAGS_1:
      • impressão pie executable
    • outro
      • impressão shared object
  • outro
    • se o arquivo é executável por usuário, grupo ou outros
      • impressão pie executable
    • outro
      • impressão shared object

O GDB executa o executável duas vezes e consulte ASLR

Uma coisa muito direta que você pode fazer é executar o executável duas vezes através do GDB e verificar se o endereço muda entre as execuções devido ao ASLR.

Expliquei como fazer isso em detalhes em: https://stackoverflow.com/questions/2463150/what-is-the-fpie-option-for-position-independent-executables-in-gcc-and-ld/51308031 # 51308031

Embora essa não seja necessariamente a solução mais prática e não seja possível se você não confia no executável, é divertido e faz a verificação final com a qual realmente nos preocupamos, ou seja, se o kernel / carregador dinâmico do Linux altera o local do executável ou não.

Existe o script bash checksec.sh no Github para verificar as propriedades de atenuação dos executáveis ​​(incluindo RELRO, Stack Canary, NX bit, PIE, RPATH, RUNPATH, Fortify Source).

Execute checkseccom -fargumentos (entrada de arquivo):

$ checksec -f /usr/bin/bash

RELRO           STACK CANARY      NX            PIE             RPATH     RUNPATH      FORTIFY Fortified Fortifiable
Full RELRO      Canary found      NX enabled    PIE enabled     No RPATH   No RUNPATH    YES      13        33