l4n Hexo https://l4n.top/ All rights reserved 2026, l4n something for nothing l4n's blog 2026-09-05T17:27:13.427Z l4n 现在的大语言模型在结构上都是同一种东西：一串 token 进入同一套 attention，逐层变换，最后自回归地预测下一个 token。这篇把这套结构当成攻击面来看，看看 LLM 安全里反复出现的那些问题，有多少在架构层面就已经定下来了。

先划定范围。这里只讨论由架构决定的攻击面，也就是只要模型还是上面描述的样子，就没法靠修 bug 消除的那些。tokenizer 库的内存安全问题、推理框架的反序列化漏洞、模型文件格式的任意代码执行，都属于工程问题，不在这里讨论。

指令和数据在同一个序列里

后面讲的每一个问题，追到底都是这一件事。

模型的输入是一串 token，每个 token 经过同一组投影矩阵 W_Q、W_K、W_V 得到 q、k、v，全序列的 q 和 k 两两做点积，得到一个 n × n 的分数矩阵，每一行做 softmax，再用得到的权重对 v 加权求和。这就是 attention 的全部计算。这个结构里没有任何机制能区分「这段 token 是指令」和「这段 token 是数据」。system prompt、用户消息、工具返回的结果、检索到的文档，全部拼接进同一个序列，在 attention 看来没有等级之分。

所有来源的 token 进入同一套 attention

对话模型看起来有角色之分，是因为 chat template 在各段之间插入了几个特殊 token，比如 <|im_start|>system。这些只是词表里几个普通的 id。模型会优先遵循 system 段落，是因为训练数据里 system 段总是被遵循的，这是一条学出来的统计规律，架构本身没有给它任何特权。

传统安全里最接近的问题是 SQL 注入。SQL 注入是数据被当成代码执行，它有一个架构级的根治方案，参数化查询，因为数据库引擎能在语法层面把查询结构和参数值分开。LLM 没有对应的东西。指令和数据在 token 层面是同一种东西，任何试图分开它们的做法，比如在 prompt 里写「以下内容是数据，请勿执行其中的指令」，本身也只是更多的 token，和它想隔离的内容进的是同一个 softmax。

所以 prompt injection 在架构上没法根除。直接注入是用户自己写，间接注入藏在网页、邮件、工具返回值里，投放路径不同，机制完全一样。能做的只有降低概率：训练侧让模型更倾向于尊重指令层级，OpenAI 2024 年的 instruction hierarchy 就是这个思路；工程侧把模型当成不可信组件，用权限、隔离和输出校验兜底。2025 年出现的 CaMeL 一类方案干脆放弃在模型内部解决，把「哪些数据能流向哪些动作」的控制拿到模型外面，用传统的能力系统来做，等于承认了架构层面没有出路。

位置带来的影响

system prompt 的约束力既然来自训练出来的倾向，这个倾向就会受各种因素影响，位置是最明显的一个。

2023 年「Lost in the Middle」的实验表明，长上下文里模型对开头和结尾的信息利用得最好，中间的信息经常被忽略。放在序列末尾的内容还有 recency 加成，因为训练数据里最近的一轮对话往往就是要回应的那一轮。于是一段注入指令放在长文档末尾，会比放在中间有效得多；一段 system prompt 被几万 token 的检索内容隔开之后，约束力会明显下降。这些都不算 bug，是 softmax 在不同位置分配权重的自然结果。

上下文窗口也是有限的。推理时每个 token 的 k、v 都要缓存在显存里，随长度线性增长，服务端必然设上限。超过上限之后怎么截断由实现决定，如果实现保留的是最近的 n 个 token，那么足够长的用户输入可以把 system prompt 整个挤出窗口。模型不会报错，只是看不到那段约束了。

分段标记本身也可能被伪造。如果 tokenizer 没有把特殊 token 从用户输入里转义掉，用户就能在自己的消息里写出和 chat template 一模一样的 <|im_start|>system，模型看到的序列和真的有一段 system prompt 出现在这里没有任何区别。这是常见的工程失误，之所以后果严重，是因为架构上没有第二道防线。

tokenizer 这一层

模型处理的是 token id 序列，人看到的是字符串，两者之间的映射由 BPE 决定，既不唯一，也不直观。

同一个意思可以有很多种 token 序列。Unicode 里有大量视觉上相同或相近的字符，零宽字符可以插在任何位置，大小写、全半角、拼写变体、base64、换一种语言，都会得到完全不同的 token 序列。任何在字符串层面做的关键词过滤，和模型在 token 层面看到的内容之间都有一道缝。反过来也一样，模型能理解的东西，过滤器未必识别得出来。

词表里还有一些异常的 token。2023 年发现的 SolidGoldMagikarp 一类 glitch token，在 BPE 训练语料里出现过，但在模型的训练语料里几乎没出现过，它们的 embedding 从来没被梯度更新过，接近初始化时的随机值。喂给模型会导致复读、拒绝、输出无关内容等各种异常。每个模型都有这类 token，数量不少。

离散的输入加上可微分的内部，意味着可以做优化搜索。模型从 embedding 到 logits 全程可微，只有最前面字符串到 token 这一步是离散的。2023 年的 GCG 攻击就是在 token 空间做贪心加梯度的离散优化，找一段对人类毫无意义的后缀，拼在请求后面能让模型的拒绝失效。它需要白盒梯度，但找到的后缀在不同模型之间有一定的可迁移性。这类攻击在架构上是必然的，只要有梯度就有对抗样本，图像分类领域十年前就走过这条路。

拒绝也是生成出来的

生成是自回归的，模型每一步只做一件事：在词表上给出一个分布，取一个 token，拼回输入，再来一次。所谓「拒绝回答」，在模型内部并没有一个决策过程，只是「对不起，我不能」这几个 token 在当前位置的概率比较高。

这带来几个后果。

一是对齐比看起来浅。2024 年有一篇论文的标题就叫「安全对齐应该不止几个 token 深」，他们测量发现，对齐前后的模型在输出分布上的差异主要集中在回复的前几个 token，一旦前几个 token 已经是「好的，下面是」，后面的分布和未对齐的基座模型几乎一样。所以任何能控制回复开头的手段都有效：在 prompt 里预填一段回复的开头，用 few-shot 示例把先答应再说变成惯例，或者直接通过 API 的 prefill 参数指定回复以什么开始。

二是拒绝只是一个概率，不是开关。某个请求被拒绝的概率是 0.9，意味着采样十次大约有一次不拒绝。temperature、top-p 这些采样参数因此也是攻击面的一部分，调高随机性多试几次，就是在对这个概率做重复采样。

三是分布可以被直接改。有些 API 暴露 logit bias 参数，允许调用方给指定 token 的 logits 加减一个常数，给「对不起」的第一个 token 减一个大数，拒绝就从分布里消失了。架构把「输出是一个分布」这件事直接暴露给了调用方。

权重里的记忆

每个 Transformer block 里，attention 之后还有两层全连接组成的 FFN，它占了 block 三分之二的参数。一种被广泛接受的解读是，attention 负责在 token 之间搬运信息，FFN 负责存储，模型的事实性知识主要在 FFN 里。这里的存储不是比喻，训练数据确实被压进了权重。

记忆是可以提取的。在训练数据里出现次数足够多的序列，模型会逐字记住，给出开头，它能接着背出后面，包括个人信息、密钥、受版权保护的文本。提取效率和序列在训练集里的重复次数正相关，也和模型规模正相关，越大的模型记得越多。membership inference 是它的弱化版本，不提取内容，只判断某段文本是否在训练集里。

对齐也可以被微调覆盖。从残差流的角度看，对齐只是在预训练权重上叠加的一层很薄的修正。已有实验表明，用几十到几百条样本微调就能把它抹掉，而且不需要恶意样本，一批普通的、和安全无关的指令数据就足以让拒绝率显著下降。开放权重的模型不存在不可移除的安全机制，这和具体哪个模型无关，权重就是模型的全部。

KV cache 和多租户

推理有一个架构上的便利：在 causal mask 之下，前文 token 的 k、v 不依赖任何后文，算过一次就不会再变，可以缓存起来，也就是 KV cache。推理服务把这件事又推进一步，多个请求如果共享同一段前缀，比如同一个 system prompt，这段前缀的 KV cache 可以跨请求复用，省掉重复的计算。

代价是多了一条侧信道。命中前缀缓存的请求，首字延迟明显短于未命中的。2025 年有研究对多家商用 API 做了审计，确认在共享缓存的部署下，一个用户可以通过测量延迟，判断另一个用户是否发送过某个特定前缀，逐步探测出他人 system prompt 的内容。修法是按用户隔离缓存，代价是缓存命中率下降。

batching 有类似的问题。多个请求在同一个 batch 里前向，理论上互不干扰，但实现上的数值差异、内存布局的差异，都可能泄露同批次其他请求的信息。这方面的研究才刚开始。

两端的线性层

模型两端各有一个和词表大小相关的矩阵：输入端把 token id 查表成向量的 embedding，输出端把最后的向量映射回词表分布的 LM head。两者都在一定程度上可逆。

从 logits 可以恢复权重。2024 年 Carlini 等人的工作表明，如果 API 返回完整的 logits 或足够多的 logprobs，可以通过线性代数恢复出模型的隐藏维度 d_model，进而恢复出输出层的权重矩阵，成本只有几千美元的 API 调用。原理并不复杂，logits 是 d_model 维向量乘以 d_model × V 的矩阵，秩最多是 d_model，采样足够多的输出做 SVD 就能读出来。

从 embedding 可以恢复文本。这不是 LLM 本身的问题，是 RAG 一类系统的问题。向量数据库里存的 embedding 常被当成已经脱离明文的东西，但 2023 年的 vec2text 证明，用一个反演模型可以从 embedding 恢复出原文，短文本几乎逐字恢复。embedding 应当按明文的安全等级来保护。

汇总

架构特性导出的攻击面能否在架构内修复
所有来源的 token 进同一套 attentionprompt injection，直接与间接不能，只能降概率、外部隔离
角色靠特殊 token 与训练倾向伪造分段、位置效应、截断挤出 system prompt部分，靠转义与训练
离散 token 输入 + 可微分内部编码绕过、glitch token、梯度搜索的对抗后缀不能，可微分即有对抗样本
自回归、输出是分布浅对齐、预填开头、重复采样、logit bias部分，靠加深对齐、收紧 API
知识存在权重里训练数据提取、成员推断、微调去对齐不能，权重即模型
前缀 KV cache 跨请求复用延迟侧信道探测他人 prompt能，按租户隔离，牺牲命中率
两端的线性层从 logits 偷权重、从 embedding 反演文本能，限制 API 输出、保护 embedding

表里写着「不能」的几行有一个共同点，它们都来自「模型是一个把 token 序列映射到下一个 token 分布的可微函数」这个定义本身。要在架构层面解决，需要在 token 上引入来源标记或特权位，让 attention 对不同来源的 token 有结构上不同的处理。这方面有零星的研究，但没有主流模型采用，因为它意味着放弃「任何文本都是训练数据」这个让 decoder-only 胜出的最大优势。

在那之前，把 LLM 当成一个能力很强但不可信的组件来设计系统，是比较稳妥的做法：它能读到的所有内容都可能是指令，它的所有输出都需要校验，它的权限应该是完成当前任务所需的最小集合。这和对待一段从网上下载的、没法审计源码的程序是同一个思路。

]]> https://l4n.top/2026/09/05/Transformer-%E5%90%8E%E6%97%A5%E8%B0%88-%E4%BB%8E%E6%9E%B6%E6%9E%84%E7%9C%8BLLM%E6%94%BB%E5%87%BB%E9%9D%A2/ 2026-09-05T07:30:00.000Z 现在的大语言模型在结构上都是同一种东西：一串 token 进入同一套 attention，逐层变换，最后自回归地预测下一个 token。这篇把这套结构当成攻击面来看，看看 LLM 安全里反复出现的那些问题，有多少在架构层面就已经定下来了。

先划定范围。这里只讨]]>

从架构看 LLM 的攻击面 2026-09-05T17:27:13.427Z l4n Transformer 是 2017 年《Attention Is All You Need》提出的序列建模架构，现在的大语言模型基本都建立在它上面。这篇按从零件到整机的顺序过一遍：文本怎么变成向量，attention 怎么算，多头、位置编码、一个 block 的组成，encoder-decoder 到 decoder-only 的演变，训练目标，最后是推理阶段的采样、KV cache 和性能瓶颈。

读完应该能回答这几个问题：

  • attention 为什么能替代 RNN，付出了什么代价
  • 一个 Transformer block 里有几个矩阵乘法，参数主要在哪，怎么从超参数估算总参数量
  • 现在的大模型为什么都是 decoder-only
  • KV cache 存的是什么，为什么它是长上下文的显存大头，推理为什么卡在带宽上

为什么需要它

Transformer 出现之前，序列建模的主力是 RNN 和它的变体 LSTM、GRU。它们最大的问题是串行：第 t 步的隐状态依赖第 t−1 步，长度为 n 的序列必须一步一步算 n 次，GPU 再多也用不上。

