在内核窥视用户态

zyr-linux

在内核窥视用户态

首先，环境：VMware Server上运行的ubuntu10.4，arch为x86_64。


先看下面这个程序：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. 
   
6. int dataA;
   
7. char bufA[1000];
   
8. 
   
9. int main()
   
10. {
    
11.         int dataB;
    
12. 
    
13.         int i_GetChar;
    
14. 
    
15.         char * bufB = NULL;
    
16. 
    
17.         bufB = malloc(1500);
    
18. 
    
19.         if (NULL == bufB)
    
20.         {
    
21.                 printf("malloc failed\n");
    
22. 
    
23.                 return 0;
    
24.         }
    
25. 
    
26.         dataA = 0X55aa;
    
27. 
    
28.         dataB = 0Xaa55;
    
29. 
    
30.         memcpy(bufA, "bufA org data", strlen("bufA org data"));
    
31. 
    
32.         memcpy(bufB, "bufB org data", strlen("bufB org data"));
    
33. 
    
34.         printf("bufA = %p, bufB = %p, &dataA = %p, &dataB = %p\n", bufA, bufB, &dataA, &dataB);
    
35.        
    
36. 
    
37.         for ( ; ; )
    
38.         {
    
39.                 printf("get char(p:print; e:exit):");
    
40.                
    
41.                 i_GetChar = getchar();
    
42. 
    
43.                 if ('p' == i_GetChar)
    
44.                 {
    
45.                         printf("bufA: %s\n", bufA);
    
46.                         printf("bufA: %s\n", bufB);
    
47.                         printf("dataA: 0x%x\n", dataA);
    
48.                         printf("dataA: 0x%x\n", dataB);
    
49.                 }
    
50.                 else if ('e' == i_GetChar)
    
51.                 {
    
52.                         break;
    
53.                 }
    
54.         }
    
55. 
    
56.         free(bufB);
    
57.        
    
58.         return 0;
    
59. }

复制代码

这个程序中有：
一个int型的全局变量dataA；
一个int型的局部变量dataB；
一个char型的全局数组bufA；
一段malloc的空间bufB。

程序先输出以上变量的地址，然后按"p"输出一次内容，按"e"退出程序。



接下来，简单的分析一下：
bufA = 0x601080, bufB = 0x6a0010, &dataA = 0x601468, &dataB = 0x7fff337284ac
仅从地址上看，他们就在不同的内存区域。
bufA和dataA是全局变量，在数据区；
bufB是malloc来的，在堆中；
dataB是局部变量，在进程的运行栈中。

抄一段linux自带的关于x86_64下地址空间的说明：

0000000000000000 - 00007fffffffffff (=47 bits) user space, different per mm
hole caused by [48:63] sign extension
ffff800000000000 - ffff80ffffffffff (=40 bits) guard hole
ffff880000000000 - ffffc7ffffffffff (=64 TB) direct mapping of all phys. memory
ffffc80000000000 - ffffc8ffffffffff (=40 bits) hole
ffffc90000000000 - ffffe8ffffffffff (=45 bits) vmalloc/ioremap space
ffffe90000000000 - ffffe9ffffffffff (=40 bits) hole
ffffea0000000000 - ffffeaffffffffff (=40 bits) virtual memory map (1TB)
... unused hole ...
ffffffff80000000 - ffffffffa0000000 (=512 MB)  kernel text mapping, from phys 0
ffffffffa0000000 - fffffffffff00000 (=1536 MB) module mapping space

可见，这些变量的地址都在user space中。

对各个用户态进程来说，地址空间都是0000000000000000 - 00007fffffffffff，而不会冲突；
因为这只是虚拟地址，每个用户态进程都拥有自身的页表，相同的虚拟地址地址经过不同的页表转换为不同的物理地址；
而内核的页表并不映射user space，这些后面会用到。

zyr-linux

内核中，每个进程有个结构体存放相关信息：struct task_struct；
struct task_struct内容很多，现在只找和内存资源相关的struct mm_struct *mm；

struct mm_struct中内容很多也很多，目前关心的是下面几个：
1，保存了进程使用的各个地址区域（vma）的struct vm_area_struct * mmap;；
2，保存了进程页表的位置的pgd_t * pgd；
3，保存进程堆/栈/数据区/代码区地址的一大堆东东
        unsigned long total_vm, locked_vm, shared_vm, exec_vm;
        unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
        unsigned long start_code, end_code, start_data, end_data;
        unsigned long start_brk, brk, start_stack;
        unsigned long arg_start, arg_end, env_start, env_end;

把他们全部打出来看看好了：



bufA和dataA在数据区；bufB是malloc来的，在堆之中；dataB是局部变量，在栈之中。
和理论分析一致！
更重要的是，用户态下输出的地址和内核态下得到的地址范围对的上，那么，这些地址就是虚拟地址。

