请问斑竹这应该学习啥书？

dancingpig

1. 
   
2. 1. vi shellcode.c
   
3. 
   
4. #include
   
5. int main ( int argc, char * argv[] )
   
6. {
   
7.     char * name[2];
   
8.     name[0] = "/bin/ksh";
   
9.     name[1] = NULL;
   
10.     execve( name[0], name, NULL );
    
11.     return 0;
    
12. }
    
13. 
    
14. 2. gcc -o shellcode -ggdb -static shellcode.c
    
15. 
    
16. 3. gdb shellcode
    
17. 
    
18. [scz@ /home/scz/src]> gdb shellcode
    
19. GNU gdb 4.17.0.11 with Linux support
    
20. This GDB was configured as "i386-redhat-linux"...
    
21. (gdb) disassemble main <-- -- -- 输入
    
22. Dump of assembler code for function main:
    
23. 0x80481a0 :       pushl  %ebp
    
24. 0x80481a1 :     movl   %esp,%ebp
    
25. 0x80481a3 :     subl   $0x8,%esp
    
26. 0x80481a6 :     movl   $0x806f308,0xfffffff8(%ebp)
    
27. 0x80481ad :    movl   $0x0,0xfffffffc(%ebp)
    
28. 0x80481b4 :    pushl  $0x0
    
29. 0x80481b6 :    leal   0xfffffff8(%ebp),%eax
    
30. 0x80481b9 :    pushl  %eax
    
31. 0x80481ba :    movl   0xfffffff8(%ebp),%eax
    
32. 0x80481bd :    pushl  %eax
    
33. 0x80481be :    call   0x804b9b0 <__execve>
    
34. 0x80481c3 :    addl   $0xc,%esp
    
35. 0x80481c6 :    xorl   %eax,%eax
    
36. 0x80481c8 :    jmp    0x80481d0
    
37. 0x80481ca :    leal   0x0(%esi),%esi
    
38. 0x80481d0 :    leave
    
39. 0x80481d1 :    ret
    
40. End of assembler dump.
    
41. (gdb) disas __execve <-- -- -- 输入
    
42. Dump of assembler code for function __execve:
    
43. 0x804b9b0 <__execve>:   pushl  %ebx
    
44. 0x804b9b1 <__execve+1>: movl   0x10(%esp,1),%edx
    
45. 0x804b9b5 <__execve+5>: movl   0xc(%esp,1),%ecx
    
46. 0x804b9b9 <__execve+9>: movl   0x8(%esp,1),%ebx
    
47. 0x804b9bd <__execve+13>:        movl   $0xb,%eax
    
48. 0x804b9c2 <__execve+18>:        int    $0x80
    
49. 0x804b9c4 <__execve+20>:        popl   %ebx
    
50. 0x804b9c5 <__execve+21>:        cmpl   $0xfffff001,%eax
    
51. 0x804b9ca <__execve+26>:        jae    0x804bcb0 <__syscall_error>
    
52. 0x804b9d0 <__execve+32>:        ret
    
53. End of assembler dump.
    
54. 
    
55. 4. 研究 main() 函数的汇编代码
    
56. 
    
57. 0x80481a0 :       pushl  %ebp      # 保存原来的栈基指针
    
58.                                          # 栈基指针与堆栈指针不是一个概念
    
59.                                          # 栈基指针对应栈底，堆栈指针对应栈顶
    
60. 0x80481a1 :     movl   %esp,%ebp # 修改得到新的栈基指针
    
61.                                          # 与我们以前在dos下汇编格式不一样
    
62.                                          # 这个语句是说把esp的值赋给ebp
    
63.                                          # 而在dos下，正好是反过来的，一定要注意
    
64. 0x80481a3 :     subl   $0x8,%esp # 堆栈指针向栈顶移动八个字节
    
65.                                          # 用于分配局部变量的存储空间
    
66.                                          # 这里具体就是给 char * name[2] 预留空间
    
67.                                          # 因为每个字符指针占用4个字节，总共两个指针
    
68. 0x80481a6 :     movl   $0x806f308,0xfffffff8(%ebp)
    
69.                                          # 将字符串"/bin/ksh"的地址拷贝到name[0]
    
70.                                          # name[0] = "/bin/ksh";
    
71.                                          # 0xfffffff8(%ebp) 就是 ebp - 8 的意思
    
72.                                          # 注意堆栈的增长方向以及局部变量的分配方向
    
73.                                          # 先分配name[0]后分配name[1]的空间
    
74. 0x80481ad :    movl   $0x0,0xfffffffc(%ebp)
    
75.                                          # 将NULL拷贝到name[1]
    
76.                                          # name[1] = NULL;
    
77. 0x80481b4 :    pushl  $0x0
    
78.                                          # 按从右到左的顺序将execve()的三个参数依次压栈
    
79.                                          # 首先压入 NULL (第三个参数)
    
