Hexedit en Español: Uso y Comandos

https://www.onlinetis.com/es/

Hexedit en Español: Uso y Comandos

Veo que estás explorando las herramientas de análisis de archivos en Kali Linux. ncurses-hexedit (comúnmente invocado simplemente como hexedit) es un editor hexadecimal basado en terminal que te permite ver y modificar archivos bit a bit.

Aquí tienes una guía rápida sobre cómo instalarlo y usarlo, ya que su interfaz es minimalista y no tiene menús en español de forma nativa.

1. Instalación

Si no lo tienes instalado en tu Kali, abre la terminal y ejecuta:

Bash

sudo apt update && sudo apt install ncurses-hexedit

2. Cómo abrir un archivo

Para empezar a editar, simplemente escribe el comando seguido de la ruta del archivo:

Bash

hexedit nombre_del_archivo

3. Controles y Atajos (en español)

Dado que la herramienta no tiene una traducción oficial al español en su interfaz, aquí tienes el "diccionario" de los comandos más importantes:

Acción	Atajo de teclado
Guardar cambios	`Ctrl + W`
Salir (sin guardar)	`Ctrl + C`
Ir a una dirección (Offset)	`Ctrl + G`
Buscar una cadena/valor	`Ctrl + S`
Cambiar entre Hexadecimal y ASCII	`Tab`
Ayuda rápida	`F1` o `Ctrl + H`
Deshacer cambios	`Ctrl + U`

Consejos útiles para Kali

Modo de solo lectura: Si solo quieres analizar un archivo sospechoso sin riesgo de corromperlo, usa el parámetro -r:
hexedit -r archivo
Interpretación: La columna de la izquierda es la dirección (offset), la central es el contenido en hexadecimal y la derecha es la representación en ASCII.
Cuidado con el tamaño: Si escribes más bytes de los que el archivo tiene originalmente, hexedit te preguntará si deseas truncar o expandir el archivo al intentar guardar.

Nota: hexedit es muy potente pero no tiene "Ctrl+Z" infinito. Siempre es buena idea trabajar sobre una copia del archivo original si estás haciendo ingeniería inversa o forense.

Saltar a una dirección específica (conocida como Offset) es fundamental cuando ya sabes dónde se encuentra el código o los datos que quieres analizar (por ejemplo, tras encontrar un punto de interés en un desensamblador).

En hexedit, el proceso es muy directo:

Paso a paso para saltar a una dirección

Presiona Ctrl + G: Esto abrirá un prompt en la parte inferior de la pantalla que dice Goto offset:.
Ingresa la dirección:
- Puedes escribirla en hexadecimal (por defecto). No es necesario poner 0x al principio, aunque el programa lo suele entender.
- Si prefieres usar decimal, puedes poner el número seguido de una d (ejemplo: 1024d).
Presiona Enter: El cursor se posicionará instantáneamente en el primer byte de esa dirección.

Entendiendo las Direcciones (Offsets)

Para no perderte mientras navegas, recuerda cómo leer la interfaz:

La columna de la izquierda: Indica la dirección base de esa línea. Si ves 00000010, significa que el primer byte de esa fila es el byte número 16 (en decimal) del archivo.
Cálculo rápido: Si estás en la línea 000000A0 y tu cursor está en la quinta pareja de números hexadecimales, tu posición exacta es 000000A4.

Atajos de navegación rápida

Si no tienes una dirección exacta pero quieres moverte rápido, usa estos comandos:

Inicio (Home): Salta al principio del archivo (offset 0).
Fin (End): Salta al último byte del archivo.
Re Pág / Av Pág: Sube o baja un bloque completo de datos en la pantalla.

Tip de experto: Si estás analizando un binario de Kali y ves algo como "Offset: 0x450" en otra herramienta, simplemente presiona Ctrl + G, escribe 450 y estarás ahí en un segundo.

Buscar cadenas de texto o valores hexadecimales específicos es como usar el "Busca y Reemplaza" de un editor de texto, pero a nivel de bits.

En hexedit, tienes dos formas principales de buscar: por texto (ASCII) o por valores (Hex).

Cómo buscar en ncurses-hexedit

