Tsglz's blog

阅读笔记（不定期更新中）

Tsglz — Fri, 12 Jun 2026 00:00:00 GMT

写一点平时读书的思考，以及对书或者作者的点评。

小时候特别爱读心理学，一边和人接触，一边对人们的行为和动机不断解构，取其精华、去其糟粕，慢慢地构成了属于自己的人生观、价值观和世界观。

再长大一些逐渐愿意接触更多的书，博览群书算不上，但大家的思想或是学说或多或少都了解一些。从心理学、社会学、经济学，过渡到哲学。真的很有意思，包括在查阅哲学资料的时候意外发现还有衍生的魔法一支。

把我的一些微不足道的看法分享给大家，共勉。

下面这张图是截取自我自己写的阅读偏好记录软件，有部分书是很久之前读的，不想补笔记所以没有写在下面的分类里。

自然科学

人文学科

哲学-哲学史

《哲学家们都干了什么》（已严肃品鉴）

推荐指数：7.5/10。

哲学-哲学入门

《你的第一本哲学书》（已严肃品鉴）

推荐指数：6/10。

社会科学

教育/个人成长

《成长的边界》（品鉴中）

第一章提出了一个问题：专家们会因为有经验而变得更好吗？

从而进一步引出了“友好型”学习环境（模式一再重复，反馈极其精确，而且速度够快，比如高尔夫、国际象棋领域）和“恶劣型”学习环境（竞赛规则通常不甚明晰，或者不够完整；重复的模式时有时无，或者不够清楚；而反馈常常滞后，或者不准确，或者两者兼有）。在最恶劣的学习环境下，经验往往会反复强化错误的教训。

最后引申出观点：人类真正的优势不是战术积累，而是判断力，或者说战略。

《如何有效阅读一本书：超实用笔记读书法》（品鉴中）

学习一下怎么阅读

心理学-司法心理学

《牛津通识读本：司法心理学》（已严肃品鉴）

推荐指数：7.5/10。

社会学-人际关系

OS：我也不知道为什么会开这么一个分支，但是我的确对这个领域非常的好奇，不管是异性之间还是同性之间。我的第一本启蒙文学作品是《蒙马特遗书》，哈哈，对，是女同写的。看完感觉云里雾里，不甚明晰。不过我也不准备再读第二遍了，没必要。

除了好奇，我读这类作品还有一个很重要的原因。我个人还是比较注重社会关系的处理的，虽然对待大部分人我都是不温不火的，但这并不意味着我不在意与人的链接，尤其是那些我欣赏的人。所以如何维护关系就显得格外重要，而这恰巧是我不太擅长的，不管是对恋人还是朋友。

《恋爱心法》（品鉴中）

商业/管理/创业

《opb-book-2.1.v3》（品鉴中）

学习一下程序员怎么创立一人公司。

文学艺术

电影研究

《如何聊电影》（品鉴中）

讲述了如何对一部电影进行分析和评价，不管是一部佳作还是一部烂片。本书从剧本、表演、艺术设计、摄影、剪辑、声音与音乐、导演七个方面进行分析。

首先是剧本部分。剧本需要回答的第一个问题是：电影制作者到底想做一部怎样的电影？

综合/跨学科

神秘学

《秘苑玫瑰》（品鉴中）

简单了解一下神秘学。内容很浅显，感觉是科普性质的书，美中不足的是，在一些细节上讲的不是很清楚。

暂时没看到实操相关的内容。

科学哲学/科学史

《世界观：现代人必须要懂的科学哲学和科学史》（品鉴中）

《牛津通识读本：司法心理学》读后感

Tsglz — Fri, 12 Jun 2026 00:00:00 GMT

在读这本书之前，我一直在思考一个问题，为什么在这些刑事案件中，需要司法心理学家出现？

在阅读这本书之后，我修正了之前的观点，但是我仍然认为，司法心理学的作用远没有那么重要。不过我认为可以给那些愿意并且主动寻求纠正自己行为的犯罪者一个改过自新的机会，这个时候司法心理学是最有用的。

而对于那些已经定型了的恶劣罪犯，我认为完全没有必要浪费宝贵的社会资源来纠正他们的行为。他们最大的用处就是做成肥料或者其他产品，这样不仅可以减轻社会压力，减轻自然环境承载力的负担，还能够为社会做出贡献。比如，肥料可以促进作物生长，这样一些贫瘠地区的粮食产量就可以提高，饥饿问题也相应能够得到改善。

但是后面我又产生了一些疑虑，比如，什么样的社会制度能够允许我这种惩戒措施的实施？此外，如果一个犯罪者同时具备不可纠正的特性，以及巨大的功劳或者潜在的作用，我是否应该对他们的行为进行惩戒？如果一个不可纠正的犯罪者与某些权力掌握者有密切关联或者利益纠葛，这种人该怎么处理，等等。

嗯，这些都是我发散思维后未经合理验证的一些想法，而非真实案例。如果说要设计一个具体可行的完备系统，我可能需要更多的知识补充，以及对法律、制度等更深入的了解。

这本书只是一本通识读本，而非专业书籍，书中仅仅包含了少量案例，并且这些案例也只有寥寥几句话描述带过。这本书更多的讲述了司法心理学中的一些概念，但是这本书将我引向了一个此前很少接触的新领域——司法心理学。给了我很多灵感，让我能够进一步补全对这个世界的认知拼图。

话归正题，下面是我画的一张简图（画的有点乱糟糟的，但是内容应该是比较全的）：

在阅读过程中，我提出了一些问题，我将在下面一一枚举，并给出我查阅资料后思考的结果。

Q1：在家暴事件中，为什么家暴者选择了暴力沟通？

我认为这是一种多个因素混合的产物。

首先是社会环境，一些人在年幼时遭受过或目睹过家庭暴力，可能在塑造观念的关键时期带来了错误的引导，此外，社会上（包括现在仍然存在）的重男轻女的思想，也在潜移默化地影响着人们的想法和行为。

更糟糕的是，在某些问题上，性别不平等，也导致了一些人选择了暴力沟通。比如说，当女性的经济地位低于男性时，男性更可能产生一种优越感，在我看来这也算一种隐形的暴力。（当然，被家暴的并非全部都是女性，但是女性经济地位低于男性比较普遍，故举此例）

另一方面，法律的不完善，或者是法律的执行不严格，也助长了暴力沟通的出现。同时，这样的不平等会让受害者失去对法律的信任，可能在受到伤害后选择忍受而非寻求法律保护。（如果法律对受害者保护力度不够，加害者可能会变本加厉）

当受害者的经济地位处于劣势，法律保护又不足时，很可能会形成一个糟糕的正反馈，陷入绝望的境地，心理上认为被伤害是正常的现象，又助长了施暴者的嚣张气焰。

Q2：现在的司法制度合理吗？如果不合理，我有能力提出更好的吗？如果我没有这个能力，我是否有能力在现有基础上修正？

不知道这个算不算不能播的...

其实我心里已经有答案了。但是我允许这个答案不断变化。或许之后我学到了更多相关的知识之后会有不一样的看法呢？

Q3：犯罪地图画像系统中有应用到圆周假设，在后续的演进中更是发展出了植入决策支持系统构图软件的概率运算。这些技术是否能类比应用到其他领域（我更关注安全领域）？目前这方面最前沿的技术是什么样的？

查了一些资料，圆周假设的应用领域还是比较广的。

简单讲一讲圆周假设是什么：事件发生地围绕一个中心点（通常是主体的居住地或活动基地）呈概率分布，距离越远，发生概率越低。这本质上是一种空间衰减模型。基于此的概率运算，如核密度估计（KDE）和贝叶斯概率模型，可以被迁移至以下领域：

疾病集群源头追踪、动物巢穴或活动核心区推断、事故源头定位、城市规划/选址的需求热点分析、网络空间安全中攻击源地理定位（这一条我有一点点存疑，因为要考虑VPN等因素）、考古中对古代定居点或活动中心的推断等等。

另一个问题，当前比较前沿的技术组合与计算机方法，首先就是热点机器学习与深度学习，可解释人工智能（XAI）这些，这个我就不细说了，各个领域都大差不差的，反正 ai 赋能都这么回事。

我要稍微提一提没见过的，比如多源异构数据融合（社交媒体与文本数据、移动通信与位置服务数据、交通与物联网数据、环境与基础设施数据等），这个方法感觉对我的社会工程学研究很有帮助，很有启发意义。

还有实时流处理（实时接收并分析犯罪报告、紧急呼叫、社交媒体帖子的流处理管道），这个国外好像有类似的软件，我之前有看到过，感觉还是挺有意思的。（大概就是把经常发生暴力事件、或者帮派活动的地方作为热点标注，提醒人们不要靠近，大概是这样，很久之前看到的了，记得不是特别清楚）

其实做网络地理画像和我做社会工程学感觉差不多，都是收集信息、分析信息，最后把人扒干净，哈哈。

Q4：案件取证的时候会包括对犯罪者的行为描述，如果是证人口述，怎么判断是否真实？取证过程中证据可能包含物证、行为描述、案发地点等等，怎么将这些证据串联成为一个最具说服力的定罪证据？

查阅了一些资料：

根据我国刑事诉讼法及相关司法解释，对证人证言真实性的审查主要从以下方面进行：感知能力审查（证人状态）、利害关系审查、程序合法性审查（是不是被暴力威胁了）、印证性审查（与其他证据有无矛盾）

顺便讲一讲陈述有效性评估（SVA）：

因为我对这方面比较感兴趣，所以多了解了一些。

陈述有效性评估是一种用于评估陈述真实性的心理学技术，核心是标准基础内容分析（CBCA）。CBCA基于一个核心理论假设：来自真实经验记忆的陈述与基于创造或幻想的陈述，在内容和质量上是不同的。

SVA中的13个标准可以在CBCA中找到对应：逻辑一致性（对应CBCA“逻辑结构”）、非结构化产出（对应CBCA“无组织的叙述”）、细节的数量（对应CBCA“细节的质量”）、语境嵌套性（对应CBCA“语境铺垫”）、对互动的描述（对应CBCA“对交互行为的描述”）、对话重构（对应CBCA“话语复述”）、预测外的难题（对应CBCA“事件中料想不到的复杂化”）、不寻常的细节（对应CBCA“异常的细节”）、冗余的细节（对应CBCA“多余的细节”）、受询者心理状态归因研究（对应CBCA“犯罪者的心理状态归因”）、自发的修正（对应CBCA“自发改正”）、承认缺失部分记忆（对应CBCA“承认记忆的缺乏”）、提出怀疑（对应CBCA“对自己证言有怀疑”）。

有几条名称不太好懂的我单独拎出来讲一下：

非结构化产出：真实经历者在回忆时可能先讲核心再补充细节或者其他片段，而说谎者倾向按时间顺序编造。
语境嵌套性：事件能否与陈述者日常行为和习惯联系起来。
对话重构：陈述中是否以初始形式复述对话，能区分出不同的说话者。
冗余的细节：与核心指控无关但与事件相关的额外细节。

然后是怎么构建证据链：比较常见的是时间线重建，将整个事件还原出来，结合物证、行为描述、案发地点，重建空间移动轨迹，放入到动机-手段-机会（MMO）框架中，同时，证据之间可以相互印证，来排查是否存在矛盾点或者异常点，从而进一步完善证据链。

——————————————————————————————————————————————————————————————————————

此外，作者在书的结尾部分还提到了侦察心理学，并给出了下面几个问题：

为什么人们明明知道某人是罪犯还要为其做伪证？

我个人的观点：伪证者可能受到了威胁或是害怕被报复；如果有利害关系的话，伪证者可能出于对自己利益的维护，选择做伪证；如果目击者和被指认方存在亲缘关系，伪证者更有可能对被指认者袒护。

此外，当一些证人的文化素质和法制意识不强，无法充分认识伪证行为的严重性和违法性时，更可能产生做伪证的行为。

在查找资料的过程中，我还看到了另一种阐释：

从社会学和传播学角度，我们可以引入“叙事权力”的概念。法庭审判不仅是事实的认定，更是叙事的竞争。作伪证者，有时是在试图构建一个对自己或所支持之人更有利的“故事版本”。他们可能认为，自己所支持的那个“叙事”（例如，一个关于家庭、友谊或反抗不公的叙事）比冰冷的“法律事实”更接近他们所理解的“正义”或“真相”。

