dlinject.py

Injetar uma biblioteca compartilhada (ou seja, código arbitrário) em um processo linux ativo, sem ptrace. Inspirado por Cexigua e linux-inject, entre outros.

Uso

    .___.__  .__            __               __
  __| _/|  | |__| ____     |__| ____   _____/  |_  ______ ___.__.
 / __ | |  | |  |/    \    |  |/ __ \_/ ___\   __\ \____ <   |  |
/ /_/ | |  |_|  |   |  \   |  \  ___/\  \___|  |   |  |_> >___  |
\____ | |____/__|___|  /\__|  |\___  >\___  >__| /\|   __// ____|
     \/              \/\______|    \/     \/     \/|__|   \/

source: https://github.com/DavidBuchanan314/dlinject

usage: dlinject.py [-h] [--stopmethod {sigstop,cgroup_freeze,none}]
                   pid /path/to/lib.so

Injetar uma biblioteca compartilhada em um processo ativo.

argumentos posicionais:
  pid                   O pid do processo alvo
  /caminho/para/lib.so       Caminho da biblioteca compartilhada a carregar (nota: deve ser relativo ao cwd do processo alvo, ou absoluto)

argumentos opcionais:
  -h, --help            exibe esta mensagem de ajuda e sai
  --stopmethod {sigstop,cgroup_freeze,none}
                        Como parar o processo alvo antes da injeção do shellcode. SIGSTOP (padrão) pode ter efeitos colaterais. cgroup freeze requer root. 'none' provavelmente causará condições de corrida.

Por quê?

• Porque eu posso.

• Existem várias técnicas anti-ptrace, que este método evita simplesmente não usando ptrace.

• Eu não gosto de ptrace.

• Usar LD_PRELOAD pode às vezes ser complicado ou impossível, se o processo que você deseja injetar for gerado por outro processo com um ambiente limpo.

Como funciona

• Enviar o sinal de parada ao processo alvo. (opcional)

• Localizar o símbolo _dl_open().

• Obter RIP e RSP via /proc/[pid]/syscall.

• Fazer um backup de parte da pilha e do código que iremos sobrescrever com nosso shellcode, lendo de /proc/[pid]/mem.

• Gerar buffers de shellcode primário e secundário.

• Inserir shellcode primário em RIP, escrevendo em /proc/[pid]/mem.

• O shellcode primário:

  • Empurra registradores comuns para a pilha.
  • Carrega o shellcode secundário via mmap().
  • Salta para o shellcode secundário.

• O shellcode secundário:

  • Restaura a pilha e o código do programa aos seus estados originais.
  • Pivota a pilha (para não tocarmos na original).
  • Chama _dl_open() para carregar a biblioteca especificada pelo usuário. Quaisquer construtores serão executados no carregamento, como de costume.
  • Restaura o estado dos registradores, desfaz o pivô da pilha e salta de volta para onde estava no momento do original.

Limitações:

• Enviar SIGSTOP pode causar efeitos colaterais indesejados, por exemplo, se outra thread estiver esperando em waitpid(). A opção --stopmethod=cgroup_freeze evita isso, mas requer root (na maioria das distros, pelo menos).

• Não tenho total certeza de como isso interagirá com aplicações complexas multi-thread. Certamente há potencial para quebras.

• Apenas Linux x86-64 (por enquanto - suporte para 32 bits poderia potencialmente ser adicionado).

• Requer root, ou configuração YAMA relaxada (echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope é útil durante testes).

• Se o processo alvo estiver em sandbox (ex.: filtros seccomp), pode não ter permissão para fazer mmap() no shellcode do segundo estágio, ou para fazer dlopen() da biblioteca.