可是，博客的域名买了十年，服务器也一直续费着，总不更新吧感觉有点浪费。因此还是抽空来灌水一番。本次灌水的主题自然是时代的宠儿：大模型。本文纯意识流输出，甚至都没用 AI 润色，可放心阅读。

The Good

大模型，确实算得上划时代的创新。有人质疑 LLM 只是 next token predictor，没有真正的“智能”，有人觉得模型幻觉严重胡说八道。但不可否认的是，LLM 确实对生产力带来了极大提升。

在 Coding 领域自不用说，我已经记不得上一次打开 IDE 是什么时候了，现在使用 coding agent 几乎能完成绝大多数编程任务 。当然我个人更多是编写小型的工程以及脚本，可即便对于大型项目也是成立的，无非是需要合适的上下文、规约和模块化。当然开发者还是要知道 Agent 的能力上限，不要指望于一句“给我写个淘宝”就能完成所有任务。

在笔者的网络安全领域，LLM 更是一往无前。漏洞分析、漏洞挖掘、逆向工程，不能说有手就行吧，那也是手到擒来。最近一次直接把一个 Mac App 仍给 Agent，什么工具都不给，让他去自己分析，可以生成近乎完美的报告。当然现在在漏洞利用上模型还有点吃力，但是按照能力曲线来看，覆盖也是迟早的事，只不过这里因为 LLM 厂商价值观对齐的关系普通安全研究员想要顺畅使用可能还有点难度，现在简单越狱可以解决，但未来的安全限制肯定是越来越多的。

在当下这个时间点，如果还有人看不上或者质疑 LLM 的能力，那跟旧时代骑马的人对汽车吹毛求疵是差不多的。LLM 也许是潮流，也许是洪流，也许是泥石流，但无论如何身在其中不可避免地会被裹挟着前进。LeetCode 完蛋了，StackOverflow 完蛋了，CTF 也完蛋了，应该不会还有老资历在抱守残缺吧？

大模型的优点大家都能体会到，这里也就不多说了，下面还是说说缺点。

The Bad

大模型优点很多，缺点自然也不少。

首先我能想到的就是——“安全对齐”，对于模型厂商而言这是“优点“，对于我而言则是妥妥的缺点。作为一个向往自由软件的安全研究员，面对一个模型不能提供 PoC，不能写漏洞利用，不能这个也不能那个（”抱歉，即便是出于学习目的也不行“），用起来着实有点难受。那位说了，你可以用一些 RolePlay Trick 来让他做这个，但这只是权宜之计，未来安全限制必定越来越严格，越是 SOTA 的模型越难以越狱；那位又说了，你可以用 HF 上的 abliterated 模型啊？这确实是一个方向，可仅限于开源模型，对于第一梯队的模型是体验不到的。安全对齐是给模型圈定的牢笼，对于大部分人也许是有益的，但对于我们搞网络安全的来说，又是另一回事了。

其次就是大模型的不确定性。这算是笔者日常工作的一个痛点。在把自动化任务 Agent 化之后，冒烟测试没什么问题，可一到线上就开始作妖了。比如在 system prompt 中定义了 1/2/3/4 个规则，比如规定输出格式、验证方法等（互相并没有冲突），有时 Agent 跑着跑着就忘了其中一个或者两个，这时只能在 system prompt 中强调一下，这里加一个 “IMPORTANT"，那里加一个 “MUST MUST MUST”，最后把提示词搞的乱七八糟，线上也还是不能保证 100% 稳定。面对这种问题要么只能使用确定性的 workflow，要么就只能使用更聪明也更昂贵的模型。

还有正如前面提到的，大语言模型的本质是 Token 预测机，有时面对一些简单的问题比如 “Strawberry 里有几个 r” 或者 “?=9.4-9.11” 都能算错，因为 LLM 看不到 token 以外的东西，而且推理引擎也没有端到端的计算能力。这些 case 当然都有很多 workaroud，但也只是缝缝补补。

最近又有很多公司新增所谓 “Token 事业部”，但是在我看来当前的 LLM 实现只是通往 AGI 路上的一个局部最优解，甚至有时候我都怀疑这是不是三体人给我们设置的绊脚石，来消耗地球算力以阻止延缓真正的 AGI 发生。也许是我杞人忧天了，但基于 Token 的预测确实存在各种局限性，在使用 LLM 的时候不要忘记这一点。

The Ugly

关于大模型，好的坏的都说了，也许还有一些没想到的等以后有时间再说。现在来说说——人。

最近一段时间虽然我没更新 blog，但是我也没闲着，一直在深度使用 LLM 也一直在观察别人使用 LLM。说得好听点是八仙过海各显神通，说得难听点那就是魑魅魍魉群魔乱舞。

首当其冲的是 AI Slop。我已经看过了太多太多 AI 文章、review 了太多 AI 代码，以至于现在一闻到味就上头。以前虽然也有水文章的人，但是水个千八百字也是有时间成本的，现在则动不动就万字长文，直接把 deep research 的结果复制粘贴进来，觉得我不会用豆包还是不会上网？LLM 让“内容”变得廉价，但是深度的内容则更加稀缺。我只能说文字也是有感情的，一篇敷衍的 AI Slop 和一篇真正深度研究过的人写出来的东西感觉完全不同。

还有 AI 代码。我承认自己写很爽，但是别人写了 pull request 给我就是另一回事了。一开始我还认真检查，看着看着发现怎么把我的 json.loads 改成了 regex，好家伙用正则来解析 JSON，也确实能跑通测试，只能说又让我体内的杀神封印松动了一点。 Vibe Coding 的最佳归宿还是单兵作战，不然协作维护起来太费劲了。即便如此也难以保证长期的维护性，从前需要经年累月才能构造的屎山代码，现在只需要一个 codingplan。

在 LLM 普及的当下，只要不是太难的任务，都可以借助 Agent 完成。这导致大家有种莫名的自信，仿佛握着 ClaudeCode 就能拳打南山敬老院，脚踢北海幼儿园。这是个奇妙的时代，一个新手就可以挖出某通用软件高危漏洞，然后给漏洞起个名字，gpt-image-2 生成一个 logo，再 Vibe Coding 一个网页，就把自己包装成了一个“全球顶尖”的研究团队。之前某公司高管说，大模型时代要更加努力，“潮水退去才会发现谁在裸泳”（大意），不过我看正好相反，这是个裸泳的好时代，只要胆子大，完全可以游到浪潮之巅。

总结

好的，我直接说人话，给你最直白、最简单、最正确的总结。这是一篇充满作者主观感受的废话文字，描述了作者认为关于 LLM(Large Language Model) 的优点和缺点，需要我为你补充更多大语言的信息吗？

本文没有特别新颖的观点，只是发表了一些自己的看法。一方面在互联网留下自己的回声，在预训数据集中留下自己的痕迹；另一方面，我觉得在 LLM 时代还是要有一些自己的思考，等哪天大模型不再能稳稳地接住你的时候，也不至于摔得太痛。

版权声明: 自由转载-非商用-非衍生-保持署名 (CC 4.0 BY-SA)
原文地址: https://evilpan.com/2026/05/29/llm-slops/
微信订阅: 『有价值炮灰』
– TO BE CONTINUED.

不知不觉已经三个月没有更新博客了。其实技术文档一直在更新，不过由于各种原因一直躺在私有的 Obsdian 仓库里。要么是因为保密的原因不便公开，要么是自我感觉没有新意不值一提。回想起早些年刚接触网络安全的时候，对什么方向都充满激情，充满好奇，只要能学到一点新知识就会写篇博客进行记录和分享。现在动笔就要考虑颇多，已经少了很多当年的乐趣。

凛冬的寒风

众所周知今年的经济环境欠佳，寒气已经确实地传递给了每一个人。笔者作为某甲方企业的安全研究岗，也逐渐感受到了氛围的变化。说起安全研究，很多人以为是挖漏洞、写利用，其实研究包括很多方面。《黑客与画家》中说到，“优秀的设计不一定是新的，但一定是好的；优秀的研究不一定是好的，但一定是新的”。所以安全研究也会极力探索前言新兴的领域，比如可信计算、区块链、星链等等，这也曾经是笔者的部分研究内容。