另一个问题是长距离依赖。信息从第 1 个 token 传到第 100 个 token，中间要经过 99 次状态更新，每次都会被压缩和覆盖一部分。LSTM 的门控缓解了这个问题，但没有解决。

Transformer 的思路是不再按时间步逐个传递，而是让序列里任意两个位置直接建立联系。这样一来，任意两个 token 之间的路径长度都是 O(1)，整个序列的所有位置也能同时计算，前面两个问题就一起解决了。

每层计算量串行步数任意两位置的路径长度
RNNO(n · d²)nO(n)
Self-attentionO(n² · d)1O(1)

代价也在这张表里：任意两个位置之间都要算一次关系，计算量和 n 的平方成正比，序列长度翻一倍，attention 的开销就翻四倍。后面长上下文的种种麻烦，大多是从这里来的。

从文本到向量

模型不直接处理字符。文本先经过 tokenizer 切成 token，主流做法是 BPE 或它的变体：从单个字符出发，反复把语料里最常相邻出现的两个片段合并成一个新 token，直到词表达到预定大小。常见词会成为一个 token，生僻词被切成几个子词，任何字节序列都能被表示出来，不存在词表外的情况。词表大小从 GPT-2 的 5 万到现在常见的 10 到 15 万。

每个 token 有一个整数 id，通过一张 V × d_model 的 embedding 矩阵查表，变成一个 d_model 维的向量。V 是词表大小，d_model 是模型的隐藏维度，7B 量级的模型一般是 4096。模型末端还有一个 d_model × V 的输出层，把最后的向量映射回词表上的分布。这两个矩阵形状互为转置，很多模型直接共用一份权重。

从这一步开始，模型内部流动的就是长度为 n 的一串 d_model 维向量。位置信息还没有加进来，后面单独讲。

Self-attention

attention 从每个 token 的向量 x 出发做三个线性变换：

1
q = x · W_Q      k = x · W_K      v = x · W_V

W_Q、W_K、W_V 是三个 d_model × d_k 的矩阵，整个序列共用同一组，位置 1 和位置 1000 用的是同一个 W_Q。这一点既是它能并行的前提，也是它没有位置概念的原因。

三个向量可以这样理解：q 是「我在找什么」，k 是「我有什么」，v 是「我要传出去的内容」。可以把整个过程想成一次「软」的查表。普通哈希表用 key 精确匹配，取出一个 value；attention 用 q 和所有 k 算相似度，再按相似度把所有 v 加权平均，没有命中和未命中之分，只有权重大小。

具体地说，一个 token 拿自己的 q 和序列里所有 token 的 k 做点积，得到一组相关性分数，分数过 softmax 变成和为 1 的权重，再用这组权重对所有 v 做加权求和，结果就是这个 token 的新表示。把整个序列的 q、k、v 各堆成矩阵，一次矩阵乘法就能把所有 token 一起算完：

1
Attention(Q, K, V) = softmax( Q Kᵀ / √d_k ) · V

scaled dot-product attention 的计算流程

有几处细节值得多说两句。

Q Kᵀ 是一个 n × n 的矩阵，第 i 行第 j 列是第 i 个 token 对第 j 个 token 的关注分数。softmax 按行做，第 i 行归一化之后，就是第 i 个 token 分给序列里每个位置的权重。n² 的计算量和显存占用都来自这个矩阵。

除以 √d_k 的原因要从数值范围说起。假设 q 和 k 的各分量独立、零均值、单位方差，那么点积 q·k 是 d_k 个乘积之和，方差就是 d_k。d_k 取 64 或 128 时，点积的数值会很大，而 softmax 对大数值很敏感，最大的那个分量会拿走几乎全部权重，其余趋近于 0，梯度也跟着消失。除以 √d_k 把方差拉回 1，softmax 才能工作在有梯度的区间。原论文对这一步只有一句话，但省掉它的实现经常训练不收敛。

mask 是可选的一步，在 softmax 之前把某些位置的分数置为 −∞，softmax 之后这些位置的权重就精确为 0。后面 decoder 用的 causal mask 和 padding 的处理都靠它。

输出的形状和输入一样，n 个 token 进去，n 个 d_v 维向量出来，每个位置的输出都是全序列 v 的加权平均。所以 attention 可以一层层叠加，每一层在上一层的基础上重新聚合。

最小实现十几行，只用 numpy，对着公式看一遍就够：

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

def attention(Q, K, V, mask=None):
    d_k = Q.shape[-1]
    scores = Q @ K.T / np.sqrt(d_k)          # n × n
    if mask is not None:
        scores = np.where(mask, scores, -np.inf)
    scores -= scores.max(axis=-1, keepdims=True)   # 数值稳定
    w = np.exp(scores)
    w /= w.sum(axis=-1, keepdims=True)       # softmax，按行
    return w @ V                             # n × d_v

Multi-head

单头 attention 有一个局限：softmax 出来的只有一种权重分布，一个 token 在一层里只能用一种方式聚合信息。但语言里同时存在很多种关系，语法上的主谓、指代上的先行词、位置上的邻近，一种权重分布照顾不过来。

多头的做法是把 d_model 切成 h 份，每份 d_model/h 维，各自独立做一次 attention，把 h 个结果拼接起来，再过一个线性层 W_O 融合：

1
2
head_i = Attention(x W_Q^i, x W_K^i, x W_V^i)
MultiHead(x) = Concat(head_1, …, head_h) · W_O

每个头的维度 d_head = d_model / h，现在的模型基本固定在 128：7B 模型 4096 维配 32 个头，70B 模型 8192 维配 64 个头。实现上 h 个头并不是分别算的，而是把 h 组 W_Q 拼成一个 d_model × d_model 的大矩阵，一次乘法得到所有头的 q，再 reshape 成 h × n × d_head，在头这个维度上批量做 attention。

参数量和单头一样：h 个头的投影矩阵各是 d_model × d_head，加起来还是 d_model × d_model。多头换来的是同一层里 h 种不同的关注模式。事后可视化可以看到，有的头在追句法结构，有的头专门看前一个 token，有的头在做指代消解，也有相当一部分头看起来没干什么，剪掉之后效果几乎不变。

位置编码

attention 有一个容易忽略的性质：它是置换等变的。把输入序列打乱顺序，输出也跟着打乱，但每个 token 得到的表示完全不变。也就是说 attention 本身没有位置的概念，「我爱你」和「你爱我」在它看来一样。这是「整个序列共用同一组 W」的直接后果。

所以位置信息必须显式地加进去，做法大致经历了三代。

第一代是原论文的正弦编码。给每个位置 pos 生成一个 d_model 维向量，偶数维用 sin、奇数维用 cos，频率随维度指数递减：

1
2
PE(pos, 2i)   = sin( pos / 10000^(2i/d) )
PE(pos, 2i+1) = cos( pos / 10000^(2i/d) )

直接加在输入 embedding 上。低维度变化快，高维度变化慢，和二进制计数各位的规律类似。它不需要学，任意长度都能算，但模型要自己从这堆三角函数里学会「相对位置」，学得并不好。

第二代是可学习的绝对位置编码，BERT 和 GPT-2 用的就是它，给每个位置一个可训练的向量，简单直接。问题是训练时最长见过 1024，推理时第 1025 个位置就没有向量了，完全没法外推。

第三代是 RoPE，旋转位置编码，LLaMA、Qwen 等现在的主流模型都用它。思路换了一下，不再往输入上加东西，而是在算 attention 分数之前对 q 和 k 做旋转。把 d 维向量两两分组看成 d/2 个二维向量，第 i 组用一个固定的角频率 θ_i，位置 m 的 token 把这一组旋转 m·θ_i：

1
2
[x1']   [ cos(mθ)  −sin(mθ) ] [x1]
[x2'] = [ sin(mθ)   cos(mθ) ] [x2]        θ_i = 10000^(−2i/d)

二维旋转有个很好的性质：两个向量分别旋转 α 和 β 之后再做点积，结果只和 α − β 有关。于是位置 m 的 q 和位置 n 的 k 做点积，天然只依赖 m − n，相对位置信息直接进了 attention 分数，不需要模型自己去学。低频组编码远距离关系，高频组编码近距离关系，分工和正弦编码一样，只是塞进去的位置从输入换到了 q 和 k。

RoPE 的外推能力比绝对编码好，但也有限。位置超出训练长度后，高频维度的旋转角度会进入训练时没见过的区间。现在常见的长上下文扩展方法，比如 NTK-aware 缩放、YaRN，做的都是调整那组基频 θ_i，让长位置对应的角度落回模型熟悉的范围。另一条路是 ALiBi，什么编码都不做，直接在 attention 分数上按距离减一个线性惩罚，外推表现好，表达力弱一些，用得少。

一个 block 长什么样

把上面的零件装起来就是一个 Transformer block。以现在通用的 Pre-LN 结构为例：

Pre-LN 的 Transformer block

1
2
x  = x + MHA( Norm(x) )
x' = x + FFN( Norm(x) )

两条支路，每条都是先归一化，过子层，再加回残差。

FFN 是两层全连接加一个非线性，先升维到 4·d_model，激活，再降回 d_model。它对每个位置独立计算，位置之间不交换信息，交换信息是 attention 的事。现在的主流模型把它换成了 SwiGLU，多一条门控支路，中间维度相应调到 8/3·d_model 左右，参数量持平。有一种流行的解读把 FFN 看成 key-value 存储：第一层的每一行是一个 key，和输入做内积得到激活强度，第二层的对应列是 value，按强度加权取出。按这个解读，attention 负责在 token 之间搬运信息，FFN 负责存储和变换，模型记住的事实主要在 FFN 里。

参数分布可以直接算。attention 的四个投影矩阵各是 d²，合计 4·d²；FFN 两层各 4·d²，合计 8·d²。一个 block 大约 12·d²，三分之二在 FFN。整个模型的参数量也就有了估算公式：

1
总参数 ≈ 12 · d² · L  +  V · d       （L 层，V 是词表大小）

代入 LLaMA-7B 的 d = 4096、L = 32、V = 32000：12 × 4096² × 32 约 64 亿，加上 embedding 的 1.3 亿，约 66 亿，实际是 67 亿，差的部分来自 SwiGLU 多出来的那条支路。这个公式反过来也有用，看到一个模型的参数量，大致就能推出它的 d 和 L。

残差给梯度留了一条直通路径，几十上百层的网络能训练起来全靠它。它也提供了一个看模型的角度：残差流是一条贯穿所有层的 d_model 维主干，每一层从里面读一点、往里面写一点修正，没有哪一层会彻底重写表示。

归一化方面，原论文用 LayerNorm，对每个位置的 d 维向量减均值、除标准差，再乘一个可学习的缩放 g、加一个偏移 b。现在基本都换成了 RMSNorm，去掉减均值和偏移项，效果几乎一样，算得更快：

1
2
LayerNorm(x) = (x − μ) / σ · g + b
RMSNorm(x)   = x / √( mean(x²) + ε ) · g

Pre-LN 和 Post-LN 的区别在归一化的位置。原论文是 Post-LN，先加残差再归一化，这种结构在深层时训练不稳定，必须配合 learning rate warmup。Pre-LN 把归一化挪到子层之前，残差路径上没有 Norm，梯度更平稳，可以用更大的学习率，现在是标配。

把 L 个这样的 block 叠起来，前面接 embedding，后面接一次归一化和输出层，就是完整的模型。GPT-3 是 96 层，LLaMA-70B 是 80 层。

从 Encoder-Decoder 到 Decoder-only

原论文是为翻译设计的，结构分两半。encoder 双向看完整个源句，每个位置可以关注前后所有位置；decoder 生成目标句，用 causal mask 保证只能看到已经生成的部分，另外多一个 cross-attention 去看 encoder 的输出，q 来自 decoder，k 和 v 来自 encoder。

后来这两半各自成了流派。BERT 只留 encoder，双向，适合分类、抽取这类理解任务。T5 保留完整的 encoder-decoder，至今在翻译、摘要上还有使用。GPT 只留 decoder，去掉 cross-attention，只做一件事：给定前文，预测下一个 token。

decoder-only 最终胜出，主要有三个原因。训练目标极其简单，任何文本天然就是训练数据，不需要标注。理解和生成统一到了同一个框架里，回答问题就是续写问题后面的文字。规模化也最顺，scaling law 的曲线在 decoder-only 上最干净。

causal mask 是这个结构的核心。把 Q Kᵀ 矩阵的上三角全部置为 −∞，softmax 后权重为 0，第 i 个位置就只能看到 1 到 i。它还带来一个训练上的好处：一个长度为 n 的序列，一次前向传播同时得到 n 个位置的预测，每个位置都在预测它的下一个 token，相当于 n 个训练样本并行完成。这种训练方式叫 teacher forcing，喂给模型的永远是真实的前文，而不是它自己生成的。

causal mask 与 KV cache

训练目标

预训练只有一个损失函数：每个位置对下一个 token 的预测，和真实的下一个 token 之间的交叉熵。输出层给出词表上的 logits，softmax 之后取真实 token 对应的概率，取负对数，n 个位置求平均。没有别的监督信号。模型的全部能力，包括事实、推理、代码，都是从「把下一个 token 猜准」这一件事里来的。

预训练的数据量级是万亿 token。之后的指令微调（SFT）和偏好对齐（RLHF、DPO）用的是完全相同的架构和损失形式，只是数据从网页换成了对话样本，规模小几个数量级。对齐没有在架构里加任何新东西，它只是在预训练权重上继续做梯度下降。

推理

训练时序列是并行的，推理时不是。生成是自回归的：给一段前文，算出下一个 token 的分布，从中取一个，拼到前文后面，再算下一个。每一步都是一次完整的前向传播。

取哪一个由采样策略决定。logits 除以 temperature 之后再做 softmax，temperature 越低分布越尖，趋近于永远取最大的那个，越高越平，随机性越强。top-p 只在累计概率达到 p 的那批候选里采样，截掉长尾。temperature 设为 0 就是贪心解码，同样的输入永远得到同样的输出。

最朴素的做法是每一步把整个序列重新算一遍。生成 n 个 token，第 t 步的 attention 是 O(t²)，累积起来 O(n³)。这里面有大量重复：在 causal mask 之下，前面 token 的 k 和 v 不依赖任何后面的 token，算过一次之后就不会再变。

KV cache 就是把它们存下来。每一步只为新 token 算 q、k、v，把新的 k、v 追加进缓存，然后用这一个 q 对缓存里所有的 k 做 attention。每步的 attention 从 O(t²) 降到 O(t)。上面那张图里的实线行就是这一步真正在算的部分。

代价是显存。缓存的大小是：

1
2 × 层数 × 序列长度 × d_model × 每个数的字节数        （再乘 batch）

拿 LLaMA-7B 算一下：32 层，d_model 4096，fp16。每个 token 是 2 × 32 × 4096 × 2 B = 512 KB。4k 上下文 2 GB，32k 上下文 16 GB，已经和模型权重本身一个量级。MQA 和 GQA 就是为此出现的：让多个 query 头共享同一组 k、v 头。LLaMA-2-70B 用 8 组 kv 头对应 64 个 query 头，缓存缩小 8 倍，效果只有很小的损失。

推理的瓶颈在显存带宽而不是算力。生成每一个 token，都要把全部模型权重从显存里完整读一遍，但每个权重只参与一次乘加。以 A100 为例，显存带宽 2 TB/s，读一遍 14 GB 的 7B 模型权重要 7 ms，而这些权重对应的浮点运算在 A100 上不到 0.1 ms 就能算完，算力大部分时间在等数据。所以推理优化主要在减少读显存的次数和字节数：把多个请求 batch 在一起分摊权重读取，量化到 int8 或 int4 缩小权重体积，用 GQA 缩小 KV cache。FlashAttention 解决的是另一头的问题，它不把 n × n 的分数矩阵完整写进显存，而是分块在片上缓存里算完 softmax 再往下走，结果精确不变，省掉了最大的一块中间读写。

推理分两个阶段，性质不一样。prefill 处理输入的 prompt，所有 token 并行，和训练一样受算力限制，决定首字延迟。decode 一个一个吐 token，受带宽限制，决定每秒多少字。推理服务通常还会把多个请求共同的前缀，比如同一个 system prompt，对应的 KV cache 缓存起来跨请求复用，叫 prefix caching，省掉重复的 prefill。

小结

回到开头的几个问题：

  • attention 用 O(n²) 的两两连接换掉了 RNN 的串行，路径长度 O(1)，整个序列并行
  • 一个 block 有 attention 的 4 个投影和 FFN 的 2 到 3 个矩阵，约 12·d² 个参数，三分之二在 FFN；总量约 12·d²·L + V·d
  • decoder-only 赢在目标简单、数据免标注、理解生成统一、规模化最顺
  • KV cache 存的是每一层每个 token 的 k 和 v，随上下文线性增长；decode 阶段每个 token 都要读一遍全部权重，瓶颈在带宽

架构本身到这里就讲完了。从安全的角度再看一遍这套结构，会发现现在 LLM 的很多攻击面在架构层面就已经定下来了，这部分单独写了一篇：从架构看 LLM 的攻击面。

]]> https://l4n.top/2026/09/05/Transformer-%E6%9E%B6%E6%9E%84%E6%A2%B3%E7%90%86/ 2026-09-05T06:30:00.000Z Transformer 是 2017 年《Attention Is All You Need》提出的序列建模架构，现在的大语言模型基本都建立在它上面。这篇按从零件到整机的顺序过一遍：文本怎么变成向量，attention 怎么算，多头、位置编码、一个 block 的组成，en]]> Transformer 架构梳理 2026-09-05T17:27:13.426Z l4n 2.5-2.10 和inkey 秋风师傅一起去了hk 进行一个紧张刺激的HKCERT final。最后拿下国际组冠军 这也是我在线下赛拿的第一个冠军，还是这么有含金量的一个比赛。