罪犯愿意通过什么程序进行虚假申诉，请求帮助寻找失踪的但是事实上是被他们自己杀害的爱人？

这个问题让我想到了《消失的她》哈哈。

虚假申诉的主要程序：

向警方正式报案。罪犯通常会表现出焦虑、悲伤甚至崩溃，以博取警方同情。但细致的观察可能发现其情感反应与情境不协调（如眼神飘忽、细节描述过于流畅）。
利用媒体和社交平台造势。罪犯选择扩大事件影响力，将自己塑造成“焦急的伴侣”，从而转移公众怀疑，同时制造情感绑架，让周围人更难质疑其行为。
联系民间搜救组织。罪犯借助第三方力量增加搜寻的“真实性”，并利用搜救过程进一步观察调查方向，及时调整自己的谎言。
推动法律程序。罪犯在适当时机（通常是数周或数月后）向法院申请宣告失踪或死亡，以便处理财产、保险理赔等事务。同时，可能咨询律师，了解如何规避法律风险。除了经济利益，这也是对“失踪”状态的正式确认，有助于罪犯心理上“结案”。
持续的情感操纵。罪犯在家人、朋友面前持续扮演悲痛角色，可能写悼念日记、保留爱人的物品，甚至创建纪念网站。通过重复表演来强化自我欺骗，减轻认知失调（即“我杀了爱人，但我仍在寻找她”）。

怎么从侦察心理学的视角识别虚假申诉？

报案时机异常：要么过早（爱人刚“失踪”就急于报案），要么过晚（故意拖延以制造更可信的失踪证据）。
细节描述矛盾：对失踪前后的细节描述过于完美，或在多次询问中出现不一致。
情感反应不协调：缺乏真实的悲伤生理反应（如哭泣时无眼泪），或情绪切换生硬（如从“悲痛”迅速转为“理性”讨论财产）。
行为模式反常：过早询问遗产继承、保险理赔等事宜，或对调查进展表现出不应有的“了解”（如提及未公开的线索）。
社会关系异常：与爱人的亲友关系突然变得疏远或过度亲密，以控制信息传播。

管理愤怒的人群的最有效方式是什么？

OS：最有效的方法其实是赶紧把导致愤怒的问题解决，而不是把愤怒的人解决。

就像治水一样，堵不如疏。愤怒往往来源于未被倾听的诉求。倾听愤怒的人群提出的诉求，给予他们尊重，这是管理的第一步。然后要精确地找到人群中的情绪领袖或煽动者，对他们进行相应的干预。这样可以很好地分化愤怒的人群。最后，对闹事者给予应有的惩戒，但不能过度惩戒，避免激化矛盾。

是什么样的心理过程导致人们诉诸恐怖主义？

依旧分内因和外因来阐述。

内因主要是身份认同需求。极权主义群体提供简单的善恶二元叙事、清晰的身份标签和强烈的归属感，这对处于身份危机中的个体尤其有吸引力。此外，具有自恋倾向、外化倾向、边缘人格特征的人更可能参与恐怖主义。巨大的心理创伤也可能导致人们诉诸恐怖主义。

外因主要是社会心理环境因素。社会不平等与边缘化、社会冲突与分裂、政治压迫与不公、媒体影响与意识形态传播为恐怖主义提供了滋生的土壤。

推荐指数：7.5/10

低价值资产不等于只需要简单防护

Tsglz — Thu, 11 Jun 2026 00:00:00 GMT

昨天晚上看到一位安全工作者发的公众号，里面提到说，真正重要的资产未必获得了匹配等级的保护。攻击者永远优先寻找最有价值、最关键、最容易获得收益的地方。防御也应该优先保护这些资产。

我认为这么说还是相对片面了。

低价值资产，是指那些在安全领域中，其价值相对较低的资产。这些资产通常被忽略，因为它们的保护成本较高，而其收益较低。

但是有一点不能忽略。一些的低价值资产，如果不合理地防护，其实更有可能作为攻击者的目标，然后作为跳板攻击高价值资产。

这就涉及到了资产配置的优先级。由于企业资产优先，无法对所有资产采取同等强度的防护力度。那么，该怎么合理配置资产的防护级？

让我们首先思考一下攻击者的攻击路径。攻击者的经典攻击路径往往不是直接攻击堡垒，而是“从外围突破，逐步横移”。一个看似低价值的资产（如一台访客WiFi、一个废弃的测试服务器、一台未打补丁的办公电脑）可能因为防护薄弱而成为初始入侵点。一旦控制了这些资产，攻击者就可以：

进行内网侦察，绘制网络拓扑，发现高价值资产的位置。
利用信任关系，如域环境、跳板机、共享凭据，横向移动到核心网络。
窃取低级别凭据，再通过密码复用或权限提升，获取高价值资产的访问权限。

所以我想一个健壮的安全体系应该是综合考虑资产的价值以及与高价值资产的关联性，同时严格使用零信任架构，对资产间的访问进行监督和限制。

对低价值资产，我们不仅要合理防护，更要考虑到如果它被攻陷，攻击者会利用它做什么？攻击者能利用它做什么？如果能未雨绸缪，提前做好预案，那么即使受到攻击，损失也可以大幅度减少。

同理，做样本分析也是这个思路。每拿到一个新样本，需要思考的不仅仅是它做了什么，更要思考它为什么这么做，它为什么可以这么做。因为最近我有参与设计一套自动化样本分析框架，我对样本分析的一整套流程有了更深刻的见解。

一个样本，一种技术，一套流程，在这些不断迭代的表象下面，我们需要看到的是攻击者与防御者之间的对抗。

碎碎念就到这里了。后续可能会讲一讲那个自动化样本分析框架在实际搭建的过程中的一些思考。共勉。

《你的第一本哲学书》读后感

Tsglz — Thu, 21 May 2026 00:00:00 GMT

这本书带给我的阅读体验并不是很好。或者更贴切的说，如果你在阅读前就对问题有相关的思考，这本书可以带来较好的印证，或是一些新的思路或启发；如果你只是想走马观花地了解一下，可能看了一遍之后还是云里雾里。

这本书主要围绕9个问题展开，分别是“外部世界是否存在”，“他人的意识”，“身——心问题”，“词语的意义”，“自由意志”，“对与错”，“正义”，“死亡”，“人生的意义”。

其他的我也不太会总结，但是显而易见，这本书只能给你提供启发，没有任何一本哲学书能让你无视一切偏听偏信，你应该有自己的思考。（这本书的作者在一些方面确实不是很懂行，也可能是科技发展太快了，让当时很多不可能变成了可能）。

在前面的几个章节，作者除了啰嗦且晦涩，也还能看。但是最后几个章节，我还是有一些不满的。比如说，我不认可作者在道德方面的相关论述，而且他的观点在我看来不够完善，在逻辑上也不够有说服力，不过无伤大雅，每个人都可以有自己的哲学观点，我选择理解，但不尊重。此外，在正义的章节，我认为作者的引入就有所偏颇。后续作者修正了自己的观点，让我感觉比较满意。

不过要是有谁真把这本书作为第一本哲学书，那可真是完蛋了。

推荐指数：6/10

《哲学家们都干了什么》读后感

Tsglz — Thu, 07 May 2026 00:00:00 GMT

这本书是我决定系统学习哲学知识之后阅读的第一本书。个人觉得这本书看起来非常舒适，很适合给完全不了解哲学，想要入门的学者扫盲。

但是有一点需要注意，这本书更偏向于按照时间顺序将古往今来西方比较有名的哲学家和他们的思想引出来，按照发展顺序连成较为线性的叙事结构。这就导致了不少的哲学家在书中只是几笔带过，甚至没有提及。

不过书中提到的哲学家，他们的著作想要拜读一遍，已经有相当的工作量了，如果后续还有余力，可以进一步发散研究。

这本书非常有意思的一点，里面提到了不少哲学家们的八卦，我常常和朋友们分享他们的恶心事迹，真是大开眼界。看来哲学家只是一份事业，而非一种人生态度。（对我就是在骂叔本华这样的人）

其他就没什么了。

推荐指数：7.5/10

使用 yt-dlp 从 Youtube 下载音频记录

Tsglz — Sat, 18 Apr 2026 00:00:00 GMT

今天突然想从 Youtube 上下载一些国内被 ban 掉的歌，但是发现需要充钱。于是笔者转头开始扒有没有小工具，还真找到一个：https://github.com/yt-dlp/yt-dlp

把它下载下来：https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe

首先测试了使用 edge 浏览器对 Youtube 内容进行爬取，命令如下：

yt-dlp --cookies-from-browser edge "https://www.youtube.com/watch?v=arGVWzrCnvM"

然后报错了，这个工具拿不到 edge 的 cookie：

Extracting cookies from edge ERROR: Could not copy Chrome cookie database. See https://github.com/yt-dlp/yt-dlp/issues/7271 for more info ERROR: Could not copy Chrome cookie database. See https://github.com/yt-dlp/yt-dlp/issues/7271 for more info

后面我查到一种方法，可以直接把浏览器的 cookie 保存下来供 yt-dlp 使用：即使用一个叫 get cookies txt 的插件（edge上叫这个）。但是实际测试结果不佳，这个插件获得不了 Youtube 页面的 cookie，如下图所示：

后续因为 edge 上开的页面太多了不方便测试排查失败原因，我直接转到 Chrome 浏览器。这里使用了一个叫 Get cookies.txt Clean 1.0 的插件，如下图所示：

使用方法：打开 chrome 浏览器，点开 Youtube 界面，使用插件将 cookies 导出到 txt：

然后就可以使用 yt-dlp 和 youtube.com_cookies.txt 来拉取想要的 mp3 文件。注意这里还有一个关键点：yt-dlp 在解析 Youtube 时需要执行 Youtube 的解密逻辑（Youtube 现在的视频流是被 signatureCipher 保护的，需要 js 解密参数）。所以 yt-dlp 必须下载 player JS，执行解密函数来还原真实 URL。

因为我的电脑上已经有 node.js，所以这里不过多讲解环境配置问题，而是分享工具使用的过程。

使用命令如下，即可得到想要的音频：

yt-dlp --cookies youtube.com_cookies.txt --js-runtimes node -f bestaudio --extract-audio --audio-format mp3 "https://www.youtube.com/watch?v=arGVWzrCnvM"

博客后续更新说明

Tsglz — Sun, 12 Apr 2026 00:00:00 GMT

前段时间一直沉迷收集一些书籍，有些书几乎绝版了不太好找，或者没有中文版本的书籍，所以精力大部分耗费在这件事上。

在对技术这方面的研究搁置了，博客更新也暂停了一段时间。后续会继续更新。

除了对技术的研究，我还会更新一些在其他领域的思考，看这篇博客的分类就知道了哈哈，主要是对哲学、心理学，还有一些神秘学的思考。因为我是实践派，所以更多地会结合与实操相关的知识，或者将理论与现实生活联系起来。

除此之外，我还是会继续更新[逆向分析]、[模型辅助视频内容概览]这两个开过的坑的内容，会更新的，我保证QAQ。

XMRig系列挖矿木马分析与yara检测（一）

Tsglz — Mon, 26 Jan 2026 00:00:00 GMT

XMRig 是一款专为门罗币（XMR）设计的高性能 CPU 挖矿软件，可以高效利用 CPU 资源，确保在不影响系统正常运行的前提下最大化挖矿效率。此外，该软件优化了在容器环境中的使用，便于在服务器等场景下部署和完成挖矿任务，且支持调整参数，实现个性化配置。

该软件可以在 github 上下载：https://github.com/xmrig/xmrig

接下来笔者会从 xmrig 原作者的开源代码和样本库中已经确认的 xmrig 系列挖矿木马两方面进行分析，从而找出该系列木马的通用检测规则。

首先开始对第一个样本的分析，对该系列样本有一个初步了解：

样本名：xmrig.exe

sha1:e502523c46e12da3006d86442a7d65aa46e490aa

sha256:0336e377528646d711dba3d88782426de25a8c5b4be587707d43ac7afe18f090

使用 DIE 对样本简单查看，发现该样本里附加了一个 ADL 音频文件：

对节进行查看，并没有发现非常明显的挖矿木马特征：

接下来使用 IDA 查看样本的运行逻辑：

