Descarga de memoria de Android

18

Necesito evaluar la seguridad de una biblioteca criptográfica. En particular, estoy apuntando a una parte de la biblioteca donde creo que la clave privada está expuesta durante un tiempo limitado en la RAM. Cualquier idea o sugerencia sobre cómo revisar la RAM para esta clave. Estaba pensando en descargar memoria después de algunas interacciones específicas de los usuarios. ¿Pero cómo empiezo con esto, cualquier herramienta recomendada? Estoy en casa en el mundo de la seguridad, sé sobre diseños de memoria, uso, contramedidas contra ataques de memoria, etc. Simplemente no en Android.

En cuanto al motor de arranque, es suficiente si las herramientas / técnicas requieren un parpadeo del kernel personalizado o dispositivos rooteados. Pero al final, debería ser aplicable en situaciones de la vida real en las que el dispositivo de destino sea un dispositivo OEM listo para usar.

    
pregunta 4oxer 02.07.2014 - 16:07
fuente

4 respuestas

9

Tenía la misma necesidad y después de mirar alrededor terminé escribiendo mi propio programa.

Uso:

memdump <pid>
memdump <pid> <ip-address> <port>

El primero enviará toda la memoria del proceso a la salida estándar, y el último al puerto TCP de su elección (es probable que use netcat en el otro extremo).

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/ptrace.h>
#include <sys/socket.h>
#include <arpa/inet.h>

void dump_memory_region(FILE* pMemFile, unsigned long start_address, long length, int serverSocket)
{
    unsigned long address;
    int pageLength = 4096;
    unsigned char page[pageLength];
    fseeko(pMemFile, start_address, SEEK_SET);

    for (address=start_address; address < start_address + length; address += pageLength)
    {
        fread(&page, 1, pageLength, pMemFile);
        if (serverSocket == -1)
        {
            // write to stdout
            fwrite(&page, 1, pageLength, stdout);
        }
        else
        {
            send(serverSocket, &page, pageLength, 0);
        }
    }
}

int main(int argc, char **argv) {

    if (argc == 2 || argc == 4)
    {
        int pid = atoi(argv[1]);
        long ptraceResult = ptrace(PTRACE_ATTACH, pid, NULL, NULL);
        if (ptraceResult < 0)
        {
            printf("Unable to attach to the pid specified\n");
            return;
        }
        wait(NULL);

        char mapsFilename[1024];
        sprintf(mapsFilename, "/proc/%s/maps", argv[1]);
        FILE* pMapsFile = fopen(mapsFilename, "r");
        char memFilename[1024];
        sprintf(memFilename, "/proc/%s/mem", argv[1]);
        FILE* pMemFile = fopen(memFilename, "r");
        int serverSocket = -1;
        if (argc == 4)
        {   
            unsigned int port;
            int count = sscanf(argv[3], "%d", &port);
            if (count == 0)
            {
                printf("Invalid port specified\n");
                return;
            }
            serverSocket = socket(AF_INET, SOCK_STREAM, 0);
            if (serverSocket == -1)
            {
                printf("Could not create socket\n");
                return;
            }
            struct sockaddr_in serverSocketAddress;
            serverSocketAddress.sin_addr.s_addr = inet_addr(argv[2]);
            serverSocketAddress.sin_family = AF_INET;
            serverSocketAddress.sin_port = htons(port);
            if (connect(serverSocket, (struct sockaddr *) &serverSocketAddress, sizeof(serverSocketAddress)) < 0)
            {
                printf("Could not connect to server\n");
                return;
            }
        }
        char line[256];
        while (fgets(line, 256, pMapsFile) != NULL)
        {
            unsigned long start_address;
            unsigned long end_address;
            sscanf(line, "%08lx-%08lx\n", &start_address, &end_address);
            dump_memory_region(pMemFile, start_address, end_address - start_address, serverSocket);
        }
        fclose(pMapsFile);
        fclose(pMemFile);
        if (serverSocket != -1)
        {
            close(serverSocket);
        }

        ptrace(PTRACE_CONT, pid, NULL, NULL);
        ptrace(PTRACE_DETACH, pid, NULL, NULL);
    }
    else
    {
        printf("%s <pid>\n", argv[0]);
        printf("%s <pid> <ip-address> <port>\n", argv[0]);
        exit(0);
    }
}

Para compilarlo de forma cruzada para Android, tu Android.mk debería tener este aspecto:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE := memdump
LOCAL_SRC_FILES := memdump.c
include $(BUILD_EXECUTABLE)
    
respondido por el Tal Aloni 27.12.2015 - 15:38
fuente
7

Puede volcar la información de la memoria usando el Puente de depuración de Android (ADB) usando el siguiente comando :

adb shell dumpsys meminfo > mem.txt

Para obtener información para una aplicación en particular, usa esto:

adb shell dumpsys meminfo 'your apps package name'

Esta respuesta ofrece una descripción detallada de la herramienta dumpsys . Echa un vistazo También, esta publicación de blog explica otro método para volcar la memoria de un proceso particular en ejecución (simplemente lo encontré en mi resultado de búsqueda de Google).

    
respondido por el Rahil Arora 02.07.2014 - 16:21
fuente
0

Existen técnicas para capturar la memoria RAM de Android en un archivo de memoria o volcado como lo haría con cualquier sistema operativo de escritorio y analizar el volcado de memoria utilizando un marco como volatilidad. Para Android, es muy probable que tenga que rootear el dispositivo. . Si tiene tiempo, esta es una gran guía de 2 partes para extraer la memoria de Android que comienza aquí. enlace

Usando la volatilidad puede extraer cadenas, ver el proceso en ejecución, etc. La base de volatilidad tiene una excelente publicación de blog aquí sobre la identificación de claves de cifrado AES para criptografía verdadera en un volcado de memoria. enlace

Parece que podría usar una metodología muy similar en su caso de uso. Espero que esto pueda ser de alguna ayuda.

    
respondido por el Escher 28.12.2015 - 01:08
fuente
0

Puedes usar GameGuardian para esto. Necesitas root.

Pestaña del editor de memoria - menú - volcado de memoria - seleccionar rango y carpeta - presionar OK - esperar a que aparezca el final de volcado ".

Aquí hay algunos ejemplos de videos de cómo hacer esto:

respondido por el Enyby 25.03.2017 - 05:32
fuente

Lea otras preguntas en las etiquetas