Presiona Ctrl + S: Se abrirá un prompt en la parte inferior que dice Search for:.
Elige el formato:
- Para buscar texto: Escribe la palabra entre comillas (ejemplo: "password" o "error").
- Para buscar valores hex: Escribe los pares de números directamente (ejemplo: 41 41 41 para buscar tres letras "A" en mayúscula).
Presiona Enter: El cursor saltará a la primera coincidencia que encuentre desde tu posición actual hacia adelante.

Atajos de búsqueda avanzada

Atajo	Acción
`Ctrl + S`	Buscar hacia adelante (Forward Search).
`Ctrl + R`	Buscar hacia atrás (Reverse Search).
`Ctrl + N`	Buscar la siguiente aparición (Next).

Ejemplo práctico: Encontrar una "Flag" o Contraseña

Si sospechas que un binario tiene una clave oculta, puedes intentar buscar términos comunes:

Pulsa Ctrl + S.
Escribe "admin" o "key".
Si lo encuentra, el cursor se pondrá justo encima. A la derecha verás el texto legible y a la izquierda su valor en hexadecimal (por ejemplo, admin se ve como 61 64 6d 69 6e).

Un truco extra para Kali: `strings`

Antes de entrar a hexedit, a veces es más rápido usar el comando strings en la terminal de Kali para ver qué texto hay dentro del archivo sin abrir el editor:

Bash

strings nombre_del_archivo | grep "password"

Esto te dará una lista de todas las palabras legibles que contienen "password", y luego puedes usar hexedit para ir exactamente a donde están.

Modificar un binario es como una cirugía de precisión: un solo byte fuera de lugar y el programa podría dejar de funcionar (el famoso Segmentation Fault).

Aquí tienes las reglas de oro y los pasos para editar con ncurses-hexedit:

1. El modo de edición

Por defecto, hexedit está en modo de inserción desactivado. Esto es bueno, porque significa que cuando escribes algo, sobrescribes el byte actual en lugar de empujar todo el archivo hacia adelante (lo cual rompería las direcciones de memoria).

Para cambiar un valor Hex: Simplemente coloca el cursor sobre el par de números y escribe los nuevos (ej. cambia 00 por FF).
Para cambiar un texto (ASCII): Pulsa Tab para mover el cursor a la columna de la derecha y escribe las letras directamente.

2. Cómo guardar (y cómo NO guardar)

Una vez que hayas hecho tus cambios, verás que los bytes modificados suelen resaltar o cambiar de color.

Guardar cambios: Presiona Ctrl + W (Write). El programa te preguntará si estás seguro.
Salir sin guardar: Si te equivocas, presiona Ctrl + C inmediatamente. No se aplicará nada al archivo original.
Deshacer (Undo): Si aún no has guardado, Ctrl + U revierte el último cambio en el byte donde estás parado.

3. Ejemplo Práctico: Cambiar un mensaje

Imagina que un programa dice "Acceso Denegado" y quieres que diga "Acceso Aceptado".

Buscas "Denegado" con Ctrl + S.
Sobrescribes con "Aceptado".
¡Ojo con la longitud! "Denegado" tiene 8 letras y "Aceptado" tiene 8. Si la nueva palabra fuera más corta, deberías rellenar el espacio sobrante con bytes nulos (00 en hex), nunca con espacios normales si quieres mantener la estructura original.

4. El truco del "Patching" en Kali

Si estás haciendo retos de CTF o ingeniería inversa, a veces quieres anular una instrucción. El "maestro" de los cambios es el byte 90, que en arquitectura x86 significa NOP (No Operation).

Consejo Pro: Si quieres que el programa "salte" una comprobación de contraseña, a veces basta con localizar el salto condicional y llenarlo con 90 90 para que el programa siga de largo como si nada hubiera pasado.

Comparar dos archivos binarios es una técnica esencial en ingeniería inversa y análisis de malware para detectar qué bytes específicos han sido alterados (por ejemplo, después de aplicar un crack o un parche).

Aunque ncurses-hexedit es excelente para editar un solo archivo, para comparar dos archivos en Kali Linux lo ideal es usar herramientas complementarias que resaltan las diferencias de forma automática.

1. Usando `vbindiff` (Visual Binary Diff)

Esta es la herramienta más parecida a hexedit pero diseñada específicamente para comparar. Muestra los dos archivos uno encima del otro y resalta las diferencias.

Instalación:

Bash

sudo apt install vbindiff

Uso:

Bash

vbindiff archivo_original archivo_modificado