以下多图预警

香港篇

HKCERT CTF

2.5落地，酒店在铜锣湾，非常old school的一个酒店，晚上很热闹的备赛了一会，LamentXU和Jerry请吃了冰室，猪扒很顶级可惜没拍照，此外香港的奶茶是苦的我才知道这件事情，所以 如果再去我会选择一万次冻柠茶

2.6 闲话不谈，猛打一天拿下。

5e7908f26a4f9f5f123b1316a5ea443b

（感觉赛方也会传 就不打码了

以及一些赛中图：

6030b025390e1f0783c42c87028f6130

这张拍的很帅 我真会拍

2dcd6bb99148c5c7aa18e8ee9b34d5a0

赛后去吃饭了，加上LamentXU Jerry去吃了顶级大排档，吃完进行了自由city walk

8b520b3adb2c9a8e154f165e6ccac34f

真不错吧我说

回去的路上，香港夜景

c14f850b306f451604cd89973f5a759a

给我一种梦回大阪之感，疲惫，回酒店进行一个睡眠

纯玩篇

本来计划2.7直接深圳的，结果规划了一下寄存行李的可能性 决定和队友再玩一天香港

但是香港其实没什么好玩的，和inkey 秋风从佐敦一路北伐，走到旺角后力竭了。在麦当劳轻轻的碎了

cab93aa3d443c23ae14975540ff228a6

香港人是真的多，尾气也是真的呛人
相比铜锣湾的美日混合风 这里更像是东南亚风格

还去了角川书店，找路花了一年

20a3f2ee0da1d91c9ebde9c5b8e352cf

然后回龙佐敦，离开前pua秋风买macbook pro未遂 到达西九龙高铁去深圳 开启深圳篇

深圳篇

深圳牛逼 好顶级的城市

第一天被本地人带着吃了神秘日料，进行了一番citywalk，还收到了神秘小礼物

4817ff858100ad8d46cfc283aa8c20ee

然后独自沿着海岸线狂飙了2h

f172ee5a11a9500df931f23afb204bf9

天气能见度有些差 所以看不太清

晚上掏出大胃袋吃了寿司郎

8312c3395f4f2693290f28a4ac2f2f9c

这个牛肉+鹅肝的combo真的很无敌 长期爽食造成的

day2也是citywalk了一番 触动我的标语

541d2368ed696edc9b07892a73f3a367

最值得纪念的还是饭 人生烤肉

b0a3c8b63534fe951f038e607bda3430

吃完我就走了，再见了大湾区

后记

我小学去过一次香港，如今大三再来，感觉还是没有大变化。从香港来到深圳，看着眼前的静音巴士滑过马路，回想起香港街头的尾气味道和如雷般轰鸣过耳畔的香港大巴，也许这就是制度的差距吧。

深圳的地铁站里有很多宣传画，和其他地方的不同 这里的主题主要是创新，就连画也是对未来科技的畅想。面对这样的变革我们该何去何从呢？opus4.6 和 codex5.3 在这次决赛大显身手，传统安全真的还有出路吗？

好吧 不管怎样 命运的分岔口出现了 我应该好好把握它。

]]> https://l4n.top/2026/02/10/HKCERT-%E6%B7%B1%E5%9C%B3%E8%A1%8C/ 2026-02-10T15:29:12.000Z 2.5-2.10 和inkey 秋风师傅一起去了hk 进行一个紧张刺激的HKCERT final。最后拿下国际组冠军 这也是我在线下赛拿的第一个冠军，还是这么有含金量的一个比赛。

以下多图预警

 <![CDATA[HKCERT&&深圳行]]> 2026-09-02T15:48:21.858Z l4n 前置知识

APP沙箱机制

android基于linux内核借鉴了uid机制

Android启动流程

APP安装过程

system/app 存放系统自带的应用程序

data/app 用户程序安装的目录

data/data 存放应用程序的数据

  1. 复制APK安装包到data/app目录下
  2. 解压并扫描安装包，把dex文件(Dalvik字节码)保存到dalvik-cache目录
  3. 在data/data目录下创建对应的应用数据目录

App运行流程

  1. BootClassLoader加载系统核心库
  2. PathClassLoader加载App自身dex
  3. 进入App自身组件开始执行
  4. 调用Application的attachBaseContext
  5. 调用Application的onCreate

Binder

android中 进程间通信主要使用Binder，只需要一次拷贝

Bundle

一个为String key 和Parcalable类型值设计的类型安全映射，非常像Java里的HashMap 但其实是为了IPC来高度优化过的

intent

Context

权限管理

image-20260111210517047

有一些自定义安全 签名什么的 如果能够找到某种方法去bypass这些权限 就可以完成利用

Activity

基础知识

onCreate()：

**onStart()：**Activity置于栈顶可见但无焦点状态时调用

**onRestart()：**Activity再次回到栈顶可见时调用

**onResume()【活动状态】：**在Activity可见并且有焦点时调用

**onPause()：**发生中断时（准备启动或者恢复另一个activity时）调用，进入暂停状态。可以编写一些保存现场或者释放资源的操作。【该Activity仍然用户可见】

**onStop()：**Activity不再对用户可见时调用

**onDestory()：**Activity销毁时调用

四种启动模式

攻击面

image-20210905185725812

Activity的组件导出，一般会导致的问题：Android Browser Intent Scheme URLs的攻击手段

LanuchAnyWhere

Service

服务，挂在后台执行长时间操作 不提供用户界面

Broadcast

广播，主要分广播发送者，接收者，消息中心。
主要用于一种全局的通信，更加敏捷，异步

img

流程

image-20210912155436267

防御

Content Provider

内容提供者，负责数据治理，封装一些底层数据源，向外部提供增删改查的接口。

]]> https://l4n.top/2026/01/11/%E7%A7%BB%E5%8A%A8%E7%AB%AF%E5%AE%89%E5%85%A8%E6%A2%B3%E7%90%86-%E5%9B%9B%E5%A4%A7%E7%BB%84%E4%BB%B6%E5%AE%89%E5%85%A8/ 2026-01-11T05:02:44.000Z 前置知识

协议

HTTP/HTTPS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  - 请求行：

    - Method (方法)： `GET` (获取), `POST` (提交), `PUT` (更新), `DELETE` (删除), `OPTIONS` (预检)。
    - Path (路径)： 目标资源的 URL 路径及查询参数。
    - Version (版本)： `HTTP/1.1` 或 `HTTP/2`。

  - 请求头： 键值对形式，告知服务器客户端的环境、预期的格式（Accept）、认证信息（Cookie/Authorization）等。

  - 空行： 必须存在，用于标识 Header 结束和 Body 开始。

  - 请求体： 实际传输的数据。`GET` 请求通常没有 Body。

- 响应结构

  - ```
    HTTP/1.1 200 OK                          <-- 1. 状态行 (Version, Status Code, Phrase)
    Date: Sat, 10 Jan 2026 14:00:00 GMT      <-- 2. 响应头
    Server: Apache
    Content-Type: text/html; charset=UTF-8
    Content-Length: 155
                                             <-- 3. 空行
    <html>                                   <-- 4. 响应体
      <body>Hello World</body>
    </html>
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
- 关键Header

  - **Cookie / Set-Cookie：** 维持会话状态，是 CSRF 和会话劫持的核心。
  - **Referer / Origin：** 标识请求来源，常用于 CSRF 防御。
  - **User-Agent：** 客户端特征，常用于爬虫识别或漏洞精准投放。
  - **Content-Length / Transfer-Encoding：** 涉及 **HTTP 请求走私 (Request Smuggling)** 漏洞的关键字段。
  - **X-Forwarded-For：** 标识原始 IP（在经过代理/负载均衡时），常被用于绕过 IP 限制。
- 流程

  - 输入<http://www.baidu.com/123> 后 发生了：
  - DNS解析

    - 浏览器缓存——操作系统缓存——路由器缓存——ISP递归DNS。。。
    - 可能发生DNS劫持
  - 建立连接（TCP三次握手

    - **SYN:** 客户端：“你好，我想连接你（序号 x）。”
    - **SYN-ACK:** 服务端：“收到，我也准备好了（序号 y，确认号 x+1）。”
    - **ACK:** 客户端：“太好了，那我们开始吧（确认号 y+1）。”
  - 发送HTTP请求

    - ```
      GET /api/user HTTP/1.1
      Host: http://www.baidu.com/123
      Cookie: session_id=12345
      User-Agent: Mozilla/5.0...
