nccgroup/libmempoolHeap analysis tooling for mempool
Nota preliminar: recomendamos usar esto como parte de asatools pero también se puede usar de forma independiente.
libmempool es un script de Python y una herramienta de análisis para GDB
que ayuda en el análisis de las estructuras de datos relacionadas con mempool
que se encuentran dentro de varios heaps en dispositivos Cisco ASA.
Normalmente esta información está incrustada en un chunk de heap, o es una
extensión personalizada de alguna otra estructura de heap común, como una
estructura mstate de dlmalloc.
Cisco usa el término mempool para describir regiones de memoria mapeadas con diversos fines, como asignaciones generales, DMA, etc. Estas regiones suelen contener su propio heap, como dlmalloc. Las rutinas de asignación en estos mempools se hacen típicamente mediante wrappers alrededor del asignador del heap subyacente, y estos wrappers inyectan metadatos específicos del mempool en las asignaciones resultantes. Nos referimos a estos metadatos como una cabecera de mempool o mh para abreviar. De igual manera, nos referiremos a menudo a un mempool como mp. El uso de mh para describir una cabecera de mempool también es consistente con varias cadenas encontradas en los binarios lina de Cisco ASA.
Aunque libmempool puede usarse como una herramienta independiente para analizar algunas cosas relacionadas con las cabeceras de mempool y las estructuras de datos, su mayor valor proviene de ser utilizado como callback desde otras librerías como libdlmalloc o libptmalloc.
Vale la pena señalar que ciertos aspectos del mempool, como los bins utilizados
para rastrear los chunks en uso, están incrustados dentro de una estructura
mstate de dlmalloc 2.8.x y siguen el mismo dimensionado de bins. Esto
significa que casi inevitablemente tendrás que explorar al menos el mstate
que encapsula los datos del mempool usando libdlmalloc.
libmempool ha sido probado con versiones de Cisco ASA de 32 y 64 bits (tanto la serie ASA5500-X como GNS3) que usan dlmalloc2.8 o el asignador basado en ptmalloc2 de glibc. Ha sido probado en numerosas versiones de ASA, incluyendo numerosas ramas 8.x.y y 9.x.y. Sin embargo, es totalmente posible que falle en alguna versión.
Para usar libmempool de forma independiente, simplemente necesitas importar el
archivo libmempool.py en tu proyecto. Esto te permite hacer algunas acciones
limitadas, como registrar el objeto mpcallback, etc. Esto puede ser útil si
estás haciendo análisis fuera de línea de la funcionalidad de heap registrada.
Para importarlo en GDB, el script solo requiere GDB con soporte de Python. Aunque la mayoría de las versiones modernas de GDB han migrado a Python 3, algunas todavía esperan 2.7. El script ha sido probado en ambas, pero principalmente el desarrollo y las pruebas se hacen con Python 3.
(gdb) source libmempool_gdb.py
Separamos la mayor parte de la lógica relacionada con GDB de libmempool.py en libmempool_gdb.py solo para probar la abstracción de cosas y para que puedas usar libmempool.py fácilmente fuera de GDB. Esto probablemente cambiará en el futuro, ya que eventualmente querríamos implementar abstracciones de motor de depuración similares a las que usan otras herramientas de análisis de heap como libheap y shadow.
Aunque gran parte del valor de libmempool proviene de la función de callback
mpcallback que expone, hay una serie de comandos GDB integrados que podemos
ver.
(gdb) mphelp
[libmempool] mempool commands for gdb
[libmempool] mpheader -v -x <addr> : show chunk contents (-v for verbose, -x for data dump)
[libmempool] mpbinwalk [-v] [-p <addr>] <sz> : walk an mpbin and operate on each chunk in a bin
[libmempool] mpbin <addr> : determine to which bin an mp_header is associated to
[libmempool] mpmstate <addr> : display and cache a mempool mstate address
[libmempool] mphelp
Suponiendo que conocemos la dirección de alguna cabecera de mempool, podemos analizar sus datos. Ten en cuenta que debe ser la dirección de la propia cabecera de mempool, y no la dirección de los metadatos del chunk del asignador central. Así, podemos volcar el contenido de la siguiente manera:
(gdb) mpheader 0x7fffbc1c1ca0
struct mp_header @ 0x7fffbc1c1ca0 {
mh_magic = 0xa11c0123
mh_len = 0x3
mh_refcount = 0x10000
mh_unused = 0x0
mh_fd_link = 0x7fffbc1c19e0 (OK)
mh_bk_link = 0x7ffff7ff7540 (-)
alloc_pc = 0x55555849e260 (-)
free_pc = 0x0 (-)
}
También podemos volcar el contenido hexadecimal del chunk usando -x.
(gdb) mpheader -x 0x7fffbc1c1ca0
struct mp_header @ 0x7fffbc1c1ca0 {
mh_magic = 0xa11c0123
mh_len = 0x3
mh_refcount = 0x10000
mh_unused = 0x0
mh_fd_link = 0x7fffbc1c19e0 (OK)
mh_bk_link = 0x7ffff7ff7540 (-)
alloc_pc = 0x55555849e260 (-)
free_pc = 0x0 (-)
0x3 bytes of chunk data:
0x7fffbc1c1cd0: 0x55 0x04 0x03
}
Los mempools tienen el concepto de bins, que son listas doblemente enlazadas
con el mismo tamaño que los bins de dlmalloc, pero que se usan para rastrear
chunks en uso en lugar de chunks libres. Esto se hace para llevar la
contabilidad del uso de memoria en los dispositivos Cisco. A menudo puedes
encontrar un chunk que contiene una cabecera de mempool, pero aún no sabes
dónde vive la estructura mstate en el heap. Para orientarte, puedes usar el
comando mpbin, que te dará la dirección del bin de mempool en el que vive
actualmente un chunk en uso. Por ejemplo:
(gdb) mpbin 0x7fffbc1c1ca0
[libmempool] Found bin start at 0x7ffff7ff7540
[libmempool] Cached new mp_mstate @ 0x7ffff7ff73c0
[libmempool] mp_smallbin[08] - sz: 0x00000040 cnt: 0x00d3, mh_fd_link: 0x7fffbc1c1ca0
Esto no solo encontró el inicio de la porción de mempool del mstate, sino que
también lo almacenó en caché, y lista el bin específico en el que existe el
chunk. Opcionalmente podríamos usar el comando mpbinwalk para listar todos
los 0xd3 chunks de este bin, o solo hasta un número específico:
(gdb) mpbinwalk 0x40
[libmempool] mp_header @ 0x7ffff7ff7540 - mh_len: 0x00000000, alloc_pc: 0x00000000 [BIN HEAD]
[libmempool] mp_header @ 0x7fffbc1c1ca0 - mh_len: 0x00000003, alloc_pc: 0x55555849e260
[libmempool] mp_header @ 0x7fffbc1c19e0 - mh_len: 0x00000003, alloc_pc: 0x55555849e260
[libmempool] mp_header @ 0x7fffbc1c1750 - mh_len: 0x00000003, alloc_pc: 0x55555849e260
[libmempool] mp_header @ 0x7fffbc1bffa0 - mh_len: 0x00000003, alloc_pc: 0x55555849e260
[libmempool] mp_header @ 0x7fffbc1bff60 - mh_len: 0x00000003, alloc_pc: 0x5555584a1288
[libmempool] mp_header @ 0x7fffbc1c0050 - mh_len: 0x00000003, alloc_pc: 0x55555849e260
[...]
Ahora, si queremos volcar toda la porción de mempool de la estructura mstate
(es decir, todos los bins y estadísticas relacionadas), podemos usar el comando
mpmstate:
(gdb) mpmstate 0x7ffff7ff73c0
struct mp_mstate @ 0x7ffff7ff73c0 {
mp_smallbin[00] - sz: 0x00000000 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[01] - sz: 0x00000008 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[02] - sz: 0x00000010 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[03] - sz: 0x00000018 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[04] - sz: 0x00000020 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[05] - sz: 0x00000028 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[06] - sz: 0x00000030 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[07] - sz: 0x00000038 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[08] - sz: 0x00000040 cnt: 0x00d3, mh_fd_link: 0x7fffbc1c1ca0
mp_smallbin[09] - sz: 0x00000048 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[10] - sz: 0x00000050 cnt: 0x0429, mh_fd_link: 0x7fffa4000d10
mp_smallbin[11] - sz: 0x00000058 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[12] - sz: 0x00000060 cnt: 0x335d, mh_fd_link: 0x7fffb80064b0
mp_smallbin[13] - sz: 0x00000068 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[14] - sz: 0x00000070 cnt: 0x073a, mh_fd_link: 0x7fffbc1c7260
mp_smallbin[15] - sz: 0x00000078 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[16] - sz: 0x00000080 cnt: 0x0301, mh_fd_link: 0x7fffbc1c72d0
mp_smallbin[17] - sz: 0x00000088 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[18] - sz: 0x00000090 cnt: 0x0c98, mh_fd_link: 0x7fffc9488920
mp_smallbin[19] - sz: 0x00000098 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[20] - sz: 0x000000a0 cnt: 0x0161, mh_fd_link: 0x7fffa40009a0
mp_smallbin[21] - sz: 0x000000a8 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[22] - sz: 0x000000b0 cnt: 0x0092, mh_fd_link: 0x7fffa4000a40
mp_smallbin[23] - sz: 0x000000b8 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[24] - sz: 0x000000c0 cnt: 0x0120, mh_fd_link: 0x7fffbc1c1270
mp_smallbin[25] - sz: 0x000000c8 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[26] - sz: 0x000000d0 cnt: 0x00ba, mh_fd_link: 0x7fffbc1b51a0
mp_smallbin[27] - sz: 0x000000d8 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[28] - sz: 0x000000e0 cnt: 0x005b, mh_fd_link: 0x7fffc9485020
mp_smallbin[29] - sz: 0x000000e8 cnt: 0x0000, mh_fd_link: 0x0
mp_smallbin[30] - sz: 0x000000f0 cnt: 0x016e, mh_fd_link: 0x7fffbc1c7040
mp_smallbin[31] - sz: 0x000000f8 cnt: 0x0000, mh_fd_link: 0x0
mp_treebin[00] - sz: 0x00000180 cnt: 0x050f, mh_fd_link: 0x7fffbc1c7130
mp_treebin[01] - sz: 0x00000200 cnt: 0x00ce, mh_fd_link: 0x7fffbc1c2610
mp_treebin[02] - sz: 0x00000300 cnt: 0x011a, mh_fd_link: 0x7fffa40053c0
mp_treebin[03] - sz: 0x00000400 cnt: 0x013e, mh_fd_link: 0x7fffa4000f80
mp_treebin[04] - sz: 0x00000600 cnt: 0x016f, mh_fd_link: 0x7fffbc1c2a80
mp_treebin[05] - sz: 0x00000800 cnt: 0x009a, mh_fd_link: 0x7fffbc1b4880
mp_treebin[06] - sz: 0x00000c00 cnt: 0x0081, mh_fd_link: 0x7fffbc1b38b0
mp_treebin[07] - sz: 0x00001000 cnt: 0x002b, mh_fd_link: 0x7fffbc1b2330
mp_treebin[08] - sz: 0x00001800 cnt: 0x0326, mh_fd_link: 0x7fffc9368e10
mp_treebin[09] - sz: 0x00002000 cnt: 0x0038, mh_fd_link: 0x7fffc92e9c60
mp_treebin[10] - sz: 0x00003000 cnt: 0x00b9, mh_fd_link: 0x7fffa4003380
mp_treebin[11] - sz: 0x00004000 cnt: 0x006d, mh_fd_link: 0x7fffc9457720
mp_treebin[12] - sz: 0x00006000 cnt: 0x023b, mh_fd_link: 0x7fffbc1ac000
mp_treebin[13] - sz: 0x00008000 cnt: 0x0018, mh_fd_link: 0x7fffc946f850
mp_treebin[14] - sz: 0x0000c000 cnt: 0x0030, mh_fd_link: 0x7fffc935fcc0
mp_treebin[15] - sz: 0x00010000 cnt: 0x0019, mh_fd_link: 0x7fffb44262b0
mp_treebin[16] - sz: 0x00018000 cnt: 0x0073, mh_fd_link: 0x7fffc93fe020
mp_treebin[17] - sz: 0x00020000 cnt: 0x0018, mh_fd_link: 0x7fffc94368f0
mp_treebin[18] - sz: 0x00030000 cnt: 0x000c, mh_fd_link: 0x7fffb0665010
mp_treebin[19] - sz: 0x00040000 cnt: 0x001c, mh_fd_link: 0x7fffa836d010
mp_treebin[20] - sz: 0x00060000 cnt: 0x000d, mh_fd_link: 0x7fffa8c55010
mp_treebin[21] - sz: 0x00080000 cnt: 0x001d, mh_fd_link: 0x7fffa9009010
mp_treebin[22] - sz: 0x000c0000 cnt: 0x0006, mh_fd_link: 0x7fffa9081010
mp_treebin[23] - sz: 0x00100000 cnt: 0x000a, mh_fd_link: 0x7fffb025f010
mp_treebin[24] - sz: 0x00180000 cnt: 0x000b, mh_fd_link: 0x7fffa8b38010
mp_treebin[25] - sz: 0x00200000 cnt: 0x000e, mh_fd_link: 0x7fffb008a010
mp_treebin[26] - sz: 0x00300000 cnt: 0x0007, mh_fd_link: 0x7fffb0323010
mp_treebin[27] - sz: 0x00400000 cnt: 0x0002, mh_fd_link: 0x7fffa87f5010
mp_treebin[28] - sz: 0x00600000 cnt: 0x0003, mh_fd_link: 0x7fffa83e9010
mp_treebin[29] - sz: 0x00800000 cnt: 0x0001, mh_fd_link: 0x7fffab328010
mp_treebin[30] - sz: 0x00c00000 cnt: 0x0001, mh_fd_link: 0x7fffd706d010
mp_treebin[31] - sz: 0xffffffff cnt: 0x0003, mh_fd_link: 0x7fffa9326010 [UNSORTED]
}
Implementamos un callback "aware" de dlmalloc y ptmalloc dentro de libmempool, que está pensado para ser llamado por libdlmalloc o libptmalloc para aumentar su anotación de chunks con datos adicionales específicos del mempool. Por ejemplo, si se usa libdlmalloc para imprimir un listado verbose de un chunk de dlmalloc, y ese chunk contiene dentro una cabecera de mempool, entonces el callback de mempool la imprimirá.
Para obtener información sobre cómo se ve esto cuando se usa a través de otras herramientas, consulta los archivos README en libdlmalloc y libptmalloc.
Probablemente añadiremos funcionalidad a libmempool según la necesitemos o mientras hagamos futuras investigaciones de Cisco ASA. Las adiciones planeadas actualmente son:
Nos encantaría recibir comentarios sobre esta herramienta y también estamos abiertos a pull requests.
Aaron Adams
aaron<dot>adams<at>nccgroup<dot>trustCedric Halbronn
cedric<dot>halbronn<at>nccgroup<dot>trust