Navegación: Con la tecla Enter saltas directamente a la siguiente diferencia.
Edición: Puedes editar cualquiera de los dos archivos en tiempo real pulsando E.

2. Usando `dhex` (Otra joya de ncurses)

Si prefieres una interfaz más moderna y robusta que la de hexedit, dhex incluye un "Modo Diff" muy potente.

Instalación:

Bash

sudo apt install dhex

Uso:

Bash

dhex archivo1 archivo2

Te mostrará las diferencias en columnas paralelas. Es muy útil para ver cómo un cambio en una sección del binario afecta a las direcciones de memoria adyacentes.

3. El método rápido por terminal: `cmp`

Si solo quieres saber en qué posición (offset) empiezan las diferencias sin ver el contenido visualmente, usa el comando nativo de Linux:

Bash

cmp -l archivo1 archivo2 | head

Esto te devolverá una lista de los offsets donde los bytes no coinciden. Luego puedes abrir hexedit, pulsar Ctrl + G e ir a esa dirección exacta para ver qué pasó.

Resumen de comparación

Herramienta	Cuándo usarla
`vbindiff`	Para navegar visualmente entre diferencias saltando con `Enter`.
`dhex`	Si necesitas un análisis más detallado y estético.
`cmp`	Para un reporte rápido de texto en la terminal.

Dato curioso: Muchos analistas usan la comparación de binarios para entender cómo funcionan las partidas guardadas de los videojuegos. Cambian algo en el juego (como el oro), guardan, y comparan el archivo antes y después para encontrar el byte exacto que controla el dinero.

Crear un script en Bash es la forma más profesional de automatizar el "patching" (parcheo) de archivos cuando tienes que repetir la misma modificación en muchos binarios o quieres crear tu propio instalador de trucos/arreglos.

Para esto, usaremos una herramienta llamada printf, que nos permite escribir bytes exactos en una posición específica del archivo sin necesidad de abrir un editor manual como hexedit.

El Script: `patcher.sh`

Copia este código en un archivo nuevo (por ejemplo, nano patcher.sh):

Bash
#!/bin/bash

# Configuración
ARCHIVO="mi_binario"
OFFSET="0x450"      # La dirección donde quieres cambiar el byte
NUEVO_BYTE="\x90"   # El valor que quieres poner (ejemplo: NOP)

# 1. Hacer una copia de seguridad por seguridad
cp "$ARCHIVO" "$ARCHIVO.bak"

# 2. Aplicar el parche
# 'seek' se mueve al offset, 'bs=1' escribe de 1 en 1 byte
printf "$NUEVO_BYTE" | dd of="$ARCHIVO" bs=1 seek=$(($OFFSET)) conv=notrunc

echo "¡Parche aplicado en $OFFSET! Copia de seguridad creada como $ARCHIVO.bak"

Explicación de los comandos:

printf "$NUEVO_BYTE": Genera el valor binario que queremos insertar.
dd: Es la herramienta "maestra" de copiado de datos en Linux.
- of="$ARCHIVO": El archivo de destino.
- bs=1: Indica que trabaje con bloques de 1 byte.
- seek=$(($OFFSET)): Salta directamente a la dirección de memoria que le digas.
- conv=notrunc: CRÍTICO. Esto le dice a Linux que no borre el resto del archivo, solo que sobrescriba el byte en esa posición.

Cómo usarlo en Kali:

Dale permisos de ejecución:
Bash
```
chmod +x patcher.sh
```
Ejecútalo:
Bash
```
./patcher.sh
```

¿Cuándo es útil esto?

Automatización: Si descubres que cambiar el byte en 0x1A2 desactiva una licencia o un chequeo de seguridad, puedes pasarle este script a un compañero y funcionará igual en su máquina.
Seguridad: Al incluir el comando cp, te aseguras de tener siempre el archivo original a mano por si algo sale mal.

Advertencia: Si el $OFFSET que pones es mayor que el tamaño del archivo, dd lo hará más grande rellenando con ceros, lo cual suele corromper los ejecutables. ¡Asegúrate de que la dirección sea correcta!

Convertir el script en un bucle (loop) es la forma más eficiente de aplicar un parche a toda una colección de archivos (como una carpeta llena de niveles de un juego, firmwares o binarios de prueba) en un solo segundo.

Aquí tienes el script mejorado para procesar todos los archivos con una extensión específica en tu carpeta actual de Kali.

