GDB Depuración Medio Ambiente
Algunas concepto de depuración de un gestor de arranque es más bien «fresco», si no «chocante» para su primer encuentro. Es aún más «chocante» si usted nunca ha oído hablar de la «programación de inserción». Al depurar una aplicación, a construir aplicaciones con símbolos de depuración, a continuación, cargar el archivo ejecutivo en GDB, iniciar un proceso de «inferior», el cual es controlado y vigilar por el BGF, configure el punto de ruptura, hacer un poco de paso a paso, mostrar los valores de alguna variable, y, finalmente, averiguar si existe algún error. Si está depurando un gestor de arranque, después de la experiencia previa, es posible que desee simplemente comenzar en GDB. ¡Pero espera! Si el gestor de arranque se instala en un ordenador central, sólo el firmware de BIOS y del gestor de arranque es cargado en la memoria, ningún sistema operativo todavía! Ningún concepto de «proceso / hilo» que está familiarizado con. Sin el apoyo de un sistema operativo en ejecución, ni siquiera se puede iniciar GDB! Ni siquiera se puede cargar el código del gestor de arranque en «bare metal» de la máquina, porque no hay una llamada «sistema de archivos» donde se puede montar y copiar archivos. Entonces, ¿qué?
Por suerte, los ingenieros de hardware han hecho un buen trabajo para hacer la vida de los programadores de software no es tan miserable, que no necesitan osciloscopio y analizador lógico para depurar el programa. Todos los chips ASIC modernos tienen pines adicionales para fines de prueba. A través de estos pines, puede supervisar el estado interno del chip y controlar su comportamiento. En una placa principal del ordenador, habrá un puerto especial, a través del cual usted puede enviar el mensaje a los chips y recibir actualización de estado a partir de astillas. Tal interacción seguir un protocolo estándar denominado «JTAG». Hay software depurador que hablan el idioma «JTAG» para el hardware de metal desnudo. Tal depurador reside en otro equipo «host», conéctese a «prueba» puerto JTAG de la máquina a través de un cable. A través de estos depurador, puede encender, apagar, reiniciar, el programa de carga en la flash y la memoria principal, la ejecución o la programación de un solo paso, establecer puntos de interrupción, etc Todo lo que puedes hacer con GDB.
JTAG suite de depuración es generalmente caro, y está hecho a bordo específico mercancías duras. No me puedo permitir que se acaba de mostrar cómo depurar GRUB. Pero por suerte, podemos ejecutar una máquina virtual en estos días, y si no tienen el apoyo de depuración para el IAE, entonces GDB podemos conectar con ellos y comenzar la depuración sólo como una suite depurador JTAG. En la máquina virtual de destino, un componente BGF llamado «servidor de GDB» o «talón de GDB» se está ejecutando. Es monitor de la máquina virtual, y se comunican con el BGF depurador a través de un canal de comunicación (línea serie o TCP / IP) a través de «Protocolo remota de serie». En máquina host, lanzamos gdb, conectarse a servidor de destino gdb, y comenzar la depuración como de costumbre. La vida vuelve a la normalidad. Para conocer más detalles de la depuración remota GDB, la referencia [1] [2] son buenos puntos de partida
1. Virtual Machine Debugging Support
Tanto Qemu y VMware ha incorporado un servidor GDB. Una vez iniciado, puede conectarse a ellos y comenzar una sesión de depuración. Para Qemu,
qemu-S-s-hda / dev/sda7
comenzará una máquina virtual QEMU con un puerto tcp depuración gdb en 1234, y la máquina virtual está encendido y se detuvo en espera de la instrucción de depurador.
Para VMware, añadir debajo de la línea en la máquina vmware «. vmx «archivos de definición:
debugStub.listen.guest32.remote =» TRUE »
debugStub.listen.guest64.remote = «TRUE»
debugStub.listen.guest32 = «TRUE»
debugStub.listen.guest64 = «TRUE»
debugStub.hideBreakpoints =» TRUE «
monitor.debugOnStartGuest32 =» TRUE «
monitor.debugOnStartGuest64 = «TRUE»
Primera iniciar la máquina virtual. Para VMware, cuando la máquina está encendido, si el diagrama que aparece a continuación, usted sabe VMware es detenido a la espera de una conexión de depuración
 |