80.                                          # 注意pushl将压入一个四字节长的0
    
81. 0x80481b6 :    leal   0xfffffff8(%ebp),%eax
    
82.                                          # 将 ebp - 8 本身放入eax寄存器中
    
83.                                          # leal的意思是取地址，而不是取值
    
84. 0x80481b9 :    pushl  %eax      # 其次压入 name
    
85. 0x80481ba :    movl   0xfffffff8(%ebp),%eax
    
86. 0x80481bd :    pushl  %eax      # 将 ebp - 8 本身放入eax寄存器中
    
87.                                          # 最后压入 name[0]
    
88.                                          # 即 "/bin/ksh" 字符串的地址
    
89. 0x80481be :    call   0x804b9b0 <__execve>
    
90.                                          # 开始调用 execve()
    
91.                                          # call指令首先会将返回地址压入堆栈
    
92. 0x80481c3 :    addl   $0xc,%esp
    
93.                                          # esp + 12
    
94.                                          # 释放为了调用 execve() 而压入堆栈的内容
    
95. 0x80481c6 :    xorl   %eax,%eax
    
96. 0x80481c8 :    jmp    0x80481d0
    
97. 0x80481ca :    leal   0x0(%esi),%esi
    
98. 0x80481d0 :    leave
    
99. 0x80481d1 :    ret
    
100. 
     
101. 5. 研究 execve() 函数的执行过程
     
102. 
     
103. Linux在寄存器里传递它的参数给系统调用，用软件中断跳到kernel模式(int $0x80)
     
104. 
     
105. 0x804b9b0 <__execve>:   pushl  %ebx      # ebx压栈
     
106. 0x804b9b1 <__execve+1>: movl   0x10(%esp,1),%edx
     
107.                                          # 把 esp + 16 本身赋给edx
     
108.                                          # 为什么是16，因为栈顶现在是ebx
     
109.                                          # 下面依次是返回地址、name[0]、name、NULL
     
110.                                          # edx --> NULL
     
111. 0x804b9b5 <__execve+5>: movl   0xc(%esp,1),%ecx
     
112.                                          # 把 esp + 12 本身赋给 ecx
     
113.                                          # ecx --> name
     
114.                                          # 命令的参数数组，包括命令自己
     
115. 0x804b9b9 <__execve+9>: movl   0x8(%esp,1),%ebx
     
116.                                          # 把 esp + 8 本身赋给 ebx
     
117.                                          # ebx --> name[0]
     
118.                                          # 命令本身，"/bin/ksh"
     
119. 0x804b9bd <__execve+13>:        movl   $0xb,%eax
     
120.                                          # 设置eax为0xb，这是syscall表中的索引
     
121.                                          # 0xb对应execve
     
122. 0x804b9c2 <__execve+18>:        int    $0x80
     
123.                                          # 软件中断，转入kernel模式
     
124. 0x804b9c4 <__execve+20>:        popl   %ebx
     
125.                                          # 恢复ebx
     
126. 0x804b9c5 <__execve+21>:        cmpl   $0xfffff001,%eax
     
127. 0x804b9ca <__execve+26>:        jae    0x804bcb0 <__syscall_error>
     
128.                                          # 判断返回值，报告可能的系统调用错误
     
129. 0x804b9d0 <__execve+32>:        ret      # execve() 调用返回
     
130.                                          # 该指令会用压在堆栈中的返回地址
     
131. 
     
132. 从上面的分析可以看出，完成 execve() 系统调用，我们所要做的不过是这么几项而已：
     
133. 
     
134.     a) 在内存中有以NULL结尾的字符串"/bin/ksh"
     
135.     b) 在内存中有"/bin/ksh"的地址，其后是一个 unsigned long 型的NULL值
     
136.     c) 将0xb拷贝到寄存器EAX中
     
137.     d) 将"/bin/ksh"的地址拷贝到寄存器EBX中
     
138.     e) 将"/bin/ksh"地址的地址拷贝到寄存器ECX中
     
139.     f) 将 NULL 拷贝到寄存器EDX中
     
140.     g) 执行中断指令int $0x80
     
141. 
     
142. 如果execve()调用失败的话，程序将继续从堆栈中获取指令并执行，而此时堆栈中的数据
     
143. 是随机的，通常这个程序会core dump。我们希望如果execve调用失败的话，程序可以正
     
144. 常退出，因此我们必须在execve调用后增加一个exit系统调用。
     

复制代码

这段东东偶看8大明白，请问斑竹要学习那方面的书？有推荐的满？

_z_

man execve
man gcc
man gdb

kj501

要看懂这样一段东东，首先要懂得linux的系统程序设计。然后是AT&T格式的汇编，熟悉各种系统调用。再熟悉linux的编程环境，自然没有问题。

dancingpig

我在学习c~
汇编以前学过ibm的……看4看的懂点……8过好象一大堆东西放在17就有点迷糊不知道啥结果……
有撒书可以参考捏？