El Script: `multi_patcher.sh`

Copia este código en un archivo (por ejemplo, nano multi_patcher.sh):

Bash
#!/bin/bash

# --- Configuración ---
EXTENSION="bin"     # Cambia esto a "exe", "dat", etc.
OFFSET=1104         # Dirección en decimal (0x450 en hex es 1104)
NUEVO_BYTE="\x90"   # El byte que quieres insertar (NOP)

echo "--- Iniciando parcheo masivo de archivos .$EXTENSION ---"

# Bucle para encontrar cada archivo
for archivo in *."$EXTENSION"; do
    # Verificar si existen archivos con esa extensión
    [ -e "$archivo" ] || continue

    echo "Procesando: $archivo..."
    
    # 1. Crear copia de seguridad
    cp "$archivo" "$archivo.bak"
    
    # 2. Aplicar el parche con dd
    # Usamos printf para enviar el byte exacto
    printf "$NUEVO_BYTE" | dd of="$archivo" bs=1 seek=$OFFSET conv=notrunc status=none
    
    echo "  [OK] Parche aplicado y backup creado."
done

echo "--- Proceso finalizado ---"

Cómo funciona este "Modo Masivo"

for archivo in *."$EXTENSION": Este es el corazón del script. Le dice a Linux: "toma cada archivo que termine en .bin y guárdalo temporalmente en la variable archivo".
status=none: He añadido esto al comando dd para que la terminal no se llene de mensajes técnicos cada vez que parchee un archivo. Así la salida es mucho más limpia.
Conversión de Hex a Decimal: Un detalle importante es que dd prefiere números decimales para el salto (seek). Si tu dirección es hexadecimal (ej: 0x450), puedes convertirla rápidamente en la terminal de Kali con:
- echo $((0x450)) -> Resultado: 1104.

Consejos de Seguridad en Kali

Prueba con uno primero: Antes de lanzar el script sobre 100 archivos, asegúrate de que el cambio funciona en uno solo usando ncurses-hexedit.
Verificación rápida: Puedes usar el comando ls -l después de ejecutar el script para ver si los archivos .bak se crearon correctamente.
Limpieza: Si todo salió bien y no necesitas los backups, puedes borrarlos todos juntos con:
rm *.bak

Dato útil: Este tipo de scripts son los que usan los analistas de malware para "desarmar" variantes de un mismo virus que solo cambian un par de bytes para evadir firmas.

Esta es la versión más "inteligente" del script. Añadir una condición de verificación (un if) es lo que diferencia a un script básico de una herramienta profesional de patching.

El script solo aplicará el cambio si el byte en la dirección específica coincide con lo que esperas. Así evitas corromper archivos que ya están parcheados o que son versiones diferentes.

El Script: `smart_patcher.sh`

Copia este código (por ejemplo, nano smart_patcher.sh):

Bash
#!/bin/bash

# --- Configuración ---
ARCHIVO="mi_binario"
OFFSET=1104          # Dirección (0x450 en hex)
BYTE_ESPERADO="41"   # El valor original (en hex, ej: "A")
NUEVO_BYTE="\x90"    # El nuevo valor (en hex con \x, ej: NOP)

# 1. Leer el byte actual en esa posición
# 'od' extrae el byte, 'head' limita el rango y 'awk' limpia el texto
BYTE_ACTUAL=$(od -j $OFFSET -N 1 -An -t x1 "$ARCHIVO" | tr -d ' ')

echo "Analizando $ARCHIVO..."
echo "Byte en offset $OFFSET: [$BYTE_ACTUAL]"

# 2. Comparar y actuar
if [ "$BYTE_ACTUAL" == "$BYTE_ESPERADO" ]; then
    echo "¡Coincidencia encontrada! Aplicando parche..."
    printf "$NUEVO_BYTE" | dd of="$ARCHIVO" bs=1 seek=$OFFSET conv=notrunc status=none
    echo "Hecho. El archivo ha sido modificado."
else
    echo "Error: El byte actual [$BYTE_ACTUAL] no coincide con el esperado [$BYTE_ESPERADO]."
    echo "No se han realizado cambios para evitar daños."
fi

Explicación de la "Magia"