Una máquina virtual de VMware |
gdb
a distancia: 8832
La depuración remota usando: 8.832 />
(Gdb) set-next-line desmontar el />
(gdb) si />
=> 0xffffe6f9: fa cli />
en? ()
=> 0xffffe6fa: 66 c1 e2 10 SHL $ 0x10,% dx
(gdb) b * 0x7C00
Breakpoint 1 a 0x7C00
(gdb) c
Continua.
Breakpoint 1, 0x00007c00 en? ()
=> 0x00007c00: eb 63 jmp 0x7c65
(gdb) si
0x00007c65 en? ()
=> 0x00007c65: fa cli
(gdb) I, regla
0x0 eax 0
ecx 0x0 0
edx 0x80 0x0 ebx /> 128
esp 0x3f6 0x3f6
ebp 0x0 0x0
esi 0x0 0
edi 0x0 0
eip 0x7c65 0x7c65
eflags 0x206 [PF IF]
cs 0x0 0
ss 0x0 0
ds 0x40 64
es 0x0 0
fs 0xea0e 59918
gs 0xf000 61440
(gdb)
Ahora estamos en código de arranque de GRUB, a partir de 0x7C00. Contamos con gdb «desmontar» para entender lo que está pasando. Para un hacker gestor de arranque, el montaje es su amigo, no enemigo. En proceso de arranque, la mayoría de las veces nos ocuparemos directamente asamblea. Estos módulos están codificados en assemly mayor parte del tiempo.
2. Depuración Símbolo Soporte
Aunque un ojo en el montaje es 100% por ciento crítico para hackers gestor de arranque, algún símbolo no dañaría demasiado. Cuando se depura código escrito en lenguaje de alto nivel, símbolo de depuración es obligatorio, o que habrá que esperar demasiado tiempo revers ingeniería. Una versión de depuración es necesario para el soporte del símbolo. La liberación Grub de Ubuntu se ha «parcheado», por lo que si está depurando la versión de Ubuntu, es necesario descargar la fuente de Ubuntu. La diferencia es menor en comparación con la fuente de grub original, pero para el software de bajo nivel como gestor de arranque, incluso una discrepancia byte le costará un montón de tiempo.
apt- conseguir grub2 fuente
dpkg-source-x grub2_2.00-13ubuntu3.dsc
grub2 ls-2.00-grub2_2.00 13ubuntu3.dsc
grub2_2.00-13ubuntu3.debian. grub2_2.00.orig.tar.xz tar.gz
cd grub2-2.00
debuild
limpia debuild-us-uc-b
build cd / grub-pc
encontrar grub-core /-name "* img." | sort
grub-core/boot.img grub-core/cdboot.img
comida
-core/diskboot.img grub-core/g2hdr.img
grub-core/grldr.img grub-core/kernel.img
grub-core/lnxboot.img
grub-core/lzma_decompress.img grub-core/pxeboot.img
encontrar grub-core /-name "* Imagen". | sort
grub-core / grldr.image
grub-core/lnxboot.image grub-core/lzma_decompress.image
grub-core/pxeboot.image
encontrar grub-core/boot . "* o" / grub-core/contrib /-name | sort
grub-core/boot/i386/pc/boot_image-boot.o grub-core/boot/i386 / pc / cdboot_image-cdboot.o
grub-core/boot/i386/pc/diskboot_image-diskboot.o grub-core/boot/i386/pc/lnxboot_image-lnxboot.o
grub-core/boot/i386/pc/lzma_decompress_image-startup_raw.o grub-core/boot/i386/pc/pxeboot_image-pxeboot.o grub-core/contrib/915resolution/915resolution_module-915resolution />
grub-core/contrib/ntldr-img/g2hdr_image-g2hdr.o grub-core/contrib/ntldr-img/grldr_image-grldrstart.o
grub-core/contrib/ntldr -img/grldr_image-ntfsbs.o />
encontrar grub-core /-name "kernel.exec"
grub-core/kernel.exec
Todos los archivos «*. img» es la versión simplificada, la «imagen *.» correspondiente versión no se despojó con sólo símbolos, pero sin el código fuente, el «*. o» es la depuración versión con todos los símbolos y códigos fuente. Por ejemplo:
file
grub-core/boot.img grub-core/boot.img: sector de arranque x86; partición 4: ID = 0xd3, starthead 205 , startsector 4278184271, 0 sectores, código de desplazamiento 0x63
ll grub-core/boot.img
-rwxr-xr-x 1 luke luke 512 01 de julio 22:46 grub-core/boot.img *
archivo />
-rwxr-xr-x 1 luke luke 2091 01 de julio 22:46 grub-core/boot.image *
tamaño grub-core / boot.image
datos de texto bss diciembre hexagonal nombre
512 0 0 512 200
grub-core/boot.image objdump-h grub-core/boot.image
grub-core / boot.image: Formato de archivo-ELF32 i386
Secciones:
Nombre Ind Tamaño VMA LMA File off ALGN
0 de texto 00000200 00007c00 00007c00 00000054 2 ** 2
CONTENIDOS, ALLOC. , CARGA, />
grub-core/boot/i386/pc/boot_image-boot.o grub-core/boot/i386/pc/boot_image-boot. o: ELF 32-bits LSB reubicable, Intel 80386, versión 1 (SYSV), no despojado
ll grub-core/boot/i386/pc/boot_image-boot.o
-rw-r - r - 1 luke luke 3152 01 de julio 22:46 grub-core/boot/i386/pc/boot_image-boot.o tamaño />
datos de texto bss diciembre hexagonal nombre
512 0 0 512 200 grub-core/boot/i386/pc/boot_image-boot.o />
grub-core/boot/i386/pc/boot_image-boot.o: formato de archivo />
Ind Tamaño VMA LMA File off ALGN
0. texto 00000200 00000000 00000000 00000034 2 ** 2
CONTENIDOS, ALLOC, CARGA, RELOC, READONLY, CÓDIGO
1. datos 00000000 00000000 00000000 00000234 2 ** 2
CONTENIDOS, ALLOC, CARGA DATOS
2. bss 00000000 00000000 00000000 00000234 2 ** 2 />
3. debug_line 000000f3 00000000 00000000 00000234 2 ** 0
CONTENIDOS, RELOC, READONLY, DEPURACIÓN
4. DEBUG_INFO 00000082 00000000 00000000 00000327 2 ** 0
CONTENIDOS, RELOC, READONLY, DEPURACIÓN
5. debug_abbrev 00000014 00000000 00000000 000003a9 2 ** 0
CONTENIDOS, READONLY, DEPURACIÓN
6. debug_aranges 00000020 00000000 00000000 000003c0 2 ** 3
CONTENIDOS, RELOC, READONLY, DEPURACIÓN
Hay una advertencia aquí. El boot.img tiene la dirección correcta offset (0x7C00) y el símbolo, pero no el código fuente; El boot_image-boot.o tiene origen, sino porque todos los archivos objeto se compilan utilizando 0x0 compensado por defecto, por lo que cuando se cargan en gdb, todas las direcciones información errónea alinear por 0x7C00. Para tener una versión completa de depuración, podemos volver a vincular el archivo «*. O» utilizando el offset correctamente (0x7C00) y sin volcar el código fuente de depuración. Usted puede hacer esto con otra imagen de la misma manera.
ld-Ttext = 0x7C00-m elf_i386 boot_image-boot.o-o boot.image
objdump -h boot.image />
boot.image: formato de archivo-ELF32 i386 />
Secciones:
Nombre Ind Tamaño VMA LMA File off ALGN
0. texto 00000200 00007c00 00007c00 00000c00 2 ** 2
CONTENIDOS, ALLOC, CARGA, READONLY, CÓDIGO
1. debug_aranges 00000020 00000000 00000000 00000e00 2 ** 3
CONTENIDOS, READONLY, DEPURACIÓN
2. DEBUG_INFO 00000082 00000000 00000000 00000e20 2 ** 0
CONTENIDOS, READONLY, DEPURACIÓN
3. debug_abbrev 00000014 00000000 00000000 00000ea2 2 ** 0
CONTENIDOS, READONLY, DEPURACIÓN
4. debug_line 000000f3 00000000 00000000 00000eb6 2 ** 0
CONTENIDOS, READONLY, /> DEBUGGING
Ahora tenemos la versión de depuración-nido completo, vamos a cargamos en gdb :
gdbAhora que finalmente tenemos un entorno de depuración funcional a través de la máquina virtual
(gdb) Archivo boot.image símbolos />
(gdb) de destino remoto: 8832
La depuración remota usando: 8.832 />
(Gdb) b _start
Breakpoint 1 a 0x7C00:. Archivo .. / ../../grub-core/boot/i386/pc/boot.S, línea 52
(gdb) l _start
47 / *
48 * A partir del sector es compatible con el BIOS
49 * bloque de parámetros.
50 * /
51
52 jmp LOCAL (after_BPB)
53 nop / * Que me importa esto??? * /54 55 / * 56 *
Este espacio es para el bloque de parámetros del BIOS!! No cambie />
Continua.Breakpoint 1, start () en .. / ../../grub-core/boot/i386 / pc / boot.S: 52
52 jmp LOCAL (after_BPB)
(gdb) I, regla
0x0 eax 0
ecx 0x0 0
edx 0x80 128
0x0 ebx 0
esp 0x3ec 0x3ec
ebp 0x0 0x0
esi 0x0 0
edi 0x0 0
eip 0x7C00 0x7C00
eflags 0x206 [PF IF]
cs 0x0 0
ss 0x0 0
ds 0x40 64
es 0x0 0
fs 0xea0e 59918
gs 0xf000 61440
(gdb ) n
103 cli / * no estamos seguros aquí! * /
(Gdb) n
115 jmp 3f / * grub-setup puede sobrescribir este salto * /
(gdb)
SyntaxHighlighter.highlight ().;
Posts Relacionados
LINUX Dominar la Administración del Sistema 3°Edición [PDF]
BackBox Linux 4.1, nueva versión de esta distro de seguridad