这样的研究方向可想而知在以盈利为目标的企业中处于多么尴尬的境地。在经济环境欣欣向荣的时候，大家都一起高歌猛进，开疆拓土，也倒不会注意到我们这部分“闲人”。毕竟安全研究产出的论文、安全比赛或者国际安全会议议题也确实在一定程度上提升了企业的安全感。

随着经济环境下行，企业也逐渐开始关注起了人力资源的效率。“岗位称重”、“收紧队形”、“逃逸平庸的重力”，等等一系列金句被提出，字里行间确切地透露出一股寒气。

群鸦的盛宴

对于大多数企业而言，都是“业务先行，安全兜底”。尤其是在经济环境萧条的情况下，保持盈利、维持现金流是很多企业的要务之一。但其实不论在什么阶段，只要企业还在正常运转，就一定需要安全团队的支撑。加上国家监管对于企业安全的硬性要求，不到万不得已，一般也不会对安全岗位动刀。

不过，在这个时代什么事情都有可能发生。一方面企业可能出于侥幸心理削减了安全团队，另一方面则是出于简单的利益权衡——出事之后的损失加监管的处罚支出，小于供养安全团队的成本，那么在线上裸奔也是划算的。大不了加强一下法务和公关团队，只要把提出问题的人消灭掉，那就没有问题了。

在这种情况下，流失的安全团队成员对企业愤愤然，既存的安全从业者也人心惶惶。不管红队蓝队，都不免做出“一颗红心，两手准备”的规划。也许在阳光下大家还觉得一切稳中向好，但地下早已经暗流涌动，技术攻防的复杂度和专业度也不断地水涨船高。

来源: 奇安信威胁情报中心: 揭秘LIVE勒索软件利用IP-Guard漏洞的技战术

相比于早年使用 QQ 号留名或是用微信支付来收赎金的脚本小子，现今新闻中爆出的网络恶性事件背后出现了更多的专业技术人员身影，也许未来很长一段时间将会是国内赛博空间的常态。

魔龙的狂舞

当然，这只是一般安全从业者可能卷入的情境。对于安全研究员而言，情况又有所不同。首先研究方向脱虚向实，太超前的研究就不鼓励投入了。于是部分研究员又回到了老本行 —— 挖漏洞。不管是企业内部漏洞还是外部竞对、HW 漏洞，都是看得见摸得着的“产出”。另一方面，对于安全研究员自身而言，挖漏洞本身也是自己在职业中立足的一种重要方式。

早期许多甲方企业乐意供养着安全实验室去进行研究，企业得名，员工得利，皆大欢喜。随着寒气入体，老板们渐渐发现徒得虚名好像也没什么大用，Pwnnie Awards？听起来还不如 Gartner “领军者” 霸气呢！于是天x杯也不建议参加了，Blackhat 的机票也不报销了，安全研究员也要开始研究起自己的饭碗了。

或主动或被动，企业中安全研究终究会调整重心，要么为业务保驾护航，要么就直接躬身下场接客，把自己变成商业化的业务。这其中免不了会有人心生不满，毕竟大家都不喜欢变化。从前拿 bounty 讲议题还有公司的激励，现今 bounty 要抽水议题要自费还要担心被网信办鉴定为间谍。因此，一部分优秀的研究员就开启了 Anonymous 之路，以匿名的方式提交漏洞报告；另一部分就经常对着某logo 是纸飞机的社交软件交流。

毕竟安全研究员能卖的就只有 0day 了。如果遇到靠谱的中间人牵线搭桥，一些危险的 0day 也许能找到它们合适的归宿，某种程度上还为国家安全做出了贡献；倘若遇人不淑，也有可能流入到敌对势力，出现不愿看到的受害者，同时也将自己至于危险的境地。

当然，买卖漏洞是不对的，而且是非法的。但是昔日极客变成了骇客，昔日的勇者变成了恶龙，谁又有能力去限制它们呢？

初春的遐想

最后我想引用一句俗套的话：“道路是曲折的，前途是光明的”。现在确实是行业的寒冬，但冬天总会过去，春天终将到来。在当前，作为安全研究员也许暂时脱离了一线研究，但依然可以在安全行业中磨练基本功，同时也不要失去对未知的好奇和热情，也许在脱离企业的场景也能更好地审视自己的选择以及研究方向的价值。

在这里我也想呼吁有关部门能够真正重视网络安全建设，让更多白帽子和安全从业人员能够通过合法、正常的渠道发光发热，真正为社会和国家的网络安全做出贡献。同时，我希望有一天中国也能够开展类似于 hack DoD 的众测项目，也希望中国的 NSA 主任也能够以幽默的方式回复我的微博调侃，而不是直接被来总夹掉。

当然，这也只是遐想罢了。

LINKS

• Selling 0-Days to Governments and Offensive Security Companies (Video)
• Update About the 0-day Industry (中文翻译: 关于0-day数字军火行业)
• The offensive cybersecurity industry — trends and updates (中文翻译: 数字军火行业的兴衰及调整 - 趋势与更新)

版权声明: 自由转载-非商用-非衍生-保持署名 (CC 4.0 BY-SA)
原文地址: https://evilpan.com/2024/02/10/winter-is-here/
微信订阅: 『有价值炮灰』
– TO BE CONTINUED.

一篇零散的总结，记录了今年的安全研究感悟。

题图: cyberpunk girl @toraji

工作

这一年的工作重心跟着团队的方向调整，从业务安全转向了安全研究。说起安全研究，很多人想到的就是分析漏洞、挖漏洞，写利用。当然这是其中一个领域，安全总是和漏洞有着千丝万缕的联系，但漏洞只是一个结果，而研究本身则包含更多。

在企业里搞研究其实是有点尴尬的。本来安全团队在企业里就是不产生效益的边缘支撑角色，忙时救火，闲时背锅；其中安全研究又是边缘中的边缘，每天搞些稀奇古怪的玩意，也不知道有什么用。最重要的是，对于老板而言，没有很好的方式去量化研究性工作的价值。

安全研究体现成果分为两部分，一部分对外，主要包括刷漏洞/致谢，写技术分析文章提高影响力或者写PR文章提高曝光度；另一部分对内，但业务方向本身也有自己的局限性。优秀的设计不一定是新的，但一定是好的；优秀的研究不一定是好的，但一定是新的。正因为如此，在企业中做安全研究有点像是《进击的巨人》中的调查兵团，不仅吃力不讨好，而且经常死在半路上。毕竟大家面临的都是一片荒芜未知，无人之境，一条路走到黑还是及时止损？俗话说，行百里者半九十，掘井九仞犹为弃井，很可能放弃早了就错过了真正有价值的收获。

既然作为一项工作，就总得有产出吧？不管是 KPI 还是 OKR，总会需要一个能够量化结果的指标。优胜劣汰是社会不变的法则，这没什么好说的，只不过任何评价指标都是一把双刃剑，在指标的压力下很容易让人只关注结果。比如漏洞挖掘本身是寻找安全问题，但是指标关注的是漏洞数量而不是漏洞品相，就可能会导致很多人把软件 Bug 当做漏洞提交。一旦只追求结果，人就容易想方设法抄近路，在抄近路的过程中，人又容易迷失真相，做事的干劲也会逐渐消磨殆尽。

安全研究

虽然有很多槽可以吐，但做一行就得做好，因此时常也在想如何才能做好安全研究。鉴于研究二字本身就包含了不可预知的投入，所以目标是很重要的。没有人能告诉你这个方向能不能做，即便有也是站在他们自己的角度，可能并不适用于你。

套用学术界做研究的四阶段:

• 第一阶段，在导师指定的领域去做，不用考虑方向，只需要把事情做到极致；
• 第二阶段，自己找一些方向，然后在导师的建议下筛除一些，最后选定一个方向去做出研究成果；
• 第三阶段，自己去探索方向，自己去判断哪些可做，并且在自己选定的方向有研究成果，这一阶段完全独立完成，不需要导师的参与，因为比你了解这些领域的人不多了；
• 第四阶段，带着第一阶段的人，指引他们去做出自己的研究成果，也就是让自己成为导师。