整体看下来，很明显，这是一个 xmrig.exe 的启动器。首先样本获取自身路径：

然后创建字符串用于构造命令，这里能找到一个关键 IOC："xmrigMiner.exe"

后续是参数的拼接，最后跟随了一个重要参数：“ - -daemonized"，代表脱离控制台，在后台静默挖矿。

构造结构如下：

"xmrigMiner.exe" [argv[1] argv[2] ... argv[n]] " --daemonized"

经过逆向分析，该样本只是一个投递型 Miner Wrapper，而非实际挖矿的矿工程序，所以这里写了一个简单的匹配规则，如下所示：

import "pe"
rule pe_xmrig_coinminer_match
{
    meta:
        author = "tsglz"
        description = "投递型 Miner Wrapper"
    strings:
        $s1 = "xmrigMiner.exe" nocase
        $s2 = "--daemonized"
    condition:
        pe.is_pe and $s1 and $s2
}

VirusTotal-yara 规则学习（一）

Tsglz — Thu, 18 Dec 2025 00:00:00 GMT

VirusTotal 支持使用 yara 规则筛选样本，共有两种方式：

写 yara 上传到 Livehunt，匹配未来上传的样本
使用 Retrohunt 对 VT 历史样本进行离线批量匹配

在 VT 中使用 yara 的步骤：

点开侧边栏，在 IoC Investigation 中，下图黄框按需要点击即可：

Yara 基本规则：https://yara.readthedocs.io/en/stable/writingrules.html

这里为了更好地测试代码，我使用了 vscode+YARA(插件)+yara64.exe(和yara文件放在同一目录)+rule.yara 的配置，可以快速在本地对目标样本进行测试。

yara64.exe 可以从 https://github.com/VirusTotal/yara 下载。

这里先讲一讲一些比较常用的内容：

第一个是 yara 中常见的关键字：

all	and	any	ascii	at	base64	base64wide	condition
contains	endswith	entrypoint	false	filesize	for	fullword	global
import	icontains	iendswith	iequals	in	include	int16	int16be
int32	int32be	int8	int8be	istartswith	matches	meta	nocase
none	not	of	or	private	rule	startswith	strings
them	true	uint16	uint16be	uint32	uint32be	uint8	uint8be
wide	xor	defined

yara 规则通常由两部分组成：字符串定义（strings）和条件（condition）。字符串有三种类型，十六进制，文本和正则表达式。

所以第二个讲一下 yara 中的字符串，yara 中的字符串有三种类型：

十六进制字符串
文本字符串
正则表达式

十六进制字符串最基本的写法如下：

rule test
{
    meta:
        author = "tsglz"
    strings:
        $hex = { 4D 5A 90 00 }
    condition:
        $hex
}

这段规则会在样本中查找 $hex 匹配的 16 进制字符串。

除此之外，十六进制字符串有 4 种特殊结构：通配符，非运算符，跳转和替代。

通配符可以占位，表示某个位置的字节位置，但是存在，可以匹配任何内容，用法如下所示：

rule test
{
    meta:
        author = "tsglz"
    strings:
        $a = { 4D 5A ?? ?? }    // MZ 头
    condition:
        $a
}

这样写相较于前一种能够更好地匹配 MZ 头，避免遗漏。另外，通配符是按半字节定义的，所以可以只定义字节的一半，而另一半设置为未知。

从 4.3.0 版本开始，可以使用非运算符，指定某个字节不是特定值。原文档中有如下用法：

rule test
{
    strings:
        $hex_string = { F4 23 ~00 62 B4 }
        $hex_string2 = { F4 23 ~?0 62 B4 }
    condition:
        $hex_string and $hex_string2
}

当出现可变长度时，需要使用跳转运算符，如下所示：

rule test
{
    strings:
        $hex_string = { F4 23 [4-6] 62 B4 }

    condition:
        $hex_string
}

其中 [4-6] 表示 4 到 6 字节的任意序列都可以占据这个位置。但是注意，下限不能大于上限。

有时，可能需要为某个片段提供不同的替代方案，文档中举例如下：

rule test
{
    strings:
        $hex_string = { F4 23 ( 62 B4 | 56 ) 45 }

    condition:
        $hex_string
}

然后是文本字符串，最基本的用法如下：

rule test
{
    strings:
        $text_string = "shellcode"

    condition:
        $text_string
}

文本字符串支持如下转义字符：

	`\"`	Double quote 双引号
	`\\`	Backslash 反斜杠
	`\r`	Carriage return 回车
	`\t`	Horizontal tab 水平标签
	`\n`	New line 换行符
	`\xdd`	Any byte in hexadecimal notation 十六进制表示法中的任何字节

nocase 修饰符可以将字符串转换为不区分大小写模式，此修饰符可以与除 base64 、 base64wide 和 xor 之外的任何修饰符一起使用。用法如下：

rule test
{
    meta:
        author = "tsglz"
    strings:
        $a = "Nocase" nocase
    condition:
        $a
}

宽字符字符串可用于搜索每个字符使用两个字节编码的字符串，例如，如果字符串“Borland”以每个字符两个字节（即 B\x00o\x00r\x00l\x00a\x00n\x00d\x00 ）的形式编码，则以下规则将匹配：

rule test
{
    strings:
        $wide_string = "Borland" wide

    condition:
        $wide_string
}

注：这里的修饰符只是将字符串中字符的 ASCII 码与零交错排列，它并不支持包含非英文字符的真正 UTF-16 字符串。

xor 修饰符可用于搜索应用了单字节 xor 运算的字符串。也就是说，但你怀疑某段文本在样本中存在异或版本，可以使用这个修饰符，用法如下：

rule test
{
    strings:
        $xor_string = "This program cannot" xor

    condition:
        $xor_string
}

一旦使用了 xor 修饰符，该文本会被尝试从 0x00 ~ 0xFF 的密钥进行异或，有一个命中即判定为命中。

文档中提到将 xor 修饰符与 wide 和 ascii 结合使用。xor 修饰符会应用在所有其他修饰符之后。这意味着同时使用 xor 和 wide (WIDE) 会导致异或运算应用于交错的零字节。

此外，yara 3.11 起，可以对 xor 的字节范围进行限定，写法如下：

rule test
{
    strings:
        $xor_string = "This program cannot" xor(0x01-0xaa)
    condition:
        $xor_string
}

base64 可用于搜索经过 base64 编码的字符串，base64wide 则是先将原始字符转换为两个字节的形式，再做 base64 进行匹配。base64 和 base64wide 修饰符仅支持文本字符串。

rule test {
    strings:
        $a = "This program cannot" base64
        $b = "This program cannot" base64wide
    condition:
        $a and $b
}

值得一提的是，base64 和 base64wide 支持自定义字母表，但是字母表长度必须为 64 字节。用例如下所示：

rule test
{
    strings:
        $a = "This program cannot" base64("!@#$%^&*(){}[].,|ABCDEFGHIJ\x09LMNOPQRSTUVWXYZabcdefghijklmnopqrstu")
    condition:
        $a
}

yara 在 base64 编码后会去除开头和结尾的字符，这是为了更好地命中样本，减少漏报。但因此需要注意，使用 base64 相关的匹配时，尽量不要使用过短的字符串进行匹配，以避免大量误报的可能。

fullword 可以对字符串进行一个更严格的限制，保证字符串仅在文件中以非字母，数字字符分隔时才会匹配。例如，如果将字符串 domain 定义为 fullword ，则它不会匹配 www.mydomain.com ，但会匹配其他内容。 www.my-domain.com 和 www.domain.com 。

最后是正则表达式：

这个不多赘述了，需要什么规则和 ai 说让它写就完了，示例如下：

rule test
{
    strings:
        $re1 = /md5: [0-9a-fA-F]{32}/
        $re2 = /state: (on|off)/
    condition:
        $re1 and $re2
}

正则表达式也可以像文本字符串一样，后跟 nocase 、 ascii 、 wide 和 fullword 修饰符。此外，可以使用修饰符 i 来忽略大小写，在要匹配的内容中加 . 来匹配任意字符（默认不匹配换行符），但是可以使用修饰符 s 来匹配换行符。示例如下：

rule test
{
    strings:
        $re1 = /foo/i    // 大小写不敏感
        $re2 = /bar./s   // bar后可跟任意一个字符，包括换行符
        $re3 = /baz./is  // 同上，且不区分大小写
    condition:
        any of them
}

此外，有一个比较好用的修饰词 private，可以让规则正常匹配，但不会在命中输出中显示，这样既可以避免检测点暴露，又可以减少输出过程中的噪声。示例如下：

rule test
{
    strings:
        private $helper1 = "cmd.exe"
        private $helper2 = "powershell"
        $core = "Invoke-Mimikatz"

    condition:
        ($helper1 or $helper2) and $core
}

Keyword 关键词	String Types 字符串类型	Summary 概括	Restrictions 限制
`nocase`	文本，正则表达式	忽略大小写	不能与 `xor` 、 `base64` 或 `base64wide` 一起使用。
`wide`	文本，正则表达式	通过穿插空字符 (0x00) 来模拟 UTF-16 编码	无
`ascii`	文本，正则表达式	同时匹配 ASCII 字符，仅当使用 `wide` 集时才需要。	无
`xor`	文本	与单字节键进行文本字符串异或运算	不能与 `nocase` 、 `base64` 或 `base64wide` 一起使用。
`base64	文本	转换为 3 种 base64 编码字符串	不能与 `nocase` 、 `xor` 或 `fullword` 一起使用。
`base64wide	文本	转换为 3 种 base64 编码字符串，然后像 `wide` 一样交错插入空字符。	不能与 `nocase` 、 `xor` 或 `fullword` 一起使用。
`fullword`	文本，正则表达式	匹配项前后没有字母，数字，字符	不能与 `base64` 或 `base64wide` 一起使用。
`private`	十六进制、文本、正则表达式	结果不包含在输出中	无

这里笔者尝试写了一个通用样本的匹配规则，通过 Retrohunt 来查找符合条件的样本：

import "pe"

rule test_match
{
    meta:
        author = "tsglz"
    strings:
        $a = "Software\\Microsoft\\Windows\\CurrentVersion\\Run" //持久化
        $b = { 4D 5A ?? ?? }    // MZ 头
        $rwx = {41b940000000 41b8 [4 - 24] ff15}    //申请RWX内存
    condition:
        $a and $b and $rwx
}

这段规则匹配了三部分内容，首先是 $a 检测常见的注册表持久化路径；然后通过 $b 检测 PE 文件头 MZ；最后通过 $rwx 十六进制匹配典型的 mov rax, ...; mov r8, ...; call [func] 形式，尝试匹配 RWX 分配。

这段规则需要三点均满足才匹配（PE 恶意样本 + 持久化 + RWX），限制较为严格，容易产生误报和漏报：

首先是注册表路径，可能出现在一些合法启动的程序中，造成误报；
其次，RWX 内存申请通配符可能过于严格，造成漏报，可以针对性地放宽部分条件。

在下一篇中笔者将讲一讲 yara 中的条件，同时讲一讲怎么提高匹配的针对性。此外，之后会对单一系列的样本进行高准确度的匹配，这需要对相关样本进行分析。

需要注意的是，规则的构建并不是一劳永逸的，而是伴随着攻防双方的不断对抗，技术的不断迭代，需要不断更新的长期工作。

大模型辅助 Bilibili 视频内容概览（二）

Tsglz — Tue, 02 Dec 2025 00:00:00 GMT

在上一篇大模型辅助总结的文章中，笔者提出两个问题：

手动操作过于麻烦，希望能够添加爬虫实现一键拉取功能
部分 B 站视频没有相应的字幕，或者音频模糊，导致文本出现偏差的问题。

今天笔者对问题一实现了脚本修正：

首先为了模块清晰，笔者对之前的脚本进行了分文件处理，同时添加了自动爬取的模块，现在的代码架构如下：

原来的一个文件被分为了四个：

[Bili_ai_fast_get]
    deepseek_llm.py
    get_subtitle.py
    main.py
    zhipu_llm.py

这里简化了手动从网页中拉取 json 的步骤，转为直接通过输入的链接自动提取 BV 号并解析，获取字幕接口并将提取到的字幕保存到本地文件中。

关键代码如下：

import json
import requests
import re

