¿Cómo funciona el volcado de memoria del sistema?

Un volcado de núcleo , ya sea de todo el sistema, o solo ejecutable, es el contenido completo de esa memoria de procesos, o en el caso del sistema, la memoria de todo, escrita en un archivo. Puede haber una gran cantidad de datos en un volcado de este tipo: aquí hay una forma abreviada del espacio de memoria de gvim, que actualmente estoy ejecutando:

pmap 19133
19133:   gvim fsstate.py
0000000000400000   2184K r-x--  /usr/bin/gvim    ; program code
0000000000821000    100K rw---  /usr/bin/gvim    ; program code again
000000000083a000     52K rw---    [ anon ]
0000000000a39000     56K rw---  /usr/bin/gvim    ; more program code
0000000002469000   3592K rw---    [ anon ]
0000003d53c00000     16K r-x--  /lib64/libuuid.so.1.3.0 ; shared object
0000003d53c04000   2044K -----  /lib64/libuuid.so.1.3.0
0000003d53e03000      4K rw---  /lib64/libuuid.so.1.3.0
0000003d55000000     28K r-x--  /usr/lib64/libSM.so.6.0.1
0000003d55007000   2044K -----  /usr/lib64/libSM.so.6.0.1
...
00007f46d66c7000     20K r----  /usr/share/locale/en_GB/LC_MESSAGES/gdk-pixbuf.mo
00007f46d66cc000      4K r----  /usr/share/locale/en_GB/LC_MESSAGES/libc.mo
00007f46d66cd000     56K r----  /usr/share/locale/en_GB/LC_MESSAGES/gtk20.mo
00007f46d66db000     28K r--s-  /usr/lib64/gconv/gconv-modules.cache
00007f46d66e5000      4K rw---    [ anon ]
00007fffc9ed9000    132K rw---    [ stack ]    ; stack!
00007fffc9f9b000      4K r-x--    [ anon ]
ffffffffff600000      4K r-x--    [ anon ]

Desde ese espacio de direcciones, los objetos compartidos no se descargarían, pero todo lo demás, la pila, el montón, sería. Las direcciones serán relativas a ciertas versiones de objetos compartidos y, potencialmente, con ASLR es posible que no se alineen con el proceso para procesar. Un volcado de núcleo se puede configurar para contener cantidades variables de información, desde pequeños volcados hasta todo.

¿Qué te dice esto? Exactamente el estado del sistema o programa en el momento de ser volcado: lo que tiene en la pila (y por lo tanto, probablemente en qué función se encuentra). La mayoría de los volcados de núcleo también contienen otra información útil como la que se encuentra en los registros del procesador en el momento del volcado.

En cuanto a cómo se resuelve lo que está sucediendo, EIP o RIP en x86 (x64) le dirán exactamente en qué dirección de memoria se estaba ejecutando el proceso. rbp o ebp le dirá dónde está funcionando su función en la pila. Usted esperaría encontrar variables locales allí. También podría buscar todas las llamadas al sistema y sus argumentos en un volcado de memoria.

Todo esto sirve para decirle lo que está sucediendo con un proceso en ese momento específico. Tampoco es solo una herramienta para probar la pluma; es posible analizar los volcados de memoria como una forma de aplicaciones de depuración, en particular donde ejecutar los depuradores es difícil o imposible. Por ejemplo, puede analizar un volcado del núcleo del kernel para averiguar por qué se estrelló el kernel (¿qué estaba haciendo cuando entró en pánico?) En lugar de adjuntar un depurador e intentarlo de nuevo; también permite que otras personas le envíen volcados para su análisis.

¿Cómo ayuda esto con las pruebas de lápiz? De la misma manera, la depuración ayuda con las pruebas de lápiz. Puedes ver lo que está cargado en la memoria, cuál es el estado actual. Puede averiguar qué podría estar haciendo un proceso cuando tomó el volcado y quizás lo más importante, cualquier información almacenada en cualquier archivo ejecutable en la memoria (montón, pila, etc.) también terminará en el volcado central, incluidas las contraseñas almacenadas como texto sin formato en la memoria. .

¿Qué hacen las herramientas de análisis? Busque patrones y estructuras indicativos de un potencial exploit (o error, si está después de la depuración). Probablemente, una explicación completa de eso está fuera del alcance de este recuadro; hay muchos libros dedicados a las técnicas para analizar los volcados de memoria. Mucho de esto también depende del sistema y la arquitectura; Las técnicas para Windows x86 son diferentes a las técnicas para Linux en MIPS.

Como ejemplo de algo que podría indicar un error, aquí hay un ejemplo que AviD realmente apreciará:

push    rbp
mov rbp, rsp
sub rsp, 32
mov QWORD PTR [rbp-24], rdi  ; this is a char* argument stored on stack
mov rdx, QWORD PTR [rbp-24]  ; and this is a pointer loading it into a register
lea rax, [rbp-16]            ; this is only 8 bytes further down
mov rcx, QWORD PTR [rdx]     ; load contents of rdx into rcx
mov QWORD PTR [rax], rcx     ; put those 8 bytes to rbp-16
mov rcx, QWORD PTR [rdx+8]   ; load next 8 butes
mov QWORD PTR [rax+8], rcx   ; write to rbp-8   
mov rcx, QWORD PTR [rdx+16]
mov QWORD PTR [rax+16], rcx  ; write to rbp     
mov rcx, QWORD PTR [rdx+24]
mov QWORD PTR [rax+24], rcx  ; write to rbp+8   
mov rcx, QWORD PTR [rdx+32]
mov QWORD PTR [rax+32], rcx  ; write to rbp+16  
mov rcx, QWORD PTR [rdx+40]
mov QWORD PTR [rax+40], rcx  ; write to rbp+24  
mov rcx, QWORD PTR [rdx+48]
mov QWORD PTR [rax+48], rcx  ; write to rbp+32
mov rdx, QWORD PTR [rdx+56]
mov QWORD PTR [rax+56], rdx  ; write to rbp+40
lea rax, [rbp-16]

Como puede ver, el primer espacio disponible para esta función en la pila para las variables locales fue rbp-16 e inferior. Por encima de eso, simplemente hemos golpeado un marco de pila con un montón de datos, lo que probablemente provocó el bloqueo del programa. Sin embargo, este código puede indicar un posible exploit. Buscar patrones como esos en un volcado de memoria es lo que los hace útiles, y además rip en este caso le dirá exactamente qué acceso a la memoria causó el problema, porque apuntará a la instrucción ofensiva (en teoría).

En caso de que se esté preguntando, el código ofensivo era simplemente un memcpy de un búfer ilimitado a un espacio de destino mucho más pequeño. La función de llamada a memcpy fue optimizada.

En primer lugar, hay dos usuarios principales de volcados de memoria en seguridad: tipos forenses y personas de escritura de exploits. Pen-testers, no tanto, por supuesto que depende del pentest;)

La forma habitual en que las herramientas de volcado de memoria funcionan es abrir el pseudo-dispositivo de memoria y leer todo el contenido en un archivo.

Por ejemplo, con dd en Windows, haría algo como dd if=\.\Device\PhysicalMemory of=memory.bin bs=4096 (antes de win-2003, después de eso necesita un controlador de kernel)

Lo mismo se aplica a linux, por ejemplo, dd if=/dev/mem of=/home/john/mem.bin bs=1024

Esta es la forma más simple, por supuesto. Otras formas de adquirir memoria son mediante el uso de volcados de memoria como menciona Ninefingers, LiveKd, obtener la memoria a través del hipervisor si estamos hablando de una máquina virtual, obtener el archivo de hibernación si existe o incluso obtener la memoria a través de fireware u otra interfaz DMA. Por supuesto, también está el ataque de arranque en frío.

Al tener la memoria en un archivo, puedes hacer muchas cosas, depende de lo que quieras. El común es buscar cadenas, por ejemplo, Tokens de contraseña, claves privadas y el resto, este es el más fácil.

Si desea hacer algo más que eso, generalmente se necesita mucho más trabajo, pero se automatiza con diversos grados de éxito utilizando herramientas comerciales o de código abierto. La idea principal es que la memoria física en su volcado se dispersará en las páginas. Para darle algún sentido, localice por búsqueda heurística las tablas de páginas e intente reconstruir una vista lógica de la memoria. Una vez hecho esto, puede realizar otras búsquedas y localizar estructuras para los distintos procesos en ejecución, archivos abiertos, conexiones de red, etc. Realmente depende de cuáles sean sus objetivos.

Le ayudaría si enumerara qué herramientas, ya que existen diferencias, por ejemplo, memoria completa frente a áreas específicas. No puedo pensar en ninguna de las herramientas de ataque que uso con regularidad y que vuelca la memoria.

Pero simplemente, tomando un volcado de memoria, le permite observar no solo el código de la aplicación in situ, sino también los valores de las variables.

La memoria se copia en un disco de manera similar a la forma en que se intercambian las páginas de la memoria en el uso normal, o una herramienta lee la memoria directamente.

Si está en Windows, use el Explorador de procesos de la suite SysInternals. Simplemente haga clic derecho en un proceso y elija volcar la memoria para ese proceso.

enlace