od -j $OFFSET -N 1 -An -t x1:
- -j: Salta al offset indicado.
- -N 1: Solo lee 1 byte.
- -An: No muestra las direcciones de memoria (solo el valor).
- -t x1: Formatea la salida como hexadecimal de 1 byte.
if [ "$BYTE_ACTUAL" == "$BYTE_ESPERADO" ]: Esta es la barrera de seguridad. Si el programa ha cambiado en una actualización y el código ya no está en esa dirección, el script se detendrá automáticamente.

Cómo usarlo en modo "Experto" en Kali

Si tienes muchos archivos, puedes combinar este script con el bucle for que vimos antes. De esta forma, podrías procesar 500 archivos y el script te diría exactamente cuáles fueron parcheados y cuáles se saltó porque no eran la versión correcta.

Resumen de comandos útiles para este flujo:

od: Para inspeccionar bytes desde la terminal.
dd: Para escribir los bytes.
hexedit: Para verificar visualmente que el parche funcionó.

Consejo final: Siempre que uses printf para parchear, asegúrate de que el valor hexadecimal lleve el prefijo \x. Por ejemplo, para el byte nulo usa \x00, no solo 00.

Tener un plan de escape es tan importante como el parcheo mismo. Cuando trabajas con muchos archivos en Kali, es fácil perder la cuenta de qué has modificado.

Aquí tienes el "Comando de Emergencia" para deshacer todos los cambios y restaurar tus archivos originales a partir de los backups .bak que creamos en los pasos anteriores.

1. El comando de una sola línea (The One-Liner)

Ejecuta esto en la terminal dentro de la carpeta donde están tus archivos:

Bash
for f in *.bak; do mv "$f" "${f%.bak}"; done

¿Qué hace exactamente este comando?

for f in *.bak: Busca todos los archivos que terminan en .bak.
mv "$f": Mueve (renombra) el archivo backup.
"${f%.bak}": Esta es la parte inteligente. Elimina la extensión .bak del nombre, sobrescribiendo el archivo parcheado con el original limpio.

2. Script de Limpieza Completa (`restore.sh`)

Si prefieres tener un archivo listo para usar siempre, crea este script. No solo restaura, sino que te avisa si no encuentra copias de seguridad.

Bash
#!/bin/bash

echo "--- Iniciando restauración de archivos originales ---"

# Comprobar si hay archivos .bak
if ls *.bak >/dev/null 2>&1; then
    for backup in *.bak; do
        # Obtener el nombre original quitando el .bak
        original="${backup%.bak}"
        
        mv "$backup" "$original"
        echo "Restaurado: $original"
    done
    echo "--- Todos los archivos han sido revertidos con éxito ---"
else
    echo "Error: No se encontraron archivos .bak para restaurar."
fi

Resumen de tu "Kit de Herramientas" en Kali

Ahora tienes un flujo de trabajo completo para ingeniería inversa básica:

Analizar: Usar ncurses-hexedit para ver y entender el binario.
Identificar: Usar Ctrl + S y Ctrl + G para encontrar puntos críticos.
Probar: Modificar un byte manualmente y guardar con Ctrl + W.
Automatizar: Usar el script de parcheo masivo para aplicar el cambio a muchos archivos.
Revertir: Usar el comando de restauración si algo sale mal.

Consejo final de seguridad: Antes de ejecutar el comando de restauración, asegúrate de que no tienes archivos importantes que realmente terminen en .bak por otras razones, ya que el comando los renombrará sin preguntar.

Aquí es donde la "magia" de los bytes se convierte en lógica de programación. Cuando cambias un byte en hexedit, lo que realmente estás haciendo es alterar una instrucción de la CPU.

Para ver esto en Kali Linux, usamos objdump, una herramienta que "desensambla" el binario, traduciendo los números hexadecimales a lenguaje ensamblador (ASM) legible por humanos.

1. Cómo leer el ensamblador de tu binario

Usa el siguiente comando para ver el código fuente en ensamblador:

Bash

objdump -d mi_binario | M -M intel | less

-d: Desensambla las secciones ejecutables.
-M intel: (Opcional) Usa la sintaxis de Intel, que es mucho más fácil de leer que la de AT&T (la que usa Windows y la mayoría de tutoriales modernos).

2. Comparando el "Antes" y el "Después"

Imagina que tenías una instrucción de salto que decidía si el usuario entraba o no.

Antes del parche (Original):

Fragmento de código

080484a5: 74 05          je 080484ac  <-- "Jump if Equal" (Salta si es igual)