不过社会和学校的一大不同是，很少有一个那么合适的导师，大部分人都是自学成才，这也是安全研究和学术研究的一大不同。漏洞本身是跟随着系统实现的变化而变化的，而实现又是偏工程化的领域，所以对于安全研究，我更赞同一句话:

Hack to learn, not learn to hack.

知识是无穷尽的，且不说最新的子领域论文一篇接一篇，教材、书籍、文档加起来也够消化一阵。曾经我就淌过这坑，之前在研究蓝牙安全的时候，硬是啃了一个星期的蓝牙核心协议文档，几千页的英文pdf，学到东西了吗？学到了，但是十分有限。从结果而言，还不如直接看 bluez/bluedroid 的代码或者 wireshark 抓包分析理解更深刻。这类的抉择有很多，比如研究 USB，是否需要先把 RFC 看完；想做 ARM 逆向，是否要先把 Cortex 的文档看完，……其实需要的时候再看具体章节即可。

保持克制

前面说到，在研究中找到合适的方向是很重要的一环，但这并不是一件简单的事。实际工作中随着研究的深入，会发现在某些关键点经常碰壁，以至于怀疑这个方向是不是没有搞头。如果正巧这时又有了别的新点子或者新想法，就会有强烈的冲动去换个方向。

这是人之常情，重要的是如何在这种情况下保持理智和专注。有人说真正有追求的人应该选择去挑战那些崇山峻岭，但高山不是一两天可以征服得下来的，甚至不是一两周、一两个月、一两年，……在这个过程中，不可避免地会陷入自我怀疑。要么怀疑自己的能力，要么怀疑自己的选择。

为了避免这种情况，就需要仔细再仔细地挑选目标。人们通常认为专注是对某件需要专注的事情说“好”，但事实并非如此。专注意味着对其他一百个好想法说“不”。

安全研究不是请客吃饭，不能东挖一铲子西挖一铲子。对于打工人而言，时间是尤其宝贵的。这一铲子下去，需要确保有足够的东西出来，要么是足够多的成果，要么是足够多的乐趣。下手之前做好长期坚持坐冷板凳的准备，下手之后就心无旁骛，全力以赴。

保持开放

对于安全研究人员而言，还有很重要的一点是保持开放，不要给自己设限。那位说这不是跟 ”保持克制“ 矛盾了吗？不错，确实是有点矛盾，或许作家协会可以考虑给我颁个矛盾文学奖。但矛盾是无所不在的，我们需要做的是在其间找到一个合适的平衡点。

举例来说，作为一个安全专家，女朋友电脑卡了让你看下，结果你说: “我是搞 Linux 安全的，Windows 我不懂，要不你重装个 CentOS”，—— 这显然不太合适。在研究中总会遇到一些全新的领域，其中某些会发展为未来的主流，有些会随着时代消逝，关键是保持开放的心态，不要把自己限制在狭隘的一个子领域中。

至于怎么选择，笔者认为可以参考自动化法则:

自动化法则: 如果某件事情手工做了三次，那么就应该写个脚本去进行自动化

也就是说，如果在研究中遇到在某个问题卡壳了三次，那么就应该花时间去深入探索。比如在研究 Linux 内核漏洞利用时经常遇到 NUMA node 的疑问，那么就值得花时间了解其原理和实现。这些点在当前上下文也许可以选择性忽略，但自己心里清楚，如果我从这里逃走，困难会在别的地方等着我。同时，让自己保持探索，也是避免思维陷入僵局好方法之一。

最后

2020年是忙碌的一年，曾经如饥似渴地学习各种知识，也曾经摆脱束缚放飞自我。不过最终还是摸索出了自己该走的路，关键在于权衡和取舍。一方面要保持克制，避免陷入知识的诅咒；另一方面要保持开放，避免自己固步自封。啰嗦了那么多，权当是作为自勉吧。

尝试不用电脑，只拿一台iPhone去参加看雪CTF2020 (娱乐向)

视频地址: https://www.bilibili.com/video/BV1Da4y1p7F3

背景

最近 iSH 在 Apple Store 上架了，之前一直抢不到 testflight 的配额，难得强管控的苹果会让这种 Terminal 类的应用发布，所以第一时间下载来玩玩。测试之后发现可以当做是一个简单的 Linux 虚拟机，至少常用的命令都没什么问题，正好看到看雪论坛有个 CTF，于是就试一下，能不能用手机来打一局 CTF :)

环境

iSH 是一个开源的 Terminal Emulator，在 iOS 中运行，使用用户态的 x86 指令模拟以及 syscall 翻译实现。iSH 中使用的是 Alphine Linux 镜像，用过 Docker 的应该都不会陌生。Alphine 是个非常轻量级的 Linux 发行版，在官网上可以直接下载各个平台预编译的镜像，平时有测试内核需求又不满足于 ramfs 的可以使用下载的镜像进行方便测试。

在 iSH 中已经有了一个简单的 Alphine 环境，可能是是因为苹果商店审核的原因，在其中并没有预置包管理工具。我们可以下载一个完整的 iso 重新挂载，但是有更简单的方法，直接从 Alphine Packages 中下载静态编译版本的 apk-tools-static:

wget http://dl-cdn.alpinelinux.org/alpine/latest-stable/main/x86/apk-tools-static-2.10.5-r1.apk
tar -zxvf apk-tools-static-2.10.5-r1.apk
./sbin/apk.static -X https://mirrors.tuna.tsinghua.edu.cn --initdb add apk-tools
apk update
rm -rf ./sbin

我们用下载的 apk-tools-static 来安装 apk-tools，然后包管理工具 apk 就可以正常使用了。如果初始化的时候没有指定镜像源，可以使用下面的命令修改为清华大学的镜像源，加快国内的访问速度:

sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories

之后需要的工具就可以自行安装了，我这里只需要 radare2 和 Python:

apk add radare2
apk add python3

题目是看雪 CTF2020 的签到题: https://ctf.pediy.com/game-season_fight-158.htm

Write Up

解题过程在文章开头的视频中已经可以看到了，这里还是用文字介绍下解题思路。

首先 rabin2 查看目标程序的信息:

$ rabin2 -I kctf2020.exe
arch     x86
baddr    0x140000000
binsz    12288
bintype  pe
bits     64
canary   false
retguard false
class    PE32+
cmp.csum 0x0000bcb6
compiled Thu Nov 12 03:49:32 2020
crypto   false
dbg_file D:\Users\admin\Documents\Visual Studio 2015\Projects\ctf2020\ConsoleApplication1\x64\Release\ConsoleApplication1.pdb
endian   little
havecode true
hdr.csum 0x00000000
guid     4EF50FB8F5E74CC481D01589FC111B1A1
laddr    0x0
lang     c
linenum  false
lsyms    false
machine  AMD 64
maxopsz  16
minopsz  1
nx       true
os       windows
overlay  false
cc       ms
pcalign  0
pic      true
relocs   false
signed   false
sanitiz  false
static   false
stripped false
subsys   Windows CUI
va       true

可以看到是 PE64 的的程序，鉴于是签到题，所以就直接逆向分析了:

$ r2 kctf2020.exe
 -- 💺
[0x14000154c]> s main
[0x140001000]> af
[0x140001000]> pd 20
            ;-- section..text:
┌ 459: int main (int argc, char **argv, char **envp);
│ bp: 7 (vars 7, args 0)
│ sp: 14 (vars 14, args 0)
│ rg: 0 (vars 0, args 0)
│           0x140001000      4055           push rbp                   ; [00] -r-x section size 8192 named .text
│           0x140001002      488dac24c0fe.  lea rbp, [rsp - 0x140]
│           0x14000100a      4881ec400200.  sub rsp, 0x240
│           0x140001011      488b05e82f00.  mov rax, qword [section..data] ; [0x140004000:8]=0x2b992ddfa232 ; "2\xa2\xdf-\x99+"
│           0x140001018      4833c4         xor rax, rsp
│           0x14000101b      488985300100.  mov qword [var_130h], rax
│           0x140001022      33d2           xor edx, edx
│           0x140001024      488d4c2430     lea rcx, [var_30h]
│           0x140001029      41b800010000   mov r8d, 0x100             ; 256
│           0x14000102f      e8ce0e0000     call 0x140001f02
│           0x140001034      33d2           xor edx, edx
│           0x140001036      488d4d30       lea rcx, [var_bp_30h]
│           0x14000103a      41b800010000   mov r8d, 0x100             ; 256
│           0x140001040      e8bd0e0000     call 0x140001f02
│           0x140001045      488d0dd42100.  lea rcx, str.KCTF_2020     ; 0x140003220 ; "KCTF 2020!\n"
│           0x14000104c      e8ff010000     call 0x140001250
│           0x140001051      488d0dd82100.  lea rcx, str.http:__bbs.pediy.com ; 0x140003230 ; "http://bbs.pediy.com\n"
│           0x140001058      e8f3010000     call 0x140001250
│           0x14000105d      488d0de42100.  lea rcx, str.Please_input_your_flag: ; 0x140003248 ; "Please input your flag: "
│           0x140001064      e8e7010000     call 0x140001250