把页表的第四级打出来，看看。
说明一下，下面两张图是补截的，地址和其他图不能完全对上。




再和内核的页表第四级对比，可以看出什么？

zyr-linux

现在，我们知道了这些变量的虚拟地址，是不是就能直接在内核态下操作了呢？
实践的结果是————OOPS……
因为，用户态进程的虚拟地址，其转换是通过该进程的页表进行，内核的页表没有这些地址的信息。

不过已经知道了页表的位置，自己转一遍：




得到了物理地址，再加上PAGE_OFFSET获得内核态下能够操作的虚拟地址，把内容打出来验证：



最后，尝试修改：



每改一次，在用户态程序上验证一次，结果符合预期：



以上只是一个简单的尝试，因为在一开始就获得了用户态进程中各个变量的地址；
获得了一个用户态进程的堆、栈、数据段、代码段的地址，并能转换为可在内核态下操作的地址；
那么，理论上，可以对该用户态进程做任何事。
但要想实用，还需要进一步的研究，比如通过反编译，objdump之类的手段获得用户态程序中的地址。

chong232

呵呵，大赞！

jinxinxin163

好东东哦

superlzdcn

楼主关键地方代码也贴出来给我们学习学习阿

毛xx总理

是的不错的。

rick_cheung

回复 1# zyr-linux


    能否把程序代码发到我的邮箱？rickcheung@foxmail.com
    多谢啦！

ww2000e

:wink: 看得不太懂

zyr-linux

查找页表，转换地址的代码，linux源代码中有现成的，不过我习惯了自己写。

1. //进行转换是传递信息的结构体
   
2. struct PGT_TansInfo
   
3. {
   
4.         //地址信息
   
5.         unsigned long ul_Vaddr;    //虚拟地址
   
6.         unsigned long ul_Paddr;    //物理地址
   
7. 
   
8.         //页表信息       
   
9.         pgd_t * pst_Level4Table;         //页表位置
   
10.         unsigned long ul_PageSize;       //页大小
    
11.         struct PGT_Level_Info astLevel[PGT_LEVEL_BULL];
    
12. 
    
13. };
    
14. 
    
15. /******************************************************************************
    
16. 
    
17. 函数: int PgtOp_VaddrTrans(struct PGT_TansInfo * vpst_TansInfo)
    
18. 
    
19. 功能: 地址转换函数
    
20. 
    
21. 输入: 1) struct PGT_TansInfo * vpst_TansInfo: 转换信息结构体指针
    
22.              
    
23. 输出: 成功返回0，失败返回非0
    
24. 
    
25. 备注: 转换虚拟地址为物理地址，并纪录转换中信息
    
26.              可用于检查虚拟地址是否正确
    
27. 
    
28. ******************************************************************************/
    
29. int MemTool_VaddrTrans(struct PGT_TansInfo * vpst_TansInfo)
    
