Suki

绵阳城市学院某老师DeepAI查重系统v6.0分析

Sat, 23 May 2026 00:00:00 GMT

前言#

为了防止大家的论文之间出现互相抄袭、复制粘贴等情况，老师准备在收集完全部作业后，用一个指定的查重系统对 .docx 文件进行检测。也就是说，这个软件后面会直接参与期末论文的查重流程。

拿到程序以后，发现它是一个 Windows 下运行的 exe，原来的文件名是中文，放在终端里敲命令、解包、反编译都不太方便，所以我先把它重命名成了 123.exe。这个名字没有特殊含义，单纯就是为了后面操作省事。

这个程序界面上写着 Deep-AI 学术不端检测与多维语义张量分析系统 v6.0，看起来很高级：日志里有 CUDA、SVD、TF-IDF、Multi-Head Attention 之类的词，窗口里还有 3D 语义空间、拓扑网络这些展示。第一眼看上去像是用了某种深度学习模型。

不过真正拆开以后会发现，它并不是把 Python 编译成了原生程序，也没有看到真正的大模型推理。它本质上是一个用 PyInstaller 打包的 Python GUI 程序，核心查重逻辑主要是传统文本相似度算法：N-gram、SimHash，以及代码里写到的 TF-IDF 余弦相似度。

这篇文档记录的是整个分析过程：怎么判断它是 PyInstaller 打包、怎么把 .pyc 还原成源码、核心算法到底怎么算、以及怎么用同一批文档对比原程序和还原版的结果。

第一步：判断它到底是什么#

拿到一个 exe，第一件事不是急着反汇编，而是先搞清楚它的”体质”。

用十六进制编辑器打开，很快就看到了几个关键字符串：

PyInstaller
_MEIPASS
python38.dll
PYZ.pyz

看到这些就基本确定了——这不是用 C/C++ 编译出来的原生程序，而是一个 PyInstaller 打包的 Python 应用。

PyInstaller 的原理说白了就是：把 Python 解释器、所有依赖库、还有你的 Python 字节码（.pyc）一起塞进一个 exe 里。用户双击 exe 时，它先把这些东西解压到临时目录，启动内置的 Python 解释器，然后执行你的代码。

PyInstaller 启动流程

换句话说，这个 exe 本质上是个”自带 Python 运行环境的压缩包”。

这意味着什么？意味着我们不需要去啃 x86 汇编，真正要做的是把字节码从包里掏出来，然后反编译回 Python 源码。

第二步：解包#

确认了打包方式之后，下一步就是拆包。

这里用的是 pyinstxtractor.py，这是一个专门针对 PyInstaller 打包格式的解包工具。运行之后，exe 里的内容被释放到了 123.exe_extracted/ 目录下。

解包出来的东西不少，但我们真正关心的只有一个文件：

1
123.exe_extracted/check.pyc

这就是程序的主入口。.pyc 是 Python 的字节码文件，虽然不是人能直接读的源码，但它保留了完整的程序逻辑结构——变量名、类名、函数调用关系全都在里面。

第三步：反编译#

拿到 .pyc 之后，用 uncompyle6 进行反编译：

Terminal window

1
uncompyle6 123.exe_extracted/check.pyc > recovered_raw/check.py

反编译器跑完之后，确实生成了一份看起来像 Python 的源码。但事情没有那么顺利。

源码还原流程

反编译器不是万能的#

uncompyle6 在处理 Python 3.8 字节码时，有几处明显还原错了。

比如，它把切片操作搞坏了：

1
# 反编译器给出的代码（错的）
2
text[i[:i + n]]
3

4
# 实际应该是
5
text[i:i + n]

还有生成器表达式被截断的情况：

1
# 反编译器给出的代码（缺参数）
2
self.raw_content = "\n".join((p.text for p in ))
3

4
# 实际应该是
5
self.raw_content = "\n".join(p.text for p in doc.paragraphs)

另外还有 for-else 结构被反编译器误还原成了 try-except-else 嵌套等问题。这些都需要对照字节码的操作序列，结合上下文逻辑手动修正。

反编译工具能帮你走完 90% 的路，但最后 10% 必须靠人来补。

修复完所有问题后，得到了最终的还原版源码：check_recovered.py。

第四步：搞懂这个程序在干什么#

还原出源码之后，终于可以从容地阅读代码了。

查重算法流程

它的技术栈很清晰：

功能	用的什么
图形界面	Tkinter
读取 Word 文档	python-docx
数据可视化	matplotlib
结果存储	SQLite
数值计算	NumPy

整个工作流程大致是这样的：

用户选择一个论文目录
程序扫描目录下所有符合命名规则的 .docx 文件
逐篇读取文档内容，提取文本特征
对所有论文进行两两比较
计算综合重复率
在界面上展示结果，支持导出 HTML 报告

界面那些酷炫的东西是真的吗？#

先说结论：大部分不是。

程序界面上有很多看起来很”硬核”的元素：

实时跳动的 CPU、RAM、TENSOR OPS 指标
不断滚动的底层计算日志，提到了 CUDA、SVD、Multi-Head Attention、AST 等
3D 语义空间可视化、拓扑网络图

但翻看源码就会发现，这些指标都是随机数生成的，日志也是从预设文案池里随机抽取的。代码里甚至有一个类叫 DeepLogger，注释写的是——

“生成伪底层计算日志，增强专业压迫感”

所以这些视觉效果更像是”气氛组”，不是真的在跑 GPU 运算。实际的查重计算全部是 CPU 上的传统算法。

第五步：拆解核心查重算法#

剥掉界面和装饰性的东西之后，核心查重引擎其实就三个算法叠加在一起。

算法一：N-gram 多重集匹配#

这是权重最高的算法（占综合分的 60%）。

原理很直观：把一篇文章的中文文本按 8 个字一组，用滑动窗口切成一堆文本片段。然后比较两篇文章有多少片段是重复的。

举个例子，假设有一段文本：

1
网络爬虫技术与数据可视化

按 8 字切片后会得到：

1
网络爬虫技术与数
2
络爬虫技术与数据
3
爬虫技术与数据可
4
虫技术与数据可视
5
技术与数据可视化

程序里有一个值得注意的细节：它用的是 Python 的 Counter（多重集）来统计片段频次，而不是普通的 set。这意味着如果某个片段在一篇文章里出现了 3 次，在另一篇里也出现了 3 次，它会如实计算 3 次匹配，而不是只算 1 次。

这也是源码注释里提到的 “Multiset Counter Fix”——保证了同一篇文章和自己比较时，重复率一定是 100%。

算法二：SimHash 指纹比对#

SimHash 是一种局部敏感哈希算法（占综合分的 20%）。

简单来说，它给每篇文章生成一个 128 位的”指纹”。生成方式是：

把文本按 2 个字一组切开
对每组做 MD5 哈希
把所有哈希累加成一个 128 维的向量
正数位记为 1，负数位记为 0，得到最终指纹

两篇文章的 SimHash 差异用海明距离（有多少位不同）来衡量。距离越小，文章越相似。

算法三：TF-IDF 余弦相似度#

第三个算法是经典的 TF-IDF + 余弦相似度（也占 20%）。

不过在实际还原和测试中发现，由于 tfidf_vec 在程序运行流程中的回填时机问题，很多非完全相同的文章对，这个值实际算出来是 0.0。也就是说，余弦相似度在大多数情况下对综合分没有实质贡献。

综合分计算#

三个算法的结果按权重加在一起：

综合分计算公式

1
综合分 = 0.6 × N-gram + 0.2 × SimHash + 0.2 × Cosine

当综合分达到 50% 时，程序就会标记为”学术不端”。

如果两篇文章的原始文本完全相同，程序会直接短路判定：三项全部 100%，综合分 100%。

AIGC 检测是怎么回事？#

程序还有一个”AIGC 疑似率”的功能，看起来像是在检测文章是否由 AI 生成。

但实际上，它完全不涉及任何大模型或深度学习。它只是做了三个简单的启发式判断：

齐普夫定律拟合度：统计词频分布是否符合自然语言的齐普夫分布
句长方差：看句子长度的变化幅度大不大
词汇丰富度：统计用了多少不重复的字

然后根据这些指标打一个基础分，最后再加上 ±10 的随机浮动。

所以这个 AIGC 检测每次运行结果都不一样，不能作为严格的判断依据。

第六步：验证还原结果#

源码还原出来了，算法也看明白了，但有一个关键问题还没回答：还原版跑出来的结果和原程序一样吗？

语法检查#

首先确认还原的源码在语法层面没有问题：

Terminal window

1
python3 -c "compile(open('check_recovered.py', encoding='utf-8').read(), \
2
  'check_recovered.py', 'exec'); print('syntax ok')"

输出 syntax ok，通过。

核心算法冒烟测试#

写了一个不依赖 GUI 的测试脚本 test_recovered_core.py，它会：

临时生成 3 篇 .docx 测试文档（其中两篇内容完全相同）
用还原版的查重引擎跑一遍
断言完全相同的两篇文章重复率为 100%

Terminal window

1
python3 test_recovered_core.py

输出 smoke ok，通过。

和原程序对比#

原程序与还原版对比流程

最关键的验证是拿同一批论文，分别用原 exe 和还原版跑一遍，然后对比核心指标。

用 4 篇真实的课程论文作为测试样本，分别在两个环境下运行，导出 HTML 报告。

对比结果：

论文对	原程序 N-gram	还原版 N-gram	原程序 SimHash	还原版 SimHash	原程序综合分	还原版综合分
刘 vs 徐	100.0%	100.0%	100.0%	100.0%	80.0%	80.0%
刘 vs 李	100.0%	100.0%	100.0%	100.0%	80.0%	80.0%
刘 vs 黄	75.86%	75.86%	82.42%	82.42%	62.0%	62.0%
徐 vs 李	100.0%	100.0%	100.0%	100.0%	80.0%	80.0%
徐 vs 黄	75.86%	75.86%	82.42%	82.42%	62.0%	62.0%
李 vs 黄	75.86%	75.86%	82.42%	82.42%	62.0%	62.0%

六组对比，核心指标完全一致。

原程序与还原版运行对比截图

上图左侧是原 123.exe 在 Windows 上运行导出的 HTML 报告，右侧是还原版在 macOS 上生成的报告，底部是还原版的 GUI 界面。可以看到两边的查重数据完全吻合。

需要注意的是，AIGC 疑似率、3D 语义空间坐标、CPU/RAM 等系统指标这些包含随机数的字段不在对比范围内——它们每次运行都会变，本身就不是确定性的结果。

附录：还原后的完整源码#

以下是从 123.exe 中逆向还原并修复后的完整 Python 源码：

点击展开完整源码（约 800 行）

1
import os, re, json, time, math, random, hashlib, sqlite3, threading, logging, difflib, tkinter as tk
2
from tkinter import ttk, filedialog, messagebox, scrolledtext
3
from docx import Document
4
from collections import defaultdict, Counter
5
from typing import List, Dict, Tuple, Optional, Set, Any
6
import numpy as np
7
try:
8
    import matplotlib
9
    matplotlib.use("TkAgg")
10
    import matplotlib.pyplot as plt
11
    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
12
    from matplotlib.figure import Figure
13
    from mpl_toolkits.mplot3d import Axes3D
14
    HAS_MPL = True
15
except ImportError:
16
    HAS_MPL = False
17
else:
18
    logging.basicConfig(level=(logging.INFO), format="%(asctime)s [%(levelname)s] %(message)s")
19
    logger = logging.getLogger("DeepAI-Checker-v6")
20
    BG_DARK = "#0d1117"
21
    BG_PANEL = "#161b22"
22
    BG_INPUT = "#010409"
23
    FG_NEON = "#00ffcc"
24
    FG_PINK = "#ff007f"
25
    FG_YELLOW = "#e3b341"
26
    FG_TEXT = "#c9d1d9"
27
    FG_DIM = "#8b949e"
28
    ACCENT_RED = "#f85149"
29
    ACCENT_GREEN = "#3fb950"
30
    CHUNK_SIZE = 8
31
    REPEAT_THRESHOLD = 50
32
    WINDOW_TITLE = "Deep-AI 学术不端检测与多维语义张量分析系统 v6.0"
33
    WINDOW_SIZE = "1400x900"
34
    FOLDER_REGEX = "^计科B230\\d+-爬虫与数据可视化-课程论文$"
35
    FILE_REGEX = "^.+-[\\d]+-.+-期末论文\\.docx$"
36
    STOP_WORDS = set("的了在我有和就都而及与或但很之于对让把被吗吧呢啊啦着过也你他她它这那要能会来且并即其若如")
37

38
    class SystemMonitor:
39
        """模拟底层硬件与张量计算监控指标"""
40

41
        @staticmethod
42
        def get_fake_metrics() -> Dict[(str, float)]:
43
            return {'cpu':(random.uniform)(45.0, 98.5),
44
             'ram':(random.uniform)(2.1, 7.8),
45
             'tensor_ops':(random.randint)(120000, 999999),
46
             'vram':(random.uniform)(1.2, 3.9)}
47

48

49
    class DeepLogger:
50
        """生成伪底层计算日志，增强专业压迫感"""
51
        PHASES = [
52
         "[AST_PARSER] 构建抽象语法树 (AST) 与依赖图解析...",
53
         "[TENSOR_CORE] 执行 SVD 奇异值分解，降维至 128 维语义空间...",
54
         "[LSH_ENGINE] 生成 MinHash 签名，应用 Banding 技术 (b=20, r=5)...",
55
         "[VSM_MAPPER] 计算 TF-IDF 稀疏矩阵，构建倒排索引...",
56
         "[DTW_ALIGN] 执行 Dynamic Time Warping 动态时间规整序列对齐...",
57
         "[ATTENTION] 应用 Multi-Head 自注意力机制，衰减因子 α=0.85...",
58
         "[AIGC_DETECT] 计算词汇信息熵与句法树深度，评估 AI 生成概率..."]
59

60
        @staticmethod
61
        def gen_fake_log() -> str:
62
            ops = [
63
             f"[0x{random.randint(1000, 9999):X}] Hash collision detected at bucket {random.randint(1, 256)}, resolving...",
64
             f"[MEM_ALLOC] Allocating {random.randint(16, 512)}MB for sparse tensor block...",
65
             f"[CUDA_SIM] Thread block {random.randint(0, 15)} synced. Processed {random.randint(1000, 9000)} tokens/sec.",
66
             f"[MATH_LIB] Computing cosine similarity in R^{random.choice([64, 128, 256])} space...",
67
             f"[GC_TRACE] Mark-and-sweep completed. Freed {random.randint(10, 99)}MB orphaned nodes.",
68
             f"[GPU_CTX] Context switch overhead: {random.uniform(0.1, 2.5)}ms. Stream 0 active.",
69
             f"[CACHE_L2] Miss rate: {random.uniform(1.0, 15.0)}%. Prefetching next batch...",
70
             "[MULTISET] Upgrading N-gram Set to Counter(Multiset) for exact 100% match guarantee..."]
71
            return random.choice(ops)
72

73

74
    class TextProcessor:
75
        """文本清洗、分词、特征提取核心工具类"""
76

77
        @staticmethod
78
        def clean_text(text: str) -> str:
79
            text = re.sub("http[s]?://\\S+", "", text)
80
            text = re.sub("\\[\\d+\\]", "", text)
81
            text = re.sub("[^\\u4e00-\\u9fa5]", "", text)
82
            return text
83

84
        @staticmethod
85
        def get_ngrams(text: str, n: int=8) -> List[str]:
86
            text = TextProcessor.clean_text(text)
87
            if len(text) >= n:
88
                return [text[i:i + n] for i in range(len(text) - n + 1)]
89
            return []
90

91
        @staticmethod
92
        def calc_entropy(text: str) -> float:
93
            if not text:
94
                return 0.0
95
            freq = Counter(text)
96
            length = len(text)
97
            return -sum((count / length * math.log2(count / length) for count in freq.values()))
98

99
        @staticmethod
100
        def calc_simhash(text: str, f: int=128) -> int:
101
            words = TextProcessor.clean_text(text)
102
            if not words:
103
                return 0
104
            v = [0] * f
105
            for i in range(len(words) - 1):
106
                word = words[i:i + 2]
107
                h = int(hashlib.md5(word.encode("utf-8")).hexdigest(), 16)
108
                for j in range(f):
109
                    if h >> j & 1:
110
                        v[j] += 1
111
                    else:
112
                        v[j] -= 1
113

114
                ans = 0
115

116
            for j in range(f):
117
                if v[j] > 0:
118
                    ans |= 1 << j
119
                return ans
120

121
        @staticmethod
122
        def split_sentences(text: str) -> List[str]:
123
            text = re.sub("([。！？\\?])([^"'])", "\\1\\n\\2", text)
124
            return [s.strip() for s in text.split("\n") if len(s.strip()) > 2]
125

126
        @staticmethod
127
        def calc_tfidf_vector(text: str, vocab: Dict[(str, int)]) -> np.ndarray:
128
            words = TextProcessor.clean_text(text)
129
            tf = Counter(words)
130
            vec = np.zeros(len(vocab))
131
            for (word, count) in tf.items():
132
                if word in vocab:
133
                    vec[vocab[word]] = count
134
                return vec
135

136

137
    class AIGCDetector:
138
        """基于齐普夫定律、句长方差和词汇丰富度的伪 AIGC 检测器"""
139

140
        def __init__(self, text: str):
141
            self.text = text
142
            self.sentences = TextProcessor.split_sentences(text)
143
            self.words = TextProcessor.clean_text(text)
144

145
        def calc_zipf_law(self) -> float:
146
            if not self.words:
147
                return 0.0
148
            freq = Counter(self.words).most_common(50)
149
            if len(freq) < 10:
150
                return 0.0
151
            ranks = np.arange(1, len(freq) + 1)
152
            counts = np.array([c for _, c in freq])
153
            log_ranks = np.log(ranks)
154
            log_counts = np.log(counts)
155
            (slope, _) = np.polyfit(log_ranks, log_counts, 1)
156
            return abs(slope)
157

158
        def calc_sentence_length_variance(self) -> float:
159
            if not self.sentences:
160
                return 0.0
161
            lengths = [len(s) for s in self.sentences]
162
            return np.var(lengths)
163

164
        def calc_vocabulary_richness(self) -> float:
165
            if not self.words:
166
                return 0.0
167
            unique_words = set(self.words)
168
            return len(unique_words) / len(self.words)
169

170
        def get_aigc_probability(self) -> float:
171
            zipf_score = self.calc_zipf_law()
172
            var_score = self.calc_sentence_length_variance()
173
            richness = self.calc_vocabulary_richness()
174
            prob = 50.0
175
            if 0.8 < zipf_score < 1.2:
176
                prob += 15.0
177
            if var_score < 20.0:
178
                prob += 15.0
179
            if richness < 0.3:
180
                prob += 10.0
181
            prob += random.uniform(-10, 10)
182
            return round(max(5.0, min(95.0, prob)), 1)
183

184

185
    class Paper:
186
        """论文数据模型，包含所有提取的特征"""
187

188
        def __init__(self, filename: str, filepath: str):
189
            self.filename = filename
190
            self.filepath = filepath
191
            self.raw_content = ""
192
            self.content = ""
193
            self.gram_list = []
194
            self.gram_counter = Counter()
195
            self.length = 0
196
            self.simhash = 0
197
            self.best_match = None
198
            self.best_rate = 0.0
199
            self.aigc_prob = 0.0
200
            self.entropy = 0.0
201
            self.vector_3d = (0.0, 0.0, 0.0)
202
            self.tfidf_vec = None
203

204
        def load(self, vocab: Optional[Dict[(str, int)]]=None):
205
            try:
206
                doc = Document(self.filepath)
207
                self.raw_content = "\n".join((p.text for p in doc.paragraphs))
208
                self.content = TextProcessor.clean_text(self.raw_content)
209
                self.gram_list = TextProcessor.get_ngrams(self.content, CHUNK_SIZE)
210
                self.gram_counter = Counter(self.gram_list)
211
                self.length = len(self.gram_list)
212
                self.simhash = TextProcessor.calc_simhash(self.content)
213
                self.entropy = TextProcessor.calc_entropy(self.content)
214
                detector = AIGCDetector(self.raw_content)
215
                self.aigc_prob = detector.get_aigc_probability()
216
                self.vector_3d = (
217
                 random.uniform(-10, 10), random.uniform(-10, 10), random.uniform(-10, 10))
218
                if vocab:
219
                    self.tfidf_vec = TextProcessor.calc_tfidf_vector(self.content, vocab)
220
            except Exception as e:
221
                try:
222
                    logger.error(f"Load failed for {self.filename}: {e}")
223
                finally:
224
                    e = None
225
                    del e
226

227

228
    class DeepCheckerEngine:
229
        """多维算法融合查重引擎"""
230

231
        def __init__(self, papers: List[Paper], weights: Tuple[(float, float, float)]=(0.6, 0.2, 0.2)):
232
            self.papers = papers
233
            self.results = []
234
            self.vocab = {}
235
            self.idf = np.array([])
236
            self.weights = weights
237
            self._build_vocab()
238

239
        def _build_vocab(self):
240
            all_words = set()
241
            for p in self.papers:
242
                all_words.update(TextProcessor.clean_text(p.content))
243

244
            self.vocab = {w: i for i, w in enumerate(all_words)}
245
            n_docs = len(self.papers)
246
            df = np.zeros(len(self.vocab))
247
            for p in self.papers:
248
                words = set(TextProcessor.clean_text(p.content))
249
                for w in words:
250
                    if w in self.vocab:
251
                        df[self.vocab[w]] += 1
252

253
                self.idf = np.log((n_docs + 1) / (df + 1)) + 1
254

255
        def calc_ngram_rate(self, a: Paper, b: Paper) -> float:
256
            """【核心修复】使用多重集(Counter)计算交集，确保相同文档重复率为 100%"""
257
            if a.length == 0:
258
                return 0.0
259
            if a.content == b.content:
260
                return 100.0
261
            match_count = sum((a.gram_counter & b.gram_counter).values())
262
            return round(match_count / a.length * 100, 2)
263

264
        def calc_simhash_rate(self, a: Paper, b: Paper) -> float:
265
            if not (a.simhash and b.simhash):
266
                return 0.0
267
            if a.content == b.content:
268
                return 100.0
269
            x = (a.simhash ^ b.simhash) & (1 << 128) - 1
270
            dist = bin(x).count("1")
271
            return round(max(0, 100 - dist / 128 * 100 * 2.5), 2)
272

273
        def calc_cosine_rate(self, a: Paper, b: Paper) -> float:
274
            if a.tfidf_vec is None or b.tfidf_vec is None:
275
                return 0.0
276
            if a.content == b.content:
277
                return 100.0
278
            vec_a = a.tfidf_vec * self.idf
279
            vec_b = b.tfidf_vec * self.idf
280
            dot = np.dot(vec_a, vec_b)
281
            norm_a = np.linalg.norm(vec_a)
282
            norm_b = np.linalg.norm(vec_b)
283
            if norm_a == 0 or norm_b == 0:
284
                return 0.0
285
            return round(dot / (norm_a * norm_b) * 100, 2)
286

287
        def run(self, update_ui, log_callback):
288
            n = len(self.papers)
289
            total = n * (n - 1) // 2
290
            current = 0
291
            (w1, w2, w3) = self.weights
292
            for p in self.papers:
293
                p.best_rate = 0.0
294
                p.best_match = None
295

296
            for i in range(n):
297
                a = self.papers[i]
298
                for j in range(i + 1, n):
299
                    b = self.papers[j]
300
                    if a.raw_content == b.raw_content:
301
                        r_ngram = 100.0
302
                        r_simhash = 100.0
303
                        r_cosine = 100.0
304
                        final_rate = 100.0
305
                    else:
306
                        r_ngram = max(self.calc_ngram_rate(a, b), self.calc_ngram_rate(b, a))
307
                        r_simhash = self.calc_simhash_rate(a, b)
308
                        r_cosine = self.calc_cosine_rate(a, b)
309
                        final_rate = round(r_ngram * w1 + r_simhash * w2 + r_cosine * w3, 2)
310
                    if final_rate > a.best_rate:
311
                        a.best_rate = final_rate
312
                        a.best_match = b.filename
313
                    if final_rate > b.best_rate:
314
                        b.best_rate = final_rate
315
                        b.best_match = a.filename
316
                    self.results.append({'p1':a.filename,
317
                     'p2':b.filename, 'ngram':r_ngram,
318
                     'simhash':r_simhash, 'cosine':r_cosine, 'final':final_rate})
319
                    if final_rate > 20:
320
                        force = final_rate / 100.0
321
                        (ax, ay, az) = a.vector_3d
322
                        (bx, by, bz) = b.vector_3d
323
                        a.vector_3d = (
324
                         ax + (bx - ax) * force * 0.1,
325
                         ay + (by - ay) * force * 0.1,
326
                         az + (bz - az) * force * 0.1)
327
                        b.vector_3d = (
328
                         bx + (ax - bx) * force * 0.1,
329
                         by + (ay - by) * force * 0.1,
330
                         bz + (az - bz) * force * 0.1)
331
                    current += 1
332
                    progress = int(current / total * 100)
333
                    update_ui(progress, a.filename, b.filename)
334
                    if current % 3 == 0:
335
                        log_callback(DeepLogger.gen_fake_log(), "dim")
336

337

338
    class DatabaseManager:
339

340
        def __init__(self, db_path: str='deep_ai_history_v6.db'):
341
            self.conn = sqlite3.connect(db_path)
342
            self._create_tables()
343

344
        def _create_tables(self):
345
            cursor = self.conn.cursor()
346
            cursor.execute("CREATE TABLE IF NOT EXISTS scan_history (\n            id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT, folder TEXT, \n            total_papers INTEGER, avg_rate REAL, max_rate REAL, aigc_count INTEGER)")
347
            cursor.execute("CREATE TABLE IF NOT EXISTS scan_results (\n            id INTEGER PRIMARY KEY AUTOINCREMENT, batch_id INTEGER, \n            paper1 TEXT, paper2 TEXT, rate REAL)")
348
            self.conn.commit()
349

350
        def insert_batch(self, folder, total, avg, mx, aigc):
351
            cursor = self.conn.cursor()
352
            ts = time.strftime("%Y-%m-%d %H:%M:%S")
353
            cursor.execute("INSERT INTO scan_history (timestamp, folder, total_papers, avg_rate, max_rate, aigc_count) VALUES (?,?,?,?,?,?)", (
354
             ts, folder, total, avg, mx, aigc))
355
            self.conn.commit()
356
            return cursor.lastrowid
357

358
        def insert_results(self, batch_id: int, results: List[Dict]):
359
            cursor = self.conn.cursor()
360
            data = [(batch_id, r["p1"], r["p2"], r["final"]) for r in results]
361
            cursor.executemany("INSERT INTO scan_results (batch_id, paper1, paper2, rate) VALUES (?,?,?,?)", data)
362
            self.conn.commit()
363

364
        def get_history(self) -> List[Tuple]:
365
            cursor = self.conn.cursor()
366
            cursor.execute("SELECT * FROM scan_history ORDER BY id DESC LIMIT 50")
367
            return cursor.fetchall()
368

369

370
    class ExportManager:
371

372
        @staticmethod
373
        def generate_html(results: List[Dict], papers: List[Paper], filepath: str):
374
            html = '<!DOCTYPE html><html lang="zh-CN"><head><meta charset="UTF-8">\n<title>Deep-AI 学术不端检测报告</title>\n<style>\nbody { font-family: \'Segoe UI\', sans-serif; background: #0d1117; color: #c9d1d9; padding: 20px; }\nh1 { color: #00ffcc; text-align: center; border-bottom: 2px solid #ff007f; padding-bottom: 10px; }\nh2 { color: #ff007f; margin-top: 30px; }\ntable { width: 100%; border-collapse: collapse; margin-top: 15px; background: #161b22; }\nth, td { border: 1px solid #30363d; padding: 10px; text-align: center; }\nth { background: #010409; color: #00ffcc; }\n.danger { color: #f85149; font-weight: bold; } .safe { color: #3fb950; font-weight: bold; }\n</style></head><body>\n<h1>◈ Deep-AI 学术不端检测与多维语义张量分析报告</h1>\n<h2>1. 两两对比详细数据</h2><table>\n<tr><th>论文 A</th><th>论文 B</th><th>N-gram(%)</th><th>SimHash(%)</th><th>Cosine(%)</th><th>综合(%)</th></tr>'
375
            for r in results:
376
                cls = "danger" if r["final"] >= REPEAT_THRESHOLD else "safe"
377
                html += f"""<tr><td>{r["p1"]}</td><td>{r["p2"]}</td><td>{r["ngram"]}</td><td>{r["simhash"]}</td><td>{r["cosine"]}</td><td class='{cls}'>{r["final"]}%</td></tr>\n"""
378

379
            html += "</table><h2>2. 单篇最高重复与 AIGC 风险评估</h2><table>"
380
            html += "<tr><th>文件名</th><th>最高重复对象</th><th>综合(%)</th><th>AIGC(%)</th><th>裁决</th></tr>\n"
381
            for p in papers:
382
                best = p.best_match or "无"
383
                rate_cls = "danger" if p.best_rate >= REPEAT_THRESHOLD else "safe"
384
                verdict = "<span class='danger'>⚠ 学术不端</span>" if p.best_rate >= REPEAT_THRESHOLD else "<span class='safe'>✅ 正常</span>"
385
                html += f"<tr><td>{p.filename}</td><td>{best}</td><td class='{rate_cls}'>{p.best_rate}%</td><td>{p.aigc_prob}%</td><td>{verdict}</td></tr>\n"
386

387
            html += "</table></body></html>"
388
            with open(filepath, "w", encoding="utf-8") as f:
389
                f.write(html)
390

391

392
    class DiffViewer(tk.Toplevel):
393
        """使用 difflib 实现逐字高亮对比的独立窗口"""
394

395
        def __init__(self, parent, p1, p2):
396
            super().__init__(parent)
397
            self.title(f"深度差异比对: {p1.filename} vs {p2.filename}")
398
            self.geometry("1000x600")
399
            self.configure(bg=BG_DARK)
400
            self.p1, self.p2 = p1, p2
401
            self.create_ui()
402
            self.compute_diff()
403

404
        def create_ui(self):
405
            paned = ttk.PanedWindow(self, orient=(tk.HORIZONTAL))
406
            paned.pack(fill=(tk.BOTH), expand=True, padx=10, pady=10)
407
            f1 = tk.Frame(paned, bg=BG_PANEL)
408
            f2 = tk.Frame(paned, bg=BG_PANEL)
409
            paned.add(f1, weight=1)
410
            paned.add(f2, weight=1)
411
            tk.Label(f1, text=(self.p1.filename), bg=BG_PANEL, fg=FG_NEON,
412
              font=('微软雅黑', 11, 'bold')).pack(pady=5)
413
            tk.Label(f2, text=(self.p2.filename), bg=BG_PANEL, fg=FG_PINK,
414
              font=('微软雅黑', 11, 'bold')).pack(pady=5)
415
            self.text1 = scrolledtext.ScrolledText(f1, bg=BG_INPUT, fg=FG_TEXT,
416
              font=('Consolas', 10), wrap=(tk.WORD))
417
            self.text1.pack(fill=(tk.BOTH), expand=True, padx=5, pady=5)
418
            self.text2 = scrolledtext.ScrolledText(f2, bg=BG_INPUT, fg=FG_TEXT,
419
              font=('Consolas', 10), wrap=(tk.WORD))
420
            self.text2.pack(fill=(tk.BOTH), expand=True, padx=5, pady=5)
421
            self.text1.tag_config("match", background="#2ea043", foreground="white")
422
            self.text2.tag_config("match", background="#2ea043", foreground="white")
423
            self.text1.tag_config("diff", background="#f85149", foreground="white")
424
            self.text2.tag_config("diff", background="#f85149", foreground="white")
425

426
        def compute_diff(self):
427
            self.text1.insert(tk.END, self.p1.content)
428
            self.text2.insert(tk.END, self.p2.content)
429
            matcher = difflib.SequenceMatcher(None, self.p1.content, self.p2.content)
430
            for (tag, i1, i2, j1, j2) in matcher.get_opcodes():
431
                if tag == "equal":
432
                    self.text1.tag_add("match", f"1.0+{i1}c", f"1.0+{i2}c")
433
                    self.text2.tag_add("match", f"1.0+{j1}c", f"1.0+{j2}c")
434
                else:
435
                    if tag in ('replace', 'delete', 'insert'):
436
                        if i1 != i2:
437
                            self.text1.tag_add("diff", f"1.0+{i1}c", f"1.0+{i2}c")
438
                        if j1 != j2:
439
                            self.text2.tag_add("diff", f"1.0+{j1}c", f"1.0+{j2}c")
440

441

442
    class CyberTerminal(scrolledtext.ScrolledText):
443

444
        def __init__(self, parent, **kwargs):
445
            (super().__init__)(parent, bg=BG_INPUT, fg=FG_NEON, insertbackground=FG_NEON,
446
             font=('Consolas', 10), relief=tk.FLAT, borderwidth=0, **kwargs)
447
            self.tag_config("info", foreground=FG_TEXT)
448
            self.tag_config("success", foreground=ACCENT_GREEN)
449
            self.tag_config("warning", foreground=FG_YELLOW)
450
            self.tag_config("error", foreground=ACCENT_RED)
451
            self.tag_config("dim", foreground=FG_DIM)
452
            self.tag_config("phase", foreground=FG_PINK, font=('Consolas', 10, 'bold'))
453

454
        def log(self, msg: str, tag: str='info'):
455
            self.insert(tk.END, f"> {msg}\n", tag)
456
            self.see(tk.END)
457

458

459
    class MetricPanel(tk.Frame):
460

461
        def __init__(self, parent, title, color, **kwargs):
462
            (super().__init__)(parent, bg=BG_PANEL, **kwargs)
463
            tk.Label(self, text=title, bg=BG_PANEL, fg=FG_DIM,
464
              font=('Consolas', 9)).pack(anchor=(tk.W), padx=5)
465
            self.val_label = tk.Label(self, text="0.0", bg=BG_PANEL, fg=color,
466
              font=('Consolas', 18, 'bold'))
467
            self.val_label.pack(anchor=(tk.W), padx=5)
468

469
        def update_val(self, val: str, suffix: str=''):
470
            self.val_label.config(text=f"{val}{suffix}")
471

472

473
    class MainApplication(tk.Tk):
474

475
        def __init__(self):
476
            super().__init__()
477
            self.title(WINDOW_TITLE)
478
            self.geometry(WINDOW_SIZE)
479
            self.configure(bg=BG_DARK)
480
            self.minsize(1200, 800)
481
            self.papers = []
482
            self.engine = None
483
            self.db_mgr = DatabaseManager()
484
            self.weights = (0.6, 0.2, 0.2)
485
            self.create_ui()
486
            self.start_metric_updater()
487

488
        def create_ui(self):
489
            header = tk.Frame(self, bg=BG_PANEL, height=70)
490
            header.pack(fill=(tk.X))
491
            header.pack_propagate(False)
492
            tk.Label(header, text="◈ DEEP-AI 学术不端检测与多维语义张量分析系统",
493
              bg=BG_PANEL, fg=FG_NEON,
494
              font=('微软雅黑', 20, 'bold')).pack(side=(tk.LEFT), padx=20, pady=15)
495
            tk.Label(header, text="v6.0 Multiset Counter Fix | 100% Symmetry Guaranteed",
496
              bg=BG_PANEL, fg=FG_DIM,
497
              font=('Consolas', 10)).pack(side=(tk.LEFT), pady=25)
498
            monitor_frame = tk.Frame(header, bg=BG_PANEL)
499
            monitor_frame.pack(side=(tk.RIGHT), padx=20, pady=10)
500
            self.cpu_panel = MetricPanel(monitor_frame, "CPU LOAD", FG_PINK)
501
            self.cpu_panel.grid(row=0, column=0, padx=10)
502
            self.ram_panel = MetricPanel(monitor_frame, "RAM USAGE", FG_YELLOW)
503
            self.ram_panel.grid(row=0, column=1, padx=10)
504
            self.tensor_panel = MetricPanel(monitor_frame, "TENSOR OPS", FG_NEON)
505
            self.tensor_panel.grid(row=0, column=2, padx=10)
506
            body = tk.Frame(self, bg=BG_DARK)
507
            body.pack(fill=(tk.BOTH), expand=True, padx=10, pady=10)
508
            left_frame = tk.Frame(body, bg=BG_PANEL, width=450)
509
            left_frame.pack(side=(tk.LEFT), fill=(tk.Y), padx=(0, 10))
510
            left_frame.pack_propagate(False)
511
            ctrl_frame = tk.LabelFrame(left_frame, text=" [ 任务控制台 ] ",
512
              bg=BG_PANEL, fg=FG_NEON,
513
              font=('微软雅黑', 11, 'bold'))
514
            ctrl_frame.pack(fill=(tk.X), padx=10, pady=10)
515
            self.path_var = tk.StringVar(value="未挂载数据目录...")
516
            tk.Entry(ctrl_frame, textvariable=(self.path_var), bg=BG_INPUT, fg=FG_TEXT,
517
              font=('Consolas', 10), relief=(tk.FLAT),
518
              state="readonly").pack(fill=(tk.X), padx=10, pady=(10, 5))
519
            btn_frame = tk.Frame(ctrl_frame, bg=BG_PANEL)
520
            btn_frame.pack(fill=(tk.X), padx=10, pady=5)
521
            self.load_btn = tk.Button(btn_frame, text="⬡ 挂载目录",
522
              command=(self.load_folder), bg=BG_INPUT, fg=FG_NEON,
523
              font=('微软雅黑', 10), relief=(tk.FLAT))
524
            self.load_btn.pack(side=(tk.LEFT), expand=True, fill=(tk.X), padx=(0, 5))
525
            self.start_btn = tk.Button(btn_frame, text="▶ 启动深度查重",
526
              command=(self.start_check), bg=FG_PINK, fg="white",
527
              font=('微软雅黑', 10, 'bold'), relief=(tk.FLAT), state=(tk.DISABLED))
528
            self.start_btn.pack(side=(tk.LEFT), expand=True, fill=(tk.X), padx=(5, 0))
529
            tk.Button(ctrl_frame, text="💾 导出 HTML 报告",
530
              command=(self.export_report), bg=BG_INPUT, fg=FG_YELLOW,
531
              font=('微软雅黑', 10), relief=(tk.FLAT)).pack(fill=(tk.X), padx=10, pady=5)
532
            prog_frame = tk.LabelFrame(left_frame, text=" [ 计算管线状态 ] ",
533
              bg=BG_PANEL, fg=FG_NEON,
534
              font=('微软雅黑', 11, 'bold'))
535
            prog_frame.pack(fill=(tk.X), padx=10, pady=10)
536
            self.phase_label = tk.Label(prog_frame, text="IDLE", bg=BG_PANEL, fg=FG_YELLOW,
537
              font=('Consolas', 10, 'bold'))
538
            self.phase_label.pack(anchor=(tk.W), padx=10, pady=(10, 0))
539
            self.prog_var = tk.DoubleVar()
540
            ttk.Progressbar(prog_frame, variable=(self.prog_var),
541
              maximum=100).pack(fill=(tk.X), padx=10, pady=10)
542
            self.prog_label = tk.Label(prog_frame, text="0%", bg=BG_PANEL, fg=FG_TEXT,
543
              font=('Consolas', 10))
544
            self.prog_label.pack(anchor=(tk.E), padx=10, pady=(0, 10))
545
            term_frame = tk.LabelFrame(left_frame, text=" [ 底层计算日志 ] ",
546
              bg=BG_PANEL, fg=FG_NEON,
547
              font=('微软雅黑', 11, 'bold'))
548
            term_frame.pack(fill=(tk.BOTH), expand=True, padx=10, pady=10)
549
            self.terminal = CyberTerminal(term_frame)
550
            self.terminal.pack(fill=(tk.BOTH), expand=True, padx=5, pady=5)
551
            right_frame = tk.Frame(body, bg=BG_PANEL)
552
            right_frame.pack(side=(tk.LEFT), fill=(tk.BOTH), expand=True)
553
            style = ttk.Style(self)
554
            style.theme_use("clam")
555
            style.configure("Dark.TNotebook", background=BG_PANEL, borderwidth=0)
556
            style.configure("Dark.TNotebook.Tab", background=BG_INPUT, foreground=FG_TEXT,
557
              padding=[15, 8], font=('微软雅黑', 11))
558
            style.map("Dark.TNotebook.Tab",
559
              background=[("selected", BG_PANEL)],
560
              foreground=[("selected", FG_NEON)])
561
            self.notebook = ttk.Notebook(right_frame, style="Dark.TNotebook")
562
            self.notebook.pack(fill=(tk.BOTH), expand=True, padx=10, pady=10)
563
            self.tab_3d = tk.Frame((self.notebook), bg=BG_PANEL)
564
            self.tab_topo = tk.Frame((self.notebook), bg=BG_PANEL)
565
            self.tab_report = tk.Frame((self.notebook), bg=BG_PANEL)
566
            self.notebook.add((self.tab_3d), text=" 🌌 3D 语义空间 ")
567
            self.notebook.add((self.tab_topo), text=" 🕸️ 拓扑网络 ")
568
            self.notebook.add((self.tab_report), text=" 📜 裁决报告 ")
569
            self.setup_report_tab()
570
            self.status_var = tk.StringVar(value="SYSTEM READY | AWAITING DATA INJECTION...")
571
            tk.Label(self, textvariable=(self.status_var), bg=BG_INPUT, fg=FG_DIM,
572
              font=('Consolas', 10), anchor=(tk.W),
573
              padx=10).pack(fill=(tk.X), side=(tk.BOTTOM))
574

575
        def setup_report_tab(self):
576
            cols = ('论文文件', '最高重复对象', '综合重复率(%)', 'AIGC 疑似率(%)', '信息熵', '裁决结果')
577
            tree_frame = tk.Frame((self.tab_report), bg=BG_PANEL)
578
            tree_frame.pack(fill=(tk.BOTH), expand=True, padx=10, pady=10)
579
            self.report_tree = ttk.Treeview(tree_frame, columns=cols,
580
              show="headings", height=20)
581
            style = ttk.Style()
582
            style.configure("Cyber.Treeview", background=BG_INPUT, foreground=FG_TEXT,
583
              fieldbackground=BG_INPUT, font=('Consolas', 10))
584
            style.configure("Cyber.Treeview.Heading", background=BG_PANEL,
585
              foreground=FG_NEON, font=('微软雅黑', 10, 'bold'))
586
            style.map("Cyber.Treeview", background=[("selected", FG_PINK)])
587
            self.report_tree.configure(style="Cyber.Treeview")
588
            for col in cols:
589
                self.report_tree.heading(col, text=col)
590
                self.report_tree.column(col, width=180, anchor=(tk.CENTER))
591

592
            vsb = ttk.Scrollbar(tree_frame, orient="vertical",
593
              command=(self.report_tree.yview))
594
            self.report_tree.configure(yscrollcommand=(vsb.set))
595
            self.report_tree.pack(side=(tk.LEFT), fill=(tk.BOTH), expand=True)
596
            vsb.pack(side=(tk.RIGHT), fill=(tk.Y))
597
            self.report_tree.bind("<Double-1>", self.on_tree_double_click)
598

599
        def start_metric_updater(self):
600

601
            def update():
602
                m = SystemMonitor.get_fake_metrics()
603
                self.cpu_panel.update_val(f'{m["cpu"]:.1f}', "%")
604
                self.ram_panel.update_val(f'{m["ram"]:.1f}', " GB")
605
                self.tensor_panel.update_val(f'{m["tensor_ops"]:,}', " /s")
606
                self.after(800, update)
607

608
            update()
609

610
        def log(self, msg: str, tag: str='info'):
611
            self.terminal.log(msg, tag)
612
            self.update_idletasks()
613

614
        def load_folder(self):
615
            path = filedialog.askdirectory()
616
            if not path:
617
                return
618
            dirname = os.path.basename(path)
619
            if not re.match(FOLDER_REGEX, dirname):
620
                messagebox.showwarning("⚠ 目录规范警告",
621
                  f"非标准目录: {dirname}\n系统将强制解析...")
622
            self.path_var.set(path)
623
            self.log(f"MOUNT_SUCCESS: 数据目录已挂载 -> {dirname}", "success")
624
            self.load_papers(path)
625

626
        def load_papers(self, path: str):
627
            self.papers = []
628
            files = [f for f in os.listdir(path)
629
              if f.endswith(".docx") if re.match(FILE_REGEX, f)]
630
            if not files:
631
                self.log("FATAL_ERROR: 未检测到符合规范的 .docx 实体文件。", "error")
632
                return
633
            self.log(f"SCANNING: 发现 {len(files)} 个目标文档，开始注入内存...", "phase")
634
            for f in files:
635
                p = Paper(f, os.path.join(path, f))
636
                p.load()
637
                if p.length > 0:
638
                    self.papers.append(p)
639
                    self.log(f"  [OK] Loaded: {f} | Tokens: {len(p.content)} | Multiset-grams: {p.length}", "info")
640
                else:
641
                    self.log(f"  [FAIL] Empty or corrupted: {f}", "error")
642

643
            self.log(f"INJECTION_COMPLETE: {len(self.papers)} 个文档张量已就绪。", "success")
644
            self.start_btn.config(state=(tk.NORMAL))
645

646
        def update_progress(self, p: int, a: str, b: str):
647
            self.prog_var.set(p)
648
            self.prog_label.config(text=f"{p}%")
649
            self.status_var.set(f"EXECUTING: {a} ⟷ {b}")
650

651
        def start_check(self):
652
            if len(self.papers) < 2:
653
                messagebox.showwarning("提示", "张量数量不足，至少需要 2 个文档实体。")
654
                return
655
            self.start_btn.config(state=(tk.DISABLED))
656
            self.load_btn.config(state=(tk.DISABLED))
657
            (self.report_tree.delete)(*self.report_tree.get_children())
658
            self.log("==================================================", "phase")
659
            self.log("INITIATING DEEP TENSOR PLAGIARISM SCAN...", "phase")
660
            self.log("ALGORITHM: N-gram Multiset Counter (100% Symmetry Fix)", "phase")
661
            self.log("==================================================", "phase")
662
            self.engine = DeepCheckerEngine(self.papers, self.weights)
663

664
            def run_pipeline():
665
                for phase in DeepLogger.PHASES:
666
                    self.after(0, lambda p=phase: self.phase_label.config(text=p))
667
                    self.after(0, lambda p=phase: self.log(p, "phase"))
668
                    time.sleep(random.uniform(0.2, 0.5))
669

670
                self.after(0, lambda: self.phase_label.config(
671
                  text="[CORE] 执行多维张量碰撞与对齐..."))
672
                self.engine.run(self.update_progress,
673
                  lambda msg, tag: self.after(0, lambda: self.log(msg, tag)))
674
                self.after(0, self.finish_check)
675

676
            threading.Thread(target=run_pipeline, daemon=True).start()
677

678
        def finish_check(self):
679
            self.log("RENDER_COMPLETE: 正在生成多维可视化图表...", "success")
680
            for p in self.papers:
681
                best = p.best_match or "无 (独立原创)"
682
                rate = p.best_rate
683
                aigc = p.aigc_prob
684
                entropy = round(p.entropy, 2)
685
                verdict = "⚠ 严重学术不端" if rate >= REPEAT_THRESHOLD else "✅ 正常通过"
686
                self.report_tree.insert("", (tk.END),
687
                  values=(p.filename, best, rate, aigc, entropy, verdict))
688

689
            if HAS_MPL:
690
                self.draw_3d_space()
691
                self.draw_topology()
692
            rates = [r["final"] for r in self.engine.results]
693
            avg_rate = sum(rates) / len(rates) if rates else 0
694
            max_rate = max(rates) if rates else 0
695
            aigc_count = sum((1 for p in self.papers if p.aigc_prob > 70))
696
            batch_id = self.db_mgr.insert_batch(
697
              os.path.basename(self.path_var.get()),
698
              len(self.papers), avg_rate, max_rate, aigc_count)
699
            self.db_mgr.insert_results(batch_id, self.engine.results)
700
            self.log("ALL_TASKS_FINISHED: 检测管线已关闭。系统进入待机状态。", "success")
701
            self.phase_label.config(text="IDLE")
702
            self.start_btn.config(state=(tk.NORMAL))
703
            self.load_btn.config(state=(tk.NORMAL))
704
            self.status_var.set("SCAN COMPLETE | AWAITING NEXT INJECTION...")
705
            self.notebook.select(self.tab_report)
706

707
        def on_tree_double_click(self, event):
708
            item = self.report_tree.selection()
709
            if not item:
710
                return
711
            vals = self.report_tree.item(item[0], "values")
712
            p1_name = vals[0]
713
            p2_name = vals[1]
714
            if p2_name == "无 (独立原创)":
715
                return
716
            p1 = next((p for p in self.papers if p.filename == p1_name), None)
717
            p2 = next((p for p in self.papers if p.filename == p2_name), None)
718
            if p1:
719
                if p2:
720
                    DiffViewer(self, p1, p2)
721

722
        def export_report(self):
723
            if not self.engine:
724
                messagebox.showwarning("提示", "没有可导出的查重结果。")
725
                return
726
            path = filedialog.asksaveasfilename(defaultextension=".html",
727
              filetypes=[('HTML Report', '*.html')])
728
            if path:
729
                ExportManager.generate_html(self.engine.results, self.papers, path)
730
                messagebox.showinfo("成功", f"报告已导出至:\n{path}")
731

732
        def draw_3d_space(self):
733
            for widget in self.tab_3d.winfo_children():
734
                widget.destroy()
735

736
            fig = Figure(figsize=(8, 6), dpi=100, facecolor=BG_PANEL)
737
            ax = fig.add_subplot(111, projection="3d")
738
            ax.set_facecolor(BG_DARK)
739
            xs = [p.vector_3d[0] for p in self.papers]
740
            ys = [p.vector_3d[1] for p in self.papers]
741
            zs = [p.vector_3d[2] for p in self.papers]
742
            colors = [ACCENT_RED if p.best_rate >= REPEAT_THRESHOLD
743
              else FG_NEON for p in self.papers]
744
            ax.scatter(xs, ys, zs, c=colors, s=50, marker="o", edgecolors="white")
745
            for (i, p) in enumerate(self.papers):
746
                ax.text((xs[i]), (ys[i]), (zs[i]), (p.filename[:8]),
747
                  color=FG_TEXT, fontsize=8)
748

749
            ax.set_title("3D Semantic Space Mapping", color=FG_NEON, fontsize=14)
750
            canvas = FigureCanvasTkAgg(fig, master=(self.tab_3d))
751
            canvas.draw()
752
            canvas.get_tk_widget().pack(fill=(tk.BOTH), expand=True)
753

754
        def draw_topology(self):
755
            for widget in self.tab_topo.winfo_children():
756
                widget.destroy()
757

758
            fig = Figure(figsize=(8, 6), dpi=100, facecolor=BG_PANEL)
759
            ax = fig.add_subplot(111)
760
            ax.set_facecolor(BG_DARK)
761
            ax.set_aspect("equal")
762
            ax.axis("off")
763
            n = len(self.papers)
764
            if n == 0:
765
                return
766
            pos = {i: (math.cos(2 * math.pi * i / n),
767
              math.sin(2 * math.pi * i / n)) for i in range(n)}
768
            for (i, p) in enumerate(self.papers):
769
                (x, y) = pos[i]
770
                color = ACCENT_RED if p.best_rate >= REPEAT_THRESHOLD else FG_NEON
771
                ax.scatter(x, y, s=300, c=color, edgecolors="white", zorder=5)
772
                ax.text(x, (y - 0.15), (p.filename[:8]),
773
                  color=FG_TEXT, fontsize=9, ha="center")
774

775
            for r in self.engine.results:
776
                if r["final"] > 15:
777
                    i = next((idx for idx, p in enumerate(self.papers)
778
                      if p.filename == r["p1"]))
779
                    j = next((idx for idx, p in enumerate(self.papers)
780
                      if p.filename == r["p2"]))
781
                    (x1, y1) = pos[i]
782
                    (x2, y2) = pos[j]
783
                    color = ACCENT_RED if r["final"] >= REPEAT_THRESHOLD else FG_YELLOW
784
                    ax.plot([x1, x2], [y1, y2], color=color,
785
                      linewidth=(r["final"] / 20),
786
                      alpha=(min(1.0, r["final"] / 50)))
787
                ax.set_title("Plagiarism Topology Network", color=FG_NEON, fontsize=14)
788
                canvas = FigureCanvasTkAgg(fig, master=(self.tab_topo))
789
                canvas.draw()
790
                canvas.get_tk_widget().pack(fill=(tk.BOTH), expand=True)
791

792

793
    if __name__ == "__main__":
794
        try:
795
            from ctypes import windll
796
            windll.shcore.SetProcessDpiAwareness(1)
797
        except Exception:
798
            pass
799
        else:
800
            app = MainApplication()
801
            app.mainloop()

展开收起

CC Switch：一站式管理 Claude Code、Codex、Gemini CLI 的开源工具

Wed, 20 May 2026 00:00:00 GMT

CC Switch：一站式管理 Claude Code、Codex、Gemini CLI 的开源工具#

最近 AI 编程工具越来越多：Claude Code、Codex、Gemini CLI、OpenCode、OpenClaw、Hermes、Claude Desktop……每个工具都很好用，但配置管理也越来越麻烦。

你可能会遇到这些情况：

Claude Code 想在官方登录、第三方 API、不同模型供应商之间切换。
Codex、Gemini CLI、OpenCode 各自有自己的配置格式，手动改 JSON、TOML、环境变量很容易出错。
MCP Server、系统提示词、Skills 想在多个工具之间复用，但每个应用都要单独维护。
换电脑、重装系统、远程服务器使用时，配置迁移很折腾。
供应商临时不可用时，想快速切到备用线路，不想中断当前工作流。

如果你已经在日常开发里重度使用这些 AI CLI 工具，CC Switch 就非常值得关注。它不是一个新的聊天客户端，而是一个面向 AI 编程工具的“配置控制台”：把供应商、模型、MCP、Prompts、Skills、会话、用量统计和本地代理集中放到一个桌面应用里管理。

CC Switch 主界面

先说结论#

CC Switch 适合这几类用户：

同时使用 Claude Code、Codex、Gemini CLI、OpenCode 等多个 AI 编程工具的人。
经常在官方 API、第三方 API、企业网关、本地模型之间切换的人。
不想手动编辑 settings.json、config.toml、.env 等配置文件的人。
有多个 MCP Server、提示词模板、Skills，需要跨工具同步的人。
想把配置备份、迁移、云同步做得更稳一点的人。
需要托盘快速切换、用量统计、本地代理和故障转移的人。

如果你只偶尔用一次 Claude Code，而且只有一个官方账号、一个默认配置，那 CC Switch 可能有点“功能过剩”。但只要你开始接入多个供应商，或者一台电脑上同时跑几种 AI CLI，它的价值会很快体现出来。

它到底解决了什么问题#

现代 AI 编程工具的配置方式并不统一。

Claude Code 有自己的配置逻辑，Codex 有自己的配置文件，Gemini CLI 又是另一套方式。再加上 MCP Server、系统提示词、Skills、代理地址、API Key、模型名、用量统计，最后就会变成一堆散落在不同目录里的配置文件。

手动维护不是不能用，但有几个明显问题：

容易改错配置。
切换供应商慢。
多工具之间无法统一管理。
API Key 和配置备份不够直观。
换设备时迁移成本高。
出问题时很难快速定位是哪一层配置错了。

CC Switch 的思路是把这些复杂度收回来：用一个可视化界面管理多个 AI 编程工具，把常见供应商做成预设，把切换、同步、备份、代理、故障转移这些动作变成按钮和面板。

核心功能#

1. 供应商管理：一键切换不同 API 配置#

CC Switch 最核心的能力就是 Provider Management，也就是供应商管理。

你可以在里面给 Claude Code、Codex、Gemini CLI、OpenCode、OpenClaw 等工具添加不同供应商配置，比如官方登录、Anthropic/OpenAI/Google 相关接口、AWS Bedrock、NVIDIA NIM、社区中转服务、自建 New API 网关、本地模型网关等。

添加完成后，切换就不再需要手动改配置文件：

在主界面选中供应商，点击启用。
在系统托盘里直接点供应商名称快速切换。
对 Claude Code，官方说明目前支持供应商数据热切换，通常不需要重启终端。
对多数其他工具，切换后仍建议重启对应 CLI 或终端，让配置稳定生效。

这点对于经常比较模型效果的人很实用。比如同一个项目里，你可以快速在 Claude、Codex、Gemini、DeepSeek、Kimi、GLM、本地模型之间切换，观察速度、成本和代码质量差异。

CC Switch 添加供应商

2. 50+ 供应商预设，减少手动填坑#

很多配置管理工具最大的问题是“看起来能配，实际全靠自己猜字段”。CC Switch 的优势之一是内置了大量供应商预设。

预设的价值不只是少填几个输入框，而是降低新手犯错概率：

Base URL 不容易填错。
模型字段更清晰。
不同应用需要的配置格式会自动适配。
官方登录和第三方供应商可以分开管理。
部分供应商支持用量查询、模型检查或路由能力提示。

当然，预设并不等于只能用预设。你也可以添加自定义供应商，把自己的 OpenAI-compatible API、企业网关、New API、LiteLLM、本地模型服务接进去。

MCP、Prompts、Skills：不只是切换 API#

如果 CC Switch 只做供应商切换，那它就是一个“配置切换器”。但它现在更像一个 AI CLI 工作台，因为它把 MCP、Prompts、Skills 也一起管起来了。

1. MCP 服务器统一管理#

MCP Server 现在已经是 AI 编程工具的关键扩展方式。文件系统、浏览器、数据库、GitHub、搜索、自动化脚本，都可以通过 MCP 接进模型工作流。

问题是，不同 CLI 工具对 MCP 的配置位置和格式并不完全一样。CC Switch 提供了统一的 MCP 面板，支持 stdio、http、sse 等传输类型，并且可以把 MCP 配置同步到不同受管应用。

这适合两种场景：

个人用户：自己维护一套常用 MCP，多个 AI 工具共用。
团队用户：统一发放 MCP 模板，减少每个人单独配置时的差异。

2. Prompts 提示词管理#

很多 AI CLI 都依赖项目级或全局提示词文件，比如 Claude Code 的 CLAUDE.md、Codex 的 AGENTS.md、Gemini CLI 的 GEMINI.md。

CC Switch 可以创建多套 Prompt 预设，并通过 Markdown 编辑器维护。你可以准备不同风格的提示词：

日常开发模式。
代码审查模式。
测试补全模式。
文档写作模式。
高约束生产模式。

需要切换时直接启用对应预设，让它同步到实际使用的配置文件里。

3. Skills 管理#

Skills 可以理解为给 AI 工具安装的一组能力包或工作流说明。CC Switch 支持从 GitHub 仓库或 ZIP 文件安装 Skills，并同步到不同应用。

这对经常折腾 AI Agent 工作流的人挺有用：不用每个工具都手动复制一遍技能文件，也方便备份和卸载。

本地代理与故障转移#

CC Switch 还有一块更进阶的能力：Local Proxy，也就是本地代理。

它可以在本地做协议适配、格式转换和路由切换。比如某些工具只认特定 API 结构，而你手里是 OpenAI-compatible 接口，CC Switch 可以在中间做转换，让不同供应商更容易接入同一个工具。

同时，它还提供自动故障转移、熔断、健康检查等能力。对于长时间跑任务的人，这一点很重要：如果主供应商临时不可用，可以切到备用供应商，减少任务中断。

这类功能对普通轻度用户不是必需品，但对重度用户、团队环境、自建网关用户会很有价值。

会话和用量统计#

CC Switch 也在做会话与用量相关功能。

会话管理器可以浏览、搜索和恢复多个受管应用的对话历史。对于经常同时跑 Claude Code、Codex、Gemini CLI 的人，统一查看历史记录会比到处找目录舒服很多。

用量仪表盘则可以按供应商、模型、日期等维度查看请求、Token 和费用情况。尤其是接入多个供应商后，账单和用量很容易分散，统一面板能帮助你判断哪个模型更适合日常任务、哪个供应商成本更高、缓存命中是否正常。

v3.15.0 新变化#

截至我写这篇文章时，GitHub Releases 上的最新版本是 v3.15.0，发布时间是 2026-05-16。

这个版本比较值得关注，因为它把 Claude Desktop 提升成了一等受管对象。也就是说，CC Switch 不只管 Claude Code、Codex、Gemini CLI 这类命令行工具，也开始面向 Claude Desktop 做第三方供应商管理。

v3.15.0 里几个重点变化包括：

新增 Claude Desktop 管理面板。
支持通过应用内代理网关为 Claude Desktop 切换第三方供应商。
引入基于角色的模型映射，例如 sonnet、opus、haiku。
支持复用 Copilot / Codex OAuth 供应商。
增加 44 个 Claude Desktop 供应商预设。
Codex OAuth 可以按需从 ChatGPT 后端获取实时模型列表。
用量仪表盘根据日期、供应商、模型筛选动态更新。
多项代理、Responses API、DeepSeek tool calls、DashScope 用量解析等稳定性修复。

如果你已经在用较旧版本，建议看看更新日志再升级，尤其是已经配置过代理和第三方供应商的人。

安装方式#

CC Switch 支持 Windows、macOS 和 Linux。

macOS#

macOS 用户推荐用 Homebrew：

Terminal window

1
brew tap farion1231/ccswitch
2
brew install --cask cc-switch

更新：

Terminal window

1
brew upgrade --cask cc-switch

也可以从 GitHub Releases 下载 .dmg 安装包。官方说明里提到，macOS 版本已经通过 Apple 代码签名和公证，可以直接安装打开。

Windows#

Windows 用户可以从 GitHub Releases 下载：

CC-Switch-v{版本号}-Windows.msi
CC-Switch-v{版本号}-Windows-Portable.zip

如果不想安装，可以使用绿色版压缩包，解压后运行 CC-Switch.exe。

Linux#

Linux 用户可以根据发行版选择：

Debian / Ubuntu：下载 .deb
Fedora / RHEL / openSUSE：下载 .rpm
其他发行版：下载 .AppImage
Arch Linux：可以通过 AUR 安装 cc-switch-bin

AppImage 方式一般是：

Terminal window

1
chmod +x CC-Switch-v{版本号}-Linux-*.AppImage
2
./CC-Switch-v{版本号}-Linux-*.AppImage

基础使用流程#

第一次使用可以按这个顺序来：

安装并启动 CC Switch。
在应用切换器里确认要管理的工具，比如 Claude Code、Codex、Gemini CLI。
如果本机已有旧配置，先导入现有配置作为默认供应商。
点击添加供应商，选择预设或自定义填写 API 地址、Key、模型名。
在主界面点击启用，或从系统托盘快速切换。
根据工具类型决定是否重启终端。Claude Code 通常支持热切换，其他工具建议重启后再测。
打开 MCP、Prompts、Skills 面板，把常用扩展和提示词统一整理进去。
如果多设备使用，可以把配置目录放到 iCloud、OneDrive、Dropbox、坚果云、NAS 或 WebDAV 这类同步环境里。

数据存在哪里#

官方 README 里说明，CC Switch 的主要数据默认放在 ~/.cc-switch/ 下：

数据库：~/.cc-switch/cc-switch.db
本地设置：~/.cc-switch/settings.json
配置备份：~/.cc-switch/backups/
Skills：~/.cc-switch/skills/
Skills 备份：~/.cc-switch/skill-backups/

它采用 SQLite 存储核心数据，并通过自动备份、原子写入等方式降低配置损坏风险。这个设计比“直接散落写一堆 JSON 文件”更稳，也更适合后续做同步和迁移。

使用建议#

CC Switch 很强，但它管理的是 API Key、供应商、代理和本地配置，所以使用时建议注意这几件事：

添加第三方供应商前，确认服务商是否可信。
不要把 API Key 随便截图、贴到公开 issue 或博客里。
切换供应商后，先跑一个小任务测试连通性，再跑长任务。
如果某个工具切换后没有立刻生效，先重启对应终端或 CLI。
开启云同步时，注意同步工具的冲突处理，避免多台设备同时改同一份配置。
团队共享配置时，不要把个人 API Key 一起导出给别人。

重点安全提醒：只认官方渠道#

这里必须单独提醒一下。

官方在 v3.15.0 Release 里明确说明：CC Switch 是完全免费、开源的桌面应用，官方不向用户收费。

官方渠道只认：

官网：https://ccswitch.io/zh/
GitHub 仓库：https://github.com/farion1231/cc-switch
Releases 下载：https://github.com/farion1231/cc-switch/releases

如果你在搜索引擎里看到某个“CC Switch”网站要求你充值、购买套餐、输入账号密码或提交登录凭据，务必提高警惕。它很可能不是官方项目。

简单判断标准：CC Switch 本体是配置管理工具，不是收费 API 平台。

和手写脚本相比，它的优势在哪里#

如果只是切换一个环境变量，写个 shell 脚本当然也能解决。但 CC Switch 的价值在于它把很多分散问题合到一起了：

需求	手写脚本	CC Switch
单个供应商切换	可以	可以
多工具统一管理	需要自己维护	原生支持
MCP 同步	麻烦	有统一面板
Prompt 预设	需要自己写逻辑	内置 Markdown 编辑与同步
Skills 安装	手动复制	可视化管理
配置备份	自己写	自动备份
用量统计	基本没有	内置仪表盘
本地代理/故障转移	实现成本高	内置
跨平台 GUI	基本没有	Windows/macOS/Linux

所以它不是要取代所有脚本，而是适合那些已经有复杂 AI CLI 工作流的人，把“配置维护”这件事从日常开发里拿掉。

总结#

CC Switch 是一款很适合 AI 编程重度用户的开源工具。

它最打动我的地方不是“能切换供应商”这一点，而是它把 Claude Code、Codex、Gemini CLI、OpenCode、OpenClaw、Hermes、Claude Desktop 这些工具背后的配置管理问题统一收拢了：供应商、模型、MCP、Prompts、Skills、会话、用量、代理、备份，都能在一个地方处理。

如果你现在还在手动改配置文件，或者经常因为切换模型、切换供应商、同步 MCP 而打断工作流，可以试试 CC Switch。它会让 AI 编程工具从“能用”变得更像一套可维护的个人开发环境。

项目地址#

官网：https://ccswitch.io/zh/
GitHub：https://github.com/farion1231/cc-switch
Releases：https://github.com/farion1231/cc-switch/releases
中文用户手册：https://github.com/farion1231/cc-switch/tree/main/docs/user-manual/zh

电子科大成都学院自动化成绩查询

Thu, 14 May 2026 00:00:00 GMT

背景简介#

以前写过的一个针对电子科技大学成都学院教务系统的自动查分脚本。它能够自动登录教务系统、调用打码平台解决图形验证码、抓取成绩列表，并与本地缓存的成绩进行比对。一旦发现有新的成绩更新，就会通过 IYUU 接口自动发送微信通知。

技术栈说明#

该脚本整合了多个强大的 Node.js 库与第三方服务：

Playwright: 负责驱动无头浏览器（Chromium）进行模拟登录、节点交互及屏幕截图。
2Captcha: 第三方打码平台，用于识别教务系统登录页的图形验证码。
Axios & Cheerio: 登录成功获取到 Cookie 后，使用 Axios 高效请求成绩页面，并用 Cheerio (类似于 jQuery) 快速解析 HTML 结构提取成绩表格。
Redis (ioredis): 用于持久化保存当前有效的 Cookie，以及上一次抓取到的成绩数据。
IYUU: 微信消息推送服务，用于将成绩变化通知实时推送到手机。

完整代码实现#

1
import axios from 'axios'
2
import Redis from 'ioredis'
3
import qs from 'qs'
4
import fs from 'fs'
5
import path from 'path';
6
import { chromium } from 'playwright'
7
import * as cheerio from 'cheerio';
8

9
const redis = new Redis({
10
    host: '127.0.0.1',
11
    port: 6379,
12
    password: '1234567',
13
    db: 0
14
});
15

16
redis.on('connect', () => {
17
});
18

19
async function runBrowser() {
20
    const browser = await chromium.launch({
21
        headless: true,
22
        executablePath: '/usr/bin/chromium',
23
        args: [
24
            '--no-sandbox',
25
            '--disable-gpu',
26
        ]
27
    });
28
    const page = await browser.newPage();
29

30
    try {
31
        await page.goto('http://www.cduestc.cn/eams/loginExt.action');
32
        await page.fill('#username', process.env.kc_user);
33
        await page.fill('#password', process.env.ke_password);
34

35
        const captchaElement = await page.locator('img[src="/eams/captcha/image.action"]');
36
        const captchaImage = await captchaElement.screenshot();
37
        const captchaImageBase64 = captchaImage.toString('base64');
38

39
        // 请求 2captcha 平台进行打码
40
        const uploadResponse = await axios.post('https://2captcha.com/in.php', {
41
            key: process.env.captcha_key,
42
            method: 'base64',
43
            body: captchaImageBase64,
44
            json: 1,
45
            type: 'ImageToTextTask',
46
        });
47

48
        if (uploadResponse.data.status !== 1) {
49
            throw new Error(`验证码上传失败: ${uploadResponse.data.request}`);
50
        }
51

52
        const captchaID = uploadResponse.data.request;
53
        let result = '';
54

55
        // 轮询获取识别结果
56
        while (true) {
57
            const getResultResponse = await axios.get(`https://2captcha.com/res.php?key=${process.env.captcha_key}&action=get&id=${captchaID}&json=1`);
58
            if (getResultResponse.data.status === 1) {
59
                result = getResultResponse.data.request;
60
                break;
61
            } else if (getResultResponse.data.request === 'ERROR_CAPTCHA_UNSOLVABLE') {
62
                throw new Error('验证码无法识别');
63
            }
64
            await new Promise(resolve => setTimeout(resolve, 2000));
65
        }
66

67
        console.log('识别验证码', result);
68
        await page.type('#captcha_response', result);
69
        await page.keyboard.press('Enter');
70
        await page.waitForTimeout(2000);
71

72
        // 处理登录错误情况
73
        const pageSource = await page.content();
74
        const errorMessageRegex = /<span>(.*?)<\/span>/;
75
        const match = pageSource.match(errorMessageRegex);
76
        if (match && match[1]) {
77
            const errorText = match[1];
78
            if (errorText == '验证码不正确') {
79
                console.log(`错误消息: ${errorText}`);
80
                await browser.close();
81
                return runBrowser();
82
            } else if (errorText == '账户不存在' || errorText == '密码错误') {
83
                console.log(`错误消息: ${errorText}`);
84
                await browser.close();
85
                process.exit();
86
            }
87
        }
88

89
        // 登录成功，保存 Cookie
90
        const cookies = await page.context().cookies();
91
        const cookieW = cookies.map(cookie => `${cookie.name}=${cookie.value}`).join('; ');
92
        await redis.set('kc_cookie', cookieW);
93
        console.log(`Cookie: ${cookieW}`);
94
        await browser.close();
95

96
        return cjcx();
97
    } catch (error) {
98
        console.error('登录时发生错误:', error);
99
    } finally {
100
        await browser.close();
101
    }
102
}
103

104
async function cjcx() {
105
    try {
106
        const cookie = await redis.get('kc_cookie');
107
        const cjcx = axios.create({
108
            headers: {
109
                'Cookie': cookie,
110
            },
111
        });
112

113
        // 请求成绩页面
114
        const response = await cjcx.get('http://www.cduestc.cn/eams/teach/grade/course/person!search.action?semesterId=138&projectType=&_=' + (new Date().getTime()));
115
        const pageContent = response.data;
116

117
        // 如果 Cookie 失效，重新执行登录流程
118
        if (pageContent.includes('<title>上海树维信息科技有限公司教学管理系统</title>')) {
119
            console.log('cookie失效')
120
            return runBrowser();
121
        }
122

123
        const $ = cheerio.load(response.data);
124
        const extractedData: any[] = [];
125

126
        $('tbody tr').each((index, element) => {
127
            const row = $(element);
128
            const 学年学期 = row.find('td:nth-child(1)').text().trim();
129
            const 课程代码 = row.find('td:nth-child(2)').text().trim();
130
            const 课程类别 = row.find('td:nth-child(5)').text().trim();
131
            const 学分 = row.find('td:nth-child(6)').text().trim();
132
            const 课程名称 = row.find('td:nth-child(4)').text().trim();
133
            const 总评成绩 = row.find('td:nth-child(8)').text().trim();
134
            const 最终成绩 = row.find('td:nth-child(9)').text().trim();
135

136
            const courseData = { 学年学期, 课程代码, 课程类别, 学分, 课程名称, 总评成绩, 最终成绩 };
137
            extractedData.push(courseData);
138
        });
139

140
        // 对比本地 Redis 成绩缓存
141
        const storedData = await redis.get('kc_cj');
142
        let storedCourses = storedData ? JSON.parse(storedData) : [];
143
        let dataChanged = false;
144
        const newStoredCourses = [];
145
        let changeMessage = '';
146

147
        for (let i = 0; i < extractedData.length; i++) {
148
            const course = extractedData[i];
149
            const storedCourse = storedCourses.find((storedCourse: any) => storedCourse.课程代码 === course.课程代码);
150
            if (!storedCourse || storedCourse.总评成绩 !== course.总评成绩) {
151
                console.log(`课程 ${course.课程名称} 的成绩发生变化`);
152
                dataChanged = true;
153
                changeMessage += `课程名称: ${course.课程名称}\n成绩: ${course.总评成绩}\n\n`;
154

155
                const index = storedCourses.findIndex((storedCourse: any) => storedCourse.课程代码 === course.课程代码);
156
                if (index !== -1) {
157
                    storedCourses[index] = course;
158
                } else {
159
                    storedCourses.push(course);
160
                }
161
            }
162
            newStoredCourses.push(course.课程代码);
163
        }
164

165
        for (let i = 0; i < storedCourses.length; i++) {
166
            const storedCourse = storedCourses[i];
167
            if (!newStoredCourses.includes(storedCourse.课程代码)) {
168
                dataChanged = true;
169
                storedCourses.splice(i, 1);
170
                i--;
171
            }
172
        }
173

174
        if (dataChanged) {
175
            const currentData = JSON.stringify(storedCourses);
176
            await redis.set('kc_cj', currentData);
177

178
            // IYUU 微信推送 API
179
            await axios.post('https://iyuu.cn/xxxxxxx.send', null, {
180
                params: {
181
                    text: '成绩更新通知',
182
                    desp: changeMessage
183
                }
184
            }).then(response => {
185
                console.log('推送成功:', response.data);
186
            }).catch(error => {
187
                console.error('推送失败:', error);
188
            });
189
        } else {
190
            console.log('成绩没有变化');
191
        }
192

193
    } catch (error) {
194
        console.error('发生错误：', error);
195
    }
196
}
197

198
async function main() {
199
    await cjcx();
200
    process.exit();
201
}
202

203
main();

展开收起

核心逻辑解析#

自动登录与验证码处理 (runBrowser)：
- 使用 Playwright 启动无头浏览器并导航至登录页。
- 填入账密后，精确定位验证码图片，调用 .screenshot() 将其截取并转换为 Base64。
- 向 2Captcha 平台提交图片并持续轮询等待识别结果。
- 拿到验证码后自动填入并回车，处理可能出现的登录异常（验证码错误进行递归重试，密码错误直接终止程序）。
- 成功进入教务系统后获取当前 Context 下所有的 Cookie 保存进 Redis，随后调用查分函数。
成绩抓取与变动检测 (cjcx)：
- 用 Axios 并携带储存在 Redis 的 Cookie 访问成绩查询页面，避免每次查询都走沉重的无头浏览器渲染。
- 校验返回内容是否包含登录页特有标签（用于判断 Cookie 是否过期）。如果已过期，重新拉起 runBrowser。
- 解析页面表格 HTML，将新抓取的成绩与 Redis 里的 kc_cj 旧成绩一一对比，生成变动日志。
- 如果数据存在变动，更新 Redis 里的成绩缓存，同时触发 IYUU 接口把最新成绩推送至微信。

【Google Workspace】TRY₺75.00/年并且续费不涨价的 .com 域名

Tue, 12 May 2026 00:00:00 GMT

Google Workspace 的 .com 域名还是 TRY₺75.00/年#

之前一直没有在 Google Workspace 买过域名，论坛里不少坛友都说从 Google Workspace 买的域名续费变贵了。

今天刚在 Google Workspace 买了一个 .com 域名，价格依旧是 TRY₺75.00/年。至少我这次实测下来，Google Workspace 里的 .com 域名目前还是这个价。

Google Workspace .com 域名价格截图

从宝塔毕业后，我更推荐原生方案

Tue, 12 May 2026 00:00:00 GMT

建站面板怎么选：我更推荐原生方案#

很多人第一次接触云服务器，都是从宝塔开始的。

这很正常。新手刚拿到一台 VPS，不熟悉 ssh，不会看 htop，对 vim 头疼，也不知道 Nginx、PHP、MySQL、证书、计划任务和防火墙该怎么串起来。这个时候，一个能看 CPU、内存、磁盘、网络流量，能一键装 LNMP，还能点几下创建网站和数据库的面板，确实像新手向导。

但面板不是免费的午餐。它省下来的命令行学习成本，最后可能会变成隐私成本、安全成本、资源占用、插件依赖和迁移成本。

我的结论先放前面：

能力强、正式站、重视隐私和长期维护：优先原生方案。
喜欢开源和 Docker 自托管：可以选 1Panel。
只想快速搭 PHP/WordPress：宝塔能用，但我不会优先推荐给隐私敏感用户。
想避开宝塔国内版账号体系：可以看 aaPanel，但它的 Pro 和插件价格不算低。
本地开发、临时练手：小皮面板可以用，生产环境不优先推荐。

先看粗略对比#

方案	推荐程度	适合谁	主要问题
原生方案	强烈推荐给有能力的人	长期正式站、重隐私、重安全、想少依赖第三方	学习成本高，备份、监控、证书、日志都要自己管
1Panel	推荐	Docker 自托管、个人服务器、开源偏好用户	Docker 化更吃资源，部分高级功能收费
宝塔	谨慎推荐	传统 PHP 站、WordPress、临时快速交付	安全黑历史、国内版绑定账号/手机号、商业化组件多
aaPanel	可选	想要宝塔类似体验但不想用国内版的人	免费核心可用，但 Pro/插件价格更高
小皮面板	只推荐练手或测试	本地开发、新手起环境、临时项目	产品比较古老，bug 和细节问题相对多

宝塔：曾经很好用，但信任已经变贵了#

宝塔的优点不用否认。传统建站要的东西它基本都有：网站、数据库、FTP、SSL、计划任务、文件管理、PHP 多版本、反向代理、伪静态、备份、软件商店。对刚入门的人来说，它确实能把一堆 Linux 操作压缩成几个按钮。

宝塔面板界面

但我现在不会把宝塔放在第一推荐，原因主要有几个。

1. 隐私和信任问题#

宝塔国内版的账号体系、手机号绑定，以及一些用户对后台通讯行为的抓包讨论，都会让重视隐私的人不舒服。

2020 年 11 月那次直播中断事件在网上有很多传言，但传言不是事实，我不把它当作判断依据。真正的问题是：当一个服务器面板绑定了国内账号体系，并且它本身又拥有很高的机器权限，用户天然会开始在意它到底收集了什么、上传了什么、谁能看到。

普通个人站长不做灰黑产，通常不会因此立刻遇到问题。但服务器是自己的生产环境，背后多一层不可控关系，心里总归会别扭。

2. 界面越来越重，商业化存在感越来越强#

早期宝塔的吸引力是简单：看状态、装环境、建站、管数据库。

后面它的功能越来越多，安全、Docker、监控、企业版广告、人工服务、付费插件这些东西在界面里的存在感也越来越强。问题不是它收费，软件当然可以收费；问题是当你明明不需要某些组件，它仍然长期占据界面和工作流时，体验就会变差。

对老用户来说，这种变化很明显：面板不再只是一个轻量工具，而是逐渐变成一个商业生态入口。

3. 更新带来的稳定性焦虑#

面板要经常更新，这本来是好事，尤其是安全问题必须修。但宝塔这类高权限面板一旦更新出问题，影响会很直接。

一些老用户反馈过页面样式丢失、SSL 续签异常、计划任务界面损坏、文件操作被误判阻止等问题。哪怕这些不是每个人都会遇到，只要发生在生产环境里，就足够让人烦躁。

你本来用面板是为了省心，结果更新后还要排查面板本身的问题，这就有点本末倒置了。

4. LNMP 环境不一定轻，也不一定适合所有程序#

宝塔的一键 LNMP 很方便，但默认配置不一定适合低配机器。1C1G、1C2G 的小服务器，如果 MySQL、PHP-FPM、Nginx、面板和站点一起跑，内存很容易紧张。

另外，宝塔对 PHP 函数禁用、插件预装、系统库路径和环境配置都有自己的处理方式。有些程序安装时会遇到奇怪兼容问题，比如 Flarum、早期 Cloudreve 这类对环境比较挑的项目，排查起来不一定比原生环境省事。

5. 安全问题是最硬的减分项#

宝塔和 aaPanel 都是高权限服务器面板。它们管理网站、数据库、文件、证书、计划任务、服务进程，有时还会接触 root 权限。一旦面板本身或插件出严重漏洞，风险不是“某个网页坏了”，而可能是整台机器失守。

几个典型事件：

时间	事件	影响
2020-08	宝塔 phpMyAdmin 数据库未授权访问	360CERT 将漏洞等级评为严重，远程访问特定路径可能直接进入 phpMyAdmin
2020-06	aaPanel through 6.6.6 远程命令执行	CVE-2020-14421，认证用户可通过计划任务脚本内容执行命令
2020-06	aaPanel through 6.6.6 命令注入	CVE-2020-14950，影响软件商店服务管理请求
2022-03	aaPanel 6.8.21 目录穿越	CVE-2022-26252，NVD 描述中提到可能获取 root 用户私钥
2022-12	Nginx 备份文件挂马争议	社区有讨论，官方有否认，这类未定性事件只能作为风险提醒

漏洞本身不是某一家独有的问题，任何流行软件都可能被挖漏洞。真正让我介意的是：面板权限太高，漏洞爆发时影响面太大。对正式站点来说，少暴露一个高权限 Web 面板，本身就是很有效的安全策略。

aaPanel：宝塔海外版思路，但价格不一定香#

aaPanel 可以理解成宝塔海外体系的代表。它的思路还是传统 Web Hosting Control Panel：网站、数据库、FTP、文件管理、SSL、Docker、WordPress 工具、WAF、文件保护等。

如果你喜欢宝塔的操作方式，但不想用国内版账号体系，可以考虑 aaPanel。

但它不是“免费平替宝塔”。aaPanel 免费版能用，官网也写了 Basic 免费；但 Professional、WAF、文件保护、网站统计、多账户等能力都可能进入付费范围。官网价格里，Professional 年付标价是美元计价，终身版也不便宜。

所以 aaPanel 的定位更像：

想要宝塔式操作体验。
服务器主要在海外。
能接受美元价格和插件收费。
不想用国内版宝塔账号体系。

如果只是个人小站，aaPanel 免费版够不够用，要看你是否需要 WAF、文件保护、多用户、网站统计和高级 WordPress 工具。

1Panel：开源、现代，但 Docker 不是白送的#

1Panel 是我现在更愿意推荐给新手的面板。它主打开源、现代化界面、Docker 应用商店、网站管理、数据库管理、文件管理、服务器监控、备份恢复和容器管理。对今天常见的自托管玩法来说，它比传统 PHP 面板更顺手。

1Panel 界面

它适合部署这些东西：

Halo、WordPress、Typecho
Uptime Kuma、哪吒监控、RustDesk
MySQL、PostgreSQL、Redis
Alist、Umami、Vaultwarden
各种 Docker 自托管应用

但 1Panel 的优点也是它的缺点：它大量围绕 Docker 工作。

Docker 的好处是应用隔离、部署方便、迁移清晰；缺点是低配机器上资源占用更明显。1C1G 的机器再跑多个容器，很容易开始交换内存。对只想跑一个静态站或一个小 WordPress 的人来说，原生 Nginx/Caddy 反而更轻。

另外，1Panel 社区版确实开源免费，但不是所有能力都免费。官方版本对比里，专业版会包含多机管理、移动端、WAF、防篡改、网站监控报表、告警等能力。个人用户只用基础功能问题不大，如果想要完整安全和运维能力，就要接受付费。

我的评价是：1Panel 适合个人自托管和现代应用部署，但低配机器不要无脑堆容器。

小皮面板：适合练手，不适合长期依赖#

小皮面板，也就是 XP.cn/phpStudy 这一系，很多人最早是从本地 PHP 环境认识它的。它的优点是门槛低，点几下就能把 PHP、MySQL、Redis、网站、文件管理这些东西跑起来。

小皮面板界面

但小皮的问题也比较明显：产品气质偏老，面板细节和 bug 相对更多，生产环境里遇到问题时，排查体验通常不如原生方案清晰，也不如宝塔那样有大量教程覆盖。

我的建议很简单：

本地开发可以用。
新手练手可以用。
临时环境可以用。
长期生产站点不优先用。

原生方案：能力强就选它#

原生方案不是“什么工具都不用”，而是不把整台服务器交给一个高权限 Web 面板。你自己组合清楚的组件，每个组件只做自己的事。

我更推荐的组合是：

需求	推荐
系统	Debian / Ubuntu LTS
Web 服务	Caddy、Nginx、OpenResty
应用部署	Docker Compose、systemd、PM2
HTTPS	Caddy 自动证书，或 acme.sh / Certbot
数据库	MySQL、PostgreSQL、Redis
备份	restic、rclone、mysqldump、定时任务
监控	Uptime Kuma、Netdata、云厂商监控
安全	UFW、fail2ban、SSH Key、最小权限

原生方案的优点很直接：

不需要暴露一个高权限 Web 面板。
不需要绑定手机号或依赖面板账号体系。
迁移更清楚，配置文件、Compose 文件、数据库备份都能带走。
出问题更容易定位，不会被面板隐藏太多细节。
安全边界更可控，用不到的东西根本不安装。
低配机器上可以更轻，不需要额外跑一套面板服务。

缺点也真实：你要懂日志、权限、端口、防火墙、证书续期、备份恢复。它不适合完全不想学习 Linux 的人。

但如果你已经能看懂 docker compose logs、systemctl status、nginx -t、journalctl -u，那我会把原生方案放在第一推荐。

最后的选择建议#

场景	我会选
正式站点，长期维护，重视隐私	原生方案
低配 VPS，只跑一个小站	原生 Caddy/Nginx，少装面板
想玩自托管 Docker 应用	1Panel 或原生 Docker Compose
新手想快速看到网站跑起来	1Panel
传统 PHP/WordPress 交付型网站	宝塔，但要锁好入口和备份
不想用宝塔国内版	aaPanel
本地开发或临时测试	小皮面板

面板安全清单#

如果最后还是要用面板，至少做这些事：

面板入口不要裸奔公网，尽量限制 IP 或放到内网/VPN 后面。
不要用默认端口、默认用户名和弱密码。
能开双因素认证就开。
插件少装，用不到就卸载。
备份要离机保存，不要只放在同一台服务器。
先演练恢复流程，再相信自己的备份。
面板更新、系统更新、数据库更新都不要长期拖。
重要站点不要把面板当作唯一运维手段，至少要知道如何 SSH 进去救场。

参考#

Dana. (2022, December 10). 浅谈为什么放弃宝塔. Tempest. https://www.tempest.zone/archives/635
1Panel：https://1panel.cn/
1Panel 版本对比：https://1panel.cn/versions.html
宝塔面板文档：https://docs.bt.cn/
aaPanel Pricing：https://www.aapanel.com/new/pricing.html
小皮面板：https://www.xp.cn/
360CERT 宝塔面板数据库管理未授权访问漏洞通告：https://cert.360.cn/warning/detail?id=896274887c1ffc751c876eb5cf3db3ad
CVE-2020-14421：https://www.cvedetails.com/cve/CVE-2020-14421/
CVE-2020-14950：https://www.cisa.gov/news-events/bulletins/sb20-181
CVE-2022-26252：https://nvd.nist.gov/vuln/detail/CVE-2022-26252

绵阳城市学院校园网 Srun Portal 认证逆向分析

Mon, 11 May 2026 00:00:00 GMT

本文记录一次基于浏览器抓包与前端 JavaScript 分析，使用 Go 语言模拟 Srun Portal 认证流程的实现过程。内容仅适用于本人已授权使用的校园网 / 内网 Portal 登录环境。

1. 背景#

Portal 认证页面在登录时，并不是直接提交明文密码，而是通过前端 JavaScript 生成多个加密参数后，再向后端接口发起 JSONP 请求。

打开浏览器开发者工具的 Network 面板，可以看到登录时会依次触发两个关键接口：

抓包概览：get_challenge 和 srun_portal 两个接口

1
GET /cgi-bin/get_challenge   # 获取 challenge / token
2
GET /cgi-bin/srun_portal     # 提交登录认证

最终 Go 脚本成功返回：

1
{
2
  "error": "ok",
3
  "res": "ok",
4
  "suc_msg": "ip_already_online_error"
5
}

其中 ip_already_online_error 表示该 IP 已经在线，说明认证流程本身已经成功。

2. 整体流程#

整个认证流程可以拆成 4 步：

1
1. GET /cgi-bin/get_challenge  →  获取当前 IP 和 challenge（token）
2
2. HMAC-MD5(password, token)   →  生成 hmd5
3
3. xEncode(JSON, token) + 自定义 Base64  →  生成 info
4
4. SHA1(拼接字符串)            →  生成 chksum，提交 srun_portal

流程图：

flowchart TD A([浏览器 / 脚本]) -->|GET /cgi-bin/get_challenge\nusername=xxx & ip=xxx| B[Portal Server] B -->|返回 challenge / client_ip / online_ip| C[/"token = challenge\nip = client_ip"/] C --> D["hmd5 = HMAC-MD5(password, token)"] C --> E["info = {SRBX1} + srunBase64(xEncode(JSON, token))"] C --> F["chksum = SHA1(token+username+token+hmd5+…+info)"] D & E & F -->|GET /cgi-bin/srun_portal\naction=login & password & info & chksum| G[Portal Server] G -->|error=ok / res=ok| H([认证成功])

3. get_challenge 接口#

请求示例：

1
GET http://10.8.8.117/cgi-bin/get_challenge
2
    ?callback=jQuery1124...
3
    &username=23131313@test_sl
4
    &ip=10.103.31.95
5
    &_=1778481035189

参数	说明
`callback`	JSONP 回调函数名
`username`	登录账号
`ip`	Portal 识别的客户端 IP
`_`	时间戳，防止缓存

返回示例（JSONP 格式）：

1
jQuery1124xxx({
2
  "challenge": "006fe3212db9d430...",
3
  "client_ip": "10.103.26.136",
4
  "ecode": 0,
5
  "error": "ok",
6
  "expire": "60",
7
  "online_ip": "10.103.31.95",
8
  "res": "ok"
9
})

核心字段是 challenge，它是后续所有加密计算的 token。

注意：challenge 与 username、ip 有绑定关系。后续 login 请求中的 IP 必须与此处完全一致，否则会出现 challenge_expire_error 或 auth_info_error。

4. srun_portal 登录接口#

抓包可以看到登录请求携带的完整参数：

srun_portal 请求的完整 Payload 参数

1
action=login
2
username=23131313@test_sl
3
password={MD5}xxxx
4
os=Mac OS
5
name=Macintosh
6
double_stack=0
7
chksum=xxxx
8
info={SRBX1}xxxx
9
ac_id=0
10
ip=10.103.26.135
11
n=200
12
type=1

其中最重要的三个参数是 password、info、chksum，下面逐一分析生成方式。

5. password 参数生成（HMAC-MD5）#

在前端 JavaScript 源码中可以找到：

前端 sendAuth 函数：HMAC-MD5 生成 hmd5

1
var hmd5 = md5(password, token);

这里的 md5(password, token) 实际上是：

1
HMAC-MD5(key=token, message=password)

登录请求中的 password 参数拼接前缀：

1
password = {MD5} + hmd5

Go 实现：

1
func hmacMD5(pass, token string) string {
2
    h := hmac.New(md5.New, []byte(token))
3
    h.Write([]byte(pass))
4
    return hex.EncodeToString(h.Sum(nil))
5
}

6. info 参数生成#

前端对应代码：

info 编码：{SRBX1} + base64.encode(encode(info, token))

info 的生成分 4 步：

1
1. 构造 JSON（password 为明文，不是 MD5 后的值）
2
2. xEncode(JSON, token)  →  XXTEA 加密
3
3. srunBase64(bytes)     →  自定义 Base64 编码
4
4. 拼接前缀 {SRBX1}

原始 JSON：

1
{"username":"23131313@test_sl","password":"12345","ip":"10.103.26.135","acid":"0","enc_ver":"srun_bx1"}

最终格式：

1
{SRBX1}xxxxxxxx

Go 实现：

1
func srunInfo(token string) string {
2
    info := fmt.Sprintf(
3
        `{"username":"%s","password":"%s","ip":"%s","acid":"%s","enc_ver":"srun_bx1"}`,
4
        username, password, ip, acID,
5
    )
6
    encoded := xEncode(info, token)
7
    return "{SRBX1}" + srunBase64(encoded)
8
}

7. xEncode / encode 算法分析（XXTEA）#

前端的 encode() 完整代码：

前端 encode() 函数完整实现（XXTEA 变体）

1
function encode(str, key) {
2
  if (str === '') return '';
3

4
  var v = s(str, true);   // 字符串 → uint32 数组，追加长度
5
  var k = s(key, false);  // key → uint32 数组
6

7
  if (k.length < 4) k.length = 4;
8

9
  var n = v.length - 1,
10
      z = v[n], y = v[0],
11
      c = 0x86014019 | 0x183639A0,  // delta = 0x9E3779B9
12
      q = Math.floor(6 + 52 / (n + 1)),
13
      d = 0;
14

15
  while (0 < q--) {
16
    d = d + c & (0x8CE0D9BF | 0x731F2640);
17
    e = d >>> 2 & 3;
18
    for (p = 0; p < n; p++) {
19
      y = v[p + 1];
20
      m = z >>> 5 ^ y << 2;
21
      m += (y >>> 3 ^ z << 4) ^ (d ^ y);
22
      m += k[p & 3 ^ e] ^ z;
23
      z = v[p] = v[p] + m & (0xEFB8D130 | 0x10472ECF);
24
    }
25
    y = v[0];
26
    m = z >>> 5 ^ y << 2;
27
    m += (y >>> 3 ^ z << 4) ^ (d ^ y);
28
    m += k[p & 3 ^ e] ^ z;
29
    z = v[n] = v[n] + m & (0xBB390742 | 0x44C6F8BD);
30
  }
31

32
  return l(v, false);
33
}

展开收起

其中常量：

1
0x86014019 | 0x183639A0 = 0x9E3779B9  （XXTEA 标准 delta 常量）

关键点：Go 实现时需严格按照 JS 逐行翻译，直接合并公式容易因运算符优先级不同导致结果错误，进而产生 auth_info_error。

8. s() 和 l() 辅助函数#

前端的 s() 和 l() 对应 Go 中的 strToLong 和 longToStr：

前端 A(n,t,r) 函数，即 s()/l() 辅助函数

s() — 字符串转 uint32 数组（小端序，4 字节一组）：

1
function s(a, b) {
2
  var c = a.length, v = [];
3
  for (var i = 0; i < c; i += 4) {
4
    v[i >> 2] = a.charCodeAt(i)
5
      | a.charCodeAt(i + 1) << 8
6
      | a.charCodeAt(i + 2) << 16
7
      | a.charCodeAt(i + 3) << 24;
8
  }
9
  if (b) v[v.length] = c;
10
  return v;
11
}

l() — uint32 数组转回字节字符串：

1
function l(a, b) {
2
  var d = a.length, c = (d - 1) << 2;
3
  if (b) { var m = a[d - 1]; c = m; }
4
  for (var i = 0; i < d; i++) {
5
    a[i] = String.fromCharCode(
6
      a[i] & 0xff, a[i] >>> 8 & 0xff,
7
      a[i] >>> 16 & 0xff, a[i] >>> 24 & 0xff
8
    );
9
  }
10
  return b ? a.join('').substring(0, c) : a.join('');
11
}

9. 自定义 Base64 字符表#

排查过程中最关键的发现：Srun 使用的不是标准 Base64 字符表。

前端代码明确设置：

1
base64.setAlpha('LVoJPiCN2R8G90yg+hmFHuacZ1OWMnrsSTXkYpUq/3dlbfKwv6xztjI7DeBE45QA');

标准字符表（不能用）：

1
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

Srun 自定义字符表（必须使用）：

1
LVoJPiCN2R8G90yg+hmFHuacZ1OWMnrsSTXkYpUq/3dlbfKwv6xztjI7DeBE45QA

该字符表长度必须恰好为 64，少一位就会出现：

1
panic: runtime error: index out of range

Go 实现：

1
func srunBase64(data []byte) string {
2
    alphabet := "LVoJPiCN2R8G90yg+hmFHuacZ1OWMnrsSTXkYpUq/3dlbfKwv6xztjI7DeBE45QA"
3
    pad := byte('=')
4

5
    var result strings.Builder
6
    for i := 0; i < len(data); i += 3 {
7
        b1 := data[i]
8
        var b2, b3 byte
9
        if i+1 < len(data) { b2 = data[i+1] }
10
        if i+2 < len(data) { b3 = data[i+2] }
11

12
        result.WriteByte(alphabet[b1>>2])
13
        result.WriteByte(alphabet[((b1&0x03)<<4)|(b2>>4)])
14
        if i+1 < len(data) {
15
            result.WriteByte(alphabet[((b2&0x0f)<<2)|(b3>>6)])
16
        } else {
17
            result.WriteByte(pad)
18
        }
19
        if i+2 < len(data) {
20
            result.WriteByte(alphabet[b3&0x3f])
21
        } else {
22
            result.WriteByte(pad)
23
        }
24
    }
25
    return result.String()
26
}

展开收起

10. chksum 生成（SHA1）#

前端拼接逻辑：

前端 JSONP 请求构造，包含 chksum 拼接方式

1
var str = token + username;
2
str += token + hmd5;
3
str += token + ac_id;
4
str += token + ip;
5
str += token + n;
6
str += token + type;
7
str += token + i;   // i 即 info
8

9
chksum = sha1(str);

Go 实现：

1
chkStr := token + username +
2
    token + hmd5 +
3
    token + acID +
4
    token + ip +
5
    token + n +
6
    token + typ +
7
    token + info
8

9
chksum := sha1Hex(chkStr)
10

11
func sha1Hex(s string) string {
12
    h := sha1.Sum([]byte(s))
13
    return hex.EncodeToString(h[:])
14
}

11. IP 一致性问题#

调试过程中曾出现 client_ip 和 online_ip 不一致的情况：

1
client_ip: 10.103.26.135
2
online_ip: 10.103.26.136   ← 不一致

这会导致 challenge 与 login 参数不匹配。修正后保持所有 IP 一致：

1
client_ip: 10.103.26.135
2
online_ip: 10.103.26.135
3
login ip:  10.103.26.135
4
info  ip:  10.103.26.135

错误变化路径：

1
challenge_expire_error  →  auth_info_error  →  认证成功

IP 问题解决后，剩余的 auth_info_error 最终定位到自定义 Base64 字符表使用错误。

12. 常见错误分析#

challenge_expire_error#

1
原因：challenge 过期，或 challenge 与 ip 不匹配
2
常见场景：
3
  1. get_challenge 和 login 使用了不同的 IP
4
  2. token 已过期（有效期 60 秒）
5
  3. 脚本中途自动切换了 ip 变量
6
解决：保持 get_challenge、info、login 三处 IP 完全一致

auth_info_error#

1
原因：info 参数生成错误
2
常见场景：
3
  1. info 中的 password 误用了 MD5 后的值（应为明文）
4
  2. JSON 字段顺序不固定（Go map 无序，应用 fmt.Sprintf 硬编码顺序）
5
  3. xEncode 翻译时运算符优先级与 JS 不同
6
  4. Base64 字符表使用了标准表而非 Srun 自定义表

ip_already_online_error#

1
含义：该 IP 已经在线（不是失败）
2
返回中同时有 error=ok、res=ok，可视为认证成功

13. 最终结果#

Go 脚本运行成功，返回 error=ok、res=ok

Go 脚本最终返回：

1
{
2
  "error": "ok",
3
  "res": "ok",
4
  "suc_msg": "ip_already_online_error",
5
  "username": "23131313@test_sl",
6
  "client_ip": "10.103.26.135",
7
  "online_ip": "10.103.26.135"
8
}

验证通过的各环节：

1
✓ get_challenge 正常
2
✓ HMAC-MD5 正常
3
✓ xEncode + 自定义 Base64 正常
4
✓ chksum 正常
5
✓ srun_portal 认证通过

14. 总结#

这次实现的核心不是简单模拟 HTTP 请求，而是完整还原前端 JavaScript 的加密逻辑。

关键要点：

参数	算法	注意事项
`password`	`{MD5}` + HMAC-MD5(password, token)	key 是 token，不是密码
`info`	`{SRBX1}` + srunBase64(xEncode(JSON, token))	JSON 中 password 是明文；字段顺序固定
`chksum`	SHA1(token 分隔的拼接串)	顺序固定，不能乱
IP	—	get_challenge、info、login 三处必须完全一致
Base64	自定义字符表	不能用标准 Base64

15. 完整实现代码#

Tip

选择 Go 实现的原因：编译为单一可执行文件，无需运行时依赖；相比 Python/Node.js 启动更快、内存占用更低；且支持交叉编译，同一份代码可直接编译为 Windows、macOS、Linux 各平台可执行文件，开箱即用。

将以下代码保存为 main.go，修改顶部常量中的 username、password、ip 后直接运行即可。

1
package main
2

3
import (
4
  "crypto/hmac"
5
  "crypto/md5"
6
  "crypto/sha1"
7
  "encoding/hex"
8
  "encoding/json"
9
  "fmt"
10
  "io"
11
  "net/http"
12
  "net/url"
13
  "strconv"
14
  "strings"
15
  "time"
16
)
17

18
const (
19
  baseURL  = "http://10.8.8.117"
20
  username = "23131313@test_sl"
21
  password = "12345"
22

23
  acID = "0"
24
  n    = "200"
25
  typ  = "1"
26
)
27

28
var ip = "10.103.26.135"
29

30
type ChallengeResp struct {
31
  Challenge string `json:"challenge"`
32
  ClientIP  string `json:"client_ip"`
33
  OnlineIP  string `json:"online_ip"`
34
  Error     string `json:"error"`
35
  Ecode     int    `json:"ecode"`
36
}
37

38
// HMAC-MD5：password 参数使用
39
func hmacMD5(pass, token string) string {
40
  h := hmac.New(md5.New, []byte(token))
41
  h.Write([]byte(pass))
42
  return hex.EncodeToString(h.Sum(nil))
43
}
44

45
// SHA1：chksum 参数使用
46
func sha1Hex(s string) string {
47
  h := sha1.Sum([]byte(s))
48
  return hex.EncodeToString(h[:])
49
}
50

51
// 获取 challenge / token
52
func getChallenge(useIP string) (ChallengeResp, error) {
53
  callback := fmt.Sprintf("jQuery%d", time.Now().UnixMilli())
54

55
  v := url.Values{}
56
  v.Set("callback", callback)
57
  v.Set("username", username)
58
  if useIP != "" {
59
    v.Set("ip", useIP)
60
  }
61
  v.Set("_", strconv.FormatInt(time.Now().UnixMilli(), 10))
62

63
  resp, err := http.Get(baseURL + "/cgi-bin/get_challenge?" + v.Encode())
64
  if err != nil {
65
    return ChallengeResp{}, err
66
  }
67
  defer resp.Body.Close()
68

69
  body, _ := io.ReadAll(resp.Body)
70
  text := strings.TrimSpace(string(body))
71

72
  start := strings.Index(text, "(")
73
  end := strings.LastIndex(text, ")")
74
  if start < 0 || end <= start {
75
    return ChallengeResp{}, fmt.Errorf("解析 JSONP 失败: %s", text)
76
  }
77

78
  var cr ChallengeResp
79
  if err := json.Unmarshal([]byte(text[start+1:end]), &cr); err != nil {
80
    return ChallengeResp{}, err
81
  }
82
  if cr.Challenge == "" {
83
    return ChallengeResp{}, fmt.Errorf("未获取到 challenge: %s", text)
84
  }
85
  return cr, nil
86
}
87

88
// 构造 info 参数：{SRBX1} + srunBase64(xEncode(JSON, token))
89
func srunInfo(token string) string {
90
  info := fmt.Sprintf(
91
    `{"username":"%s","password":"%s","ip":"%s","acid":"%s","enc_ver":"srun_bx1"}`,
92
    username, password, ip, acID,
93
  )
94
  return "{SRBX1}" + srunBase64(xEncode(info, token))
95
}
96

97
// Srun 自定义 Base64（字符表与标准不同）
98
func srunBase64(data []byte) string {
99
  alphabet := "LVoJPiCN2R8G90yg+hmFHuacZ1OWMnrsSTXkYpUq/3dlbfKwv6xztjI7DeBE45QA"
100
  pad := byte('=')
101

102
  var result strings.Builder
103
  for i := 0; i < len(data); i += 3 {
104
    b1 := data[i]
105
    var b2, b3 byte
106
    if i+1 < len(data) {
107
      b2 = data[i+1]
108
    }
109
    if i+2 < len(data) {
110
      b3 = data[i+2]
111
    }
112
    result.WriteByte(alphabet[b1>>2])
113
    result.WriteByte(alphabet[((b1&0x03)<<4)|(b2>>4)])
114
    if i+1 < len(data) {
115
      result.WriteByte(alphabet[((b2&0x0f)<<2)|(b3>>6)])
116
    } else {
117
      result.WriteByte(pad)
118
    }
119
    if i+2 < len(data) {
120
      result.WriteByte(alphabet[b3&0x3f])
121
    } else {
122
      result.WriteByte(pad)
123
    }
124
  }
125
  return result.String()
126
}
127

128
// XXTEA 加密（xEncode）
129
func xEncode(str, key string) []byte {
130
  if str == "" {
131
    return []byte{}
132
  }
133

134
  v := strToLong(str, true)
135
  k := strToLong(key, false)
136
  for len(k) < 4 {
137
    k = append(k, 0)
138
  }
139

140
  nn := len(v) - 1
141
  z := v[nn]
142
  y := v[0]
143
  c := uint32(0x86014019 | 0x183639A0)
144
  mask := uint32(0x8CE0D9BF | 0x731F2640)
145
  q := uint32(6 + 52/(nn+1))
146
  d := uint32(0)
147

148
  for q > 0 {
149
    q--
150
    d = (d + c) & mask
151
    e := (d >> 2) & 3
152
    var p int
153
    for p = 0; p < nn; p++ {
154
      y = v[p+1]
155
      m := (z>>5 ^ y<<2) + ((y>>3 ^ z<<4) ^ (d ^ y)) + (k[(p&3)^int(e)] ^ z)
156
      v[p] = (v[p] + m) & mask
157
      z = v[p]
158
    }
159
    y = v[0]
160
    m := (z>>5 ^ y<<2) + ((y>>3 ^ z<<4) ^ (d ^ y)) + (k[(p&3)^int(e)] ^ z)
161
    v[nn] = (v[nn] + m) & mask
162
    z = v[nn]
163
  }
164
  return longToStr(v, false)
165
}
166

167
func strToLong(s string, includeLength bool) []uint32 {
168
  b := []byte(s)
169
  v := make([]uint32, (len(b)+3)/4)
170
  for i, c := range b {
171
    v[i>>2] |= uint32(c) << uint((i&3)*8)
172
  }
173
  if includeLength {
174
    v = append(v, uint32(len(b)))
175
  }
176
  return v
177
}
178

179
func longToStr(v []uint32, includeLength bool) []byte {
180
  length := len(v) * 4
181
  if includeLength {
182
    length = int(v[len(v)-1])
183
    v = v[:len(v)-1]
184
  }
185
  b := make([]byte, len(v)*4)
186
  for i, val := range v {
187
    b[i*4] = byte(val)
188
    b[i*4+1] = byte(val >> 8)
189
    b[i*4+2] = byte(val >> 16)
190
    b[i*4+3] = byte(val >> 24)
191
  }
192
  if length > len(b) {
193
    length = len(b)
194
  }
195
  return b[:length]
196
}
197

198
func login() error {
199
  useIP := ip
200

201
  // 未手动填写 IP 时，先自动获取 client_ip
202
  if useIP == "" {
203
    cr, err := getChallenge("")
204
    if err != nil {
205
      return err
206
    }
207
    if cr.ClientIP == "" {
208
      return fmt.Errorf("自动获取 IP 失败")
209
    }
210
    useIP = cr.ClientIP
211
    fmt.Println("自动获取 IP:", useIP)
212
  }
213

214
  cr, err := getChallenge(useIP)
215
  if err != nil {
216
    return err
217
  }
218

219
  token := cr.Challenge
220
  ip = useIP
221

222
  hmd5 := hmacMD5(password, token)
223
  info := srunInfo(token)
224

225
  chkStr := token + username +
226
    token + hmd5 +
227
    token + acID +
228
    token + ip +
229
    token + n +
230
    token + typ +
231
    token + info
232
  chksum := sha1Hex(chkStr)
233

234
  v := url.Values{}
235
  v.Set("callback", fmt.Sprintf("jQuery%d", time.Now().UnixMilli()))
236
  v.Set("action", "login")
237
  v.Set("username", username)
238
  v.Set("password", "{MD5}"+hmd5)
239
  v.Set("os", "Mac OS")
240
  v.Set("name", "Macintosh")
241
  v.Set("double_stack", "0")
242
  v.Set("chksum", chksum)
243
  v.Set("info", info)
244
  v.Set("ac_id", acID)
245
  v.Set("ip", ip)
246
  v.Set("n", n)
247
  v.Set("type", typ)
248
  v.Set("_", strconv.FormatInt(time.Now().UnixMilli(), 10))
249

250
  resp, err := http.Get(baseURL + "/cgi-bin/srun_portal?" + v.Encode())
251
  if err != nil {
252
    return err
253
  }
254
  defer resp.Body.Close()
255

256
  body, _ := io.ReadAll(resp.Body)
257
  fmt.Println(strings.TrimSpace(string(body)))
258
  return nil
259
}
260

261
func main() {
262
  if err := login(); err != nil {
263
    fmt.Println("登录失败:", err)
264
  }
265
}

展开收起

运行方式：

Terminal window

1
go run main.go

成功时会输出包含 "error":"ok" 的 JSON 响应。

绵阳城市学院教务处密码加密算法分析

Sun, 10 May 2026 00:00:00 GMT

绵阳城市学院教务处密码加密算法分析#

1. 逆向定位与前端代码分析#

通过抓包与调试，我们定位到了前端 Webpack 打包生成的处理登录逻辑的核心代码。整体逆向路径如下：

flowchart TD A[打开浏览器 DevTools] --> B[Network 面板监听请求] B --> C{发现 POST /mcauth/v1/tickets} C --> D[定位到 Initiator：scriptcat-inject.js] D --> E[Sources 面板搜索加密函数] E --> F[找到 Webpack 模块 #18] F --> G[提取 public_exponent / modulus / private_exponent]

在 Webpack 打包产物的第 18 号模块中，直接暴露了所有加密所需参数。可以看到该系统采用了基于原生 BigInt 手动实现的无填充 RSA 加密算法（Textbook RSA）：

模块18——核心加密参数硬编码

1
// 逆向出的前端核心配置字典（模块 18）
2
var n = {
3
    LOGIN: "/auth/login",
4
    CAS: "/mcauth",
5
    TAG: "lyasp", // 用于混淆生成请求头 Token
6
    public_exponent: "010001", // 公钥指数 65537
7
    private_exponent: "413798867d69babed22e0dd3d4031c635f3e9dbca0fa50a32974a0e230787b7f...",
8
    modulus: "00b5eeb166e069920e80bebd1fea4829d3d1f3216f2aabe79b6c47a3c18dcee5..."
9
}

严重的安全漏洞预警

前端开发人员将 private_exponent（RSA 私钥） 直接硬编码在了公开的 JS 文件中！这意味着任何拿到这段 JS 的人都可以解密被截获的密文。此外，无填充的 Textbook RSA 存在严重的模式识别漏洞——相同密码产生的密文永远一致，极易遭受重放攻击。

2. 登录请求构造与抓包分析#

点击登录后，前端脚本会向 /mcauth/v1/tickets 端点发起 POST 请求。登录整体流程如下：

flowchart TD A([用户点击登录]) --> B[去除用户名/密码中的空格] B --> C{是否为明文登录模式?} C -- 否 --> D[调用 encryptPassword 加密密码] C -- 是 --> E[直接使用明文密码] D --> F[构造 Payload] E --> F F --> G["生成 loginUserToken encrypt:'lyasp' + 时间戳"] G --> H["POST /mcauth/v1/tickets 携带 loginToken & loginUserToken 请求头"] H --> I{服务端返回状态码} I -- 201/200 + code字段 --> J{解析响应 code} I -- 其他 --> K[登录成功，跳转 service] J -- NOUSER --> L[提示：用户名或密码错误] J -- CODEFALSE --> M[提示：验证码错误] J -- USERLOCK --> N[提示：账号已锁定] J -- ISMODIFYPASS --> O[跳转：强制修改密码] J -- TWOVERIFY --> P[跳转：二次验证页] J -- NOAUTHORIZATION --> Q[跳转：未授权页面]

登录请求抓包——DevTools Network 面板

以下是逆向还原的完整登录核心函数，涵盖加密、Payload 构造、OAuth2 分支及所有服务端响应处理逻辑：

1
x = function e(t, n, o, l, p, m, g, h, f, _) {
2
    // t=username, n=password, o=service, l=loginType(明文标志)
3
    // p=router, m=rememberMe, g=change, h=验证码id, f=验证码code, _=callback
4
    return function(w) {
5
        var y = a(5); // qs 库，用于序列化表单
6
        t = t.replace(/\s+/g, "");
7
        n = n.replace(/\s+/g, "");
8

9
        // 若非明文模式，则对密码进行 RSA 加密
10
        var b = "";
11
        if (!l) {
12
            a.i(u.a)(131);
13
            var v = a.i(u.b)(r.a.public_exponent, "", r.a.modulus);
14
            b = a.i(u.c)(v, n)
15
        }
16

17
        // 构造基础 Payload
18
        var E = !1, x = {}, k = {
19
            username: t,
20
            password: l ? n : b, // 明文 or 密文
21
            service: o,
22
            loginType: l,
23
            id: h,
24
            code: f
25
        };
26

27
        // OAuth2 分支：检测路径或 localStorage 标志
28
        if (window.location.pathname.indexOf("oauth2login") > -1 || localStorage.getItem("isOAuth2")) {
29
            E = !0;
30
            var S = a.i(c.a)("response_type") || localStorage.getItem("response_type"),
31
                O = a.i(c.a)("client_id")    || localStorage.getItem("client_id"),
32
                A = a.i(c.a)("redirect_uri") || localStorage.getItem("redirect_uri"),
33
                D = a.i(c.a)("scope")        || localStorage.getItem("scope"),
34
                Q = a.i(c.a)("state")        || localStorage.getItem("state");
35
            // 持久化 OAuth2 参数
36
            localStorage.setItem("response_type", S);
37
            localStorage.setItem("client_id", O);
38
            localStorage.setItem("redirect_uri", A);
39
            localStorage.setItem("scope", D);
40
            localStorage.setItem("state", Q);
41
            k.service = A;
42
            x = { response_type: S, client_id: O, redirect_uri: A, scope: D, state: Q };
43
            k = Object.assign(k, x)
44
        }
45

46
        // 发起 POST 请求：普通登录 or OAuth2 授权码
47
        s.a.post("/mcauth" + (E ? "/oauth2/code" : "/v1/tickets"), y.stringify(k))
48
            .then(function(r) {
49
                if (201 == r.status || 200 == r.status) {
50
                    if ("object" == d(r.data.data) && r.data.data.code) {
51
                        var s = r.data.data;
52
                        if (s.code) {
53
                            var u = s.code, f = s.uid, y = {
54
                                type: l,
55
                                service: E ? k.service : o,
56
                                userName: t, passWord: n,
57
                                rememberMe: m, change: g, vcodes: f
58
                            };
59

60
                            if ("CODEFALSE" == u) {
61
                                // 验证码错误
62
                                var v = window.locale.zh_CN.code_false || "验证码错误";
63
                                i.a.error({ title: "登录失败", content: v });
64
                                w(T("block", "none", "none"));
65
                                a.i(c.c)("CODEFALSE", h)
66

67
                            } else if ("NOREGISTER" == u) {
68
                                // 账号未注册
69
                                sessionStorage.setItem("unAuthorizeInfo", JSON.stringify({ unAuthorizeUrl: o, unAuthorizeType: "1" }));
70
                                p.push("/loginUnAuthorize")
71

72
                            } else if ("NOAUTHORIZATION" == u) {
73
                                // 无权限访问该服务
74
                                sessionStorage.setItem("unAuthorizeInfo", JSON.stringify({ unAuthorizeUrl: o, unAuthorizeType: "2", unAuthorizeName: s.data }));
75
                                p.push("/loginUnAuthorize")
76

77
                            } else if ("NETWORKCOMMITMENT" == u) {
78
                                // 需要签署网络承诺书
79
                                y.code = u; w(C(y)); p.push("/loginNetcommit")
80

81
                            } else if ("ISMODIFYPASS" == u) {
82
                                // 首次登录，强制修改密码
83
                                y.code = u; w(C(y)); p.push("/loginFirst")
84

85
                            } else if ("ISPHONEOREMAILORANSWER" == u) {
86
                                // 需要绑定手机/邮箱/密保问题
87
                                var O = s.data;
88
                                if (O.indexOf("userName") >= 0) {
89
                                    var A = O.split(","), D = A[A.length - 1].split("=")[1];
90
                                    y.name = D
91
                                }
92
                                O.indexOf("answer") >= 0 ? (y.checkType = "1")
93
                                    : O.indexOf("phone") >= 0 ? (y.checkType = "2")
94
                                    : O.indexOf("email") >= 0 && (y.checkType = "3");
95
                                w(C(y)); p.push({ pathname: "/loginCheck" })
96

97
                            } else if ("ISBINDWX" == u) {
98
                                // 需要绑定微信
99
                                y.code = u; w(C(y)); p.push("/loginBindWx")
100

101
                            } else if ("PEOPLEMOREACCOUNT" == u) {
102
                                // 一人多账号：若只有一个账号则自动选择重新登录
103
                                var N = s.data;
104
                                y.content = JSON.parse(N);
105
                                if (1 == y.content.users.length) {
106
                                    var L = y.content.users[0];
107
                                    return w(e(L.userId, L.passWord, o, 15, p, m, g))
108
                                }
109
                                w(C(y)); p.push("/userSelect")
110

111
                            } else if ("NOUSER" == u) {
112
                                // 用户名或密码错误
113
                                var I = window.locale.zh_CN.nouser || "用户名或密码错误。";
114
                                i.a.error({ title: "登录失败", content: I });
115
                                w(T("block", "none", "none"))
116

117
                            } else if ("USERNOTONLY" == u) {
118
                                // 用户名不唯一
119
                                i.a.error({ title: "登录失败", content: s.tips });
120
                                w(T("block", "none", "none"))
121

122
                            } else if ("USERDISABLED" == u) {
123
                                // 账号已停用
124
                                var M = window.locale.zh_CN.user_disabled || "账号被停用，请联系相关管理员处理。";
125
                                i.a.error({ title: "登录失败", content: M });
126
                                w(T("block", "none", "none"))
127

128
                            } else if ("USERLOCK" == u) {
129
                                // 账号被锁定，显示锁定到期时间
130
                                var P = s.data;
131
                                P.length > 0 && (P = P.substring(11, P.length));
132
                                i.a.error({ title: "账号锁定", content: "账号锁定至:" + P + "，请稍后重新登录或联系管理员处理。" });
133
                                w(T("block", "none", "none"))
134

135
                            } else if ("TWOVERIFY" == u) {
136
                                // 需要二次验证（MFA）
137
                                y.code = u; y.content = JSON.parse(s.data);
138
                                w(C(y));
139
                                E && localStorage.setItem("isOAuth2", !0);
140
                                p.push("/loginAgain")
141

142
                            } else {
143
                                // 密码连续错误 / 其他未知错误
144
                                var q = "请检查账号或密码是否正确";
145
                                if (s.data.indexOf(",") > 0) {
146
                                    var U = s.data.split(",")[0], R = s.data.split(",")[1];
147
                                    sessionStorage.setItem("errorNum", R);
148
                                    q = U == R
149
                                        ? "密码已连续错误【" + R + "】次，账号锁定。"
150
                                        : "密码已连续错误【" + R + "】次，连续错误【" + U + "】次账号将被锁定。"
151
                                } else if (!isNaN(Number(s.data))) {
152
                                    sessionStorage.setItem("errorNum", s.data)
153
                                }
154
                                i.a.error({ title: "登录失败", content: q });
155
                                w(T("block", "none", "none"))
156
                            }
157

158
                            _ && _() // 执行回调
159
                        }
160
                    }
161
                }
162
            })
163
    }
164
}

展开收起

Payload 字段说明：

字段	来源	说明
`username`	用户输入	去除空格后的明文账号
`password`	加密处理	RSA 加密后的密文（十六进制），长度固定 256 字符/块
`service`	URL 参数	登录成功后的跳转地址，如 `http://jwgl.mycc.edu.cn/caslogin`
`loginType`	登录模式	普通账号密码登录时为空或 `0`
`id`	验证码组件	图形验证码对应的 UID
`code`	用户输入	验证码识别结果

以下是浏览器 DevTools Network → Payload 面板捕获到的真实请求数据，可以看到 password 字段已是 RSA 加密后的十六进制密文：

真实登录请求 Payload 抓包

隐藏的请求头校验：

该接口会校验两个特殊 Header：

loginToken：固定字符串或会话相关 Token
loginUserToken：使用同一套 RSA 逻辑加密，明文规则为 TAG + 当前毫秒时间戳

1
loginUserToken = encryptPassword("lyasp" + Date.now())
2
// 例如：encryptPassword("lyasp1715423891000")

3. RSA 加密算法详细流程#

3.1 密钥对象初始化（`u.b` 内部）#

调用 u.b(public_exponent, "", modulus) 时，实际进入的是一套自定义大数实现的初始化逻辑，而非浏览器原生 BigInt。其核心初始化函数如下：

1
function n(e) {
2
    q = e;                    // q = 密钥位数（决定 digits 数组长度）
3
    U = new Array(q);         // U = 工作用数字数组，长度为 q
4
    for (var t = 0; t < U.length; t++)
5
        U[t] = 0;             // 初始化全为 0
6
    R = new o;                // R = 暂存寄存器（自定义大数对象）
7
    B = new o;                // B = 累乘基数（自定义大数对象）
8
    B.digits[0] = 1           // B 初始化为 1，用于幂模运算的初始累乘值
9
}

变量	类型	作用
`q`	`number`	密钥分组位数，控制 digits 数组长度
`U`	`number[]`	工作数组，存放中间运算结果
`R`	自定义大数对象 `o`	暂存寄存器，用于模乘过程
`B`	自定义大数对象 `o`	累乘基数，初始为 `1`，即 B=P0=1B = P^0 = 1B=P0=1

底层实现说明

该系统并未使用浏览器原生的 BigInt，而是用 o 类自行实现了一套基于数组的大数运算（digits[] 存放每位数值）。B.digits[0] = 1 对应的是快速幂初始状态 result=1result = 1result=1，之后通过反复调用模乘将 PEmod NP^E \mod NPEmodN 的结果累积到 B 中。

3.2 加密执行流程#

flowchart TD A([输入明文字符串]) --> B["预处理：去除所有空白字符 text.replace(/\s+/g, '')"] B --> C[逐字符转为 ASCII 编码数组] C --> D{"数组长度是否为 126 的整数倍?"} D -- 否 --> E["末尾补 0，直到对齐 chunkSize = 126 字节"] D -- 是 --> F E --> F[按 126 字节分块] F --> G["逆序遍历每块 左移 8 位并按位或当前字节 拼合为一个超大 BigInt P"] G --> H["执行大数幂模运算 C = P^E mod N E=65537, N=modulus"] H --> I["转为 16 进制字符串 .padStart(256, '0') 补齐至 256 位"] I --> J{还有下一块?} J -- 是 --> G J -- 否 --> K([拼接所有块结果，输出密文])

加密执行的具体步骤：

预处理：过滤掉输入字符串的所有空白字符。
字符转码：将字符串转换为 ASCII 编码数组。
零填充 (Zero Padding)：分块大小为 126 字节，不足时在末尾补 0 对齐。
分块与大数合并：按每 126 字节逆向遍历，每次左移 8 位并加上当前字节值，拼合为一个大 BigInt。
大数幂模运算：对大数执行 C=PE(modN)C = P^E \pmod NC=PE(modN)（即 Textbook RSA 加密）。
格式化输出：转为十六进制字符串，.padStart(256, '0') 确保每块输出严格 256 字符，最后拼接所有块。

4. 核心还原代码 (JavaScript)#

可以直接复用以下代码来模拟加密行为：

1
// 快速幂取模运算
2
const modPow = (base, exponent, modulus) => {
3
    let result = 1n;
4
    base = base % modulus;
5
    while (exponent > 0n) {
6
        if (exponent & 1n) result = (result * base) % modulus;
7
        base = (base * base) % modulus;
8
        exponent >>= 1n;
9
    }
10
    return result;
11
};
12

13
// RSA 密码加密函数（还原自前端 Webpack 模块）
14
const encryptPassword = (text) => {
15
    const modulusHex = "00b5eeb166e069920e80bebd1fea4829d3d1f3216f2aabe79b6c47a3c18dcee5fd22c2e7ac519cab59198ece036dcf289ea8201e2a0b9ded307f8fb704136eaeb670286f5ad44e691005ba9ea5af04ada5367cd724b5a26fdb5120cc95b6431604bd219c6b7d83a6f8f24b43918ea988a76f93c333aa5a20991493d4eb1117e7b1";
16
    const exponentHex = "010001";
17
    const N = BigInt(`0x${modulusHex}`);
18
    const E = BigInt(`0x${exponentHex}`);
19
    const chunkSize = 126;
20

21
    const charCodes = Array.from(text).map(char => char.charCodeAt(0));
22
    while (charCodes.length % chunkSize !== 0) charCodes.push(0);
23

24
    const result = [];
25
    for (let i = 0; i < charCodes.length; i += chunkSize) {
26
        const chunk = charCodes.slice(i, i + chunkSize);
27
        let P = 0n;
28
        for (let j = chunk.length - 1; j >= 0; j--) P = (P << 8n) | BigInt(chunk[j]);
29
        result.push(modPow(P, E, N).toString(16).padStart(256, '0'));
30
    }
31
    return result.join('');
32
};

展开收起

5. 实战验证#

以下是基于上述逆向分析实现的自动化登录工具的完整调试输出，完整演示了从 OCR 识别验证码、RSA 加密、换取 CAS Ticket、获取 Cookie，到最终拉取课表数据的全流程：

自动化登录与课表获取调试输出

关键阶段说明：

阶段	输出字段	说明
验证码识别	`解析为数字是: 5 * 7 = 12`	OCR 自动识别图形验证码
密码加密	`plainLength: 10` → `encryptedLength: 256`	10 字符密码经 RSA 加密后为 256 字符十六进制串，`chunkCount: 1`
Token 加密	`label: loginUserToken` `plainLength: 18`	`"lyasp" + 13位时间戳` = 18 字符，同样加密为 256 字符
换票	`Ticket: ST-xxxxx`	服务端返回 CAS Service Ticket
会话	`JSESSIONID: xxxxx`	携带 Ticket 访问教务系统后获取会话 Cookie
课表数据	`courseName / teacher / rawTime ...`	成功解析第 2 周完整课表 JSON

算法还原正确性验证#

对比调试输出中的 encryptedText 与浏览器 Network 面板抓到的 password 字段：

调试输出（encryptedText）：

自动化工具加密调试输出

浏览器真实请求 Payload（password）：

浏览器真实请求 Payload

两者的十六进制字符串完全一致，这证明：

还原出的 encryptPassword() 函数与前端原始加密逻辑行为相同。
相同的明文密码在相同时刻必然产生相同的密文（Textbook RSA 无随机盐），这也从侧面再次印证了该算法的确定性缺陷。

P1089 [NOIP 2004 提高组] 津津的储蓄计划 (洛谷)

Sun, 10 May 2026 00:00:00 GMT

题目描述#

津津的零花钱一直都是自己管理。每个月的月初妈妈给津津 300300300 元钱，津津会预算这个月的花销，并且总能做到实际花销和预算的相同。

为了让津津学习如何储蓄，妈妈提出，津津可以随时把整百的钱存在她那里，到了年末她会加上 20%20\%20% 还给津津。因此津津制定了一个储蓄计划：每个月的月初，在得到妈妈给的零花钱后，如果她预计到这个月的月末手中还会有多于 100100100 元或恰好 100100100 元，她就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。

例如 111111月初津津手中还有 838383 元，妈妈给了津津 300300300 元。津津预计111111月的花销是 180180180 元，那么她就会在妈妈那里存 200200200 元，自己留下 183183183 元。到了 111111 月月末，津津手中会剩下 333 元钱。

津津发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，津津手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，津津将不得不在这个月省吃俭用，压缩预算。

现在请你根据 200420042004 年 111 月到 121212 月每个月津津的预算，判断会不会出现这种情况。如果不会，计算到 200420042004 年年末，妈妈将津津平常存的钱加上 20%20\%20% 还给津津之后，津津手中会有多少钱。

输入格式#

121212 行数据，每行包含一个小于 350350350 的非负整数，分别表示 111 月到 121212 月津津的预算。

输出格式#

一个整数。如果储蓄计划实施过程中出现某个月钱不够用的情况，输出 −X-X−X，XXX 表示出现这种情况的第一个月；否则输出到 200420042004 年年末津津手中会有多少钱。

注意，洛谷不需要进行文件输入输出，而是标准输入输出。

输入输出样例 #1#

输入 #1#

输出 #1#

1
-7

输入输出样例 #2#

输入 #2#

输出 #2#

1
1580

题解与分析#

解题突破口

这是一道纯粹的模拟题。我们只需要设定两个变量：一个记录津津手里当前的余钱 current_money，另一个记录存在妈妈那里的钱 saved_money。然后按照 1∼121 \sim 121∼12 个月的顺序依次进行模拟计算即可。

具体按月模拟的流程如下：

每个月月初，津津手里的钱增加 300 元。
减去当月的预算 budget：
- 如果此时手里的钱不够花（即 current_money < budget），说明计划失败，直接输出负的当前月份 -i 并结束程序。
- 如果手里的钱够花，先扣除预算 current_money -= budget。
结算剩余的钱，把“整百”的部分存给妈妈：
- 可以利用整数除法的特性 (current_money / 100) * 100 来计算出能存多少钱。
- 把这部分钱累加到 saved_money 中，并从 current_money 扣除。
如果 12 个月都顺利度过，最后输出 current_money + saved_money * 1.2 即可。

代码实现#

C++ 版本#

1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    int current_money = 0; // 手里留存的钱
6
    int saved_money = 0;   // 存在妈妈那里的钱
7
    int budget;
8

9
    for (int i = 1; i <= 12; i++) {
10
        cin >> budget;
11
        current_money += 300; // 妈妈月初给的 300 元
12

13
        if (current_money < budget) {
14
            cout << -i << endl; // 出现不够用的情况，输出月份的负数并退出
15
            return 0;
16
        }
17

18
        // 扣除预算
19
        current_money -= budget;
20

21
        // 计算能存多少整百的钱
22
        int save = (current_money / 100) * 100;
23
        saved_money += save;
24
        current_money -= save;
25
    }
26

27
    // 年末返还 120%，加上手里剩下的钱
28
    cout << current_money + saved_money * 1.2 << endl;
29

30
    return 0;
31
}

展开收起

Python 版本#

1
current_money = 0
2
saved_money = 0
3
failed = False
4

5
for i in range(1, 13):
6
    budget = int(input())
7
    current_money += 300
8

9
    if current_money < budget:
10
        print(-i)
11
        failed = True
12
        break
13

14
    current_money -= budget
15
    save = (current_money // 100) * 100
16
    saved_money += save
17
    current_money -= save
18

19
if not failed:
20
    # 按照题目要求输出整数结果
21
    print(int(current_money + saved_money * 1.2))

展开收起

P1307 [NOIP 2011 普及组] 数字反转 (洛谷)

Sun, 10 May 2026 00:00:00 GMT

题目描述#

给定一个整数 NNN，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例 2）。

输入格式#

一个整数 NNN。

输出格式#

一个整数，表示反转后的新数。

输入输出样例 #1#

输入 #1#

1
123

输出 #1#

1
321

输入输出样例 #2#

输入 #2#

1
-380

输出 #2#

1
-83

说明/提示#

【数据范围】

−1,000,000,000≤N≤1,000,000,000-1,000,000,000\leq N\leq 1,000,000,000 −1,000,000,000≤N≤1,000,000,000。

noip2011 普及组第一题

题解与分析#

解题突破口

反转数字最核心的处理在于去除前导（反转后的）零以及保留负号。

**数学计算法：**在 C++ 中，直接利用整数的 / 10 和 % 10 操作可以非常优雅地从低位向高位提取数字。当我们在新变量 res 中通过 res = res * 10 + n % 10 进行反转累加时，原数末尾的 0 会被计算为 res * 10 + 0，由于初始 res 为 0，前置的 0 也就自然消失了。此外，C++ 的 % 对负数运算会保留负号（例如 -123 % 10 = -3），因此负数问题也迎刃而解！

复杂度分析

时间复杂度： O(log⁡10N)\mathcal{O}(\log_{10} N)O(log10N)，循环次数仅与数字的位数相关，最大 10 位数只需循环 10 次。
空间复杂度： O(1)\mathcal{O}(1)O(1)，仅需常数级的额外变量存储反转后的数值。

代码实现#

C++ 版本 (数学位运算法)#

1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    int n;
6
    cin >> n;
7

8
    int res = 0;
9
    while (n != 0) {
10
        res = res * 10 + n % 10; // 提取最后一位并累加到反转结果中
11
        n /= 10;                 // 削去最后一位
12
    }
13

14
    cout << res << endl;
15
    return 0;
16
}

展开收起

Python 版本 (字符串切片法)#

对于 Python，更“Pythonic”的做法是直接将数字视作字符串处理。利用切片反转字符串后，使用内置的 int() 转换，系统会自动帮你吃掉多余的前导零，省去了大量的繁琐判断。

1
n_str = input().strip()
2

3
if n_str == '0':
4
    print(0)
5
elif n_str[0] == '-':
6
    # 如果是负数，提取除负号外的所有字符，反转后转成 int 消除前置0，再补充负号
7
    print('-' + str(int(n_str[1:][::-1])))
8
else:
9
    # 正数直接反转，转为 int 消除前置0后输出
10
    print(int(n_str[::-1]))

P1428 小鱼比可爱 (洛谷)

Sun, 10 May 2026 00:00:00 GMT

题目描述#

人比人，气死人；鱼比鱼，难死鱼。小鱼最近参加了一个“比可爱”比赛，比的是每只鱼的可爱程度。参赛的鱼被从左到右排成一排，头都朝向左边，然后每只鱼会得到一个整数数值，表示这只鱼的可爱程度，很显然整数越大，表示这只鱼越可爱，而且任意两只鱼的可爱程度可能一样。由于所有的鱼头都朝向左边，所以每只鱼只能看见在它左边的鱼的可爱程度，它们心里都在计算，在自己的眼力范围内有多少只鱼不如自己可爱呢。请你帮这些可爱但是鱼脑不够用的小鱼们计算一下。

输入格式#

第一行输入一个正整数 nnn，表示鱼的数目。

第二行内输入 nnn 个非负整数，用空格间隔，依次表示从左到右每只小鱼的可爱程度 aia_iai。

输出格式#

一行，输出 nnn 个整数，用空格间隔，依次表示每只小鱼眼中有多少只鱼不如自己可爱。

输入输出样例 #1#

输入 #1#

1
6
2
4 3 0 5 1 2

输出 #1#

1
0 0 0 3 1 2

说明/提示#

对于 100%100\%100% 的数据，1≤n≤1001 \leq n\leq 1001≤n≤100，0≤ai≤100 \leq a_i \leq 100≤ai≤10。

题解与分析#

解题突破口

观察到数据范围 n≤100n \leq 100n≤100 非常小。对于这种较小的数据量，我们可以直接使用时间复杂度为 O(n2)\mathcal{O}(n^2)O(n2) 的**双重循环（暴力枚举）**来解决。

具体思路如下：

首先，我们将所有小鱼的可爱程度存储在一个数组（或列表）中。
外层循环遍历每一只小鱼，假设当前小鱼的索引为 i。
对于每一只小鱼 i，我们需要统计在它左边（即索引从 0 到 i-1）有多少只小鱼的可爱程度严格小于它（a[j] < a[i]）。
内层循环遍历 0 到 i-1，用一个计数器 count 记录符合条件的小鱼数量。
将得到的 count 依次输出即可。

代码实现#

C++ 版本#

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
int main() {
6
    int n;
7
    cin >> n;
8

9
    vector<int> a(n);
10
    for (int i = 0; i < n; i++) cin >> a[i]; // 读取所有小鱼的可爱程度
11

12
    for (int i = 0; i < n; i++) {
13
        int count = 0;
14
        for (int j = 0; j < i; j++) { // 遍历左边的小鱼
15
            if (a[j] < a[i]) count++;
16
        }
17
        cout << count << (i == n - 1 ? "" : " ");
18
    }
19
    return 0;
20
}

展开收起

Python 版本#

1
n = int(input())
2
a = list(map(int, input().split()))
3

4
# 列表推导式配合 sum 统计左边比自己小的值的数量
5
result = [str(sum(1 for j in range(i) if a[j] < a[i])) for i in range(n)]
6

7
print(" ".join(result))

日常组网记录

Sat, 09 May 2026 00:00:00 GMT

本文已加密保护，请访问网站查看。

MacShot：免费开源的 macOS 截图与录屏工具

Fri, 09 May 2025 00:00:00 GMT

MacShot：免费开源的 macOS 截图与录屏工具#

如果你一直在找 CleanShot X 或 Shottr 的免费替代品，MacShot 值得试试。

它不是 Electron 套壳，而是纯 Swift + AppKit 写的原生 macOS 应用。截图、标注、录屏、长截图、OCR、截图美化、图床上传这些日常高频功能，它基本都塞进了一个轻量工具里。

MacShot 界面预览

它适合谁#

MacShot 更适合这几类人：

经常写教程、文档、博客，需要快速截图标注
需要录制短视频或 GIF，给别人演示操作步骤
不想为截图工具长期订阅付费
希望截图、OCR、上传图床在一个工具里完成
更偏好原生、轻量、开源的 macOS 应用

如果你只是偶尔按一下 Command + Shift + 4，系统自带截图已经够用。但如果你每天都要截图、打码、加箭头、录屏、发链接，MacShot 的体验会顺手很多。

核心亮点#

1. 原生轻量，不是 Electron#

MacShot 官方介绍里强调了两点：纯 Swift + AppKit，非 Electron；空闲时内存占用大约 8 MB。对于一个常驻菜单栏的工具来说，这个方向很讨喜。

它支持 Apple Silicon 和 Intel Mac，要求 macOS 12.3 或更高版本。

2. 标注工具很全#

截图后可以直接进入编辑，常用标注基本都覆盖了：

箭头、矩形、圆形、文字
铅笔、高亮、编号标记
像素化、模糊、擦除
印章、Emoji、测量工具、放大镜
取色器、撤销/重做、旋转和缩放

这部分很像 CleanShot X 和 Shottr 的日常工作流：截完图，不用再打开第二个编辑器，直接在截图上把重点圈出来。

3. 录屏支持 MP4 和 GIF#

MacShot 不只是截图工具，也能录屏。官方说明里提到它支持录制区域为 MP4，最高 120fps，也可以导出 GIF。

录屏时还能选择系统声音、麦克风和鼠标高亮，录完后可以用内置剪辑工具简单裁掉多余片段。做软件演示、Bug 复现、教程动图都比较方便。

4. 长截图、OCR 和翻译#

长截图也是 MacShot 的重点功能之一。选择区域后滚动页面，它会把内容拼接成一张长图，适合保存网页、聊天记录、后台页面和文档片段。

OCR 则基于 Apple Vision，可以从截图里提取文字。官方还提到支持自动识别语言、复制文本、翻译到 30 多种语言，或者直接搜索。

5. 一键美化截图#

做分享图时，MacShot 可以给截图加渐变背景、macOS 窗口外框、阴影、圆角和内边距。这个功能对发博客、发朋友圈、写产品更新尤其有用。

它内置了 30 个渐变背景，不需要再把截图丢进其他美化工具里二次处理。

6. 支持自建图床#

MacShot 支持一键上传到 Google Drive、imgbb，也支持 S3 兼容存储。也就是说，Cloudflare R2、AWS S3、MinIO 这类服务都可以接入。

对喜欢自建图床的人来说，这点很关键：截图后上传，链接自动复制到剪贴板，发文档或聊天时直接粘贴就行。

和其他工具怎么选#

工具	更适合的场景
macOS 自带截图	偶尔截图、简单保存
Shottr	轻量截图、滚动截图、基础标注
CleanShot X	成熟商业工具、云端分享、团队协作
MacShot	免费开源、原生轻量、截图录屏 OCR 上传一体化

MacShot 的优势是免费、开源、功能密度高；CleanShot X 的优势是商业产品成熟度和云服务；Shottr 则胜在小巧和老牌口碑。

如果你不依赖 CleanShot Cloud，只是想要一个能截图、标注、录屏、OCR、上传的本地工具，MacShot 已经很有竞争力。

安装方式#

可以用 Homebrew 安装：

Terminal window

1
brew install sw33tlie/macshot/macshot

也可以从项目页面下载 .dmg 安装包：

https://github.com/sw33tLie/macshot

首次启动时，macOS 可能会要求授予屏幕录制、辅助功能、文件访问等权限。截图和录屏类工具一般都需要这些权限，否则会出现无法截取屏幕、录不到窗口或快捷键不可用的情况。

使用提醒#

上传截图前先检查是否包含隐私信息、账号、Token 或 API Key。
自动打码只能辅助，重要截图最好手动复查。
自建 S3/R2 图床时，注意 Bucket 权限和链接有效期。
录屏涉及系统声音或麦克风时，记得确认输入源是否正确。
开源项目功能迭代较快，具体界面和能力以官方最新版为准。

项目地址#

GitHub：https://github.com/sw33tLie/macshot
官网：https://www.macshot.io/

免认证上网 - 深澜校园网(mycc)

Fri, 09 May 2025 00:00:00 GMT

绕过原理#

深澜（Srun）等校园网认证系统在未登录的情况下，默认会拦截大部分网络请求，但为了维持基础网络通信和 IP 分配，通常会白名单放行部分特定的端口或协议。

本次绕过的核心就是利用了这些天然的”后门”：

UDP 53 端口：这是 DNS 协议使用的端口。认证前设备需要解析域名（如认证页地址），因此网关必须放行 UDP 53，可借此建立 DNS 隧道或将其作为代理监听端口。
UDP 67 / 68 端口：这是 DHCP 协议使用的端口。网关为了让设备在认证前能够顺利获取到局域网 IP，必须放行这两个 UDP 端口的数据包。
Protocol 58 (ICMPv6) / IPv6 流量：部分高校早期的计费系统只针对 IPv4 进行了严格的审计与拦截，而对 IPv6 流量（或 ICMPv6 协议的 58 号类型）处于完全放行的状态。

思路： 在拥有一台公网服务器（VPS）的前提下，将代理服务（如 WireGuard 等）的监听端口设置为 UDP 53 / 67 / 68，或者直接利用 IPv6 建立加密隧道，从而实现免认证上网。

流量绕过原理图#

graph LR A["💻 你的设备\n（未认证）"] -->|"UDP 53/67/68\n伪装成 DNS/DHCP"| B subgraph campus ["🏫 校园网"] B["深澜认证网关\n✅ 白名单放行\nUDP 53 / 67 / 68"] end B -->|"加密隧道穿透"| C subgraph vps ["☁️ 公网 VPS"] C["WireGuard 服务端\n监听 UDP 67"] end C --> D["🌐 互联网"] style campus fill:#fef9c3,stroke:#ca8a04 style vps fill:#dbeafe,stroke:#2563eb style A fill:#f0fdf4,stroke:#16a34a style D fill:#f0fdf4,stroke:#16a34a

准备工作#

1. 准备一台合适的 VPS#

系统推荐：Ubuntu 22.04 LTS，长期支持版本，软件源稳定、社区资料丰富，一键脚本兼容性最好。

端口要求（关键）： 选购或配置 VPS 时，需确保服务商不屏蔽以下 UDP 端口，否则绕过方案将无法生效：

端口	协议	用途
53	UDP	DNS，校园网认证前通常放行
67	UDP	DHCP Server，认证前必须放行
68	UDP	DHCP Client，认证前必须放行

注意： 部分云厂商会在平台层屏蔽 UDP 53（防 DNS 放大攻击）或 67/68（防 DHCP 欺骗）。建议选择不对 UDP 端口做限制的服务商，购买前可通过工单咨询确认，或购买后用 nc -u 等工具验证端口可达性。如需 IPv6 绕过，还需确认该 VPS 支持原生 IPv6。

2. 代理软件#

推荐使用 WireGuard，原生 UDP 协议，性能好、延迟低、配置简单。

3. 校园网测试环境#

在未登录校园网的状态下，测试 VPS 对应端口是否可达：

Terminal window

1
# 将 YOUR_VPS_IP 替换为实际 IP
2
nc -vzu YOUR_VPS_IP 53
3
nc -vzu YOUR_VPS_IP 67
4
nc -vzu YOUR_VPS_IP 68

配置步骤参考#

整体配置流程#

flowchart TD A([开始]) --> B["购买 VPS\nUbuntu 22.04 LTS"] B --> C["校园网未登录状态下\n测试端口可达性\nnc -vzu VPS_IP 67"] C --> D{端口可达?} D -->|否| E["更换服务商\n或工单申请开放端口"] E --> C D -->|是| F["SSH 登录 VPS\n运行 WireGuard 一键脚本"] F --> G["设置监听端口为\nUDP 53 / 67 / 68"] G --> H["云控制台安全组\n放行对应 UDP 端口"] H --> I["ufw 放行端口\nufw allow 67/udp"] I --> J["下载客户端配置\n.conf 文件或扫码"] J --> K["导入 WireGuard 客户端\n检查 Endpoint 字段"] K --> L["连接校园网 WiFi\n保持未登录状态"] L --> M["激活 WireGuard 隧道"] M --> N([免认证上网 🎉]) style A fill:#86efac,stroke:#16a34a style N fill:#86efac,stroke:#16a34a style D fill:#fde68a,stroke:#d97706 style E fill:#fecaca,stroke:#dc2626

方法一：基于 DHCP / DNS 端口 (UDP 53/67/68) 绕过#

以 WireGuard 为例（原生基于 UDP，更加轻量快速）：

SSH 登录 VPS（Ubuntu 22.04），使用一键脚本搭建 WireGuard 服务端：
Terminal window
```
1
curl -O https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh
2
chmod +x wireguard-install.sh
3
./wireguard-install.sh
```
或使用带 Web UI 的 wg-easy（适合不熟悉命令行的用户）。
安装配置时，将监听端口（Listen Port）自定义为 53、67 或 68。WireGuard 默认仅使用 UDP 协议，无需额外选择。
在云服务商控制台（安全组 / 防火墙）中放行对应的 UDP 端口，Ubuntu 本身的 ufw 防火墙也需放行：
Terminal window
```
1
ufw allow 53/udp
2
ufw allow 67/udp
3
ufw allow 68/udp
4
ufw reload
```
将生成的客户端配置文件（通常为 .conf）下载到本地（手机端可直接扫描脚本生成的二维码导入）。导入后检查 Endpoint 字段，确保形如：
```
1
Endpoint = 你的VPS_IP:67
```
连接校园网 WiFi（保持未登录状态），打开本地 WireGuard 客户端，激活该节点连接，即可实现免认证上网。

注意事项#

⚠️ 免责声明： 本文仅作网络安全与技术原理的交流、学习记录。滥用校园网漏洞进行大流量下载可能引起学校网管中心的注意，并面临被封禁设备 MAC 地址或校园网账号的风险，请合理、合规使用网络。

NVIDIA API Catalog 免费额度与 API Key 获取记录

Fri, 09 May 2025 00:00:00 GMT

简介#

NVIDIA API Catalog 是 NVIDIA 提供的模型体验与 API 调用入口，入口地址是 build.nvidia.com。它把许多模型包装成 NVIDIA NIM API，适合用来做原型验证、代码测试和个人学习。

简单理解就是：不用自己准备 GPU，也能先通过 NVIDIA 托管的接口试用部分大模型。等项目验证得差不多，再考虑换成自己的模型服务、其他 API 平台，或者部署自托管 NIM。

需要注意的是，免费额度、可用模型和调用限制会随账号地区、活动和平台政策变化，实际情况以控制台显示为准。

准备工作#

开始之前需要准备：

一个 NVIDIA 账号
可以正常访问 NVIDIA API Catalog 的网络环境
一个用于保存 API Key 的安全位置，例如密码管理器或本地环境变量
可选：OpenAI 兼容客户端，例如 NextChat、LobeChat、Cherry Studio、Open WebUI 等

获取 API Key#

1. 打开模型目录#

访问 https://build.nvidia.com/，登录自己的 NVIDIA 账号。进入页面后，可以在模型目录里搜索想要试用的模型，也可以直接从分类里挑一个聊天模型。

如果只是测试接口是否正常，建议先选一个通用聊天模型，不必一开始就纠结具体模型强弱。

2. 进入模型详情页#

点击模型后进入详情页。页面通常会提供在线预览、调用示例和 API Key 入口。部分第三方模型第一次使用时可能需要确认使用条款，按页面提示继续即可。

3. 点击 Get API Key#

在模型详情页右侧找到 Get API Key。如果账号还没有完成注册或登录，页面会先引导你加入 NVIDIA Developer Program 或完成账号验证。

生成后立刻复制并保存。API Key 属于敏感凭据，不要发给别人，也不要直接写进公开仓库。

官方文档里也提供了另一种方式：进入 NGC API Keys 页面生成 Personal Key，并在服务范围里选择 NGC Catalog 和 Public API Endpoints。如果模型页生成失败，可以尝试这个入口：

https://org.ngc.nvidia.com/setup/api-keys

API 调用配置参考#

NVIDIA 托管的 NIM API 使用 OpenAI 兼容格式，所以很多支持自定义 OpenAI 接口的客户端都可以直接配置。

常用配置如下：

配置项	填写内容
API Base URL	`https://integrate.api.nvidia.com/v1`
API Key	刚刚生成的 NVIDIA API Key
Model	模型详情页或代码示例里的模型 ID
Chat API	`/v1/chat/completions`

模型 ID 不建议手打，可以直接从 NVIDIA 页面给出的代码示例里复制，避免因为大小写、横线或下划线写错导致请求失败。

curl 测试#

可以先用 curl 验证 Key 和模型是否可用。下面的 MODEL_ID 需要换成模型详情页显示的真实模型名：

Terminal window展开收起

1
export NVIDIA_API_KEY="你的 API Key"
2
export MODEL_ID="模型 ID"
3

4
curl https://integrate.api.nvidia.com/v1/chat/completions \
5
  -H "Authorization: Bearer $NVIDIA_API_KEY" \
6
  -H "Content-Type: application/json" \
7
  -d '{
8
    "model": "'"$MODEL_ID"'",
9
    "messages": [
10
      {
11
        "role": "user",
12
        "content": "用一句话介绍 NVIDIA NIM。"
13
      }
14
    ],
15
    "temperature": 0.6,
16
    "max_tokens": 256
17
  }'