def fetch_and_save_subtitles(bvnane: str, file_name: str = "content.txt"):
    # 目标网址和请求头
    headers = {
        "Cookie": "",   # 填自己的
        "Origin": "https://www.bilibili.com",
        "User-Agent": ""    # 填自己的
    }

    # 视频的 URL
    pp = "0"
    url = f"https://www.bilibili.com/video/{bvnane}/?spm_id_from=333.1007.tianma.1-2-2.click&vd_source=efbc10526f5fa5642530923cf09ce506&p={pp}"

    # 发送HTTP请求获取页面
    response = requests.get(url, headers=headers)

    # 提取 aid 和 cid
    aid_match = re.findall(r'.*,"aid":(\d+),', response.text)
    cids_match = re.findall(rf'"{bvnane}","cid":(\d+),', response.text)

    if aid_match and cids_match:
        aid = aid_match[0]
        cid = cids_match[0]
        print(f"aid: {aid}, cid: {cid}")

        # 获取字幕接口 URL
        hturl = f"https://api.bilibili.com/x/player/wbi/v2?aid={aid}&cid={cid}"
        print(f"[+]请求字幕接口: {hturl}")

        # 发送第二次请求
        response2 = requests.get(hturl, headers=headers)

        # 提取字幕url
        pattern = r'"subtitle_url":"(.*?)","subtitle_url_v2"'
        match = re.search(pattern, response2.text)

        if match:
            subtitle_url = match.group(1)
            print(f"[+]字幕 URL: https:{subtitle_url}")

            # 请求字幕文件
            uul = f"https:{subtitle_url}"
            responses1 = requests.get(uul, headers=headers)

            # 解析字幕文件数据
            data = json.loads(responses1.text)

            # 提取 content 内容
            contents = [item['content'] for item in data['body']]

            # 将每一句话写入到文本文件
            with open(file_name, "w", encoding="utf-8") as file:
                for line in contents:
                    file.write(f"{line}\n")
            print(f"[+]已将字幕内容保存到 {file_name} 文件。")
            return file_name
        else:
            print("[!]未找到字幕 URL")
            return ""
    else:
        print("[!]未能提取到 aid 或 cid")
        return ""

目前需要完善的部分如下：

实现批量总结。
对音频模糊但是有字幕的视频实现OCR文字识别。
对音频模糊且难以提取字幕的视频尝试修复。
对论文导读类视频的拆解，只提取笔者感兴趣的部分，其他全部丢弃，对接收信息进行提纯。
对过长的内容可能需要进行预处理，节省token的同时，提高大模型提炼的准确度。

下一次讲讲简单的 OCR 功能实现，以及整合过程中的一些问题（等我把问题解决完先）

大模型辅助 Bilibili 视频内容概览（一）

Tsglz — Mon, 17 Nov 2025 00:00:00 GMT

因为事务繁忙，最近我对 ai 智能总结产生了兴趣，做了几次总结之后发现效果还不错，这里做一个初版的记录，之后会逐步完善整个工作流。

目前的 demo 自动化的程度并不高，目前的工作流程如下：

首先设计一个从 json 文件中提取目标文本的函数，在提取之前，我们要先观察一下 json 的格式：

{
  "font_size": 0.4,
  "font_color": "#FFFFFF",
  "background_alpha": 0.5,
  "background_color": "#9C27B0",
  "Stroke": "none",
  "type": "AIsubtitle",
  "lang": "zh",
  "version": "v1.7.0.4",
  "body": [
    {
      "from": 0.0,
      "to": 0.24,
      "sid": 1,
      "location": 2,
      "content": "Hello",
      "music": 0.0
    },
    {
      "from": 0.24,
      "to": 0.64,
      "sid": 2,
      "location": 2,
      "content": "大家好",
      "music": 0.0
    },
    {
      "from": 509.08,
      "to": 509.5,
      "sid": 201,
      "location": 2,
      "content": "拜拜",
      "music": 0.0
    }
  ]
}

于是设计提取函数如下：

def extract_subtitles(json_path: str, output_path: str = None):
    json_file = Path(json_path)
    if not json_file.exists():
        print(f"[!] 文件不存在: {json_file}")
        return None
    with open(json_file, "r", encoding="utf-8") as f:
        data = json.load(f)
    body = data.get("body", None)
    if not body:
        print("[!] JSON中未找到 'body' 字段，可能不是字幕文件格式。")
        return None
    subtitles = [entry.get("content", "").strip() for entry in body if "content" in entry]
    text = "\n".join(subtitles)
    if not output_path:
        output_path = json_file.with_suffix(".txt")
    with open(output_path, "w", encoding="utf-8") as f:
        f.write(text)
    print(f"[+] 提取完成：{output_path}")
    return output_path

将提取到的内容单行保存在 content.txt 中，然后调用 deepseek-chat，glm-4.5-flash 模型二选一进行总结，前者需要付费，后者在一定额度内免费使用。经过测试，两者的准确度相差不打大，所以默认使用后者进行总结。

提示词使用如下，因为我会挑选一部分写入博客，所以预留了一个标题的位置：

messages=[
    {
        "role": "system",
        "content": (
        "你是一个有用的AI助手，现在请你对如下文本进行总结，要求语言精炼并保持原意。\n\n"
        "【输出格式要求】\n"
        "- 使用 Markdown 形式输出\n"
        "- 顶层标题统一使用“##”\n"
        "- 二级标题统一使用“###”\n"
          "- 不得修改原文本含义，仅优化结构与表达"
          ),
     },
]

前两次 ai 总结内容同样在博客里，这里给出链接：

2025.11.10-ai总结

2025.11.16-ai总结

在实际使用的过程中感官还算可以，但是手动操作过于麻烦；而且部分 B 站视频没有相应的字幕，或者音频模糊，导致文本出现偏差的问题，后续将从这两个方向继续完善。

2025.11.16-ai总结

Tsglz — Sun, 16 Nov 2025 00:00:00 GMT

美股加密金库热潮分析

现象概述

美股市场上出现"加密金库"热潮，指一些小型边缘上市公司通过转型加密资产托管实现估值飙升
这些公司通常市值极低(如Sharp Link Gaming最初仅200万美元)，通过宣布加密资产战略获得巨额估值增长
Sharp Link Gaming案例：市值从200万美元暴涨至25亿美元，估值比资产溢价488%

套利机制

核心逻辑：美股市场对加密资产存在估值溢价(1美元加密资产可定价为2-6美元)
操作流程：
1. 小型私募融资(如Sharp Link募资4.25亿美元)
2. 用资金购买加密货币(如以太坊)
3. 保留原业务维持上市地位
4. 利用高估值卖给二级市场投资者

内在矛盾

传统金融规则与加密世界估值逻辑冲突
部分公司复制模式但无实质业务，估值与基本面脱节
实业公司(如苹果)拒绝参与，而加密基金若不参与被视为管理不善
监管滞后，可能存在内幕交易问题

变现困境

股份流动性差：Sharp Link 97%股份被私募锁定，按日均成交量需3年才能完全退出
变现尝试：
- 增发新股购买更多加密资产(相当于吹大泡沫)
- 高管通过薪酬方式套现(金额与原始资本规模不匹配)
加密资产波动性和股票流动性风险使账面利润难以落袋为安

法律争议案例

Mango Markets套现事件

交易员利用去中心化交易所漏洞，操纵MNGO代币价格暴涨1300%
以虚高市值作抵押，借出价值超1亿美元加密货币
法律复杂性：
- "代码即法律"原则被挑战：法官指出规则不明确
- 用户无法证明理解并同意还款承诺
- 司法管辖权争议：事件发生在波多黎各，服务器在巴哈马和罗马尼亚，案件提交纽约法院

FTX崩塌与魔法豆陷阱

魔法豆陷阱：纸面财富与真实价值脱节现象
FTX案例：估值最高达320亿美元，核心资产仅为自发行FTT代币，无外部资产支撑
市场信任崩塌后无法应对用户挤兑，48小时内因用户提币超60亿美元导致破产
影响：投资者损失惨重，动摇加密市场信用根基

投资者建议

认识到市场对创新事物可能过度热情
警惕估值逻辑矛盾、账面利润难以变现等风险
投资者应保持冷静，不被热潮冲昏头脑
机会与风险同在，需全面评估后谨慎参与

DeFi行业SEC政策转变与未来发展趋势分析

SEC政策转向的影响

为DeFi打开更广阔大门，明确矿工和验证者豁免证券法监管
PoW和PoS网络法律风险基本解除，缓解行业担忧
支持自我托管和创新豁免机制，使行业更接近主流
释放约900亿美元TVL市场潜力，借贷DEX和稳定币占市场78%
行业合规成本下降40%

DeFi的独特优势

基于区块链的开放金融架构，核心为智能合约
自动执行交易，无需传统金融机构作为中介
无需复杂KYC，可覆盖17亿无银行账户人群
开源代码不可篡改，交易透明度高
协议间可组合性创造创新金融产品(如闪电贷)

DeFi行业规模与结构

总锁仓价值突破900亿美元
借贷和DEX为最大板块，年复合增长率62%
借贷协议占41%市场份额，主导项目为Aave和Compound
DEX交易量占整个加密市场38%，做市商机制降低滑点
稳定币日均结算量达680亿美元，超过Visa网络

技术演进中的挑战

以太坊拥堵问题通过多链生态和Layer2方案改善
跨链桥安全事故每年造成近13亿美元损失
MEV问题严重，年抽成达8亿美元

机遇与风险

机遇：

机构资金入场，合规DeFi资产管理规模突破400亿美元
RWA tokenization打开万亿美元市场可能
嵌入式金融降低用户使用门槛，减少60%中间成本

风险：

2023年因智能合约漏洞损失23亿美元
稳定币脱钩事件导致单日TVL撤出27%
全球监管差异增加200%合规成本
MEV抽成每年8亿美元限制行业发展

竞争格局与未来趋势

头部项目形成：Aave V3支持七条链，市占率51%；Uniswap V4 hooks机制增强定制化
未来趋势：账户抽象、零知识证明、监管科技成为发展关键
DeFi保险协议年增长率达300%

健康发展所需机制

技术创新：开发形式化验证工具减少智能合约漏洞
风险管理：建立跨链流动性储备应对市场波动
监管协同：参与国际组织推动监管标准统一、与传统金融机构合作开发混合型产品

2025.11.10-ai总结

Tsglz — Mon, 10 Nov 2025 00:00:00 GMT

2025.11.9 19点场分析总结

一、全球市场风险与港股影响

外围市场压力：日韩、美股市场出现风险信号，如大幅回调、阴线扩大，可能引发连锁反应。
港股弱势：因海外投资者占比高，受外围市场低开影响显著，恒生指数易跟随下跌。
AI产业链风险：美股头部AI公司（如OpenAI、英伟达）存在螺旋式上升的牛市泡沫，一旦下滑可能导致大幅回撤。

二、技术分析流派与应用

均线流派：适合趋势性行情，但在震荡市中易频繁报错（金叉死叉反复），导致高买低卖。
裸K流派：关注价格点位和箱体结构，适用于横盘震荡行情，需等待突破上沿并放量信号。
核心观点：技术流派需根据市场结构（趋势性或震荡性）选择适用方法，避免方法论错误。

三、REITs（房地产投资信托基金）分析与风险

基本概念：将实物资产（如高速公路、产业园）证券化，份额公开交易，规定90%以上可分配金额必须分红。

收益陷阱：

使用权型REITs（如高速公路）：需扣除折旧（1/收费年限），例如20年期收费权扣除5%，若股息率4%，实际收益为负。
产权型REITs（如保障房）：扣除1.5%折旧，实际收益需调整。
风险提示：部分REITs通过会计手段（如汇兑损失）降低分红，投资者需仔细甄别底层资产和收费年限。

四、公司特定分析

HH国际控股：

优势：收购海外品牌（如斯维斯、宠物品牌）在国内生产，利用品牌溢价。
风险：高负债并购，财务压力大，债务率超60%，建议轻仓操作。

比亚迪：

看好其产业地位，但认为当前估值过高，需下跌30%-40%才考虑入场。
商业模式属重资产制造业，竞争激烈。

白酒行业：

消费场景稳固（如商务宴请），茅台等高端酒具备周期性调整而非长期衰退。
强调消费股的复购性优势（如牛奶），优于制造业（如家电）。