在 0x140001250 地址处经常有调用，根据参数可以猜测是打印函数，验证一下:

[0x140001000]> s 0x140001250
[0x140001250]> af
[0x140001250]> pdf
            ; CALL XREFS from main @ 0x14000104c, 0x140001058, 0x140001064, 0x14000119b, 0x1400011ab
┌ 85: int printf (const char *format);
│           ; var int64_t var_20h_2 @ rsp+0x20
│           ; var int64_t var_8h @ rsp+0x50
│           ; var int64_t var_10h @ rsp+0x58
│           ; var int64_t var_18h @ rsp+0x60
│           ; var int64_t var_20h @ rsp+0x68
│           ; arg int64_t arg1 @ rcx
│           ; arg int64_t arg2 @ rdx
│           ; arg int64_t arg3 @ r8
│           ; arg int64_t arg4 @ r9
│           0x140001250      48894c2408     mov qword [var_8h], rcx    ; arg1
│           0x140001255      4889542410     mov qword [var_10h], rdx   ; arg2
│           0x14000125a      4c89442418     mov qword [var_18h], r8    ; arg3
│           0x14000125f      4c894c2420     mov qword [var_20h], r9    ; arg4
│           0x140001264      53             push rbx
│           0x140001265      56             push rsi
│           0x140001266      57             push rdi
│           0x140001267      4883ec30       sub rsp, 0x30
│           0x14000126b      488bf9         mov rdi, rcx
│           0x14000126e      488d742458     lea rsi, [var_10h]
│           0x140001273      b901000000     mov ecx, 1
│           0x140001278      ff150a1f0000   call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll___acrt_iob_func] ; [0x140003188:8]=0x3a98 reloc.api_ms_win_crt_stdio_l1_1_0.dll___acrt_iob_func
│           0x14000127e      488bd8         mov rbx, rax
│           0x140001281      e8baffffff     call fcn.140001240
│           0x140001286      4533c9         xor r9d, r9d
│           0x140001289      4889742420     mov qword [var_20h_2], rsi
│           0x14000128e      4c8bc7         mov r8, rdi
│           0x140001291      488bd3         mov rdx, rbx
│           0x140001294      488b08         mov rcx, qword [rax]
│           0x140001297      ff15e31e0000   call qword [sym.imp.api_ms_win_crt_stdio_l1_1_0.dll___stdio_common_vfprintf] ; [0x140003180:8]=0x3aaa reloc.api_ms_win_crt_stdio_l1_1_0.dll___stdio_common_vfprintf
│           0x14000129d      4883c430       add rsp, 0x30
│           0x1400012a1      5f             pop rdi
│           0x1400012a2      5e             pop rsi
│           0x1400012a3      5b             pop rbx
└           0x1400012a4      c3             ret

果然是打印函数，直接重命名一下，清爽一些:

[0x140001250]> af printf
[0x140001250]> s-
[0x140001000]> pd 20
            ;-- section..text:
┌ 459: int main (int argc, char **argv, char **envp);
│ bp: 7 (vars 7, args 0)
│ sp: 14 (vars 14, args 0)
│ rg: 0 (vars 0, args 0)
│           0x140001000      4055           push rbp                   ; [00] -r-x section size 8192 named .text
│           0x140001002      488dac24c0fe.  lea rbp, [rsp - 0x140]
│           0x14000100a      4881ec400200.  sub rsp, 0x240
│           0x140001011      488b05e82f00.  mov rax, qword [section..data] ; [0x140004000:8]=0x2b992ddfa232 ; "2\xa2\xdf-\x99+"
│           0x140001018      4833c4         xor rax, rsp
│           0x14000101b      488985300100.  mov qword [var_130h], rax
│           0x140001022      33d2           xor edx, edx
│           0x140001024      488d4c2430     lea rcx, [var_30h]
│           0x140001029      41b800010000   mov r8d, 0x100             ; 256
│           0x14000102f      e8ce0e0000     call 0x140001f02
│           0x140001034      33d2           xor edx, edx
│           0x140001036      488d4d30       lea rcx, [var_bp_30h]
│           0x14000103a      41b800010000   mov r8d, 0x100             ; 256
│           0x140001040      e8bd0e0000     call 0x140001f02
│           0x140001045      488d0dd42100.  lea rcx, str.KCTF_2020     ; 0x140003220 ; "KCTF 2020!\n"
│           0x14000104c      e8ff010000     call printf                ; int printf(const char *format)
│           0x140001051      488d0dd82100.  lea rcx, str.http:__bbs.pediy.com ; 0x140003230 ; "http://bbs.pediy.com\n"
│           0x140001058      e8f3010000     call printf                ; int printf(const char *format)
│           0x14000105d      488d0de42100.  lea rcx, str.Please_input_your_flag: ; 0x140003248 ; "Please input your flag: "
│           0x140001064      e8e7010000     call printf                ; int printf(const char *format)

同理，把 scanf 也重命名上，先看程序开头的逻辑:

│           0x140001069      41b800010000   mov r8d, 0x100             ; 256
│           0x14000106f      488d542430     lea rdx, [var_30h]
│           0x140001074      488d0de92100.  lea rcx, [0x140003264]     ; "%s"
│           0x14000107b      e860010000     call scanf                 ; int scanf(const char *format)
│           0x140001080      488d542430     lea rdx, [var_30h]
│           0x140001085      4883c9ff       or rcx, 0xffffffffffffffff
│           0x140001089      0f1f80000000.  nop dword [rax]
│       ┌─> 0x140001090      48ffc1         inc rcx
│       ╎   0x140001093      803c0a00       cmp byte [rdx + rcx], 0
│       └─< 0x140001097      75f7           jne 0x140001090
│           0x140001099      83f90c         cmp ecx, 0xc               ; 12
│       ┌─< 0x14000109c      0f8502010000   jne 0x1400011a4
│       │   0x1400010a2      807c243066     cmp byte [var_30h], 0x66
│      ┌──< 0x1400010a7      0f85f7000000   jne 0x1400011a4
│      ││   0x1400010ad      807c24316c     cmp byte [var_31h], 0x6c
│     ┌───< 0x1400010b2      0f85ec000000   jne 0x1400011a4
│     │││   0x1400010b8      807c243261     cmp byte [var_32h], 0x61
│    ┌────< 0x1400010bd      0f85e1000000   jne 0x1400011a4
│    ││││   0x1400010c3      807c243367     cmp byte [var_33h], 0x67
│   ┌─────< 0x1400010c8      0f85d6000000   jne 0x1400011a4
│   │││││   0x1400010ce      807c24347b     cmp byte [var_34h], 0x7b
│  ┌──────< 0x1400010d3      0f85cb000000   jne 0x1400011a4
│  ││││││   0x1400010d9      807c243b7d     cmp byte [var_3bh], 0x7d
│ ┌───────< 0x1400010de      0f85c0000000   jne 0x1400011a4

var_30h 是输入的字符串，分别进行字节和长度比对，要求输入字符串长度为 12，并且格式为 flag{xxxxxx}，这里有个技巧是 radare2 中 VV 模式下的跳转:

• tab/shift+tab: 跳转到下一个/前一个 basic block
• t/f: 跳转到 true/false 分支
• u/U: undo/redo 跳转

