Watermelonabc Hexo https://blog.watermelonabc.top/ All rights reserved 2026, Watermelonabc 欢迎来到 Watermelonabc 的 Blog 🥳，一个蒟蒻 CTFer 的自留地~ Watermelonabc的Blog 2026-08-15T04:22:01.000Z Watermelonabc 新发正式版的 Hacker 模拟游戏：HackHub - Ultimate Hacker Simulator，属于渗透 / 红队领域

正如制作组所说的 “A hacking game that actually feels real”[1]，此游戏的一个优势在于制作组确实构建了一个真实向的终端环境——简化的 KDE 桌面、Firefox、Discord、apt-get、bash 等，还有 Gmail、Twitter（小蓝鸟复活）、GitHub，并引入了一些真实存在的 CLI 工具。至少这个游戏没有追求炫酷但何意味的 “过场动画式” 工具，而选择融入实际的命令行。

Hackhub游戏界面
Hackhub 游戏界面

不过，既然是游戏，那么就存在 “不是那么现实” 的情况。比如前期游戏就虚构了一个信息搜集工具，堪称 “一键开盒”，但是很多理应存在的信息却显示 No data，只输出任务直接相关的信息。以及有些任务也是出于 “游戏性” 考虑的。

我玩的是学习版，还没有玩多少内容…… 原价￥48，一般打八折。我不会花这个钱的，不如真的去装个 Linux 虚拟机，真的去安装并使用那些实际存在的工具。这种游戏还是属于激发兴趣、简要入门以及安全的 Playground

看了一下创意工坊（对，支持 MOD），现在社区都做出了暗网、媒体播放器、NES 模拟器、密码管理器、加密货币以及 python-is-python3 🤣，那么什么时候进化到支持引入 AI 呢？

封面来自制作组 Hotbunny Interactive

  1. Hackhub | Hotbunny Interactive ↩︎

]]> https://blog.watermelonabc.top/p/4be45b93/ 2026-08-04T03:19:57.000Z 至少构建了一个真实向的终端环境 又一个黑客模拟游戏 2026-08-15T04:22:01.000Z Watermelonabc 今天帮三升四的弟弟（对，我俩差了 12 岁，正好两个都属 🐔）辅导了一下课业，几个感想：

  1. “知识的诅咒” 发力了，应用题我一开始想着列个方程，但是根据课标教材，三年级的数学工具不支持；后面想到分数乘法，结果三年级也没有直接的说明；最后用 “几份几份” 将这些问题转化为整数的四则运算。（之后翻了三年级上册课本才发现此时的数学工具也是这样做的）
  2. 也许是习题集的问题吧，整数列式计算中间出了一两道小数除法，三年级教材也没有说明。但是从整数转到小数除法，采用知其然的说法（被除数小数点点哪，商的小数点就点哪）也不难。当然我小学时也有这个问题，老师没讲就说不知道（
  3. 答题卷面很糟糕，数学符号和汉字写得都比较乱。我在幼小阶段是很痛恨练字的，但是如果卷面呈现出来是这个样子的话我认为还是有必要练一练整齐度的，实在不行出个 “昏招”：课堂开小差就琢磨着数字的 N 种写法（
  4. 不理解上下文，上一行公式的结果到下一行就忘了。可能是我们在旁边指导吧，他开始 “大脑外置”。“12 个人分成 3 份，1 份 4 个人，三分之一，三份取一份，女生一份，请问女生几个人？” 结果先回答 8 人（男生）然后回答 1 份。这还是三年级上册课本的例题！
  5. 至少令我欣慰的一点是，当我不去指导应用题时，他会去翻我讲过的题目作为参考，虽然那些题目的格式相似，但至少有点 “举一反三” 的意味在了。
  6. 英语，粗劣的手写体不怪他，但是听写单词能不能别像搜索一样，写错回退换一个字母试试？！虽然以我的教育体验来讲，小学英语的差距可以在初中弥补，但我现在又不确定了。

“现阶段我国还有少部分地区师资欠缺、开课不足，一些孩子的英语基础相对薄弱，为此我们在七年级上册设计并调整了第一单元作为预备学习单元，供你们选用。”——义务教育教科书《英语》科学普及出版社 2011 年课标版本。在 2022 年课标版本里，预备学习单元的内容被压缩。

“当教育制度开始改革，往往又是一次代际更替，而前人则带着旧体制的烙印进入社会”。十二年，已经过了 “十年树木” 的阶段，而现在的基础教育实践已经和我所经历过的有了差距。随着 “素质教育” 和 “减负” 的提出，一部分的学习任务从学校转移到家庭，而很显然，我们貌似没能适应这种变化。

家里人给他买了某知名教培品牌的学习平板，比我小学时期的步步高不知道高级多少。它也内置了很多表面亮丽的学习游戏，但看来没有起到激发学习兴趣的作用。这类游戏完全比不过娱乐视频，只能是面对更加无趣的一般学习模块时的备选：事实如此，当要求学单词时，他打开的是闯关游戏，而不是一般的单词模块（类似百词斩、不背单词这种）

而对于一般平板呢？他之前还用着 2020 年买的华为平板，满是各种钓鱼小游戏。屏幕摔过不知多少次，甚至露出了内部的背光模块和电子元件。最后被我妈一怒之下格式化了。

现在，就在我旁边，他拿着学习平板，观看着视频资源——吐槽恶搞学校生活的动画，本质上和我以前看过的《茶啊二中》相似。不知是平板一开始就开放的，还是由于我父亲的宽松管控而开放的。再想到我装个 “欧路词典” 都要家长授权、单词学习界面滥用思源黑体（这种字体应该选择手写风格的，比如 ABeeZee），只能说依旧草班台子。

小时候我也想过：要当一个 “好” 家长。但现在来看，我也开始重演上一辈的 “打击教育”；我也是个脾气不好、缺乏耐心的人啊。

]]> https://blog.watermelonabc.top/p/84608961/ 2026-07-31T13:06:44.000Z 一代人有一代人的教育 家庭辅导一晚，有点感想 2026-08-10T11:20:31.000Z Watermelonabc

最终成绩：87 分
考试说明：闭卷形式，选择题 + 程序填空题 + 计算题 + 简答题

CH1 嵌入式系统概述

1、嵌入式系统的定义

以应用为中心，以计算机技术为基础，软硬件可裁剪，适应应用系统对功能、可靠性、安全性、成本、体积、重量、功耗、环境等方面有严格要求的专用计算机系统。

2、嵌入式系统和通用计算机系统的比较（共同点和不同点）、嵌入式系统的特点

共同点：都属于计算机系统，由硬件和软件组成；工作原理相同，都属存储程序机制；从硬件上看，嵌入式系统和通用计算机系统都是由 CPU、存储器、I/O 接口和中断系统等部件组成；从软件上看，嵌入式系统软件和通用计算机软件都可以划分为系统软件和应用软件两类。

不同点：形态，功能，资源，价值，功耗，开发方式。

特点：专用性强、可裁剪性、实时性好、可靠性高、生命周期长、不易被垄断

3、嵌入式系统的架构：冯･诺依曼结构和哈佛结构

冯･诺依曼结构：采用二进制逻辑、程序存储执行以及计算机由五个部分组成（运算器、控制器、存储器、输入设备、输出设备）

哈佛结构（存储器结构）：程序存储器和数据存储器是两个独立的存储器，每个存储器独立编址、独立访问。

4、嵌入式系统处理器：MPU、MCU、DSP、SoC

分别为微处理器 (MPU)、微控制器（MCU，俗称单片机）、数字信号处理器 (DSP) 和嵌入式片上系统（System on Chip ，简称 SoC）

MCU 的特点是集成度高、控制能力强、可靠性强、低功耗、性价比高、系统设计周期短。最大特点是单片化，体积大大减小，从而使功耗和成本下降，可靠性提高。

5、MCU 的基本组成：CPU、时钟、存储器、通用 I/O、定时器/计数器、外设等

单片机的 CPU 由运算器和控制器组成，有运算和控制的功能。单片机的指令代码就是通过 CPU 执行的。

时钟时钟本质上就是固定频率的脉冲信号，为 MCU 工作提供基准时序。时钟频率直接决定了 MCU 的执行速度。

单片机的存储器包括存放代码指令的 ROM（或 Flash），以及存放变量、数据的 SRAM。

通用 I/O 口 (GPIO) 可以当作输入或输出接口。大部分单片机为了减少引脚数量，I/O 口还复用作为其它特殊功能引脚，比如 PWM 输出、捕获输入、串行通信、外部中断输入等。

定时器 / 计数器能够提供精确定时，或者对外部事件进行计数。内部硬件本质是计数器，当计数器脉冲来源是固定频率脉冲时，可通过计数来实现计时。

MCU 常用的外设模块有：模数转换模块 (ADC)、PWM 模块、捕获模块 (CAP)、通信模块等等。不同芯片有不同的外设配置

6、CPU 功能

CPU 有运算和控制的功能。单片机另外增设了 “面向控制” 的处理功能，如位处理、查表、跳转、乘除法运算、状态检测、中断处理等，增强了实用性。

7、总线 BUS：地址总线、数据总线、控制总线

总线是一组相关逻辑信号的集合。不同芯片有不同的总线标准。

地址总线 (Address Bus, AB)：单向，用于传递地址信息。地址线的数目决定了可寻址的存储空间。一根地址线有两种状态，即可以区分两个不同的存储单元，或者说可以寻址两个存储单元；如果有 nn 根地址线，则可以寻址 2n2n 个存储单元。

数据总线 (Data Bus, DB)：一般为双向，用于 CPU 与存储器、CPU 与外设、或外设与外设之间传送数据信息。我们平常说的 8 位、16 位或 32 位单片机，指的就是 CPU 一次能够处理的数据位数，这也决定了单片机数据总线的根数（宽度）。

控制总线 (Control Bus, CB)：是单片机系统中所有控制信号线的总称，用来传递控制信息。

CH2 C2000 系列微控制器及硬件平台

1、F28027 主要资源

32 位 CPU、时钟（40MHz/50MHz/60MHz）、哈佛总线架构、3.3V 单电源供电、外设资源（GPIO、中断 PIE、CPU 定时器、ePWM、eCAP、ADC、SCI、SPI、I2C）

2、引脚。功能复用、引脚有效符号等

F28027 的引脚按其功能进行分类，可以分为 JTAG 接口、Flash、时钟信号、复位引脚、ADC 模拟输入信号、CPU 和 I/O 电源引脚、电压调节控制引脚、GPIO 和外设信号。

3、MCU 硬件功能概述

F28027 有一个 32 位的 CPU 内核（TMS320C28x），主频高达 60MHz，同时它具有 GPIO、模数转换器 ADC、增强型 PWM 模块、增强型捕获模块、串口通信接口、串行外设接口等外设。功能丰富强大，用户可以方便地用它来开发高性能的微控制系统。片内集成了 Flash 存储器，程序可以直接烧写到 Flash 中，实现脱机运行。

4、内存映射（数据空间 / 地址空间，空间大小与地址的转换）

M0 SARAM 和 M1 SARAM 大小均为 1K×16 位，地址范围分别为0x000000 ~ 0x0003FF、0x000400 ~ 0x0007FF。当复位后，堆栈指针指向 M1 块的起始地址，堆栈指针向上生长。M0、M1 可以映射到程序区和数据区。

0x000800 ~ 0x0001FFF 对应外设帧 0，为寄存器映射空间，该空间直接通过 CPU 内存总线访问。

0x006000 ~ 0x0006FFF 对应外设帧 1，为寄存器映射空间，该空间通过 32 位外设总线访问。

L0 SARAM 的大小为 4K×16 位，即可以映射到程序区，也可以映射到数据区。L0 SRAM 地址为双映射，可以映射到0x008000 ~ 0x008FFF，也可以映射到0x03F8000 ~ 0x3F8FFF。

用户 OTP 区的大小为 1K×16 位，地址范围为 0x3D7800 ~ 0x3D7BFF，即可以映射到程序区，也可以映射到数据区。

0x3D7C80 ~ 0x3D7CBF 为内部振荡器和 ADC 模块的校正数据空间。由厂家进行编程，用户不可编程。

0x3D7CC0 ~ 0x3D7CDF 该存储空间保存 MCU 工作模式引导程序。在 MCU 初始化引导时调用引导程序进入相应模式。

0x3D7E80 ~ 0x3D7EAF 预留给 TMX/TMP 系列芯片使用。

0x3D7FFF 保存设备相关信息，对于 TI 28027PT 读取值为 0x00CF。

0x3F0000 ~ 0x3F7FF7 闪存分为四个扇区，每个扇区 8K×16，分别是扇区 D、扇区 C、扇区 B、扇区 A。如果使用代码安全模式，Flash 空间 0x3F7F80 - 0x3F7FF5不能用来保存程序代码或数据，必须将这些区域编程为 0。如果不使用代码安全模式，可以用来保存程序或数据，但是 0x3F7FF0 ~ 0x3F7FF5 s 只能用于保存数据，不能用于保存程序代码。

0x3F7FF8 ~ 0x3F7FFF 128 位密码区。密钥由用户编程时写入闪存。

0x3FE000 ~ 0x3FFFFF BOOT ROM 用于保存 TI 的引导装载程序和 IQ 数学表，在芯片出厂时已经编程好。包含 IQ 数学表、IQ 数学函数、Bootloader 函数、Flash 应用程序接口库、ROM 版本和 ROM 校验和、复位向量和 CPU 向量表几个部分。

0x3FE000 ~ 0x3FFFFF F28027 的 CPU 向量表。在 CPU 向量表中，唯一可以直接使用的是位于0x3FFFC0的复位向量，复位向量保存着 InitBoot 函数的入口地址。

5、时钟信号 SYSCLKOUT

由锁相环模块输出。为了达到节能目的，TI 对时钟提供一种管理机制，每个外设模块都可以对时钟输入进行使能或禁止（CLK ENABLE），只对需要工作的模块提供时钟信号，不工作的模块不提供时钟信号。系统时钟可以再次被处理，生成低速时钟信号 LSPCLK，用于低速外设模块，如 SCI 模块和 SPI 模块。

F28027 提供了四种时钟来源。包括：1、提供外接晶振的接口来实现内部振荡电路的工作；2、直接用外接时钟信号 XCLKIN；3、内部振荡器 Internal OSC1；4、内部振荡器 Internal OSC2。内部振荡器的工作频率是 10MHz，单片机上电复位后默认的时钟来源是 Internal OSC1。

6、看门狗电路（本质是定时器，“喂狗”：0x55AA）

F28027 提供了看门狗模块。该模块本质上是一个计数器，在计数器溢出时，它会产生一个复位信号，来复位 CPU 或者产生看门狗中断。为了不让它产生复位信号，那就需要在计数器溢出前对它清零，俗称 “喂狗”。

时钟源 OSCCLK 经过 512 分频后再进行可编程的预分频 (Watchdog Prescaler)，输出脉冲作为看门狗计数器（Watchdog Counter）的计数脉冲。Watchdog 55+AA Key Detector 是看门狗的 “喂狗” 操作。“喂狗” 时，需要先写入数据 “55” 给寄存器 WDKEY，接着写入 “AA” 给寄存器 WDKEY，硬件就会发出有效的信号 Good Key，用于复位看门狗计数器。

当程序运行出现问题，比如 “死机” 或进入 “死循环”，那么设定的 “喂狗” 程序将无法执行，看门狗计数器将溢出并发出触发信号，通过 Generate Output Pulse 模块输出 512 个时钟周期的低电平信号。

7、片内上电复位 / 欠电压复位

上电复位电路（POR）的目的是在整个上电过程，对器件产生一个有效的复位信号。器件上电过程结束后，欠压复位电路（BOR）对 VDDIO 进行监测，如果使能片内电压稳压器，还对 VDD 进行监测。POR 的电压保护点比 BOR 低。当电压低于相应的保护点时，复位电路把 XRS 拉至低电平引起复位过程。

CH3 微控制器程序设计基础

1、编程语言

机器语言就是用二进制代码表示的计算机能直接识别和执行的一种机器指令集合，每一条机器指令在计算机内部都有相应的电路来完成它，是唯一的计算机能够直接识别和执行的语言。CPU 的所有指令集构成该计算机的指令系统。

汇编语言是面向机器的程序设计语言。由汇编语言编写的程序，计算机无法直接识别，需把汇编语言翻译成机器语言，这种具有翻译功能的程序叫做汇编程序。汇编程序把汇编语言翻译成机器语言的过程称为汇编。汇编语言的指令一般都由操作码和操作数组成，操作码也被称为指令助记符。

机器语言和汇编语言都是低级语言。高级语言是一种贴合人类逻辑思维、便于直观理解的计算机语言，高级语言既接近自然语言又可以使用数学表达式，并且相对独立于计算机，可以跨计算机使用。编译的程序代码通常比用汇编语言设计的程序代码更长、执行更慢。

2、CPU 执行指令 5 个过程：取指令、指令译码、取操作数、执行指令、结果写回

取指令：将指令从程序存储器取出。程序计数器 PC 中的数值指示当前指令在程序存储器中的位置。当一条指令被取出后，PC 中的数值将根据指令长度自动递增，指向下一条指令。

指令译码：指令译码器按照预定的指令格式，对取回的指令进行译码，识别出不同的指令类别以及各种获取操作数的方法。

取操作数：从存储器或者 CPU 寄存器中获取操作数。操作数指出了参与运算的数据或数据所在的地址，而如何得到就由芯片的寻址方式决定。C28x 支持四种基本寻址方式：直接寻址方式、间接寻址方式、堆栈寻址方式、寄存器寻址方式。同时，C28x 还支持一些特殊寻址方式，如数据/程序/IO 空间寻址方式、程序空间间接寻址方式等。

执行指令：完成指令所规定的操作，实现指令的功能。为此，CPU 的不同部分被连接起来，以执行所需的操作。

结果写回：把执行指令阶段的运行结果数据写回到存储器或 CPU 寄存器。

在结果数据写回之后，当条指令执行完毕。CPU 从程序计数器 PC 中取得下一条指令地址，开始新一轮的循环。

为了提高效率，C28x 采用 8 个独立阶段来完成以上 5 个过程。指令以流水线方式执行，在任何时候，最多可以执行八个指令，每个指令处于不同的完成阶段。

3、嵌入式 C 语言：几个特殊保留字（volatile、interrupt）

嵌入式 C 语言的四大要素就是数据及其处理、程序流程控制、函数与中断服务程序以及指针。

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

Example

1
2
3
4
5
volatile int i=10;int a = i;...// 其他代码，并未明确告诉编译器，对 i 进行过操作int b = i;

volatile 指出 i 是随时可能发生变化的，每次使用它的时候必须从 i 的地址中读取，因而编译器生成的汇编代码会重新从 i 的地址读取数据放在 b 中。而优化做法是，由于编译器发现两次从 i 读数据的代码之间的代码没有对 i 进行过操作，它会自动把上次读的数据放在 b 中。而不是重新从 i 里面读。这样以来，如果 i 是一个寄存器变量或者表示一个端口数据就容易出错，所以说 volatile 可以保证对特殊地址的稳定访问。

interrupt/__interrupt 为编译器扩展的保留字，用于声明中断服务函数（ISR）。ISR 函数必须定义为 void 返回类型，且没有参数。例如：__interrupt void int_handler(void)。编译器会在编译时执行特殊的操作：自动保存和恢复寄存器；生成特殊的中断返回指令 IRET。

CH4 软件架构与 CCS 集成开发环境

1、如何使用结构体指针操作寄存器

结构体指针的定义：

  • 第一步：声明结构体类型，结构体类型名为GPIO_Obj。
    结构体成员包含了 GPIO 模块的所有寄存器，结构体成员严格按照寄存器的地址顺序排列，并保留没有用到的地址空间，
  • 第二步：声明结构体指针类型，结构体指针类型名为GPIO_Handle。
    typedef GPIO_Obj * GPIO_Handle;
  • 第三步：定义结构体指针变量 myGpio。
    GPIO_Handle myGpio;
  • 第四步：结构体指针变量初始化。
    myGpio = (void*)GPIO_BASE_ADDR; //GPIO_BASE_ADDR为GPIO模块所有寄存器的首地址0x0000 6F80

接下来，以 GPADAT 寄存器为例介绍寄存器的读写操作方法。

1
2
myGpio->GPADAT = 5; // GPADAT寄存器值设置为5data = myGpio->GPADAT; // 读取GPADAT寄存器值当前的值,保存到变量data中

2、寄存器位操作

寄存器位操作一般都是通过逻辑 “与” 和逻辑 “或” 来实现的。在对某个位操作的同时不能影响到寄存器的其他位。例如，对GPADAT的GPIO2这个位进行写和读操作：

1
2
3
4
5
myGpio ->GPADAT &= (~((uint32_t)1 << 2)); // 待操作位清零，其他位保持不变myGpio ->GPADAT |= (uint32_t)1<< 2; // GPIO2位写1// myGpio ->GPADAT |= (uint32_t)0<< 2; // GPIO2位写0Bitdata= ((myGpio -> GPADAT >> 2) & 0x0001)；// GPIO2位值保存到Bitdata变量中。

3、软件架构

分为主程序层、应用层、用户模块层和芯片模块层。

TI 公司为各系列 MCU 提供了丰富的固件库函数和技术支持。固件库是一个固件函数包，它由程序、数据结构和宏组成，包括 MCU 所有系统级和外设标准驱动函数 (接口)。对于初学者而言，可以直接调用这些驱动函数，快速实现需要的应用。

用户模块层对 MCU 驱动函数进行封装，完成具体的功能操作。

应用层对用户函数进行封装。

主程序层主要是对 MCU 的初始化配置和应用层功能函数的调用，实现复杂的 MCU 功能。初始化部分包含系统和外设模块配置函数和初始化函数。

CH5 通用输入输出口

1、GPIO 基础知识

GPIO 是微控制器的数字输入输出模块，可以实现微控制器与外部设备的数字交换。数字输入功能主要是将外部设备的开关量信号转换成 CPU 可读取的数字信号 “1”、“0”，从而获知外部设备的运行状态；数字输出功能则是将 CPU 的数字控制信号 “1”、“0” 转换成引脚高、低电平信号，从而实现对外部设备运行状态控制。

GPIO 输出驱动器主要由多路选择器、输出控制和 MOS 管组成。

多路选择器根据用户配置决定该引脚是用于通用 GPIO 还是复用功能输出。通用输出时，该引脚的输出信号来自于 GPIO 输出数据寄存器。复用功能输出时，该引脚输出信号来自于片上外设，并且一个引脚输出可能来自多个不同外设。同一时刻，一个引脚只能使用一种输出功能。

根据数字电路输出电平的 “强弱”，可将 IO 输出分为图腾柱输出（推挽输出 / 推拉输出）、开漏输出、下拉电阻输出 3 种。

图腾柱输出电路输出为强 1，强 0 或高阻态。推挽输出既提高电路的负载能力，又提高开关速度，适用于输出 0V 和 VDD 的场合。输出强 1：上管导通，下管截止，OUTPUT 输出高电平；输出强 0：上管截止，下管导通，OUTPUT 输出低电平；高阻状态：上管截止，下管截止，无影响

开漏输出：与图腾柱方式相比，只有下管受控，上管断开或没有上管。对于与 Vss 相连的 MOS 管来说，其漏级是开路的。当内部输出 “0” 时，下管导通，引脚相当于接地，外部输出低电平；当内部输出 “1” 时，下管截止，由于上管也截止，外部输出既不是高电平，也不是低电平，而是高阻态。如果想要外部输出高电平，必须接有上拉电阻。上拉电阻输出电路为强 0 弱 1 电路。

下拉电阻输出电路为强 1 弱 0 电路。与图腾柱方式相比，只有上管受控，没有下管。

2、C2000 的 GPIO 模块（概述、软件架构）

F28027 有 22 个 GPIO（DIO）、6 个 AIO（与 AD 采样通道共用引脚）；GPIO 引脚分组管理，分为端口 A（由 GPIO0 - GPIO31 组成）、端口 B（由 GPIO32-GPIO38 组成）。

GPIO 引脚与最多 3 种外设功能引脚共用，使用前需要先进行模式选择。

GPIO 引脚可工作在上拉模式或推挽模式。

GPIO 引脚的电气特性：输入时，低电平电压范围为：（Vss-0.3）V ~ 0.8V，高电平电压范围为：2V ~（VDD+0.3）V。输出时，逻辑 “1” 输出的电压最低为 2.4V，逻辑 “0” 输出的电压最高为 0.4V。

CPU 对输入引脚的信号确认有 3 种方式。非同步（异步输入）方式、同步时钟方式、采样窗方式。默认情况下，所有输入引脚信号被设置为同步于系统时钟 SYSCLKOUT。

采样窗方式下，输入信号首先被同步到系统时钟 SYSCLKOUT，然后输入信号状态持续时间达到指定数量周期数时，输入状态才允许改变。

为了限定信号，在固定的周期进行输入信号采样。用户指定采样周期（也称采样间隔时间）是相对于系统时钟（SYSCLKOUT）而言的。

采样的次数可以选择为 3 次采样或者 6 次采样，通过寄存器 GPAQSEL1、GPAQSEL2、GPBQSEL1 和 GPBQSEL2 来设置。当连续 3 次或 6 次信号状态一样，输入状态的改变才会被确认

采样窗口就是输入信号被确认的时间长度。为了让输入限定能够检测到输入的变化，信号电平必须在采样窗口或者更长的时间内保持稳定。GPIO 引脚的输入信号经过限定器后输出信号就对小毛刺 A 进行了滤波。

3、软件思维导图：配置 GPIO 控制 LED 和按键

GPIO 的硬件初始化配置都需要通过 GPIO 的寄存器实现，包括 GPIO 控制寄存器（GPIO Control Registers）和 GPIO 中断
和低功耗唤醒选择寄存器（GPIO Interrupt and Low Power Mode Select Registers）。GPIO 的读写操作通过 GPIO 数据寄存器操作（GPIO Data Registers）。

由于引脚功能的复用性，使用前需要根据硬件系统的资源需求，统筹考虑把引脚当作 GPIO 或其他外设功能。优先考虑并预留外设功能的需求。

步骤 1：配置引脚功能 (GPIO_setMode)。
步骤 2：使能 / 禁止内部上拉电阻 (GPIO_setPullUp)。
步骤 3：配置输入限定 (GPIO_setQualification、GPIO_setQualificationPeriod)。
步骤 4：配置引脚方向 (GPIO_setDirection)。
步骤 5：低功耗唤醒模式唤醒源 (GPIO_lpmSelect)。
步骤 6：选择外部中断源（GPIO_setExtInt）。

CH6 中断系统

1、中断基础知识（中断概念、中断处理过程、中断嵌套）

单片机的中断系统能够加强 CPU 对多任务事件的处理能力。中断是 CPU 对系统发生的某个事件作出的一种反应。引起中断的事件称为中断源。中断源向 CPU 提出处理的请求称为中断请求。发生中断时被打断程序的暂停点称为断点。CPU 暂停现行程序而转去响应中断请求的过程称为中断响应。中断响应的程序称为中断处理程序。CPU 执行有关的中断处理程序称为中断处理。而返回断点的过程称为中断返回。中断的实现通过软件和硬件综合完成，硬件部分叫做硬件装置，软件部分称为软件处理程序。

根据来源不同，中断可分为硬件中断（Hardware Interrupt）和软件中断（Software Interrupt）；根据中断请求能否被屏蔽，中断可分为可屏蔽中断（Maskable Interrupt）和非可屏蔽中断（Non-Maskable Interrupt，NMI）

中断服务程序的入口地址称为中断向量

中断的优先级主要用来描述不同事件的重要程度。如果在执行一个中断时又被另一个更重要的事件打断，暂停该中断处理过程转而去处理这个更重要的事件，处理完毕后再继续处理本中断的过程称为中断的嵌套

程序设计人员可以通过设置相应的中断屏蔽位，禁止 CPU 响应某个中断，从而实现中断屏蔽。但值得注意的是，尽管某个中断源可以被屏蔽，但一旦该中断发生，不管该中断屏蔽与否，它的中断标志位都会被置位，而且只要该中断标志位不被清除，它就一直有效。

MCU 的中断处理过程包括中断请求、中断响应、中断服务、中断返回四个步骤。当外设发出中断请求时，如果从外设到 CPU 的中断使能被允许，那么进入中断响应阶段。由于 CPU 执行完中断处理程序之后要返回被中断的地方继续执行原来程序，因此在执行中断服务程序之前，要把断点处地址和现场进行保护。

单一中断请求时，CPU 暂停正在运行的主程序转而运行中断服务程序，中断处理完毕后运行原程序。当多个中断请求同时挂起且不允许中断嵌套时，CPU 首先处理高优先级中断事件，然后再处理低优先级中断事件，最后返回执行主程序。允许中断嵌套时，大多数 MCU 高优先级中断可以中断低优先级中断服务程序，低优先级中断不能中断高优先级中断服务程序

2、C2000 的中断系统

中断资源包含 1 个非可屏蔽中断 NMI 和 16 个可屏蔽中断（INT1-INT14、RTOSINT、DLOGINT）

可屏蔽中断（INT1～INT12）采用外设中断扩展（PeripheralInterrupt Expansion，PIE）来进行协助管理，定时器 1、2 对应的 INT13、INT14 中断和 NMI 不经过 PIE，直接与 CPU 相连。

PIE 模块参与管理的中断有以下四类：

  • TINT0：定时器 0 中断，可屏蔽中断；
  • 外部中断：XINT1、XINT2、XINT3；
  • 唤醒中断：WAKEINT，包括看门狗和低功耗唤醒；
  • 外设中断：SPI、SCI、I2C、EPWM、HRPWM、ECAP、ADC 等。

PIE 最多可管理 96 个独立中断源，这 96 个中断源分成 12 组、每组 8 个，分别对应 CPU 级 12 个可屏蔽中断（INT1～INT12）。96 个中断源具有独立的中断向量，均存储在专用 RAM 中，用户可以修改这些中断向量。

3、PIE 三级中断管理机制

F28027 的中断采用的是 3 级中断管理机制，分别是外设级、PIE 级和 CPU 级。对于某一个具体的外设中断请求，任意一级的不许可，CPU 最终都不会响应该外设中断。

外设模块产生中断事件时，相应外设模块寄存器的中断标志位 IF 被置位，如果对应的外设中断允许位 IE 被使能，则外设就向 PIE 发送一个中断请求。如果外设中断允许位 IE 未被使能，则该中断被屏蔽，不会向 PIE 发送中断请求。外设模块的中断标志位有的会在中断响应后自动清除，有的需要通过软件来清除。外部中断比较特殊，没有中断标志位，如果中断使能允许，外部中断请求信号直接送达 PIE。

PIE 控制器将每 8 个外设或外部中断汇集成 1 个 CPU 级中断。这样对于 96 个外设中断源，就被分成 12 组，分别是 PIE1～PIE12，每一组对应一个 CPU 级中断，即 PIE1 对应 INT1，PIE12 对应 INT12。一旦中断请求被送到 PIE 模块，相应的 PIE 中断标志位 PIEIFRx.y 被置位。如果对应的中断使能位PIEIERx.y=1，那么 PIE 模块将检查相应的 PIE 应答位PIEACKx，确认 CPU 是否准备好响应这个组的中断。如果这个组的 PIE 应答位PIEACKx=0，则 PIE 将该中断请求送至 CPU。如果 PIE 应答位PIEACKx=1，中断请求不会被 PIE 发送给 CPU，直到PIEACKx=0且该中断请求还存在时，PIE 才会将挂起的中断请求发送给 CPU。

软件清除中断应答位PIEACKx；而 CPU 响应 PIE 级中断后，自动清除相应的中断标志位PIEIFRx.y，后者不可通过软件进行清除。

当中断请求从 PIE 发送到 CPU 时，CPU 级的中断标志寄存器IFRx被置位，中断应答位PIEACKx被置位，同组的其他中断请求被挂起。如果IERx=1且中断总开关INTM=0，那么 CPU 将响应这个中断请求并自动清零对应的IFRx标志位

CPU 响应中断请求后，要去处理中断服务程序，这个中断响应过程包括现场保护（中断返回地址、相关寄存器等入栈）和中断服务子程序地址的获取。其中，中断服务子程序地址保存在 MCU 内存单元，这部分内存单元也称为中断向量表。

CH7 CPU 定时器

1、定时器基础知识（本质是计数器、计数方式、定时时间计算）

定时器本质上是一个计数器，该计数器能对固定频率的脉冲进行计数，把时间的计量转化为对脉冲的计数。根据计数方向不同，有增计数、减计数、增减计数三种模式

增计数的工作模式是计数器按加 1 计数，也就是计数器在时钟脉冲的触发下连续加 1。当计数值与预先设置的周期值 PRD 相等时，计数器重新从 0 开始计数，由于计数是从 0 开始的，因此实际的计数周期要多加 1。

减计数的计数方式与增计数相反，计数器从某个初始值开始减 1，减到 0 时回到初始值重新开始。

增、减计数工作模式下定时器的定时时间 T 为：T=Tclk×(PDR+1)T=T_{clk} × (PDR+1)

增减计数模式的计数方向由定时器自动设置，当计数器的值增加到周期值时，计数方向由增计数自动改为减计数，同样，当计数值减到 0 时，计数方向由减计数自动改为加计数。这种工作模式下定时器的定时时间 T 为：T=Tclk×(PDR×2)T=T_{clk} × (PDR×2)

2、C2000 的定时器（3 个定时器、时钟基准 SYSCLKOUT、减计数方式、预分频、周期、定时时间计算）

F28027 有 3 个 32 位的定时器 TIMER0、TIMER1 和 TIMER2，三个定时器均采用减计数工作模式。TIMER0 和 TIMER1 提供给用户使用，TIMER2 提供给实时操作系统使用。时钟基准默认为系统时钟 SYSCLKOUT。

预分频计数器（PSCH:PSC）的触发信号是系统时钟信号（SYSCLKOUT）。每个时钟周期 PSCH:PSC 的值减 1，当 PSCH:PSC 值为 0 后的一个时钟周期，发出脉冲信号（Borrow），该信号作为计数器（TIMH:TIM）的时钟信号，同时触发寄存器 TDDRH:TDDR 的值重新装载到寄存器 PSCH:PSC。

定时器的工作流程是：每经过 (TDDRH:TDDR+1) 个时钟周期计数器（TIMH:TIM）减 1，当计数器 TIMH:TIM 减到 0 后将产生一次中断请求信号送给 CPU。

Example

假设系统时钟是 1MHz（即 1 微秒一个脉冲）。

  • 如果 TDDRH:TDDR = 0，预分频系数是 1，则主计数器每 1 微秒减 1。
  • 如果 TDDRH:TDDR = 99，预分频系数是 100，则主计数器每 100 微秒才减 1。

定时时间：T=(TDDRH:TDDR+1)×(TIMH:TIM+1)×TclkT=(TDDRH:TDDR+1)×(TIMH:TIM+1)×T_{clk}

CH8 增强型捕获模块

1、捕获模块基础知识

捕获模块可以捕获 MCU 引脚的电平跳变（上升沿、下降沿），并记录电平跳变的时刻。捕获模块也有对时间的处理，也是通过计数器来实现的。捕获模块可以用于外部事件的精确时间测量。只要被检测信号能够转换为脉冲信号，捕获模块就可以对该脉冲信号进行捕获。

2、计数器工作模式：增计数

3、C2000 的 eCAP（概述、功能（预分频、边沿极性、连续 / 单次模式、事件决策、捕获寄存器、中断控制）

单触发捕获模式：捕获 1-4 个事件后停止捕获
连续捕获模式：循环进行 1-4 个事件的捕获
中断功能：4 个捕获事件都可以触发中断
捕获模式不使用时，eCAP 模块可以配置为单通道 PWM 输出

预分频器可以对输入脉冲信号进行预分频（2-62 分频，2 的倍数），或者直接旁路，不经过预分频器。

边沿极性可以选择上升沿捕获或下降沿捕获。eCAP 模块有 4 个独立的边沿极性选择，每一个分别对应一个捕获事件。

Modulo 4 counter：事件触发计数器，由捕获事件触发计数。计数值只能是 0、1、2、3。

输入信号经过事件预分频（Event prescale）、极性选择（Polarity select）后到达事件决策模块（Event qualifier）。事件决策模块根据捕获模式（Continuous/Oneshot Capture Control）的配置，产生装载捕获寄存器的触发信号（LD1~LD4），把捕获计数器（TSCTR）的当前值 CTR 装载到捕获寄存器中（CAP1、CAP2、CAP3、CAP4）。根据复位配置（CTRRSTx）可输出信号（Delta mode）复位捕获计数器。捕获事件（Capture events）可发出捕获事件中断信号（CEVT）给 PIE。另外，eCAP1~ eCAP4 可通过时钟同步信号（SYNCIn）进行计数器初始值（CTRPHS）的装载。

捕获事件 1 设置为上升沿触发，差分模式，当上升沿捕获时，计数器清 0，开始新的周期计数；捕获事件 2 设置为下降沿触发，绝对值模式，这样 CAP2 即对应高电平的周期值；CAP1 的值对应波形周期值。

eCAP 捕获模式时有 5 个中断事件，即捕获事件 1（CEVT1）、捕获事件 2（CEVT2）、捕获事件 3（CEVT3）、捕获事件 4（CEVT4）、TSCTR 计数器溢出（CTROVF）（计数值从 FFFFFFFF 回到 00000000）。

CH9 增强型脉宽调制模块

1、PWM 基础知识

PWM 是 Pulse Width Modulation 的缩写，即脉冲宽度调制，也就是宽度可调节的方波脉冲。相关的参数：周期、频率和占空比

  • 周期 T：输出一次脉冲，即输出一次完整的高低电平的时间
  • 频率 f：周期的倒数，即 f=1Tf=\frac{1}{T}
  • 占空比 D：一个周期内，脉冲高电平时间与周期的比值（D=ThighTD=\frac{T_{high}}{T}）

PWM 信号有两种产生方法：模拟电子方法和数字化方法。

模拟电子方法：由三角波或锯齿波发生器产生高频调制波，经比较器产生 PWM 信号。三角波或锯齿波与可调直流电源比较，产生占空比可调的 PWM 信号；与正弦基波比较，产生占空比按正弦规律变化的 SPWM 信号。

数字化方法（主流）：与硬件构成 PWM 信号类似，数字逻辑将锯齿波发生器等效为一个计数器 Count，将可调直流电源等效为比较点 Compare。数字控制产生 PWM 需要 3 个寄存器：计数器、周期值和比较值。通过配置周期值和比较值就能够产生任意频率、占空比的 PWM 信号。

2、C2000 的 ePWM（TB 子模块、CC 子模块、AQ 子模块、ET 子模块）

时基子模块（TB）功能：每个 ePWM 单元都有一个独立的时基单元，用来决定该 ePWM 模块相关的事件时序。通过同步输入信号可以将所有的 ePWM 工作在同一时基信号下，即所有的 ePWM 级联在一起，处于同步状态，可以看成一个整体。

TB 模块的主要功能：

  1. 预分频功能（Clock Prescale）
  2. PWM 周期值（TBPRD）
  3. 时基计数器 TBCTR
  4. 时基时钟同步
  5. 时基计数器相位控制

系统时钟预分频后作为 TB 子模块的时钟信号，分频系数由寄存器TBCTL[HSPCLKDIV]和TBCTL[CLKDIV]决定。HSPCLKDIV的值为 x，则如果 x 为 0，则分频系数为 1，如果 x 不为 0，则分频系数为 2x；如果CLKDIV的值为 y，则分频系数为 2y。

Example

本书案例设置 SYSCLKOUT 为 60MHz，如果 HSPCLKDIV=0，CLKDIV=1，则 TBCLK=30MHz。

PWM 周期值 TBPRD 有两个寄存器：影子寄存器（Period Shadow）和活动寄存器（PeriodActive）。它们具有相同物理地址。由TBCTL[PRDLD]位控制周期寄存器的工作模式：影子寄存器模式 (=0) 或立即加载模式 (=1)。默认情况下 TBPRD 采用影子寄存器模式。在影子寄存器模式下，对 TBPRD 的读写操作是对影子寄存器进行的，只有当 TBCTR=0 时，影子寄存器的值加载到工作寄存器。

时基计数器的计数模式有三种模式，分别是：增计数模式、减计数模式和增减计数模式。在这三种计数模式中，一个有效的 TBCLK，时基计数器变化率为 1。

每个 ePWM 模块的时基时钟 TBCLK 是独立的，它们都是由系统时钟信号 SYSCLKOUT 分频得到。在 CLK 模块中，提供一个同步开关 TBCLKSYNC，当这个开关有效（置位）时，所有工作的 ePWM 模块的时基计数器 TBCTR 同步于 TBCLK 的第一个上升沿。每个 ePWM 模块的分频必须设置一样。

每个 ePWM 模块拥有一个同步信号输入 (EPWMxSYNCI) 和一个同步信号输出 (EPWMxSYNCO)。第一个 ePWM 模块（ePWM1）的同步输入信号是来自芯片的引脚。同步信号还控制关联的捕获（eCAP）模块。同步脉冲信号实现不同 ePWM 模块的同步，而且通过 TBPHS 实现各 ePWM 模块的相位超前和滞后的控制。当同步输入信号发生时，时基相位 TBPHS 装载到时基计数器 TBCTR，装载时刻一致，同步实现。如果 ePWM 模块的 TBPHS 不为零，那么在同步信号作用下，TBPHS 的值就装载进 TBCTR，各个 ePWM 模块就存在计数初值的不同，也就是存在相位差。

CC 子模块主要功能是对 TB 子模块的计数器值 TBCTR 与给定的比较值进行比较，产生比较相等的事件，该事件作为后续 AQ 子模块的触发事件。有两个比较寄存器 CMPA 和 CMPB

它们分别有两个寄存器：影子寄存器和工作寄存器。影子寄存器和工作寄存器具有相同的物理地址。由CMPCTL[SHDWAMODE]或CMPCTL[SHDWBMODE]位控制比较值寄存器的工作模式：影子寄存器模式或立即加载模式。对 CMPA 的写操作是对影子寄存器进行的。在设置的特殊时刻，影子寄存器的值加载到工作寄存器。加载的特殊时刻由CMCTRL[LOADMODE]决定，可以在 CTR=0 时刻、CTR=PRD 时刻或两者都可以。

比较功能子模块可以产生两个独立的比较事件，对于增计数或减计数，在一个 PWM 周期内，比较事件只发生一次。对于增减计数模式，在一个 PWM 周期内，如果比较寄存器的值在 0~TBPRD 之间，在一个 PWM 周期内，比较事件发生两次。

AQ 子模块决定了相应事件发生时应该输出什么样的电平。该模块是基于事件驱动的，可以认为该子模块输入的就是事件，输出的是动作。每个子模块有两路独立输出 EPWMA 和 EPWMB

AQ 子模块的输入事件有 4 种，事件发生时触发 AQ 子模块，分别是：

  1. CTR = PRD，计数器寄存器 TBCTR 的值与周期寄存器 TBPRD 相等时；
  2. CTR = Zero，计数器寄存器 TBCTR 的值等于 0 时；
  3. CTR = CMPA，计数器寄存器 TBCTR 的值等于比较寄存器 CMPA；
  4. CTR = CMPB，计数器寄存器 TBCTR 的值等于比较寄存器 CMPB

将计数方向输入给 AQ 子模块，能够把计数比较事件细分为增计数情形的计数比较事件（CAU 和 CBU）和减计数情形的计数比较事件（CAD 和 CBD）。除了以上外部事 件外，还可以用软件强制触发。通过设置寄存器 AQSFRC、AQCSFRC，产生一个软件强制事件。该软件强制事件可以是单次作用，也可以是连续作用。

AQ 子模块控制在触发事件产生时，2 路 PWM 输出 EPWMxA 和 EPWMxB 表现出何种行为。PWM 输出 EPWMxA 和 EPWMxB 可以设置为以下的动作：

  1. 置高，EPWMxA 或 EPWMxB 输出高电平；
  2. 置低，EPWMxA 或 EPWMxB 输出低电平；
  3. 翻转，EPWMxA 或 EPWMxB 输出电平与之前的电平相反；
  4. 无动作，EPWMxA 或 EPWMxB 的输出状态不变。
Warning

任何有效事件都能用来产生预定的动作，例如事件 CTR=CMPA 和 CTR=CMPB 都可以作用于 EPWMxA，不要认为 A 的事件只能用来产生 A 的 PWM 输出。

AQ 在硬件上也设计有事件的优先级。在众多事件中，软件强制的优先级始终是最高的。在增减计数下，CTR = CMPB 优先于 CTR = CMPA；增计数方向上，增事件优先于减事件，CTR = Zero 在中间；减计数方向上，减事件优先于增事件，CTR = PRD 在中间

如果是增/减计数，那么就排除减/增计数方向和减/增事件。

死区，通常叫死区时间（dead time），用于避免功率开关控制信号翻转时发生误触发的情况。死区子模块 (DB) 就是起到延时导通的作用。实现的功能有：死区发生器时钟选择、死区时间的设置、输入源选择（DBCTL[IN_MODE]）、极性选择（DBCTL[POLSEL]）、输出模式（DBCTL[OUT-MODE])

死区发生器产生波形上升沿延时 RED 和下降沿延时 FED，它是通过 10 位计数器来实现的。计数器时钟 DBCLK 可以选择为：

  • fDBCLK=fTBCLK，即与 TBCLK 同频，称为周期时钟
  • fDBCLK= 2×fTBCLK，即为 TBCLK 的 2 倍频，称为半周期时钟

死区时延时间计算公式为：
FED=DBFED×TTBCLKFED = DBFED × TTBCLK
RED=DBRED×TTBCLKRED = DBRED × TTBCLK
其中 TTBCLKTTBCLK 是时基时钟 TBCLK 的周期。如果选择半周期时钟，则 TTBCLKTTBCLK 也取半。

通过对应开关控制，死区子模块的输入信号是动作限定子模块的输出信号，记为 EPWMxA in 和 EPWMxB in。信号源可以设置为：

  • EPWMxA in 作为上降沿和下升沿延时的信号源，该模式是缺省模式。
  • EPWMxA in 作为上降沿延时的信号源，EPWMxB 作为下升沿延时的信号源。
  • EPWMxA in 作为下升沿延时的信号源，EPWMxB 作为上降沿延时的信号源。
  • EPWMxB in 作为上降沿和下升沿延时的信号源。

事件触发与中断管理 (ET) 子模块主要功能有：

  • 管理由时基子模块、比较子模块所产生的事件，这些事件可用于产生 PIE 中断 EPWMxINT 和 ADC 转换启动信号 EPWMxSOCA 和 EPWMxSOCB
  • 允许软件强制触发中断和启动 ADC 转换
  • 通过事件分频机制，灵活设置输出触发事件的频度

可用于 ET 子模块的输入事件信号有：

  • CTR=Zero：计数器寄存器的值为 0，TBCTR =0
  • CTR=PRD：计数器寄存器的值为 PRD，TBCTR =PRD
  • CTR=Zero 或 CTR=PRD：TBCTR = 0 或 TBCTR = period
  • CTRU=CMPA：在计数器增计数时，TBCTR=CMPA，CTR_dir=1
  • CTRD=CMPA：在计数器减计数时，TBCTR=CMPA，CTR_dir=0
  • CTRU=CMPB：在计数器增计数时，TBCTR=CMPB，CTR_dir=1
  • CTRD=CMPB：在计数器减计数时，TBCTR=CMPB，CTR_dir=0
  • 软件产生的强制事件信号

每个 ePWM 的 ET 子模块拥有的输出事件信号有：

  • 1 路 PIE 中断，EPWMxINT
  • 2 路 ADC 启动信号，EPWMxSOCA 和 EPWMxSOCB

PWM 周期：T=(N+1)×TclkT=(N + 1)×T_{clk}

占空比与比较值：Thigh=CMP+TclkT_{high} = CMP + T_{clk}

3、软件思维导图

引脚配置：

  1. 配置引脚功能（GPIO_setMode）
  2. 配置引脚方向（GPIO_setDirection）
  3. 使能 / 禁止内部上拉电阻（GPIO_setPullUp）
  4. 输入配置为异步系统时钟（GPIO_setQualification）

功能配置：

  1. PWM 时基时钟关闭（CLK_disableTbClockSync (myClk)
  2. PWM 时钟设置（PWM_setHighSpeedClkDiv、PWM_setClkDiv）
  3. PWM 计数模式设置（PWM_setCounterMode）
  4. PWM 动作限定设置（AQ 模块）
  5. 计算 PWM 的周期、周期设置（PWM_setPeriod）
  6. 计算 PWM 的占空比、占空比设置（CC 模块）
  7. 设置 PWM 死区（DB 模块, 可选项）
  8. 设置 PWM 斩波（PC 模块，可选项）
  9. 设置 PWM 故障联防（TZ 模块，可选项）
  10. PWM 时基时钟开启（CLK_enableTbClockSync）
  11. PWM 事件触发与中断管理（ET 模块）

中断事件配置：

  1. 中断入口地址注册（PIE_registerPieIntHandler）
  2. PWMx 事件中断使能（PWM_enableInt）
  3. PIE 级中断使能（PIE_enableInt）
  4. CPU 级中断使能（CPU_enableInt）

中断服务程序：

  1. 在 PWM 中断服务程序里完成比较点的更新或其他任务
  2. 清除 PWM 中断标志位和对应的 PIE 中断应答位 PIEACKx。

CH10 模 / 数转换器

1、ADC 基础知识

模拟数字转换器（Analog to Digital Converter, ADC），也称模数转换器，是将连续变化的模拟信号转换为离散的数字信号的电子器件。因为 CPU 只能处理数字量，所以需要把外部待测量的模拟量转换为数字量

输出量为待测量的电压、电流、温度、压力、流量、速度等物理量，这些物理量先经过传感器变换为电信号，再调制成符合 ADC 模块输入电压范围的电压模拟量，最后送给 ADC 模块转换为数字量，实时控制系统可以对该数字量进行处理

输入的模拟信号在时间上是连续的，而输出的数字信号是离散的。将连续的模拟量转换为离散的数字量通常要经过 3 个步骤：采样保持、量化、编码。

  1. 采样是将随时间变化的模拟量转换为在时间上离散的模拟量，保持则将所采样的模拟信号值保持一段时间，以使得后续的量化编码过程中信号值不发生变化。
  2. 采样后每个脉冲的幅度仍然是连续的，必须对每个脉冲的幅度进行离散化处理。将采样保持电路输出的电平转换为量化单位的整数倍的过程称为量化。
  3. 把量化的结果用二进制表示出来叫做编码。

ADC 的主要性能参数有量程、分辨率、精度、转换时间、量化误差、偏移误差等。除此之外，其他指标还有：绝对精度、相对精度、微分非线性、单调性和无错码、总谐波失真和积分非线性等等。

量程是指 ADC 所能转换的模拟输入电压的范围，分为单极性和双极性两种类型。

量化时需要把电平转换为量化单位的整数倍，因为模拟电压是连续的，它不一定能被量化单位整除，因而不可避免地会存在量化误差。AD 分辨率越高，量化误差越小。一般是 1 个或 0.5 个最小数字量的模拟变化量，表示为 1LSB 或 0.5LSB

分辨率（Resolution）：指 ADC 能分辨的最小模拟输入量。从理论上来讲，n 位输出的 ADC 能区分 2n 个不同等级的输入模拟电压，能区分输入电压的最小值为满量程输入的 12n\frac{1}{2^n}。

精度（Accuracy）：精度是指对于 ADC 的数字输出（二进制代码），其实际需要的模拟输入值与理论上要求的模拟输入值之差。

转换时间（Conversion time）：ADC 完成一次 AD 转换所需要的时间，是指从启动 ADC 开始到获得相应数据所需要的时间。一般来讲，ADC 的分辨率越高，转换时间就越长。

偏移误差（Offset Error）：模拟量输入信号为零时，数字量输出不为零的值。

增益误差（Gain Error）：满刻度输出时对应的模拟输入量与理想的模拟输入量之差。

ADC 的主要类型：

  • 逐次逼近型 ADC 属于直接式 ADC，其原理可理解为将输入模拟量逐次与 UREF/2、UREF/4、UREF/8、…、UREF/2N-1 作比较，模拟量大于比较值取 1（并减去比较值），否则取 0。逐次逼近型 ADC 转换精度高，速度较快，价格适中，是目前种类最多、应用最广的 AD 转换器

  • 积分型 ADC 是一种间接式 ADC，其原理是将输入模拟量和基准量通过积分器积分，转换为时间，再对时间计数，计数值即为数字量。优点是转换精度高，缺点是转换时间较长。

  • 并行比较型 ADC 的主要原理是将参考电压分为 2N−12^N-1 个等级（对于 NN 位的 ADC），通过 2N−12^N-1 个比较器和输入模拟电压进行比较，比较器的输出状态由触发器存储，经编码器编码，得到数字量输出。速度快，但其分辨率不高。

  • 压频变换型 ADC 是一种间接式 ADC，其原理是将模拟量转换为频率信号，再对频率信号计数，转换为数字量。精度高，功耗较低，抗干扰能力强，便于长距离传送，但转换速度较低。

  • ∑-Δ 型 ADC 又称为过采样型 ADC，是目前分辨率最高的 ADC。它主要由采样 / 保持电路、模拟低通滤波器、DAC 及数字滤波器构成。大多数的模块都是由数字电路搭建，一些噪声对其的影响很小。

  • 流水线型 ADC 的原理是将多级比较网络级联在一起，每一级得到一位数字码。如果需要的是 n 位数字码，则需要比较 n 次。每次输入的信号必须从头传到尾才算完成了一次量化编码。其优点是高速、高精度，低功耗，芯片面积小，同时具有优异的动态特性。

2、C2000 的 ADC（12 位 ADC 内核、量程、SOC）

具有内置双采样保持 (S/H) 的 12 位 ADC 内核

ADC 内核包含一个 12 位转换器，转换器为部分逐次逼近型、部分流水线型。转换器的模拟参考电平可以配置为外部电压基准 (VREFHI/VREFLO)，也可以配置为内部电压基准。

全范围模拟输入：0V 至 3.3V，或者 VREFLO 到 VREFHI

F28027 有 13 个 ADC 引脚可以与外部模拟量相连，分为两组，包括 ADCINA（ADCINA7、ADCINA6、ADCINA4、ADCINA3、ADCINA2、ADCINA1、ADCINA0 等 7 个引脚）和 ADCINB（ADCINB7、ADCINB6、ADCINB4、ADCINB3、ADCINB2、ADCINB1 等 6 个引脚）。在芯片内部，内置温度传感器占用 A5 输入，参考电压 VREFLO 占用 B5 输入，ADCINA5、ADCINB5 和 ADCINB0 没有外接引脚。

ADC 的工作是基于 SOC 控制的，SOC 信号送到 ADC 采样决策辑模块（ADC Sample Generation Logic）进行决策，产生相应的控制信号：通道选择（CHSEL）、采样窗设置（ACQPS）和开始转换触发信号（SOC）。

每个 SOC 可以独立配置：转换的通道、采样窗宽度和选择开始转换的触发源。转换方式灵活：用同一个触发源对不同的通道进行采样；用不同的触发源对不同的通道进行采样；也可以用一个触发源对同一个采样通道进行多次采样的过采样。

输入电路包括通道选择和采样 / 保持电路。ADC 模块输入的通道有 16 个（F28027 只有 13 个，见概述说明），分为 A 组和 B 组，各 8 个。当使用外部参考电平时，电平 VREFHI 占用 ADCINA0 引脚，ADCINA0 不能当作采样输入口。

采样窗的配置信号 ACQPS 来自采样决策模块。ADC 的采样保持电路必须快速准确地跟踪被采样的信号 ADCIN。AD 处理总的时间等于采样时间和转换时间之和。

ADC 触发源用于启动 SOC 配置的通道开始 AD 转换。每个 SOC 的触发源可以配置为以下任意一个事件：

  • 软件立即触发
  • ePWM 1-4 的 SOCA 和 SOCB
  • 外部中断 2，GPIO XINT2
  • CPU 定时器 0/1/2 中断
  • ADCINT1/2。用 ADC 转换结束中断信号作为触发事件，
  • 可以用于通道的连续转换控制。

ADC 转换的结果保存在结果寄存器 ADCRESULTx 中。保存方式是：顺序采样时，SOCx 触发的通道转换结果保存在对应的 ADCRESULTx 中，序号一一对应。对于同步采样，通常只用偶数的 SOCx，该 SOCx 配置的一对通道转换后结果保存在 ADCRESULTx 和 ADCRESULT（x+1）中，分别对应 A 组和 B 组的转换结果。

当多个 SOC 被同时触发时，需要通过优先级来决定哪个 SOC 对应的通道优先被转换。采样优先级有两种模式：Round Robin 模式和具有高优先级的 Round Robin 模式。

  • Round Robin 模式：是由 SOC0~SOC15 组成的一个头尾相接，方向固定的循环闭环。优先级由循环指针 RRPOINTER 决定。当前 RRPOINTER 的值表示上一次被转换的 SOC，那么它的下一个 SOC 具有最高的优先级。ADC 模块复位后，RRPOINTER=20h，表示没有 SOC 被转换，那么 SOC0 具有最高优先级。

  • 具有高优先级的 Round Robin 模式：该模式可以设置某些 SOC 具有高优先级，这些高优先级的 SOC 可以打断 Round Robin 的循环顺序，优先进行转换。多个高优先级的 SOC，序号低的优先级高。

对应于 16 个独立的 SOCx，有相应的 16 个采样结束信号 EOCx。ADC 模块有 9 个中断输出信号，即 ADCINT1~ADCINT9。任意一个 EOCx 脉冲都可以配置为 ADCINTx 的触发源。

CH11 串行通信接口

1、串行通信的基础知识

MCU 通信的数据是以字节为单位进行传输，其中每个字节包括多个数据位，根据数据位传输方式的不同，MCU 通信可分为串行通信和并行通信。

串行通信定义：字节中的数据一位一位依次传送的通信方式，具有传输信号线少、传输距离远等优点，但传输速度慢。

并行通信定义：字节中的所有数据位同时传送的通信方式，传输速度快，但是所需传输信号线多，适用于近距离通信。

SCI 串行通信仅需接收和发送两根信号线，8 位并行通信则需 8 根信号线。这两种通信方式除了信号线外，还需一根零电位参考线。

根据电平与数据对应的不同形成不同的编码方式，可分成 RZ 编码（Return Zero Code）、NRZ (Not Return Zero Code) 和 NRZI（Not Return Zero Inverted Code）等。

在 RZ 编码中，正电平代表逻辑 1，负电平代表逻辑 0，并且每传输完一位数据信号返回到零电平

与 RZ 编码不同的是，NRZ 编码电平不需要归零，因此只需采用高、低两种电平即可进行数据传输。

NRZI 编码使用信号的翻转代表一种逻辑，信号保持不变代表另外一种逻辑，如 “0” 对应电平翻转，“1” 电平保持不变。

数据在信号线上传输时需要满足一定的规范，才能使得通信双方正确地收发数据。通常以帧（frame）为单位进行数据传输。

从开始位到结束位的时间间隔称为一帧，通常一帧数据包括 1 位开始位、8 位数据位、1 到 2 位的停止位。

异步串行通信过程中，通信双方的发送和接收步调要一致才能保证传输数据的正确接收。因此，通过波特率（Boad Rate）来实现通信双方的步调一致，波特率是用来描述数据传输的速率。常用的波特率有 600、2400、4800、9600、19200、38400、57600、115200、128000 等。通信距离越长的时候通常选用越低的波特率。

在一帧数据中增加一位奇偶校验位用于错误检测。奇校验时，如果数据位 1 的个数是奇数，则校验位为 0；如果 1 的个数为偶数，则校验位为 1。偶校验时，如果数据位 1 的个数是奇数，则校验位为 1；如果 1 的个数为偶数，则校验位为 0。

串行通信根据接线的不同，有单工、半双工、全双工三种传输方式。

  • 单工通信：数据传输是单向的，除了地线外，只有一根数据线。
  • 半双工通信：数据传输是双向的，但是只有一根数据线，发送和接收不能同时进行。
  • 全双工通信：数据传输是双向的，有两根独立的数据线，发送和接收可以同时进行。

2、C2000 的 SCI（波特率、数据帧）

SCI 的波特率由时钟 LSPCLK 和波特率配置寄存器控制。LSPCLK 由系统时钟模块的低速外设时钟预分频寄存器配置，波特率选择寄存器为 16 位寄存器，有 65536 种不同的波特率选择。

假设 16 位波特率配置寄存器配置值为 BRR，则对应的波特率计算方法为：

Baud=LSPCLK(BRR+1)∗8,1≤BRR≤65535Baud=\frac{LSPCLK}{(BRR+1)*8}, 1≤BRR≤65535
Baud=LSPCLK16,BRR=0Baud=\frac{LSPCLK}{16}, BRR=0

帧格式配置：

  • 1 位开始位；
  • 1-8 位数据位；
  • 1 位地址和数据的识别位（针对地址位方式的多机模式）
  • 1 位可选的奇偶校验位
  • 1 或 2 位停止位

需要学会画出帧的波形表示。

CH12 实验

总共 4 次实验，代码运行结果需要给老师测试。实验代码可以参考文字辅导材料、视频教程（CCS 软件开发 ---F28027）和 AI。由于是小组形式，因此可以组内外私下交流。老师一般不会要求你解释代码功能，只会让你向他展示运行结果。

建议早测试早结束。大部分人都是将测试积压到后面的课时，导致组内和组间需要竞争测试机会——一次课只有一个半小时，还不算理论教授时间。最极端的情况下，你可能需要和老师单独约定时间测试。

注意基础配置：什么文件在哪个文件夹，各类初始化在哪个文件。在考试中需要回忆得起来，因为有程序填空题。

]]> https://blog.watermelonabc.top/p/3c5ed94a/ 2026-06-21T16:26:21.000Z 为毛跨学科的选修课也这么难啊 福州大学单片机原理与应用（跨学科）复习 2026-08-04T09:53:11.000Z Watermelonabc

最终成绩：76 分

考试流程

考试时间 100 分钟，前 60 分钟为论述题回答时间，后 40 分钟为选择题回答时间。选择题使用超星学习通系统，论述题回答结束后也上传一份电子档至学习通。

答题纸左侧为第 1 题答题区域，右侧为第 2 题答题区域。论述题回答时间内，不得使用手机。论述题回答结束时，将回答结果拍照上传至学习通，5 分钟内提交答题纸。

问答题

Q1 什么是马克思主义中国化时代化？

（定义）马克思主义中国化时代化，就是立足中国国情和时代特点，坚持把马克思主义基本原理同中国具体实际相结合、同中华优秀传统文化相结合，深入研究和解决中国革命、建设、改革不同历史时期的实际问题，真正搞懂面临的时代课题，不断吸收新的时代内容，科学回答时代提出的重大理论和实践课题，创造新的理论成果。

（内涵）运用马克思主义的立场、观点、方法，观察时代，把握时代，引领时代，解决中国革命、建设、改革中面临的实际问题；总结和提炼中国实践经验，并上升为理论，以指导新的实践，赋予马克思主义新的时代内涵和实践要求；运用中国人民喜闻乐见的民族语言来阐述马克思主义、使其植根于中华优秀传统文化的土壤之中, 具有中国特色、中国风格、中国气派。准确把握马克思主义中国化时代化的科学内涵，要做到坚持马克思主义和发展马克思主义相统一，要做到同中国具体实际、同中国优秀传统文化相结合。

Q2 如何理解马克思主义中国化时代化是 “一脉相承又与时俱进的关系”？（已考）

一脉相承：都坚持马克思主义基本原理，都立足中国实际
与时俱进：每个理论都回答了不同历史时期面临的主要问题；后一个理论都是对前一个理论的继承、丰富和发展

一方面，毛泽东思想所蕴含的马克思主义的立场、观点和方法，为中国特色社会主义理论体系提供了基本遵循。另一方面，中国特色社会主义理论体系在新的历史条件下进一步丰富和发展了毛泽东思想。

（举一个例子，建议从 “实事求是、群众路线、独立自主” 中选。比如群众路线 -> “三个有利于”（邓）-> “三个代表”（江）-> 科学发展观（胡）-> 习近平思想，论述后面发展的理论如何传承毛泽东思想中的 “群众路线”）

Tip

“三个有利于”：是否有利于发展社会主义社会的生产力、是否有利于增强社会主义国家的综合国力、是否有利于提高人民的生活水平
“三个代表”：中国共产党始终代表中国先进生产力的发展要求、始终代表中国先进文化的前进方向、始终代表中国最广大人民的根本利益
科学发展观：坚持以人为本，全面、协调、可持续的发展观。发展为了人民、发展依靠人民、发展成果由人民共享

Q3 为什么新民主主义革命属于资产阶级民主主义革命？

近代中国半殖民地半封建社会的性质和中国革命的历史任务，决定了新民主主义革命的性质是资产阶级民主主义革命。新民主主义革命在政治上争取和联合民族资产阶级，在经济上保护民族工商业。它要建立的是无产阶级领导的各革命阶级的联合专政，而不是无产阶级专政。

新民主主义革命时期中国革命的历史任务

反对帝国主义、封建主义、官僚资本主义，争取民族独立、人民解放，为实现中华民族伟大复兴创造根本社会条件。

Q4 说明新旧民主主义革命的区别（“新” 在哪里？）

新民主主义革命处于世界无产阶级社会主义革命的时代，是世界无产阶级社会革命的一部分；革命的领导力量是中国无产阶级及其先锋队——中国共产党；革命的指导思想是马克思列宁主义；革命的前途是社会主义而不是资本主义。

Q5 为什么说 “新民主主义社会是一个过渡性的社会”？（已考）

新民主主义社会不是一个独立的社会形态，而是由新民主主义转变到社会主义的过渡性的社会。

（生产力）新民主主义社会中存在着五种经济成分，其中主要的经济成分是三种：社会主义经济、个体经济和资本主义经济。通过没收官僚资本而形成的社会主义的国营经济，掌握了主要经济命脉，居于领导地位；而以农业和手工业为主体的个体经济，则在国民经济中占绝对优势。新民主主义社会要继续向前发展，就要不断扩大国营经济，同时逐步将资本主义经济和个体经济转变为社会主义经济，使社会主义经济逐步成为我国的经济基础。

（基本纲领）

  • 政治上：推翻帝国主义、封建主义和官僚资本主义的反动统治，建立无产阶级领导的，以工农联盟为基础的，各革命阶级联合专政的新民主主义国家。这是过渡形式。
  • 经济上：没收封建地主阶级的土地归农民所有，没收官僚资产阶级的垄断资本归新民主主义国家所有，保护民族工商业。
  • 文化上：是无产阶级领导的人民大众的反帝反封建的文化，是民族的、科学的、大众的文化。

（主要矛盾）土地改革完成后，工人阶级和资产阶级的矛盾逐渐成为我国社会的主要矛盾。只有解决了这一矛盾，才能使中国社会实现向社会主义的转变。

新民主主义社会是属于社会主义体系的，是逐步过渡到社会主义社会的过渡性质的社会。为了促进社会生产力的进一步发展，为了实现国家富强、民族复兴、人民幸福，我国新民主主义社会必须适时地逐步过渡到社会主义社会。

Q6 为什么进行社会主义改造？

  1. 我国有极其广大的个体农业和手工业及在国民经济中占很大一部分比重的资本主义工商业，要求一个相当长的时期改造它们。
  2. 经过 1949 年到 1952 年三年的努力，我国已经有了相对强大和迅速发展的社会主义国营经济。这为党提出向社会主义过渡的总路线提供了物质基础。
  3. 国内的资本主义力量弱小，发展困难，不可能成为中国工业起飞的基础。
  4. 党总结在国民经济恢复时期在老解放区大力推广农业互助组和初级合作社的经验。这也为党提出向社会主义过渡的总路线提供了重要依据。
  5. 新中国成立初期，国家在利用和限制资本主义工商业的过程中所积累的经验，成为对资本主义经济进行社会主义改造的最初步骤。
  6. 当时的国际形势也有利于中国向社会主义过渡。苏联社会主义的发展已经显示出相对于资本主义的优越性，对我国有重要的借鉴作用。

Q7 为什么不是走资本主义工业化，而是走社会主义工业化道路？

从历史上看，实现工业化有两条道路：一条是资本主义工业化道路，另一条是社会主义工业化道路。

“资本主义道路，也可增产，但时间要长，而且是痛苦的道路。我们不搞资本主义，这是定了的。”——毛泽东

三个 “不”：

  • 等不起：资本主义工业化开始于 18 世纪 60 年代英国的产业革命，至 19 世纪后期，主要资本主义国家先后完成了工业化。我国和资本主义国家有上百年的发展差距，不是短时间内可以弥补的。当时的中国必须在比较短的时间内实现自身实力的提升。
  • 玩不起：资本主义通过剥削、掠夺实现资本原始积累。我国不可能选择对外侵略，必须依靠自身力量实现工业化。
  • 走不起：以美国为首的西方资本主义阵营对我国实施长期封锁、禁运和军事威胁；与之同时，苏联等社会主义国家向我国提供了援助和宝贵经验。当时的时代条件和国际环境的新特点促使中国人民选择走社会主义道路。

Q8 如何理解改革开放前后历史时期关系？

  1. 前 30 年在重大挫折中取得了巨大成就，全盘否定前 30 年的历史是极端错误的。毛泽东等开国元勋带领全国人民进行社会主义革命和建设，取得了巨大成绩；前 30 年属于探索时期，出现错误在所难免。
  2. 改革开放前后时期是探索、铺垫与继承、发展的关系。改革开放前的社会主义实践探索为改革开放后的社会主义实践探索积累了经验并准备了条件，改革开放后的社会主义实践探索是对前一个时期探索的坚持、改革、发展。
  3. 对改革开放前的社会主义实践探索，要坚持实事求是，分清主流和支流，坚持真理，修正错误，发扬经验，吸取教训。

Q9 如何理解国内改革和国外开放的关系？

开放也是改革。对外开放是建设中国特色社会主义的一项基本国策。对外开放之所以重要，是因为历史经验一再告诉我们，关起门来搞建设是不行的，把自己孤立于世界之外是不利的。对外开放，包括对发达国家的开放，也包括对发展中国家的开放，是对世界所有国家的开放。它不仅是经济领域的开放，还包括科技、教育、文化等领域的开放。

改革是开放的基础与内因，国内制度完善、市场统一和营商环境优化，决定了对外开放的深度与能级，为高水平开放提供制度支撑。开放是改革的催化剂与压力测试，通过对接国际高标准经贸规则，引入外部竞争，倒逼国内体制机制创新，破除利益固化藩篱，实现 “以开放促改革”。

Q10 如何理解社会主义市场经济制度中政府和市场的关系？

“计划经济不等于社会主义，资本主义也有计划；市场经济不等于资本主义，社会主义也有市场。”——邓小平

社会主义市场经济理论的要点：一是计划经济和市场经济不是划分社会制度的标志，计划经济不等于社会主义，市场经济也不等于资本主义；二是计划和市场都是经济手段，对经济活动的调节各有优势和长处，社会主义实行市场经济要把两者结合起来；三是市场经济作为资源配置的一种方式本身不具有制度属性，可以和不同的社会制度结合，从而表现出不同的性质。

Q11 为什么说 “改革是中国的第二次革命”？

所谓第二次革命，是与中国共产党领导的第一次革命相对而言的。中国共产党领导的第一次革命把一个半殖民地半封建的旧中国变成了一个社会主义新中国；中国共产党领导的第二次革命，将把一个经济文化比较落后的社会主义中国变成一个现代化的社会主义国家。没有改革，就不可能走出一条建设中国特色社会主义的正确道路，我们的事业就不可能顺利前进。

改革作为一次新的革命，不是也不允许否定和抛弃我们建立起来的社会主义基本制度，它是社会主义制度的自我完善和发展。

]]> https://blog.watermelonabc.top/p/763d5207/ 2026-06-10T14:28:40.000Z 燃尽了^2 福州大学毛概期末复习 2026-08-04T09:53:11.000Z Watermelonabc 7. x86 汇编语言元素

现在我们带你讲解一下一个汇编语言程序是怎么写的。x86 汇编语言由语句 (statement) 构成，一条语句可能有以下元素：

7.1 常量整数和常量整数表达式

一个常量整数表示为 [{ + | - }] 数字 { 基数字符 }，例如 -10、11010011b、0A3h。

标识说明：

  • [] 的内容是可选的
  • { A | B } 说明必须在 A 和 B 中选择一项

基数字符说明了此整数使用的数制，如下表所示：

基数字符数制
空置/d十进制 (Dec)
q/o八进制 (Oct)
h十六进制 (Hex)
b二进制 (Bin)

如果一个十六进制值以字母开头，如 A4，则必须加上前缀 0 以免和变量名混淆。

整数字面量间的运算使用以下运算符：

运算符优先级备注
()1
+, -2正负号
*, /3
mod4
+, -5加减号

每个表达式的计算结果必须为可存储为 32 位的整型（0 ~ FFFFFFFF），此结果在编译时确定，运行时不可变。

EQU 指令可以设置符号整数常量，相当于 C 中的 #define，格式为 标识符 EQU 常量整数表达式。EQU 定义的常量在汇编时直接替换为字面量，因此运行时固定不可变。更宽松的版本是 = 指令，允许常量重定义，但依然是汇编时确定，运行时不可更改。

7.2 其他常量

常量实数表示为 [{ + | - }]数字.[数字][指数]，其中[指数]为科学记数法中的 ×10n×10^{n} 部分，表示为 E[{ + | - }]integer。2.、-44.2E+05、26.E5 都是合法的十进制实数。常量实数按照 IEEE 浮点数格式转换存储。

编码实数 (encoded real) 以十六进制表示，用 r 结尾。对应的十六进制从 IEEE 浮点数格式的二进制数转换得到，如 +1.0 的 IEEE 浮点数格式为 0011 1111 1000 0000 0000 0000 0000 0000，编码实数表示为 3F800000r

字符和字符串常量以 ''/"" 包围，按照 ASCII 码存储。

7.3 保留字

保留字主要有以下类型：

  • 指令助记符，如 mov、add、mul 等
  • 寄存器名称
  • 汇编器指令
  • 类型属性，如 byte 和 word
  • 运算符
  • 预定义的符号

保留字大小写不敏感，如 MOV 和 mov 是一样的，但预定义符号除外。

7.4 标识符

标识符用于标识变量、常量、函数、标签，有以下规则：

  • 长度在 1 ~ 247 之间
  • 大小写不敏感（通过汇编器的 -Cp 选项可使之大小写敏感）
  • 首字符必须是字母、下划线、@、? 或 $，后续的字符才可以取数字。
    作为建议，请尽量不要以下划线或者 @ 开头，减少违反下一条规则的概率。
  • 不能和保留字撞名

7.5 指令

指令在汇编时转换成运行时可执行的语句（机器语言字节）。一条指令包含四个部分：[标签:] [助记符] [操作数] [;注释]

  • 标签
    标签用于标识数据 / 代码的位置。

  • 助记符
    助记符标识指令功能。

  • 操作数
    操作数用于指令数据的输入输出。操作数可以是寄存器 (reg)、内存地址 (mem) 或者整数表达式 (imm)。一条指令可以有 0 到 3 个操作数。
    对于有两个操作数的指令，第一个操作数作为目标操作数 (dest)，第二个操作数作为源操作数 (src)。指令一般修改的是目标操作数。
    对于有三个操作数的指令，后两个操作数作为源操作数执行指令，结果存储到目标操作数。
    常见助记符及其操作数：

    助记符操作数说明
    MOVdest, srcsrc 的值赋值到 dest
    ADDdest, srcdest = dest + src
    INCopop 递增 1
    DECopop 递减 1
    SUBdest, srcdest = dest - src
    MULop无符号乘法，结果储存在主寄存器中，即 EAX = EAX * op
    IMULdest, src1, src2有符号乘法，dest = src1 * src2
    JMPlabel无条件跳转至标签位置
    CALLfunc调用函数
    NOP无无操作指令，占用 1 字节，常被汇编器用于字节对齐
    Note

    无论何时，我们都建议优先以寄存器作为操作数，然后是常量值，最后才是内存地址标识，因为它们的读取效率是依次递减的。

  • 注释
    单行注释以 ; 开头
    多行注释使用 COMMENT 指令，语法为 COMMENT 结束符。从 COMMENT 到第一个结束符之间的代码块将被忽略。

7.6 段式存储

正如 4.2 所述，x86 处理器底层依然属于段式存储模型。在大部分操作系统上，采用的模型和各位在 C/C++ 学的内存布局是一样的。

现在这个阶段，需要我们设置的内存段只有 .data（数据段）和 .code（代码段）。

7.7 示例 1

下面是一个进行加减运算的 MASM 汇编程序，操作数是写死在程序中的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
INCLUDE Irvine32.inc.codemain PROCa:mov eax,30000h; EAX = 10000hadd eax,80000h; EAX = 50000hsub eax,20000h; EAX = 30000h; jmp a           ; jump to label 'a'call DumpRegsexitmain ENDPEND main

我们详细分析一下这个程序。第一部分是汇编器指令：

  • INCLUDE Irvine32.inc 调用了教学用库 Irvine32.inc
Warning

我们要求：在本课程中，必须 INCLUDE Irvine32.inc，因为它预设置了有用的函数和汇编器指令。

接下来是代码区，我们在这里写函数代码：

  • .code 表示下面的所有代码均属于代码段的内容
  • main PROC 定义 main 过程（Procedure，即函数）
  • a: 定义了一个标签 a，指向 mov eax, 30000h
  • mov eax, 30000h 将十六进制值 30000h 赋值给 eax
  • add eax, 80000h 将 80000h 和 eax 的值相加，结果保存到 eax。
  • call DumpRegs 调用 Irvine32.inc 的 DumpRegs 函数，作用是打印当前的寄存器数值
  • jmp a 表示无条件跳转到 a 指向的代码。由于有个 bug 故注释，注意到了么？
  • exit 是系统调用 (system call)，表示程序的退出。注意不要对主函数使用 ret，因为 ret 需要显式调用方
  • main ENDP 表示结束此过程的定义
  • END main 表示整个源文件结束，并且指定了入口点函数 main。

7.8 数据类型与数据操作

MASM 内建以下数据类型：BYTE, SBYTE（有符号字节）, WORD, SWORD, DWORD, SDWORD, FWORD（六字节）, QWORD, TBYTE（十字节）。主要使用 BYTE, WORD, DWORD, QWORD 类型，可分别简写为 db, dw, dd, dq。

使用 TYPEDEF 可以定义新的类型，包括指针，语法为 类型名 TYPEDEF [PTR] 已注册的类型。已注册的类型包括内建类型和已使用 TYPEDEF 注册过的类型，例如：

1
2
CHAR    TYPEDEF BYTEPCHAR   TYPEDEF PTR CHAR

使用数据类型在 .data 段定义数据的语法为 [标识符] 类型 [初始化值, ...]

1
2
count dword 114514homo  word  ?

数据定义时必须有至少一个初始化值，如果不想自己设定，可以使用 ? 表示随机赋值。所有的初始化值，无论其格式，都会被汇编器转换为二进制数据。如果初始化值是有规律重复的，可以使用 DUP (Duplicate) 命令：

1
2
3
BYTE 20 DUP(0) ; 20 字节，均初始化为 0BYTE 20 DUP(?) ; 20 字节，均随机初始化BYTE 4 DUP("STACK") ; 20 字节，一个字符串："STACKSTACKSTACKSTACK"

可以有多个初始化值，这实际上就声明了一个数组：

1
2
list  byte  10,20,30,40      byte  50,60,70,80

数据 10 位于 list 的偏移 0 位置，以此类推。

字符串也是一种数组，但作为例外，每个字节间不都需要逗号分隔。正如各位在 C 中所学的那样，所有的字符串都需要加一个 \0 终止符（当然，是手动的，没有编译器兜底了）。对于多行字符串，只需要一整块字符串的末尾终止即可，如果需要换行，需要使用 0dh, 0ah (CR/LF)：

1
2
3
4
greeting1 BYTE "Welcome to the Encryption Demo program "          BYTE "created by Kip Irvine.",0dh,0ah          BYTE "If you wish to modify this program, please "          BYTE "send me a copy.",0dh,0ah,0

计算数组长度可以使用 $ - Array，例如：

1
2
list BYTE 10,20,30,40ListSize = ($ - list) ; ListSize = 4

如果是字符串长度，需要减去使用的转义字符的长度：

1
2
hello BYTE "Hello",0StringSize = ($ - hello) - 1 ; StringSize = 5

注意采用这种方式计算的，表达式必须紧跟在数组之后，因为 ($ - list) 的语义是当前地址 ($) 减去 list 的地址。数据在段内是连续的，因此可以用偏移值计算元素个数。如果中间再插入了其他数据，偏移值就计算错误了。

BYTE 只占 1 字节，因此偏移值 = 元素数。如果是 WORD 等更大的数据类型，就需要除以它的单位长度，例如：

1
2
data WORD 1,1,4,5,1,4dataSize = ($ - data) / 2 ; $ - data = 12, dataSize = 6

可以在代码段中间夹杂数据段。数据的作用域从声明位置开始：

1
2
3
4
5
6
.codemov eax,ebx.datatemp DWORD ?.codemov temp,eax

在进行数据的转移时，数据的宽度必须匹配目标寄存器的宽度。由于寄存器的宽度可以 “分割”，会出现数值覆盖 (Overlapping Values) 的情况：

1
2
3
4
5
6
7
8
9
10
11
.dataoneByte BYTE 78honeWord WORD 1234honeDword DWORD 12345678h.codemov eax,0 ; EAX = 00000000hmov al,oneByte ; EAX = 00000078hmov ax,oneWord ; EAX = 00001234hmov eax,oneDword ; EAX = 12345678hmov ax,0 ; EAX = 12340000h

数值仅覆盖对应位数，而其他位不变。对于有符号数，这种情况更加复杂：

1
2
3
4
5
.datasignedVal SWORD -16 ; FFF0h (-16).codemov ecx,0mov cx,signedVal ; ECX = 0000FFF0h (+65,520)

明明存储的是负数，结果读 ECX 的时候却读出了正数！除了尽量保证使用 CX，我们也可以先将 ECX 赋值为 FFFFFFFFh，这样数值就是正确的 FFFFFFF0h 了，这被称为符号位扩展 (Sign Extension)。为了简便较小宽度的数据向较大宽度的寄存器的转移， x86 设计了两个指令：

  • MOVZX (Move with Zero eXtension)

适用于无符号数，将扩展的位数设置为 0。

  • MOVSX (Move with Sign eXtension)

适用于有符号数，将扩展的位数设置为 1。

1
2
3
4
5
.databyteVal BYTE 10001111b.codemovzx ax,byteVal ; AX = 0000000010001111bmovsx bx,byteVal ; BX = 1111111110001111b
Warning

以上两个指令不得使用常量作为操作数。它们仅接受以下操作数组合：

1
2
3
reg32, reg/mem8reg32, reg/mem16reg16, reg/mem8

不要滥用符号位扩展，请优先确认操作数的宽度。例如：三个数据 10h、20h 和 30h 定义为 BYTE 类型，其中 30h 和前两个的用途不同。

这是中间一个步骤的内存视图：

1
10 00 00 00 30 00

如果将 20h 位扩展到 32 位（和 EAX 对齐）存进内存，那么：

1
10 20 00 00 00 00

之前存的 30h 被扩展的 0 覆盖了！

你如果还记得 C 语言的话，估计会把交换数据写成三个存储位置的中转交换，但 x86 提供了 XCHG (eXchange data)，可以直接交换数据：

1
2
3
XCHG reg,regXCHG reg,memXCHG mem,reg

对于两个内存数据的交换，需要使用寄存器中转：

1
2
3
mov ax,val1xchg ax,val2mov val1,ax

7.9 操作数和寻址方式

正如我们在 7.5 所述，操作数可以是寄存器、内存地址或者整数表达式。我们将这些操作数分类为：立即数、寄存器和内存，由此得到几种寻址模式：

寻址方式典型语句关键含义C 场景记忆点
寄存器寻址mov ecx, eax寄存器中的数据传送中间结果无 []
立即数寻址add eax, 5常量写在指令中常量赋值数直接给出
直接寻址mov ecx, count变量名给出地址普通变量名字就能定位
间接寻址mov edx, [ebx]按寄存器地址取值指针 *p寄存器里装地址
相对寻址mov esi, [ebx+4]基址 + 常量偏移arr[1]偏移按字节
相对寻址mov eax, count[esi]符号地址 + 寄存器偏移count[i]基址 + 位移
变址寻址mov eax, [ebx+edx+80h]基址 + 变址 + 位移buf[32+i]多一个动态偏移
比例变址mov eax, [ebx+esi*4-80h]基址 + 下标 × 大小 + 位移arr[i-32]自动乘元素大小
  • 立即数寻址

立即数就是内存中的字面量，因此立即数可以直接写在指令中：

1
2
3
4
mov eax, 10h; View in Hex:; B8 10000000
  • 直接内存寻址

地址需要解引用以访问对应数据。不过相比直接写地址值，我们一般都使用变量名，因为变量名携带了相对与段基地址的偏移信息。

1
2
3
4
5
mov eax, var1; Suppose var1 were located at offset 10400h; View in Hex:; A1 00040100
操作码

发现了吗？同样是 mov，两者在 Hex dump 中的表示却不一样！我们将 B8、A1 称为操作码 (Opcode)，可以参见 MOV -- Move Data。
不同的 Opcode 对应不同的操作数类型，但在汇编中我们统一写成 mov。这就是上层虚拟机对底层虚拟机功能的封装。

B8 表示将 imm 复制到 reg，而 A1 表示将位于 seg:offset 的值复制到 EAX。这样你就明白为什么 mov eax, var1 是将 var1 指向的值复制到 eax，而不是将 var1 的地址赋值给 eax 了吧，因为此时操作码 A1 表示对随后的地址值解引用。

Warning

正如在 4.2 中所说的，x86 的大多数指令不支持两个内存操作数。每条 mov 指令的操作码中，用于指定操作数的位域有限，无法同时编码两个完整的内存地址；并且早期 CPU 的寄存器才是真正进行移动操作的场所，内存只是数据的 “仓库”，需要使用寄存器作为中转：

1
2
mov eax, var1mov var2, eax

现代 CPU 的存储转发机制可能会直接将 var1 的数据从 L1 数据缓存转发到 var2 的存储操作中，甚至不需要寄存器物理上 “持有” 数据。但指令集层面仍然要求程序员（或编译器）显式写出这个寄存器。

  • 直接寄存器寻址

7.10 示例 2

1
2
3
4
5
6
7
8
9
10
11
12
13
INCLUDE Irvine32.inc.datagreeting byte "Hello, World!", 0.codemain PROCmov  edx, OFFSET greetingcall WriteStringexitmain ENDPEND  main

此处我调用了 Irvine32.inc 的 WriteString 函数。它以 edx 作为参数，接受字符串地址，将含终止符的字符串打印到标准输出。

7.11 基本运算

基本运算指令分为算术运算和逻辑运算。所有运算都会同步修改标志寄存器。

7.11.1 加减运算

INC 和 DEC 指令的作用是对寄存器 / 内存的值递增 (Increase) 和递减 (Decrease) 1，操作数就一个，运算结果保存到操作数上。

ADD 和 SUB 指令分别为加法 (Add) 和减法 (Substraction)，操作数是 dest,src，运算结果保存到 dest，不修改 src

NEG 是取反 (Negate) 指令，就是将寄存器 / 内存的值的符号位取反。

7.11.2 乘除运算

MUL 是无符号数乘法 (unsigned Multiply)，只有一个操作数。AX 寄存器作为被乘数，操作数作为乘数。结果写回低位寄存器，若位数不足则溢出至高位寄存器 (AH / DX)。两个操作数的位数和是结果的位数。

CF 标志用于检查高位进位。

1
2
3
mov al,5hmov bl,10hmul bl ; AX = 0050h, CF = 0

IMUL 是有符号乘法 (signed multiply)，可选 1、2、3 个操作数。

一个操作数时，行为类似 MUL；两个操作数时，第一个操作数作为被乘数和目标，第二个操作数作为乘数；三个操作数时，第一个操作数作为目标，第二个操作数作为被乘数，第三个操作数作为乘数。

IMUL 需要注意 CF 和 OF 标志。如果结果的高位不能解释为低位的符号扩展，那么 OF = 1

Tip

OF 标志主要看乘法结果是否在低位的有符号数表示范围内。

DIV 是无符号数除法 (unsigned Divide)。除法比较特殊——带余数的整除法。

DIV 只有一个操作数。DX 和 AX 作为被除数，操作数为除数。结果中，商写回低位寄存器，余数写回高位寄存器 (AH / DX)。两个操作数的位数差是结果的位数。

7.11.3 位运算

8. 分支与循环程序设计

默认情况下，CPU 按顺序加载和执行程序。但条件指令会根据 CPU 状态标志的值（Zero、Sign、Carry 等）将控制权转移到程序中的新位置。控制转移分为两种：无条件转移和条件转移。

循环在这里视为分支，因为它也可以使用条件转移指令实现。

8.1 无条件转移

使用 JMP 指令：

1
JMP label

CPU 将自动将 label 转换成偏移值，赋值给 IP 以在新位置执行代码。

JMP 是创建循环的最简单方法，结合标签可以形成一个无限循环：

1
2
3
top:  ; ...  jmp top

8.2 条件转移

只有判断标志寄存器的值满足条件时，条件指令才跳转。由于标志寄存器不能直接设定，因此需要搭配 cmp (compare) 或 test 指令使用。

cmp 的底层逻辑是 A - B，用于判断两个数的大小。test 的底层逻辑是 A & B，用于检查特定位数的状态（test A,A 可以判断 A 是否为 0）。两个指令均只修改 FLAGS 寄存器而不破坏元数据。

常见条件转移指令：

指令英文全称含义判断标志位
JE, JZjump equal，jump zero结果为零则跳转 (相等时跳转)ZF=1
JNE, JNZjump not equal，jump not zero结果不为零则跳转 (不相等时跳转)ZF=0
JSjump sign结果为负则跳转SF=1
JNSjump not sign结果为非负则跳转SF=0
JP, JPEjump parity，jump parity even结果中 1 的个数为偶数则跳转PF=1
JNP, JPOjump not parity，jump parity odd结果中 1 的个数为偶数则跳转PF=0
JOjump overflow结果溢出了则跳转OF=1
JNOjump not overflow结果没有溢出则跳转OF=0
JB, JNAEjump below，jump not above equal小于则跳转 (无符号数)CF=1
JNB, JAEjump not below，jump above equal大于等于则跳转 (无符号数)CF=0
JBE, JNAjump below equal，jump not above小于等于则跳转 (无符号数)CF=1 or ZF=1
JNBE, JAjump not below equal，jump above大于则跳转 (无符号数)CF=0 and ZF=0
JL, JNGEjump less，jump not greater equal小于则跳转 (有符号数)SF≠ OF
JNL, JGEjump not less，jump greater equal大于等于则跳转 (有符号数)SF=OF
JLE, JNGjump less equal，jump not greater小于等于则跳转 (有符号数)ZF=1 or SF≠ OF
JNLE, JGjump not less equal，jump greater大于则跳转 (有符号数)ZF=0 and SF=OF

其实记忆这些指令并不难，因为它们都是 JMP + 条件缩写的形式。

条件转移可以形成一个有限循环：

1
2
3
4
5
6
7
8
9
10
; ...mov ecx, a_lencopy:    mov eax, a[esi]    mov b[esi], eax    add esi, 4    dec ecx    cmp ecx, 0    jne copy; ...

有一个专门的指令 LOOP 同样实现了有限循环，以 ECX 作为循环次数，当其数值减少到 0 时，LOOP 指令就会停止，继续执行下面的指令。

1
2
3
4
5
6
7
8
; ...mov ecx, a_lencopy:    mov eax, a[esi]    mox b[esi], eax    add esi, 4    loop copy; ...
Warning

在进入 LOOP 循环体前，务必显式初始化 ECX！在循环体内，我们也不建议再修改 ECX。如果要修改，请先将 ECX 代表的循环次数保存，然后在退出一次循环前将次数恢复到 ECX。
对于嵌套循环，你同样需要先保存外层循环次数，再设置内层循环次数；内层循环结束后，及时将外层循环次数恢复到 ECX：

1
2
3
4
5
6
7
8
9
10
11
12
13
.datacount dword ?.codemov ecx,100 ; set outer loop countL1:mov count,ecx ; save outer loop countmov ecx,20 ; set inner loop countL2:; ...loop L2mov ecx,count ; restore outer loop countloop L1

9. 函数

通俗地说，我们可以将函数（Procedure，本义为过程，有人也称为子程序）定义为一个返回语句结束的语句块。函数是使用 PROC 与 ENDP 指令声明的。它必须被赋予一个合法的标识符。

对于非入口点函数（即 main），使用 RET 作为返回语句：

1
2
3
4
sample PROC; ...retsample ENDP

函数内标签的作用域仅限于此函数内，这主要影响跳转与循环指令。虽然可以通过标签名后标识 :: 来声明一个全局标签，但这样做容易破坏程序的运行时栈 (Runtime Stack)。关于运行时栈我们会更详细地介绍。

这是一个简单的加法函数，约定参数和返回值都通过寄存器传递，比较简单：

1
2
3
4
5
SumOf PROC    add eax,ebx    add eax,ecx    retSumOf ENDP

现在你可以使用 CALL 指令调用函数了！Irvine32.inc 实现了一些简单的输入输出函数。你可以直接打开此文件查看此库声明了哪些函数。

9.1 运行时栈

运行时栈用于存储函数执行期间的必要的临时信息。和数据结构中的 “栈” 一样，运行时栈同样遵循 LIFO 规则。运行时栈通过 ESP 寄存器管理地址。一般来讲，我们不会直接修改 ESP，而是通过 CALL、RET、PUSH 和 POP 指令间接修改。

ESP 永远指向最后一个压入栈的值，即栈顶。这里需要注意一下，在操作系统中，栈是 “向下生长” 的，即栈的地址是从高到低的。每当我们 PUSH 一个值进入栈，ESP 的值会递减，然后将操作数复制到栈里。一个 16 bits 操作数会使 ESP 递减 2，32 bits 则递减 4。PUSH 的操作数可以是寄存器、内存地址或立即数。

POP 会将 ESP 指向的栈内容复制到操作数中，然后递增 ESP。POP 的操作数可以是寄存器或内存地址。

9.2 函数调用

CALL 指令可以让 CPU 跳转到函数内存位置以执行指令。与之配套的是函数内的 RET 语句。

具体来讲，CALL 将返回地址压入栈中，然后将目标函数地址赋值给 EIP。返回地址指向 CALL 的下一条语句。当函数 RET 时，栈中存放的返回地址赋值给 EIP，之后弹出。

因此，对于一个正常的程序，其调用函数前后的堆栈是平衡的，即在 RET 时 ESP 的值应该和 CALL 时返回地址压入后的 ESP 值相等，这样 RET 才能将正确的返回地址写入 EIP。

对于函数的嵌套调用同样如此。每 CALL 一个子函数，对应的返回地址就会压入栈中；系统在同一时间内只会执行位于运行时栈栈顶的那个函数；然后 RET 时不断 “溯源”，直到返回主函数。

9.3 保存和恢复寄存器

现在我们准备写一个更复杂的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
;----------------------------------------------------; ArraySum ;  ; Calculates the sum of an array of 32-bit integers. ; Receives: ESI = the array offset ;           ECX = number of elements in the array ; Returns: EAX = sum of the array elements ;----------------------------------------------------ArraySum PROCpush esi ; save ESI, ECXpush ecxmov eax,0 ; set the sum to zeroL1:  add eax,[esi] ; add each integer to sum  add esi,TYPE DWORD ; point to next integerloop L1pop ecx ; restore ECX, ESIpop esiretArraySum ENDP

此函数通过寄存器传递参数和返回值，不使用特定标识符以提高兼容性。

不过我们不是想聊这个。看这个程序的开头，它将 ESI 和 ECX 的值压入栈中，而返回前又将其 POP 出来。这是大多数修改寄存器的函数的典型做法：始终保存并恢复被函数修改的寄存器，以确保调用者自身的寄存器值不会被覆盖。该规则的一个例外是用作返回值的寄存器，一般是 EAX。

Warning

注意遵循堆栈的 “后进先出” 原则！

你可以通过 USES 指令让汇编器自动生成这类代码：

1
2
3
4
5
6
7
8
9
10
ArraySum PROC USES esi ecxmov eax,0 ; set the sum to zeroL1:  add eax,[esi] ; add each integer to sum  add esi,TYPE DWORD ; point to next integerloop L1retArraySum ENDP

USES 紧跟在 PROC 之后，寄存器列表中间无逗号。

Warning

USES 生成的代码会先于用户代码执行。例如：

1
2
3
4
ArraySum PROC USES esi ecxpush ebpmov  ebp,esp; ...

生成的是：

1
2
3
4
5
push esipush ecxpush ebpmov  ebp,esp; ...

在后面章节有需要使用 ebp 间接寻址堆栈内容的地方。有时只看到显式 push 的寄存器，结果把 USES 忘了，脑子里想的堆栈和实际堆栈不一样

或者使用 pushad 和 popad （ad 代表 All Double）将所有的通用寄存器都 push/pop。

9.4 用栈传递参数

本节开头我们展示了如何用寄存器传递参数。然而，大多数现代语言中函数参数是通过堆栈传递的：在 32 位下，Windows API 的参数也通过栈传递。因此，必须学会如何用栈传递参数。

为什么不继续使用寄存器？

和通过栈传递参数相比，寄存器传参更快（对于较早期 CPU）。然而，一旦程序规模开始膨胀，寄存器传参出现 bug 的概率就越高；寄存器数量有限，多传几个参数就不够用了

实际上，正由于寄存器及其有限，fastcall 只允许前两个参数使用寄存器（ecx 和 edx），之后的参数使用栈传参。对于可变数量参数，全部的参数都使用栈传递。

因此，在 x86 下，我们非常建议各位使用栈传参。如果使用寄存器传参，最好确保参数个数不超过 2 个，否则管理寄存器资源会变成噩梦 😦

9.4.1 栈帧

当函数被调用时，运行时栈会预留一块区域，称为栈帧（Stack Frame，或活动记录 Activation Record）。栈帧存放着函数的实参、返回地址、局部变量和保存的寄存器。一个栈帧由以下步骤建立：

  1. 传递的实参被压入堆栈。
  2. 调用函数，使函数返回地址被推送到栈上。
  3. 当函数开始执行时，EBP 会被推送到堆栈上。
  4. EBP 设置成和 ESP 相等。从此，EBP 作为函数形参的基址参考。
  5. 如果存在局部变量，需要递减 ESP 以预留堆栈上的变量空间。
  6. 需要保护的寄存器被推送到堆栈中。
Tip

即使使用 PUSHAD，我们依然建议在此之前先单独 push 和设置 EBP。

使用 ESP 实现栈上数据的存储和逻辑删除。EBP 在当前栈帧内位置固定，因此函数中对大部分数据的访问都基于 EBP 进行。

汇编的传参形式有两种：值传参和引用传参。

压栈顺序

需要注意的是，两种传参的参数压栈顺序都是倒序的。参考等效 C 语言格式：int some_func(int var1, int var2)，则 var2 先压入，var1 后压入，从右往左。

数组必定使用引用传参，因为值传参代表它需要将每个元素都压入栈。使用 OFFSET 指令。

9.4.2 栈参数的调用和清理

现在我们来一个示例：

1
2
3
4
5
6
7
8
AddTwo PROC  push ebp  mov  ebp,esp  mov  eax,[ebp + 12]  add  eba,[ebp + 8]  pop  ebp  retAddTwo ENDP

使用栈传参时，需要将 EBP 压入栈，ESP 由系统自动管理，不需要我们操心。

如果我们调用了 AddTwo(5,6)，即：

1
2
3
push 6push 5call AddTwo

那么它的栈结构大概长这样：

AddTwo(5,6)的栈结构

如果我们想访问参数，那么用相对寻址。像 [ebp + 12] 这样用表达式引用实参的，我们称为显式栈参数 (Explicit Stack Parameter)。

有一个问题不知道你发现了没有：既然返回地址在实参下面，而当返回地址被弹出时，函数也退出了，那么剩下的实参怎么处理？

很遗憾，操作系统并不会在程序运行过程中自动回收它们。忽略它们？如果只用一层调用还好，但如果是嵌套调用呢？内层函数残留的栈实参在外层函数返回地址的下面，而 ESP 会读取实参作为地址！还记得我们在 C/C++ 所说的吗？标准结局就是内存访问冲突。

清理的理由有了，但怎么清理？POP 可不能把立即数 POP 出去啊。那么，既然栈实参不能物理移除，可不可以直接跳过它呢……

9.4.3 调用约定

调用约定 (Calling Convention) 确定了函数传参的传参形式、压栈顺序、返回值存储和清除栈方式。在 x86 Windows 下有两个主要的调用约定：C 调用约定 (CDECL) 和 STDCALL 调用约定。

C 调用约定和 STDCALL 的压栈顺序一致，即从右到左倒序压栈。而清除栈方式不一样：

  • C 调用约定是调用者清除 (Caller Cleanup)，在调用函数 CALL 的下一行对 ESP 进行加法，其值等于被调用函数参数的总大小。
  • STDCALL 是被调用者清除 (Callee Cleanup)，给予被调用函数 RET 一个操作数，其值等于被调用函数参数的总大小。此时系统会自动向 ESP 增加值。

STDCALL 可以确保调用者不会忘记清理栈，而 C 调用约定允许可变数量参数。

FASTCALL 使用 ECX 和 EDX 传递前两个参数，之后的参数使用栈传递。

所有调用约定的整数返回值均通过 EAX 返回。

FASTCALL 的翻身

随着 CPU 的进步，寄存器的数量增加，FASTCALL 也迎来了升级。x86-64 Windows 允许前 4 个、x86-64 Linux 允许前 6 个参数使用寄存器传参（从左到右顺序），其他参数使用栈传参（从右往左）。

FASTCALL 成为 x86-64 的唯一调用约定。不少函数实现了纯寄存器传参，因为长参数的函数还是少见的。

Tip

虽然你的程序你做主，但最好和汇编器一样遵守调用约定……

如果压栈参数在寄存器里，将寄存器压入栈，那么由调用者恢复寄存器：

1
2
3
4
5
6
mov ecx,eaxpush ecxpush OFFSET Arraycall some_funcadd esp,4pop ecx

压栈的参数长度必须为 4 字节（32 bit 下）。如果值传参发现参数长度不是 4 字节，则应该换用引用传参。

9.5 引用传参的使用

引用参数通常使用间接寻址访问。比如将一个数组的引用传递给 ESI：

1
2
3
4
5
6
mov esi,[ebp+12] ; offset of arraymov ecx,[ebp+8] ; array length; ...mov [esi],ax ; insert value in arrayadd esi,TYPE WORD ; move to next element; ...

9.6 综合示例

对于计科的同学，课程要求就到这里。

函数调用时的具体步骤如下：

  1. 主调函数将被调函数所要求的参数，根据相应的函数调用约定，保存在运行时栈中。该操作会改变程序的栈指针。
  2. 主调函数将控制权移交给被调函数（使用 CALL 指令）。函数的返回地址（待执行的下条指令地址）保存在程序栈中（压栈操作隐含在 CALL 指令中）。
  3. 被调函数会设置帧基指针 ESP
  4. 被调函数通过修改栈顶指针的值，为自己的局部变量在运行时栈中分配内存空间，并从帧基指针的位置处向低地址方向存放被调函数的局部变量和临时变量。
  5. 如有必要，被调函数会保存希望调用前后保持不变的寄存器值。
  6. 被调函数执行自己任务，此时可能需要访问由主调函数传入的参数。若被调函数返回一个值，该值通常保存在一个指定寄存器中 (如 EAX)。
  7. 一旦被调函数完成操作，为该函数局部变量分配的栈空间将被释放。这通常是步骤 4 的逆向执行。
  8. 恢复步骤 3 中保存的寄存器值，包含主调函数的帧基指针寄存器。
  9. 被调函数将控制权交还主调函数 (使用 ret 指令)。根据使用的函数调用约定，该操作也可能从程序栈上清除先前传入的参数。
  10. 主调函数再次获得控制权后，可能需要将先前的参数从栈上清除。在这种情况下，对栈的修改需要将帧基指针值恢复到步骤 1 之前的值。

步骤 3 与步骤 4 在函数调用之初常一同出现，统称为函数序 (prologue)；步骤 6 到步骤 8 在函数调用的最后常一同出现，统称为函数跋 (epilogue)。

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
; lab5_2.asm - Watermelonabc 2026/4/18; 本程序用于求给定有符号数列中，绝对值比目标数 X 更大的最小负奇数; 若存在，输出此数的绝对值；若不存在，输出 0include Irvine32.inc.dataTAB dword 5 dup(?)datSize = ($ - TAB)/4X dword 9Min dword ?.code; dword _cdecl getMin(dword* src,dword goal,dword leng) [ebp+8,ebp+12,ebp+16]; src 地址、goal 和 leng 通过堆栈传参; 返回值通过 eax 返回，表示 Min 的绝对值getMin PROC    push ebp    mov ebp,esp    push esi    push edx    push ebx    mov esi,[ebp+8]    mov ebx,[ebp+12]    mov ecx,[ebp+16]    mov eax,0    mov edx,0    isMin:        mov edx,[esi]        cmp edx,0        jge notMin ; is below 0?        and edx,1h        cmp edx,1        jne notMin ; is odd number？        mov edx,[esi]        neg edx        cmp edx,ebx        jle notMin ; is bigger than X?        cmp eax,edx        jg notMin ; is bigger than current Min?        mov eax,edx        notMin:        add esi,4    loop isMin    pop ebx    pop edx    pop esi    pop ebp    retgetMin ENDPmain PROC    mov esi,OFFSET TAB    mov ecx,datSize    input:        call ReadInt ; read a signed 32 bits integer from console and put into EAX        mov [esi],eax        add esi,4    loop input    push datSize ; leng    push X       ; goal    push OFFSET TAB ; *src    call getMin    add esp,12    mov Min,eax    call WriteDec ; get an unsigned 32 bits integer from EAX and write to console    exitmain ENDPEND main

9.7 局部变量

和参数不一样，局部变量是顺序 “入栈” 的。局部变量的值不是 PUSH 入栈的，而是先在栈上用 ESP 预留空间，然后直接向预留的栈空间写入局部变量。比如，一个 C 函数：

1
2
3
4
5
void MySub(){  int X = 10;  int Y = 20;}

在 x86 汇编中呈现为：

1
2
3
4
5
6
7
8
9
10
MySub PROCpush ebpmov  ebp,espsub  esp,8 ; reserve space for locals in stackmov  dword PTR [ebp-4],10 ; Xmov  dword PTR [ebp-8],20 ; Ymov  esp,ebp ; remove locals from stackpop  ebpretMySub ENDP

栈帧大致表现为：

MySub()的栈帧

注意此处由于只保存了 ebp 寄存器，而它又属于栈底，因此直接将 esp 移到 ebp 就好了。如果你还使用了其他寄存器，那么还请你手动清理，再移动。

LEAVE 指令等效于清理局部变量的那两条指令。

如果是一个数组呢？同样预留空间，但是预留的空间应该符合字节对齐，宜大不宜小。并且用 LEA (Load Effective Address) 指令获取地址。OFFSET 对栈上地址没有用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
makeArray PROC  push ebp  mov  ebp,esp  sub  esp,32  lea  esi,[ebp-30] ; load address of myString  mov  ecx,30  L1:    mov BYTE PTR [esi],'*'    inc esi  loop L1  add  esp,32 ; remove the array (restore ESP)  pop  ebp  retmakeArray ENDP

同样有 ENTER 和 LEAVE 指令可以为我们预留局部变量的栈空间。

ENTER 会 push EBP、设置 EBP 和 ESP 相等并减少 ESP 以预留栈空间。它有两个操作数：numbytes, nestinglevel。numbytes 是你希望预留的字节数，nestinglevel 决定了从前一帧复制到新栈帧中的栈帧指针数量。

Note

nestinglevel 中的 nesting 指的是嵌套函数。在嵌套函数中，函数作用域是既包含又独立的。如果不将外层函数的帧复制到内层函数，那么万一内层函数需要外层函数的变量，就没处找了！

在这里，我们将 nestinglevel 固定为 0，只修改 numbytes。

LEAVE 没有操作数，它将 ESP 设置为和 EBP 相等并弹出 EBP 以恢复栈。

而 MASM 提供了一个 ENTER 的上位替代指令：LOCAL。它更接近我们使用的参数表：

1
2
3
LOCAL temp:DWORD, SwapFlag:BYTE ; Two locals var: temp and SwapFlagLOCAL pArray:PTR WORD ; A pointer to a 16 bits integerLOCAL TempArray[10]:DWORD ; An array of 10 DWORD

AP. CTF 中常见汇编知识

Tip

Source: Quick Start：汇编语言 - Hello CTF 和 [调试逆向] 逆向基础笔记六 汇编跳转和比较指令 - 52pojie

了解了一些基本的汇编指令后，下面我们来看看 CTF 中常见的一些指令：

  1. loop 循环指令：
1
2
3
4
5
6
7
mov rax,0mov rcx,236s:add rax,123loop sleaveret

上面的指令执行的是对 123 累加 236 次，从以上代码中我们可以看到，rcx 寄存器保存的是循环次数，loop 指令每执行一次，rcx 的数值就会减少 1，当其数值减少到 0 时，loop 指令就会停止，继续执行下面的指令。

  1. 无条件跳转指令：
1
2
3
4
lable:mov edx,0jmp lable

无条件跳转指令为 jmp，其意思从字面上就可以看出来，只要是执行到 jmp 这里，无论什么情况，都会直接跳转到 lable 的代码块中继续往下执行指令。

  1. 条件跳转：
1
2
3
4
5
lable:mov ebx,1cmp ebx,0je lable

以上代码将 ebx 的值与 0 对比，如果相等，则会跳转到 lable 处，条件跳转指令 je 代表相等则跳转，还有其他与之条件不一样的条件跳转指令，一般条件跳转指令是与 cmp、test 指令混在一起用的。以上代码也可以用 test 来写：

1
2
3
4
5
lable:mov ebx,1test ebx,0jnz lable

test 是逻辑与指令，以上代表的即为 ebx&0，jnz 代表标志位为 0 就跳转，其实现效果与 cmp 相同。

下面是一些常见的条件跳转指令：

指令英文全称含义判断标志位
JE, JZjump equal，jump zero结果为零则跳转 (相等时跳转)ZF=1
JNE, JNZjump not equal，jump not zero结果不为零则跳转 (不相等时跳转)ZF=0
JSjump sign结果为负则跳转SF=1
JNSjump not sign结果为非负则跳转SF=0
JP, JPEjump parity，jump parity even结果中 1 的个数为偶数则跳转PF=1
JNP, JPOjump not parity，jump parity odd结果中 1 的个数为偶数则跳转PF=0
JOjump overflow结果溢出了则跳转OF=1
JNOjump not overflow结果没有溢出则跳转OF=0
JB, JNAEjump below，jump not above equal小于则跳转 (无符号数)CF=1
JNB, JAEjump not below，jump above equal大于等于则跳转 (无符号数)CF=0
JBE, JNAjump below equal，jump not above小于等于则跳转 (无符号数)CF=1 or ZF=1
JNBE, JAjump not below equal，jump above大于则跳转 (无符号数)CF=0 and ZF=0
JL, JNGEjump less，jump not greater equal小于则跳转 (有符号数)SF≠ OF
JNL, JGEjump not less，jump greater equal大于等于则跳转 (有符号数)SF=OF
JLE, JNGjump less equal，jump not greater小于等于则跳转 (有符号数)ZF=1 or SF≠ OF
JNLE, JGjump not less equal，jump greater大于则跳转 (有符号数)ZF=0 and SF=OF

下面是一些常见的位运算指令：

  • AND：与运算，AND AX,BX 将 AX 与 BX 进行逻辑与运算，并将结果保存到 AX 寄存器中
  • OR：或运算，OR AX,BX 将 AX 与 BX 进行逻辑或运算，并将结果保存到 AX 寄存器中
  • XOR：异或运算，XOR AX,BX 将 AX 与 BX 进行异或运算，并将结果保存到 AX 寄存器中
  • NOT：取反操作，NOT CX 将 CX 进行取反，并将结果保存到 CX 寄存器中
  • TEST：逻辑与运算，TEST AX,BX 将 AX 与 BX 进行与运算，并设置标志位，结果不保存
  1. 函数传参：

在汇编中，我们有时候需要知道参数被保存在那个寄存器里，这里我列举一般情况：

通常函数的返回值保存在 ax 寄存器里，比如 eax，rax 等； 函数的参数一般按顺序保存在 cx、dx、si 中，在 64 位汇编中，一般按 rcx, rdx, r8, r9, r10, r11, ... 的顺序保存参数。

有时候根据函数调用约定以及编译器和平台的不同，这个储存规律也会发生改变，我们需要根据当时情况动态调整。

  1. lea 地址加载：

其使用格式为 lea rdx,[my_var]，将 my_var 的地址而不是内容赋值给 rdx 寄存器。

  1. xchg 数值交换指令：

其使用格式为 xchg ax,bx 将 ax 和 bx 的数值交换。

]]> https://blog.watermelonabc.top/p/57f94527/ 2026-03-24T12:22:30.000Z x86 平台的汇编语言的笔记，本部分为语言知识 x86 汇编语言详解 -2 2026-08-18T15:20:45.000Z Watermelonabc 杂记部分

在广外的大学城校区比赛！体育场比 FZU 大太多了，而且貌似别的学校也有类似的规模的体育场所？！太羡慕了

被 Web 学长和 Pwn 队友带飞的一集，我这个 Re 手还是太 fw 了 QAQ

最终没有 AK 零食……

不过居然是一等奖！好欸！-

]]> https://blog.watermelonabc.top/p/c392bccc/ 2026-03-23T12:25:51.000Z 蒟蒻的第一次 CCB 线下赛 ;) CCB 2026 Half-Final Guangzhou 2026-08-04T09:53:11.000Z Watermelonabc
Note

本题为 “中国高校智能机器人创意大赛产教融合赛道 - 软件系统安全赛” 的 re1，可惜的是我在比赛期间没有解出。只能说恐怕离了 AI 我就啥也不是了哎 😔

1. 题目背景

本题的参考项目应该是这个：Malicious-PixelCode。GitHub 提交记录显示是 25 年 11 月上传的，算是一个 Real World 题目了。

首先，计算机中的视频本质上仍是一串字节序列，只要是字节序列就会有程序可以读取。

你可以观看 不依赖三方库和框架，直接操纵像素在 CPU 上跑 Shader | Tsoding，看看纯代码是如何生成简单图像和视频的。

像素代码 (Pixel Code) 是以可视化像素的形式表示二进制数据的技术。每个像素通过将可执行字节转换为结构化的彩色矩阵来编码原始文件的一小部分，数据可以存储、传输或嵌入图像或视频中而不暴露原始形式。

该技术常被用于研究数据混淆、隐蔽存储和非常规编码通道。通过将恶意软件转化为基于像素的表示形式，攻击者可能试图将其负载伪装成无害的多媒体内容。这些编码文件随后可以上传到合法平台，绕过传统的安全过滤器，向外界传达一种可信赖的假象。攻击者控制的加载器或解码器随后可以检索视频并重建原始恶意文件。

整体流程是这样的：

Pixel Code Workflow

  1. 编写攻击负载并构建为可执行文件
  2. 生成的可执行文件会通过专门设计用于将二进制数据转换为像素代码的基于 Python 的工具进行处理。该工具将可执行文件转换为可视化的 MP4 视频，二进制字节以像素值的形式嵌入帧中。
  3. 生成 Pixel Code MP4 文件后，会作为标准视频上传到视频平台。
  4. 编写 Python Stager 脚本以从视频中重建代码
  5. 将 Stager 脚本转换为编码序列（这里是先转成 EXE 再 Base64 一次），嵌入加载器代码
  6. 构建加载器

当目标机器下载并运行加载器后，加载器会自动从视频网站下载视频。然后加载器重建 Stager 脚本，Stager 脚本再从视频里重建攻击负载，最后攻击负载执行，实现攻击目的。

2. 题目分析

本题给了两个文件：ELF 格式的 Loader 和 video.mp4。打开 video.mp4 的话会看到一系列条码在 “滚动”。

加载 Loader 会发现附带调试信息，因此总体是比较清晰的：

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
int __fastcall main(int argc, const char **argv, const char **envp){  __int64 v3; // rax  __int64 v4; // rax  __int64 v5; // rax  int v6; // ebx  __int64 v7; // rax  const char *file; // rax  _BYTE v10[9]; // [rsp+7h] [rbp-99h] BYREF  _BYTE *v11; // [rsp+10h] [rbp-90h]  _BYTE *v12; // [rsp+18h] [rbp-88h]  __int64 videoFile[4]; // [rsp+20h] [rbp-80h] BYREF  __int64 src[4]; // [rsp+40h] [rbp-60h] BYREF  __int64 File[7]; // [rsp+60h] [rbp-40h] BYREF  File[5] = __readfsqword(0x28u);  *(_QWORD *)&v10[1] = v10;  std::string::basic_string(videoFile, "video.mp4", v10);  std::__new_allocator<char>::~__new_allocator(v10);  if ( file_exists(videoFile) )  {    v11 = v10;    std::string::basic_string(      File,      stager_pyc_base64,                        // "delete"      v10);                                     // "delete"    base64_decode(src, File);    std::string::~string();    std::__new_allocator<char>::~__new_allocator(v10);    v12 = v10;    std::string::basic_string(File, "stager.pyc", v10);    std::__new_allocator<char>::~__new_allocator(v10);    if ( (unsigned __int8)write_string_to_file((__int64)File, src) == 1 )    {      file = (const char *)std::string::c_str(File);      chmod(file, 493u);      run_python_script(File);      v6 = 0;    }    else    {      v7 = std::operator<<<std::char_traits<char>>(&std::cerr, "创建 stager.pyc 失败");      std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);      v6 = 1;    }    std::string::~string();    std::string::~string();  }  else  {    v3 = std::operator<<<std::char_traits<char>>(&std::cerr, "错误：未找到视频文件 ");    v4 = std::operator<<<char>(v3, videoFile);    std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);    v5 = std::operator<<<std::char_traits<char>>(&std::cerr, "请确保 video.mp4 位于当前目录");    std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);    v6 = 1;  }  std::string::~string();  return v6;}

Loader 的逻辑是：

graph LR  A(检查 video.mp4 是否存在) -->|是| B(加载并解码脚本字节序列)  A -->|否| C(抛出错误)  B --> D(将解码结果写入 stager.pyc)  D -->|成功| E(加权限，执行脚本)  D -->|失败| F(抛出错误)

这里出题者将 Stager.pyc 的字节序列删除了，只留下 "delete"，但是查看 .data 段会发现攻击用的负载编码器的编码序列没有删除。将其 dump 下来并保存为 .pyc 文件，反编译得到：

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
from PIL import Imageimport mathimport osimport sysimport numpy as npimport imageiofrom tqdm import tqdmdef file_to_video(input_file, width, height, pixel_size, fps, output_file = (640, 480, 8, 10, 'video.mp4')):    if not os.path.isfile(input_file):        return None    file_size = None.path.getsize(input_file)    binary_string = ''    with None:        f = open(input_file, 'rb')        for chunk in None(None((lambda : f.read(1024)), b''), math.ceil(file_size / 1024), 'KB', '读取文件', **('iterable', 'total', 'unit', 'desc')):            binary_string += ''.join((lambda .0: pass)(chunk))    xor_key = '10101010'    xor_binary_string = ''    for i in range(0, len(binary_string), 8):        chunk = binary_string[i:i + 8]        if len(chunk) == 8:            chunk_int = int(chunk, 2)            key_int = int(xor_key, 2)            xor_result = chunk_int ^ key_int            xor_binary_string += f'''{xor_result:08b}'''            continue        xor_binary_string += chunk        binary_string = xor_binary_string    pixels_per_image = (width // pixel_size) * (height // pixel_size)    num_images = math.ceil(len(binary_string) / pixels_per_image)    frames = []    for i in tqdm(range(num_images), '生成视频帧', **('desc',)):        start = i * pixels_per_image        bits = binary_string[start:start + pixels_per_image]        if len(bits) < pixels_per_image:            bits = bits + '0' * (pixels_per_image - len(bits))        img = Image.new('RGB', (width, height), 'white', **('color',))        for r in range(height // pixel_size):            row_start = r * (width // pixel_size)            row_end = (r + 1) * (width // pixel_size)            row = bits[row_start:row_end]            for c, bit in enumerate(row):                color = (0, 0, 0) if bit == '1' else (255, 255, 255)                x1 = c * pixel_size                y1 = r * pixel_size                img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))                            frames.append(np.array(img))        with imageio.get_writer(output_file, fps, 'libx264', **('fps', 'codec')) as writer:        for frame in tqdm(frames, '写入视频帧', **('desc',)):            writer.append_data(frame)if __name__ == '__main__':    input_path = 'payload'    if os.path.exists(input_path):        file_to_video(input_path)    else:        sys.exit(1)

对照原始项目脚本，将原始项目脚本修改为：

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
from PIL import Imageimport math, osimport numpy as npfrom moviepy import ImageSequenceClipfrom tqdm import tqdm# tqdm 是进度条的库def file_to_video(input_file, width=640, height=480, pixel_size=8, fps=10):    if not os.path.isfile(input_file):        print(f"Error: File '{input_file}' does not exist.")        return    file_size = os.path.getsize(input_file)    binary_string = ""    with open(input_file, "rb") as f:        for chunk in tqdm(iterable=iter(lambda: f.read(1024), b""),                          total=math.ceil(file_size/1024), unit="KB"):            binary_string += "".join(f"{byte:08b}" for byte in chunk)    xor_key = '10101010'    xor_binary_string = ''    for i in range(0, len(binary_string), 8):        chunk = binary_string[i:i + 8]        if len(chunk) == 8:            chunk_int = int(chunk, 2)            key_int = int(xor_key, 2)            xor_result = chunk_int ^ key_int            xor_binary_string += f'''{xor_result:08b}'''            continue        xor_binary_string += chunk    binary_string = xor_binary_string    pixels_per_image = (width // pixel_size) * (height // pixel_size)    num_images = math.ceil(len(binary_string) / pixels_per_image)    frames = []    for i in tqdm(range(num_images), desc="Generating frames"):        start = i * pixels_per_image        bits = binary_string[start:start + pixels_per_image]        img = Image.new('RGB', (width, height), color='white')                if len(bits) < pixels_per_image:            bits = bits + '0' * (pixels_per_image - len(bits))        for r in range(height // pixel_size):            row = bits[r * (width // pixel_size):(r + 1) * (width // pixel_size)]            for c, bit in enumerate(row):                color = (0, 0, 0) if bit == '1' else (255, 255, 255)                x1, y1 = c * pixel_size, r * pixel_size                img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))                frames.append(np.array(img))        # print(frames)    clip = ImageSequenceClip(frames, fps=fps)    clip.write_videofile('video.mp4', fps=fps, codec='libx264')    print("Video generated successfully: video.mp4")if __name__ == "__main__":    print("Convert file → video")    path = input("Enter file path: ")    file_to_video(path)

脚本主要分成两部分：将程序转化成二进制流并作按位异或处理；将二进制流以 8bits 为一个单位，设定位置和颜色，最终生成一个 640 × 480 @ 10FPS 的 mp4 视频文件。

Info

我怎么发现这个 GitHub 项目的呢？我在解码 pyc 文件后，发现解码结果中间有一些合法的文件名，比如 Payload_To_PixelCode_video.py，于是我就拿到 Bing 上搜，一下就搜到了这个项目（

现在正向转换我们知道是怎么回事了，但逆过来呢？

背景项目提供了一个解码器：

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
import imageioimport numpy as npimport osdef frames_to_bits_auto(frames):    bits_list = []    for frame in frames:        gray = np.mean(frame, axis=2)        h, w = gray.shape        pixel_size_h = max(1, h // 256)        pixel_size_w = max(1, w // 256)        pixel_size = min(pixel_size_h, pixel_size_w)        h_blocks = h // pixel_size        w_blocks = w // pixel_size        cropped = gray[:h_blocks * pixel_size, :w_blocks * pixel_size]        reshaped = cropped.reshape(h_blocks, pixel_size, w_blocks, pixel_size)        block_means = reshaped.mean(axis=(1, 3))        block_bits = (block_means < 128).astype(np.uint8)        bits_list.append(block_bits.ravel())    if not bits_list:        return np.array([], dtype=np.uint8)    return np.concatenate(bits_list)def bits_to_file(bits, output_file):    remainder = bits.size % 8    if remainder:        bits = bits[: bits.size - remainder]    if bits.size == 0:        return False    packed = np.packbits(bits, bitorder='big')    try:        with open(output_file, 'wb') as f:            f.write(packed.tobytes())        return True    except:        return Falsedef video_to_exe(video_path, output_name="Final_Result"):    if not os.path.exists(video_path):        return False    try:        reader = imageio.get_reader(video_path, 'ffmpeg')    except:        return False    frames = []    try:        for frame in reader:            frames.append(frame)    except:        reader.close()        return False    reader.close()    bits = frames_to_bits_auto(frames)    return bits_to_file(bits, output_name)if __name__ == "__main__":    video_file = "Pixel_Code_Video.mp4"    out_exe = "Final_Result"    success = video_to_exe(video_file, out_exe)    if success and os.path.exists(out_exe):        try:            print("Reconstruction Success.\n")            # os.startfile(out_exe)          except:            print("Reconstruction Failed.\n")

对比原项目提供的编码器，我们发现题目中编码器只修改了两点：一是程序字节转二进制流时的按位异或，二是二进制流数据不够时补 0。第二点在逆向时不需要关注，因此我们只需要确定这个异或操作应该出现在解码器的哪个位置。

从编码器来看，异或操作位于程序字节转成二进制流之后，那么编码器生成二进制流之后需要经过一次异或才是原始程序字节。逆异或操作位于 numpy 打包完成二进制流之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# ...def undo_xor(data):    return bytes([b ^ 0xAA for b in data]) # 0xAAh = 10101010bdef bits_to_file(bits, output_file):    remainder = bits.size % 8    if remainder:        bits = bits[: bits.size - remainder]    if bits.size == 0:        return False    packed = np.packbits(bits, bitorder='big')    decoded = undo_xor(packed.tobytes())    try:        with open(output_file, 'wb') as f:            f.write(decoded)        return True    except:        return False# ...

执行修改后的脚本，得到 Final_Result。使用 IDA 反编译，查看 .rodata 段，得到 “提示：每个 MD5 哈希对应一个 ASCII 字符，按顺序组合这些字符即可得到 flag。” 以及 20 个 MD5 值。解密这些 MD5 值，得到 flag：

dart{2b1f8-3045e76c}

]]> https://blog.watermelonabc.top/p/698c60bb/ 2026-03-19T11:13:43.000Z 何等 Pixel Art 的代码 视频也可以含恶意代码吗 2026-08-13T04:22:01.000Z Watermelonabc 封面来源：新华社 你好，2026

和ROIS队友们联机Minecraft
和 ROIS 队友们联机 Minecraft

Hi，这里是 Watermelonabc

不知不觉间，又来到 2026 年，我已经迎来人生的第 2 个 10 周年。再过三周，我的博客也将迎来建站的 1 周年（以 Git 提交时间计）

老实说，我现在的感受有点…… 暗淡？因为我实在没有什么认为值得说道的，也许是终于加入了 ROIS 团队，认识了一群可亲可爱的队友和学长？在 ROIS，我也实现了人生中第一次出省旅行（9th XCTF Finals，浙江宁波，比赛主要是学长在打哈 X^X）

但除了这些小浪花呢？每天仿佛是一样的过，上课、呆实验室、呆宿舍。上半年我还有闲情雅致出校游玩，但进入大二，工作日奉献给了教室，而周末则一头扎进实验室或者在宿舍赋闲，顶多去趟学生街，基本没出过校园范围。

讲真这样的生活确实有些单调，更可怕的是我已经没有能力为这无聊的生活增添些许色彩的平衡。

我追求完美，但这世界总有缺陷，因此经常会构建一种 “完美” 的自己，并陷入其中。我们常常将这种想象称为 “白日梦”“中二病”。然而泡泡是脆弱的，现实并不会放任它膨胀，于是想象过后是落差的羞耻。有言道，“知耻而后勇”，但在我这里，很多时候往往是 “知耻而后退”。于是，没有进一步的勇气，只好搁置那想象中的 “理想自我”，最后腐烂。

这 “完美” 要命的点在于，人们总觉得干 “正事” 才会追求完美，但对于我而言，干 “不那么正的事” 同样要追求完美，故培养兴趣的时候，我总是 “三分钟热度”，干柴烈火一番后认识到落差，便迅速冷却。换句话说，我好像没有一个认为值得拿出来谈论的所谓 “兴趣爱好”。

由 “完美” 又引出 “控制欲”，因为那想象中的 “完美” 自己是得心应手、掌控一切的。于是你会发现这会影响我生活的方方面面：我不希望别人中途打扰我的工作，也难以开口求助；我倾向于模拟经营类游戏，且会开 Trainer（单人情况下，联机还是要遵守服务器规则的）…… 一点点变量的引入都可能会导致自娱自乐的小框架的崩塌。（虽然这框架本就摇摇欲坠）

“你以后想干什么？” 从家庭、学校到社会，我被持续地追问这个问题，然而，我竟不能给出一个令我自己信服的答案，每次都是敷衍了事。所以我到底是个什么东西呢？答案依然在风中飘 -^- 或许也是我无法设计出自己的兽设的原因吧，毕竟若如许多大大所说的 “furry 是真实自我的展现” 的话，那么当我自己被虚假的期望包裹时，又如何知晓那个 “真实的自己” 是个什么样子呢？

和一位Furry老师的合影，也是跨年夜唯一一张集邮🥲
和一位 Furry 老师的合影，也是跨年夜唯一一张集邮🥲

多么可笑啊，明明自己为了和毛毛互动才搭地铁到宝龙，但真的见到 TA 们上毛的时候，却没有勇气上前拍照合影，只敢在一旁看着，但这倒显得我像个神必跟踪狂了。无论如何都无法完美啊。

总之，日子依然要一天天过下去……

]]> https://blog.watermelonabc.top/p/12511374/ 2025-12-31T14:31:49.000Z 也许是2025年总结（负能量致歉！） Hello,2026 2026-08-13T03:25:03.000Z Watermelonabc LightSummary

基础数据结构

数组 (Array) 占据一块连续的内存，索引和遍历速度快 (O(1)O(1))，但其他操作就慢了（插入、删除的时间复杂度是 O(n)O(n)），大小也不能伸缩

动态数组 (Dynamic Array) 可以随着数据量的增加而扩展（但理论上不能缩小），C++ 的 vector<T> 实现了这个数据结构。但是插入和删除依然很慢。

Note

可以参照一般数组使用，因此在使用下标访问时，请确保 vector 已经分配内存。圆括号用于指定空间大小，如果需要追加数据，请使用 push_back() 方法。

链表 (linked List) 基于节点 (node) 组成，在内存中一般不连续，C++ 的 list<T> 实现了这个数据结构（双向链表）。链表可以在 O(1)O(1) 复杂度下实现插入和删除操作，但访问操作又退化到 O(n)O(n) 了，所以很多时候也挺慢 😦

1
2
3
4
5
6
struct Node{int data;Node* pNext;Node* pPrev;};

数组的下标只能是非负整数，而散列表 (Hash Table) 可以以任意标识访问元素，因为它是键值对 (key-value pair) 组成的。散列表的查询、插入和删除速度都很快 (理论上是 O(1)O(1))。C++ 的 unordered_map<T, P> 和 unordered_set<T> 实现了这个数据结构。两者的不同在于 map 有键值对，是标准的散列表；而 set 没有，更像数学中的 “集合” 概念（既然是集合，那么 set 中的元素都是不重复的）。

注意到 “unordered” 了吗？散列表是不能排序的

先考虑最简单的情况，仅用一个数组来实现哈希表。在哈希表中，我们将数组中的每个空位称为桶 (bucket)，每个桶可存储一个键值对。因此，查询操作就是找到 key 对应的桶，并在桶中获取 value。

如何基于 key 定位对应的桶呢？这是通过散列函数 (hash function) 实现的。换句话说，我们通过散列函数为每个 key 分配（唯一的）桶位。

1
2
3
4
size_t hash(int key){return key % n; // n 为桶的数量}

散列函数本身也是有运行成本的！

使用上面的散列函数，我们很快遇到一个问题：有好几个 key 指向同一个桶位！我们称之为散列冲突 (Hash Collision)。

散列冲突的一个解决方法是链式地址 (separate chaining)。我们将冲突的键值对通过链表（有时也用 vector<T>）连接起来，输入 key 后先遍历桶，再遍历桶下的冲突链。

队列 (Queue) 和栈 (Stack) 都是关于 push（推入）和 pop（弹出）的数组 / 队列，区别在于队列是先进先出 (FIFO) 的，栈是后进先出 (LIFO) 的。C++ 分别用 queue<T> 和 stack<T> 实现

二叉树 (Binary Tree) 是一个树状数据结构，用于快速搜索、插入和删除。它经常作为散列表的替代，速度稍慢 (O(log⁡N)O(\log{N}))，但使用时是排序好的

堆 (Heap) 是一种二叉树的特例，用数组实现，常用于优先队列 (priority queue)

实践部分

有些算法和数据结构可以直接用标准库的，毕竟这篇是 “功利性质” 的，就没有重复造轮子的必要了。

注意 “数据保证 XX”，这说明我们不需要考虑判断输入的数据是否符合 XX 条件，因为已经保证它符合这个 XX 条件了（系统不会在酒吧里点炒饭的）

考 FZU DS 原题，分为栈、队列、排序、二叉搜索树以及图和路径

CPP “万能” 文件头：<bits/stdc++.h>

下面是 DS 题目与配套的 AC 代码（感谢 LuminaryDawn 整理提供 😃）

另附 .pbs 文件，你可以导入小熊猫 C++ 实现本地自动判题：FZU DS.pbs

如果你想 “背诵”，建议背关键算法的描述，除非你认为自己真的能像背课文那样把一行行代码背下来

实际考试为了降低难度，较简单题的分数是比较高的。
注意 PTA 的补全提示很少，复习时不要依赖 IDE 的补全
如果想通过，总分应该在 50 分以上

表

亚克星上的军队

★实验任务

亚克星上住着许多神奇的生物。其中有聪慧的人族、优雅的精灵、彪悍的野蛮猪、粗鲁的首任驻….有一天，住在湛蓝球上的恶魔们突破空间的封锁入侵这个美丽的星球。为了保卫共同的家园，亚克星各族不得不摒弃前嫌，组成联盟。为了更有利的反击恶魔们的入侵，他们建立了统一的军事指挥中心。在前期，指挥中心会不停的发布军队调动命令，可是，麻烦来了。为了更好的做出决策，指挥中心必须迅速了解己方的各地区的军事力量详情。你能否帮帮这些可怜的种族呢？

每个地区有一个编号（从 1 到 N），如果一个地区有军队的话，这些军队将组成一个军团。指挥中心将发布的命令如下：

U a b:将 b 地区军团的调到 a 地区，从而组成一个新的军团。为了便于管理，每次新加入的军队将按顺序加入到 a 军团后面。数据保证 a 与 b 不相同。

I a x:将一支人数为 x 的军队调到 a 地区。为了便于管理，每次新加入的军队将加入到 a 军团前面。

D a x:将 a 地区中军队人数为 x 的调走。若不存在，则不执行。

Q a：询问 a 地区的具体军事信息（即按顺序输出该军团中每个军队的人数）。

★数据输入

输入第一行为两个正整数 N ,M (2 <= N,M <= 1000)。

接下来 N 行，每行第一个数 K 表示该地区军队的个数 K (1<=K<=100)，接下来 K 个数, 表示各个军队的人数信息 (0<=a_i<2^31)。

接下来 M 行，每行一个操作。

★数据输出

对于每个询问操作，输出一行表示 a 地区具体军事信息，每两个数之间空格隔开，行末无空格。若 a 内无元素，输出 -1。

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
#include <bits/stdc++.h>using namespace std;typedef long long ll;int main() {// 基于流的 I/O 优化// std::cin.tie(nullptr); // 解除关联// std::ios::sync_with_stdio(false); // 关闭同步ll n,m; // n: 区域数；m: 操作数cin >> n >> m;vector<list<ll>> listt(n); // 存储各区域的军事信息for (ll i = 0; i < n; i++) {ll t;cin >> t; // t: 军队个数for (ll j = 0; j < t; j++) {ll temp;cin >> temp; // temp: 各军队人数listt[i].push_back(temp);}}for (ll i = 0; i < m; i++) {char type;cin >> type;if (type == 'U') {ll a,b;cin >> a >> b;a--;b--; // 编号从 1 到 N，减 1 和数组下标对齐listt[a].splice(listt[a].end(), listt[b]); // splice(a, b) 将 b 的内容转移到 this*，位置为 a}else if (type == 'I') {ll a,x;cin >> a >> x;a--;listt[a].push_front(x); // list 的向前插入}else if (type == 'D') {ll a,x;cin >> a >> x;a--;listt[a].remove(x); // remove() 移除符合特定条件的元素}else if (type == 'Q') {ll y;cin >> y;y--;if (listt[y].empty()) {cout << "-1\n";}else {bool first = true;for (auto j : listt[y]) {if (!first) cout << " ";cout << j;first = false;}cout << "\n";}}}return 0;}

洗盘子

★实验任务

猪妈妈有很多小猪仔，每次吃完饭洗盘子是一个很大的问题。这天猪妈妈想出了一个方法。她让小猪们排成一队，从 2 开始给他们编号。每次排在最前面的不用洗盘子（假设它的编号是 i ），但是，排在它后面的第 i 只 ，2 i 只，3 i 只… 的小猪要洗盘子。让排在最前面以及要洗盘子的小猪出队，然后重复上述过程。那些不用洗盘子的小猪被称为幸运猪（lucky pigs），把它们的编号从小到大排序，现在要问第 n 个幸运猪的编号是多少。

比如说一开始，在最前面的小猪编号是 2，那么它不用洗盘子，出队。在它后面的第 2 只小猪，就是编号为 4 的小猪要洗盘子，编号为 6, 8, 10… 的小猪都要洗盘子，然后它们都出队。其中编号为 2 的小猪就是第一只幸运猪了。接下排在最前面的小猪编号是 3，它是幸运猪，出队。在它后面的第 3 只，就是编号为 9 的小猪要洗盘子，出队。以此类推。

★数据输入

输入第一行为 T ，代表接下去有 T 个询问， 0 < T <=300

接下去有 T 行，每行一个数 n ，0 < n <=3000

★数据输出

对于每个询问输出一行，为第 n 个幸运猪的编号。

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
#include <iostream>#include <vector>using namespace std;int main() {int T;cin >> T;vector<int> luckyPigs;vector<int> pigs;for (int i = 2; i <= 100000; i++) {pigs.push_back(i); // 初始化猪仔编号向量}while (luckyPigs.size() < 3000 && !pigs.empty()) { // 限制求解规模int lucky = pigs[0]; // 每次排在最前面的不用洗盘子luckyPigs.push_back(lucky); // 编号推入 luckyPigs 向量vector<int> keep; // 没被叫去洗盘子for (int j = 1; j < pigs.size(); j++) {if ((j % lucky) != 0) {keep.push_back(pigs[j]);}}pigs = keep;}while (T--) {int n;cin >> n;cout << luckyPigs[n - 1] << endl;}return 0;}

队列

Rescue the princess

★实验任务

有一天，公主被一个魔王抓走关在一个城堡里面，城堡可以用 N * M 的矩阵来描述，1 < N, M <= 200。监狱由 N * M 个方格组成，每个方格中可能为墙壁，空地，怪物，公主或者是勇士。

现在勇士想去营救公主。他的任务是找到公主。约定，“找到公主” 的意思是到达公主被关的位置。如果勇士想到达某个方格，但方格中有怪物，那么必须杀死怪物，才能到达这个方格。假设勇士只能向上，下，左，右四个方向移动一步。移动一步的需要花费 1 个单位的时间，杀死怪物也需要一个单位的时间。

试着计算勇士找到公主需要多长时间。只能上，下，左，右移动，而且墙壁不能通过。

★数据输入

输入第一行包含 2 个整数 N，M，接下来 N 行，每行 M 个字符：. 代表空地，a” 表示公主，r 表示勇士， # 代表墙壁， x 表示怪物。（测试数据中 a 和 r 只有一个）。

★数据输出

输出一个整数，表示找到公主所需要最短的时间。如果无法找到公主，输出 -1。

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
#include <bits/stdc++.h>using namespace std;struct Node {int x, y, time;// 重载大于运算符，比较两个 Node 等价于比较两个 Node.timebool operator>(const Node& other) const {return time > other.time;}};int main(){int n, m;cin >> n >> m;vector<string> grid(n);int start_x=-1, start_y =-1, end_x=-1, end_y=-1;// 读入地图，初始化坐标for(int i=0;i< n;i++){cin >> grid[i];for(int j=0;j<m;j++){if(grid[i][j] == 'r'){start_x = i;start_y = j;}if(grid[i][j] == 'a'){end_x = i;end_y = j;}}}// 方向向量，表示移动方式int dx[4] = {0, 0, 1, -1}; // 上：-1，下：1int dy[4] = {1, -1, 0, 0}; // 左：-1，右：1// 每个格子相对于起点的路径距离（时间成本），初始化为“无穷大”vector<vector<int>> dist(n, vector<int>(m, INT_MAX));dist[start_x][start_y] = 0;// 定义最小堆，堆顶元素必定最小。great 表示大于队尾元素的插入元素进入队尾，否则插入队尾元素之前。最大堆用 less    // 存储待探索的点，按距离升序排序priority_queue<Node, vector<Node>, greater<Node>> pq;// 起点作为第一个待探索点pq.push({start_x, start_y, 0});while(!pq.empty()){Node curr = pq.top(); // 当前位置pq.pop(); // 将该点弹出待探索堆。之后此点不再探索int x = curr.x;int y = curr.y;int time = curr.time;        // 剪枝。这说明你是从较远路径来到这个点的，而根据我们的走法，已经有“人”探索接下来的路了，因此不要重复探索。if(time > dist[x][y]){continue;}// 向 4 个方向探索for(int i=0;i<4;i++){int nx = x + dx[i];int ny = y + dy[i];// 探测边界和墙壁if(nx < 0 || nx >= n || ny < 0 || ny > m || grid[nx][ny] == '#'){continue;}int new_time = time + 1; // 前进 1 步// 遇怪增加时间if(grid[nx][ny] == 'x'){new_time ++;}// 如果找到更短路径，则更新路径距离if(new_time < dist[nx][ny]){dist[nx][ny] = new_time;pq.push({nx, ny, new_time}); // 把点推入待探索堆中}}}if(dist[end_x][end_y] != INT_MAX){cout << dist[end_x][end_y] << "\n";}else{cout << "-1" << "\n";}}

交易

考了

★实验任务

作为炉石传说的发牌员，你的任务就是发牌。从上到下有 n 张牌，编号 1~n。因为你和选手进行了一次 “交易”，所以当至少还剩两张牌时，发出最上面的牌，第二张牌放到最下面，重复这个过程直到只剩下一张牌。输出发牌的序列和最后剩下的牌。

★数据输入

第一行 1 个正整数 n (1=<n<1000)

★数据输出

输出一行为发牌的序列，一行为最后剩下的牌。两个数字之间用空格隔开，末尾没有空格。

★Hint

第一个样例 n=1, 只输出一行。

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
#include <bits/stdc++.h>using namespace std;int main(){int n;cin >> n;queue<int> card;    // 初始化牌堆for(int i=1;i<=n;i++){card.push(i);}bool isFirst = true;do{if(!isFirst){cout << " ";}        // 输出第一张牌cout << card.front();card.pop();isFirst = false;        // 第二张牌排到队尾if(!card.empty()){int second = card.front();card.pop();card.push(second);}}while(card.size() >= 2);cout << endl;if(!card.empty()){cout << card.front();}}

栈

火车

考了

★实验任务

TonyY 等火车无聊的时候，会去观察火车的排列，有一天他思考这么一个问题，火车总站的火车只能进站，要出站的话只能先出最后进站的那辆车，那么知道火车的进站顺序，能不能把它的出站顺序调整成火车站想要的呢？

★数据输入

输入第一行为一个正整数 n 表示火车辆数 (编号 1-n)（1<=n<=9）。

然后为两个长度为 n 的序列，表示火车的进站顺序和出站顺序。每辆火车刚好进出站各一次。

★数据输出

如果可以调整，输出 Yes 和出入站顺序。

如果不能，输出 No。

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
#include <iostream>#include <stack>#include <string>using namespace std;int main() {int n;cin >> n;string in_seq, out_seq;cin >> in_seq >> out_seq;stack<int> station;int out_index = 0;  // 当前应该出站的元素索引bool possible = true;// 模拟过程判断是否可能，并记录操作序列string operations[20]; // 最多 2 * 9 = 18 次操作int op_count = 0;for (int i = 0; i < n; i++) { // 由于出入站是单行的，因此每列列车有且只有一次进站和出站操作// 入站station.push(in_seq[i] - '0');operations[op_count++] = "in";// 检查能否出站，while 应对连续出站情况while (!station.empty() && station.top() == out_seq[out_index] - '0') {station.pop();operations[op_count++] = "out";out_index++;}}// 检查是否所有元素都正确出栈if (out_index != n) {possible = false;}if (possible) {cout << "Yes" << endl;// 输出缓存的操作序列for (int i = 0; i < op_count; i++) {cout << operations[i] << endl;}} else {cout << "No" << endl;}return 0;}

价值

★实验任务

K 神最近喜欢上了刷题，一天不刷浑身难受。最近他研究发现，自己的人生价值在于他某段时间内的刷题总数乘上这几天刷题数的最小值，现在 K 神很寂寞（无敌是多么寂寞），想知道他人生价值最高的时候究竟有多高（krz）

★数据输入

第一行为总天数 N (1<=N<=100000)

接下来一行 N 个整数 ai（1<=ai<=100000），表示 K 神第 i 天的刷题数。

★数据输出

输出 K 神在连续一段时间内可能的最高价值 W。

对每个元素 a[i]，把它当作 “区间最小值”，看它能控制的最大区间，然后计算 a[i] * (这个区间的元素和)，取最大值。

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
#include<bits/stdc++.h>using namespace std;int main(){int n;cin>>n;int num=n+5;vector<int>a(num), left(num), right(num);for(int i=1;i<=n;i++){cin>>a[i];}// 求前缀和，便于求区间和，例如区间 [a,b) 内的和为 sums[b-1] - sums[a]vector<long long>sums(n+1,0);for(int i=1;i<=n;i++){sums[i]=sums[i-1]+a[i];}// 求区间和就需要求上下边界    // 将刷题数序列的每一个值都认为是属于某个区间的最小值，现在就是求最大的区间。    // 使用单调栈排序下标stack<int>st;    // 左边界，从左到右选择for(int i=1;i<=n;i++){        // 如果当前栈顶的元素不小于要插入的元素，则弹出栈顶元素。注意一定要带等号，不然会出错while(!st.empty() && a[st.top()]>=a[i]){st.pop();}left[i]=st.empty()?0:st.top();st.push(i);}    // 清空栈while(!st.empty())st.pop();    // 右边界，从右到左选择for(int i=n;i>=1;i--){        // 如果当前栈顶的元素小于要插入的元素，则弹出栈顶元素while(!st.empty() && a[st.top()]>a[i]){st.pop();}right[i]=st.empty()?(n+1):st.top();st.push(i);}long long maxx=0;for(int i=1;i<=n;i++){long long sum=sums[right[i]-1]-sums[left[i]];long long cur=a[i]*sum;maxx=max(maxx, cur);}cout<<maxx<<endl;return 0;}

排序与选择

魔音吉他

考了

★问题描述

少年甲很喜欢音乐，有一天他来到了少年乙的村落。少年甲一曲高山流水，寻觅到了乙这位知音。然而，天下没有不散的宴席，少年甲要回村杀猪了，离别在即，少年乙拿出了自己珍藏多年的吉他，作为离别的礼物。就在少年甲欣喜之际，少年乙说，这把吉他变幻莫测，每次你拿起它的时候，它会有 n 根弦，每根弦可以演奏出 1018+110^{18}+1 个音符，而这 1018+110^{18}+1 个音符是连续的，取决于它每根弦的第一个音符（请看样例说明）。
此时，少年甲提出了一个疑问，如果给定一个区间 l，r（包括端点），里面共有几种不同的音符呢？少年乙对此谙熟于心，但是他想考验一下你，于是将这个问题抛给了你。

★数据输入

第一行一个正整数 n (1<=n<=100,000)，表示吉他有几根弦。
第二行共 n 个数 x，即代表对应弦的第一个音符 (0<=x<=101810^{18})。
第三行一个正整数 q (1<=q<=100,000)，表示少年甲的询问次数。
接下来 q 行，每行两个数 l，r (0<=l, r<=1018+110^{18}+1)，表示少年甲想要询问的区间。

★数据输出

输出共 q 个数，表示对应 q 个询问的答案。即询问区间内有多少个不同的音符。以空格隔开。

★样例说明

对应弦的第一个音符：3 1 4 1 5 9

列下标：0 1 2 3 4 5 ……
弦一： 3 4 5 6 7 8 ……
弦二： 1 2 3 4 5 6 ……
弦三： 4 5 6 7 8 9 ……
弦四： 1 2 3 4 5 6 ……
弦五： 5 6 7 8 9 10 ……
弦六： 9 10 11 12 13 14 ……

在第一根弦（最低音为 1）遇到的音符为 1、2、3，一共 3 个新音符。
在第二根弦（最低音为 3）遇到的音符为 3、4、5，一共 2 个新音符。
在第三根弦（最低音为 4）遇到的音符为 4、5、6，一共 1 个新音符。
在第四根弦（最低音为 5）遇到的音符为 5、6、7，一共 1 个新音符。
在第五根弦（最低音为 9）遇到的音符为 9、10、11，一共 3 个新音符。
区间 [0,2] 内有 1、2、3、4、5、6、7、9、10、11，共 10 个不同的音符。

★Hint

（1）询问区间 l，r 即为样例说明中的列下标。
（2）所谓不同音符个数，即区间 l，r 内 n 行内不同的数字个数。
（3）由于 l，r 的范围巨大，请思考其与每行第一个数字的关系（即给出的第一个音符）。

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
// 由“样例说明”可知，从第二根弦开始每根弦遇到的新音符数量受其与上一跟弦的差值影响即 a[i] - a[i-1]（比如 a[2] - a[1] = 3 - 1 =2, a[3] - a[2] = 4 - 3 = 1)，但如果其差值大于询问的区间长度 (r-l+1)，其增长的值就为其区间范围的值// 则总的音符数为基弦的音符数（区间长度）+ 后面弦的新增音符数#include <iostream>#include <vector>#include <algorithm>using namespace std;int main() {    int n;    cin >> n;    vector<long long> first(n);    for (int i = 0; i < n; i++) {        cin >> first[i];    }    //把弦的起始音符排个序    sort(first.begin(), first.end());    //求出相邻弦之间的差值    vector<long long> diff;    for (int i = 1; i < n; i++) {        diff.push_back(first[i] - first[i - 1]);    }    sort(diff.begin(), diff.end());    //计算前缀和（为了后面快速求和）    vector<long long> pre(diff.size() + 1, 0);    for (int i = 0; i < (int)diff.size(); i++) {        pre[i + 1] = pre[i] + diff[i];    }    int q;    cin >> q;    for (int t = 0; t < q; t++) {        long long l, r;        cin >> l >> r;        // 区间长度（包括两端）        long long len = (r >= l) ? (r - l + 1) : 0;        // 找出 <= len 的差值数量        int k=upper_bound(diff.begin(),diff.end(),len)-diff.begin();        // 计算 sum(min(len, diff[i]))        long long summin = pre[k] + (long long)(diff.size() - k) * len;        // 最终结果（音符总数）        long long ans = len + summin;        cout << ans; // 输出        if (t != q - 1) cout << " ";    }    cout << endl;    return 0;}

Just Sort

★实验任务

给定两个序列 a, b，序列 a 原先是一个单调递增的正数序列，但是由于某些原因，使得序列乱序了，并且一些数丢失了（用 0 表示）。经过数据恢复后，找到了正数序列 b ，且序列 a 中 0 的个数等于序列 b 的个数，打算使用序列 b 恢复序列 a。

对于序列 a 来说，我们可以交换两个位置上的非零的数，并且可以交换任意次。序列 b 同样也可以进行任意次交换。

现在要将序列 b 填充到序列 a 中的值丢失的位置上，序列 b 中的每个数只能填充一次，问最后构成的序列是否是单调递增的，如果是，则输出填充后的序列，否则输出 -1。

★数据输入

输入给定 N, M，表示序列 a 和序列 b 的长度。

第一行为序列 a，第二行为序列 b。题目保证除了 0 以外的数，在序列 a 和 b 中只出现一次。

数据保证:

80% 的数据，N, M <= 100

100% 的数据，N, M <= 100000, 0 <= a [i] <= 100000, 0 < b [i] <= 100000

★数据输出

如果最后序列 a 是单调递增的，输出该序列，否则输出 -1。

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
#include <bits/stdc++.h>using namespace std;const int N = 1e5 + 10;int a[N], b[N], c[N], vis[N];void solve(){int n, m;cin >> n >> m;int idx = 0;for(int i=1;i<=n;i++){int x;cin >> x;if(x==0){vis[i] = 1; // 标记序列 a 中缺失元素的位置}else{a[++idx] = x; // 收集 a 中非 0 的数}}for(int i = 1; i <= m; i++){cin >> b[i];}    // 允许任意交换意味着原始位置已经不重要了，只剩下“数的集合”重要    // 问题变成：能否把“a 的非零数和 b 中的数”重新排列，按原位置规则放回（形成新序列），使整个序列严格递增？sort(a + 1, a + idx + 1); // std::sort(container.begin(), container.end());sort(b + 1, b + m + 1);int idx1 = 0, idx2 = 0;for(int i=1;i<=n;i++){if(vis[i]){c[i] = b[++idx1]; // 如果此位置是 a 中缺失的元素位置，那么用序列 b 填充}else{c[i] = a[++idx2]; // 如果没缺失，则用 a 中原本没缺失的元素填充}if(i > 1){            // 发现填充违规，说明当前最小可用的数都不够大，而换用更大的数会把这个较小数留给后面更大的数，更难实现递增if(c[i] <= c[i - 1]){cout << "-1" << "\n";return;}}}for(int i=1;i<=n;i++){if(i != 1){cout << " ";}cout << c[i];}cout << "\n";}int main(){solve();}

树

文件管理器

好难 QAQ

背景

操作系统具有对计算机硬件资源管理和调度的功能。文件是对占用了硬盘一定空间的对象的描述和抽象。考虑一般的文件具有文件名、大小和创建时间。文件管理在任何操作系统中都是必不可少的。文件管理器是用户用来观察和操作文件的一个软件。考虑一个简易的文件管理器，用户可以通过这个简易的文件管理器对某个目录下文件最大/小、文件名 (字符串) 字典序最大/最小的一些文件，即按 XX 排序功能，此外文件管理器具有删除和添加文件的功能。输入保证目录只有一级，操作随机。

输入及输出格式

第 1 行输入一个 Q (1<=Q<=100000)，表示操作的次数。

第 2-Q+1 行输入一行操作序列

操作序列的格式为 op args

当 op=1, 即第一种操作时，args 的格式为 folder name size，表示将要在某个 folder 目录 (1<=folder<=5 的整数) 下添加文件名为 name (1<=name<=100000 的整数) 的文件，文件大小为 size (1<=size<=100000 的整数)，如果文件名重复，就先删除原来的文件再进行 1 操作；

当 op=2, 即第二种操作时，args 的格式为 folder name，表示将要在某个 folder 目录 (1<=folder<=5 的整数) 下删除文件名为 name (1<=name<=100000 的整数) 的文件，如果文件名不存在，操作不执行；

当 op=3, 即第三种操作时，args 的格式为 folder k，表示输出某个目录下文件大小最大至第 k 大的文件名，如果大小相同按文件名数字从小到大输出，如果不满 k 个文件只需要输出已有的文件名，如果文件夹为空或不存在则输出一个空行；

当 op=4, 即第四种操作时，args 的格式为 folder k，表示输出某个目录下文件名数字大小最小至第 k 小的文件名，如果不满 k 个文件只需要输出已有的文件名，如果文件夹为空或不存在则输出一个空行；

保证 1<= k <=10

备注

输出文件名以空格隔开，不输出多余的换行和空格

样例说明

样例输出为 8 个空行

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
#include<bits/stdc++.h>using namespace std;struct node{int name,size;};class cmp{public:bool operator()(const node&x,const node&y)const{if(x.size!=y.size){return x.size>y.size;}else{return x.name<y.name;}}};map<int,int>folder[7];set<node,cmp>s1[7];//set<string>s2[7];void solve(){int op,idx,name,size,k;cin>>op>>idx;switch(op){case 1:cin>>name>>size;node t;t.name=name,t.size=size;if(folder[idx].count(name)){s1[idx].erase(s1[idx].find({name,folder[idx][name]}));}/*else{s2[idx].insert(to_string(name));}*/s1[idx].insert(t);folder[idx][name]=size;break;case 2:cin>>name;if(folder[idx].count(name)){auto it=s1[idx].find({name,folder[idx][name]});s1[idx].erase(it);//s2[idx].erase(to_string(name));folder[idx].erase(name);}break;case 3:cin>>k;if(!s1[idx].empty()){int cnt=0;for(auto el:s1[idx]){if(cnt){cout<<' ';}cout<<el.name;cnt++;if(cnt==k){break;}}}cout<<'\n';break;case 4:cin>>k;/*if(!s2[idx].empty()){int cnt=0;for(auto el:s2[idx]){if(cnt){cout<<' ';}cout<<el;cnt++;if(cnt==k){break;}}}*/if(!folder[idx].empty()){int cnt=0;for(auto el : folder[idx]){if(cnt){cout<<' ';}cout<<el.first;cnt++;if(cnt==k){break;}}}cout<<'\n';break;}}int main(){ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);int t=1;cin>>t;while(t--){solve();}    return 0;}

鼹鼠报数

考了

★实验任务

Winder 养了一群会报数的鼹鼠，而且 Winder 喜欢用数字给他的鼹鼠们编号，如 “311”、“1048” 等。当然，为了不混淆，鼹鼠们的编号都是不同的。为了锻炼鼹鼠们的身体健康，Winder 决定让鼹鼠们进行掘土训练，顺便提高鼹鼠们的挖掘能力。
鼹鼠们排成一列，由第一个开始向下挖洞，并待在洞中。第二只与第一只相比，若编号值大的鼹鼠，则向右下方挖洞，否则向左下方。接下来的鼹鼠们以此类推，若比洞中所在鼹鼠编号值大，则向右下方走，否则向左下方。
训练结束后，Winder 会让他的鼹鼠们报数（既报出各自的编号）。通过报数的序列 Winder 想知道经过训练之后，鼹鼠们的位置是怎样的。
报数规则为：如果 A 鼹鼠的下方分别存在 ALeft 鼹鼠和 ARight 鼹鼠，则 ALeft 鼹鼠在 ARight 鼹鼠之前报数，ARight 鼹鼠在 A 鼹鼠之前报数。
位置表达式规则为：“根节点 <左子树表达式><右子树表达式>”, 如左子树不存在, 则只输出 “根节点 <右子树表达式>”，右子树同理。

★数据输入

第一行为 N（2<N<=1000），表示有 N 只鼹鼠。
第二行为 N 个整数 bi（0<bi<10000），表示报数顺序。

★数据输出

输出鼹鼠们的位置表达式。

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
// 报数过程就是二叉树的后序遍历// 问题转化成：已知一棵 BST 的后序遍历序列，输出它的 “位置表达式”（先根 + 左右子树）#include <iostream>using namespace std;const int MAX = 10000;int a[MAX], n;void dfs(int * a, int begin, int end) {bool l = 1;bool r = 1;cout << a[end]; // 后序遍历的最后一个一定是根int i = begin;    // [ begin ... i-1 ] < root → 左子树    // [ i ... end-1 ] > root → 右子树while (i < end && a[i]<a[end]) {        i++;    }if (i==begin) {        l=0;    }if (i==end) {        r=0;    }if (l) {cout << "<";dfs(a, begin, i - 1);cout << ">";}if (r) {cout << "<";dfs(a, i, end - 1);cout << ">";}}int main () {cin >> n;for (int i=1; i<=n; i++){        cin>>a[i];    }dfs(a, 1, n);return 0;}

散列表

Sins of a Solar Empire P7

★实验任务

正如你所知道 sins 是一个贪玩的不得了的小 P 孩（如果你非常讨厌他可以直接跳到第二段），你也知道他最近很喜欢玩一个叫做太阳帝国的原罪的策略游戏我向你保证这是太阳帝国原罪系列的第七章了。
现在 sins 拥护 N 个星球，每个星球 m 种不同的资源，每个资源都拥有一个编号 A，对于 sins 来说 N 个星球都有的资源才是最宝贵的，他想知道这样的资源有哪些？

★数据输入

第 1 行是正整数 N（1<=N<=1000）。
第 2~N+1 行各有一个正整数 m 和 m 个正整数编号 A (有重复)，（0<m<=1000, 0 <= A <=10^9）.

★数据输出

第一行一个整数 S，表示 N 个星球都拥有的资源个数。
如果 S 不等于 0 输出第二行，按照升序输出 S 个整数表示资源编号 (无重复)，资源编号之间有空格，结尾没有空格。

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
#include <iostream>#include <unordered_map>#include <unordered_set>#include <vector>#include <algorithm>using namespace std;int main() {    int N;    cin >> N;    unordered_map<int, int> Count;    for (int i = 0; i < N; ++i) {        int m;        cin >> m;        unordered_set<int> only;        for (int j = 0; j < m; ++j) {            int A;            cin >> A;            only.insert(A);        }        for (int res : only) {            Count[res]++;        }    }    vector<int> common;    for (const auto& pair : Count) {        if (pair.second == N) {            common.push_back(pair.first);        }    }    sort(common.begin(), common.end());    cout << common.size() << endl;    if (!common.empty()) {        for (int i = 0; i < common.size(); ++i) {            if (i > 0) {                cout << " ";            }            cout << common[i];        }        cout << endl;    }    return 0;}

特殊匹配 R

★实验任务

定义一种语言 L，L 语言中所有的字符串只能由 abc 三个字母组成。
在语言 L 之上定义一种特殊匹配规则 R，R 的定义如下：假设有两个字符串 x 和 y，x 和 y 等长，且 x 与 y 有且只有一个位置上的字符不同。
例如字符串 x 为 “abc”：
（1）若字符串 y 为 ”abb”，这 x 与 y 符合 R 匹配；
（2）若 y 为 ”abc” 或 ”bbb” 或 ”abcc”，则 x 与 y 不符合 R 匹配。
现给定一个由 n 个 x 字符串构成的匹配表 r，然后进行 m 次询问。每次询问输入一个 y 字符串，然后判断 r 表中是否存在与 y 符合 R 匹配的 x 字符串，若有输出 ”YES”，否则输出 ”NO”。

★数据输入

输入中第一行给出一整数 n，m（1<=n,m<=1000）。
接下来 n 行给出 n 个 x 字符串。
接下来 m 行，每行输入一个 y 字符串进行询问。
题目保证每一个字符串的长度在 1000 以内。

★数据输出

对于 m 个询问，每个询问输出在 x 个字符串中是否有与 y 字符串符合 R 匹配的字符串，若有输出 ”YES”，否则输出 ”NO”。

★提示
60% 的数据 n<=100,m<=100
100% 的数据 n<=1000,m<=1000

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
#include <iostream>#include <string>#include <unordered_set>#include <vector>using namespace std;int main() {    int n, m;    cin >> n >> m;    unordered_set<string> x_set;    vector<string> x_list;    for (int i = 0; i < n; i++) {        string x;        cin >> x;        x_set.insert(x);        x_list.push_back(x);    }    for (int i = 0; i < m; i++) {        string y;        cin >> y;        int len = y.length();        bool found = false;        for (const string& x : x_list) {            if (x.length() != len) continue;            int diff_count = 0;            for (int j = 0; j < len; j++) {                if (x[j] != y[j]) {                    diff_count++;                    if (diff_count > 1) break;                }            }            if (diff_count == 1) {                found = true;                break;            }        }        cout << (found ? "YES" : "NO") << endl;    }    return 0;}

优先队列

哈夫曼问题

★问题描述

对于给定的一个数列，求出用该数列构造 Huffman 树的总费用。

给出一列数 {pi}=p0,p1,…,pn−1\{p_i\}=p_0, p_1, …, p_{n-1}，用这列数构造 Huffman 树的过程如下：

  1. 找到 {pi}\{p_i\} 中最小的两个数，设为 pap_a和 pbp_b，将 pap_a和 pbp_b 从 {pi}\{p_i\} 中删除掉，然后将它们的和加入到 {pi}\{p_i\} 中。这个过程的费用记为 pa+pbp_a + p_b。
  2. 重复步骤 1，直到 {pi}\{p_i\} 中只剩下一个数。

在上面的操作过程中，把所有的费用相加，就得到了构造 Huffman 树的总费用。

例如，对于数列 {pi}\{p_i\}={5, 3, 8, 2, 9}，Huffman 树的构造过程如下：

  1. 找到 {5, 3, 8, 2, 9} 中最小的两个数，分别是 2 和 3，从 {pi}\{p_i\} 中删除它们并将和 5 加入，得到 {5, 8, 9, 5}，费用为 5。
  2. 找到 {5, 8, 9, 5} 中最小的两个数，分别是 5 和 5，从 {pi}\{p_i\} 中删除它们并将和 10 加入，得到 {8, 9, 10}，费用为 10。
  3. 找到 {8, 9, 10} 中最小的两个数，分别是 8 和 9，从 {pi}\{p_i\} 中删除它们并将和 17 加入，得到 {10, 17}，费用为 17。
  4. 找到 {10, 17} 中最小的两个数，分别是 10 和 17，从 {pi}\{p_i\} 中删除它们并将和 27 加入，得到 {27}，费用为 27。
  5. 现在，数列中只剩下一个数 27，构造过程结束，总费用为 5+10+17+27=59。

★数据输入

输入的第一行包含一个正整数 n（n<=100）。

接下来是 n 个正整数，表示 p0,p1,…,pn−1p_0, p_1, …, p_{n-1}，每个数不超过 1000。

★数据输出

用这些数构造 Huffman 树的总费用。

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
#include<iostream>using namespace std;int main(){    int n;    cin>>n;    int a[100];    for (int i=0;i<n;i++)    {        cin>>a[i];    }    int len=n;    int total=0;    while(len>1)    {        int min1=0,min2=1;        if (a[min1]>a[min2])            swap(min1,min2);        for (int i=2;i<len;i++)        {            if (a[i]<a[min1])            {                min2=min1;                min1=i;            }            else if(a[i]<a[min2])            {                min2=i;            }        }        int sum=a[min1]+a[min2];        total+=sum;        a[min1]=sum;        a[min2]=a[len-1];        len--;    }    cout<<total<<endl;    return 0;}

森林冰火人

★实验任务

火人喜欢堆雪人。

已知火人在接下来的 N 天中，每天早上都会堆一个大小为 vi 的雪人。

但是火人的温度太高了！每天晚上，所有已存在的雪人的体积都会由于融化而减少 ti（若雪人体积不足 ti，则雪人体积融化至 0）。

问，每天融化的总体积为多少？

★数据输入

输入第一行为正整数 N (1<=N<=10^5)

第二行为 N 个正整数 vi (1<=vi<=10^5)，代表每天堆的雪人的体积。

第三行为 N 个正整数 ti (1<=ti<=10^5)，表示每天雪人融化的体积。

对于 80% 的数据， 1<=N<=100

对于 100% 的数据， 1<=N<=10^5

★数据输出

输出 N 个整数，代表每天融化的体积。（整数间以空格分隔）

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
#include <bits/stdc++.h>using namespace std;typedef long long ll;int main() {    int N;    cin >>N;    vector<ll> v(N),t(N);    for (int i=0;i<N;i++)        cin>>v[i];    for (int i=0;i<N;i++)        cin>>t[i];struct compare {    bool operator()(ll a,ll b) {        return a>b;    }};    priority_queue<ll,vector<ll>,compare> pq_min;//最小堆    ll sum=0;    for (int i=0;i<N;i++) {        pq_min.push(v[i]+sum);        ll melt=0;        while(!pq_min.empty() &&pq_min.top()<=sum+t[i]){            melt+=pq_min.top()-sum;            pq_min.pop();        }        melt+=pq_min.size()*t[i];        sum+=t[i];        cout<<melt<<" ";    }    cout<<endl;    return 0;}

并查集

转移炸弹

★实验任务

A 国有 N 个城市，这些城市编号为 1 到 N，有一天，他们调查出恐怖分子在每个城市中都安放了炸弹，于是他们给炸弹也编上了序号，第 i 个城市里的炸弹编号为 i。现在他们想把这些炸弹转移，以便于销毁炸弹。

由于炸弹是通过不同人转移的，所以需要一个指挥部门来记录转移炸弹的信息，以便于有些人要查询这些信息。我们有两个操作：

1. 将 a 炸弹目前所在城市中所有的炸弹转移到 b 炸弹所在的城市。

2. 询问 a 炸弹目前在哪个城市编号和这个城市中有炸弹个数。

★数据输入

输入第一行包含两个数 N,Q（1<=N<=500000 , 1<=Q<=120000）。分别表示城市的个数和操作数。

接下来有 Q 行，每行表示一个操作，第一种操作输入格式为 1 a b，第二种操作输入格式为 2 a。（1<=a,b<=N）

★数据输出

对于第一个操作，如果两个炸弹在同一个城市里，输出 “ERROR”，并不执行此操作。否则执行操作并不输出任何东西。

对于第二种操作，输出一行两个数表示炸弹所在的城市编号和该城市中炸弹个数，用一个空格分开。

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
#include <stdio.h>#include <stdlib.h>#define MAXN 500005int parent[MAXN];  // 父节点int city[MAXN];    // 炸弹当前所在的城市编号int size[MAXN];    // 城市中的炸弹数量// 查找根节点（带路径压缩）int find(int x) {    if (parent[x] != x) {        parent[x] = find(parent[x]);    }    return parent[x];}int main() {    int N, Q;    scanf("%d %d", &N, &Q);    // 初始化    for (int i = 1; i <= N; i++) {        parent[i] = i;        city[i] = i;    // 初始时炸弹i在城市i        size[i] = 1;    // 每个城市初始有1个炸弹    }    while (Q--) {        int op, a, b;        scanf("%d", &op);        if (op == 1) {            scanf("%d %d", &a, &b);            int ra = find(a);            int rb = find(b);            if (ra == rb) {                printf("ERROR\n");            } else {                // 把a所在城市的所有炸弹转移到b所在城市                // 合并集合，以rb为新的根                parent[ra] = rb;                size[rb] += size[ra];                size[ra] = 0;                // 更新城市编号：整个集合现在都在city[rb]城市                city[rb] = city[rb]; // 保持不变                // 注意：这里不需要更新city[ra]，因为ra不再是根节点            }        } else {            scanf("%d", &a);            int root = find(a);            printf("%d %d\n", city[root], size[root]);        }    }    return 0;}

道路

★实验任务

某省调查城镇交通状况，得到现有城镇道路统计表，现给出每条道路连接的城镇编号，问当前的道路设计方案是否合理。

合理的方案为任意两个城镇之间可以相互到达，有且只有一条通路。

★数据输入

输入 a b (1<=a,b<=10,000)，表示城镇 a 和城镇 b 连通。输入包含多组数据，每组数据以 0 0 结束。

整个文件以 -1 -1 结尾

★数据输出

如果方案合法，输出 "Yes", 否则输出 "No"。

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
#include<iostream>#include<unordered_set>using namespace std;const int MAXN = 10005;int parent[MAXN];unordered_set<int> nodes;int find(int x) {    if (parent[x] != x) {        parent[x] = find(parent[x]);    }    return parent[x];}void init() {    for (int i = 1; i < MAXN; ++i) {        parent[i] = i;    }    nodes.clear();}int main() {    int a, b;    while (cin >> a >> b) {        if (a == -1 && b == -1) break;        init();        bool has_cycle = false;        int edge_count = 0;        while (a != 0 || b != 0) {            nodes.insert(a);            nodes.insert(b);            edge_count++;            int rootA = find(a);            int rootB = find(b);            if (rootA == rootB) {                has_cycle = true;            }else {                parent[rootA] = rootB;            }            cin >> a >> b;        }        if (has_cycle) {            cout << "No\n";        }else {            if (nodes.empty()) {                cout << "Yes\n";            }else {                int root = find(*nodes.begin());                bool connected = true;                for (int node : nodes) {                    if (find(node) != root) {                        connected = false;                        break;                    }                }                if (connected && edge_count == nodes.size() - 1) {                    cout << "Yes\n";                }else {                    cout << "No\n";                }            }        }    }    return 0;}

图

图论难题

好难 QAQ
考了

★问题描述

数据结构与算法课程里面有各种求解最短路的算法，比如 floyd 算法、dijkstra 算法、bellman 算法。但该难题需要求解的不是最短路，而是求最短路的路径条数。

★实验任务

我们定义从 source 到达 target 的路径：source → u → v → target 是最短路，当且仅当该路径里面的所有边 (u，v) 满足：存在一条从 v 出发到终点的路径长度小于任意一条从 u 出发到终点的路径长度。

对于给定的一个无向无自环的图给你一个起点和一个终点，求出从起点到终点的最短路的路径条数。

★数据输入

第一行有两个正整数 N (1<=N<=1000), M (0<=M<=N(N−1)2\frac{N(N-1)}{2})。N 代表图 G 的顶点个数, M 代表图 G 有 M 条边。

接下来一共有 M 条边的描述，每条边的描述有三个整数 u (1<=u<=N), v (1<=v<=N), len (1<=len<=1000)。代表从 u 点到 v 点有一条边，且边的长度为 len。数据保证 u!=v 且不会出现重边。

最后一行有两个整数 S (1<=S<=N), T (1<=T<=N)，分别表示起点和终点。

★数据输出

输出一行为从 S 到 T 的最短路条数，如果 S 根本就走不到 T 就输出 -1

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
#include <iostream>#include <vector>#include <queue>#include <algorithm>#include <cstring>using namespace std;typedef long long ll;const int MAXN = 1005;const int INF = 0x3f3f3f3f;int N, M, S, T;vector<pair<int, int>> graph[MAXN];int dist[MAXN];bool visited[MAXN];vector<int> dag[MAXN];void dijkstra(int start) {    memset(dist, 0x3f, sizeof(dist));    memset(visited, false, sizeof(visited));    dist[start] = 0;    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;    pq.push({0, start});    while (!pq.empty()) {        int d = pq.top().first;        int u = pq.top().second;        pq.pop();        if (visited[u]) continue;        visited[u] = true;        for (auto &e : graph[u]) {            int v = e.first;            int w = e.second;            if (dist[v] > d + w) {                dist[v] = d + w;                pq.push({dist[v], v});            }        }    }}int main() {    cin >> N >> M;    for (int i = 0; i < M; i++) {        int u, v, len;        cin >> u >> v >> len;        graph[u].push_back({v, len});        graph[v].push_back({u, len});    }    cin >> S >> T;    // 计算从T到所有点的最短距离    dijkstra(T);    if (dist[S] == INF) {        cout << -1 << endl;        return 0;    }    // 构建DAG：只包含从距离大的点指向距离小的点的边    for (int u = 1; u <= N; u++) {        for (auto &e : graph[u]) {            int v = e.first;            // 只添加满足条件的边：dist[u] > dist[v]            if (dist[u] > dist[v]) {                dag[u].push_back(v);            }        }    }    // 按到T的距离升序排序所有顶点（距离小的先处理）    vector<int> nodes;    for (int i = 1; i <= N; i++) {        if (dist[i] < INF) {            nodes.push_back(i);        }    }    sort(nodes.begin(), nodes.end(), [](int a, int b) {        return dist[a] < dist[b];    });    // 动态规划计算路径条数    vector<ll> dp(N + 1, 0);    dp[T] = 1;    for (int v : nodes) {        if (v == T) continue;        for (int u : dag[v]) {            dp[v] += dp[u];        }    }    // 输出路径条数    cout << dp[S] << endl;    return 0;}

最小生成树

★问题描述

给定平面上的 n 个点，添加一些边使得任何两个点之间都能相互到达，求添加的边的长度总和最小为多少

★数据输入

第一行一个正整数 n (1<=n<=5000)，表示序列有 n 个点，
接下来有 n 行，每行两个整数 xi 和 yi，（-1000000≤xi,yi≤1000000），表示 n 个点的坐标

★数据输出

添加的边的长度总和的最小值，四舍五入保留两位小数

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
#include <iostream>#include <cmath>#include <cstring>using namespace std;const int N = 5005;double x[N], y[N]; // 坐标double dist[N]; // 边长bool vis[N]; // 树int main() {    int n;    cin >> n;    for (int i = 1; i <= n; i++)        cin >> x[i] >> y[i];    for (int i = 1; i <= n; i++)        dist[i] = 1e18;    dist[1] = 0;        // 从第 1 个点开始做 Prim    double ans = 0;    for (int i = 1; i <= n; i++) {        int u = -1;        // 找当前未加入 MST 的最近点        for (int j = 1; j <= n; j++) {            if (!vis[j] && (u == -1 || dist[j] < dist[u]))                u = j;        }        vis[u] = true;        ans += dist[u];        // 用 u 更新其他点的最小连边        for (int v = 1; v <= n; v++) {            if (!vis[v]) {                double dx = x[u] - x[v];                double dy = y[u] - y[v];                double d = sqrt(dx*dx + dy*dy);                if (d < dist[v]) dist[v] = d;            }        }    }    printf("%.2f\n", ans);    return 0;}

理论部分

破防了！弃坑！

]]> https://blog.watermelonabc.top/p/d5d6cc48/ 2025-12-21T13:02:31.000Z 情况真是急转直下啊（ 2025 福州大学算法与数据结构复习 2026-08-20T15:50:53.000Z Watermelonabc 试卷结构：

  • 单选题 20 * 1
  • 多选题 10 * 2
  • 简答题 4 * 5
  • 材料分析题 20
  • 论述题 20

单选题和多选题有题库；简答题有题纲；材料题关注教材第十一章（民生）；论述题关注二十届四中全会公报

简答题部分

一题就 5 分，不用多答

第一章

  1. 简述当前我国主要矛盾
    人民日益增长的美好生活需要和不平衡不充分的发展之间的矛盾
  2. 如何理解 “四个全面” 战略布局新内涵
    “全面建成小康社会、全面深化改革、全面依法治国、全面从严治党”。全面建成小康社会后，又发展出 “全面建设社会主义现代化国家”
  3. 中国共产党的初心使命是什么
    为中国人民谋幸福，为中华民族谋复兴

第二章

  1. 什么是中国梦
    实现中华民族伟大复兴
  2. 如何理解中国式现代化是人口规模巨大的现代化
    我国全体人民整体迈入现代化，规模超过现有发达国家人口的总和，将极大地改变现代化的世界版图
  3. 如何理解中国式现代化是全体人民共同富裕的现代化
    中国式现代化坚持以人民为中心，突出现代化方向的人民性，在高质量发展中不断增进人民福祉，扎实推动全体人民共同富裕
  4. 如何理解中国式现代化是物质文明和精神文明相协调的现代化
    物质贫困不是社会主义，精神贫乏也不是社会主义。物质富足、精神富有是社会主义现代化的根本要求
  5. 如何理解中国式现代化是人与自然和谐共生的现代化
    中国式现代化坚持绿色发展，统筹推进经济社会发展和环境保护，确保可持续发展
  6. 如何理解中国式现代化是走和平发展道路的现代化
    中国式现代化坚持独立自主、自力更生，依靠全体人民的辛勤劳动和创新创造发展壮大自己

第三章

  1. 简述 “两个拥护” 的内涵
    坚决维护习近平总书记党中央的核心、全党的核心地位，坚决维护党中央权威和集中统一领导
  2. 如何理解中国共产党在国家政治生活中的领导核心地位
    在当今中国，没有大于中国共产党的政治力量或其他什么力量。党政军民学，东西南北中，党是领导一切的，是最高的政治领导力量。
  3. 如何理解民主集中制基本原则中第一条的内涵
    党员个人服从党的组织，少数服从多数，下级组织服从上级组织，全党各个组织和全体党员服从党的全国代表大会和中央委员会
  4. 简述 “四个意识” 的内涵
    政治意识、大局意识、核心意识、看齐意识

第四章

  1. 如何理解 “人民是历史的创造者，是真正的英雄”
    人民群众是社会物质财富、精神财富的创造者和社会变革的决定性力量
  2. 如何理解 “人民立场”
    政治立场是一个政党观察、认识、处理政治问题的立足点，反映了这个政党的世界观、方法论和执政理念，体现了这个党的根本属性。人民立场是中国共产党的根本政治立场，是我们党区别于其他政党的显著标志
  3. 如何依靠人民创造历史伟业
    尊重人民的主体地位，尊重群众的首创精神

第五章

  1. 简述全面深化改革的总目标
    完善和发展中国特色社会主义制度，推进国家治理体系和治理能力现代化
  2. 简述国家治理体系的内涵
    国家治理体系是在党领导下管理国家的制度体系，包括经济、政治、文化、社会、生态文明和党的建设等各领域体制机制、法律法规安排，也就是一整套紧密相连、相互协调的国家制度
  3. 简述国家治理能力的内涵
    国家治理能力是运用国家制度管理社会各方面事务的能力，包括改革发展稳定、内政外交国防、治党治国治军等各个方面

第六章

  1. 简述新发展理念的内容
    创新、协调、绿色、开放、共享的发展方式
  2. 简述社会主义基本经济制度的新概括
    公有制为主体、多种所有制经济共同发展；按劳分配为主体、多种分配方式并存；社会主义市场经济体制
  3. 简述公有制经济的组成
    国有经济、集体经济和混合所有制经济中的国有成分与集体成分
  4. 简述非公有制经济的组成
    个体经济、私营经济、港澳台投资、外商投资（外资经济）和混合所有制经济中的非国有成分与非集体成分
  5. 简述两个 “毫不动摇” 的内容
    毫不动摇地巩固和发展公有制经济，毫不动摇地鼓励、支持和引导非公有制经济发展
  6. 简述新发展格局的内涵
    以国内大循环为主体、国内国际双循环相互促进的经济发展模式

第八章

  1. 简要回答 “全过程人民民主” 的内涵
    全过程人民民主实现了过程民主和成果民主、程序民主和实质民主、直接民主和间接民主、人民民主和国家意志相统一，是全链条、全方位、全覆盖的民主，是最广泛、最真实、最管用的社会主义民主。
  2. 坚持走中国特色社会主义政治发展道路的三个支点是什么
    党的领导、人民当家作主、依法治国有机统一
  3. 简述人民当家作主的制度保障
    人民代表大会制度（根本）；中国共产党领导的多党合作和政治协商制度、民族区域自治制度、基层群众自治制度（基本、重要）

第十章

  1. 如何理解文化自信
    文化自信是更基础、更广泛、更深层的自信，是一个国家、一个民族发展过程中最基本、最深沉、最持久的力量
  2. 简述 “两个结合” 的内容
    把马克思主义基本原理同中国具体实际相结合、同中华优秀传统文化相结合
  3. 什么是中华优秀传统文化的创造性转化和创新性发展
    创造性转化，就是要按照时代特点和要求，对那些至今仍有借鉴价值的内涵和陈旧的表现形式加以改造，赋予其新的时代内涵和现代表达形式，激活其生命力。创新性发展，就是要按照时代的新进步新进展，对中华优秀传统文化的内涵加以补充、拓展、完善，增强其影响力和感召力。
  4. 简述文化发展 “二为” 方向的内容
    为人民服务，为社会主义服务
  5. 简述 “双百” 方针的内容
    百花齐放，百家争鸣
  6. 简述 “文化软实力” 的内涵
    文化软实力集中体现了一个国家基于文化而具有的凝聚力和生命力，以及由此产生的吸引力和影响力。

第十一章

  1. 简述 “民生” 的内涵
    民生是老百姓最关心的问题，涉及分配、就业、教育、医疗、住房、社会保障等方面。随着经济社会的发展进步，人民生活品质的不断提高，民生内涵也在不断丰富
  2. 简述社会保障体系的内涵
    社会保障体系是由国家立法规定并以国家作为给付义务主体，为保障社会成员的基本生活和福利、对生活困难社会成员给予物质或服务帮助的各项措施的统称，主要涉及社会保险、社会救助、社会福利、社会优抚等方面。
  3. 如何理解社会治理体系中的 “共建” 原则
    共建是共同参与社会建设，要求突出制度和体系建设的基础性、战略性地位，是社会治理的基础
  4. 如何理解社会治理体系中的 “共治” 原则
    共治是共同参与社会治理，要求树立大社会观、大治理观，打造全民参与的开放治理体系，是社会治理的关键
  5. 如何理解社会治理体系中的 “共享” 原则
    共享是共同享有社会治理成果，要求社会治理的成效更多更惠及全体人民，是社会治理的目标

第十二章

  1. 简述 “两山理论” 的内容
    一是既要绿水青山，也要金山银山；二是宁要绿水青山，不要金山银山；三是绿水青山就是金山银山
  2. 简述 “双碳” 目标的内容
    2030 年前实现碳达峰，2060 年前实现碳中和
  3. 简述 “人与自然生命共同体” 的内涵
    生态是统一的自然系统，是相互依存、紧密联系的有机链条。人的命脉在田，田的命脉在水，水的命脉在山，山的命脉在土，土的命脉在林和草，这个生命共同体是人类生存发展的物质基础
  4. 如何理解全球生态治理过程中的中国角色
    中国致力于推动共建地球生命共同体，积极参与全球环境治理，是全球生态文明建设的重要参与者、贡献者、引领者

第十三章

  1. 简述国家安全的内涵
    国家安全是指国家政权、主权、统一和领土完整、人民福祉、经济社会可持续发展和国家其他重大利益相对处于没有危险和不受内外威胁的状态，以及保障持续安全状态的能力
  2. 如何理解政治安全
    政治安全涉及国家主权、政权、制度和意识形态的稳固，是一个国家最根本的需求，是国家赖以生存和发展的基础条件
  3. 如何理解 “统筹发展与安全”
    发展是安全的基础和目的，安全是发展的条件和保障，要坚持发展和安全并重
  4. 列举 5 个中国国家安全重点领域
    国土安全、经济安全、社会安全、网络安全、生物安全、公共卫生安全、外部安全等

第十六章

  1. 简述 “推动构建新型国际关系” 的内涵
    推动构建新型国际关系，就是要秉持相互尊重、公平正义、合作共赢原则，走出一条对话而不对抗、结伴而不结盟的国与国外交新路。
  2. 什么是中国外交的神圣使命
    维护国家主权、安全和发展利益
  3. 简述一带一路倡议的内涵
    共建 “一带一路” 是对中国与世界实现开放共赢路径的顶层设计，是推动构建人类命运共同体的实践平台。
  4. 简述 “外交为民” 的内涵
    中国外交始终坚守外交为民的宗旨，把为民服务、为民解忧作为重要职责，把人民的满意度作为重要标尺，坚持把中国人民的利益和全人类共同利益联系在一起，促进各国人民相互了解、相互支持、相互帮助
  5. 简述 “建设五个世界” 总目标内容
    坚持对话协商，建设一个持久和平的世界；坚持共建共享，建设一个普遍安全的世界；坚持合作共赢，建设一个共同繁荣的世界；坚持交流互鉴，建设一个开放包容的世界；坚持绿色低碳，建设一个清洁美丽的世界。

B3 卷考后回忆版

客观题部分

难度不会太大，建议找个同伴齐头复习，随时提问。有些题目的答案甚至会在其他题目的题干中有所呈现。

简答题部分

  1. 简述 “四个全面” 战略布局新的时代内涵
  2. 如何理解 “人民立场”
  3. 简述国家治理能力的内涵
  4. 如何理解 “统筹发展与安全”

材料题部分

材料

为人民而生，因人民而兴，始终同人民在一起，为人民利益而奋斗，是我们党立党兴党强党的根本出发点和落脚点。习近平总书记指出：“中国共产党始终代表最广大人民根本利益，与人民休戚与共、生死相依，没有任何自己特殊的利益，从来不代表任何利益集团、任何权势团体、任何特权阶层的利益。” 100 年来，为了人民幸福和民族复兴，我们党团结带领中国人民，以 “为有牺牲多壮志，敢教日月换新天” 的大无畏气概，书写了中华民族几千年历史上最恢宏的史诗，创造了新民主主义革命的伟大成就，创造了社会主义革命和建设的伟大成就，创造了改革开放和社会主义现代化建设的伟大成就，创造了新时代中国特色社会主义的伟大成就。特别是党的十八大以来，中国特色社会主义进入新时代，我们党团结带领中国人民，自信自强、守正创新，统揽伟大斗争、伟大工程、伟大事业、伟大梦想，党和国家事业取得历史性成就、发生历史性变革，中华民族迎来了从站起来、富起来到强起来的伟大飞跃，实现中华民族伟大复兴进入了不可逆转的历史进程！
——人民日报《人民对美好生活的向往就是我们的奋斗目标》

结合材料内容和所学知识，谈谈为什么让人民生活幸福是 “国之大者”。

论述题部分

阅读（实际上并没给任何材料）二十届四中全会公报内容，结合所学知识和党的创新理论，谈谈如何推动高质量发展。

]]> https://blog.watermelonabc.top/p/7c6cc5e4/ 2025-12-02T12:57:06.000Z 燃尽了 2025 福州大学习概期末复习 2026-08-04T09:53:11.000Z Watermelonabc Frida 是一个知名的 Hook 框架
接下来我们主要以 Android Hook 为主题进行讲解

环境配置

分别在 PC 和目标 Android 上配置 Frida：

1
2
3
4
5
# 我使用 UV 管理 Python，因此没有一个全局的 Python# uv venv --seed --clear venv# venv\Scripts\activatepip install frida frida-tools

记住 Frida 版本：

1
2
3
4
$ pip show fridaName: fridaVersion: 17.5.1

在 ADB shell 中查看 Android 设备架构：

1
2
3
$ uname -maarch64
Note

一般来讲，模拟器采用 x86-64，真机采用 arm64（即此处的 aarch64）

在 Releases · frida/frida 下载对应版本的 Frida-server，例如此处应下 frida-server-17.5.1-android-arm64.xz。

解压得到的文件传输到 Android 上：

1
adb push frida-server-17.5.1-android-arm64 /data/local/tmp/

在 Android 上启动服务端：

1
2
3
4
5
6
adb shellsu # 需要在 Root 下运行，否则 SELinux 会报错cd /data/local/tmpchmod +x ./frida-server-17.5.1-android-arm64 # 赋予执行权限./frida-server-17.5.1-android-arm64 # 无报错即服务端正常运行

现在就可以用 Frida 了 😊

Frida 调试基础

Android 每个 APP 都运行在自己独立的虚拟机和沙盒中，如果每个 APP 的运行时环境都不共享，那么资源消耗是很恐怖的。而 Android 提供了 Zygote 进程，所有 APP 都是由 Zygote fork 出来的：

1
2
3
4
5
init └── Zygote（已预加载所有 Framework 类）    ├── system_server    ├── com.tencent.mm    └── com.example.yourapp  ← 你要分析的 APP

Zygote 的作用是：提前把 Android Framework 所有的类加载好，每次 fork 新进程时直接继承，不用重新初始化。这样做可以实现极速启动和节省内存.

两种模式：Spawn（生成）和 Attach（附加）。Spawn 模式是从头启动应用并调试，Attach 模式是在应用运行时才开始调试。Spawn 模式下，Frida 利用 Zygote 控制进程创建，可以在业务代码运行前完成 Hook；Attach 模式下，APP 的 Application.onCreate 等初始化逻辑已经执行完，注入太晚。因此对抗加固的场景大多用 Spawn 模式。

但 Spawn 模式也可以被某些 APP 检测到。

Spawn 模式：

1
frida -U -f <TARGET> -l <SCRIPT>
  • TARGET：APP 包名或可执行文件名
  • SCRIPT：用于调试的 Python, JS 或 TS 脚本。自己写或者用已有的。如果不附带脚本，则进入交互式调试。

TARGET 需要的包名可以通过 frida-ps -Ua（运行中的应用）/frida-ps -Uai（安装的应用）得到。

Spawn 方式启动后，会立刻暂停运行。需要继续运行，需要手动输入：%resume

旧版本有一个 --no-pause 会自动运行，但新版本已不支持。

Attach 模式：

1
frida -U -N TARGET -l SCRIPT
如何处理 I/O error

解决方法：Root + 设置 setenforce 0 + Reboot

"Failed to enumerate processes: unable to perform ptrace pokedata: I/O error” on rooted Android (SELinux Enforcing)

frida-ps -U Failed to enumerate processes: unable to perform ptrace pokedata: I/O error

怎么写好一个调试脚本

脚本主要有三类内容：

  • Interceptor（拦截器）：实现 Hook 函数、打印参数等调试操作。每次匹配到（对应函数），都会触发执行代码。
  • ApiResolver（解析器）：模糊查找相关函数。只有第一次（解析时）匹配到，才会执行。
  • Stalker（跟踪器）：跟踪代码的实际运行的过程。期间可以打印和查看对应的值，便于实现调试真正代码运行的逻辑。

对于 JS 脚本，一个简单的 CTF 示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 所有 Java API 调用必须在 Java.perform() 回调中执行Java.perform(function () {  // 获取目标类的引用  var Vault = Java.use("com.heroctf.freeda1.utils.Vault");  // 尝试调用目标方法并处理异常。延迟 1000ms 执行以减少 bug  setTimeout(function () {    try {      var flag = Vault.get_flag();      console.log("[SUCCESS] Flag: " + flag);    } catch (e) {      console.log("[ERROR] " + e);    }  }, 1000);});

这个的脚本的目的是直接获取 Vault 类下的 get_flag() 方法的输出，得到 flag。

一些常用方法：

API 名称描述
Java.use(className)获取指定的 Java 类并使其在 JavaScript 代码中可用。
Java.perform(callback)确保回调函数在 Java 的主线程上执行。
Java.choose(className, callbacks)枚举指定类的所有实例。
Java.cast(obj, cls)将一个 Java 对象转换成另一个 Java 类的实例。
Java.enumerateLoadedClasses(callbacks)枚举进程中已经加载的所有 Java 类。
Java.enumerateClassLoaders(callbacks)枚举进程中存在的所有 Java 类加载器。
Java.enumerateMethods(targetClassMethod)枚举指定类的所有方法。

绕过检测

要用 Frida-server 调试的前提就是 Root，但显然大部分应用都不希望自己被 Frida 或者 Root 调戏，因此会做 Root 检测，一检测到特征就停止程序运行。

但是，代码总是有执行顺序的，只要我在检测前就把特征检测方法给 Hook 掉，你不就检查不出来了吗？另一种就是 “打入内部”，将 Frida-gadget 植入程序，可以实现免 Root 的 Hook。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.heroctf.freeda2.utils;import android.content.Context;import com.scottyab.rootbeer.RootBeer;/* compiled from: r8-map-id-baa4c77f810b701c3077d4ce68a3d5b79ee91034c03e266e8ba1aed7e464c1a1 *//* loaded from: classes.dex */public final class Security {    private Security() {    }    public static boolean detectRoot(Context context) {        return new RootBeer(context).isRooted();    }}
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
Java.perform(function () {  console.log("[+] Bypassing root detection...");  // 绕过 RootBeer  var RootBeer = Java.use("com.scottyab.rootbeer.RootBeer");  RootBeer.isRooted.implementation = function () {    console.log("[+] RootBeer.isRooted() bypassed");    return false;  };  // 绕过 Vault 构造函数检测  var Vault = Java.use("com.heroctf.freeda2.utils.Vault");  Vault.$init.implementation = function () {    console.log("[+] Vault constructor bypassed");    // Don't call original constructor  };  setTimeout(function () {    try {      var flag = Vault.get_flag();      console.log("[SUCCESS] Flag: " + flag);    } catch (e) {      console.log("[ERROR] " + e);    }  }, 1000);});

RootBeer 是一个简单的 Root 权限检查库。作者也在 README 中坦陈 RootBeer 可以被绕过（查看 Bypassing Android’s RootBeer Library — Part 1）

本题仅使用 RootBeer 的综合检测方法 isRooted() 来检测 Root，这倒是为我们省去了不少麻烦，因为我们只需要 Hook isRooted() 就行了。

Native Hook

与 Java 层不同，Native 层的函数是分散在 so 文件中的。在 Hook 前，Frida 需要找到目标函数，因为 so 是动态加载的。

]]> https://blog.watermelonabc.top/p/f840d92a/ 2025-12-01T09:19:41.000Z REer 钓 Functions Frida 入门 2026-08-04T09:53:11.000Z Watermelonabc 这几天在 FZU 贴吧里参加一场 “讨论”（你福里面的伪人还是有点东西的）。正好最近还刷到了一个讲 “诡辩” 的视频，正巧没地方应用，这下机会来了。

思来想去，也搬 史 过来给各位读者瞧瞧，看看哪方有理。毕竟观众也是辩论的重要一环 -

Note

我使用 ChatGPT 进行逻辑辅助，即先检查我的回答中逻辑是否足以反驳对方的观点；具体表达基本由我自己查阅资料后写出。我与 ChatGPT 的交流，详见 支持哪方观点分析

Question

你能找出这里哪些地方运用了诡辩吗？

以下是帖子里的交流内容，为了节省篇幅，仅节选我和 TA 的交流。TA 的交流以灰色注释形式给出。

Background

有人在学校表白墙上发了一篇声讨不规范骑电动车的文章，评论区内抱怨违法的和讽刺守法的开始争吵

我是认为如果你能保持每时每刻全部遵守交规你才能站在制高点上指指点点，五十步笑百步的就别在这显摆优越感了

建议您先搜一下 “诉诸人身” 再重新审视一下自己的观点。“…… 毕竟，大家都是半斤八两，你王美丽不过是五十步笑百步罢了，也好不到哪里去。张小帅最后的这种想法，也是一种诉诸人身的谬误，其拉丁名字叫 Tu quoque，意思是‘你也一样’。它又叫诉诸伪善谬误。”

比烂不可取。极端一点，我是否可以认为，基于你的说法，连交警都可能无法依法规劝违规行为，因为你无法保证 TA 曾经是否也违反过交规？

交警的依规处理国家赋予的权利，你一个普通公民有执法权？

我有说 “执法” 吗？我说的是依法 “规劝”：“公民以规劝维护公共安全，如劝阻公交车纠纷时体现的正当性受到司法保护” 当然，交警的执法权利有法律保护，这是事实。但是，其他人就不能 “规劝” 他人守法吗？

“对违反道路交通安全的行为，任何人都有权劝阻和控告”——《福建省道路交通管理实施办法》（1991 年） “任何单位和个人都…… 有权劝阻、举报道路交通安全违法行为，报告道路交通安全隐患”——《山东省实施道路交通安全责任制规定》/浙江省实施《中华人民共和国道路交通安全法》办法

这件事属于规劝吗？在网上骂，输出情绪，真规劝当场啊

说白了，法律上你要不当场和他吵，在网上说没屁用，道德上，你自己都在违法，有什么立场，己所不欲勿施于人，真正解决问题，也没有，都在输出情绪

首先，“规劝” 不限于线下，否则各类安全公众号所发布的内容都是无用功——毕竟线上劝没用，一定要现实中 “不撞南墙不回头”；其次，我一再强调，“违规过” 不代表不能 “批评”；再者，不能立刻解决问题不等于没价值，不说才是真正永远解决不了问题。最后，互联网确实是情绪化的。

“社交平台成为公众抒发个人意见、释放情绪，缓解生活压力的主要渠道”。按你的说法，我也可以认为，除非你没有过在互联网上 “输出情绪” 的时候，否则你也没有权利去阻止别人 “情绪输出”；你的回复同样没有解决问题，甚至可能扩大化了问题。那么，我的建议是：把嘴巴闭一闭

第一，在原贴发言的没有规劝意味，只是骂，我不认为有帮助，公众号是在温和劝导，方式不对，效果不同，这样只会骂战，无意义，第二，违规过可以批评，前提是你改了，问题是所有在这边骂的人，在对自己的时候就开始双标，他在这边骂，下次自己开车一样违反，一样不带头盔，他有什么资格骂他人，事实上他自己和你都清楚这是不可避免的，但还在骂，只不过是在网上看不到你们自己的丑态，可以对一个虚拟形象施暴，展现自己的道德优越，第三，我不是在阻止情绪输出，我在反对过度理想化的非黑即白，我在请求在网络环境进行有意义的可实施性方案的探讨，而不是对立，双方输出情绪，让问题回归问题

1. 情绪输出中也有 TA 的观点表达；温和劝导也未必能引导有效讨论 2. 你无从知道对方是否 “改过” 3. 擅自将网络后的每个人都认为 “可能犯过法”，是否也是一种 “非黑即白”？

你 23 点罔顾现实

closed as not continued

]]> https://blog.watermelonabc.top/p/a4a1670e/ 2025-11-21T17:19:15.000Z 并不别样也不大的争吵 记一场贴吧交流 2026-08-04T09:53:11.000Z Watermelonabc 最近和学长们打了一些大比赛，看了下来发现 VMP 有点多哈 😅。总不能每次见到就投降吧。

什么是 VMP

VMP 全称是 “基于虚拟机的代码保护技术” (Virtual Machine-Based Protection)。当然，和各位可能听到过的 VMWare 等不太一样，程序保护中的 “虚拟机” 更多像 “解释器”：虚拟机先将原始代码翻译成其自己的专有字节码（这个过程称为虚拟化），然后在运行时解释并执行字节码对应语句。

专业点说，就是使用自己的一套指令集架构（指令、内存、寄存器、权限……）作为中间层，隐藏实际的通用架构指令。

这种保护技术的特点是，我们不能直接看到自己可能熟悉的原始指令；我们必须首先分析解释器，然后使用所获得的自定义指令集知识将专有字节码转换为我们熟悉的标准指令。

最基础的 VM

用 C 的 switch-case 语句就能构建一个非常简单的 VM：

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
#include <stdio.h>int vm(int* opcode, int opleng){  int pc = 0;  if(opleng <= 0)  {    printf("Invaild length of opcode array\n");    return 1;  }  else  {    while(pc != opleng)    {      switch(opcode[pc])      {        // ...        default:          printf("Invalid opcode: 0x%x at position %d\n", opcode[pc], pc);          return 2;      }      pc++;    }  }  return 0;}int main(void){  int opcode[] = {...};  int opleng = sizeof(opcode) / sizeof(opcode[0]);  vm(opcode, opleng);  return 0;}

这个 VM 会按顺序执行 opcode[] 定义的的字节码，通过 switch(opcode[pc]) 指定如何解释字节码行为，还有基本的错误处理功能。

当然，这个 VM 是禁不住考验的：对于防守方，opcode 的复用性差劲，没有完全实现 “解释器” 功能；对于攻击方，整个架构太简单，VM 本身也变得需要保护。

从计组讲起

指令执行的五个阶段分为取指 (Fetch)、译码 (Decode)、执行 (Execute)、访存、写回。VM 就是要部分模拟这个过程，一般是取指、译码、分发 (Dispatch)、执行。其中分发环节是 VM 设计的重点。

我们上面给出的简单 VM 就演示了 switch-case dispatch 这种分发方式。

以一道 CTF 题目为基础

L3HCTF 2025 easyvm

视频：【星盟安全】L3HCTF 逆向方向 easyvm 讲解

字符串定位主函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sub_140005940();v2 = std::operator<<<std::char_traits<char>>(a1, a2, "Welcome to L3HCTF2025!!!Do you love cpp and vm?", &std::cout);std::ostream::operator<<(a1, a2, &std::endl<char,std::char_traits<char>>, v2);sub_140011D30(a1, a2, v3, v29, v4, v5);sub_140017DF0(a1, a2, &unk_140022040, v28, v6, v7);sub_140010700(a1, a2, v28, v29, v8, v9);v10 = std::operator<<<std::char_traits<char>>(a1, a2, "Explore this virtual machine and have fun!", &std::cout);std::ostream::operator<<(a1, a2, &std::endl<char,std::char_traits<char>>, v10);v11 = std::operator<<<std::char_traits<char>>(a1, a2, "Plz show me flag:", &std::cout);std::ostream::operator<<(a1, a2, &std::endl<char,std::char_traits<char>>, v11);sub_140011C40(a1, a2, v12, v29, v13, v14);sub_140011AB0(a1, a2, v15, v29, v16, v17);sub_140011AE0(a1, a2, v18, v29, v19, v20);sub_140017FC0(a1, a2, v21, v28, v22, v23);sub_140011DE0(a1, a2, v24, v29, v25, v26);

我们主要看提示输入 flag 后的这 4 个函数。

sub_140011C40 里面有一个格式化字符串 %s，猜测作用是读取输入的 flag。

sub_140011AB0 内的 sub_1400107E0 里有着大量的 switch-case 结构：

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
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
__int64 __fastcall sub_1400107E0(void *Ix, int a2, int a3, __int64 a4, int a5, int a6){  unsigned __int64 v6; // rbx  int v7; // r8d  int v8; // r9d  int v11; // edx  int v12; // r8d  int v13; // r9d  unsigned __int8 n2; // al  int v15; // edx  int v16; // r8d  int v17; // r9d  int v18; // edx  int v19; // r8d  int v20; // r9d  int v21; // r8d  int v22; // r9d  int v23; // edx  int v24; // r8d  int v25; // r9d  int v26; // edx  int v27; // r8d  int v28; // r9d  int v29; // edx  int v30; // r8d  int v31; // r9d  int v32; // edx  int v33; // r8d  int v34; // r9d  int v35; // r8d  int v36; // r9d  int v37; // r8d  int v38; // r9d  int v39; // edx  int v40; // r8d  int v41; // r9d  int v42; // edx  int v43; // r8d  int v44; // r9d  int v45; // edx  int v46; // r8d  int v47; // r9d  int v48; // edx  int v49; // r8d  int v50; // r9d  int v51; // r8d  int v52; // r9d  int v53; // edx  int v54; // r8d  int v55; // r9d  int v56; // edx  int v57; // r8d  int v58; // r9d  int v59; // edx  int v60; // r8d  int v61; // r9d  int v62; // edx  int v63; // r8d  int v64; // r9d  int v65; // r8d  int v66; // r9d  int v67; // edx  int v68; // r8d  int v69; // r9d  int v70; // edx  int v71; // r8d  int v72; // r9d  int v73; // edx  int v74; // r8d  int v75; // r9d  int v76; // edx  int v77; // r8d  int v78; // r9d  int v79; // r8d  int v80; // r9d  int v81; // edx  int v82; // r8d  int v83; // r9d  int v84; // edx  int v85; // r8d  int v86; // r9d  int v87; // edx  int v88; // r8d  int v89; // r9d  int v90; // edx  int v91; // r8d  int v92; // r9d  int v93; // r8d  int v94; // r9d  int v95; // edx  int v96; // r8d  int v97; // r9d  int v98; // edx  int v99; // r8d  int v100; // r9d  int v101; // edx  int v102; // r8d  int v103; // r9d  int v104; // edx  int v105; // r8d  int v106; // r9d  int v107; // r8d  int v108; // r9d  int v109; // edx  int v110; // r8d  int v111; // r9d  int v112; // edx  int v113; // r8d  int v114; // r9d  int v115; // r8d  int v116; // r9d  int v117; // edx  int v118; // r8d  int v119; // r9d  int v120; // edx  int v121; // r8d  int v122; // r9d  int v123; // edx  int v124; // r8d  int v125; // r9d  int v126; // edx  int v127; // r8d  int v128; // r9d  int v129; // r8d  int v130; // r9d  int v131; // edx  int v132; // r8d  int v133; // r9d  int v134; // edx  int v135; // r8d  int v136; // r9d  int v137; // edx  int v138; // r8d  int v139; // r9d  int v140; // edx  int v141; // r8d  int v142; // r9d  int v143; // r8d  int v144; // r9d  int v145; // edx  int v146; // r8d  int v147; // r9d  int v148; // edx  int v149; // r8d  int v150; // r9d  int v151; // edx  int v152; // r8d  int v153; // r9d  int v154; // edx  int v155; // r8d  int v156; // r9d  int v157; // r8d  int v158; // r9d  int v159; // edx  int v160; // r8d  int v161; // r9d  int v162; // edx  int v163; // r8d  int v164; // r9d  int v165; // edx  int v166; // r8d  int v167; // r9d  int v168; // edx  int v169; // r8d  int v170; // r9d  int v171; // r8d  int v172; // r9d  int v173; // edx  int v174; // r8d  int v175; // r9d  int v176; // edx  int v177; // r8d  int v178; // r9d  int v179; // edx  int v180; // r8d  int v181; // r9d  int v182; // edx  int v183; // r8d  int v184; // r9d  int v185; // r8d  int v186; // r9d  int v187; // edx  int v188; // r8d  int v189; // r9d  int v190; // edx  int v191; // r8d  int v192; // r9d  int v193; // edx  int v194; // r8d  int v195; // r9d  int v196; // edx  int v197; // r8d  int v198; // r9d  int v199; // r8d  int v200; // r9d  int v201; // edx  int v202; // r8d  int v203; // r9d  int v204; // edx  int v205; // r8d  int v206; // r9d  int v207; // edx  int v208; // r8d  int v209; // r9d  int v210; // edx  int v211; // r8d  int v212; // r9d  int v213; // r8d  int v214; // r9d  BOOL v215; // eax  int v216; // edx  int v217; // r8d  int v218; // r9d  int v219; // edx  int v220; // r8d  int v221; // r9d  int v222; // edx  int v223; // r8d  int v224; // r9d  int v225; // edx  int v226; // r8d  int v227; // r9d  int v228; // r8d  int v229; // r9d  BOOL v230; // eax  int v231; // edx  int v232; // r8d  int v233; // r9d  int v234; // edx  int v235; // r8d  int v236; // r9d  int v237; // r8d  int v238; // r9d  int v239; // edx  int v240; // r8d  int v241; // r9d  int v242; // edx  int v243; // r8d  int v244; // r9d  int v245; // edx  int v246; // r8d  int v247; // r9d  int v248; // edx  int v249; // r8d  int v250; // r9d  int v251; // r9d  int v252; // edx  int v253; // r8d  int v254; // r9d  int v255; // edx  int v256; // r8d  int v257; // r9d  int v258; // edx  int v259; // r8d  int v260; // r9d  int v261; // edx  int v262; // r8d  int v263; // r9d  int v264; // r9d  int v265; // edx  int v266; // r8d  int v267; // r9d  int v268; // edx  int v269; // r8d  int v270; // r9d  int v271; // r8d  int v272; // r9d  int v273; // eax  int v274; // r8d  int v275; // r9d  int v276; // edx  int v277; // r8d  int v278; // r9d  int v279; // edx  int v280; // r8d  int v281; // r9d  int v282; // edx  int v283; // r8d  int v284; // r9d  int v285; // edx  int v286; // r8d  int v287; // r9d  int v288; // ebx  int v289; // r8d  int v290; // r9d  int v291; // edx  int v292; // r8d  int v293; // r9d  int v294; // edx  int v295; // r8d  int v296; // r9d  int v297; // edx  int v298; // r8d  int v299; // r9d  int v300; // edx  int v301; // r8d  int v302; // r9d  int v303; // edx  int v304; // r8d  int v305; // r9d  int v306; // edx  int v307; // r8d  int v308; // r9d  int v309; // edx  int v310; // r8d  int v311; // r9d  int v312; // edx  int v313; // r8d  int v314; // r9d  int v315; // r8d  int v316; // r9d  int v317; // edx  int v318; // r8d  int v319; // r9d  __int64 *v320; // rax  __int64 v321; // rdx  int v322; // r8d  int v323; // r9d  __int64 v324; // [rsp+0h] [rbp-80h]  __int64 v325; // [rsp+0h] [rbp-80h]  __int64 v326; // [rsp+0h] [rbp-80h]  __int64 v327; // [rsp+8h] [rbp-78h]  int v328; // [rsp+28h] [rbp-58h] BYREF  int v329; // [rsp+2Ch] [rbp-54h] BYREF  int v330; // [rsp+30h] [rbp-50h] BYREF  int v331; // [rsp+34h] [rbp-4Ch] BYREF  int v332; // [rsp+38h] [rbp-48h] BYREF  int v333; // [rsp+3Ch] [rbp-44h] BYREF  int v334; // [rsp+40h] [rbp-40h] BYREF  int v335; // [rsp+44h] [rbp-3Ch] BYREF  int v336; // [rsp+48h] [rbp-38h] BYREF  int v337; // [rsp+4Ch] [rbp-34h] BYREF  BOOL v338; // [rsp+50h] [rbp-30h] BYREF  BOOL v339; // [rsp+54h] [rbp-2Ch] BYREF  BOOL v340; // [rsp+58h] [rbp-28h] BYREF  BOOL v341; // [rsp+5Ch] [rbp-24h] BYREF  BOOL v342; // [rsp+60h] [rbp-20h] BYREF  BOOL v343; // [rsp+64h] [rbp-1Ch] BYREF  BOOL v344; // [rsp+68h] [rbp-18h] BYREF  BOOL v345; // [rsp+6Ch] [rbp-14h] BYREF  BOOL v346; // [rsp+70h] [rbp-10h] BYREF  int v347; // [rsp+74h] [rbp-Ch] BYREF  unsigned int v348; // [rsp+78h] [rbp-8h] BYREF  unsigned int v349; // [rsp+7Ch] [rbp-4h] BYREF  unsigned int v350; // [rsp+80h] [rbp+0h] BYREF  int v351; // [rsp+84h] [rbp+4h] BYREF  __int64 v352; // [rsp+88h] [rbp+8h] BYREF  int v353; // [rsp+90h] [rbp+10h]  int v354; // [rsp+94h] [rbp+14h]  int v355; // [rsp+98h] [rbp+18h]  int v356; // [rsp+9Ch] [rbp+1Ch]  int v357; // [rsp+A0h] [rbp+20h]  int v358; // [rsp+A4h] [rbp+24h]  unsigned int v359; // [rsp+A8h] [rbp+28h]  unsigned int v360; // [rsp+ACh] [rbp+2Ch]  unsigned int v361; // [rsp+B0h] [rbp+30h]  unsigned int v362; // [rsp+B4h] [rbp+34h]  int v363; // [rsp+B8h] [rbp+38h]  int v364; // [rsp+BCh] [rbp+3Ch]  unsigned int v365; // [rsp+C0h] [rbp+40h]  int v366; // [rsp+C4h] [rbp+44h]  int v367; // [rsp+C8h] [rbp+48h]  int v368; // [rsp+CCh] [rbp+4Ch]  int v369; // [rsp+D0h] [rbp+50h]  int v370; // [rsp+D4h] [rbp+54h]  int v371; // [rsp+D8h] [rbp+58h]  int v372; // [rsp+DCh] [rbp+5Ch]  unsigned int v373; // [rsp+E0h] [rbp+60h]  unsigned int v374; // [rsp+E4h] [rbp+64h]  unsigned int v375; // [rsp+E8h] [rbp+68h]  unsigned int v376; // [rsp+ECh] [rbp+6Ch]  unsigned int v377; // [rsp+F0h] [rbp+70h]  unsigned int v378; // [rsp+F4h] [rbp+74h]  unsigned int v379; // [rsp+F8h] [rbp+78h]  unsigned int v380; // [rsp+FCh] [rbp+7Ch]  int v381; // [rsp+100h] [rbp+80h]  int v382; // [rsp+104h] [rbp+84h]  int v383; // [rsp+108h] [rbp+88h]  int v384; // [rsp+10Ch] [rbp+8Ch]  int v385; // [rsp+110h] [rbp+90h]  unsigned int v386; // [rsp+114h] [rbp+94h]  int v387; // [rsp+118h] [rbp+98h]  unsigned int v388; // [rsp+11Ch] [rbp+9Ch]  int v389; // [rsp+120h] [rbp+A0h]  int v390; // [rsp+124h] [rbp+A4h]  __int64 v391; // [rsp+128h] [rbp+A8h]  v6 = *(a4 + 240);  if ( v6 >= sub_140012B20(Ix, a2, a3, a4, a5, a6) || *(a4 + 248) )    return 0;  v391 = sub_140018360(Ix, a2, *(a4 + 240), a4, v7, v8);  n2 = *v391;  if ( *v391 == 0xFF )  {    *(a4 + 248) = 1;    return 0;  }  else  {    if ( n2 < 0x60u )    {      if ( n2 == 84 )      {        if ( sub_140012AD0(Ix, a2, v11, a4 + 160, v12, v13) != 1 )        {          v320 = sub_1400178A0(Ix, a2, v317, a4 + 160, v318, v319);          v321 = *v320;          *(a4 + 240) = *v320;          sub_140017840(Ix, a2, v321, a4 + 160, v322, v323);          return 1;        }      }      else if ( n2 <= 0x54u )      {        switch ( n2 )        {          case 'S':            v352 = *(a4 + 240) + 1LL;            sub_140017900(Ix, a2, &v352, a4 + 160, v12, v13);            *(a4 + 240) = *(v391 + 4);            return 1;          case 'R':            if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )            {              v390 = *sub_140017720(Ix, a2, v297, a4 + 24, v298, v299);              sub_1400176C0(Ix, a2, v300, a4 + 24, v301, v302);              if ( v390 )              {                *(a4 + 240) = *(v391 + 4);                return 1;              }            }            break;          case 'Q':            if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )            {              v389 = *sub_140017720(Ix, a2, v291, a4 + 24, v292, v293);              sub_1400176C0(Ix, a2, v294, a4 + 24, v295, v296);              if ( !v389 )              {                *(a4 + 240) = *(v391 + 4);                return 1;              }            }            break;          case 'P':            *(a4 + 240) = *(v391 + 4);            return 1;          case 'A':            if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )            {              v388 = *sub_140017720(Ix, a2, v276, a4 + 24, v277, v278);              sub_1400176C0(Ix, a2, v279, a4 + 24, v280, v281);              v387 = *sub_140017720(Ix, a2, v282, a4 + 24, v283, v284);              sub_1400176C0(Ix, a2, v285, a4 + 24, v286, v287);              v288 = v387;              v350 = v388;              *sub_140015400(Ix, a2, &v350, a4 + 104, v289, v290, v324, v327) = v288;            }            break;          default:            if ( n2 <= 0x41u )            {              if ( n2 == 64 )              {                if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )                {                  v386 = *sub_140017720(Ix, a2, v265, a4 + 24, v266, v267);                  sub_1400176C0(Ix, a2, v268, a4 + 24, v269, v270);                  v349 = v386;                  v273 = sub_140015400(Ix, a2, &v349, a4 + 104, v271, v272, v324, v327);                  sub_1400177B0(Ix, a2, v273, a4 + 24, v274, v275, v326);                }              }              else if ( n2 == 50 )              {                if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )                {                  v385 = *sub_140017720(Ix, a2, v231, a4 + 24, v232, v233);                  sub_1400176C0(Ix, a2, v234, a4 + 24, v235, v236);                  v346 = v385 == 0;                  sub_140017780(Ix, a2, &v346, a4 + 24, v237, v238);                }              }              else if ( n2 <= 0x32u )              {                switch ( n2 )                {                  case '1':                    if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                    {                      v384 = *sub_140017720(Ix, a2, v216, a4 + 24, v217, v218);                      sub_1400176C0(Ix, a2, v219, a4 + 24, v220, v221);                      v383 = *sub_140017720(Ix, a2, v222, a4 + 24, v223, v224);                      sub_1400176C0(Ix, a2, v225, a4 + 24, v226, v227);                      v230 = v383 || v384;                      v345 = v230;                      sub_140017780(Ix, a2, &v345, a4 + 24, v228, v229);                    }                    break;                  case '0':                    if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                    {                      v382 = *sub_140017720(Ix, a2, v201, a4 + 24, v202, v203);                      sub_1400176C0(Ix, a2, v204, a4 + 24, v205, v206);                      v381 = *sub_140017720(Ix, a2, v207, a4 + 24, v208, v209);                      sub_1400176C0(Ix, a2, v210, a4 + 24, v211, v212);                      v215 = v381 && v382;                      v344 = v215;                      sub_140017780(Ix, a2, &v344, a4 + 24, v213, v214);                    }                    break;                  case '%':                    if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                    {                      v380 = *sub_140017720(Ix, a2, v187, a4 + 24, v188, v189);                      sub_1400176C0(Ix, a2, v190, a4 + 24, v191, v192);                      v379 = *sub_140017720(Ix, a2, v193, a4 + 24, v194, v195);                      sub_1400176C0(Ix, a2, v196, a4 + 24, v197, v198);                      v343 = v379 >= v380;                      sub_140017780(Ix, a2, &v343, a4 + 24, v199, v200);                    }                    break;                  default:                    if ( n2 <= 0x25u )                    {                      switch ( n2 )                      {                        case 0x24u:                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                          {                            v378 = *sub_140017720(Ix, a2, v173, a4 + 24, v174, v175);                            sub_1400176C0(Ix, a2, v176, a4 + 24, v177, v178);                            v377 = *sub_140017720(Ix, a2, v179, a4 + 24, v180, v181);                            sub_1400176C0(Ix, a2, v182, a4 + 24, v183, v184);                            v342 = v378 < v377;                            sub_140017780(Ix, a2, &v342, a4 + 24, v185, v186);                          }                          break;                        case 0x23u:                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                          {                            v376 = *sub_140017720(Ix, a2, v159, a4 + 24, v160, v161);                            sub_1400176C0(Ix, a2, v162, a4 + 24, v163, v164);                            v375 = *sub_140017720(Ix, a2, v165, a4 + 24, v166, v167);                            sub_1400176C0(Ix, a2, v168, a4 + 24, v169, v170);                            v341 = v376 >= v375;                            sub_140017780(Ix, a2, &v341, a4 + 24, v171, v172);                          }                          break;                        case 0x22u:                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                          {                            v374 = *sub_140017720(Ix, a2, v145, a4 + 24, v146, v147);                            sub_1400176C0(Ix, a2, v148, a4 + 24, v149, v150);                            v373 = *sub_140017720(Ix, a2, v151, a4 + 24, v152, v153);                            sub_1400176C0(Ix, a2, v154, a4 + 24, v155, v156);                            v340 = v373 < v374;                            sub_140017780(Ix, a2, &v340, a4 + 24, v157, v158);                          }                          break;                        case 0x21u:                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                          {                            v372 = *sub_140017720(Ix, a2, v131, a4 + 24, v132, v133);                            sub_1400176C0(Ix, a2, v134, a4 + 24, v135, v136);                            v371 = *sub_140017720(Ix, a2, v137, a4 + 24, v138, v139);                            sub_1400176C0(Ix, a2, v140, a4 + 24, v141, v142);                            v339 = v371 != v372;                            sub_140017780(Ix, a2, &v339, a4 + 24, v143, v144);                          }                          break;                        case 0x20u:                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                          {                            v370 = *sub_140017720(Ix, a2, v117, a4 + 24, v118, v119);                            sub_1400176C0(Ix, a2, v120, a4 + 24, v121, v122);                            v369 = *sub_140017720(Ix, a2, v123, a4 + 24, v124, v125);                            sub_1400176C0(Ix, a2, v126, a4 + 24, v127, v128);                            v338 = v369 == v370;                            sub_140017780(Ix, a2, &v338, a4 + 24, v129, v130);                          }                          break;                        case 0x18u:                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                          {                            v368 = *sub_140017720(Ix, a2, v303, a4 + 24, v304, v305);                            sub_1400176C0(Ix, a2, v306, a4 + 24, v307, v308);                            v367 = *sub_140017720(Ix, a2, v309, a4 + 24, v310, v311);                            sub_1400176C0(Ix, a2, v312, a4 + 24, v313, v314);                            v351 = v368 ^ v367;                            sub_140017780(Ix, a2, &v351, a4 + 24, v315, v316);                          }                          break;                        default:                          if ( n2 <= 0x18u )                          {                            switch ( n2 )                            {                              case 0x17u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v366 = *sub_140017720(Ix, a2, v252, a4 + 24, v253, v254);                                  sub_1400176C0(Ix, a2, v255, a4 + 24, v256, v257);                                  v365 = *sub_140017720(Ix, a2, v258, a4 + 24, v259, v260);                                  sub_1400176C0(Ix, a2, v261, a4 + 24, v262, v263);                                  v348 = v365 >> v366;                                  sub_140017780(Ix, a2, &v348, a4 + 24, a4 + 24, v264);                                }                                break;                              case 0x16u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v364 = *sub_140017720(Ix, a2, v239, a4 + 24, v240, v241);                                  sub_1400176C0(Ix, a2, v242, a4 + 24, v243, v244);                                  v363 = *sub_140017720(Ix, a2, v245, a4 + 24, v246, v247);                                  sub_1400176C0(Ix, a2, v248, a4 + 24, v249, v250);                                  v347 = v363 << v364;                                  sub_140017780(Ix, a2, &v347, a4 + 24, a4 + 24, v251);                                }                                break;                              case 0x15u:                                if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )                                {                                  v328 = *sub_140017720(Ix, a2, v109, a4 + 24, v110, v111);                                  sub_1400176C0(Ix, a2, v112, a4 + 24, v113, v114);                                  sub_1400177B0(Ix, a2, &v328, a4 + 24, v115, v116, v324);                                }                                break;                              case 0x14u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v362 = *sub_140017720(Ix, a2, v95, a4 + 24, v96, v97);                                  sub_1400176C0(Ix, a2, v98, a4 + 24, v99, v100);                                  v361 = *sub_140017720(Ix, a2, v101, a4 + 24, v102, v103);                                  sub_1400176C0(Ix, a2, v104, a4 + 24, v105, v106);                                  if ( v362 )                                  {                                    v337 = v361 % v362;                                    sub_140017780(Ix, a2, &v337, a4 + 24, v107, v108);                                  }                                }                                break;                              case 0x13u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v360 = *sub_140017720(Ix, a2, v81, a4 + 24, v82, v83);                                  sub_1400176C0(Ix, a2, v84, a4 + 24, v85, v86);                                  v359 = *sub_140017720(Ix, a2, v87, a4 + 24, v88, v89);                                  sub_1400176C0(Ix, a2, v90, a4 + 24, v91, v92);                                  if ( v360 )                                  {                                    v336 = v359 / v360;                                    sub_140017780(Ix, a2, &v336, a4 + 24, v93, v94);                                  }                                }                                break;                              case 0x12u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v358 = *sub_140017720(Ix, a2, v67, a4 + 24, v68, v69);                                  sub_1400176C0(Ix, a2, v70, a4 + 24, v71, v72);                                  v357 = *sub_140017720(Ix, a2, v73, a4 + 24, v74, v75);                                  sub_1400176C0(Ix, a2, v76, a4 + 24, v77, v78);                                  v335 = v358 * v357;                                  sub_140017780(Ix, a2, &v335, a4 + 24, v79, v80);                                }                                break;                              case 0x11u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v356 = *sub_140017720(Ix, a2, v53, a4 + 24, v54, v55);                                  sub_1400176C0(Ix, a2, v56, a4 + 24, v57, v58);                                  v355 = *sub_140017720(Ix, a2, v59, a4 + 24, v60, v61);                                  sub_1400176C0(Ix, a2, v62, a4 + 24, v63, v64);                                  v334 = v355 - v356;                                  sub_140017780(Ix, a2, &v334, a4 + 24, v65, v66);                                }                                break;                              case 0x10u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v354 = *sub_140017720(Ix, a2, v39, a4 + 24, v40, v41);                                  sub_1400176C0(Ix, a2, v42, a4 + 24, v43, v44);                                  v353 = *sub_140017720(Ix, a2, v45, a4 + 24, v46, v47);                                  sub_1400176C0(Ix, a2, v48, a4 + 24, v49, v50);                                  v333 = v353 + v354;                                  sub_140017780(Ix, a2, &v333, a4 + 24, v51, v52);                                }                                break;                              case 4u:                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )                                {                                  v330 = *sub_140017720(Ix, a2, v23, a4 + 24, v24, v25);                                  sub_1400176C0(Ix, a2, v26, a4 + 24, v27, v28);                                  v329 = *sub_140017720(Ix, a2, v29, a4 + 24, v30, v31);                                  sub_1400176C0(Ix, a2, v32, a4 + 24, v33, v34);                                  sub_1400177B0(Ix, a2, &v330, a4 + 24, v35, v36, v324);                                  sub_1400177B0(Ix, a2, &v329, a4 + 24, v37, v38, v325);                                }                                break;                              default:                                if ( n2 <= 4u )                                {                                  if ( n2 == 3 )                                  {                                    if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )                                    {                                      v331 = *sub_140017720(Ix, a2, v18, a4 + 24, v19, v20);                                      sub_1400177B0(Ix, a2, &v331, a4 + 24, v21, v22, v324);                                    }                                  }                                  else if ( n2 == 1 )                                  {                                    v332 = *(v391 + 4);                                    sub_140017780(Ix, a2, &v332, a4 + 24, v12, v13);                                  }                                  else if ( n2 == 2 && sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )                                  {                                    sub_1400176C0(Ix, a2, v15, a4 + 24, v16, v17);                                  }                                }                                break;                            }                          }                          break;                      }                    }                    break;                }              }            }            break;        }      }    }    ++*(a4 + 240);    return 1;  }}

可认为这就是 VM 主体了。

sub_140011AE0 则开始输出正确与否了，此函数应该为验证函数。

]]> https://blog.watermelonabc.top/p/ea587991/ 2025-11-09T12:52:31.000Z 你猜猜我执行的是什么指令 🙂 虚拟机保护 2026-08-04T09:53:11.000Z Watermelonabc 孩子们，我又被 RE 肘击辣 😭

PolyEncryption

本题使用 Docker 部署，但是所给的文件不足以本地搭建……

题目只给了一个 dll，拖进 DIE，发现是 .NET，故使用 ILSpy 进行反编译

不要用 dnSpy

因为 dll 用了异步编程，所以编译的时候会编译成状态机的形式，用 dnspy 看的话只能反编译到状态机的代码，用 ilspy 才能完整反编译。

即使我使用 dnSpy 的最新构建版本，依然无法完整反编译…… C# 那篇已经更新信息了。

作为对比，对于 Main 方法，dnSpy 的反编译结果只有 12 行，而 ILSpy 则是足足 284 行！

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
// saw, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null// Sawusing System;using System.Diagnostics;using System.Net;using System.Net.Sockets;using System.Reflection;using System.Security.Cryptography;using System.Text;using System.Threading;using System.Threading.Tasks;private static async Task Main(string[] args){if (args.Length != 1){Console.WriteLine("Usage: dotnet saw.dll [input]");Console.WriteLine("  where input is 16 hexa bytes (eg abe74e3a9c375b3428bf31d1f8fa49c1)");Environment.Exit(1);}man.BlockSize = 128;man.Mode = CipherMode.CBC;man.Padding = PaddingMode.PKCS7;k = SHA256.Create().ComputeHash(Encoding.ASCII.GetBytes(typeof(Saw).Assembly.FullName));s[1023] = 3207972492L;s[1024] = 1190065579L;s[1025] = 4165979424L;s[1026] = 2693353696L;s[1027] = 3628337899L;s[1028] = 1707638109L;s[1029] = 1003779598L;s[1030] = 2653425729L;s[1031] = 795752593L;s[1032] = 2469382657L;long[] array = new long[16];Array.Copy(s, 1017, array, 0, 16);iv = Array.ConvertAll(array, (long x) => (byte)x);TcpListener tcpListener = new TcpListener(IPAddress.Loopback, 0);tcpListener.Start();Process p = Process.Start(new ProcessStartInfo("python3", "-m saw " + ((IPEndPoint)tcpListener.LocalEndpoint).Port){Environment = {{"PYTHONPATH",Assembly.GetEntryAssembly().Location} }});client = tcpListener.AcceptTcpClient();await Hack();await Track();int rr = 0;while (true){Console.Error.Write(".");await Shreck();if (rr == 0){s[32] = Convert.ToInt64(args[0].Substring(0, 8), 16);s[33] = Convert.ToInt64(args[0].Substring(8, 8), 16);s[34] = Convert.ToInt64(args[0].Substring(16, 8), 16);s[35] = Convert.ToInt64(args[0].Substring(24, 8), 16);}else if (rr % 2 == 1){if (rr != 1){await Stop(await Crack(new byte[32]{34, 38, 13, 204, 106, 91, 87, 35, 115, 198,124, 92, 83, 151, 127, 227, 60, 108, 237, 212,71, 88, 37, 39, 222, 28, 237, 242, 207, 61,89, 65}));}else{await Stop(await Crack(new byte[32]{54, 26, 153, 43, 207, 163, 66, 102, 1, 251,172, 137, 133, 103, 252, 200, 133, 6, 227, 185,100, 190, 49, 220, 132, 230, 14, 201, 184, 28,84, 127}));sp += 3;}long[] array2 = s;array2[2] = await Stop(await Crack(new byte[16]{132, 17, 89, 19, 158, 87, 26, 91, 138, 184,20, 203, 22, 142, 33, 67}));array2 = s;array2[3] = await Stop(await Crack(new byte[16]{98, 124, 165, 114, 4, 73, 122, 239, 35, 224,182, 58, 230, 239, 169, 171}));if (rr == 1){s[4] = 1038097261L;}else{s[4] ^= s[3];}}else{sp -= 27;await Stop(await Crack(new byte[32]{181, 158, 168, 62, 5, 218, 108, 22, 225, 44,69, 4, 169, 112, 225, 186, 212, 234, 186, 217,245, 102, 219, 46, 107, 236, 2, 37, 80, 8,162, 183}));await Stop(await Crack(new byte[32]{71, 166, 143, 191, 134, 170, 65, 147, 11, 69,123, 125, 140, 156, 32, 225, 68, 85, 198, 59,6, 58, 62, 75, 142, 62, 22, 169, 7, 21,26, 177}));for (int ii = 0; ii < 4; ii++){await Stop(await Crack(new byte[32]{88, 244, 228, 34, 209, 136, 53, 33, 174, 103,199, 211, 90, 244, 91, 46, 98, 141, 50, 45,70, 160, 34, 209, 131, 19, 95, 66, 187, 185,87, 236}));await Stop(await Crack(new byte[32]{59, 134, 219, 11, 168, 34, 42, 6, 142, 30,47, 12, 175, 97, 187, 166, 191, 165, 206, 91,56, 92, 35, 91, 63, 232, 2, 235, 246, 41,249, 60}));await Stop(await Crack(new byte[32]{30, 47, 78, 72, 232, 144, 186, 158, 145, 46,78, 42, 66, 78, 48, 177, 201, 84, 194, 246,32, 77, 153, 26, 204, 139, 24, 149, 70, 89,23, 50}));await Stop(await Crack(new byte[32]{88, 244, 228, 34, 209, 136, 53, 33, 174, 103,199, 211, 90, 244, 91, 46, 98, 141, 50, 45,70, 160, 34, 209, 131, 19, 95, 66, 187, 185,87, 236}));await Stop(await Crack(new byte[32]{59, 134, 219, 11, 168, 34, 42, 6, 142, 30,47, 12, 175, 97, 187, 166, 191, 165, 206, 91,56, 92, 35, 91, 63, 232, 2, 235, 246, 41,249, 60}));await Stop(await Crack(new byte[32]{30, 47, 78, 72, 232, 144, 186, 158, 145, 46,78, 42, 66, 78, 48, 177, 201, 84, 194, 246,32, 77, 153, 26, 204, 139, 24, 149, 70, 89,23, 50}));await Stop(await Crack(new byte[32]{88, 244, 228, 34, 209, 136, 53, 33, 174, 103,199, 211, 90, 244, 91, 46, 98, 141, 50, 45,70, 160, 34, 209, 131, 19, 95, 66, 187, 185,87, 236}));await Stop(await Crack(new byte[32]{59, 134, 219, 11, 168, 34, 42, 6, 142, 30,47, 12, 175, 97, 187, 166, 191, 165, 206, 91,56, 92, 35, 91, 63, 232, 2, 235, 246, 41,249, 60}));await Stop(await Crack(new byte[32]{30, 47, 78, 72, 232, 144, 186, 158, 145, 46,78, 42, 66, 78, 48, 177, 201, 84, 194, 246,32, 77, 153, 26, 204, 139, 24, 149, 70, 89,23, 50}));await Stop(await Crack(new byte[32]{47, 110, 238, 143, 41, 255, 113, 160, 229, 92,84, 132, 31, 128, 72, 253, 98, 154, 102, 114,68, 165, 121, 194, 102, 210, 191, 221, 49, 209,210, 215}));await Stop(await Crack(new byte[32]{59, 134, 219, 11, 168, 34, 42, 6, 142, 30,47, 12, 175, 97, 187, 166, 68, 235, 237, 14,9, 156, 105, 253, 49, 93, 204, 138, 86, 162,159, 183}));await Stop(await Crack(new byte[32]{59, 134, 219, 11, 168, 34, 42, 6, 142, 30,47, 12, 175, 97, 187, 166, 191, 165, 206, 91,56, 92, 35, 91, 63, 232, 2, 235, 246, 41,249, 60}));await Stop(await Crack(new byte[32]{30, 47, 78, 72, 232, 144, 186, 158, 145, 46,78, 42, 66, 78, 48, 177, 201, 84, 194, 246,32, 77, 153, 26, 204, 139, 24, 149, 70, 89,23, 50}));}await Stop(await Crack(new byte[32]{164, 53, 148, 8, 250, 208, 160, 70, 126, 59,160, 104, 222, 18, 194, 130, 172, 224, 232, 3,9, 43, 214, 128, 13, 213, 251, 91, 231, 216,221, 212}));long[] array2 = s;long num = s[1];array2[32] = num ^ await Stop(await Crack(new byte[16]{132, 17, 89, 19, 158, 87, 26, 91, 138, 184,20, 203, 22, 142, 33, 67}));array2 = s;num = s[2];array2[33] = num ^ await Stop(await Crack(new byte[16]{98, 124, 165, 114, 4, 73, 122, 239, 35, 224,182, 58, 230, 239, 169, 171}));array2 = s;num = s[3];array2[34] = num ^ await Stop(await Crack(new byte[16]{41, 105, 145, 250, 243, 41, 66, 60, 57, 250,209, 67, 192, 42, 111, 95}));array2 = s;num = s[4];array2[35] = num ^ await Stop(await Crack(new byte[16]{46, 125, 65, 197, 84, 64, 181, 17, 52, 236,114, 213, 42, 180, 217, 142}));}if (rr == 22){await blient.GetStream().WriteAsync(new byte[15]{0, 0, 0, 15, 0, 0, 0, 1, 0, 1,10, 0, 0, 0, 0}, default(CancellationToken));p.Kill();_ = new byte[16];for (int num2 = 0; num2 < 4; num2++){byte[] bytes = BitConverter.GetBytes((uint)s[32 + num2]);Array.Reverse(bytes);Console.Write(BitConverter.ToString(bytes).Replace("-", ""));}Environment.Exit(0);}await Breck();await client.GetStream().WriteAsync(BitConverter.GetBytes(0), default(CancellationToken));while (await Hack()){}bool flag = true;while (flag){flag = await Horror();}rr++;}}

很明显，要部署 Docker，环境里至少还需要一个 python 脚本，Where is it?

DIE 已经有提示：

此处 DIE 识别不完全正确。识别为 JAR 的实际依然是 ZIP。

DIE 内置的提取器，选择 Binary 模式，“扫描” 并 “转储全部”：

改 jar 后缀为 zip，解压体积最大的那个 zip（polyencrypt.dll.9200_2b8c.zip），得到完整文件：

1
2
3
4
5
6
7
8
9
10
11
d----          2025/10/25    22:09                META-INF-a---            2024/5/6     4:18            338 Curse.class-a---            2024/5/6     4:18           2048 Curse.dll-a---            2024/5/6     4:18            736 Hack.class-a---           2024/5/11    16:53          48524 polyencrypt.dll-a---           2024/5/11    16:53            242 polyencrypt.runtimeconfig.json-a---            2024/5/6     4:18           1337 remote_pdb_LICENSE.txt-a---            2024/5/6     4:18           3985 remote_pdb.py-a---          2025/10/10    22:55             69 run.sh-a---            2024/5/6     4:18           8823 Saw.class-a---            2024/5/6     4:18           5025 saw.py
]]> https://blog.watermelonabc.top/p/6375919/ 2025-10-25T08:54:19.000Z 面向蒟蒻 REer 的赛题复现 2025 强网杯 S9 Reverse 复现 2026-08-13T03:25:03.000Z Watermelonabc 封面来自 José Luis Botello Sánchez，Unsplash License

主包从铜盘搬到旗山后，在快递这一块也是狠狠赤了依托石 😋

看着 淘宝 / PDD 上十几个虎视眈眈的包裹 “四散” 在校内外各处，再高傲的福 🧊 也不禁弯下了脊梁骨，这也是外迁之世的一个侧面……

Anyway，抽象话就不继续说了，下面就和主包一起看看怎么才能在 FZU 顺利取到快递吧 😊

Warning

主包只住过铜盘和旗山校区喵，其他校区我不知道喵。

Tip

主包去过的所有快递点的货架都难找，容易绕晕 😵
铜盘可以在菜鸟上用 “实景找包裹”，会尽量标注各个包裹的货架位置。但是驿站有时会调整货架，而地图是不会更新的，所以大概还是得在驿站内绕来绕去。
旗山我还没有尝试过，但是比铜盘更史，快递中心申通、极兔那边有些货架更是梦到哪里排哪里（
旗山的快递站会尽量按序号排列快递，这一点比铜盘要好，找到货架就能快速地找到快递。但毕竟我们不是按序号先后来取快递的，而且工作人员有时也不会那么尽责，因此也存在序号混乱的情况。

铜盘校区

此部分信息可能过期

铜盘的所有快递集中在操场旁边的菜鸟驿站中，你在校易班绘制的地图上就能看到。校园地图参见校园地图 - FZU Wiki

由于是菜鸟驿站，所以它的收件码体系和淘宝强关联。想查询取件码需要通过淘宝或菜鸟 APP 输入快递单号才可以。

我记得是有 7 台出库机的。大部分快递通过出口的 6 台出库机出库，需要淘宝身份码；还有一些 PDD 快递（如邮政）有单独的 1 台出库机，不需要身份码。

Warning

在主包刚来铜盘的一段时间内（2024 年），驿站还支持菜鸟身份码，但一次 “升级” 之后就不支持了，必须用淘宝身份码。
其实不扫身份码直接拿也没事，没人追究的吧

快递集中一处的优势是方便取件。出库另说哈（ 一大群人挤在一个闷热狭小的空间中实在不是什么好的体验。

信件根据小红书的说法，在生活区 6 号楼下的物业中心或者门口文创店。

旗山校区

最赤石的来哩 🤣

旗山校区虽然有一个名义上的 “快递服务中心”，但实际上这个 “中心” 实在要打个问号。也许是 “天下大势，分久必合，合久必分”，好几个快递企业选择将它们的服务点搬出快递中心，这就苦了我们这些网购大学生。

还真是 “分久必合，合久必分”，有 ldx 说好几年前快递也是东一个西一个的，后面建了快递中心才集聚起来，现在又分出去了。

旗山有 4 个主要的快递集散点：快递中心、生活一区 9 号楼邮政、福大学生街驿站（兔喜生活，或者显示在周麻婆后）和筑安商业中心的多多驿站。由于快递点多且散，建议旗山的同学买一辆电动车貌似 25 级往后的同学原则上就没有电动车骑了……

德邦快递在福大没有固定的服务点，需要同学自己去生活区大门和快递员取件。一般来讲，快递员会在下午 4:30 ~ 5:00 内到生活区门口，到了会电话通知。就我的体验来讲，如果你下午有第二节大课，那么你有概率是领不到了，因为快递员可能下班了。有时我下课骑车回来还能看到德邦快递员在大门口。

开学的一段时间，由于快递较多，德邦可能会在生活区门口设置临时集散点。

FZU 旗山校区快递点一图概览

底图来自福州大学校园地图服务系统，2026/08/14标注，使用GIMP
底图来自福州大学校园地图服务系统，2026/08/14 标注，使用 GIMP

快递中心

位于生活三区 35 号楼后。从两个生活区大门左转沿路直走均可到达。平日营业时间为 9:00 ~ 19:00。有时 19:00 后快递站仍会开放，但此时快递公司人员基本下班，你只能使用自助机器进行取件。

快递中心驻扎顺丰、申通、极兔、圆通、京东、菜鸟（天猫超市）。不同快递企业（甚至同一企业的不同货架区域）有自己的出库机，一般来说你在哪个区域就用哪里的出库机。有些出库机会标明适用于哪些号码的货架。

现在快递中心的货架是比较混乱的，特别是申通的快递，有些比较大的货架号 (238+) 就会安排在靠近进货口的位置

所有出库机都需要扫描快递单条码。一些出库机需要同时使用身份码，请根据机身说明打开对应软件的身份码（淘宝 / 拼多多）。注意是根据你使用的出库机为依据选择身份码，大部分使用 PDD 身份码，申通的少量机器使用淘宝身份码。

如何获取身份码

统一方法：出库机上会贴二维码，用对应 APP 扫描即可。

淘宝：首页 > 搜索框下的 “菜鸟驿站” > 底栏 “身份码”（不要使用菜鸟 APP！）
拼多多：（如果有待取包裹）“聊天” > “物流助手” > “查快递” > “取快递” > 顶部 “查看身份码”

寒暑假期间误送到学校的滞留件，之后会转移到出入库口的一个棚子里（入口右转到尽头），会有物流通知的。

生活一区 9 号楼邮政

位于一区京元食堂背后宿舍楼下沿街铺面。顾名思义，邮政的快递都送到这里来。信件自然也在此处寄收。平日营业时间为 9:00 ~ 19:00

门口有 1 台出库机，需要拼多多身份码。

信件请询问工作人员。明信片可能放在出库机旁边，或者空货架上。

福大学生街驿站

位于糖巢零食旁边，中通驻扎。平日营业时间为 10:00 ~ 17:00

2~3 台出库机，需要拼多多身份码。

筑安商业中心的多多驿站

韵达驻扎。从四区门口对面的入口直走即可看到驿站。但是四区后门仅限行人通过，骑车建议从旁边高架桥旁边的道路通过（上面所示蓝色路线，红木一条街）

入口处有一台出库机，不需要身份码。

]]> https://blog.watermelonabc.top/p/3107cb4a/ 2025-09-11T15:38:39.000Z 哎我艹这旗山校区怎么这么坏啊 QAQ 你如何在 FZU 取到快递 2026-08-14T05:19:14.000Z Watermelonabc 数理逻辑

命题

非真即假的封闭陈述句就是命题 (proposition)。一个命题的真值 (truth value) 表示命题的真假情况，本课程定义 1 为真，0 为假。

一个无法被分解的命题称为简单命题或原子命题 (atomic proposition)，简单命题通过联结词 (logical connectives) 联结得到复合命题 (compound propositions)

命题的判断

一个命题需要满足以下两个条件：1）是陈述句；2）非真即假，即仅有唯一真值。
条件 1）比较好达成，但要注意数学表达式（如 1<21 < 2）也是一种陈述句。
条件 2）可能就有点难了。我们只看它能否理论上判断有唯一真值，不需要确定它是真是假。例如 “我喝了 114514 杯红茶”，我们现在可能无法确定到底是高手在民间还是吹牛批，但它有唯一真值！而 x+1>2x + 1 > 2 就不是一个命题，因为它有时真有时假。而 “这句话是假的” 同样不是一个命题，因为它同时是真和假。
和 ChatGPT 交流后发现，命题还有一个特征：陈述的主语必须无歧义。换句话说，主语不能是指代模糊的 xx、"He" 等。如果你需要上下文、需要自圆其说，那么他就不是一个命题。例如 “它是整数”，谁是整数？它是 1，是 “笔记本”，还是 “福州大学”？我们无法判断。这个特征需要灵活运用，因为在一些语境下，可能默认代词有指称。

直到现在我们讲的还是简单命题。对于复合语句呢？我们只需要其分解为简单陈述句，然后分别判断即可。只有所有简单陈述句都是命题，复合语句才是命题。
例如 “如果明天不下雨，我们就去公园”，这句话可以分为 “明天下雨” 和 “我们去公园”，这两个都是命题，所以一整句话也是一个命题。

语句是否为命题，和语句的语意合理情况无关。例如 “北京是首都当且仅当 2 + 2 = 4”，虽然荒谬但确实是命题。

我们习惯上用字母 pp, qq, rr, ss, ... 来表示命题变量 (propositional variables)，即表示命题的变量。

我们有 5 个联结词：

否定 (Negation)

令 pp 为一命题，则 pp 的否定记作 ¬p\neg p ，指 “不是 pp 所指的情形”，pp 的否定与 pp 的真值相反。(NOT)

否定运算符的记号并没有统一的标准，只是 " ¬\neg " 比较常用而已

Warning

抽取简单命题时，不可抽取否定语句。例如上面的 “如果明天不下雨”，抽取的就是 “明天下雨” 而不是 “明天不下雨”。

命题的否定也可以看作否定运算符 (negation operator) 作用在命题上的结果。

合取 (Conjunction)

令 pp, qq 为命题，pp, qq 的合取即命题 “pp 并且 qq”，记作 “p∧qp\land q”，当 pp, qq 皆为真命题时，p∧qp\land q 为真，否则为假。(AND)

如果一个命题为假，那么整个合取式固定为假；如果一个命题为真，那么整个合取式的真值取决于另一个命题。

析取 (Disjunction)

令 pp, qq 为命题，pp, qq 的析取即命题 “pp 或 qq”，记作 “p∨qp\lor q”，当 pp, qq 皆为假命题时，p∨qp \lor q 为假, 否则为真。(OR)

如果一个命题为真，那么整个析取式固定为真；如果一个命题为假，那么整个析取式的真值取决于另一个命题。

异或 (Exclusive or)

令 pp, qq 为命题，pp, qq 的异或（记作 p⊕qp\oplus q）是这样的一个命题：当 pp, qq 中恰好有一个为真时命题为真，否则为假。

换句话说，命题 pp, qq 的真值相同则为假 (0) ，真值不同则为真 (1)。

ppqqp⊕qp\oplus q
TTF
TFT
FTT
FFF

联想到异或运算，其实是同一个概念，二进制位相同则为 0，二进制位不同则为 1。

和析取相比，异或排除了 pp、qq 同时成立的情况，因此也称 “排斥或”。与之相对的，“析取” 也称 “相容或”

蕴涵 (Implication)

或称条件语句 (Conditional Statement)。

令 pp, qq 为命题，蕴含 p→qp\rightarrow q 是命题 “如果 pp，则 qq”，当 pp 为真而 qq 为假时，条件语句 p→qp\rightarrow q 为假，否则为真。在蕴涵中，pp 称为假设（hypothesis，或前件 antecedent，前提 premise），qq 称为结论（conclusion，或后件 consequence）。

ppqqp→qp\rightarrow q
TTT
TFF
FTT
FFT
Note

为什么 pp 为假时，qq 不论真假，命题一定为真？
如果 qq 为假，不必多说，确实符合这个命题。
如果 qq 为真，命题没有规定 pp 为假的情况，并且仍然在一定程度上符合命题。
因此，如果 pp 为假，我们不需要使用 p→qp\rightarrow q。既然我们不会使用它，我们可以将其真值定义为任何我们喜欢的东西，但也要符合其他的联结词。

蕴含式中 pp 和 qq 的顺序很重要。如果交换 pp 和 qq，会产生一个不同的命题。

常用的自然语言描述：

  • 只要 pp，就 qq
  • 因为 pp，才 qq
  • pp 仅当 qq
  • 只有 qq 才 pp
  • 除非 qq 才 pp
  • 除非 qq，否则非 pp（¬q→¬p\neg q \rightarrow \neg p，假言易位）

等价 (Biconditional)

如果 p→qp\rightarrow q 且 q→pq\rightarrow p，则称 pp 和 qq 等价，即 p↔qp\leftrightarrow q，也叫双条件。等价式中的两个命题可以交换。

命题公式

]]> https://blog.watermelonabc.top/p/d73ba365/ 2025-09-09T13:06:00.000Z 正如其名，“离散” 2025 福州大学离散数学笔记 2026-08-04T09:53:11.000Z Watermelonabc
破防了QAQ
破防了 QAQ

（永恒的经典：【考试周破防】4K 高清重制版）

沃日，90 分满绩，翁老师我爱你 😚

教学内容与考核标准

内容：基本知识、逻辑运算、逻辑函数化简、逻辑门电路、组合逻辑电路、触发器、时序逻辑电路、中规模逻辑电路

理论 40 学时 + 实验 36 学时

考核方式：雨课堂考勤 + 课程中心作业 + 期末考试

期末考试题目分布

  • 单选题 1 * 10 = 10 分
  • 填空题 2 * 10 = 20 分
  • 化简题 3 * 5 = 15 分
  • 分析题 3 题 25 分
  • 设计题 3 题 30 分

数制

常用数制：十进制 (Decimal)、二进制 (Binary)、十六进制 (Hexadecimal)、八进制 (Octal)

数字的表示法：

(N)R=(KnKn−1...K1K0.K−1K−2...)R=Kn×Rn+Kn−1×Rn−1+...+K1×R1+K0×R0+K−1×R−1+K−2×R−2+...(N)_R = (K_nK_{n-1}...K_{1}K_{0}.K_{-1}K_{-2}...)_R = K_n × R^{n} + K_{n-1} × R^{n-1} + ... + K_{1} × R^{1} + K_{0} × R^{0} + K_{-1} × R^{-1} + K{-2} × R{-2} + ...

第二个等号后面的表示法称为 “按权展开法”。注意十六进制数的按权展开需要将字母换成对应的十进制数

数制转换

按权展开法会将数字转换成十进制的，因此其他进制转十进制非常简单。下面介绍其他进制转换。

Warning

本部分在考试中仅作选择或填空题。选择自己可以熟练掌握的技巧，不需要考虑方法是否学过。

Tip

一些计算器不支持小数的进制转换，你可能需要在线寻找，例如二进制转换或 BINARY2HEX；或者使用更高级的计算器，如 Qalculate!

1. 十进制转二进制

正规方法：整数除 2 取余；小数乘 2 取整。

Tip

除 2 取余，除到商为 0 为止
乘 2 取整，乘到积为 1 或精度的后一位为止。期间，如果整数部分有进位，舍去进位。当得到精度的后一位（如要求 4 位小数，则进行 5 次乘法）时，如果整数部分为 0，则不进位；如果整数部分为 1，则进位。

其他方法：按位展开，逐次递减

image-20250908170136476
Tip

由于其他进制转十进制很容易，因此如果想降低知识点负担，对于其他进制转二进制，只需要先转成十进制，然后再转成二进制即可。

2. 二进制转八进制

整数从右到左、小数从左到右，将数字按三位三位划分（三位二进制数最多表示到 7），不足三位的用 0 补齐。然后分别计算三位数字对应的八进制数，连接起来即可。

(11100101.01)2=(011)2(100)2(101)2.(010)2=(3)8(4)8(5)8.(2)8=(345.2)8(11100101.01)_2 = (011)_2(100)_2(101)_2.(010)_2=(3)_{8}(4)_{8}(5)_{8}.(2)_{8}=(345.2)_8

八转二是逆过程，每一个八进制数用三位二进制数表示即可。

3. 二进制转十六进制

整数从右到左、小数从左到右，将数字按四位四位划分（四位二进制数最多表示到 F，即 15），不足四位的用 0 补齐。然后分别计算四位数字对应的十六进制数，连接起来即可。

(11100101.01)2=(1110)2(0101)2.(0100)2=(E)16(5)16.(8)16=(E5.8)16(11100101.01)_2 = (1110)_2(0101)_2.(0100)_2=(\text{E})_{16}(5)_{16}.(8)_{16} = (\text{E}5.8)_{16}

十六转二是逆过程，每一个十六进制数用四位二进制数表示即可。

有符号数表达

对于有符号数，数字的最高位（最左端）是符号位，用 “0” 表示正数，用 “1” 表示负数。符号位之后的位才表示数值。例如 01010=+1010=+1001010 = +1010 = +10

Warning

符号位只有一位，如果计算时发现符号位出现进位现象，舍弃进位。

通常将用 “+”、“-” 表示正、负的二进制数称为符号数的真值，而把将符号和数值一起编码表示的二进制数称为机器数或机器码。

1. 原码

数值位和无符号数一样，再加上符号位，就得到了原码。整数的符号位加在数值位最高位的左端，小数的符号位在整数部分上。

如 +1101+1101 的原码是 0110101101，−1101-1101 的原码是 1110111101；+0.1011+0.1011 的原码是 0.10110.1011，−0.1011-0.1011 的原码是 1.10111.1011。

原码虽然表示简单，但计算较为不便。例如，9+(−3)=69+(-3) = 6，但在原码表示中，9+(−3)=(01001)2+(10011)2=(11100)2=−129+(-3)=(01001)_2+(10011)_2=(11100)_2=-12，很明显是错误的！

2. 反码

相比原码，正数反码不变，而负数反码的数值位按位取反。如 +1101+1101 的反码是 0110101101，而 −1101-1101 的反码是 1001010010。

反码是解决原码带来的计算问题的一个过渡方案。这句话的意思是：它仍然有问题。比如反码仍然算不对上面的 9+(−3)9+(-3)。

原码和反码还会多出来一个 “正负 0” 问题：“正 0” 表示为 0000 00000000\ 0000，而 “负 0” 表示为 1000 00001000\ 0000

3. 补码

相比原码，正数补码不变，而负数补码的数值位按位取反后还要对最低位加 1。如 −1101-1101 的补码是 1(0010+1)=100111(0010+1)=10011，−0.1101-0.1101 的补码是 1.(0010+1)=1.00111.(0010+1)=1.0011

Note

也可以这么看：对于负数，数值位从右到左（即最低位）数直到遇到第一个 1，这些位不变，之后的位取反，即 −1101=1(110) 反 1=10011-1101=1 (110)_{\text {反}} 1=10011，−10110=1(101) 反 10=101010-10110=1 (101)_{\text {反}} 10=101010

补码解决了原码和反码的计算问题，这次就算对了 9+(−3)9+(-3) 。

补码也解决了 “正负 0” 问题：对于 8 位二进制数，“负 0” 的补码仍然是 0000 00000000\ 0000，因为第 9 位因溢出而舍弃。

计算机中的运算均采用补码形式。

码制

如果说数制表示数字，那么码制就表示信息。

BCD 码

BCD 码全称二 - 十进制 (Binary Coded Decimal) 码，通过四位二进制数对一位十进制数编码以传递信息。例如，对于十进制的 1212，我们不是直接转换成 11001100，而是对 11 和 22 分别进行 BCD 编码。

Note

由于一位十进制数仅由 0 ~ 9 表示，但四位二进制数可以表示 24=162^4=16 个十进制数，于是每种 BCD 码仅取出其中 10 种作为有效编码，其余 6 种是无效编码（称为 “冗余码”）。

BCD 码有何好处？首先是转换方便。计算机只需要每四位二进制数按照映射表转换成一位十进制数，然后拼接即可得到完整的十进制数字，这比整体按权展开要容易得多。

其次，由于 BCD 按位编码，所以它可以精确表示十进制小数。如 0.10.1 在一种 BCD 码下表示为 0000.00010000.0001，但如果乘 2 取整就会得到一个无限循环小数 0.000110011001100...0.000110011001100...，计算机无法精确表示一个具有无限位的数，于是会出现精度问题。

本课主要学习 8421 码和余 3 码，2421 码仅作了解

1. 8421 码

8421 码是最常用的一种有权码。8421 码到十进制的转换和普通二进制数相同（按权展开），它们表示出来的 0 ~ 9 也完全相同。注意，1010 ~ 1111 是冗余码。

Tip

8421 码表示的二进制数字和其对应十进制数字字符的 ASCII 码的低四位相同，因此使用 8421 码可以简化 BCD 码与对应 ASCII 码的转换。

8421 码按位编码，如：

(258)10=(0010 0101 1000)8421 码 (258)_{10}=(0010\ 0101\ 1000)_{\text {8421 码}}

(0001 0001 0100 0101)8421=(1145)10(0001\ 0001\ 0100\ 0101)_{\text{8421}}=(1145)_{10}

8421 码之间的计算：如果某一位的和 ≤ 9，且没有产生进位，无需调整；如果某一位的和 > 9，或者产生了进位（虽然和 ≤ 9 但向高位进了一位），则必须进行加 6 调整（即加上 01100110）。和之后的余 3 码相比，8421 码的调整规则就多了一点。

17+18=0001 0111+0001 1000=0010 1111(进位 + 低四位和 > 9, 需要调整) 17 + 18=0001\ 0111 + 0001\ 1000=0010\ 1111\text {(进位 + 低四位和 > 9, 需要调整)}

调整：0010 1111+0000 0110=(0011 0101)8421 码 =35\text {调整：} 0010\ 1111+ 0000\ 0110=(0011\ 0101)_{\text {8421 码}}=35

2. 2421 码

2421 码也是一种有权码，它的权是 2、4、2、1。0101 ~ 1010 是冗余码。

2421 码是一种对 9 的自补代码，可以给运算带来方便。对 9 自补意味着一个数的 2421 码只要自身按位取反，便可以得到该数对 9 的补数的 2421 码。

(258)10=(0010 1011 1110)2421 码 (258)_{10}=(0010\ 1011\ 1110)_{\text {2421 码}}

(0001 0001 0100 1011)2421 码 =(1145)2421 码 (0001\ 0001\ 0100\ 1011)_{\text {2421 码}}=(1145)_{\text {2421 码}}

(4)10=(0100)2421 码→按位取反 (1011)2421 码 =(5)10(4)_{10}=(0100)_{\text {2421 码}}\xrightarrow {\text {按位取反}}(1011)_{\text {2421 码}}=(5)_{10}

3. 余 3 码

余 3 码是 8421 码加上 0011 形成的一种无权码，因其比 8421 码多 3 而得名，如 (5)10=(0101)8421 码 +(0011)2=(1000) 余 3 码 (5)_{10} = (0101)_{\text {8421 码}}+(0011)_{2}=(1000)_{\text {余 3 码}}。0000、0001、0010、1101、1110、1111 是冗余码。

余 3 码同样是一种对 9 的自补代码。两个余 3 码相加的运算规则是：如果有进位，结果每四位加 3；如果没有进位，结果每四位减 3。注意将结果转换回十进制时使用的是余 3 码。

余 3 码同样按位编码。

(256)10=((0010)8421+(0011)2  (0101)8421+(0011)2  (0110)8421+(0011)2) 余 3 码 =(0101 1000 1001) 余 3 码 (256)_{10}=((0010)_{8421}+(0011)_2\ \ (0101)_{8421}+(0011)_{2}\ \ (0110)_{8421}+(0011)_{2})_{\text {余 3 码}}=(0101\ 1000\ 1001)_{\text {余 3 码}}

(1000 1001 1001 1011) 余 3 码 =(5668)10(1000\ 1001\ 1001\ 1011)_{\text {余 3 码}}=(5668)_{10}

计算：

13+67=0100 0110+1001 1010=1110 0000(进位，需要调整) 13+67=0100\ 0110+1001\ 1010=1110\ 0000\text {(进位，需要调整)}

调整：1110 0000+0011 0011=(1011 0011) 余 3 码 =80\text {调整：} 1110\ 0000 + 0011\ 0011 = (1011\ 0011)_{\text {余 3 码}} = 80

几种 BCD 码的映射表：

十进制数字8421 码2421 码余 3 码
0000000000011
1000100010100
2001000100101
3001100110110
4010001000111
5010110111000
6011011001001
7011111011010
8100011101011
9100111111100
无效码1010 - 11110101 - 10100000 - 0010 和 1101 - 1111

可靠性编码

用于校验 / 纠错，提高信息传输的可靠性。

从 BCD 码转到可靠性编码，中间需要先转到二进制码。例如 (01001000)8421 码 =(110000)2=(101000) 格雷码 (01001000)_{\text {8421 码}}=(110000)_{2}=(101000)_{\text {格雷码}}

由于 8421 码的低四位和二进制码相同，因此在转换小等于 4 位的 8421 码时，可以直接转换成格雷码

格雷码

格雷码的特点：任意两个相邻的数，其格雷码仅有一位不同。可以有效避免多位跳变，提高系统可靠性。

二进制码转格雷码：

设二进制码为 B=Bn−1Bn−2…Bi+1Bi…B1B0，对应格雷码为 G=Gn−1Gn−2…Gi+1Gi…G1G0\text {设二进制码为}\ B = B_{n-1} B_{n-2} … B_{i+1} B_i … B_1B_0\text {，对应格雷码为} G = G_{n-1} G_{n-2} … G_{i+1} G_i … G_1G_0

有：

Gn−1=Bn−1（最高位相同）G_{n-1} = B_{n-1}\text {（最高位相同）}

Gi=Bi+1⊕Bi（其他位为高位二进制与当前位异或）G_i = B_{i+1} ⊕ B_i\text {（其他位为高位二进制与当前位异或）}

格雷码转二进制码：

逆向计算。二进制码的最高位（最左边）与格雷码的最高位相同。将产生的每一位二进制码，与下一位相邻的格雷码异或（舍去进位），作为二进制码的下一位。

即：

Bn−1=Gn−1（最高位相同）B_{n-1} = G_{n-1}\text {（最高位相同）}

Bi=Bi+1⊕GiB_{i} = B_{i+1} ⊕ G_{i}

每位 BiB_{i} 最终可以全部用格雷码表示。

奇偶校验码

奇偶校验码仅校验，不纠错（因为无法判断出错位置），只能检测奇数个 bit 错误。

  • 奇校验

    如果给定一组数据位中 1 的个数是奇数，补一个 bit（0 或 1）在最右方，使得总的 1 的个数是奇数。例：0000001, 补一个 bit 为 0, 得到 00000010。
    校验时，对接收数据（含校验位）逐位相加，对 2 取余。如果余数为 1，则奇校验通过。

  • 偶校验

    如果一组给定数据位中 1 的个数是奇数，补一个 bit（0 或 1）在最右方，使得总的 1 的个数是偶数。例：0000001, 补一个 bit 为 1, 得到 00000011。
    校验时，对接收数据（含校验位）逐位相加，对 2 取余。如果余数为 0，则偶校验通过。

异或的 “不进位加法” 性质和此校验方法相似。

Note

实际上，在数学中，一个二进制数的奇偶性只需要看它的最低位即可。如果最低位为 1，则为奇数；为 0，则为偶数。

reference: 奇偶校验位

逻辑代数基础

逻辑代数是逻辑电路的数学表达。

代数系统概述

逻辑变量以大写字母表示。逻辑变量的取值只有 “0” 和 “1” 两种可能

三大基本逻辑运算：

  • 与 (AND)
    • F=A⋅BF = A\cdot B
    • 对应逻辑电路中的 “或门”
  • 或 (OR)
    • F=A+BF = A+B
    • 对应逻辑电路中的 “与门”
  • 非 (NOT)
    • F=A‾F = \overline{A}
    • 对应逻辑电路中的 “非门”/“反相器”

在一个表达式中，如果既有与运算又有或运算，则按先与后或的规则进行运算。

Note

“与” 也称 “逻辑乘”，只要有一个变量为假 (0)，那么运算结果也为假，和一般乘法相同
“或” 也称 “逻辑加”，只要有一个变量为真 (1)，那么运算结果也为真，和一般加法相似

五大公理：

  1. 交换律

  2. 结合律

  3. 分配律

  • A+(B⋅C)=(A+B)⋅(A+C)A+(B\cdot C) = (A+B)\cdot (A+C)
  • A⋅(B+C)=A⋅B+A⋅CA\cdot (B+C) = A\cdot B + A\cdot C
  1. 0-1 律
  • A+0=AA + 0=A，A⋅0=0A\cdot 0 = 0
  • A+1=1A + 1 = 1，A⋅1=AA\cdot 1 = A
  1. 互补律
  • A+A‾=1A + \overline{A} = 1，A⋅A‾=0A\cdot \overline{A}=0
  • A‾\overline{A} 唯一存在

三种基本逻辑运算可以描述各种逻辑关系，对这些关系使用数学描述，即可得到逻辑函数。

F=f(A1,A2,...,An)F=f{(A_1,A_2,...,A_n)}

逻辑函数的取值同样是 “0” 或 “1”。如果对应于逻辑变量 A1,A2,...,AnA_1,A_2,...,A_n 的任意一组取值，逻辑函数 F1F_1 和 F2F_2 的取值均相等，则 F1=F2F_1 = F_2。

表示逻辑函数的方法，除了上面给出的逻辑表达式之外，还有真值表和卡诺图两种。

基本定理

由五大公理可推出八大定理：

  1. 0-1 律

  2. 重叠律（你，莫的选择）

  • A+A=AA+A=A，A⋅A=AA\cdot A =A
  1. 吸收律
  • A+A⋅B=AA+A\cdot B=A，A⋅(A+B)=AA\cdot (A+B)=A
  1. 消除律
  • A+A‾⋅B=A+BA+\overline{A}\cdot B = A + B，A⋅(A‾+B)=A⋅BA\cdot (\overline{A}+B)=A\cdot B
  1. 对合律（双重否定表肯定）
  • A‾‾=A\overline{\overline{A}}=A
  1. 互补律
  • A+B‾=A‾⋅B‾\overline{A+B}=\overline{A}\cdot \overline{B}，A⋅B‾=A‾+B‾\overline{A\cdot B} = \overline{A} + \overline{B}
  1. 并项律
  • A⋅B+A⋅B‾=AA\cdot B+A\cdot \overline{B} = A，(A+B)⋅(A+B‾)=A(A+B)\cdot (A+\overline{B})=A
  1. 包含律
  • A⋅B+A‾⋅C+B⋅C=A⋅B+A‾⋅CA\cdot B+\overline{A}\cdot C+B\cdot C=A\cdot B+\overline{A}\cdot C
  • (A+B)⋅(A‾+C)⋅(B+C)=(A+B)⋅(A‾+C)(A+B)\cdot (\overline{A}+C)\cdot (B+C)=(A+B)\cdot (\overline{A}+C)

重要规则

三个重要规则：

  1. 代入规则

A(B+C)=AB+ACA(B+C)=AB+AC，令 C=C+DC=C+D，则 A[B+(C+D)]=AB+A(C+D)A[B+(C+D)]=AB+A(C+D)

  1. 反演规则（德・摩根定理）

一切运算 “反过来”：“⋅\cdot” 和 “++” 互换，“0” 和 “1” 互换，原反变量互换，保持运算顺序不变（如原式中的乘法优先于加法，反演后从乘法得到的加法仍然优先于从加法得到的乘法）。

复合逻辑的反演

对于复合逻辑，有两种做法：

  • 不管复合逻辑，只做下面的基本运算。例如，ABC‾\overline{ABC} 的反演式是 A‾+B‾+C‾‾\overline{\overline{A}+\overline{B}+\overline{C}}。如果需要化简，那么对上面的式子用互补律即可。例如，接上式，A‾+B‾+C‾‾=A‾‾B‾‾C‾‾=ABC\overline{\overline{A}+\overline{B}+\overline{C}} = \overline{\overline{A}}\overline{\overline{B}}\overline{\overline{C}}=ABC
  • 不管基本运算，直接将复合逻辑下的基本运算视为整体。例如，ABC‾=ABC‾‾=ABC\overline{ABC}=\overline{\overline{ABC}}=ABC，可以直接得到最简

F=A‾+B‾⋅(C+D‾E)→F‾=A⋅[B+C‾⋅(D+E‾)]F=\overline{A}+\overline{B}\cdot (C+\overline{D}E) \rightarrow \overline{F}=A\cdot [B+\overline{C}\cdot (D+\overline{E})]

可以求反函数。

  1. 对偶规则

与反演规则相比，对偶规则不需要原反变量的互换。得到的是函数的对偶式 F′F'

F=A‾+B‾⋅(C+D‾E)→F′=A‾⋅[B‾+C⋅(D‾+E)]F=\overline{A}+\overline{B}\cdot (C+\overline{D}E) \rightarrow F'=\overline{A}\cdot [\overline{B}+C\cdot (\overline{D}+E)]

如果 F=F′F=F'，则 FF 为自对偶函数。

如果 F=GF=G，则 F′=G′F'=G'。

复合逻辑

  1. 与非逻辑

F=A⋅B⋅C⋅...‾F=\overline{A\cdot B\cdot C \cdot ...}

与非逻辑可以检测全 1 序列

使用与非逻辑可以实现与、或、非三种基本运算

  • 与：F=A⋅B‾⋅1‾=A⋅B‾‾+0=A⋅BF=\overline{\overline{A\cdot B}\cdot 1}=\overline{\overline{A\cdot B}}+0=A\cdot B

  • 或：F=A⋅1‾⋅B⋅1‾‾=A⋅1‾‾+B⋅1‾‾=A+BF=\overline{\overline{A\cdot 1}\cdot\overline{B\cdot 1}}=\overline{\overline{A\cdot 1}}+\overline{\overline{B\cdot 1}}=A+ B

  • 非：F=A⋅1‾=A‾+0=A‾F=\overline{A\cdot 1}=\overline{A} + 0=\overline{A}（未使用的输入端全部挂高接 1）

  1. 或非逻辑

F=A+B+C+...‾F=\overline{A+B+C+...}

或非逻辑可以检测全 0 序列

使用或非逻辑同样可以实现与、或、非三种基本运算

  • 与：F=A+0‾+B+0‾‾=A+0‾‾⋅B+0‾‾=A+BF=\overline{\overline{A + 0} + \overline{B + 0}}=\overline{\overline{A + 0}}\cdot\overline{\overline{B+0}}=A + B

  • 或：F=A+B‾+0‾=A+B‾‾⋅1=A+BF=\overline{\overline{A + B}+ 0}=\overline{\overline{A+B}}\cdot 1=A+B

  • 非：F=A+0‾=A‾⋅1=A‾F=\overline{A + 0}=\overline{A}\cdot 1=\overline{A}（未使用的输入端全部挂低接 0）

  1. 与或非逻辑

F=AB+CD+...‾F=\overline{AB+CD+...}

使用与或非逻辑也可以实现与、或、非三种基本运算，但实际应用中成本较高，因此与或非逻辑更多用于实现与化简逻辑函数。

  1. 异或逻辑

F=A⊕B=A‾B+AB‾F=A⊕B=\overline{A}B+A\overline{B}

相同为 0，不同为 1。异或可以检测二进制数据中 1 个数的奇偶性

快速计算方法：异或是 “不进位加法”。例如 1⊕0⊕1=1+0+1=(1)0=0（舍去进位）1⊕0⊕1=1+0+1=(1) 0=0\text {（舍去进位）}

  1. 同或逻辑（异或非）

F=A⊙B=A‾B‾+ABF=A⊙B=\overline{A}\overline{B}+AB

相同为 1，不同为 0。同或可以按位检测二进制是否相等

同或和异或既互为相反，又互为对偶。由于同或可以由异或取反得到，因此实践中通常用异或实现同或。

逻辑函数表达式

基本形式

  • 与 - 或表达式（积之和）

例如：F=A‾B+AB‾C+CF=\overline{A}B+A\overline{B}C+C

  • 或 - 与表达式（和之积）

例如：F=(A‾+B)(A+B‾+C)DF=(\overline{A}+B)(A+\overline{B}+C)D

混合表达式是 “两不像”，例如 F=(AB+C‾)(A+B‾C)+DF=(AB+\overline{C})(A+\overline{B}C)+D 既不属于与 - 或表达式，也不属于或 - 与表达式

逻辑函数的基本形式是不唯一的。

最小项和最大项

  • 最小项

包含所有 nn 个变量的与项，共有 2n2^n 种组合。每个变量以原变量或反变量形式出现且仅出现一次，在 2n2^n 种变量组合中，每个最小项仅在一种组合下为 1，其余均为 0

相同变量构成的不同最小项的与和必定为 0；全部最小项的或和必定为 1。

  • 最大项

包含所有 nn 个变量的或项，也有 2n2^n 种组合。每个变量以原变量或反变量形式出现且仅出现一次，在 2n2^n 种变量组合中，每个最大项仅在一种组合下为 0，其余均为 1

相同变量构成的不同最大项的或和必定为 1。

相同变量构成的最大项 MiM_i 和最小项 mim_i 互补，即 Mi=mi‾M_i=\overline{m_i}。

对于相同变量，若用最小项列表表示为 ∑m(Sm)\sum m(S_m)，那么它的最大项列表 ∏M(⋯ )\prod M(\cdots) 中的下标，恰好是全体下标中没出现在最小项列表里的那些，即 ∑i∈Smmi=∏j∉SmMj\sum_{i \in S_m} m_i = \prod_{j \notin S_m} M_j

最小项和最大项的序号按照二进制转换成十进制，注意最小项中原变量为 1，而最大项中反变量为 1。例如，最小项 ABC‾DAB\overline{C}D 对应的二进制位是 11011101，对应 m13m_{13}；最大项 A+B+C‾+DA+B+\overline{C}+D 对应的二进制位是 00100010，对应 M2M_{2}

如果两个最小/大项之间只有一项的原反性不同，则这两个最小/大项在逻辑上相邻。例如 ABAB 和 A‾B\overline{A}B 逻辑相邻，而 ABAB 和 A‾B‾\overline{A}\overline{B} 在逻辑上不相邻。

标准形式

用 mim_i 或 MiM_i 替代变量。

  • 标准与 - 或（最小项）

F(A,B,C)=A‾⋅B‾C+A‾BC‾+AB‾⋅C‾+ABC=m1+m2+m4+m7=∑m(1,2,4,7)F(A,B,C)=\overline{A}\cdot\overline{B}C+\overline{A}B\overline{C}+A\overline{B}\cdot\overline{C}+ABC\\=m_1+m_2+m_4+m_7\\=\sum{m(1,2,4,7)}

  • 标准或 - 与（最大项）

F(A,B,C)=(A+B+C‾)(A‾+B+C‾)(A‾+B‾+C‾)=M1+M5+M7=∏M(1,5,7)F(A,B,C)=(A+B+\overline{C})(\overline{A}+B+\overline{C})(\overline{A}+\overline{B}+\overline{C})\\=M_1+M_5+M_7\\=\prod{M(1,5,7)}

转化为标准形式

  • 代数转换法

第一步：转换成与 - 或表达式 / 或 - 与表达式
第二步：补项，将非最小/大项的项扩展成最小/大项形式。与 - 或表达式用 A+A‾=1A+\overline{A}=1 补项；或 - 与表达式用 A⋅A‾=0A\cdot \overline{A}=0 补项

  • 真值表转换法

列真值表，输出为 1 对应最小项，输出为 0 对应最大项

表达式化简

目标：项数最少，每一项中的变量也最少（和标准表达式不太一样，标准表达式每一项的变量都是全的）

  1. 代数化简法

化简与 - 或表达式常用定理：并项律、吸收律、消去律，参见基本定理

化简或 - 与表达式：

Ⅰ 求 FF 的对偶式 F′F'（加变乘，乘变加）
Ⅱ 化简 F′F'（此时 F′F' 又变成与 - 或那一套了）
Ⅲ 求化简后的 F′F' 的对偶式，即为 FF 的最简或 - 与表达式

  1. 卡诺图化简法

卡诺图是一种图形化的逻辑函数化简方法，通过格雷码排列（00 -> 01 -> 11 -> 10）的方式将逻辑相邻（上下、左右、首尾相接）的最小项放在物理相邻的位置。由于当变量大于 5 时难以构造，故一般最多考到 4 变量。

如何填写卡诺图？其实应当以格子对应的最小项序号为准。如果存在对应的最小项，则在对应格子填上 1。

设计过程中还会遇到无关项 d，这些无关项可 1 可 0。

然后画卡诺圈。画的时候需要遵循以下规则：

  • 所有的 1 都需要被至少一个卡诺圈圈起
  • 圈的个数尽量少，面积尽量大，但面积必须是 2k2^k（1、2、4、8、16）
  • 卡诺圈可以 “头尾相接”，即最后一列/行的 1 可以和第一列/行的 1 圈在一起
卡诺图画法示例，注意我们写的时候 AB 和 CD 要换过来
卡诺图画法示例，注意我们写的时候 AB 和 CD 要换过来
示例不够？

卡诺图 (K-Map) 化简工具 提供了一个在线化简工具。你不仅可以得到化简后的表达式，还可以关联其对应的卡诺圈画法、真值表、最小 / 大项 以及非国标的门电路图

从卡诺圈得到最小项：在一个卡诺圈内，如果一个变量的值始终为 1，则以原变量形式出现在最小项中；如果始终为 0，则以反变量形式出现；如果既有 1 也有 0，则不出现。

集成门电路

电平

逻辑值 0 和 1 在数字电路中体现就是电平。电平分为高电平和低电平。一般来讲，高电平对应 “1”，低电平对应 “0”。

正逻辑和负逻辑

正逻辑：高电平对应 “1”，低电平对应 “0”，现代的大部分接口使用正逻辑。
负逻辑：高电平对应 “0”，低电平对应 “1”，仅用于早期或特殊接口。

高低电平之间的差值越大，逻辑值 “1” 和 “0” 的在物理层面的区别越明显，电路工作越可靠。

电路不会一直稳定。为了应对电压波动，实际的高低电平判定有范围，如理想的低电平是 0V，实际可能 0.5V 也可以判定为低电平。

常见逻辑门符号

符号标准使用国标 GB/T 4728.12-1996，参见 基本逻辑门电路图形符号 的 “国标图形符号” 部分

  • 与门标 &\And
  • 或门标 ⩾1\geqslant 1
  • 非门标 11，门后加圆圈表示 “非”
  • 与非门标 &\And，门后加圆圈
  • 或非门标 ⩾1\geqslant 1，门后加圆圈
  • 异或门标 =1=1

触发器

在数字电路中，输入信号作用前的状态称为现态，记作 QQ；输入信号作用后的状态，称为次态，记作 Qn+1Q^{n+1}

触发器是一种具有记忆功能的电子器件，每次可以存储 1 位二进制信息，其输出除了和输入相关，有时还和现态相关。

Tip

nn 个触发器存储 nn 位二进制信息，可以表示 2n2^n 状态

触发器可分为 RS 触发器、D 触发器、JK 触发器、T 触发器等类型。当输入的时钟脉冲 CP = 1 时：

触发器次态方程约束方程功能备注
RS 触发器Qn+1=S+R‾QQ^{n+1}=S + \overline{R}Q / Qn+1=S‾+RQQ^{n+1}=\overline{S} + RQ（与非门构成的基本 RS[1]）R⋅S=0R\cdot S=0 / R+S=1R+ S=1（与非门构成的基本 RS）保留、置 0、置 1Reset（置 0），Set（置 1），约束方程表示 R、S 需要满足的条件
D 触发器Qn+1=DQ^{n+1}=D-置 0、置 1状态变化仅与输入信号相关；锁存器
JK 触发器Qn+1=JQ‾+K‾QQ^{n+1}=J\overline{Q}+\overline{K}Q-保留、置 0、置 1、翻转
T 触发器Qn+1=TQ‾+T‾Q=T⊕QQ^{n+1}=T\overline{Q}+\overline{T}Q=T⊕Q-保留、翻转JK 触发器的特殊情况；计数触发器
T' 触发器Qn+1=Q‾Q^{n+1}=\overline{Q}-翻转T 触发器的特殊情况，可以通过 JK 触发器或 D 触发器实现

当输入的时钟脉冲 CP = 0 时，所有触发器的状态保持不变，即 Qn+1=QQ^{n+1}=Q。这是电平触发。电平触发的时钟信号是使能信号，在它处于某个特定电平（高电平或低电平）的整个期间，输出都会实时跟随输入的变化。当使能信号无效时，输出才 “锁存” 住最后一个值并保持不变。所有简单结构触发器均采用这一触发方式。

简单结构触发器的抗干扰能力较弱，所以实际使用的触发器结构要复杂一些，分为主从触发和边沿触发。

主从触发器有两个触发器，分为主触发器和从触发器。假设主触发器高电平有效，从触发器低电平有效，当 CP = 1 时，仅有主触发器工作（主模式），实时响应输入信号；下降沿以及低电平时，主触发器被锁定，从触发器工作（主从模式），输出主触发器锁存的值。主从 RS 触发器和主从 JK 触发器属于这一类触发

边沿触发分为上升沿（正边沿）触发和下降沿（负边沿）触发。上升沿触发只有在时钟信号从低电平（逻辑 0）跳变到高电平（逻辑 1）的那个瞬间，电路才会采样输入并更新输出；下降沿触发只有在时钟信号从高电平（逻辑 1）跳变到低电平（逻辑 0）的那个瞬间，电路才会采样输入并更新输出。在时钟周期内的其他任何时间，输入信号都不会影响输出。维持 - 阻塞 D 触发器属于上升沿触发。

触发器需要注意两个问题：一个是简单结构触发器的 “空翻” 现象，另一个是主从 JK 触发器的 “一次翻转” 现象。

“空翻” 现象指的是在同一个脉冲作用周期内触发器状态发生两次及以上的变化的现象，原因是在使能信号生效期间，输出都会实时跟随输入的变化。“一次翻转” 指的是在同一个脉冲作用周期内，主触发器的状态只能根据输入信号的变化改变一次，翻转一次后主触发器锁定，状态不再受输入影响。

几个触发器描述图表

  1. 状态表

现态和对应输入下次态的输出

次态 Qn+1Q^{n+1}
现态 QQRS = 00RS=01RS=11RS=10
0d001
1d011
  1. 状态图

反映状态转移关系的有向图

RS 触发器的状态图

  1. 激励表

状态转移时对输入的要求

QQQn+1Q^{n+1}RS
00d1
0110
1001
111d
  1. 时间图（工作波形图）

状态转移在一定时间内的连续变化。按照触发方式和功能表确定判决时刻线，在时刻线上判断输出变化，其它时刻保持不变

RS 触发器的时间图

有限状态机

上面的状态图已经可以表示一个有限状态机了。有限状态机 (FSM) 是表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型。

一个状态机一般由这几个部分组成：状态、转移、动作、转移条件。

  • 将一个系统离散化，可以得到很多种状态
  • 一个状态接收一个输入执行了某些动作到达了另外一个状态的过程就是一个转移
  • 在某一状态下，只有达到了转移条件，才会按照状态机的转移流程转移到下一状态，并执行相应的动作。
  • 在状态机的运转过程中会有很多种动作，例如进入动作在进入状态时进行

如果你还知道 C 语言的话，switch - case 语句就可以构成一个简单的状态机。

组合逻辑电路

输出仅取决于该时刻的输入，而与过去的输入值无关，没有反馈回路。

分析组合电路的步骤

  1. 确定电路的输入和输出
  • 识别电路的输入变量（通常用 A、B、C 等表示）
  • 确定电路的输出变量（通常用 Y、F 等表示）
  1. 从输入到输出逐级分析
  • 从输入端开始，逐级向输出端分析
  • 写出每个门电路的输出逻辑表达式
  • 将各级表达式代入，得到最终的逻辑函数
  1. 化简逻辑函数
  • 使用布尔代数定律化简表达式
  • 或使用卡诺图进行化简
  1. 列出真值表
  • 根据化简后的逻辑函数，列出所有输入组合对应的输出值
  1. 描述电路功能
  • 根据真值表分析电路实现的逻辑功能（序列检测、加减法、码制转换）
  • 确定电路的应用场合

设计组合电路的步骤

  1. 建立给定问题的逻辑描述
  • 设定输入、输出变量组成。一个二进制位对应一个独立变量。输出变量根据逻辑决定数量，两个没有直接逻辑关系的行为分属两个变量。
  • 常用分析方法有真值表法（通用方法但是比较累）和分析方法（比较简洁但是难）
  1. 求出逻辑函数的最简表达式

参考 表达式化简

  1. 选择逻辑门类型，并进行逻辑函数变换
  2. 画出逻辑电路图

设计路线不是唯一的。我们不要求最简洁的做法，只需要逻辑功能正确即可

设计过程中的几个问题

无关项

如果输入变量的某些取值组合不会出现或者对这些组合的输出不关心，则称这些输入项为无关项，用 X 或 d 表示

在卡诺图化简中，这些无关项的取值可 1 可 0，因此可以灵活选择以符合 “卡诺圈面积尽量大” 的规则

多输出函数

能掌握掌握，不能掌握可以不用，这是锦上添花的做法

不提供反变量

最直接的做法就是接一个非门，但设计结果往往不经济，因此不提供反变量也意味着使用最少的非门（或不使用）。具体怎么实现看题目有没有限制逻辑门使用。

没有一种系统而有效的方法以设计出不提供反变量的最简电路，因此灵活处理即可

中规模组合逻辑电路

中规模组合逻辑电路主要有以下种类芯片：加法器、译码器、数据选择器

加法器

加法器分为半加器和全加器。半加器不考虑来自低位的进位，而全加器需要考虑来自低位的进位。

半加器

半加器

半加器的输入是 AiA_i、BiB_i，输出是本位和 SiS_i 与本位进位 CiC_i

Si=Ai⊕Bi, Ci=AiBiS_i=A_i \oplus B_i,\ C_i=A_iB_i

由于单个半加器不接受低位进位，因此只能对 1 位二进制数执行相加运算，也可以作为级联构成的加法器的第一级（因为此时没低位）

全加器

半加器的输入是 AiA_i、BiB_i 和低位进位 Ci−1C_{i-1}，输出是本位和 SiS_i 与本位进位 CiC_i

由于单个全加器接受低位进位，因此可以级联构成多位二进制数的加法器。

有两种方法得到全加器：

  • 通过完整的组合逻辑电路设计步骤，从真值表、卡诺图、表达式得到
  • 通过两个半加器的叠加
全加器的构成方法
全加器的构成方法

按进位方式分类，全加器可分为串行进位二进制加法器和超前进位二进制并行加法器

  • 串行进位二进制加法器

由全加器级联构成，高位的进位输入依赖于低位的进位输出

  • 超前进位二进制并行加法器

此内容较为困难，故仅介绍采用此方式的芯片

74283

74283 属于超前进位二进制并行加法器，有 4 个被加数输入端 AiA_i、4 个加数输入端 BiB_i、1 个低位进位输入端、4 个本位和输出端 FiF_i、1 个本位进位输出端

74283 芯片符号

  • 码制转换（8421 码和余 3 码）

    将 8421 码转换成余 3 码，只需要固定加数输入为 0011（3 的补码）；将余 3 码转换成 8421 码，只需要固定加数为 1101（-3 的补码），或者固定加数为 1100（-3 的反码），缺少的 “1” 由低位输出补齐；若要实现二者的互换，则引入控制信号 MM 接入低位进位端和固定加数端，当 M=0M=0 时实现将 8421 码转换成余 3 码，当 M=1M=1 时实现将余 3 码转换成 8421 码。

  • 余 3 码的加法

    由于余 3 码有修正机制（有进位时加 3，没进位时减 3），因此需要两片 74283，其中一片用于修正。

  • 乘法

    依照小学学过的竖式乘法，计算各位输出。（分析法）得到的输出应和此式相似：Z1=a1b1+0Z_1=a_1b_1+0，那么 a1b1a_1b_1 接入 A1A_1/B1B_1，00 接入 B1B_1/A1A_1

译码器

译码即将二进制代码的原意 “翻译” 出来，还原成原特定含义的信息。输入是一组二进制代码，输出是一组对应的高低电平信号，只有一个输出端呈现有效信号。

变量译码器是将 nn 位二进制输入变量译为 2n2^n 个不同输出信号的电路，每个输出对应一种输入代码，即一个 nn 变量最小项。由于输出的是最小项，因此在化简逻辑函数表达式时需要将表达式写作最小项表示

课程所用的译码器输出均为低电平有效，因此化简后，需要再次变换让最小项带上 “非”，例如 m1+m2+m4+m7m_1+m_2+m_4+m_7 应该转换成 m1‾⋅m2‾⋅m4‾⋅m7‾‾\overline{\overline{m_1}\cdot\overline{m_2}\cdot\overline{m_4}\cdot\overline{m_7}}

代表芯片是 74138（3-8 线译码器）、74139（双 2-4 线译码器）

74138

74138 是 3-8 线译码器，具有三个输入、八个输出以及三个使能端。当使能端 S1=1S_1=1，S2‾+S3‾=0\overline{S_2}+\overline{S_3}=0 时，译码器才正常工作

74138

74139

2-4 线译码器具有两个输入、四个输出以及一个使能端。当使能端 E‾=0\overline{E}=0 时，译码器才正常工作。

74139 是双 2-4 线译码器，就是两个 2-4 线译码器并排黏合组成的

74139

译码器的扩展

在解决 nn 输入问题时，除了对应使用 nn 输入的译码器，还可以使用多个 n−1n-1 输入的译码器。由于一个译码器只能覆盖目标输出的一部分，因此需要片选译码器以分段输出需要的最小项。

两个 2-4 译码器可以构成一个 3-8 译码器，两个 3-8 译码器可以构成一个 4-16 译码器。设计时可以利用译码器的使能端，将最高位分别接入两片译码器的不同使能端，使得同一个最高位内，仅有一片输出译码器正常工作

如果用 2-4 译码器构成 4-16 译码器呢？从输出来看，我们至少需要 4 个 2-4 译码器作为输出端（4×4=164×4=16），但 2-4 译码器满打满算也就只有 2 + 1 = 3 个输入端，连 4 位输入都无法满足。因此，我们还需要一个 2-4 译码器 “压缩” 一部分输入，总共五个 2-4 译码器。高二位和一个使能信号接压缩输入的那个译码器，其输出和低二位分别作为四个输出译码器的输入。

函数发生

译码器输出最小项，而逻辑函数就可以用最小项之和表示。因此，译码器可以生成我们需要的逻辑函数

例如，通过真值表得知，全加器的输出函数可以这么表示：

Si(Ai,Bi,Ci−1)=∑m(1,2,4,7), Ci=(Ai,Bi,Ci−1)=∑m(3,5,6,7)S_i(A_i,B_i,C_{i-1})=\sum{m(1,2,4,7)},\ C_i=(A_i,B_i,C_{i-1})=\sum{m(3,5,6,7)}

转换得到译码器工作模式

数据选择器

通过选择变量选择需要输出哪一路的数据，当选择变量符合对应最小项下标，则将选择变量与上数据输出。nn 个选择变量可以控制 2n2^n 个数据输出。

nn 选 1 数据选择器的输出函数表达通式：F=∑i=0n−1miDiF=\sum_{i=0}^{n-1}{m_iD_i}，其中 mim_i 表示选择变量的最小项

课程主要使用 74153（四选一）和 74151（八选一）

74153

4 个数据输入端，2 个选择变量端，1 个输出端，1 个使能端。当使能端 E‾\overline{E} 为 0 时，数据选择器正常工作

74153

实际应用时会将两个四选一 MUX 合并成一个 74153

74151

8 个数据输入端，3 个选择变量端，1 个输出端，1 个使能端。当使能端 E‾\overline{E} 为 0 时，数据选择器正常工作

74151

数据选择器的扩展

用 2 个 4 选 1 构成一个 8 选 1，用 2 个 8 选 1 构成一个 16 选 1

函数发生

由上面的通式可知，数据选择器可以输出选择变量的最小项。给不同的 DiD_i 赋予不同数据，就可以选取不同的完整最小项，从而实现函数发生。

nn 个控制变量可以实现 n+1n+1 变量的函数发生（有一个变量可以接到数据端）

时序逻辑电路

按输入脉冲同步与否，将时序逻辑电路分为同步时序逻辑电路和异步时序逻辑电路。同步时序逻辑电路有一个统一的时钟脉冲控制每个触发器的状态，即每个触发器的 CP 端连接同一个脉冲；异步时序逻辑电路则没有，存在有的触发器的 CP 端连接到另外的脉冲上

根据输出信号的特点，将同步时序逻辑电路分为 Mealy 型和 Moore 型电路。Mealy 型电路的输出不仅和触发器现态 QQ 有关，还和当前的输入 X 有关；Moore 型电路的输出仅和触发器现态 QQ 有关

换句话说，就是看输入连接到哪些元件上了。如果输入存在直接连到最后输出的逻辑门上的分支，那么就是 Mealy 型电路。

时序电路的电路性质就是按这两点来描述的。

描述方法

  1. 逻辑函数表达式

分为输出函数表达式、激励函数表达式（驱动方程）和次态函数表达式。

输出函数表达式就是电路输出与输入和现态之间的关系表达式；激励函数表达式是存储电路的输入（电路内部）与输入和现态之间的关系表达式，具体来讲就是触发器的输入与输入和现态之间的关系表达式，一般从高序号到低序号写；次态函数表达式是次态与激励函数和现态之间关系表达式。

  1. 状态表

反映输出 ZZ、次态 yn+1y^{n+1} 和输入 xx、现态 yy 之间的关系

Mealy 型电路的状态表：

次态 / 输出
现态输入 xx
yyyn+1/Zy^{n+1}/Z

输出跟着输入走

Moore 型电路的状态表：

次态
现态输入 xx输出
yyyn+1y^{n+1}ZZ

输出和输入无关

状态表简化得到转换表

CP现态输出
0Q2nQ1nQ0nQ_{2}^{n}Q_{1}^{n}Q_{0}^{n}Y
  1. 状态图

反映状态转移规律，由状态表得出

Mealy 型电路的状态转换图：

模 4 可逆计数器 A

Moore 型电路的状态转换图：

模 4 可逆计数器 B

简化得到转换图，只表示状态转换顺序

模 8 计数器

  1. 时间图（工作波形图）

状态转移在一定时间内的连续变化。按照触发方式和功能表确定判决时刻线，在时刻线上判断输出变化，其它时刻保持不变

模 4 可逆计数器 B 的时间图

分析方法

表格分析法

  1. 确定电路类型，是 Mealy 型还是 Moore 型
  2. 写出输出函数表达式和激励函数表达式
  3. 列出次态真值表
输入现态激励函数（控制变量）次态
xxyyDD/JJ/KKyn+1y^{n+1}
  1. 由次态真值表和输出函数表达式，作出状态图和状态表
  2. 画出时序图和时间图，文字说明电路逻辑功能

代数分析法

  1. 确定电路类型
  2. 写出输出函数表达式和激励函数表达式
  3. 将激励函数表达式代入触发器的次态方程，得到电路的次态方程
  4. 由次态方程和输出函数表达式，作出状态图和状态表
  5. 画出时序图和时间图，文字说明电路逻辑功能

设计方法

小规模同步时序逻辑电路主要设计计数器和序列检测器。触发器一般使用 JK 触发器

计数器

计数器，顾名思义就是在时钟的节拍下进行计数。计数器在工作时，所经历的状态是周期性的、有限的。我们将一次循环所包含的状态总数称为模数 MM，包含 nn 个触发器的最大模数 M=2nM=2^n。

计数器也称为分频器。模 MM 计数器的输出端的信号频率是 CP 信号的 1M\frac{1}{M}

计数器只需要时钟脉冲以使触发器工作，不需要额外输入，因此计数器电路属于 Moore 型电路

  1. 输入输出变量
  2. 建立状态图和状态表。状态图仅包括从状态 S0S_0 到 Sn−1S_{n-1} 的状态，状态表则要讨论全部状态（包含无效状态 d）
  3. 求出各触发器输出端的卡诺图
  4. 写出电路的状态方程和输出方程
  5. 求出驱动方程
  6. 画电路图
  7. 检查电路能否自启动。具体来说，如果所有无效状态经过有限个时钟周期后可以转换为某个有效状态，进入正常循环，那么电路就可以 “自启动”
自启动和挂起

有些题目还会讨论 “挂起” 现象。“挂起” 说明有无效状态组成了一个死循环，导致电路可能无法进入正常工作循环。“挂起” 现象是一种设计错误，如果出现 “挂起”，则应认为此电路不可自启动。
不存在 “部分可自启动” 这个说法。它是一个全局属性，要么成立（即对所有状态成立），要么不成立（即至少对一个状态不成立）

序列检测器

序列检测器用于检测是否连续输入某个序列。

  1. 建立原始状态图、原始状态表。原始状态图和原始状态表均只讨论题目明确说明的有效状态
  2. 状态化简。合并等价状态。
  3. 状态编码。根据化简后的状态数量确定触发器数量，进而确定每个状态要用几位编码。状态编码根据格雷码排序，需要讨论无效状态
  4. 求驱动方程和输出方程
  5. 画电路图
  6. 检查自启动特性

状态化简

判断两个状态等价有两个条件：输出相同且次态等价。次态等价指两个状态的次态相等（等价）、交错（即 SiS_i​ 的次态是 SjS_j​，SjS_j​ 的次态是 SiS_i）、循环（多个状态相互依赖）或者不变

状态化简分为两个方法：目测法和隐含表法

目测法就是按上面的定义 义眼盯真 目视找出等价状态。很明显只有明显的状态对才能被找出。

隐含表法遵循以下步骤：

  1. 构成隐含表（横去尾、纵去头排列状态，等差阶梯状表格）
  2. 顺序比较：比较结果打 “√” 或 “×”，如果需要进一步确认则填上等效需要的条件状态对
  3. 关联比较状态对：查看条件状态对是否等价，如不等价则打 “×”
  4. 形成最大等效类：等价关系具有传递性，如等价对 AD、BD 等价，则最大等效类为 ABD
  5. 合并状态

隐含表

中规模时序逻辑电路

中规模组合逻辑电路主要有以下种类芯片：计数器和寄存器

同步计数器

本课程使用 74161 芯片。74161 的计数进制（模数）为十六进制，输出 4 位二进制码。置数方式采用同步方式，清零方式采用异步方式

异步方式只需要使能信号有效即可（即时响应），而同步方式需要使能信号有效 + 时钟边沿到来（定时响应）

74161 有 4 个置数输入端、2 个使能输入端 T 和 P、异步清零端 Cr‾\overline{C_r}、同步预置端 LD‾\overline{L_D}、脉冲输入端 CP、溢出进位输出端 OCO_C 和 4 个数据输出端 QDQCQBQAQ_DQ_CQ_BQ_A（高位到低位，严格按照此字母顺序）

74161

当 Cr‾=LD‾=1\overline{C_r}=\overline{L_D}=1 且 T⋅P=0T\cdot P=0 时处于输出保持状态；在计数器正常工作状态（T⋅P=1T\cdot P=1）下，当同步计数器加到 11111111 时，OC=T⋅QD⋅QC⋅QB⋅QA=1O_C=T\cdot Q_D\cdot Q_C\cdot Q_B\cdot Q_A=1

构成小于十六进制的计数器

两种方法：

  • 反馈复位法

从输出端接收到特定信号时将信号返回给清零端 CrC_r。由于异步方式清零，因此设计 MM 进制计数器时，反馈复位法需要 M+1M+1 个状态以防止有效状态被清零，并且因为清零端从接受信号到清零中间有时间差，因此时间图会有毛刺

  • 反馈预置法

从输出端接收到特定信号时将信号返回给预置端 LDL_D。由于同步方式置数，因此设计 MM 进制计数器时，反馈预置法只需要 MM 个状态且没有毛刺

如果预置数为 0，那么计数从 0 → M 循环；预置数为 (16 - M)，那么计数从预置数 → M 循环

构成大于十六进制的计数器

首先确定需要几位输出。MM 进制计数器所需状态数应在 2n−1<M⩽2n2^{n-1} \lt M \leqslant 2^{n} 内，则需要 nn 位输出，那么就需要 4(k−1)<n⩽4k4(k-1) \lt n \leqslant 4k，即 k 个 74161 芯片。

芯片之间的两种连接方法：

  • 同步连接法

两片芯片输入相同的 CP，片 2 的两个使能信号均引自片 1 的 OCO_C 端

  • 异步连接法

片 2 的 CP 来自片 1 的 OC‾\overline{O_C}（加非门），两片芯片的使能信号始终生效

异步计数器

异步二进制计数器由 T′T' 触发器构成（而 T′T' 触发器又可由 JK 触发器或 D 触发器构成），触发器之间串接，低位触发器的输出作为高位触发器的时钟

一个考点是判断是加法还是减法计数器

判断方法是看 Qi−1Q_{i-1}（低位输出）和 CPiCP_{i}（高位脉冲端）之间的连接情况。如果连起偶数个（0 / 2 个）圆圈，则为减法计数器；如果连起奇数个（1 个）圆圈，则为加法计数器

代表芯片是 7490 芯片

7490 芯片电路符号

7490 芯片逻辑功能表

按指定码制构成十进制计数器

  • 8421 码

将 QAQ_A 与 CPBCP_B 相连，计数脉冲从 CPACP_A 输入。QDQCQBQAQ_DQ_CQ_BQ_A输出，构成 8421 码计数器

  • 5421 码

将 QDQ_D 与 CPACP_A 相连，计数脉冲从 CPBCP_B 输入。QDQCQBQAQ_DQ_CQ_BQ_A输出，构成 5421 码计数器

实现 10 以内 M 进制计数器

把 M 进制对应的输出端为 1 的输出相与后反馈到清零端，作为计数满整清零信号

实现 11 - 100 的 M 进制计数器

  1. 由两片（个位和十位）7490 扩展成 100 进制

两芯片均连接成十进制，时钟脉冲从个位 CP0CP_0 进，个位的 Q3Q_3 与十位芯片的 CP0CP_0 相连即可，

  1. 把 M 进制所对应的十位、个位芯片上输出为 1 的端相与后反馈到清零端，作为个位和十位的计数满整清零信号

计数型序列发生器

循环产生指定序列。nn 位长度的序列需要 nn 个状态，即需要先构成 nn 进制计数器。

计数器的计数输出需要翻译为 1 位二进制，可以使用基本逻辑门实现

0101101 序列发生器

或者将计数器输出引入译码器（74138）或数据选择器（74151）。

如果使用译码器，则把 “序列输出 F 为 1 的那些状态” 找出来，用译码器把这些状态 “识别” 出来，然后把识别结果 “与非” 在一起。

11000101 序列发生器

如果使用数据选择器，则数据选择器的数据输入端设置为指定的序列值

011101 序列发生器

寄存器

寄存器用于暂时存放一组二进制代码，由触发器和控制门构成。

基本寄存器有读出、写入、复位（清零）功能，使用 D 触发器构成最简单。一个 nn 位寄存器由 nn 个触发器构成，能存放 nn 位二进制数

移位寄存器在基本寄存器的基础上增加了左移 / 右移功能。右移指 Qin+1=Qi−1nQ^{n+1}_{i}=Q^{n}_{i-1}，左移指 Qin+1=Qi+1nQ^{n+1}_{i}=Q^{n}_{i+1}。空出来的位置由对应的串行输入取代，被挤出去的数据就没有了

代表芯片是 74194，实现了双向移位

74194 芯片电路符号

这个芯片比较难 QAQ

环形和扭环形计数器

环形计数器的有效循环为：唯一的 1 右移，或者唯一的 0 左移

环形计数器的状态利用率低，nn 个触发器构成的环形计数器仅有 nn 个有效状态，有 2n−n2^n-n 个无效状态

扭环形计数器的有效循环为：从左到右，1 填满 0；从右到左，0 填满 1

扭环形计数器的状态利用率较高，nn 个触发器构成的环形计数器有 2n2n 个有效状态，有 2n−2n2^n-2n 个无效状态

扭环形计数器也可以用 74194 芯片构成。

奇数分频器

本质计数器，按反馈预置法接线

有一个规律：使用 74194 芯片右移时，置数端

  • 接 QD‾\overline{Q_D} 是模 8 计数
  • 接 QC‾\overline{Q_C} 是模 6 计数
  • 接 QB‾\overline{Q_B} 是模 4 计数
  • 接 QA‾\overline{Q_A} 是模 2 计数
  • 接 QDQC‾\overline{Q_DQ_C} 是模 8+62=7\frac{8+6}{2}=7 计数
  • 接 QCQB‾\overline{Q_CQ_B} 是模 6+42=5\frac{6+4}{2}=5 计数
  • 接 QDQB‾\overline{Q_DQ_B} 是模 8+42=6\frac{8+4}{2}=6 计数

脉冲型序列发生器

先设置左移右移，然后设计反馈电路

10110 序列发生器

实验提示

建议使用芯片乃至实验仪前测试一下功能。基础门电路芯片尽量对每个门（至少测你需要的门）都测一遍功能，不然会成小丑 🤡

数码管记得 “共阳极” 接法，即在数码管右侧、逻辑灯泡的左下角，有对 “-5V” 和 “+5V” 的接口，将它们连一起。否则你的数码管数值会乱跳，然后求助老师并收获一番质问 😦

要对自己的电路有信心。也可以先用 Multisim 仿真一下结果

普通实验的数据记录可以提前写，因为我们做的毕竟是 “理论验证实验” 🤣 这样不仅便于调试还能加快撤退速度 😍

实验考试难度，就我抽到的题目（74161 实现模 10 计数器）而言，不会超过实验书的实验难度（远远没达到综合实验的难度），但一定要带实验书和一般实验的报告，因为你要看芯片的接线图的！

  1. 集成触发器（如 D 触发器、JK 触发器）中，其内部的核心锁存单元绝大多数都是基于或非门（或等效结构）的 RS 锁存器。 ↩︎

]]> https://blog.watermelonabc.top/p/7d823f34/ 2025-09-08T07:06:34.000Z 还剩第五章，时序逻辑（ 2025 福州大学数字逻辑笔记 2026-08-20T15:50:52.000Z Watermelonabc C# 用于微软 .NET 的开发。如果我们尝试使用 IDA 对 C# 程序反汇编，很可能只能收到一个无情的 Sorry, the current file is not decompilable。C# 反编译需要专门工具。

Note

Unity 同样使用 C#。对于使用 Mono 作为脚本后端 (Scripting Backend) 的 Unity 游戏，可以使用下面介绍的 C# 反编译工具对 Assembly-CSharp.dll 反编译，即可得到源码。

dnSpy 和 ILSpy

dnSpy 是一个调试器和 .NET 程序集编辑器。它提供了和 Visual Studio 类似的界面，并且有官方中文！

我们关心的特性有这几个：

  • 调试 .NET Framework、.NET 和 Unity 游戏程序集，无需源代码
  • 所有元数据都可以编辑
  • 使用 IntelliSense 编辑 C# 或 Visual Basic 中的方法和类，无需源代码
  • 在 C# 或 Visual Basic 中添加新的方法、类或成员
Note

所以没有用反逆向机制的 C# 或 .NET 程序是很容易被破解的……

原始的 dnSpy 已经在 2020 年归档，现在仍在活跃的是分支版本 dnSpyEx。

dnSpy 采用和 VS 类似的文件组织架构，导入的文件显示在 “程序集资源管理器” 中

dnSpy截图

一个文件被划分为以下部分（从上到下）：

  • PE
  • 类型引用
  • 引用
  • 类 ({})

我们主要关注的是 {} 下的那些方法。

如果你需要全局查找字符串，请使用 “搜索程序集” 功能，并选择搜索 “数字 / 字符串”。它可以在工具栏最右端、“编辑” 菜单中找到，或者按快捷键 Ctrl + Shift + K。

dnSpy 的反编译器是 ILSpy，它同样拥有图形化界面。由于 ILSpy 专注于反编译工作，因此它的更新速度比较快，反编译效果也更好。我们建议将 dnSpy 和 ILSpy 配合使用。

其他反编译软件有 dotPeek（效果媲美 ILSpy，但启动过慢）、.NET Reflector（祖师爷级别，但已经不再进一步更新）等。

]]> https://blog.watermelonabc.top/p/b88b7467/ 2025-09-04T14:15:33.000Z 专人专用 C# 逆向入门 2026-08-13T03:25:03.000Z Watermelonabc 安卓刷机一点通

封面来自 Android Studio I/O Edition: What’s new in Android Developer tools

对于数年前的安卓用户而言，刷机并不是一个生涩的词。厂商官网上提供解锁 Bootloader 服务，应用市场里躺着 Root 获取器和刷机软件，专业论坛里有着丰富的刷机包，Root 之后，像是烧饼、葫芦侠、幸运、GG 等修改器就可以大显身手了。这些构成了我当时对于安卓刷机的印象。

那时，我在一个一键刷机软件上找了一个看的过去的刷机包，把我的乐视 1（大概？）刷上了机。当然，我当时只是一个小萌新，丝毫不知道这 “一键” 的后果是什么。我自信地勾选了 “保留软件”，但在刷机后却发现这只是把刷机前安装的软件再安装一遍，而原有的用户数据自然是菠萝菠萝哒了 (OMO)

在现在这个时间谈刷机似乎不合时宜。各品牌都在收紧解 BL 锁的权利，乃至禁止 （猜猜看是哪个品牌既有高考又有体考的）。因此，要学刷机，我们就只好折腾旧手机了，这也是更经济的选择。

Note

本文使用 Google Pixel 2 作为示例。作为 Google 亲儿子，Pixel 系列的刷机难度是比较低的，开发工具和文档也很完善。
请确认你购买的机型是否可以解 OEM 锁，这是解 Bootloader 锁的前提。商家页面会写，一般标 “O” 的就是可以解 OEM 锁。实际上，更有可能的情况是商家已经默认帮你提前解锁好了 Bootloader 买这种破烂机器做什么他们门儿清
依照财力选择，量力而行。Pixel 1 不太推荐，我在淘宝上买了两家的 Pixel 1，一家脱了我数天不发货，然后看了小肩膀的推荐去了另外一家，我买完就下架了，并且客服跟我说现在他们手里的都是功能缺陷品。当然，你也可以在咸鱼上面找一找，多半是比我买的要便宜的。

了解 Android 文件目录

Android 系统有三种权限：第三方软件权限、用户权限和超级用户 (ROOT)，从低到高排序。如果我们想在软件层面折腾手机，就必须先获取 ROOT 权限。

Root 后会不会不安全

是的，手机 Root 后确实会带来显著的安全风险。但这并不意味着它 “绝对不安全”，而是意味着安全的重心从手机厂商转移到了你自己身上。
—— DeepSeek V3

…… 我是用一台全新的平板折腾，并永不打算在这台设备上安装微信、支付宝、银行 APP 等敏感 APP。再就是解锁 ROOT、安装 Magisk 和 LSPosed 后，千万不可随意安装需要 ROOT 的 APP、脚本、模块等。因为你会给这些程序赋予你手机的最高权限，程序可以在完全不询问你、不显示 UI 的前提下，对你的手机进行一切权限操作。
所以一般来说，只敢选择 GitHub 开源的，在 B 站、酷安、V 站等平台口碑较好的存活时间较长的软件、模块。并且建议选择 GitHub 开源代码的，直接在原版作者的 Gtihub 的 releases 中下载 APK/ZIP。安装后，设置生效范围，比如 Guise 模块只有 Tiktok 用，生效范围只选 Tiktok。在 Magisk 中的排除列表，排除所有敏感 APP，这些被排除的 APP 不参与到 ROOT、模块中。
——关于 2024 年如何 ROOT 安卓系统 并进行系统优化等 基础入门 Magisk lsposed

与真正的 Linux 相比，Android 的 Root 的权限相对更 “大”。当然，这种 “大” 是不受控的、“粗糙的”，因为 Android 设计时就不希望用户获取 Root 权限，所以一旦你获取了 Root 权限，Android 系统内就几乎没有安全机制限制权限。由于 Android 的权限控制是基于应用的，所以一个获取了 Root 权限的应用实际上也获取了和你一样的权力。

在旧版的 Android 中，系统文件目录分为：

  • Boot 分区：包含 Kernel（内核）和 Ramdisk（虚拟内存），和开机启动引导有关。我们折腾手机很大一部分就是在折腾 Boot 分区。如果 Boot 分区损坏，那么手机开机就会卡在第一屏（有 “Powered by ...” 的）变砖辣
  • System 和 Vendor 分区：存放操作系统和系统软件，系统升级 / 刷机就是刷 System 的。如果 System 分区损坏，那么手机开机就会卡在第二屏 又变砖啦
  • Data 分区：存放软件数据
  • Cache 分区：缓存区
  • Recovery 分区：包含一个简易的 Linux 系统，用于恢复和维护手机，类似于 Windows PE。

从 7.0 开始，Android 引入了新的升级方式：A/B System Updates。手机中同时存在两套 Boot 和 System，其中一套作为备份，必要时可以切换。这种更新方式的特征就是无缝升级和容灾。用户在系统升级时仍然可以操作手机，如果升级失败，备份分区的存在也不至于造成无法挽回的损失。A/B 分区下的 Recovery 集成到 Boot 分区中。

从 10.0 开始，Android 引入了动态分区技术，备份的 A/B System、Vendor 等系统分区整合到 Super 分区中，开发者无需关心 Super 分区下各子分区的大小。注意，由于原理限制，Boot 分区不使用动态分区。

A/B 分区由于多了一个备份分区，会导致系统空间占用增加，于是 Android 11 又出现了 VAB（虚拟 A/B 分区）。VAB 仅备份 Boot 分区，其他分区（包括 Super）将更新的增量内容写入快照中。更新后，如果正常启动，那么系统就会将快照内容合并到老数据，这样就完成了一次 VAB 更新。

由于 AB 和 VAB 分区中 Recovery 分区被合并到 Boot 分区中，所以刷第三方 Recovery（如 TWRP）会比较麻烦。现在更推荐一种更接近底层的刷机方法—— Fastboot。

Fastboot

Android 系统启动前，会加载 Bootloader（引导加载器，相当于 BIOS/UEFI），初始化硬件设备并引导硬件设备。在引导后期，我们可以通过快捷键进入 Fastboot 模式。Fastboot 是一种引导加载程序模式，可以在该模式下刷写设备。

Note

我们所说的 BL 锁是一个系统分区签名检查机制。运行时，Bootloader 会检查设备状态，如果是 Locked，则检查签名，匹配成功后正常引导系统，匹配不成功则拒绝引导；如果是 Unlocked，则不检查签名。
第三方系统镜像基本没有签名，因此 Bootloader 无法引导这些镜像。当然，理论上讲，如果有正确的签名工具对分区签名，也可以过一些 BL 锁，不过可能都是华强北山寨机了。
如何查看 BL 有没有解锁？一个是查看手机正常启动时有没有提示，例如 Google Pixel 在 BL 解锁后会先显示一个警告，然后进入开机画面时会有一个开锁 🔓 图标。另一个是进入 Fastboot 模式查看 Device State 是否为 Unlocked

当您开启 Android 设备时，系统会对操作系统进行检查，以确保它可以安全使用。可以安全使用意味着代码均来自可信来源，而且没有遭到更改或损坏。

如果您的操作系统可能存在问题，系统会向您发出一条警告消息，该消息会将您转至此页面 (g.co/ABH)。

——了解关于操作系统安全的警告

Fastboot 独立于 Android 文件目录之外。如果刷 Recovery 刷砖了，可以试试能否用 Fastboot 救回来。有时候情况更加危急，比如刷机刷坏了基带、字库等，连 Fastboot 都进不去，那么就只能通过更加底层的刷机模式—— EDL 串口线刷模式来救了。在高通平台，它的别名更加知名：9008 模式。

用 fastboot devices 检查是否进入 fastboot 模式。如果没有输出，请先查看是否安装驱动。

检查驱动

如果 fastboot 找不到设备，请查看设备管理器是否有显示感叹号 ⚠ 的设备（我这里显示 Android+）。如果有，右键 -> 更新驱动程序 -> 浏览我的计算机以查找驱动程序 -> 让我从计算机上的可用驱动程序列表选取。如果弹出的选项直接有 “ADB 设备”，则选择。否则返回，我们需要手动指向 Google USB 驱动。

如果你在 Android Studio 中勾选安装了 Google USB Driver，那么驱动在 <Android SDK Location>\extras\google\usb_driver。在 “浏览我的计算机以查找驱动程序” 填入以上位置搜索驱动程序。

Android Studio 是唯一的官方驱动获取途径。文档提供的独立下载链接不知为何返回的是 404。

Tip

在设备关机时，可使用以下组合键进入 fastboot 模式：同时按住音量 “-” 键和电源键
在设备开机时，可以通过 adb reboot bootloader 进入 fastboot 模式。

刷 LineageOS 22

LineageOS 是一个非常长寿而著名的类原生安卓发行版。正如它的宣传语：“为您的设备注入新的活力，无论是旧设备还是新设备。” 他们为许多老旧手机提供了远超官方维护期限的系统更新服务，例如我手里的 Google Pixel 2，当它的 Google 官方最高版本停留在 2020 年 Android 11 时，LineageOS 维护至今，已经适配到了 Android 15。

LineageOS 是开源软件，且默认不包含 Google 服务，因此吸引了其他开发者以此作为基底，开发自己的 Android 发行版。

Pixel 2 在 LineageOS 官网有良好的安装指引：关于 walleye 的信息。可遵循该指引安装 LineageOS。

LineageOS 是一个纯净的系统，自身没有提供 Root 权限，所以要获取 Root 权限，我们还需要安装其他的东西。

Note

根据 LineageOS 文档和 XDA 论坛的说法，如果想要再刷其他的自定义系统，建议先刷回 Google 的出厂镜像，然后再按照一般方法刷入第三方镜像。

Magisk

Magisk 在刷机界大名鼎鼎，适配性比较好。本次我们选择的是 topjohnwu/Magisk，其他分支版本请自己探索。

Note

Magisk 不是唯一选择。你还有 KernelUS。
Apatch、SukiSU 等由 KernelUS 派生而来，同样是另外的选择。
注意 LineageOS 22 或者低 Linux 内核版本（老机型）可能无法安装 KernelUS 系。Magisk 系是更稳妥的选择。
比如，Google 从 Pixel 6 才开始引入 GKI 内核，而 KernelSU 就是基于 GKI 内核的。如果是非 GKI 内核，那么需要自行修改 Adnroid 源码并编译。

Warning

仅从官方 GitHub 页面下载 Magisk。

使用 Magisk 前，你需要获取当前系统的原版 boot.img/init_boot.img 文件。LineageOS 在下载页面提供了 boot.img，如果没有专门提供 boot.img 下载，则需要从刷机包中提取。

将提取好的 boot.img 文件传输到手机上，Magisk 首页点击 “安装” 按钮，选择 “选择并修补一个文件”，然后选择你刚刚传输的 img 文件，等待修补完成。

将修补后的文件传回电脑，使用 fastboot 刷入修补镜像。重启，就可以得到 Root 权限了。

你可能会用到的 ADB/Fastboot 命令：

之后除非重装 / 升级系统，否则可以直接使用 Magisk 应用升级 Magisk 修补镜像。

]]> https://blog.watermelonabc.top/p/58cd3450/ 2025-08-29T08:08:04.000Z 安卓逆向到最后，玩的就是系统 安卓刷机一点通 2026-08-16T13:26:53.000Z Watermelonabc 算法算法，离不开各种公式。我们坚信：只要解出这些公式，就可以得到 flag。

但计算机中的 “公式” 往往不会是简单的 x+y=2x+y=2 之类，而会是掺杂了算术、位向量、数据结构等。我们（判断能否）解出这些公式的过程，就是在判断这些公式的可满足性 (Satisfiability) 如何。

这里我们就提出了可满足性模理论 (Satisfiability Modulo Theories, SMT)：

  1. 给定一组理论 (Theory)，根据给定逻辑，求在该组理论解释下公式的可满足性
  2. 现有理论通常针对一阶理论，即公理都是一阶的
理论 Theory

从逻辑学角度来看，a+b<ca+b<c 或者 f(b)>cf(b)>c 都是逻辑系统中不包含的符号，计算机需要知道他们的意思，这就引出了理论的概念：

  1. 理论用于对这类符号谓词 / 函数（比如 >>，f(⋅)f(⋅)，++，...）赋予含义;
  2. 理论包含一组公理和这组公理能推导出的结论;

因此，如果想解决 SMT 问题，求解器就需要内置基本的理论。

公理都是一阶的

首先，Z3 内置的理论都是在一阶逻辑 (FOL, first-order logic) 下定义的，需要推的公理只使用这些一阶逻辑理论定义。
一阶逻辑的显著特点是只对对象变量（如 xx，yy 等）进行量化（全称量化 ∀ 和存在量化 ∃），没有对函数或谓词本身做量化，它们在这些理论中应当是固定的。一阶逻辑相对好求，因为对象集合离散且数量级较小，可以用 SMT 技术穷举。
二阶逻辑量化的是谓词/函数本身，这些谓词和函数在现有理论中是不固定的。二阶逻辑难求，因为它需要遍历所有可能的谓词/函数，数量级非常大，Z3 不支持这一类问题。

换句话说，一阶逻辑相当于数学考试中的 “求符合条件的 xx 的值”，二阶逻辑相当于 “求符合条件的函数 f(x)f{(x)}”

将程序算法当成一个 SMT 问题，我们便可以从正向破解它，并且相对于逆向的难度较小。Z3 就是一个高效的 SMT 求解器，具有专门用于解决一阶逻辑理论的算法。

Z3Py 入门

要使用 Python 的 Z3，请通过 pip 安装：

接下来我们解一个简单的二元一次方程：

1
2
3
4
5
from z3 import *x= Int('x')y= Int('y')solve(x > 2, y < 10, x + 2 * y == 7)

得到输出：

1
[y = 0, x = 7]

函数 Int('x') 用于在 Z3 中创建一个名为 x 的整数变量。solve 函数求解一个约束系统 (System of Constraints)。上面的例子使用了两个变量 x 和 y，以及三个约束 (Constraints)：

  1. x 必须大于 2

  2. y 必须小于 10

  3. 当 x 加上 y 的两倍时，它必须等于 7

约束就相当于考试中的条件和公式。

Z3Py 和 Python 一样使用 = 进行赋值，使用运算符 <、<=、>、>=、== 和 != 进行比较。

接下来，我们将介绍 Z3 Solver 的一些特性。

表达式属性

1
2
3
4
5
6
7
8
9
x = Int('x')y = Int('y')n = x + y >= 3print ("num args: ", n.num_args())print ("children: ", n.children())print ("1st child:", n.arg(0))print ("2nd child:", n.arg(1))print ("operator: ", n.decl())print ("op name:  ", n.decl().name())

输出：

1
2
3
4
5
6
num args:  2children:  [x + y, 3]1st child: x + y2nd child: 3operator:  >=op name:   >=

n 注册了一个表达式类，通过类 n 提供的方法，我们可以得到表达式的参数、子式（左右两边的式子）和比较运算符信息。

基本数学运算

Z3 提供所有基本的数学运算。Z3Py 使用与 Python 语言相同的运算符优先级。[1]

Z3 内置的整数算术是 Presburger 算术，只完备支持加减法、乘常数和比较运算。

Z3 基本数学运算支持与完备性速查表

Note

本表由 GPT-5 生成
本表基于 Z3Py 与 SMT-LIB2 标准，标明完备性（✅ 完备 / ⚠️ 部分完备 / ❌ 不完备）。

  • ✅ 完备：Z3 在相应理论（如 LIA/LRA）下可保证可判定且一定返回 SAT/UNSAT。
  • ⚠️ 部分完备：Z3 尝试求解，但可能返回 unknown。
  • ❌ 不完备 / 不支持：Z3 无内置语义，需人工编码或近似化。

参考

  1. 通用 (LIA / LRA)
Z3PySMT-LIB2含义完备性
++加法✅
--减法 / 取负✅
**乘法（线性，有一个是常量）✅
//实数除法✅
<, <=<, <=小于 / 小于等于✅
>, >=>, >=大于 / 大于等于✅
==等式✅
Distinct(a,b,c)distinct两两不等✅
  1. 整数专用 (LIA / LIA+mod)
Z3PySMT-LIB2含义完备性
IntDiv(x, y)div整数除法（向零取整）✅
x % y / Mod(x, y)mod取模（符号与被除数相同）✅
Abs(x)abs绝对值✅
ToReal(x)to_realInt → Real 转换✅
ToInt(x)to_intReal → Int 转换（向零取整）✅
is_int(x)is_int检查实数是否是整数值✅
  1. 常量与类型装换
Z3PySMT-LIB2含义
IntVal(n)numeral整数常量
RealVal(r)numeral实数常量
  1. 不属于基本运算的运算（非线性 / 超越）
运算例子完备性备注
非线性乘法x*y⚠️两个算子都属于变量
幂运算（常数指数）x**2⚠️属于非线性算术，可求但不完备
幂运算（变量指数）x**y❌一般不可判定
平方根 / 开方sqrt(x)⚠️/❌需编码为幂运算
三角函数sin(x)❌不支持内置语义
对数 / 指数函数log(x) / exp(x)❌不支持内置语义
其他超越函数—❌不支持

布尔逻辑运算

Z3 支持布尔运算符：与 (And)、或 (Or)、非 (Not)、蕴含 / 充分条件 (Implies)、如果 (If)。双蕴含（即充要条件）使用等号 (==) 表示。

常 / 变量表示

一阶逻辑公式由项（变量或常量）与扩展布尔结构组成。变量在 Z3 中可表示为：

1
2
3
4
5
6
7
x = Int(name = 'x') # x is an integery = Real(name = 'y') # y is a real numberz = BitVec(name = 'z', bv = 32) # z is a 32-bit vectorp = Bool(name = 'p') # p is a bool
Tip

这里可以忽略掉 name 和 bv，直接写参数，如 BitVec('z', 32)

在 Z3 中，Int 类型使用的是数学上的 “整数” 概念，这和我们在计算机中有范围的 int 类型不一样。如果需要指定类型可以表示的数字大小，请使用 BitVec，如 BitVec('x', 32) 表示一个 32 位位向量，就相当于我们在计算机中使用的 int。

我们建议，如果想要声明 “整数” 变量，请使用 Int 而不是 BitVec 以避免截断导致的精度问题。

整型与实数类型变量之间可以互相进行转换：

1
2
3
ToReal(x)ToInt(y)

Z3 也支持序列的表示：

1
2
3
4
5
flag = [BitVec('x%d' % i, 8) for i in range(32)] # a char array, like `char flag[32]` in Cflag = [Int('%d' % i) for i in range(32)] # an 'integer' arrayflag = [BitVec('x%d' % i, 32) for i in range(32)] # an int array, like `int flag[32]` in C
Tip

BitVec('x%d' % i, 8) 应该这样理解：%d 对应循环计数器 i，本句实际上在创建从 x0 到 x31 的数个 8 位符号位向量。
这种方式声明的序列，在添加约束时应该调用 flag[i]，默认输出 x<i> = ...

对于常量，除了 Python 原有的数据类型外，也可以用 Z3 自己的数据类型表示：

1
2
3
4
5
6
7
8
9
10
11
>>> IntVal(val = 114514) # integer114514>>> RealVal(val = 1919810) # real number1919810>>> BitVecVal(val = 1145141919810, bv = 32) # bit vector，自动截断2680619074>>> BitVecVal(val = 1145141919810, bv = 64) # bit vector1145141919810

Z3 中的布尔常量用 True 和 False 表示。

求解器

如果只有公式（约束）较少，那我们调用 solve 方法就好，但有时我们会有大量约束，单行命令易读性就很差了。此时需要创建一个求解器类 Solver，一行一行地将约束添加进去。所以，求解器是一群约束的集合。

1
s = Solver()

现在我们创建了一个求解器实例 s，需要用 add 方法向这个求解器添加约束：

1
2
s.add(x * 5 == 10)s.add(y * 1/2 == x)

添加约束之后，我们可以调用 check 方法检查约束是否可满足 (satisfiable)。如果返回 sat 即为 “可以满足”，unsat 即为 “不可满足”。

如果约束可以满足，则我们可以调用 model 方法得到一组解。

如果需要输出结果（包括满足性情况），注意使用 print 函数。

Note

之前示例中使用的 solve 方法是通过 Z3 求解器 API 实现的。当你调用 solve 时，Z3 会帮你创建一个临时的求解器，将约束传入，检查是否满足并输出结果。可以将 solve 方法简单理解为 check、model 和 print 的一次性封装。

一个求解器示例：

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
from z3 import *flag = [Int('s[%d]' % i) for i in range(6)]s = Solver()# a1[2] - a1[3] == 0x84A236FFLL#     && a1[3] + a1[4] == 0xFA6CB703LL#     && a1[2] - a1[4] == 0x42D731A8#     && *a1 == 0xDF48EF7E#     && a1[5] == 0x84F30420#     && a1[1] == 0x20CAACF4s.add(flag[2] - flag[3] == 0x84A236FF)s.add(flag[3] + flag[4] == 0xFA6CB703)s.add(flag[2] - flag[4] == 0x42D731A8)s.add(flag[0] == 0xDF48EF7E)s.add(flag[5] == 0x84F30420)s.add(flag[1] == 0x20CAACF4)if s.check() == sat:    m = s.model()    print(m)else:    print("No solution")

运行后输出：

1
2
3
4
5
6
[s[4] = 2652626477, s[2] = 3774025685, s[0] = 3746099070, s[1] = 550153460, s[5] = 2230518816, s[3] = 1548802262]

  1. Python 运算符 ↩︎

]]> https://blog.watermelonabc.top/p/975d5fe4/ 2025-08-12T10:05:58.000Z 我们一起解方程！ Z3-Solver 教程 2026-08-04T09:53:11.000Z