泡泡玛特：

利润依赖盲盒销量增长，非二级市场炒作。
风险：产能扩大可能抑制炒作价格，存世量增加或导致过剩。

五、投资哲学与建议

逆周期投资：
分散化：避免单压一家公司，选择多行业头部企业。
兜底要求：目标4%以上股息率，确保现金流覆盖时间成本。
头部公司优先：如蒙牛、海底捞，基本面强且易受资金关注。
风险警示：
避免在牛市盲目自信加杠杆，熊市谨慎投资更安全。
低利率环境下，上市公司债务多数只增不减，需警惕财务风险。
学习与实证：
推荐经典书籍（如费雪《如何选择成长股》、格雷厄姆《证券分析》）。
强调学以致用，通过计算和实践验证理论。

六、市场制度批评

A股上市问题：优质消费股（如蜜雪冰城、泡泡玛特）多赴港股上市，A股充斥高融资低分红企业，导致市场抽血效应。
建议：鼓励盈利企业回A股，将PPT概念股移至海外，改善投资者回报。

七、其他话题

保险公司与证券公司：利润波动大因投资业务影响，分红与现金流关联弱，需穿透看实际可分配利润。
港口与航运：推荐躺着收钱模式（如天津港、中国船舶租赁），规避周期性强的远洋航运。

总结：用户强调理性投资、方法论适配市场环境，并警示当前外围风险与高估值陷阱。建议投资者聚焦低估值、高分红资产，避免盲目跟风，并通过持续学习提升认知。

擒龙先生-11.9-下周动向

一、投资要点

量子科技：机会渺茫(概率≈0)，可考虑回落后小仓位低吸，如持续上涨应离场
光伏板块：趋势看好，可关注低位机会，核心是阳光电源，需注意其承接情况
芯片股：关注寒武纪、中际旭创，但受资金虹吸效应和投机市场压制
商业航天：新方向商业航天，关注中国卫星、航天智装，航天科技，沿趋势低吸，避免梭哈

二、投机风向

风向标：平潭、合富、海马，下周地位排序可能为合富>平潭>海马
需密切关注平潭和合富表现，若无大幅负反馈，可继续关注板块
重点关注海马汽车(海马)、福龙马(福马)、神马电力等

三、操作建议

趋势股操作：关注5日线支撑，如立达信、云铝股份、振德医疗、振华科技
破位止损：跌破5日线需观察尾盘能否收回或分时是否有承接
风险控制：判断不会100%正确，严格控制仓位，不要一次性梭哈

Kill Chain 模型

Tsglz — Fri, 03 Oct 2025 00:00:00 GMT

Kill Chain 模型是网络安全和军事领域中用于描述攻击过程的一个经典框架，最初由美国空军在 20 世纪 90 年代提出，用于描述军事打击的流程，后被借鉴应用于网络空间安全领域，成为网络攻击分析、防御规划和威胁检测的重要工具。

Kill Chain 总共分为七个阶段：

Reconnaissance：侦查阶段，主要是收集情报，包括目标的网络信息、系统信息、人员信息、敌人的信息等。
Weaponization：武器化阶段，主要是根据收集到的信息制作针对性的恶意载荷。
Delivery：投递阶段，主要是将恶意载荷投递到目标系统。
Exploitation：利用阶段，主要是利用目标系统的漏洞进行攻击。此时恶意载荷已经在目标机器上执行。
Installation：安装阶段，植入持久化后门，比如将恶意载荷植入系统的启动项中或计划任务中。
Command and Control：命令控制阶段，主要是控制目标系统的执行，包括控制目标机器的操作系统、网络、数据等。
Actions on Objectives：行动阶段，主要是执行攻击者的最终目标，比如窃取数据、破坏系统、控制网络等。

由于 Kill Chain 模型已经较为久远，在实践过程中已经衍生出了更多新的操作分支，比如：对攻击痕迹进行清理；横向渗透......等等。

在命令控制阶段和行动阶段之间可以插入更多的操作，来达成隐藏或者进一步攻击的目的。

对TEMPEST代码的研究（一）

Tsglz — Mon, 24 Mar 2025 00:00:00 GMT

项目地址：Teach2Breach/Tempest: A command and control framework written in rust.

Tempest 是一个完全由 rust 编写的研究性 C2，作者在项目介绍中提到，该项目并未借鉴其它框架，是以该项目生成的 shellcode 或许可以与 cobalt strike 生成的 shellcode 进行对比学习

Tempest 的组件分为如下三部分：服务器，客户端，代理/植入物顺便一提，由于笔者对于 linux 以及 mac 不甚精通，目前的研究仅限于 Windows 部分的分析

基础架构

Anvil - 服务器

2 个带有 API 的服务器。所有 API 都经过身份验证，并且不支持 unauth-discovery。
SQLite 本地数据库
内部功能（构建 IMPS、生成 shellCode 等）

Conduit - 黑客客户端

终端用户界面（TUI）
“实时”仪表板显示
便携，完全在终端中运行

IMPS - 信标/代理/植入物 Windows 功能：

通过 TLS 的 AES 加密通信
专注于 OPSEC，功能丰富（无膨胀）
远程进程注入
Bof 支持
.DOTNET 可执行文件支持
WMI
TEB 步行 “noldr”

服务器-anvil

当前配置为 2 个不同端口（443，8443），在 config.toml 中进行配置，443 被用于植入物，目前不支持关闭侦听器，处于默认打开状态。此外，初始访问使用的是 HTTPS 协议，其它协议有待拓展

anvil 服务器使用 config.toml 进行配置，用户可在其中定义自己的用户名和密码进行验证或其它操作（如 LITCRYPT 密钥）。服务器还需要本地存储的 TLS 证书才能通过 HTTPS 提供内容

config.toml 文件示例

[[users]]
username = "forge"
password = "forge"

[[users]]
username = "adversary"
password = "pwd1"

[cert]
private_key = "/home/adversary/Tempest/Anvil/cert/key.pem"
certificate = "/home/adversary/Tempest/Anvil/cert/cert.pem"

[crypt]
LITCRYPT_ENCRYPT_KEY = "......"

填写完配置文件，即可使用如下命令进行构建

cargo build --release

客户端-conduit

跨平台的与 c2 交互的客户端，完全在终端运行，编译后可以移植

其中坏死植入物用红色表示，管理员用橙色表示，存活植入物用白色表示

植入物

Windows 植入程序使用 LdrGetDllHandle 和 LdrGetProcedureAddress 来查找程序中调用的几乎所有其他 API 的函数地址。

而 Windows_noldr 变体使用 TEB->PEB 遍历，首先读取 CPU 寄存器以查找 TEB（基于 NTCurrentTeb），然后定位 PEB 并遍历 PEB 以查找 ntdll.dll 或 kernel32.dll 等 dll。这允许植入体查找 API 调用的函数地址，而无需调用 LdrGetDllHandle 和 LdrGetProcedureAddress

socks 代理，该模块目前为单个植入物设计。出于安全考虑，作者将代理设置为仅在 c2 服务器上本地可用。这意味着为了使用代理，操作者必须通过 ssh 进入运行 anvil c2 服务器的机器，命令如下：

ssh -L 1080：localhost：1080 username@anvilserver

differences

在作者的描述中，目前该项目可以生成 exe 和 dll 文件，但由于时间有限，并不支持生成 shellcode

此外，作者采用精简化处理框架，删去了大量冗余功能，加入了 bof 支持、有效的远程进程注入和 WMI 支持，编写了 whoami、ipconfig 和其他更基本的模块（如 ps），通过实际深入研究 Windows 内部，并调用与 Task Manager 等相同的函数，以与 Task Manager 相同的方式检索进程列表，但使用隐蔽的动态定位函数地址

具体如何实现还需要进一步对项目进行分析

ppid 伪造(一)

Tsglz — Mon, 10 Mar 2025 00:00:00 GMT

让恶意的程序看起来是由另一个进程产生的，主要用于逃避基于父子进程关系的检测

Windows 不能直接修改 ppid，只能在创建新进程时指定父进程句柄

使用环节

通常使用在加载器中，也可以存在 payload 中或者将加载器和 payload 一同送进目标主机

伪造方法

首先构造一个能够检索目标父进程的 pid 的函数，这样可以减少手动操作的不便

// 检索目标父进程的pid
DWORD getPPID(LPCWSTR processName)
{
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 process = { 0 };
    process.dwSize = sizeof(process);
    if (Process32First(snapshot, &process))
    {
        do
        {
            if (!wcscmp(process.szExeFile, processName))
                break;
        } while (Process32Next(snapshot, &process));
    }
    CloseHandle(snapshot);
    return process.th32ProcessID;
}

主函数中进行调用

#include <iostream>
#include <windows.h>
#include <tlHelp32.h>

int main()
{
    STARTUPINFOEX si = { sizeof(STARTUPINFOEX) };
    PROCESS_INFORMATION pi;
    SIZE_T attributeSize;
    ZeroMemory(&si, sizeof(STARTUPINFOEXA));

    // 通过函数 getPPID 获取目标父进程的 pid
    // 输入目标进程的名称
    LPCWSTR parentProcess = L"explorer.exe";
    DWORD parentPID = getPPID(parentProcess);
    printf("[+] Spoofing %ws (PID: %u) as the parent process.\n", parentProcess, parentPID);

    // 这里末尾的数字是目标父进程的 pid，可以自定义函数获取
    HANDLE expProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, parentPID);
    InitializeProcThreadAttributeList(NULL, 1, 0, &attributeSize);
    si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, attributeSize);
    InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attributeSize);
    UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &expProcess, sizeof(expProcess), NULL, NULL);
    si.StartupInfo.cb = sizeof(STARTUPINFOEXA);
    // 这里添加目标子进程的路径或者启动命令
    LPCWSTR spawnProcess = L"C:\\Windows\\System32\\notepad.exe";
    CreateProcess(spawnProcess, NULL, NULL, NULL, TRUE, EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, (STARTUPINFO*)&si, &pi);
    printf("[+] Spawning %ws (PID: %u)\n", spawnProcess, pi.dwProcessId);
    return 0;
}

测试结果

可以看到伪造成功了，弹出了记事本

[+] Spoofing explorer.exe (PID: 12048) as the parent process.
[+] Spawning C:\Windows\System32\notepad.exe (PID: 32968)

权限问题

如果目标父进程的完整性级别超过了标准用户，我们就无权访问这样的进程。

此时，我们就希望能有一个函数能够帮助我们检查进程的完整性级别，这个操作使用的函数为 GetTokenInformation，它能够检索与进程关联的访问令牌的信息

修改后的代码如下

#include <windows.h>
#include <TlHelp32.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <atlconv.h>
using namespace std;

// 异常处理
string get_last_error(DWORD errCode)
{
	string err("");
	if (errCode == 0) errCode = GetLastError();
	LPTSTR lpBuffer = NULL;
	if (0 == FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, //标志位，决定如何说明lpSource参数，
																					// dwFlags的低位指定如何处理换行功能在输出缓冲区，也决定最大宽度的格式化输出行,可选参数
		NULL,	// 根据dwFlags标志而定
		errCode,	// 请求的消息的标识符
					// 当dwFlags标志为FORMAT_MESSAGE_FROM_STRING时会被忽略
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),	//请求的消息的语言标识符
		(LPTSTR)&lpBuffer,	//接收错误信息描述的缓冲区指针
		0,	//如果FORMAT_MESSAGE_ALLOCATE_BUFFER标志没有被指定，这个参数必须指定为输出缓冲区的大小，如果指定值为0，这个参数指定为分配给输出缓冲区的最小数
		NULL	//保存格式化信息中的插入值的一个数组
	))
	{//失败
		char tmp[100] = { 0 };
		sprintf_s(tmp, "{未定义错误描述(%d)}", errCode);
		err = tmp;
	}
	else    //成功
	{
		USES_CONVERSION;
		err = W2A(lpBuffer);
		LocalFree(lpBuffer);
	}
	return err;
}