然后是 flag 中间字符的判断:

0x1400010e4      440fb74c2439   movzx r9d, word [var_39h]
0x1400010ea      4c8d442420     lea r8, [var_20h]
0x1400010ef      448b542435     mov r10d, dword [var_35h]
0x1400010f4      33c0           xor eax, eax
0x1400010f6      6644894c2424   mov word [var_24h], r9w
0x1400010fc      8bd0           mov edx, eax
0x1400010fe      4489542420     mov dword [var_20h], r10d
0x140001103      0f1f4000       nop dword [rax]
0x140001107      660f1f840000.  nop word [rax + rax]

这里使用 mov dword 来进行拷贝，将 var_35h 拷贝 到 var_20h 中，同时 r8 寄存器指向 var_20h。接着先循环逐个判断字符c - 0x30是否小于 9，如果有大于 9 的就报错:

 ┌─> 0x140001110      410fb608       movzx ecx, byte [r8]
 ╎   0x140001114      80e930         sub cl, 0x30               ; 48
 ╎   0x140001117      80f909         cmp cl, 9                  ; 9
┌──< 0x14000111a      0f8784000000   ja 0x1400011a4
│╎   0x140001120      ffc2           inc edx
│╎   0x140001122      49ffc0         inc r8
│╎   0x140001125      83fa06         cmp edx, 6                 ; 6
│└─< 0x140001128      72e6           jb 0x140001110
│    0x14000112a      ...

接着经过下面的判断，记得 var_30h 是我们的输入，长度为 12，格式为 flag{xxxxxx}:

     0x14000112a      0fb6542437     movzx edx, byte [var_37h]
     0x14000112f      4c8d053e2100.  lea r8, [0x140003274]      ; "2;=EFI"
     0x140001136      0fb64c2436     movzx ecx, byte [var_36h]
     0x14000113b      80ea30         sub dl, 0x30               ; 48
     0x14000113e      80e930         sub cl, 0x30               ; 48
     0x140001141      44885530       mov byte [var_bp_30h], r10b
     0x140001145      4102ca         add cl, r10b
     0x140001148      4180e930       sub r9b, 0x30              ; 48
     0x14000114c      02d1           add dl, cl
     0x14000114e      884d31         mov byte [var_bp_31h], cl
     0x140001151      0fb64c2438     movzx ecx, byte [var_38h]
     0x140001156      80e930         sub cl, 0x30               ; 48
     0x140001159      885532         mov byte [var_bp_32h], dl
     0x14000115c      02ca           add cl, dl
     0x14000115e      488d5530       lea rdx, [var_bp_30h]
     0x140001162      4402c9         add r9b, cl
     0x140001165      884d33         mov byte [var_bp_33h], cl
     0x140001168      0fb64c243a     movzx ecx, byte [var_3ah]
     0x14000116d      80e930         sub cl, 0x30               ; 48
     0x140001170      44884d34       mov byte [var_bp_34h], r9b
     0x140001174      4102c9         add cl, r9b
     0x140001177      884d35         mov byte [var_bp_35h], cl
     0x14000117a      660f1f440000   nop word [rax + rax]
 ┌─> 0x140001180      0fb60c02       movzx ecx, byte [rdx + rax]
 ╎   0x140001184      48ffc0         inc rax
 ╎   0x140001187      413a4c00ff     cmp cl, byte [r8 + rax - 1]
┌──< 0x14000118c      7516           jne 0x1400011a4
│╎   0x14000118e      4883f807       cmp rax, 7                 ; 7
│└─< 0x140001192      75ec           jne 0x140001180
│    0x140001194      488d0de52000.  lea rcx, [0x140003280]     ; "You are winner!\n"
│    0x14000119b      e8b0000000     call printf                ; int printf(const char *format)

设flag{}中间的内容为flag，这里的逻辑可以写成伪代码:

buf[0] = flag[0]
buf[1] = buf[0] + flag[1] - 48
buf[2] = buf[1] + flag[2] - 48
buf[3] = buf[2] + flag[3] - 48
buf[4] = buf[3] + flag[4] - 48
buf[5] = buf[4] + flag[5] - 48
if buf == "2;=EFI":
  printf("You are winner!\n")

反向计算，可得:

flag[0] = buf[0]
flag[1] = buf[1] - buf[0] + 48
flag[2] = buf[2] - buf[1] + 48
flag[3] = buf[3] - buf[2] + 48
flag[4] = buf[4] - buf[3] + 48
flag[5] = buf[5] - buf[4] + 48

所以计算的 flag 为:

$ ./solve.py
flag: b'292813'

最终答案应该是 flag{292813}，如果有 windows 环境的话可以进行动态验证，在 Linux/MacOS 环境中可以用 wine 来进行验证，如下:

$ wine64 kctf2020.exe
0025:err:plugplay:runloop_thread Couldn't open IOHIDManager.
0009:fixme:vcruntime:__telemetry_main_invoke_trigger (0x0)
KCTF 2020!
http://bbs.pediy.com
Please input your flag: 0009:fixme:msvcrt:MSVCRT__stdio_common_vfscanf options 3 not handled
flag{292813}
You are winner!
0009:fixme:vcruntime:__telemetry_main_return_trigger (0x0)

后记

安装了 iSH 之后，我的手机时间分配一度变成了这样:

手机上的 Terminal 可以用来做什么呢？这里可以列举一些:

1. 用来 ssh 登录到服务器进行管理
2. 用来随时查看 man page
3. 用来编写和运行自动化脚本
4. 进行一些简单的命令行操作
5. …

其中 ssh 对我来说是个刚需，因为在此之前苹果上一直没有一个好用且免费的 ssh client，只能用 Termius 勉强度日。不过可惜的是由于苹果的策略，iSH 暂时还不能在后台运行，不然直接 ssh -R 还能当做隧道用，岂不美哉？

当然，iSH 还是有很多局限性的，比如只能模拟 x86 的指令集，而且由于是软件模拟，因此运行效率比较低。如果要执行复杂的任务，比如 gcc 编译大型项目，还是最好在 PC 上运行了。

博客从 Jekyll 迁移到 Hugo，以及最近一些折腾的感悟。

个人博客那些事

其实从很早的时候就开始了个人博客网站的搭建，最初得益于 github.io 域名的开放。总的来说，我搭建博客的历史主要分为三个阶段。

第一阶段

第一阶段属于简单至上主义。这个时期使用 Jekyll 作为主要的静态博客生成引擎，可以方便地使用 Markdown 来进行写作，并且这也是 Github Pages 官方支持的。

最初是使用了一个简单的模板，后来随着需求日益增加，比如需要标签、目录、侧边栏等功能，于是又转投了另一个主题。

第二阶段

由于在第一阶段中日益增长的定制需求和静态博客的限制矛盾，这个时期开始了一段折腾的造轮子历程。在这个阶段，我用 Python (Django) 写了一个完整博客系统，命名为 berserk (因为当时喜欢听阿姆)。该博客支持以下功能:

• 支持 Markdown 渲染，文章目录、代码语法高亮、自适应文章布局
• 支持文章分类、标签，以及这些属性的数据库管理
• 支持页面访问统计、评论
• 支持后台管理 (基于定制的Django-Admin)
• 支持在后台使用类似 VIM 的键盘映射来编写文章
• 支持真实后台管理页面的隐藏以及虚假后台页面的蜜罐和告警 (没错)

此外因为当时工作接触了一些新潮前端概念，还尝试将一套前后端分离的模式融入到系统中。学习 ReactJS 并折腾了一段时间后发现和 Django 原本的模板系统格格不入，然后就又去掉了。

这个博客系统一直缝缝补补并使用了很一段时间，充满了各种奇怪的前后端 tricks。期间也遇到过各种问题，比如整天被乌克兰的机器人在评论区发广告，于是又加入了人机验证，诸如此类。……直到有一天发现这一切和我的初衷(写博客)似乎没什么直接关系，于是又怀念起了以前用 Jekyll 的那段开心时光。

第三阶段

在自建博客前后端被搞的焦头烂额之后，我又回到了 Jekyll 的怀抱。其实是在自建博客期间看到了许多优秀的 Jekyll 主题完全可以满足我的要求，所以才最终回归。并且在内心暗暗下决心: 再也不折腾了。