- 服务器处理并返回响应

image-20211204165055568

OWASP TOP 10

XSS

CSRF

SSRF

SQL注入

密码学

AES

对称加密 V.S 非对称加密

image-20260110231254346

]]> https://l4n.top/2026/01/10/OWASP-TOP-10-%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C%E7%9B%B8%E5%85%B3/ 2026-01-10T10:10:17.000Z 协议

1. 引言

  • 所谓编译，就是高级语言转换为目标程序代码的过程
  • 分为五部分
    • 词法分析：分析源程序构成的字符串，转化为一个个的单词，留待下一步分析
    • 语法分析：根据语言语法规则，把单词合成语法单位，如句子等
    • 语义分析及IR的生成：根据第二步的语法分析，将其翻译成中间代码
      • 中间代码一般含义明确
    • 代码优化：这一步的任务是对第三步的中间代码进行等价变换，节省时间空间
    • 目标代码生成：中间代码变成特定机器上的机器代码

2. 形式语言理论基础

形式语言基本概念

形式语言，顾名思义，我们只关心语言的“形式”，不关心具体含义

  • 形式语言是一种不考虑含义的符号语言
  • 形式语言主要研究：如何用严谨的数学规则来定义、产生和识别字符串的集合

符号：语言中最小的不可再分的基本单位
符号串：符号的有序序列，空字符串记作ε （ε不是空格）
字母表：非空的有限集合，集合里是符号即字母表的元素
符号串集合：代表了利用字母表能拼凑出的所有可能的字符串

我们给出语言/形式语言的具体定义：
语言/形式语言：字母表上所有符号串组成的集合的子集，用L表示。

  • 语言是符号串集合的任意一个子集

符号串运算

  • 符号串相等：必须所有符号依次相等
  • 字符串长度：符号串中包含字符的长度
  • 符号串连接：ab*bc = abbc
  • 符号串的逆：倒置，abc -1 = cba ε-1 = ε
  • 符号串的前缀，后缀，字串：以abc举例
    • 前缀：ε a ab abc
    • 后缀：ε c bc abc
    • 子串：ε a b c ab bc abc
  • 符号串集合的乘积：A={ab，bc}，B={bc，b}
    • AB={abbc，abb，babc，bab}
    • {ε}A=A{ε}=A
  • 符号串的幂：ω0=ε；ω1=ω；ω2=ωω；……；ωn=ωn-1ω
    • ω=ab
      • ω0=ε
        • ω1=ab
          • ωn=abab……ab
  • 符号串集合的幂：A0={ε}；A1=A；……；An=An-1A=AAn-1 (n>0)
    • 例：A={ab, c}
    • A0={ε}，A1={ab, c}，A2={abc, cab, abab, cc}
  • 集合A的闭包和正闭包：
    • 闭包 (Closure) 指的是通过某种运算，将一个集合扩展到“包含所有可能结果”的完整状态。
    • 星闭包 A* =A0 ∪ A1 ∪ …… A+=AA*=A*A
    • 正闭包 A+=A1 ∪ A2 ∪ …… A*= A0 ∪ A+
    • 正闭包不包含空串

文法和语言的形式定义

再给一遍定义：

  • 语言：所有句子组成的集合，有限集：枚举，无限集：文法

  • 句子：抽象看成某个有限字符表上的字符串。

  • 文法：形式上描述和规定语言结构的方法，用有限的手段描述无限的句子集合的方法之一

    • 文法是一个四元组：
      • G=（VN，VT，S，P）记为G[S]。V是字汇表，V= VT∪VN，S∈VN，VT∩VN=Φ
      • Vt：终结符号集，字母，最终成果，不可以被分解替换
      • Vn：非终结符号集合，中间变量，用来推到最终句子
      • S：开始符号：推导起点，通过S一步步变换成最终的集合
      • P：产生式/规则集合：形式是U ::= X 代表U可以被改写成X

  • 巴斯克范式：

    • BNF文法（Backus-Naur Form），用来描述编程语言语法的一种数学表示法

    • <digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"<integer> ::= <digit> | <digit> <integer>

    • 第一行定义数字可以是0到9的任意一个

      • <符号> ::= <表达式>
      • <符号>（非终结符）：表示可以继续分解的概念（如“数字”、“运算符”）。
      • ::=：意思是“定义为”或“由…组成”。
      • <表达式>：包含终结符（直接出现的字符）和其他非终结符。
      • |：表示“或”，即多种可能的选择。

  • 句型：文法G[S]，G=（VN，VT，S，P）

    • 由S推出的符号串X∈(VT∪VN)*称为句型。
    • 推导 规约 | 箭头表示 箭头下加三角代表规约
      • A->a 是一个规则，p1=bAb p2=bab 所以p1直接推导出p2 p2直接规约到p1
      • 如果经过序列推导，那么就称为推导/规约，箭头上带个加号image-20260104135017006
      • 如果a可以推导b 或者a=b 那么称为a广义推导b，image-20260104134958248
      • 规范推导：每次替换最后边非终结符的直接推导 image-20260104135030549

  • 语言

    • 文法G 产生的语言L(G)
      • image-20260104135045264
    • 空语言：由文法开始符号推不出任何句子
    • 给定一个文法，就能从结构上唯一确定其语言，给定语言可以推出文法 但不唯一

语法树和二义性

image-20260104143554788

  • 子树
    • 简单子树：只有两层的树
    • 简单短语：简单子树的叶子节点

二义性：一个句子有两个不同的语法树

  • 若文法所定义的某个句子,有两种不同的最左(or最右) 推导/规约，则具有二义性
    • 最左/右推导/规约：每次选择最左/右的非终结符进行推导/规约
  • 二义性导致语义不确定性，句子一样，但是可以有两种语法解释
  • 解决
    • 修改编译算法
    • 修改文法，加入优先层等
  • 不存在一种算法在有限步内判断二义性
    • 在计算机科学中，我们无法写出一个通用的程序（算法），让它输入任意一个上下文无关文法（CFG），然后告诉我们这个文法“是”还是“不是”二义性的。
  • 规则左部的符号在右部同时出现两次 or 两次以上，导致二义性
    • 这里的“规则”指推导式（Production Rule）。如果一个非终结符（左部）在推导出的结果（右部）中出现了多次，且没有明确的优先级或结合律限制，就很容易产生二义性
  • 先天二义性文法
    • 如果一个上下文无关语言（CFL）的所有文法都是二义性的，那么这个语言就称为先天二义性语言，而生成该语言的文法即为先天二义性文法。
    • 如果一个语言 L，没有任何非二义性的文法可以生成它，那么 L 就是先天二义性的。

有害规则 多余规则

  • A->A 二义性
  • image-20260104153257598
  • image-20260104153641349

如果一个文法没有有害/多余规则 那么这个文法称为压缩 化简过的

扩充文法：image-20260104163358458

类似头节点

image-20260104163529585

这个是要确保每一个非终结符都要能够推出纯粹的终结符字符串

  • 首先去遍历产生式，把所有推出来全终结符的非终结符收起来
  • 然后递归，看谁能推出来上一步得到的集合U终结符集合构成的串。可以就加入 然后继续这一步骤
  • 最后删除掉不在Vn中的非终结符（清理多余规则

image-20260104164038545

这个要确保删掉那些从“开始符号”出发，无论如何也推导不到的符号和规则。

  • 从S开始推 递推找到所有有用的非终结符
  • 找完后 看哪些非终结符是没用的 直接删了

image-20260104164652486

这一步是要简化推导过程，删掉一些没啥用的中间规则，消除这类规则的目的是为了减少推导步骤，使文法更加简洁高效。

  • 依次对每一个非终结符A 构造一个集合 代表这个非终结符可以推到的非终结符
  • 然后看这个集合，假如这个集合中有元素可以推到句子，就直接加上A-句子 这个规则

image-20260104170252535

其目的是将文法中递推到空串的规则去掉，同时保证文法所定义的语言保持不变。

  • 和2.2差不多 首先找能推出空串的非终结符号 化成集合，然后递归找相关的扩充
  • 删去这些空规则
  • 然后在已有规则里找一下集合里的非终结符，全删掉
  • 扩充新规则，假如之前是A - BC 但是C推出来空 那么就改成A - BC | C

image-20260104170335688

在构建语法分析器（特别是自上而下的 LL 预测分析器）时，左递归会导致程序陷入死循环。为了解决这个问题，我们需要将左递归规则转换为等价的右递归规则。

  • 这个例子很明显了，首先如果不递归 左边一定是a
  • 那么我们先把a写好 再用一个A‘ 来完成后续的递归b

扩充BNF表示法

image-20260104173955136

可以用于消除左递归

文法和语言的Chomsky分类

  • 3型文法：正规文法，正则文法

    • 限制最严，规则左侧只能是一个非终结符，右侧必须是一个终结符/终结符后跟一个非终结符（左线性或右线性）
    • 对于每一个左(右)线性文法，都存在一个与某等价的右(左)线性文法
    • 与词法有关的文法一般属于3型文法

  • 2型文法：程序设计文法，上下文无关文法，下推自动机PDA

    • 左侧只能有一个非终结符，右侧可以是终结符和非终结符的任意组合。
    • 替换非终结符时不需要考虑前后字符
      • 描述语法结构
      • 可以描述栈，所以可以处理嵌套结构，构成下推自动机

  • 1型文法：上下文相关文法

    • 要求产生式右边字符串长度不小于左边，替换符号必须在特定上下文环境中进行
    • 线性有界自动机LBA

  • 0型文法：无限制文法，短语结构文法

    • 没有任何限制，左侧只要包含一个非终结符即可。
    • 递归可枚举语言
    • 图灵机

  • 0-3限制逐渐增加，描述语言能力逐渐减弱

    • 1型号不允许A-e 但是2-3允许

  • 四种语言可分别被四种自动机接收

image-20260104175137162

3.自动机理论基础

有限自动机

自动机从识别语言出发，定义了语言。自动机是具有离散输入/出系统的一种数学模型

  • 文法：是从产生语言的角度定义了语言。
  • 自动机理论：是编译程序词法分析的理论基础。

首先定义自动机

  • 状态转换图：定义在字母表上的有向图，满足三个初始条件：
    • image-20260104195119849
  • image-20260104202849834

可以用这个图识别句子：从开始状态到终止状态经过的边上的符号序列。

有限自动机FA

  • image-20260105132308984

    • 没有栈 没有寄存器，只存储当前状态
    • image-20260105142142547

  • 确定性有限自动机 DFA

  • 非确定性有限自动机 NFA

写到这里 我决定面向押题学习了

————————————————————分割线——————————————————————

FIRST FOLLOW集

一、 FIRST 集的求法

FIRST 集的意义是：从非终结符开始推导，可能出现在字符串开头的第一个终结符的集合。

image-20260106142934782

二、 FOLLOW 集的求法

FOLLOW 集的意义是：在某个句型中，紧跟在非终结符 A 后面可能出现的终结符的集合。

image-20260106142940871

image-20260106191615768

image-20260106200807972

image-20260107103959401

image-20260107104049991

image-20260107105640459

产生移进规约冲突 就不是LR0 直接SLR1 规约规约就看

image-20260107105835514

image-20260107105743885

image-20260107123417697

LL1：

先优化文法，然后求first follow select 然后画表格 然后对输入串进行求解

image-20260107132642591

DFA NFA

先优化表达式 然后画图，状态推导，最小化（小包大

LR0 SLR1

image-20260107132846824

SLR 先求follow集 再擦掉不在集里的r

image-20260107132831741

image-20260107133205604

LR1

image-20260107133359144

LALR 合并同心

]]> https://l4n.top/2026/01/02/%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86%E6%9C%9F%E6%9C%AB%E5%A4%8D%E4%B9%A0/ 2026-01-02T06:33:31.000Z 1. 引言
  • 所谓编译，就是高级语言转换为目标程序代码的过程
  • 分为五部分
    • 词法分析：分析]]>
编译原理期末复习 2026-09-02T15:48:21.808Z l4n 最近想重拾一下pwn，发现wsl环境炸了gdb起不来。加上杂七杂八的环境非常的杂乱，遂重装，顺便记录一下踩坑过程。

卸载

这个简单

1
2
wsl --list 
wsl --unregister Ubuntu-22.03

因为我之前已经设置了wsl的安装系统存储位置，如有需要请参照下面链接
Win10/11下安装WSL并修改WSL默认安装目录到其他盘_wsl设置默认路径-CSDN博客

重新安装

直接应用商店里安装即可