// 检查进程的完整性级别
LPCWSTR getProcessIntegrityLevel(HANDLE hProcess, PDWORD pdwIntegrityLevel)
{
	DWORD dwError = ERROR_SUCCESS;
	HANDLE hToken = NULL;
	DWORD cbTokenIL = 0;
	PTOKEN_MANDATORY_LABEL pTokenIL = NULL;
	if (pdwIntegrityLevel == NULL)
	{
		dwError = ERROR_INVALID_PARAMETER;
		goto Cleanup;
	}
	// 以TOKEN_QUERY开启此线程的主访问令牌。
	if (!OpenProcessToken(hProcess, TOKEN_QUERY, &hToken))
	{
		cout << "[!] OpenProcessToken error!" << endl;
		dwError = GetLastError();
		goto Cleanup;
	}
	// 查询令牌完整性级别信息的大小。注意：我们预期得到一个FALSE结果及错误
	// ERROR_INSUFFICIENT_BUFFER， 这是由于我们在GetTokenInformation输入一个
	// 空缓冲。同时，在cbTokenIL中我们会得知完整性级别信息的大小。
	if (!GetTokenInformation(hToken, TokenIntegrityLevel, NULL, 0, &cbTokenIL))
	{
		if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
		{
			// 当进程运行于Windows Vista之前的系统中，GetTokenInformation返回
			// FALSE和错误码ERROR_INVALID_PARAMETER。这是由于这些操作系统不支
			// 持TokenElevation。
			cout << "[!] GetTokenInformation no support !" << endl;
			dwError = GetLastError();
			goto Cleanup;
		}
	}
	// 现在我们为完整性级别信息分配一个缓存。
	pTokenIL = (TOKEN_MANDATORY_LABEL*)LocalAlloc(LPTR, cbTokenIL);
	if (pTokenIL == NULL)
	{
		cout << "[!] pTokenIL is null" << endl;
		dwError = GetLastError();
		goto Cleanup;
	}
	// 获得令牌完整性级别信息。
	if (!GetTokenInformation(hToken, TokenIntegrityLevel, pTokenIL,
		cbTokenIL, &cbTokenIL))
	{
		cout << "[!] GetTokenInformation error !" << endl;
		dwError = GetLastError();
		goto Cleanup;
	}
	// 完整性级别SID为S-1-16-0xXXXX形式。（例如：S-1-16-0x1000表示为低完整性
	// 级别的SID）。而且有且仅有一个次级授权信息。
	*pdwIntegrityLevel = *GetSidSubAuthority(pTokenIL->Label.Sid, 0);
Cleanup:
	// 集中清理所有已分配的内存资源
	if (hToken)
	{
		CloseHandle(hToken);
		hToken = NULL;
	}
	if (pTokenIL)
	{
		LocalFree(pTokenIL);
		pTokenIL = NULL;
		cbTokenIL = 0;
	}
	if (ERROR_SUCCESS != dwError)
	{
		// 失败时确保此能够获取此错误代码
		SetLastError(dwError);
		return L"ERROR";
	}
	else
	{
		if (*pdwIntegrityLevel == SECURITY_MANDATORY_LOW_RID) {
			return L"LOW";
		}
		else if (*pdwIntegrityLevel >= SECURITY_MANDATORY_MEDIUM_RID && *pdwIntegrityLevel < SECURITY_MANDATORY_HIGH_RID) {
			return L"MEDIUM";
		}
		else if (*pdwIntegrityLevel >= SECURITY_MANDATORY_HIGH_RID) {
			return L"HIGH";
		}
		else if (*pdwIntegrityLevel >= SECURITY_MANDATORY_SYSTEM_RID) {
			return L"SYSTEM";
		}
	}
}
DWORD getPPID(LPCWSTR processName) {
	HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	PROCESSENTRY32 process = { 0 };
	process.dwSize = sizeof(process);
	bool flag = false;
	if (Process32First(snapshot, &process)) {
		do {
			if (!wcscmp(process.szExeFile, processName)) {
				HANDLE hProcess = OpenProcess(MAXIMUM_ALLOWED, FALSE, process.th32ProcessID);
				if (hProcess) {
					LPCWSTR integrityLevel = NULL;
					DWORD dwIntegrityLevel;
					integrityLevel = getProcessIntegrityLevel(hProcess, &dwIntegrityLevel);
					if (!wcscmp(integrityLevel, L"ERROR")) {
						cout << "[!] PID = " << process.th32ProcessID << " GetProcessIntegrityLevel failed, Error: " << get_last_error(GetLastError()) << endl;
						continue;
					}
					if (!wcscmp(integrityLevel, L"MEDIUM")) {
						flag = true;
						break;
					}
				}
			}
		} while (Process32Next(snapshot, &process));
	}
	CloseHandle(snapshot);
	// 没有找到 MEDIUM 权限的进程
	if (!flag) {
		cout << processName << " does have medium integrity level!!" << endl;
		exit(-1);
	}
	return process.th32ProcessID;
}
int main() {
	STARTUPINFOEXA si;
	PROCESS_INFORMATION pi;
	SIZE_T attributeSize;
	ZeroMemory(&si, sizeof(STARTUPINFOEXA));

	// 通过函数 getPPID 获取目标父进程的 pid
	// 输入目标进程的名称
	LPCWSTR parentProcess = L"svchost.exe";
	DWORD parentPID = getPPID(parentProcess);
	printf("[+] Spoofing %ws (PID: %u) as the parent process.\n", parentProcess, parentPID);

	// 这里末尾的数字是目标父进程的 pid，可以自定义函数获取
	HANDLE parentProcessHandle = OpenProcess(MAXIMUM_ALLOWED, false, parentPID);
	InitializeProcThreadAttributeList(NULL, 1, 0, &attributeSize);
	si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, attributeSize);
	InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attributeSize);
	UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &parentProcessHandle, sizeof(HANDLE), NULL, NULL);
	si.StartupInfo.cb = sizeof(STARTUPINFOEXA);

	// 这里添加目标子进程的路径或者启动命令
	LPCWSTR spawnProcess = L"C:\\Windows\\System32\\notepad.exe";
	CreateProcess(spawnProcess, NULL, NULL, NULL, TRUE, EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, (STARTUPINFO*)&si, &pi);
	printf("[+] Spawning %ws (PID: %u)\n", spawnProcess, pi.dwProcessId);
	return 0;
}

对抗检测

用这种方法伪造的 ppid 是能够被检测到的

https://github.com/countercept/ppid-spoofing/blob/master/detect-ppid-spoof.py

父进程欺骗绕过可以绕过脚本对于父子原进程关系的检测，减少被发现的可能，这个过几天写

Part_Two_A_Minimal_Rust_Kernel

Tsglz — Tue, 05 Nov 2024 00:00:00 GMT

目的

编译为一个特定的目标系统

新增 `FlowOS.json`

{
  "llvm-target": "x86_64-unknown-none",
  "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
  "arch": "x86_64",
  "target-endian": "little",
  "target-pointer-width": "64",
  "target-c-int-width": "32",
  "os": "none",
  "executables": true,
  "linker-flavor": "ld.lld",
  "linker": "rust-lld",
  "panic-strategy": "abort",
  "disable-redzone": true,
  "features": "-mmx,-sse,+soft-float"
}

build-std 特性

允许按照自己的需要重编译 core 等标准 crate，而不需要使用 Rust 安装程序内置的预编译版本

但是该特性是全新的功能，到目前为止尚未完全完成，所以它被标记为 “unstable” 且仅被允许在 Nightly 环境下调用

要启用该特性，在 .cargo/config.toml 写入以下语句：

[unstable]
build-std = [
  "core",
  "compiler_builtins"
]

该配置会告知cargo需要重新编译 core 和 compiler_builtins 这两个crate，其中 compiler_builtins 是 core 的必要依赖

重编译需要提供源码，使用如下命令来下载它们

rustup component add rust-src

编译命令

cargo build --target .\src\FlowOS.json

build-std-features

为了使用内存相关函数，在 .cargo/config.toml 的 [unstable] 写入以下语句：

build-std-features = [ "compiler-builtins-mem" ]

设置编译目标：在 .cargo/config.toml 加入如下选项，接下来，==使用 cargo build 即可进行编译==

这里因为一些原因，我使用了绝对路径

[build]
target = "F:\\vscode_repo\\Rust\\FlowOS\\src\\FlowOS.json"

向屏幕打印字符

写入 VGA 字符缓冲区，这段缓冲区的地址是 0xb8000，且每个字符单元包含一个 ASCII 码字节和一个颜色字节

代码修改

static HELLO: &[u8] = b"Hello World!";

#[no_mangle]
pub extern "C" fn _start() -> ! {
    let vga_buffer = 0xb8000 as *mut u8;

    for (i, &byte) in HELLO.iter().enumerate() {
        unsafe {
            *vga_buffer.offset(i as isize * 2) = byte;
            *vga_buffer.offset(i as isize * 2 + 1) = 0xb;
        }
    }

    loop {}
}

启动内核

创建引导映像

cargo add bootloader

我这里使用的是

bootloader = "0.9"

将内核和引导程序组合

cargo install bootimage

安装 llvm-tools-preview

rustup component add llvm-tools-preview

创建一个可引导的磁盘映像

cargo bootimage

编译好后能在文件夹中找到 bootimage-FlowOS.bin

运行

在 QEMU 中输入如下命令运行

qemu-system-x86_64 -drive format=raw,file=target\FlowOS\debug\bootimage-FlowOS.bin

也可以使用 dd 工具把内核写入 U 盘，以便在真机上启动，这里不多赘述

原代码作者补注：bootloader 包暂时不支持 UEFI，所以不能在 UEFI 机器上启动（现在不知道，没试）

使用 `cargo run`

在 .cargo/config.toml 中设置 runner 配置项：

[target.'cfg(target_os = "none")']
runner = "bootimage runner"

这样，就可以直接使用 cargo run 直接运行

Part_One_First_Sight

Tsglz — Tue, 05 Nov 2024 00:00:00 GMT

参考：独立式可执行程序 | Writing an OS in Rust

样例代码

#![no_std] // 不链接 Rust 标准库
#![no_main] // 禁用所有 Rust 层级的入口点

use core::panic::PanicInfo;

/// 这个函数将在 panic 时被调用
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

#[no_mangle] // 不重整函数名
pub extern "C" fn _start() -> ! {
    // 因为链接器会寻找一个名为 `_start` 的函数，所以这个函数就是入口点
    // 默认命名为 `_start`
    loop {}
}

cargo.toml

[package]
name = "FlowOS"
version = "0.1.0"
edition = "2021"

[dependencies]

[profile.dev]
panic = "abort"

[profile.release]
panic = "abort"

Windows 平台使用的编译命令不同

cargo rustc -- -C link-args="/ENTRY:_start /SUBSYSTEM:console"

也可以在 rust 目录下的 .cargo 文件夹下创建 config.toml 文件，输入

==注意；如果同时包含 config 和 config.toml 请二选一，如果同时存在，无后缀的会被加载==

[target.'cfg(target_os = "linux")']
rustflags = [
  "-C",
  "link-arg=-nostartfiles"
]

[target.'cfg(target_os = "windows")']
rustflags = [
  "-C",
  "link-args=/ENTRY:_start /SUBSYSTEM:console"
]

[target.'cfg(target_os = "macos")']
rustflags = [
  "-C",
  "link-args=-e __start -static -nostartfiles"
]

上述只是拓展的方法，之后的编译都使用裸机，输入如下代码

rustup target add thumbv7em-none-eabihf

编译命令

cargo build --target thumbv7em-none-eabihf

另附：使用 nightly 版本

Scripts

Tsglz — Fri, 18 Oct 2024 00:00:00 GMT

最近打比赛，发现有很多脚本能够实现模板化处理，能够节省大量时间

下面将展示笔者收藏的一些常用脚本

简单异或

#include <stdio.h>

int main() {
    int string_length = ; // 字符串长度
    int key = ;           // 密钥(需要异或的内容)

    // 定义v5数组
    unsigned char v5[string_length] = {
        // 密文
    };

    // 定义解密后的flag数组
    char flag[string_length + 1]; // 长度 + '\0' 结束符

    // 解密过程
    for (int i = 0; i < string_length; ++i) {
        flag[i] = v5[i] ^ key; // xor，这里的 key 也可以根据需要进行修改
    }
    flag[string_length] = '\0'; // 结束符

    // 输出解密后的结果
    printf("Flag: %s\n", flag);
    return 0;
}

带密钥的异或

# 密文
v6 = []

# 密钥
key = b""
key_length = len(key)

