libdebug

libdebug

libdebug es una biblioteca Python de código abierto para automatizar la depuración de un ejecutable binario.

Con libdebug tienes control total del flujo de tu ejecutable depurado. Con él podrás:

• Acceder a la memoria del proceso y a los registros.
• Controlar el flujo de ejecución del proceso.
• Manejar y secuestrar llamadas al sistema
• Captar y secuestrar señales
• Depure aplicaciones multiproceso con facilidad
• Cambie sin problemas a GDB para realizar análisis interactivos
• Multiarch: actualmente soporta Linux AMD64 y AArch64 e i386 (tanto nativo como en modo de compatibilidad de 32 bits)

Cuando se ejecuta el mismo ejecutable varias veces, elegir implementaciones eficientes puede marcar la diferencia. Por este motivo, libdebug prioriza el rendimiento.

Enlaces de proyectos

Página de inicio: https://libdebug.org
Documentación: https://docs.libdebug.org

Requisitos de instalación:

Ubuntu:
sudo apt install -y python3 python3-dev libdwarf-dev libelf-dev libiberty-dev linux-headers-generic libc6-dbg
Debian:
sudo apt install -y python3 python3-dev libdwarf-dev libelf-dev libiberty-dev linux-headers-generic libc6-dbg
Arco Linux:
sudo pacman -S python libelf libdwarf gcc make debuginfod
Fedor:
sudo dnf install -y python3 python3-devel kernel-devel binutils-devel libdwarf-devel

Instalación

python3 -m pip install libdebug

PyPy3 es compatible pero no recomendado, ya que funciona peor en la mayoría de nuestras pruebas.

Si desea mantenerse actualizado con las funciones más innovadoras (y no le importa estar en una rama inestable), puede instalar desde una rama diferente (por ejemplo, dev).

python3 -m pip install git+https://github.com/libdebug/libdebug.git@dev

Tu primer guión

Ahora que tiene instalado libdebug, puede comenzar a usarlo en sus scripts. Aquí hay un ejemplo simple de cómo usar libdebug para depurar un binario:

 from libdebug import debugger

d = debugger ( "./test" )

# Start debugging from the entry point
d . run ()

my_breakpoint = d . breakpoint ( "function" )

# Continue the execution until the breakpoint is hit
d . cont ()

# Print RAX
print ( f"RAX is { hex ( d . regs . rax ) } " )

# Write to memory
d . memory [ 0x10ad , 8 , "binary" ] = b"Hello! x00 x00 "

# Continue the execution
d . cont ()

El script anterior ejecutará la test binaria en el directorio de trabajo y se detendrá en la función correspondiente al símbolo "función". Luego imprimirá el valor del registro RAX y finalizará el proceso.

Hay mucho más que se puede hacer con libdebug. Lea la documentación para obtener más información.

las cosas interesantes

libdebug ofrece muchas funciones avanzadas. Echa un vistazo a este script que hace magia con señales:

 from libdebug import debugger , libcontext

libcontext . terminal = [ 'tmux' , 'splitw' , '-h' ]

# Define signal catchers
def catcher_SIGUSR1 ( t : ThreadContext , catcher : SignalCatcher ) -> None :
    t . signal = 0x0
    print ( f"SIGUSR1: Signal number { catcher } " )

def catcher_SIGINT ( t : ThreadContext , catcher : SignalCatcher ) -> None :
    print ( f"SIGINT: Signal number { catcher } " )

def catcher_SIGPIPE ( t : ThreadContext , catcher : SignalCatcher ) -> None :
    print ( f"SIGPIPE: Signal number { catcher } " )

def handler_geteuid ( t : ThreadContext , handler : SyscallHandler ) -> None :
	t . regs . rax = 0x0

# Initialize the debugger
d = debugger ( '/path/to/executable' , continue_to_binary_entrypoint = False , aslr = False )

# Register signal catchers
catcher1 = d . catch_signal ( "SIGUSR1" , callback = catcher_SIGUSR1 )
catcher2 = d . catch_signal ( "SIGINT" , callback = catcher_SIGINT )
catcher3 = d . catch_signal ( "SIGPIPE" , callback = catcher_SIGPIPE )

# Register signal hijackings
d . hijack_signal ( "SIGQUIT" , "SIGTERM" )
d . hijack_signal ( "SIGINT" , "SIGPIPE" , recursive = True )

# Define which signals to block
d . signals_to_block = [ "SIGPOLL" , "SIGIO" , "SIGALRM" ]

d . handle_syscall ( "geteuid" , on_exit = handler_geteuid )

# Continue execution
d . cont ()

# Disable the catchers after execution
catcher1 . disable ()
catcher2 . disable ()
catcher3 . disable ()

bp = d . breakpoint ( 0xdeadc0de , hardware = True )

d . cont ()
d . wait ()

d . gdb ()

Interrupción automática al comando

libdebug también le permite ejecutar todos los comandos lo antes posible, sin tener que esperar a que se detenga un evento. Para habilitar este modo, puede usar auto_interrupt_on_command=True

 from libdebug import debugger

d = debugger ( "/path/to/executable" , auto_interrupt_on_command = True )

pipes = d . run ()

bp = d . breakpoint ( "function" )

d . cont ()

# Read shortly after the cont is issued
# The process is forcibly stopped to read the register
value = d . regs . rax
print ( f"RAX is { hex ( value ) } " )

system_offset = d . symbols . filter ( "system" )[ 0 ]. start
libc_base = d . maps . filter ( "libc" )[ 0 ]. base

system_address = libc_base + system_offset

d . memory [ 0x12ebe , 8 , "libc" ] = int . to_bytes ( system_address , 8 , "little" )

d . cont ()
d . wait ()

# Here we should be at the breakpoint

# This value is read while the process is stopped at the breakpoint
ip_value = d . regs . rip

print ( f"RIP is { hex ( ip_value ) } " )

d . kill ()

Atribución

Si tiene la intención de utilizar libdebug en su trabajo, cite este repositorio utilizando el siguiente biblatex:

 @software{libdebug_2024,
	title = {libdebug: {Build} {Your} {Own} {Debugger}},
	copyright = {MIT Licence},
	url = {https://libdebug.org},
	publisher = {libdebug.org},
	author = {Digregorio, Gabriele and Bertolini, Roberto Alessandro and Panebianco, Francesco and Polino, Mario},
	year = {2024},
	doi = {10.5281/zenodo.13151549},
}