不过还是小小折腾了一下，在此期间对一个小众的主题进行了一些简单的定制和优化。这个阶段算是返璞归真，没有了后端的琐事，可以简单地对主题模板进行修改。基于对 Jekyll 模板的了解，这些事情算是驾轻就熟，可以说对博客页面的折腾已经到头了。

这个系统也一直使用了较长的时间，一切都挺满意，除了头顶的几片乌云:

1. 博客访问统计使用的是不算子，服务器在国外，而且数据不可控；
2. 网页常规同步加载，在图片等资源多的时候会感觉速度很慢；
3. Jekyll 使用 Ruby，安装繁琐，构建速度极慢；
4. …

第3点的依赖问题可以通过 bundle 或者直接使用 docker 来解决，但是编译构建的速度着实堪忧，比如才几十篇文章，在服务器上构建就需要长达 15秒 的时间:

$ docker run -it --rm -v $PWD:/srv/jekyll -p 4000:4000 jekyll/jekyll jekyll serve -s /srv/jekyll
ruby 2.6.5p114 (2019-10-01 revision 67812) [x86_64-linux-musl]
Configuration file: /srv/jekyll/_config.yml
            Source: /srv/jekyll
       Destination: /srv/jekyll/_site
 Incremental build: disabled. Enable with --incremental
      Generating...
                    done in 15.28 seconds.
 Auto-regeneration: enabled for '/srv/jekyll'
    Server address: http://0.0.0.0:4000/
  Server running... press ctrl-c to stop.

所以，我又开始折腾了。……但是这次没有忘记初衷，而是选择了 Hugo 加一个比较活跃的主题，因为我不想在前端的修改上花费时间，也不想花太多时间去研究新的模板语法(不过最终还是提了pull request)。

总之，博客还是从 Jekyll 迁移到了 Hugo。迁移过程不算太顺利，因为二者对 Markdown 的元数据理解不同，而且整站的路径也不一样，但通过编写迁移脚本可算实现了。

新的博客可以直接通过 https://evilpan.com 访问。

感悟

其实改来改去，对于最终的阅读者(如果有的话)并不会产生太大影响。就我个人而言，反而不太喜欢那些花里胡哨的博客主题，比如背景弄一些酷炫的 canvas 搞得电脑风扇直转。从阅读者的角度来说，(博客)网站只需要做到:

1. 良好的阅读体验，包括字体、图片、颜色，别搞些绿底黄字的非人间配色；
2. 文章长的话最好有目录，方便阅读；
3. 链接的持久性，不要让阅读者在百度或者其他地方索引过来发现是 404；
4. RSS (当然也可以不提供，需要的人可以用 feed43 之类的爬虫，但是没必要)；

这些一般的博客引擎都能满足，实在没有瞎折腾的必要。而对于博客本身，其实最重要的只有一个 —— 文章质量！其他的都是扯谈，如果是内容农场那就另当别论。

关于 credit

很多人在自建博客时习惯把底部的 credit 去掉，比如 Power by Hugo / Theme By XXX 这种信息。我以前也会这样，一方面是为了简洁，另一方面也是希望能有一些“个性”，生怕宝藏主题被别人抄去了导致烂大街；或者就是干脆想让别人认为这是自己写出来的。

其实大可不必。首先你不是一个前端工程师，所以前端技能并不是别人想要从你身上学习的点。反过来说，如果你是前端，那么自己写一套主题那也应该是常规操作，投机取巧并不能让你自己有所受益；其次，留下主题信息可以让更多看到的人去使用是件好事，获得更多关注后就可能潜在引入更多的开源贡献，最终能让你自己获得更好的使用体验；最后，credit 是对原作者劳动成果的一个起码尊重，谁也不想自己辛苦开发或者写的东西被白嫖党滥用。

在看许多国外的 slides 或者文章时候经常看到对于图片、截图如果不是自己画的都会有明显说明来源何处，国内经常就是拿来就用，当然俺也一样，不过已经在改了。

关于时间

年轻的时候喜欢做加法，奉行 艺多不压身 的准则，对于各种不同领域都喜欢去探索和学习，现在也还是会有很多冲动。但是随着任务列表的逐渐变长，里面的很多项目很可能会一直沉睡在收藏夹中。到了一定的阶段，就需要学会管住自己的双手，把时间用在刀刃上。也就是说，需要学会给人生做减法了。

除了前面提到的博客系统，我还做过很多浪费时间的事情，比如自己写 XSS 盲注后台、DNS服务器(SSRF)、GPS钓鱼系统、写各种命令行工具去实现本可以在网页做到的功能。……

各种命令行工具，有查单词的:

$ dictionary.py restrain
##########################
### Youdao Translation ###
##########################
restrain: 抑制
us:[rɪˈstreɪn], uk:[rɪˈstreɪn]
=== basic ===
vt. 抑制，控制；约束；制止
=== web ===
restrain: 阻止,抑制,限制
Ratio restrain: 比率制动
restrain test: 栓固试验

$ abbr.py PUA
[+] found 25 results
+------+----------------------------------------+-----------------------------------+------+
| name |                  desc                  |               domain              | rate |
+------+----------------------------------------+-----------------------------------+------+
| PUA  |    Pandemic Unemployment Assistance    |    Miscellaneous / Unclassified   |  5   |
| PUA  |   Potentially Unwanted Applications    |    Miscellaneous / Unclassified   |  4   |
| PUA  |    Potentially Unwanted Application    |        Computing / Software       |  4   |
| PUA  |             Pick Up Artist             |    Community / Performing Arts    |  3   |
| PUA  |            Public Use Area             |    Miscellaneous / Unclassified   |  2   |
| PUA  |         Puas, Papua New Guinea         |      Regional / Airport Codes     |  2   |
| PUA  |            Private Use Area            |             Community             |  2   |
| PUA  |          Personal User Agent           |    Miscellaneous / Unclassified   |  2   |
| PUA  | Professional Underwriters Agency, Inc. |    Business / Companies & Firms   |  1   |
| PUA  |    Professional Underwriters Agency    |        Business / Agencies        |  1   |
| PUA  |           Present under Arms           |    Miscellaneous / Unclassified   |  1   |
| PUA  |       Premium Upgrade Assurance        |    Miscellaneous / Unclassified   |  1   |
| PUA  |    Potentialy Unwanted Application     |    Miscellaneous / Unclassified   |  1   |
| PUA  |       Potentially Unwanted Apps        |    Miscellaneous / Unclassified   |  1   |
| PUA  |      Possession and Use Agreement      |    Miscellaneous / Unclassified   |  1   |
| PUA  |      Portland Urologic Associates      |    Business / Companies & Firms   |  1   |
| PUA  |            Plasma Uric Acid            |   Academic & Science / Chemistry  |  1   |
| PUA  |            Pick Up Artists             |          Community / Art          |  1   |
| PUA  |    Pharos University in Alexandria     | Academic & Science / Universities |  1   |
| PUA  |   Peoples University of the Americas   | Academic & Science / Universities |  1   |
| PUA  |      Pediatric Urology Associates      |        Medical / Pediatric        |  1   |
| PUA  |     Payment Undertaking Agreement      |    Miscellaneous / Unclassified   |  1   |
| PUA  |  Partido de Unificación Anticomunista  |     International / Guatemalan    |  1   |
| PUA  |           Paid Up Additions            |    Miscellaneous / Unclassified   |  1   |
| PUA  | Paul University, Awka - Anambra State  |         Academic & Science        |  0   |
+------+----------------------------------------+-----------------------------------+------+

有查股票的:

有查 IP 地址的:

$ iplocate.py --on 1.1.1.1
>>>>>> results for 1.1.1.1 <<<<<<
[*] GeoLite : 澳大利亚(AU) - None
[*] Kn0007  : CLOUDFLARE.COMCLOUDFLARE.COM
[*] DBIP    : OC(Oceania),AU(Australia) New South Wales, Sydney
[*] Tencent : 澳大利亚 code(-1) lnglat(149.1333,-35.2667)
[*] IPIP    : ["CLOUDFLARE.COM","","","",""]