# 逆向解密，得到 flag
flag = []
for i in range(len(v6)):
    for j in range(4):  # 每个 v6[i] 是 4 个字节
        flag_byte = (v6[i] >> (j * 8)) & 0xFF  # 提取 v6[i] 的每个字节
        key_byte = key[(i * 4 + j) % key_length]  # 密钥循环使用
        decrypted_byte = flag_byte ^ key_byte  # 逆向异或得到原始字节
        flag.append(decrypted_byte)

# 输出解密得到的 flag
print(bytes(flag).decode())

大小写转化

from base64 import b64encode
from os import urandom

def Decrypt(msg, key):
    Lenth = len(key)
    result = ''

    upper_base = ord('A')
    lower_base = ord('a')
    KEY = [ord(key.upper()[_]) - upper_base for _ in range(Lenth)]

    index = 0
    for m in msg:
        tmp_key = KEY[index % Lenth]
        if not m.isalpha():
            result += m
            continue

        if m.isupper():
            result += chr(upper_base + (ord(m) - upper_base - tmp_key) % 26)
        else:
            result += chr(lower_base + (ord(m) - lower_base - tmp_key) % 26)
        index += 1
    return result

# 用你知道的key
key = "oWccl"  # 你需要知道加密时生成的密钥
encrypted_msg = "0lCcop{oyd94092-g8mq-4963-88b6-4helrxdhm6q7}"

# 解密
decrypted_flag = Decrypt(encrypted_msg, key)
print(decrypted_flag)

大小写转化+简单移位

from base64 import b64encode
from os import urandom

def Decrypt(msg, key):
    Lenth = len(key)
    result = ''

    upper_base = ord('A')
    lower_base = ord('a')
    KEY = [ord(key.upper()[_]) - upper_base for _ in range(Lenth)]

    index = 0
    for m in msg:
        tmp_key = KEY[index % Lenth]
        if not m.isalpha():
            result += m
            continue

        if m.isupper():
            result += chr(upper_base + (ord(m) - upper_base - tmp_key) % 26)
        else:
            result += chr(lower_base + (ord(m) - lower_base - tmp_key) % 26)
        index += 1
    return result

# 用你知道的key
key = ""  # 加密时生成的密钥（如果你知道部分信息，你可以逆推出来）
encrypted_msg = ""  # 移位的密文

# 解密
decrypted_flag = Decrypt(encrypted_msg, key)
print(decrypted_flag)

简单的RSA+MD5处理flag

from Crypto.Util.number import getPrime
from gmpy2 import invert, gcd
import hashlib

# 已知的公钥
N =
e =
# 使用 N 来尝试分解成 p 和 q
p=
q=

# 计算 phi——逆元
phi = (p - 1) * (q - 1)

# 计算私钥 d
d = invert(e, phi)

# 已知的密文 c
c =

# 解密
m_decrypted = pow(c, d, N)

md5 = hashlib.md5()
md5.update(str(m_decrypted).encode('utf-8'))

# 生成 flag
flag =md5.hexdigest()
print(flag)

使用z3求解

from z3 import *

# 创建 Z3 Solver
solver = Solver()

# 创建变量，如果进行位操作的话，需要使用 BitVec 类型
v13 = BitVec('v13', 64)  # 64 位
v14 = BitVec('v14', 64)
v15 = BitVec('v15', 64)

# 添加条件
solver.add()
solver.add()
solver.add()

# 求解
if solver.check() == sat:
    model = solver.model()
    v13_val = model[v13].as_long()
    v14_val = model[v14].as_long()
    v15_val = model[v15].as_long()

    # 打印结果
    print(f"Found values: v13 = {v13_val:#x}, v14 = {v14_val:#x}, v15 = {v15_val:#x}")

pwn计算的小脚本

不知道怎么修改，之间照搬过来吧，跑完就可以直接读取 flag 了

from pwn import *
import string

context.log_level = 'debug'

p = remote('47.97.58.52', 40010) #环境地址，端口

def send_after_clean(content: bytes = b"", until: bytes = None,
                     timeout: float = 0.05, no_show: bool = True):
    if until is not None:
        p.recvuntil(flat(until))
    else:
        received = p.clean(timeout)
        if not no_show:
            print(f"[$]received:\n{received.decode('UTF-8')}")
    p.send(flat(content))

def sendline_after_clean(content: bytes = b"", until: bytes = None,
                         timeout: float = 0.05, no_show: bool = True):
    send_after_clean([content, p.newline], until, timeout, no_show)

def interactive_after_clean(timeout: int = 0.05, no_show: bool = True):
    received = p.clean(timeout)
    if not no_show:
        print(f"[$]received:\n{received}")
    p.interactive()

def formula_compute(formula: bytes, precise: bool = False):
    if isinstance(formula, bytes):
        formula = formula.decode("UTF-8")
    formula = formula.strip()
    formula = formula.strip("\n")
    formula = formula.replace("x", "*")
    formula = formula.replace("^", "**")
    formula = formula.replace("÷", "/")
    if not precise:
        formula = formula.replace("//", "/")
        formula = formula.replace("/", "//")
    return bytes(str(eval(formula)), encoding="UTF-8")

p.recvuntil(b'Welcome to the calc game!\n')  #p.sendlineafter(some_string, payload) 接收到 some_string 后, 发送你的 payload，加个换行
for i in range(100):
	p.recvline(keepends=True)
	#p.recvuntil(b' ',drop=True) #p.recvuntil(some_string) 接收到 some_string 为止
	s=p.recvuntil(b' =',drop=True)
	#p.recvall()
	print(s)
	res=str(eval(s)).encode()
	p.sendlineafter(b" ", res)
	p.recvline() #p.recvline() 接收一行输出

p.interactive() #交互模式

忘记哪个是真的能用的了，等下次跑出来再改吧

# 自动生成头部
from pwn import *
from pwn import p64, p32, u32, u64, p8, p16

if_32: bool = False
if_debug: bool = False
pg = p32 if if_32 else p64
ug = u32 if if_32 else u64
context(log_level="debug", arch="i386" if if_32 else "amd64", os="linux")
p=remote("47.97.58.52",40010)

# 下面是自定义的一些工具函数

def send_after_clean(content: bytes = b"", until: bytes = None,
                     timeout: float = 0.05, no_show: bool = True):
    if until is not None:
        p.recvuntil(flat(until))
    else:
        received = p.clean(timeout)
        if not no_show:
            print(f"[$]received:\n{received.decode('UTF-8')}")
    p.send(flat(content))

def sendline_after_clean(content: bytes = b"", until: bytes = None,
                         timeout: float = 0.05, no_show: bool = True):
    send_after_clean([content, p.newline], until, timeout, no_show)

def interactive_after_clean(timeout: int = 0.05, no_show: bool = True):
    received = p.clean(timeout)
    if not no_show:
        print(f"[$]received:\n{received}")
    p.interactive()

def formula_compute(formula: bytes, precise: bool = False):
    if isinstance(formula, bytes):
        formula = formula.decode("UTF-8")
    formula = formula.strip()
    formula = formula.strip("\n")
    formula = formula.replace("x", "*")
    formula = formula.replace("^", "**")
    formula = formula.replace("÷", "/")
    if not precise:
        formula = formula.replace("//", "/")
        formula = formula.replace("/", "//")
    return bytes(str(eval(formula)), encoding="UTF-8")

for i in range(100):
    # 从标准输出流获取题目
    # 会一直读到b"."为止
    question = p.recvuntil(b".")
    # 工具函数自动计算结果
    # 注意，输入的题目必须是有意义的算式，不能有等号
    # 比如可以是1+2, 1÷2
    # 如果需要小数，定义参数precise=True
    answer = formula_compute(question)
    # 在结尾加上回车发送answer
    # 直到读到"answer:"才开始发送
    # 也可以不定义until字符串，脚本会在程序没有输出的时候发送（但如果网络不好，脚本可能判断出错）
    sendline_after_clean(answer, "answer:")

# 进入人机交互模式
interactive_after_clean()

随机数+奇偶分离

#include <iostream>
#include <array>
#include <string>

int main() {
    // 加密后的数组，用逗号隔开
    std::array<uint64_t, 4> v13 = {
    };

    // 密钥
    uint8_t initialRandom = ;

    // 解密结果字符串
    std::string decrypted;

    // 解密过程
    for (size_t i = 0; i < 30; ++i) {
        uint8_t xorValue;

        // 奇偶选择XOR值
        if (i % 2 == 0) {
            xorValue = initialRandom + 3; // 偶数位置
        } else {
            xorValue = initialRandom; // 奇数位置
        }

        // 对应的加密值
        uint8_t encryptedChar = static_cast<uint8_t>(v13[i / 8] >> ((i % 8) * 8)); // 取得v13的当前字符

        // 解密字符
        uint8_t originalChar = encryptedChar ^ xorValue;

        // 将字符添加到解密字符串
        decrypted += static_cast<char>(originalChar);
    }

    // 输出解密结果
    std::cout << decrypted << std::endl;

    return 0;
}

高低位组合

#include <stdio.h>

void decode(unsigned char *encoded_str, int length) {
    for (int i = 0; i < length; i++) {
        unsigned char high = (encoded_str[i] & 0xF0) >> 4;  // 提取高4位
        unsigned char low = (encoded_str[i] & 0x0F) << 4;   // 提取低4位
        encoded_str[i] = high | low;                        // 组合高位和低位
    }
}

int main() {
    // Encoded data
    unsigned char encdata[] = {

    };

    int length = sizeof(encdata) / sizeof(encdata[0]);

    // Decode the data
    decode(encdata, length);

    // Output the decoded string
    for (int i = 0; i < length; i++) {
        printf("%c", encdata[i]);
    }
    printf("\n");

    return 0;
}

爆破程序

import itertools
import string
import subprocess

# 定义可执行文件的路径
exe_path = ""  # 替换为你程序的路径

# 固定前缀和后缀
prefix = ""
suffix = ""

# 字符集为数字和小写字母
charset = string.ascii_lowercase + string.digits

# 生成自定义输入
def generate_inputs():
    for combo1 in itertools.product(charset, repeat=4):  # 第一个 4 字节部分
        for combo2 in itertools.product(charset, repeat=4):  # 第二个 4 字节部分
            for combo3 in itertools.product(charset, repeat=4):  # 第三个 4 字节部分
                middle = ''.join(combo1) + '-' + ''.join(combo2) + '-' + ''.join(combo3)  # 连接三个部分
                yield prefix + middle + suffix