30. {
    
31.         unsigned long ul_Index;
    
32.        
    
33.         unsigned long * aul_Talbe = NULL;
    
34. 
    
35.         //参数检查并赋值
    
36.         if ((NULL == vpst_TansInfo) || (NULL == vpst_TansInfo->pst_Level4Table))
    
37.         {
    
38.                 printk("vpst_TansInfo or pst_Level4Table is NULL!\n");
    
39.                 return -1;
    
40.         }
    
41. 
    
42.         //X86_64中，虚拟地址前17bit一致
    
43.         if ((0 != (vpst_TansInfo->ul_Vaddr & MEMTOOL_ADDR_HEAD_MASK))
    
44.                  && (MEMTOOL_ADDR_HEAD_MASK != (vpst_TansInfo->ul_Vaddr & MEMTOOL_ADDR_HEAD_MASK)))
    
45.         {
    
46.                 printk("vaddr 0x%lx is error!\n", vpst_TansInfo->ul_Vaddr);
    
47.                 return -1;
    
48.         }
    
49. 
    
50.         aul_Talbe = (unsigned long *)vpst_TansInfo->pst_Level4Table;
    
51. 
    
52. 
    
53.         //查找第四级页表
    
54. 
    
55.         ul_Index = pgd_index(vpst_TansInfo->ul_Vaddr);
    
56. 
    
57.         if (0 == vpst_TansInfo->pst_Level4Table[ul_Index].pgd)
    
58.         {
    
59.                 return -1;
    
60.         }
    
61.         else
    
62.         {
    
63.                 vpst_TansInfo->astLevel[PGT_LEVEL_LV4].ul_TableAddr = (unsigned long)aul_Talbe;       
    
64.                 vpst_TansInfo->astLevel[PGT_LEVEL_LV4].ul_Index = ul_Index;
    
65.                 vpst_TansInfo->astLevel[PGT_LEVEL_LV4].ul_Value = aul_Talbe[ul_Index];
    
66.         }
    
67. 
    
68.        
    
69.         //查找第三级页表
    
70.         aul_Talbe = (unsigned long *)(PAGE_OFFSET + ((aul_Talbe[ul_Index] & PAGE_MASK) & MEMTOOL_ADDR_NX_MASK));
    
71. 
    
72.         ul_Index = pud_index(vpst_TansInfo->ul_Vaddr);
    
73. 
    
74.         if (0 == aul_Talbe[ul_Index])
    
75.         {
    
76.                 return -1;
    
77.         }
    
78.         else
    
79.         {
    
80.                 vpst_TansInfo->astLevel[PGT_LEVEL_PGD].ul_TableAddr = (unsigned long)aul_Talbe;       
    
81.                 vpst_TansInfo->astLevel[PGT_LEVEL_PGD].ul_Index = ul_Index;
    
82.                 vpst_TansInfo->astLevel[PGT_LEVEL_PGD].ul_Value = aul_Talbe[ul_Index];
    
83. 
    
84. 
    
85.                 //判断是不是1GB页
    
86.                 if (0 != (_PAGE_PAT & aul_Talbe[ul_Index]))
    
87.                 {
    
88.                         vpst_TansInfo->ul_PageSize = PGT_PAGESIZE_1G;
    
89. 
    
90.                         //取物理地址
    
91.                         vpst_TansInfo->ul_Paddr = ((aul_Talbe[ul_Index] & PUD_MASK) & MEMTOOL_ADDR_NX_MASK)
    
92.                                                   + (vpst_TansInfo->ul_Vaddr & (PUD_SIZE - 1));
    
93. 
    
94.                         return 0;
    
95.                 }
    
96.         }
    
97. 
    
98.         //查找第二级页表
    
99.         aul_Talbe = (unsigned long *)(PAGE_OFFSET + ((aul_Talbe[ul_Index] & PAGE_MASK) & MEMTOOL_ADDR_NX_MASK));
    
100. 
     
101.         ul_Index = pmd_index(vpst_TansInfo->ul_Vaddr);
     
102. 
     
103.         if (0 == aul_Talbe[ul_Index])
     
104.         {
     
105.                 return -1;
     
106.         }
     
107.         else
     
108.         {
     
109.                 vpst_TansInfo->astLevel[PGT_LEVEL_PMD].ul_TableAddr = (unsigned long)aul_Talbe;       
     
110.                 vpst_TansInfo->astLevel[PGT_LEVEL_PMD].ul_Index = ul_Index;
     
111.                 vpst_TansInfo->astLevel[PGT_LEVEL_PMD].ul_Value = aul_Talbe[ul_Index];
     
112.         }
     
113. 
     
114.         //判断4K页还是2MB页
     
115.         if (0 == (_PAGE_PAT & aul_Talbe[ul_Index]))
     
116.         {
     
117.                 //4K页，查找第一级页表
     
118.                
     
119.                 aul_Talbe = (unsigned long *)(PAGE_OFFSET + ((aul_Talbe[ul_Index] & PAGE_MASK) & MEMTOOL_ADDR_NX_MASK));
     
120.                
     
121.                 ul_Index = pte_index(vpst_TansInfo->ul_Vaddr);
     
122. 
     
123.                 if (0 == aul_Talbe[ul_Index])
     
124.                 {
     
125.                         return -1;
     
126.                 }
     
127.                 else
     
128.                 {
     
129.                         vpst_TansInfo->astLevel[PGT_LEVEL_PTE].ul_TableAddr = (unsigned long)aul_Talbe;       
     
130.                         vpst_TansInfo->astLevel[PGT_LEVEL_PTE].ul_Index = ul_Index;
     
131.                         vpst_TansInfo->astLevel[PGT_LEVEL_PTE].ul_Value = aul_Talbe[ul_Index];
     
132. 
     
133.                         vpst_TansInfo->ul_PageSize = PGT_PAGESIZE_4K;
     
134. 
     
135.                         //取物理地址
     
136.                         vpst_TansInfo->ul_Paddr = ((aul_Talbe[ul_Index] & PAGE_MASK) & MEMTOOL_ADDR_NX_MASK)
     
137.                                                   + (vpst_TansInfo->ul_Vaddr & (PAGE_SIZE - 1));
     
138. 
     
139.                 }
     
140.        
     
141.         }
     
142.         else
     
143.         {
     
144.                 vpst_TansInfo->ul_PageSize = PGT_PAGESIZE_2M;
     
145.                 //取物理地址
     
146.                 vpst_TansInfo->ul_Paddr = ((aul_Talbe[ul_Index] & PMD_MASK)& MEMTOOL_ADDR_NX_MASK)
     
147.                                           + (vpst_TansInfo->ul_Vaddr & (PMD_SIZE - 1));
     
148.         }
     
149. 
     
150.         return 0;
     
151. 
     
152. }

复制代码