试图从内存中打印出有用的数据

时间:2018-05-10 10:26:16

标签: c windows memory hexdump

void update_memblock(MEMBLOCK *mb)
{
    static unsigned char tempbuf[128 * 1024];
    SIZE_T bytes_left;
    SIZE_T total_read;
    SIZE_T bytes_to_read;
    SIZE_T bytes_read;

    bytes_left = mb->size;
    total_read = 0;

    while (bytes_left)
    {
        bytes_to_read = (bytes_left > sizeof(tempbuf)) ? 
sizeof(tempbuf) : bytes_left;
        ReadProcessMemory(mb->hProc, mb->addr + total_read, 
tempbuf, bytes_to_read, &bytes_read);
        if (bytes_read != bytes_to_read) break;

        memcpy(mb->buffer + total_read, tempbuf, bytes_read);

        bytes_left -= bytes_read;
        total_read += bytes_read;
    }
    mb->size = total_read;
}

这是我目前的代码,我最初正在阅读另一个流程'内存使用ReadProcessMemory。现在我将临时数据存储在tempbuf中。我能够以十六进制形式从tempbuf输出数据。但是我打算如图所示显示它,另外我面临的另一个复杂因素是bytes_left> sizeof(tempbuf)我只读取相当于tempbuf大小的足够数据。如何读取更多数据,因为我定义的数组只能支持尽可能多的数据?

in_this_format

2 个答案:

答案 0 :(得分:5)

如果我理解正确,你的主要问题是如何模仿十六进制编辑器的输出。

这可以分为三个部分:

  1. 打印地址
  2. 打印每个字节的十六进制值
  3. 打印每个字节的ASCII值
  4. 以十六进制打印地址很容易。我们可以使用%p打印指针的地址,如下所示:

    char* mem = malloc(99);
    printf("%p\n", (void*)mem);
    // output: 0xc17080
    

    接下来,您可以在char(1字节)上使用%02x打印字节的十六进制值。 02指定零填充字段宽度为2.在这种情况下,只需将0打印为00即可使内容排列整齐,看起来很漂亮。

    printf("%02x", mem[0]);
    // output: 0A
    

    最后,打印ASCII是最简单的......差不多。我们可以使用%c为某些ASCII值打印字节,但我们不想打印\n\t之类的内容。要解决此问题,我们可以将%c的使用限制在ASCII table的字符/符号区域,并为其他所有内容打印.

    char c = mem[0];
    if ( ' ' <= c && c <= '~' ) {
         printf("%c", c);
    }
    else {
         printf(".");
    }
    //output: .
    

    现在我们只需将这些组合在一起。您可以决定每行要显示的字节数,并打印“[地址] [n十六进制字节] [n ascii字节]”并重复,直到您完成整个存储区域。我在下面给出了一个示例函数,您可以自己运行here

    void display_mem(void* mem, int mem_size, int line_len) {
       /*
            mem         - pointer to beggining of memory region to be printed
            mem_size    - number of bytes mem points to
            line_len    - number of bytyes to display per line
       */
    
        unsigned char* data = mem;
        int full_lines = mem_size / line_len;
        unsigned char* addr = mem;
    
        for (int linno = 0; linno < full_lines; linno++) {
            // Print Address
            printf("0x%x\t", addr);
    
            // Print Hex
            for (int i = 0; i < line_len; i++) {
                printf(" %02x", data[linno*line_len + i]);
            }
            printf("\t");
    
            // Print Ascii
            for (int i = 0; i < line_len; i++) {
                char c = data[linno*line_len + i];
                if ( 32 < c && c < 125) {
                    printf(" %c", c);
                }
                else {
                    printf(" .");
                }
            }
            printf("\n");
    
            // Incremement addr by number of bytes printed
            addr += line_len;
        }
    
        // Print any remaining bytes that couldn't make a full line
        int remaining = mem_size % line_len;
        if (remaining > 0) {
            // Print Address
            printf("0x%x\t", addr);
    
            // Print Hex
            for (int i = 0; i < remaining; i++) {
                printf(" %02x", data[line_len*full_lines + i]);
            }
            for (int i = 0; i < line_len - remaining; i++) {
                printf("  ");
            }
            printf("\t");
    
            // Print Hex
            for (int i = 0; i < remaining; i++) {
                char c = data[line_len*full_lines + i];
                if ( 32 < c && c < 125) {
                    printf(" %c", c);
                }
                else {
                    printf(" .");
                }
            }
            printf("\n");
         }
     }
    

    示例输出:

    0x1e79010        74 65 73 74 79 2a 6e    t e s t y * n
    0x1e79017        0c 3e 24 45 5e 33 27    . > $ E ^ 3 '
    0x1e7901e        18 51 09 2d 76 7e 4a    . Q . - v . J
    0x1e79025        12 53 0f 6e 0b 1a 6d    . S . n . . m
    0x1e7902c        31 6e 03 2b 01 2f 2c    1 n . + . / ,
    0x1e79033        72 59 1c 76 18 38 3c    r Y . v . 8 <
    0x1e7903a        6e 6b 5b 00 36 64 25    n k [ . 6 d %
    0x1e79041        2d 5c 6f 38 30 00 27    - \ o 8 0 . '
    0x1e79048        33 12 15 5c 01 18 09    3 . . \ . . .
    0x1e7904f        02 40 2d 6c 1a 41 63    . @ - l . A c
    0x1e79056        2b 72 18 1a 5e 74 12    + r . . ^ t .
    0x1e7905d        0d 51 38 33 26 28 6b    . Q 8 3 & ( k
    0x1e79064        56 20 0b 0b 32 20 67    V . . . 2 . g
    0x1e7906b        34 30 68 2e 70 0f 1c    4 0 h . p . .
    0x1e79072        04 50                   . P
    

    至于你问题的第二部分,如果你不能增加tempbuf的大小,那么你就会在任何时候处理这​​段内存。

    但是,如果你想要做的只是如上所述显示内存,你可以以块的形式显示每个内存部分。你可以获得一块内存,显示它,然后获得一个新的块,显示新的块,重复。

    的内容
    while (bytes_left) {
        ReadProcessMemory(mb->hProc, mb->addr + total_read, tempbuf, bytes_to_read, &bytes_read);
        // Get new chunk
        memcpy(mb->buffer + total_read, tempbuf, bytes_read);
    
        // Display chunk
        display_mem(tempbuf, bytes_read);
    
        bytes_left -= bytes_read;
    }
    

    您需要做更多的工作来检查错误并使一切看起来不错,但希望能让您对可以做的事情有所了解。

答案 1 :(得分:3)

无法存储比分配空间更多的数据。如果需要存储更多数据,则需要在某处分配更多空间(更多RAM,磁盘文件等)。压缩将允许您在分配的空间中存储更多数据,但您不会获得那么多。对于几乎无限制的存储,您将需要写入磁盘。

或者,如果你只需要显示一次然后就可以忘记,读入16个字节,显示该行,然后将下16个字节读入同一个存储器。