# 运行程序并传递生成的输入
def run_program_with_input(input_str):
    try:
        process = subprocess.Popen([exe_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        output, error = process.communicate(input=input_str.encode())
        if "Congratulations" in output.decode() or "Correct" in output.decode():  # 替换为程序的正确输出标志
            return True, output.decode()
        return False, output.decode()
    except Exception as e:
        return False, str(e)

# 使用生成器进行爆破
for generated_input in generate_inputs():
    print(f"Trying input: {generated_input}")
    success, result = run_program_with_input(generated_input)

    if success:
        print(f"Success! The correct input is: {generated_input}")
        print(f"Program output: {result}")
        break
    else:
        continue
        #print(f"Failed attempt with input: {generated_input}")
        #print(f"Program output: {result}")

二次剩余+中国剩余定理

2024-0xGame-w1 的 wp 里偷的，以后有需要直接扒过来改改就能用~

多解是正常的，跑久一点也能理解，四个解带进去排除一下就好了

from gmpy2 import invert, gcd, gcdext
Pub_Key = (1022053332886345327, 294200073186305890)
Encrypt_msg = 107033510346108389
m = 759871216848924391
N = Pub_Key[0]
e = Pub_Key[1]
c = Encrypt_msg

#import q、p form factordb
q = 970868179
p = 1052721013
phi = (q-1)*(p-1)

def crt(b,m):
    #判断是否互素
    for i in range(len(m)):
        for j in range(i+1,len(m)):
            if gcd(m[i],m[j]) != 1:
                print("m中含有不是互余的数")
                return -1

    #乘积
    M = 1
    for i in range(len(m)):
        M *= m[i]
    #求M/mi
    Mm = []
    for i in range(len(m)):
        Mm.append(M // m[i])
    #求Mm[i]的乘法逆元
    Mm_ = []
    for i in range(len(m)):
        _,a,_ = gcdext(Mm[i],m[i])
        Mm_.append(int(a % m[i]))
    #求MiM'ibi的累加
    y = 0
    for i in range(len(m)):
        #print(Mm[i] * Mm_[i] * b[i])
        y += (Mm[i] * Mm_[i] * b[i])
    y = y % M
    return y

#直接在Zmod p、q下求m^2 ，也可以在Zmod N下求解m^2后，再⽤因⼦取余:
e0 = e//2
d1 = invert(e0,p-1)
m1 = pow(c,d1,p)
d2 = invert(e0,q-1)
m2 = pow(c,d2,q)

#直接⽤遍历开根：
def Gao(x,p):
    result = []
    for i in range(p):
        if pow(i,2,p) == x:
            result.append(i)
    return result

m1_ = Gao(m1,p)
m2_ = Gao(m2,q)

print(m1_,m2_)

from hashlib import md5
def MD5(m):return md5(str(m).encode()).hexdigest()

m1_ = [215896886, 836824127]
m2_ = [215973055, 754895124]

for m1 in m1_:
    for m2 in m2_:
        print('0xGame{' + MD5(crt([m1,m2],[p,q])) + '}')

'''
 0xGame{15820afdb9a129e89e40e57f40ff8de9}
 0xGame{f4107420d94cc7037114376d8566d4ef}
 0xGame{3932f6728585abbf751a212f69276d3e}
 0xGame{127016d0be858ef48a99723710ad4d49}
'''

2024_SACC_安全组招新

Tsglz — Thu, 17 Oct 2024 00:00:00 GMT

题目链接：https://github.com/tsglz/tsglz.github.io/releases/download/2024-SACC/2024-SACC.rar

密码：2024-SACC

1_just_click

直接 IDA 打开，打开 omg(0) 即为 flag

如果你对 xyz(p) 感到好奇点开看了下，你就会发现进行了一个 异或0x55 的操作，但实际上它并没有实质性的影响

2_another_three_click

打开看一眼，看不懂，拖 IDA

看到 3 个 test_func 函数，合理推断 flag 是三段式，点击进去看看

进入汇编界面，很容易看到三段 flag，一、三两段是明文，第二段需要转换一下

按a即可，将 flag 拼好即可提交

3_MaybeXorAndRot13

打开文件，输出的是数字

然后打开 IDA 进行查看，同样是一串数字，可以看到进行了 异或0x55 的操作，在刚进入 IDA 的时候，其实能直接看到异或之前的内容，如果不确定，可以写个脚本验证一下

python：

a="54 102 57 32 49 29 33 34 55 56 19 51 52 19 108 47 24 2 19 45 13 102 57 59 51 4 104 104"
b=a.split()
c=list(map(int,b))

for i in range(len(c)):
    d = chr(c[i]^0x55)
    print(d,end="")

c：

#include <stdio.h>
int main()
{
    int a[28]= {54,102,57,32,49,29,33,34,55,56,19,51,52,19,108,47,24,2,19,45,13,102,57,59,51,4,104,104};
    for (int i = 0; i < 28; i++)
    {
        printf("%c", a[i]^0x55);
    }
    return 0;
}

解出来是一样的，熟练的一眼 base64

c3ludHtwbmFfaF9zMWFxX3lnfQ==

得到如下内容，很明显这还不是最终的 flag，根据提示，还用到了 Rot13

synt{pna_h_s1aq_yg}

解密可得

flag{can_u_f1nd_lt}

4_in_string

这道题特别 ez，一打开就能看到一个半成品的 flag，提示中给的 in_string 只是提供一个快速查找有用信息的方法

string位置：View >> Open subviews >> string

flag{RighT t0 g3t f1Ag}

如果直接提交 flag，会发现 flag 是错误的，

打开 main 函数，刚才看到的 flag 就在 text_57 里面

接着在 change 函数中会看到替换的步骤，32 >> 95，熟练的知道是 '_'替换了 ' '

如果不清楚可以查 ascii 码表，在汇编中也能应证

给半成品 flag 补上下划线即可

5_oh_upx

不了解的可能会有点难受，upx 壳是常用压缩壳，这里使用的是未经魔改的版本，只需要去网上下一个就好

如果不脱壳，IDA 看到的代码就是乱七八糟的一坨，但其实不影响运行

首先进行脱壳 upx -d 即可，不清楚使用方法可以浏览器查一下，非常清楚

然后使用 IDA 打开，在下方直接能看到两段 flag ，根据提示，flag 一共有三段

在 main 函数中直接能找到中间缺失的一段，拼起来即可

6_inline_assembly

这道题用到了内联汇编，这会一定程度上阻碍静态分析，但这里我并没有做过多的处理，所以可以直接在 String 里找到

如果对 Windows 比较熟悉会知道，这段程序是 32 位的，不知道也没关系，DIE 可以进行分析

用 32位 DIE 打开

打开 String，直接能看到 flag flag{May23_th1s_1s_the_flag}

hexo博客搭建

Tsglz — Mon, 15 Apr 2024 00:00:00 GMT

搭建个人博客使用：Github + Hexo

如果有条件，可以部署在自己的服务器上，发布到自己服务器的话，Negix 代理

一、前置条件

Github 账号
- 都能搭建个人博客了肯定会用 Github 吧~
NodeJS
- nodejs 要好好配置哦，不然之后会很崩溃的，嘻
- 可以参考下这个NodeJS安装及配置(Windows)
Git，(理论上cmd也是可以的，我就是用的cmd)

二、Github部分

新建一个仓库

按要求填写

测试一下是否能正常使用
- 在新仓库中添加 index.html
- 保存

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>tsglz</title>
  </head>
  <body>
    <h1>This is tsglz</h1>
  </body>
</html>

在 settings 的 page 中可以访问到自己的网站
- 如果显示正常，即部署成功，可以进行下一步
- 如果不成功，自查上面的步骤是否出现遗漏

Token

除了一个仓库，你还需要一个 Token

注意使用 classic 哦~
select 一个 repo 就能用了
expiration 按照需要配置
- 并不建议一直用一个

三、Hexo部分

1.安装hexo

npm install -g hexo-cli

查看版本

hexo -v

出现版本号
- 有一大串是正常情况，请不要感到害怕

2.创建 hexo-blog

创建一个项目 hexo-blog 并初始化

hexo init hexo-blog
cd hexo-blog
npm install

更换主题

Release 1.9.7 · fluid-dev/hexo-theme-fluid (github.com)

下载解压到 themes 目录，并将解压出的文件夹重命名为 fluid。
- 注意，fluid目录下应该直接是多个文件
- 如果存在多余的文件夹，请移出内部文件后删除它
修改根目录下的 _config.yml：

创建「关于页」

首次使用主题的「关于页」需要手动创建：

hexo new page about

创建成功后，编辑博客目录下 /source/about/index.md，添加 layout 属性。

---
title: about
date: xxxxxx
layout: about
---

注意冒号后面有空格，否则会报错

关于移动 hexo-blog 的补充说明

一般来说全局状态下的 hexo-blog 会出现在 C:\Windows\System32 中
但对于一些 C盘看上去不太友好（快爆炸）的人来说（比如我），还是更希望把它移到别的地方去

C:\Windows\System32\hexo-blog找到那个文件夹
把它剪切到你希望它出现的位置
- 这个时候使用 cd hexo-blog 大概率是不成功的
- 为了让我们更好的使用它，可以配置一下环境变量（如果你连环境变量在哪里或者是什么都不知道的话，问问万能的Google吧）
把你的路径塞到 path 里

3.启动！

先在本地运行下

hexo g
hexo server

如果启动不了，请使用 管理员模式 进行尝试

4.创建文章

根目录下 _config.yml
- 在生成文章的时候生成一个同名的资源目录用于存放图片文件

post_asset_folder: true

插入图片
- 这种方法在 md 编辑器里看不到图片，但在博客里是可以看到的
- 更多方法参考官方文档（最下面会给的，别急）

![图片引用方法二](test.png)

想要使图片显示出来，需要装一个依赖
- 它可以帮你更好地对路径进行转换

npm install https://github.com/CodeFalling/hexo-asset-image --save

四、fluid 部分

覆盖配置

配置指南 | Hexo Fluid 用户手册 (fluid-dev.com)

好东西就要狠狠学习
建议马上配置好

1.申请LeanCloud账号并创建应用

开发者信息 · 账号 · LeanCloud

注册一下
- 如果可以请使用国际版，不然你的浏览量是看不到的
  - 国际版的使用可能需要一些特殊的小技巧
- 笔者在测试过程中发现评论功能国际版有些问题（笔者是不会承认自己是菜鸡的QAQ）
  - 个人建议两个都注册下（以防万一）
验证邮箱
创建应用
- 开发版就够了

设置->应用凭证，找到 AppID 和 AppKey
- 留着等下用

2. 来个记录浏览数的功能吧

配置一下 app_id 和 app_key
顺手把底部的也解决一下吧

打开计数功能，统计来源改为 leancloud

注：统计的功能或许也需要一些特殊的小技巧，当你看不到眼睛和浏览次数的时候，请不用太过着急
- 以下是示例
- 如果你能看到它，恭喜你，你成功了~

3.在来个评论的功能吧

先这样

再这样

评论的查看在 leancloud 的 数据存储 >> 结构化数据 >> Comment 里
- 删除也在这里，不要因为测试输入的乱码删不掉而苦恼：)

五、一些使用技巧

快速导航

- 清除缓存：hexo clean
- 生成：hexo g
- 部署到远端：hexo d
- 在自己的主机上部署：hexo s
- 创建文章：hexo new post $文章名$
- 图片插入方法一：{% asset_img test.png 图片引用方法一 %}
- 图片插入方法二：![图片引用方法二](test.png)

关于多级分类

父子分类

categories:
- 一级
- 二级

同级分类

categories:
- [一级,二级,二级中的1]
- [一级,二级,二级中的2]

此时该文章同时处于 一级-二级 下的 1和2 中

参考文章

hexo

GitHub Pages + Hexo搭建个人博客网站，史上最全教程_hexo博客-CSDN博客

fluid

https://hexo.fluid-dev.com/docs/guide/
Front-matter | Hexo

valine

快速开始 | Valine 一款快速、简洁且高效的无后端评论系统。

如有遗漏，欢迎补充：）

Tsglz's blog

阅读笔记（不定期更新中）

自然科学

人文学科

哲学-哲学史

哲学-哲学入门

社会科学

教育/个人成长

心理学-司法心理学

社会学-人际关系

商业/管理/创业

文学艺术

电影研究

综合/跨学科

神秘学

科学哲学/科学史

《牛津通识读本：司法心理学》读后感

低价值资产不等于只需要简单防护

《你的第一本哲学书》读后感

《哲学家们都干了什么》读后感

使用 yt-dlp 从 Youtube 下载音频记录

博客后续更新说明

XMRig系列挖矿木马分析与yara检测（一）

VirusTotal-yara 规则学习（一）

大模型辅助 Bilibili 视频内容概览（二）

大模型辅助 Bilibili 视频内容概览（一）

2025.11.16-ai总结

美股加密金库热潮分析

现象概述

套利机制

内在矛盾

变现困境

法律争议案例

Mango Markets套现事件

FTX崩塌与魔法豆陷阱

投资者建议

DeFi行业SEC政策转变与未来发展趋势分析

SEC政策转向的影响

DeFi的独特优势

DeFi行业规模与结构

技术演进中的挑战

机遇与风险

竞争格局与未来趋势

健康发展所需机制

2025.11.10-ai总结

2025.11.9 19点场分析总结

一、全球市场风险与港股影响

二、技术分析流派与应用

三、REITs（房地产投资信托基金）分析与风险

四、公司特定分析

五、投资哲学与建议

六、市场制度批评

七、其他话题

擒龙先生-11.9-下周动向

一、投资要点

二、投机风向

三、操作建议

Kill Chain 模型

对TEMPEST代码的研究（一）

基础架构

服务器-anvil

客户端-conduit

植入物

differences

ppid 伪造(一)

使用环节

伪造方法

测试结果

权限问题

对抗检测

Part_Two_A_Minimal_Rust_Kernel

目的

新增 FlowOS.json

build-std 特性

build-std-features

向屏幕打印字符

启动内核

创建引导映像

将内核和引导程序组合

安装 llvm-tools-preview

新增 `FlowOS.json`

使用 `cargo run`