Si el byte es 74, el programa salta a otra parte (quizás al mensaje de "Acceso Denegado").

Después del parche (Tu modificación):

Si usaste nuestro script para poner un NOP (90), verás esto:

Fragmento de código

080484a5: 90             nop          <-- "No Operation" (No hace nada)
080484a6: 90             nop

Ahora el procesador simplemente "pasa de largo" y ejecuta la siguiente línea, ignorando por completo la comprobación de seguridad.

3. Identificando instrucciones clave

Cuando estés navegando por el volcado de objdump, busca estas instrucciones comunes que suelen ser el objetivo de los parches:

Instrucción Hex	Ensamblador	Significado
`74` / `0F 84`	`JE` / `JZ`	Salta si el resultado es cero (Igual).
`75` / `0F 85`	`JNE` / `JNZ`	Salta si el resultado NO es cero (Diferente).
`EB`	`JMP`	Salto incondicional (salta siempre).
`90`	`NOP`	No hace nada (relleno o anulación).
`C3`	`RET`	Finaliza la función actual y regresa.

El flujo de trabajo del Analista

strings: Encuentras el texto "Password incorrecto".
objdump: Buscas qué función usa ese texto y localizas el JE (salto) que te echa fuera.
hexedit: Vas a ese offset y cambias el 74 (JE) por 75 (JNE) para invertir la lógica, o por 90 90 para anularla.
objdump (de nuevo): Verificas que el código ahora se ve como querías.

Tip de Kali: Si el binario es muy grande, usa grep para buscar funciones específicas:
objdump -d mi_binario | grep "<main>:" -A 20 (esto te muestra la función principal y las 20 líneas siguientes).

Esta es la parte donde muchos se confunden, porque la dirección que ves en objdump (Memoria Virtual) no siempre coincide con la que ves en hexedit (Offset del archivo).

Para encontrar el lugar exacto donde operar, necesitas entender la diferencia entre estas dos "direcciones".

1. Memoria Virtual (VMA) vs. Offset del Archivo

VMA (en objdump): Es la dirección donde el programa espera estar cuando se esté ejecutando en la RAM (ej: 0x080484a5).
Offset (en hexedit): Es la posición física del byte dentro del archivo en el disco (ej: 0x4a5).

En binarios simples (como archivos .bin o ejecutables pequeños), el offset suele ser simplemente los últimos dígitos de la dirección de memoria. Pero en binarios complejos (ELF en Linux), hay una cabecera que desplaza todo.

2. Cómo encontrar el Offset real

Para archivos ejecutables en Kali, el comando más fiable es readelf. Este comando te dirá cómo se mapea el archivo a la memoria.

Paso a paso:

Busca la sección: Casi todo el código ejecutable está en una sección llamada .text.
Ejecuta este comando:
Bash
```
readelf -S mi_binario | grep .text
```
Verás algo como esto:
[ 1] .text PROGBITS 08048390 000390 ...
- 08048390 es la dirección en Memoria.
- 000390 es el Offset en el archivo.

3. La fórmula del éxito

Si tienes una dirección de objdump y quieres el offset para hexedit, usa esta resta:

Offset = Dirección_{Objetivo} - (Dirección_{Sección} - Offset_{Sección})

Ejemplo real:

Quieres ir a 0x080484a5 (visto en objdump).
Tu sección .text empieza en 0x08048390 y su offset es 0x000390.
La diferencia es constante. En este caso, simplemente restas la base de memoria y sumas el offset del archivo.

Truco rápido: En la mayoría de los retos de CTF o binarios pequeños de Linux, si objdump te dice 0x80484a5, el offset en hexedit será simplemente 4a5 o 14a5. ¡Prueba primero con los últimos dígitos!

4. Verificación final en `hexedit`

Una vez que calcules el offset:

Abre hexedit.
Pulsa Ctrl + G e introduce tu offset calculado.
Compara los bytes: Mira si los bytes que ves en hexedit coinciden exactamente con los "Opcodes" que viste en objdump.
- Si en objdump viste 74 05 y en hexedit ves 74 05, ¡estás en el lugar correcto!

Resumen de Herramientas

objdump: Para leer la lógica (Ensamblador).
readelf: Para calcular el mapa del archivo (Offsets).
hexedit: Para aplicar la "cirugía" (Modificar bytes).