mmap()函数疑问？

_nosay

回复 9# Tinnal

噢，有道理。

nswcfd

回复 8# _nosay

这不是背着glibc过河拆桥嘛……

_nosay

回复 7# nswcfd

http://my.oschina.net/fgq611/blog/181812

nswcfd

是的，一般kernel exploit都是这个思路。

不过这个链接里少一个很关键的内存布局图，http://doc.ithao123.cn/uploads/u ... 5aaaac9b6103534.jpg

_nosay

回复 14# nswcfd

嗯，我发的那个链接里显示不了这个图，第一次看exploit程序，感觉还是很巧妙的，但我的问题还是关于MAP_FIXED：

mmap_start = 0x10000;
mmap_size = 0x120000;

这块空间为什么可以用MAP_FIXED方式映射，不用担心像我在8楼举的例子那样吗？
还是像Tinnal版主说的那样，内存的使用是有规划的，比如这块就是规划给MAP_FIXED用的？
那有规划的规范吗，比如说0x某某~0x某某，是专门留给某某用的？

_nosay

回复 13# _nosay

1. #include <stdio.h>
   
2. 
   
3. 
   
4. struct s_fun {
   
5.         void (*fun)(int, int);
   
6. };
   
7. 
   
8. struct s_target {
   
9.         unsigned int target;
   
10. };
    
11. 
    
12. void fun(int m, int n)
    
13. {
    
14.         printf("m = %d, n = %d\n", m, n);
    
15. }
    
16. 
    
17. void target()
    
18. {
    
19.         printf("hello\n");
    
20. 
    
21. #if 0
    
22. __asm__ __volatile__(
    
23.                 "popl %%ebx\n\t"
    
24.                 "popl %%ebx\n\t"
    
25.                 :::"ebx"
    
26.         );
    
27. #endif
    
28. }
    
29. 
    
30. // __cdecl__ default
    
31. int /*__attribute__((__stdcall__))*/ main()
    
32. {
    
33.         struct s_fun f[1] = { {fun} };
    
34.         struct s_target t = { 0x08048462 };  // objdump -d
    
35. 
    
36.         printf("%p, %p\n", &f[1], &t);
    
37.         printf("0x%x, 0x%x\n", sizeof(f[1]), sizeof(t));
    
38. 
    
39.         printf("0x%x\n", (unsigned int)f[0].fun);
    
40.         printf("0x%x, 0x%x\n", (unsigned int)f[1].fun, ((struct s_target*)&f[1])->target);
    
41. 
    
42.         f[0].fun(0, 0);
    
43.         f[1].fun(1, 1);  // overflow to target()
    
44. 
    
45.         return 0;
    
46. }

复制代码

这个程序用于模拟“利用溢出执行指定目标代码”的效果，即f[1].fun(1,1)实际上执行的是target()，打印结果如下：
[121] $ ./a.out
0xbfb1a4cc, 0xbfb1a4cc
0x4, 0x4
0x8048440
0x8048462
0x8048462
m = 0, n = 0
hello

但实验过程中我产生了一个疑问：由于调用时传了2个参数，肯定是压到栈里去了，但并没什么什么地方进行堆栈平衡处理，为什么程序没有coredump？
我最先想到的是linux函数调用默认采用的是__cdecl__方式，gcc会在f[1].fun(1,1)调用之后自动加上出栈的指令，但指定main()调用方式为__stdcall__，程序仍然正常结束了。。

后来看了一下main()函数反汇编的结果是这样的：

1. 8048476:       55                      push   %ebp
   
2. 8048477:       89 e5                   mov    %esp,%ebp
   
3. 8048479:       83 e4 f0                and    $0xfffffff0,%esp
   
4. 804847c:       83 ec 20                sub    $0x20,%esp                // 虽然只有8字节的局部变量，但分配了0x20大小的栈帧
   
5. ...
   
6. 80484ff:       8b 44 24 18             mov    0x18(%esp),%eax
   
7. 8048503:       c7 44 24 04 00 00 00    movl   $0x0,0x4(%esp)  // 参数0，不会覆盖局部变量
   
8. 804850a:       00
   
9. 804850b:       c7 04 24 00 00 00 00    movl   $0x0,(%esp)        // 参数0，不会覆盖局部变量
   
10. 8048512:       ff d0                   call   *%eax                            // 调用f[1].fun(0, 0)
    
11. 8048514:       8b 44 24 1c             mov    0x1c(%esp),%eax
    
12. 8048518:       c7 44 24 04 01 00 00    movl   $0x1,0x4(%esp)
    
13. 804851f:       00
    
14. 8048520:       c7 04 24 01 00 00 00    movl   $0x1,(%esp)
    
15. 8048527:       ff d0                   call   *%eax
    
16. 8048529:       b8 00 00 00 00          mov    $0x0,%eax
    
17. 804852e:       c9                      leave
    
18. 804852f:       c3                      ret

复制代码

可以看出，main()分配了0x20大小的栈帧，0x1c(%esp)、0x18(%esp)用于保存局部变量f[]和t，0x14(%esp)~(%esp)用于传参，这样可以省掉出栈的过程，提高执行效率，分析的应该没错吧 ？

nswcfd

回复 15# _nosay

明白问题了，怎么保证exploit选择的MAP_FIXED地址，没有被程序中的malloc代码（直接或间接的）用到，是这个意思吧？

布局是够规划的，参见Document/x86/x86_64/mm.txt

Virtual memory map with 4 level page tables:

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

The direct mapping covers all memory in the system up to the highest
memory address (this means in some cases it can also include PCI memory
holes).

vmalloc space is lazily synchronized into the different PML4 pages of
the processes using the page fault handler, with init_level4_pgt as
reference.

Current X86-64 implementations only support 40 bits of address space,
but we support up to 46 bits. This expands into MBZ space in the page tables.

-Andi Kleen, Jul 2004


   

_nosay

回复 17# nswcfd

没看懂，Linux-2.4.0的代码里没有这个文档，你看的代码是哪个版本？

nswcfd

2.6.32的版本。

不过这个文件好像也没有规定user space应该怎么布局，不确定是否在其它Document/文件提到。

user space的布局通常是这个样子，http://www.cnblogs.com/cherishui/p/4235145.html

_nosay

回复 19# nswcfd

反正意思就是，内核会保证用户态一定有一块区间，malloc是不会使用的，如果非要MAP_FIXED的话，就可以用这块区间，是吧？