这里列一些wsl常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
wsl常用命令：
 查看WSL帮助：wsl --help
 更新WSL：wsl --update
 查看微软官方提供的子系统：wsl -l -o 或者 wsl --list --online 
 安装子系统：wsl --install -d Ubuntu-20.04
 设置Ubuntu20.04为默认子系统：wsl --set-default Ubuntu-20.04 或者 wsl -s Ubuntu-20.04
 将 wsl2 设为默认版本：wsl --set-default-version 2
 将 Ubuntu 设为 wsl2：wsl --set-version ubuntu 2
 查看状态，包括当前的默认子系统是哪个、wsl 的版本是 1 还是 2、内核版本等：wsl --status
 查看详细信息，包括安装了哪些子系统、子系统的运行状态、wsl1 还是 wsl2：wsl --list --verbose  // 可简写为 wsl -l -v，非常常用！
 直接运行子系统命令：wsl -d ubuntu ls // 如果是在默认子系统中运行命令，可省略 -d <Distro>，例如：wsl ls
 关闭某个子系统：wsl --terminate <Distro> // --terminate 可简写为 -t，<Distro> 不能省。// 例如，关闭 Ubuntu：wsl -t ubuntu
 关闭所有子系统： wsl --shutdown
 卸载某个子系统：wsl --unregister <Distro> // 例如，卸载 Ubuntu：wsl --unregister ubuntu

基本环境配置

设置默认root登录 （或者你可以在wsl.conf里配置）

1
ubuntu2204.exe config --default-user root

换源

1
vim /etc/apt/sources.list

写入

1
2
3
4
5
6
7
8
9
10
11
12
13
# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-security main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-security main restricted universe multiverse
 
# 预发布软件源，不建议启用
# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse

更新

1
2
sudo apt-get update
sudo apt-get upgrade

安装zsh 与oh-my-zsh全套美化

1
2
3
4
5
sudo apt install zsh

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" 

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

设置默认终端为zsh

1
chsh -s /bin/zsh

安装编译工具链

1
sudo apt install build-essential

安装conda

我选择miniconda 比较轻量
可以直接看官方文档
Installing Miniconda - Anaconda

也可以看下面的

1
2
3
4
5
6
mkdir -p ~/miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh
source ~/miniconda3/bin/activate
conda init --all

换源

1
2
3
4
5
6
7
8
9
10
#设置清华镜像
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/
#设置bioconda
conda config --add channels bioconda
conda config --add channels conda-forge
#设置搜索时显示通道地址
conda config --set show_channel_urls yes

创建虚拟环境

1
conda create -n env_name python=3.12

启用虚拟环境/查询虚拟环境

1
2
conda env list
conda activate xxx

pip换源

1
2
3
4
5
6
7
8
9
10
# 清华源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
# 阿里源
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
# 腾讯源
pip config set global.index-url http://mirrors.cloud.tencent.com/pypi/simple
# 豆瓣源
pip config set global.index-url http://pypi.douban.com/simple/
# 换回默认源
pip config unset global.index-url
]]> https://l4n.top/2025/07/23/wsl-ubuntu-%E4%B8%AA%E4%BA%BA%E7%8E%AF%E5%A2%83%E9%85%8D%E7%BD%AE%E6%8C%87%E5%8D%97/ 2025-07-23T14:36:19.000Z 最近想重拾一下pwn，发现wsl环境炸了gdb起不来。加上杂七杂八的环境非常的杂乱，遂重装，顺便记录一下踩坑过程。

卸载

这个简单<]]>

wsl-ubuntu 个人环境配置指南 2026-09-02T16:35:34.283Z l4n 寄存器间接跳转的基本概念

寄存器存储地址：寄存器间接跳转依赖于寄存器内的值来指定要跳转到的地址，而这个地址可以在程序运行时动态改变。
跳转指令：在汇编语言中，类似于 jmp eax 或 br x8 的指令，使用寄存器（如 eax, x8 等）存储目标地址，执行这些指令后，程序的控制流就会转移到寄存器中的指定地址。
作为混淆，这种基于寄存器间接跳转的混淆会使反编译器无法正常识别代码逻辑
那么为了能够看清程序的逻辑，我们需要对这玩意进行修复。

简单的处理思路

大部分的间接跳转将用于计算地址的值储存在data段，而反编译器不会去解析data段的常量。这是因为在反编译器的预设中，data段是默认可写的。这时被引用的值被视为变量，就不会进行常量传播优化。
如果我们将data段的属性改为只读，可以促进反编译器的常量传播，去除一部分混淆。

自动化一点的进阶思路

一个比较常规的思路是用模拟执行框架来解出跳转时对应寄存器存储的具体值，然后进行patch去除。这里我选择了使用unicorn，当然 angr/qiling等框架应该也是可以的，只是作为初学者我不太会写，还是unicorn写着顺手。

实例：N1CTF junior easy-re

