Use MMAP/dev/MEM to read and write Linux memory-root permission

Use MMAP/dev/MEM to read and write Linux memory
Category:
Linux Kernel

114 reading comments (1)
Favorites
Report

Use hexedit/dev/MEM to display information in all physical memory. Use MMAP to map/dev/MEM, and then directly read and write it to implement kernel operations in the user space.

Below is a sample I wrote

View plain

1. # Include <stdio. h>
2. # Include <unistd. h>
3. # Include <sys/Mman. h>
4. # Include <sys/types. h>
5. # Include <sys/STAT. h>
6. # Include <fcntl. h>
8. Int main ()
9. {
10. Unsigned char * map_base;
11. File * F;
12. Int N, FD;
14. FD = open ("/dev/mem", o_rdwr | o_sync );
15. If (FD =-1)
16. {
17. Return (-1 );
18. }
20. Map_base = MMAP (null, 0xff, prot_read | prot_write, map_shared, FD, 0x20000 );
22. If (map_base = 0)
23. {
24. Printf ("null pointer! \ N ");
25. }
26. Else
27. {
28. Printf ("successfull! \ N ");
29. }
31. Unsigned long ADDR;
32. Unsigned char content;
34. Int I = 0;
35. For (; I <0xff; ++ I)
36. {
37. ADDR = (unsigned long) (map_base + I );
38. Content = map_base [I];
39. Printf ("Address: 0x % lx content 0x % x \ t", ADDR, (unsigned INT) content );
41. Map_base [I] = (unsigned char) I;
42. Content = map_base [I];
43. Printf ("updated address: 0x % lx content 0x % x \ n", ADDR, (unsigned INT) content );
44. }
46. Close (FD );
48. Munmap (map_base, 0xff );
50. Return (1 );
51. }

In the preceding example, the starting address 0x20000 (physical address) is mapped to 0xff. Then you can operate the memory like an ordinary array.

The output result is as follows:

Address: 0x7f3f95391000 content 0x0 updated address: 0x7f3f95391000 content 0x0
Address: 0x7f3f95391001 content 0x0 updated address: 0x7f3f95391001 content 0x1
Address: 0x7f3f95391002 content 0x0 updated address: 0x7f3f95391002 content 0x2
Address: 0x7f3f95391003 content 0x0 updated address: 0x7f3f95391003 content 0x3
Address: 0x7f3f95391004 content 0x0 updated address: 0x7f3f95391004 content 0x4
...

My testing machine is a 64-bit machine. In this example, the physical address 0x20000 is mapped to the virtual address 0x7f3f95391000.

First, output the content under the current address, and then write a new value.

You can use hexedit/dev/MEM to verify that the new value has been written.

This can be done if you want to process the address allocated by the kernel in user mode. First, use pai_addr = get_free_pages (gfp_kernel, order) to allocate memory, use phy_addr = _ Pa (pai_addr) to obtain the physical address, and then map/dev/MEM with MMAP in the user State, offset is phy_addr, and length is set to 2 ^ order. Now you can read and write the memory allocated by the kernel in user mode.

Note: This operation requires the root permission.