Bagaimana saya membaca dari / proc / $ pid / mem di Linux?

The Linux proc(5)halaman manual memberitahu saya bahwa /proc/$pid/mem“dapat digunakan untuk mengakses halaman memori proses ini”. Tetapi upaya langsung untuk menggunakannya hanya memberi saya

$ cat /proc/$$/mem /proc/self/mem
cat: /proc/3065/mem: No such process
cat: /proc/self/mem: Input/output error

Mengapa tidak catdapat mencetak memorinya sendiri ( /proc/self/mem)? Dan apa kesalahan "proses seperti ini" yang aneh ketika saya mencoba mencetak memori shell ( /proc/$$/mem, jelas prosesnya ada)? Bagaimana saya bisa membaca /proc/$pid/mem?

/proc/$pid/maps

/proc/$pid/memmemperlihatkan isi memori $ pid yang dipetakan dengan cara yang sama seperti dalam proses, yaitu byte pada offset x dalam file pseudo sama dengan byte pada alamat x dalam proses. Jika alamat tidak dipetakan dalam proses, bacalah dari offset yang sesuai dalam file yang dikembalikan EIO(Kesalahan input / output). Sebagai contoh, karena halaman pertama dalam suatu proses tidak pernah dipetakan (sehingga dereferencing NULLpointer gagal dengan bersih daripada mengakses memori yang sebenarnya), membaca byte pertama /proc/$pid/memselalu menghasilkan kesalahan I / O.

Cara untuk mengetahui bagian mana dari memori proses yang dipetakan adalah dengan membaca /proc/$pid/maps. File ini berisi satu baris per wilayah yang dipetakan, terlihat seperti ini:

08048000-08054000 r-xp 00000000 08:01 828061     /bin/cat
08c9b000-08cbc000 rw-p 00000000 00:00 0          [heap]

Dua angka pertama adalah batas wilayah (alamat byte pertama dan byte setelah yang terakhir, dalam heksa). Kolom berikutnya berisi izin, lalu ada beberapa informasi tentang file (offset, perangkat, inode, dan nama) jika ini adalah pemetaan file. Lihat proc(5)halaman manual atau Memahami Linux / proc / id / maps untuk informasi lebih lanjut.

Berikut ini skrip proof-of-concept yang membuang konten dari ingatannya sendiri.

#! /usr/bin/env python
import re
maps_file = open("/proc/self/maps", 'r')
mem_file = open("/proc/self/mem", 'r', 0)
for line in maps_file.readlines():  # for each mapped region
    m = re.match(r'([0-9A-Fa-f]+)-([0-9A-Fa-f]+) ([-r])', line)
    if m.group(3) == 'r':  # if this is a readable region
        start = int(m.group(1), 16)
        end = int(m.group(2), 16)
        mem_file.seek(start)  # seek to region start
        chunk = mem_file.read(end - start)  # read region contents
        print chunk,  # dump contents to standard output
maps_file.close()
mem_file.close()

/proc/$pid/mem

Jika Anda mencoba membaca dari file mempseudo dari proses lain, itu tidak berfungsi: Anda mendapatkan ESRCHkesalahan (Tidak ada proses seperti itu).

Izin pada /proc/$pid/mem( r--------) lebih liberal daripada yang seharusnya. Misalnya, Anda seharusnya tidak dapat membaca memori proses setuid. Lebih jauh lagi, mencoba membaca memori suatu proses ketika proses memodifikasi itu dapat memberikan pembaca pandangan yang tidak konsisten dari memori, dan lebih buruk lagi, ada kondisi ras yang dapat melacak versi Linux kernel yang lebih lama (menurut utas lkml ini , meskipun saya tidak tahu detailnya). Jadi diperlukan pemeriksaan tambahan:

• Proses yang ingin dibaca /proc/$pid/memharus dilampirkan ke proses menggunakan ptracedengan PTRACE_ATTACHbendera. Inilah yang dilakukan para debugger ketika mereka memulai proses debug; itu juga apa yang stracedilakukan untuk panggilan sistem suatu proses. Setelah pembaca selesai membaca dari /proc/$pid/mem, pembaca harus melepaskan dengan memanggil ptracedengan PTRACE_DETACHbendera.
• Proses yang diamati tidak boleh berjalan. Biasanya panggilan ptrace(PTRACE_ATTACH, …)akan menghentikan proses target (mengirimkan STOPsinyal), tetapi ada kondisi balapan (pengiriman sinyal asinkron), sehingga pelacak harus menelepon wait(seperti yang didokumentasikan dalam ptrace(2)).

Sebuah proses yang berjalan sebagai root dapat membaca memori proses apa pun, tanpa perlu memanggil ptrace, tetapi proses yang diamati harus dihentikan, atau pembacaan akan tetap kembali ESRCH.

Dalam sumber kernel Linux, kode menyediakan entri per-proses di /procdalam fs/proc/base.c, dan fungsi untuk membaca dari /proc/$pid/memadalah mem_read. Pemeriksaan tambahan dilakukan oleh check_mem_permission.

Berikut ini beberapa contoh kode C untuk dilampirkan ke suatu proses dan membaca sebagian dari memfilenya (pengecekan kesalahan dihilangkan):

sprintf(mem_file_name, "/proc/%d/mem", pid);
mem_fd = open(mem_file_name, O_RDONLY);
ptrace(PTRACE_ATTACH, pid, NULL, NULL);
waitpid(pid, NULL, 0);
lseek(mem_fd, offset, SEEK_SET);
read(mem_fd, buf, _SC_PAGE_SIZE);
ptrace(PTRACE_DETACH, pid, NULL, NULL);

Saya sudah memasang skrip proof-of-concept untuk dibuang /proc/$pid/memdi utas lain .

Perintah ini (dari gdb) membuang memori dengan andal:

gcore pid

Dump bisa besar, gunakan -o outfilejika direktori Anda saat ini tidak memiliki cukup ruang.

Ketika Anda menjalankan cat /proc/$$/memvariabel $$dievaluasi oleh oleh bash yang menyisipkan pid sendiri. Ini kemudian mengeksekusi catyang memiliki pid berbeda. Anda berakhir dengan catmencoba membaca memori bash, proses induknya. Karena proses yang tidak istimewa hanya dapat membaca ruang memori mereka sendiri, ini ditolak oleh kernel.

Ini sebuah contoh:

$ echo $$
17823

Catatan yang $$mengevaluasi ke 17823. Mari kita lihat proses mana yang.

$ ps -ef | awk '{if ($2 == "17823") print}'
bahamat  17823 17822  0 13:51 pts/0    00:00:00 -bash

Ini shell saya saat ini.

$ cat /proc/$$/mem
cat: /proc/17823/mem: No such process

Di sini lagi $$mengevaluasi ke 17823, yang merupakan shell saya. cattidak dapat membaca ruang memori shell saya.

Berikut ini adalah program kecil yang saya tulis di C:

Pemakaian:

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

Program ini menggunakan / proc / $ pid / maps untuk menemukan semua wilayah memori yang dipetakan dari proses, dan kemudian membaca wilayah tersebut dari / proc / $ pid / mem, satu halaman sekaligus. halaman tersebut ditulis ke stdout atau alamat IP dan port TCP yang Anda tentukan.

Kode (diuji pada Android, memerlukan izin pengguna super):

#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);
    }
}