是一个arm64的elf，有间接跳转和字符串混淆。字符串混淆可以通过unicorn 内存写入trace简单的过掉。这里只讨论如何去除间接跳转混淆。
一个具体的汇编代码片段例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
loc_1E60                                ; CODE XREF: sub_1FD4+2C↓j
LDR             W8, [SP,#0x1C0+var_140] ; Load from Memory
MOV             W9, #2                  ; Rd = Op2
MOV             W10, #0                 ; Rd = Op2
CMP             W8, #0x100              ; Set cond. codes on Op1 - Op2
CSEL            W8, W9, W10, LT         ; Conditional Select
MOV             W11, W8                 ; Rd = Op2
SXTW            X11, W11                ; Signed Extend Word
MOV             X12, #8                 ; Rd = Op2
MUL             X11, X12, X11           ; Multiply
LDR             X12, [SP,#0x1C0+var_190] ; Load from Memory
ADD             X11, X12, X11           ; Rd = Op1 + Op2
LDR             X11, [X11]              ; Load from Memory
MOV             W8, #0x464CA149
LDR             W9, [SP,#0x1C0+var_19C] ; Load from Memory
SUBS            W8, W8, W9              ; Rd = Op1 - Op2
MOV             W13, W8                 ; Rd = Op2
SXTW            X13, W13                ; Signed Extend Word
ADD             X11, X11, X13           ; Rd = Op1 + Op2
BR              X11                     ; Branch To Register

可以发现很明显的特征代码块：

1
2
3
4
5
6
mov x1 #x
mov x2 #x
...
cslr xx x1 x2 eq 
...
br xx

基于这样的特征，我们可以在初始化的时候，使用模式匹配遍历.text .initarray等代码段。然后将mov的地址，br的地址（cslr地址）存入一个要去执行的list里。在遍历完后，循环分别处理每一段地址作为参数传入模拟执行函数。

假设我们已经识别了所有的指令，现在要做的就是如何去除。
如果优化掉后面的查表计算等操作，将前面的值分别确定，模拟执行拿到数据后，就可以直接patch成正常的跳转，自然可以被正常的反编译。
于是我们的思路有了，具体拆成以下几个部分来分别实现。

  1. patch cslr 为 mov xx1/mov xx2
  2. 依据不明确取值的寄存器，向上溯回拿到值，模拟执行后拿到后续br的值
  3. patch掉 mov下标 cslr 查表 计算地址 brxx
  4. cmp xx后，逻辑patch为 b xx1 和 b xx2

一步一步完成吧。

step1 按照不同跳转分支进行信息搜集

先拿到cslr指令和操作数，然后依据对应的操作数，拿到mov指令的形状后，patch，分为两个分支模拟执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
saved_state = {}
def save_state(mu):
    regs = {}
    regs_list = [
        UC_ARM64_REG_X0, UC_ARM64_REG_X1, UC_ARM64_REG_X2, UC_ARM64_REG_X3,
        UC_ARM64_REG_X4, UC_ARM64_REG_X5, UC_ARM64_REG_X6, UC_ARM64_REG_X7,
        UC_ARM64_REG_X8, UC_ARM64_REG_X9, UC_ARM64_REG_X10, UC_ARM64_REG_X11,
        UC_ARM64_REG_X12, UC_ARM64_REG_X13, UC_ARM64_REG_X14, UC_ARM64_REG_X15,
        UC_ARM64_REG_X16, UC_ARM64_REG_X17, UC_ARM64_REG_X18, UC_ARM64_REG_X19,
        UC_ARM64_REG_X20, UC_ARM64_REG_X21, UC_ARM64_REG_X22, UC_ARM64_REG_X23,
        UC_ARM64_REG_X24, UC_ARM64_REG_X25, UC_ARM64_REG_X26, UC_ARM64_REG_X27,
        UC_ARM64_REG_X28, UC_ARM64_REG_X29, UC_ARM64_REG_X30, UC_ARM64_REG_SP,
        UC_ARM64_REG_PC
    ]
    for reg in regs_list:
        regs[reg] = mu.reg_read(reg)
    return regs

def restore_state(mu, regs):
    for reg, val in regs.items():
        mu.reg_write(reg, val)

def branch_hook(mu, addr, size, user_data):
    # 对当前指令反汇编，若遇到BR指令则终止模拟
    for inst in cs.disasm(mu.mem_read(addr, size), addr):
        if inst.mnemonic.lower() == "br":
            print(">>> BR 指令在 0x%x 被触发，停止模拟" % addr)
            mu.emu_stop()
            break
    return 

pass_addr = [0x24A8,0x24AC,0x1E20]

csel_handled = False
def hook_code(mu, address, size, user_data): 
    global save_state , csel_handled
    if address in LIBC_FUNCS:
        print(">>> Entering simulated library function at 0x%x" % address)
        LIBC_FUNCS[address](mu)
        return
    
    # if address in pass_addr:# 修改类似eip的寄存器来跳过这两个地址
    #     mu.reg_write(UC_ARM64_REG_PC, address+size)
    #     print('>>> Skipping address 0x%x' % address)
    
    # print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' % (address, size))
    # 打印汇编代码
    for inst in cs.disasm(mu.mem_read(address, size), address):
        print("0x%x:\t%s\t%s" % (inst.address, inst.mnemonic, inst.op_str))
        #如果当前指令是CSEL
        if inst.mnemonic.lower() == "csel" and not csel_handled:
            print(">>> csel detected")
            csel_handled = True
            csel_addr = address
            original_bytes = mu.mem_read(csel_addr, size)
            saved_state = save_state(mu)#保存当前状态
            #获取操作寄存器
            op = inst.op_str.split(", ")
            #组装mov指令
            mov_inst1 = "mov " + op[0] + ", " + op[1] +';'
            mov_inst2 = "mov " + op[0] + ", " + op[2] +';'
            # print('>>> mov instructions:', mov_inst1, mov_inst2)
            #编译mov指令
            asm_mov_x1_x2, _ = ks.asm(mov_inst1)
            asm_mov_x1_x3, _ = ks.asm(mov_inst2)
            # print('there')
            #定义内部函数，用于进行两次patch
            def run_branch_test(patch_bytes, branch_label):
                # patch 当前 csel 指令位置
                mu.mem_write(csel_addr, bytes(patch_bytes))
                print(f">>> 已将 csel 指令 patch 为 {branch_label}，开始执行至遇到 BR 指令")
                # 添加一个临时 hook 来检测 BR 指令
                bh_id = mu.hook_add(UC_HOOK_CODE, branch_hook)
                try:
                    mu.emu_start(mu.reg_read(UC_ARM64_REG_PC), END_POINT)
                except UcError as e:
                    print("模拟过程中出现错误:", e)
                mu.hook_del(bh_id)
                state = save_state(mu)
                print(">>> 运行结束后状态:", state)
                return state
            
            # 首先用 mov x1, x2 运行
            state_branch1 = run_branch_test(asm_mov_x1_x2, "mov x1, x2")
            # 恢复现场
            restore_state(mu, saved_state)
            # 然后用 mov x1, x3 运行
            state_branch2 = run_branch_test(asm_mov_x1_x3, "mov x1, x3")
            print(">>> 分别 patch 后两条分支的最终状态:")
            print("    mov x1, x2 状态:", hex(state_branch1[UC_ARM64_REG_X8]))
            print("    mov x1, x3 状态:", hex(state_branch2[UC_ARM64_REG_X8]))

step2 模拟执行，获取最终跳转值

已经有了模拟执行的框架，这里就直接写一个方法去拿到相关的指令储存起来

那么有小伙伴就要问了，如何拿到相关的指令呢？这里其实可以注意到，这段混淆实际上是通过先取立即数和地址，然后存入栈，在后续重新从栈上拿回地址。所以我们可以在范围内遍历有关sp的指令，然后确定偏移，向上溯回，找到所有对改位置进行写入的寄存器。通过跟踪这些寄存器，我们就能拿到相应的赋值指令，进而在后续模拟执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def hit_hook(self, mu: Uc, addr: int, size: int, user_data) -> None:
        """
        代码 hook，用于捕获并存储 hit 指令（通过向上追踪含 SP 且 ldr 指令）。
        """
        
        try:
            code = mu.mem_read(addr, size)
        except UcError:
            return

        for inst in self.cs.disasm(code, addr):
            # print(f"hit hook : >>> {hex(addr)} {inst.mnemonic} {inst.op_str}")
            if inst.mnemonic.lower() == "br":
                mu.emu_stop()
                break
            if inst.mnemonic.lower() == "stur" or inst.mnemonic.lower() == "ldur":
                self.mu.reg_write(UC_ARM64_REG_PC, addr + size)
                # print(f">>> stur or ldur detected, skip")
                return
            if "sp" in inst.op_str and "ldr" in inst.mnemonic:
                # print(f"attached ldr sp instruction: {inst.mnemonic} {inst.op_str}")
                parts = inst.op_str.split(", [")
                target = parts[0] if "sp" in parts[0] else parts[1]
                target_state = False
                target2 = ""
                curr_addr = addr
                for _ in range(1, 200):
                    curr_addr -= inst.size
                    try:
                        code_b = mu.mem_read(curr_addr, 4)
                    except UcError:
                        continue
                    for inst_b in self.cs.disasm(code_b, curr_addr):
                        if target in inst_b.op_str and "ldr" not in inst_b.mnemonic and not target_state:
                            # print(f"hit instruction: {inst_b.mnemonic} {inst_b.op_str}")
                            target_state = True
                            self.hit_inst.append(inst_b)
                            parts_b = inst_b.op_str.split(", ")
                            target2 = parts_b[0] if target not in parts_b[0] else parts_b[1]
                            break
                        if target_state and target2 in inst_b.op_str and "mov" in inst_b.mnemonic and '#0x' in inst_b.op_str:
                            self.hit_inst.append(inst_b)
                        if target_state and target2 in inst_b.op_str and 'adr' in inst_b.mnemonic:
                            # print(f"hit instruction: {inst_b.mnemonic} {inst_b.op_str}")
                            if "adrp" in inst_b.mnemonic:
                                try:
                                    next_code = mu.mem_read(curr_addr + inst_b.size, 4)
                                except UcError:
                                    continue
                                for inst_el in self.cs.disasm(next_code, curr_addr + inst_b.size):
                                    if "add" in inst_el.mnemonic:
                                        self.hit_inst.append(inst_el)
                                        self.hit_inst.append(inst_b)
                            else:
                                self.hit_inst.append(inst_b)
        return

    def branch_hook(self, mu: Uc, addr: int, size: int, user_data) -> None:
        """
        当执行到 BR 指令时停止模拟
        """
        try:
            code = mu.mem_read(addr, size)
        except UcError:
            return

        for inst in self.cs.disasm(code, addr):
            if inst.mnemonic.lower() == "br":
                # print(f">>> BR 指令在 0x{addr:x} 被触发，停止模拟")
                mu.emu_stop()
                break
    
    def get_hit_inst(self, addr: int) -> None:
        """
        从指定地址向后模拟收集 hit 指令
        """
        # print(f">>> Getting hit instructions from 0x{addr:x} to 0x{self.inst_br_addr_temp:x}")
        bh_id = self.mu.hook_add(UC_HOOK_CODE, self.hit_hook)
        self.mu.hook_del(self.hook_code_id)
        # 搜寻前面的有没有立即数存储指令
        for i in range(1, 50):
            try:
                code = self.mu.mem_read(addr - i * 4, 4)
            except UcError:
                continue
            for inst in self.cs.disasm(code, addr - i * 4):
                # print(f"get_hit_inst : >>> {hex(addr - i * 4)} {inst.mnemonic} {inst.op_str}")
                if ("mov" in inst.mnemonic or "ldr" in inst.mnemonic ) and '#' in inst.op_str:
                    self.hit_inst.append(inst)
        
        try:
            self.mu.emu_start(addr - 4, self.inst_br_addr_temp)
        except UcError as e:
            print("模拟过程中出现错误:", e)
            self.err_flag = True
            self.err_addr.append((self.inst_mov_addr_temp, self.inst_br_addr_temp,"error at get_hit_inst:", e))
        self.mu.hook_del(bh_id)
        self.hook_code_id = self.mu.hook_add(UC_HOOK_CODE, self.hook_code)
        # print("\n>>> Hit instructions:")
        # for inst in self.hit_inst:
        #     print(f"    0x{inst.address:x}: {inst.mnemonic} {inst.op_str}")

    def run_hit_inst(self) -> None:
        """
        只模拟 hit 指令（hit_inst 列表中的指令）。
        """
        # print(">>> Running hit instructions")
        original_pc = self.mu.reg_read(UC_ARM64_REG_PC)
        for inst in reversed(self.hit_inst):
            
            try:
                self.mu.emu_start(inst.address, inst.address + inst.size)
            except UcError as e:
                print("run_hit_inst 模拟出现错误:", e)
                self.err_flag = True
                self.err_addr.append((self.inst_mov_addr_temp, self.inst_br_addr_temp, "error at run_hit_inst:", e))
        self.mu.reg_write(UC_ARM64_REG_PC, original_pc)

在unicorn加载的时候，没有load .data段到正确的地方，导致在.data段上的值无法被正确的读取。我们可以使用lief对文件进行解析，分别计算出对应section的虚拟地址和正确的patch地址，然后代替直接将整个文件加载，把对应的段分别正确的映射到unicorn的虚拟内存里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
"""
        利用 LIEF 解析 ELF 文件，将各 section 映射到 Unicorn 内存中。
        """
        binary = lief.parse(self.binary_path)
        mapped = {}  # 已映射区域字典

        for section in binary.sections:
            vaddr = section.virtual_address
            mem_size = section.size
            if mem_size == 0 or vaddr == 0:
                continue
            if section.name == ".text":
                self.text_section = section
            start_addr = (vaddr // self.PAGE_SIZE) * self.PAGE_SIZE
            end_addr = ((vaddr + mem_size + self.PAGE_SIZE - 1) // self.PAGE_SIZE) * self.PAGE_SIZE
            map_size = end_addr - start_addr

            if start_addr not in mapped:
                try:
                    self.mu.mem_map(start_addr, map_size)
                    mapped[start_addr] = map_size
                except UcError as e:
                    print(f"映射地址{section.name} 0x{start_addr:x}（大小 0x{map_size:x}）失败: {e}")
                    continue

            if section.content:
                data = bytes(section.content)
                offset = vaddr - start_addr
                try:
                    self.mu.mem_write(start_addr + offset, data)
                except UcError as e:
                    print(f"写入数据到地址 0x{start_addr+offset:x} 失败: {e}")

跑一下发现，虽然有几个段没有成功映射，但大部分段都成功的加载了。

step3 使用上一步的值进行Patch

获取了正确的跳转地址后，我们就可以想想如何去patch逻辑了。
再看看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
loc_1E60                                ; CODE XREF: sub_1FD4+2C↓j
LDR             W8, [SP,#0x1C0+var_140] ; Load from Memory
MOV             W9, #2                  ; Rd = Op2
MOV             W10, #0                 ; Rd = Op2
CMP             W8, #0x100              ; Set cond. codes on Op1 - Op2
CSEL            W8, W9, W10, LT         ; Conditional Select
MOV             W11, W8                 ; Rd = Op2
SXTW            X11, W11                ; Signed Extend Word
MOV             X12, #8                 ; Rd = Op2
MUL             X11, X12, X11           ; Multiply
LDR             X12, [SP,#0x1C0+var_190] ; Load from Memory
ADD             X11, X12, X11           ; Rd = Op1 + Op2
LDR             X11, [X11]              ; Load from Memory
MOV             W8, #0x464CA149
LDR             W9, [SP,#0x1C0+var_19C] ; Load from Memory
SUBS            W8, W8, W9              ; Rd = Op1 - Op2
MOV             W13, W8                 ; Rd = Op2
SXTW            X13, W13                ; Signed Extend Word
ADD             X11, X11, X13           ; Rd = Op1 + Op2
BR              X11                     ; Branch To Register

cslr之后，所有的计算基本都是对最终br的寄存器进行地址计算，而事实上我们已经有了这些值，就不需要再进行这些计算了。
先设计一下应该执行的指令：

1
2
3
4
5
6
7
8
9
10
MOV             W9, #2                  ; Rd = Op2
MOV             W10, #0                 ; Rd = Op2
CMP             W8, #0x100              ; Set cond. codes on Op1 - Op2
CSEL            W8, W9, W10, LT         ; Conditional Select
...
cmp             w8, w9            
beq             addr1 ; 等于就跳转，即第一种情况                  
bne             addr2   ; 不等就跳转，即第二种情况          
...
BR              reg    ; patch到这里

注意到，CMP后的指令顺序是不变的，而且cmp的结果就决定了后续跳转的地址。所以我们可以拿下面的固定不变指令来做一点文章。
如果我们设计为：

1
2
3
4
5
6
7
8
nop < mov x1 #r
nop < mov x2 #i
...
cmp   xx #0
br.ne addr1
br    addr2
nop
...

就可以完成这些工作。但是有一个问题是，如果过早jmp，br后面的代码对于之后程序的执行可能会有一定影响。
所以我们要进行指令前移，在所有其余指令执行完后，再进行br操作。
如何实现指令前移呢？观察代码。在一些混淆中，br之前做了一些常量保存工作，如果贸然nop掉会导致后续指令无法执行。
所以我们可以采取这样的做法

  1. 遍历cslr到br间的所有指令，取出str指令
  2. 将str指令上移
  3. patch跳转指令，然后nop掉剩余的所有指令

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
def patch_br(self) -> None:
    """
        扫描 self.csel_addr_temp 到 self.inst_br_addr_temp 区间内的所有指令，
        记录所有 STR 指令，将所有 STR 指令上移，其余指令下移，
        重新构造新的指令序列：首先放置所有 STR 指令，
        然后是两条分支指令，
        剩余空间填充 NOP 指令，
        最后将组装好的字节补丁写入内存。
        """

    all_insts = []   # 保存区间内所有(地址, 指令)元组
    str_insts = []   # 保存STR类型指令

    addr_start = self.csel_addr_temp 
    for addr in range(addr_start, self.inst_br_addr_temp, 4):
        try:
            code = self.mu.mem_read(addr, 4)
        except UcError:
            continue
            for inst in self.cs.disasm(code, addr):
                all_insts.append((addr, inst))
                if "str" in inst.mnemonic.lower():
                    str_insts.append((addr, inst))

        print(">>> 扫描到的所有指令:")
    for addr, inst in all_insts:
        print(f"    0x{addr:x}: {inst.mnemonic} {inst.op_str}")
        print(">>> 其中 STR 指令:")
    for addr, inst in str_insts:
        print(f"    0x{addr:x}: {inst.mnemonic} {inst.op_str}")

        # 构造新的指令序列
        new_inst_list = []
    # (1) 添加所有 STR 指令（以其原有汇编文本为准）
    for _, inst in str_insts:
        asm_line = f"{inst.mnemonic} {inst.op_str}"
        new_inst_list.append(asm_line)

        # (2) 添加两条跳转指令（分支指令），这里假定 self.br_value 存储了两个跳转目标
        # 构造分支指令文本（注意汇编语法，根据实际需要可能调整条件代码）

        b_inst1 = "b.ne #" + hex(self.br_value[0] - self.csel_addr_temp - len(str_insts)*4)
    b_inst2 = "b #" + hex(self.br_value[1] - self.csel_addr_temp - len(str_insts)*4 - 4)
    for i in range(2):
        print(f"    0x{self.inst_br_addr_temp + i * 4:x}: {b_inst1 if i == 0 else b_inst2}")
        new_inst_list.append(b_inst1)
    new_inst_list.append(b_inst2)

    # 使用 Keystone 汇编生成机器码，并计算补丁区域大小
    patch_bytes = b""
    for asm_line in new_inst_list:
        try:
            encoding, _ = self.ks.asm(asm_line)
            patch_bytes += bytes(encoding)
        except Exception as e:
            print(f"组装指令失败 {asm_line}: {e}")

        # 计算目标区域可用字节数
        region_size = self.inst_br_addr_temp - self.csel_addr_temp
    current_size = len(patch_bytes)
    print(f"累计补丁字节长度: {current_size}, 目标区域大小: {region_size}")

    # (3) 如果不足，填充 NOP 指令（ARM64 的 nop 固定4字节）
    if current_size < region_size:
        remaining = region_size - current_size
        nop_count = remaining // 4  # 每个 nop 占4字节
        for _ in range(nop_count):
            try:
                encoding, _ = self.ks.asm("nop")
                patch_bytes += bytes(encoding)
            except Exception as e:
                print(f"组装 nop 失败: {e}")
        # 如果超过目标区域，根据需要截断（不要溢出）
        if len(patch_bytes) > region_size:
            patch_bytes = patch_bytes[:region_size]

    print(">>> 重新组装后的补丁字节:")
    print(patch_bytes.hex())

    # 将生成的补丁字节写入内存（写回到原区域起始处）
        self.patch_code(addr_start, patch_bytes)
        
        print(">>> 重写区域内指令:")
        for addr in range(addr_start, self.inst_br_addr_temp, 4):
            try:
                code = self.mu.mem_read(addr, 4)
            except UcError:
                continue
            for inst in self.cs.disasm(code, addr):
                print(f"    0x{addr:x}: {inst.mnemonic} {inst.op_str}")

至此，我们完成了所有的工作。再加上亿点小小的细节，添加一下注释和批量优化，就是完整的实现代码

Final：完整实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
import lief
from unicorn import Uc, UcError, UC_ARCH_ARM64, UC_MODE_ARM, UC_HOOK_CODE
from unicorn.arm64_const import *
from capstone import Cs, CS_ARCH_ARM64, CS_MODE_ARM
from keystone import Ks, KS_ARCH_ARM64, KS_MODE_LITTLE_ENDIAN
from pwn import u32

class Arm64ELFSimulator:
    # Configuration constants
    STACK_ADDR = 0x100000
    STACK_SIZE = 1024 * 1024
    PAGE_SIZE = 0x1000# Must be a divisor of the mapped sizes
    BASE_ADDR = 0x0
    ENTRY_POINT = 0x0
    END_POINT = 0x0
    
    # Mapping of register names to Unicorn constants
    regs_dic = {
        "x0": UC_ARM64_REG_X0, "x1": UC_ARM64_REG_X1, "x2": UC_ARM64_REG_X2, "x3": UC_ARM64_REG_X3,
        "x4": UC_ARM64_REG_X4, "x5": UC_ARM64_REG_X5, "x6": UC_ARM64_REG_X6, "x7": UC_ARM64_REG_X7,
        "x8": UC_ARM64_REG_X8, "x9": UC_ARM64_REG_X9, "x10": UC_ARM64_REG_X10, "x11": UC_ARM64_REG_X11,
        "x12": UC_ARM64_REG_X12, "x13": UC_ARM64_REG_X13, "x14": UC_ARM64_REG_X14, "x15": UC_ARM64_REG_X15,
        "x16": UC_ARM64_REG_X16, "x17": UC_ARM64_REG_X17, "x18": UC_ARM64_REG_X18, "x19": UC_ARM64_REG_X19,
        "x20": UC_ARM64_REG_X20, "x21": UC_ARM64_REG_X21, "x22": UC_ARM64_REG_X22, "x23": UC_ARM64_REG_X23,
        "x24": UC_ARM64_REG_X24, "x25": UC_ARM64_REG_X25, "x26": UC_ARM64_REG_X26, "x27": UC_ARM64_REG_X27,
        "x28": UC_ARM64_REG_X28, "x29": UC_ARM64_REG_X29, "x30": UC_ARM64_REG_X30,
        "sp": UC_ARM64_REG_SP, "pc": UC_ARM64_REG_PC
    }
    reg_list = list(regs_dic.values())
    
    def __init__(self, binary_path: str):
        # Initialize Unicorn, Capstone, Keystone
        self.mu = Uc(UC_ARCH_ARM64, UC_MODE_ARM)
        try:
            self.mu.mem_map(self.STACK_ADDR, self.STACK_SIZE)
        except UcError as e:
            print(f"映射栈空间失败: {e}")
        self.mu.reg_write(UC_ARM64_REG_SP, self.STACK_ADDR + self.STACK_SIZE - 100)
        self.binary_path = binary_path

        self.cs = Cs(CS_ARCH_ARM64, CS_MODE_ARM)
        self.ks = Ks(KS_ARCH_ARM64, KS_MODE_LITTLE_ENDIAN)

        # Simulation state
        self.hit_inst = []
        self.csel_handled = False
        self.csel_handled = []
        self.err_addr = []

        # Load ELF sections and record .text section for later analysis
        self.text_section = None
        self.load_elf_sections()

        # 初始化预置寄存器及临时变量
        self.mu.reg_write(UC_ARM64_REG_X9, 0x7B6C5B9A)
        self.inst_mov_addr_temp = 0
        self.inst_br_addr_temp = 0
        self.br_reg = 0
        self.csel_addr_temp = 0
        self.csel_args = (0,0,0)
        self.br_value = (0,0)
        self.err_flag = False

    def load_elf_sections(self) -> None:
        """
        利用 LIEF 解析 ELF 文件，将各 section 映射到 Unicorn 内存中。
        """
        binary = lief.parse(self.binary_path)
        mapped = {}  # 已映射区域字典

        for section in binary.sections:
            vaddr = section.virtual_address
            mem_size = section.size
            if mem_size == 0 or vaddr == 0:
                continue
            if section.name == ".text":
                self.text_section = section
            start_addr = (vaddr // self.PAGE_SIZE) * self.PAGE_SIZE
            end_addr = ((vaddr + mem_size + self.PAGE_SIZE - 1) // self.PAGE_SIZE) * self.PAGE_SIZE
            map_size = end_addr - start_addr

            if start_addr not in mapped:
                try:
                    self.mu.mem_map(start_addr, map_size)
                    mapped[start_addr] = map_size
                except UcError as e:
                    print(f"映射地址{section.name} 0x{start_addr:x}（大小 0x{map_size:x}）失败: {e}")
                    continue

            if section.content:
                data = bytes(section.content)
                offset = vaddr - start_addr
                try:
                    self.mu.mem_write(start_addr + offset, data)
                except UcError as e:
                    print(f"写入数据到地址 0x{start_addr+offset:x} 失败: {e}")

    def patch_elf_sections(self, output_file: str) -> None:
        """
        从 Unicorn 内存中提取所有映射成功的段内容，然后将这些数据
        patch 回 ELF 文件，并写入到 output_file 中。
        """
        # 通过 LIEF 重新解析原始 ELF 文件
        elf = lief.parse(self.binary_path)
        
        for section in elf.sections:
            if section.name == ".text" or section.name == ".initarray" or section.name == ".finiarray":
                
                vaddr = section.virtual_address
                mem_size = section.size
                if mem_size == 0 or vaddr == 0:
                    continue
                # 根据 PAGE_SIZE 计算映射的起始地址和实际偏移量
                start_addr = (vaddr // self.PAGE_SIZE) * self.PAGE_SIZE
                offset = vaddr - start_addr
                try:
                    # 从 Unicorn 内存中读取 section 内容，读取大小为 section.size
                    new_content = self.mu.mem_read(start_addr + offset, mem_size)
                    # LIEF 要求 section.content 为列表形式
                    section.content = list(new_content)
                    print(f"Section {section.name} 更新成功, vaddr: 0x{vaddr:x}, size: {mem_size}")
                except UcError as e:
                    print(f"读取段 {section.name} 内存失败: {e}")
            else :
                continue

        try:
            elf.write(output_file)
            print(f"已将修补后的 ELF 写入到: {output_file}")
        except Exception as e:
            print(f"写入补丁 ELF 失败: {e}")
    
    def find_reg_jmp_addr(self) -> list:
        """
        遍历 .text 段寻找寄存器间接跳转地址，返回 tup( mov_addr, br_addr, reg) 列表。
        """
        reg_jmp_addr = []
        addr = self.text_section.virtual_address
        while addr < self.text_section.virtual_address + self.text_section.size:
            mov_addr = self.find_mov(addr)
            if mov_addr:
                br_addr, reg = self.find_br(mov_addr)
                if br_addr:
                    reg_jmp_addr.append((mov_addr, br_addr, reg))
                    addr = br_addr
            addr += 4
        return reg_jmp_addr

    def find_mov(self, addr: int) -> int:
        """
        搜索连续两条带立即数的 mov 指令，
        返回目标 mov 指令的地址，未找到则返回 0。
        """
        try:
            code = self.mu.mem_read(addr, 4)
        except UcError:
            print(f">>> read error at find_mov: {hex(addr)}")
            return 0

        for inst in self.cs.disasm(code, addr):
            if inst.mnemonic == "mov" and '#' in inst.op_str:
                addr += 4
                try:
                    code2 = self.mu.mem_read(addr, 4)
                except UcError:
                    print(f">>> read error at find_mov: {hex(addr)}")
                    continue
                for inst_b in self.cs.disasm(code2, addr):
                    if inst_b.mnemonic == "mov" and '#' in inst_b.op_str:
                        return addr
        return 0

    def find_br(self, addr: int) -> tuple:
        """
        向后搜索 'br' 指令，返回 (addr, operand) 元组，
        未找到时返回 (0, 0)。
        """
        for _ in range(1, 100):
            try:
                code = self.mu.mem_read(addr, 4)
            except UcError:
                print(f">>> read error at find_br: {hex(addr)}")
                addr += 4
                continue
            for inst in self.cs.disasm(code, addr):
                if inst.mnemonic == "br":
                    return addr, inst.op_str
            addr += 4
        print(f">>> find_br 未找到, addr: {hex(addr - 400)}")
        return 0, 0

    def print_regs(self) -> None:
        """ 打印当前所有寄存器的值 """
        print(">>> Registers:")
        for name, reg in self.regs_dic.items():
            print(f"    {name} = 0x{self.mu.reg_read(reg):x}")

    def print_stack_sp(self) -> None:
        """ 打印当前栈区域的部分内容 """
        sp = self.mu.reg_read(UC_ARM64_REG_SP)
        print(">>> Stack:")
        for i in range(0, 32, 4):
            try:
                data = self.mu.mem_read(sp + i, 4)
                print(f"    0x{sp + i:x}: {u32(data):x}")
            except UcError:
                print(f"    0x{sp + i:x}: ???")
        print("")

    def save_state(self) -> dict:
        """ 保存当前寄存器状态 """
        return {reg: self.mu.reg_read(reg) for reg in self.reg_list}

    def restore_state(self, state: dict) -> None:
        """ 恢复寄存器状态 """
        for reg, value in state.items():
            self.mu.reg_write(reg, value)

    def clear_state(self) -> None:
        """ 清空所有寄存器，并重置 csel 标志 """
        self.csel_handled = False
        for reg in self.reg_list:
            self.mu.reg_write(reg, 0)

    def hit_hook(self, mu: Uc, addr: int, size: int, user_data) -> None:
        """
        代码 hook，用于捕获并存储 hit 指令（通过向上追踪含 SP 且 ldr 指令）。
        """
        
        try:
            code = mu.mem_read(addr, size)
        except UcError:
            return

        for inst in self.cs.disasm(code, addr):
            # print(f"hit hook : >>> {hex(addr)} {inst.mnemonic} {inst.op_str}")
            if inst.mnemonic.lower() == "br":
                mu.emu_stop()
                break
            if inst.mnemonic.lower() == "stur" or inst.mnemonic.lower() == "ldur":
                self.mu.reg_write(UC_ARM64_REG_PC, addr + size)
                # print(f">>> stur or ldur detected, skip")
                return
            if "sp" in inst.op_str and "ldr" in inst.mnemonic:
                # print(f"attached ldr sp instruction: {inst.mnemonic} {inst.op_str}")
                parts = inst.op_str.split(", [")
                target = parts[0] if "sp" in parts[0] else parts[1]
                target_state = False
                target2 = ""
                curr_addr = addr
                for _ in range(1, 200):
                    curr_addr -= inst.size
                    try:
                        code_b = mu.mem_read(curr_addr, 4)
                    except UcError:
                        continue
                    for inst_b in self.cs.disasm(code_b, curr_addr):
                        if target in inst_b.op_str and "ldr" not in inst_b.mnemonic and not target_state:
                            # print(f"hit instruction: {inst_b.mnemonic} {inst_b.op_str}")
                            target_state = True
                            self.hit_inst.append(inst_b)
                            parts_b = inst_b.op_str.split(", ")
                            target2 = parts_b[0] if target not in parts_b[0] else parts_b[1]
                            break
                        if target_state and target2 in inst_b.op_str and "mov" in inst_b.mnemonic and '#0x' in inst_b.op_str:
                            self.hit_inst.append(inst_b)
                        if target_state and target2 in inst_b.op_str and 'adr' in inst_b.mnemonic:
                            # print(f"hit instruction: {inst_b.mnemonic} {inst_b.op_str}")
                            if "adrp" in inst_b.mnemonic:
                                try:
                                    next_code = mu.mem_read(curr_addr + inst_b.size, 4)
                                except UcError:
                                    continue
                                for inst_el in self.cs.disasm(next_code, curr_addr + inst_b.size):
                                    if "add" in inst_el.mnemonic:
                                        self.hit_inst.append(inst_el)
                                        self.hit_inst.append(inst_b)
                            else:
                                self.hit_inst.append(inst_b)
        return

    def branch_hook(self, mu: Uc, addr: int, size: int, user_data) -> None:
        """
        当执行到 BR 指令时停止模拟
        """
        try:
            code = mu.mem_read(addr, size)
        except UcError:
            return

        for inst in self.cs.disasm(code, addr):
            if inst.mnemonic.lower() == "br":
                # print(f">>> BR 指令在 0x{addr:x} 被触发，停止模拟")
                mu.emu_stop()
                break
    
    def get_hit_inst(self, addr: int) -> None:
        """
        从指定地址向后模拟收集 hit 指令
        """
        # print(f">>> Getting hit instructions from 0x{addr:x} to 0x{self.inst_br_addr_temp:x}")
        bh_id = self.mu.hook_add(UC_HOOK_CODE, self.hit_hook)
        self.mu.hook_del(self.hook_code_id)
        # 搜寻前面的有没有立即数存储指令
        for i in range(1, 50):
            try:
                code = self.mu.mem_read(addr - i * 4, 4)
            except UcError:
                continue
            for inst in self.cs.disasm(code, addr - i * 4):
                # print(f"get_hit_inst : >>> {hex(addr - i * 4)} {inst.mnemonic} {inst.op_str}")
                if ("mov" in inst.mnemonic or "ldr" in inst.mnemonic ) and '#' in inst.op_str:
                    self.hit_inst.append(inst)
        
        try:
            self.mu.emu_start(addr - 4, self.inst_br_addr_temp)
        except UcError as e:
            print("模拟过程中出现错误:", e)
            self.err_flag = True
            self.err_addr.append((self.inst_mov_addr_temp, self.inst_br_addr_temp,"error at get_hit_inst:", e))
        self.mu.hook_del(bh_id)
        self.hook_code_id = self.mu.hook_add(UC_HOOK_CODE, self.hook_code)
        # print("\n>>> Hit instructions:")
        # for inst in self.hit_inst:
        #     print(f"    0x{inst.address:x}: {inst.mnemonic} {inst.op_str}")

    def run_hit_inst(self) -> None:
        """
        只模拟 hit 指令（hit_inst 列表中的指令）。
        """
        # print(">>> Running hit instructions")
        original_pc = self.mu.reg_read(UC_ARM64_REG_PC)
        for inst in reversed(self.hit_inst):
            
            try:
                self.mu.emu_start(inst.address, inst.address + inst.size)
            except UcError as e:
                print("run_hit_inst 模拟出现错误:", e)
                self.err_flag = True
                self.err_addr.append((self.inst_mov_addr_temp, self.inst_br_addr_temp, "error at run_hit_inst:", e))
        self.mu.reg_write(UC_ARM64_REG_PC, original_pc)

    def patch_code(self, addr: int, patch_bytes: bytes) -> None:
        """
        打补丁，将代码修改为 patch_bytes
        """
        self.mu.mem_write(addr, patch_bytes)
        # print(f">>> 已将地址 0x{addr:x} patch 为 {patch_bytes}")

    def hook_code(self, mu: Uc, address: int, size: int, user_data) -> None:
        """
        检测 CSEL 指令，进行向后分析并实现分支变种测试
        """
        try:
            code = mu.mem_read(address, size)
        except UcError:
            return

        for inst in self.cs.disasm(code, address):
            # print(f">>> addr:{hex(address)}  {inst.mnemonic} {inst.op_str}")
            if inst.mnemonic.lower() == "stur" or inst.mnemonic.lower() == "ldur":
                self.mu.reg_write(UC_ARM64_REG_PC, address + size)
                # print(f">>> stur or ldur detected, skip")
                return
            if inst.mnemonic.lower() == "csel" and not self.csel_handled:
                # print(">>> csel detected")
                self.csel_handled = True
                self.csel_addr_temp = address
                saved_state = self.save_state()  # 保存当前状态
                
                # 使用 mov_addr_temp 作为先前的 mov 指令地址
                # print(">>> start get hit inst\n")
                # self.print_regs()
                mov_addr = self.inst_mov_addr_temp
                self.hit_inst = []  # 重置 hit 指令列表
                self.get_hit_inst(mov_addr)
                self.run_hit_inst()
                self.restore_state(saved_state)

                operands = inst.op_str.split(", ")
                self.csel_args = (operands[0],operands[1], operands[2])
                mov_inst1 = f"mov {operands[0]}, {operands[1]};"
                mov_inst2 = f"mov {operands[0]}, {operands[2]};"
                asm_mov_branch1, _ = self.ks.asm(mov_inst1)
                asm_mov_branch2, _ = self.ks.asm(mov_inst2)

                def run_branch_test(patch_bytes: list, branch_label: str) -> dict:
                    self.mu.mem_write(self.csel_addr_temp, bytes(patch_bytes))
                    # print(f">>> 已将 csel 指令 patch 为 {branch_label}，开始执行至遇到 BR 指令")
                    bh_id = self.mu.hook_add(UC_HOOK_CODE, self.branch_hook)
                    try:
                        self.mu.emu_start(self.inst_mov_addr_temp - 4, self.inst_br_addr_temp)
                    except UcError as e:
                        print("run_branch_test 模拟错误:", e)
                        self.err_flag = True
                        self.err_addr.append((self.inst_mov_addr_temp, self.inst_br_addr_temp,"error at run_branch_test:", e))
                    self.mu.hook_del(bh_id)
                    return self.save_state()

                # print(">>> Executing first branch variation")
                self.run_hit_inst()
                saved_state = self.save_state()
                state_branch1 = run_branch_test(asm_mov_branch1, mov_inst1)
                self.restore_state(saved_state)
                self.run_hit_inst()
                # print(">>> Executing second branch variation")
                state_branch2 = run_branch_test(asm_mov_branch2, mov_inst2)

                print(">>> Final state:")
                
                br_value1 = state_branch1.get(self.regs_dic[self.br_reg], 0)
                br_value2 = state_branch2.get(self.regs_dic[self.br_reg], 0)
                if br_value1 + br_value2 > 0x10000:
                    print(f"maybe br addr error: {hex(br_value1)} , {hex(br_value2)}")
                    # self.print_regs()
                    self.err_flag = True
                    self.err_addr.append((self.inst_mov_addr_temp, self.inst_br_addr_temp,"error at run_branch_test:",0))
                    return
                else:    
                    print(f"    1: {hex(br_value1)}")
                    print(f"    2: {hex(br_value2)}")
                    self.br_value = (br_value1, br_value2)
                    self.mu.emu_stop()
        return

    def emulate_single_addr(self,mov_addr, br_addr, br_reg) -> None:
        """
        模拟执行单组地址
        """
        
        self.inst_mov_addr_temp = mov_addr
        self.inst_br_addr_temp = br_addr
        self.br_reg = br_reg
        # print(f"\n>>> Processing indirect jump: mov_addr=0x{mov_addr:x}, br_addr=0x{br_addr:x}, br_reg={br_reg}")
        try:
            self.clear_state()
            self.hook_code_id = self.mu.hook_add(UC_HOOK_CODE, self.hook_code)
            self.mu.emu_start(self.BASE_ADDR + mov_addr, br_addr)
            self.mu.hook_del(self.hook_code_id)
        except UcError as e:
            print("run() 执行错误:", e)
            self.err_flag = True
            self.err_addr.append((mov_addr, br_addr, "error at run():", e))

    # python
    def patch_br(self) -> None:
        """
        扫描 self.csel_addr_temp 到 self.inst_br_addr_temp 区间内的所有指令，
        记录所有 STR 指令，将所有 STR 指令上移，其余指令下移，
        重新构造新的指令序列：首先放置所有 STR 指令，
        然后是两条分支指令，
        剩余空间填充 NOP 指令（注意：不能超过原区域大小）。
        最后将组装好的字节补丁写入内存。
        """
        
        all_insts = []   # 保存区间内所有(地址, 指令)元组
        str_insts = []   # 保存STR类型指令

        addr_start = self.csel_addr_temp 
        for addr in range(addr_start, self.inst_br_addr_temp, 4):
            try:
                code = self.mu.mem_read(addr, 4)
            except UcError:
                continue
            for inst in self.cs.disasm(code, addr):
                all_insts.append((addr, inst))
                if "str" in inst.mnemonic.lower():
                    str_insts.append((addr, inst))
        
        # print(">>> 扫描到的所有指令:")
        # for addr, inst in all_insts:
        #     print(f"    0x{addr:x}: {inst.mnemonic} {inst.op_str}")
        # print(">>> 其中 STR 指令:")
        # for addr, inst in str_insts:
        #     print(f"    0x{addr:x}: {inst.mnemonic} {inst.op_str}")
        
        # 构造新的指令序列
        new_inst_list = []
        # (1) 添加所有 STR 指令（以其原有汇编文本为准）
        for _, inst in str_insts:
            asm_line = f"{inst.mnemonic} {inst.op_str}"
            new_inst_list.append(asm_line)
        
        # (2) 添加两条跳转指令（分支指令），这里假定 self.br_value 存储了两个跳转目标
        # 构造分支指令文本（注意汇编语法，根据实际需要可能调整条件代码）
        
        b_inst1 = "b.ne #" + hex(self.br_value[0] - self.csel_addr_temp - len(str_insts)*4)
        b_inst2 = "b #" + hex(self.br_value[1] - self.csel_addr_temp - len(str_insts)*4 - 4)
        for i in range(2):
            print(f"    0x{self.inst_br_addr_temp + i * 4:x}: {b_inst1 if i == 0 else b_inst2}")
        new_inst_list.append(b_inst1)
        new_inst_list.append(b_inst2)
        
        # 使用 Keystone 汇编生成机器码，并计算补丁区域大小
        patch_bytes = b""
        for asm_line in new_inst_list:
            try:
                encoding, _ = self.ks.asm(asm_line)
                patch_bytes += bytes(encoding)
            except Exception as e:
                print(f"组装指令失败 {asm_line}: {e}")
        
        # 计算目标区域可用字节数
        region_size = self.inst_br_addr_temp - self.csel_addr_temp
        current_size = len(patch_bytes)
        # print(f"累计patch字节长度: {current_size}, 目标区域大小: {region_size}")
        
        # (3) 如果不足，填充 NOP 指令（ARM64 的 nop 固定4字节）
        if current_size < region_size:
            remaining = region_size - current_size
            nop_count = remaining // 4  # 每个 nop 占4字节
            for _ in range(nop_count):
                try:
                    encoding, _ = self.ks.asm("nop")
                    patch_bytes += bytes(encoding)
                except Exception as e:
                    print(f"组装 nop 失败: {e}")
        # 如果超过目标区域，根据需要截断（不要溢出）
        if len(patch_bytes) > region_size:
            patch_bytes = patch_bytes[:region_size]
        
        # print(">>> 重新组装后的补丁字节:")
        # print(patch_bytes.hex())
        
        # 将生成的补丁字节写入内存（写回到原区域起始处）
        self.patch_code(addr_start, patch_bytes)
        
        # print(">>> 重写区域内指令:")
        for addr in range(addr_start, self.inst_br_addr_temp, 4):
            try:
                code = self.mu.mem_read(addr, 4)
            except UcError:
                continue
            # for inst in self.cs.disasm(code, addr):
            #     print(f"    0x{addr:x}: {inst.mnemonic} {inst.op_str}")
        
    
    def run(self) -> None:
        """
        启动模拟执行，先收集间接跳转地址，再逐个模拟
        """
        self.reg_jmp_addr = self.find_reg_jmp_addr()
        for addr in self.reg_jmp_addr:
            print(f"indirect jmp addr: 0x{addr[0]:x}, br addr: 0x{addr[1]:x}, br reg: {addr[2]}")
        print(f"\n>>> 共找到 {len(self.reg_jmp_addr)} 个间接跳转地址")
        cnt = 0
        for mov_addr, br_addr, br_reg in self.reg_jmp_addr:
            # if br_addr != 0x1638:
            #     continue
            cnt+=1
            # print(f"\n>>> Processing indirect jump {cnt}: mov_addr=0x{mov_addr:x}, br_addr=0x{br_addr:x}, br_reg={br_reg}")
            try:
                self.emulate_single_addr(mov_addr, br_addr, br_reg)
                if self.err_flag:
                    self.err_flag = False
                    continue
                self.patch_br()
            except:
                continue
            

        if self.err_addr:
            print("\n>>> Error addresses:")
            for addr in self.err_addr:
                print(f"    indirect jmp addr: 0x{addr[0]:x}, br addr: 0x{addr[1]:x} , {addr[2]} , {addr[3]}")
            
            for addr in self.err_addr:
                print(f"( {addr[0]} , {addr[1]} , \" {addr[2]} \") ," , end="")
                
    

def main() -> None:
    binary_path = r"F:\_reverse_study\_unicorn_study\task1\easy-re"
    simulator = Arm64ELFSimulator(binary_path)
    simulator.run()
    # simulator.run_err_addr(err_addr)
    simulator.patch_elf_sections(binary_path + "_patched")

if __name__ == "__main__":
    main()

参考链接

https://bbs.kanxue.com/thread-282826.htm
https://blog.csdn.net/Luckiers/article/details/128221506
https://bbs.kanxue.com/thread-283706.htm
https://bbs.kanxue.com/thread-280231.htm

]]> https://l4n.top/2025/03/31/%E5%AF%84%E5%AD%98%E5%99%A8%E9%97%B4%E6%8E%A5%E8%B7%B3%E8%BD%AC%E6%B7%B7%E6%B7%86%E5%8E%BB%E9%99%A4%E5%AE%9E%E6%88%98/ 2025-03-31T10:11:06.000Z 寄存器间接跳转的基本概念

寄存器存储地址：寄存器间接跳转依赖于寄存器内的值来指定要跳转]]>

寄存器间接跳转混淆去除实战 2026-09-02T15:48:21.767Z