复杂一点的还有代理池管理工具，书签管理工具等等:

有些小工具就是三下五除二就弄好了，但是有些就颇花了些时间。要说有没有必要，其实很多都没必要，想要开车并不表示需要自己造轮子。原型开发的过程还是很有趣的，但是其中有许多项目做完之后也就爽那么一下，然后就很长时间都没用过。

为了避免这种做无用功的尴尬，重要的是管理好自己的想法。对于时不时冒出来的 idea 可以先记录下来，到周末或者某个固定时间再进行排序，评估哪些可以做、需要做，哪些可以借助已有的轮子。站在巨人的肩膀上，而不是盲目追求写代码的快感。

曾经的想法是**“因为我可以做，所以我就去做”**，但重要的是管理好自己的精力和时间。学习也是一样，各种新概念层出不穷，开始学习之前需要先评估这究竟是不是你需要的，而不是因为看起来很热门就去投入。

Be curious , but don’t get drown.

关于白嫖

在迁移博客的时候发现 Chrome 新版本对于 https 站点中的所有 HTTP 资源都拒绝加载了，导致以前七牛 CDN 上的图片都无法显示，而七牛的 HTTPS 流量又是收费的，所以我决定换一个图床。为了找一个新的 HTTPS 免费图床，我翻了很多记录，发现很多免费站点都已经无法访问了，最终是选择使用某个博客平台的图片上传功能，为了批量上传还分析了该平台的验签和加密算法。

虽然最终目标实现了，但我也耗费了大半天的时间。都是传统的白嫖思想在作祟，因为从小习惯了免费。免费的聊天工具，免费的游戏，免费的操作系统，免费的杀毒软件，……这其实完全没有道理。如果一个东西做的很好，但是完全不赚钱，那么开发者是否还会投入那么多精力去维护呢？一腔热情投入开源工作，还要面对各种小白的挑刺以及伸手党的催促，个中滋味只有经历过才能体会到吧。

我们花几百块钱吃一顿饭觉得合情合理，但是花几十块钱购买在线服务或者软件就踌躇不决。但是说到底，白嫖终究不是长久之计。一个免费 CDN 需要在流量和速度上进行限制，一个免费的云服务器不会提供可用性保证，一个免费的图床可能说挂就挂，能在下线前告诉你一声已经仁至义尽了。

白嫖在线的服务需要自己承担稳定性和迁移风险，白嫖本地应用需要忍受广告和推送，这世上本就没有免费的午餐。如果上天能给我个再来一次的机会，我想说:

最近看到一篇新闻感觉很有意思，微信推出看一看、小视频等功能，不是因为用户需要，而是面对头条对 用户时间 的蚕食感到不安 —— 用户每天花在微信的时间从 X 小时下降到了 Y 小时，而在头条系产品中投入的时间从 M 小时增加到了 N 小时。第一次对"时间就是金钱"有了别样的认识。

你以为你白嫖赚到了，其实最后被嫖的是你自己。

昨天去参加了mosec2020的安全会议，这也是我第一次参加mosec，议题质量比预料中的要高，因此在这记录一下其中几个有意思的议题。

IO80211Family

第一个议题是王宇师傅(@keenjoy95)关于苹果WiFi子系统的安全研究分享，其实王宇在前一段时间就提了一大波苹果蓝牙子系统的漏洞，看来手里的料还是挺多的。之所以去撸WiFi子系统，也是因为“之前的一个0day在升级系统后不work了”，……说回思路方面，研究入口的寻找个人认为比较有启发性，利用Kemon的内核挂钩能力，确实可以做到往上拳打daemon process，往下脚踢kernel driver或firmware。

IO80211Family V1/V2的这些漏洞，也是因为在接口上发现有巨大的参数传入。一方面通过修改Kemon实现Passive Fuzzer，另一方面去逆向对于这些参数的处理和校验从而优化样本。效果怎么样呢？也就是“每天和panic打交道，对于一些品相不好的panic都懒得去分析”的地步吧。

另外，对于这些复杂的设备驱动，可以参考开源代码(AppleIntelWiFiMVM)，甚至自己去实现一遍，这样可能在分析时会有不一样的理解。

像WiFi、蓝牙、NFC这些攻击面其实影响是很大的，而这部分驱动或者firmware的开发者由于自恃功能复杂天知地知或者抱着能用就行的心理，对一些不可信数据没有意识添加完善的边界检查，导致实现往往在遇到非预期输入时存在bug或者漏洞从而引起内存破坏。这部分分析一个绕不过的门槛是逆向的基本功，安全研究人员做好头发的保养工作还是很有必要的。

另外王宇也提到了他在macbook touchbar图像驱动中也是有0day的，感兴趣的同学也可以尝试去撞一下:)

DroidCorn: 无源码Android Binary Fuzzing

这个议题是flanker(@Flanker_017)介绍了他(们？)做的一个无源码fuzzing框架。说到无源码fuzz，常见的两个流派就是binary patch和dynamic instrument，而DroidCorn听名字也大概能猜到了，就是基于Unicorn开发的动态插桩式执行引擎。

该引擎架构大致分为以下部分:

• Crash Triager
  • Trace Recorder
  • Symbolizer
• Mini Runtime
  • ELF linker
  • Mini Heap
  • Mini Hooker
• Mini Kernel
  • Memory Layer
  • Syscall Handler
• Processor
  • Unicorn(patched)
  • ForkServer
  • Tracer

无源fuzz的思路和AFL-unicorn类似，在QEMU执行Translation Block的时候插入afl_maybe_log记录执行覆盖率。Unicorn本身只是QEMU中CPU Emulation部分代码提炼出来的可编程框架，要实现二进制程序的加载和运行还需要依赖于linker和内核的正确处理。DroidCorn中在这部分做了不少工作，实现自定义的ELF Linker、Runtime以及根据不同应用实现不同的内核系统调用(~20个)，这让我想起了另一个类似的框架qiling.io。最后作为PoC，展示了三星手机图片库中找到的一些漏洞，不过工具想必近期是不会开源了，自己动手丰衣足食吧。

也许以后这类更偏向实战的无源fuzz会是一大热点。CPU指令的软件模拟运行的虽然可以做很多优化，但性能终究是比不上原生虚拟化的支持，ARM Server FTW？

深入浅出JSC优化措施

大宝(@S0rryMybad)的议题，讲得太深，而且又是我的知识盲区，所以不多介绍。唯一的收获是学会了面向RCE的“倒序挖洞法”，针对类型混淆去搜寻JS Array类型改变和检查的地方并寻找潜在的非预期状态。C/C++的代码审计和php有很大不同，但是现在网上更多的资料是关于后者，这个未来有时间也值得谈谈。

暗涌2020

slipper的议题，光听名字完全不知道说啥，副标题是小米5c中国产自研手机芯片澎湃S1分析，其实我觉得标题应该改成“小米5c: 年轻人的第一个fullchain” :)。

虽然标题说是芯片，不过和芯片本身没什么太大关系。议题本身还是很精彩的，从头到尾介绍了如何实现one-click获得小米5c的持久化root权限(准确来说可以达到S-EL1的权限)。

由于安卓的碎片化，小米ROM中其实还是Android7.1，所以在攻击链中有几部分使用了n-day，比如webview和sepolicy的问题。小米5c使用了OP-TEE作为TEE的实现，从其中某个TA里发现漏洞函数，通过在用户态发送消息可以触发。一般TA中都是没有现代mitigation的，所以直接栈溢出+ROP来返回内核并进行patch从而获取了root权限；最后则是通过分析firstboot(LK+aboot)发现特殊入口绕过SecureBoot从而实现持久化。

最近中美关系紧张，可能会出现更多的国产芯片。除了芯片本身的硬件实现外，软件设施也需要跟上时代。华为海思是个很好的例子，虽然其TEE(iTrustee，之前是Trusted Core)也曾经有过漏洞，但至少是和国际持平的。开源实现也不是不能用，不过开发者移植的时候最好先有个全面理解，这样也不至于把开源项目的测试接口原汁原味编译进release版本中，然后被安全研究员在大会上公开diss了:)

攻击SEP的安全启动

