dlinject.py

Inyecta una biblioteca compartida (es decir, código arbitrario) en un proceso linux en vivo, sin ptrace. Inspirado por Cexigua y linux-inject, entre otras cosas.

Uso

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

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

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

Inject a shared library into a live process.

positional arguments:
  pid                   The pid of the target process
  /path/to/lib.so       Path of the shared library to load (note: must be
                        relative to the target process's cwd, or absolute)

optional arguments:
  -h, --help            show this help message and exit
  --stopmethod {sigstop,cgroup_freeze,none}
                        How to stop the target process prior to shellcode
                        injection. SIGSTOP (default) can have side-effects.
                        cgroup freeze requires root. 'none' is likely to cause
                        race conditions.

¿Por qué?

• Porque puedo.

• Existen varias técnicas anti-ptrace, las cuales esto evade simplemente no usando ptrace.

• No me gusta ptrace.

• Usar LD_PRELOAD a veces puede ser complicado o imposible, si el proceso que quieres inyectar es generado por otro proceso con un entorno limpio.

Cómo funciona

• Enviar la señal de parada al proceso objetivo. (opcional)

• Localizar el símbolo _dl_open().

• Obtener RIP y RSP a través de /proc/[pid]/syscall.

• Hacer una copia de seguridad de parte de la pila y del código que vamos a sobrescribir con nuestro shellcode, leyendo desde /proc/[pid]/mem.

• Generar buffers de shellcode primario y secundario.

• Insertar shellcode primario en RIP, escribiendo en /proc/[pid]/mem.

• El shellcode primario:

  • Empuja los registros comunes a la pila.
  • Carga el shellcode secundario mediante mmap().
  • Salta al shellcode secundario.

• El shellcode secundario:

  • Restaura la pila y el código del programa a sus estados originales.
  • Desvía la pila (para no tocar la original en absoluto).
  • Llama a _dl_open() para cargar la biblioteca especificada por el usuario. Cualquier constructor se ejecutará al cargarlo, como es habitual.
  • Restaura el estado de los registros, desvía la pila y salta de vuelta a donde estaba en el momento del original.

Limitaciones:

• Enviar SIGSTOP puede causar efectos secundarios no deseados, por ejemplo si otro hilo está esperando en waitpid(). La opción --stopmethod=cgroup_freeze evita esto, pero requiere root (en la mayoría de las distribuciones, al menos).

• No estoy completamente seguro de cómo esto interactuará con aplicaciones complejas de múltiples hilos. Ciertamente hay potencial para fallos.

• Solo Linux x86-64 (por ahora: el soporte de 32 bits podría agregarse potencialmente).

• Requiere root, o configuración YAMA relajada (echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope es útil al probar).

• Si el proceso objetivo está en un entorno aislado (por ejemplo, filtros seccomp), es posible que no tenga permiso para hacer mmap() del shellcode de segunda etapa, o para dlopen() la biblioteca.