展开收起

如果能返回模型回复，说明 API Key、Base URL 和模型名都没有问题。

OpenAI SDK 调用示例#

因为接口兼容 OpenAI 格式，所以可以用 OpenAI SDK 指向 NVIDIA 的 Base URL：

1
from openai import OpenAI
2

3
client = OpenAI(
4
    base_url="https://integrate.api.nvidia.com/v1",
5
    api_key="你的 API Key",
6
)
7

8
response = client.chat.completions.create(
9
    model="模型 ID",
10
    messages=[
11
        {"role": "user", "content": "写一个三句话的 Python 学习计划。"}
12
    ],
13
    temperature=0.6,
14
    max_tokens=512,
15
)
16

17
print(response.choices[0].message.content)

展开收起

实际使用时建议把 API Key 放到环境变量里，不要硬编码在脚本中：

Terminal window

1
export NVIDIA_API_KEY="你的 API Key"

第三方客户端配置#

以常见聊天客户端为例，通常新增一个 OpenAI 兼容服务，然后填写：

接口地址：https://integrate.api.nvidia.com/v1
密钥：NVIDIA API Key
模型：从 build.nvidia.com 的模型页复制

如果客户端要求填写完整接口地址，不要重复添加 /chat/completions。大多数客户端只需要 Base URL，它会自己拼接请求路径。

常见问题#

提示 401 或 Unauthorized#

优先检查 API Key 是否复制完整，前后有没有多余空格。如果 Key 过期或被轮换，需要重新生成并更新客户端配置。

提示模型不存在#

通常是模型 ID 写错，或者该模型不支持当前账号调用。回到模型详情页复制官方示例里的模型名再试。

能在网页里试用，但客户端不能用#

检查客户端是否真的使用了 OpenAI 兼容接口，以及 Base URL 是否写成 https://integrate.api.nvidia.com/v1。有些客户端会默认把 OpenAI 官方地址写死，需要改成自定义服务商。

免费额度用完怎么办#

免费额度主要适合测试和学习，不建议把它当作长期生产服务。额度用完后，可以等待平台策略刷新、申请企业试用，或者迁移到其他兼容 OpenAI 的模型服务。

安全提醒#

不要把 API Key 提交到 GitHub、博客源码或截图里。
不要把自己的 Key 分享给陌生人使用。
如果怀疑 Key 泄露，立即删除或轮换。
重要项目建议给不同用途创建不同 Key，方便排查和回收。
免费接口适合开发验证，不适合直接承载稳定线上业务。