徐昊(@windknown)的压轴议题，这也是我觉得最有干货的一个议题了。在checkm8出来后，攻击者号称这是ROM的代码漏洞无法被修复，但是苹果计划在iOS14中修复这个问题，修复方法之一就是通过SEP。SEP是安全处理器(Secure Enclave Processor)，与ARM提供的Truszone总线隔离不同，而是使用了一个独立的处理器来专门处理敏感信息。

关于SEP的公开信息并不多，曾经在2016年BlackHatUS中的议题“Demystifying the Secure Enclave Processor”介绍过，此后很长一段时间都没有相关的安全分析。SEP同样也是一个ARM处理器，拥有独立的RAM和外设，如加密引擎(GID/UID)和TRNG，但同时也有部分和应用处理器共用的资源，比如电源管理(PMGR)、Mailbox和共享内存。

Mailbox是SEP和AP之间唯一的通信信道，基于双方都能访问的映射IO寄存器实现。AP端的映射基地址是0x20da04000，SEP端映射的虚拟地址是0xcda00b80(物理地址为0x20da00b80)。Mailbox信息(messages)的大小是8字节，其中4字节为data，数据结构如下:

struct __attribute__((packed)) sep_message {
	unsigned __int8 endpoint;
	unsigned __int8 tag;
	unsigned __int8 opcode;
	unsigned __int8 param;
	unsigned int data;
}

这个议题本身更多关注与安全启动部分，作者逆向分析了SEP ROM中的代码，分析地址映射和地址保护初始化的逻辑，并寻找其中的攻击点，最终在部分型号下实现SEP的memory读写。可能由于作者还没有完全撸完，所以后面留了一手，不过总的来说也算给其他研究者提供了一个指引方向，后面应该会针对SEP有个小爆发。

Baijiu Con

会后的环节是白酒Con，想上台讲的喝一杯白酒讲五分钟，挺新颖的形式。其中也有一些有趣的议题，比如:

• 王宇介绍了SEP研究的一些其他相关资料和最新进展
• 王勇(ThomasKing2014)介绍了一种名为Arch-flip的奇淫技巧，在运行时切换ARM32/64位的运行环境，可用来辅助写chrome exp或者反逆向
• Rancho介绍了Windows打印驱动的安全研究
• redra1n介绍了供应链攻击，red on red，用魔法打败魔法(●—●)
• 360的小哥介绍了奔驰汽车安全研究，进入汽车系统后发现一个越权远程控制任意奔驰的漏洞(还好买不起)
• iOS in 2020: 秀了一把最新iOS 14的越狱，不说了，盘古NB
• Chromium Series in TCTF: 分享CTF中遇到的Chromium的漏洞利用技巧

虽然会议视频和slides没有公开，但是CTF主播slipper在斗鱼直播间中直播了Baijiu Con部分的演讲，感兴趣的可以去看看，直播间号码是7851291

In Islington there was a man,
Of whom the world might say,
That still a godly race he ran——
Whene’er he went to pray.

A kind and gentle heart he had,
To comfort friends and foes;
The naked every day he clad——
When he put on his clothes.

And in that town a dog was found,
As many dogs there be,
Both mongrel, puppy, whelp and hound,
And curs of low degree.

This dog and man at first were friends;
But when a pique began,
The dog, to gain some private ends,
Went mad and bit the man.

Around from all the neighbouring streets
The wondering neighbours ran,
And swore the dog had lost his wits,
To bite so good a man.

The wound it seemed both sore and sad
To every Christian eye;
And while they swore the dog was mad,
They swore the man would die.

But soon a wonder came to light,
That showed the rogues they lied,——
The man recovered of the bite,
The dog it was that died.

Oliver Goldsmith
1766

首先，如果时间旅行真的可能，必须使得现在已知的悖论得以解决。为此我将世界假定为当下流行的“平行世界模型”，即每一个时刻的世界 都是平行发生的，当我碰到红灯时，有两种选择，一是继续前进，二是等待绿灯；继续前进的我是一个世界的我，姑且称之为世界1；等待绿 灯的我是另一个世界的我，称之为世界2；；两个世界各自平行地向前生长。在世界1里，也许我被车撞倒，进了医院；在世界2里，我通过马路， 正常打卡上班。这只是一种简单假设，实际上由于万物可以无限细分，选择也可以在无限的时间细分，大千世界里又有大千世界，毫不含糊。

为了使问题简单，首先做一点简化。假设W为某一时刻的世界，并且在此时刻之后仅有两种发展的可能，即世界W1和W2，而后者也分别有两种 后续发展W11、W12、W21、W22。假设我们现在所在的世界为W22，并且打算穿越到W以改变当下的境遇（即逆转未来），那么过程应该如何呢？ 穿越的方式有两种，一种为肉体穿越，即整个人连同内衣裤都转移到从前；另一种为意志穿越，或者说精神穿越，即尽有类似于灵魂的东西出 现在过去来改变世界运转。肉体穿越不大现实，所以暂且假定为意志穿越，即我现在的意志像灵魂出窍一样回到过去，并且附身于从前（W）的 自己，W的我的灵魂则压入堆栈，暂时失去身体的控制权，由此我就能开始改变世界啦！改变之后，W的灵魂W22出栈，回到W22中，享受修改了的世界。

就这么简单了？刚刚说到世界像分叉一样向前生长，改变了的W是否还会生长到W2进而到我原来意识中的一模一样的W22呢？也许不会，但是 如果没有在穿越的时候大搞破坏的话，应该大同小异。也许回到W22之后会发现有些事变了，生命中会莫名其妙地少了几个人或者多了几个人。 X战警中就是这样的设定，但这是有问题的。原W22的金刚狼灵魂出窍修改了W再回到W22，但回去的W22（暂且成为W22B）已经不是原来的W22（称为W22A）了， W22A的金刚狼的灵魂强占了W22B的金刚狼的灵魂，那么W22B的金刚狼的灵魂则在那一刻之后永远沉入栈底，这是多么可悲的啊，按照这种理论，还会发现他 在一夜之间性情大变，不觉得奇怪吗？

因此按照平行世界的理论，虽然穿越到过去可以实现，但是也无法改变现在。假设灵魂可以出窍，那么之后他将看到无数可选的世界（处于不同的时间）， 改变过去之后会出现一个更好的现在，但是已经有原生的灵魂居住了。事实上根本不用去修改过去，就会有一个和现在类似的但是更美好的世界，与我所 来的世界平行前进，但是幸福是我的，幸福也不是我的。这也解释了我心里的一个疑惑，即为什么未来的我不穿越回来把福利彩票的中奖号透露给我， 因为一则我是如此之多，他根本就无法选择，二则即便透露了，快乐也是我的，他什么也没有。

即便这些方式能解释穿越之后引致的矛盾，此外也还有更加严峻的问题，比如在W22时间结点之后，人类掌握的时间旅行的技术，那么从这一时刻开始， 各种不安分的灵魂就会到处乱窜，从前朴素的灵魂就会不断被压入堆栈，这点又怎么解决呢？反证而言，甚至可能灵魂根本就无法进入过去的人的身体， 无法左右过去的世界，只能在一片苍茫中无形地飘荡。结果是所谓的穿越时间，最终还是沦为一场4D的iMaX原始纪录片观影旅行。

If you can dream—and not make dreams your master;
If you can think—and not make thoughts your aim;
If you can meet with Triumph and Disaster
And treat those two impostors just the same;
If you can bear to hear the truth you’ve spoken
Twisted by knaves to make a trap for fools,
Or watch the things you gave your life to, broken,
And stoop and build ’em up with worn-out tools:

If you can make one heap of all your winnings
And risk it on one turn of pitch-and-toss,
And lose, and start again at your beginnings
And never breathe a word about your loss;
If you can force your heart and nerve and sinew
To serve your turn long after they are gone,
And so hold on when there is nothing in you
Except the Will which says to them: “Hold on!”

If you can talk with crowds and keep your virtue,
Or walk with Kings—nor lose the common touch,
If neither foes nor loving friends can hurt you,
If all men count with you, but none too much;
If you can fill the unforgiving minute
With sixty seconds’ worth of distance run,
Yours is the Earth and everything that’s in it,
And—which is more—you’ll be a Man, my son.